doc/api/_gx_gui_system_8h_source.html

//===========================================================================

//===========================================================================

#pragma once


#if GX_DEVELOP


GX_CORE_NAMESPACE_BEGIN()


#define GX_GUI_USE_PROFILE          0           // Guiのプロファイルを使用する


#if GX_GUI_USE_PROFILE

#define GX_GUI_PROFILE( name )  GX_PROFILE_COLOR_ADJUST( name, GxProfiler::ColorBaseTool )

#else //GX_GUI_USE_PROFILE

#define GX_GUI_PROFILE( name )  (static_cast<void>(0))

#endif // !GX_GUI_USE_PROFILE


class GxGuiDesktop;

class GxGuiGraphics;

class GxGuiWindow;

class GxGuiProperty;


#define MULTI_SELECT_DISP 1 // 複数選択時、値が異なるときの表示を使用


//===========================================================================

//===========================================================================

class GxGuiConfig : public GxClassBase

{

    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    enum class GUI_ROTATE

    {

        XYZ = 0,

        XZY,

        YXZ,

        YZX,

        ZXY,

        ZYX,

        QUATERNION,

        MAX,

    };

#if GX_DEVELOP

    GX_ENUM_TABLE_MAX(GUI_ROTATE)

#endif //GX_DEVELOP


    // RTTI定義

    GX_RTTI_CLASS(GxGuiConfig, GxClassBase)

    // new, delete定義

    GX_OPERATOR_NEW_DELETE(GxAllocatorList::ALLOCATOR_TYPE::DEVELOP)


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    GxGuiConfig(void);


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    void loadJson(const GxJson::GxJsonNode& jsonNode);


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    GX_FORCE_INLINE b32 isRotateTabEnable(GUI_ROTATE gui) const { return _rotateTabEnable.isFlag(gui); }

    constexpr GUI_ROTATE getRotateTabDefault(void) const { return _rotateTabDefault; }

    constexpr f32 getRotateSliderStep(void) const { return _rotateSliderStep; }

    constexpr s32 getRotateFloatFormat(void) const { return _rotateFloatFormat; }


    GxGuiConfig& operator = (const GxGuiConfig& v);

    GX_FORCE_INLINE void set(GxGuiConfig& v) { *this = v; }

    void setDefault(void);


    //-----------------------------------------------------------

    //-----------------------------------------------------------


    GxFlag32Index<GUI_ROTATE>   _rotateTabEnable;

    GUI_ROTATE                  _rotateTabDefault;

    f32                         _rotateSliderStep;

    s32                         _rotateFloatFormat;


};


//===========================================================================

//===========================================================================

class GxGuiSystem : public GxClassBaseReference, public SingletonBase<GxGuiSystem>

{

    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    // RTTI宣言

    GX_RTTI_ABSTRACT_CLASS(GxGuiSystem, GxClassBaseReference)

    // GxClassBaseReference継承クラス用禁止宣言

    GX_PROHIBIT_CLASS_BASE_REFERENCE(GxGuiSystem)

    // new, delete定義

    GX_OPERATOR_NEW_DELETE(GxAllocatorList::ALLOCATOR_TYPE::DEVELOP)


    // コールバック：GxGuiPropertyのsetPropertyValueが呼ばれた時

    typedef void (GxClassBaseRoot::* SET_PROP_VALUE_CALLBACK)(GxGuiProperty* pSender);


private:

    struct GxGuiHistoryParam : public GxStructBase

    {

        //-----------------------------------------------------------

        //-----------------------------------------------------------


        // RTTI宣言

        GX_RTTI_STRUCT(GxGuiHistoryParam)

        // new, delete定義

        GX_OPERATOR_NEW_DELETE(GxAllocatorList::ALLOCATOR_TYPE::DEVELOP)


        //-----------------------------------------------------------

        //-----------------------------------------------------------


        GxGuiProperty*      _pGuiProperty;

