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