---

gui.h

Go to the documentation of this file.

#ifndef _GUI_H_
#define _GUI_H_

#include <TROOT.h>
#include <TApplication.h>
#include <TGLabel.h>
#include <TGFrame.h>
#include <TGMenu.h>
#include <TRootEmbeddedCanvas.h>
#include <TLatex.h>
#include <TGScrollBar.h>
#include <TGButton.h>
#include <TGDoubleSlider.h>
#include <TGTextEntry.h>
#include <TGTextBuffer.h>
#include <TGNumberEntry.h>
#include <TGComboBox.h>
#include <TG3DLine.h>
#include <TGTab.h>
#include <TGListView.h>
#include <TGMsgBox.h>
#include <TGFileDialog.h>
#include <TGSplitter.h>
#include <TObjectTable.h>
#include <TSystem.h>
#include <RQ_OBJECT.h>

#include <time.h>
#include "enum.h"
#include "lattice.h"
#include "configuration.h"
#include "formula.h"

class LVPicture : public TGPicture
{
    public:
        LVPicture();
        virtual ~LVPicture();
};


class TGNumEntry : public TGTextEntry
{
    public:
        TGNumEntry(const TGWindow* p, const char* t, Int_t id = -1)
            : TGTextEntry(p, t, id) {}
        TGNumEntry(const TGWindow* p, Double_t f, Int_t id = -1);
        TGNumEntry(const TGWindow* p, TGTextBuffer* t, Int_t id = -1)
            : TGTextEntry(p, t, id) {}
        virtual void Insert(const char*);
        Double_t GetDoubleNum() { return atof(GetText()); }
        Int_t GetIntNum() { return atoi(GetText()); }
};

class TGFuncNameEntry : public TGTextEntry
{
    public:
        TGFuncNameEntry(const TGWindow* p, const char* t, Int_t id = -1)
            : TGTextEntry(p, t, id) {}
        
        virtual void Insert(const char*);
};

class TGToggleButton : public TGTextButton
{
    public:
        TGToggleButton(const TGWindow* p, const char* s, Int_t id = -1, GContext_t norm = GetDefaultGC()(), FontStruct_t font = GetDefaultFontStruct(), UInt_t option = kRaisedFrame|kDoubleBorder)
            : TGTextButton(p, s, id, norm, font, option) {}
        
        virtual void SetState(EButtonState);
};

class ScrollView : public TGCanvas
{
    public:
        ScrollView(const TGWindow* p, UInt_t w, UInt_t h, UInt_t options = kSunkenFrame|kDoubleBorder, ULong_t back = fgDefaultFrameBackground)
            : TGCanvas(p, w, h, options, back) {}
    
        virtual void Layout() {
            UInt_t cw, ch;
            Bool_t fixedw;
            TGFrame *container;
            
            TGCanvas::Layout();
            
            container = fVport->GetContainer();
            if (!container) {
                Error("Layout", "no canvas container set yet");
                return;
            }

            cw = fWidth  - (fBorderWidth << 1);
            ch = fHeight - (fBorderWidth << 1);
            
            if (container->GetDefaultHeight() > ch) {
                if (fScrolling & kCanvasScrollVertical) {
                    cw -= fVScrollbar->GetDefaultWidth();
                    if ((Int_t) cw < 0) {
                        cw = 10;
                    }
                }
            }
            
            fixedw = (container->GetOptions() & kFixedWidth) ? kTRUE : kFALSE;
            if (!fixedw) {
                container->SetWidth(cw);
                container->Layout();
            }
        }
};

class TempControl;

class MainFrame : public TGMainFrame
{
    public:
        friend class TempControl;
    
        MainFrame(const TGWindow*, UInt_t, UInt_t);
        virtual ~MainFrame();
        
        void CloseWindow();
        void HandleMenu(Int_t);
        void DoButtons(Int_t wid = -1, Int_t id = -1);
        void DoTempText(const char*);
        
        void SetInfoAtoms(Int_t);
        void SetInfoDefects(Int_t);
        void SetInfoEnergy(Double_t);
        void SetInfoMoves(Int_t);
        void SetInfoImages(Int_t);
        void SetInfoStatus();
        
