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), boost::bind (&Editor::location_changed, this, _1), gui_context());
 158         location->end_changed.connect (*this, invalidator (*this), boost::bind (&Editor::location_changed, this, _1), gui_context());
 159         location->changed.connect (*this, invalidator (*this), boost::bind (&Editor::location_changed, this, _1), gui_context());
 160         location->name_changed.connect (*this, invalidator (*this), boost::bind (&Editor::location_changed, this, _1), gui_context());
 161         location->FlagsChanged.connect (*this, invalidator (*this), boost::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::mouse_add_new_range (framepos_t where)
 666 {
 667         if (!_session) {
 668                 return;
 669         }
 670
 671         /* Make this marker 1/8th of the visible area of the session so that
 672            it's reasonably easy to manipulate after creation.
 673         */
 674
 675         framepos_t const end = where + current_page_frames() / 8;
 676
 677         string name;
 678         _session->locations()->next_available_name (name, _("range"));
 679         Location* loc = new Location (*_session, where, end, name, Location::IsRangeMarker);
 680
 681         begin_reversible_command (_("new range marker"));
 682         XMLNode& before = _session->locations()->get_state ();
 683         _session->locations()->add (loc, true);
 684         XMLNode& after = _session->locations()->get_state ();
 685         _session->add_command (new MementoCommand<Locations> (*_session->locations(), &before, &after));
 686         commit_reversible_command ();
 687 }
 688
 689 void
 690 Editor::remove_marker (ArdourCanvas::Item& item, GdkEvent*)
 691 {
 692         Marker* marker;
 693         bool is_start;
 694
 695         if ((marker = static_cast<Marker*> (item.get_data ("marker"))) == 0) {
 696                 fatal << _("programming error: marker canvas item has no marker object pointer!") << endmsg;
 697                 /*NOTREACHED*/
 698         }
 699
 700         if (entered_marker == marker) {
 701                 entered_marker = NULL;
 702         }
 703
 704         Location* loc = find_location_from_marker (marker, is_start);
 705
 706         if (_session && loc) {
 707                 Glib::signal_idle().connect (sigc::bind (sigc::mem_fun(*this, &Editor::really_remove_marker), loc));
 708         }
 709 }
 710
 711 gint
 712 Editor::really_remove_marker (Location* loc)
 713 {
 714         _session->begin_reversible_command (_("remove marker"));
 715         XMLNode &before = _session->locations()->get_state();
 716         _session->locations()->remove (loc);
 717         XMLNode &after = _session->locations()->get_state();
 718         _session->add_command (new MementoCommand<Locations>(*(_session->locations()), &before, &after));
 719         _session->commit_reversible_command ();
 720         return FALSE;
 721 }
 722
 723 void
 724 Editor::location_gone (Location *location)
 725 {
 726         ENSURE_GUI_THREAD (*this, &Editor::location_gone, location)
 727
 728         LocationMarkerMap::iterator i;
 729
 730         if (location == transport_loop_location()) {
 731                 update_loop_range_view (true);
 732         }
 733
 734         if (location == transport_punch_location()) {
 735                 update_punch_range_view (true);
 736         }
 737
 738         for (i = location_markers.begin(); i != location_markers.end(); ++i) {
 739                 if (i->first == location) {
 740
 741                         remove_sorted_marker (i->second->start);
 742                         if (i->second->end) {
 743                                 remove_sorted_marker (i->second->end);
 744                         }
 745
 746                         LocationMarkers* m = i->second;
 747                         location_markers.erase (i);
 748                         delete m;
 749                         break;
 750                 }
 751         }
 752 }
 753
 754 void
 755 Editor::tempo_or_meter_marker_context_menu (GdkEventButton* ev, ArdourCanvas::Item* item)
 756 {
 757         marker_menu_item = item;
 758
 759         MeterMarker* mm;
 760         TempoMarker* tm;
 761         dynamic_cast_marker_object (marker_menu_item->get_data ("marker"), &mm, &tm);
 762
 763         bool can_remove = false;
 764
 765         if (mm) {
 766                 can_remove = mm->meter().movable ();
 767         } else if (tm) {
 768                 can_remove = tm->tempo().movable ();
 769         } else {
 770                 return;
 771         }
 772
 773         delete tempo_or_meter_marker_menu;
 774         build_tempo_or_meter_marker_menu (can_remove);
 775         tempo_or_meter_marker_menu->popup (1, ev->time);
 776 }
 777
 778 void
 779 Editor::marker_context_menu (GdkEventButton* ev, ArdourCanvas::Item* item)
 780 {
 781         Marker * marker;
 782         if ((marker = reinterpret_cast<Marker *> (item->get_data("marker"))) == 0) {
 783                 fatal << _("programming error: marker canvas item has no marker object pointer!") << endmsg;
 784                 /*NOTREACHED*/
 785         }
 786
 787         bool is_start;
 788         Location * loc = find_location_from_marker (marker, is_start);
 789
 790         if (loc == transport_loop_location() || loc == transport_punch_location() || loc->is_session_range ()) {
 791
 792                 if (transport_marker_menu == 0) {
 793                         build_range_marker_menu (loc == transport_loop_location() || loc == transport_punch_location(), loc->is_session_range());
 794                 }
 795
 796                 marker_menu_item = item;
 797                 transport_marker_menu->popup (1, ev->time);
 798
 799         } else if (loc->is_mark()) {
 800
 801                         delete marker_menu;
 802                         build_marker_menu (loc);
 803
 804                 // GTK2FIX use action group sensitivity
 805 #ifdef GTK2FIX
 806                         if (children.size() >= 3) {
 807                                 MenuItem * loopitem = &children[2];
 808                                 if (loopitem) {
 809                                         if (loc->is_mark()) {
 810                                                 loopitem->set_sensitive(false);
 811                                         }
 812                                         else {
 813                                                 loopitem->set_sensitive(true);
 814                                         }
 815                                 }
 816                         }
 817 #endif
 818                         marker_menu_item = item;
 819                         marker_menu->popup (1, ev->time);
 820
 821         } else if (loc->is_range_marker()) {
 822                 if (range_marker_menu == 0) {
 823                         build_range_marker_menu (false, false);
 824                 }
 825                 marker_menu_item = item;
 826                 range_marker_menu->popup (1, ev->time);
 827         }
 828 }
 829
 830 void
 831 Editor::new_transport_marker_context_menu (GdkEventButton* ev, ArdourCanvas::Item*)
 832 {
 833         if (new_transport_marker_menu == 0) {
 834                 build_new_transport_marker_menu ();
 835         }
 836
 837         new_transport_marker_menu->popup (1, ev->time);
 838
 839 }
 840
 841 void
 842 Editor::build_marker_menu (Location* loc)
 843 {
 844         using namespace Menu_Helpers;
 845
 846         marker_menu = new Menu;
 847         MenuList& items = marker_menu->items();
 848         marker_menu->set_name ("ArdourContextMenu");
 849
 850         items.push_back (MenuElem (_("Locate to Here"), sigc::mem_fun(*this, &Editor::marker_menu_set_playhead)));
 851         items.push_back (MenuElem (_("Play from Here"), sigc::mem_fun(*this, &Editor::marker_menu_play_from)));
 852         items.push_back (MenuElem (_("Move Mark to Playhead"), sigc::mem_fun(*this, &Editor::marker_menu_set_from_playhead)));
 853
 854         items.push_back (SeparatorElem());
 855
 856         items.push_back (MenuElem (_("Create Range to Next Marker"), sigc::mem_fun(*this, &Editor::marker_menu_range_to_next)));
 857
 858         items.push_back (MenuElem (_("Hide"), sigc::mem_fun(*this, &Editor::marker_menu_hide)));
 859         items.push_back (MenuElem (_("Rename..."), sigc::mem_fun(*this, &Editor::marker_menu_rename)));
 860
 861         items.push_back (CheckMenuElem (_("Lock")));
 862         CheckMenuItem* lock_item = static_cast<CheckMenuItem*> (&items.back());
 863         if (loc->locked ()) {
 864                 lock_item->set_active ();
 865         }
 866         lock_item->signal_activate().connect (sigc::mem_fun (*this, &Editor::toggle_marker_menu_lock));
 867
 868         items.push_back (CheckMenuElem (_("Glue to Bars and Beats")));
 869         CheckMenuItem* glue_item = static_cast<CheckMenuItem*> (&items.back());
 870         if (loc->position_lock_style() == MusicTime) {
 871                 glue_item->set_active ();
 872         }
 873         glue_item->signal_activate().connect (sigc::mem_fun (*this, &Editor::toggle_marker_menu_glue));
 874
 875         items.push_back (SeparatorElem());
 876
 877         items.push_back (MenuElem (_("Remove"), sigc::mem_fun(*this, &Editor::marker_menu_remove)));
 878 }
 879
 880 void
 881 Editor::build_range_marker_menu (bool loop_or_punch, bool session)
 882 {
 883         using namespace Menu_Helpers;
 884
 885         bool const loop_or_punch_or_session = loop_or_punch | session;
 886
 887         Menu *markerMenu = new Menu;
 888         if (loop_or_punch_or_session) {
 889                 transport_marker_menu = markerMenu;
 890         } else {
 891                 range_marker_menu = markerMenu;
 892         }
 893         MenuList& items = markerMenu->items();
 894         markerMenu->set_name ("ArdourContextMenu");
 895
 896         items.push_back (MenuElem (_("Play Range"), sigc::mem_fun(*this, &Editor::marker_menu_play_range)));
 897         items.push_back (MenuElem (_("Locate to Range Mark"), sigc::mem_fun(*this, &Editor::marker_menu_set_playhead)));
 898         items.push_back (MenuElem (_("Play from Range Mark"), sigc::mem_fun(*this, &Editor::marker_menu_play_from)));
 899         if (!loop_or_punch_or_session) {
 900                 items.push_back (MenuElem (_("Loop Range"), sigc::mem_fun(*this, &Editor::marker_menu_loop_range)));
 901         }
 902         items.push_back (MenuElem (_("Set Range Mark from Playhead"), sigc::mem_fun(*this, &Editor::marker_menu_set_from_playhead)));
 903         if (!Profile->get_sae()) {
 904                 items.push_back (MenuElem (_("Set Range from Range Selection"), sigc::mem_fun(*this, &Editor::marker_menu_set_from_selection)));
 905         }
 906
 907         items.push_back (MenuElem (_("Zoom to Range"), sigc::mem_fun (*this, &Editor::marker_menu_zoom_to_range)));
 908
 909         items.push_back (SeparatorElem());
 910         items.push_back (MenuElem (_("Export Range..."), sigc::mem_fun(*this, &Editor::export_range)));
 911         items.push_back (SeparatorElem());
 912
 913         if (!loop_or_punch_or_session) {
 914                 items.push_back (MenuElem (_("Hide Range"), sigc::mem_fun(*this, &Editor::marker_menu_hide)));
 915                 items.push_back (MenuElem (_("Rename Range..."), sigc::mem_fun(*this, &Editor::marker_menu_rename)));
 916         }
 917
 918         if (!session) {
 919                 items.push_back (MenuElem (_("Remove Range"), sigc::mem_fun(*this, &Editor::marker_menu_remove)));
 920         }
 921
 922         if (!loop_or_punch_or_session || !session) {
 923                 items.push_back (SeparatorElem());
 924         }
 925
 926         items.push_back (MenuElem (_("Separate Regions in Range"), sigc::mem_fun(*this, &Editor::marker_menu_separate_regions_using_location)));
 927         items.push_back (MenuElem (_("Select All in Range"), sigc::mem_fun(*this, &Editor::marker_menu_select_all_selectables_using_range)));
 928         if (!Profile->get_sae()) {
 929                 items.push_back (MenuElem (_("Select Range"), sigc::mem_fun(*this, &Editor::marker_menu_select_using_range)));
 930         }
 931 }
 932
 933 void
 934 Editor::build_tempo_or_meter_marker_menu (bool can_remove)
 935 {
 936         using namespace Menu_Helpers;
 937
 938         tempo_or_meter_marker_menu = new Menu;
 939         MenuList& items = tempo_or_meter_marker_menu->items();
 940         tempo_or_meter_marker_menu->set_name ("ArdourContextMenu");
 941
 942         items.push_back (MenuElem (_("Edit..."), sigc::mem_fun(*this, &Editor::marker_menu_edit)));
 943         items.push_back (MenuElem (_("Remove"), sigc::mem_fun(*this, &Editor::marker_menu_remove)));
 944
 945         items.back().set_sensitive (can_remove);
 946 }
 947
 948 void
 949 Editor::build_new_transport_marker_menu ()
 950 {
 951         using namespace Menu_Helpers;
 952
 953         new_transport_marker_menu = new Menu;
 954         MenuList& items = new_transport_marker_menu->items();
 955         new_transport_marker_menu->set_name ("ArdourContextMenu");
 956
 957         items.push_back (MenuElem (_("Set Loop Range"), sigc::mem_fun(*this, &Editor::new_transport_marker_menu_set_loop)));
 958         items.push_back (MenuElem (_("Set Punch Range"), sigc::mem_fun(*this, &Editor::new_transport_marker_menu_set_punch)));
 959
 960         new_transport_marker_menu->signal_unmap().connect ( sigc::mem_fun(*this, &Editor::new_transport_marker_menu_popdown));
 961 }
 962
 963 void
 964 Editor::marker_menu_hide ()
 965 {
 966         Marker* marker;
 967
 968         if ((marker = reinterpret_cast<Marker *> (marker_menu_item->get_data ("marker"))) == 0) {
 969                 fatal << _("programming error: marker canvas item has no marker object pointer!") << endmsg;
 970                 /*NOTREACHED*/
 971         }
 972
 973         Location* l;
 974         bool is_start;
 975
 976         if ((l = find_location_from_marker (marker, is_start)) != 0) {
 977                 l->set_hidden (true, this);
 978         }
 979 }
 980
 981 void
 982 Editor::marker_menu_select_using_range ()
 983 {
 984         Marker* marker;
 985
 986         if ((marker = reinterpret_cast<Marker *> (marker_menu_item->get_data ("marker"))) == 0) {
 987                 fatal << _("programming error: marker canvas item has no marker object pointer!") << endmsg;
 988                 /*NOTREACHED*/
 989         }
 990
 991         Location* l;
 992         bool is_start;
 993
 994         if (((l = find_location_from_marker (marker, is_start)) != 0) && (l->end() > l->start())) {
 995                 set_selection_from_range (*l);
 996         }
 997 }
 998
 999 void
1000 Editor::marker_menu_select_all_selectables_using_range ()
1001 {
1002         Marker* marker;
1003
1004         if ((marker = reinterpret_cast<Marker *> (marker_menu_item->get_data ("marker"))) == 0) {
1005                 fatal << _("programming error: marker canvas item has no marker object pointer!") << endmsg;
1006                 /*NOTREACHED*/
1007         }
1008
1009         Location* l;
1010         bool is_start;
1011
1012         if (((l = find_location_from_marker (marker, is_start)) != 0) && (l->end() > l->start())) {
1013                 select_all_within (l->start(), l->end() - 1, 0,  DBL_MAX, track_views, Selection::Set, false);
1014         }
1015
1016 }
1017
1018 void
1019 Editor::marker_menu_separate_regions_using_location ()
1020 {
1021         Marker* marker;
1022
1023         if ((marker = reinterpret_cast<Marker *> (marker_menu_item->get_data ("marker"))) == 0) {
1024                 fatal << _("programming error: marker canvas item has no marker object pointer!") << endmsg;
1025                 /*NOTREACHED*/
1026         }
1027
1028         Location* l;
1029         bool is_start;
1030
1031         if (((l = find_location_from_marker (marker, is_start)) != 0) && (l->end() > l->start())) {
1032                 separate_regions_using_location (*l);
1033         }
1034
1035 }
1036
1037 void
1038 Editor::marker_menu_play_from ()
1039 {
1040         Marker* marker;
1041
1042         if ((marker = reinterpret_cast<Marker *> (marker_menu_item->get_data ("marker"))) == 0) {
1043                 fatal << _("programming error: marker canvas item has no marker object pointer!") << endmsg;
1044                 /*NOTREACHED*/
1045         }
1046
1047         Location* l;
1048         bool is_start;
1049
1050         if ((l = find_location_from_marker (marker, is_start)) != 0) {
1051
1052                 if (l->is_mark()) {
1053                         _session->request_locate (l->start(), true);
1054                 }
1055                 else {
1056                         //_session->request_bounded_roll (l->start(), l->end());
1057
1058                         if (is_start) {
1059                                 _session->request_locate (l->start(), true);
1060                         } else {
1061                                 _session->request_locate (l->end(), true);
1062                         }
1063                 }
1064         }
1065 }
1066
1067 void
1068 Editor::marker_menu_set_playhead ()
1069 {
1070         Marker* marker;
1071
1072         if ((marker = reinterpret_cast<Marker *> (marker_menu_item->get_data ("marker"))) == 0) {
1073                 fatal << _("programming error: marker canvas item has no marker object pointer!") << endmsg;
1074                 /*NOTREACHED*/
1075         }
1076
1077         Location* l;
1078         bool is_start;
1079
1080         if ((l = find_location_from_marker (marker, is_start)) != 0) {
1081
1082                 if (l->is_mark()) {
1083                         _session->request_locate (l->start(), false);
1084                 }
1085                 else {
1086                         if (is_start) {
1087                                 _session->request_locate (l->start(), false);
1088                         } else {
1089                                 _session->request_locate (l->end(), false);
1090                         }
1091                 }
1092         }
1093 }
1094
1095 void
1096 Editor::marker_menu_range_to_next ()
1097 {
1098         Marker* marker;
1099         if (!_session) {
1100                 return;
1101         }
1102
1103         if ((marker = reinterpret_cast<Marker *> (marker_menu_item->get_data ("marker"))) == 0) {
1104                 fatal << _("programming error: marker canvas item has no marker object pointer!") << endmsg;
1105                 /*NOTREACHED*/
1106         }
1107
1108         Location* l;
1109         bool is_start;
1110
1111         if ((l = find_location_from_marker (marker, is_start)) == 0) {
1112                 return;
1113         }
1114
1115         framepos_t start;
1116         framepos_t end;
1117         _session->locations()->marks_either_side (marker->position(), start, end);
1118
1119         if (end != max_framepos) {
1120                 string range_name = l->name();
1121                 range_name += "-range";
1122
1123                 Location* newrange = new Location (*_session, marker->position(), end, range_name, Location::IsRangeMarker);
1124                 _session->locations()->add (newrange);
1125         }
1126 }
1127
1128 void
1129 Editor::marker_menu_set_from_playhead ()
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                         l->set_start (_session->audible_frame ());
1145                 }
1146                 else {
1147                         if (is_start) {
1148                                 l->set_start (_session->audible_frame ());
1149                         } else {
1150                                 l->set_end (_session->audible_frame ());
1151                         }
1152                 }
1153         }
1154 }
1155
1156 void
1157 Editor::marker_menu_set_from_selection ()
1158 {
1159         Marker* marker;
1160
1161         if ((marker = reinterpret_cast<Marker *> (marker_menu_item->get_data ("marker"))) == 0) {
1162                 fatal << _("programming error: marker canvas item has no marker object pointer!") << endmsg;
1163                 /*NOTREACHED*/
1164         }
1165
1166         Location* l;
1167         bool is_start;
1168
1169         if ((l = find_location_from_marker (marker, is_start)) != 0) {
1170
1171                 if (l->is_mark()) {
1172                         // nothing for now
1173                 }
1174                 else {
1175
1176                         /* if range selection use first to last */
1177
1178                         if (mouse_mode == Editing::MouseRange) {
1179                                 if (!selection->time.empty()) {
1180                                         l->set_start (selection->time.start());
1181                                         l->set_end (selection->time.end_frame());
1182                                 }
1183                         }
1184                         else {
1185                                 if (!selection->regions.empty()) {
1186                                         l->set_start (selection->regions.start());
1187                                         l->set_end (selection->regions.end_frame());
1188                                 }
1189                         }
1190                 }
1191         }
1192 }
1193
1194
1195 void
1196 Editor::marker_menu_play_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
1210                 if (l->is_mark()) {
1211                         _session->request_locate (l->start(), true);
1212                 }
1213                 else {
1214                         _session->request_bounded_roll (l->start(), l->end());
1215
1216                 }
1217         }
1218 }
1219
1220 void
1221 Editor::marker_menu_loop_range ()
1222 {
1223         Marker* marker;
1224
1225         if ((marker = reinterpret_cast<Marker *> (marker_menu_item->get_data ("marker"))) == 0) {
1226                 fatal << _("programming error: marker canvas item has no marker object pointer!") << endmsg;
1227                 /*NOTREACHED*/
1228         }
1229
1230         Location* l;
1231         bool is_start;
1232
1233         if ((l = find_location_from_marker (marker, is_start)) != 0) {
1234                 Location* l2;
1235                 if ((l2 = transport_loop_location()) != 0) {
1236                         l2->set (l->start(), l->end());
1237
1238                         // enable looping, reposition and start rolling
1239                         _session->request_play_loop(true);
1240                         _session->request_locate (l2->start(), true);
1241                 }
1242         }
1243 }
1244
1245 /** Temporal zoom to the range of the marker_menu_item (plus 5% either side) */
1246 void
1247 Editor::marker_menu_zoom_to_range ()
1248 {
1249         Marker* marker = reinterpret_cast<Marker *> (marker_menu_item->get_data ("marker"));
1250         assert (marker);
1251
1252         bool is_start;
1253         Location* l = find_location_from_marker (marker, is_start);
1254         if (l == 0) {
1255                 return;
1256         }
1257
1258         framecnt_t const extra = l->length() * 0.05;
1259         framepos_t a = l->start ();
1260         if (a >= extra) {
1261                 a -= extra;
1262         }
1263
1264         framepos_t b = l->end ();
1265         if (b < (max_framepos - extra)) {
1266                 b += extra;
1267         }
1268
1269         temporal_zoom_by_frame (a, b);
1270 }
1271
1272 void
1273 Editor::dynamic_cast_marker_object (void* p, MeterMarker** m, TempoMarker** t) const
1274 {
1275         Marker* marker = reinterpret_cast<Marker*> (p);
1276         if (!marker) {
1277                 fatal << _("programming error: marker canvas item has no marker object pointer!") << endmsg;
1278                 /*NOTREACHED*/
1279         }
1280
1281         *m = dynamic_cast<MeterMarker*> (marker);
1282         *t = dynamic_cast<TempoMarker*> (marker);
1283 }
1284
1285 void
1286 Editor::marker_menu_edit ()
1287 {
1288         MeterMarker* mm;
1289         TempoMarker* tm;
1290         dynamic_cast_marker_object (marker_menu_item->get_data ("marker"), &mm, &tm);
1291
1292         if (mm) {
1293                 edit_meter_section (&mm->meter());
1294         } else if (tm) {
1295                 edit_tempo_section (&tm->tempo());
1296         }
1297 }
1298
1299 void
1300 Editor::marker_menu_remove ()
1301 {
1302         MeterMarker* mm;
1303         TempoMarker* tm;
1304         dynamic_cast_marker_object (marker_menu_item->get_data ("marker"), &mm, &tm);
1305
1306         if (mm) {
1307                 remove_meter_marker (marker_menu_item);
1308         } else if (tm) {
1309                 remove_tempo_marker (marker_menu_item);
1310         } else {
1311                 remove_marker (*marker_menu_item, (GdkEvent*) 0);
1312         }
1313 }
1314
1315 void
1316 Editor::toggle_marker_menu_lock ()
1317 {
1318         Marker* marker;
1319
1320         if ((marker = reinterpret_cast<Marker *> (marker_menu_item->get_data ("marker"))) == 0) {
1321                 fatal << _("programming error: marker canvas item has no marker object pointer!") << endmsg;
1322                 /*NOTREACHED*/
1323         }
1324
1325         Location* loc;
1326         bool ignored;
1327
1328         loc = find_location_from_marker (marker, ignored);
1329
1330         if (!loc) {
1331                 return;
1332         }
1333
1334         if (loc->locked()) {
1335                 loc->unlock ();
1336         } else {
1337                 loc->lock ();
1338         }
1339 }
1340
1341 void
1342 Editor::marker_menu_rename ()
1343 {
1344         Marker* marker;
1345
1346         if ((marker = reinterpret_cast<Marker *> (marker_menu_item->get_data ("marker"))) == 0) {
1347                 fatal << _("programming error: marker canvas item has no marker object pointer!") << endmsg;
1348                 /*NOTREACHED*/
1349         }
1350
1351         Location* loc;
1352         bool is_start;
1353
1354         loc = find_location_from_marker (marker, is_start);
1355
1356         if (!loc) return;
1357
1358         ArdourPrompter dialog (true);
1359         string txt;
1360
1361         dialog.set_prompt (_("New Name:"));
1362
1363         if (loc->is_mark()) {
1364                 dialog.set_title (_("Rename Mark"));
1365         } else {
1366                 dialog.set_title (_("Rename Range"));
1367         }
1368
1369         dialog.set_name ("MarkRenameWindow");
1370         dialog.set_size_request (250, -1);
1371         dialog.set_position (Gtk::WIN_POS_MOUSE);
1372
1373         dialog.add_button (_("Rename"), RESPONSE_ACCEPT);
1374         dialog.set_response_sensitive (Gtk::RESPONSE_ACCEPT, false);
1375         dialog.set_initial_text (loc->name());
1376
1377         dialog.show ();
1378
1379         switch (dialog.run ()) {
1380         case RESPONSE_ACCEPT:
1381                 break;
1382         default:
1383                 return;
1384         }
1385
1386         begin_reversible_command ( _("rename marker") );
1387         XMLNode &before = _session->locations()->get_state();
1388
1389         dialog.get_result(txt);
1390         loc->set_name (txt);
1391
1392         XMLNode &after = _session->locations()->get_state();
1393         _session->add_command (new MementoCommand<Locations>(*(_session->locations()), &before, &after));
1394         commit_reversible_command ();
1395 }
1396
1397 void
1398 Editor::new_transport_marker_menu_popdown ()
1399 {
1400         // hide rects
1401         transport_bar_drag_rect->hide();
1402
1403         _drags->abort ();
1404 }
1405
1406 void
1407 Editor::new_transport_marker_menu_set_loop ()
1408 {
1409         set_loop_range (temp_location->start(), temp_location->end(), _("set loop range"));
1410 }
1411
1412 void
1413 Editor::new_transport_marker_menu_set_punch ()
1414 {
1415         set_punch_range (temp_location->start(), temp_location->end(), _("set punch range"));
1416 }
1417
1418 void
1419 Editor::update_loop_range_view (bool visibility)
1420 {
1421         if (_session == 0) {
1422                 return;
1423         }
1424
1425         Location* tll;
1426
1427         if (_session->get_play_loop() && ((tll = transport_loop_location()) != 0)) {
1428
1429                 double x1 = frame_to_pixel (tll->start());
1430                 double x2 = frame_to_pixel (tll->end());
1431
1432                 transport_loop_range_rect->property_x1() = x1;
1433                 transport_loop_range_rect->property_x2() = x2;
1434
1435                 if (visibility) {
1436                         transport_loop_range_rect->show();
1437                 }
1438
1439         } else if (visibility) {
1440                 transport_loop_range_rect->hide();
1441         }
1442 }
1443
1444 void
1445 Editor::update_punch_range_view (bool visibility)
1446 {
1447         if (_session == 0) {
1448                 return;
1449         }
1450
1451         Location* tpl;
1452
1453         if ((_session->config.get_punch_in() || _session->config.get_punch_out()) && ((tpl = transport_punch_location()) != 0)) {
1454                 guint track_canvas_width,track_canvas_height;
1455                 track_canvas->get_size(track_canvas_width,track_canvas_height);
1456                 if (_session->config.get_punch_in()) {
1457                         transport_punch_range_rect->property_x1() = frame_to_pixel (tpl->start());
1458                         transport_punch_range_rect->property_x2() = (_session->config.get_punch_out() ? frame_to_pixel (tpl->end()) : frame_to_pixel (JACK_MAX_FRAMES));
1459                 } else {
1460                         transport_punch_range_rect->property_x1() = 0;
1461                         transport_punch_range_rect->property_x2() = (_session->config.get_punch_out() ? frame_to_pixel (tpl->end()) : track_canvas_width);
1462                 }
1463
1464                 if (visibility) {
1465                         transport_punch_range_rect->show();
1466                 }
1467         } else if (visibility) {
1468                 transport_punch_range_rect->hide();
1469         }
1470 }
1471
1472 void
1473 Editor::marker_selection_changed ()
1474 {
1475         if (_session && _session->deletion_in_progress()) {
1476                 return;
1477         }
1478
1479         for (LocationMarkerMap::iterator i = location_markers.begin(); i != location_markers.end(); ++i) {
1480                 i->second->set_selected (false);
1481         }
1482
1483         for (MarkerSelection::iterator x = selection->markers.begin(); x != selection->markers.end(); ++x) {
1484                 (*x)->set_selected (true);
1485         }
1486 }
1487
1488 struct SortLocationsByPosition {
1489     bool operator() (Location* a, Location* b) {
1490             return a->start() < b->start();
1491     }
1492 };
1493
1494 void
1495 Editor::goto_nth_marker (int n)
1496 {
1497         if (!_session) {
1498                 return;
1499         }
1500         const Locations::LocationList& l (_session->locations()->list());
1501         Locations::LocationList ordered;
1502         ordered = l;
1503
1504         SortLocationsByPosition cmp;
1505         ordered.sort (cmp);
1506
1507         for (Locations::LocationList::iterator i = ordered.begin(); n >= 0 && i != ordered.end(); ++i) {
1508                 if ((*i)->is_mark() && !(*i)->is_hidden() && !(*i)->is_session_range()) {
1509                         if (n == 0) {
1510                                 _session->request_locate ((*i)->start(), _session->transport_rolling());
1511                                 break;
1512                         }
1513                         --n;
1514                 }
1515         }
1516 }
1517
1518 void
1519 Editor::toggle_marker_menu_glue ()
1520 {
1521         Marker* marker;
1522
1523         if ((marker = reinterpret_cast<Marker *> (marker_menu_item->get_data ("marker"))) == 0) {
1524                 fatal << _("programming error: marker canvas item has no marker object pointer!") << endmsg;
1525                 /*NOTREACHED*/
1526         }
1527
1528         Location* loc;
1529         bool ignored;
1530
1531         loc = find_location_from_marker (marker, ignored);
1532
1533         if (!loc) {
1534                 return;
1535         }
1536
1537         if (loc->position_lock_style() == MusicTime) {
1538                 loc->set_position_lock_style (AudioTime);
1539         } else {
1540                 loc->set_position_lock_style (MusicTime);
1541         }
1542
1543 }
1544
1545 void
1546 Editor::toggle_marker_lines ()
1547 {
1548         _show_marker_lines = !_show_marker_lines;
1549
1550         for (LocationMarkerMap::iterator i = location_markers.begin(); i != location_markers.end(); ++i) {
1551                 i->second->set_show_lines (_show_marker_lines);
1552         }
1553 }
1554
1555 void
1556 Editor::remove_sorted_marker (Marker* m)
1557 {
1558         for (std::map<ArdourCanvas::Group *, std::list<Marker *> >::iterator i = _sorted_marker_lists.begin(); i != _sorted_marker_lists.end(); ++i) {
1559                 i->second.remove (m);
1560         }
1561 }
1562
1563 Marker *
1564 Editor::find_marker_from_location_id (PBD::ID const & id, bool is_start) const
1565 {
1566         for (LocationMarkerMap::const_iterator i = location_markers.begin(); i != location_markers.end(); ++i) {
1567                 if (i->first->id() == id) {
1568                         return is_start ? i->second->start : i->second->end;
1569                 }
1570         }
1571
1572         return 0;
1573 }