guionly/plugin/ui.cpp

#include "ui.hpp"

#include "chassis.hpp"

START_NAMESPACE_DISTRHO

namespace Art = Artwork;

DistrhoUIchassis::DistrhoUIchassis() : UI(Art::backgroundWidth, Art::backgroundHeight, true),
                                       fImgBackground(Art::backgroundData, Art::backgroundWidth, Art::backgroundHeight, kImageFormatRGB)

{
    Image orangeSlider(Art::orangeData, Art::sliderWidth, Art::sliderHeight, kImageFormatRGBA);
    Image greenSlider(Art::greenData, Art::sliderWidth, Art::sliderHeight, kImageFormatRGBA);
    Image blueSlider(Art::blueData, Art::sliderWidth, Art::sliderHeight, kImageFormatRGBA);
    Image whiteSlider(Art::whiteData, Art::sliderWidth, Art::sliderHeight, kImageFormatRGBA);

    xSliderLFORate = new ImageSlider(this, orangeSlider);
    xSliderLFORate->setId(Chassis::pLFORate);
    xSliderLFORate->setStartPos(50, 72);
    xSliderLFORate->setEndPos(50, 151);
    xSliderLFORate->setRange(0, 127.0f);
    xSliderLFORate->setCallback(this);

    xSliderLFODelay = new ImageSlider(this, orangeSlider);
    xSliderLFODelay->setId(Chassis::pLFODelay);
    xSliderLFODelay->setStartPos(92, 72);
    xSliderLFODelay->setEndPos(92, 151);
    xSliderLFODelay->setRange(0, 127.0f);
    xSliderLFODelay->setCallback(this);

    xSliderLFODepth = new ImageSlider(this, greenSlider);
    xSliderLFODepth->setId(Chassis::pLFODepth);
    xSliderLFODepth->setStartPos(292, 72);
    xSliderLFODepth->setEndPos(292, 151);
    xSliderLFODepth->setRange(0, 127.0f);
    xSliderLFODepth->setCallback(this);

    xSliderPWMDepth = new ImageSlider(this, greenSlider);
    xSliderPWMDepth->setId(Chassis::pPWMDepth);
    xSliderPWMDepth->setStartPos(331, 72);
    xSliderPWMDepth->setEndPos(331, 151);
    xSliderPWMDepth->setRange(0, 127.0f);
    xSliderPWMDepth->setCallback(this);

    xSliderSubLevel = new ImageSlider(this, greenSlider);
    xSliderSubLevel->setId(Chassis::pSubLevel);
    xSliderSubLevel->setStartPos(518, 72);
    xSliderSubLevel->setEndPos(518, 151);
    xSliderSubLevel->setRange(0, 127.0f);
    xSliderSubLevel->setCallback(this);

    xSliderNoiseLevel = new ImageSlider(this, greenSlider);
    xSliderNoiseLevel->setId(Chassis::pNoiseLevel);
    xSliderNoiseLevel->setStartPos(560, 72);
    xSliderNoiseLevel->setEndPos(560, 151);
    xSliderNoiseLevel->setRange(0, 127.0f);
    xSliderNoiseLevel->setCallback(this);

    xSliderHPF = new ImageSlider(this, blueSlider);
    xSliderHPF->setId(Chassis::pHPF);
    xSliderHPF->setStartPos(619, 72);
    xSliderHPF->setEndPos(619, 151);
    xSliderHPF->setRange(0, 3.0f);
    xSliderHPF->setStep(1);
    xSliderHPF->setCallback(this);

    xSliderCutoff = new ImageSlider(this, blueSlider);
    xSliderCutoff->setId(Chassis::pCutoff);
    xSliderCutoff->setStartPos(21, 261);
    xSliderCutoff->setEndPos(21, 340);
    xSliderCutoff->setRange(0, 127.0f);
    xSliderCutoff->setCallback(this);

    xSliderRes = new ImageSlider(this, blueSlider);
    xSliderRes->setId(Chassis::pRes);
    xSliderRes->setStartPos(60, 261);
    xSliderRes->setEndPos(60, 340);
    xSliderRes->setRange(0, 127.0f);
    xSliderRes->setCallback(this);

    xSliderEnv = new ImageSlider(this, blueSlider);
    xSliderEnv->setId(Chassis::pEnv);
    xSliderEnv->setStartPos(144, 261);
    xSliderEnv->setEndPos(144, 340);
    xSliderEnv->setRange(0, 127.0f);
    xSliderEnv->setCallback(this);

    xSliderLfo = new ImageSlider(this, blueSlider);
    xSliderLfo->setId(Chassis::pLfo);
    xSliderLfo->setStartPos(183, 261);
    xSliderLfo->setEndPos(183, 340);
    xSliderLfo->setRange(0, 127.0f);
    xSliderLfo->setCallback(this);

    xSliderKyb = new ImageSlider(this, blueSlider);
    xSliderKyb->setId(Chassis::pKyb);
    xSliderKyb->setStartPos(222, 261);
    xSliderKyb->setEndPos(222, 340);
    xSliderKyb->setRange(0, 127.0f);
    xSliderKyb->setCallback(this);

    xSliderVCALevel = new ImageSlider(this, whiteSlider);
    xSliderVCALevel->setId(Chassis::pVCALevel);
    xSliderVCALevel->setStartPos(314, 261);
    xSliderVCALevel->setEndPos(314, 340);
    xSliderVCALevel->setRange(0, 127.0f);
    xSliderVCALevel->setCallback(this);

    xSliderAtk = new ImageSlider(this, whiteSlider);
    xSliderAtk->setId(Chassis::pAtk);
    xSliderAtk->setStartPos(375, 261);
    xSliderAtk->setEndPos(375, 340);
    xSliderAtk->setRange(0, 127.0f);
    xSliderAtk->setCallback(this);

    xSliderDcy = new ImageSlider(this, whiteSlider);
    xSliderDcy->setId(Chassis::pDcy);
    xSliderDcy->setStartPos(414, 261);
    xSliderDcy->setEndPos(414, 340);
    xSliderDcy->setRange(0, 127.0f);
    xSliderDcy->setCallback(this);

    xSliderStn = new ImageSlider(this, whiteSlider);
    xSliderStn->setId(Chassis::pStn);
    xSliderStn->setStartPos(454, 261);
    xSliderStn->setEndPos(454, 340);
    xSliderStn->setRange(0, 127.0f);
    xSliderStn->setCallback(this);

    xSliderRls = new ImageSlider(this, whiteSlider);
    xSliderRls->setId(Chassis::pRls);
    xSliderRls->setStartPos(493, 261);
    xSliderRls->setEndPos(493, 340);
    xSliderRls->setRange(0, 127.0f);
    xSliderRls->setCallback(this);

    programLoaded(0);
}

