customcontrols.h

Go to the documentation of this file.

// -----------------------------------------------------------------------------
//    ASPiK Custom Controls File:  customcontrols.h
//
// -----------------------------------------------------------------------------
#ifndef __CustomControls__
#define __CustomControls__

#include "vstgui/lib/controls/cbuttons.h"
#include "vstgui/lib/controls/cknob.h"
#include "vstgui/lib/cframe.h"
#include "vstgui/lib/controls/cslider.h"
#include "vstgui/lib/controls/cvumeter.h"
#include "vstgui/lib/controls/cxypad.h"
#include "vstgui/vstgui.h"
#include "vstgui/lib/vstguibase.h"
#include "guiconstants.h"

namespace VSTGUI {

enum mouseAction {mouseDirUpAndDown, mouseDirUp, mouseDirDown};

class CKickButtonEx : public CKickButton
{
public:
    CKickButtonEx(const CRect& size, IControlListener* listener, int32_t tag, CBitmap* background, const CPoint& offset = CPoint (0, 0));

    virtual CMouseEventResult onMouseDown (CPoint& where, const CButtonState& buttons) override;

    virtual CMouseEventResult onMouseUp (CPoint& where, const CButtonState& buttons) override;

    void setMouseMode(unsigned int mode){mouseBehavior = mode;}

private:
    float entryState = 0.0;         
    unsigned int mouseBehavior = 0; 
};

class TextButtonEx : public CTextButton
{
public:
    TextButtonEx(const CRect& size, IControlListener* listener, int32_t tag, UTF8StringPtr title = 0, CTextButton::Style = kKickStyle);

    void draw(CDrawContext* context) override;

    virtual CMouseEventResult onMouseDown(CPoint& where, const CButtonState& buttons) override;

    virtual CMouseEventResult onMouseMoved(CPoint& where, const CButtonState& buttons) override;

    virtual CMouseEventResult onMouseUp(CPoint& where, const CButtonState& buttons) override;

    void setMouseMode(unsigned int uMode) { mouseBehavior = uMode; }

private:
    float entryState = 0.0;         
    unsigned int mouseBehavior = 0; 
};

class CAnimKnobEx : public CAnimKnob
{
public:
    CAnimKnobEx(const CRect& size, IControlListener* listener, int32_t tag, int32_t subPixmaps,
            CCoord heightOfOneImage, CBitmap* background, const CPoint &offset,
            bool bSwitchKnob = false);

    virtual void draw (CDrawContext* pContext) override;

    CMouseEventResult onMouseUp(CPoint& where, const CButtonState& buttons) override;

    CMouseEventResult onMouseDown(CPoint& where, const CButtonState& buttons) override;

    virtual CMouseEventResult onMouseMoved (CPoint& where, const CButtonState& buttons) override;

    bool checkDefaultValue (CButtonState button) override;
    virtual void valueChanged() override;

    void setSwitchMax(float f){maxControlValue = f;}

    bool isSwitchKnob(){return switchKnob;}

    void setAAXKnob(bool b){aaxKnob = b;}

    bool isAAXKnob(){return aaxKnob;}

protected:
    bool switchKnob = false;
    bool aaxKnob = false;
    float maxControlValue = 1.0;
    virtual ~CAnimKnobEx(void);

private:
    CPoint firstPoint;
    CPoint lastPoint;
    float  startValue;
    float  fEntryState;
    float  range;
    float  coef;
    CButtonState   oldButton;
    bool   modeLinear;

};

class CVerticalSliderEx : public CVerticalSlider
{
public:
    CVerticalSliderEx (const CRect& size, IControlListener* listener, int32_t tag, int32_t iMinPos, int32_t iMaxPos, CBitmap* handle, CBitmap* background, const CPoint& offset = CPoint (0, 0), const int32_t style = kBottom);

    // overrides
    virtual void draw (CDrawContext*) override;

    CMouseEventResult onMouseUp(CPoint& where, const CButtonState& buttons) override;

    CMouseEventResult onMouseDown(CPoint& where, const CButtonState& buttons) override;

    virtual CMouseEventResult onMouseMoved (CPoint& where, const CButtonState& buttons) override;

    bool checkDefaultValue (CButtonState button) override;

    void setSwitchMax(float f){maxControlValue = f;}

    bool isSwitchSlider(){return switchSlider;}

    void setSwitchSlider(bool b){switchSlider = b;}

    void setAAXSlider(bool b){aaxSlider = b;}

    bool isAAXSlider(){return aaxSlider;}

    CLASS_METHODS(CVerticalSliderEx, CControl)

protected:
    ~CVerticalSliderEx ();
    bool switchSlider;
    bool aaxSlider;
    float maxControlValue;

private:
    CCoord  delta;
    float   oldVal;
    float   startVal;
    CButtonState oldButton;
    CPoint mouseStartPoint;
};


class CHorizontalSliderEx : public CHorizontalSlider
{
public:
    CHorizontalSliderEx (const CRect& size, IControlListener* listener, int32_t tag, int32_t iMinPos, int32_t iMaxPos, CBitmap* handle, CBitmap* background, const CPoint& offset = CPoint (0, 0), const int32_t style = kLeft);

    // overrides
    virtual void draw (CDrawContext*) override;

    CMouseEventResult onMouseUp(CPoint& where, const CButtonState& buttons) override;

    CMouseEventResult onMouseDown(CPoint& where, const CButtonState& buttons) override;

    virtual CMouseEventResult onMouseMoved (CPoint& where, const CButtonState& buttons) override;

    bool checkDefaultValue (CButtonState button) override;

    void setSwitchMax(float f){maxControlValue = f;}

    void setSwitchSlider(bool b){switchSlider = b;}

