ipluginbase.h

Go to the documentation of this file.

 //-----------------------------------------------------------------------------
// Project     : SDK Core
//
// Category    : SDK Core Interfaces
// Filename    : pluginterfaces/base/ipluginbase.h
// Created by  : Steinberg, 01/2004
// Description : Basic Plug-in Interfaces
//
//-----------------------------------------------------------------------------
// This file is part of a Steinberg SDK. It is subject to the license terms
// in the LICENSE file found in the top-level directory of this distribution
// and at www.steinberg.net/sdklicenses. 
// No part of the SDK, including this file, may be copied, modified, propagated,
// or distributed except according to the terms contained in the LICENSE file.
//-----------------------------------------------------------------------------
 
#pragma once
 
#include "funknown.h"
#include "fstrdefs.h"
 
namespace Steinberg {
 
//------------------------------------------------------------------------
class IPluginBase: public FUnknown
{
public:
//------------------------------------------------------------------------
    virtual tresult PLUGIN_API initialize (FUnknown* context) = 0;
 
    virtual tresult PLUGIN_API terminate () = 0;
 
//------------------------------------------------------------------------
    static const FUID iid;
};
 
DECLARE_CLASS_IID (IPluginBase, 0x22888DDB, 0x156E45AE, 0x8358B348, 0x08190625)
 
 
//------------------------------------------------------------------------
struct PFactoryInfo
{
//------------------------------------------------------------------------
    enum FactoryFlags
    {
        kNoFlags = 0,
 
        kClassesDiscardable = 1 << 0,
 
        kLicenseCheck = 1 << 1,
 
        kComponentNonDiscardable = 1 << 3,
 
        kUnicode = 1 << 4
    };
 
    enum
    {
        kURLSize = 256,
        kEmailSize = 128,
        kNameSize = 64
    };
 
//------------------------------------------------------------------------
    char8 vendor[kNameSize];    
    char8 url[kURLSize];        
    char8 email[kEmailSize];    
    int32 flags;                
//------------------------------------------------------------------------
    SMTG_CONSTEXPR14 PFactoryInfo (const char8* _vendor, const char8* _url, const char8* _email,
                                   int32 _flags)
#if SMTG_CPP14
    : vendor (), url (), email (), flags ()
#endif
    {
        strncpy8 (vendor, _vendor, kNameSize);
        strncpy8 (url, _url, kURLSize);
        strncpy8 (email, _email, kEmailSize);
        flags = _flags;
#ifdef UNICODE
        flags |= kUnicode;
#endif
    }
#if SMTG_CPP11
    constexpr PFactoryInfo () : vendor (), url (), email (), flags () {}
#else
    PFactoryInfo () { memset (this, 0, sizeof (PFactoryInfo)); }
#endif
};
 
//------------------------------------------------------------------------
struct PClassInfo
{
//------------------------------------------------------------------------
    enum ClassCardinality
    {
        kManyInstances = 0x7FFFFFFF
    };
 
    enum
    {
        kCategorySize = 32,
        kNameSize = 64
    };
//------------------------------------------------------------------------
    TUID cid;
 
    int32 cardinality;
 
    char8 category[kCategorySize];
 
    char8 name[kNameSize];
 
//------------------------------------------------------------------------
 
    SMTG_CONSTEXPR14 PClassInfo (const TUID _cid, int32 _cardinality, const char8* _category,
                                 const char8* _name)
#if SMTG_CPP14
    : cid (), cardinality (), category (), name ()
#endif
    {
#if SMTG_CPP14
        copyTUID (cid, _cid);
#else
        memset (this, 0, sizeof (PClassInfo));
        memcpy (cid, _cid, sizeof (TUID));
#endif
        if (_category)
            strncpy8 (category, _category, kCategorySize);
        if (_name)
            strncpy8 (name, _name, kNameSize);
        cardinality = _cardinality;
    }
#if SMTG_CPP11
    constexpr PClassInfo () : cid (), cardinality (), category (), name () {}
#else
    PClassInfo () { memset (this, 0, sizeof (PClassInfo)); }
#endif
};
 
//------------------------------------------------------------------------
//  IPluginFactory interface declaration
//------------------------------------------------------------------------
class IPluginFactory : public FUnknown
{
public:
//------------------------------------------------------------------------
    virtual tresult PLUGIN_API getFactoryInfo (PFactoryInfo* info) = 0;
 
