?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Add a couple of missing attach_buffers() calls after _ports has been changed. I...
[ardour2.git] / gtk2_ardour / editor_rulers.cc
blob1c077e85527b4530299e36b801a346443c9863ad
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 #include <cstdio> // for sprintf, grrr
25 #include <cmath>
26 #include <inttypes.h>
27
28 #include <string>
29
30 #include <gtk/gtkaction.h>
31
32 #include "ardour/session.h"
33 #include "ardour/tempo.h"
34 #include "ardour/profile.h"
35 #include <gtkmm2ext/gtk_ui.h>
36
37 #include "editor.h"
38 #include "editing.h"
39 #include "actions.h"
40 #include "gtk-custom-hruler.h"
41 #include "gui_thread.h"
42 #include "time_axis_view.h"
43 #include "editor_drag.h"
44 #include "editor_cursors.h"
45
46 #include "i18n.h"
47
48 using namespace ARDOUR;
49 using namespace PBD;
50 using namespace Gtk;
51 using namespace Editing;
52
53 Editor *Editor::ruler_editor;
54
55 /* the order here must match the "metric" enums in editor.h */
56
57 GtkCustomMetric Editor::ruler_metrics[4] = {
58 {1, Editor::_metric_get_timecode },
59 {1, Editor::_metric_get_bbt },
60 {1, Editor::_metric_get_samples },
61 {1, Editor::_metric_get_minsec }
62 };
63
64 void
65 Editor::initialize_rulers ()
66 {
67 ruler_editor = this;
68 ruler_grabbed_widget = 0;
69
70 _ruler_separator = new Gtk::HSeparator();
71 _ruler_separator->set_size_request(-1, 2);
72 _ruler_separator->set_name("TimebarPadding");
73 _ruler_separator->show();
74
75 _minsec_ruler = gtk_custom_hruler_new ();
76 minsec_ruler = Glib::wrap (_minsec_ruler);
77 minsec_ruler->set_name ("MinSecRuler");
78 minsec_ruler->set_size_request (-1, (int)timebar_height);
79 gtk_custom_ruler_set_metric (GTK_CUSTOM_RULER(_minsec_ruler), &ruler_metrics[ruler_metric_minsec]);
80 minsec_ruler->hide ();
81 minsec_ruler->set_no_show_all();
82
83 _timecode_ruler = gtk_custom_hruler_new ();
84 timecode_ruler = Glib::wrap (_timecode_ruler);
85 timecode_ruler->set_name ("TimecodeRuler");
86 timecode_ruler->set_size_request (-1, (int)timebar_height);
87 gtk_custom_ruler_set_metric (GTK_CUSTOM_RULER(_timecode_ruler), &ruler_metrics[ruler_metric_timecode]);
88 timecode_ruler->hide ();
89 timecode_ruler->set_no_show_all();
90 timecode_nmarks = 0;
91
92 _bbt_ruler = gtk_custom_hruler_new ();
93 bbt_ruler = Glib::wrap (_bbt_ruler);
94 bbt_ruler->set_name ("BBTRuler");
95 bbt_ruler->set_size_request (-1, (int)timebar_height);
96 gtk_custom_ruler_set_metric (GTK_CUSTOM_RULER(_bbt_ruler), &ruler_metrics[ruler_metric_bbt]);
97 bbt_ruler->hide ();
98 bbt_ruler->set_no_show_all();
99 bbt_nmarks = 0;
100
101 _samples_ruler = gtk_custom_hruler_new ();
102 samples_ruler = Glib::wrap (_samples_ruler);
103 samples_ruler->set_name ("SamplesRuler");
104 samples_ruler->set_size_request (-1, (int) timebar_height);
105 gtk_custom_ruler_set_metric (GTK_CUSTOM_RULER (_samples_ruler), &ruler_metrics[ruler_metric_samples]);
106 samples_ruler->hide ();
107 samples_ruler->set_no_show_all ();
108
109 _bbt_ruler = gtk_custom_hruler_new ();
110 bbt_ruler = Glib::wrap (_bbt_ruler);
111 bbt_ruler->set_name ("BBTRuler");
112 bbt_ruler->set_size_request (-1, (int)timebar_height);
113 gtk_custom_ruler_set_metric (GTK_CUSTOM_RULER(_bbt_ruler), &ruler_metrics[ruler_metric_bbt]);
114 bbt_ruler->hide ();
115 bbt_ruler->set_no_show_all();
116 minsec_ruler->hide ();
117 minsec_ruler->set_no_show_all();
118 minsec_nmarks = 0;
119
120 using namespace Box_Helpers;
121 BoxList & ruler_lab_children = ruler_label_vbox.children();
122 BoxList & ruler_children = time_canvas_vbox.children();
123 BoxList & lab_children = time_button_vbox.children();
124
125 BoxList::iterator canvaspos = ruler_children.begin();
126
127 lab_children.push_back (Element(meter_label, PACK_SHRINK, PACK_START));
128 lab_children.push_back (Element(tempo_label, PACK_SHRINK, PACK_START));
129 lab_children.push_back (Element(range_mark_label, PACK_SHRINK, PACK_START));
130 lab_children.push_back (Element(transport_mark_label, PACK_SHRINK, PACK_START));
131 lab_children.push_back (Element(cd_mark_label, PACK_SHRINK, PACK_START));
132 lab_children.push_back (Element(mark_label, PACK_SHRINK, PACK_START));
133
134 ruler_lab_children.push_back (Element(minsec_label, PACK_SHRINK, PACK_START));
135 ruler_children.insert (canvaspos, Element(*minsec_ruler, PACK_SHRINK, PACK_START));
136 ruler_lab_children.push_back (Element(timecode_label, PACK_SHRINK, PACK_START));
137 ruler_children.insert (canvaspos, Element(*timecode_ruler, PACK_SHRINK, PACK_START));
138 ruler_lab_children.push_back (Element(samples_label, PACK_SHRINK, PACK_START));
139 ruler_children.insert (canvaspos, Element (*samples_ruler, PACK_SHRINK, PACK_START));
140 ruler_lab_children.push_back (Element(bbt_label, PACK_SHRINK, PACK_START));
141 ruler_children.insert (canvaspos, Element(*bbt_ruler, PACK_SHRINK, PACK_START));
142
143 timecode_ruler->add_events (Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK|Gdk::SCROLL_MASK);
144 bbt_ruler->add_events (Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK|Gdk::SCROLL_MASK);
145 samples_ruler->add_events (Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK|Gdk::SCROLL_MASK);
146 minsec_ruler->add_events (Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK|Gdk::SCROLL_MASK);
147
148 timecode_ruler->signal_button_release_event().connect (sigc::mem_fun(*this, &Editor::ruler_button_release));
149 bbt_ruler->signal_button_release_event().connect (sigc::mem_fun(*this, &Editor::ruler_button_release));
150 samples_ruler->signal_button_release_event().connect (sigc::mem_fun(*this, &Editor::ruler_button_release));
151 minsec_ruler->signal_button_release_event().connect (sigc::mem_fun(*this, &Editor::ruler_button_release));
152
153 timecode_ruler->signal_button_press_event().connect (sigc::mem_fun(*this, &Editor::ruler_button_press));
154 bbt_ruler->signal_button_press_event().connect (sigc::mem_fun(*this, &Editor::ruler_button_press));
155 samples_ruler->signal_button_press_event().connect (sigc::mem_fun(*this, &Editor::ruler_button_press));
156 minsec_ruler->signal_button_press_event().connect (sigc::mem_fun(*this, &Editor::ruler_button_press));
157
158 timecode_ruler->signal_motion_notify_event().connect (sigc::mem_fun(*this, &Editor::ruler_mouse_motion));
159 bbt_ruler->signal_motion_notify_event().connect (sigc::mem_fun(*this, &Editor::ruler_mouse_motion));
160 samples_ruler->signal_motion_notify_event().connect (sigc::mem_fun(*this, &Editor::ruler_mouse_motion));
161 minsec_ruler->signal_motion_notify_event().connect (sigc::mem_fun(*this, &Editor::ruler_mouse_motion));
162
163 timecode_ruler->signal_scroll_event().connect (sigc::mem_fun(*this, &Editor::ruler_scroll));
164 bbt_ruler->signal_scroll_event().connect (sigc::mem_fun(*this, &Editor::ruler_scroll));
165 samples_ruler->signal_scroll_event().connect (sigc::mem_fun(*this, &Editor::ruler_scroll));
166 minsec_ruler->signal_scroll_event().connect (sigc::mem_fun(*this, &Editor::ruler_scroll));
167
168 visible_timebars = 0; /*this will be changed below */
169 canvas_timebars_vsize = 0;
170 }
171
172 bool
173 Editor::ruler_scroll (GdkEventScroll* event)
174 {
175 framepos_t xdelta;
176 int direction = event->direction;
177 bool handled = false;
178
179 switch (direction) {
180 case GDK_SCROLL_UP:
181 temporal_zoom_step (true);
182 handled = true;
183 break;
184
185 case GDK_SCROLL_DOWN:
186 temporal_zoom_step (false);
187 handled = true;
188 break;
189
190 case GDK_SCROLL_LEFT:
191 xdelta = (current_page_frames() / 2);
192 if (leftmost_frame > xdelta) {
193 reset_x_origin (leftmost_frame - xdelta);
194 } else {
195 reset_x_origin (0);
196 }
197 handled = true;
198 break;
199
200 case GDK_SCROLL_RIGHT:
201 xdelta = (current_page_frames() / 2);
202 if (max_framepos - xdelta > leftmost_frame) {
203 reset_x_origin (leftmost_frame + xdelta);
204 } else {
205 reset_x_origin (max_framepos - current_page_frames());
206 }
207 handled = true;
208 break;
209
210 default:
211 /* what? */
212 break;
213 }
214
215 return handled;
216 }
217
218
219 bool
220 Editor::ruler_button_press (GdkEventButton* ev)
221 {
222 if (_session == 0) {
223 return false;
224 }
225
226 // jlc: grab ev->window ?
227 //Gtk::Main::grab_add (*minsec_ruler);
228 Widget * grab_widget = 0;
229
230 if (timecode_ruler->is_realized() && ev->window == timecode_ruler->get_window()->gobj()) {
231 grab_widget = timecode_ruler;
232 } else if (bbt_ruler->is_realized() && ev->window == bbt_ruler->get_window()->gobj()) {
233 grab_widget = bbt_ruler;
234 } else if (samples_ruler->is_realized() && ev->window == samples_ruler->get_window()->gobj()) {
235 grab_widget = samples_ruler;
236 } else if (minsec_ruler->is_realized() && ev->window == minsec_ruler->get_window()->gobj()) {
237 grab_widget = minsec_ruler;
238 }
239
240 if (grab_widget) {
241 grab_widget->add_modal_grab ();
242 ruler_grabbed_widget = grab_widget;
243 }
244
245 if (ev->button == 1) {
246 // Since we will locate the playhead on button release, cancel any running
247 // auditions.
248 if (_session->is_auditioning()) {
249 _session->cancel_audition ();
250 }
251
252 /* playhead cursor */
253 _drags->set (new CursorDrag (this, &playhead_cursor->canvas_item, false), reinterpret_cast<GdkEvent *> (ev));
254 _dragging_playhead = true;
255 }
256
257 return true;
258 }
259
260 bool
261 Editor::ruler_button_release (GdkEventButton* ev)
262 {
263 if (_session == 0) {
264 return false;
265 }
266
267 gint x,y;
268 Gdk::ModifierType state;
269
270 if (_drags->active ()) {
271 _drags->end_grab (reinterpret_cast<GdkEvent*> (ev));
272 _dragging_playhead = false;
273 }
274
275 if (ev->button == 3) {
276 /* need to use the correct x,y, the event lies */
277 time_canvas_event_box.get_window()->get_pointer (x, y, state);
278
279 stop_canvas_autoscroll();
280
281 framepos_t where = leftmost_frame + pixel_to_frame (x);
282 snap_to (where);
283 popup_ruler_menu (where);
284 }
285
286 if (ruler_grabbed_widget) {
287 ruler_grabbed_widget->remove_modal_grab();
288 ruler_grabbed_widget = 0;
289 }
290
291 return true;
292 }
293
294 bool
295 Editor::ruler_label_button_release (GdkEventButton* ev)
296 {
297 if (ev->button == 3) {
298 Gtk::Menu* m = dynamic_cast<Gtk::Menu*> (ActionManager::get_widget (X_("/RulerMenuPopup")));
299 if (m) {
300 m->popup (1, ev->time);
301 }
302 }
303
304 return true;
305 }
306
307
308 bool
309 Editor::ruler_mouse_motion (GdkEventMotion* ev)
310 {
311 if (_session == 0) {
312 return false;
313 }
314
315 if (_drags->active ()) {
316 _drags->motion_handler (reinterpret_cast<GdkEvent*> (ev), false);
317 }
318
319 return true;
320 }
321
322
323 void
324 Editor::popup_ruler_menu (framepos_t where, ItemType t)
325 {
326 using namespace Menu_Helpers;
327
328 if (editor_ruler_menu == 0) {
329 editor_ruler_menu = new Menu;
330 editor_ruler_menu->set_name ("ArdourContextMenu");
331 }
332
333 // always build from scratch
334 MenuList& ruler_items = editor_ruler_menu->items();
335 editor_ruler_menu->set_name ("ArdourContextMenu");
336 ruler_items.clear();
337
338 switch (t) {
339 case MarkerBarItem:
340 ruler_items.push_back (MenuElem (_("New location marker"), sigc::bind ( sigc::mem_fun(*this, &Editor::mouse_add_new_marker), where, false, false)));
341 ruler_items.push_back (MenuElem (_("Clear all locations"), sigc::mem_fun(*this, &Editor::clear_markers)));
342 ruler_items.push_back (MenuElem (_("Unhide locations"), sigc::mem_fun(*this, &Editor::unhide_markers)));
343 ruler_items.push_back (SeparatorElem ());
344 break;
345 case RangeMarkerBarItem:
346 //ruler_items.push_back (MenuElem (_("New Range")));
347 ruler_items.push_back (MenuElem (_("Clear all ranges"), sigc::mem_fun(*this, &Editor::clear_ranges)));
348 ruler_items.push_back (MenuElem (_("Unhide ranges"), sigc::mem_fun(*this, &Editor::unhide_ranges)));
349 ruler_items.push_back (SeparatorElem ());
350
351 break;
352 case TransportMarkerBarItem:
353
354 break;
355
356 case CdMarkerBarItem:
357 // TODO
358 ruler_items.push_back (MenuElem (_("New CD track marker"), sigc::bind ( sigc::mem_fun(*this, &Editor::mouse_add_new_marker), where, true, false)));
359 break;
360
361
362 case TempoBarItem:
363 ruler_items.push_back (MenuElem (_("New Tempo"), sigc::bind ( sigc::mem_fun(*this, &Editor::mouse_add_new_tempo_event), where)));
364 ruler_items.push_back (SeparatorElem ());
365 break;
366
367 case MeterBarItem:
368 ruler_items.push_back (MenuElem (_("New Meter"), sigc::bind ( sigc::mem_fun(*this, &Editor::mouse_add_new_meter_event), where)));
369 ruler_items.push_back (SeparatorElem ());
370 break;
371
372 default:
373 break;
374 }
375
376 Glib::RefPtr<Action> action;
377
378 action = ActionManager::get_action ("Rulers", "toggle-minsec-ruler");
379 if (action) {
380 ruler_items.push_back (MenuElem (*action->create_menu_item()));
381 }
382 if (!Profile->get_sae()) {
383 action = ActionManager::get_action ("Rulers", "toggle-timecode-ruler");
384 if (action) {
385 ruler_items.push_back (MenuElem (*action->create_menu_item()));
386 }
387 }
388 action = ActionManager::get_action ("Rulers", "toggle-samples-ruler");
389 if (action) {
390 ruler_items.push_back (MenuElem (*action->create_menu_item()));
391 }
392 action = ActionManager::get_action ("Rulers", "toggle-bbt-ruler");
393 if (action) {
394 ruler_items.push_back (MenuElem (*action->create_menu_item()));
395 }
396 action = ActionManager::get_action ("Rulers", "toggle-meter-ruler");
397 if (action) {
398 ruler_items.push_back (MenuElem (*action->create_menu_item()));
399 }
400 action = ActionManager::get_action ("Rulers", "toggle-tempo-ruler");
401 if (action) {
402 ruler_items.push_back (MenuElem (*action->create_menu_item()));
403 }
404 if (!Profile->get_sae()) {
405 action = ActionManager::get_action ("Rulers", "toggle-range-ruler");
406 if (action) {
407 ruler_items.push_back (MenuElem (*action->create_menu_item()));
408 }
409 }
410 action = ActionManager::get_action ("Rulers", "toggle-loop-punch-ruler");
411 if (action) {
412 ruler_items.push_back (MenuElem (*action->create_menu_item()));
413 }
414 action = ActionManager::get_action ("Rulers", "toggle-cd-marker-ruler");
415 if (action) {
416 ruler_items.push_back (MenuElem (*action->create_menu_item()));
417 }
418 action = ActionManager::get_action ("Rulers", "toggle-marker-ruler");
419 if (action) {
420 ruler_items.push_back (MenuElem (*action->create_menu_item()));
421 }
422
423 editor_ruler_menu->popup (1, gtk_get_current_event_time());
424
425 no_ruler_shown_update = false;
426 }
427
428 void
429 Editor::store_ruler_visibility ()
430 {
431 XMLNode* node = new XMLNode(X_("RulerVisibility"));
432
433 node->add_property (X_("timecode"), ruler_timecode_action->get_active() ? "yes": "no");
434 node->add_property (X_("bbt"), ruler_bbt_action->get_active() ? "yes": "no");
435 node->add_property (X_("samples"), ruler_samples_action->get_active() ? "yes": "no");
436 node->add_property (X_("minsec"), ruler_minsec_action->get_active() ? "yes": "no");
437 node->add_property (X_("tempo"), ruler_tempo_action->get_active() ? "yes": "no");
438 node->add_property (X_("meter"), ruler_meter_action->get_active() ? "yes": "no");
439 node->add_property (X_("marker"), ruler_marker_action->get_active() ? "yes": "no");
440 node->add_property (X_("rangemarker"), ruler_range_action->get_active() ? "yes": "no");
441 node->add_property (X_("transportmarker"), ruler_loop_punch_action->get_active() ? "yes": "no");
442 node->add_property (X_("cdmarker"), ruler_cd_marker_action->get_active() ? "yes": "no");
443
444 _session->add_extra_xml (*node);
445 _session->set_dirty ();
446 }
447
448 void
449 Editor::restore_ruler_visibility ()
450 {
451 XMLProperty* prop;
452 XMLNode * node = _session->extra_xml (X_("RulerVisibility"));
453
454 no_ruler_shown_update = true;
455
456 if (node) {
457 if ((prop = node->property ("timecode")) != 0) {
458 if (string_is_affirmative (prop->value())) {
459 ruler_timecode_action->set_active (true);
460 } else {
461 ruler_timecode_action->set_active (false);
462 }
463 }
464 if ((prop = node->property ("bbt")) != 0) {
465 if (string_is_affirmative (prop->value())) {
466 ruler_bbt_action->set_active (true);
467 } else {
468 ruler_bbt_action->set_active (false);
469 }
470 }
471 if ((prop = node->property ("samples")) != 0) {
472 if (string_is_affirmative (prop->value())) {
473 ruler_samples_action->set_active (true);
474 } else {
475 ruler_samples_action->set_active (false);
476 }
477 }
478 if ((prop = node->property ("minsec")) != 0) {
479 if (string_is_affirmative (prop->value())) {
480 ruler_minsec_action->set_active (true);
481 } else {
482 ruler_minsec_action->set_active (false);
483 }
484 }
485 if ((prop = node->property ("tempo")) != 0) {
486 if (string_is_affirmative (prop->value())) {
487 ruler_tempo_action->set_active (true);
488 } else {
489 ruler_tempo_action->set_active (false);
490 }
491 }
492 if ((prop = node->property ("meter")) != 0) {
493 if (string_is_affirmative (prop->value())) {
494 ruler_meter_action->set_active (true);
495 } else {
496 ruler_meter_action->set_active (false);
497 }
498 }
499 if ((prop = node->property ("marker")) != 0) {
500 if (string_is_affirmative (prop->value())) {
501 ruler_marker_action->set_active (true);
502 } else {
503 ruler_marker_action->set_active (false);
504 }
505 }
506 if ((prop = node->property ("rangemarker")) != 0) {
507 if (string_is_affirmative (prop->value())) {
508 ruler_range_action->set_active (true);
509 } else {
510 ruler_range_action->set_active (false);
511 }
512 }
513
514 if ((prop = node->property ("transportmarker")) != 0) {
515 if (string_is_affirmative (prop->value())) {
516 ruler_loop_punch_action->set_active (true);
517 } else {
518 ruler_loop_punch_action->set_active (false);
519 }
520 }
521
522 if ((prop = node->property ("cdmarker")) != 0) {
523 if (string_is_affirmative (prop->value())) {
524 ruler_cd_marker_action->set_active (true);
525 } else {
526 ruler_cd_marker_action->set_active (false);
527 }
528
529 } else {
530 // this _session doesn't yet know about the cdmarker ruler
531 // as a benefit to the user who doesn't know the feature exists, show the ruler if
532 // any cd marks exist
533 ruler_cd_marker_action->set_active (false);
534 const Locations::LocationList & locs = _session->locations()->list();
535 for (Locations::LocationList::const_iterator i = locs.begin(); i != locs.end(); ++i) {
536 if ((*i)->is_cd_marker()) {
537 ruler_cd_marker_action->set_active (true);
538 break;
539 }
540 }
541 }
542
543 }
544
545 no_ruler_shown_update = false;
546 update_ruler_visibility ();
547 }
548
549 void
550 Editor::update_ruler_visibility ()
551 {
552 int visible_rulers = 0;
553
554 if (no_ruler_shown_update) {
555 return;
556 }
557
558 visible_timebars = 0;
559
560 if (ruler_minsec_action->get_active()) {
561 visible_rulers++;
562 minsec_label.show ();
563 minsec_ruler->show ();
564 } else {
565 minsec_label.hide ();
566 minsec_ruler->hide ();
567 }
568
569 if (ruler_timecode_action->get_active()) {
570 visible_rulers++;
571 timecode_label.show ();
572 timecode_ruler->show ();
573 } else {
574 timecode_label.hide ();
575 timecode_ruler->hide ();
576 }
577
578 if (ruler_samples_action->get_active()) {
579 visible_rulers++;
580 samples_label.show ();
581 samples_ruler->show ();
582 } else {
583 samples_label.hide ();
584 samples_ruler->hide ();
585 }
586
587 if (ruler_bbt_action->get_active()) {
588 visible_rulers++;
589 bbt_label.show ();
590 bbt_ruler->show ();
591 } else {
592 bbt_label.hide ();
593 bbt_ruler->hide ();
594 }
595
596 double tbpos = 0.0;
597 double tbgpos = 0.0;
598 double old_unit_pos;
599
600 #ifdef GTKOSX
601 /* gtk update probs require this (damn) */
602 meter_label.hide();
603 tempo_label.hide();
604 range_mark_label.hide();
605 transport_mark_label.hide();
606 cd_mark_label.hide();
607 mark_label.hide();
608 #endif
609 if (ruler_meter_action->get_active()) {
610 old_unit_pos = meter_group->property_y();
611 if (tbpos != old_unit_pos) {
612 meter_group->move ( 0.0, tbpos - old_unit_pos);
613 }
614 old_unit_pos = meter_bar_group->property_y();
615 if (tbgpos != old_unit_pos) {
616 meter_bar_group->move ( 0.0, tbgpos - old_unit_pos);
617 }
618 meter_bar_group->show();
619 meter_group->show();
620 meter_label.show();
621 tbpos += timebar_height;
622 tbgpos += timebar_height;
623 visible_timebars++;
624 } else {
625 meter_bar_group->hide();
626 meter_group->hide();
627 meter_label.hide();
628 }
629
630 if (ruler_tempo_action->get_active()) {
631 old_unit_pos = tempo_group->property_y();
632 if (tbpos != old_unit_pos) {
633 tempo_group->move(0.0, tbpos - old_unit_pos);
634 }
635 old_unit_pos = tempo_bar_group->property_y();
636 if (tbgpos != old_unit_pos) {
637 tempo_bar_group->move ( 0.0, tbgpos - old_unit_pos);
638 }
639 tempo_bar_group->show();
640 tempo_group->show();
641 tempo_label.show();
642 tbpos += timebar_height;
643 tbgpos += timebar_height;
644 visible_timebars++;
645 } else {
646 tempo_bar_group->hide();
647 tempo_group->hide();
648 tempo_label.hide();
649 }
650
651 if (!Profile->get_sae() && ruler_range_action->get_active()) {
652 old_unit_pos = range_marker_group->property_y();
653 if (tbpos != old_unit_pos) {
654 range_marker_group->move (0.0, tbpos - old_unit_pos);
655 }
656 old_unit_pos = range_marker_bar_group->property_y();
657 if (tbgpos != old_unit_pos) {
658 range_marker_bar_group->move (0.0, tbgpos - old_unit_pos);
659 }
660 range_marker_bar_group->show();
661 range_marker_group->show();
662 range_mark_label.show();
663
664 tbpos += timebar_height;
665 tbgpos += timebar_height;
666 visible_timebars++;
667 } else {
668 range_marker_bar_group->hide();
669 range_marker_group->hide();
670 range_mark_label.hide();
671 }
672
673 if (ruler_loop_punch_action->get_active()) {
674 old_unit_pos = transport_marker_group->property_y();
675 if (tbpos != old_unit_pos) {
676 transport_marker_group->move ( 0.0, tbpos - old_unit_pos);
677 }
678 old_unit_pos = transport_marker_bar_group->property_y();
679 if (tbgpos != old_unit_pos) {
680 transport_marker_bar_group->move ( 0.0, tbgpos - old_unit_pos);
681 }
682 transport_marker_bar_group->show();
683 transport_marker_group->show();
684 transport_mark_label.show();
685 tbpos += timebar_height;
686 tbgpos += timebar_height;
687 visible_timebars++;
688 } else {
689 transport_marker_bar_group->hide();
690 transport_marker_group->hide();
691 transport_mark_label.hide();
692 }
693
694 if (ruler_cd_marker_action->get_active()) {
695 old_unit_pos = cd_marker_group->property_y();
696 if (tbpos != old_unit_pos) {
697 cd_marker_group->move (0.0, tbpos - old_unit_pos);
698 }
699 old_unit_pos = cd_marker_bar_group->property_y();
700 if (tbgpos != old_unit_pos) {
701 cd_marker_bar_group->move (0.0, tbgpos - old_unit_pos);
702 }
703 cd_marker_bar_group->show();
704 cd_marker_group->show();
705 cd_mark_label.show();
706 tbpos += timebar_height;
707 tbgpos += timebar_height;
708 visible_timebars++;
709 // make sure all cd markers show up in their respective places
710 update_cd_marker_display();
711 } else {
712 cd_marker_bar_group->hide();
713 cd_marker_group->hide();
714 cd_mark_label.hide();
715 // make sure all cd markers show up in their respective places
716 update_cd_marker_display();
717 }
718
719 if (ruler_marker_action->get_active()) {
720 old_unit_pos = marker_group->property_y();
721 if (tbpos != old_unit_pos) {
722 marker_group->move ( 0.0, tbpos - old_unit_pos);
723 }
724 old_unit_pos = marker_bar_group->property_y();
725 if (tbgpos != old_unit_pos) {
726 marker_bar_group->move ( 0.0, tbgpos - old_unit_pos);
727 }
728 marker_bar_group->show();
729 marker_group->show();
730 mark_label.show();
731 tbpos += timebar_height;
732 tbgpos += timebar_height;
733 visible_timebars++;
734 } else {
735 marker_bar_group->hide();
736 marker_group->hide();
737 mark_label.hide();
738 }
739
740 gdouble old_canvas_timebars_vsize = canvas_timebars_vsize;
741 canvas_timebars_vsize = (timebar_height * visible_timebars) - 1;
742 gdouble vertical_pos_delta = canvas_timebars_vsize - old_canvas_timebars_vsize;
743 vertical_adjustment.set_upper(vertical_adjustment.get_upper() + vertical_pos_delta);
744 full_canvas_height += vertical_pos_delta;
745
746 if (vertical_adjustment.get_value() != 0 && (vertical_adjustment.get_value() + _canvas_height >= full_canvas_height)) {
747 /*if we're at the bottom of the canvas, don't move the _trackview_group*/
748 vertical_adjustment.set_value (full_canvas_height - _canvas_height + 1);
749 } else {
750 _trackview_group->property_y () = - get_trackview_group_vertical_offset ();
751 _background_group->property_y () = - get_trackview_group_vertical_offset ();
752 _trackview_group->move (0, 0);
753 _background_group->move (0, 0);
754 last_trackview_group_vertical_offset = get_trackview_group_vertical_offset ();
755 }
756
757 gdouble bottom_track_pos = vertical_adjustment.get_value() + _canvas_height - canvas_timebars_vsize;
758 std::pair<TimeAxisView*, int> const p = trackview_by_y_position (bottom_track_pos);
759 if (p.first) {
760 p.first->clip_to_viewport ();
761 }
762
763 ruler_label_vbox.set_size_request (-1, (int)(timebar_height * visible_rulers));
764 time_canvas_vbox.set_size_request (-1,-1);
765
766 compute_fixed_ruler_scale ();
767 update_fixed_rulers();
768 redisplay_tempo (false);
769
770 /* Changing ruler visibility means that any lines on markers might need updating */
771 for (LocationMarkerMap::iterator i = location_markers.begin(); i != location_markers.end(); ++i) {
772 i->second->setup_lines ();
773 }
774 }
775
776 void
777 Editor::update_just_timecode ()
778 {
779 ENSURE_GUI_THREAD (*this, &Editor::update_just_timecode)
780
781 if (_session == 0) {
782 return;
783 }
784
785 framepos_t rightmost_frame = leftmost_frame + current_page_frames();
786
787 if (ruler_timecode_action->get_active()) {
788 gtk_custom_ruler_set_range (GTK_CUSTOM_RULER(_timecode_ruler), leftmost_frame, rightmost_frame,
789 leftmost_frame, _session->current_end_frame());
790 }
791 }
792
793 void
794 Editor::compute_fixed_ruler_scale ()
795 {
796 if (_session == 0) {
797 return;
798 }
799
800 if (ruler_timecode_action->get_active()) {
801 set_timecode_ruler_scale (leftmost_frame, leftmost_frame + current_page_frames());
802 }
803
804 if (ruler_minsec_action->get_active()) {
805 set_minsec_ruler_scale (leftmost_frame, leftmost_frame + current_page_frames());
806 }
807
808 if (ruler_samples_action->get_active()) {
809 set_samples_ruler_scale (leftmost_frame, leftmost_frame + current_page_frames());
810 }
811 }
812
813 void
814 Editor::update_fixed_rulers ()
815 {
816 framepos_t rightmost_frame;
817
818 if (_session == 0) {
819 return;
820 }
821
822 ruler_metrics[ruler_metric_timecode].units_per_pixel = frames_per_unit;
823 ruler_metrics[ruler_metric_samples].units_per_pixel = frames_per_unit;
824 ruler_metrics[ruler_metric_minsec].units_per_pixel = frames_per_unit;
825
826 rightmost_frame = leftmost_frame + current_page_frames();
827
828 /* these force a redraw, which in turn will force execution of the metric callbacks
829 to compute the relevant ticks to display.
830 */
831
832 if (ruler_timecode_action->get_active()) {
833 gtk_custom_ruler_set_range (GTK_CUSTOM_RULER(_timecode_ruler), leftmost_frame, rightmost_frame,
834 leftmost_frame, _session->current_end_frame());
835 }
836
837 if (ruler_samples_action->get_active()) {
838 gtk_custom_ruler_set_range (GTK_CUSTOM_RULER (_samples_ruler), leftmost_frame, rightmost_frame,
839 leftmost_frame, _session->current_end_frame());
840 }
841
842 if (ruler_minsec_action->get_active()) {
843 gtk_custom_ruler_set_range (GTK_CUSTOM_RULER(_minsec_ruler), leftmost_frame, rightmost_frame,
844 leftmost_frame, _session->current_end_frame());
845 }
846 }
847
848 void
849 Editor::update_tempo_based_rulers ()
850 {
851 if (_session == 0) {
852 return;
853 }
854
855 ruler_metrics[ruler_metric_bbt].units_per_pixel = frames_per_unit;
856
857 if (ruler_bbt_action->get_active()) {
858 gtk_custom_ruler_set_range (GTK_CUSTOM_RULER(_bbt_ruler), leftmost_frame, leftmost_frame+current_page_frames(),
859 leftmost_frame, _session->current_end_frame());
860 }
861 }
862
863 /* Mark generation */
864
865 gint
866 Editor::_metric_get_timecode (GtkCustomRulerMark **marks, gdouble lower, gdouble upper, gint maxchars)
867 {
868 return ruler_editor->metric_get_timecode (marks, lower, upper, maxchars);
869 }
870
871 gint
872 Editor::_metric_get_bbt (GtkCustomRulerMark **marks, gdouble lower, gdouble upper, gint maxchars)
873 {
874 return ruler_editor->metric_get_bbt (marks, lower, upper, maxchars);
875 }
876
877 gint
878 Editor::_metric_get_samples (GtkCustomRulerMark **marks, gdouble lower, gdouble upper, gint maxchars)
879 {
880 return ruler_editor->metric_get_samples (marks, lower, upper, maxchars);
881 }
882
883 gint
884 Editor::_metric_get_minsec (GtkCustomRulerMark **marks, gdouble lower, gdouble upper, gint maxchars)
885 {
886 return ruler_editor->metric_get_minsec (marks, lower, upper, maxchars);
887 }
888
889 void
890 Editor::set_timecode_ruler_scale (framepos_t lower, framepos_t upper)
891 {
892 framepos_t spacer;
893 framepos_t fr;
894
895 if (_session == 0) {
896 return;
897 }
898
899 fr = _session->frame_rate();
900
901 if (lower > (spacer = (framepos_t) (128 * Editor::get_current_zoom ()))) {
902 lower = lower - spacer;
903 } else {
904 lower = 0;
905 }
906 upper = upper + spacer;
907 framecnt_t const range = upper - lower;
908
909 if (range < (2 * _session->frames_per_timecode_frame())) { /* 0 - 2 frames */
910 timecode_ruler_scale = timecode_show_bits;
911 timecode_mark_modulo = 20;
912 timecode_nmarks = 2 + (2 * _session->config.get_subframes_per_frame());
913 } else if (range <= (fr / 4)) { /* 2 frames - 0.250 second */
914 timecode_ruler_scale = timecode_show_frames;
915 timecode_mark_modulo = 1;
916 timecode_nmarks = 2 + (range / (framepos_t)_session->frames_per_timecode_frame());
917 } else if (range <= (fr / 2)) { /* 0.25-0.5 second */
918 timecode_ruler_scale = timecode_show_frames;
919 timecode_mark_modulo = 2;
920 timecode_nmarks = 2 + (range / (framepos_t)_session->frames_per_timecode_frame());
921 } else if (range <= fr) { /* 0.5-1 second */
922 timecode_ruler_scale = timecode_show_frames;
923 timecode_mark_modulo = 5;
924 timecode_nmarks = 2 + (range / (framepos_t)_session->frames_per_timecode_frame());
925 } else if (range <= 2 * fr) { /* 1-2 seconds */
926 timecode_ruler_scale = timecode_show_frames;
927 timecode_mark_modulo = 10;
928 timecode_nmarks = 2 + (range / (framepos_t)_session->frames_per_timecode_frame());
929 } else if (range <= 8 * fr) { /* 2-8 seconds */
930 timecode_ruler_scale = timecode_show_seconds;
931 timecode_mark_modulo = 1;
932 timecode_nmarks = 2 + (range / fr);
933 } else if (range <= 16 * fr) { /* 8-16 seconds */
934 timecode_ruler_scale = timecode_show_seconds;
935 timecode_mark_modulo = 2;
936 timecode_nmarks = 2 + (range / fr);
937 } else if (range <= 30 * fr) { /* 16-30 seconds */
938 timecode_ruler_scale = timecode_show_seconds;
939 timecode_mark_modulo = 5;
940 timecode_nmarks = 2 + (range / fr);
941 } else if (range <= 60 * fr) { /* 30-60 seconds */
942 timecode_ruler_scale = timecode_show_seconds;
943 timecode_mark_modulo = 5;
944 timecode_nmarks = 2 + (range / fr);
945 } else if (range <= 2 * 60 * fr) { /* 1-2 minutes */
946 timecode_ruler_scale = timecode_show_seconds;
947 timecode_mark_modulo = 15;
948 timecode_nmarks = 2 + (range / fr);
949 } else if (range <= 4 * 60 * fr) { /* 2-4 minutes */
950 timecode_ruler_scale = timecode_show_seconds;
951 timecode_mark_modulo = 30;
952 timecode_nmarks = 2 + (range / fr);
953 } else if (range <= 10 * 60 * fr) { /* 4-10 minutes */
954 timecode_ruler_scale = timecode_show_minutes;
955 timecode_mark_modulo = 2;
956 timecode_nmarks = 2 + 10;
957 } else if (range <= 30 * 60 * fr) { /* 10-30 minutes */
958 timecode_ruler_scale = timecode_show_minutes;
959 timecode_mark_modulo = 5;
960 timecode_nmarks = 2 + 30;
961 } else if (range <= 60 * 60 * fr) { /* 30 minutes - 1hr */
962 timecode_ruler_scale = timecode_show_minutes;
963 timecode_mark_modulo = 10;
964 timecode_nmarks = 2 + 60;
965 } else if (range <= 4 * 60 * 60 * fr) { /* 1 - 4 hrs*/
966 timecode_ruler_scale = timecode_show_minutes;
967 timecode_mark_modulo = 30;
968 timecode_nmarks = 2 + (60 * 4);
969 } else if (range <= 8 * 60 * 60 * fr) { /* 4 - 8 hrs*/
970 timecode_ruler_scale = timecode_show_hours;
971 timecode_mark_modulo = 1;
972 timecode_nmarks = 2 + 8;
973 } else if (range <= 16 * 60 * 60 * fr) { /* 16-24 hrs*/
974 timecode_ruler_scale = timecode_show_hours;
975 timecode_mark_modulo = 1;
976 timecode_nmarks = 2 + 24;
977 } else {
978
979 /* not possible if framepos_t is a 32 bit quantity */
980
981 timecode_ruler_scale = timecode_show_hours;
982 timecode_mark_modulo = 4;
983 timecode_nmarks = 2 + 24;
984 }
985
986 }
987
988 gint
989 Editor::metric_get_timecode (GtkCustomRulerMark **marks, gdouble lower, gdouble /*upper*/, gint /*maxchars*/)
990 {
991 framepos_t pos;
992 framecnt_t spacer;
993 Timecode::Time timecode;
994 gchar buf[16];
995 gint n;
996
997 if (_session == 0) {
998 return 0;
999 }
1000
1001 if (lower > (spacer = (framecnt_t)(128 * Editor::get_current_zoom ()))) {
1002 lower = lower - spacer;
1003 } else {
1004 lower = 0;
1005 }
1006
1007 pos = (framecnt_t) floor (lower);
1008
1009 *marks = (GtkCustomRulerMark *) g_malloc (sizeof(GtkCustomRulerMark) * timecode_nmarks);
1010 switch (timecode_ruler_scale) {
1011 case timecode_show_bits:
1012
1013 // Find timecode time of this sample (pos) with subframe accuracy
1014 _session->sample_to_timecode(pos, timecode, true /* use_offset */, true /* use_subframes */ );
1015
1016 for (n = 0; n < timecode_nmarks; n++) {
1017 _session->timecode_to_sample(timecode, pos, true /* use_offset */, true /* use_subframes */ );
1018 if ((timecode.subframes % timecode_mark_modulo) == 0) {
1019 if (timecode.subframes == 0) {
1020 (*marks)[n].style = GtkCustomRulerMarkMajor;
1021 snprintf (buf, sizeof(buf), "%s%02u:%02u:%02u:%02u", timecode.negative ? "-" : "", timecode.hours, timecode.minutes, timecode.seconds, timecode.frames);
1022 } else {
1023 (*marks)[n].style = GtkCustomRulerMarkMinor;
1024 snprintf (buf, sizeof(buf), ".%02u", timecode.subframes);
1025 }
1026 } else {
1027 snprintf (buf, sizeof(buf)," ");
1028 (*marks)[n].style = GtkCustomRulerMarkMicro;
1029
1030 }
1031 (*marks)[n].label = g_strdup (buf);
1032 (*marks)[n].position = pos;
1033
1034 // Increment subframes by one
1035 Timecode::increment_subframes( timecode, _session->config.get_subframes_per_frame() );
1036 }
1037 break;
1038 case timecode_show_seconds:
1039 // Find timecode time of this sample (pos)
1040 _session->sample_to_timecode(pos, timecode, true /* use_offset */, false /* use_subframes */ );
1041 // Go to next whole second down
1042 Timecode::seconds_floor( timecode );
1043
1044 for (n = 0; n < timecode_nmarks; n++) {
1045 _session->timecode_to_sample(timecode, pos, true /* use_offset */, false /* use_subframes */ );
1046 if ((timecode.seconds % timecode_mark_modulo) == 0) {
1047 if (timecode.seconds == 0) {
1048 (*marks)[n].style = GtkCustomRulerMarkMajor;
1049 (*marks)[n].position = pos;
1050 } else {
1051 (*marks)[n].style = GtkCustomRulerMarkMinor;
1052 (*marks)[n].position = pos;
1053 }
1054 snprintf (buf, sizeof(buf), "%s%02u:%02u:%02u:%02u", timecode.negative ? "-" : "", timecode.hours, timecode.minutes, timecode.seconds, timecode.frames);
1055 } else {
1056 snprintf (buf, sizeof(buf)," ");
1057 (*marks)[n].style = GtkCustomRulerMarkMicro;
1058 (*marks)[n].position = pos;
1059
1060 }
1061 (*marks)[n].label = g_strdup (buf);
1062 Timecode::increment_seconds( timecode, _session->config.get_subframes_per_frame() );
1063 }
1064 break;
1065 case timecode_show_minutes:
1066 // Find timecode time of this sample (pos)
1067 _session->sample_to_timecode(pos, timecode, true /* use_offset */, false /* use_subframes */ );
1068 // Go to next whole minute down
1069 Timecode::minutes_floor( timecode );
1070
1071 for (n = 0; n < timecode_nmarks; n++) {
1072 _session->timecode_to_sample(timecode, pos, true /* use_offset */, false /* use_subframes */ );
1073 if ((timecode.minutes % timecode_mark_modulo) == 0) {
1074 if (timecode.minutes == 0) {
1075 (*marks)[n].style = GtkCustomRulerMarkMajor;
1076 } else {
1077 (*marks)[n].style = GtkCustomRulerMarkMinor;
1078 }
1079 snprintf (buf, sizeof(buf), "%s%02u:%02u:%02u:%02u", timecode.negative ? "-" : "", timecode.hours, timecode.minutes, timecode.seconds, timecode.frames);
1080 } else {
1081 snprintf (buf, sizeof(buf)," ");
1082 (*marks)[n].style = GtkCustomRulerMarkMicro;
1083
1084 }
1085 (*marks)[n].label = g_strdup (buf);
1086 (*marks)[n].position = pos;
1087 Timecode::increment_minutes( timecode, _session->config.get_subframes_per_frame() );
1088 }
1089
1090 break;
1091 case timecode_show_hours:
1092 // Find timecode time of this sample (pos)
1093 _session->sample_to_timecode(pos, timecode, true /* use_offset */, false /* use_subframes */ );
1094 // Go to next whole hour down
1095 Timecode::hours_floor( timecode );
1096
1097 for (n = 0; n < timecode_nmarks; n++) {
1098 _session->timecode_to_sample(timecode, pos, true /* use_offset */, false /* use_subframes */ );
1099 if ((timecode.hours % timecode_mark_modulo) == 0) {
1100 (*marks)[n].style = GtkCustomRulerMarkMajor;
1101 snprintf (buf, sizeof(buf), "%s%02u:%02u:%02u:%02u", timecode.negative ? "-" : "", timecode.hours, timecode.minutes, timecode.seconds, timecode.frames);
1102 } else {
1103 snprintf (buf, sizeof(buf)," ");
1104 (*marks)[n].style = GtkCustomRulerMarkMicro;
1105
1106 }
1107 (*marks)[n].label = g_strdup (buf);
1108 (*marks)[n].position = pos;
1109
1110 Timecode::increment_hours( timecode, _session->config.get_subframes_per_frame() );
1111 }
1112 break;
1113 case timecode_show_frames:
1114 // Find timecode time of this sample (pos)
1115 _session->sample_to_timecode(pos, timecode, true /* use_offset */, false /* use_subframes */ );
1116 // Go to next whole frame down
1117 Timecode::frames_floor( timecode );
1118
1119 for (n = 0; n < timecode_nmarks; n++) {
1120 _session->timecode_to_sample(timecode, pos, true /* use_offset */, false /* use_subframes */ );
1121 if ((timecode.frames % timecode_mark_modulo) == 0) {
1122 if (timecode.frames == 0) {
1123 (*marks)[n].style = GtkCustomRulerMarkMajor;
1124 } else {
1125 (*marks)[n].style = GtkCustomRulerMarkMinor;
1126 }
1127 (*marks)[n].position = pos;
1128 snprintf (buf, sizeof(buf), "%s%02u:%02u:%02u:%02u", timecode.negative ? "-" : "", timecode.hours, timecode.minutes, timecode.seconds, timecode.frames);
1129 } else {
1130 snprintf (buf, sizeof(buf)," ");
1131 (*marks)[n].style = GtkCustomRulerMarkMicro;
1132 (*marks)[n].position = pos;
1133
1134 }
1135 (*marks)[n].label = g_strdup (buf);
1136 Timecode::increment( timecode, _session->config.get_subframes_per_frame() );
1137 }
1138
1139 break;
1140 }
1141
1142 return timecode_nmarks;
1143 }
1144
1145
1146 void
1147 Editor::compute_bbt_ruler_scale (framepos_t lower, framepos_t upper)
1148 {
1149 if (_session == 0) {
1150 return;
1151 }
1152 TempoMap::BBTPointList::iterator i;
1153 Timecode::BBT_Time lower_beat, upper_beat; // the beats at each end of the ruler
1154
1155 _session->bbt_time (lower, lower_beat);
1156 _session->bbt_time (upper, upper_beat);
1157 uint32_t beats = 0;
1158
1159 bbt_accent_modulo = 1;
1160 bbt_bar_helper_on = false;
1161 bbt_bars = 0;
1162 bbt_nmarks = 1;
1163
1164 bbt_ruler_scale = bbt_over;
1165
1166 switch (_snap_type) {
1167 case SnapToBeatDiv2:
1168 bbt_beat_subdivision = 2;
1169 break;
1170 case SnapToBeatDiv3:
1171 bbt_beat_subdivision = 3;
1172 break;
1173 case SnapToBeatDiv4:
1174 bbt_beat_subdivision = 4;
1175 break;
1176 case SnapToBeatDiv5:
1177 bbt_beat_subdivision = 5;
1178 bbt_accent_modulo = 2; // XXX YIKES
1179 break;
1180 case SnapToBeatDiv6:
1181 bbt_beat_subdivision = 6;
1182 bbt_accent_modulo = 2; // XXX YIKES
1183 break;
1184 case SnapToBeatDiv7:
1185 bbt_beat_subdivision = 7;
1186 bbt_accent_modulo = 2; // XXX YIKES
1187 break;
1188 case SnapToBeatDiv8:
1189 bbt_beat_subdivision = 8;
1190 bbt_accent_modulo = 2;
1191 break;
1192 case SnapToBeatDiv10:
1193 bbt_beat_subdivision = 10;
1194 bbt_accent_modulo = 2; // XXX YIKES
1195 break;
1196 case SnapToBeatDiv12:
1197 bbt_beat_subdivision = 12;
1198 bbt_accent_modulo = 3;
1199 break;
1200 case SnapToBeatDiv14:
1201 bbt_beat_subdivision = 14;
1202 bbt_accent_modulo = 3; // XXX YIKES!
1203 break;
1204 case SnapToBeatDiv16:
1205 bbt_beat_subdivision = 16;
1206 bbt_accent_modulo = 4;
1207 break;
1208 case SnapToBeatDiv20:
1209 bbt_beat_subdivision = 20;
1210 bbt_accent_modulo = 5;
1211 break;
1212 case SnapToBeatDiv24:
1213 bbt_beat_subdivision = 24;
1214 bbt_accent_modulo = 6;
1215 break;
1216 case SnapToBeatDiv28:
1217 bbt_beat_subdivision = 28;
1218 bbt_accent_modulo = 7;
1219 break;
1220 case SnapToBeatDiv32:
1221 bbt_beat_subdivision = 32;
1222 bbt_accent_modulo = 8;
1223 break;
1224 default:
1225 bbt_beat_subdivision = 4;
1226 break;
1227 }
1228
1229 if (current_bbt_points == 0 || current_bbt_points->empty()) {
1230 return;
1231 }
1232
1233 i = current_bbt_points->end();
1234 i--;
1235 if ((*i).beat >= (*current_bbt_points->begin()).beat) {
1236 bbt_bars = (*i).bar - (*current_bbt_points->begin()).bar;
1237 } else {
1238 bbt_bars = (*i).bar - (*current_bbt_points->begin()).bar - 1;
1239 }
1240 beats = current_bbt_points->size() - bbt_bars;
1241
1242 /* Only show the bar helper if there aren't many bars on the screen */
1243 if ((bbt_bars < 2) || (beats < 5)) {
1244 bbt_bar_helper_on = true;
1245 }
1246
1247 if (bbt_bars > 8192) {
1248 bbt_ruler_scale = bbt_over;
1249 } else if (bbt_bars > 1024) {
1250 bbt_ruler_scale = bbt_show_64;
1251 } else if (bbt_bars > 256) {
1252 bbt_ruler_scale = bbt_show_16;
1253 } else if (bbt_bars > 64) {
1254 bbt_ruler_scale = bbt_show_4;
1255 } else if (bbt_bars > 10) {
1256 bbt_ruler_scale = bbt_show_1;
1257 } else if (bbt_bars > 2) {
1258 bbt_ruler_scale = bbt_show_beats;
1259 } else if (bbt_bars > 0) {
1260 bbt_ruler_scale = bbt_show_ticks;
1261 } else {
1262 bbt_ruler_scale = bbt_show_ticks_detail;
1263 }
1264
1265 if ((bbt_ruler_scale == bbt_show_ticks_detail) && (lower_beat.beats == upper_beat.beats) && (upper_beat.ticks - lower_beat.ticks <= Timecode::BBT_Time::ticks_per_beat / 4)) {
1266 bbt_ruler_scale = bbt_show_ticks_super_detail;
1267 }
1268 }
1269
1270 gint
1271 Editor::metric_get_bbt (GtkCustomRulerMark **marks, gdouble lower, gdouble /*upper*/, gint /*maxchars*/)
1272 {
1273 if (_session == 0) {
1274 return 0;
1275 }
1276
1277 TempoMap::BBTPointList::iterator i;
1278
1279 char buf[64];
1280 gint n = 0;
1281 framepos_t pos;
1282 Timecode::BBT_Time next_beat;
1283 framepos_t next_beat_pos;
1284 uint32_t beats = 0;
1285
1286 uint32_t tick = 0;
1287 uint32_t skip;
1288 uint32_t t;
1289 framepos_t frame_skip;
1290 double frame_skip_error;
1291 double bbt_position_of_helper;
1292 double accumulated_error;
1293 bool i_am_accented = false;
1294 bool helper_active = false;
1295
1296 if (current_bbt_points == 0 || current_bbt_points->empty()) {
1297 return 0;
1298 }
1299
1300 switch (bbt_ruler_scale) {
1301
1302 case bbt_show_beats:
1303 beats = current_bbt_points->size();
1304 bbt_nmarks = beats + 2;
1305
1306 *marks = (GtkCustomRulerMark *) g_malloc (sizeof(GtkCustomRulerMark) * bbt_nmarks);
1307
1308 (*marks)[0].label = g_strdup(" ");
1309 (*marks)[0].position = lower;
1310 (*marks)[0].style = GtkCustomRulerMarkMicro;
1311
1312 for (n = 1, i = current_bbt_points->begin(); n < bbt_nmarks && i != current_bbt_points->end(); ++i) {
1313 if ((*i).type != TempoMap::Beat) {
1314 continue;
1315 }
1316 if ((*i).frame < lower && (bbt_bar_helper_on)) {
1317 snprintf (buf, sizeof(buf), "<%" PRIu32 "|%" PRIu32, (*i).bar, (*i).beat);
1318 (*marks)[0].label = g_strdup (buf);
1319 helper_active = true;
1320 } else {
1321
1322 if ((*i).beat == 1) {
1323 (*marks)[n].style = GtkCustomRulerMarkMajor;
1324 snprintf (buf, sizeof(buf), "%" PRIu32, (*i).bar);
1325 } else if (((*i).beat % 2 == 1)) {
1326 (*marks)[n].style = GtkCustomRulerMarkMinor;
1327 snprintf (buf, sizeof(buf), " ");
1328 } else {
1329 (*marks)[n].style = GtkCustomRulerMarkMicro;
1330 snprintf (buf, sizeof(buf), " ");
1331 }
1332 (*marks)[n].label = g_strdup (buf);
1333 (*marks)[n].position = (*i).frame;
1334 n++;
1335 }
1336 }
1337 break;
1338
1339 case bbt_show_ticks:
1340
1341 beats = current_bbt_points->size();
1342 bbt_nmarks = (beats + 2) * bbt_beat_subdivision;
1343
1344 bbt_position_of_helper = lower + (30 * Editor::get_current_zoom ());
1345 *marks = (GtkCustomRulerMark *) g_malloc (sizeof(GtkCustomRulerMark) * bbt_nmarks);
1346
1347 (*marks)[0].label = g_strdup(" ");
1348 (*marks)[0].position = lower;
1349 (*marks)[0].style = GtkCustomRulerMarkMicro;
1350
1351 for (n = 1, i = current_bbt_points->begin(); n < bbt_nmarks && i != current_bbt_points->end(); ++i) {
1352 if ((*i).type != TempoMap::Beat) {
1353 continue;
1354 }
1355 if ((*i).frame < lower && (bbt_bar_helper_on)) {
1356 snprintf (buf, sizeof(buf), "<%" PRIu32 "|%" PRIu32, (*i).bar, (*i).beat);
1357 (*marks)[0].label = g_strdup (buf);
1358 helper_active = true;
1359 } else {
1360
1361 if ((*i).beat == 1) {
1362 (*marks)[n].style = GtkCustomRulerMarkMajor;
1363 snprintf (buf, sizeof(buf), "%" PRIu32, (*i).bar);
1364 } else {
1365 (*marks)[n].style = GtkCustomRulerMarkMinor;
1366 snprintf (buf, sizeof(buf), "%" PRIu32, (*i).beat);
1367 }
1368 if (((*i).frame < bbt_position_of_helper) && helper_active) {
1369 snprintf (buf, sizeof(buf), " ");
1370 }
1371 (*marks)[n].label = g_strdup (buf);
1372 (*marks)[n].position = (*i).frame;
1373 n++;
1374 }
1375
1376 /* Add the tick marks */
1377
1378 /* Find the next beat */
1379 next_beat.beats = (*i).beat;
1380 next_beat.bars = (*i).bar;
1381 next_beat.ticks = 0;
1382
1383 if ((*i).meter->beats_per_bar() > (next_beat.beats + 1)) {
1384 next_beat.beats += 1;
1385 } else {
1386 next_beat.bars += 1;
1387 next_beat.beats = 1;
1388 }
1389
1390 next_beat_pos = _session->tempo_map().frame_time(next_beat);
1391
1392 frame_skip = (framepos_t) floor (frame_skip_error = (_session->frame_rate() * 60) / (bbt_beat_subdivision * (*i).tempo->beats_per_minute()));
1393 frame_skip_error -= frame_skip;
1394 skip = (uint32_t) (Timecode::BBT_Time::ticks_per_beat / bbt_beat_subdivision);
1395
1396 pos = (*i).frame + frame_skip;
1397 accumulated_error = frame_skip_error;
1398
1399 tick = skip;
1400
1401 for (t = 0; (tick < Timecode::BBT_Time::ticks_per_beat) && (n < bbt_nmarks) && (pos < next_beat_pos) ; pos += frame_skip, tick += skip, ++t) {
1402
1403 if (t % bbt_accent_modulo == (bbt_accent_modulo - 1)) {
1404 i_am_accented = true;
1405 }
1406
1407 snprintf (buf, sizeof(buf), " ");
1408 (*marks)[n].label = g_strdup (buf);
1409
1410 /* Error compensation for float to framepos_t*/
1411 accumulated_error += frame_skip_error;
1412 if (accumulated_error > 1) {
1413 pos += 1;
1414 accumulated_error -= 1.0f;
1415 }
1416
1417 (*marks)[n].position = pos;
1418
1419 if ((bbt_beat_subdivision > 4) && i_am_accented) {
1420 (*marks)[n].style = GtkCustomRulerMarkMinor;
1421 } else {
1422 (*marks)[n].style = GtkCustomRulerMarkMicro;
1423 }
1424 i_am_accented = false;
1425 n++;
1426 }
1427 }
1428
1429 break;
1430
1431 case bbt_show_ticks_detail:
1432
1433 beats = current_bbt_points->size();
1434 bbt_nmarks = (beats + 2) * bbt_beat_subdivision;
1435
1436 bbt_position_of_helper = lower + (30 * Editor::get_current_zoom ());
1437 *marks = (GtkCustomRulerMark *) g_malloc (sizeof(GtkCustomRulerMark) * bbt_nmarks);
1438
1439 (*marks)[0].label = g_strdup(" ");
1440 (*marks)[0].position = lower;
1441 (*marks)[0].style = GtkCustomRulerMarkMicro;
1442
1443 for (n = 1, i = current_bbt_points->begin(); n < bbt_nmarks && i != current_bbt_points->end(); ++i) {
1444 if ((*i).type != TempoMap::Beat) {
1445 continue;
1446 }
1447 if ((*i).frame < lower && (bbt_bar_helper_on)) {
1448 snprintf (buf, sizeof(buf), "<%" PRIu32 "|%" PRIu32, (*i).bar, (*i).beat);
1449 (*marks)[0].label = g_strdup (buf);
1450 helper_active = true;
1451 } else {
1452
1453 if ((*i).beat == 1) {
1454 (*marks)[n].style = GtkCustomRulerMarkMajor;
1455 snprintf (buf, sizeof(buf), "%" PRIu32, (*i).bar);
1456 } else {
1457 (*marks)[n].style = GtkCustomRulerMarkMinor;
1458 snprintf (buf, sizeof(buf), "%" PRIu32, (*i).beat);
1459 }
1460 if (((*i).frame < bbt_position_of_helper) && helper_active) {
1461 snprintf (buf, sizeof(buf), " ");
1462 }
1463 (*marks)[n].label = g_strdup (buf);
1464 (*marks)[n].position = (*i).frame;
1465 n++;
1466 }
1467
1468 /* Add the tick marks */
1469
1470 /* Find the next beat */
1471
1472 next_beat.beats = (*i).beat;
1473 next_beat.bars = (*i).bar;
1474
1475 if ((*i).meter->beats_per_bar() > (next_beat.beats + 1)) {
1476 next_beat.beats += 1;
1477 } else {
1478 next_beat.bars += 1;
1479 next_beat.beats = 1;
1480 }
1481
1482 next_beat_pos = _session->tempo_map().frame_time(next_beat);
1483
1484 frame_skip = (framepos_t) floor (frame_skip_error = (_session->frame_rate() * 60) / (bbt_beat_subdivision * (*i).tempo->beats_per_minute()));
1485 frame_skip_error -= frame_skip;
1486 skip = (uint32_t) (Timecode::BBT_Time::ticks_per_beat / bbt_beat_subdivision);
1487
1488 pos = (*i).frame + frame_skip;
1489 accumulated_error = frame_skip_error;
1490
1491 tick = skip;
1492
1493 for (t = 0; (tick < Timecode::BBT_Time::ticks_per_beat) && (n < bbt_nmarks) && (pos < next_beat_pos) ; pos += frame_skip, tick += skip, ++t) {
1494
1495 if (t % bbt_accent_modulo == (bbt_accent_modulo - 1)) {
1496 i_am_accented = true;
1497 }
1498
1499 if (i_am_accented && (pos > bbt_position_of_helper)){
1500 snprintf (buf, sizeof(buf), "%" PRIu32, tick);
1501 } else {
1502 snprintf (buf, sizeof(buf), " ");
1503 }
1504
1505 (*marks)[n].label = g_strdup (buf);
1506
1507 /* Error compensation for float to framepos_t*/
1508 accumulated_error += frame_skip_error;
1509 if (accumulated_error > 1) {
1510 pos += 1;
1511 accumulated_error -= 1.0f;
1512 }
1513
1514 (*marks)[n].position = pos;
1515
1516 if ((bbt_beat_subdivision > 4) && i_am_accented) {
1517 (*marks)[n].style = GtkCustomRulerMarkMinor;
1518 } else {
1519 (*marks)[n].style = GtkCustomRulerMarkMicro;
1520 }
1521 i_am_accented = false;
1522 n++;
1523 }
1524 }
1525
1526 break;
1527
1528 case bbt_show_ticks_super_detail:
1529
1530 beats = current_bbt_points->size();
1531 bbt_nmarks = (beats + 2) * bbt_beat_subdivision;
1532
1533 bbt_position_of_helper = lower + (30 * Editor::get_current_zoom ());
1534 *marks = (GtkCustomRulerMark *) g_malloc (sizeof(GtkCustomRulerMark) * bbt_nmarks);
1535
1536 (*marks)[0].label = g_strdup(" ");
1537 (*marks)[0].position = lower;
1538 (*marks)[0].style = GtkCustomRulerMarkMicro;
1539
1540 for (n = 1, i = current_bbt_points->begin(); n < bbt_nmarks && i != current_bbt_points->end(); ++i) {
1541 if ((*i).type != TempoMap::Beat) {
1542 continue;
1543 }
1544 if ((*i).frame < lower && (bbt_bar_helper_on)) {
1545 snprintf (buf, sizeof(buf), "<%" PRIu32 "|%" PRIu32, (*i).bar, (*i).beat);
1546 (*marks)[0].label = g_strdup (buf);
1547 helper_active = true;
1548 } else {
1549
1550 if ((*i).beat == 1) {
1551 (*marks)[n].style = GtkCustomRulerMarkMajor;
1552 snprintf (buf, sizeof(buf), "%" PRIu32, (*i).bar);
1553 } else {
1554 (*marks)[n].style = GtkCustomRulerMarkMinor;
1555 snprintf (buf, sizeof(buf), "%" PRIu32, (*i).beat);
1556 }
1557 if (((*i).frame < bbt_position_of_helper) && helper_active) {
1558 snprintf (buf, sizeof(buf), " ");
1559 }
1560 (*marks)[n].label = g_strdup (buf);
1561 (*marks)[n].position = (*i).frame;
1562 n++;
1563 }
1564
1565 /* Add the tick marks */
1566
1567 /* Find the next beat */
1568
1569 next_beat.beats = (*i).beat;
1570 next_beat.bars = (*i).bar;
1571
1572 if ((*i).meter->beats_per_bar() > (next_beat.beats + 1)) {
1573 next_beat.beats += 1;
1574 } else {
1575 next_beat.bars += 1;
1576 next_beat.beats = 1;
1577 }
1578
1579 next_beat_pos = _session->tempo_map().frame_time(next_beat);
1580
1581 frame_skip = (framepos_t) floor (frame_skip_error = (_session->frame_rate() * 60) / (bbt_beat_subdivision * (*i).tempo->beats_per_minute()));
1582 frame_skip_error -= frame_skip;
1583 skip = (uint32_t) (Timecode::BBT_Time::ticks_per_beat / bbt_beat_subdivision);
1584
1585 pos = (*i).frame + frame_skip;
1586 accumulated_error = frame_skip_error;
1587
1588 tick = skip;
1589
1590 for (t = 0; (tick < Timecode::BBT_Time::ticks_per_beat) && (n < bbt_nmarks) && (pos < next_beat_pos) ; pos += frame_skip, tick += skip, ++t) {
1591
1592 if (t % bbt_accent_modulo == (bbt_accent_modulo - 1)) {
1593 i_am_accented = true;
1594 }
1595
1596 if (pos > bbt_position_of_helper) {
1597 snprintf (buf, sizeof(buf), "%" PRIu32, tick);
1598 } else {
1599 snprintf (buf, sizeof(buf), " ");
1600 }
1601
1602 (*marks)[n].label = g_strdup (buf);
1603
1604 /* Error compensation for float to framepos_t*/
1605 accumulated_error += frame_skip_error;
1606 if (accumulated_error > 1) {
1607 pos += 1;
1608 accumulated_error -= 1.0f;
1609 }
1610
1611 (*marks)[n].position = pos;
1612
1613 if ((bbt_beat_subdivision > 4) && i_am_accented) {
1614 (*marks)[n].style = GtkCustomRulerMarkMinor;
1615 } else {
1616 (*marks)[n].style = GtkCustomRulerMarkMicro;
1617 }
1618 i_am_accented = false;
1619 n++;
1620 }
1621 }
1622
1623 break;
1624
1625 case bbt_over:
1626 bbt_nmarks = 1;
1627 *marks = (GtkCustomRulerMark *) g_malloc (sizeof(GtkCustomRulerMark) * bbt_nmarks);
1628 snprintf (buf, sizeof(buf), "cannot handle %" PRIu32 " bars", bbt_bars );
1629 (*marks)[0].style = GtkCustomRulerMarkMajor;
1630 (*marks)[0].label = g_strdup (buf);
1631 (*marks)[0].position = lower;
1632 n = 1;
1633
1634 break;
1635
1636 case bbt_show_64:
1637 bbt_nmarks = (gint) (bbt_bars / 64) + 1;
1638 *marks = (GtkCustomRulerMark *) g_malloc (sizeof(GtkCustomRulerMark) * bbt_nmarks);
1639 for (n = 0, i = current_bbt_points->begin(); i != current_bbt_points->end() && n < bbt_nmarks; i++) {
1640 if ((*i).type == TempoMap::Bar) {
1641 if ((*i).bar % 64 == 1) {
1642 if ((*i).bar % 256 == 1) {
1643 snprintf (buf, sizeof(buf), "%" PRIu32, (*i).bar);
1644 (*marks)[n].style = GtkCustomRulerMarkMajor;
1645 } else {
1646 snprintf (buf, sizeof(buf), " ");
1647 if ((*i).bar % 256 == 129) {
1648 (*marks)[n].style = GtkCustomRulerMarkMinor;
1649 } else {
1650 (*marks)[n].style = GtkCustomRulerMarkMicro;
1651 }
1652 }
1653 (*marks)[n].label = g_strdup (buf);
1654 (*marks)[n].position = (*i).frame;
1655 n++;
1656 }
1657 }
1658 }
1659 break;
1660
1661 case bbt_show_16:
1662 bbt_nmarks = (bbt_bars / 16) + 1;
1663 *marks = (GtkCustomRulerMark *) g_malloc (sizeof(GtkCustomRulerMark) * bbt_nmarks);
1664 for (n = 0, i = current_bbt_points->begin(); i != current_bbt_points->end() && n < bbt_nmarks; i++) {
1665 if ((*i).type == TempoMap::Bar) {
1666 if ((*i).bar % 16 == 1) {
1667 if ((*i).bar % 64 == 1) {
1668 snprintf (buf, sizeof(buf), "%" PRIu32, (*i).bar);
1669 (*marks)[n].style = GtkCustomRulerMarkMajor;
1670 } else {
1671 snprintf (buf, sizeof(buf), " ");
1672 if ((*i).bar % 64 == 33) {
1673 (*marks)[n].style = GtkCustomRulerMarkMinor;
1674 } else {
1675 (*marks)[n].style = GtkCustomRulerMarkMicro;
1676 }
1677 }
1678 (*marks)[n].label = g_strdup (buf);
1679 (*marks)[n].position = (*i).frame;
1680 n++;
1681 }
1682 }
1683 }
1684 break;
1685
1686 case bbt_show_4:
1687 bbt_nmarks = (bbt_bars / 4) + 1;
1688 *marks = (GtkCustomRulerMark *) g_malloc (sizeof(GtkCustomRulerMark) * bbt_nmarks);
1689 for (n = 0, i = current_bbt_points->begin(); i != current_bbt_points->end() && n < bbt_nmarks; ++i) {
1690 if ((*i).type == TempoMap::Bar) {
1691 if ((*i).bar % 4 == 1) {
1692 if ((*i).bar % 16 == 1) {
1693 snprintf (buf, sizeof(buf), "%" PRIu32, (*i).bar);
1694 (*marks)[n].style = GtkCustomRulerMarkMajor;
1695 } else {
1696 snprintf (buf, sizeof(buf), " ");
1697 if ((*i).bar % 16 == 9) {
1698 (*marks)[n].style = GtkCustomRulerMarkMinor;
1699 } else {
1700 (*marks)[n].style = GtkCustomRulerMarkMicro;
1701 }
1702 }
1703 (*marks)[n].label = g_strdup (buf);
1704 (*marks)[n].position = (*i).frame;
1705 n++;
1706 }
1707 }
1708 }
1709 break;
1710
1711 case bbt_show_1:
1712 // default:
1713 bbt_nmarks = bbt_bars + 2;
1714 *marks = (GtkCustomRulerMark *) g_malloc (sizeof(GtkCustomRulerMark) * bbt_nmarks );
1715 for (n = 0, i = current_bbt_points->begin(); i != current_bbt_points->end() && n < bbt_nmarks; i++) {
1716 if ((*i).type == TempoMap::Bar) {
1717 if ((*i).bar % 4 == 1) {
1718 snprintf (buf, sizeof(buf), "%" PRIu32, (*i).bar);
1719 (*marks)[n].style = GtkCustomRulerMarkMajor;
1720 } else {
1721 snprintf (buf, sizeof(buf), " ");
1722 if ((*i).bar % 4 == 3) {
1723 (*marks)[n].style = GtkCustomRulerMarkMinor;
1724 } else {
1725 (*marks)[n].style = GtkCustomRulerMarkMicro;
1726 }
1727 }
1728 (*marks)[n].label = g_strdup (buf);
1729 (*marks)[n].position = (*i).frame;
1730 n++;
1731 }
1732 }
1733
1734 break;
1735
1736 }
1737
1738 return n; //return the actual number of marks made, since we might have skipped some from fractional time signatures
1739
1740 }
1741
1742 void
1743 Editor::set_samples_ruler_scale (framepos_t lower, framepos_t upper)
1744 {
1745 _samples_ruler_interval = (upper - lower) / 5;
1746 }
1747
1748 gint
1749 Editor::metric_get_samples (GtkCustomRulerMark **marks, gdouble lower, gdouble upper, gint /*maxchars*/)
1750 {
1751 framepos_t pos;
1752 framepos_t const ilower = (framepos_t) floor (lower);
1753 gchar buf[16];
1754 gint nmarks;
1755 gint n;
1756
1757 if (_session == 0) {
1758 return 0;
1759 }
1760
1761 nmarks = 5;
1762 *marks = (GtkCustomRulerMark *) g_malloc (sizeof(GtkCustomRulerMark) * nmarks);
1763 for (n = 0, pos = ilower; n < nmarks; pos += _samples_ruler_interval, ++n) {
1764 snprintf (buf, sizeof(buf), "%" PRIi64, pos);
1765 (*marks)[n].label = g_strdup (buf);
1766 (*marks)[n].position = pos;
1767 (*marks)[n].style = GtkCustomRulerMarkMajor;
1768 }
1769
1770 return nmarks;
1771 }
1772
1773 static void
1774 sample_to_clock_parts ( framepos_t sample,
1775 framepos_t sample_rate,
1776 long *hrs_p,
1777 long *mins_p,
1778 long *secs_p,
1779 long *millisecs_p)
1780
1781 {
1782 framepos_t left;
1783 long hrs;
1784 long mins;
1785 long secs;
1786 long millisecs;
1787
1788 left = sample;
1789 hrs = left / (sample_rate * 60 * 60);
1790 left -= hrs * sample_rate * 60 * 60;
1791 mins = left / (sample_rate * 60);
1792 left -= mins * sample_rate * 60;
1793 secs = left / sample_rate;
1794 left -= secs * sample_rate;
1795 millisecs = left * 1000 / sample_rate;
1796
1797 *millisecs_p = millisecs;
1798 *secs_p = secs;
1799 *mins_p = mins;
1800 *hrs_p = hrs;
1801
1802 return;
1803 }
1804
1805 void
1806 Editor::set_minsec_ruler_scale (framepos_t lower, framepos_t upper)
1807 {
1808 framepos_t fr;
1809 framepos_t spacer;
1810
1811 if (_session == 0) {
1812 return;
1813 }
1814
1815 fr = _session->frame_rate();
1816
1817 /* to prevent 'flashing' */
1818 if (lower > (spacer = (framepos_t)(128 * Editor::get_current_zoom ()))) {
1819 lower -= spacer;
1820 } else {
1821 lower = 0;
1822 }
1823 upper += spacer;
1824 framecnt_t const range = upper - lower;
1825
1826 if (range < (fr / 50)) {
1827 minsec_mark_interval = fr / 1000; /* show 1/1000 seconds */
1828 minsec_ruler_scale = minsec_show_frames;
1829 minsec_mark_modulo = 10;
1830 } else if (range <= (fr / 10)) { /* 0-0.1 second */
1831 minsec_mark_interval = fr / 1000; /* show 1/1000 seconds */
1832 minsec_ruler_scale = minsec_show_frames;
1833 minsec_mark_modulo = 10;
1834 } else if (range <= (fr / 2)) { /* 0-0.5 second */
1835 minsec_mark_interval = fr / 100; /* show 1/100 seconds */
1836 minsec_ruler_scale = minsec_show_frames;
1837 minsec_mark_modulo = 100;
1838 } else if (range <= fr) { /* 0-1 second */
1839 minsec_mark_interval = fr / 10; /* show 1/10 seconds */
1840 minsec_ruler_scale = minsec_show_frames;
1841 minsec_mark_modulo = 200;
1842 } else if (range <= 2 * fr) { /* 1-2 seconds */
1843 minsec_mark_interval = fr / 10; /* show 1/10 seconds */
1844 minsec_ruler_scale = minsec_show_frames;
1845 minsec_mark_modulo = 500;
1846 } else if (range <= 8 * fr) { /* 2-5 seconds */
1847 minsec_mark_interval = fr / 5; /* show 2 seconds */
1848 minsec_ruler_scale = minsec_show_frames;
1849 minsec_mark_modulo = 1000;
1850 } else if (range <= 16 * fr) { /* 8-16 seconds */
1851 minsec_mark_interval = fr; /* show 1 seconds */
1852 minsec_ruler_scale = minsec_show_seconds;
1853 minsec_mark_modulo = 2;
1854 } else if (range <= 30 * fr) { /* 10-30 seconds */
1855 minsec_mark_interval = fr; /* show 1 seconds */
1856 minsec_ruler_scale = minsec_show_seconds;
1857 minsec_mark_modulo = 5;
1858 } else if (range <= 60 * fr) { /* 30-60 seconds */
1859 minsec_mark_interval = fr; /* show 1 seconds */
1860 minsec_ruler_scale = minsec_show_seconds;
1861 minsec_mark_modulo = 5;
1862 } else if (range <= 2 * 60 * fr) { /* 1-2 minutes */
1863 minsec_mark_interval = 5 * fr; /* show 5 seconds */
1864 minsec_ruler_scale = minsec_show_seconds;
1865 minsec_mark_modulo = 3;
1866 } else if (range <= 4 * 60 * fr) { /* 4 minutes */
1867 minsec_mark_interval = 5 * fr; /* show 10 seconds */
1868 minsec_ruler_scale = minsec_show_seconds;
1869 minsec_mark_modulo = 30;
1870 } else if (range <= 10 * 60 * fr) { /* 10 minutes */
1871 minsec_mark_interval = 30 * fr; /* show 30 seconds */
1872 minsec_ruler_scale = minsec_show_seconds;
1873 minsec_mark_modulo = 120;
1874 } else if (range <= 30 * 60 * fr) { /* 10-30 minutes */
1875 minsec_mark_interval = 60 * fr; /* show 1 minute */
1876 minsec_ruler_scale = minsec_show_minutes;
1877 minsec_mark_modulo = 5;
1878 } else if (range <= 60 * 60 * fr) { /* 30 minutes - 1hr */
1879 minsec_mark_interval = 2 * 60 * fr; /* show 2 minutes */
1880 minsec_ruler_scale = minsec_show_minutes;
1881 minsec_mark_modulo = 10;
1882 } else if (range <= 4 * 60 * 60 * fr) { /* 1 - 4 hrs*/
1883 minsec_mark_interval = 5 * 60 * fr; /* show 10 minutes */
1884 minsec_ruler_scale = minsec_show_minutes;
1885 minsec_mark_modulo = 30;
1886 } else if (range <= 8 * 60 * 60 * fr) { /* 4 - 8 hrs*/
1887 minsec_mark_interval = 20 * 60 * fr; /* show 20 minutes */
1888 minsec_ruler_scale = minsec_show_minutes;
1889 minsec_mark_modulo = 60;
1890 } else if (range <= 16 * 60 * 60 * fr) { /* 16-24 hrs*/
1891 minsec_mark_interval = 60 * 60 * fr; /* show 60 minutes */
1892 minsec_ruler_scale = minsec_show_hours;
1893 minsec_mark_modulo = 2;
1894 } else {
1895
1896 /* not possible if framepos_t is a 32 bit quantity */
1897
1898 minsec_mark_interval = 4 * 60 * 60 * fr; /* show 4 hrs */
1899 }
1900 minsec_nmarks = 2 + (range / minsec_mark_interval);
1901 }
1902
1903 gint
1904 Editor::metric_get_minsec (GtkCustomRulerMark **marks, gdouble lower, gdouble /*upper*/, gint /*maxchars*/)
1905 {
1906 framepos_t pos;
1907 framepos_t spacer;
1908 long hrs, mins, secs, millisecs;
1909 gchar buf[16];
1910 gint n;
1911
1912 if (_session == 0) {
1913 return 0;
1914 }
1915
1916 /* to prevent 'flashing' */
1917 if (lower > (spacer = (framepos_t) (128 * Editor::get_current_zoom ()))) {
1918 lower = lower - spacer;
1919 } else {
1920 lower = 0;
1921 }
1922
1923 *marks = (GtkCustomRulerMark *) g_malloc (sizeof(GtkCustomRulerMark) * minsec_nmarks);
1924 pos = ((((framepos_t) floor(lower)) + (minsec_mark_interval/2))/minsec_mark_interval) * minsec_mark_interval;
1925 switch (minsec_ruler_scale) {
1926 case minsec_show_seconds:
1927 for (n = 0; n < minsec_nmarks; pos += minsec_mark_interval, ++n) {
1928 sample_to_clock_parts (pos, _session->frame_rate(), &hrs, &mins, &secs, &millisecs);
1929 if (secs % minsec_mark_modulo == 0) {
1930 if (secs == 0) {
1931 (*marks)[n].style = GtkCustomRulerMarkMajor;
1932 } else {
1933 (*marks)[n].style = GtkCustomRulerMarkMinor;
1934 }
1935 snprintf (buf, sizeof(buf), "%02ld:%02ld:%02ld.%03ld", hrs, mins, secs, millisecs);
1936 } else {
1937 snprintf (buf, sizeof(buf), " ");
1938 (*marks)[n].style = GtkCustomRulerMarkMicro;
1939 }
1940 (*marks)[n].label = g_strdup (buf);
1941 (*marks)[n].position = pos;
1942 }
1943 break;
1944 case minsec_show_minutes:
1945 for (n = 0; n < minsec_nmarks; pos += minsec_mark_interval, ++n) {
1946 sample_to_clock_parts (pos, _session->frame_rate(), &hrs, &mins, &secs, &millisecs);
1947 if (mins % minsec_mark_modulo == 0) {
1948 if (mins == 0) {
1949 (*marks)[n].style = GtkCustomRulerMarkMajor;
1950 } else {
1951 (*marks)[n].style = GtkCustomRulerMarkMinor;
1952 }
1953 snprintf (buf, sizeof(buf), "%02ld:%02ld:%02ld.%03ld", hrs, mins, secs, millisecs);
1954 } else {
1955 snprintf (buf, sizeof(buf), " ");
1956 (*marks)[n].style = GtkCustomRulerMarkMicro;
1957 }
1958 (*marks)[n].label = g_strdup (buf);
1959 (*marks)[n].position = pos;
1960 }
1961 break;
1962 case minsec_show_hours:
1963 for (n = 0; n < minsec_nmarks; pos += minsec_mark_interval, ++n) {
1964 sample_to_clock_parts (pos, _session->frame_rate(), &hrs, &mins, &secs, &millisecs);
1965 if (hrs % minsec_mark_modulo == 0) {
1966 (*marks)[n].style = GtkCustomRulerMarkMajor;
1967 snprintf (buf, sizeof(buf), "%02ld:%02ld:%02ld.%03ld", hrs, mins, secs, millisecs);
1968 } else {
1969 snprintf (buf, sizeof(buf), " ");
1970 (*marks)[n].style = GtkCustomRulerMarkMicro;
1971 }
1972 (*marks)[n].label = g_strdup (buf);
1973 (*marks)[n].position = pos;
1974 }
1975 break;
1976 case minsec_show_frames:
1977 for (n = 0; n < minsec_nmarks; pos += minsec_mark_interval, ++n) {
1978 sample_to_clock_parts (pos, _session->frame_rate(), &hrs, &mins, &secs, &millisecs);
1979 if (millisecs % minsec_mark_modulo == 0) {
1980 if (secs == 0) {
1981 (*marks)[n].style = GtkCustomRulerMarkMajor;
1982 } else {
1983 (*marks)[n].style = GtkCustomRulerMarkMinor;
1984 }
1985 snprintf (buf, sizeof(buf), "%02ld:%02ld:%02ld.%03ld", hrs, mins, secs, millisecs);
1986 } else {
1987 snprintf (buf, sizeof(buf), " ");
1988 (*marks)[n].style = GtkCustomRulerMarkMicro;
1989 }
1990 (*marks)[n].label = g_strdup (buf);
1991 (*marks)[n].position = pos;
1992 }
1993 break;
1994 }
1995
1996 return minsec_nmarks;
1997 }
Digital Audio Workstation