← Back to branch summary

~ubuntu-branches/ubuntu/feisty/muse/feisty

« back to all changes in this revision

Viewing changes to midiedit/pianoroll.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:
midiedit/pianoroll.cpp
 
1
//=========================================================
 
2
//  MusE
 
3
//  Linux Music Editor
 
4
//    $Id: pianoroll.cpp,v 1.1 2002/01/30 14:10:08 muse Exp $
 
5
//  (C) Copyright 1999 Werner Schweer (ws@seh.de)
 
6
//=========================================================
 
7
 
 
8
#include <stdio.h>
 
9
 
 
10
#include "xml.h"
 
11
#include "mtscale.h"
 
12
#include "prcanvas.h"
 
13
#include "pianoroll.h"
 
14
#include "scrollscale.h"
 
15
#include "piano.h"
 
16
#include "../ctrl/ctrledit.h"
 
17
#include "splitter.h"
 
18
#include "ttoolbar.h"
 
19
#include "tb1.h"
 
20
#include "utils.h"
 
21
#include "globals.h"
 
22
#include "icons.h"
 
23
#include "event.h"
 
24
#include "midithread.h"
 
25
 
 
26
#include <qaccel.h>
 
27
#include <qlayout.h>
 
28
#include <qhbox.h>
 
29
#include <qsizegrip.h>
 
30
#include <qlabel.h>
 
31
#include <qpushbutton.h>
 
32
#include <qbuttongroup.h>
 
33
#include <qtoolbutton.h>
 
34
#include <qtooltip.h>
 
35
#include <qpopupmenu.h>
 
36
#include <qmenubar.h>
 
37
#include <qapplication.h>
 
38
#include <qclipboard.h>
 
39
 
 
40
#include "cmd.h"
 
41
#include "quantconfig.h"
 
42
 
 
43
int PianoRoll::_quantInit = 96;
 
44
int PianoRoll::_rasterInit = 96;
 
45
int PianoRoll::_quantStrengthInit = 80;      // 1 - 100%
 
46
int PianoRoll::_quantLimitInit = 50;         // tick value
 
47
bool PianoRoll::_quantLenInit = false;
 
48
int PianoRoll::_toInit = 0;
 
49
int PianoRoll::colorModeInit = 0;
 
50
 
 
51
static const int xscale = -10;
 
52
static const int yscale = 1;
 
53
static const int pianoWidth = 40;
 
54
 
 
55
//---------------------------------------------------------
 
56
//   PianoRoll
 
57
//---------------------------------------------------------
 
58
 
 
59
PianoRoll::PianoRoll(PartList* pl, QWidget* parent = 0, const char* name = 0)
 
60
   : MidiEditor(_quantInit, _rasterInit, pl, parent, name)
 
