make dragging a region from the list not crash.
[ardour.git] / gtk2_ardour / ardour_ui.h
1 /*
2     Copyright (C) 1999-2002 Paul Davis
3
4     This program is free software; you can redistribute it and/or modify
5     it under the terms of the GNU General Public License as published by
6     the Free Software Foundation; either version 2 of the License, or
7     (at your option) any later version.
8
9     This program is distributed in the hope that it will be useful,
10     but WITHOUT ANY WARRANTY; without even the implied warranty of
11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12     GNU General Public License for more details.
13
14     You should have received a copy of the GNU General Public License
15     along with this program; if not, write to the Free Software
16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
17
18 */
19
20 #ifndef __ardour_gui_h__
21 #define __ardour_gui_h__
22
23 #include <time.h>
24
25 /* need _BSD_SOURCE to get timersub macros */
26
27 #ifdef _BSD_SOURCE
28 #include <sys/time.h>
29 #else
30 #define _BSD_SOURCE
31 #include <sys/time.h>
32 #undef _BSD_SOURCE
33 #endif
34
35 #include <list>
36 #include <cmath>
37
38
39 #include "pbd/xml++.h"
40 #include "pbd/controllable.h"
41 #include <gtkmm/box.h>
42 #include <gtkmm/frame.h>
43 #include <gtkmm/label.h>
44 #include <gtkmm/table.h>
45 #include <gtkmm/fixed.h>
46 #include <gtkmm/drawingarea.h>
47 #include <gtkmm/eventbox.h>
48 #include <gtkmm/menu.h>
49 #include <gtkmm/menuitem.h>
50 #include <gtkmm/button.h>
51 #include <gtkmm/togglebutton.h>
52 #include <gtkmm/treeview.h>
53 #include <gtkmm/menubar.h>
54 #include <gtkmm/textbuffer.h>
55 #include <gtkmm/adjustment.h>
56
57 #include "gtkmm2ext/gtk_ui.h"
58 #include "gtkmm2ext/click_box.h"
59 #include "gtkmm2ext/stateful_button.h"
60 #include "gtkmm2ext/bindable_button.h"
61 #include "gtkmm2ext/bindings.h"
62 #include "gtkmm2ext/visibility_tracker.h"
63
64 #include "ardour/ardour.h"
65 #include "ardour/types.h"
66 #include "ardour/utils.h"
67 #include "ardour/plugin.h"
68 #include "ardour/session_handle.h"
69 #include "ardour/system_exec.h"
70
71 #include "video_timeline.h"
72
73 #include "add_route_dialog.h"
74 #include "ardour_button.h"
75 #include "ardour_dialog.h"
76 #include "ardour_spacer.h"
77 #include "ardour_window.h"
78 #include "editing.h"
79 #include "enums.h"
80 #include "mini_timeline.h"
81 #include "shuttle_control.h"
82 #include "visibility_group.h"
83 #include "window_manager.h"
84
85 #ifdef COMPILER_MSVC
86 #include "about.h"
87 #include "add_video_dialog.h"
88 #include "big_clock_window.h"
89 #include "bundle_manager.h"
90 #include "engine_dialog.h"
91 #include "export_video_dialog.h"
92 #include "global_port_matrix.h"
93 #include "keyeditor.h"
94 #include "location_ui.h"
95 #include "lua_script_manager.h"
96 #include "rc_option_editor.h"
97 #include "route_dialogs.h"
98 #include "route_params_ui.h"
99 #include "session_option_editor.h"
100 #include "speaker_dialog.h"
101 #else
102 class About;
103 class AddRouteDialog;
104 class AddVideoDialog;
105 class BigClockWindow;
106 class BundleManager;
107 class EngineControl;
108 class ExportVideoDialog;
109 class KeyEditor;
110 class LocationUIWindow;
111 class LuaScriptManager;
112 class RCOptionEditor;
113 class RouteParams_UI;
114 class SessionOptionEditor;
115 class SpeakerDialog;
116 class GlobalPortMatrixWindow;
117 #endif
118
119 class VideoTimeLine;
120 class ArdourKeyboard;
121 class ArdourVSpacer;
122 class AudioClock;
123 class ButtonJoiner;
124 class ConnectionEditor;
125 class DuplicateRouteDialog;
126 class MainClock;
127 class Mixer_UI;
128 class ArdourPrompter;
129 class PublicEditor;
130 class SaveAsDialog;
131 class SessionDialog;
132 class SessionOptionEditorWindow;
133 class Splash;
134 class TimeInfoBox;
135 class Meterbridge;
136 class LuaWindow;
137 class MidiTracer;
138 class NSM_Client;
139 class LevelMeterHBox;
140 class GUIObjectState;
141
142 namespace ARDOUR {
143         class ControlProtocolInfo;
144         class IO;
145         class Port;
146         class Route;
147         class RouteGroup;
148         class Location;
149         class ProcessThread;
150 }
151
152 namespace Gtk {
153         class ProgressBar;
154 }
155
156 namespace Gtkmm2ext {
157         class Tabbable;
158 }
159
160 class ARDOUR_UI : public Gtkmm2ext::UI, public ARDOUR::SessionHandlePtr
161 {
162 public:
163         ARDOUR_UI (int *argcp, char **argvp[], const char* localedir);
164         ~ARDOUR_UI();
165
166         bool run_startup (bool should_be_new, std::string load_template);
167
168         void show_splash ();
169         void hide_splash ();
170
171         void launch_chat ();
172         void launch_manual ();
173         void launch_reference ();
174         void launch_tracker ();
175         void launch_subscribe ();
176         void launch_cheat_sheet ();
177         void launch_website ();
178         void launch_website_dev ();
179         void launch_forums ();
180         void launch_howto_report ();
181         void show_about ();
182         void hide_about ();
183
184         void load_from_application_api (const std::string& path);
185         void finish();
186
187         int load_session (const std::string& path, const std::string& snapshot, std::string mix_template = std::string());
188         bool session_loaded;
189         int build_session (const std::string& path, const std::string& snapshot, ARDOUR::BusProfile&);
190         bool session_is_new() const { return _session_is_new; }
191
192         ARDOUR::Session* the_session() { return _session; }
193
194         bool get_smart_mode () const;
195
196         int get_session_parameters (bool quit_on_cancel, bool should_be_new = false, std::string load_template = "");
197         int  build_session_from_dialog (SessionDialog&, const std::string& session_name, const std::string& session_path);
198         bool ask_about_loading_existing_session (const std::string& session_path);
199
200         /// @return true if session was successfully unloaded.
201         int unload_session (bool hide_stuff = false);
202         void close_session();
203
204         int  save_state_canfail (std::string state_name = "", bool switch_to_it = false);
205         void save_state (const std::string & state_name = "", bool switch_to_it = false);
206
207         static ARDOUR_UI *instance () { return theArdourUI; }
208
209         /* signal emitted when escape key is pressed. All UI components that
210            need to respond to Escape in some way (e.g. break drag, clear
211            selection, etc) should connect to and handle this.
212         */
213         PBD::Signal0<void> Escape;
214
215         PublicEditor&     the_editor() { return *editor;}
216         Mixer_UI* the_mixer() { return mixer; }
217
218         void new_midi_tracer_window ();
219         void toggle_editing_space();
220         void toggle_mixer_space();
221         void toggle_mixer_list();
222         void toggle_monitor_section_visibility ();
223         void toggle_keep_tearoffs();
224
225         void reset_focus (Gtk::Widget*);
226
227         static PublicEditor* _instance;
228
229         /** Emitted frequently with the audible frame, false, and the edit point as
230          *  parameters respectively.
231          *
232          *  (either RapidScreenUpdate || SuperRapidScreenUpdate - user-config)
233          */
234         static sigc::signal<void, framepos_t, bool, framepos_t> Clock;
235
236         static void close_all_dialogs () { CloseAllDialogs(); }
237         static sigc::signal<void> CloseAllDialogs;
238
239         XMLNode* main_window_settings() const;
240         XMLNode* editor_settings() const;
241         XMLNode* preferences_settings() const;
242         XMLNode* mixer_settings () const;
243         XMLNode* keyboard_settings () const;
244         XMLNode* tearoff_settings (const char*) const;
245
246         void save_ardour_state ();
247         gboolean configure_handler (GdkEventConfigure* conf);
248
249         void halt_on_xrun_message ();
250         void xrun_handler (framepos_t);
251         void create_xrun_marker (framepos_t);
252
253         GUIObjectState* gui_object_state;
254
255         MainClock* primary_clock;
256         MainClock* secondary_clock;
257         void focus_on_clock ();
258         AudioClock*   big_clock;
259
260         VideoTimeLine *video_timeline;
261
262         void store_clock_modes ();
263         void restore_clock_modes ();
264         void reset_main_clocks ();
265
266         void synchronize_sync_source_and_video_pullup ();
267
268         void add_route ();
269         void add_route_dialog_finished (int);
270
271         void add_routes_part_two ();
272         void add_routes_thread ();
273
274         void start_duplicate_routes ();
275
276         void add_lua_script ();
277         void remove_lua_script ();
278
279         void add_video (Gtk::Window* float_window);
280         void remove_video ();
281         void start_video_server_menu (Gtk::Window* float_window);
282         bool start_video_server (Gtk::Window* float_window, bool popup_msg);
283         void stop_video_server (bool ask_confirm=false);
284         void flush_videotimeline_cache (bool localcacheonly=false);
285         void export_video (bool range = false);
286
287         void session_add_vca (std::string const &, uint32_t);
288
289         void session_add_audio_route (bool, int32_t, int32_t, ARDOUR::TrackMode, ARDOUR::RouteGroup *, uint32_t, std::string const &, bool, ARDOUR::PresentationInfo::order_t order);
290         void session_add_audio_track (
291                 int input_channels,
292                 int32_t output_channels,
293                 ARDOUR::TrackMode mode,
294                 ARDOUR::RouteGroup* route_group,
295                 uint32_t how_many,
296                 std::string const & name_template,
297                 bool strict_io,
298                 ARDOUR::PresentationInfo::order_t order
299                 ) {
300                 session_add_audio_route (true, input_channels, output_channels, mode, route_group, how_many, name_template, strict_io, order);
301         }
302
303         void session_add_audio_bus (
304                         int input_channels,
305                         int32_t output_channels,
306                         ARDOUR::RouteGroup* route_group,
307                         uint32_t how_many,
308                         std::string const & name_template,
309                         bool strict_io,
310                         ARDOUR::PresentationInfo::order_t order
311                         ) {
312                 session_add_audio_route (false, input_channels, output_channels, ARDOUR::Normal, route_group, how_many, name_template, strict_io, order);
313         }
314
315         void session_add_midi_track (
316                         ARDOUR::RouteGroup* route_group,
317                         uint32_t how_many,
318                         std::string const & name_template,
319                         bool strict_io,
320                         ARDOUR::PluginInfoPtr instrument,
321                         ARDOUR::Plugin::PresetRecord* preset,
322                         ARDOUR::PresentationInfo::order_t order
323                 ) {
324                 session_add_midi_route (true, route_group, how_many, name_template, strict_io, instrument, preset, order);
325         }
326
327         void session_add_mixed_track (const ARDOUR::ChanCount&, const ARDOUR::ChanCount&, ARDOUR::RouteGroup*, uint32_t, std::string const &, bool,
328                                       ARDOUR::PluginInfoPtr, ARDOUR::Plugin::PresetRecord* pset,
329                                       ARDOUR::PresentationInfo::order_t order);
330         void session_add_midi_bus (ARDOUR::RouteGroup*, uint32_t, std::string const &, bool, ARDOUR::PluginInfoPtr, ARDOUR::Plugin::PresetRecord* pset,
331                                    ARDOUR::PresentationInfo::order_t order);
332         void session_add_midi_route (bool, ARDOUR::RouteGroup *, uint32_t, std::string const &, bool,
333                                      ARDOUR::PluginInfoPtr, ARDOUR::Plugin::PresetRecord*,
334                                      ARDOUR::PresentationInfo::order_t order);
335         void display_insufficient_ports_message ();
336
337         void attach_to_engine ();
338         void post_engine ();
339
340         gint exit_on_main_window_close (GdkEventAny *);
341
342         void maximise_editing_space ();
343         void restore_editing_space ();
344
345         void show_ui_prefs ();
346
347         bool check_audioengine(Gtk::Window&);
348
349         void setup_profile ();
350         void setup_tooltips ();
351
352         void set_shuttle_fract (double);
353
354         void get_process_buffers ();
355         void drop_process_buffers ();
356
357         void reset_peak_display ();
358         void reset_route_peak_display (ARDOUR::Route*);
359         void reset_group_peak_display (ARDOUR::RouteGroup*);
360
361         const std::string& announce_string() const { return _announce_string; }
362
363         void hide_application ();
364
365         Gtk::Notebook& tabs();
366         Gtk::Window& main_window () { return _main_window; }
367
368         void setup_toplevel_window (Gtk::Window&, const std::string& name, void* owner);
369
370         /* called from a static C function */
371
372         GtkNotebook* tab_window_root_drop (GtkNotebook* src,
373                                            GtkWidget* w,
374                                            gint x,
375                                            gint y,
376                                            gpointer user_data);
377
378         bool tabbed_window_state_event_handler (GdkEventWindowState*, void* object);
379         bool key_event_handler (GdkEventKey*, Gtk::Window* window);
380
381         Gtkmm2ext::ActionMap global_actions;
382
383         ARDOUR::PresentationInfo::order_t translate_order (RouteDialogs::InsertAt);
384
385 protected:
386         friend class PublicEditor;
387
388         void toggle_auto_play ();
389         void toggle_auto_input ();
390         void toggle_punch ();
391         void unset_dual_punch ();
392         bool ignore_dual_punch;
393         void toggle_punch_in ();
394         void toggle_punch_out ();
395         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         void toggle_follow_edits ();
509
510         ArdourButton roll_button;
511         ArdourButton stop_button;
512         ArdourButton goto_start_button;
513         ArdourButton goto_end_button;
514         ArdourButton auto_loop_button;
515         ArdourButton play_selection_button;
516         ArdourButton rec_button;
517         ArdourButton punch_in_button;
518         ArdourButton punch_out_button;
519         ArdourButton layered_button;
520
521         ArdourVSpacer recpunch_spacer;
522         ArdourVSpacer monitoring_spacer;
523
524         ArdourButton monitor_in_button;
525         ArdourButton monitor_disk_button;
526         ArdourButton auto_input_button;
527
528         Gtk::Label   punch_label;
529         Gtk::Label   layered_label;
530
531         Gtk::Label   punch_space;
532         Gtk::Label   mon_space;
533
534         void toggle_external_sync ();
535         void toggle_time_master ();
536         void toggle_video_sync ();
537
538         ShuttleControl shuttle_box;
539         MiniTimeline   mini_timeline;
540         TimeInfoBox   *time_info_box;
541
542         ArdourButton auto_return_button;
543         ArdourButton follow_edits_button;
544         ArdourButton click_button;
545         ArdourButton sync_button;
546
547         ArdourButton auditioning_alert_button;
548         ArdourButton solo_alert_button;
549         ArdourButton feedback_alert_button;
550         ArdourButton error_alert_button;
551
552         ArdourButton action_script_call_btn[10];
553         Gtk::Table action_script_table;
554
555         Gtk::VBox alert_box;
556         Gtk::VBox meter_box;
557         LevelMeterHBox * editor_meter;
558         float            editor_meter_max_peak;
559         ArdourButton     editor_meter_peak_display;
560         bool             editor_meter_peak_button_release (GdkEventButton*);
561
562         void blink_handler (bool);
563         sigc::connection blink_connection;
564
565         void cancel_solo ();
566         void solo_blink (bool);
567         void sync_blink (bool);
568         void audition_blink (bool);
569         void feedback_blink (bool);
570         void error_blink (bool);
571
572         void set_flat_buttons();
573
574         void soloing_changed (bool);
575         void auditioning_changed (bool);
576         void _auditioning_changed (bool);
577
578         bool solo_alert_press (GdkEventButton* ev);
579         void audition_alert_clicked ();
580         bool error_alert_press (GdkEventButton *);
581
582         void layered_button_clicked ();
583
584         void big_clock_value_changed ();
585         void primary_clock_value_changed ();
586         void secondary_clock_value_changed ();
587
588         /* called by Blink signal */
589
590         void transport_rec_enable_blink (bool onoff);
591
592         Gtk::Menu*        session_popup_menu;
593
594         /* menu bar and associated stuff */
595
596         Gtk::MenuBar* menu_bar;
597         Gtk::EventBox menu_bar_base;
598         Gtk::HBox     menu_hbox;
599
600         void use_menubar_as_top_menubar ();
601         void build_menu_bar ();
602
603         Gtk::Label   wall_clock_label;
604         gint update_wall_clock ();
605
606         Gtk::Label   disk_space_label;
607         void update_disk_space ();
608
609         Gtk::Label   timecode_format_label;
610         void update_timecode_format ();
611
612         Gtk::Label   cpu_load_label;
613         void update_cpu_load ();
614
615         Gtk::Label   xrun_label;
616         void update_xrun_count ();
617
618         Gtk::Label   peak_thread_work_label;
619         void update_peak_thread_work ();
620
621         Gtk::Label   buffer_load_label;
622         void update_buffer_load ();
623
624         Gtk::Label   sample_rate_label;
625         void update_sample_rate (ARDOUR::framecnt_t);
626
627         Gtk::Label    format_label;
628         void update_format ();
629
630         void every_second ();
631         void every_point_one_seconds ();
632         void every_point_zero_something_seconds ();
633
634         sigc::connection second_connection;
635         sigc::connection point_one_second_connection;
636         sigc::connection point_zero_something_second_connection;
637         sigc::connection fps_connection;
638
639         void set_fps_timeout_connection ();
640
641         void open_session ();
642         void open_recent_session ();
643         bool process_save_template_prompter (ArdourPrompter& prompter);
644         void save_template ();
645
646         void edit_metadata ();
647         void import_metadata ();
648
649         void set_loop_sensitivity ();
650         void set_transport_sensitivity (bool);
651
652         //stuff for ProTools-style numpad
653         void transport_numpad_event (int num);
654         void transport_numpad_decimal ();
655         bool _numpad_locate_happening;
656         int _pending_locate_num;
657         gint transport_numpad_timeout ();
658         sigc::connection _numpad_timeout_connection;
659
660         void transport_goto_nth_marker (int nth);
661         void transport_goto_zero ();
662         void transport_goto_start ();
663         void transport_goto_end ();
664         void transport_goto_wallclock ();
665         void transport_stop ();
666         void transport_record (bool roll);
667         void transport_roll ();
668         void transport_play_selection();
669         void transport_play_preroll();
670         void transport_rec_preroll();
671         void transport_forward (int option);
672         void transport_rewind (int option);
673         void transport_loop ();
674         void toggle_roll (bool with_abort, bool roll_out_of_bounded_mode);
675         bool trx_record_enable_all_tracks ();
676
677         bool _session_is_new;
678         void set_session (ARDOUR::Session *);
679         void connect_dependents_to_session (ARDOUR::Session *);
680         void we_have_dependents ();
681
682         void setup_session_options ();
683
684         guint32  last_key_press_time;
685
686         bool process_snapshot_session_prompter (ArdourPrompter& prompter, bool switch_to_it);
687         void snapshot_session (bool switch_to_it);
688
689         void quick_snapshot_session (bool switch_to_it);  //does not promtp for name, just makes a timestamped file
690
691         SaveAsDialog* save_as_dialog;
692
693         bool save_as_progress_update (float fraction, int64_t cnt, int64_t total, Gtk::Label* label, Gtk::ProgressBar* bar);
694         void save_session_as ();
695         void archive_session ();
696         void rename_session ();
697
698         int         create_mixer ();
699         int         create_editor ();
700         int         create_meterbridge ();
701         int         create_luawindow ();
702         int         create_masters ();
703
704         Meterbridge  *meterbridge;
705         LuaWindow    *luawindow;
706
707         /* Dialogs that can be created via new<T> */
708
709         RCOptionEditor* rc_option_editor;
710         Gtk::HBox rc_option_editor_placeholder;
711
712         WM::Proxy<SpeakerDialog> speaker_config_window;
713         WM::Proxy<AddRouteDialog> add_route_dialog;
714         WM::Proxy<About> about;
715         WM::Proxy<LocationUIWindow> location_ui;
716         WM::Proxy<RouteParams_UI> route_params;
717         WM::Proxy<EngineControl> audio_midi_setup;
718         WM::Proxy<ExportVideoDialog> export_video_dialog;
719         WM::Proxy<LuaScriptManager> lua_script_window;
720
721         /* Windows/Dialogs that require a creator method */
722
723         WM::ProxyWithConstructor<SessionOptionEditor> session_option_editor;
724         WM::ProxyWithConstructor<AddVideoDialog> add_video_dialog;
725         WM::ProxyWithConstructor<BundleManager> bundle_manager;
726         WM::ProxyWithConstructor<BigClockWindow> big_clock_window;
727         WM::ProxyWithConstructor<GlobalPortMatrixWindow> audio_port_matrix;
728         WM::ProxyWithConstructor<GlobalPortMatrixWindow> midi_port_matrix;
729         WM::ProxyWithConstructor<KeyEditor> key_editor;
730
731         /* creator methods */
732
733         SessionOptionEditor*    create_session_option_editor ();
734         BundleManager*          create_bundle_manager ();
735         AddVideoDialog*         create_add_video_dialog ();
736         BigClockWindow*         create_big_clock_window();
737         GlobalPortMatrixWindow* create_global_port_matrix (ARDOUR::DataType);
738         KeyEditor*              create_key_editor ();
739
740         ARDOUR::SystemExec *video_server_process;
741
742         void handle_locations_change (ARDOUR::Location*);
743
744         /* Keyboard Handling */
745
746         ArdourKeyboard* keyboard;
747
748         /* Keymap handling */
749
750         void install_actions ();
751
752         void toggle_record_enable (uint16_t);
753
754         uint32_t rec_enabled_streams;
755         void count_recenabled_streams (ARDOUR::Route&);
756
757         Splash* splash;
758
759         void pop_back_splash (Gtk::Window&);
760
761         /* cleanup */
762
763         Gtk::MenuItem *cleanup_item;
764
765         void display_cleanup_results (ARDOUR::CleanupReport& rep, const gchar* list_title, const bool msg_delete);
766         void cleanup ();
767         void cleanup_peakfiles ();
768         void flush_trash ();
769
770         bool have_configure_timeout;
771         ARDOUR::microseconds_t last_configure_time;
772         gint configure_timeout ();
773
774         ARDOUR::microseconds_t last_peak_grab;
775         ARDOUR::microseconds_t last_shuttle_request;
776
777         bool have_disk_speed_dialog_displayed;
778         void disk_speed_dialog_gone (int ignored_response, Gtk::MessageDialog*);
779         void disk_overrun_handler ();
780         void disk_underrun_handler ();
781         void gui_idle_handler ();
782
783         void cancel_plugin_scan ();
784         void cancel_plugin_timeout ();
785         void plugin_scan_dialog (std::string type, std::string plugin, bool);
786         void plugin_scan_timeout (int);
787
788         void session_format_mismatch (std::string, std::string);
789
790         void session_dialog (std::string);
791         int pending_state_dialog ();
792         int sr_mismatch_dialog (ARDOUR::framecnt_t, ARDOUR::framecnt_t);
793         void sr_mismatch_message (ARDOUR::framecnt_t, ARDOUR::framecnt_t);
794
795         Gtk::MenuItem* jack_disconnect_item;
796         Gtk::MenuItem* jack_reconnect_item;
797         Gtk::Menu*     jack_bufsize_menu;
798
799         Glib::RefPtr<Gtk::ActionGroup> common_actions;
800
801         void editor_realized ();
802
803         std::vector<std::string> positional_sync_strings;
804
805         void toggle_use_mmc ();
806         void toggle_send_mmc ();
807         void toggle_send_mtc ();
808         void toggle_send_midi_clock ();
809
810         void toggle_use_osc ();
811
812         void parameter_changed (std::string);
813         void session_parameter_changed (std::string);
814
815         bool first_idle ();
816
817         void check_memory_locking ();
818
819         void audioengine_setup ();
820
821         void display_message (const char *prefix, gint prefix_len,
822                         Glib::RefPtr<Gtk::TextBuffer::Tag> ptag, Glib::RefPtr<Gtk::TextBuffer::Tag> mtag,
823                         const char *msg);
824         Gtk::Label status_bar_label;
825         bool status_bar_button_press (GdkEventButton*);
826
827         void loading_message (const std::string& msg);
828
829         PBD::ScopedConnectionList forever_connections;
830         PBD::ScopedConnection halt_connection;
831
832         void step_edit_status_change (bool);
833
834         /* these are used only in response to a platform-specific "ShouldQuit" signal */
835         bool idle_finish ();
836         void queue_finish ();
837         void fontconfig_dialog ();
838
839         int missing_file (ARDOUR::Session*s, std::string str, ARDOUR::DataType type);
840         int ambiguous_file (std::string file, std::vector<std::string> hits);
841
842         bool click_button_clicked (GdkEventButton *);
843         bool click_button_scroll (GdkEventScroll *);
844         bool sync_button_clicked (GdkEventButton *);
845
846         VisibilityGroup _status_bar_visibility;
847
848         /** A ProcessThread so that we have some thread-local buffers for use by
849          *  PluginEqGui::impulse_analysis ().
850          */
851         ARDOUR::ProcessThread* _process_thread;
852
853         void feedback_detected ();
854
855         ArdourButton             midi_panic_button;
856         void                     midi_panic ();
857
858         void successful_graph_sort ();
859         bool _feedback_exists;
860
861         enum ArdourLogLevel {
862                 LogLevelNone = 0,
863                 LogLevelInfo,
864                 LogLevelWarning,
865                 LogLevelError
866         };
867
868         ArdourLogLevel _log_not_acknowledged;
869
870         void resize_text_widgets ();
871
872         bool xrun_button_release (GdkEventButton* ev);
873
874         std::string _announce_string;
875         void check_announcements ();
876
877         int do_audio_midi_setup (uint32_t);
878         void audioengine_became_silent ();
879
880         DuplicateRouteDialog* duplicate_routes_dialog;
881
882         void grab_focus_after_dialog ();
883
884         void tabs_switch (GtkNotebookPage*, guint page_number);
885         void tabs_page_added (Gtk::Widget*, guint);
886         void tabs_page_removed (Gtk::Widget*, guint);
887         ArdourButton editor_visibility_button;
888         ArdourButton mixer_visibility_button;
889         ArdourButton prefs_visibility_button;
890
891         bool key_press_focus_accelerator_handler (Gtk::Window& window, GdkEventKey* ev, Gtkmm2ext::Bindings*);
892         bool try_gtk_accel_binding (GtkWindow* win, GdkEventKey* ev, bool translate, GdkModifierType modifier);
893
894         bool main_window_delete_event (GdkEventAny*);
895         bool idle_ask_about_quit ();
896
897         void load_bindings ();
898         bool tabbable_visibility_button_press (GdkEventButton* ev, std::string const& tabbable_name);
899
900         void step_up_through_tabs ();
901         void step_down_through_tabs ();
902
903         void escape ();
904         void close_current_dialog ();
905         void pre_release_dialog ();
906 };
907
908 #endif /* __ardour_gui_h__ */