plugingui.h

Go to the documentation of this file.

// -----------------------------------------------------------------------------
//    ASPiK Plugin Kernel File:  plugingui.h
//
// -----------------------------------------------------------------------------
#pragma once
#ifndef __PluginGUI__
#define __PluginGUI__

//#define DOXYDOC 1

#ifdef DOXYDOC

#define AUPLUGIN 1
#define AAXPLUGIN 1
#define VSTPLUGIN 1
#define RAFXPLUGIN 1

#endif

// --- custom VSTGUI4 derived classes
#include "customcontrols.h"

// --- VSTGUI
#include "vstgui/vstgui.h"
#include "vstgui/uidescription/uiviewswitchcontainer.h"
#include "vstgui/vstgui_uidescription.h"
#include "vstgui/lib/crect.h"

#if VSTGUI_LIVE_EDITING
#include "vstgui/uidescription/editing/uieditcontroller.h"
#include "vstgui/uidescription/editing/uieditmenucontroller.h"
#endif

#ifdef AUPLUGIN
#import <CoreFoundation/CoreFoundation.h>
#import <AudioUnit/AudioUnit.h>
#import <AudioToolbox/AudioToolbox.h>
#endif

#ifdef AAXPLUGIN
#include "AAX_IEffectParameters.h"
#include "AAXtoVSTGUIButtonState.h"
#endif

// --- plugin stuff
#include "pluginparameter.h"

// --- std::
#include <sstream>
#include <algorithm>
#include <functional>
#include <cctype>
#include <locale>
#include <map>

// --- const for host choice knob mode
const uint32_t kHostChoice = 3;

namespace VSTGUI {

class ControlUpdateReceiver
{
public:
    ControlUpdateReceiver(CControl* control, PluginParameter* pluginParameterPtr, bool _isControlListener)
    {
       hasRefGuiControl = pluginParameterPtr ? true : false;

        if(hasRefGuiControl)
            refGuiControl = *pluginParameterPtr;

        addControl(control);
        isControlListener = _isControlListener;
    }

    ~ControlUpdateReceiver()
    {
        for(std::vector<CControl*>::iterator it = guiControls.begin(); it != guiControls.end(); ++it)
        {
            CControl* ctrl = *it;
            ctrl->forget();
        }
    }

    bool hasControl(CControl* control)
    {
        return std::find(guiControls.begin (), guiControls.end (), control) != guiControls.end ();
    }

    void addControl(CControl* control)
    {
        if(hasControl(control))
            return;

        control->remember();
        guiControls.push_back(control);

        // --- set default value (rather than from XML, which is a pain because it must be normalized)
        if(hasRefGuiControl)
        {
            float normalizedValue = (float)refGuiControl.getDefaultValueNormalized();
            control->setDefaultValue(normalizedValue);
        }
    }

    void removeControl(CControl* control)
    {
        for(std::vector<CControl*>::iterator it = guiControls.begin(); it != guiControls.end(); ++it)
        {
            CControl* ctrl = *it;
            if(ctrl == control)
            {
                ctrl->forget();
                guiControls.erase(it);
                return;
            }
        }
    }

    bool controlInRxGroupIsEditing()
    {
        for(std::vector<CControl*>::iterator it = guiControls.begin(); it != guiControls.end(); ++it)
        {
            CControl* ctrl = *it;
            if(ctrl && ctrl->isEditing())
                return true;
        }
        return false;
    }

    float getActualValueWithNormalizedValue(float normalizedValue)
    {
        return (float)refGuiControl.getControlValueWithNormalizedValue(normalizedValue);
    }

    float getNormalizedValueWithActualValue(float actualValue)
    {
        return (float)refGuiControl.getNormalizedControlValueWithActualValue(actualValue);
    }

    void updateControlsWithControl(CControl* control)
    {
        updateControlsWithActualValue(getActualValueWithNormalizedValue(control->getValueNormalized()), control);
    }

    void updateControlsWithNormalizedValue(float normalizedValue, CControl* control = nullptr)
    {
        updateControlsWithActualValue(getActualValueWithNormalizedValue(normalizedValue), control);
    }

    void initControl(CControl* control)
    {
        float actualValue = (float)refGuiControl.getControlValue();
        updateControlsWithActualValue(actualValue, control);
    }

