← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/muse/oneiric

« back to all changes in this revision

Viewing changes to mixer/mixer.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Daniel Kobras
  • Date: 2002-04-23 17:28:23 UTC
  • Revision ID: james.westby@ubuntu.com-20020423172823-w8yplzr81a759xa3
Tags: upstream-0.5.2
Import upstream version 0.5.2

Show diffs side-by-side

added added

removed removed

Lines of Context:
mixer/mixer.cpp
 
1
//=========================================================
 
2
//  MusE
 
3
//  Linux Music Editor
 
4
//    $Id: mixer.cpp,v 1.1 2002/01/30 12:08:38 muse Exp $
 
5
//  (C) Copyright 1999 Werner Schweer (ws@seh.de)
 
6
//=========================================================
 
7
 
 
8
#include <stdio.h>
 
9
 
 
10
#include "mixer.h"
 
11
#include <qapp.h>
 
12
#include <qlayout.h>
 
13
#include <qslider.h>
 
14
#include <qlabel.h>
 
15
#include <qsignalmapper.h>
 
16
#include <qpixmap.h>
 
17
#include <qpushbutton.h>
 
18
#include <qtoolbar.h>
 
19
 
 
20
#include "intlabel.h"
 
21
#include "song.h"
 
22
#include "lcombo.h"
 
23
#include "midiport.h"
 
24
#include "icons.h"
 
25
#include "utils.h"
 
26
#include "../xml.h"
 
27
#include "midictrl.h"
 
28
 
 
29
#define CTRL  4         // number of controller values in mixer
 
30
 
 
31
//---------------------------------------------------------
 
32
//   Mixer
 
33
//---------------------------------------------------------
 
34
 
 
35
Mixer::Mixer() : TopWin(0, "MidiMixer", WType_TopLevel)
 
