← Back to branch summary

~ubuntu-branches/ubuntu/breezy/muse/breezy

« back to all changes in this revision

Viewing changes to midiedit/drumedit.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Daniel Kobras
  • Date: 2004-02-07 15:18:22 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20040207151822-es27xxkzbcxkebjm
Tags: 0.6.3-1
http://bugs.debian.org/228788
* New upstream version.
* Added patches:
  + [10_alsa_init_fix] New, from upstream CVS.
    Initialize direction variable when setting Alsa parameters.
  + [10_canvas_translation_fix] New, from upstream CVS.
    Do not translate tooltips twice in canvas popup.
  + [10_checkbox_fix] New, from upstream CVS.
    Use proper set/test methods on metronome checkboxes.
  + [10_html_doc_cleanup] New.
    Fix links and HTML errors in documentation.
  + [20_allow_system_timer] New.
    The new upstream version fails by default if the real-time clock
    could not be accessed (usually the case when not running suid-root).
    This patch reverts the old behaviour of falling back to the more
    inaccurate system timer.
* Updated patches:
  + [11_PIC_fixes_fixup] Rediffed.
* Removed patches:
  + [20_no_atomic_asm] Merged upstream.
* debian/compat: Splice out debhelper compatibility level from rules file.
* debian/control: Build-depend on latest jack release by default.
  Closes: #228788
