vsteditcontroller.h

Go to the documentation of this file.

//------------------------------------------------------------------------
// Project     : VST SDK
//
// Category    : Helpers
// Filename    : public.sdk/source/vst/vsteditcontroller.h
// Created by  : Steinberg, 04/2005
// Description : VST Edit Controller Implementation
//
//-----------------------------------------------------------------------------
// LICENSE
// (c) 2021, Steinberg Media Technologies GmbH, All Rights Reserved
//-----------------------------------------------------------------------------
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
// 
//   * Redistributions of source code must retain the above copyright notice, 
//     this list of conditions and the following disclaimer.
//   * Redistributions in binary form must reproduce the above copyright notice,
//     this list of conditions and the following disclaimer in the documentation 
//     and/or other materials provided with the distribution.
//   * Neither the name of the Steinberg Media Technologies nor the names of its
//     contributors may be used to endorse or promote products derived from this 
//     software without specific prior written permission.
// 
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
// IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 
// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE 
// OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE  OF THIS SOFTWARE, EVEN IF ADVISED
// OF THE POSSIBILITY OF SUCH DAMAGE.
//-----------------------------------------------------------------------------
 
#pragma once
 
#include "public.sdk/source/vst/vstcomponentbase.h"
#include "public.sdk/source/vst/vstparameters.h"
#include "public.sdk/source/common/pluginview.h"
#include "base/source/fstring.h"
 
#include "pluginterfaces/vst/ivsteditcontroller.h"
#include "pluginterfaces/vst/ivstunits.h"
 
#include <vector>
#include <map>
 
//------------------------------------------------------------------------
namespace Steinberg {
namespace Vst {
 
class EditorView;
 
//------------------------------------------------------------------------
class EditController : public ComponentBase, public IEditController, public IEditController2
{
public:
//------------------------------------------------------------------------
        EditController ();
 
        //---from IEditController-------
        tresult PLUGIN_API setComponentState (IBStream* state) SMTG_OVERRIDE;
        tresult PLUGIN_API setState (IBStream* state) SMTG_OVERRIDE;
        tresult PLUGIN_API getState (IBStream* state) SMTG_OVERRIDE;
        int32 PLUGIN_API getParameterCount () SMTG_OVERRIDE;
        tresult PLUGIN_API getParameterInfo (int32 paramIndex, ParameterInfo& info) SMTG_OVERRIDE;
        tresult PLUGIN_API getParamStringByValue (ParamID tag, ParamValue valueNormalized, String128 string) SMTG_OVERRIDE;
        tresult PLUGIN_API getParamValueByString (ParamID tag, TChar* string, ParamValue& valueNormalized) SMTG_OVERRIDE;
        ParamValue PLUGIN_API normalizedParamToPlain (ParamID tag, ParamValue valueNormalized) SMTG_OVERRIDE;
        ParamValue PLUGIN_API plainParamToNormalized (ParamID tag, ParamValue plainValue) SMTG_OVERRIDE;
        ParamValue PLUGIN_API getParamNormalized (ParamID tag) SMTG_OVERRIDE;
        tresult PLUGIN_API setParamNormalized (ParamID tag, ParamValue value) SMTG_OVERRIDE;
        tresult PLUGIN_API setComponentHandler (IComponentHandler* handler) SMTG_OVERRIDE;
        IPlugView* PLUGIN_API createView (FIDString /*name*/) SMTG_OVERRIDE {return nullptr;}
 
        //---from IEditController2-------
        tresult PLUGIN_API setKnobMode (KnobMode mode) SMTG_OVERRIDE { hostKnobMode = mode; return kResultTrue; }
        tresult PLUGIN_API openHelp (TBool /*onlyCheck*/) SMTG_OVERRIDE {return kResultFalse;}
        tresult PLUGIN_API openAboutBox (TBool /*onlyCheck*/) SMTG_OVERRIDE {return kResultFalse;}
 
        //---from ComponentBase---------
        tresult PLUGIN_API initialize (FUnknown* context) SMTG_OVERRIDE;
        tresult PLUGIN_API terminate () SMTG_OVERRIDE;
 
        //---Internal Methods-------
        virtual tresult beginEdit (ParamID tag);        
        virtual tresult performEdit (ParamID tag, ParamValue valueNormalized); 
        virtual tresult endEdit (ParamID tag);          
        virtual tresult startGroupEdit ();                      
        virtual tresult finishGroupEdit ();                     
 
