Window.h

Go to the documentation of this file.

/*
===========================================================================

Doom 3 GPL Source Code
Copyright (C) 1999-2011 id Software LLC, a ZeniMax Media company. 

This file is part of the Doom 3 GPL Source Code (?Doom 3 Source Code?).  

Doom 3 Source Code 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 3 of the License, or
(at your option) any later version.

Doom 3 Source Code 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 Doom 3 Source Code.  If not, see <http://www.gnu.org/licenses/>.

In addition, the Doom 3 Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 Source Code.  If not, please request a copy in writing from id Software at the address below.

If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.

===========================================================================
*/

#ifndef __WINDOW_H__
#define __WINDOW_H__

#include "Rectangle.h"
#include "DeviceContext.h"
#include "RegExp.h"
#include "Winvar.h"
#include "GuiScript.h"
#include "SimpleWindow.h"

const int WIN_CHILD                     = 0x00000001;
const int WIN_CAPTION           = 0x00000002;
const int WIN_BORDER            = 0x00000004;
const int WIN_SIZABLE           = 0x00000008;
const int WIN_MOVABLE           = 0x00000010;
const int WIN_FOCUS                     = 0x00000020;
const int WIN_CAPTURE           = 0x00000040;
const int WIN_HCENTER           = 0x00000080;
const int WIN_VCENTER           = 0x00000100;
const int WIN_MODAL                     = 0x00000200;
const int WIN_INTRANSITION      = 0x00000400;
const int WIN_CANFOCUS          = 0x00000800;
const int WIN_SELECTED          = 0x00001000;
const int WIN_TRANSFORM         = 0x00002000;
const int WIN_HOLDCAPTURE       = 0x00004000;
const int WIN_NOWRAP            = 0x00008000;
const int WIN_NOCLIP            = 0x00010000;
const int WIN_INVERTRECT        = 0x00020000;
const int WIN_NATURALMAT        = 0x00040000;
const int WIN_NOCURSOR          = 0x00080000;
const int WIN_MENUGUI           = 0x00100000;
const int WIN_ACTIVE            = 0x00200000;
const int WIN_SHOWCOORDS        = 0x00400000;
const int WIN_SHOWTIME          = 0x00800000;
const int WIN_WANTENTER         = 0x01000000;

const int WIN_DESKTOP           = 0x10000000;

const char CAPTION_HEIGHT[] = "16.0";
const char SCROLLER_SIZE[] = "16.0";
const int SCROLLBAR_SIZE = 16;

const int MAX_WINDOW_NAME = 32;
const int MAX_LIST_ITEMS = 1024;

const char DEFAULT_BACKCOLOR[] = "1 1 1 1";
const char DEFAULT_FORECOLOR[] = "0 0 0 1";
const char DEFAULT_BORDERCOLOR[] = "0 0 0 1";
const char DEFAULT_TEXTSCALE[] = "0.4";

typedef enum {
        WOP_TYPE_ADD,
        WOP_TYPE_SUBTRACT,
        WOP_TYPE_MULTIPLY,
        WOP_TYPE_DIVIDE,
        WOP_TYPE_MOD,
        WOP_TYPE_TABLE,
        WOP_TYPE_GT,
        WOP_TYPE_GE,
        WOP_TYPE_LT,
        WOP_TYPE_LE,
        WOP_TYPE_EQ,
        WOP_TYPE_NE,
        WOP_TYPE_AND,
        WOP_TYPE_OR,
        WOP_TYPE_VAR,
        WOP_TYPE_VARS,
        WOP_TYPE_VARF,
        WOP_TYPE_VARI,
        WOP_TYPE_VARB,
        WOP_TYPE_COND
} wexpOpType_t;

typedef enum {
        WEXP_REG_TIME,
        WEXP_REG_NUM_PREDEFINED
} wexpRegister_t;

typedef struct {
        wexpOpType_t opType;    
        int     a, b, c, d;
} wexpOp_t;

struct idRegEntry {
        const char *name;
        idRegister::REGTYPE type;
        int index;
};

