← Back to branch summary

~ubuntu-branches/ubuntu/quantal/muse/quantal

« back to all changes in this revision

Viewing changes to muse/arranger/trackinfo.cpp

  • Committer: Package Import Robot
  • Author(s): Alessio Treglia
  • Date: 2011-08-12 11:16:41 UTC
  • mfrom: (1.2.1 upstream)
  • mto: This revision was merged to the branch mainline in revision 26.
  • Revision ID: package-import@ubuntu.com-20110812111641-sg7bj019yhh91mpl
Tags: upstream-2.0~beta2
Import upstream version 2.0~beta2

Show diffs side-by-side

added added

removed removed

Lines of Context:
muse/arranger/trackinfo.cpp
1
 
//=========================================================
2
 
//  MusE
3
 
//  Linux Music Editor
4
 
//    $Id: trackinfo.cpp,v 1.10.2.15 2009/11/14 03:37:48 terminator356 Exp $
5
 
//  (C) Copyright 1999-2004 Werner Schweer (ws@seh.de)
6
 
//=========================================================
7
 
 
8
 
#include <qlayout.h>
9
 
#include <qcombobox.h>
10
 
#include <qtoolbutton.h>
11
 
#include <qlabel.h>
12
 
#include <qpopupmenu.h>
13
 
#include <qmessagebox.h>
14
 
#include <qhbox.h>
15
 
#include <qcheckbox.h>
16
 
#include <qpushbutton.h>
17
 
#include <qwidgetstack.h>
18
 
#include <qlineedit.h>
19
 
#include <qtimer.h>
20
 
#include <math.h>
21
 
#include <string.h>
22
 
 
23
 
#include "song.h"
24
 
#include "globals.h"
25
 
#include "spinbox.h"
26
 
#include "config.h"
27
 
#include "gconfig.h"
28
 
#include "arranger.h"
29
 
#include "midiport.h"
30
 
#include "mididev.h"
31
 
#include "utils.h"
32
 
#include "tlist.h"
33
 
//#include "mtrackinfobase.h"
34
 
#include "alayout.h"
35
 
#include "audio.h"
36
 
#include "mixer/amixer.h"
37
 
#include "midi.h"
38
 
#include "midictrl.h"
39
 
#include "xpm/muse_leftside_logo.xpm"
40
 
#include "mixer/astrip.h"
41
 
#include "icons.h"
42
 
#include "app.h"
43
 
#include "route.h"
44
 
#include "popupmenu.h"
45
 
 
46
 
 
47
 
//---------------------------------------------------------
48
 
//   midiTrackInfoHeartBeat
49
 
//---------------------------------------------------------
50
 
 
51
 
void Arranger::midiTrackInfoHeartBeat()
52
 
{
53
 
  if(!showTrackinfoFlag || !selected)
54
 
    return;
55
 
  switch(selected->type()) 
56
 
  {
57
 
    case Track::MIDI:
58
 
    case Track::DRUM:
59
 
    {
60
 
      MidiTrack* track = (MidiTrack*)selected;
61
 
      
62
 
      int outChannel = track->outChannel();
63
 
      int outPort    = track->outPort();
64
 
      ///int ichMask    = track->inChannelMask();
65
 
      //int iptMask    = track->inPortMask();
66
 
      ///unsigned int iptMask    = track->inPortMask();
67
 
      
68
 
      MidiPort* mp = &midiPorts[outPort];
69
 
      
70
 
      // Set record echo.
71
 
      if(midiTrackInfo->recEchoButton->isOn() != track->recEcho())
72
 
      {
73
 
        midiTrackInfo->recEchoButton->blockSignals(true);
74
 
        midiTrackInfo->recEchoButton->setOn(track->recEcho());
75
 
        midiTrackInfo->recEchoButton->blockSignals(false);
76
 
      }
77
 
      
78
 
      // Check for detection of midi general activity on chosen channels...
79
 
      int mpt = 0;
80
 
      //int mch = 0;
81
 
      RouteList* rl = track->inRoutes();
82
 
      
83
 
      ciRoute r = rl->begin();
84
 
      //for( ; mpt < MIDI_PORTS; ++mpt)
85
 
      for( ; r != rl->end(); ++r)
86
 
      {
87
 
        //if(!r->isValid() || ((r->type != Route::ALSA_MIDI_ROUTE) && (r->type != Route::JACK_MIDI_ROUTE)))
88
 
        //if(!r->isValid() || (r->type != Route::MIDI_DEVICE_ROUTE))
89
 
        if(!r->isValid() || (r->type != Route::MIDI_PORT_ROUTE))   // p3.3.49
90
 
          continue;
91
 
        
92
 
        // NOTE: TODO: Code for channelless events like sysex, ** IF we end up using the 'special channel 17' method.
93
 
        //if(r->channel == -1)
94
 
        if(r->channel == -1 || r->channel == 0)  // p3.3.50
95
 
          continue;
96
 
        
97
 
        // No port assigned to the device?
98
 
        //mpt = r->device->midiPort();
99
 
        mpt = r->midiPort;              // p3.3.49
100
 
        if(mpt < 0 || mpt >= MIDI_PORTS)
101
 
          continue;
102
 
        
103
 
        //for(; mch < MIDI_CHANNELS; ++mch)
104
 
        //{
105
 
          //if(midiPorts[mpt].syncInfo().actDetect(mch) && (iptMask & (1 << mpt)) && (ichMask & (1 << mch)) )
106
 
          //if((iptMask & bitShiftLU[mpt]) && (midiPorts[mpt].syncInfo().actDetectBits() & ichMask) )
107
 
          //if(midiPorts[mpt].syncInfo().actDetectBits() & bitShiftLU[r->channel]) 
108
 
          if(midiPorts[mpt].syncInfo().actDetectBits() & r->channel)          // p3.3.50 Use new channel mask.
109
 
          {
110
 
            //if(midiTrackInfo->iChanTextLabel->paletteBackgroundColor() != green)
111
 
            //  midiTrackInfo->iChanTextLabel->setPaletteBackgroundColor(green);
112
 
            //if(midiTrackInfo->iChanDetectLabel->pixmap() != greendotIcon)
113
 
            if(!midiTrackInfo->_midiDetect)
114
 
            {
115
 
              //printf("Arranger::midiTrackInfoHeartBeat setting green icon\n");
116
 
          
117
 
              midiTrackInfo->_midiDetect = true;
118
 
              //midiTrackInfo->iChanDetectLabel->setPixmap(*greendotIcon);
119
 
              midiTrackInfo->iChanDetectLabel->setPixmap(*redLedIcon);
120
 
            }  
121
 
            break;  
122
 
          }
123
 
        //}
124
 
      }
125
 
      // No activity detected?
126
 
      //if(mch == MIDI_CHANNELS)
127
 
      //if(mpt == MIDI_PORTS)
128
 
      if(r == rl->end())
129
 
      {
130
 
        //if(midiTrackInfo->iChanTextLabel->paletteBackgroundColor() != darkGreen)
131
 
        //  midiTrackInfo->iChanTextLabel->setPaletteBackgroundColor(darkGreen);
132
 
        //if(midiTrackInfo->iChanDetectLabel->pixmap() != darkgreendotIcon)
133
 
        if(midiTrackInfo->_midiDetect)
134
 
        {
135
 
          //printf("Arranger::midiTrackInfoHeartBeat setting darkgreen icon\n");
136
 
          
137
 
          midiTrackInfo->_midiDetect = false;
138
 
          //midiTrackInfo->iChanDetectLabel->setPixmap(*darkgreendotIcon);
139
 
          midiTrackInfo->iChanDetectLabel->setPixmap(*darkRedLedIcon);
140
 
        }  
141
 
      }
142
 
      
143
 
      int nprogram = mp->hwCtrlState(outChannel, CTRL_PROGRAM);
144
 
      if(nprogram == CTRL_VAL_UNKNOWN)
145
 
      {
146
 
        if(program != CTRL_VAL_UNKNOWN)
147
 
        {
148
 
          //printf("Arranger::midiTrackInfoHeartBeat setting program to unknown\n");
149
 
          
150
 
          program = CTRL_VAL_UNKNOWN;
151
 
          if(midiTrackInfo->iHBank->value() != 0)
152
 
          {
153
 
            midiTrackInfo->iHBank->blockSignals(true);
154
 
            midiTrackInfo->iHBank->setValue(0);
155
 
            midiTrackInfo->iHBank->blockSignals(false);
156
 
          }
157
 
          if(midiTrackInfo->iLBank->value() != 0)
158
 
          {
159
 
            midiTrackInfo->iLBank->blockSignals(true);
160
 
            midiTrackInfo->iLBank->setValue(0);
161
 
            midiTrackInfo->iLBank->blockSignals(false);
162
 
          }
163
 
          if(midiTrackInfo->iProgram->value() != 0)
164
 
          {
165
 
            midiTrackInfo->iProgram->blockSignals(true);
166
 
            midiTrackInfo->iProgram->setValue(0);
167
 
            midiTrackInfo->iProgram->blockSignals(false);
168
 
          }
169
 
        }
170
 
          
171
 
        nprogram = mp->lastValidHWCtrlState(outChannel, CTRL_PROGRAM);
172
 
        if(nprogram == CTRL_VAL_UNKNOWN) 
173
 
        {
174
 
          //const char* n = "<unknown>";
175
 
          const QString n(tr("<unknown>"));
176
 
          //if(strcmp(midiTrackInfo->iPatch->text().latin1(), n) != 0)
177
 
          if(midiTrackInfo->iPatch->text() != n)
178
 
          {
179
 
            //printf("Arranger::midiTrackInfoHeartBeat setting patch <unknown>\n");
180
 
          
181
 
            midiTrackInfo->iPatch->setText(n);
182
 
          }  
183
 
        }
184
 
        else
185
 
        {
186
 
          MidiInstrument* instr = mp->instrument();
187
 
          const char* name = instr->getPatchName(outChannel, nprogram, song->mtype(), track->type() == Track::DRUM);
188
 
          if(!name)
189
 
          {
190
 
            if(midiTrackInfo->iPatch->text() != ("???"))
191
 
              midiTrackInfo->iPatch->setText("???");
192
 
          }
193
 
          else
194
 
          if(strcmp(midiTrackInfo->iPatch->text().latin1(), name) != 0)
195
 
          {
196
 
            //printf("Arranger::midiTrackInfoHeartBeat setting patch name\n");
197
 
          
198
 
            midiTrackInfo->iPatch->setText(name);
199
 
          }  
200
 
        }         
201
 
      }
202
 
      else
203
 
      if(program != nprogram) 
204
 
      {
205
 
            program = nprogram;
206
 
 
207
 
            //int hb, lb, pr;
208
 
            //if (program == CTRL_VAL_UNKNOWN) {
209
 
            //      hb = lb = pr = 0;
210
 
            //      iPatch->setText("---");
211
 
            //      }
212
 
            //else 
213
 
            //{
214
 
                  MidiInstrument* instr = mp->instrument();
215
 
                  const char* name = instr->getPatchName(outChannel, program, song->mtype(), track->type() == Track::DRUM);
216
 
                  if(strcmp(midiTrackInfo->iPatch->text().latin1(), name) != 0)
217
 
                    midiTrackInfo->iPatch->setText(QString(name));
218
 
 
219
 
                  int hb = ((program >> 16) & 0xff) + 1;
220
 
                  if (hb == 0x100)
221
 
                        hb = 0;
222
 
                  int lb = ((program >> 8) & 0xff) + 1;
223
 
                  if (lb == 0x100)
224
 
                        lb = 0;
225
 
                  int pr = (program & 0xff) + 1;
226
 
                  if (pr == 0x100)
227
 
                        pr = 0;
228
 
            //}
229
 
            
230
 
            //printf("Arranger::midiTrackInfoHeartBeat setting program\n");
231
 
          
232
 
            if(midiTrackInfo->iHBank->value() != hb)
233
 
            {
234
 
              midiTrackInfo->iHBank->blockSignals(true);
235
 
              midiTrackInfo->iHBank->setValue(hb);
236
 
              midiTrackInfo->iHBank->blockSignals(false);
237
 
            }
238
 
            if(midiTrackInfo->iLBank->value() != lb)
239
 
            {
240
 
              midiTrackInfo->iLBank->blockSignals(true);
241
 
              midiTrackInfo->iLBank->setValue(lb);
242
 
              midiTrackInfo->iLBank->blockSignals(false);
243
 
            }
244
 
            if(midiTrackInfo->iProgram->value() != pr)
245
 
            {
246
 
              midiTrackInfo->iProgram->blockSignals(true);
247
 
              midiTrackInfo->iProgram->setValue(pr);
248
 
              midiTrackInfo->iProgram->blockSignals(false);
249
 
            }
250
 
            
251
 
      }
252
 
 
253
 
      MidiController* mc = mp->midiController(CTRL_VOLUME);
254
 
      int mn = mc->minVal();
255
 
      int v = mp->hwCtrlState(outChannel, CTRL_VOLUME);
256
 
      if(v == CTRL_VAL_UNKNOWN)
257
 
      //{
258
 
        //v = mc->initVal();
259
 
        //if(v == CTRL_VAL_UNKNOWN)
260
 
        //  v = 0;
261
 
        v = mn - 1;
262
 
      //}  
263
 
      else
264
 
        // Auto bias...
265
 
        v -= mc->bias();
266
 
      if(volume != v)
267
 
      {
268
 
        volume = v;
269
 
        if(midiTrackInfo->iLautst->value() != v)
270
 
        {
271
 
          //printf("Arranger::midiTrackInfoHeartBeat setting volume\n");
272
 
          
273
 
          midiTrackInfo->iLautst->blockSignals(true);
274
 
          //midiTrackInfo->iLautst->setRange(mn - 1, mc->maxVal());
275
 
          midiTrackInfo->iLautst->setValue(v);
276
 
          midiTrackInfo->iLautst->blockSignals(false);
277
 
        }
278
 
      }
279
 
      
280
 
      mc = mp->midiController(CTRL_PANPOT);
281
 
      mn = mc->minVal();
282
 
      v = mp->hwCtrlState(outChannel, CTRL_PANPOT);
283
 
      if(v == CTRL_VAL_UNKNOWN)
284
 
      //{
285
 
        //v = mc->initVal();
286
 
        //if(v == CTRL_VAL_UNKNOWN)
287
 
        //  v = 0;
288
 
        v = mn - 1;
289
 
      //}  
290
 
      else
291
 
        // Auto bias...
292
 
        v -= mc->bias();
293
 
      if(pan != v)
294
 
      {
295
 
        pan = v;
296
 
        if(midiTrackInfo->iPan->value() != v)
297
 
        {
298
 
          //printf("Arranger::midiTrackInfoHeartBeat setting pan\n");
299
 
          
300
 
          midiTrackInfo->iPan->blockSignals(true);
301
 
          //midiTrackInfo->iPan->setRange(mn - 1, mc->maxVal());
302
 
          midiTrackInfo->iPan->setValue(v);
303
 
          midiTrackInfo->iPan->blockSignals(false);
304
 
        }  
305
 
      }  
306
 
      
307
 
      // Does it include a midi controller value adjustment? Then handle it...
308
 
      //if(flags & SC_MIDI_CONTROLLER)
309
 
      //  seek();
310
 
 
311
 
      /*
312
 
      if(midiTrackInfo->iTransp->value() != track->transposition)
313
 
        midiTrackInfo->iTransp->setValue(track->transposition);
314
 
      if(midiTrackInfo->iAnschl->value() != track->velocity)
315
 
        midiTrackInfo->iAnschl->setValue(track->velocity);
316
 
      if(midiTrackInfo->iVerz->value() != track->delay)
317
 
        midiTrackInfo->iVerz->setValue(track->delay);
318
 
      if(midiTrackInfo->iLen->value() != track->len)
319
 
        midiTrackInfo->iLen->setValue(track->len);
320
 
      if(midiTrackInfo->iKompr->value() != track->compression)
321
 
        midiTrackInfo->iKompr->setValue(track->compression);
322
 
      */  
323
 
    }  
324
 
    break;
325
 
    
326
 
    case Track::WAVE:
327
 
    case Track::AUDIO_OUTPUT:
328
 
    case Track::AUDIO_INPUT:
329
 
    case Track::AUDIO_GROUP:
330
 
    case Track::AUDIO_AUX:
331
 
    case Track::AUDIO_SOFTSYNTH:
332
 
    break;
333
 
  }  
334
 
}
335
 
 
336
 