        Bool_t IsInfoEnabled() { return pMenuView->IsEntryChecked(M_VIEW_INFO); }
        
        Layer* GetLayer() { return pLayer; }
            
    private:
        void FillParamCont(TGCompositeFrame*);
        void ClearEnFuncCombo(TGComboBox*);
        void FillEnFuncCombo(TGComboBox*);
    
        TList *pCleanup;
        TList *pParamElems, *pParamVals;
        TGVSplitter *pSplitter;
        TGCompositeFrame *pMainCont, *pControlFrame;
        TGCompositeFrame *pSplitFrame, *pParamCont;
        TGCompositeFrame *pSimToolFr, *pSimBtFr;
        TGCompositeFrame *pSimTmpFr, *pSimLaunchBtFr;
        TGCompositeFrame *pInfoFr, *pFr;
        TGDoubleVSlider *pSimTmpSlider;
        TGNumEntry *pSimTmpEntry;
        TGTextBuffer *pSimTmpEBuf;
        TGLabel *pFuncL, *pLabel;
        TGLabel *pNumAtomL, *pNumDefL, *pEnergyL;
        TGLabel *pMovesL, *pImgL, *pStatusL;
        TGComboBox *pFuncCombo;
        ScrollView *pParamSV;
        TGGroupFrame *pParamGrFr, *pSimGrFr;
        TGToggleButton *pSimStartBt, *pSimStopBt;
        TGTextButton *pSimInsBt, *pSimRemBt, *pSimTempRangeBt;
        TGTextButton *pSimRemAllBt, *pSimUpdBt;
        TGTextButton *pParamSetBt, *pSimEnBt, *pSimOptsBt;
        TGHorizontal3DLine *pSimSep;
        TGLayoutHints *pL, *pL2;
        TGMenuBar* pMenuBar;
        TGPopupMenu *pMenuProg, *pMenuSim, *pMenuOpts;
        TGPopupMenu *pMenuView, *pMenuPlot;
        TGLayoutHints *pMenuBarLayout;
        TGLayoutHints *pMenuBarItemLayout;
        time_t simStartTime;
        
        TRootEmbeddedCanvas* pRECanvas;
        TEFormula* pEFormula;
        TEF1* pEPlot1;
        TEF2* pEPlot2;
        Layer* pLayer;
        Configuration* pConfig;
        TempControl* pTempControl;
};

class ParamFrame : public TGCompositeFrame
{
    public:
        ParamFrame(TGCompositeFrame* fr, const char* id, const char* name, Double_t value, const char* descr);
        virtual ~ParamFrame();
        
        void SetId(Int_t id);
    
        TGCheckButton *pChk;
        TGTextEntry *pName, *pDescr;
        TGNumEntry *pValue;
    
    protected:
        TGLayoutHints *pL1, *pL2, *pL3;
        TGCompositeFrame *pFr;
};


    
class ConfigDialog
{
    RQ_OBJECT("ConfigDialog");
    
    public:
        ConfigDialog(Configuration*, const TGWindow*, const TGWindow*, UInt_t, UInt_t, UInt_t = kVerticalFrame);
        virtual ~ConfigDialog();
        
        void CloseWindow();
        void DoOk();
        void DoCancel();
        Int_t DoSave();
        void DoTab(Int_t);
        void DoTabButtons(Int_t wid = -1, Int_t id = -1);
        static char* ParseExpression(Configuration*, const char*);
        
        friend class AddFuncDlg;
        friend class RenFuncDlg;
        
    private:
        void LoadParameters();
        void LoadFunctions(Int_t = -1);
        void RemoveFunctions();
        Int_t VerifyFunction(Int_t, Bool_t = kTRUE, Bool_t = kTRUE);
    
        TGTransientFrame* pMain;
        TGHorizontalFrame *pFr1;
        TGTextButton *pOkButton, *pCancelButton, *pSaveButton;
        TGTab *pTab;
        TGCompositeFrame *pTabFrame;
        TGLayoutHints *pL, *pL1, *pL2, *pL3, *pL4;
        TList *pCleanup;
        TEFormula *pEFormula;
        