class rvGEWindowWrapper;
class idWindow;

struct idTimeLineEvent {
        idTimeLineEvent() {
                event = new idGuiScriptList;
        }
        ~idTimeLineEvent() {
                delete event;
        }
        int time;
        idGuiScriptList *event;
        bool pending;
        size_t Size() {
                return sizeof(*this) + event->Size();
        }
};

class rvNamedEvent
{
public:

        rvNamedEvent(const char* name)
        {
                mEvent = new idGuiScriptList;
                mName  = name;
        }
        ~rvNamedEvent(void)
        {
                delete mEvent;
        }
        size_t Size() 
        {
                return sizeof(*this) + mEvent->Size();
        }
        
        idStr                           mName;
        idGuiScriptList*        mEvent;
};

struct idTransitionData {
        idWinVar *data;
        int     offset;
        idInterpolateAccelDecelLinear<idVec4> interp;
};


class idUserInterfaceLocal;
class idWindow {
public:
        idWindow(idUserInterfaceLocal *gui);
        idWindow(idDeviceContext *d, idUserInterfaceLocal *gui);
        virtual ~idWindow();

        enum {
                ON_MOUSEENTER = 0,
                ON_MOUSEEXIT,
                ON_ACTION,
                ON_ACTIVATE,
                ON_DEACTIVATE,
                ON_ESC,
                ON_FRAME,
                ON_TRIGGER,
                ON_ACTIONRELEASE,
                ON_ENTER,
                ON_ENTERRELEASE,
                SCRIPT_COUNT
        };

        enum {
                ADJUST_MOVE = 0,
                ADJUST_TOP,
                ADJUST_RIGHT,
                ADJUST_BOTTOM,
                ADJUST_LEFT,
                ADJUST_TOPLEFT,
                ADJUST_BOTTOMRIGHT,
                ADJUST_TOPRIGHT,
                ADJUST_BOTTOMLEFT
        };

        static const char *ScriptNames[SCRIPT_COUNT];

        static const idRegEntry RegisterVars[];
        static const int                NumRegisterVars;

        void SetDC(idDeviceContext *d);

        idDeviceContext*        GetDC ( void ) { return dc; }

        idWindow *SetFocus(idWindow *w, bool scripts = true);

        idWindow *SetCapture(idWindow *w);
        void SetParent(idWindow *w);
        void SetFlag(unsigned int f);
        void ClearFlag(unsigned int f);
        unsigned GetFlags() {return flags;};
        void Move(float x, float y);
        void BringToTop(idWindow *w);
        void Adjust(float xd, float yd);
        void SetAdjustMode(idWindow *child);
        void Size(float x, float y, float w, float h);
        void SetupFromState();
        void SetupBackground();
        drawWin_t *FindChildByName(const char *name);
        idSimpleWindow *FindSimpleWinByName(const char *_name);
        idWindow *GetParent() { return parent; }
        idUserInterfaceLocal *GetGui() {return gui;};
        bool Contains(float x, float y);
        size_t Size();
        virtual size_t Allocated();
        idStr* GetStrPtrByName(const char *_name);

        virtual idWinVar *GetWinVarByName       (const char *_name, bool winLookup = false, drawWin_t** owner = NULL);

        int  GetWinVarOffset( idWinVar *wv, drawWin_t *dw );
        float GetMaxCharHeight();
        float GetMaxCharWidth();
        void SetFont();
        void SetInitialState(const char *_name);
        void AddChild(idWindow *win);
        void DebugDraw(int time, float x, float y);
        void CalcClientRect(float xofs, float yofs);
        void CommonInit();
        void CleanUp();
        void DrawBorderAndCaption(const idRectangle &drawRect);
        void DrawCaption(int time, float x, float y);
        void SetupTransforms(float x, float y);
        bool Contains(const idRectangle &sr, float x, float y);
        const char *GetName() { return name; };