    virtual int32 PLUGIN_API countClasses () = 0;
 
    virtual tresult PLUGIN_API getClassInfo (int32 index, PClassInfo* info) = 0;
 
    virtual tresult PLUGIN_API createInstance (FIDString cid, FIDString _iid, void** obj) = 0;
 
//------------------------------------------------------------------------
    static const FUID iid;
};
 
DECLARE_CLASS_IID (IPluginFactory, 0x7A4D811C, 0x52114A1F, 0xAED9D2EE, 0x0B43BF9F)
 
 
//------------------------------------------------------------------------
struct PClassInfo2
{
//------------------------------------------------------------------------
    TUID cid;
 
    int32 cardinality;
 
    char8 category[PClassInfo::kCategorySize];
 
    char8 name[PClassInfo::kNameSize];
 
    enum {
        kVendorSize = 64,
        kVersionSize = 64,
        kSubCategoriesSize = 128
    };
 
    uint32 classFlags;
 
    char8 subCategories[kSubCategoriesSize];
    
    char8 vendor[kVendorSize];
 
    char8 version[kVersionSize];
 
    char8 sdkVersion[kVersionSize];
//------------------------------------------------------------------------
 
    SMTG_CONSTEXPR14 PClassInfo2 (const TUID _cid, int32 _cardinality, const char8* _category,
                                  const char8* _name, int32 _classFlags,
                                  const char8* _subCategories, const char8* _vendor,
                                  const char8* _version, const char8* _sdkVersion)
#if SMTG_CPP14
    : cid ()
    , cardinality ()
    , category ()
    , name ()
    , classFlags ()
    , subCategories ()
    , vendor ()
    , version ()
    , sdkVersion ()
#endif
    {
#if SMTG_CPP14
        copyTUID (cid, _cid);
#else
        memset (this, 0, sizeof (PClassInfo2));
        memcpy (cid, _cid, sizeof (TUID));
#endif
        cardinality = _cardinality;
        if (_category)
            strncpy8 (category, _category, PClassInfo::kCategorySize);
        if (_name)
            strncpy8 (name, _name, PClassInfo::kNameSize);
        classFlags = static_cast<uint32> (_classFlags);
        if (_subCategories)
            strncpy8 (subCategories, _subCategories, kSubCategoriesSize);
        if (_vendor)
            strncpy8 (vendor, _vendor, kVendorSize);
        if (_version)
            strncpy8 (version, _version, kVersionSize);
        if (_sdkVersion)
            strncpy8 (sdkVersion, _sdkVersion, kVersionSize);
    }
#if SMTG_CPP11
    constexpr PClassInfo2 ()
    : cid ()
    , cardinality ()
    , category ()
    , name ()
    , classFlags ()
    , subCategories ()
    , vendor ()
    , version ()
    , sdkVersion ()
    {
    }
#else
    PClassInfo2 () { memset (this, 0, sizeof (PClassInfo2)); }
#endif
};
 
//------------------------------------------------------------------------
//  IPluginFactory2 interface declaration
//------------------------------------------------------------------------
class IPluginFactory2 : public IPluginFactory
{
public:
//------------------------------------------------------------------------
    virtual tresult PLUGIN_API getClassInfo2 (int32 index, PClassInfo2* info) = 0;
 
//------------------------------------------------------------------------
    static const FUID iid;
};
DECLARE_CLASS_IID (IPluginFactory2, 0x0007B650, 0xF24B4C0B, 0xA464EDB9, 0xF00B2ABB)
 
 
//------------------------------------------------------------------------
struct PClassInfoW
{
//------------------------------------------------------------------------
    TUID cid;                           
    int32 cardinality;                  
    char8 category[PClassInfo::kCategorySize];  
    char16 name[PClassInfo::kNameSize]; 
 
    enum {
        kVendorSize = 64,
        kVersionSize = 64,
        kSubCategoriesSize = 128
    };
 
    uint32 classFlags;
 
    char8 subCategories[kSubCategoriesSize];
    
    char16 vendor[kVendorSize];
    
    char16 version[kVersionSize];
    