DistrhoUIchassis::~DistrhoUIchassis() {
    printf("Called destructor for UI\n");
}

void DistrhoUIchassis::programLoaded(uint32_t index) {
    printf("in programLoaded %d\n", index);
    switch (index) {
        case Chassis::pLFORate:
            xSliderLFORate->setValue(0.5);
            printf("set lforate\n");
            break;
        case Chassis::pLFODelay:
            xSliderLFODelay->setValue(0.5);
            printf("set lfoDelay\n");
            break;
    }
}
void DistrhoUIchassis::parameterChanged(uint32_t index, float value) {
    // printf("in parameterchanged %d %f\n", index, value);
    if (index == Chassis::pLFORate) {
        xSliderLFORate->setValue(value);
    }
    if (index == Chassis::pLFODelay) {
        xSliderLFODelay->setValue(value);
    }

    switch(index) {
        case Chassis::pLFORate: xSliderLFORate->setValue(value); break;
        case Chassis::pLFODelay: xSliderLFODelay->setValue(value); break;
        case Chassis::pLFODepth: xSliderLFODepth->setValue(value); break;
        case Chassis::pPWMDepth: xSliderPWMDepth->setValue(value); break;
        case Chassis::pSubLevel: xSliderSubLevel->setValue(value); break;
        case Chassis::pNoiseLevel: xSliderNoiseLevel->setValue(value); break;
        case Chassis::pHPF: xSliderHPF->setValue(value); break;
        case Chassis::pCutoff: xSliderCutoff->setValue(value); break;
        case Chassis::pRes: xSliderRes->setValue(value); break;
        case Chassis::pEnv: xSliderEnv->setValue(value); break;
        case Chassis::pLfo: xSliderLfo->setValue(value); break;
        case Chassis::pKyb: xSliderKyb->setValue(value); break;


    }

}

void DistrhoUIchassis::imageSliderDragStarted(ImageSlider* slider) {
    editParameter(slider->getId(), true);
}

void DistrhoUIchassis::imageSliderDragFinished(ImageSlider* slider) {
    editParameter(slider->getId(), false);
}

void DistrhoUIchassis::imageSliderValueChanged(ImageSlider* slider, float value) {
    printf("%f\n", value);
    setParameterValue(slider->getId(), value);
}

void DistrhoUIchassis::onDisplay() {
    const GraphicsContext& context(getGraphicsContext());
    fImgBackground.draw(context);
};

UI* createUI() {
    return new DistrhoUIchassis();
}

END_NAMESPACE_DISTRHO