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