        //--- Energy-Tab -----------------
        Int_t curFuncId;
        TGCompositeFrame *pEnergyFr, *pParVarFr, *pFr;
        TGGroupFrame *pParListGrFr, *pVarGrFr, *pEnGrFr;
        TGLabel *pLabel;
        TGLabel *pXLabel, *pYLabel, *pZLabel;
        TGComboBox *pEnFunCombo;
        TGListView *pParLV;
        TGLVContainer *pParLVCont;
        TGHorizontal3DLine *pEnLine;
        TGTextEntry *pEnFunExp, *pEnFunLat;
        TGTextEntry *pXEntry, *pYEntry, *pZEntry;
        const LVPicture *pPic;
        TRootEmbeddedCanvas* pLatexCanv;
        TLatex *pLatexExpr;
        TGCompositeFrame *pLatexFr, *pLatexBtFr;
        TGCompositeFrame *pEnFunBtFr, *pEnBtFr;
        TGTextButton *pEnFunBtVer, *pEnFunBtRen;
        TGTextButton *pEnBtAdd, *pEnBtDel, *pEnBtRev;
        TGTextButton *pLatMBt, *pLatPBt;
                
        //--- Parameter-Tab ------------------
        TGTextButton *pParamBtAdd, *pParamBtDel, *pParamBtRev;
        ParamFrame *pPFr;
        TGLabel *pParHeadL1, *pParHeadL2, *pParHeadL3;
        TGGroupFrame *pParGrFr;
        TGCompositeFrame *pParHeadFr;
        TGCompositeFrame *pParamFr, *pParLineFr;
        TGCompositeFrame *pParamBtFr;
        ScrollView *pParSV;
        TGCheckButton *pChkBox;
        TList *pParamLFr;
        
        
        Configuration* pConfig;
};


class SimulationDialog
{
    RQ_OBJECT("SimulationDialog");
    
    public:
        SimulationDialog(Configuration*, Lattice*, const TGWindow*, const TGWindow*, UInt_t, UInt_t, UInt_t = kVerticalFrame);
        virtual ~SimulationDialog();
        
        void CloseWindow();
        void DoOk();
        void DoCancel();
        void DoTabButtons(Int_t wid = -1);
            
    private:
        TGTransientFrame* pMain;
        TGTextButton *pOkButton, *pCancelButton, *pTryButton;
        TGTab *pTab;
        TGCompositeFrame *pTabFrame, *pBtFrame;
        TGCompositeFrame *pLatticeFr, *pFr;
        TGCompositeFrame *pMCFr, *pImgFr;
        TGGroupFrame *pAlgFr, *pGraphFr;
        TGGroupFrame *pAtomFr, *pDefectFr;
        TGGroupFrame *pInsRemFr;
        TGLabel *pBoltzmL, *pIntLimL, *pIntLimL2;
        TGLabel *pAShapeL, *pASizeL, *pAColorL;
        TGLabel *pDShapeL, *pDSizeL, *pDColorL;
        TGLabel *pUpdateL, *pUpdateL2;
        TGLabel *pImgFormatL, *pImgPathL, *pImgPrefixL;
        TGLabel *pAutoSaveL, *pAutoSaveL2;
        TGLabel *pInsL, *pInsL2, *pRemL, *pRemL2;
        TGCheckButton *pUpdateChBt, *pAutoSaveChBt;
        TGComboBox *pAShapeC, *pAColorC;
        TGComboBox *pDShapeC, *pDColorC;
        TGComboBox *pImgFormatC;
        TGTextEntry *pImgPathE, *pImgPrefixE;
        TGNumEntry *pBoltzmE, *pIntLimE;
        TGNumberEntry *pASizeE, *pDSizeE, *pUpdateNum;
        TGNumberEntry *pAutoSaveNum, *pInsE, *pRemE;
        TGLayoutHints *pL, *pL1, *pL2, *pL3, *pL4;
        TList *pCleanup;
        
        Configuration *pConfig;
        Lattice *pLattice;
};
    

class AddFuncDlg
{
    RQ_OBJECT("AddFuncDlg");
    
