← Back to branch summary

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

« back to all changes in this revision

Viewing changes to muse/song.cpp

  • Committer: Package Import Robot
  • Author(s): Alessio Treglia
  • Date: 2011-08-12 11:16:41 UTC
  • mfrom: (1.1.9) (10.1.6 sid)
  • Revision ID: package-import@ubuntu.com-20110812111641-sjz0e93fr0ozfv0b
Tags: 2.0~beta2-1
http://bugs.debian.org/627371
http://bugs.debian.org/604584
http://bugs.debian.org/570833
* New maintainer (see bug 637185#12), thanks Daniel!
* New upstream release (Closes: #627371):
  - New interface Qt4-based (Closes: #604584)
* Refresh packaging:
  - Move to DH7 and source format 3.0 (quilt).
  - Refresh patchset.
  - Fix a bunch lintian warnings.
  - debian/postinst:
    + Use set -e in the body rather than pass -e on the #! line to make it
      have actually effect if it is run by hand with "sh /path/to/script".
  - Update instructions on how-to increase RTC clock frequency.
    Thanks to Torquil Macdonald Sørensen for the report (Closes: #570833).
  - Bump Standards.

Show diffs side-by-side

added added

removed removed

Lines of Context:
muse/song.cpp
9
9
#include <unistd.h>
10
10
#include <stdio.h>
11
11
#include <errno.h>
12
 
#include <qapplication.h>
13
 
#include <qmessagebox.h>
14
 
#include <qpopupmenu.h>
15
 
#include <qdir.h>
16
 
#include <qaction.h>
17
 
#include <qcursor.h>
18
 
#include <qpoint.h>
19
 
#include <qbutton.h>
 
12
 
 
13
#include <QAction>
 
14
#include <QDir>
 
15
#include <QMenu>
 
16
#include <QMessageBox>
 
17
#include <QPoint>
 
18
#include <QSignalMapper>
 
19
#include <QTextStream>
20
20
 
21
21
#include "app.h"
22
22
#include "driver/jackmidi.h"
40
40
#include "midictrl.h"
41
41
#include "menutitleitem.h"
42
42
#include "midi.h"
43
 
#include "sig.h"
 
43
///#include "sig.h"
 
44
#include "al/sig.h"
 
45
#include "keyevent.h"
44
46
#include <sys/wait.h>
45
47
 
46
48
extern void clearMidiTransforms();
72
74
//---------------------------------------------------------
73
75
 
74
76
Song::Song(const char* name)
75
 
   :QObject(0, name)
 
77
   :QObject(0)
76
78
      {
77
 
      _recRaster     = 0; // Set to measure, the same as Arranger intial value. Arranger snap combo will set this.
 
79
      setObjectName(name);
 
80
      _arrangerRaster     = 0; // Set to measure, the same as Arranger intial value. Arranger snap combo will set this.
78
81
      noteFifoSize   = 0;
79
82
      noteFifoWindex = 0;
80
83
      noteFifoRindex = 0;
131
134
            }
132
135
      }
133
136
 
 
137
void Song::setSig(const AL::TimeSignature& sig)
 
138
      {
 
139
      if (_masterFlag) {
 
140
            audio->msgAddSig(pos[0].tick(), sig.z, sig.n);
 
141
            }
 
142
      }
 
143
 
134
144
//---------------------------------------------------------
135
145
//    addNewTrack
136
146
//    Called from GUI context
137
147
//    Besides normal track types, n includes synth menu ids from populateAddTrack()
138
148
//---------------------------------------------------------
139
149
 
140
 
Track* Song::addNewTrack(int n)
 
150
Track* Song::addNewTrack(QAction* action)
141
151
{
 
152
  int n = action->data().toInt();
142
153
    // Ignore negative numbers since this slot could be called by a menu or list etc. passing -1.
143
154
    if(n < 0)
144
155
      return 0;                  
245
256
      msgInsertTrack(track, -1, true);
246
257
      insertTrack3(track, -1);
247
258
 
 
259
      // Add default track <-> midiport routes. 
 
260
      if(track->isMidiTrack()) 
 
261
      {
 
262
        MidiTrack* mt = (MidiTrack*)track;
 
263
        int c, cbi, ch;
 
264
        bool defOutFound = false;                /// TODO: Remove this if and when multiple output routes supported.
 
265
        for(int i = 0; i < MIDI_PORTS; ++i)
 
266
        {
 
267
          MidiPort* mp = &midiPorts[i];
 
268
          
 
269
          if(mp->device())  // Only if device is valid. p4.0.17 
 
270
          {
 
271
            c = mp->defaultInChannels();
 
272
            if(c)
 
273
            {
 
274
              audio->msgAddRoute(Route(i, c), Route(track, c));
 
275
              updateFlags |= SC_ROUTE;
 
276
            }
 
277
          }  
 
278
          
 
279
          if(!defOutFound)                       ///
 
280
          {
 
281
            c = mp->defaultOutChannels();
 
282
            if(c)
 
283
            {
 
284
              
 
285
        /// TODO: Switch if and when multiple output routes supported.
 
286
        #if 0
 
287
              audio->msgAddRoute(Route(track, c), Route(i, c));
 
288
              updateFlags |= SC_ROUTE;
 
289
        #else 
 
290
              for(ch = 0; ch < MIDI_CHANNELS; ++ch)   
 
291
              {
 
292
                cbi = 1 << ch;
 
293
                if(c & cbi)
 
294
                {
 
295
                  defOutFound = true;
 
296
                  mt->setOutPort(i);
 
297
                  if(type != Track::DRUM)  // p4.0.17 Leave drum tracks at channel 10.
 
298
                    mt->setOutChannel(ch);
 
299
                  updateFlags |= SC_ROUTE;
 
300
                  break;               
 
301
                }
 
302
              }
 
303
        #endif
 
304
            }
 
305
          }  
 
306
        }
 
307
      }
 
308
                  
248
309
      //
249
310
      //  add default route to master
250
311
      //
252
313
      if (!ol->empty()) {
253
314
            AudioOutput* ao = ol->front();
254
315
            switch(type) {
255
 
                  case Track::MIDI:
256
 
                  case Track::DRUM:
257
 
                  case Track::AUDIO_OUTPUT:
258
 
                        break;
 
316
                  //case Track::MIDI:
 
317
                  //case Track::DRUM:
 
318
                  //case Track::AUDIO_OUTPUT:
 
319
                  //      break;
 
320
                  
259
321
                  case Track::WAVE:
260
 
                  case Track::AUDIO_GROUP:
 
322
                  //case Track::AUDIO_GROUP:  // Removed by Tim.
261
323
                  case Track::AUDIO_AUX:
262
 
                  case Track::AUDIO_INPUT:
 
324
                  //case Track::AUDIO_INPUT:  // Removed by Tim.
263
325
                  // p3.3.38
264
326
                  //case Track::AUDIO_SOFTSYNTH:
265
327
                        audio->msgAddRoute(Route((AudioTrack*)track, -1), Route(ao, -1));
270
332
                        audio->msgAddRoute(Route((AudioTrack*)track, 0, ((AudioTrack*)track)->channels()), Route(ao, 0, ((AudioTrack*)track)->channels()));
271
333
                        updateFlags |= SC_ROUTE;
272
334
                        break;
 
335
                  default:
 
336
                        break;
273
337
                  }
274
338
            }
275
339
      audio->msgUpdateSoloStates();
385
449
      {
386
450
        // This can be normal for some (redundant) operations.
387
451
        if(debugMsg)
388
 
          printf("Song::addEvent event already found in part:%s size:%zd\n", part->name().latin1(), part->events()->size());
 
452
          printf("Song::addEvent event already found in part:%s size:%zd\n", part->name().toLatin1().constData(), part->events()->size());
389
453
        return false;
390
454
      }
391
455
      
404
468
      if (i == part->events()->end()) {
405
469
            // This can be normal for some (redundant) operations.
406
470
            if(debugMsg)
407
 
              printf("Song::changeEvent event not found in part:%s size:%zd\n", part->name().latin1(), part->events()->size());
 
471
              printf("Song::changeEvent event not found in part:%s size:%zd\n", part->name().toLatin1().constData(), part->events()->size());
408
472
            // abort();
409
473
            // Removed by T356. Allow it to add the new event. 
410
474
            // (And remove the old one from the midi port controller!)
506
570
      if (ev == part->events()->end()) {
507
571
            // This can be normal for some (redundant) operations.
508
572
            if(debugMsg)
509
 
              printf("Song::deleteEvent event not found in part:%s size:%zd\n", part->name().latin1(), part->events()->size());
 
573
              printf("Song::deleteEvent event not found in part:%s size:%zd\n", part->name().toLatin1().constData(), part->events()->size());
510
574
            return;
511
575
            }
512
576
      part->events()->erase(ev);
739
803
            //startTick = roundDownBar(startTick);
740
804
            //endTick   = roundUpBar(endTick);
741
805
            // Round the start down using the Arranger part snap raster value. 
742
 
            startTick = sigmap.raster1(startTick, recRaster());
 
806
            startTick = AL::sigmap.raster1(startTick, arrangerRaster());
743
807
            // Round the end up using the Arranger part snap raster value. 
744
 
            endTick   = sigmap.raster2(endTick, recRaster());
 
808
            endTick   = AL::sigmap.raster2(endTick, arrangerRaster());
745
809
            
746
810
            part->setTick(startTick);
747
811
            part->setLenTick(endTick - startTick);
776
840
            // Added by Tim. p3.3.8
777
841
            
778
842
            // Round the end up (again) using the Arranger part snap raster value. 
779
 
            endTick   = sigmap.raster2(endTick, recRaster());
 
843
            endTick   = AL::sigmap.raster2(endTick, arrangerRaster());
780
844
            
781
845
            // Remove all of the part's port controller values. Indicate do not do clone parts.
782
846
            removePortCtrlEvents(part, false);
995
1059
      {
996
1060
      if (loopFlag != f) {
997
1061
            loopFlag = f;
998
 
            loopAction->setOn(loopFlag);
 
1062
            loopAction->setChecked(loopFlag);
999
1063
            emit loopChanged(loopFlag);
1000
1064
            }
1001
1065
      }
1014
1078
//---------------------------------------------------------
1015
1079
void Song::setRecord(bool f, bool autoRecEnable)
1016
1080
      {
 
1081
      if(debugMsg)
 
1082
        printf("setRecord recordflag =%d f(record state)=%d autoRecEnable=%d\n", recordFlag, f, autoRecEnable);
 
1083
 
 
1084
      if (f && config.useProjectSaveDialog && museProject == museProjectInitPath ) { // check that there is a project stored before commencing
 
1085
        // no project, we need to create one.
 
1086
        if (!muse->saveAs())
 
1087
          return; // could not store project, won't enable record
 
1088
      }
1017
1089
      if (recordFlag != f) {
1018
1090
            if (f && autoRecEnable) {
1019
1091
                bool alreadyRecEnabled = false;
1055
1127
                            f = false;
1056
1128
                            }
1057
1129
                      }
 
1130
                // prepare recording of wave files for all record enabled wave tracks
 
1131
                for (iWaveTrack i = wtl->begin(); i != wtl->end(); ++i) {
 
1132
                      if((*i)->recordFlag() || (selectedTrack == (*i) && autoRecEnable)) // prepare if record flag or if it is set to recenable
 
1133
                      {                                                                  // setRecordFlag may take too long time to complete
 
1134
                                                                                         // so we try this case specifically
 
1135
                        (*i)->prepareRecording();
 
1136
                      }
 
1137
                }
 
1138
 
1058
1139
#if 0
1059
1140
                  // check for midi devices suitable for recording
1060
1141
                  bool portFound = false;
1076
1157
            if (audio->isPlaying() && f)
1077
1158
                  f = false;
1078
1159
            recordFlag = f;
1079
 
            recordAction->setOn(recordFlag);
 
1160
            recordAction->setChecked(recordFlag);
1080
1161
            emit recordChanged(recordFlag);
1081
1162
            }
1082
1163
      }
1090
1171
      {
1091
1172
      if (punchinFlag != f) {
1092
1173
            punchinFlag = f;
1093
 
            punchinAction->setOn(punchinFlag);
 
1174
            punchinAction->setChecked(punchinFlag);
1094
1175
            emit punchinChanged(punchinFlag);
1095
1176
            }
1096
1177
      }
1104
1185
      {
1105
1186
      if (punchoutFlag != f) {
1106
1187
            punchoutFlag = f;
1107
 
            punchoutAction->setOn(punchoutFlag);
 
1188
            punchoutAction->setChecked(punchoutFlag);
1108
1189
            emit punchoutChanged(punchoutFlag);
1109
1190
            }
1110
1191
      }
1163
1244
      }
1164
1245
      // only allow the user to set the button "on"
1165
1246
      if (!f)
1166
 
            playAction->setOn(true);
 
1247
            playAction->setChecked(true);
1167
1248
      else
1168
1249
            audio->msgPlay(true);
1169
1250
      }
1177
1258
      }
1178
1259
      // only allow the user to set the button "on"
1179
1260
      if (!f)
1180
 
            stopAction->setOn(true);
 
1261
            stopAction->setChecked(true);
1181
1262
      else
1182
1263
            audio->msgPlay(false);
1183
1264
      }
