GEWindowWrapper.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 GEWINDOWWRAPPER_H_
#define GEWINDOWWRAPPER_H_

class idWindow;
class rvGEWindowWrapper;

typedef bool (*PFNENUMCHILDRENPROC) ( rvGEWindowWrapper* wrapper, void* data );

class rvGEWindowWrapper
{
public:

        enum EWindowType
        {
                WT_UNKNOWN,
                WT_NORMAL,
                WT_EDIT,
                WT_HTML,
                WT_CHOICE,
                WT_SLIDER,
                WT_BIND,
                WT_LIST,
                WT_RENDER,
                WT_TRANSITION
        };

        rvGEWindowWrapper ( idWindow* window, EWindowType type );

        static rvGEWindowWrapper*       GetWrapper ( idWindow* window );        
                
        idWindow*                       GetWindow                       ( void );
        idDict&                         GetStateDict            ( void );
        idDict&                         GetVariableDict         ( void );
        idDict&                         GetScriptDict           ( void );
        idRectangle&            GetClientRect           ( void );
        idRectangle&            GetScreenRect           ( void );
        EWindowType                     GetWindowType           ( void );
        int                                     GetChildCount           ( void );
        int                                     GetDepth                        ( void );
        idWindow*                       GetChild                        ( int index );
        
        void                            SetRect                         ( idRectangle& rect );
        void                            SetState                        ( const idDict& dict );
        void                            SetStateKey                     ( const char* key, const char* value, bool update = true );
        void                            DeleteStateKey          ( const char* key );
        bool                            VerfiyStateKey          ( const char* name, const char* value, idStr* result = NULL );
        
        bool                            IsFlippedHorz           ( void );
        bool                            IsFlippedVert           ( void );
        bool                            IsHidden                        ( void );
        bool                            IsDeleted                       ( void );
        bool                            IsSelected                      ( void );
        bool                            IsExpanded                      ( void );

        bool                            CanHaveChildren         ( void );
        bool                            CanMoveAndSize          ( void );
        
        void                            SetFlippedHorz          ( bool f );
        void                            SetFlippedVert          ( bool f );
        void                            SetHidden                       ( bool v );
        void                            SetDeleted                      ( bool del );
        void                            SetSelected                     ( bool sel );
        void                            SetWindowType           ( EWindowType type );

        bool                            Expand                          ( void );
        bool                            Collapse                        ( void );

        bool                            EnumChildren            ( PFNENUMCHILDRENPROC proc, void* data );

        idWindow*                       WindowFromPoint         ( float x, float y, bool visibleOnly = true );
        
        void                            Finish                          ( void );
        
        static EWindowType      StringToWindowType              ( const char* string );
        static const char*      WindowTypeToString              ( EWindowType type );
        
protected:

        void                            CalcScreenRect          ( void );
        void                            UpdateRect                      ( void );
        void                            UpdateWindowState       ( void );       

        idRectangle             mClientRect;
        idRectangle             mScreenRect;
        idWindow*               mWindow;
        idDict                  mState;
        idDict                  mVariables;
        idDict                  mScripts;
        bool                    mFlippedHorz;
        bool                    mFlippedVert;
        bool                    mHidden;
        bool                    mDeleted;
        bool                    mSelected;
        bool                    mExpanded;
        bool                    mOldVisible;
        bool                    mMoveable;
        EWindowType             mType;
};

ID_INLINE idDict& rvGEWindowWrapper::GetStateDict ( void )
{
        return mState;
}

ID_INLINE idDict& rvGEWindowWrapper::GetVariableDict ( void )
{
        return mVariables;
}

ID_INLINE idDict& rvGEWindowWrapper::GetScriptDict ( void )
{
        return mScripts;
}

ID_INLINE bool rvGEWindowWrapper::IsFlippedHorz ( void )
{
        return mFlippedHorz;
}

ID_INLINE bool rvGEWindowWrapper::IsFlippedVert ( void ) 
{
        return mFlippedVert;
}

ID_INLINE bool rvGEWindowWrapper::IsExpanded ( void ) 
{
        return mExpanded;
}
        
ID_INLINE void rvGEWindowWrapper::SetFlippedHorz ( bool f )
{
        mFlippedHorz = f;
}

ID_INLINE void rvGEWindowWrapper::SetFlippedVert ( bool f )
{
        mFlippedVert = f;
}

ID_INLINE idRectangle& rvGEWindowWrapper::GetClientRect ( void )
{
        return mClientRect;
}

ID_INLINE idRectangle& rvGEWindowWrapper::GetScreenRect ( void )
{
        return mScreenRect;
}

ID_INLINE bool rvGEWindowWrapper::IsHidden ( void )
{
        return mHidden;
}

ID_INLINE bool rvGEWindowWrapper::IsDeleted ( void )
{
        return mDeleted;
}

ID_INLINE bool rvGEWindowWrapper::IsSelected ( void )
{
        return mSelected;
}

ID_INLINE void rvGEWindowWrapper::SetSelected ( bool sel )
{
        mSelected = sel;
}

ID_INLINE rvGEWindowWrapper::EWindowType rvGEWindowWrapper::GetWindowType ( void )
{
        return mType;
}

ID_INLINE void rvGEWindowWrapper::SetWindowType ( rvGEWindowWrapper::EWindowType type )
{
        mType = type;
}

ID_INLINE idWindow* rvGEWindowWrapper::GetChild ( int index )
{
        return mWindow->GetChild ( index );
}

ID_INLINE idWindow* rvGEWindowWrapper::GetWindow ( void )
{
        return mWindow;
}

ID_INLINE bool rvGEWindowWrapper::CanMoveAndSize ( void )
{
        return mMoveable;
}

#endif // GEWINDOWWRAPPER_H_