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