GxGuiWindow.h

Go to the documentation of this file.

//===========================================================================
//===========================================================================
#pragma once
 
#if GX_DEVELOP
 
GX_CORE_NAMESPACE_BEGIN()
class GxGuiMenu;
class GxGuiHover;
 
//===========================================================================
//===========================================================================
#if defined(_WINDOWS)
class GxGuiWindow : public GxGuiBase, public GxRenderNotifier
#else //_WINDOWS
class GxGuiWindow : public GxGuiBase
#endif // !_WINDOWS
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GX_RTTI_CLASS_ICON(GxGuiWindow, GxGuiBase, GxRtti::ICON_TYPE::OROCHI)
    // GxClassBaseReference継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE_REFERENCE(GxGuiWindow)
 
    
    enum class FAIRING_MODE
    {
        NORMAL = 0,     
        MIN,            
        MAX,            
    };
 
    enum class DOCKING_MODE
    {
        OFF = -1,       
        LEFT = 0,       
        RIGHT,          
        TOP,            
        BOTTOM,         
        CENTER,         
        MAX,            
    };
 
protected:
    enum class CONTROL_MODE
    {
        OFF = 0,            
        SIZE_LEFT,          
        SIZE_TOP,           
        SIZE_RIGHT,         
        SIZE_BOTTOM,        
        SIZE_LEFTTOP,       
        SIZE_RIGHTTOP,      
        SIZE_LEFTBOTTOM,    
        SIZE_RIGHTBOTTOM,   
        TRANSLATE,          
 
        CLOSE,              
        SIZEMIN,            
        SIZEMAX,            
        MAX                 
    };
 
    class GxWindowButton;
    class GxMenuBar;
    class GxViewBar;
 
private:
    static constexpr u32 CAPTION_SIZE_Y         = 16;
    static constexpr u32 WINDOW_FRAME           = 4;
    static constexpr u32 CAPTION_MARGIN_TOP     = 0;
    static constexpr u32 CAPTION_MARGIN_SIDE    = 4;
    static constexpr u32 CAPTION_MARGIN_BOTTOM  = 2;
    static constexpr u32 BUTTON_SIZE            = CAPTION_SIZE_Y - CAPTION_MARGIN_TOP - CAPTION_MARGIN_BOTTOM;
    static constexpr u32 BUTTON_MARGIN_SIDE     = 2;
 
    enum class HIT
    {
        NONE            = 0,    
 
        CLIENT,                 
 
        // GxGuiWindowが使用
        CAPTION,                
        LEFT,                   
        TOP,                    
        RIGHT,                  
        BOTTOM,                 
        LEFTTOP,                
        RIGHTTOP,               
        LEFTBOTTOM,             
        RIGHTBOTTOM,            
        CLOSE,                  
        SIZEMAX,                
        SIZEMIN,                
 
        MAX                     
    };
 
    enum class BAR_TYPE
    {
        MENU,           
        VIEW,           
        MAX             
    };
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GxGuiWindow(void);
    GxGuiWindow( b32 useCloseWindowButton, b32 useMinWindowButton, b32 useMaxWindowButton, b32 useCaption = true, b32 isOutsideWindow = false);
 
private:
#if GX_EDITOR
    void resetWindow(void);
#endif //GX_EDITOR
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    b32 initialize( void ) override;
 
    void update( void ) override;
 
    // 解放
    void cleanup( void ) override;
 
    void closeChild( void ) override;
 
    void onNoClientDraw( void ) override;
 
#if GX_EDITOR
    void setRegion(const GxRect& rect, b32 force = false ) override;
    b32 onResetDevice(void) override;
    void preDraw( void ) override;
    void postDraw( void ) override;
