/[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 1261 by persson, Thu Jul 5 17:12:20 2007 UTC revision 1623 by persson, Fri Jan 4 19:42:45 2008 UTC
# Line 1  Line 1 
1  /*  /*
2   * Copyright (C) 2006, 2007 Andreas Persson   * Copyright (C) 2006-2008 Andreas Persson
3   *   *
4   * This program is free software; you can redistribute it and/or   * This program is free software; you can redistribute it and/or
5   * modify it under the terms of the GNU General Public License as   * modify it under the terms of the GNU General Public License as
# Line 19  Line 19 
19    
20  #include "dimregionedit.h"  #include "dimregionedit.h"
21    
22  #include <libintl.h>  #include "global.h"
 #define _(String) gettext(String)  
23    
24  DimRegionEdit::DimRegionEdit() :  DimRegionEdit::DimRegionEdit() :
25      eEG1PreAttack("Pre-attack", 0, 100, 2),      eEG1PreAttack("Pre-attack", 0, 100, 2),
# Line 110  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 302  DimRegionEdit::DimRegionEdit() : Line 410  DimRegionEdit::DimRegionEdit() :
410    
411      nextPage();      nextPage();
412    
413      addHeader(_("Filter Cutoff Envelope (EG2)"));      lEG2 = addHeader(_("Filter Cutoff Envelope (EG2)"));
414      addProp(eEG2PreAttack);      addProp(eEG2PreAttack);
415      addProp(eEG2Attack);      addProp(eEG2Attack);
416      addProp(eEG2Decay1);      addProp(eEG2Decay1);
# Line 315  DimRegionEdit::DimRegionEdit() : Line 423  DimRegionEdit::DimRegionEdit() :
423      addProp(eEG2ControllerAttackInfluence);      addProp(eEG2ControllerAttackInfluence);
424      addProp(eEG2ControllerDecayInfluence);      addProp(eEG2ControllerDecayInfluence);
425      addProp(eEG2ControllerReleaseInfluence);      addProp(eEG2ControllerReleaseInfluence);
426      addHeader(_("Filter Cutoff Oscillator (LFO2)"));      lLFO2 = addHeader(_("Filter Cutoff Oscillator (LFO2)"));
427      addProp(eLFO2Frequency);      addProp(eLFO2Frequency);
428      addProp(eLFO2InternalDepth);      addProp(eLFO2InternalDepth);
429      addProp(eLFO2ControlDepth);      addProp(eLFO2ControlDepth);
# Line 390  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 461  void DimRegionEdit::addString(const char Line 569  void DimRegionEdit::addString(const char
569      rowno++;      rowno++;
570  }  }
571    
572  void DimRegionEdit::addHeader(const char* text)  Gtk::Label* DimRegionEdit::addHeader(const char* text)
573  {  {
574      if (firstRowInBlock < rowno - 1)      if (firstRowInBlock < rowno - 1)
575      {      {
# Line 479  void DimRegionEdit::addHeader(const char Line 587  void DimRegionEdit::addHeader(const char
587                            Gtk::FILL, Gtk::SHRINK);                            Gtk::FILL, Gtk::SHRINK);
588      rowno++;      rowno++;
589      firstRowInBlock = rowno;      firstRowInBlock = rowno;
590        return label;
591  }  }
592    
593  void DimRegionEdit::nextPage()  void DimRegionEdit::nextPage()
# Line 499  void DimRegionEdit::addProp(BoolEntry& b Line 608  void DimRegionEdit::addProp(BoolEntry& b
608      table[pageno]->attach(boolentry.widget, 1, 3, rowno, rowno + 1,      table[pageno]->attach(boolentry.widget, 1, 3, rowno, rowno + 1,
609                            Gtk::FILL, Gtk::SHRINK);                            Gtk::FILL, Gtk::SHRINK);
610      rowno++;      rowno++;
611      boolentry.signal_changed_by_user().connect(dimreg_changed_signal.make_slot());  }
612    
613    void DimRegionEdit::addProp(BoolEntryPlus6& boolentry)
614    {
615        table[pageno]->attach(boolentry.widget, 1, 3, rowno, rowno + 1,
616                              Gtk::FILL, Gtk::SHRINK);
617        rowno++;
618  }  }
619    
620  void DimRegionEdit::addProp(LabelWidget& prop)  void DimRegionEdit::addProp(LabelWidget& prop)
# Line 509  void DimRegionEdit::addProp(LabelWidget& Line 624  void DimRegionEdit::addProp(LabelWidget&
624      table[pageno]->attach(prop.widget, 2, 3, rowno, rowno + 1,      table[pageno]->attach(prop.widget, 2, 3, rowno, rowno + 1,
625                            Gtk::EXPAND | Gtk::FILL, Gtk::SHRINK);                            Gtk::EXPAND | Gtk::FILL, Gtk::SHRINK);
626      rowno++;      rowno++;
     prop.signal_changed_by_user().connect(dimreg_changed_signal.make_slot());  
627  }  }
628    
629    
# Line 520  void DimRegionEdit::set_dim_region(gig:: Line 634  void DimRegionEdit::set_dim_region(gig::
634      set_sensitive(d);      set_sensitive(d);
635      if (!d) return;      if (!d) return;
636    
637      wSample->set_text(d->pSample ? d->pSample->pInfo->Name.c_str() : "NULL");      update_model++;
638      eEG1PreAttack.set_ptr(&d->EG1PreAttack);      eEG1PreAttack.set_value(d->EG1PreAttack);
639      eEG1Attack.set_ptr(&d->EG1Attack);      eEG1Attack.set_value(d->EG1Attack);
640      eEG1Decay1.set_ptr(&d->EG1Decay1);      eEG1Decay1.set_value(d->EG1Decay1);
641      eEG1Decay2.set_ptr(&d->EG1Decay2);      eEG1Decay2.set_value(d->EG1Decay2);
642      eEG1InfiniteSustain.set_ptr(&d->EG1InfiniteSustain);      eEG1InfiniteSustain.set_value(d->EG1InfiniteSustain);
643      eEG1Sustain.set_ptr(&d->EG1Sustain);      eEG1Sustain.set_value(d->EG1Sustain);
644      eEG1Release.set_ptr(&d->EG1Release);      eEG1Release.set_value(d->EG1Release);
645      eEG1Hold.set_ptr(&d->EG1Hold);      eEG1Hold.set_value(d->EG1Hold);
646      eEG1Controller.set_ptr(&d->EG1Controller);      eEG1Controller.set_value(d->EG1Controller);
647      eEG1ControllerInvert.set_ptr(&d->EG1ControllerInvert);      eEG1ControllerInvert.set_value(d->EG1ControllerInvert);
648      eEG1ControllerAttackInfluence.set_ptr(&d->EG1ControllerAttackInfluence);      eEG1ControllerAttackInfluence.set_value(d->EG1ControllerAttackInfluence);
649      eEG1ControllerDecayInfluence.set_ptr(&d->EG1ControllerDecayInfluence);      eEG1ControllerDecayInfluence.set_value(d->EG1ControllerDecayInfluence);
650      eEG1ControllerReleaseInfluence.set_ptr(&d->EG1ControllerReleaseInfluence);      eEG1ControllerReleaseInfluence.set_value(d->EG1ControllerReleaseInfluence);
651      eLFO1Frequency.set_ptr(&d->LFO1Frequency);      eLFO1Frequency.set_value(d->LFO1Frequency);
652      eLFO1InternalDepth.set_ptr(&d->LFO1InternalDepth);      eLFO1InternalDepth.set_value(d->LFO1InternalDepth);
653      eLFO1ControlDepth.set_ptr(&d->LFO1ControlDepth);      eLFO1ControlDepth.set_value(d->LFO1ControlDepth);
654      eLFO1Controller.set_ptr(&d->LFO1Controller);      eLFO1Controller.set_value(d->LFO1Controller);
655      eLFO1FlipPhase.set_ptr(&d->LFO1FlipPhase);      eLFO1FlipPhase.set_value(d->LFO1FlipPhase);
656      eLFO1Sync.set_ptr(&d->LFO1Sync);      eLFO1Sync.set_value(d->LFO1Sync);
657      eEG2PreAttack.set_ptr(&d->EG2PreAttack);      eEG2PreAttack.set_value(d->EG2PreAttack);
658      eEG2Attack.set_ptr(&d->EG2Attack);      eEG2Attack.set_value(d->EG2Attack);
659      eEG2Decay1.set_ptr(&d->EG2Decay1);      eEG2Decay1.set_value(d->EG2Decay1);
660      eEG2Decay2.set_ptr(&d->EG2Decay2);      eEG2Decay2.set_value(d->EG2Decay2);
661      eEG2InfiniteSustain.set_ptr(&d->EG2InfiniteSustain);      eEG2InfiniteSustain.set_value(d->EG2InfiniteSustain);
662      eEG2Sustain.set_ptr(&d->EG2Sustain);      eEG2Sustain.set_value(d->EG2Sustain);
663      eEG2Release.set_ptr(&d->EG2Release);      eEG2Release.set_value(d->EG2Release);
664      eEG2Controller.set_ptr(&d->EG2Controller);      eEG2Controller.set_value(d->EG2Controller);
665      eEG2ControllerInvert.set_ptr(&d->EG2ControllerInvert);      eEG2ControllerInvert.set_value(d->EG2ControllerInvert);
666      eEG2ControllerAttackInfluence.set_ptr(&d->EG2ControllerAttackInfluence);      eEG2ControllerAttackInfluence.set_value(d->EG2ControllerAttackInfluence);
667      eEG2ControllerDecayInfluence.set_ptr(&d->EG2ControllerDecayInfluence);      eEG2ControllerDecayInfluence.set_value(d->EG2ControllerDecayInfluence);
668      eEG2ControllerReleaseInfluence.set_ptr(&d->EG2ControllerReleaseInfluence);      eEG2ControllerReleaseInfluence.set_value(d->EG2ControllerReleaseInfluence);
669      eLFO2Frequency.set_ptr(&d->LFO2Frequency);      eLFO2Frequency.set_value(d->LFO2Frequency);
670      eLFO2InternalDepth.set_ptr(&d->LFO2InternalDepth);      eLFO2InternalDepth.set_value(d->LFO2InternalDepth);
671      eLFO2ControlDepth.set_ptr(&d->LFO2ControlDepth);      eLFO2ControlDepth.set_value(d->LFO2ControlDepth);
672      eLFO2Controller.set_ptr(&d->LFO2Controller);      eLFO2Controller.set_value(d->LFO2Controller);
673      eLFO2FlipPhase.set_ptr(&d->LFO2FlipPhase);      eLFO2FlipPhase.set_value(d->LFO2FlipPhase);
674      eLFO2Sync.set_ptr(&d->LFO2Sync);      eLFO2Sync.set_value(d->LFO2Sync);
675      eEG3Attack.set_ptr(&d->EG3Attack);      eEG3Attack.set_value(d->EG3Attack);
676      eEG3Depth.set_ptr(&d->EG3Depth);      eEG3Depth.set_value(d->EG3Depth);
677      eLFO3Frequency.set_ptr(&d->LFO3Frequency);      eLFO3Frequency.set_value(d->LFO3Frequency);
678      eLFO3InternalDepth.set_ptr(&d->LFO3InternalDepth);      eLFO3InternalDepth.set_value(d->LFO3InternalDepth);
679      eLFO3ControlDepth.set_ptr(&d->LFO3ControlDepth);      eLFO3ControlDepth.set_value(d->LFO3ControlDepth);
680      eLFO3Controller.set_ptr(&d->LFO3Controller);      eLFO3Controller.set_value(d->LFO3Controller);
681      eLFO3Sync.set_ptr(&d->LFO3Sync);      eLFO3Sync.set_value(d->LFO3Sync);
682      eVCFEnabled.set_ptr(&d->VCFEnabled);      eVCFEnabled.set_value(d->VCFEnabled);
683      eVCFType.set_ptr(&d->VCFType);      eVCFType.set_value(d->VCFType);
684      eVCFCutoffController.set_ptr(&d->VCFCutoffController);      eVCFCutoffController.set_value(d->VCFCutoffController);
685      eVCFCutoffControllerInvert.set_ptr(&d->VCFCutoffControllerInvert);      eVCFCutoffControllerInvert.set_value(d->VCFCutoffControllerInvert);
686      eVCFCutoff.set_ptr(&d->VCFCutoff);      eVCFCutoff.set_value(d->VCFCutoff);
687      eVCFVelocityCurve.set_ptr(&d->VCFVelocityCurve);      eVCFVelocityCurve.set_value(d->VCFVelocityCurve);
688      eVCFVelocityScale.set_ptr(&d->VCFVelocityScale);      eVCFVelocityScale.set_value(d->VCFVelocityScale);
689      eVCFVelocityDynamicRange.set_ptr(&d->VCFVelocityDynamicRange);      eVCFVelocityDynamicRange.set_value(d->VCFVelocityDynamicRange);
690      eVCFResonance.set_ptr(&d->VCFResonance);      eVCFResonance.set_value(d->VCFResonance);
691      eVCFResonanceDynamic.set_ptr(&d->VCFResonanceDynamic);      eVCFResonanceDynamic.set_value(d->VCFResonanceDynamic);
692      eVCFResonanceController.set_ptr(&d->VCFResonanceController);      eVCFResonanceController.set_value(d->VCFResonanceController);
693      eVCFKeyboardTracking.set_ptr(&d->VCFKeyboardTracking);      eVCFKeyboardTracking.set_value(d->VCFKeyboardTracking);
694      eVCFKeyboardTrackingBreakpoint.set_ptr(&d->VCFKeyboardTrackingBreakpoint);      eVCFKeyboardTrackingBreakpoint.set_value(d->VCFKeyboardTrackingBreakpoint);
695      eVelocityResponseCurve.set_ptr(&d->VelocityResponseCurve);      eVelocityResponseCurve.set_value(d->VelocityResponseCurve);
696      eVelocityResponseDepth.set_ptr(&d->VelocityResponseDepth);      eVelocityResponseDepth.set_value(d->VelocityResponseDepth);
697      eVelocityResponseCurveScaling.set_ptr(&d->VelocityResponseCurveScaling);      eVelocityResponseCurveScaling.set_value(d->VelocityResponseCurveScaling);
698      eReleaseVelocityResponseCurve.set_ptr(&d->ReleaseVelocityResponseCurve);      eReleaseVelocityResponseCurve.set_value(d->ReleaseVelocityResponseCurve);
699      eReleaseVelocityResponseDepth.set_ptr(&d->ReleaseVelocityResponseDepth);      eReleaseVelocityResponseDepth.set_value(d->ReleaseVelocityResponseDepth);
700      eReleaseTriggerDecay.set_ptr(&d->ReleaseTriggerDecay);      eReleaseTriggerDecay.set_value(d->ReleaseTriggerDecay);
701        eCrossfade_in_start.set_value(d->Crossfade.in_start);
702      eCrossfade_in_start.set_ptr(0);      eCrossfade_in_end.set_value(d->Crossfade.in_end);
703      eCrossfade_in_end.set_ptr(0);      eCrossfade_out_start.set_value(d->Crossfade.out_start);
704      eCrossfade_out_start.set_ptr(0);      eCrossfade_out_end.set_value(d->Crossfade.out_end);
705      eCrossfade_out_end.set_ptr(0);      ePitchTrack.set_value(d->PitchTrack);
706      eCrossfade_in_start.set_ptr(&d->Crossfade.in_start);      eDimensionBypass.set_value(d->DimensionBypass);
707      eCrossfade_in_end.set_ptr(&d->Crossfade.in_end);      ePan.set_value(d->Pan);
708      eCrossfade_out_start.set_ptr(&d->Crossfade.out_start);      eSelfMask.set_value(d->SelfMask);
709      eCrossfade_out_end.set_ptr(&d->Crossfade.out_end);      eAttenuationController.set_value(d->AttenuationController);
710        eInvertAttenuationController.set_value(d->InvertAttenuationController);
711      ePitchTrack.set_ptr(&d->PitchTrack);      eAttenuationControllerThreshold.set_value(d->AttenuationControllerThreshold);
712      eDimensionBypass.set_ptr(&d->DimensionBypass);      eChannelOffset.set_value(d->ChannelOffset);
713      ePan.set_ptr(&d->Pan);      eSustainDefeat.set_value(d->SustainDefeat);
714      eSelfMask.set_ptr(&d->SelfMask);      eMSDecode.set_value(d->MSDecode);
715      eAttenuationController.set_ptr(&d->AttenuationController);      eSampleStartOffset.set_value(d->SampleStartOffset);
716      eInvertAttenuationController.set_ptr(&d->InvertAttenuationController);      eUnityNote.set_value(d->UnityNote);
717      eAttenuationControllerThreshold.set_ptr(&d->AttenuationControllerThreshold);      eFineTune.set_value(d->FineTune);
718      eChannelOffset.set_ptr(&d->ChannelOffset);      eGain.set_value(d->Gain);
719      eSustainDefeat.set_ptr(&d->SustainDefeat);      eGainPlus6.set_value(d->Gain);
720      eMSDecode.set_ptr(&d->MSDecode);      eSampleLoopEnabled.set_value(d->SampleLoops);
721      eSampleStartOffset.set_ptr(&d->SampleStartOffset);      eSampleLoopType.set_value(
722      eUnityNote.set_ptr(&d->UnityNote);          d->SampleLoops ? d->pSampleLoops[0].LoopType : 0);
723      eFineTune.set_ptr(&d->FineTune);      eSampleLoopStart.set_value(
724      eGain.set_ptr(&d->Gain);          d->SampleLoops ? d->pSampleLoops[0].LoopStart : 0);
725      eGainPlus6.set_ptr(&d->Gain);      eSampleLoopLength.set_value(
726            d->SampleLoops ? d->pSampleLoops[0].LoopLength : 0);
727        eSampleLoopInfinite.set_value(
728            d->pSample && d->pSample->LoopPlayCount == 0);
729        eSampleLoopPlayCount.set_value(
730            d->pSample ? d->pSample->LoopPlayCount : 0);
731        update_model--;
732    
733      eSampleLoopEnabled.set_active(d->SampleLoops);      wSample->set_text(d->pSample ? d->pSample->pInfo->Name.c_str() : "NULL");
     updateLoopElements();  
734    
735        update_loop_elements();
736      VCFEnabled_toggled();      VCFEnabled_toggled();
737  }  }
738    
739    
740  void DimRegionEdit::VCFEnabled_toggled()  void DimRegionEdit::VCFEnabled_toggled()
741  {  {
742      bool sensitive = eVCFEnabled.get_active();      bool sensitive = eVCFEnabled.get_value();
743      eVCFType.set_sensitive(sensitive);      eVCFType.set_sensitive(sensitive);
744      eVCFCutoffController.set_sensitive(sensitive);      eVCFCutoffController.set_sensitive(sensitive);
745      eVCFVelocityCurve.set_sensitive(sensitive);      eVCFVelocityCurve.set_sensitive(sensitive);
# Line 628  void DimRegionEdit::VCFEnabled_toggled() Line 749  void DimRegionEdit::VCFEnabled_toggled()
749      eVCFResonanceController.set_sensitive(sensitive);      eVCFResonanceController.set_sensitive(sensitive);
750      eVCFKeyboardTracking.set_sensitive(sensitive);      eVCFKeyboardTracking.set_sensitive(sensitive);
751      eVCFKeyboardTrackingBreakpoint.set_sensitive(sensitive);      eVCFKeyboardTrackingBreakpoint.set_sensitive(sensitive);
752        lEG2->set_sensitive(sensitive);
753      eEG2PreAttack.set_sensitive(sensitive);      eEG2PreAttack.set_sensitive(sensitive);
754      eEG2Attack.set_sensitive(sensitive);      eEG2Attack.set_sensitive(sensitive);
755      eEG2Decay1.set_sensitive(sensitive);      eEG2Decay1.set_sensitive(sensitive);
# Line 638  void DimRegionEdit::VCFEnabled_toggled() Line 760  void DimRegionEdit::VCFEnabled_toggled()
760      eEG2ControllerAttackInfluence.set_sensitive(sensitive);      eEG2ControllerAttackInfluence.set_sensitive(sensitive);
761      eEG2ControllerDecayInfluence.set_sensitive(sensitive);      eEG2ControllerDecayInfluence.set_sensitive(sensitive);
762      eEG2ControllerReleaseInfluence.set_sensitive(sensitive);      eEG2ControllerReleaseInfluence.set_sensitive(sensitive);
763        lLFO2->set_sensitive(sensitive);
764      eLFO2Frequency.set_sensitive(sensitive);      eLFO2Frequency.set_sensitive(sensitive);
765      eLFO2InternalDepth.set_sensitive(sensitive);      eLFO2InternalDepth.set_sensitive(sensitive);
766      eLFO2ControlDepth.set_sensitive(sensitive);      eLFO2ControlDepth.set_sensitive(sensitive);
# Line 664  void DimRegionEdit::VCFEnabled_toggled() Line 787  void DimRegionEdit::VCFEnabled_toggled()
787    
788  void DimRegionEdit::VCFCutoffController_changed()  void DimRegionEdit::VCFCutoffController_changed()
789  {  {
790      int rowno = eVCFCutoffController.get_active_row_number();      gig::vcf_cutoff_ctrl_t ctrl = eVCFCutoffController.get_value();
791      bool hasController = rowno != 0 && rowno != 1;      bool hasController = ctrl != gig::vcf_cutoff_ctrl_none && ctrl != gig::vcf_cutoff_ctrl_none2;
792    
793      eVCFCutoffControllerInvert.set_sensitive(hasController);      eVCFCutoffControllerInvert.set_sensitive(hasController);
794      eVCFCutoff.set_sensitive(!hasController);      eVCFCutoff.set_sensitive(!hasController);
# Line 676  void DimRegionEdit::VCFCutoffController_ Line 799  void DimRegionEdit::VCFCutoffController_
799    
800  void DimRegionEdit::VCFResonanceController_changed()  void DimRegionEdit::VCFResonanceController_changed()
801  {  {
802      bool hasController = eVCFResonanceController.get_active_row_number() != 0;      bool hasController = eVCFResonanceController.get_value() != gig::vcf_res_ctrl_none;
803      eVCFResonance.set_sensitive(!hasController);      eVCFResonance.set_sensitive(!hasController);
804  }  }
805    
806  void DimRegionEdit::EG1InfiniteSustain_toggled()  void DimRegionEdit::EG1InfiniteSustain_toggled()
807  {  {
808      bool infSus = eEG1InfiniteSustain.get_active();      bool infSus = eEG1InfiniteSustain.get_value();
809      eEG1Decay2.set_sensitive(!infSus);      eEG1Decay2.set_sensitive(!infSus);
810  }  }
811    
812  void DimRegionEdit::EG2InfiniteSustain_toggled()  void DimRegionEdit::EG2InfiniteSustain_toggled()
813  {  {
814      bool infSus = eEG2InfiniteSustain.get_active();      bool infSus = eEG2InfiniteSustain.get_value();
815      eEG2Decay2.set_sensitive(!infSus);      eEG2Decay2.set_sensitive(!infSus);
816  }  }
817    
818  void DimRegionEdit::EG1Controller_changed()  void DimRegionEdit::EG1Controller_changed()
819  {  {
820      bool hasController = eEG1Controller.get_active_row_number() != 0;      bool hasController = eEG1Controller.get_value().type != gig::leverage_ctrl_t::type_none;
821      eEG1ControllerInvert.set_sensitive(hasController);      eEG1ControllerInvert.set_sensitive(hasController);
822  }  }
823    
824  void DimRegionEdit::EG2Controller_changed()  void DimRegionEdit::EG2Controller_changed()
825  {  {
826      bool hasController = eEG2Controller.get_active_row_number() != 0;      bool hasController = eEG2Controller.get_value().type != gig::leverage_ctrl_t::type_none;
827      eEG2ControllerInvert.set_sensitive(hasController);      eEG2ControllerInvert.set_sensitive(hasController);
828  }  }
829    
830  void DimRegionEdit::AttenuationController_changed()  void DimRegionEdit::AttenuationController_changed()
831  {  {
832      bool hasController = eAttenuationController.get_active_row_number() != 0;      bool hasController =
833            eAttenuationController.get_value().type != gig::leverage_ctrl_t::type_none;
834      eInvertAttenuationController.set_sensitive(hasController);      eInvertAttenuationController.set_sensitive(hasController);
835      eAttenuationControllerThreshold.set_sensitive(hasController);      eAttenuationControllerThreshold.set_sensitive(hasController);
836      eCrossfade_in_start.set_sensitive(hasController);      eCrossfade_in_start.set_sensitive(hasController);
# Line 717  void DimRegionEdit::AttenuationControlle Line 841  void DimRegionEdit::AttenuationControlle
841    
842  void DimRegionEdit::LFO1Controller_changed()  void DimRegionEdit::LFO1Controller_changed()
843  {  {
844      int rowno = eLFO1Controller.get_active_row_number();      gig::lfo1_ctrl_t ctrl = eLFO1Controller.get_value();
845      eLFO1ControlDepth.set_sensitive(rowno != 0);      eLFO1ControlDepth.set_sensitive(ctrl != gig::lfo1_ctrl_internal);
846      eLFO1InternalDepth.set_sensitive(rowno != 1 && rowno != 2);      eLFO1InternalDepth.set_sensitive(ctrl != gig::lfo1_ctrl_modwheel &&
847                                         ctrl != gig::lfo1_ctrl_breath);
848  }  }
849    
850  void DimRegionEdit::LFO2Controller_changed()  void DimRegionEdit::LFO2Controller_changed()
851  {  {
852      int rowno = eLFO2Controller.get_active_row_number();      gig::lfo2_ctrl_t ctrl = eLFO2Controller.get_value();
853      eLFO2ControlDepth.set_sensitive(rowno != 0);      eLFO2ControlDepth.set_sensitive(ctrl != gig::lfo2_ctrl_internal);
854      eLFO2InternalDepth.set_sensitive(rowno != 1 && rowno != 2);      eLFO2InternalDepth.set_sensitive(ctrl != gig::lfo2_ctrl_modwheel &&
855                                         ctrl != gig::lfo2_ctrl_foot);
856  }  }
857    
858  void DimRegionEdit::LFO3Controller_changed()  void DimRegionEdit::LFO3Controller_changed()
859  {  {
860      int rowno = eLFO3Controller.get_active_row_number();      gig::lfo3_ctrl_t ctrl = eLFO3Controller.get_value();
861      eLFO3ControlDepth.set_sensitive(rowno != 0);      eLFO3ControlDepth.set_sensitive(ctrl != gig::lfo3_ctrl_internal);
862      eLFO3InternalDepth.set_sensitive(rowno != 1 && rowno != 2);      eLFO3InternalDepth.set_sensitive(ctrl != gig::lfo3_ctrl_modwheel &&
863                                         ctrl != gig::lfo3_ctrl_aftertouch);
864  }  }
865    
866  void DimRegionEdit::crossfade1_changed()  void DimRegionEdit::crossfade1_changed()
867  {  {
868      double c1 = eCrossfade_in_start.get_value();      update_model++;
869      double c2 = eCrossfade_in_end.get_value();      eCrossfade_in_end.set_value(dimregion->Crossfade.in_end);
870      if (c1 > c2) eCrossfade_in_end.set_value(c1);      eCrossfade_out_start.set_value(dimregion->Crossfade.out_start);
871        eCrossfade_out_end.set_value(dimregion->Crossfade.out_end);
872        update_model--;
873  }  }
874    
875  void DimRegionEdit::crossfade2_changed()  void DimRegionEdit::crossfade2_changed()
876  {  {
877      double c1 = eCrossfade_in_start.get_value();      update_model++;
878      double c2 = eCrossfade_in_end.get_value();      eCrossfade_in_start.set_value(dimregion->Crossfade.in_start);
879      double c3 = eCrossfade_out_start.get_value();      eCrossfade_out_start.set_value(dimregion->Crossfade.out_start);
880        eCrossfade_out_end.set_value(dimregion->Crossfade.out_end);
881      if (c2 < c1) eCrossfade_in_start.set_value(c2);      update_model--;
     if (c2 > c3) eCrossfade_out_start.set_value(c2);  
882  }  }
883    
884  void DimRegionEdit::crossfade3_changed()  void DimRegionEdit::crossfade3_changed()
885  {  {
886      double c2 = eCrossfade_in_end.get_value();      update_model++;
887      double c3 = eCrossfade_out_start.get_value();      eCrossfade_in_start.set_value(dimregion->Crossfade.in_start);
888      double c4 = eCrossfade_out_end.get_value();      eCrossfade_in_end.set_value(dimregion->Crossfade.in_end);
889        eCrossfade_out_end.set_value(dimregion->Crossfade.out_end);
890      if (c3 < c2) eCrossfade_in_end.set_value(c3);      update_model--;
     if (c3 > c4) eCrossfade_out_end.set_value(c3);  
891  }  }
892    
893  void DimRegionEdit::crossfade4_changed()  void DimRegionEdit::crossfade4_changed()
894  {  {
895      double c3 = eCrossfade_out_start.get_value();      update_model++;
896      double c4 = eCrossfade_out_end.get_value();      eCrossfade_in_start.set_value(dimregion->Crossfade.in_start);
897        eCrossfade_in_end.set_value(dimregion->Crossfade.in_end);
898        eCrossfade_out_start.set_value(dimregion->Crossfade.out_start);
899        update_model--;
900    }
901    
902    void DimRegionEdit::update_loop_elements()
903    {
904        update_model++;
905        const bool active = eSampleLoopEnabled.get_value();
906        eSampleLoopStart.set_sensitive(active);
907        eSampleLoopLength.set_sensitive(active);
908        eSampleLoopType.set_sensitive(active);
909        eSampleLoopInfinite.set_sensitive(active && dimregion && dimregion->pSample);
910        // sample loop shall never be longer than the actual sample size
911        loop_start_changed();
912        loop_length_changed();
913        eSampleLoopStart.set_value(
914            dimregion->SampleLoops ? dimregion->pSampleLoops[0].LoopStart : 0);
915        eSampleLoopLength.set_value(
916            dimregion->SampleLoops ? dimregion->pSampleLoops[0].LoopLength : 0);
917    
918        eSampleLoopInfinite.set_value(
919            dimregion->pSample && dimregion->pSample->LoopPlayCount == 0);
920    
921        loop_infinite_toggled();
922        update_model--;
923    }
924    
925    void DimRegionEdit::loop_start_changed() {
926        if (dimregion && dimregion->SampleLoops) {
927            eSampleLoopLength.set_upper(dimregion->pSample ?
928                                        dimregion->pSample->SamplesTotal -
929                                        dimregion->pSampleLoops[0].LoopStart : 0);
930        }
931    }
932    
933    void DimRegionEdit::loop_length_changed() {
934        if (dimregion && dimregion->SampleLoops) {
935            eSampleLoopStart.set_upper(dimregion->pSample ?
936                                       dimregion->pSample->SamplesTotal -
937                                       dimregion->pSampleLoops[0].LoopLength : 0);
938        }
939    }
940    
941    void DimRegionEdit::loop_infinite_toggled() {
942        eSampleLoopPlayCount.set_sensitive(
943            dimregion && dimregion->pSample &&
944            !eSampleLoopInfinite.get_value() &&
945            eSampleLoopEnabled.get_value()
946        );
947        update_model++;
948        eSampleLoopPlayCount.set_value(
949            dimregion->pSample ? dimregion->pSample->LoopPlayCount : 0);
950        update_model--;
951    }
952    
953    bool DimRegionEdit::set_sample(gig::Sample* sample)
954    {
955        if (dimregion) {
956            //TODO: we should better move the code from MainWindow::on_sample_label_drop_drag_data_received() here
957    
958            // currently commented because we're sending a similar signal in MainWindow::on_sample_label_drop_drag_data_received()
959            //dimreg_to_be_changed_signal.emit(dimregion);
960    
961            gig::Sample* oldref = dimregion->pSample;
962            dimregion->pSample = sample;
963    
964            // copy sample information from Sample to DimensionRegion
965    
966            dimregion->UnityNote = sample->MIDIUnityNote;
967            dimregion->FineTune = sample->FineTune;
968    
969            int loops = sample->Loops ? 1 : 0;
970            while (dimregion->SampleLoops > loops) {
971                dimregion->DeleteSampleLoop(&dimregion->pSampleLoops[0]);
972            }
973            while (dimregion->SampleLoops < sample->Loops) {
974                DLS::sample_loop_t loop;
975                dimregion->AddSampleLoop(&loop);
976            }
977            if (loops) {
978                dimregion->pSampleLoops[0].Size = sizeof(DLS::sample_loop_t);
979                dimregion->pSampleLoops[0].LoopType = sample->LoopType;
980                dimregion->pSampleLoops[0].LoopStart = sample->LoopStart;
981                dimregion->pSampleLoops[0].LoopLength = sample->LoopEnd - sample->LoopStart + 1;
982            }
983    
984            // update ui
985            update_model++;
986            wSample->set_text(dimregion->pSample->pInfo->Name);
987            eUnityNote.set_value(dimregion->UnityNote);
988            eFineTune.set_value(dimregion->FineTune);
989            eSampleLoopEnabled.set_value(dimregion->SampleLoops);
990            update_loop_elements();
991            update_model--;
992    
993            sample_ref_changed_signal.emit(oldref, sample);
994            // currently commented because we're sending a similar signal in MainWindow::on_sample_label_drop_drag_data_received()
995            //dimreg_changed_signal.emit(dimregion);
996            return true;
997        }
998        return false;
999    }
1000    
1001    sigc::signal<void, gig::DimensionRegion*>& DimRegionEdit::signal_dimreg_to_be_changed() {
1002        return dimreg_to_be_changed_signal;
1003    }
1004    
1005    sigc::signal<void, gig::DimensionRegion*>& DimRegionEdit::signal_dimreg_changed() {
1006        return dimreg_changed_signal;
1007    }
1008    
1009    sigc::signal<void, gig::Sample*/*old*/, gig::Sample*/*new*/>& DimRegionEdit::signal_sample_ref_changed() {
1010        return sample_ref_changed_signal;
1011    }
1012    
1013    
1014    void DimRegionEdit::set_UnityNote(gig::DimensionRegion* d, uint8_t value)
1015    {
1016        d->UnityNote = value;
1017    }
1018    
1019    void DimRegionEdit::set_FineTune(gig::DimensionRegion* d, int16_t value)
1020    {
1021        d->FineTune = value;
1022    }
1023    
1024    void DimRegionEdit::set_Crossfade_in_start(gig::DimensionRegion* d,
1025                                               uint8_t value)
1026    {
1027        d->Crossfade.in_start = value;
1028        if (d->Crossfade.in_end < value) set_Crossfade_in_end(d, value);
1029    }
1030    
1031    void DimRegionEdit::set_Crossfade_in_end(gig::DimensionRegion* d,
1032                                             uint8_t value)
1033    {
1034        d->Crossfade.in_end = value;
1035        if (value < d->Crossfade.in_start) set_Crossfade_in_start(d, value);
1036        if (value > d->Crossfade.out_start) set_Crossfade_out_start(d, value);
1037    }
1038    
1039      if (c4 < c3) eCrossfade_out_start.set_value(c4);  void DimRegionEdit::set_Crossfade_out_start(gig::DimensionRegion* d,
1040                                                uint8_t value)
1041    {
1042        d->Crossfade.out_start = value;
1043        if (value < d->Crossfade.in_end) set_Crossfade_in_end(d, value);
1044        if (value > d->Crossfade.out_end) set_Crossfade_out_end(d, value);
1045  }  }
1046    
1047  void DimRegionEdit::loop_enabled_toggled()  void DimRegionEdit::set_Crossfade_out_end(gig::DimensionRegion* d,
1048                                              uint8_t value)
1049  {  {
1050      const bool active = eSampleLoopEnabled.get_active();      d->Crossfade.out_end = value;
1051      if (active) {      if (value < d->Crossfade.out_start) set_Crossfade_out_start(d, value);
1052    }
1053    
1054    void DimRegionEdit::set_Gain(gig::DimensionRegion* d, int32_t value)
1055    {
1056        d->SetGain(value);
1057    }
1058    
1059    void DimRegionEdit::set_LoopEnabled(gig::DimensionRegion* d, bool value)
1060    {
1061        if (value) {
1062          // create a new sample loop in case there is none yet          // create a new sample loop in case there is none yet
1063          if (!dimregion->SampleLoops) {          if (!d->SampleLoops) {
1064              DLS::sample_loop_t loop;              DLS::sample_loop_t loop;
1065              loop.LoopType   = gig::loop_type_normal;              loop.LoopType = gig::loop_type_normal;
1066              // loop the whole sample by default              // loop the whole sample by default
1067              loop.LoopStart  = 0;              loop.LoopStart  = 0;
1068              loop.LoopLength =              loop.LoopLength =
1069                  (dimregion->pSample) ? dimregion->pSample->GetSize() : 0;                  (d->pSample) ? d->pSample->SamplesTotal : 0;
1070              dimregion->AddSampleLoop(&loop);              dimreg_to_be_changed_signal.emit(d);
1071              dimreg_changed_signal();              d->AddSampleLoop(&loop);
1072                dimreg_changed_signal.emit(d);
1073          }          }
1074      } else {      } else {
1075          if (dimregion->SampleLoops) {          if (d->SampleLoops) {
1076                dimreg_to_be_changed_signal.emit(d);
1077              // delete ALL existing sample loops              // delete ALL existing sample loops
1078              while (dimregion->SampleLoops) {              while (d->SampleLoops) {
1079                  dimregion->DeleteSampleLoop(&dimregion->pSampleLoops[0]);                  d->DeleteSampleLoop(&d->pSampleLoops[0]);
1080              }              }
1081              dimreg_changed_signal();              dimreg_changed_signal.emit(d);
1082          }          }
1083      }      }
     updateLoopElements();  
1084  }  }
1085    
1086  void DimRegionEdit::updateLoopElements()  void DimRegionEdit::set_LoopType(gig::DimensionRegion* d, uint32_t value)
1087  {  {
1088      const bool active = eSampleLoopEnabled.get_active();      if (d->SampleLoops) d->pSampleLoops[0].LoopType = value;
1089      eSampleLoopStart.set_sensitive(active);  }
     eSampleLoopLength.set_sensitive(active);  
     eSampleLoopType.set_sensitive(active);  
     eSampleLoopInfinite.set_sensitive(active);  
     eSampleLoopStart.set_ptr(0);  
     eSampleLoopLength.set_ptr(0);  
     eSampleLoopPlayCount.set_ptr(0);  
1090    
1091      if (dimregion && dimregion->SampleLoops) {  void DimRegionEdit::set_LoopStart(gig::DimensionRegion* d, uint32_t value)
1092          eSampleLoopStart.set_ptr(&dimregion->pSampleLoops[0].LoopStart);  {
1093          eSampleLoopLength.set_ptr(&dimregion->pSampleLoops[0].LoopLength);      if (d->SampleLoops) {
1094          eSampleLoopType.set_ptr(&dimregion->pSampleLoops[0].LoopType);          d->pSampleLoops[0].LoopStart =
1095          eSampleLoopInfinite.set_active(              d->pSample ?
1096              dimregion->pSample && !dimregion->pSample->LoopPlayCount              std::min(value, uint32_t(d->pSample->SamplesTotal -
1097          );                                       d->pSampleLoops[0].LoopLength)) :
1098          // updated enabled state of loop play count widget              0;
         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->GetSize() -  
                   dimregion->pSampleLoops[0].LoopLength  
                 : 0  
         );  
         eSampleLoopLength.set_upper(  
             (dimregion->pSample)  
                 ? dimregion->pSample->GetSize() -  
                   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();  
1099      }      }
1100  }  }
1101    
1102  void DimRegionEdit::loop_infinite_toggled() {  void DimRegionEdit::set_LoopLength(gig::DimensionRegion* d, uint32_t value)
1103      eSampleLoopPlayCount.set_sensitive(  {
1104          !eSampleLoopInfinite.get_active() &&      if (d->SampleLoops) {
1105           eSampleLoopEnabled.get_active()          d->pSampleLoops[0].LoopLength =
1106      );              d->pSample ?
1107      if (eSampleLoopInfinite.get_active())              std::min(value, uint32_t(d->pSample->SamplesTotal -
1108          eSampleLoopPlayCount.set_value(0);                                       d->pSampleLoops[0].LoopStart)) :
1109      else if (!eSampleLoopPlayCount.get_value())              0;
1110          eSampleLoopPlayCount.set_value(1);      }
1111    }
1112    
1113    void DimRegionEdit::set_LoopInfinite(gig::DimensionRegion* d, bool value)
1114    {
1115        if (d->pSample) {
1116            if (value) d->pSample->LoopPlayCount = 0;
1117            else if (d->pSample->LoopPlayCount == 0) d->pSample->LoopPlayCount = 1;
1118        }
1119    }
1120    
1121    void DimRegionEdit::set_LoopPlayCount(gig::DimensionRegion* d, uint32_t value)
1122    {
1123        if (d->pSample) d->pSample->LoopPlayCount = value;
1124  }  }
Legend:
Removed from v.1261  
changed lines
  Added in v.1623
  ViewVC Help
Powered by ViewVC