//---------------------------------------------------------
337
 
//   showTrackInfo
338
 
//---------------------------------------------------------
339
 
 
340
 
void Arranger::showTrackInfo(bool flag)
341
 
      {
342
 
      showTrackinfoFlag = flag;
343
 
      trackInfo->setShown(flag);
344
 
      infoScroll->setShown(flag);
345
 
      updateTrackInfo(-1);
346
 
      }
347
 
 
348
 
//---------------------------------------------------------
349
 
//   genTrackInfo
350
 
//---------------------------------------------------------
351
 
 
352
 
void Arranger::genTrackInfo(QWidget* parent)
353
 
      {
354
 
      trackInfo = new WidgetStack(parent, "trackInfoStack");
355
 
 
356
 
      noTrackInfo          = new QWidget(trackInfo);
357
 
      QPixmap *noInfoPix   = new QPixmap(160, 1000); //muse_leftside_logo_xpm);
358
 
      const QPixmap *logo  = new QPixmap(muse_leftside_logo_xpm);
359
 
      noInfoPix->fill(noTrackInfo->paletteBackgroundColor() );
360
 
      copyBlt(noInfoPix, 10, 0, logo, 0,0, logo->width(), logo->height());
361
 
      noTrackInfo->setPaletteBackgroundPixmap(*noInfoPix);
362
 
      noTrackInfo->setGeometry(0, 0, 65, 200);
363
 
      noTrackInfo->setSizePolicy(QSizePolicy(QSizePolicy::Fixed, QSizePolicy::Expanding));
364
 
 
365
 
      midiTrackInfo = new MidiTrackInfo(trackInfo);
366
 
      trackInfo->addWidget(noTrackInfo,   0);
367
 
      trackInfo->addWidget(midiTrackInfo, 1);
368
 
      trackInfo->addWidget(0, 2);
369
 
 
370
 
      genMidiTrackInfo();
371
 
      }
372
 
 
373
 
//---------------------------------------------------------
374
 
//   updateTrackInfo
375
 
//---------------------------------------------------------
376
 
 
377
 
void Arranger::updateTrackInfo(int flags)
378
 
      {
379
 
      if (!showTrackinfoFlag) {
380
 
            switchInfo(-1);
381
 
            return;
382
 
            }
383
 
      if (selected == 0) {
384
 
            switchInfo(0);
385
 
            return;
386
 
            }
387
 
      if (selected->isMidiTrack()) {
388
 
            switchInfo(1);
389
 
            updateMidiTrackInfo(flags);
390
 
            }
391
 
      else {
392
 
            switchInfo(2);
393
 
            }
394
 
      }
395
 
 
396
 
//---------------------------------------------------------
397
 
//   switchInfo
398
 
//---------------------------------------------------------
399
 
 
400
 