        b32                 _b32Param;

        f64                 _f64Param;

        s64                 _s64Param;

        u64                 _u64Param;

        GxString            _stringParam;


    };


    class GxInfoOnSetPropertyValue : GxClassBase

    {

        //-----------------------------------------------------------

        //-----------------------------------------------------------

    public:

        GxInfoOnSetPropertyValue(GxClassBaseRoot* pOwner, SET_PROP_VALUE_CALLBACK pCallback)

            : _pOwner(pOwner)

            , _pCallback(pCallback)

        {}


        //-----------------------------------------------------------

        //-----------------------------------------------------------


        GxClassBaseRoot* _pOwner;

        SET_PROP_VALUE_CALLBACK _pCallback;


    };


    static constexpr u32 SERIALIZE_TEMPORARY_SIZE = GxMath::VALUE_1M;


    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    GxGuiSystem(void);


    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    b32             initialize(void);

    void            cleanup(void) override;

    void            update( void );

    void            render( void );


#if GX_EDITOR

    void setTopWindowAll(HWND exceptHandle = nullptr);

    void setMinimumWindowAll(void);

    void setNormalWindowAll(void);

#endif //GX_EDITOR


    void            reserveDeleteGui( GxGuiBase* pGui );

private:

    void            emptyDeleteReservationList( void );


protected:

    void            drawAutoScroll(void);


public:

    void            addHistoryParam(GxGuiProperty* pGuiProperty);


    void            eraceAllHistoryParam(void);


    void            eraceHistoryParam(GxGuiProperty* pGuiProperty);


    b32             isExistHistoryParam(GxGuiProperty* pGuiProperty);


protected:

    void            executeUndo(void);


    void            executeRedo(void);


    void            applyHistoryParam(GxGuiHistoryParam* pGuiHistoryParam);


public:

    void setCallbackOnSetPropertyValue(GxClassBaseRoot* pOwner, SET_PROP_VALUE_CALLBACK pFunction);


    void removeCallbackOnSetPropertyValue(GxClassBaseRoot* pOwner, SET_PROP_VALUE_CALLBACK pFunction);


    void onSetPropertyValue(GxGuiProperty* pSender);


    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

#if GX_EDITOR

    GxGuiWindow* getGuiWindow(HWND windowHandle);

#endif //GX_EDITOR


    GxGuiBase* getGui( const GxPoint2& position );


    GX_FORCE_INLINE void setEditMode( b32 editMode ){ _editMode = editMode; }


    GX_FORCE_INLINE b32 isEditMode( void ) const { return _editMode; }


    GX_FORCE_INLINE const GxString& getEditParam( void ) const { return _editParam; }


    s32 calcCursorPositionFromPosition( const GxPoint2& position ) const;


    constexpr s32 getEditParamCursorPosition( void ) const { return _editParamCursorPosition; }


    void            setEditParamCursorPosition( s32 position, b32 select = false );


    void            setEditParam( const GxString& editParam );


    void            deleteEditParamSelected( void );


    void            selectAllEditParam( void );


    void            popEditParam( void );


    void            copyParamSelected( void );


    void            cutParamSelected( void );


    void            pasteParamSelected( void );


    constexpr GxGuiDesktop* getDesktop( void ) const { return _pDesktop; }


    constexpr GxGuiBase* getFocus( void ) const { return _pFocus; }


    void            setFocus( GxGuiBase* pFocus );


    constexpr GxGuiBase* getModalGui(void) const { return _pModalGui; }

    void            setModalMode( GxGuiBase* pGui, b32 on );


    void            setInScreenWindow( void );


    void            editParam( GxKeyboard::KEY key );


#if defined( _WINDOWS )

    constexpr GX_CHAR* getDialogEdit( void ){ return _dialogEdit; }


    constexpr u32 getDialogEditSize( void ) const { return sizeof( _dialogEdit ); }


#endif  //_WINDOWS


