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

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

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

revision 1396 by schoenebeck, Wed Oct 10 15:48:54 2007 UTC revision 1460 by persson, Sat Oct 27 12:28:33 2007 UTC
# Line 109  DimRegionEdit::DimRegionEdit() : Line 109  DimRegionEdit::DimRegionEdit() :
109      eSampleLoopLength("Loop size"),      eSampleLoopLength("Loop size"),
110      eSampleLoopType("Loop type"),      eSampleLoopType("Loop type"),
111      eSampleLoopInfinite("Infinite loop"),      eSampleLoopInfinite("Infinite loop"),
112      eSampleLoopPlayCount("Playback count")      eSampleLoopPlayCount("Playback count", 1),
113        update_model(0)
114  {  {
115        connect(eEG1PreAttack, &gig::DimensionRegion::EG1PreAttack);
116        connect(eEG1Attack, &gig::DimensionRegion::EG1Attack);
117        connect(eEG1Decay1, &gig::DimensionRegion::EG1Decay1);
118        connect(eEG1Decay2, &gig::DimensionRegion::EG1Decay2);
119        connect(eEG1InfiniteSustain, &gig::DimensionRegion::EG1InfiniteSustain);
120        connect(eEG1Sustain, &gig::DimensionRegion::EG1Sustain);
121        connect(eEG1Release, &gig::DimensionRegion::EG1Release);
122        connect(eEG1Hold, &gig::DimensionRegion::EG1Hold);
123        connect(eEG1Controller, &gig::DimensionRegion::EG1Controller);
124        connect(eEG1ControllerInvert, &gig::DimensionRegion::EG1ControllerInvert);
125        connect(eEG1ControllerAttackInfluence,
126                &gig::DimensionRegion::EG1ControllerAttackInfluence);
127        connect(eEG1ControllerDecayInfluence,
128                &gig::DimensionRegion::EG1ControllerDecayInfluence);
129        connect(eEG1ControllerReleaseInfluence,
130                &gig::DimensionRegion::EG1ControllerReleaseInfluence);
131        connect(eLFO1Frequency, &gig::DimensionRegion::LFO1Frequency);
132        connect(eLFO1InternalDepth, &gig::DimensionRegion::LFO1InternalDepth);
133        connect(eLFO1ControlDepth, &gig::DimensionRegion::LFO1ControlDepth);
134        connect(eLFO1Controller, &gig::DimensionRegion::LFO1Controller);
135        connect(eLFO1FlipPhase, &gig::DimensionRegion::LFO1FlipPhase);
136        connect(eLFO1Sync, &gig::DimensionRegion::LFO1Sync);
137        connect(eEG2PreAttack, &gig::DimensionRegion::EG2PreAttack);
138        connect(eEG2Attack, &gig::DimensionRegion::EG2Attack);
139        connect(eEG2Decay1, &gig::DimensionRegion::EG2Decay1);
140        connect(eEG2Decay2, &gig::DimensionRegion::EG2Decay2);
141        connect(eEG2InfiniteSustain, &gig::DimensionRegion::EG2InfiniteSustain);
142        connect(eEG2Sustain, &gig::DimensionRegion::EG2Sustain);
143        connect(eEG2Release, &gig::DimensionRegion::EG2Release);
144        connect(eEG2Controller, &gig::DimensionRegion::EG2Controller);
145        connect(eEG2ControllerInvert, &gig::DimensionRegion::EG2ControllerInvert);
146        connect(eEG2ControllerAttackInfluence,
147                &gig::DimensionRegion::EG2ControllerAttackInfluence);
148        connect(eEG2ControllerDecayInfluence,
149                &gig::DimensionRegion::EG2ControllerDecayInfluence);
150        connect(eEG2ControllerReleaseInfluence,
151                &gig::DimensionRegion::EG2ControllerReleaseInfluence);
152        connect(eLFO2Frequency, &gig::DimensionRegion::LFO2Frequency);
153        connect(eLFO2InternalDepth, &gig::DimensionRegion::LFO2InternalDepth);
154        connect(eLFO2ControlDepth, &gig::DimensionRegion::LFO2ControlDepth);
155        connect(eLFO2Controller, &gig::DimensionRegion::LFO2Controller);
156        connect(eLFO2FlipPhase, &gig::DimensionRegion::LFO2FlipPhase);
157        connect(eLFO2Sync, &gig::DimensionRegion::LFO2Sync);
158        connect(eEG3Attack, &gig::DimensionRegion::EG3Attack);
159        connect(eEG3Depth, &gig::DimensionRegion::EG3Depth);
160        connect(eLFO3Frequency, &gig::DimensionRegion::LFO3Frequency);
161        connect(eLFO3InternalDepth, &gig::DimensionRegion::LFO3InternalDepth);
162        connect(eLFO3ControlDepth, &gig::DimensionRegion::LFO3ControlDepth);
163        connect(eLFO3Controller, &gig::DimensionRegion::LFO3Controller);
164        connect(eLFO3Sync, &gig::DimensionRegion::LFO3Sync);
165        connect(eVCFEnabled, &gig::DimensionRegion::VCFEnabled);
166        connect(eVCFType, &gig::DimensionRegion::VCFType);
167        connect(eVCFCutoffController,
168                &gig::DimensionRegion::SetVCFCutoffController);
169        connect(eVCFCutoffControllerInvert,
170                &gig::DimensionRegion::VCFCutoffControllerInvert);
171        connect(eVCFCutoff, &gig::DimensionRegion::VCFCutoff);
172        connect(eVCFVelocityCurve, &gig::DimensionRegion::SetVCFVelocityCurve);
173        connect(eVCFVelocityScale, &gig::DimensionRegion::SetVCFVelocityScale);
174        connect(eVCFVelocityDynamicRange,
175                &gig::DimensionRegion::SetVCFVelocityDynamicRange);
176        connect(eVCFResonance, &gig::DimensionRegion::VCFResonance);
177        connect(eVCFResonanceDynamic, &gig::DimensionRegion::VCFResonanceDynamic);
178        connect(eVCFResonanceController,
179                &gig::DimensionRegion::VCFResonanceController);
180        connect(eVCFKeyboardTracking, &gig::DimensionRegion::VCFKeyboardTracking);
181        connect(eVCFKeyboardTrackingBreakpoint,
182                &gig::DimensionRegion::VCFKeyboardTrackingBreakpoint);
183        connect(eVelocityResponseCurve,
184                &gig::DimensionRegion::SetVelocityResponseCurve);
185        connect(eVelocityResponseDepth,
186                &gig::DimensionRegion::SetVelocityResponseDepth);
187        connect(eVelocityResponseCurveScaling,
188                &gig::DimensionRegion::SetVelocityResponseCurveScaling);
189        connect(eReleaseVelocityResponseCurve,
190                &gig::DimensionRegion::SetReleaseVelocityResponseCurve);
191        connect(eReleaseVelocityResponseDepth,
192                &gig::DimensionRegion::SetReleaseVelocityResponseDepth);
193        connect(eReleaseTriggerDecay, &gig::DimensionRegion::ReleaseTriggerDecay);
194        connect(eCrossfade_in_start, &DimRegionEdit::set_Crossfade_in_start);
195        connect(eCrossfade_in_end, &DimRegionEdit::set_Crossfade_in_end);
196        connect(eCrossfade_out_start, &DimRegionEdit::set_Crossfade_out_start);
197        connect(eCrossfade_out_end, &DimRegionEdit::set_Crossfade_out_end);
198        connect(ePitchTrack, &gig::DimensionRegion::PitchTrack);
199        connect(eDimensionBypass, &gig::DimensionRegion::DimensionBypass);
200        connect(ePan, &gig::DimensionRegion::Pan);
201        connect(eSelfMask, &gig::DimensionRegion::SelfMask);
202        connect(eAttenuationController,
203                &gig::DimensionRegion::AttenuationController);
204        connect(eInvertAttenuationController,
205                &gig::DimensionRegion::InvertAttenuationController);
206        connect(eAttenuationControllerThreshold,
207                &gig::DimensionRegion::AttenuationControllerThreshold);
208        connect(eChannelOffset, &gig::DimensionRegion::ChannelOffset);
209        connect(eSustainDefeat, &gig::DimensionRegion::SustainDefeat);
210        connect(eMSDecode, &gig::DimensionRegion::MSDecode);
211        connect(eSampleStartOffset, &gig::DimensionRegion::SampleStartOffset);
212        connect(eUnityNote, &DimRegionEdit::set_UnityNote);
213        connect(eFineTune, &DimRegionEdit::set_FineTune);
214        connect(eGain, &DimRegionEdit::set_Gain);
215        connect(eGainPlus6, &DimRegionEdit::set_Gain);
216        connect(eSampleLoopEnabled, &DimRegionEdit::set_LoopEnabled);
217        connect(eSampleLoopType, &DimRegionEdit::set_LoopType);
218        connect(eSampleLoopStart, &DimRegionEdit::set_LoopStart);
219        connect(eSampleLoopLength, &DimRegionEdit::set_LoopLength);
220        connect(eSampleLoopInfinite, &DimRegionEdit::set_LoopInfinite);
221        connect(eSampleLoopPlayCount, &DimRegionEdit::set_LoopPlayCount);
222    
223      for (int i = 0 ; i < 7 ; i++) {      for (int i = 0 ; i < 7 ; i++) {
224          table[i] = new Gtk::Table(3, 1);          table[i] = new Gtk::Table(3, 1);
225          table[i]->set_col_spacings(7);          table[i]->set_col_spacings(7);
# Line 389  DimRegionEdit::DimRegionEdit() : Line 498  DimRegionEdit::DimRegionEdit() :
498      nextPage();      nextPage();
499    
500    
501      eEG1InfiniteSustain.signal_toggled().connect(      eEG1InfiniteSustain.signal_value_changed().connect(
502          sigc::mem_fun(*this, &DimRegionEdit::EG1InfiniteSustain_toggled) );          sigc::mem_fun(*this, &DimRegionEdit::EG1InfiniteSustain_toggled));
503      eEG2InfiniteSustain.signal_toggled().connect(      eEG2InfiniteSustain.signal_value_changed().connect(
504          sigc::mem_fun(*this, &DimRegionEdit::EG2InfiniteSustain_toggled) );          sigc::mem_fun(*this, &DimRegionEdit::EG2InfiniteSustain_toggled));
505      eEG1Controller.signal_changed().connect(      eEG1Controller.signal_value_changed().connect(
506          sigc::mem_fun(*this, &DimRegionEdit::EG1Controller_changed) );          sigc::mem_fun(*this, &DimRegionEdit::EG1Controller_changed));
507      eEG2Controller.signal_changed().connect(      eEG2Controller.signal_value_changed().connect(
508          sigc::mem_fun(*this, &DimRegionEdit::EG2Controller_changed) );          sigc::mem_fun(*this, &DimRegionEdit::EG2Controller_changed));
509      eLFO1Controller.signal_changed().connect(      eLFO1Controller.signal_value_changed().connect(
510          sigc::mem_fun(*this, &DimRegionEdit::LFO1Controller_changed) );          sigc::mem_fun(*this, &DimRegionEdit::LFO1Controller_changed));
511      eLFO2Controller.signal_changed().connect(      eLFO2Controller.signal_value_changed().connect(
512          sigc::mem_fun(*this, &DimRegionEdit::LFO2Controller_changed) );          sigc::mem_fun(*this, &DimRegionEdit::LFO2Controller_changed));
513      eLFO3Controller.signal_changed().connect(      eLFO3Controller.signal_value_changed().connect(
514          sigc::mem_fun(*this, &DimRegionEdit::LFO3Controller_changed) );          sigc::mem_fun(*this, &DimRegionEdit::LFO3Controller_changed));
515      eAttenuationController.signal_changed().connect(      eAttenuationController.signal_value_changed().connect(
516          sigc::mem_fun(*this, &DimRegionEdit::AttenuationController_changed) );          sigc::mem_fun(*this, &DimRegionEdit::AttenuationController_changed));
517      eVCFEnabled.signal_toggled().connect(      eVCFEnabled.signal_value_changed().connect(
518          sigc::mem_fun(*this, &DimRegionEdit::VCFEnabled_toggled) );          sigc::mem_fun(*this, &DimRegionEdit::VCFEnabled_toggled));
519      eVCFCutoffController.signal_changed().connect(      eVCFCutoffController.signal_value_changed().connect(
520          sigc::mem_fun(*this, &DimRegionEdit::VCFCutoffController_changed) );          sigc::mem_fun(*this, &DimRegionEdit::VCFCutoffController_changed));
521      eVCFResonanceController.signal_changed().connect(      eVCFResonanceController.signal_value_changed().connect(
522          sigc::mem_fun(*this, &DimRegionEdit::VCFResonanceController_changed) );          sigc::mem_fun(*this, &DimRegionEdit::VCFResonanceController_changed));
523    
524      eCrossfade_in_start.signal_changed_by_user().connect(      eCrossfade_in_start.signal_value_changed().connect(
525          sigc::mem_fun(*this, &DimRegionEdit::crossfade1_changed));          sigc::mem_fun(*this, &DimRegionEdit::crossfade1_changed));
526      eCrossfade_in_end.signal_changed_by_user().connect(      eCrossfade_in_end.signal_value_changed().connect(
527          sigc::mem_fun(*this, &DimRegionEdit::crossfade2_changed));          sigc::mem_fun(*this, &DimRegionEdit::crossfade2_changed));
528      eCrossfade_out_start.signal_changed_by_user().connect(      eCrossfade_out_start.signal_value_changed().connect(
529          sigc::mem_fun(*this, &DimRegionEdit::crossfade3_changed));          sigc::mem_fun(*this, &DimRegionEdit::crossfade3_changed));
530      eCrossfade_out_end.signal_changed_by_user().connect(      eCrossfade_out_end.signal_value_changed().connect(
531          sigc::mem_fun(*this, &DimRegionEdit::crossfade4_changed));          sigc::mem_fun(*this, &DimRegionEdit::crossfade4_changed));
532    
533      eSampleLoopEnabled.signal_toggled().connect(      eSampleLoopEnabled.signal_value_changed().connect(
534          sigc::mem_fun(*this, &DimRegionEdit::loop_enabled_toggled));          sigc::mem_fun(*this, &DimRegionEdit::update_loop_elements));
535      eSampleLoopStart.signal_changed_by_user().connect(      eSampleLoopStart.signal_value_changed().connect(
536          sigc::mem_fun(*this, &DimRegionEdit::updateLoopElements));          sigc::mem_fun(*this, &DimRegionEdit::loop_start_changed));
537      eSampleLoopLength.signal_changed_by_user().connect(      eSampleLoopLength.signal_value_changed().connect(
538          sigc::mem_fun(*this, &DimRegionEdit::updateLoopElements));          sigc::mem_fun(*this, &DimRegionEdit::loop_length_changed));
539      eSampleLoopInfinite.signal_toggled().connect(      eSampleLoopInfinite.signal_value_changed().connect(
540          sigc::mem_fun(*this, &DimRegionEdit::loop_infinite_toggled));          sigc::mem_fun(*this, &DimRegionEdit::loop_infinite_toggled));
541    
542      append_page(*table[0], "Sample");      append_page(*table[0], "Sample");
# Line 498  void DimRegionEdit::addProp(BoolEntry& b Line 607  void DimRegionEdit::addProp(BoolEntry& b
607      table[pageno]->attach(boolentry.widget, 1, 3, rowno, rowno + 1,      table[pageno]->attach(boolentry.widget, 1, 3, rowno, rowno + 1,
608                            Gtk::FILL, Gtk::SHRINK);                            Gtk::FILL, Gtk::SHRINK);
609      rowno++;      rowno++;
     boolentry.signal_changed_by_user().connect(  
         sigc::bind(dimreg_changed_signal.make_slot(), sigc::ref(this->dimregion))  
     );  
610  }  }
611    
612  void DimRegionEdit::addProp(BoolEntryPlus6& boolentry)  void DimRegionEdit::addProp(BoolEntryPlus6& boolentry)
# Line 508  void DimRegionEdit::addProp(BoolEntryPlu Line 614  void DimRegionEdit::addProp(BoolEntryPlu
614      table[pageno]->attach(boolentry.widget, 1, 3, rowno, rowno + 1,      table[pageno]->attach(boolentry.widget, 1, 3, rowno, rowno + 1,
615                            Gtk::FILL, Gtk::SHRINK);                            Gtk::FILL, Gtk::SHRINK);
616      rowno++;      rowno++;
     boolentry.signal_changed_by_user().connect(  
         sigc::bind(dimreg_changed_signal.make_slot(), sigc::ref(this->dimregion))  
     );  
617  }  }
618    
619  void DimRegionEdit::addProp(LabelWidget& prop)  void DimRegionEdit::addProp(LabelWidget& prop)
# Line 520  void DimRegionEdit::addProp(LabelWidget& Line 623  void DimRegionEdit::addProp(LabelWidget&
623      table[pageno]->attach(prop.widget, 2, 3, rowno, rowno + 1,      table[pageno]->attach(prop.widget, 2, 3, rowno, rowno + 1,
624                            Gtk::EXPAND | Gtk::FILL, Gtk::SHRINK);                            Gtk::EXPAND | Gtk::FILL, Gtk::SHRINK);
625      rowno++;      rowno++;
     prop.signal_changed_by_user().connect(  
         sigc::bind(dimreg_changed_signal.make_slot(), sigc::ref(this->dimregion))  
     );  
