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 TimeInfoBox;
 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
 257         TimeInfoBox* time_info_box;
 258
 259         VideoTimeLine *video_timeline;
 260
 261         void store_clock_modes ();
 262         void restore_clock_modes ();
 263         void reset_main_clocks ();
 264
 265         void synchronize_sync_source_and_video_pullup ();
 266
 267         void add_route ();
 268         void add_route_dialog_finished (int);
 269
 270         void add_routes_part_two ();
 271         void add_routes_thread ();
 272
 273         void start_duplicate_routes ();
 274
 275         void add_lua_script ();
 276         void remove_lua_script ();
 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_vca (std::string const &, uint32_t);
 287
 288         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);
 289         void session_add_audio_track (
 290                 int input_channels,
 291                 int32_t output_channels,
 292                 ARDOUR::TrackMode mode,
 293                 ARDOUR::RouteGroup* route_group,
 294                 uint32_t how_many,
 295                 std::string const & name_template,
 296                 bool strict_io,
 297                 ARDOUR::PresentationInfo::order_t order
 298                 ) {
 299                 session_add_audio_route (true, input_channels, output_channels, mode, route_group, how_many, name_template, strict_io, order);
 300         }
 301
 302         void session_add_audio_bus (
 303                         int input_channels,
 304                         int32_t output_channels,
 305                         ARDOUR::RouteGroup* route_group,
 306                         uint32_t how_many,
 307                         std::string const & name_template,
 308                         bool strict_io,
 309                         ARDOUR::PresentationInfo::order_t order
 310                         ) {
 311                 session_add_audio_route (false, input_channels, output_channels, ARDOUR::Normal, route_group, how_many, name_template, strict_io, order);
 312         }
 313
 314         void session_add_midi_track (
 315                         ARDOUR::RouteGroup* route_group,
 316                         uint32_t how_many,
 317                         std::string const & name_template,
 318                         bool strict_io,
 319                         ARDOUR::PluginInfoPtr instrument,
 320                         ARDOUR::Plugin::PresetRecord* preset,
 321                         ARDOUR::PresentationInfo::order_t order
 322                 ) {
 323                 session_add_midi_route (true, route_group, how_many, name_template, strict_io, instrument, preset, order);
 324         }
 325
 326         void session_add_mixed_track (const ARDOUR::ChanCount&, const ARDOUR::ChanCount&, ARDOUR::RouteGroup*, uint32_t, std::string const &, bool,
 327                                       ARDOUR::PluginInfoPtr, ARDOUR::Plugin::PresetRecord* pset,
 328                                       ARDOUR::PresentationInfo::order_t order);
 329         void session_add_midi_bus (ARDOUR::RouteGroup*, uint32_t, std::string const &, bool, ARDOUR::PluginInfoPtr, ARDOUR::Plugin::PresetRecord* pset,
 330                                    ARDOUR::PresentationInfo::order_t order);
 331         void session_add_midi_route (bool, ARDOUR::RouteGroup *, uint32_t, std::string const &, bool,
 332                                      ARDOUR::PluginInfoPtr, ARDOUR::Plugin::PresetRecord*,
 333                                      ARDOUR::PresentationInfo::order_t order);
 334         void display_insufficient_ports_message ();
 335
 336         void attach_to_engine ();
 337         void post_engine ();
 338
 339         gint exit_on_main_window_close (GdkEventAny *);
 340
 341         void maximise_editing_space ();
 342         void restore_editing_space ();
 343
 344         void show_ui_prefs ();
 345
 346         bool check_audioengine(Gtk::Window&);
 347
 348         void setup_profile ();
 349         void setup_tooltips ();
 350
 351         void set_shuttle_fract (double);
 352
 353         void get_process_buffers ();
 354         void drop_process_buffers ();
 355
 356         void reset_peak_display ();
 357         void reset_route_peak_display (ARDOUR::Route*);
 358         void reset_group_peak_display (ARDOUR::RouteGroup*);
 359
 360         const std::string& announce_string() const { return _announce_string; }
 361
 362         void hide_application ();
 363
 364         Gtk::Notebook& tabs();
 365         Gtk::Window& main_window () { return _main_window; }
 366
 367         void setup_toplevel_window (Gtk::Window&, const std::string& name, void* owner);
 368
 369         /* called from a static C function */
 370
 371         GtkNotebook* tab_window_root_drop (GtkNotebook* src,
 372                                            GtkWidget* w,
 373                                            gint x,
 374                                            gint y,
 375                                            gpointer user_data);
 376
 377         bool tabbed_window_state_event_handler (GdkEventWindowState*, void* object);
 378         bool key_event_handler (GdkEventKey*, Gtk::Window* window);
 379
 380         Gtkmm2ext::ActionMap global_actions;
 381
 382         ARDOUR::PresentationInfo::order_t translate_order (RouteDialogs::InsertAt);
 383
 384 protected:
 385         friend class PublicEditor;
 386
 387         void toggle_auto_play ();
 388         void toggle_auto_input ();
 389         void toggle_punch ();
 390         void unset_dual_punch ();
 391         bool ignore_dual_punch;
 392         void toggle_punch_in ();
 393         void toggle_punch_out ();
 394         void show_loop_punch_ruler_and_disallow_hide ();
 395         void reenable_hide_loop_punch_ruler_if_appropriate ();
 396         void toggle_auto_return ();
 397         void toggle_click ();
 398         void toggle_audio_midi_setup ();
 399         void toggle_session_auto_loop ();
 400         void toggle_rc_options_window ();
 401         void toggle_session_options_window ();
 402
 403 private:
 404         Gtk::Window   _main_window;
 405         Gtkmm2ext::VisibilityTracker* main_window_visibility;
 406         Gtk::VBox      main_vpacker;
 407         Gtk::HBox      status_bar_hpacker;
 408         Gtk::Notebook _tabs;
 409         PublicEditor*  editor;
 410         Mixer_UI*      mixer;
 411         Gtk::Tooltips _tooltips;
 412         NSM_Client*    nsm;
 413         bool          _was_dirty;
 414         bool          _mixer_on_top;
 415         bool          _initial_verbose_plugin_scan;
 416         bool           first_time_engine_run;
 417
 418         void show_tabbable (Gtkmm2ext::Tabbable*);
 419         void hide_tabbable (Gtkmm2ext::Tabbable*);
 420         void detach_tabbable (Gtkmm2ext::Tabbable*);
 421         void attach_tabbable (Gtkmm2ext::Tabbable*);
 422         void button_change_tabbable_visibility (Gtkmm2ext::Tabbable*);
 423         void key_change_tabbable_visibility (Gtkmm2ext::Tabbable*);
 424         void toggle_editor_and_mixer ();
 425
 426         void tabbable_state_change (Gtkmm2ext::Tabbable&);
 427
 428         void toggle_meterbridge ();
 429         void toggle_luawindow ();
 430
 431         int  setup_windows ();
 432         void setup_transport ();
 433         void setup_clock ();
 434
 435         static ARDOUR_UI *theArdourUI;
 436         SessionDialog *_session_dialog;
 437
 438         int starting ();
 439
 440         int  ask_about_saving_session (const std::vector<std::string>& actions);
 441
 442         void save_session_at_its_request (std::string);
 443         /* periodic safety backup, to be precise */
 444         gint autosave_session();
 445         void update_autosave();
 446         sigc::connection _autosave_connection;
 447
 448         void session_dirty_changed ();
 449         void update_title ();
 450
 451         void map_transport_state ();
 452         int32_t do_engine_start ();
 453
 454         void engine_halted (const char* reason, bool free_reason);
 455         void engine_stopped ();
 456         void engine_running ();
 457
 458         void use_config ();
 459
 460         void about_signal_response(int response);
 461
 462         Gtk::VBox     top_packer;
 463
 464         sigc::connection clock_signal_connection;
 465         void         update_clocks ();
 466         void         start_clocking ();
 467         void         stop_clocking ();
 468
 469         void update_transport_clocks (framepos_t pos);
 470         void record_state_changed ();
 471
 472         std::list<MidiTracer*> _midi_tracer_windows;
 473
 474         /* Transport Control */
 475
 476         Gtk::Frame               transport_frame;
 477         Gtk::HBox                transport_hbox;
 478         Gtk::Fixed               transport_base;
 479         Gtk::Fixed               transport_button_base;
 480         Gtk::Frame               transport_button_frame;
 481         Gtk::HBox                transport_button_hbox;
 482         Gtk::VBox                transport_button_vbox;
 483         Gtk::HBox                transport_option_button_hbox;
 484         Gtk::VBox                transport_option_button_vbox;
 485         Gtk::HBox                transport_clock_hbox;
 486         Gtk::VBox                transport_clock_vbox;
 487         Gtk::HBox                primary_clock_hbox;
 488         Gtk::HBox                secondary_clock_hbox;
 489
 490         struct TransportControllable : public PBD::Controllable {
 491             enum ToggleType {
 492                     Roll = 0,
 493                     Stop,
 494                     RecordEnable,
 495                     GotoStart,
 496                     GotoEnd,
 497                     AutoLoop,
 498                     PlaySelection,
 499             };
 500
 501             TransportControllable (std::string name, ARDOUR_UI&, ToggleType);
 502             void set_value (double, PBD::Controllable::GroupControlDisposition group_override);
 503             double get_value (void) const;
 504
 505             ARDOUR_UI& ui;
 506             ToggleType type;
 507         };
 508
 509         boost::shared_ptr<TransportControllable> roll_controllable;
 510         boost::shared_ptr<TransportControllable> stop_controllable;
 511         boost::shared_ptr<TransportControllable> goto_start_controllable;
 512         boost::shared_ptr<TransportControllable> goto_end_controllable;
 513         boost::shared_ptr<TransportControllable> auto_loop_controllable;
 514         boost::shared_ptr<TransportControllable> play_selection_controllable;
 515         boost::shared_ptr<TransportControllable> rec_controllable;
 516
 517         void toggle_follow_edits ();
 518
 519         void set_transport_controllable_state (const XMLNode&);
 520         XMLNode& get_transport_controllable_state ();
 521
 522         ArdourButton roll_button;
 523         ArdourButton stop_button;
 524         ArdourButton goto_start_button;
 525         ArdourButton goto_end_button;
 526         ArdourButton auto_loop_button;
 527         ArdourButton play_selection_button;
 528         ArdourButton rec_button;
 529
 530         void toggle_external_sync ();
 531         void toggle_time_master ();
 532         void toggle_video_sync ();
 533
 534         ShuttleControl* shuttle_box;
 535
 536         ArdourButton auto_return_button;
 537         ArdourButton follow_edits_button;
 538         ArdourButton auto_input_button;
 539         ArdourButton click_button;
 540         ArdourButton sync_button;
 541
 542         ArdourButton auditioning_alert_button;
 543         ArdourButton solo_alert_button;
 544         ArdourButton feedback_alert_button;
 545         ArdourButton error_alert_button;
 546
 547         ArdourButton action_script_call_btn[10];
 548         Gtk::Table action_script_table;
 549
 550         Gtk::VBox alert_box;
 551         Gtk::VBox meter_box;
 552         LevelMeterHBox * editor_meter;
 553         float            editor_meter_max_peak;
 554         ArdourButton     editor_meter_peak_display;
 555         bool             editor_meter_peak_button_release (GdkEventButton*);
 556
 557         void blink_handler (bool);
 558         sigc::connection blink_connection;
 559
 560         void cancel_solo ();
 561         void solo_blink (bool);
 562         void sync_blink (bool);
 563         void audition_blink (bool);
 564         void feedback_blink (bool);
 565         void error_blink (bool);
 566
 567         void set_flat_buttons();
 568
 569         void soloing_changed (bool);
 570         void auditioning_changed (bool);
 571         void _auditioning_changed (bool);
 572
 573         bool solo_alert_press (GdkEventButton* ev);
 574         bool audition_alert_press (GdkEventButton* ev);
 575         bool feedback_alert_press (GdkEventButton *);
 576         bool error_alert_press (GdkEventButton *);
 577
 578         void big_clock_value_changed ();
 579         void primary_clock_value_changed ();
 580         void secondary_clock_value_changed ();
 581
 582         /* called by Blink signal */
 583
 584         void transport_rec_enable_blink (bool onoff);
 585
 586         Gtk::Menu*        session_popup_menu;
 587
 588         /* menu bar and associated stuff */
 589
 590         Gtk::MenuBar* menu_bar;
 591         Gtk::EventBox menu_bar_base;
 592         Gtk::HBox     menu_hbox;
 593
 594         void use_menubar_as_top_menubar ();
 595         void build_menu_bar ();
 596
 597         Gtk::Label   wall_clock_label;
 598         gint update_wall_clock ();
 599
 600         Gtk::Label   disk_space_label;
 601         void update_disk_space ();
 602
 603         Gtk::Label   timecode_format_label;
 604         void update_timecode_format ();
 605
 606         Gtk::Label   cpu_load_label;
 607         void update_cpu_load ();
 608
 609         Gtk::Label   xrun_label;
 610         void update_xrun_count ();
 611
 612         Gtk::Label   peak_thread_work_label;
 613         void update_peak_thread_work ();
 614
 615         Gtk::Label   buffer_load_label;
 616         void update_buffer_load ();
 617
 618         Gtk::Label   sample_rate_label;
 619         void update_sample_rate (ARDOUR::framecnt_t);
 620
 621         Gtk::Label    format_label;
 622         void update_format ();
 623
 624         void every_second ();
 625         void every_point_one_seconds ();
 626         void every_point_zero_something_seconds ();
 627
 628         sigc::connection second_connection;
 629         sigc::connection point_one_second_connection;
 630         sigc::connection point_zero_something_second_connection;
 631         sigc::connection fps_connection;
 632
 633         void set_fps_timeout_connection ();
 634
 635         void open_session ();
 636         void open_recent_session ();
 637         bool process_save_template_prompter (ArdourPrompter& prompter);
 638         void save_template ();
 639
 640         void edit_metadata ();
 641         void import_metadata ();
 642
 643         void set_transport_sensitivity (bool);
 644
 645         //stuff for ProTools-style numpad
 646         void transport_numpad_event (int num);
 647         void transport_numpad_decimal ();
 648         bool _numpad_locate_happening;
 649         int _pending_locate_num;
 650         gint transport_numpad_timeout ();
 651         sigc::connection _numpad_timeout_connection;
 652
 653         void transport_goto_nth_marker (int nth);
 654         void transport_goto_zero ();
 655         void transport_goto_start ();
 656         void transport_goto_end ();
 657         void transport_goto_wallclock ();
 658         void transport_stop ();
 659         void transport_record (bool roll);
 660         void transport_roll ();
 661         void transport_play_selection();
 662         void transport_play_preroll();
 663         void transport_forward (int option);
 664         void transport_rewind (int option);
 665         void transport_loop ();
 666         void toggle_roll (bool with_abort, bool roll_out_of_bounded_mode);
 667         bool trx_record_enable_all_tracks ();
 668
 669         bool _session_is_new;
 670         void set_session (ARDOUR::Session *);
 671         void connect_dependents_to_session (ARDOUR::Session *);
 672         void we_have_dependents ();
 673
 674         void setup_session_options ();
 675
 676         guint32  last_key_press_time;
 677
 678         bool process_snapshot_session_prompter (ArdourPrompter& prompter, bool switch_to_it);
 679         void snapshot_session (bool switch_to_it);
 680
 681         void quick_snapshot_session (bool switch_to_it);  //does not promtp for name, just makes a timestamped file
 682
 683         SaveAsDialog* save_as_dialog;
 684
 685         bool save_as_progress_update (float fraction, int64_t cnt, int64_t total, Gtk::Label* label, Gtk::ProgressBar* bar);
 686         void save_session_as ();
 687         void archive_session ();
 688         void rename_session ();
 689
 690         int         create_mixer ();
 691         int         create_editor ();
 692         int         create_meterbridge ();
 693         int         create_luawindow ();
 694         int         create_masters ();
 695
 696         Meterbridge  *meterbridge;
 697         LuaWindow    *luawindow;
 698
 699         /* Dialogs that can be created via new<T> */
 700
 701         RCOptionEditor* rc_option_editor;
 702         Gtk::HBox rc_option_editor_placeholder;
 703
 704         WM::Proxy<SpeakerDialog> speaker_config_window;
 705         WM::Proxy<AddRouteDialog> add_route_dialog;
 706         WM::Proxy<About> about;
 707         WM::Proxy<LocationUIWindow> location_ui;
 708         WM::Proxy<RouteParams_UI> route_params;
 709         WM::Proxy<EngineControl> audio_midi_setup;
 710         WM::Proxy<ExportVideoDialog> export_video_dialog;
 711         WM::Proxy<LuaScriptManager> lua_script_window;
 712
 713         /* Windows/Dialogs that require a creator method */
 714
 715         WM::ProxyWithConstructor<SessionOptionEditor> session_option_editor;
 716         WM::ProxyWithConstructor<AddVideoDialog> add_video_dialog;
 717         WM::ProxyWithConstructor<BundleManager> bundle_manager;
 718         WM::ProxyWithConstructor<BigClockWindow> big_clock_window;
 719         WM::ProxyWithConstructor<GlobalPortMatrixWindow> audio_port_matrix;
 720         WM::ProxyWithConstructor<GlobalPortMatrixWindow> midi_port_matrix;
 721         WM::ProxyWithConstructor<KeyEditor> key_editor;
 722
 723         /* creator methods */
 724
 725         SessionOptionEditor*    create_session_option_editor ();
 726         BundleManager*          create_bundle_manager ();
 727         AddVideoDialog*         create_add_video_dialog ();
 728         BigClockWindow*         create_big_clock_window();
 729         GlobalPortMatrixWindow* create_global_port_matrix (ARDOUR::DataType);
 730         KeyEditor*              create_key_editor ();
 731
 732         ARDOUR::SystemExec *video_server_process;
 733
 734         void handle_locations_change (ARDOUR::Location*);
 735
 736         /* Keyboard Handling */
 737
 738         ArdourKeyboard* keyboard;
 739
 740         /* Keymap handling */
 741
 742         void install_actions ();
 743
 744         void toggle_record_enable (uint16_t);
 745
 746         uint32_t rec_enabled_streams;
 747         void count_recenabled_streams (ARDOUR::Route&);
 748
 749         Splash* splash;
 750
 751         void pop_back_splash (Gtk::Window&);
 752
 753         /* cleanup */
 754
 755         Gtk::MenuItem *cleanup_item;
 756
 757         void display_cleanup_results (ARDOUR::CleanupReport& rep, const gchar* list_title, const bool msg_delete);
 758         void cleanup ();
 759         void cleanup_peakfiles ();
 760         void flush_trash ();
 761
 762         bool have_configure_timeout;
 763         ARDOUR::microseconds_t last_configure_time;
 764         gint configure_timeout ();
 765
 766         ARDOUR::microseconds_t last_peak_grab;
 767         ARDOUR::microseconds_t last_shuttle_request;
 768
 769         bool have_disk_speed_dialog_displayed;
 770         void disk_speed_dialog_gone (int ignored_response, Gtk::MessageDialog*);
 771         void disk_overrun_handler ();
 772         void disk_underrun_handler ();
 773         void gui_idle_handler ();
 774
 775         void cancel_plugin_scan ();
 776         void cancel_plugin_timeout ();
 777         void plugin_scan_dialog (std::string type, std::string plugin, bool);
 778         void plugin_scan_timeout (int);
 779
 780         void session_format_mismatch (std::string, std::string);
 781
 782         void session_dialog (std::string);
 783         int pending_state_dialog ();
 784         int sr_mismatch_dialog (ARDOUR::framecnt_t, ARDOUR::framecnt_t);
 785         void sr_mismatch_message (ARDOUR::framecnt_t, ARDOUR::framecnt_t);
 786
 787         Gtk::MenuItem* jack_disconnect_item;
 788         Gtk::MenuItem* jack_reconnect_item;
 789         Gtk::Menu*     jack_bufsize_menu;
 790
 791         Glib::RefPtr<Gtk::ActionGroup> common_actions;
 792
 793         void editor_realized ();
 794
 795         std::vector<std::string> positional_sync_strings;
 796
 797         void toggle_send_midi_feedback ();
 798         void toggle_use_mmc ();
 799         void toggle_send_mmc ();
 800         void toggle_send_mtc ();
 801         void toggle_send_midi_clock ();
 802
 803         void toggle_use_osc ();
 804
 805         void parameter_changed (std::string);
 806         void session_parameter_changed (std::string);
 807
 808         bool first_idle ();
 809
 810         void check_memory_locking ();
 811
 812         void audioengine_setup ();
 813
 814         void display_message (const char *prefix, gint prefix_len,
 815                         Glib::RefPtr<Gtk::TextBuffer::Tag> ptag, Glib::RefPtr<Gtk::TextBuffer::Tag> mtag,
 816                         const char *msg);
 817         Gtk::Label status_bar_label;
 818         bool status_bar_button_press (GdkEventButton*);
 819
 820         void loading_message (const std::string& msg);
 821
 822         PBD::ScopedConnectionList forever_connections;
 823         PBD::ScopedConnection halt_connection;
 824
 825         void step_edit_status_change (bool);
 826
 827         /* these are used only in response to a platform-specific "ShouldQuit" signal */
 828         bool idle_finish ();
 829         void queue_finish ();
 830         void fontconfig_dialog ();
 831
 832         int missing_file (ARDOUR::Session*s, std::string str, ARDOUR::DataType type);
 833         int ambiguous_file (std::string file, std::vector<std::string> hits);
 834
 835         bool click_button_clicked (GdkEventButton *);
 836
 837         VisibilityGroup _status_bar_visibility;
 838
 839         /** A ProcessThread so that we have some thread-local buffers for use by
 840          *  PluginEqGui::impulse_analysis ().
 841          */
 842         ARDOUR::ProcessThread* _process_thread;
 843
 844         void feedback_detected ();
 845
 846         ArdourButton             midi_panic_button;
 847         void                     midi_panic ();
 848
 849         void successful_graph_sort ();
 850         bool _feedback_exists;
 851
 852         enum ArdourLogLevel {
 853                 LogLevelNone = 0,
 854                 LogLevelInfo,
 855                 LogLevelWarning,
 856                 LogLevelError
 857         };
 858
 859         ArdourLogLevel _log_not_acknowledged;
 860
 861         void resize_text_widgets ();
 862
 863         bool xrun_button_release (GdkEventButton* ev);
 864
 865         std::string _announce_string;
 866         void check_announcements ();
 867
 868         int do_audio_midi_setup (uint32_t);
 869         void audioengine_became_silent ();
 870
 871         DuplicateRouteDialog* duplicate_routes_dialog;
 872
 873         void grab_focus_after_dialog ();
 874
 875         void tabs_switch (GtkNotebookPage*, guint page_number);
 876         void tabs_page_added (Gtk::Widget*, guint);
 877         void tabs_page_removed (Gtk::Widget*, guint);
 878         ArdourButton editor_visibility_button;
 879         ArdourButton mixer_visibility_button;
 880         ArdourButton prefs_visibility_button;
 881
 882         bool key_press_focus_accelerator_handler (Gtk::Window& window, GdkEventKey* ev, Gtkmm2ext::Bindings*);
 883         bool try_gtk_accel_binding (GtkWindow* win, GdkEventKey* ev, bool translate, GdkModifierType modifier);
 884
 885         bool main_window_delete_event (GdkEventAny*);
 886         bool idle_ask_about_quit ();
 887
 888         void load_bindings ();
 889         bool tabbable_visibility_button_press (GdkEventButton* ev, std::string const& tabbable_name);
 890
 891         void step_up_through_tabs ();
 892         void step_down_through_tabs ();
 893
 894         void escape ();
 895         void close_current_dialog ();
 896         void pre_release_dialog ();
 897 };
 898
 899 #endif /* __ardour_gui_h__ */