    char16 sdkVersion[kVersionSize];
 
//------------------------------------------------------------------------
    SMTG_CONSTEXPR14 PClassInfoW (const TUID _cid, int32 _cardinality, const char8* _category,
                                  const char16* _name, int32 _classFlags,
                                  const char8* _subCategories, const char16* _vendor,
                                  const char16* _version, const char16* _sdkVersion)
#if SMTG_CPP14
    : cid ()
    , cardinality ()
    , category ()
    , name ()
    , classFlags ()
    , subCategories ()
    , vendor ()
    , version ()
    , sdkVersion ()
#endif
    {
#if SMTG_CPP14
        copyTUID (cid, _cid);
#else
        memset (this, 0, sizeof (PClassInfoW));
        memcpy (cid, _cid, sizeof (TUID));
#endif
        cardinality = _cardinality;
        if (_category)
            strncpy8 (category, _category, PClassInfo::kCategorySize);
        if (_name)
            strncpy16 (name, _name, PClassInfo::kNameSize);
        classFlags = static_cast<uint32> (_classFlags);
        if (_subCategories)
            strncpy8 (subCategories, _subCategories, kSubCategoriesSize);
        if (_vendor)
            strncpy16 (vendor, _vendor, kVendorSize);
        if (_version)
            strncpy16 (version, _version, kVersionSize);
        if (_sdkVersion)
            strncpy16 (sdkVersion, _sdkVersion, kVersionSize);
    }
#if SMTG_CPP11
    constexpr PClassInfoW ()
    : cid ()
    , cardinality ()
    , category ()
    , name ()
    , classFlags ()
    , subCategories ()
    , vendor ()
    , version ()
    , sdkVersion ()
    {
    }
#else
    PClassInfoW () { memset (this, 0, sizeof (PClassInfoW)); }
#endif
 
    SMTG_CONSTEXPR14 void fromAscii (const PClassInfo2& ci2)
    {
#if SMTG_CPP14
        copyTUID (cid, ci2.cid);
#else
        memcpy (cid, ci2.cid, sizeof (TUID));
#endif
        cardinality = ci2.cardinality;
        strncpy8 (category, ci2.category, PClassInfo::kCategorySize);
        str8ToStr16 (name, ci2.name, PClassInfo::kNameSize);
        classFlags = ci2.classFlags;
        strncpy8 (subCategories, ci2.subCategories, kSubCategoriesSize);
 
        str8ToStr16 (vendor, ci2.vendor, kVendorSize);
        str8ToStr16 (version, ci2.version, kVersionSize);
        str8ToStr16 (sdkVersion, ci2.sdkVersion, kVersionSize);
    }
};
 
//------------------------------------------------------------------------
//  IPluginFactory3 interface declaration
//------------------------------------------------------------------------
class IPluginFactory3 : public IPluginFactory2
{
public:
//------------------------------------------------------------------------
    virtual tresult PLUGIN_API getClassInfoUnicode (int32 index, PClassInfoW* info) = 0;
 
    virtual tresult PLUGIN_API setHostContext (FUnknown* context) = 0;
 
//------------------------------------------------------------------------
    static const FUID iid;
};
DECLARE_CLASS_IID (IPluginFactory3, 0x4555A2AB, 0xC1234E57, 0x9B122910, 0x36878931)
//------------------------------------------------------------------------
} // namespace Steinberg
 
//------------------------------------------------------------------------
#define LICENCE_UID(l1, l2, l3, l4) \
{ \
    (int8)((l1 & 0xFF000000) >> 24), (int8)((l1 & 0x00FF0000) >> 16), \
    (int8)((l1 & 0x0000FF00) >>  8), (int8)((l1 & 0x000000FF)      ), \
    (int8)((l2 & 0xFF000000) >> 24), (int8)((l2 & 0x00FF0000) >> 16), \
    (int8)((l2 & 0x0000FF00) >>  8), (int8)((l2 & 0x000000FF)      ), \
    (int8)((l3 & 0xFF000000) >> 24), (int8)((l3 & 0x00FF0000) >> 16), \
    (int8)((l3 & 0x0000FF00) >>  8), (int8)((l3 & 0x000000FF)      ), \
    (int8)((l4 & 0xFF000000) >> 24), (int8)((l4 & 0x00FF0000) >> 16), \
    (int8)((l4 & 0x0000FF00) >>  8), (int8)((l4 & 0x000000FF)      )  \
}
 
//------------------------------------------------------------------------
// GetPluginFactory
//------------------------------------------------------------------------
extern "C"
{
    SMTG_EXPORT_SYMBOL Steinberg::IPluginFactory* PLUGIN_API GetPluginFactory ();
    typedef Steinberg::IPluginFactory* (PLUGIN_API *GetFactoryProc) ();
}