---

ExtObject.h

Go to the documentation of this file.

#ifndef ExtObjectH
#define ExtObjectH

/*******************************************************************************
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 NEMESIS
** SOUBOR:              ExtObject
** ÚÈEL:                tøída popisující základní vlastnosti objektu
** VERZE:               1.0
** JAZYK:               CBuilder C++
** CÍLOVÝ POÈÍTAÈ:      IBM PC
** PROGRAMÁTOR:         Petr Kulhánek
** HISTORIE ÚPRAV:
VERZE   DATUM       POZNÁMKA
1.0     02.09.2000  tøída vznikla pro zvýšení modularizace celého kódu
                2000-11-01      vytvoøení univerzální tøídy pro libovolný objekt pluginu,
                                pùvodní funkce, které mají využití pouze v projektu NEMESIS
                    byly pøeneseny do tøídy CExtObject
        2000-11-16  zrušena tøída CRegisteredObject, její úlohu pøebírá
                                tato tøída
        2001-12-15  zavedení automatizace manageru objektu pøes správce pluginù
*******************************************************************************/

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

#include "CoreMainHeader.h"
#include "SimpleList.h"
#include "ComObject.h"
#include "GeoDescriptor.h"
#include "CoreHistoryList.h"
#include "EventSystem.h"

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

/*
ZÁKLADNÍ FILOZOFIE NON-VCL OBJEKTU

Každý objekt, který není pøímo nebo nepøímo odvozen od knihovny VCL, musí dìdit
jako bázovou tøídu tøídu CExtObject (zkrácenina z ExtendedObject). Tato tøída
zajištuje jméno objektu, jeho popis a status. Tyto vlastnosti lze nastavovat
pøímo nebo se záznamem do HistoryListu. Zatím kromì stutusu, protože u nìj mùže
v dùsledku ruzné implementace docházet k možné nereverzibilitì zmìn.
Kromì toho tato tøída zajištuje obecné vlastnosti objektu jako jsou geometrický
deskriptor, který zajištuje jednotné mìøení geometrie mezi objekty a jednoznaèný
identifikátor objektu.
Poslední velmi dùležitou èástí objektu je registrace nebo odregistrování událostí
nad objektem.
Události vyvolává objekt a zpracovává je objekt, který událost zaregistroval.
Tento model slouží ke komunikaci mezi objektem a ruznými manažery, kteøí mohou
mìnit data objektu. Systém událostí zajištuje konzistenci mezi daty objektu a daty
zobrazenými v rùzných manažerech.
*/

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

class CProject;
class CPluginObjectDescription;
class CExtObject;
class CObjectDesigner;
class CExtVisObject;


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


class NEMESIS_CORE_PACKAGE CExtObject : public CComObject{
    public:
        __fastcall CExtObject(CComObject* owner,CPluginObjectInfo* objectinfo,CProject* project);
        __fastcall CExtObject(CVisObject* owner,CPluginObjectInfo* objectinfo,CProject* project);
    __fastcall ~CExtObject(void);

  // veøejné datové struktury --------------------------------------------------

    class NEMESIS_CORE_PACKAGE CStatus{
        public:
                        __fastcall CStatus(void);
        friend istream& __fastcall operator >> (istream& str,CStatus& status);
        friend ostream& __fastcall operator << (ostream& str,const CStatus& status);

        CSmallString __fastcall GetStringForm(void) const;
        void __fastcall SetFromStringForm(const CSmallString& set);

        public:
        bool Locked : 1;        // objekt je uzamèen
        bool Visible : 1;       // viditelnost objektu
        bool Highlighted : 1;   // zvýraznìní objektu
        bool FragmentWork : 1;  // slouží pro mapování fragmentù
        bool Active: 1;         // urèuje zda je objekt aktivní
        bool Temporary: 1;      // doèasný objekt
        bool ShowName: 1;
        bool ShowDescription: 1;
        };

  // metody - zjištìní projektu ------------------------------------------------
    inline CProject* __fastcall GetProject(void) const;
    __property CProject* Project = {read=FProject};

  // zmìnové metody - záznam do history listu ----------------------------------
                // událost ComObject_SetName
    bool         __fastcall ChangeName(const CSmallString& name);
                // událost ComObject_SetDescription
    bool         __fastcall ChangeDescription(const CSmallString& name);
    bool         __fastcall ChangeStatus(const CStatus& status);
// zatím není rozhodnuto zda bude podporováno z možných dùvodu nereverzibility zmìn

  // základní nastavení objektu ------------------------------------------------
        // událost ExtObject_SetName
    void  __fastcall SetName(const CSmallString& name);
        // událost ExtObject_SetDescription
    void  __fastcall SetDescription(const CSmallString& name);

  // metody - uzamèení objektu
        // událost ComObject_SetStatus
    void __fastcall Lock(bool status,bool propagate=false);
    inline bool __fastcall IsLocked(void) const;