61
      {
 
62
      selEvent       = 0;
 
63
      selPart        = 0;
 
64
      quantConfig    = 0;
 
65
      _playEvents    = false;
 
66
      _quantStrength = _quantStrengthInit;
 
67
      _quantLimit    = _quantLimitInit;
 
68
      _quantLen      = _quantLenInit;
 
69
      _to            = _toInit;
 
70
      colorMode      = colorModeInit;
 
71
 
 
72
      //---------Men�----------------------------------
 
73
      menuEdit = new QPopupMenu(this);
 
74
      menuBar()->insertItem(tr("&Edit"), menuEdit);
 
75
      menuEdit->insertItem(tr("Cut"),   PianoCanvas::CMD_CUT);
 
76
      menuEdit->setAccel(CTRL+Key_X,    PianoCanvas::CMD_CUT);
 
77
      menuEdit->insertItem(tr("Copy"),  PianoCanvas::CMD_COPY);
 
78
      menuEdit->setAccel(CTRL+Key_C,    PianoCanvas::CMD_COPY);
 
79
      menuEdit->insertItem(tr("Paste"), PianoCanvas::CMD_PASTE);
 
80
      menuEdit->setAccel(CTRL+Key_V,    PianoCanvas::CMD_PASTE);
 
81
      menuEdit->insertSeparator();
 
82
      menuEdit->insertItem(tr("Delete Events"), PianoCanvas::CMD_DEL);
 
83
      menuEdit->insertSeparator();
 
84
 
 
85
      QPopupMenu* menuSelect = new QPopupMenu(this);
 
86
      menuSelect->insertItem(tr("Select All"),   PianoCanvas::CMD_SELECT_ALL);
 
87
      menuSelect->insertItem(tr("Select None"),  PianoCanvas::CMD_SELECT_NONE);
 
88
      menuSelect->insertItem(tr("Invert"),       PianoCanvas::CMD_SELECT_INVERT);
 
89
      menuSelect->insertSeparator();
 
90
      menuSelect->insertItem(tr("Inside Loop"),  PianoCanvas::CMD_SELECT_ILOOP);
 
91
      menuSelect->insertItem(tr("Outside Loop"), PianoCanvas::CMD_SELECT_OLOOP);
 
92
      menuEdit->insertItem(tr("&Select"), menuSelect);
 
93
 
 
94
      eventColor = new QPopupMenu(this);
 
95
      eventColor->insertItem(tr("blue"), 0);
 
96
      eventColor->insertItem(tr("pitch colors"), 1);
 
97
      eventColor->insertItem(tr("velocity colors"), 2);
 
98
      connect(eventColor, SIGNAL(activated(int)), SLOT(setEventColorMode(int)));
 
99
 
 
100
      QPopupMenu* menuConfig = new QPopupMenu(this);
 
101
      menuBar()->insertItem(tr("&Config"), menuConfig);
 
102
      menuConfig->insertItem(tr("event color"), eventColor, Key_E);
 
103
 
 
104
      menuFunctions = new QPopupMenu(this);
 
105
      menuBar()->insertItem(tr("&Functions"), menuFunctions);
 
106
      menuFunctions->insertTearOffHandle();
 
107
      menuFunctions->insertItem(tr("Over Quantize"),        PianoCanvas::CMD_OVER_QUANTIZE);
 
108
      menuFunctions->insertItem(tr("Note On Quantize"),     PianoCanvas::CMD_ON_QUANTIZE);
 
109
      menuFunctions->insertItem(tr("Note On/Off Quantize"), PianoCanvas::CMD_ONOFF_QUANTIZE);
 
110
      menuFunctions->insertItem(tr("Iterative Quantize"),   PianoCanvas::CMD_ITERATIVE_QUANTIZE);
 
111
      menuFunctions->insertSeparator();
 
112
      menuFunctions->insertItem(tr("Config Quant..."), this,
 
113
        SLOT(configQuant()));
 
114
      menuFunctions->insertSeparator();
 
115
      menuFunctions->insertItem(tr("Modify Gate Time"), PianoCanvas::CMD_MODIFY_GATE_TIME);
 
116
      menuFunctions->insertItem(tr("Modify Velocity"),  PianoCanvas::CMD_MODIFY_VELOCITY);
 
117
      menuFunctions->insertItem(tr("Crescendo"),        PianoCanvas::CMD_CRESCENDO);
 
118
      menuFunctions->insertItem(tr("Transpose"),        PianoCanvas::CMD_TRANSPOSE);
 
119
      menuFunctions->insertItem(tr("Thin Out"),         PianoCanvas::CMD_THIN_OUT);
 
120
      menuFunctions->insertItem(tr("Erase Event"),      PianoCanvas::CMD_ERASE_EVENT);
 
121
      menuFunctions->insertItem(tr("Note Shift"),       PianoCanvas::CMD_NOTE_SHIFT);
 
122
      menuFunctions->insertItem(tr("Move Clock"),       PianoCanvas::CMD_MOVE_CLOCK);
 
123
      menuFunctions->insertItem(tr("Copy Measure"),     PianoCanvas::CMD_COPY_MEASURE);
 
124
      menuFunctions->insertItem(tr("Erase Measure"),    PianoCanvas::CMD_ERASE_MEASURE);
 
125
      menuFunctions->insertItem(tr("Delete Measure"),   PianoCanvas::CMD_DELETE_MEASURE);
 
126
      menuFunctions->insertItem(tr("Create Measure"),   PianoCanvas::CMD_CREATE_MEASURE);
 
127
 
 
128
      menuFunctions->setItemEnabled(PianoCanvas::CMD_CRESCENDO, false);
 
129
      menuFunctions->setItemEnabled(PianoCanvas::CMD_TRANSPOSE, false);
 
130
      menuFunctions->setItemEnabled(PianoCanvas::CMD_THIN_OUT, false);
 
131
      menuFunctions->setItemEnabled(PianoCanvas::CMD_ERASE_EVENT, false);
 
132
      menuFunctions->setItemEnabled(PianoCanvas::CMD_NOTE_SHIFT, false);
 
133
      menuFunctions->setItemEnabled(PianoCanvas::CMD_MOVE_CLOCK, false);
 
134
      menuFunctions->setItemEnabled(PianoCanvas::CMD_COPY_MEASURE, false);
 
135
      menuFunctions->setItemEnabled(PianoCanvas::CMD_ERASE_MEASURE, false);
 
136
      menuFunctions->setItemEnabled(PianoCanvas::CMD_DELETE_MEASURE, false);
 
137
      menuFunctions->setItemEnabled(PianoCanvas::CMD_CREATE_MEASURE, false);
 
138
 
 
139
      connect(menuEdit, SIGNAL(activated(int)),      SLOT(cmd(int)));
 
140
      connect(menuSelect, SIGNAL(activated(int)),    SLOT(cmd(int)));
 
141
      connect(menuFunctions, SIGNAL(activated(int)), SLOT(cmd(int)));
 
142
 
 
143
      //---------ToolBar----------------------------------
 
144
      tools = new QToolBar(this, "pianoroll-tools");
 
145
      tools->setLabel(tr("Pianoroll Tools"));
 
146
      undoRedo->addTo(tools);
 
147
      tools->addSeparator();
 
148
 
 
149
      srec  = new QToolButton(tools, "srec");
 
150
      QToolTip::add(srec, tr("Step Record"));
 
151
      srec->setPixmap(*steprecIcon);
 
152
      srec->setToggleButton(true);
 
153
 
 
154
      midiin  = new QToolButton(tools, "midiin");
 
155
      QToolTip::add(midiin, tr("Midi Input"));
 
156
      midiin->setPixmap(*midiinIcon);
 
157
      midiin->setToggleButton(true);
 
158
 
 
159
      speaker  = new QToolButton(tools, "speaker");
 
160
      QToolTip::add(speaker, tr("Play Events"));
 
161
      speaker->setPixmap(*speakerIcon);
 
162
      speaker->setToggleButton(true);
 
163
 
 
164
      tools2 = new EditToolBar(this, PointerTool | PencilTool | RubberTool | DrawTool);
 
165
 
 
166
      //-------------------------------------------------------------
 
167
      //    Transport Bar
 
168
      new TransportToolbar(this);
 
169
 
 
170
      toolbar = new Toolbar1(this, _rasterInit, _quantInit);
 
171
      info    = new NoteInfo(this);
 
172
 
 
173
      //---------------------------------------------------
 
174
      //    split
 
175
      //---------------------------------------------------
 
176
 
 
177
      splitter = new Splitter(Vertical, mainw, "splitter");
 
178
      QPushButton* ctrl = new QPushButton("ctrl", mainw, "Ctrl");
 
179
      QToolTip::add(ctrl, tr("Add Controller View"));
 
180
      hscroll = new ScrollScale(-25, -2, xscale, 20000, Horizontal, mainw);
 
181
      ctrl->setFixedSize(pianoWidth, hscroll->sizeHint().height());
 
182
 
 
183
      QSizeGrip* corner = new QSizeGrip(mainw);
 
184
 
 
185
      mainGrid->setRowStretch(0, 100);
 
186
      mainGrid->setColStretch(1, 100);
 
187
      mainGrid->addMultiCellWidget(splitter, 0, 0, 0, 2);
 
188
      mainGrid->addWidget(ctrl,    1, 0);
 
189
      mainGrid->addWidget(hscroll, 1, 1);
 
190
      mainGrid->addWidget(corner,  1, 2, AlignBottom|AlignRight);
 
191
      mainGrid->addRowSpacing(1, hscroll->sizeHint().height());
 
192
 
 
193
      QWidget* split1     = new QWidget(splitter, "split1");
 
194
      QGridLayout* gridS1 = new QGridLayout(split1);
 
195
      time                = new MTScale(&_raster, split1, xscale);
 
196
      Piano* piano        = new Piano(split1, yscale);
 
197
      canvas              = new PianoCanvas(this, split1, xscale, yscale);
 
198
      vscroll             = new ScrollScale(-3, 7, yscale, KH * 75, Vertical, split1);
 
199
 
 
200
      int offset = -(division/4);
 
201
      canvas->setOrigin(offset, 0);
 
202
      time->setOrigin(offset, 0);
 
203
 
 
204
      gridS1->setRowStretch(2, 100);
 
205
      gridS1->setColStretch(1, 100);
 
206
 
 
207
      gridS1->addMultiCellWidget(time,  0, 0, 1, 2);
 
208
      gridS1->addMultiCellWidget(hLine(split1), 1, 1, 0, 2);
 
209
      gridS1->addWidget(piano,   2, 0);
 
210
      gridS1->addWidget(canvas,  2, 1);
 
211
      gridS1->addWidget(vscroll, 2, 2);
 
212
 
 
213
      piano->setFixedWidth(pianoWidth);
 
214
 
 
215
      connect(tools2, SIGNAL(toolChanged(int)), canvas,   SLOT(setTool(int)));
 
216
 
 
217
      connect(ctrl, SIGNAL(clicked()), SLOT(addCtrl()));
 
218
      connect(info, SIGNAL(valueChanged(NoteInfo::ValType, int)), SLOT(noteinfoChanged(NoteInfo::ValType, int)));
 
219
      connect(vscroll, SIGNAL(scrollChanged(int)), piano,  SLOT(setYPos(int)));
 
220
      connect(vscroll, SIGNAL(scrollChanged(int)), canvas, SLOT(setYPos(int)));
 
221
      connect(vscroll, SIGNAL(scaleChanged(int)),  canvas, SLOT(setYMag(int)));
 
222
      connect(vscroll, SIGNAL(scaleChanged(int)),  piano,  SLOT(setYMag(int)));
 
223
 
 
224
      connect(hscroll, SIGNAL(scrollChanged(int)), canvas,   SLOT(setXPos(int)));
 
225
      connect(hscroll, SIGNAL(scrollChanged(int)), time,     SLOT(setXPos(int)));
 
226
 
 
227
      connect(hscroll, SIGNAL(scaleChanged(int)),  canvas,   SLOT(setXMag(int)));
 
228
      connect(hscroll, SIGNAL(scaleChanged(int)),  time,     SLOT(setXMag(int)));
 
229
 
 
230
      connect(canvas, SIGNAL(pitchChanged(int)), piano, SLOT(setPitch(int)));
 
231
      connect(canvas, SIGNAL(selectionChanged(int, Event*, Part*)), this,
 
232
         SLOT(setSelection(int, Event*, Part*)));
 
233
 
 
234
      connect(piano, SIGNAL(keyPressed(int, bool)), canvas, SLOT(pianoPressed(int, bool)));
 
235
      connect(piano, SIGNAL(keyReleased(int, bool)), canvas, SLOT(pianoReleased(int, bool)));
 
236
      connect(srec, SIGNAL(toggled(bool)), SLOT(setSteprec(bool)));
 
237
      connect(midiin, SIGNAL(toggled(bool)), canvas, SLOT(setMidiin(bool)));
 
238
      connect(speaker, SIGNAL(toggled(bool)), SLOT(setSpeaker(bool)));
 
239
      connect(canvas, SIGNAL(followEvent(int)), SLOT(follow(int)));
 
240
 
 
241
      piano->setYPos(KH * 30);
 
242
      canvas->setYPos(KH * 30);
 
243
      vscroll->setPos(KH * 30);
 
244
      setSelection(0, 0, 0);
 
245
 
 
246
      connect(song, SIGNAL(songChanged(int)), SLOT(songChanged(int)));
 
247
      connect(song, SIGNAL(soloChanged(SoundSource*)), SLOT(soloChanged(SoundSource*)));
 
248
 
 
249
      setCaption(canvas->getCaption());
 
250
      int s, e;
 
251
      canvas->range(&s, &e);
 
252
      hscroll->setRange(s, e);
 
253
 
 
254
      // connect to toolbar
 
255
      connect(canvas,   SIGNAL(pitchChanged(int)), toolbar, SLOT(setPitch(int)));
 
256
      connect(canvas,   SIGNAL(timeChanged(int)),  SLOT(setTime(int)));
 
257
      connect(piano,    SIGNAL(pitchChanged(int)), toolbar, SLOT(setPitch(int)));
 
258
      connect(time,     SIGNAL(timeChanged(int)),  SLOT(setTime(int)));
 
259
      connect(toolbar,  SIGNAL(quantChanged(int)), SLOT(setQuant(int)));
 
260
      connect(toolbar,  SIGNAL(rasterChanged(int)),SLOT(setRaster(int)));
 
261
      connect(toolbar,  SIGNAL(toChanged(int)),    SLOT(setTo(int)));
 
262
      connect(toolbar,  SIGNAL(soloChanged(bool)), SLOT(soloChanged(bool)));
 
263
 
 
264
      setFocusPolicy(StrongFocus);
 
265
      setEventColorMode(colorMode);
 
266
 
 
267
      QClipboard* cb = QApplication::clipboard();
 
268
      connect(cb, SIGNAL(dataChanged()), SLOT(clipboardChanged()));
 
269
 
 
270
      clipboardChanged(); // enable/disable "Paste"
 
271
      selectionChanged(); // enable/disable "Copy" & "Paste"
 
272
      }
 
