/[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 1261 - (hide annotations) (download)
Thu Jul 5 17:12:20 2007 UTC (13 years ago) by persson
File size: 32309 byte(s)
* a changed file is now marked with an asterisk in the window title
* added close confirmation dialog, shown if file is changed
* "save" means "save as" for new files
* enabled acceleration keys
* add .gig to filename in "save as" if it's not already there
* filename character encodings other than utf-8 supported

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     void DimRegionEdit::addProp(LabelWidget& prop)
506     {
507     table[pageno]->attach(prop.label, 1, 2, rowno, rowno + 1,
508     Gtk::FILL, Gtk::SHRINK);
509     table[pageno]->attach(prop.widget, 2, 3, rowno, rowno + 1,
510     Gtk::EXPAND | Gtk::FILL, Gtk::SHRINK);
511     rowno++;
512 persson 1261 prop.signal_changed_by_user().connect(dimreg_changed_signal.make_slot());
513 schoenebeck 1225 }
514    
515    
516     void DimRegionEdit::set_dim_region(gig::DimensionRegion* d)
517     {
518     dimregion = d;
519    
520     set_sensitive(d);
521     if (!d) return;
522    
523     wSample->set_text(d->pSample ? d->pSample->pInfo->Name.c_str() : "NULL");
524     eEG1PreAttack.set_ptr(&d->EG1PreAttack);
525     eEG1Attack.set_ptr(&d->EG1Attack);
526     eEG1Decay1.set_ptr(&d->EG1Decay1);
527     eEG1Decay2.set_ptr(&d->EG1Decay2);
528     eEG1InfiniteSustain.set_ptr(&d->EG1InfiniteSustain);
529     eEG1Sustain.set_ptr(&d->EG1Sustain);
530     eEG1Release.set_ptr(&d->EG1Release);
531     eEG1Hold.set_ptr(&d->EG1Hold);
532     eEG1Controller.set_ptr(&d->EG1Controller);
533     eEG1ControllerInvert.set_ptr(&d->EG1ControllerInvert);
534     eEG1ControllerAttackInfluence.set_ptr(&d->EG1ControllerAttackInfluence);
535     eEG1ControllerDecayInfluence.set_ptr(&d->EG1ControllerDecayInfluence);
536     eEG1ControllerReleaseInfluence.set_ptr(&d->EG1ControllerReleaseInfluence);
537     eLFO1Frequency.set_ptr(&d->LFO1Frequency);
538     eLFO1InternalDepth.set_ptr(&d->LFO1InternalDepth);
539     eLFO1ControlDepth.set_ptr(&d->LFO1ControlDepth);
540     eLFO1Controller.set_ptr(&d->LFO1Controller);
541     eLFO1FlipPhase.set_ptr(&d->LFO1FlipPhase);
542     eLFO1Sync.set_ptr(&d->LFO1Sync);
543     eEG2PreAttack.set_ptr(&d->EG2PreAttack);
544     eEG2Attack.set_ptr(&d->EG2Attack);
545     eEG2Decay1.set_ptr(&d->EG2Decay1);
546     eEG2Decay2.set_ptr(&d->EG2Decay2);
547     eEG2InfiniteSustain.set_ptr(&d->EG2InfiniteSustain);
548     eEG2Sustain.set_ptr(&d->EG2Sustain);
549     eEG2Release.set_ptr(&d->EG2Release);
550     eEG2Controller.set_ptr(&d->EG2Controller);
551     eEG2ControllerInvert.set_ptr(&d->EG2ControllerInvert);
552     eEG2ControllerAttackInfluence.set_ptr(&d->EG2ControllerAttackInfluence);
553     eEG2ControllerDecayInfluence.set_ptr(&d->EG2ControllerDecayInfluence);
554     eEG2ControllerReleaseInfluence.set_ptr(&d->EG2ControllerReleaseInfluence);
555     eLFO2Frequency.set_ptr(&d->LFO2Frequency);
556     eLFO2InternalDepth.set_ptr(&d->LFO2InternalDepth);
557     eLFO2ControlDepth.set_ptr(&d->LFO2ControlDepth);
558     eLFO2Controller.set_ptr(&d->LFO2Controller);
559     eLFO2FlipPhase.set_ptr(&d->LFO2FlipPhase);
560     eLFO2Sync.set_ptr(&d->LFO2Sync);
561     eEG3Attack.set_ptr(&d->EG3Attack);
562     eEG3Depth.set_ptr(&d->EG3Depth);
563     eLFO3Frequency.set_ptr(&d->LFO3Frequency);
564     eLFO3InternalDepth.set_ptr(&d->LFO3InternalDepth);
565     eLFO3ControlDepth.set_ptr(&d->LFO3ControlDepth);
566     eLFO3Controller.set_ptr(&d->LFO3Controller);
567     eLFO3Sync.set_ptr(&d->LFO3Sync);
568     eVCFEnabled.set_ptr(&d->VCFEnabled);
569     eVCFType.set_ptr(&d->VCFType);
570     eVCFCutoffController.set_ptr(&d->VCFCutoffController);
571     eVCFCutoffControllerInvert.set_ptr(&d->VCFCutoffControllerInvert);
572     eVCFCutoff.set_ptr(&d->VCFCutoff);
573     eVCFVelocityCurve.set_ptr(&d->VCFVelocityCurve);
574     eVCFVelocityScale.set_ptr(&d->VCFVelocityScale);
575     eVCFVelocityDynamicRange.set_ptr(&d->VCFVelocityDynamicRange);
576     eVCFResonance.set_ptr(&d->VCFResonance);
577     eVCFResonanceDynamic.set_ptr(&d->VCFResonanceDynamic);
578     eVCFResonanceController.set_ptr(&d->VCFResonanceController);
579     eVCFKeyboardTracking.set_ptr(&d->VCFKeyboardTracking);
580     eVCFKeyboardTrackingBreakpoint.set_ptr(&d->VCFKeyboardTrackingBreakpoint);
581     eVelocityResponseCurve.set_ptr(&d->VelocityResponseCurve);
582     eVelocityResponseDepth.set_ptr(&d->VelocityResponseDepth);
583     eVelocityResponseCurveScaling.set_ptr(&d->VelocityResponseCurveScaling);
584     eReleaseVelocityResponseCurve.set_ptr(&d->ReleaseVelocityResponseCurve);
585     eReleaseVelocityResponseDepth.set_ptr(&d->ReleaseVelocityResponseDepth);
586     eReleaseTriggerDecay.set_ptr(&d->ReleaseTriggerDecay);
587 persson 1261
588     eCrossfade_in_start.set_ptr(0);
589     eCrossfade_in_end.set_ptr(0);
590     eCrossfade_out_start.set_ptr(0);
591     eCrossfade_out_end.set_ptr(0);
592 schoenebeck 1225 eCrossfade_in_start.set_ptr(&d->Crossfade.in_start);
593     eCrossfade_in_end.set_ptr(&d->Crossfade.in_end);
594     eCrossfade_out_start.set_ptr(&d->Crossfade.out_start);
595     eCrossfade_out_end.set_ptr(&d->Crossfade.out_end);
596 persson 1261
597 schoenebeck 1225 ePitchTrack.set_ptr(&d->PitchTrack);
598     eDimensionBypass.set_ptr(&d->DimensionBypass);
599     ePan.set_ptr(&d->Pan);
600     eSelfMask.set_ptr(&d->SelfMask);
601     eAttenuationController.set_ptr(&d->AttenuationController);
602     eInvertAttenuationController.set_ptr(&d->InvertAttenuationController);
603     eAttenuationControllerThreshold.set_ptr(&d->AttenuationControllerThreshold);
604     eChannelOffset.set_ptr(&d->ChannelOffset);
605     eSustainDefeat.set_ptr(&d->SustainDefeat);
606     eMSDecode.set_ptr(&d->MSDecode);
607     eSampleStartOffset.set_ptr(&d->SampleStartOffset);
608     eUnityNote.set_ptr(&d->UnityNote);
609     eFineTune.set_ptr(&d->FineTune);
610     eGain.set_ptr(&d->Gain);
611     eGainPlus6.set_ptr(&d->Gain);
612    
613     eSampleLoopEnabled.set_active(d->SampleLoops);
614     updateLoopElements();
615    
616     VCFEnabled_toggled();
617     }
618    
619     void DimRegionEdit::VCFEnabled_toggled()
620     {
621     bool sensitive = eVCFEnabled.get_active();
622     eVCFType.set_sensitive(sensitive);
623     eVCFCutoffController.set_sensitive(sensitive);
624     eVCFVelocityCurve.set_sensitive(sensitive);
625     eVCFVelocityScale.set_sensitive(sensitive);
626     eVCFVelocityDynamicRange.set_sensitive(sensitive);
627     eVCFResonance.set_sensitive(sensitive);
628     eVCFResonanceController.set_sensitive(sensitive);
629     eVCFKeyboardTracking.set_sensitive(sensitive);
630     eVCFKeyboardTrackingBreakpoint.set_sensitive(sensitive);
631     eEG2PreAttack.set_sensitive(sensitive);
632     eEG2Attack.set_sensitive(sensitive);
633     eEG2Decay1.set_sensitive(sensitive);
634     eEG2InfiniteSustain.set_sensitive(sensitive);
635     eEG2Sustain.set_sensitive(sensitive);
636     eEG2Release.set_sensitive(sensitive);
637     eEG2Controller.set_sensitive(sensitive);
638     eEG2ControllerAttackInfluence.set_sensitive(sensitive);
639     eEG2ControllerDecayInfluence.set_sensitive(sensitive);
640     eEG2ControllerReleaseInfluence.set_sensitive(sensitive);
641     eLFO2Frequency.set_sensitive(sensitive);
642     eLFO2InternalDepth.set_sensitive(sensitive);
643     eLFO2ControlDepth.set_sensitive(sensitive);
644     eLFO2Controller.set_sensitive(sensitive);
645     eLFO2FlipPhase.set_sensitive(sensitive);
646     eLFO2Sync.set_sensitive(sensitive);
647     if (sensitive) {
648     VCFCutoffController_changed();
649     VCFResonanceController_changed();
650     EG2InfiniteSustain_toggled();
651     EG2Controller_changed();
652     LFO2Controller_changed();
653     } else {
654     eVCFCutoffControllerInvert.set_sensitive(false);
655     eVCFCutoff.set_sensitive(false);
656     eVCFResonanceDynamic.set_sensitive(false);
657     eVCFResonance.set_sensitive(false);
658     eEG2Decay2.set_sensitive(false);
659     eEG2ControllerInvert.set_sensitive(false);
660     eLFO2InternalDepth.set_sensitive(false);
661     eLFO2ControlDepth.set_sensitive(false);
662     }
663     }
664    
665     void DimRegionEdit::VCFCutoffController_changed()
666     {
667     int rowno = eVCFCutoffController.get_active_row_number();
668     bool hasController = rowno != 0 && rowno != 1;
669    
670     eVCFCutoffControllerInvert.set_sensitive(hasController);
671     eVCFCutoff.set_sensitive(!hasController);
672     eVCFResonanceDynamic.set_sensitive(!hasController);
673     eVCFVelocityScale.label.set_text(hasController ? "Minimum cutoff:" :
674     "Velocity scale:");
675     }
676    
677     void DimRegionEdit::VCFResonanceController_changed()
678     {
679     bool hasController = eVCFResonanceController.get_active_row_number() != 0;
680     eVCFResonance.set_sensitive(!hasController);
681     }
682    
683     void DimRegionEdit::EG1InfiniteSustain_toggled()
684     {
685     bool infSus = eEG1InfiniteSustain.get_active();
686     eEG1Decay2.set_sensitive(!infSus);
687     }
688    
689     void DimRegionEdit::EG2InfiniteSustain_toggled()
690     {
691     bool infSus = eEG2InfiniteSustain.get_active();
692     eEG2Decay2.set_sensitive(!infSus);
693     }
694    
695     void DimRegionEdit::EG1Controller_changed()
696     {
697     bool hasController = eEG1Controller.get_active_row_number() != 0;
698     eEG1ControllerInvert.set_sensitive(hasController);
699     }
700    
701     void DimRegionEdit::EG2Controller_changed()
702     {
703     bool hasController = eEG2Controller.get_active_row_number() != 0;
704     eEG2ControllerInvert.set_sensitive(hasController);
705     }
706    
707     void DimRegionEdit::AttenuationController_changed()
708     {
709     bool hasController = eAttenuationController.get_active_row_number() != 0;
710     eInvertAttenuationController.set_sensitive(hasController);
711     eAttenuationControllerThreshold.set_sensitive(hasController);
712     eCrossfade_in_start.set_sensitive(hasController);
713     eCrossfade_in_end.set_sensitive(hasController);
714     eCrossfade_out_start.set_sensitive(hasController);
715     eCrossfade_out_end.set_sensitive(hasController);
716     }
717    
718     void DimRegionEdit::LFO1Controller_changed()
719     {
720     int rowno = eLFO1Controller.get_active_row_number();
721     eLFO1ControlDepth.set_sensitive(rowno != 0);
722     eLFO1InternalDepth.set_sensitive(rowno != 1 && rowno != 2);
723     }
724    
725     void DimRegionEdit::LFO2Controller_changed()
726     {
727     int rowno = eLFO2Controller.get_active_row_number();
728     eLFO2ControlDepth.set_sensitive(rowno != 0);
729     eLFO2InternalDepth.set_sensitive(rowno != 1 && rowno != 2);
730     }
731    
732     void DimRegionEdit::LFO3Controller_changed()
733     {
734     int rowno = eLFO3Controller.get_active_row_number();
735     eLFO3ControlDepth.set_sensitive(rowno != 0);
736     eLFO3InternalDepth.set_sensitive(rowno != 1 && rowno != 2);
737     }
738    
739     void DimRegionEdit::crossfade1_changed()
740     {
741     double c1 = eCrossfade_in_start.get_value();
742     double c2 = eCrossfade_in_end.get_value();
743     if (c1 > c2) eCrossfade_in_end.set_value(c1);
744     }
745    
746     void DimRegionEdit::crossfade2_changed()
747     {
748     double c1 = eCrossfade_in_start.get_value();
749     double c2 = eCrossfade_in_end.get_value();
750     double c3 = eCrossfade_out_start.get_value();
751    
752     if (c2 < c1) eCrossfade_in_start.set_value(c2);
753     if (c2 > c3) eCrossfade_out_start.set_value(c2);
754     }
755    
756     void DimRegionEdit::crossfade3_changed()
757     {
758     double c2 = eCrossfade_in_end.get_value();
759     double c3 = eCrossfade_out_start.get_value();
760     double c4 = eCrossfade_out_end.get_value();
761    
762     if (c3 < c2) eCrossfade_in_end.set_value(c3);
763     if (c3 > c4) eCrossfade_out_end.set_value(c3);
764     }
765    
766     void DimRegionEdit::crossfade4_changed()
767     {
768     double c3 = eCrossfade_out_start.get_value();
769     double c4 = eCrossfade_out_end.get_value();
770    
771     if (c4 < c3) eCrossfade_out_start.set_value(c4);
772     }
773    
774     void DimRegionEdit::loop_enabled_toggled()
775     {
776     const bool active = eSampleLoopEnabled.get_active();
777     if (active) {
778     // create a new sample loop in case there is none yet
779     if (!dimregion->SampleLoops) {
780     DLS::sample_loop_t loop;
781     loop.LoopType = gig::loop_type_normal;
782     // loop the whole sample by default
783     loop.LoopStart = 0;
784     loop.LoopLength =
785     (dimregion->pSample) ? dimregion->pSample->GetSize() : 0;
786     dimregion->AddSampleLoop(&loop);
787 persson 1261 dimreg_changed_signal();
788 schoenebeck 1225 }
789     } else {
790 persson 1261 if (dimregion->SampleLoops) {
791     // delete ALL existing sample loops
792     while (dimregion->SampleLoops) {
793     dimregion->DeleteSampleLoop(&dimregion->pSampleLoops[0]);
794     }
795     dimreg_changed_signal();
796     }
797 schoenebeck 1225 }
798     updateLoopElements();
799     }
800    
801     void DimRegionEdit::updateLoopElements()
802     {
803     const bool active = eSampleLoopEnabled.get_active();
804     eSampleLoopStart.set_sensitive(active);
805     eSampleLoopLength.set_sensitive(active);
806     eSampleLoopType.set_sensitive(active);
807     eSampleLoopInfinite.set_sensitive(active);
808 persson 1261 eSampleLoopStart.set_ptr(0);
809     eSampleLoopLength.set_ptr(0);
810     eSampleLoopPlayCount.set_ptr(0);
811    
812 schoenebeck 1225 if (dimregion && dimregion->SampleLoops) {
813     eSampleLoopStart.set_ptr(&dimregion->pSampleLoops[0].LoopStart);
814     eSampleLoopLength.set_ptr(&dimregion->pSampleLoops[0].LoopLength);
815     eSampleLoopType.set_ptr(&dimregion->pSampleLoops[0].LoopType);
816     eSampleLoopInfinite.set_active(
817     dimregion->pSample && !dimregion->pSample->LoopPlayCount
818     );
819 persson 1261 // updated enabled state of loop play count widget
820     loop_infinite_toggled();
821    
822     eSampleLoopPlayCount.set_ptr(
823     (dimregion->pSample) ? &dimregion->pSample->LoopPlayCount : 0
824     );
825    
826 schoenebeck 1225 // sample loop shall never be longer than the actual sample size
827     eSampleLoopStart.set_upper(
828     (dimregion->pSample)
829     ? dimregion->pSample->GetSize() -
830     dimregion->pSampleLoops[0].LoopLength
831     : 0
832     );
833     eSampleLoopLength.set_upper(
834     (dimregion->pSample)
835     ? dimregion->pSample->GetSize() -
836     dimregion->pSampleLoops[0].LoopStart
837     : 0
838     );
839     } else { // no sample loop(s)
840 persson 1261 eSampleLoopType.set_ptr(0);
841     // updated enabled state of loop play count widget
842     loop_infinite_toggled();
843 schoenebeck 1225 }
844     }
845    
846     void DimRegionEdit::loop_infinite_toggled() {
847     eSampleLoopPlayCount.set_sensitive(
848     !eSampleLoopInfinite.get_active() &&
849     eSampleLoopEnabled.get_active()
850     );
851     if (eSampleLoopInfinite.get_active())
852     eSampleLoopPlayCount.set_value(0);
853     else if (!eSampleLoopPlayCount.get_value())
854     eSampleLoopPlayCount.set_value(1);
855     }

  ViewVC Help
Powered by ViewVC