/[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 2169 - (show annotations) (download)
Sun Mar 6 07:51:04 2011 UTC (13 years ago) by persson
File size: 46521 byte(s)
* ported to gtkmm 3, keeping compatibility with gtkmm 2

1 /*
2 * Copyright (C) 2006-2011 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 "global.h"
23 #include "compat.h"
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"), 1),
114 update_model(0)
115 {
116 connect(eEG1PreAttack, &gig::DimensionRegion::EG1PreAttack);
117 connect(eEG1Attack, &gig::DimensionRegion::EG1Attack);
118 connect(eEG1Decay1, &gig::DimensionRegion::EG1Decay1);
119 connect(eEG1Decay2, &gig::DimensionRegion::EG1Decay2);
120 connect(eEG1InfiniteSustain, &gig::DimensionRegion::EG1InfiniteSustain);
121 connect(eEG1Sustain, &gig::DimensionRegion::EG1Sustain);
122 connect(eEG1Release, &gig::DimensionRegion::EG1Release);
123 connect(eEG1Hold, &gig::DimensionRegion::EG1Hold);
124 connect(eEG1Controller, &gig::DimensionRegion::EG1Controller);
125 connect(eEG1ControllerInvert, &gig::DimensionRegion::EG1ControllerInvert);
126 connect(eEG1ControllerAttackInfluence,
127 &gig::DimensionRegion::EG1ControllerAttackInfluence);
128 connect(eEG1ControllerDecayInfluence,
129 &gig::DimensionRegion::EG1ControllerDecayInfluence);
130 connect(eEG1ControllerReleaseInfluence,
131 &gig::DimensionRegion::EG1ControllerReleaseInfluence);
132 connect(eLFO1Frequency, &gig::DimensionRegion::LFO1Frequency);
133 connect(eLFO1InternalDepth, &gig::DimensionRegion::LFO1InternalDepth);
134 connect(eLFO1ControlDepth, &gig::DimensionRegion::LFO1ControlDepth);
135 connect(eLFO1Controller, &gig::DimensionRegion::LFO1Controller);
136 connect(eLFO1FlipPhase, &gig::DimensionRegion::LFO1FlipPhase);
137 connect(eLFO1Sync, &gig::DimensionRegion::LFO1Sync);
138 connect(eEG2PreAttack, &gig::DimensionRegion::EG2PreAttack);
139 connect(eEG2Attack, &gig::DimensionRegion::EG2Attack);
140 connect(eEG2Decay1, &gig::DimensionRegion::EG2Decay1);
141 connect(eEG2Decay2, &gig::DimensionRegion::EG2Decay2);
142 connect(eEG2InfiniteSustain, &gig::DimensionRegion::EG2InfiniteSustain);
143 connect(eEG2Sustain, &gig::DimensionRegion::EG2Sustain);
144 connect(eEG2Release, &gig::DimensionRegion::EG2Release);
145 connect(eEG2Controller, &gig::DimensionRegion::EG2Controller);
146 connect(eEG2ControllerInvert, &gig::DimensionRegion::EG2ControllerInvert);
147 connect(eEG2ControllerAttackInfluence,
148 &gig::DimensionRegion::EG2ControllerAttackInfluence);
149 connect(eEG2ControllerDecayInfluence,
150 &gig::DimensionRegion::EG2ControllerDecayInfluence);
151 connect(eEG2ControllerReleaseInfluence,
152 &gig::DimensionRegion::EG2ControllerReleaseInfluence);
153 connect(eLFO2Frequency, &gig::DimensionRegion::LFO2Frequency);
154 connect(eLFO2InternalDepth, &gig::DimensionRegion::LFO2InternalDepth);
155 connect(eLFO2ControlDepth, &gig::DimensionRegion::LFO2ControlDepth);
156 connect(eLFO2Controller, &gig::DimensionRegion::LFO2Controller);
157 connect(eLFO2FlipPhase, &gig::DimensionRegion::LFO2FlipPhase);
158 connect(eLFO2Sync, &gig::DimensionRegion::LFO2Sync);
159 connect(eEG3Attack, &gig::DimensionRegion::EG3Attack);
160 connect(eEG3Depth, &gig::DimensionRegion::EG3Depth);
161 connect(eLFO3Frequency, &gig::DimensionRegion::LFO3Frequency);
162 connect(eLFO3InternalDepth, &gig::DimensionRegion::LFO3InternalDepth);
163 connect(eLFO3ControlDepth, &gig::DimensionRegion::LFO3ControlDepth);
164 connect(eLFO3Controller, &gig::DimensionRegion::LFO3Controller);
165 connect(eLFO3Sync, &gig::DimensionRegion::LFO3Sync);
166 connect(eVCFEnabled, &gig::DimensionRegion::VCFEnabled);
167 connect(eVCFType, &gig::DimensionRegion::VCFType);
168 connect(eVCFCutoffController,
169 &gig::DimensionRegion::SetVCFCutoffController);
170 connect(eVCFCutoffControllerInvert,
171 &gig::DimensionRegion::VCFCutoffControllerInvert);
172 connect(eVCFCutoff, &gig::DimensionRegion::VCFCutoff);
173 connect(eVCFVelocityCurve, &gig::DimensionRegion::SetVCFVelocityCurve);
174 connect(eVCFVelocityScale, &gig::DimensionRegion::SetVCFVelocityScale);
175 connect(eVCFVelocityDynamicRange,
176 &gig::DimensionRegion::SetVCFVelocityDynamicRange);
177 connect(eVCFResonance, &gig::DimensionRegion::VCFResonance);
178 connect(eVCFResonanceDynamic, &gig::DimensionRegion::VCFResonanceDynamic);
179 connect(eVCFResonanceController,
180 &gig::DimensionRegion::VCFResonanceController);
181 connect(eVCFKeyboardTracking, &gig::DimensionRegion::VCFKeyboardTracking);
182 connect(eVCFKeyboardTrackingBreakpoint,
183 &gig::DimensionRegion::VCFKeyboardTrackingBreakpoint);
184 connect(eVelocityResponseCurve,
185 &gig::DimensionRegion::SetVelocityResponseCurve);
186 connect(eVelocityResponseDepth,
187 &gig::DimensionRegion::SetVelocityResponseDepth);
188 connect(eVelocityResponseCurveScaling,
189 &gig::DimensionRegion::SetVelocityResponseCurveScaling);
190 connect(eReleaseVelocityResponseCurve,
191 &gig::DimensionRegion::SetReleaseVelocityResponseCurve);
192 connect(eReleaseVelocityResponseDepth,
193 &gig::DimensionRegion::SetReleaseVelocityResponseDepth);
194 connect(eReleaseTriggerDecay, &gig::DimensionRegion::ReleaseTriggerDecay);
195 connect(eCrossfade_in_start, &DimRegionEdit::set_Crossfade_in_start);
196 connect(eCrossfade_in_end, &DimRegionEdit::set_Crossfade_in_end);
197 connect(eCrossfade_out_start, &DimRegionEdit::set_Crossfade_out_start);
198 connect(eCrossfade_out_end, &DimRegionEdit::set_Crossfade_out_end);
199 connect(ePitchTrack, &gig::DimensionRegion::PitchTrack);
200 connect(eDimensionBypass, &gig::DimensionRegion::DimensionBypass);
201 connect(ePan, &gig::DimensionRegion::Pan);
202 connect(eSelfMask, &gig::DimensionRegion::SelfMask);
203 connect(eAttenuationController,
204 &gig::DimensionRegion::AttenuationController);
205 connect(eInvertAttenuationController,
206 &gig::DimensionRegion::InvertAttenuationController);
207 connect(eAttenuationControllerThreshold,
208 &gig::DimensionRegion::AttenuationControllerThreshold);
209 connect(eChannelOffset, &gig::DimensionRegion::ChannelOffset);
210 connect(eSustainDefeat, &gig::DimensionRegion::SustainDefeat);
211 connect(eMSDecode, &gig::DimensionRegion::MSDecode);
212 connect(eSampleStartOffset, &gig::DimensionRegion::SampleStartOffset);
213 connect(eUnityNote, &DimRegionEdit::set_UnityNote);
214 connect(eFineTune, &DimRegionEdit::set_FineTune);
215 connect(eGain, &DimRegionEdit::set_Gain);
216 connect(eGainPlus6, &DimRegionEdit::set_Gain);
217 connect(eSampleLoopEnabled, &DimRegionEdit::set_LoopEnabled);
218 connect(eSampleLoopType, &DimRegionEdit::set_LoopType);
219 connect(eSampleLoopStart, &DimRegionEdit::set_LoopStart);
220 connect(eSampleLoopLength, &DimRegionEdit::set_LoopLength);
221 connect(eSampleLoopInfinite, &DimRegionEdit::set_LoopInfinite);
222 connect(eSampleLoopPlayCount, &DimRegionEdit::set_LoopPlayCount);
223
224 for (int i = 0 ; i < 7 ; i++) {
225 table[i] = new Gtk::Table(3, 1);
226 table[i]->set_col_spacings(7);
227 }
228
229 // set tooltips
230 eUnityNote.set_tip(
231 _("Note this sample is associated with (a.k.a. 'root note')")
232 );
233 eSampleStartOffset.set_tip(_("Sample position at which playback should be started"));
234 ePan.set_tip(_("Stereo balance (left/right)"));
235 eChannelOffset.set_tip(
236 _("Output channel where the audio signal should be routed to (0 - 9)")
237 );
238 ePitchTrack.set_tip(
239 _("If true: sample will be pitched according to the key position "
240 "(this would be disabled for drums for example)")
241 );
242 eSampleLoopEnabled.set_tip(_("If enabled: repeats to playback the sample"));
243 eSampleLoopStart.set_tip(
244 _("Start position within the sample (in sample points) of the area to "
245 "be looped")
246 );
247 eSampleLoopLength.set_tip(
248 _("Duration (in sample points) of the area to be looped")
249 );
250 eSampleLoopType.set_tip(
251 _("Direction in which the loop area in the sample should be played back")
252 );
253 eSampleLoopInfinite.set_tip(
254 _("Whether the loop area should be played back forever\n"
255 "Caution: this setting is stored on Sample side, thus is shared "
256 "among all dimension regions that use this sample!")
257 );
258 eSampleLoopPlayCount.set_tip(
259 _("How many times the loop area should be played back\n"
260 "Caution: this setting is stored on Sample side, thus is shared "
261 "among all dimension regions that use this sample!")
262 );
263
264 pageno = 0;
265 rowno = 0;
266 firstRowInBlock = 0;
267
268 addHeader(_("Mandatory Settings"));
269 addString(_("Sample"), lSample, wSample);
270 //TODO: the following would break drag&drop: wSample->property_editable().set_value(false); or this: wSample->set_editable(false);
271 #ifdef OLD_TOOLTIPS
272 tooltips.set_tip(*wSample, _("Drop a sample here"));
273 #else
274 wSample->set_tooltip_text(_("Drop a sample here"));
275 #endif
276 addProp(eUnityNote);
277 addHeader(_("Optional Settings"));
278 addProp(eSampleStartOffset);
279 addProp(eChannelOffset);
280 addHeader(_("Loops"));
281 addProp(eSampleLoopEnabled);
282 addProp(eSampleLoopStart);
283 addProp(eSampleLoopLength);
284 {
285 const char* choices[] = { _("normal"), _("bidirectional"), _("backward"), 0 };
286 static const uint32_t values[] = {
287 gig::loop_type_normal,
288 gig::loop_type_bidirectional,
289 gig::loop_type_backward
290 };
291 eSampleLoopType.set_choices(choices, values);
292 }
293 addProp(eSampleLoopType);
294 addProp(eSampleLoopInfinite);
295 addProp(eSampleLoopPlayCount);
296
297 nextPage();
298
299 addHeader(_("General Amplitude Settings"));
300 addProp(eGain);
301 addProp(eGainPlus6);
302 addProp(ePan);
303 addHeader(_("Amplitude Envelope (EG1)"));
304 addProp(eEG1PreAttack);
305 addProp(eEG1Attack);
306 addProp(eEG1Decay1);
307 addProp(eEG1Decay2);
308 addProp(eEG1InfiniteSustain);
309 addProp(eEG1Sustain);
310 addProp(eEG1Release);
311 addProp(eEG1Hold);
312 addProp(eEG1Controller);
313 addProp(eEG1ControllerInvert);
314 addProp(eEG1ControllerAttackInfluence);
315 addProp(eEG1ControllerDecayInfluence);
316 addProp(eEG1ControllerReleaseInfluence);
317
318 nextPage();
319
320 addHeader(_("Amplitude Oscillator (LFO1)"));
321 addProp(eLFO1Frequency);
322 addProp(eLFO1InternalDepth);
323 addProp(eLFO1ControlDepth);
324 {
325 const char* choices[] = { _("internal"), _("modwheel"), _("breath"),
326 _("internal+modwheel"), _("internal+breath"), 0 };
327 static const gig::lfo1_ctrl_t values[] = {
328 gig::lfo1_ctrl_internal,
329 gig::lfo1_ctrl_modwheel,
330 gig::lfo1_ctrl_breath,
331 gig::lfo1_ctrl_internal_modwheel,
332 gig::lfo1_ctrl_internal_breath
333 };
334 eLFO1Controller.set_choices(choices, values);
335 }
336 addProp(eLFO1Controller);
337 addProp(eLFO1FlipPhase);
338 addProp(eLFO1Sync);
339 addHeader(_("Crossfade"));
340 addProp(eAttenuationController);
341 addProp(eInvertAttenuationController);
342 addProp(eAttenuationControllerThreshold);
343 addProp(eCrossfade_in_start);
344 addProp(eCrossfade_in_end);
345 addProp(eCrossfade_out_start);
346 addProp(eCrossfade_out_end);
347
348 nextPage();
349
350 addHeader(_("General Filter Settings"));
351 addProp(eVCFEnabled);
352 {
353 const char* choices[] = { _("lowpass"), _("lowpassturbo"), _("bandpass"),
354 _("highpass"), _("bandreject"), 0 };
355 static const gig::vcf_type_t values[] = {
356 gig::vcf_type_lowpass,
357 gig::vcf_type_lowpassturbo,
358 gig::vcf_type_bandpass,
359 gig::vcf_type_highpass,
360 gig::vcf_type_bandreject
361 };
362 eVCFType.set_choices(choices, values);
363 }
364 addProp(eVCFType);
365 {
366 const char* choices[] = { _("none"), _("none2"), _("modwheel"), _("effect1"), _("effect2"),
367 _("breath"), _("foot"), _("sustainpedal"), _("softpedal"),
368 _("genpurpose7"), _("genpurpose8"), _("aftertouch"), 0 };
369 static const gig::vcf_cutoff_ctrl_t values[] = {
370 gig::vcf_cutoff_ctrl_none,
371 gig::vcf_cutoff_ctrl_none2,
372 gig::vcf_cutoff_ctrl_modwheel,
373 gig::vcf_cutoff_ctrl_effect1,
374 gig::vcf_cutoff_ctrl_effect2,
375 gig::vcf_cutoff_ctrl_breath,
376 gig::vcf_cutoff_ctrl_foot,
377 gig::vcf_cutoff_ctrl_sustainpedal,
378 gig::vcf_cutoff_ctrl_softpedal,
379 gig::vcf_cutoff_ctrl_genpurpose7,
380 gig::vcf_cutoff_ctrl_genpurpose8,
381 gig::vcf_cutoff_ctrl_aftertouch
382 };
383 eVCFCutoffController.set_choices(choices, values);
384 }
385 addProp(eVCFCutoffController);
386 addProp(eVCFCutoffControllerInvert);
387 addProp(eVCFCutoff);
388 const char* curve_type_texts[] = { _("nonlinear"), _("linear"), _("special"), 0 };
389 static const gig::curve_type_t curve_type_values[] = {
390 gig::curve_type_nonlinear,
391 gig::curve_type_linear,
392 gig::curve_type_special
393 };
394 eVCFVelocityCurve.set_choices(curve_type_texts, curve_type_values);
395 addProp(eVCFVelocityCurve);
396 addProp(eVCFVelocityScale);
397 addProp(eVCFVelocityDynamicRange);
398 addProp(eVCFResonance);
399 addProp(eVCFResonanceDynamic);
400 {
401 const char* choices[] = { _("none"), _("genpurpose3"), _("genpurpose4"),
402 _("genpurpose5"), _("genpurpose6"), 0 };
403 static const gig::vcf_res_ctrl_t values[] = {
404 gig::vcf_res_ctrl_none,
405 gig::vcf_res_ctrl_genpurpose3,
406 gig::vcf_res_ctrl_genpurpose4,
407 gig::vcf_res_ctrl_genpurpose5,
408 gig::vcf_res_ctrl_genpurpose6
409 };
410 eVCFResonanceController.set_choices(choices, values);
411 }
412 addProp(eVCFResonanceController);
413 addProp(eVCFKeyboardTracking);
414 addProp(eVCFKeyboardTrackingBreakpoint);
415
416 nextPage();
417
418 lEG2 = addHeader(_("Filter Cutoff Envelope (EG2)"));
419 addProp(eEG2PreAttack);
420 addProp(eEG2Attack);
421 addProp(eEG2Decay1);
422 addProp(eEG2Decay2);
423 addProp(eEG2InfiniteSustain);
424 addProp(eEG2Sustain);
425 addProp(eEG2Release);
426 addProp(eEG2Controller);
427 addProp(eEG2ControllerInvert);
428 addProp(eEG2ControllerAttackInfluence);
429 addProp(eEG2ControllerDecayInfluence);
430 addProp(eEG2ControllerReleaseInfluence);
431 lLFO2 = addHeader(_("Filter Cutoff Oscillator (LFO2)"));
432 addProp(eLFO2Frequency);
433 addProp(eLFO2InternalDepth);
434 addProp(eLFO2ControlDepth);
435 {
436 const char* choices[] = { _("internal"), _("modwheel"), _("foot"),
437 _("internal+modwheel"), _("internal+foot"), 0 };
438 static const gig::lfo2_ctrl_t values[] = {
439 gig::lfo2_ctrl_internal,
440 gig::lfo2_ctrl_modwheel,
441 gig::lfo2_ctrl_foot,
442 gig::lfo2_ctrl_internal_modwheel,
443 gig::lfo2_ctrl_internal_foot
444 };
445 eLFO2Controller.set_choices(choices, values);
446 }
447 addProp(eLFO2Controller);
448 addProp(eLFO2FlipPhase);
449 addProp(eLFO2Sync);
450
451 nextPage();
452
453 addHeader(_("General Pitch Settings"));
454 addProp(eFineTune);
455 addProp(ePitchTrack);
456 addHeader(_("Pitch Envelope (EG3)"));
457 addProp(eEG3Attack);
458 addProp(eEG3Depth);
459 addHeader(_("Pitch Oscillator (LFO3)"));
460 addProp(eLFO3Frequency);
461 addProp(eLFO3InternalDepth);
462 addProp(eLFO3ControlDepth);
463 {
464 const char* choices[] = { _("internal"), _("modwheel"), _("aftertouch"),
465 _("internal+modwheel"), _("internal+aftertouch"), 0 };
466 static const gig::lfo3_ctrl_t values[] = {
467 gig::lfo3_ctrl_internal,
468 gig::lfo3_ctrl_modwheel,
469 gig::lfo3_ctrl_aftertouch,
470 gig::lfo3_ctrl_internal_modwheel,
471 gig::lfo3_ctrl_internal_aftertouch
472 };
473 eLFO3Controller.set_choices(choices, values);
474 }
475 addProp(eLFO3Controller);
476 addProp(eLFO3Sync);
477
478 nextPage();
479
480 eVelocityResponseCurve.set_choices(curve_type_texts, curve_type_values);
481 addProp(eVelocityResponseCurve);
482 addProp(eVelocityResponseDepth);
483 addProp(eVelocityResponseCurveScaling);
484 eReleaseVelocityResponseCurve.set_choices(curve_type_texts,
485 curve_type_values);
486 addProp(eReleaseVelocityResponseCurve);
487 addProp(eReleaseVelocityResponseDepth);
488 addProp(eReleaseTriggerDecay);
489 {
490 const char* choices[] = { _("none"), _("effect4depth"), _("effect5depth"), 0 };
491 static const gig::dim_bypass_ctrl_t values[] = {
492 gig::dim_bypass_ctrl_none,
493 gig::dim_bypass_ctrl_94,
494 gig::dim_bypass_ctrl_95
495 };
496 eDimensionBypass.set_choices(choices, values);
497 }
498 addProp(eDimensionBypass);
499 addProp(eSelfMask);
500 addProp(eSustainDefeat);
501 addProp(eMSDecode);
502
503 nextPage();
504
505
506 eEG1InfiniteSustain.signal_value_changed().connect(
507 sigc::mem_fun(*this, &DimRegionEdit::EG1InfiniteSustain_toggled));
508 eEG2InfiniteSustain.signal_value_changed().connect(
509 sigc::mem_fun(*this, &DimRegionEdit::EG2InfiniteSustain_toggled));
510 eEG1Controller.signal_value_changed().connect(
511 sigc::mem_fun(*this, &DimRegionEdit::EG1Controller_changed));
512 eEG2Controller.signal_value_changed().connect(
513 sigc::mem_fun(*this, &DimRegionEdit::EG2Controller_changed));
514 eLFO1Controller.signal_value_changed().connect(
515 sigc::mem_fun(*this, &DimRegionEdit::LFO1Controller_changed));
516 eLFO2Controller.signal_value_changed().connect(
517 sigc::mem_fun(*this, &DimRegionEdit::LFO2Controller_changed));
518 eLFO3Controller.signal_value_changed().connect(
519 sigc::mem_fun(*this, &DimRegionEdit::LFO3Controller_changed));
520 eAttenuationController.signal_value_changed().connect(
521 sigc::mem_fun(*this, &DimRegionEdit::AttenuationController_changed));
522 eVCFEnabled.signal_value_changed().connect(
523 sigc::mem_fun(*this, &DimRegionEdit::VCFEnabled_toggled));
524 eVCFCutoffController.signal_value_changed().connect(
525 sigc::mem_fun(*this, &DimRegionEdit::VCFCutoffController_changed));
526 eVCFResonanceController.signal_value_changed().connect(
527 sigc::mem_fun(*this, &DimRegionEdit::VCFResonanceController_changed));
528
529 eCrossfade_in_start.signal_value_changed().connect(
530 sigc::mem_fun(*this, &DimRegionEdit::crossfade1_changed));
531 eCrossfade_in_end.signal_value_changed().connect(
532 sigc::mem_fun(*this, &DimRegionEdit::crossfade2_changed));
533 eCrossfade_out_start.signal_value_changed().connect(
534 sigc::mem_fun(*this, &DimRegionEdit::crossfade3_changed));
535 eCrossfade_out_end.signal_value_changed().connect(
536 sigc::mem_fun(*this, &DimRegionEdit::crossfade4_changed));
537
538 eSampleLoopEnabled.signal_value_changed().connect(
539 sigc::mem_fun(*this, &DimRegionEdit::update_loop_elements));
540 eSampleLoopStart.signal_value_changed().connect(
541 sigc::mem_fun(*this, &DimRegionEdit::loop_start_changed));
542 eSampleLoopLength.signal_value_changed().connect(
543 sigc::mem_fun(*this, &DimRegionEdit::loop_length_changed));
544 eSampleLoopInfinite.signal_value_changed().connect(
545 sigc::mem_fun(*this, &DimRegionEdit::loop_infinite_toggled));
546
547 append_page(*table[0], _("Sample"));
548 append_page(*table[1], _("Amplitude (1)"));
549 append_page(*table[2], _("Amplitude (2)"));
550 append_page(*table[3], _("Filter (1)"));
551 append_page(*table[4], _("Filter (2)"));
552 append_page(*table[5], _("Pitch"));
553 append_page(*table[6], _("Misc"));
554 }
555
556 DimRegionEdit::~DimRegionEdit()
557 {
558 }
559
560 void DimRegionEdit::addString(const char* labelText, Gtk::Label*& label,
561 Gtk::Entry*& widget)
562 {
563 label = new Gtk::Label(Glib::ustring(labelText) + ":");
564 label->set_alignment(Gtk::ALIGN_START);
565
566 table[pageno]->attach(*label, 1, 2, rowno, rowno + 1,
567 Gtk::FILL, Gtk::SHRINK);
568
569 widget = new Gtk::Entry();
570
571 table[pageno]->attach(*widget, 2, 3, rowno, rowno + 1,
572 Gtk::EXPAND | Gtk::FILL, Gtk::SHRINK);
573
574 rowno++;
575 }
576
577 Gtk::Label* DimRegionEdit::addHeader(const char* text)
578 {
579 if (firstRowInBlock < rowno - 1)
580 {
581 Gtk::Label* filler = new Gtk::Label(" ");
582 table[pageno]->attach(*filler, 0, 1, firstRowInBlock, rowno,
583 Gtk::FILL, Gtk::SHRINK);
584 }
585 Glib::ustring str = "<b>";
586 str += text;
587 str += "</b>";
588 Gtk::Label* label = new Gtk::Label(str);
589 label->set_use_markup();
590 label->set_alignment(Gtk::ALIGN_START);
591 table[pageno]->attach(*label, 0, 3, rowno, rowno + 1,
592 Gtk::FILL, Gtk::SHRINK);
593 rowno++;
594 firstRowInBlock = rowno;
595 return label;
596 }
597
598 void DimRegionEdit::nextPage()
599 {
600 if (firstRowInBlock < rowno - 1)
601 {
602 Gtk::Label* filler = new Gtk::Label(" ");
603 table[pageno]->attach(*filler, 0, 1, firstRowInBlock, rowno,
604 Gtk::FILL, Gtk::SHRINK);
605 }
606 pageno++;
607 rowno = 0;
608 firstRowInBlock = 0;
609 }
610
611 void DimRegionEdit::addProp(BoolEntry& boolentry)
612 {
613 table[pageno]->attach(boolentry.widget, 1, 3, rowno, rowno + 1,
614 Gtk::FILL, Gtk::SHRINK);
615 rowno++;
616 }
617
618 void DimRegionEdit::addProp(BoolEntryPlus6& boolentry)
619 {
620 table[pageno]->attach(boolentry.widget, 1, 3, rowno, rowno + 1,
621 Gtk::FILL, Gtk::SHRINK);
622 rowno++;
623 }
624
625 void DimRegionEdit::addProp(LabelWidget& prop)
626 {
627 table[pageno]->attach(prop.label, 1, 2, rowno, rowno + 1,
628 Gtk::FILL, Gtk::SHRINK);
629 table[pageno]->attach(prop.widget, 2, 3, rowno, rowno + 1,
630 Gtk::EXPAND | Gtk::FILL, Gtk::SHRINK);
631 rowno++;
632 }
633
634
635 void DimRegionEdit::set_dim_region(gig::DimensionRegion* d)
636 {
637 dimregion = d;
638
639 set_sensitive(d);
640 if (!d) return;
641
642 update_model++;
643 eEG1PreAttack.set_value(d->EG1PreAttack);
644 eEG1Attack.set_value(d->EG1Attack);
645 eEG1Decay1.set_value(d->EG1Decay1);
646 eEG1Decay2.set_value(d->EG1Decay2);
647 eEG1InfiniteSustain.set_value(d->EG1InfiniteSustain);
648 eEG1Sustain.set_value(d->EG1Sustain);
649 eEG1Release.set_value(d->EG1Release);
650 eEG1Hold.set_value(d->EG1Hold);
651 eEG1Controller.set_value(d->EG1Controller);
652 eEG1ControllerInvert.set_value(d->EG1ControllerInvert);
653 eEG1ControllerAttackInfluence.set_value(d->EG1ControllerAttackInfluence);
654 eEG1ControllerDecayInfluence.set_value(d->EG1ControllerDecayInfluence);
655 eEG1ControllerReleaseInfluence.set_value(d->EG1ControllerReleaseInfluence);
656 eLFO1Frequency.set_value(d->LFO1Frequency);
657 eLFO1InternalDepth.set_value(d->LFO1InternalDepth);
658 eLFO1ControlDepth.set_value(d->LFO1ControlDepth);
659 eLFO1Controller.set_value(d->LFO1Controller);
660 eLFO1FlipPhase.set_value(d->LFO1FlipPhase);
661 eLFO1Sync.set_value(d->LFO1Sync);
662 eEG2PreAttack.set_value(d->EG2PreAttack);
663 eEG2Attack.set_value(d->EG2Attack);
664 eEG2Decay1.set_value(d->EG2Decay1);
665 eEG2Decay2.set_value(d->EG2Decay2);
666 eEG2InfiniteSustain.set_value(d->EG2InfiniteSustain);
667 eEG2Sustain.set_value(d->EG2Sustain);
668 eEG2Release.set_value(d->EG2Release);
669 eEG2Controller.set_value(d->EG2Controller);
670 eEG2ControllerInvert.set_value(d->EG2ControllerInvert);
671 eEG2ControllerAttackInfluence.set_value(d->EG2ControllerAttackInfluence);
672 eEG2ControllerDecayInfluence.set_value(d->EG2ControllerDecayInfluence);
673 eEG2ControllerReleaseInfluence.set_value(d->EG2ControllerReleaseInfluence);
674 eLFO2Frequency.set_value(d->LFO2Frequency);
675 eLFO2InternalDepth.set_value(d->LFO2InternalDepth);
676 eLFO2ControlDepth.set_value(d->LFO2ControlDepth);
677 eLFO2Controller.set_value(d->LFO2Controller);
678 eLFO2FlipPhase.set_value(d->LFO2FlipPhase);
679 eLFO2Sync.set_value(d->LFO2Sync);
680 eEG3Attack.set_value(d->EG3Attack);
681 eEG3Depth.set_value(d->EG3Depth);
682 eLFO3Frequency.set_value(d->LFO3Frequency);
683 eLFO3InternalDepth.set_value(d->LFO3InternalDepth);
684 eLFO3ControlDepth.set_value(d->LFO3ControlDepth);
685 eLFO3Controller.set_value(d->LFO3Controller);
686 eLFO3Sync.set_value(d->LFO3Sync);
687 eVCFEnabled.set_value(d->VCFEnabled);
688 eVCFType.set_value(d->VCFType);
689 eVCFCutoffController.set_value(d->VCFCutoffController);
690 eVCFCutoffControllerInvert.set_value(d->VCFCutoffControllerInvert);
691 eVCFCutoff.set_value(d->VCFCutoff);
692 eVCFVelocityCurve.set_value(d->VCFVelocityCurve);
693 eVCFVelocityScale.set_value(d->VCFVelocityScale);
694 eVCFVelocityDynamicRange.set_value(d->VCFVelocityDynamicRange);
695 eVCFResonance.set_value(d->VCFResonance);
696 eVCFResonanceDynamic.set_value(d->VCFResonanceDynamic);
697 eVCFResonanceController.set_value(d->VCFResonanceController);
698 eVCFKeyboardTracking.set_value(d->VCFKeyboardTracking);
699 eVCFKeyboardTrackingBreakpoint.set_value(d->VCFKeyboardTrackingBreakpoint);
700 eVelocityResponseCurve.set_value(d->VelocityResponseCurve);
701 eVelocityResponseDepth.set_value(d->VelocityResponseDepth);
702 eVelocityResponseCurveScaling.set_value(d->VelocityResponseCurveScaling);
703 eReleaseVelocityResponseCurve.set_value(d->ReleaseVelocityResponseCurve);
704 eReleaseVelocityResponseDepth.set_value(d->ReleaseVelocityResponseDepth);
705 eReleaseTriggerDecay.set_value(d->ReleaseTriggerDecay);
706 eCrossfade_in_start.set_value(d->Crossfade.in_start);
707 eCrossfade_in_end.set_value(d->Crossfade.in_end);
708 eCrossfade_out_start.set_value(d->Crossfade.out_start);
709 eCrossfade_out_end.set_value(d->Crossfade.out_end);
710 ePitchTrack.set_value(d->PitchTrack);
711 eDimensionBypass.set_value(d->DimensionBypass);
712 ePan.set_value(d->Pan);
713 eSelfMask.set_value(d->SelfMask);
714 eAttenuationController.set_value(d->AttenuationController);
715 eInvertAttenuationController.set_value(d->InvertAttenuationController);
716 eAttenuationControllerThreshold.set_value(d->AttenuationControllerThreshold);
717 eChannelOffset.set_value(d->ChannelOffset);
718 eSustainDefeat.set_value(d->SustainDefeat);
719 eMSDecode.set_value(d->MSDecode);
720 eSampleStartOffset.set_value(d->SampleStartOffset);
721 eUnityNote.set_value(d->UnityNote);
722 eFineTune.set_value(d->FineTune);
723 eGain.set_value(d->Gain);
724 eGainPlus6.set_value(d->Gain);
725 eSampleLoopEnabled.set_value(d->SampleLoops);
726 eSampleLoopType.set_value(
727 d->SampleLoops ? d->pSampleLoops[0].LoopType : 0);
728 eSampleLoopStart.set_value(
729 d->SampleLoops ? d->pSampleLoops[0].LoopStart : 0);
730 eSampleLoopLength.set_value(
731 d->SampleLoops ? d->pSampleLoops[0].LoopLength : 0);
732 eSampleLoopInfinite.set_value(
733 d->pSample && d->pSample->LoopPlayCount == 0);
734 eSampleLoopPlayCount.set_value(
735 d->pSample ? d->pSample->LoopPlayCount : 0);
736 update_model--;
737
738 wSample->set_text(d->pSample ? d->pSample->pInfo->Name.c_str() : _("NULL"));
739
740 update_loop_elements();
741 VCFEnabled_toggled();
742 }
743
744
745 void DimRegionEdit::VCFEnabled_toggled()
746 {
747 bool sensitive = eVCFEnabled.get_value();
748 eVCFType.set_sensitive(sensitive);
749 eVCFCutoffController.set_sensitive(sensitive);
750 eVCFVelocityCurve.set_sensitive(sensitive);
751 eVCFVelocityScale.set_sensitive(sensitive);
752 eVCFVelocityDynamicRange.set_sensitive(sensitive);
753 eVCFResonance.set_sensitive(sensitive);
754 eVCFResonanceController.set_sensitive(sensitive);
755 eVCFKeyboardTracking.set_sensitive(sensitive);
756 eVCFKeyboardTrackingBreakpoint.set_sensitive(sensitive);
757 lEG2->set_sensitive(sensitive);
758 eEG2PreAttack.set_sensitive(sensitive);
759 eEG2Attack.set_sensitive(sensitive);
760 eEG2Decay1.set_sensitive(sensitive);
761 eEG2InfiniteSustain.set_sensitive(sensitive);
762 eEG2Sustain.set_sensitive(sensitive);
763 eEG2Release.set_sensitive(sensitive);
764 eEG2Controller.set_sensitive(sensitive);
765 eEG2ControllerAttackInfluence.set_sensitive(sensitive);
766 eEG2ControllerDecayInfluence.set_sensitive(sensitive);
767 eEG2ControllerReleaseInfluence.set_sensitive(sensitive);
768 lLFO2->set_sensitive(sensitive);
769 eLFO2Frequency.set_sensitive(sensitive);
770 eLFO2InternalDepth.set_sensitive(sensitive);
771 eLFO2ControlDepth.set_sensitive(sensitive);
772 eLFO2Controller.set_sensitive(sensitive);
773 eLFO2FlipPhase.set_sensitive(sensitive);
774 eLFO2Sync.set_sensitive(sensitive);
775 if (sensitive) {
776 VCFCutoffController_changed();
777 VCFResonanceController_changed();
778 EG2InfiniteSustain_toggled();
779 EG2Controller_changed();
780 LFO2Controller_changed();
781 } else {
782 eVCFCutoffControllerInvert.set_sensitive(false);
783 eVCFCutoff.set_sensitive(false);
784 eVCFResonanceDynamic.set_sensitive(false);
785 eVCFResonance.set_sensitive(false);
786 eEG2Decay2.set_sensitive(false);
787 eEG2ControllerInvert.set_sensitive(false);
788 eLFO2InternalDepth.set_sensitive(false);
789 eLFO2ControlDepth.set_sensitive(false);
790 }
791 }
792
793 void DimRegionEdit::VCFCutoffController_changed()
794 {
795 gig::vcf_cutoff_ctrl_t ctrl = eVCFCutoffController.get_value();
796 bool hasController = ctrl != gig::vcf_cutoff_ctrl_none && ctrl != gig::vcf_cutoff_ctrl_none2;
797
798 eVCFCutoffControllerInvert.set_sensitive(hasController);
799 eVCFCutoff.set_sensitive(!hasController);
800 eVCFResonanceDynamic.set_sensitive(!hasController);
801 eVCFVelocityScale.label.set_text(hasController ? _("Minimum cutoff:") :
802 _("Velocity scale:"));
803 }
804
805 void DimRegionEdit::VCFResonanceController_changed()
806 {
807 bool hasController = eVCFResonanceController.get_value() != gig::vcf_res_ctrl_none;
808 eVCFResonance.set_sensitive(!hasController);
809 }
810
811 void DimRegionEdit::EG1InfiniteSustain_toggled()
812 {
813 bool infSus = eEG1InfiniteSustain.get_value();
814 eEG1Decay2.set_sensitive(!infSus);
815 }
816
817 void DimRegionEdit::EG2InfiniteSustain_toggled()
818 {
819 bool infSus = eEG2InfiniteSustain.get_value();
820 eEG2Decay2.set_sensitive(!infSus);
821 }
822
823 void DimRegionEdit::EG1Controller_changed()
824 {
825 bool hasController = eEG1Controller.get_value().type != gig::leverage_ctrl_t::type_none;
826 eEG1ControllerInvert.set_sensitive(hasController);
827 }
828
829 void DimRegionEdit::EG2Controller_changed()
830 {
831 bool hasController = eEG2Controller.get_value().type != gig::leverage_ctrl_t::type_none;
832 eEG2ControllerInvert.set_sensitive(hasController);
833 }
834
835 void DimRegionEdit::AttenuationController_changed()
836 {
837 bool hasController =
838 eAttenuationController.get_value().type != gig::leverage_ctrl_t::type_none;
839 eInvertAttenuationController.set_sensitive(hasController);
840 eAttenuationControllerThreshold.set_sensitive(hasController);
841 eCrossfade_in_start.set_sensitive(hasController);
842 eCrossfade_in_end.set_sensitive(hasController);
843 eCrossfade_out_start.set_sensitive(hasController);
844 eCrossfade_out_end.set_sensitive(hasController);
845 }
846
847 void DimRegionEdit::LFO1Controller_changed()
848 {
849 gig::lfo1_ctrl_t ctrl = eLFO1Controller.get_value();
850 eLFO1ControlDepth.set_sensitive(ctrl != gig::lfo1_ctrl_internal);
851 eLFO1InternalDepth.set_sensitive(ctrl != gig::lfo1_ctrl_modwheel &&
852 ctrl != gig::lfo1_ctrl_breath);
853 }
854
855 void DimRegionEdit::LFO2Controller_changed()
856 {
857 gig::lfo2_ctrl_t ctrl = eLFO2Controller.get_value();
858 eLFO2ControlDepth.set_sensitive(ctrl != gig::lfo2_ctrl_internal);
859 eLFO2InternalDepth.set_sensitive(ctrl != gig::lfo2_ctrl_modwheel &&
860 ctrl != gig::lfo2_ctrl_foot);
861 }
862
863 void DimRegionEdit::LFO3Controller_changed()
864 {
865 gig::lfo3_ctrl_t ctrl = eLFO3Controller.get_value();
866 eLFO3ControlDepth.set_sensitive(ctrl != gig::lfo3_ctrl_internal);
867 eLFO3InternalDepth.set_sensitive(ctrl != gig::lfo3_ctrl_modwheel &&
868 ctrl != gig::lfo3_ctrl_aftertouch);
869 }
870
871 void DimRegionEdit::crossfade1_changed()
872 {
873 update_model++;
874 eCrossfade_in_end.set_value(dimregion->Crossfade.in_end);
875 eCrossfade_out_start.set_value(dimregion->Crossfade.out_start);
876 eCrossfade_out_end.set_value(dimregion->Crossfade.out_end);
877 update_model--;
878 }
879
880 void DimRegionEdit::crossfade2_changed()
881 {
882 update_model++;
883 eCrossfade_in_start.set_value(dimregion->Crossfade.in_start);
884 eCrossfade_out_start.set_value(dimregion->Crossfade.out_start);
885 eCrossfade_out_end.set_value(dimregion->Crossfade.out_end);
886 update_model--;
887 }
888
889 void DimRegionEdit::crossfade3_changed()
890 {
891 update_model++;
892 eCrossfade_in_start.set_value(dimregion->Crossfade.in_start);
893 eCrossfade_in_end.set_value(dimregion->Crossfade.in_end);
894 eCrossfade_out_end.set_value(dimregion->Crossfade.out_end);
895 update_model--;
896 }
897
898 void DimRegionEdit::crossfade4_changed()
899 {
900 update_model++;
901 eCrossfade_in_start.set_value(dimregion->Crossfade.in_start);
902 eCrossfade_in_end.set_value(dimregion->Crossfade.in_end);
903 eCrossfade_out_start.set_value(dimregion->Crossfade.out_start);
904 update_model--;
905 }
906
907 void DimRegionEdit::update_loop_elements()
908 {
909 update_model++;
910 const bool active = eSampleLoopEnabled.get_value();
911 eSampleLoopStart.set_sensitive(active);
912 eSampleLoopLength.set_sensitive(active);
913 eSampleLoopType.set_sensitive(active);
914 eSampleLoopInfinite.set_sensitive(active && dimregion && dimregion->pSample);
915 // sample loop shall never be longer than the actual sample size
916 loop_start_changed();
917 loop_length_changed();
918 eSampleLoopStart.set_value(
919 dimregion->SampleLoops ? dimregion->pSampleLoops[0].LoopStart : 0);
920 eSampleLoopLength.set_value(
921 dimregion->SampleLoops ? dimregion->pSampleLoops[0].LoopLength : 0);
922
923 eSampleLoopInfinite.set_value(
924 dimregion->pSample && dimregion->pSample->LoopPlayCount == 0);
925
926 loop_infinite_toggled();
927 update_model--;
928 }
929
930 void DimRegionEdit::loop_start_changed() {
931 if (dimregion && dimregion->SampleLoops) {
932 eSampleLoopLength.set_upper(dimregion->pSample ?
933 dimregion->pSample->SamplesTotal -
934 dimregion->pSampleLoops[0].LoopStart : 0);
935 }
936 }
937
938 void DimRegionEdit::loop_length_changed() {
939 if (dimregion && dimregion->SampleLoops) {
940 eSampleLoopStart.set_upper(dimregion->pSample ?
941 dimregion->pSample->SamplesTotal -
942 dimregion->pSampleLoops[0].LoopLength : 0);
943 }
944 }
945
946 void DimRegionEdit::loop_infinite_toggled() {
947 eSampleLoopPlayCount.set_sensitive(
948 dimregion && dimregion->pSample &&
949 !eSampleLoopInfinite.get_value() &&
950 eSampleLoopEnabled.get_value()
951 );
952 update_model++;
953 eSampleLoopPlayCount.set_value(
954 dimregion->pSample ? dimregion->pSample->LoopPlayCount : 0);
955 update_model--;
956 }
957
958 bool DimRegionEdit::set_sample(gig::Sample* sample)
959 {
960 if (dimregion) {
961 //TODO: we should better move the code from MainWindow::on_sample_label_drop_drag_data_received() here
962
963 // currently commented because we're sending a similar signal in MainWindow::on_sample_label_drop_drag_data_received()
964 //dimreg_to_be_changed_signal.emit(dimregion);
965
966 // make sure stereo samples always are the same in both
967 // dimregs in the samplechannel dimension
968 int nbDimregs = 1;
969 gig::DimensionRegion* d[2] = { dimregion, 0 };
970 if (sample->Channels == 2) {
971 gig::Region* region = dimregion->GetParent();
972
973 int bitcount = 0;
974 int stereo_bit = 0;
975 for (int dim = 0 ; dim < region->Dimensions ; dim++) {
976 if (region->pDimensionDefinitions[dim].dimension == gig::dimension_samplechannel) {
977 stereo_bit = 1 << bitcount;
978 break;
979 }
980 bitcount += region->pDimensionDefinitions[dim].bits;
981 }
982
983 if (stereo_bit) {
984 int dimregno;
985 for (dimregno = 0 ; dimregno < region->DimensionRegions ; dimregno++) {
986 if (region->pDimensionRegions[dimregno] == dimregion) {
987 break;
988 }
989 }
990 d[0] = region->pDimensionRegions[dimregno & ~stereo_bit];
991 d[1] = region->pDimensionRegions[dimregno | stereo_bit];
992 nbDimregs = 2;
993 }
994 }
995
996 gig::Sample* oldref = dimregion->pSample;
997
998 for (int i = 0 ; i < nbDimregs ; i++) {
999 d[i]->pSample = sample;
1000
1001 // copy sample information from Sample to DimensionRegion
1002
1003 d[i]->UnityNote = sample->MIDIUnityNote;
1004 d[i]->FineTune = sample->FineTune;
1005
1006 int loops = sample->Loops ? 1 : 0;
1007 while (d[i]->SampleLoops > loops) {
1008 d[i]->DeleteSampleLoop(&d[i]->pSampleLoops[0]);
1009 }
1010 while (d[i]->SampleLoops < sample->Loops) {
1011 DLS::sample_loop_t loop;
1012 d[i]->AddSampleLoop(&loop);
1013 }
1014 if (loops) {
1015 d[i]->pSampleLoops[0].Size = sizeof(DLS::sample_loop_t);
1016 d[i]->pSampleLoops[0].LoopType = sample->LoopType;
1017 d[i]->pSampleLoops[0].LoopStart = sample->LoopStart;
1018 d[i]->pSampleLoops[0].LoopLength = sample->LoopEnd - sample->LoopStart + 1;
1019 }
1020 }
1021
1022 // update ui
1023 update_model++;
1024 wSample->set_text(dimregion->pSample->pInfo->Name);
1025 eUnityNote.set_value(dimregion->UnityNote);
1026 eFineTune.set_value(dimregion->FineTune);
1027 eSampleLoopEnabled.set_value(dimregion->SampleLoops);
1028 update_loop_elements();
1029 update_model--;
1030
1031 sample_ref_changed_signal.emit(oldref, sample);
1032 // currently commented because we're sending a similar signal in MainWindow::on_sample_label_drop_drag_data_received()
1033 //dimreg_changed_signal.emit(dimregion);
1034 return true;
1035 }
1036 return false;
1037 }
1038
1039 sigc::signal<void, gig::DimensionRegion*>& DimRegionEdit::signal_dimreg_to_be_changed() {
1040 return dimreg_to_be_changed_signal;
1041 }
1042
1043 sigc::signal<void, gig::DimensionRegion*>& DimRegionEdit::signal_dimreg_changed() {
1044 return dimreg_changed_signal;
1045 }
1046
1047 sigc::signal<void, gig::Sample*/*old*/, gig::Sample*/*new*/>& DimRegionEdit::signal_sample_ref_changed() {
1048 return sample_ref_changed_signal;
1049 }
1050
1051
1052 void DimRegionEdit::set_UnityNote(gig::DimensionRegion* d, uint8_t value)
1053 {
1054 d->UnityNote = value;
1055 }
1056
1057 void DimRegionEdit::set_FineTune(gig::DimensionRegion* d, int16_t value)
1058 {
1059 d->FineTune = value;
1060 }
1061
1062 void DimRegionEdit::set_Crossfade_in_start(gig::DimensionRegion* d,
1063 uint8_t value)
1064 {
1065 d->Crossfade.in_start = value;
1066 if (d->Crossfade.in_end < value) set_Crossfade_in_end(d, value);
1067 }
1068
1069 void DimRegionEdit::set_Crossfade_in_end(gig::DimensionRegion* d,
1070 uint8_t value)
1071 {
1072 d->Crossfade.in_end = value;
1073 if (value < d->Crossfade.in_start) set_Crossfade_in_start(d, value);
1074 if (value > d->Crossfade.out_start) set_Crossfade_out_start(d, value);
1075 }
1076
1077 void DimRegionEdit::set_Crossfade_out_start(gig::DimensionRegion* d,
1078 uint8_t value)
1079 {
1080 d->Crossfade.out_start = value;
1081 if (value < d->Crossfade.in_end) set_Crossfade_in_end(d, value);
1082 if (value > d->Crossfade.out_end) set_Crossfade_out_end(d, value);
1083 }
1084
1085 void DimRegionEdit::set_Crossfade_out_end(gig::DimensionRegion* d,
1086 uint8_t value)
1087 {
1088 d->Crossfade.out_end = value;
1089 if (value < d->Crossfade.out_start) set_Crossfade_out_start(d, value);
1090 }
1091
1092 void DimRegionEdit::set_Gain(gig::DimensionRegion* d, int32_t value)
1093 {
1094 d->SetGain(value);
1095 }
1096
1097 void DimRegionEdit::set_LoopEnabled(gig::DimensionRegion* d, bool value)
1098 {
1099 if (value) {
1100 // create a new sample loop in case there is none yet
1101 if (!d->SampleLoops) {
1102 DLS::sample_loop_t loop;
1103 loop.LoopType = gig::loop_type_normal;
1104 // loop the whole sample by default
1105 loop.LoopStart = 0;
1106 loop.LoopLength =
1107 (d->pSample) ? d->pSample->SamplesTotal : 0;
1108 dimreg_to_be_changed_signal.emit(d);
1109 d->AddSampleLoop(&loop);
1110 dimreg_changed_signal.emit(d);
1111 }
1112 } else {
1113 if (d->SampleLoops) {
1114 dimreg_to_be_changed_signal.emit(d);
1115 // delete ALL existing sample loops
1116 while (d->SampleLoops) {
1117 d->DeleteSampleLoop(&d->pSampleLoops[0]);
1118 }
1119 dimreg_changed_signal.emit(d);
1120 }
1121 }
1122 }
1123
1124 void DimRegionEdit::set_LoopType(gig::DimensionRegion* d, uint32_t value)
1125 {
1126 if (d->SampleLoops) d->pSampleLoops[0].LoopType = value;
1127 }
1128
1129 void DimRegionEdit::set_LoopStart(gig::DimensionRegion* d, uint32_t value)
1130 {
1131 if (d->SampleLoops) {
1132 d->pSampleLoops[0].LoopStart =
1133 d->pSample ?
1134 std::min(value, uint32_t(d->pSample->SamplesTotal -
1135 d->pSampleLoops[0].LoopLength)) :
1136 0;
1137 }
1138 }
1139
1140 void DimRegionEdit::set_LoopLength(gig::DimensionRegion* d, uint32_t value)
1141 {
1142 if (d->SampleLoops) {
1143 d->pSampleLoops[0].LoopLength =
1144 d->pSample ?
1145 std::min(value, uint32_t(d->pSample->SamplesTotal -
1146 d->pSampleLoops[0].LoopStart)) :
1147 0;
1148 }
1149 }
1150
1151 void DimRegionEdit::set_LoopInfinite(gig::DimensionRegion* d, bool value)
1152 {
1153 if (d->pSample) {
1154 if (value) d->pSample->LoopPlayCount = 0;
1155 else if (d->pSample->LoopPlayCount == 0) d->pSample->LoopPlayCount = 1;
1156 }
1157 }
1158
1159 void DimRegionEdit::set_LoopPlayCount(gig::DimensionRegion* d, uint32_t value)
1160 {
1161 if (d->pSample) d->pSample->LoopPlayCount = value;
1162 }

  ViewVC Help
Powered by ViewVC