  // metody - viditelnost objektu
        // událost ComObject_SetStatus
    void __fastcall SetVisible(bool status,bool propagate=false);
    inline bool __fastcall IsVisible(void) const;

  // metody - zvýraznìní objektu
        // událost ComObject_SetStatus
    void __fastcall Highlight(bool status,bool propagate=false);
    inline __fastcall IsHighlighted(void) const;

  // obecné nastavení objektu --------------------------------------------------

  // metody - status objektu (viditelnost a uzamèení objektu zahrnuto)
        // událost ComObject_SetStatus
    void             __fastcall SetStatus(const CStatus& status,const CStatus& mask,bool propagate=false);
    inline const CStatus&   __fastcall GetStatus(void) const;

    virtual CGeoDescriptor  __fastcall GetGeoDescriptor(void);  // geometrický deskriptor

 // práce s managerem objektu
    CObjectDesigner* __fastcall OpenObjectDesigner(bool unregistered=false);

  // metody - registruje a odregistrovává obsluhu událostí

  // metody pro práci s registrovanými objekty ---------------------------------
    inline void  __fastcall RegisterObject(CExtObject* p_ro);
    inline void  __fastcall UnregisterObject(CExtObject* p_ro);
    void                 __fastcall UnregisterAllRegisteredObjects(CElementsRecord* history=NULL);
    virtual void __fastcall RemoveFromRegistered(CExtObject* object,CElementsRecord* history=NULL){};
    inline CExtObject* __fastcall  RemoveFirstFromROList(void); // odstraní ze seznamu první registrovaný objekt
    inline CSimpleList<CExtObject>& __fastcall GetROList(void);

  // registrace handlerù obsluhující události ----------------------------------
    bool __fastcall RegisterEventForServer(const CEventIdentifier& event,CExtObject* server);
    bool __fastcall UnregisterEventForServer(const CEventIdentifier& event,CExtObject* server);
    bool __fastcall UnregisterAllEvents(void);

    bool __fastcall UnregisterAllEventsForClient(CExtObject* client);
    bool __fastcall UnregisterAllEventsForClient(CExtVisObject* client);

  // metody - vyvolá událost
    void __fastcall ThrowEvent(const CEventIdentifier& event);
    void __fastcall ThrowEvent(const CEventIdentifier& event,void* p_data);

  // metody - zpracuje událost
    virtual void __fastcall ProcessEvent(const CEventIdentifier& event,CExtObject* Sender,void* p_data);

  // metody - povoluje šíøení událostí
    inline void __fastcall EnableEvents(bool status);

  // sekce soukromých dat ------------------------------------------------------
    private:
    class CEventRecievers;         // zpracovatelé události - viz dále
    CProject*                       FProject;            // projekt, pod který patøí
    CStatus                         Status;             // status objektu
    CSimpleList<CEventRecievers>    RegisteredEvents;   // registrované události a zpracovatelé
    CSimpleList<CExtObject>         Servers;            // používané servery
    CEventRecievers*                RunningEventReceiver;
    bool                            EnabledEvents;      // povolení vyvolání události
    CSimpleList<CExtObject>             RegisteredObjects;  // registrované objekty
    CObjectDesigner*                ObjectDesigner;

    virtual bool __fastcall PropagateStatus(const CStatus& status,const CStatus& mask);
    friend class CObjectDesigner;
    friend class CExtVisObject;
    friend class CEventRecievers;
    };

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

/*  TØÍDA: class CComObject::CEventRecievers
    ÚÈEL:  sdružuje zpracovatelé události Event
*/

class CExtObject::CEventRecievers{ // popis pøíjemcù zprávy
    public:
                __fastcall CEventRecievers(const CEventIdentifier& event);
    // registruje funkci pro zpracování události
    bool    __fastcall RegisterClient(CExtObject* client);
    bool    __fastcall RegisterClient(CExtVisObject* client);
    // odregistruje funkci pro zpracování události
    bool    __fastcall UnregisterClient(CExtObject* client);
    bool    __fastcall UnregisterClient(CExtVisObject* client);
    //
    bool    __fastcall UnregisterClientOnServerSide(CExtObject* server);
    // vyvolá událost nad všemi registrovanými zpracovateli událostí
    void    __fastcall ThrowEvent(CExtObject* object,void* p_data);
    // událost nemá žádného zpracovatele (vrátí FALSE)
    inline bool                     __fastcall IsEmpty(void) const;
    // vrátí pøidruženou událost
    inline const CEventIdentifier&  __fastcall GetEvent(void);
    inline void __fastcall SetRemoveAfterThrowEvent(void);

  // sekce dat ------------------------------------------------------
    public:
    bool    RemoveAfterThrowEvent;

