---

Atom.h

Go to the documentation of this file.

#ifndef AtomH
#define AtomH

/*******************************************************************************
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:              Atom
** ÚÈEL:                tøída popisující atom v molekule
** VERZE:               4.0
** JAZYK:               CBuilder C++
** CÍLOVÝ POÈÍTAÈ:      IBM PC
** PROGRAMÁTOR:         Petr Kulhánek
** HISTORIE ÚPRAV:
VERZE   DATUM       POZNÁMKA
1.0     ?????       vytvoøení koncepce tøídy, atomy vázané vazbou k atomu, byly
                    øazeny do pole o konstantní velikosti
2.0     ?????       použití tøídy CList pro registraci atomù tvoøících vazbu
2.1     30.04.1998  zmìna jmen (C...)
2.1     01.09.1998  doplnìní o nové modely
3.0     24.07.1999  doplnìní o history list
3.0     30.01.2000  pøenesení všech tøíd pro záznam zmìn do tohoto modulu
3.1     27.05.2000  pøenesení vykreslování do CStandardModel
4.0     02.09.2000  redistribuce èásti tøídy atom a úprava modularity
                2000-11-15      zavedení tøídy CAtomType pro popis atomového typu v molekulové
                                mechanice
*******************************************************************************/

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

#include "CoreMainHeader.h"
#include "ExtObject.h"
#include "SimpleList.h"
#include "Point.h"
#include "Bond.h"
#include "ContainerEnumerator.h"

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

class CStructureUnit;
class CMolecule;
class CSmallString;
class CFragment;
class CAtomsList;
class CXMLElement;

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

extern CPluginObjectInfo AtomObjectInfo;

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


class NEMESIS_CORE_PACKAGE CAtomType{
    public:
    const CSmallString& __fastcall GetStringForm(void) const;
    void __fastcall SetFromStringForm(const CSmallString& set);


    friend ostream& __fastcall operator << (ostream& str,const CAtomType& sa);
    friend istream& __fastcall operator >> (istream& str,CAtomType& sa);
        private:
    CSmallString                MMType;
    };

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


class NEMESIS_CORE_PACKAGE CAtomData{
    public:
 // konstruktor ----------------------------------------------------------------
        __fastcall CAtomData(void);

 // extraktor a inserter pro proudové operace ----------------------------------
    friend ostream& __fastcall operator << (ostream& str,const CAtomData& sa);
    friend istream& __fastcall operator >> (istream& str,CAtomData& sa);

    bool __fastcall Load(CXMLElement* p_el);
    bool __fastcall Save(CXMLElement* p_el);

 // inicializaèní a rekonstrukèní operace --------------------------------------
        void    __fastcall GetFromAtom(const CAtom* p_atom);
    CAtom*      __fastcall MakeAtom(CMolecule* molecule,CElementsRecord* history=NULL) const;
    inline int __fastcall GetAtomIndex(void) const;

 // sekce verejných dat -------------------------------------------------------

    public:
    int                          Z;             // protonové èíslo
    CPoint                       Pos;           // poloha atomu
    CSmallString         Name;          // jméno objektu
    CSmallString                 Description;   // popis atomu
    CExtObject::CStatus  Status;        // status atomu
    CAtomType            AtomType;              // typ pro molekulovou mechaniku
    int                          AtomIndex;     // jednoznaèný identifikátor atomu
    };

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


class NEMESIS_CORE_PACKAGE CAtom : public CExtObject{
 public:
 // konstruktor a destruktor ---------------------------------------------------
         __fastcall CAtom(CAtomsList *bl);
         __fastcall CAtom(CAtomsList *bl,int Z,const CPoint& pos);
         __fastcall ~CAtom(void);
    void __fastcall RemoveFromBaseList(CElementsRecord* history=NULL);

 // metody - zmìny registrované do seznamu zmìn --------------------------------
    bool __fastcall   ChangePos(const CPoint& pos);
    bool __fastcall   ChangeZ(int newz);
    bool __fastcall   Delete(void);   // odstraní atom z molekuly, odstraòuje konstrejny
    bool __fastcall   MakeBondWith(CAtom *atom,EBondOrder order);

 // metody - zjiš�ovací operace ------------------------------------------------
    // redefinované virtuální funkce
    virtual CGeoDescriptor      __fastcall GetGeoDescriptor(void);

    // novì definované funkce
    __property CMolecule* Molecule = {read = GetMolecule};

    inline CMolecule*           __fastcall      GetMolecule(void) const;   // molekula, pod kterou patøí
    inline CAtomsList*      __fastcall  GetAtomsList(void) const;  // seznam atomù
    inline const CPoint&    __fastcall  GetPos(void) const;        // poloha atomu
    inline int              __fastcall  GetZ(void) const;          // protonové èíslo
    inline const CAtomType& __fastcall  GetAtomType(void) const;   // atomový typ

