plugin.h

Go to the documentation of this file.

#pragma once

// Copyright 2010 Autodesk, Inc.  All rights reserved. 
//
// This computer source code and related instructions and comments are the
// unpublished confidential and proprietary information of Autodesk, Inc. and
// are protected under applicable copyright and trade secret law.  They may
// not be disclosed to, copied or used by any third party without the prior
// written consent of Autodesk, Inc.

#include "maxheap.h"
#include "strclass.h"
#include "plugapi.h"
#include "Path.h"
#include "Noncopyable.h"
#include "BuildWarnings.h"
#include "DataClassDesc.h"

typedef const ULONG (*LibVersionProcPtr)();

typedef const MCHAR* (*LibDescriptionProcPtr)();

typedef int (*LibNumberClassesProcPtr)();

typedef ClassDesc* (*LibClassDescProcPtr)(int i);

typedef int (*LibInitializeProcPtr)();

typedef int (*LibShutdownProcPtr)();

typedef ULONG (*CanAutoDeferProcPtr)();

class DllDesc: public MaxHeapOperators
{
public:
    CoreExport bool IsLoaded() const;

    CoreExport const MCHAR* Description() const;

    CoreExport int NumberOfClasses() const;

    CoreExport ClassDesc* operator[](int i) const;

    CoreExport ClassDesc* GetClassDesc(int i) const;

    CoreExport int operator==( const DllDesc& dd ) const;

    CoreExport bool HasRttiSupport() const;

    CoreExport bool IsBinaryCompatible() const;

    CoreExport ULONG GetVersion() const;

    CoreExport bool IsDeferrable() const;

    CoreExport bool ImplementsCanAutoDefer() const;

    CoreExport static bool IsPluginDllVersionValid(ULONG pluginDllVersion);

    CoreExport const MSTR& GetFullPath() const;

    CoreExport const MSTR& GetFileName() const;

    CoreExport const MSTR& GetDirectoryName() const;

    CoreExport const HINSTANCE GetHandle() const;

    CoreExport DWORD GetSize() const;

    CoreExport FILETIME GetTimeLastModified() const;

    MAX_DEPRECATED void Free();

    MAX_DEPRECATED BOOL Initialize();

    MAX_DEPRECATED BOOL Shutdown();

    // The following methods are supposed to be used only internally, therefore
    // they are not exported.

    // Constructor - Use it to create a DllDesc that represents a plug-in DLL that was 
    // loaded (had a valid HINSTANCE), as  opposed to being defer loaded.
    explicit DllDesc(
        HINSTANCE dllHandle, 
        const MCHAR* dllFullPath, 
        LibVersionProcPtr libVersionProcPtr,
        LibDescriptionProcPtr libDescriptionProcPtr,
        LibNumberClassesProcPtr libNumberClassesProcPtr,
        LibClassDescProcPtr libClassDescProcPtr,
        LibInitializeProcPtr libInitializeProcPtr,
        LibShutdownProcPtr libShutdownProcPtr,
        CanAutoDeferProcPtr canAutoDeferProcPtr,
        const FILETIME& timeLastWrite);

    // Constructor - Use it create a DllDesc that represents a defer loaded plug-in DLL
    explicit DllDesc(const MCHAR* dllFullPath, const MCHAR* dllDescription, const FILETIME& timeLastWrite);
    
    // Unloads the plug-in DLL that corresponds to this DllDesc instance
    void Unload();

    // Calls a plug-in's LibInitialize method
    BOOL CallInitialize();

    // Calls a plug-in's LibShutdown method 
    BOOL CallShutdown();

    // Copy constructor 
    DllDesc(const DllDesc& other);

    // Assignment operator
    DllDesc operator=(const DllDesc& other);

    // Destructor 
    ~DllDesc(); 

private:
    class DllDescImpl;
    MaxSDK::AutoPtr<DllDescImpl> mImpl;

    // Disallowed method
    DllDesc();
};

