windows-server-2003/public/internal/windows/inc/duser/duielement.h

/*
 * Element
 */

#ifndef DUI_CORE_ELEMENT_H_INCLUDED
#define DUI_CORE_ELEMENT_H_INCLUDED

#pragma once

#include "duivalue.h"
#include "duievent.h"
#include "duisheet.h"
#include "duilayout.h"

struct IAccessible;

namespace DirectUI
{

#if DBG
extern UINT g_cGetDep;
extern UINT g_cGetVal;
extern UINT g_cOnPropChg;
#endif

class DuiAccessible;

// TODO: Switch DUI listeners to use DirectUser MessageHandlers

/*
 * Element Properties
 *
 * Element provides default behavior for Get/SetValue based on the flags used in PropertyInfo.
 * The Flags also define what indicies are available during property operations.
 *
 * Get/SetValue cannot be overridden. Rather, a default implemention is supplied for GetValue's
 * on all properties. By default, Get's on the Specified and Computed index are handled by a
 * built-in Value Expression (VE) while Get's on Local query a local store (see below for exact
 * default behavior). However, various system properties override this default behavior with
 * different unchangable Value Expressions (implicit VEs) in the Local and Computed indicies.
 *
 * End users will use Normal properties and may occasionally use LocalOnly properties. Although
 * available to derived classes, TriLevel property functionaly is only useful by the system.
 *
 * All property value must be available generically through GetValue.
 *
 * Flags supported (default behavior):
 * 
 * "LocalOnly"
 *   Indicies: Local
 *        Get: Retrieve local value from Element. If none is set, 'Unset' returned.
 *        Set: Stores value locally on the Element. 
 * Dependents: None
 *  Modifiers: Readonly: Disallow Set
 *
 * "Normal"
 *   Indicies: Local, Specified (implicit VE)
 *        Get:     Local: Retrieve local value from Element. If none is set, 'Unset' returned.
 *             Specified: Does a Get on the Local value. If 'Unset', return Property Sheet value
 *                        if Cascade modifier is set. If 'Unset', return parent's value if Inherit
 *                        modifier is set. If 'Unset' return property's Default value. 
 *                        Automatically evaulate value expressions before return.
 *        Set:     Local: Stores value locally on the Element.
 *             Specified: Unsupported.
 * Dependents: Specified is dependent on Local.
 *  Modifiers: Readonly: Disallow Set for Local.
 *              Cascade: Used with Specified Get (see Get description).
 *              Inherit: Used with Specified Get (see Get description).
 *
 * "TriLevel"
 *   Indicies: Local, Specified (implicit VE), Computed (implicit VE)
 *        Get:     Local: Retrieve local value from Element. If none is set, 'Unset' returned.
 *             Specified: Does a Get on the Local value. If 'Unset', return Property Sheet value
 *                        if Cascade modifier is set. If 'Unset', return parent's value if Inherit
 *                        modifier is set. If 'Unset' return property's Default value. 
 *                        Automatically evaulate value expressions before return.
 *              Computed: Does a get of the Specified value.
 *        Set:     Local: Stores value locally on the Element.
 *             Specified: Unsupported.
 *              Computed: Unsupported.
 * Dependents: Computed is dependent on Specified. Specified is dependent on Local.
 *  Modifiers: Readonly: Disallow Set for Local.
 *              Cascade: Used with Specified Get (see Get description).
 *              Inherit: Used with Specified Get (see Get description).
 *
 * SetValue must always be used by derived classes. However, SetValue is sometimes bypassed and
 * Pre/PostSourceChange is called directly in the case of LocalOnly properties that are ReadOnly
 * and are cached directly on the Element (optimization). All other ReadOnly sets use
 * _SetValue since generic storage (of Values) is used. SetValue is used in all other cases.
 *
 * For ReadOnly values, if storing the value is cheap (i.e. bools) and interit and style sheet
 * functionality is not required, it is best to not use generic storage (_SetValue). Rather,
 * write the value directly and call Pre/PostSourceChange directly ("LocalOnly property). 
 * Otherwise, if a ReadOnly value requires inheritance and/or sheet lookups, or the value is
 * seldom different than a default value, use _SetValue (generic storage, "Normal" property).
 *
 * For Normal/ReadOnly, use SetValue, For LocalOnly/ReadOnly, use _SetValue,
 * For internal LocalOnly/ReadOnly, set and store manually (no generic storage)
 *
 * All property values must be settable generically via SetValue except ReadOnly properties.
 * Any "LocalOnly" property that doesn't use generic storage must initialize their members
 * at construction to the property's default value. "Normal" properties will choose the
 * default value automatically when queried. All derived classes (external) will use "Normal"
 * properties.
 *
 * SetValue only accepts the PI_Local index. ReadOnly sets do not fire OnPropertyChanging.
 * All value sets must result in a PreSourceChange, followed by the store update (in which GetValue
 * will retrieve values from), followed by a PostSourceChange. OnPropertyChange and old value
 * compare are optional.
 *
 * Set values are updated immediately (i.e. an immediate GetValue after will produce the updated
 * result). Location and Extent are updated after the defer cycle ends (EndDefer, SetValues are internal).
 */

/*
 * Element Multithreading
 *
 * Elements have context affinity. A single thread is allowed per context. This thread
 * is owned by the context. Only that thread may be allowed to access objects in its
 * context. This requirement is not enforced in this library. The caller application
 * must ensure access to objects in a context happens via the owned thread.
 *
 * A Proxy class is provided to invoke methods on objects from an out-of-context thread.
 *
 * The library supports multiple instances in the same process. This would happen by
 * linking the library to multiple process modules. The only restriction is a thread
 * must access a set of objects consistantly with the same instance of the library code.
 *
 */

/*
 * Error Reporting
 *
 * Conditions that would affect the stability of DirectUI are reported. Some conditions are
 * only reported in Debug builds, and other in both Release and Debug
 *
 *  Debug time reporting:
 *   Erroneous states are reported in Debug (checked) builds. An erroneous state arises
 *   when a programming error is found or when invalid arguments are passed to a method.
 *   Erroneous states cause raising of asserts
 *
 *  Release time reporting:
 *   Abnormal states (such as out of memory or resources) that result in a serious condition
 *   (crash or very irregular state) are reported via HRESULTs. Any DUI API that can fail due to
 *   these types of abnormal states returns an HRESULT. If a method fails, it will recover.
 *   Some methods (such as object creation methods) will recover by freeing any memory or
 *   resources allocated within that method (resulting of a complete undo of all the work it
 *   accomplished up to the point of the failure). Other methods (such as rendering and the defer 
 *   cycle) will do as much work as possible. Upon a failure, they will return an 'incomplete'
 *   error, however, they would have not completed. Failures do not result in crashes or irregular
 *   state. Failures are ignored in callbacks
 */

typedef int (__cdecl *CompareCallback)(const void*, const void*);

// Property indicies
#define PI_Local        1
#define PI_Specified    2
#define PI_Computed     3

// Property flags
#define PF_LocalOnly    0x01
#define PF_Normal       0x02
#define PF_TriLevel     0x03
#define PF_Cascade      0x04
#define PF_Inherit      0x08
#define PF_ReadOnly     0x10

#define PF_TypeBits     0x03  // Map out for LocalOnly, Normal, or Trilevel

// For use in OnPropertyChanged, mask out non-retrieval index property changes
#define IsProp(p)       ((p##Prop == ppi) && ((ppi->fFlags&PF_TypeBits) == iIndex))
#define RetIdx(p)       (p->fFlags&PF_TypeBits)
    
// Property groups
#define PG_AffectsDesiredSize         0x00000001    // Normal priority
#define PG_AffectsParentDesiredSize   0x00000002
#define PG_AffectsLayout              0x00000004
#define PG_AffectsParentLayout        0x00000008
#define PG_AffectsBounds              0x00010000    // Low priority
#define PG_AffectsDisplay             0x00020000

#define PG_NormalPriMask              0x0000FFFF
#define PG_LowPriMask                 0xFFFF0000

// Layout cycle queue modes
#define LC_Pass         0
#define LC_Normal       1
#define LC_Optimize     2

// todo: get these from accessibility
#define GA_NOTHANDLED     ((Element*) -1)

// to be internal
#define NAV_LOGICAL    0x00000001 // unset == directional
#define NAV_FORWARD    0x00000002 // unset == backward
#define NAV_VERTICAL   0x00000004 // unset == horizontal
#define NAV_RELATIVE   0x00000008 // unset == absolute

// to be exposed
#define NAV_FIRST      (NAV_FORWARD | NAV_LOGICAL)
#define NAV_LAST       (NAV_LOGICAL)
#define NAV_UP         (NAV_RELATIVE | NAV_VERTICAL)
#define NAV_DOWN       (NAV_RELATIVE | NAV_VERTICAL | NAV_FORWARD)
#define NAV_LEFT       (NAV_RELATIVE)
#define NAV_RIGHT      (NAV_RELATIVE | NAV_FORWARD)
#define NAV_NEXT       (NAV_RELATIVE | NAV_FORWARD | NAV_LOGICAL)
#define NAV_PREV       (NAV_RELATIVE | NAV_LOGICAL)

// to be exposed
#define DIRECTION_LTR     0
#define DIRECTION_RTL     1

// Asynchronous destroy message (must be async to ensure outstanding
// defer pointers are cleared)
#define GM_DUIASYNCDESTROY            GM_USER - 1


////////////////////////////////////////////////////////
// PropertyInfo

struct IClassInfo;

struct EnumMap
{
    LPCWSTR pszEnum;
    int nEnum;
};

struct PropertyInfo
{
    WCHAR szName[81];
    int fFlags;
    int fGroups;
    int* pValidValues;
    EnumMap* pEnumMaps;
    Value* pvDefault;
    int _iIndex;           // Class-wide unique id (zero-based consecutive, set by ClassInfo)
    int _iGlobalIndex;     // Process-wide unique id (zero-based consecutive, set by ClassInfo (manually set for Element))
    IClassInfo* _pciOwner; // Class that this property is defined on (direct owner, not inherited-by)
};

class Element;

////////////////////////////////////////////////////////
// UpdateCache

struct UpdateCache
{
    Element* peSrc;
    PropertyInfo* ppiSrc;
    int iIndexSrc;
    Value* pvOldSrc;
    Value* pvNewSrc;
};

////////////////////////////////////////////////////////
// Dependencies

struct Dependency
{
    Element* pe;
    PropertyInfo* ppi;
    int iIndex;
};

// Track dependency records in PC list
struct DepRecs
{
    int iDepPos;
    int cDepCnt;
};

struct NavReference
{
    void Init(Element* pe, RECT* prc);