        virtual void editorDestroyed (EditorView* /*editor*/) {}        
        virtual void editorAttached (EditorView* /*editor*/) {}         
        virtual void editorRemoved (EditorView* /*editor*/) {}          
 
        static KnobMode getHostKnobMode () { return hostKnobMode; }     

        virtual Parameter* getParameterObject (ParamID tag) { return parameters.getParameter (tag); }

        virtual tresult getParameterInfoByTag (ParamID tag, ParameterInfo& info);

        virtual tresult setDirty (TBool state);

        virtual tresult requestOpenEditor (FIDString name = ViewType::kEditor);
 
        //---Accessor Methods-------
        IComponentHandler* getComponentHandler () const { return componentHandler; }
 
        //---Interface---------
        OBJ_METHODS (EditController, ComponentBase)
        DEFINE_INTERFACES
                DEF_INTERFACE (IEditController)
                DEF_INTERFACE (IEditController2)
        END_DEFINE_INTERFACES (ComponentBase)
        REFCOUNT_METHODS (ComponentBase)
//------------------------------------------------------------------------
protected:
        IComponentHandler* componentHandler;
        IComponentHandler2* componentHandler2;
 
        ParameterContainer parameters;
 
        static KnobMode hostKnobMode;
};
 
//------------------------------------------------------------------------
class EditorView : public CPluginView
{
public:
//------------------------------------------------------------------------
        EditorView (EditController* controller, ViewRect* size = nullptr);
        ~EditorView () override;

        EditController* getController () const { return controller; }
 
        //---from CPluginView-------------
        void attachedToParent () SMTG_OVERRIDE;
        void removedFromParent () SMTG_OVERRIDE;
 
//------------------------------------------------------------------------
protected:
        EditController* controller;
};
 
//------------------------------------------------------------------------
class Unit : public FObject
{
public:
//------------------------------------------------------------------------
        Unit (const String128 name, UnitID unitId, UnitID parentUnitId = kRootUnitId,
              ProgramListID programListId = kNoProgramListId);
        Unit (const UnitInfo& unit);

        const UnitInfo& getInfo () const { return info; }

        UnitID getID () const { return info.id; }

        void setID (UnitID newID) { info.id = newID; }

        const TChar* getName () const { return info.name; }

        void setName (const String128 newName);

        ProgramListID getProgramListID () const { return info.programListId; }

        void setProgramListID (ProgramListID newID) { info.programListId = newID; }
 
        OBJ_METHODS (Unit, FObject)
//------------------------------------------------------------------------
protected:
        Unit ();
        UnitInfo info;
};
 
//------------------------------------------------------------------------
class ProgramList : public FObject
{
public:
//------------------------------------------------------------------------
        ProgramList (const String128 name, ProgramListID listId, UnitID unitId);
        ProgramList (const ProgramList& programList);
 
        const ProgramListInfo& getInfo () const { return info; }
        ProgramListID getID () const { return info.id; }
        const TChar* getName () const { return info.name; }
        int32 getCount () const { return info.programCount; }
 
        virtual tresult getProgramName (int32 programIndex, String128 name /*out*/);
        virtual tresult setProgramName (int32 programIndex, const String128 name /*in*/);
        virtual tresult getProgramInfo (int32 programIndex, CString attributeId,
                                        String128 value /*out*/);
        virtual tresult hasPitchNames (int32 programIndex)
        {
                (void)programIndex;
                return kResultFalse;
        }
        virtual tresult getPitchName (int32 programIndex, int16 midiPitch, String128 name /*out*/)
        {
                (void)programIndex;
                (void)midiPitch;
                (void)name;
                return kResultFalse;
        }

        virtual int32 addProgram (const String128 name);

        virtual bool setProgramInfo (int32 programIndex, CString attributeId, const String128 value);

        virtual Parameter* getParameter ();
 
        OBJ_METHODS (ProgramList, FObject)
//------------------------------------------------------------------------
protected:
        using StringMap = std::map<String, String>;
        using StringVector = std::vector<String>;
        using ProgramInfoVector = std::vector<StringMap>;
        ProgramListInfo info;
        UnitID unitId;
        StringVector programNames;
        ProgramInfoVector programInfos;
        Parameter* parameter;
};
 
//------------------------------------------------------------------------
class ProgramListWithPitchNames : public ProgramList
{
public:
        ProgramListWithPitchNames (const String128 name, ProgramListID listId, UnitID unitId);

