---

Plugins.h

Go to the documentation of this file.

#ifndef PluginsH
#define PluginsH
/*******************************************************************************
Copyright 2000,2001,2002 Petr Kulhanek

    This file is part of Core plugin.

    Core plugin is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    Core plugin is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with Core plugin; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*******************************************************************************/
/*******************************************************************************
** PROJEKT:             Projekt molekulového modelování
** SOUBOR:              Plugins
** úÈEL:                modul pro práci ze zásuvnými moduly
** VERZE:               2.0
** JAZYK:               CBuilder C++ v1.0
** CÍLOVÝ POÈÍTAÈ:      IBM PC
** PROGRAMÁTOR:         Petr Kulhánek
** HISTORIE úPRAV:
VERZE   DATUM       POZNÁMKA
2.0             2000-10-07      zahrnuta identifikace objektù pomocí UUID
*******************************************************************************/

/* HLAVIÈKOVÉ SOUBORY *********************************************************/

#include <Graphics.hpp>
#include <controls.hpp>
#include <extctrls.hpp>
#include <vector>

#include "CoreMainHeader.h"
#include "SmallString.h"
#include "SimpleList.h"
#include "ExtendedUUID.h"
#include "DynamicPackage.h"
#include "EventSystem.h"
#include "RegistryUnit.h"

/* KONEC HLAVIÈKOVÝCH SOUBORù *************************************************/

extern NEMESIS_CORE_PACKAGE class CPluginsDatabase              PluginsDatabase;

DECLARE_EVENT(SET_NEW_LANGUAGE);

//------------------------------------------------------------------------------

// makra

#define START_INIT void PACKAGE InitPoint(CPluginObjectDescription* descrip){
#define INIT_OBJECT(object)  if( descrip->GetObjectUUID() == object.GetObjectUUID() ) descrip->Connect(object);
#define END_INIT }

#define START_INFO void PACKAGE InfoPoint(const CExtUUID& objectuuid,CExtUUID& category,Graphics::TIcon* icon){
#define INFO_OBJECT(object,module) if( objectuuid == object.GetObjectUUID() ){category = object.GetCategory();if(icon)module->ImageList->GetIcon(object.GetImageIndex(),icon);}
#define END_INFO }

#define START_DEPENDENCY void PACKAGE InitDependency(CPluginModule* p_module){ CExtUUID uuid;
#define ADD_DEPENDENCY(object) if( uuid.LoadFromString(object) == true) p_module->AddDependencyPlugin(uuid);
#define END_DEPENDENCY }

//------------------------------------------------------------------------------

/*
pro modifikaci uživatelovy databáze pluginù se používá následující strategie

1. Databáze se zkompletuje podle všech dostupných pluginù (informace z centrálního
   úložištì HKEY_LOCAL_MACHINE
2. pluginy, které nemá uživatel konfigurované, mají nastaven pøíznak Temporary
3. vkládání nebo odstaòování se øídí nastavovaním pøíznaku Temporary
4. po skonèení editace databáze se odstraní doèasné pluginy z databáze

5. pøi ukládání uživatelovy databáze se ukládájí pouze pluginy, které jsou non-temporary
   pøi ukládání se zapisuje do registrèní databáze HKEY_CURRENT_USER pouze jméno
   pluginu a pracovní mód, pøí otevírání pluginu se ostatní informace berou z
   centrální databaze (HKEY_LOCAL_MACHINE) (napø. obrázky, popis objektù v pluginu aj.
*/

//------------------------------------------------------------------------------

class CComObject;
class CVisObject;
class CPluginObjectDescription;
class CPluginModule;
class CPluginObjectInfo;

typedef void* __fastcall (*_CCreateObject)(CPluginObjectInfo* objinfo,void* masterowner);

extern CPluginObjectInfo        CoreGenericObjectInfo;  // obecný objekt, vìtšinou pomocný

// -----------------------------------------------------------------------------
// #############################################################################
// -----------------------------------------------------------------------------

/* DEFINICE TØÍD **************************************************************/


