---

Constraint.h

Go to the documentation of this file.

#ifndef ConstraintH
#define ConstraintH
/*******************************************************************************
Copyright 2000,2001,2002,2003 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:              Constraint.h
** ÚÈEL:                tøída popisující konstreiny
** VERZE:               4.0
** JAZYK:               CBuilder C++
** CÍLOVÝ POÈÍTAÈ:      IBM PC
** PROGRAMÁTOR:         Petr Kulhánek
** HISTORIE ÚPRAV:
VERZE   DATUM       POZNÁMKA
3.1     27.05.2000  pøevedení vykreslování do CStandardModel
4.0     2001-04-15  vykreslování se stává záložitostí tohoto objektu,
                    jedná se o hybrid mezi strukturním objektem a grafickým objektem
                    molekuly,
*******************************************************************************/

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

#include "ExtObject.h"
#include "List.h"
#include "Point.h"
#include "ContainerEnumerator.h"

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

extern CPluginObjectInfo ConstraintObjectInfo;

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

class CConstraint;
class CConstraintsList;
class CMolecule;
class CAtom;
class CAdvancedProject;
class CXMLElement;
class CJob;
class CMoleculeInfo;

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


class NEMESIS_CORE_PACKAGE CPositionLock{
    public:
    bool    LockX:1;
    bool    LockY:1;
    bool    LockZ:1;

    public:
    __fastcall CPositionLock(void);

    bool operator == (const CPositionLock& left) const;
    };

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


enum EConstraintType{
        CT_ATOM = 0,       // freeze center
        CT_DISTANCE = 1,   // vzdálenost
        CT_ANGLE = 2,      // úhel
        CT_DIHEDRAL = 3       // torsní úhel
        };

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


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

 // inicializaèní a rekonstrukèní operace --------------------------------------
        void            __fastcall GetFromConstraint(const CConstraint* p_con);
    CConstraint*        __fastcall MakeConstraint(CConstraintsList* p_list,CElementsRecord* history=NULL) const;
    inline int      __fastcall GetConstraintIndex(void) const;

 // sekce soukromých dat -------------------------------------------------------
    public:
    int                 ConstraintIndex;
    CSmallString        Name;           // jméno objektu
    CSmallString                Description;    // popis atomu
    CExtObject::CStatus Status;         // status atomu
    EConstraintType     Type;           // typ konstrejnu
    int                 AtomIndex[4];   // co tvoøí atom
    CPositionLock       Lock;           // které osy jsou uzamèeny (pro konstrejn polohy atomu)
    CPoint              Value;          // hodnota
    double              Sigma;          // možná odchylka
    bool                HarmonicFreeze;
    };

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


class NEMESIS_CORE_PACKAGE CConstraint : public CExtObject{
    public:
 // konstruktor a destruktor ---------------------------------------------------
         __fastcall CConstraint(CConstraintsList *bl);
         __fastcall CConstraint(CConstraintsList *bl,
                            CAtom *a1,CAtom *a2,CAtom *a3,CAtom *a4,
                            EConstraintType type,const CPoint& value,double sigma,
                            const CPositionLock& lock);
    void __fastcall RemoveFromBaseList(CElementsRecord* history=NULL);

 // metody - zmìnové operace zaznamenávané do history listu --------------------
    bool __fastcall Delete(void);
    bool __fastcall ChangeData(const CPoint& value,double sigma,
                            const CPositionLock& lock,bool harmonic,bool active);
    bool __fastcall ChangeActiveState(void);
    bool __fastcall ChangeActiveStateTo(bool set);
    bool __fastcall Synchronize(void); // set actual value as constraint value
    
 // operace pro nastavení vlastností objektu -----------------------------------
    void __fastcall    SetValue(const CPoint& value);
    void __fastcall    SetFinalDrvValue(const CPoint& drvvalue);
    void __fastcall    SetSigma(double sigma);
    void __fastcall    SetActive(bool act);
    void __fastcall    SetHarmonic(bool harmonic);
    void __fastcall    SetLock(const CPositionLock& lock);
    void __fastcall    SetDrivingMode(bool set);