#endif //GX_EDITOR
 
    void screenRender( void ) override;
 
    void setCaptionName( GX_CSTR pName );
    GX_FORCE_INLINE void setCaptionName( const GxString& name ){ setCaptionName( name.getString() ); }
 
    GX_FORCE_INLINE const GxString& getCaptionName( void ) const { return _captionName; }
 
    b32 createMenuBar( const GxPropertyTable& propertyTable );
 
    void clearMenuBar(void);
 
    b32 createViewBar( const GxPropertyTable& propertyTable, GxResTexture* pResIconTexture, const GxVector2& iconTextureSize, const GxVector2& iconTextureStartUV );
 
    void clearViewBar(void);
 
    void setPopupMenu(GxGuiMenu* pGuiMenu);
 
    void setPopupHover(const GxPoint2& position, GX_CSTR message, const GxGuiBase* pOwner, b32 useAdjust = true);
private:
    void closeHover(void);
public:
    void setFairingMode( FAIRING_MODE mode );
 
    void maximize( void );
 
    void minimize( void );
 
    void normalize( void );
 
    GX_FORCE_INLINE virtual GxSize getDefaultWindowSize(void) const { return GxSize(400, 300); }
 
    GxSize getClampedRegionSize( const GxSize& requestSize ) const override;
 
    void onSize(const GxSize& size) override;
 
    GX_FORCE_INLINE virtual void closeAll(void) { eventClose(); }
    void eventClose(void);
 
    GxRect calculateClientRect( const GxRect& clientRect ) const override;
 
    void setPositionInScreen(const GxSize& screenSize);
private:
    void controlWindowOnMouseDown(const GxPoint2& position, u32 button);
 
    GxRect calcFairingRect(FAIRING_MODE mode) const;
 
    HIT getMouseHitTest(const GxPoint2& point);
 
    void updateCaption(void);
 
#if GX_EDITOR
    static LRESULT CALLBACK wndProc(HWND windowHandle, UINT uMessage, WPARAM wParam, LPARAM lParam);
#endif //GX_EDITOR
 
protected:
    virtual void controlWindow(void);
 
    void eventMin(void);
 
    void eventMax(void);
 
    GxGuiGraphics::MOUSE_CURSOR getMouseCursor(void) override;
 
    GX_FORCE_INLINE void onMouseDown(const GxPoint2& /*position*/, u32 /*button*/) override {};
 
    void onNoClientMouseDown(const GxPoint2& position, u32 button) override;
 
    void onMouseUp(const GxPoint2& position, u32 button) override;
 
    void onNoClientDoubleClick(const GxPoint2& position, u32 button) override;
 
    void onActive(b32 active) override;
 
    void onMouseLeave(void) override;
 
    static GxRect calcDockingRect(const GxRect& windowRect, DOCKING_MODE mode);
    GX_FORCE_INLINE virtual DOCKING_MODE getDockingModeFromGuide(void) const { return DOCKING_MODE::OFF; }
 
#if GX_EDITOR
    void createOutsideWindow(void);
    void releaseOutsideWindow(void);
#endif //GX_EDITOR
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    constexpr void setIconHandle( GX_HANDLE handle ){ _iconHandle = handle; }
 
    GX_FORCE_INLINE b32 isSendClientRectToChildGuiFormRegion( void ) const { return _isSendClientRectToChildGuiFormRegion; }
 
    GX_FORCE_INLINE void setSendClientRectToChildGuiFormRegion( b32 isSendClientRectToChildGuiFormRegion ){ _isSendClientRectToChildGuiFormRegion = isSendClientRectToChildGuiFormRegion; }
 
    GX_FORCE_INLINE b32 isFairingMode(FAIRING_MODE mode) const { return _fairingMode == mode; }
 
    GX_FORCE_INLINE virtual b32 isNormalWindow( void ) const { return isFairingMode(FAIRING_MODE::NORMAL); }
 
    GX_FORCE_INLINE const GxRect& getNormalRect( void ) const { return _normalRect; }
 
    GX_FORCE_INLINE void setNormalRect( const GxRect& normalRect ) { _normalRect = normalRect; }
 
    GX_FORCE_INLINE b32 isMovable(void) const { return _isMovable; }
    GX_FORCE_INLINE void setMovable(b32 enable) { _isMovable = enable; }
    GX_FORCE_INLINE b32 isClosable(void) const { return _isClosable; }
    GX_FORCE_INLINE void setClosable(b32 enable) { _isClosable = enable; }
    void setVisible(b32 enable);
 
    b32 isDocking(void) const;
    b32 isDockingEnable(void) const;
 
