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