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