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