/[svn]/gigedit/trunk/src/gigedit/dimregionedit.cpp
ViewVC logotype

Annotation of /gigedit/trunk/src/gigedit/dimregionedit.cpp

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1265 - (hide annotations) (download)
Sun Jul 29 13:44:59 2007 UTC (11 years, 11 months ago) by persson
File size: 33887 byte(s)
* added support for 24 bit sample import
* when importing samples, settings for loops and root note are copied
  from the sample files (if they have such settings)

1 schoenebeck 1225 /*
2     * Copyright (C) 2006, 2007 Andreas Persson
3     *
4     * This program is free software; you can redistribute it and/or
5     * modify it under the terms of the GNU General Public License as
6     * published by the Free Software Foundation; either version 2, or (at
7     * your option) any later version.
8     *
9     * This program is distributed in the hope that it will be useful, but
10     * WITHOUT ANY WARRANTY; without even the implied warranty of
11     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12     * General Public License for more details.
13     *
14     * You should have received a copy of the GNU General Public License
15     * along with program; see the file COPYING. If not, write to the Free
16     * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
17     * 02110-1301 USA.
18     */
19    
20     #include "dimregionedit.h"
21    
22     #include <libintl.h>
23     #define _(String) gettext(String)
24    
25     DimRegionEdit::DimRegionEdit() :
26     eEG1PreAttack("Pre-attack", 0, 100, 2),
27     eEG1Attack("Attack", 0, 60, 3),
28     eEG1Decay1("Decay 1", 0.005, 60, 3),
29     eEG1Decay2("Decay 2", 0, 60, 3),
30     eEG1InfiniteSustain("Infinite sustain"),
31     eEG1Sustain("Sustain", 0, 100, 2),
32     eEG1Release("Release", 0, 60, 3),
33     eEG1Hold("Hold"),
34     eEG1Controller("Controller"),
35     eEG1ControllerInvert("Controller invert"),
36     eEG1ControllerAttackInfluence("Controller attack influence", 0, 3),
37     eEG1ControllerDecayInfluence("Controller decay influence", 0, 3),
38     eEG1ControllerReleaseInfluence("Controller release influence", 0, 3),
39     eLFO1Frequency("Frequency", 0.1, 10, 2),
40     eLFO1InternalDepth("Internal depth", 0, 1200),
41     eLFO1ControlDepth("Control depth", 0, 1200),
42     eLFO1Controller("Controller"),
43     eLFO1FlipPhase("Flip phase"),
44     eLFO1Sync("Sync"),
45     eEG2PreAttack("Pre-attack", 0, 100, 2),
46     eEG2Attack("Attack", 0, 60, 3),
47     eEG2Decay1("Decay 1", 0.005, 60, 3),
48     eEG2Decay2("Decay 2", 0, 60, 3),
49     eEG2InfiniteSustain("Infinite sustain"),
50     eEG2Sustain("Sustain", 0, 100, 2),
51     eEG2Release("Release", 0, 60, 3),
52     eEG2Controller("Controller"),
53     eEG2ControllerInvert("Controller invert"),
54     eEG2ControllerAttackInfluence("Controller attack influence", 0, 3),
55     eEG2ControllerDecayInfluence("Controller decay influence", 0, 3),
56     eEG2ControllerReleaseInfluence("Controller release influence", 0, 3),
57     eLFO2Frequency("Frequency", 0.1, 10, 2),
58     eLFO2InternalDepth("Internal depth", 0, 1200),
59     eLFO2ControlDepth("Control depth", 0, 1200),
60     eLFO2Controller("Controller"),
61     eLFO2FlipPhase("Flip phase"),
62     eLFO2Sync("Sync"),
63     eEG3Attack("Attack", 0, 10, 3),
64     eEG3Depth("Depth", -1200, 1200),
65     eLFO3Frequency("Frequency", 0.1, 10, 2),
66     eLFO3InternalDepth("Internal depth", 0, 1200),
67     eLFO3ControlDepth("Control depth", 0, 1200),
68     eLFO3Controller("Controller"),
69     eLFO3Sync("Sync"),
70     eVCFEnabled("Enabled"),
71     eVCFType("Type"),
72     eVCFCutoffController("Cutoff controller"),
73     eVCFCutoffControllerInvert("Cutoff controller invert"),
74     eVCFCutoff("Cutoff"),
75     eVCFVelocityCurve("Velocity curve"),
76     eVCFVelocityScale("Velocity scale"),
77     eVCFVelocityDynamicRange("Velocity dynamic range", 0, 4),
78     eVCFResonance("Resonance"),
79     eVCFResonanceDynamic("Resonance dynamic"),
80     eVCFResonanceController("Resonance controller"),
81     eVCFKeyboardTracking("Keyboard tracking"),
82     eVCFKeyboardTrackingBreakpoint("Keyboard tracking breakpoint"),
83     eVelocityResponseCurve("Velocity response curve"),
84     eVelocityResponseDepth("Velocity response depth", 0, 4),
85     eVelocityResponseCurveScaling("Velocity response curve scaling"),
86     eReleaseVelocityResponseCurve("Release velocity response curve"),
87     eReleaseVelocityResponseDepth("Release velocity response depth", 0, 4),
88     eReleaseTriggerDecay("Release trigger decay", 0, 8),
89     eCrossfade_in_start("Crossfade-in start"),
90     eCrossfade_in_end("Crossfade-in end"),
91     eCrossfade_out_start("Crossfade-out start"),
92     eCrossfade_out_end("Crossfade-out end"),
93     ePitchTrack("Pitch track"),
94     eDimensionBypass("Dimension bypass"),
95     ePan("Pan", -64, 63),
96     eSelfMask("Self mask"),
97     eAttenuationController("Attenuation controller"),
98     eInvertAttenuationController("Invert attenuation controller"),
99     eAttenuationControllerThreshold("Attenuation controller threshold"),
100     eChannelOffset("Channel offset", 0, 9),
101     eSustainDefeat("Sustain defeat"),
102     eMSDecode("MS decode"),
103     eSampleStartOffset("Sample start offset", 0, 2000),
104     eUnityNote("Unity note"),
105     eFineTune("Fine tune", -49, 50),
106     eGain("Gain", -96, 0, 2, -655360),
107     eGainPlus6("Gain +6dB", eGain, 6 * -655360),
108     eSampleLoopEnabled("Enabled"),
109     eSampleLoopStart("Loop start positon"),
110     eSampleLoopLength("Loop size"),
111     eSampleLoopType("Loop type"),
112     eSampleLoopInfinite("Infinite loop"),
113     eSampleLoopPlayCount("Playback count")
114     {
115     for (int i = 0 ; i < 7 ; i++) {
116     table[i] = new Gtk::Table(3, 1);
117     table[i]->set_col_spacings(7);
118     }
119    
120     // set tooltips
121     eUnityNote.set_tip(
122     _("Note this sample is associated with (a.k.a. 'root note')")
123     );
124     eSampleStartOffset.set_tip(_("Sample position at which playback should be started"));
125     ePan.set_tip(_("Stereo balance (left/right)"));
126     eChannelOffset.set_tip(
127     _("Output channel where the audio signal should be routed to (0 - 9)")
128     );
129     ePitchTrack.set_tip(
130     _("If true: sample will be pitched according to the key position "
131     "(this would be disabled for drums for example)")
132     );
133     eSampleLoopEnabled.set_tip(_("If enabled: repeats to playback the sample"));
134     eSampleLoopStart.set_tip(
135     _("Start position within the sample (in sample points) of the area to "
136     "be looped")
137     );
138     eSampleLoopLength.set_tip(
139     _("Duration (in sample points) of the area to be looped")
140     );
141     eSampleLoopType.set_tip(
142     _("Direction in which the loop area in the sample should be played back")
143     );
144     eSampleLoopInfinite.set_tip(
145     _("Whether the loop area should be played back forever\n"
146     "Caution: this setting is stored on Sample side, thus is shared "
147     "among all dimension regions that use this sample!")
148     );
149     eSampleLoopPlayCount.set_tip(
150     _("How many times the loop area should be played back\n"
151     "Caution: this setting is stored on Sample side, thus is shared "
152     "among all dimension regions that use this sample!")
153     );
154    
155     pageno = 0;
156     rowno = 0;
157     firstRowInBlock = 0;
158    
159     addHeader(_("Mandatory Settings"));
160     addString("Sample", lSample, wSample);
161     //TODO: the following would break drag&drop: wSample->property_editable().set_value(false); or this: wSample->set_editable(false);
162     tooltips.set_tip(*wSample, _("Drop a sample here"));
163     addProp(eUnityNote);
164     addHeader(_("Optional Settings"));
165     addProp(eSampleStartOffset);
166     addProp(eChannelOffset);
167     addHeader("Loops");
168     addProp(eSampleLoopEnabled);
169     addProp(eSampleLoopStart);
170     addProp(eSampleLoopLength);
171     {
172     const char* choices[] = { "normal", "bidirectional", "backward", 0 };
173     static const uint32_t values[] = {
174     gig::loop_type_normal,
175     gig::loop_type_bidirectional,
176     gig::loop_type_backward
177     };
178     eSampleLoopType.set_choices(choices, values);
179     }
180     addProp(eSampleLoopType);
181     addProp(eSampleLoopInfinite);
182     addProp(eSampleLoopPlayCount);
183    
184     nextPage();
185    
186     addHeader(_("General Amplitude Settings"));
187     addProp(eGain);
188     addProp(eGainPlus6);
189     addProp(ePan);
190     addHeader(_("Amplitude Envelope (EG1)"));
191     addProp(eEG1PreAttack);
192     addProp(eEG1Attack);
193     addProp(eEG1Decay1);
194     addProp(eEG1Decay2);
195     addProp(eEG1InfiniteSustain);
196     addProp(eEG1Sustain);
197     addProp(eEG1Release);
198     addProp(eEG1Hold);
199     addProp(eEG1Controller);
200     addProp(eEG1ControllerInvert);
201     addProp(eEG1ControllerAttackInfluence);
202     addProp(eEG1ControllerDecayInfluence);
203     addProp(eEG1ControllerReleaseInfluence);
204    
205     nextPage();
206    
207     addHeader(_("Amplitude Oscillator (LFO1)"));
208     addProp(eLFO1Frequency);
209     addProp(eLFO1InternalDepth);
210     addProp(eLFO1ControlDepth);
211     {
212     const char* choices[] = { "internal", "modwheel", "breath",
213     "internal+modwheel", "internal+breath", 0 };
214     static const gig::lfo1_ctrl_t values[] = {
215     gig::lfo1_ctrl_internal,
216     gig::lfo1_ctrl_modwheel,
217     gig::lfo1_ctrl_breath,
218     gig::lfo1_ctrl_internal_modwheel,
219     gig::lfo1_ctrl_internal_breath
220     };
221     eLFO1Controller.set_choices(choices, values);
222     }
223     addProp(eLFO1Controller);
224     addProp(eLFO1FlipPhase);
225     addProp(eLFO1Sync);
226     addHeader("Crossfade");
227     addProp(eAttenuationController);
228     addProp(eInvertAttenuationController);
229     addProp(eAttenuationControllerThreshold);
230     addProp(eCrossfade_in_start);
231     addProp(eCrossfade_in_end);
232     addProp(eCrossfade_out_start);
233     addProp(eCrossfade_out_end);
234    
235     nextPage();
236    
237     addHeader(_("General Filter Settings"));
238     addProp(eVCFEnabled);
239     {
240     const char* choices[] = { "lowpass", "lowpassturbo", "bandpass",
241     "highpass", "bandreject", 0 };
242     static const gig::vcf_type_t values[] = {
243     gig::vcf_type_lowpass,
244     gig::vcf_type_lowpassturbo,
245     gig::vcf_type_bandpass,
246     gig::vcf_type_highpass,
247     gig::vcf_type_bandreject
248     };
249     eVCFType.set_choices(choices, values);
250     }
251     addProp(eVCFType);
252     {
253     const char* choices[] = { "none", "none2", "modwheel", "effect1", "effect2",
254     "breath", "foot", "sustainpedal", "softpedal",
255     "genpurpose7", "genpurpose8", "aftertouch", 0 };
256     static const gig::vcf_cutoff_ctrl_t values[] = {
257     gig::vcf_cutoff_ctrl_none,
258     gig::vcf_cutoff_ctrl_none2,
259     gig::vcf_cutoff_ctrl_modwheel,
260     gig::vcf_cutoff_ctrl_effect1,
261     gig::vcf_cutoff_ctrl_effect2,
262     gig::vcf_cutoff_ctrl_breath,
263     gig::vcf_cutoff_ctrl_foot,
264     gig::vcf_cutoff_ctrl_sustainpedal,
265     gig::vcf_cutoff_ctrl_softpedal,
266     gig::vcf_cutoff_ctrl_genpurpose7,
267     gig::vcf_cutoff_ctrl_genpurpose8,
268     gig::vcf_cutoff_ctrl_aftertouch
269     };
270     eVCFCutoffController.set_choices(choices, values);
271     }
272     addProp(eVCFCutoffController);
273     addProp(eVCFCutoffControllerInvert);
274     addProp(eVCFCutoff);
275     const char* curve_type_texts[] = { "nonlinear", "linear", "special", 0 };
276     static const gig::curve_type_t curve_type_values[] = {
277     gig::curve_type_nonlinear,
278     gig::curve_type_linear,
279     gig::curve_type_special
280     };
281     eVCFVelocityCurve.set_choices(curve_type_texts, curve_type_values);
282     addProp(eVCFVelocityCurve);
283     addProp(eVCFVelocityScale);
284     addProp(eVCFVelocityDynamicRange);
285     addProp(eVCFResonance);
286     addProp(eVCFResonanceDynamic);
287     {
288     const char* choices[] = { "none", "genpurpose3", "genpurpose4",
289     "genpurpose5", "genpurpose6", 0 };
290     static const gig::vcf_res_ctrl_t values[] = {
291     gig::vcf_res_ctrl_none,
292     gig::vcf_res_ctrl_genpurpose3,
293     gig::vcf_res_ctrl_genpurpose4,
294     gig::vcf_res_ctrl_genpurpose5,
295     gig::vcf_res_ctrl_genpurpose6
296     };
297     eVCFResonanceController.set_choices(choices, values);
298     }
299     addProp(eVCFResonanceController);
300     addProp(eVCFKeyboardTracking);
301     addProp(eVCFKeyboardTrackingBreakpoint);
302    
303     nextPage();
304    
305     addHeader(_("Filter Cutoff Envelope (EG2)"));
306     addProp(eEG2PreAttack);
307     addProp(eEG2Attack);
308     addProp(eEG2Decay1);
309     addProp(eEG2Decay2);
310     addProp(eEG2InfiniteSustain);
311     addProp(eEG2Sustain);
312     addProp(eEG2Release);
313     addProp(eEG2Controller);
314     addProp(eEG2ControllerInvert);
315     addProp(eEG2ControllerAttackInfluence);
316     addProp(eEG2ControllerDecayInfluence);
317     addProp(eEG2ControllerReleaseInfluence);
318     addHeader(_("Filter Cutoff Oscillator (LFO2)"));
319     addProp(eLFO2Frequency);
320     addProp(eLFO2InternalDepth);
321     addProp(eLFO2ControlDepth);
322     {
323     const char* choices[] = { "internal", "modwheel", "foot",
324     "internal+modwheel", "internal+foot", 0 };
325     static const gig::lfo2_ctrl_t values[] = {
326     gig::lfo2_ctrl_internal,
327     gig::lfo2_ctrl_modwheel,
328     gig::lfo2_ctrl_foot,
329     gig::lfo2_ctrl_internal_modwheel,
330     gig::lfo2_ctrl_internal_foot
331     };
332     eLFO2Controller.set_choices(choices, values);
333     }
334     addProp(eLFO2Controller);
335     addProp(eLFO2FlipPhase);
336     addProp(eLFO2Sync);
337    
338     nextPage();
339    
340     addHeader(_("General Pitch Settings"));
341     addProp(eFineTune);
342     addProp(ePitchTrack);
343     addHeader(_("Pitch Envelope (EG3)"));
344     addProp(eEG3Attack);
345     addProp(eEG3Depth);
346     addHeader(_("Pitch Oscillator (LFO3)"));
347     addProp(eLFO3Frequency);
348     addProp(eLFO3InternalDepth);
349     addProp(eLFO3ControlDepth);
350     {
351     const char* choices[] = { "internal", "modwheel", "aftertouch",
352     "internal+modwheel", "internal+aftertouch", 0 };
353     static const gig::lfo3_ctrl_t values[] = {
354     gig::lfo3_ctrl_internal,
355     gig::lfo3_ctrl_modwheel,
356     gig::lfo3_ctrl_aftertouch,
357     gig::lfo3_ctrl_internal_modwheel,
358     gig::lfo3_ctrl_internal_aftertouch
359     };
360     eLFO3Controller.set_choices(choices, values);
361     }
362     addProp(eLFO3Controller);
363     addProp(eLFO3Sync);
364    
365     nextPage();
366    
367     eVelocityResponseCurve.set_choices(curve_type_texts, curve_type_values);
368     addProp(eVelocityResponseCurve);
369     addProp(eVelocityResponseDepth);
370     addProp(eVelocityResponseCurveScaling);
371     eReleaseVelocityResponseCurve.set_choices(curve_type_texts,
372     curve_type_values);
373     addProp(eReleaseVelocityResponseCurve);
374     addProp(eReleaseVelocityResponseDepth);
375     addProp(eReleaseTriggerDecay);
376     {
377     const char* choices[] = { "none", "effect4depth", "effect5depth", 0 };
378     static const gig::dim_bypass_ctrl_t values[] = {
379     gig::dim_bypass_ctrl_none,
380     gig::dim_bypass_ctrl_94,
381     gig::dim_bypass_ctrl_95
382     };
383     eDimensionBypass.set_choices(choices, values);
384     }
385     addProp(eDimensionBypass);
386     addProp(eSelfMask);
387     addProp(eSustainDefeat);
388     addProp(eMSDecode);
389    
390     nextPage();
391    
392    
393     eEG1InfiniteSustain.signal_toggled().connect(
394     sigc::mem_fun(*this, &DimRegionEdit::EG1InfiniteSustain_toggled) );
395     eEG2InfiniteSustain.signal_toggled().connect(
396     sigc::mem_fun(*this, &DimRegionEdit::EG2InfiniteSustain_toggled) );
397     eEG1Controller.signal_changed().connect(
398     sigc::mem_fun(*this, &DimRegionEdit::EG1Controller_changed) );
399     eEG2Controller.signal_changed().connect(
400     sigc::mem_fun(*this, &DimRegionEdit::EG2Controller_changed) );
401     eLFO1Controller.signal_changed().connect(
402     sigc::mem_fun(*this, &DimRegionEdit::LFO1Controller_changed) );
403     eLFO2Controller.signal_changed().connect(
404     sigc::mem_fun(*this, &DimRegionEdit::LFO2Controller_changed) );
405     eLFO3Controller.signal_changed().connect(
406     sigc::mem_fun(*this, &DimRegionEdit::LFO3Controller_changed) );
407     eAttenuationController.signal_changed().connect(
408     sigc::mem_fun(*this, &DimRegionEdit::AttenuationController_changed) );
409     eVCFEnabled.signal_toggled().connect(
410     sigc::mem_fun(*this, &DimRegionEdit::VCFEnabled_toggled) );
411     eVCFCutoffController.signal_changed().connect(
412     sigc::mem_fun(*this, &DimRegionEdit::VCFCutoffController_changed) );
413     eVCFResonanceController.signal_changed().connect(
414     sigc::mem_fun(*this, &DimRegionEdit::VCFResonanceController_changed) );
415    
416 persson 1261 eCrossfade_in_start.signal_changed_by_user().connect(
417 schoenebeck 1225 sigc::mem_fun(*this, &DimRegionEdit::crossfade1_changed));
418 persson 1261 eCrossfade_in_end.signal_changed_by_user().connect(
419 schoenebeck 1225 sigc::mem_fun(*this, &DimRegionEdit::crossfade2_changed));
420 persson 1261 eCrossfade_out_start.signal_changed_by_user().connect(
421 schoenebeck 1225 sigc::mem_fun(*this, &DimRegionEdit::crossfade3_changed));
422 persson 1261 eCrossfade_out_end.signal_changed_by_user().connect(
423 schoenebeck 1225 sigc::mem_fun(*this, &DimRegionEdit::crossfade4_changed));
424    
425     eSampleLoopEnabled.signal_toggled().connect(
426     sigc::mem_fun(*this, &DimRegionEdit::loop_enabled_toggled));
427 persson 1261 eSampleLoopStart.signal_changed_by_user().connect(
428 schoenebeck 1225 sigc::mem_fun(*this, &DimRegionEdit::updateLoopElements));
429 persson 1261 eSampleLoopLength.signal_changed_by_user().connect(
430 schoenebeck 1225 sigc::mem_fun(*this, &DimRegionEdit::updateLoopElements));
431     eSampleLoopInfinite.signal_toggled().connect(
432     sigc::mem_fun(*this, &DimRegionEdit::loop_infinite_toggled));
433    
434     append_page(*table[0], "Sample");
435     append_page(*table[1], "Amplitude (1)");
436     append_page(*table[2], "Amplitude (2)");
437     append_page(*table[3], "Filter (1)");
438     append_page(*table[4], "Filter (2)");
439     append_page(*table[5], "Pitch");
440     append_page(*table[6], "Misc");
441     }
442    
443     DimRegionEdit::~DimRegionEdit()
444     {
445     }
446    
447     void DimRegionEdit::addString(const char* labelText, Gtk::Label*& label,
448     Gtk::Entry*& widget)
449     {
450     label = new Gtk::Label(Glib::ustring(labelText) + ":");
451     label->set_alignment(Gtk::ALIGN_LEFT);
452    
453     table[pageno]->attach(*label, 1, 2, rowno, rowno + 1,
454     Gtk::FILL, Gtk::SHRINK);
455    
456     widget = new Gtk::Entry();
457    
458     table[pageno]->attach(*widget, 2, 3, rowno, rowno + 1,
459     Gtk::EXPAND | Gtk::FILL, Gtk::SHRINK);
460    
461     rowno++;
462     }
463    
464     void DimRegionEdit::addHeader(const char* text)
465     {
466     if (firstRowInBlock < rowno - 1)
467     {
468     Gtk::Label* filler = new Gtk::Label(" ");
469     table[pageno]->attach(*filler, 0, 1, firstRowInBlock, rowno,
470     Gtk::FILL, Gtk::SHRINK);
471     }
472     Glib::ustring str = "<b>";
473     str += text;
474     str += "</b>";
475     Gtk::Label* label = new Gtk::Label(str);
476     label->set_use_markup();
477     label->set_alignment(Gtk::ALIGN_LEFT);
478     table[pageno]->attach(*label, 0, 3, rowno, rowno + 1,
479     Gtk::FILL, Gtk::SHRINK);
480     rowno++;
481     firstRowInBlock = rowno;
482     }
483    
484     void DimRegionEdit::nextPage()
485     {
486     if (firstRowInBlock < rowno - 1)
487     {
488     Gtk::Label* filler = new Gtk::Label(" ");
489     table[pageno]->attach(*filler, 0, 1, firstRowInBlock, rowno,
490     Gtk::FILL, Gtk::SHRINK);
491     }
492     pageno++;
493     rowno = 0;
494     firstRowInBlock = 0;
495     }
496    
497     void DimRegionEdit::addProp(BoolEntry& boolentry)
498     {
499     table[pageno]->attach(boolentry.widget, 1, 3, rowno, rowno + 1,
500     Gtk::FILL, Gtk::SHRINK);
501     rowno++;
502 persson 1261 boolentry.signal_changed_by_user().connect(dimreg_changed_signal.make_slot());
503 schoenebeck 1225 }
504    
505 persson 1262 void DimRegionEdit::addProp(BoolEntryPlus6& boolentry)
506     {
507     table[pageno]->attach(boolentry.widget, 1, 3, rowno, rowno + 1,
508     Gtk::FILL, Gtk::SHRINK);
509     rowno++;
510     boolentry.signal_changed_by_user().connect(dimreg_changed_signal.make_slot());
511     }
512    
513 schoenebeck 1225 void DimRegionEdit::addProp(LabelWidget& prop)
514     {
515     table[pageno]->attach(prop.label, 1, 2, rowno, rowno + 1,
516     Gtk::FILL, Gtk::SHRINK);
517     table[pageno]->attach(prop.widget, 2, 3, rowno, rowno + 1,
518     Gtk::EXPAND | Gtk::FILL, Gtk::SHRINK);
519     rowno++;
520 persson 1261 prop.signal_changed_by_user().connect(dimreg_changed_signal.make_slot());
521 schoenebeck 1225 }
522    
523    
524     void DimRegionEdit::set_dim_region(gig::DimensionRegion* d)
525     {
526     dimregion = d;
527    
528     set_sensitive(d);
529     if (!d) return;
530    
531     wSample->set_text(d->pSample ? d->pSample->pInfo->Name.c_str() : "NULL");
532     eEG1PreAttack.set_ptr(&d->EG1PreAttack);
533     eEG1Attack.set_ptr(&d->EG1Attack);
534     eEG1Decay1.set_ptr(&d->EG1Decay1);
535     eEG1Decay2.set_ptr(&d->EG1Decay2);
536     eEG1InfiniteSustain.set_ptr(&d->EG1InfiniteSustain);
537     eEG1Sustain.set_ptr(&d->EG1Sustain);
538     eEG1Release.set_ptr(&d->EG1Release);
539     eEG1Hold.set_ptr(&d->EG1Hold);
540     eEG1Controller.set_ptr(&d->EG1Controller);
541     eEG1ControllerInvert.set_ptr(&d->EG1ControllerInvert);
542     eEG1ControllerAttackInfluence.set_ptr(&d->EG1ControllerAttackInfluence);
543     eEG1ControllerDecayInfluence.set_ptr(&d->EG1ControllerDecayInfluence);
544     eEG1ControllerReleaseInfluence.set_ptr(&d->EG1ControllerReleaseInfluence);
545     eLFO1Frequency.set_ptr(&d->LFO1Frequency);
546     eLFO1InternalDepth.set_ptr(&d->LFO1InternalDepth);
547     eLFO1ControlDepth.set_ptr(&d->LFO1ControlDepth);
548     eLFO1Controller.set_ptr(&d->LFO1Controller);
549     eLFO1FlipPhase.set_ptr(&d->LFO1FlipPhase);
550     eLFO1Sync.set_ptr(&d->LFO1Sync);
551     eEG2PreAttack.set_ptr(&d->EG2PreAttack);
552     eEG2Attack.set_ptr(&d->EG2Attack);
553     eEG2Decay1.set_ptr(&d->EG2Decay1);
554     eEG2Decay2.set_ptr(&d->EG2Decay2);
555     eEG2InfiniteSustain.set_ptr(&d->EG2InfiniteSustain);
556     eEG2Sustain.set_ptr(&d->EG2Sustain);
557     eEG2Release.set_ptr(&d->EG2Release);
558     eEG2Controller.set_ptr(&d->EG2Controller);
559     eEG2ControllerInvert.set_ptr(&d->EG2ControllerInvert);
560     eEG2ControllerAttackInfluence.set_ptr(&d->EG2ControllerAttackInfluence);
561     eEG2ControllerDecayInfluence.set_ptr(&d->EG2ControllerDecayInfluence);
562     eEG2ControllerReleaseInfluence.set_ptr(&d->EG2ControllerReleaseInfluence);
563     eLFO2Frequency.set_ptr(&d->LFO2Frequency);
564     eLFO2InternalDepth.set_ptr(&d->LFO2InternalDepth);
565     eLFO2ControlDepth.set_ptr(&d->LFO2ControlDepth);
566     eLFO2Controller.set_ptr(&d->LFO2Controller);
567     eLFO2FlipPhase.set_ptr(&d->LFO2FlipPhase);
568     eLFO2Sync.set_ptr(&d->LFO2Sync);
569     eEG3Attack.set_ptr(&d->EG3Attack);
570     eEG3Depth.set_ptr(&d->EG3Depth);
571     eLFO3Frequency.set_ptr(&d->LFO3Frequency);
572     eLFO3InternalDepth.set_ptr(&d->LFO3InternalDepth);
573     eLFO3ControlDepth.set_ptr(&d->LFO3ControlDepth);
574     eLFO3Controller.set_ptr(&d->LFO3Controller);
575     eLFO3Sync.set_ptr(&d->LFO3Sync);
576     eVCFEnabled.set_ptr(&d->VCFEnabled);
577     eVCFType.set_ptr(&d->VCFType);
578     eVCFCutoffController.set_ptr(&d->VCFCutoffController);
579     eVCFCutoffControllerInvert.set_ptr(&d->VCFCutoffControllerInvert);
580     eVCFCutoff.set_ptr(&d->VCFCutoff);
581     eVCFVelocityCurve.set_ptr(&d->VCFVelocityCurve);
582     eVCFVelocityScale.set_ptr(&d->VCFVelocityScale);
583     eVCFVelocityDynamicRange.set_ptr(&d->VCFVelocityDynamicRange);
584     eVCFResonance.set_ptr(&d->VCFResonance);
585     eVCFResonanceDynamic.set_ptr(&d->VCFResonanceDynamic);
586     eVCFResonanceController.set_ptr(&d->VCFResonanceController);
587     eVCFKeyboardTracking.set_ptr(&d->VCFKeyboardTracking);
588     eVCFKeyboardTrackingBreakpoint.set_ptr(&d->VCFKeyboardTrackingBreakpoint);
589     eVelocityResponseCurve.set_ptr(&d->VelocityResponseCurve);
590     eVelocityResponseDepth.set_ptr(&d->VelocityResponseDepth);
591     eVelocityResponseCurveScaling.set_ptr(&d->VelocityResponseCurveScaling);
592     eReleaseVelocityResponseCurve.set_ptr(&d->ReleaseVelocityResponseCurve);
593     eReleaseVelocityResponseDepth.set_ptr(&d->ReleaseVelocityResponseDepth);
594     eReleaseTriggerDecay.set_ptr(&d->ReleaseTriggerDecay);
595 persson 1261
596     eCrossfade_in_start.set_ptr(0);
597     eCrossfade_in_end.set_ptr(0);
598     eCrossfade_out_start.set_ptr(0);
599     eCrossfade_out_end.set_ptr(0);
600 schoenebeck 1225 eCrossfade_in_start.set_ptr(&d->Crossfade.in_start);
601     eCrossfade_in_end.set_ptr(&d->Crossfade.in_end);
602     eCrossfade_out_start.set_ptr(&d->Crossfade.out_start);
603     eCrossfade_out_end.set_ptr(&d->Crossfade.out_end);
604 persson 1261
605 schoenebeck 1225 ePitchTrack.set_ptr(&d->PitchTrack);
606     eDimensionBypass.set_ptr(&d->DimensionBypass);
607     ePan.set_ptr(&d->Pan);
608     eSelfMask.set_ptr(&d->SelfMask);
609     eAttenuationController.set_ptr(&d->AttenuationController);
610     eInvertAttenuationController.set_ptr(&d->InvertAttenuationController);
611     eAttenuationControllerThreshold.set_ptr(&d->AttenuationControllerThreshold);
612     eChannelOffset.set_ptr(&d->ChannelOffset);
613     eSustainDefeat.set_ptr(&d->SustainDefeat);
614     eMSDecode.set_ptr(&d->MSDecode);
615     eSampleStartOffset.set_ptr(&d->SampleStartOffset);
616     eUnityNote.set_ptr(&d->UnityNote);
617     eFineTune.set_ptr(&d->FineTune);
618     eGain.set_ptr(&d->Gain);
619     eGainPlus6.set_ptr(&d->Gain);
620    
621     eSampleLoopEnabled.set_active(d->SampleLoops);
622     updateLoopElements();
623    
624     VCFEnabled_toggled();
625     }
626    
627     void DimRegionEdit::VCFEnabled_toggled()
628     {
629     bool sensitive = eVCFEnabled.get_active();
630     eVCFType.set_sensitive(sensitive);
631     eVCFCutoffController.set_sensitive(sensitive);
632     eVCFVelocityCurve.set_sensitive(sensitive);
633     eVCFVelocityScale.set_sensitive(sensitive);
634     eVCFVelocityDynamicRange.set_sensitive(sensitive);
635     eVCFResonance.set_sensitive(sensitive);
636     eVCFResonanceController.set_sensitive(sensitive);
637     eVCFKeyboardTracking.set_sensitive(sensitive);
638     eVCFKeyboardTrackingBreakpoint.set_sensitive(sensitive);
639     eEG2PreAttack.set_sensitive(sensitive);
640     eEG2Attack.set_sensitive(sensitive);
641     eEG2Decay1.set_sensitive(sensitive);
642     eEG2InfiniteSustain.set_sensitive(sensitive);
643     eEG2Sustain.set_sensitive(sensitive);
644     eEG2Release.set_sensitive(sensitive);
645     eEG2Controller.set_sensitive(sensitive);
646     eEG2ControllerAttackInfluence.set_sensitive(sensitive);
647     eEG2ControllerDecayInfluence.set_sensitive(sensitive);
648     eEG2ControllerReleaseInfluence.set_sensitive(sensitive);
649     eLFO2Frequency.set_sensitive(sensitive);
650     eLFO2InternalDepth.set_sensitive(sensitive);
651     eLFO2ControlDepth.set_sensitive(sensitive);
652     eLFO2Controller.set_sensitive(sensitive);
653     eLFO2FlipPhase.set_sensitive(sensitive);
654     eLFO2Sync.set_sensitive(sensitive);
655     if (sensitive) {
656     VCFCutoffController_changed();
657     VCFResonanceController_changed();
658     EG2InfiniteSustain_toggled();
659     EG2Controller_changed();
660     LFO2Controller_changed();
661     } else {
662     eVCFCutoffControllerInvert.set_sensitive(false);
663     eVCFCutoff.set_sensitive(false);
664     eVCFResonanceDynamic.set_sensitive(false);
665     eVCFResonance.set_sensitive(false);
666     eEG2Decay2.set_sensitive(false);
667     eEG2ControllerInvert.set_sensitive(false);
668     eLFO2InternalDepth.set_sensitive(false);
669     eLFO2ControlDepth.set_sensitive(false);
670     }
671     }
672    
673     void DimRegionEdit::VCFCutoffController_changed()
674     {
675     int rowno = eVCFCutoffController.get_active_row_number();
676     bool hasController = rowno != 0 && rowno != 1;
677    
678     eVCFCutoffControllerInvert.set_sensitive(hasController);
679     eVCFCutoff.set_sensitive(!hasController);
680     eVCFResonanceDynamic.set_sensitive(!hasController);
681     eVCFVelocityScale.label.set_text(hasController ? "Minimum cutoff:" :
682     "Velocity scale:");
683     }
684    
685     void DimRegionEdit::VCFResonanceController_changed()
686     {
687     bool hasController = eVCFResonanceController.get_active_row_number() != 0;
688     eVCFResonance.set_sensitive(!hasController);
689     }
690    
691     void DimRegionEdit::EG1InfiniteSustain_toggled()
692     {
693     bool infSus = eEG1InfiniteSustain.get_active();
694     eEG1Decay2.set_sensitive(!infSus);
695     }
696    
697     void DimRegionEdit::EG2InfiniteSustain_toggled()
698     {
699     bool infSus = eEG2InfiniteSustain.get_active();
700     eEG2Decay2.set_sensitive(!infSus);
701     }
702    
703     void DimRegionEdit::EG1Controller_changed()
704     {
705     bool hasController = eEG1Controller.get_active_row_number() != 0;
706     eEG1ControllerInvert.set_sensitive(hasController);
707     }
708    
709     void DimRegionEdit::EG2Controller_changed()
710     {
711     bool hasController = eEG2Controller.get_active_row_number() != 0;
712     eEG2ControllerInvert.set_sensitive(hasController);
713     }
714    
715     void DimRegionEdit::AttenuationController_changed()
716     {
717     bool hasController = eAttenuationController.get_active_row_number() != 0;
718     eInvertAttenuationController.set_sensitive(hasController);
719     eAttenuationControllerThreshold.set_sensitive(hasController);
720     eCrossfade_in_start.set_sensitive(hasController);
721     eCrossfade_in_end.set_sensitive(hasController);
722     eCrossfade_out_start.set_sensitive(hasController);
723     eCrossfade_out_end.set_sensitive(hasController);
724     }
725    
726     void DimRegionEdit::LFO1Controller_changed()
727     {
728     int rowno = eLFO1Controller.get_active_row_number();
729     eLFO1ControlDepth.set_sensitive(rowno != 0);
730     eLFO1InternalDepth.set_sensitive(rowno != 1 && rowno != 2);
731     }
732    
733     void DimRegionEdit::LFO2Controller_changed()
734     {
735     int rowno = eLFO2Controller.get_active_row_number();
736     eLFO2ControlDepth.set_sensitive(rowno != 0);
737     eLFO2InternalDepth.set_sensitive(rowno != 1 && rowno != 2);
738     }
739    
740     void DimRegionEdit::LFO3Controller_changed()
741     {
742     int rowno = eLFO3Controller.get_active_row_number();
743     eLFO3ControlDepth.set_sensitive(rowno != 0);
744     eLFO3InternalDepth.set_sensitive(rowno != 1 && rowno != 2);
745     }
746    
747     void DimRegionEdit::crossfade1_changed()
748     {
749     double c1 = eCrossfade_in_start.get_value();
750     double c2 = eCrossfade_in_end.get_value();
751     if (c1 > c2) eCrossfade_in_end.set_value(c1);
752     }
753    
754     void DimRegionEdit::crossfade2_changed()
755     {
756     double c1 = eCrossfade_in_start.get_value();
757     double c2 = eCrossfade_in_end.get_value();
758     double c3 = eCrossfade_out_start.get_value();
759    
760     if (c2 < c1) eCrossfade_in_start.set_value(c2);
761     if (c2 > c3) eCrossfade_out_start.set_value(c2);
762     }
763    
764     void DimRegionEdit::crossfade3_changed()
765     {
766     double c2 = eCrossfade_in_end.get_value();
767     double c3 = eCrossfade_out_start.get_value();
768     double c4 = eCrossfade_out_end.get_value();
769    
770     if (c3 < c2) eCrossfade_in_end.set_value(c3);
771     if (c3 > c4) eCrossfade_out_end.set_value(c3);
772     }
773    
774     void DimRegionEdit::crossfade4_changed()
775     {
776     double c3 = eCrossfade_out_start.get_value();
777     double c4 = eCrossfade_out_end.get_value();
778    
779     if (c4 < c3) eCrossfade_out_start.set_value(c4);
780     }
781    
782     void DimRegionEdit::loop_enabled_toggled()
783     {
784     const bool active = eSampleLoopEnabled.get_active();
785     if (active) {
786     // create a new sample loop in case there is none yet
787     if (!dimregion->SampleLoops) {
788     DLS::sample_loop_t loop;
789     loop.LoopType = gig::loop_type_normal;
790     // loop the whole sample by default
791     loop.LoopStart = 0;
792     loop.LoopLength =
793     (dimregion->pSample) ? dimregion->pSample->GetSize() : 0;
794     dimregion->AddSampleLoop(&loop);
795 persson 1261 dimreg_changed_signal();
796 schoenebeck 1225 }
797     } else {
798 persson 1261 if (dimregion->SampleLoops) {
799     // delete ALL existing sample loops
800     while (dimregion->SampleLoops) {
801     dimregion->DeleteSampleLoop(&dimregion->pSampleLoops[0]);
802     }
803     dimreg_changed_signal();
804     }
805 schoenebeck 1225 }
806     updateLoopElements();
807     }
808    
809     void DimRegionEdit::updateLoopElements()
810     {
811     const bool active = eSampleLoopEnabled.get_active();
812     eSampleLoopStart.set_sensitive(active);
813     eSampleLoopLength.set_sensitive(active);
814     eSampleLoopType.set_sensitive(active);
815     eSampleLoopInfinite.set_sensitive(active);
816 persson 1261 eSampleLoopStart.set_ptr(0);
817     eSampleLoopLength.set_ptr(0);
818     eSampleLoopPlayCount.set_ptr(0);
819    
820 schoenebeck 1225 if (dimregion && dimregion->SampleLoops) {
821     eSampleLoopStart.set_ptr(&dimregion->pSampleLoops[0].LoopStart);
822     eSampleLoopLength.set_ptr(&dimregion->pSampleLoops[0].LoopLength);
823     eSampleLoopType.set_ptr(&dimregion->pSampleLoops[0].LoopType);
824     eSampleLoopInfinite.set_active(
825     dimregion->pSample && !dimregion->pSample->LoopPlayCount
826     );
827 persson 1261 // updated enabled state of loop play count widget
828     loop_infinite_toggled();
829    
830     eSampleLoopPlayCount.set_ptr(
831     (dimregion->pSample) ? &dimregion->pSample->LoopPlayCount : 0
832     );
833    
834 schoenebeck 1225 // sample loop shall never be longer than the actual sample size
835     eSampleLoopStart.set_upper(
836     (dimregion->pSample)
837 persson 1265 ? dimregion->pSample->SamplesTotal -
838 schoenebeck 1225 dimregion->pSampleLoops[0].LoopLength
839     : 0
840     );
841     eSampleLoopLength.set_upper(
842     (dimregion->pSample)
843 persson 1265 ? dimregion->pSample->SamplesTotal -
844 schoenebeck 1225 dimregion->pSampleLoops[0].LoopStart
845     : 0
846     );
847     } else { // no sample loop(s)
848 persson 1261 eSampleLoopType.set_ptr(0);
849     // updated enabled state of loop play count widget
850     loop_infinite_toggled();
851 schoenebeck 1225 }
852     }
853    
854     void DimRegionEdit::loop_infinite_toggled() {
855     eSampleLoopPlayCount.set_sensitive(
856     !eSampleLoopInfinite.get_active() &&
857     eSampleLoopEnabled.get_active()
858     );
859     if (eSampleLoopInfinite.get_active())
860     eSampleLoopPlayCount.set_value(0);
861     else if (!eSampleLoopPlayCount.get_value())
862     eSampleLoopPlayCount.set_value(1);
863     }
864 persson 1265
865     bool DimRegionEdit::set_sample(gig::Sample* sample)
866     {
867     if (dimregion) {
868     dimregion->pSample = sample;
869    
870     // copy sample information from Sample to DimensionRegion
871    
872     dimregion->UnityNote = sample->MIDIUnityNote;
873     dimregion->FineTune = sample->FineTune;
874    
875     int loops = sample->Loops ? 1 : 0;
876     while (dimregion->SampleLoops > loops) {
877     dimregion->DeleteSampleLoop(&dimregion->pSampleLoops[0]);
878     }
879     while (dimregion->SampleLoops < sample->Loops) {
880     DLS::sample_loop_t loop;
881     dimregion->AddSampleLoop(&loop);
882     }
883     if (loops) {
884     dimregion->pSampleLoops[0].Size = sizeof(DLS::sample_loop_t);
885     dimregion->pSampleLoops[0].LoopType = sample->LoopType;
886     dimregion->pSampleLoops[0].LoopStart = sample->LoopStart;
887     dimregion->pSampleLoops[0].LoopLength = sample->LoopEnd - sample->LoopStart + 1;
888     }
889    
890     // update ui
891     wSample->set_text(dimregion->pSample->pInfo->Name);
892     eUnityNote.set_ptr(&dimregion->UnityNote);
893     eFineTune.set_ptr(&dimregion->FineTune);
894     eSampleLoopEnabled.set_active(dimregion->SampleLoops);
895     updateLoopElements();
896    
897     dimreg_changed_signal();
898     return true;
899     }
900     return false;
901     }

  ViewVC Help
Powered by ViewVC