    private:
    const CEventIdentifier& Event;          // událost
    class CClientDescription{
        public:
        CExtObject*     ExtClient;
        CExtVisObject*  ExtVisClient;
        };
    CSimpleList<CClientDescription> Clients;      // zpracovatelé události
    CSimpleIterator<CClientDescription> TPH;
    bool   MoveTPH;
    };

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

// definice událostí pro objekt CComObject

DECLARE_EVENT(ExtObject_SetName);
DECLARE_EVENT(ExtObject_SetDescription);
DECLARE_EVENT(ExtObject_SetStatus);
DECLARE_EVENT(ExtObject_Delete);
DECLARE_EVENT(ExtObject_SetGeoDescriptor);

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

/*  TØÍDA: CExtObjectNameHistory
    ÚÈEL:  záznam zmìny jména
*/

class CExtObjectNameHistory:public CCoreElementsRecord{
    public:
 // konstruktor a destruktor ---------------------------------------------------
        __fastcall CExtObjectNameHistory(CExtObject* p_object,const CSmallString& newname);

                // zjištìní celého øetìzce popisujícího zmìnu
    virtual CSmallString __fastcall GetDescription(const CSmallString& format);

 // sekce soukromých dat -------------------------------------------------------
    private:
    CProject*           Project;     // vlastník
    CSmallString            NewName;      // nová hodnota
    CSmallString            OldName;      // pùvodní hodnota Z
    CPluginObjectInfo*  ObjectInfo;
    int                         ObjectIndex; // index objektu

    virtual void __fastcall Forward(void);
    virtual void __fastcall Backward(void);
    };

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

/*  TØÍDA: CExtObjectDescriptionHistory
    ÚÈEL:  záznam zmìny popisu objektu
*/
class CExtObjectDescriptionHistory:public CCoreElementsRecord{
    public:
 // konstruktor a destruktor ---------------------------------------------------
        __fastcall CExtObjectDescriptionHistory(CExtObject* p_object,const CSmallString& newdescription);

                // zjištìní celého øetìzce popisujícího zmìnu
    virtual CSmallString __fastcall GetDescription(const CSmallString& format);

 // sekce soukromých dat -------------------------------------------------------
    private:
    CProject*           Project;     // vlastník
    CSmallString            NewDescription;      // nová hodnota
    CSmallString            OldDescription;      // pùvodní hodnota Z
    int                         ObjectIndex; // index objektu
    CPluginObjectInfo*  ObjectInfo;

    virtual void __fastcall Forward(void);
    virtual void __fastcall Backward(void);
    };

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

/*  TØÍDA: CHL_ChangeDescription
    ÚÈEL:  záznam zmìny popisu objektu
*/
class CExtObjectStatusHistory:public CCoreElementsRecord{
    public:
 // konstruktor a destruktor ---------------------------------------------------
        __fastcall CExtObjectStatusHistory(CExtObject* p_object,const CExtObject::CStatus& newstatus);

                // zjištìní celého øetìzce popisujícího zmìnu
    virtual CSmallString __fastcall GetDescription(const CSmallString& format);

 // sekce soukromých dat -------------------------------------------------------
    private:
    CProject*       Project;     // vlastník
    CExtObject::CStatus         NewStatus;      // nová hodnota
    CExtObject::CStatus         OldStatus;      // pùvodní hodnota Z
    int                     ObjectIndex; // index objektu

    virtual void __fastcall Forward(void);
    virtual void __fastcall Backward(void);
    };

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

inline CProject* __fastcall CExtObject::GetProject(void) const
{
 return(Project);
}

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

inline bool __fastcall CExtObject::IsLocked(void) const
{
 return(Status.Locked);
}

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

inline bool __fastcall CExtObject::IsVisible(void) const
{
 return(Status.Visible);
}

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

inline __fastcall CExtObject::IsHighlighted(void) const
{
 return(Status.Highlighted);
}

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

inline const CExtObject::CStatus& __fastcall CExtObject::GetStatus(void) const
{
 return(Status);
}
//------------------------------------------------------------------------------

inline void __fastcall CExtObject::EnableEvents(bool status)
{
 EnabledEvents = status;
}

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

inline bool __fastcall CExtObject::CEventRecievers::IsEmpty(void) const
{
 return(Clients.IsEmpty());
}

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

inline const CEventIdentifier& __fastcall CExtObject::CEventRecievers::GetEvent(void)
{
 return(Event);
}

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

inline CExtObject* __fastcall CExtObject::RemoveFirstFromROList(void)
{
 return(RegisteredObjects.RemoveFromBegin());
}

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

inline void  __fastcall CExtObject::RegisterObject(CExtObject* p_ro)
{
 RegisteredObjects.InsertToEnd(p_ro);
}

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

inline void  __fastcall CExtObject::UnregisterObject(CExtObject* p_ro)
{
 RegisteredObjects.Remove(p_ro);
}

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

inline CSimpleList<CExtObject>& __fastcall CExtObject::GetROList(void)
{
 return(RegisteredObjects);
}

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


#endif

---