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 #include <gtkmm2ext/window_title.h>
  27
  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
  41 #include "i18n.h"
  42
  43 using namespace std;
  44 using namespace sigc;
  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 (bind (mem_fun(*this, &Editor::add_new_location), location));
  64
  65         LocationMarkers *lam = new LocationMarkers;
  66         uint32_t color;
  67
  68         if (location->is_cd_marker()) {
  69                 color = location_cd_marker_color;
  70         } else if (location->is_mark()) {
  71                 color = location_marker_color;
  72         } else if (location->is_auto_loop()) {
  73                 color = location_loop_color;
  74         } else if (location->is_auto_punch()) {
  75                 color = location_punch_color;
  76         } else {
  77                 color = location_range_color;
  78         }
  79
  80         if (location->is_mark()) {
  81
  82                 if (location->is_cd_marker() && ruler_cd_marker_action->get_active()) {
  83                         lam->start = new Marker (*this, *cd_marker_group, color, location->name(), Marker::Mark, location->start());
  84                 }
  85                 else {
  86                         lam->start = new Marker (*this, *marker_group, color, location->name(), Marker::Mark, location->start());
  87                 }
  88                 lam->end   = 0;
  89
  90         } else if (location->is_auto_loop()) {
  91                 // transport marker
  92                 lam->start = new Marker (*this, *transport_marker_group, color,
  93                                          location->name(), Marker::LoopStart, location->start());
  94                 lam->end   = new Marker (*this, *transport_marker_group, color,
  95                                          location->name(), Marker::LoopEnd, location->end());
  96
  97         } else if (location->is_auto_punch()) {
  98                 // transport marker
  99                 lam->start = new Marker (*this, *transport_marker_group, color,
 100                                          location->name(), Marker::PunchIn, location->start());
 101                 lam->end   = new Marker (*this, *transport_marker_group, color,
 102                                          location->name(), Marker::PunchOut, location->end());
 103
 104         } else {
 105                 // range marker
 106                 if (location->is_cd_marker() && ruler_cd_marker_action->get_active()) {
 107                         lam->start = new Marker (*this, *cd_marker_group, color,
 108                                                  location->name(), Marker::Start, location->start());
 109                         lam->end   = new Marker (*this, *cd_marker_group, color,
 110                                                  location->name(), Marker::End, location->end());
 111                 }
 112                 else {
 113
 114                         lam->start = new Marker (*this, *range_marker_group, color,
 115                                                  location->name(), Marker::Start, location->start());
 116                         lam->end   = new Marker (*this, *range_marker_group, color,
 117                                                  location->name(), Marker::End, location->end());
 118                 }
 119         }
 120
 121         if (location->is_hidden ()) {
 122                 lam->hide();
 123         } else {
 124                 lam->show ();
 125         }
 126
 127         location->start_changed.connect (mem_fun(*this, &Editor::location_changed));
 128         location->end_changed.connect (mem_fun(*this, &Editor::location_changed));
 129         location->changed.connect (mem_fun(*this, &Editor::location_changed));
 130         location->name_changed.connect (mem_fun(*this, &Editor::location_changed));
 131         location->FlagsChanged.connect (mem_fun(*this, &Editor::location_flags_changed));
 132
 133         pair<Location*,LocationMarkers*> newpair;
 134
 135         newpair.first = location;
 136         newpair.second = lam;
 137
 138         location_markers.insert (newpair);
 139
 140         if (select_new_marker && location->is_mark()) {
 141                 selection->set (lam->start);
 142                 select_new_marker = false;
 143         }
 144 }
 145
 146 void
 147 Editor::location_changed (Location *location)
 148 {
 149         ENSURE_GUI_THREAD (bind (mem_fun(*this, &Editor::location_changed), location));
 150
 151         LocationMarkers *lam = find_location_markers (location);
 152
 153         if (lam == 0) {
 154                 /* a location that isn't "marked" with markers */
 155                 return;
 156         }
 157
 158         lam->set_name (location->name());
 159         lam->set_position (location->start(), location->end());
 160
 161         if (location->is_auto_loop()) {
 162                 update_loop_range_view ();
 163         } else if (location->is_auto_punch()) {
 164                 update_punch_range_view ();
 165         }
 166 }
 167
 168 void
 169 Editor::location_flags_changed (Location *location, void *src)
 170 {
 171         ENSURE_GUI_THREAD(bind (mem_fun(*this, &Editor::location_flags_changed), location, src));
 172
 173         LocationMarkers *lam = find_location_markers (location);
 174
 175         if (lam == 0) {
 176                 /* a location that isn't "marked" with markers */
 177                 return;
 178         }
 179
 180         // move cd markers to/from cd marker bar as appropriate
 181         ensure_cd_marker_updated (lam, location);
 182
 183         if (location->is_cd_marker()) {
 184                 lam->set_color_rgba (location_cd_marker_color);
 185         } else if (location->is_mark()) {
 186                 lam->set_color_rgba (location_marker_color);
 187         } else if (location->is_auto_punch()) {
 188                 lam->set_color_rgba (location_punch_color);
 189         } else if (location->is_auto_loop()) {
 190                 lam->set_color_rgba (location_loop_color);
 191         } else {
 192                 lam->set_color_rgba (location_range_color);
 193         }
 194
 195         if (location->is_hidden()) {
 196                 lam->hide();
 197         } else {
 198                 lam->show ();
 199         }
 200 }
 201
 202 void Editor::update_cd_marker_display ()
 203 {
 204         for (LocationMarkerMap::iterator i = location_markers.begin(); i != location_markers.end(); ++i) {
 205                 LocationMarkers * lam = i->second;
 206                 Location * location = i->first;
 207
 208                 ensure_cd_marker_updated (lam, location);
 209         }
 210 }
 211
 212 void Editor::ensure_cd_marker_updated (LocationMarkers * lam, Location * location)
 213 {
 214         if (location->is_cd_marker()
 215             && (ruler_cd_marker_action->get_active() &&  lam->start->get_parent() != cd_marker_group))
 216         {
 217                 //cerr << "reparenting non-cd marker so it can be relocated: " << location->name() << endl;
 218                 if (lam->start) {
 219                         lam->start->reparent (*cd_marker_group);
 220                 }
 221                 if (lam->end) {
 222                         lam->end->reparent (*cd_marker_group);
 223                 }
 224         }
 225         else if ( (!location->is_cd_marker() || !ruler_cd_marker_action->get_active())
 226                   && (lam->start->get_parent() == cd_marker_group))
 227         {
 228                 //cerr << "reparenting non-cd marker so it can be relocated: " << location->name() << endl;
 229                 if (location->is_mark()) {
 230                         if (lam->start) {
 231                                 lam->start->reparent (*marker_group);
 232                         }
 233                         if (lam->end) {
 234                                 lam->end->reparent (*marker_group);
 235                         }
 236                 }
 237                 else {
 238                         if (lam->start) {
 239                                 lam->start->reparent (*range_marker_group);
 240                         }
 241                         if (lam->end) {
 242                                 lam->end->reparent (*range_marker_group);
 243                         }
 244                 }
 245         }
 246 }
 247
 248 Editor::LocationMarkers::~LocationMarkers ()
 249 {
 250         if (start) {
 251                 delete start;
 252         }
 253
 254         if (end) {
 255                 delete end;
 256         }
 257 }
 258
 259 Editor::LocationMarkers *
 260 Editor::find_location_markers (Location *location) const
 261 {
 262         LocationMarkerMap::const_iterator i;
 263
 264         for (i = location_markers.begin(); i != location_markers.end(); ++i) {
 265                 if ((*i).first == location) {
 266                         return (*i).second;
 267                 }
 268         }
 269
 270         return 0;
 271 }
 272
 273 Location *
 274 Editor::find_location_from_marker (Marker *marker, bool& is_start) const
 275 {
 276         LocationMarkerMap::const_iterator i;
 277
 278         for (i = location_markers.begin(); i != location_markers.end(); ++i) {
 279                 LocationMarkers *lm = (*i).second;
 280                 if (lm->start == marker) {
 281                         is_start = true;
 282                         return (*i).first;
 283                 } else if (lm->end == marker) {
 284                         is_start = false;
 285                         return (*i).first;
 286                 }
 287         }
 288
 289         return 0;
 290 }
 291
 292 void
 293 Editor::refresh_location_display_internal (Locations::LocationList& locations)
 294 {
 295         /* invalidate all */
 296
 297         for (LocationMarkerMap::iterator i = location_markers.begin(); i != location_markers.end(); ++i) {
 298                 i->second->valid = false;
 299         }
 300
 301         /* add new ones */
 302
 303         for (Locations::LocationList::iterator i = locations.begin(); i != locations.end(); ++i) {
 304
 305                 LocationMarkerMap::iterator x;
 306
 307                 if ((x = location_markers.find (*i)) != location_markers.end()) {
 308                         x->second->valid = true;
 309                         continue;
 310                 }
 311
 312                 add_new_location (*i);
 313         }
 314
 315         /* remove dead ones */
 316
 317         for (LocationMarkerMap::iterator i = location_markers.begin(); i != location_markers.end(); ) {
 318
 319                 LocationMarkerMap::iterator tmp;
 320
 321                 tmp = i;
 322                 ++tmp;
 323
 324                 if (!i->second->valid) {
 325                         delete i->second;
 326                         location_markers.erase (i);
 327                 }
 328
 329                 i = tmp;
 330         }
 331
 332         update_punch_range_view (false);
 333         update_loop_range_view (false);
 334 }
 335
 336 void
 337 Editor::refresh_location_display ()
 338 {
 339         ENSURE_GUI_THREAD(mem_fun(*this, &Editor::refresh_location_display));
 340
 341         if (session) {
 342                 session->locations()->apply (*this, &Editor::refresh_location_display_internal);
 343         }
 344 }
 345
 346 void
 347 Editor::refresh_location_display_s (Change ignored)
 348 {
 349         ENSURE_GUI_THREAD(bind (mem_fun(*this, &Editor::refresh_location_display_s), ignored));
 350
 351         if (session) {
 352                 session->locations()->apply (*this, &Editor::refresh_location_display_internal);
 353         }
 354 }
 355
 356 void
 357 Editor::LocationMarkers::hide()
 358 {
 359         start->hide ();
 360         if (end) { end->hide(); }
 361 }
 362
 363 void
 364 Editor::LocationMarkers::show()
 365 {
 366         start->show ();
 367         if (end) { end->show(); }
 368 }
 369
 370 void
 371 Editor::LocationMarkers::set_name (const string& str)
 372 {
 373         start->set_name (str);
 374         if (end) { end->set_name (str); }
 375 }
 376
 377 void
 378 Editor::LocationMarkers::set_position (nframes64_t startf,
 379                                        nframes64_t endf)
 380 {
 381         start->set_position (startf);
 382         if (end) { end->set_position (endf); }
 383 }
 384
 385 void
 386 Editor::LocationMarkers::set_color_rgba (uint32_t rgba)
 387 {
 388         start->set_color_rgba (rgba);
 389         if (end) { end->set_color_rgba (rgba); }
 390 }
 391
 392 void
 393 Editor::mouse_add_new_marker (nframes64_t where, bool is_cd, bool is_xrun)
 394 {
 395         string markername, markerprefix;
 396         int flags = (is_cd ? Location::IsCDMarker|Location::IsMark : Location::IsMark);
 397
 398         if (is_xrun) {
 399                 markerprefix = "xrun";
 400                 flags = Location::IsMark;
 401         } else {
 402                 markerprefix = "mark";
 403         }
 404
 405         if (session) {
 406                 session->locations()->next_available_name(markername, markerprefix);
 407                 if (!is_xrun && !choose_new_marker_name(markername)) {
 408                         return;
 409                 }
 410                 Location *location = new Location (where, where, markername, (Location::Flags) flags);
 411                 session->begin_reversible_command (_("add marker"));
 412                 XMLNode &before = session->locations()->get_state();
 413                 session->locations()->add (location, true);
 414                 XMLNode &after = session->locations()->get_state();
 415                 session->add_command (new MementoCommand<Locations>(*(session->locations()), &before, &after));
 416                 session->commit_reversible_command ();
 417
 418                 /* find the marker we just added */
 419
 420                 LocationMarkers *lam = find_location_markers (location);
 421                 if (lam) {
 422                         /* make it the selected marker */
 423                         selection->set (lam->start);
 424                 }
 425         }
 426 }
 427
 428 void
 429 Editor::remove_marker (ArdourCanvas::Item& item, GdkEvent* event)
 430 {
 431         Marker* marker;
 432         bool is_start;
 433
 434         if ((marker = static_cast<Marker*> (item.get_data ("marker"))) == 0) {
 435                 fatal << _("programming error: marker canvas item has no marker object pointer!") << endmsg;
 436                 /*NOTREACHED*/
 437         }
 438
 439         if (entered_marker == marker) {
 440                 entered_marker = NULL;
 441         }
 442
 443         Location* loc = find_location_from_marker (marker, is_start);
 444
 445         if (session && loc) {
 446                 Glib::signal_idle().connect (bind (mem_fun(*this, &Editor::really_remove_marker), loc));
 447         }
 448 }
 449
 450 gint
 451 Editor::really_remove_marker (Location* loc)
 452 {
 453         session->begin_reversible_command (_("remove marker"));
 454         XMLNode &before = session->locations()->get_state();
 455         session->locations()->remove (loc);
 456         XMLNode &after = session->locations()->get_state();
 457         session->add_command (new MementoCommand<Locations>(*(session->locations()), &before, &after));
 458         session->commit_reversible_command ();
 459         return FALSE;
 460 }
 461
 462 void
 463 Editor::location_gone (Location *location)
 464 {
 465         ENSURE_GUI_THREAD(bind (mem_fun(*this, &Editor::location_gone), location));
 466
 467         LocationMarkerMap::iterator i;
 468
 469         if (location == transport_loop_location()) {
 470                 update_loop_range_view (true);
 471         }
 472
 473         if (location == transport_punch_location()) {
 474                 update_punch_range_view (true);
 475         }
 476
 477         for (i = location_markers.begin(); i != location_markers.end(); ++i) {
 478                 if ((*i).first == location) {
 479                         delete (*i).second;
 480                         location_markers.erase (i);
 481                         break;
 482                 }
 483         }
 484 }
 485
 486 void
 487 Editor::tm_marker_context_menu (GdkEventButton* ev, ArdourCanvas::Item* item)
 488 {
 489         if (tm_marker_menu == 0) {
 490                 build_tm_marker_menu ();
 491         }
 492
 493         marker_menu_item = item;
 494         tm_marker_menu->popup (1, ev->time);
 495
 496 }
 497
 498 void
 499 Editor::marker_context_menu (GdkEventButton* ev, ArdourCanvas::Item* item)
 500 {
 501         Marker * marker;
 502         if ((marker = reinterpret_cast<Marker *> (item->get_data("marker"))) == 0) {
 503                 fatal << _("programming error: marker canvas item has no marker object pointer!") << endmsg;
 504                 /*NOTREACHED*/
 505         }
 506
 507         bool is_start;
 508         Location * loc = find_location_from_marker (marker, is_start);
 509         if (loc == transport_loop_location() || loc == transport_punch_location()) {
 510                 if (transport_marker_menu == 0) {
 511                         build_range_marker_menu (true);
 512                 }
 513                 marker_menu_item = item;
 514                 transport_marker_menu->popup (1, ev->time);
 515         } else {
 516
 517                 if (loc->is_mark()) {
 518                         bool start_or_end = loc->is_start() || loc->is_end();
 519                         Menu *markerMenu;
 520                         if (start_or_end) {
 521                                 if (start_end_marker_menu == 0)
 522                                         build_marker_menu (true);
 523                                 markerMenu = start_end_marker_menu;
 524                         } else {
 525                                 if (marker_menu == 0)
 526                                         build_marker_menu (false);
 527                                 markerMenu = marker_menu;
 528                         }
 529
 530
 531                 // GTK2FIX use action group sensitivity
 532 #ifdef GTK2FIX
 533                 if (children.size() >= 3) {
 534                         MenuItem * loopitem = &children[2];
 535                         if (loopitem) {
 536                                 if (loc->is_mark()) {
 537                                         loopitem->set_sensitive(false);
 538                                 }
 539                                 else {
 540                                         loopitem->set_sensitive(true);
 541                                 }
 542                         }
 543                 }
 544 #endif
 545                 marker_menu_item = item;
 546                 markerMenu->popup (1, ev->time);
 547                 }
 548
 549                 if (loc->is_range_marker()) {
 550                        if (range_marker_menu == 0){
 551                               build_range_marker_menu (false);
 552                        }
 553                        marker_menu_item = item;
 554                        range_marker_menu->popup (1, ev->time);
 555                 }
 556         }
 557 }
 558
 559 void
 560 Editor::new_transport_marker_context_menu (GdkEventButton* ev, ArdourCanvas::Item* item)
 561 {
 562         if (new_transport_marker_menu == 0) {
 563                 build_new_transport_marker_menu ();
 564         }
 565
 566         new_transport_marker_menu->popup (1, ev->time);
 567
 568 }
 569
 570 void
 571 Editor::transport_marker_context_menu (GdkEventButton* ev, ArdourCanvas::Item* item)
 572 {
 573         if (transport_marker_menu == 0) {
 574                 build_range_marker_menu (true);
 575         }
 576
 577         transport_marker_menu->popup (1, ev->time);
 578 }
 579
 580 void
 581 Editor::build_marker_menu (bool start_or_end)
 582 {
 583         using namespace Menu_Helpers;
 584
 585         Menu *markerMenu = new Menu;
 586         if (start_or_end) {
 587                 start_end_marker_menu = markerMenu;
 588         } else {
 589                 marker_menu = markerMenu;
 590         }
 591         MenuList& items = markerMenu->items();
 592         markerMenu->set_name ("ArdourContextMenu");
 593
 594         items.push_back (MenuElem (_("Locate to here"), mem_fun(*this, &Editor::marker_menu_set_playhead)));
 595         items.push_back (MenuElem (_("Play from here"), mem_fun(*this, &Editor::marker_menu_play_from)));
 596         items.push_back (MenuElem (_("Move Mark to Playhead"), mem_fun(*this, &Editor::marker_menu_set_from_playhead)));
 597
 598         items.push_back (SeparatorElem());
 599
 600         items.push_back (MenuElem (_("Create range to next marker"), mem_fun(*this, &Editor::marker_menu_range_to_next)));
 601
 602         items.push_back (MenuElem (_("Hide"), mem_fun(*this, &Editor::marker_menu_hide)));
 603         if (start_or_end) return;
 604         items.push_back (MenuElem (_("Rename"), mem_fun(*this, &Editor::marker_menu_rename)));
 605         items.push_back (MenuElem (_("Lock"), bind (mem_fun(*this, &Editor::marker_menu_lock), true)));
 606         items.push_back (MenuElem (_("Unlock"), bind (mem_fun(*this, &Editor::marker_menu_lock), false)));
 607
 608         items.push_back (SeparatorElem());
 609
 610         items.push_back (MenuElem (_("Remove"), mem_fun(*this, &Editor::marker_menu_remove)));
 611 }
 612
 613 void
 614 Editor::build_range_marker_menu (bool loop_or_punch)
 615 {
 616         using namespace Menu_Helpers;
 617
 618         Menu *markerMenu = new Menu;
 619         if (loop_or_punch) {
 620                 transport_marker_menu = markerMenu;
 621         } else {
 622                 range_marker_menu = markerMenu;
 623         }
 624
 625         MenuList& items = markerMenu->items();
 626         markerMenu->set_name ("ArdourContextMenu");
 627
 628         items.push_back (MenuElem (_("Play Range"), mem_fun(*this, &Editor::marker_menu_play_range)));
 629         items.push_back (MenuElem (_("Locate to Range Mark"), mem_fun(*this, &Editor::marker_menu_set_playhead)));
 630         items.push_back (MenuElem (_("Play from Range Mark"), mem_fun(*this, &Editor::marker_menu_play_from)));
 631         if (!loop_or_punch) {
 632                 items.push_back (MenuElem (_("Loop Range"), mem_fun(*this, &Editor::marker_menu_loop_range)));
 633         }
 634         items.push_back (MenuElem (_("Set Range Mark from Playhead"), mem_fun(*this, &Editor::marker_menu_set_from_playhead)));
 635         if (!Profile->get_sae()) {
 636                 items.push_back (MenuElem (_("Set Range from Range Selection"), mem_fun(*this, &Editor::marker_menu_set_from_selection)));
 637         }
 638
 639         items.push_back (SeparatorElem());
 640
 641         items.push_back (MenuElem (_("Export Range"), mem_fun(*this, &Editor::marker_menu_export_range)));
 642
 643         items.push_back (SeparatorElem());
 644
 645         if (!loop_or_punch) {
 646                 items.push_back (MenuElem (_("Hide Range"), mem_fun(*this, &Editor::marker_menu_hide)));
 647                 items.push_back (MenuElem (_("Rename Range"), mem_fun(*this, &Editor::marker_menu_rename)));
 648                 items.push_back (MenuElem (_("Remove Range"), mem_fun(*this, &Editor::marker_menu_remove)));
 649         }
 650
 651         items.push_back (SeparatorElem());
 652
 653         items.push_back (MenuElem (_("Separate Regions in Range"), mem_fun(*this, &Editor::marker_menu_separate_regions_using_location)));
 654         items.push_back (MenuElem (_("Select All in Range"), mem_fun(*this, &Editor::marker_menu_select_all_selectables_using_range)));
 655         if (!Profile->get_sae()) {
 656                 items.push_back (MenuElem (_("Select Range"), mem_fun(*this, &Editor::marker_menu_select_using_range)));
 657         }
 658 }
 659
 660 void
 661 Editor::build_tm_marker_menu ()
 662 {
 663         using namespace Menu_Helpers;
 664
 665         tm_marker_menu = new Menu;
 666         MenuList& items = tm_marker_menu->items();
 667         tm_marker_menu->set_name ("ArdourContextMenu");
 668
 669         items.push_back (MenuElem (_("Edit"), mem_fun(*this, &Editor::marker_menu_edit)));
 670         items.push_back (MenuElem (_("Remove"), mem_fun(*this, &Editor::marker_menu_remove)));
 671 }
 672
 673 void
 674 Editor::build_new_transport_marker_menu ()
 675 {
 676         using namespace Menu_Helpers;
 677
 678         new_transport_marker_menu = new Menu;
 679         MenuList& items = new_transport_marker_menu->items();
 680         new_transport_marker_menu->set_name ("ArdourContextMenu");
 681
 682         items.push_back (MenuElem (_("Set Loop Range"), mem_fun(*this, &Editor::new_transport_marker_menu_set_loop)));
 683         items.push_back (MenuElem (_("Set Punch Range"), mem_fun(*this, &Editor::new_transport_marker_menu_set_punch)));
 684
 685         new_transport_marker_menu->signal_unmap().connect ( mem_fun(*this, &Editor::new_transport_marker_menu_popdown));
 686 }
 687
 688 void
 689 Editor::marker_menu_hide ()
 690 {
 691         Marker* marker;
 692
 693         if ((marker = reinterpret_cast<Marker *> (marker_menu_item->get_data ("marker"))) == 0) {
 694                 fatal << _("programming error: marker canvas item has no marker object pointer!") << endmsg;
 695                 /*NOTREACHED*/
 696         }
 697
 698         Location* l;
 699         bool is_start;
 700
 701         if ((l = find_location_from_marker (marker, is_start)) != 0) {
 702                 l->set_hidden (true, this);
 703         }
 704 }
 705
 706 void
 707 Editor::marker_menu_select_using_range ()
 708 {
 709         Marker* marker;
 710
 711         if ((marker = reinterpret_cast<Marker *> (marker_menu_item->get_data ("marker"))) == 0) {
 712                 fatal << _("programming error: marker canvas item has no marker object pointer!") << endmsg;
 713                 /*NOTREACHED*/
 714         }
 715
 716         Location* l;
 717         bool is_start;
 718
 719         if (((l = find_location_from_marker (marker, is_start)) != 0) && (l->end() > l->start())) {
 720                 set_selection_from_range (*l);
 721         }
 722 }
 723
 724 void
 725 Editor::marker_menu_select_all_selectables_using_range ()
 726 {
 727         Marker* marker;
 728
 729         if ((marker = reinterpret_cast<Marker *> (marker_menu_item->get_data ("marker"))) == 0) {
 730                 fatal << _("programming error: marker canvas item has no marker object pointer!") << endmsg;
 731                 /*NOTREACHED*/
 732         }
 733
 734         Location* l;
 735         bool is_start;
 736
 737         if (((l = find_location_from_marker (marker, is_start)) != 0) && (l->end() > l->start())) {
 738                 select_all_within (l->start(), l->end() - 1, 0,  DBL_MAX, track_views, Selection::Set);
 739         }
 740
 741 }
 742
 743 void
 744 Editor::marker_menu_separate_regions_using_location ()
 745 {
 746         Marker* marker;
 747
 748         if ((marker = reinterpret_cast<Marker *> (marker_menu_item->get_data ("marker"))) == 0) {
 749                 fatal << _("programming error: marker canvas item has no marker object pointer!") << endmsg;
 750                 /*NOTREACHED*/
 751         }
 752
 753         Location* l;
 754         bool is_start;
 755
 756         if (((l = find_location_from_marker (marker, is_start)) != 0) && (l->end() > l->start())) {
 757                 separate_regions_using_location (*l);
 758         }
 759
 760 }
 761
 762 void
 763 Editor::marker_menu_play_from ()
 764 {
 765         Marker* marker;
 766
 767         if ((marker = reinterpret_cast<Marker *> (marker_menu_item->get_data ("marker"))) == 0) {
 768                 fatal << _("programming error: marker canvas item has no marker object pointer!") << endmsg;
 769                 /*NOTREACHED*/
 770         }
 771
 772         Location* l;
 773         bool is_start;
 774
 775         if ((l = find_location_from_marker (marker, is_start)) != 0) {
 776
 777                 if (l->is_mark()) {
 778                         session->request_locate (l->start(), true);
 779                 }
 780                 else {
 781                         //session->request_bounded_roll (l->start(), l->end());
 782
 783                         if (is_start) {
 784                                 session->request_locate (l->start(), true);
 785                         } else {
 786                                 session->request_locate (l->end(), true);
 787                         }
 788                 }
 789         }
 790 }
 791
 792 void
 793 Editor::marker_menu_set_playhead ()
 794 {
 795         Marker* marker;
 796
 797         if ((marker = reinterpret_cast<Marker *> (marker_menu_item->get_data ("marker"))) == 0) {
 798                 fatal << _("programming error: marker canvas item has no marker object pointer!") << endmsg;
 799                 /*NOTREACHED*/
 800         }
 801
 802         Location* l;
 803         bool is_start;
 804
 805         if ((l = find_location_from_marker (marker, is_start)) != 0) {
 806
 807                 if (l->is_mark()) {
 808                         session->request_locate (l->start(), false);
 809                 }
 810                 else {
 811                         if (is_start) {
 812                                 session->request_locate (l->start(), false);
 813                         } else {
 814                                 session->request_locate (l->end(), false);
 815                         }
 816                 }
 817         }
 818 }
 819
 820 void
 821 Editor::marker_menu_export_range ()
 822 {
 823         Marker* marker;
 824
 825         if ((marker = reinterpret_cast<Marker *> (marker_menu_item->get_data ("marker"))) == 0) {
 826                 fatal << _("programming error: marker canvas item has no marker object pointer!") << endmsg;
 827                 /*NOTREACHED*/
 828         }
 829
 830         Location* l;
 831         bool is_start;
 832
 833         if ((l = find_location_from_marker (marker, is_start)) != 0) {
 834                 if (l->is_range_marker()) {
 835                         export_range (l->start(), l->end());
 836                 }
 837         }
 838 }
 839
 840 void
 841 Editor::marker_menu_range_to_next ()
 842 {
 843         Marker* marker;
 844         if (!session) {
 845                 return;
 846         }
 847
 848         if ((marker = reinterpret_cast<Marker *> (marker_menu_item->get_data ("marker"))) == 0) {
 849                 fatal << _("programming error: marker canvas item has no marker object pointer!") << endmsg;
 850                 /*NOTREACHED*/
 851         }
 852
 853         Location* l;
 854         bool is_start;
 855
 856         if ((l = find_location_from_marker (marker, is_start)) == 0) {
 857                 return;
 858         }
 859
 860         nframes_t end = session->locations()->first_mark_after (marker->position());
 861
 862         if (end != max_frames) {
 863                 string range_name = l->name();
 864                 range_name += "-range";
 865
 866                 Location* newrange = new Location (marker->position(), end, range_name, Location::IsRangeMarker);
 867                 session->locations()->add (newrange);
 868         }
 869 }
 870
 871 void
 872 Editor::marker_menu_set_from_playhead ()
 873 {
 874         Marker* marker;
 875
 876         if ((marker = reinterpret_cast<Marker *> (marker_menu_item->get_data ("marker"))) == 0) {
 877                 fatal << _("programming error: marker canvas item has no marker object pointer!") << endmsg;
 878                 /*NOTREACHED*/
 879         }
 880
 881         Location* l;
 882         bool is_start;
 883
 884         if ((l = find_location_from_marker (marker, is_start)) != 0) {
 885
 886                 if (l->is_mark()) {
 887                         l->set_start (session->audible_frame ());
 888                 }
 889                 else {
 890                         if (is_start) {
 891                                 l->set_start (session->audible_frame ());
 892                         } else {
 893                                 l->set_end (session->audible_frame ());
 894                         }
 895                 }
 896         }
 897 }
 898
 899 void
 900 Editor::marker_menu_set_from_selection ()
 901 {
 902         Marker* marker;
 903
 904         if ((marker = reinterpret_cast<Marker *> (marker_menu_item->get_data ("marker"))) == 0) {
 905                 fatal << _("programming error: marker canvas item has no marker object pointer!") << endmsg;
 906                 /*NOTREACHED*/
 907         }
 908
 909         Location* l;
 910         bool is_start;
 911
 912         if ((l = find_location_from_marker (marker, is_start)) != 0) {
 913
 914                 if (l->is_mark()) {
 915                         // nothing for now
 916                 } else {
 917
 918                         /* if range selection use first to last */
 919
 920                         if (mouse_mode == Editing::MouseRange) {
 921                                 if (!selection->time.empty()) {
 922                                         l->set_start (selection->time.start());
 923                                         l->set_end (selection->time.end_frame());
 924                                 }
 925                         }
 926                         else {
 927                                 if (!selection->regions.empty()) {
 928                                         l->set_start (selection->regions.start());
 929                                         l->set_end (selection->regions.end_frame());
 930                                 }
 931                         }
 932                 }
 933         }
 934 }
 935
 936
 937 void
 938 Editor::marker_menu_play_range ()
 939 {
 940         Marker* marker;
 941
 942         if ((marker = reinterpret_cast<Marker *> (marker_menu_item->get_data ("marker"))) == 0) {
 943                 fatal << _("programming error: marker canvas item has no marker object pointer!") << endmsg;
 944                 /*NOTREACHED*/
 945         }
 946
 947         Location* l;
 948         bool is_start;
 949
 950         if ((l = find_location_from_marker (marker, is_start)) != 0) {
 951
 952                 if (l->is_mark()) {
 953                         session->request_locate (l->start(), true);
 954                 }
 955                 else {
 956                         session->request_bounded_roll (l->start(), l->end());
 957
 958                 }
 959         }
 960 }
 961
 962 void
 963 Editor::marker_menu_loop_range ()
 964 {
 965         Marker* marker;
 966
 967         if ((marker = reinterpret_cast<Marker *> (marker_menu_item->get_data ("marker"))) == 0) {
 968                 fatal << _("programming error: marker canvas item has no marker object pointer!") << endmsg;
 969                 /*NOTREACHED*/
 970         }
 971
 972         Location* l;
 973         bool is_start;
 974
 975         if ((l = find_location_from_marker (marker, is_start)) != 0) {
 976                 Location* l2;
 977                 if ((l2 = transport_loop_location()) != 0) {
 978                         l2->set (l->start(), l->end());
 979
 980                         // enable looping, reposition and start rolling
 981                         session->request_play_loop(true);
 982                         session->request_locate (l2->start(), true);
 983                 }
 984         }
 985 }
 986
 987 void
 988 Editor::marker_menu_edit ()
 989 {
 990         MeterMarker* mm;
 991         TempoMarker* tm;
 992         Marker* marker;
 993
 994         if ((marker = reinterpret_cast<Marker *> (marker_menu_item->get_data ("marker"))) == 0) {
 995                 fatal << _("programming error: marker canvas item has no marker object pointer!") << endmsg;
 996                 /*NOTREACHED*/
 997         }
 998
 999         if ((mm = dynamic_cast<MeterMarker*> (marker)) != 0) {
1000                 edit_meter_section (&mm->meter());
1001         } else if ((tm = dynamic_cast<TempoMarker*> (marker)) != 0) {
1002                 edit_tempo_section (&tm->tempo());
1003         } else {
1004                 fatal << X_("programming erorr: unhandled marker type in Editor::marker_menu_edit")
1005                       << endmsg;
1006                 /*NOTREACHED*/
1007         }
1008 }
1009
1010 void
1011 Editor::marker_menu_remove ()
1012 {
1013         MeterMarker* mm;
1014         TempoMarker* tm;
1015         Marker* marker;
1016
1017         if ((marker = reinterpret_cast<Marker *> (marker_menu_item->get_data ("marker"))) == 0) {
1018                 fatal << _("programming error: marker canvas item has no marker object pointer!") << endmsg;
1019                 /*NOTREACHED*/
1020         }
1021
1022         if ((mm = dynamic_cast<MeterMarker*> (marker)) != 0) {
1023                 remove_meter_marker (marker_menu_item);
1024         } else if ((tm = dynamic_cast<TempoMarker*> (marker)) != 0) {
1025                 remove_tempo_marker (marker_menu_item);
1026         } else {
1027                 remove_marker (*marker_menu_item, (GdkEvent*) 0);
1028         }
1029 }
1030
1031 void
1032 Editor::marker_menu_lock (bool yn)
1033 {
1034
1035         Marker* marker;
1036
1037         if ((marker = reinterpret_cast<Marker *> (marker_menu_item->get_data ("marker"))) == 0) {
1038                 fatal << _("programming error: marker canvas item has no marker object pointer!") << endmsg;
1039                 /*NOTREACHED*/
1040         }
1041
1042         Location* loc;
1043         bool ignored;
1044
1045         loc = find_location_from_marker (marker, ignored);
1046
1047         if (!loc) return;
1048
1049         if (yn) {
1050                 loc->lock();
1051         } else {
1052                 loc->unlock ();
1053         }
1054 }
1055
1056 void
1057 Editor::marker_menu_rename ()
1058 {
1059         Marker* marker;
1060
1061         if ((marker = reinterpret_cast<Marker *> (marker_menu_item->get_data ("marker"))) == 0) {
1062                 fatal << _("programming error: marker canvas item has no marker object pointer!") << endmsg;
1063                 /*NOTREACHED*/
1064         }
1065
1066         Location* loc;
1067         bool is_start;
1068
1069         loc = find_location_from_marker (marker, is_start);
1070
1071         if (!loc) return;
1072
1073         ArdourPrompter dialog (true);
1074         string txt;
1075
1076         dialog.set_prompt (_("New Name:"));
1077
1078         WindowTitle title(Glib::get_application_name());
1079         if (loc->is_mark()) {
1080                 title += _("Rename Mark");
1081         } else {
1082                 title += _("Rename Range");
1083         }
1084
1085         dialog.set_title(title.get_string());
1086
1087         dialog.set_name ("MarkRenameWindow");
1088         dialog.set_size_request (250, -1);
1089         dialog.set_position (Gtk::WIN_POS_MOUSE);
1090
1091         dialog.add_button (_("Rename"), RESPONSE_ACCEPT);
1092         dialog.set_response_sensitive (Gtk::RESPONSE_ACCEPT, false);
1093         dialog.set_initial_text (loc->name());
1094
1095         dialog.show ();
1096
1097         switch (dialog.run ()) {
1098         case RESPONSE_ACCEPT:
1099                 break;
1100         default:
1101                 return;
1102         }
1103
1104         begin_reversible_command ( _("rename marker") );
1105         XMLNode &before = session->locations()->get_state();
1106
1107         dialog.get_result(txt);
1108         loc->set_name (txt);
1109
1110         XMLNode &after = session->locations()->get_state();
1111         session->add_command (new MementoCommand<Locations>(*(session->locations()), &before, &after));
1112         commit_reversible_command ();
1113 }
1114
1115 void
1116 Editor::new_transport_marker_menu_popdown ()
1117 {
1118         // hide rects
1119         transport_bar_drag_rect->hide();
1120         range_marker_drag_rect->hide();
1121 }
1122
1123 void
1124 Editor::new_transport_marker_menu_set_loop ()
1125 {
1126         set_loop_range (temp_location->start(), temp_location->end(), _("set loop range"));
1127 }
1128
1129 void
1130 Editor::new_transport_marker_menu_set_punch ()
1131 {
1132         set_punch_range (temp_location->start(), temp_location->end(), _("set punch range"));
1133 }
1134
1135 void
1136 Editor::update_loop_range_view (bool visibility)
1137 {
1138         if (session == 0) {
1139                 return;
1140         }
1141
1142         Location* tll;
1143
1144         if (session->get_play_loop() && ((tll = transport_loop_location()) != 0)) {
1145
1146                 double x1 = frame_to_pixel (tll->start());
1147                 double x2 = frame_to_pixel (tll->end());
1148
1149                 transport_loop_range_rect->property_x1() = x1;
1150                 transport_loop_range_rect->property_x2() = x2;
1151
1152                 if (visibility) {
1153                         transport_loop_range_rect->show();
1154                 }
1155
1156         } else if (visibility) {
1157                 transport_loop_range_rect->hide();
1158         }
1159 }
1160
1161 void
1162 Editor::update_punch_range_view (bool visibility)
1163 {
1164         if (session == 0) {
1165                 return;
1166         }
1167
1168         Location* tpl;
1169
1170         if ((Config->get_punch_in() || Config->get_punch_out()) && ((tpl = transport_punch_location()) != 0)) {
1171                 guint track_canvas_width,track_canvas_height;
1172                 track_canvas->get_size(track_canvas_width,track_canvas_height);
1173                 if (Config->get_punch_in()) {
1174                         transport_punch_range_rect->property_x1() = frame_to_pixel (tpl->start());
1175                         transport_punch_range_rect->property_x2() = (Config->get_punch_out() ? frame_to_pixel (tpl->end()) : frame_to_pixel (JACK_MAX_FRAMES));
1176                 } else {
1177                         transport_punch_range_rect->property_x1() = 0;
1178                         transport_punch_range_rect->property_x2() = (Config->get_punch_out() ? frame_to_pixel (tpl->end()) : track_canvas_width);
1179                 }
1180
1181                 if (visibility) {
1182                         transport_punch_range_rect->show();
1183                 }
1184         } else if (visibility) {
1185                 transport_punch_range_rect->hide();
1186         }
1187 }
1188
1189 void
1190 Editor::marker_selection_changed ()
1191 {
1192         if (session && session->deletion_in_progress()) {
1193                 return;
1194         }
1195
1196         for (LocationMarkerMap::iterator i = location_markers.begin(); i != location_markers.end(); ++i) {
1197                 LocationMarkers* lam = i->second;
1198
1199                 if (lam->start) {
1200                         lam->start->hide_line();
1201                 }
1202
1203                 if (lam->end) {
1204                         lam->end->hide_line();
1205                 }
1206         }
1207
1208         edit_point_clock_connection_a.disconnect();
1209         edit_point_clock_connection_b.disconnect();
1210
1211         if (selection->markers.empty()) {
1212                 edit_point_clock.set (0);
1213                 return;
1214         }
1215
1216         for (MarkerSelection::iterator x = selection->markers.begin(); x != selection->markers.end(); ++x) {
1217                 (*x)->add_line (cursor_group, 0, canvas_height);
1218                 (*x)->show_line ();
1219         }
1220
1221         edit_point_clock.set (selection->markers.front()->position());
1222
1223         bool ignored;
1224         Location* loc = find_location_from_marker (selection->markers.front(), ignored);
1225
1226         if (loc) {
1227                 edit_point_clock_connection_a = loc->changed.connect (mem_fun (*this, &Editor::selected_marker_moved));
1228                 edit_point_clock_connection_b = loc->start_changed.connect (mem_fun (*this, &Editor::selected_marker_moved));
1229         }
1230 }
1231
1232 void
1233 Editor::selected_marker_moved (Location* loc)
1234 {
1235         edit_point_clock.set (loc->start());
1236 }
1237
1238 struct SortLocationsByPosition {
1239     bool operator() (Location* a, Location* b) {
1240             return a->start() < b->start();
1241     }
1242 };
1243
1244 void
1245 Editor::goto_nth_marker (int n)
1246 {
1247         if (!session) {
1248                 return;
1249         }
1250         const Locations::LocationList& l (session->locations()->list());
1251         Locations::LocationList ordered;
1252         ordered = l;
1253
1254         SortLocationsByPosition cmp;
1255         ordered.sort (cmp);
1256
1257         for (Locations::LocationList::iterator i = ordered.begin(); n >= 0 && i != ordered.end(); ++i) {
1258                 if ((*i)->is_mark() && !(*i)->is_hidden() && !(*i)->is_start()) {
1259                         if (n == 0) {
1260                                 session->request_locate ((*i)->start(), session->transport_rolling());
1261                                 break;
1262                         }
1263                         --n;
1264                 }
1265         }
1266 }