libs/ardour/location.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     $Id$
  19 */
  20
  21 #include <algorithm>
  22 #include <set>
  23 #include <cstdio> /* for sprintf */
  24 #include <unistd.h>
  25 #include <cerrno>
  26 #include <ctime>
  27 #include <sigc++/bind.h>
  28
  29 #include <pbd/stl_delete.h>
  30 #include <pbd/xml++.h>
  31
  32 #include <ardour/location.h>
  33 #include <ardour/session.h>
  34 #include <ardour/audiofilesource.h>
  35
  36 #include "i18n.h"
  37
  38 using namespace std;
  39 using namespace ARDOUR;
  40 using namespace sigc;
  41 using namespace PBD;
  42
  43 Location::Location (const Location& other)
  44         : _name (other._name),
  45           _start (other._start),
  46           _end (other._end),
  47           _flags (other._flags)
  48 {
  49         /* start and end flags can never be copied, because there can only ever be one of each */
  50
  51         _flags = Flags (_flags & ~IsStart);
  52         _flags = Flags (_flags & ~IsEnd);
  53 }
  54
  55 Location::Location (const XMLNode& node)
  56 {
  57         if (set_state (node)) {
  58                 throw failed_constructor ();
  59         }
  60 }
  61
  62 Location*
  63 Location::operator= (const Location& other)
  64 {
  65         if (this == &other) {
  66                 return this;
  67         }
  68
  69         _name = other._name;
  70         _start = other._start;
  71         _end = other._end;
  72         _flags = other._flags;
  73
  74         /* "changed" not emitted on purpose */
  75
  76         return this;
  77 }
  78
  79 int
  80 Location::set_start (nframes_t s)
  81 {
  82         if (is_mark()) {
  83                 if (_start != s) {
  84
  85                         _start = s;
  86                         _end = s;
  87
  88                         start_changed(this); /* EMIT SIGNAL */
  89
  90                         if ( is_start() ) {
  91
  92                                 Session::StartTimeChanged (); /* EMIT SIGNAL */
  93                                 AudioFileSource::set_header_position_offset ( s );
  94                         }
  95
  96                         if ( is_end() ) {
  97                                 Session::EndTimeChanged (); /* EMIT SIGNAL */
  98                         }
  99                 }
 100                 return 0;
 101         }
 102
 103         if (((is_auto_punch() || is_auto_loop()) && s >= _end) || s > _end) {
 104                 return -1;
 105         }
 106
 107         if (s != _start) {
 108                 _start = s;
 109                 start_changed(this); /* EMIT SIGNAL */
 110         }
 111
 112         return 0;
 113 }
 114
 115 int
 116 Location::set_end (nframes_t e)
 117 {
 118         if (is_mark()) {
 119                 if (_start != e) {
 120                         _start = e;
 121                         _end = e;
 122                         end_changed(this); /* EMIT SIGNAL */
 123                 }
 124                 return 0;
 125         }
 126
 127         if (((is_auto_punch() || is_auto_loop()) && e <= _start) || e < _start) {
 128                 return -1;
 129         }
 130
 131         if (e != _end) {
 132                 _end = e;
 133                  end_changed(this); /* EMIT SIGNAL */
 134         }
 135         return 0;
 136 }
 137
 138 int
 139 Location::set (nframes_t start, nframes_t end)
 140 {
 141         if (is_mark() && start != end) {
 142                 return -1;
 143         } else if (((is_auto_punch() || is_auto_loop()) && start >= end) || (start > end)) {
 144                 return -1;
 145         }
 146
 147         if (_start != start) {
 148                 _start = start;
 149                 start_changed(this); /* EMIT SIGNAL */
 150         }
 151
 152         if (_end != end) {
 153                 _end = end;
 154                 end_changed(this); /* EMIT SIGNAL */
 155         }
 156         return 0;
 157 }
 158
 159 void
 160 Location::set_hidden (bool yn, void *src)
 161 {
 162         if (set_flag_internal (yn, IsHidden)) {
 163                  FlagsChanged (this, src); /* EMIT SIGNAL */
 164         }
 165 }
 166
 167 void
 168 Location::set_cd (bool yn, void *src)
 169 {
 170         if (set_flag_internal (yn, IsCDMarker)) {
 171                  FlagsChanged (this, src); /* EMIT SIGNAL */
 172         }
 173 }
 174
 175 void
 176 Location::set_is_end (bool yn, void *src)
 177 {
 178         if (set_flag_internal (yn, IsEnd)) {
 179                  FlagsChanged (this, src); /* EMIT SIGNAL */
 180         }
 181 }
 182
 183 void
 184 Location::set_is_start (bool yn, void *src)
 185 {
 186         if (set_flag_internal (yn, IsStart)) {
 187                  FlagsChanged (this, src); /* EMIT SIGNAL */
 188         }
 189 }
 190
 191 void
 192 Location::set_auto_punch (bool yn, void *src)
 193 {
 194         if (is_mark() || _start == _end) {
 195                 return;
 196         }
 197
 198         if (set_flag_internal (yn, IsAutoPunch)) {
 199                  FlagsChanged (this, src); /* EMIT SIGNAL */
 200         }
 201 }
 202
 203 void
 204 Location::set_auto_loop (bool yn, void *src)
 205 {
 206         if (is_mark() || _start == _end) {
 207                 return;
 208         }
 209
 210         if (set_flag_internal (yn, IsAutoLoop)) {
 211                  FlagsChanged (this, src); /* EMIT SIGNAL */
 212         }
 213 }
 214
 215 bool
 216 Location::set_flag_internal (bool yn, Flags flag)
 217 {
 218         if (yn) {
 219                 if (!(_flags & flag)) {
 220                         _flags |= flag;
 221                         return true;
 222                 }
 223         } else {
 224                 if (_flags & flag) {
 225                         _flags &= ~flag;
 226                         return true;
 227                 }
 228         }
 229         return false;
 230 }
 231
 232 void
 233 Location::set_mark (bool yn)
 234 {
 235         /* This function is private, and so does not emit signals */
 236
 237         if (_start != _end) {
 238                 return;
 239         }
 240
 241         set_flag_internal (yn, IsMark);
 242 }
 243
 244
 245 XMLNode&
 246 Location::cd_info_node(const string & name, const string & value)
 247 {
 248         XMLNode* root = new XMLNode("CD-Info");
 249
 250         root->add_property("name", name);
 251         root->add_property("value", value);
 252
 253         return *root;
 254 }
 255
 256
 257 XMLNode&
 258 Location::get_state (void)
 259 {
 260         XMLNode *node = new XMLNode ("Location");
 261         char buf[64];
 262
 263         typedef map<string, string>::const_iterator CI;
 264
 265         for(CI m = cd_info.begin(); m != cd_info.end(); ++m){
 266                 node->add_child_nocopy(cd_info_node(m->first, m->second));
 267         }
 268
 269         id().print (buf, sizeof (buf));
 270         node->add_property("id", buf);
 271         node->add_property ("name", name());
 272         snprintf (buf, sizeof (buf), "%u", start());
 273         node->add_property ("start", buf);
 274         snprintf (buf, sizeof (buf), "%u", end());
 275         node->add_property ("end", buf);
 276         snprintf (buf, sizeof (buf), "%" PRIu32, (uint32_t) _flags);
 277         node->add_property ("flags", buf);
 278
 279         return *node;
 280 }
 281
 282 int
 283 Location::set_state (const XMLNode& node)
 284 {
 285         const XMLProperty *prop;
 286
 287         XMLNodeList cd_list = node.children();
 288         XMLNodeConstIterator cd_iter;
 289         XMLNode *cd_node;
 290
 291         string cd_name;
 292         string cd_value;
 293
 294         if (node.name() != "Location") {
 295                 error << _("incorrect XML node passed to Location::set_state") << endmsg;
 296                 return -1;
 297         }
 298
 299         if ((prop = node.property ("id")) == 0) {
 300                 warning << _("XML node for Location has no ID information") << endmsg;
 301         } else {
 302                 _id = prop->value ();
 303         }
 304
 305         if ((prop = node.property ("name")) == 0) {
 306                 error << _("XML node for Location has no name information") << endmsg;
 307                 return -1;
 308         }
 309
 310         set_name (prop->value());
 311
 312         if ((prop = node.property ("start")) == 0) {
 313                 error << _("XML node for Location has no start information") << endmsg;
 314                 return -1;
 315         }
 316
 317                 /* can't use set_start() here, because _end
 318                    may make the value of _start illegal.
 319                 */
 320
 321         _start = atoi (prop->value().c_str());
 322
 323         if ((prop = node.property ("end")) == 0) {
 324                   error << _("XML node for Location has no end information") << endmsg;
 325                   return -1;
 326         }
 327
 328         _end = atoi (prop->value().c_str());
 329
 330         _flags = 0;
 331
 332         if ((prop = node.property ("flags")) == 0) {
 333                   error << _("XML node for Location has no flags information") << endmsg;
 334                   return -1;
 335         }
 336
 337         _flags = Flags (atoi (prop->value().c_str()));
 338
 339         for (cd_iter = cd_list.begin(); cd_iter != cd_list.end(); ++cd_iter) {
 340
 341                   cd_node = *cd_iter;
 342
 343                   if (cd_node->name() != "CD-Info") {
 344                     continue;
 345                   }
 346
 347                   if ((prop = cd_node->property ("name")) != 0) {
 348                     cd_name = prop->value();
 349                   } else {
 350                     throw failed_constructor ();
 351                   }
 352
 353                   if ((prop = cd_node->property ("value")) != 0) {
 354                     cd_value = prop->value();
 355                   } else {
 356                     throw failed_constructor ();
 357                   }
 358
 359
 360                   cd_info[cd_name] = cd_value;
 361
 362         }
 363
 364         changed(this); /* EMIT SIGNAL */
 365
 366         return 0;
 367 }
 368
 369 /*---------------------------------------------------------------------- */
 370
 371 Locations::Locations ()
 372
 373 {
 374         current_location = 0;
 375 #ifdef STATE_MANAGER
 376         save_state (_("initial"));
 377 #endif
 378 }
 379
 380 Locations::~Locations ()
 381 {
 382         for (LocationList::iterator i = locations.begin(); i != locations.end(); ) {
 383                 LocationList::iterator tmp = i;
 384                 ++tmp;
 385                 delete *i;
 386                 i = tmp;
 387         }
 388
 389 #ifdef STATE_MANAGER
 390
 391         std::set<Location*> all_locations;
 392
 393
 394         for (StateMap::iterator siter = states.begin(); siter != states.end(); ++siter) {
 395
 396                 State* lstate = dynamic_cast<State*> (*siter);
 397
 398                 for (LocationList::iterator liter = lstate->locations.begin(); liter != lstate->locations.end(); ++liter) {
 399                         all_locations.insert (*liter);
 400                 }
 401
 402                 for (LocationList::iterator siter = lstate->states.begin(); siter != lstate->states.end(); ++siter) {
 403                         all_locations.insert (*siter);
 404                 }
 405         }
 406
 407         set_delete (&all_locations);
 408 #endif
 409 }
 410
 411 int
 412 Locations::set_current (Location *loc, bool want_lock)
 413
 414 {
 415         int ret;
 416
 417         if (want_lock) {
 418                 Glib::Mutex::Lock lm (lock);
 419                 ret = set_current_unlocked (loc);
 420         } else {
 421                 ret = set_current_unlocked (loc);
 422         }
 423
 424         if (ret == 0) {
 425                  current_changed (current_location); /* EMIT SIGNAL */
 426         }
 427         return ret;
 428 }
 429
 430 int
 431 Locations::set_current_unlocked (Location *loc)
 432 {
 433         if (find (locations.begin(), locations.end(), loc) == locations.end()) {
 434                 error << _("Locations: attempt to use unknown location as selected location") << endmsg;
 435                 return -1;
 436         }
 437
 438         current_location = loc;
 439         return 0;
 440 }
 441
 442 void
 443 Locations::clear ()
 444 {
 445         {
 446                 Glib::Mutex::Lock lm (lock);
 447                 LocationList::iterator tmp;
 448                 for (LocationList::iterator i = locations.begin(); i != locations.end(); ) {
 449                         tmp = i;
 450                         ++tmp;
 451                         if (!(*i)->is_end() && !(*i)->is_start()) {
 452                                 locations.erase (i);
 453                         }
 454                         i = tmp;
 455                 }
 456
 457                 locations.clear ();
 458                 current_location = 0;
 459         }
 460
 461 #ifdef STATE_MANAGER
 462         save_state (_("clear"));
 463 #endif
 464
 465         changed (); /* EMIT SIGNAL */
 466         current_changed (0); /* EMIT SIGNAL */
 467 }
 468
 469 void
 470 Locations::clear_markers ()
 471 {
 472         {
 473                 Glib::Mutex::Lock lm (lock);
 474                 LocationList::iterator tmp;
 475
 476                 for (LocationList::iterator i = locations.begin(); i != locations.end(); ) {
 477                         tmp = i;
 478                         ++tmp;
 479
 480                         if ((*i)->is_mark() && !(*i)->is_end() && !(*i)->is_start()) {
 481                                 locations.erase (i);
 482                         }
 483
 484                         i = tmp;
 485                 }
 486         }
 487
 488 #ifdef STATE_MANAGER
 489         save_state (_("clear markers"));
 490 #endif
 491
 492         changed (); /* EMIT SIGNAL */
 493 }
 494
 495 void
 496 Locations::clear_ranges ()
 497 {
 498         {
 499                 Glib::Mutex::Lock lm (lock);
 500                 LocationList::iterator tmp;
 501
 502                 for (LocationList::iterator i = locations.begin(); i != locations.end(); ) {
 503
 504                         tmp = i;
 505                         ++tmp;
 506
 507                         if (!(*i)->is_mark()) {
 508                                 locations.erase (i);
 509
 510                         }
 511
 512                         i = tmp;
 513                 }
 514
 515                 current_location = 0;
 516         }
 517
 518 #ifdef STATE_MANAGER
 519         save_state (_("clear ranges"));
 520 #endif
 521
 522         changed (); /* EMIT SIGNAL */
 523         current_changed (0); /* EMIT SIGNAL */
 524 }
 525
 526 void
 527 Locations::add (Location *loc, bool make_current)
 528 {
 529         {
 530                 Glib::Mutex::Lock lm (lock);
 531                 locations.push_back (loc);
 532
 533                 if (make_current) {
 534                         current_location = loc;
 535                 }
 536         }
 537
 538 #ifdef STATE_MANAGER
 539         save_state (_("add"));
 540 #endif
 541
 542         added (loc); /* EMIT SIGNAL */
 543
 544         if (make_current) {
 545                  current_changed (current_location); /* EMIT SIGNAL */
 546         }
 547 }
 548
 549 void
 550 Locations::remove (Location *loc)
 551
 552 {
 553         bool was_removed = false;
 554         bool was_current = false;
 555         LocationList::iterator i;
 556
 557         if (loc->is_end() || loc->is_start()) {
 558                 return;
 559         }
 560
 561         {
 562                 Glib::Mutex::Lock lm (lock);
 563
 564                 for (i = locations.begin(); i != locations.end(); ++i) {
 565                         if ((*i) == loc) {
 566                                 locations.erase (i);
 567                                 was_removed = true;
 568                                 if (current_location == loc) {
 569                                         current_location = 0;
 570                                         was_current = true;
 571                                 }
 572                                 break;
 573                         }
 574                 }
 575         }
 576
 577         if (was_removed) {
 578 #ifdef STATE_MANAGER
 579                 save_state (_("remove"));
 580 #endif
 581
 582                  removed (loc); /* EMIT SIGNAL */
 583
 584                 if (was_current) {
 585                          current_changed (0); /* EMIT SIGNAL */
 586                 }
 587
 588                 changed (); /* EMIT_SIGNAL */
 589         }
 590 }
 591
 592 void
 593 Locations::location_changed (Location* loc)
 594 {
 595 #ifdef STATE_MANAGER
 596         save_state (X_("location changed"));
 597 #endif
 598         changed (); /* EMIT SIGNAL */
 599 }
 600
 601 XMLNode&
 602 Locations::get_state ()
 603 {
 604         XMLNode *node = new XMLNode ("Locations");
 605         LocationList::iterator iter;
 606         Glib::Mutex::Lock lm (lock);
 607
 608         for (iter  = locations.begin(); iter != locations.end(); ++iter) {
 609                 node->add_child_nocopy ((*iter)->get_state ());
 610         }
 611
 612         return *node;
 613 }
 614
 615 int
 616 Locations::set_state (const XMLNode& node)
 617 {
 618         XMLNodeList nlist;
 619         XMLNodeConstIterator niter;
 620
 621         if (node.name() != "Locations") {
 622                 error << _("incorrect XML mode passed to Locations::set_state") << endmsg;
 623                 return -1;
 624         }
 625
 626         nlist = node.children();
 627
 628         {
 629                 Glib::Mutex::Lock lm (lock);
 630
 631                 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
 632
 633                         try {
 634
 635                                 Location *loc = new Location (**niter);
 636                                 locations.push_back (loc);
 637                         }
 638
 639                         catch (failed_constructor& err) {
 640                                 error << _("could not load location from session file - ignored") << endmsg;
 641                         }
 642                 }
 643
 644                 if (locations.size()) {
 645
 646                         current_location = locations.front();
 647                 } else {
 648                         current_location = 0;
 649                 }
 650         }
 651
 652         changed (); /* EMIT SIGNAL */
 653
 654         return 0;
 655 }
 656
 657 struct LocationStartEarlierComparison
 658 {
 659     bool operator() (Location *a, Location *b) {
 660         return a->start() < b->start();
 661     }
 662 };
 663
 664 struct LocationStartLaterComparison
 665 {
 666     bool operator() (Location *a, Location *b) {
 667         return a->start() > b->start();
 668     }
 669 };
 670
 671 Location *
 672 Locations::first_location_before (nframes_t frame)
 673 {
 674         LocationList locs;
 675
 676         {
 677                 Glib::Mutex::Lock lm (lock);
 678                 locs = locations;
 679         }
 680
 681         LocationStartLaterComparison cmp;
 682         locs.sort (cmp);
 683
 684         /* locs is now sorted latest..earliest */
 685
 686         for (LocationList::iterator i = locs.begin(); i != locs.end(); ++i) {
 687                 if (!(*i)->is_hidden() && (*i)->start() < frame) {
 688                         return (*i);
 689                 }
 690         }
 691
 692         return 0;
 693 }
 694
 695 Location *
 696 Locations::first_location_after (nframes_t frame)
 697 {
 698         LocationList locs;
 699
 700         {
 701                 Glib::Mutex::Lock lm (lock);
 702                 locs = locations;
 703         }
 704
 705         LocationStartEarlierComparison cmp;
 706         locs.sort (cmp);
 707
 708         /* locs is now sorted earliest..latest */
 709
 710         for (LocationList::iterator i = locs.begin(); i != locs.end(); ++i) {
 711                 if (!(*i)->is_hidden() && (*i)->start() > frame) {
 712                         return (*i);
 713                 }
 714         }
 715
 716         return 0;
 717 }
 718
 719 nframes_t
 720 Locations::first_mark_before (nframes_t frame)
 721 {
 722         LocationList locs;
 723
 724         {
 725         Glib::Mutex::Lock lm (lock);
 726                 locs = locations;
 727         }
 728
 729         LocationStartLaterComparison cmp;
 730         locs.sort (cmp);
 731
 732         /* locs is now sorted latest..earliest */
 733
 734         for (LocationList::iterator i = locs.begin(); i != locs.end(); ++i) {
 735                 if (!(*i)->is_hidden()) {
 736                         if ((*i)->is_mark()) {
 737                                 /* MARK: start == end */
 738                                 if ((*i)->start() < frame) {
 739                                         return (*i)->start();
 740                                 }
 741                         } else {
 742                                 /* RANGE: start != end, compare start and end */
 743                                 if ((*i)->end() < frame) {
 744                                         return (*i)->end();
 745                                 }
 746                                 if ((*i)->start () < frame) {
 747                                         return (*i)->start();
 748                                 }
 749                         }
 750                 }
 751         }
 752
 753         return 0;
 754 }
 755
 756 nframes_t
 757 Locations::first_mark_after (nframes_t frame)
 758 {
 759         LocationList locs;
 760
 761         {
 762         Glib::Mutex::Lock lm (lock);
 763                 locs = locations;
 764         }
 765
 766         LocationStartEarlierComparison cmp;
 767         locs.sort (cmp);
 768
 769         /* locs is now sorted earliest..latest */
 770
 771         for (LocationList::iterator i = locs.begin(); i != locs.end(); ++i) {
 772                 if (!(*i)->is_hidden()) {
 773                         if ((*i)->is_mark()) {
 774                                 /* MARK, start == end so just compare start */
 775                                 if ((*i)->start() > frame) {
 776                                         return (*i)->start();
 777                                 }
 778                         } else {
 779                                 /* RANGE, start != end, compare start and end */
 780                                 if ((*i)->start() > frame ) {
 781                                         return (*i)->start ();
 782                                 }
 783                                 if ((*i)->end() > frame) {
 784                                         return (*i)->end ();
 785                                 }
 786                         }
 787                 }
 788         }
 789
 790         return max_frames;
 791 }
 792
 793 Location*
 794 Locations::end_location () const
 795 {
 796         for (LocationList::const_iterator i = locations.begin(); i != locations.end(); ++i) {
 797                 if ((*i)->is_end()) {
 798                         return const_cast<Location*> (*i);
 799                 }
 800         }
 801         return 0;
 802 }
 803
 804 Location*
 805 Locations::start_location () const
 806 {
 807         for (LocationList::const_iterator i = locations.begin(); i != locations.end(); ++i) {
 808                 if ((*i)->is_start()) {
 809                         return const_cast<Location*> (*i);
 810                 }
 811         }
 812         return 0;
 813 }
 814
 815 Location*
 816 Locations::auto_loop_location () const
 817 {
 818         for (LocationList::const_iterator i = locations.begin(); i != locations.end(); ++i) {
 819                 if ((*i)->is_auto_loop()) {
 820                         return const_cast<Location*> (*i);
 821                 }
 822         }
 823         return 0;
 824 }
 825
 826 Location*
 827 Locations::auto_punch_location () const
 828 {
 829         for (LocationList::const_iterator i = locations.begin(); i != locations.end(); ++i) {
 830                 if ((*i)->is_auto_punch()) {
 831                         return const_cast<Location*> (*i);
 832                 }
 833         }
 834        return 0;
 835 }
 836
 837 #ifdef STATE_MANAGER
 838 StateManager::State*
 839 Locations::state_factory (std::string why) const
 840 {
 841         State* state = new State (why);
 842
 843         state->locations = locations;
 844
 845         for (LocationList::const_iterator i = locations.begin(); i != locations.end(); ++i) {
 846                 state->states.push_back (new Location (**i));
 847         }
 848
 849         return state;
 850 }
 851
 852 Change
 853 Locations::restore_state (StateManager::State& state)
 854 {
 855         {
 856                 Glib::Mutex::Lock lm (lock);
 857                 State* lstate = dynamic_cast<State*> (&state);
 858
 859                 locations = lstate->locations;
 860                 LocationList& states = lstate->states;
 861                 LocationList::iterator l, s;
 862
 863                 for (l = locations.begin(), s = states.begin(); s != states.end(); ++s, ++l) {
 864                         (*l) = (*s);
 865                 }
 866         }
 867
 868         return Change (0);
 869 }
 870
 871 UndoAction
 872 Locations::get_memento () const
 873 {
 874   return sigc::bind (mem_fun (*(const_cast<Locations*> (this)), &StateManager::use_state), _current_state_id);
 875 }
 876 #endif
 877
 878 uint32_t
 879 Locations::num_range_markers () const
 880 {
 881         uint32_t cnt = 0;
 882         Glib::Mutex::Lock lm (lock);
 883         for (LocationList::const_iterator i = locations.begin(); i != locations.end(); ++i) {
 884                 if ((*i)->is_range_marker()) {
 885                         ++cnt;
 886                 }
 887         }
 888         return cnt;
 889 }
 890
 891 Location *
 892 Locations::get_location_by_id(PBD::ID id)
 893 {
 894     LocationList::iterator it;
 895     for (it  = locations.begin(); it != locations.end(); it++)
 896         if (id == (*it)->id())
 897             return *it;
 898
 899     return 0;
 900 }