gtk2_ardour/ardour_ui.h

   1 /*
   2     Copyright (C) 1999-2002 Paul Davis
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18 */
  19
  20 #ifndef __ardour_gui_h__
  21 #define __ardour_gui_h__
  22
  23 #include <time.h>
  24
  25 /* need _BSD_SOURCE to get timersub macros */
  26
  27 #ifdef _BSD_SOURCE
  28 #include <sys/time.h>
  29 #else
  30 #define _BSD_SOURCE
  31 #include <sys/time.h>
  32 #undef _BSD_SOURCE
  33 #endif
  34
  35 #include <list>
  36 #include <cmath>
  37
  38
  39 #include "pbd/xml++.h"
  40 #include "pbd/controllable.h"
  41 #include <gtkmm/box.h>
  42 #include <gtkmm/frame.h>
  43 #include <gtkmm/label.h>
  44 #include <gtkmm/table.h>
  45 #include <gtkmm/fixed.h>
  46 #include <gtkmm/drawingarea.h>
  47 #include <gtkmm/eventbox.h>
  48 #include <gtkmm/menu.h>
  49 #include <gtkmm/menuitem.h>
  50 #include <gtkmm/button.h>
  51 #include <gtkmm/togglebutton.h>
  52 #include <gtkmm/treeview.h>
  53 #include <gtkmm/menubar.h>
  54 #include <gtkmm/textbuffer.h>
  55 #include <gtkmm/adjustment.h>
  56
  57 #include "gtkmm2ext/gtk_ui.h"
  58 #include "gtkmm2ext/click_box.h"
  59 #include "gtkmm2ext/stateful_button.h"
  60 #include "gtkmm2ext/bindable_button.h"
  61 #include "gtkmm2ext/bindings.h"
  62 #include "gtkmm2ext/visibility_tracker.h"
  63
  64 #include "ardour/ardour.h"
  65 #include "ardour/types.h"
  66 #include "ardour/utils.h"
  67 #include "ardour/plugin.h"
  68 #include "ardour/session_handle.h"
  69 #include "ardour/system_exec.h"
  70
  71 #include "video_timeline.h"
  72
  73 #include "add_route_dialog.h"
  74 #include "ardour_button.h"
  75 #include "ardour_dialog.h"
  76 #include "ardour_spacer.h"
  77 #include "ardour_window.h"
  78 #include "editing.h"
  79 #include "enums.h"
  80 #include "mini_timeline.h"
  81 #include "shuttle_control.h"
  82 #include "visibility_group.h"
  83 #include "window_manager.h"
  84
  85 #ifdef COMPILER_MSVC
  86 #include "about.h"
  87 #include "add_video_dialog.h"
  88 #include "big_clock_window.h"
  89 #include "bundle_manager.h"
  90 #include "engine_dialog.h"
  91 #include "export_video_dialog.h"
  92 #include "global_port_matrix.h"
  93 #include "keyeditor.h"
  94 #include "location_ui.h"
  95 #include "lua_script_manager.h"
  96 #include "rc_option_editor.h"
  97 #include "route_dialogs.h"
  98 #include "route_params_ui.h"
  99 #include "session_option_editor.h"
 100 #include "speaker_dialog.h"
 101 #else
 102 class About;
 103 class AddRouteDialog;
 104 class AddVideoDialog;
 105 class BigClockWindow;
 106 class BundleManager;
 107 class EngineControl;
 108 class ExportVideoDialog;
 109 class KeyEditor;
 110 class LocationUIWindow;
 111 class LuaScriptManager;
 112 class RCOptionEditor;
 113 class RouteParams_UI;
 114 class SessionOptionEditor;
 115 class SpeakerDialog;
 116 class GlobalPortMatrixWindow;
 117 #endif
 118
 119 class VideoTimeLine;
 120 class ArdourKeyboard;
 121 class ArdourVSpacer;
 122 class AudioClock;
 123 class ButtonJoiner;
 124 class ConnectionEditor;
 125 class DuplicateRouteDialog;
 126 class MainClock;
 127 class Mixer_UI;
 128 class ArdourPrompter;
 129 class PublicEditor;
 130 class SaveAsDialog;
 131 class SessionDialog;
 132 class SessionOptionEditorWindow;
 133 class Splash;
 134 class TimeInfoBox;
 135 class Meterbridge;
 136 class LuaWindow;
 137 class MidiTracer;
 138 class NSM_Client;
 139 class LevelMeterHBox;
 140 class GUIObjectState;
 141
 142 namespace ARDOUR {
 143         class ControlProtocolInfo;
 144         class IO;
 145         class Port;
 146         class Route;
 147         class RouteGroup;
 148         class Location;
 149         class ProcessThread;
 150 }
 151
 152 namespace Gtk {
 153         class ProgressBar;
 154 }
 155
 156 namespace Gtkmm2ext {
 157         class Tabbable;
 158 }
 159
 160 class ARDOUR_UI : public Gtkmm2ext::UI, public ARDOUR::SessionHandlePtr
 161 {
 162 public:
 163         ARDOUR_UI (int *argcp, char **argvp[], const char* localedir);
 164         ~ARDOUR_UI();
 165
 166         bool run_startup (bool should_be_new, std::string load_template);
 167
 168         void show_splash ();
 169         void hide_splash ();
 170
 171         void launch_chat ();
 172         void launch_manual ();
 173         void launch_reference ();
 174         void launch_tracker ();
 175         void launch_subscribe ();
 176         void launch_cheat_sheet ();
 177         void launch_website ();
 178         void launch_website_dev ();
 179         void launch_forums ();
 180         void launch_howto_report ();
 181         void show_about ();
 182         void hide_about ();
 183
 184         void load_from_application_api (const std::string& path);
 185         void finish();
 186
 187         int load_session (const std::string& path, const std::string& snapshot, std::string mix_template = std::string());
 188         bool session_loaded;
 189         int build_session (const std::string& path, const std::string& snapshot, ARDOUR::BusProfile&);
 190         bool session_is_new() const { return _session_is_new; }
 191
 192         ARDOUR::Session* the_session() { return _session; }
 193
 194         bool get_smart_mode () const;
 195
 196         int get_session_parameters (bool quit_on_cancel, bool should_be_new = false, std::string load_template = "");
 197         int  build_session_from_dialog (SessionDialog&, const std::string& session_name, const std::string& session_path);
 198         bool ask_about_loading_existing_session (const std::string& session_path);
 199
 200         /// @return true if session was successfully unloaded.
 201         int unload_session (bool hide_stuff = false);
 202         void close_session();
 203
 204         int  save_state_canfail (std::string state_name = "", bool switch_to_it = false);
 205         void save_state (const std::string & state_name = "", bool switch_to_it = false);
 206
 207         static ARDOUR_UI *instance () { return theArdourUI; }
 208
 209         /* signal emitted when escape key is pressed. All UI components that
 210            need to respond to Escape in some way (e.g. break drag, clear
 211            selection, etc) should connect to and handle this.
 212         */
 213         PBD::Signal0<void> Escape;
 214
 215         PublicEditor&     the_editor() { return *editor;}
 216         Mixer_UI* the_mixer() { return mixer; }
 217
 218         void new_midi_tracer_window ();
 219         void toggle_editing_space();
 220         void toggle_mixer_space();
 221         void toggle_mixer_list();
 222         void toggle_monitor_section_visibility ();
 223         void toggle_keep_tearoffs();
 224
 225         void reset_focus (Gtk::Widget*);
 226
 227         static PublicEditor* _instance;
 228
 229         /** Emitted frequently with the audible frame, false, and the edit point as
 230          *  parameters respectively.
 231          *
 232          *  (either RapidScreenUpdate || SuperRapidScreenUpdate - user-config)
 233          */
 234         static sigc::signal<void, framepos_t, bool, framepos_t> Clock;
 235
 236         static void close_all_dialogs () { CloseAllDialogs(); }
 237         static sigc::signal<void> CloseAllDialogs;
 238
 239         XMLNode* main_window_settings() const;
 240         XMLNode* editor_settings() const;
 241         XMLNode* preferences_settings() const;
 242         XMLNode* mixer_settings () const;
 243         XMLNode* keyboard_settings () const;
 244         XMLNode* tearoff_settings (const char*) const;
 245
 246         void save_ardour_state ();
 247         gboolean configure_handler (GdkEventConfigure* conf);
 248
 249         void halt_on_xrun_message ();
 250         void xrun_handler (framepos_t);
 251         void create_xrun_marker (framepos_t);
 252
 253         GUIObjectState* gui_object_state;
 254
 255         MainClock* primary_clock;
 256         MainClock* secondary_clock;
 257         void focus_on_clock ();
 258         AudioClock*   big_clock;
 259
 260         VideoTimeLine *video_timeline;
 261
 262         void store_clock_modes ();
 263         void restore_clock_modes ();
 264         void reset_main_clocks ();
 265
 266         void synchronize_sync_source_and_video_pullup ();
 267
 268         void add_route ();
 269         void add_route_dialog_finished (int);
 270
 271         void add_routes_part_two ();
 272         void add_routes_thread ();
 273
 274         void start_duplicate_routes ();
 275
 276         void add_video (Gtk::Window* float_window);
 277         void remove_video ();
 278         void start_video_server_menu (Gtk::Window* float_window);
 279         bool start_video_server (Gtk::Window* float_window, bool popup_msg);
 280         void stop_video_server (bool ask_confirm=false);
 281         void flush_videotimeline_cache (bool localcacheonly=false);
 282         void export_video (bool range = false);
 283
 284         void session_add_vca (std::string const &, uint32_t);
 285
 286         void session_add_audio_route (bool, int32_t, int32_t, ARDOUR::TrackMode, ARDOUR::RouteGroup *, uint32_t, std::string const &, bool, ARDOUR::PresentationInfo::order_t order);
 287         void session_add_audio_track (
 288                 int input_channels,
 289                 int32_t output_channels,
 290                 ARDOUR::TrackMode mode,
 291                 ARDOUR::RouteGroup* route_group,
 292                 uint32_t how_many,
 293                 std::string const & name_template,
 294                 bool strict_io,
 295                 ARDOUR::PresentationInfo::order_t order
 296                 ) {
 297                 session_add_audio_route (true, input_channels, output_channels, mode, route_group, how_many, name_template, strict_io, order);
 298         }
 299
 300         void session_add_audio_bus (
 301                         int input_channels,
 302                         int32_t output_channels,
 303                         ARDOUR::RouteGroup* route_group,
 304                         uint32_t how_many,
 305                         std::string const & name_template,
 306                         bool strict_io,
 307                         ARDOUR::PresentationInfo::order_t order
 308                         ) {
 309                 session_add_audio_route (false, input_channels, output_channels, ARDOUR::Normal, route_group, how_many, name_template, strict_io, order);
 310         }
 311
 312         void session_add_midi_track (
 313                         ARDOUR::RouteGroup* route_group,
 314                         uint32_t how_many,
 315                         std::string const & name_template,
 316                         bool strict_io,
 317                         ARDOUR::PluginInfoPtr instrument,
 318                         ARDOUR::Plugin::PresetRecord* preset,
 319                         ARDOUR::PresentationInfo::order_t order
 320                 ) {
 321                 session_add_midi_route (true, route_group, how_many, name_template, strict_io, instrument, preset, order);
 322         }
 323
 324         void session_add_mixed_track (const ARDOUR::ChanCount&, const ARDOUR::ChanCount&, ARDOUR::RouteGroup*, uint32_t, std::string const &, bool,
 325                                       ARDOUR::PluginInfoPtr, ARDOUR::Plugin::PresetRecord* pset,
 326                                       ARDOUR::PresentationInfo::order_t order);
 327         void session_add_midi_bus (ARDOUR::RouteGroup*, uint32_t, std::string const &, bool, ARDOUR::PluginInfoPtr, ARDOUR::Plugin::PresetRecord* pset,
 328                                    ARDOUR::PresentationInfo::order_t order);
 329         void session_add_midi_route (bool, ARDOUR::RouteGroup *, uint32_t, std::string const &, bool,
 330                                      ARDOUR::PluginInfoPtr, ARDOUR::Plugin::PresetRecord*,
 331                                      ARDOUR::PresentationInfo::order_t order);
 332         void display_insufficient_ports_message ();
 333
 334         void attach_to_engine ();
 335         void post_engine ();
 336
 337         gint exit_on_main_window_close (GdkEventAny *);
 338
 339         void maximise_editing_space ();
 340         void restore_editing_space ();
 341
 342         void show_ui_prefs ();
 343
 344         bool check_audioengine(Gtk::Window&);
 345
 346         void setup_profile ();
 347         void setup_tooltips ();
 348
 349         void set_shuttle_fract (double);
 350
 351         void get_process_buffers ();
 352         void drop_process_buffers ();
 353
 354         void reset_peak_display ();
 355         void reset_route_peak_display (ARDOUR::Route*);
 356         void reset_group_peak_display (ARDOUR::RouteGroup*);
 357
 358         const std::string& announce_string() const { return _announce_string; }
 359
 360         void hide_application ();
 361
 362         Gtk::Notebook& tabs();
 363         Gtk::Window& main_window () { return _main_window; }
 364
 365         void setup_toplevel_window (Gtk::Window&, const std::string& name, void* owner);
 366
 367         /* called from a static C function */
 368
 369         GtkNotebook* tab_window_root_drop (GtkNotebook* src,
 370                                            GtkWidget* w,
 371                                            gint x,
 372                                            gint y,
 373                                            gpointer user_data);
 374
 375         bool tabbed_window_state_event_handler (GdkEventWindowState*, void* object);
 376         bool key_event_handler (GdkEventKey*, Gtk::Window* window);
 377
 378         Gtkmm2ext::ActionMap global_actions;
 379
 380         ARDOUR::PresentationInfo::order_t translate_order (RouteDialogs::InsertAt);
 381
 382 protected:
 383         friend class PublicEditor;
 384
 385         void toggle_auto_play ();
 386         void toggle_auto_input ();
 387         void toggle_punch ();
 388         void unset_dual_punch ();
 389         bool ignore_dual_punch;
 390         void toggle_punch_in ();
 391         void toggle_punch_out ();
 392         void toggle_session_monitoring_in ();
 393         void toggle_session_monitoring_disk ();
 394         void show_loop_punch_ruler_and_disallow_hide ();
 395         void reenable_hide_loop_punch_ruler_if_appropriate ();
 396         void toggle_auto_return ();
 397         void toggle_click ();
 398         void toggle_audio_midi_setup ();
 399         void toggle_session_auto_loop ();
 400         void toggle_rc_options_window ();
 401         void toggle_session_options_window ();
 402
 403 private:
 404         Gtk::Window   _main_window;
 405         Gtkmm2ext::VisibilityTracker* main_window_visibility;
 406         Gtk::VBox      main_vpacker;
 407         Gtk::HBox      status_bar_hpacker;
 408         Gtk::Notebook _tabs;
 409         PublicEditor*  editor;
 410         Mixer_UI*      mixer;
 411         Gtk::Tooltips _tooltips;
 412         NSM_Client*    nsm;
 413         bool          _was_dirty;
 414         bool          _mixer_on_top;
 415         bool          _initial_verbose_plugin_scan;
 416         bool           first_time_engine_run;
 417
 418         void show_tabbable (Gtkmm2ext::Tabbable*);
 419         void hide_tabbable (Gtkmm2ext::Tabbable*);
 420         void detach_tabbable (Gtkmm2ext::Tabbable*);
 421         void attach_tabbable (Gtkmm2ext::Tabbable*);
 422         void button_change_tabbable_visibility (Gtkmm2ext::Tabbable*);
 423         void key_change_tabbable_visibility (Gtkmm2ext::Tabbable*);
 424         void toggle_editor_and_mixer ();
 425
 426         void tabbable_state_change (Gtkmm2ext::Tabbable&);
 427
 428         void toggle_meterbridge ();
 429         void toggle_luawindow ();
 430
 431         int  setup_windows ();
 432         void setup_transport ();
 433         void setup_clock ();
 434
 435         static ARDOUR_UI *theArdourUI;
 436         SessionDialog *_session_dialog;
 437
 438         int starting ();
 439
 440         int  ask_about_saving_session (const std::vector<std::string>& actions);
 441
 442         void save_session_at_its_request (std::string);
 443         /* periodic safety backup, to be precise */
 444         gint autosave_session();
 445         void update_autosave();
 446         sigc::connection _autosave_connection;
 447
 448         void session_dirty_changed ();
 449         void update_title ();
 450
 451         void map_transport_state ();
 452         int32_t do_engine_start ();
 453
 454         void engine_halted (const char* reason, bool free_reason);
 455         void engine_stopped ();
 456         void engine_running ();
 457
 458         void use_config ();
 459
 460         void about_signal_response(int response);
 461
 462         Gtk::VBox     top_packer;
 463
 464         sigc::connection clock_signal_connection;
 465         void         update_clocks ();
 466         void         start_clocking ();
 467         void         stop_clocking ();
 468
 469         void update_transport_clocks (framepos_t pos);
 470         void record_state_changed ();
 471
 472         std::list<MidiTracer*> _midi_tracer_windows;
 473
 474         /* Transport Control */
 475
 476         Gtk::Table               transport_table;
 477         Gtk::Frame               transport_frame;
 478         Gtk::HBox                transport_hbox;
 479
 480         ArdourVSpacer *secondary_clock_spacer;
 481         void repack_transport_hbox ();
 482         void update_clock_visibility ();
 483
 484         struct TransportControllable : public PBD::Controllable {
 485             enum ToggleType {
 486                     Roll = 0,
 487                     Stop,
 488                     RecordEnable,
 489                     GotoStart,
 490                     GotoEnd,
 491                     AutoLoop,
 492                     PlaySelection,
 493             };
 494
 495             TransportControllable (std::string name, ARDOUR_UI&, ToggleType);
 496             void set_value (double, PBD::Controllable::GroupControlDisposition group_override);
 497             double get_value (void) const;
 498
 499             ARDOUR_UI& ui;
 500             ToggleType type;
 501         };
 502
 503         boost::shared_ptr<TransportControllable> roll_controllable;
 504         boost::shared_ptr<TransportControllable> stop_controllable;
 505         boost::shared_ptr<TransportControllable> goto_start_controllable;
 506         boost::shared_ptr<TransportControllable> goto_end_controllable;
 507         boost::shared_ptr<TransportControllable> auto_loop_controllable;
 508         boost::shared_ptr<TransportControllable> play_selection_controllable;
 509         boost::shared_ptr<TransportControllable> rec_controllable;
 510
 511         void toggle_follow_edits ();
 512
 513         void set_transport_controllable_state (const XMLNode&);
 514         XMLNode& get_transport_controllable_state ();
 515
 516         ArdourButton roll_button;
 517         ArdourButton stop_button;
 518         ArdourButton goto_start_button;
 519         ArdourButton goto_end_button;
 520         ArdourButton auto_loop_button;
 521         ArdourButton play_selection_button;
 522         ArdourButton rec_button;
 523         ArdourButton punch_in_button;
 524         ArdourButton punch_out_button;
 525         ArdourButton layered_button;
 526
 527         ArdourVSpacer recpunch_spacer;
 528         ArdourVSpacer monitoring_spacer;
 529
 530         ArdourButton monitor_in_button;
 531         ArdourButton monitor_disk_button;
 532         ArdourButton auto_input_button;
 533
 534         Gtk::Label   punch_label;
 535         Gtk::Label   layered_label;
 536
 537         Gtk::Label   punch_space;
 538         Gtk::Label   mon_space;
 539
 540         void toggle_external_sync ();
 541         void toggle_time_master ();
 542         void toggle_video_sync ();
 543
 544         ShuttleControl shuttle_box;
 545         MiniTimeline   mini_timeline;
 546         TimeInfoBox   *time_info_box;
 547
 548         ArdourButton auto_return_button;
 549         ArdourButton follow_edits_button;
 550         ArdourButton click_button;
 551         ArdourButton sync_button;
 552
 553         ArdourButton auditioning_alert_button;
 554         ArdourButton solo_alert_button;
 555         ArdourButton feedback_alert_button;
 556         ArdourButton error_alert_button;
 557
 558         ArdourButton action_script_call_btn[10];
 559         Gtk::Table action_script_table;
 560
 561         Gtk::VBox alert_box;
 562         Gtk::VBox meter_box;
 563         LevelMeterHBox * editor_meter;
 564         float            editor_meter_max_peak;
 565         ArdourButton     editor_meter_peak_display;
 566         bool             editor_meter_peak_button_release (GdkEventButton*);
 567
 568         void blink_handler (bool);
 569         sigc::connection blink_connection;
 570
 571         void cancel_solo ();
 572         void solo_blink (bool);
 573         void sync_blink (bool);
 574         void audition_blink (bool);
 575         void feedback_blink (bool);
 576         void error_blink (bool);
 577
 578         void set_flat_buttons();
 579
 580         void soloing_changed (bool);
 581         void auditioning_changed (bool);
 582         void _auditioning_changed (bool);
 583
 584         bool solo_alert_press (GdkEventButton* ev);
 585         void audition_alert_clicked ();
 586         bool error_alert_press (GdkEventButton *);
 587
 588         void layered_button_clicked ();
 589
 590         void big_clock_value_changed ();
 591         void primary_clock_value_changed ();
 592         void secondary_clock_value_changed ();
 593
 594         /* called by Blink signal */
 595
 596         void transport_rec_enable_blink (bool onoff);
 597
 598         Gtk::Menu*        session_popup_menu;
 599
 600         /* menu bar and associated stuff */
 601
 602         Gtk::MenuBar* menu_bar;
 603         Gtk::EventBox menu_bar_base;
 604         Gtk::HBox     menu_hbox;
 605
 606         void use_menubar_as_top_menubar ();
 607         void build_menu_bar ();
 608
 609         Gtk::Label   wall_clock_label;
 610         gint update_wall_clock ();
 611
 612         Gtk::Label   disk_space_label;
 613         void update_disk_space ();
 614
 615         Gtk::Label   timecode_format_label;
 616         void update_timecode_format ();
 617
 618         Gtk::Label   cpu_load_label;
 619         void update_cpu_load ();
 620
 621         Gtk::Label   xrun_label;
 622         void update_xrun_count ();
 623
 624         Gtk::Label   peak_thread_work_label;
 625         void update_peak_thread_work ();
 626
 627         Gtk::Label   buffer_load_label;
 628         void update_buffer_load ();
 629
 630         Gtk::Label   sample_rate_label;
 631         void update_sample_rate (ARDOUR::framecnt_t);
 632
 633         Gtk::Label    format_label;
 634         void update_format ();
 635
 636         void every_second ();
 637         void every_point_one_seconds ();
 638         void every_point_zero_something_seconds ();
 639
 640         sigc::connection second_connection;
 641         sigc::connection point_one_second_connection;
 642         sigc::connection point_zero_something_second_connection;
 643         sigc::connection fps_connection;
 644
 645         void set_fps_timeout_connection ();
 646
 647         void open_session ();
 648         void open_recent_session ();
 649         bool process_save_template_prompter (ArdourPrompter& prompter);
 650         void save_template ();
 651
 652         void edit_metadata ();
 653         void import_metadata ();
 654
 655         void set_loop_sensitivity ();
 656         void set_transport_sensitivity (bool);
 657
 658         //stuff for ProTools-style numpad
 659         void transport_numpad_event (int num);
 660         void transport_numpad_decimal ();
 661         bool _numpad_locate_happening;
 662         int _pending_locate_num;
 663         gint transport_numpad_timeout ();
 664         sigc::connection _numpad_timeout_connection;
 665
 666         void transport_goto_nth_marker (int nth);
 667         void transport_goto_zero ();
 668         void transport_goto_start ();
 669         void transport_goto_end ();
 670         void transport_goto_wallclock ();
 671         void transport_stop ();
 672         void transport_record (bool roll);
 673         void transport_roll ();
 674         void transport_play_selection();
 675         void transport_play_preroll();
 676         void transport_rec_preroll();
 677         void transport_rec_count_in();
 678         void transport_forward (int option);
 679         void transport_rewind (int option);
 680         void transport_loop ();
 681         void toggle_roll (bool with_abort, bool roll_out_of_bounded_mode);
 682         bool trx_record_enable_all_tracks ();
 683
 684         bool _session_is_new;
 685         void set_session (ARDOUR::Session *);
 686         void connect_dependents_to_session (ARDOUR::Session *);
 687         void we_have_dependents ();
 688
 689         void setup_session_options ();
 690
 691         guint32  last_key_press_time;
 692
 693         bool process_snapshot_session_prompter (ArdourPrompter& prompter, bool switch_to_it);
 694         void snapshot_session (bool switch_to_it);
 695
 696         void quick_snapshot_session (bool switch_to_it);  //does not promtp for name, just makes a timestamped file
 697
 698         SaveAsDialog* save_as_dialog;
 699
 700         bool save_as_progress_update (float fraction, int64_t cnt, int64_t total, Gtk::Label* label, Gtk::ProgressBar* bar);
 701         void save_session_as ();
 702         void archive_session ();
 703         void rename_session ();
 704
 705         int         create_mixer ();
 706         int         create_editor ();
 707         int         create_meterbridge ();
 708         int         create_luawindow ();
 709         int         create_masters ();
 710
 711         Meterbridge  *meterbridge;
 712         LuaWindow    *luawindow;
 713
 714         /* Dialogs that can be created via new<T> */
 715
 716         RCOptionEditor* rc_option_editor;
 717         Gtk::HBox rc_option_editor_placeholder;
 718
 719         WM::Proxy<SpeakerDialog> speaker_config_window;
 720         WM::Proxy<AddRouteDialog> add_route_dialog;
 721         WM::Proxy<About> about;
 722         WM::Proxy<LocationUIWindow> location_ui;
 723         WM::Proxy<RouteParams_UI> route_params;
 724         WM::Proxy<EngineControl> audio_midi_setup;
 725         WM::Proxy<ExportVideoDialog> export_video_dialog;
 726         WM::Proxy<LuaScriptManager> lua_script_window;
 727
 728         /* Windows/Dialogs that require a creator method */
 729
 730         WM::ProxyWithConstructor<SessionOptionEditor> session_option_editor;
 731         WM::ProxyWithConstructor<AddVideoDialog> add_video_dialog;
 732         WM::ProxyWithConstructor<BundleManager> bundle_manager;
 733         WM::ProxyWithConstructor<BigClockWindow> big_clock_window;
 734         WM::ProxyWithConstructor<GlobalPortMatrixWindow> audio_port_matrix;
 735         WM::ProxyWithConstructor<GlobalPortMatrixWindow> midi_port_matrix;
 736         WM::ProxyWithConstructor<KeyEditor> key_editor;
 737
 738         /* creator methods */
 739
 740         SessionOptionEditor*    create_session_option_editor ();
 741         BundleManager*          create_bundle_manager ();
 742         AddVideoDialog*         create_add_video_dialog ();
 743         BigClockWindow*         create_big_clock_window();
 744         GlobalPortMatrixWindow* create_global_port_matrix (ARDOUR::DataType);
 745         KeyEditor*              create_key_editor ();
 746
 747         ARDOUR::SystemExec *video_server_process;
 748
 749         void handle_locations_change (ARDOUR::Location*);
 750
 751         /* Keyboard Handling */
 752
 753         ArdourKeyboard* keyboard;
 754
 755         /* Keymap handling */
 756
 757         void install_actions ();
 758
 759         void toggle_record_enable (uint16_t);
 760
 761         uint32_t rec_enabled_streams;
 762         void count_recenabled_streams (ARDOUR::Route&);
 763
 764         Splash* splash;
 765
 766         void pop_back_splash (Gtk::Window&);
 767
 768         /* cleanup */
 769
 770         Gtk::MenuItem *cleanup_item;
 771
 772         void display_cleanup_results (ARDOUR::CleanupReport& rep, const gchar* list_title, const bool msg_delete);
 773         void cleanup ();
 774         void cleanup_peakfiles ();
 775         void flush_trash ();
 776
 777         bool have_configure_timeout;
 778         ARDOUR::microseconds_t last_configure_time;
 779         gint configure_timeout ();
 780
 781         ARDOUR::microseconds_t last_peak_grab;
 782         ARDOUR::microseconds_t last_shuttle_request;
 783
 784         bool have_disk_speed_dialog_displayed;
 785         void disk_speed_dialog_gone (int ignored_response, Gtk::MessageDialog*);
 786         void disk_overrun_handler ();
 787         void disk_underrun_handler ();
 788         void gui_idle_handler ();
 789
 790         void cancel_plugin_scan ();
 791         void cancel_plugin_timeout ();
 792         void plugin_scan_dialog (std::string type, std::string plugin, bool);
 793         void plugin_scan_timeout (int);
 794
 795         void session_format_mismatch (std::string, std::string);
 796
 797         void session_dialog (std::string);
 798         int pending_state_dialog ();
 799         int sr_mismatch_dialog (ARDOUR::framecnt_t, ARDOUR::framecnt_t);
 800         void sr_mismatch_message (ARDOUR::framecnt_t, ARDOUR::framecnt_t);
 801
 802         Gtk::MenuItem* jack_disconnect_item;
 803         Gtk::MenuItem* jack_reconnect_item;
 804         Gtk::Menu*     jack_bufsize_menu;
 805
 806         Glib::RefPtr<Gtk::ActionGroup> common_actions;
 807
 808         void editor_realized ();
 809
 810         std::vector<std::string> positional_sync_strings;
 811
 812         void toggle_use_mmc ();
 813         void toggle_send_mmc ();
 814         void toggle_send_mtc ();
 815         void toggle_send_midi_clock ();
 816
 817         void toggle_use_osc ();
 818
 819         void parameter_changed (std::string);
 820         void session_parameter_changed (std::string);
 821
 822         bool first_idle ();
 823
 824         void check_memory_locking ();
 825
 826         void audioengine_setup ();
 827
 828         void display_message (const char *prefix, gint prefix_len,
 829                         Glib::RefPtr<Gtk::TextBuffer::Tag> ptag, Glib::RefPtr<Gtk::TextBuffer::Tag> mtag,
 830                         const char *msg);
 831         Gtk::Label status_bar_label;
 832         bool status_bar_button_press (GdkEventButton*);
 833
 834         void loading_message (const std::string& msg);
 835
 836         PBD::ScopedConnectionList forever_connections;
 837         PBD::ScopedConnection halt_connection;
 838
 839         void step_edit_status_change (bool);
 840
 841         /* these are used only in response to a platform-specific "ShouldQuit" signal */
 842         bool idle_finish ();
 843         void queue_finish ();
 844         void fontconfig_dialog ();
 845
 846         int missing_file (ARDOUR::Session*s, std::string str, ARDOUR::DataType type);
 847         int ambiguous_file (std::string file, std::vector<std::string> hits);
 848
 849         bool click_button_clicked (GdkEventButton *);
 850         bool click_button_scroll (GdkEventScroll *);
 851         bool sync_button_clicked (GdkEventButton *);
 852
 853         VisibilityGroup _status_bar_visibility;
 854
 855         /** A ProcessThread so that we have some thread-local buffers for use by
 856          *  PluginEqGui::impulse_analysis ().
 857          */
 858         ARDOUR::ProcessThread* _process_thread;
 859
 860         void feedback_detected ();
 861
 862         ArdourButton             midi_panic_button;
 863         void                     midi_panic ();
 864
 865         void successful_graph_sort ();
 866         bool _feedback_exists;
 867
 868         enum ArdourLogLevel {
 869                 LogLevelNone = 0,
 870                 LogLevelInfo,
 871                 LogLevelWarning,
 872                 LogLevelError
 873         };
 874
 875         ArdourLogLevel _log_not_acknowledged;
 876
 877         void resize_text_widgets ();
 878
 879         bool xrun_button_release (GdkEventButton* ev);
 880
 881         std::string _announce_string;
 882         void check_announcements ();
 883
 884         int do_audio_midi_setup (uint32_t);
 885         void audioengine_became_silent ();
 886
 887         DuplicateRouteDialog* duplicate_routes_dialog;
 888
 889         void grab_focus_after_dialog ();
 890
 891         void tabs_switch (GtkNotebookPage*, guint page_number);
 892         void tabs_page_added (Gtk::Widget*, guint);
 893         void tabs_page_removed (Gtk::Widget*, guint);
 894         ArdourButton editor_visibility_button;
 895         ArdourButton mixer_visibility_button;
 896         ArdourButton prefs_visibility_button;
 897
 898         bool key_press_focus_accelerator_handler (Gtk::Window& window, GdkEventKey* ev, Gtkmm2ext::Bindings*);
 899         bool try_gtk_accel_binding (GtkWindow* win, GdkEventKey* ev, bool translate, GdkModifierType modifier);
 900
 901         bool main_window_delete_event (GdkEventAny*);
 902         bool idle_ask_about_quit ();
 903
 904         void load_bindings ();
 905         bool tabbable_visibility_button_press (GdkEventButton* ev, std::string const& tabbable_name);
 906
 907         void step_up_through_tabs ();
 908         void step_down_through_tabs ();
 909
 910         void escape ();
 911         void close_current_dialog ();
 912         void pre_release_dialog ();
 913
 914         bool bind_lua_action_script (GdkEventButton*, int);
 915         void update_action_script_btn (int i, const std::string&);
 916 };
 917
 918 #endif /* __ardour_gui_h__ */