    UINT     cbSize;
    Element* pe;
    RECT*    prc;
};

////////////////////////////////////////////////////////
// Class information interface

// Used so that a class will not be linked out if a class is not referred to
// (and is only referred by the parser)
#define UsingDUIClass(classn) static IClassInfo* _DUI__pCI##classn = ##classn::Class

struct IClassInfo
{
    virtual HRESULT CreateInstance(OUT Element** ppElement) = 0;
    virtual PropertyInfo* EnumPropertyInfo(UINT nEnum) = 0;  // Includes base classes
    virtual UINT GetPICount() = 0;                           // Includes base classes
    virtual UINT GetGlobalIndex() = 0;
    virtual IClassInfo* GetBaseClass() = 0;
    virtual LPCWSTR GetName() = 0;
    virtual bool IsValidProperty(PropertyInfo* ppi) = 0;
    virtual bool IsSubclassOf(IClassInfo* pci) = 0;
    virtual void Destroy() = 0;
};

////////////////////////////////////////////////////////
// Element Listener interface
struct IElementListener
{
    virtual void OnListenerAttach(Element* peFrom) = 0;
    virtual void OnListenerDetach(Element* peFrom) = 0;
    virtual bool OnListenedPropertyChanging(Element* peFrom, PropertyInfo* ppi, int iIndex, Value* pvOld, Value* pvNew) = 0;
    virtual void OnListenedPropertyChanged(Element* peFrom, PropertyInfo* ppi, int iIndex, Value* pvOld, Value* pvNew) = 0;
    virtual void OnListenedInput(Element* peFrom, InputEvent* pInput) = 0;
    virtual void OnListenedEvent(Element* peFrom, Event* pEvent) = 0;
};

#if DBG
////////////////////////////////////////////////////////
// Track "owner" context of this instance to validation that threads that don't
// belong to the context don't access the object.
//
// For side-by-side library support, also store the TLS slot of the instance
// of the library in the process that created this object. This will ensure the 
// thread is using the correct library instance to access the object. 

struct Owner
{
    HDCONTEXT hCtx;
    DWORD dwTLSSlot;
};
#endif

////////////////////////////////////////////////////////
// Element

typedef DynamicArray<Element*> ElementList;
class DeferCycle;
struct PCRecord;

#define EC_NoGadgetCreate       0x1  // Do not create DisplayNode, must be created within constructor override
#define EC_SelfLayout           0x2  // Element will lay out children (via self layout callbacks)

class Element
{
public:

    ////////////////////////////////////////////////////////
    // Construction / destruction

    static HRESULT Create(UINT nCreate, OUT Element** ppe);
    HRESULT Destroy(bool fDelayed = true);  // Destroy self
    HRESULT DestroyAll();                   // Destroy all children

    Element() { }
    virtual ~Element();
    HRESULT Initialize(UINT nCreate);

    ////////////////////////////////////////////////////////
    // Properties (impl in property.cpp)

    // Accessors
    Value* GetValue(PropertyInfo* ppi, int iIndex, UpdateCache* puc = NULL);
    HRESULT SetValue(PropertyInfo* ppi, int iIndex, Value* pv);

    // Additional property methods
    HRESULT RemoveLocalValue(PropertyInfo* ppi);

    // Deferring
    static void StartDefer();
    static void EndDefer();

    // Checks
    inline bool IsValidAccessor(PropertyInfo* ppi, int iIndex, bool bSetting);
    static bool IsValidValue(PropertyInfo* ppi, Value* pv);
    bool IsRTL() { return (GetDirection() == DIRECTION_RTL);}