    void updateControlsWithActualValue(float actualValue, CControl* control = nullptr)
    {
        // --- eliminiate glitching from AAX parameter loop
        if(!control && controlInRxGroupIsEditing())
            return;

        // --- store on our reference control
        refGuiControl.setControlValue(actualValue);

        // --- synchoronize all controls that share this controlID
        for(std::vector<CControl*>::iterator it = guiControls.begin(); it != guiControls.end(); ++it)
        {
            CControl* guiCtrl = *it;
            if(guiCtrl && control != guiCtrl) // nned the check for XY pads
            {
                // --- need to take care of multiple control types, slight differences in setup
                CTextLabel* label = dynamic_cast<CTextLabel*>(guiCtrl);
                COptionMenu* oMenu = dynamic_cast<COptionMenu*>(guiCtrl);
                CXYPadEx* xyPad = dynamic_cast<CXYPadEx*>(guiCtrl);
                CVuMeter* meter = dynamic_cast<CVuMeter*>(guiCtrl);

                if(meter) 
                {
                    continue;
                }
                else if(label)
                {
                    label->setText(refGuiControl.getControlValueAsString().c_str());
                    label->invalid();
                }
                else if(oMenu)
                {
                    // --- current rafx GUI Designer does not set max to anything
                    guiCtrl->setMin((float)refGuiControl.getGUIMin());
                    guiCtrl->setMax((float)refGuiControl.getGUIMin());

                    // --- load for first time, NOT dynamic loading here
                    oMenu->removeAllEntry();

                    for (uint32_t i = 0; i < refGuiControl.getStringCount(); i++)
                    {
                        oMenu->addEntry(refGuiControl.getStringByIndex(i).c_str());
                    }

                    oMenu->setValue((float)refGuiControl.getControlValue());
                }
                else if(xyPad)
                {
                    float x = 0.f;
                    float y = 0.f;
                    xyPad->calculateXY(xyPad->getValue(), x, y);

                    // --- retrieve the X and Y tags on the CXYPadEx
                    int32_t tagX = xyPad->getTagX();
                    int32_t tagY = xyPad->getTagY();

                    if(tagX == refGuiControl.getControlID())
                        x = (float)refGuiControl.getControlValueNormalized();
                    if(tagY == refGuiControl.getControlID())
                        y = (float)refGuiControl.getControlValueNormalized();

                    if(tagX >= 0 && tagY >= 0 && !guiCtrl->isEditing())
                        xyPad->setValue(xyPad->calculateValue(x, y));
                }
                else if(!guiCtrl->isEditing())
                    guiCtrl->setValueNormalized((float)refGuiControl.getControlValueNormalized());

                guiCtrl->invalid();
            }
        }
    }

    const PluginParameter getGuiControl(){return refGuiControl;}

    int32_t getControlID(){ return refGuiControl.getControlID(); }

    inline bool controlAndContainerVisible(CControl* ctrl)
    {
        if(!ctrl) return false;

        bool stickyVisible = ctrl->isVisible();

        if(!stickyVisible)
            return false;

        // --- check parents
        CView* parent = ctrl->getParentView();
        while(parent)
        {
            stickyVisible = parent->isVisible();
            if(!stickyVisible)
                return false;

            parent = parent->getParentView();
        }
        return stickyVisible;
    }

    int getControlID_WithMouseCoords(const CPoint& where)
    {
        CPoint mousePoint = where;

        for(std::vector<CControl*>::iterator it = guiControls.begin(); it != guiControls.end(); ++it)
        {
            CControl* ctrl = *it;
            if(ctrl && controlAndContainerVisible(ctrl))
            {
                CPoint point = ctrl->frameToLocal(mousePoint);
                CRect rect = ctrl->getViewSize();
                if(rect.pointInside(point))
                {
                    int tag = ctrl->getTag();
                    if(isReservedTag(tag))
                        return -1;
                    else
                        return tag;
                }
            }
        }
        return -1;
    }