void Arranger::switchInfo(int n)
401
 
      {
402
 
      if (n == 2) {
403
 
            AudioStrip* w = (AudioStrip*)(trackInfo->getWidget(2));
404
 
            if (w == 0 || selected != w->getTrack()) {
405
 
                  if (w)
406
 
                        delete w;
407
 
                  w = new AudioStrip(trackInfo, (AudioTrack*)selected);
408
 
                  connect(song, SIGNAL(songChanged(int)), w, SLOT(songChanged(int)));
409
 
                  connect(muse, SIGNAL(configChanged()), w, SLOT(configChanged()));
410
 
                  w->setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed));
411
 
                  trackInfo->addWidget(w, 2);
412
 
                  w->show();
413
 
                  tgrid->activate();
414
 
                  }
415
 
            }
416
 
      if (trackInfo->curIdx() == n)
417
 
            return;
418
 
      trackInfo->raiseWidget(n);
419
 
      tgrid->activate();
420
 
      }
421
 
 
422
 
//---------------------------------------------------------
423
 
//   setTrackInfoLabelText
424
 
//---------------------------------------------------------
425
 
 
426
 
void Arranger::setTrackInfoLabelText()
427
 
{
428
 
      MidiTrack* track = (MidiTrack*)selected;
429
 
      if(track)
430
 
        midiTrackInfo->trackNameLabel->setText(track->name());
431
 
      else  
432
 
        midiTrackInfo->trackNameLabel->setText(QString());
433
 
}
434
 
  
435
 
//---------------------------------------------------------
436
 
//   setTrackInfoLabelFont
437
 
//---------------------------------------------------------
438
 
 
439
 
void Arranger::setTrackInfoLabelFont()
440
 
{
441
 
      MidiTrack* track = (MidiTrack*)selected;
442
 
      if(!track)
443
 
        return;
444
 
        
445
 
      // Use the new font #6 I created just for these labels (so far).
446
 
      // Set the label's font.
447
 
      midiTrackInfo->trackNameLabel->setFont(config.fonts[6]);
448
 
      // Dealing with a horizontally constrained label. Ignore vertical. Use a minimum readable point size.
449
 
      autoAdjustFontSize(midiTrackInfo->trackNameLabel, midiTrackInfo->trackNameLabel->text(), false, true, config.fonts[6].pointSize(), 5);
450
 
}
451
 
  
452
 
// Removed by Tim. p3.3.9
453
 
 
454
 
/*
455
 
//---------------------------------------------------------
456
 
//   iNameChanged
457
 
//---------------------------------------------------------
458
 
 
459
 
void Arranger::iNameChanged()
460
 
      {
461
 
      QString txt = midiTrackInfo->iName->text();
462
 
      if (txt == selected->name())
463
 
            return;
464
 
      
465
 
      TrackList* tl = song->tracks();
466
 
      for(iTrack i = tl->begin(); i != tl->end(); ++i) 
467
 
      {
468
 
        if((*i)->name() == txt) 
469
 
        {
470
 
          // Restore the text.
471
 
          midiTrackInfo->iName->blockSignals(true);
472
 
          midiTrackInfo->iName->setText(selected->name());
473
 
          midiTrackInfo->iName->blockSignals(false);
474
 
          
475
 
          QMessageBox::critical(this,
476
 
              tr("MusE: bad trackname"),
477
 
              tr("please choose a unique track name"),
478
 
              QMessageBox::Ok,
479
 
              QMessageBox::NoButton,
480
 
              QMessageBox::NoButton);
481
 
          
482
 
          midiTrackInfo->iName->setFocus();
483
 
          return;
484
 
        }
485
 
      }
486
 
      
487
 
      //Track* track = selected->clone();
488
 
      Track* track = selected->clone(false);
489
 
      selected->setName(txt);
490
 
      audio->msgChangeTrack(track, selected);
491
 
      }
492
 
*/
493
 
 
494
 
//---------------------------------------------------------
495
 
//   iOutputChannelChanged
496
 
//---------------------------------------------------------
497
 
 
498
 
void Arranger::iOutputChannelChanged(int channel)
499
 
      {
500
 
      --channel;
501
 
      MidiTrack* track = (MidiTrack*)selected;
502
 
      if (channel != track->outChannel()) {
503
 
            // Changed by T356.
504
 
            //track->setOutChannel(channel);
505
 
            audio->msgIdle(true);
506
 
            //audio->msgSetTrackOutChannel(track, channel);
507
 
            track->setOutChanAndUpdate(channel);
508
 
            audio->msgIdle(false);
509
 
            
510
 
            // may result in adding/removing mixer strip:
511
 
            //song->update(-1);
512
 
            song->update(SC_MIDI_CHANNEL);
513
 
            }
514
 
      }
515
 
 
516
 
/*
517
 
//---------------------------------------------------------
518
 
//   iKanalChanged
519
 
//---------------------------------------------------------
520
 
 
521
 
void Arranger::iInputChannelChanged(const QString& s)
522
 
      {
523
 
      MidiTrack* track = (MidiTrack*)selected;
524
 
      int val = string2bitmap(s);
525
 
      if (val != track->inChannelMask()) {
526
 
            track->setInChannelMask(val);
527
 
            list->redraw();
528
 
            }
529
 
      }
530
 
*/
531
 
 
532
 
//---------------------------------------------------------
533
 
//   iOutputPortChanged
534
 
//---------------------------------------------------------
535
 
 
536
 
void Arranger::iOutputPortChanged(int index)
537
 
      {
538
 
      MidiTrack* track = (MidiTrack*)selected;
539
 
      if (index == track->outPort())
540
 
            return;
541
 
      // Changed by T356.
542
 
      //track->setOutPort(index);
543
 
      audio->msgIdle(true);
544
 
      //audio->msgSetTrackOutPort(track, index);
545
 
      track->setOutPortAndUpdate(index);
546
 
      audio->msgIdle(false);
547
 
      
548
 
      list->redraw();
549
 
      }
550
 
 
551
 
/*
552
 
//---------------------------------------------------------
553
 
//   iInputPortChanged
554
 
//---------------------------------------------------------
555
 
 
556
 
void Arranger::iInputPortChanged(const QString& s)
557
 
      {
558
 
      // Changed by Tim. p3.3.8
559
 
      //int val = string2bitmap(s);
560
 
      unsigned int val = string2u32bitmap(s);
561
 
      
562
 
      MidiTrack* track = (MidiTrack*)selected;
563
 
      if (val == track->inPortMask())
564
 
            return;
565
 
      track->setInPortMask(val);
566
 
      list->redraw();
567
 
      }
568
 
*/
569
 
 
570
 
//---------------------------------------------------------
571
 
//   routingPopupMenuActivated
572
 
//---------------------------------------------------------
573
 
 
574
 
void Arranger::routingPopupMenuActivated(int n)
575
 
{
576
 
  //if(gRoutingPopupMenuMaster != this || !track || !track->isMidiTrack())
577
 
  if(!midiTrackInfo || gRoutingPopupMenuMaster != midiTrackInfo || !selected || !selected->isMidiTrack())
578
 
    return;
579
 
  //if (n > 999) {
580
 
  //if (n >= MIDI_PORTS * MIDI_CHANNELS) {    // p3.3.50
581
 
  //  for (int i = 0; i < MIDI_CHANNELS; i++)
582
 
      //muse->routingPopupMenuActivated(selected, i + MIDI_CHANNELS * (n-1000));
583
 
  //    muse->routingPopupMenuActivated(selected, i + MIDI_CHANNELS * (n - MIDI_PORTS * MIDI_CHANNELS));   // p3.3.50
584
 
  //}
585
 
  //else {
586
 
    muse->routingPopupMenuActivated(selected, n);
587
 
  //}
588
 
}
589
 
 
590
 
//---------------------------------------------------------
591
 
//   inRoutesPressed
592
 
//---------------------------------------------------------
593
 
 
594
 
void Arranger::inRoutesPressed()
595
 
{
596
 
  if(!selected)
597
 
    return;
598
 
    
599
 
  ///song->chooseMidiRoutes(midiTrackInfo->iRButton, (MidiTrack*)selected, false);
600
 
  
601
 
  if(!selected->isMidiTrack())
602
 
    return;
603
 
  
604
 
  //song->chooseMidiRoutes(iR, (MidiTrack*)track, false);
605
 
  PopupMenu* pup = muse->prepareRoutingPopupMenu(selected, false);
606
 
  if(!pup)
607
 
    return;
608
 
  
609
 
  //pup->disconnect();
610
 
  //gRoutingPopupMenuMaster = this;
611
 
  gRoutingPopupMenuMaster = midiTrackInfo;
612
 
  connect(pup, SIGNAL(activated(int)), SLOT(routingPopupMenuActivated(int)));
613
 
  // Nope, can't clear menu and mm list in there, sub-menus stay open. Never mind for now...
614
 
  connect(pup, SIGNAL(aboutToHide()), muse, SLOT(routingPopupMenuAboutToHide()));
615
 
  pup->popup(QCursor::pos(), 0);
616
 
  midiTrackInfo->iRButton->setDown(false);     
617
 
  return;
618
 
}
619
 
 
620
 
//---------------------------------------------------------
621
 
//   outRoutesPressed
622
 
//---------------------------------------------------------
623
 
 
624
 
void Arranger::outRoutesPressed()
625
 
