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