    void            drawEditParam( const GxRect& drawRect, const GxColor& color );


    void            setPopupHover( const GxPoint2& position, GX_CSTR message, const GxGuiBase* pOwner, b32 useAdjust = true );


    void            setMessageBox( const GxString& message, const GxString& caption );


    b32             isFocusedDesktop( void ) const;


    b32             isOnDesktopMousePosition( void ) const;


    GX_FORCE_INLINE void setDrawAutoScroll( const GxPoint2& start, const GxPoint2& end ){ _isDrawAutoScroll = true; _autoScrollStartPosition = start; _autoScrollEndPosition = end; }


    b32             isClickTarget( GxGuiBase* pGui ) const;


    GX_FORCE_INLINE void useRealFloatFormat( b32 isUse ) { _isRealFloatFormat = isUse; }

    GX_FORCE_INLINE b32 isRealFloatFormat(void) const { return _isRealFloatFormat; }

    GX_FORCE_INLINE GxGuiConfig* getGuiConfig(void) { return &_guiConfig; }


    GX_FORCE_INLINE void setStopRTDPlayByClick( b32 isUse ) { _isStopRTDPlayByClick = isUse; }

    GX_FORCE_INLINE b32 getStopRTDPlayByClick(void) const { return _isStopRTDPlayByClick; }

    GX_FORCE_INLINE void setRTDWheelScroll( b32 isUse ) { _useRTDWheelScroll = isUse; }

    GX_FORCE_INLINE b32 getRTDWheelScroll(void) const { return _useRTDWheelScroll; }

    b32             isFocused(void);


    constexpr GxGuiBase* getOnMouseGUI(void) const { return _pOnMouse; }

    constexpr GxGuiWindow* getOnMouseWindow(void) const { return _pOnMouseWindow; }

    constexpr GxGuiWindow* getDragWindow(void) const { return _pDragWindow; }

    constexpr void setDragWindow(GxGuiWindow* pWindow) { _pDragWindow = pWindow; }

    constexpr void setStartDragGUI(GxGuiBase* pGui) { _pStartDragGUI = pGui; }


    //-----------------------------------------------------------

    //-----------------------------------------------------------

private:

    GxArray                 _listOnSetPropertyValue;

protected:

    GxGuiGraphics*          _pGuiGraphics;

    GxGuiDesktop*           _pDesktop;


    GxGuiBase*              _pFocus;

    GxGuiBase*              _pModalGui;

    GxGuiBase*              _pOnMouse;

    GxGuiWindow*            _pOnMouseWindow;

    GxGuiBase*              _pClickTarget;

    GxGuiWindow*            _pDragWindow;

    GxGuiBase*              _pStartDragGUI;


    GxArrayClassBaseReference   _guiDeleteReservationList;


    b32                     _editMode;

    GxString                _editParam;

    GxString                _saveParam;


    s32                     _editParamCursorPosition;

    s32                     _editParamCursorTimer;


    s32                     _editParamSelectStartPosition;

    s32                     _editParamSelectEndPosition;


#if defined( _WINDOWS ) || defined(_PS4) || defined(_PS5)

    GX_CHAR                 _dialogEdit[GxMath::VALUE_512];

#endif  // _WINDOWS || _PS4 || _PS5


    s32                     _counter;


    GxProperty              _copyObjectProperty;

    u32                     _copyObjectArrayCount;


    GX_CHAR                 _serializeTemporaryBuffer[ SERIALIZE_TEMPORARY_SIZE ];


    b32                     _isDrawAutoScroll;

    GxPoint2                _autoScrollStartPosition;

    GxPoint2                _autoScrollEndPosition;


    //  undo/redo用

    GxList                  _guiHistoryParamList;

    GxList::GxNode*         _pGuiHistoryCurrentNode;

    f32                     _keyPushTimerForUndo;

    f32                     _keyPushTimerForRedo;

    GxCriticalSection       _historyListCriticalSection;


    // その他

