summaryrefslogtreecommitdiff
path: root/attic/muse2-oom/muse2/muse/miditransform.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'attic/muse2-oom/muse2/muse/miditransform.cpp')
-rw-r--r--attic/muse2-oom/muse2/muse/miditransform.cpp1743
1 files changed, 0 insertions, 1743 deletions
diff --git a/attic/muse2-oom/muse2/muse/miditransform.cpp b/attic/muse2-oom/muse2/muse/miditransform.cpp
deleted file mode 100644
index 1c73b7c2..00000000
--- a/attic/muse2-oom/muse2/muse/miditransform.cpp
+++ /dev/null
@@ -1,1743 +0,0 @@
-//=========================================================
-// MusE
-// Linux Music Editor
-// $Id: miditransform.cpp,v 1.8.2.3 2009/05/24 21:43:44 terminator356 Exp $
-//
-// (C) Copyright 2001 Werner Schweer (ws@seh.de)
-//=========================================================
-
-#include <stdio.h>
-#include <list>
-
-
-#include <QDialog>
-#include <QListWidgetItem>
-
-#include "helper.h"
-#include "spinboxFP.h"
-#include "event.h"
-#include "miditransform.h"
-#include "track.h"
-#include "song.h"
-#include "xml.h"
-#include "globals.h"
-#include "comboQuant.h"
-//#include "pitchedit.h"
-#include "audio.h"
-#include "gconfig.h"
-#include "midictrl.h"
-
-//
-// Order of events:
-// Note, Poly Pressure, Control, AfterTouch, Pitch Bend, NRPN, RPN
-//
-#define MIDITRANSFORM_NOTE 0
-#define MIDITRANSFORM_POLY 1
-#define MIDITRANSFORM_CTRL 2
-#define MIDITRANSFORM_ATOUCH 3
-#define MIDITRANSFORM_PITCHBEND 4
-#define MIDITRANSFORM_NRPN 5
-#define MIDITRANSFORM_RPN 6
-
-
-static int eventTypeTable[] = {
- MIDITRANSFORM_NOTE, MIDITRANSFORM_POLY, MIDITRANSFORM_CTRL, MIDITRANSFORM_ATOUCH,
- MIDITRANSFORM_PITCHBEND, MIDITRANSFORM_NRPN, MIDITRANSFORM_RPN
- };
-
-static int procVal2Map[] = { 0, 1, 2, 3, 4, 5, 6, 7, 10, 11 };
-
-//---------------------------------------------------------
-// MidiTransformation
-//---------------------------------------------------------
-
-class MidiTransformation {
- public:
- QString name;
- QString comment;
-
- ValOp selEventOp;
- EventType selType;
-
- ValOp selVal1;
- int selVal1a, selVal1b;
- ValOp selVal2;
- int selVal2a, selVal2b;
- ValOp selLen;
- int selLenA, selLenB;
- ValOp selRange;
- int selRangeA, selRangeB;
-
- TransformOperator procEvent;
- EventType eventType;
- TransformOperator procVal1;
- int procVal1a, procVal1b;
- TransformOperator procVal2;
- int procVal2a, procVal2b;
- TransformOperator procLen;
- int procLenA;
- TransformOperator procPos;
- int procPosA;
-
- TransformFunction funcOp;
- int quantVal;
- bool selectedTracks;
- bool insideLoop;
-
- MidiTransformation(const QString& s) {
- name = s;
- selEventOp = All;
- selType = Note;
- selVal1 = Ignore;
- selVal1a = 0;
- selVal1b = 0;
- selVal2 = Ignore;
- selVal2a = 0;
- selVal2b = 0;
- selLen = Ignore;
- selLenA = 0;
- selLenB = 0;
- selRange = Ignore;
- selRangeA = 0;
- selRangeB = 0;
- procEvent = Keep;
- eventType = Note;
- procVal1 = Keep;
- procVal1a = 0;
- procVal1b = 0;
- procVal2 = Keep;
- procVal2a = 0;
- procVal2b = 0;
- procLen = Keep;
- procLenA = 0;
- procPos = Keep;
- procPosA = 0;
- funcOp = Select;
- quantVal = config.division;
- selectedTracks = false;
- insideLoop = false;
- }
- void write(int level, Xml& xml);
- };
-
-class MidiTransformPrivate {
- public:
- MidiTransformation* cmt;
- int cindex; // current index in preset list
- };
-
-typedef std::list<MidiTransformation* > MidiTransformationList;
-typedef std::list<MidiTransformation* >::iterator iMidiTransformation;
-typedef std::list<MidiTransformation* >::const_iterator ciMidiTransformation;
-
-static MidiTransformationList mtlist;
-
-//---------------------------------------------------------
-// MidiTransformDialog
-// Widgets:
-// presetList nameEntry commentEntry
-// selEventOp selType
-// selVal1Op selVal1a selVal1b
-// selVal2Op selVal2a selVal2b
-// selLenOp selLenA selLenB
-// selRangeOp selBarA selBarB
-//
-// procEventOp procType
-// procVal1Op procVal1a procVal1b
-// procVal2Op procVal2a procVal2b
-// procLenOp procLenA
-// procPosOp procPosA
-// funcOp funcQuantVal
-// processAll selectedTracks insideLoop
-// buttonNew buttonDelete buttonApply buttonOk
-//---------------------------------------------------------
-
-MidiTransformerDialog::MidiTransformerDialog(QDialog* parent, Qt::WFlags fl)
- : QDialog(parent, fl)
- {
- setupUi(this);
- data = new MidiTransformPrivate;
- data->cmt = 0;
- data->cindex = -1;
- connect(buttonApply, SIGNAL(clicked()), SLOT(apply()));
- connect(buttonNew, SIGNAL(clicked()), SLOT(presetNew()));
- connect(buttonDelete, SIGNAL(clicked()), SLOT(presetDelete()));
- connect(selEventOp, SIGNAL(activated(int)), SLOT(selEventOpSel(int)));
- connect(selType, SIGNAL(activated(int)), SLOT(selTypeSel(int)));
- connect(selVal1Op, SIGNAL(activated(int)), SLOT(selVal1OpSel(int)));
- connect(selVal2Op, SIGNAL(activated(int)), SLOT(selVal2OpSel(int)));
- connect(selLenOp, SIGNAL(activated(int)), SLOT(selLenOpSel(int)));
- connect(selRangeOp, SIGNAL(activated(int)), SLOT(selRangeOpSel(int)));
- connect(procEventOp, SIGNAL(activated(int)), SLOT(procEventOpSel(int)));
- connect(procType, SIGNAL(activated(int)), SLOT(procEventTypeSel(int)));
- connect(procVal1Op, SIGNAL(activated(int)), SLOT(procVal1OpSel(int)));
- connect(procVal2Op, SIGNAL(activated(int)), SLOT(procVal2OpSel(int)));
- connect(procLenOp, SIGNAL(activated(int)), SLOT(procLenOpSel(int)));
- connect(procPosOp, SIGNAL(activated(int)), SLOT(procPosOpSel(int)));
- connect(funcOp, SIGNAL(activated(int)), SLOT(funcOpSel(int)));
- connect(funcQuantVal, SIGNAL(valueChanged(int)), SLOT(funcQuantValSel(int)));
- connect(presetList, SIGNAL(itemClicked(QListWidgetItem*)),
- SLOT(presetChanged(QListWidgetItem*)));
- connect(nameEntry, SIGNAL(textChanged(const QString&)),
- SLOT(nameChanged(const QString&)));
- connect(commentEntry, SIGNAL(textChanged()), SLOT(commentChanged()));
-
- connect(selVal1a, SIGNAL(valueChanged(int)), SLOT(selVal1aChanged(int)));
- connect(selVal1b, SIGNAL(valueChanged(int)), SLOT(selVal1bChanged(int)));
- connect(selVal2a, SIGNAL(valueChanged(int)), SLOT(selVal2aChanged(int)));
- connect(selVal2b, SIGNAL(valueChanged(int)), SLOT(selVal2bChanged(int)));
- connect(selLenA, SIGNAL(valueChanged(int)), SLOT(selLenAChanged(int)));
- connect(selLenB, SIGNAL(valueChanged(int)), SLOT(selLenBChanged(int)));
- connect(selBarA, SIGNAL(valueChanged(int)), SLOT(selBarAChanged(int)));
- connect(selBarB, SIGNAL(valueChanged(int)), SLOT(selBarBChanged(int)));
- connect(procVal1a, SIGNAL(valueChanged(int)), SLOT(procVal1aChanged(int)));
- connect(procVal1b, SIGNAL(valueChanged(int)), SLOT(procVal1bChanged(int)));
- connect(procVal2a, SIGNAL(valueChanged(int)), SLOT(procVal2aChanged(int)));
- connect(procVal2b, SIGNAL(valueChanged(int)), SLOT(procVal2bChanged(int)));
- connect(procLenA, SIGNAL(valueChanged(int)), SLOT(procLenAChanged(int)));
- connect(procPosA, SIGNAL(valueChanged(int)), SLOT(procPosAChanged(int)));
-
- connect(processAll, SIGNAL(toggled(bool)), SLOT(processAllChanged(bool)));
- connect(selectedTracks, SIGNAL(toggled(bool)), SLOT(selectedTracksChanged(bool)));
- connect(insideLoop, SIGNAL(toggled(bool)), SLOT(insideLoopChanged(bool)));
-
- //---------------------------------------------------
- // populate preset list
- //---------------------------------------------------
-
- updatePresetList();
- connect(song, SIGNAL(songChanged(int)), SLOT(songChanged(int)));
- }
-
-//---------------------------------------------------------
-// ~MidiTransformDialog
-//---------------------------------------------------------
-
-MidiTransformerDialog::~MidiTransformerDialog()
- {
- delete data;
- }
-
-//---------------------------------------------------------
-// songChanged
-//---------------------------------------------------------
-
-void MidiTransformerDialog::songChanged(int flags)
-{
- // Whenever a song is loaded, flags is -1. Since transforms are part of configuration,
- // use SC_CONFIG here, to filter unwanted song change events.
- if(flags & SC_CONFIG)
- updatePresetList();
-}
-
-//---------------------------------------------------------
-// updatePresetList
-//---------------------------------------------------------
-
-void MidiTransformerDialog::updatePresetList()
-{
- data->cmt = 0;
- data->cindex = 0;
- presetList->clear();
- for (iMidiTransformation i = mtlist.begin(); i != mtlist.end(); ++i) {
- presetList->addItem((*i)->name);
- if (data->cmt == 0)
- data->cmt = *i;
- }
- if (data->cmt == 0) {
- data->cmt = new MidiTransformation(tr("New"));
- mtlist.push_back(data->cmt);
- presetList->addItem(tr("New"));
- presetList->setCurrentItem(0);
- }
-
- //data->cindex = 0;
- //presetList->setCurrentItem(0);
-
-}
-
-//---------------------------------------------------------
-// writeMidiTransforms
-//---------------------------------------------------------
-
-void writeMidiTransforms(int level, Xml& xml)
- {
- for (iMidiTransformation i = mtlist.begin(); i != mtlist.end(); ++i) {
- (*i)->write(level, xml);
- }
- }
-
-//---------------------------------------------------------
-// write
-//---------------------------------------------------------
-
-void MidiTransformation::write(int level, Xml& xml)
- {
- xml.tag(level++, "midiTransform");
- xml.strTag(level, "name", name);
- xml.strTag(level, "comment", comment);
- xml.intTag(level, "function", int(funcOp));
- xml.intTag(level, "selectedTracks", selectedTracks);
- xml.intTag(level, "insideLoop", insideLoop);
- if (funcOp == Quantize) {
- xml.intTag(level, "quantVal", quantVal);
- }
- if (funcOp == Transform || funcOp == Insert) {
- if (procEvent != Keep) {
- xml.intTag(level, "procEventOp", int(procEvent));
- xml.intTag(level, "eventType", int(eventType));
- }
- if (procVal1 != Keep) {
- xml.intTag(level, "procVal1Op", int(procVal1));
- xml.intTag(level, "procVal1a", procVal1a);
- xml.intTag(level, "procVal1b", procVal1b);
- }
- if (procVal2 != Keep) {
- xml.intTag(level, "procVal2Op", int(procVal2));
- xml.intTag(level, "procVal2a", procVal2a);
- xml.intTag(level, "procVal2b", procVal2b);
- }
- if (procLen != Keep) {
- xml.intTag(level, "procLenOp", int(procLen));
- xml.intTag(level, "procLen", procLenA);
- }
- if (procPos != Keep) {
- xml.intTag(level, "procPosOp", int(procPos));
- xml.intTag(level, "procPos", procPosA);
- }
- }
- if (selEventOp != Ignore) {
- xml.intTag(level, "selEventOp", int(selEventOp));
- xml.intTag(level, "selEventType", int(selType));
- }
- if (selVal1 != Ignore) {
- xml.intTag(level, "selVal1Op", int(selVal1));
- xml.intTag(level, "selVal1a", selVal1a);
- xml.intTag(level, "selVal1b", selVal1b);
- }
- if (selVal2 != Ignore) {
- xml.intTag(level, "selVal2Op", int(selVal2));
- xml.intTag(level, "selVal2a", selVal2a);
- xml.intTag(level, "selVal2b", selVal2b);
- }
- if (selLen != Ignore) {
- xml.intTag(level, "selLenOp", int(selLen));
- xml.intTag(level, "selLenA", selLenA);
- xml.intTag(level, "selLenB", selLenB);
- }
- if (selRange != Ignore) {
- xml.intTag(level, "selRangeOp", int(selRange));
- xml.intTag(level, "selRangeA", selRangeA);
- xml.intTag(level, "selRangeB", selRangeB);
- }
- xml.etag(level, "midiTransform");
- }
-
-//---------------------------------------------------------
-// readMidiTransform
-//---------------------------------------------------------
-
-void readMidiTransform(Xml& xml)
- {
- MidiTransformation trans(QWidget::tr("new"));
-
- for (;;) {
- Xml::Token token = xml.parse();
- const QString& tag = xml.s1();
- switch (token) {
- case Xml::Error:
- case Xml::End:
- return;
- case Xml::TagStart:
- if (tag == "name")
- trans.name = xml.parse1();
- else if (tag == "comment")
- trans.comment = xml.parse1();
- else if (tag == "function")
- trans.funcOp = TransformFunction(xml.parseInt());
- else if (tag == "selectedTracks")
- trans.selectedTracks = xml.parseInt();
- else if (tag == "insideLoop")
- trans.insideLoop = xml.parseInt();
- else if (tag == "quantVal")
- trans.quantVal = xml.parseInt();
- else if (tag == "procEventOp")
- trans.procEvent = TransformOperator(xml.parseInt());
- else if (tag == "eventType")
- trans.eventType = EventType(xml.parseInt());
- else if (tag == "procVal1Op")
- trans.procVal1 = TransformOperator(xml.parseInt());
- else if (tag == "procVal1a")
- trans.procVal1a = xml.parseInt();
- else if (tag == "procVal1b")
- trans.procVal1b = xml.parseInt();
- else if (tag == "procVal2Op")
- trans.procVal2 = TransformOperator(xml.parseInt());
- else if (tag == "procVal2a")
- trans.procVal2a = xml.parseInt();
- else if (tag == "procVal2b")
- trans.procVal2b = xml.parseInt();
- else if (tag == "procLenOp")
- trans.procLen = TransformOperator(xml.parseInt());
- else if (tag == "procLen")
- trans.procLenA = xml.parseInt();
- else if (tag == "procPosOp")
- trans.procPos = TransformOperator(xml.parseInt());
- else if (tag == "procPos")
- trans.procPosA = xml.parseInt();
- else if (tag == "selEventOp")
- trans.selEventOp = ValOp(xml.parseInt());
- else if (tag == "selEventType")
- trans.selType = EventType(xml.parseInt());
- else if (tag == "selVal1Op")
- trans.selVal1 = ValOp(xml.parseInt());
- else if (tag == "selVal1a")
- trans.selVal1a = xml.parseInt();
- else if (tag == "selVal1b")
- trans.selVal1b = xml.parseInt();
- else if (tag == "selVal2Op")
- trans.selVal2 = ValOp(xml.parseInt());
- else if (tag == "selVal2a")
- trans.selVal2a = xml.parseInt();
- else if (tag == "selVal2b")
- trans.selVal2b = xml.parseInt();
- else if (tag == "selLenOp")
- trans.selLen = ValOp(xml.parseInt());
- else if (tag == "selLenA")
- trans.selLenA = xml.parseInt();
- else if (tag == "selLenB")
- trans.selLenB = xml.parseInt();
- else if (tag == "selRangeOp")
- trans.selRange = ValOp(xml.parseInt());
- else if (tag == "selRangeA")
- trans.selRangeA = xml.parseInt();
- else if (tag == "selRangeB")
- trans.selRangeB = xml.parseInt();
- else
- xml.unknown("midiTransform");
- break;
- case Xml::TagEnd:
- if (xml.s1() == "midiTransform") {
- // By T356. A previous bug caused some .med files to grow very large
- // with duplicate transforms. Here we can eliminate those duplicates.
- for(iMidiTransformation i = mtlist.begin(); i != mtlist.end(); ++i)
- {
- if((*i)->name == trans.name)
- return;
- }
-
- MidiTransformation* t = new MidiTransformation(trans);
- mtlist.push_back(t);
- return;
- }
- default:
- break;
- }
- }
- }
-
-//---------------------------------------------------------
-// clearMidiTransforms
-//---------------------------------------------------------
-
-void clearMidiTransforms()
-{
- for (iMidiTransformation i = mtlist.begin(); i != mtlist.end(); ++i)
- {
- MidiTransformation* t = *i;
- if(t)
- delete t;
- }
- mtlist.clear();
-}
-
-//---------------------------------------------------------
-// accept
-//---------------------------------------------------------
-
-void MidiTransformerDialog::accept()
- {
- apply();
- reject();
- }
-
-//---------------------------------------------------------
-// transformEvent
-// subfunction of processEvent()
-//---------------------------------------------------------
-
-void MidiTransformerDialog::transformEvent(Event& event, MidiPart* part,
- MidiPart* newPart)
- {
- MidiTransformation* cmt = data->cmt;
- Event newEvent = event.clone();
-
- if (cmt->procEvent != Keep)
- newEvent.setType(cmt->eventType);
-
- //---------------------------------------------------
- // transform value A
- //---------------------------------------------------
-
- int val = newEvent.dataA();
- switch (cmt->procVal1) {
- case Keep:
- break;
- case Plus:
- val += cmt->procVal1a;
- break;
- case Minus:
- val -= cmt->procVal1a;
- break;
- case Multiply:
- val = int(val * (cmt->procVal1a/100.0) + .5);
- break;
- case Divide:
- val = int(val / (cmt->procVal1a/100.0) + .5);
- break;
- case Fix:
- val = cmt->procVal1a;
- break;
- case Value:
- val = cmt->procVal2a;
- break;
- case Invert:
- val = 128 - val;
- break;
- case ScaleMap:
- printf("scale map not implemented\n");
- break;
- case Flip:
- val = cmt->procVal1a - val;
- break;
- case Dynamic: // "crescendo"
- val = (((cmt->procVal2b-cmt->procVal2a)
- * (newEvent.tick() - song->lpos()))
- / (song->rpos() - song->lpos())) + cmt->procVal2a;
- break;
- case Random:
- {
- int range = cmt->procVal1b - cmt->procVal1a;
- if (range > 0)
- val = (rand() % range) + cmt->procVal1a;
- else if (range < 0)
- val = (rand() % -range) + cmt->procVal1b;
- else
- val = cmt->procVal1a;
- }
- break;
- }
- if (val < 0)
- val = 0;
- if (val > 127)
- val = 127;
- newEvent.setA(val);
-
- //---------------------------------------------------
- // transform value B
- //---------------------------------------------------
-
- val = newEvent.dataB();
- switch (cmt->procVal2) {
- case Plus:
- val += cmt->procVal2a;
- break;
- case Minus:
- val -= cmt->procVal2a;
- break;
- case Multiply:
- val = int(val * (cmt->procVal2a/100.0) + .5);
- break;
- case Divide:
- val = int(val / (cmt->procVal2a/100.0) + .5);
- break;
- case Fix:
- val = cmt->procVal2a;
- break;
- case Value:
- val = cmt->procVal1a;
- break;
- case Invert:
- val = 128 - val;
- break;
- case Dynamic:
- val = (((cmt->procVal2b-cmt->procVal2a)
- * (newEvent.tick() - song->lpos()))
- / (song->rpos() - song->lpos())) + cmt->procVal2a;
- break;
- case Random:
- {
- int range = cmt->procVal2b - cmt->procVal2a;
- if (range > 0)
- val = (rand() % range) + cmt->procVal2a;
- else if (range < 0)
- val = (rand() % -range) + cmt->procVal2b;
- else
- val = cmt->procVal1a;
- }
- break;
- case ScaleMap:
- case Keep:
- case Flip:
- break;
- }
- if (val < 0)
- val = 0;
- if (val > 127)
- val = 127;
- newEvent.setB(val);
-
- //---------------------------------------------------
- // transform len
- //---------------------------------------------------
-
- int len = newEvent.lenTick();
- switch (cmt->procLen) {
- case Plus:
- len += cmt->procLenA;
- break;
- case Minus:
- len -= cmt->procLenA;
- break;
- case Multiply:
- len = int(val * (cmt->procLenA/100.0) + .5);
- break;
- case Divide:
- len = int(val / (cmt->procLenA/100.0) + .5);
- break;
- case Fix:
- len = cmt->procLenA;
- break;
- case Invert:
- case ScaleMap:
- case Dynamic:
- case Random:
- case Keep:
- case Flip:
- case Value:
- break;
- }
- if (len < 0)
- len = 0;
- newEvent.setLenTick(len);
-
- //---------------------------------------------------
- // transform pos
- //---------------------------------------------------
-
- int pos = newEvent.tick();
- switch (cmt->procPos) {
- case Plus:
- pos += cmt->procPosA;
- break;
- case Minus:
- pos -= cmt->procPosA;
- break;
- case Multiply:
- pos = int(val * (cmt->procPosA/100.0) + .5);
- break;
- case Divide:
- pos = int(val / (cmt->procPosA/100.0) + .5);
- break;
- case Fix:
- case Invert:
- case ScaleMap:
- case Dynamic:
- case Random:
- case Keep:
- case Flip:
- case Value:
- break;
- }
- if (pos < 0)
- pos = 0;
- newEvent.setTick(pos);
-
- Event dummy;
- switch(data->cmt->funcOp) {
- case Transform:
- // Indicate do clone parts.
- removePortCtrlEvents(event, part, true);
- song->changeEvent(event, newEvent, part);
- // Indicate do clone parts.
- addPortCtrlEvents(newEvent, part, true);
- // Indicate do port controller values and clone parts.
- //song->undoOp(UndoOp::ModifyEvent, newEvent, event, part);
- song->undoOp(UndoOp::ModifyEvent, newEvent, event, part, true, true);
- song->addUpdateFlags(SC_EVENT_MODIFIED);
- break;
- case Insert:
- // Indicate do port controller values and clone parts.
- //song->undoOp(UndoOp::AddEvent, dummy, newEvent, part);
- song->undoOp(UndoOp::AddEvent, dummy, newEvent, part, true, true);
- song->addEvent(newEvent, part);
- // Indicate do clone parts.
- addPortCtrlEvents(newEvent, part, true);
- song->addUpdateFlags(SC_EVENT_INSERTED);
- break;
- case Extract:
- // Indicate do port controller values and clone parts.
- //song->undoOp(UndoOp::DeleteEvent, dummy, event, part);
- song->undoOp(UndoOp::DeleteEvent, dummy, event, part, true, true);
- // Indicate do clone parts.
- removePortCtrlEvents(event, part, true);
- song->deleteEvent(event, part);
- song->addUpdateFlags(SC_EVENT_REMOVED);
- case Copy:
- newPart->addEvent(newEvent);
- break;
- default:
- break;
- }
- }
-
-//---------------------------------------------------------
-// processEvent
-//---------------------------------------------------------
-
-void MidiTransformerDialog::processEvent(Event& event, MidiPart* part, MidiPart* newPart)
- {
- switch(data->cmt->funcOp) {
- case Select:
- break;
- case Quantize:
- {
- int tick = event.tick();
- int rt = AL::sigmap.raster(tick, data->cmt->quantVal) - tick;
- if (tick != rt) {
- // Indicate do clone parts.
- removePortCtrlEvents(event, part, true);
- Event newEvent = event.clone();
- newEvent.setTick(rt);
- song->changeEvent(event, newEvent, part);
- // Indicate do clone parts.
- addPortCtrlEvents(newEvent, part, true);
- // Indicate do port controller values and clone parts.
- //song->undoOp(UndoOp::ModifyEvent, newEvent, event, part);
- song->undoOp(UndoOp::ModifyEvent, newEvent, event, part, true, true);
- song->addUpdateFlags(SC_EVENT_MODIFIED);
- }
- }
- break;
- case Delete:
- {
- Event ev;
- // Indicate do port controller values and clone parts.
- //song->undoOp(UndoOp::DeleteEvent, ev, event, part, true, true);
- song->undoOp(UndoOp::DeleteEvent, ev, event, part, true, true);
- // Indicate do clone parts.
- removePortCtrlEvents(event, part, true);
- song->deleteEvent(event, part);
- song->addUpdateFlags(SC_EVENT_REMOVED);
- }
- break;
- case Transform:
- case Insert:
- case Copy:
- case Extract:
- transformEvent(event, part, newPart);
- break;
- }
- }
-
-//---------------------------------------------------------
-// isSelected
-// apply Select filter
-// return true if event is selected
-//---------------------------------------------------------
-
-bool MidiTransformerDialog::isSelected(Event& event, MidiPart*)
- {
- MidiTransformation* cmt = data->cmt;
-
- switch (cmt->selEventOp) {
- case Equal:
- if (!typesMatch(event, cmt->selType)) {
- return false;
- }
- break;
- case Unequal:
- if (typesMatch(event, cmt->selType))
- return false;
- break;
- default:
- break;
- }
- switch (cmt->selVal1) {
- case Ignore:
- break;
- case Equal:
- if (event.dataA() != cmt->selVal1a)
- return false;
- break;
- case Unequal:
- if (event.dataA() == cmt->selVal1a)
- return false;
- break;
- case Higher:
- if (event.dataA() <= cmt->selVal1a)
- return false;
- break;
- case Lower:
- if (event.dataA() >= cmt->selVal1a)
- return false;
- break;
- case Inside:
- if ((event.dataA() < cmt->selVal1a)
- || (event.dataA() >= cmt->selVal1b))
- return false;
- break;
- case Outside:
- if ((event.dataA() >= cmt->selVal1a)
- && (event.dataA() < cmt->selVal1b))
- return false;
- break;
- }
- switch (cmt->selVal2) {
- case Ignore:
- break;
- case Equal:
- if (event.dataB() != cmt->selVal2a)
- return false;
- break;
- case Unequal:
- if (event.dataB() == cmt->selVal2a)
- return false;
- break;
- case Higher:
- if (event.dataB() <= cmt->selVal2a)
- return false;
- break;
- case Lower:
- if (event.dataB() >= cmt->selVal2a)
- return false;
- break;
- case Inside:
- if ((event.dataB() < cmt->selVal2a)
- || (event.dataB() >= cmt->selVal2b))
- return false;
- break;
- case Outside:
- if ((event.dataB() >= cmt->selVal2a)
- && (event.dataB() < cmt->selVal2b))
- return false;
- break;
- }
- int len = event.lenTick();
- switch (cmt->selLen) {
- case Ignore:
- break;
- case Equal:
- if (len != cmt->selLenA)
- return false;
- break;
- case Unequal:
- if (len == cmt->selLenA)
- return false;
- break;
- case Higher:
- if (len <= cmt->selLenA)
- return false;
- break;
- case Lower:
- if (len >= cmt->selLenA)
- return false;
- break;
- case Inside:
- if ((len < cmt->selLenA) || (len >= cmt->selLenB))
- return false;
- break;
- case Outside:
- if ((len >= cmt->selLenA) && (len < cmt->selLenB))
- return false;
- break;
- }
- int bar, beat;
- unsigned tick;
- AL::sigmap.tickValues(event.tick(), &bar, &beat, &tick);
- int beat1 = cmt->selRangeA / 1000;
- unsigned tick1 = cmt->selRangeA % 1000;
- int beat2 = cmt->selRangeB / 1000;
- unsigned tick2 = cmt->selRangeB % 1000;
- switch (cmt->selRange) {
- case Ignore:
- break;
- case Equal:
- if (beat != beat1 || tick != tick1)
- return false;
- break;
- case Unequal:
- if (beat == beat1 && tick == tick1)
- return false;
- break;
- case Higher:
- if (beat <= beat1)
- return false;
- if (beat == beat1 && tick <= tick1)
- return false;
- break;
- case Lower:
- if (beat >= beat1)
- return false;
- if (beat == beat1 && tick >= tick1)
- return false;
- break;
- case Inside:
- if ((beat < beat1) || (beat >= beat2))
- return false;
- if (beat == beat1 && tick < tick1)
- return false;
- if (beat == beat2 && tick >= tick2)
- return false;
- break;
- case Outside:
- if ((beat >= beat1) || (beat < beat2))
- return false;
- if (beat == beat1 && tick >= tick1)
- return false;
- if (beat == beat2 && tick < tick2)
- return false;
- break;
- }
- return true;
- }
-
-//---------------------------------------------------------
-// apply
-//---------------------------------------------------------
-
-void MidiTransformerDialog::apply()
- {
- int flags = 0;
- song->startUndo();
- audio->msgIdle(true);
- bool copyExtract = (data->cmt->funcOp == Copy)
- || (data->cmt->funcOp == Extract);
-
- std::vector< EventList* > doneList;
- typedef std::vector< EventList* >::iterator iDoneList;
- iDoneList idl;
-
- MidiTrackList* tracks = song->midis();
- MidiTrackList tl;
- for (iMidiTrack t = tracks->begin(); t != tracks->end(); ++t) {
- if (data->cmt->selectedTracks && !(*t)->selected())
- continue;
- MidiTrack* newTrack = 0;
- PartList *pl = (*t)->parts();
- if (copyExtract) {
- // check wether we must generate a new track
- for (iPart p = pl->begin(); p != pl->end(); ++p) {
- MidiPart* part = (MidiPart *) p->second;
- EventList* el = part->events();
- // Check if the event list has already been done. Skip repeated clones.
- for(idl = doneList.begin(); idl != doneList.end(); ++idl)
- if(*idl == el)
- break;
- if(idl != doneList.end())
- break;
- doneList.push_back(el);
-
- for (iEvent i = el->begin(); i != el->end(); ++i) {
- Event event = i->second;
- unsigned tick = event.tick();
- if (data->cmt->insideLoop && (tick < song->lpos() || tick >= song->rpos()))
- continue;
- if (isSelected(event, part)) {
- newTrack = new MidiTrack();
- tl.push_back(newTrack);
- break;
- }
- }
- if (newTrack)
- break;
- }
- }
-
- for (iPart p = pl->begin(); p != pl->end(); ++p) {
- MidiPart* part = (MidiPart *) p->second;
- MidiPart* newPart = 0;
- EventList* el = part->events();
- // Check if the event list has already been done. Skip repeated clones.
- for(idl = doneList.begin(); idl != doneList.end(); ++idl)
- if(*idl == el)
- break;
- if(idl != doneList.end())
- break;
- doneList.push_back(el);
-
- if (copyExtract) {
- // check wether we must generate a new part
- for (iEvent i = el->begin(); i != el->end(); ++i) {
- Event event = i->second;
- unsigned tick = event.tick();
- if (data->cmt->insideLoop && (tick < song->lpos() || tick >= song->rpos()))
- continue;
- if (isSelected(event, part)) {
- newPart = new MidiPart(newTrack);
- newPart->setName(part->name());
- newPart->setColorIndex(part->colorIndex());
- newPart->setTick(part->tick());
- newPart->setLenTick(part->lenTick());
- song->addPart(newPart);
- flags |= SC_PART_INSERTED;
- break;
- }
- }
- }
- EventList pel;
- for (iEvent i = el->begin(); i != el->end(); ++i) {
- Event event = i->second;
- unsigned tick = event.tick();
- if (data->cmt->insideLoop && (tick < song->lpos() || tick >= song->rpos()))
- continue;
- int flag = isSelected(event, part);
- if (data->cmt->funcOp == Select)
- event.setSelected(flag);
- else if (flag)
- pel.add(event);
- }
- for (iEvent i = pel.begin(); i != pel.end(); ++i) {
- Event event = i->second;
- processEvent(event, part, newPart);
- }
- }
- }
- if (!tl.empty()) {
- flags |= SC_TRACK_INSERTED;
- for (iTrack t = tl.begin(); t != tl.end(); ++t) {
- song->insertTrack0(*t, -1);
- }
- }
-
- switch(data->cmt->funcOp) {
- case Select:
- flags |= SC_SELECTION;
- break;
- case Quantize:
- flags |= SC_EVENT_MODIFIED;
- break;
- case Delete:
- flags |= SC_EVENT_REMOVED;
- break;
- case Transform:
- flags |= SC_EVENT_MODIFIED;
- break;
- case Insert:
- flags |= SC_EVENT_INSERTED;
- break;
- case Copy:
- flags |= SC_EVENT_INSERTED;
- case Extract:
- break;
- }
- audio->msgIdle(false);
- song->endUndo(flags);
- }
-
-//---------------------------------------------------------
-// setValOp
-//---------------------------------------------------------
-
-void MidiTransformerDialog::setValOp(QWidget* a, QWidget* b, ValOp op)
- {
- switch (op) {
- case Ignore:
- a->setEnabled(false);
- b->setEnabled(false);
- break;
- case Equal:
- case Unequal:
- case Higher:
- case Lower:
- a->setEnabled(true);
- b->setEnabled(false);
- break;
- case Inside:
- case Outside:
- a->setEnabled(true);
- b->setEnabled(true);
- break;
- }
- }
-
-//---------------------------------------------------------
-// selEventOpSel
-//---------------------------------------------------------
-
-void MidiTransformerDialog::selEventOpSel(int val)
- {
- selType->setEnabled(val != All);
- data->cmt->selEventOp = ValOp(val);
- selVal1aChanged(data->cmt->selVal1a);
- selVal1bChanged(data->cmt->selVal1b);
- }
-
-//---------------------------------------------------------
-// selTypeSel
-//---------------------------------------------------------
-
-void MidiTransformerDialog::selTypeSel(int val)
- {
- data->cmt->selType = EventType(eventTypeTable[val]);
- selVal1aChanged(data->cmt->selVal1a);
- selVal1bChanged(data->cmt->selVal1b);
- }
-
-//---------------------------------------------------------
-// selVal1OpSel
-//---------------------------------------------------------
-
-void MidiTransformerDialog::selVal1OpSel(int val)
- {
- setValOp(selVal1a, selVal1b, ValOp(val));
- data->cmt->selVal1 = ValOp(val);
- }
-
-//---------------------------------------------------------
-// selVal2OpSel
-//---------------------------------------------------------
-
-void MidiTransformerDialog::selVal2OpSel(int val)
- {
- setValOp(selVal2a, selVal2b, ValOp(val));
- data->cmt->selVal2 = ValOp(val);
- }
-
-//---------------------------------------------------------
-// selLenOpSel
-//---------------------------------------------------------
-
-void MidiTransformerDialog::selLenOpSel(int val)
- {
- setValOp(selLenA, selLenB, ValOp(val));
- data->cmt->selLen = ValOp(val);
- }
-
-//---------------------------------------------------------
-// selRangeOpSel
-//---------------------------------------------------------
-
-void MidiTransformerDialog::selRangeOpSel(int val)
- {
- setValOp(selBarA, selBarB, ValOp(val));
- data->cmt->selRange = ValOp(val);
- }
-
-//---------------------------------------------------------
-// procEventOpSel
-//---------------------------------------------------------
-
-void MidiTransformerDialog::procEventOpSel(int val)
- {
- TransformOperator op = val == 0 ? Keep : Fix;
- procType->setEnabled(op == Fix);
- data->cmt->procEvent = op;
-
- procVal1aChanged(data->cmt->procVal1a);
- procVal1bChanged(data->cmt->procVal1b);
- }
-
-//---------------------------------------------------------
-// procEventTypeSel
-//---------------------------------------------------------
-
-void MidiTransformerDialog::procEventTypeSel(int val)
- {
- data->cmt->eventType = EventType(eventTypeTable[val]);
- procVal1aChanged(data->cmt->procVal1a);
- procVal1bChanged(data->cmt->procVal1b);
- }
-
-//---------------------------------------------------------
-// procVal1OpSel
-//---------------------------------------------------------
-
-void MidiTransformerDialog::procVal1OpSel(int val)
- {
- data->cmt->procVal1 = TransformOperator(val);
- switch(TransformOperator(val)) {
- case Keep:
- case Invert:
- procVal1a->setEnabled(false);
- procVal1b->setEnabled(false);
- break;
- case Multiply:
- case Divide:
- procVal1a->setEnabled(true);
- procVal1a->setDecimals(2);
- procVal1b->setEnabled(false);
- break;
- case Plus:
- case Minus:
- case Fix:
- case Value:
- case Flip:
- procVal1a->setDecimals(0);
- procVal1a->setEnabled(true);
- procVal1b->setEnabled(false);
- break;
- case Random:
- case ScaleMap:
- case Dynamic:
- procVal1a->setDecimals(0);
- procVal1a->setEnabled(true);
- procVal1b->setEnabled(true);
- break;
- }
- procVal1aChanged(data->cmt->procVal1a);
- procVal1bChanged(data->cmt->procVal1b);
- }
-
-//---------------------------------------------------------
-// procVal2OpSel
-//---------------------------------------------------------
-
-void MidiTransformerDialog::procVal2OpSel(int val)
- {
- TransformOperator op = TransformOperator(procVal2Map[val]);
- data->cmt->procVal2 = op;
-
- switch (op) {
- case Keep:
- case Invert:
- procVal2a->setEnabled(false);
- procVal2b->setEnabled(false);
- break;
- case Multiply:
- case Divide:
- procVal2a->setEnabled(true);
- procVal2a->setDecimals(2);
- procVal2b->setEnabled(false);
- break;
- case Plus:
- case Minus:
- case Fix:
- case Value:
- procVal2a->setDecimals(0);
- procVal2a->setEnabled(true);
- procVal2b->setEnabled(false);
- break;
- case Random:
- case Dynamic:
- procVal2a->setDecimals(0);
- procVal2a->setEnabled(true);
- procVal2b->setEnabled(true);
- break;
- default:
- break;
- }
- }
-
-//---------------------------------------------------------
-// procLenOpSel
-//---------------------------------------------------------
-
-void MidiTransformerDialog::procLenOpSel(int val)
- {
- TransformOperator op = TransformOperator(val);
- data->cmt->procLen = op;
-
- switch (op) {
- case Keep:
- case Invert:
- procLenA->setEnabled(false);
- break;
- case Plus:
- case Minus:
- case Fix:
- procLenA->setDecimals(0);
- procLenA->setEnabled(true);
- break;
- case Multiply:
- case Divide:
- procLenA->setDecimals(2);
- procLenA->setEnabled(true);
- break;
- default:
- break;
- }
- }
-
-//---------------------------------------------------------
-// procPosOpSel
-//---------------------------------------------------------
-
-void MidiTransformerDialog::procPosOpSel(int val)
- {
- TransformOperator op = TransformOperator(val);
- data->cmt->procPos = op;
-
- switch (op) {
- case Keep:
- case Invert:
- procPosA->setEnabled(false);
- break;
- case Multiply:
- case Divide:
- procPosA->setDecimals(2);
- procPosA->setEnabled(true);
- break;
- case Plus:
- case Minus:
- procPosA->setDecimals(0);
- procPosA->setEnabled(true);
- break;
- default:
- break;
- }
- }
-
-//---------------------------------------------------------
-// funcOpSel
-//---------------------------------------------------------
-
-void MidiTransformerDialog::funcOpSel(int val)
- {
- funcQuantVal->setEnabled(val == Quantize);
- bool isFuncOp = val == Transform || val == Insert;
-
- procEventOp->setEnabled(isFuncOp);
- procType->setEnabled(isFuncOp);
- procVal1Op->setEnabled(isFuncOp);
- procVal1a->setEnabled(isFuncOp);
- procVal1b->setEnabled(isFuncOp);
- procVal2Op->setEnabled(isFuncOp);
- procVal2a->setEnabled(isFuncOp);
- procVal2b->setEnabled(isFuncOp);
- procLenOp->setEnabled(isFuncOp);
- procLenA->setEnabled(isFuncOp);
- procPosOp->setEnabled(isFuncOp);
- procPosA->setEnabled(isFuncOp);
- if (isFuncOp) {
- procEventOpSel(data->cmt->procEvent);
- procVal1OpSel(data->cmt->procVal1);
- procVal2OpSel(data->cmt->procVal2);
- procLenOpSel(data->cmt->procLen);
- procPosOpSel(data->cmt->procPos);
- }
- data->cmt->funcOp = TransformFunction(val);
- }
-
-//---------------------------------------------------------
-// presetNew
-//---------------------------------------------------------
-
-void MidiTransformerDialog::presetNew()
- {
- QString name;
- for (int i = 0;; ++i) {
- name.sprintf("New-%d", i);
- iMidiTransformation imt;
- for (imt = mtlist.begin(); imt != mtlist.end(); ++imt) {
- if (name == (*imt)->name)
- break;
- }
- if (imt == mtlist.end())
- break;
- }
- MidiTransformation* mt = new MidiTransformation(name);
- QListWidgetItem* lbi = new QListWidgetItem(name);
- presetList->addItem(lbi);
- mtlist.push_back(mt);
- presetList->setCurrentItem(lbi);
- presetChanged(lbi);
- }
-
-//---------------------------------------------------------
-// presetDelete
-//---------------------------------------------------------
-
-void MidiTransformerDialog::presetDelete()
- {
- if (data->cindex != -1) {
- iMidiTransformation mt = mtlist.begin();
- for (int i = 0; i < data->cindex; ++i, ++mt) {
- mtlist.erase(mt);
- presetList->setCurrentItem(presetList->item(data->cindex - 1));
- presetList->takeItem(data->cindex);
- presetChanged(presetList->item(data->cindex - 1));
- break;
- }
- }
- }
-
-//---------------------------------------------------------
-// presetChanged
-//---------------------------------------------------------
-
-void MidiTransformerDialog::presetChanged(QListWidgetItem* item)
- {
- data->cindex = presetList->row(item);
- iMidiTransformation i;
- for (i = mtlist.begin(); i != mtlist.end(); ++i) {
- if (item->text() == (*i)->name) {
- data->cmt = *i;
- break;
- }
- }
- if (i == mtlist.end()) {
- printf("MidiTransformerDialog::presetChanged: not found\n");
- return;
- }
- nameEntry->setText(data->cmt->name);
- commentEntry->setText(data->cmt->comment);
-
- selEventOp->setCurrentIndex(data->cmt->selEventOp);
- selEventOpSel(data->cmt->selEventOp);
-
- for (unsigned i = 0; i < sizeof(eventTypeTable)/sizeof(*eventTypeTable); ++i) {
- if (eventTypeTable[i] == data->cmt->selType) {
- selType->setCurrentIndex(i);
- break;
- }
- }
-
- selVal1Op->setCurrentIndex(data->cmt->selVal1);
- selVal1OpSel(data->cmt->selVal1);
-
- selVal2Op->setCurrentIndex(data->cmt->selVal2);
- selVal2OpSel(data->cmt->selVal2);
-
- selLenOp->setCurrentIndex(data->cmt->selLen);
- selLenOpSel(data->cmt->selLen);
-
- selRangeOp->setCurrentIndex(data->cmt->selRange);
- selRangeOpSel(data->cmt->selRange);
-
- funcOp->setCurrentIndex(data->cmt->funcOp);
- funcOpSel(data->cmt->funcOp);
-
- // TransformOperator procEvent: Keep, Fix
- procEventOp->setCurrentIndex(data->cmt->procEvent == Fix);
-
- procEventOpSel(data->cmt->procEvent);
-
- procVal1Op->setCurrentIndex(data->cmt->procVal1);
- procVal1OpSel(data->cmt->procVal1);
-
- for (unsigned i = 0; i < sizeof(procVal2Map)/sizeof(*procVal2Map); ++i) {
- if (procVal2Map[i] == data->cmt->procVal2) {
- procVal2Op->setCurrentIndex(i);
- break;
- }
- }
- procLenOp->setCurrentIndex(data->cmt->procLen);
- procLenOpSel(data->cmt->procLen);
-
- procPosOp->setCurrentIndex(data->cmt->procPos);
- procPosOpSel(data->cmt->procPos);
-
- selVal1aChanged(data->cmt->selVal1a);
- selVal1bChanged(data->cmt->selVal1b);
- selVal2a->setValue(data->cmt->selVal2a);
- selVal2b->setValue(data->cmt->selVal2b);
- selLenA->setValue(data->cmt->selLenA);
- selLenB->setValue(data->cmt->selLenB);
- selBarA->setValue(data->cmt->selRangeA);
- selBarB->setValue(data->cmt->selRangeB);
- procVal1a->setValue(data->cmt->procVal1a);
- procVal1b->setValue(data->cmt->procVal1b);
- procVal2a->setValue(data->cmt->procVal2a);
- procVal2b->setValue(data->cmt->procVal2b);
- procLenA->setValue(data->cmt->procLenA);
- procPosA->setValue(data->cmt->procPosA);
- funcQuantVal->setValue(data->cmt->quantVal);
-
- selectedTracks->setChecked(data->cmt->selectedTracks);
- selectedTracksChanged(data->cmt->selectedTracks);
- insideLoop->setChecked(data->cmt->insideLoop);
- insideLoopChanged(data->cmt->insideLoop);
- }
-
-//---------------------------------------------------------
-// nameChanged
-//---------------------------------------------------------
-
-void MidiTransformerDialog::nameChanged(const QString& s)
- {
- data->cmt->name = s;
- QListWidgetItem* item = presetList->item(data->cindex);
- if (s != item->text()) {
- disconnect(presetList, SIGNAL(highlighted(QListWidgetItem*)),
- this, SLOT(presetChanged(QListWidgetItem*)));
- presetList->insertItem(data->cindex, s);
- presetList->takeItem(data->cindex);
- presetList->setCurrentItem(presetList->item(data->cindex));
- connect(presetList, SIGNAL(highlighted(QListWidgetItem*)),
- SLOT(presetChanged(QListWidgetItem*)));
- }
- }
-
-//---------------------------------------------------------
-// commentChanged
-//---------------------------------------------------------
-
-void MidiTransformerDialog::commentChanged()
- {
- data->cmt->comment = commentEntry->toPlainText();
- }
-
-//-----------------------------op----------------------------
-// selVal1aChanged
-//---------------------------------------------------------
-
-void MidiTransformerDialog::selVal1aChanged(int val)
- {
- data->cmt->selVal1a = val;
- if ((data->cmt->selEventOp != All)
- && (data->cmt->selType == Note)) {
- selVal1a->setSuffix(" - " + pitch2string(val));
- }
- else
- {
- if(!selVal1a->suffix().isEmpty())
- selVal1a->setSuffix(QString(""));
- }
- }
-
-//---------------------------------------------------------
-// selVal1bChanged
-//---------------------------------------------------------
-
-void MidiTransformerDialog::selVal1bChanged(int val)
- {
- data->cmt->selVal1b = val;
- if ((data->cmt->selEventOp != All)
- && (data->cmt->selType == Note)) {
- selVal1b->setSuffix(" - " + pitch2string(val));
- }
- else
- {
- if(!selVal1b->suffix().isEmpty())
- selVal1b->setSuffix(QString(""));
- }
- }
-
-//---------------------------------------------------------
-// selVal2aChanged
-//---------------------------------------------------------
-
-void MidiTransformerDialog::selVal2aChanged(int val)
- {
- data->cmt->selVal2a = val;
- }
-
-//---------------------------------------------------------
-// selVal2bChanged
-//---------------------------------------------------------
-
-void MidiTransformerDialog::selVal2bChanged(int val)
- {
- data->cmt->selVal2b = val;
- }
-
-//---------------------------------------------------------
-// selLenAChanged
-//---------------------------------------------------------
-
-void MidiTransformerDialog::selLenAChanged(int val)
- {
- data->cmt->selLenA = val;
- }
-
-//---------------------------------------------------------
-// selLenBChanged
-//---------------------------------------------------------
-
-void MidiTransformerDialog::selLenBChanged(int val)
- {
- data->cmt->selLenB = val;
- }
-
-//---------------------------------------------------------
-// selBarAChanged
-//---------------------------------------------------------
-
-void MidiTransformerDialog::selBarAChanged(int val)
- {
- data->cmt->selRangeA = val;
- }
-
-//---------------------------------------------------------
-// selBarBChanged
-//---------------------------------------------------------
-
-void MidiTransformerDialog::selBarBChanged(int val)
- {
- data->cmt->selRangeB = val;
- }
-
-//---------------------------------------------------------
-// procVal1aChanged
-//---------------------------------------------------------
-
-void MidiTransformerDialog::procVal1aChanged(int val)
- {
- data->cmt->procVal1a = val;
-
- if((data->cmt->procEvent == Keep && data->cmt->selType == MIDITRANSFORM_NOTE) &&
- (data->cmt->procVal1 == Fix || data->cmt->procVal1 == ScaleMap || data->cmt->procVal1 == Dynamic ||
- data->cmt->procVal1 == Random || data->cmt->procVal1 == Flip))
- {
- procVal1a->setSuffix(" - " + pitch2string(val));
- }
- else
- {
- if(!procVal1a->suffix().isEmpty())
- procVal1a->setSuffix(QString(""));
- }
-
- }
-
-//---------------------------------------------------------
-// procVal1bChanged
-//---------------------------------------------------------
-
-void MidiTransformerDialog::procVal1bChanged(int val)
- {
- data->cmt->procVal1b = val;
-
- if((data->cmt->procEvent == Keep && data->cmt->selType == MIDITRANSFORM_NOTE) &&
- (data->cmt->procVal1 == Fix || data->cmt->procVal1 == ScaleMap || data->cmt->procVal1 == Dynamic ||
- data->cmt->procVal1 == Random || data->cmt->procVal1 == Flip))
- {
- procVal1b->setSuffix(" - " + pitch2string(val));
- }
- else
- {
- if(!procVal1b->suffix().isEmpty())
- procVal1b->setSuffix(QString(""));
- }
- }
-
-//---------------------------------------------------------
-// procVal2aChanged
-//---------------------------------------------------------
-
-void MidiTransformerDialog::procVal2aChanged(int val)
- {
- data->cmt->procVal2a = val;
- }
-
-//---------------------------------------------------------
-// procVal2bChanged
-//---------------------------------------------------------
-
-void MidiTransformerDialog::procVal2bChanged(int val)
- {
- data->cmt->procVal2b = val;
- }
-
-//---------------------------------------------------------
-// procLenAChanged
-//---------------------------------------------------------
-
-void MidiTransformerDialog::procLenAChanged(int val)
- {
- data->cmt->procLenA = val;
- }
-
-//---------------------------------------------------------
-// procPosAChanged
-//---------------------------------------------------------
-
-void MidiTransformerDialog::procPosAChanged(int val)
- {
- data->cmt->procPosA = val;
- }
-
-//---------------------------------------------------------
-// funcQuantValSel
-//---------------------------------------------------------
-
-void MidiTransformerDialog::funcQuantValSel(int val)
- {
- data->cmt->quantVal = val;
- }
-
-//---------------------------------------------------------
-// processAllChanged
-//---------------------------------------------------------
-
-void MidiTransformerDialog::processAllChanged(bool val)
- {
- if (val == true) {
- selectedTracks->setChecked(false);
- insideLoop->setChecked(false);
- data->cmt->selectedTracks = false;
- data->cmt->insideLoop = false;
- }
- }
-
-//---------------------------------------------------------
-// selectedTracksChanged
-//---------------------------------------------------------
-
-void MidiTransformerDialog::selectedTracksChanged(bool val)
- {
- data->cmt->selectedTracks = val;
- processAll->setChecked(!val && !data->cmt->insideLoop);
- }
-
-//---------------------------------------------------------
-// insideLoopChanged
-//---------------------------------------------------------
-
-void MidiTransformerDialog::insideLoopChanged(bool val)
- {
- data->cmt->insideLoop = val;
- processAll->setChecked(!data->cmt->selectedTracks && !val);
- }
-
-
-
-/*!
- \fn MidiTransformerDialog::typesMatch(MidiEvent e, unsigned t)
- */
-bool MidiTransformerDialog::typesMatch(Event& e, unsigned selType)
- {
- bool matched = false;
- switch (selType)
- {
- case MIDITRANSFORM_NOTE:
- matched = (e.type() == Note);
- break;
- case MIDITRANSFORM_POLY:
- matched = (e.type() == PAfter);
- break;
- case MIDITRANSFORM_CTRL:
- matched = (e.type() == Controller);
- break;
- case MIDITRANSFORM_ATOUCH:
- matched = (e.type() == CAfter);
- break;
- case MIDITRANSFORM_PITCHBEND:
- {
- if (e.type() == Controller) {
- MidiController::ControllerType c = midiControllerType(e.dataA());
- matched = (c == MidiController::Pitch);
- }
- break;
- }
- case MIDITRANSFORM_NRPN:
- {
- if (e.type() == Controller) {
- MidiController::ControllerType c = midiControllerType(e.dataA());
- matched = (c == MidiController::NRPN);
- }
- }
- case MIDITRANSFORM_RPN:
- {
- if (e.type() == Controller) {
- MidiController::ControllerType c = midiControllerType(e.dataA());
- matched = (c == MidiController::RPN);
- }
- }
- default:
- fprintf(stderr, "Error matching type in MidiTransformerDialog: unknown eventtype!\n");
- break;
- }
- //printf("Event type=%d, selType =%d matched=%d\n", e.type(), selType, matched);
- return matched;
- }
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-27 06:40:17 +0000