gtk2_ardour/time_info_box.cc

   1 /*
   2     Copyright (C) 2011 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 #include <algorithm>
  21 #include "pbd/compose.h"
  22
  23 #include "gtkmm2ext/cairocell.h"
  24 #include "gtkmm2ext/gui_thread.h"
  25 #include "gtkmm2ext/utils.h"
  26 #include "gtkmm2ext/stateful_button.h"
  27 #include "gtkmm2ext/actions.h"
  28
  29 #include "ardour/location.h"
  30 #include "ardour/session.h"
  31
  32 #include "time_info_box.h"
  33 #include "audio_clock.h"
  34 #include "editor.h"
  35
  36 #include "i18n.h"
  37
  38 using namespace Gtk;
  39 using namespace ARDOUR;
  40 using std::min;
  41 using std::max;
  42
  43 TimeInfoBox::TimeInfoBox ()
  44         : left (2, 4)
  45         , right (2, 4)
  46         , syncing_selection (false)
  47         , syncing_punch (false)
  48 {
  49         selection_start = new AudioClock ("selection-start", false, "selection", false, false, false, false);
  50         selection_end = new AudioClock ("selection-end", false, "selection", false, false, false, false);
  51         selection_length = new AudioClock ("selection-length", false, "selection", false, false, true, false);
  52
  53         punch_start = new AudioClock ("punch-start", false, "punch", false, false, false, false);
  54         punch_end = new AudioClock ("punch-end", false, "punch", false, false, false, false);
  55
  56         selection_start->set_draw_background (false);
  57         selection_end->set_draw_background (false);
  58         selection_length->set_draw_background (false);
  59         punch_start->set_draw_background (false);
  60         punch_end->set_draw_background (false);
  61
  62         selection_title.set_text (_("Selection"));
  63         punch_title.set_text (_("Punch"));
  64
  65         set_homogeneous (false);
  66         set_spacing (6);
  67         set_border_width (2);
  68
  69         pack_start (left, true, true);
  70         pack_start (right, true, true);
  71
  72         left.set_homogeneous (false);
  73         left.set_spacings (0);
  74         left.set_border_width (2);
  75         left.set_col_spacings (2);
  76
  77         right.set_homogeneous (false);
  78         right.set_spacings (0);
  79         right.set_border_width (2);
  80         right.set_col_spacings (2);
  81
  82         Gtk::Label* l;
  83
  84         selection_title.set_name ("TimeInfoSelectionTitle");
  85         left.attach (selection_title, 0, 2, 0, 1);
  86         l = manage (new Label);
  87         l->set_text (_("Start"));
  88         l->set_alignment (1.0, 0.5);
  89         l->set_name (X_("TimeInfoSelectionLabel"));
  90         left.attach (*l, 0, 1, 1, 2, FILL);
  91         left.attach (*selection_start, 1, 2, 1, 2);
  92
  93         l = manage (new Label);
  94         l->set_text (_("End"));
  95         l->set_alignment (1.0, 0.5);
  96         l->set_name (X_("TimeInfoSelectionLabel"));
  97         left.attach (*l, 0, 1, 2, 3, FILL);
  98         left.attach (*selection_end, 1, 2, 2, 3);
  99
 100         l = manage (new Label);
 101         l->set_text (_("Length"));
 102         l->set_alignment (1.0, 0.5);
 103         l->set_name (X_("TimeInfoSelectionLabel"));
 104         left.attach (*l, 0, 1, 3, 4, FILL);
 105         left.attach (*selection_length, 1, 2, 3, 4);
 106
 107         punch_in_button.set_name ("punch button");
 108         punch_out_button.set_name ("punch button");
 109         punch_in_button.set_text (_("In"));
 110         punch_out_button.set_text (_("Out"));
 111
 112         Glib::RefPtr<Action> act = ActionManager::get_action ("Transport", "TogglePunchIn");
 113         punch_in_button.set_related_action (act);
 114         act = ActionManager::get_action ("Transport", "TogglePunchOut");
 115         punch_out_button.set_related_action (act);
 116
 117         Gtkmm2ext::UI::instance()->set_tip (punch_in_button, _("Start recording at auto-punch start"));
 118         Gtkmm2ext::UI::instance()->set_tip (punch_out_button, _("Stop recording at auto-punch end"));
 119
 120         punch_title.set_name ("TimeInfoSelectionTitle");
 121         right.attach (punch_title, 2, 4, 0, 1);
 122         right.attach (punch_in_button, 2, 3, 1, 2, FILL, SHRINK);
 123         right.attach (*punch_start, 3, 4, 1, 2);
 124         right.attach (punch_out_button, 2, 3, 2, 3, FILL, SHRINK);
 125         right.attach (*punch_end, 3, 4, 2, 3);
 126
 127         show_all ();
 128
 129         selection_start->mode_changed.connect (sigc::bind (sigc::mem_fun (*this, &TimeInfoBox::sync_selection_mode), selection_start));
 130         selection_end->mode_changed.connect (sigc::bind (sigc::mem_fun (*this, &TimeInfoBox::sync_selection_mode), selection_end));
 131         selection_length->mode_changed.connect (sigc::bind (sigc::mem_fun (*this, &TimeInfoBox::sync_selection_mode), selection_length));
 132
 133         punch_start->mode_changed.connect (sigc::bind (sigc::mem_fun (*this, &TimeInfoBox::sync_punch_mode), punch_start));
 134         punch_end->mode_changed.connect (sigc::bind (sigc::mem_fun (*this, &TimeInfoBox::sync_punch_mode), punch_end));
 135
 136         selection_start->signal_button_release_event().connect (sigc::bind (sigc::mem_fun (*this, &TimeInfoBox::clock_button_release_event), selection_start), true);
 137         selection_end->signal_button_release_event().connect (sigc::bind (sigc::mem_fun (*this, &TimeInfoBox::clock_button_release_event), selection_end), true);
 138
 139         punch_start->signal_button_release_event().connect (sigc::bind (sigc::mem_fun (*this, &TimeInfoBox::clock_button_release_event), punch_start), true);
 140         punch_end->signal_button_release_event().connect (sigc::bind (sigc::mem_fun (*this, &TimeInfoBox::clock_button_release_event), punch_end), true);
 141
 142         Editor::instance().get_selection().TimeChanged.connect (sigc::mem_fun (*this, &TimeInfoBox::selection_changed));
 143         Editor::instance().get_selection().RegionsChanged.connect (sigc::mem_fun (*this, &TimeInfoBox::selection_changed));
 144
 145         Editor::instance().MouseModeChanged.connect (editor_connections, invalidator(*this), ui_bind (&TimeInfoBox::track_mouse_mode, this), gui_context());
 146 }
 147
 148 TimeInfoBox::~TimeInfoBox ()
 149 {
 150         delete selection_length;
 151         delete selection_end;
 152         delete selection_start;
 153
 154         delete punch_start;
 155         delete punch_end;
 156 }
 157
 158 void
 159 TimeInfoBox::track_mouse_mode ()
 160 {
 161         selection_changed ();
 162 }
 163
 164 bool
 165 TimeInfoBox::clock_button_release_event (GdkEventButton* ev, AudioClock* src)
 166 {
 167         if (!_session) {
 168                 return false;
 169         }
 170
 171         if (ev->button == 1) {
 172                 if (!src->off()) {
 173                         _session->request_locate (src->current_time ());
 174                 }
 175                 return true;
 176         }
 177
 178         return false;
 179 }
 180
 181 void
 182 TimeInfoBox::sync_selection_mode (AudioClock* src)
 183 {
 184         if (!syncing_selection) {
 185                 syncing_selection = true;
 186                 selection_start->set_mode (src->mode());
 187                 selection_end->set_mode (src->mode());
 188                 selection_length->set_mode (src->mode());
 189                 syncing_selection = false;
 190         }
 191 }
 192
 193 void
 194 TimeInfoBox::sync_punch_mode (AudioClock* src)
 195 {
 196         if (!syncing_punch) {
 197                 syncing_punch = true;
 198                 punch_start->set_mode (src->mode());
 199                 punch_end->set_mode (src->mode());
 200                 syncing_punch = false;
 201         }
 202 }
 203
 204
 205 void
 206 TimeInfoBox::set_session (Session* s)
 207 {
 208         SessionHandlePtr::set_session (s);
 209
 210         selection_start->set_session (s);
 211         selection_end->set_session (s);
 212         selection_length->set_session (s);
 213
 214         punch_start->set_session (s);
 215         punch_end->set_session (s);
 216
 217         if (s) {
 218                 Location* punch = s->locations()->auto_punch_location ();
 219
 220                 if (punch) {
 221                         watch_punch (punch);
 222                 }
 223
 224                 punch_changed (punch);
 225
 226                 _session->auto_punch_location_changed.connect (_session_connections, MISSING_INVALIDATOR,
 227                                                                boost::bind (&TimeInfoBox::punch_location_changed, this, _1), gui_context());
 228         }
 229 }
 230
 231 void
 232 TimeInfoBox::selection_changed ()
 233 {
 234         framepos_t s, e;
 235         Selection& selection (Editor::instance().get_selection());
 236
 237         switch (Editor::instance().current_mouse_mode()) {
 238
 239         case Editing::MouseObject:
 240                 if (Editor::instance().internal_editing()) {
 241                         /* displaying MIDI note selection is tricky */
 242
 243                         selection_start->set_off (true);
 244                         selection_end->set_off (true);
 245                         selection_length->set_off (true);
 246
 247                 } else {
 248                         if (selection.regions.empty()) {
 249                                 if (selection.points.empty()) {
 250                                         selection_start->set_off (true);
 251                                         selection_end->set_off (true);
 252                                         selection_length->set_off (true);
 253                                 } else {
 254                                         s = max_framepos;
 255                                         e = 0;
 256                                         for (PointSelection::iterator i = selection.points.begin(); i != selection.points.end(); ++i) {
 257                                                 s = min (s, (framepos_t) i->start);
 258                                                 e = max (e, (framepos_t) i->end);
 259                                         }
 260                                         selection_start->set_off (false);
 261                                         selection_end->set_off (false);
 262                                         selection_length->set_off (false);
 263                                         selection_start->set (s);
 264                                         selection_end->set (e);
 265                                         selection_length->set (e - s + 1);
 266                                 }
 267                         } else {
 268                                 s = selection.regions.start();
 269                                 e = selection.regions.end_frame();
 270                                 selection_start->set_off (false);
 271                                 selection_end->set_off (false);
 272                                 selection_length->set_off (false);
 273                                 selection_start->set (s);
 274                                 selection_end->set (e);
 275                                 selection_length->set (e - s + 1);
 276                         }
 277                 }
 278                 break;
 279
 280         case Editing::MouseRange:
 281                 if (selection.time.empty()) {
 282                         selection_start->set_off (true);
 283                         selection_end->set_off (true);
 284                         selection_length->set_off (true);
 285                 } else {
 286                         selection_start->set_off (false);
 287                         selection_end->set_off (false);
 288                         selection_length->set_off (false);
 289                         selection_start->set (selection.time.start());
 290                         selection_end->set (selection.time.end_frame());
 291                         selection_length->set (selection.time.length());
 292                 }
 293                 break;
 294
 295         default:
 296                 selection_start->set_off (true);
 297                 selection_end->set_off (true);
 298                 selection_length->set_off (true);
 299                 break;
 300         }
 301 }
 302
 303 void
 304 TimeInfoBox::punch_location_changed (Location* loc)
 305 {
 306         if (loc) {
 307                 watch_punch (loc);
 308         }
 309 }
 310
 311 void
 312 TimeInfoBox::watch_punch (Location* punch)
 313 {
 314         punch_connections.drop_connections ();
 315
 316         punch->start_changed.connect (punch_connections, MISSING_INVALIDATOR, boost::bind (&TimeInfoBox::punch_changed, this, _1), gui_context());
 317         punch->end_changed.connect (punch_connections, MISSING_INVALIDATOR, boost::bind (&TimeInfoBox::punch_changed, this, _1), gui_context());
 318
 319         punch_changed (punch);
 320 }
 321
 322 void
 323 TimeInfoBox::punch_changed (Location* loc)
 324 {
 325         if (!loc) {
 326                 punch_start->set_off (true);
 327                 punch_end->set_off (true);
 328                 return;
 329         }
 330
 331         punch_start->set_off (false);
 332         punch_end->set_off (false);
 333
 334         punch_start->set (loc->start());
 335         punch_end->set (loc->end());
 336 }
 337