    b32                     _isRealFloatFormat;

    b32                     _useRTDWheelScroll;

    b32                     _isStopRTDPlayByClick;

    GxGuiConfig             _guiConfig;


};


// アクセスインターフェイス

GX_FORCE_INLINE GxGuiSystem* getGxGuiSystem(void){ return GxGuiSystem::getSingletonPointer(); }


//===========================================================================

//===========================================================================

class GxGuiGraphics : public GxClassBaseReference, public SingletonBase<GxGuiGraphics>

{

    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    // RTTI

    GX_RTTI_ABSTRACT_CLASS(GxGuiGraphics, GxClassBaseReference)

    // GxClassBaseReference継承クラス用禁止宣言

    GX_PROHIBIT_CLASS_BASE_REFERENCE(GxGuiGraphics)

    // new, delete定義

    GX_OPERATOR_NEW_DELETE(GxAllocatorList::ALLOCATOR_TYPE::DEVELOP)


    enum LAYOUT

    {

        LAYOUT_CENTER_HORIZON   =   (1<<0),

        LAYOUT_CENTER_VERTICAL  =   (1<<1),

        LAYOUT_LEFT             =   (1<<2),

        LAYOUT_RIGHT            =   (1<<3),

        LAYOUT_TOP              =   (1<<4),

        LAYOUT_BOTTOM           =   (1<<5),


        LAYOUT_CENTER           = LAYOUT_CENTER_HORIZON | LAYOUT_CENTER_VERTICAL,


        LAYOUT_HORIZON_MASK     = LAYOUT_CENTER_HORIZON | LAYOUT_LEFT | LAYOUT_RIGHT,

        LAYOUT_VERTICAL_MASK    = LAYOUT_CENTER_VERTICAL | LAYOUT_TOP | LAYOUT_BOTTOM

    };


    static constexpr u32        ICON_FULL_SIZE_WIDTH    =   16;

    static constexpr u32        ICON_FULL_SIZE_HEIGHT   =   16;


    enum class MOUSE_CURSOR

    {

        ARROW = 0,

        SIZEALL,

        SIZEWE,

        SIZENESW,

        SIZENS,

        SIZENWSE,

        IBEAM,

        MAX

    };


    static const GxColor        WINDOW_FRAME_COLOR_DEFAULT;

    static const GxColor        WINDOW_BACK_COLOR_DEFAULT;

    static const GxColor        TEXT_COLOR_DEFAULT;

    static const GxColor        KEY_WORD_1_COLOR_DEFAULT;

    static const GxColor        KEY_WORD_2_COLOR_DEFAULT;

    static const GxColor        FOCUS_COLOR_DEFAULT;

    static const GxRect         EXPAND_FRAMERECT_DEFAULT;

    static const GxSize         MOUSE_CURSOR_SIZE;


    enum class ICON_DOCKING_TYPE

    {

        // 子画面無し

        LEFT_4 = 0,

        TOP_4,

        RIGHT_4,

        BOTTOM_4,

        LEFT_TOP_4,

        RIGHT_TOP_4,

        LEFT_BOTTOM_4,

        RIGHT_BOTTOM_4,

        // 子画面あり

        LEFT_TOP_8,

        TOP_8,

        RIGHT_TOP_8,

        LEFT_8,

        RIGHT_8,

        LEFT_BOTTOM_8,

        BOTTOM_8,

        RIGHT_BOTTOM_8,


        LEFT_ALL_8,

        RIGHT_ALL_8,

        TOP_ALL_8,

        BOTTOM_ALL_8,

        MAX

    };


    // インナークラス

    class GxIcon;

    class GxMouseCursor;


    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    GxGuiGraphics(void);


    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    b32             initialize(void);

    void            cleanup(void) override;

    void            update(void) {}


#if GX_DEVELOP

    static GxGuiBase* createGui(GxProperty& property, GxTypedObject* pOwner, const GxRtti& rtti, u32 index);

#endif //GX_DEVELOP


