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