cXDialog.h

Go to the documentation of this file.

//
//
#ifndef _INC_cXDialog_H
#define _INC_cXDialog_H
 
#pragma once
 
#include "../Style/cXStyleSheet.h"
#include "../Style/cXIcon.h"
#include "../Window/cXWindow.h"
#include "GrayLib/include/Locale/cTextLocMgr.h"
#include "GrayLib/include/Math/cValueLerp.h"
 
namespace GrayGUI
{
        class cXDialog;
        typedef cRefPtr<cXDialog> cXDialogPtr;
 
        class cXDialogSizingParams
        {
        public:
                void InitMouseRect();
        public:
                DWORD m_dwHitTest;              
                cRectI m_MouseRect;             
                cRectI m_SizingRect;    
                cPoint2i m_ptLastPoint; 
 
                cPoint2i m_ptStartPoint;        
                cRectI m_rectStart;             
 
                MINMAXINFO m_MinMax;    
        };
 
        class cXDialogPlacement : public cWindowPlacement
        {
 
#define DIALOGPLACEMENT_VERCODE 0x02
        public:
                cXDialogPlacement();
 
                void InitPlacement()
                {
                        cWindowPlacement::InitPlacement();
                        m_bVerCode = DIALOGPLACEMENT_VERCODE;
                }
 
                bool IsValidFormat() const
                {
                        if (m_bVerCode != DIALOGPLACEMENT_VERCODE)
                                return false;
                        return isInitPlacement();
                }
 
                static bool UseDialogPlacement(X_WNDCLASS_TYPE XClassType);
        public:
                BYTE m_bVerCode;                                
                COLOR_ELEM_t m_bBackAlpha;              
                COLOR_ELEM_t m_bFrameAlpha;             
                WINDOCKFLAG_MASK m_uDockFlags;
                DWORD m_dwXTypeData1;                   
                bool m_bDialogLocked;                   
        };
 
        class cXDialogPlacementObj : public cXDialogPlacement, public cRefBase
        {
        public:
                cXDialogPlacementObj(X_WNDCLASS_TYPE XClassType = X_WNDCLASS_INVALID, int iEnum = 0)
                        : m_eXWClass(XClassType)
                        , m_iEnum(iEnum)
                {
                }
                HASHCODE_t get_HashCode() const noexcept
                {
                        return MAKEDWORD(m_iEnum, m_eXWClass);
                }
                bool IsValidFormat() const;
        public:
                X_WNDCLASS_TYPE m_eXWClass;             
                int m_iEnum;                                    
        };
        typedef cRefPtr<cXDialogPlacementObj> cXDialogPlacementPtr;
 
        enum PLAYCMD_TYPE;      // user determined actions/commands.
 
        class cXDialog : public cXWindowText
        {
                typedef cXWindowText SUPER_t;
        public:
                cXDialog(cXWindow* pParent, X_WNDCLASS_TYPE eXWClass = X_DLG_FIRST, DLGID_t dlgid = 0, UID_t uidDialog = cUID::k_CLEAR);
                ~cXDialog();
 
                PLAYCMD_TYPE get_DialogCommand() const;
 
                void DialogPlacementInit(void);
                bool DialogPlacementUpdate();
                bool GetMinMaxInfo(MINMAXINFO& MinMax) const;
 
                virtual cString get_Text(void) const
                {
                        return(m_strCaption);
                }
                virtual void put_Text(const GChar_t* pszCaption)
                {
                        if (pszCaption == nullptr)      // or is this a clear?
                                return;
                        m_strCaption = g_Text.GetStringTest(pszCaption);
                }
                const cRectI& get_ClientRect() const
                {
                        return m_rectClientArea;
                }
                virtual void put_Style(DWORD dwStyle);
                bool HasStyleCaption() const
                {
                        if ((get_Style() & WS_CAPTION) != WS_CAPTION)
                                return false;
                        if (HasFlags(WINFLAG_HIDETITLE))
                                return false;
                        return true;
                }
                void SetScissorDialog(cPoint2i& ptAbsolutePos);
                HRESULT SetViewportDialog(cPoint2i& ptAbsolutePos);
 
                virtual bool LoadTextureFromFile(const FILECHAR_t* File, TEXTURELOAD_t uLoadFlags = TEXTURELOAD_NOP);
 