    void drawIconF( const GxRect& rect, GX_HANDLE handle, const GxColor& color = GxColor::WHITE );

    void drawIconG( const GxRect& rect, GX_HANDLE handle, const GxColor& color0, const GxColor& color1, const GxColor& color2, const GxColor& color3 );

    void drawIconF( const GxRect& rect, GX_HANDLE handle, const GxVector2& rotateCenter, const f32 rotateRadian, const GxColor& color = GxColor::WHITE );

    void drawIconG( const GxRect& rect, GX_HANDLE handle, const GxVector2& rotateCenter, const f32 rotateRadian, const GxColor& color0, const GxColor& color1, const GxColor& color2, const GxColor& color3 );


    static void drawFrame( const GxRect& frameRect,const GxColor& frameLeftColor, const GxColor& frameTopColor, const GxColor frameRightColor, const GxColor& frameBottomColor );

    GX_FORCE_INLINE static void drawFrame( const GxRect& frameRect,const GxColor& frameLeftTopColor, const GxColor& frameRightBottomColor ){ drawFrame(frameRect,frameLeftTopColor,frameLeftTopColor,frameRightBottomColor,frameRightBottomColor); }

    GX_FORCE_INLINE static void drawFrame( const GxRect& frameRect,const GxColor& frameColor ){ drawFrame(frameRect,frameColor,frameColor); }


    static void drawFrame( const GxRect& frameRect, b32 in, const GxColor& color );


    static void drawFrameRect( const GxRect& frameRect, b32 in, const GxColor& color );


    GX_FORCE_INLINE void drawFrame( const GxRect& frameRect, b32 in = false ){ drawFrame( frameRect,in,getWindowFrameColor() ); }


    GX_FORCE_INLINE void drawFrameRect( const GxRect& frameRect, b32 in = false ){ drawFrameRect( frameRect,in,getWindowFrameColor() ); }


    void drawSelectedRect( const GxRect& rect );


    static GxSize calculateStringSize( GX_CSTR string, u32 offset );

    static GxSize calculateStringSize(GxString::GxTokenizer& tokenizer);

    GX_FORCE_INLINE static GxSize calculateStringSize( GX_CSTR string){ return calculateStringSize(string, GX_STRLEN(string) ); }

    static GxSize calculateStringSizeLine( GX_CSTR string, u32 offset );

    GX_FORCE_INLINE static GxSize calculateStringSizeLine( GX_CSTR string){ return calculateStringSizeLine(string, GX_STRLEN(string) ); }

    static u32 getStringOffset( GX_CSTR string, u32 length );

    static u32 getStringOffsetUtf8( GX_CSTR string, u32 length );

    static u32 getStringOffsetSjis( GX_CSTR string, u32 length );


    GX_FORCE_INLINE static GxString clipString(GX_CSTR string, const GxSize& size, b32 clipTop = false) { GxString temporary(string); clipStringDirect(temporary, size, clipTop ); return temporary; }

    static void clipStringDirect( GxString& string, const GxSize& size, b32 clipTop = false);

    GX_FORCE_INLINE static GxString clipAndAddString( GX_CSTR string, const GxSize& size, b32 clipTop, GX_CSTR stringAdd){ GxString temporary(string); clipAndAddStringDirect(temporary, size, clipTop, stringAdd); return temporary; }

    static void clipAndAddStringDirect(GxString&, const GxSize& size, b32 clipTop, GX_CSTR stringAdd);

    static void clipAndAddStringDirectAndLineBreak( GxString& string, const GxSize& size, GX_CSTR stringAdd, u32 fontHeight );

    static void drawLayoutString( const GxRect& rect, GX_CSTR string, const GxColor& color, const GxFlag32Bit& layout );

    static GxRect calculateLayoutString( const GxRect& rect, GX_CSTR string, const GxFlag32Bit& layout );