    // System event callbacks
    virtual bool OnPropertyChanging(PropertyInfo* ppi, int iIndex, Value* pvOld, Value* pvNew);  // Direct
    virtual void OnPropertyChanged(PropertyInfo* ppi, int iIndex, Value* pvOld, Value* pvNew);   // Direct
    virtual void OnGroupChanged(int fGroups, bool bLowPri);                                      // Direct
    virtual void OnInput(InputEvent* pInput);                                                    // Direct and bubbled
    virtual void OnKeyFocusMoved(Element* peFrom, Element* peTo);                                // Direct and bubbled
    virtual void OnMouseFocusMoved(Element* peFrom, Element* peTo);                              // Direct and bubbled
    virtual void OnDestroy();                                                                    // Direct
    // ContainerCleanup: OnLoadedFromResource(dictionary)
 
    // Generic eventing and callback (pointer is only guaranteed good for the lifetime of the call)
    void FireEvent(Event* pEvent, bool fFull = true);
    virtual void OnEvent(Event* pEvent);

    // Rendering callbacks
    virtual void Paint(HDC hDC, const RECT* prcBounds, const RECT* prcInvalid, RECT* prcSkipBorder, RECT* prcSkipContent);
#ifdef GADGET_ENABLE_GDIPLUS
    virtual void Paint(Gdiplus::Graphics* pgpgr, const Gdiplus::RectF* prcBounds, const Gdiplus::RectF* prcInvalid, Gdiplus::RectF* prSkipBorder, Gdiplus::RectF* prSkipContent);
#endif
    virtual SIZE GetContentSize(int dConstW, int dConstH, Surface* psrf);
    float GetTreeAlphaLevel();

    // Hierarchy
    HRESULT Add(Element* pe);
    virtual HRESULT Add(Element** ppe, UINT cCount);
    HRESULT Insert(Element* pe, UINT iInsertIdx);
    virtual HRESULT Insert(Element** ppe, UINT cCount, UINT iInsertIdx);

    HRESULT Add(Element* pe, CompareCallback lpfnCompare);
    HRESULT SortChildren(CompareCallback lpfnCompare);

    HRESULT Remove(Element* peFrom);
    HRESULT RemoveAll();
    virtual HRESULT Remove(Element** ppe, UINT cCount);

    // Mapping and navigation
    Element* FindDescendent(ATOM atomID);
    void MapElementPoint(Element* peFrom, const POINT* pptFrom, POINT* pptTo);
    Element* GetImmediateChild(Element* peFrom);
    bool IsDescendent(Element* pe);
    virtual Element* GetAdjacent(Element* peFrom, int iNavDir, NavReference const* pnr, bool bKeyable);
    Element* GetKeyWithinChild();
    Element* GetMouseWithinChild();
    bool EnsureVisible();
    bool EnsureVisible(UINT uChild);
    virtual bool EnsureVisible(int x, int y, int cx, int cy);
    virtual void SetKeyFocus();

    // Element Listeners
    HRESULT AddListener(IElementListener* pel);
    void RemoveListener(IElementListener* pel);

    // Effects, animate display node to match current Element state
    void InvokeAnimation(int dAni, UINT nTypeMask);
    void InvokeAnimation(UINT nTypes, UINT nInterpol, float flDuration, float flDelay, bool fPushToChildren = false);
    void StopAnimation(UINT nTypes);

    // Display node callback extension
    virtual UINT MessageCallback(GMSG* pGMsg);

    // Internal defer cycle and Layout-only callbacks 
    SIZE _UpdateDesiredSize(int dConstW, int dConstH, Surface* psrf);
    void _UpdateLayoutPosition(int dX, int dY);
    void _UpdateLayoutSize(int dWidth, int dHeight);

    // Use in DoLayout on children where one or more properties will be changed which will
    // cause a Layout GPC to be queued. This will cancel the layout GPCs and force the child
    // to be included in the current layout cycle
    void _StartOptimizedLayoutQ() { DUIAssertNoMsg(_fBit.fNeedsLayout != LC_Optimize); _fBit.fNeedsLayout = LC_Optimize; }
    void _EndOptimizedLayoutQ() { _fBit.fNeedsLayout = LC_Normal; }

    // Internal defer cycle and PropertySheet-only callbacks
    static void _AddDependency(Element* pe, PropertyInfo* ppi, int iIndex, DepRecs* pdr, DeferCycle* pdc, HRESULT* phr);

    // Internal DirectUser interop
    static HRESULT CALLBACK _DisplayNodeCallback(HGADGET hgadCur, void * pvCur, EventMsg * pGMsg);

    // Internal IUnknown interface impl
    long __stdcall QueryInterface(REFIID iid, void** pvObj) { UNREFERENCED_PARAMETER(iid); UNREFERENCED_PARAMETER(pvObj); return E_NOTIMPL; }
    ULONG __stdcall AddRef() { return 1; }
    ULONG __stdcall Release() { return 1; }
    
private:

    // Value update
    HRESULT _GetDependencies(PropertyInfo* ppi, int iIndex, DepRecs* pdr, int iPCSrcRoot, DeferCycle* pdc);
    static void _VoidPCNotifyTree(int iPCPos, DeferCycle* pdc);

    // Defer cycle
    static void _FlushDS(Element* pe, DeferCycle* pdc);
    static void _FlushLayout(Element* pe, DeferCycle* pdc);

    // Value Update
    HRESULT _PreSourceChange(PropertyInfo* ppi, int iIndex, Value* pvOld, Value* pvNew);
    HRESULT _PostSourceChange();

protected:

    // EC_SelfLayout flag at creation activates these methods. No external layouts are used for layout,
    // rather, Element is responsible for layout (use when layout is specific and hierarchy is known)
    virtual void _SelfLayoutDoLayout(int dWidth, int dHeight);
    virtual SIZE _SelfLayoutUpdateDesiredSize(int dConstW, int dConstH, Surface* psrf);

    // Internal Set and Remove
    HRESULT _SetValue(PropertyInfo* ppi, int iIndex, Value* pv, bool fInternalCall = true);
    HRESULT _RemoveLocalValue(PropertyInfo* ppi, bool fInternalCall = true);

    // Natvie hosting system event callbacks and retrieval
    virtual void OnHosted(Element* peNewHost);    // Direct
    virtual void OnUnHosted(Element* peOldHost);  // Direct
    void MarkHosted() { _fBit.bHosted = true; }

public:

    inline void DoubleBuffered(bool fEnabled = true)
    {
        if (_hgDisplayNode)
            SetGadgetStyle(_hgDisplayNode, (fEnabled) ? GS_BUFFERED : 0, GS_BUFFERED);
    }

    inline BOOL IsRoot()
    {
        return IsHosted() && (GetParent() == NULL);
    }

    // Return if being hosted by a native root
    inline Element* GetRoot()
    {
        if (!IsHosted())
            return NULL;

        Element * peCur = this;
        while (peCur->GetParent() != NULL) 
        {
            peCur = peCur->GetParent();
        }
            
        return peCur;
    }

    static BTreeLookup<IClassInfo*>* pciMap;

