2 * Copyright (C) 2005-2006 Taybin Rutkin <taybin@taybin.com>
3 * Copyright (C) 2005-2018 Paul Davis <paul@linuxaudiosystems.com>
4 * Copyright (C) 2006-2016 David Robillard <d@drobilla.net>
5 * Copyright (C) 2006 Hans Fugal <hans@fugal.net>
6 * Copyright (C) 2006 Nick Mainsbridge <mainsbridge@gmail.com>
7 * Copyright (C) 2007-2012 Carl Hetherington <carl@carlh.net>
8 * Copyright (C) 2007-2015 Tim Mayberry <mojofunk@gmail.com>
9 * Copyright (C) 2007 Doug McLain <doug@nostar.net>
10 * Copyright (C) 2013-2019 Robin Gareus <robin@gareus.org>
11 * Copyright (C) 2014-2018 Ben Loftis <ben@harrisonconsoles.com>
13 * This program is free software; you can redistribute it and/or modify
14 * it under the terms of the GNU General Public License as published by
15 * the Free Software Foundation; either version 2 of the License, or
16 * (at your option) any later version.
18 * This program is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU General Public License for more details.
23 * You should have received a copy of the GNU General Public License along
24 * with this program; if not, write to the Free Software Foundation, Inc.,
25 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
28 /* This file contains any ARDOUR_UI methods that require knowledge of
29 the various dialog boxes, and exists so that no compilation dependency
30 exists between the main ARDOUR_UI modules and their respective classes.
31 This is to cut down on the compile times. It also helps with my sanity.
36 #include <gtkmm/treemodelfilter.h>
38 #include "pbd/convert.h"
40 #include "ardour/audioengine.h"
41 #include "ardour/automation_watch.h"
42 #include "ardour/control_protocol_manager.h"
43 #include "ardour/profile.h"
44 #include "ardour/session.h"
46 #include "control_protocol/control_protocol.h"
48 #include "gtkmm2ext/keyboard.h"
49 #include "gtkmm2ext/utils.h"
52 #include "add_route_dialog.h"
53 #include "add_video_dialog.h"
54 #include "ardour_ui.h"
55 #include "big_clock_window.h"
56 #include "big_transport_window.h"
57 #include "bundle_manager.h"
58 #include "global_port_matrix.h"
59 #include "gui_object.h"
60 #include "gui_thread.h"
61 #include "keyeditor.h"
62 #include "location_ui.h"
63 #include "lua_script_manager.h"
64 #include "luawindow.h"
65 #include "main_clock.h"
66 #include "meterbridge.h"
67 #include "meter_patterns.h"
68 #include "monitor_section.h"
69 #include "midi_tracer.h"
70 #include "mini_timeline.h"
72 #include "plugin_dspload_window.h"
73 #include "public_editor.h"
74 #include "processor_box.h"
75 #include "rc_option_editor.h"
76 #include "route_params_ui.h"
77 #include "shuttle_control.h"
78 #include "session_option_editor.h"
79 #include "speaker_dialog.h"
82 #include "time_info_box.h"
84 #include "transport_masters_dialog.h"
88 using namespace ARDOUR;
92 using namespace Gtkmm2ext;
93 using namespace ArdourWidgets;
96 ARDOUR_UI::set_session (Session *s)
98 SessionHandlePtr::set_session (s);
100 transport_ctrl.set_session (s);
102 if (big_transport_window) {
103 big_transport_window->set_session (s);
107 WM::Manager::instance().set_session (s);
108 /* Session option editor cannot exist across change-of-session */
109 session_option_editor.drop_window ();
110 /* Ditto for AddVideoDialog */
111 add_video_dialog.drop_window ();
115 const XMLNode* node = _session->extra_xml (X_("UI"));
118 const XMLNodeList& children = node->children();
119 for (XMLNodeList::const_iterator i = children.begin(); i != children.end(); ++i) {
120 if ((*i)->name() == GUIObjectState::xml_node_name) {
121 gui_object_state->load (**i);
127 WM::Manager::instance().set_session (s);
129 AutomationWatch::instance().set_session (s);
131 shuttle_box.set_session (s);
132 mini_timeline.set_session (s);
133 time_info_box->set_session (s);
135 primary_clock->set_session (s);
136 secondary_clock->set_session (s);
137 big_clock->set_session (s);
138 video_timeline->set_session (s);
139 lua_script_window->set_session (s);
140 plugin_dsp_load_window->set_session (s);
141 transport_masters_window->set_session (s);
142 rc_option_editor->set_session (s);
144 /* sensitize menu bar options that are now valid */
146 ActionManager::set_sensitive (ActionManager::session_sensitive_actions, true);
147 ActionManager::set_sensitive (ActionManager::write_sensitive_actions, _session->writable());
149 if (_session->locations()->num_range_markers()) {
150 ActionManager::set_sensitive (ActionManager::range_sensitive_actions, true);
152 ActionManager::set_sensitive (ActionManager::range_sensitive_actions, false);
155 /* allow wastebasket flush again */
157 Glib::RefPtr<Action> act = ActionManager::get_action (X_("Main"), X_("FlushWastebasket"));
159 act->set_sensitive (true);
162 /* there are never any selections on startup */
164 ActionManager::set_sensitive (ActionManager::time_selection_sensitive_actions, false);
165 ActionManager::set_sensitive (ActionManager::track_selection_sensitive_actions, false);
166 ActionManager::set_sensitive (ActionManager::route_selection_sensitive_actions, false);
167 ActionManager::set_sensitive (ActionManager::bus_selection_sensitive_actions, false);
168 ActionManager::set_sensitive (ActionManager::vca_selection_sensitive_actions, false);
169 ActionManager::set_sensitive (ActionManager::stripable_selection_sensitive_actions, false);
170 ActionManager::set_sensitive (ActionManager::line_selection_sensitive_actions, false);
171 ActionManager::set_sensitive (ActionManager::point_selection_sensitive_actions, false);
172 ActionManager::set_sensitive (ActionManager::playlist_selection_sensitive_actions, false);
174 solo_alert_button.set_active (_session->soloing());
176 setup_session_options ();
178 blink_connection = Timers::blink_connect (sigc::mem_fun(*this, &ARDOUR_UI::blink_handler));
180 _session->SaveSessionRequested.connect (_session_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::save_session_at_its_request, this, _1), gui_context());
181 _session->StateSaved.connect (_session_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::update_title, this), gui_context());
182 _session->RecordStateChanged.connect (_session_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::record_state_changed, this), gui_context());
183 _session->TransportStateChange.connect (_session_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::map_transport_state, this), gui_context());
184 _session->DirtyChanged.connect (_session_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::session_dirty_changed, this), gui_context());
186 _session->Xrun.connect (_session_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::xrun_handler, this, _1), gui_context());
187 _session->SoloActive.connect (_session_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::soloing_changed, this, _1), gui_context());
188 _session->AuditionActive.connect (_session_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::auditioning_changed, this, _1), gui_context());
189 _session->locations()->added.connect (_session_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::handle_locations_change, this, _1), gui_context());
190 _session->locations()->removed.connect (_session_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::handle_locations_change, this, _1), gui_context());
191 _session->config.ParameterChanged.connect (_session_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::session_parameter_changed, this, _1), gui_context ());
193 /* Clocks are on by default after we are connected to a session, so show that here.
196 connect_dependents_to_session (s);
198 /* listen to clock mode changes. don't do this earlier because otherwise as the clocks
199 restore their modes or are explicitly set, we will cause the "new" mode to be saved
200 back to the session XML ("Extra") state.
203 AudioClock::ModeChanged.connect (sigc::mem_fun (*this, &ARDOUR_UI::store_clock_modes));
205 Glib::signal_idle().connect (sigc::mem_fun (*this, &ARDOUR_UI::first_idle));
209 map_transport_state ();
211 second_connection = Timers::second_connect (sigc::mem_fun(*this, &ARDOUR_UI::every_second));
212 point_one_second_connection = Timers::rapid_connect (sigc::mem_fun(*this, &ARDOUR_UI::every_point_one_seconds));
213 point_zero_something_second_connection = Timers::super_rapid_connect (sigc::mem_fun(*this, &ARDOUR_UI::every_point_zero_something_seconds));
214 set_fps_timeout_connection();
218 if (editor_meter_table.get_parent()) {
219 transport_hbox.remove (editor_meter_table);
223 editor_meter_table.remove(*editor_meter);
226 editor_meter_peak_display.hide();
229 if (editor_meter_table.get_parent()) {
230 transport_hbox.remove (editor_meter_table);
234 _session->master_out() &&
235 _session->master_out()->n_outputs().n(DataType::AUDIO) > 0) {
237 if (!ARDOUR::Profile->get_trx()) {
238 editor_meter = new LevelMeterHBox(_session);
239 editor_meter->set_meter (_session->master_out()->shared_peak_meter().get());
240 editor_meter->clear_meters();
241 editor_meter->setup_meters (30, 10, 6);
242 editor_meter->show();
244 editor_meter_table.set_spacings(3);
245 editor_meter_table.attach(*editor_meter, 0,1, 0,1, FILL, FILL);
246 editor_meter_table.attach(editor_meter_peak_display, 0,1, 1,2, FILL, EXPAND|FILL);
248 editor_meter->show();
249 editor_meter_peak_display.show();
252 ArdourMeter::ResetAllPeakDisplays.connect (sigc::mem_fun(*this, &ARDOUR_UI::reset_peak_display));
253 ArdourMeter::ResetRoutePeakDisplays.connect (sigc::mem_fun(*this, &ARDOUR_UI::reset_route_peak_display));
254 ArdourMeter::ResetGroupPeakDisplays.connect (sigc::mem_fun(*this, &ARDOUR_UI::reset_group_peak_display));
256 editor_meter_peak_display.set_name ("meterbridge peakindicator");
257 editor_meter_peak_display.unset_flags (Gtk::CAN_FOCUS);
258 editor_meter_peak_display.set_size_request (-1, std::max(6.f, rintf(5.f * UIConfiguration::instance().get_ui_scale())) );
259 editor_meter_peak_display.set_corner_radius (3.0);
261 editor_meter_max_peak = -INFINITY;
262 editor_meter_peak_display.signal_button_release_event().connect (sigc::mem_fun(*this, &ARDOUR_UI::editor_meter_peak_button_release), false);
264 repack_transport_hbox ();
271 ARDOUR_UI::unload_session (bool hide_stuff)
274 ARDOUR_UI::instance()->video_timeline->sync_session_state();
277 if (_session && _session->dirty()) {
278 std::vector<std::string> actions;
279 actions.push_back (_("Don't close"));
280 actions.push_back (_("Just close"));
281 actions.push_back (_("Save and close"));
282 switch (ask_about_saving_session (actions)) {
288 _session->save_state ("");
294 // tear down session specific CPI (owned by rc_config_editor which can remain)
295 ControlProtocolManager& m = ControlProtocolManager::instance ();
296 for (std::list<ControlProtocolInfo*>::iterator i = m.control_protocol_info.begin(); i != m.control_protocol_info.end(); ++i) {
297 if (*i && (*i)->protocol && (*i)->protocol->has_editor ()) {
298 (*i)->protocol->tear_down_gui ();
304 close_all_dialogs ();
307 meterbridge->hide ();
308 audio_port_matrix->hide();
309 midi_port_matrix->hide();
310 route_params->hide();
313 second_connection.disconnect ();
314 point_one_second_connection.disconnect ();
315 point_zero_something_second_connection.disconnect();
316 fps_connection.disconnect();
319 editor_meter_table.remove(*editor_meter);
322 editor_meter_peak_display.hide();
325 ActionManager::set_sensitive (ActionManager::session_sensitive_actions, false);
327 WM::Manager::instance().set_session ((ARDOUR::Session*) 0);
329 if (ARDOUR_UI::instance()->video_timeline) {
330 ARDOUR_UI::instance()->video_timeline->close_session();
335 /* drop everything attached to the blink signal */
337 blink_connection.disconnect ();
339 ARDOUR::Session* session_to_delete = _session;
341 delete session_to_delete;
349 ARDOUR_UI::toggle_editor_and_mixer ()
351 if (editor->tabbed() && mixer->tabbed()) {
352 /* both in the same window */
353 if (_tabs.get_current_page() == _tabs.page_num (editor->contents())) {
354 _tabs.set_current_page (_tabs.page_num (mixer->contents()));
355 } else if (_tabs.get_current_page() == _tabs.page_num (mixer->contents())) {
356 _tabs.set_current_page (_tabs.page_num (editor->contents()));
359 _tabs.set_current_page (_tabs.page_num (mixer->contents()));
365 if (editor->tabbed() && !mixer->tabbed()) {
366 /* editor is tabbed, mixer is not */
368 Gtk::Window* mwin = mixer->current_toplevel ();
371 /* mixer's own window doesn't exist */
372 mixer->make_visible ();
373 } else if (!mwin->is_mapped ()) {
374 /* mixer's own window exists but isn't mapped */
375 mixer->make_visible ();
377 /* mixer window is mapped, editor is visible as tab */
378 Gtk::Widget* f = mwin->get_focus();
379 if (f && f->has_focus()) {
380 /* mixer has focus, switch to editor */
381 editor->make_visible ();
383 mixer->make_visible ();
389 if (!editor->tabbed() && mixer->tabbed()) {
390 /* mixer is tabbed, editor is not */
392 Gtk::Window* ewin = editor->current_toplevel ();
395 /* mixer's own window doesn't exist */
396 editor->make_visible ();
397 } else if (!ewin->is_mapped ()) {
398 /* editor's own window exists but isn't mapped */
399 editor->make_visible ();
401 /* editor window is mapped, mixer is visible as tab */
402 Gtk::Widget* f = ewin->get_focus();
403 if (f && f->has_focus()) {
404 /* editor has focus, switch to mixer */
405 mixer->make_visible ();
407 editor->make_visible ();
415 ARDOUR_UI::step_up_through_tabs ()
417 std::vector<Tabbable*> candidates;
419 /* this list must match the order of visibility buttons */
421 if (!editor->window_visible()) {
422 candidates.push_back (editor);
425 if (!mixer->window_visible()) {
426 candidates.push_back (mixer);
429 if (!rc_option_editor->window_visible()) {
430 candidates.push_back (rc_option_editor);
433 if (candidates.size() < 2) {
434 /* nothing to be done with zero or one visible in tabs */
438 std::vector<Tabbable*>::iterator prev = candidates.end();
439 std::vector<Tabbable*>::iterator i;
440 Gtk::Widget* w = _tabs.get_nth_page (_tabs.get_current_page ());
442 for (i = candidates.begin(); i != candidates.end(); ++i) {
443 if (w == &(*i)->contents()) {
444 if (prev != candidates.end()) {
445 _tabs.set_current_page (_tabs.page_num ((*prev)->contents()));
447 _tabs.set_current_page (_tabs.page_num (candidates.back()->contents()));
456 ARDOUR_UI::step_down_through_tabs ()
458 std::vector<Tabbable*> candidates;
460 /* this list must match the order of visibility buttons */
462 if (!editor->window_visible()) {
463 candidates.push_back (editor);
466 if (!mixer->window_visible()) {
467 candidates.push_back (mixer);
470 if (!rc_option_editor->window_visible()) {
471 candidates.push_back (rc_option_editor);
474 if (candidates.size() < 2) {
475 /* nothing to be done with zero or one visible in tabs */
479 std::vector<Tabbable*>::reverse_iterator next = candidates.rend();
480 std::vector<Tabbable*>::reverse_iterator i;
481 Gtk::Widget* w = _tabs.get_nth_page (_tabs.get_current_page ());
483 for (i = candidates.rbegin(); i != candidates.rend(); ++i) {
484 if (w == &(*i)->contents()) {
485 if (next != candidates.rend()) {
486 _tabs.set_current_page (_tabs.page_num ((*next)->contents()));
488 _tabs.set_current_page (_tabs.page_num (candidates.front()->contents()));
497 ARDOUR_UI::key_change_tabbable_visibility (Tabbable* t)
504 _tabs.set_current_page (_tabs.page_num (t->contents()));
505 } else if (!t->fully_visible()) {
508 _main_window.present ();
513 ARDOUR_UI::button_change_tabbable_visibility (Tabbable* t)
515 /* For many/most users, clicking a button in the main window will make it
516 the main/front/key window, which will change any stacking relationship they
517 were trying to modify by clicking on the button in the first
518 place. This button-aware method knows that click on
519 a button designed to show/hide a Tabbable that has its own window
520 will have made that window be obscured (as the main window comes to
521 the front). We therefore *hide* the Tabbable's window if it is even
522 partially visible, believing that this is likely because the
523 Tabbable window used to be front, the user clicked to change that,
524 and before we even get here, the main window has become front.
532 _tabs.set_current_page (_tabs.page_num (t->contents()));
533 } else if (t->visible()) {
541 ARDOUR_UI::show_tabbable (Tabbable* t)
551 ARDOUR_UI::hide_tabbable (Tabbable* t)
556 t->make_invisible ();
560 ARDOUR_UI::attach_tabbable (Tabbable* t)
570 ARDOUR_UI::detach_tabbable (Tabbable* t)
579 ARDOUR_UI::tabs_page_added (Widget*,guint)
581 if (_tabs.get_n_pages() > 1) {
583 std::vector<TargetEntry> drag_target_entries;
584 drag_target_entries.push_back (TargetEntry ("tabbable"));
586 editor_visibility_button.drag_source_set (drag_target_entries);
587 mixer_visibility_button.drag_source_set (drag_target_entries);
588 prefs_visibility_button.drag_source_set (drag_target_entries);
590 editor_visibility_button.drag_source_set_icon (Gtkmm2ext::pixbuf_from_string (editor->name(),
591 Pango::FontDescription ("Sans 24"),
593 Gdk::Color ("red")));
594 mixer_visibility_button.drag_source_set_icon (Gtkmm2ext::pixbuf_from_string (mixer->name(),
595 Pango::FontDescription ("Sans 24"),
597 Gdk::Color ("red")));
598 prefs_visibility_button.drag_source_set_icon (Gtkmm2ext::pixbuf_from_string (rc_option_editor->name(),
599 Pango::FontDescription ("Sans 24"),
601 Gdk::Color ("red")));
606 ARDOUR_UI::tabs_page_removed (Widget*, guint)
608 if (_tabs.get_n_pages() < 2) {
609 editor_visibility_button.drag_source_unset ();
610 mixer_visibility_button.drag_source_unset ();
611 prefs_visibility_button.drag_source_unset ();
616 ARDOUR_UI::tabs_switch (GtkNotebookPage*, guint page)
618 if (editor && (page == (guint) _tabs.page_num (editor->contents()))) {
619 editor_visibility_button.set_active_state (Gtkmm2ext::ImplicitActive);
621 if (mixer && (mixer->tabbed() || mixer->tabbed_by_default())) {
622 mixer_visibility_button.set_active_state (Gtkmm2ext::Off);
625 if (rc_option_editor && (rc_option_editor->tabbed() || rc_option_editor->tabbed_by_default())) {
626 prefs_visibility_button.set_active_state (Gtkmm2ext::Off);
628 } else if (mixer && (page == (guint) _tabs.page_num (mixer->contents()))) {
630 if (editor && (editor->tabbed() || editor->tabbed_by_default())) {
631 editor_visibility_button.set_active_state (Gtkmm2ext::Off);
634 mixer_visibility_button.set_active_state (Gtkmm2ext::ImplicitActive);
636 if (rc_option_editor && (rc_option_editor->tabbed() || rc_option_editor->tabbed_by_default())) {
637 prefs_visibility_button.set_active_state (Gtkmm2ext::Off);
640 } else if (page == (guint) _tabs.page_num (rc_option_editor->contents())) {
642 if (editor && (editor->tabbed() || editor->tabbed_by_default())) {
643 editor_visibility_button.set_active_state (Gtkmm2ext::Off);
646 if (mixer && (mixer->tabbed() || mixer->tabbed_by_default())) {
647 mixer_visibility_button.set_active_state (Gtkmm2ext::Off);
650 prefs_visibility_button.set_active_state (Gtkmm2ext::ImplicitActive);
656 ARDOUR_UI::tabbable_state_change (Tabbable& t)
658 std::vector<std::string> insensitive_action_names;
659 std::vector<std::string> sensitive_action_names;
660 std::vector<std::string> active_action_names;
661 std::vector<std::string> inactive_action_names;
662 Glib::RefPtr<Action> action;
663 std::string downcased_name = downcase (t.name());
673 insensitive_action_names.push_back (string_compose ("attach-%1", downcased_name));
674 sensitive_action_names.push_back (string_compose ("show-%1", downcased_name));
675 sensitive_action_names.push_back (string_compose ("detach-%1", downcased_name));
676 sensitive_action_names.push_back (string_compose ("hide-%1", downcased_name));
680 } else if (t.tabbed_by_default ()) {
682 insensitive_action_names.push_back (string_compose ("attach-%1", downcased_name));
683 insensitive_action_names.push_back (string_compose ("hide-%1", downcased_name));
684 sensitive_action_names.push_back (string_compose ("show-%1", downcased_name));
685 sensitive_action_names.push_back (string_compose ("detach-%1", downcased_name));
689 } else if (t.window_visible()) {
691 insensitive_action_names.push_back (string_compose ("detach-%1", downcased_name));
692 sensitive_action_names.push_back (string_compose ("show-%1", downcased_name));
693 sensitive_action_names.push_back (string_compose ("attach-%1", downcased_name));
694 sensitive_action_names.push_back (string_compose ("hide-%1", downcased_name));
696 active_action_names.push_back (string_compose ("show-%1", downcased_name));
697 inactive_action_names.push_back (string_compose ("hide-%1", downcased_name));
703 /* not currently visible. allow user to retab it or just make
707 insensitive_action_names.push_back (string_compose ("detach-%1", downcased_name));
708 insensitive_action_names.push_back (string_compose ("hide-%1", downcased_name));
709 sensitive_action_names.push_back (string_compose ("show-%1", downcased_name));
710 sensitive_action_names.push_back (string_compose ("attach-%1", downcased_name));
712 active_action_names.push_back (string_compose ("hide-%1", downcased_name));
713 inactive_action_names.push_back (string_compose ("show-%1", downcased_name));
718 for (std::vector<std::string>::iterator s = insensitive_action_names.begin(); s != insensitive_action_names.end(); ++s) {
719 action = ActionManager::get_action (X_("Common"), (*s).c_str(), false);
721 action->set_sensitive (false);
725 for (std::vector<std::string>::iterator s = sensitive_action_names.begin(); s != sensitive_action_names.end(); ++s) {
726 action = ActionManager::get_action (X_("Common"), (*s).c_str(), false);
728 action->set_sensitive (true);
732 ArdourButton* vis_button = 0;
733 std::vector<ArdourButton*> other_vis_buttons;
736 vis_button = &editor_visibility_button;
737 other_vis_buttons.push_back (&mixer_visibility_button);
738 other_vis_buttons.push_back (&prefs_visibility_button);
739 } else if (&t == mixer) {
740 vis_button = &mixer_visibility_button;
741 other_vis_buttons.push_back (&editor_visibility_button);
742 other_vis_buttons.push_back (&prefs_visibility_button);
743 } else if (&t == rc_option_editor) {
744 vis_button = &prefs_visibility_button;
745 other_vis_buttons.push_back (&editor_visibility_button);
746 other_vis_buttons.push_back (&mixer_visibility_button);
755 vis_button->set_active_state (Gtkmm2ext::ImplicitActive);
758 vis_button->set_active_state (Gtkmm2ext::ExplicitActive);
761 vis_button->set_active_state (Gtkmm2ext::Off);
765 for (std::vector<ArdourButton*>::iterator b = other_vis_buttons.begin(); b != other_vis_buttons.end(); ++b) {
766 (*b)->set_active_state (Gtkmm2ext::Off);
771 ARDOUR_UI::toggle_meterbridge ()
773 assert (editor && mixer && meterbridge);
776 bool obscuring = false;
778 if (meterbridge->not_visible ()) {
780 } else if ((editor->window_visible() && ARDOUR_UI_UTILS::windows_overlap (editor->own_window(), meterbridge)) ||
781 (mixer->window_visible () && ARDOUR_UI_UTILS::windows_overlap (mixer->own_window(), meterbridge))) {
785 if (obscuring && ((editor->own_window() && editor->own_window()->property_has_toplevel_focus()) ||
786 (mixer->own_window() && mixer->own_window()->property_has_toplevel_focus()))) {
791 meterbridge->show_window ();
792 meterbridge->present ();
793 meterbridge->raise ();
795 meterbridge->hide_window (NULL);
800 ARDOUR_UI::toggle_luawindow ()
802 assert (editor && luawindow);
806 if (luawindow->not_visible ()) {
809 // TODO check overlap
812 luawindow->show_window ();
813 luawindow->present ();
816 luawindow->hide_window (NULL);
822 ARDOUR_UI::new_midi_tracer_window ()
824 RefPtr<Action> act = ActionManager::get_action (X_("Common"), X_("NewMIDITracer"));
829 std::list<MidiTracer*>::iterator i = _midi_tracer_windows.begin ();
830 while (i != _midi_tracer_windows.end() && (*i)->get_visible() == true) {
834 if (i == _midi_tracer_windows.end()) {
835 /* all our MIDITracer windows are visible; make a new one */
836 MidiTracer* t = new MidiTracer ();
838 _midi_tracer_windows.push_back (t);
840 /* re-use the hidden one */
846 ARDOUR_UI::create_key_editor ()
848 KeyEditor* kedit = new KeyEditor;
850 for (std::list<Bindings*>::iterator b = Bindings::bindings.begin(); b != Bindings::bindings.end(); ++b) {
851 kedit->add_tab ((*b)->name(), **b);
858 ARDOUR_UI::create_bundle_manager ()
860 return new BundleManager (_session);
864 ARDOUR_UI::create_add_video_dialog ()
866 return new AddVideoDialog (_session);
870 ARDOUR_UI::create_session_option_editor ()
872 return new SessionOptionEditor (_session);
876 ARDOUR_UI::create_big_clock_window ()
878 return new BigClockWindow (*big_clock);
882 ARDOUR_UI::create_big_transport_window ()
884 BigTransportWindow* btw = new BigTransportWindow ();
885 btw->set_session (_session);
890 ARDOUR_UI::handle_locations_change (Location *)
893 if (_session->locations()->num_range_markers()) {
894 ActionManager::set_sensitive (ActionManager::range_sensitive_actions, true);
896 ActionManager::set_sensitive (ActionManager::range_sensitive_actions, false);
902 ARDOUR_UI::tabbed_window_state_event_handler (GdkEventWindowState* ev, void* object)
904 if (object == editor) {
906 if ((ev->changed_mask & GDK_WINDOW_STATE_FULLSCREEN) &&
907 (ev->new_window_state & GDK_WINDOW_STATE_FULLSCREEN)) {
908 if (big_clock_window) {
909 big_clock_window->set_transient_for (*editor->own_window());
911 if (big_transport_window) {
912 big_transport_window->set_transient_for (*editor->own_window());
916 } else if (object == mixer) {
918 if ((ev->changed_mask & GDK_WINDOW_STATE_FULLSCREEN) &&
919 (ev->new_window_state & GDK_WINDOW_STATE_FULLSCREEN)) {
920 if (big_clock_window) {
921 big_clock_window->set_transient_for (*mixer->own_window());
923 if (big_transport_window) {
924 big_transport_window->set_transient_for (*mixer->own_window());
933 ARDOUR_UI::editor_meter_peak_button_release (GdkEventButton* ev)
935 if (ev->button == 1) {
936 ArdourMeter::ResetAllPeakDisplays ();
942 ARDOUR_UI::toggle_mixer_space()
944 Glib::RefPtr<ToggleAction> tact = ActionManager::get_toggle_action ("Common", "ToggleMaximalMixer");
945 if (tact->get_active()) {
946 mixer->maximise_mixer_space ();
948 mixer->restore_mixer_space ();