---

Fragment.h

Go to the documentation of this file.

#ifndef FragmentH
#define FragmentH
/*******************************************************************************
Copyright 1998,1999,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:              Fragment
** úÈEL:                slouží pro popis èástí molekuly
** VERZE:               2.0
** JAZYK:               CBuilder C++
** CÍLOVÝ POÈÍTAÈ:      IBM PC
** PROGRAMÁTOR:         Petr Kulhánek
** HISTORIE úPRAV:
VERZE   DATUM       POZNÁMKA
1.0             ????-??-??      vznik tøídy, zahrnuje i CBondManipulateFragment a
                                        CTemporaryFragment
2.0             2000-12-01      zùstalo pouze jádro definující fragment, ostatní tøídy byly
                                        pøesunuty a upraveny tak aby pracovaly pøes CGraphicsObject
                    dale byla zavedena tøída CFragmentsList
*******************************************************************************/

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

#include "CoreMainHeader.h"
#include "ExtObject.h"
#include "Atom.h"
#include "Bond.h"
#include "HistoryList.h"
#include "ContainerEnumerator.h"

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

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

extern CPluginObjectInfo FragmentObjectInfo;

class CFragmentsList;

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


class NEMESIS_CORE_PACKAGE CFragmentData{
        public:
 // konstruktor a destruktor ---------------------------------------------------
        __fastcall CFragmentData(void);
        __fastcall ~CFragmentData(void);

 // inicializaèní a rekonstrukèní operace --------------------------------------
        void            __fastcall GetFromFragment(CFragment* p_fragment);
    CFragment*  __fastcall MakeFragment(CMolecule* molecule,CElementsRecord* history=NULL) const;
    inline int  __fastcall GetFragmentIndex(void) const;

 // sekce soukromých dat -------------------------------------------------------
    public:
    int                                         FragmentIndex;  // index fragmentu
    CSmallString                        Name;           // jméno fragmentu
    CSmallString                        Description;    // popis fragmentu
    CExtObject::CStatus         Status;         // status fragmentu
    int                                         NumOfAtoms;     // poèet atomù fragmentu
    int                     NumOfBonds;         // poèet vazeb fragmentu
    int                     NumOfHalfBonds; // poèet hranièních vazeb
    int*                                        Atoms;                  // seznam indexù atomù
    int*                                        Bonds;          // seznam indexù vazeb
    int*                    HalfBonds;      // seznam hranièních vazeb
    };

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


class NEMESIS_CORE_PACKAGE CFragment : public CExtObject{
    public:
 // konstruktor a destruktor ---------------------------------------------------
                        __fastcall CFragment(CFragmentsList* own);
    void        __fastcall RemoveFromBaseList(CElementsRecord* history=NULL);

 // operace pro mapování fragmentù ---------------------------------------------
    void __fastcall MapAtoms(CAtom* atom1,CAtom* atom2=NULL,CElementsRecord* history=NULL);
    void __fastcall MapBonds(CElementsRecord* history=NULL);
    void __fastcall EndMap(void);

 // metody - operace zaznamenané do seznamu zmìn -------------------------------
    bool __fastcall Delete(void);
    bool __fastcall DeleteContents(void);
    bool __fastcall SaveChangePositionOfAtoms(void);
    bool __fastcall MapAtomsFromSelection(CSelection* p_selection);
    bool __fastcall AddObject(CExtObject* p_object);
    bool __fastcall RemoveObject(CExtObject* p_object);

 // metody - zjištovací operace ------------------------------------------------
    CPoint __fastcall GetCentrum(void);
    inline CMolecule* __fastcall GetMolecule(void);

 // metody - uložení a naètení fragmentu -------------------------------------------
    bool __fastcall Load(CXMLElement* p_el);
    bool __fastcall Save(CXMLElement* p_el);
    bool __fastcall SaveInStructureFormat(CXMLElement* p_el);