                HRESULT SetupFrameFromResource(cResDialog& DlgTemp);
                HRESULT SetupChildrenFromResourceT(cResDialog& DlgTemp);
                HRESULT SetupChildrenFromResource(const GChar_t* pszName);
                HRESULT SetupInitDataFromResource(const GChar_t* pszName);
                HRESULT SetupDialogFromResourceT(cResDialog& DlgTemp, const GChar_t* pszName);
                HRESULT SetupDialogFromResource(const GChar_t* pszName);
 
                void SetRadioRange(DLGID_t idStart, DLGID_t idEnd, DLGID_t idCurrent);
                void ShowWindowRange(DLGID_t idStart, DLGID_t idEnd, int nCmd);
 
                bool IsDialogOnScreenOnly() const;
                void KeepDialogOnScreenWH();
                void KeepDialogOnScreenXY();
                void KeepDialogOnScreen();
 
                virtual HRESULT DisposeThis();
                virtual bool InitXWindow(void);
 
                virtual HRESULT InitDeviceObjects(IDirect3DDevice9* pDev);
                virtual HRESULT OnResetDeviceX();
 
                virtual void ShowWindow(SHOWWINDOW_t nCmdShow = SW_SHOWNORMAL);
                virtual void SetWidthHeight(PIXELS_t Width, PIXELS_t Height);
                virtual void SetXYPos(PIXELS_t X, PIXELS_t Y);
                virtual void Render(void);
 
                virtual void OnSize(UINT uType, PIXELS_t cx, PIXELS_t cy);
                virtual bool OnMouseDblClk(MBUTTON_TYPE uButton, PIXELS_t x, PIXELS_t y);
                virtual bool OnMouseDown(MBUTTON_TYPE uButton, PIXELS_t x, PIXELS_t y);
                virtual bool OnMouseUp(MBUTTON_TYPE uButton, PIXELS_t x, PIXELS_t y);
                virtual bool OnMouseMove(MBUTTON_TYPE uButton, PIXELS_t x, PIXELS_t y);
                virtual bool OnRender(void);
                virtual void OnDialogActive(bool bActive);
                virtual bool OnKeyFocus(bool bActive);
                virtual void OnContextMenu(cXMenu* pMenu, cXWindow* pCtrl);
                virtual bool OnCommand(DLGID_t id, cXWindow* pCtrl, WORD wNotify);
                virtual void OnCommandClose();
                virtual bool OnSysCommand(WPARAM nSysCmd, PIXELS_t x, PIXELS_t y);
                virtual DWORD OnNCHitTest(int x, int y) const; // HTCLIENT
                virtual bool OnGetMinMaxInfo(LPMINMAXINFO pMinMax) const;
                virtual bool OnDrop(cXWindow* pDragged, cXWindow* pConsumer, bool bTest)
                {
                        UNREFERENCED_PARAMETER(pDragged);
                        UNREFERENCED_PARAMETER(pConsumer);
                        UNREFERENCED_PARAMETER(bTest);
                        return false;
                }
                virtual void OnDragOff(cXWindow* pDragged)                              //first implemented in CXPaperDoll for highlights
                {
                        UNREFERENCED_PARAMETER(pDragged);
                }
 
                void StartDragOff(PIXELS_t cursorX, PIXELS_t cursorY); // force drag-moving of this dialog (like when "dragging dialog out" of something)
 
                virtual void OnColorChange();   // allow the dialog to change its children on color pop change.
 
                bool MoveSizing_OnMouseDown(DWORD dwHitTest, PIXELS_t X, PIXELS_t Y);
                bool MoveSizing_OnMouseMove(PIXELS_t x, PIXELS_t y);
 
                cRectI ConstrainWHRatio(const cRectI& rectInput, PIXELS_t dx = 0, PIXELS_t dy = 0);     //fixes to correct ratio
 
                virtual cString GetToolTip(cXWindow* pCtrl, PIXELS_t x, PIXELS_t y) const;
 
                static bool NC_IsSizing(DWORD dwHTMode);
 
                virtual void ModifyFlags(WINFLAG_MASK uiFlagsAdd, WINFLAG_MASK uiFlagsRem = 0)
                {
                        __super::ModifyFlags(uiFlagsAdd, uiFlagsRem);
                        DialogPlacementUpdate();
                }
 
                COLOR_ELEM_t get_FrameAlpha(void) const
                {
                        // 0xff = opaque = COLOR_ALPHA_OPAQUE
                        if (m_pDP == nullptr)
                                return COLOR_ALPHA_OPAQUE;
                        return(m_pDP->m_bFrameAlpha);
                }
                void put_FrameAlpha(COLOR_ELEM_t bFrameAlpha)
                {
                        // 0xff = fully opaque = COLOR_ALPHA_OPAQUE
                        if (m_pDP == nullptr)
                                return;
                        m_pDP->m_bFrameAlpha = bFrameAlpha;
                }
 
