/[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 1117 by persson, Sat Mar 24 13:05:58 2007 UTC revision 1151 by schoenebeck, Sun Apr 8 13:45:45 2007 UTC
# Line 19  Line 19 
19    
20  #include "dimregionedit.h"  #include "dimregionedit.h"
21    
 bool update_gui;  
   
 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;  
     }  
 }  
   
22  DimRegionEdit::DimRegionEdit() :  DimRegionEdit::DimRegionEdit() :
23      eEG1PreAttack("PreAttack", &gig::DimensionRegion::EG1PreAttack, 0, 100, 2),      eEG1PreAttack("PreAttack", 0, 100, 2),
24      eEG1Attack("Attack", &gig::DimensionRegion::EG1Attack, 0, 60, 3),      eEG1Attack("Attack", 0, 60, 3),
25      eEG1Decay1("Decay1", &gig::DimensionRegion::EG1Decay1, 0.005, 60, 3),      eEG1Decay1("Decay1", 0.005, 60, 3),
26      eEG1Decay2("Decay2", &gig::DimensionRegion::EG1Decay2, 0, 60, 3),      eEG1Decay2("Decay2", 0, 60, 3),
27      eEG1InfiniteSustain("InfiniteSustain",      eEG1InfiniteSustain("InfiniteSustain"),
28                          &gig::DimensionRegion::EG1InfiniteSustain),      eEG1Sustain("Sustain", 0, 100, 2),
29      eEG1Sustain("Sustain", &gig::DimensionRegion::EG1Sustain, 0, 100, 2),      eEG1Release("Release", 0, 60, 3),
30      eEG1Release("Release", &gig::DimensionRegion::EG1Release, 0, 60, 3),      eEG1Hold("Hold"),
31      eEG1Hold("Hold", &gig::DimensionRegion::EG1Hold),      eEG1Controller("Controller"),
32      eEG1Controller("Controller", &gig::DimensionRegion::EG1Controller),      eEG1ControllerInvert("ControllerInvert"),
33      eEG1ControllerInvert("ControllerInvert",      eEG1ControllerAttackInfluence("ControllerAttackInfluence", 0, 3),
34                           &gig::DimensionRegion::EG1ControllerInvert),      eEG1ControllerDecayInfluence("ControllerDecayInfluence", 0, 3),
35      eEG1ControllerAttackInfluence("ControllerAttackInfluence",      eEG1ControllerReleaseInfluence("ControllerReleaseInfluence", 0, 3),
36                                    &gig::DimensionRegion::EG1ControllerAttackInfluence,      eLFO1Frequency("Frequency", 0.1, 10, 2),
37                                    0, 3),      eLFO1InternalDepth("InternalDepth", 0, 1200),
38      eEG1ControllerDecayInfluence("ControllerDecayInfluence",      eLFO1ControlDepth("ControlDepth", 0, 1200),
39                                   &gig::DimensionRegion::EG1ControllerDecayInfluence,      eLFO1Controller("Controller"),
40                                   0, 3),      eLFO1FlipPhase("FlipPhase"),
41      eEG1ControllerReleaseInfluence("ControllerReleaseInfluence",      eLFO1Sync("Sync"),
42                                     &gig::DimensionRegion::EG1ControllerReleaseInfluence,      eEG2PreAttack("PreAttack", 0, 100, 2),
43                                     0, 3),      eEG2Attack("Attack", 0, 60, 3),
44      eLFO1Frequency("Frequency", &gig::DimensionRegion::LFO1Frequency,      eEG2Decay1("Decay1", 0.005, 60, 3),
45                     0.1, 10, 2),      eEG2Decay2("Decay2", 0, 60, 3),
46      eLFO1InternalDepth("InternalDepth",      eEG2InfiniteSustain("InfiniteSustain"),
47                         &gig::DimensionRegion::LFO1InternalDepth, 0, 1200),      eEG2Sustain("Sustain", 0, 100, 2),
48      eLFO1ControlDepth("ControlDepth", &gig::DimensionRegion::LFO1ControlDepth,      eEG2Release("Release", 0, 60, 3),
49                        0, 1200),      eEG2Controller("Controller"),
50      eLFO1Controller("Controller", &gig::DimensionRegion::LFO1Controller),      eEG2ControllerInvert("ControllerInvert"),
51      eLFO1FlipPhase("FlipPhase", &gig::DimensionRegion::LFO1FlipPhase),      eEG2ControllerAttackInfluence("ControllerAttackInfluence", 0, 3),
52      eLFO1Sync("Sync", &gig::DimensionRegion::LFO1Sync),      eEG2ControllerDecayInfluence("ControllerDecayInfluence", 0, 3),
53      eEG2PreAttack("PreAttack", &gig::DimensionRegion::EG2PreAttack, 0, 100, 2),      eEG2ControllerReleaseInfluence("ControllerReleaseInfluence", 0, 3),
54      eEG2Attack("Attack", &gig::DimensionRegion::EG2Attack, 0, 60, 3),      eLFO2Frequency("Frequency", 0.1, 10, 2),
55      eEG2Decay1("Decay1", &gig::DimensionRegion::EG2Decay1, 0.005, 60, 3),      eLFO2InternalDepth("InternalDepth", 0, 1200),
56      eEG2Decay2("Decay2", &gig::DimensionRegion::EG2Decay2, 0, 60, 3),      eLFO2ControlDepth("ControlDepth", 0, 1200),
57      eEG2InfiniteSustain("InfiniteSustain",      eLFO2Controller("Controller"),
58                          &gig::DimensionRegion::EG2InfiniteSustain),      eLFO2FlipPhase("FlipPhase"),
59      eEG2Sustain("Sustain", &gig::DimensionRegion::EG2Sustain, 0, 100, 2),      eLFO2Sync("Sync"),
60      eEG2Release("Release", &gig::DimensionRegion::EG2Release, 0, 60, 3),      eEG3Attack("Attack", 0, 10, 3),
61      eEG2Controller("Controller", &gig::DimensionRegion::EG2Controller),      eEG3Depth("Depth", -1200, 1200),
62      eEG2ControllerInvert("ControllerInvert",      eLFO3Frequency("Frequency", 0.1, 10, 2),
63                           &gig::DimensionRegion::EG2ControllerInvert),      eLFO3InternalDepth("InternalDepth", 0, 1200),
64      eEG2ControllerAttackInfluence("ControllerAttackInfluence",      eLFO3ControlDepth("ControlDepth", 0, 1200),
65                                    &gig::DimensionRegion::EG2ControllerAttackInfluence,      eLFO3Controller("Controller"),
66                                    0, 3),      eLFO3Sync("Sync"),
67      eEG2ControllerDecayInfluence("ControllerDecayInfluence",      eVCFEnabled("Enabled"),
68                                   &gig::DimensionRegion::EG2ControllerDecayInfluence,      eVCFType("Type"),
69                                   0, 3),      eVCFCutoffController("CutoffController"),
70      eEG2ControllerReleaseInfluence("ControllerReleaseInfluence",      eVCFCutoffControllerInvert("CutoffControllerInvert"),
71                                     &gig::DimensionRegion::EG2ControllerReleaseInfluence,      eVCFCutoff("Cutoff"),
72                                     0, 3),      eVCFVelocityCurve("VelocityCurve"),
73      eLFO2Frequency("Frequency", &gig::DimensionRegion::LFO2Frequency,      eVCFVelocityScale("VelocityScale"),
74                     0.1, 10, 2),      eVCFVelocityDynamicRange("VelocityDynamicRange", 0, 4),
75      eLFO2InternalDepth("InternalDepth",      eVCFResonance("Resonance"),
76                         &gig::DimensionRegion::LFO2InternalDepth, 0, 1200),      eVCFResonanceDynamic("ResonanceDynamic"),
77      eLFO2ControlDepth("ControlDepth",      eVCFResonanceController("ResonanceController"),
78                        &gig::DimensionRegion::LFO2ControlDepth, 0, 1200),      eVCFKeyboardTracking("KeyboardTracking"),
79      eLFO2Controller("Controller", &gig::DimensionRegion::LFO2Controller),      eVCFKeyboardTrackingBreakpoint("KeyboardTrackingBreakpoint"),
80      eLFO2FlipPhase("FlipPhase", &gig::DimensionRegion::LFO2FlipPhase),      eVelocityResponseCurve("VelocityResponseCurve"),
81      eLFO2Sync("Sync", &gig::DimensionRegion::LFO2Sync),      eVelocityResponseDepth("VelocityResponseDepth", 0, 4),
82      eEG3Attack("Attack", &gig::DimensionRegion::EG3Attack, 0, 10, 3),      eVelocityResponseCurveScaling("VelocityResponseCurveScaling"),
83      eEG3Depth("Depth", &gig::DimensionRegion::EG3Depth, -1200, 1200),      eReleaseVelocityResponseCurve("ReleaseVelocityResponseCurve"),
84      eLFO3Frequency("Frequency", &gig::DimensionRegion::LFO3Frequency,      eReleaseVelocityResponseDepth("ReleaseVelocityResponseDepth", 0, 4),
85                     0.1, 10, 2),      eReleaseTriggerDecay("ReleaseTriggerDecay", 0, 8),
86      eLFO3InternalDepth("InternalDepth",      eCrossfade_in_start("Crossfade.in_start"),
87                         &gig::DimensionRegion::LFO3InternalDepth, 0, 1200),      eCrossfade_in_end("Crossfade.in_end"),
88      eLFO3ControlDepth("ControlDepth", &gig::DimensionRegion::LFO3ControlDepth,      eCrossfade_out_start("Crossfade.out_start"),
89                        0, 1200),      eCrossfade_out_end("Crossfade.out_end"),
90      eLFO3Controller("Controller", &gig::DimensionRegion::LFO3Controller),      ePitchTrack("PitchTrack"),
91      eLFO3Sync("Sync", &gig::DimensionRegion::LFO3Sync),      eDimensionBypass("DimensionBypass"),
92      eVCFEnabled("Enabled", &gig::DimensionRegion::VCFEnabled),      ePan("Pan", -64, 63),
93      eVCFType("Type", &gig::DimensionRegion::VCFType),      eSelfMask("SelfMask"),
94      eVCFCutoffController("CutoffController",      eAttenuationController("AttenuationController"),
95                           &gig::DimensionRegion::VCFCutoffController),      eInvertAttenuationController("InvertAttenuationController"),
96      eVCFCutoffControllerInvert("CutoffControllerInvert",      eAttenuationControllerThreshold("AttenuationControllerThreshold"),
97                                 &gig::DimensionRegion::VCFCutoffControllerInvert),      eChannelOffset("ChannelOffset", 0, 9),
98      eVCFCutoff("Cutoff", &gig::DimensionRegion::VCFCutoff),      eSustainDefeat("SustainDefeat"),
99      eVCFVelocityCurve("VelocityCurve", &gig::DimensionRegion::VCFVelocityCurve),      eMSDecode("MSDecode"),
100      eVCFVelocityScale("VelocityScale", &gig::DimensionRegion::VCFVelocityScale),      eSampleStartOffset("SampleStartOffset", 0, 2000),
101      eVCFVelocityDynamicRange("VelocityDynamicRange",      eUnityNote("UnityNote"),
102                               &gig::DimensionRegion::VCFVelocityDynamicRange,      eFineTune("FineTune", -49, 50),
103                               0, 4),      eGain("Gain", -96, 0, 2, -655360),
104      eVCFResonance("Resonance", &gig::DimensionRegion::VCFResonance),      eGainPlus6("Gain +6dB", eGain, 6 * -655360),
105      eVCFResonanceDynamic("ResonanceDynamic",      eSampleLoops("SampleLoops", 0, 1)
                          &gig::DimensionRegion::VCFResonanceDynamic),  
     eVCFResonanceController("ResonanceController",  
                             &gig::DimensionRegion::VCFResonanceController),  
     eVCFKeyboardTracking("KeyboardTracking",  
                          &gig::DimensionRegion::VCFKeyboardTracking),  
     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)  
