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

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

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1118 by schoenebeck, Sat Mar 24 13:48:16 2007 UTC revision 1159 by persson, Fri Apr 13 17:57:26 2007 UTC
# Line 19  Line 19 
19    
20  #include "dimregionedit.h"  #include "dimregionedit.h"
21    
22  bool update_gui;  #include <libintl.h>
23    #define _(String) gettext(String)
 namespace {  
     uint8_t& access_UnityNote(gig::DimensionRegion* dimreg)  
     {  
         return dimreg->UnityNote;  
     }  
     int16_t& access_FineTune(gig::DimensionRegion* dimreg)  
     {  
         return dimreg->FineTune;  
     }  
     uint32_t& access_SampleLoops(gig::DimensionRegion* dimreg)  
     {  
         return dimreg->SampleLoops;  
     }  
     uint8_t& access_Crossfade_in_start(gig::DimensionRegion* dimreg)  
     {  
         return dimreg->Crossfade.in_start;  
     }  
     uint8_t& access_Crossfade_in_end(gig::DimensionRegion* dimreg)  
     {  
         return dimreg->Crossfade.in_end;  
     }  
     uint8_t& access_Crossfade_out_start(gig::DimensionRegion* dimreg)  
     {  
         return dimreg->Crossfade.out_start;  
     }  
     uint8_t& access_Crossfade_out_end(gig::DimensionRegion* dimreg)  
     {  
         return dimreg->Crossfade.out_end;  
     }  
 }  