1189
1270
 
1190
1271
      emit playChanged(f);   // signal transport window
1191
1272
 
1192
 
      playAction->setOn(f);
1193
 
      stopAction->setOn(!f);
 
1273
      playAction->setChecked(f);
 
1274
      stopAction->setChecked(!f);
1194
1275
 
1195
1276
      stopAction->blockSignals(false);
1196
1277
      playAction->blockSignals(false);
1209
1290
      }
1210
1291
 
1211
1292
//---------------------------------------------------------
 
1293
//   seekTo
 
1294
//   setPos slot, only active when not doing playback
 
1295
//---------------------------------------------------------
 
1296
void Song::seekTo(int tick)
 
1297
{
 
1298
  if (!audio->isPlaying()) {
 
1299
    Pos p(tick, true);
 
1300
    setPos(0, p);
 
1301
  }
 
1302
}
 
1303
//---------------------------------------------------------
1212
1304
//   setPos
1213
1305
//   song->setPos(Song::CPOS, pos, true, true, true);
1214
1306
//---------------------------------------------------------
1375
1467
 
1376
1468
void Song::initLen()
1377
1469
      {
1378
 
      _len = sigmap.bar2tick(40, 0, 0);    // default song len
 
1470
      _len = AL::sigmap.bar2tick(40, 0, 0);    // default song len
1379
1471
      for (iTrack t = _tracks.begin(); t != _tracks.end(); ++t) {
1380
1472
            MidiTrack* track = dynamic_cast<MidiTrack*>(*t);
1381
1473
            if (track == 0)
1407
1499
      {
1408
1500
      int bar, beat;
1409
1501
      unsigned tick;
1410
 
      sigmap.tickValues(t, &bar, &beat, &tick);
 
1502
      AL::sigmap.tickValues(t, &bar, &beat, &tick);
1411
1503
      if (beat || tick)
1412
 
            return sigmap.bar2tick(bar+1, 0, 0);
 
1504
            return AL::sigmap.bar2tick(bar+1, 0, 0);
1413
1505
      return t;
1414
1506
      }
1415
1507
 
1421
1513
      {
1422
1514
      int bar, beat;
1423
1515
      unsigned tick;
1424
 
      sigmap.tickValues(t, &bar, &beat, &tick);
 
1516
      AL::sigmap.tickValues(t, &bar, &beat, &tick);
1425
1517
      if (tick)
1426
 
            return sigmap.bar2tick(bar, beat+1, 0);
 
1518
            return AL::sigmap.bar2tick(bar, beat+1, 0);
1427
1519
      return t;
1428
1520
      }
1429
1521
 
1435
1527
      {
1436
1528
      int bar, beat;
1437
1529
      unsigned tick;
1438
 
      sigmap.tickValues(t, &bar, &beat, &tick);
1439
 
      return sigmap.bar2tick(bar, 0, 0);
 
1530
      AL::sigmap.tickValues(t, &bar, &beat, &tick);
 
1531
      return AL::sigmap.bar2tick(bar, 0, 0);
1440
1532
      }
1441
1533
 
1442
1534
//---------------------------------------------------------
1446
1538
void Song::dumpMaster()
1447
1539
      {
1448
1540
      tempomap.dump();
1449
 
      sigmap.dump();
 
1541
      AL::sigmap.dump();
1450
1542
      }
1451
1543
 
1452
1544
//---------------------------------------------------------
1553
1645
      {
1554
1646
//   printf("set MType %d\n", t);
1555
1647
      _mtype = t;
 
1648
      song->update(SC_SONG_TYPE);  // p4.0.7 Tim.
1556
1649
      }
1557
1650
 
1558
1651
//---------------------------------------------------------
1692
1785
            }
1693
1786
//      updateFlags |= SC_RECFLAG;
1694
1787
      update(SC_RECFLAG);
 
1788
 
1695
1789
      }