    // Event types
    static UID KeyboardNavigate;

    // Property definitions
    static PropertyInfo* ParentProp;            // 00
    static PropertyInfo* ChildrenProp;          // 01
    static PropertyInfo* VisibleProp;           // 02 
    static PropertyInfo* WidthProp;             // 03
    static PropertyInfo* HeightProp;            // 04
    static PropertyInfo* LocationProp;          // 05
    static PropertyInfo* ExtentProp;            // 06
    static PropertyInfo* XProp;                 // 07
    static PropertyInfo* YProp;                 // 08
    static PropertyInfo* PosInLayoutProp;       // 09
    static PropertyInfo* SizeInLayoutProp;      // 10
    static PropertyInfo* DesiredSizeProp;       // 11
    static PropertyInfo* LastDSConstProp;       // 12
    static PropertyInfo* LayoutProp;            // 13
    static PropertyInfo* LayoutPosProp;         // 14
    static PropertyInfo* BorderThicknessProp;   // 15
    static PropertyInfo* BorderStyleProp;       // 16
    static PropertyInfo* BorderColorProp;       // 17
    static PropertyInfo* PaddingProp;           // 18
    static PropertyInfo* MarginProp;            // 19
    static PropertyInfo* ForegroundProp;        // 20
    static PropertyInfo* BackgroundProp;        // 21
    static PropertyInfo* ContentProp;           // 22
    static PropertyInfo* FontFaceProp;          // 23
    static PropertyInfo* FontSizeProp;          // 24
    static PropertyInfo* FontWeightProp;        // 25
    static PropertyInfo* FontStyleProp;         // 26
    static PropertyInfo* ActiveProp;            // 27
    static PropertyInfo* ContentAlignProp;      // 28
    static PropertyInfo* KeyFocusedProp;        // 29
    static PropertyInfo* KeyWithinProp;         // 30
    static PropertyInfo* MouseFocusedProp;      // 31
    static PropertyInfo* MouseWithinProp;       // 32
    static PropertyInfo* ClassProp;             // 33
    static PropertyInfo* IDProp;                // 34
    static PropertyInfo* SheetProp;             // 35
    static PropertyInfo* SelectedProp;          // 36
    static PropertyInfo* AlphaProp;             // 37
    static PropertyInfo* AnimationProp;         // 38
    static PropertyInfo* CursorProp;            // 39
    static PropertyInfo* DirectionProp;         // 40
    static PropertyInfo* AccessibleProp;        // 41
    static PropertyInfo* AccRoleProp;           // 42
    static PropertyInfo* AccStateProp;          // 43
    static PropertyInfo* AccNameProp;           // 44
    static PropertyInfo* AccDescProp;           // 45
    static PropertyInfo* AccValueProp;          // 46
    static PropertyInfo* AccDefActionProp;      // 47
    static PropertyInfo* ShortcutProp;          // 48
    static PropertyInfo* EnabledProp;           // 49

#if DBG
    Owner owner;
#endif

protected:

    HGADGET _hgDisplayNode;

private:

    int _iIndex;

    BTreeLookup<Value*>* _pvmLocal;

    int _iGCSlot;
    int _iGCLPSlot;
    int _iPCTail;

    IElementListener** _ppel;

    // All "cached" values are caching resulting values from the Specified and Computed IVEs.
    // All local (loc) values are for ReadOnly properties. These values are updated directly
    // since it is not required to go generically through SetValue because they are ReadOnly.
    // They are used often or are cheap to store (bools), so they do not use generic
    // storage (via _SetValue).

    // Cached and local values
    Element* _peLocParent;        // Parent local
    POINT _ptLocPosInLayt;        // Position in layout local
    SIZE _sizeLocSizeInLayt;      // Size in layout local
    SIZE _sizeLocLastDSConst;     // Last desired size constraint local
    SIZE _sizeLocDesiredSize;     // Desired size local

    int _dSpecLayoutPos;          // Cached layout position
    Value* _pvSpecSheet;          // Cached property sheet specified (Value cached due to destruction)
    ATOM _atomSpecID;             // Cached id specified
    int _dSpecAlpha;              // Cached alpha value

    struct _BitMap
    {
        // Local values
        bool bLocKeyWithin       : 1;  // 0  Keyboard within local
        bool bLocMouseWithin     : 1;  // 1  Mouse within local

        // Direct VE cache
        bool bCmpVisible         : 1;  // 2  Cached visible computed
        bool bSpecVisible        : 1;  // 3  Cached visible specified
        UINT fSpecActive         : 2;  // 4  Cached active state specified
        bool bSpecSelected       : 1;  // 5  Cached selected state specified
        bool bSpecKeyFocused     : 1;  // 6  Cached keyboard focused state specified
        bool bSpecMouseFocused   : 1;  // 7  Cached mouse focused state specified
        UINT nSpecDirection      : 1;  // 8  Cached direction specified
        bool bSpecAccessible     : 1;  // 9  Cached accessible specified
        bool bSpecEnabled        : 1;  // 10 Cached enabled specified

        // Indirect VE cache (cache if default value)
        bool bHasChildren        : 1;  // 11 Cached children state (likely to be default value, no full cache)
        bool bHasLayout          : 1;  // 12 Cached layout state (likely to be default value, no full cache)
        bool bHasBorder          : 1;  // 13 Cached border state (likely to be default value, no full cache)
        bool bHasPadding         : 1;  // 14 Cached padding state (likely to be default value, no full cache)
        bool bHasMargin          : 1;  // 15 Cached margin state (likely to be default value, no full cache)
        bool bHasContent         : 1;  // 16 Cached content state (likely to be default value, no full cache)
        bool bDefaultCAlign      : 1;  // 17 Cached content align state (likely to be default value, no full cache)
        bool bWordWrap           : 1;  // 18 Cached content align state (likely to be default value, no full cache)
        bool bHasAnimation       : 1;  // 19 Cached animation state (likely to be default value, no full cache)
        bool bDefaultCursor      : 1;  // 20 Cached cursor state (likely to be default value, no full cache)
        bool bDefaultBorderColor : 1;  // 21 Cached border color state (likely to be default value, no full cache)
        bool bDefaultForeground  : 1;  // 22 Cached foreground state (likely to be default value, no full cache)
        bool bDefaultFontWeight  : 1;  // 23 Cached font weight state (likely to be default value, no full cache)
        bool bDefaultFontStyle   : 1;  // 24 Cached font style state (likely to be default value, no full cache)

        // Layout and UDS flags
        bool bSelfLayout         : 1;  // 25 Element is laying out itself (callbacks active, external layout set is undefined)
        bool bNeedsDSUpdate      : 1;  // 26
        UINT fNeedsLayout        : 2;  // 27

        // Lifetime flags
        bool bDestroyed          : 1;  // 28

        // Hosting flags
        bool bHosted             : 1;  // 29 Initially set by host Element directly

    } _fBit;

public:

    // Element DisplayNode and Index access
    HGADGET GetDisplayNode()     { return _hgDisplayNode; }
    int GetIndex()               { return _iIndex; }
    bool IsDestroyed()           { return _fBit.bDestroyed; }
    bool IsHosted()              { return _fBit.bHosted; }