273
 
 
274
//---------------------------------------------------------
 
275
//   follow
 
276
//---------------------------------------------------------
 
277
 
 
278
void PianoRoll::follow(int pos)
 
279
      {
 
280
      int s, e;
 
281
      canvas->range(&s, &e);
 
282
 
 
283
      if (pos < e && pos >= s)
 
284
            hscroll->setOffset(pos);
 
285
      if (pos < s)
 
286
            hscroll->setOffset(s);
 
287
      }
 
288
 
 
289
//---------------------------------------------------------
 
290
//   setTime
 
291
//---------------------------------------------------------
 
292
 
 
293
void PianoRoll::setTime(int tick)
 
294
      {
 
295
      toolbar->setTime(tick);
 
296
      time->setPos(3, tick, false);
 
297
      }
 
298
 
 
299
//---------------------------------------------------------
 
300
//   ~Pianoroll
 
301
//---------------------------------------------------------
 
302
 
 
303
PianoRoll::~PianoRoll()
 
304
      {
 
305
      undoRedo->removeFrom(tools);
 
306
      }
 
307
 
 
308
//---------------------------------------------------------
 
309
//   cmd
 
310
//    pulldown menu commands
 
311
//---------------------------------------------------------
 
312
 
 
313
void PianoRoll::cmd(int cmd)
 
