TheDummyAssistant(openfluid::machine::SimulationBlob* SimBlob) :
Gtk::Assistant(), mp_SimBlob(SimBlob), mp_TestUnitsColl(0), m_Applied(false)
{
set_title("Dummy assistant");
set_default_size(400, 300);
set_modal(true);
Gtk::Label* Label1 = Gtk::manage(new Gtk::Label(
"I'm a Dummy assistant for tests"));
append_page(*Label1);
set_page_title(*Label1, "Page 1/2");
set_page_type(*Label1, Gtk::ASSISTANT_PAGE_INTRO);
set_page_complete(*Label1, true);
Gtk::Label* Label2 = Gtk::manage(new Gtk::Label());
if (!mp_SimBlob)
{
Label2->set_text("Nb of units in TestUnits class: no CoreRepository\n"
"Nothing to do");
signal_apply().connect(sigc::mem_fun(*this, &Gtk::Assistant::hide));
}
else
{
unsigned int Size = 0;
mp_TestUnitsColl = mp_SimBlob->getCoreRepository().getUnits("TestUnits");
if (mp_TestUnitsColl)
Size = mp_TestUnitsColl->getList()->size();
Label2->set_text(Glib::ustring::compose(
"Nb of units in TestUnits class: %1\n"
"Clicking ok will add a Unit of class \"TestUnits\"", Size));
signal_apply().connect(
sigc::mem_fun(*this, &TheDummyAssistant::m_apply));
}
append_page(*Label2);
set_page_title(*Label2, "Page 2/2");
set_page_type(*Label2, Gtk::ASSISTANT_PAGE_CONFIRM);
set_page_complete(*Label2, true);
signal_cancel().connect(sigc::mem_fun(*this, &Gtk::Assistant::hide));
signal_close().connect(sigc::mem_fun(*this, &Gtk::Assistant::hide));
show_all_children();
}
void EditorArea::add_editor(SourceEditor *editor)
{
m_editors[editor->get_file()->get_path()] = editor;
int idx = append_page(*editor, editor->get_file()->get_basename());
editor->show_all();
set_current_page(idx);
}
void
header_editor_frame_c::clear_pages() {
m_ignore_tree_selection_changes = true;
for (size_t i = 0; m_pages.size() > i; ++i)
if (m_pages[i]->IsShown())
m_pages[i]->Hide();
m_bs_page->Clear();
m_bs_main->Hide(m_tc_tree);
m_tc_tree->DeleteChildren(m_root_id);
m_pages.clear();
m_top_level_pages.clear();
he_empty_page_c *page = new he_empty_page_c(this, YT("No file loaded"), YT("No file has been loaded yet. You can open a file by selecting\n'Open' from the 'File' menu."));
append_page(page);
m_tc_tree->SelectItem(page->m_page_id);
m_bs_main->Show(m_tc_tree);
m_bs_main->Layout();
m_ignore_tree_selection_changes = false;
}
// Navigation widget
Navi::Navi(MMdlObserver* aDesObs): iNatn(NULL), iDesObs(aDesObs)
{
// Native nodes
iNatn = new NaviNatN(iDesObs);
iNatn->show();
iNatnSw.add(*iNatn);
iNatnSw.show();
append_page(iNatnSw, "Native");
// Modules
iNatMod = new NaviModules(iDesObs);
iNatMod->show();
append_page(*iNatMod, "Modules");
// Current hier
iNatHier = new NaviHier(iDesObs);
iNatHier->show();
iNatHierSw.add(*iNatHier);
iNatHierSw.show();
append_page(iNatHierSw, "Model");
}
void VentanaClienteDinamica::personalizar(Personalizador& dynBuilder) {
std::vector< Tab* >::iterator it = tabs.begin();
for ( ; it != tabs.end(); ++it)
remove(**it);
tabs.clear();
consultas.clear();
while (dynBuilder.tieneSiguiente()) {
Tab& t = dynBuilder.siguiente();
agregarData(t);
append_page(t, t.getEtiqueta());
}
show_all();
}
bool bin_index_t::file_node::set(const data_t& key,const data_t& val)
{
validate_key_len(key);
open_index_file();
if(!root_page)
{
root_page=create_page();
append_page(*root_page);
save_index_data(0,root_page->page_offset);
add_page(root_page);
}
index_t it;
align_key(key,it);
if(get_item(it))
{
index_t old_i=it;
if(it.data_len>=val.size())save_data(it.data_offset,val);
else it.data_offset=append_data(val);
it.data_len=val.size();
if(old_i.data_offset==it.data_offset&&
old_i.data_len==it.data_len)
return false;
update_page(it);
return false;
}
index_t v;
v.key=key;
align_key(key,v);
v.data_len=val.size();
v.data_offset=append_data(val);
add_item(v);
return true;
}
void bin_index_t::file_node::add_item(const index_t& val)
{
if(root_page->items_count()<root_page->page_max)
{
add_item(val,*root_page);
return;
}
page_ptr new_root(create_page());
index_ref r=(*new_root)[0];
r.left()=root_page->page_offset;
add_item(val,*new_root);
root_page=new_root;
append_page(*new_root);
add_page(root_page);
save_index_data(0,new_root->page_offset);
}
static int insert_new_page_normal_style (HWND hwnd, PPROPSHEETDATA propsheet, PPROPPAGE page, DWORD style)
{
int require_width, index;
HDC hdc = GetClientDC (hwnd);
require_width = tab_required_width (hdc, propsheet, page);
ReleaseDC (hdc);
index = 0;
if (propsheet->active) {
show_hide_page (propsheet->active, SW_HIDE);
}
propsheet->active = page;
page->width = require_width;
index = append_page (propsheet, page);
update_propsheet (propsheet);
return index;
}
void bin_index_t::file_node::split_page(page_t& child_page,page_t& parent_page,size_t parent_index,page_t& new_right_page)
{
size_t left_count=(child_page.items_count()-1)/2;
std::copy(
child_page.buffer.begin()+idx_rec_len(aligned_key_len)*(left_count+1),
child_page.buffer.begin()+idx_rec_len(aligned_key_len)*(child_page.items_count()+1),
new_right_page.buffer.begin());
new_right_page.items_count()=child_page.items_count()-left_count-1;
append_page(new_right_page);
index_t val;
val=child_page[left_count];
val.index_in_page=parent_index;
val.left=child_page.page_offset;
parent_page.insert_item(val);
child_page.items_count()=left_count;
parent_page[parent_index+1].left()=new_right_page.page_offset;
child_page.dirty=true;
new_right_page.dirty=true;
}
DimRegionEdit::DimRegionEdit() :
eEG1PreAttack("Pre-attack", 0, 100, 2),
eEG1Attack("Attack", 0, 60, 3),
eEG1Decay1("Decay 1", 0.005, 60, 3),
eEG1Decay2("Decay 2", 0, 60, 3),
eEG1InfiniteSustain("Infinite sustain"),
eEG1Sustain("Sustain", 0, 100, 2),
eEG1Release("Release", 0, 60, 3),
eEG1Hold("Hold"),
eEG1Controller("Controller"),
eEG1ControllerInvert("Controller invert"),
eEG1ControllerAttackInfluence("Controller attack influence", 0, 3),
eEG1ControllerDecayInfluence("Controller decay influence", 0, 3),
eEG1ControllerReleaseInfluence("Controller release influence", 0, 3),
eLFO1Frequency("Frequency", 0.1, 10, 2),
eLFO1InternalDepth("Internal depth", 0, 1200),
eLFO1ControlDepth("Control depth", 0, 1200),
eLFO1Controller("Controller"),
eLFO1FlipPhase("Flip phase"),
eLFO1Sync("Sync"),
eEG2PreAttack("Pre-attack", 0, 100, 2),
eEG2Attack("Attack", 0, 60, 3),
eEG2Decay1("Decay 1", 0.005, 60, 3),
eEG2Decay2("Decay 2", 0, 60, 3),
eEG2InfiniteSustain("Infinite sustain"),
eEG2Sustain("Sustain", 0, 100, 2),
eEG2Release("Release", 0, 60, 3),
eEG2Controller("Controller"),
eEG2ControllerInvert("Controller invert"),
eEG2ControllerAttackInfluence("Controller attack influence", 0, 3),
eEG2ControllerDecayInfluence("Controller decay influence", 0, 3),
eEG2ControllerReleaseInfluence("Controller release influence", 0, 3),
eLFO2Frequency("Frequency", 0.1, 10, 2),
eLFO2InternalDepth("Internal depth", 0, 1200),
eLFO2ControlDepth("Control depth", 0, 1200),
eLFO2Controller("Controller"),
eLFO2FlipPhase("Flip phase"),
eLFO2Sync("Sync"),
eEG3Attack("Attack", 0, 10, 3),
eEG3Depth("Depth", -1200, 1200),
eLFO3Frequency("Frequency", 0.1, 10, 2),
eLFO3InternalDepth("Internal depth", 0, 1200),
eLFO3ControlDepth("Control depth", 0, 1200),
eLFO3Controller("Controller"),
eLFO3Sync("Sync"),
eVCFEnabled("Enabled"),
eVCFType("Type"),
eVCFCutoffController("Cutoff controller"),
eVCFCutoffControllerInvert("Cutoff controller invert"),
eVCFCutoff("Cutoff"),
eVCFVelocityCurve("Velocity curve"),
eVCFVelocityScale("Velocity scale"),
eVCFVelocityDynamicRange("Velocity dynamic range", 0, 4),
eVCFResonance("Resonance"),
eVCFResonanceDynamic("Resonance dynamic"),
eVCFResonanceController("Resonance controller"),
eVCFKeyboardTracking("Keyboard tracking"),
eVCFKeyboardTrackingBreakpoint("Keyboard tracking breakpoint"),
eVelocityResponseCurve("Velocity response curve"),
eVelocityResponseDepth("Velocity response depth", 0, 4),
eVelocityResponseCurveScaling("Velocity response curve scaling"),
eReleaseVelocityResponseCurve("Release velocity response curve"),
eReleaseVelocityResponseDepth("Release velocity response depth", 0, 4),
eReleaseTriggerDecay("Release trigger decay", 0, 8),
eCrossfade_in_start("Crossfade-in start"),
eCrossfade_in_end("Crossfade-in end"),
eCrossfade_out_start("Crossfade-out start"),
eCrossfade_out_end("Crossfade-out end"),
ePitchTrack("Pitch track"),
eDimensionBypass("Dimension bypass"),
ePan("Pan", -64, 63),
eSelfMask("Self mask"),
eAttenuationController("Attenuation controller"),
eInvertAttenuationController("Invert attenuation controller"),
eAttenuationControllerThreshold("Attenuation controller threshold"),
eChannelOffset("Channel offset", 0, 9),
eSustainDefeat("Sustain defeat"),
eMSDecode("MS decode"),
eSampleStartOffset("Sample start offset", 0, 2000),
eUnityNote("Unity note"),
eFineTune("Fine tune", -49, 50),
eGain("Gain", -96, 0, 2, -655360),
eGainPlus6("Gain +6dB", eGain, 6 * -655360),
eSampleLoopEnabled("Enabled"),
eSampleLoopStart("Loop start positon"),
eSampleLoopLength("Loop size"),
eSampleLoopType("Loop type"),
eSampleLoopInfinite("Infinite loop"),
eSampleLoopPlayCount("Playback count", 1),
update_model(0)
{
connect(eEG1PreAttack, &gig::DimensionRegion::EG1PreAttack);
connect(eEG1Attack, &gig::DimensionRegion::EG1Attack);
connect(eEG1Decay1, &gig::DimensionRegion::EG1Decay1);
connect(eEG1Decay2, &gig::DimensionRegion::EG1Decay2);
connect(eEG1InfiniteSustain, &gig::DimensionRegion::EG1InfiniteSustain);
connect(eEG1Sustain, &gig::DimensionRegion::EG1Sustain);
connect(eEG1Release, &gig::DimensionRegion::EG1Release);
connect(eEG1Hold, &gig::DimensionRegion::EG1Hold);
connect(eEG1Controller, &gig::DimensionRegion::EG1Controller);
connect(eEG1ControllerInvert, &gig::DimensionRegion::EG1ControllerInvert);
connect(eEG1ControllerAttackInfluence,
&gig::DimensionRegion::EG1ControllerAttackInfluence);
connect(eEG1ControllerDecayInfluence,
&gig::DimensionRegion::EG1ControllerDecayInfluence);
connect(eEG1ControllerReleaseInfluence,
&gig::DimensionRegion::EG1ControllerReleaseInfluence);
connect(eLFO1Frequency, &gig::DimensionRegion::LFO1Frequency);
connect(eLFO1InternalDepth, &gig::DimensionRegion::LFO1InternalDepth);
connect(eLFO1ControlDepth, &gig::DimensionRegion::LFO1ControlDepth);
connect(eLFO1Controller, &gig::DimensionRegion::LFO1Controller);
connect(eLFO1FlipPhase, &gig::DimensionRegion::LFO1FlipPhase);
connect(eLFO1Sync, &gig::DimensionRegion::LFO1Sync);
connect(eEG2PreAttack, &gig::DimensionRegion::EG2PreAttack);
connect(eEG2Attack, &gig::DimensionRegion::EG2Attack);
connect(eEG2Decay1, &gig::DimensionRegion::EG2Decay1);
connect(eEG2Decay2, &gig::DimensionRegion::EG2Decay2);
connect(eEG2InfiniteSustain, &gig::DimensionRegion::EG2InfiniteSustain);
connect(eEG2Sustain, &gig::DimensionRegion::EG2Sustain);
connect(eEG2Release, &gig::DimensionRegion::EG2Release);
connect(eEG2Controller, &gig::DimensionRegion::EG2Controller);
connect(eEG2ControllerInvert, &gig::DimensionRegion::EG2ControllerInvert);
connect(eEG2ControllerAttackInfluence,
&gig::DimensionRegion::EG2ControllerAttackInfluence);
connect(eEG2ControllerDecayInfluence,
&gig::DimensionRegion::EG2ControllerDecayInfluence);
connect(eEG2ControllerReleaseInfluence,
&gig::DimensionRegion::EG2ControllerReleaseInfluence);
connect(eLFO2Frequency, &gig::DimensionRegion::LFO2Frequency);
connect(eLFO2InternalDepth, &gig::DimensionRegion::LFO2InternalDepth);
connect(eLFO2ControlDepth, &gig::DimensionRegion::LFO2ControlDepth);
connect(eLFO2Controller, &gig::DimensionRegion::LFO2Controller);
connect(eLFO2FlipPhase, &gig::DimensionRegion::LFO2FlipPhase);
connect(eLFO2Sync, &gig::DimensionRegion::LFO2Sync);
connect(eEG3Attack, &gig::DimensionRegion::EG3Attack);
connect(eEG3Depth, &gig::DimensionRegion::EG3Depth);
connect(eLFO3Frequency, &gig::DimensionRegion::LFO3Frequency);
connect(eLFO3InternalDepth, &gig::DimensionRegion::LFO3InternalDepth);
connect(eLFO3ControlDepth, &gig::DimensionRegion::LFO3ControlDepth);
connect(eLFO3Controller, &gig::DimensionRegion::LFO3Controller);
connect(eLFO3Sync, &gig::DimensionRegion::LFO3Sync);
connect(eVCFEnabled, &gig::DimensionRegion::VCFEnabled);
connect(eVCFType, &gig::DimensionRegion::VCFType);
connect(eVCFCutoffController,
&gig::DimensionRegion::SetVCFCutoffController);
connect(eVCFCutoffControllerInvert,
&gig::DimensionRegion::VCFCutoffControllerInvert);
connect(eVCFCutoff, &gig::DimensionRegion::VCFCutoff);
connect(eVCFVelocityCurve, &gig::DimensionRegion::SetVCFVelocityCurve);
connect(eVCFVelocityScale, &gig::DimensionRegion::SetVCFVelocityScale);
connect(eVCFVelocityDynamicRange,
&gig::DimensionRegion::SetVCFVelocityDynamicRange);
connect(eVCFResonance, &gig::DimensionRegion::VCFResonance);
connect(eVCFResonanceDynamic, &gig::DimensionRegion::VCFResonanceDynamic);
connect(eVCFResonanceController,
&gig::DimensionRegion::VCFResonanceController);
connect(eVCFKeyboardTracking, &gig::DimensionRegion::VCFKeyboardTracking);
connect(eVCFKeyboardTrackingBreakpoint,
&gig::DimensionRegion::VCFKeyboardTrackingBreakpoint);
connect(eVelocityResponseCurve,
&gig::DimensionRegion::SetVelocityResponseCurve);
connect(eVelocityResponseDepth,
&gig::DimensionRegion::SetVelocityResponseDepth);
connect(eVelocityResponseCurveScaling,
&gig::DimensionRegion::SetVelocityResponseCurveScaling);
connect(eReleaseVelocityResponseCurve,
&gig::DimensionRegion::SetReleaseVelocityResponseCurve);
connect(eReleaseVelocityResponseDepth,
&gig::DimensionRegion::SetReleaseVelocityResponseDepth);
connect(eReleaseTriggerDecay, &gig::DimensionRegion::ReleaseTriggerDecay);
connect(eCrossfade_in_start, &DimRegionEdit::set_Crossfade_in_start);
connect(eCrossfade_in_end, &DimRegionEdit::set_Crossfade_in_end);
connect(eCrossfade_out_start, &DimRegionEdit::set_Crossfade_out_start);
connect(eCrossfade_out_end, &DimRegionEdit::set_Crossfade_out_end);
connect(ePitchTrack, &gig::DimensionRegion::PitchTrack);
connect(eDimensionBypass, &gig::DimensionRegion::DimensionBypass);
connect(ePan, &gig::DimensionRegion::Pan);
connect(eSelfMask, &gig::DimensionRegion::SelfMask);
connect(eAttenuationController,
&gig::DimensionRegion::AttenuationController);
connect(eInvertAttenuationController,
&gig::DimensionRegion::InvertAttenuationController);
connect(eAttenuationControllerThreshold,
&gig::DimensionRegion::AttenuationControllerThreshold);
connect(eChannelOffset, &gig::DimensionRegion::ChannelOffset);
connect(eSustainDefeat, &gig::DimensionRegion::SustainDefeat);
connect(eMSDecode, &gig::DimensionRegion::MSDecode);
connect(eSampleStartOffset, &gig::DimensionRegion::SampleStartOffset);
connect(eUnityNote, &DimRegionEdit::set_UnityNote);
connect(eFineTune, &DimRegionEdit::set_FineTune);
connect(eGain, &DimRegionEdit::set_Gain);
connect(eGainPlus6, &DimRegionEdit::set_Gain);
connect(eSampleLoopEnabled, &DimRegionEdit::set_LoopEnabled);
connect(eSampleLoopType, &DimRegionEdit::set_LoopType);
connect(eSampleLoopStart, &DimRegionEdit::set_LoopStart);
connect(eSampleLoopLength, &DimRegionEdit::set_LoopLength);
connect(eSampleLoopInfinite, &DimRegionEdit::set_LoopInfinite);
connect(eSampleLoopPlayCount, &DimRegionEdit::set_LoopPlayCount);
for (int i = 0 ; i < 7 ; i++) {
table[i] = new Gtk::Table(3, 1);
table[i]->set_col_spacings(7);
}
// set tooltips
eUnityNote.set_tip(
_("Note this sample is associated with (a.k.a. 'root note')")
);
eSampleStartOffset.set_tip(_("Sample position at which playback should be started"));
ePan.set_tip(_("Stereo balance (left/right)"));
eChannelOffset.set_tip(
_("Output channel where the audio signal should be routed to (0 - 9)")
);
ePitchTrack.set_tip(
_("If true: sample will be pitched according to the key position "
"(this would be disabled for drums for example)")
);
eSampleLoopEnabled.set_tip(_("If enabled: repeats to playback the sample"));
eSampleLoopStart.set_tip(
_("Start position within the sample (in sample points) of the area to "
"be looped")
);
eSampleLoopLength.set_tip(
_("Duration (in sample points) of the area to be looped")
);
eSampleLoopType.set_tip(
_("Direction in which the loop area in the sample should be played back")
);
eSampleLoopInfinite.set_tip(
_("Whether the loop area should be played back forever\n"
"Caution: this setting is stored on Sample side, thus is shared "
"among all dimension regions that use this sample!")
);
eSampleLoopPlayCount.set_tip(
_("How many times the loop area should be played back\n"
"Caution: this setting is stored on Sample side, thus is shared "
"among all dimension regions that use this sample!")
);
pageno = 0;
rowno = 0;
firstRowInBlock = 0;
addHeader(_("Mandatory Settings"));
addString("Sample", lSample, wSample);
//TODO: the following would break drag&drop: wSample->property_editable().set_value(false); or this: wSample->set_editable(false);
tooltips.set_tip(*wSample, _("Drop a sample here"));
addProp(eUnityNote);
addHeader(_("Optional Settings"));
addProp(eSampleStartOffset);
addProp(eChannelOffset);
addHeader("Loops");
addProp(eSampleLoopEnabled);
addProp(eSampleLoopStart);
addProp(eSampleLoopLength);
{
const char* choices[] = { "normal", "bidirectional", "backward", 0 };
static const uint32_t values[] = {
gig::loop_type_normal,
gig::loop_type_bidirectional,
gig::loop_type_backward
};
eSampleLoopType.set_choices(choices, values);
}
addProp(eSampleLoopType);
addProp(eSampleLoopInfinite);
addProp(eSampleLoopPlayCount);
nextPage();
addHeader(_("General Amplitude Settings"));
addProp(eGain);
addProp(eGainPlus6);
addProp(ePan);
addHeader(_("Amplitude Envelope (EG1)"));
addProp(eEG1PreAttack);
addProp(eEG1Attack);
addProp(eEG1Decay1);
addProp(eEG1Decay2);
addProp(eEG1InfiniteSustain);
addProp(eEG1Sustain);
addProp(eEG1Release);
addProp(eEG1Hold);
addProp(eEG1Controller);
addProp(eEG1ControllerInvert);
addProp(eEG1ControllerAttackInfluence);
addProp(eEG1ControllerDecayInfluence);
addProp(eEG1ControllerReleaseInfluence);
nextPage();
addHeader(_("Amplitude Oscillator (LFO1)"));
addProp(eLFO1Frequency);
addProp(eLFO1InternalDepth);
addProp(eLFO1ControlDepth);
{
const char* choices[] = { "internal", "modwheel", "breath",
"internal+modwheel", "internal+breath", 0 };
static const gig::lfo1_ctrl_t values[] = {
gig::lfo1_ctrl_internal,
gig::lfo1_ctrl_modwheel,
gig::lfo1_ctrl_breath,
gig::lfo1_ctrl_internal_modwheel,
gig::lfo1_ctrl_internal_breath
};
eLFO1Controller.set_choices(choices, values);
}
addProp(eLFO1Controller);
addProp(eLFO1FlipPhase);
addProp(eLFO1Sync);
addHeader("Crossfade");
addProp(eAttenuationController);
addProp(eInvertAttenuationController);
addProp(eAttenuationControllerThreshold);
addProp(eCrossfade_in_start);
addProp(eCrossfade_in_end);
addProp(eCrossfade_out_start);
addProp(eCrossfade_out_end);
nextPage();
addHeader(_("General Filter Settings"));
addProp(eVCFEnabled);
{
const char* choices[] = { "lowpass", "lowpassturbo", "bandpass",
"highpass", "bandreject", 0 };
static const gig::vcf_type_t values[] = {
gig::vcf_type_lowpass,
gig::vcf_type_lowpassturbo,
gig::vcf_type_bandpass,
gig::vcf_type_highpass,
gig::vcf_type_bandreject
};
eVCFType.set_choices(choices, values);
}
addProp(eVCFType);
{
const char* choices[] = { "none", "none2", "modwheel", "effect1", "effect2",
"breath", "foot", "sustainpedal", "softpedal",
"genpurpose7", "genpurpose8", "aftertouch", 0 };
static const gig::vcf_cutoff_ctrl_t values[] = {
gig::vcf_cutoff_ctrl_none,
gig::vcf_cutoff_ctrl_none2,
gig::vcf_cutoff_ctrl_modwheel,
gig::vcf_cutoff_ctrl_effect1,
gig::vcf_cutoff_ctrl_effect2,
gig::vcf_cutoff_ctrl_breath,
gig::vcf_cutoff_ctrl_foot,
gig::vcf_cutoff_ctrl_sustainpedal,
gig::vcf_cutoff_ctrl_softpedal,
gig::vcf_cutoff_ctrl_genpurpose7,
gig::vcf_cutoff_ctrl_genpurpose8,
gig::vcf_cutoff_ctrl_aftertouch
};
eVCFCutoffController.set_choices(choices, values);
}
addProp(eVCFCutoffController);
addProp(eVCFCutoffControllerInvert);
addProp(eVCFCutoff);
const char* curve_type_texts[] = { "nonlinear", "linear", "special", 0 };
static const gig::curve_type_t curve_type_values[] = {
gig::curve_type_nonlinear,
gig::curve_type_linear,
gig::curve_type_special
};
eVCFVelocityCurve.set_choices(curve_type_texts, curve_type_values);
addProp(eVCFVelocityCurve);
addProp(eVCFVelocityScale);
addProp(eVCFVelocityDynamicRange);
addProp(eVCFResonance);
addProp(eVCFResonanceDynamic);
{
const char* choices[] = { "none", "genpurpose3", "genpurpose4",
"genpurpose5", "genpurpose6", 0 };
static const gig::vcf_res_ctrl_t values[] = {
gig::vcf_res_ctrl_none,
gig::vcf_res_ctrl_genpurpose3,
gig::vcf_res_ctrl_genpurpose4,
gig::vcf_res_ctrl_genpurpose5,
gig::vcf_res_ctrl_genpurpose6
};
eVCFResonanceController.set_choices(choices, values);
}
addProp(eVCFResonanceController);
addProp(eVCFKeyboardTracking);
addProp(eVCFKeyboardTrackingBreakpoint);
nextPage();
addHeader(_("Filter Cutoff Envelope (EG2)"));
addProp(eEG2PreAttack);
addProp(eEG2Attack);
addProp(eEG2Decay1);
addProp(eEG2Decay2);
addProp(eEG2InfiniteSustain);
addProp(eEG2Sustain);
addProp(eEG2Release);
addProp(eEG2Controller);
addProp(eEG2ControllerInvert);
addProp(eEG2ControllerAttackInfluence);
addProp(eEG2ControllerDecayInfluence);
addProp(eEG2ControllerReleaseInfluence);
addHeader(_("Filter Cutoff Oscillator (LFO2)"));
addProp(eLFO2Frequency);
addProp(eLFO2InternalDepth);
addProp(eLFO2ControlDepth);
{
const char* choices[] = { "internal", "modwheel", "foot",
"internal+modwheel", "internal+foot", 0 };
static const gig::lfo2_ctrl_t values[] = {
gig::lfo2_ctrl_internal,
gig::lfo2_ctrl_modwheel,
gig::lfo2_ctrl_foot,
gig::lfo2_ctrl_internal_modwheel,
gig::lfo2_ctrl_internal_foot
};
eLFO2Controller.set_choices(choices, values);
}
addProp(eLFO2Controller);
addProp(eLFO2FlipPhase);
addProp(eLFO2Sync);
nextPage();
addHeader(_("General Pitch Settings"));
addProp(eFineTune);
addProp(ePitchTrack);
addHeader(_("Pitch Envelope (EG3)"));
addProp(eEG3Attack);
addProp(eEG3Depth);
addHeader(_("Pitch Oscillator (LFO3)"));
addProp(eLFO3Frequency);
addProp(eLFO3InternalDepth);
addProp(eLFO3ControlDepth);
{
const char* choices[] = { "internal", "modwheel", "aftertouch",
"internal+modwheel", "internal+aftertouch", 0 };
static const gig::lfo3_ctrl_t values[] = {
gig::lfo3_ctrl_internal,
gig::lfo3_ctrl_modwheel,
gig::lfo3_ctrl_aftertouch,
gig::lfo3_ctrl_internal_modwheel,
gig::lfo3_ctrl_internal_aftertouch
};
eLFO3Controller.set_choices(choices, values);
}
addProp(eLFO3Controller);
addProp(eLFO3Sync);
nextPage();
eVelocityResponseCurve.set_choices(curve_type_texts, curve_type_values);
addProp(eVelocityResponseCurve);
addProp(eVelocityResponseDepth);
addProp(eVelocityResponseCurveScaling);
eReleaseVelocityResponseCurve.set_choices(curve_type_texts,
curve_type_values);
addProp(eReleaseVelocityResponseCurve);
addProp(eReleaseVelocityResponseDepth);
addProp(eReleaseTriggerDecay);
{
const char* choices[] = { "none", "effect4depth", "effect5depth", 0 };
static const gig::dim_bypass_ctrl_t values[] = {
gig::dim_bypass_ctrl_none,
gig::dim_bypass_ctrl_94,
gig::dim_bypass_ctrl_95
};
eDimensionBypass.set_choices(choices, values);
}
addProp(eDimensionBypass);
addProp(eSelfMask);
addProp(eSustainDefeat);
addProp(eMSDecode);
nextPage();
eEG1InfiniteSustain.signal_value_changed().connect(
sigc::mem_fun(*this, &DimRegionEdit::EG1InfiniteSustain_toggled));
eEG2InfiniteSustain.signal_value_changed().connect(
sigc::mem_fun(*this, &DimRegionEdit::EG2InfiniteSustain_toggled));
eEG1Controller.signal_value_changed().connect(
sigc::mem_fun(*this, &DimRegionEdit::EG1Controller_changed));
eEG2Controller.signal_value_changed().connect(
sigc::mem_fun(*this, &DimRegionEdit::EG2Controller_changed));
eLFO1Controller.signal_value_changed().connect(
sigc::mem_fun(*this, &DimRegionEdit::LFO1Controller_changed));
eLFO2Controller.signal_value_changed().connect(
sigc::mem_fun(*this, &DimRegionEdit::LFO2Controller_changed));
eLFO3Controller.signal_value_changed().connect(
sigc::mem_fun(*this, &DimRegionEdit::LFO3Controller_changed));
eAttenuationController.signal_value_changed().connect(
sigc::mem_fun(*this, &DimRegionEdit::AttenuationController_changed));
eVCFEnabled.signal_value_changed().connect(
sigc::mem_fun(*this, &DimRegionEdit::VCFEnabled_toggled));
eVCFCutoffController.signal_value_changed().connect(
sigc::mem_fun(*this, &DimRegionEdit::VCFCutoffController_changed));
eVCFResonanceController.signal_value_changed().connect(
sigc::mem_fun(*this, &DimRegionEdit::VCFResonanceController_changed));
eCrossfade_in_start.signal_value_changed().connect(
sigc::mem_fun(*this, &DimRegionEdit::crossfade1_changed));
eCrossfade_in_end.signal_value_changed().connect(
sigc::mem_fun(*this, &DimRegionEdit::crossfade2_changed));
eCrossfade_out_start.signal_value_changed().connect(
sigc::mem_fun(*this, &DimRegionEdit::crossfade3_changed));
eCrossfade_out_end.signal_value_changed().connect(
sigc::mem_fun(*this, &DimRegionEdit::crossfade4_changed));
eSampleLoopEnabled.signal_value_changed().connect(
sigc::mem_fun(*this, &DimRegionEdit::update_loop_elements));
eSampleLoopStart.signal_value_changed().connect(
sigc::mem_fun(*this, &DimRegionEdit::loop_start_changed));
eSampleLoopLength.signal_value_changed().connect(
sigc::mem_fun(*this, &DimRegionEdit::loop_length_changed));
eSampleLoopInfinite.signal_value_changed().connect(
sigc::mem_fun(*this, &DimRegionEdit::loop_infinite_toggled));
append_page(*table[0], "Sample");
append_page(*table[1], "Amplitude (1)");
append_page(*table[2], "Amplitude (2)");
append_page(*table[3], "Filter (1)");
append_page(*table[4], "Filter (2)");
append_page(*table[5], "Pitch");
append_page(*table[6], "Misc");
}
/* window procedure of the property sheet. */
static int
PropSheetCtrlProc (HWND hwnd, int message, WPARAM wParam, LPARAM lParam)
{
PCONTROL ctrl;
PPROPSHEETDATA propsheet;
ctrl = gui_Control (hwnd);
propsheet = (PROPSHEETDATA *) ctrl->dwAddData2;
switch (message) {
case MSG_CREATE: {
#ifdef __TARGET_MSTUDIO__
SetWindowBkColor(hwnd,
GetWindowElementPixel (hwnd, WE_MAINC_THREED_BODY));
#endif
if (!(propsheet = calloc (1, sizeof (PROPSHEETDATA)))) {
return -1;
}
ctrl->dwAddData2 = (DWORD)propsheet;
break;
}
/* make the client size same as window size */
case MSG_SIZECHANGED: {
const RECT* rcWin = (RECT *)wParam;
RECT* rcClient = (RECT *)lParam;
/* cale the width of content page */
*rcClient = *rcWin;
propsheet->head_rc.right = RECTWP (rcClient);
if ((ctrl->dwStyle & 0xf0L) == PSS_BOTTOM) {
propsheet->head_rc.top = RECTHP (rcClient) - get_metrics (MWM_ICONY)
- 2 - _ICON_OFFSET * 2;
propsheet->head_rc.bottom = RECTHP (rcClient);
} else {
propsheet->head_rc.bottom = get_metrics (MWM_ICONY) + 2
+ _ICON_OFFSET * 2;
}
if ((ctrl->dwStyle & 0x0fL)!= PSS_SCROLLABLE) {
recalc_tab_widths (hwnd, propsheet, ctrl->dwStyle);
} else {
HDC hdc;
propsheet->head_width = propsheet->head_rc.right;
if (propsheet->head) {
PPROPPAGE page;
hdc = GetClientDC(hwnd);
page = propsheet->head;
while(page) {
page->width = tab_required_width (hdc, propsheet, page);
page = page->next;
}
ReleaseDC (hdc);
update_propsheet (propsheet);
}
}
resize_children (propsheet, rcClient, ctrl->dwStyle);
InvalidateRect (hwnd, &propsheet->head_rc, TRUE);
return 1;
}
case MSG_DESTROY: {
PPROPPAGE page, temp;
page = propsheet->head;
while (page) {
temp = page->next;
destroy_page (page);
free (page);
page = temp;
}
free (propsheet);
break;
}
case MSG_GETDLGCODE: {
return DLGC_WANTTAB | DLGC_WANTARROWS;
}
case PSM_SHEETCMD: {
int index = 0;
PPROPPAGE page = propsheet->head;
while (page) {
if (SendMessage (page->hwnd, MSG_SHEETCMD, wParam, lParam))
/* when encounter an error, return page index plus 1. */
return index + 1;
index++;
page = page->next;
}
return 0; /* success */
}
case PSM_SETACTIVEINDEX: {
PPROPPAGE page;
if ((page = get_page (propsheet, wParam)) && page != propsheet->active) {
show_hide_page (propsheet->active, SW_HIDE);
propsheet->active = page;
update_propsheet (propsheet);
NotifyParent (hwnd, ctrl->id, PSN_ACTIVE_CHANGED);
show_hide_page (page, SW_SHOW);
InvalidateRect (hwnd, &propsheet->head_rc, TRUE);
return PS_OKAY;
}
return PS_ERR;
}
case PSM_GETACTIVEINDEX: {
int index = 0;
PPROPPAGE page = propsheet->head;
while (page) {
if (page == propsheet->active) {
return index;
}
index ++;
page = page->next;
}
return PS_ERR;
}
case PSM_GETACTIVEPAGE: {
return (propsheet->active) ?
propsheet->active->hwnd : HWND_INVALID;
}
case PSM_GETPAGE: {
int index = 0;
PPROPPAGE page = propsheet->head;
while (page) {
if (index == wParam) {
return page->hwnd;
}
index ++;
page = page->next;
}
return HWND_INVALID;
}
case PSM_GETPAGEINDEX: {
int index = 0;
PPROPPAGE page = propsheet->head;
while (page) {
if (page->hwnd == wParam) {
return index;
}
index ++;
page = page->next;
}
return PS_ERR;
}
case PSM_GETPAGECOUNT: {
return propsheet->page_count;
}
case PSM_GETTITLELENGTH: {
int len = PS_ERR;
PPROPPAGE page;
if ((page = get_page (propsheet, wParam))) {
len = strlen (page->title);
}
return len;
}
case PSM_GETTITLE: {
char* buffer = (char*)lParam;
PPROPPAGE page;
if ((page = get_page (propsheet, wParam))) {
strcpy (buffer, page->title);
return PS_OKAY;
}
return PS_ERR;
}
case PSM_SETTITLE: {
BOOL rc = PS_ERR;
char* buffer = (char*)lParam;
PPROPPAGE page;
HDC hdc;
if ((ctrl->dwStyle & 0x0fL) != PSS_SCROLLABLE) {
if ((page = get_page (propsheet, wParam))) {
rc = set_page_title (page, buffer);
recalc_tab_widths (hwnd, propsheet, ctrl->dwStyle);
InvalidateRect (hwnd, &propsheet->head_rc, TRUE);
}
} else {
if ((page = get_page (propsheet, wParam))) {
hdc = GetClientDC (hwnd);
rc = set_page_title_normal_style (hdc, propsheet, page, buffer);
ReleaseDC (hdc);
InvalidateRect (hwnd, &propsheet->head_rc, TRUE);
}
}
return rc;
}
case PSM_ADDPAGE: {
if ((ctrl->dwStyle & 0x0fL) != PSS_SCROLLABLE) {
int index;
PPROPPAGE page;
if ((propsheet->head_rc.right / (propsheet->page_count + 1)) <
_MIN_TAB_WIDTH) {
return PS_ERR;
}
if (!(page = calloc (1, sizeof (PROPPAGE)))) {
return PS_ERR;
}
if (!create_page (hwnd, ctrl->dwStyle, propsheet, page,
(DLGTEMPLATE *)wParam, (WNDPROC)lParam)) {
free (page);
return PS_ERR;
}
index = append_page (propsheet, page);
if (propsheet->active) {
show_hide_page (propsheet->active, SW_HIDE);
}
propsheet->active = page;
NotifyParent (hwnd, ctrl->id, PSN_ACTIVE_CHANGED);
show_hide_page (page, SW_SHOW);
recalc_tab_widths (hwnd, propsheet, ctrl->dwStyle);
InvalidateRect (hwnd, &propsheet->head_rc, TRUE);
return index;
} else {
return add_new_page_normal_style (hwnd, ctrl,
propsheet, (DLGTEMPLATE *)wParam,
(WNDPROC)lParam);
}
}
case PSM_REMOVEPAGE: {
if ((ctrl->dwStyle & 0x0fL) != PSS_SCROLLABLE) {
PPROPPAGE page;
if ((page = get_page (propsheet, wParam))) {
remove_page (propsheet, page);
destroy_page (page);
free (page);
recalc_tab_widths (hwnd, propsheet, ctrl->dwStyle);
} else {
return PS_ERR;
}
if (propsheet->active == page) {
propsheet->active = propsheet->head;
NotifyParent (hwnd, ctrl->id, PSN_ACTIVE_CHANGED);
if (propsheet->active) {
show_hide_page (propsheet->active, SW_SHOW);
}
}
InvalidateRect (hwnd, &propsheet->head_rc, TRUE);
return PS_OKAY;
} else {
return delete_page (hwnd, ctrl, propsheet, wParam);
}
}
case MSG_LBUTTONDOWN: {
click_tab_bar (hwnd, ctrl, propsheet, lParam);
/* dump_propsheetdata (propsheet); */
break;
}
case MSG_KEYDOWN: {
PPROPPAGE page, new_active = NULL;
if (!(lParam & KS_CTRL) || (propsheet->head == NULL)) {
break;
}
/* Key borad message for PSS_COMPACTTAB and PSS_SIMPLE */
switch (LOWORD (wParam)) {
case SCANCODE_CURSORBLOCKDOWN:
case SCANCODE_CURSORBLOCKRIGHT:
if ((ctrl->dwStyle & 0x0fL)!= PSS_SCROLLABLE) {
new_active = propsheet->active->next;
if (new_active == NULL)
new_active = propsheet->head;
break;
} else {
scroll_tab_right (hwnd, ctrl, propsheet);
InvalidateRect (hwnd, &propsheet->head_rc, TRUE);
return 0;
}
case SCANCODE_CURSORBLOCKUP:
case SCANCODE_CURSORBLOCKLEFT:
if ((ctrl->dwStyle & 0x0fL)!= PSS_SCROLLABLE) {
page = propsheet->head;
if (propsheet->head == propsheet->active) {
while (page && page->next) {
page = page->next;
}
} else {
while (page) {
if (page->next == propsheet->active)
break;
page = page->next;
}
}
new_active = page;
break;
} else {
scroll_tab_left (hwnd, ctrl, propsheet);
InvalidateRect (hwnd, &propsheet->head_rc, TRUE);
return 0;
}
} /* switch */
if (new_active == NULL) {
break;
}
show_hide_page (propsheet->active, SW_HIDE);
propsheet->active = new_active;
NotifyParent (hwnd, ctrl->id, PSN_ACTIVE_CHANGED);
show_hide_page (new_active, SW_SHOW);
InvalidateRect (hwnd, &propsheet->head_rc, TRUE);
return 0;
}
case MSG_NCPAINT:
case MSG_PAINT: {
HDC hdc = BeginPaint (hwnd);
PPROPPAGE page = ((ctrl->dwStyle & 0x0fL) == PSS_SCROLLABLE) ?
propsheet->first_display_page : propsheet->head;
draw_propsheet (hwnd, hdc, ctrl, propsheet, page);
EndPaint (hwnd, hdc);
return 0;
}
default:
break;
}
return DefaultControlProc (hwnd, message, wParam, lParam);
}
GenericAssistant::GenericAssistant
(
std::string assistantTitle,
std::vector<std::string> assistantLabels,
std::vector<std::string> assistantPlaceholders,
bool assistantModalMode
)
{
set_title(assistantTitle);
set_default_size (323, 200);
set_modal(assistantModalMode);
container = manage(new Gtk::Box(Gtk::ORIENTATION_VERTICAL,(2*assistantLabels.size())-1));
for (unsigned int i=0;i<assistantLabels.size();i++)
{
Gtk::Box * b = manage(new Gtk::Box(Gtk::ORIENTATION_HORIZONTAL,3));
Gtk::Label * l = manage(new Gtk::Label(assistantLabels.at(i)));
b->add(*l);
Gtk::AspectFrame * af = manage(new Gtk::AspectFrame());
b->add(*af);
// entry and placeholder....
Gtk::Entry * e = manage(new Gtk::Entry());
e->set_placeholder_text(assistantPlaceholders.at(i).c_str());
b->add(*e);
// record the entry's content
Entry.push_back(e);
// show_children
b->show_all_children();
// add
container->add(*b);
if (assistantLabels.size()-1 != i)
{
Gtk::AspectFrame * af = manage(new Gtk::AspectFrame());
container->add(*af);
}
}
container->show_all_children();
// set assistant pages and config it
append_page(*container);
set_page_complete(*container, true);
set_page_type(*container, Gtk::ASSISTANT_PAGE_CONFIRM);
show_all_children();
// close or cancel the assistant
signal_cancel().connect
(
sigc::mem_fun
(
*this,
&GenericAssistant::on_assistant_cancel
)
);
signal_close().connect
(
sigc::mem_fun
(
*this,
&GenericAssistant::on_assistant_close
)
);
}