        virtual bool Parse(idParser *src, bool rebuild = true);
        virtual const char *HandleEvent(const sysEvent_t *event, bool *updateVisuals);
        void    CalcRects(float x, float y);
        virtual void Redraw(float x, float y);

        virtual void ArchiveToDictionary(idDict *dict, bool useNames = true);
        virtual void InitFromDictionary(idDict *dict, bool byName = true);
        virtual void PostParse();
        virtual void Activate( bool activate, idStr &act );
        virtual void Trigger();
        virtual void GainFocus();
        virtual void LoseFocus();
        virtual void GainCapture();
        virtual void LoseCapture();
        virtual void Sized();
        virtual void Moved();
        virtual void Draw(int time, float x, float y);
        virtual void MouseExit();
        virtual void MouseEnter();
        virtual void DrawBackground(const idRectangle &drawRect);
        virtual const char *RouteMouseCoords(float xd, float yd);
        virtual void SetBuddy(idWindow *buddy) {};
        virtual void HandleBuddyUpdate(idWindow *buddy) {};
        virtual void StateChanged( bool redraw );
        virtual void ReadFromDemoFile( class idDemoFile *f, bool rebuild = true );
        virtual void WriteToDemoFile( class idDemoFile *f );

        // SaveGame support
        void                    WriteSaveGameString( const char *string, idFile *savefile );
        void                    WriteSaveGameTransition( idTransitionData &trans, idFile *savefile );
        virtual void    WriteToSaveGame( idFile *savefile );
        void                    ReadSaveGameString( idStr &string, idFile *savefile );
        void                    ReadSaveGameTransition( idTransitionData & trans, idFile *savefile );
        virtual void    ReadFromSaveGame( idFile *savefile );
        void                    FixupTransitions();
        virtual void HasAction(){};
        virtual void HasScripts(){};

        void FixupParms();
        void GetScriptString(const char *name, idStr &out);
        void SetScriptParams();
        bool HasOps() { return (ops.Num() > 0); };
        float EvalRegs(int test = -1, bool force = false);
        void StartTransition();
        void AddTransition(idWinVar *dest, idVec4 from, idVec4 to, int time, float accelTime, float decelTime);
        void ResetTime(int time);
        void ResetCinematics();

        int NumTransitions();

        bool ParseScript(idParser *src, idGuiScriptList &list, int *timeParm = NULL, bool allowIf = false);
        bool RunScript(int n);
        bool RunScriptList(idGuiScriptList *src);
        void SetRegs(const char *key, const char *val);
        int ParseExpression( idParser *src, idWinVar *var = NULL, int component = 0 );
        int ExpressionConstant(float f);
        idRegisterList *RegList() { return &regList; }
        void AddCommand(const char *cmd);
        void AddUpdateVar(idWinVar *var);
        bool Interactive();
        bool ContainsStateVars();
        void SetChildWinVarVal(const char *name, const char *var, const char *val);
        idWindow *GetFocusedChild();
        idWindow *GetCaptureChild();
        const char *GetComment() { return comment;  }
        void SetComment( const char * p) { comment = p; }

        idStr cmd;

        virtual void RunNamedEvent              ( const char* eventName );

        void            AddDefinedVar           ( idWinVar* var );

        idWindow*       FindChildByPoint        ( float x, float y, idWindow* below = NULL );
        int                     GetChildIndex           ( idWindow* window );
        int                     GetChildCount           ( void );
        idWindow*       GetChild                        ( int index );
        void            RemoveChild                     ( idWindow *win );
        bool            InsertChild                     ( idWindow *win, idWindow* before );

        void            ScreenToClient          ( idRectangle* rect );
        void            ClientToScreen          ( idRectangle* rect );

        bool            UpdateFromDictionary ( idDict& dict );

protected:

        friend          class rvGEWindowWrapper;

        idWindow*       FindChildByPoint        ( float x, float y, idWindow** below );
        void            SetDefaults                     ( void );