314
      {
 
315
      ((PianoCanvas*)canvas)->cmd(cmd, _quantStrength, _quantLimit, _quantLen, _to);
 
316
      }
 
317
 
 
318
//---------------------------------------------------------
 
319
//   setSelection
 
320
//    update Info Line
 
321
//---------------------------------------------------------
 
322
 
 
323
void PianoRoll::setSelection(int tick, Event* e, Part* p)
 
324
      {
 
325
      selEvent = (MidiEvent*)e;
 
326
      selPart  = (MidiPart*)p;
 
327
      selTick  = tick;
 
328
      if (e) {
 
329
            info->setEnabled(true);
 
330
            info->setValues(tick,
 
331
               selEvent->lenTick(),
 
332
               selEvent->pitch(),
 
333
               selEvent->velo(),
 
334
               selEvent->veloOff(),
 
335
               selEvent->channel()+1);
 
336
            }
 
337
      else {
 
338
            info->setEnabled(false);
 
339
            }
 
340
      selectionChanged();
 
341
      }
 
342
 
 
343
//---------------------------------------------------------
 
344
//    edit currently selected Event
 
345
//---------------------------------------------------------
 
346
 
 
347
void PianoRoll::noteinfoChanged(NoteInfo::ValType type, int val)
 
348
      {
 
349
      if (selEvent == 0) {
 
350
            printf("noteinfoChanged while note is zero\n");
 
351
            return;
 
352
            }
 
353
      MidiEvent* event = new MidiEvent(*selEvent);
 
354
      switch(type) {
 
355
            case NoteInfo::VAL_TIME:
 
356
                  break;
 
357
            case NoteInfo::VAL_LEN:
 
358
                  event->setLenTick(val);
 
359
                  break;
 
360
            case NoteInfo::VAL_VELON:
 
361
                  event->setVelo(val);
 
362
                  break;
 
363
            case NoteInfo::VAL_VELOFF:
 
364
                  event->setVeloOff(val);
 
365
                  break;
 
366
            case NoteInfo::VAL_CHANNEL:
 
367
//                  event->setChannel(val-1);
 
368
                  break;
 
369
            case NoteInfo::VAL_PITCH:
 
370
                  event->setPitch(val);
 
371
                  break;
 
372
            }
 
373
      midiThread->msgChangeEvent(selEvent, event, selPart);
 
374
      }
 