36
      {
 
37
      setCaption("MusE: Midi Mixer");
 
38
      const char* ctrlLabels[CTRL] = { "Rev", "Cho", "Var", "Pan" };
 
39
      port = 0;
 
40
 
 
41
      TrackList* tracks = song->tracks();
 
42
      bool used[MIDI_CHANNELS*MIDI_PORTS];
 
43
      for (int i = 0; i < MIDI_CHANNELS*MIDI_PORTS; ++i)
 
44
            used[i] = false;
 
45
      for (iTrack it = tracks->begin(); it != tracks->end(); ++it) {
 
46
            MidiTrack* track = dynamic_cast<MidiTrack*>(*it);
 
47
            if (track == 0)
 
48
                  continue;
 
49
            int port = track->outPort();
 
50
            int channel = track->outChannel();
 
51
            used[channel + MIDI_CHANNELS * port] = true;
 
52
            }
 
53
      int channels = 0;
 
54
      for (int port = 0; port < MIDI_PORTS; ++port) {
 
55
            for (int channel = 0; channel < MIDI_CHANNELS; ++channel) {
 
56
                  if (used[channel + MIDI_CHANNELS * port]) {
 
57
                        MixerLine* line = new MixerLine;
 
58
                        line->port = port;
 
59
                        line->channel = channel;
 
60
                        line->index = channels++;
 
61
                        lines.push_back(line);
 
62
                        }
 
63
                  }
 
64
            }
 
65
 
 
66
      QWidget* w = new QWidget(this, "main");
 
67
      setCentralWidget(w);
 
68
 
 
69
      QSignalMapper* mapper = new QSignalMapper(this);
 
70
      connect(mapper, SIGNAL(mapped(int)), this, SLOT(valChanged(int)));
 
71
 
 
72
      QGridLayout* grid = new QGridLayout(w);
 
73
      grid->setRowStretch(4+CTRL*2, 20);
 
74
 
 
75
      grid->addMultiCellWidget(hLine(w),  0, 0, 0, channels*2);
 
76
      grid->addMultiCellWidget(hLine(w),  2, 2, 0, channels*2);
 
77
 
 
78
      for (iMixerLine i = lines.begin(); i != lines.end(); ++i) {
 
79
            MixerLine* l = *i;
 
80
 
 
81
            int index = l->index;
 
82
            char buffer[16];
 
83
            sprintf(buffer, "Ch%d", (*i)->channel + 1);
 
84
            QLabel* cl = new QLabel(buffer, w);
 
85
            cl->setAlignment(AlignCenter);
 
86
            grid->addWidget(cl,       1, index*2);
 
87
            grid->addWidget(vLine(w), 1, index*2+1);
 
88
 
 
89
            sprintf(buffer, "P %d", (*i)->port + 1);
 
90
            QLabel* pl = new QLabel(buffer, w);
 
91
            pl->setAlignment(AlignCenter);
 
92
            grid->addWidget(pl,       3, index*2);
 
93
            grid->addWidget(hLine(w), 4, index*2);
 
94
 
 
95
            grid->addMultiCellWidget(vLine(w), 3, 6+CTRL*2, index*2+1, index*2+1);
 
96
 
 
97
            IntLabel** dials[CTRL] = {
 
98
                  &l->reverb, &l->chorus, &l->variation, &l->panpos
 
99
                  };
 
100
            for (int k = 0; k < CTRL; ++k) {
 
101
                  *dials[k] = new IntLabel(-1, -1, 127, w, -1);
 
102
                  (*dials[k])->setFixedWidth(32);
 
103
                  mapper->setMapping(*dials[k], (k<<8)+index);
 
104
                  connect(*dials[k], SIGNAL(valueChanged(int)), mapper, SLOT(map()));
 
105
                  grid->addWidget(*dials[k], 5+k*2, index*2);
 
106
                  grid->addWidget(hLine(w), 6+k*2, index*2);
 
107
                  }
 
108
            l->mute = new QPushButton(w);
 
109
            l->mute->setPixmap(*dot1Icon);
 
110
            l->mute->setToggleButton(true);
 
111
            grid->addWidget(l->mute, 5+CTRL*2, index*2);
 
112
            mapper->setMapping(l->mute, 4*256+index);
 
113
            connect(l->mute, SIGNAL(toggled(bool)), mapper, SLOT(map()));
 
114
 
 
115
            l->volume = new QSlider(0, 127, 1, 127, Vertical, w);
 
116
            l->volume->setTickmarks(QSlider::Right);
 
117
            l->volume->setTickInterval(32);
 
118
            mapper->setMapping(l->volume, 5*256+index);
 
119
            connect(l->volume, SIGNAL(valueChanged(int)), mapper, SLOT(map()));
 
120
            grid->addWidget(l->volume, 6 + CTRL*2, index*2);
 
121
            }
 
122
 
 
123
      //---------------------------------------------------
 
124
      //    master
 
125
      //---------------------------------------------------
 
126
 
 
127
      QLabel* cl = new QLabel("Master", w, "chl");
 
128
      grid->addWidget(cl, 1, channels*2);
 
129
 
 
130
      QLabel* cp = new QLabel("Port", w);
 
131
      cp->setAlignment(AlignCenter);
 
132
      grid->addWidget(cp, 3, channels*2);
 
133
      grid->addWidget(hLine(w), 4, channels*2);
 
134
 
 
135
      for (int k = 0; k < CTRL; ++k) {
 
136
            QLabel* l1  = new QLabel(ctrlLabels[k], w);
 
137
            l1->setAlignment(AlignCenter);
 
138
            grid->addWidget(l1, 5+k*2, channels*2);
 
139
            grid->addWidget(hLine(w), 6+k*2, channels*2);
 
140
            }
 
141
      QLabel* l2 =new QLabel(tr("Mute"), w);
 
142
      grid->addWidget(l2, 5+CTRL*2, channels*2);
 
143
 
 
144
      master = new QSlider(0, 16383, 1, 16383, Vertical, w);
 
145
      master->setTickmarks(QSlider::Right);
 
146
      master->setTickInterval(2048);
 
147
      master->setValue(16383 - midiPorts[0].masterVol());
 
148
 
 
149
      grid->addWidget(master, 6+CTRL*2, channels*2);
 
150
      connect(master, SIGNAL(valueChanged(int)), this, SLOT(masterChanged(int)));
 
151
      grid->setColStretch(channels*2+1, 20);
 
152
      updateValues(false);    // set init values
 
153
      setFixedWidth((channels+1) * (32+5));
 
154
      }
 
155
 
 
156
//---------------------------------------------------------
 
157
//   valChanged
 
158
//---------------------------------------------------------
 
159
 
 
160
void Mixer::valChanged(int p)
 
