cXWindow.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cXWindow_H
#define _INC_cXWindow_H
#pragma once
 
#include "../GrayGUI.h"
#include "../Style/cXSpriteMap.h"
 
#include "Gray3D/include/DX/cDXFont.h"
#include "Gray3D/include/DX/cDXSprite.h"
#include "Gray3D/include/Texture/cXTextureMgr.h"
 
#include "GrayLib/include/WinAPI/cResDialog.h"
#include "GrayLib/include/XObject/cXObjDef.h"
#include "GrayLib/include/Input/cInputBase.h"   // MBUTTON_TYPE
#include "GrayCore/include/cOSProcess.h"
 
namespace GrayGUI
{
        // Extended class types here:
        const SHOWWINDOW_t SW_TOGGLE = SW_MAX;  // SHOWWINDOW_t
 
        const DLGID_t k_DLGID_Static = 0xFFFFFFFF;      // IDC_STATIC = (DLGID_t)(-1);
        const DLGID_t k_DLGID_User = 0x00010000;        // start local user control id's here.
        const DLGID_t k_DLGID_ANY = 0xFFFFFFFF;         // Any match.
 
        enum XSTYLE_ELEM_TYPE;
 
        enum X_WNDCLASS_TYPE
        {
                X_WNDCLASS_INVALID = -1,
#define cXWindowClassDef(a,b,c,d)       X_##a##_##b,    // = FOURCC ?
#include "cXWindowClasses.tbl"
#undef cXWindowClassDef
                X_WNDCLASS_QTY, // May be extended by user.
        };
 
        typedef DWORD WINFLAG_MASK;
        enum WINFLAG_TYPE_
        {
                WINFLAG_RESTORETOMAXIMIZED = 0x00000002,        
 
                WINFLAG_TAB_HIDDEN = 0x00000010,                
                WINFLAG_SHOWWINDOW_CALLED = 0x00000020, 
                WINFLAG_TOPMOST = 0x00000040,                   
                WINFLAG_MODAL = 0x00000080,
                WINFLAG_TOOLTIP_PARENT = 0x00000100,    
                WINFLAG_HIDETITLE = 0x00000200,                 
                WINFLAG_HIDEFRAME = 0x00000400,                 
                WINFLAG_TOOLTIP_FAST = 0x00000800,              
 
                WINFLAG_USER_RADAR_ROSE = 0x00010000,   
                WINFLAG_USER_QUICK_VERT = 0x00020000,   
                WINFLAG_USER_RADAR_FACEUP = 0x00040000,
                //WINFLAG_USER2                         = 0x00080000,
        };
 
        typedef DWORD WINDOCKFLAG_MASK;
        enum WINDOCKFLAG_TYPE_
        {
                WINDOCKFLAG_NONE = 0x0000,                      
                WINDOCKFLAG_LEFT = 0x0001,
                WINDOCKFLAG_RIGHT = 0x0002,
                WINDOCKFLAG_TOP = 0x0004,
                WINDOCKFLAG_BOTTOM = 0x0008,            
                WINDOCKFLAG_SIDES = 0x000F,                     
                WINDOCKFLAG_HCENTER = 0x0010,
                WINDOCKFLAG_VCENTER = 0x0020,
                WINDOCKFLAG_MAXSIZE = 0x0100,                   
                WINDOCKFLAG_HEADINPARENT = 0x0200,      
                WINDOCKFLAG_ALLINPARENT = 0x0400,       
                WINDOCKFLAG_OFF_MASK = 0x0600,          
                WINDOCKFLAG_OFF = 0x1000,                       
        };
 
        class cXDesktopMgr;
        class cXMenu;
        class cXWindow;
        typedef cRefPtr<cXWindow> cXWindowPtr;
        class cXDialog;
        typedef cRefPtr<cXDialog> cXDialogPtr;
 
        class cXWindow : public cXObject, public IInputWnd, public cDXBase
        {
 
                friend class cXDesktopMgr;
                friend class cXDialog;
                typedef cXObject SUPER_t;
 