/*-----------------------------------------------------------------
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.

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

#pragma warning(push)
#pragma warning(disable:4100)
class ClassEntry : public MaxHeapOperators
{
    public:
        CoreExport ClassEntry();
        CoreExport ClassEntry(const ClassEntry &ce);
        CoreExport ClassEntry(ClassDesc *cld, int dllN, int index, bool load);
        CoreExport ~ClassEntry();

        CoreExport int DllNumber() const;
        
        CoreExport int IsPublic() const;
        
        CoreExport Class_ID ClassID() const;
        
        CoreExport MSTR& ClassName() const;
        
        CoreExport MSTR& Category() const;

        CoreExport int UseCount() const;

        CoreExport void IncUseCount();

        CoreExport void SetUseCount(int i);

        CoreExport int IsAccType(int accType);
        
        CoreExport bool IsLoaded() const;

        CoreExport int ClassNumber() const;

        CoreExport ClassDesc* CD() const;

        CoreExport ClassDesc* FullCD();

        CoreExport ClassEntry& operator=( const ClassEntry &ce ); 

        CoreExport int operator==( const ClassEntry &ce ) const;

        CoreExport void Set(ClassDesc *cld, int dllN, int index, bool load);

        CoreExport int GetScroll() const;

        CoreExport void SetScroll(int s); 

        CoreExport BOOL PageStateSet() const; 

        CoreExport BOOL GetPageState(int i) const;

        CoreExport void SetPageState(int i,BOOL state);

        CoreExport DWORD GetPageState() const;

    private:
        class ClassEntryImpl;
        MaxSDK::Util::AutoPtr<ClassEntryImpl> mImpl;
};


#define ACC_PUBLIC 1 

#define ACC_PRIVATE 2 

#define ACC_ALL (ACC_PUBLIC|ACC_PRIVATE)


class SClassUIInfo: public MaxHeapOperators
    {
    public:
        virtual ~SClassUIInfo() {}
    // A color associated with the superclass.  This is currently used to draw nodes
    // in the schematic view at extreme zoom-outs where it is impossible to draw
    // legible node names.
    CoreExport virtual COLORREF Color(SClass_ID superClassID) { return RGB(128, 128, 128); };

    // Draws an image which represents the superclass (usually an icon) in a rectangle
    // in a given Windows DC.  The implementation should attempt to draw the image as fast
    // as possible as this method is called repeatedly while drawing certain UI
    // components.  Return false if no image was drawn and a generic stand-in image will
    // be used.  The provided "bkColor" is the average background color of the surface on
    // which the image is being drawn.  It can be used, if desired, to antialias the image.
    CoreExport virtual bool DrawRepresentation(SClass_ID superClassID, COLORREF bkColor, HDC hDC, Rect &rect) { return false; }
};


class SubClassList : public MaxSDK::Util::Noncopyable
{
    public:
    CoreExport ClassEntry& operator[](int i)const;

    CoreExport int FindClass(Class_ID classID) const;
    
    CoreExport int FindClass(const MCHAR *name) const;
    
    CoreExport void AddClass(ClassDesc *cld, int dllNum, int index, bool load); 

    CoreExport int  Count(int accType) const;
    
    CoreExport SClass_ID SuperID() const;
    
    CoreExport int GetFirst(int accType) const;

    CoreExport int GetNext(int accType) const;

    CoreExport int operator==( const SubClassList& lst ) const;
    CoreExport int operator==(const SubClassList &sl);

    CoreExport int DeleteClass(ClassDesc *cld); 

    CoreExport void SetUIInfo(SClassUIInfo *uiInfo);

    CoreExport SClassUIInfo* GetUIInfo() const;

    CoreExport void ReplaceClass(int idx, ClassDesc *cld, int dllNum, int index, bool load); 

    ~SubClassList();
    SubClassList(SClass_ID sid);

private:
    class SubClassListImpl;
    MaxSDK::Util::AutoPtr<SubClassListImpl> mImpl;

private:
    SubClassList(); // disallowed
};
#pragma warning(pop)

class ClassDirectory : public MaxSDK::Util::Noncopyable 
{
public:
    CoreExport static ClassDirectory& GetInstance();

    CoreExport SubClassList* GetClassList(SClass_ID superClassID) const;

    CoreExport int Count() const;

    CoreExport SubClassList& operator[](int i) const;

    CoreExport ClassDesc* FindClass(SClass_ID superClassID, const Class_ID& classID) const;

    CoreExport ClassEntry* FindClassEntry(SClass_ID superClassID, const Class_ID& classID) const;

    CoreExport int AddClass(ClassDesc* cdesc, int dllNum, int index, bool load);

    CoreExport int DeleteClass(ClassDesc* cdesc);

    CoreExport bool SetUIInfoForSClass(SClass_ID superClassID, SClassUIInfo* uiInfo);

    CoreExport SClassUIInfo* GetUIInfoForSClass(SClass_ID superClassID) const;

    ClassDirectory();
    ~ClassDirectory();

private:
    class ClassDirectoryImpl;
    MaxSDK::Util::AutoPtr<ClassDirectoryImpl> mImpl;

    void AddSuperClass(SClass_ID superClassID);
};

class DllDir : public MaxSDK::Util::Noncopyable
{
    public:
        CoreExport static DllDir& GetInstance();

        /* Destructor */
        virtual  ~DllDir() = 0;

        CoreExport int Count() const;

        CoreExport const DllDesc& operator[](int i) const;

        CoreExport const DllDesc& GetDllDescription(int i) const;

        CoreExport int LoadDlls(const MCHAR* pluginWildcard, bool forceLoadDeferrablepluginDlls = false);

        CoreExport int LoadDllsFromDir(const MCHAR* pluginPath, const MCHAR* pluginWildcard, bool forceLoadDeferrablePluginDlls = false);

        CoreExport bool LoadADll(const MCHAR* pluginDllFileName, bool forceLoadDeferrablePluginDlls);

        CoreExport ClassDirectory& ClassDir() const;

        CoreExport const DllDesc* GetDllDescriptionForClass(SClass_ID superClassId, const Class_ID& classId);

        CoreExport int FindDllDescFromDllPath(const MaxSDK::Util::Path& aFullPath) const;

        CoreExport int FindDllDescFromHInstance(const HINSTANCE hInst) const;

        MAX_DEPRECATED void UnloadAllDlls();

    protected:
        // Constructor
        DllDir();
        class DllDirImpl;
        MaxSDK::AutoPtr<DllDirImpl> mImpl;

    private:
        bool LoadADllProxy(const MaxSDK::Util::Path& filePath, const MCHAR* description, const FILETIME& timeLastWrite);

};