ZFStyleable.h

Go to the documentation of this file.

 
#ifndef _ZFI_ZFStyleable_h_
#define _ZFI_ZFStyleable_h_
 
#include "ZFSerializable.h"
#include "ZFObjectObserver.h"
ZF_NAMESPACE_GLOBAL_BEGIN
 
// ============================================================
// ZFStyleable
zfclassFwd _ZFP_ZFStyleKeyHolder;
zfinterface ZFLIB_ZFCore ZFStyleable : zfextend ZFInterface {
    ZFINTERFACE_DECLARE(ZFStyleable, ZFInterface)
 
public:
    virtual zfautoT<ZFStyleable> copy(void);
    virtual void copyFrom(ZF_IN ZFObject *anotherStyleable);
 
public:
    virtual zfanyT<ZFStyleable> defaultStyle(void);
    virtual zfbool styleableIsDefaultStyle(void) {
        return zffalse;
    }

    zffinal void styleablePropertyGetAllT(
            ZF_OUT ZFCoreArray<const ZFProperty *> &ret
            );
    zffinal ZFCoreArray<const ZFProperty *> styleablePropertyGetAll(void);
 
protected:
    virtual void styleableOnCopyPropertyFrom(
            ZF_IN ZFObject *anotherStyleable
            , ZF_IN const ZFProperty *property
            );
    virtual void styleableOnCopyFrom(ZF_IN ZFObject *anotherStyleable);
 
public:
    zffinal void styleKey(ZF_IN const zfstring &styleKey);
    zffinal const zfstring &styleKey(void);
    zffinal void propStyle(
            ZF_IN const zfstring &propertyName
            , ZF_IN const zfstring &styleKey
            );
    zffinal const zfstring &propStyle(ZF_IN const zfstring &propertyName);
private:
    friend zfclassFwd _ZFP_ZFStyleKeyHolder;
 
    // ============================================================
public:
    zffinal zfbool progressUpdate(
            ZF_IN ZFStyleable *from
            , ZF_IN ZFStyleable *to
            , ZF_IN zffloat progress
            );
 
protected:
    virtual inline zfbool progressOnUpdate(
            ZF_IN ZFStyleable *from
            , ZF_IN ZFStyleable *to
            , ZF_IN zffloat progress
            ) {
        return zffalse;
    }
};
 
// ============================================================
// ZFStyle
zfclass ZFLIB_ZFCore ZFStyle : zfextend ZFObject, zfimplement ZFStyleable, zfimplement ZFSerializable {
    ZFOBJECT_DECLARE(ZFStyle, ZFObject)
    ZFIMPLEMENT_DECLARE(ZFStyleable, ZFSerializable)
};
 
// ============================================================
// DefaultStyle
#define _ZFP_ZFStyleableDefault_level ZFLevelZFFrameworkHigh
extern ZFLIB_ZFCore void **_ZFP_ZFStyleableDefaultRefAccess(ZF_IN const zfstring &name);
typedef void (*_ZFP_ZFStyleableDefaultDeleteCallback)(ZF_IN void *instance);
zfclassLikePOD ZFLIB_ZFCore _ZFP_ZFStyleableDefaultDeleteCallbackHolder {
public:
    _ZFP_ZFStyleableDefaultDeleteCallbackHolder(
            ZF_IN _ZFP_ZFStyleableDefaultDeleteCallback deleteCallback
            , ZF_IN void *instance
            )
    : deleteCallback(deleteCallback)
    , instance(instance)
    {
    }
    ~_ZFP_ZFStyleableDefaultDeleteCallbackHolder(void) {
        if(this->deleteCallback && this->instance) {
            this->deleteCallback(this->instance);
        }
    }
private:
    _ZFP_ZFStyleableDefaultDeleteCallback deleteCallback;
    void *instance;
};
 
#define _ZFP_ZFSTYLE_DEFAULT_DECLARE(YourStyle) \
    public: \
        zfclass _ZFP_StyleDef_##YourStyle; \
    public: \
 \
        static zfanyT<YourStyle> DefaultStyle(void); \
    private: \
        static void _ZFP_StyleDefU(ZF_IN YourStyle *newInstance); \
        static ZFObject *&_ZFP_StyleDefC(void); /* cleaner */ \
        static void _ZFP_StyleDefD(ZF_IN void *instance); /* onDelete */ \
    public:
