customviews.h

Go to the documentation of this file.

// -----------------------------------------------------------------------------
//    ASPiK Custom Views File:  customviews.h
//
// -----------------------------------------------------------------------------
#pragma once
#include "vstgui/vstgui.h"
#include "vstgui/vstgui_uidescription.h" // for IController
 
#include "../PluginKernel/pluginstructures.h"
// #pragma warning(disable: 4244)
 
namespace VSTGUI {
 
// --- with an update cycle of ~50mSec, we need at least 2205 samples; this should be more than enough
const int DATA_QUEUE_LEN = 4096;
 
// --- custom message; add more here...
const unsigned int MESSAGE_SET_STRINGLIST = 0;
const unsigned int MESSAGE_SET_STRING = 1;
 
 
class WaveView : public CControl, public ICustomView
{
public:
    WaveView(const CRect& size, IControlListener* listener, int32_t tag);
    ~WaveView();
 
    virtual void updateView() override;
 
    virtual void pushDataValue(double data) override;
 
    void addWaveDataPoint(float fSample);
 
    void clearBuffer();
 
    void showXAxis(bool _paintXAxis) { paintXAxis = _paintXAxis; }
 
    void draw(CDrawContext* pContext) override;
 
    // --- for CControl pure abstract functions
    CLASS_METHODS(WaveView, CControl)
 
protected:
    // --- turn on/off zerodB line
    bool paintXAxis = true; 
 
    // --- circular buffer and index values
    double* circularBuffer = nullptr;   
    int writeIndex = 0;     
    int readIndex = 0;      
    int circularBufferLength = 0;
    CRect currentRect;      
 
private:
    // --- lock-free queue for incoming data, sized to DATA_QUEUE_LEN in length
    moodycamel::ReaderWriterQueue<double, DATA_QUEUE_LEN>* dataQueue = nullptr; 
 
};
 
#ifdef HAVE_FFTW
// --- FFTW (REQUIRED)
#include "fftw3.h"
 
enum class spectrumViewWindowType {kRectWindow, kHannWindow, kBlackmanHarrisWindow};
 
// --- change this for higher accuracy; needs to be power of 2
const int FFT_LEN = 512;
 
// --- SpectrumView
/*
*/
class SpectrumView : public CControl, public ICustomView
{
public:
    SpectrumView(const CRect& size, IControlListener* listener, int32_t tag);
    ~SpectrumView();
 
    virtual void updateView() override;
 
    virtual void pushDataValue(double data) override;
 
    void showFilledFFT(bool _filledFFT) { filledFFT = _filledFFT; }
 
    void setWindow(spectrumViewWindowType _window);
 
    void draw(CDrawContext* pContext) override;
 
    // --- for CControl pure abstract functions
    CLASS_METHODS(SpectrumView, CControl)
 
protected:
    // --- for windowing; this doesn't need to be saved in current
    //     implementation but you may need it for homework/upgrading the object
    spectrumViewWindowType window = spectrumViewWindowType::kRectWindow; 
 
    // --- setup FFTW
    fftw_complex* data = nullptr;           
    fftw_complex* fft_result = nullptr;     
    fftw_complex* ifft_result = nullptr;    
    fftw_plan plan_forward;                 
    fftw_plan plan_backward;                
 
    // --- for FFT data input
    int fftInputCounter = 0;                
 
    bool addFFTInputData(double inputSample);
 
    // --- a double buffer pair of magnitude arrays
    double fftMagnitudeArray_A[FFT_LEN] = {0.0}; 
    double fftMagnitudeArray_B[FFT_LEN] = {0.0}; 
 
    // --- buffer for the assigned window
    double fftWindow[FFT_LEN] = {1.0}; 
 
    // --- pointer to mag buffer that drawing thread uses; note that
    //     this pointer is never shared with any other function
    double* currentFFTMagBuffer = nullptr; 
 
    // --- NOTE: move these to another file for use by other objects!!
    // --- helper for FFT magnitude
    inline double getMagnitude(double re, double im)
    {
        return sqrt((re*re)+(im*im));
    }
 
    inline double normalizeBufferGetFMax(double* buffer, unsigned int bufferSize, int* ptrMaxIndex)
    {
        double max = 0;
        double maxRetValue = 0;
        *ptrMaxIndex = 0;
 
        for(int j=0; j<bufferSize; j++)
        {
            if((fabs(buffer[j])) > max)
            {
                max = fabs(buffer[j]);
                *ptrMaxIndex = j;
            }
        }
 
        if(max > 0)
        {
            for(int j=0; j<bufferSize; j++)
            {
                buffer[j] = buffer[j]/max;
                if(j == *ptrMaxIndex)
                    maxRetValue = buffer[j];
            }
        }
 
        return maxRetValue;
    }
 