1696
1790
 
1697
1791
//---------------------------------------------------------
1850
1944
 
1851
1945
            case SEQM_ADD_SIG:
1852
1946
                  undoOp(UndoOp::AddSig, msg->a, msg->b, msg->c);
1853
 
                  sigmap.add(msg->a, msg->b, msg->c);
 
1947
                  AL::sigmap.add(msg->a, AL::TimeSignature(msg->b, msg->c));
1854
1948
                  updateFlags = SC_SIG;
1855
1949
                  break;
1856
1950
 
1857
1951
            case SEQM_REMOVE_SIG:
1858
1952
                  undoOp(UndoOp::DeleteSig, msg->a, msg->b, msg->c);
1859
 
                  sigmap.del(msg->a);
 
1953
                  AL::sigmap.del(msg->a);
1860
1954
                  updateFlags = SC_SIG;
1861
1955
                  break;
1862
1956
 
 
1957
            case SEQM_ADD_KEY:
 
1958
                  undoOp(UndoOp::AddKey, msg->a, msg->b);
 
1959
                  keymap.addKey(msg->a, (key_enum) msg->b);
 
1960
                  updateFlags = SC_KEY;
 
1961
                  break;
 
1962
 
 
1963
            case SEQM_REMOVE_KEY:
 
1964
                  undoOp(UndoOp::DeleteKey, msg->a, msg->b);
 
1965
                  keymap.delKey(msg->a);
 
1966
                  updateFlags = SC_KEY;
 
1967
                  break;
 
1968
 
1863
1969
            default:
1864
1970
                  printf("unknown seq message %d\n", msg->id);
1865
1971
                  break;
1941
2047
//    signal - emit signals for changes if true
1942
2048
//    called from constructor as clear(false) and
1943
2049
//    from MusE::clearSong() as clear(false)
 
2050
//    If clear_all is false, it will not touch things like midi ports.  
1944
2051
//---------------------------------------------------------
1945
2052
 
1946
 
void Song::clear(bool signal)
 
