src/core/AutomationPattern.cpp

   1 /*
   2  * AutomationPattern.cpp - implementation of class AutomationPattern which
   3  *                         holds dynamic values
   4  *
   5  * Copyright (c) 2008-2010 Tobias Doerffel <tobydox/at/users.sourceforge.net>
   6  * Copyright (c) 2006-2008 Javier Serrano Polo <jasp00/at/users.sourceforge.net>
   7  *
   8  * This file is part of Linux MultiMedia Studio - http://lmms.sourceforge.net
   9  *
  10  * This program is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU General Public
  12  * License as published by the Free Software Foundation; either
  13  * version 2 of the License, or (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public
  21  * License along with this program (see COPYING); if not, write to the
  22  * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  23  * Boston, MA 02110-1301 USA.
  24  *
  25  */
  26
  27 #include <QtXml/QDomElement>
  28 #include <QtGui/QMouseEvent>
  29 #include <QtGui/QPainter>
  30
  31 #include "AutomationPattern.h"
  32 #include "AutomationPatternView.h"
  33 #include "AutomationEditor.h"
  34 #include "AutomationTrack.h"
  35 #include "ProjectJournal.h"
  36 #include "bb_track_container.h"
  37 #include "song.h"
  38
  39
  40
  41 AutomationPattern::AutomationPattern( AutomationTrack * _auto_track ) :
  42         trackContentObject( _auto_track ),
  43         m_autoTrack( _auto_track ),
  44         m_objects(),
  45         m_hasAutomation( false )
  46 {
  47         changeLength( midiTime( 1, 0 ) );
  48         m_timeMap[0] = 0;
  49 }
  50
  51
  52
  53
  54 AutomationPattern::AutomationPattern( const AutomationPattern & _pat_to_copy ) :
  55         trackContentObject( _pat_to_copy.m_autoTrack ),
  56         m_autoTrack( _pat_to_copy.m_autoTrack ),
  57         m_objects( _pat_to_copy.m_objects ),
  58         m_hasAutomation( _pat_to_copy.m_hasAutomation )
  59 {
  60         for( timeMap::const_iterator it = _pat_to_copy.m_timeMap.begin();
  61                                 it != _pat_to_copy.m_timeMap.end(); ++it )
  62         {
  63                 m_timeMap[it.key()] = it.value();
  64         }
  65 }
  66
  67
  68
  69
  70 AutomationPattern::~AutomationPattern()
  71 {
  72         if( engine::automationEditor() &&
  73                 engine::automationEditor()->currentPattern() == this )
  74         {
  75                 engine::automationEditor()->setCurrentPattern( NULL );
  76         }
  77 }
  78
  79
  80
  81
  82 void AutomationPattern::addObject( AutomatableModel * _obj, bool _search_dup )
  83 {
  84         bool addIt = true;
  85
  86         if( _search_dup )
  87         {
  88                 for( objectVector::iterator it = m_objects.begin();
  89                                         it != m_objects.end(); ++it )
  90                 {
  91                         if( *it == _obj )
  92                         {
  93                                 // Already exists
  94                                 // TODO: Maybe let the user know in some non-annoying way
  95                                 addIt = false;
  96                                 break;
  97                         }
  98                 }
  99         }
 100
 101         if( addIt )
 102         {
 103                 m_objects += _obj;
 104                 // been empty before?
 105                 if( m_objects.size() == 1 && !hasAutomation() )
 106                 {
 107                         // then initialize default-value
 108                         putValue( 0, _obj->value<float>(), false );
 109                 }
 110                 connect( _obj, SIGNAL( destroyed( jo_id_t ) ),
 111                                 this, SLOT( objectDestroyed( jo_id_t ) ),
 112                                                         Qt::DirectConnection );
 113         }
 114 }
 115
 116
 117
 118
 119 const AutomatableModel * AutomationPattern::firstObject() const
 120 {
 121         AutomatableModel * m;
 122         if( !m_objects.isEmpty() && ( m = m_objects.first() ) != NULL )
 123         {
 124                 return m;
 125         }
 126
 127         static FloatModel _fm( 0, 0, 1, 0.001 );
 128         return &_fm;
 129 }
 130
 131
 132
 133
 134
 135 //TODO: Improve this
 136 midiTime AutomationPattern::length() const
 137 {
 138         tick_t max_length = 0;
 139
 140         for( timeMap::const_iterator it = m_timeMap.begin();
 141                                                 it != m_timeMap.end(); ++it )
 142         {
 143                 max_length = qMax<tick_t>( max_length, it.key() );
 144         }
 145         return midiTime( qMax( midiTime( max_length ).getTact() + 1, 1 ), 0 );
 146 }
 147
 148
 149
 150
 151 midiTime AutomationPattern::putValue( const midiTime & _time,
 152                                                         const float _value,
 153                                                         const bool _quant_pos )
 154 {
 155         midiTime newTime = _quant_pos && engine::automationEditor() ?
 156                 note::quantized( _time,
 157                         engine::automationEditor()->quantization() ) :
 158                 _time;
 159
 160         m_timeMap[newTime] = _value;
 161
 162         if( newTime == 0 )
 163         {
 164                 for( objectVector::iterator it = m_objects.begin();
 165                                                 it != m_objects.end(); )
 166                 {
 167                         if( *it )
 168                         {
 169                                 ( *it )->setValue( _value );
 170                                 ++it;
 171                         }
 172                         else
 173                         {
 174                                 it = m_objects.erase( it );
 175                         }
 176                 }
 177         }
 178
 179         // just one automation value?
 180         if( m_timeMap.size() == 1 )
 181         {
 182                 m_hasAutomation = m_objects.isEmpty();  // usually false
 183                 for( objectVector::iterator it = m_objects.begin();
 184                                                 it != m_objects.end(); ++it )
 185                 {
 186                         // default value differs from current value?
 187                         if( *it && _value != ( *it )->initValue<float>() )
 188                         {
 189                                 // then enable automating this object
 190                                 m_hasAutomation = true;
 191                         }
 192                 }
 193         }
 194         else
 195         {
 196                 // in all other cases assume we have automation
 197                 m_hasAutomation = true;
 198         }
 199
 200         // we need to maximize our length in case we're part of a hidden
 201         // automation track as the user can't resize this pattern
 202         if( getTrack() && getTrack()->type() == track::HiddenAutomationTrack )
 203         {
 204                 changeLength( length() );
 205         }
 206
 207         emit dataChanged();
 208
 209         return newTime;
 210 }
 211
 212
 213
 214
 215 void AutomationPattern::removeValue( const midiTime & _time )
 216 {
 217         if( _time != 0 )
 218         {
 219                 m_timeMap.remove( _time );
 220
 221                 if( m_timeMap.size() == 1 )
 222                 {
 223                         const float val = m_timeMap[0];
 224                         m_hasAutomation = false;
 225                         for( objectVector::iterator it = m_objects.begin();
 226                                                 it != m_objects.end(); )
 227                         {
 228                                 if( *it )
 229                                 {
 230                                         ( *it )->setValue( val );
 231                                         if( ( *it )->initValue<float>() != val )
 232                                         {
 233                                                 m_hasAutomation = true;
 234                                         }
 235                                         ++it;
 236                                 }
 237                                 else
 238                                 {
 239                                         it = m_objects.erase( it );
 240                                 }
 241                         }
 242                 }
 243
 244                 if( getTrack() &&
 245                         getTrack()->type() == track::HiddenAutomationTrack )
 246                 {
 247                         changeLength( length() );
 248                 }
 249
 250                 emit dataChanged();
 251         }
 252 }
 253
 254
 255
 256
 257 float AutomationPattern::valueAt( const midiTime & _time ) const
 258 {
 259         if( m_timeMap.isEmpty() )
 260         {
 261                 return 0;
 262         }
 263         timeMap::const_iterator v = m_timeMap.lowerBound( _time );
 264         // lowerBound returns next value with greater key, therefore we take
 265         // the previous element to get the current value
 266         return ( v != m_timeMap.begin() ) ? (v-1).value() : v.value();
 267 }
 268
 269
 270
 271
 272 void AutomationPattern::saveSettings( QDomDocument & _doc, QDomElement & _this )
 273 {
 274         _this.setAttribute( "pos", startPosition() );
 275         _this.setAttribute( "len", trackContentObject::length() );
 276         _this.setAttribute( "name", name() );
 277
 278         for( timeMap::const_iterator it = m_timeMap.begin();
 279                                                 it != m_timeMap.end(); ++it )
 280         {
 281                 QDomElement element = _doc.createElement( "time" );
 282                 element.setAttribute( "pos", it.key() );
 283                 element.setAttribute( "value", it.value() );
 284                 _this.appendChild( element );
 285         }
 286
 287         for( objectVector::const_iterator it = m_objects.begin();
 288                                                 it != m_objects.end(); ++it )
 289         {
 290                 if( *it )
 291                 {
 292                         QDomElement element = _doc.createElement( "object" );
 293                         element.setAttribute( "id", ( *it )->id() );
 294                         _this.appendChild( element );
 295                 }
 296         }
 297 }
 298
 299
 300
 301
 302 void AutomationPattern::loadSettings( const QDomElement & _this )
 303 {
 304         clear();
 305
 306         movePosition( _this.attribute( "pos" ).toInt() );
 307         setName( _this.attribute( "name" ) );
 308
 309         for( QDomNode node = _this.firstChild(); !node.isNull();
 310                                                 node = node.nextSibling() )
 311         {
 312                 QDomElement element = node.toElement();
 313                 if( element.isNull()  )
 314                 {
 315                         continue;
 316                 }
 317                 if( element.tagName() == "time" )
 318                 {
 319                         m_timeMap[element.attribute( "pos" ).toInt()]
 320                                 = element.attribute( "value" ).toFloat();
 321                 }
 322                 else if( element.tagName() == "object" )
 323                 {
 324                         m_idsToResolve << element.attribute( "id" ).toInt();
 325                 }
 326         }
 327
 328         m_hasAutomation = m_timeMap.size() > 1;
 329         if( m_hasAutomation == false )
 330         {
 331                 for( objectVector::iterator it = m_objects.begin();
 332                                                 it != m_objects.end(); ++it )
 333                 {
 334                         if( *it )
 335                         {
 336                                 ( *it )->setValue( m_timeMap[0] );
 337                         }
 338                 }
 339         }
 340         int len = _this.attribute( "len" ).toInt();
 341         if( len <= 0 )
 342         {
 343                 len = length();
 344         }
 345         changeLength( len );
 346 }
 347
 348
 349
 350
 351 const QString AutomationPattern::name() const
 352 {
 353         if( !trackContentObject::name().isEmpty() )
 354         {
 355                 return trackContentObject::name();
 356         }
 357         if( !m_objects.isEmpty() && m_objects.first() != NULL )
 358         {
 359                 return m_objects.first()->fullDisplayName();
 360         }
 361         return tr( "Drag a control while pressing <Ctrl>" );
 362 }
 363
 364
 365
 366
 367 void AutomationPattern::processMidiTime( const midiTime & _time )
 368 {
 369         if( _time >= 0 && m_hasAutomation )
 370         {
 371                 const float val = valueAt( _time );
 372                 for( objectVector::iterator it = m_objects.begin();
 373                                                 it != m_objects.end(); ++it )
 374                 {
 375                         if( *it )
 376                         {
 377                                 ( *it )->setAutomatedValue( val );
 378                         }
 379
 380                 }
 381         }
 382 }
 383
 384
 385
 386
 387
 388 trackContentObjectView * AutomationPattern::createView( trackView * _tv )
 389 {
 390         return new AutomationPatternView( this, _tv );
 391 }
 392
 393
 394
 395
 396
 397 bool AutomationPattern::isAutomated( const AutomatableModel * _m )
 398 {
 399         trackContainer::trackList l = engine::getSong()->tracks() +
 400                                 engine::getBBTrackContainer()->tracks();
 401         l += engine::getSong()->globalAutomationTrack();
 402         for( trackContainer::trackList::const_iterator it = l.begin();
 403                                                         it != l.end(); ++it )
 404         {
 405                 if( ( *it )->type() == track::AutomationTrack ||
 406                         ( *it )->type() == track::HiddenAutomationTrack )
 407                 {
 408                         const track::tcoVector & v = ( *it )->getTCOs();
 409                         for( track::tcoVector::const_iterator j = v.begin();
 410                                                         j != v.end(); ++j )
 411                         {
 412                                 const AutomationPattern * a =
 413                                                                 dynamic_cast<const AutomationPattern *>( *j );
 414                                 if( a && a->m_hasAutomation )
 415                                 {
 416         for( objectVector::const_iterator k = a->m_objects.begin();
 417                                         k != a->m_objects.end(); ++k )
 418         {
 419                 if( *k == _m )
 420                 {
 421                         return true;
 422                 }
 423         }
 424                                 }
 425                         }
 426                 }
 427         }
 428         return false;
 429 }
 430
 431
 432
 433
 434
 435 AutomationPattern * AutomationPattern::globalAutomationPattern(
 436                                                         AutomatableModel * _m )
 437 {
 438         AutomationTrack * t = engine::getSong()->globalAutomationTrack();
 439         track::tcoVector v = t->getTCOs();
 440         for( track::tcoVector::const_iterator j = v.begin(); j != v.end(); ++j )
 441         {
 442                 AutomationPattern * a = dynamic_cast<AutomationPattern *>( *j );
 443                 if( a )
 444                 {
 445                         for( objectVector::const_iterator k = a->m_objects.begin();
 446                                                                                                 k != a->m_objects.end(); ++k )
 447                         {
 448                                 if( *k == _m )
 449                                 {
 450                                         return a;
 451                                 }
 452                         }
 453                 }
 454         }
 455
 456         AutomationPattern * a = new AutomationPattern( t );
 457         a->addObject( _m, false );
 458         return a;
 459 }
 460
 461
 462
 463
 464 void AutomationPattern::resolveAllIDs()
 465 {
 466         trackContainer::trackList l = engine::getSong()->tracks() +
 467                                 engine::getBBTrackContainer()->tracks();
 468         l += engine::getSong()->globalAutomationTrack();
 469         for( trackContainer::trackList::iterator it = l.begin();
 470                                                         it != l.end(); ++it )
 471         {
 472                 if( ( *it )->type() == track::AutomationTrack ||
 473                          ( *it )->type() == track::HiddenAutomationTrack )
 474                 {
 475                         track::tcoVector v = ( *it )->getTCOs();
 476                         for( track::tcoVector::iterator j = v.begin();
 477                                                         j != v.end(); ++j )
 478                         {
 479                                 AutomationPattern * a = dynamic_cast<AutomationPattern *>( *j );
 480                                 if( a )
 481                                 {
 482         for( QVector<jo_id_t>::Iterator k = a->m_idsToResolve.begin();
 483                                         k != a->m_idsToResolve.end(); ++k )
 484         {
 485                 JournallingObject * o = engine::projectJournal()->
 486                                                                                 journallingObject( *k );
 487                 if( o && dynamic_cast<AutomatableModel *>( o ) )
 488                 {
 489                         a->addObject( dynamic_cast<AutomatableModel *>( o ), false );
 490                 }
 491         }
 492         a->m_idsToResolve.clear();
 493         a->dataChanged();
 494                                 }
 495                         }
 496                 }
 497         }
 498 }
 499
 500
 501
 502
 503 void AutomationPattern::clear()
 504 {
 505         const float val = firstObject()->value<float>();
 506         m_timeMap.clear();
 507         putValue( 0, val );
 508
 509         if( engine::automationEditor() &&
 510                 engine::automationEditor()->currentPattern() == this )
 511         {
 512                 engine::automationEditor()->update();
 513         }
 514 }
 515
 516
 517
 518
 519 void AutomationPattern::openInAutomationEditor()
 520 {
 521         engine::automationEditor()->setCurrentPattern( this );
 522         engine::automationEditor()->parentWidget()->show();
 523         engine::automationEditor()->setFocus();
 524 }
 525
 526
 527
 528
 529 void AutomationPattern::objectDestroyed( jo_id_t _id )
 530 {
 531         // TODO: distict between temporary removal (e.g. LADSPA controls
 532         // when switching samplerate) and real deletions because in the latter
 533         // case we had to remove ourselves if we're the global automation
 534         // pattern of the destroyed object
 535         m_idsToResolve += _id;
 536 }
 537
 538
 539
 540
 541 #include "moc_AutomationPattern.cxx"
 542