    public:
        AddFuncDlg(ConfigDialog*, const TGWindow*, const TGWindow*, UInt_t, UInt_t, UInt_t = kVerticalFrame);
        virtual ~AddFuncDlg();
        
        void DoButtons(Int_t = -1, Int_t = -1);
        void CloseWindow();
        
    private:
        ConfigDialog *confDlg;
        TGTransientFrame* pMain;
        TGTextButton *pOkButton, *pCancelButton;
        TGCompositeFrame *pDlgFrame, *pBtFrame;
        TGLabel *pNameL;
        TGFuncNameEntry *pNameT;
        TGRadioButton *pEmptyRad, *pCloneRad;
        TGComboBox *pFuncList;
        TGGroupFrame *pGrpFrame;
        TGLayoutHints *pL;
        TList *pCleanup;
};

class RenFuncDlg
{
    RQ_OBJECT("RenFuncDlg");
    
    public:
        RenFuncDlg(ConfigDialog*, const TGWindow*, const TGWindow*, UInt_t, UInt_t, UInt_t = kVerticalFrame);
        virtual ~RenFuncDlg();
        
        void DoButtons(Int_t = -1);
        void CloseWindow();
    
    private:
        ConfigDialog *confDlg;
        char *strLabel;
        Int_t id;
        TGTransientFrame* pMain;
        TGTextButton *pOkButton, *pCancelButton;
        TGCompositeFrame *pDlgFrame, *pBtFrame;
        TGLabel *pNameL;
        TGFuncNameEntry *pNameT;
        TGLayoutHints *pL;
        TList *pCleanup;
};

class SliderRangeDlg
{
    RQ_OBJECT("SliderRangeDlg");
    
    public:
        SliderRangeDlg(TGDoubleSlider*, Configuration*, const TGWindow*, const TGWindow*, UInt_t, UInt_t, UInt_t = kVerticalFrame);
        virtual ~SliderRangeDlg();
        
        void DoButtons(Int_t = -1);
        void CloseWindow();
    
    private:
        Configuration *pConfig;
        TGDoubleSlider *slider;
        TGTransientFrame* pMain;
        TGLabel *pLabel;
        TGCompositeFrame *pDlgFrame;
        TGCompositeFrame *pRangeFr, *pBtFrame;
        TGNumEntry *pFromEntry, *pToEntry;
        TGTextButton *pOkButton, *pCancelButton;
        TGLayoutHints *pL;
        TList *pCleanup;
};

class TempControl
{
    RQ_OBJECT("TempControl");
    
    public:
        TempControl(Configuration*, MainFrame*, const TGWindow*, const TGWindow*, UInt_t, UInt_t, UInt_t = kVerticalFrame);
        virtual ~TempControl();
        
        void DoMinRange(char*);
        void DoMaxRange(char*);
        void CloseWindow();
        void DoSlider();
    
    private:
        Configuration *pConfig;
        MainFrame *pMainFrame;
        TGTransientFrame* pMain;
        TGLabel *pTempL;
        TGCompositeFrame *pDlgFrame, *pRangeFrame;
        TGDoubleHSlider *pTempSlider;
        TGNumEntry *pFromEntry, *pToEntry;
        TGLayoutHints *pL1, *pL2;
};

class LatticeDlg
{
    RQ_OBJECT("LatticeDlg");
    
    public:
        LatticeDlg(Layer*, const TGWindow*, const TGWindow*, UInt_t, UInt_t, UInt_t = kVerticalFrame);
        virtual ~LatticeDlg();
        
        void DoButtons(Int_t = -1);
        void CloseWindow();
        
    private:
        Layer *pLayer;
        TGTransientFrame* pMain;
        TGTextButton *pOkButton, *pCancelButton;
        TGCompositeFrame *pDlgFrame, *pBtFrame;
        TGLabel *pLatticeL, *pNumXL, *pNumYL, *pNumSizeL;
        TGComboBox *pLatticeCombo;
        TGNumEntry *pNumXE, *pNumYE, *pNumSizeE;
        TGLayoutHints *pL;
        TList *pCleanup;
};


#endif // _GUI_H_

---