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