    bool isSwitchSlider(){return switchSlider;}

    void setAAXSlider(bool b){aaxSlider = b;}

    bool isAAXSlider(){return aaxSlider;}

    CLASS_METHODS(CHorizontalSliderEx, CControl)

protected:
    ~CHorizontalSliderEx ();
    bool switchSlider;
    float maxControlValue;
    bool aaxSlider;

private:
    CCoord  delta;
    float   oldVal;
    float   startVal;
    CButtonState oldButton;
    CPoint mouseStartPoint;
};

class CMeterDetector
{
public:
    CMeterDetector(void);
    ~CMeterDetector(void);

public:

    // Call the Init Function to initialize and setup all at once; this can be called as many times
    // as you want
    void init(float samplerate, float attack_in_ms, float release_in_ms, bool bAnalogTC, unsigned int uDetect, bool bLogDetector);

    // these functions allow you to change modes and attack/release one at a time during
    // realtime operation
    void setTCModeAnalog(bool _analogTC);

    // THEN do these after init
    void setAttackTime(float attack_in_ms);
    void setReleaseTime(float release_in_ms);

    // --- see guiconstants.h
    // ENV_DETECT_MODE_PEAK     = 0;
    // ENV_DETECT_MODE_MS       = 1;
    // ENV_DETECT_MODE_RMS      = 2;
    // ENV_DETECT_MODE_NONE     = 3;
    void setDetectMode(unsigned int _detectMode) {detectMode = _detectMode;}

    void setSampleRate(float f)
    {
        detectorSampleRate = f;

        setAttackTime(attackTime_mSec);
        setReleaseTime(releaseTime_mSec);
    }

    void setLogDetect(bool b) {logDetector = b;}

    // call this to detect; it returns the peak ms or rms value at that instant
    float detect(float input);

    // call this from your prepareForPlay() function each time to reset the detector
    void prepareForPlay();

    void resetPeakHold(){ peakEnvelope = -1.0; }
    void setPeakHold(bool b) { peakHold = b; }

protected:
    float attackTime;
    float m_fReleaseTime;
    float attackTime_mSec;
    float releaseTime_mSec;
    float detectorSampleRate;
    float envelope;
    float peakEnvelope;
    bool  analogTC;
    bool  logDetector;
    unsigned int  detectMode;
    bool peakHold;

    void setEnvelope(float value)
    {
        if(!peakHold)
        {
            envelope = value;
            return;
        }

        // --- holding peak
        if(value > peakEnvelope)
        {
            peakEnvelope = value;
            envelope = value;
        }
    }
};

class CVuMeterEx : public CVuMeter
{
public:
    CVuMeterEx(const CRect& size, CBitmap* onBitmap, CBitmap* offBitmap, int32_t nbLed, bool bInverted, bool bAnalogVU, int32_t style = kVertical);

    CVuMeterEx(void);
    ~CVuMeterEx(void);

    // --- overrides!
    virtual void draw(CDrawContext* pContext) override;
    virtual void setViewSize (const CRect& newSize, bool invalid = true) override;

    inline void initDetector(float samplerate, float attack_in_ms, float release_in_ms, bool bAnalogTC, unsigned int uDetect, bool bLogDetector)
    {
        detector.init(samplerate, attack_in_ms, release_in_ms, bAnalogTC, uDetect, bLogDetector);
        detector.prepareForPlay();
    }

    void setHtOneImage(double d){heightOfOneImage = d;}
    void setImageCount(double d){subPixMaps = d;}
    void setZero_dB_Frame(double d){zero_dB_Frame = d;}

protected:
    bool isInverted;
    bool isAnalogVU;
    double zero_dB_Frame;
    double heightOfOneImage;
    double subPixMaps;

    CMeterDetector detector;
};

class CXYPadEx : public CXYPad
{
public:
    CXYPadEx(const CRect& size = CRect (0, 0, 0, 0));

    // --- for easy trackpad and XY stuff
public:
    void setTagX(int32_t tag){tagX = tag;}
    int32_t getTagX(){return tagX;}

    void setTagY(int32_t tag){tagY = tag;}
    int32_t getTagY(){return tagY;}

    // --- overrides
    void draw(CDrawContext* context) override;

    CMouseEventResult onMouseMoved(CPoint& where, const CButtonState& buttons) override;

    CMouseEventResult onMouseUp(CPoint& where, const CButtonState& buttons) override;

    CMouseEventResult onMouseDown(CPoint& where, const CButtonState& buttons) override;
    virtual void setValue(float val) override;

    // --- for vector joystick operation
    inline int pointInPolygon(int nvert, float *vertx, float *verty, float testx, float testy)
    {
        int i, j, c = 0;
        for (i = 0, j = nvert-1; i < nvert; j = i++)
        {
            if ( ((verty[i]>testy) != (verty[j]>testy)) &&
                (testx < (vertx[j]-vertx[i]) * (testy-verty[i]) / (verty[j]-verty[i]) + vertx[i]) )
            c = !c;
        }
     return c;
    }

    static void calculateXY (float value, float& x, float& y)
    {
        x = std::floor (value * 1000.f + 0.5f) * 0.001f;
        y = std::floor ((value - x)  * 10000000.f + 0.5f) * 0.001f;
        y = -1.f*y + 1.f;
    }

    static float calculateValue (float x, float y)
    {
        y = -1.f*y + 1.f;
        x = std::floor (x * 1000.f + 0.5f) * 0.001f;
        y = std::floor (y * 1000.f + 0.5f) * 0.0000001f;
        return x + y;
    }

protected:
    int32_t tagX;
    int32_t tagY;
    bool isJoystickPad;

    float vertX[4];
    float vertY[4];

    float lastX;
    float lastY;
};


}

#endif