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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 2397 - (hide annotations) (download)
Wed Jan 9 20:59:29 2013 UTC (6 years, 6 months ago) by persson
File size: 51897 byte(s)
* minor tweaks to the graphical curves
* updated Swedish translation

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

  ViewVC Help
Powered by ViewVC