gtk2_ardour/ardour_ui_dependents.cc

   1 /*
   2     Copyright (C) 2000 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 #ifdef WAF_BUILD
  21 #include "gtk2ardour-config.h"
  22 #endif
  23
  24 /* this file exists solely to break compilation dependencies that
  25    would connect changes to the mixer or editor objects.
  26 */
  27
  28 #include <cstdio>
  29
  30 #include "pbd/error.h"
  31
  32 #include "ardour/session.h"
  33
  34 #include "gtkmm2ext/bindings.h"
  35
  36 #include "actions.h"
  37 #include "ardour_ui.h"
  38 #include "public_editor.h"
  39 #include "meterbridge.h"
  40 #include "luainstance.h"
  41 #include "luawindow.h"
  42 #include "mixer_ui.h"
  43 #include "keyboard.h"
  44 #include "splash.h"
  45 #include "rc_option_editor.h"
  46 #include "route_params_ui.h"
  47 #include "time_info_box.h"
  48 #include "opts.h"
  49 #include "utils.h"
  50
  51 #include "pbd/i18n.h"
  52
  53 using namespace Gtk;
  54 using namespace PBD;
  55
  56 namespace ARDOUR {
  57         class Session;
  58         class Route;
  59 }
  60
  61 using namespace ARDOUR;
  62
  63 void
  64 ARDOUR_UI::we_have_dependents ()
  65 {
  66         install_actions ();
  67         load_bindings ();
  68
  69         ProcessorBox::register_actions ();
  70
  71         /* Global, editor, mixer, processor box actions are defined now. Link
  72            them with any bindings, so that GTK does not get a chance to define
  73            the GTK accel map entries first when we ask the GtkUIManager to
  74            create menus/widgets.
  75
  76            If GTK adds the actions to its accel map before we do, we lose our
  77            freedom to use any keys. More precisely, we can use any keys, but
  78            ones that GTK considers illegal as accelerators will not show up in
  79            menus.
  80
  81            There are other dynamic actions that can be created by a monitor
  82            section, by step entry dialogs. These need to be handled
  83            separately. They don't tend to use GTK-illegal bindings and more
  84            importantly they don't have menus showing the bindings, so it is
  85            less of an issue.
  86         */
  87
  88         Gtkmm2ext::Bindings::associate_all ();
  89
  90         editor->setup_tooltips ();
  91         editor->UpdateAllTransportClocks.connect (sigc::mem_fun (*this, &ARDOUR_UI::update_transport_clocks));
  92
  93         /* catch up on tabbable state, in the right order to leave the editor
  94          * selected by default
  95          */
  96
  97         tabbable_state_change (*rc_option_editor);
  98         tabbable_state_change (*mixer);
  99         tabbable_state_change (*editor);
 100
 101         /* all actions are defined */
 102
 103         ActionManager::load_menus (ARDOUR_COMMAND_LINE::menus_file);
 104
 105         /* catch up on parameters */
 106
 107         boost::function<void (std::string)> pc (boost::bind (&ARDOUR_UI::parameter_changed, this, _1));
 108         Config->map_parameters (pc);
 109
 110         UIConfiguration::instance().reset_dpi ();
 111 }
 112
 113 void
 114 ARDOUR_UI::connect_dependents_to_session (ARDOUR::Session *s)
 115 {
 116         DisplaySuspender ds;
 117         BootMessage (_("Setup Editor"));
 118         editor->set_session (s);
 119         BootMessage (_("Setup Mixer"));
 120         mixer->set_session (s);
 121         meterbridge->set_session (s);
 122         luawindow->set_session (s);
 123
 124         /* its safe to do this now */
 125
 126         BootMessage (_("Reload Session History"));
 127         s->restore_history ("");
 128 }
 129
 130 /** The main editor window has been closed */
 131 gint
 132 ARDOUR_UI::exit_on_main_window_close (GdkEventAny * /*ev*/)
 133 {
 134 #ifdef TOP_MENUBAR
 135         /* just hide the window, and return - the top menu stays up */
 136         editor->hide ();
 137         return TRUE;
 138 #else
 139         /* time to get out of here */
 140         finish();
 141         return TRUE;
 142 #endif
 143 }
 144
 145 GtkNotebook*
 146 ARDOUR_UI::tab_window_root_drop (GtkNotebook* src,
 147                                  GtkWidget* w,
 148                                  gint x,
 149                                  gint y,
 150                                  gpointer)
 151 {
 152         using namespace std;
 153         Gtk::Notebook* nb = 0;
 154         Gtk::Window* win = 0;
 155         Gtkmm2ext::Tabbable* tabbable = 0;
 156
 157
 158         if (w == GTK_WIDGET(editor->contents().gobj())) {
 159                 tabbable = editor;
 160         } else if (w == GTK_WIDGET(mixer->contents().gobj())) {
 161                 tabbable = mixer;
 162         } else if (w == GTK_WIDGET(rc_option_editor->contents().gobj())) {
 163                 tabbable = rc_option_editor;
 164         } else {
 165                 return 0;
 166         }
 167
 168         nb = tabbable->tab_root_drop ();
 169         win = tabbable->own_window ();
 170
 171         if (nb) {
 172                 win->move (x, y);
 173                 win->show_all ();
 174                 win->present ();
 175                 return nb->gobj();
 176         }
 177
 178         return 0; /* what was that? */
 179 }
 180
 181 bool
 182 ARDOUR_UI::idle_ask_about_quit ()
 183 {
 184         if (_session && _session->dirty()) {
 185                 finish ();
 186         } else {
 187                 /* no session or session not dirty, but still ask anyway */
 188
 189                 Gtk::MessageDialog msg (string_compose (_("Quit %1?"), PROGRAM_NAME),
 190                                         false, /* no markup */
 191                                         Gtk::MESSAGE_INFO,
 192                                         Gtk::BUTTONS_YES_NO,
 193                                         true); /* modal */
 194                 msg.set_default_response (Gtk::RESPONSE_YES);
 195
 196                 if (msg.run() == Gtk::RESPONSE_YES) {
 197                         finish ();
 198                 }
 199         }
 200
 201         /* not reached but keep the compiler happy */
 202
 203         return false;
 204 }
 205
 206 bool
 207 ARDOUR_UI::main_window_delete_event (GdkEventAny* ev)
 208 {
 209         /* quit the application as soon as we go idle. If we call this here,
 210          * the window manager/desktop can think we're taking too longer to
 211          * handle the "delete" event
 212          */
 213
 214         Glib::signal_idle().connect (sigc::mem_fun (*this, &ARDOUR_UI::idle_ask_about_quit));
 215
 216         return true;
 217 }
 218
 219 static GtkNotebook*
 220 tab_window_root_drop (GtkNotebook* src,
 221                       GtkWidget* w,
 222                       gint x,
 223                       gint y,
 224                       gpointer user_data)
 225 {
 226         return ARDOUR_UI::instance()->tab_window_root_drop (src, w, x, y, user_data);
 227 }
 228
 229 int
 230 ARDOUR_UI::setup_windows ()
 231 {
 232         /* actions do not need to be defined when we load keybindings. They
 233          * will be lazily discovered. But bindings do need to exist when we
 234          * create windows/tabs with their own binding sets.
 235          */
 236
 237         keyboard->setup_keybindings ();
 238
 239         _tabs.set_show_border(false);
 240         _tabs.signal_switch_page().connect (sigc::mem_fun (*this, &ARDOUR_UI::tabs_switch));
 241         _tabs.signal_page_added().connect (sigc::mem_fun (*this, &ARDOUR_UI::tabs_page_added));
 242         _tabs.signal_page_removed().connect (sigc::mem_fun (*this, &ARDOUR_UI::tabs_page_removed));
 243
 244         rc_option_editor = new RCOptionEditor;
 245         rc_option_editor->StateChange.connect (sigc::mem_fun (*this, &ARDOUR_UI::tabbable_state_change));
 246
 247         if (create_editor ()) {
 248                 error << _("UI: cannot setup editor") << endmsg;
 249                 return -1;
 250         }
 251
 252         if (create_mixer ()) {
 253                 error << _("UI: cannot setup mixer") << endmsg;
 254                 return -1;
 255         }
 256
 257         if (create_meterbridge ()) {
 258                 error << _("UI: cannot setup meterbridge") << endmsg;
 259                 return -1;
 260         }
 261
 262         if (create_luawindow ()) {
 263                 error << _("UI: cannot setup luawindow") << endmsg;
 264                 return -1;
 265         }
 266
 267         /* order of addition affects order seen in initial window display */
 268
 269         rc_option_editor->add_to_notebook (_tabs, _("Preferences"));
 270         mixer->add_to_notebook (_tabs, _("Mixer"));
 271         editor->add_to_notebook (_tabs, _("Editor"));
 272
 273         time_info_box = new TimeInfoBox (false);
 274         /* all other dialogs are created conditionally */
 275
 276         we_have_dependents ();
 277
 278 #ifdef TOP_MENUBAR
 279         EventBox* status_bar_event_box = manage (new EventBox);
 280
 281         status_bar_event_box->add (status_bar_label);
 282         status_bar_event_box->add_events (Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK);
 283         status_bar_label.set_size_request (300, -1);
 284
 285         status_bar_label.show ();
 286         status_bar_event_box->show ();
 287
 288         status_bar_event_box->signal_button_press_event().connect (mem_fun (*this, &ARDOUR_UI::status_bar_button_press));
 289
 290         status_bar_hpacker.pack_start (*status_bar_event_box, true, true, 6);
 291         status_bar_hpacker.pack_start (menu_bar_base, false, false, 2);
 292 #else
 293         top_packer.pack_start (menu_bar_base, false, false);
 294 #endif
 295
 296         main_vpacker.pack_start (top_packer, false, false);
 297
 298         /* now add the transport frame to the top of main window */
 299
 300         main_vpacker.pack_start (transport_frame, false, false);
 301         main_vpacker.pack_start (_tabs, true, true);
 302
 303 #ifdef TOP_MENUBAR
 304         main_vpacker.pack_start (status_bar_hpacker, false, false);
 305 #endif
 306
 307         for (int i = 0; i < 9; ++i) {
 308                 std::string const a = string_compose (X_("script-action-%1"), i + 1);
 309                 Glib::RefPtr<Action> act = ActionManager::get_action(X_("Editor"), a.c_str());
 310                 assert (act);
 311                 action_script_call_btn[i].set_text (string_compose ("%1", i+1));
 312                 action_script_call_btn[i].set_related_action (act);
 313                 action_script_call_btn[i].signal_button_press_event().connect (sigc::bind (sigc::mem_fun(*this, &ARDOUR_UI::bind_lua_action_script), i), false);
 314                 if (act->get_sensitive ()) {
 315                         action_script_call_btn[i].set_visual_state (Gtkmm2ext::VisualState (action_script_call_btn[i].visual_state() & ~Gtkmm2ext::Insensitive));
 316                 } else {
 317                         action_script_call_btn[i].set_visual_state (Gtkmm2ext::VisualState (action_script_call_btn[i].visual_state() | Gtkmm2ext::Insensitive));
 318                 }
 319                 const int row = i % 2;
 320                 const int col = i / 2;
 321                 action_script_table.attach (action_script_call_btn[i], col, col + 1, row, row + 1, EXPAND, EXPAND, 1, 0);
 322                 action_script_call_btn[i].set_no_show_all ();
 323         }
 324         action_script_table.show ();
 325
 326         setup_transport();
 327         build_menu_bar ();
 328         setup_tooltips ();
 329
 330         _main_window.signal_delete_event().connect (sigc::mem_fun (*this, &ARDOUR_UI::main_window_delete_event));
 331
 332         /* pack the main vpacker into the main window and show everything
 333          */
 334
 335         _main_window.add (main_vpacker);
 336         transport_frame.show_all ();
 337
 338         const XMLNode* mnode = main_window_settings ();
 339
 340         if (mnode) {
 341                 XMLProperty const * prop;
 342                 gint x = -1;
 343                 gint y = -1;
 344                 gint w = -1;
 345                 gint h = -1;
 346
 347                 if ((prop = mnode->property (X_("x"))) != 0) {
 348                         x = atoi (prop->value());
 349                 }
 350
 351                 if ((prop = mnode->property (X_("y"))) != 0) {
 352                         y = atoi (prop->value());
 353                 }
 354
 355                 if ((prop = mnode->property (X_("w"))) != 0) {
 356                         w = atoi (prop->value());
 357                 }
 358
 359                 if ((prop = mnode->property (X_("h"))) != 0) {
 360                         h = atoi (prop->value());
 361                 }
 362
 363                 if (x >= 0 && y >= 0 && w >= 0 && h >= 0) {
 364                         _main_window.set_position (Gtk::WIN_POS_NONE);
 365                 }
 366
 367                 if (x >= 0 && y >= 0) {
 368                         _main_window.move (x, y);
 369                 }
 370
 371                 if (w > 0 && h > 0) {
 372                         _main_window.set_default_size (w, h);
 373                 }
 374
 375                 std::string current_tab;
 376
 377                 if ((prop = mnode->property (X_("current-tab"))) != 0) {
 378                         current_tab = prop->value();
 379                 } else {
 380                         current_tab = "editor";
 381                 }
 382                 if (mixer && current_tab == "mixer") {
 383                         _tabs.set_current_page (_tabs.page_num (mixer->contents()));
 384                 } else if (rc_option_editor && current_tab == "preferences") {
 385                         _tabs.set_current_page (_tabs.page_num (rc_option_editor->contents()));
 386                 } else if (editor) {
 387                         _tabs.set_current_page (_tabs.page_num (editor->contents()));
 388                 }
 389         }
 390
 391         setup_toplevel_window (_main_window, "", this);
 392         _main_window.show_all ();
 393
 394         _tabs.set_show_tabs (false);
 395
 396         /* It would be nice if Gtkmm had wrapped this rather than just
 397          * deprecating the old set_window_creation_hook() method, but oh well...
 398          */
 399         g_signal_connect (_tabs.gobj(), "create-window", (GCallback) ::tab_window_root_drop, this);
 400
 401         return 0;
 402 }
 403
 404 bool
 405 ARDOUR_UI::bind_lua_action_script (GdkEventButton*ev, int i)
 406 {
 407         if (ev->button != 3) {
 408                 return false;
 409         }
 410         LuaInstance *li = LuaInstance::instance();
 411         li->interactive_add (LuaScriptInfo::EditorAction, i);
 412         return true;
 413 }