    inline double interpArrayValue(double* array, int arraySize, double fractionalIndex)
    {
        // --- extract [index_x] values
        int x1 = (int)fractionalIndex;
        int x2 = x1 + 1;
 
        // --- check invalid conditions
        if(x1 >= arraySize)
            return 0.0;
        if(x2 >= arraySize)
            return array[x1];
        if(x2 - x1 == 0)    // 0 slope: should not ever happen
            return array[x1];
 
        // --- calculate decimal position of x
        double dx = (fractionalIndex - x1)/(x2 - x1);
 
        // --- use weighted sum method of interpolating
        return dx*array[x2] + (1-dx)*array[x1];
    }
 
protected:
    // --- filled/unfilled FFT
    bool filledFFT = true; 
 
private:
    // --- lock-free queue for incoming data, sized to FFT_LEN in length
    moodycamel::ReaderWriterQueue<double,FFT_LEN>* dataQueue = nullptr; 
 
    // --- a pair of lock-free queues to store empty and full magnitude buffers
    //     these are setup as double buffers but you can easily extend them
    //     to quad (4) and octal (8) if you want
    moodycamel::ReaderWriterQueue<double*,2>* fftMagBuffersReady = nullptr; 
    moodycamel::ReaderWriterQueue<double*,2>* fftMagBuffersEmpty = nullptr; 
};
#endif // defined FFTW
 
 
// --- custom view example
const unsigned int MESSAGE_SHOW_CONTROL = 0;
const unsigned int MESSAGE_HIDE_CONTROL = 1;
const unsigned int MESSAGE_SET_CONTROL_ALPHA = 2;
const unsigned int MESSAGE_QUERY_CONTROL = 3;
 
// --- example of a custom view message; here we control the visual appearance of a control
struct CustomViewMessage
{
    CustomViewMessage() {}
    CustomViewMessage(const CustomViewMessage& initMessage)
    {
        message = initMessage.message;
        visible = initMessage.visible;
        showAlternateGraphic = initMessage.showAlternateGraphic;
        controlAlpha = initMessage.controlAlpha;
        queryString = initMessage.queryString;
        replyString = initMessage.replyString;
        messageData = initMessage.messageData;
    }
    
    CustomViewMessage& operator =(const CustomViewMessage& viewMessage)
    {
        message = viewMessage.message;
        visible = viewMessage.visible;
        showAlternateGraphic = viewMessage.showAlternateGraphic;
        controlAlpha = viewMessage.controlAlpha;
        queryString = viewMessage.queryString;
        replyString = viewMessage.replyString;
        messageData = viewMessage.messageData;
        return *this;
    }
    
    // --- show/hide flag
    unsigned int message = MESSAGE_HIDE_CONTROL;
    
    bool visible = true;
    bool showAlternateGraphic = false;
    double controlAlpha = 1.0; // transparency: 0 = invisible (100% transparent) and 1 = solidly visible (0% transparent)
    std::string queryString;
    std::string replyString;
    void* messageData = nullptr;
};
 
class CustomKnobView : public CAnimKnob, public ICustomView
{
public:
    CustomKnobView(const CRect& size, IControlListener* listener, int32_t tag, int32_t subPixmaps,
            CCoord heightOfOneImage, CBitmap* background, const CPoint &offset,
            bool bSwitchKnob = false);
 
    virtual void updateView() override;
 
    virtual void sendMessage(void* data) override;
 
protected:
    virtual ~CustomKnobView(void);
 
private:
    // --- lock-free queue for incoming data, sized to 32 in length
    moodycamel::ReaderWriterQueue<CustomViewMessage, 32>* dataQueue = nullptr; 
};
 
 
class KnobLinkController : public IController
{
public:
    KnobLinkController(IController* _parentController)
    {
        // --- save the parent listener
        parentController = _parentController;
 
        // --- INITIALIZE LINK STATE
        linkControls = false;
    }
    ~KnobLinkController()
    {
        linkedKnobs.clear();
    }
 
    bool isLinkedControl(CControl* control)
    {
        return std::find(linkedKnobs.begin(), linkedKnobs.end(), control) != linkedKnobs.end();
    }
 
    virtual CView* verifyView(CView* view, const UIAttributes& attributes, const IUIDescription* description) override
    {
        CAnimKnob* knob = dynamic_cast<CAnimKnob*>(view);
        CTextButton* button = dynamic_cast<CTextButton*>(view);
 
        // --- save button, push back knob onto list
        if (button)
        {
            linkControl = button;
            if (button->getValueNormalized() != 0)
                linkControls = true;
            else
                linkControls = false;
        }
        else if (knob)
            linkedKnobs.push_back(knob);
 
        return view;
    }
 
    virtual void valueChanged(CControl* control) override
    {
        // --- set the link flag
        if (control == linkControl)
        {
            if (control->getValueNormalized() != 0)
                linkControls = true;
            else
                linkControls = false;
 
            return parentController->valueChanged(control);
        }
 
        // --- check flag
        if (!linkControls)
            return parentController->valueChanged(control);
 
        // --- we are linking
        //
        // --- make sure this is not a rogue control
        if (isLinkedControl(control))
        {
            // --- iterate list
            for (std::vector<CAnimKnob*>::iterator it = linkedKnobs.begin(); it != linkedKnobs.end(); ++it)
            {
                // --- set the control value for all knobs except the one generating this message
                CControl* ctrl = *it;
 
                if (ctrl && control != ctrl)
                {
                    // --- set the control visually
                    ctrl->setValueNormalized(control->getValueNormalized());
 
                    // --- do the value change at parent level, to set on plugin
                    parentController->valueChanged(ctrl);
                    
                    ctrl->invalid();
                }
            }
        }
        // --- do the value change at parent level, to set on plugin
        parentController->valueChanged(control);
    }
 
