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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1159 - (hide annotations) (download)
Fri Apr 13 17:57:26 2007 UTC (12 years, 7 months ago) by persson
File size: 31259 byte(s)
* improved labels in dimension region editor
* use normal layout for checkboxes

1 persson 1100 /*
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 schoenebeck 1153 #include <libintl.h>
23     #define _(String) gettext(String)
24    
25 persson 1100 DimRegionEdit::DimRegionEdit() :
26 persson 1159 eEG1PreAttack("Pre-attack", 0, 100, 2),
27 persson 1138 eEG1Attack("Attack", 0, 60, 3),
28 persson 1159 eEG1Decay1("Decay 1", 0.005, 60, 3),
29     eEG1Decay2("Decay 2", 0, 60, 3),
30     eEG1InfiniteSustain("Infinite sustain"),
31 persson 1138 eEG1Sustain("Sustain", 0, 100, 2),
32     eEG1Release("Release", 0, 60, 3),
33     eEG1Hold("Hold"),
34     eEG1Controller("Controller"),
35 persson 1159 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 persson 1138 eLFO1Frequency("Frequency", 0.1, 10, 2),
40 persson 1159 eLFO1InternalDepth("Internal depth", 0, 1200),
41     eLFO1ControlDepth("Control depth", 0, 1200),
42 persson 1138 eLFO1Controller("Controller"),
43 persson 1159 eLFO1FlipPhase("Flip phase"),
44 persson 1138 eLFO1Sync("Sync"),
45 persson 1159 eEG2PreAttack("Pre-attack", 0, 100, 2),
46 persson 1138 eEG2Attack("Attack", 0, 60, 3),
47 persson 1159 eEG2Decay1("Decay 1", 0.005, 60, 3),
48     eEG2Decay2("Decay 2", 0, 60, 3),
49     eEG2InfiniteSustain("Infinite sustain"),
50 persson 1138 eEG2Sustain("Sustain", 0, 100, 2),
51     eEG2Release("Release", 0, 60, 3),
52     eEG2Controller("Controller"),
53 persson 1159 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 persson 1138 eLFO2Frequency("Frequency", 0.1, 10, 2),
58 persson 1159 eLFO2InternalDepth("Internal depth", 0, 1200),
59     eLFO2ControlDepth("Control depth", 0, 1200),
60 persson 1138 eLFO2Controller("Controller"),
61 persson 1159 eLFO2FlipPhase("Flip phase"),
62 persson 1138 eLFO2Sync("Sync"),
63     eEG3Attack("Attack", 0, 10, 3),
64     eEG3Depth("Depth", -1200, 1200),
65     eLFO3Frequency("Frequency", 0.1, 10, 2),
66 persson 1159 eLFO3InternalDepth("Internal depth", 0, 1200),
67     eLFO3ControlDepth("Control depth", 0, 1200),
68 persson 1138 eLFO3Controller("Controller"),
69     eLFO3Sync("Sync"),
70     eVCFEnabled("Enabled"),
71     eVCFType("Type"),
72 persson 1159 eVCFCutoffController("Cutoff controller"),
73     eVCFCutoffControllerInvert("Cutoff controller invert"),
74 persson 1138 eVCFCutoff("Cutoff"),
75 persson 1159 eVCFVelocityCurve("Velocity curve"),
76     eVCFVelocityScale("Velocity scale"),
77     eVCFVelocityDynamicRange("Velocity dynamic range", 0, 4),
78 persson 1138 eVCFResonance("Resonance"),
79 persson 1159 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 persson 1138 ePan("Pan", -64, 63),
96 persson 1159 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 persson 1138 eGain("Gain", -96, 0, 2, -655360),
107     eGainPlus6("Gain +6dB", eGain, 6 * -655360),
108 schoenebeck 1156 eSampleLoopEnabled("Enabled"),
109 persson 1159 eSampleLoopStart("Loop start positon"),
110     eSampleLoopLength("Loop size"),
111     eSampleLoopType("Loop type"),
112     eSampleLoopInfinite("Infinite loop"),
113     eSampleLoopPlayCount("Playback count")
114 persson 1100 {
115 schoenebeck 1151 for (int i = 0 ; i < 7 ; i++) {
116 persson 1100 table[i] = new Gtk::Table(3, 1);
117 schoenebeck 1151 table[i]->set_col_spacings(7);
118 persson 1100 }
119    
120 schoenebeck 1153 // set tooltips
121     eUnityNote.set_tip(
122 persson 1159 _("Note this sample is associated with (a.k.a. 'root note')")
123 schoenebeck 1153 );
124 persson 1159 eSampleStartOffset.set_tip(_("Sample position at which playback should be started"));
125     ePan.set_tip(_("Stereo balance (left/right)"));
126 schoenebeck 1153 eChannelOffset.set_tip(
127 persson 1159 _("Output channel where the audio signal should be routed to (0 - 9)")
128 schoenebeck 1153 );
129     ePitchTrack.set_tip(
130 persson 1159 _("If true: sample will be pitched according to the key position "
131 schoenebeck 1153 "(this would be disabled for drums for example)")
132     );
133 persson 1159 eSampleLoopEnabled.set_tip(_("If enabled: repeats to playback the sample"));
134 schoenebeck 1156 eSampleLoopStart.set_tip(
135 persson 1159 _("Start position within the sample (in sample points) of the area to "
136 schoenebeck 1156 "be looped")
137     );
138     eSampleLoopLength.set_tip(
139 persson 1159 _("Duration (in sample points) of the area to be looped")
140 schoenebeck 1156 );
141     eSampleLoopType.set_tip(
142 persson 1159 _("Direction in which the loop area in the sample should be played back")
143 schoenebeck 1156 );
144     eSampleLoopInfinite.set_tip(
145 persson 1159 _("Whether the loop area should be played back forever\n"
146 schoenebeck 1156 "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 persson 1159 _("How many times the loop area should be played back\n"
151 schoenebeck 1156 "Caution: this setting is stored on Sample side, thus is shared "
152     "among all dimension regions that use this sample!")
153     );
154 schoenebeck 1153
155 persson 1100 pageno = 0;
156     rowno = 0;
157     firstRowInBlock = 0;
158    
159 persson 1159 addHeader(_("Mandatory Settings"));
160 persson 1100 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 persson 1159 tooltips.set_tip(*wSample, _("Drop a sample here"));
163 schoenebeck 1150 addProp(eUnityNote);
164 persson 1159 addHeader(_("Optional Settings"));
165 schoenebeck 1150 addProp(eSampleStartOffset);
166     addProp(ePan);
167     addProp(eChannelOffset);
168 persson 1159 addHeader("Loops");
169 schoenebeck 1156 addProp(eSampleLoopEnabled);
170     addProp(eSampleLoopStart);
171     addProp(eSampleLoopLength);
172     {
173     char* choices[] = { "normal", "bidirectional", "backward", 0 };
174     static const uint32_t values[] = {
175     gig::loop_type_normal,
176     gig::loop_type_bidirectional,
177     gig::loop_type_backward
178     };
179     eSampleLoopType.set_choices(choices, values);
180     }
181     addProp(eSampleLoopType);
182     addProp(eSampleLoopInfinite);
183     addProp(eSampleLoopPlayCount);
184 persson 1159 addHeader("Crossfade");
185 schoenebeck 1150 addProp(eCrossfade_in_start);
186     addProp(eCrossfade_in_end);
187     addProp(eCrossfade_out_start);
188     addProp(eCrossfade_out_end);
189    
190     nextPage();
191    
192 persson 1159 addHeader(_("General Amplitude Settings"));
193 schoenebeck 1150 addProp(eGain);
194     addProp(eGainPlus6);
195     addProp(eAttenuationController);
196     addProp(eInvertAttenuationController);
197     addProp(eAttenuationControllerThreshold);
198 persson 1159 addHeader(_("Amplitude Envelope (EG1)"));
199 persson 1100 addProp(eEG1PreAttack);
200     addProp(eEG1Attack);
201     addProp(eEG1Decay1);
202     addProp(eEG1Decay2);
203     addProp(eEG1InfiniteSustain);
204     addProp(eEG1Sustain);
205     addProp(eEG1Release);
206     addProp(eEG1Hold);
207     addProp(eEG1Controller);
208     addProp(eEG1ControllerInvert);
209     addProp(eEG1ControllerAttackInfluence);
210     addProp(eEG1ControllerDecayInfluence);
211     addProp(eEG1ControllerReleaseInfluence);
212 schoenebeck 1151
213     nextPage();
214    
215 persson 1159 addHeader(_("Amplitude Oscillator (LFO1)"));
216 persson 1100 addProp(eLFO1Frequency);
217     addProp(eLFO1InternalDepth);
218     addProp(eLFO1ControlDepth);
219     {
220     char* choices[] = { "internal", "modwheel", "breath",
221     "internal+modwheel", "internal+breath", 0 };
222     static const gig::lfo1_ctrl_t values[] = {
223     gig::lfo1_ctrl_internal,
224     gig::lfo1_ctrl_modwheel,
225     gig::lfo1_ctrl_breath,
226     gig::lfo1_ctrl_internal_modwheel,
227     gig::lfo1_ctrl_internal_breath
228     };
229     eLFO1Controller.set_choices(choices, values);
230     }
231     addProp(eLFO1Controller);
232     addProp(eLFO1FlipPhase);
233     addProp(eLFO1Sync);
234    
235     nextPage();
236    
237 persson 1159 addHeader(_("General Filter Settings"));
238 persson 1100 addProp(eVCFEnabled);
239     {
240     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     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     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     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 schoenebeck 1151
303     nextPage();
304    
305 persson 1159 addHeader(_("Filter Cutoff Envelope (EG2)"));
306 schoenebeck 1150 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 persson 1159 addHeader(_("Filter Cutoff Oscillator (LFO2)"));
319 schoenebeck 1150 addProp(eLFO2Frequency);
320     addProp(eLFO2InternalDepth);
321     addProp(eLFO2ControlDepth);
322     {
323     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 persson 1100
338     nextPage();
339    
340 persson 1159 addHeader(_("General Pitch Settings"));
341 schoenebeck 1150 addProp(eFineTune);
342     addProp(ePitchTrack);
343 persson 1159 addHeader(_("Pitch Envelope (EG3)"));
344 schoenebeck 1150 addProp(eEG3Attack);
345     addProp(eEG3Depth);
346 persson 1159 addHeader(_("Pitch Oscillator (LFO3)"));
347 schoenebeck 1150 addProp(eLFO3Frequency);
348     addProp(eLFO3InternalDepth);
349     addProp(eLFO3ControlDepth);
350     {
351     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 persson 1100 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     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 schoenebeck 1150 addProp(eMSDecode);
389 persson 1100
390     nextPage();
391    
392 schoenebeck 1150
393 persson 1100 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     eCrossfade_in_start.signal_value_changed().connect(
417     sigc::mem_fun(*this, &DimRegionEdit::crossfade1_changed));
418     eCrossfade_in_end.signal_value_changed().connect(
419     sigc::mem_fun(*this, &DimRegionEdit::crossfade2_changed));
420     eCrossfade_out_start.signal_value_changed().connect(
421     sigc::mem_fun(*this, &DimRegionEdit::crossfade3_changed));
422     eCrossfade_out_end.signal_value_changed().connect(
423     sigc::mem_fun(*this, &DimRegionEdit::crossfade4_changed));
424    
425 schoenebeck 1156 eSampleLoopEnabled.signal_toggled().connect(
426     sigc::mem_fun(*this, &DimRegionEdit::loop_enabled_toggled));
427     eSampleLoopStart.signal_value_changed().connect(
428     sigc::mem_fun(*this, &DimRegionEdit::updateLoopElements));
429     eSampleLoopLength.signal_value_changed().connect(
430     sigc::mem_fun(*this, &DimRegionEdit::updateLoopElements));
431     eSampleLoopInfinite.signal_toggled().connect(
432     sigc::mem_fun(*this, &DimRegionEdit::loop_infinite_toggled));
433    
434 schoenebeck 1150 append_page(*table[0], "Sample");
435 schoenebeck 1151 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 persson 1100 }
442    
443     DimRegionEdit::~DimRegionEdit()
444     {
445     }
446    
447     void DimRegionEdit::addString(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(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 persson 1159 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     }
503    
504 persson 1100 void DimRegionEdit::addProp(LabelWidget& prop)
505     {
506     table[pageno]->attach(prop.label, 1, 2, rowno, rowno + 1,
507     Gtk::FILL, Gtk::SHRINK);
508     table[pageno]->attach(prop.widget, 2, 3, rowno, rowno + 1,
509     Gtk::EXPAND | Gtk::FILL, Gtk::SHRINK);
510     rowno++;
511     }
512    
513    
514     void DimRegionEdit::set_dim_region(gig::DimensionRegion* d)
515     {
516 schoenebeck 1156 dimregion = d;
517    
518 persson 1104 set_sensitive(d);
519     if (!d) return;
520    
521 persson 1100 update_gui = false;
522     wSample->set_text(d->pSample ? d->pSample->pInfo->Name.c_str() : "NULL");
523 persson 1138 eEG1PreAttack.set_ptr(&d->EG1PreAttack);
524     eEG1Attack.set_ptr(&d->EG1Attack);
525     eEG1Decay1.set_ptr(&d->EG1Decay1);
526     eEG1Decay2.set_ptr(&d->EG1Decay2);
527     eEG1InfiniteSustain.set_ptr(&d->EG1InfiniteSustain);
528     eEG1Sustain.set_ptr(&d->EG1Sustain);
529     eEG1Release.set_ptr(&d->EG1Release);
530     eEG1Hold.set_ptr(&d->EG1Hold);
531     eEG1Controller.set_ptr(&d->EG1Controller);
532     eEG1ControllerInvert.set_ptr(&d->EG1ControllerInvert);
533     eEG1ControllerAttackInfluence.set_ptr(&d->EG1ControllerAttackInfluence);
534     eEG1ControllerDecayInfluence.set_ptr(&d->EG1ControllerDecayInfluence);
535     eEG1ControllerReleaseInfluence.set_ptr(&d->EG1ControllerReleaseInfluence);
536     eLFO1Frequency.set_ptr(&d->LFO1Frequency);
537     eLFO1InternalDepth.set_ptr(&d->LFO1InternalDepth);
538     eLFO1ControlDepth.set_ptr(&d->LFO1ControlDepth);
539     eLFO1Controller.set_ptr(&d->LFO1Controller);
540     eLFO1FlipPhase.set_ptr(&d->LFO1FlipPhase);
541     eLFO1Sync.set_ptr(&d->LFO1Sync);
542     eEG2PreAttack.set_ptr(&d->EG2PreAttack);
543     eEG2Attack.set_ptr(&d->EG2Attack);
544     eEG2Decay1.set_ptr(&d->EG2Decay1);
545     eEG2Decay2.set_ptr(&d->EG2Decay2);
546     eEG2InfiniteSustain.set_ptr(&d->EG2InfiniteSustain);
547     eEG2Sustain.set_ptr(&d->EG2Sustain);
548     eEG2Release.set_ptr(&d->EG2Release);
549     eEG2Controller.set_ptr(&d->EG2Controller);
550     eEG2ControllerInvert.set_ptr(&d->EG2ControllerInvert);
551     eEG2ControllerAttackInfluence.set_ptr(&d->EG2ControllerAttackInfluence);
552     eEG2ControllerDecayInfluence.set_ptr(&d->EG2ControllerDecayInfluence);
553     eEG2ControllerReleaseInfluence.set_ptr(&d->EG2ControllerReleaseInfluence);
554     eLFO2Frequency.set_ptr(&d->LFO2Frequency);
555     eLFO2InternalDepth.set_ptr(&d->LFO2InternalDepth);
556     eLFO2ControlDepth.set_ptr(&d->LFO2ControlDepth);
557     eLFO2Controller.set_ptr(&d->LFO2Controller);
558     eLFO2FlipPhase.set_ptr(&d->LFO2FlipPhase);
559     eLFO2Sync.set_ptr(&d->LFO2Sync);
560     eEG3Attack.set_ptr(&d->EG3Attack);
561     eEG3Depth.set_ptr(&d->EG3Depth);
562     eLFO3Frequency.set_ptr(&d->LFO3Frequency);
563     eLFO3InternalDepth.set_ptr(&d->LFO3InternalDepth);
564     eLFO3ControlDepth.set_ptr(&d->LFO3ControlDepth);
565     eLFO3Controller.set_ptr(&d->LFO3Controller);
566     eLFO3Sync.set_ptr(&d->LFO3Sync);
567     eVCFEnabled.set_ptr(&d->VCFEnabled);
568     eVCFType.set_ptr(&d->VCFType);
569     eVCFCutoffController.set_ptr(&d->VCFCutoffController);
570     eVCFCutoffControllerInvert.set_ptr(&d->VCFCutoffControllerInvert);
571     eVCFCutoff.set_ptr(&d->VCFCutoff);
572     eVCFVelocityCurve.set_ptr(&d->VCFVelocityCurve);
573     eVCFVelocityScale.set_ptr(&d->VCFVelocityScale);
574     eVCFVelocityDynamicRange.set_ptr(&d->VCFVelocityDynamicRange);
575     eVCFResonance.set_ptr(&d->VCFResonance);
576     eVCFResonanceDynamic.set_ptr(&d->VCFResonanceDynamic);
577     eVCFResonanceController.set_ptr(&d->VCFResonanceController);
578     eVCFKeyboardTracking.set_ptr(&d->VCFKeyboardTracking);
579     eVCFKeyboardTrackingBreakpoint.set_ptr(&d->VCFKeyboardTrackingBreakpoint);
580     eVelocityResponseCurve.set_ptr(&d->VelocityResponseCurve);
581     eVelocityResponseDepth.set_ptr(&d->VelocityResponseDepth);
582     eVelocityResponseCurveScaling.set_ptr(&d->VelocityResponseCurveScaling);
583     eReleaseVelocityResponseCurve.set_ptr(&d->ReleaseVelocityResponseCurve);
584     eReleaseVelocityResponseDepth.set_ptr(&d->ReleaseVelocityResponseDepth);
585     eReleaseTriggerDecay.set_ptr(&d->ReleaseTriggerDecay);
586     eCrossfade_in_start.set_ptr(&d->Crossfade.in_start);
587     eCrossfade_in_end.set_ptr(&d->Crossfade.in_end);
588     eCrossfade_out_start.set_ptr(&d->Crossfade.out_start);
589     eCrossfade_out_end.set_ptr(&d->Crossfade.out_end);
590     ePitchTrack.set_ptr(&d->PitchTrack);
591     eDimensionBypass.set_ptr(&d->DimensionBypass);
592     ePan.set_ptr(&d->Pan);
593     eSelfMask.set_ptr(&d->SelfMask);
594     eAttenuationController.set_ptr(&d->AttenuationController);
595     eInvertAttenuationController.set_ptr(&d->InvertAttenuationController);
596     eAttenuationControllerThreshold.set_ptr(&d->AttenuationControllerThreshold);
597     eChannelOffset.set_ptr(&d->ChannelOffset);
598     eSustainDefeat.set_ptr(&d->SustainDefeat);
599     eMSDecode.set_ptr(&d->MSDecode);
600     eSampleStartOffset.set_ptr(&d->SampleStartOffset);
601     eUnityNote.set_ptr(&d->UnityNote);
602     eFineTune.set_ptr(&d->FineTune);
603     eGain.set_ptr(&d->Gain);
604     eGainPlus6.set_ptr(&d->Gain);
605 persson 1100
606 schoenebeck 1156 eSampleLoopEnabled.set_active(d->SampleLoops);
607     updateLoopElements();
608    
609 persson 1100 VCFEnabled_toggled();
610    
611     update_gui = true;
612     }
613    
614     void DimRegionEdit::VCFEnabled_toggled()
615     {
616     bool sensitive = eVCFEnabled.get_active();
617     eVCFType.set_sensitive(sensitive);
618     eVCFCutoffController.set_sensitive(sensitive);
619     eVCFVelocityCurve.set_sensitive(sensitive);
620     eVCFVelocityScale.set_sensitive(sensitive);
621     eVCFVelocityDynamicRange.set_sensitive(sensitive);
622     eVCFResonance.set_sensitive(sensitive);
623     eVCFResonanceController.set_sensitive(sensitive);
624     eVCFKeyboardTracking.set_sensitive(sensitive);
625     eVCFKeyboardTrackingBreakpoint.set_sensitive(sensitive);
626     eEG2PreAttack.set_sensitive(sensitive);
627     eEG2Attack.set_sensitive(sensitive);
628     eEG2Decay1.set_sensitive(sensitive);
629     eEG2InfiniteSustain.set_sensitive(sensitive);
630     eEG2Sustain.set_sensitive(sensitive);
631     eEG2Release.set_sensitive(sensitive);
632     eEG2Controller.set_sensitive(sensitive);
633     eEG2ControllerAttackInfluence.set_sensitive(sensitive);
634     eEG2ControllerDecayInfluence.set_sensitive(sensitive);
635     eEG2ControllerReleaseInfluence.set_sensitive(sensitive);
636     eLFO2Frequency.set_sensitive(sensitive);
637     eLFO2InternalDepth.set_sensitive(sensitive);
638     eLFO2ControlDepth.set_sensitive(sensitive);
639     eLFO2Controller.set_sensitive(sensitive);
640     eLFO2FlipPhase.set_sensitive(sensitive);
641     eLFO2Sync.set_sensitive(sensitive);
642     if (sensitive) {
643     VCFCutoffController_changed();
644     VCFResonanceController_changed();
645     EG2InfiniteSustain_toggled();
646     EG2Controller_changed();
647     LFO2Controller_changed();
648     } else {
649     eVCFCutoffControllerInvert.set_sensitive(false);
650     eVCFCutoff.set_sensitive(false);
651     eVCFResonanceDynamic.set_sensitive(false);
652     eVCFResonance.set_sensitive(false);
653     eEG2Decay2.set_sensitive(false);
654     eEG2ControllerInvert.set_sensitive(false);
655     eLFO2InternalDepth.set_sensitive(false);
656     eLFO2ControlDepth.set_sensitive(false);
657     }
658     }
659    
660     void DimRegionEdit::VCFCutoffController_changed()
661     {
662     int rowno = eVCFCutoffController.get_active_row_number();
663     bool hasController = rowno != 0 && rowno != 1;
664    
665     eVCFCutoffControllerInvert.set_sensitive(hasController);
666     eVCFCutoff.set_sensitive(!hasController);
667     eVCFResonanceDynamic.set_sensitive(!hasController);
668 persson 1159 eVCFVelocityScale.label.set_text(hasController ? "Minimum cutoff:" :
669     "Velocity scale:");
670 persson 1100 }
671    
672     void DimRegionEdit::VCFResonanceController_changed()
673     {
674     bool hasController = eVCFResonanceController.get_active_row_number() != 0;
675     eVCFResonance.set_sensitive(!hasController);
676     }
677    
678     void DimRegionEdit::EG1InfiniteSustain_toggled()
679     {
680     bool infSus = eEG1InfiniteSustain.get_active();
681     eEG1Decay2.set_sensitive(!infSus);
682     }
683    
684     void DimRegionEdit::EG2InfiniteSustain_toggled()
685     {
686     bool infSus = eEG2InfiniteSustain.get_active();
687     eEG2Decay2.set_sensitive(!infSus);
688     }
689    
690     void DimRegionEdit::EG1Controller_changed()
691     {
692     bool hasController = eEG1Controller.get_active_row_number() != 0;
693     eEG1ControllerInvert.set_sensitive(hasController);
694     }
695    
696     void DimRegionEdit::EG2Controller_changed()
697     {
698     bool hasController = eEG2Controller.get_active_row_number() != 0;
699     eEG2ControllerInvert.set_sensitive(hasController);
700     }
701    
702     void DimRegionEdit::AttenuationController_changed()
703     {
704     bool hasController = eAttenuationController.get_active_row_number() != 0;
705     eInvertAttenuationController.set_sensitive(hasController);
706     }
707    
708     void DimRegionEdit::LFO1Controller_changed()
709     {
710     int rowno = eLFO1Controller.get_active_row_number();
711     eLFO1ControlDepth.set_sensitive(rowno != 0);
712     eLFO1InternalDepth.set_sensitive(rowno != 1 && rowno != 2);
713     }
714    
715     void DimRegionEdit::LFO2Controller_changed()
716     {
717     int rowno = eLFO2Controller.get_active_row_number();
718     eLFO2ControlDepth.set_sensitive(rowno != 0);
719     eLFO2InternalDepth.set_sensitive(rowno != 1 && rowno != 2);
720     }
721    
722     void DimRegionEdit::LFO3Controller_changed()
723     {
724     int rowno = eLFO3Controller.get_active_row_number();
725     eLFO3ControlDepth.set_sensitive(rowno != 0);
726     eLFO3InternalDepth.set_sensitive(rowno != 1 && rowno != 2);
727     }
728    
729     void DimRegionEdit::crossfade1_changed()
730     {
731     double c1 = eCrossfade_in_start.get_value();
732     double c2 = eCrossfade_in_end.get_value();
733     if (c1 > c2) eCrossfade_in_end.set_value(c1);
734     }
735    
736     void DimRegionEdit::crossfade2_changed()
737     {
738     double c1 = eCrossfade_in_start.get_value();
739     double c2 = eCrossfade_in_end.get_value();
740     double c3 = eCrossfade_out_start.get_value();
741    
742     if (c2 < c1) eCrossfade_in_start.set_value(c2);
743     if (c2 > c3) eCrossfade_out_start.set_value(c2);
744     }
745    
746     void DimRegionEdit::crossfade3_changed()
747     {
748     double c2 = eCrossfade_in_end.get_value();
749     double c3 = eCrossfade_out_start.get_value();
750     double c4 = eCrossfade_out_end.get_value();
751    
752     if (c3 < c2) eCrossfade_in_end.set_value(c3);
753     if (c3 > c4) eCrossfade_out_end.set_value(c3);
754     }
755    
756     void DimRegionEdit::crossfade4_changed()
757     {
758     double c3 = eCrossfade_out_start.get_value();
759     double c4 = eCrossfade_out_end.get_value();
760    
761     if (c4 < c3) eCrossfade_out_start.set_value(c4);
762     }
763 schoenebeck 1156
764     void DimRegionEdit::loop_enabled_toggled()
765     {
766     const bool active = eSampleLoopEnabled.get_active();
767     if (active) {
768     // create a new sample loop in case there is none yet
769     if (!dimregion->SampleLoops) {
770     DLS::sample_loop_t loop;
771     loop.LoopType = gig::loop_type_normal;
772     // loop the whole sample by default
773     loop.LoopStart = 0;
774     loop.LoopLength =
775     (dimregion->pSample) ? dimregion->pSample->GetSize() : 0;
776     dimregion->AddSampleLoop(&loop);
777     }
778     } else {
779     // delete ALL existing sample loops
780     while (dimregion->SampleLoops)
781     dimregion->DeleteSampleLoop(&dimregion->pSampleLoops[0]);
782     }
783     updateLoopElements();
784     }
785    
786     void DimRegionEdit::updateLoopElements()
787     {
788     const bool active = eSampleLoopEnabled.get_active();
789     eSampleLoopStart.set_sensitive(active);
790     eSampleLoopLength.set_sensitive(active);
791     eSampleLoopType.set_sensitive(active);
792     eSampleLoopInfinite.set_sensitive(active);
793     if (dimregion && dimregion->SampleLoops) {
794     eSampleLoopStart.set_ptr(&dimregion->pSampleLoops[0].LoopStart);
795     eSampleLoopLength.set_ptr(&dimregion->pSampleLoops[0].LoopLength);
796     eSampleLoopType.set_ptr(&dimregion->pSampleLoops[0].LoopType);
797     eSampleLoopPlayCount.set_ptr(
798     (dimregion->pSample) ? &dimregion->pSample->LoopPlayCount : NULL
799     );
800     eSampleLoopInfinite.set_active(
801     dimregion->pSample && !dimregion->pSample->LoopPlayCount
802     );
803     // sample loop shall never be longer than the actual sample size
804     eSampleLoopStart.set_upper(
805     (dimregion->pSample)
806     ? dimregion->pSample->GetSize() -
807     dimregion->pSampleLoops[0].LoopLength
808     : 0
809     );
810     eSampleLoopLength.set_upper(
811     (dimregion->pSample)
812     ? dimregion->pSample->GetSize() -
813     dimregion->pSampleLoops[0].LoopStart
814     : 0
815     );
816     } else { // no sample loop(s)
817     eSampleLoopStart.set_ptr(NULL);
818     eSampleLoopLength.set_ptr(NULL);
819     eSampleLoopType.set_ptr(NULL);
820     eSampleLoopPlayCount.set_ptr(NULL);
821     }
822     }
823    
824     void DimRegionEdit::loop_infinite_toggled() {
825     eSampleLoopPlayCount.set_sensitive(!eSampleLoopInfinite.get_active());
826     if (eSampleLoopInfinite.get_active()) eSampleLoopPlayCount.set_value(0);
827 schoenebeck 1157 else eSampleLoopPlayCount.set_value(1);
828 schoenebeck 1156 }

  ViewVC Help
Powered by ViewVC