class NEMESIS_CORE_PACKAGE CPluginObjectInfo{
        public:
        __fastcall CPluginObjectInfo(
                                                        const CExtUUID&         objectuuid,
                                const CExtUUID&         categoryuuid,
                                const int                       imageindex,
                                                                _CCreateObject          createobject
                                );

 // zjištovací operace ---------------------------------------------------------
    inline const CSmallString   __fastcall      GetLocaleString(const CSmallString& univalue);
    inline const CExtUUID&      __fastcall  GetCategory(void) const;    // uuid kategorie do které patøí
    inline const CExtUUID&      __fastcall  GetObjectUUID(void) const;  // uuid objektu
    inline CPluginModule*       __fastcall  GetPluginModule(void) const;
    inline int                  __fastcall  GetImageIndex(void) const; // zadaný
    inline int                  __fastcall  GetRealImageIndex(void) const; // v globálním seznamu obrázkù

 // informace o vytvoøení nebo zániku objektu ----------------------------------
    // tyto funkce se volají tehdy pokud se vytváøí objekt uvnitø pluginu
    // napø. jiným objektem
    // volají se i tehdy když se objekt vytváøí pøes volání funkce
    // CreateComObject / CreateVisObject
    void __fastcall     CreateObject(void);
    void __fastcall             DestroyObject(void);

 // ----------------------------------------------------------------------------
    private:
    CExtUUID                                    ObjectUUID;    // uuid objektu
    CExtUUID                                    CategoryUUID;  // uuid kategorie
    const int                                   ImageIndex;    // index obrázku v imagelistu
    _CCreateObject                              CreateObjectPoint;  // funkce definující vytvoøení objektu
    CPluginObjectDescription*   ObjectDescription;  // popis objektu

    friend class CPluginObjectDescription;
    };

//------------------------------------------------------------------------------


class NEMESIS_CORE_PACKAGE CPluginObjectDescription{
    public:
    __fastcall CPluginObjectDescription(CPluginModule* module,
                                                                        const CExtUUID&         objectuuid,
                                                const CExtUUID&         categoryuuid,
                                        int   imageindex
                                        );

    __fastcall ~CPluginObjectDescription(void);

 // popisuje vlastnosti objektu ------------------------------------------------

    inline const CSmallString&  __fastcall GetName(void) const;         // jméno objektu
    inline const int            __fastcall GetImage(void) const;        // grafická reprezentace objektu
    inline const CSmallString&  __fastcall GetCaption(void) const; // lokalizované jméno objektu
    inline const CSmallString&  __fastcall GetHint(void) const;    // popis objektu
    inline const CExtUUID&      __fastcall GetCategory(void) const;    // uuid kategorie do které patøí
    inline const CExtUUID&      __fastcall GetObjectUUID(void) const;  // uuid objektu
    inline int                  __fastcall GetObjectCount(void) const;   // poèet použití objektu

 // vytvoøení objektu ----------------------------------------------------------

    CComObject* __fastcall CreateComObject(void* masterowner);  // vytvoøí objekt odvozený od CComObject
    CVisObject* __fastcall CreateVisObject(void* masterowner);  // vytvoøí objekt odvozený od CVisObject

 // zjiš�ovací operace ---------------------------------------------------------

        inline CPluginModule*   __fastcall GetPluginModule(void) const;

 // výkonné operace ------------------------------------------------------------

        // funkce slouží k napojení na objekt v modulu pluginu, pøes tuto funkci se
    // inicializují pointery pro vytváøení objektù
    void                                           __fastcall Connect(CPluginObjectInfo& info);

 // soukromé data --------------------------------------------------------------
    private:
    CPluginModule*              PluginModule;   // odpovídající modul
    CPluginObjectInfo*  ObjectInfo;             // odpovídající info na stranì pluginu

    CExtUUID            ObjectUUID;     // uuid objektu
    CExtUUID            CategoryUUID;   // uuid kategorie, do které objekt patøí

    int             ImageIndex;     // index obrázku reprezentující objekt
    int             ObjectCounter;  // poèet otevøených objektù

    _CCreateObject  CreateObjectA;  // pointer na funkci vytváøející objekt