                void put_BackAlpha(COLOR_ELEM_t bBackAlpha)
                {
                        //need virtual put_BackAlpha to insert dialog placement information before calling superclass's
                        // 0xff = fully opaque = COLOR_ALPHA_OPAQUE
                        __super::put_BackAlpha(bBackAlpha);
                        if (m_pDP == nullptr)
                                return;
                        m_pDP->m_bBackAlpha = bBackAlpha;
                }
 
                void put_HideTitlebar(bool bHideTitleBar);
 
                bool IsDialogActingAsControl() const
                {
                        // my parent isn't the desktop?
                        if (m_pParentWnd == nullptr)
                                return false;
                        return(m_pParentWnd->get_XWType() < X_DT_FIRST);
                }
 
                bool get_DialogLocked() const
                {
                        return m_bDialogLocked;
                }
                void put_DialogLocked(bool bIsLocked)
                {
                        if (m_bDialogLocked && IsDialogActingAsControl())
                                return;
 
                        m_bDialogLocked = bIsLocked;
                }
 
                virtual bool CanTakeMouseInput(void) const;
 
        public:
                STDMETHOD(s_Invoke)(const cScriptableMethod* pMethod, const cVariant& vArgs, cVariant& vValRet) override;
 
                CSCRIPT_CLASS_DEF1(XDialog, cXWindowText);
                enum M_TYPE_
                {
#define cXDialogMethod(a,b,c) M_##a,
#include "cXDialogMethods.tbl"
#undef cXDialogMethod
                        M_QTY,
                };
                static cScriptableMethod sm_Methods[M_QTY + 1];
 
                void FitDialogToClientArea(void); // adjusts the window around the client
 
        protected:
                bool NC_AdjustWindowRect(cRectI& rectClient) const;
                void NC_AdjustClientRect();
 
                void UpdateScalingClient(void);
                HRESULT NC_DrawSysCmd(const cPoint2i& ptAbsPos, XSTYLE_ELEM_TYPE eStyleElem, XSTYLE_ELEM_TYPE iControlID);
 
        private:
                bool NC_RenderCaptionFore(const cPoint2i& ptAbsPos, bool bActive);
                bool NC_Render();
 
                void ShowWindowMinMax(UINT cmd, cRectI& rect);
                void UpdateDialogIcon();
 
                // Init dialog from templates
                static X_WNDCLASS_TYPE GetXTypeByName(const ATOMCHAR_t* pszName);
                static X_WNDCLASS_TYPE GetXTypeFromTemplateItem(cResDlgTemplateItem* pItem);
                cXWindowPtr AddControlType(X_WNDCLASS_TYPE eXWClass, DLGID_t id, DWORD dwStyle, cXWindowPtr& pLastGroup);
                HRESULT AddControlTemplateItem(cResDlgTemplateItem* pItem, cXWindowPtr& pCtrl, cXWindowPtr& pLastGroup, const cVector2f& vDlgUnit);
                HRESULT AddControlVar(cVariant& vArgs);
                HRESULT SetupInitDataFromResource(cResDialogInit& DlgInit);
 
        public:
                static const ATOMCHAR_t* sm_pHTTrackCursor;
                cXDialogPlacementPtr m_pDP;                             // persistent placement info.
                cXIcon2 m_Icon;                                                 // An icon to represent the dialog.
                cRectI m_rectNonBorder;                                 // Inside the border. (if there is one)
                cRectI m_rectSysCmd[DLG_SYSCMD_QTY];    // The WS_CAPTION controls.
 
                const GChar_t* m_idDialogResource;      // LoadResource was called for this ?
                DLGID_t m_idHelpText;                   // the resource id for the help text for this dialog.
        private:
                bool m_bDialogLocked;                                           // lock toggle bool
 
        public:
                // REPLACE THIS WITH A FLAG ???
                float m_fRatioWH;                                               // Width/Height ratio constraint
 
        protected:
                cRectI m_rectClientArea;        // client area, relative to m_WindowRect
                cValueLerp<COLOR_ELEM_t> m_FrameAlpha;  // animated to target over time.
                cString m_strCaption;
                cXDialogPtr m_pPrevModalDialog; // WINFLAG_MODAL
                static cXDialogSizingParams sm_MoveSizing;
        };
};
#endif // _INC_cXDialog_H