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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1160 - (show annotations) (download)
Sun Apr 15 20:25:13 2007 UTC (11 years, 5 months ago) by schoenebeck
File size: 31423 byte(s)
* minor fix regarding sensitivity of a loop control GUI element

1 /*
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(ePan);
167 addProp(eChannelOffset);
168 addHeader("Loops");
169 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 addHeader("Crossfade");
185 addProp(eCrossfade_in_start);
186 addProp(eCrossfade_in_end);
187 addProp(eCrossfade_out_start);
188 addProp(eCrossfade_out_end);
189
190 nextPage();
191
192 addHeader(_("General Amplitude Settings"));
193 addProp(eGain);
194 addProp(eGainPlus6);
195 addProp(eAttenuationController);
196 addProp(eInvertAttenuationController);
197 addProp(eAttenuationControllerThreshold);
198 addHeader(_("Amplitude Envelope (EG1)"));
199 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
213 nextPage();
214
215 addHeader(_("Amplitude Oscillator (LFO1)"));
216 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 addHeader(_("General Filter Settings"));
238 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
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 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 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 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 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 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 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(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 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 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 dimregion = d;
517
518 set_sensitive(d);
519 if (!d) return;
520
521 update_gui = false;
522 wSample->set_text(d->pSample ? d->pSample->pInfo->Name.c_str() : "NULL");
523 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
606 eSampleLoopEnabled.set_active(d->SampleLoops);
607 updateLoopElements();
608
609 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 eVCFVelocityScale.label.set_text(hasController ? "Minimum cutoff:" :
669 "Velocity scale:");
670 }
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
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 // updated enabled state of loop play count widget
823 loop_infinite_toggled();
824 }
825
826 void DimRegionEdit::loop_infinite_toggled() {
827 eSampleLoopPlayCount.set_sensitive(
828 !eSampleLoopInfinite.get_active() &&
829 eSampleLoopEnabled.get_active()
830 );
831 if (eSampleLoopInfinite.get_active())
832 eSampleLoopPlayCount.set_value(0);
833 else if (!eSampleLoopPlayCount.get_value())
834 eSampleLoopPlayCount.set_value(1);
835 }

  ViewVC Help
Powered by ViewVC