gtk2_ardour/ardour_ui.h

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