    void __fastcall ObjectIsBeforeCreate(void);     // pøed vytvoøením objektu
    void __fastcall ObjectIsDestroyed(void);            // pøi destrukci objektu
    void __fastcall UpdateLocalization(void);       // obnoví lokalizaci položek

    friend class    CPluginModule;
    friend class    CPluginObjectInfo;
    };

// -----------------------------------------------------------------------------
// #############################################################################
// -----------------------------------------------------------------------------

// definice vstupních bodù modulu

// vstupní body modulu - install-time ------------------------------------------

typedef int _CInstallCallBackFunction;   // doèasnì

typedef bool (*_CInstallPoint)(_CInstallCallBackFunction installfunction);

// vstupní body modulu - run-time ----------------------------------------------

typedef bool                                    (*_CInitPoint)(CPluginObjectDescription* descrip);
typedef void                                    (*_CAboutPoint)(void);
typedef const CSmallString      (*_CLocalePoint)(const CSmallString& univalue);
typedef void                    (*_CInfoPoint)(const CExtUUID& objectuuid,CExtUUID& category,Graphics::TIcon* icon);
typedef void                    (*_CInitializePlugin)(void);
typedef void                    (*_CFinalizePlugin)(void);
typedef void                    (*_CInitDependency)(CPluginModule* p_module);

//------------------------------------------------------------------------------

class CPluginsDatabase;


class NEMESIS_CORE_PACKAGE CPluginModule{
    public:
    enum EMode{
        ALWAYS_LOAD,   // vždy natáhne do pamìti
        LOAD_IN_USE,   // natáhne pøi prvním použití
        UNLOAD_ALWAYS, // natáhne pøí prvním použití, pokud se již nepoužívá tak odstraní z pamìti
        };

 // konstruktor a destruktor tøídy ---------------------------------------------

        __fastcall CPluginModule(CPluginsDatabase* base,const CExtUUID& uuid); // vytvoøí
        __fastcall ~CPluginModule(void);

    bool __fastcall InitializeModule(EMode mode = UNLOAD_ALWAYS,bool temporary=false);

 // základní informace o pluginu -----------------------------------------------

    inline const CSmallString&  __fastcall GetName(void) const;         // jméno modulu
    inline const CExtUUID&      __fastcall GetPluginUUID(void) const;   // jednoznaèný identifikator
    inline EMode                        __fastcall GetMode(void) const;         // pracovní mód modulu
    void                        __fastcall About(void);                     // zobrazí dialog o modulu

 // stavové informace o modulu -------------------------------------------------

    inline bool         __fastcall IsModuleLoaded(void) const;  // zjistí zda je modul natažen do pamìti
    inline bool     __fastcall IsTemporary(void) const;         // zjistí zda je modul doèasnì natažen do pamìti

 // nastavovací funkce ---------------------------------------------------------

    void        __fastcall SetTemporaryStatus(bool temporary);
    void    __fastcall SetMode(EMode mode);
    void        __fastcall SetRemoveObjectStatus(bool status);

 // zji�ovací funkce -----------------------------------------------------------

    inline CSimpleList<CPluginObjectDescription>&    __fastcall GetDescriptionList(void);
    CPluginObjectDescription*  __fastcall FindDescription(const CSmallString& name);
    const CSmallString         __fastcall GetLocaleString(const CSmallString& univalue);

 // výkonné funkce -------------------------------------------------------------

    void __fastcall     TryUnload(void);  // funkce se volá v urèitých intervalech
                                                                  // a slouží k odstranìní modulu z pamìti
                                      // pokud již není použiván a má nastaven
                                      // pøíslušný mód

 // závislosti -----------------------------------------------------------------

    void __fastcall AddDependencyPlugin(const CExtUUID& uuid);

 // language support -----------------------------------------------------------
    bool __fastcall SetLanguage(void);
    LCID __fastcall GetDefaultLanguage(void);

 // soukromé data --------------------------------------------------------------
    private:
    CPluginsDatabase*               DataBase; // databáze pluginù

