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 (true);
 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);
 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::transport_marker_context_menu (GdkEventButton* ev, ArdourCanvas::Item*)
 818 {
 819         if (transport_marker_menu == 0) {
 820                 build_range_marker_menu (true);
 821         }
 822
 823         transport_marker_menu->popup (1, ev->time);
 824 }
 825
 826 void
 827 Editor::build_marker_menu (Location* loc)
 828 {
 829         using namespace Menu_Helpers;
 830
 831         marker_menu = new Menu;
 832         MenuList& items = marker_menu->items();
 833         marker_menu->set_name ("ArdourContextMenu");
 834
 835         items.push_back (MenuElem (_("Locate to Here"), sigc::mem_fun(*this, &Editor::marker_menu_set_playhead)));
 836         items.push_back (MenuElem (_("Play from Here"), sigc::mem_fun(*this, &Editor::marker_menu_play_from)));
 837         items.push_back (MenuElem (_("Move Mark to Playhead"), sigc::mem_fun(*this, &Editor::marker_menu_set_from_playhead)));
 838
 839         items.push_back (SeparatorElem());
 840
 841         items.push_back (MenuElem (_("Create Range to Next Marker"), sigc::mem_fun(*this, &Editor::marker_menu_range_to_next)));
 842
 843         items.push_back (MenuElem (_("Hide"), sigc::mem_fun(*this, &Editor::marker_menu_hide)));
 844         items.push_back (MenuElem (_("Rename"), sigc::mem_fun(*this, &Editor::marker_menu_rename)));
 845
 846         items.push_back (CheckMenuElem (_("Lock")));
 847         CheckMenuItem* lock_item = static_cast<CheckMenuItem*> (&items.back());
 848         if (loc->locked ()) {
 849                 lock_item->set_active ();
 850         }
 851         lock_item->signal_activate().connect (sigc::mem_fun (*this, &Editor::toggle_marker_menu_lock));
 852
 853         items.push_back (CheckMenuElem (_("Glue to Bars and Beats")));
 854         CheckMenuItem* glue_item = static_cast<CheckMenuItem*> (&items.back());
 855         if (loc->position_lock_style() == MusicTime) {
 856                 glue_item->set_active ();
 857         }
 858         glue_item->signal_activate().connect (sigc::mem_fun (*this, &Editor::toggle_marker_menu_glue));
 859
 860         items.push_back (SeparatorElem());
 861
 862         items.push_back (MenuElem (_("Remove"), sigc::mem_fun(*this, &Editor::marker_menu_remove)));
 863 }
 864
 865 void
 866 Editor::build_range_marker_menu (bool loop_or_punch_or_session)
 867 {
 868         using namespace Menu_Helpers;
 869
 870         Menu *markerMenu = new Menu;
 871         if (loop_or_punch_or_session) {
 872                 transport_marker_menu = markerMenu;
 873         } else {
 874                 range_marker_menu = markerMenu;
 875         }
 876         MenuList& items = markerMenu->items();
 877         markerMenu->set_name ("ArdourContextMenu");
 878
 879         items.push_back (MenuElem (_("Play Range"), sigc::mem_fun(*this, &Editor::marker_menu_play_range)));
 880         items.push_back (MenuElem (_("Locate to Range Mark"), sigc::mem_fun(*this, &Editor::marker_menu_set_playhead)));
 881         items.push_back (MenuElem (_("Play from Range Mark"), sigc::mem_fun(*this, &Editor::marker_menu_play_from)));
 882         if (!loop_or_punch_or_session) {
 883                 items.push_back (MenuElem (_("Loop Range"), sigc::mem_fun(*this, &Editor::marker_menu_loop_range)));
 884         }
 885         items.push_back (MenuElem (_("Set Range Mark from Playhead"), sigc::mem_fun(*this, &Editor::marker_menu_set_from_playhead)));
 886         if (!Profile->get_sae()) {
 887                 items.push_back (MenuElem (_("Set Range from Range Selection"), sigc::mem_fun(*this, &Editor::marker_menu_set_from_selection)));
 888         }
 889
 890         items.push_back (SeparatorElem());
 891         items.push_back (MenuElem (_("Export Range"), sigc::mem_fun(*this, &Editor::export_range)));
 892         items.push_back (SeparatorElem());
 893
 894         if (!loop_or_punch_or_session) {
 895                 items.push_back (MenuElem (_("Hide Range"), sigc::mem_fun(*this, &Editor::marker_menu_hide)));
 896                 items.push_back (MenuElem (_("Rename Range"), sigc::mem_fun(*this, &Editor::marker_menu_rename)));
 897                 items.push_back (MenuElem (_("Remove Range"), sigc::mem_fun(*this, &Editor::marker_menu_remove)));
 898                 items.push_back (SeparatorElem());
 899         }
 900
 901         items.push_back (MenuElem (_("Separate Regions in Range"), sigc::mem_fun(*this, &Editor::marker_menu_separate_regions_using_location)));
 902         items.push_back (MenuElem (_("Select All in Range"), sigc::mem_fun(*this, &Editor::marker_menu_select_all_selectables_using_range)));
 903         if (!Profile->get_sae()) {
 904                 items.push_back (MenuElem (_("Select Range"), sigc::mem_fun(*this, &Editor::marker_menu_select_using_range)));
 905         }
 906 }
 907
 908 void
 909 Editor::build_tempo_or_meter_marker_menu (bool can_remove)
 910 {
 911         using namespace Menu_Helpers;
 912
 913         tempo_or_meter_marker_menu = new Menu;
 914         MenuList& items = tempo_or_meter_marker_menu->items();
 915         tempo_or_meter_marker_menu->set_name ("ArdourContextMenu");
 916
 917         items.push_back (MenuElem (_("Edit..."), sigc::mem_fun(*this, &Editor::marker_menu_edit)));
 918         items.push_back (MenuElem (_("Remove"), sigc::mem_fun(*this, &Editor::marker_menu_remove)));
 919
 920         items.back().set_sensitive (can_remove);
 921 }
 922
 923 void
 924 Editor::build_new_transport_marker_menu ()
 925 {
 926         using namespace Menu_Helpers;
 927
 928         new_transport_marker_menu = new Menu;
 929         MenuList& items = new_transport_marker_menu->items();
 930         new_transport_marker_menu->set_name ("ArdourContextMenu");
 931
 932         items.push_back (MenuElem (_("Set Loop Range"), sigc::mem_fun(*this, &Editor::new_transport_marker_menu_set_loop)));
 933         items.push_back (MenuElem (_("Set Punch Range"), sigc::mem_fun(*this, &Editor::new_transport_marker_menu_set_punch)));
 934
 935         new_transport_marker_menu->signal_unmap().connect ( sigc::mem_fun(*this, &Editor::new_transport_marker_menu_popdown));
 936 }
 937
 938 void
 939 Editor::marker_menu_hide ()
 940 {
 941         Marker* marker;
 942
 943         if ((marker = reinterpret_cast<Marker *> (marker_menu_item->get_data ("marker"))) == 0) {
 944                 fatal << _("programming error: marker canvas item has no marker object pointer!") << endmsg;
 945                 /*NOTREACHED*/
 946         }
 947
 948         Location* l;
 949         bool is_start;
 950
 951         if ((l = find_location_from_marker (marker, is_start)) != 0) {
 952                 l->set_hidden (true, this);
 953         }
 954 }
 955
 956 void
 957 Editor::marker_menu_select_using_range ()
 958 {
 959         Marker* marker;
 960
 961         if ((marker = reinterpret_cast<Marker *> (marker_menu_item->get_data ("marker"))) == 0) {
 962                 fatal << _("programming error: marker canvas item has no marker object pointer!") << endmsg;
 963                 /*NOTREACHED*/
 964         }
 965
 966         Location* l;
 967         bool is_start;
 968
 969         if (((l = find_location_from_marker (marker, is_start)) != 0) && (l->end() > l->start())) {
 970                 set_selection_from_range (*l);
 971         }
 972 }
 973
 974 void
 975 Editor::marker_menu_select_all_selectables_using_range ()
 976 {
 977         Marker* marker;
 978
 979         if ((marker = reinterpret_cast<Marker *> (marker_menu_item->get_data ("marker"))) == 0) {
 980                 fatal << _("programming error: marker canvas item has no marker object pointer!") << endmsg;
 981                 /*NOTREACHED*/
 982         }
 983
 984         Location* l;
 985         bool is_start;
 986
 987         if (((l = find_location_from_marker (marker, is_start)) != 0) && (l->end() > l->start())) {
 988                 select_all_within (l->start(), l->end() - 1, 0,  DBL_MAX, track_views, Selection::Set, false);
 989         }
 990
 991 }
 992
 993 void
 994 Editor::marker_menu_separate_regions_using_location ()
 995 {
 996         Marker* marker;
 997
 998         if ((marker = reinterpret_cast<Marker *> (marker_menu_item->get_data ("marker"))) == 0) {
 999                 fatal << _("programming error: marker canvas item has no marker object pointer!") << endmsg;
1000                 /*NOTREACHED*/
1001         }
1002
1003         Location* l;
1004         bool is_start;
1005
1006         if (((l = find_location_from_marker (marker, is_start)) != 0) && (l->end() > l->start())) {
1007                 separate_regions_using_location (*l);
1008         }
1009
1010 }
1011
1012 void
1013 Editor::marker_menu_play_from ()
1014 {
1015         Marker* marker;
1016
1017         if ((marker = reinterpret_cast<Marker *> (marker_menu_item->get_data ("marker"))) == 0) {
1018                 fatal << _("programming error: marker canvas item has no marker object pointer!") << endmsg;
1019                 /*NOTREACHED*/
1020         }
1021
1022         Location* l;
1023         bool is_start;
1024
1025         if ((l = find_location_from_marker (marker, is_start)) != 0) {
1026
1027                 if (l->is_mark()) {
1028                         _session->request_locate (l->start(), true);
1029                 }
1030                 else {
1031                         //_session->request_bounded_roll (l->start(), l->end());
1032
1033                         if (is_start) {
1034                                 _session->request_locate (l->start(), true);
1035                         } else {
1036                                 _session->request_locate (l->end(), true);
1037                         }
1038                 }
1039         }
1040 }
1041
1042 void
1043 Editor::marker_menu_set_playhead ()
1044 {
1045         Marker* marker;
1046
1047         if ((marker = reinterpret_cast<Marker *> (marker_menu_item->get_data ("marker"))) == 0) {
1048                 fatal << _("programming error: marker canvas item has no marker object pointer!") << endmsg;
1049                 /*NOTREACHED*/
1050         }
1051
1052         Location* l;
1053         bool is_start;
1054
1055         if ((l = find_location_from_marker (marker, is_start)) != 0) {
1056
1057                 if (l->is_mark()) {
1058                         _session->request_locate (l->start(), false);
1059                 }
1060                 else {
1061                         if (is_start) {
1062                                 _session->request_locate (l->start(), false);
1063                         } else {
1064                                 _session->request_locate (l->end(), false);
1065                         }
1066                 }
1067         }
1068 }
1069
1070 void
1071 Editor::marker_menu_range_to_next ()
1072 {
1073         Marker* marker;
1074         if (!_session) {
1075                 return;
1076         }
1077
1078         if ((marker = reinterpret_cast<Marker *> (marker_menu_item->get_data ("marker"))) == 0) {
1079                 fatal << _("programming error: marker canvas item has no marker object pointer!") << endmsg;
1080                 /*NOTREACHED*/
1081         }
1082
1083         Location* l;
1084         bool is_start;
1085
1086         if ((l = find_location_from_marker (marker, is_start)) == 0) {
1087                 return;
1088         }
1089
1090         framepos_t start;
1091         framepos_t end;
1092         _session->locations()->marks_either_side (marker->position(), start, end);
1093
1094         if (end != max_framepos) {
1095                 string range_name = l->name();
1096                 range_name += "-range";
1097
1098                 Location* newrange = new Location (*_session, marker->position(), end, range_name, Location::IsRangeMarker);
1099                 _session->locations()->add (newrange);
1100         }
1101 }
1102
1103 void
1104 Editor::marker_menu_set_from_playhead ()
1105 {
1106         Marker* marker;
1107
1108         if ((marker = reinterpret_cast<Marker *> (marker_menu_item->get_data ("marker"))) == 0) {
1109                 fatal << _("programming error: marker canvas item has no marker object pointer!") << endmsg;
1110                 /*NOTREACHED*/
1111         }
1112
1113         Location* l;
1114         bool is_start;
1115
1116         if ((l = find_location_from_marker (marker, is_start)) != 0) {
1117
1118                 if (l->is_mark()) {
1119                         l->set_start (_session->audible_frame ());
1120                 }
1121                 else {
1122                         if (is_start) {
1123                                 l->set_start (_session->audible_frame ());
1124                         } else {
1125                                 l->set_end (_session->audible_frame ());
1126                         }
1127                 }
1128         }
1129 }
1130
1131 void
1132 Editor::marker_menu_set_from_selection ()
1133 {
1134         Marker* marker;
1135
1136         if ((marker = reinterpret_cast<Marker *> (marker_menu_item->get_data ("marker"))) == 0) {
1137                 fatal << _("programming error: marker canvas item has no marker object pointer!") << endmsg;
1138                 /*NOTREACHED*/
1139         }
1140
1141         Location* l;
1142         bool is_start;
1143
1144         if ((l = find_location_from_marker (marker, is_start)) != 0) {
1145
1146                 if (l->is_mark()) {
1147                         // nothing for now
1148                 }
1149                 else {
1150
1151                         /* if range selection use first to last */
1152
1153                         if (mouse_mode == Editing::MouseRange) {
1154                                 if (!selection->time.empty()) {
1155                                         l->set_start (selection->time.start());
1156                                         l->set_end (selection->time.end_frame());
1157                                 }
1158                         }
1159                         else {
1160                                 if (!selection->regions.empty()) {
1161                                         l->set_start (selection->regions.start());
1162                                         l->set_end (selection->regions.end_frame());
1163                                 }
1164                         }
1165                 }
1166         }
1167 }
1168
1169
1170 void
1171 Editor::marker_menu_play_range ()
1172 {
1173         Marker* marker;
1174
1175         if ((marker = reinterpret_cast<Marker *> (marker_menu_item->get_data ("marker"))) == 0) {
1176                 fatal << _("programming error: marker canvas item has no marker object pointer!") << endmsg;
1177                 /*NOTREACHED*/
1178         }
1179
1180         Location* l;
1181         bool is_start;
1182
1183         if ((l = find_location_from_marker (marker, is_start)) != 0) {
1184
1185                 if (l->is_mark()) {
1186                         _session->request_locate (l->start(), true);
1187                 }
1188                 else {
1189                         _session->request_bounded_roll (l->start(), l->end());
1190
1191                 }
1192         }
1193 }
1194
1195 void
1196 Editor::marker_menu_loop_range ()
1197 {
1198         Marker* marker;
1199
1200         if ((marker = reinterpret_cast<Marker *> (marker_menu_item->get_data ("marker"))) == 0) {
1201                 fatal << _("programming error: marker canvas item has no marker object pointer!") << endmsg;
1202                 /*NOTREACHED*/
1203         }
1204
1205         Location* l;
1206         bool is_start;
1207
1208         if ((l = find_location_from_marker (marker, is_start)) != 0) {
1209                 Location* l2;
1210                 if ((l2 = transport_loop_location()) != 0) {
1211                         l2->set (l->start(), l->end());
1212
1213                         // enable looping, reposition and start rolling
1214                         _session->request_play_loop(true);
1215                         _session->request_locate (l2->start(), true);
1216                 }
1217         }
1218 }
1219
1220 void
1221 Editor::dynamic_cast_marker_object (void* p, MeterMarker** m, TempoMarker** t) const
1222 {
1223         Marker* marker = reinterpret_cast<Marker*> (p);
1224         if (!marker) {
1225                 fatal << _("programming error: marker canvas item has no marker object pointer!") << endmsg;
1226                 /*NOTREACHED*/
1227         }
1228
1229         *m = dynamic_cast<MeterMarker*> (marker);
1230         *t = dynamic_cast<TempoMarker*> (marker);
1231 }
1232
1233 void
1234 Editor::marker_menu_edit ()
1235 {
1236         MeterMarker* mm;
1237         TempoMarker* tm;
1238         dynamic_cast_marker_object (marker_menu_item->get_data ("marker"), &mm, &tm);
1239
1240         if (mm) {
1241                 edit_meter_section (&mm->meter());
1242         } else if (tm) {
1243                 edit_tempo_section (&tm->tempo());
1244         }
1245 }
1246
1247 void
1248 Editor::marker_menu_remove ()
1249 {
1250         MeterMarker* mm;
1251         TempoMarker* tm;
1252         dynamic_cast_marker_object (marker_menu_item->get_data ("marker"), &mm, &tm);
1253
1254         if (mm) {
1255                 remove_meter_marker (marker_menu_item);
1256         } else if (tm) {
1257                 remove_tempo_marker (marker_menu_item);
1258         } else {
1259                 remove_marker (*marker_menu_item, (GdkEvent*) 0);
1260         }
1261 }
1262
1263 void
1264 Editor::toggle_marker_menu_lock ()
1265 {
1266         Marker* marker;
1267
1268         if ((marker = reinterpret_cast<Marker *> (marker_menu_item->get_data ("marker"))) == 0) {
1269                 fatal << _("programming error: marker canvas item has no marker object pointer!") << endmsg;
1270                 /*NOTREACHED*/
1271         }
1272
1273         Location* loc;
1274         bool ignored;
1275
1276         loc = find_location_from_marker (marker, ignored);
1277
1278         if (!loc) {
1279                 return;
1280         }
1281
1282         if (loc->locked()) {
1283                 loc->unlock ();
1284         } else {
1285                 loc->lock ();
1286         }
1287 }
1288
1289 void
1290 Editor::marker_menu_rename ()
1291 {
1292         Marker* marker;
1293
1294         if ((marker = reinterpret_cast<Marker *> (marker_menu_item->get_data ("marker"))) == 0) {
1295                 fatal << _("programming error: marker canvas item has no marker object pointer!") << endmsg;
1296                 /*NOTREACHED*/
1297         }
1298
1299         Location* loc;
1300         bool is_start;
1301
1302         loc = find_location_from_marker (marker, is_start);
1303
1304         if (!loc) return;
1305
1306         ArdourPrompter dialog (true);
1307         string txt;
1308
1309         dialog.set_prompt (_("New Name:"));
1310
1311         if (loc->is_mark()) {
1312                 dialog.set_title (_("Rename Mark"));
1313         } else {
1314                 dialog.set_title (_("Rename Range"));
1315         }
1316
1317         dialog.set_name ("MarkRenameWindow");
1318         dialog.set_size_request (250, -1);
1319         dialog.set_position (Gtk::WIN_POS_MOUSE);
1320
1321         dialog.add_button (_("Rename"), RESPONSE_ACCEPT);
1322         dialog.set_response_sensitive (Gtk::RESPONSE_ACCEPT, false);
1323         dialog.set_initial_text (loc->name());
1324
1325         dialog.show ();
1326
1327         switch (dialog.run ()) {
1328         case RESPONSE_ACCEPT:
1329                 break;
1330         default:
1331                 return;
1332         }
1333
1334         begin_reversible_command ( _("rename marker") );
1335         XMLNode &before = _session->locations()->get_state();
1336
1337         dialog.get_result(txt);
1338         loc->set_name (txt);
1339
1340         XMLNode &after = _session->locations()->get_state();
1341         _session->add_command (new MementoCommand<Locations>(*(_session->locations()), &before, &after));
1342         commit_reversible_command ();
1343 }
1344
1345 void
1346 Editor::new_transport_marker_menu_popdown ()
1347 {
1348         // hide rects
1349         transport_bar_drag_rect->hide();
1350
1351         _drags->abort ();
1352 }
1353
1354 void
1355 Editor::new_transport_marker_menu_set_loop ()
1356 {
1357         set_loop_range (temp_location->start(), temp_location->end(), _("set loop range"));
1358 }
1359
1360 void
1361 Editor::new_transport_marker_menu_set_punch ()
1362 {
1363         set_punch_range (temp_location->start(), temp_location->end(), _("set punch range"));
1364 }
1365
1366 void
1367 Editor::update_loop_range_view (bool visibility)
1368 {
1369         if (_session == 0) {
1370                 return;
1371         }
1372
1373         Location* tll;
1374
1375         if (_session->get_play_loop() && ((tll = transport_loop_location()) != 0)) {
1376
1377                 double x1 = frame_to_pixel (tll->start());
1378                 double x2 = frame_to_pixel (tll->end());
1379
1380                 transport_loop_range_rect->property_x1() = x1;
1381                 transport_loop_range_rect->property_x2() = x2;
1382
1383                 if (visibility) {
1384                         transport_loop_range_rect->show();
1385                 }
1386
1387         } else if (visibility) {
1388                 transport_loop_range_rect->hide();
1389         }
1390 }
1391
1392 void
1393 Editor::update_punch_range_view (bool visibility)
1394 {
1395         if (_session == 0) {
1396                 return;
1397         }
1398
1399         Location* tpl;
1400
1401         if ((_session->config.get_punch_in() || _session->config.get_punch_out()) && ((tpl = transport_punch_location()) != 0)) {
1402                 guint track_canvas_width,track_canvas_height;
1403                 track_canvas->get_size(track_canvas_width,track_canvas_height);
1404                 if (_session->config.get_punch_in()) {
1405                         transport_punch_range_rect->property_x1() = frame_to_pixel (tpl->start());
1406                         transport_punch_range_rect->property_x2() = (_session->config.get_punch_out() ? frame_to_pixel (tpl->end()) : frame_to_pixel (JACK_MAX_FRAMES));
1407                 } else {
1408                         transport_punch_range_rect->property_x1() = 0;
1409                         transport_punch_range_rect->property_x2() = (_session->config.get_punch_out() ? frame_to_pixel (tpl->end()) : track_canvas_width);
1410                 }
1411
1412                 if (visibility) {
1413                         transport_punch_range_rect->show();
1414                 }
1415         } else if (visibility) {
1416                 transport_punch_range_rect->hide();
1417         }
1418 }
1419
1420 void
1421 Editor::marker_selection_changed ()
1422 {
1423         if (_session && _session->deletion_in_progress()) {
1424                 return;
1425         }
1426
1427         for (LocationMarkerMap::iterator i = location_markers.begin(); i != location_markers.end(); ++i) {
1428                 i->second->set_selected (false);
1429         }
1430
1431         for (MarkerSelection::iterator x = selection->markers.begin(); x != selection->markers.end(); ++x) {
1432                 (*x)->set_selected (true);
1433         }
1434 }
1435
1436 struct SortLocationsByPosition {
1437     bool operator() (Location* a, Location* b) {
1438             return a->start() < b->start();
1439     }
1440 };
1441
1442 void
1443 Editor::goto_nth_marker (int n)
1444 {
1445         if (!_session) {
1446                 return;
1447         }
1448         const Locations::LocationList& l (_session->locations()->list());
1449         Locations::LocationList ordered;
1450         ordered = l;
1451
1452         SortLocationsByPosition cmp;
1453         ordered.sort (cmp);
1454
1455         for (Locations::LocationList::iterator i = ordered.begin(); n >= 0 && i != ordered.end(); ++i) {
1456                 if ((*i)->is_mark() && !(*i)->is_hidden() && !(*i)->is_session_range()) {
1457                         if (n == 0) {
1458                                 _session->request_locate ((*i)->start(), _session->transport_rolling());
1459                                 break;
1460                         }
1461                         --n;
1462                 }
1463         }
1464 }
1465
1466 void
1467 Editor::toggle_marker_menu_glue ()
1468 {
1469         Marker* marker;
1470
1471         if ((marker = reinterpret_cast<Marker *> (marker_menu_item->get_data ("marker"))) == 0) {
1472                 fatal << _("programming error: marker canvas item has no marker object pointer!") << endmsg;
1473                 /*NOTREACHED*/
1474         }
1475
1476         Location* loc;
1477         bool ignored;
1478
1479         loc = find_location_from_marker (marker, ignored);
1480
1481         if (!loc) {
1482                 return;
1483         }
1484
1485         if (loc->position_lock_style() == MusicTime) {
1486                 loc->set_position_lock_style (AudioTime);
1487         } else {
1488                 loc->set_position_lock_style (MusicTime);
1489         }
1490
1491 }
1492
1493 void
1494 Editor::toggle_marker_lines ()
1495 {
1496         _show_marker_lines = !_show_marker_lines;
1497
1498         for (LocationMarkerMap::iterator i = location_markers.begin(); i != location_markers.end(); ++i) {
1499                 i->second->set_show_lines (_show_marker_lines);
1500         }
1501 }
1502
1503 void
1504 Editor::remove_sorted_marker (Marker* m)
1505 {
1506         for (std::map<ArdourCanvas::Group *, std::list<Marker *> >::iterator i = _sorted_marker_lists.begin(); i != _sorted_marker_lists.end(); ++i) {
1507                 i->second.remove (m);
1508         }
1509 }