    static GxRect calculateLayout( const GxRect& rect, const GxSize &size, const GxFlag32Bit& layout );


public:

    const GxGuiGraphics::GxIcon* getIcon(GX_HANDLE handle) const;

private:

    void calcIconUV(const GxPoint2& uv0, const GxPoint2& uv1, GxVector2& dstUv0, GxVector2& dstUv1) const;


    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    GX_FORCE_INLINE void            setWindowFrameColor( const GxColor& windowFrameColor ){ _windowFrameColor = windowFrameColor; }

    GX_FORCE_INLINE const GxColor&  getWindowFrameColor( void ) const { return _windowFrameColor; }


    GX_FORCE_INLINE void            setWindowBackColor( const GxColor& windowBackColor ){ _windowBackColor = windowBackColor; }

    GX_FORCE_INLINE const GxColor&  getWindowBackColor( void ) const { return _windowBackColor; }


    GX_FORCE_INLINE void            setTextColor( const GxColor& textColor ){ _textColor = textColor; }

    GX_FORCE_INLINE const GxColor&  getTextColor( void ) const { return _textColor; }


    GX_FORCE_INLINE void            setKeyWord1Color( const GxColor& keyWord1Color ){ _keyWord1Color = keyWord1Color; }

    GX_FORCE_INLINE const GxColor&  getKeyWord1Color( void ) const { return _keyWord1Color; }


    GX_FORCE_INLINE void            setKeyWord2Color( const GxColor& keyWord2Color ){ _keyWord2Color = keyWord2Color; }

    GX_FORCE_INLINE const GxColor&  getKeyWord2Color( void ) const { return _keyWord2Color; }


    GX_FORCE_INLINE void            setSelectedColor( const GxColor& selectedColor ){ _selectedColor = selectedColor; }

    GX_FORCE_INLINE const GxColor&  getSelectedColor( void ) const { return _selectedColor; }


    GX_FORCE_INLINE GxColor         getGrayOutColor( void ) const { return GxColor::getLerp( _textColor, _windowBackColor, 0.5f ); }


    // ドッキングガイドアイコンハンドル取得

    constexpr GX_HANDLE     getDockingGuideIconHandle( ICON_DOCKING_TYPE type ) const { return _hDockingIcon[static_cast<s32>(type)]; }


    // システムアイコンハンドル取得

    GX_HANDLE       getSystemIconHandle(GxRtti::ICON_TYPE type, bool isSize64 = false) const;


    GX_HANDLE       createIcon( GxResTexture* pResTexture, const GxVector2& uv0, const GxVector2& uv1 );


    GX_HANDLE       createIcon( GxResTexture* pResTexture, const GxRect& uvRect );


    void            deleteIcon( GX_HANDLE handle );


    void            loadIcon( GX_CSTR pFilePath, GX_HANDLE* pHandles );


    void            drawMouseCursor( const GxPoint2& position ) const;


    void            createMouseCursor( MOUSE_CURSOR mouseCursor, GxResTexture* pResTexture, const GxRect& rect );


    void            createMouseCursor( MOUSE_CURSOR mouseCursor, GxResTexture* pResTexture, const GxVector2& uv0, const GxVector2& uv1 );


    void            loadMouseIcon(void);


    constexpr void setMouseCursor( MOUSE_CURSOR mouseCursor ){ _mouseCursor = mouseCursor; }


    // プロパティ表示時のフレーム枠設定

    GX_FORCE_INLINE void setExpandFrameRect( const GxRect& rect ){ _expandFrameRect = rect; }


    // プロパティ表示時のフレーム枠取得

    GX_FORCE_INLINE const GxRect& getExpandFrameRect( void ) const { return _expandFrameRect; }


    void setButtonOffColorDefault( void );


    void setButtonOnColorDefault( void );


    void setButtonOffColor( const GxColor& color0, f32 value0, const GxColor& color1, f32 value1, const GxColor& color2, f32 value2, const GxColor& color3, f32 value3 );