{
626
 
  if(!selected)
627
 
    return;
628
 
    
629
 
  ///song->chooseMidiRoutes(midiTrackInfo->oRButton, (MidiTrack*)selected, true);
630
 
  
631
 
  if(!selected->isMidiTrack())
632
 
    return;
633
 
  
634
 
  //song->chooseMidiRoutes(iR, (MidiTrack*)track, false);
635
 
  PopupMenu* pup = muse->prepareRoutingPopupMenu(selected, true);
636
 
  if(!pup)
637
 
    return;
638
 
  
639
 
  //pup->disconnect();
640
 
  //gRoutingPopupMenuMaster = this;
641
 
  gRoutingPopupMenuMaster = midiTrackInfo;
642
 
  connect(pup, SIGNAL(activated(int)), SLOT(routingPopupMenuActivated(int)));
643
 
  // Nope, can't clear menu and mm list in there, sub-menus stay open. Never mind for now...
644
 
  connect(pup, SIGNAL(aboutToHide()), muse, SLOT(routingPopupMenuAboutToHide()));
645
 
  pup->popup(QCursor::pos(), 0);
646
 
  midiTrackInfo->oRButton->setDown(false);     
647
 
  return;
648
 
}
649
 
 
650
 
//---------------------------------------------------------
651
 
//   iProgHBankChanged
652
 
//---------------------------------------------------------
653
 
 
654
 
void Arranger::iProgHBankChanged()
655
 
      {
656
 
      MidiTrack* track = (MidiTrack*)selected;
657
 
      int channel = track->outChannel();
658
 
      int port    = track->outPort();
659
 
      int hbank   = midiTrackInfo->iHBank->value();
660
 
      int lbank   = midiTrackInfo->iLBank->value();
661
 
      int prog    = midiTrackInfo->iProgram->value();
662
 
 
663
 
      if (hbank > 0 && hbank < 129)
664
 
            hbank -= 1;
665
 
      else
666
 
            hbank = 0xff;
667
 
      if (lbank > 0 && lbank < 129)
668
 
            lbank -= 1;
669
 
      else
670
 
            lbank = 0xff;
671
 
      if (prog > 0 && prog < 129)
672
 
            prog -= 1;
673
 
      else
674
 
            prog = 0xff;
675
 
 
676
 
      MidiPort* mp = &midiPorts[port];
677
 
      if(prog == 0xff && hbank == 0xff && lbank == 0xff)
678
 
      {
679
 
        program = CTRL_VAL_UNKNOWN;
680
 
        if(mp->hwCtrlState(channel, CTRL_PROGRAM) != CTRL_VAL_UNKNOWN)
681
 
          audio->msgSetHwCtrlState(mp, channel, CTRL_PROGRAM, CTRL_VAL_UNKNOWN);
682
 
        return;  
683
 
      }
684
 
      
685
 
      int np = mp->hwCtrlState(channel, CTRL_PROGRAM);
686
 
      if(np == CTRL_VAL_UNKNOWN)
687
 
      {
688
 
        np = mp->lastValidHWCtrlState(channel, CTRL_PROGRAM);
689
 
        if(np != CTRL_VAL_UNKNOWN)
690
 
        {
691
 
          lbank = (np & 0xff00) >> 8; 
692
 
          prog = np & 0xff;
693
 
          if(prog == 0xff)
694
 
            prog = 0;
695
 
          int ilbnk = lbank;
696
 
          int iprog = prog;
697
 
          if(ilbnk == 0xff)
698
 
            ilbnk = -1;
699
 
          ++ilbnk;
700
 
          ++iprog;
701
 
          midiTrackInfo->iLBank->blockSignals(true);
702
 
          midiTrackInfo->iProgram->blockSignals(true);
703
 
          midiTrackInfo->iLBank->setValue(ilbnk);
704
 
          midiTrackInfo->iProgram->setValue(iprog);
705
 
          midiTrackInfo->iLBank->blockSignals(false);
706
 
          midiTrackInfo->iProgram->blockSignals(false);
707
 
        }
708
 
      }
709
 
      
710
 
      if(prog == 0xff && (hbank != 0xff || lbank != 0xff))
711
 
      {
712
 
        prog = 0;
713
 
        midiTrackInfo->iProgram->blockSignals(true);
714
 
        midiTrackInfo->iProgram->setValue(1);
715
 
        midiTrackInfo->iProgram->blockSignals(false);
716
 
      }  
717
 
      program = (hbank << 16) + (lbank << 8) + prog;
718
 
      MidiPlayEvent ev(0, port, channel, ME_CONTROLLER, CTRL_PROGRAM, program);
719
 
      audio->msgPlayMidiEvent(&ev);
720
 
      
721
 
      MidiInstrument* instr = mp->instrument();
722
 
      const char* name = instr->getPatchName(channel, program, song->mtype(), track->type() == Track::DRUM);
723
 
      midiTrackInfo->iPatch->setText(QString(name));
724
 
//      updateTrackInfo();
725
 
      }
726
 
 
727
 
//---------------------------------------------------------
728
 
//   iProgLBankChanged
729
 
//---------------------------------------------------------
730
 
 
731
 
void Arranger::iProgLBankChanged()
732
 
      {
733
 
      MidiTrack* track = (MidiTrack*)selected;
734
 
      int channel = track->outChannel();
735
 
      int port    = track->outPort();
736
 
      int hbank   = midiTrackInfo->iHBank->value();
737
 
      int lbank   = midiTrackInfo->iLBank->value();
738
 
      int prog    = midiTrackInfo->iProgram->value();
739
 
 
740
 
      if (hbank > 0 && hbank < 129)
741
 
            hbank -= 1;
742
 
      else
743
 
            hbank = 0xff;
744
 
      if (lbank > 0 && lbank < 129)
745
 
            lbank -= 1;
746
 
      else
747
 
            lbank = 0xff;
748
 
      if (prog > 0 && prog < 129)
749
 
            prog -= 1;
750
 
      else
751
 
            prog = 0xff;
752
 
 
753
 
      MidiPort* mp = &midiPorts[port];
754
 
      if(prog == 0xff && hbank == 0xff && lbank == 0xff)
755
 
      {
756
 
        program = CTRL_VAL_UNKNOWN;
757
 
        if(mp->hwCtrlState(channel, CTRL_PROGRAM) != CTRL_VAL_UNKNOWN)
758
 
          audio->msgSetHwCtrlState(mp, channel, CTRL_PROGRAM, CTRL_VAL_UNKNOWN);
759
 
        return;  
760
 
      }
761
 
      
762
 
      int np = mp->hwCtrlState(channel, CTRL_PROGRAM);
763
 
      if(np == CTRL_VAL_UNKNOWN)
764
 
      {
765
 
        np = mp->lastValidHWCtrlState(channel, CTRL_PROGRAM);
766
 
        if(np != CTRL_VAL_UNKNOWN)
767
 
        {
768
 
          hbank = (np & 0xff0000) >> 16; 
769
 
          prog = np & 0xff;
770
 
          if(prog == 0xff)
771
 
            prog = 0;
772
 
          int ihbnk = hbank;
773
 
          int iprog = prog;
774
 
          if(ihbnk == 0xff)
775
 
            ihbnk = -1;
776
 
          ++ihbnk;
777
 
          ++iprog;
778
 
          midiTrackInfo->iHBank->blockSignals(true);
779
 
          midiTrackInfo->iProgram->blockSignals(true);
780
 
          midiTrackInfo->iHBank->setValue(ihbnk);
781
 
          midiTrackInfo->iProgram->setValue(iprog);
782
 
          midiTrackInfo->iHBank->blockSignals(false);
783
 
          midiTrackInfo->iProgram->blockSignals(false);
784
 
        }
785
 
      }
786
 
      
787
 
      if(prog == 0xff && (hbank != 0xff || lbank != 0xff))
788
 
      {
789
 
        prog = 0;
790
 
        midiTrackInfo->iProgram->blockSignals(true);
791
 
        midiTrackInfo->iProgram->setValue(1);
792
 
        midiTrackInfo->iProgram->blockSignals(false);
793
 
      }  
794
 
      program = (hbank << 16) + (lbank << 8) + prog;
795
 
      MidiPlayEvent ev(0, port, channel, ME_CONTROLLER, CTRL_PROGRAM, program);
796
 
      audio->msgPlayMidiEvent(&ev);
797
 
      
798
 
      MidiInstrument* instr = mp->instrument();
799
 
      const char* name = instr->getPatchName(channel, program, song->mtype(), track->type() == Track::DRUM);
800
 
      midiTrackInfo->iPatch->setText(QString(name));
801
 
//      updateTrackInfo();
802
 
      }
803
 
 
804
 
//---------------------------------------------------------
805
 
//   iProgramChanged
806
 
//---------------------------------------------------------
807
 
 
808
 
