2 Copyright (C) 2000 Paul Davis
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.
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.
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.
20 /* This file contains any ARDOUR_UI methods that require knowledge of
21 the various dialog boxes, and exists so that no compilation dependency
22 exists between the main ARDOUR_UI modules and their respective classes.
23 This is to cut down on the compile times. It also helps with my sanity.
28 #include "pbd/convert.h"
30 #include "ardour/audioengine.h"
31 #include "ardour/automation_watch.h"
32 #include "ardour/control_protocol_manager.h"
33 #include "ardour/profile.h"
34 #include "ardour/session.h"
36 #include "control_protocol/control_protocol.h"
38 #include "gtkmm2ext/keyboard.h"
39 #include "gtkmm2ext/utils.h"
42 #include "add_route_dialog.h"
43 #include "add_video_dialog.h"
44 #include "ardour_ui.h"
45 #include "big_clock_window.h"
46 #include "bundle_manager.h"
47 #include "global_port_matrix.h"
48 #include "gui_object.h"
49 #include "gui_thread.h"
50 #include "keyeditor.h"
51 #include "location_ui.h"
52 #include "lua_script_manager.h"
53 #include "luawindow.h"
54 #include "main_clock.h"
55 #include "meterbridge.h"
56 #include "meter_patterns.h"
57 #include "monitor_section.h"
58 #include "midi_tracer.h"
60 #include "public_editor.h"
61 #include "processor_box.h"
62 #include "rc_option_editor.h"
63 #include "route_params_ui.h"
64 #include "shuttle_control.h"
65 #include "session_option_editor.h"
66 #include "speaker_dialog.h"
69 #include "theme_manager.h"
70 #include "time_info_box.h"
75 using namespace ARDOUR;
79 using namespace Gtkmm2ext;
82 ARDOUR_UI::set_session (Session *s)
84 SessionHandlePtr::set_session (s);
87 WM::Manager::instance().set_session (s);
88 /* Session option editor cannot exist across change-of-session */
89 session_option_editor.drop_window ();
90 /* Ditto for AddVideoDialog */
91 add_video_dialog.drop_window ();
95 const XMLNode* node = _session->extra_xml (X_("UI"));
98 const XMLNodeList& children = node->children();
99 for (XMLNodeList::const_iterator i = children.begin(); i != children.end(); ++i) {
100 if ((*i)->name() == GUIObjectState::xml_node_name) {
101 gui_object_state->load (**i);
107 WM::Manager::instance().set_session (s);
109 AutomationWatch::instance().set_session (s);
112 shuttle_box->set_session (s);
115 primary_clock->set_session (s);
116 secondary_clock->set_session (s);
117 big_clock->set_session (s);
118 time_info_box->set_session (s);
119 video_timeline->set_session (s);
121 /* sensitize menu bar options that are now valid */
123 ActionManager::set_sensitive (ActionManager::session_sensitive_actions, true);
124 ActionManager::set_sensitive (ActionManager::write_sensitive_actions, _session->writable());
126 if (_session->locations()->num_range_markers()) {
127 ActionManager::set_sensitive (ActionManager::range_sensitive_actions, true);
129 ActionManager::set_sensitive (ActionManager::range_sensitive_actions, false);
132 if (!_session->monitor_out()) {
133 Glib::RefPtr<Action> act = ActionManager::get_action (X_("options"), X_("SoloViaBus"));
135 act->set_sensitive (false);
139 /* allow wastebasket flush again */
141 Glib::RefPtr<Action> act = ActionManager::get_action (X_("Main"), X_("FlushWastebasket"));
143 act->set_sensitive (true);
146 /* there are never any selections on startup */
148 ActionManager::set_sensitive (ActionManager::time_selection_sensitive_actions, false);
149 ActionManager::set_sensitive (ActionManager::track_selection_sensitive_actions, false);
150 ActionManager::set_sensitive (ActionManager::line_selection_sensitive_actions, false);
151 ActionManager::set_sensitive (ActionManager::point_selection_sensitive_actions, false);
152 ActionManager::set_sensitive (ActionManager::playlist_selection_sensitive_actions, false);
154 rec_button.set_sensitive (true);
156 solo_alert_button.set_active (_session->soloing());
158 setup_session_options ();
160 blink_connection = Timers::blink_connect (sigc::mem_fun(*this, &ARDOUR_UI::blink_handler));
162 _session->SaveSessionRequested.connect (_session_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::save_session_at_its_request, this, _1), gui_context());
163 _session->RecordStateChanged.connect (_session_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::record_state_changed, this), gui_context());
164 _session->StepEditStatusChange.connect (_session_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::step_edit_status_change, this, _1), gui_context());
165 _session->TransportStateChange.connect (_session_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::map_transport_state, this), gui_context());
166 _session->DirtyChanged.connect (_session_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::session_dirty_changed, this), gui_context());
168 _session->Xrun.connect (_session_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::xrun_handler, this, _1), gui_context());
169 _session->SoloActive.connect (_session_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::soloing_changed, this, _1), gui_context());
170 _session->AuditionActive.connect (_session_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::auditioning_changed, this, _1), gui_context());
171 _session->locations()->added.connect (_session_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::handle_locations_change, this, _1), gui_context());
172 _session->locations()->removed.connect (_session_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::handle_locations_change, this, _1), gui_context());
173 _session->config.ParameterChanged.connect (_session_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::session_parameter_changed, this, _1), gui_context ());
175 /* Clocks are on by default after we are connected to a session, so show that here.
178 connect_dependents_to_session (s);
180 /* listen to clock mode changes. don't do this earlier because otherwise as the clocks
181 restore their modes or are explicitly set, we will cause the "new" mode to be saved
182 back to the session XML ("Extra") state.
185 AudioClock::ModeChanged.connect (sigc::mem_fun (*this, &ARDOUR_UI::store_clock_modes));
187 Glib::signal_idle().connect (sigc::mem_fun (*this, &ARDOUR_UI::first_idle));
191 map_transport_state ();
193 second_connection = Timers::second_connect (sigc::mem_fun(*this, &ARDOUR_UI::every_second));
194 point_one_second_connection = Timers::rapid_connect (sigc::mem_fun(*this, &ARDOUR_UI::every_point_one_seconds));
195 point_zero_something_second_connection = Timers::super_rapid_connect (sigc::mem_fun(*this, &ARDOUR_UI::every_point_zero_something_seconds));
196 set_fps_timeout_connection();
200 if (meter_box.get_parent()) {
201 transport_hbox.remove (meter_box);
202 transport_hbox.remove (editor_meter_peak_display);
206 meter_box.remove(*editor_meter);
209 editor_meter_peak_display.hide();
212 if (meter_box.get_parent()) {
213 transport_hbox.remove (meter_box);
214 transport_hbox.remove (editor_meter_peak_display);
218 _session->master_out() &&
219 _session->master_out()->n_outputs().n(DataType::AUDIO) > 0) {
221 if (!ARDOUR::Profile->get_trx()) {
222 editor_meter = new LevelMeterHBox(_session);
223 editor_meter->set_meter (_session->master_out()->shared_peak_meter().get());
224 editor_meter->clear_meters();
225 editor_meter->set_type (_session->master_out()->meter_type());
226 editor_meter->setup_meters (30, 12, 6);
227 editor_meter->show();
228 meter_box.pack_start(*editor_meter);
231 ArdourMeter::ResetAllPeakDisplays.connect (sigc::mem_fun(*this, &ARDOUR_UI::reset_peak_display));
232 ArdourMeter::ResetRoutePeakDisplays.connect (sigc::mem_fun(*this, &ARDOUR_UI::reset_route_peak_display));
233 ArdourMeter::ResetGroupPeakDisplays.connect (sigc::mem_fun(*this, &ARDOUR_UI::reset_group_peak_display));
235 editor_meter_peak_display.set_name ("meterbridge peakindicator");
236 editor_meter_peak_display.unset_flags (Gtk::CAN_FOCUS);
237 editor_meter_peak_display.set_size_request (std::max(9.f, rintf(8.f * UIConfiguration::instance().get_ui_scale())), -1);
238 editor_meter_peak_display.set_corner_radius (3.0);
240 editor_meter_max_peak = -INFINITY;
241 editor_meter_peak_display.signal_button_release_event().connect (sigc::mem_fun(*this, &ARDOUR_UI::editor_meter_peak_button_release), false);
243 if (UIConfiguration::instance().get_show_editor_meter() && !ARDOUR::Profile->get_trx()) {
244 transport_hbox.pack_start (meter_box, false, false);
245 transport_hbox.pack_start (editor_meter_peak_display, false, false);
247 editor_meter_peak_display.show();
255 ARDOUR_UI::unload_session (bool hide_stuff)
258 ARDOUR_UI::instance()->video_timeline->sync_session_state();
261 if (_session && _session->dirty()) {
262 std::vector<std::string> actions;
263 actions.push_back (_("Don't close"));
264 actions.push_back (_("Just close"));
265 actions.push_back (_("Save and close"));
266 switch (ask_about_saving_session (actions)) {
272 _session->save_state ("");
278 // tear down session specific CPI (owned by rc_config_editor which can remain)
279 ControlProtocolManager& m = ControlProtocolManager::instance ();
280 for (std::list<ControlProtocolInfo*>::iterator i = m.control_protocol_info.begin(); i != m.control_protocol_info.end(); ++i) {
281 if (*i && (*i)->protocol && (*i)->protocol->has_editor ()) {
282 (*i)->protocol->tear_down_gui ();
290 meterbridge->hide ();
291 audio_port_matrix->hide();
292 midi_port_matrix->hide();
293 route_params->hide();
296 second_connection.disconnect ();
297 point_one_second_connection.disconnect ();
298 point_zero_something_second_connection.disconnect();
299 fps_connection.disconnect();
302 meter_box.remove(*editor_meter);
305 editor_meter_peak_display.hide();
308 ActionManager::set_sensitive (ActionManager::session_sensitive_actions, false);
310 rec_button.set_sensitive (false);
312 WM::Manager::instance().set_session ((ARDOUR::Session*) 0);
314 if (ARDOUR_UI::instance()->video_timeline) {
315 ARDOUR_UI::instance()->video_timeline->close_session();
320 /* drop everything attached to the blink signal */
322 blink_connection.disconnect ();
327 session_loaded = false;
329 update_buffer_load ();
336 ARDOUR_UI::toggle_editor_and_mixer ()
338 if (editor->tabbed() && mixer->tabbed()) {
339 /* both in the same window */
340 if (_tabs.get_current_page() == _tabs.page_num (editor->contents())) {
341 _tabs.set_current_page (_tabs.page_num (mixer->contents()));
342 } else if (_tabs.get_current_page() == _tabs.page_num (mixer->contents())) {
343 _tabs.set_current_page (_tabs.page_num (editor->contents()));
346 _tabs.set_current_page (_tabs.page_num (mixer->contents()));
352 if (editor->tabbed() && !mixer->tabbed()) {
353 /* editor is tabbed, mixer is not */
355 Gtk::Window* mwin = mixer->current_toplevel ();
358 /* mixer's own window doesn't exist */
359 mixer->make_visible ();
360 } else if (!mwin->is_mapped ()) {
361 /* mixer's own window exists but isn't mapped */
362 mixer->make_visible ();
364 /* mixer window is mapped, editor is visible as tab */
365 Gtk::Widget* f = mwin->get_focus();
366 if (f && f->has_focus()) {
367 /* mixer has focus, switch to editor */
368 editor->make_visible ();
370 mixer->make_visible ();
376 if (!editor->tabbed() && mixer->tabbed()) {
377 /* mixer is tabbed, editor is not */
379 Gtk::Window* ewin = editor->current_toplevel ();
382 /* mixer's own window doesn't exist */
383 editor->make_visible ();
384 } else if (!ewin->is_mapped ()) {
385 /* editor's own window exists but isn't mapped */
386 editor->make_visible ();
388 /* editor window is mapped, mixer is visible as tab */
389 Gtk::Widget* f = ewin->get_focus();
390 if (f && f->has_focus()) {
391 /* editor has focus, switch to mixer */
392 mixer->make_visible ();
394 editor->make_visible ();
402 ARDOUR_UI::step_up_through_tabs ()
404 std::vector<Tabbable*> candidates;
406 /* this list must match the order of visibility buttons */
408 if (!editor->window_visible()) {
409 candidates.push_back (editor);
412 if (!mixer->window_visible()) {
413 candidates.push_back (mixer);
416 if (!rc_option_editor->window_visible()) {
417 candidates.push_back (rc_option_editor);
420 if (candidates.size() < 2) {
421 /* nothing to be done with zero or one visible in tabs */
425 std::vector<Tabbable*>::iterator prev = candidates.end();
426 std::vector<Tabbable*>::iterator i;
427 Gtk::Widget* w = _tabs.get_nth_page (_tabs.get_current_page ());
429 for (i = candidates.begin(); i != candidates.end(); ++i) {
430 if (w == &(*i)->contents()) {
431 if (prev != candidates.end()) {
432 _tabs.set_current_page (_tabs.page_num ((*prev)->contents()));
434 _tabs.set_current_page (_tabs.page_num (candidates.back()->contents()));
443 ARDOUR_UI::step_down_through_tabs ()
445 std::vector<Tabbable*> candidates;
447 /* this list must match the order of visibility buttons */
449 if (!editor->window_visible()) {
450 candidates.push_back (editor);
453 if (!mixer->window_visible()) {
454 candidates.push_back (mixer);
457 if (!rc_option_editor->window_visible()) {
458 candidates.push_back (rc_option_editor);
461 if (candidates.size() < 2) {
462 /* nothing to be done with zero or one visible in tabs */
466 std::vector<Tabbable*>::reverse_iterator next = candidates.rend();
467 std::vector<Tabbable*>::reverse_iterator i;
468 Gtk::Widget* w = _tabs.get_nth_page (_tabs.get_current_page ());
470 for (i = candidates.rbegin(); i != candidates.rend(); ++i) {
471 if (w == &(*i)->contents()) {
472 if (next != candidates.rend()) {
473 _tabs.set_current_page (_tabs.page_num ((*next)->contents()));
475 _tabs.set_current_page (_tabs.page_num (candidates.front()->contents()));
484 ARDOUR_UI::key_change_tabbable_visibility (Tabbable* t)
491 _tabs.set_current_page (_tabs.page_num (t->contents()));
492 } else if (!t->fully_visible()) {
495 _main_window.present ();
500 ARDOUR_UI::button_change_tabbable_visibility (Tabbable* t)
502 /* For many/most users, clicking a button in the main window will make it
503 the main/front/key window, which will change any stacking relationship they
504 were trying to modify by clicking on the button in the first
505 place. This button-aware method knows that click on
506 a button designed to show/hide a Tabbable that has its own window
507 will have made that window be obscured (as the main window comes to
508 the front). We therefore *hide* the Tabbable's window if it is even
509 partially visible, believing that this is likely because the
510 Tabbable window used to be front, the user clicked to change that,
511 and before we even get here, the main window has become front.
519 _tabs.set_current_page (_tabs.page_num (t->contents()));
520 } else if (t->visible()) {
528 ARDOUR_UI::show_tabbable (Tabbable* t)
538 ARDOUR_UI::hide_tabbable (Tabbable* t)
543 t->make_invisible ();
547 ARDOUR_UI::attach_tabbable (Tabbable* t)
557 ARDOUR_UI::detach_tabbable (Tabbable* t)
566 ARDOUR_UI::tabs_page_added (Widget*,guint)
568 if (_tabs.get_n_pages() > 1) {
570 std::vector<TargetEntry> drag_target_entries;
571 drag_target_entries.push_back (TargetEntry ("tabbable"));
573 editor_visibility_button.drag_source_set (drag_target_entries);
574 mixer_visibility_button.drag_source_set (drag_target_entries);
575 prefs_visibility_button.drag_source_set (drag_target_entries);
577 editor_visibility_button.drag_source_set_icon (Gtkmm2ext::pixbuf_from_string (editor->name(),
578 Pango::FontDescription ("Sans 24"),
580 Gdk::Color ("red")));
581 mixer_visibility_button.drag_source_set_icon (Gtkmm2ext::pixbuf_from_string (mixer->name(),
582 Pango::FontDescription ("Sans 24"),
584 Gdk::Color ("red")));
585 prefs_visibility_button.drag_source_set_icon (Gtkmm2ext::pixbuf_from_string (rc_option_editor->name(),
586 Pango::FontDescription ("Sans 24"),
588 Gdk::Color ("red")));
593 ARDOUR_UI::tabs_page_removed (Widget*, guint)
595 if (_tabs.get_n_pages() < 2) {
596 editor_visibility_button.drag_source_unset ();
597 mixer_visibility_button.drag_source_unset ();
598 prefs_visibility_button.drag_source_unset ();
603 ARDOUR_UI::tabs_switch (GtkNotebookPage*, guint page)
605 if (editor && (page == (guint) _tabs.page_num (editor->contents()))) {
606 editor_visibility_button.set_active_state (Gtkmm2ext::ImplicitActive);
608 if (mixer && (mixer->tabbed() || mixer->tabbed_by_default())) {
609 mixer_visibility_button.set_active_state (Gtkmm2ext::Off);
612 if (rc_option_editor && (rc_option_editor->tabbed() || rc_option_editor->tabbed_by_default())) {
613 prefs_visibility_button.set_active_state (Gtkmm2ext::Off);
615 } else if (mixer && (page == (guint) _tabs.page_num (mixer->contents()))) {
617 if (editor && (editor->tabbed() || editor->tabbed_by_default())) {
618 editor_visibility_button.set_active_state (Gtkmm2ext::Off);
621 mixer_visibility_button.set_active_state (Gtkmm2ext::ImplicitActive);
623 if (rc_option_editor && (rc_option_editor->tabbed() || rc_option_editor->tabbed_by_default())) {
624 prefs_visibility_button.set_active_state (Gtkmm2ext::Off);
627 } else if (page == (guint) _tabs.page_num (rc_option_editor->contents())) {
629 if (editor && (editor->tabbed() || editor->tabbed_by_default())) {
630 editor_visibility_button.set_active_state (Gtkmm2ext::Off);
633 if (mixer && (mixer->tabbed() || mixer->tabbed_by_default())) {
634 mixer_visibility_button.set_active_state (Gtkmm2ext::Off);
637 prefs_visibility_button.set_active_state (Gtkmm2ext::ImplicitActive);
643 ARDOUR_UI::tabbable_state_change (Tabbable& t)
645 std::vector<std::string> insensitive_action_names;
646 std::vector<std::string> sensitive_action_names;
647 std::vector<std::string> active_action_names;
648 std::vector<std::string> inactive_action_names;
649 Glib::RefPtr<Action> action;
650 std::string downcased_name = downcase (t.name());
660 insensitive_action_names.push_back (string_compose ("attach-%1", downcased_name));
661 sensitive_action_names.push_back (string_compose ("show-%1", downcased_name));
662 sensitive_action_names.push_back (string_compose ("detach-%1", downcased_name));
663 sensitive_action_names.push_back (string_compose ("hide-%1", downcased_name));
667 } else if (t.tabbed_by_default ()) {
669 insensitive_action_names.push_back (string_compose ("attach-%1", downcased_name));
670 insensitive_action_names.push_back (string_compose ("hide-%1", downcased_name));
671 sensitive_action_names.push_back (string_compose ("show-%1", downcased_name));
672 sensitive_action_names.push_back (string_compose ("detach-%1", downcased_name));
676 } else if (t.window_visible()) {
678 insensitive_action_names.push_back (string_compose ("detach-%1", downcased_name));
679 sensitive_action_names.push_back (string_compose ("show-%1", downcased_name));
680 sensitive_action_names.push_back (string_compose ("attach-%1", downcased_name));
681 sensitive_action_names.push_back (string_compose ("hide-%1", downcased_name));
683 active_action_names.push_back (string_compose ("show-%1", downcased_name));
684 inactive_action_names.push_back (string_compose ("hide-%1", downcased_name));
690 /* not currently visible. allow user to retab it or just make
694 insensitive_action_names.push_back (string_compose ("detach-%1", downcased_name));
695 insensitive_action_names.push_back (string_compose ("hide-%1", downcased_name));
696 sensitive_action_names.push_back (string_compose ("show-%1", downcased_name));
697 sensitive_action_names.push_back (string_compose ("attach-%1", downcased_name));
699 active_action_names.push_back (string_compose ("hide-%1", downcased_name));
700 inactive_action_names.push_back (string_compose ("show-%1", downcased_name));
705 for (std::vector<std::string>::iterator s = insensitive_action_names.begin(); s != insensitive_action_names.end(); ++s) {
706 action = ActionManager::get_action (X_("Common"), (*s).c_str());
708 action->set_sensitive (false);
712 for (std::vector<std::string>::iterator s = sensitive_action_names.begin(); s != sensitive_action_names.end(); ++s) {
713 action = ActionManager::get_action (X_("Common"), (*s).c_str());
715 action->set_sensitive (true);
719 ArdourButton* vis_button = 0;
720 std::vector<ArdourButton*> other_vis_buttons;
723 vis_button = &editor_visibility_button;
724 other_vis_buttons.push_back (&mixer_visibility_button);
725 other_vis_buttons.push_back (&prefs_visibility_button);
726 } else if (&t == mixer) {
727 vis_button = &mixer_visibility_button;
728 other_vis_buttons.push_back (&editor_visibility_button);
729 other_vis_buttons.push_back (&prefs_visibility_button);
730 } else if (&t == rc_option_editor) {
731 vis_button = &prefs_visibility_button;
732 other_vis_buttons.push_back (&editor_visibility_button);
733 other_vis_buttons.push_back (&mixer_visibility_button);
742 vis_button->set_active_state (Gtkmm2ext::ImplicitActive);
745 vis_button->set_active_state (Gtkmm2ext::ExplicitActive);
748 vis_button->set_active_state (Gtkmm2ext::Off);
752 for (std::vector<ArdourButton*>::iterator b = other_vis_buttons.begin(); b != other_vis_buttons.end(); ++b) {
753 (*b)->set_active_state (Gtkmm2ext::Off);
758 ARDOUR_UI::toggle_meterbridge ()
760 assert (editor && mixer && meterbridge);
763 bool obscuring = false;
765 if (meterbridge->not_visible ()) {
767 } else if ((editor->window_visible() && ARDOUR_UI_UTILS::windows_overlap (editor->own_window(), meterbridge)) ||
768 (mixer->window_visible () && ARDOUR_UI_UTILS::windows_overlap (mixer->own_window(), meterbridge))) {
772 if (obscuring && ((editor->own_window() && editor->own_window()->property_has_toplevel_focus()) ||
773 (mixer->own_window() && mixer->own_window()->property_has_toplevel_focus()))) {
778 meterbridge->show_window ();
779 meterbridge->present ();
780 meterbridge->raise ();
782 meterbridge->hide_window (NULL);
787 ARDOUR_UI::toggle_luawindow ()
789 assert (editor && luawindow);
793 if (luawindow->not_visible ()) {
796 // TODO check overlap
799 luawindow->show_window ();
800 luawindow->present ();
803 luawindow->hide_window (NULL);
809 ARDOUR_UI::new_midi_tracer_window ()
811 RefPtr<Action> act = ActionManager::get_action (X_("Common"), X_("NewMIDITracer"));
816 std::list<MidiTracer*>::iterator i = _midi_tracer_windows.begin ();
817 while (i != _midi_tracer_windows.end() && (*i)->get_visible() == true) {
821 if (i == _midi_tracer_windows.end()) {
822 /* all our MIDITracer windows are visible; make a new one */
823 MidiTracer* t = new MidiTracer ();
825 _midi_tracer_windows.push_back (t);
827 /* re-use the hidden one */
833 ARDOUR_UI::create_key_editor ()
835 KeyEditor* kedit = new KeyEditor;
837 for (std::list<Bindings*>::iterator b = Bindings::bindings.begin(); b != Bindings::bindings.end(); ++b) {
838 kedit->add_tab ((*b)->name(), **b);
845 ARDOUR_UI::create_bundle_manager ()
847 return new BundleManager (_session);
851 ARDOUR_UI::create_add_video_dialog ()
853 return new AddVideoDialog (_session);
857 ARDOUR_UI::create_session_option_editor ()
859 return new SessionOptionEditor (_session);
863 ARDOUR_UI::create_big_clock_window ()
865 return new BigClockWindow (*big_clock);
869 ARDOUR_UI::handle_locations_change (Location *)
872 if (_session->locations()->num_range_markers()) {
873 ActionManager::set_sensitive (ActionManager::range_sensitive_actions, true);
875 ActionManager::set_sensitive (ActionManager::range_sensitive_actions, false);
881 ARDOUR_UI::tabbed_window_state_event_handler (GdkEventWindowState* ev, void* object)
883 if (object == editor) {
885 if ((ev->changed_mask & GDK_WINDOW_STATE_FULLSCREEN) &&
886 (ev->new_window_state & GDK_WINDOW_STATE_FULLSCREEN)) {
887 if (big_clock_window) {
888 big_clock_window->set_transient_for (*editor->own_window());
892 } else if (object == mixer) {
894 if ((ev->changed_mask & GDK_WINDOW_STATE_FULLSCREEN) &&
895 (ev->new_window_state & GDK_WINDOW_STATE_FULLSCREEN)) {
896 if (big_clock_window) {
897 big_clock_window->set_transient_for (*mixer->own_window());
906 ARDOUR_UI::editor_meter_peak_button_release (GdkEventButton* ev)
908 if (ev->button == 1 && Gtkmm2ext::Keyboard::modifier_state_equals (ev->state, Gtkmm2ext::Keyboard::PrimaryModifier|Gtkmm2ext::Keyboard::TertiaryModifier)) {
909 ArdourMeter::ResetAllPeakDisplays ();
910 } else if (ev->button == 1 && Gtkmm2ext::Keyboard::modifier_state_equals (ev->state, Gtkmm2ext::Keyboard::PrimaryModifier)) {
911 if (_session->master_out()) {
912 ArdourMeter::ResetGroupPeakDisplays (_session->master_out()->route_group());
914 } else if (_session->master_out()) {
915 ArdourMeter::ResetRoutePeakDisplays (_session->master_out().get());
921 ARDOUR_UI::toggle_mixer_space()
923 Glib::RefPtr<Action> act = ActionManager::get_action ("Common", "ToggleMaximalMixer");
926 Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
927 if (tact->get_active()) {
928 mixer->maximise_mixer_space ();
930 mixer->restore_mixer_space ();
936 ARDOUR_UI::toggle_mixer_list()
938 Glib::RefPtr<Action> act = ActionManager::get_action ("Common", "ToggleMixerList");
941 Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
942 mixer->show_mixer_list (tact->get_active());
947 ARDOUR_UI::toggle_monitor_section_visibility ()
949 Glib::RefPtr<Action> act = ActionManager::get_action ("Common", "ToggleMonitorSection");
952 Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
953 mixer->show_monitor_section (tact->get_active());