        public:
                cXWindow(X_WNDCLASS_TYPE eXWClass, cXWindow* pParent, DLGID_t dlgid = k_DLGID_Static, UID_t uid = cUID::k_CLEAR);
                virtual ~cXWindow();
 
                virtual HRESULT DisposeThis();  // detach my children etc.
                virtual bool InitXWindow();
 
                STDMETHOD_(XOBJTID_t, get_XObjTypeId)() const
                {
                        return cFourCC('U', 'I', 'W', 'i'); // RESC_UIWindow;
                }
 
                static const ATOMCHAR_t* GetXWTypeName(X_WNDCLASS_TYPE eXWClass);
                X_WNDCLASS_TYPE get_XWType() const
                {
                        return m_eXWClass;
                }
                const ATOMCHAR_t* get_XWTypeName() const
                {
                        return GetXWTypeName(m_eXWClass);
                }
                STDMETHOD_(cString, get_Name)() const override
                {
                        return get_Text();
                        // return get_XWTypeName();
                }
                virtual cXObjectPtr get_ContainerObject() const override
                {
                        return m_pParentWnd.get_Ptr();
                }
                cXDialogPtr get_DialogParent() const;
 
                //*****************************
                // Scripting
                STDMETHOD(s_PropGet)(const cScriptableProp* pProp, cVariant& vValRet) override;
                STDMETHOD(s_PropPut)(const cScriptableProp* pProp, const cVariant& vVal) override;
                STDMETHOD(s_Invoke)(const cScriptableMethod* pMethod, const cVariant& vArgs, cVariant& vValRet) override;
 
                CSCRIPT_CLASS_DEF1(XWindow, cXObject);
                enum P_TYPE_
                {
#define cXWindowProp(a,b,c,d,e) P_##a,
#include "cXWindowProps.tbl"
#undef cXWindowProp
                        P_QTY,
                };
                void s_Update(P_TYPE_ eProp);
                static cScriptableProp sm_Props[P_QTY + 1];
                enum M_TYPE_
                {
#define cXWindowMethod(a,b,c) M_##a,
#include "cXWindowMethods.tbl"
#undef cXWindowMethod
                        M_QTY,
                };
                static cScriptableMethod sm_Methods[M_QTY + 1];
 
                //*****************************
                // Show state
                virtual void ShowWindow(SHOWWINDOW_t nCmdShow = SW_SHOW);
                void ShowWindowBool(bool bShow);
                bool IsWindowVisible(void) const noexcept
                {
                        return (m_dwStyle & WS_VISIBLE) != 0;
                }
                bool IsWindowEnabled(void) const noexcept
                {
                        return (m_dwStyle & WS_DISABLED) == 0;
                }
                void EnableWindow(bool bClickable)
                {
                        if (bClickable)
                                m_dwStyle &= ~WS_DISABLED;
                        else
                                m_dwStyle |= WS_DISABLED;
                }
                bool IsZoomed(void) const noexcept
                {
                        if (IsIconic())
                                return false;
                        return(m_dwStyle & WS_MAXIMIZE) != 0;
                }
                bool IsIconic(void) const noexcept
                {
                        return(m_dwStyle & WS_MINIMIZE) != 0;
                }
                bool IsWindowOpen() const noexcept
                {
                        return IsWindowVisible() && !IsIconic();
                }
 
                bool IsStyle(DWORD dwStyle) const noexcept
                {
                        return (m_dwStyle & dwStyle) != 0;
                }
                DWORD get_Style(void) const noexcept
                {
                        return m_dwStyle;
                }
                virtual void put_Style(DWORD dwStyle)
                {
                        m_dwStyle = dwStyle;
                }
                void ModifyStyle(DWORD dwStyleAdd, DWORD dwStyleRem = 0)
                {
                        put_Style((get_Style() & ~dwStyleRem) | dwStyleAdd);
                }
                void ModifyStyleBool(DWORD dwStyleMod, bool bFlag)
                {
                        DWORD dwStyle = get_Style();
                        if (bFlag)
                                dwStyle |= dwStyleMod;
                        else
                                dwStyle &= ~dwStyleMod;
                        put_Style(dwStyle);
                }
 
