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 "luawindow.h"
  41 #include "mixer_ui.h"
  42 #include "keyboard.h"
  43 #include "splash.h"
  44 #include "rc_option_editor.h"
  45 #include "route_params_ui.h"
  46 #include "opts.h"
  47 #include "utils.h"
  48
  49 #include "i18n.h"
  50
  51 using namespace Gtk;
  52 using namespace PBD;
  53
  54 namespace ARDOUR {
  55         class Session;
  56         class Route;
  57 }
  58
  59 using namespace ARDOUR;
  60
  61 void
  62 ARDOUR_UI::we_have_dependents ()
  63 {
  64         install_actions ();
  65         load_bindings ();
  66
  67         ProcessorBox::register_actions ();
  68
  69         /* Global, editor, mixer, processor box actions are defined now. Link
  70            them with any bindings, so that GTK does not get a chance to define
  71            the GTK accel map entries first when we ask the GtkUIManager to
  72            create menus/widgets.
  73
  74            If GTK adds the actions to its accel map before we do, we lose our
  75            freedom to use any keys. More precisely, we can use any keys, but
  76            ones that GTK considers illegal as accelerators will not show up in
  77            menus.
  78
  79            There are other dynamic actions that can be created by a monitor
  80            section, by step entry dialogs. These need to be handled
  81            separately. They don't tend to use GTK-illegal bindings and more
  82            importantly they don't have menus showing the bindings, so it is
  83            less of an issue.
  84         */
  85
  86         Gtkmm2ext::Bindings::associate_all ();
  87
  88         editor->setup_tooltips ();
  89         editor->UpdateAllTransportClocks.connect (sigc::mem_fun (*this, &ARDOUR_UI::update_transport_clocks));
  90
  91         /* catch up on tabbable state, in the right order to leave the editor
  92          * selected by default
  93          */
  94
  95         tabbable_state_change (*rc_option_editor);
  96         tabbable_state_change (*mixer);
  97         tabbable_state_change (*editor);
  98
  99         /* all actions are defined */
 100
 101         ActionManager::load_menus (ARDOUR_COMMAND_LINE::menus_file);
 102
 103         editor->track_mixer_selection ();
 104         mixer->track_editor_selection ();
 105
 106         /* catch up on parameters */
 107
 108         boost::function<void (std::string)> pc (boost::bind (&ARDOUR_UI::parameter_changed, this, _1));
 109         Config->map_parameters (pc);
 110
 111         UIConfiguration::instance().reset_dpi ();
 112 }
 113
 114 void
 115 ARDOUR_UI::connect_dependents_to_session (ARDOUR::Session *s)
 116 {
 117         DisplaySuspender ds;
 118         BootMessage (_("Setup Editor"));
 119         editor->set_session (s);
 120         BootMessage (_("Setup Mixer"));
 121         mixer->set_session (s);
 122         meterbridge->set_session (s);
 123         luawindow->set_session (s);
 124
 125         /* its safe to do this now */
 126
 127         BootMessage (_("Reload Session History"));
 128         s->restore_history ("");
 129 }
 130
 131 /** The main editor window has been closed */
 132 gint
 133 ARDOUR_UI::exit_on_main_window_close (GdkEventAny * /*ev*/)
 134 {
 135 #ifdef TOP_MENUBAR
 136         /* just hide the window, and return - the top menu stays up */
 137         editor->hide ();
 138         return TRUE;
 139 #else
 140         /* time to get out of here */
 141         finish();
 142         return TRUE;
 143 #endif
 144 }
 145
 146 GtkNotebook*
 147 ARDOUR_UI::tab_window_root_drop (GtkNotebook* src,
 148                                  GtkWidget* w,
 149                                  gint x,
 150                                  gint y,
 151                                  gpointer)
 152 {
 153         using namespace std;
 154         Gtk::Notebook* nb = 0;
 155         Gtk::Window* win = 0;
 156         Gtkmm2ext::Tabbable* tabbable = 0;
 157
 158
 159         if (w == GTK_WIDGET(editor->contents().gobj())) {
 160                 tabbable = editor;
 161         } else if (w == GTK_WIDGET(mixer->contents().gobj())) {
 162                 tabbable = mixer;
 163         } else if (w == GTK_WIDGET(rc_option_editor->contents().gobj())) {
 164                 tabbable = rc_option_editor;
 165         } else {
 166                 return 0;
 167         }
 168
 169         nb = tabbable->tab_root_drop ();
 170         win = tabbable->own_window ();
 171
 172         if (nb) {
 173                 win->move (x, y);
 174                 win->show_all ();
 175                 win->present ();
 176                 return nb->gobj();
 177         }
 178
 179         return 0; /* what was that? */
 180 }
 181
 182 bool
 183 ARDOUR_UI::idle_ask_about_quit ()
 184 {
 185         if (_session && _session->dirty()) {
 186                 finish ();
 187         } else {
 188                 /* no session or session not dirty, but still ask anyway */
 189
 190                 Gtk::MessageDialog msg (string_compose ("Quit %1?", PROGRAM_NAME),
 191                                         false, /* no markup */
 192                                         Gtk::MESSAGE_INFO,
 193                                         Gtk::BUTTONS_YES_NO,
 194                                         true); /* modal */
 195                 msg.set_default_response (Gtk::RESPONSE_YES);
 196
 197                 if (msg.run() == Gtk::RESPONSE_YES) {
 198                         finish ();
 199                 }
 200         }
 201
 202         /* not reached but keep the compiler happy */
 203
 204         return false;
 205 }
 206
 207 bool
 208 ARDOUR_UI::main_window_delete_event (GdkEventAny* ev)
 209 {
 210         /* quit the application as soon as we go idle. If we call this here,
 211          * the window manager/desktop can think we're taking too longer to
 212          * handle the "delete" event
 213          */
 214
 215         Glib::signal_idle().connect (sigc::mem_fun (*this, &ARDOUR_UI::idle_ask_about_quit));
 216
 217         return true;
 218 }
 219
 220 static GtkNotebook*
 221 tab_window_root_drop (GtkNotebook* src,
 222                       GtkWidget* w,
 223                       gint x,
 224                       gint y,
 225                       gpointer user_data)
 226 {
 227         return ARDOUR_UI::instance()->tab_window_root_drop (src, w, x, y, user_data);
 228 }
 229
 230 int
 231 ARDOUR_UI::setup_windows ()
 232 {
 233         /* actions do not need to be defined when we load keybindings. They
 234          * will be lazily discovered. But bindings do need to exist when we
 235          * create windows/tabs with their own binding sets.
 236          */
 237
 238         keyboard->setup_keybindings ();
 239
 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         /* all other dialogs are created conditionally */
 274
 275         we_have_dependents ();
 276
 277 #ifdef TOP_MENUBAR
 278         EventBox* status_bar_event_box = manage (new EventBox);
 279
 280         status_bar_event_box->add (status_bar_label);
 281         status_bar_event_box->add_events (Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK);
 282         status_bar_label.set_size_request (300, -1);
 283
 284         status_bar_label.show ();
 285         status_bar_event_box->show ();
 286
 287         status_bar_event_box->signal_button_press_event().connect (mem_fun (*this, &ARDOUR_UI::status_bar_button_press));
 288
 289         status_bar_hpacker.pack_start (*status_bar_event_box, true, true, 6);
 290         status_bar_hpacker.pack_start (menu_bar_base, false, false, 2);
 291 #else
 292         top_packer.pack_start (menu_bar_base, false, false);
 293 #endif
 294
 295         main_vpacker.pack_start (top_packer, false, false);
 296
 297         /* now add the transport frame to the top of main window */
 298
 299         main_vpacker.pack_start (transport_frame, false, false);
 300         main_vpacker.pack_start (_tabs, true, true);
 301
 302 #ifdef TOP_MENUBAR
 303         main_vpacker.pack_start (status_bar_hpacker, false, false);
 304 #endif
 305
 306         setup_transport();
 307         build_menu_bar ();
 308         setup_tooltips ();
 309
 310         _main_window.signal_delete_event().connect (sigc::mem_fun (*this, &ARDOUR_UI::main_window_delete_event));
 311
 312         /* pack the main vpacker into the main window and show everything
 313          */
 314
 315         _main_window.add (main_vpacker);
 316         transport_frame.show_all ();
 317
 318         const XMLNode* mnode = main_window_settings ();
 319
 320         if (mnode) {
 321                 const XMLProperty* prop;
 322                 gint x = -1;
 323                 gint y = -1;
 324                 gint w = -1;
 325                 gint h = -1;
 326
 327                 if ((prop = mnode->property (X_("x"))) != 0) {
 328                         x = atoi (prop->value());
 329                 }
 330
 331                 if ((prop = mnode->property (X_("y"))) != 0) {
 332                         y = atoi (prop->value());
 333                 }
 334
 335                 if ((prop = mnode->property (X_("w"))) != 0) {
 336                         w = atoi (prop->value());
 337                 }
 338
 339                 if ((prop = mnode->property (X_("h"))) != 0) {
 340                         h = atoi (prop->value());
 341                 }
 342
 343                 if (x >= 0 && y >= 0 && w >= 0 && h >= 0) {
 344                         _main_window.set_position (Gtk::WIN_POS_NONE);
 345                 }
 346
 347                 if (x >= 0 && y >= 0) {
 348                         _main_window.move (x, y);
 349                 }
 350
 351                 if (w > 0 && h > 0) {
 352                         _main_window.set_default_size (w, h);
 353                 }
 354
 355                 std::string current_tab;
 356
 357                 if ((prop = mnode->property (X_("current-tab"))) != 0) {
 358                         current_tab = prop->value();
 359                 } else {
 360                         current_tab = "editor";
 361                 }
 362                 if (mixer && current_tab == "mixer") {
 363                         _tabs.set_current_page (_tabs.page_num (mixer->contents()));
 364                 } else if (rc_option_editor && current_tab == "preferences") {
 365                         _tabs.set_current_page (_tabs.page_num (rc_option_editor->contents()));
 366                 } else if (editor) {
 367                         _tabs.set_current_page (_tabs.page_num (editor->contents()));
 368                 }
 369         }
 370
 371         setup_toplevel_window (_main_window, "", this);
 372         _main_window.show_all ();
 373
 374         _tabs.set_show_tabs (false);
 375
 376         /* It would be nice if Gtkmm had wrapped this rather than just
 377          * deprecating the old set_window_creation_hook() method, but oh well...
 378          */
 379         g_signal_connect (_tabs.gobj(), "create-window", (GCallback) ::tab_window_root_drop, this);
 380
 381         return 0;
 382 }