← Back to branch summary

~ubuntu-branches/ubuntu/raring/muse/raring-proposed

« back to all changes in this revision

Viewing changes to muse/song.cpp

  • Committer: Package Import Robot
  • Author(s): Alessio Treglia
  • Date: 2012-11-22 01:16:59 UTC
  • mto: This revision was merged to the branch mainline in revision 23.
  • Revision ID: package-import@ubuntu.com-20121122011659-a2fwbf33ceqe1s0t
Tags: upstream-2.1~rc1
Import upstream version 2.1~rc1

Show diffs side-by-side

added added

removed removed

Lines of Context:
muse/song.cpp
245
245
                  track->setType(Track::MIDI);
246
246
                  if (MusEGlobal::config.unhideTracks) MidiTrack::setVisible(true);
247
247
                  break;
 
248
            case Track::NEW_DRUM:
 
249
                  track = new MidiTrack();
 
250
                  track->setType(Track::NEW_DRUM);
 
251
                  ((MidiTrack*)track)->setOutChannel(9);
 
252
                  break;
248
253
            case Track::DRUM:
249
254
                  track = new MidiTrack();
250
255
                  track->setType(Track::DRUM);
332
337
                {
333
338
                  defOutFound = true;
334
339
                  mt->setOutPort(i);
335
 
                  if(type != Track::DRUM)  // p4.0.17 Leave drum tracks at channel 10.
 
340
                  if(type != Track::DRUM  &&  type != Track::NEW_DRUM)  // p4.0.17 Leave drum tracks at channel 10.
336
341
                    mt->setOutChannel(ch);
337
342
                  updateFlags |= SC_ROUTE;
338
343
                  break;               
382
387
  int audio_found = 0;
383
388
  int midi_found = 0;
384
389
  int drum_found = 0;
 
390
  int new_drum_found = 0;
385
391
  for(iTrack it = tl.begin(); it != tl.end(); ++it) 
386
392
    if((*it)->selected()) 
387
393
    {
392
398
      
393
399
      if(type == Track::DRUM)
394
400
        ++drum_found;
395
 
      else
396
 
      if(type == Track::MIDI)
 
401
      else if(type == Track::NEW_DRUM)
 
402
        ++new_drum_found;
 
403
      else if(type == Track::MIDI)
397
404
        ++midi_found;
398
405
      else
399
406
        ++audio_found;
400
407
    }
401
408
 
402
 
  if(audio_found == 0 && midi_found == 0 && drum_found == 0)
 
409
  if(audio_found == 0 && midi_found == 0 && drum_found == 0 && new_drum_found==0)
403
410
    return;
404
411
  
405
412
  
406
 
  MusEGui::DuplicateTracksDialog* dlg = new MusEGui::DuplicateTracksDialog(audio_found, midi_found, drum_found);
 
413
  MusEGui::DuplicateTracksDialog* dlg = new MusEGui::DuplicateTracksDialog(audio_found, midi_found, drum_found, new_drum_found);
407
414
  
408
415
  int rv = dlg->exec();
409
416
  if(rv == QDialog::Rejected)
427
434
    flags |= Track::ASSIGN_DEFAULT_ROUTES;
428
435
  if(dlg->copyParts())
429
436
    flags |= Track::ASSIGN_PARTS;     
 
437
  if(dlg->copyDrumlist())
 
438
    flags |= Track::ASSIGN_DRUMLIST;     
430
439
  
431
440
  delete dlg;
432
441
  
515
524
    --trackno;
516
525
  }
517
526
  
518
 
  int update_flags = SC_TRACK_INSERTED;
 
527
  MusECore::SongChangedFlags_t update_flags = SC_TRACK_INSERTED;
519
528
  if(flags & (Track::ASSIGN_ROUTES | Track::ASSIGN_DEFAULT_ROUTES))
520
529
    update_flags |= SC_ROUTE;
521
530
  MusEGlobal::song->endUndo(update_flags);
