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