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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1117 - (show annotations) (download)
Sat Mar 24 13:05:58 2007 UTC (17 years ago) by persson
File size: 29145 byte(s)
* added +6dB parameter to DimRegionEdit
* preparations for improved instrument properties dialog

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 bool update_gui;
23
24 namespace {
25 uint8_t& access_UnityNote(gig::DimensionRegion* dimreg)
26 {
27 return dimreg->UnityNote;
28 }
29 int16_t& access_FineTune(gig::DimensionRegion* dimreg)
30 {
31 return dimreg->FineTune;
32 }
33 uint32_t& access_SampleLoops(gig::DimensionRegion* dimreg)
34 {
35 return dimreg->SampleLoops;
36 }
37 uint8_t& access_Crossfade_in_start(gig::DimensionRegion* dimreg)
38 {
39 return dimreg->Crossfade.in_start;
40 }
41 uint8_t& access_Crossfade_in_end(gig::DimensionRegion* dimreg)
42 {
43 return dimreg->Crossfade.in_end;
44 }
45 uint8_t& access_Crossfade_out_start(gig::DimensionRegion* dimreg)
46 {
47 return dimreg->Crossfade.out_start;
48 }
49 uint8_t& access_Crossfade_out_end(gig::DimensionRegion* dimreg)
50 {
51 return dimreg->Crossfade.out_end;
52 }
53 }
54
55 DimRegionEdit::DimRegionEdit() :
56 eEG1PreAttack("PreAttack", &gig::DimensionRegion::EG1PreAttack, 0, 100, 2),
57 eEG1Attack("Attack", &gig::DimensionRegion::EG1Attack, 0, 60, 3),
58 eEG1Decay1("Decay1", &gig::DimensionRegion::EG1Decay1, 0.005, 60, 3),
59 eEG1Decay2("Decay2", &gig::DimensionRegion::EG1Decay2, 0, 60, 3),
60 eEG1InfiniteSustain("InfiniteSustain",
61 &gig::DimensionRegion::EG1InfiniteSustain),
62 eEG1Sustain("Sustain", &gig::DimensionRegion::EG1Sustain, 0, 100, 2),
63 eEG1Release("Release", &gig::DimensionRegion::EG1Release, 0, 60, 3),
64 eEG1Hold("Hold", &gig::DimensionRegion::EG1Hold),
65 eEG1Controller("Controller", &gig::DimensionRegion::EG1Controller),
66 eEG1ControllerInvert("ControllerInvert",
67 &gig::DimensionRegion::EG1ControllerInvert),
68 eEG1ControllerAttackInfluence("ControllerAttackInfluence",
69 &gig::DimensionRegion::EG1ControllerAttackInfluence,
70 0, 3),
71 eEG1ControllerDecayInfluence("ControllerDecayInfluence",
72 &gig::DimensionRegion::EG1ControllerDecayInfluence,
73 0, 3),
74 eEG1ControllerReleaseInfluence("ControllerReleaseInfluence",
75 &gig::DimensionRegion::EG1ControllerReleaseInfluence,
76 0, 3),
77 eLFO1Frequency("Frequency", &gig::DimensionRegion::LFO1Frequency,
78 0.1, 10, 2),
79 eLFO1InternalDepth("InternalDepth",
80 &gig::DimensionRegion::LFO1InternalDepth, 0, 1200),
81 eLFO1ControlDepth("ControlDepth", &gig::DimensionRegion::LFO1ControlDepth,
82 0, 1200),
83 eLFO1Controller("Controller", &gig::DimensionRegion::LFO1Controller),
84 eLFO1FlipPhase("FlipPhase", &gig::DimensionRegion::LFO1FlipPhase),
85 eLFO1Sync("Sync", &gig::DimensionRegion::LFO1Sync),
86 eEG2PreAttack("PreAttack", &gig::DimensionRegion::EG2PreAttack, 0, 100, 2),
87 eEG2Attack("Attack", &gig::DimensionRegion::EG2Attack, 0, 60, 3),
88 eEG2Decay1("Decay1", &gig::DimensionRegion::EG2Decay1, 0.005, 60, 3),
89 eEG2Decay2("Decay2", &gig::DimensionRegion::EG2Decay2, 0, 60, 3),
90 eEG2InfiniteSustain("InfiniteSustain",
91 &gig::DimensionRegion::EG2InfiniteSustain),
92 eEG2Sustain("Sustain", &gig::DimensionRegion::EG2Sustain, 0, 100, 2),
93 eEG2Release("Release", &gig::DimensionRegion::EG2Release, 0, 60, 3),
94 eEG2Controller("Controller", &gig::DimensionRegion::EG2Controller),
95 eEG2ControllerInvert("ControllerInvert",
96 &gig::DimensionRegion::EG2ControllerInvert),
97 eEG2ControllerAttackInfluence("ControllerAttackInfluence",
98 &gig::DimensionRegion::EG2ControllerAttackInfluence,
99 0, 3),
100 eEG2ControllerDecayInfluence("ControllerDecayInfluence",
101 &gig::DimensionRegion::EG2ControllerDecayInfluence,
102 0, 3),
103 eEG2ControllerReleaseInfluence("ControllerReleaseInfluence",
104 &gig::DimensionRegion::EG2ControllerReleaseInfluence,
105 0, 3),
106 eLFO2Frequency("Frequency", &gig::DimensionRegion::LFO2Frequency,
107 0.1, 10, 2),
108 eLFO2InternalDepth("InternalDepth",
109 &gig::DimensionRegion::LFO2InternalDepth, 0, 1200),
110 eLFO2ControlDepth("ControlDepth",
111 &gig::DimensionRegion::LFO2ControlDepth, 0, 1200),
112 eLFO2Controller("Controller", &gig::DimensionRegion::LFO2Controller),
113 eLFO2FlipPhase("FlipPhase", &gig::DimensionRegion::LFO2FlipPhase),
114 eLFO2Sync("Sync", &gig::DimensionRegion::LFO2Sync),
115 eEG3Attack("Attack", &gig::DimensionRegion::EG3Attack, 0, 10, 3),
116 eEG3Depth("Depth", &gig::DimensionRegion::EG3Depth, -1200, 1200),
117 eLFO3Frequency("Frequency", &gig::DimensionRegion::LFO3Frequency,
118 0.1, 10, 2),
119 eLFO3InternalDepth("InternalDepth",
120 &gig::DimensionRegion::LFO3InternalDepth, 0, 1200),
121 eLFO3ControlDepth("ControlDepth", &gig::DimensionRegion::LFO3ControlDepth,
122 0, 1200),
123 eLFO3Controller("Controller", &gig::DimensionRegion::LFO3Controller),
124 eLFO3Sync("Sync", &gig::DimensionRegion::LFO3Sync),
125 eVCFEnabled("Enabled", &gig::DimensionRegion::VCFEnabled),
126 eVCFType("Type", &gig::DimensionRegion::VCFType),
127 eVCFCutoffController("CutoffController",
128 &gig::DimensionRegion::VCFCutoffController),
129 eVCFCutoffControllerInvert("CutoffControllerInvert",
130 &gig::DimensionRegion::VCFCutoffControllerInvert),
131 eVCFCutoff("Cutoff", &gig::DimensionRegion::VCFCutoff),
132 eVCFVelocityCurve("VelocityCurve", &gig::DimensionRegion::VCFVelocityCurve),
133 eVCFVelocityScale("VelocityScale", &gig::DimensionRegion::VCFVelocityScale),
134 eVCFVelocityDynamicRange("VelocityDynamicRange",
135 &gig::DimensionRegion::VCFVelocityDynamicRange,
136 0, 4),
137 eVCFResonance("Resonance", &gig::DimensionRegion::VCFResonance),
138 eVCFResonanceDynamic("ResonanceDynamic",
139 &gig::DimensionRegion::VCFResonanceDynamic),
140 eVCFResonanceController("ResonanceController",
141 &gig::DimensionRegion::VCFResonanceController),
142 eVCFKeyboardTracking("KeyboardTracking",
143 &gig::DimensionRegion::VCFKeyboardTracking),
144 eVCFKeyboardTrackingBreakpoint("KeyboardTrackingBreakpoint",
145 &gig::DimensionRegion::VCFKeyboardTrackingBreakpoint),
146 eVelocityResponseCurve("VelocityResponseCurve",
147 &gig::DimensionRegion::VelocityResponseCurve),
148 eVelocityResponseDepth("VelocityResponseDepth",
149 &gig::DimensionRegion::VelocityResponseDepth, 0, 4),
150 eVelocityResponseCurveScaling("VelocityResponseCurveScaling",
151 &gig::DimensionRegion::VelocityResponseCurveScaling),
152 eReleaseVelocityResponseCurve("ReleaseVelocityResponseCurve",
153 &gig::DimensionRegion::ReleaseVelocityResponseCurve),
154 eReleaseVelocityResponseDepth("ReleaseVelocityResponseDepth",
155 &gig::DimensionRegion::ReleaseVelocityResponseDepth,
156 0, 4),
157 eReleaseTriggerDecay("ReleaseTriggerDecay",
158 &gig::DimensionRegion::ReleaseTriggerDecay, 0, 8),
159 eCrossfade_in_start("Crossfade.in_start", &access_Crossfade_in_start),
160 eCrossfade_in_end("Crossfade.in_end", &access_Crossfade_in_end),
161 eCrossfade_out_start("Crossfade.out_start", &access_Crossfade_out_start),
162 eCrossfade_out_end("Crossfade.out_end", &access_Crossfade_out_end),
163 ePitchTrack("PitchTrack", &gig::DimensionRegion::PitchTrack),
164 eDimensionBypass("DimensionBypass", &gig::DimensionRegion::DimensionBypass),
165 ePan("Pan", &gig::DimensionRegion::Pan, -64, 63),
166 eSelfMask("SelfMask", &gig::DimensionRegion::SelfMask),
167 eAttenuationController("AttenuationController",
168 &gig::DimensionRegion::AttenuationController),
169 eInvertAttenuationController("InvertAttenuationController",
170 &gig::DimensionRegion::InvertAttenuationController),
171 eAttenuationControllerThreshold("AttenuationControllerThreshold",
172 &gig::DimensionRegion::AttenuationControllerThreshold),
173 eChannelOffset("ChannelOffset", &gig::DimensionRegion::ChannelOffset, 0, 9),
174 eSustainDefeat("SustainDefeat", &gig::DimensionRegion::SustainDefeat),
175 eMSDecode("MSDecode", &gig::DimensionRegion::MSDecode),
176 eSampleStartOffset("SampleStartOffset",
177 &gig::DimensionRegion::SampleStartOffset, 0, 2000),
178 eUnityNote("UnityNote", &access_UnityNote),
179 eFineTune("FineTune", &access_FineTune, -49, 50),
180 eGain("Gain", -96, 0, 2),
181 eGainPlus6("Gain +6dB", eGain),
182 eSampleLoops("SampleLoops", &access_SampleLoops, 0, 1)
183 {
184 for (int i = 0 ; i < 5 ; i++) {
185 table[i] = new Gtk::Table(3, 1);
186 table[i]->set_col_spacings(5);
187 }
188
189 pageno = 0;
190 rowno = 0;
191 firstRowInBlock = 0;
192
193 addString("Sample", lSample, wSample);
194 //TODO: the following would break drag&drop: wSample->property_editable().set_value(false); or this: wSample->set_editable(false);
195 addHeader("EG1");
196 addProp(eEG1PreAttack);
197 addProp(eEG1Attack);
198 addProp(eEG1Decay1);
199 addProp(eEG1Decay2);
200 addProp(eEG1InfiniteSustain);
201 addProp(eEG1Sustain);
202 addProp(eEG1Release);
203 addProp(eEG1Hold);
204 addProp(eEG1Controller);
205 addProp(eEG1ControllerInvert);
206 addProp(eEG1ControllerAttackInfluence);
207 addProp(eEG1ControllerDecayInfluence);
208 addProp(eEG1ControllerReleaseInfluence);
209 addHeader("LFO1");
210 addProp(eLFO1Frequency);
211 addProp(eLFO1InternalDepth);
212 addProp(eLFO1ControlDepth);
213 {
214 char* choices[] = { "internal", "modwheel", "breath",
215 "internal+modwheel", "internal+breath", 0 };
216 static const gig::lfo1_ctrl_t values[] = {
217 gig::lfo1_ctrl_internal,
218 gig::lfo1_ctrl_modwheel,
219 gig::lfo1_ctrl_breath,
220 gig::lfo1_ctrl_internal_modwheel,
221 gig::lfo1_ctrl_internal_breath
222 };
223 eLFO1Controller.set_choices(choices, values);
224 }
225 addProp(eLFO1Controller);
226 addProp(eLFO1FlipPhase);
227 addProp(eLFO1Sync);
228
229 nextPage();
230 addHeader("EG2");
231 addProp(eEG2PreAttack);
232 addProp(eEG2Attack);
233 addProp(eEG2Decay1);
234 addProp(eEG2Decay2);
235 addProp(eEG2InfiniteSustain);
236 addProp(eEG2Sustain);
237 addProp(eEG2Release);
238 addProp(eEG2Controller);
239 addProp(eEG2ControllerInvert);
240 addProp(eEG2ControllerAttackInfluence);
241 addProp(eEG2ControllerDecayInfluence);
242 addProp(eEG2ControllerReleaseInfluence);
243 addHeader("LFO2");
244 addProp(eLFO2Frequency);
245 addProp(eLFO2InternalDepth);
246 addProp(eLFO2ControlDepth);
247 {
248 char* choices[] = { "internal", "modwheel", "foot",
249 "internal+modwheel", "internal+foot", 0 };
250 static const gig::lfo2_ctrl_t values[] = {
251 gig::lfo2_ctrl_internal,
252 gig::lfo2_ctrl_modwheel,
253 gig::lfo2_ctrl_foot,
254 gig::lfo2_ctrl_internal_modwheel,
255 gig::lfo2_ctrl_internal_foot
256 };
257 eLFO2Controller.set_choices(choices, values);
258 }
259 addProp(eLFO2Controller);
260 addProp(eLFO2FlipPhase);
261 addProp(eLFO2Sync);
262
263 nextPage();
264
265 addHeader("EG3");
266 addProp(eEG3Attack);
267 addProp(eEG3Depth);
268 addHeader("LFO3");
269 addProp(eLFO3Frequency);
270 addProp(eLFO3InternalDepth);
271 addProp(eLFO3ControlDepth);
272 {
273 char* choices[] = { "internal", "modwheel", "aftertouch",
274 "internal+modwheel", "internal+aftertouch", 0 };
275 static const gig::lfo3_ctrl_t values[] = {
276 gig::lfo3_ctrl_internal,
277 gig::lfo3_ctrl_modwheel,
278 gig::lfo3_ctrl_aftertouch,
279 gig::lfo3_ctrl_internal_modwheel,
280 gig::lfo3_ctrl_internal_aftertouch
281 };
282 eLFO3Controller.set_choices(choices, values);
283 }
284 addProp(eLFO3Controller);
285 addProp(eLFO3Sync);
286 addHeader("VCF");
287 addProp(eVCFEnabled);
288 {
289 char* choices[] = { "lowpass", "lowpassturbo", "bandpass",
290 "highpass", "bandreject", 0 };
291 static const gig::vcf_type_t values[] = {
292 gig::vcf_type_lowpass,
293 gig::vcf_type_lowpassturbo,
294 gig::vcf_type_bandpass,
295 gig::vcf_type_highpass,
296 gig::vcf_type_bandreject
297 };
298 eVCFType.set_choices(choices, values);
299 }
300 addProp(eVCFType);
301 {
302 char* choices[] = { "none", "none2", "modwheel", "effect1", "effect2",
303 "breath", "foot", "sustainpedal", "softpedal",
304 "genpurpose7", "genpurpose8", "aftertouch", 0 };
305 static const gig::vcf_cutoff_ctrl_t values[] = {
306 gig::vcf_cutoff_ctrl_none,
307 gig::vcf_cutoff_ctrl_none2,
308 gig::vcf_cutoff_ctrl_modwheel,
309 gig::vcf_cutoff_ctrl_effect1,
310 gig::vcf_cutoff_ctrl_effect2,
311 gig::vcf_cutoff_ctrl_breath,
312 gig::vcf_cutoff_ctrl_foot,
313 gig::vcf_cutoff_ctrl_sustainpedal,
314 gig::vcf_cutoff_ctrl_softpedal,
315 gig::vcf_cutoff_ctrl_genpurpose7,
316 gig::vcf_cutoff_ctrl_genpurpose8,
317 gig::vcf_cutoff_ctrl_aftertouch
318 };
319 eVCFCutoffController.set_choices(choices, values);
320 }
321 addProp(eVCFCutoffController);
322 addProp(eVCFCutoffControllerInvert);
323 addProp(eVCFCutoff);
324 char* curve_type_texts[] = { "nonlinear", "linear", "special", 0 };
325 static const gig::curve_type_t curve_type_values[] = {
326 gig::curve_type_nonlinear,
327 gig::curve_type_linear,
328 gig::curve_type_special
329 };
330 eVCFVelocityCurve.set_choices(curve_type_texts, curve_type_values);
331 addProp(eVCFVelocityCurve);
332 addProp(eVCFVelocityScale);
333 addProp(eVCFVelocityDynamicRange);
334 addProp(eVCFResonance);
335 addProp(eVCFResonanceDynamic);
336 {
337 char* choices[] = { "none", "genpurpose3", "genpurpose4",
338 "genpurpose5", "genpurpose6", 0 };
339 static const gig::vcf_res_ctrl_t values[] = {
340 gig::vcf_res_ctrl_none,
341 gig::vcf_res_ctrl_genpurpose3,
342 gig::vcf_res_ctrl_genpurpose4,
343 gig::vcf_res_ctrl_genpurpose5,
344 gig::vcf_res_ctrl_genpurpose6
345 };
346 eVCFResonanceController.set_choices(choices, values);
347 }
348 addProp(eVCFResonanceController);
349 addProp(eVCFKeyboardTracking);
350 addProp(eVCFKeyboardTrackingBreakpoint);
351
352 nextPage();
353
354 eVelocityResponseCurve.set_choices(curve_type_texts, curve_type_values);
355 addProp(eVelocityResponseCurve);
356 addProp(eVelocityResponseDepth);
357 addProp(eVelocityResponseCurveScaling);
358 eReleaseVelocityResponseCurve.set_choices(curve_type_texts,
359 curve_type_values);
360 addProp(eReleaseVelocityResponseCurve);
361 addProp(eReleaseVelocityResponseDepth);
362 addProp(eReleaseTriggerDecay);
363 addProp(eCrossfade_in_start);
364 addProp(eCrossfade_in_end);
365 addProp(eCrossfade_out_start);
366 addProp(eCrossfade_out_end);
367 addProp(ePitchTrack);
368 {
369 char* choices[] = { "none", "effect4depth", "effect5depth", 0 };
370 static const gig::dim_bypass_ctrl_t values[] = {
371 gig::dim_bypass_ctrl_none,
372 gig::dim_bypass_ctrl_94,
373 gig::dim_bypass_ctrl_95
374 };
375 eDimensionBypass.set_choices(choices, values);
376 }
377 addProp(eDimensionBypass);
378 addProp(ePan);
379 addProp(eSelfMask);
380 addProp(eAttenuationController);
381 addProp(eInvertAttenuationController);
382 addProp(eAttenuationControllerThreshold);
383 addProp(eChannelOffset);
384 addProp(eSustainDefeat);
385
386 nextPage();
387 addProp(eMSDecode);
388 addProp(eSampleStartOffset);
389 addProp(eUnityNote);
390 addProp(eFineTune);
391 addProp(eGain);
392 addProp(eGainPlus6);
393 addProp(eSampleLoops);
394 nextPage();
395
396 eEG1InfiniteSustain.signal_toggled().connect(
397 sigc::mem_fun(*this, &DimRegionEdit::EG1InfiniteSustain_toggled) );
398 eEG2InfiniteSustain.signal_toggled().connect(
399 sigc::mem_fun(*this, &DimRegionEdit::EG2InfiniteSustain_toggled) );
400 eEG1Controller.signal_changed().connect(
401 sigc::mem_fun(*this, &DimRegionEdit::EG1Controller_changed) );
402 eEG2Controller.signal_changed().connect(
403 sigc::mem_fun(*this, &DimRegionEdit::EG2Controller_changed) );
404 eLFO1Controller.signal_changed().connect(
405 sigc::mem_fun(*this, &DimRegionEdit::LFO1Controller_changed) );
406 eLFO2Controller.signal_changed().connect(
407 sigc::mem_fun(*this, &DimRegionEdit::LFO2Controller_changed) );
408 eLFO3Controller.signal_changed().connect(
409 sigc::mem_fun(*this, &DimRegionEdit::LFO3Controller_changed) );
410 eAttenuationController.signal_changed().connect(
411 sigc::mem_fun(*this, &DimRegionEdit::AttenuationController_changed) );
412 eVCFEnabled.signal_toggled().connect(
413 sigc::mem_fun(*this, &DimRegionEdit::VCFEnabled_toggled) );
414 eVCFCutoffController.signal_changed().connect(
415 sigc::mem_fun(*this, &DimRegionEdit::VCFCutoffController_changed) );
416 eVCFResonanceController.signal_changed().connect(
417 sigc::mem_fun(*this, &DimRegionEdit::VCFResonanceController_changed) );
418
419 eCrossfade_in_start.signal_value_changed().connect(
420 sigc::mem_fun(*this, &DimRegionEdit::crossfade1_changed));
421 eCrossfade_in_end.signal_value_changed().connect(
422 sigc::mem_fun(*this, &DimRegionEdit::crossfade2_changed));
423 eCrossfade_out_start.signal_value_changed().connect(
424 sigc::mem_fun(*this, &DimRegionEdit::crossfade3_changed));
425 eCrossfade_out_end.signal_value_changed().connect(
426 sigc::mem_fun(*this, &DimRegionEdit::crossfade4_changed));
427
428 append_page(*table[0], "EG1");
429 append_page(*table[1], "EG2");
430 append_page(*table[2], "EG3");
431 append_page(*table[3], "Velocity");
432 append_page(*table[4], "Misc");
433 }
434
435 DimRegionEdit::~DimRegionEdit()
436 {
437 }
438
439 void DimRegionEdit::addString(char* labelText, Gtk::Label*& label,
440 Gtk::Entry*& widget)
441 {
442 label = new Gtk::Label(Glib::ustring(labelText) + ":");
443 label->set_alignment(Gtk::ALIGN_LEFT);
444
445 table[pageno]->attach(*label, 1, 2, rowno, rowno + 1,
446 Gtk::FILL, Gtk::SHRINK);
447
448 widget = new Gtk::Entry();
449
450 table[pageno]->attach(*widget, 2, 3, rowno, rowno + 1,
451 Gtk::EXPAND | Gtk::FILL, Gtk::SHRINK);
452
453 rowno++;
454 }
455
456 void DimRegionEdit::addHeader(char* text)
457 {
458 if (firstRowInBlock < rowno - 1)
459 {
460 Gtk::Label* filler = new Gtk::Label(" ");
461 table[pageno]->attach(*filler, 0, 1, firstRowInBlock, rowno,
462 Gtk::FILL, Gtk::SHRINK);
463 }
464 Glib::ustring str = "<b>";
465 str += text;
466 str += "</b>";
467 Gtk::Label* label = new Gtk::Label(str);
468 label->set_use_markup();
469 label->set_alignment(Gtk::ALIGN_LEFT);
470 table[pageno]->attach(*label, 0, 3, rowno, rowno + 1,
471 Gtk::FILL, Gtk::SHRINK);
472 rowno++;
473 firstRowInBlock = rowno;
474 }
475
476 void DimRegionEdit::nextPage()
477 {
478 if (firstRowInBlock < rowno - 1)
479 {
480 Gtk::Label* filler = new Gtk::Label(" ");
481 table[pageno]->attach(*filler, 0, 1, firstRowInBlock, rowno,
482 Gtk::FILL, Gtk::SHRINK);
483 }
484 pageno++;
485 rowno = 0;
486 firstRowInBlock = 0;
487 }
488
489 void DimRegionEdit::addProp(LabelWidget& prop)
490 {
491 table[pageno]->attach(prop.label, 1, 2, rowno, rowno + 1,
492 Gtk::FILL, Gtk::SHRINK);
493 table[pageno]->attach(prop.widget, 2, 3, rowno, rowno + 1,
494 Gtk::EXPAND | Gtk::FILL, Gtk::SHRINK);
495 rowno++;
496 }
497
498
499 void DimRegionEdit::set_dim_region(gig::DimensionRegion* d)
500 {
501 set_sensitive(d);
502 if (!d) return;
503
504 update_gui = false;
505 wSample->set_text(d->pSample ? d->pSample->pInfo->Name.c_str() : "NULL");
506 eEG1PreAttack.set_dimreg(d);
507 eEG1Attack.set_dimreg(d);
508 eEG1Decay1.set_dimreg(d);
509 eEG1Decay2.set_dimreg(d);
510 eEG1InfiniteSustain.set_dimreg(d);
511 eEG1Sustain.set_dimreg(d);
512 eEG1Release.set_dimreg(d);
513 eEG1Hold.set_dimreg(d);
514 eEG1Controller.set_dimreg(d);
515 eEG1ControllerInvert.set_dimreg(d);
516 eEG1ControllerAttackInfluence.set_dimreg(d);
517 eEG1ControllerDecayInfluence.set_dimreg(d);
518 eEG1ControllerReleaseInfluence.set_dimreg(d);
519 eLFO1Frequency.set_dimreg(d);
520 eLFO1InternalDepth.set_dimreg(d);
521 eLFO1ControlDepth.set_dimreg(d);
522 eLFO1Controller.set_dimreg(d);
523 eLFO1FlipPhase.set_dimreg(d);
524 eLFO1Sync.set_dimreg(d);
525 eEG2PreAttack.set_dimreg(d);
526 eEG2Attack.set_dimreg(d);
527 eEG2Decay1.set_dimreg(d);
528 eEG2Decay2.set_dimreg(d);
529 eEG2InfiniteSustain.set_dimreg(d);
530 eEG2Sustain.set_dimreg(d);
531 eEG2Release.set_dimreg(d);
532 eEG2Controller.set_dimreg(d);
533 eEG2ControllerInvert.set_dimreg(d);
534 eEG2ControllerAttackInfluence.set_dimreg(d);
535 eEG2ControllerDecayInfluence.set_dimreg(d);
536 eEG2ControllerReleaseInfluence.set_dimreg(d);
537 eLFO2Frequency.set_dimreg(d);
538 eLFO2InternalDepth.set_dimreg(d);
539 eLFO2ControlDepth.set_dimreg(d);
540 eLFO2Controller.set_dimreg(d);
541 eLFO2FlipPhase.set_dimreg(d);
542 eLFO2Sync.set_dimreg(d);
543 eEG3Attack.set_dimreg(d);
544 eEG3Depth.set_dimreg(d);
545 eLFO3Frequency.set_dimreg(d);
546 eLFO3InternalDepth.set_dimreg(d);
547 eLFO3ControlDepth.set_dimreg(d);
548 eLFO3Controller.set_dimreg(d);
549 eLFO3Sync.set_dimreg(d);
550 eVCFEnabled.set_dimreg(d);
551 eVCFType.set_dimreg(d);
552 eVCFCutoffController.set_dimreg(d);
553 eVCFCutoffControllerInvert.set_dimreg(d);
554 eVCFCutoff.set_dimreg(d);
555 eVCFVelocityCurve.set_dimreg(d);
556 eVCFVelocityScale.set_dimreg(d);
557 eVCFVelocityDynamicRange.set_dimreg(d);
558 eVCFResonance.set_dimreg(d);
559 eVCFResonanceDynamic.set_dimreg(d);
560 eVCFResonanceController.set_dimreg(d);
561 eVCFKeyboardTracking.set_dimreg(d);
562 eVCFKeyboardTrackingBreakpoint.set_dimreg(d);
563 eVelocityResponseCurve.set_dimreg(d);
564 eVelocityResponseDepth.set_dimreg(d);
565 eVelocityResponseCurveScaling.set_dimreg(d);
566 eReleaseVelocityResponseCurve.set_dimreg(d);
567 eReleaseVelocityResponseDepth.set_dimreg(d);
568 eReleaseTriggerDecay.set_dimreg(d);
569 eCrossfade_in_start.set_dimreg(d);
570 eCrossfade_in_end.set_dimreg(d);
571 eCrossfade_out_start.set_dimreg(d);
572 eCrossfade_out_end.set_dimreg(d);
573 ePitchTrack.set_dimreg(d);
574 eDimensionBypass.set_dimreg(d);
575 ePan.set_dimreg(d);
576 eSelfMask.set_dimreg(d);
577 eAttenuationController.set_dimreg(d);
578 eInvertAttenuationController.set_dimreg(d);
579 eAttenuationControllerThreshold.set_dimreg(d);
580 eChannelOffset.set_dimreg(d);
581 eSustainDefeat.set_dimreg(d);
582 eMSDecode.set_dimreg(d);
583 eSampleStartOffset.set_dimreg(d);
584 eUnityNote.set_dimreg(d);
585 eFineTune.set_dimreg(d);
586 eGain.set_dimreg(d);
587 eGainPlus6.set_dimreg(d);
588 eSampleLoops.set_dimreg(d);
589
590 VCFEnabled_toggled();
591
592 update_gui = true;
593 }
594
595 void DimRegionEdit::VCFEnabled_toggled()
596 {
597 bool sensitive = eVCFEnabled.get_active();
598 eVCFType.set_sensitive(sensitive);
599 eVCFCutoffController.set_sensitive(sensitive);
600 eVCFVelocityCurve.set_sensitive(sensitive);
601 eVCFVelocityScale.set_sensitive(sensitive);
602 eVCFVelocityDynamicRange.set_sensitive(sensitive);
603 eVCFResonance.set_sensitive(sensitive);
604 eVCFResonanceController.set_sensitive(sensitive);
605 eVCFKeyboardTracking.set_sensitive(sensitive);
606 eVCFKeyboardTrackingBreakpoint.set_sensitive(sensitive);
607 eEG2PreAttack.set_sensitive(sensitive);
608 eEG2Attack.set_sensitive(sensitive);
609 eEG2Decay1.set_sensitive(sensitive);
610 eEG2InfiniteSustain.set_sensitive(sensitive);
611 eEG2Sustain.set_sensitive(sensitive);
612 eEG2Release.set_sensitive(sensitive);
613 eEG2Controller.set_sensitive(sensitive);
614 eEG2ControllerAttackInfluence.set_sensitive(sensitive);
615 eEG2ControllerDecayInfluence.set_sensitive(sensitive);
616 eEG2ControllerReleaseInfluence.set_sensitive(sensitive);
617 eLFO2Frequency.set_sensitive(sensitive);
618 eLFO2InternalDepth.set_sensitive(sensitive);
619 eLFO2ControlDepth.set_sensitive(sensitive);
620 eLFO2Controller.set_sensitive(sensitive);
621 eLFO2FlipPhase.set_sensitive(sensitive);
622 eLFO2Sync.set_sensitive(sensitive);
623 if (sensitive) {
624 VCFCutoffController_changed();
625 VCFResonanceController_changed();
626 EG2InfiniteSustain_toggled();
627 EG2Controller_changed();
628 LFO2Controller_changed();
629 } else {
630 eVCFCutoffControllerInvert.set_sensitive(false);
631 eVCFCutoff.set_sensitive(false);
632 eVCFResonanceDynamic.set_sensitive(false);
633 eVCFResonance.set_sensitive(false);
634 eEG2Decay2.set_sensitive(false);
635 eEG2ControllerInvert.set_sensitive(false);
636 eLFO2InternalDepth.set_sensitive(false);
637 eLFO2ControlDepth.set_sensitive(false);
638 }
639 }
640
641 void DimRegionEdit::VCFCutoffController_changed()
642 {
643 int rowno = eVCFCutoffController.get_active_row_number();
644 bool hasController = rowno != 0 && rowno != 1;
645
646 eVCFCutoffControllerInvert.set_sensitive(hasController);
647 eVCFCutoff.set_sensitive(!hasController);
648 eVCFResonanceDynamic.set_sensitive(!hasController);
649 eVCFVelocityScale.label.set_text(hasController ? "MinimumCutoff:" :
650 "VelocityScale:");
651 }
652
653 void DimRegionEdit::VCFResonanceController_changed()
654 {
655 bool hasController = eVCFResonanceController.get_active_row_number() != 0;
656 eVCFResonance.set_sensitive(!hasController);
657 }
658
659 void DimRegionEdit::EG1InfiniteSustain_toggled()
660 {
661 bool infSus = eEG1InfiniteSustain.get_active();
662 eEG1Decay2.set_sensitive(!infSus);
663 }
664
665 void DimRegionEdit::EG2InfiniteSustain_toggled()
666 {
667 bool infSus = eEG2InfiniteSustain.get_active();
668 eEG2Decay2.set_sensitive(!infSus);
669 }
670
671 void DimRegionEdit::EG1Controller_changed()
672 {
673 bool hasController = eEG1Controller.get_active_row_number() != 0;
674 eEG1ControllerInvert.set_sensitive(hasController);
675 }
676
677 void DimRegionEdit::EG2Controller_changed()
678 {
679 bool hasController = eEG2Controller.get_active_row_number() != 0;
680 eEG2ControllerInvert.set_sensitive(hasController);
681 }
682
683 void DimRegionEdit::AttenuationController_changed()
684 {
685 bool hasController = eAttenuationController.get_active_row_number() != 0;
686 eInvertAttenuationController.set_sensitive(hasController);
687 }
688
689 void DimRegionEdit::LFO1Controller_changed()
690 {
691 int rowno = eLFO1Controller.get_active_row_number();
692 eLFO1ControlDepth.set_sensitive(rowno != 0);
693 eLFO1InternalDepth.set_sensitive(rowno != 1 && rowno != 2);
694 }
695
696 void DimRegionEdit::LFO2Controller_changed()
697 {
698 int rowno = eLFO2Controller.get_active_row_number();
699 eLFO2ControlDepth.set_sensitive(rowno != 0);
700 eLFO2InternalDepth.set_sensitive(rowno != 1 && rowno != 2);
701 }
702
703 void DimRegionEdit::LFO3Controller_changed()
704 {
705 int rowno = eLFO3Controller.get_active_row_number();
706 eLFO3ControlDepth.set_sensitive(rowno != 0);
707 eLFO3InternalDepth.set_sensitive(rowno != 1 && rowno != 2);
708 }
709
710 void DimRegionEdit::crossfade1_changed()
711 {
712 double c1 = eCrossfade_in_start.get_value();
713 double c2 = eCrossfade_in_end.get_value();
714 if (c1 > c2) eCrossfade_in_end.set_value(c1);
715 }
716
717 void DimRegionEdit::crossfade2_changed()
718 {
719 double c1 = eCrossfade_in_start.get_value();
720 double c2 = eCrossfade_in_end.get_value();
721 double c3 = eCrossfade_out_start.get_value();
722
723 if (c2 < c1) eCrossfade_in_start.set_value(c2);
724 if (c2 > c3) eCrossfade_out_start.set_value(c2);
725 }
726
727 void DimRegionEdit::crossfade3_changed()
728 {
729 double c2 = eCrossfade_in_end.get_value();
730 double c3 = eCrossfade_out_start.get_value();
731 double c4 = eCrossfade_out_end.get_value();
732
733 if (c3 < c2) eCrossfade_in_end.set_value(c3);
734 if (c3 > c4) eCrossfade_out_end.set_value(c3);
735 }
736
737 void DimRegionEdit::crossfade4_changed()
738 {
739 double c3 = eCrossfade_out_start.get_value();
740 double c4 = eCrossfade_out_end.get_value();
741
742 if (c4 < c3) eCrossfade_out_start.set_value(c4);
743 }

  ViewVC Help
Powered by ViewVC