ZFUICellAdapter.h

Go to the documentation of this file.

 
#ifndef _ZFI_ZFUICellAdapter_h_
#define _ZFI_ZFUICellAdapter_h_
 
#include "ZFUICell.h"
ZF_NAMESPACE_GLOBAL_BEGIN

zfinterface ZFLIB_ZFUIWidget ZFUICellAdapter : zfextend ZFInterface {
    ZFINTERFACE_DECLARE_WITH_CUSTOM_CTOR(ZFUICellAdapter, ZFInterface)
 
    // ============================================================
    // events
public:
    ZFEVENT(CellAdapterOnReload)
    ZFEVENT(CellOnUpdate)
    ZFEVENT(CellCacheOnRecycle)
 
    // ============================================================
    // owner state
private:
    ZFUIOrientation _ZFP_ZFUICellAdapter_orientation;
public:
    ZFMETHOD_DECLARE_0(ZFUIOrientation, orientation)
 
private:
    ZFUISize _ZFP_ZFUICellAdapter_containerSize;
public:
    ZFMETHOD_DECLARE_0(const ZFUISize &, containerSize)
 
public:
    ZFPROPERTY_ASSIGN(zffloat, cellSizeHint, ZFUIGlobalStyle::DefaultStyle()->itemSizeCell())
    ZFPROPERTY_ON_ATTACH_DECLARE(zffloat, cellSizeHint)

    ZFPROPERTY_ASSIGN(zfbool, cellSizeFill, zffalse)
    ZFPROPERTY_ON_ATTACH_DECLARE(zfbool, cellSizeFill)
 
    // ============================================================
    // basic cell access
public:
    ZFMETHOD_DECLARE_1(void, cellAdapterNotifyReload
            , ZFMP_IN_OPT(zfindex, atIndexOrMax, zfindexMax())
            )
    virtual zfindex cellCount(void) zfpurevirtual;
    virtual zfautoT<ZFUICell> cellAt(ZF_IN zfindex index) zfpurevirtual;
    ZFMETHOD_DECLARE_2(zffloat, cellSizeAt
            , ZFMP_IN(zfindex, index)
            , ZFMP_IN(ZFUICell *, cell)
            )
 
public:
    zffinal void notifyContainerUpdate(
            ZF_IN ZFUIOrientation orientation
            , ZF_IN const ZFUISize &containerSize
            ) {
        _ZFP_ZFUICellAdapter_orientation = orientation;
        _ZFP_ZFUICellAdapter_containerSize = containerSize;
    }

    zffinal void notifyCellAdapterReload(ZF_IN_OPT zfindex atIndexOrMax = zfindexMax()) {
        this->cellAdapterOnReload(atIndexOrMax);
    }

    zffinal void notifyCellUpdate(
            ZF_IN zfindex atIndex
            , ZF_IN ZFUICell *cell
            ) {
        this->cellOnUpdate(atIndex, cell);
    }

    zffinal zfauto notifyCellCacheAccess(ZF_IN zfindex index) {
        return this->cellCacheOnAccess(index);
    }

    zffinal void notifyCellCacheRecycle(ZF_IN ZFUICell *cell) {
        this->cellCacheOnRecycle(cell);
        this->toObject()->observerNotify(zfself::E_CellCacheOnRecycle(), cell);
    }
 
    // ============================================================
    // cell update callback
protected:
    virtual inline void cellAdapterOnReload(ZF_IN_OPT zfindex atIndexOrMax = zfindexMax()) {
        this->toObject()->observerNotify(zfself::E_CellAdapterOnReload(),
            (atIndexOrMax == zfindexMax()) ? zfnull : zfobj<v_zfindex>(atIndexOrMax).toObject());
    }

    virtual inline void cellOnUpdate(
            ZF_IN zfindex atIndex
            , ZF_IN ZFUICell *cell
            ) {
        this->toObject()->observerNotify(zfself::E_CellOnUpdate(), cell, zfobj<v_zfindex>(atIndex));
    }
 
    // ============================================================
    // cache logic
protected:
    virtual inline zfauto cellCacheOnAccess(ZF_IN zfindex index) {
        return zfnull;
    }

    virtual inline void cellCacheOnRecycle(ZF_IN ZFUICell *cell) {
    }
 
public:
    ZFMETHOD_DECLARE_1(zfautoT<ZFUICell>, cellCacheDefaultAccess
            , ZFMP_IN(const zfstring &, key)
            )
    ZFMETHOD_DECLARE_2(void, cellCacheDefaultRecycle
            , ZFMP_IN(const zfstring &, key)
            , ZFMP_IN(ZFUICell *, cell)
            )
 
protected:
    ZFUICellAdapter(void)
    : _ZFP_ZFUICellAdapter_orientation(v_ZFUIOrientation::e_Top)
    , _ZFP_ZFUICellAdapter_containerSize(ZFUISizeZero())
    {
    }
};
 
ZF_NAMESPACE_GLOBAL_END
#endif // #ifndef _ZFI_ZFUICellAdapter_h_