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;                            
//------------------------------------------------------------------------
        PFactoryInfo (const char8* _vendor, const char8* _url, const char8* _email, int32 _flags)
        {
                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];          
//------------------------------------------------------------------------
 
        PClassInfo (const TUID _cid, int32 _cardinality, const char8* _category, const char8* _name)
        {
                memset (this, 0, sizeof (PClassInfo));
                memcpy (cid, _cid, sizeof (TUID));
                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]; 
 
//------------------------------------------------------------------------
 
        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)
        {
                memset (this, 0, sizeof (PClassInfo2));
                memcpy (cid, _cid, sizeof (TUID));
                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];        
 
//------------------------------------------------------------------------
        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)
        {
                memset (this, 0, sizeof (PClassInfoW));
                memcpy (cid, _cid, sizeof (TUID));
                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
 
        void fromAscii (const PClassInfo2& ci2)
        {
                memcpy (cid, ci2.cid, sizeof (TUID));
                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) ();
}