X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=gtk2_ardour%2Fardour_ui_dependents.cc;h=8490643487ccf6753c35b6909b7baf8f6c26a895;hb=cf52d6e4b40111eb04b244ec054055a4ec15dbe0;hp=937ba5ab819ae7743f01315c9bc8f3a5ca3a3a5d;hpb=51ab5ccabf432540ca935065f6c6f40a96f42dad;p=ardour.git diff --git a/gtk2_ardour/ardour_ui_dependents.cc b/gtk2_ardour/ardour_ui_dependents.cc index 937ba5ab81..8490643487 100644 --- a/gtk2_ardour/ardour_ui_dependents.cc +++ b/gtk2_ardour/ardour_ui_dependents.cc @@ -31,14 +31,22 @@ #include "ardour/session.h" +#include "gtkmm2ext/bindings.h" + +#include "actions.h" #include "ardour_ui.h" #include "public_editor.h" +#include "meterbridge.h" +#include "luawindow.h" #include "mixer_ui.h" #include "keyboard.h" #include "splash.h" +#include "rc_option_editor.h" #include "route_params_ui.h" #include "opts.h" -#include "i18n.h" +#include "utils.h" + +#include "pbd/i18n.h" using namespace Gtk; using namespace PBD; @@ -50,31 +58,69 @@ namespace ARDOUR { using namespace ARDOUR; -void -ARDOUR_UI::shutdown () -{ - if (ui_config->dirty()) { - ui_config->save_state(); - } -} - void ARDOUR_UI::we_have_dependents () { install_actions (); + load_bindings (); + ProcessorBox::register_actions (); - keyboard->setup_keybindings (); + + /* Global, editor, mixer, processor box actions are defined now. Link + them with any bindings, so that GTK does not get a chance to define + the GTK accel map entries first when we ask the GtkUIManager to + create menus/widgets. + + If GTK adds the actions to its accel map before we do, we lose our + freedom to use any keys. More precisely, we can use any keys, but + ones that GTK considers illegal as accelerators will not show up in + menus. + + There are other dynamic actions that can be created by a monitor + section, by step entry dialogs. These need to be handled + separately. They don't tend to use GTK-illegal bindings and more + importantly they don't have menus showing the bindings, so it is + less of an issue. + */ + + Gtkmm2ext::Bindings::associate_all (); + editor->setup_tooltips (); editor->UpdateAllTransportClocks.connect (sigc::mem_fun (*this, &ARDOUR_UI::update_transport_clocks)); + + /* catch up on tabbable state, in the right order to leave the editor + * selected by default + */ + + tabbable_state_change (*rc_option_editor); + tabbable_state_change (*mixer); + tabbable_state_change (*editor); + + /* all actions are defined */ + + ActionManager::load_menus (ARDOUR_COMMAND_LINE::menus_file); + + editor->track_mixer_selection (); + mixer->track_editor_selection (); + + /* catch up on parameters */ + + boost::function pc (boost::bind (&ARDOUR_UI::parameter_changed, this, _1)); + Config->map_parameters (pc); + + UIConfiguration::instance().reset_dpi (); } void ARDOUR_UI::connect_dependents_to_session (ARDOUR::Session *s) { + DisplaySuspender ds; BootMessage (_("Setup Editor")); editor->set_session (s); BootMessage (_("Setup Mixer")); mixer->set_session (s); + meterbridge->set_session (s); + luawindow->set_session (s); /* its safe to do this now */ @@ -82,91 +128,273 @@ ARDOUR_UI::connect_dependents_to_session (ARDOUR::Session *s) s->restore_history (""); } -static bool -_hide_splash (gpointer arg) +/** The main editor window has been closed */ +gint +ARDOUR_UI::exit_on_main_window_close (GdkEventAny * /*ev*/) { - ((ARDOUR_UI*)arg)->hide_splash(); - return false; +#ifdef TOP_MENUBAR + /* just hide the window, and return - the top menu stays up */ + editor->hide (); + return TRUE; +#else + /* time to get out of here */ + finish(); + return TRUE; +#endif } -void -ARDOUR_UI::goto_editor_window () +GtkNotebook* +ARDOUR_UI::tab_window_root_drop (GtkNotebook* src, + GtkWidget* w, + gint x, + gint y, + gpointer) { - if (splash && splash->is_visible()) { - // in 2 seconds, hide the splash screen - Glib::signal_timeout().connect (sigc::bind (sigc::ptr_fun (_hide_splash), this), 2000); + using namespace std; + Gtk::Notebook* nb = 0; + Gtk::Window* win = 0; + Gtkmm2ext::Tabbable* tabbable = 0; + + + if (w == GTK_WIDGET(editor->contents().gobj())) { + tabbable = editor; + } else if (w == GTK_WIDGET(mixer->contents().gobj())) { + tabbable = mixer; + } else if (w == GTK_WIDGET(rc_option_editor->contents().gobj())) { + tabbable = rc_option_editor; + } else { + return 0; + } + + nb = tabbable->tab_root_drop (); + win = tabbable->own_window (); + + if (nb) { + win->move (x, y); + win->show_all (); + win->present (); + return nb->gobj(); } - editor->show_window (); - editor->present (); - flush_pending (); + return 0; /* what was that? */ } -void -ARDOUR_UI::goto_mixer_window () +bool +ARDOUR_UI::idle_ask_about_quit () { - mixer->show_window (); - mixer->present (); - flush_pending (); + if (_session && _session->dirty()) { + finish (); + } else { + /* no session or session not dirty, but still ask anyway */ + + Gtk::MessageDialog msg (string_compose ("Quit %1?", PROGRAM_NAME), + false, /* no markup */ + Gtk::MESSAGE_INFO, + Gtk::BUTTONS_YES_NO, + true); /* modal */ + msg.set_default_response (Gtk::RESPONSE_YES); + + if (msg.run() == Gtk::RESPONSE_YES) { + finish (); + } + } + + /* not reached but keep the compiler happy */ + + return false; } -void -ARDOUR_UI::toggle_mixer_window () +bool +ARDOUR_UI::main_window_delete_event (GdkEventAny* ev) { - Glib::RefPtr act = ActionManager::get_action (X_("Common"), X_("toggle-mixer")); - if (!act) { - return; - } + /* quit the application as soon as we go idle. If we call this here, + * the window manager/desktop can think we're taking too longer to + * handle the "delete" event + */ - Glib::RefPtr tact = Glib::RefPtr::cast_dynamic (act); + Glib::signal_idle().connect (sigc::mem_fun (*this, &ARDOUR_UI::idle_ask_about_quit)); - if (tact->get_active()) { - goto_mixer_window (); - } else { - mixer->hide (); - } + return true; } -void -ARDOUR_UI::toggle_mixer_on_top () +static GtkNotebook* +tab_window_root_drop (GtkNotebook* src, + GtkWidget* w, + gint x, + gint y, + gpointer user_data) { - Glib::RefPtr act = ActionManager::get_action (X_("Common"), X_("toggle-mixer-on-top")); - if (!act) { - return; - } + return ARDOUR_UI::instance()->tab_window_root_drop (src, w, x, y, user_data); +} - Glib::RefPtr tact = Glib::RefPtr::cast_dynamic (act); +int +ARDOUR_UI::setup_windows () +{ + /* actions do not need to be defined when we load keybindings. They + * will be lazily discovered. But bindings do need to exist when we + * create windows/tabs with their own binding sets. + */ - if (tact->get_active()) { + keyboard->setup_keybindings (); - /* Toggle the mixer to `visible' if required */ - act = ActionManager::get_action (X_("Common"), X_("toggle-mixer")); - if (act) { - tact = Glib::RefPtr::cast_dynamic (act); + _tabs.signal_switch_page().connect (sigc::mem_fun (*this, &ARDOUR_UI::tabs_switch)); + _tabs.signal_page_added().connect (sigc::mem_fun (*this, &ARDOUR_UI::tabs_page_added)); + _tabs.signal_page_removed().connect (sigc::mem_fun (*this, &ARDOUR_UI::tabs_page_removed)); - if (!tact->get_active()) { - tact->set_active (); - } - } + rc_option_editor = new RCOptionEditor; + rc_option_editor->StateChange.connect (sigc::mem_fun (*this, &ARDOUR_UI::tabbable_state_change)); - goto_mixer_window (); - } else { - goto_editor_window (); + if (create_editor ()) { + error << _("UI: cannot setup editor") << endmsg; + return -1; } -} -/** The main editor window has been closed */ -gint -ARDOUR_UI::exit_on_main_window_close (GdkEventAny * /*ev*/) -{ + if (create_mixer ()) { + error << _("UI: cannot setup mixer") << endmsg; + return -1; + } + + if (create_meterbridge ()) { + error << _("UI: cannot setup meterbridge") << endmsg; + return -1; + } + + if (create_luawindow ()) { + error << _("UI: cannot setup luawindow") << endmsg; + return -1; + } + + /* order of addition affects order seen in initial window display */ + + rc_option_editor->add_to_notebook (_tabs, _("Preferences")); + mixer->add_to_notebook (_tabs, _("Mixer")); + editor->add_to_notebook (_tabs, _("Editor")); + + /* all other dialogs are created conditionally */ + + we_have_dependents (); + #ifdef TOP_MENUBAR - /* just hide the window, and return - the top menu stays up */ - editor->hide (); - return TRUE; + EventBox* status_bar_event_box = manage (new EventBox); + + status_bar_event_box->add (status_bar_label); + status_bar_event_box->add_events (Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK); + status_bar_label.set_size_request (300, -1); + + status_bar_label.show (); + status_bar_event_box->show (); + + status_bar_event_box->signal_button_press_event().connect (mem_fun (*this, &ARDOUR_UI::status_bar_button_press)); + + status_bar_hpacker.pack_start (*status_bar_event_box, true, true, 6); + status_bar_hpacker.pack_start (menu_bar_base, false, false, 2); #else - /* time to get out of here */ - finish(); - return TRUE; + top_packer.pack_start (menu_bar_base, false, false); #endif -} + main_vpacker.pack_start (top_packer, false, false); + + /* now add the transport frame to the top of main window */ + + main_vpacker.pack_start (transport_frame, false, false); + main_vpacker.pack_start (_tabs, true, true); + +#ifdef TOP_MENUBAR + main_vpacker.pack_start (status_bar_hpacker, false, false); +#endif + + for (int i = 0; i < 9; ++i) { + std::string const a = string_compose (X_("script-action-%1"), i + 1); + Glib::RefPtr act = ActionManager::get_action(X_("Editor"), a.c_str()); + assert (act); + action_script_call_btn[i].set_text (string_compose ("%1", i+1)); + action_script_call_btn[i].set_related_action (act); + if (act->get_sensitive ()) { + action_script_call_btn[i].set_visual_state (Gtkmm2ext::VisualState (action_script_call_btn[i].visual_state() & ~Gtkmm2ext::Insensitive)); + } else { + action_script_call_btn[i].set_visual_state (Gtkmm2ext::VisualState (action_script_call_btn[i].visual_state() | Gtkmm2ext::Insensitive)); + } + const int row = i % 3; + const int col = i / 3; + action_script_table.attach (action_script_call_btn[i], col, col + 1, row, row + 1, EXPAND, EXPAND, 1, 1); + action_script_call_btn[i].set_no_show_all (); + } + action_script_table.show (); + + setup_transport(); + build_menu_bar (); + setup_tooltips (); + + _main_window.signal_delete_event().connect (sigc::mem_fun (*this, &ARDOUR_UI::main_window_delete_event)); + + /* pack the main vpacker into the main window and show everything + */ + + _main_window.add (main_vpacker); + transport_frame.show_all (); + + const XMLNode* mnode = main_window_settings (); + + if (mnode) { + XMLProperty const * prop; + gint x = -1; + gint y = -1; + gint w = -1; + gint h = -1; + + if ((prop = mnode->property (X_("x"))) != 0) { + x = atoi (prop->value()); + } + + if ((prop = mnode->property (X_("y"))) != 0) { + y = atoi (prop->value()); + } + + if ((prop = mnode->property (X_("w"))) != 0) { + w = atoi (prop->value()); + } + + if ((prop = mnode->property (X_("h"))) != 0) { + h = atoi (prop->value()); + } + + if (x >= 0 && y >= 0 && w >= 0 && h >= 0) { + _main_window.set_position (Gtk::WIN_POS_NONE); + } + + if (x >= 0 && y >= 0) { + _main_window.move (x, y); + } + + if (w > 0 && h > 0) { + _main_window.set_default_size (w, h); + } + + std::string current_tab; + + if ((prop = mnode->property (X_("current-tab"))) != 0) { + current_tab = prop->value(); + } else { + current_tab = "editor"; + } + if (mixer && current_tab == "mixer") { + _tabs.set_current_page (_tabs.page_num (mixer->contents())); + } else if (rc_option_editor && current_tab == "preferences") { + _tabs.set_current_page (_tabs.page_num (rc_option_editor->contents())); + } else if (editor) { + _tabs.set_current_page (_tabs.page_num (editor->contents())); + } + } + + setup_toplevel_window (_main_window, "", this); + _main_window.show_all (); + + _tabs.set_show_tabs (false); + + /* It would be nice if Gtkmm had wrapped this rather than just + * deprecating the old set_window_creation_hook() method, but oh well... + */ + g_signal_connect (_tabs.gobj(), "create-window", (GCallback) ::tab_window_root_drop, this); + + return 0; +}