    inline CSimpleList<CBond>& __fastcall GetBonds(void); // vrátí seznam vazeb
    inline CStructureUnit*        __fastcall GetStructureUnit(void) const;

    inline bool   __fastcall       IsVirtual(void);
    CBond* __fastcall       IsFixedWith(const CAtom *a2); // urèí zda je vázán s atomem
    CBond* __fastcall       GetConectBond(void);    // urèí valenèní vazbu

 // metody - zmìnové operace neregistrované do seznamu zmìn --------------------
    inline  void __fastcall SetPos(const CPoint& pos);
    inline  void __fastcall SetZ(int z);
    inline  void __fastcall SetAtomType(const CAtomType& atomtype);
            void __fastcall SetStructureUnit(CStructureUnit* su);

    void __fastcall     SetWorkForFragment(bool set_status);    // používá se pro mapování fragmentù
    bool __fastcall GetWorkForFragment(void);

 // mol info methods -----------------------------------------------------------
    inline int  __fastcall GetMolInfoIndex(void);
    inline void __fastcall SetMolInfoIndex(int index);

 // pomocné funkce -------------------------------------------------------------
    // tyto funkce slouží pro registraci jednotlivých objektù a to speciálnì
    // vazeb (z dùvodu strukturních)
    inline void __fastcall RegisterBond(CBond *b);
    inline void __fastcall UnregisterBond(CBond *b);

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

 // ............. SEKCE PRIVÁTNÍCH DAT .........................................
 private:
    int                 Z;               // protonové èíslo
    CPoint              Pos;             // poloha
    CAtomType           AtomType;        // typ atomu
    CSimpleList<CBond>  Bonds;                  // seznam vazeb vychazejicích z atomu
    CAtomsList*                 BaseList;               // seznam, pod který patøí
    CStructureUnit*     StructureUnit;      // strukturní jednotka
    int                 MolInfoIndex;    // index in MoleculeInfo structure

    friend class CAtomData;
        };

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

DECLARE_EVENT(Atom_SetPosition);
DECLARE_EVENT(Atom_SetZ);
DECLARE_EVENT(Atom_SetAtomType);

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


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

 // metody - zmìny registrované do seznamu zmìn --------------------------------
    bool  __fastcall  Center(void);
    CAtom* __fastcall CreateAtom(const CAtomData& atomdata);

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

 // metody - výkonové operace --------------------------------------------------
    CAtom* __fastcall AddAtom(int z,const CPoint& pos,CElementsRecord* history=NULL);
    CAtom* __fastcall AddAtom(const CAtomData& sa,CElementsRecord* history=NULL);
    void  __fastcall  SetCenter(const CPoint& center);

 // metody - uložení a naètení atomù -------------------------------------------
    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(AtomsList_AddAtom);
DECLARE_EVENT(AtomsList_RemoveAtom);


extern CPluginObjectInfo AtomEnumObjectInfo;
extern CExtUUID          ID_AtomEnum;

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


class CAtomEnumerator : public CContainerEnumerator {
    public:
            __fastcall CAtomEnumerator(CComObject* owner,CMolecule* molecule);
    virtual __fastcall ~CAtomEnumerator(void);

    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 data section -------------------------------------------------------
    private:
    CAtomsList*             Atoms;
    CTemplIterator<CAtom>   Pointer;
    CEventReciever          Receiver;
    CAtom*                  CurrentObject;
    int                     StartPos;
    int                     EndPos;
    bool                    Changed;
    CSimpleList<CAtom>      CurrentView;

    virtual void __fastcall ProcessEvent(const CEventIdentifier& event,CExtObject* Sender,void* p_data);
    void __fastcall RecieveEvent(const CEventIdentifier& EventType,void* Data,void* Sender);
    void __fastcall TestCondition(EEventCondition CondType,bool& Result);
    };



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

/*
v této èásti jsou definovány tøídy sloužící pro záznam zmìn do history listu
*/

/*  TØÍDA:  CAtomElementData
    ÚÈEL:   obsahuje elementární data popisující atom, slouží pro záznam
                strukturních zmìn
*/

class CAtomDataHistory: public CElementData{
    public:
    __fastcall CAtomDataHistory(CAtom* p_atom,bool create);

    private:
    CMolecule*      Molecule;
    CAtomData           Data;
    
    virtual void __fastcall Forward(void);
    virtual void __fastcall Backward(void);
    };

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

/*  TØÍDA: CAtomsListCenterHistory
    ÚÈEL:  tøída sloužící pro záznam zmìny tìžištì molekuly
*/

