ZFUIRootWindow.h

Go to the documentation of this file.

 
#ifndef _ZFI_ZFUIRootWindow_h_
#define _ZFI_ZFUIRootWindow_h_
 
#include "ZFUIRootView.h"
ZF_NAMESPACE_GLOBAL_BEGIN
 
ZF_NAMESPACE_BEGIN(ZFGlobalEvent)
ZFEVENT_GLOBAL(ZFLIB_ZFUIKit, MainWindowOnAttach)
ZF_NAMESPACE_END(ZFGlobalEvent)
 
// ============================================================
zfclassFwd ZFUIRootWindowEmbedImpl;
zfclassFwd _ZFP_ZFUIRootWindowPrivate;
zffinal zfclass ZFLIB_ZFUIKit ZFUIRootWindow : zfextend ZFObject {
    ZFOBJECT_DECLARE(ZFUIRootWindow, ZFObject)
 
    // ============================================================
    // observer events
public:
    ZFEVENT(WindowOnCreate)
    ZFEVENT(WindowOnDestroy)
    ZFEVENT(WindowOnResume)
    ZFEVENT(WindowOnPause)
    ZFEVENT(WindowOnRotate)
    ZFEVENT(WindowMarginOnUpdate)

    ZFEVENT(WindowOnKeyEvent)
 
public:
    static zfautoT<ZFUIRootWindow> nativeWindowEmbed(ZF_IN ZFUIRootWindowEmbedImpl *embedImpl);

    virtual ZFUIRootWindowEmbedImpl *nativeWindowEmbedImpl(void);

    ZFMETHOD_DECLARE_0(void, nativeWindowEmbedImplDestroy)

    ZFMETHOD_DECLARE_STATIC_1(zfautoT<ZFUIRootWindow>, nativeWindowEmbedNativeView
            , ZFMP_IN(void *, nativeParent)
            )

    ZFMETHOD_DECLARE_STATIC_2(zfautoT<ZFUIRootWindow>, nativeWindowEmbedNativeView
            , ZFMP_IN(void *, nativeParent)
            , ZFMP_IN(const zfstring &, rootWindowName)
            )
    ZFMETHOD_DECLARE_STATIC_1(void, nativeWindowEmbedNativeViewCleanup
            , ZFMP_IN(const zfstring &, rootWindowName)
            )
 
public:
    ZFMETHOD_DECLARE_STATIC_1(void, mainWindowRegister
            , ZFMP_IN(ZFUIRootWindow *, window)
            )
    ZFMETHOD_DECLARE_STATIC_0(zfanyT<ZFUIRootWindow>, mainWindow)
    ZFMETHOD_DECLARE_STATIC_0(zfbool, mainWindowAttached)

    ZFMETHOD_DECLARE_STATIC_1(void, keyWindow
            , ZFMP_IN(ZFUIRootWindow *, window)
            )
    ZFMETHOD_DECLARE_STATIC_0(zfanyT<ZFUIRootWindow>, keyWindow)
 
public:
    ZFMETHOD_DECLARE_0(const ZFUISize &, windowSize)
 
public:
    ZFMETHOD_DECLARE_0(const ZFUIMargin &, windowMargin)
    void _ZFP_ZFUIRootWindow_windowMargin(ZF_IN const ZFUIMargin &windowMargin);
protected:
    virtual void windowMarginOnUpdate(ZF_IN const ZFUIMargin &windowMarginOld);
 
    ZFOBJECT_PRIVATE_ALLOC("can only be created by ZFUIRootWindow::modalWindowShow")
protected:
    zfoverride
    virtual void objectOnInit(void);
    zfoverride
    virtual void objectOnInitFinish(void);
    zfoverride
    virtual void objectOnDeallocPrepare(void);
    zfoverride
    virtual void objectOnDealloc(void);
 
public:
    ZFMETHOD_DECLARE_0(void *, nativeWindow)
 
public:
    ZFMETHOD_DECLARE_0(zfbool, nativeWindowIsCreated)
    ZFMETHOD_DECLARE_0(zfbool, nativeWindowIsResumed)
 
public:
    ZFMETHOD_DECLARE_0(ZFUIOrientation, windowOrientation)
    ZFMETHOD_DECLARE_1(void, windowOrientationFlags
            , ZFMP_IN(const ZFUIOrientationFlags &, windowOrientationFlags)
            )
    ZFMETHOD_DECLARE_0(const ZFUIOrientationFlags &, windowOrientationFlags)

    ZFPROPERTY_ASSIGN(zfbool, preferFullscreen, zffalse)
    ZFPROPERTY_ON_UPDATE_DECLARE(zfbool, preferFullscreen)
 
public:
    ZFMETHOD_DECLARE_0(zfautoT<ZFUIRootWindow>, modalWindowShow)
    ZFMETHOD_DECLARE_0(void, modalWindowHide)
    ZFMETHOD_DECLARE_0(zfanyT<ZFUIRootWindow>, modalWindowShowing)
    ZFMETHOD_DECLARE_0(zfanyT<ZFUIRootWindow>, modalWindowOwner)
 
public:
    ZFMETHOD_DECLARE_0(zfanyT<ZFUILayoutParam>, layoutParam)

    ZFMETHOD_DECLARE_0(zfanyT<ZFUIRootView>, rootView)
 
public:
    zffinal ZFUIRect _ZFP_ZFUIRootWindow_measureWindow(ZF_IN const ZFUIRect &rootRefRect);
    zffinal void _ZFP_ZFUIRootWindow_onCreate(ZF_IN void *nativeWindow);
    zffinal void _ZFP_ZFUIRootWindow_onDestroy(void);
    zffinal void _ZFP_ZFUIRootWindow_onResume(void);
    zffinal void _ZFP_ZFUIRootWindow_onPause(void);
    zffinal void _ZFP_ZFUIRootWindow_onRotate(void);
    zffinal void _ZFP_ZFUIRootWindow_layoutUpdate(void);
    zffinal void _ZFP_ZFUIRootWindow_keyEvent(ZF_IN ZFUIKeyEvent *event) {
        this->observerNotify(ZFUIRootWindow::E_WindowOnKeyEvent(), event);
    }
 
private:
    _ZFP_ZFUIRootWindowPrivate *d;
};
 