    CSimpleList<CPluginObjectDescription>       PluginObjectDescriptions; // objekty
    CSmallString                                PluginName;               // jméno modulu
    CSmallString                            Path;   // cesta k pluginu, pokud je NULL tak se pouzije cesta z PluginDatabase
    CExtUUID                                PluginUUID;
    vector<CExtUUID>                        DependenciesList;
    CDynamicPackage                 Module;                     // modul
    EMode                           Mode;           // mód modulu
    bool                            Temporary;          // urèuje zda-li je tento modul doèasný
        bool                                                    RemoveObject;   // urèuje zda se má objekt vyøadit z databáze
    int                             ObjectCounter;      // poèet otevøených objektù
    LCID                            DefaultLanguage;


    _CInitPoint                     InitPoint;    // vstupní bod iniciace knihovny
    _CAboutPoint                    AboutPoint;   // informaèní dialog
    _CLocalePoint                   LocalePoint;  // pro lokalizované informace
    _CInfoPoint                     InfoPoint;    // vstupni bod pro kompletaci dat o objektu modulu  
    _CInitializePlugin              InitializePlugin;
    _CFinalizePlugin                FinalizePlugin;
    _CInitDependency                InitDependency;

 // soukromé funkce ------------------------------------------------------------

    bool __fastcall LoadDataFromRegistry(void); // inicializuje seznam objektù modulu

    CPluginObjectDescription* __fastcall AddDescription(const CExtUUID&         objectuuid,
                                                           const CExtUUID&      categoryuuid,
                                   int                          imageindex
                                   );

    bool __fastcall LoadModule(bool only_load=false);   // nahraje modul
    void __fastcall UnloadModule(void);                         // odstraní modul z pamìti
    bool __fastcall LoadDependencyModules(void);


    bool __fastcall ConectAllDescription(void); // aktualizuje všechna pøipojení
    bool __fastcall UpdateLocalization(void);   // aktualizuje lokalizaci

    friend class CPluginObjectDescription;
    friend class CPluginObjectInfo;
    };

// -----------------------------------------------------------------------------
// #############################################################################
// -----------------------------------------------------------------------------

enum EPluginsChangeAction{
        MSG_PLUGIN_OBJECT_DESCRIPTION_CHANGE,
    MSG_PLUGIN_MODULE_CHANGE,
    };

typedef void __fastcall (__closure* TPluginsAction)(EPluginsChangeAction  action,
                                                                                                        void* Sender);

// -----------------------------------------------------------------------------


class NEMESIS_CORE_PACKAGE CPluginsDatabase{
        public:
 // konstruktor a destruktor ---------------------------------------------------
            __fastcall CPluginsDatabase(void);    // vytvoøí prázdnou databázi
            __fastcall ~CPluginsDatabase(void);   // uvolní databázi z pamìti

 // inicializace databaze pluginù ----------------------------------------------
    bool __fastcall Init(void);
    bool __fastcall Clear(void);

 // language support -----------------------------------------------------------
    bool            __fastcall SetLanguage(LCID language);
    CSmallString    __fastcall GetCurrentLanguageString(void);
    CSmallString    __fastcall GetLanguageString(LCID language);
    LCID            __fastcall GetCurrentLanguage(void);
    CSmallString    __fastcall GetLanguageResPath(void);

    bool __fastcall StartEnumLanguages(void);
    bool __fastcall GetLanguage(LCID& lcid);
    void __fastcall EndEnumLanguages(void);

 // vytvoøení objektù ----------------------------------------------------------
    const CExtUUID& __fastcall GetObjectCategory(const CUUID& object_uuid);
    bool __fastcall GetExtObjectType(const CUUID& object_uuid,CExtUUID& extobject_uuid);

    CComObject* __fastcall CreateComObject(const CUUID& object_uuid,void* masterobject=NULL);
    CVisObject* __fastcall CreateVisObject(const CUUID& object_uuid,void* masterobject=NULL);

    bool __fastcall FindObjectExt(const CSmallString& name,const CUUID& object_uuid,CUUID& ext_uuid);
    bool __fastcall FindObjectExtValue(const CSmallString& name,const CUUID& object_uuid,CSmallString& ext_value);

 // individual object setup
    CSmallString __fastcall GetModuleRegName(const CExtUUID& module_uuid);
    CSmallString __fastcall GetObjectRegName(const CUUID& object_uuid);
    CSmallString __fastcall GetObjectRegName(CPluginObjectDescription* p_pod);