2053
void Song::clear(bool signal, bool /*clear_all*/)
1947
2054
      {
1948
2055
      if(debugMsg)
1949
2056
        printf("Song::clear\n");
1968
2075
        // p3.3.50 Reset this.
1969
2076
        midiPorts[i].setFoundInSongFile(false);
1970
2077
 
1971
 
        // This will also close the device.
1972
 
        midiPorts[i].setMidiDevice(0);
 
2078
        //if(clear_all)  // Allow not touching devices. p4.0.17  TESTING: Maybe some problems...
 
2079
          // This will also close the device.
 
2080
          midiPorts[i].setMidiDevice(0);
1973
2081
      }
1974
2082
      
1975
2083
      _synthIs.clearDelete();
1986
2094
          //if((*imd)->deviceType() == MidiDevice::JACK_MIDI)
1987
2095
          if(dynamic_cast< MidiJackDevice* >(*imd))
1988
2096
          {
1989
 
            // Remove the device from the list.
1990
 
            midiDevices.erase(imd);
1991
 
            // Since Jack midi devices are created dynamically, we must delete them.
1992
 
            // The destructor unregisters the device from Jack, which also disconnects all device-to-jack routes.
1993
 
            // This will also delete all midi-track-to-device routes, they point to non-existant midi tracks 
1994
 
            //  which were all deleted above
1995
 
            delete (*imd);
1996
 
            loop = true;
1997
 
            break;
 
2097
            //if(clear_all)  // Allow not touching devices. p4.0.17  TESTING: Maybe some problems...
 
2098
            {
 
2099
              // Remove the device from the list.
 
2100
              midiDevices.erase(imd);
 
2101
              // Since Jack midi devices are created dynamically, we must delete them.
 
2102
              // The destructor unregisters the device from Jack, which also disconnects all device-to-jack routes.
 
2103
              // This will also delete all midi-track-to-device routes, they point to non-existant midi tracks 
 
2104
              //  which were all deleted above
 
2105
              delete (*imd);
 
2106
              loop = true;
 
2107
              break;
 
2108
            }  
1998
2109
          }  
1999
2110
          else
2000
2111
          //if((*imd)->deviceType() == MidiDevice::ALSA_MIDI)
2010
2121
      while (loop);
2011
2122
      
2012
2123
      tempomap.clear();
2013
 
      sigmap.clear();
 
2124
      AL::sigmap.clear();
 
2125
      keymap.clear();
2014
2126
      undoList->clearDelete();
2015
2127
      redoList->clear();
2016
2128
      _markerList->clear();
2049
2161
      if (signal) {
2050
2162
            emit loopChanged(false);
2051
2163
            recordChanged(false);
 
2164
            emit songChanged(-1);
2052
2165
            }
2053
2166
      }
2054
2167
 
2095
2208
      _synthIs.clearDelete();    // each ~SynthI() -> deactivate3() -> ~SynthIF()
2096
2209
 
2097
2210
      tempomap.clear();
2098
 
      sigmap.clear();
 
2211
      AL::sigmap.clear();
 
2212
      keymap.clear();
2099
2213
      
2100
2214
      if(debugMsg)
2101
2215
        printf("deleting undoList, clearing redoList\n");
2116
2230
        // Remove the controllers and the values.
2117
2231
        midiPorts[i].controller()->clearDelete(true);
2118
2232
        
2119
 
      // Can't do this here. Jack isn't running.
2120
 
      /*
 
2233
      // Can't do this here. Jack isn't running. Fixed. Test OK so far.
 
2234
      #if 1
2121
2235
      if(debugMsg)
2122
 
        printf("deleting midi devices\n");
 
2236
        printf("deleting midi devices except synths\n");
2123
2237
      for(iMidiDevice imd = midiDevices.begin(); imd != midiDevices.end(); ++imd)
2124
2238
      {
2125
2239
        // Since Syntis are midi devices, there's no need to delete them below.
2128
2242
        delete (*imd);
2129
2243
      }
2130
2244
      midiDevices.clear();     // midi devices
2131
 
      */
 
2245
      #endif
2132
2246
      
2133
2247
      if(debugMsg)
2134
 
        printf("deleting synths\n");
 
2248
        printf("deleting global available synths\n");
2135
2249
      // Delete all synths.
2136
2250
      std::vector<Synth*>::iterator is;
2137
2251
      for(is = synthis.begin(); is != synthis.end(); ++is)
2143
2257
      }
2144
2258
      synthis.clear();
2145
2259
      
 
2260
      if(debugMsg)
 
2261
        printf("deleting midi instruments\n");
 
2262
      for(iMidiInstrument imi = midiInstruments.begin(); imi != midiInstruments.end(); ++imi)
 
2263
      {
 
2264
        // Since Syntis are midi instruments, there's no need to delete them below.
 
2265
        // Tricky, must cast as SynthI*.
 
2266
        SynthI* s = dynamic_cast <SynthI*> (*imi);
 
2267
        if(s)
 
2268
          continue;
 
2269
        delete (*imi);
 
2270
      }
 
2271
      midiInstruments.clear();     // midi devices
 
2272
      
2146
2273
      // Nothing required for ladspa plugin list, and rack instances of them
2147
2274
      //  are handled by ~AudioTrack.
2148
2275
      
2193
2320
 