void Arranger::iProgramChanged()
809
 
      {
810
 
      MidiTrack* track = (MidiTrack*)selected;
811
 
      int channel = track->outChannel();
812
 
      int port    = track->outPort();
813
 
      int hbank   = midiTrackInfo->iHBank->value();
814
 
      int lbank   = midiTrackInfo->iLBank->value();
815
 
      int prog    = midiTrackInfo->iProgram->value();
816
 
 
817
 
      if (hbank > 0 && hbank < 129)
818
 
            hbank -= 1;
819
 
      else
820
 
            hbank = 0xff;
821
 
      if (lbank > 0 && lbank < 129)
822
 
            lbank -= 1;
823
 
      else
824
 
            lbank = 0xff;
825
 
      if (prog > 0 && prog < 129)
826
 
            prog -= 1;
827
 
      else
828
 
            prog = 0xff;
829
 
 
830
 
      MidiPort *mp = &midiPorts[port];
831
 
      if(prog == 0xff)
832
 
      {
833
 
        program = CTRL_VAL_UNKNOWN;
834
 
        midiTrackInfo->iHBank->blockSignals(true);
835
 
        midiTrackInfo->iLBank->blockSignals(true);
836
 
        midiTrackInfo->iHBank->setValue(0);
837
 
        midiTrackInfo->iLBank->setValue(0);
838
 
        midiTrackInfo->iHBank->blockSignals(false);
839
 
        midiTrackInfo->iLBank->blockSignals(false);
840
 
        
841
 
        if(mp->hwCtrlState(channel, CTRL_PROGRAM) != CTRL_VAL_UNKNOWN)
842
 
          audio->msgSetHwCtrlState(mp, channel, CTRL_PROGRAM, CTRL_VAL_UNKNOWN);
843
 
        return;  
844
 
      }
845
 
      else
846
 
      {
847
 
        int np = mp->hwCtrlState(channel, CTRL_PROGRAM);
848
 
        if(np == CTRL_VAL_UNKNOWN)
849
 
        {
850
 
          np = mp->lastValidHWCtrlState(channel, CTRL_PROGRAM);
851
 
          if(np != CTRL_VAL_UNKNOWN)
852
 
          {
853
 
            hbank = (np & 0xff0000) >> 16;
854
 
            lbank = (np & 0xff00) >> 8; 
855
 
            int ihbnk = hbank;
856
 
            int ilbnk = lbank;
857
 
            if(ihbnk == 0xff)
858
 
              ihbnk = -1;
859
 
            if(ilbnk == 0xff)
860
 
              ilbnk = -1;
861
 
            ++ihbnk;
862
 
            ++ilbnk;
863
 
            midiTrackInfo->iHBank->blockSignals(true);
864
 
            midiTrackInfo->iLBank->blockSignals(true);
865
 
            midiTrackInfo->iHBank->setValue(ihbnk);
866
 
            midiTrackInfo->iLBank->setValue(ilbnk);
867
 
            midiTrackInfo->iHBank->blockSignals(false);
868
 
            midiTrackInfo->iLBank->blockSignals(false);
869
 
          }
870
 
        }
871
 
        program = (hbank << 16) + (lbank << 8) + prog;
872
 
        MidiPlayEvent ev(0, port, channel, ME_CONTROLLER, CTRL_PROGRAM, program);
873
 
        audio->msgPlayMidiEvent(&ev);
874
 
        
875
 
        MidiInstrument* instr = mp->instrument();
876
 
        const char* name = instr->getPatchName(channel, program, song->mtype(), track->type() == Track::DRUM);
877
 
        midiTrackInfo->iPatch->setText(QString(name));
878
 
      }
879
 
        
880
 
//      updateTrackInfo();
881
 
      }
882
 
 
883
 
//---------------------------------------------------------
884
 
//   iLautstChanged
885
 
//---------------------------------------------------------
886
 
 
887
 
void Arranger::iLautstChanged(int val)
888
 
    {
889
 
      MidiTrack* track = (MidiTrack*)selected;
890
 
      int outPort = track->outPort();
891
 
      int chan = track->outChannel();
892
 
      MidiPort* mp = &midiPorts[outPort];
893
 
      MidiController* mctl = mp->midiController(CTRL_VOLUME);
894
 
      if((val < mctl->minVal()) || (val > mctl->maxVal()))
895
 
      {
896
 
        if(mp->hwCtrlState(chan, CTRL_VOLUME) != CTRL_VAL_UNKNOWN)
897
 
          audio->msgSetHwCtrlState(mp, chan, CTRL_VOLUME, CTRL_VAL_UNKNOWN);
898
 
      }  
899
 
      else
900
 
      {
901
 
        val += mctl->bias();
902
 
        
903
 
        MidiPlayEvent ev(0, outPort, chan,
904
 
          ME_CONTROLLER, CTRL_VOLUME, val);
905
 
        audio->msgPlayMidiEvent(&ev);
906
 
      }  
907
 
      song->update(SC_MIDI_CONTROLLER);
908
 
    }
909
 
 
910
 
//---------------------------------------------------------
911
 
//   iTranspChanged
912
 
//---------------------------------------------------------
913
 
 
914
 
void Arranger::iTranspChanged(int val)
915
 
      {
916
 
      MidiTrack* track = (MidiTrack*)selected;
917
 
      track->transposition = val;
918
 
      }
919
 
 
920
 
//---------------------------------------------------------
921
 
//   iAnschlChanged
922
 
//---------------------------------------------------------
923
 
 
924
 
void Arranger::iAnschlChanged(int val)
925
 
      {
926
 
      MidiTrack* track = (MidiTrack*)selected;
927
 
      track->velocity = val;
928
 
      }
929
 
 
930
 
//---------------------------------------------------------
931
 
//   iVerzChanged
932
 
//---------------------------------------------------------
933
 
 
934
 
void Arranger::iVerzChanged(int val)
935
 
      {
936
 
      MidiTrack* track = (MidiTrack*)selected;
937
 
      track->delay = val;
938
 
      }
939
 
 
940
 
//---------------------------------------------------------
941
 
//   iLenChanged
942
 
//---------------------------------------------------------
943
 
 
944
 
void Arranger::iLenChanged(int val)
945
 
      {
946
 
      MidiTrack* track = (MidiTrack*)selected;
947
 
      track->len = val;
948
 
      }
949
 
 
950
 
//---------------------------------------------------------
951
 
//   iKomprChanged
952
 
//---------------------------------------------------------
953
 
 
954
 
void Arranger::iKomprChanged(int val)
955
 
      {
956
 
      MidiTrack* track = (MidiTrack*)selected;
957
 
      track->compression = val;
958
 
      }
959
 
 
960
 
//---------------------------------------------------------
961
 
//   iPanChanged
962
 
//---------------------------------------------------------
963
 
 
964
 
void Arranger::iPanChanged(int val)
965
 
    {
966
 
      MidiTrack* track = (MidiTrack*)selected;
967
 
      int port    = track->outPort();
968
 
      int chan = track->outChannel();
969
 
      MidiPort* mp = &midiPorts[port];  
970
 
      MidiController* mctl = mp->midiController(CTRL_PANPOT);
971
 
      if((val < mctl->minVal()) || (val > mctl->maxVal()))
972
 
      {
973
 
        if(mp->hwCtrlState(chan, CTRL_PANPOT) != CTRL_VAL_UNKNOWN)
974
 
          audio->msgSetHwCtrlState(mp, chan, CTRL_PANPOT, CTRL_VAL_UNKNOWN);
975
 
      }  
976
 
      else
977
 
      {
978
 
        val += mctl->bias();
979
 
        
980
 
        // Realtime Change:
981
 
        MidiPlayEvent ev(0, port, chan,
982
 
          ME_CONTROLLER, CTRL_PANPOT, val);
983
 
        audio->msgPlayMidiEvent(&ev);
984
 
      }  
985
 
      song->update(SC_MIDI_CONTROLLER);
986
 
    }
987
 
 
988
 
//---------------------------------------------------------
989
 
//   instrPopup
990
 
//---------------------------------------------------------
991
 
 
992
 
void Arranger::instrPopup()
993
 
      {
994
 
      MidiTrack* track = (MidiTrack*)selected;
995
 
      int channel = track->outChannel();
996
 
      int port    = track->outPort();
997
 
      MidiInstrument* instr = midiPorts[port].instrument();
998
 
      instr->populatePatchPopup(pop, channel, song->mtype(), track->type() == Track::DRUM);
999
 
 
1000
 
      if(pop->count() == 0)
1001
 
        return;
1002
 
      int rv = pop->exec(midiTrackInfo->iPatch->mapToGlobal(QPoint(10,5)));
1003
 
      if (rv != -1) {
1004
 
            MidiPlayEvent ev(0, port, channel, ME_CONTROLLER, CTRL_PROGRAM, rv);
1005
 
            audio->msgPlayMidiEvent(&ev);
1006
 
            updateTrackInfo(-1);
1007
 
            }
1008
 
      }
1009
 
 
1010
 
//---------------------------------------------------------
1011
 
//   recEchoToggled
1012
 
//---------------------------------------------------------
1013
 
 
1014
 
void Arranger::recEchoToggled(bool v)
1015
 
{
1016
 
  MidiTrack* track = (MidiTrack*)selected;
1017
 
  track->setRecEcho(v);
1018
 
  
1019
 
  //song->update(SC_???);
1020
 
}
1021
 
 
1022
 
//---------------------------------------------------------
1023
 
//   iProgramDoubleClicked
1024
 
//---------------------------------------------------------
1025
 
 
1026
 
void Arranger::iProgramDoubleClicked()
1027
 
{
1028
 
  MidiTrack* track = (MidiTrack*)selected;
1029
 
  int port = track->outPort();
1030
 
  int chan = track->outChannel();
1031
 
  MidiPort* mp = &midiPorts[port];  
1032
 
  MidiController* mctl = mp->midiController(CTRL_PROGRAM);
1033
 
  
1034
 
  if(!track || !mctl)
1035
 
      return;
1036
 
  
1037
 
  int lastv = mp->lastValidHWCtrlState(chan, CTRL_PROGRAM);
1038
 
  int curv = mp->hwCtrlState(chan, CTRL_PROGRAM);
1039
 
  
1040
 
  if(curv == CTRL_VAL_UNKNOWN)
1041
 
  {
1042
 
    // If no value has ever been set yet, use the current knob value 
1043
 
    //  (or the controller's initial value?) to 'turn on' the controller.
1044
 
    if(lastv == CTRL_VAL_UNKNOWN)
1045
 
    {
1046
 
      int kiv = mctl->initVal();
1047
 
      //int kiv = lrint(_knob->value());
1048
 
      if(kiv == CTRL_VAL_UNKNOWN)
1049
 
        kiv = 0;
1050
 
      //else
1051
 
      //{  
1052
 
        //if(kiv < mctrl->minVal())
1053
 
        //  kiv = mctrl->minVal();
1054
 
        //if(kiv > mctrl->maxVal())
1055
 
        //  kiv = mctrl->maxVal();
1056
 
        //kiv += mctrl->bias();
1057
 
      //}    
1058
 
      
1059
 
      //MidiPlayEvent ev(0, port, chan, ME_CONTROLLER, num, kiv);
1060
 
      MidiPlayEvent ev(0, port, chan, ME_CONTROLLER, CTRL_PROGRAM, kiv);
1061
 
      audio->msgPlayMidiEvent(&ev);
1062
 
    }
1063
 
    else
1064
 
    {
1065
 
      MidiPlayEvent ev(0, port, chan, ME_CONTROLLER, CTRL_PROGRAM, lastv);
1066
 
      audio->msgPlayMidiEvent(&ev);
1067
 
    }
1068
 
  }  
1069
 
  else
1070
 
  {
1071
 
    if(mp->hwCtrlState(chan, CTRL_PROGRAM) != CTRL_VAL_UNKNOWN)
1072
 
      audio->msgSetHwCtrlState(mp, chan, CTRL_PROGRAM, CTRL_VAL_UNKNOWN);
1073
 
  }
1074
 
  
1075
 
  song->update(SC_MIDI_CONTROLLER);
1076
 
}
1077
 
 
1078
 