708
717
    {
709
718
      MidiPart* part = (MidiPart*)(ip->second);
710
719
      const EventList* el = part->cevents();
711
 
      unsigned len = part->lenTick();
 
720
      // unsigned len = part->lenTick(); // Commented out by flo, see below
712
721
      for(ciEvent ie = el->begin(); ie != el->end(); ++ie)
713
722
      {
714
723
        const Event& ev = ie->second;
715
724
        // Added by T356. Do not handle events which are past the end of the part.
716
 
        if(ev.tick() >= len)
717
 
          break;
 
725
        // Commented out by flo: yes, DO handle them! these are "hidden events"
 
726
        //                       which may be revealed later again!
 
727
        // if(ev.tick() >= len)
 
728
        //   break;
718
729
                    
719
730
        if(ev.type() != Controller)
720
731
          continue;
1359
1370
//   update
1360
1371
//---------------------------------------------------------
1361
1372
 
1362
 
void Song::update(int flags)
 
1373
void Song::update(MusECore::SongChangedFlags_t flags, bool allowRecursion)
1363
1374
      {
1364
1375
      static int level = 0;         // DEBUG
1365
 
      if (level) {
1366
 
            printf("Song::update %08x, level %d\n", flags, level);
 
1376
      if (level && !allowRecursion) {
 
1377
            printf("THIS SHOULD NEVER HAPPEN: unallowed recursion in Song::update(%08lx), level %d!\n"
 
1378
                   "                          the songChanged() signal is NOT emitted. this will\n"
 
1379
                   "                          probably cause windows being not up-to-date.\n", flags, level);
1367
1380
            return;
1368
1381
            }
1369
1382
      ++level;
1570
1583
      return parts;
1571
1584
      }
1572
1585
 
1573
 
void Song::setMType(MType t)
1574
 
      {
1575
 
      _mtype = t;
1576
 
      MusEGlobal::song->update(SC_SONG_TYPE);
1577
 
      }
1578
 
 
1579
1586
//---------------------------------------------------------
1580
1587
//   beat
1581
1588
//---------------------------------------------------------
1765
1772
            redoList->clearDelete();
1766
1773
            MusEGlobal::undoAction->setEnabled(true);
1767
1774
            MusEGlobal::redoAction->setEnabled(false);
 
1775
            setUndoRedoText();
1768
1776
            emit songChanged(updateFlags);
1769
1777
            }
1770
1778
      }
1782
1790
      doUndo3();
1783
1791
      MusEGlobal::redoAction->setEnabled(true);
1784
1792
      MusEGlobal::undoAction->setEnabled(!undoList->empty());
 
1793
      setUndoRedoText();
1785
1794
 
1786
1795
      if(updateFlags && (SC_TRACK_REMOVED | SC_TRACK_INSERTED))
1787
1796
        MusEGlobal::audio->msgUpdateSoloStates();
1802
1811
      doRedo3();
1803
1812
      MusEGlobal::undoAction->setEnabled(true);
1804
1813
      MusEGlobal::redoAction->setEnabled(!redoList->empty());
 
1814
      setUndoRedoText();
1805
1815
 
1806
1816
      if(updateFlags && (SC_TRACK_REMOVED | SC_TRACK_INSERTED))
1807
1817
        MusEGlobal::audio->msgUpdateSoloStates();
2089
2099
        MusEGlobal::undoAction->setEnabled(false);
2090
2100
      if(MusEGlobal::redoAction)
2091
2101
        MusEGlobal::redoAction->setEnabled(false);
 
2102
      setUndoRedoText();
2092
2103
      
2093
2104
      _markerList->clear();
2094
2105
      pos[0].setTick(0);
2102
2113
 
2103
2114
      // Clear all midi port controller values.
2104
2115
      for(int i = 0; i < MIDI_PORTS; ++i)
2105
 
        // Don't remove the controllers, just the values.
2106
 
        MusEGlobal::midiPorts[i].controller()->clearDelete(false);
 
2116
      {
 
2117
        // Remove the controllers AND the values so we start with a clean slate.
 
2118
        MusEGlobal::midiPorts[i].controller()->clearDelete(true);
 
2119
        // Don't forget to re-add the default managed controllers.
 
2120
        MusEGlobal::midiPorts[i].addDefaultControllers();
 
2121
      }
2107
2122
 
2108
2123
      _masterFlag    = true;
2109
2124
      loopFlag       = false;
2112
2127
      punchoutFlag   = false;
2113
2128
      recordFlag     = false;
2114
2129
      soloFlag       = false;
2115
 
      // seq
2116
 
      _mtype         = MT_UNKNOWN;
2117
2130
      _recMode       = REC_OVERDUP;
2118
2131
      _cycleMode     = CYCLE_NORMAL;
2119
2132
      _click         = false;
2122
2135
      _follow        = JUMP;
2123
2136
      dirty          = false;
2124
2137
      initDrumMap();
 
2138
      initNewDrumMap();
2125
2139
      if (signal) {
2126
2140
            emit loopChanged(false);
2127
2141
            recordChanged(false);
2128
 
            emit songChanged(-1);
 
2142
            emit songChanged(-1);  
2129
2143
            }
2130
2144
      }
2131
2145
 
3041
3055
      switch(track->type()) {
3042
3056
            case Track::MIDI:
3043
3057
            case Track::DRUM:
 
3058
            case Track::NEW_DRUM:
3044
3059
                  _midis.push_back((MidiTrack*)track);
3045
3060
                  addPortCtrlEvents(((MidiTrack*)track));
3046
3061
                  
3246
3261
      switch(track->type()) {
3247
3262
            case Track::MIDI:
3248
3263
            case Track::DRUM:
 
3264
            case Track::NEW_DRUM:
3249
3265
                  removePortCtrlEvents(((MidiTrack*)track));
3250
3266
                  unchainTrackParts(track, true);
3251
3267