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