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                 _background_group->property_y () = - get_trackview_group_vertical_offset ();
 822                 _trackview_group->move (0, 0);
 823                 _background_group->move (0, 0);
 824                 last_trackview_group_vertical_offset = get_trackview_group_vertical_offset ();
 825         }
 826
 827         gdouble bottom_track_pos = vertical_adjustment.get_value() + canvas_height - canvas_timebars_vsize;
 828         if (trackview_by_y_position(bottom_track_pos) != 0) {
 829                 trackview_by_y_position(bottom_track_pos)->clip_to_viewport ();
 830         }
 831
 832         ruler_label_vbox.set_size_request (-1, (int)(timebar_height * visible_rulers));
 833         time_canvas_vbox.set_size_request (-1,-1);
 834
 835         update_fixed_rulers();
 836         redisplay_tempo (false);
 837 }
 838
 839 void
 840 Editor::update_just_smpte ()
 841 {
 842         ENSURE_GUI_THREAD(mem_fun(*this, &Editor::update_just_smpte));
 843
 844         if (session == 0) {
 845                 return;
 846         }
 847
 848         nframes64_t rightmost_frame = leftmost_frame + current_page_frames();
 849
 850         if (ruler_timecode_action->get_active()) {
 851                 gtk_custom_ruler_set_range (GTK_CUSTOM_RULER(_smpte_ruler), leftmost_frame, rightmost_frame,
 852                                             leftmost_frame, session->current_end_frame());
 853         }
 854 }
 855
 856 void
 857 Editor::update_fixed_rulers ()
 858 {
 859         nframes64_t rightmost_frame;
 860
 861         if (session == 0) {
 862                 return;
 863         }
 864
 865         ruler_metrics[ruler_metric_smpte].units_per_pixel = frames_per_unit;
 866         ruler_metrics[ruler_metric_frames].units_per_pixel = frames_per_unit;
 867         ruler_metrics[ruler_metric_minsec].units_per_pixel = frames_per_unit;
 868
 869         rightmost_frame = leftmost_frame + current_page_frames ();
 870
 871         /* these force a redraw, which in turn will force execution of the metric callbacks
 872            to compute the relevant ticks to display.
 873         */
 874
 875         if (ruler_timecode_action->get_active()) {
 876                 gtk_custom_ruler_set_range (GTK_CUSTOM_RULER(_smpte_ruler), leftmost_frame, rightmost_frame,
 877                                             leftmost_frame, session->current_end_frame());
 878         }
 879
 880         if (ruler_samples_action->get_active()) {
 881                 gtk_custom_ruler_set_range (GTK_CUSTOM_RULER(_frames_ruler), leftmost_frame, rightmost_frame,
 882                                             leftmost_frame, session->current_end_frame());
 883         }
 884
 885         if (ruler_minsec_action->get_active()) {
 886                 gtk_custom_ruler_set_range (GTK_CUSTOM_RULER(_minsec_ruler), leftmost_frame, rightmost_frame,
 887                                             leftmost_frame, session->current_end_frame());
 888         }
 889 }
 890
 891 void
 892 Editor::update_tempo_based_rulers ()
 893 {
 894         if (session == 0) {
 895                 return;
 896         }
 897
 898         ruler_metrics[ruler_metric_bbt].units_per_pixel = frames_per_unit;
 899
 900         if (ruler_bbt_action->get_active()) {
 901                 gtk_custom_ruler_set_range (GTK_CUSTOM_RULER(_bbt_ruler), leftmost_frame, leftmost_frame+current_page_frames(),
 902                                             leftmost_frame, session->current_end_frame());
 903         }
 904 }
 905
 906 /* Mark generation */
 907
 908 gint
 909 Editor::_metric_get_smpte (GtkCustomRulerMark **marks, gdouble lower, gdouble upper, gint maxchars)
 910 {
 911         return ruler_editor->metric_get_smpte (marks, lower, upper, maxchars);
 912 }
 913
 914 gint
 915 Editor::_metric_get_bbt (GtkCustomRulerMark **marks, gdouble lower, gdouble upper, gint maxchars)
 916 {
 917         return ruler_editor->metric_get_bbt (marks, lower, upper, maxchars);
 918 }
 919
 920 gint
 921 Editor::_metric_get_frames (GtkCustomRulerMark **marks, gdouble lower, gdouble upper, gint maxchars)
 922 {
 923         return ruler_editor->metric_get_frames (marks, lower, upper, maxchars);
 924 }
 925
 926 gint
 927 Editor::_metric_get_minsec (GtkCustomRulerMark **marks, gdouble lower, gdouble upper, gint maxchars)
 928 {
 929         return ruler_editor->metric_get_minsec (marks, lower, upper, maxchars);
 930 }
 931
 932 gint
 933 Editor::metric_get_smpte (GtkCustomRulerMark **marks, gdouble lower, gdouble upper, gint maxchars)
 934 {
 935         nframes_t pos;
 936         nframes64_t range;
 937         nframes64_t spacer;
 938         nframes64_t fr;
 939         SMPTE::Time smpte;
 940         gchar buf[16];
 941         gint nmarks = 0;
 942         gint n;
 943         bool show_bits = false;
 944         bool show_frames = false;
 945         bool show_seconds = false;
 946         bool show_minutes = false;
 947         bool show_hours = false;
 948         int mark_modulo;
 949
 950         if (session == 0) {
 951                 return 0;
 952         }
 953
 954         fr = session->frame_rate();
 955
 956         if (lower > (spacer = (nframes64_t)(128 * Editor::get_current_zoom ()))) {
 957                 lower = lower - spacer;
 958         } else {
 959                 lower = 0;
 960         }
 961         upper = upper + spacer;
 962         range = (nframes64_t) floor (upper - lower);
 963
 964         if (range < (2 * session->frames_per_smpte_frame())) { /* 0 - 2 frames */
 965                 show_bits = true;
 966                 mark_modulo = 20;
 967                 nmarks = 1 + (2 * Config->get_subframes_per_frame());
 968         } else if (range <= (fr / 4)) { /* 2 frames - 0.250 second */
 969                 show_frames = true;
 970                 mark_modulo = 1;
 971                 nmarks = 1 + (range / (nframes64_t)session->frames_per_smpte_frame());
 972         } else if (range <= (fr / 2)) { /* 0.25-0.5 second */
 973                 show_frames = true;
 974                 mark_modulo = 2;
 975                 nmarks = 1 + (range / (nframes64_t)session->frames_per_smpte_frame());
 976         } else if (range <= fr) { /* 0.5-1 second */
 977                 show_frames = true;
 978                 mark_modulo = 5;
 979                 nmarks = 1 + (range / (nframes64_t)session->frames_per_smpte_frame());
 980         } else if (range <= 2 * fr) { /* 1-2 seconds */
 981                 show_frames = true;
 982                 mark_modulo = 10;
 983                 nmarks = 1 + (range / (nframes64_t)session->frames_per_smpte_frame());
 984         } else if (range <= 8 * fr) { /* 2-8 seconds */
 985                 show_seconds = true;
 986                 mark_modulo = 1;
 987                 nmarks = 1 + (range / fr);
 988         } else if (range <= 16 * fr) { /* 8-16 seconds */
 989                 show_seconds = true;
 990                 mark_modulo = 2;
 991                 nmarks = 1 + (range / fr);
 992         } else if (range <= 30 * fr) { /* 16-30 seconds */
 993                 show_seconds = true;
 994                 mark_modulo = 5;
 995                 nmarks = 1 + (range / fr);
 996         } else if (range <= 60 * fr) { /* 30-60 seconds */
 997                 show_seconds = true;
 998                 mark_modulo = 5;
 999                 nmarks = 1 + (range / fr);
1000         } else if (range <= 2 * 60 * fr) { /* 1-2 minutes */
1001                 show_seconds = true;
1002                 mark_modulo = 20;
1003                 nmarks = 1 + (range / fr);
1004         } else if (range <= 4 * 60 * fr) { /* 2-4 minutes */
1005                 show_seconds = true;
1006                 mark_modulo = 30;
1007                 nmarks = 1 + (range / fr);
1008         } else if (range <= 10 * 60 * fr) { /* 4-10 minutes */
1009                 show_minutes = true;
1010                 mark_modulo = 2;
1011                 nmarks = 1 + 10;
1012         } else if (range <= 30 * 60 * fr) { /* 10-30 minutes */
1013                 show_minutes = true;
1014                 mark_modulo = 5;
1015                 nmarks = 1 + 30;
1016         } else if (range <= 60 * 60 * fr) { /* 30 minutes - 1hr */
1017                 show_minutes = true;
1018                 mark_modulo = 10;
1019                 nmarks = 1 + 60;
1020         } else if (range <= 4 * 60 * 60 * fr) { /* 1 - 4 hrs*/
1021                 show_minutes = true;
1022                 mark_modulo = 30;
1023                 nmarks = 1 + (60 * 4);
1024         } else if (range <= 8 * 60 * 60 * fr) { /* 4 - 8 hrs*/
1025                 show_hours = true;
1026                 mark_modulo = 1;
1027                 nmarks = 1 + 8;
1028         } else if (range <= 16 * 60 * 60 * fr) { /* 16-24 hrs*/
1029                 show_hours = true;
1030                 mark_modulo = 1;
1031                 nmarks = 1 + 24;
1032         } else {
1033
1034                 /* not possible if nframes64_t is a 32 bit quantity */
1035
1036                 show_hours = true;
1037                 mark_modulo = 4;
1038                 nmarks = 1 + 24;
1039         }
1040
1041         pos = (nframes_t) floor (lower);
1042
1043         *marks = (GtkCustomRulerMark *) g_malloc (sizeof(GtkCustomRulerMark) * nmarks);
1044
1045         if (show_bits) {
1046                 // Find smpte time of this sample (pos) with subframe accuracy
1047                 session->sample_to_smpte(pos, smpte, true /* use_offset */, true /* use_subframes */ );
1048
1049                 for (n = 0; n < nmarks; n++) {
1050                         session->smpte_to_sample(smpte, pos, true /* use_offset */, true /* use_subframes */ );
1051                         if ((smpte.subframes % mark_modulo) == 0) {
1052                                 if (smpte.subframes == 0) {
1053                                         (*marks)[n].style = GtkCustomRulerMarkMajor;
1054                                         snprintf (buf, sizeof(buf), "%s%02u:%02u:%02u:%02u", smpte.negative ? "-" : "", smpte.hours, smpte.minutes, smpte.seconds, smpte.frames);
1055                                 } else {
1056                                         (*marks)[n].style = GtkCustomRulerMarkMinor;
1057                                         snprintf (buf, sizeof(buf), ".%02u", smpte.subframes);
1058                                 }
1059                         } else {
1060                                 snprintf (buf, sizeof(buf)," ");
1061                                 (*marks)[n].style = GtkCustomRulerMarkMicro;
1062
1063                         }
1064                         (*marks)[n].label = g_strdup (buf);
1065                         (*marks)[n].position = pos;
1066
1067                         // Increment subframes by one
1068                         SMPTE::increment_subframes( smpte );
1069                 }
1070         } else if (show_seconds) {
1071                 // Find smpte time of this sample (pos)
1072                 session->sample_to_smpte(pos, smpte, true /* use_offset */, false /* use_subframes */ );
1073                 // Go to next whole second down
1074                 SMPTE::seconds_floor( smpte );
1075
1076                 for (n = 0; n < nmarks; n++) {
1077                         session->smpte_to_sample(smpte, pos, true /* use_offset */, false /* use_subframes */ );
1078                         if ((smpte.seconds % mark_modulo) == 0) {
1079                                 if (smpte.seconds == 0) {
1080                                         (*marks)[n].style = GtkCustomRulerMarkMajor;
1081                                         (*marks)[n].position = pos;
1082                                 } else {
1083                                         (*marks)[n].style = GtkCustomRulerMarkMinor;
1084                                         (*marks)[n].position = pos;
1085                                 }
1086                                 snprintf (buf, sizeof(buf), "%s%02u:%02u:%02u:%02u", smpte.negative ? "-" : "", smpte.hours, smpte.minutes, smpte.seconds, smpte.frames);
1087                         } else {
1088                                 snprintf (buf, sizeof(buf)," ");
1089                                 (*marks)[n].style = GtkCustomRulerMarkMicro;
1090                                 (*marks)[n].position = pos;
1091
1092                         }
1093                         (*marks)[n].label = g_strdup (buf);
1094                         SMPTE::increment_seconds( smpte );
1095                 }
1096         } else if (show_minutes) {
1097                 // Find smpte time of this sample (pos)
1098                 session->sample_to_smpte(pos, smpte, true /* use_offset */, false /* use_subframes */ );
1099                 // Go to next whole minute down
1100                 SMPTE::minutes_floor( smpte );
1101
1102                 for (n = 0; n < nmarks; n++) {
1103                         session->smpte_to_sample(smpte, pos, true /* use_offset */, false /* use_subframes */ );
1104                         if ((smpte.minutes % mark_modulo) == 0) {
1105                                 if (smpte.minutes == 0) {
1106                                         (*marks)[n].style = GtkCustomRulerMarkMajor;
1107                                 } else {
1108                                         (*marks)[n].style = GtkCustomRulerMarkMinor;
1109                                 }
1110                                 snprintf (buf, sizeof(buf), "%s%02u:%02u:%02u:%02u", smpte.negative ? "-" : "", smpte.hours, smpte.minutes, smpte.seconds, smpte.frames);
1111                         } else {
1112                                 snprintf (buf, sizeof(buf)," ");
1113                                 (*marks)[n].style = GtkCustomRulerMarkMicro;
1114
1115                         }
1116                         (*marks)[n].label = g_strdup (buf);
1117                         (*marks)[n].position = pos;
1118                         SMPTE::increment_minutes( smpte );
1119                 }
1120         } else if (show_hours) {
1121                 // Find smpte time of this sample (pos)
1122                 session->sample_to_smpte(pos, smpte, true /* use_offset */, false /* use_subframes */ );
1123                 // Go to next whole hour down
1124                 SMPTE::hours_floor( smpte );
1125
1126                 for (n = 0; n < nmarks; n++) {
1127                         session->smpte_to_sample(smpte, pos, true /* use_offset */, false /* use_subframes */ );
1128                         if ((smpte.hours % mark_modulo) == 0) {
1129                                 (*marks)[n].style = GtkCustomRulerMarkMajor;
1130                                 snprintf (buf, sizeof(buf), "%s%02u:%02u:%02u:%02u", smpte.negative ? "-" : "", smpte.hours, smpte.minutes, smpte.seconds, smpte.frames);
1131                         } else {
1132                                 snprintf (buf, sizeof(buf)," ");
1133                                 (*marks)[n].style = GtkCustomRulerMarkMicro;
1134
1135                         }
1136                         (*marks)[n].label = g_strdup (buf);
1137                         (*marks)[n].position = pos;
1138
1139                         SMPTE::increment_hours( smpte );
1140                 }
1141         } else { // show_frames
1142                 // Find smpte time of this sample (pos)
1143                 session->sample_to_smpte(pos, smpte, true /* use_offset */, false /* use_subframes */ );
1144                 // Go to next whole frame down
1145                 SMPTE::frames_floor( smpte );
1146
1147                 for (n = 0; n < nmarks; n++) {
1148                         session->smpte_to_sample(smpte, pos, true /* use_offset */, false /* use_subframes */ );
1149                         if ((smpte.frames % mark_modulo) == 0)  {
1150                                 (*marks)[n].style = GtkCustomRulerMarkMajor;
1151                                 (*marks)[n].position = pos;
1152                                 snprintf (buf, sizeof(buf), "%s%02u:%02u:%02u:%02u", smpte.negative ? "-" : "", smpte.hours, smpte.minutes, smpte.seconds, smpte.frames);
1153                         } else {
1154                                 snprintf (buf, sizeof(buf)," ");
1155                                 (*marks)[n].style = GtkCustomRulerMarkMicro;
1156                                 (*marks)[n].position = pos;
1157
1158                         }
1159                         (*marks)[n].label = g_strdup (buf);
1160                         SMPTE::increment( smpte );
1161                 }
1162         }
1163
1164         return nmarks;
1165 }
1166
1167
1168 gint
1169 Editor::metric_get_bbt (GtkCustomRulerMark **marks, gdouble lower, gdouble upper, gint maxchars)
1170 {
1171         if (session == 0) {
1172                 return 0;
1173         }
1174
1175         TempoMap::BBTPointList::iterator i;
1176
1177         uint32_t beats = 0;
1178         uint32_t bars = 0;
1179         uint32_t desirable_marks;
1180         uint32_t magic_accent_number = 1;
1181         gint nmarks;
1182         char buf[64];
1183         gint  n = 0;
1184         nframes64_t pos;
1185         bool bar_helper_on = true;
1186
1187         BBT_Time next_beat;
1188         nframes64_t next_beat_pos;
1189
1190         if ((desirable_marks = maxchars / 7) == 0) {
1191                return 0;
1192         }
1193
1194         /* align the tick marks to whatever we're snapping to... */
1195
1196         switch (snap_type) {
1197         case SnapToAThirdBeat:
1198                 bbt_beat_subdivision = 3;
1199                 break;
1200         case SnapToAQuarterBeat:
1201                 bbt_beat_subdivision = 4;
1202                 break;
1203         case SnapToAEighthBeat:
1204                 bbt_beat_subdivision = 8;
1205                 magic_accent_number = 2;
1206                 break;
1207         case SnapToASixteenthBeat:
1208                 bbt_beat_subdivision = 16;
1209                 magic_accent_number = 4;
1210                 break;
1211         case SnapToAThirtysecondBeat:
1212                 bbt_beat_subdivision = 32;
1213                 magic_accent_number = 8;
1214                 break;
1215         default:
1216                bbt_beat_subdivision = 4;
1217                 break;
1218         }
1219
1220         if (current_bbt_points == 0 || current_bbt_points->empty()) {
1221                 return 0;
1222         }
1223
1224         i = current_bbt_points->end();
1225         i--;
1226         bars = (*i).bar - (*current_bbt_points->begin()).bar;
1227         beats = current_bbt_points->size() - bars;
1228
1229         /*Only show the bar helper if there aren't many bars on the screen */
1230         if (bars > 1) {
1231                 bar_helper_on = false;
1232         }
1233
1234         if (desirable_marks > (beats / 4)) {
1235
1236                 /* we're in beat land...*/
1237
1238                 uint32_t tick = 0;
1239                 uint32_t skip;
1240                 uint32_t t;
1241                 nframes64_t frame_skip;
1242                 double frame_skip_error;
1243                 double accumulated_error;
1244                 double position_of_helper;
1245                 bool i_am_accented = false;
1246                 bool we_need_ticks = false;
1247                 bool helper_active = false;
1248
1249                 position_of_helper = lower + (30 * Editor::get_current_zoom ());
1250
1251                 if (desirable_marks >= (beats)) {
1252                         nmarks = (beats * bbt_beat_subdivision) + 1;
1253                         we_need_ticks = true;
1254                 } else {
1255                         nmarks = beats + 1;
1256                 }
1257
1258                 *marks = (GtkCustomRulerMark *) g_malloc (sizeof(GtkCustomRulerMark) * nmarks);
1259
1260                 (*marks)[0].label = g_strdup(" ");
1261                 (*marks)[0].position = lower;
1262                 (*marks)[0].style = GtkCustomRulerMarkMicro;
1263
1264                 for (n = 1,   i = current_bbt_points->begin(); n < nmarks && i != current_bbt_points->end(); ++i) {
1265
1266                         if ((*i).frame < lower && (bar_helper_on)) {
1267                                         snprintf (buf, sizeof(buf), "<%" PRIu32 "|%" PRIu32, (*i).bar, (*i).beat);
1268                                         (*marks)[0].label = g_strdup (buf);
1269                                         helper_active = true;
1270                         } else {
1271
1272                           if ((*i).type == TempoMap::Bar)  {
1273                             if (((*i).frame < position_of_helper) && helper_active) {
1274                               snprintf (buf, sizeof(buf), " ");
1275                             } else {
1276                               snprintf (buf, sizeof(buf), "%" PRIu32, (*i).bar);
1277                             }
1278                             (*marks)[n].label = g_strdup (buf);
1279                             (*marks)[n].position = (*i).frame;
1280                             (*marks)[n].style = GtkCustomRulerMarkMajor;
1281                             n++;
1282
1283                           } else if (((*i).type == TempoMap::Beat) && ((*i).beat > 1)) {
1284                             ((((*i).frame < position_of_helper) && bar_helper_on) || !we_need_ticks) ?
1285                               snprintf (buf, sizeof(buf), " ") : snprintf (buf, sizeof(buf), "%" PRIu32, (*i).beat);
1286                             if (((*i).beat % 2 == 1) || we_need_ticks) {
1287                               (*marks)[n].style = GtkCustomRulerMarkMinor;
1288                             } else {
1289                               (*marks)[n].style = GtkCustomRulerMarkMicro;
1290                             }
1291                             (*marks)[n].label =  g_strdup (buf);
1292                             (*marks)[n].position = (*i).frame;
1293                             n++;
1294                           }
1295
1296                         }
1297
1298
1299                         /* Add the tick marks */
1300
1301                         if (we_need_ticks && (*i).type == TempoMap::Beat) {
1302
1303                                 /* Find the next beat */
1304
1305                                 next_beat.beats = (*i).beat;
1306                                 next_beat.bars = (*i).bar;
1307
1308                                 if ((*i).meter->beats_per_bar() > (next_beat.beats + 1)) {
1309                                   next_beat.beats += 1;
1310                                 } else {
1311                                   next_beat.bars += 1;
1312                                   next_beat.beats = 1;
1313                                 }
1314
1315                                 next_beat_pos = session->tempo_map().frame_time(next_beat);
1316
1317                                 frame_skip = (nframes64_t) floor (frame_skip_error = (session->frame_rate() *  60) / (bbt_beat_subdivision * (*i).tempo->beats_per_minute()));
1318                                 frame_skip_error -= frame_skip;
1319                                 skip = (uint32_t) (Meter::ticks_per_beat / bbt_beat_subdivision);
1320
1321                                 pos = (*i).frame + frame_skip;
1322                                 accumulated_error = frame_skip_error;
1323
1324                                 tick = skip;
1325
1326                                 for (t = 0; (tick < Meter::ticks_per_beat) && (n < nmarks) && (pos < next_beat_pos) ; pos += frame_skip, tick += skip, ++t) {
1327
1328                                         if (t % magic_accent_number == (magic_accent_number - 1)) {
1329                                                 i_am_accented = true;
1330                                         }
1331                                         if (Editor::get_current_zoom () > 32) {
1332                                                 snprintf (buf, sizeof(buf), " ");
1333                                         } else if ((Editor::get_current_zoom () > 8) && !i_am_accented) {
1334                                                 snprintf (buf, sizeof(buf), " ");
1335                                         } else  if (bar_helper_on && (pos < position_of_helper)) {
1336                                                 snprintf (buf, sizeof(buf), " ");
1337                                         } else {
1338                                                 snprintf (buf, sizeof(buf), "%" PRIu32, tick);
1339                                         }
1340
1341                                         (*marks)[n].label = g_strdup (buf);
1342
1343                                         /* Error compensation for float to nframes64_t*/
1344                                         accumulated_error += frame_skip_error;
1345                                         if (accumulated_error > 1) {
1346                                                 pos += 1;
1347                                                 accumulated_error -= 1.0f;
1348                                         }
1349
1350                                         (*marks)[n].position = pos;
1351
1352                                         if ((bbt_beat_subdivision > 4) && i_am_accented) {
1353                                                 (*marks)[n].style = GtkCustomRulerMarkMinor;
1354                                         } else {
1355                                                 (*marks)[n].style = GtkCustomRulerMarkMicro;
1356                                         }
1357                                         i_am_accented = false;
1358                                         n++;
1359
1360                                 }
1361                         }
1362                 }
1363                 return n; //return the actual number of marks made, since we might have skipped some fro fractional time signatures
1364
1365        } else {
1366
1367                 /* we're in bar land */
1368
1369                 if (desirable_marks < (bars / 256)) {
1370                         nmarks = 1;
1371                         *marks = (GtkCustomRulerMark *) g_malloc (sizeof(GtkCustomRulerMark) * nmarks);
1372                         snprintf (buf, sizeof(buf), "too many bars... (currently %" PRIu32 ")", bars );
1373                         (*marks)[0].style = GtkCustomRulerMarkMajor;
1374                         (*marks)[0].label = g_strdup (buf);
1375                         (*marks)[0].position = lower;
1376                 } else if (desirable_marks < (uint32_t)(nmarks = (gint) (bars / 64) + 1)) {
1377                         *marks = (GtkCustomRulerMark *) g_malloc (sizeof(GtkCustomRulerMark) * nmarks);
1378                         for (n = 0,   i = current_bbt_points->begin(); i != current_bbt_points->end() && n < nmarks; i++) {
1379                                 if ((*i).type == TempoMap::Bar)  {
1380                                         if ((*i).bar % 64 == 1) {
1381                                                 if ((*i).bar % 256 == 1) {
1382                                                         snprintf (buf, sizeof(buf), "%" PRIu32, (*i).bar);
1383                                                         (*marks)[n].style = GtkCustomRulerMarkMajor;
1384                                                 } else {
1385                                                         snprintf (buf, sizeof(buf), " ");
1386                                                         if ((*i).bar % 256 == 129)  {
1387                                                                 (*marks)[n].style = GtkCustomRulerMarkMinor;
1388                                                         } else {
1389                                                                 (*marks)[n].style = GtkCustomRulerMarkMicro;
1390                                                         }
1391                                                 }
1392                                                 (*marks)[n].label = g_strdup (buf);
1393                                                 (*marks)[n].position = (*i).frame;
1394                                                 n++;
1395                                         }
1396                                 }
1397                         }
1398                 } else if (desirable_marks < (uint32_t)(nmarks = (bars / 16) + 1)) {
1399                         *marks = (GtkCustomRulerMark *) g_malloc (sizeof(GtkCustomRulerMark) * nmarks);
1400                         for (n = 0,  i = current_bbt_points->begin(); i != current_bbt_points->end() && n < nmarks; i++) {
1401                                 if ((*i).type == TempoMap::Bar)  {
1402                                         if ((*i).bar % 16 == 1) {
1403                                                 if ((*i).bar % 64 == 1) {
1404                                                         snprintf (buf, sizeof(buf), "%" PRIu32, (*i).bar);
1405                                                         (*marks)[n].style = GtkCustomRulerMarkMajor;
1406                                                 } else {
1407                                                         snprintf (buf, sizeof(buf), " ");
1408                                                         if ((*i).bar % 64 == 33)  {
1409                                                                 (*marks)[n].style = GtkCustomRulerMarkMinor;
1410                                                         } else {
1411                                                                 (*marks)[n].style = GtkCustomRulerMarkMicro;
1412                                                         }
1413                                                 }
1414                                                 (*marks)[n].label = g_strdup (buf);
1415                                                 (*marks)[n].position = (*i).frame;
1416                                                 n++;
1417                                         }
1418                                 }
1419                         }
1420                 } else if (desirable_marks < (uint32_t)(nmarks = (bars / 4) + 1)){
1421                         *marks = (GtkCustomRulerMark *) g_malloc (sizeof(GtkCustomRulerMark) * nmarks);
1422                         for (n = 0,   i = current_bbt_points->begin(); i != current_bbt_points->end() && n < nmarks; ++i) {
1423                                 if ((*i).type == TempoMap::Bar)  {
1424                                         if ((*i).bar % 4 == 1) {
1425                                                 if ((*i).bar % 16 == 1) {
1426                                                         snprintf (buf, sizeof(buf), "%" PRIu32, (*i).bar);
1427                                                         (*marks)[n].style = GtkCustomRulerMarkMajor;
1428                                                 } else {
1429                                                         snprintf (buf, sizeof(buf), " ");
1430                                                         if ((*i).bar % 16 == 9)  {
1431                                                                 (*marks)[n].style = GtkCustomRulerMarkMinor;
1432                                                         } else {
1433                                                                 (*marks)[n].style = GtkCustomRulerMarkMicro;
1434                                                         }
1435                                                 }
1436                                                 (*marks)[n].label = g_strdup (buf);
1437                                                 (*marks)[n].position = (*i).frame;
1438                                                 n++;
1439                                         }
1440                                 }
1441                         }
1442                 } else {
1443                         nmarks = bars + 1;
1444                         *marks = (GtkCustomRulerMark *) g_malloc (sizeof(GtkCustomRulerMark) * nmarks );
1445                         for (n = 0,  i = current_bbt_points->begin(); i != current_bbt_points->end() && n < nmarks; i++) {
1446                                 if ((*i).type == TempoMap::Bar)  {
1447                                         if ((*i).bar % 4 == 1) {
1448                                                 snprintf (buf, sizeof(buf), "%" PRIu32, (*i).bar);
1449                                                 (*marks)[n].style = GtkCustomRulerMarkMajor;
1450                                         } else {
1451                                                 snprintf (buf, sizeof(buf), " ");
1452                                                 if ((*i).bar % 4 == 3)  {
1453                                                         (*marks)[n].style = GtkCustomRulerMarkMinor;
1454                                                 } else {
1455                                                         (*marks)[n].style = GtkCustomRulerMarkMicro;
1456                                                 }
1457                                         }
1458                                         (*marks)[n].label = g_strdup (buf);
1459                                         (*marks)[n].position = (*i).frame;
1460                                         n++;
1461                                 }
1462                         }
1463                 }
1464                 return n;
1465         }
1466 }
1467
1468 gint
1469 Editor::metric_get_frames (GtkCustomRulerMark **marks, gdouble lower, gdouble upper, gint maxchars)
1470 {
1471         nframes64_t mark_interval;
1472         nframes64_t pos;
1473         nframes64_t ilower = (nframes64_t) floor (lower);
1474         nframes64_t iupper = (nframes64_t) floor (upper);
1475         gchar buf[16];
1476         gint nmarks;
1477         gint n;
1478
1479         if (session == 0) {
1480                 return 0;
1481         }
1482
1483         mark_interval = (iupper - ilower) / 5;
1484         if (mark_interval > session->frame_rate()) {
1485                 mark_interval -= mark_interval % session->frame_rate();
1486         } else {
1487                 mark_interval = session->frame_rate() / (session->frame_rate() / mark_interval ) ;
1488         }
1489         nmarks = 5;
1490         *marks = (GtkCustomRulerMark *) g_malloc (sizeof(GtkCustomRulerMark) * nmarks);
1491         for (n = 0, pos = ilower; n < nmarks; pos += mark_interval, ++n) {
1492                 snprintf (buf, sizeof(buf), "%" PRIi64,  pos);
1493                 (*marks)[n].label = g_strdup (buf);
1494                 (*marks)[n].position = pos;
1495                 (*marks)[n].style = GtkCustomRulerMarkMajor;
1496         }
1497
1498         return nmarks;
1499 }
1500
1501 static void
1502 sample_to_clock_parts ( nframes64_t sample,
1503                         nframes64_t sample_rate,
1504                         long *hrs_p,
1505                         long *mins_p,
1506                         long *secs_p,
1507                         long *millisecs_p)
1508
1509 {
1510         nframes64_t left;
1511         long hrs;
1512         long mins;
1513         long secs;
1514         long millisecs;
1515
1516         left = sample;
1517         hrs = left / (sample_rate * 60 * 60);
1518         left -= hrs * sample_rate * 60 * 60;
1519         mins = left / (sample_rate * 60);
1520         left -= mins * sample_rate * 60;
1521         secs = left / sample_rate;
1522         left -= secs * sample_rate;
1523         millisecs = left * 1000 / sample_rate;
1524
1525         *millisecs_p = millisecs;
1526         *secs_p = secs;
1527         *mins_p = mins;
1528         *hrs_p = hrs;
1529
1530         return;
1531 }
1532
1533 gint
1534 Editor::metric_get_minsec (GtkCustomRulerMark **marks, gdouble lower, gdouble upper, gint maxchars)
1535 {
1536         nframes64_t range;
1537         nframes64_t fr;
1538         nframes64_t mark_interval;
1539         nframes64_t pos;
1540         nframes64_t spacer;
1541         long hrs, mins, secs, millisecs;
1542         gchar buf[16];
1543         gint nmarks;
1544         gint n;
1545         gint mark_modulo = 100;
1546         bool show_seconds = false;
1547         bool show_minutes = false;
1548         bool show_hours = false;
1549         nframes64_t ilower = (nframes64_t) floor (lower);
1550         nframes64_t iupper = (nframes64_t) floor (upper);
1551
1552         if (session == 0) {
1553                 return 0;
1554         }
1555
1556         fr = session->frame_rate();
1557
1558         /* to prevent 'flashing' */
1559         if (lower > (spacer = (nframes64_t)(128 * Editor::get_current_zoom ()))) {
1560                 lower = lower - spacer;
1561         } else {
1562                 lower = 0;
1563         }
1564         upper = upper + spacer;
1565         range = iupper - ilower;
1566
1567         if (range <  (fr / 50)) {
1568                 mark_interval =  fr / 100; /* show 1/100 seconds */
1569                 mark_modulo = 10;
1570         } else if (range <= (fr / 10)) { /* 0-0.1 second */
1571                 mark_interval = fr / 50; /* show 1/50 seconds */
1572                 mark_modulo = 20;
1573         } else if (range <= (fr / 2)) { /* 0-0.5 second */
1574                 mark_interval = fr / 20;  /* show 1/20 seconds */
1575                 mark_modulo = 100;
1576         } else if (range <= fr) { /* 0-1 second */
1577                 mark_interval = fr / 10;  /* show 1/10 seconds */
1578                 mark_modulo = 200;
1579         } else if (range <= 2 * fr) { /* 1-2 seconds */
1580                 mark_interval = fr / 2; /* show 1/2 seconds */
1581                 mark_modulo = 500;
1582         } else if (range <= 8 * fr) { /* 2-5 seconds */
1583                 mark_interval =  fr / 5; /* show 2 seconds */
1584                 mark_modulo = 1000;
1585         } else if (range <= 16 * fr) { /* 8-16 seconds */
1586                 mark_interval =  fr; /* show 1 seconds */
1587                 show_seconds = true;
1588                 mark_modulo = 5;
1589         } else if (range <= 30 * fr) { /* 10-30 seconds */
1590                 mark_interval =  fr; /* show 10 seconds */
1591                 show_seconds = true;
1592                 mark_modulo = 5;
1593         } else if (range <= 60 * fr) { /* 30-60 seconds */
1594                 mark_interval = 5 * fr; /* show 5 seconds */
1595                 show_seconds = true;
1596                 mark_modulo = 3;
1597         } else if (range <= 2 * 60 * fr) { /* 1-2 minutes */
1598                 mark_interval = 5 * fr; /* show 5 seconds */
1599                 show_seconds = true;
1600                 mark_modulo = 3;
1601         } else if (range <= 4 * 60 * fr) { /* 4 minutes */
1602                 mark_interval = 10 * fr; /* show 10 seconds */
1603                 show_seconds = true;
1604                 mark_modulo = 30;
1605         } else if (range <= 10 * 60 * fr) { /* 10 minutes */
1606                 mark_interval = 30 * fr; /* show 30 seconds */
1607                 show_seconds = true;
1608                 mark_modulo = 60;
1609         } else if (range <= 30 * 60 * fr) { /* 10-30 minutes */
1610                 mark_interval =  60 * fr; /* show 1 minute */
1611                 show_minutes = true;
1612                 mark_modulo = 5;
1613         } else if (range <= 60 * 60 * fr) { /* 30 minutes - 1hr */
1614                 mark_interval = 2 * 60 * fr; /* show 2 minutes */
1615                 show_minutes = true;
1616                 mark_modulo = 10;
1617         } else if (range <= 4 * 60 * 60 * fr) { /* 1 - 4 hrs*/
1618                 mark_interval = 5 * 60 * fr; /* show 10 minutes */
1619                 show_minutes = true;
1620                 mark_modulo = 30;
1621         } else if (range <= 8 * 60 * 60 * fr) { /* 4 - 8 hrs*/
1622                 mark_interval = 20 * 60 * fr; /* show 20 minutes */
1623                 show_minutes = true;
1624                 mark_modulo = 60;
1625         } else if (range <= 16 * 60 * 60 * fr) { /* 16-24 hrs*/
1626                 mark_interval =  60 * 60 * fr; /* show 60 minutes */
1627                 show_hours = true;
1628                 mark_modulo = 2;
1629         } else {
1630
1631                 /* not possible if nframes64_t is a 32 bit quantity */
1632
1633                 mark_interval = 4 * 60 * 60 * fr; /* show 4 hrs */
1634         }
1635
1636         nmarks = 1 + (range / mark_interval);
1637         *marks = (GtkCustomRulerMark *) g_malloc (sizeof(GtkCustomRulerMark) * nmarks);
1638         pos = ((ilower + (mark_interval/2))/mark_interval) * mark_interval;
1639
1640         if (show_seconds) {
1641                 for (n = 0; n < nmarks; pos += mark_interval, ++n) {
1642                         sample_to_clock_parts (pos, fr, &hrs, &mins, &secs, &millisecs);
1643                         if (secs % mark_modulo == 0) {
1644                                 if (secs == 0) {
1645                                         (*marks)[n].style = GtkCustomRulerMarkMajor;
1646                                 } else {
1647                                         (*marks)[n].style = GtkCustomRulerMarkMinor;
1648                                 }
1649                                 snprintf (buf, sizeof(buf), "%02ld:%02ld:%02ld.%03ld", hrs, mins, secs, millisecs);
1650                         } else {
1651                                 snprintf (buf, sizeof(buf), " ");
1652                                 (*marks)[n].style = GtkCustomRulerMarkMicro;
1653                         }
1654                         (*marks)[n].label = g_strdup (buf);
1655                         (*marks)[n].position = pos;
1656                 }
1657         } else if (show_minutes) {
1658                 for (n = 0; n < nmarks; pos += mark_interval, ++n) {
1659                         sample_to_clock_parts (pos, fr, &hrs, &mins, &secs, &millisecs);
1660                         if (mins % mark_modulo == 0) {
1661                                 if (mins == 0) {
1662                                         (*marks)[n].style = GtkCustomRulerMarkMajor;
1663                                 } else {
1664                                         (*marks)[n].style = GtkCustomRulerMarkMinor;
1665                                 }
1666                                 snprintf (buf, sizeof(buf), "%02ld:%02ld:%02ld.%03ld", hrs, mins, secs, millisecs);
1667                         } else {
1668                                 snprintf (buf, sizeof(buf), " ");
1669                                 (*marks)[n].style = GtkCustomRulerMarkMicro;
1670                         }
1671                         (*marks)[n].label = g_strdup (buf);
1672                         (*marks)[n].position = pos;
1673                 }
1674         } else if (show_hours) {
1675                  for (n = 0; n < nmarks; pos += mark_interval, ++n) {
1676                         sample_to_clock_parts (pos, fr, &hrs, &mins, &secs, &millisecs);
1677                         if (hrs % mark_modulo == 0) {
1678                                 (*marks)[n].style = GtkCustomRulerMarkMajor;
1679                                 snprintf (buf, sizeof(buf), "%02ld:%02ld:%02ld.%03ld", hrs, mins, secs, millisecs);
1680                         } else {
1681                                 snprintf (buf, sizeof(buf), " ");
1682                                 (*marks)[n].style = GtkCustomRulerMarkMicro;
1683                         }
1684                         (*marks)[n].label = g_strdup (buf);
1685                         (*marks)[n].position = pos;
1686                 }
1687         } else {
1688                 for (n = 0; n < nmarks; pos += mark_interval, ++n) {
1689                         sample_to_clock_parts (pos, fr, &hrs, &mins, &secs, &millisecs);
1690                         if (millisecs % mark_modulo == 0) {
1691                                 if (millisecs == 0) {
1692                                         (*marks)[n].style = GtkCustomRulerMarkMajor;
1693                                 } else {
1694                                         (*marks)[n].style = GtkCustomRulerMarkMinor;
1695                                 }
1696                                 snprintf (buf, sizeof(buf), "%02ld:%02ld:%02ld.%03ld", hrs, mins, secs, millisecs);
1697                         } else {
1698                                 snprintf (buf, sizeof(buf), " ");
1699                                 (*marks)[n].style = GtkCustomRulerMarkMicro;
1700                         }
1701                         (*marks)[n].label = g_strdup (buf);
1702                         (*marks)[n].position = pos;
1703                 }
1704         }
1705
1706         return nmarks;
1707 }