#if GX_EDITOR
    constexpr HWND getWindowHandle(void) const { return _hwnd; }
    GX_FORCE_INLINE b32 isActiveWindow(void) const { return GetActiveWindow() == _hwnd; }
    b32 isOnMouseWindowHandle(HWND hwnd) const;
#if GX_USE_DX11
    GX_FORCE_INLINE GxRenderTexture* getRenderTexture(void) const { return _pRenderTexture; }
#elif GX_USE_DX12
    GX_FORCE_INLINE GxRenderTexture* getRenderTexture(void) const { return _pRenderTexture[getGxRenderDevice()->getWriteBuffer()]; }
#endif //GX_USE_DX12
#endif //GX_EDITOR
 
    GX_FORCE_INLINE b32 isControlMode(CONTROL_MODE mode) const { return _controlMode == mode; }
 
#if GX_EDITOR
    GX_FORCE_INLINE b32 isOutsideWindow(void) const { return _isOutsideWindow; }
#endif //GX_EDITOR
    constexpr GxGuiButton* getCloseButton(void) const { return _pCloseButton; }
    GX_FORCE_INLINE b32 isEnableClose(void) const { return _useCloseWindowButton; }
    GX_FORCE_INLINE b32 isEnableMin(void) const { return _useMinWindowButton; }
    GX_FORCE_INLINE b32 isEnableMax(void) const { return _useMaxWindowButton; }
private:
    constexpr u32 getCaptionSizeY(void) const { return _useCaption ? CAPTION_SIZE_Y : 0; }
    GX_FORCE_INLINE u32 getWindowFrameSize(void) const { return isDocking() ? 0 : WINDOW_FRAME; }
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
protected:
    GxGuiButton*        _pMinButton;                            
    GxGuiButton*        _pMaxButton;                            
    GxGuiButton*        _pCloseButton;                          
    GxMenuBar*          _pBar[static_cast<int>(BAR_TYPE::MAX)]; 
 
    b32                 _isSendClientRectToChildGuiFormRegion;  
 
    b32                 _isMovable;                             
    b32                 _isClosable;                            
    b32                 _useCloseWindowButton;                  
    b32                 _useMinWindowButton;                    
    b32                 _useMaxWindowButton;                    
    b32                 _useCaption;                            
 
    FAIRING_MODE        _fairingMode;                           
 
    GxString            _captionName;                           
    GxString            _clipCaptionName;                       
 
    GxRect              _normalRect;                            
 
    CONTROL_MODE        _controlMode;                           
    GxPoint2            _clickOffset;                           
 
    GxRect              _nameRect;                              
 
    GX_HANDLE           _iconHandle;                            
 
    s32                 _minIndex;                              
 
#if GX_EDITOR
    b32                 _isOutsideWindow;                       
    HWND                _hwnd;                                  
    b32                 _resetWindowFlag;                       
#if GX_USE_DX11
    GxRenderTexture*    _pRenderTexture;                        
    IDXGISwapChain*     _pDXGISwapChain;                        
#elif GX_USE_DX12
    GxRenderTexture*    _pRenderTexture[3];                     
    IDXGISwapChain3*    _pDXGISwapChain;                        
#endif GX_USE_DX12
#endif //GX_EDITOR
 
};
 
