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