 // metody - pomocné funkce ----------------------------------------------------
    bool __fastcall RegisterAtom(CAtom* atom,CElementsRecord* history=NULL);
    bool __fastcall UnregisterAtom(CAtom* atom,CElementsRecord* history=NULL);
    bool __fastcall RegisterBond(CBond* bond,CElementsRecord* history=NULL);
    bool __fastcall UnregisterBond(CBond* bond,CElementsRecord* history=NULL);
    bool __fastcall RegisterHalfBond(CBond* bond,CElementsRecord* history=NULL);
    bool __fastcall UnregisterHalfBond(CBond* bond,CElementsRecord* history=NULL);

 // metody
    virtual void __fastcall RemoveFromRegistered(CExtObject* object,CElementsRecord* history=NULL);

 // sekce veøejných dat --------------------------------------------------------
    CSimpleList<CAtom>           Atoms;           // seznam atomù
    CSimpleList<CBond>           Bonds;           // seznam vazeb
    CSimpleList<CBond>           HalfBonds;       // seznam okrajových vazeb, není vlastníkem

    private:
    CFragmentsList*                              BaseList;                // seznam fragmentù
    bool                         HighlightStatus;
    virtual void __fastcall ProcessEvent(const CEventIdentifier& event,CExtObject* Sender,void* p_data);
    };
    
// ----------------------------------------------------------------------------

DECLARE_EVENT(Fragment_RegisterObject);
DECLARE_EVENT(Fragment_UnregisterObject);

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


class NEMESIS_CORE_PACKAGE CFragmentsList : public CExtObject, public CTemplList<CFragment> {
    public:
        __fastcall CFragmentsList(CMolecule* own);

 // metody se záznamem do history listu ----------------------------------------
    CFragment* __fastcall CreateFragment(CFragmentData& fragmentdata);

 // metody - operace se seznamem -----------------------------------------------
    CFragment* __fastcall SearchByName(const CSmallString& name);
    CFragment* __fastcall SearchByDescription(const CSmallString& descrip);

 // metody - výkonové operace --------------------------------------------------
        CFragment* __fastcall MakeNewFragment(CElementsRecord* history=NULL);
    CFragment* __fastcall AddFragment(CFragmentData& fd,CElementsRecord* history=NULL);

 // metody - uložení a naètení fragmentù -------------------------------------------
    bool __fastcall Load(CXMLElement* p_el);
    bool __fastcall Save(CXMLElement* p_el);

 // zjiš�ovací operace ---------------------------------------------------------
    __property CMolecule* Molecule = {read = FMolecule};

 // sekce soukromých dat -------------------------------------------------------
    private:
    CMolecule* FMolecule; // odkaz na molekulu
    };


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

DECLARE_EVENT(FragmentsList_AddFragment);
DECLARE_EVENT(FragmentsList_RemoveFragment);

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

extern CPluginObjectInfo FragmentEnumObjectInfo;
extern CExtUUID          ID_FragmentEnum;

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


class CFragmentEnumerator : public CContainerEnumerator {
    public:
        __fastcall CFragmentEnumerator(CComObject* owner,CMolecule* molecule);

    virtual int __fastcall NumOfCommands(void);
    virtual CSmallString __fastcall GetCommand(int i,bool& enabled);
    virtual bool __fastcall DoCommand(int i);

    virtual int         __fastcall NumOfObjects(void);
    virtual bool        __fastcall PrepareObjects(int startpos,int size,int rstart,int rend);
    virtual CExtObject* __fastcall GetObject(int pos);

 // funkce pro rozšíøený popis objektù a kontejnerù ----------------------------
    virtual int __fastcall NumOfColumns(void);  // poèet sloupcù popisujících objekt
    virtual const CSmallString __fastcall GetColumnCaption(int index); // popis sloupce
    virtual const CSmallString __fastcall GetObjectProperty(int index); // vlastnost objektu
    virtual int __fastcall GetObjectImageIndex(void);

    virtual CExtObject* __fastcall GetCurrentObject(void);
    virtual bool __fastcall SetCurrentObject(CExtObject* p_object);