                bool IsExStyle(DWORD dwStyle) const noexcept
                {
                        return((m_dwExStyle & dwStyle) != 0);
                }
                void put_ExStyle(DWORD dwStyle)
                {
                        m_dwExStyle = dwStyle;
                }
 
                WINFLAG_MASK get_Flags(void) const noexcept
                {
                        return m_uWinFlags;
                }
                void put_Flags(WINFLAG_MASK uiFlags)
                {
                        m_uWinFlags = uiFlags;
                }
                bool HasFlags(WINFLAG_MASK uiFlags) const noexcept
                {
                        return (m_uWinFlags & uiFlags) != 0;
                }
                virtual void ModifyFlags(WINFLAG_MASK uiFlagsAdd, WINFLAG_MASK uiFlagsRem = 0)
                {
                        m_uWinFlags &= ~uiFlagsRem;
                        m_uWinFlags |= uiFlagsAdd;
                }
 
                WINDOCKFLAG_MASK get_DockFlags(void) const noexcept
                {
                        return m_uDockFlags;
                }
                void put_DockFlags(WINDOCKFLAG_MASK dock)
                {
                        m_uDockFlags = dock;
                }
                bool ConstrainDocking(void);
 
                DLGID_t get_DlgID(void) const noexcept
                {
                        return m_DlgItemId;
                }
                void put_DlgID(DLGID_t id)
                {
                        m_DlgItemId = id;
                }
                DLGID_t get_HelpID() const;
 
                cDXSpriteElem& get_TextureDC(void)
                {
                        return m_TexElem;
                }
 
                //**********************************************
                // Position rectangle and z order
 
                PIXELS_t get_XPos(void) const noexcept
                {
                        // Get my left coord in my parent coords.
                        return m_WindowRect.left;
                }
                PIXELS_t get_YPos(void) const noexcept
                {
                        // Get my left coord in my parent coords.
                        return m_WindowRect.top;
                }
 
                PIXELS_t get_Width(void) const noexcept
                {
                        return m_WindowRect.Width();
                }
                PIXELS_t get_Height(void) const noexcept
                {
                        return m_WindowRect.Height();
                }
 
                void MoveWindow(PIXELS_t xParent, PIXELS_t yParent, PIXELS_t width, PIXELS_t height);
                void MoveWindow(const cRectI& rect);
 
                const cRectI& get_WindowRect(void) const noexcept
                {
                        // Get the window rectangle in my parents coords.
                        return m_WindowRect;
                }
                void CvtWindowToApp(cPoint2i* pPoint) const;
                void CvtWindowToApp(cPoint2i* pPoint, PIXELS_t x, PIXELS_t y) const;
                void CvtAppToWindow(cPoint2i* pPoint) const;
                void CvtAppToWindow(cPoint2i* pPoint, PIXELS_t x, PIXELS_t y) const;
 
                HRESULT SetViewportWindow(cPoint2i& ptAbsolutePos);
                void SetScissorWindow(cPoint2i& ptAbsolutePos);
 
                bool IsPointIntersect(PIXELS_t x, PIXELS_t y) const;
                bool IsAppIntersect(PIXELS_t x, PIXELS_t y) const;
                bool IsCursorIntersect() const;
 
                void ScaleAll(FLOAT fScale);
 
                void MoveToFront();
                bool MoveToFront(cXWindow* pChildControl);
 
                //*****************************
                // Render
                virtual HRESULT InitDeviceObjects(cDXDevice* pDXDev);
                virtual HRESULT DeleteDeviceObjects();
                virtual HRESULT OnResetDeviceX();
                virtual HRESULT OnLostDeviceX();
                virtual void Render();  // render me and my children.
                void RenderChildren();
 