2194
2321
                        {
2195
2322
                        // give the user a sensible explanation
2196
 
                        int btn = QMessageBox::critical( muse, tr(QString("Jack shutdown!")),
2197
 
                            tr(QString("Jack has detected a performance problem which has lead to\n"
 
2323
                        int btn = QMessageBox::critical( muse, tr("Jack shutdown!"),
 
2324
                            tr("Jack has detected a performance problem which has lead to\n"
2198
2325
                            "MusE being disconnected.\n"
2199
2326
                            "This could happen due to a number of reasons:\n"
2200
2327
                            "- a performance issue with your particular setup.\n"
2208
2335
                            " homepage which is available through the help menu)\n"
2209
2336
                            "\n"
2210
2337
                            "To proceed check the status of Jack and try to restart it and then .\n"
2211
 
                            "click on the Restart button.")), "restart", "cancel");
 
2338
                            "click on the Restart button."), "restart", "cancel");
2212
2339
                        if (btn == 0) {
2213
2340
                              printf("restarting!\n");
2214
2341
                              muse->seqRestart();
2340
2467
{
2341
2468
  //enum { HEADER, SEP1, PREV_EVENT, NEXT_EVENT, SEP2, ADD_EVENT, CLEAR_EVENT, CLEAR_RANGE, CLEAR_ALL_EVENTS };
2342
2469
  enum { HEADER, PREV_EVENT, NEXT_EVENT, SEP2, ADD_EVENT, CLEAR_EVENT, CLEAR_RANGE, CLEAR_ALL_EVENTS };
2343
 
  QPopupMenu* menu = new QPopupMenu;
 
2470
  QMenu* menu = new QMenu;
2344
2471
 
2345
2472
  int count = 0;
2346
2473
  bool isEvent = false, canSeekPrev = false, canSeekNext = false, canEraseRange = false;
2377
2504
 
2378
2505
  //menu->insertItem(tr("Automation:"), HEADER, HEADER);
2379
2506
  //menu->setItemEnabled(HEADER, false);
2380
 
  MenuTitleItem* title = new MenuTitleItem(tr("Automation:"));
2381
 
  menu->insertItem(title, HEADER, HEADER);
 
2507
  //MenuTitleItem* title = new MenuTitleItem(tr("Automation:")); ddskrjo
 
2508
  //menu->insertItem(title, HEADER, HEADER); ddskrjo
 
2509
  menu->addAction(new MenuTitleItem(tr("Automation:"), menu));
2382
2510
  
2383
2511
  //menu->insertSeparator(SEP1);
2384
2512
  
2385
 
  menu->insertItem(tr("previous event"), PREV_EVENT, PREV_EVENT);
2386
 
  menu->setItemEnabled(PREV_EVENT, canSeekPrev);
2387
 
 
2388
 
  menu->insertItem(tr("next event"), NEXT_EVENT, NEXT_EVENT);
2389
 
  menu->setItemEnabled(NEXT_EVENT, canSeekNext);
2390
 
 
2391
 
  menu->insertSeparator(SEP2);
2392
 
 
 
2513
  QAction* prevEvent = menu->addAction(tr("previous event"));
 
2514
  prevEvent->setData(PREV_EVENT);
 
2515
  prevEvent->setEnabled(canSeekPrev);
 
2516
 
 
2517
  QAction* nextEvent = menu->addAction(tr("next event"));
 
2518
  nextEvent->setData(NEXT_EVENT);
 
2519
  nextEvent->setEnabled(canSeekNext);
 
2520
 
 
2521
  //menu->insertSeparator(SEP2);
 
2522
  menu->addSeparator();
 
2523
 
 
2524
  QAction* addEvent = new QAction(menu);
 
2525
  menu->addAction(addEvent);
2393
2526
  if(isEvent)
2394
 
    menu->insertItem(tr("set event"), ADD_EVENT, ADD_EVENT);
 
2527
    addEvent->setText(tr("set event"));
2395
2528
  else  
2396
 
    menu->insertItem(tr("add event"), ADD_EVENT, ADD_EVENT);
2397
 
  menu->setItemEnabled(ADD_EVENT, canAdd);
2398
 
  menu->insertItem(tr("erase event"), CLEAR_EVENT, CLEAR_EVENT);
2399
 
  menu->setItemEnabled(CLEAR_EVENT, isEvent);
2400
 
 
2401
 
  menu->insertItem(tr("erase range"), CLEAR_RANGE, CLEAR_RANGE);
2402
 
  menu->setItemEnabled(CLEAR_RANGE, canEraseRange);
2403
 
 
2404
 
  menu->insertItem(tr("clear automation"), CLEAR_ALL_EVENTS, CLEAR_ALL_EVENTS);
2405
 
  menu->setItemEnabled(CLEAR_ALL_EVENTS, (bool)count);
2406
 
 
2407
 
  int sel = menu->exec(menupos, 1);
 
2529
    addEvent->setText(tr("add event"));
 
2530
  addEvent->setData(ADD_EVENT);
 
2531
  addEvent->setEnabled(canAdd);
 
2532
 
 
2533
  QAction* eraseEventAction = menu->addAction(tr("erase event"));
 
2534
  eraseEventAction->setData(CLEAR_EVENT);
 
2535
  eraseEventAction->setEnabled(isEvent);
 
2536
 
 
2537
  QAction* eraseRangeAction = menu->addAction(tr("erase range"));
 
2538
  eraseRangeAction->setData(CLEAR_RANGE);
 
2539
  eraseRangeAction->setEnabled(canEraseRange);
 
2540
 
 
2541
  QAction* clearAction = menu->addAction(tr("clear automation"));
 
2542
  clearAction->setData(CLEAR_ALL_EVENTS);
 
2543
  clearAction->setEnabled((bool)count);
 
2544
 
 
2545
  QAction* act = menu->exec(menupos);
 
2546
  //delete menu;
 
2547
  if (!act || !track)
 
2548
  {
 
2549
    delete menu;
 
2550
    return -1;
 
2551
  }
 
2552
  
 
2553
  //if(!track)
 
2554
  //  return -1;
 
2555
 
 
2556
  int sel = act->data().toInt();
2408
2557
  delete menu;
2409
 
  if (sel == -1)
2410
 
    return -1;
2411
2558
  
2412
 
  if(!track)
2413
 
    return -1;
2414
2559
  switch(sel)
2415
2560
  {
2416
2561
    case ADD_EVENT:
2443
2588
          return -1;
2444
2589
    break;      
2445
2590
  }
 
2591
  
2446
2592
  return sel;
2447
2593
}
2448
2594
 
2457
2603
    
2458
2604
  //enum { HEADER, SEP1, PREV_EVENT, NEXT_EVENT, SEP2, ADD_EVENT, CLEAR_EVENT, CLEAR_RANGE, CLEAR_ALL_EVENTS };
2459
2605
  enum { HEADER, ADD_EVENT, CLEAR_EVENT };
2460
 
  QPopupMenu* menu = new QPopupMenu;
 
2606
  QMenu* menu = new QMenu;
2461
2607
 
2462
2608
  //int count = 0;
2463
2609
  bool isEvent = false;
2545
2691
 
2546
2692
  //menu->insertItem(tr("Automation:"), HEADER, HEADER);
2547
2693
  //menu->setItemEnabled(HEADER, false);
2548
 
  MenuTitleItem* title = new MenuTitleItem(tr("Automation:"));
2549
 
  menu->insertItem(title, HEADER, HEADER);
 
2694
  //MenuTitleItem* title = new MenuTitleItem(tr("Automation:")); ddskrjo
 
2695
  ///menu->insertItem(title, HEADER, HEADER); ddskrjo
2550
2696
  
2551
2697
  //menu->insertSeparator(SEP1);
2552
2698
  
2558
2704
 
2559
2705
//  menu->insertSeparator(SEP2);
2560
2706
 
 
2707
  QAction* addEvent = new QAction(menu);
 
2708
  menu->addAction(addEvent);
2561
2709
  if(isEvent)
2562
 
    menu->insertItem(tr("set event"), ADD_EVENT, ADD_EVENT);
2563
 
  else  
2564
 
    menu->insertItem(tr("add event"), ADD_EVENT, ADD_EVENT);
2565
 
  //menu->setItemEnabled(ADD_EVENT, canAdd);
2566
 
  menu->setItemEnabled(ADD_EVENT, true);
2567
 
  
2568
 
  menu->insertItem(tr("erase event"), CLEAR_EVENT, CLEAR_EVENT);
2569
 
  menu->setItemEnabled(CLEAR_EVENT, isEvent);
 
2710
    addEvent->setText(tr("set event"));
 
2711
  else
 
2712
    addEvent->setText(tr("add event"));
 
2713
  addEvent->setData(ADD_EVENT);
 
2714
  //addEvent->setEnabled(canAdd);
 
2715
  addEvent->setEnabled(true);
 
2716
 
 
2717
  QAction* eraseEventAction = menu->addAction(tr("erase event"));
 
2718
  eraseEventAction->setData(CLEAR_EVENT);
 
2719
  eraseEventAction->setEnabled(isEvent);
2570
2720
 
2571
2721
//  menu->insertItem(tr("erase range"), CLEAR_RANGE, CLEAR_RANGE);
2572
2722
//  menu->setItemEnabled(CLEAR_RANGE, canEraseRange);
2574
2724
//  menu->insertItem(tr("clear automation"), CLEAR_ALL_EVENTS, CLEAR_ALL_EVENTS);
2575
2725
//  menu->setItemEnabled(CLEAR_ALL_EVENTS, (bool)count);
2576
2726
 
2577
 
  int sel = menu->exec(menupos, 1);
2578
 
  delete menu;
2579
 
  if (sel == -1)
 
2727
 
 
2728
  QAction* act = menu->exec(menupos);
 
2729
  //delete menu;
 
2730
  if (!act)
 
2731
  {
 
2732
    delete menu;
2580
2733
    return -1;
 
2734
  }
2581
2735
  
2582
2736
  //if(!part)
2583
2737
  //  return -1;
2584
2738
  
 
2739
  int sel = act->data().toInt();
 
2740
  delete menu;
 
2741
  
2585
2742
  switch(sel)
2586
2743
  {
2587
2744
    case ADD_EVENT:
2869
3026
      for(int ch = 0; ch < MIDI_CHANNELS; ++ch) 
2870
3027
      {
2871
3028
        //QAction* a = m->addAction(QString("Channel %1").arg(ch+1));
2872
 
        //subp->insertItem(QT_TR_NOOP(QString("Channel %1").arg(ch+1)), i * MIDI_CHANNELS + ch);
 
3029
        //subp->insertItem(QT_TRANSLATE_NOOP("@default", QString("Channel %1").arg(ch+1)), i * MIDI_CHANNELS + ch);
2873
3030
        gid = i * MIDI_CHANNELS + ch;
2874
3031
        
2875
3032
        //printf("MidiStrip::iRoutePressed inserting gid:%d\n", gid);
2892
3049
          }
2893
3050
        }
2894
3051
      }
2895
 
      pup->insertItem(QT_TR_NOOP(md->name()), subp);
 
3052
      pup->insertItem(QT_TRANSLATE_NOOP("@default", md->name()), subp);
2896
3053
    }
