/[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 1322 - (hide annotations) (download)
Tue Sep 4 11:04:56 2007 UTC (12 years, 2 months ago) by schoenebeck
File size: 35212 byte(s)
* as counterpart to latest LS commit: added experimental support to
  synchronize gigedit with LinuxSampler to avoid race conditions / crash
  while modifying data structures and playing the instrument with LS at
  the same time
* packaging fixes: don't use a hard coded path to install the LS plugin
  DLL, trying to substitute the given LS plugin directory by the
  '${libdir}' automake variable (mandatory i.e. for Gentoo ebuild) and
  include plugin/linuxsamplerplugin.h into the release tarball
  ('make dist')
* updated German translation (po/de.po)

1 schoenebeck 1225 /*
2     * Copyright (C) 2006, 2007 Andreas Persson
3     *
4     * This program is free software; you can redistribute it and/or
5     * modify it under the terms of the GNU General Public License as
6     * published by the Free Software Foundation; either version 2, or (at
7     * your option) any later version.
8     *
9     * This program is distributed in the hope that it will be useful, but
10     * WITHOUT ANY WARRANTY; without even the implied warranty of
11     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12     * General Public License for more details.
13     *
14     * You should have received a copy of the GNU General Public License
15     * along with program; see the file COPYING. If not, write to the Free
16     * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
17     * 02110-1301 USA.
18     */
19    
20     #include "dimregionedit.h"
21    
22     #include <libintl.h>
23     #define _(String) gettext(String)
24    
25     DimRegionEdit::DimRegionEdit() :
26     eEG1PreAttack("Pre-attack", 0, 100, 2),
27     eEG1Attack("Attack", 0, 60, 3),
28     eEG1Decay1("Decay 1", 0.005, 60, 3),
29     eEG1Decay2("Decay 2", 0, 60, 3),
30     eEG1InfiniteSustain("Infinite sustain"),
31     eEG1Sustain("Sustain", 0, 100, 2),
32     eEG1Release("Release", 0, 60, 3),
33     eEG1Hold("Hold"),
34     eEG1Controller("Controller"),
35     eEG1ControllerInvert("Controller invert"),
36     eEG1ControllerAttackInfluence("Controller attack influence", 0, 3),
37     eEG1ControllerDecayInfluence("Controller decay influence", 0, 3),
38     eEG1ControllerReleaseInfluence("Controller release influence", 0, 3),
39     eLFO1Frequency("Frequency", 0.1, 10, 2),
40     eLFO1InternalDepth("Internal depth", 0, 1200),
41     eLFO1ControlDepth("Control depth", 0, 1200),
42     eLFO1Controller("Controller"),
43     eLFO1FlipPhase("Flip phase"),
44     eLFO1Sync("Sync"),
45     eEG2PreAttack("Pre-attack", 0, 100, 2),
46     eEG2Attack("Attack", 0, 60, 3),
47     eEG2Decay1("Decay 1", 0.005, 60, 3),
48     eEG2Decay2("Decay 2", 0, 60, 3),
49     eEG2InfiniteSustain("Infinite sustain"),
50     eEG2Sustain("Sustain", 0, 100, 2),
51     eEG2Release("Release", 0, 60, 3),
52     eEG2Controller("Controller"),
53     eEG2ControllerInvert("Controller invert"),
54     eEG2ControllerAttackInfluence("Controller attack influence", 0, 3),
55     eEG2ControllerDecayInfluence("Controller decay influence", 0, 3),
56     eEG2ControllerReleaseInfluence("Controller release influence", 0, 3),
57     eLFO2Frequency("Frequency", 0.1, 10, 2),
58     eLFO2InternalDepth("Internal depth", 0, 1200),
59     eLFO2ControlDepth("Control depth", 0, 1200),
60     eLFO2Controller("Controller"),
61     eLFO2FlipPhase("Flip phase"),
62     eLFO2Sync("Sync"),
63     eEG3Attack("Attack", 0, 10, 3),
64     eEG3Depth("Depth", -1200, 1200),
65     eLFO3Frequency("Frequency", 0.1, 10, 2),
66     eLFO3InternalDepth("Internal depth", 0, 1200),
67     eLFO3ControlDepth("Control depth", 0, 1200),
68     eLFO3Controller("Controller"),
69     eLFO3Sync("Sync"),
70     eVCFEnabled("Enabled"),
71     eVCFType("Type"),
72     eVCFCutoffController("Cutoff controller"),
73     eVCFCutoffControllerInvert("Cutoff controller invert"),
74     eVCFCutoff("Cutoff"),
75     eVCFVelocityCurve("Velocity curve"),
76     eVCFVelocityScale("Velocity scale"),
77     eVCFVelocityDynamicRange("Velocity dynamic range", 0, 4),
78     eVCFResonance("Resonance"),
79     eVCFResonanceDynamic("Resonance dynamic"),
80     eVCFResonanceController("Resonance controller"),
81     eVCFKeyboardTracking("Keyboard tracking"),
82     eVCFKeyboardTrackingBreakpoint("Keyboard tracking breakpoint"),
83     eVelocityResponseCurve("Velocity response curve"),
84     eVelocityResponseDepth("Velocity response depth", 0, 4),
85     eVelocityResponseCurveScaling("Velocity response curve scaling"),
86     eReleaseVelocityResponseCurve("Release velocity response curve"),
87     eReleaseVelocityResponseDepth("Release velocity response depth", 0, 4),
88     eReleaseTriggerDecay("Release trigger decay", 0, 8),
89     eCrossfade_in_start("Crossfade-in start"),
90     eCrossfade_in_end("Crossfade-in end"),
91     eCrossfade_out_start("Crossfade-out start"),
92     eCrossfade_out_end("Crossfade-out end"),
93     ePitchTrack("Pitch track"),
94     eDimensionBypass("Dimension bypass"),
95     ePan("Pan", -64, 63),
96     eSelfMask("Self mask"),
97     eAttenuationController("Attenuation controller"),
98     eInvertAttenuationController("Invert attenuation controller"),
99     eAttenuationControllerThreshold("Attenuation controller threshold"),
100     eChannelOffset("Channel offset", 0, 9),
101     eSustainDefeat("Sustain defeat"),
102     eMSDecode("MS decode"),
103     eSampleStartOffset("Sample start offset", 0, 2000),
104     eUnityNote("Unity note"),
105     eFineTune("Fine tune", -49, 50),
106     eGain("Gain", -96, 0, 2, -655360),
107     eGainPlus6("Gain +6dB", eGain, 6 * -655360),
108     eSampleLoopEnabled("Enabled"),
109     eSampleLoopStart("Loop start positon"),
110     eSampleLoopLength("Loop size"),
111     eSampleLoopType("Loop type"),
112     eSampleLoopInfinite("Infinite loop"),
113     eSampleLoopPlayCount("Playback count")
114     {
115     for (int i = 0 ; i < 7 ; i++) {
116     table[i] = new Gtk::Table(3, 1);
117     table[i]->set_col_spacings(7);
118     }
119    
120     // set tooltips
121     eUnityNote.set_tip(
122     _("Note this sample is associated with (a.k.a. 'root note')")
123     );
124     eSampleStartOffset.set_tip(_("Sample position at which playback should be started"));
125     ePan.set_tip(_("Stereo balance (left/right)"));
126     eChannelOffset.set_tip(
127     _("Output channel where the audio signal should be routed to (0 - 9)")
128     );
129     ePitchTrack.set_tip(
130     _("If true: sample will be pitched according to the key position "
131     "(this would be disabled for drums for example)")
132     );
133     eSampleLoopEnabled.set_tip(_("If enabled: repeats to playback the sample"));
134     eSampleLoopStart.set_tip(
135     _("Start position within the sample (in sample points) of the area to "
136     "be looped")
137     );
138     eSampleLoopLength.set_tip(
139     _("Duration (in sample points) of the area to be looped")
140     );
141     eSampleLoopType.set_tip(
142     _("Direction in which the loop area in the sample should be played back")
143     );
144     eSampleLoopInfinite.set_tip(
145     _("Whether the loop area should be played back forever\n"
146     "Caution: this setting is stored on Sample side, thus is shared "
147     "among all dimension regions that use this sample!")
148     );
149     eSampleLoopPlayCount.set_tip(
150     _("How many times the loop area should be played back\n"
151     "Caution: this setting is stored on Sample side, thus is shared "
152     "among all dimension regions that use this sample!")
153     );
154    
155     pageno = 0;
156     rowno = 0;
157     firstRowInBlock = 0;
158    
159     addHeader(_("Mandatory Settings"));
160     addString("Sample", lSample, wSample);
161     //TODO: the following would break drag&drop: wSample->property_editable().set_value(false); or this: wSample->set_editable(false);
162     tooltips.set_tip(*wSample, _("Drop a sample here"));
163     addProp(eUnityNote);
164     addHeader(_("Optional Settings"));
165     addProp(eSampleStartOffset);
166     addProp(eChannelOffset);
167     addHeader("Loops");
168     addProp(eSampleLoopEnabled);
169     addProp(eSampleLoopStart);
170     addProp(eSampleLoopLength);
171     {
172     const char* choices[] = { "normal", "bidirectional", "backward", 0 };
173     static const uint32_t values[] = {
174     gig::loop_type_normal,
175     gig::loop_type_bidirectional,
176     gig::loop_type_backward
177     };
178     eSampleLoopType.set_choices(choices, values);
179     }
180     addProp(eSampleLoopType);
181     addProp(eSampleLoopInfinite);
182     addProp(eSampleLoopPlayCount);
183    
184     nextPage();
185    
186     addHeader(_("General Amplitude Settings"));
187     addProp(eGain);
188     addProp(eGainPlus6);
189     addProp(ePan);
190     addHeader(_("Amplitude Envelope (EG1)"));
191     addProp(eEG1PreAttack);
192     addProp(eEG1Attack);
193     addProp(eEG1Decay1);
194     addProp(eEG1Decay2);
195     addProp(eEG1InfiniteSustain);
196     addProp(eEG1Sustain);
197     addProp(eEG1Release);
198     addProp(eEG1Hold);
199     addProp(eEG1Controller);
200     addProp(eEG1ControllerInvert);
201     addProp(eEG1ControllerAttackInfluence);
202     addProp(eEG1ControllerDecayInfluence);
203     addProp(eEG1ControllerReleaseInfluence);
204    
205     nextPage();
206    
207     addHeader(_("Amplitude Oscillator (LFO1)"));
208     addProp(eLFO1Frequency);
209     addProp(eLFO1InternalDepth);
210     addProp(eLFO1ControlDepth);
211     {
212     const char* choices[] = { "internal", "modwheel", "breath",
213     "internal+modwheel", "internal+breath", 0 };
214     static const gig::lfo1_ctrl_t values[] = {
215     gig::lfo1_ctrl_internal,
216     gig::lfo1_ctrl_modwheel,
217     gig::lfo1_ctrl_breath,
218     gig::lfo1_ctrl_internal_modwheel,
219     gig::lfo1_ctrl_internal_breath
220     };
221     eLFO1Controller.set_choices(choices, values);
222     }
223     addProp(eLFO1Controller);
224     addProp(eLFO1FlipPhase);
225     addProp(eLFO1Sync);
226     addHeader("Crossfade");
227     addProp(eAttenuationController);
228     addProp(eInvertAttenuationController);
229     addProp(eAttenuationControllerThreshold);
230     addProp(eCrossfade_in_start);
231     addProp(eCrossfade_in_end);
232     addProp(eCrossfade_out_start);
233     addProp(eCrossfade_out_end);
234    
235     nextPage();
236    
237     addHeader(_("General Filter Settings"));
238     addProp(eVCFEnabled);
239     {
240     const char* choices[] = { "lowpass", "lowpassturbo", "bandpass",
241     "highpass", "bandreject", 0 };
242     static const gig::vcf_type_t values[] = {
243     gig::vcf_type_lowpass,
244     gig::vcf_type_lowpassturbo,
245     gig::vcf_type_bandpass,
246     gig::vcf_type_highpass,
247     gig::vcf_type_bandreject
248     };
249     eVCFType.set_choices(choices, values);
250     }
251     addProp(eVCFType);
252     {
253     const char* choices[] = { "none", "none2", "modwheel", "effect1", "effect2",
254     "breath", "foot", "sustainpedal", "softpedal",
255     "genpurpose7", "genpurpose8", "aftertouch", 0 };
256     static const gig::vcf_cutoff_ctrl_t values[] = {
257     gig::vcf_cutoff_ctrl_none,
258     gig::vcf_cutoff_ctrl_none2,
259     gig::vcf_cutoff_ctrl_modwheel,
260     gig::vcf_cutoff_ctrl_effect1,
261     gig::vcf_cutoff_ctrl_effect2,
262     gig::vcf_cutoff_ctrl_breath,
263     gig::vcf_cutoff_ctrl_foot,
264     gig::vcf_cutoff_ctrl_sustainpedal,
265     gig::vcf_cutoff_ctrl_softpedal,
266     gig::vcf_cutoff_ctrl_genpurpose7,
267     gig::vcf_cutoff_ctrl_genpurpose8,
268     gig::vcf_cutoff_ctrl_aftertouch
269     };
270     eVCFCutoffController.set_choices(choices, values);
271     }
272     addProp(eVCFCutoffController);
273     addProp(eVCFCutoffControllerInvert);
274     addProp(eVCFCutoff);
275     const char* curve_type_texts[] = { "nonlinear", "linear", "special", 0 };
276     static const gig::curve_type_t curve_type_values[] = {
277     gig::curve_type_nonlinear,
278     gig::curve_type_linear,
279     gig::curve_type_special
280     };
281     eVCFVelocityCurve.set_choices(curve_type_texts, curve_type_values);
282     addProp(eVCFVelocityCurve);
283     addProp(eVCFVelocityScale);
284     addProp(eVCFVelocityDynamicRange);
285     addProp(eVCFResonance);
286     addProp(eVCFResonanceDynamic);
287     {
288     const char* choices[] = { "none", "genpurpose3", "genpurpose4",
289     "genpurpose5", "genpurpose6", 0 };
290     static const gig::vcf_res_ctrl_t values[] = {
291     gig::vcf_res_ctrl_none,
292     gig::vcf_res_ctrl_genpurpose3,
293     gig::vcf_res_ctrl_genpurpose4,
294     gig::vcf_res_ctrl_genpurpose5,
295     gig::vcf_res_ctrl_genpurpose6
296     };
297     eVCFResonanceController.set_choices(choices, values);
298     }
299     addProp(eVCFResonanceController);
300     addProp(eVCFKeyboardTracking);
301     addProp(eVCFKeyboardTrackingBreakpoint);
302    
303     nextPage();
304    
305     addHeader(_("Filter Cutoff Envelope (EG2)"));
306     addProp(eEG2PreAttack);
307     addProp(eEG2Attack);
308     addProp(eEG2Decay1);
309     addProp(eEG2Decay2);
310     addProp(eEG2InfiniteSustain);
311     addProp(eEG2Sustain);
312     addProp(eEG2Release);
313     addProp(eEG2Controller);
314     addProp(eEG2ControllerInvert);
315     addProp(eEG2ControllerAttackInfluence);
316     addProp(eEG2ControllerDecayInfluence);
317     addProp(eEG2ControllerReleaseInfluence);
318     addHeader(_("Filter Cutoff Oscillator (LFO2)"));
319     addProp(eLFO2Frequency);
320     addProp(eLFO2InternalDepth);
321     addProp(eLFO2ControlDepth);
322     {
323     const char* choices[] = { "internal", "modwheel", "foot",
324     "internal+modwheel", "internal+foot", 0 };
325     static const gig::lfo2_ctrl_t values[] = {
326     gig::lfo2_ctrl_internal,
327     gig::lfo2_ctrl_modwheel,
328     gig::lfo2_ctrl_foot,
329     gig::lfo2_ctrl_internal_modwheel,
330     gig::lfo2_ctrl_internal_foot
331     };
332     eLFO2Controller.set_choices(choices, values);
333     }
334     addProp(eLFO2Controller);
335     addProp(eLFO2FlipPhase);
336     addProp(eLFO2Sync);
337    
338     nextPage();
339    
340     addHeader(_("General Pitch Settings"));
341     addProp(eFineTune);
342     addProp(ePitchTrack);
343     addHeader(_("Pitch Envelope (EG3)"));
344     addProp(eEG3Attack);
345     addProp(eEG3Depth);
346     addHeader(_("Pitch Oscillator (LFO3)"));
347     addProp(eLFO3Frequency);
348     addProp(eLFO3InternalDepth);
349     addProp(eLFO3ControlDepth);
350     {
351     const char* choices[] = { "internal", "modwheel", "aftertouch",
352     "internal+modwheel", "internal+aftertouch", 0 };
353     static const gig::lfo3_ctrl_t values[] = {
354     gig::lfo3_ctrl_internal,
355     gig::lfo3_ctrl_modwheel,
356     gig::lfo3_ctrl_aftertouch,
357     gig::lfo3_ctrl_internal_modwheel,
358     gig::lfo3_ctrl_internal_aftertouch
359     };
360     eLFO3Controller.set_choices(choices, values);
361     }
362     addProp(eLFO3Controller);
363     addProp(eLFO3Sync);
364    
365     nextPage();
366    
367     eVelocityResponseCurve.set_choices(curve_type_texts, curve_type_values);
368     addProp(eVelocityResponseCurve);
369     addProp(eVelocityResponseDepth);
370     addProp(eVelocityResponseCurveScaling);
371     eReleaseVelocityResponseCurve.set_choices(curve_type_texts,
372     curve_type_values);
373     addProp(eReleaseVelocityResponseCurve);
374     addProp(eReleaseVelocityResponseDepth);
375     addProp(eReleaseTriggerDecay);
376     {
377     const char* choices[] = { "none", "effect4depth", "effect5depth", 0 };
378     static const gig::dim_bypass_ctrl_t values[] = {
379     gig::dim_bypass_ctrl_none,
380     gig::dim_bypass_ctrl_94,
381     gig::dim_bypass_ctrl_95
382     };
383     eDimensionBypass.set_choices(choices, values);
384     }
385     addProp(eDimensionBypass);
386     addProp(eSelfMask);
387     addProp(eSustainDefeat);
388     addProp(eMSDecode);
389    
390     nextPage();
391    
392    
393     eEG1InfiniteSustain.signal_toggled().connect(
394     sigc::mem_fun(*this, &DimRegionEdit::EG1InfiniteSustain_toggled) );
395     eEG2InfiniteSustain.signal_toggled().connect(
396     sigc::mem_fun(*this, &DimRegionEdit::EG2InfiniteSustain_toggled) );
397     eEG1Controller.signal_changed().connect(
398     sigc::mem_fun(*this, &DimRegionEdit::EG1Controller_changed) );
399     eEG2Controller.signal_changed().connect(
400     sigc::mem_fun(*this, &DimRegionEdit::EG2Controller_changed) );
401     eLFO1Controller.signal_changed().connect(
402     sigc::mem_fun(*this, &DimRegionEdit::LFO1Controller_changed) );
403     eLFO2Controller.signal_changed().connect(
404     sigc::mem_fun(*this, &DimRegionEdit::LFO2Controller_changed) );
405     eLFO3Controller.signal_changed().connect(
406     sigc::mem_fun(*this, &DimRegionEdit::LFO3Controller_changed) );
407     eAttenuationController.signal_changed().connect(
408     sigc::mem_fun(*this, &DimRegionEdit::AttenuationController_changed) );
409     eVCFEnabled.signal_toggled().connect(
410     sigc::mem_fun(*this, &DimRegionEdit::VCFEnabled_toggled) );
411     eVCFCutoffController.signal_changed().connect(
412     sigc::mem_fun(*this, &DimRegionEdit::VCFCutoffController_changed) );
413     eVCFResonanceController.signal_changed().connect(
414     sigc::mem_fun(*this, &DimRegionEdit::VCFResonanceController_changed) );
415    
416 persson 1261 eCrossfade_in_start.signal_changed_by_user().connect(
417 schoenebeck 1225 sigc::mem_fun(*this, &DimRegionEdit::crossfade1_changed));
418 persson 1261 eCrossfade_in_end.signal_changed_by_user().connect(
419 schoenebeck 1225 sigc::mem_fun(*this, &DimRegionEdit::crossfade2_changed));
420 persson 1261 eCrossfade_out_start.signal_changed_by_user().connect(
421 schoenebeck 1225 sigc::mem_fun(*this, &DimRegionEdit::crossfade3_changed));
422 persson 1261 eCrossfade_out_end.signal_changed_by_user().connect(
423 schoenebeck 1225 sigc::mem_fun(*this, &DimRegionEdit::crossfade4_changed));
424    
425     eSampleLoopEnabled.signal_toggled().connect(
426     sigc::mem_fun(*this, &DimRegionEdit::loop_enabled_toggled));
427 persson 1261 eSampleLoopStart.signal_changed_by_user().connect(
428 schoenebeck 1225 sigc::mem_fun(*this, &DimRegionEdit::updateLoopElements));
429 persson 1261 eSampleLoopLength.signal_changed_by_user().connect(
430 schoenebeck 1225 sigc::mem_fun(*this, &DimRegionEdit::updateLoopElements));
431     eSampleLoopInfinite.signal_toggled().connect(
432     sigc::mem_fun(*this, &DimRegionEdit::loop_infinite_toggled));
433    
434     append_page(*table[0], "Sample");
435     append_page(*table[1], "Amplitude (1)");
436     append_page(*table[2], "Amplitude (2)");
437     append_page(*table[3], "Filter (1)");
438     append_page(*table[4], "Filter (2)");
439     append_page(*table[5], "Pitch");
440     append_page(*table[6], "Misc");
441     }
442    
443     DimRegionEdit::~DimRegionEdit()
444     {
445     }
446    
447     void DimRegionEdit::addString(const char* labelText, Gtk::Label*& label,
448     Gtk::Entry*& widget)
449     {
450     label = new Gtk::Label(Glib::ustring(labelText) + ":");
451     label->set_alignment(Gtk::ALIGN_LEFT);
452    
453     table[pageno]->attach(*label, 1, 2, rowno, rowno + 1,
454     Gtk::FILL, Gtk::SHRINK);
455    
456     widget = new Gtk::Entry();
457    
458     table[pageno]->attach(*widget, 2, 3, rowno, rowno + 1,
459     Gtk::EXPAND | Gtk::FILL, Gtk::SHRINK);
460    
461     rowno++;
462     }
463    
464     void DimRegionEdit::addHeader(const char* text)
465     {
466     if (firstRowInBlock < rowno - 1)
467     {
468     Gtk::Label* filler = new Gtk::Label(" ");
469     table[pageno]->attach(*filler, 0, 1, firstRowInBlock, rowno,
470     Gtk::FILL, Gtk::SHRINK);
471     }
472     Glib::ustring str = "<b>";
473     str += text;
474     str += "</b>";
475     Gtk::Label* label = new Gtk::Label(str);
476     label->set_use_markup();
477     label->set_alignment(Gtk::ALIGN_LEFT);
478     table[pageno]->attach(*label, 0, 3, rowno, rowno + 1,
479     Gtk::FILL, Gtk::SHRINK);
480     rowno++;
481     firstRowInBlock = rowno;
482     }
483    
484     void DimRegionEdit::nextPage()
485     {
486     if (firstRowInBlock < rowno - 1)
487     {
488     Gtk::Label* filler = new Gtk::Label(" ");
489     table[pageno]->attach(*filler, 0, 1, firstRowInBlock, rowno,
490     Gtk::FILL, Gtk::SHRINK);
491     }
492     pageno++;
493     rowno = 0;
494     firstRowInBlock = 0;
495     }
496    
497     void DimRegionEdit::addProp(BoolEntry& boolentry)
498     {
499     table[pageno]->attach(boolentry.widget, 1, 3, rowno, rowno + 1,
500     Gtk::FILL, Gtk::SHRINK);
501     rowno++;
502 schoenebeck 1322 boolentry.signal_changed_by_user().connect(
503     sigc::bind(dimreg_changed_signal.make_slot(), sigc::ref(this->dimregion))
504     );
505 schoenebeck 1225 }
506    
507 persson 1262 void DimRegionEdit::addProp(BoolEntryPlus6& boolentry)
508     {
509     table[pageno]->attach(boolentry.widget, 1, 3, rowno, rowno + 1,
510     Gtk::FILL, Gtk::SHRINK);
511     rowno++;
512 schoenebeck 1322 boolentry.signal_changed_by_user().connect(
513     sigc::bind(dimreg_changed_signal.make_slot(), sigc::ref(this->dimregion))
514     );
515 persson 1262 }
516    
517 schoenebeck 1225 void DimRegionEdit::addProp(LabelWidget& prop)
518     {
519     table[pageno]->attach(prop.label, 1, 2, rowno, rowno + 1,
520     Gtk::FILL, Gtk::SHRINK);
521     table[pageno]->attach(prop.widget, 2, 3, rowno, rowno + 1,
522     Gtk::EXPAND | Gtk::FILL, Gtk::SHRINK);
523     rowno++;
524 schoenebeck 1322 prop.signal_changed_by_user().connect(
525     sigc::bind(dimreg_changed_signal.make_slot(), sigc::ref(this->dimregion))
526     );
527 schoenebeck 1225 }
528    
529    
530     void DimRegionEdit::set_dim_region(gig::DimensionRegion* d)
531     {
532     dimregion = d;
533    
534     set_sensitive(d);
535     if (!d) return;
536    
537     wSample->set_text(d->pSample ? d->pSample->pInfo->Name.c_str() : "NULL");
538     eEG1PreAttack.set_ptr(&d->EG1PreAttack);
539     eEG1Attack.set_ptr(&d->EG1Attack);
540     eEG1Decay1.set_ptr(&d->EG1Decay1);
541     eEG1Decay2.set_ptr(&d->EG1Decay2);
542     eEG1InfiniteSustain.set_ptr(&d->EG1InfiniteSustain);
543     eEG1Sustain.set_ptr(&d->EG1Sustain);
544     eEG1Release.set_ptr(&d->EG1Release);
545     eEG1Hold.set_ptr(&d->EG1Hold);
546     eEG1Controller.set_ptr(&d->EG1Controller);
547     eEG1ControllerInvert.set_ptr(&d->EG1ControllerInvert);
548     eEG1ControllerAttackInfluence.set_ptr(&d->EG1ControllerAttackInfluence);
549     eEG1ControllerDecayInfluence.set_ptr(&d->EG1ControllerDecayInfluence);
550     eEG1ControllerReleaseInfluence.set_ptr(&d->EG1ControllerReleaseInfluence);
551     eLFO1Frequency.set_ptr(&d->LFO1Frequency);
552     eLFO1InternalDepth.set_ptr(&d->LFO1InternalDepth);
553     eLFO1ControlDepth.set_ptr(&d->LFO1ControlDepth);
554     eLFO1Controller.set_ptr(&d->LFO1Controller);
555     eLFO1FlipPhase.set_ptr(&d->LFO1FlipPhase);
556     eLFO1Sync.set_ptr(&d->LFO1Sync);
557     eEG2PreAttack.set_ptr(&d->EG2PreAttack);
558     eEG2Attack.set_ptr(&d->EG2Attack);
559     eEG2Decay1.set_ptr(&d->EG2Decay1);
560     eEG2Decay2.set_ptr(&d->EG2Decay2);
561     eEG2InfiniteSustain.set_ptr(&d->EG2InfiniteSustain);
562     eEG2Sustain.set_ptr(&d->EG2Sustain);
563     eEG2Release.set_ptr(&d->EG2Release);
564     eEG2Controller.set_ptr(&d->EG2Controller);
565     eEG2ControllerInvert.set_ptr(&d->EG2ControllerInvert);
566     eEG2ControllerAttackInfluence.set_ptr(&d->EG2ControllerAttackInfluence);
567     eEG2ControllerDecayInfluence.set_ptr(&d->EG2ControllerDecayInfluence);
568     eEG2ControllerReleaseInfluence.set_ptr(&d->EG2ControllerReleaseInfluence);
569     eLFO2Frequency.set_ptr(&d->LFO2Frequency);
570     eLFO2InternalDepth.set_ptr(&d->LFO2InternalDepth);
571     eLFO2ControlDepth.set_ptr(&d->LFO2ControlDepth);
572     eLFO2Controller.set_ptr(&d->LFO2Controller);
573     eLFO2FlipPhase.set_ptr(&d->LFO2FlipPhase);
574     eLFO2Sync.set_ptr(&d->LFO2Sync);
575     eEG3Attack.set_ptr(&d->EG3Attack);
576     eEG3Depth.set_ptr(&d->EG3Depth);
577     eLFO3Frequency.set_ptr(&d->LFO3Frequency);
578     eLFO3InternalDepth.set_ptr(&d->LFO3InternalDepth);
579     eLFO3ControlDepth.set_ptr(&d->LFO3ControlDepth);
580     eLFO3Controller.set_ptr(&d->LFO3Controller);
581     eLFO3Sync.set_ptr(&d->LFO3Sync);
582     eVCFEnabled.set_ptr(&d->VCFEnabled);
583     eVCFType.set_ptr(&d->VCFType);
584     eVCFCutoffController.set_ptr(&d->VCFCutoffController);
585     eVCFCutoffControllerInvert.set_ptr(&d->VCFCutoffControllerInvert);
586     eVCFCutoff.set_ptr(&d->VCFCutoff);
587     eVCFVelocityCurve.set_ptr(&d->VCFVelocityCurve);
588     eVCFVelocityScale.set_ptr(&d->VCFVelocityScale);
589     eVCFVelocityDynamicRange.set_ptr(&d->VCFVelocityDynamicRange);
590     eVCFResonance.set_ptr(&d->VCFResonance);
591     eVCFResonanceDynamic.set_ptr(&d->VCFResonanceDynamic);
592     eVCFResonanceController.set_ptr(&d->VCFResonanceController);
593     eVCFKeyboardTracking.set_ptr(&d->VCFKeyboardTracking);
594     eVCFKeyboardTrackingBreakpoint.set_ptr(&d->VCFKeyboardTrackingBreakpoint);
595     eVelocityResponseCurve.set_ptr(&d->VelocityResponseCurve);
596     eVelocityResponseDepth.set_ptr(&d->VelocityResponseDepth);
597     eVelocityResponseCurveScaling.set_ptr(&d->VelocityResponseCurveScaling);
598     eReleaseVelocityResponseCurve.set_ptr(&d->ReleaseVelocityResponseCurve);
599     eReleaseVelocityResponseDepth.set_ptr(&d->ReleaseVelocityResponseDepth);
600     eReleaseTriggerDecay.set_ptr(&d->ReleaseTriggerDecay);
601 persson 1261
602     eCrossfade_in_start.set_ptr(0);
603     eCrossfade_in_end.set_ptr(0);
604     eCrossfade_out_start.set_ptr(0);
605     eCrossfade_out_end.set_ptr(0);
606 schoenebeck 1225 eCrossfade_in_start.set_ptr(&d->Crossfade.in_start);
607     eCrossfade_in_end.set_ptr(&d->Crossfade.in_end);
608     eCrossfade_out_start.set_ptr(&d->Crossfade.out_start);
609     eCrossfade_out_end.set_ptr(&d->Crossfade.out_end);
610 persson 1261
611 schoenebeck 1225 ePitchTrack.set_ptr(&d->PitchTrack);
612     eDimensionBypass.set_ptr(&d->DimensionBypass);
613     ePan.set_ptr(&d->Pan);
614     eSelfMask.set_ptr(&d->SelfMask);
615     eAttenuationController.set_ptr(&d->AttenuationController);
616     eInvertAttenuationController.set_ptr(&d->InvertAttenuationController);
617     eAttenuationControllerThreshold.set_ptr(&d->AttenuationControllerThreshold);
618     eChannelOffset.set_ptr(&d->ChannelOffset);
619     eSustainDefeat.set_ptr(&d->SustainDefeat);
620     eMSDecode.set_ptr(&d->MSDecode);
621     eSampleStartOffset.set_ptr(&d->SampleStartOffset);
622     eUnityNote.set_ptr(&d->UnityNote);
623     eFineTune.set_ptr(&d->FineTune);
624     eGain.set_ptr(&d->Gain);
625     eGainPlus6.set_ptr(&d->Gain);
626    
627     eSampleLoopEnabled.set_active(d->SampleLoops);
628     updateLoopElements();
629    
630     VCFEnabled_toggled();
631     }
632    
633     void DimRegionEdit::VCFEnabled_toggled()
634     {
635     bool sensitive = eVCFEnabled.get_active();
636     eVCFType.set_sensitive(sensitive);
637     eVCFCutoffController.set_sensitive(sensitive);
638     eVCFVelocityCurve.set_sensitive(sensitive);
639     eVCFVelocityScale.set_sensitive(sensitive);
640     eVCFVelocityDynamicRange.set_sensitive(sensitive);
641     eVCFResonance.set_sensitive(sensitive);
642     eVCFResonanceController.set_sensitive(sensitive);
643     eVCFKeyboardTracking.set_sensitive(sensitive);
644     eVCFKeyboardTrackingBreakpoint.set_sensitive(sensitive);
645     eEG2PreAttack.set_sensitive(sensitive);
646     eEG2Attack.set_sensitive(sensitive);
647     eEG2Decay1.set_sensitive(sensitive);
648     eEG2InfiniteSustain.set_sensitive(sensitive);
649     eEG2Sustain.set_sensitive(sensitive);
650     eEG2Release.set_sensitive(sensitive);
651     eEG2Controller.set_sensitive(sensitive);
652     eEG2ControllerAttackInfluence.set_sensitive(sensitive);
653     eEG2ControllerDecayInfluence.set_sensitive(sensitive);
654     eEG2ControllerReleaseInfluence.set_sensitive(sensitive);
655     eLFO2Frequency.set_sensitive(sensitive);
656     eLFO2InternalDepth.set_sensitive(sensitive);
657     eLFO2ControlDepth.set_sensitive(sensitive);
658     eLFO2Controller.set_sensitive(sensitive);
659     eLFO2FlipPhase.set_sensitive(sensitive);
660     eLFO2Sync.set_sensitive(sensitive);
661     if (sensitive) {
662     VCFCutoffController_changed();
663     VCFResonanceController_changed();
664     EG2InfiniteSustain_toggled();
665     EG2Controller_changed();
666     LFO2Controller_changed();
667     } else {
668     eVCFCutoffControllerInvert.set_sensitive(false);
669     eVCFCutoff.set_sensitive(false);
670     eVCFResonanceDynamic.set_sensitive(false);
671     eVCFResonance.set_sensitive(false);
672     eEG2Decay2.set_sensitive(false);
673     eEG2ControllerInvert.set_sensitive(false);
674     eLFO2InternalDepth.set_sensitive(false);
675     eLFO2ControlDepth.set_sensitive(false);
676     }
677     }
678    
679     void DimRegionEdit::VCFCutoffController_changed()
680     {
681     int rowno = eVCFCutoffController.get_active_row_number();
682     bool hasController = rowno != 0 && rowno != 1;
683    
684     eVCFCutoffControllerInvert.set_sensitive(hasController);
685     eVCFCutoff.set_sensitive(!hasController);
686     eVCFResonanceDynamic.set_sensitive(!hasController);
687     eVCFVelocityScale.label.set_text(hasController ? "Minimum cutoff:" :
688     "Velocity scale:");
689     }
690    
691     void DimRegionEdit::VCFResonanceController_changed()
692     {
693     bool hasController = eVCFResonanceController.get_active_row_number() != 0;
694     eVCFResonance.set_sensitive(!hasController);
695     }
696    
697     void DimRegionEdit::EG1InfiniteSustain_toggled()
698     {
699     bool infSus = eEG1InfiniteSustain.get_active();
700     eEG1Decay2.set_sensitive(!infSus);
701     }
702    
703     void DimRegionEdit::EG2InfiniteSustain_toggled()
704     {
705     bool infSus = eEG2InfiniteSustain.get_active();
706     eEG2Decay2.set_sensitive(!infSus);
707     }
708    
709     void DimRegionEdit::EG1Controller_changed()
710     {
711     bool hasController = eEG1Controller.get_active_row_number() != 0;
712     eEG1ControllerInvert.set_sensitive(hasController);
713     }
714    
715     void DimRegionEdit::EG2Controller_changed()
716     {
717     bool hasController = eEG2Controller.get_active_row_number() != 0;
718     eEG2ControllerInvert.set_sensitive(hasController);
719     }
720    
721     void DimRegionEdit::AttenuationController_changed()
722     {
723     bool hasController = eAttenuationController.get_active_row_number() != 0;
724     eInvertAttenuationController.set_sensitive(hasController);
725     eAttenuationControllerThreshold.set_sensitive(hasController);
726     eCrossfade_in_start.set_sensitive(hasController);
727     eCrossfade_in_end.set_sensitive(hasController);
728     eCrossfade_out_start.set_sensitive(hasController);
729     eCrossfade_out_end.set_sensitive(hasController);
730     }
731    
732     void DimRegionEdit::LFO1Controller_changed()
733     {
734     int rowno = eLFO1Controller.get_active_row_number();
735     eLFO1ControlDepth.set_sensitive(rowno != 0);
736     eLFO1InternalDepth.set_sensitive(rowno != 1 && rowno != 2);
737     }
738    
739     void DimRegionEdit::LFO2Controller_changed()
740     {
741     int rowno = eLFO2Controller.get_active_row_number();
742     eLFO2ControlDepth.set_sensitive(rowno != 0);
743     eLFO2InternalDepth.set_sensitive(rowno != 1 && rowno != 2);
744     }
745    
746     void DimRegionEdit::LFO3Controller_changed()
747     {
748     int rowno = eLFO3Controller.get_active_row_number();
749     eLFO3ControlDepth.set_sensitive(rowno != 0);
750     eLFO3InternalDepth.set_sensitive(rowno != 1 && rowno != 2);
751     }
752    
753     void DimRegionEdit::crossfade1_changed()
754     {
755     double c1 = eCrossfade_in_start.get_value();
756     double c2 = eCrossfade_in_end.get_value();
757     if (c1 > c2) eCrossfade_in_end.set_value(c1);
758     }
759    
760     void DimRegionEdit::crossfade2_changed()
761     {
762     double c1 = eCrossfade_in_start.get_value();
763     double c2 = eCrossfade_in_end.get_value();
764     double c3 = eCrossfade_out_start.get_value();
765    
766     if (c2 < c1) eCrossfade_in_start.set_value(c2);
767     if (c2 > c3) eCrossfade_out_start.set_value(c2);
768     }
769    
770     void DimRegionEdit::crossfade3_changed()
771     {
772     double c2 = eCrossfade_in_end.get_value();
773     double c3 = eCrossfade_out_start.get_value();
774     double c4 = eCrossfade_out_end.get_value();
775    
776     if (c3 < c2) eCrossfade_in_end.set_value(c3);
777     if (c3 > c4) eCrossfade_out_end.set_value(c3);
778     }
779    
780     void DimRegionEdit::crossfade4_changed()
781     {
782     double c3 = eCrossfade_out_start.get_value();
783     double c4 = eCrossfade_out_end.get_value();
784    
785     if (c4 < c3) eCrossfade_out_start.set_value(c4);
786     }
787    
788     void DimRegionEdit::loop_enabled_toggled()
789     {
790     const bool active = eSampleLoopEnabled.get_active();
791     if (active) {
792     // create a new sample loop in case there is none yet
793     if (!dimregion->SampleLoops) {
794     DLS::sample_loop_t loop;
795     loop.LoopType = gig::loop_type_normal;
796     // loop the whole sample by default
797     loop.LoopStart = 0;
798     loop.LoopLength =
799     (dimregion->pSample) ? dimregion->pSample->GetSize() : 0;
800 schoenebeck 1322 dimreg_to_be_changed_signal.emit(dimregion);
801 schoenebeck 1225 dimregion->AddSampleLoop(&loop);
802 schoenebeck 1322 dimreg_changed_signal.emit(dimregion);
803 schoenebeck 1225 }
804     } else {
805 persson 1261 if (dimregion->SampleLoops) {
806 schoenebeck 1322 dimreg_to_be_changed_signal.emit(dimregion);
807 persson 1261 // delete ALL existing sample loops
808     while (dimregion->SampleLoops) {
809     dimregion->DeleteSampleLoop(&dimregion->pSampleLoops[0]);
810     }
811 schoenebeck 1322 dimreg_changed_signal.emit(dimregion);
812 persson 1261 }
813 schoenebeck 1225 }
814     updateLoopElements();
815     }
816    
817     void DimRegionEdit::updateLoopElements()
818     {
819     const bool active = eSampleLoopEnabled.get_active();
820     eSampleLoopStart.set_sensitive(active);
821     eSampleLoopLength.set_sensitive(active);
822     eSampleLoopType.set_sensitive(active);
823 persson 1303 eSampleLoopInfinite.set_sensitive(active && dimregion && dimregion->pSample);
824 persson 1261 eSampleLoopStart.set_ptr(0);
825     eSampleLoopLength.set_ptr(0);
826     eSampleLoopPlayCount.set_ptr(0);
827    
828 schoenebeck 1225 if (dimregion && dimregion->SampleLoops) {
829     eSampleLoopStart.set_ptr(&dimregion->pSampleLoops[0].LoopStart);
830     eSampleLoopLength.set_ptr(&dimregion->pSampleLoops[0].LoopLength);
831     eSampleLoopType.set_ptr(&dimregion->pSampleLoops[0].LoopType);
832     eSampleLoopInfinite.set_active(
833     dimregion->pSample && !dimregion->pSample->LoopPlayCount
834     );
835 persson 1261 // updated enabled state of loop play count widget
836     loop_infinite_toggled();
837    
838     eSampleLoopPlayCount.set_ptr(
839     (dimregion->pSample) ? &dimregion->pSample->LoopPlayCount : 0
840     );
841    
842 schoenebeck 1225 // sample loop shall never be longer than the actual sample size
843     eSampleLoopStart.set_upper(
844     (dimregion->pSample)
845 persson 1265 ? dimregion->pSample->SamplesTotal -
846 schoenebeck 1225 dimregion->pSampleLoops[0].LoopLength
847     : 0
848     );
849     eSampleLoopLength.set_upper(
850     (dimregion->pSample)
851 persson 1265 ? dimregion->pSample->SamplesTotal -
852 schoenebeck 1225 dimregion->pSampleLoops[0].LoopStart
853     : 0
854     );
855     } else { // no sample loop(s)
856 persson 1261 eSampleLoopType.set_ptr(0);
857     // updated enabled state of loop play count widget
858     loop_infinite_toggled();
859 schoenebeck 1225 }
860     }
861    
862     void DimRegionEdit::loop_infinite_toggled() {
863     eSampleLoopPlayCount.set_sensitive(
864 persson 1303 dimregion && dimregion->pSample &&
865 schoenebeck 1225 !eSampleLoopInfinite.get_active() &&
866     eSampleLoopEnabled.get_active()
867     );
868     if (eSampleLoopInfinite.get_active())
869     eSampleLoopPlayCount.set_value(0);
870     else if (!eSampleLoopPlayCount.get_value())
871     eSampleLoopPlayCount.set_value(1);
872     }
873 persson 1265
874     bool DimRegionEdit::set_sample(gig::Sample* sample)
875     {
876     if (dimregion) {
877 schoenebeck 1322 //TODO: we should better move the code from MainWindow::on_sample_label_drop_drag_data_received() here
878    
879     // currently commented because we're sending a similar signal in MainWindow::on_sample_label_drop_drag_data_received()
880     //dimreg_to_be_changed_signal.emit(dimregion);
881    
882     gig::Sample* oldref = dimregion->pSample;
883 persson 1265 dimregion->pSample = sample;
884    
885     // copy sample information from Sample to DimensionRegion
886    
887     dimregion->UnityNote = sample->MIDIUnityNote;
888     dimregion->FineTune = sample->FineTune;
889    
890     int loops = sample->Loops ? 1 : 0;
891     while (dimregion->SampleLoops > loops) {
892     dimregion->DeleteSampleLoop(&dimregion->pSampleLoops[0]);
893     }
894     while (dimregion->SampleLoops < sample->Loops) {
895     DLS::sample_loop_t loop;
896     dimregion->AddSampleLoop(&loop);
897     }
898     if (loops) {
899     dimregion->pSampleLoops[0].Size = sizeof(DLS::sample_loop_t);
900     dimregion->pSampleLoops[0].LoopType = sample->LoopType;
901     dimregion->pSampleLoops[0].LoopStart = sample->LoopStart;
902     dimregion->pSampleLoops[0].LoopLength = sample->LoopEnd - sample->LoopStart + 1;
903     }
904    
905     // update ui
906     wSample->set_text(dimregion->pSample->pInfo->Name);
907     eUnityNote.set_ptr(&dimregion->UnityNote);
908     eFineTune.set_ptr(&dimregion->FineTune);
909     eSampleLoopEnabled.set_active(dimregion->SampleLoops);
910     updateLoopElements();
911    
912 schoenebeck 1322 sample_ref_changed_signal.emit(oldref, sample);
913     // currently commented because we're sending a similar signal in MainWindow::on_sample_label_drop_drag_data_received()
914     //dimreg_changed_signal.emit(dimregion);
915 persson 1265 return true;
916     }
917     return false;
918     }
919 schoenebeck 1322
920     sigc::signal<void, gig::DimensionRegion*> DimRegionEdit::signal_dimreg_to_be_changed() {
921     return dimreg_to_be_changed_signal;
922     }
923    
924     sigc::signal<void, gig::DimensionRegion*> DimRegionEdit::signal_dimreg_changed() {
925     return dimreg_changed_signal;
926     }
927    
928     sigc::signal<void, gig::Sample*/*old*/, gig::Sample*/*new*/> DimRegionEdit::signal_sample_ref_changed() {
929     return sample_ref_changed_signal;
930     }

  ViewVC Help
Powered by ViewVC