ZFStyleable.h

Go to the documentation of this file.

 
#ifndef _ZFI_ZFStyleable_h_
#define _ZFI_ZFStyleable_h_
 
#include "ZFSerializable.h"
#include "ZFCopyable.h"
#include "ZFObjectObserver.h"
ZF_NAMESPACE_GLOBAL_BEGIN
 
// ============================================================
// ZFStyleable
zfclassFwd _ZFP_ZFStyleKeyHolder;
zfinterface ZFLIB_ZFCore ZFStyleable : zfextend ZFInterface {
    ZFINTERFACE_DECLARE(ZFStyleable, ZFInterface)
 
public:
    virtual zfanyT<ZFStyleable> defaultStyle(void);
 
public:
    zffinal void styleableCopyFrom(ZF_IN ZFObject *anotherStyleable);
 
public:
    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;
protected:
    ZFINTERFACE_ON_DEALLOC_DECLARE();
};
 
// ============================================================
// ZFStyle
zfclass ZFLIB_ZFCore ZFStyle : zfextend ZFObject, zfimplement ZFStyleable, zfimplement ZFSerializable, zfimplement ZFCopyable {
    ZFOBJECT_DECLARE(ZFStyle, ZFObject)
    ZFIMPLEMENT_DECLARE(ZFStyleable, ZFSerializable, ZFCopyable)
 
protected:
    zfoverride
    virtual void copyableOnCopyFrom(ZF_IN ZFObject *anotherObj) {
        zfsuperI(ZFCopyable)::copyableOnCopyFrom(anotherObj);
        this->styleableCopyFrom(zfcast(zfself *, anotherObj));
    }
};
 
// ============================================================
// DefaultStyle
#define _ZFP_ZFStyleableDefault_level ZFLevelZFFrameworkHigh
zfclassLikePOD ZFLIB_ZFCore _ZFP_ZFStyleableDefaultPointerHolder {
public:
    void *d;
    _ZFP_ZFStyleableDefaultPointerHolder(void) : d(zfnull) {}
};
 
extern ZFLIB_ZFCore _ZFP_ZFStyleableDefaultPointerHolder *_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_ZFStyleableDefault_##YourStyle; \
    public: \
 \
        static zfanyT<YourStyle> DefaultStyle(void); \
    private: \
        static void _ZFP_ZFStyleablEnumDefaultStyle(ZF_IN YourStyle *newInstance); \
        static const ZFCorePointer *&_ZFP_ZFStyleableDefaultCleaner(void); \
        static void _ZFP_ZFStyleableDefaultOnDelete(ZF_IN void *instance); \
    public:
#define _ZFP_ZFSTYLE_DEFAULT_DEFINE(YourStyle) \
    zfclass YourStyle::_ZFP_ZFStyleableDefault_##YourStyle : zfextend YourStyle { \
        ZFOBJECT_DECLARE(_ZFP_ZFStyleableDefault_##YourStyle, YourStyle) \
    public: \
        zfoverride \
        virtual zfbool styleableIsDefaultStyle(void) { \
            return zftrue; \
        } \
    }; \
    zfanyT<YourStyle> YourStyle::DefaultStyle(void) { \
        static _ZFP_ZFStyleableDefaultPointerHolder *holder = _ZFP_ZFStyleableDefaultRefAccess(#YourStyle); \
        if(holder->d == zfnull) { \
            ZFCoreMutexLocker(); \
            if(ZFFrameworkStateCheck(_ZFP_ZFStyleableDefault_level) == ZFFrameworkStateNotAvailable) { \
                return zfnull; \
            } \
            zfauto obj = _ZFP_ZFStyleableDefault_##YourStyle::ClassData()->newInstance(); \
            if(obj != zfnull) { \
                zfself::_ZFP_ZFStyleablEnumDefaultStyle(obj.to<YourStyle *>()); \
            } \
        } \
        return (YourStyle *)holder->d; \
    } \
    ZFMETHOD_USER_REGISTER_DETAIL_0({ \
            return YourStyle::DefaultStyle(); \
        }, YourStyle, \
        public, ZFMethodTypeStatic, s, \
        zfanyT<YourStyle>, DefaultStyle) \
    void YourStyle::_ZFP_ZFStyleablEnumDefaultStyle(ZF_IN YourStyle *newInstance) { \
        if(ZFFrameworkStateCheck(_ZFP_ZFStyleableDefault_level) == ZFFrameworkStateNotAvailable) { \
            return; \
        } \
        _ZFP_ZFStyleableDefaultPointerHolder *holder = _ZFP_ZFStyleableDefaultRefAccess(#YourStyle); \
        if(holder->d == newInstance) { \
            return; \
        } \
        const ZFCorePointer *&cleanerRef = _ZFP_ZFStyleableDefaultCleaner(); \
        const ZFCorePointer *cleanerOld = cleanerRef; \
        const ZFCorePointer *cleanerNew = zfnull; \
        cleanerRef = zfnull; \
        if(newInstance != zfnull) { \
            holder->d = zfRetain(newInstance); \
            cleanerNew = ZFObjectGlobalInstanceAdd(ZFCorePointerForObject<_ZFP_ZFStyleableDefaultDeleteCallbackHolder *>( \
                zfnew(_ZFP_ZFStyleableDefaultDeleteCallbackHolder, YourStyle::_ZFP_ZFStyleableDefaultOnDelete, holder->d)), \
                _ZFP_ZFStyleableDefault_level); \
            cleanerRef = cleanerNew; \
        } \
        if(cleanerOld != zfnull) { \
            ZFObjectGlobalInstanceRemove(cleanerOld, _ZFP_ZFStyleableDefault_level); \
            holder->d = newInstance; \
            cleanerRef = cleanerNew; \
        } \
    } \
    const ZFCorePointer *&YourStyle::_ZFP_ZFStyleableDefaultCleaner(void) { \
        static const ZFCorePointer *_cleaner = zfnull; \
        return _cleaner; \
    } \
    void YourStyle::_ZFP_ZFStyleableDefaultOnDelete(ZF_IN void *instance) { \
        YourStyle::_ZFP_ZFStyleableDefaultCleaner() = zfnull; \
        _ZFP_ZFStyleableDefaultPointerHolder *holder = _ZFP_ZFStyleableDefaultRefAccess(#YourStyle); \
        holder->d = zfnull; \
        zfRelease((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->styleableCopyFrom(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, 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_