626  }  }
627    
628    
# Line 530  void DimRegionEdit::set_dim_region(gig:: Line 630  void DimRegionEdit::set_dim_region(gig::
630  {  {
631      dimregion = d;      dimregion = d;
632    
     // disconnect connections to old dimregion, to avoid segfaults  
     connection_eVCFCutoffController.disconnect();  
     connection_eVCFVelocityCurve.disconnect();  
     connection_eVCFVelocityScale.disconnect();  
     connection_eVCFVelocityDynamicRange.disconnect();  
     connection_eVelocityResponseCurve.disconnect();  
     connection_eVelocityResponseDepth.disconnect();  
     connection_eVelocityResponseCurveScaling.disconnect();  
     connection_eReleaseVelocityResponseCurve.disconnect();  
     connection_eReleaseVelocityResponseDepth.disconnect();  
     connection_eGain.disconnect();  
   
633      set_sensitive(d);      set_sensitive(d);
634      if (!d) return;      if (!d) return;
635    
636      wSample->set_text(d->pSample ? d->pSample->pInfo->Name.c_str() : "NULL");      // TODO: Here is where we decide which dimregions that are going
637      eEG1PreAttack.set_ptr(&d->EG1PreAttack);      // to be modified when the user changes a parameter. For now, just
638      eEG1Attack.set_ptr(&d->EG1Attack);      // choose the shown dimregion.
639      eEG1Decay1.set_ptr(&d->EG1Decay1);      dimregs.clear();
640      eEG1Decay2.set_ptr(&d->EG1Decay2);      dimregs.insert(d);
641      eEG1InfiniteSustain.set_ptr(&d->EG1InfiniteSustain);  
642      eEG1Sustain.set_ptr(&d->EG1Sustain);      update_model++;
643      eEG1Release.set_ptr(&d->EG1Release);      eEG1PreAttack.set_value(d->EG1PreAttack);
644      eEG1Hold.set_ptr(&d->EG1Hold);      eEG1Attack.set_value(d->EG1Attack);
645      eEG1Controller.set_ptr(&d->EG1Controller);      eEG1Decay1.set_value(d->EG1Decay1);
646      eEG1ControllerInvert.set_ptr(&d->EG1ControllerInvert);      eEG1Decay2.set_value(d->EG1Decay2);
647      eEG1ControllerAttackInfluence.set_ptr(&d->EG1ControllerAttackInfluence);      eEG1InfiniteSustain.set_value(d->EG1InfiniteSustain);
648      eEG1ControllerDecayInfluence.set_ptr(&d->EG1ControllerDecayInfluence);      eEG1Sustain.set_value(d->EG1Sustain);
649      eEG1ControllerReleaseInfluence.set_ptr(&d->EG1ControllerReleaseInfluence);      eEG1Release.set_value(d->EG1Release);
650      eLFO1Frequency.set_ptr(&d->LFO1Frequency);      eEG1Hold.set_value(d->EG1Hold);
651      eLFO1InternalDepth.set_ptr(&d->LFO1InternalDepth);      eEG1Controller.set_value(d->EG1Controller);
652      eLFO1ControlDepth.set_ptr(&d->LFO1ControlDepth);      eEG1ControllerInvert.set_value(d->EG1ControllerInvert);
653      eLFO1Controller.set_ptr(&d->LFO1Controller);      eEG1ControllerAttackInfluence.set_value(d->EG1ControllerAttackInfluence);
654      eLFO1FlipPhase.set_ptr(&d->LFO1FlipPhase);      eEG1ControllerDecayInfluence.set_value(d->EG1ControllerDecayInfluence);
655      eLFO1Sync.set_ptr(&d->LFO1Sync);      eEG1ControllerReleaseInfluence.set_value(d->EG1ControllerReleaseInfluence);
656      eEG2PreAttack.set_ptr(&d->EG2PreAttack);      eLFO1Frequency.set_value(d->LFO1Frequency);
657      eEG2Attack.set_ptr(&d->EG2Attack);      eLFO1InternalDepth.set_value(d->LFO1InternalDepth);
658      eEG2Decay1.set_ptr(&d->EG2Decay1);      eLFO1ControlDepth.set_value(d->LFO1ControlDepth);
659      eEG2Decay2.set_ptr(&d->EG2Decay2);      eLFO1Controller.set_value(d->LFO1Controller);
660      eEG2InfiniteSustain.set_ptr(&d->EG2InfiniteSustain);      eLFO1FlipPhase.set_value(d->LFO1FlipPhase);
661      eEG2Sustain.set_ptr(&d->EG2Sustain);      eLFO1Sync.set_value(d->LFO1Sync);
662      eEG2Release.set_ptr(&d->EG2Release);      eEG2PreAttack.set_value(d->EG2PreAttack);
663      eEG2Controller.set_ptr(&d->EG2Controller);      eEG2Attack.set_value(d->EG2Attack);
664      eEG2ControllerInvert.set_ptr(&d->EG2ControllerInvert);      eEG2Decay1.set_value(d->EG2Decay1);
665      eEG2ControllerAttackInfluence.set_ptr(&d->EG2ControllerAttackInfluence);      eEG2Decay2.set_value(d->EG2Decay2);
666      eEG2ControllerDecayInfluence.set_ptr(&d->EG2ControllerDecayInfluence);      eEG2InfiniteSustain.set_value(d->EG2InfiniteSustain);
667      eEG2ControllerReleaseInfluence.set_ptr(&d->EG2ControllerReleaseInfluence);      eEG2Sustain.set_value(d->EG2Sustain);
668      eLFO2Frequency.set_ptr(&d->LFO2Frequency);      eEG2Release.set_value(d->EG2Release);
669      eLFO2InternalDepth.set_ptr(&d->LFO2InternalDepth);      eEG2Controller.set_value(d->EG2Controller);
670      eLFO2ControlDepth.set_ptr(&d->LFO2ControlDepth);      eEG2ControllerInvert.set_value(d->EG2ControllerInvert);
671      eLFO2Controller.set_ptr(&d->LFO2Controller);      eEG2ControllerAttackInfluence.set_value(d->EG2ControllerAttackInfluence);
672      eLFO2FlipPhase.set_ptr(&d->LFO2FlipPhase);      eEG2ControllerDecayInfluence.set_value(d->EG2ControllerDecayInfluence);
673      eLFO2Sync.set_ptr(&d->LFO2Sync);      eEG2ControllerReleaseInfluence.set_value(d->EG2ControllerReleaseInfluence);
674      eEG3Attack.set_ptr(&d->EG3Attack);      eLFO2Frequency.set_value(d->LFO2Frequency);
675      eEG3Depth.set_ptr(&d->EG3Depth);      eLFO2InternalDepth.set_value(d->LFO2InternalDepth);
676      eLFO3Frequency.set_ptr(&d->LFO3Frequency);      eLFO2ControlDepth.set_value(d->LFO2ControlDepth);
677      eLFO3InternalDepth.set_ptr(&d->LFO3InternalDepth);      eLFO2Controller.set_value(d->LFO2Controller);
678      eLFO3ControlDepth.set_ptr(&d->LFO3ControlDepth);      eLFO2FlipPhase.set_value(d->LFO2FlipPhase);
679      eLFO3Controller.set_ptr(&d->LFO3Controller);      eLFO2Sync.set_value(d->LFO2Sync);
680      eLFO3Sync.set_ptr(&d->LFO3Sync);      eEG3Attack.set_value(d->EG3Attack);
681      eVCFEnabled.set_ptr(&d->VCFEnabled);      eEG3Depth.set_value(d->EG3Depth);
682      eVCFType.set_ptr(&d->VCFType);      eLFO3Frequency.set_value(d->LFO3Frequency);
683      eVCFCutoffController.set_ptr(&d->VCFCutoffController);      eLFO3InternalDepth.set_value(d->LFO3InternalDepth);
684      connection_eVCFCutoffController =      eLFO3ControlDepth.set_value(d->LFO3ControlDepth);
685          eVCFCutoffController.signal_value_changed().connect(      eLFO3Controller.set_value(d->LFO3Controller);
686              sigc::mem_fun(d, &gig::DimensionRegion::SetVCFCutoffController)      eLFO3Sync.set_value(d->LFO3Sync);
687          );      eVCFEnabled.set_value(d->VCFEnabled);
688      eVCFCutoffControllerInvert.set_ptr(&d->VCFCutoffControllerInvert);      eVCFType.set_value(d->VCFType);
689      eVCFCutoff.set_ptr(&d->VCFCutoff);      eVCFCutoffController.set_value(d->VCFCutoffController);
690      eVCFVelocityCurve.set_ptr(&d->VCFVelocityCurve);      eVCFCutoffControllerInvert.set_value(d->VCFCutoffControllerInvert);
691      connection_eVCFVelocityCurve =      eVCFCutoff.set_value(d->VCFCutoff);
692          eVCFVelocityCurve.signal_value_changed().connect(      eVCFVelocityCurve.set_value(d->VCFVelocityCurve);
693              sigc::mem_fun(d, &gig::DimensionRegion::SetVCFVelocityCurve)      eVCFVelocityScale.set_value(d->VCFVelocityScale);
694          );      eVCFVelocityDynamicRange.set_value(d->VCFVelocityDynamicRange);
695      eVCFVelocityScale.set_ptr(&d->VCFVelocityScale);      eVCFResonance.set_value(d->VCFResonance);
696      connection_eVCFVelocityScale =      eVCFResonanceDynamic.set_value(d->VCFResonanceDynamic);
697          eVCFVelocityScale.signal_value_changed().connect(      eVCFResonanceController.set_value(d->VCFResonanceController);
698              sigc::mem_fun(d, &gig::DimensionRegion::SetVCFVelocityScale)      eVCFKeyboardTracking.set_value(d->VCFKeyboardTracking);
699          );      eVCFKeyboardTrackingBreakpoint.set_value(d->VCFKeyboardTrackingBreakpoint);
700      eVCFVelocityDynamicRange.set_ptr(&d->VCFVelocityDynamicRange);      eVelocityResponseCurve.set_value(d->VelocityResponseCurve);
701      connection_eVCFVelocityDynamicRange =      eVelocityResponseDepth.set_value(d->VelocityResponseDepth);
702          eVCFVelocityDynamicRange.signal_value_changed().connect(      eVelocityResponseCurveScaling.set_value(d->VelocityResponseCurveScaling);
703              sigc::mem_fun(d, &gig::DimensionRegion::SetVCFVelocityDynamicRange)      eReleaseVelocityResponseCurve.set_value(d->ReleaseVelocityResponseCurve);
704          );      eReleaseVelocityResponseDepth.set_value(d->ReleaseVelocityResponseDepth);
705      eVCFResonance.set_ptr(&d->VCFResonance);      eReleaseTriggerDecay.set_value(d->ReleaseTriggerDecay);
706      eVCFResonanceDynamic.set_ptr(&d->VCFResonanceDynamic);      eCrossfade_in_start.set_value(d->Crossfade.in_start);
707      eVCFResonanceController.set_ptr(&d->VCFResonanceController);      eCrossfade_in_end.set_value(d->Crossfade.in_end);
708      eVCFKeyboardTracking.set_ptr(&d->VCFKeyboardTracking);      eCrossfade_out_start.set_value(d->Crossfade.out_start);
709      eVCFKeyboardTrackingBreakpoint.set_ptr(&d->VCFKeyboardTrackingBreakpoint);      eCrossfade_out_end.set_value(d->Crossfade.out_end);
710      eVelocityResponseCurve.set_ptr(&d->VelocityResponseCurve);      ePitchTrack.set_value(d->PitchTrack);
711      connection_eVelocityResponseCurve =      eDimensionBypass.set_value(d->DimensionBypass);
712          eVelocityResponseCurve.signal_value_changed().connect(      ePan.set_value(d->Pan);
713              sigc::mem_fun(d, &gig::DimensionRegion::SetVelocityResponseCurve)      eSelfMask.set_value(d->SelfMask);
714          );      eAttenuationController.set_value(d->AttenuationController);
715      eVelocityResponseDepth.set_ptr(&d->VelocityResponseDepth);      eInvertAttenuationController.set_value(d->InvertAttenuationController);
716      connection_eVelocityResponseDepth =      eAttenuationControllerThreshold.set_value(d->AttenuationControllerThreshold);
717          eVelocityResponseDepth.signal_value_changed().connect(      eChannelOffset.set_value(d->ChannelOffset);
718              sigc::mem_fun(d, &gig::DimensionRegion::SetVelocityResponseDepth)      eSustainDefeat.set_value(d->SustainDefeat);
719          );      eMSDecode.set_value(d->MSDecode);
720      eVelocityResponseCurveScaling.set_ptr(&d->VelocityResponseCurveScaling);      eSampleStartOffset.set_value(d->SampleStartOffset);
721      connection_eVelocityResponseCurveScaling =      eUnityNote.set_value(d->UnityNote);
722          eVelocityResponseCurveScaling.signal_value_changed().connect(      eFineTune.set_value(d->FineTune);
723              sigc::mem_fun(d, &gig::DimensionRegion::SetVelocityResponseCurveScaling)      eGain.set_value(d->Gain);
724          );      eGainPlus6.set_value(d->Gain);
725      eReleaseVelocityResponseCurve.set_ptr(&d->ReleaseVelocityResponseCurve);      eSampleLoopEnabled.set_value(d->SampleLoops);
726      connection_eReleaseVelocityResponseCurve =      eSampleLoopType.set_value(
727          eReleaseVelocityResponseCurve.signal_value_changed().connect(          d->SampleLoops ? d->pSampleLoops[0].LoopType : 0);
728              sigc::mem_fun(d, &gig::DimensionRegion::SetReleaseVelocityResponseCurve)      eSampleLoopStart.set_value(
729          );          d->SampleLoops ? d->pSampleLoops[0].LoopStart : 0);
730      eReleaseVelocityResponseDepth.set_ptr(&d->ReleaseVelocityResponseDepth);      eSampleLoopLength.set_value(
731      connection_eReleaseVelocityResponseDepth =          d->SampleLoops ? d->pSampleLoops[0].LoopLength : 0);
732          eReleaseVelocityResponseDepth.signal_value_changed().connect(      eSampleLoopInfinite.set_value(
733              sigc::mem_fun(d, &gig::DimensionRegion::SetReleaseVelocityResponseDepth)          d->pSample && d->pSample->LoopPlayCount == 0);
734          );      eSampleLoopPlayCount.set_value(
735      eReleaseTriggerDecay.set_ptr(&d->ReleaseTriggerDecay);          d->pSample ? d->pSample->LoopPlayCount : 0);
736        update_model--;
     eCrossfade_in_start.set_ptr(0);  
     eCrossfade_in_end.set_ptr(0);  
     eCrossfade_out_start.set_ptr(0);  
     eCrossfade_out_end.set_ptr(0);  
     eCrossfade_in_start.set_ptr(&d->Crossfade.in_start);  
     eCrossfade_in_end.set_ptr(&d->Crossfade.in_end);  
     eCrossfade_out_start.set_ptr(&d->Crossfade.out_start);  
     eCrossfade_out_end.set_ptr(&d->Crossfade.out_end);  
   
     ePitchTrack.set_ptr(&d->PitchTrack);  
     eDimensionBypass.set_ptr(&d->DimensionBypass);  
     ePan.set_ptr(&d->Pan);  
     eSelfMask.set_ptr(&d->SelfMask);  
     eAttenuationController.set_ptr(&d->AttenuationController);  
     eInvertAttenuationController.set_ptr(&d->InvertAttenuationController);  
     eAttenuationControllerThreshold.set_ptr(&d->AttenuationControllerThreshold);  
     eChannelOffset.set_ptr(&d->ChannelOffset);  
     eSustainDefeat.set_ptr(&d->SustainDefeat);  
     eMSDecode.set_ptr(&d->MSDecode);  
     eSampleStartOffset.set_ptr(&d->SampleStartOffset);  
     eUnityNote.set_ptr(&d->UnityNote);  
     eFineTune.set_ptr(&d->FineTune);  
     eGain.set_ptr(&d->Gain);  
     connection_eGain =  
         eGain.signal_value_changed().connect(  
             sigc::mem_fun(d, &gig::DimensionRegion::SetGain)  
         );  
     eGainPlus6.set_ptr(&d->Gain);  
737    
738      eSampleLoopEnabled.set_active(d->SampleLoops);      wSample->set_text(d->pSample ? d->pSample->pInfo->Name.c_str() : "NULL");
     updateLoopElements();  
739    
740        update_loop_elements();
741      VCFEnabled_toggled();      VCFEnabled_toggled();
742  }  }
743    
744    
745  void DimRegionEdit::VCFEnabled_toggled()  void DimRegionEdit::VCFEnabled_toggled()
746  {  {
747      bool sensitive = eVCFEnabled.get_active();      bool sensitive = eVCFEnabled.get_value();
748      eVCFType.set_sensitive(sensitive);      eVCFType.set_sensitive(sensitive);
749      eVCFCutoffController.set_sensitive(sensitive);      eVCFCutoffController.set_sensitive(sensitive);
750      eVCFVelocityCurve.set_sensitive(sensitive);      eVCFVelocityCurve.set_sensitive(sensitive);
# Line 729  void DimRegionEdit::VCFEnabled_toggled() Line 790  void DimRegionEdit::VCFEnabled_toggled()
790    
791  void DimRegionEdit::VCFCutoffController_changed()  void DimRegionEdit::VCFCutoffController_changed()
792  {  {
793      int rowno = eVCFCutoffController.get_active_row_number();      gig::vcf_cutoff_ctrl_t ctrl = eVCFCutoffController.get_value();
794      bool hasController = rowno != 0 && rowno != 1;      bool hasController = ctrl != gig::vcf_cutoff_ctrl_none && ctrl != gig::vcf_cutoff_ctrl_none2;
795    
796      eVCFCutoffControllerInvert.set_sensitive(hasController);      eVCFCutoffControllerInvert.set_sensitive(hasController);
797      eVCFCutoff.set_sensitive(!hasController);      eVCFCutoff.set_sensitive(!hasController);
# Line 741  void DimRegionEdit::VCFCutoffController_ Line 802  void DimRegionEdit::VCFCutoffController_
802    
803  void DimRegionEdit::VCFResonanceController_changed()  void DimRegionEdit::VCFResonanceController_changed()
804  {  {
805      bool hasController = eVCFResonanceController.get_active_row_number() != 0;      bool hasController = eVCFResonanceController.get_value() != gig::vcf_res_ctrl_none;
806      eVCFResonance.set_sensitive(!hasController);      eVCFResonance.set_sensitive(!hasController);
807  }  }
808    
809  void DimRegionEdit::EG1InfiniteSustain_toggled()  void DimRegionEdit::EG1InfiniteSustain_toggled()
810  {  {
811      bool infSus = eEG1InfiniteSustain.get_active();      bool infSus = eEG1InfiniteSustain.get_value();
812      eEG1Decay2.set_sensitive(!infSus);      eEG1Decay2.set_sensitive(!infSus);
813  }  }
814    
815  void DimRegionEdit::EG2InfiniteSustain_toggled()  void DimRegionEdit::EG2InfiniteSustain_toggled()
816  {  {
817      bool infSus = eEG2InfiniteSustain.get_active();      bool infSus = eEG2InfiniteSustain.get_value();
818      eEG2Decay2.set_sensitive(!infSus);      eEG2Decay2.set_sensitive(!infSus);
819  }  }
820    
821  void DimRegionEdit::EG1Controller_changed()  void DimRegionEdit::EG1Controller_changed()
822  {  {
823      bool hasController = eEG1Controller.get_active_row_number() != 0;      bool hasController = eEG1Controller.get_value().type != gig::leverage_ctrl_t::type_none;
824      eEG1ControllerInvert.set_sensitive(hasController);      eEG1ControllerInvert.set_sensitive(hasController);
825  }  }
826    
827  void DimRegionEdit::EG2Controller_changed()  void DimRegionEdit::EG2Controller_changed()
828  {  {
829      bool hasController = eEG2Controller.get_active_row_number() != 0;      bool hasController = eEG2Controller.get_value().type != gig::leverage_ctrl_t::type_none;
830      eEG2ControllerInvert.set_sensitive(hasController);      eEG2ControllerInvert.set_sensitive(hasController);
831  }  }
832    
833  void DimRegionEdit::AttenuationController_changed()  void DimRegionEdit::AttenuationController_changed()
834  {  {
835      bool hasController = eAttenuationController.get_active_row_number() != 0;      bool hasController =
836            eAttenuationController.get_value().type != gig::leverage_ctrl_t::type_none;
837      eInvertAttenuationController.set_sensitive(hasController);      eInvertAttenuationController.set_sensitive(hasController);
838      eAttenuationControllerThreshold.set_sensitive(hasController);      eAttenuationControllerThreshold.set_sensitive(hasController);
839      eCrossfade_in_start.set_sensitive(hasController);      eCrossfade_in_start.set_sensitive(hasController);
# Line 782  void DimRegionEdit::AttenuationControlle Line 844  void DimRegionEdit::AttenuationControlle
844    
845  void DimRegionEdit::LFO1Controller_changed()  void DimRegionEdit::LFO1Controller_changed()
846  {  {
847      int rowno = eLFO1Controller.get_active_row_number();      gig::lfo1_ctrl_t ctrl = eLFO1Controller.get_value();
848      eLFO1ControlDepth.set_sensitive(rowno != 0);      eLFO1ControlDepth.set_sensitive(ctrl != gig::lfo1_ctrl_internal);
849      eLFO1InternalDepth.set_sensitive(rowno != 1 && rowno != 2);      eLFO1InternalDepth.set_sensitive(ctrl != gig::lfo1_ctrl_modwheel &&
850                                         ctrl != gig::lfo1_ctrl_breath);
851  }  }
852    
853  void DimRegionEdit::LFO2Controller_changed()  void DimRegionEdit::LFO2Controller_changed()
854  {  {
855      int rowno = eLFO2Controller.get_active_row_number();      gig::lfo2_ctrl_t ctrl = eLFO2Controller.get_value();
856      eLFO2ControlDepth.set_sensitive(rowno != 0);      eLFO2ControlDepth.set_sensitive(ctrl != gig::lfo2_ctrl_internal);
857      eLFO2InternalDepth.set_sensitive(rowno != 1 && rowno != 2);      eLFO2InternalDepth.set_sensitive(ctrl != gig::lfo2_ctrl_modwheel &&
858                                         ctrl != gig::lfo2_ctrl_foot);
859  }  }
860    
861  void DimRegionEdit::LFO3Controller_changed()  void DimRegionEdit::LFO3Controller_changed()
862  {  {
863      int rowno = eLFO3Controller.get_active_row_number();      gig::lfo3_ctrl_t ctrl = eLFO3Controller.get_value();
864      eLFO3ControlDepth.set_sensitive(rowno != 0);      eLFO3ControlDepth.set_sensitive(ctrl != gig::lfo3_ctrl_internal);
865      eLFO3InternalDepth.set_sensitive(rowno != 1 && rowno != 2);      eLFO3InternalDepth.set_sensitive(ctrl != gig::lfo3_ctrl_modwheel &&
866                                         ctrl != gig::lfo3_ctrl_aftertouch);
867  }  }
868    
869  void DimRegionEdit::crossfade1_changed()  void DimRegionEdit::crossfade1_changed()
870  {  {
871      double c1 = eCrossfade_in_start.get_value();      update_model++;
872      double c2 = eCrossfade_in_end.get_value();      eCrossfade_in_end.set_value(dimregion->Crossfade.in_end);
873      if (c1 > c2) eCrossfade_in_end.set_value(c1);      eCrossfade_out_start.set_value(dimregion->Crossfade.out_start);
874        eCrossfade_out_end.set_value(dimregion->Crossfade.out_end);
875        update_model--;
876  }  }
877    
878  void DimRegionEdit::crossfade2_changed()  void DimRegionEdit::crossfade2_changed()
879  {  {
880      double c1 = eCrossfade_in_start.get_value();      update_model++;
881      double c2 = eCrossfade_in_end.get_value();      eCrossfade_in_start.set_value(dimregion->Crossfade.in_start);
882      double c3 = eCrossfade_out_start.get_value();      eCrossfade_out_start.set_value(dimregion->Crossfade.out_start);
883        eCrossfade_out_end.set_value(dimregion->Crossfade.out_end);
884      if (c2 < c1) eCrossfade_in_start.set_value(c2);      update_model--;
     if (c2 > c3) eCrossfade_out_start.set_value(c2);  
885  }  }
886    
887  void DimRegionEdit::crossfade3_changed()  void DimRegionEdit::crossfade3_changed()
888  {  {
889      double c2 = eCrossfade_in_end.get_value();      update_model++;
890      double c3 = eCrossfade_out_start.get_value();      eCrossfade_in_start.set_value(dimregion->Crossfade.in_start);
891      double c4 = eCrossfade_out_end.get_value();      eCrossfade_in_end.set_value(dimregion->Crossfade.in_end);
892        eCrossfade_out_end.set_value(dimregion->Crossfade.out_end);
893      if (c3 < c2) eCrossfade_in_end.set_value(c3);      update_model--;
     if (c3 > c4) eCrossfade_out_end.set_value(c3);  
894  }  }
895    
896  void DimRegionEdit::crossfade4_changed()  void DimRegionEdit::crossfade4_changed()
897  {  {
898      double c3 = eCrossfade_out_start.get_value();      update_model++;
899      double c4 = eCrossfade_out_end.get_value();      eCrossfade_in_start.set_value(dimregion->Crossfade.in_start);
900        eCrossfade_in_end.set_value(dimregion->Crossfade.in_end);
901      if (c4 < c3) eCrossfade_out_start.set_value(c4);      eCrossfade_out_start.set_value(dimregion->Crossfade.out_start);
902  }      update_model--;
   
 void DimRegionEdit::loop_enabled_toggled()  
 {  
     const bool active = eSampleLoopEnabled.get_active();  
     if (active) {  
         // create a new sample loop in case there is none yet  
         if (!dimregion->SampleLoops) {  
             DLS::sample_loop_t loop;  
             loop.LoopType   = gig::loop_type_normal;  
             // loop the whole sample by default  
             loop.LoopStart  = 0;  
             loop.LoopLength =  
                 (dimregion->pSample) ? dimregion->pSample->GetSize() : 0;  
             dimreg_to_be_changed_signal.emit(dimregion);  
             dimregion->AddSampleLoop(&loop);  
             dimreg_changed_signal.emit(dimregion);  
         }  
     } else {  
         if (dimregion->SampleLoops) {  
             dimreg_to_be_changed_signal.emit(dimregion);  
             // delete ALL existing sample loops  
             while (dimregion->SampleLoops) {  
                 dimregion->DeleteSampleLoop(&dimregion->pSampleLoops[0]);  
             }  
             dimreg_changed_signal.emit(dimregion);  
         }  
     }  
     updateLoopElements();  
903  }  }
904    
905  void DimRegionEdit::updateLoopElements()  void DimRegionEdit::update_loop_elements()
906  {  {
907      const bool active = eSampleLoopEnabled.get_active();      update_model++;
908        const bool active = eSampleLoopEnabled.get_value();
909      eSampleLoopStart.set_sensitive(active);      eSampleLoopStart.set_sensitive(active);
910      eSampleLoopLength.set_sensitive(active);      eSampleLoopLength.set_sensitive(active);
911      eSampleLoopType.set_sensitive(active);      eSampleLoopType.set_sensitive(active);
912      eSampleLoopInfinite.set_sensitive(active && dimregion && dimregion->pSample);      eSampleLoopInfinite.set_sensitive(active && dimregion && dimregion->pSample);
913      eSampleLoopStart.set_ptr(0);      // sample loop shall never be longer than the actual sample size
914      eSampleLoopLength.set_ptr(0);      loop_start_changed();
915      eSampleLoopPlayCount.set_ptr(0);      loop_length_changed();
916        eSampleLoopStart.set_value(
917            dimregion->SampleLoops ? dimregion->pSampleLoops[0].LoopStart : 0);
918        eSampleLoopLength.set_value(
919            dimregion->SampleLoops ? dimregion->pSampleLoops[0].LoopLength : 0);
920    
921        eSampleLoopInfinite.set_value(
922            dimregion->pSample && dimregion->pSample->LoopPlayCount == 0);
923    
924        loop_infinite_toggled();
925        update_model--;
926    }
927    
928    void DimRegionEdit::loop_start_changed() {
929        if (dimregion && dimregion->SampleLoops) {
930            eSampleLoopLength.set_upper(dimregion->pSample ?
931                                        dimregion->pSample->SamplesTotal -
932                                        dimregion->pSampleLoops[0].LoopStart : 0);
933        }
934    }
935    
936    void DimRegionEdit::loop_length_changed() {
937      if (dimregion && dimregion->SampleLoops) {      if (dimregion && dimregion->SampleLoops) {
938          eSampleLoopStart.set_ptr(&dimregion->pSampleLoops[0].LoopStart);          eSampleLoopStart.set_upper(dimregion->pSample ?
939          eSampleLoopLength.set_ptr(&dimregion->pSampleLoops[0].LoopLength);                                     dimregion->pSample->SamplesTotal -
940          eSampleLoopType.set_ptr(&dimregion->pSampleLoops[0].LoopType);                                     dimregion->pSampleLoops[0].LoopLength : 0);
         eSampleLoopInfinite.set_active(  
             dimregion->pSample && !dimregion->pSample->LoopPlayCount  
         );  
         // updated enabled state of loop play count widget  
         loop_infinite_toggled();  
   
         eSampleLoopPlayCount.set_ptr(  
             (dimregion->pSample) ? &dimregion->pSample->LoopPlayCount : 0  
         );  
   
         // sample loop shall never be longer than the actual sample size  
         eSampleLoopStart.set_upper(  
             (dimregion->pSample)  
                 ? dimregion->pSample->SamplesTotal -  
                   dimregion->pSampleLoops[0].LoopLength  
                 : 0  
         );  
         eSampleLoopLength.set_upper(  
             (dimregion->pSample)  
                 ? dimregion->pSample->SamplesTotal -  
                   dimregion->pSampleLoops[0].LoopStart  
                 : 0  
         );  
     } else { // no sample loop(s)  
         eSampleLoopType.set_ptr(0);  
         // updated enabled state of loop play count widget  
         loop_infinite_toggled();  
941      }      }
942  }  }
943    
944  void DimRegionEdit::loop_infinite_toggled() {  void DimRegionEdit::loop_infinite_toggled() {
945      eSampleLoopPlayCount.set_sensitive(      eSampleLoopPlayCount.set_sensitive(
946          dimregion && dimregion->pSample &&          dimregion && dimregion->pSample &&
947          !eSampleLoopInfinite.get_active() &&          !eSampleLoopInfinite.get_value() &&
948           eSampleLoopEnabled.get_active()          eSampleLoopEnabled.get_value()
949      );      );
950      if (eSampleLoopInfinite.get_active())      update_model++;
951          eSampleLoopPlayCount.set_value(0);      eSampleLoopPlayCount.set_value(
952      else if (!eSampleLoopPlayCount.get_value())          dimregion->pSample ? dimregion->pSample->LoopPlayCount : 0);
953          eSampleLoopPlayCount.set_value(1);      update_model--;
954  }  }
955    
956  bool DimRegionEdit::set_sample(gig::Sample* sample)  bool DimRegionEdit::set_sample(gig::Sample* sample)
# Line 954  bool DimRegionEdit::set_sample(gig::Samp Line 985  bool DimRegionEdit::set_sample(gig::Samp
985          }          }
986    
987          // update ui          // update ui
988            update_model++;
989          wSample->set_text(dimregion->pSample->pInfo->Name);          wSample->set_text(dimregion->pSample->pInfo->Name);
990          eUnityNote.set_ptr(&dimregion->UnityNote);          eUnityNote.set_value(dimregion->UnityNote);
991          eFineTune.set_ptr(&dimregion->FineTune);          eFineTune.set_value(dimregion->FineTune);
992          eSampleLoopEnabled.set_active(dimregion->SampleLoops);          eSampleLoopEnabled.set_value(dimregion->SampleLoops);
993          updateLoopElements();          update_loop_elements();
994            update_model--;
995    
996          sample_ref_changed_signal.emit(oldref, sample);          sample_ref_changed_signal.emit(oldref, sample);
997          // currently commented because we're sending a similar signal in MainWindow::on_sample_label_drop_drag_data_received()          // currently commented because we're sending a similar signal in MainWindow::on_sample_label_drop_drag_data_received()
# Line 979  sigc::signal<void, gig::DimensionRegion* Line 1012  sigc::signal<void, gig::DimensionRegion*
1012  sigc::signal<void, gig::Sample*/*old*/, gig::Sample*/*new*/>& DimRegionEdit::signal_sample_ref_changed() {  sigc::signal<void, gig::Sample*/*old*/, gig::Sample*/*new*/>& DimRegionEdit::signal_sample_ref_changed() {
1013      return sample_ref_changed_signal;      return sample_ref_changed_signal;
1014  }  }
1015    
1016    
1017    void DimRegionEdit::set_UnityNote(gig::DimensionRegion* d, uint8_t value)
1018    {
1019        d->UnityNote = value;
1020    }
1021    
1022    void DimRegionEdit::set_FineTune(gig::DimensionRegion* d, int16_t value)
1023    {
1024        d->FineTune = value;
1025    }
1026    
1027    void DimRegionEdit::set_Crossfade_in_start(gig::DimensionRegion* d,
1028                                               uint8_t value)
1029    {
1030        d->Crossfade.in_start = value;
1031        if (d->Crossfade.in_end < value) set_Crossfade_in_end(d, value);
1032    }
1033    
1034    void DimRegionEdit::set_Crossfade_in_end(gig::DimensionRegion* d,
1035                                             uint8_t value)
1036    {
1037        d->Crossfade.in_end = value;
1038        if (value < d->Crossfade.in_start) set_Crossfade_in_start(d, value);
1039        if (value > d->Crossfade.out_start) set_Crossfade_out_start(d, value);
1040    }
1041    
1042    void DimRegionEdit::set_Crossfade_out_start(gig::DimensionRegion* d,
1043                                                uint8_t value)
1044    {
1045        d->Crossfade.out_start = value;
1046        if (value < d->Crossfade.in_end) set_Crossfade_in_end(d, value);
1047        if (value > d->Crossfade.out_end) set_Crossfade_out_end(d, value);
1048    }
1049    
1050    void DimRegionEdit::set_Crossfade_out_end(gig::DimensionRegion* d,
1051                                              uint8_t value)
1052    {
1053        d->Crossfade.out_end = value;
1054        if (value < d->Crossfade.out_start) set_Crossfade_out_start(d, value);
1055    }
1056    
1057    void DimRegionEdit::set_Gain(gig::DimensionRegion* d, int32_t value)
1058    {
1059        d->SetGain(value);
1060    }
1061    
1062    void DimRegionEdit::set_LoopEnabled(gig::DimensionRegion* d, bool value)
1063    {
1064        if (value) {
1065            // create a new sample loop in case there is none yet
1066            if (!d->SampleLoops) {
1067                DLS::sample_loop_t loop;
1068                loop.LoopType = gig::loop_type_normal;
1069                // loop the whole sample by default
1070                loop.LoopStart  = 0;
1071                loop.LoopLength =
1072                    (d->pSample) ? d->pSample->SamplesTotal : 0;
1073                dimreg_to_be_changed_signal.emit(d);
1074                d->AddSampleLoop(&loop);
1075                dimreg_changed_signal.emit(d);
1076            }
1077        } else {
1078            if (d->SampleLoops) {
1079                dimreg_to_be_changed_signal.emit(d);
1080                // delete ALL existing sample loops
1081                while (d->SampleLoops) {
1082                    d->DeleteSampleLoop(&d->pSampleLoops[0]);
1083                }
1084                dimreg_changed_signal.emit(d);
1085            }
1086        }
1087    }
1088    
1089    void DimRegionEdit::set_LoopType(gig::DimensionRegion* d, uint32_t value)
1090    {
1091        if (d->SampleLoops) d->pSampleLoops[0].LoopType = value;
1092    }
1093    
1094    void DimRegionEdit::set_LoopStart(gig::DimensionRegion* d, uint32_t value)
1095    {
1096        if (d->SampleLoops) {
1097            d->pSampleLoops[0].LoopStart =
1098                d->pSample ?
1099                std::min(value, uint32_t(d->pSample->SamplesTotal -
1100                                         d->pSampleLoops[0].LoopLength)) :
1101                0;
1102        }
1103    }
1104    
1105    void DimRegionEdit::set_LoopLength(gig::DimensionRegion* d, uint32_t value)
1106    {
1107        if (d->SampleLoops) {
1108            d->pSampleLoops[0].LoopLength =
1109                d->pSample ?
1110                std::min(value, uint32_t(d->pSample->SamplesTotal -
1111                                         d->pSampleLoops[0].LoopStart)) :
1112                0;
1113        }
1114    }
1115    
1116    void DimRegionEdit::set_LoopInfinite(gig::DimensionRegion* d, bool value)
1117    {
1118        if (d->pSample) {
1119            if (value) d->pSample->LoopPlayCount = 0;
1120            else if (d->pSample->LoopPlayCount == 0) d->pSample->LoopPlayCount = 1;
1121        }
1122    }
1123    
1124    void DimRegionEdit::set_LoopPlayCount(gig::DimensionRegion* d, uint32_t value)
1125    {
1126        if (d->pSample) d->pSample->LoopPlayCount = value;
1127    }
Legend:
Removed from v.1396  
changed lines
  Added in v.1460
  ViewVC Help
Powered by ViewVC