    void setButtonOnColor( const GxColor& color0, f32 value0, const GxColor& color1, f32 value1, const GxColor& color2, f32 value2, const GxColor& color3, f32 value3 );


    void getButtonOffColor( GxColor& color0, f32& value0, GxColor& color1, f32& value1, GxColor& color2, f32& value2, GxColor& color3, f32& value3 ) const;


    void getButtonOnColor( GxColor& color0, f32& value0, GxColor& color1, f32& value1, GxColor& color2, f32& value2, GxColor& color3, f32& value3 ) const;


    void getButtonOffColor( GxColor color[], const GxColor& baseColor ) const;


    void getButtonOnColor( GxColor color[], const GxColor& baseColor ) const;


    //-----------------------------------------------------------

    //-----------------------------------------------------------

protected:

    GxColor                         _windowFrameColor;

    GxColor                         _windowBackColor;

    GxColor                         _textColor;

    GxColor                         _keyWord1Color;

    GxColor                         _keyWord2Color;

    GxColor                         _selectedColor;


    GxRect                          _expandFrameRect;


    // OffColor

    GxColor                         _buttonOffColor[ 4 ];

    f32                             _buttonOffColorRatio[ 4 ];


    // OnColor

    GxColor                         _buttonOnColor[ 4 ];

    f32                             _buttonOnColorRatio[ 4 ];


    GX_HANDLE                       _hDockingIcon[static_cast<s32>(ICON_DOCKING_TYPE::MAX)];


    GX_HANDLE                       _hSystemIcon[static_cast<s32>(GxRtti::ICON_TYPE::MAX)];

    GX_HANDLE                       _hSystemIcon64[static_cast<s32>(GxRtti::ICON_TYPE_64::MAX)];


    MOUSE_CURSOR                    _mouseCursor;

    GxPoint2                        _mouseCursorOffset;

    GxSize                          _mouseCursorSize;


    GxArrayClassBaseReference       _systemIconList;

    GxArrayClassBaseReference       _mouseIconList;


};


//===========================================================================

//===========================================================================

class GxGuiGraphics::GxIcon : public GxClassBaseReference

{

    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    // RTTI

    GX_RTTI_CLASS(GxIcon, GxClassBaseReference)

    // GxClassBase継承クラス用禁止宣言

    GX_PROHIBIT_CLASS_BASE(GxIcon)

    // new, delete定義

    GX_OPERATOR_NEW_DELETE(GxAllocatorList::ALLOCATOR_TYPE::DEVELOP)


    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    GxIcon(void);

    GxIcon(GxResTexture* pResTexture, const GxVector2& uv0, const GxVector2& uv1);


    void cleanup( void ) override;


    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    GX_HANDLE                   _handle;

    GxResTexture*               _pResTexture;

    GxVector2                   _uv0;

    GxVector2                   _uv1;


};


//===========================================================================

//===========================================================================

class GxGuiGraphics::GxMouseCursor : public GxClassBaseReference

{

    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    // RTTI

    GX_RTTI_CLASS(GxMouseCursor, GxClassBaseReference)

    // GxClassBaseReference継承クラス用禁止宣言

    GX_PROHIBIT_CLASS_BASE_REFERENCE(GxMouseCursor)

    // new, delete定義

    GX_OPERATOR_NEW_DELETE(GxAllocatorList::ALLOCATOR_TYPE::DEVELOP)


    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    GxMouseCursor(void);

    GxMouseCursor(MOUSE_CURSOR icon, GxResTexture* pResTexture, const GxVector2& uv0, const GxVector2& uv1);


    // 解放

    void cleanup( void ) override;


    //-----------------------------------------------------------

    //-----------------------------------------------------------

public:

    MOUSE_CURSOR                _id;

    GxResTexture*               _pResTexture;

    GxVector2                   _uv0;

    GxVector2                   _uv1;


};


