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 (nframes_t startf,
 379                                        nframes_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 (nframes_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 (_("Hide"), mem_fun(*this, &Editor::marker_menu_hide)));
 601         if (start_or_end) return;
 602         items.push_back (MenuElem (_("Rename"), mem_fun(*this, &Editor::marker_menu_rename)));
 603         items.push_back (MenuElem (_("Lock"), bind (mem_fun(*this, &Editor::marker_menu_lock), true)));
 604         items.push_back (MenuElem (_("Unlock"), bind (mem_fun(*this, &Editor::marker_menu_lock), false)));
 605
 606         items.push_back (SeparatorElem());
 607
 608         items.push_back (MenuElem (_("Remove"), mem_fun(*this, &Editor::marker_menu_remove)));
 609 }
 610
 611 void
 612 Editor::build_range_marker_menu (bool loop_or_punch)
 613 {
 614         using namespace Menu_Helpers;
 615
 616         Menu *markerMenu = new Menu;
 617         if (loop_or_punch) {
 618                 transport_marker_menu = markerMenu;
 619         } else {
 620                 range_marker_menu = markerMenu;
 621         }
 622
 623         MenuList& items = markerMenu->items();
 624         markerMenu->set_name ("ArdourContextMenu");
 625
 626         items.push_back (MenuElem (_("Play Range"), mem_fun(*this, &Editor::marker_menu_play_range)));
 627         items.push_back (MenuElem (_("Locate to Range Mark"), mem_fun(*this, &Editor::marker_menu_set_playhead)));
 628         items.push_back (MenuElem (_("Play from Range Mark"), mem_fun(*this, &Editor::marker_menu_play_from)));
 629         if (!loop_or_punch) {
 630                 items.push_back (MenuElem (_("Loop Range"), mem_fun(*this, &Editor::marker_menu_loop_range)));
 631         }
 632         items.push_back (MenuElem (_("Set Range Mark from Playhead"), mem_fun(*this, &Editor::marker_menu_set_from_playhead)));
 633         if (!Profile->get_sae()) {
 634                 items.push_back (MenuElem (_("Set Range from Range Selection"), mem_fun(*this, &Editor::marker_menu_set_from_selection)));
 635         }
 636
 637         items.push_back (SeparatorElem());
 638
 639         if (!loop_or_punch) {
 640                 items.push_back (MenuElem (_("Hide Range"), mem_fun(*this, &Editor::marker_menu_hide)));
 641                 items.push_back (MenuElem (_("Rename Range"), mem_fun(*this, &Editor::marker_menu_rename)));
 642                 items.push_back (MenuElem (_("Remove Range"), mem_fun(*this, &Editor::marker_menu_remove)));
 643         }
 644
 645         items.push_back (SeparatorElem());
 646
 647         items.push_back (MenuElem (_("Separate Regions in Range"), mem_fun(*this, &Editor::marker_menu_separate_regions_using_location)));
 648         items.push_back (MenuElem (_("Select All in Range"), mem_fun(*this, &Editor::marker_menu_select_all_selectables_using_range)));
 649         if (!Profile->get_sae()) {
 650                 items.push_back (MenuElem (_("Select Range"), mem_fun(*this, &Editor::marker_menu_select_using_range)));
 651         }
 652 }
 653
 654 void
 655 Editor::build_tm_marker_menu ()
 656 {
 657         using namespace Menu_Helpers;
 658
 659         tm_marker_menu = new Menu;
 660         MenuList& items = tm_marker_menu->items();
 661         tm_marker_menu->set_name ("ArdourContextMenu");
 662
 663         items.push_back (MenuElem (_("Edit"), mem_fun(*this, &Editor::marker_menu_edit)));
 664         items.push_back (MenuElem (_("Remove"), mem_fun(*this, &Editor::marker_menu_remove)));
 665 }
 666
 667 void
 668 Editor::build_new_transport_marker_menu ()
 669 {
 670         using namespace Menu_Helpers;
 671
 672         new_transport_marker_menu = new Menu;
 673         MenuList& items = new_transport_marker_menu->items();
 674         new_transport_marker_menu->set_name ("ArdourContextMenu");
 675
 676         items.push_back (MenuElem (_("Set Loop Range"), mem_fun(*this, &Editor::new_transport_marker_menu_set_loop)));
 677         items.push_back (MenuElem (_("Set Punch Range"), mem_fun(*this, &Editor::new_transport_marker_menu_set_punch)));
 678
 679         new_transport_marker_menu->signal_unmap_event().connect ( mem_fun(*this, &Editor::new_transport_marker_menu_popdown));
 680 }
 681
 682 void
 683 Editor::marker_menu_hide ()
 684 {
 685         Marker* marker;
 686
 687         if ((marker = reinterpret_cast<Marker *> (marker_menu_item->get_data ("marker"))) == 0) {
 688                 fatal << _("programming error: marker canvas item has no marker object pointer!") << endmsg;
 689                 /*NOTREACHED*/
 690         }
 691
 692         Location* l;
 693         bool is_start;
 694
 695         if ((l = find_location_from_marker (marker, is_start)) != 0) {
 696                 l->set_hidden (true, this);
 697         }
 698 }
 699
 700 void
 701 Editor::marker_menu_select_using_range ()
 702 {
 703         Marker* marker;
 704
 705         if ((marker = reinterpret_cast<Marker *> (marker_menu_item->get_data ("marker"))) == 0) {
 706                 fatal << _("programming error: marker canvas item has no marker object pointer!") << endmsg;
 707                 /*NOTREACHED*/
 708         }
 709
 710         Location* l;
 711         bool is_start;
 712
 713         if (((l = find_location_from_marker (marker, is_start)) != 0) && (l->end() > l->start())) {
 714                 set_selection_from_range (*l);
 715         }
 716 }
 717
 718 void
 719 Editor::marker_menu_select_all_selectables_using_range ()
 720 {
 721         Marker* marker;
 722
 723         if ((marker = reinterpret_cast<Marker *> (marker_menu_item->get_data ("marker"))) == 0) {
 724                 fatal << _("programming error: marker canvas item has no marker object pointer!") << endmsg;
 725                 /*NOTREACHED*/
 726         }
 727
 728         Location* l;
 729         bool is_start;
 730
 731         if (((l = find_location_from_marker (marker, is_start)) != 0) && (l->end() > l->start())) {
 732                 select_all_within (l->start(), l->end() - 1, 0,  DBL_MAX, track_views, Selection::Set);
 733         }
 734
 735 }
 736
 737 void
 738 Editor::marker_menu_separate_regions_using_location ()
 739 {
 740         Marker* marker;
 741
 742         if ((marker = reinterpret_cast<Marker *> (marker_menu_item->get_data ("marker"))) == 0) {
 743                 fatal << _("programming error: marker canvas item has no marker object pointer!") << endmsg;
 744                 /*NOTREACHED*/
 745         }
 746
 747         Location* l;
 748         bool is_start;
 749
 750         if (((l = find_location_from_marker (marker, is_start)) != 0) && (l->end() > l->start())) {
 751                 separate_regions_using_location (*l);
 752         }
 753
 754 }
 755
 756 void
 757 Editor::marker_menu_play_from ()
 758 {
 759         Marker* marker;
 760
 761         if ((marker = reinterpret_cast<Marker *> (marker_menu_item->get_data ("marker"))) == 0) {
 762                 fatal << _("programming error: marker canvas item has no marker object pointer!") << endmsg;
 763                 /*NOTREACHED*/
 764         }
 765
 766         Location* l;
 767         bool is_start;
 768
 769         if ((l = find_location_from_marker (marker, is_start)) != 0) {
 770
 771                 if (l->is_mark()) {
 772                         session->request_locate (l->start(), true);
 773                 }
 774                 else {
 775                         //session->request_bounded_roll (l->start(), l->end());
 776
 777                         if (is_start) {
 778                                 session->request_locate (l->start(), true);
 779                         } else {
 780                                 session->request_locate (l->end(), true);
 781                         }
 782                 }
 783         }
 784 }
 785
 786 void
 787 Editor::marker_menu_set_playhead ()
 788 {
 789         Marker* marker;
 790
 791         if ((marker = reinterpret_cast<Marker *> (marker_menu_item->get_data ("marker"))) == 0) {
 792                 fatal << _("programming error: marker canvas item has no marker object pointer!") << endmsg;
 793                 /*NOTREACHED*/
 794         }
 795
 796         Location* l;
 797         bool is_start;
 798
 799         if ((l = find_location_from_marker (marker, is_start)) != 0) {
 800
 801                 if (l->is_mark()) {
 802                         session->request_locate (l->start(), false);
 803                 }
 804                 else {
 805                         if (is_start) {
 806                                 session->request_locate (l->start(), false);
 807                         } else {
 808                                 session->request_locate (l->end(), false);
 809                         }
 810                 }
 811         }
 812 }
 813
 814 void
 815 Editor::marker_menu_set_from_playhead ()
 816 {
 817         Marker* marker;
 818
 819         if ((marker = reinterpret_cast<Marker *> (marker_menu_item->get_data ("marker"))) == 0) {
 820                 fatal << _("programming error: marker canvas item has no marker object pointer!") << endmsg;
 821                 /*NOTREACHED*/
 822         }
 823
 824         Location* l;
 825         bool is_start;
 826
 827         if ((l = find_location_from_marker (marker, is_start)) != 0) {
 828
 829                 if (l->is_mark()) {
 830                         l->set_start (session->audible_frame ());
 831                 }
 832                 else {
 833                         if (is_start) {
 834                                 l->set_start (session->audible_frame ());
 835                         } else {
 836                                 l->set_end (session->audible_frame ());
 837                         }
 838                 }
 839         }
 840 }
 841
 842 void
 843 Editor::marker_menu_set_from_selection ()
 844 {
 845         Marker* marker;
 846
 847         if ((marker = reinterpret_cast<Marker *> (marker_menu_item->get_data ("marker"))) == 0) {
 848                 fatal << _("programming error: marker canvas item has no marker object pointer!") << endmsg;
 849                 /*NOTREACHED*/
 850         }
 851
 852         Location* l;
 853         bool is_start;
 854
 855         if ((l = find_location_from_marker (marker, is_start)) != 0) {
 856
 857                 if (l->is_mark()) {
 858                         // nothing for now
 859                 } else {
 860
 861                         /* if range selection use first to last */
 862
 863                         if (mouse_mode == Editing::MouseRange) {
 864                                 if (!selection->time.empty()) {
 865                                         l->set_start (selection->time.start());
 866                                         l->set_end (selection->time.end_frame());
 867                                 }
 868                         }
 869                         else {
 870                                 if (!selection->regions.empty()) {
 871                                         l->set_start (selection->regions.start());
 872                                         l->set_end (selection->regions.end_frame());
 873                                 }
 874                         }
 875                 }
 876         }
 877 }
 878
 879
 880 void
 881 Editor::marker_menu_play_range ()
 882 {
 883         Marker* marker;
 884
 885         if ((marker = reinterpret_cast<Marker *> (marker_menu_item->get_data ("marker"))) == 0) {
 886                 fatal << _("programming error: marker canvas item has no marker object pointer!") << endmsg;
 887                 /*NOTREACHED*/
 888         }
 889
 890         Location* l;
 891         bool is_start;
 892
 893         if ((l = find_location_from_marker (marker, is_start)) != 0) {
 894
 895                 if (l->is_mark()) {
 896                         session->request_locate (l->start(), true);
 897                 }
 898                 else {
 899                         session->request_bounded_roll (l->start(), l->end());
 900
 901                 }
 902         }
 903 }
 904
 905 void
 906 Editor::marker_menu_loop_range ()
 907 {
 908         Marker* marker;
 909
 910         if ((marker = reinterpret_cast<Marker *> (marker_menu_item->get_data ("marker"))) == 0) {
 911                 fatal << _("programming error: marker canvas item has no marker object pointer!") << endmsg;
 912                 /*NOTREACHED*/
 913         }
 914
 915         Location* l;
 916         bool is_start;
 917
 918         if ((l = find_location_from_marker (marker, is_start)) != 0) {
 919                 Location* l2;
 920                 if ((l2 = transport_loop_location()) != 0) {
 921                         l2->set (l->start(), l->end());
 922
 923                         // enable looping, reposition and start rolling
 924                         session->request_play_loop(true);
 925                         session->request_locate (l2->start(), true);
 926                 }
 927         }
 928 }
 929
 930 void
 931 Editor::marker_menu_edit ()
 932 {
 933         MeterMarker* mm;
 934         TempoMarker* tm;
 935         Marker* marker;
 936
 937         if ((marker = reinterpret_cast<Marker *> (marker_menu_item->get_data ("marker"))) == 0) {
 938                 fatal << _("programming error: marker canvas item has no marker object pointer!") << endmsg;
 939                 /*NOTREACHED*/
 940         }
 941
 942         if ((mm = dynamic_cast<MeterMarker*> (marker)) != 0) {
 943                 edit_meter_section (&mm->meter());
 944         } else if ((tm = dynamic_cast<TempoMarker*> (marker)) != 0) {
 945                 edit_tempo_section (&tm->tempo());
 946         } else {
 947                 fatal << X_("programming erorr: unhandled marker type in Editor::marker_menu_edit")
 948                       << endmsg;
 949                 /*NOTREACHED*/
 950         }
 951 }
 952
 953 void
 954 Editor::marker_menu_remove ()
 955 {
 956         MeterMarker* mm;
 957         TempoMarker* tm;
 958         Marker* marker;
 959
 960         if ((marker = reinterpret_cast<Marker *> (marker_menu_item->get_data ("marker"))) == 0) {
 961                 fatal << _("programming error: marker canvas item has no marker object pointer!") << endmsg;
 962                 /*NOTREACHED*/
 963         }
 964
 965         if ((mm = dynamic_cast<MeterMarker*> (marker)) != 0) {
 966                 remove_meter_marker (marker_menu_item);
 967         } else if ((tm = dynamic_cast<TempoMarker*> (marker)) != 0) {
 968                 remove_tempo_marker (marker_menu_item);
 969         } else {
 970                 remove_marker (*marker_menu_item, (GdkEvent*) 0);
 971         }
 972 }
 973
 974 void
 975 Editor::marker_menu_lock (bool yn)
 976 {
 977
 978         Marker* marker;
 979
 980         if ((marker = reinterpret_cast<Marker *> (marker_menu_item->get_data ("marker"))) == 0) {
 981                 fatal << _("programming error: marker canvas item has no marker object pointer!") << endmsg;
 982                 /*NOTREACHED*/
 983         }
 984
 985         Location* loc;
 986         bool ignored;
 987
 988         loc = find_location_from_marker (marker, ignored);
 989
 990         if (!loc) return;
 991
 992         if (yn) {
 993                 loc->lock();
 994         } else {
 995                 loc->unlock ();
 996         }
 997 }
 998
 999 void