    private:
    CFragmentsList*             Fragments;
    CTemplIterator<CFragment>   Pointer;
    CFragment*                  CurrentObject;
    int                         StartPos;
    int                         EndPos;
    bool                        Changed;
    CSimpleList<CFragment>      CurrentView;

    virtual void __fastcall CFragmentEnumerator::ProcessEvent(const CEventIdentifier& event,CExtObject* Sender,void* p_data);

    };

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

/* TØÍDA:   CBondDataHistory
   ÚÈEL:    popisuje fragment, používá history list
*/

class CFragmentDataHistory : public CElementData{
    public:
                                __fastcall CFragmentDataHistory(CFragment* p_fragment,bool create);
    private:
    virtual void        __fastcall Forward(void);
    virtual void        __fastcall Backward(void);

    CMolecule*          Molecule;
    CFragmentData   Data;
    };


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

class CFragmentsListCreateFragmentHistory:public CCoreElementsRecord{
    public:
        __fastcall CFragmentsListCreateFragmentHistory(const CSmallString& name);
        private:
    virtual CSmallString __fastcall GetDescription(const CSmallString& format);
    CSmallString    FragmentName;
    };

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


/*  TØÍDA: CFragmentDeleteHistory
    ÚÈEL:  slouží pro záznam odstranìní fragmentu
*/

class CFragmentDeleteHistory:public CCoreElementsRecord{
        public:
        __fastcall CFragmentDeleteHistory(CFragment* p_fragment);

    private:
    CSmallString  Name;
    virtual CSmallString __fastcall GetDescription(const CSmallString& format);
    };

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

class CFragmentDeleteContentsHistory:public CCoreElementsRecord{
        public:
        __fastcall CFragmentDeleteContentsHistory(CFragment* p_fragment);
    private:
    CSmallString  Name;
    virtual CSmallString __fastcall GetDescription(const CSmallString& format);
    };

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

/*  TØÍDA: CFragmentPositionHistory
    ÚÈEL:  slouží pro záznam zmìny polohy fragmentu
*/

class CFragmentPositionHistory:public CCoreElementsRecord{
    public:
    __fastcall CFragmentPositionHistory(void);
    __fastcall ~CFragmentPositionHistory(void);
    bool __fastcall ConstructFromList(CSimpleList<CAtom> &atoms);

    private:
    CMolecule* Molecule;
    CPoint  *Area;
    int     *Indexs;
    int     Size;
    virtual CSmallString __fastcall GetDescription(const CSmallString& format);
    virtual void __fastcall Forward(void);
    virtual void __fastcall Backward(void);
    };

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

class CFragmentObjectUnregHistory: public CElementData{
    public:
    __fastcall CFragmentObjectUnregHistory(CFragment* p_fr,CExtObject* p_obj,bool regobject,bool half=false);

    private:
    CMolecule*  Molecule;
    int         FragmentIndex;
    int         ObjectIndex;
    bool        IsAtom;
    bool        Half;

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

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

class CMapAtomsFromSelectionHistory : public CCoreElementsRecord{
    public:
    __fastcall CMapAtomsFromSelectionHistory(CFragment* p_fra);

    private:
    CSmallString    FragmentName;
    virtual CSmallString __fastcall GetDescription(const CSmallString& format);
    };

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

class CMapObjectHistory : public CCoreElementsRecord{
    public:
    __fastcall CMapObjectHistory(CFragment* p_fra,CExtObject* p_object,bool add);

    private:
    CSmallString    FragmentName;
    CSmallString    ObjectName;
    CSmallString    ObjectType;
    virtual CSmallString __fastcall GetDescription(const CSmallString& format);
    };

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

inline int      __fastcall CFragmentData::GetFragmentIndex(void) const
{
 return(FragmentIndex);
}

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

inline CMolecule* __fastcall CFragment::GetMolecule(void)
{
 return(BaseList->Molecule);
}

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


#endif

---