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