gtk2_ardour/ardour_ui.h

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