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         void show_loop_punch_ruler_and_disallow_hide ();
 395         void reenable_hide_loop_punch_ruler_if_appropriate ();
 396         void toggle_auto_return ();
 397         void toggle_click ();
 398         void toggle_audio_midi_setup ();
 399         void toggle_session_auto_loop ();
 400         void toggle_rc_options_window ();
 401         void toggle_session_options_window ();
 402
 403 private:
 404         Gtk::Window   _main_window;
 405         Gtkmm2ext::VisibilityTracker* main_window_visibility;
 406         Gtk::VBox      main_vpacker;
 407         Gtk::HBox      status_bar_hpacker;
 408         Gtk::Notebook _tabs;
 409         PublicEditor*  editor;
 410         Mixer_UI*      mixer;
 411         Gtk::Tooltips _tooltips;
 412         NSM_Client*    nsm;
 413         bool          _was_dirty;
 414         bool          _mixer_on_top;
 415         bool          _initial_verbose_plugin_scan;
 416         bool           first_time_engine_run;
 417
 418         void show_tabbable (Gtkmm2ext::Tabbable*);
 419         void hide_tabbable (Gtkmm2ext::Tabbable*);
 420         void detach_tabbable (Gtkmm2ext::Tabbable*);
 421         void attach_tabbable (Gtkmm2ext::Tabbable*);
 422         void button_change_tabbable_visibility (Gtkmm2ext::Tabbable*);
 423         void key_change_tabbable_visibility (Gtkmm2ext::Tabbable*);
 424         void toggle_editor_and_mixer ();
 425
 426         void tabbable_state_change (Gtkmm2ext::Tabbable&);
 427
 428         void toggle_meterbridge ();
 429         void toggle_luawindow ();
 430
 431         int  setup_windows ();
 432         void setup_transport ();
 433         void setup_clock ();
 434
 435         bool transport_expose (GdkEventExpose*);
 436
 437         static ARDOUR_UI *theArdourUI;
 438         SessionDialog *_session_dialog;
 439
 440         int starting ();
 441
 442         int  ask_about_saving_session (const std::vector<std::string>& actions);
 443
 444         void save_session_at_its_request (std::string);
 445         /* periodic safety backup, to be precise */
 446         gint autosave_session();
 447         void update_autosave();
 448         sigc::connection _autosave_connection;
 449
 450         void session_dirty_changed ();
 451         void update_title ();
 452
 453         void map_transport_state ();
 454         int32_t do_engine_start ();
 455
 456         void engine_halted (const char* reason, bool free_reason);
 457         void engine_stopped ();
 458         void engine_running ();
 459
 460         void use_config ();
 461
 462         void about_signal_response(int response);
 463
 464         Gtk::VBox     top_packer;
 465
 466         sigc::connection clock_signal_connection;
 467         void         update_clocks ();
 468         void         start_clocking ();
 469         void         stop_clocking ();
 470
 471         void update_transport_clocks (framepos_t pos);
 472         void record_state_changed ();
 473
 474         std::list<MidiTracer*> _midi_tracer_windows;
 475
 476         /* Transport Control */
 477
 478         Gtk::Table               transport_table;
 479         Gtk::Frame               transport_frame;
 480         Gtk::HBox                transport_hbox;
 481
 482         ArdourVSpacer *secondary_clock_spacer;
 483         void repack_transport_hbox ();
 484         void update_clock_visibility ();
 485
 486         struct TransportControllable : public PBD::Controllable {
 487             enum ToggleType {
 488                     Roll = 0,
 489                     Stop,
 490                     RecordEnable,
 491                     GotoStart,
 492                     GotoEnd,
 493                     AutoLoop,
 494                     PlaySelection,
 495             };
 496
 497             TransportControllable (std::string name, ARDOUR_UI&, ToggleType);
 498             void set_value (double, PBD::Controllable::GroupControlDisposition group_override);
 499             double get_value (void) const;
 500
 501             ARDOUR_UI& ui;
 502             ToggleType type;
 503         };
 504
 505         boost::shared_ptr<TransportControllable> roll_controllable;
 506         boost::shared_ptr<TransportControllable> stop_controllable;
 507         boost::shared_ptr<TransportControllable> goto_start_controllable;
 508         boost::shared_ptr<TransportControllable> goto_end_controllable;
 509         boost::shared_ptr<TransportControllable> auto_loop_controllable;
 510         boost::shared_ptr<TransportControllable> play_selection_controllable;
 511         boost::shared_ptr<TransportControllable> rec_controllable;
 512
 513         void toggle_follow_edits ();
 514
 515         void set_transport_controllable_state (const XMLNode&);
 516         XMLNode& get_transport_controllable_state ();
 517
 518         ArdourButton roll_button;
 519         ArdourButton stop_button;
 520         ArdourButton goto_start_button;
 521         ArdourButton goto_end_button;
 522         ArdourButton auto_loop_button;
 523         ArdourButton play_selection_button;
 524         ArdourButton rec_button;
 525         ArdourButton punch_in_button;
 526         ArdourButton punch_out_button;
 527         ArdourButton layered_button;
 528
 529         Gtk::Label   punch_label;
 530         Gtk::Label   layered_label;
 531
 532         void toggle_external_sync ();
 533         void toggle_time_master ();
 534         void toggle_video_sync ();
 535
 536         ShuttleControl shuttle_box;
 537         MiniTimeline   mini_timeline;
 538         TimeInfoBox   *time_info_box;
 539
 540         ArdourButton auto_return_button;
 541         ArdourButton follow_edits_button;
 542         ArdourButton auto_input_button;
 543         ArdourButton click_button;
 544         ArdourButton sync_button;
 545
 546         ArdourButton auditioning_alert_button;
 547         ArdourButton solo_alert_button;
 548         ArdourButton feedback_alert_button;
 549         ArdourButton error_alert_button;
 550
 551         ArdourButton action_script_call_btn[10];
 552         Gtk::Table action_script_table;
 553
 554         Gtk::VBox alert_box;
 555         Gtk::VBox meter_box;
 556         LevelMeterHBox * editor_meter;
 557         float            editor_meter_max_peak;
 558         ArdourButton     editor_meter_peak_display;
 559         bool             editor_meter_peak_button_release (GdkEventButton*);
 560
 561         void blink_handler (bool);
 562         sigc::connection blink_connection;
 563
 564         void cancel_solo ();
 565         void solo_blink (bool);
 566         void sync_blink (bool);
 567         void audition_blink (bool);
 568         void feedback_blink (bool);
 569         void error_blink (bool);
 570
 571         void set_flat_buttons();
 572
 573         void soloing_changed (bool);
 574         void auditioning_changed (bool);
 575         void _auditioning_changed (bool);
 576
 577         bool solo_alert_press (GdkEventButton* ev);
 578         void audition_alert_clicked ();
 579         bool error_alert_press (GdkEventButton *);
 580
 581         void layered_button_clicked ();
 582
 583         void big_clock_value_changed ();
 584         void primary_clock_value_changed ();
 585         void secondary_clock_value_changed ();
 586
 587         /* called by Blink signal */
 588
 589         void transport_rec_enable_blink (bool onoff);
 590
 591         Gtk::Menu*        session_popup_menu;
 592
 593         /* menu bar and associated stuff */
 594
 595         Gtk::MenuBar* menu_bar;
 596         Gtk::EventBox menu_bar_base;
 597         Gtk::HBox     menu_hbox;
 598
 599         void use_menubar_as_top_menubar ();
 600         void build_menu_bar ();
 601
 602         Gtk::Label   wall_clock_label;
 603         gint update_wall_clock ();
 604
 605         Gtk::Label   disk_space_label;
 606         void update_disk_space ();
 607
 608         Gtk::Label   timecode_format_label;
 609         void update_timecode_format ();
 610
 611         Gtk::Label   cpu_load_label;
 612         void update_cpu_load ();
 613
 614         Gtk::Label   xrun_label;
 615         void update_xrun_count ();
 616
 617         Gtk::Label   peak_thread_work_label;
 618         void update_peak_thread_work ();
 619
 620         Gtk::Label   buffer_load_label;
 621         void update_buffer_load ();
 622
 623         Gtk::Label   sample_rate_label;
 624         void update_sample_rate (ARDOUR::framecnt_t);
 625
 626         Gtk::Label    format_label;
 627         void update_format ();
 628
 629         void every_second ();
 630         void every_point_one_seconds ();
 631         void every_point_zero_something_seconds ();
 632
 633         sigc::connection second_connection;
 634         sigc::connection point_one_second_connection;
 635         sigc::connection point_zero_something_second_connection;
 636         sigc::connection fps_connection;
 637
 638         void set_fps_timeout_connection ();
 639
 640         void open_session ();
 641         void open_recent_session ();
 642         bool process_save_template_prompter (ArdourPrompter& prompter);
 643         void save_template ();
 644
 645         void edit_metadata ();
 646         void import_metadata ();
 647
 648         void set_transport_sensitivity (bool);
 649
 650         //stuff for ProTools-style numpad
 651         void transport_numpad_event (int num);
 652         void transport_numpad_decimal ();
 653         bool _numpad_locate_happening;
 654         int _pending_locate_num;
 655         gint transport_numpad_timeout ();
 656         sigc::connection _numpad_timeout_connection;
 657
 658         void transport_goto_nth_marker (int nth);
 659         void transport_goto_zero ();
 660         void transport_goto_start ();
 661         void transport_goto_end ();
 662         void transport_goto_wallclock ();
 663         void transport_stop ();
 664         void transport_record (bool roll);
 665         void transport_roll ();
 666         void transport_play_selection();
 667         void transport_play_preroll();
 668         void transport_forward (int option);
 669         void transport_rewind (int option);
 670         void transport_loop ();
 671         void toggle_roll (bool with_abort, bool roll_out_of_bounded_mode);
 672         bool trx_record_enable_all_tracks ();
 673
 674         bool _session_is_new;
 675         void set_session (ARDOUR::Session *);
 676         void connect_dependents_to_session (ARDOUR::Session *);
 677         void we_have_dependents ();
 678
 679         void setup_session_options ();
 680
 681         guint32  last_key_press_time;
 682
 683         bool process_snapshot_session_prompter (ArdourPrompter& prompter, bool switch_to_it);
 684         void snapshot_session (bool switch_to_it);
 685
 686         void quick_snapshot_session (bool switch_to_it);  //does not promtp for name, just makes a timestamped file
 687
 688         SaveAsDialog* save_as_dialog;
 689
 690         bool save_as_progress_update (float fraction, int64_t cnt, int64_t total, Gtk::Label* label, Gtk::ProgressBar* bar);
 691         void save_session_as ();
 692         void archive_session ();
 693         void rename_session ();
 694
 695         int         create_mixer ();
 696         int         create_editor ();
 697         int         create_meterbridge ();
 698         int         create_luawindow ();
 699         int         create_masters ();
 700
 701         Meterbridge  *meterbridge;
 702         LuaWindow    *luawindow;
 703
 704         /* Dialogs that can be created via new<T> */
 705
 706         RCOptionEditor* rc_option_editor;
 707         Gtk::HBox rc_option_editor_placeholder;
 708
 709         WM::Proxy<SpeakerDialog> speaker_config_window;
 710         WM::Proxy<AddRouteDialog> add_route_dialog;
 711         WM::Proxy<About> about;
 712         WM::Proxy<LocationUIWindow> location_ui;
 713         WM::Proxy<RouteParams_UI> route_params;
 714         WM::Proxy<EngineControl> audio_midi_setup;
 715         WM::Proxy<ExportVideoDialog> export_video_dialog;
 716         WM::Proxy<LuaScriptManager> lua_script_window;
 717
 718         /* Windows/Dialogs that require a creator method */
 719
 720         WM::ProxyWithConstructor<SessionOptionEditor> session_option_editor;
 721         WM::ProxyWithConstructor<AddVideoDialog> add_video_dialog;
 722         WM::ProxyWithConstructor<BundleManager> bundle_manager;
 723         WM::ProxyWithConstructor<BigClockWindow> big_clock_window;
 724         WM::ProxyWithConstructor<GlobalPortMatrixWindow> audio_port_matrix;
 725         WM::ProxyWithConstructor<GlobalPortMatrixWindow> midi_port_matrix;
 726         WM::ProxyWithConstructor<KeyEditor> key_editor;
 727
 728         /* creator methods */
 729
 730         SessionOptionEditor*    create_session_option_editor ();
 731         BundleManager*          create_bundle_manager ();
 732         AddVideoDialog*         create_add_video_dialog ();
 733         BigClockWindow*         create_big_clock_window();
 734         GlobalPortMatrixWindow* create_global_port_matrix (ARDOUR::DataType);
 735         KeyEditor*              create_key_editor ();
 736
 737         ARDOUR::SystemExec *video_server_process;
 738
 739         void handle_locations_change (ARDOUR::Location*);
 740
 741         /* Keyboard Handling */
 742
 743         ArdourKeyboard* keyboard;
 744
 745         /* Keymap handling */
 746
 747         void install_actions ();
 748
 749         void toggle_record_enable (uint16_t);
 750
 751         uint32_t rec_enabled_streams;
 752         void count_recenabled_streams (ARDOUR::Route&);
 753
 754         Splash* splash;
 755
 756         void pop_back_splash (Gtk::Window&);
 757
 758         /* cleanup */
 759
 760         Gtk::MenuItem *cleanup_item;
 761
 762         void display_cleanup_results (ARDOUR::CleanupReport& rep, const gchar* list_title, const bool msg_delete);
 763         void cleanup ();
 764         void cleanup_peakfiles ();
 765         void flush_trash ();
 766
 767         bool have_configure_timeout;
 768         ARDOUR::microseconds_t last_configure_time;
 769         gint configure_timeout ();
 770
 771         ARDOUR::microseconds_t last_peak_grab;
 772         ARDOUR::microseconds_t last_shuttle_request;
 773
 774         bool have_disk_speed_dialog_displayed;
 775         void disk_speed_dialog_gone (int ignored_response, Gtk::MessageDialog*);
 776         void disk_overrun_handler ();
 777         void disk_underrun_handler ();
 778         void gui_idle_handler ();
 779
 780         void cancel_plugin_scan ();
 781         void cancel_plugin_timeout ();
 782         void plugin_scan_dialog (std::string type, std::string plugin, bool);
 783         void plugin_scan_timeout (int);
 784
 785         void session_format_mismatch (std::string, std::string);
 786
 787         void session_dialog (std::string);
 788         int pending_state_dialog ();
 789         int sr_mismatch_dialog (ARDOUR::framecnt_t, ARDOUR::framecnt_t);
 790         void sr_mismatch_message (ARDOUR::framecnt_t, ARDOUR::framecnt_t);
 791
 792         Gtk::MenuItem* jack_disconnect_item;
 793         Gtk::MenuItem* jack_reconnect_item;
 794         Gtk::Menu*     jack_bufsize_menu;
 795
 796         Glib::RefPtr<Gtk::ActionGroup> common_actions;
 797
 798         void editor_realized ();
 799
 800         std::vector<std::string> positional_sync_strings;
 801
 802         void toggle_send_midi_feedback ();
 803         void toggle_use_mmc ();
 804         void toggle_send_mmc ();
 805         void toggle_send_mtc ();
 806         void toggle_send_midi_clock ();
 807
 808         void toggle_use_osc ();
 809
 810         void parameter_changed (std::string);
 811         void session_parameter_changed (std::string);
 812
 813         bool first_idle ();
 814
 815         void check_memory_locking ();
 816
 817         void audioengine_setup ();
 818
 819         void display_message (const char *prefix, gint prefix_len,
 820                         Glib::RefPtr<Gtk::TextBuffer::Tag> ptag, Glib::RefPtr<Gtk::TextBuffer::Tag> mtag,
 821                         const char *msg);
 822         Gtk::Label status_bar_label;
 823         bool status_bar_button_press (GdkEventButton*);
 824
 825         void loading_message (const std::string& msg);
 826
 827         PBD::ScopedConnectionList forever_connections;
 828         PBD::ScopedConnection halt_connection;
 829
 830         void step_edit_status_change (bool);
 831
 832         /* these are used only in response to a platform-specific "ShouldQuit" signal */
 833         bool idle_finish ();
 834         void queue_finish ();
 835         void fontconfig_dialog ();
 836
 837         int missing_file (ARDOUR::Session*s, std::string str, ARDOUR::DataType type);
 838         int ambiguous_file (std::string file, std::vector<std::string> hits);
 839
 840         bool click_button_clicked (GdkEventButton *);
 841         bool sync_button_clicked (GdkEventButton *);
 842
 843         VisibilityGroup _status_bar_visibility;
 844
 845         /** A ProcessThread so that we have some thread-local buffers for use by
 846          *  PluginEqGui::impulse_analysis ().
 847          */
 848         ARDOUR::ProcessThread* _process_thread;
 849
 850         void feedback_detected ();
 851
 852         ArdourButton             midi_panic_button;
 853         void                     midi_panic ();
 854
 855         void successful_graph_sort ();
 856         bool _feedback_exists;
 857
 858         enum ArdourLogLevel {
 859                 LogLevelNone = 0,
 860                 LogLevelInfo,
 861                 LogLevelWarning,
 862                 LogLevelError
 863         };
 864
 865         ArdourLogLevel _log_not_acknowledged;
 866
 867         void resize_text_widgets ();
 868
 869         bool xrun_button_release (GdkEventButton* ev);
 870
 871         std::string _announce_string;
 872         void check_announcements ();
 873
 874         int do_audio_midi_setup (uint32_t);
 875         void audioengine_became_silent ();
 876
 877         DuplicateRouteDialog* duplicate_routes_dialog;
 878
 879         void grab_focus_after_dialog ();
 880
 881         void tabs_switch (GtkNotebookPage*, guint page_number);
 882         void tabs_page_added (Gtk::Widget*, guint);
 883         void tabs_page_removed (Gtk::Widget*, guint);
 884         ArdourButton editor_visibility_button;
 885         ArdourButton mixer_visibility_button;
 886         ArdourButton prefs_visibility_button;
 887
 888         bool key_press_focus_accelerator_handler (Gtk::Window& window, GdkEventKey* ev, Gtkmm2ext::Bindings*);
 889         bool try_gtk_accel_binding (GtkWindow* win, GdkEventKey* ev, bool translate, GdkModifierType modifier);
 890
 891         bool main_window_delete_event (GdkEventAny*);
 892         bool idle_ask_about_quit ();
 893
 894         void load_bindings ();
 895         bool tabbable_visibility_button_press (GdkEventButton* ev, std::string const& tabbable_name);
 896
 897         void step_up_through_tabs ();
 898         void step_down_through_tabs ();
 899
 900         void escape ();
 901         void close_current_dialog ();
 902         void pre_release_dialog ();
 903 };
 904
 905 #endif /* __ardour_gui_h__ */