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"
 
// --- 4.9
#include "vstgui/uidescription/cstream.h"
 
// --- 4.10 new way to initialize the library
#include "vstgui/lib/vstguiinit.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)
    {
        if (hasRefGuiControl)
        {
            if (normalizedValue == (float)refGuiControl.getDefaultValueNormalized())
            {
                return (float)refGuiControl.getDefaultValue();
            }
        }
 
        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)
    {
        // --- is this the defalt value?
        if (hasRefGuiControl)
        {
            if (normalizedValue == (float)refGuiControl.getDefaultValueNormalized())
            {
                updateControlsWithActualValue((float)refGuiControl.getDefaultValue(), control);
                return;
            }
        }
 
        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(), i);
                    }
 
                    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 OldMouseObserverAdapter /*IMouseObserver*/,
                  public VSTGUIEditorInterface,
                  public CBaseObject,
                  public ICommandMenuItemTarget,
                  public IGUIView
{
 
public:
    PluginGUI(UTF8StringPtr _xmlFile);
 
    virtual ~PluginGUI();
 
    bool open(UTF8StringPtr _viewName,
              void* parent,
              const std::vector<PluginParameter*>* pluginParameterPtr,
              const PlatformType& 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();
 
    void clearGUIPluginConnector(){ guiPluginConnector = nullptr; }
 
    // --- for AAX-Windows ONLY
    static void initVSTGUILib(void* hInstance);
 
    static void exitVSTGUILib();
 
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;
 
    virtual bool validateCommandMenuItem(CCommandMenuItem* item) override;
 
    virtual bool onCommandMenuItemSelected(CCommandMenuItem* item) override;
 
    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