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