gtk2_ardour/editor_markers.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 <sigc++/retype.h>
  21 #include <cstdlib>
  22 #include <cmath>
  23
  24 #include <libgnomecanvas/libgnomecanvas.h>
  25 #include <gtkmm2ext/gtk_ui.h>
  26
  27 #include "ardour/session.h"
  28 #include "ardour/location.h"
  29 #include "ardour/profile.h"
  30 #include "pbd/memento_command.h"
  31
  32 #include "editor.h"
  33 #include "marker.h"
  34 #include "selection.h"
  35 #include "editing.h"
  36 #include "gui_thread.h"
  37 #include "simplerect.h"
  38 #include "actions.h"
  39 #include "prompter.h"
  40 #include "editor_drag.h"
  41
  42 #include "i18n.h"
  43
  44 using namespace std;
  45 using namespace ARDOUR;
  46 using namespace PBD;
  47 using namespace Gtk;
  48 using namespace Gtkmm2ext;
  49
  50 void
  51 Editor::clear_marker_display ()
  52 {
  53         for (LocationMarkerMap::iterator i = location_markers.begin(); i != location_markers.end(); ++i) {
  54                 delete i->second;
  55         }
  56
  57         location_markers.clear ();
  58         _sorted_marker_lists.clear ();
  59 }
  60
  61 void
  62 Editor::add_new_location (Location *location)
  63 {
  64         ENSURE_GUI_THREAD (*this, &Editor::add_new_location, location);
  65
  66         ArdourCanvas::Group* group = add_new_location_internal (location);
  67
  68         /* Do a full update of the markers in this group */
  69         update_marker_labels (group);
  70 }
  71
  72 /** Add a new location, without a time-consuming update of all marker labels;
  73  *  the caller must call update_marker_labels () after calling this.
  74  *  @return canvas group that the location's marker was added to.
  75  */
  76 ArdourCanvas::Group*
  77 Editor::add_new_location_internal (Location* location)
  78 {
  79         LocationMarkers *lam = new LocationMarkers;
  80         uint32_t color;
  81
  82         /* make a note here of which group this marker ends up in */
  83         ArdourCanvas::Group* group = 0;
  84
  85         if (location->is_cd_marker()) {
  86                 color = location_cd_marker_color;
  87         } else if (location->is_mark()) {
  88                 color = location_marker_color;
  89         } else if (location->is_auto_loop()) {
  90                 color = location_loop_color;
  91         } else if (location->is_auto_punch()) {
  92                 color = location_punch_color;
  93         } else {
  94                 color = location_range_color;
  95         }
  96
  97         if (location->is_mark()) {
  98
  99                 if (location->is_cd_marker() && ruler_cd_marker_action->get_active()) {
 100                         lam->start = new Marker (*this, *cd_marker_group, color, location->name(), Marker::Mark, location->start());
 101                         group = cd_marker_group;
 102                 } else {
 103                         lam->start = new Marker (*this, *marker_group, color, location->name(), Marker::Mark, location->start());
 104                         group = marker_group;
 105                 }
 106
 107                 lam->end = 0;
 108
 109         } else if (location->is_auto_loop()) {
 110
 111                 // transport marker
 112                 lam->start = new Marker (*this, *transport_marker_group, color,
 113                                          location->name(), Marker::LoopStart, location->start());
 114                 lam->end   = new Marker (*this, *transport_marker_group, color,
 115                                          location->name(), Marker::LoopEnd, location->end());
 116                 group = transport_marker_group;
 117
 118         } else if (location->is_auto_punch()) {
 119
 120                 // transport marker
 121                 lam->start = new Marker (*this, *transport_marker_group, color,
 122                                          location->name(), Marker::PunchIn, location->start());
 123                 lam->end   = new Marker (*this, *transport_marker_group, color,
 124                                          location->name(), Marker::PunchOut, location->end());
 125                 group = transport_marker_group;
 126
 127         } else if (location->is_session_range()) {
 128
 129                 // session range
 130                 lam->start = new Marker (*this, *marker_group, color, _("start"), Marker::SessionStart, location->start());
 131                 lam->end = new Marker (*this, *marker_group, color, _("end"), Marker::SessionEnd, location->end());
 132                 group = marker_group;
 133
 134         } else {
 135                 // range marker
 136                 if (location->is_cd_marker() && ruler_cd_marker_action->get_active()) {
 137                         lam->start = new Marker (*this, *cd_marker_group, color,
 138                                                  location->name(), Marker::RangeStart, location->start());
 139                         lam->end   = new Marker (*this, *cd_marker_group, color,
 140                                                  location->name(), Marker::RangeEnd, location->end());
 141                         group = cd_marker_group;
 142                 } else {
 143                         lam->start = new Marker (*this, *range_marker_group, color,
 144                                                  location->name(), Marker::RangeStart, location->start());
 145                         lam->end   = new Marker (*this, *range_marker_group, color,
 146                                                  location->name(), Marker::RangeEnd, location->end());
 147                         group = range_marker_group;
 148                 }
 149         }
 150
 151         if (location->is_hidden ()) {
 152                 lam->hide();
 153         } else {
 154                 lam->show ();
 155         }
 156
 157         location->start_changed.connect (*this, invalidator (*this), ui_bind (&Editor::location_changed, this, _1), gui_context());
 158         location->end_changed.connect (*this, invalidator (*this), ui_bind (&Editor::location_changed, this, _1), gui_context());
 159         location->changed.connect (*this, invalidator (*this), ui_bind (&Editor::location_changed, this, _1), gui_context());
 160         location->name_changed.connect (*this, invalidator (*this), ui_bind (&Editor::location_changed, this, _1), gui_context());
 161         location->FlagsChanged.connect (*this, invalidator (*this), ui_bind (&Editor::location_flags_changed, this, _1, _2), gui_context());
 162
 163         pair<Location*,LocationMarkers*> newpair;
 164
 165         newpair.first = location;
 166         newpair.second = lam;
 167
 168         location_markers.insert (newpair);
 169
 170         if (select_new_marker && location->is_mark()) {
 171                 selection->set (lam->start);
 172                 select_new_marker = false;
 173         }
 174
 175         lam->canvas_height_set (_canvas_height);
 176         lam->set_show_lines (_show_marker_lines);
 177
 178         /* Add these markers to the appropriate sorted marker lists, which will render
 179            them unsorted until a call to update_marker_labels() sorts them out.
 180         */
 181         _sorted_marker_lists[group].push_back (lam->start);
 182         if (lam->end) {
 183                 _sorted_marker_lists[group].push_back (lam->end);
 184         }
 185
 186         return group;
 187 }
 188
 189 void
 190 Editor::location_changed (Location *location)
 191 {
 192         ENSURE_GUI_THREAD (*this, &Editor::location_changed, location)
 193
 194         LocationMarkers *lam = find_location_markers (location);
 195
 196         if (lam == 0) {
 197                 /* a location that isn't "marked" with markers */
 198                 return;
 199         }
 200
 201         lam->set_name (location->name ());
 202         lam->set_position (location->start(), location->end());
 203
 204         if (location->is_auto_loop()) {
 205                 update_loop_range_view ();
 206         } else if (location->is_auto_punch()) {
 207                 update_punch_range_view ();
 208         }
 209
 210         check_marker_label (lam->start);
 211         if (lam->end) {
 212                 check_marker_label (lam->end);
 213         }
 214 }
 215
 216 /** Look at a marker and check whether its label, and those of the previous and next markers,
 217  *  need to have their labels updated (in case those labels need to be shortened or can be
 218  *  lengthened)
 219  */
 220 void
 221 Editor::check_marker_label (Marker* m)
 222 {
 223         /* Get a time-ordered list of markers from the last time anything changed */
 224         std::list<Marker*>& sorted = _sorted_marker_lists[m->get_parent()];
 225
 226         list<Marker*>::iterator i = find (sorted.begin(), sorted.end(), m);
 227
 228         list<Marker*>::iterator prev = sorted.end ();
 229         list<Marker*>::iterator next = i;
 230         ++next;
 231
 232         /* Look to see if the previous marker is still behind `m' in time */
 233         if (i != sorted.begin()) {
 234
 235                 prev = i;
 236                 --prev;
 237
 238                 if ((*prev)->position() > m->position()) {
 239                         /* This marker is no longer in the correct order with the previous one, so
 240                          * update all the markers in this group.
 241                          */
 242                         update_marker_labels (m->get_parent ());
 243                         return;
 244                 }
 245         }
 246
 247         /* Look to see if the next marker is still ahead of `m' in time */
 248         if (next != sorted.end() && (*next)->position() < m->position()) {
 249                 /* This marker is no longer in the correct order with the next one, so
 250                  * update all the markers in this group.
 251                  */
 252                 update_marker_labels (m->get_parent ());
 253                 return;
 254         }
 255
 256         if (prev != sorted.end()) {
 257
 258                 /* Update just the available space between the previous marker and this one */
 259
 260                 double const p = frame_to_pixel (m->position() - (*prev)->position());
 261
 262                 if (m->label_on_left()) {
 263                         (*prev)->set_right_label_limit (p / 2);
 264                 } else {
 265                         (*prev)->set_right_label_limit (p);
 266                 }
 267
 268                 if ((*prev)->label_on_left ()) {
 269                         m->set_left_label_limit (p);
 270                 } else {
 271                         m->set_left_label_limit (p / 2);
 272                 }
 273         }
 274
 275         if (next != sorted.end()) {
 276
 277                 /* Update just the available space between this marker and the next */
 278
 279                 double const p = frame_to_pixel ((*next)->position() - m->position());
 280
 281                 if ((*next)->label_on_left()) {
 282                         m->set_right_label_limit (p / 2);
 283                 } else {
 284                         m->set_right_label_limit (p);
 285                 }
 286
 287                 if (m->label_on_left()) {
 288                         (*next)->set_left_label_limit (p);
 289                 } else {
 290                         (*next)->set_left_label_limit (p / 2);
 291                 }
 292         }
 293 }
 294
 295 struct MarkerComparator {
 296         bool operator() (Marker const * a, Marker const * b) {
 297                 return a->position() < b->position();
 298         }
 299 };
 300
 301 /** Update all marker labels in all groups */
 302 void
 303 Editor::update_marker_labels ()
 304 {
 305         for (std::map<ArdourCanvas::Group *, std::list<Marker *> >::iterator i = _sorted_marker_lists.begin(); i != _sorted_marker_lists.end(); ++i) {
 306                 update_marker_labels (i->first);
 307         }
 308 }
 309
 310 /** Look at all markers in a group and update label widths */
 311 void
 312 Editor::update_marker_labels (ArdourCanvas::Group* group)
 313 {
 314         list<Marker*>& sorted = _sorted_marker_lists[group];
 315
 316         if (sorted.empty()) {
 317                 return;
 318         }
 319
 320         /* We sort the list of markers and then set up the space available between each one */
 321
 322         sorted.sort (MarkerComparator ());
 323
 324         list<Marker*>::iterator i = sorted.begin ();
 325
 326         list<Marker*>::iterator prev = sorted.end ();
 327         list<Marker*>::iterator next = i;
 328         ++next;
 329
 330         while (i != sorted.end()) {
 331
 332                 if (prev != sorted.end()) {
 333                         double const p = frame_to_pixel ((*i)->position() - (*prev)->position());
 334
 335                         if ((*prev)->label_on_left()) {
 336                                 (*i)->set_left_label_limit (p);
 337                         } else {
 338                                 (*i)->set_left_label_limit (p / 2);
 339                         }
 340
 341                 }
 342
 343                 if (next != sorted.end()) {
 344                         double const p = frame_to_pixel ((*next)->position() - (*i)->position());
 345
 346                         if ((*next)->label_on_left()) {
 347                                 (*i)->set_right_label_limit (p / 2);
 348                         } else {
 349                                 (*i)->set_right_label_limit (p);
 350                         }
 351                 }
 352
 353                 prev = i;
 354                 ++i;
 355                 ++next;
 356         }
 357 }
 358
 359 void
 360 Editor::location_flags_changed (Location *location, void*)
 361 {
 362         ENSURE_GUI_THREAD (*this, &Editor::location_flags_changed, location, src)
 363
 364         LocationMarkers *lam = find_location_markers (location);
 365
 366         if (lam == 0) {
 367                 /* a location that isn't "marked" with markers */
 368                 return;
 369         }
 370
 371         // move cd markers to/from cd marker bar as appropriate
 372         ensure_cd_marker_updated (lam, location);
 373
 374         if (location->is_cd_marker()) {
 375                 lam->set_color_rgba (location_cd_marker_color);
 376         } else if (location->is_mark()) {
 377                 lam->set_color_rgba (location_marker_color);
 378         } else if (location->is_auto_punch()) {
 379                 lam->set_color_rgba (location_punch_color);
 380         } else if (location->is_auto_loop()) {
 381                 lam->set_color_rgba (location_loop_color);
 382         } else {
 383                 lam->set_color_rgba (location_range_color);
 384         }
 385
 386         if (location->is_hidden()) {
 387                 lam->hide();
 388         } else {
 389                 lam->show ();
 390         }
 391 }
 392
 393 void Editor::update_cd_marker_display ()
 394 {
 395         for (LocationMarkerMap::iterator i = location_markers.begin(); i != location_markers.end(); ++i) {
 396                 LocationMarkers * lam = i->second;
 397                 Location * location = i->first;
 398
 399                 ensure_cd_marker_updated (lam, location);
 400         }
 401 }
 402
 403 void Editor::ensure_cd_marker_updated (LocationMarkers * lam, Location * location)
 404 {
 405         if (location->is_cd_marker()
 406             && (ruler_cd_marker_action->get_active() &&  lam->start->get_parent() != cd_marker_group))
 407         {
 408                 //cerr << "reparenting non-cd marker so it can be relocated: " << location->name() << endl;
 409                 if (lam->start) {
 410                         lam->start->reparent (*cd_marker_group);
 411                 }
 412                 if (lam->end) {
 413                         lam->end->reparent (*cd_marker_group);
 414                 }
 415         }
 416         else if ( (!location->is_cd_marker() || !ruler_cd_marker_action->get_active())
 417                   && (lam->start->get_parent() == cd_marker_group))
 418         {
 419                 //cerr << "reparenting non-cd marker so it can be relocated: " << location->name() << endl;
 420                 if (location->is_mark()) {
 421                         if (lam->start) {
 422                                 lam->start->reparent (*marker_group);
 423                         }
 424                         if (lam->end) {
 425                                 lam->end->reparent (*marker_group);
 426                         }
 427                 }
 428                 else {
 429                         if (lam->start) {
 430                                 lam->start->reparent (*range_marker_group);
 431                         }
 432                         if (lam->end) {
 433                                 lam->end->reparent (*range_marker_group);
 434                         }
 435                 }
 436         }
 437 }
 438
 439 Editor::LocationMarkers::~LocationMarkers ()
 440 {
 441         delete start;
 442         delete end;
 443 }
 444
 445 Editor::LocationMarkers *
 446 Editor::find_location_markers (Location *location) const
 447 {
 448         LocationMarkerMap::const_iterator i;
 449
 450         for (i = location_markers.begin(); i != location_markers.end(); ++i) {
 451                 if ((*i).first == location) {
 452                         return (*i).second;
 453                 }
 454         }
 455
 456         return 0;
 457 }
 458
 459 Location *
 460 Editor::find_location_from_marker (Marker *marker, bool& is_start) const
 461 {
 462         LocationMarkerMap::const_iterator i;
 463
 464         for (i = location_markers.begin(); i != location_markers.end(); ++i) {
 465                 LocationMarkers *lm = (*i).second;
 466                 if (lm->start == marker) {
 467                         is_start = true;
 468                         return (*i).first;
 469                 } else if (lm->end == marker) {
 470                         is_start = false;
 471                         return (*i).first;
 472                 }
 473         }
 474
 475         return 0;
 476 }
 477
 478 void
 479 Editor::refresh_location_display_internal (Locations::LocationList& locations)
 480 {
 481         /* invalidate all */
 482
 483         for (LocationMarkerMap::iterator i = location_markers.begin(); i != location_markers.end(); ++i) {
 484                 i->second->valid = false;
 485         }
 486
 487         /* add new ones */
 488
 489         for (Locations::LocationList::iterator i = locations.begin(); i != locations.end(); ++i) {
 490
 491                 LocationMarkerMap::iterator x;
 492
 493                 if ((x = location_markers.find (*i)) != location_markers.end()) {
 494                         x->second->valid = true;
 495                         continue;
 496                 }
 497
 498                 add_new_location_internal (*i);
 499         }
 500
 501         /* remove dead ones */
 502
 503         for (LocationMarkerMap::iterator i = location_markers.begin(); i != location_markers.end(); ) {
 504
 505                 LocationMarkerMap::iterator tmp;
 506
 507                 tmp = i;
 508                 ++tmp;
 509
 510                 if (!i->second->valid) {
 511
 512                         remove_sorted_marker (i->second->start);
 513                         if (i->second->end) {
 514                                 remove_sorted_marker (i->second->end);
 515                         }
 516
 517                         LocationMarkers* m = i->second;
 518                         location_markers.erase (i);
 519                         delete m;
 520                 }
 521
 522                 i = tmp;
 523         }
 524
 525         update_punch_range_view (false);
 526         update_loop_range_view (false);
 527 }
 528
 529 void
 530 Editor::refresh_location_display ()
 531 {
 532         ENSURE_GUI_THREAD (*this, &Editor::refresh_location_display)
 533
 534         if (_session) {
 535                 _session->locations()->apply (*this, &Editor::refresh_location_display_internal);
 536         }
 537
 538         update_marker_labels ();
 539 }
 540
 541 void
 542 Editor::LocationMarkers::hide()
 543 {
 544         start->hide ();
 545         if (end) {
 546                 end->hide ();
 547         }
 548 }
 549
 550 void
 551 Editor::LocationMarkers::show()
 552 {
 553         start->show ();
 554         if (end) {
 555                 end->show ();
 556         }
 557 }
 558
 559 void
 560 Editor::LocationMarkers::canvas_height_set (double h)
 561 {
 562         start->canvas_height_set (h);
 563         if (end) {
 564                 end->canvas_height_set (h);
 565         }
 566 }
 567
 568 void
 569 Editor::LocationMarkers::set_name (const string& str)
 570 {
 571         /* XXX: hack: don't change names of session start/end markers */
 572
 573         if (start->type() != Marker::SessionStart) {
 574                 start->set_name (str);
 575         }
 576
 577         if (end && end->type() != Marker::SessionEnd) {
 578                 end->set_name (str);
 579         }
 580 }
 581
 582 void
 583 Editor::LocationMarkers::set_position (framepos_t startf,
 584                                        framepos_t endf)
 585 {
 586         start->set_position (startf);
 587         if (end) {
 588                 end->set_position (endf);
 589         }
 590 }
 591
 592 void
 593 Editor::LocationMarkers::set_color_rgba (uint32_t rgba)
 594 {
 595         start->set_color_rgba (rgba);
 596         if (end) {
 597                 end->set_color_rgba (rgba);
 598         }
 599 }
 600
 601 void
 602 Editor::LocationMarkers::set_show_lines (bool s)
 603 {
 604         start->set_show_line (s);
 605         if (end) {
 606                 end->set_show_line (s);
 607         }
 608 }
 609
 610 void
 611 Editor::LocationMarkers::set_selected (bool s)
 612 {
 613         start->set_selected (s);
 614         if (end) {
 615                 end->set_selected (s);
 616         }
 617 }
 618
 619 void
 620 Editor::LocationMarkers::setup_lines ()
 621 {
 622         start->setup_line ();
 623         if (end) {
 624                 end->setup_line ();
 625         }
 626 }
 627
 628 void
 629 Editor::mouse_add_new_marker (framepos_t where, bool is_cd, bool is_xrun)
 630 {
 631         string markername, markerprefix;
 632         int flags = (is_cd ? Location::IsCDMarker|Location::IsMark : Location::IsMark);
 633
 634         if (is_xrun) {
 635                 markerprefix = "xrun";
 636                 flags = Location::IsMark;
 637         } else {
 638                 markerprefix = "mark";
 639         }
 640
 641         if (_session) {
 642                 _session->locations()->next_available_name(markername, markerprefix);
 643                 if (!is_xrun && !choose_new_marker_name(markername)) {
 644                         return;
 645                 }
 646                 Location *location = new Location (*_session, where, where, markername, (Location::Flags) flags);
 647                 _session->begin_reversible_command (_("add marker"));
 648                 XMLNode &before = _session->locations()->get_state();
 649                 _session->locations()->add (location, true);
 650                 XMLNode &after = _session->locations()->get_state();
 651                 _session->add_command (new MementoCommand<Locations>(*(_session->locations()), &before, &after));
 652                 _session->commit_reversible_command ();
 653
 654                 /* find the marker we just added */
 655
 656                 LocationMarkers *lam = find_location_markers (location);
 657                 if (lam) {
 658                         /* make it the selected marker */
 659                         selection->set (lam->start);
 660                 }
 661         }
 662 }
 663
 664 void
 665 Editor::remove_marker (ArdourCanvas::Item& item, GdkEvent*)
 666 {
 667         Marker* marker;
 668         bool is_start;
 669
 670         if ((marker = static_cast<Marker*> (item.get_data ("marker"))) == 0) {
 671                 fatal << _("programming error: marker canvas item has no marker object pointer!") << endmsg;
 672                 /*NOTREACHED*/
 673         }
 674
 675         if (entered_marker == marker) {
 676                 entered_marker = NULL;
 677         }
 678
 679         Location* loc = find_location_from_marker (marker, is_start);
 680
 681         if (_session && loc) {
 682                 Glib::signal_idle().connect (sigc::bind (sigc::mem_fun(*this, &Editor::really_remove_marker), loc));
 683         }
 684 }
 685
 686 gint
 687 Editor::really_remove_marker (Location* loc)
 688 {
 689         _session->begin_reversible_command (_("remove marker"));
 690         XMLNode &before = _session->locations()->get_state();
 691         _session->locations()->remove (loc);
 692         XMLNode &after = _session->locations()->get_state();
 693         _session->add_command (new MementoCommand<Locations>(*(_session->locations()), &before, &after));
 694         _session->commit_reversible_command ();
 695         return FALSE;
 696 }
 697
 698 void
 699 Editor::location_gone (Location *location)
 700 {
 701         ENSURE_GUI_THREAD (*this, &Editor::location_gone, location)
 702
 703         LocationMarkerMap::iterator i;
 704
 705         if (location == transport_loop_location()) {
 706                 update_loop_range_view (true);
 707         }
 708
 709         if (location == transport_punch_location()) {
 710                 update_punch_range_view (true);
 711         }
 712
 713         for (i = location_markers.begin(); i != location_markers.end(); ++i) {
 714                 if (i->first == location) {
 715
 716                         remove_sorted_marker (i->second->start);
 717                         if (i->second->end) {
 718                                 remove_sorted_marker (i->second->end);
 719                         }
 720
 721                         LocationMarkers* m = i->second;
 722                         location_markers.erase (i);
 723                         delete m;
 724                         break;
 725                 }
 726         }
 727 }
 728
 729 void
 730 Editor::tempo_or_meter_marker_context_menu (GdkEventButton* ev, ArdourCanvas::Item* item)
 731 {
 732         marker_menu_item = item;
 733
 734         MeterMarker* mm;
 735         TempoMarker* tm;
 736         dynamic_cast_marker_object (marker_menu_item->get_data ("marker"), &mm, &tm);
 737
 738         bool can_remove = false;
 739
 740         if (mm) {
 741                 can_remove = mm->meter().movable ();
 742         } else if (tm) {
 743                 can_remove = tm->tempo().movable ();
 744         } else {
 745                 return;
 746         }
 747
 748         delete tempo_or_meter_marker_menu;
 749         build_tempo_or_meter_marker_menu (can_remove);
 750         tempo_or_meter_marker_menu->popup (1, ev->time);
 751 }
 752
 753 void
 754 Editor::marker_context_menu (GdkEventButton* ev, ArdourCanvas::Item* item)
 755 {
 756         Marker * marker;
 757         if ((marker = reinterpret_cast<Marker *> (item->get_data("marker"))) == 0) {
 758                 fatal << _("programming error: marker canvas item has no marker object pointer!") << endmsg;
 759                 /*NOTREACHED*/
 760         }
 761
 762         bool is_start;
 763         Location * loc = find_location_from_marker (marker, is_start);
 764
 765         if (loc == transport_loop_location() || loc == transport_punch_location() || loc->is_session_range ()) {
 766
 767                 if (transport_marker_menu == 0) {
 768                         build_range_marker_menu (loc == transport_loop_location() || loc == transport_punch_location(), loc->is_session_range());
 769                 }
 770
 771                 marker_menu_item = item;
 772                 transport_marker_menu->popup (1, ev->time);
 773
 774         } else if (loc->is_mark()) {
 775
 776                         delete marker_menu;
 777                         build_marker_menu (loc);
 778
 779                 // GTK2FIX use action group sensitivity
 780 #ifdef GTK2FIX
 781                         if (children.size() >= 3) {
 782                                 MenuItem * loopitem = &children[2];
 783                                 if (loopitem) {
 784                                         if (loc->is_mark()) {
 785                                                 loopitem->set_sensitive(false);
 786                                         }
 787                                         else {
 788                                                 loopitem->set_sensitive(true);
 789                                         }
 790                                 }
 791                         }
 792 #endif
 793                         marker_menu_item = item;
 794                         marker_menu->popup (1, ev->time);
 795
 796         } else if (loc->is_range_marker()) {
 797                 if (range_marker_menu == 0) {
 798                         build_range_marker_menu (false, false);
 799                 }
 800                 marker_menu_item = item;
 801                 range_marker_menu->popup (1, ev->time);
 802         }
 803 }
 804
 805 void
 806 Editor::new_transport_marker_context_menu (GdkEventButton* ev, ArdourCanvas::Item*)
 807 {
 808         if (new_transport_marker_menu == 0) {
 809                 build_new_transport_marker_menu ();
 810         }
 811
 812         new_transport_marker_menu->popup (1, ev->time);
 813
 814 }
 815
 816 void
 817 Editor::build_marker_menu (Location* loc)
 818 {
 819         using namespace Menu_Helpers;
 820
 821         marker_menu = new Menu;
 822         MenuList& items = marker_menu->items();
 823         marker_menu->set_name ("ArdourContextMenu");
 824
 825         items.push_back (MenuElem (_("Locate to Here"), sigc::mem_fun(*this, &Editor::marker_menu_set_playhead)));
 826         items.push_back (MenuElem (_("Play from Here"), sigc::mem_fun(*this, &Editor::marker_menu_play_from)));
 827         items.push_back (MenuElem (_("Move Mark to Playhead"), sigc::mem_fun(*this, &Editor::marker_menu_set_from_playhead)));
 828
 829         items.push_back (SeparatorElem());
 830
 831         items.push_back (MenuElem (_("Create Range to Next Marker"), sigc::mem_fun(*this, &Editor::marker_menu_range_to_next)));
 832
 833         items.push_back (MenuElem (_("Hide"), sigc::mem_fun(*this, &Editor::marker_menu_hide)));
 834         items.push_back (MenuElem (_("Rename..."), sigc::mem_fun(*this, &Editor::marker_menu_rename)));
 835
 836         items.push_back (CheckMenuElem (_("Lock")));
 837         CheckMenuItem* lock_item = static_cast<CheckMenuItem*> (&items.back());
 838         if (loc->locked ()) {
 839                 lock_item->set_active ();
 840         }
 841         lock_item->signal_activate().connect (sigc::mem_fun (*this, &Editor::toggle_marker_menu_lock));
 842
 843         items.push_back (CheckMenuElem (_("Glue to Bars and Beats")));
 844         CheckMenuItem* glue_item = static_cast<CheckMenuItem*> (&items.back());
 845         if (loc->position_lock_style() == MusicTime) {
 846                 glue_item->set_active ();
 847         }
 848         glue_item->signal_activate().connect (sigc::mem_fun (*this, &Editor::toggle_marker_menu_glue));
 849
 850         items.push_back (SeparatorElem());
 851
 852         items.push_back (MenuElem (_("Remove"), sigc::mem_fun(*this, &Editor::marker_menu_remove)));
 853 }
 854
 855 void
 856 Editor::build_range_marker_menu (bool loop_or_punch, bool session)
 857 {
 858         using namespace Menu_Helpers;
 859
 860         bool const loop_or_punch_or_session = loop_or_punch | session;
 861
 862         Menu *markerMenu = new Menu;
 863         if (loop_or_punch_or_session) {
 864                 transport_marker_menu = markerMenu;
 865         } else {
 866                 range_marker_menu = markerMenu;
 867         }
 868         MenuList& items = markerMenu->items();
 869         markerMenu->set_name ("ArdourContextMenu");
 870
 871         items.push_back (MenuElem (_("Play Range"), sigc::mem_fun(*this, &Editor::marker_menu_play_range)));
 872         items.push_back (MenuElem (_("Locate to Range Mark"), sigc::mem_fun(*this, &Editor::marker_menu_set_playhead)));
 873         items.push_back (MenuElem (_("Play from Range Mark"), sigc::mem_fun(*this, &Editor::marker_menu_play_from)));
 874         if (!loop_or_punch_or_session) {
 875                 items.push_back (MenuElem (_("Loop Range"), sigc::mem_fun(*this, &Editor::marker_menu_loop_range)));
 876         }
 877         items.push_back (MenuElem (_("Set Range Mark from Playhead"), sigc::mem_fun(*this, &Editor::marker_menu_set_from_playhead)));
 878         if (!Profile->get_sae()) {
 879                 items.push_back (MenuElem (_("Set Range from Range Selection"), sigc::mem_fun(*this, &Editor::marker_menu_set_from_selection)));
 880         }
 881
 882         items.push_back (SeparatorElem());
 883         items.push_back (MenuElem (_("Export Range..."), sigc::mem_fun(*this, &Editor::export_range)));
 884         items.push_back (SeparatorElem());
 885
 886         if (!loop_or_punch_or_session) {
 887                 items.push_back (MenuElem (_("Hide Range"), sigc::mem_fun(*this, &Editor::marker_menu_hide)));
 888                 items.push_back (MenuElem (_("Rename Range..."), sigc::mem_fun(*this, &Editor::marker_menu_rename)));
 889         }
 890
 891         if (!session) {
 892                 items.push_back (MenuElem (_("Remove Range"), sigc::mem_fun(*this, &Editor::marker_menu_remove)));
 893         }
 894
 895         if (loop_or_punch_or_session) {
 896                 items.push_back (SeparatorElem());
 897         }
 898
 899         items.push_back (MenuElem (_("Separate Regions in Range"), sigc::mem_fun(*this, &Editor::marker_menu_separate_regions_using_location)));
 900         items.push_back (MenuElem (_("Select All in Range"), sigc::mem_fun(*this, &Editor::marker_menu_select_all_selectables_using_range)));
 901         if (!Profile->get_sae()) {
 902                 items.push_back (MenuElem (_("Select Range"), sigc::mem_fun(*this, &Editor::marker_menu_select_using_range)));
 903         }
 904 }
 905
 906 void
 907 Editor::build_tempo_or_meter_marker_menu (bool can_remove)
 908 {
 909         using namespace Menu_Helpers;
 910
 911         tempo_or_meter_marker_menu = new Menu;
 912         MenuList& items = tempo_or_meter_marker_menu->items();
 913         tempo_or_meter_marker_menu->set_name ("ArdourContextMenu");
 914
 915         items.push_back (MenuElem (_("Edit..."), sigc::mem_fun(*this, &Editor::marker_menu_edit)));
 916         items.push_back (MenuElem (_("Remove"), sigc::mem_fun(*this, &Editor::marker_menu_remove)));
 917
 918         items.back().set_sensitive (can_remove);
 919 }
 920
 921 void
 922 Editor::build_new_transport_marker_menu ()
 923 {
 924         using namespace Menu_Helpers;
 925
 926         new_transport_marker_menu = new Menu;
 927         MenuList& items = new_transport_marker_menu->items();
 928         new_transport_marker_menu->set_name ("ArdourContextMenu");
 929
 930         items.push_back (MenuElem (_("Set Loop Range"), sigc::mem_fun(*this, &Editor::new_transport_marker_menu_set_loop)));
 931         items.push_back (MenuElem (_("Set Punch Range"), sigc::mem_fun(*this, &Editor::new_transport_marker_menu_set_punch)));
 932
 933         new_transport_marker_menu->signal_unmap().connect ( sigc::mem_fun(*this, &Editor::new_transport_marker_menu_popdown));
 934 }
 935
 936 void
 937 Editor::marker_menu_hide ()
 938 {
 939         Marker* marker;
 940
 941         if ((marker = reinterpret_cast<Marker *> (marker_menu_item->get_data ("marker"))) == 0) {
 942                 fatal << _("programming error: marker canvas item has no marker object pointer!") << endmsg;
 943                 /*NOTREACHED*/
 944         }
 945
 946         Location* l;
 947         bool is_start;
 948
 949         if ((l = find_location_from_marker (marker, is_start)) != 0) {
 950                 l->set_hidden (true, this);
 951         }
 952 }
 953
 954 void
 955 Editor::marker_menu_select_using_range ()
 956 {
 957         Marker* marker;
 958
 959         if ((marker = reinterpret_cast<Marker *> (marker_menu_item->get_data ("marker"))) == 0) {
 960                 fatal << _("programming error: marker canvas item has no marker object pointer!") << endmsg;
 961                 /*NOTREACHED*/
 962         }
 963
 964         Location* l;
 965         bool is_start;
 966
 967         if (((l = find_location_from_marker (marker, is_start)) != 0) && (l->end() > l->start())) {
 968                 set_selection_from_range (*l);
 969         }
 970 }
 971
 972 void
 973 Editor::marker_menu_select_all_selectables_using_range ()
 974 {
 975         Marker* marker;
 976
 977         if ((marker = reinterpret_cast<Marker *> (marker_menu_item->get_data ("marker"))) == 0) {
 978                 fatal << _("programming error: marker canvas item has no marker object pointer!") << endmsg;
 979                 /*NOTREACHED*/
 980         }
 981
 982         Location* l;
 983         bool is_start;
 984
 985         if (((l = find_location_from_marker (marker, is_start)) != 0) && (l->end() > l->start())) {
 986                 select_all_within (l->start(), l->end() - 1, 0,  DBL_MAX, track_views, Selection::Set, false);
 987         }
 988
 989 }
 990
 991 void
 992 Editor::marker_menu_separate_regions_using_location ()
 993 {
 994         Marker* marker;
 995
 996         if ((marker = reinterpret_cast<Marker *> (marker_menu_item->get_data ("marker"))) == 0) {
 997                 fatal << _("programming error: marker canvas item has no marker object pointer!") << endmsg;
 998                 /*NOTREACHED*/
 999         }
1000
1001         Location* l;
1002         bool is_start;
1003
1004         if (((l = find_location_from_marker (marker, is_start)) != 0) && (l->end() > l->start())) {
1005                 separate_regions_using_location (*l);
1006         }
1007
1008 }
1009
1010 void
1011 Editor::marker_menu_play_from ()
1012 {
1013         Marker* marker;
1014
1015         if ((marker = reinterpret_cast<Marker *> (marker_menu_item->get_data ("marker"))) == 0) {
1016                 fatal << _("programming error: marker canvas item has no marker object pointer!") << endmsg;
1017                 /*NOTREACHED*/
1018         }
1019
1020         Location* l;
1021         bool is_start;
1022
1023         if ((l = find_location_from_marker (marker, is_start)) != 0) {
1024
1025                 if (l->is_mark()) {
1026                         _session->request_locate (l->start(), true);
1027                 }
1028                 else {
1029                         //_session->request_bounded_roll (l->start(), l->end());
1030
1031                         if (is_start) {
1032                                 _session->request_locate (l->start(), true);
1033                         } else {
1034                                 _session->request_locate (l->end(), true);
1035                         }
1036                 }
1037         }
1038 }
1039
1040 void
1041 Editor::marker_menu_set_playhead ()
1042 {
1043         Marker* marker;
1044
1045         if ((marker = reinterpret_cast<Marker *> (marker_menu_item->get_data ("marker"))) == 0) {
1046                 fatal << _("programming error: marker canvas item has no marker object pointer!") << endmsg;
1047                 /*NOTREACHED*/
1048         }
1049
1050         Location* l;
1051         bool is_start;
1052
1053         if ((l = find_location_from_marker (marker, is_start)) != 0) {
1054
1055                 if (l->is_mark()) {
1056                         _session->request_locate (l->start(), false);
1057                 }
1058                 else {
1059                         if (is_start) {
1060                                 _session->request_locate (l->start(), false);
1061                         } else {
1062                                 _session->request_locate (l->end(), false);
1063                         }
1064                 }
1065         }
1066 }
1067
1068 void
1069 Editor::marker_menu_range_to_next ()
1070 {
1071         Marker* marker;
1072         if (!_session) {
1073                 return;
1074         }
1075
1076         if ((marker = reinterpret_cast<Marker *> (marker_menu_item->get_data ("marker"))) == 0) {
1077                 fatal << _("programming error: marker canvas item has no marker object pointer!") << endmsg;
1078                 /*NOTREACHED*/
1079         }
1080
1081         Location* l;
1082         bool is_start;
1083
1084         if ((l = find_location_from_marker (marker, is_start)) == 0) {
1085                 return;
1086         }
1087
1088         framepos_t start;
1089         framepos_t end;
1090         _session->locations()->marks_either_side (marker->position(), start, end);
1091
1092         if (end != max_framepos) {
1093                 string range_name = l->name();
1094                 range_name += "-range";
1095
1096                 Location* newrange = new Location (*_session, marker->position(), end, range_name, Location::IsRangeMarker);
1097                 _session->locations()->add (newrange);
1098         }
1099 }
1100
1101 void
1102 Editor::marker_menu_set_from_playhead ()
1103 {
1104         Marker* marker;
1105
1106         if ((marker = reinterpret_cast<Marker *> (marker_menu_item->get_data ("marker"))) == 0) {
1107                 fatal << _("programming error: marker canvas item has no marker object pointer!") << endmsg;
1108                 /*NOTREACHED*/
1109         }
1110
1111         Location* l;
1112         bool is_start;
1113
1114         if ((l = find_location_from_marker (marker, is_start)) != 0) {
1115
1116                 if (l->is_mark()) {
1117                         l->set_start (_session->audible_frame ());
1118                 }
1119                 else {
1120                         if (is_start) {
1121                                 l->set_start (_session->audible_frame ());
1122                         } else {
1123                                 l->set_end (_session->audible_frame ());
1124                         }
1125                 }
1126         }
1127 }
1128
1129 void
1130 Editor::marker_menu_set_from_selection ()
1131 {
1132         Marker* marker;
1133
1134         if ((marker = reinterpret_cast<Marker *> (marker_menu_item->get_data ("marker"))) == 0) {
1135                 fatal << _("programming error: marker canvas item has no marker object pointer!") << endmsg;
1136                 /*NOTREACHED*/
1137         }
1138
1139         Location* l;
1140         bool is_start;
1141
1142         if ((l = find_location_from_marker (marker, is_start)) != 0) {
1143
1144                 if (l->is_mark()) {
1145                         // nothing for now
1146                 }
1147                 else {
1148
1149                         /* if range selection use first to last */
1150
1151                         if (mouse_mode == Editing::MouseRange) {
1152                                 if (!selection->time.empty()) {
1153                                         l->set_start (selection->time.start());
1154                                         l->set_end (selection->time.end_frame());
1155                                 }
1156                         }
1157                         else {
1158                                 if (!selection->regions.empty()) {
1159                                         l->set_start (selection->regions.start());
1160                                         l->set_end (selection->regions.end_frame());
1161                                 }
1162                         }
1163                 }
1164         }
1165 }
1166
1167
1168 void
1169 Editor::marker_menu_play_range ()
1170 {
1171         Marker* marker;
1172
1173         if ((marker = reinterpret_cast<Marker *> (marker_menu_item->get_data ("marker"))) == 0) {
1174                 fatal << _("programming error: marker canvas item has no marker object pointer!") << endmsg;
1175                 /*NOTREACHED*/
1176         }
1177
1178         Location* l;
1179         bool is_start;
1180
1181         if ((l = find_location_from_marker (marker, is_start)) != 0) {
1182
1183                 if (l->is_mark()) {
1184                         _session->request_locate (l->start(), true);
1185                 }
1186                 else {
1187                         _session->request_bounded_roll (l->start(), l->end());
1188
1189                 }
1190         }
1191 }
1192
1193 void
1194 Editor::marker_menu_loop_range ()
1195 {
1196         Marker* marker;
1197
1198         if ((marker = reinterpret_cast<Marker *> (marker_menu_item->get_data ("marker"))) == 0) {
1199                 fatal << _("programming error: marker canvas item has no marker object pointer!") << endmsg;
1200                 /*NOTREACHED*/
1201         }
1202
1203         Location* l;
1204         bool is_start;
1205
1206         if ((l = find_location_from_marker (marker, is_start)) != 0) {
1207                 Location* l2;
1208                 if ((l2 = transport_loop_location()) != 0) {
1209                         l2->set (l->start(), l->end());
1210
1211                         // enable looping, reposition and start rolling
1212                         _session->request_play_loop(true);
1213                         _session->request_locate (l2->start(), true);
1214                 }
1215         }
1216 }
1217
1218 void
1219 Editor::dynamic_cast_marker_object (void* p, MeterMarker** m, TempoMarker** t) const
1220 {
1221         Marker* marker = reinterpret_cast<Marker*> (p);
1222         if (!marker) {
1223                 fatal << _("programming error: marker canvas item has no marker object pointer!") << endmsg;
1224                 /*NOTREACHED*/
1225         }
1226
1227         *m = dynamic_cast<MeterMarker*> (marker);
1228         *t = dynamic_cast<TempoMarker*> (marker);
1229 }
1230
1231 void
1232 Editor::marker_menu_edit ()
1233 {
1234         MeterMarker* mm;
1235         TempoMarker* tm;
1236         dynamic_cast_marker_object (marker_menu_item->get_data ("marker"), &mm, &tm);
1237
1238         if (mm) {
1239                 edit_meter_section (&mm->meter());
1240         } else if (tm) {
1241                 edit_tempo_section (&tm->tempo());
1242         }
1243 }
1244
1245 void
1246 Editor::marker_menu_remove ()
1247 {
1248         MeterMarker* mm;
1249         TempoMarker* tm;
1250         dynamic_cast_marker_object (marker_menu_item->get_data ("marker"), &mm, &tm);
1251
1252         if (mm) {
1253                 remove_meter_marker (marker_menu_item);
1254         } else if (tm) {
1255                 remove_tempo_marker (marker_menu_item);
1256         } else {
1257                 remove_marker (*marker_menu_item, (GdkEvent*) 0);
1258         }
1259 }
1260
1261 void
1262 Editor::toggle_marker_menu_lock ()
1263 {
1264         Marker* marker;
1265
1266         if ((marker = reinterpret_cast<Marker *> (marker_menu_item->get_data ("marker"))) == 0) {
1267                 fatal << _("programming error: marker canvas item has no marker object pointer!") << endmsg;
1268                 /*NOTREACHED*/
1269         }
1270
1271         Location* loc;
1272         bool ignored;
1273
1274         loc = find_location_from_marker (marker, ignored);
1275
1276         if (!loc) {
1277                 return;
1278         }
1279
1280         if (loc->locked()) {
1281                 loc->unlock ();
1282         } else {
1283                 loc->lock ();
1284         }
1285 }
1286
1287 void
1288 Editor::marker_menu_rename ()
1289 {
1290         Marker* marker;
1291
1292         if ((marker = reinterpret_cast<Marker *> (marker_menu_item->get_data ("marker"))) == 0) {
1293                 fatal << _("programming error: marker canvas item has no marker object pointer!") << endmsg;
1294                 /*NOTREACHED*/
1295         }
1296
1297         Location* loc;
1298         bool is_start;
1299
1300         loc = find_location_from_marker (marker, is_start);
1301
1302         if (!loc) return;
1303
1304         ArdourPrompter dialog (true);
1305         string txt;
1306
1307         dialog.set_prompt (_("New Name:"));
1308
1309         if (loc->is_mark()) {
1310                 dialog.set_title (_("Rename Mark"));
1311         } else {
1312                 dialog.set_title (_("Rename Range"));
1313         }
1314
1315         dialog.set_name ("MarkRenameWindow");
1316         dialog.set_size_request (250, -1);
1317         dialog.set_position (Gtk::WIN_POS_MOUSE);
1318
1319         dialog.add_button (_("Rename"), RESPONSE_ACCEPT);
1320         dialog.set_response_sensitive (Gtk::RESPONSE_ACCEPT, false);
1321         dialog.set_initial_text (loc->name());
1322
1323         dialog.show ();
1324
1325         switch (dialog.run ()) {
1326         case RESPONSE_ACCEPT:
1327                 break;
1328         default:
1329                 return;
1330         }
1331
1332         begin_reversible_command ( _("rename marker") );
1333         XMLNode &before = _session->locations()->get_state();
1334
1335         dialog.get_result(txt);
1336         loc->set_name (txt);
1337
1338         XMLNode &after = _session->locations()->get_state();
1339         _session->add_command (new MementoCommand<Locations>(*(_session->locations()), &before, &after));
1340         commit_reversible_command ();
1341 }
1342
1343 void
1344 Editor::new_transport_marker_menu_popdown ()
1345 {
1346         // hide rects
1347         transport_bar_drag_rect->hide();
1348
1349         _drags->abort ();
1350 }
1351
1352 void
1353 Editor::new_transport_marker_menu_set_loop ()
1354 {
1355         set_loop_range (temp_location->start(), temp_location->end(), _("set loop range"));
1356 }
1357
1358 void
1359 Editor::new_transport_marker_menu_set_punch ()
1360 {
1361         set_punch_range (temp_location->start(), temp_location->end(), _("set punch range"));
1362 }
1363
1364 void
1365 Editor::update_loop_range_view (bool visibility)
1366 {
1367         if (_session == 0) {
1368                 return;
1369         }
1370
1371         Location* tll;
1372
1373         if (_session->get_play_loop() && ((tll = transport_loop_location()) != 0)) {
1374
1375                 double x1 = frame_to_pixel (tll->start());
1376                 double x2 = frame_to_pixel (tll->end());
1377
1378                 transport_loop_range_rect->property_x1() = x1;
1379                 transport_loop_range_rect->property_x2() = x2;
1380
1381                 if (visibility) {
1382                         transport_loop_range_rect->show();
1383                 }
1384
1385         } else if (visibility) {
1386                 transport_loop_range_rect->hide();
1387         }
1388 }
1389
1390 void
1391 Editor::update_punch_range_view (bool visibility)
1392 {
1393         if (_session == 0) {
1394                 return;
1395         }
1396
1397         Location* tpl;
1398
1399         if ((_session->config.get_punch_in() || _session->config.get_punch_out()) && ((tpl = transport_punch_location()) != 0)) {
1400                 guint track_canvas_width,track_canvas_height;
1401                 track_canvas->get_size(track_canvas_width,track_canvas_height);
1402                 if (_session->config.get_punch_in()) {
1403                         transport_punch_range_rect->property_x1() = frame_to_pixel (tpl->start());
1404                         transport_punch_range_rect->property_x2() = (_session->config.get_punch_out() ? frame_to_pixel (tpl->end()) : frame_to_pixel (JACK_MAX_FRAMES));
1405                 } else {
1406                         transport_punch_range_rect->property_x1() = 0;
1407                         transport_punch_range_rect->property_x2() = (_session->config.get_punch_out() ? frame_to_pixel (tpl->end()) : track_canvas_width);
1408                 }
1409
1410                 if (visibility) {
1411                         transport_punch_range_rect->show();
1412                 }
1413         } else if (visibility) {
1414                 transport_punch_range_rect->hide();
1415         }
1416 }
1417
1418 void
1419 Editor::marker_selection_changed ()
1420 {
1421         if (_session && _session->deletion_in_progress()) {
1422                 return;
1423         }
1424
1425         for (LocationMarkerMap::iterator i = location_markers.begin(); i != location_markers.end(); ++i) {
1426                 i->second->set_selected (false);
1427         }
1428
1429         for (MarkerSelection::iterator x = selection->markers.begin(); x != selection->markers.end(); ++x) {
1430                 (*x)->set_selected (true);
1431         }
1432 }
1433
1434 struct SortLocationsByPosition {
1435     bool operator() (Location* a, Location* b) {
1436             return a->start() < b->start();
1437     }
1438 };
1439
1440 void
1441 Editor::goto_nth_marker (int n)
1442 {
1443         if (!_session) {
1444                 return;
1445         }
1446         const Locations::LocationList& l (_session->locations()->list());
1447         Locations::LocationList ordered;
1448         ordered = l;
1449
1450         SortLocationsByPosition cmp;
1451         ordered.sort (cmp);
1452
1453         for (Locations::LocationList::iterator i = ordered.begin(); n >= 0 && i != ordered.end(); ++i) {
1454                 if ((*i)->is_mark() && !(*i)->is_hidden() && !(*i)->is_session_range()) {
1455                         if (n == 0) {
1456                                 _session->request_locate ((*i)->start(), _session->transport_rolling());
1457                                 break;
1458                         }
1459                         --n;
1460                 }
1461         }
1462 }
1463
1464 void
1465 Editor::toggle_marker_menu_glue ()
1466 {
1467         Marker* marker;
1468
1469         if ((marker = reinterpret_cast<Marker *> (marker_menu_item->get_data ("marker"))) == 0) {
1470                 fatal << _("programming error: marker canvas item has no marker object pointer!") << endmsg;
1471                 /*NOTREACHED*/
1472         }
1473
1474         Location* loc;
1475         bool ignored;
1476
1477         loc = find_location_from_marker (marker, ignored);
1478
1479         if (!loc) {
1480                 return;
1481         }
1482
1483         if (loc->position_lock_style() == MusicTime) {
1484                 loc->set_position_lock_style (AudioTime);
1485         } else {
1486                 loc->set_position_lock_style (MusicTime);
1487         }
1488
1489 }
1490
1491 void
1492 Editor::toggle_marker_lines ()
1493 {
1494         _show_marker_lines = !_show_marker_lines;
1495
1496         for (LocationMarkerMap::iterator i = location_markers.begin(); i != location_markers.end(); ++i) {
1497                 i->second->set_show_lines (_show_marker_lines);
1498         }
1499 }
1500
1501 void
1502 Editor::remove_sorted_marker (Marker* m)
1503 {
1504         for (std::map<ArdourCanvas::Group *, std::list<Marker *> >::iterator i = _sorted_marker_lists.begin(); i != _sorted_marker_lists.end(); ++i) {
1505                 i->second.remove (m);
1506         }
1507 }
1508
1509 Marker *
1510 Editor::find_marker_from_location_id (PBD::ID const & id, bool is_start) const
1511 {
1512         for (LocationMarkerMap::const_iterator i = location_markers.begin(); i != location_markers.end(); ++i) {
1513                 if (i->first->id() == id) {
1514                         return is_start ? i->second->start : i->second->end;
1515                 }
1516         }
1517
1518         return 0;
1519 }