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