375
 
 
376
//---------------------------------------------------------
 
377
//   addCtrl
 
378
//---------------------------------------------------------
 
379
 
 
380
CtrlEdit* PianoRoll::addCtrl()
 
381
      {
 
382
      CtrlEdit* ctrlEdit = new CtrlEdit(splitter, this, xscale, false, "pianoCtrlEdit");
 
383
      connect(tools2,   SIGNAL(toolChanged(int)),   ctrlEdit, SLOT(setTool(int)));
 
384
      connect(hscroll,  SIGNAL(scrollChanged(int)), ctrlEdit, SLOT(setXPos(int)));
 
385
      connect(hscroll,  SIGNAL(scaleChanged(int)),  ctrlEdit, SLOT(setXMag(int)));
 
386
      connect(ctrlEdit, SIGNAL(timeChanged(int)),   SLOT(setTime(int)));
 
387
      connect(ctrlEdit, SIGNAL(destroyedCtrl(CtrlEdit*)), SLOT(removeCtrl(CtrlEdit*)));
 
388
      connect(ctrlEdit, SIGNAL(yposChanged(int)), toolbar, SLOT(setInt(int)));
 
389
 
 
390
//TODO init:     ctrlEdit->setTool(??);
 
391
      ctrlEdit->setXPos(hscroll->pos());
 
392
      ctrlEdit->setXMag(hscroll->getScaleValue());
 
393
 
 
394
      ctrlEdit->show();
 
395
      ctrlEditList.push_back(ctrlEdit);
 
396
      return ctrlEdit;
 
397
      }
 
398
 
 
399
//---------------------------------------------------------
 
400
//   removeCtrl
 
401
//---------------------------------------------------------
 
402
 
 
403
void PianoRoll::removeCtrl(CtrlEdit* ctrl)
 
404
      {
 
405
      for (std::list<CtrlEdit*>::iterator i = ctrlEditList.begin();
 
406
         i != ctrlEditList.end(); ++i) {
 
407
            if (*i == ctrl) {
 
408
                  ctrlEditList.erase(i);
 
409
                  break;
 
410
                  }
 
411
            }
 
412
      }
 
413
 
 
414
//---------------------------------------------------------
 
415
//   closeEvent
 
416
//---------------------------------------------------------
 
417
 
 
418
void PianoRoll::closeEvent(QCloseEvent* e)
 
419
      {
 
420
      emit deleted((int)this);
 
421
      e->accept();
 
422
      }
 
423
 
 
424
//---------------------------------------------------------
 
