1 //===========================================================================
2 //
3 // DeicsOnze an emulator of the YAMAHA DX11 synthesizer
4 //
5 // Version 0.5.5
6 //
7 // deicsonzepreset.cpp
8 //
9 //
10 // Copyright (c) 2004-2006 Nil Geisweiller
11 //
12 //
13 //
14 // This program is free software; you can redistribute it and/or
15 // modify it under the terms of the GNU General Public License
16 // as published by the Free Software Foundation; either version 2
17 // of the License, or (at your option) any later version.
18 //
19 // This program is distributed in the hope that it will be useful,
20 // but WITHOUT ANY WARRANTY; without even the implied warranty of
21 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 // GNU General Public License for more details.
23 //
24 // You should have received a copy of the GNU General Public License
25 // along with this program; if not, write to the Free Software
26 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
27 // 02111-1301, USA or point your web browser to http://www.gnu.org.
28 //===========================================================================
29
30 #include "deicsonzepreset.h"
31 #include <iostream>
32 #include <algorithm>
33
34 #include <QDomElement>
35
36 //-----------------------------------------------------------
37 // Constructor destructor
38 //-----------------------------------------------------------
Preset()39 Preset::Preset() {_subcategory=NULL;_isUsed=false;initPreset();}
Preset(Subcategory * sub)40 Preset::Preset(Subcategory* sub) {
41 _subcategory=sub;
42 _isUsed=false;
43 initPreset();
44 if(sub) sub->_presetVector.push_back(this);
45 }
Preset(Subcategory * sub,int pr)46 Preset::Preset(Subcategory* sub, int pr) {
47 _subcategory=sub;
48 _isUsed=false;
49 initPreset();
50 prog=pr;
51 if(sub) sub->_presetVector.push_back(this);
52 }
~Preset()53 Preset::~Preset() {
54 if(_subcategory) {
55 std::vector<Preset*>::iterator iB=_subcategory->_presetVector.begin();
56 std::vector<Preset*>::iterator iE=_subcategory->_presetVector.end();
57 std::vector<Preset*>::iterator iP=std::find(iB, iE, this);
58 if(iP!=iE) _subcategory->_presetVector.erase(iP);
59 else printf("Error : preset %s not found\n", name.c_str());
60 }
61 }
62 //----------------------------------------------------------
63 // setIsUsed(bool b)
64 // set the flag _isUsed and transmit in the parents
65 //----------------------------------------------------------
setIsUsed(bool b)66 void Preset::setIsUsed(bool b) {
67 if(!_isUsed) {
68 _isUsed=b;
69 if(_subcategory) {
70 _subcategory->_isUsed=b;
71 if(_subcategory->_category) {
72 _subcategory->_category->_isUsed=b;
73 }
74 }
75 }
76 }
77 //----------------------------------------------------------
78 // getHBankLBankProg
79 // return the hbank, lbank and prog of the preset
80 // warning : if there is not subcategory of category
81 // the value l or h are let unchanged
82 //----------------------------------------------------------
getHBankLBankProg(int * h,int * l,int * p)83 void Preset::getHBankLBankProg(int* h, int* l, int* p) {
84 *p = prog;
85 if(_subcategory) {
86 *l = _subcategory->_lbank;
87 if(_subcategory->_category) *h = _subcategory->_category->_hbank;
88 }
89 }
90 //----------------------------------------------------------
91 // linkSubcategory
92 // links the preset to a subcategory parent and erase itself
93 // from the last subcategory if not NULL
94 //----------------------------------------------------------
linkSubcategory(Subcategory * sub)95 void Preset::linkSubcategory(Subcategory* sub) {
96 if(_subcategory) {
97 std::vector<Preset*> pv=_subcategory->_presetVector;
98 std::vector<Preset*>::iterator iP=find(pv.begin(),pv.end(),this);
99 if(iP!=pv.end()) pv.erase(iP);
100 else printf("Error linkSubcategory: preset %s not found\n",
101 name.c_str());
102 }
103 _subcategory=sub;
104 if(sub) sub->_presetVector.push_back(this);
105 }
106 //----------------------------------------------------------
107 // linkCategory
108 // links the subcategory to a category parent and erase itself
109 // from the last category if not NULL
110 //----------------------------------------------------------
linkCategory(Category * cat)111 void Subcategory::linkCategory(Category* cat) {
112 if(_category) {
113 std::vector<Subcategory*> sv=_category->_subcategoryVector;
114 std::vector<Subcategory*>::iterator iS=find(sv.begin(),sv.end(),this);
115 if(iS!=sv.end()) sv.erase(iS);
116 else printf("Error linkCategory: preset %s not found\n",
117 _subcategoryName.c_str());
118 }
119 _category=cat;
120 if(cat) cat->_subcategoryVector.push_back(this);
121 }
122
123
124 //----------------------------------------------------------
125 // linkSet
126 // links the category to a set parent (there is always only one set)
127 //----------------------------------------------------------
linkSet(Set * s)128 void Category::linkSet(Set* s) {
129 _set=s;
130 if(s) s->_categoryVector.push_back(this);
131 }
132
133 //----------------------------------------------------------
134 // Subcategory constructor and destruction
135 //----------------------------------------------------------
Subcategory()136 Subcategory::Subcategory() {_category=NULL;}
Subcategory(Category * cat)137 Subcategory::Subcategory(Category* cat) {
138 _category=cat;
139 _isUsed=false;
140 if(cat) cat->_subcategoryVector.push_back(this);
141 }
Subcategory(const std::string name)142 Subcategory::Subcategory(const std::string name) {
143 _category=NULL;
144 _isUsed=false;
145 _subcategoryName=name;
146 }
Subcategory(Category * cat,const std::string name,int lbank)147 Subcategory::Subcategory(Category* cat, const std::string name, int lbank) {
148 _category=cat;
149 _isUsed=false;
150 _subcategoryName=name;
151 _lbank=lbank;
152 if(cat) cat->_subcategoryVector.push_back(this);
153 }
~Subcategory()154 Subcategory::~Subcategory() {
155 while(!_presetVector.empty()) delete(*_presetVector.begin());
156 if(_category) {
157 std::vector<Subcategory*>::iterator
158 iB=_category->_subcategoryVector.begin();
159 std::vector<Subcategory*>::iterator
160 iE=_category->_subcategoryVector.end();
161 std::vector<Subcategory*>::iterator iS=std::find(iB, iE, this);
162 if(iS!=iE) _category->_subcategoryVector.erase(iS);
163 else printf("Error : subcategory %s not found\n",
164 _subcategoryName.c_str());
165 }
166 }
167
168 //--------------------------------------------------------
169 // Category constructor destructor
170 //--------------------------------------------------------
Category()171 Category::Category() {_set=NULL;_isUsed=false;}
Category(Set * s)172 Category::Category(Set* s) {
173 _set=s;
174 _isUsed=false;
175 if(s) s->_categoryVector.push_back(this);
176 }
Category(Set * s,const std::string name,int hbank)177 Category::Category(Set* s,const std::string name, int hbank) {
178 _set=s;
179 _isUsed=false;
180 _categoryName=name;
181 _hbank=hbank;
182 if(s) s->_categoryVector.push_back(this);
183 }
~Category()184 Category::~Category() {
185 while(!_subcategoryVector.empty()) delete(*_subcategoryVector.begin());
186 if(_set) {
187 std::vector<Category*>::iterator iB=_set->_categoryVector.begin();
188 std::vector<Category*>::iterator iE=_set->_categoryVector.end();
189 std::vector<Category*>::iterator iC=std::find(iB, iE, this);
190 if(iC!=iE) _set->_categoryVector.erase(iC);
191 else printf("Error : category %s not found\n", _categoryName.c_str());
192 }
193 }
194
195 //---------------------------------------------------------
196 // initPreset
197 // put the preset in the initial state as defined by YAMAHA
198 //---------------------------------------------------------
initPreset()199 void Preset::initPreset() {
200 //algorithm
201 algorithm=FIRST;
202 //feedeback
203 feedback=0;
204 //lfo
205 lfo.wave=TRIANGL;
206 lfo.speed=35;
207 lfo.delay=0;
208 lfo.pModDepth=0;
209 lfo.aModDepth=0;
210 lfo.sync=false;
211 //sensitivity
212 sensitivity.pitch=6;
213 sensitivity.amplitude=0;
214 sensitivity.ampOn[0]=false;
215 sensitivity.ampOn[1]=false;
216 sensitivity.ampOn[2]=false;
217 sensitivity.ampOn[3]=false;
218 sensitivity.egBias[0]=0;
219 sensitivity.egBias[1]=0;
220 sensitivity.egBias[2]=0;
221 sensitivity.egBias[3]=0;
222 sensitivity.keyVelocity[0]=0;
223 sensitivity.keyVelocity[1]=0;
224 sensitivity.keyVelocity[2]=0;
225 sensitivity.keyVelocity[3]=0;
226 //frequency
227 frequency[0].ratio=1.0;
228 frequency[1].ratio=1.0;
229 frequency[2].ratio=1.0;
230 frequency[3].ratio=1.0;
231 frequency[0].isFix=false;
232 frequency[1].isFix=false;
233 frequency[2].isFix=false;
234 frequency[3].isFix=false;
235 frequency[0].freq=255.0;
236 frequency[1].freq=255.0;
237 frequency[2].freq=255.0;
238 frequency[3].freq=255.0;
239 //oscWave
240 oscWave[0]=W1;
241 oscWave[1]=W1;
242 oscWave[2]=W1;
243 oscWave[3]=W1;
244 //detune
245 detune[0]=0;
246 detune[1]=0;
247 detune[2]=0;
248 detune[3]=0;
249 //eg
250 eg[0].ar=31;
251 eg[1].ar=31;
252 eg[2].ar=31;
253 eg[3].ar=31;
254 eg[0].d1r=31;
255 eg[1].d1r=31;
256 eg[2].d1r=31;
257 eg[3].d1r=31;
258 eg[0].d1l=15;
259 eg[1].d1l=15;
260 eg[2].d1l=15;
261 eg[3].d1l=15;
262 eg[0].d2r=0;
263 eg[1].d2r=0;
264 eg[2].d2r=0;
265 eg[3].d2r=0;
266 eg[0].rr=15;
267 eg[1].rr=15;
268 eg[2].rr=15;
269 eg[3].rr=15;
270 eg[0].egShift=VOF;
271 eg[1].egShift=VOF;
272 eg[2].egShift=VOF;
273 eg[3].egShift=VOF;
274 //pitchEg
275 pitchEg.pr1=99;
276 pitchEg.pr2=99;
277 pitchEg.pr3=99;
278 pitchEg.pl1=50;
279 pitchEg.pl2=50;
280 pitchEg.pl3=50;
281 //outLevel
282 outLevel[0]=90;
283 outLevel[1]=0;
284 outLevel[2]=0;
285 outLevel[3]=0;
286 //scaling
287 scaling.rate[0]=0;
288 scaling.rate[1]=0;
289 scaling.rate[2]=0;
290 scaling.rate[3]=0;
291 scaling.level[0]=0;
292 scaling.level[1]=0;
293 scaling.level[2]=0;
294 scaling.level[3]=0;
295 //function
296 function.transpose=0;
297 function.mode=POLY;
298 function.pBendRange=4;
299 function.portamento=FULL;
300 function.portamentoTime=0;
301 function.fcVolume=40;
302 function.fcPitch=0;
303 function.fcAmplitude=0;
304 function.mwPitch=50;
305 function.mwAmplitude=0;
306 function.bcPitch=0;
307 function.bcAmplitude=0;
308 function.bcPitchBias=0;
309 function.bcEgBias=0;
310 function.atPitch=0;
311 function.atAmplitude=0;
312 function.atPitchBias=0;
313 function.atEgBias=0;
314 function.reverbRate=0;
315 //globalDetune=0;
316 //Name
317 name="INITVOICE";
318 }
319 //---------------------------------------------------------
320 // Preset::merge
321 // copy the preset
322 //---------------------------------------------------------
merge(Preset * p)323 void Preset::merge(Preset* p) {
324 if(p) {
325 //algorithm
326 algorithm=p->algorithm;
327 //feedeback
328 feedback=p->feedback;
329 //lfo
330 lfo.wave=p->lfo.wave;
331 lfo.speed=p->lfo.speed;
332 lfo.delay=p->lfo.delay;
333 lfo.pModDepth=p->lfo.pModDepth;
334 lfo.aModDepth=p->lfo.aModDepth;
335 lfo.sync=p->lfo.sync;
336 //sensitivity
337 sensitivity.pitch=p->sensitivity.pitch;
338 sensitivity.amplitude=p->sensitivity.amplitude;
339 for(int k=0; k<NBROP; k++) {
340 sensitivity.ampOn[k]=p->sensitivity.ampOn[k];
341 sensitivity.egBias[k]=p->sensitivity.egBias[k];
342 sensitivity.keyVelocity[k]=p->sensitivity.keyVelocity[k];
343 //frequency
344 frequency[k].ratio=p->frequency[k].ratio;
345 frequency[k].isFix=p->frequency[k].isFix;
346 frequency[k].freq=p->frequency[k].freq;
347 //oscWave
348 oscWave[k]=p->oscWave[k];
349 //detune
350 detune[k]=p->detune[k];
351 //eg
352 eg[k].ar=p->eg[k].ar;
353 eg[k].d1r=p->eg[k].d1r;
354 eg[k].d1l=p->eg[k].d1l;
355 eg[k].d2r=p->eg[k].d2r;
356 eg[k].rr=p->eg[k].rr;
357 eg[k].egShift=p->eg[k].egShift;
358 //outLevel
359 outLevel[k]=p->outLevel[k];
360 //scaling
361 scaling.rate[k]=p->scaling.rate[k];
362 scaling.level[k]=p->scaling.level[k];
363 }
364 //pitchEg
365 pitchEg.pr1=p->pitchEg.pr1;
366 pitchEg.pr2=p->pitchEg.pr2;
367 pitchEg.pr3=p->pitchEg.pr3;
368 pitchEg.pl1=p->pitchEg.pl1;
369 pitchEg.pl2=p->pitchEg.pl2;
370 pitchEg.pl3=p->pitchEg.pl3;
371 //function
372 function.transpose=p->function.transpose;
373 function.mode=p->function.mode;
374 function.pBendRange=p->function.pBendRange;
375 function.portamento=p->function.portamento;
376 function.portamentoTime=p->function.portamentoTime;
377 function.fcVolume=p->function.fcVolume;
378 function.fcPitch=p->function.fcPitch;
379 function.fcAmplitude=p->function.fcAmplitude;
380 function.mwPitch=p->function.mwPitch;
381 function.mwAmplitude=p->function.mwAmplitude;
382 function.bcPitch=p->function.bcPitch;
383 function.bcAmplitude=p->function.bcAmplitude;
384 function.bcPitchBias=p->function.bcPitchBias;
385 function.bcEgBias=p->function.bcEgBias;
386 function.atPitch=p->function.atPitch;
387 function.atAmplitude=p->function.atAmplitude;
388 function.atPitchBias=p->function.atPitchBias;
389 function.atEgBias=p->function.atEgBias;
390 function.reverbRate=p->function.reverbRate;
391 //globalDetune=p->globalDetune;
392 //Name
393 name=p->name;
394 }
395 }
396 //---------------------------------------------------------
397 // findPreset
398 // return the first preset corresponding of hbank, lbank, prog
399 //---------------------------------------------------------
findPreset(int prog)400 Preset* Subcategory::findPreset(int prog) {
401 std::vector<Preset*>::iterator pvi;
402 for(pvi=_presetVector.begin(); pvi!=_presetVector.end(); pvi++) {
403 if((*pvi)->prog==prog) return(*pvi);
404 }
405 return NULL;
406 }
findPreset(int lbank,int prog)407 Preset* Category::findPreset(int lbank, int prog) {
408 Subcategory* s=findSubcategory(lbank);
409 if(s) {
410 Preset* p=s->findPreset(prog);
411 if(p) return(p);
412 }
413 return(NULL);
414 }
findPreset(int hbank,int lbank,int prog)415 Preset* Set::findPreset(int hbank, int lbank, int prog) {
416 Category* c=findCategory(hbank);
417 if(c) {
418 Preset* p=c->findPreset(lbank, prog);
419 if(p) return(p);
420 }
421 return NULL;
422 }
423
424 //---------------------------------------------------------
425 // isFreeHBank, firstFreeHBank -1 otherwise
426 //---------------------------------------------------------
isFreeHBank(int hbank)427 bool Set::isFreeHBank(int hbank) {
428 if(findCategory(hbank)) return(false);
429 else return(true);
430 }
firstFreeHBank()431 int Set::firstFreeHBank() {
432 for(int hbank=0; hbank<128; hbank++) if(isFreeHBank(hbank)) return(hbank);
433 return(-1);
434 }
435 //--------------------------------------------------------------
436 // Set::merge
437 //--------------------------------------------------------------
merge(Category * c)438 void Set::merge(Category* c) {
439 if(isFreeHBank(c->_hbank)) c->linkSet(this);
440 else {
441 Category* cFromSet=findCategory(c->_hbank);
442 cFromSet->_categoryName=c->_categoryName;
443 for(std::vector<Subcategory*>::iterator
444 i=c->_subcategoryVector.begin();
445 i!=c->_subcategoryVector.end(); i++) cFromSet->merge(*i);
446 //delete(c);
447 }
448 }
449
isFreeLBank(int lbank)450 bool Category::isFreeLBank(int lbank) {
451 if(findSubcategory(lbank)) return(false);
452 else return(true);
453 }
firstFreeLBank()454 int Category::firstFreeLBank() {
455 for(int lbank=0; lbank<128; lbank++) if(isFreeLBank(lbank)) return(lbank);
456 return(-1);
457 }
458 //--------------------------------------------------------------
459 // Category::merge
460 //--------------------------------------------------------------
merge(Subcategory * s)461 void Category::merge(Subcategory* s) {
462 if(isFreeLBank(s->_lbank)) s->linkCategory(this);
463 else {
464 Subcategory* sFromCat=findSubcategory(s->_lbank);
465 sFromCat->_subcategoryName=s->_subcategoryName;
466 for(std::vector<Preset*>::iterator
467 i=s->_presetVector.begin();
468 i!=s->_presetVector.end(); i++) sFromCat->merge(*i);
469 //delete(s);
470 }
471 }
472 //---------------------------------------------------------
473 // Category::unlink
474 // unlink the subcategories, so don't delete them when delete
475 //---------------------------------------------------------
unlink()476 void Category::unlink() {
477 while(!_subcategoryVector.empty())
478 _subcategoryVector.erase(_subcategoryVector.begin());
479 }
480
isFreeProg(int pr)481 bool Subcategory::isFreeProg(int pr) {
482 if(findPreset(pr)) return(false);
483 else return(true);
484 }
firstFreeProg()485 int Subcategory::firstFreeProg() {
486 for(int pr=0; pr<128; pr++) if(isFreeProg(pr)) return(pr);
487 return(-1);
488 }
489 //---------------------------------------------------------
490 // Subcategory::unlink
491 // unlink the presets, so don't delete them when delete
492 //---------------------------------------------------------
unlink()493 void Subcategory::unlink() {
494 while(!_presetVector.empty()) _presetVector.erase(_presetVector.begin());
495 }
496
497 //---------------------------------------------------------
498 // findSubcategory
499 // take hbank and lbank and return the subcategory corresponding,
500 // NULL if doesn't exist
501 //---------------------------------------------------------
findSubcategory(int hbank,int lbank)502 Subcategory* Set::findSubcategory(int hbank, int lbank) {
503 Category* c = findCategory(hbank);
504 Subcategory* s;
505 if(c) {
506 s = c->findSubcategory(lbank);
507 return s;
508 }
509 else return NULL;
510 }
511
512 //---------------------------------------------------------
513 // findCategory
514 // takes hbank a category and return the first category,
515 // NULL if doesn't exist
516 //---------------------------------------------------------
findCategory(int hbank)517 Category* Set::findCategory(int hbank) {
518 std::vector<Category*>::iterator cvi;
519 for(cvi=_categoryVector.begin(); cvi!=_categoryVector.end(); cvi++)
520 if((*cvi)->_hbank==hbank) return(*cvi);
521 return(NULL);
522 }
523 //---------------------------------------------------------
524 // findSubcategory
525 // takes lbank a subcategory and return the subcategory
526 // NULL if doesn't exist
527 //---------------------------------------------------------
findSubcategory(int lbank)528 Subcategory* Category::findSubcategory(int lbank) {
529 std::vector<Subcategory*>::iterator svi;
530 for(svi=_subcategoryVector.begin(); svi!=_subcategoryVector.end(); svi++)
531 if((*svi)->_lbank==lbank) return(*svi);
532 return(NULL);
533 }
534 //--------------------------------------------------------------
535 // Subcategory::merge
536 //--------------------------------------------------------------
merge(Preset * p)537 void Subcategory::merge(Preset* p) {
538 if(isFreeProg(p->prog)) p->linkSubcategory(this);
539 else {
540 Preset* pFromSub=findPreset(p->prog);
541 pFromSub->merge(p);
542 }
543 }
544
545 //---------------------------------------------------------
546 // readSet
547 //---------------------------------------------------------
readSet(QDomNode setNode)548 void Set::readSet(QDomNode setNode) {
549 while(!setNode.isNull()) {
550 QDomElement setEl = setNode.toElement();
551 if (setEl.isNull())
552 continue;
553 if (setEl.tagName() == "setName")
554 _setName=setEl.text().toLatin1().data();
555 if (setEl.tagName() == "deicsOnzeCategory") {
556 //load category
557 QString version = setEl.attribute(QString("version"));
558 if (version == "1.0") {
559 Category* lCategory = new Category();
560 lCategory->readCategory(setNode.firstChild());
561 //printf("Ready to merge!\n");
562 merge(lCategory);
563 }
564 }
565 setNode = setNode.nextSibling();
566 }
567 }
568
569 //---------------------------------------------------------
570 // writeSet
571 //---------------------------------------------------------
writeSet(AL::Xml * xml,bool onlyUsed)572 void Set::writeSet(AL::Xml* xml, bool onlyUsed) {
573 xml->stag("deicsOnzeSet version=\"1.0\"");
574 xml->tag("setName", QString(_setName.c_str()));
575 for(std::vector<Category*>::iterator i=_categoryVector.begin();
576 i!=_categoryVector.end(); i++) (*i)->writeCategory(xml, onlyUsed);
577 xml->etag("deicsOnzeSet");
578 }
579
580 //---------------------------------------------------------
581 // readCategory
582 //---------------------------------------------------------
readCategory(QDomNode catNode)583 void Category::readCategory(QDomNode catNode) {
584 while(!catNode.isNull()) {
585 QDomElement catEl = catNode.toElement();
586 if (catEl.isNull())
587 continue;
588 if (catEl.tagName() == "categoryName")
589 _categoryName=catEl.text().toLatin1().data();
590 if (catEl.tagName() == "hbank")
591 _hbank=catEl.text().toInt();
592 if (catEl.tagName() == "deicsOnzeSubcategory") {
593 //load Subcategory
594 QString version = catEl.attribute(QString("version"));
595 if (version == "1.0") {
596 Subcategory* lSubcategory = new Subcategory(this);
597 lSubcategory->readSubcategory(catNode.firstChild());
598 }
599 }
600 catNode = catNode.nextSibling();
601 }
602 }
603
604 //---------------------------------------------------------
605 // writeCategory
606 //---------------------------------------------------------
writeCategory(AL::Xml * xml,bool onlyUsed)607 void Category::writeCategory(AL::Xml* xml, bool onlyUsed) {
608 if((!onlyUsed || _isUsed)) {
609 xml->stag("deicsOnzeCategory version=\"1.0\"");
610 xml->tag("categoryName", QString(_categoryName.c_str()));
611 xml->tag("hbank", _hbank);
612 for(std::vector<Subcategory*>::iterator i=_subcategoryVector.begin();
613 i!=_subcategoryVector.end(); i++)
614 (*i)->writeSubcategory(xml, onlyUsed);
615 xml->etag("deicsOnzeCategory");
616 }
617 }
618
619 //---------------------------------------------------------
620 // readSubcategory
621 //---------------------------------------------------------
readSubcategory(QDomNode subNode)622 void Subcategory::readSubcategory(QDomNode subNode) {
623 while(!subNode.isNull()) {
624 QDomElement subEl = subNode.toElement();
625 if (subEl.isNull())
626 continue;
627 if (subEl.tagName() == "subcategoryName")
628 _subcategoryName=subEl.text().toLatin1().data();
629 if (subEl.tagName() == "lbank")
630 _lbank=subEl.text().toInt();
631 if (subEl.tagName() == "deicsOnzePreset") {
632 //load preset
633 QString version = subEl.attribute(QString("version"));
634 if (version == "1.0") {
635 Preset* lPreset = new Preset(this);
636 lPreset->readPreset(subNode.firstChild());
637 }
638 }
639 subNode = subNode.nextSibling();
640 }
641 }
642
643 //---------------------------------------------------------
644 // writeSubcategory
645 //---------------------------------------------------------
writeSubcategory(AL::Xml * xml,bool onlyUsed)646 void Subcategory::writeSubcategory(AL::Xml* xml, bool onlyUsed) {
647 if((!onlyUsed || _isUsed)) {
648 xml->stag("deicsOnzeSubcategory version=\"1.0\"");
649 xml->tag("subcategoryName", QString(_subcategoryName.c_str()));
650 xml->tag("lbank", _lbank);
651 for(std::vector<Preset*>::iterator i=_presetVector.begin();
652 i!=_presetVector.end(); i++) (*i)->writePreset(xml, onlyUsed);
653 xml->etag("deicsOnzeSubcategory");
654 }
655 }
656
657 //---------------------------------------------------------
658 // readPreset
659 //---------------------------------------------------------
readPreset(QDomNode presetNode)660 void Preset::readPreset(QDomNode presetNode) {
661 while(!presetNode.isNull()) {
662 QDomElement presetEl = presetNode.toElement();
663 if (presetEl.isNull())
664 continue;
665 //algorithm
666 if(presetEl.tagName()==ALGSTR)
667 algorithm=(presetEl.text()=="FIRST"? FIRST:
668 (presetEl.text()=="SECOND"? SECOND:
669 (presetEl.text()=="THIRD"? THIRD:
670 (presetEl.text()=="FOURTH"? FOURTH:
671 (presetEl.text()=="FIFTH"? FIFTH:
672 (presetEl.text()=="SIXTH"? SIXTH:
673 (presetEl.text()=="SEVENTH"? SEVENTH:EIGHTH)))))));
674 //feedback
675 else if(presetEl.tagName()==FEEDBACKSTR)
676 feedback=presetEl.text().toInt();
677 //quick edit
678 //else if(presetEl.tagName()==FINEBRIGHTNESSSTR)
679 // brightness=presetEl.text().toInt();
680 //else if(presetEl.tagName()==MODULATIONSTR)
681 // modulation=(unsigned char)presetEl.text().toInt();
682 //else if(presetEl.tagName()==GLOBALDETUNESTR)
683 // globalDetune=presetEl.text().toInt();
684 //else if(presetEl.tagName()==ATTACKSTR)
685 // attack=presetEl.text().toInt();
686 //else if(presetEl.tagName()==RELEASESTR)
687 // release=presetEl.text().toInt();
688 //lfo
689 else if(presetEl.tagName()=="lfo") {
690 QDomNode lfoNode = presetNode.firstChild();
691 while(!lfoNode.isNull()) {
692 QDomElement lfoEl = lfoNode.toElement();
693 if (lfoEl.isNull())
694 continue;
695 if(lfoEl.tagName()==WAVESTR)
696 lfo.wave=(lfoEl.text()=="SAWUP"? SAWUP:
697 (lfoEl.text()=="SQUARE"? SQUARE:
698 (lfoEl.text()=="TRIANGL"? TRIANGL:SHOLD)));
699 else if(lfoEl.tagName()==SPEEDSTR)
700 lfo.speed=lfoEl.text().toInt();
701 else if(lfoEl.tagName()==DELAYSTR)
702 lfo.delay=lfoEl.text().toInt();
703 else if(lfoEl.tagName()==PMODDEPTHSTR)
704 lfo.pModDepth=lfoEl.text().toInt();
705 else if(lfoEl.tagName()==AMODDEPTHSTR)
706 lfo.aModDepth=lfoEl.text().toInt();
707 else if(lfoEl.tagName()==SYNCSTR)
708 lfo.sync=(lfoEl.text()=="on"? true:false);
709 lfoNode = lfoNode.nextSibling();
710 }
711 }
712 //sensitivity
713 else if(presetEl.tagName()=="sensitivity") {
714 QDomNode sensitivityNode = presetNode.firstChild();
715 while(!sensitivityNode.isNull()) {
716 QDomElement sensitivityEl = sensitivityNode.toElement();
717 if (sensitivityEl.isNull())
718 continue;
719 QString st=sensitivityEl.tagName();
720 if(st==PMODSENSSTR)
721 sensitivity.pitch=sensitivityEl.text().toInt();
722 else if(st==AMSSTR)
723 sensitivity.amplitude=sensitivityEl.text().toInt();
724 else if(st.contains(AMESTR, Qt::CaseSensitive)) {
725 int op = (st.remove(AMESTR, Qt::CaseSensitive)).toInt()-1;
726 sensitivity.ampOn[op]=(sensitivityEl.text()=="on"? true:false);
727 }
728 else if(st.contains(EBSSTR, Qt::CaseSensitive)) {
729 int op = (st.remove(EBSSTR, Qt::CaseSensitive)).toInt()-1;
730 sensitivity.egBias[op]=sensitivityEl.text().toInt();
731 }
732 else if(st.contains(KVSSTR, Qt::CaseSensitive)) {
733 int op = (st.remove(KVSSTR, Qt::CaseSensitive)).toInt()-1;
734 sensitivity.keyVelocity[op]=sensitivityEl.text().toInt();
735 }
736 sensitivityNode =sensitivityNode.nextSibling();
737 }
738 }
739 //frequency
740 else if(presetEl.tagName()=="frequency") {
741 QDomNode frequencyNode = presetNode.firstChild();
742 while(!frequencyNode.isNull()) {
743 QDomElement frequencyEl = frequencyNode.toElement();
744 if (frequencyEl.isNull())
745 continue;
746 QString ft = frequencyEl.tagName();
747 if(ft.contains(RATIOSTR, Qt::CaseSensitive)) {
748 int op = (ft.remove(RATIOSTR, Qt::CaseSensitive)).toInt()-1;
749 frequency[op].ratio=frequencyEl.text().toDouble();
750 }
751 else if(ft.contains(FIXSTR, Qt::CaseSensitive)) {
752 int op = (ft.remove(FIXSTR, Qt::CaseSensitive)).toInt()-1;
753 frequency[op].isFix=(frequencyEl.text()=="yes"?true:false);
754 }
755 else if(ft.contains(FIXRANGESTR, Qt::CaseSensitive)) {
756 int op= (ft.remove(FIXRANGESTR, Qt::CaseSensitive)).toInt()-1;
757 frequency[op].freq=frequencyEl.text().toDouble();
758 }
759 frequencyNode =frequencyNode.nextSibling();
760 }
761 }
762 //oscWave
763 else if(presetEl.tagName().contains(OSWSTR, Qt::CaseSensitive)) {
764 int op=(presetEl.tagName().remove(OSWSTR, Qt::CaseSensitive)).toInt()-1;
765 oscWave[op]=(presetEl.text()=="W1"? W1:
766 (presetEl.text()=="W2"?W2:
767 (presetEl.text()=="W3"?W3:
768 (presetEl.text()=="W4"?W4:
769 (presetEl.text()=="W5"?W5:
770 (presetEl.text()=="W6"?W6:
771 (presetEl.text()=="W7"?W7:W8)))))));
772
773 }
774 //detune
775 else if(presetEl.tagName().contains(DETSTR, Qt::CaseSensitive)) {
776 int op=(presetEl.tagName().remove(DETSTR, Qt::CaseSensitive)).toInt()-1;
777 detune[op]=presetEl.text().toInt();
778 }
779 //eg
780 else if(presetEl.tagName()=="eg") {
781 QDomNode egNode = presetNode.firstChild();
782 while(!egNode.isNull()) {
783 QDomElement egEl = egNode.toElement();
784 if (egEl.isNull())
785 continue;
786 QString et=egEl.tagName();
787 if(et.contains(ARSTR, Qt::CaseSensitive)) {
788 int op=(et.remove(ARSTR, Qt::CaseSensitive)).toInt()-1;
789 eg[op].ar=egEl.text().toInt();
790 }
791 else if(et.contains(D1RSTR, Qt::CaseSensitive)) {
792 int op=(et.remove(D1RSTR, Qt::CaseSensitive)).toInt()-1;
793 eg[op].d1r=egEl.text().toInt();
794 }
795 else if(et.contains(D1LSTR, Qt::CaseSensitive)) {
796 int op = (et.remove(D1LSTR, Qt::CaseSensitive)).toInt()-1;
797 eg[op].d1l=egEl.text().toInt();
798 }
799 else if(et.contains(D2RSTR, Qt::CaseSensitive)) {
800 int op=(et.remove(D2RSTR, Qt::CaseSensitive)).toInt()-1;
801 eg[op].d2r=egEl.text().toInt();
802 }
803 else if(et.contains(RRSTR, Qt::CaseSensitive)) {
804 int op=(et.remove(RRSTR, Qt::CaseSensitive)).toInt()-1;
805 eg[op].rr=egEl.text().toInt();
806 }
807 else if(et.contains(SHFTSTR, Qt::CaseSensitive)) {
808 int op=(et.remove(SHFTSTR, Qt::CaseSensitive)).toInt()-1;
809 eg[op].egShift=(egEl.text()=="VOF"?VOF:
810 (egEl.text()=="V48"?V48:
811 (egEl.text()=="V24"?V24:V12)));
812 }
813 egNode =egNode.nextSibling();
814 }
815 }
816 //pitchEg
817 else if(presetEl.tagName()=="pitchEg") {
818 QDomNode pitchEgNode = presetNode.firstChild();
819 while(!pitchEgNode.isNull()) {
820 QDomElement pitchEgEl = pitchEgNode.toElement();
821 if (pitchEgEl.isNull())
822 continue;
823 QString pt=pitchEgEl.tagName();
824 if(pt==PR1STR) pitchEg.pr1=pitchEgEl.text().toInt();
825 else if(pt==PR2STR) pitchEg.pr2=pitchEgEl.text().toInt();
826 else if(pt==PR3STR) pitchEg.pr3=pitchEgEl.text().toInt();
827 else if(pt==PL1STR) pitchEg.pl1=pitchEgEl.text().toInt();
828 else if(pt==PL2STR) pitchEg.pl2=pitchEgEl.text().toInt();
829 else if(pt==PL3STR) pitchEg.pl3=pitchEgEl.text().toInt();
830 pitchEgNode=pitchEgNode.nextSibling();
831 }
832 }
833 //outLevel
834 else if(presetEl.tagName().contains(OUTSTR, Qt::CaseSensitive)) {
835 int op=(presetEl.tagName().remove(OUTSTR, Qt::CaseSensitive)).toInt()-1;
836 outLevel[op]=presetEl.text().toInt();
837 }
838 //scaling
839 else if(presetEl.tagName()=="scaling") {
840 QDomNode scalingNode = presetNode.firstChild();
841 while(!scalingNode.isNull()) {
842 QDomElement scalingEl = scalingNode.toElement();
843 if (scalingEl.isNull())
844 continue;
845 QString st=scalingEl.tagName();
846 if(st.contains(RSSTR, Qt::CaseSensitive)) {
847 int op=(st.remove(RSSTR, Qt::CaseSensitive)).toInt()-1;
848 scaling.rate[op]=scalingEl.text().toInt();
849 }
850 else if(st.contains(LSSTR, Qt::CaseSensitive)) {
851 int op=(st.remove(LSSTR, Qt::CaseSensitive)).toInt()-1;
852 scaling.level[op]=scalingEl.text().toInt();
853 }
854 scalingNode =scalingNode.nextSibling();
855 }
856 }
857 //function
858 else if(presetEl.tagName()=="function") {
859 QDomNode functionNode = presetNode.firstChild();
860 while(!functionNode.isNull()) {
861 QDomElement functionEl = functionNode.toElement();
862 if (functionEl.isNull())
863 continue;
864 QString ft=functionEl.tagName();
865 if(ft==TRANSPOSESTR)
866 function.transpose=functionEl.text().toInt();
867 else if(ft==POLYMODESTR)
868 function.mode=(functionEl.text()=="POLY"?POLY:MONO);
869 else if(ft==PBENDRANGESTR)
870 function.pBendRange=functionEl.text().toInt();
871 else if(ft==PORTAMODESTR)
872 function.portamento=
873 functionEl.text()=="FINGER"?FINGER:FULL;
874 else if(ft==PORTATIMESTR)
875 function.portamentoTime=functionEl.text().toInt();
876 else if(ft==FSWSTR)
877 function.footSw=(functionEl.text()=="POR"?POR:SUS);
878 else if(ft==FCVOLUMESTR)
879 function.fcVolume=functionEl.text().toInt();
880 else if(ft==FCPITCHSTR)
881 function.fcPitch=functionEl.text().toInt();
882 else if(ft==FCAMPLITUDESTR)
883 function.fcAmplitude=functionEl.text().toInt();
884 else if(ft==MWPITCHSTR)
885 function.mwPitch=functionEl.text().toInt();
886 else if(ft==MWAMPLITUDESTR)
887 function.mwAmplitude=functionEl.text().toInt();
888 else if(ft==BCPITCHSTR)
889 function.bcPitch=functionEl.text().toInt();
890 else if(ft==BCAMPLITUDESTR)
891 function.bcAmplitude=functionEl.text().toInt();
892 else if(ft==BCPITCHBIASSTR)
893 function.bcPitchBias=functionEl.text().toInt();
894 else if(ft==BCEGBIASSTR)
895 function.bcEgBias=functionEl.text().toInt();
896 else if(ft==ATPITCHSTR)
897 function.atPitch=functionEl.text().toInt();
898 else if(ft==ATAMPLITUDESTR)
899 function.atAmplitude=functionEl.text().toInt();
900 else if(ft==ATPITCHBIASSTR)
901 function.atPitchBias=functionEl.text().toInt();
902 else if(ft==ATEGBIASSTR)
903 function.atEgBias=functionEl.text().toInt();
904 else if(ft==REVERBRATESTR)
905 function.reverbRate=functionEl.text().toInt();
906 functionNode=functionNode.nextSibling();
907 }
908 }
909 //globalDetune
910 //else if(presetEl.tagName()=="globalDetune")
911 // globalDetune=presetEl.text().toInt();
912 //Names
913 else if(presetEl.tagName()=="name")
914 name=presetEl.text().toLatin1().data();
915 //prog
916 else if(presetEl.tagName()=="prog")
917 prog=presetEl.text().toInt();
918 presetNode = presetNode.nextSibling();
919 }
920 }
921
922 //---------------------------------------------------------
923 // witePreset
924 //---------------------------------------------------------
writePreset(AL::Xml * xml,bool onlyUsed)925 void Preset::writePreset(AL::Xml* xml, bool onlyUsed) {
926 char s[MAXCHARTAG];
927 if((!onlyUsed || _isUsed)) {
928 xml->stag("deicsOnzePreset version=\"1.0\"");
929
930 //algorithm
931 xml->tag(ALGSTR, QString((algorithm==FIRST? "FIRST":
932 (algorithm==SECOND? "SECOND":
933 (algorithm==THIRD? "THIRD":
934 (algorithm==FOURTH? "FOURTH":
935 (algorithm==FIFTH? "FIFTH":
936 (algorithm==SIXTH? "SIXTH":
937 (algorithm==SEVENTH? "SEVENTH":
938 "EIGHTH")))))))));
939 //feedback
940 xml->tag(FEEDBACKSTR, feedback);
941 //quick edit
942 //xml->tag(FINEBRIGHTNESSSTR, brightness);
943 //xml->tag(MODULATIONSTR, (int)modulation);
944 //xml->tag(GLOBALDETUNESTR, globalDetune);
945 //xml->tag(ATTACKSTR, attack);
946 //xml->tag(RELEASESTR, release);
947 //lfo
948 xml->stag("lfo");
949 xml->tag(WAVESTR, QString((lfo.wave==SAWUP? "SAWUP":
950 (lfo.wave==SQUARE? "SQUARE":
951 (lfo.wave==TRIANGL? "TRIANGL":"SHOLD")))));
952 xml->tag(SPEEDSTR, lfo.speed);
953 xml->tag(DELAYSTR, lfo.delay);
954 xml->tag(PMODDEPTHSTR, lfo.pModDepth);
955 xml->tag(AMODDEPTHSTR, lfo.aModDepth);
956 xml->tag(SYNCSTR, QString((lfo.sync==true? "on":"off")));
957 xml->etag("lfo");
958 //sensitivity
959 xml->stag("sensitivity");
960 xml->tag(PMODSENSSTR, sensitivity.pitch);
961 xml->tag(AMSSTR, sensitivity.amplitude);
962 for(int i=0; i<NBROP; i++) {
963 snprintf(s, MAXCHARTAG, AMESTR "%d",i+1);
964 xml->tag(s, QString((sensitivity.ampOn[i]==true? "on":"off")));
965 }
966 for(int i=0; i<NBROP; i++) {
967 snprintf(s, MAXCHARTAG,EBSSTR "%d",i+1);
968 xml->tag(s, sensitivity.egBias[i]);
969 }
970 for(int i=0; i<NBROP; i++) {
971 snprintf(s, MAXCHARTAG, KVSSTR "%d",i+1);
972 xml->tag(s, sensitivity.keyVelocity[i]);
973 }
974 xml->etag("sensitivity");
975 //frequency
976 xml->stag("frequency");
977 for(int i=0; i<NBROP; i++) {
978 snprintf(s, MAXCHARTAG, RATIOSTR "%d",i+1);
979 xml->tag(s, frequency[i].ratio);
980 }
981 for(int i=0; i<NBROP; i++) {
982 snprintf(s, MAXCHARTAG, FIXSTR "%d",i+1);
983 xml->tag(s, QString((frequency[i].isFix==true? "yes":"no")));
984 }
985 for(int i=0; i<NBROP; i++) {
986 snprintf(s, MAXCHARTAG, FIXRANGESTR "%d",i+1);
987 xml->tag(s, frequency[i].freq);
988 }
989 xml->etag("frequency");
990 //oscWave
991 for(int i=0; i<NBROP; i++) {
992 snprintf(s, MAXCHARTAG, OSWSTR "%d",i+1);
993 xml->tag(s, QString((oscWave[i]==W1?"W1":
994 (oscWave[i]==W2?"W2":
995 (oscWave[i]==W3?"W3":
996 (oscWave[i]==W4?"W4":
997 (oscWave[i]==W5?"W5":
998 (oscWave[i]==W6?"W6":
999 (oscWave[i]==W7?"W7":"W8")))))))));
1000 }
1001 //detune
1002 for(int i=0; i<NBROP; i++) {
1003 snprintf(s, MAXCHARTAG, DETSTR "%d",i+1);
1004 xml->tag(s, detune[i]);
1005 }
1006 //eg
1007 xml->stag("eg");
1008 for(int i=0; i<NBROP; i++) {
1009 snprintf(s, MAXCHARTAG, ARSTR "%d",i+1);
1010 xml->tag(s, eg[i].ar);
1011 }
1012 for(int i=0; i<NBROP; i++) {
1013 snprintf(s, MAXCHARTAG, D1RSTR "%d",i+1);
1014 xml->tag(s, eg[i].d1r);
1015 }
1016 for(int i=0; i<NBROP; i++) {
1017 snprintf(s, MAXCHARTAG, D1LSTR "%d",i+1);
1018 xml->tag(s, eg[i].d1l);
1019 }
1020 for(int i=0; i<NBROP; i++) {
1021 snprintf(s, MAXCHARTAG, D2RSTR "%d",i+1);
1022 xml->tag(s, eg[i].d2r);
1023 }
1024 for(int i=0; i<NBROP; i++) {
1025 snprintf(s, MAXCHARTAG, RRSTR "%d",i+1);
1026 xml->tag(s, eg[i].rr);
1027 }
1028 for(int i=0; i<NBROP; i++) {
1029 snprintf(s, MAXCHARTAG, SHFTSTR "%d",i+1);
1030 xml->tag(s, QString((eg[i].egShift==VOF?"VOF":
1031 (eg[i].egShift==V48?"V48":
1032 (eg[i].egShift==V24?"V24":"V12")))));
1033 }
1034 xml->etag("eg");
1035 //pitchEg
1036 xml->stag("pitchEg");
1037 xml->tag(PR1STR,pitchEg.pr1);
1038 xml->tag(PR2STR,pitchEg.pr2);
1039 xml->tag(PR3STR,pitchEg.pr3);
1040 xml->tag(PL1STR,pitchEg.pl1);
1041 xml->tag(PL2STR,pitchEg.pl2);
1042 xml->tag(PL3STR,pitchEg.pl3);
1043 xml->etag("pitchEg");
1044 //outLevel
1045 for(int i=0; i<NBROP; i++) {
1046 snprintf(s, MAXCHARTAG, OUTSTR "%d",i+1);
1047 xml->tag(s, outLevel[i]);
1048 }
1049 //scaling
1050 xml->stag("scaling");
1051 for(int i=0; i<NBROP; i++) {
1052 snprintf(s, MAXCHARTAG, RSSTR "%d",i+1);
1053 xml->tag(s, scaling.rate[i]);
1054 }
1055 for(int i=0; i<NBROP; i++) {
1056 snprintf(s, MAXCHARTAG, LSSTR "%d",i+1);
1057 xml->tag(s, scaling.level[i]);
1058 }
1059 xml->etag("scaling");
1060 //function
1061 xml->stag("function");
1062 xml->tag(TRANSPOSESTR, function.transpose);
1063 xml->tag(POLYMODESTR, QString((function.mode==POLY? "POLY":"MONO")));
1064 xml->tag(PBENDRANGESTR, function.pBendRange);
1065 xml->tag(PORTAMODESTR, QString((function.portamento==FINGER?
1066 "FINGER":"FULL")));
1067 xml->tag(PORTATIMESTR, function.portamentoTime);
1068 xml->tag(FSWSTR, QString((function.footSw==POR? "POR":"SUS")));
1069 xml->tag(FCVOLUMESTR, function.fcVolume);
1070 xml->tag(FCPITCHSTR, function.fcPitch);
1071 xml->tag(FCAMPLITUDESTR, function.fcAmplitude);
1072 xml->tag(MWPITCHSTR, function.mwPitch);
1073 xml->tag(MWAMPLITUDESTR, function.mwAmplitude);
1074 xml->tag(BCPITCHSTR, function.bcPitch);
1075 xml->tag(BCAMPLITUDESTR, function.bcAmplitude);
1076 xml->tag(BCPITCHBIASSTR, function.bcPitchBias);
1077 xml->tag(BCEGBIASSTR, function.bcEgBias);
1078 xml->tag(ATPITCHSTR, function.atPitch);
1079 xml->tag(ATAMPLITUDESTR, function.atAmplitude);
1080 xml->tag(ATPITCHBIASSTR, function.atPitchBias);
1081 xml->tag(ATEGBIASSTR, function.atEgBias);
1082 xml->tag(REVERBRATESTR, function.reverbRate);
1083 xml->etag("function");
1084 //globalDetune
1085 //xml->tag("globalDetune", globalDetune);
1086 //preset name
1087 xml->tag("name", QString(name.c_str()));
1088 //bank prog
1089 xml->tag("prog",prog);
1090
1091 xml->etag("deicsOnzePreset");
1092 }
1093 }
1094
1095 //---------------------------------------------------------
1096 // printPreset
1097 //---------------------------------------------------------
1098
printPreset()1099 void Preset::printPreset()
1100 {
1101 printf("\n");
1102 printf("Algorithm : %d, Feedback : %d\n", algorithm, feedback);
1103 printf("LFO : ");
1104 switch(lfo.wave)
1105 {
1106 case(SAWUP) : printf("SAWUP ,"); break;
1107 case(SQUARE) : printf("SQUARE ,"); break;
1108 case(TRIANGL) : printf("TRIANGL ,"); break;
1109 case(SHOLD) : printf("SHOLD ,"); break;
1110 default : printf("No defined, "); break;
1111 }
1112 printf("Speed : %d, Delay : %d, PModD : %d, AModD : %d, ",
1113 lfo.speed, lfo.delay, lfo.pModDepth, lfo.aModDepth);
1114 if(lfo.sync) printf("Sync\n"); else printf("Not Sync\n");
1115 printf("LFO Pitch Sensitivity : %d, LFO Amplitude Sensitivity : %d\n",
1116 sensitivity.pitch, sensitivity.amplitude);
1117 for(int i=0; i<NBROP; i++)
1118 {
1119 printf("amp%d ",i+1);
1120 if(sensitivity.ampOn [i]) printf("ON "); else printf("OFF ");
1121 }
1122 printf("\n");
1123 for(int i=0; i<NBROP; i++)
1124 printf("EgBias%d : %d ",i+1, sensitivity.egBias[i]);
1125 printf("\n");
1126 for(int i=0; i<NBROP; i++)
1127 printf("KVS%d : %d ",i+1, sensitivity.keyVelocity[i]);
1128 printf("\n");
1129 for(int i=0; i<NBROP; i++)
1130 {
1131 if(frequency[i].isFix)
1132 printf("Freq%d : %f ",i+1, frequency[i].ratio);
1133 else printf("Ratio%d : %f ",i+1, frequency[i].ratio);
1134 }
1135 printf("\n");
1136 for(int i=0; i<NBROP; i++)
1137 {
1138 printf("OscWave%d ", i+1);
1139 switch(oscWave[i])
1140 {
1141 case(W1) : printf("W1 "); break;
1142 case(W2) : printf("W2 "); break;
1143 case(W3) : printf("W3 "); break;
1144 case(W4) : printf("W4 "); break;
1145 case(W5) : printf("W5 "); break;
1146 case(W6) : printf("W6 "); break;
1147 case(W7) : printf("W7 "); break;
1148 case(W8) : printf("W8 "); break;
1149 default : printf("No defined "); break;
1150 }
1151 }
1152 printf("\n");
1153 for(int i=0; i<NBROP; i++)
1154 printf("Detune%d : %d ",i+1, detune[i]);
1155 printf("\n");
1156 for(int i=0; i<NBROP; i++)
1157 {
1158 printf("AR%d : %d, D1R%d : %d, D1L%d : %d, D2R%d : %d, RR%d : %d, EgShift%d : ",
1159 i+1, eg[i].ar, i+1, eg[i].d1r,
1160 i+1, eg[i].d1l, i+1, eg[i].d2r, i+1, eg[i].rr, i+1);
1161 switch(eg[i].egShift)
1162 {
1163 case(VOF) : printf("VOF"); break;
1164 case(V48) : printf("48"); break;
1165 case(V24) : printf("24"); break;
1166 case(V12) : printf("12"); break;
1167 }
1168 printf("\n");
1169 }
1170 printf("PitchEg pr1 : %d, pr2 : %d, pr3 : %d, pl1 : %d, pl2 : %d, pl3 : %d"
1171 , pitchEg.pr1, pitchEg.pr2, pitchEg.pr3,
1172 pitchEg.pl1, pitchEg.pl2, pitchEg.pl3);
1173 printf("\n");
1174 for(int i=0; i<NBROP; i++)
1175 printf("OutLevel%d : %d ",i+1, outLevel[i]);
1176 printf("\n");
1177 printf("Name : %s\n", name.c_str());
1178 }
1179
printSubcategory()1180 void Subcategory::printSubcategory() {
1181 std::cout << " " << _subcategoryName << "\n";
1182 for(std::vector<Preset*>::iterator i=_presetVector.begin();
1183 i!=_presetVector.end(); i++) (*i)->printPreset();
1184 }
1185
printCategory()1186 void Category::printCategory() {
1187 std::cout << " " << _categoryName << "\n";
1188 for(unsigned int i=0; i<_subcategoryVector.size(); i++)
1189 _subcategoryVector[i]->printSubcategory();
1190 }
1191
printSet()1192 void Set::printSet() {
1193 std::cout << _setName << "\n";
1194 for(unsigned int i=0; i<_categoryVector.size(); i++)
1195 _categoryVector[i]->printCategory();
1196 }
1197