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