1000 Editor::marker_menu_rename ()
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* loc;
1010         bool is_start;
1011
1012         loc = find_location_from_marker (marker, is_start);
1013
1014         if (!loc) return;
1015
1016         ArdourPrompter dialog (true);
1017         string txt;
1018
1019         dialog.set_prompt (_("New Name:"));
1020
1021         WindowTitle title(Glib::get_application_name());
1022         if (loc->is_mark()) {
1023                 title += _("Rename Mark");
1024         } else {
1025                 title += _("Rename Range");
1026         }
1027
1028         dialog.set_title(title.get_string());
1029
1030         dialog.set_name ("MarkRenameWindow");
1031         dialog.set_size_request (250, -1);
1032         dialog.set_position (Gtk::WIN_POS_MOUSE);
1033
1034         dialog.add_button (_("Rename"), RESPONSE_ACCEPT);
1035         dialog.set_response_sensitive (Gtk::RESPONSE_ACCEPT, false);
1036         dialog.set_initial_text (loc->name());
1037
1038         dialog.show ();
1039
1040         switch (dialog.run ()) {
1041         case RESPONSE_ACCEPT:
1042                 break;
1043         default:
1044                 return;
1045         }
1046
1047         begin_reversible_command ( _("rename marker") );
1048         XMLNode &before = session->locations()->get_state();
1049
1050         dialog.get_result(txt);
1051         loc->set_name (txt);
1052
1053         XMLNode &after = session->locations()->get_state();
1054         session->add_command (new MementoCommand<Locations>(*(session->locations()), &before, &after));
1055         commit_reversible_command ();
1056 }
1057
1058 gint
1059 Editor::new_transport_marker_menu_popdown (GdkEventAny *ev)
1060 {
1061         // hide rects
1062         transport_bar_drag_rect->hide();
1063         range_marker_drag_rect->hide();
1064
1065         return FALSE;
1066 }
1067
1068 void
1069 Editor::new_transport_marker_menu_set_loop ()
1070 {
1071         set_loop_range (temp_location->start(), temp_location->end(), _("set loop range"));
1072 }
1073
1074 void
1075 Editor::new_transport_marker_menu_set_punch ()
1076 {
1077         set_punch_range (temp_location->start(), temp_location->end(), _("set punch range"));
1078 }
1079
1080 void
1081 Editor::update_loop_range_view (bool visibility)
1082 {
1083         if (session == 0) {
1084                 return;
1085         }
1086
1087         Location* tll;
1088
1089         if (session->get_play_loop() && ((tll = transport_loop_location()) != 0)) {
1090
1091                 double x1 = frame_to_pixel (tll->start());
1092                 double x2 = frame_to_pixel (tll->end());
1093
1094                 transport_loop_range_rect->property_x1() = x1;
1095                 transport_loop_range_rect->property_x2() = x2;
1096
1097                 if (visibility) {
1098                         transport_loop_range_rect->show();
1099                 }
1100
1101         } else if (visibility) {
1102                 transport_loop_range_rect->hide();
1103         }
1104 }
1105
1106 void
1107 Editor::update_punch_range_view (bool visibility)
1108 {
1109         if (session == 0) {
1110                 return;
1111         }
1112
1113         Location* tpl;
1114
1115         if ((Config->get_punch_in() || Config->get_punch_out()) && ((tpl = transport_punch_location()) != 0)) {
1116
1117                 double x1 = frame_to_pixel (tpl->start());
1118                 double x2 = frame_to_pixel (tpl->end());
1119
1120                 guint track_canvas_width,track_canvas_height;
1121                 track_canvas->get_size(track_canvas_width,track_canvas_height);
1122
1123                 transport_punch_range_rect->property_x1() = x1;
1124                 transport_punch_range_rect->property_x2() = x2;
1125
1126                 transport_punch_range_rect->property_x1() = (Config->get_punch_in() ? x1 : 0);
1127                 transport_punch_range_rect->property_x2() = (Config->get_punch_out() ? x2 : track_canvas_width);
1128
1129                 if (visibility) {
1130                         transport_punch_range_rect->show();
1131                 }
1132         }
1133         else if (visibility) {
1134                 transport_punch_range_rect->hide();
1135         }
1136
1137 //      if (session->get_punch_in()) {
1138 //              double x = frame_to_pixel (transport_punch_location->start());
1139 //              gnome_canvas_item_set (transport_punchin_line, "x1", x, "x2", x, NULL);
1140
1141 //              if (visibility) {
1142 //                      gnome_canvas_item_show (transport_punchin_line);
1143 //              }
1144 //      }
1145 //      else if (visibility) {
1146 //              gnome_canvas_item_hide (transport_punchin_line);
1147 //      }
1148
1149 //      if (session->get_punch_out()) {
1150 //              double x = frame_to_pixel (transport_punch_location->end());
1151
1152 //              gnome_canvas_item_set (transport_punchout_line, "x1", x, "x2", x, NULL);
1153
1154 //              if (visibility) {
1155 //                      gnome_canvas_item_show (transport_punchout_line);
1156 //              }
1157 //      }
1158 //      else if (visibility) {
1159 //              gnome_canvas_item_hide (transport_punchout_line);
1160 //      }
1161 }
1162
1163 void
1164 Editor::marker_selection_changed ()
1165 {
1166         if (session && session->deletion_in_progress()) {
1167                 return;
1168         }
1169
1170         for (LocationMarkerMap::iterator i = location_markers.begin(); i != location_markers.end(); ++i) {
1171                 LocationMarkers* lam = i->second;
1172
1173                 if (lam->start) {
1174                         lam->start->hide_line();
1175                 }
1176
1177                 if (lam->end) {
1178                         lam->end->hide_line();
1179                 }
1180         }
1181
1182         edit_point_clock_connection_a.disconnect();
1183         edit_point_clock_connection_b.disconnect();
1184
1185         if (selection->markers.empty()) {
1186                 edit_point_clock.set (0);
1187                 return;
1188         }
1189
1190         for (MarkerSelection::iterator x = selection->markers.begin(); x != selection->markers.end(); ++x) {
1191                 (*x)->add_line (cursor_group, vertical_adjustment.get_value(), canvas_height);
1192                 (*x)->show_line ();
1193         }
1194
1195         edit_point_clock.set (selection->markers.front()->position());
1196
1197         bool ignored;
1198         Location* loc = find_location_from_marker (selection->markers.front(), ignored);
1199
1200         if (loc) {
1201                 edit_point_clock_connection_a = loc->changed.connect (mem_fun (*this, &Editor::selected_marker_moved));
1202                 edit_point_clock_connection_b = loc->start_changed.connect (mem_fun (*this, &Editor::selected_marker_moved));
1203         }
1204 }
1205
1206 void
1207 Editor::selected_marker_moved (Location* loc)
1208 {
1209         edit_point_clock.set (loc->start());
1210 }
1211
1212 struct SortLocationsByPosition {
1213     bool operator() (Location* a, Location* b) {
1214             return a->start() < b->start();
1215     }
1216 };
1217
1218 void
1219 Editor::goto_nth_marker (int n)
1220 {
1221         if (!session) {
1222                 return;
1223         }
1224         const Locations::LocationList& l (session->locations()->list());
1225         Locations::LocationList ordered;
1226         ordered = l;
1227
1228         SortLocationsByPosition cmp;
1229         ordered.sort (cmp);
1230
1231         for (Locations::LocationList::iterator i = ordered.begin(); n >= 0 && i != ordered.end(); ++i) {
1232                 if ((*i)->is_mark() && !(*i)->is_hidden() && !(*i)->is_start()) {
1233                         if (n == 0) {
1234                                 session->request_locate ((*i)->start(), session->transport_rolling());
1235                                 break;
1236                         }
1237                         --n;
1238                 }
1239         }
1240 }