// アクセスインターフェイス

GX_FORCE_INLINE GxGuiGraphics* getGxGuiGraphics(void){ return GxGuiGraphics::getSingletonPointer(); }


GX_CORE_NAMESPACE_END()


#endif  // GX_DEVELOP

GX_PROHIBIT_CLASS_BASE_REFERENCE
#define GX_PROHIBIT_CLASS_BASE_REFERENCE(__CLASS__)
GxClassBaseReference継承の禁止宣言(new以外の生成禁止 + コピー禁止)
Definition GxBase.h:244

GX_PROHIBIT_CLASS_BASE
#define GX_PROHIBIT_CLASS_BASE(__CLASS__)
GxClassBase継承の禁止宣言
Definition GxBase.h:240

OUTPUT_TYPE::MAX
@ MAX
定義数

GxTypedObject
void GxTypedObject
その他
Definition GxDefine.h:213

GX_HANDLE
u32 GX_HANDLE
ハンドル
Definition GxDefine.h:214

GX_STRLEN
#define GX_STRLEN(__STRING__)
文字列の長さ取得
Definition GxString.h:604

GxArrayClassBaseReference
参照カウンタ用配列クラス
Definition GxArrayClassBase.h:145

GxArray
配列クラス
Definition GxArray.h:18

GxClassBase
オブジェクト基底クラス
Definition GxBase.h:88

GxClassBaseReference
参照オブジェクト基底クラス
Definition GxBase.h:122

GxClassBaseReference::cleanup
virtual void cleanup(void)
delete直前に呼び出される関数
Definition GxBase.cpp:248

GxClassBaseRoot
基底クラス
Definition GxBase.h:51

GxClassBaseRoot::operator=
constexpr GxClassBaseRoot & operator=(const GxClassBaseRoot &)
代入演算子
Definition GxBase.h:64

GxCriticalSection
クリティカルセクションクラス
Definition GxThread.h:20

GxJson::GxJsonNode
JSON解析用ノード
Definition GxJson.h:108

GxList::GxNode
連結リストノードクラス
Definition GxList.h:106

GxList
連結リストクラス
Definition GxList.h:18

GxMath::VALUE_512
static constexpr u32 VALUE_512
512
Definition GxMath.h:128

GxMath::VALUE_1M
static constexpr u32 VALUE_1M
1M
Definition GxMath.h:139

GxProperty
プロパティクラス
Definition GxProperty.h:48

GxResTexture
テクスチャリソース
Definition GxResTexture.h:23

GxRtti
実行時型情報クラス
Definition GxRtti.h:154

GxRtti::ICON_TYPE
ICON_TYPE
アイコンタイプ定義
Definition GxRtti.h:202

GxRtti::ICON_TYPE::MAX
@ MAX
定義数

GxRtti::ICON_TYPE_64::MAX
@ MAX
定義数

SingletonBase
シングルトン基礎クラス
Definition GxSingleton.h:19

GxColor
色
Definition GxColor.h:21

GxColor::getLerp
static GX_FORCE_INLINE GxColor getLerp(const GxColor color0, const GxColor color1, f32 t)
補間値を取得(互換用)
Definition GxColor.inl:468

GxColor::WHITE
static const GxColor WHITE
白
Definition GxColor.h:37

GxFlag32Bit
ビット指定型フラグ
Definition GxStruct.h:1338

GxFlag32Index
インデックス指定型フラグ
Definition GxStruct.h:1294

GxPoint2
座標
Definition GxStruct.h:867

GxRect
矩形
Definition GxStruct.h:951

GxSize
サイズ
Definition GxStruct.h:730

GxString::GxTokenizer
トークン操作クラス
Definition GxString.h:337

GxString
文字列型クラス
Definition GxString.h:18

GxStructBase
Definition GxBase.h:24

GxVector2
2次元ベクトル
Definition GxVector.h:34

b32
32bitブーリアン
Definition GxDefine.h:173