    // Cache state for faster property value lookup
    bool IsSelfLayout()          { return _fBit.bSelfLayout; }
    bool HasChildren()           { return _fBit.bHasChildren; }   // Quick check before doing lookup
    bool HasLayout()             { return _fBit.bHasLayout; }     // Quick check before doing lookup
    bool HasBorder()             { return _fBit.bHasBorder; }     // Quick check before doing lookup
    bool HasPadding()            { return _fBit.bHasPadding; }    // Quick check before doing lookup
    bool HasMargin()             { return _fBit.bHasMargin; }     // Quick check before doing lookup
    bool HasContent()            { return _fBit.bHasContent; }    // Quick check before doing lookup
    bool IsDefaultCAlign()       { return _fBit.bDefaultCAlign; } // Quick check before doing lookup
    bool IsWordWrap()            { return _fBit.bWordWrap; }      // Quick check before doing lookup
    bool HasAnimation()          { return _fBit.bHasAnimation; }  // Quick check before doing lookup
    bool IsDefaultCursor()       { return _fBit.bDefaultCursor; } // Quick check before doing lookup

    // Quick property accessors (since system has knowledge of its unchangable value expressions, use cached values 
    // directly were possible to bypass GetValue value lookup). Quick accessors are only used during non-cache
    // gets. (PostSourceChange requires GetValue directly (with update-cache flag) for cache updates.)
    // All derived classes do accessors normally (no direct cache lookups)

    #define DUIQuickGetter(t, gv, p, i)                     { Value* pv; t v = (pv = GetValue(p##Prop, PI_##i))->gv; pv->Release(); return v; }
    #define DUIQuickGetterInd(gv, p, i)                     { return (*ppv = GetValue(p##Prop, PI_##i))->gv; }
    #define DUIQuickSetter(cv, p)                           { Value* pv = Value::cv; if (!pv) return E_OUTOFMEMORY; HRESULT hr = SetValue(p##Prop, PI_Local, pv); pv->Release(); return hr; }

    Element* GetParent()                                    { return _peLocParent; }
    bool GetVisible()                                       { return _fBit.bCmpVisible; }
    int GetWidth()                                          DUIQuickGetter(int, GetInt(), Width, Specified)
    int GetHeight()                                         DUIQuickGetter(int, GetInt(), Height, Specified)
    ElementList* GetChildren(Value** ppv)                   { return (*ppv = (HasChildren() ? GetValue(ChildrenProp, PI_Specified) : ChildrenProp->pvDefault))->GetElementList(); }
    int GetX()                                              DUIQuickGetter(int, GetInt(), X, Specified)
    int GetY()                                              DUIQuickGetter(int, GetInt(), Y, Specified)
    Layout* GetLayout(Value** ppv)                          { return (*ppv = (HasLayout() ? GetValue(LayoutProp, PI_Specified) : LayoutProp->pvDefault))->GetLayout(); }
    int GetLayoutPos()                                      { return _dSpecLayoutPos; }
    const RECT* GetBorderThickness(Value** ppv)             { return (*ppv = (HasBorder() ? GetValue(BorderThicknessProp, PI_Specified) : BorderThicknessProp->pvDefault))->GetRect(); }
    int GetBorderStyle()                                    DUIQuickGetter(int, GetInt(), BorderStyle, Specified)
    int GetBorderStdColor()                                 DUIQuickGetter(int, GetInt(), BorderColor, Specified)
    const Fill* GetBorderColor(Value** ppv)                 DUIQuickGetterInd(GetFill(), BorderColor, Specified)
    const RECT* GetPadding(Value** ppv)                     { return (*ppv = (HasPadding() ? GetValue(PaddingProp, PI_Specified) : PaddingProp->pvDefault))->GetRect(); }
    const RECT* GetMargin(Value** ppv)                      { return (*ppv = (HasMargin() ? GetValue(MarginProp, PI_Specified) : MarginProp->pvDefault))->GetRect(); }
    const POINT* GetLocation(Value** ppv)                   DUIQuickGetterInd(GetPoint(), Location, Local)
    const SIZE* GetExtent(Value** ppv)                      DUIQuickGetterInd(GetSize(), Extent, Local)
    const SIZE* GetDesiredSize()                            { return &_sizeLocDesiredSize; }
    int GetForegroundStdColor()                             DUIQuickGetter(int, GetInt(), Foreground, Specified)
    const Fill* GetForegroundColor(Value** ppv)             DUIQuickGetterInd(GetFill(), Foreground, Specified)
    int GetBackgroundStdColor()                             DUIQuickGetter(int, GetInt(), Background, Specified)
    const LPWSTR GetContentString(Value** ppv)              { return (*ppv = (HasContent() ? GetValue(ContentProp, PI_Specified) : Value::pvStringNull))->GetString(); }
    const LPWSTR GetFontFace(Value** ppv)                   DUIQuickGetterInd(GetString(), FontFace, Specified)
    int GetFontSize()                                       DUIQuickGetter(int, GetInt(), FontSize, Specified)
    int GetFontWeight()                                     DUIQuickGetter(int, GetInt(), FontWeight, Specified)
    int GetFontStyle()                                      DUIQuickGetter(int, GetInt(), FontStyle, Specified)
    int GetActive()                                         { return _fBit.fSpecActive; }
    int GetContentAlign()                                   { Value* pv; int v = (pv = (!IsDefaultCAlign() ? GetValue(ContentAlignProp, PI_Specified) : Value::pvIntZero))->GetInt(); pv->Release(); return v; }
    bool GetKeyFocused()                                    { return _fBit.bSpecKeyFocused; }
    bool GetKeyWithin()                                     { return _fBit.bLocKeyWithin; }
    bool GetMouseFocused()                                  { return _fBit.bSpecMouseFocused; }
    bool GetMouseWithin()                                   { return _fBit.bLocMouseWithin; }
    const LPWSTR GetClass(Value** ppv)                      DUIQuickGetterInd(GetString(), Class, Specified)
    ATOM GetID()                                            { return _atomSpecID; }
    PropertySheet* GetSheet()                               { return _pvSpecSheet->GetPropertySheet(); }
    bool GetSelected()                                      { return _fBit.bSpecSelected; }
    int GetAlpha()                                          { return _dSpecAlpha; }
    int GetAnimation()                                      DUIQuickGetter(int, GetInt(), Animation, Specified)
    int GetDirection()                                      DUIQuickGetter(int, GetInt(), Direction, Specified)
    bool GetAccessible()                                    { return _fBit.bSpecAccessible; }
    int GetAccRole()                                        DUIQuickGetter(int, GetInt(), AccRole, Specified)
    int GetAccState()                                       DUIQuickGetter(int, GetInt(), AccState, Specified)
    const LPWSTR GetAccName(Value** ppv)                    DUIQuickGetterInd(GetString(), AccName, Specified)
    const LPWSTR GetAccDesc(Value** ppv)                    DUIQuickGetterInd(GetString(), AccDesc, Specified)
    const LPWSTR GetAccValue(Value** ppv)                   DUIQuickGetterInd(GetString(), AccValue, Specified)
    const LPWSTR GetAccDefAction(Value** ppv)               DUIQuickGetterInd(GetString(), AccDefAction, Specified)
    int GetShortcut()                                       DUIQuickGetter(int, GetInt(), Shortcut, Specified)
    bool GetEnabled()                                       { return _fBit.bSpecEnabled; }