    CControl* getControl_WithMouseCoords(const CPoint& where)
    {
        CPoint mousePoint = where;

        for(std::vector<CControl*>::iterator it = guiControls.begin(); it != guiControls.end(); ++it)
        {
            CControl* ctrl = *it;
            if(ctrl && controlAndContainerVisible(ctrl))
            {
                CPoint point = ctrl->frameToLocal(mousePoint);
                CRect rect = ctrl->getViewSize();
                if(rect.pointInside(point))
                    return ctrl;
            }
        }
        return nullptr;
    }

protected:
    PluginParameter refGuiControl;          
    std::vector<CControl*> guiControls;     
    bool hasRefGuiControl = false;          
    bool isControlListener = false;         
};


class PluginGUI : public IController,
                  public IViewAddedRemovedObserver,
                  public IMouseObserver,
                  public IKeyboardHook,
                  public VSTGUIEditorInterface,
                  public CBaseObject,
                  public IGUIView
{

public:
    PluginGUI(UTF8StringPtr _xmlFile);

    virtual ~PluginGUI();

    bool open(UTF8StringPtr _viewName,
              void* parent,
              const std::vector<PluginParameter*>* pluginParameterPtr,
              const PlatformType& platformType = kDefaultNative,
              IGUIPluginConnector* _guiPluginConnector = nullptr,
              void* data = nullptr);

    void close();

    void syncGUIControl(uint32_t controlID);

    void getSize(float& width, float& height);

    void scaleGUISize(uint32_t controlValue);

    void writeToPresetFile();

protected:
    virtual void idle();

    void preCreateGUI();

    bool createGUI(bool bShowGUIEditor);

    void save(bool saveAs = false);

    virtual int32_t getKnobMode() const override;

    void deleteGUIControlList()
    {
        for(std::vector<PluginParameter*>::iterator it = pluginParameters.begin(); it != pluginParameters.end(); ++it) {
            delete *it;
        }
        pluginParameters.clear();
    }

    PluginParameter* getGuiControlWithTag(int tag)
    {
        for(std::vector<PluginParameter*>::iterator it = pluginParameters.begin(); it != pluginParameters.end(); ++it) {
            PluginParameter* ctrl = *it;
            if(ctrl->getControlID() == tag)
                return ctrl;
        }
        return nullptr;
    }

    // --- protected variables
    IGUIPluginConnector* guiPluginConnector = nullptr; 
    UIDescription* description = nullptr; 
    std::string viewName;           
    std::string xmlFile;            

    uint32_t numUIControls = 0;     
    double zoomFactor = 1.0;        
    CVSTGUITimer* timer;            

    CPoint minSize;     
    CPoint maxSize;     
    CRect nonEditRect;  

    // --- flags for showing view
    bool showGUIEditor = false; 
    bool createNewView = true;  

    double guiDesignerWidth;    
    double guiDesignerHeight;   
    float guiWidth;             
    float guiHeight;            

    IGUIWindowFrame* guiWindowFrame = nullptr;  
    CFrame* guiEditorFrame = nullptr;           
    uint32_t knobAction = kLinearMode;          

    std::string getGUIDesignerSize();

    int getControlID_WithMouseCoords(const CPoint& where);

    CControl* getControl_WithMouseCoords(const CPoint& where);

    CMouseEventResult sendAAXMouseDown(int controlID, const CButtonState& buttons);

    CMouseEventResult sendAAXMouseMoved(int controlID, const CButtonState& buttons, const CPoint& where);

    CMouseEventResult sendAUMouseDown(CControl* control, const CButtonState& buttons);

    CMouseEventResult sendAUMouseMoved(CControl* control, const CButtonState& buttons, const CPoint& where) { return kMouseEventNotImplemented; }

    void setPluginParameterFromGUIControl(CControl* control, int tag, float actualValue, float normalizedValue)
    {
#ifdef AUPLUGIN
        setAUEventFromGUIControl(control, tag, actualValue);
#endif

#ifdef AAXPLUGIN
        setAAXParameterFromGUIControl(control, tag, actualValue, normalizedValue);
#endif

#ifdef VSTPLUGIN
        setVSTParameterFromGUIControl(control, tag, actualValue, normalizedValue);
#endif

#ifdef RAFXPLUGIN
        setRAFXParameterFromGUIControl(control, tag, actualValue, normalizedValue);
#endif
}

#ifdef AAXPLUGIN
public:
    void setAAXViewContainer(AAX_IViewContainer* _aaxViewContainer){ aaxViewContainer = _aaxViewContainer;}

    void setAAXParameterFromGUIControl(CControl* control, int tag, float actualValue, float normalizedValue);

    void updateGUIControlAAX(int tag, float actualPluginValue, float normalizedValue = 0.f, bool useNormalized = false);
protected:
#endif


#ifdef AUPLUGIN
    AudioUnit m_AU;                         
    AUEventListenerRef AUEventListener;     

public:
    void dispatchAUControlChange(int tag, float actualPluginValue, int message = -1, bool fromEventListener = false);

    void setAU(AudioUnit inAU){m_AU = inAU;}

protected:
    void setAUEventFromGUIControl(CControl* control, int tag, float normalizedValue);
#endif

#ifdef VSTPLUGIN

    void setVSTParameterFromGUIControl(CControl* control, int tag, float actualValue, float normalizedValue);

    void updateGUIControlVST(int tag, float normalizedValue);
#endif

#ifdef RAFXPLUGIN

    void setRAFXParameterFromGUIControl(CControl* control, int tag, float actualValue, float normalizedValue);

    void updateGUIControlRAFX(int tag, float normalizedValue);
#endif


public:
    CMessageResult notify(CBaseObject* sender, IdStringPtr message) override;

    virtual void valueChanged(VSTGUI::CControl* pControl) override;

    virtual int32_t controlModifierClicked(VSTGUI::CControl* pControl, VSTGUI::CButtonState button) override { return 0; }  

    virtual void controlBeginEdit(VSTGUI::CControl* pControl) override;

    virtual void controlEndEdit(VSTGUI::CControl* pControl) override;

    virtual void controlTagWillChange(VSTGUI::CControl* pControl) override;

    virtual void controlTagDidChange(VSTGUI::CControl* pControl) override;
#if DEBUG

    virtual char controlModifierClicked(VSTGUI::CControl* pControl, long button) { return 0; }
#endif

    CView* createUserCustomView(std::string viewname, const CRect rect, IControlListener* listener, int32_t tag);

    CView* createView(const UIAttributes& attributes, const IUIDescription* description) override;

    IController* createSubController(UTF8StringPtr name, const IUIDescription* description) override;

    ControlUpdateReceiver* getControlUpdateReceiver(int32_t tag) const;

    void onViewAdded(CFrame* frame, CView* view) override {}

    void onViewRemoved(CFrame* frame, CView* view) override;

    void onMouseEntered(CView* view, CFrame* frame) override {}

    void onMouseExited(CView* view, CFrame* frame) override {}

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

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

    int32_t onKeyDown(const VstKeyCode& code, CFrame* frame) override { return -1; }

    int32_t onKeyUp(const VstKeyCode& code, CFrame* frame) override { return -1; }

    virtual void setGUIWindowFrame(IGUIWindowFrame* frame) override
    {
        // --- we keep for resiging here
        guiWindowFrame = frame;
    }

    inline static bool parseSize (const std::string& str, CPoint& point)
    {
        size_t sep = str.find (',', 0);
        if (sep != std::string::npos)
        {
            point.x = strtol (str.c_str (), 0, 10);
            point.y = strtol (str.c_str () + sep+1, 0, 10);
            return true;
        }
        return false;
    }

    // --- for Meters only right now, but could be used to mark any control as writeable
    bool hasWriteableControl(CControl* control)
    {
        return std::find (writeableControls.begin (), writeableControls.end (), control) != writeableControls.end ();
    }

    void checkAddWriteableControl(PluginParameter* piParam, CControl* control)
    {
       if(!piParam)
            return;
        if(!control)
            return;
        if(!piParam->getIsWritable())
            return;
        if(!hasWriteableControl(control))
        {
            writeableControls.push_back(control);
            control->remember();
        }
    }

    void checkRemoveWriteableControl(CControl* control)
    {
        if(!hasWriteableControl(control)) return;

        for(std::vector<CControl*>::iterator it = writeableControls.begin(); it != writeableControls.end(); ++it)
        {
            CControl* ctrl = *it;
            if(ctrl == control)
            {
                ctrl->forget();
                writeableControls.erase(it);
                return;
            }
        }
    }


    void deleteControlUpdateReceivers()
    {
        for (ControlUpdateReceiverMap::const_iterator it = controlUpdateReceivers.begin(), end = controlUpdateReceivers.end(); it != end; ++it)
        {
            delete it->second;
        }
        controlUpdateReceivers.clear();
    }

    void forgetWriteableControls()
    {
        for (std::vector<CControl*>::iterator it = writeableControls.begin(); it != writeableControls.end(); ++it)
        {
            CControl* ctrl = *it;
            ctrl->forget();
        }
        writeableControls.clear();
    }

    bool hasICustomView(CView* view)
    {
        ICustomView* customView = dynamic_cast<ICustomView*>(view);
        if (customView)
            return true;
        return false;
    }

    bool hasICustomView(IController* subController)
    {
        ICustomView* customView = dynamic_cast<ICustomView*>(subController);
        if (customView)
            return true;
        return false;
    }

private:
    typedef std::map<int32_t, ControlUpdateReceiver*> ControlUpdateReceiverMap; 
    ControlUpdateReceiverMap controlUpdateReceivers;
    std::vector<CControl*> writeableControls;       
    std::vector<PluginParameter*> pluginParameters; 

#ifdef AAXPLUGIN
    AAX_IViewContainer* aaxViewContainer = nullptr; 
#endif
};

}

#endif