//---------------------------------------------------------
1079
 
//   iLautstDoubleClicked
1080
 
//---------------------------------------------------------
1081
 
 
1082
 
void Arranger::iLautstDoubleClicked()
1083
 
{
1084
 
  MidiTrack* track = (MidiTrack*)selected;
1085
 
  int port = track->outPort();
1086
 
  int chan = track->outChannel();
1087
 
  MidiPort* mp = &midiPorts[port];  
1088
 
  MidiController* mctl = mp->midiController(CTRL_VOLUME);
1089
 
  
1090
 
  if(!track || !mctl)
1091
 
      return;
1092
 
  
1093
 
  int lastv = mp->lastValidHWCtrlState(chan, CTRL_VOLUME);
1094
 
  int curv = mp->hwCtrlState(chan, CTRL_VOLUME);
1095
 
  
1096
 
  if(curv == CTRL_VAL_UNKNOWN)
1097
 
  {
1098
 
    // If no value has ever been set yet, use the current knob value 
1099
 
    //  (or the controller's initial value?) to 'turn on' the controller.
1100
 
    if(lastv == CTRL_VAL_UNKNOWN)
1101
 
    {
1102
 
      int kiv = mctl->initVal();
1103
 
      //int kiv = lrint(_knob->value());
1104
 
      if(kiv == CTRL_VAL_UNKNOWN)
1105
 
        // Set volume to 78% of range, so that if range is 0 - 127, then value is 100.
1106
 
        kiv = lround(double(mctl->maxVal() - mctl->minVal()) * 0.7874);
1107
 
      else
1108
 
      {  
1109
 
        if(kiv < mctl->minVal())
1110
 
          kiv = mctl->minVal();
1111
 
        if(kiv > mctl->maxVal())
1112
 
          kiv = mctl->maxVal();
1113
 
        kiv += mctl->bias();
1114
 
      }    
1115
 
      
1116
 
      MidiPlayEvent ev(0, port, chan, ME_CONTROLLER, CTRL_VOLUME, kiv);
1117
 
      audio->msgPlayMidiEvent(&ev);
1118
 
    }
1119
 
    else
1120
 
    {
1121
 
      MidiPlayEvent ev(0, port, chan, ME_CONTROLLER, CTRL_VOLUME, lastv);
1122
 
      audio->msgPlayMidiEvent(&ev);
1123
 
    }
1124
 
  }  
1125
 
  else
1126
 
  {
1127
 
    if(mp->hwCtrlState(chan, CTRL_VOLUME) != CTRL_VAL_UNKNOWN)
1128
 
      audio->msgSetHwCtrlState(mp, chan, CTRL_VOLUME, CTRL_VAL_UNKNOWN);
1129
 
  }
1130
 
  
1131
 
  song->update(SC_MIDI_CONTROLLER);
1132
 
}
1133
 
 
1134
 
//---------------------------------------------------------
1135
 
//   iPanDoubleClicked
1136
 
//---------------------------------------------------------
1137
 
 
1138
 
void Arranger::iPanDoubleClicked()
1139
 
{
1140
 
  MidiTrack* track = (MidiTrack*)selected;
1141
 
  int port = track->outPort();
1142
 
  int chan = track->outChannel();
1143
 
  MidiPort* mp = &midiPorts[port];  
1144
 
  MidiController* mctl = mp->midiController(CTRL_PANPOT);
1145
 
  
1146
 
  if(!track || !mctl)
1147
 
      return;
1148
 
  
1149
 
  int lastv = mp->lastValidHWCtrlState(chan, CTRL_PANPOT);
1150
 
  int curv = mp->hwCtrlState(chan, CTRL_PANPOT);
1151
 
  
1152
 
  if(curv == CTRL_VAL_UNKNOWN)
1153
 
  {
1154
 
    // If no value has ever been set yet, use the current knob value 
1155
 
    //  (or the controller's initial value?) to 'turn on' the controller.
1156
 
    if(lastv == CTRL_VAL_UNKNOWN)
1157
 
    {
1158
 
      int kiv = mctl->initVal();
1159
 
      //int kiv = lrint(_knob->value());
1160
 
      if(kiv == CTRL_VAL_UNKNOWN)
1161
 
        // Set volume to 50% of range, so that if range is 0 - 127, then value is 64.
1162
 
        kiv = lround(double(mctl->maxVal() - mctl->minVal()) * 0.5);
1163
 
      else
1164
 
      {  
1165
 
        if(kiv < mctl->minVal())
1166
 
          kiv = mctl->minVal();
1167
 
        if(kiv > mctl->maxVal())
1168
 
          kiv = mctl->maxVal();
1169
 
        kiv += mctl->bias();
1170
 
      }    
1171
 
      
1172
 
      MidiPlayEvent ev(0, port, chan, ME_CONTROLLER, CTRL_PANPOT, kiv);
1173
 
      audio->msgPlayMidiEvent(&ev);
1174
 
    }
1175
 
    else
1176
 
    {
1177
 
      MidiPlayEvent ev(0, port, chan, ME_CONTROLLER, CTRL_PANPOT, lastv);
1178
 
      audio->msgPlayMidiEvent(&ev);
1179
 
    }
1180
 
  }  
1181
 
  else
1182
 
  {
1183
 
    if(mp->hwCtrlState(chan, CTRL_PANPOT) != CTRL_VAL_UNKNOWN)
1184
 
      audio->msgSetHwCtrlState(mp, chan, CTRL_PANPOT, CTRL_VAL_UNKNOWN);
1185
 
  }
1186
 
  
1187
 
  song->update(SC_MIDI_CONTROLLER);
1188
 
}
1189
 
 
1190
 
//---------------------------------------------------------
1191
 
//   genMidiTrackInfo
1192
 
//---------------------------------------------------------
1193
 
 
1194
 