    HRESULT SetVisible(bool v)                              DUIQuickSetter(CreateBool(v), Visible)
    HRESULT SetWidth(int v)                                 DUIQuickSetter(CreateInt(v), Width)
    HRESULT SetHeight(int v)                                DUIQuickSetter(CreateInt(v), Height)
    HRESULT SetX(int v)                                     DUIQuickSetter(CreateInt(v), X)
    HRESULT SetY(int v)                                     DUIQuickSetter(CreateInt(v), Y)
    HRESULT SetLayout(Layout* v)                            DUIQuickSetter(CreateLayout(v), Layout)
    HRESULT SetLayoutPos(int v)                             DUIQuickSetter(CreateInt(v), LayoutPos)
    HRESULT SetBorderThickness(int l, int t, int r, int b)  DUIQuickSetter(CreateRect(l, t, r, b), BorderThickness)
    HRESULT SetBorderStyle(int v)                           DUIQuickSetter(CreateInt(v), BorderStyle)
    HRESULT SetBorderStdColor(int v)                        DUIQuickSetter(CreateInt(v), BorderColor)
    HRESULT SetBorderColor(COLORREF cr)                     DUIQuickSetter(CreateColor(cr), BorderColor)
    HRESULT SetBorderGradientColor(COLORREF cr0, 
            COLORREF cr1, BYTE dType = FILLTYPE_HGradient)  DUIQuickSetter(CreateColor(cr0, cr1, dType), BorderColor)
    HRESULT SetPadding(int l, int t, int r, int b)          DUIQuickSetter(CreateRect(l, t, r, b), Padding)
    HRESULT SetMargin(int l, int t, int r, int b)           DUIQuickSetter(CreateRect(l, t, r, b), Margin)
    HRESULT SetForegroundStdColor(int v)                    DUIQuickSetter(CreateInt(v), Foreground)
    HRESULT SetForegroundColor(COLORREF cr)                 DUIQuickSetter(CreateColor(cr), Foreground)
    HRESULT SetForegroundColor(COLORREF cr0, COLORREF cr1, 
            BYTE dType = FILLTYPE_HGradient)                DUIQuickSetter(CreateColor(cr0, cr1, dType), Foreground)
    HRESULT SetForegroundColor(COLORREF cr0, COLORREF cr1, COLORREF cr2,
            BYTE dType = FILLTYPE_TriHGradient)             DUIQuickSetter(CreateColor(cr0, cr1, cr2, dType), Foreground)
    HRESULT SetBackgroundStdColor(int v)                    DUIQuickSetter(CreateInt(v), Background)
    HRESULT SetBackgroundColor(COLORREF cr)                 DUIQuickSetter(CreateColor(cr), Background)
    HRESULT SetBackgroundColor(COLORREF cr0, COLORREF cr1,
            BYTE dType = FILLTYPE_HGradient)                DUIQuickSetter(CreateColor(cr0, cr1, dType), Background)
    HRESULT SetBackgroundColor(COLORREF cr0, COLORREF cr1, COLORREF cr2,
            BYTE dType = FILLTYPE_TriHGradient)             DUIQuickSetter(CreateColor(cr0, cr1, cr2, dType), Background)
    HRESULT SetContentString(LPCWSTR v)                     DUIQuickSetter(CreateString(v), Content)
    HRESULT SetContentGraphic(LPCWSTR v, 
            BYTE dBlendMode = GRAPHIC_NoBlend,
            UINT dBlendValue = 0)                           DUIQuickSetter(CreateGraphic(v, dBlendMode, dBlendValue), Content)
    HRESULT SetContentGraphic(LPCWSTR v, USHORT cxDesired, 
            USHORT cyDesired)                               DUIQuickSetter(CreateGraphic(v, cxDesired, cyDesired), Content)
    HRESULT SetFontFace(LPCWSTR v)                          DUIQuickSetter(CreateString(v), FontFace)
    HRESULT SetFontSize(int v)                              DUIQuickSetter(CreateInt(v), FontSize)
    HRESULT SetFontWeight(int v)                            DUIQuickSetter(CreateInt(v), FontWeight)
    HRESULT SetFontStyle(int v)                             DUIQuickSetter(CreateInt(v), FontStyle)
    HRESULT SetActive(int v)                                DUIQuickSetter(CreateInt(v), Active)
    HRESULT SetContentAlign(int v)                          DUIQuickSetter(CreateInt(v), ContentAlign)
    HRESULT SetClass(LPCWSTR v)                             DUIQuickSetter(CreateString(v), Class)
    HRESULT SetID(LPCWSTR v)                                DUIQuickSetter(CreateAtom(v), ID)
    HRESULT SetSheet(PropertySheet* v)                      DUIQuickSetter(CreatePropertySheet(v), Sheet)
    HRESULT SetSelected(bool v)                             DUIQuickSetter(CreateBool(v), Selected)
    HRESULT SetAlpha(int v)                                 DUIQuickSetter(CreateInt(v), Alpha)
    HRESULT SetAnimation(int v)                             DUIQuickSetter(CreateInt(v), Animation)
    HRESULT SetStdCursor(int v)                             DUIQuickSetter(CreateInt(v), Cursor)
    HRESULT SetCursor(LPCWSTR v)                            DUIQuickSetter(CreateCursor(v), Cursor)
    HRESULT SetDirection(int v)                             DUIQuickSetter(CreateInt(v), Direction)
    HRESULT SetAccessible(bool v)                           DUIQuickSetter(CreateBool(v), Accessible)
    HRESULT SetAccRole(int v)                               DUIQuickSetter(CreateInt(v), AccRole)
    HRESULT SetAccState(int v)                              DUIQuickSetter(CreateInt(v), AccState)
    HRESULT SetAccName(LPCWSTR v)                           DUIQuickSetter(CreateString(v), AccName)
    HRESULT SetAccDesc(LPCWSTR v)                           DUIQuickSetter(CreateString(v), AccDesc)
    HRESULT SetAccValue(LPCWSTR v)                          DUIQuickSetter(CreateString(v), AccValue)
    HRESULT SetAccDefAction(LPCWSTR v)                      DUIQuickSetter(CreateString(v), AccDefAction)
    HRESULT SetShortcut(int v)                              DUIQuickSetter(CreateInt(v), Shortcut)
    HRESULT SetEnabled(bool v)                              DUIQuickSetter(CreateBool(v), Enabled)

    ////////////////////////////////////////////////////////
    // ClassInfo accessors (static and virtual instance-based)

    static IClassInfo* Class;
    virtual IClassInfo* GetClassInfo() { return Class; }
    static HRESULT Register();

    ///////////////////////////////////////////////////////
    // Accessibility support