        bool setPitchName (int32 programIndex, int16 pitch, const String128 pitchName);

        bool removePitchName (int32 programIndex, int16 pitch);
 
        //---from ProgramList---------
        int32 addProgram (const String128 name) SMTG_OVERRIDE;
        tresult hasPitchNames (int32 programIndex) SMTG_OVERRIDE;
        tresult getPitchName (int32 programIndex, int16 midiPitch,
                              String128 name /*out*/) SMTG_OVERRIDE;
 
        OBJ_METHODS (ProgramListWithPitchNames, ProgramList)
protected:
        using PitchNameMap = std::map<int16, String>;
        using PitchNamesVector = std::vector<PitchNameMap>;
        PitchNamesVector pitchNames;
};
 
//------------------------------------------------------------------------
class EditControllerEx1 : public EditController, public IUnitInfo
{
public:
        EditControllerEx1 ();
        ~EditControllerEx1 () override;
 
        //---from ComponentBase---------
        tresult PLUGIN_API terminate () SMTG_OVERRIDE;

        bool addUnit (Unit* unit);

        bool addProgramList (ProgramList* list);

        ProgramList* getProgramList (ProgramListID listId) const;

        tresult notifyProgramListChange (ProgramListID listId, int32 programIndex = kAllProgramInvalid);
 
        //---from IUnitInfo------------------
        int32 PLUGIN_API getUnitCount () SMTG_OVERRIDE { return static_cast<int32> (units.size ()); }
        tresult PLUGIN_API getUnitInfo (int32 unitIndex, UnitInfo& info /*out*/) SMTG_OVERRIDE;
 
        int32 PLUGIN_API getProgramListCount () SMTG_OVERRIDE;
        tresult PLUGIN_API getProgramListInfo (int32 listIndex,
                                               ProgramListInfo& info /*out*/) SMTG_OVERRIDE;
        tresult PLUGIN_API getProgramName (ProgramListID listId, int32 programIndex,
                                           String128 name /*out*/) SMTG_OVERRIDE;
        tresult PLUGIN_API getProgramInfo (ProgramListID listId, int32 programIndex,
                                           CString attributeId /*in*/,
                                           String128 attributeValue /*out*/) SMTG_OVERRIDE;
 
        tresult PLUGIN_API hasProgramPitchNames (ProgramListID listId,
                                                 int32 programIndex) SMTG_OVERRIDE;
        tresult PLUGIN_API getProgramPitchName (ProgramListID listId, int32 programIndex,
                                                int16 midiPitch, String128 name /*out*/) SMTG_OVERRIDE;
 
        virtual tresult setProgramName (ProgramListID listId, int32 programIndex,
                                        const String128 name /*in*/);
 
        // units selection --------------------
        UnitID PLUGIN_API getSelectedUnit () SMTG_OVERRIDE { return selectedUnit; }
        tresult PLUGIN_API selectUnit (UnitID unitId) SMTG_OVERRIDE
        {
                selectedUnit = unitId;
                return kResultTrue;
        }
 
        tresult PLUGIN_API getUnitByBus (MediaType /*type*/, BusDirection /*dir*/, int32 /*busIndex*/,
                                         int32 /*channel*/, UnitID& /*unitId*/ /*out*/) SMTG_OVERRIDE
        {
                return kResultFalse;
        }
        tresult PLUGIN_API setUnitProgramData (int32 /*listOrUnitId*/, int32 /*programIndex*/,
                                               IBStream* /*data*/) SMTG_OVERRIDE
        {
                return kResultFalse;
        }

        virtual tresult notifyUnitSelection ();
 
        //---from IDependent------------------
        void PLUGIN_API update (FUnknown* changedUnknown, int32 message) SMTG_OVERRIDE;
 
        //---Interface---------
        OBJ_METHODS (EditControllerEx1, EditController)
        DEFINE_INTERFACES
                DEF_INTERFACE (IUnitInfo)
        END_DEFINE_INTERFACES (EditController)
        REFCOUNT_METHODS (EditController)
 
protected:
        using ProgramListVector = std::vector<IPtr<ProgramList>>;
        using ProgramIndexMap = std::map<ProgramListID, ProgramListVector::size_type>;
        using UnitVector = std::vector<IPtr<Unit>>;
        UnitVector units;
        ProgramListVector programLists;
        ProgramIndexMap programIndexMap;
        UnitID selectedUnit;
};
 
//------------------------------------------------------------------------
} // namespace Vst
} // namespace Steinberg