 // zjištovací operace ---------------------------------------------------------
    inline double           __fastcall GetSigma(void) const;
    inline bool             __fastcall IsActive(void) const;
    inline bool             __fastcall IsHarmonic(void) const;
    inline EConstraintType  __fastcall GetConstraintType(void) const;
           int              __fastcall GetTypeImage(void) const;
    inline const CPoint&    __fastcall GetValue(void) const;
    CPoint                  __fastcall GetActualValue(void);
    CPoint                  __fastcall GetValueForMoleculeInfo(CMoleculeInfo* p_minfo);
    inline const CPoint&    __fastcall GetFinalDrvValue(void) const;
    inline CAtom*           __fastcall GetAtom(int index) const;
    inline bool             __fastcall IsInDrivingMode(void) const;

    inline const CPositionLock&     __fastcall GetLock(void) const;
    inline CMolecule*                   __fastcall      GetMolecule(void) const;   // molekula, pod kterou patøí

    __property CMolecule* Molecule = {read = GetMolecule};

    inline CConstraintsList* __fastcall GetBaseList(void);
    inline CJob*             __fastcall GetJob(void);

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

 // funkce sloužící pro registraci objektù -------------------------------------
    virtual void __fastcall RemoveFromRegistered(CExtObject* object,CElementsRecord* history=NULL);

 // sekce soukromých dat -------------------------------------------------------
    private:
    CConstraintsList*   BaseList;   // bázový seznam
    EConstraintType     Type;       // typ konstrejnu
    CAtom*              A[4];       // atomy tvoøící konstraint
    CPoint              Value;      // pro vzdálenost, úhel, atd, je platná hodnota x
    CPoint              FinalDrvValue;
    CPositionLock       Lock;       // urèuje co je uzamèeno
    double              Sigma;      // možná odchylka
    bool                Harmonic;   // cönstraint(false)/restraint(true)
    bool                DrivingMode;

    public:
    static int CTAtomIndex;
    static int CTDistanceIndex;
    static int CTAngleIndex;
    static int CTDihedralIndex;
    };

 // ----------------------------------------------------------------------------
// seznam definovaných událostí nad objektem CConstraint

DECLARE_EVENT(Constraint_DataChange);
DECLARE_EVENT(Constraint_Activate);
DECLARE_EVENT(Constraint_SetDrvMode);
DECLARE_EVENT(Constraint_SetDrvParm);

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


class NEMESIS_CORE_PACKAGE CConstraintsList:public CExtObject,public CTemplList<CConstraint> {
        public:
 // konstruktor ----------------------------------------------------------------
    __fastcall  CConstraintsList(CMolecule *p_mol,CJob* p_job);

 // metody - zmìny registrované do seznamu zmìn --------------------------------
    static bool __fastcall CreateConstraint(CSimpleList<CExtObject>& list);

    CConstraint* __fastcall AddConstraintWithHistory(
                            CAtom *a1,CAtom *a2,CAtom *a3,CAtom *a4,
                            EConstraintType type,const CPoint& value,double sigma,
                            const CPositionLock& lock,
                            const CSmallString& name,const CSmallString& descrip);

    bool __fastcall ChangeActiveStatusForAllConstraints(bool active);
    bool __fastcall DeleteAllConstraints(void);
    bool __fastcall DeleteNonActiveConstraints(void);
    bool __fastcall SynchronizeAllConstraints(void);

 // metody - výkonové operace --------------------------------------------------
        CConstraint* __fastcall AddConstraint(
                            CAtom *a1,CAtom *a2,CAtom *a3,CAtom *a4,
                            EConstraintType type,const CPoint& value,double sigma,
                            const CPositionLock& lock,
                            CElementsRecord* history=NULL);
    CConstraint* __fastcall AddConstraint(CConstraintData& sc,CElementsRecord* history=NULL);