                //*****************************
                // Overridable accessors and methods
                virtual void SetWidthHeight(PIXELS_t Width, PIXELS_t Height);
                virtual void SetXYPos(PIXELS_t X, PIXELS_t Y);
                void SetXYCenter();
                void GetSizeParent(SIZE& sizeparent) const;
 
                //*****************************
                // Overridable notifications.
                virtual bool OnRender(void);    // render just me and not my children.
 
                virtual bool OnMouseDown(MBUTTON_TYPE uButton, PIXELS_t x, PIXELS_t y);
                virtual bool OnMouseWheel(MBUTTON_TYPE uButton, PIXELS_t x, PIXELS_t y, short nWheelChange);
                virtual bool OnMouseMove(MBUTTON_TYPE uButton, PIXELS_t x, PIXELS_t y);
                virtual bool OnMouseUp(MBUTTON_TYPE uButton, PIXELS_t x, PIXELS_t y);
                virtual bool OnMouseDblClk(MBUTTON_TYPE uButton, PIXELS_t x, PIXELS_t y);
 
                virtual bool OnKeyDown(VK_TYPE vKey);
                virtual bool OnKeyUp(VK_TYPE vKey);
                virtual bool OnChar(VK_TYPE vKey);
                virtual bool OnCommand(DLGID_t id, cXWindow* pCtrl, WORD wNotify);
 
                virtual DWORD OnNCHitTest(int x, int y) const;
                virtual bool OnDrop(cXWindow* pDragged, cXWindow* pConsumer, bool bTest);
                virtual void OnCancelMode()
                {}
                virtual void OnShowWindow(bool bShow, UINT nShowWindowCode);
                virtual bool OnKeyFocus(bool bActive);
 
                virtual bool OnHelp() const;
 
                virtual void OnScroll(int iPos, cXWindow* pCtrl);
                virtual void OnContextMenu(cXMenu* pMenu, cXWindow* pCtrl);
                virtual void OnSize(UINT uType, PIXELS_t cx, PIXELS_t cy);
 
                void FrameMoveTick(TIMESYS_t timeNow);          // update me and my children.
                virtual void onTick(void);
                virtual bool CanTakeMouseInput() const;
 
                //************************************
                // Children
                int get_ChildQty() const noexcept
                {
                        return m_aChildWindows.GetSize();
                }
                cXWindowPtr EnumChild(ITERATE_t index) const;
                bool IsChildTypeOpen(X_WNDCLASS_TYPE xClassType, DLGID_t id = k_DLGID_ANY) const;
                cXWindowPtr FindChildByType(X_WNDCLASS_TYPE XClassType, DLGID_t id = k_DLGID_ANY) const;
                cXWindowPtr GetDlgItem(DLGID_t id, int iDescendChildren = 0) const;
                int AddChildWindow(cXWindow* pChild, bool bAddBottom = false, SHOWWINDOW_t nShowCmd = SW_SHOWNORMAL);
                void GetWidthHeightForChildren(OUT cRectI& rect, PIXELS_t dx, PIXELS_t dy);
                bool IsMyDescendant(const cXWindow* pChild) const;
                virtual cXWindowPtr GetConsumingControl(int x, int y, cXWindow* pIgnore = nullptr) const;
                bool DetachFromParent();
                void EnableWindowRange(DLGID_t idStart, DLGID_t idEnd, bool bEnable);
 
                //*****************************
                // Attribute helpers.
 
                bool SendCommand(WORD wNotify) const;
                cXWindowPtr get_ParentWindow(void) const noexcept
                {
                        return m_pParentWnd;
                }
 
                virtual bool LoadTextureFromFile(const FILECHAR_t* File, TEXTURELOAD_t uLoadFlags = TEXTURELOAD_NOP);
                void LoadTextureBlank();
                bool LoadTextureStyleElem(XSTYLE_ELEM_TYPE eStyleElem, TEXTURELOAD_t uLoadFlags = TEXTURELOAD_NOP);
                bool LoadTextureIcon(SPRITEID_t iIconIndex);
 
