ZFUIView.h

Go to the documentation of this file.

 
#ifndef _ZFI_ZFUIView_h_
#define _ZFI_ZFUIView_h_
 
#include "ZFUIViewType.h"
#include "ZFUIMouseEvent.h"
#include "ZFUIKeyEvent.h"
#include "ZFUIWheelEvent.h"
 
ZF_NAMESPACE_GLOBAL_BEGIN

#define ZFSerializableKeyword_ZFUIView_internalImplView "internalImplView"
#define ZFSerializableKeyword_ZFUIView_internalBgView "internalBgView"
#define ZFSerializableKeyword_ZFUIView_internalFgView "internalFgView"

#define ZFSerializableKeyword_ZFUIView_child "child"
#define ZFSerializableKeyword_ZFUIView_layoutParam "layoutParam"
 
// ============================================================
zfclassFwd ZFUIView;
typedef void (*ZFUIViewNativeImplViewDeleteCallback)(ZF_IN zfanyT<ZFUIView> const &view);
 
// ============================================================
// ZFUIView
zfclassFwd _ZFP_ZFUIViewPrivate;
zfclass ZFLIB_ZFUIKit ZFUIView : zfextend ZFStyle {
    ZFOBJECT_DECLARE(ZFUIView, ZFStyle)
    ZFSTYLE_DEFAULT_DECLARE(ZFUIView)
 
public:
    // ============================================================
    // events
    ZFEVENT(ViewTreeInWindowOnUpdate)
    ZFEVENT(ViewTreeVisibleOnUpdate)
    ZFEVENT(ViewChildOnUpdate)
    ZFEVENT(ViewChildOnAdd)
    ZFEVENT(ViewChildOnRemove)
    ZFEVENT(ViewOnAddToParent)
    ZFEVENT(ViewOnRemoveFromParent)
    ZFEVENT(UIScaleOnUpdate)
    ZFEVENT(ViewFocusOnUpdate)
    ZFEVENT(ViewOnEvent)
    ZFEVENT(ViewLayoutOnLayoutRequest)
    ZFEVENT(ViewLayoutOnMeasurePrepare)
    ZFEVENT(ViewLayoutOnMeasure)
    ZFEVENT(ViewLayoutOnLayoutPrepare)
    ZFEVENT(ViewLayoutOnLayout)
    ZFEVENT(ViewLayoutOnLayoutFinish)
    ZFEVENT(NativeImplViewMarginOnUpdate)
 
    // ============================================================
    // serialize
public:
    virtual void serializableRefLayoutParam(ZF_IN ZFUILayoutParam *serializableRefLayoutParam);
    virtual ZFUILayoutParam *serializableRefLayoutParam(void);
    virtual ZFUILayoutParam *serializableRefLayoutParamCheckInit(void);
protected:
    zfoverride
    virtual zfbool serializableOnSerializeFromData(
            ZF_IN const ZFSerializableData &serializableData
            , ZF_OUT_OPT zfstring *outErrorHint = zfnull
            , ZF_OUT_OPT ZFSerializableData *outErrorPos = zfnull
            );
    zfoverride
    virtual zfbool serializableOnSerializeToData(
            ZF_IN_OUT ZFSerializableData &serializableData
            , ZF_OUT_OPT zfstring *outErrorHint = zfnull
            , ZF_IN_OPT ZFSerializable *refOwner = zfnull
            );
    virtual inline zfbool serializableOnCheckNeedSerializeChildren(void) {
        return zftrue;
    }
 
public:
    // ============================================================
    // properties
    ZFPROPERTY_ASSIGN(zfstring, viewId)
 
    
    ZFPROPERTY_ASSIGN(zfbool, visible, zftrue)
    ZFPROPERTY_ON_ATTACH_DECLARE(zfbool, visible)

    ZFMETHOD_DECLARE_0(zfbool, viewTreeInWindow)
    ZFMETHOD_DECLARE_0(zfbool, viewTreeVisible)
 
    zffinal void _ZFP_ZFUIView_viewTreeInWindow(ZF_IN zfbool viewTreeInWindow);

    ZFPROPERTY_ASSIGN(zffloat, alpha, 1)
    ZFPROPERTY_ON_UPDATE_DECLARE(zffloat, alpha)
    ZFPROPERTY_ON_ATTACH_DECLARE(zffloat, alpha)

    ZFPROPERTY_ASSIGN(zfbool, viewUIEnable, zftrue)
    ZFPROPERTY_ON_ATTACH_DECLARE(zfbool, viewUIEnable)

    ZFPROPERTY_ASSIGN(zfbool, viewUIEnableTree, zftrue)
    ZFPROPERTY_ON_ATTACH_DECLARE(zfbool, viewUIEnableTree)

    ZFMETHOD_DECLARE_0(zfbool, viewUIEnableFixed)
    ZFMETHOD_DECLARE_0(zfbool, viewUIEnableTreeFixed)

    ZFPROPERTY_ASSIGN(zfbool, mouseHoverEnable)
    ZFPROPERTY_ON_ATTACH_DECLARE(zfbool, mouseHoverEnable)

    ZFPROPERTY_ASSIGN(zfbool, focusable)
    ZFPROPERTY_ON_ATTACH_DECLARE(zfbool, focusable)
    ZFPROPERTY_ASSIGN(zfbool, focusObtainWhenClick, zftrue)

    ZFMETHOD_DECLARE_0(ZFUIRect const &, viewFrame)
    ZFMETHOD_DECLARE_1(void, viewFrame
            , ZFMP_IN(ZFUIRect const &, viewFrame)
            )

    ZFMETHOD_DECLARE_0(const ZFUIRect &, viewFramePrev)

    ZFMETHOD_DECLARE_0(zfbool, viewFrameOverrided)

    ZFMETHOD_DECLARE_0(void, viewFrameReset)

    ZFMETHOD_DECLARE_0(zffloat, x)
    ZFMETHOD_DECLARE_1(void, x
            , ZFMP_IN(zffloat const &, propertyValue)
            )
    ZFMETHOD_DECLARE_0(zffloat, y)
    ZFMETHOD_DECLARE_1(void, y
            , ZFMP_IN(zffloat const &, propertyValue)
            )
    ZFMETHOD_DECLARE_0(zffloat, width)
    ZFMETHOD_DECLARE_1(void, width
            , ZFMP_IN(zffloat const &, propertyValue)
            )
    ZFMETHOD_DECLARE_0(zffloat, height)
    ZFMETHOD_DECLARE_1(void, height
            , ZFMP_IN(zffloat const &, propertyValue)
            )
    ZFMETHOD_DECLARE_0(zffloat, centerX)
    ZFMETHOD_DECLARE_1(void, centerX
            , ZFMP_IN(zffloat const &, propertyValue)
            )
    ZFMETHOD_DECLARE_0(zffloat, centerY)
    ZFMETHOD_DECLARE_1(void, centerY
            , ZFMP_IN(zffloat const &, propertyValue)
            )

    ZFMETHOD_DECLARE_1(void, viewSizeFixed
            , ZFMP_IN(const ZFUISize &, size)
            )
    ZFMETHOD_DECLARE_2(void, viewSizeFixed
            , ZFMP_IN(zffloat, width)
            , ZFMP_IN(zffloat, height)
            )
    ZFPROPERTY_ASSIGN(ZFUISize, viewSizeMin)
    ZFPROPERTY_ON_ATTACH_DECLARE(ZFUISize, viewSizeMin)
    ZFPROPERTY_ASSIGN(ZFUISize, viewSizeMax, ZFUISizeInvalid())
    ZFPROPERTY_ON_ATTACH_DECLARE(ZFUISize, viewSizeMax)

    ZFPROPERTY_ASSIGN(ZFUIColor, bgColor, ZFUIColorZero())
    ZFPROPERTY_ON_ATTACH_DECLARE(ZFUIColor, bgColor)
 
    // ============================================================
    // transform
    ZFMETHOD_DECLARE_STATIC_0(ZFUITransformFlags, transformAvailable)

    ZFPROPERTY_ASSIGN(zffloat, translateX, 0)
    ZFPROPERTY_ON_ATTACH_DECLARE(zffloat, translateX)
    ZFPROPERTY_ASSIGN(zffloat, translateY, 0)
    ZFPROPERTY_ON_ATTACH_DECLARE(zffloat, translateY)
    ZFPROPERTY_ASSIGN(zffloat, translateZ, 0)
    ZFPROPERTY_ON_ATTACH_DECLARE(zffloat, translateZ)

    ZFPROPERTY_ASSIGN(zffloat, scaleX, 1)
    ZFPROPERTY_ON_UPDATE_DECLARE(zffloat, scaleX)
    ZFPROPERTY_ASSIGN(zffloat, scaleY, 1)
    ZFPROPERTY_ON_UPDATE_DECLARE(zffloat, scaleY)
    ZFPROPERTY_ASSIGN(zffloat, scaleZ, 1)
    ZFPROPERTY_ON_UPDATE_DECLARE(zffloat, scaleZ)

    ZFPROPERTY_ASSIGN(zffloat, rotateX, 0)
    ZFPROPERTY_ON_UPDATE_DECLARE(zffloat, rotateX)
    ZFPROPERTY_ASSIGN(zffloat, rotateY, 0)
    ZFPROPERTY_ON_UPDATE_DECLARE(zffloat, rotateY)
    ZFPROPERTY_ASSIGN(zffloat, rotateZ, 0)
    ZFPROPERTY_ON_UPDATE_DECLARE(zffloat, rotateZ)
 
    // ============================================================
    // util
public:
    ZFMETHOD_DECLARE_2(void, bind
            , ZFMP_IN(ZFObject *, owner)
            , ZFMP_IN(const zfstring &, propertyName)
            )
    ZFMETHOD_DECLARE_3(void, bindEvent
            , ZFMP_IN(const zfstring &, eventName)
            , ZFMP_IN(ZFObject *, owner)
            , ZFMP_IN(const zfstring &, methodName)
            )
    ZFMETHOD_DECLARE_3(void, bindEvent
            , ZFMP_IN(zfidentity, eventId)
            , ZFMP_IN(ZFObject *, owner)
            , ZFMP_IN(const zfstring &, methodName)
            )
 
    // ============================================================
    // init and dealloc
protected:
    zfoverride
    virtual void objectOnInit(void);
    zfoverride
    virtual void objectOnDealloc(void);
    zfoverride
    virtual void objectOnDeallocPrepare(void);
 
protected:
    zfoverride
    virtual void objectInfoImplAppend(ZF_IN_OUT zfstring &ret);
 
    // ============================================================
public:
    ZFMETHOD_DECLARE_0(void *, nativeImplView)
    ZFMETHOD_DECLARE_0(const ZFUIMargin &, nativeImplViewMargin)
    ZFMETHOD_DECLARE_0(void, nativeImplViewMarginUpdate)
    ZFMETHOD_DECLARE_0(const ZFUIRect &, nativeImplViewFrame)
 
protected:
    virtual void nativeImplView(
            ZF_IN void *nativeImplView
            , ZF_IN ZFUIViewNativeImplViewDeleteCallback nativeImplViewDeleteCallback
            );
    virtual inline void nativeImplViewMarginImplUpdate(ZF_IN_OUT ZFUIMargin &nativeImplViewMargin) {
    }

    virtual inline void nativeImplViewMarginOnUpdate(void) {
        this->observerNotify(ZFUIView::E_NativeImplViewMarginOnUpdate());
    }

    virtual void nativeImplViewOnLayout(
            ZF_OUT ZFUIRect &ret
            , ZF_IN const ZFUIRect &bounds
            , ZF_IN const ZFUIMargin &nativeImplViewMargin
            ) {
        ZFUIRectApplyMarginT(ret, bounds, nativeImplViewMargin);
    }
 
    // ============================================================
protected:
    virtual void implChildOnAdd(
            ZF_IN ZFUIView *child
            , ZF_IN zfindex virtualIndex
            , ZF_IN ZFUIViewChildLayer childLayer
            , ZF_IN zfindex childLayerIndex
            );
    virtual void implChildOnRemove(
            ZF_IN ZFUIView *child
            , ZF_IN zfindex virtualIndex
            , ZF_IN ZFUIViewChildLayer childLayer
            , ZF_IN zfindex childLayerIndex
            );
    virtual void implChildOnRemoveAllForDealloc(void);
 
public:
    ZFMETHOD_DECLARE_0(void *, nativeView)
    static void _ZFP_ZFUIView_nativeViewNotifyAdd(
            ZF_IN ZFUIView *view
            , ZF_IN void *nativeParentView
            );
    static void _ZFP_ZFUIView_nativeViewNotifyRemove(ZF_IN ZFUIView *view);
 
    // ============================================================
    // view focus
public:
    ZFMETHOD_DECLARE_0(zfbool, focused)
    ZFMETHOD_DECLARE_1(void, focusRequest
            , ZFMP_IN(zfbool, focus)
            )
    zffinal void _ZFP_ZFUIView_focusOnUpdate(void) {
        this->focusOnUpdate();
    }
    ZFMETHOD_DECLARE_0(zfanyT<ZFUIView>, focusFind)
protected:
    virtual inline void focusOnUpdate(void) {
        this->observerNotify(ZFUIView::E_ViewFocusOnUpdate());
    }
 
    // ============================================================
    // parent
public:
    zffinal void _ZFP_ZFUIView_parentOnUpdate(
            ZF_IN ZFUIView *parentView
            , ZF_IN ZFUILayoutParam *layoutParam
            , ZF_IN ZFUIViewChildLayer viewLayer
            );
    ZFMETHOD_DECLARE_0(zfanyT<ZFUIView>, parent)
 
    
    ZFMETHOD_DECLARE_0(void, removeFromParent)
 
    // ============================================================
    // scale settings
public:
    ZFPROPERTY_ASSIGN(zffloat, UIScale, 1)
    ZFPROPERTY_ON_UPDATE_DECLARE(zffloat, UIScale)
    ZFPROPERTY_ON_ATTACH_DECLARE(zffloat, UIScale)
    ZFMETHOD_DECLARE_0(zffloat, UIScaleInherited)
    ZFMETHOD_DECLARE_0(zffloat, UIScaleForImpl)
    ZFMETHOD_DECLARE_0(zffloat, UIScaleForPixel)
    ZFMETHOD_DECLARE_0(zffloat, UIScaleFixed)
protected:
    virtual void UIScaleOnUpdate(void);
 
    // ============================================================
    // layout logic
public:
    ZFMETHOD_DECLARE_0(zfautoT<ZFUILayoutParam>, layoutParamCreate)
protected:
    virtual const ZFClass *layoutParamClass(void);
    virtual inline void layoutParamOnUpdate(ZF_IN ZFUILayoutParam *layoutParam) {
    }
 
public:
    ZFMETHOD_DECLARE_1(void, layoutParam
            , ZFMP_IN(ZFUILayoutParam *, layoutParam)
            )
    ZFMETHOD_DECLARE_0(zfanyT<ZFUILayoutParam>, layoutParam)
 
public:
    ZFMETHOD_DECLARE_0(void, layoutRequest)
    ZFMETHOD_DECLARE_0(zfbool, layoutRequested)
    ZFMETHOD_DECLARE_0(zfbool, layouting)
    ZFMETHOD_DECLARE_2(const ZFUISize &, layoutMeasure
            , ZFMP_IN(const ZFUISize &, sizeHintOrig)
            , ZFMP_IN(const ZFUISizeParam &, sizeParam)
            )
    ZFMETHOD_DECLARE_0(const ZFUISize &, layoutMeasuredSize)
    ZFMETHOD_DECLARE_0(void, layoutIfNeed)
    ZFMETHOD_DECLARE_0(ZFUIPoint, layoutChildOffset)
 
public:
    void _ZFP_ZFUIView_notifyLayoutView(ZF_IN const ZFUIRect &viewFrame);
protected:
    virtual void layoutOnLayoutRequest(void);
    virtual inline void layoutOnMeasurePrepare(
            ZF_IN const ZFUISize &sizeHintOrig
            , ZF_IN const ZFUISizeParam &sizeParam
            ) {
    }

    virtual inline void layoutOnMeasure(
            ZF_OUT ZFUISize &ret
            , ZF_IN const ZFUISize &sizeHint
            , ZF_IN const ZFUISizeParam &sizeParam
            ) {
    }

    virtual inline void layoutOnMeasureFinish(
            ZF_IN_OUT ZFUISize &measuredSize
            , ZF_IN const ZFUISize &sizeHint
            , ZF_IN const ZFUISizeParam &sizeParam
            ) {
    }

    virtual inline void layoutOnLayoutPrepare(ZF_IN const ZFUIRect &bounds) {
    }

    virtual void layoutOnLayout(ZF_IN const ZFUIRect &bounds);
    virtual inline void layoutOnLayoutFinish(ZF_IN const ZFUIRect &bounds) {
    }

    virtual inline void layoutChildOffsetOnUpdate(ZF_IN_OUT ZFUIPoint &ret) {
    }
 
    // ============================================================
    // children management
public:
    ZFMETHOD_DECLARE_3(zfanyT<ZFUIView>, childFindById
            , ZFMP_IN(const zfstring &, viewId)
            , ZFMP_IN_OPT(zfbool, findRecursively, zftrue)
            , ZFMP_IN_OPT(zfbool, includeInternalViews, zffalse)
            )
    ZFMETHOD_DECLARE_3(zfanyT<ZFUIView>, childFindByClass
            , ZFMP_IN(const ZFClass *, cls)
            , ZFMP_IN_OPT(zfbool, findRecursively, zftrue)
            , ZFMP_IN_OPT(zfbool, includeInternalViews, zffalse)
            )
    ZFMETHOD_DECLARE_3(zfauto, childForEach
            , ZFMP_IN(const ZFListener &, impl)
            , ZFMP_IN_OPT(zfbool, findRecursively, zftrue)
            , ZFMP_IN_OPT(zfbool, includeInternalViews, zffalse)
            )
 
public:
    zffinal zfanyT<ZFUILayoutParam> child(
            ZF_IN const zfany &view
            , ZF_IN_OPT zfindex atIndex = zfindexMax()
            );
    ZFMETHOD_DECLARE_1(void, childRemove
            , ZFMP_IN(ZFUIView *, view)
            )
    ZFMETHOD_DECLARE_1(void, childRemoveAt
            , ZFMP_IN(zfindex, index)
            )
    ZFMETHOD_DECLARE_0(void, childRemoveAll)
    ZFMETHOD_DECLARE_2(void, childMove
            , ZFMP_IN(zfindex, fromIndex)
            , ZFMP_IN(zfindex, toIndexOrIndexMax)
            )
    ZFMETHOD_DECLARE_2(void, childMove
            , ZFMP_IN(ZFUIView *, child)
            , ZFMP_IN(zfindex, toIndexOrIndexMax)
            )
    ZFMETHOD_DECLARE_2(void, childReplaceAt
            , ZFMP_IN(zfindex, atIndex)
            , ZFMP_IN(ZFUIView *, toReplace)
            )
    ZFMETHOD_DECLARE_0(zfindex, childCount)
    ZFMETHOD_DECLARE_1(zfanyT<ZFUIView>, childAt
            , ZFMP_IN(zfindex, index)
            )
    ZFMETHOD_DECLARE_1(zfindex, childFind
            , ZFMP_IN(ZFUIView *, view)
            )
    ZFMETHOD_DECLARE_0(ZFCoreArray<zfautoT<ZFUIView> >, childArray)

    ZFMETHOD_DECLARE_0(ZFUIViewChildLayer, viewLayer)
    ZFMETHOD_DECLARE_0(ZFCoreArray<zfautoT<ZFUIView> >, childRawArray)
 
    // ============================================================
    // events
protected:
    virtual void viewTreeInWindowOnUpdate(void);
    virtual void viewTreeVisibleOnUpdate(void);
    virtual void viewChildOnUpdate(void);
    virtual void viewChildOnAdd(
            ZF_IN ZFUIView *child
            , ZF_IN ZFUIViewChildLayer childLayer
            );
    virtual void viewChildOnRemove(
            ZF_IN ZFUIView *child
            , ZF_IN ZFUIViewChildLayer childLayer
            );
    virtual void viewOnAddToParent(ZF_IN ZFUIView *parent);
    virtual void viewOnRemoveFromParent(ZF_IN ZFUIView *parent);
 
    // ============================================================
    // internal views
public:
    ZFMETHOD_DECLARE_2(zfanyT<ZFUILayoutParam>, internalImplView
            , ZFMP_IN(ZFUIView *, view)
            , ZFMP_IN_OPT(zfindex, atIndex, zfindexMax())
            )
    ZFMETHOD_DECLARE_1(void, internalImplViewRemove
            , ZFMP_IN(ZFUIView *, view)
            )
    ZFMETHOD_DECLARE_0(ZFCoreArray<zfautoT<ZFUIView> >, internalImplViewArray)
 
public:
    ZFMETHOD_DECLARE_2(zfanyT<ZFUILayoutParam>, internalBgView
            , ZFMP_IN(ZFUIView *, view)
            , ZFMP_IN_OPT(zfindex, atIndex, zfindexMax())
            )
    ZFMETHOD_DECLARE_1(void, internalBgViewRemove
            , ZFMP_IN(ZFUIView *, view)
            )
    ZFMETHOD_DECLARE_0(ZFCoreArray<zfautoT<ZFUIView> >, internalBgViewArray)
 
public:
    ZFMETHOD_DECLARE_2(zfanyT<ZFUILayoutParam>, internalFgView
            , ZFMP_IN(ZFUIView *, view)
            , ZFMP_IN_OPT(zfindex, atIndex, zfindexMax())
            )
    ZFMETHOD_DECLARE_1(void, internalFgViewRemove
            , ZFMP_IN(ZFUIView *, view)
            )
    ZFMETHOD_DECLARE_0(ZFCoreArray<zfautoT<ZFUIView> >, internalFgViewArray)
 
    // ============================================================
    // other internal view logic
public:
    ZFMETHOD_DECLARE_1(void, internalViewAutoSerializeTagAdd
            , ZFMP_IN(const zfstring &, tag)
            )
    ZFMETHOD_DECLARE_1(void, internalViewAutoSerializeTagRemove
            , ZFMP_IN(const zfstring &, tag)
            )
    ZFMETHOD_DECLARE_0(void, internalViewAutoSerializeTagRemoveAll)
    ZFMETHOD_DECLARE_1(void, internalViewAutoSerializeTagGetAllT
            , ZFMP_IN_OUT(ZFCoreArray<zfstring> &, ret)
            )
    ZFMETHOD_DECLARE_0(ZFCoreArray<zfstring>, internalViewAutoSerializeTagGetAll)
 
protected:
    virtual inline zfbool internalViewShouldLayout(ZF_IN ZFUIView *internalView) {
        return zftrue;
    }

    virtual void internalViewOnLayout(ZF_IN const ZFUIRect &bounds);
 
    // ============================================================
    // UI events
public:
    ZFMETHOD_DECLARE_1(void, viewEventSend
            , ZFMP_IN(ZFUIEvent *, event)
            )
protected:
    virtual void viewEventOnEvent(ZF_IN ZFUIEvent *event);
 
    // ============================================================
    // events
protected:
    virtual void viewEventOnMouseEvent(ZF_IN ZFUIMouseEvent *mouseEvent);

    virtual void viewEventOnKeyEvent(ZF_IN ZFUIKeyEvent *keyEvent);
    virtual void viewEventOnKeyEventResolveFocus(ZF_IN ZFUIKeyEvent *keyEvent);

    virtual void viewEventOnWheelEvent(ZF_IN ZFUIWheelEvent *wheelEvent);
 
    // ============================================================
    // utils
public:
    ZFMETHOD_DECLARE_0(void, showByWindow)
    ZFMETHOD_DECLARE_0(void, hideByWindow)
 
    // ============================================================
    // override
protected:
    zfoverride
    virtual void styleableOnCopyFrom(ZF_IN ZFObject *anotherStyleable);
 
protected:
    zfoverride
    virtual void observerOnAdd(ZF_IN zfidentity eventId);
    zfoverride
    virtual void observerOnRemove(ZF_IN zfidentity eventId);
 
private:
    _ZFP_ZFUIViewPrivate *d;
    friend zfclassFwd _ZFP_ZFUIViewPrivate;
};
 
ZF_NAMESPACE_GLOBAL_END
#endif // #ifndef _ZFI_ZFUIView_h_