gtk2_ardour/ardour_ui.h

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