void Arranger::genMidiTrackInfo()                                                                                                             
1195
 
      {
1196
 
      //midiTrackInfo->iChanDetectLabel->setPixmap(*darkgreendotIcon);
1197
 
      midiTrackInfo->iChanDetectLabel->setPixmap(*darkRedLedIcon);
1198
 
      
1199
 
      QIconSet recEchoIconSet;
1200
 
      recEchoIconSet.setPixmap(*recEchoIconOn, QIconSet::Automatic, QIconSet::Normal, QIconSet::On);
1201
 
      recEchoIconSet.setPixmap(*recEchoIconOff, QIconSet::Automatic, QIconSet::Normal, QIconSet::Off);
1202
 
      midiTrackInfo->recEchoButton->setIconSet(recEchoIconSet);
1203
 
      
1204
 
      //midiTrackInfo->trackNameLabel->setAlignment(AlignCenter | WordBreak);
1205
 
      //midiTrackInfo->trackNameLabel->setSizePolicy(QSizePolicy(QSizePolicy::Ignored, QSizePolicy::Minimum));
1206
 
      //frameShape WinPanel
1207
 
      //frameShadow Raised
1208
 
      //lineWidth 1
1209
 
      //midLineWidth 0
1210
 
      midiTrackInfo->trackNameLabel->setBackgroundColor(QColor(0, 160, 255)); // Med blue
1211
 
      
1212
 
      // Added by Tim. p3.3.9
1213
 
      setTrackInfoLabelText();
1214
 
      setTrackInfoLabelFont();
1215
 
        
1216
 
 
1217
 
      connect(midiTrackInfo->iPatch, SIGNAL(released()), SLOT(instrPopup()));
1218
 
 
1219
 
      pop = new QPopupMenu(midiTrackInfo->iPatch);
1220
 
      pop->setCheckable(false);
1221
 
 
1222
 
      // Removed by Tim. p3.3.9
1223
 
      //connect(midiTrackInfo->iName, SIGNAL(returnPressed()), SLOT(iNameChanged()));
1224
 
      
1225
 
      connect(midiTrackInfo->iOutputChannel, SIGNAL(valueChanged(int)), SLOT(iOutputChannelChanged(int)));
1226
 
      ///connect(midiTrackInfo->iInputChannel, SIGNAL(textChanged(const QString&)), SLOT(iInputChannelChanged(const QString&)));
1227
 
      connect(midiTrackInfo->iHBank, SIGNAL(valueChanged(int)), SLOT(iProgHBankChanged()));
1228
 
      connect(midiTrackInfo->iLBank, SIGNAL(valueChanged(int)), SLOT(iProgLBankChanged()));
1229
 
      connect(midiTrackInfo->iProgram, SIGNAL(valueChanged(int)), SLOT(iProgramChanged()));
1230
 
      connect(midiTrackInfo->iHBank, SIGNAL(doubleClicked()), SLOT(iProgramDoubleClicked()));
1231
 
      connect(midiTrackInfo->iLBank, SIGNAL(doubleClicked()), SLOT(iProgramDoubleClicked()));
1232
 
      connect(midiTrackInfo->iProgram, SIGNAL(doubleClicked()), SLOT(iProgramDoubleClicked()));
1233
 
      connect(midiTrackInfo->iLautst, SIGNAL(valueChanged(int)), SLOT(iLautstChanged(int)));
1234
 
      connect(midiTrackInfo->iLautst, SIGNAL(doubleClicked()), SLOT(iLautstDoubleClicked()));
1235
 
      connect(midiTrackInfo->iTransp, SIGNAL(valueChanged(int)), SLOT(iTranspChanged(int)));
1236
 
      connect(midiTrackInfo->iAnschl, SIGNAL(valueChanged(int)), SLOT(iAnschlChanged(int)));
1237
 
      connect(midiTrackInfo->iVerz, SIGNAL(valueChanged(int)), SLOT(iVerzChanged(int)));
1238
 
      connect(midiTrackInfo->iLen, SIGNAL(valueChanged(int)), SLOT(iLenChanged(int)));
1239
 
      connect(midiTrackInfo->iKompr, SIGNAL(valueChanged(int)), SLOT(iKomprChanged(int)));
1240
 
      connect(midiTrackInfo->iPan, SIGNAL(valueChanged(int)), SLOT(iPanChanged(int)));
1241
 
      connect(midiTrackInfo->iPan, SIGNAL(doubleClicked()), SLOT(iPanDoubleClicked()));
1242
 
      connect(midiTrackInfo->iOutput, SIGNAL(activated(int)), SLOT(iOutputPortChanged(int)));
1243
 
      ///connect(midiTrackInfo->iInput, SIGNAL(textChanged(const QString&)), SLOT(iInputPortChanged(const QString&)));
1244
 
      connect(midiTrackInfo->recordButton, SIGNAL(clicked()), SLOT(recordClicked()));
1245
 
      connect(midiTrackInfo->progRecButton, SIGNAL(clicked()), SLOT(progRecClicked()));
1246
 
      connect(midiTrackInfo->volRecButton, SIGNAL(clicked()), SLOT(volRecClicked()));
1247
 
      connect(midiTrackInfo->panRecButton, SIGNAL(clicked()), SLOT(panRecClicked()));
1248
 
      connect(midiTrackInfo->recEchoButton, SIGNAL(toggled(bool)), SLOT(recEchoToggled(bool)));
1249
 
      connect(midiTrackInfo->iRButton, SIGNAL(pressed()), SLOT(inRoutesPressed()));
1250
 
      
1251
 
      // TODO: Works OK, but disabled for now, until we figure out what to do about multiple out routes and display values...
1252
 
      midiTrackInfo->oRButton->setEnabled(false);
1253
 
      connect(midiTrackInfo->oRButton, SIGNAL(pressed()), SLOT(outRoutesPressed()));
1254
 
      
1255
 
      connect(heartBeatTimer, SIGNAL(timeout()), SLOT(midiTrackInfoHeartBeat()));
1256
 
      }
1257
 
 
1258
 
//---------------------------------------------------------
1259
 
//   updateMidiTrackInfo
1260
 
//---------------------------------------------------------
1261
 
 
1262
 
void Arranger::updateMidiTrackInfo(int flags)
1263
 
{
1264
 
      MidiTrack* track = (MidiTrack*)selected;
1265
 
      
1266
 
      // Is it simply a midi controller value adjustment? Forget it.
1267
 
      if(flags == SC_MIDI_CONTROLLER)
1268
 
        return;
1269
 
        
1270
 
      // p3.3.47 Update the routing popup menu if anything relevant changes.
1271
 
      //if(gRoutingPopupMenuMaster == midiTrackInfo && selected && (flags & (SC_ROUTE | SC_CHANNELS | SC_CONFIG))) 
1272
 
      if(flags & (SC_ROUTE | SC_CHANNELS | SC_CONFIG))     // p3.3.50
1273
 
        // Use this handy shared routine.
1274
 
        //muse->updateRouteMenus(selected);
1275
 
        muse->updateRouteMenus(selected, midiTrackInfo);   // p3.3.50
1276
 
      
1277
 
      // Added by Tim. p3.3.9
1278
 
      setTrackInfoLabelText();
1279
 
      setTrackInfoLabelFont();
1280
 
        
1281
 
      //{
1282
 
        int outChannel = track->outChannel();
1283
 
        ///int inChannel  = track->inChannelMask();
1284
 
        int outPort    = track->outPort();
1285
 
        //int inPort     = track->inPortMask();
1286
 
        ///unsigned int inPort     = track->inPortMask();
1287
 
  
1288
 
        //midiTrackInfo->iInput->clear();
1289
 
        midiTrackInfo->iOutput->clear();
1290
 
  
1291
 
        for (int i = 0; i < MIDI_PORTS; ++i) {
1292
 
              QString name;
1293
 
              name.sprintf("%d:%s", i+1, midiPorts[i].portname().latin1());
1294
 
              midiTrackInfo->iOutput->insertItem(name, i);
1295
 
              if (i == outPort)
1296
 
                    midiTrackInfo->iOutput->setCurrentItem(i);
1297
 
              }
1298
 
        //midiTrackInfo->iInput->setText(bitmap2String(inPort));
1299
 
        ///midiTrackInfo->iInput->setText(u32bitmap2String(inPort));
1300
 
        
1301
 
        //midiTrackInfo->iInputChannel->setText(bitmap2String(inChannel));
1302
 
  
1303
 
        // Removed by Tim. p3.3.9
1304
 
        //if (midiTrackInfo->iName->text() != selected->name()) {
1305
 
        //      midiTrackInfo->iName->setText(selected->name());
1306
 
        //      midiTrackInfo->iName->home(false);
1307
 
        //      }
1308
 
        
1309
 
        midiTrackInfo->iOutputChannel->setValue(outChannel+1);
1310
 
        ///midiTrackInfo->iInputChannel->setText(bitmap2String(inChannel));
1311
 
        
1312
 
        // Set record echo.
1313
 
        if(midiTrackInfo->recEchoButton->isOn() != track->recEcho())
1314
 
        {
1315
 
          midiTrackInfo->recEchoButton->blockSignals(true);
1316
 
          midiTrackInfo->recEchoButton->setOn(track->recEcho());
1317
 
          midiTrackInfo->recEchoButton->blockSignals(false);
1318
 
        }
1319
 
        
1320
 
        MidiPort* mp = &midiPorts[outPort];
1321
 
        int nprogram = mp->hwCtrlState(outChannel, CTRL_PROGRAM);
1322
 
        if(nprogram == CTRL_VAL_UNKNOWN)
1323
 
        {
1324
 
          midiTrackInfo->iHBank->blockSignals(true);
1325
 
          midiTrackInfo->iLBank->blockSignals(true);
1326
 
          midiTrackInfo->iProgram->blockSignals(true);
1327
 
          midiTrackInfo->iHBank->setValue(0);
1328
 
          midiTrackInfo->iLBank->setValue(0);
1329
 
          midiTrackInfo->iProgram->setValue(0);
1330
 
          midiTrackInfo->iHBank->blockSignals(false);
1331
 
          midiTrackInfo->iLBank->blockSignals(false);
1332
 
          midiTrackInfo->iProgram->blockSignals(false);
1333
 
          
1334
 
          program = CTRL_VAL_UNKNOWN;
1335
 
          nprogram = mp->lastValidHWCtrlState(outChannel, CTRL_PROGRAM);
1336
 
          if(nprogram == CTRL_VAL_UNKNOWN) 
1337
 
            //midiTrackInfo->iPatch->setText(QString("<unknown>"));
1338
 
            midiTrackInfo->iPatch->setText(tr("<unknown>"));
1339
 
          else
1340
 
          {
1341
 
            MidiInstrument* instr = mp->instrument();
1342
 
            const char* name = instr->getPatchName(outChannel, nprogram, song->mtype(), track->type() == Track::DRUM);
1343
 
            midiTrackInfo->iPatch->setText(QString(name));
1344
 
          }         
1345
 
        }
1346
 
        else
1347
 
        //if (program != nprogram) 
1348
 
        {
1349
 
              program = nprogram;
1350
 
 
1351
 
              //int hb, lb, pr;
1352
 
              //if (program == CTRL_VAL_UNKNOWN) {
1353
 
              //      hb = lb = pr = 0;
1354
 
              //      midiTrackInfo->iPatch->setText("---");
1355
 
              //      }
1356
 
              //else 
1357
 
              //{
1358
 
                    MidiInstrument* instr = mp->instrument();
1359
 
                    const char* name = instr->getPatchName(outChannel, program, song->mtype(), track->type() == Track::DRUM);
1360
 
                    midiTrackInfo->iPatch->setText(QString(name));
1361
 
 
1362
 
                    int hb = ((program >> 16) & 0xff) + 1;
1363
 
                    if (hb == 0x100)
1364
 
                          hb = 0;
1365
 
                    int lb = ((program >> 8) & 0xff) + 1;
1366
 
                    if (lb == 0x100)
1367
 
                          lb = 0;
1368
 
                    int pr = (program & 0xff) + 1;
1369
 
                    if (pr == 0x100)
1370
 
                          pr = 0;
1371
 
              //}
1372
 
              midiTrackInfo->iHBank->blockSignals(true);
1373
 
              midiTrackInfo->iLBank->blockSignals(true);
1374
 
              midiTrackInfo->iProgram->blockSignals(true);
1375
 
 
1376
 
              midiTrackInfo->iHBank->setValue(hb);
1377
 
              midiTrackInfo->iLBank->setValue(lb);
1378
 
              midiTrackInfo->iProgram->setValue(pr);
1379
 
 
1380
 
              midiTrackInfo->iHBank->blockSignals(false);
1381
 
              midiTrackInfo->iLBank->blockSignals(false);
1382
 
              midiTrackInfo->iProgram->blockSignals(false);
1383
 
        }
1384
 
        
1385
 
        MidiController* mc = mp->midiController(CTRL_VOLUME);
1386
 
        int mn = mc->minVal();
1387
 
        int v = mp->hwCtrlState(outChannel, CTRL_VOLUME);
1388
 
        volume = v;
1389
 
        if(v == CTRL_VAL_UNKNOWN)
1390
 
        //{
1391
 
          //v = mc->initVal();
1392
 
          //if(v == CTRL_VAL_UNKNOWN)
1393
 
          //  v = 0;
1394
 
          v = mn - 1;
1395
 
        //}  
1396
 
        else
1397
 
          // Auto bias...
1398
 
          v -= mc->bias();
1399
 
        midiTrackInfo->iLautst->blockSignals(true);
1400
 
        midiTrackInfo->iLautst->setRange(mn - 1, mc->maxVal());
1401
 
        midiTrackInfo->iLautst->setValue(v);
1402
 
        midiTrackInfo->iLautst->blockSignals(false);
1403
 
        
1404
 
        mc = mp->midiController(CTRL_PANPOT);
1405
 
        mn = mc->minVal();
1406
 
        v = mp->hwCtrlState(outChannel, CTRL_PANPOT);
1407
 
        pan = v;
1408
 
        if(v == CTRL_VAL_UNKNOWN)
1409
 
        //{
1410
 
          //v = mc->initVal();
1411
 
          //if(v == CTRL_VAL_UNKNOWN)
1412
 
          //  v = 0;
1413
 
          v = mn - 1;
1414
 
        //}  
1415
 
        else
1416
 
          // Auto bias...
1417
 
          v -= mc->bias();
1418
 
        midiTrackInfo->iPan->blockSignals(true);
1419
 
        midiTrackInfo->iPan->setRange(mn - 1, mc->maxVal());
1420
 
        midiTrackInfo->iPan->setValue(v);
1421
 
        midiTrackInfo->iPan->blockSignals(false);
1422
 
      //}
1423
 
      
1424
 
      
1425
 
      // Does it include a midi controller value adjustment? Then handle it...
1426
 
      //if(flags & SC_MIDI_CONTROLLER)
1427
 
      //  seek();
1428
 
 
1429
 
      // Is it simply a midi controller value adjustment? Forget it.
1430
 
      //if(flags != SC_MIDI_CONTROLLER)
1431
 
      //{
1432
 
        midiTrackInfo->iTransp->setValue(track->transposition);
1433
 
        midiTrackInfo->iAnschl->setValue(track->velocity);
1434
 
        midiTrackInfo->iVerz->setValue(track->delay);
1435
 
        midiTrackInfo->iLen->setValue(track->len);
1436
 
        midiTrackInfo->iKompr->setValue(track->compression);
1437
 
      //}
1438
 
}
1439
 
 
1440
 