425
//   readConfiguration
 
426
//---------------------------------------------------------
 
427
 
 
428
void PianoRoll::readConfiguration(Xml& xml)
 
429
      {
 
430
      for (;;) {
 
431
            Xml::Token token = xml.parse();
 
432
            if (token == Xml::Error || token == Xml::End)
 
433
                  break;
 
434
            const QString& tag = xml.s1();
 
435
            switch (token) {
 
436
                  case Xml::TagStart:
 
437
                        if (tag == "quant")
 
438
                              _quantInit = xml.parseInt();
 
439
                        else if (tag == "raster")
 
440
                              _rasterInit = xml.parseInt();
 
441
                        else if (tag == "quantStrength")
 
442
                              _quantStrengthInit = xml.parseInt();
 
443
                        else if (tag == "quantLimit")
 
444
                              _quantLimitInit = xml.parseInt();
 
445
                        else if (tag == "quantLen")
 
446
                              _quantLenInit = xml.parseInt();
 
447
                        else if (tag == "to")
 
448
                              _toInit = xml.parseInt();
 
449
                        else if (tag == "colormode")
 
450
                              colorModeInit = xml.parseInt();
 
451
                        else
 
452
                              xml.unknown("PianoRoll");
 
453
                        break;
 
454
                  case Xml::TagEnd:
 
455
                        if (tag == "pianoroll")
 
456
                              return;
 
457
                  default:
 
458
                        break;
 
459
                  }
 
460
            }
 
461
      }
 
462
 
 
463
//---------------------------------------------------------
 
464
//   writeConfiguration
 
465
//---------------------------------------------------------
 
466
 
 
467
void PianoRoll::writeConfiguration(int level, Xml& xml)
 
468
      {
 
469
      xml.tag(level++, "pianoroll");
 
470
      xml.intTag(level, "quant", _quantInit);
 
471
      xml.intTag(level, "raster", _rasterInit);
 
472
      xml.intTag(level, "quantStrength", _quantStrengthInit);
 
473
      xml.intTag(level, "quantLimit", _quantLimitInit);
 
474
      xml.intTag(level, "quantLen", _quantLenInit);
 
475
      xml.intTag(level, "to", _toInit);
 
476
      xml.intTag(level, "colormode", colorModeInit);
 
477
      xml.etag(level, "pianoroll");
 
478
      }
 
479
 
 
480
void PianoRoll::soloChanged(SoundSource* s)
 
481
      {
 
482
      toolbar->setSolo(s == canvas->track());
 
483
      }
 
484
 
 
485
void PianoRoll::soloChanged(bool flag)
 
486
      {
 
487
      song->setSolo(flag ? canvas->track() : 0);
 
488
      }
 
489
 
 
490
void PianoRoll::setRaster(int val)
 
491
      {
 
492
      _rasterInit = val;
 
493
      MidiEditor::setRaster(val);
 
494
      canvas->setFocus();     // give back focus after kb input
 
495
      }
 
496
void PianoRoll::setQuant(int val)
 
497
      {
 
498
      _quantInit = val;
 
499
      MidiEditor::setQuant(val);
 
500
      canvas->setQuant(val);
 
501
      canvas->setFocus();
 
502
      }
 
503
 
 
504
//---------------------------------------------------------
 
505
//   writeStatus
 
506
//---------------------------------------------------------
 
507
 
 
508
void PianoRoll::writeStatus(int level, Xml& xml) const
 
509
      {
 
510
      writePartList(level, xml);
 
511
      xml.tag(level++, "pianoroll");
 
512
      MidiEditor::writeStatus(level, xml);
 
513
      splitter->writeStatus(level, xml);
 
514
 
 
515
      for (std::list<CtrlEdit*>::const_iterator i = ctrlEditList.begin();
 
516
         i != ctrlEditList.end(); ++i) {
 
517
            (*i)->writeStatus(level, xml);
 
518
            }
 
519
 
 
520
      xml.intTag(level, "steprec", canvas->steprec());
 
521
      xml.intTag(level, "midiin", canvas->midiin());
 
522
      xml.intTag(level, "tool", int(canvas->tool()));
 
523
      xml.intTag(level, "quantStrength", _quantStrength);
 
524
      xml.intTag(level, "quantLimit", _quantLimit);
 
525
      xml.intTag(level, "quantLen", _quantLen);
 
526
      xml.intTag(level, "playEvents", _playEvents);
 
527
      xml.intTag(level, "xpos", hscroll->pos());
 
528
      xml.intTag(level, "xmag", hscroll->mag());
 
529
      xml.intTag(level, "ypos", vscroll->pos());
 
530
      xml.intTag(level, "ymag", vscroll->mag());
 
531
      xml.tag(level, "/pianoroll");
 
532
      }
 
533
 
 
534
//---------------------------------------------------------
 
535
//   readStatus
 
536
//---------------------------------------------------------
 