2897
3054
        
2898
3055
//    QPopupMenu* pup = new QPopupMenu(iR);
2905
3062
//    for (int i = 0; i < channel; ++i) 
2906
3063
//    {
2907
3064
//          char buffer[128];
2908
 
//          snprintf(buffer, 128, "%s %d", tr("Channel").latin1(), i+1);
 
3065
//          snprintf(buffer, 128, "%s %d", tr("Channel").toLatin1().constData(), i+1);
2909
3066
//          MenuTitleItem* titel = new MenuTitleItem(QString(buffer));
2910
3067
//          pup->insertItem(titel);
2911
3068
 
2959
3116
          }  
2960
3117
          
2961
3118
          //QString s(pup->text(n));
2962
 
          //QT_TR_NOOP(md->name())
 
3119
          //QT_TRANSLATE_NOOP("@default", md->name())
2963
3120
          
2964
3121
          //Route srcRoute(s, false, -1);
2965
3122
          Route aRoute(md, ch);
2981
3138
            // disconnect
2982
3139
            if(dst)
2983
3140
            {
2984
 
              //printf("Song::chooseMidiRoutes removing route src track name: %s dst device name: %s\n", track->name().latin1(), md->name().latin1());
 
3141
              //printf("Song::chooseMidiRoutes removing route src track name: %s dst device name: %s\n", track->name().toLatin1().constData(), md->name().toLatin1().constData());
2985
3142
              audio->msgRemoveRoute(bRoute, aRoute);
2986
3143
            }
2987
3144
            else
2988
3145
            {
2989
 
              //printf("Song::chooseMidiRoutes removing route src device name: %s dst track name: %s\n", md->name().latin1(), track->name().latin1());
 
3146
              //printf("Song::chooseMidiRoutes removing route src device name: %s dst track name: %s\n", md->name().toLatin1().constData(), track->name().toLatin1().constData());
2990
3147
              audio->msgRemoveRoute(aRoute, bRoute);
2991
3148
            }
2992
3149
          }
2995
3152
            // connect
2996
3153
            if(dst)
2997
3154
            {
2998
 
              //printf("Song::chooseMidiRoutes adding route src track name: %s dst device name: %s\n", track->name().latin1(), md->name().latin1());
 
3155
              //printf("Song::chooseMidiRoutes adding route src track name: %s dst device name: %s\n", track->name().toLatin1().constData(), md->name().toLatin1().constData());
2999
3156
              audio->msgAddRoute(bRoute, aRoute);
3000
3157
            }
3001
3158
            else
3002
3159
            {
3003
 
              //printf("Song::chooseMidiRoutes adding route src device name: %s dst track name: %s\n", md->name().latin1(), track->name().latin1());
 
3160
              //printf("Song::chooseMidiRoutes adding route src device name: %s dst track name: %s\n", md->name().toLatin1().constData(), track->name().toLatin1().constData());
3004
3161
              audio->msgAddRoute(aRoute, bRoute);
3005
3162
            }  
3006
3163
          }
3197
3354
            const RouteList* rl = track->inRoutes();
3198
3355
            for (ciRoute r = rl->begin(); r != rl->end(); ++r)