    virtual CView* createView(const UIAttributes& attributes, const IUIDescription* description) override { return parentController->createView(attributes, description); }
 
    virtual void controlBeginEdit(CControl* pControl)override { parentController->controlBeginEdit(pControl); }
 
    virtual void controlEndEdit(CControl* pControl)override { parentController->controlEndEdit(pControl); }
 
    virtual void controlTagWillChange(CControl* pControl) override
    {
        pControl->setListener(parentController);
        parentController->controlTagWillChange(pControl);
        pControl->setListener(this);
    }
 
    virtual void controlTagDidChange(CControl* pControl) override
    {
        pControl->setListener(parentController);
        parentController->controlTagDidChange(pControl);
        pControl->setListener(this);
    }
 
protected:
    // --- the parent controller; we can issue IController commands to it!
    IController* parentController = nullptr; 
 
    // --- a CTextButton is the switcher (linkControl)
    CTextButton* linkControl = nullptr; 
 
    // --- when linked, all of these controls move when one of them moves,
    //     regardless of their control tags
    typedef std::vector<CAnimKnob*> KnobList; 
    KnobList linkedKnobs;
 
    // --- flag for linking knobs
    bool linkControls = false;      
};
 
 
struct TextDisplayViewMessage
{
    TextDisplayViewMessage() {}
 
    // --- members
    unsigned int message = MESSAGE_SET_STRING;
 
    std::string labelString;
    std::vector<std::string> stringList;
    // uint32_t stringCount = 0;
    uint32_t controlStringCount = 0;
};
 
struct RAFX2CustomViewMessage
{
    RAFX2CustomViewMessage() {}
    // --- for external thunk clients, RackAFX or standalone ASPiK
    uint32_t message = MESSAGE_SET_STRING;
 
    const char* labelString;
    char** stringList;
    uint32_t stringCount = 0;
};
 
class CustomTextLabel : public CTextLabel, public ICustomView
{
public:
    CustomTextLabel(const CRect& size, CHoriTxtAlign horizTA = CHoriTxtAlign::kCenterText, UTF8StringPtr txt = 0, CBitmap* background = 0, const int32_t style = 0)
        : CTextLabel(size, txt, background, style)
    {
        textAlignment = horizTA;
    }
 
    virtual void updateView() override {
        // --- force redraw
        invalid();
    }
 
    void draw(CDrawContext* pContext) override
    {
        setHoriAlign(textAlignment);
        CTextLabel::draw(pContext);
    }
 
    virtual void sendMessage(void* data) override
    {
        TextDisplayViewMessage* viewMessage = (TextDisplayViewMessage*)data;
 
        // --- set the text in the label
        if (viewMessage->message == MESSAGE_SET_STRING)
        {
            // --- change the label
            this->setText(viewMessage->labelString.c_str());
        }
    }
 
protected:
    virtual ~CustomTextLabel(void) {    }
    CHoriTxtAlign textAlignment = CHoriTxtAlign::kCenterText;
};
 
 
class CustomOptionMenu : public COptionMenu, public ICustomView
{
public:
    CustomOptionMenu(const CRect& size, IControlListener* listener, int32_t tag, CBitmap* background = nullptr, CBitmap* bgWhenClick = nullptr, const int32_t style = 0)
        : COptionMenu(size, listener, tag, background, bgWhenClick, style)
    {
        this->setNbItemsPerColumn(8);
    }
 
    virtual void updateView() override {
        // --- force redraw
        invalid();
    }
 
 
    virtual void valueChanged() override
    {
        CMenuItem* item = getEntry((int32_t)getValue());
        if (!item) return;
        if (item->getTitle() == "-----")
        {
            setValue((float)lastActualEntryIndex);
            setDirty();
        }
 
        COptionMenu::valueChanged();
    }
 
    virtual void sendMessage(void* data) override
    {
        TextDisplayViewMessage* viewMessage = (TextDisplayViewMessage*)data;
 
        // --- set the text in the label
        if (viewMessage->message == MESSAGE_SET_STRINGLIST)
        {
            // --- clear items
            this->removeAllEntry();
            for (uint32_t i = 0; i < viewMessage->controlStringCount; i++)
            {
                if (i < viewMessage->stringList.size())
                {
                    COptionMenu::addEntry(viewMessage->stringList[i].c_str(), i);
                    if(viewMessage->stringList[i].compare("-----") != 0)
                        lastActualEntryIndex = i;// --- save for later to avoid a non-setting
                }
                else
                    COptionMenu::addEntry("-----", i);
            }
            // --- should never happen
            if (lastActualEntryIndex < 0) lastActualEntryIndex = 0;
        }
    }
 
protected:
    virtual ~CustomOptionMenu(void) {    }
    int32_t lastActualEntryIndex = 0;
};
 
}