source: golgotha/src/maxtool/sdk_inc/plugin.h Tweet

#ifndef PLUGIN_H_DEFINED
#define PLUGIN_H_DEFINED

/*******************************************************************
 *
 *    DESCRIPTION: DLL Plugin classes
 *
 *    AUTHOR: Dan Silva
 *
 *    HISTORY: 11/30/94 Started coding
 *
 *******************************************************************/

typedef unsigned long ulong;

#include <plugapi.h>
//---------------------------------------------------------
// This is the interface to a DLL
// Each DLL may implement any number of classes. 
//
class DllDesc {
public:
        HINSTANCE               handle;
        TSTR fname;
        const TCHAR*    (*vDescription)();   // copy of this string can be stored in the DLL dir
        int                             (*vNumClasses)();    // How many classes does this DLL implement?
    ClassDesc*          (*vClassDesc)(int i); // Hands back a ClassDesc for the ith class
        CoreExport              DllDesc(); 
        CoreExport void                 Free() { FreeLibrary(handle); }
        CoreExport const TCHAR* Description() { return (*vDescription)(); };
        CoreExport int                  NumberOfClasses() { return (*vNumClasses)(); };
        ClassDesc*              operator[](int i) { return (*vClassDesc)(i); };
        int operator==( const DllDesc& dd ) const { return 0; }
        };


/*-----------------------------------------------------------------
 We will build one big DllDir on startup.
 As we do this, we will build a set of lists, one for each SuperClass.
 For a given super class, we want to 
        (a) Enumerate all public subclasses 
        (b) Enumerate all subclasses
        (c) Find the subClass for a given subClass ID.

--------------------------------------------------------------*/

class ClassEntry {
        int dllNumber;  // index into the master Dll list
        int classNum;   // index of the class within the DLL
        int isPublic;
        int useCount;  // used for enumerating classes in summary info
        Class_ID classID;
        TSTR name;
        TSTR category;
        ClassDesc *cd;  
        
        // The following are use to store the last rollup state for a
        // given class. 'scroll' is the scroll amount of the command panel
        // and pageState is the open close state for up to 32 rollup pages. (when the bit is set that means the rollup page is closed)
        int scroll;
        DWORD pageState;
        
        public:
                CoreExport ClassEntry();
                CoreExport ClassEntry(const ClassEntry &ce);
                CoreExport ClassEntry(ClassDesc *cld, int dllN, int index);
                CoreExport void Set(ClassDesc *cld, int dllN, int index);
                int DllNumber() { return dllNumber; }
                int IsPublic() { return isPublic; }
                Class_ID ClassID() { return classID; }
                TSTR &ClassName() { return name; }
                TSTR &Category() { return category; }
                int GetScroll() {return scroll;}
                void SetScroll(int s) {scroll = s;}
                BOOL GetPageState(int i) {return (pageState&(1<<i))?TRUE:FALSE;}
                void SetPageState(int i,BOOL state) {if (state) pageState |= (1<<i); else pageState &= ~(1<<i);}
                int UseCount() { return useCount; }
                void IncUseCount () { useCount++; }
            void SetUseCount(int i) { useCount = i; }
                ClassDesc *CD() { return cd; }
                CoreExport int ClassEntry::IsAccType(int accType);
                CoreExport ClassEntry& operator=( const ClassEntry &ce ); 
                int operator==( const ClassEntry &ce ) const { return 0; }
        };

// access type.
#define ACC_PUBLIC 1
#define ACC_PRIVATE 2
#define ACC_ALL (ACC_PUBLIC|ACC_PRIVATE)

typedef ClassEntry* PClassEntry;
typedef Tab<PClassEntry> SubClassTab;


class SubClassList {
                int iEnum;
                ulong superID;
                SubClassTab subClList;
    public:
                CoreExport ~SubClassList();
                SubClassList(ulong sid=0) { superID = sid; }
                ClassEntry& operator[](int i){ return(*subClList[i]);}
                CoreExport int FindClass(Class_ID subClassID);    // Get a class by its class ID
                CoreExport int FindClass(const TCHAR *name);    // Get a class by its class name
                CoreExport void AddClass(ClassDesc *cld, int dllNum, int index); 
                CoreExport int  Count(int accType);
                ulong SuperID() { return superID; }
                int operator==(const SubClassList &sl) {return(0);}

                // Enumerate.
                CoreExport int GetFirst(int accType);    // get first ClassDesc of accType
                CoreExport int GetNext(int accType);     // get next ClassDesc of accType (NULL for End)

                int operator==( const SubClassList& lst ) const { return 0; }
        };


typedef SubClassList* PSubClassList;
typedef Tab<PSubClassList> ListOfClassLists;

/* ClassDirectory: A list of SubClassLists, one for each pluggable
   super class */
class ClassDirectory {
        ListOfClassLists cl;
        public:                           
                CoreExport ~ClassDirectory();
                CoreExport SubClassList* GetClassList(SClass_ID superClassID);  
                CoreExport ClassDesc* FindClass(SClass_ID superClassID, Class_ID subClassID);
                CoreExport ClassEntry *FindClassEntry(SClass_ID superClassID, Class_ID subClassID);
                SubClassList& operator[](int i){ return(*cl[i]);}
                CoreExport void AddSuperClass(SClass_ID superClassID);
                // returns 0 if class already exists
                // returns -1 if superclass was unknown
                CoreExport int  AddClass(ClassDesc *cdesc, int dllNum, int index);
                int Count() { return cl.Count(); }      
        };

/* DllDirectory: A list DllDescriptors, one for every DLL loaded 
   Also contains the ClassDirectory of all classes implemented in these
   DLL's */

typedef DllDesc *PDllDesc;

class DllDir {
        Tab<PDllDesc> dll;    // list of Descriptors for all the loaded DLL's
        ClassDirectory classDir; // All the classes implemented in these DLL's 
        int  AddDll(const DllDesc *dllDesc);
        public:
                CoreExport ~DllDir();
                CoreExport void UnloadAllDlls();
                int Count() { return dll.Count(); }
                DllDesc& operator[](int i) { return(*dll[i]); }
                CoreExport int LoadDllsFromDir(TCHAR *directory, TCHAR *  wildcard, HWND hwnd=NULL);
                ClassDirectory& ClassDir() { return classDir; }
        };

#endif // PLUGIN_H_DEFINED