 // metody - operace se seznamem -----------------------------------------------
    CConstraint* __fastcall SearchByName(const CSmallString& name);
    CConstraint* __fastcall SearchByDescription(const CSmallString& descrip);
    CConstraint* __fastcall FindConstraint(CAtom* a1,CAtom* a2=NULL,CAtom* a3=NULL,CAtom* a4=NULL);

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

 // lock methods ---------------------------------------------------------------
    void        __fastcall Lock(bool set);
    inline bool __fastcall IsLocked(void);

 // metody - uložení a naètení atomù -------------------------------------------
    bool __fastcall Load(CXMLElement* p_el,bool new_indexes=false,CElementsRecord* history=NULL);
    bool __fastcall Save(CXMLElement* p_el);

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

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

DECLARE_EVENT(ConstraintsList_AddConstraint);
DECLARE_EVENT(ConstraintsList_Lock);
DECLARE_EVENT(ConstraintsList_RemoveConstraint);

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

extern CPluginObjectInfo ConstraintEnumObjectInfo;
extern CExtUUID          ID_ConstraintEnum;

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


class CConstraintEnumerator : public CContainerEnumerator {
    public:
        __fastcall CConstraintEnumerator(CComObject* owner,CConstraintsList* p_conlist);
        __fastcall ~CConstraintEnumerator(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:
    CConstraintsList*             Constraints;
    CTemplIterator<CConstraint>   Pointer;
    CConstraint*                  CurrentObject;
    int                           StartPos;
    int                           EndPos;
    bool                          Changed;
    CSimpleList<CConstraint>      CurrentView;
    CEventReciever                Receiver;
    
    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);
    };

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

/*  TØÍDA:  class CConstraintDataHistory
    ÚÈEL:   popisuje elementární zmìnu týkající se konstrejnu
*/

class CConstraintDataHistory : public CElementData{
    public:
 // konstruktor ----------------------------------------------------------------
        __fastcall CConstraintDataHistory(CConstraint *p_con,bool create);

    private:
    CProject*           Project;
    int                 ConstraintsListIndex;
    CConstraintData     Data;
    virtual void __fastcall Forward(void);
    virtual void __fastcall Backward(void);
    };

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

/*  TØÍDA:  class CConstraintListAddConstraintHistory
    ÚÈEL:   slouží pro ukládání zmìn v konstrejn listu, jak pro vytvoøení v
            CConstreintListu tak i pro odstranìní v CConstraint
*/

class CConstraintListAddConstraintHistory : public CCoreElementsRecord {
    public:
    __fastcall CConstraintListAddConstraintHistory(CConstraint *p_con,bool create);

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

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

class CConstraintChangeDataHistory : public CCoreElementsRecord {
    public:
    __fastcall CConstraintChangeDataHistory(CConstraint *p_con,const CPoint& value,
                            double sigma,const CPositionLock& lock,
                            bool harmonic,bool active);

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

    int                 ConstraintIndex;
    CSmallString        Name;
    CProject*           Project;
    int                 ConstraintsListIndex;

    CPoint              NewValue;
    double              NewSigma;
    CPositionLock       NewLock;
    bool                NewHarmonic;
    bool                NewActive;

    CPoint              OldValue;
    double              OldSigma;
    CPositionLock       OldLock;
    bool                OldHarmonic;
    bool                OldActive;
    };

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

class CConstraintChangeActiveStateHistory : public CCoreElementsRecord {
    public:
    __fastcall CConstraintChangeActiveStateHistory(CConstraint *p_con);

    private:
    CSmallString Name;
    int          ConstraintIndex;
    CProject*    Project;
    int          ConstraintsListIndex;