3199
3356
            {
3200
 
                  //printf("Song::insertTrack2 %s in route port:%d\n", track->name().latin1(), r->midiPort);   // p3.3.50
 
3357
                  //printf("Song::insertTrack2 %s in route port:%d\n", track->name().toLatin1().constData(), r->midiPort);   // p3.3.50
3201
3358
                  Route src(track, r->channel);
3202
3359
                  midiPorts[r->midiPort].outRoutes()->push_back(src);
3203
3360
            }
3204
3361
            rl = track->outRoutes();
3205
3362
            for (ciRoute r = rl->begin(); r != rl->end(); ++r)
3206
3363
            {
3207
 
                  //printf("Song::insertTrack2 %s out route port:%d\n", track->name().latin1(), r->midiPort);  // p3.3.50
 
3364
                  //printf("Song::insertTrack2 %s out route port:%d\n", track->name().toLatin1().constData(), r->midiPort);  // p3.3.50
3208
3365
                  Route src(track, r->channel);
3209
3366
                  midiPorts[r->midiPort].inRoutes()->push_back(src);
3210
3367
            }      
3301
3458
                SynthI* si = (SynthI*)track;
3302
3459
                if(si->hasGui())
3303
3460
                  si->showGui(false);
 
3461
                if(si->hasNativeGui())       // p4.0.20
 
3462
                  si->showNativeGui(false);
3304
3463
                }
3305
3464
              break;
3306
3465
          default:
3315
3474
 
