Extended host callback interface Vst::IComponentHandler3 for an edit controller. More...

#include <ivstcontextmenu.h>

Inheritance diagram for IComponentHandler3:

Public Member Functions
virtual IContextMenu *	createContextMenu (IPlugView plugView, const ParamID paramID)=0
	Creates a host context menu for a plug-in: More...

Public Member Functions inherited from FUnknown
virtual tresult	queryInterface (const TUID _iid, void **obj)=0

virtual uint32	addRef ()=0

virtual uint32	release ()=0

Static Public Attributes
static const FUID	iid

Static Public Attributes inherited from FUnknown
static const FUID	iid

Detailed Description

Extended host callback interface Vst::IComponentHandler3 for an edit controller.

[host imp]
[extends IComponentHandler]
[released: 3.5.0]
[optional]

A plug-in can ask the host to create a context menu for a given exported parameter ID or a generic context menu.
The host may pre-fill this context menu with specific items regarding the parameter ID like "Show automation for parameter", "MIDI learn" etc...
The plug-in can use the context menu in two ways :

add its own items to the menu via the IContextMenu interface and call IContextMenu::popup(..) to create the pop-up. See the Examples.
extract the host menu items and add them to a context menu created by the plug-in.

Note: You can and should use this even if you do not add your own items to the menu as this is considered to be a big user value.

See also: IContextMenu; IContextMenuTarget

Examples

For example, Cubase adds its owned entries in the context menu opened with right-click on an exported parameter when the plug-in uses createContextMenu.
Adding plug-in specific items to the context menu:

//------------------------------------------------------------------------
class PluginContextMenuTarget : public IContextMenuTarget, public FObject
{
public:
    PluginContextMenuTarget () {}
 
    virtual tresult PLUGIN_API executeMenuItem (int32 tag)
    {
        // this will be called if the user has executed one of the menu items of the plug-in.
        // It will not be called for items of the host.
        switch (tag)
        {
            case 1: break;
            case 2: break;
        }
        return kResultTrue;
    }
 
    OBJ_METHODS(PluginContextMenuTarget, FObject)
    DEFINE_INTERFACES
        DEF_INTERFACE (IContextMenuTarget)
    END_DEFINE_INTERFACES (FObject)
    REFCOUNT_METHODS(FObject)
};
 
// The following is the code to create the context menu
void popupContextMenu (IComponentHandler* componentHandler, IPlugView* view, const ParamID* paramID, UCoord x, UCoord y)
{
    if (componentHandler == 0 || view == 0)
        return;
    FUnknownPtr<IComponentHandler3> handler (componentHandler);
    if (handler == 0)
        return;
    IContextMenu* menu = handler->createContextMenu (view, paramID);
    if (menu)
    {
        // here you can add your entries (optional)
        PluginContextMenuTarget* target = new PluginContextMenuTarget ();
        
        IContextMenu::Item item = {0};
        UString128 ("My Item 1").copyTo (item.name, 128);
        item.tag = 1;
        menu->addItem (item, target);
 
        UString128 ("My Item 2").copyTo (item.name, 128);
        item.tag = 2;
        menu->addItem (item, target);
        target->release ();
        //--end of adding new entries
        
        // here the the context menu will be pop-up (and it waits a user interaction)
        menu->popup (x, y);
        menu->release ();
    }
}

Member Function Documentation

◆ createContextMenu()

virtual IContextMenu * createContextMenu	(	IPlugView *	plugView,
		const ParamID *	paramID
	)

pure virtual

Creates a host context menu for a plug-in:

If paramID is zero, the host may create a generic context menu.
The IPlugView object must be valid.
The return IContextMenu object needs to be released afterwards by the plug-in.

Member Data Documentation

◆ iid

const FUID iid

static