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 <gtkmm/treemodelfilter.h>
30 #include "pbd/convert.h"
32 #include "ardour/audioengine.h"
33 #include "ardour/automation_watch.h"
34 #include "ardour/control_protocol_manager.h"
35 #include "ardour/profile.h"
36 #include "ardour/session.h"
38 #include "control_protocol/control_protocol.h"
40 #include "gtkmm2ext/keyboard.h"
41 #include "gtkmm2ext/utils.h"
44 #include "add_route_dialog.h"
45 #include "add_video_dialog.h"
46 #include "ardour_ui.h"
47 #include "big_clock_window.h"
48 #include "bundle_manager.h"
49 #include "global_port_matrix.h"
50 #include "gui_object.h"
51 #include "gui_thread.h"
52 #include "keyeditor.h"
53 #include "location_ui.h"
54 #include "lua_script_manager.h"
55 #include "luawindow.h"
56 #include "main_clock.h"
57 #include "meterbridge.h"
58 #include "meter_patterns.h"
59 #include "monitor_section.h"
60 #include "midi_tracer.h"
61 #include "mini_timeline.h"
63 #include "public_editor.h"
64 #include "processor_box.h"
65 #include "rc_option_editor.h"
66 #include "route_params_ui.h"
67 #include "shuttle_control.h"
68 #include "session_option_editor.h"
69 #include "speaker_dialog.h"
72 #include "time_info_box.h"
77 using namespace ARDOUR;
81 using namespace Gtkmm2ext;
82 using namespace ArdourWidgets;
85 ARDOUR_UI::set_session (Session *s)
87 SessionHandlePtr::set_session (s);
90 WM::Manager::instance().set_session (s);
91 /* Session option editor cannot exist across change-of-session */
92 session_option_editor.drop_window ();
93 /* Ditto for AddVideoDialog */
94 add_video_dialog.drop_window ();
98 const XMLNode* node = _session->extra_xml (X_("UI"));
101 const XMLNodeList& children = node->children();
102 for (XMLNodeList::const_iterator i = children.begin(); i != children.end(); ++i) {
103 if ((*i)->name() == GUIObjectState::xml_node_name) {
104 gui_object_state->load (**i);
110 WM::Manager::instance().set_session (s);
112 AutomationWatch::instance().set_session (s);
114 shuttle_box.set_session (s);
115 mini_timeline.set_session (s);
116 time_info_box->set_session (s);
118 primary_clock->set_session (s);
119 secondary_clock->set_session (s);
120 big_clock->set_session (s);
121 video_timeline->set_session (s);
122 lua_script_window->set_session (s);
124 /* sensitize menu bar options that are now valid */
126 ActionManager::set_sensitive (ActionManager::session_sensitive_actions, true);
127 ActionManager::set_sensitive (ActionManager::write_sensitive_actions, _session->writable());
129 if (_session->locations()->num_range_markers()) {
130 ActionManager::set_sensitive (ActionManager::range_sensitive_actions, true);
132 ActionManager::set_sensitive (ActionManager::range_sensitive_actions, false);
135 if (!_session->monitor_out()) {
136 Glib::RefPtr<Action> act = ActionManager::get_action (X_("options"), X_("SoloViaBus"));
138 act->set_sensitive (false);
142 /* allow wastebasket flush again */
144 Glib::RefPtr<Action> act = ActionManager::get_action (X_("Main"), X_("FlushWastebasket"));
146 act->set_sensitive (true);
149 /* there are never any selections on startup */
151 ActionManager::set_sensitive (ActionManager::time_selection_sensitive_actions, false);
152 ActionManager::set_sensitive (ActionManager::track_selection_sensitive_actions, false);
153 ActionManager::set_sensitive (ActionManager::route_selection_sensitive_actions, false);
154 ActionManager::set_sensitive (ActionManager::bus_selection_sensitive_actions, false);
155 ActionManager::set_sensitive (ActionManager::vca_selection_sensitive_actions, false);
156 ActionManager::set_sensitive (ActionManager::stripable_selection_sensitive_actions, false);
157 ActionManager::set_sensitive (ActionManager::line_selection_sensitive_actions, false);
158 ActionManager::set_sensitive (ActionManager::point_selection_sensitive_actions, false);
159 ActionManager::set_sensitive (ActionManager::playlist_selection_sensitive_actions, false);
161 rec_button.set_sensitive (true);
163 solo_alert_button.set_active (_session->soloing());
165 setup_session_options ();
167 blink_connection = Timers::blink_connect (sigc::mem_fun(*this, &ARDOUR_UI::blink_handler));
169 _session->SaveSessionRequested.connect (_session_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::save_session_at_its_request, this, _1), gui_context());
170 _session->StateSaved.connect (_session_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::update_title, this), gui_context());
171 _session->RecordStateChanged.connect (_session_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::record_state_changed, this), gui_context());
172 _session->StepEditStatusChange.connect (_session_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::step_edit_status_change, this, _1), gui_context());
173 _session->TransportStateChange.connect (_session_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::map_transport_state, this), gui_context());
174 _session->DirtyChanged.connect (_session_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::session_dirty_changed, this), gui_context());
176 _session->Xrun.connect (_session_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::xrun_handler, this, _1), gui_context());
177 _session->SoloActive.connect (_session_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::soloing_changed, this, _1), gui_context());
178 _session->AuditionActive.connect (_session_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::auditioning_changed, this, _1), gui_context());
179 _session->locations()->added.connect (_session_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::handle_locations_change, this, _1), gui_context());
180 _session->locations()->removed.connect (_session_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::handle_locations_change, this, _1), gui_context());
181 _session->config.ParameterChanged.connect (_session_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::session_parameter_changed, this, _1), gui_context ());
182 _session->auto_loop_location_changed.connect (_session_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::set_loop_sensitivity, this), gui_context ());
184 /* Clocks are on by default after we are connected to a session, so show that here.
187 connect_dependents_to_session (s);
189 /* listen to clock mode changes. don't do this earlier because otherwise as the clocks
190 restore their modes or are explicitly set, we will cause the "new" mode to be saved
191 back to the session XML ("Extra") state.
194 AudioClock::ModeChanged.connect (sigc::mem_fun (*this, &ARDOUR_UI::store_clock_modes));
196 Glib::signal_idle().connect (sigc::mem_fun (*this, &ARDOUR_UI::first_idle));
200 map_transport_state ();
202 second_connection = Timers::second_connect (sigc::mem_fun(*this, &ARDOUR_UI::every_second));
203 point_one_second_connection = Timers::rapid_connect (sigc::mem_fun(*this, &ARDOUR_UI::every_point_one_seconds));
204 point_zero_something_second_connection = Timers::super_rapid_connect (sigc::mem_fun(*this, &ARDOUR_UI::every_point_zero_something_seconds));
205 set_fps_timeout_connection();
209 if (meter_box.get_parent()) {
210 transport_hbox.remove (meter_box);
211 transport_hbox.remove (editor_meter_peak_display);
215 meter_box.remove(*editor_meter);
218 editor_meter_peak_display.hide();
221 if (meter_box.get_parent()) {
222 transport_hbox.remove (meter_box);
223 transport_hbox.remove (editor_meter_peak_display);
227 _session->master_out() &&
228 _session->master_out()->n_outputs().n(DataType::AUDIO) > 0) {
230 if (!ARDOUR::Profile->get_trx()) {
231 editor_meter = new LevelMeterHBox(_session);
232 editor_meter->set_meter (_session->master_out()->shared_peak_meter().get());
233 editor_meter->clear_meters();
234 editor_meter->set_meter_type (_session->master_out()->meter_type());
235 editor_meter->setup_meters (30, 10, 6);
236 editor_meter->show();
237 meter_box.pack_start(*editor_meter);
239 editor_meter->ButtonPress.connect_same_thread (editor_meter_connection, boost::bind (&ARDOUR_UI::editor_meter_button_press, this, _1));
242 ArdourMeter::ResetAllPeakDisplays.connect (sigc::mem_fun(*this, &ARDOUR_UI::reset_peak_display));
243 ArdourMeter::ResetRoutePeakDisplays.connect (sigc::mem_fun(*this, &ARDOUR_UI::reset_route_peak_display));
244 ArdourMeter::ResetGroupPeakDisplays.connect (sigc::mem_fun(*this, &ARDOUR_UI::reset_group_peak_display));
246 editor_meter_peak_display.set_name ("meterbridge peakindicator");
247 editor_meter_peak_display.unset_flags (Gtk::CAN_FOCUS);
248 editor_meter_peak_display.set_size_request (std::max(9.f, rintf(8.f * UIConfiguration::instance().get_ui_scale())), -1);
249 editor_meter_peak_display.set_corner_radius (3.0);
251 editor_meter_max_peak = -INFINITY;
252 editor_meter_peak_display.signal_button_release_event().connect (sigc::mem_fun(*this, &ARDOUR_UI::editor_meter_peak_button_release), false);
254 repack_transport_hbox ();
261 ARDOUR_UI::unload_session (bool hide_stuff)
264 ARDOUR_UI::instance()->video_timeline->sync_session_state();
267 if (_session && _session->dirty()) {
268 std::vector<std::string> actions;
269 actions.push_back (_("Don't close"));
270 actions.push_back (_("Just close"));
271 actions.push_back (_("Save and close"));
272 switch (ask_about_saving_session (actions)) {
278 _session->save_state ("");
284 // tear down session specific CPI (owned by rc_config_editor which can remain)
285 ControlProtocolManager& m = ControlProtocolManager::instance ();
286 for (std::list<ControlProtocolInfo*>::iterator i = m.control_protocol_info.begin(); i != m.control_protocol_info.end(); ++i) {
287 if (*i && (*i)->protocol && (*i)->protocol->has_editor ()) {
288 (*i)->protocol->tear_down_gui ();
294 close_all_dialogs ();
297 meterbridge->hide ();
298 audio_port_matrix->hide();
299 midi_port_matrix->hide();
300 route_params->hide();
303 second_connection.disconnect ();
304 point_one_second_connection.disconnect ();
305 point_zero_something_second_connection.disconnect();
306 fps_connection.disconnect();
309 meter_box.remove(*editor_meter);
312 editor_meter_peak_display.hide();
315 ActionManager::set_sensitive (ActionManager::session_sensitive_actions, false);
317 rec_button.set_sensitive (false);
319 WM::Manager::instance().set_session ((ARDOUR::Session*) 0);
321 if (ARDOUR_UI::instance()->video_timeline) {
322 ARDOUR_UI::instance()->video_timeline->close_session();
327 /* drop everything attached to the blink signal */
329 blink_connection.disconnect ();
334 session_loaded = false;
336 update_buffer_load ();
343 ARDOUR_UI::toggle_editor_and_mixer ()
345 if (editor->tabbed() && mixer->tabbed()) {
346 /* both in the same window */
347 if (_tabs.get_current_page() == _tabs.page_num (editor->contents())) {
348 _tabs.set_current_page (_tabs.page_num (mixer->contents()));
349 } else if (_tabs.get_current_page() == _tabs.page_num (mixer->contents())) {
350 _tabs.set_current_page (_tabs.page_num (editor->contents()));
353 _tabs.set_current_page (_tabs.page_num (mixer->contents()));
359 if (editor->tabbed() && !mixer->tabbed()) {
360 /* editor is tabbed, mixer is not */
362 Gtk::Window* mwin = mixer->current_toplevel ();
365 /* mixer's own window doesn't exist */
366 mixer->make_visible ();
367 } else if (!mwin->is_mapped ()) {
368 /* mixer's own window exists but isn't mapped */
369 mixer->make_visible ();
371 /* mixer window is mapped, editor is visible as tab */
372 Gtk::Widget* f = mwin->get_focus();
373 if (f && f->has_focus()) {
374 /* mixer has focus, switch to editor */
375 editor->make_visible ();
377 mixer->make_visible ();
383 if (!editor->tabbed() && mixer->tabbed()) {
384 /* mixer is tabbed, editor is not */
386 Gtk::Window* ewin = editor->current_toplevel ();
389 /* mixer's own window doesn't exist */
390 editor->make_visible ();
391 } else if (!ewin->is_mapped ()) {
392 /* editor's own window exists but isn't mapped */
393 editor->make_visible ();
395 /* editor window is mapped, mixer is visible as tab */
396 Gtk::Widget* f = ewin->get_focus();
397 if (f && f->has_focus()) {
398 /* editor has focus, switch to mixer */
399 mixer->make_visible ();
401 editor->make_visible ();
409 ARDOUR_UI::step_up_through_tabs ()
411 std::vector<Tabbable*> candidates;
413 /* this list must match the order of visibility buttons */
415 if (!editor->window_visible()) {
416 candidates.push_back (editor);
419 if (!mixer->window_visible()) {
420 candidates.push_back (mixer);
423 if (!rc_option_editor->window_visible()) {
424 candidates.push_back (rc_option_editor);
427 if (candidates.size() < 2) {
428 /* nothing to be done with zero or one visible in tabs */
432 std::vector<Tabbable*>::iterator prev = candidates.end();
433 std::vector<Tabbable*>::iterator i;
434 Gtk::Widget* w = _tabs.get_nth_page (_tabs.get_current_page ());
436 for (i = candidates.begin(); i != candidates.end(); ++i) {
437 if (w == &(*i)->contents()) {
438 if (prev != candidates.end()) {
439 _tabs.set_current_page (_tabs.page_num ((*prev)->contents()));
441 _tabs.set_current_page (_tabs.page_num (candidates.back()->contents()));
450 ARDOUR_UI::step_down_through_tabs ()
452 std::vector<Tabbable*> candidates;
454 /* this list must match the order of visibility buttons */
456 if (!editor->window_visible()) {
457 candidates.push_back (editor);
460 if (!mixer->window_visible()) {
461 candidates.push_back (mixer);
464 if (!rc_option_editor->window_visible()) {
465 candidates.push_back (rc_option_editor);
468 if (candidates.size() < 2) {
469 /* nothing to be done with zero or one visible in tabs */
473 std::vector<Tabbable*>::reverse_iterator next = candidates.rend();
474 std::vector<Tabbable*>::reverse_iterator i;
475 Gtk::Widget* w = _tabs.get_nth_page (_tabs.get_current_page ());
477 for (i = candidates.rbegin(); i != candidates.rend(); ++i) {
478 if (w == &(*i)->contents()) {
479 if (next != candidates.rend()) {
480 _tabs.set_current_page (_tabs.page_num ((*next)->contents()));
482 _tabs.set_current_page (_tabs.page_num (candidates.front()->contents()));
491 ARDOUR_UI::key_change_tabbable_visibility (Tabbable* t)
498 _tabs.set_current_page (_tabs.page_num (t->contents()));
499 } else if (!t->fully_visible()) {
502 _main_window.present ();
507 ARDOUR_UI::button_change_tabbable_visibility (Tabbable* t)
509 /* For many/most users, clicking a button in the main window will make it
510 the main/front/key window, which will change any stacking relationship they
511 were trying to modify by clicking on the button in the first
512 place. This button-aware method knows that click on
513 a button designed to show/hide a Tabbable that has its own window
514 will have made that window be obscured (as the main window comes to
515 the front). We therefore *hide* the Tabbable's window if it is even
516 partially visible, believing that this is likely because the
517 Tabbable window used to be front, the user clicked to change that,
518 and before we even get here, the main window has become front.
526 _tabs.set_current_page (_tabs.page_num (t->contents()));
527 } else if (t->visible()) {
535 ARDOUR_UI::show_tabbable (Tabbable* t)
545 ARDOUR_UI::hide_tabbable (Tabbable* t)
550 t->make_invisible ();
554 ARDOUR_UI::attach_tabbable (Tabbable* t)
564 ARDOUR_UI::detach_tabbable (Tabbable* t)
573 ARDOUR_UI::tabs_page_added (Widget*,guint)
575 if (_tabs.get_n_pages() > 1) {
577 std::vector<TargetEntry> drag_target_entries;
578 drag_target_entries.push_back (TargetEntry ("tabbable"));
580 editor_visibility_button.drag_source_set (drag_target_entries);
581 mixer_visibility_button.drag_source_set (drag_target_entries);
582 prefs_visibility_button.drag_source_set (drag_target_entries);
584 editor_visibility_button.drag_source_set_icon (Gtkmm2ext::pixbuf_from_string (editor->name(),
585 Pango::FontDescription ("Sans 24"),
587 Gdk::Color ("red")));
588 mixer_visibility_button.drag_source_set_icon (Gtkmm2ext::pixbuf_from_string (mixer->name(),
589 Pango::FontDescription ("Sans 24"),
591 Gdk::Color ("red")));
592 prefs_visibility_button.drag_source_set_icon (Gtkmm2ext::pixbuf_from_string (rc_option_editor->name(),
593 Pango::FontDescription ("Sans 24"),
595 Gdk::Color ("red")));
600 ARDOUR_UI::tabs_page_removed (Widget*, guint)
602 if (_tabs.get_n_pages() < 2) {
603 editor_visibility_button.drag_source_unset ();
604 mixer_visibility_button.drag_source_unset ();
605 prefs_visibility_button.drag_source_unset ();
610 ARDOUR_UI::tabs_switch (GtkNotebookPage*, guint page)
612 if (editor && (page == (guint) _tabs.page_num (editor->contents()))) {
613 editor_visibility_button.set_active_state (Gtkmm2ext::ImplicitActive);
615 if (mixer && (mixer->tabbed() || mixer->tabbed_by_default())) {
616 mixer_visibility_button.set_active_state (Gtkmm2ext::Off);
619 if (rc_option_editor && (rc_option_editor->tabbed() || rc_option_editor->tabbed_by_default())) {
620 prefs_visibility_button.set_active_state (Gtkmm2ext::Off);
622 } else if (mixer && (page == (guint) _tabs.page_num (mixer->contents()))) {
624 if (editor && (editor->tabbed() || editor->tabbed_by_default())) {
625 editor_visibility_button.set_active_state (Gtkmm2ext::Off);
628 mixer_visibility_button.set_active_state (Gtkmm2ext::ImplicitActive);
630 if (rc_option_editor && (rc_option_editor->tabbed() || rc_option_editor->tabbed_by_default())) {
631 prefs_visibility_button.set_active_state (Gtkmm2ext::Off);
634 } else if (page == (guint) _tabs.page_num (rc_option_editor->contents())) {
636 if (editor && (editor->tabbed() || editor->tabbed_by_default())) {
637 editor_visibility_button.set_active_state (Gtkmm2ext::Off);
640 if (mixer && (mixer->tabbed() || mixer->tabbed_by_default())) {
641 mixer_visibility_button.set_active_state (Gtkmm2ext::Off);
644 prefs_visibility_button.set_active_state (Gtkmm2ext::ImplicitActive);
650 ARDOUR_UI::tabbable_state_change (Tabbable& t)
652 std::vector<std::string> insensitive_action_names;
653 std::vector<std::string> sensitive_action_names;
654 std::vector<std::string> active_action_names;
655 std::vector<std::string> inactive_action_names;
656 Glib::RefPtr<Action> action;
657 std::string downcased_name = downcase (t.name());
667 insensitive_action_names.push_back (string_compose ("attach-%1", downcased_name));
668 sensitive_action_names.push_back (string_compose ("show-%1", downcased_name));
669 sensitive_action_names.push_back (string_compose ("detach-%1", downcased_name));
670 sensitive_action_names.push_back (string_compose ("hide-%1", downcased_name));
674 } else if (t.tabbed_by_default ()) {
676 insensitive_action_names.push_back (string_compose ("attach-%1", downcased_name));
677 insensitive_action_names.push_back (string_compose ("hide-%1", downcased_name));
678 sensitive_action_names.push_back (string_compose ("show-%1", downcased_name));
679 sensitive_action_names.push_back (string_compose ("detach-%1", downcased_name));
683 } else if (t.window_visible()) {
685 insensitive_action_names.push_back (string_compose ("detach-%1", downcased_name));
686 sensitive_action_names.push_back (string_compose ("show-%1", downcased_name));
687 sensitive_action_names.push_back (string_compose ("attach-%1", downcased_name));
688 sensitive_action_names.push_back (string_compose ("hide-%1", downcased_name));
690 active_action_names.push_back (string_compose ("show-%1", downcased_name));
691 inactive_action_names.push_back (string_compose ("hide-%1", downcased_name));
697 /* not currently visible. allow user to retab it or just make
701 insensitive_action_names.push_back (string_compose ("detach-%1", downcased_name));
702 insensitive_action_names.push_back (string_compose ("hide-%1", downcased_name));
703 sensitive_action_names.push_back (string_compose ("show-%1", downcased_name));
704 sensitive_action_names.push_back (string_compose ("attach-%1", downcased_name));
706 active_action_names.push_back (string_compose ("hide-%1", downcased_name));
707 inactive_action_names.push_back (string_compose ("show-%1", downcased_name));
712 for (std::vector<std::string>::iterator s = insensitive_action_names.begin(); s != insensitive_action_names.end(); ++s) {
713 action = ActionManager::get_action (X_("Common"), (*s).c_str());
715 action->set_sensitive (false);
719 for (std::vector<std::string>::iterator s = sensitive_action_names.begin(); s != sensitive_action_names.end(); ++s) {
720 action = ActionManager::get_action (X_("Common"), (*s).c_str());
722 action->set_sensitive (true);
726 ArdourButton* vis_button = 0;
727 std::vector<ArdourButton*> other_vis_buttons;
730 vis_button = &editor_visibility_button;
731 other_vis_buttons.push_back (&mixer_visibility_button);
732 other_vis_buttons.push_back (&prefs_visibility_button);
733 } else if (&t == mixer) {
734 vis_button = &mixer_visibility_button;
735 other_vis_buttons.push_back (&editor_visibility_button);
736 other_vis_buttons.push_back (&prefs_visibility_button);
737 } else if (&t == rc_option_editor) {
738 vis_button = &prefs_visibility_button;
739 other_vis_buttons.push_back (&editor_visibility_button);
740 other_vis_buttons.push_back (&mixer_visibility_button);
749 vis_button->set_active_state (Gtkmm2ext::ImplicitActive);
752 vis_button->set_active_state (Gtkmm2ext::ExplicitActive);
755 vis_button->set_active_state (Gtkmm2ext::Off);
759 for (std::vector<ArdourButton*>::iterator b = other_vis_buttons.begin(); b != other_vis_buttons.end(); ++b) {
760 (*b)->set_active_state (Gtkmm2ext::Off);
765 ARDOUR_UI::toggle_meterbridge ()
767 assert (editor && mixer && meterbridge);
770 bool obscuring = false;
772 if (meterbridge->not_visible ()) {
774 } else if ((editor->window_visible() && ARDOUR_UI_UTILS::windows_overlap (editor->own_window(), meterbridge)) ||
775 (mixer->window_visible () && ARDOUR_UI_UTILS::windows_overlap (mixer->own_window(), meterbridge))) {
779 if (obscuring && ((editor->own_window() && editor->own_window()->property_has_toplevel_focus()) ||
780 (mixer->own_window() && mixer->own_window()->property_has_toplevel_focus()))) {
785 meterbridge->show_window ();
786 meterbridge->present ();
787 meterbridge->raise ();
789 meterbridge->hide_window (NULL);
794 ARDOUR_UI::toggle_luawindow ()
796 assert (editor && luawindow);
800 if (luawindow->not_visible ()) {
803 // TODO check overlap
806 luawindow->show_window ();
807 luawindow->present ();
810 luawindow->hide_window (NULL);
816 ARDOUR_UI::new_midi_tracer_window ()
818 RefPtr<Action> act = ActionManager::get_action (X_("Common"), X_("NewMIDITracer"));
823 std::list<MidiTracer*>::iterator i = _midi_tracer_windows.begin ();
824 while (i != _midi_tracer_windows.end() && (*i)->get_visible() == true) {
828 if (i == _midi_tracer_windows.end()) {
829 /* all our MIDITracer windows are visible; make a new one */
830 MidiTracer* t = new MidiTracer ();
832 _midi_tracer_windows.push_back (t);
834 /* re-use the hidden one */
840 ARDOUR_UI::create_key_editor ()
842 KeyEditor* kedit = new KeyEditor;
844 for (std::list<Bindings*>::iterator b = Bindings::bindings.begin(); b != Bindings::bindings.end(); ++b) {
845 kedit->add_tab ((*b)->name(), **b);
852 ARDOUR_UI::create_bundle_manager ()
854 return new BundleManager (_session);
858 ARDOUR_UI::create_add_video_dialog ()
860 return new AddVideoDialog (_session);
864 ARDOUR_UI::create_session_option_editor ()
866 return new SessionOptionEditor (_session);
870 ARDOUR_UI::create_big_clock_window ()
872 return new BigClockWindow (*big_clock);
876 ARDOUR_UI::handle_locations_change (Location *)
879 if (_session->locations()->num_range_markers()) {
880 ActionManager::set_sensitive (ActionManager::range_sensitive_actions, true);
882 ActionManager::set_sensitive (ActionManager::range_sensitive_actions, false);
888 ARDOUR_UI::tabbed_window_state_event_handler (GdkEventWindowState* ev, void* object)
890 if (object == editor) {
892 if ((ev->changed_mask & GDK_WINDOW_STATE_FULLSCREEN) &&
893 (ev->new_window_state & GDK_WINDOW_STATE_FULLSCREEN)) {
894 if (big_clock_window) {
895 big_clock_window->set_transient_for (*editor->own_window());
899 } else if (object == mixer) {
901 if ((ev->changed_mask & GDK_WINDOW_STATE_FULLSCREEN) &&
902 (ev->new_window_state & GDK_WINDOW_STATE_FULLSCREEN)) {
903 if (big_clock_window) {
904 big_clock_window->set_transient_for (*mixer->own_window());
913 ARDOUR_UI::editor_meter_peak_button_release (GdkEventButton* ev)
915 if (ev->button == 1 && Gtkmm2ext::Keyboard::modifier_state_equals (ev->state, Gtkmm2ext::Keyboard::PrimaryModifier|Gtkmm2ext::Keyboard::TertiaryModifier)) {
916 ArdourMeter::ResetAllPeakDisplays ();
917 } else if (ev->button == 1 && Gtkmm2ext::Keyboard::modifier_state_equals (ev->state, Gtkmm2ext::Keyboard::PrimaryModifier)) {
918 if (_session->master_out()) {
919 ArdourMeter::ResetGroupPeakDisplays (_session->master_out()->route_group());
921 } else if (_session->master_out()) {
922 ArdourMeter::ResetRoutePeakDisplays (_session->master_out().get());
928 ARDOUR_UI::toggle_mixer_space()
930 Glib::RefPtr<Action> act = ActionManager::get_action ("Common", "ToggleMaximalMixer");
933 Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
934 if (tact->get_active()) {
935 mixer->maximise_mixer_space ();
937 mixer->restore_mixer_space ();
943 ARDOUR_UI::toggle_mixer_list()
945 Glib::RefPtr<Action> act = ActionManager::get_action ("Common", "ToggleMixerList");
948 Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
949 mixer->show_mixer_list (tact->get_active());
954 ARDOUR_UI::toggle_monitor_section_visibility ()
956 Glib::RefPtr<Action> act = ActionManager::get_action ("Common", "ToggleMonitorSection");
959 Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
960 mixer->show_monitor_section (tact->get_active());