    DuiAccessible * _pDuiAccessible;
    virtual HRESULT GetAccessibleImpl(IAccessible ** ppAccessible);
    HRESULT QueueDefaultAction();
    virtual HRESULT DefaultAction();
};

////////////////////////////////////////////////////////
// Element helpers

Element* ElementFromGadget(HGADGET hGadget);
void QueryDetails(Element* pe, HWND hParent);

////////////////////////////////////////////////////////
// DeferCycle: Per-thread deferring information

// Group notifications: deferred until EndDefer and coalesced
struct GCRecord
{
    Element* pe;
    int fGroups;
};

// Property notifications: deferred until source's dependency
// graph is searched (within SetValue call), not coalesced
struct PCRecord
{
    bool fVoid;
    Element* pe;
    PropertyInfo* ppi;
    int iIndex;
    Value* pvOld;
    Value* pvNew;
    DepRecs dr;
    int iPrevElRec;
};

class DeferCycle
{
public:
    static HRESULT Create(DeferCycle** ppDC);
    void Destroy() { HDelete<DeferCycle>(this); }
    
    void Reset();

    DynamicArray<GCRecord>* pdaGC;            // Group changed database
    DynamicArray<GCRecord>* pdaGCLP;          // Low priority group changed database
    DynamicArray<PCRecord>* pdaPC;            // Property changed database
    ValueMap<Element*,BYTE>* pvmLayoutRoot;   // Layout trees pending
    ValueMap<Element*,BYTE>* pvmUpdateDSRoot; // Update desired size trees pending

    int cEnter;
    bool fFiring;
    int iGCPtr;
    int iGCLPPtr;
    int iPCPtr;
    int iPCSSUpdate;
    int cPCEnter;

