libs/ardour/midi_region.cc

   1 /*
   2     Copyright (C) 2000-2006 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: midiregion.cc 746 2006-08-02 02:44:23Z drobilla $
  19 */
  20
  21 #include <cmath>
  22 #include <climits>
  23 #include <cfloat>
  24
  25 #include <set>
  26
  27 #include <glibmm/threads.h>
  28 #include <glibmm/fileutils.h>
  29 #include <glibmm/miscutils.h>
  30
  31 #include "evoral/Beats.hpp"
  32
  33 #include "pbd/xml++.h"
  34 #include "pbd/basename.h"
  35
  36 #include "ardour/automation_control.h"
  37 #include "ardour/midi_model.h"
  38 #include "ardour/midi_region.h"
  39 #include "ardour/midi_ring_buffer.h"
  40 #include "ardour/midi_source.h"
  41 #include "ardour/region_factory.h"
  42 #include "ardour/session.h"
  43 #include "ardour/source_factory.h"
  44 #include "ardour/tempo.h"
  45 #include "ardour/types.h"
  46
  47 #include "pbd/i18n.h"
  48 #include <locale.h>
  49
  50 using namespace std;
  51 using namespace ARDOUR;
  52 using namespace PBD;
  53
  54 namespace ARDOUR {
  55         namespace Properties {
  56                 PBD::PropertyDescriptor<Evoral::Beats> start_beats;
  57                 PBD::PropertyDescriptor<Evoral::Beats> length_beats;
  58         }
  59 }
  60
  61 void
  62 MidiRegion::make_property_quarks ()
  63 {
  64         Properties::start_beats.property_id = g_quark_from_static_string (X_("start-beats"));
  65         DEBUG_TRACE (DEBUG::Properties, string_compose ("quark for start-beats = %1\n", Properties::start_beats.property_id));
  66         Properties::length_beats.property_id = g_quark_from_static_string (X_("length-beats"));
  67         DEBUG_TRACE (DEBUG::Properties, string_compose ("quark for length-beats = %1\n", Properties::length_beats.property_id));
  68 }
  69
  70 void
  71 MidiRegion::register_properties ()
  72 {
  73         add_property (_start_beats);
  74         add_property (_length_beats);
  75 }
  76
  77 /* Basic MidiRegion constructor (many channels) */
  78 MidiRegion::MidiRegion (const SourceList& srcs)
  79         : Region (srcs)
  80         , _start_beats (Properties::start_beats, Evoral::Beats())
  81         , _length_beats (Properties::length_beats, midi_source(0)->length_beats())
  82 {
  83         register_properties ();
  84         midi_source(0)->ModelChanged.connect_same_thread (_source_connection, boost::bind (&MidiRegion::model_changed, this));
  85         model_changed ();
  86         assert(_name.val().find("/") == string::npos);
  87         assert(_type == DataType::MIDI);
  88 }
  89
  90 MidiRegion::MidiRegion (boost::shared_ptr<const MidiRegion> other)
  91         : Region (other)
  92         , _start_beats (Properties::start_beats, other->_start_beats)
  93         , _length_beats (Properties::length_beats, other->_length_beats)
  94 {
  95         //update_length_beats ();
  96         register_properties ();
  97
  98         assert(_name.val().find("/") == string::npos);
  99         midi_source(0)->ModelChanged.connect_same_thread (_source_connection, boost::bind (&MidiRegion::model_changed, this));
 100         model_changed ();
 101 }
 102
 103 /** Create a new MidiRegion that is part of an existing one */
 104 MidiRegion::MidiRegion (boost::shared_ptr<const MidiRegion> other, frameoffset_t offset, const int32_t sub_num)
 105         : Region (other, offset, sub_num)
 106         , _start_beats (Properties::start_beats, Evoral::Beats())
 107         , _length_beats (Properties::length_beats, other->_length_beats)
 108 {
 109         _start_beats = Evoral::Beats (_session.tempo_map().exact_qn_at_frame (other->_position + offset, sub_num) - (other->pulse() * 4.0)) + other->_start_beats;
 110
 111         update_length_beats (sub_num);
 112         register_properties ();
 113
 114         assert(_name.val().find("/") == string::npos);
 115         midi_source(0)->ModelChanged.connect_same_thread (_source_connection, boost::bind (&MidiRegion::model_changed, this));
 116         model_changed ();
 117 }
 118
 119 MidiRegion::~MidiRegion ()
 120 {
 121 }
 122
 123 /** Export the MIDI data of the MidiRegion to a new MIDI file (SMF).
 124  */
 125 bool
 126 MidiRegion::do_export (string path) const
 127 {
 128         boost::shared_ptr<MidiSource> newsrc;
 129
 130         /* caller must check for pre-existing file */
 131         assert (!path.empty());
 132         assert (!Glib::file_test (path, Glib::FILE_TEST_EXISTS));
 133         newsrc = boost::dynamic_pointer_cast<MidiSource>(
 134                 SourceFactory::createWritable(DataType::MIDI, _session,
 135                                               path, false, _session.frame_rate()));
 136
 137         BeatsFramesConverter bfc (_session.tempo_map(), _position);
 138         Evoral::Beats const bbegin = bfc.from (_start);
 139         Evoral::Beats const bend = bfc.from (_start + _length);
 140
 141         {
 142                 /* Lock our source since we'll be reading from it.  write_to() will
 143                    take a lock on newsrc. */
 144                 Source::Lock lm (midi_source(0)->mutex());
 145                 if (midi_source(0)->export_write_to (lm, newsrc, bbegin, bend)) {
 146                         return false;
 147                 }
 148         }
 149
 150         return true;
 151 }
 152
 153
 154 /** Create a new MidiRegion that has its own version of some/all of the Source used by another.
 155  */
 156 boost::shared_ptr<MidiRegion>
 157 MidiRegion::clone (string path) const
 158 {
 159         boost::shared_ptr<MidiSource> newsrc;
 160
 161         /* caller must check for pre-existing file */
 162         assert (!path.empty());
 163         assert (!Glib::file_test (path, Glib::FILE_TEST_EXISTS));
 164         newsrc = boost::dynamic_pointer_cast<MidiSource>(
 165                 SourceFactory::createWritable(DataType::MIDI, _session,
 166                                               path, false, _session.frame_rate()));
 167         return clone (newsrc);
 168 }
 169
 170 boost::shared_ptr<MidiRegion>
 171 MidiRegion::clone (boost::shared_ptr<MidiSource> newsrc) const
 172 {
 173         BeatsFramesConverter bfc (_session.tempo_map(), _position);
 174         Evoral::Beats const bbegin = bfc.from (_start);
 175         Evoral::Beats const bend = bfc.from (_start + _length);
 176
 177         {
 178                 /* Lock our source since we'll be reading from it.  write_to() will
 179                    take a lock on newsrc. */
 180                 Source::Lock lm (midi_source(0)->mutex());
 181                 if (midi_source(0)->write_to (lm, newsrc, bbegin, bend)) {
 182                         return boost::shared_ptr<MidiRegion> ();
 183                 }
 184         }
 185
 186         PropertyList plist;
 187
 188         plist.add (Properties::name, PBD::basename_nosuffix (newsrc->name()));
 189         plist.add (Properties::whole_file, true);
 190         plist.add (Properties::start, _start);
 191         plist.add (Properties::start_beats, _start_beats);
 192         plist.add (Properties::length, _length);
 193         plist.add (Properties::length_beats, _length_beats);
 194         plist.add (Properties::layer, 0);
 195
 196         boost::shared_ptr<MidiRegion> ret (boost::dynamic_pointer_cast<MidiRegion> (RegionFactory::create (newsrc, plist, true)));
 197         ret->set_beat (beat());
 198         ret->set_pulse (pulse());
 199
 200         return ret;
 201 }
 202
 203 void
 204 MidiRegion::post_set (const PropertyChange& pc)
 205 {
 206         Region::post_set (pc);
 207
 208         if (pc.contains (Properties::length) && !pc.contains (Properties::length_beats)) {
 209                 /* we're called by Stateful::set_values() which sends a change
 210                    only if the value is different from _current.
 211                    session load means we can clobber length_beats here in error (not all properties differ from current),
 212                    so disallow (this has been set from XML state anyway).
 213                 */
 214                 if (!_session.loading()) {
 215                         /* update non-musically */
 216                         update_length_beats (0);
 217                 }
 218         } else if (pc.contains (Properties::start) && !pc.contains (Properties::start_beats)) {
 219                 set_start_beats_from_start_frames ();
 220         }
 221 }
 222
 223 void
 224 MidiRegion::set_start_beats_from_start_frames ()
 225 {
 226         _start_beats = Evoral::Beats ((pulse() * 4.0) - _session.tempo_map().quarter_note_at_frame (_position - _start));
 227 }
 228
 229 void
 230 MidiRegion::set_length_internal (framecnt_t len, const int32_t sub_num)
 231 {
 232         Region::set_length_internal (len, sub_num);
 233         update_length_beats (sub_num);
 234 }
 235
 236 void
 237 MidiRegion::update_after_tempo_map_change (bool /* send */)
 238 {
 239         boost::shared_ptr<Playlist> pl (playlist());
 240
 241         if (!pl) {
 242                 return;
 243         }
 244
 245         const framepos_t old_pos = _position;
 246         const framepos_t old_length = _length;
 247         const framepos_t old_start = _start;
 248
 249         PropertyChange s_and_l;
 250
 251         if (position_lock_style() == AudioTime) {
 252                 recompute_position_from_lock_style (0);
 253
 254                 /*
 255                   set _start to new position in tempo map.
 256
 257                   The user probably expects the region contents to maintain audio position as the
 258                   tempo changes, but AFAICT this requires modifying the src file to use
 259                   SMPTE timestamps with the current disk read model (?).
 260
 261                   We could arguably use _start to set _start_beats here,
 262                   resulting in viewport-like behaviour (the contents maintain
 263                   their musical position while the region is stationary).
 264
 265                   For now, the musical position at the region start is retained, but subsequent events
 266                   will maintain their beat distance according to the map.
 267                 */
 268                 _start = _position - _session.tempo_map().frame_at_pulse (pulse() - (_start_beats.val().to_double() / 4.0));
 269
 270                 /* _length doesn't change for audio-locked regions. update length_beats to match. */
 271                 _length_beats = Evoral::Beats (_session.tempo_map().quarter_note_at_frame (_position + _length) - _session.tempo_map().quarter_note_at_frame (_position));
 272
 273                 s_and_l.add (Properties::start);
 274                 s_and_l.add (Properties::length_beats);
 275
 276                 send_change  (s_and_l);
 277                 return;
 278         }
 279
 280         Region::update_after_tempo_map_change (false);
 281
 282         /* _start has now been updated. */
 283         _length = _session.tempo_map().frame_at_pulse (pulse() + (_length_beats.val().to_double() / 4.0)) - _position;
 284
 285         if (old_start != _start) {
 286                 s_and_l.add (Properties::start);
 287         }
 288         if (old_length != _length) {
 289                 s_and_l.add (Properties::length);
 290         }
 291         if (old_pos != _position) {
 292                 s_and_l.add (Properties::position);
 293         }
 294
 295         send_change (s_and_l);
 296 }
 297
 298 void
 299 MidiRegion::update_length_beats (const int32_t sub_num)
 300 {
 301         _length_beats = Evoral::Beats (_session.tempo_map().exact_qn_at_frame (_position + _length, sub_num) - (pulse() * 4.0));
 302 }
 303
 304 void
 305 MidiRegion::set_position_internal (framepos_t pos, bool allow_bbt_recompute, const int32_t sub_num)
 306 {
 307         Region::set_position_internal (pos, allow_bbt_recompute, sub_num);
 308
 309         /* set _start to new position in tempo map */
 310         _start = _position - _session.tempo_map().frame_at_pulse (pulse() - (_start_beats.val().to_double() / 4.0));
 311
 312         /* in construction from src */
 313         if (_length_beats == Evoral::Beats()) {
 314                 update_length_beats (sub_num);
 315         }
 316
 317         /* don't clobber _length and _length_beats if session loading.*/
 318         if (!_session.loading()) {
 319                 if (position_lock_style() == AudioTime) {
 320                         _length_beats = Evoral::Beats (_session.tempo_map().quarter_note_at_frame (_position + _length) - _session.tempo_map().quarter_note_at_frame (_position));
 321                 } else {
 322                         /* leave _length_beats alone, and change _length to reflect the state of things
 323                            at the new position (tempo map may dictate a different number of frames).
 324                         */
 325                         Region::set_length_internal (_session.tempo_map().frame_at_pulse (pulse() + (_length_beats.val().to_double() / 4.0)) - _position, sub_num);
 326                 }
 327         }
 328 }
 329
 330 framecnt_t
 331 MidiRegion::read_at (Evoral::EventSink<framepos_t>& out,
 332                      framepos_t                     position,
 333                      framecnt_t                     dur,
 334                      Evoral::Range<framepos_t>*     loop_range,
 335                      uint32_t                       chan_n,
 336                      NoteMode                       mode,
 337                      MidiStateTracker*              tracker,
 338                      MidiChannelFilter*             filter) const
 339 {
 340         return _read_at (_sources, out, position, dur, loop_range, chan_n, mode, tracker, filter);
 341 }
 342
 343 framecnt_t
 344 MidiRegion::master_read_at (MidiRingBuffer<framepos_t>& out,
 345                             framepos_t                  position,
 346                             framecnt_t                  dur,
 347                             Evoral::Range<framepos_t>*  loop_range,
 348                             uint32_t                    chan_n,
 349                             NoteMode                    mode) const
 350 {
 351         return _read_at (_master_sources, out, position, dur, loop_range, chan_n, mode); /* no tracker */
 352 }
 353
 354 framecnt_t
 355 MidiRegion::_read_at (const SourceList&              /*srcs*/,
 356                       Evoral::EventSink<framepos_t>& dst,
 357                       framepos_t                     position,
 358                       framecnt_t                     dur,
 359                       Evoral::Range<framepos_t>*     loop_range,
 360                       uint32_t                       chan_n,
 361                       NoteMode                       mode,
 362                       MidiStateTracker*              tracker,
 363                       MidiChannelFilter*             filter) const
 364 {
 365         frameoffset_t internal_offset = 0;
 366         framecnt_t    to_read         = 0;
 367
 368         /* precondition: caller has verified that we cover the desired section */
 369
 370         assert(chan_n == 0);
 371
 372         if (muted()) {
 373                 return 0; /* read nothing */
 374         }
 375
 376         if (position < _position) {
 377                 /* we are starting the read from before the start of the region */
 378                 internal_offset = 0;
 379                 dur -= _position - position;
 380         } else {
 381                 /* we are starting the read from after the start of the region */
 382                 internal_offset = position - _position;
 383         }
 384
 385         if (internal_offset >= _length) {
 386                 return 0; /* read nothing */
 387         }
 388
 389         if ((to_read = min (dur, _length - internal_offset)) == 0) {
 390                 return 0; /* read nothing */
 391         }
 392
 393         boost::shared_ptr<MidiSource> src = midi_source(chan_n);
 394
 395         Glib::Threads::Mutex::Lock lm(src->mutex());
 396
 397         src->set_note_mode(lm, mode);
 398
 399 #if 0
 400         cerr << "MR " << name () << " read @ " << position << " + " << to_read
 401              << " dur was " << dur
 402              << " len " << _length
 403              << " l-io " << (_length - internal_offset)
 404              << " _position = " << _position
 405              << " _start = " << _start
 406              << " intoffset = " << internal_offset
 407              << " pulse = " << pulse()
 408              << " start_pulse = " << start_pulse()
 409              << " start_beat = " << _start_beats
 410              << endl;
 411 #endif
 412
 413         /* This call reads events from a source and writes them to `dst' timed in session frames */
 414
 415         if (src->midi_read (
 416                     lm, // source lock
 417                     dst, // destination buffer
 418                     _position - _start, // start position of the source in session frames
 419                     _start + internal_offset, // where to start reading in the source
 420                     to_read, // read duration in frames
 421                     loop_range,
 422                     tracker,
 423                     filter,
 424                     _filtered_parameters,
 425                     pulse(),
 426                     _start_beats.val().to_double()
 427                     ) != to_read) {
 428                 return 0; /* "read nothing" */
 429         }
 430
 431         return to_read;
 432 }
 433
 434 XMLNode&
 435 MidiRegion::state ()
 436 {
 437         return Region::state ();
 438 }
 439
 440 int
 441 MidiRegion::set_state (const XMLNode& node, int version)
 442 {
 443         int ret = Region::set_state (node, version);
 444
 445         if (ret == 0) {
 446                 /* set length beats to the frame (non-musical) */
 447                 if (position_lock_style() == AudioTime) {
 448                         update_length_beats (0);
 449                 }
 450         }
 451
 452         return ret;
 453 }
 454
 455 void
 456 MidiRegion::recompute_at_end ()
 457 {
 458         /* our length has changed
 459          * so what? stuck notes are dealt with via a note state tracker
 460          */
 461 }
 462
 463 void
 464 MidiRegion::recompute_at_start ()
 465 {
 466         /* as above, but the shift was from the front
 467          * maybe bump currently active note's note-ons up so they sound here?
 468          * that could be undesireable in certain situations though.. maybe
 469          * remove the note entirely, including it's note off?  something needs to
 470          * be done to keep the played MIDI sane to avoid messing up voices of
 471          * polyhonic things etc........
 472          */
 473 }
 474
 475 int
 476 MidiRegion::separate_by_channel (ARDOUR::Session&, vector< boost::shared_ptr<Region> >&) const
 477 {
 478         // TODO
 479         return -1;
 480 }
 481
 482 boost::shared_ptr<Evoral::Control>
 483 MidiRegion::control (const Evoral::Parameter& id, bool create)
 484 {
 485         return model()->control(id, create);
 486 }
 487
 488 boost::shared_ptr<const Evoral::Control>
 489 MidiRegion::control (const Evoral::Parameter& id) const
 490 {
 491         return model()->control(id);
 492 }
 493
 494 boost::shared_ptr<MidiModel>
 495 MidiRegion::model()
 496 {
 497         return midi_source()->model();
 498 }
 499
 500 boost::shared_ptr<const MidiModel>
 501 MidiRegion::model() const
 502 {
 503         return midi_source()->model();
 504 }
 505
 506 boost::shared_ptr<MidiSource>
 507 MidiRegion::midi_source (uint32_t n) const
 508 {
 509         // Guaranteed to succeed (use a static cast?)
 510         return boost::dynamic_pointer_cast<MidiSource>(source(n));
 511 }
 512
 513 /* don't use this. hopefully it will go away.
 514    currently used by headless-chicken session utility.
 515 */
 516 void
 517 MidiRegion::clobber_sources (boost::shared_ptr<MidiSource> s)
 518 {
 519        drop_sources();
 520
 521        _sources.push_back (s);
 522        s->inc_use_count ();
 523        _master_sources.push_back (s);
 524        s->inc_use_count ();
 525
 526        s->DropReferences.connect_same_thread (*this, boost::bind (&Region::source_deleted, this, boost::weak_ptr<Source>(s)));
 527
 528 }
 529
 530 void
 531 MidiRegion::model_changed ()
 532 {
 533         if (!model()) {
 534                 return;
 535         }
 536
 537         /* build list of filtered Parameters, being those whose automation state is not `Play' */
 538
 539         _filtered_parameters.clear ();
 540
 541         Automatable::Controls const & c = model()->controls();
 542
 543         for (Automatable::Controls::const_iterator i = c.begin(); i != c.end(); ++i) {
 544                 boost::shared_ptr<AutomationControl> ac = boost::dynamic_pointer_cast<AutomationControl> (i->second);
 545                 assert (ac);
 546                 if (ac->alist()->automation_state() != Play) {
 547                         _filtered_parameters.insert (ac->parameter ());
 548                 }
 549         }
 550
 551         /* watch for changes to controls' AutoState */
 552         midi_source()->AutomationStateChanged.connect_same_thread (
 553                 _model_connection, boost::bind (&MidiRegion::model_automation_state_changed, this, _1)
 554                 );
 555 }
 556
 557 void
 558 MidiRegion::model_automation_state_changed (Evoral::Parameter const & p)
 559 {
 560         /* Update our filtered parameters list after a change to a parameter's AutoState */
 561
 562         boost::shared_ptr<AutomationControl> ac = model()->automation_control (p);
 563         if (!ac || ac->alist()->automation_state() == Play) {
 564                 /* It should be "impossible" for ac to be NULL, but if it is, don't
 565                    filter the parameter so events aren't lost. */
 566                 _filtered_parameters.erase (p);
 567         } else {
 568                 _filtered_parameters.insert (p);
 569         }
 570
 571         /* the source will have an iterator into the model, and that iterator will have been set up
 572            for a given set of filtered_parameters, so now that we've changed that list we must invalidate
 573            the iterator.
 574         */
 575         Glib::Threads::Mutex::Lock lm (midi_source(0)->mutex(), Glib::Threads::TRY_LOCK);
 576         if (lm.locked()) {
 577                 /* TODO: This is too aggressive, we need more fine-grained invalidation. */
 578                 midi_source(0)->invalidate (lm);
 579         }
 580 }
 581
 582 /** This is called when a trim drag has resulted in a -ve _start time for this region.
 583  *  Fix it up by adding some empty space to the source.
 584  */
 585 void
 586 MidiRegion::fix_negative_start ()
 587 {
 588         BeatsFramesConverter c (_session.tempo_map(), _position);
 589
 590         model()->insert_silence_at_start (c.from (-_start));
 591         _start = 0;
 592         _start_beats = Evoral::Beats();
 593 }
 594
 595 void
 596 MidiRegion::set_start_internal (framecnt_t s, const int32_t sub_num)
 597 {
 598         Region::set_start_internal (s, sub_num);
 599
 600         if (position_lock_style() == AudioTime) {
 601                 set_start_beats_from_start_frames ();
 602                 }
 603 }
 604
 605 void
 606 MidiRegion::trim_to_internal (framepos_t position, framecnt_t length, const int32_t sub_num)
 607 {
 608         if (locked()) {
 609                 return;
 610         }
 611
 612         PropertyChange what_changed;
 613
 614         /* beat has been set exactly by set_position_internal, but the source starts on a frame.
 615            working in beats seems the correct thing to do, but reports of a missing first note
 616            on playback suggest otherwise. for now, we work in exact beats.
 617         */
 618         const double pos_pulse = _session.tempo_map().exact_qn_at_frame (position, sub_num) / 4.0;
 619         const double pulse_delta = pos_pulse - pulse();
 620
 621         /* Set position before length, otherwise for MIDI regions this bad thing happens:
 622          * 1. we call set_length_internal; length in beats is computed using the region's current
 623          *    (soon-to-be old) position
 624          * 2. we call set_position_internal; position is set and length in frames re-computed using
 625          *    length in beats from (1) but at the new position, which is wrong if the region
 626          *    straddles a tempo/meter change.
 627          */
 628
 629         if (_position != position) {
 630                 /* sets _beat to new position.*/
 631                 set_position_internal (position, true, sub_num);
 632                 what_changed.add (Properties::position);
 633
 634                 const double new_start_pulse = (_start_beats.val().to_double() / 4.0) + pulse_delta;
 635                 const framepos_t new_start = _position - _session.tempo_map().frame_at_pulse (pulse() - new_start_pulse);
 636
 637                 if (!verify_start_and_length (new_start, length)) {
 638                         return;
 639                 }
 640
 641                 _start_beats = Evoral::Beats (new_start_pulse * 4.0);
 642                 what_changed.add (Properties::start_beats);
 643
 644                 set_start_internal (new_start, sub_num);
 645                 what_changed.add (Properties::start);
 646         }
 647
 648         if (_length != length) {
 649
 650                 if (!verify_start_and_length (_start, length)) {
 651                         return;
 652                 }
 653
 654                 set_length_internal (length, sub_num);
 655                 what_changed.add (Properties::length);
 656                 what_changed.add (Properties::length_beats);
 657         }
 658
 659         set_whole_file (false);
 660
 661         PropertyChange start_and_length;
 662
 663         start_and_length.add (Properties::start);
 664         start_and_length.add (Properties::length);
 665
 666         if (what_changed.contains (start_and_length)) {
 667                 first_edit ();
 668         }
 669
 670         if (!what_changed.empty()) {
 671                 send_change (what_changed);
 672         }
 673 }