537
 
 
538
void PianoRoll::readStatus(Xml& xml)
 
539
      {
 
540
      for (;;) {
 
541
            Xml::Token token = xml.parse();
 
542
            if (token == Xml::Error || token == Xml::End)
 
543
                  break;
 
544
            const QString& tag = xml.s1();
 
545
            switch (token) {
 
546
                  case Xml::TagStart:
 
547
                        if (tag == "steprec") {
 
548
                              int val = xml.parseInt();
 
549
                              canvas->setSteprec(val);
 
550
                              srec->setOn(val);
 
551
                              }
 
552
                        else if (tag == "midiin") {
 
553
                              int val = xml.parseInt();
 
554
                              canvas->setMidiin(val);
 
555
                              midiin->setOn(val);
 
556
                              }
 
557
                        else if (tag == "tool") {
 
558
                              int tool = xml.parseInt();
 
559
                              canvas->setTool(tool);
 
560
                              tools2->set(tool);
 
561
                              }
 
562
                        else if (tag == "midieditor")
 
563
                              MidiEditor::readStatus(xml);
 
564
                        else if (tag == "ctrledit") {
 
565
                              CtrlEdit* ctrl = addCtrl();
 
566
                              ctrl->readStatus(xml);
 
567
                              }
 
568
                        else if (tag == splitter->name())
 
569
                              splitter->readStatus(xml);
 
570
                        else if (tag == "quantStrength")
 
571
                              _quantStrength = xml.parseInt();
 
572
                        else if (tag == "quantLimit")
 
573
                              _quantLimit = xml.parseInt();
 
574
                        else if (tag == "quantLen")
 
575
                              _quantLen = xml.parseInt();
 
576
                        else if (tag == "playEvents") {
 
577
                              _playEvents = xml.parseInt();
 
578
                              canvas->playEvents(_playEvents);
 
579
                              speaker->setOn(_playEvents);
 
580
                              }
 
581
                        else if (tag == "xmag")
 
582
                              hscroll->setMag(xml.parseInt());
 
583
                        else if (tag == "xpos")
 
584
                              hscroll->setPos(xml.parseInt());
 
585
                        else if (tag == "ymag")
 
586
                              vscroll->setMag(xml.parseInt());
 
587
                        else if (tag == "ypos")
 
588
                              vscroll->setPos(xml.parseInt());
 
589
                        else
 
590
                              xml.unknown("PianoRoll");
 
591
                        break;
 
592
                  case Xml::TagEnd:
 
593
                        if (tag == "pianoroll") {
 
594
                              _quantInit  = _quant;
 
595
                              _rasterInit = _raster;
 
596
                              toolbar->setRaster(_raster);
 
597
                              toolbar->setQuant(_quant);
 
598
                              canvas->setQuant(_quant);
 
599
                              return;
 
600
                              }
 
601
                  default:
 
602
                        break;
 
603
                  }
 
604
            }
 
605
      }
 
606
 
 
607
static int rasterTable[] = {
 
608
      //-9----8-  7    6     5     4    3(1/4)     2   1
 
609
      4,  8, 16, 32,  64, 128, 256,  512, 1024,  // triple
 
610
      6, 12, 24, 48,  96, 192, 384,  768, 1536,
 
611
      9, 18, 36, 72, 144, 288, 576, 1152, 2304   // dot
 
612
      };
 
613
 
 
614
//---------------------------------------------------------
 
615
//   viewKeyPressEvent
 
616
//---------------------------------------------------------
 
617
 
 
618
void PianoRoll::keyPressEvent(QKeyEvent* event)
 
