gtk2_ardour/editor_rulers.cc

   1 /*
   2     Copyright (C) 2000 Paul Davis
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18 */
  19
  20 #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 (_("New CD track marker"), bind ( mem_fun(*this, &Editor::mouse_add_new_marker), where, true, false)));
 428                 break;
 429
 430
 431         case TempoBarItem:
 432                 ruler_items.push_back (MenuElem (_("New Tempo"), bind ( mem_fun(*this, &Editor::mouse_add_new_tempo_event), where)));
 433                 ruler_items.push_back (MenuElem (_("Clear tempo")));
 434                 ruler_items.push_back (SeparatorElem ());
 435                 break;
 436
 437         case MeterBarItem:
 438                 ruler_items.push_back (MenuElem (_("New Meter"), bind ( mem_fun(*this, &Editor::mouse_add_new_meter_event), where)));
 439                 ruler_items.push_back (MenuElem (_("Clear meter")));
 440                 ruler_items.push_back (SeparatorElem ());
 441                 break;
 442
 443         default:
 444                 break;
 445         }
 446
 447         Glib::RefPtr<Action> action;
 448
 449         action = ActionManager::get_action ("Rulers", "toggle-minsec-ruler");
 450         if (action) {
 451                 ruler_items.push_back (MenuElem (*action->create_menu_item()));
 452         }
 453         if (!Profile->get_sae()) {
 454                 action = ActionManager::get_action ("Rulers", "toggle-timecode-ruler");
 455                 if (action) {
 456                         ruler_items.push_back (MenuElem (*action->create_menu_item()));
 457                 }
 458         }
 459         action = ActionManager::get_action ("Rulers", "toggle-samples-ruler");
 460         if (action) {
 461                 ruler_items.push_back (MenuElem (*action->create_menu_item()));
 462         }
 463         action = ActionManager::get_action ("Rulers", "toggle-bbt-ruler");
 464         if (action) {
 465                 ruler_items.push_back (MenuElem (*action->create_menu_item()));
 466         }
 467         action = ActionManager::get_action ("Rulers", "toggle-meter-ruler");
 468         if (action) {
 469                 ruler_items.push_back (MenuElem (*action->create_menu_item()));
 470         }
 471         action = ActionManager::get_action ("Rulers", "toggle-tempo-ruler");
 472         if (action) {
 473                 ruler_items.push_back (MenuElem (*action->create_menu_item()));
 474         }
 475         if (!Profile->get_sae()) {
 476                 action = ActionManager::get_action ("Rulers", "toggle-range-ruler");
 477                 if (action) {
 478                         ruler_items.push_back (MenuElem (*action->create_menu_item()));
 479                 }
 480         }
 481         action = ActionManager::get_action ("Rulers", "toggle-loop-punch-ruler");
 482         if (action) {
 483                 ruler_items.push_back (MenuElem (*action->create_menu_item()));
 484         }
 485         action = ActionManager::get_action ("Rulers", "toggle-cd-marker-ruler");
 486         if (action) {
 487                 ruler_items.push_back (MenuElem (*action->create_menu_item()));
 488         }
 489         action = ActionManager::get_action ("Rulers", "toggle-marker-ruler");
 490         if (action) {
 491                 ruler_items.push_back (MenuElem (*action->create_menu_item()));
 492         }
 493
 494         editor_ruler_menu->popup (1, gtk_get_current_event_time());
 495
 496         no_ruler_shown_update = false;
 497 }
 498
 499 void
 500 Editor::store_ruler_visibility ()
 501 {
 502         XMLNode* node = new XMLNode(X_("RulerVisibility"));
 503
 504         node->add_property (X_("smpte"), ruler_timecode_action->get_active() ? "yes": "no");
 505         node->add_property (X_("bbt"), ruler_bbt_action->get_active() ? "yes": "no");
 506         node->add_property (X_("frames"), ruler_samples_action->get_active() ? "yes": "no");
 507         node->add_property (X_("minsec"), ruler_minsec_action->get_active() ? "yes": "no");
 508         node->add_property (X_("tempo"), ruler_tempo_action->get_active() ? "yes": "no");
 509         node->add_property (X_("meter"), ruler_meter_action->get_active() ? "yes": "no");
 510         node->add_property (X_("marker"), ruler_marker_action->get_active() ? "yes": "no");
 511         node->add_property (X_("rangemarker"), ruler_range_action->get_active() ? "yes": "no");
 512         node->add_property (X_("transportmarker"), ruler_loop_punch_action->get_active() ? "yes": "no");
 513         node->add_property (X_("cdmarker"), ruler_cd_marker_action->get_active() ? "yes": "no");
 514
 515         session->add_extra_xml (*node);
 516         session->set_dirty ();
 517 }
 518
 519 void
 520 Editor::restore_ruler_visibility ()
 521 {
 522         XMLProperty* prop;
 523         XMLNode * node = session->extra_xml (X_("RulerVisibility"));
 524
 525         no_ruler_shown_update = true;
 526
 527         if (node) {
 528                 if ((prop = node->property ("smpte")) != 0) {
 529                         if (prop->value() == "yes") {
 530                                 ruler_timecode_action->set_active (true);
 531                         } else {
 532                                 ruler_timecode_action->set_active (false);
 533                         }
 534                 }
 535                 if ((prop = node->property ("bbt")) != 0) {
 536                         if (prop->value() == "yes") {
 537                                 ruler_bbt_action->set_active (true);
 538                         } else {
 539                                 ruler_bbt_action->set_active (false);
 540                         }
 541                 }
 542                 if ((prop = node->property ("frames")) != 0) {
 543                         if (prop->value() == "yes") {
 544                                 ruler_samples_action->set_active (true);
 545                         } else {
 546                                 ruler_samples_action->set_active (false);
 547                         }
 548                 }
 549                 if ((prop = node->property ("minsec")) != 0) {
 550                         if (prop->value() == "yes") {
 551                                 ruler_minsec_action->set_active (true);
 552                         } else {
 553                                 ruler_minsec_action->set_active (false);
 554                         }
 555                 }
 556                 if ((prop = node->property ("tempo")) != 0) {
 557                         if (prop->value() == "yes") {
 558                                 ruler_tempo_action->set_active (true);
 559                         } else {
 560                                 ruler_tempo_action->set_active (false);
 561                         }
 562                 }
 563                 if ((prop = node->property ("meter")) != 0) {
 564                         if (prop->value() == "yes") {
 565                                 ruler_meter_action->set_active (true);
 566                         } else {
 567                                 ruler_meter_action->set_active (false);
 568                         }
 569                 }
 570                 if ((prop = node->property ("marker")) != 0) {
 571                         if (prop->value() == "yes") {
 572                                 ruler_marker_action->set_active (true);
 573                         } else {
 574                                 ruler_marker_action->set_active (false);
 575                         }
 576                 }
 577                 if ((prop = node->property ("rangemarker")) != 0) {
 578                         if (prop->value() == "yes") {
 579                                 ruler_range_action->set_active (true);
 580                         } else {
 581                                 ruler_range_action->set_active (false);
 582                         }
 583                 }
 584
 585                 if ((prop = node->property ("transportmarker")) != 0) {
 586                         if (prop->value() == "yes") {
 587                                 ruler_loop_punch_action->set_active (true);
 588                         } else {
 589                                 ruler_loop_punch_action->set_active (false);
 590                         }
 591                 }
 592
 593                 if ((prop = node->property ("cdmarker")) != 0) {
 594                         if (prop->value() == "yes") {
 595                                 ruler_cd_marker_action->set_active (true);
 596                         } else {
 597                                 ruler_cd_marker_action->set_active (false);
 598                         }
 599
 600                 } else {
 601                         // this session doesn't yet know about the cdmarker ruler
 602                         // as a benefit to the user who doesn't know the feature exists, show the ruler if
 603                         // any cd marks exist
 604                         ruler_cd_marker_action->set_active (false);
 605                         const Locations::LocationList & locs = session->locations()->list();
 606                         for (Locations::LocationList::const_iterator i = locs.begin(); i != locs.end(); ++i) {
 607                                 if ((*i)->is_cd_marker()) {
 608                                         ruler_cd_marker_action->set_active (true);
 609                                         break;
 610                                 }
 611                         }
 612                 }
 613
 614         }
 615
 616         no_ruler_shown_update = false;
 617         update_ruler_visibility ();
 618 }
 619
 620 void
 621 Editor::update_ruler_visibility ()
 622 {
 623         int visible_rulers = 0;
 624
 625         if (no_ruler_shown_update) {
 626                 return;
 627         }
 628
 629         visible_timebars = 0;
 630
 631         if (ruler_minsec_action->get_active()) {
 632                 visible_rulers++;
 633                 minsec_label.show ();
 634                 minsec_ruler->show ();
 635         } else {
 636                 minsec_label.hide ();
 637                 minsec_ruler->hide ();
 638         }
 639
 640         if (ruler_timecode_action->get_active()) {
 641                 visible_rulers++;
 642                 smpte_label.show ();
 643                 smpte_ruler->show ();
 644         } else {
 645                 smpte_label.hide ();
 646                 smpte_ruler->hide ();
 647         }
 648
 649         if (ruler_samples_action->get_active()) {
 650                 visible_rulers++;
 651                 frame_label.show ();
 652                 frames_ruler->show ();
 653         } else {
 654                 frame_label.hide ();
 655                 frames_ruler->hide ();
 656         }
 657
 658         if (ruler_bbt_action->get_active()) {
 659                 visible_rulers++;
 660                 bbt_label.show ();
 661                 bbt_ruler->show ();
 662         } else {
 663                 bbt_label.hide ();
 664                 bbt_ruler->hide ();
 665         }
 666
 667         double tbpos = 0.0;
 668         double tbgpos = 0.0;
 669         double old_unit_pos;
 670
 671 #ifdef GTKOSX
 672         /* gtk update probs require this (damn) */
 673         meter_label.hide();
 674         tempo_label.hide();
 675         range_mark_label.hide();
 676         transport_mark_label.hide();
 677         cd_mark_label.hide();
 678         mark_label.hide();
 679 #endif
 680         if (ruler_meter_action->get_active()) {
 681                 old_unit_pos = meter_group->property_y();
 682                 if (tbpos != old_unit_pos) {
 683                         meter_group->move ( 0.0, tbpos - old_unit_pos);
 684                 }
 685                 old_unit_pos = meter_bar_group->property_y();
 686                 if (tbgpos != old_unit_pos) {
 687                         meter_bar_group->move ( 0.0, tbgpos - old_unit_pos);
 688                 }
 689                 meter_bar_group->show();
 690                 meter_group->show();
 691                 meter_label.show();
 692                 tbpos += timebar_height;
 693                 tbgpos += timebar_height;
 694                 visible_timebars++;
 695         } else {
 696                 meter_bar_group->hide();
 697                 meter_group->hide();
 698                 meter_label.hide();
 699         }
 700
 701         if (ruler_tempo_action->get_active()) {
 702                 old_unit_pos = tempo_group->property_y();
 703                 if (tbpos != old_unit_pos) {
 704                         tempo_group->move(0.0, tbpos - old_unit_pos);
 705                 }
 706                 old_unit_pos = tempo_bar_group->property_y();
 707                 if (tbgpos != old_unit_pos) {
 708                         tempo_bar_group->move ( 0.0, tbgpos - old_unit_pos);
 709                 }
 710                 tempo_bar_group->show();
 711                 tempo_group->show();
 712                 tempo_label.show();
 713                 tbpos += timebar_height;
 714                 tbgpos += timebar_height;
 715                 visible_timebars++;
 716         } else {
 717                 tempo_bar_group->hide();
 718                 tempo_group->hide();
 719                 tempo_label.hide();
 720         }
 721
 722         if (!Profile->get_sae() && ruler_range_action->get_active()) {
 723                 old_unit_pos = range_marker_group->property_y();
 724                 if (tbpos != old_unit_pos) {
 725                         range_marker_group->move (0.0, tbpos - old_unit_pos);
 726                 }
 727                 old_unit_pos = range_marker_bar_group->property_y();
 728                 if (tbgpos != old_unit_pos) {
 729                         range_marker_bar_group->move (0.0, tbgpos - old_unit_pos);
 730                 }
 731                 range_marker_bar_group->show();
 732                 range_marker_group->show();
 733                 range_mark_label.show();
 734                 tbpos += timebar_height;
 735                 tbgpos += timebar_height;
 736                 visible_timebars++;
 737         } else {
 738                 range_marker_bar_group->hide();
 739                 range_marker_group->hide();
 740                 range_mark_label.hide();
 741         }
 742
 743         if (ruler_loop_punch_action->get_active()) {
 744                 old_unit_pos = transport_marker_group->property_y();
 745                 if (tbpos != old_unit_pos) {
 746                         transport_marker_group->move ( 0.0, tbpos - old_unit_pos);
 747                 }
 748                 old_unit_pos = transport_marker_bar_group->property_y();
 749                 if (tbgpos != old_unit_pos) {
 750                         transport_marker_bar_group->move ( 0.0, tbgpos - old_unit_pos);
 751                 }
 752                 transport_marker_bar_group->show();
 753                 transport_marker_group->show();
 754                 transport_mark_label.show();
 755                 tbpos += timebar_height;
 756                 tbgpos += timebar_height;
 757                 visible_timebars++;
 758         } else {
 759                 transport_marker_bar_group->hide();
 760                 transport_marker_group->hide();
 761                 transport_mark_label.hide();
 762         }
 763
 764         if (ruler_cd_marker_action->get_active()) {
 765                 old_unit_pos = cd_marker_group->property_y();
 766                 if (tbpos != old_unit_pos) {
 767                         cd_marker_group->move (0.0, tbpos - old_unit_pos);
 768                 }
 769                 old_unit_pos = cd_marker_bar_group->property_y();
 770                 if (tbgpos != old_unit_pos) {
 771                         cd_marker_bar_group->move (0.0, tbgpos - old_unit_pos);
 772                 }
 773                 cd_marker_bar_group->show();
 774                 cd_marker_group->show();
 775                 cd_mark_label.show();
 776                 tbpos += timebar_height;
 777                 tbgpos += timebar_height;
 778                 visible_timebars++;
 779                 // make sure all cd markers show up in their respective places
 780                 update_cd_marker_display();
 781         } else {
 782                 cd_marker_bar_group->hide();
 783                 cd_marker_group->hide();
 784                 cd_mark_label.hide();
 785                 // make sure all cd markers show up in their respective places
 786                 update_cd_marker_display();
 787         }
 788
 789         if (ruler_marker_action->get_active()) {
 790                 old_unit_pos = marker_group->property_y();
 791                 if (tbpos != old_unit_pos) {
 792                         marker_group->move ( 0.0, tbpos - old_unit_pos);
 793                 }
 794                 old_unit_pos = marker_bar_group->property_y();
 795                 if (tbgpos != old_unit_pos) {
 796                         marker_bar_group->move ( 0.0, tbgpos - old_unit_pos);
 797                 }
 798                 marker_bar_group->show();
 799                 marker_group->show();
 800                 mark_label.show();
 801                 tbpos += timebar_height;
 802                 tbgpos += timebar_height;
 803                 visible_timebars++;
 804         } else {
 805                 marker_bar_group->hide();
 806                 marker_group->hide();
 807                 mark_label.hide();
 808         }
 809
 810         gdouble old_canvas_timebars_vsize = canvas_timebars_vsize;
 811         canvas_timebars_vsize = (timebar_height * visible_timebars) - 1;
 812         gdouble vertical_pos_delta = canvas_timebars_vsize - old_canvas_timebars_vsize;
 813         vertical_adjustment.set_upper(vertical_adjustment.get_upper() + vertical_pos_delta);
 814         full_canvas_height += vertical_pos_delta;
 815
 816         if (vertical_adjustment.get_value() != 0 && (vertical_adjustment.get_value() + canvas_height >= full_canvas_height)) {
 817                 /*if we're at the bottom of the canvas, don't move the _trackview_group*/
 818                 vertical_adjustment.set_value (full_canvas_height - canvas_height + 1);
 819         } else {
 820                 _trackview_group->property_y () = - get_trackview_group_vertical_offset ();
 821                 _trackview_group->move (0, 0);
 822                 last_trackview_group_vertical_offset = get_trackview_group_vertical_offset ();
 823         }
 824
 825         gdouble bottom_track_pos = vertical_adjustment.get_value() + canvas_height - canvas_timebars_vsize;
 826         if (trackview_by_y_position(bottom_track_pos) != 0) {
 827                 trackview_by_y_position(bottom_track_pos)->clip_to_viewport ();
 828         }
 829
 830         ruler_label_vbox.set_size_request (-1, (int)(timebar_height * visible_rulers));
 831         time_canvas_vbox.set_size_request (-1,-1);
 832
 833         update_fixed_rulers();
 834         redisplay_tempo (false);
 835 }
 836
 837 void
 838 Editor::update_just_smpte ()
 839 {
 840         ENSURE_GUI_THREAD(mem_fun(*this, &Editor::update_just_smpte));
 841
 842         if (session == 0) {
 843                 return;
 844         }
 845
 846         nframes64_t rightmost_frame = leftmost_frame + current_page_frames();
 847
 848         if (ruler_timecode_action->get_active()) {
 849                 gtk_custom_ruler_set_range (GTK_CUSTOM_RULER(_smpte_ruler), leftmost_frame, rightmost_frame,
 850                                             leftmost_frame, session->current_end_frame());
 851         }
 852 }
 853
 854 void
 855 Editor::update_fixed_rulers ()
 856 {
 857         nframes64_t rightmost_frame;
 858
 859         if (session == 0) {
 860                 return;
 861         }
 862
 863         ruler_metrics[ruler_metric_smpte].units_per_pixel = frames_per_unit;
 864         ruler_metrics[ruler_metric_frames].units_per_pixel = frames_per_unit;
 865         ruler_metrics[ruler_metric_minsec].units_per_pixel = frames_per_unit;
 866
 867         rightmost_frame = leftmost_frame + current_page_frames ();
 868
 869         /* these force a redraw, which in turn will force execution of the metric callbacks
 870            to compute the relevant ticks to display.
 871         */
 872
 873         if (ruler_timecode_action->get_active()) {
 874                 gtk_custom_ruler_set_range (GTK_CUSTOM_RULER(_smpte_ruler), leftmost_frame, rightmost_frame,
 875                                             leftmost_frame, session->current_end_frame());
 876         }
 877
 878         if (ruler_samples_action->get_active()) {
 879                 gtk_custom_ruler_set_range (GTK_CUSTOM_RULER(_frames_ruler), leftmost_frame, rightmost_frame,
 880                                             leftmost_frame, session->current_end_frame());
 881         }
 882
 883         if (ruler_minsec_action->get_active()) {
 884                 gtk_custom_ruler_set_range (GTK_CUSTOM_RULER(_minsec_ruler), leftmost_frame, rightmost_frame,
 885                                             leftmost_frame, session->current_end_frame());
 886         }
 887 }
 888
 889 void
 890 Editor::update_tempo_based_rulers ()
 891 {
 892         if (session == 0) {
 893                 return;
 894         }
 895
 896         ruler_metrics[ruler_metric_bbt].units_per_pixel = frames_per_unit;
 897
 898         if (ruler_bbt_action->get_active()) {
 899                 gtk_custom_ruler_set_range (GTK_CUSTOM_RULER(_bbt_ruler), leftmost_frame, leftmost_frame+current_page_frames(),
 900                                             leftmost_frame, session->current_end_frame());
 901         }
 902 }
 903
 904 /* Mark generation */
 905
 906 gint
 907 Editor::_metric_get_smpte (GtkCustomRulerMark **marks, gdouble lower, gdouble upper, gint maxchars)
 908 {
 909         return ruler_editor->metric_get_smpte (marks, lower, upper, maxchars);
 910 }
 911
 912 gint
 913 Editor::_metric_get_bbt (GtkCustomRulerMark **marks, gdouble lower, gdouble upper, gint maxchars)
 914 {
 915         return ruler_editor->metric_get_bbt (marks, lower, upper, maxchars);
 916 }
 917
 918 gint
 919 Editor::_metric_get_frames (GtkCustomRulerMark **marks, gdouble lower, gdouble upper, gint maxchars)
 920 {
 921         return ruler_editor->metric_get_frames (marks, lower, upper, maxchars);
 922 }
 923
 924 gint
 925 Editor::_metric_get_minsec (GtkCustomRulerMark **marks, gdouble lower, gdouble upper, gint maxchars)
 926 {
 927         return ruler_editor->metric_get_minsec (marks, lower, upper, maxchars);
 928 }
 929
 930 gint
 931 Editor::metric_get_smpte (GtkCustomRulerMark **marks, gdouble lower, gdouble upper, gint maxchars)
 932 {
 933         nframes_t pos;
 934         nframes64_t range;
 935         nframes64_t spacer;
 936         nframes64_t fr;
 937         SMPTE::Time smpte;
 938         gchar buf[16];
 939         gint nmarks = 0;
 940         gint n;
 941         bool show_bits = false;
 942         bool show_frames = false;
 943         bool show_seconds = false;
 944         bool show_minutes = false;
 945         bool show_hours = false;
 946         int mark_modulo;
 947
 948         if (session == 0) {
 949                 return 0;
 950         }
 951
 952         fr = session->frame_rate();
 953
 954         if (lower > (spacer = (nframes64_t)(128 * Editor::get_current_zoom ()))) {
 955                 lower = lower - spacer;
 956         } else {
 957                 lower = 0;
 958         }
 959         upper = upper + spacer;
 960         range = (nframes64_t) floor (upper - lower);
 961
 962         if (range < (2 * session->frames_per_smpte_frame())) { /* 0 - 2 frames */
 963                 show_bits = true;
 964                 mark_modulo = 20;
 965                 nmarks = 1 + (2 * Config->get_subframes_per_frame());
 966         } else if (range <= (fr / 4)) { /* 2 frames - 0.250 second */
 967                 show_frames = true;
 968                 mark_modulo = 1;
 969                 nmarks = 1 + (range / (nframes64_t)session->frames_per_smpte_frame());
 970         } else if (range <= (fr / 2)) { /* 0.25-0.5 second */
 971                 show_frames = true;
 972                 mark_modulo = 2;
 973                 nmarks = 1 + (range / (nframes64_t)session->frames_per_smpte_frame());
 974         } else if (range <= fr) { /* 0.5-1 second */
 975                 show_frames = true;
 976                 mark_modulo = 5;
 977                 nmarks = 1 + (range / (nframes64_t)session->frames_per_smpte_frame());
 978         } else if (range <= 2 * fr) { /* 1-2 seconds */
 979                 show_frames = true;
 980                 mark_modulo = 10;
 981                 nmarks = 1 + (range / (nframes64_t)session->frames_per_smpte_frame());
 982         } else if (range <= 8 * fr) { /* 2-8 seconds */
 983                 show_seconds = true;
 984                 mark_modulo = 1;
 985                 nmarks = 1 + (range / fr);
 986         } else if (range <= 16 * fr) { /* 8-16 seconds */
 987                 show_seconds = true;
 988                 mark_modulo = 2;
 989                 nmarks = 1 + (range / fr);
 990         } else if (range <= 30 * fr) { /* 16-30 seconds */
 991                 show_seconds = true;
 992                 mark_modulo = 5;
 993                 nmarks = 1 + (range / fr);
 994         } else if (range <= 60 * fr) { /* 30-60 seconds */
 995                 show_seconds = true;
 996                 mark_modulo = 5;
 997                 nmarks = 1 + (range / fr);
 998         } else if (range <= 2 * 60 * fr) { /* 1-2 minutes */
 999                 show_seconds = true;
1000                 mark_modulo = 20;
1001                 nmarks = 1 + (range / fr);
1002         } else if (range <= 4 * 60 * fr) { /* 2-4 minutes */
1003                 show_seconds = true;
1004                 mark_modulo = 30;
1005                 nmarks = 1 + (range / fr);
1006         } else if (range <= 10 * 60 * fr) { /* 4-10 minutes */
1007                 show_minutes = true;
1008                 mark_modulo = 2;
1009                 nmarks = 1 + 10;
1010         } else if (range <= 30 * 60 * fr) { /* 10-30 minutes */
1011                 show_minutes = true;
1012                 mark_modulo = 5;
1013                 nmarks = 1 + 30;
1014         } else if (range <= 60 * 60 * fr) { /* 30 minutes - 1hr */
1015                 show_minutes = true;
1016                 mark_modulo = 10;
1017                 nmarks = 1 + 60;
1018         } else if (range <= 4 * 60 * 60 * fr) { /* 1 - 4 hrs*/
1019                 show_minutes = true;
1020                 mark_modulo = 30;
1021                 nmarks = 1 + (60 * 4);
1022         } else if (range <= 8 * 60 * 60 * fr) { /* 4 - 8 hrs*/
1023                 show_hours = true;
1024                 mark_modulo = 1;
1025                 nmarks = 1 + 8;
1026         } else if (range <= 16 * 60 * 60 * fr) { /* 16-24 hrs*/
1027                 show_hours = true;
1028                 mark_modulo = 1;
1029                 nmarks = 1 + 24;
1030         } else {
1031
1032                 /* not possible if nframes64_t is a 32 bit quantity */
1033
1034                 show_hours = true;
1035                 mark_modulo = 4;
1036                 nmarks = 1 + 24;
1037         }
1038
1039         pos = (nframes_t) floor (lower);
1040
1041         *marks = (GtkCustomRulerMark *) g_malloc (sizeof(GtkCustomRulerMark) * nmarks);
1042
1043         if (show_bits) {
1044                 // Find smpte time of this sample (pos) with subframe accuracy
1045                 session->sample_to_smpte(pos, smpte, true /* use_offset */, true /* use_subframes */ );
1046
1047                 for (n = 0; n < nmarks; n++) {
1048                         session->smpte_to_sample(smpte, pos, true /* use_offset */, true /* use_subframes */ );
1049                         if ((smpte.subframes % mark_modulo) == 0) {
1050                                 if (smpte.subframes == 0) {
1051                                         (*marks)[n].style = GtkCustomRulerMarkMajor;
1052                                         snprintf (buf, sizeof(buf), "%s%02u:%02u:%02u:%02u", smpte.negative ? "-" : "", smpte.hours, smpte.minutes, smpte.seconds, smpte.frames);
1053                                 } else {
1054                                         (*marks)[n].style = GtkCustomRulerMarkMinor;
1055                                         snprintf (buf, sizeof(buf), ".%02u", smpte.subframes);
1056                                 }
1057                         } else {
1058                                 snprintf (buf, sizeof(buf)," ");
1059                                 (*marks)[n].style = GtkCustomRulerMarkMicro;
1060
1061                         }
1062                         (*marks)[n].label = g_strdup (buf);
1063                         (*marks)[n].position = pos;
1064
1065                         // Increment subframes by one
1066                         SMPTE::increment_subframes( smpte );
1067                 }
1068         } else if (show_seconds) {
1069                 // Find smpte time of this sample (pos)
1070                 session->sample_to_smpte(pos, smpte, true /* use_offset */, false /* use_subframes */ );
1071                 // Go to next whole second down
1072                 SMPTE::seconds_floor( smpte );
1073
1074                 for (n = 0; n < nmarks; n++) {
1075                         session->smpte_to_sample(smpte, pos, true /* use_offset */, false /* use_subframes */ );
1076                         if ((smpte.seconds % mark_modulo) == 0) {
1077                                 if (smpte.seconds == 0) {
1078                                         (*marks)[n].style = GtkCustomRulerMarkMajor;
1079                                         (*marks)[n].position = pos;
1080                                 } else {
1081                                         (*marks)[n].style = GtkCustomRulerMarkMinor;
1082                                         (*marks)[n].position = pos;
1083                                 }
1084                                 snprintf (buf, sizeof(buf), "%s%02u:%02u:%02u:%02u", smpte.negative ? "-" : "", smpte.hours, smpte.minutes, smpte.seconds, smpte.frames);
1085                         } else {
1086                                 snprintf (buf, sizeof(buf)," ");
1087                                 (*marks)[n].style = GtkCustomRulerMarkMicro;
1088                                 (*marks)[n].position = pos;
1089
1090                         }
1091                         (*marks)[n].label = g_strdup (buf);
1092                         SMPTE::increment_seconds( smpte );
1093                 }
1094         } else if (show_minutes) {
1095                 // Find smpte time of this sample (pos)
1096                 session->sample_to_smpte(pos, smpte, true /* use_offset */, false /* use_subframes */ );
1097                 // Go to next whole minute down
1098                 SMPTE::minutes_floor( smpte );
1099
1100                 for (n = 0; n < nmarks; n++) {
1101                         session->smpte_to_sample(smpte, pos, true /* use_offset */, false /* use_subframes */ );
1102                         if ((smpte.minutes % mark_modulo) == 0) {
1103                                 if (smpte.minutes == 0) {
1104                                         (*marks)[n].style = GtkCustomRulerMarkMajor;
1105                                 } else {
1106                                         (*marks)[n].style = GtkCustomRulerMarkMinor;
1107                                 }
1108                                 snprintf (buf, sizeof(buf), "%s%02u:%02u:%02u:%02u", smpte.negative ? "-" : "", smpte.hours, smpte.minutes, smpte.seconds, smpte.frames);
1109                         } else {
1110                                 snprintf (buf, sizeof(buf)," ");
1111                                 (*marks)[n].style = GtkCustomRulerMarkMicro;
1112
1113                         }
1114                         (*marks)[n].label = g_strdup (buf);
1115                         (*marks)[n].position = pos;
1116                         SMPTE::increment_minutes( smpte );
1117                 }
1118         } else if (show_hours) {
1119                 // Find smpte time of this sample (pos)
1120                 session->sample_to_smpte(pos, smpte, true /* use_offset */, false /* use_subframes */ );
1121                 // Go to next whole hour down
1122                 SMPTE::hours_floor( smpte );
1123
1124                 for (n = 0; n < nmarks; n++) {
1125                         session->smpte_to_sample(smpte, pos, true /* use_offset */, false /* use_subframes */ );
1126                         if ((smpte.hours % mark_modulo) == 0) {
1127                                 (*marks)[n].style = GtkCustomRulerMarkMajor;
1128                                 snprintf (buf, sizeof(buf), "%s%02u:%02u:%02u:%02u", smpte.negative ? "-" : "", smpte.hours, smpte.minutes, smpte.seconds, smpte.frames);
1129                         } else {
1130                                 snprintf (buf, sizeof(buf)," ");
1131                                 (*marks)[n].style = GtkCustomRulerMarkMicro;
1132
1133                         }
1134                         (*marks)[n].label = g_strdup (buf);
1135                         (*marks)[n].position = pos;
1136
1137                         SMPTE::increment_hours( smpte );
1138                 }
1139         } else { // show_frames
1140                 // Find smpte time of this sample (pos)
1141                 session->sample_to_smpte(pos, smpte, true /* use_offset */, false /* use_subframes */ );
1142                 // Go to next whole frame down
1143                 SMPTE::frames_floor( smpte );
1144
1145                 for (n = 0; n < nmarks; n++) {
1146                         session->smpte_to_sample(smpte, pos, true /* use_offset */, false /* use_subframes */ );
1147                         if ((smpte.frames % mark_modulo) == 0)  {
1148                                 (*marks)[n].style = GtkCustomRulerMarkMajor;
1149                                 (*marks)[n].position = pos;
1150                                 snprintf (buf, sizeof(buf), "%s%02u:%02u:%02u:%02u", smpte.negative ? "-" : "", smpte.hours, smpte.minutes, smpte.seconds, smpte.frames);
1151                         } else {
1152                                 snprintf (buf, sizeof(buf)," ");
1153                                 (*marks)[n].style = GtkCustomRulerMarkMicro;
1154                                 (*marks)[n].position = pos;
1155
1156                         }
1157                         (*marks)[n].label = g_strdup (buf);
1158                         SMPTE::increment( smpte );
1159                 }
1160         }
1161
1162         return nmarks;
1163 }
1164
1165
1166 gint
1167 Editor::metric_get_bbt (GtkCustomRulerMark **marks, gdouble lower, gdouble upper, gint maxchars)
1168 {
1169         if (session == 0) {
1170                 return 0;
1171         }
1172
1173         TempoMap::BBTPointList::iterator i;
1174
1175         uint32_t beats = 0;
1176         uint32_t bars = 0;
1177         uint32_t desirable_marks;
1178         uint32_t magic_accent_number = 1;
1179         gint nmarks;
1180         char buf[64];
1181         gint  n = 0;
1182         nframes64_t pos;
1183         bool bar_helper_on = true;
1184
1185         BBT_Time next_beat;
1186         nframes64_t next_beat_pos;
1187
1188         if ((desirable_marks = maxchars / 7) == 0) {
1189                return 0;
1190         }
1191
1192         /* align the tick marks to whatever we're snapping to... */
1193
1194         switch (snap_type) {
1195         case SnapToAThirdBeat:
1196                 bbt_beat_subdivision = 3;
1197                 break;
1198         case SnapToAQuarterBeat:
1199                 bbt_beat_subdivision = 4;
1200                 break;
1201         case SnapToAEighthBeat:
1202                 bbt_beat_subdivision = 8;
1203                 magic_accent_number = 2;
1204                 break;
1205         case SnapToASixteenthBeat:
1206                 bbt_beat_subdivision = 16;
1207                 magic_accent_number = 4;
1208                 break;
1209         case SnapToAThirtysecondBeat:
1210                 bbt_beat_subdivision = 32;
1211                 magic_accent_number = 8;
1212                 break;
1213         default:
1214                bbt_beat_subdivision = 4;
1215                 break;
1216         }
1217
1218         if (current_bbt_points == 0 || current_bbt_points->empty()) {
1219                 return 0;
1220         }
1221
1222         i = current_bbt_points->end();
1223         i--;
1224         bars = (*i).bar - (*current_bbt_points->begin()).bar;
1225         beats = current_bbt_points->size() - bars;
1226
1227         /*Only show the bar helper if there aren't many bars on the screen */
1228         if (bars > 1) {
1229                 bar_helper_on = false;
1230         }
1231
1232         if (desirable_marks > (beats / 4)) {
1233
1234                 /* we're in beat land...*/
1235
1236                 uint32_t tick = 0;
1237                 uint32_t skip;
1238                 uint32_t t;
1239                 nframes64_t frame_skip;
1240                 double frame_skip_error;
1241                 double accumulated_error;
1242                 double position_of_helper;
1243                 bool i_am_accented = false;
1244                 bool we_need_ticks = false;
1245                 bool helper_active = false;
1246
1247                 position_of_helper = lower + (30 * Editor::get_current_zoom ());
1248
1249                 if (desirable_marks >= (beats)) {
1250                         nmarks = (beats * bbt_beat_subdivision) + 1;
1251                         we_need_ticks = true;
1252                 } else {
1253                         nmarks = beats + 1;
1254                 }
1255
1256                 *marks = (GtkCustomRulerMark *) g_malloc (sizeof(GtkCustomRulerMark) * nmarks);
1257
1258                 (*marks)[0].label = g_strdup(" ");
1259                 (*marks)[0].position = lower;
1260                 (*marks)[0].style = GtkCustomRulerMarkMicro;
1261
1262                 for (n = 1,   i = current_bbt_points->begin(); n < nmarks && i != current_bbt_points->end(); ++i) {
1263
1264                         if ((*i).frame < lower && (bar_helper_on)) {
1265                                         snprintf (buf, sizeof(buf), "<%" PRIu32 "|%" PRIu32, (*i).bar, (*i).beat);
1266                                         (*marks)[0].label = g_strdup (buf);
1267                                         helper_active = true;
1268                         } else {
1269
1270                           if ((*i).type == TempoMap::Bar)  {
1271                             if (((*i).frame < position_of_helper) && helper_active) {
1272                               snprintf (buf, sizeof(buf), " ");
1273                             } else {
1274                               snprintf (buf, sizeof(buf), "%" PRIu32, (*i).bar);
1275                             }
1276                             (*marks)[n].label = g_strdup (buf);
1277                             (*marks)[n].position = (*i).frame;
1278                             (*marks)[n].style = GtkCustomRulerMarkMajor;
1279                             n++;
1280
1281                           } else if (((*i).type == TempoMap::Beat) && ((*i).beat > 1)) {
1282                             ((((*i).frame < position_of_helper) && bar_helper_on) || !we_need_ticks) ?
1283                               snprintf (buf, sizeof(buf), " ") : snprintf (buf, sizeof(buf), "%" PRIu32, (*i).beat);
1284                             if (((*i).beat % 2 == 1) || we_need_ticks) {
1285                               (*marks)[n].style = GtkCustomRulerMarkMinor;
1286                             } else {
1287                               (*marks)[n].style = GtkCustomRulerMarkMicro;
1288                             }
1289                             (*marks)[n].label =  g_strdup (buf);
1290                             (*marks)[n].position = (*i).frame;
1291                             n++;
1292                           }
1293
1294                         }
1295
1296
1297                         /* Add the tick marks */
1298
1299                         if (we_need_ticks && (*i).type == TempoMap::Beat) {
1300
1301                                 /* Find the next beat */
1302
1303                                 next_beat.beats = (*i).beat;
1304                                 next_beat.bars = (*i).bar;
1305
1306                                 if ((*i).meter->beats_per_bar() > (next_beat.beats + 1)) {
1307                                   next_beat.beats += 1;
1308                                 } else {
1309                                   next_beat.bars += 1;
1310                                   next_beat.beats = 1;
1311                                 }
1312
1313                                 next_beat_pos = session->tempo_map().frame_time(next_beat);
1314
1315                                 frame_skip = (nframes64_t) floor (frame_skip_error = (session->frame_rate() *  60) / (bbt_beat_subdivision * (*i).tempo->beats_per_minute()));
1316                                 frame_skip_error -= frame_skip;
1317                                 skip = (uint32_t) (Meter::ticks_per_beat / bbt_beat_subdivision);
1318
1319                                 pos = (*i).frame + frame_skip;
1320                                 accumulated_error = frame_skip_error;
1321
1322                                 tick = skip;
1323
1324                                 for (t = 0; (tick < Meter::ticks_per_beat) && (n < nmarks) && (pos < next_beat_pos) ; pos += frame_skip, tick += skip, ++t) {
1325
1326                                         if (t % magic_accent_number == (magic_accent_number - 1)) {
1327                                                 i_am_accented = true;
1328                                         }
1329                                         if (Editor::get_current_zoom () > 32) {
1330                                                 snprintf (buf, sizeof(buf), " ");
1331                                         } else if ((Editor::get_current_zoom () > 8) && !i_am_accented) {
1332                                                 snprintf (buf, sizeof(buf), " ");
1333                                         } else  if (bar_helper_on && (pos < position_of_helper)) {
1334                                                 snprintf (buf, sizeof(buf), " ");
1335                                         } else {
1336                                                 snprintf (buf, sizeof(buf), "%" PRIu32, tick);
1337                                         }
1338
1339                                         (*marks)[n].label = g_strdup (buf);
1340
1341                                         /* Error compensation for float to nframes64_t*/
1342                                         accumulated_error += frame_skip_error;
1343                                         if (accumulated_error > 1) {
1344                                                 pos += 1;
1345                                                 accumulated_error -= 1.0f;
1346                                         }
1347
1348                                         (*marks)[n].position = pos;
1349
1350                                         if ((bbt_beat_subdivision > 4) && i_am_accented) {
1351                                                 (*marks)[n].style = GtkCustomRulerMarkMinor;
1352                                         } else {
1353                                                 (*marks)[n].style = GtkCustomRulerMarkMicro;
1354                                         }
1355                                         i_am_accented = false;
1356                                         n++;
1357
1358                                 }
1359                         }
1360                 }
1361                 return n; //return the actual number of marks made, since we might have skipped some fro fractional time signatures
1362
1363        } else {
1364
1365                 /* we're in bar land */
1366
1367                 if (desirable_marks < (bars / 256)) {
1368                         nmarks = 1;
1369                         *marks = (GtkCustomRulerMark *) g_malloc (sizeof(GtkCustomRulerMark) * nmarks);
1370                         snprintf (buf, sizeof(buf), "too many bars... (currently %" PRIu32 ")", bars );
1371                         (*marks)[0].style = GtkCustomRulerMarkMajor;
1372                         (*marks)[0].label = g_strdup (buf);
1373                         (*marks)[0].position = lower;
1374                 } else if (desirable_marks < (uint32_t)(nmarks = (gint) (bars / 64) + 1)) {
1375                         *marks = (GtkCustomRulerMark *) g_malloc (sizeof(GtkCustomRulerMark) * nmarks);
1376                         for (n = 0,   i = current_bbt_points->begin(); i != current_bbt_points->end() && n < nmarks; i++) {
1377                                 if ((*i).type == TempoMap::Bar)  {
1378                                         if ((*i).bar % 64 == 1) {
1379                                                 if ((*i).bar % 256 == 1) {
1380                                                         snprintf (buf, sizeof(buf), "%" PRIu32, (*i).bar);
1381                                                         (*marks)[n].style = GtkCustomRulerMarkMajor;
1382                                                 } else {
1383                                                         snprintf (buf, sizeof(buf), " ");
1384                                                         if ((*i).bar % 256 == 129)  {
1385                                                                 (*marks)[n].style = GtkCustomRulerMarkMinor;
1386                                                         } else {
1387                                                                 (*marks)[n].style = GtkCustomRulerMarkMicro;
1388                                                         }
1389                                                 }
1390                                                 (*marks)[n].label = g_strdup (buf);
1391                                                 (*marks)[n].position = (*i).frame;
1392                                                 n++;
1393                                         }
1394                                 }
1395                         }
1396                 } else if (desirable_marks < (uint32_t)(nmarks = (bars / 16) + 1)) {
1397                         *marks = (GtkCustomRulerMark *) g_malloc (sizeof(GtkCustomRulerMark) * nmarks);
1398                         for (n = 0,  i = current_bbt_points->begin(); i != current_bbt_points->end() && n < nmarks; i++) {
1399                                 if ((*i).type == TempoMap::Bar)  {
1400                                         if ((*i).bar % 16 == 1) {
1401                                                 if ((*i).bar % 64 == 1) {
1402                                                         snprintf (buf, sizeof(buf), "%" PRIu32, (*i).bar);
1403                                                         (*marks)[n].style = GtkCustomRulerMarkMajor;
1404                                                 } else {
1405                                                         snprintf (buf, sizeof(buf), " ");
1406                                                         if ((*i).bar % 64 == 33)  {
1407                                                                 (*marks)[n].style = GtkCustomRulerMarkMinor;
1408                                                         } else {
1409                                                                 (*marks)[n].style = GtkCustomRulerMarkMicro;
1410                                                         }
1411                                                 }
1412                                                 (*marks)[n].label = g_strdup (buf);
1413                                                 (*marks)[n].position = (*i).frame;
1414                                                 n++;
1415                                         }
1416                                 }
1417                         }
1418                 } else if (desirable_marks < (uint32_t)(nmarks = (bars / 4) + 1)){
1419                         *marks = (GtkCustomRulerMark *) g_malloc (sizeof(GtkCustomRulerMark) * nmarks);
1420                         for (n = 0,   i = current_bbt_points->begin(); i != current_bbt_points->end() && n < nmarks; ++i) {
1421                                 if ((*i).type == TempoMap::Bar)  {
1422                                         if ((*i).bar % 4 == 1) {
1423                                                 if ((*i).bar % 16 == 1) {
1424                                                         snprintf (buf, sizeof(buf), "%" PRIu32, (*i).bar);
1425                                                         (*marks)[n].style = GtkCustomRulerMarkMajor;
1426                                                 } else {
1427                                                         snprintf (buf, sizeof(buf), " ");
1428                                                         if ((*i).bar % 16 == 9)  {
1429                                                                 (*marks)[n].style = GtkCustomRulerMarkMinor;
1430                                                         } else {
1431                                                                 (*marks)[n].style = GtkCustomRulerMarkMicro;
1432                                                         }
1433                                                 }
1434                                                 (*marks)[n].label = g_strdup (buf);
1435                                                 (*marks)[n].position = (*i).frame;
1436                                                 n++;
1437                                         }
1438                                 }
1439                         }
1440                 } else {
1441                         nmarks = bars + 1;
1442                         *marks = (GtkCustomRulerMark *) g_malloc (sizeof(GtkCustomRulerMark) * nmarks );
1443                         for (n = 0,  i = current_bbt_points->begin(); i != current_bbt_points->end() && n < nmarks; i++) {
1444                                 if ((*i).type == TempoMap::Bar)  {
1445                                         if ((*i).bar % 4 == 1) {
1446                                                 snprintf (buf, sizeof(buf), "%" PRIu32, (*i).bar);
1447                                                 (*marks)[n].style = GtkCustomRulerMarkMajor;
1448                                         } else {
1449                                                 snprintf (buf, sizeof(buf), " ");
1450                                                 if ((*i).bar % 4 == 3)  {
1451                                                         (*marks)[n].style = GtkCustomRulerMarkMinor;
1452                                                 } else {
1453                                                         (*marks)[n].style = GtkCustomRulerMarkMicro;
1454                                                 }
1455                                         }
1456                                         (*marks)[n].label = g_strdup (buf);
1457                                         (*marks)[n].position = (*i).frame;
1458                                         n++;
1459                                 }
1460                         }
1461                 }
1462                 return n;
1463         }
1464 }
1465
1466 gint
1467 Editor::metric_get_frames (GtkCustomRulerMark **marks, gdouble lower, gdouble upper, gint maxchars)
1468 {
1469         nframes64_t mark_interval;
1470         nframes64_t pos;
1471         nframes64_t ilower = (nframes64_t) floor (lower);
1472         nframes64_t iupper = (nframes64_t) floor (upper);
1473         gchar buf[16];
1474         gint nmarks;
1475         gint n;
1476
1477         if (session == 0) {
1478                 return 0;
1479         }
1480
1481         mark_interval = (iupper - ilower) / 5;
1482         if (mark_interval > session->frame_rate()) {
1483                 mark_interval -= mark_interval % session->frame_rate();
1484         } else {
1485                 mark_interval = session->frame_rate() / (session->frame_rate() / mark_interval ) ;
1486         }
1487         nmarks = 5;
1488         *marks = (GtkCustomRulerMark *) g_malloc (sizeof(GtkCustomRulerMark) * nmarks);
1489         for (n = 0, pos = ilower; n < nmarks; pos += mark_interval, ++n) {
1490                 snprintf (buf, sizeof(buf), "%" PRIi64,  pos);
1491                 (*marks)[n].label = g_strdup (buf);
1492                 (*marks)[n].position = pos;
1493                 (*marks)[n].style = GtkCustomRulerMarkMajor;
1494         }
1495
1496         return nmarks;
1497 }
1498
1499 static void
1500 sample_to_clock_parts ( nframes64_t sample,
1501                         nframes64_t sample_rate,
1502                         long *hrs_p,
1503                         long *mins_p,
1504                         long *secs_p,
1505                         long *millisecs_p)
1506
1507 {
1508         nframes64_t left;
1509         long hrs;
1510         long mins;
1511         long secs;
1512         long millisecs;
1513
1514         left = sample;
1515         hrs = left / (sample_rate * 60 * 60);
1516         left -= hrs * sample_rate * 60 * 60;
1517         mins = left / (sample_rate * 60);
1518         left -= mins * sample_rate * 60;
1519         secs = left / sample_rate;
1520         left -= secs * sample_rate;
1521         millisecs = left * 1000 / sample_rate;
1522
1523         *millisecs_p = millisecs;
1524         *secs_p = secs;
1525         *mins_p = mins;
1526         *hrs_p = hrs;
1527
1528         return;
1529 }
1530
1531 gint
1532 Editor::metric_get_minsec (GtkCustomRulerMark **marks, gdouble lower, gdouble upper, gint maxchars)
1533 {
1534         nframes64_t range;
1535         nframes64_t fr;
1536         nframes64_t mark_interval;
1537         nframes64_t pos;
1538         nframes64_t spacer;
1539         long hrs, mins, secs, millisecs;
1540         gchar buf[16];
1541         gint nmarks;
1542         gint n;
1543         gint mark_modulo = 100;
1544         bool show_seconds = false;
1545         bool show_minutes = false;
1546         bool show_hours = false;
1547         nframes64_t ilower = (nframes64_t) floor (lower);
1548         nframes64_t iupper = (nframes64_t) floor (upper);
1549
1550         if (session == 0) {
1551                 return 0;
1552         }
1553
1554         fr = session->frame_rate();
1555
1556         /* to prevent 'flashing' */
1557         if (lower > (spacer = (nframes64_t)(128 * Editor::get_current_zoom ()))) {
1558                 lower = lower - spacer;
1559         } else {
1560                 lower = 0;
1561         }
1562         upper = upper + spacer;
1563         range = iupper - ilower;
1564
1565         if (range <  (fr / 50)) {
1566                 mark_interval =  fr / 100; /* show 1/100 seconds */
1567                 mark_modulo = 10;
1568         } else if (range <= (fr / 10)) { /* 0-0.1 second */
1569                 mark_interval = fr / 50; /* show 1/50 seconds */
1570                 mark_modulo = 20;
1571         } else if (range <= (fr / 2)) { /* 0-0.5 second */
1572                 mark_interval = fr / 20;  /* show 1/20 seconds */
1573                 mark_modulo = 100;
1574         } else if (range <= fr) { /* 0-1 second */
1575                 mark_interval = fr / 10;  /* show 1/10 seconds */
1576                 mark_modulo = 200;
1577         } else if (range <= 2 * fr) { /* 1-2 seconds */
1578                 mark_interval = fr / 2; /* show 1/2 seconds */
1579                 mark_modulo = 500;
1580         } else if (range <= 8 * fr) { /* 2-5 seconds */
1581                 mark_interval =  fr / 5; /* show 2 seconds */
1582                 mark_modulo = 1000;
1583         } else if (range <= 16 * fr) { /* 8-16 seconds */
1584                 mark_interval =  fr; /* show 1 seconds */
1585                 show_seconds = true;
1586                 mark_modulo = 5;
1587         } else if (range <= 30 * fr) { /* 10-30 seconds */
1588                 mark_interval =  fr; /* show 10 seconds */
1589                 show_seconds = true;
1590                 mark_modulo = 5;
1591         } else if (range <= 60 * fr) { /* 30-60 seconds */
1592                 mark_interval = 5 * fr; /* show 5 seconds */
1593                 show_seconds = true;
1594                 mark_modulo = 3;
1595         } else if (range <= 2 * 60 * fr) { /* 1-2 minutes */
1596                 mark_interval = 5 * fr; /* show 5 seconds */
1597                 show_seconds = true;
1598                 mark_modulo = 3;
1599         } else if (range <= 4 * 60 * fr) { /* 4 minutes */
1600                 mark_interval = 10 * fr; /* show 10 seconds */
1601                 show_seconds = true;
1602                 mark_modulo = 30;
1603         } else if (range <= 10 * 60 * fr) { /* 10 minutes */
1604                 mark_interval = 30 * fr; /* show 30 seconds */
1605                 show_seconds = true;
1606                 mark_modulo = 60;
1607         } else if (range <= 30 * 60 * fr) { /* 10-30 minutes */
1608                 mark_interval =  60 * fr; /* show 1 minute */
1609                 show_minutes = true;
1610                 mark_modulo = 5;
1611         } else if (range <= 60 * 60 * fr) { /* 30 minutes - 1hr */
1612                 mark_interval = 2 * 60 * fr; /* show 2 minutes */
1613                 show_minutes = true;
1614                 mark_modulo = 10;
1615         } else if (range <= 4 * 60 * 60 * fr) { /* 1 - 4 hrs*/
1616                 mark_interval = 5 * 60 * fr; /* show 10 minutes */
1617                 show_minutes = true;
1618                 mark_modulo = 30;
1619         } else if (range <= 8 * 60 * 60 * fr) { /* 4 - 8 hrs*/
1620                 mark_interval = 20 * 60 * fr; /* show 20 minutes */
1621                 show_minutes = true;
1622                 mark_modulo = 60;
1623         } else if (range <= 16 * 60 * 60 * fr) { /* 16-24 hrs*/
1624                 mark_interval =  60 * 60 * fr; /* show 60 minutes */
1625                 show_hours = true;
1626                 mark_modulo = 2;
1627         } else {
1628
1629                 /* not possible if nframes64_t is a 32 bit quantity */
1630
1631                 mark_interval = 4 * 60 * 60 * fr; /* show 4 hrs */
1632         }
1633
1634         nmarks = 1 + (range / mark_interval);
1635         *marks = (GtkCustomRulerMark *) g_malloc (sizeof(GtkCustomRulerMark) * nmarks);
1636         pos = ((ilower + (mark_interval/2))/mark_interval) * mark_interval;
1637
1638         if (show_seconds) {
1639                 for (n = 0; n < nmarks; pos += mark_interval, ++n) {
1640                         sample_to_clock_parts (pos, fr, &hrs, &mins, &secs, &millisecs);
1641                         if (secs % mark_modulo == 0) {
1642                                 if (secs == 0) {
1643                                         (*marks)[n].style = GtkCustomRulerMarkMajor;
1644                                 } else {
1645                                         (*marks)[n].style = GtkCustomRulerMarkMinor;
1646                                 }
1647                                 snprintf (buf, sizeof(buf), "%02ld:%02ld:%02ld.%03ld", hrs, mins, secs, millisecs);
1648                         } else {
1649                                 snprintf (buf, sizeof(buf), " ");
1650                                 (*marks)[n].style = GtkCustomRulerMarkMicro;
1651                         }
1652                         (*marks)[n].label = g_strdup (buf);
1653                         (*marks)[n].position = pos;
1654                 }
1655         } else if (show_minutes) {
1656                 for (n = 0; n < nmarks; pos += mark_interval, ++n) {
1657                         sample_to_clock_parts (pos, fr, &hrs, &mins, &secs, &millisecs);
1658                         if (mins % mark_modulo == 0) {
1659                                 if (mins == 0) {
1660                                         (*marks)[n].style = GtkCustomRulerMarkMajor;
1661                                 } else {
1662                                         (*marks)[n].style = GtkCustomRulerMarkMinor;
1663                                 }
1664                                 snprintf (buf, sizeof(buf), "%02ld:%02ld:%02ld.%03ld", hrs, mins, secs, millisecs);
1665                         } else {
1666                                 snprintf (buf, sizeof(buf), " ");
1667                                 (*marks)[n].style = GtkCustomRulerMarkMicro;
1668                         }
1669                         (*marks)[n].label = g_strdup (buf);
1670                         (*marks)[n].position = pos;
1671                 }
1672         } else if (show_hours) {
1673                  for (n = 0; n < nmarks; pos += mark_interval, ++n) {
1674                         sample_to_clock_parts (pos, fr, &hrs, &mins, &secs, &millisecs);
1675                         if (hrs % mark_modulo == 0) {
1676                                 (*marks)[n].style = GtkCustomRulerMarkMajor;
1677                                 snprintf (buf, sizeof(buf), "%02ld:%02ld:%02ld.%03ld", hrs, mins, secs, millisecs);
1678                         } else {
1679                                 snprintf (buf, sizeof(buf), " ");
1680                                 (*marks)[n].style = GtkCustomRulerMarkMicro;
1681                         }
1682                         (*marks)[n].label = g_strdup (buf);
1683                         (*marks)[n].position = pos;
1684                 }
1685         } else {
1686                 for (n = 0; n < nmarks; pos += mark_interval, ++n) {
1687                         sample_to_clock_parts (pos, fr, &hrs, &mins, &secs, &millisecs);
1688                         if (millisecs % mark_modulo == 0) {
1689                                 if (millisecs == 0) {
1690                                         (*marks)[n].style = GtkCustomRulerMarkMajor;
1691                                 } else {
1692                                         (*marks)[n].style = GtkCustomRulerMarkMinor;
1693                                 }
1694                                 snprintf (buf, sizeof(buf), "%02ld:%02ld:%02ld.%03ld", hrs, mins, secs, millisecs);
1695                         } else {
1696                                 snprintf (buf, sizeof(buf), " ");
1697                                 (*marks)[n].style = GtkCustomRulerMarkMicro;
1698                         }
1699                         (*marks)[n].label = g_strdup (buf);
1700                         (*marks)[n].position = pos;
1701                 }
1702         }
1703
1704         return nmarks;
1705 }