    virtual CSmallString __fastcall GetDescription(const CSmallString& format);
    virtual void __fastcall Forward(void);
    virtual void __fastcall Backward(void);
    };

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

class CConstraintChangeActiveStateToHistory : public CCoreElementsRecord {
    public:
    __fastcall CConstraintChangeActiveStateToHistory(CConstraint *p_con, bool newvalue);

    private:
    CSmallString Name;
    int          ConstraintIndex;
    CProject*    Project;
    int          ConstraintsListIndex;
    bool         OldValue;
    bool         NewValue;      

    virtual CSmallString __fastcall GetDescription(const CSmallString& format);
    virtual void __fastcall Forward(void);
    virtual void __fastcall Backward(void);
    };

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

class CConstraintsChangeAllActiveStateHistory : public CCoreElementsRecord {
    public:
        __fastcall CConstraintsChangeAllActiveStateHistory(CConstraintsList* p_list,bool activate);
        __fastcall ~CConstraintsChangeAllActiveStateHistory(void);

    private:
    CProject*    Project;
    int          ConstraintsListIndex;
    bool         Activate;
    int          NumOfObjects;   
    int*         Indexes;
    bool*        Statuses;

    virtual CSmallString __fastcall GetDescription(const CSmallString& format);
    virtual void __fastcall Forward(void);
    virtual void __fastcall Backward(void);
    };

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

class CDeleteAllConstraintsHistory : public CCoreElementsRecord {
    public:
        __fastcall CDeleteAllConstraintsHistory(void);
    };

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

class CDeleteNonActiveConstraintsHistory : public CCoreElementsRecord {
    public:
        __fastcall CDeleteNonActiveConstraintsHistory(void);
    };

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

class CSynchronizeAllConstraintsHistory : public CCoreElementsRecord {
    public:
        __fastcall CSynchronizeAllConstraintsHistory(void);
    };

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

class CSynchronizeConstraintHistory : public CCoreElementsRecord {
    public:
        __fastcall CSynchronizeConstraintHistory(CConstraint *p_con);

    private:
    CProject*    Project;
    int          ConstraintIndex;
    int          ConstraintsListIndex;
    CSmallString Name;
    CPoint       OldValue;
    CPoint       NewValue;
    
    virtual CSmallString __fastcall GetDescription(const CSmallString& format);
    virtual void __fastcall Forward(void);
    virtual void __fastcall Backward(void);
    };

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

inline int __fastcall CConstraintData::GetConstraintIndex(void) const
{
 return(ConstraintIndex);
}

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

inline double __fastcall CConstraint::GetSigma(void) const
{
 return(Sigma);
}

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

inline bool __fastcall CConstraint::IsActive(void) const
{
 return(GetStatus().Active);
}

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

inline EConstraintType __fastcall CConstraint::GetConstraintType(void) const
{
 return(Type);
}

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

inline const CPoint& __fastcall CConstraint::GetValue(void) const
{
 return(Value);
}

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

inline const CPoint& __fastcall CConstraint::GetFinalDrvValue(void) const
{
 return(FinalDrvValue);
}

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

inline CAtom* __fastcall CConstraint::GetAtom(int index) const
{
 if( (index < 0) || (index > 3) ) return(NULL);
 return(A[index]);
}

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

inline const CPositionLock& __fastcall CConstraint::GetLock(void) const
{
 return(Lock);
}

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

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

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

inline bool  __fastcall CConstraint::IsHarmonic(void) const
{
 return(Harmonic);
}

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

inline CConstraintsList* __fastcall CConstraint::GetBaseList(void)
{
 return(BaseList);
}

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

inline CJob* __fastcall CConstraint::GetJob(void)
{
 return(BaseList->Job);
}

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

inline bool __fastcall CConstraint::IsInDrivingMode(void) const
{
 return(DrivingMode);
}

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

inline bool __fastcall CConstraintsList::IsLocked(void)
{
 return(Locked);
}

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

#endif

---