 // tyto operace se týkají uložení odkazù na moduly z centrální databáze -------
 // toto uložení jde do HKEY_CURRENT_USER

    bool __fastcall LoadFromRegistry(void);    // inicializuje databázi z registù
    bool __fastcall SaveToRegistry(void);      // uloží databázi do registrù

 // konfigurace uživatelských informací ---------------------------------------

    bool __fastcall AddPlugin(const CExtUUID& uuid,CPluginModule::EMode mode = CPluginModule::UNLOAD_ALWAYS,bool temp=false);  // pøidá modul
    bool __fastcall RemovePlugin(const CSmallString& name);// odebere modul
    void __fastcall SetFlushTimeForUnload(unsigned int time);    // nastaví èas po kterém se odstranují moduly z pamì�i

  // zjištování informací o databázi -------------------------------------------

    CSimpleList<CPluginModule>&                 __fastcall GetModuleList(void);
    CSimpleList<CPluginObjectDescription>&      __fastcall GetPluginDescriptionList(void);
    TImageList*                                                                 __fastcall GetImageList(void);
    TImageList*                                                                 __fastcall GetLargeImageList(void);
    inline const CSmallString&  __fastcall GetExtensionsList(void) const; // pøípona projektù

 // ostatní --------------------------------------------------------------------

    int  __fastcall AddImage(Graphics::TIcon* icon); // vloží obrázek do seznamu obrázkù

    bool __fastcall CompletePluginsDatabase(void); // nahraje všechny moduly do pamìti
                                                                                           // ty co nejsou používany oznaèí jako doèasné
    bool __fastcall ReleaseTemporaryPlugins(void); // odstraní z pamìti všechny doèasné moduly

    // následující funkce se volají když dojde ke zmìnì statusu v obou tøídách
    // zmìna poètu objektù nebo natažení nebo odstranìní z pamì�i
    void __fastcall NotifyDescriptionChange(CPluginObjectDescription* changedobject);
    void __fastcall NotifyModuleChange(CPluginModule* changedmodule);

 // privátní data --------------------------------------------------------------
    private:
    CSimpleList<CPluginModule>                  PluginModules;        // moduly
    CSimpleList<CPluginObjectDescription>       ObjectDescriptions;   // objekty
    TImageList*                         ImageList;      // obrázky
    TImageList*                         LargeImageList; // obrázky
    TTimer*                             FlushTimer;     // èasovaè sloužící k odstranování modulù z pamìti
    TPluginsAction                                              FOnAction;      // volá se pøi rùzných událostech
    CSmallString                                                PluginsPath;    // cesta k pluginùm
    CSmallString                                                MainKeyPath;    // cesta k centrálnímu klíèí
    CSmallString                                                UserKeyPath;    // cesta k uživatelskému klíèi
    CSmallString                        ExtensionsList; // seznam pøípon pro otevøení

 // language support -----------------------------------------------------------
    LCID                                CurrentLanguage;
    CSmallString                        LanguageResPath;
    CSmallString                        MainProgramName;
    LCID                                MainProgramDefLanguage;
    CRegistry                           LangReg;
    int                                 LangIndex;

    void __fastcall OnFlushTimer(TObject* Sender);      // obslužná funkce pro odstraòování modulù z pamì�i
    bool __fastcall SetMainProgramLanguage(void);

    friend class CPluginModule;

 // události -------------------------------------------------------------------

    public:
    __property TPluginsAction  OnAction = {read=FOnAction, write=FOnAction};
    };

// -----------------------------------------------------------------------------
// #############################################################################
// -----------------------------------------------------------------------------


/* KONEC DEFINICE TØÍD ********************************************************/

const CSmallString __fastcall   CPluginObjectInfo::GetLocaleString(const CSmallString& univalue)
{
 return(ObjectDescription->GetPluginModule()->GetLocaleString(univalue));
}

//---------------------------------------------------------------------------

const CExtUUID& __fastcall  CPluginObjectInfo::GetCategory(void) const
{
 return(CategoryUUID);
}