24    
25  DimRegionEdit::DimRegionEdit() :  DimRegionEdit::DimRegionEdit() :
26      eEG1PreAttack("PreAttack", &gig::DimensionRegion::EG1PreAttack, 0, 100, 2),      eEG1PreAttack("Pre-attack", 0, 100, 2),
27      eEG1Attack("Attack", &gig::DimensionRegion::EG1Attack, 0, 60, 3),      eEG1Attack("Attack", 0, 60, 3),
28      eEG1Decay1("Decay1", &gig::DimensionRegion::EG1Decay1, 0.005, 60, 3),      eEG1Decay1("Decay 1", 0.005, 60, 3),
29      eEG1Decay2("Decay2", &gig::DimensionRegion::EG1Decay2, 0, 60, 3),      eEG1Decay2("Decay 2", 0, 60, 3),
30      eEG1InfiniteSustain("InfiniteSustain",      eEG1InfiniteSustain("Infinite sustain"),
31                          &gig::DimensionRegion::EG1InfiniteSustain),      eEG1Sustain("Sustain", 0, 100, 2),
32      eEG1Sustain("Sustain", &gig::DimensionRegion::EG1Sustain, 0, 100, 2),      eEG1Release("Release", 0, 60, 3),
33      eEG1Release("Release", &gig::DimensionRegion::EG1Release, 0, 60, 3),      eEG1Hold("Hold"),
34      eEG1Hold("Hold", &gig::DimensionRegion::EG1Hold),      eEG1Controller("Controller"),
35      eEG1Controller("Controller", &gig::DimensionRegion::EG1Controller),      eEG1ControllerInvert("Controller invert"),
36      eEG1ControllerInvert("ControllerInvert",      eEG1ControllerAttackInfluence("Controller attack influence", 0, 3),
37                           &gig::DimensionRegion::EG1ControllerInvert),      eEG1ControllerDecayInfluence("Controller decay influence", 0, 3),
38      eEG1ControllerAttackInfluence("ControllerAttackInfluence",      eEG1ControllerReleaseInfluence("Controller release influence", 0, 3),
39                                    &gig::DimensionRegion::EG1ControllerAttackInfluence,      eLFO1Frequency("Frequency", 0.1, 10, 2),
40                                    0, 3),      eLFO1InternalDepth("Internal depth", 0, 1200),
41      eEG1ControllerDecayInfluence("ControllerDecayInfluence",      eLFO1ControlDepth("Control depth", 0, 1200),
42                                   &gig::DimensionRegion::EG1ControllerDecayInfluence,      eLFO1Controller("Controller"),
43                                   0, 3),      eLFO1FlipPhase("Flip phase"),
44      eEG1ControllerReleaseInfluence("ControllerReleaseInfluence",      eLFO1Sync("Sync"),
45                                     &gig::DimensionRegion::EG1ControllerReleaseInfluence,      eEG2PreAttack("Pre-attack", 0, 100, 2),
46                                     0, 3),      eEG2Attack("Attack", 0, 60, 3),
47      eLFO1Frequency("Frequency", &gig::DimensionRegion::LFO1Frequency,      eEG2Decay1("Decay 1", 0.005, 60, 3),
48                     0.1, 10, 2),      eEG2Decay2("Decay 2", 0, 60, 3),
49      eLFO1InternalDepth("InternalDepth",      eEG2InfiniteSustain("Infinite sustain"),
50                         &gig::DimensionRegion::LFO1InternalDepth, 0, 1200),      eEG2Sustain("Sustain", 0, 100, 2),
51      eLFO1ControlDepth("ControlDepth", &gig::DimensionRegion::LFO1ControlDepth,      eEG2Release("Release", 0, 60, 3),
52                        0, 1200),      eEG2Controller("Controller"),
53      eLFO1Controller("Controller", &gig::DimensionRegion::LFO1Controller),      eEG2ControllerInvert("Controller invert"),
54      eLFO1FlipPhase("FlipPhase", &gig::DimensionRegion::LFO1FlipPhase),      eEG2ControllerAttackInfluence("Controller attack influence", 0, 3),
55      eLFO1Sync("Sync", &gig::DimensionRegion::LFO1Sync),      eEG2ControllerDecayInfluence("Controller decay influence", 0, 3),
56      eEG2PreAttack("PreAttack", &gig::DimensionRegion::EG2PreAttack, 0, 100, 2),      eEG2ControllerReleaseInfluence("Controller release influence", 0, 3),
57      eEG2Attack("Attack", &gig::DimensionRegion::EG2Attack, 0, 60, 3),      eLFO2Frequency("Frequency", 0.1, 10, 2),
58      eEG2Decay1("Decay1", &gig::DimensionRegion::EG2Decay1, 0.005, 60, 3),      eLFO2InternalDepth("Internal depth", 0, 1200),
59      eEG2Decay2("Decay2", &gig::DimensionRegion::EG2Decay2, 0, 60, 3),      eLFO2ControlDepth("Control depth", 0, 1200),
60      eEG2InfiniteSustain("InfiniteSustain",      eLFO2Controller("Controller"),
61                          &gig::DimensionRegion::EG2InfiniteSustain),      eLFO2FlipPhase("Flip phase"),
62      eEG2Sustain("Sustain", &gig::DimensionRegion::EG2Sustain, 0, 100, 2),      eLFO2Sync("Sync"),
63      eEG2Release("Release", &gig::DimensionRegion::EG2Release, 0, 60, 3),      eEG3Attack("Attack", 0, 10, 3),
64      eEG2Controller("Controller", &gig::DimensionRegion::EG2Controller),      eEG3Depth("Depth", -1200, 1200),
65      eEG2ControllerInvert("ControllerInvert",      eLFO3Frequency("Frequency", 0.1, 10, 2),
66                           &gig::DimensionRegion::EG2ControllerInvert),      eLFO3InternalDepth("Internal depth", 0, 1200),
67      eEG2ControllerAttackInfluence("ControllerAttackInfluence",      eLFO3ControlDepth("Control depth", 0, 1200),
68                                    &gig::DimensionRegion::EG2ControllerAttackInfluence,      eLFO3Controller("Controller"),
69                                    0, 3),      eLFO3Sync("Sync"),
70      eEG2ControllerDecayInfluence("ControllerDecayInfluence",      eVCFEnabled("Enabled"),
71                                   &gig::DimensionRegion::EG2ControllerDecayInfluence,      eVCFType("Type"),
72                                   0, 3),      eVCFCutoffController("Cutoff controller"),
73      eEG2ControllerReleaseInfluence("ControllerReleaseInfluence",      eVCFCutoffControllerInvert("Cutoff controller invert"),
74                                     &gig::DimensionRegion::EG2ControllerReleaseInfluence,      eVCFCutoff("Cutoff"),
75                                     0, 3),      eVCFVelocityCurve("Velocity curve"),
76      eLFO2Frequency("Frequency", &gig::DimensionRegion::LFO2Frequency,      eVCFVelocityScale("Velocity scale"),
77                     0.1, 10, 2),      eVCFVelocityDynamicRange("Velocity dynamic range", 0, 4),
78      eLFO2InternalDepth("InternalDepth",      eVCFResonance("Resonance"),
79                         &gig::DimensionRegion::LFO2InternalDepth, 0, 1200),      eVCFResonanceDynamic("Resonance dynamic"),
80      eLFO2ControlDepth("ControlDepth",      eVCFResonanceController("Resonance controller"),
81                        &gig::DimensionRegion::LFO2ControlDepth, 0, 1200),      eVCFKeyboardTracking("Keyboard tracking"),
82      eLFO2Controller("Controller", &gig::DimensionRegion::LFO2Controller),      eVCFKeyboardTrackingBreakpoint("Keyboard tracking breakpoint"),
83      eLFO2FlipPhase("FlipPhase", &gig::DimensionRegion::LFO2FlipPhase),      eVelocityResponseCurve("Velocity response curve"),
84      eLFO2Sync("Sync", &gig::DimensionRegion::LFO2Sync),      eVelocityResponseDepth("Velocity response depth", 0, 4),
85      eEG3Attack("Attack", &gig::DimensionRegion::EG3Attack, 0, 10, 3),      eVelocityResponseCurveScaling("Velocity response curve scaling"),
86      eEG3Depth("Depth", &gig::DimensionRegion::EG3Depth, -1200, 1200),      eReleaseVelocityResponseCurve("Release velocity response curve"),
87      eLFO3Frequency("Frequency", &gig::DimensionRegion::LFO3Frequency,      eReleaseVelocityResponseDepth("Release velocity response depth", 0, 4),
88                     0.1, 10, 2),      eReleaseTriggerDecay("Release trigger decay", 0, 8),
89      eLFO3InternalDepth("InternalDepth",      eCrossfade_in_start("Crossfade-in start"),
90                         &gig::DimensionRegion::LFO3InternalDepth, 0, 1200),      eCrossfade_in_end("Crossfade-in end"),
91      eLFO3ControlDepth("ControlDepth", &gig::DimensionRegion::LFO3ControlDepth,      eCrossfade_out_start("Crossfade-out start"),
92                        0, 1200),      eCrossfade_out_end("Crossfade-out end"),
93      eLFO3Controller("Controller", &gig::DimensionRegion::LFO3Controller),      ePitchTrack("Pitch track"),
94      eLFO3Sync("Sync", &gig::DimensionRegion::LFO3Sync),      eDimensionBypass("Dimension bypass"),
95      eVCFEnabled("Enabled", &gig::DimensionRegion::VCFEnabled),      ePan("Pan", -64, 63),
96      eVCFType("Type", &gig::DimensionRegion::VCFType),      eSelfMask("Self mask"),
97      eVCFCutoffController("CutoffController",      eAttenuationController("Attenuation controller"),
98                           &gig::DimensionRegion::VCFCutoffController),      eInvertAttenuationController("Invert attenuation controller"),
99      eVCFCutoffControllerInvert("CutoffControllerInvert",      eAttenuationControllerThreshold("Attenuation controller threshold"),
100                                 &gig::DimensionRegion::VCFCutoffControllerInvert),      eChannelOffset("Channel offset", 0, 9),
101      eVCFCutoff("Cutoff", &gig::DimensionRegion::VCFCutoff),      eSustainDefeat("Sustain defeat"),
102      eVCFVelocityCurve("VelocityCurve", &gig::DimensionRegion::VCFVelocityCurve),      eMSDecode("MS decode"),
103      eVCFVelocityScale("VelocityScale", &gig::DimensionRegion::VCFVelocityScale),      eSampleStartOffset("Sample start offset", 0, 2000),
104      eVCFVelocityDynamicRange("VelocityDynamicRange",      eUnityNote("Unity note"),
105                               &gig::DimensionRegion::VCFVelocityDynamicRange,      eFineTune("Fine tune", -49, 50),
106                               0, 4),      eGain("Gain", -96, 0, 2, -655360),
107      eVCFResonance("Resonance", &gig::DimensionRegion::VCFResonance),      eGainPlus6("Gain +6dB", eGain, 6 * -655360),
108      eVCFResonanceDynamic("ResonanceDynamic",      eSampleLoopEnabled("Enabled"),
109                           &gig::DimensionRegion::VCFResonanceDynamic),      eSampleLoopStart("Loop start positon"),
110      eVCFResonanceController("ResonanceController",      eSampleLoopLength("Loop size"),
111                              &gig::DimensionRegion::VCFResonanceController),      eSampleLoopType("Loop type"),
112      eVCFKeyboardTracking("KeyboardTracking",      eSampleLoopInfinite("Infinite loop"),
113                           &gig::DimensionRegion::VCFKeyboardTracking),      eSampleLoopPlayCount("Playback count")
     eVCFKeyboardTrackingBreakpoint("KeyboardTrackingBreakpoint",  
                                    &gig::DimensionRegion::VCFKeyboardTrackingBreakpoint),  
     eVelocityResponseCurve("VelocityResponseCurve",  
                            &gig::DimensionRegion::VelocityResponseCurve),  
     eVelocityResponseDepth("VelocityResponseDepth",  
                            &gig::DimensionRegion::VelocityResponseDepth, 0, 4),  
     eVelocityResponseCurveScaling("VelocityResponseCurveScaling",  
                                   &gig::DimensionRegion::VelocityResponseCurveScaling),  
     eReleaseVelocityResponseCurve("ReleaseVelocityResponseCurve",  
                                   &gig::DimensionRegion::ReleaseVelocityResponseCurve),  
     eReleaseVelocityResponseDepth("ReleaseVelocityResponseDepth",  
                                   &gig::DimensionRegion::ReleaseVelocityResponseDepth,  
                                   0, 4),  
     eReleaseTriggerDecay("ReleaseTriggerDecay",  
                          &gig::DimensionRegion::ReleaseTriggerDecay, 0, 8),  
     eCrossfade_in_start("Crossfade.in_start", &access_Crossfade_in_start),  
     eCrossfade_in_end("Crossfade.in_end", &access_Crossfade_in_end),  
     eCrossfade_out_start("Crossfade.out_start", &access_Crossfade_out_start),  
     eCrossfade_out_end("Crossfade.out_end", &access_Crossfade_out_end),  
     ePitchTrack("PitchTrack", &gig::DimensionRegion::PitchTrack),  
     eDimensionBypass("DimensionBypass", &gig::DimensionRegion::DimensionBypass),  
     ePan("Pan", &gig::DimensionRegion::Pan, -64, 63),  
     eSelfMask("SelfMask", &gig::DimensionRegion::SelfMask),  
     eAttenuationController("AttenuationController",  
                            &gig::DimensionRegion::AttenuationController),  
     eInvertAttenuationController("InvertAttenuationController",  
                                  &gig::DimensionRegion::InvertAttenuationController),  
     eAttenuationControllerThreshold("AttenuationControllerThreshold",  
                                     &gig::DimensionRegion::AttenuationControllerThreshold),  
     eChannelOffset("ChannelOffset", &gig::DimensionRegion::ChannelOffset, 0, 9),  
     eSustainDefeat("SustainDefeat", &gig::DimensionRegion::SustainDefeat),  
     eMSDecode("MSDecode", &gig::DimensionRegion::MSDecode),  
     eSampleStartOffset("SampleStartOffset",  
                        &gig::DimensionRegion::SampleStartOffset, 0, 2000),  
     eUnityNote("UnityNote", &access_UnityNote),  
     eFineTune("FineTune", &access_FineTune, -49, 50),  
     eGain("Gain", -96, 0, 2),  
     eGainPlus6("Gain +6dB", eGain),  
     eSampleLoops("SampleLoops", &access_SampleLoops, 0, 1)  