619
      {
 
620
      if (info->hasFocus()) {
 
621
            event->ignore();
 
622
            return;
 
623
            }
 
624
      bool shift = event->state() & ShiftButton;
 
625
//      bool ctrl  = event->state() & ControlButton;
 
626
 
 
627
      int index = 0;
 
628
      int n = sizeof(rasterTable);
 
629
      for (; index < n; ++index)
 
630
            if (rasterTable[index] == raster())
 
631
                  break;
 
632
      int off = (index / 9) * 9;
 
633
      index   = index % 9;
 
634
 
 
635
      int val;
 
636
 
 
637
      PianoCanvas* pc = (PianoCanvas*)canvas;
 
638
      switch(event->key()) {
 
639
            case Key_Right:
 
640
                  pc->pianoCmd(shift ? CMD_INSERT : CMD_RIGHT);
 
641
                  return;
 
642
            case Key_Left:
 
643
                  pc->pianoCmd(CMD_LEFT);
 
644
                  return;
 
645
            case Key_Insert:
 
646
                  pc->pianoCmd(CMD_INSERT);
 
647
                  return;
 
648
            case Key_Delete:
 
649
                  pc->pianoCmd(CMD_DELETE);
 
650
                  return;
 
651
            case Key_1:
 
652
                  val = rasterTable[8 + off];
 
653
                  break;
 
654
            case Key_2:
 
655
                  val = rasterTable[7 + off];
 
656
                  break;
 
657
            case Key_3:
 
658
                  val = rasterTable[6 + off];
 
659
                  break;
 
660
            case Key_4:
 
661
                  val = rasterTable[5 + off];
 
662
                  break;
 
663
            case Key_5:
 
664
                  val = rasterTable[4 + off];
 
665
                  break;
 
666
            case Key_6:
 
667
                  val = rasterTable[3 + off];
 
668
                  break;
 
669
            case Key_7:
 
670
                  val = rasterTable[2 + off];
 
671
                  break;
 
672
            case Key_T:
 
673
                  val = rasterTable[index + ((off == 0) ? 9 : 0)];
 
674
                  break;
 
675
            case Key_Period:
 
676
                  val = rasterTable[index + ((off == 18) ? 9 : 18)];
 
677
                  break;
 
678
            case Key_Comma: //CDW
 
679
                  if ((off == 18) && (index > 2)) {
 
680
                        val = rasterTable[index + 9 - 1];
 
681
                        break;
 
682
                        }
 
683
                  else if ((off == 9) && (index < 8)) {
 
684
                        val = rasterTable[index + 18 + 1];
 
685
                        break;
 
686
                        }
 
687
                  else
 
688
                        return;
 
689
            default:
 
690
                  event->ignore();
 
691
                  return;
 
692
            }
 
693
      setQuant(val);
 
694
      setRaster(val);
 
695
      toolbar->setQuant(_quant);
 
696
      toolbar->setRaster(_raster);
 
697
      }
 
698
 
 
699
//---------------------------------------------------------
 
700
//   configQuant
 
701
//---------------------------------------------------------
 
702
 
 
703
void PianoRoll::configQuant()
 
704
      {
 
705
      if (!quantConfig) {
 
706
            quantConfig = new QuantConfig(_quantStrength, _quantLimit, _quantLen);
 
707
            connect(quantConfig, SIGNAL(setQuantStrength(int)), SLOT(setQuantStrength(int)));
 
708
            connect(quantConfig, SIGNAL(setQuantLimit(int)), SLOT(setQuantLimit(int)));
 
709
            connect(quantConfig, SIGNAL(setQuantLen(bool)), SLOT(setQuantLen(bool)));
 
710
            }
 
711
      quantConfig->show();
 
712
      }
 
713
 
 
714
//---------------------------------------------------------
 
715
//   setSteprec
 
716
//---------------------------------------------------------
 
717
 
 
718
void PianoRoll::setSteprec(bool flag)
 
719
      {
 
720
      canvas->setSteprec(flag);
 
721
      if (flag == false)
 
722
            midiin->setOn(flag);
 
723
      }
 
724
 
 
725
//---------------------------------------------------------
 
726
//   setEventColorMode
 
727
//---------------------------------------------------------
 
728
 
 
729
void PianoRoll::setEventColorMode(int mode)
 
730
      {
 
731
      colorMode = mode;
 
732
      colorModeInit = colorMode;
 
733
      eventColor->setItemChecked(0, mode == 0);
 
734
      eventColor->setItemChecked(1, mode == 1);
 
735
      eventColor->setItemChecked(2, mode == 2);
 
736
      ((PianoCanvas*)(canvas))->setColorMode(colorMode);
 
737
      }
 
738
 
 
739
//---------------------------------------------------------
 
740
//   clipboardChanged
 
741
//---------------------------------------------------------
 
742
 
 
743
void PianoRoll::clipboardChanged()
 
744
      {
 
745
      QMimeSource* ms = QApplication::clipboard()->data();
 
746
      if (ms && ms->format(0)) {
 
747
            bool flag = strcmp(ms->format(0), "text/eventlist;charset=UTF-8") == 0;
 
748
            menuEdit->setItemEnabled(PianoCanvas::CMD_PASTE, flag);
 
749
            }
 
750
      }
 
751
 
 
752
//---------------------------------------------------------
 
753
//   selectionChanged
 
754
//---------------------------------------------------------
 
755
 
 
756
void PianoRoll::selectionChanged()
 
757
      {
 
758
      bool flag = canvas->selectionSize() > 0;
 
759
      menuEdit->setItemEnabled(PianoCanvas::CMD_CUT, flag);
 
760
      menuEdit->setItemEnabled(PianoCanvas::CMD_COPY, flag);
 
761
      menuEdit->setItemEnabled(PianoCanvas::CMD_DEL, flag);
 
762
      }
 
763
 
 
764
//---------------------------------------------------------
 
765
//   setSpeaker
 
766
//---------------------------------------------------------
 
767
 
 
768
void PianoRoll::setSpeaker(bool val)
 
769
      {
 
770
      _playEvents = val;
 
771
      canvas->playEvents(_playEvents);
 
772
      }
 
773