//---------------------------------------------------------------------------

const CExtUUID& __fastcall  CPluginObjectInfo::GetObjectUUID(void) const
{
 return(ObjectUUID);
}

// -----------------------------------------------------------------------------

inline CPluginModule* __fastcall CPluginObjectInfo::GetPluginModule(void) const
{
 return(ObjectDescription->GetPluginModule());
}

// -----------------------------------------------------------------------------

inline int __fastcall CPluginObjectInfo::GetImageIndex(void) const
{
 return(ImageIndex);
}

// -----------------------------------------------------------------------------

inline int __fastcall  CPluginObjectInfo::GetRealImageIndex(void) const
{
 if( ObjectDescription == NULL ) return(-1);
 return(ObjectDescription->GetImage());
}

// -----------------------------------------------------------------------------
// #############################################################################
// -----------------------------------------------------------------------------


inline const CSmallString&  __fastcall CPluginObjectDescription::GetName(void) const
{
 return(ObjectUUID.GetClassName());
}

//---------------------------------------------------------------------------

inline const int __fastcall CPluginObjectDescription::GetImage(void) const
{
 return(ImageIndex);
}

//---------------------------------------------------------------------------

inline const CSmallString&  __fastcall CPluginObjectDescription::GetCaption(void) const
{
 return(ObjectUUID.GetLocaleClassName());
}

//---------------------------------------------------------------------------

inline const CSmallString& __fastcall CPluginObjectDescription::GetHint(void) const
{
 return(ObjectUUID.GetLocaleClassHint());
}

//---------------------------------------------------------------------------

inline const CExtUUID& __fastcall CPluginObjectDescription::GetCategory(void) const
{
 return(CategoryUUID);
}

//---------------------------------------------------------------------------

inline const CExtUUID& __fastcall CPluginObjectDescription::GetObjectUUID(void) const
{
 return(ObjectUUID);
}

//---------------------------------------------------------------------------

inline int __fastcall CPluginObjectDescription::GetObjectCount(void) const
{
 return(ObjectCounter);
}

//---------------------------------------------------------------------------

inline CPluginModule* __fastcall CPluginObjectDescription::GetPluginModule(void) const
{
 return(PluginModule);
}

// -----------------------------------------------------------------------------
// #############################################################################
// -----------------------------------------------------------------------------

inline const CSmallString& __fastcall CPluginModule::GetName(void) const
{
 return(PluginName);
}

//------------------------------------------------------------------------------

inline CPluginModule::EMode __fastcall CPluginModule::GetMode(void) const
{
 return(Mode);
}

//------------------------------------------------------------------------------

inline const CExtUUID& __fastcall CPluginModule::GetPluginUUID(void) const
{
 return(PluginUUID);
}

//------------------------------------------------------------------------------

inline bool __fastcall CPluginModule::IsModuleLoaded(void) const
{
 return(Module != NULL);
}

//------------------------------------------------------------------------------

inline bool __fastcall CPluginModule::IsTemporary(void) const
{
 return(Temporary);
}

//------------------------------------------------------------------------------

inline CSimpleList<CPluginObjectDescription>& __fastcall CPluginModule::GetDescriptionList(void)
{
 return(PluginObjectDescriptions);
}

//---------------------------------------------------------------------------

inline CSimpleList<CPluginModule>& __fastcall CPluginsDatabase::GetModuleList(void)
{
 return(PluginModules);
}

//---------------------------------------------------------------------------

inline CSimpleList<CPluginObjectDescription>& __fastcall CPluginsDatabase::GetPluginDescriptionList(void)
{
 return(ObjectDescriptions);
}

//---------------------------------------------------------------------------

inline TImageList* __fastcall CPluginsDatabase::GetImageList(void)
{
 return(ImageList);
}

//---------------------------------------------------------------------------

inline TImageList* __fastcall CPluginsDatabase::GetLargeImageList(void)
{
 return(LargeImageList);
}

//---------------------------------------------------------------------------

inline const CSmallString&  __fastcall CPluginsDatabase::GetExtensionsList(void) const
{
 return(ExtensionsList);
}

//---------------------------------------------------------------------------

#endif

---