#define _ZFP_ZFSTYLE_DEFAULT_DEFINE(YourStyle) \
    zfclass YourStyle::_ZFP_StyleDef_##YourStyle : zfextend YourStyle { \
        ZFOBJECT_DECLARE(_ZFP_StyleDef_##YourStyle, YourStyle) \
    public: \
        zfoverride \
        virtual zfbool styleableIsDefaultStyle(void) { \
            return zftrue; \
        } \
    }; \
    zfanyT<YourStyle> YourStyle::DefaultStyle(void) { \
        static void **holder = _ZFP_ZFStyleableDefaultRefAccess(#YourStyle); \
        if(*holder == zfnull) { \
            ZFCoreMutexLocker(); \
            if(ZFFrameworkStateCheck(_ZFP_ZFStyleableDefault_level) == ZFFrameworkStateNotAvailable) { \
                return zfnull; \
            } \
            zfauto obj = _ZFP_StyleDef_##YourStyle::ClassData()->newInstance(); \
            if(obj != zfnull) { \
                zfself::_ZFP_StyleDefU(obj.to<YourStyle *>()); \
            } \
        } \
        return (YourStyle *)(*holder); \
    } \
    ZFMETHOD_USER_REGISTER_DETAIL_0(YourStyle, \
        public, ZFMethodTypeStatic, s, \
        zfanyT<YourStyle>, DefaultStyle) { \
        return YourStyle::DefaultStyle(); \
    } \
    void YourStyle::_ZFP_StyleDefU(ZF_IN YourStyle *newInstance) { \
        if(ZFFrameworkStateCheck(_ZFP_ZFStyleableDefault_level) == ZFFrameworkStateNotAvailable) { \
            return; \
        } \
        void **holder = _ZFP_ZFStyleableDefaultRefAccess(#YourStyle); \
        if(*holder == (void *)newInstance) { \
            return; \
        } \
        ZFObject *&cleanerRef = _ZFP_StyleDefC(); \
        zfauto cleanerOld = cleanerRef; \
        cleanerRef = zfnull; \
        if(newInstance != zfnull) { \
            *holder = (void *)zfobjRetain(newInstance); \
            zfobj<ZFValue> cleanerRefTmp(*holder, YourStyle::_ZFP_StyleDefD); \
            cleanerRef = cleanerRefTmp; \
            ZFObjectGlobalInstanceAdd(cleanerRef, _ZFP_ZFStyleableDefault_level); \
        } \
        if(cleanerOld != zfnull) { \
            ZFObjectGlobalInstanceRemove(cleanerOld, _ZFP_ZFStyleableDefault_level); \
            *holder = (void *)newInstance; \
        } \
    } \
    ZFObject *&YourStyle::_ZFP_StyleDefC(void) { \
        static ZFObject *_cleaner = zfnull; \
        return _cleaner; \
    } \
    void YourStyle::_ZFP_StyleDefD(ZF_IN void *instance) { \
        YourStyle::_ZFP_StyleDefC() = zfnull; \
        void **holder = _ZFP_ZFStyleableDefaultRefAccess(#YourStyle); \
        *holder = zfnull; \
        zfobjRelease((YourStyle *)instance); \
    }

#define ZFSTYLE_DEFAULT_DECLARE(YourStyle) \
    _ZFP_ZFSTYLE_DEFAULT_DECLARE(YourStyle)

#define ZFSTYLE_DEFAULT_DEFINE(YourStyle) \
    _ZFP_ZFSTYLE_DEFAULT_DEFINE(YourStyle)

extern ZFLIB_ZFCore void ZFStyleDefaultApplyAutoCopy(ZF_IN ZFStyleable *style);

#define ZFSTYLE_DEFAULT_AUTO_COPY() \
    ZFINTERFACE_ON_INIT_DECLARE() { \
        if(!this->styleableIsDefaultStyle()) { \
            zfanyT<ZFStyleable> defaultStyle = this->defaultStyle(); \
            if(defaultStyle != zfnull) { \
                this->copyFrom(defaultStyle); \
                ZFStyleDefaultApplyAutoCopy(this); \
            } \
        } \
    }
 
// ============================================================
// style holder
extern ZFLIB_ZFCore void ZFStyleSet(
        ZF_IN const zfstring &styleKey
        , ZF_IN ZFStyleable *styleValue
        );
extern ZFLIB_ZFCore zfauto ZFStyleGet(ZF_IN const zfstring &styleKey);
extern ZFLIB_ZFCore void ZFStyleGetAll(
        ZF_IN_OUT ZFCoreArray<zfstring> &styleKey
        , ZF_IN_OUT ZFCoreArray<zfauto> &styleValue
        );
extern ZFLIB_ZFCore void ZFStyleGetAllKeyT(
        ZF_IN_OUT ZFCoreArray<zfstring> &styleKey
        );
inline ZFCoreArray<zfstring> ZFStyleGetAllKey(void) {
    ZFCoreArray<zfstring> ret;
    ZFStyleGetAllKeyT(ret);
    return ret;
}

extern ZFLIB_ZFCore void ZFStyleGetAllValueT(
        ZF_IN_OUT ZFCoreArray<zfauto> &styleValue
        );
inline ZFCoreArray<zfauto> ZFStyleGetAllValue(void) {
    ZFCoreArray<zfauto> ret;
    ZFStyleGetAllValueT(ret);
    return ret;
}

extern ZFLIB_ZFCore void ZFStyleRemoveAll(void);

extern ZFLIB_ZFCore void ZFStyleUpdateBegin();
extern ZFLIB_ZFCore void ZFStyleUpdateEnd();

#define ZFStyleUpdateBlock() _ZFP_ZFStyleUpdateBlock ZFUniqueName(_ZFP_ZFStyleUpdateBlock)
zfclassLikePOD _ZFP_ZFStyleUpdateBlock {
public:
    _ZFP_ZFStyleUpdateBlock(void) {
        ZFStyleUpdateBegin();
    }
    ~_ZFP_ZFStyleUpdateBlock(void) {
        ZFStyleUpdateEnd();
    }
};
 
ZF_NAMESPACE_BEGIN(ZFGlobalEvent)
ZFEVENT_GLOBAL(ZFLIB_ZFCore, ZFStyleOnUpdateBegin)
ZFEVENT_GLOBAL(ZFLIB_ZFCore, ZFStyleOnUpdate)
ZFEVENT_GLOBAL(ZFLIB_ZFCore, ZFStyleOnInvalid)
ZF_NAMESPACE_END(ZFGlobalEvent)
 
// ============================================================
#define ZFSTYLE_DECODER_DEFINE(registerSig, decodeAction, ...) \
    _ZFP_ZFSTYLE_DECODER_DEFINE(registerSig, decodeAction, ##__VA_ARGS__)
#define _ZFP_ZFSTYLE_DECODER_DEFINE(registerSig, decodeAction, ...) \
    ZF_STATIC_REGISTER_INIT(ZFStyleDecoder_##registerSig) { \
        _ZFP_ZFStyleDecoderRegister(zftext(#registerSig), zfself::_ZFP_decode); \
    } \
    ZF_STATIC_REGISTER_DESTROY(ZFStyleDecoder_##registerSig) { \
        _ZFP_ZFStyleDecoderUnregister(zftext(#registerSig)); \
    } \
    static zfbool _ZFP_decode( \
            ZF_OUT zfauto &ret \
            , ZF_IN const zfstring &styleKey \
            ) { \
        decodeAction __VA_ARGS__ \
    } \
    ZF_STATIC_REGISTER_END(ZFStyleDecoder_##registerSig)
typedef zfbool (*_ZFP_ZFStyleDecoder)(
        ZF_OUT zfauto &ret
        , ZF_IN const zfstring &styleKey
        );
extern ZFLIB_ZFCore void _ZFP_ZFStyleDecoderRegister(
        ZF_IN const zfstring &registerSig
        , ZF_IN _ZFP_ZFStyleDecoder decoder
        );
extern ZFLIB_ZFCore void _ZFP_ZFStyleDecoderUnregister(ZF_IN const zfstring &registerSig);
 
ZF_NAMESPACE_GLOBAL_END
#endif // #ifndef _ZFI_ZFStyleable_h_