class CAtomsListCenterHistory:public CCoreElementsRecord{
    public:
 // konstruktor a destruktor tøídy ---------------------------------------------
    __fastcall CAtomsListCenterHistory(CMolecule* molecule,const CPoint& center);

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

 // sekce soukromých dat -------------------------------------------------------
    private:
    CMolecule*  Molecule;  // molekula
    CPoint      Center;    // pùvodní poloha tìžištì
    virtual void __fastcall Forward(void);
    virtual void __fastcall Backward(void);
    };

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

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

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

/*  TØÍDA: CAtomZHistory
    ÚÈEL:  slouží pro záznam zmìny protonového èísla atomu
*/

class CAtomZHistory:public CCoreElementsRecord{
    public:
 // konstruktor a destruktor ---------------------------------------------------
        __fastcall CAtomZHistory(CAtom* p_atom,int newz);

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

 // sekce soukromých dat -------------------------------------------------------
    private:
    CMolecule*      Molecule;  // vlastník atomu
    CSmallString    Name;
    CSmallString    Description;
    int                     NewZ;      // nová hodnota
    int                     OldZ;      // pùvodní hodnota Z
    int                 AtomIndex; // index atomu
    virtual void __fastcall Forward(void);
    virtual void __fastcall Backward(void);
    };

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

class CAtomPosHistory:public CCoreElementsRecord{
    public:
 // konstruktor a destruktor ---------------------------------------------------
        __fastcall CAtomPosHistory(CAtom* p_atom,const CPoint& newpos);

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

 // sekce soukromých dat -------------------------------------------------------
    private:
    CMolecule*      Molecule;  // vlastník atomu
    CSmallString    Name;
    CSmallString    Description;
    CPoint                  NewPos;      // nová hodnota
    CPoint          OldPos;      // pùvodní hodnota Z
    int                     AtomIndex; // index atomu
    virtual void __fastcall Forward(void);
    virtual void __fastcall Backward(void);
    };

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

class CDeleteAtomHistory:public CCoreElementsRecord{
    public:
        __fastcall CDeleteAtomHistory(CAtom* atom);
        private:
    virtual CSmallString __fastcall GetDescription(const CSmallString& format);
    CSmallString    AtomName;
    };

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

class CMakeBondHistory:public CCoreElementsRecord{
    public:
        __fastcall CMakeBondHistory(CAtom* atom1,CAtom* atom2,EBondOrder order);
        private:
    virtual CSmallString __fastcall GetDescription(const CSmallString& format);
    CSmallString    AtomName1;
    CSmallString    AtomName2;
    };

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

inline int __fastcall CAtomData::GetAtomIndex(void) const
{
 return(AtomIndex);
}

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

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

//..............................................................................

inline CAtomsList* __fastcall CAtom::GetAtomsList(void) const
{
 return(BaseList);
}

//..............................................................................

inline const CPoint& __fastcall CAtom::GetPos(void) const
{
 return(Pos);
}

//..............................................................................

inline int __fastcall CAtom::GetZ(void) const
{
 return(Z);
}

//..............................................................................

inline const CAtomType& __fastcall CAtom::GetAtomType(void) const
{
 return(AtomType);
}

//..............................................................................

inline CSimpleList<CBond>& __fastcall CAtom::GetBonds(void)
{
 return(Bonds);
}

//..............................................................................

inline void  __fastcall CAtom::SetPos(const CPoint& pos)
{
 Pos = pos;
 ThrowEvent(Atom_SetPosition);
 ThrowEvent(ExtObject_SetGeoDescriptor);
}

//..............................................................................

inline void __fastcall CAtom::SetZ(int z)
{
 Z = z;
 ThrowEvent(Atom_SetZ);
}

//..............................................................................

inline bool __fastcall CAtom::IsVirtual(void)
{
 return((Z==0)||(Z==1));
}

//..............................................................................

inline void __fastcall CAtom::SetAtomType(const CAtomType& atomtype)
{
 AtomType = atomtype;
 ThrowEvent(Atom_SetAtomType);
}

//..............................................................................

inline void __fastcall CAtom::RegisterBond(CBond *b)
{
 Bonds.InsertToEnd(b);
}

//..............................................................................

inline void __fastcall CAtom::UnregisterBond(CBond *b)
{
 Bonds.Remove(b);
}

//..............................................................................

inline CStructureUnit* __fastcall CAtom::GetStructureUnit(void) const
{
 return(StructureUnit);
}

//..............................................................................

inline int  __fastcall CAtom::GetMolInfoIndex(void)
{
 return(MolInfoIndex);
}

//..............................................................................

inline void __fastcall CAtom::SetMolInfoIndex(int index)
{
 MolInfoIndex = index;
}

//..............................................................................

#endif

---