* debian/control: Bump standards version.
* debian/control: Use auto-generated debconf dependency via misc:Depends.
* debian/control: Minor tweaks to the long description.
* debian/control: Tighten fluidsynth build dependency to sane version.
* debian/muse.doc-base: New. Register HTML documentation with doc-base.
* debian/templates: Tiny rewording, and typo fix.
* debian/templates, debian/po/*: Switch to po-debconf for translations.

Show diffs side-by-side

added added

removed removed

Lines of Context:
midiedit/drumedit.cpp
1
1
//=========================================================
2
2
//  MusE
3
3
//  Linux Music Editor
4
 
//    $Id: drumedit.cpp,v 1.1 2002/01/30 14:10:08 muse Exp $
 
4
//    $Id: drumedit.cpp,v 1.3 2003/11/19 21:28:40 lunar_shuttle Exp $
5
5
//  (C) Copyright 1999 Werner Schweer (ws@seh.de)
6
6
//=========================================================
7
7
 
51
51
      };
52
52
int DrumEdit::_quantInit = 96;
53
53
int DrumEdit::_rasterInit = 96;
 
54
int DrumEdit::_widthInit = 600;
 
55
int DrumEdit::_heightInit = 400;
 
56
int DrumEdit::_dlistWidthInit = 50; 
 
57
int DrumEdit::_dcanvasWidthInit = 300; 
54
58
 
55
59
static const int xscale = -10;
56
60
static const int yscale = 1;
 
61
static const int drumeditTools = PointerTool | PencilTool | RubberTool;
57
62
 
58
63
//---------------------------------------------------------
59
64
//   DWhatsThis::text
63
68
      {
64
69
      int section = header->sectionAt(pos.x());
65
70
      if (section == -1)
66
 
            return 0;
 
71
            return QString::null;
67
72
      switch(section) {
68
 
            case 0: return  header->tr("mute instrument"); break;
69
 
            case 1: return  header->tr("sound name"); break;
70
 
            case 2: return  header->tr("quantisation"
71
 
                  "\ncurrently not used"); break;
72
 
            case 3: return  header->tr("this input note triggers the sound"); break;
73
 
            case 4: return  header->tr("note length"); break;
74
 
            case 5: return  header->tr("this note is send for the sound"); break;
75
 
            case 6: return  header->tr("output channel"
76
 
                  "\ncurrently not used"); break;
77
 
            case 7: return  header->tr("output port"
78
 
                  "\ncurrently not used"); break;
79
 
            case 8: return  header->tr("velocity level 1"); break;
80
 
            case 9: return  header->tr("velocity level 2"); break;
81
 
            case 10: return header->tr("velocity level 3"); break;
82
 
            case 11: return header->tr("velocity level 4"); break;
 
73
            case 0: return  QHeader::tr("mute instrument"); break;
 
74
            case 1: return  QHeader::tr("sound name"); break;
 
75
            case 2: return  QHeader::tr("quantisation"
 
76
                  "\ncurrently not used"); break;
 
77
            case 3: return  QHeader::tr("this input note triggers the sound"); break;
 
78
            case 4: return  QHeader::tr("note length"); break;
 
79
            case 5: return  QHeader::tr("this note is send for the sound"); break;
 
80
            case 6: return  QHeader::tr("output channel"
 
81
                  "\ncurrently not used"); break;
 
82
            case 7: return  QHeader::tr("output port"
 
83
                  "\ncurrently not used"); break;
 
84
            case 8: return  QHeader::tr("velocity level 1"); break;
 
85
            case 9: return  QHeader::tr("velocity level 2"); break;
 
86
            case 10: return QHeader::tr("velocity level 3"); break;
 
87
            case 11: return QHeader::tr("velocity level 4"); break;
83
88
            default: break;
84
89
            }
85
 
      return 0;
 
90
      return QString::null;
86
91
      }
87
92
 
88
93
//---------------------------------------------------------
99
104
         w->height());
100
105
      QString p;
101
106
      switch(section) {
102
 
            case 0:  p = w->tr("mute instrument"); break;
103
 
            case 1:  p = w->tr("sound name"); break;
104
 
            case 2:  p = w->tr("quantisation"); break;
105
 
            case 3:  p = w->tr("this input note triggers the sound"); break;
106
 
            case 4:  p = w->tr("note length"); break;
107
 
            case 5:  p = w->tr("this note is send for the sound"); break;
108
 
            case 6:  p = w->tr("output channel"); break;
109
 
            case 7:  p = w->tr("output port"); break;
110
 
            case 8:  p = w->tr("velocity level 1"); break;
111
 
            case 9:  p = w->tr("velocity level 2"); break;
112
 
            case 10: p = w->tr("velocity level 3"); break;
113
 
            case 11: p = w->tr("velocity level 4"); break;
 
107
            case 0:  p = QHeader::tr("mute instrument"); break;
 
108
            case 1:  p = QHeader::tr("sound name"); break;
 
109
            case 2:  p = QHeader::tr("quantisation"); break;
 
110
            case 3:  p = QHeader::tr("this input note triggers the sound"); break;
 
111
            case 4:  p = QHeader::tr("note length"); break;
 
112
            case 5:  p = QHeader::tr("this note is send for the sound"); break;
 
113
            case 6:  p = QHeader::tr("output channel"); break;
 
114
            case 7:  p = QHeader::tr("output port"); break;
 
115
            case 8:  p = QHeader::tr("velocity level 1"); break;
 
116
            case 9:  p = QHeader::tr("velocity level 2"); break;
 
117
            case 10: p = QHeader::tr("velocity level 3"); break;
 
118
            case 11: p = QHeader::tr("velocity level 4"); break;
114
119
            default: return;
115
120
            }
116
121
      tip(r, p);
122
127
 
123
128
void DrumEdit::closeEvent(QCloseEvent* e)
124
129
      {
 
130
      //Store values of the horizontal splitter 
 
131
      QValueList<int> sizes = split2->sizes(); 
 
132
      QValueList<int>::Iterator it = sizes.begin(); 
 
133
      _dlistWidthInit = *it; //There are only 2 values stored in the sizelist, size of dlist widget and dcanvas widget 
 
134
      it++; 
 
135
      _dcanvasWidthInit = *it; 
125
136
      emit deleted((int)this);
126
137
      e->accept();
127
138
      }
130
141
//   DrumEdit
131
142
//---------------------------------------------------------
132
143
 
133
 
DrumEdit::DrumEdit(PartList* pl, QWidget* parent = 0, const char* name = 0)
 
144
DrumEdit::DrumEdit(PartList* pl, QWidget* parent, const char* name)
134
145
   : MidiEditor(_quantInit, _rasterInit, pl, parent, name)
135
146
      {
 
147
      resize(_widthInit, _heightInit);
136
148
      selEvent = 0;
137
149
      selPart  = 0;
138
150
      //---------Pulldown Menu----------------------------
139
151
      QPopupMenu* menuFile = new QPopupMenu(this);
140
 
      menuBar()->insertItem("&File", menuFile);
 
152
      menuBar()->insertItem(tr("&File"), menuFile);
141
153
 
142
154
      menuFile->insertItem(*openIcon, tr("Load Map"), DrumCanvas::CMD_LOAD);
143
155
      menuFile->setAccel(CTRL+Key_O, DrumCanvas::CMD_LOAD);
146
158
 
147
159
      menuEdit = new QPopupMenu(this);
148
160
      menuBar()->insertItem(tr("&Edit"), menuEdit);
 
161
      undoRedo->addTo(menuEdit);
 
162
      QAccel* qa = new QAccel(this); 
 
163
      qa->connectItem(qa->insertItem(CTRL+Key_Z), song, SLOT(undo()));
 
164
      menuEdit->insertSeparator();
149
165
      menuEdit->insertItem(tr("Cut"),   DrumCanvas::CMD_CUT);
150
166
      menuEdit->setAccel(CTRL+Key_X,    DrumCanvas::CMD_CUT);
151
167
      menuEdit->insertItem(tr("Copy"),  DrumCanvas::CMD_COPY);
154
170
      menuEdit->setAccel(CTRL+Key_V,    DrumCanvas::CMD_PASTE);
155
171
      menuEdit->insertSeparator();
156
172
      menuEdit->insertItem(tr("Delete Events"), DrumCanvas::CMD_DEL);
 
173
      menuEdit->setAccel(Key_Delete, DrumCanvas::CMD_DEL);
157
174
      menuEdit->insertSeparator();
 
175
      menuEdit->insertItem(tr("Set fixed length"), DrumCanvas::CMD_FIXED_LEN); 
 
176
      menuEdit->setAccel(ALT+Key_L,     DrumCanvas::CMD_FIXED_LEN); 
158
177
 
159
178
      QPopupMenu* menuSelect = new QPopupMenu(this);
160
179
      menuSelect->insertItem(tr("Select All"),   DrumCanvas::CMD_SELECT_ALL);
174
193
      //---------------------------------------------------
175
194
 
176
195
      tools = new QToolBar(this, "drum-tools");
177
 
      new QToolButton(*openIcon, "Load Drummap",
178
 
                                            QString::null, this, SLOT(load()),
179
 
                                            tools, "load drummap from file");
 
196
      new QToolButton(*openIcon, tr("Load Drummap"),
 
197
                  QString::null, this, SLOT(load()), 
 
198
                  tools, "load drummap from file"); 
180
199
 
181
 
      new QToolButton(*saveIcon, "Store Drummap",
182
 
                                            QString::null,
183
 
                                            this, SLOT(save()),
184
 
                                            tools, "store drummap to file");
 
200
      new QToolButton(*saveIcon, tr("Store Drummap"),
 
201
                  QString::null, 
 
202
                  this, SLOT(save()), 
 
203
                  tools, "store drummap to file"); 
185
204
 
186
205
      QWhatsThis::whatsThisButton(tools);
187
206
 
199
218
      midiin->setPixmap(*midiinIcon);
200
219
      midiin->setToggleButton(true);
201
220
 
202
 
      EditToolBar* etb = new EditToolBar(this,
203
 
         PointerTool | PencilTool | RubberTool);
 
221
      tools2 = new EditToolBar(this, drumeditTools);
204
222
 
205
 
      new TransportToolbar(this);
 
223
      QToolBar* transport = new QToolBar(this);
 
224
      transportAction->addTo(transport);
206
225
 
207
226
      // dont�t show pitch value in toolbar
208
227
      toolbar = new Toolbar1(this, _rasterInit, _quantInit, false);
213
232
      //---------------------------------------------------
214
233
 
215
234
      split1            = new Splitter(Vertical, mainw, "split1");
216
 
      QPushButton* ctrl = new QPushButton("ctrl", mainw, "Ctrl");
 
235
      QPushButton* ctrl = new QPushButton(tr("ctrl"), mainw, "Ctrl");
 
236
      ctrl->setFont(font3);
217
237
      hscroll           = new ScrollScale(-25, -2, xscale, 20000, Horizontal, mainw);
218
238
      ctrl->setFixedSize(50, hscroll->sizeHint().height());
219
239
      QToolTip::add(ctrl, tr("Add Controller View"));
220
240
 
221
241
      QSizeGrip* corner = new QSizeGrip(mainw);
 
242
      corner->setFixedHeight(hscroll->sizeHint().height());
222
243
 
223
244
      mainGrid->setRowStretch(0, 100);
224
245
      mainGrid->setColStretch(1, 100);
 
246
 
225
247
      mainGrid->addMultiCellWidget(split1, 0, 0, 0, 2);
226
248
      mainGrid->addWidget(ctrl,    1, 0);
227
249
      mainGrid->addWidget(hscroll, 1, 1);
228
250
      mainGrid->addWidget(corner,  1, 2, AlignBottom|AlignRight);
229
 
      mainGrid->addRowSpacing(1, hscroll->sizeHint().height());
 
251
//      mainGrid->addRowSpacing(1, hscroll->sizeHint().height());
230
252
 
231
253
      split2              = new Splitter(Horizontal, split1, "split2");
232
254
      QWidget* split1w1   = new QWidget(split2, "split1w1");
238
260
      vscroll             = new ScrollScale(1, 5, yscale, DRUM_MAPSIZE*TH, Vertical, split1w2);
239
261
      int offset = -(division/4);
240
262
      canvas->setOrigin(offset, 0);
 
263
      canvas->setCanvasTools(drumeditTools);
 
264
      canvas->setFocus();
 
265
      connect(canvas, SIGNAL(toolChanged(int)), tools2, SLOT(set(int)));
 
266
 
241
267
      time->setOrigin(offset, 0);
242
268
      vscroll->showMag(false);
243
269
 
244
270
      QValueList<int> mops;
245
 
      mops.append(50);
246
 
      mops.append(300);
 
271
      mops.append(_dlistWidthInit); 
 
272
      mops.append(_dcanvasWidthInit); 
247
273
      split2->setSizes(mops);
248
274
 
249
275
      gridS2->setRowStretch(1, 100);
276
302
      dlist = new DList(header, split1w1, yscale);
277
303
      connect(dlist, SIGNAL(keyPressed(int, bool)), canvas, SLOT(keyPressed(int, bool)));
278
304
      connect(dlist, SIGNAL(keyReleased(int, bool)), canvas, SLOT(keyReleased(int, bool)));
279
 
      connect(dlist, SIGNAL(mapChanged()), canvas, SLOT(mapChanged()));
 
305
      connect(dlist, SIGNAL(mapChanged(int, int)), canvas, SLOT(mapChanged(int, int)));
 
306
      connect(dlist, SIGNAL(selectionChanged(DrumMap*)), SLOT(dlistSelectionChanged(DrumMap*)));
280
307
 
281
308
      gridS1->setRowStretch(1, 100);
282
309
      gridS1->setColStretch(0, 100);
285
312
 
286
313
      connect(canvas, SIGNAL(newWidth(int)), SLOT(newCanvasWidth(int)));
287
314
      connect(song, SIGNAL(songChanged(int)), SLOT(songChanged(int)));
 
315
      connect(song, SIGNAL(songChanged(int)),      dlist, SLOT(songChanged(int)));
288
316
      connect(vscroll, SIGNAL(scrollChanged(int)), canvas, SLOT(setYPos(int)));
289
317
      connect(hscroll, SIGNAL(scrollChanged(int)), canvas, SLOT(setXPos(int)));
290
318
      connect(hscroll, SIGNAL(scaleChanged(int)),  canvas, SLOT(setXMag(int)));
295
323
      connect(hscroll, SIGNAL(scrollChanged(int)),   time,   SLOT(setXPos(int)));
296
324
      connect(hscroll, SIGNAL(scaleChanged(int)), time,   SLOT(setXMag(int)));
297
325
 
298
 
      connect(etb, SIGNAL(toolChanged(int)), canvas, SLOT(setTool(int)));
299
 
//      connect(etb, SIGNAL(toolChanged(int)), ctrlCanvas, SLOT(setTool(int)));
 
326
      connect(tools2, SIGNAL(toolChanged(int)), canvas, SLOT(setTool(int)));
300
327
 
301
328
      connect(canvas, SIGNAL(selectionChanged(int, Event*, Part*)), this,
302
329
         SLOT(setSelection(int, Event*, Part*)));
375
402
               selEvent->lenTick(),
376
403
               selEvent->pitch(),
377
404
               selEvent->velo(),
378
 
               selEvent->veloOff(),
379
 
               selEvent->channel()+1);
 
405
               selEvent->veloOff());
380
406
            }
381
407
      selectionChanged();
382
408
      }
387
413
 
388
414
void DrumEdit::soloChanged(bool flag)
389
415
      {
390
 
      song->setSolo(flag ? canvas->track() : 0);
391
 
      }
392
 
 
393
 
void DrumEdit::soloChanged(Track* t)
394
 
      {
395
 
      toolbar->setSolo(t == canvas->track());
396
 
      }
397
 
 
 
416
      canvas->track()->node()->setSolo(flag);
 
417
      }
 
418
 
 
419
void DrumEdit::soloChanged(SNode* t)
 
420
      {
 
421
      toolbar->setSolo(t == canvas->track()->node());
 
422
      }
 
423
 
 
424
 
 
425
void DrumEdit::dlistSelectionChanged(DrumMap* dm)
 
426
      {
 
427
      QString name = dm->name;
 
428
      }
398
429
//---------------------------------------------------------
399
430
//   setRaster
400
431
//---------------------------------------------------------
429
460
      MidiEvent* event = new MidiEvent(*selEvent);
430
461
      switch(type) {
431
462
            case NoteInfo::VAL_TIME:
 
463
                  event->setPosTick(val - selPart->posTick());
432
464
                  break;
433
465
            case NoteInfo::VAL_LEN:
434
466
                  event->setLenTick(val);
439
471
            case NoteInfo::VAL_VELOFF:
440
472
                  event->setVeloOff(val);
441
473
                  break;
442
 
            case NoteInfo::VAL_CHANNEL:
443
 
//                  event->setChannel(val-1);
444
 
                  break;
445
474
            case NoteInfo::VAL_PITCH:
446
475
                  event->setPitch(val);
447
476
                  break;
501
530
                              canvas->setMidiin(val);
502
531
                              midiin->setOn(val);
503
532
                              }
504
 
                        else if (tag == "ctrledit") {
505
 
                              CtrlEdit* ctrl = addCtrl();
506
 
                              ctrl->readStatus(xml);
507
 
                              }
508
533
                        else if (tag == split1->name())
509
534
                              split1->readStatus(xml);
510
535
                        else if (tag == split2->name())
515
540
                              header->readStatus(xml);
516
541
                        else if (tag == "xmag")
517
542
                              hscroll->setMag(xml.parseInt());
 
543
                        else if (tag == "ctrledit") {
 
544
                              CtrlEdit* ctrl = addCtrl();
 
545
                              ctrl->readStatus(xml);
 
546
                              }
518
547
                        else if (tag == "xpos")
519
548
                              hscroll->setPos(xml.parseInt());
520
549
                        else if (tag == "ymag")
557
586
                              _quantInit = xml.parseInt();
558
587
                        else if (tag == "raster")
559
588
                              _rasterInit = xml.parseInt();
 
589
                        else if (tag == "width")
 
590
                              _widthInit = xml.parseInt();
 
591
                        else if (tag == "height")
 
592
                              _heightInit = xml.parseInt();
 
593
                        else if (tag == "dcanvaswidth") 
 
594
                              _dcanvasWidthInit = xml.parseInt(); 
 
595
                        else if (tag == "dlistwidth") 
 
596
                              _dlistWidthInit = xml.parseInt(); 
560
597
                        else
561
598
                              xml.unknown("DrumEdit");
562
599
                        break;
579
616
      xml.tag(level++, "drumedit");
580
617
      xml.intTag(level, "quant", _quantInit);
581
618
      xml.intTag(level, "raster", _rasterInit);
 
619
      xml.intTag(level, "width", _widthInit);
 
620
      xml.intTag(level, "height", _heightInit);
 
621
      xml.intTag(level, "dlistwidth", _dlistWidthInit); 
 
622
      xml.intTag(level, "dcanvaswidth", _dcanvasWidthInit);
582
623
      xml.tag(level, "/drumedit");
583
624
      }
584
625
 
588
629
 
589
630
void DrumEdit::load()
590
631
      {
591
 
      QString fn = getOpenFileName("drummaps", map_file_pattern,
592
 
         this, "Muse: Load Drum Map");
 
632
      QString fn = getOpenFileName(tr("drummaps"), map_file_pattern,
 
633
         this, tr("Muse: Load Drum Map"));
593
634
      if (fn.isEmpty())
594
635
            return;
595
636
      bool popenFlag;
596
 
      FILE* f = fileOpen(this, fn, ".map", "r", popenFlag, true);
 
637
      FILE* f = fileOpen(this, fn, QString(".map"), "r", popenFlag, true);
597
638
      if (f == 0)
598
639
            return;
599
640
 
640
681
 
641
682
void DrumEdit::save()
642
683
      {
643
 
      QString fn = getSaveFileName("drummaps", map_file_pattern,
644
 
        this, "MusE: Store Drum Map");
 
684
      QString fn = getSaveFileName(QString("drummaps"), map_file_pattern,
 
685
        this, tr("MusE: Store Drum Map"));
645
686
      if (fn.isEmpty())
646
687
            return;
647
688
      bool popenFlag;
648
 
      FILE* f = fileOpen(this, fn, ".map", "w", popenFlag, false, true);
 
689
      FILE* f = fileOpen(this, fn, QString(".map"), "w", popenFlag, false, true);
649
690
      if (f == 0)
650
691
            return;
651
692
      Xml xml(f);
686
727
 
687
728
void DrumEdit::clipboardChanged()
688
729
      {
689
 
      QMimeSource* ms = QApplication::clipboard()->data();
 
730
      QMimeSource* ms = QApplication::clipboard()->data(QClipboard::Clipboard);
690
731
      if (ms && ms->format(0)) {
691
732
            bool flag = strcmp(ms->format(0), "text/eventlist;charset=UTF-8") == 0;
692
733
            menuEdit->setItemEnabled(DrumCanvas::CMD_PASTE, flag);
717
758
      connect(ctrlEdit, SIGNAL(timeChanged(int)),   SLOT(setTime(int)));
718
759
      connect(ctrlEdit, SIGNAL(destroyedCtrl(CtrlEdit*)), SLOT(removeCtrl(CtrlEdit*)));
719
760
      connect(ctrlEdit, SIGNAL(yposChanged(int)), toolbar, SLOT(setInt(int)));
 
761
      connect(tools2,   SIGNAL(toolChanged(int)),   ctrlEdit, SLOT(setTool(int)));
 
762
      connect(dlist, SIGNAL(keyFilterChanged(const char )), ctrlEdit, SLOT(setKeyfilter(const char )));
 
763
 
 
764
      int curSelectedInstrument = dlist->getSelectedInstrument();
 
765
      if (curSelectedInstrument != -1)
 
766
            ctrlEdit->setKeyfilter((char)curSelectedInstrument);
720
767
 
721
768
      ctrlEdit->setXPos(hscroll->pos());
722
769
      ctrlEdit->setXMag(hscroll->getScaleValue());
755
802
            }
756
803
      }
757
804
 
 
805
//---------------------------------------------------------
 
806
//   resizeEvent
 
807
//---------------------------------------------------------
 
808
 
 
809
void DrumEdit::resizeEvent(QResizeEvent* ev)
 
810
      {
 
811
      QWidget::resizeEvent(ev);
 
812
      _widthInit = ev->size().width();
 
813
      _heightInit = ev->size().height();
 
814
 
 
815
      //TODO: Make the dlist not expand/shrink, but the canvas instead 
 
816
      }
 
817
 
 
818