// ============================================================
zfinterface ZFLIB_ZFUIKit ZFUIRootWindowEmbedImpl : zfextend ZFInterface {
    ZFINTERFACE_DECLARE_WITH_CUSTOM_CTOR(ZFUIRootWindowEmbedImpl, ZFInterface)
 
public:
    zfanyT<ZFUIRootWindow> _ZFP_ownerZFUIRootWindow;
    inline zfanyT<ZFUIRootWindow> const &ownerZFUIRootWindow(void) {
        return this->_ZFP_ownerZFUIRootWindow;
    }
 
public:
    ZFUIRootWindowEmbedImpl(void) : _ZFP_ownerZFUIRootWindow(zfnull) {}
 
    // ============================================================
public:
    virtual void nativeWindowOnCleanup(ZF_IN ZFUIRootWindow *rootWindow) {
    }

    virtual void nativeWindowRootViewOnAdd(
            ZF_IN ZFUIRootWindow *rootWindow
            , ZF_OUT_OPT void *&nativeParentView
            ) zfpurevirtual;
    virtual void nativeWindowRootViewOnRemove(ZF_IN ZFUIRootWindow *rootWindow) zfpurevirtual;

    virtual zfautoT<ZFUIRootWindow> modalWindowShow(ZF_IN ZFUIRootWindow *owner) zfpurevirtual;
    virtual void modalWindowHide(
            ZF_IN ZFUIRootWindow *owner
            , ZF_IN ZFUIRootWindow *toHide
            ) zfpurevirtual;

    virtual void layoutParamOnInit(ZF_IN ZFUIRootWindow *rootWindow) {
    }

    virtual void layoutParamOnUpdate(ZF_IN ZFUIRootWindow *rootWindow) {
    }

    virtual ZFUIOrientation windowOrientation(ZF_IN ZFUIRootWindow *rootWindow) {
        return v_ZFUIOrientation::e_Top;
    }

    virtual void windowOrientationFlags(
            ZF_IN ZFUIRootWindow *rootWindow
            , ZF_IN const ZFUIOrientationFlags &flags
            ) {
    }
 
    // ============================================================
    // callbacks that implementations must notify
public:
    zffinal ZFUIRect notifyMeasureWindow(
            ZF_IN ZFUIRootWindow *rootWindow
            , ZF_IN const ZFUIRect &rootRefRect
            , ZF_IN const ZFUIMargin &windowMargin
            ) {
        rootWindow->_ZFP_ZFUIRootWindow_windowMargin(windowMargin);
        return rootWindow->_ZFP_ZFUIRootWindow_measureWindow(rootRefRect);
    }

    zffinal void notifyOnCreate(
            ZF_IN ZFUIRootWindow *rootWindow
            , ZF_IN void *nativeWindow
            ) {
        rootWindow->_ZFP_ZFUIRootWindow_onCreate(nativeWindow);
    }

    zffinal void notifyOnDestroy(ZF_IN ZFUIRootWindow *rootWindow) {
        rootWindow->_ZFP_ZFUIRootWindow_onDestroy();
    }

    zffinal void notifyOnResume(ZF_IN ZFUIRootWindow *rootWindow) {
        rootWindow->_ZFP_ZFUIRootWindow_onResume();
    }

    zffinal void notifyOnPause(ZF_IN ZFUIRootWindow *rootWindow) {
        rootWindow->_ZFP_ZFUIRootWindow_onPause();
    }

    zffinal void notifyOnRotate(ZF_IN ZFUIRootWindow *rootWindow) {
        rootWindow->_ZFP_ZFUIRootWindow_onRotate();
    }

    zffinal void notifyKeyEvent(
            ZF_IN ZFUIRootWindow *rootWindow
            , ZF_IN ZFUIKeyEvent *event
            ) {
        rootWindow->_ZFP_ZFUIRootWindow_keyEvent(event);
    }
};
 
ZF_NAMESPACE_GLOBAL_END
#endif // #ifndef _ZFI_ZFUIRootWindow_h_