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