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