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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1262 - (show annotations) (download)
Sun Jul 22 15:07:08 2007 UTC (12 years, 2 months ago) by persson
File size: 32584 byte(s)
* regions can now be moved, not just resized
* improved labels in instrument properties dialog
* remove file extensions from file names when importing samples
* fixed some more checkbox layouts

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

  ViewVC Help
Powered by ViewVC