3316
3475
void Song::removeTrack2(Track* track)
3317
3476
{
3318
 
      //printf("Song::removeTrack2 track:%s\n", track->name().latin1());  // p3.3.50
 
3477
      //printf("Song::removeTrack2 track:%s\n", track->name().toLatin1().constData());  // p3.3.50
3319
3478
                  
3320
3479
      switch(track->type()) {
3321
3480
            case Track::MIDI:
3398
3557
            {
3399
3558
                  //if(r->track == track)  
3400
3559
                  //  r->track->outRoutes()->removeRoute(*r);
3401
 
                  //printf("Song::removeTrack2 %s audio out track:%s\n", track->name().latin1(), r->track->name().latin1());  // p3.3.50
 
3560
                  //printf("Song::removeTrack2 %s audio out track:%s\n", track->name().toLatin1().constData(), r->track->name().toLatin1().constData());  // p3.3.50
3402
3561
                  // p3.3.50
3403
3562
                  Route src(track, r->channel, r->channels);
3404
3563
                  src.remoteChannel = r->remoteChannel;
3412
3571
            {
3413
3572
                  //if(r->track == track)  
3414
3573
                  //  r->track->inRoutes()->removeRoute(*r);
3415
 
                  //printf("Song::removeTrack2 %s audio in track:%s\n", track->name().latin1(), r->track->name().latin1());  // p3.3.50
 
3574
                  //printf("Song::removeTrack2 %s audio in track:%s\n", track->name().toLatin1().constData(), r->track->name().toLatin1().constData());  // p3.3.50
3416
3575
                  // p3.3.50
3417
3576
                  Route src(track, r->channel, r->channels);
3418
3577
                  src.remoteChannel = r->remoteChannel;
3424
3583
            const RouteList* rl = track->inRoutes();
3425
3584
            for (ciRoute r = rl->begin(); r != rl->end(); ++r)
3426
3585
            {
3427
 
                  //printf("Song::removeTrack2 %s in route port:%d\n", track->name().latin1(), r->midiPort);   // p3.3.50
 
3586
                  //printf("Song::removeTrack2 %s in route port:%d\n", track->name().toLatin1().constData(), r->midiPort);   // p3.3.50
3428
3587
                  Route src(track, r->channel);
3429
3588
                  midiPorts[r->midiPort].outRoutes()->removeRoute(src);
3430
3589
            }
3431
3590
            rl = track->outRoutes();
3432
3591
            for (ciRoute r = rl->begin(); r != rl->end(); ++r)
3433
3592
            {
3434
 
                  //printf("Song::removeTrack2 %s out route port:%d\n", track->name().latin1(), r->midiPort);  // p3.3.50
 
3593
                  //printf("Song::removeTrack2 %s out route port:%d\n", track->name().toLatin1().constData(), r->midiPort);  // p3.3.50
3435
3594
                  Route src(track, r->channel);
3436
3595
                  midiPorts[r->midiPort].inRoutes()->removeRoute(src);
3437
3596
            }      
3443
3602
            {
3444
3603
                  //if(r->track == track)   
3445
3604
                  //  r->track->outRoutes()->removeRoute(*r);
3446
 
                  //printf("Song::removeTrack2 %s in route track:%s\n", track->name().latin1(), r->track->name().latin1());  // p3.3.50
 
3605
                  //printf("Song::removeTrack2 %s in route track:%s\n", track->name().toLatin1().constData(), r->track->name().toLatin1().constData());  // p3.3.50
3447
3606
                  // p3.3.50
3448
3607
                  Route src(track, r->channel, r->channels);
3449
3608
                  src.remoteChannel = r->remoteChannel;
3454
3613
            {
3455
3614
                  //if(r->track == track)  
3456
3615
                  //  r->track->inRoutes()->removeRoute(*r);
3457
 
                  //printf("Song::removeTrack2 %s out route track:%s\n", track->name().latin1(), r->track->name().latin1());  // p3.3.50
 
3616
                  //printf("Song::removeTrack2 %s out route track:%s\n", track->name().toLatin1().constData(), r->track->name().toLatin1().constData());  // p3.3.50
3458
3617
                  // p3.3.50
3459
3618
                  Route src(track, r->channel, r->channels);
3460
3619
                  src.remoteChannel = r->remoteChannel;
3485
3644
      */
3486
3645
      }
3487
3646
 
3488
 
 
3489
3647
//---------------------------------------------------------
3490
3648
//   executeScript
3491
3649
//---------------------------------------------------------
3503
3661
      //
3504
3662
      song->startUndo(); // undo this entire block
3505
3663
      for (iPart i = parts->begin(); i != parts->end(); i++) {
3506
 
            const char* tmp = tmpnam(NULL);
 
3664
            //const char* tmp = tmpnam(NULL);
 
3665
            char tmp[16] = "muse-tmp-XXXXXX";
 
3666
            int fd = mkstemp(tmp);
3507
3667
            printf("script input filename=%s\n",tmp);
3508
 
            FILE *fp = fopen(tmp, "w");
 
3668
            //FILE *fp = fopen(tmp, "w");
 
3669
            FILE *fp = fdopen(fd , "w");
3509
3670
            MidiPart *part = (MidiPart*)(i->second);
3510
3671
            int partStart = part->endTick()-part->lenTick();
3511
3672
            int z, n;
3512
 
            sigmap.timesig(0, z, n);
 
3673
            AL::sigmap.timesig(0, z, n);
3513
3674
            fprintf(fp, "TIMESIG %d %d\n", z, n);
3514
3675
            fprintf(fp, "PART %d %d\n", partStart, part->lenTick());
3515
 
            fprintf(fp, "BEATLEN %d\n", sigmap.ticksBeat(0));
 
3676
            fprintf(fp, "BEATLEN %d\n", AL::sigmap.ticksBeat(0));
3516
3677
            fprintf(fp, "QUANTLEN %d\n", quant);
3517
3678
 
3518
3679
            //for (iCItem i = items.begin(); i != items.end(); ++i) {
3565
3726
                        // TODO: Create a new part, update the entire editor from it, hehh....
3566
3727
                      
3567
3728
                        QFile file(tmp);
3568
 
                        if ( file.open( IO_ReadOnly ) ) {
 
3729
                        if ( file.open( QIODevice::ReadOnly ) ) {
3569
3730
                            QTextStream stream( &file );
3570
3731
                            QString line;
3571
3732
                            while ( !stream.atEnd() ) {
3572
3733
                                line = stream.readLine(); // line of text excluding '\n'
3573
3734
                                if (line.startsWith("NOTE"))
3574
3735
                                {
3575
 
                                    QStringList sl = QStringList::split(" ",line);
 
3736
                                    QStringList sl = line.split(" ");
3576
3737
 
3577
3738
                                      Event e(Note);
3578
3739
                                      int tick = sl[1].toInt();
3589
3750
                                }
3590
3751
                                if (line.startsWith("CONTROLLER"))
3591
3752
                                {
3592
 
                                      QStringList sl = QStringList::split(" ",line);
 
3753
                                      QStringList sl = line.split(" ");
3593
3754
 
3594
3755
                                      Event e(Controller);
3595
3756
                                      int tick = sl[1].toInt();
3614
3775
      endUndo(SC_EVENT_REMOVED);
3615
3776
}
3616
3777
 
3617
 
#define SCRIPTSSUFFIX "/share/muse/scripts/"
3618
 
#define USERSCRIPTSSUFFIX "/.muse/scripts/"
3619
 
void Song::populateScriptMenu(QPopupMenu* menuPlugins, QObject* receiver)
 
3778
 
 
3779
void Song::populateScriptMenu(QMenu* menuPlugins, QObject* receiver)
3620
3780
{
3621
3781
      //
3622
3782
      // List scripts
3623
3783
      // 
3624
 
      QString distScripts = QString(INSTPREFIX) + QString(SCRIPTSSUFFIX);
3625
 
      QString home = "";
3626
 
      if (getenv("HOME") != NULL)
3627
 
            home = QString(getenv("HOME"));
3628
 
      QString userScripts = home + QString(USERSCRIPTSSUFFIX);
 
3784
      QString distScripts = museGlobalShare + "/scripts";
 
3785
 
 
3786
      QString userScripts = configPath + "/scripts";
3629
3787
 
3630
3788
      QFileInfo distScriptsFi(distScripts);
3631
3789
      if (distScriptsFi.isDir()) {
3640
3798
            userScriptNames = dir.entryList();
3641
3799
            }
3642
3800
 
 
3801
      QSignalMapper* distSignalMapper = new QSignalMapper(this);
 
3802
      QSignalMapper* userSignalMapper = new QSignalMapper(this);
 
3803
 
3643
3804
      if (deliveredScriptNames.size() > 0 || userScriptNames.size() > 0) {
3644
3805
            //menuPlugins = new QPopupMenu(this);
3645
3806
            //menuBar()->insertItem(tr("&Plugins"), menuPlugins);
3648
3809
                  for (QStringList::Iterator it = deliveredScriptNames.begin(); it != deliveredScriptNames.end(); it++, id++) {
3649
3810
                        //menuPlugins->insertItem(*it, this, SLOT(execDeliveredScript(int)), 0, id);
3650
3811
                        //menuPlugins->insertItem(*it, this, slot_deliveredscripts, 0, id);
3651
 
                        menuPlugins->insertItem(*it, receiver, SLOT(execDeliveredScript(int)), 0, id);
 
3812
                        QAction* act = menuPlugins->addAction(*it);
 
3813
                        connect(act, SIGNAL(triggered()), distSignalMapper, SLOT(map()));
 
3814
                        distSignalMapper->setMapping(act, id);
3652
3815
                        }
3653
 
                  menuPlugins->insertSeparator();
 
3816
                  menuPlugins->addSeparator();
3654
3817
                  }
3655
3818
            if (userScriptNames.size() > 0) {
3656
3819
                  for (QStringList::Iterator it = userScriptNames.begin(); it != userScriptNames.end(); it++, id++) {
3657
3820
                        //menuPlugins->insertItem(*it, this, slot_userscripts, 0, id);
3658
 
                        menuPlugins->insertItem(*it, receiver, SLOT(execUserScript(int)), 0, id);
 
3821
                        QAction* act = menuPlugins->addAction(*it);
 
3822
                        connect(act, SIGNAL(triggered()), userSignalMapper, SLOT(map()));
 
3823
                        userSignalMapper->setMapping(act, id);
3659
3824
                        }
3660
 
                  menuPlugins->insertSeparator();
 
3825
                  menuPlugins->addSeparator();
3661
3826
                  }
 
3827
            connect(distSignalMapper, SIGNAL(mapped(int)), receiver, SLOT(execDeliveredScript(int)));
 
3828
            connect(userSignalMapper, SIGNAL(mapped(int)), receiver, SLOT(execUserScript(int)));
3662
3829
            }
3663
3830
      return; 
3664
3831
}
3669
3836
QString Song::getScriptPath(int id, bool isdelivered)
3670
3837
{
3671
3838
      if (isdelivered) {
3672
 
            QString path = QString(INSTPREFIX) + SCRIPTSSUFFIX + deliveredScriptNames[id];
 
3839
            QString path = museGlobalShare + "/scripts/" + deliveredScriptNames[id];
3673
3840
            return path;
3674
3841
            }
3675
3842
 
3676
 
      QString path = QString(getenv("HOME")) + USERSCRIPTSSUFFIX + userScriptNames[id - deliveredScriptNames.size()];
 
3843
      QString path = configPath + "/scripts/" + userScriptNames[id - deliveredScriptNames.size()];
3677
3844
      return path;
3678
3845
}
3679
3846