/*
1441
 
//---------------------------------------------------------
1442
 
//   seek
1443
 
//    change values akkording to seek position
1444
 
//---------------------------------------------------------
1445
 
 
1446
 
void Arranger::seek()
1447
 
      {
1448
 
      if (!showTrackinfoFlag || !selected)
1449
 
            return;
1450
 
      switch(selected->type()) {
1451
 
            case Track::MIDI:
1452
 
            case Track::DRUM:
1453
 
                  {
1454
 
                    MidiTrack* track = (MidiTrack*)selected;
1455
 
                    int outPort      = track->outPort();
1456
 
                    int outChannel   = track->outChannel();
1457
 
                    MidiPort* mp = &midiPorts[outPort];
1458
 
  
1459
 
                    // int nprogram = mp->getCtrl(outChannel, tick, CTRL_PROGRAM);
1460
 
                    int nprogram = mp->hwCtrlState(outChannel, CTRL_PROGRAM);
1461
 
                    if(nprogram == CTRL_VAL_UNKNOWN)
1462
 
                    {
1463
 
                      midiTrackInfo->iHBank->blockSignals(true);
1464
 
                      midiTrackInfo->iLBank->blockSignals(true);
1465
 
                      midiTrackInfo->iProgram->blockSignals(true);
1466
 
                      midiTrackInfo->iHBank->setValue(0);
1467
 
                      midiTrackInfo->iLBank->setValue(0);
1468
 
                      midiTrackInfo->iProgram->setValue(0);
1469
 
                      midiTrackInfo->iHBank->blockSignals(false);
1470
 
                      midiTrackInfo->iLBank->blockSignals(false);
1471
 
                      midiTrackInfo->iProgram->blockSignals(false);
1472
 
                      
1473
 
                      program = CTRL_VAL_UNKNOWN;
1474
 
                      nprogram = mp->lastValidHWCtrlState(outChannel, CTRL_PROGRAM);
1475
 
                      if(nprogram == CTRL_VAL_UNKNOWN) 
1476
 
                        midiTrackInfo->iPatch->setText(QString("<unknown>"));
1477
 
                      else
1478
 
                      {
1479
 
                        MidiInstrument* instr = mp->instrument();
1480
 
                        const char* name = instr->getPatchName(outChannel, nprogram, song->mtype(), track->type() == Track::DRUM);
1481
 
                        midiTrackInfo->iPatch->setText(QString(name));
1482
 
                      }         
1483
 
                    }
1484
 
                    else
1485
 
                    if (program != nprogram) {
1486
 
                          program = nprogram;
1487
 
  
1488
 
                          //int hb, lb, pr;
1489
 
                          //if (program == CTRL_VAL_UNKNOWN) {
1490
 
                          //      hb = lb = pr = 0;
1491
 
                          //      midiTrackInfo->iPatch->setText("---");
1492
 
                          //      }
1493
 
                          //else 
1494
 
                          //{
1495
 
                                MidiInstrument* instr = mp->instrument();
1496
 
                                const char* name = instr->getPatchName(outChannel, program, song->mtype(), track->type() == Track::DRUM);
1497
 
                                midiTrackInfo->iPatch->setText(QString(name));
1498
 
  
1499
 
                                int hb = ((program >> 16) & 0xff) + 1;
1500
 
                                if (hb == 0x100)
1501
 
                                      hb = 0;
1502
 
                                int lb = ((program >> 8) & 0xff) + 1;
1503
 
                                if (lb == 0x100)
1504
 
                                      lb = 0;
1505
 
                                int pr = (program & 0xff) + 1;
1506
 
                                if (pr == 0x100)
1507
 
                                      pr = 0;
1508
 
                          //}
1509
 
                          midiTrackInfo->iHBank->blockSignals(true);
1510
 
                          midiTrackInfo->iLBank->blockSignals(true);
1511
 
                          midiTrackInfo->iProgram->blockSignals(true);
1512
 
  
1513
 
                          midiTrackInfo->iHBank->setValue(hb);
1514
 
                          midiTrackInfo->iLBank->setValue(lb);
1515
 
                          midiTrackInfo->iProgram->setValue(pr);
1516
 
  
1517
 
                          midiTrackInfo->iHBank->blockSignals(false);
1518
 
                          midiTrackInfo->iLBank->blockSignals(false);
1519
 
                          midiTrackInfo->iProgram->blockSignals(false);
1520
 
                          }
1521
 
  
1522
 
                    //int nvolume = midiPorts[outPort].getCtrl(outChannel, tick, CTRL_VOLUME);
1523
 
                    // int npan = midiPorts[outPort].getCtrl(outChannel, tick, CTRL_PANPOT);
1524
 
                    MidiController* mc = mp->midiController(CTRL_VOLUME);
1525
 
                    int v = mp->hwCtrlState(outChannel, CTRL_VOLUME);
1526
 
                    if(v != volume) 
1527
 
                    {
1528
 
                      volume = v;
1529
 
                      if(v == CTRL_VAL_UNKNOWN)
1530
 
                        v = mc->minVal() - 1;
1531
 
                      else
1532
 
                        v -= mc->bias();
1533
 
                      midiTrackInfo->iLautst->blockSignals(true);
1534
 
                      midiTrackInfo->iLautst->setValue(v);
1535
 
                      midiTrackInfo->iLautst->blockSignals(false);
1536
 
                    }  
1537
 
                    mc = mp->midiController(CTRL_PANPOT);
1538
 
                    v = mp->hwCtrlState(outChannel, CTRL_PANPOT);
1539
 
                    if(v != pan) 
1540
 
                    {
1541
 
                      pan = v;
1542
 
                      if(v == CTRL_VAL_UNKNOWN)
1543
 
                      //{
1544
 
                        //v = mc->initVal();
1545
 
                        //if(v == CTRL_VAL_UNKNOWN)
1546
 
                        //  v = 0;
1547
 
                        v = mc->minVal() - 1;
1548
 
                      //}  
1549
 
                      else
1550
 
                        // Auto bias...
1551
 
                        v -= mc->bias();
1552
 
                      midiTrackInfo->iPan->blockSignals(true);
1553
 
                      midiTrackInfo->iPan->setValue(v);
1554
 
                      midiTrackInfo->iPan->blockSignals(false);
1555
 
                    }
1556
 
                
1557
 
                  }
1558
 
                  break;
1559
 
            case Track::WAVE:
1560
 
            case Track::AUDIO_OUTPUT:
1561
 
            case Track::AUDIO_INPUT:
1562
 
            case Track::AUDIO_GROUP:
1563
 
            case Track::AUDIO_AUX:
1564
 
            case Track::AUDIO_SOFTSYNTH:
1565
 
                  break;
1566
 
            }
1567
 
      }
1568
 
*/