161
      {
 
162
      int type    = p >> 8;
 
163
      int index = p & 0xff;
 
164
      iMixerLine i;
 
165
      for (i = lines.begin(); i != lines.end(); ++i) {
 
166
            if ((*i)->index == index)
 
167
                  break;
 
168
            }
 
169
      assert(i != lines.end());
 
170
      MixerLine* l = *i;
 
171
      int channel = l->channel;
 
172
      int port    = l->port;
 
173
      int val;
 
174
      switch(type) {
 
175
            case 0:
 
176
                  val = l->reverb->value();
 
177
                  emit ctrlChanged(port, channel, 0x5b, val);
 
178
                  break;
 
179
            case 1:
 
180
                  val = l->chorus->value();
 
181
                  emit ctrlChanged(port, channel, 0x5d, val);
 
182
                  break;
 
183
            case 2:
 
184
                  val = l->variation->value();
 
185
                  emit ctrlChanged(port, channel, 0x5e, val);
 
186
                  break;
 
187
            case 3:
 
188
                  val = l->panpos->value();
 
189
                  emit ctrlChanged(port, channel, 0x0a, val);
 
190
                  break;
 
191
            case 4:
 
192
                  val = l->mute->isOn();
 
193
                  l->mute->setPixmap(val ? *muteIcon : *dot1Icon);
 
194
                  song->setChannelMute(channel, val);
 
195
                  break;
 
196
            case 5:
 
197
                  val = 127 - l->volume->value();
 
198
                  emit ctrlChanged(port, channel, 0x7, val);
 
199
                  break;
 
200
            default:
 
201
                  printf("valChanged:interner Fehler type=%d\n", type);
 
202
                  break;
 
203
            }
 
204
      }
 
205
 
 
206
//---------------------------------------------------------
 
207
//   masterChanged
 
208
//---------------------------------------------------------
 
209
 
 
210
void Mixer::masterChanged(int val)
 
211
      {
 
212
      emit masterVolChanged(16383-val);
 
213
      }
 
214
 
 
215
//---------------------------------------------------------
 
216
//   closeEvent
 
217
//---------------------------------------------------------
 
218
 
 
219
void Mixer::closeEvent(QCloseEvent* e)
 
220
      {
 
221
      emit deleted((int)this);
 
222
      e->accept();
 
223
      }
 
224
 
 
225
//---------------------------------------------------------
 
226
//   updateMixer
 
227
//---------------------------------------------------------
 
228
 
 
229
void Mixer::updateValues(bool current=true)
 
230
      {
 
231
      for (iMixerLine i = lines.begin(); i != lines.end(); ++i) {
 
232
            MixerLine* l = *i;
 
233
            MidiPort* port = &midiPorts[l->port];
 
234
            ChannelState* state = current ? port->cState(l->channel) : port->iState(l->channel);
 
235
            int val = state->controller[CTRL_VOLUME];
 
236
            if (val != 127-l->volume->value())
 
237
                  l->volume->setValue(127 - val);
 
238
            val = state->controller[CTRL_CHORUS_SEND];
 
239
            if (val != l->chorus->value())
 
240
                  l->chorus->setValue(val);
 
241
            val = state->controller[CTRL_REVERB_SEND];
 
242
            if (val != l->reverb->value())
 
243
                  l->reverb->setValue(val);
 
244
            val = state->controller[CTRL_VARIATION_SEND];
 
245
            if (val != l->variation->value())
 
246
                  l->variation->setValue(val);
 
247
            val = state->controller[CTRL_PANPOT];
 
248
            if (val != l->panpos->value())
 
249
                  l->panpos->setValue(val);
 
250
            }
 
251
      }
 
252
 
 
253
//---------------------------------------------------------
 
254
//   readStatus
 
255
//---------------------------------------------------------
 
256
 
 
257
void Mixer::readStatus(Xml& xml)
 
258
      {
 
259
 
 
260
      for (;;) {
 
261
            Xml::Token token = xml.parse();
 
262
            const QString& tag = xml.s1();
 
263
            switch (token) {
 
264
                  case Xml::Error:
 
265
                  case Xml::End:
 
266
                        return;
 
267
                  case Xml::TagStart:
 
268
                        if (tag == "topwin")
 
269
                              TopWin::readStatus(xml);
 
270
                        else
 
271
                              xml.unknown("MidiMixer");
 
272
                        break;
 
273
                  case Xml::TagEnd:
 
274
                        if (tag == "midimixer")
 
275
                              return;
 
276
                  default:
 
277
                        break;
 
278
                  }
 
279
            }
 
280
      }
 
281
 
 
282
//---------------------------------------------------------
 
283
//   writeStatus
 
284
//---------------------------------------------------------
 
285
 
 
286
void Mixer::writeStatus(int level, Xml& xml) const
 
287
      {
 
288
      xml.tag(level++, "midimixer");
 
289
      TopWin::writeStatus(level, xml);
 
290
      xml.tag(level, "/midimixer");
 
291
      }