114  {  {
115      for (int i = 0 ; i < 5 ; i++) {      for (int i = 0 ; i < 7 ; i++) {
116          table[i] = new Gtk::Table(3, 1);          table[i] = new Gtk::Table(3, 1);
117          table[i]->set_col_spacings(5);          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;      pageno = 0;
156      rowno = 0;      rowno = 0;
157      firstRowInBlock = 0;      firstRowInBlock = 0;
158    
159        addHeader(_("Mandatory Settings"));
160      addString("Sample", lSample, wSample);      addString("Sample", lSample, wSample);
161      //TODO: the following would break drag&drop:   wSample->property_editable().set_value(false);  or this:    wSample->set_editable(false);      //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");      tooltips.set_tip(*wSample, _("Drop a sample here"));
163      addHeader("EG1");      addProp(eUnityNote);
164        addHeader(_("Optional Settings"));
165        addProp(eSampleStartOffset);
166        addProp(ePan);
167        addProp(eChannelOffset);
168        addHeader("Loops");
169        addProp(eSampleLoopEnabled);
170        addProp(eSampleLoopStart);
171        addProp(eSampleLoopLength);
172        {
173            char* choices[] = { "normal", "bidirectional", "backward", 0 };
174            static const uint32_t values[] = {
175                gig::loop_type_normal,
176                gig::loop_type_bidirectional,
177                gig::loop_type_backward
178            };
179            eSampleLoopType.set_choices(choices, values);
180        }
181        addProp(eSampleLoopType);
182        addProp(eSampleLoopInfinite);
183        addProp(eSampleLoopPlayCount);
184        addHeader("Crossfade");
185        addProp(eCrossfade_in_start);
186        addProp(eCrossfade_in_end);
187        addProp(eCrossfade_out_start);
188        addProp(eCrossfade_out_end);
189    
190        nextPage();
191    
192        addHeader(_("General Amplitude Settings"));
193        addProp(eGain);
194        addProp(eGainPlus6);
195        addProp(eAttenuationController);
196        addProp(eInvertAttenuationController);
197        addProp(eAttenuationControllerThreshold);
198        addHeader(_("Amplitude Envelope (EG1)"));
199      addProp(eEG1PreAttack);      addProp(eEG1PreAttack);
200      addProp(eEG1Attack);      addProp(eEG1Attack);
201      addProp(eEG1Decay1);      addProp(eEG1Decay1);
# Line 207  DimRegionEdit::DimRegionEdit() : Line 209  DimRegionEdit::DimRegionEdit() :
209      addProp(eEG1ControllerAttackInfluence);      addProp(eEG1ControllerAttackInfluence);
210      addProp(eEG1ControllerDecayInfluence);      addProp(eEG1ControllerDecayInfluence);
211      addProp(eEG1ControllerReleaseInfluence);      addProp(eEG1ControllerReleaseInfluence);
212      addHeader("LFO1");  
213        nextPage();
214    
215        addHeader(_("Amplitude Oscillator (LFO1)"));
216      addProp(eLFO1Frequency);      addProp(eLFO1Frequency);
217      addProp(eLFO1InternalDepth);      addProp(eLFO1InternalDepth);
218      addProp(eLFO1ControlDepth);      addProp(eLFO1ControlDepth);
# Line 228  DimRegionEdit::DimRegionEdit() : Line 233  DimRegionEdit::DimRegionEdit() :
233      addProp(eLFO1Sync);      addProp(eLFO1Sync);
234    
235      nextPage();      nextPage();
     addHeader("EG2");  
     addProp(eEG2PreAttack);  
     addProp(eEG2Attack);  
     addProp(eEG2Decay1);  
     addProp(eEG2Decay2);  
     addProp(eEG2InfiniteSustain);  
     addProp(eEG2Sustain);  
     addProp(eEG2Release);  
     addProp(eEG2Controller);  
     addProp(eEG2ControllerInvert);  
     addProp(eEG2ControllerAttackInfluence);  
     addProp(eEG2ControllerDecayInfluence);  
     addProp(eEG2ControllerReleaseInfluence);  
     addHeader("LFO2");  
     addProp(eLFO2Frequency);  
     addProp(eLFO2InternalDepth);  
     addProp(eLFO2ControlDepth);  
     {  
         char* choices[] = { "internal", "modwheel", "foot",  
                             "internal+modwheel", "internal+foot", 0 };  
         static const gig::lfo2_ctrl_t values[] = {  
             gig::lfo2_ctrl_internal,  
             gig::lfo2_ctrl_modwheel,  
             gig::lfo2_ctrl_foot,  
             gig::lfo2_ctrl_internal_modwheel,  
             gig::lfo2_ctrl_internal_foot  
         };  
         eLFO2Controller.set_choices(choices, values);  
     }  
     addProp(eLFO2Controller);  
     addProp(eLFO2FlipPhase);  
     addProp(eLFO2Sync);  
   
     nextPage();  
236    
237      addHeader("EG3");      addHeader(_("General Filter Settings"));
     addProp(eEG3Attack);  
     addProp(eEG3Depth);  
     addHeader("LFO3");  
     addProp(eLFO3Frequency);  
     addProp(eLFO3InternalDepth);  
     addProp(eLFO3ControlDepth);  
     {  
         char* choices[] = { "internal", "modwheel", "aftertouch",  
                             "internal+modwheel", "internal+aftertouch", 0 };  
         static const gig::lfo3_ctrl_t values[] = {  
             gig::lfo3_ctrl_internal,  
             gig::lfo3_ctrl_modwheel,  
             gig::lfo3_ctrl_aftertouch,  
             gig::lfo3_ctrl_internal_modwheel,  
             gig::lfo3_ctrl_internal_aftertouch  
         };  
         eLFO3Controller.set_choices(choices, values);  
     }  
     addProp(eLFO3Controller);  
     addProp(eLFO3Sync);  
     addHeader("VCF");  
238      addProp(eVCFEnabled);      addProp(eVCFEnabled);
239      {      {
240          char* choices[] = { "lowpass", "lowpassturbo", "bandpass",          char* choices[] = { "lowpass", "lowpassturbo", "bandpass",
# Line 352  DimRegionEdit::DimRegionEdit() : Line 302  DimRegionEdit::DimRegionEdit() :
302    
303      nextPage();      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            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            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);      eVelocityResponseCurve.set_choices(curve_type_texts, curve_type_values);
368      addProp(eVelocityResponseCurve);      addProp(eVelocityResponseCurve);
369      addProp(eVelocityResponseDepth);      addProp(eVelocityResponseDepth);
# Line 361  DimRegionEdit::DimRegionEdit() : Line 373  DimRegionEdit::DimRegionEdit() :
373      addProp(eReleaseVelocityResponseCurve);      addProp(eReleaseVelocityResponseCurve);
374      addProp(eReleaseVelocityResponseDepth);      addProp(eReleaseVelocityResponseDepth);
375      addProp(eReleaseTriggerDecay);      addProp(eReleaseTriggerDecay);
     addProp(eCrossfade_in_start);  
     addProp(eCrossfade_in_end);  
     addProp(eCrossfade_out_start);  
     addProp(eCrossfade_out_end);  
     addProp(ePitchTrack);  
376      {      {
377          char* choices[] = { "none", "effect4depth", "effect5depth", 0 };          char* choices[] = { "none", "effect4depth", "effect5depth", 0 };
378          static const gig::dim_bypass_ctrl_t values[] = {          static const gig::dim_bypass_ctrl_t values[] = {
# Line 376  DimRegionEdit::DimRegionEdit() : Line 383  DimRegionEdit::DimRegionEdit() :
383          eDimensionBypass.set_choices(choices, values);          eDimensionBypass.set_choices(choices, values);
384      }      }
385      addProp(eDimensionBypass);      addProp(eDimensionBypass);
     addProp(ePan);  
386      addProp(eSelfMask);      addProp(eSelfMask);
     addProp(eAttenuationController);  
     addProp(eInvertAttenuationController);  
     addProp(eAttenuationControllerThreshold);  
     addProp(eChannelOffset);  
387      addProp(eSustainDefeat);      addProp(eSustainDefeat);
   
     nextPage();  
388      addProp(eMSDecode);      addProp(eMSDecode);
389      addProp(eSampleStartOffset);  
     addProp(eUnityNote);  
     addProp(eFineTune);  
     addProp(eGain);  
     addProp(eGainPlus6);  
     addProp(eSampleLoops);  
390      nextPage();      nextPage();
391    
392    
393      eEG1InfiniteSustain.signal_toggled().connect(      eEG1InfiniteSustain.signal_toggled().connect(
394          sigc::mem_fun(*this, &DimRegionEdit::EG1InfiniteSustain_toggled) );          sigc::mem_fun(*this, &DimRegionEdit::EG1InfiniteSustain_toggled) );
395      eEG2InfiniteSustain.signal_toggled().connect(      eEG2InfiniteSustain.signal_toggled().connect(
# Line 426  DimRegionEdit::DimRegionEdit() : Line 422  DimRegionEdit::DimRegionEdit() :
422      eCrossfade_out_end.signal_value_changed().connect(      eCrossfade_out_end.signal_value_changed().connect(
423          sigc::mem_fun(*this, &DimRegionEdit::crossfade4_changed));          sigc::mem_fun(*this, &DimRegionEdit::crossfade4_changed));
424    
425      append_page(*table[0], "EG1");      eSampleLoopEnabled.signal_toggled().connect(
426      append_page(*table[1], "EG2");          sigc::mem_fun(*this, &DimRegionEdit::loop_enabled_toggled));
427      append_page(*table[2], "EG3");      eSampleLoopStart.signal_value_changed().connect(
428      append_page(*table[3], "Velocity");          sigc::mem_fun(*this, &DimRegionEdit::updateLoopElements));
429      append_page(*table[4], "Misc");      eSampleLoopLength.signal_value_changed().connect(
430            sigc::mem_fun(*this, &DimRegionEdit::updateLoopElements));
431        eSampleLoopInfinite.signal_toggled().connect(
432            sigc::mem_fun(*this, &DimRegionEdit::loop_infinite_toggled));
433    
434        append_page(*table[0], "Sample");
435        append_page(*table[1], "Amplitude (1)");
436        append_page(*table[2], "Amplitude (2)");
437        append_page(*table[3], "Filter (1)");
438        append_page(*table[4], "Filter (2)");
439        append_page(*table[5], "Pitch");
440        append_page(*table[6], "Misc");
441  }  }
442    
443  DimRegionEdit::~DimRegionEdit()  DimRegionEdit::~DimRegionEdit()
# Line 487  void DimRegionEdit::nextPage() Line 494  void DimRegionEdit::nextPage()
494      firstRowInBlock = 0;      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    }
503    
504  void DimRegionEdit::addProp(LabelWidget& prop)  void DimRegionEdit::addProp(LabelWidget& prop)
505  {  {
506      table[pageno]->attach(prop.label, 1, 2, rowno, rowno + 1,      table[pageno]->attach(prop.label, 1, 2, rowno, rowno + 1,
# Line 499  void DimRegionEdit::addProp(LabelWidget& Line 513  void DimRegionEdit::addProp(LabelWidget&
513    
514  void DimRegionEdit::set_dim_region(gig::DimensionRegion* d)  void DimRegionEdit::set_dim_region(gig::DimensionRegion* d)
515  {  {
516        dimregion = d;
517    
518      set_sensitive(d);      set_sensitive(d);
519      if (!d) return;      if (!d) return;
520    
521      update_gui = false;      update_gui = false;
522      wSample->set_text(d->pSample ? d->pSample->pInfo->Name.c_str() : "NULL");      wSample->set_text(d->pSample ? d->pSample->pInfo->Name.c_str() : "NULL");
523      eEG1PreAttack.set_dimreg(d);      eEG1PreAttack.set_ptr(&d->EG1PreAttack);
524      eEG1Attack.set_dimreg(d);      eEG1Attack.set_ptr(&d->EG1Attack);
525      eEG1Decay1.set_dimreg(d);      eEG1Decay1.set_ptr(&d->EG1Decay1);
526      eEG1Decay2.set_dimreg(d);      eEG1Decay2.set_ptr(&d->EG1Decay2);
527      eEG1InfiniteSustain.set_dimreg(d);      eEG1InfiniteSustain.set_ptr(&d->EG1InfiniteSustain);
528      eEG1Sustain.set_dimreg(d);      eEG1Sustain.set_ptr(&d->EG1Sustain);
529      eEG1Release.set_dimreg(d);      eEG1Release.set_ptr(&d->EG1Release);
530      eEG1Hold.set_dimreg(d);      eEG1Hold.set_ptr(&d->EG1Hold);
531      eEG1Controller.set_dimreg(d);      eEG1Controller.set_ptr(&d->EG1Controller);
532      eEG1ControllerInvert.set_dimreg(d);      eEG1ControllerInvert.set_ptr(&d->EG1ControllerInvert);
533      eEG1ControllerAttackInfluence.set_dimreg(d);      eEG1ControllerAttackInfluence.set_ptr(&d->EG1ControllerAttackInfluence);
534      eEG1ControllerDecayInfluence.set_dimreg(d);      eEG1ControllerDecayInfluence.set_ptr(&d->EG1ControllerDecayInfluence);
535      eEG1ControllerReleaseInfluence.set_dimreg(d);      eEG1ControllerReleaseInfluence.set_ptr(&d->EG1ControllerReleaseInfluence);
536      eLFO1Frequency.set_dimreg(d);      eLFO1Frequency.set_ptr(&d->LFO1Frequency);
537      eLFO1InternalDepth.set_dimreg(d);      eLFO1InternalDepth.set_ptr(&d->LFO1InternalDepth);
538      eLFO1ControlDepth.set_dimreg(d);      eLFO1ControlDepth.set_ptr(&d->LFO1ControlDepth);
539      eLFO1Controller.set_dimreg(d);      eLFO1Controller.set_ptr(&d->LFO1Controller);
540      eLFO1FlipPhase.set_dimreg(d);      eLFO1FlipPhase.set_ptr(&d->LFO1FlipPhase);
541      eLFO1Sync.set_dimreg(d);      eLFO1Sync.set_ptr(&d->LFO1Sync);
542      eEG2PreAttack.set_dimreg(d);      eEG2PreAttack.set_ptr(&d->EG2PreAttack);
543      eEG2Attack.set_dimreg(d);      eEG2Attack.set_ptr(&d->EG2Attack);
544      eEG2Decay1.set_dimreg(d);      eEG2Decay1.set_ptr(&d->EG2Decay1);
545      eEG2Decay2.set_dimreg(d);      eEG2Decay2.set_ptr(&d->EG2Decay2);
546      eEG2InfiniteSustain.set_dimreg(d);      eEG2InfiniteSustain.set_ptr(&d->EG2InfiniteSustain);
547      eEG2Sustain.set_dimreg(d);      eEG2Sustain.set_ptr(&d->EG2Sustain);
548      eEG2Release.set_dimreg(d);      eEG2Release.set_ptr(&d->EG2Release);
549      eEG2Controller.set_dimreg(d);      eEG2Controller.set_ptr(&d->EG2Controller);
550      eEG2ControllerInvert.set_dimreg(d);      eEG2ControllerInvert.set_ptr(&d->EG2ControllerInvert);
551      eEG2ControllerAttackInfluence.set_dimreg(d);      eEG2ControllerAttackInfluence.set_ptr(&d->EG2ControllerAttackInfluence);
552      eEG2ControllerDecayInfluence.set_dimreg(d);      eEG2ControllerDecayInfluence.set_ptr(&d->EG2ControllerDecayInfluence);
553      eEG2ControllerReleaseInfluence.set_dimreg(d);      eEG2ControllerReleaseInfluence.set_ptr(&d->EG2ControllerReleaseInfluence);
554      eLFO2Frequency.set_dimreg(d);      eLFO2Frequency.set_ptr(&d->LFO2Frequency);
555      eLFO2InternalDepth.set_dimreg(d);      eLFO2InternalDepth.set_ptr(&d->LFO2InternalDepth);
556      eLFO2ControlDepth.set_dimreg(d);      eLFO2ControlDepth.set_ptr(&d->LFO2ControlDepth);
557      eLFO2Controller.set_dimreg(d);      eLFO2Controller.set_ptr(&d->LFO2Controller);
558      eLFO2FlipPhase.set_dimreg(d);      eLFO2FlipPhase.set_ptr(&d->LFO2FlipPhase);
559      eLFO2Sync.set_dimreg(d);      eLFO2Sync.set_ptr(&d->LFO2Sync);
560      eEG3Attack.set_dimreg(d);      eEG3Attack.set_ptr(&d->EG3Attack);
561      eEG3Depth.set_dimreg(d);      eEG3Depth.set_ptr(&d->EG3Depth);
562      eLFO3Frequency.set_dimreg(d);      eLFO3Frequency.set_ptr(&d->LFO3Frequency);
563      eLFO3InternalDepth.set_dimreg(d);      eLFO3InternalDepth.set_ptr(&d->LFO3InternalDepth);
564      eLFO3ControlDepth.set_dimreg(d);      eLFO3ControlDepth.set_ptr(&d->LFO3ControlDepth);
565      eLFO3Controller.set_dimreg(d);      eLFO3Controller.set_ptr(&d->LFO3Controller);
566      eLFO3Sync.set_dimreg(d);      eLFO3Sync.set_ptr(&d->LFO3Sync);
567      eVCFEnabled.set_dimreg(d);      eVCFEnabled.set_ptr(&d->VCFEnabled);
568      eVCFType.set_dimreg(d);      eVCFType.set_ptr(&d->VCFType);
569      eVCFCutoffController.set_dimreg(d);      eVCFCutoffController.set_ptr(&d->VCFCutoffController);
570      eVCFCutoffControllerInvert.set_dimreg(d);      eVCFCutoffControllerInvert.set_ptr(&d->VCFCutoffControllerInvert);
571      eVCFCutoff.set_dimreg(d);      eVCFCutoff.set_ptr(&d->VCFCutoff);
572      eVCFVelocityCurve.set_dimreg(d);      eVCFVelocityCurve.set_ptr(&d->VCFVelocityCurve);
573      eVCFVelocityScale.set_dimreg(d);      eVCFVelocityScale.set_ptr(&d->VCFVelocityScale);
574      eVCFVelocityDynamicRange.set_dimreg(d);      eVCFVelocityDynamicRange.set_ptr(&d->VCFVelocityDynamicRange);
575      eVCFResonance.set_dimreg(d);      eVCFResonance.set_ptr(&d->VCFResonance);
576      eVCFResonanceDynamic.set_dimreg(d);      eVCFResonanceDynamic.set_ptr(&d->VCFResonanceDynamic);
577      eVCFResonanceController.set_dimreg(d);      eVCFResonanceController.set_ptr(&d->VCFResonanceController);
578      eVCFKeyboardTracking.set_dimreg(d);      eVCFKeyboardTracking.set_ptr(&d->VCFKeyboardTracking);
579      eVCFKeyboardTrackingBreakpoint.set_dimreg(d);      eVCFKeyboardTrackingBreakpoint.set_ptr(&d->VCFKeyboardTrackingBreakpoint);
580      eVelocityResponseCurve.set_dimreg(d);      eVelocityResponseCurve.set_ptr(&d->VelocityResponseCurve);
581      eVelocityResponseDepth.set_dimreg(d);      eVelocityResponseDepth.set_ptr(&d->VelocityResponseDepth);
582      eVelocityResponseCurveScaling.set_dimreg(d);      eVelocityResponseCurveScaling.set_ptr(&d->VelocityResponseCurveScaling);
583      eReleaseVelocityResponseCurve.set_dimreg(d);      eReleaseVelocityResponseCurve.set_ptr(&d->ReleaseVelocityResponseCurve);
584      eReleaseVelocityResponseDepth.set_dimreg(d);      eReleaseVelocityResponseDepth.set_ptr(&d->ReleaseVelocityResponseDepth);
585      eReleaseTriggerDecay.set_dimreg(d);      eReleaseTriggerDecay.set_ptr(&d->ReleaseTriggerDecay);
586      eCrossfade_in_start.set_dimreg(d);      eCrossfade_in_start.set_ptr(&d->Crossfade.in_start);
587      eCrossfade_in_end.set_dimreg(d);      eCrossfade_in_end.set_ptr(&d->Crossfade.in_end);
588      eCrossfade_out_start.set_dimreg(d);      eCrossfade_out_start.set_ptr(&d->Crossfade.out_start);
589      eCrossfade_out_end.set_dimreg(d);      eCrossfade_out_end.set_ptr(&d->Crossfade.out_end);
590      ePitchTrack.set_dimreg(d);      ePitchTrack.set_ptr(&d->PitchTrack);
591      eDimensionBypass.set_dimreg(d);      eDimensionBypass.set_ptr(&d->DimensionBypass);
592      ePan.set_dimreg(d);      ePan.set_ptr(&d->Pan);
593      eSelfMask.set_dimreg(d);      eSelfMask.set_ptr(&d->SelfMask);
594      eAttenuationController.set_dimreg(d);      eAttenuationController.set_ptr(&d->AttenuationController);
595      eInvertAttenuationController.set_dimreg(d);      eInvertAttenuationController.set_ptr(&d->InvertAttenuationController);
596      eAttenuationControllerThreshold.set_dimreg(d);      eAttenuationControllerThreshold.set_ptr(&d->AttenuationControllerThreshold);
597      eChannelOffset.set_dimreg(d);      eChannelOffset.set_ptr(&d->ChannelOffset);
598      eSustainDefeat.set_dimreg(d);      eSustainDefeat.set_ptr(&d->SustainDefeat);
599      eMSDecode.set_dimreg(d);      eMSDecode.set_ptr(&d->MSDecode);
600      eSampleStartOffset.set_dimreg(d);      eSampleStartOffset.set_ptr(&d->SampleStartOffset);
601      eUnityNote.set_dimreg(d);      eUnityNote.set_ptr(&d->UnityNote);
602      eFineTune.set_dimreg(d);      eFineTune.set_ptr(&d->FineTune);
603      eGain.set_dimreg(d);      eGain.set_ptr(&d->Gain);
604      eGainPlus6.set_dimreg(d);      eGainPlus6.set_ptr(&d->Gain);
605      eSampleLoops.set_dimreg(d);  
606        eSampleLoopEnabled.set_active(d->SampleLoops);
607        updateLoopElements();
608    
609      VCFEnabled_toggled();      VCFEnabled_toggled();
610    
# Line 647  void DimRegionEdit::VCFCutoffController_ Line 665  void DimRegionEdit::VCFCutoffController_
665      eVCFCutoffControllerInvert.set_sensitive(hasController);      eVCFCutoffControllerInvert.set_sensitive(hasController);
666      eVCFCutoff.set_sensitive(!hasController);      eVCFCutoff.set_sensitive(!hasController);
667      eVCFResonanceDynamic.set_sensitive(!hasController);      eVCFResonanceDynamic.set_sensitive(!hasController);
668      eVCFVelocityScale.label.set_text(hasController ? "MinimumCutoff:" :      eVCFVelocityScale.label.set_text(hasController ? "Minimum cutoff:" :
669                                       "VelocityScale:");                                       "Velocity scale:");
670  }  }
671    
672  void DimRegionEdit::VCFResonanceController_changed()  void DimRegionEdit::VCFResonanceController_changed()
# Line 742  void DimRegionEdit::crossfade4_changed() Line 760  void DimRegionEdit::crossfade4_changed()
760    
761      if (c4 < c3) eCrossfade_out_start.set_value(c4);      if (c4 < c3) eCrossfade_out_start.set_value(c4);
762  }  }
763    
764    void DimRegionEdit::loop_enabled_toggled()
765    {
766        const bool active = eSampleLoopEnabled.get_active();
767        if (active) {
768            // create a new sample loop in case there is none yet
769            if (!dimregion->SampleLoops) {
770                DLS::sample_loop_t loop;
771                loop.LoopType   = gig::loop_type_normal;
772                // loop the whole sample by default
773                loop.LoopStart  = 0;
774                loop.LoopLength =
775                    (dimregion->pSample) ? dimregion->pSample->GetSize() : 0;
776                dimregion->AddSampleLoop(&loop);
777            }
778        } else {
779            // delete ALL existing sample loops
780            while (dimregion->SampleLoops)
781                dimregion->DeleteSampleLoop(&dimregion->pSampleLoops[0]);
782        }
783        updateLoopElements();
784    }
785    
786    void DimRegionEdit::updateLoopElements()
787    {
788        const bool active = eSampleLoopEnabled.get_active();
789        eSampleLoopStart.set_sensitive(active);
790        eSampleLoopLength.set_sensitive(active);
791        eSampleLoopType.set_sensitive(active);
792        eSampleLoopInfinite.set_sensitive(active);
793        if (dimregion && dimregion->SampleLoops) {
794            eSampleLoopStart.set_ptr(&dimregion->pSampleLoops[0].LoopStart);
795            eSampleLoopLength.set_ptr(&dimregion->pSampleLoops[0].LoopLength);
796            eSampleLoopType.set_ptr(&dimregion->pSampleLoops[0].LoopType);
797            eSampleLoopPlayCount.set_ptr(
798                (dimregion->pSample) ? &dimregion->pSample->LoopPlayCount : NULL
799            );
800            eSampleLoopInfinite.set_active(
801                dimregion->pSample && !dimregion->pSample->LoopPlayCount
802            );
803            // sample loop shall never be longer than the actual sample size
804            eSampleLoopStart.set_upper(
805                (dimregion->pSample)
806                    ? dimregion->pSample->GetSize() -
807                      dimregion->pSampleLoops[0].LoopLength
808                    : 0
809            );
810            eSampleLoopLength.set_upper(
811                (dimregion->pSample)
812                    ? dimregion->pSample->GetSize() -
813                      dimregion->pSampleLoops[0].LoopStart
814                    : 0
815            );
816        } else { // no sample loop(s)
817            eSampleLoopStart.set_ptr(NULL);
818            eSampleLoopLength.set_ptr(NULL);
819            eSampleLoopType.set_ptr(NULL);
820            eSampleLoopPlayCount.set_ptr(NULL);
821        }
822    }
823    
824    void DimRegionEdit::loop_infinite_toggled() {
825        eSampleLoopPlayCount.set_sensitive(!eSampleLoopInfinite.get_active());
826        if (eSampleLoopInfinite.get_active()) eSampleLoopPlayCount.set_value(0);
827        else                                  eSampleLoopPlayCount.set_value(1);
828    }
Legend:
Removed from v.1118  
changed lines
  Added in v.1159
  ViewVC Help
Powered by ViewVC