summaryrefslogtreecommitdiff
path: root/muse2/synti/deicsonze2/deicsonze2preset.cpp
diff options
context:
space:
mode:
authorNil Geisweiller <a-lin@sourceforge.net>2010-11-14 07:41:38 +0000
committerNil Geisweiller <a-lin@sourceforge.net>2010-11-14 07:41:38 +0000
commit2a079213ac507ab4866d9e27c5cf86ddcb7a3c6d (patch)
tree1b31e3bd10a3937c0eb249407530d00c7de4c1e5 /muse2/synti/deicsonze2/deicsonze2preset.cpp
parent17d8ce85ca5ee2a3b3e0b3c9c8af745da8117e40 (diff)
see ChangeLog
Diffstat (limited to 'muse2/synti/deicsonze2/deicsonze2preset.cpp')
-rw-r--r--muse2/synti/deicsonze2/deicsonze2preset.cpp1202
1 files changed, 1202 insertions, 0 deletions
diff --git a/muse2/synti/deicsonze2/deicsonze2preset.cpp b/muse2/synti/deicsonze2/deicsonze2preset.cpp
new file mode 100644
index 00000000..f4ddbb98
--- /dev/null
+++ b/muse2/synti/deicsonze2/deicsonze2preset.cpp
@@ -0,0 +1,1202 @@
+//===========================================================================
+//
+// DeicsOnze2 an emulator of the YAMAHA DX11 synthesizer
+//
+// Version 0.5.5
+//
+// deicsonzepreset.cpp
+//
+//
+// Copyright (c) 2004-2006 Nil Geisweiller
+//
+//
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License
+// as published by the Free Software Foundation; either version 2
+// of the License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+// 02111-1307, USA or point your web browser to http://www.gnu.org.
+//===========================================================================
+
+#include "deicsonzepreset.h"
+#include <iostream>
+#include <algorithm>
+
+#define SET_LEVEL 1
+#define CAT_LEVEL 2
+#define SUB_LEVEL 3
+#define PRE_LEVEL 4
+
+//-----------------------------------------------------------
+// Constructor destructor
+//-----------------------------------------------------------
+Preset::Preset() {_subcategory=NULL;_isUsed=false;initPreset();}
+Preset::Preset(Subcategory* sub) {
+ _subcategory=sub;
+ _isUsed=false;
+ initPreset();
+ if(sub) sub->_presetVector.push_back(this);
+}
+Preset::Preset(Subcategory* sub, int pr) {
+ _subcategory=sub;
+ _isUsed=false;
+ initPreset();
+ prog=pr;
+ if(sub) sub->_presetVector.push_back(this);
+}
+Preset::~Preset() {
+ if(_subcategory) {
+ std::vector<Preset*>::iterator iB=_subcategory->_presetVector.begin();
+ std::vector<Preset*>::iterator iE=_subcategory->_presetVector.end();
+ std::vector<Preset*>::iterator iP=std::find(iB, iE, this);
+ if(iP!=iE) _subcategory->_presetVector.erase(iP);
+ else printf("Error : preset %s not found\n", name.c_str());
+ }
+}
+//----------------------------------------------------------
+// setIsUsed(bool b)
+// set the flag _isUsed and transmit in the parents
+//----------------------------------------------------------
+void Preset::setIsUsed(bool b) {
+ if(!_isUsed) {
+ _isUsed=b;
+ if(_subcategory) {
+ _subcategory->_isUsed=b;
+ if(_subcategory->_category) {
+ _subcategory->_category->_isUsed=b;
+ }
+ }
+ }
+}
+//----------------------------------------------------------
+// getHBankLBankProg
+// return the hbank, lbank and prog of the preset
+// warning : if there is not subcategory of category
+// the value l or h are let unchanged
+//----------------------------------------------------------
+void Preset::getHBankLBankProg(int* h, int* l, int* p) {
+ *p = prog;
+ if(_subcategory) {
+ *l = _subcategory->_lbank;
+ if(_subcategory->_category) *h = _subcategory->_category->_hbank;
+ }
+}
+//----------------------------------------------------------
+// linkSubcategory
+// links the preset to a subcategory parent and erase itself
+// from the last subcategory if not NULL
+//----------------------------------------------------------
+void Preset::linkSubcategory(Subcategory* sub) {
+ if(_subcategory) {
+ std::vector<Preset*> pv=_subcategory->_presetVector;
+ std::vector<Preset*>::iterator iP=find(pv.begin(),pv.end(),this);
+ if(iP!=pv.end()) pv.erase(iP);
+ else printf("Error linkSubcategory: preset %s not found\n",
+ name.c_str());
+ }
+ _subcategory=sub;
+ if(sub) sub->_presetVector.push_back(this);
+}
+//----------------------------------------------------------
+// linkCategory
+// links the subcategory to a category parent and erase itself
+// from the last category if not NULL
+//----------------------------------------------------------
+void Subcategory::linkCategory(Category* cat) {
+ if(_category) {
+ std::vector<Subcategory*> sv=_category->_subcategoryVector;
+ std::vector<Subcategory*>::iterator iS=find(sv.begin(),sv.end(),this);
+ if(iS!=sv.end()) sv.erase(iS);
+ else printf("Error linkCategory: preset %s not found\n",
+ _subcategoryName.c_str());
+ }
+ _category=cat;
+ if(cat) cat->_subcategoryVector.push_back(this);
+}
+
+
+//----------------------------------------------------------
+// linkSet
+// links the category to a set parent (there is always only one set)
+//----------------------------------------------------------
+void Category::linkSet(Set* s) {
+ _set=s;
+ if(s) s->_categoryVector.push_back(this);
+}
+
+//----------------------------------------------------------
+// Subcategory constructor and destruction
+//----------------------------------------------------------
+Subcategory::Subcategory() {_category=NULL;}
+Subcategory::Subcategory(Category* cat) {
+ _category=cat;
+ _isUsed=false;
+ if(cat) cat->_subcategoryVector.push_back(this);
+}
+Subcategory::Subcategory(const std::string name) {
+ _category=NULL;
+ _isUsed=false;
+ _subcategoryName=name;
+}
+Subcategory::Subcategory(Category* cat, const std::string name, int lbank) {
+ _category=cat;
+ _isUsed=false;
+ _subcategoryName=name;
+ _lbank=lbank;
+ if(cat) cat->_subcategoryVector.push_back(this);
+}
+Subcategory::~Subcategory() {
+ while(!_presetVector.empty()) delete(*_presetVector.begin());
+ if(_category) {
+ std::vector<Subcategory*>::iterator
+ iB=_category->_subcategoryVector.begin();
+ std::vector<Subcategory*>::iterator
+ iE=_category->_subcategoryVector.end();
+ std::vector<Subcategory*>::iterator iS=std::find(iB, iE, this);
+ if(iS!=iE) _category->_subcategoryVector.erase(iS);
+ else printf("Error : subcategory %s not found\n",
+ _subcategoryName.c_str());
+ }
+}
+
+//--------------------------------------------------------
+// Category constructor destructor
+//--------------------------------------------------------
+Category::Category() {_set=NULL;_isUsed=false;}
+Category::Category(Set* s) {
+ _set=s;
+ _isUsed=false;
+ if(s) s->_categoryVector.push_back(this);
+}
+Category::Category(Set* s,const std::string name, int hbank) {
+ _set=s;
+ _isUsed=false;
+ _categoryName=name;
+ _hbank=hbank;
+ if(s) s->_categoryVector.push_back(this);
+}
+Category::~Category() {
+ while(!_subcategoryVector.empty()) delete(*_subcategoryVector.begin());
+ if(_set) {
+ std::vector<Category*>::iterator iB=_set->_categoryVector.begin();
+ std::vector<Category*>::iterator iE=_set->_categoryVector.end();
+ std::vector<Category*>::iterator iC=std::find(iB, iE, this);
+ if(iC!=iE) _set->_categoryVector.erase(iC);
+ else printf("Error : category %s not found\n", _categoryName.c_str());
+ }
+}
+
+//---------------------------------------------------------
+// initPreset
+// put the preset in the initial state as defined by YAMAHA
+//---------------------------------------------------------
+void Preset::initPreset() {
+ //algorithm
+ algorithm=FIRST;
+ //feedeback
+ feedback=0;
+ //lfo
+ lfo.wave=TRIANGL;
+ lfo.speed=35;
+ lfo.delay=0;
+ lfo.pModDepth=0;
+ lfo.aModDepth=0;
+ lfo.sync=false;
+ //sensitivity
+ sensitivity.pitch=6;
+ sensitivity.amplitude=0;
+ sensitivity.ampOn[0]=false;
+ sensitivity.ampOn[1]=false;
+ sensitivity.ampOn[2]=false;
+ sensitivity.ampOn[3]=false;
+ sensitivity.egBias[0]=0;
+ sensitivity.egBias[1]=0;
+ sensitivity.egBias[2]=0;
+ sensitivity.egBias[3]=0;
+ sensitivity.keyVelocity[0]=0;
+ sensitivity.keyVelocity[1]=0;
+ sensitivity.keyVelocity[2]=0;
+ sensitivity.keyVelocity[3]=0;
+ //frequency
+ frequency[0].ratio=1.0;
+ frequency[1].ratio=1.0;
+ frequency[2].ratio=1.0;
+ frequency[3].ratio=1.0;
+ frequency[0].isFix=false;
+ frequency[1].isFix=false;
+ frequency[2].isFix=false;
+ frequency[3].isFix=false;
+ frequency[0].freq=255.0;
+ frequency[1].freq=255.0;
+ frequency[2].freq=255.0;
+ frequency[3].freq=255.0;
+ //oscWave
+ oscWave[0]=W1;
+ oscWave[1]=W1;
+ oscWave[2]=W1;
+ oscWave[3]=W1;
+ //detune
+ detune[0]=0;
+ detune[1]=0;
+ detune[2]=0;
+ detune[3]=0;
+ //eg
+ eg[0].ar=31;
+ eg[1].ar=31;
+ eg[2].ar=31;
+ eg[3].ar=31;
+ eg[0].d1r=31;
+ eg[1].d1r=31;
+ eg[2].d1r=31;
+ eg[3].d1r=31;
+ eg[0].d1l=15;
+ eg[1].d1l=15;
+ eg[2].d1l=15;
+ eg[3].d1l=15;
+ eg[0].d2r=0;
+ eg[1].d2r=0;
+ eg[2].d2r=0;
+ eg[3].d2r=0;
+ eg[0].rr=15;
+ eg[1].rr=15;
+ eg[2].rr=15;
+ eg[3].rr=15;
+ eg[0].egShift=VOF;
+ eg[1].egShift=VOF;
+ eg[2].egShift=VOF;
+ eg[3].egShift=VOF;
+ //pitchEg
+ pitchEg.pr1=99;
+ pitchEg.pr2=99;
+ pitchEg.pr3=99;
+ pitchEg.pl1=50;
+ pitchEg.pl2=50;
+ pitchEg.pl3=50;
+ //outLevel
+ outLevel[0]=90;
+ outLevel[1]=0;
+ outLevel[2]=0;
+ outLevel[3]=0;
+ //scaling
+ scaling.rate[0]=0;
+ scaling.rate[1]=0;
+ scaling.rate[2]=0;
+ scaling.rate[3]=0;
+ scaling.level[0]=0;
+ scaling.level[1]=0;
+ scaling.level[2]=0;
+ scaling.level[3]=0;
+ //function
+ function.transpose=0;
+ function.mode=POLY;
+ function.pBendRange=4;
+ function.portamento=FULL;
+ function.portamentoTime=0;
+ function.fcVolume=40;
+ function.fcPitch=0;
+ function.fcAmplitude=0;
+ function.mwPitch=50;
+ function.mwAmplitude=0;
+ function.bcPitch=0;
+ function.bcAmplitude=0;
+ function.bcPitchBias=0;
+ function.bcEgBias=0;
+ function.atPitch=0;
+ function.atAmplitude=0;
+ function.atPitchBias=0;
+ function.atEgBias=0;
+ function.reverbRate=0;
+ //globalDetune=0;
+ //Name
+ name="INITVOICE";
+}
+//---------------------------------------------------------
+// Preset::merge
+// copy the preset
+//---------------------------------------------------------
+void Preset::merge(Preset* p) {
+ if(p) {
+ //algorithm
+ algorithm=p->algorithm;
+ //feedeback
+ feedback=p->feedback;
+ //lfo
+ lfo.wave=p->lfo.wave;
+ lfo.speed=p->lfo.speed;
+ lfo.delay=p->lfo.delay;
+ lfo.pModDepth=p->lfo.pModDepth;
+ lfo.aModDepth=p->lfo.aModDepth;
+ lfo.sync=p->lfo.sync;
+ //sensitivity
+ sensitivity.pitch=p->sensitivity.pitch;
+ sensitivity.amplitude=p->sensitivity.amplitude;
+ for(int k=0; k<NBROP; k++) {
+ sensitivity.ampOn[k]=p->sensitivity.ampOn[k];
+ sensitivity.egBias[k]=p->sensitivity.egBias[k];
+ sensitivity.keyVelocity[k]=p->sensitivity.keyVelocity[k];
+ //frequency
+ frequency[k].ratio=p->frequency[k].ratio;
+ frequency[k].isFix=p->frequency[k].isFix;
+ frequency[k].freq=p->frequency[k].freq;
+ //oscWave
+ oscWave[k]=p->oscWave[k];
+ //detune
+ detune[k]=p->detune[k];
+ //eg
+ eg[k].ar=p->eg[k].ar;
+ eg[k].d1r=p->eg[k].d1r;
+ eg[k].d1l=p->eg[k].d1l;
+ eg[k].d2r=p->eg[k].d2r;
+ eg[k].rr=p->eg[k].rr;
+ eg[k].egShift=p->eg[k].egShift;
+ //outLevel
+ outLevel[k]=p->outLevel[k];
+ //scaling
+ scaling.rate[k]=p->scaling.rate[k];
+ scaling.level[k]=p->scaling.level[k];
+ }
+ //pitchEg
+ pitchEg.pr1=p->pitchEg.pr1;
+ pitchEg.pr2=p->pitchEg.pr2;
+ pitchEg.pr3=p->pitchEg.pr3;
+ pitchEg.pl1=p->pitchEg.pl1;
+ pitchEg.pl2=p->pitchEg.pl2;
+ pitchEg.pl3=p->pitchEg.pl3;
+ //function
+ function.transpose=p->function.transpose;
+ function.mode=p->function.mode;
+ function.pBendRange=p->function.pBendRange;
+ function.portamento=p->function.portamento;
+ function.portamentoTime=p->function.portamentoTime;
+ function.fcVolume=p->function.fcVolume;
+ function.fcPitch=p->function.fcPitch;
+ function.fcAmplitude=p->function.fcAmplitude;
+ function.mwPitch=p->function.mwPitch;
+ function.mwAmplitude=p->function.mwAmplitude;
+ function.bcPitch=p->function.bcPitch;
+ function.bcAmplitude=p->function.bcAmplitude;
+ function.bcPitchBias=p->function.bcPitchBias;
+ function.bcEgBias=p->function.bcEgBias;
+ function.atPitch=p->function.atPitch;
+ function.atAmplitude=p->function.atAmplitude;
+ function.atPitchBias=p->function.atPitchBias;
+ function.atEgBias=p->function.atEgBias;
+ function.reverbRate=p->function.reverbRate;
+ //globalDetune=p->globalDetune;
+ //Name
+ name=p->name;
+ }
+}
+//---------------------------------------------------------
+// findPreset
+// return the first preset corresponding of hbank, lbank, prog
+//---------------------------------------------------------
+Preset* Subcategory::findPreset(int prog) {
+ std::vector<Preset*>::iterator pvi;
+ for(pvi=_presetVector.begin(); pvi!=_presetVector.end(); pvi++) {
+ if((*pvi)->prog==prog) return(*pvi);
+ }
+ return NULL;
+}
+Preset* Category::findPreset(int lbank, int prog) {
+ Subcategory* s=findSubcategory(lbank);
+ if(s) {
+ Preset* p=s->findPreset(prog);
+ if(p) return(p);
+ }
+ return(NULL);
+}
+Preset* Set::findPreset(int hbank, int lbank, int prog) {
+ Category* c=findCategory(hbank);
+ if(c) {
+ Preset* p=c->findPreset(lbank, prog);
+ if(p) return(p);
+ }
+ return NULL;
+}
+
+//---------------------------------------------------------
+// isFreeHBank, firstFreeHBank -1 otherwise
+//---------------------------------------------------------
+bool Set::isFreeHBank(int hbank) {
+ if(findCategory(hbank)) return(false);
+ else return(true);
+}
+int Set::firstFreeHBank() {
+ for(int hbank=0; hbank<128; hbank++) if(isFreeHBank(hbank)) return(hbank);
+ return(-1);
+}
+//--------------------------------------------------------------
+// Set::merge
+//--------------------------------------------------------------
+void Set::merge(Category* c) {
+ if(isFreeHBank(c->_hbank)) c->linkSet(this);
+ else {
+ Category* cFromSet=findCategory(c->_hbank);
+ cFromSet->_categoryName=c->_categoryName;
+ for(std::vector<Subcategory*>::iterator
+ i=c->_subcategoryVector.begin();
+ i!=c->_subcategoryVector.end(); i++) cFromSet->merge(*i);
+ //delete(c);
+ }
+}
+
+bool Category::isFreeLBank(int lbank) {
+ if(findSubcategory(lbank)) return(false);
+ else return(true);
+}
+int Category::firstFreeLBank() {
+ for(int lbank=0; lbank<128; lbank++) if(isFreeLBank(lbank)) return(lbank);
+ return(-1);
+}
+//--------------------------------------------------------------
+// Category::merge
+//--------------------------------------------------------------
+void Category::merge(Subcategory* s) {
+ if(isFreeLBank(s->_lbank)) s->linkCategory(this);
+ else {
+ Subcategory* sFromCat=findSubcategory(s->_lbank);
+ sFromCat->_subcategoryName=s->_subcategoryName;
+ for(std::vector<Preset*>::iterator
+ i=s->_presetVector.begin();
+ i!=s->_presetVector.end(); i++) sFromCat->merge(*i);
+ //delete(s);
+ }
+}
+//---------------------------------------------------------
+// Category::unlink
+// unlink the subcategories, so don't delete them when delete
+//---------------------------------------------------------
+void Category::unlink() {
+ while(!_subcategoryVector.empty())
+ _subcategoryVector.erase(_subcategoryVector.begin());
+}
+
+bool Subcategory::isFreeProg(int pr) {
+ if(findPreset(pr)) return(false);
+ else return(true);
+}
+int Subcategory::firstFreeProg() {
+ for(int pr=0; pr<128; pr++) if(isFreeProg(pr)) return(pr);
+ return(-1);
+}
+//---------------------------------------------------------
+// Subcategory::unlink
+// unlink the presets, so don't delete them when delete
+//---------------------------------------------------------
+void Subcategory::unlink() {
+ while(!_presetVector.empty()) _presetVector.erase(_presetVector.begin());
+}
+
+//---------------------------------------------------------
+// findSubcategory
+// take hbank and lbank and return the subcategory corresponding,
+// NULL if doesn't exist
+//---------------------------------------------------------
+Subcategory* Set::findSubcategory(int hbank, int lbank) {
+ Category* c = findCategory(hbank);
+ Subcategory* s;
+ if(c) {
+ s = c->findSubcategory(lbank);
+ return s;
+ }
+ else return NULL;
+}
+
+//---------------------------------------------------------
+// findCategory
+// takes hbank a category and return the first category,
+// NULL if doesn't exist
+//---------------------------------------------------------
+Category* Set::findCategory(int hbank) {
+ std::vector<Category*>::iterator cvi;
+ for(cvi=_categoryVector.begin(); cvi!=_categoryVector.end(); cvi++)
+ if((*cvi)->_hbank==hbank) return(*cvi);
+ return(NULL);
+}
+//---------------------------------------------------------
+// findSubcategory
+// takes lbank a subcategory and return the subcategory
+// NULL if doesn't exist
+//---------------------------------------------------------
+Subcategory* Category::findSubcategory(int lbank) {
+ std::vector<Subcategory*>::iterator svi;
+ for(svi=_subcategoryVector.begin(); svi!=_subcategoryVector.end(); svi++)
+ if((*svi)->_lbank==lbank) return(*svi);
+ return(NULL);
+}
+//--------------------------------------------------------------
+// Subcategory::merge
+//--------------------------------------------------------------
+void Subcategory::merge(Preset* p) {
+ if(isFreeProg(p->prog)) p->linkSubcategory(this);
+ else {
+ Preset* pFromSub=findPreset(p->prog);
+ pFromSub->merge(p);
+ }
+}
+
+//---------------------------------------------------------
+// readSet
+//---------------------------------------------------------
+void Set::readSet(QDomNode setNode) {
+ while(!setNode.isNull()) {
+ QDomElement setEl = setNode.toElement();
+ if (setEl.isNull())
+ continue;
+ if (setEl.tagName() == "setName")
+ _setName=setEl.text().ascii();
+ if (setEl.tagName() == "deicsOnzeCategory") {
+ //load category
+ QString version = setEl.attribute(QString("version"));
+ if (version == "1.0") {
+ Category* lCategory = new Category();
+ lCategory->readCategory(setNode.firstChild());
+ //printf("Ready to merge!\n");
+ merge(lCategory);
+ }
+ }
+ setNode = setNode.nextSibling();
+ }
+}
+
+//---------------------------------------------------------
+// writeSet
+//---------------------------------------------------------
+void Set::writeSet(Xml* xml, bool onlyUsed) {
+ xml->tag(0, "deicsOnzeSet version=\"1.0\"");
+ xml->strTag(SET_LEVEL, "setName", _setName.c_str());
+ for(std::vector<Category*>::iterator i = _categoryVector.begin();
+ i != _categoryVector.end(); i++) (*i)->writeCategory(xml, onlyUsed);
+ xml->etag(0, "deicsOnzeSet");
+}
+
+//---------------------------------------------------------
+// readCategory
+//---------------------------------------------------------
+void Category::readCategory(QDomNode catNode) {
+ while(!catNode.isNull()) {
+ QDomElement catEl = catNode.toElement();
+ if (catEl.isNull())
+ continue;
+ if (catEl.tagName() == "categoryName")
+ _categoryName=catEl.text().ascii();
+ if (catEl.tagName() == "hbank")
+ _hbank=catEl.text().toInt();
+ if (catEl.tagName() == "deicsOnzeSubcategory") {
+ //load Subcategory
+ QString version = catEl.attribute(QString("version"));
+ if (version == "1.0") {
+ Subcategory* lSubcategory = new Subcategory(this);
+ lSubcategory->readSubcategory(catNode.firstChild());
+ }
+ }
+ catNode = catNode.nextSibling();
+ }
+}
+
+//---------------------------------------------------------
+// writeCategory
+//---------------------------------------------------------
+void Category::writeCategory(Xml* xml, bool onlyUsed) {
+ if((!onlyUsed || _isUsed)) {
+ xml->tag(SET_LEVEL, "deicsOnzeCategory version=\"1.0\"");
+ xml->strTag(CAT_LEVEL, "categoryName", _categoryName.c_str());
+ xml->intTag(CAT_LEVEL, "hbank", _hbank);
+ for(std::vector<Subcategory*>::iterator i=_subcategoryVector.begin();
+ i!=_subcategoryVector.end(); i++)
+ (*i)->writeSubcategory(xml, onlyUsed);
+ xml->etag(SET_LEVEL, "deicsOnzeCategory");
+ }
+}
+
+//---------------------------------------------------------
+// readSubcategory
+//---------------------------------------------------------
+void Subcategory::readSubcategory(QDomNode subNode) {
+ while(!subNode.isNull()) {
+ QDomElement subEl = subNode.toElement();
+ if (subEl.isNull())
+ continue;
+ if (subEl.tagName() == "subcategoryName")
+ _subcategoryName=subEl.text().ascii();
+ if (subEl.tagName() == "lbank")
+ _lbank=subEl.text().toInt();
+ if (subEl.tagName() == "deicsOnzePreset") {
+ //load preset
+ QString version = subEl.attribute(QString("version"));
+ if (version == "1.0") {
+ Preset* lPreset = new Preset(this);
+ lPreset->readPreset(subNode.firstChild());
+ }
+ }
+ subNode = subNode.nextSibling();
+ }
+}
+
+//---------------------------------------------------------
+// writeSubcategory
+//---------------------------------------------------------
+void Subcategory::writeSubcategory(Xml* xml, bool onlyUsed) {
+ if((!onlyUsed || _isUsed)) {
+ xml->tag(CAT_LEVEL, "deicsOnzeSubcategory version=\"1.0\"");
+ xml->strTag(SUB_LEVEL, "subcategoryName", _subcategoryName.c_str());
+ xml->intTag(SUB_LEVEL, "lbank", _lbank);
+ for(std::vector<Preset*>::iterator i=_presetVector.begin();
+ i!=_presetVector.end(); i++) (*i)->writePreset(xml, onlyUsed);
+ xml->etag(CAT_LEVEL, "deicsOnzeSubcategory");
+ }
+}
+
+//---------------------------------------------------------
+// readPreset
+//---------------------------------------------------------
+void Preset::readPreset(QDomNode presetNode) {
+ while(!presetNode.isNull()) {
+ QDomElement presetEl = presetNode.toElement();
+ if (presetEl.isNull())
+ continue;
+ //algorithm
+ if(presetEl.tagName()==ALGSTR)
+ algorithm=(presetEl.text()=="FIRST"? FIRST:
+ (presetEl.text()=="SECOND"? SECOND:
+ (presetEl.text()=="THIRD"? THIRD:
+ (presetEl.text()=="FOURTH"? FOURTH:
+ (presetEl.text()=="FIFTH"? FIFTH:
+ (presetEl.text()=="SIXTH"? SIXTH:
+ (presetEl.text()=="SEVENTH"? SEVENTH:EIGHTH)))))));
+ //feedback
+ else if(presetEl.tagName()==FEEDBACKSTR)
+ feedback=presetEl.text().toInt();
+ //quick edit
+ //else if(presetEl.tagName()==FINEBRIGHTNESSSTR)
+ // brightness=presetEl.text().toInt();
+ //else if(presetEl.tagName()==MODULATIONSTR)
+ // modulation=(unsigned char)presetEl.text().toInt();
+ //else if(presetEl.tagName()==GLOBALDETUNESTR)
+ // globalDetune=presetEl.text().toInt();
+ //else if(presetEl.tagName()==ATTACKSTR)
+ // attack=presetEl.text().toInt();
+ //else if(presetEl.tagName()==RELEASESTR)
+ // release=presetEl.text().toInt();
+ //lfo
+ else if(presetEl.tagName()=="lfo") {
+ QDomNode lfoNode = presetNode.firstChild();
+ while(!lfoNode.isNull()) {
+ QDomElement lfoEl = lfoNode.toElement();
+ if (lfoEl.isNull())
+ continue;
+ if(lfoEl.tagName()==WAVESTR)
+ lfo.wave=(lfoEl.text()=="SAWUP"? SAWUP:
+ (lfoEl.text()=="SQUARE"? SQUARE:
+ (lfoEl.text()=="TRIANGL"? TRIANGL:SHOLD)));
+ else if(lfoEl.tagName()==SPEEDSTR)
+ lfo.speed=lfoEl.text().toInt();
+ else if(lfoEl.tagName()==DELAYSTR)
+ lfo.delay=lfoEl.text().toInt();
+ else if(lfoEl.tagName()==PMODDEPTHSTR)
+ lfo.pModDepth=lfoEl.text().toInt();
+ else if(lfoEl.tagName()==AMODDEPTHSTR)
+ lfo.aModDepth=lfoEl.text().toInt();
+ else if(lfoEl.tagName()==SYNCSTR)
+ lfo.sync=(lfoEl.text()=="on"? true:false);
+ lfoNode = lfoNode.nextSibling();
+ }
+ }
+ //sensitivity
+ else if(presetEl.tagName()=="sensitivity") {
+ QDomNode sensitivityNode = presetNode.firstChild();
+ while(!sensitivityNode.isNull()) {
+ QDomElement sensitivityEl = sensitivityNode.toElement();
+ if (sensitivityEl.isNull())
+ continue;
+ QString st=sensitivityEl.tagName();
+ if(st==PMODSENSSTR)
+ sensitivity.pitch=sensitivityEl.text().toInt();
+ else if(st==AMSSTR)
+ sensitivity.amplitude=sensitivityEl.text().toInt();
+ else if(st.contains(AMESTR, Qt::CaseSensitive)) {
+ int op = (st.remove(AMESTR, Qt::CaseSensitive)).toInt()-1;
+ sensitivity.ampOn[op]=(sensitivityEl.text()=="on"? true:false);
+ }
+ else if(st.contains(EBSSTR, Qt::CaseSensitive)) {
+ int op = (st.remove(EBSSTR, Qt::CaseSensitive)).toInt()-1;
+ sensitivity.egBias[op]=sensitivityEl.text().toInt();
+ }
+ else if(st.contains(KVSSTR, Qt::CaseSensitive)) {
+ int op = (st.remove(KVSSTR, Qt::CaseSensitive)).toInt()-1;
+ sensitivity.keyVelocity[op]=sensitivityEl.text().toInt();
+ }
+ sensitivityNode =sensitivityNode.nextSibling();
+ }
+ }
+ //frequency
+ else if(presetEl.tagName()=="frequency") {
+ QDomNode frequencyNode = presetNode.firstChild();
+ while(!frequencyNode.isNull()) {
+ QDomElement frequencyEl = frequencyNode.toElement();
+ if (frequencyEl.isNull())
+ continue;
+ QString ft = frequencyEl.tagName();
+ if(ft.contains(RATIOSTR, Qt::CaseSensitive)) {
+ int op = (ft.remove(RATIOSTR, Qt::CaseSensitive)).toInt()-1;
+ frequency[op].ratio=frequencyEl.text().toDouble();
+ }
+ else if(ft.contains(FIXSTR, Qt::CaseSensitive)) {
+ int op = (ft.remove(FIXSTR, Qt::CaseSensitive)).toInt()-1;
+ frequency[op].isFix=(frequencyEl.text()=="yes"?true:false);
+ }
+ else if(ft.contains(FIXRANGESTR, Qt::CaseSensitive)) {
+ int op= (ft.remove(FIXRANGESTR, Qt::CaseSensitive)).toInt()-1;
+ frequency[op].freq=frequencyEl.text().toDouble();
+ }
+ frequencyNode =frequencyNode.nextSibling();
+ }
+ }
+ //oscWave
+ else if(presetEl.tagName().contains(OSWSTR, Qt::CaseSensitive)) {
+ int op=(presetEl.tagName().remove(OSWSTR, Qt::CaseSensitive)).toInt()-1;
+ oscWave[op]=(presetEl.text()=="W1"? W1:
+ (presetEl.text()=="W2"?W2:
+ (presetEl.text()=="W3"?W3:
+ (presetEl.text()=="W4"?W4:
+ (presetEl.text()=="W5"?W5:
+ (presetEl.text()=="W6"?W6:
+ (presetEl.text()=="W7"?W7:W8)))))));
+
+ }
+ //detune
+ else if(presetEl.tagName().contains(DETSTR, Qt::CaseSensitive)) {
+ int op=(presetEl.tagName().remove(DETSTR, Qt::CaseSensitive)).toInt()-1;
+ detune[op]=presetEl.text().toInt();
+ }
+ //eg
+ else if(presetEl.tagName()=="eg") {
+ QDomNode egNode = presetNode.firstChild();
+ while(!egNode.isNull()) {
+ QDomElement egEl = egNode.toElement();
+ if (egEl.isNull())
+ continue;
+ QString et=egEl.tagName();
+ if(et.contains(ARSTR, Qt::CaseSensitive)) {
+ int op=(et.remove(ARSTR, Qt::CaseSensitive)).toInt()-1;
+ eg[op].ar=egEl.text().toInt();
+ }
+ else if(et.contains(D1RSTR, Qt::CaseSensitive)) {
+ int op=(et.remove(D1RSTR, Qt::CaseSensitive)).toInt()-1;
+ eg[op].d1r=egEl.text().toInt();
+ }
+ else if(et.contains(D1LSTR, Qt::CaseSensitive)) {
+ int op = (et.remove(D1LSTR, Qt::CaseSensitive)).toInt()-1;
+ eg[op].d1l=egEl.text().toInt();
+ }
+ else if(et.contains(D2RSTR, Qt::CaseSensitive)) {
+ int op=(et.remove(D2RSTR, Qt::CaseSensitive)).toInt()-1;
+ eg[op].d2r=egEl.text().toInt();
+ }
+ else if(et.contains(RRSTR, Qt::CaseSensitive)) {
+ int op=(et.remove(RRSTR, Qt::CaseSensitive)).toInt()-1;
+ eg[op].rr=egEl.text().toInt();
+ }
+ else if(et.contains(SHFTSTR, Qt::CaseSensitive)) {
+ int op=(et.remove(SHFTSTR, Qt::CaseSensitive)).toInt()-1;
+ eg[op].egShift=(egEl.text()=="VOF"?VOF:
+ (egEl.text()=="V48"?V48:
+ (egEl.text()=="V24"?V24:V12)));
+ }
+ egNode =egNode.nextSibling();
+ }
+ }
+ //pitchEg
+ else if(presetEl.tagName()=="pitchEg") {
+ QDomNode pitchEgNode = presetNode.firstChild();
+ while(!pitchEgNode.isNull()) {
+ QDomElement pitchEgEl = pitchEgNode.toElement();
+ if (pitchEgEl.isNull())
+ continue;
+ QString pt=pitchEgEl.tagName();
+ if(pt==PR1STR) pitchEg.pr1=pitchEgEl.text().toInt();
+ else if(pt==PR2STR) pitchEg.pr2=pitchEgEl.text().toInt();
+ else if(pt==PR3STR) pitchEg.pr3=pitchEgEl.text().toInt();
+ else if(pt==PL1STR) pitchEg.pl1=pitchEgEl.text().toInt();
+ else if(pt==PL2STR) pitchEg.pl2=pitchEgEl.text().toInt();
+ else if(pt==PL3STR) pitchEg.pl3=pitchEgEl.text().toInt();
+ pitchEgNode=pitchEgNode.nextSibling();
+ }
+ }
+ //outLevel
+ else if(presetEl.tagName().contains(OUTSTR, Qt::CaseSensitive)) {
+ int op=(presetEl.tagName().remove(OUTSTR, Qt::CaseSensitive)).toInt()-1;
+ outLevel[op]=presetEl.text().toInt();
+ }
+ //scaling
+ else if(presetEl.tagName()=="scaling") {
+ QDomNode scalingNode = presetNode.firstChild();
+ while(!scalingNode.isNull()) {
+ QDomElement scalingEl = scalingNode.toElement();
+ if (scalingEl.isNull())
+ continue;
+ QString st=scalingEl.tagName();
+ if(st.contains(RSSTR, Qt::CaseSensitive)) {
+ int op=(st.remove(RSSTR, Qt::CaseSensitive)).toInt()-1;
+ scaling.rate[op]=scalingEl.text().toInt();
+ }
+ else if(st.contains(LSSTR, Qt::CaseSensitive)) {
+ int op=(st.remove(LSSTR, Qt::CaseSensitive)).toInt()-1;
+ scaling.level[op]=scalingEl.text().toInt();
+ }
+ scalingNode =scalingNode.nextSibling();
+ }
+ }
+ //function
+ else if(presetEl.tagName()=="function") {
+ QDomNode functionNode = presetNode.firstChild();
+ while(!functionNode.isNull()) {
+ QDomElement functionEl = functionNode.toElement();
+ if (functionEl.isNull())
+ continue;
+ QString ft=functionEl.tagName();
+ if(ft==TRANSPOSESTR)
+ function.transpose=functionEl.text().toInt();
+ else if(ft==POLYMODESTR)
+ function.mode=(functionEl.text()=="POLY"?POLY:MONO);
+ else if(ft==PBENDRANGESTR)
+ function.pBendRange=functionEl.text().toInt();
+ else if(ft==PORTAMODESTR)
+ function.portamento=
+ functionEl.text()=="FINGER"?FINGER:FULL;
+ else if(ft==PORTATIMESTR)
+ function.portamentoTime=functionEl.text().toInt();
+ else if(ft==FSWSTR)
+ function.footSw=(functionEl.text()=="POR"?POR:SUS);
+ else if(ft==FCVOLUMESTR)
+ function.fcVolume=functionEl.text().toInt();
+ else if(ft==FCPITCHSTR)
+ function.fcPitch=functionEl.text().toInt();
+ else if(ft==FCAMPLITUDESTR)
+ function.fcAmplitude=functionEl.text().toInt();
+ else if(ft==MWPITCHSTR)
+ function.mwPitch=functionEl.text().toInt();
+ else if(ft==MWAMPLITUDESTR)
+ function.mwAmplitude=functionEl.text().toInt();
+ else if(ft==BCPITCHSTR)
+ function.bcPitch=functionEl.text().toInt();
+ else if(ft==BCAMPLITUDESTR)
+ function.bcAmplitude=functionEl.text().toInt();
+ else if(ft==BCPITCHBIASSTR)
+ function.bcPitchBias=functionEl.text().toInt();
+ else if(ft==BCEGBIASSTR)
+ function.bcEgBias=functionEl.text().toInt();
+ else if(ft==ATPITCHSTR)
+ function.atPitch=functionEl.text().toInt();
+ else if(ft==ATAMPLITUDESTR)
+ function.atAmplitude=functionEl.text().toInt();
+ else if(ft==ATPITCHBIASSTR)
+ function.atPitchBias=functionEl.text().toInt();
+ else if(ft==ATEGBIASSTR)
+ function.atEgBias=functionEl.text().toInt();
+ else if(ft==REVERBRATESTR)
+ function.reverbRate=functionEl.text().toInt();
+ functionNode=functionNode.nextSibling();
+ }
+ }
+ //globalDetune
+ //else if(presetEl.tagName()=="globalDetune")
+ // globalDetune=presetEl.text().toInt();
+ //Names
+ else if(presetEl.tagName()=="name")
+ name=presetEl.text().ascii();
+ //prog
+ else if(presetEl.tagName()=="prog")
+ prog=presetEl.text().toInt();
+ presetNode = presetNode.nextSibling();
+ }
+}
+
+//---------------------------------------------------------
+// witePreset
+//---------------------------------------------------------
+void Preset::writePreset(Xml* xml, bool onlyUsed) {
+ char s[MAXCHARTAG];
+ if((!onlyUsed || _isUsed)) {
+ xml->tag(SUB_LEVEL, "deicsOnzePreset version=\"1.0\"");
+
+ //algorithm
+ xml->strTag(PRE_LEVEL, ALGSTR, (algorithm==FIRST? "FIRST":
+ (algorithm==SECOND? "SECOND":
+ (algorithm==THIRD? "THIRD":
+ (algorithm==FOURTH? "FOURTH":
+ (algorithm==FIFTH? "FIFTH":
+ (algorithm==SIXTH? "SIXTH":
+ (algorithm==SEVENTH? "SEVENTH":
+ "EIGHTH"))))))));
+ //feedback
+ xml->uintTag(PRE_LEVEL, FEEDBACKSTR, feedback);
+ //quick edit
+ //xml->tag(FINEBRIGHTNESSSTR, brightness);
+ //xml->tag(MODULATIONSTR, (int)modulation);
+ //xml->tag(GLOBALDETUNESTR, globalDetune);
+ //xml->tag(ATTACKSTR, attack);
+ //xml->tag(RELEASESTR, release);
+ //lfo
+ xml->tag(PRE_LEVEL, "lfo");
+ xml->strTag(PRE_LEVEL + 1, WAVESTR,
+ (lfo.wave==SAWUP? "SAWUP":
+ (lfo.wave==SQUARE? "SQUARE":
+ (lfo.wave==TRIANGL? "TRIANGL":"SHOLD"))));
+ xml->uintTag(PRE_LEVEL + 1, SPEEDSTR, lfo.speed);
+ xml->uintTag(PRE_LEVEL + 1, DELAYSTR, lfo.delay);
+ xml->uintTag(PRE_LEVEL + 1, PMODDEPTHSTR, lfo.pModDepth);
+ xml->uintTag(PRE_LEVEL + 1, AMODDEPTHSTR, lfo.aModDepth);
+ xml->strTag(PRE_LEVEL + 1, SYNCSTR, (lfo.sync==true? "on":"off"));
+ xml->etag(PRE_LEVEL, "lfo");
+ //sensitivity
+ xml->tag(PRE_LEVEL, "sensitivity");
+ xml->uintTag(PRE_LEVEL + 1, PMODSENSSTR, sensitivity.pitch);
+ xml->uintTag(PRE_LEVEL + 1, AMSSTR, sensitivity.amplitude);
+ for(int i=0; i<NBROP; i++) {
+ sprintf(s, AMESTR "%d",i+1);
+ xml->strTag(PRE_LEVEL + 1, s,
+ (sensitivity.ampOn[i]==true? "on":"off"));
+ }
+ for(int i=0; i<NBROP; i++) {
+ sprintf(s,EBSSTR "%d",i+1);
+ xml->uintTag(PRE_LEVEL + 1, s, sensitivity.egBias[i]);
+ }
+ for(int i=0; i<NBROP; i++) {
+ sprintf(s, KVSSTR "%d",i+1);
+ xml->uintTag(PRE_LEVEL + 1, s, sensitivity.keyVelocity[i]);
+ }
+ xml->etag(PRE_LEVEL, "sensitivity");
+ //frequency
+ xml->tag(PRE_LEVEL, "frequency");
+ for(int i=0; i<NBROP; i++) {
+ sprintf(s, RATIOSTR "%d",i+1);
+ xml->doubleTag(PRE_LEVEL + 1, s, frequency[i].ratio);
+ }
+ for(int i=0; i<NBROP; i++) {
+ sprintf(s, FIXSTR "%d",i+1);
+ xml->strTag(PRE_LEVEL + 1, s, (frequency[i].isFix==true? "yes":"no"));
+ }
+ for(int i=0; i<NBROP; i++) {
+ sprintf(s, FIXRANGESTR "%d",i+1);
+ xml->doubleTag(PRE_LEVEL + 1, s, frequency[i].freq);
+ }
+ xml->etag(PRE_LEVEL, "frequency");
+ //oscWave
+ for(int i=0; i<NBROP; i++) {
+ sprintf(s, OSWSTR "%d",i+1);
+ xml->strTag(PRE_LEVEL, s, (oscWave[i]==W1?"W1":
+ (oscWave[i]==W2?"W2":
+ (oscWave[i]==W3?"W3":
+ (oscWave[i]==W4?"W4":
+ (oscWave[i]==W5?"W5":
+ (oscWave[i]==W6?"W6":
+ (oscWave[i]==W7?"W7":"W8"))))))));
+ }
+ //detune
+ for(int i=0; i<NBROP; i++) {
+ sprintf(s, DETSTR "%d",i+1);
+ xml->intTag(PRE_LEVEL, s, detune[i]);
+ }
+ //eg
+ xml->tag(PRE_LEVEL, "eg");
+ for(int i=0; i<NBROP; i++) {
+ sprintf(s, ARSTR "%d",i+1);
+ xml->uintTag(PRE_LEVEL + 1, s, eg[i].ar);
+ }
+ for(int i=0; i<NBROP; i++) {
+ sprintf(s, D1RSTR "%d",i+1);
+ xml->uintTag(PRE_LEVEL + 1, s, eg[i].d1r);
+ }
+ for(int i=0; i<NBROP; i++) {
+ sprintf(s, D1LSTR "%d",i+1);
+ xml->uintTag(PRE_LEVEL + 1, s, eg[i].d1l);
+ }
+ for(int i=0; i<NBROP; i++) {
+ sprintf(s, D2RSTR "%d",i+1);
+ xml->uintTag(PRE_LEVEL + 1, s, eg[i].d2r);
+ }
+ for(int i=0; i<NBROP; i++) {
+ sprintf(s, RRSTR "%d",i+1);
+ xml->uintTag(PRE_LEVEL + 1, s, eg[i].rr);
+ }
+ for(int i=0; i<NBROP; i++) {
+ sprintf(s, SHFTSTR "%d",i+1);
+ xml->strTag(PRE_LEVEL + 1, s, (eg[i].egShift==VOF?"VOF":
+ (eg[i].egShift==V48?"V48":
+ (eg[i].egShift==V24?"V24":"V12"))));
+ }
+ xml->etag(PRE_LEVEL, "eg");
+ //pitchEg
+ xml->tag(PRE_LEVEL, "pitchEg");
+ xml->uintTag(PRE_LEVEL + 1, PR1STR,pitchEg.pr1);
+ xml->uintTag(PRE_LEVEL + 1, PR2STR,pitchEg.pr2);
+ xml->uintTag(PRE_LEVEL + 1, PR3STR,pitchEg.pr3);
+ xml->uintTag(PRE_LEVEL + 1, PL1STR,pitchEg.pl1);
+ xml->uintTag(PRE_LEVEL + 1, PL2STR,pitchEg.pl2);
+ xml->uintTag(PRE_LEVEL + 1, PL3STR,pitchEg.pl3);
+ xml->etag(PRE_LEVEL, "pitchEg");
+ //outLevel
+ for(int i=0; i<NBROP; i++) {
+ sprintf(s, OUTSTR "%d",i+1);
+ xml->uintTag(PRE_LEVEL, s, outLevel[i]);
+ }
+ //scaling
+ xml->tag(PRE_LEVEL, "scaling");
+ for(int i=0; i<NBROP; i++) {
+ sprintf(s, RSSTR "%d",i+1);
+ xml->uintTag(PRE_LEVEL + 1, s, scaling.rate[i]);
+ }
+ for(int i=0; i<NBROP; i++) {
+ sprintf(s, LSSTR "%d",i+1);
+ xml->uintTag(PRE_LEVEL + 1, s, scaling.level[i]);
+ }
+ xml->etag(PRE_LEVEL, "scaling");
+ //function
+ xml->tag(PRE_LEVEL, "function");
+ xml->intTag(PRE_LEVEL + 1, TRANSPOSESTR, function.transpose);
+ xml->strTag(PRE_LEVEL + 1, POLYMODESTR,
+ (function.mode==POLY? "POLY":"MONO"));
+ xml->uintTag(PRE_LEVEL + 1, PBENDRANGESTR, function.pBendRange);
+ xml->strTag(PRE_LEVEL + 1, PORTAMODESTR,
+ (function.portamento==FINGER? "FINGER":"FULL"));
+ xml->uintTag(PRE_LEVEL + 1, PORTATIMESTR, function.portamentoTime);
+ xml->strTag(PRE_LEVEL + 1, FSWSTR, (function.footSw==POR? "POR":"SUS"));
+ xml->uintTag(PRE_LEVEL + 1, FCVOLUMESTR, function.fcVolume);
+ xml->uintTag(PRE_LEVEL + 1, FCPITCHSTR, function.fcPitch);
+ xml->uintTag(PRE_LEVEL + 1, FCAMPLITUDESTR, function.fcAmplitude);
+ xml->uintTag(PRE_LEVEL + 1, MWPITCHSTR, function.mwPitch);
+ xml->uintTag(PRE_LEVEL + 1, MWAMPLITUDESTR, function.mwAmplitude);
+ xml->uintTag(PRE_LEVEL + 1, BCPITCHSTR, function.bcPitch);
+ xml->uintTag(PRE_LEVEL + 1, BCAMPLITUDESTR, function.bcAmplitude);
+ xml->intTag(PRE_LEVEL + 1, BCPITCHBIASSTR, function.bcPitchBias);
+ xml->uintTag(PRE_LEVEL + 1, BCEGBIASSTR, function.bcEgBias);
+ xml->uintTag(PRE_LEVEL + 1, ATPITCHSTR, function.atPitch);
+ xml->uintTag(PRE_LEVEL + 1, ATAMPLITUDESTR, function.atAmplitude);
+ xml->intTag(PRE_LEVEL + 1, ATPITCHBIASSTR, function.atPitchBias);
+ xml->uintTag(PRE_LEVEL + 1, ATEGBIASSTR, function.atEgBias);
+ xml->intTag(PRE_LEVEL + 1, REVERBRATESTR, function.reverbRate);
+ xml->etag(PRE_LEVEL, "function");
+ //globalDetune
+ //xml->tag("globalDetune", globalDetune);
+ //preset name
+ xml->strTag(PRE_LEVEL, "name", name.c_str());
+ //bank prog
+ xml->intTag(PRE_LEVEL, "prog", prog);
+
+ xml->etag(SUB_LEVEL, "deicsOnzePreset");
+ }
+}
+
+//---------------------------------------------------------
+// printPreset
+//---------------------------------------------------------
+
+void Preset::printPreset()
+{
+ printf("\n");
+ printf("Algorithm : %d, Feedback : %d\n", algorithm, feedback);
+ printf("LFO : ");
+ switch(lfo.wave)
+ {
+ case(SAWUP) : printf("SAWUP ,"); break;
+ case(SQUARE) : printf("SQUARE ,"); break;
+ case(TRIANGL) : printf("TRIANGL ,"); break;
+ case(SHOLD) : printf("SHOLD ,"); break;
+ default : printf("No defined, "); break;
+ }
+ printf("Speed : %d, Delay : %d, PModD : %d, AModD : %d, ",
+ lfo.speed, lfo.delay, lfo.pModDepth, lfo.aModDepth);
+ if(lfo.sync) printf("Sync\n"); else printf("Not Sync\n");
+ printf("LFO Pitch Sensitivity : %d, LFO Amplitude Sensitivity : %d\n",
+ sensitivity.pitch, sensitivity.amplitude);
+ for(int i=0; i<NBROP; i++)
+ {
+ printf("amp%d ",i+1);
+ if(sensitivity.ampOn) printf("ON "); else printf("OFF ");
+ }
+ printf("\n");
+ for(int i=0; i<NBROP; i++)
+ printf("EgBias%d : %d ",i+1, sensitivity.egBias[i]);
+ printf("\n");
+ for(int i=0; i<NBROP; i++)
+ printf("KVS%d : %d ",i+1, sensitivity.keyVelocity[i]);
+ printf("\n");
+ for(int i=0; i<NBROP; i++)
+ {
+ if(frequency[i].isFix)
+ printf("Freq%d : %f ",i+1, frequency[i].ratio);
+ else printf("Ratio%d : %f ",i+1, frequency[i].ratio);
+ }
+ printf("\n");
+ for(int i=0; i<NBROP; i++)
+ {
+ printf("OscWave%d ", i+1);
+ switch(oscWave[i])
+ {
+ case(W1) : printf("W1 "); break;
+ case(W2) : printf("W2 "); break;
+ case(W3) : printf("W3 "); break;
+ case(W4) : printf("W4 "); break;
+ case(W5) : printf("W5 "); break;
+ case(W6) : printf("W6 "); break;
+ case(W7) : printf("W7 "); break;
+ case(W8) : printf("W8 "); break;
+ default : printf("No defined "); break;
+ }
+ }
+ printf("\n");
+ for(int i=0; i<NBROP; i++)
+ printf("Detune%d : %d ",i+1, detune[i]);
+ printf("\n");
+ for(int i=0; i<NBROP; i++)
+ {
+ printf("AR%d : %d, D1R%d : %d, D1L%d : %d, D2R%d : %d, RR%d : %d, EgShift%d : ",
+ i+1, eg[i].ar, i+1, eg[i].d1r,
+ i+1, eg[i].d1l, i+1, eg[i].d2r, i+1, eg[i].rr, i+1);
+ switch(eg[i].egShift)
+ {
+ case(VOF) : printf("VOF");
+ case(V48) : printf("48");
+ case(V24) : printf("24");
+ case(V12) : printf("12");
+ }
+ printf("\n");
+ }
+ printf("PitchEg pr1 : %d, pr2 : %d, pr3 : %d, pl1 : %d, pl2 : %d, pl3 : %d"
+ , pitchEg.pr1, pitchEg.pr2, pitchEg.pr3,
+ pitchEg.pl1, pitchEg.pl2, pitchEg.pl3);
+ printf("\n");
+ for(int i=0; i<NBROP; i++)
+ printf("OutLevel%d : %d ",i+1, outLevel[i]);
+ printf("\n");
+ printf("Name : %s\n", name.c_str());
+}
+
+void Subcategory::printSubcategory() {
+ std::cout << " " << _subcategoryName << "\n";
+ for(std::vector<Preset*>::iterator i=_presetVector.begin();
+ i!=_presetVector.end(); i++) (*i)->printPreset();
+}
+
+void Category::printCategory() {
+ std::cout << " " << _categoryName << "\n";
+ for(unsigned int i=0; i<_subcategoryVector.size(); i++)
+ _subcategoryVector[i]->printSubcategory();
+}
+
+void Set::printSet() {
+ std::cout << _setName << "\n";
+ for(unsigned int i=0; i<_categoryVector.size(); i++)
+ _categoryVector[i]->printCategory();
+}