//===========================================================================
//===========================================================================
class GxGuiWindow::GxMenuBar : public GxClassBaseReference
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GX_RTTI_CLASS(GxMenuBar, GxClassBaseReference)
    // GxClassBaseReference継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE_REFERENCE(GxMenuBar)
    // new, delete定義
    GX_OPERATOR_NEW_DELETE(GxAllocatorList::ALLOCATOR_TYPE::DEVELOP)
 
    struct GxItem;
 
    static const s32    MENU_MARGIN_SIZE_LEFT;
    static const s32    MENU_MARGIN_SIZE_RIGHT;
    static const s32    MENU_MARGIN_SIZE_TOP;
    static const s32    MENU_MARGIN_SIZE_BOTTOM;
    static const s32    MENU_MARGIN_SIZE_WIDTH;
    static const s32    MENU_MARGIN_SIZE_HEIGHT;
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GxMenuBar(void);
 
    GxMenuBar(GxGuiWindow* pOwner);
 
    void cleanup( void ) override;
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    void                setPropertyTable( const GxPropertyTable& propertyTable );
 
    GxSize              getUseSize( void );
 
    constexpr u32       getItemNum( void ) const { return _itemNum; }
 
    const GxItem*       getItem( u32 index ) const;
 
    virtual void        updateItemTable( const GxRect& menuRect );
 
private:
    virtual GxSize      getItemSize( GxProperty& property );
 
public:
    void                onMouseMove(const GxPoint2& posotion, u32 button);
 
    void                onMouseDown(const GxPoint2& position, u32 button);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    b32                 isOpen( void ) const;
    void                openSubMenu( s32 index );
    void                closeSubMenu( void );
private:
    s32                 getItemIndex(const GxPoint2& position);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GxGuiWindow*            _pOwner;                
 
    s32                     _selectedIndex;         
    GxPropertyTable         _propertyTable;         
 
    u32                     _itemNum;               
    GxItem*                 _pItemTable;            
    GxGuiMenu*              _pGuiMenu;              
 
};
 
//-----------------------------------------------------------
//-----------------------------------------------------------
struct GxGuiWindow::GxMenuBar::GxItem : public GxStructBase
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GX_RTTI_STRUCT(GxItem)
 
    // new, delete定義
    GX_OPERATOR_NEW_DELETE_USE_ARRAY(GxAllocatorList::ALLOCATOR_TYPE::DEVELOP)
        
    
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GxRect              _selectRegion;      
    u32                 _depth;             
 
};
 
//===========================================================================
//===========================================================================
class GxGuiWindow::GxViewBar : public GxGuiWindow::GxMenuBar
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GX_RTTI_CLASS(GxGuiWindow::GxViewBar, GxGuiWindow::GxMenuBar)
    // GxClassBaseReference継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE_REFERENCE(GxViewBar)
    // new, delete定義
    GX_OPERATOR_NEW_DELETE(GxAllocatorList::ALLOCATOR_TYPE::DEVELOP)
 
    
    static const s32    VIEW_ICON_WIDTH;
    static const s32    VIEW_ICON_HEIGHT;
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GxViewBar(void);
    GxViewBar(GxGuiWindow* pOwner);
    void cleanup( void ) override;
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
private:
    GxSize      getItemSize( GxProperty& property ) override;
 
public:
    GX_FORCE_INLINE void setIconTexture( GxResTexture* pResIconTexture, const GxVector2& iconTextureSize, const GxVector2& iconTextureStartUV ){ GX_SET_CLASS_BASE_REFERENCE( _pResIconTexture , pResIconTexture ); _iconTextureSize = iconTextureSize; _iconTextureStartUV = iconTextureStartUV; }
    constexpr GxResTexture* getIconTexture( void ) const { return _pResIconTexture; }
    GX_FORCE_INLINE GxVector2 getIconTextureSize( void ) const { return _iconTextureSize; }
    GX_FORCE_INLINE GxVector2 getIconTextureStartUV( void ) const { return _iconTextureStartUV; }
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
private:
    GxResTexture*           _pResIconTexture;       
    GxVector2               _iconTextureSize;       
    GxVector2               _iconTextureStartUV;    
 
};
 
GX_CORE_NAMESPACE_END()
 
#endif // GX_DEVELOP