    DeferCycle() { }
    HRESULT Initialize();
    virtual ~DeferCycle();
};

#if DBG
// Process-wide element count
extern LONG g_cElement;
#endif

// Per-thread Element slot
extern DWORD g_dwElSlot;

struct ElTls
{
    HDCONTEXT hCtx;         // DirectUser thread context
    int cRef;
    SBAlloc* psba;
    DeferCycle* pdc;
    FontCache* pfc;
    bool fCoInitialized;
    int dEnableAnimations;
#if DBG
    int cDNCBEnter;         // Track when _DisplayNodeCallback is entered
#endif
};

/////////////////////////////////////////////////////////////////////////////
// Per-Context object access

inline bool IsAnimationsEnabled() 
{ 
    ElTls* petls = (ElTls*)TlsGetValue(g_dwElSlot);
    if (!petls) 
        return false; 
    return (petls->dEnableAnimations == 0); 
}

inline void EnableAnimations()
{
    ElTls* petls = (ElTls*)TlsGetValue(g_dwElSlot);
    if (!petls)
        return;
    petls->dEnableAnimations++;
}

inline void DisableAnimations()
{
    ElTls* petls = (ElTls*)TlsGetValue(g_dwElSlot);
    if (!petls)
        return;
    petls->dEnableAnimations--;
}

inline HDCONTEXT GetContext()
{
    ElTls* petls = (ElTls*)TlsGetValue(g_dwElSlot);
    if (!petls)
        return NULL;
    return petls->hCtx;
}

inline DeferCycle* GetDeferObject()
{
    ElTls* petls = (ElTls*)TlsGetValue(g_dwElSlot);
    if (!petls)
        return NULL;
    return petls->pdc;
}

inline FontCache* GetFontCache()
{
    ElTls* petls = (ElTls*)TlsGetValue(g_dwElSlot);
    if (!petls)
        return NULL;
    return petls->pfc;
}

inline SBAlloc* GetSBAllocator()
{
#if 0
    ElTls* petls = (ElTls*)TlsGetValue(g_dwElSlot);
    if (!petls)
        return NULL;
    return petls->psba;
#else
    ElTls* petls = (ElTls*)TlsGetValue(g_dwElSlot);
    DUIAssert(petls != NULL, "Must have valid SBAllocator");
    return petls->psba;
#endif
}

// Use to check if Element may be accessed via the current thread
#if DBG
inline void ContextCheck(Element* pe)
{
    DUIAssert(pe->owner.dwTLSSlot == g_dwElSlot, "Element being accessed out of side-by-side instance");
    DUIAssert(pe->owner.hCtx == GetContext(), "Element being accessed out of context");
}
#define DUIContextAssert(pe) ContextCheck(pe)
#else
#define DUIContextAssert(pe)
#endif

////////////////////////////////////////////////////////
// Property enumerations

// ActiveProp
#define AE_Inactive             0x00000000
#define AE_Mouse                0x00000001
#define AE_Keyboard             0x00000002
#define AE_MouseAndKeyboard     (AE_Mouse | AE_Keyboard)

// BorderStyleProp
#define BDS_Solid               0
#define BDS_Raised              1
#define BDS_Sunken              2
#define BDS_Rounded             3

// FontStyleProp
#define FS_None                 0x00000000
#define FS_Italic               0x00000001
#define FS_Underline            0x00000002
#define FS_StrikeOut            0x00000004
#define FS_Shadow               0x00000008

// FontWeightProp
#define FW_DontCare             0
#define FW_Thin                 100
#define FW_ExtraLight           200
#define FW_Light                300
#define FW_Normal               400
#define FW_Medium               500
#define FW_SemiBold             600
#define FW_Bold                 700
#define FW_ExtraBold            800
#define FW_Heavy                900
    
// ContentAlignProp (CAE_XY, Y=bits 0-1, X=bits 2-3)
#define CA_TopLeft              0x00000000  // (0,0)
#define CA_TopCenter            0x00000001  // (0,1)
#define CA_TopRight             0x00000002  // (0,2)
#define CA_MiddleLeft           0x00000004  // (1,0)
#define CA_MiddleCenter         0x00000005  // (1,1)
#define CA_MiddleRight          0x00000006  // (1,2)
#define CA_BottomLeft           0x00000008  // (2,0)
#define CA_BottomCenter         0x00000009  // (2,1)
#define CA_BottomRight          0x0000000A  // (2,2)
#define CA_WrapLeft             0x0000000C  // (3,0)
#define CA_WrapCenter           0x0000000D  // (3,1)
#define CA_WrapRight            0x0000000E  // (3,2)

#define CA_EndEllipsis          0x00000010
#define CA_FocusRect            0x00000020

// AnimationProp (Interpolation | CatType [ | CatType | ... ] | Speed)
#define ANI_InterpolMask        0x0000000F
#define ANI_DelayMask           0x000000F0
#define ANI_TypeMask            0x0FFFFF00
#define ANI_SpeedMask           0xF0000000

#define ANI_DefaultInterpol     0x00000000
#define ANI_Linear              0x00000001  // INTERPOLATION_LINEAR
#define ANI_Log                 0x00000002  // INTERPOLATION_LOG
#define ANI_Exp                 0x00000003  // INTERPOLATION_EXP
#define ANI_S                   0x00000004  // INTERPOLATION_S

#define ANI_DelayNone           0x00000000
#define ANI_DelayShort          0x00000010
#define ANI_DelayMedium         0x00000020
#define ANI_DelayLong           0x00000030

#define ANI_AlphaType           0x00000F00
#define ANI_BoundsType          0x0000F000
#define ANI_XFormType           0x000F0000

#define ANI_None                0x00000000
#define ANI_Alpha               0x00000100
#define ANI_Position            0x00001000
#define ANI_Size                0x00002000
#define ANI_SizeH               0x00003000
#define ANI_SizeV               0x00004000
#define ANI_Rect                0x00005000
#define ANI_RectH               0x00006000
#define ANI_RectV               0x00007000
#define ANI_Scale               0x00010000

#define ANI_DefaultSpeed        0x00000000
#define ANI_VeryFast            0x10000000
#define ANI_Fast                0x20000000
#define ANI_MediumFast          0x30000000
#define ANI_Medium              0x40000000
#define ANI_MediumSlow          0x50000000
#define ANI_Slow                0x60000000
#define ANI_VerySlow            0x70000000

// CursorProp
#define CUR_Arrow               0
#define CUR_Hand                1
#define CUR_Help                2
#define CUR_No                  3
#define CUR_Wait                4
#define CUR_SizeAll             5
#define CUR_SizeNESW            6
#define CUR_SizeNS              7
#define CUR_SizeNWSE            8
#define CUR_SizeWE              9
#define CUR_Total              10

// Internal property indicies for property compares. Must match up one to one
// with Element property definitions
#define _PIDX_Parent            0
#define _PIDX_PosInLayout       1
#define _PIDX_SizeInLayout      2
#define _PIDX_DesiredSize       3
#define _PIDX_LastDSConst       4
#define _PIDX_Location          5
#define _PIDX_Extent            6
#define _PIDX_LayoutPos         7
#define _PIDX_Active            8
#define _PIDX_Children          9
#define _PIDX_Layout            10
#define _PIDX_BorderThickness   11
#define _PIDX_Padding           12
#define _PIDX_Margin            13
#define _PIDX_Visible           14
#define _PIDX_X                 15
#define _PIDX_Y                 16
#define _PIDX_ContentAlign      17
#define _PIDX_KeyFocused        18
#define _PIDX_KeyWithin         19
#define _PIDX_MouseFocused      20
#define _PIDX_MouseWithin       21
#define _PIDX_Content           22
#define _PIDX_Sheet             23
#define _PIDX_Width             24
#define _PIDX_Height            25
#define _PIDX_BorderStyle       26
#define _PIDX_BorderColor       27
#define _PIDX_Foreground        28
#define _PIDX_Background        29
#define _PIDX_FontFace          30
#define _PIDX_FontSize          31
#define _PIDX_FontWeight        32
#define _PIDX_FontStyle         33
#define _PIDX_Class             34
#define _PIDX_ID                35
#define _PIDX_Selected          36
#define _PIDX_Alpha             37
#define _PIDX_Animation         38
#define _PIDX_Cursor            39
#define _PIDX_Direction         40
#define _PIDX_Accessible        41
#define _PIDX_AccRole           42
#define _PIDX_AccState          43
#define _PIDX_AccName           44
#define _PIDX_AccDesc           45
#define _PIDX_AccValue          46
#define _PIDX_AccDefAction      47
#define _PIDX_Shortcut          48
#define _PIDX_Enabled           49

#define _PIDX_TOTAL             50

////////////////////////////////////////////////////////
// Class information template

// All classes that derive from Element must create a global instance of this class.
// It maintains a list of the class properties (provides enumeration) and creation method
// C = Class, B = Base class

// Defined in Element.cpp
extern UINT g_iGlobalCI;
extern UINT g_iGlobalPI;

template <typename C, typename B> class ClassInfo : public IClassInfo
{
public:
    // Registration (cannot unregister -- will be registered until UnInitProcess is called)
    static HRESULT Register(LPCWSTR pszName, PropertyInfo** ppPI, UINT cPI)
    {
        HRESULT hr;
    
        // If class mapping doesn't exist, registration fails 
        if (!Element::pciMap)
            return E_FAIL;

        // Check for entry in mapping, if exists, ignore registration
        if (!Element::pciMap->GetItem((void*)pszName))
        {
            // Never been registered, create class info entry
            hr = Create(pszName, ppPI, cPI, &C::Class);
            if (FAILED(hr))
                return hr;
        
            hr = Element::pciMap->SetItem((void*)pszName, C::Class);
            if (FAILED(hr))
                return hr;
        }

        return S_OK;
    }

    // Construction
    static HRESULT Create(LPCWSTR pszName, PropertyInfo** ppPI, UINT cPI, IClassInfo** ppCI)
    {
        *ppCI = NULL;

        // Element map must already exist
        if (!Element::pciMap)
            return E_FAIL;
    
        ClassInfo* pci = HNew<ClassInfo>();
        if (!pci)
            return E_OUTOFMEMORY;

        // Setup state
        pci->_ppPI = ppPI;
        pci->_cPI = cPI;
        pci->_pszName = pszName;

        // Set global index
        pci->_iGlobalIndex = g_iGlobalCI++;

        // Setup property ownership
        for (UINT i = 0; i < cPI; i++)
        {
            ppPI[i]->_iIndex = i;
            ppPI[i]->_iGlobalIndex = g_iGlobalPI++;
            ppPI[i]->_pciOwner = pci;
        }

#if DBG
        // Call string conversion method directly since can't assume Util library is available for header
        CHAR szNameA[101];
        ZeroMemory(szNameA, sizeof(szNameA));
        WideCharToMultiByte(CP_ACP, 0, pszName, -1, szNameA, (sizeof(szNameA) / sizeof(CHAR)) - 1, NULL, NULL);
        //DUITrace("RegDUIClass[%d]: '%s', %d ClassProps\n", pci->_iGlobalIndex, szNameA, cPI);
#endif

        *ppCI = pci;

        return S_OK;
    }

    void Destroy() { HDelete<ClassInfo>(this); }

public:
    HRESULT CreateInstance(OUT Element** ppElement) { return C::Create(ppElement); }
    PropertyInfo* EnumPropertyInfo(UINT nEnum) { return (nEnum < _cPI) ? _ppPI[nEnum] : B::Class->EnumPropertyInfo(nEnum - _cPI); }
    UINT GetPICount() { return _cPI + B::Class->GetPICount(); }
    UINT GetGlobalIndex() { return _iGlobalIndex; }
    IClassInfo* GetBaseClass() { return B::Class; }
    LPCWSTR GetName() { return _pszName; }
    bool IsValidProperty(PropertyInfo* ppi) { return (ppi->_pciOwner == this) ? true : B::Class->IsValidProperty(ppi); }
    bool IsSubclassOf(IClassInfo* pci) { return (pci == this) ? true : B::Class->IsSubclassOf(pci); }

    ClassInfo() { }
    virtual ~ClassInfo() { }

private:
    PropertyInfo** _ppPI;  // Array of properties for this class (C)
    UINT _cPI;             // Count of properties for this class (C)
    UINT _iGlobalIndex;    // Zero-based unique contiguous class id
    LPCWSTR _pszName;      // Class name
};

} // namespace DirectUI

#endif // DUI_CORE_ELEMENT_H_INCLUDED