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