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) 2023, 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 "pluginterfaces/vst/ivsteditcontroller.h"
#include "pluginterfaces/vst/ivstunits.h"
 
#include <map>
#include <string>
#include <vector>
 
//------------------------------------------------------------------------
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:
    IPtr<IComponentHandler> componentHandler;
    IPtr<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:
    IPtr<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<std::string, std::u16string>;
    using StringVector = std::vector<std::u16string>;
    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, std::u16string>;
    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 {kRootUnitId};
};
 
//------------------------------------------------------------------------
} // namespace Vst
} // namespace Steinberg