        friend class idSimpleWindow;
        friend class idUserInterfaceLocal;
        bool IsSimple();
        void UpdateWinVars();
        void DisableRegister(const char *_name);
        void Transition();
        void Time();
        bool RunTimeEvents(int time);
        void Dump();

        int ExpressionTemporary();
        wexpOp_t *ExpressionOp();
        int EmitOp( int a, int b, wexpOpType_t opType, wexpOp_t **opp = NULL );
        int ParseEmitOp( idParser *src, int a, wexpOpType_t opType, int priority, wexpOp_t **opp = NULL );
        int ParseTerm( idParser *src, idWinVar *var = NULL, int component = 0 );
        int ParseExpressionPriority( idParser *src, int priority, idWinVar *var = NULL, int component = 0 );
        void EvaluateRegisters(float *registers);
        void SaveExpressionParseState();
        void RestoreExpressionParseState();
        void ParseBracedExpression(idParser *src);
        bool ParseScriptEntry(const char *name, idParser *src);
        bool ParseRegEntry(const char *name, idParser *src);
        virtual bool ParseInternalVar(const char *name, idParser *src);
        void ParseString(idParser *src, idStr &out);
        void ParseVec4(idParser *src, idVec4 &out);
        void ConvertRegEntry(const char *name, idParser *src, idStr &out, int tabs);

        float actualX;                                  // physical coords
        float actualY;                                  // ''
        int       childID;                                      // this childs id
        unsigned int flags;             // visible, focus, mouseover, cursor, border, etc.. 
        int lastTimeRun;                                //
        idRectangle drawRect;                   // overall rect
        idRectangle clientRect;                 // client area
        idVec2  origin;

        int timeLine;                                   // time stamp used for various fx
        float xOffset;                  
        float yOffset;
        float forceAspectWidth;
        float forceAspectHeight;
        float matScalex;
        float matScaley;
        float borderSize;
        float textAlignx;
        float textAligny;
        idStr   name;
        idStr   comment;
        idVec2  shear;

        signed char     textShadow;
        unsigned char fontNum;
        unsigned char cursor;                                   //
        signed char     textAlign;

        idWinBool       noTime;                                 // 
        idWinBool       visible;                                // 
        idWinBool       noEvents;
        idWinRectangle rect;                            // overall rect
        idWinVec4       backColor;
        idWinVec4       matColor;
        idWinVec4       foreColor;
        idWinVec4       hoverColor;
        idWinVec4       borderColor;
        idWinFloat      textScale;
        idWinFloat      rotate;
        idWinStr        text;
        idWinBackground backGroundName;                 // 

        idList<idWinVar*> definedVars;
        idList<idWinVar*> updateVars;

        idRectangle textRect;                   // text extented rect
        const idMaterial *background;         // background asset  

        idWindow *parent;                               // parent window
        idList<idWindow*> children;             // child windows        
        idList<drawWin_t> drawWindows;          

        idWindow *focusedChild;                 // if a child window has the focus
        idWindow *captureChild;                 // if a child window has mouse capture
        idWindow *overChild;                    // if a child window has mouse capture
        bool hover;

        idDeviceContext *dc;

        idUserInterfaceLocal *gui;

        static idCVar gui_debug;
        static idCVar gui_edit;

        idGuiScriptList *scripts[SCRIPT_COUNT];
        bool *saveTemps;

        idList<idTimeLineEvent*> timeLineEvents;
        idList<idTransitionData> transitions;

        static bool registerIsTemporary[MAX_EXPRESSION_REGISTERS]; // statics to assist during parsing

        idList<wexpOp_t> ops;                           // evaluate to make expressionRegisters
        idList<float> expressionRegisters;
        idList<wexpOp_t> *saveOps;                              // evaluate to make expressionRegisters
        idList<rvNamedEvent*>           namedEvents;            //  added named events
        idList<float> *saveRegs;

        idRegisterList regList;

        idWinBool       hideCursor;
};

ID_INLINE void idWindow::AddDefinedVar( idWinVar* var ) {
        definedVars.AddUnique( var );
}

#endif /* !__WINDOW_H__ */