                COLOR_ELEM_t get_BackAlpha() const noexcept
                {
                        return m_TexElem.get_Alpha();
                }
                virtual void put_BackAlpha(COLOR_ELEM_t bAlpha)
                {
                        m_TexElem.put_Alpha(bAlpha);
                }
                D3DCOLOR get_BackColor() const
                {
                        return m_TexElem.get_SpriteColor();
                }
                void put_BackColor(D3DCOLOR color)
                {
                        m_TexElem.put_SpriteColor(color);
                }
                D3DCOLOR get_NormalColor() const
                {
                        return m_NormalColor;
                }
                void put_NormalColor(D3DCOLOR color)
                {
                        m_NormalColor = color;
                        put_BackColor(color);
                }
 
                void put_ToolTip(const GChar_t* pstrToolTip);
                virtual cString GetToolTip(cXWindow* pCtrl, int x, int y) const;
 
                virtual void put_Text(const GChar_t* pszText)
                {
                        UNREFERENCED_PARAMETER(pszText);
                }
                virtual cString get_Text() const        // any text associated with this window?
                {
                        return "";
                }
                virtual void put_FontPtr(const cFontBase* pFont)
                {
                        UNREFERENCED_PARAMETER(pFont);
                }
 
                bool SetKeyFocus();
 
                void put_TickTimer(TIMESYSD_t dwTimeInc);
 
        public:
                const X_WNDCLASS_TYPE m_eXWClass;       // similar to the windows concept of a class
                static const ATOMCHAR_t* k_XWindowClassNames[X_WNDCLASS_QTY + 1];
 
                cColorDX m_NormalColor;                 
 
        protected:
                //Status
                cXWindowPtr m_pParentWnd;       
                cRectI m_WindowRect;            
                cDXSpriteElem m_TexElem;        
                cArrayRef<cXWindow> m_aChildWindows;    
 
        private:
                DLGID_t m_DlgItemId;                    
 
                DWORD m_dwStyle;                                
                DWORD m_dwExStyle;                              
                WINDOCKFLAG_MASK m_uDockFlags;  
                WINFLAG_MASK m_uWinFlags;               
 
                cString m_strToolTip;                   
                TIMESYSD_t m_timeTickFreq;              
                cTimeSys m_timeTickLast;
        };
 
        class cXWindowText : public cXWindow
        {
 
                typedef cXWindow SUPER_t;
 
        public:
                cFontPtr m_pFont;               // the font associated with any text in this window.
 
        public:
                cXWindowText(X_WNDCLASS_TYPE eXWClass, cXWindow* pParent, DLGID_t dlgid = k_DLGID_Static, UID_t uid = cUID::k_CLEAR);
                virtual ~cXWindowText();
 
                virtual void put_FontPtr(const cFontBase* pFont) override
                {
                        m_pFont = pFont;
                }
 
                virtual HRESULT InitDeviceObjects(cDXDevice* pDXDev)
                {
                        if (m_pFont != nullptr)
                        {
                                m_pFont->InitDeviceObjects(pDXDev);
                        }
                        return __super::InitDeviceObjects(pDXDev);
                }
                virtual HRESULT DeleteDeviceObjects()
                {
                        if (m_pFont != nullptr)
                        {
                                m_pFont->DeleteDeviceObjects();
                        }
                        return __super::DeleteDeviceObjects();
                }
                virtual HRESULT OnLostDeviceX()
                {
                        if (m_pFont != nullptr)
                        {
                                m_pFont->OnLostDeviceX();
                        } 
                        return __super::OnLostDeviceX();
                }
                virtual HRESULT OnResetDeviceX()
                {
                        if (m_pFont != nullptr)
                        {
                                m_pFont->OnResetDeviceX();
                        }
                        return __super::OnResetDeviceX();
                }
        };
 
        typedef cRefPtr<cXWindowText> cXWindowTextPtr;
} 
 
#endif // _INC_cXWindow_H