106  {  {
107      for (int i = 0 ; i < 5 ; i++) {      for (int i = 0 ; i < 7 ; i++) {
108          table[i] = new Gtk::Table(3, 1);          table[i] = new Gtk::Table(3, 1);
109          table[i]->set_col_spacings(5);          table[i]->set_col_spacings(7);
110      }      }
111    
112      pageno = 0;      pageno = 0;
113      rowno = 0;      rowno = 0;
114      firstRowInBlock = 0;      firstRowInBlock = 0;
115    
116        addHeader("General (mandatory):");
117      addString("Sample", lSample, wSample);      addString("Sample", lSample, wSample);
118      //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);
119      addHeader("EG1");      tooltips.set_tip(*wSample, "drop a sample here");
120        addProp(eUnityNote);
121        addHeader("Optional Settings:");
122        addProp(eSampleStartOffset);
123        addProp(ePan);
124        addProp(eChannelOffset);
125        addHeader("Loops:");
126        addProp(eSampleLoops);
127        addHeader("Crossfade:");
128        addProp(eCrossfade_in_start);
129        addProp(eCrossfade_in_end);
130        addProp(eCrossfade_out_start);
131        addProp(eCrossfade_out_end);
132    
133        nextPage();
134    
135        addHeader("General Amplitude Settings:");
136        addProp(eGain);
137        addProp(eGainPlus6);
138        addProp(eAttenuationController);
139        addProp(eInvertAttenuationController);
140        addProp(eAttenuationControllerThreshold);
141        addHeader("EG1 (Amplitude Envelope):");
142      addProp(eEG1PreAttack);      addProp(eEG1PreAttack);
143      addProp(eEG1Attack);      addProp(eEG1Attack);
144      addProp(eEG1Decay1);      addProp(eEG1Decay1);
# Line 206  DimRegionEdit::DimRegionEdit() : Line 152  DimRegionEdit::DimRegionEdit() :
152      addProp(eEG1ControllerAttackInfluence);      addProp(eEG1ControllerAttackInfluence);
153      addProp(eEG1ControllerDecayInfluence);      addProp(eEG1ControllerDecayInfluence);
154      addProp(eEG1ControllerReleaseInfluence);      addProp(eEG1ControllerReleaseInfluence);
155      addHeader("LFO1");  
156        nextPage();
157    
158        addHeader("LFO1 (Amplitude Oscillator):");
159      addProp(eLFO1Frequency);      addProp(eLFO1Frequency);
160      addProp(eLFO1InternalDepth);      addProp(eLFO1InternalDepth);
161      addProp(eLFO1ControlDepth);      addProp(eLFO1ControlDepth);
# Line 227  DimRegionEdit::DimRegionEdit() : Line 176  DimRegionEdit::DimRegionEdit() :
176      addProp(eLFO1Sync);      addProp(eLFO1Sync);
177    
178      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();  
179    
180      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");  
181      addProp(eVCFEnabled);      addProp(eVCFEnabled);
182      {      {
183          char* choices[] = { "lowpass", "lowpassturbo", "bandpass",          char* choices[] = { "lowpass", "lowpassturbo", "bandpass",
# Line 351  DimRegionEdit::DimRegionEdit() : Line 245  DimRegionEdit::DimRegionEdit() :
245    
246      nextPage();      nextPage();
247    
248        addHeader("EG2 (Filter Cutoff Envelope):");
249        addProp(eEG2PreAttack);
250        addProp(eEG2Attack);
251        addProp(eEG2Decay1);
252        addProp(eEG2Decay2);
253        addProp(eEG2InfiniteSustain);
254        addProp(eEG2Sustain);
255        addProp(eEG2Release);
256        addProp(eEG2Controller);
257        addProp(eEG2ControllerInvert);
258        addProp(eEG2ControllerAttackInfluence);
259        addProp(eEG2ControllerDecayInfluence);
260        addProp(eEG2ControllerReleaseInfluence);
261        addHeader("LFO2 (Filter Cutoff Oscillator):");
262        addProp(eLFO2Frequency);
263        addProp(eLFO2InternalDepth);
264        addProp(eLFO2ControlDepth);
265        {
266            char* choices[] = { "internal", "modwheel", "foot",
267                                "internal+modwheel", "internal+foot", 0 };
268            static const gig::lfo2_ctrl_t values[] = {
269                gig::lfo2_ctrl_internal,
270                gig::lfo2_ctrl_modwheel,
271                gig::lfo2_ctrl_foot,
272                gig::lfo2_ctrl_internal_modwheel,
273                gig::lfo2_ctrl_internal_foot
274            };
275            eLFO2Controller.set_choices(choices, values);
276        }
277        addProp(eLFO2Controller);
278        addProp(eLFO2FlipPhase);
279        addProp(eLFO2Sync);
280    
281        nextPage();
282    
283        addHeader("General Pitch Settings:");
284        addProp(eFineTune);
285        addProp(ePitchTrack);
286        addHeader("EG3 (Pitch Envelope):");
287        addProp(eEG3Attack);
288        addProp(eEG3Depth);
289        addHeader("LFO3 (Pitch Oscillator):");
290        addProp(eLFO3Frequency);
291        addProp(eLFO3InternalDepth);
292        addProp(eLFO3ControlDepth);
293        {
294            char* choices[] = { "internal", "modwheel", "aftertouch",
295                                "internal+modwheel", "internal+aftertouch", 0 };
296            static const gig::lfo3_ctrl_t values[] = {
297                gig::lfo3_ctrl_internal,
298                gig::lfo3_ctrl_modwheel,
299                gig::lfo3_ctrl_aftertouch,
300                gig::lfo3_ctrl_internal_modwheel,
301                gig::lfo3_ctrl_internal_aftertouch
302            };
303            eLFO3Controller.set_choices(choices, values);
304        }
305        addProp(eLFO3Controller);
306        addProp(eLFO3Sync);
307    
308        nextPage();
309    
310      eVelocityResponseCurve.set_choices(curve_type_texts, curve_type_values);      eVelocityResponseCurve.set_choices(curve_type_texts, curve_type_values);
311      addProp(eVelocityResponseCurve);      addProp(eVelocityResponseCurve);
312      addProp(eVelocityResponseDepth);      addProp(eVelocityResponseDepth);
# Line 360  DimRegionEdit::DimRegionEdit() : Line 316  DimRegionEdit::DimRegionEdit() :
316      addProp(eReleaseVelocityResponseCurve);      addProp(eReleaseVelocityResponseCurve);
317      addProp(eReleaseVelocityResponseDepth);      addProp(eReleaseVelocityResponseDepth);
318      addProp(eReleaseTriggerDecay);      addProp(eReleaseTriggerDecay);
     addProp(eCrossfade_in_start);  
     addProp(eCrossfade_in_end);  
     addProp(eCrossfade_out_start);  
     addProp(eCrossfade_out_end);  
     addProp(ePitchTrack);  
319      {      {
320          char* choices[] = { "none", "effect4depth", "effect5depth", 0 };          char* choices[] = { "none", "effect4depth", "effect5depth", 0 };
321          static const gig::dim_bypass_ctrl_t values[] = {          static const gig::dim_bypass_ctrl_t values[] = {
# Line 375  DimRegionEdit::DimRegionEdit() : Line 326  DimRegionEdit::DimRegionEdit() :
326          eDimensionBypass.set_choices(choices, values);          eDimensionBypass.set_choices(choices, values);
327      }      }
328      addProp(eDimensionBypass);      addProp(eDimensionBypass);
     addProp(ePan);  
329      addProp(eSelfMask);      addProp(eSelfMask);
     addProp(eAttenuationController);  
     addProp(eInvertAttenuationController);  
     addProp(eAttenuationControllerThreshold);  
     addProp(eChannelOffset);  
330      addProp(eSustainDefeat);      addProp(eSustainDefeat);
   
     nextPage();  
331      addProp(eMSDecode);      addProp(eMSDecode);
332      addProp(eSampleStartOffset);  
     addProp(eUnityNote);  
     addProp(eFineTune);  
     addProp(eGain);  
     addProp(eGainPlus6);  
     addProp(eSampleLoops);  
333      nextPage();      nextPage();
334    
335    
336      eEG1InfiniteSustain.signal_toggled().connect(      eEG1InfiniteSustain.signal_toggled().connect(
337          sigc::mem_fun(*this, &DimRegionEdit::EG1InfiniteSustain_toggled) );          sigc::mem_fun(*this, &DimRegionEdit::EG1InfiniteSustain_toggled) );
338      eEG2InfiniteSustain.signal_toggled().connect(      eEG2InfiniteSustain.signal_toggled().connect(
# Line 425  DimRegionEdit::DimRegionEdit() : Line 365  DimRegionEdit::DimRegionEdit() :
365      eCrossfade_out_end.signal_value_changed().connect(      eCrossfade_out_end.signal_value_changed().connect(
366          sigc::mem_fun(*this, &DimRegionEdit::crossfade4_changed));          sigc::mem_fun(*this, &DimRegionEdit::crossfade4_changed));
367    
368      append_page(*table[0], "EG1");      append_page(*table[0], "Sample");
369      append_page(*table[1], "EG2");      append_page(*table[1], "Amplitude (1)");
370      append_page(*table[2], "EG3");      append_page(*table[2], "Amplitude (2)");
371      append_page(*table[3], "Velocity");      append_page(*table[3], "Filter (1)");
372      append_page(*table[4], "Misc");      append_page(*table[4], "Filter (2)");
373        append_page(*table[5], "Pitch");
374        append_page(*table[6], "Misc");
375  }  }
376    
377  DimRegionEdit::~DimRegionEdit()  DimRegionEdit::~DimRegionEdit()
# Line 503  void DimRegionEdit::set_dim_region(gig:: Line 445  void DimRegionEdit::set_dim_region(gig::
445    
446      update_gui = false;      update_gui = false;
447      wSample->set_text(d->pSample ? d->pSample->pInfo->Name.c_str() : "NULL");      wSample->set_text(d->pSample ? d->pSample->pInfo->Name.c_str() : "NULL");
448      eEG1PreAttack.set_dimreg(d);      eEG1PreAttack.set_ptr(&d->EG1PreAttack);
449      eEG1Attack.set_dimreg(d);      eEG1Attack.set_ptr(&d->EG1Attack);
450      eEG1Decay1.set_dimreg(d);      eEG1Decay1.set_ptr(&d->EG1Decay1);
451      eEG1Decay2.set_dimreg(d);      eEG1Decay2.set_ptr(&d->EG1Decay2);
452      eEG1InfiniteSustain.set_dimreg(d);      eEG1InfiniteSustain.set_ptr(&d->EG1InfiniteSustain);
453      eEG1Sustain.set_dimreg(d);      eEG1Sustain.set_ptr(&d->EG1Sustain);
454      eEG1Release.set_dimreg(d);      eEG1Release.set_ptr(&d->EG1Release);
455      eEG1Hold.set_dimreg(d);      eEG1Hold.set_ptr(&d->EG1Hold);
456      eEG1Controller.set_dimreg(d);      eEG1Controller.set_ptr(&d->EG1Controller);
457      eEG1ControllerInvert.set_dimreg(d);      eEG1ControllerInvert.set_ptr(&d->EG1ControllerInvert);
458      eEG1ControllerAttackInfluence.set_dimreg(d);      eEG1ControllerAttackInfluence.set_ptr(&d->EG1ControllerAttackInfluence);
459      eEG1ControllerDecayInfluence.set_dimreg(d);      eEG1ControllerDecayInfluence.set_ptr(&d->EG1ControllerDecayInfluence);
460      eEG1ControllerReleaseInfluence.set_dimreg(d);      eEG1ControllerReleaseInfluence.set_ptr(&d->EG1ControllerReleaseInfluence);
461      eLFO1Frequency.set_dimreg(d);      eLFO1Frequency.set_ptr(&d->LFO1Frequency);
462      eLFO1InternalDepth.set_dimreg(d);      eLFO1InternalDepth.set_ptr(&d->LFO1InternalDepth);
463      eLFO1ControlDepth.set_dimreg(d);      eLFO1ControlDepth.set_ptr(&d->LFO1ControlDepth);
464      eLFO1Controller.set_dimreg(d);      eLFO1Controller.set_ptr(&d->LFO1Controller);
465      eLFO1FlipPhase.set_dimreg(d);      eLFO1FlipPhase.set_ptr(&d->LFO1FlipPhase);
466      eLFO1Sync.set_dimreg(d);      eLFO1Sync.set_ptr(&d->LFO1Sync);
467      eEG2PreAttack.set_dimreg(d);      eEG2PreAttack.set_ptr(&d->EG2PreAttack);
468      eEG2Attack.set_dimreg(d);      eEG2Attack.set_ptr(&d->EG2Attack);
469      eEG2Decay1.set_dimreg(d);      eEG2Decay1.set_ptr(&d->EG2Decay1);
470      eEG2Decay2.set_dimreg(d);      eEG2Decay2.set_ptr(&d->EG2Decay2);
471      eEG2InfiniteSustain.set_dimreg(d);      eEG2InfiniteSustain.set_ptr(&d->EG2InfiniteSustain);
472      eEG2Sustain.set_dimreg(d);      eEG2Sustain.set_ptr(&d->EG2Sustain);
473      eEG2Release.set_dimreg(d);      eEG2Release.set_ptr(&d->EG2Release);
474      eEG2Controller.set_dimreg(d);      eEG2Controller.set_ptr(&d->EG2Controller);
475      eEG2ControllerInvert.set_dimreg(d);      eEG2ControllerInvert.set_ptr(&d->EG2ControllerInvert);
476      eEG2ControllerAttackInfluence.set_dimreg(d);      eEG2ControllerAttackInfluence.set_ptr(&d->EG2ControllerAttackInfluence);
477      eEG2ControllerDecayInfluence.set_dimreg(d);      eEG2ControllerDecayInfluence.set_ptr(&d->EG2ControllerDecayInfluence);
478      eEG2ControllerReleaseInfluence.set_dimreg(d);      eEG2ControllerReleaseInfluence.set_ptr(&d->EG2ControllerReleaseInfluence);
479      eLFO2Frequency.set_dimreg(d);      eLFO2Frequency.set_ptr(&d->LFO2Frequency);
480      eLFO2InternalDepth.set_dimreg(d);      eLFO2InternalDepth.set_ptr(&d->LFO2InternalDepth);
481      eLFO2ControlDepth.set_dimreg(d);      eLFO2ControlDepth.set_ptr(&d->LFO2ControlDepth);
482      eLFO2Controller.set_dimreg(d);      eLFO2Controller.set_ptr(&d->LFO2Controller);
483      eLFO2FlipPhase.set_dimreg(d);      eLFO2FlipPhase.set_ptr(&d->LFO2FlipPhase);
484      eLFO2Sync.set_dimreg(d);      eLFO2Sync.set_ptr(&d->LFO2Sync);
485      eEG3Attack.set_dimreg(d);      eEG3Attack.set_ptr(&d->EG3Attack);
486      eEG3Depth.set_dimreg(d);      eEG3Depth.set_ptr(&d->EG3Depth);
487      eLFO3Frequency.set_dimreg(d);      eLFO3Frequency.set_ptr(&d->LFO3Frequency);
488      eLFO3InternalDepth.set_dimreg(d);      eLFO3InternalDepth.set_ptr(&d->LFO3InternalDepth);
489      eLFO3ControlDepth.set_dimreg(d);      eLFO3ControlDepth.set_ptr(&d->LFO3ControlDepth);
490      eLFO3Controller.set_dimreg(d);      eLFO3Controller.set_ptr(&d->LFO3Controller);
491      eLFO3Sync.set_dimreg(d);      eLFO3Sync.set_ptr(&d->LFO3Sync);
492      eVCFEnabled.set_dimreg(d);      eVCFEnabled.set_ptr(&d->VCFEnabled);
493      eVCFType.set_dimreg(d);      eVCFType.set_ptr(&d->VCFType);
494      eVCFCutoffController.set_dimreg(d);      eVCFCutoffController.set_ptr(&d->VCFCutoffController);
495      eVCFCutoffControllerInvert.set_dimreg(d);      eVCFCutoffControllerInvert.set_ptr(&d->VCFCutoffControllerInvert);
496      eVCFCutoff.set_dimreg(d);      eVCFCutoff.set_ptr(&d->VCFCutoff);
497      eVCFVelocityCurve.set_dimreg(d);      eVCFVelocityCurve.set_ptr(&d->VCFVelocityCurve);
498      eVCFVelocityScale.set_dimreg(d);      eVCFVelocityScale.set_ptr(&d->VCFVelocityScale);
499      eVCFVelocityDynamicRange.set_dimreg(d);      eVCFVelocityDynamicRange.set_ptr(&d->VCFVelocityDynamicRange);
500      eVCFResonance.set_dimreg(d);      eVCFResonance.set_ptr(&d->VCFResonance);
501      eVCFResonanceDynamic.set_dimreg(d);      eVCFResonanceDynamic.set_ptr(&d->VCFResonanceDynamic);
502      eVCFResonanceController.set_dimreg(d);      eVCFResonanceController.set_ptr(&d->VCFResonanceController);
503      eVCFKeyboardTracking.set_dimreg(d);      eVCFKeyboardTracking.set_ptr(&d->VCFKeyboardTracking);
504      eVCFKeyboardTrackingBreakpoint.set_dimreg(d);      eVCFKeyboardTrackingBreakpoint.set_ptr(&d->VCFKeyboardTrackingBreakpoint);
505      eVelocityResponseCurve.set_dimreg(d);      eVelocityResponseCurve.set_ptr(&d->VelocityResponseCurve);
506      eVelocityResponseDepth.set_dimreg(d);      eVelocityResponseDepth.set_ptr(&d->VelocityResponseDepth);
507      eVelocityResponseCurveScaling.set_dimreg(d);      eVelocityResponseCurveScaling.set_ptr(&d->VelocityResponseCurveScaling);
508      eReleaseVelocityResponseCurve.set_dimreg(d);      eReleaseVelocityResponseCurve.set_ptr(&d->ReleaseVelocityResponseCurve);
509      eReleaseVelocityResponseDepth.set_dimreg(d);      eReleaseVelocityResponseDepth.set_ptr(&d->ReleaseVelocityResponseDepth);
510      eReleaseTriggerDecay.set_dimreg(d);      eReleaseTriggerDecay.set_ptr(&d->ReleaseTriggerDecay);
511      eCrossfade_in_start.set_dimreg(d);      eCrossfade_in_start.set_ptr(&d->Crossfade.in_start);
512      eCrossfade_in_end.set_dimreg(d);      eCrossfade_in_end.set_ptr(&d->Crossfade.in_end);
513      eCrossfade_out_start.set_dimreg(d);      eCrossfade_out_start.set_ptr(&d->Crossfade.out_start);
514      eCrossfade_out_end.set_dimreg(d);      eCrossfade_out_end.set_ptr(&d->Crossfade.out_end);
515      ePitchTrack.set_dimreg(d);      ePitchTrack.set_ptr(&d->PitchTrack);
516      eDimensionBypass.set_dimreg(d);      eDimensionBypass.set_ptr(&d->DimensionBypass);
517      ePan.set_dimreg(d);      ePan.set_ptr(&d->Pan);
518      eSelfMask.set_dimreg(d);      eSelfMask.set_ptr(&d->SelfMask);
519      eAttenuationController.set_dimreg(d);      eAttenuationController.set_ptr(&d->AttenuationController);
520      eInvertAttenuationController.set_dimreg(d);      eInvertAttenuationController.set_ptr(&d->InvertAttenuationController);
521      eAttenuationControllerThreshold.set_dimreg(d);      eAttenuationControllerThreshold.set_ptr(&d->AttenuationControllerThreshold);
522      eChannelOffset.set_dimreg(d);      eChannelOffset.set_ptr(&d->ChannelOffset);
523      eSustainDefeat.set_dimreg(d);      eSustainDefeat.set_ptr(&d->SustainDefeat);
524      eMSDecode.set_dimreg(d);      eMSDecode.set_ptr(&d->MSDecode);
525      eSampleStartOffset.set_dimreg(d);      eSampleStartOffset.set_ptr(&d->SampleStartOffset);
526      eUnityNote.set_dimreg(d);      eUnityNote.set_ptr(&d->UnityNote);
527      eFineTune.set_dimreg(d);      eFineTune.set_ptr(&d->FineTune);
528      eGain.set_dimreg(d);      eGain.set_ptr(&d->Gain);
529      eGainPlus6.set_dimreg(d);      eGainPlus6.set_ptr(&d->Gain);
530      eSampleLoops.set_dimreg(d);      eSampleLoops.set_ptr(&d->SampleLoops);
531    
532      VCFEnabled_toggled();      VCFEnabled_toggled();
533    
Legend:
Removed from v.1117  
changed lines
  Added in v.1151
  ViewVC Help
Powered by ViewVC