/**
 * @file XTPMarkupObject.h
 *
 * @copyright
 * (c) 1998-2025 Codejock Software, All Rights Reserved.
 *
 * This source file is the property of Codejock Software and must not be
 * redistributed by any means without the explicit written permission of
 * Codejock Software.
 *
 * The use of this source code is governed by the terms and conditions specified
 * in the Toolkit Pro license agreement. Codejock Software grants you, as a
 * single software developer, the limited right to use this software on one
 * computer only.
 *
 * Contact Information:
 * support@codejock.com
 * http://www.codejock.com
 *
 */

/** @cond */
#if !defined(__XTPMARKUPOBJECT_H__)
#	define __XTPMARKUPOBJECT_H__
/** @endcond */

#	if _MSC_VER > 1000
#		pragma once
#	endif // _MSC_VER > 1000

#	include "Common/Base/Diagnostic/XTPDisableAdvancedWarnings.h"
#	include <DispEx.h>
#	include "Common/Base/Diagnostic/XTPEnableAdvancedWarnings.h"

#	include "Common/Base/Diagnostic/XTPDisableNoisyWarnings.h"

class CXTPMarkupDrawingContext;
class CXTPMarkupDependencyProperty;
class CXTPMarkupObject;
class CXTPMarkupBuilder;
class CXTPMarkupPropertyFromNameMap;
class CXTPMarkupPropertyChangedEventArgs;
class CXTPMarkupContext;
class CXTPMarkupProperties;
class CXTPMarkupType;
class CXTPMarkupStyle;
class CXTPMarkupBuilder;
class CXTPMarkupExtension;
class CXTPComInitializer;
/** @cond */
class CXTPMarkupObjectAttachedPropertyDispCollection;
class CXTPMarkupObjectAttachedPropertyElementSO;
/** @endcond */

namespace XTPXML
{
struct IXMLDOMElement;
}

enum XTPMarkupTextAlignment
{
	xtpMarkupTextAlignmentLeft,
	xtpMarkupTextAlignmentRight,
	xtpMarkupTextAlignmentCenter,
	xtpMarkupTextAlignmentJustify
};

enum XTPMarkupHorizontalAlignment
{
	xtpMarkupHorizontalAlignmentLeft,
	xtpMarkupHorizontalAlignmentCenter,
	xtpMarkupHorizontalAlignmentRight,
	xtpMarkupHorizontalAlignmentStretch
};

enum XTPMarkupVerticalAlignment
{
	xtpMarkupVerticalAlignmentTop,
	xtpMarkupVerticalAlignmentCenter,
	xtpMarkupVerticalAlignmentBottom,
	xtpMarkupVerticalAlignmentStretch
};

enum XTPMarkupOrientation
{
	xtpMarkupOrientationHorizontal,
	xtpMarkupOrientationVertical
};

enum XTPMarkupBaselineAlignment
{
	xtpMarkupBaselineTop,
	xtpMarkupBaselineCenter,
	xtpMarkupBaselineBottom,
	xtpMarkupBaseline,
	xtpMarkupBaselineTextTop,
	xtpMarkupBaselineTextBottom,
	xtpMarkupBaselineSubscript,
	xtpMarkupBaselineSuperscript
};

enum XTPMarkupVisibility
{
	xtpMarkupVisibilityVisible   = 0,
	xtpMarkupVisibilityHidden	= 1,
	xtpMarkupVisibilityCollapsed = 2
};

enum XTPMarkupLineCap
{
	xtpMarkupLineCapFlat,
	xtpMarkupLineCapSquare,
	xtpMarkupLineCapRound,
	xtpMarkupLineCapTriangle
};

enum XTPMarkupLineJoin
{
	xtpMarkupLineJoinMiter,
	xtpMarkupLineJoinBevel,
	xtpMarkupLineJoinRound
};

typedef CXTPMarkupObject* (*PFNCONVERTFROM)(
	CXTPMarkupBuilder* pBuilder, CXTPMarkupObject* pObject,
	CXTPMarkupDependencyProperty* pAssociatedProperty /*= NULL*/);
typedef void (*PFNPROPERTYCHANGED)(CXTPMarkupObject* d, CXTPMarkupPropertyChangedEventArgs* e);

class _XTP_EXT_CLASS CXTPMarkupPropertyMetadata
{
public:
	enum MetadataFlags
	{
		flagInherited			 = 1,
		flagAffectsArrange		 = 2,
		flagAffectsMeasure		 = 4,
		flagAffectsParentArrange = 8,
		flagAffectsParentMeasure = 16,
		flagAffectsRender		 = 32,
		flagDpiSensible			 = 64,
		flagHorzDpiSensible		 = flagDpiSensible,
		flagVertDpiSensible		 = 128,
	};

public:
	CXTPMarkupPropertyMetadata(CXTPMarkupObject* pDefaultValue, DWORD dwFlags = 0);
	CXTPMarkupPropertyMetadata(CXTPMarkupObject* pDefaultValue, PFNCONVERTFROM pConverter,
							   DWORD dwFlags = 0);
	CXTPMarkupPropertyMetadata(CXTPMarkupObject* pDefaultValue, PFNPROPERTYCHANGED pPropertyChanged,
							   DWORD dwFlags = 0);
	CXTPMarkupPropertyMetadata(CXTPMarkupObject* pDefaultValue, PFNCONVERTFROM pConverter,
							   PFNPROPERTYCHANGED pPropertyChanged, DWORD dwFlags = 0);
	virtual ~CXTPMarkupPropertyMetadata();

public:
	CXTPMarkupObject* m_pDefaultValue;
	PFNCONVERTFROM m_pConverter;
	PFNPROPERTYCHANGED m_pPropertyChanged;
	DWORD m_dwFlags;

	friend class CXTPMarkupObject;
};

#	define MARKUP_RELEASE(x)                                                                      \
		if (x)                                                                                     \
		{                                                                                          \
			(x)->Release();                                                                        \
			(x) = 0;                                                                               \
		}
#	define MARKUP_ADDREF(x)                                                                       \
		if (x)                                                                                     \
		{                                                                                          \
			(x)->AddRef();                                                                         \
		}

/** @cond */
#	define MARKUP_TYPE_(class_name) class_name::Get##class_name##Type()
/** @endcond */

#	define MARKUP_TYPE(class_name) XTP_ASSERT_CHECK_NOT_NULL(MARKUP_TYPE_(class_name))

#	define DECLARE_MARKUPCLASS(class_name)                                                        \
		DECLARE_DYNAMIC(class_name)                                                                \
	private:                                                                                       \
		static CXTPThreadLocal<CXTPMarkupType>* m_p##class_name##TlsPtr;                           \
		static BOOL m_b##class_name##RegistrationAttempted;                                        \
		static BOOL m_b##class_name##Unregistered;                                                 \
                                                                                                   \
	public:                                                                                        \
		static CXTPMarkupType* AFX_CDECL GetMarkupBaseType();                                      \
		static CXTPMarkupObject* AFX_CDECL CreateMarkupObject(CXTPMarkupContext* pContext);        \
		static void AFX_CDECL RegisterMarkupClass();                                               \
		static void AFX_CDECL RegisterMarkupClass_();                                              \
		static void AFX_CDECL UnregisterMarkupClass();                                             \
		virtual CXTPMarkupType* GetType() const;                                                   \
		static void AFX_CDECL RegisterType();                                                      \
		static CXTPMarkupType* Get##class_name##Type();                                            \
		static CXTPMarkupType* AFX_CDECL Create##class_name##Instance();                           \
		static void AFX_CDECL Destroy##class_name##Instance(CXTPMarkupType* pType);

#	define IMPLEMENT_MARKUPCLASS_CUSTOM_BASE(class_tag, class_name, base_class_name,              \
											  get_base_type)                                       \
		IMPLEMENT_DYNAMIC(class_name, base_class_name);                                            \
		CXTPThreadLocal<CXTPMarkupType>* class_name::m_p##class_name##TlsPtr = NULL;               \
		BOOL class_name::m_b##class_name##RegistrationAttempted				 = FALSE;              \
		BOOL class_name::m_b##class_name##Unregistered						 = FALSE;              \
		CXTPMarkupObject* AFX_CDECL class_name::CreateMarkupObject(CXTPMarkupContext* pContext)    \
		{                                                                                          \
			class_name* obj = new class_name;                                                      \
			if (obj)                                                                               \
				obj->m_pMarkupContext = pContext;                                                  \
			return obj;                                                                            \
		}                                                                                          \
		void AFX_CDECL class_name::RegisterMarkupClass_()                                          \
		{                                                                                          \
			CXTPMarkupType::RegisterTypeEntry(class_tag, class_name::Get##class_name##Type);       \
			RegisterMarkupClass();                                                                 \
		}                                                                                          \
		CXTPMarkupType* AFX_CDECL class_name::GetMarkupBaseType()                                  \
		{                                                                                          \
			return get_base_type;                                                                  \
		}                                                                                          \
		CXTPMarkupType* AFX_CDECL class_name::Create##class_name##Instance()                       \
		{                                                                                          \
			CXTPMarkupType* pType = new CXTPMarkupType(class_tag, L#class_name,                    \
													   &class_name::CreateMarkupObject,            \
													   &class_name::GetMarkupBaseType,             \
													   &class_name::RegisterMarkupClass_,          \
													   &class_name::UnregisterMarkupClass);        \
			return pType;                                                                          \
		}                                                                                          \
		void AFX_CDECL class_name::Destroy##class_name##Instance(CXTPMarkupType* pType)            \
		{                                                                                          \
			_ASSERTE(NULL != pType);                                                               \
			pType->ExternalRelease();                                                              \
		}                                                                                          \
		CXTPMarkupType* class_name::Get##class_name##Type()                                        \
		{                                                                                          \
			if (m_b##class_name##Unregistered)                                                     \
				return NULL;                                                                       \
			if (!m_b##class_name##RegistrationAttempted)                                           \
				RegisterType();                                                                    \
			if (NULL == m_p##class_name##TlsPtr)                                                   \
				m_p##class_name##TlsPtr = new CXTPThreadLocal<CXTPMarkupType>(                     \
					class_name::Create##class_name##Instance,                                      \
					class_name::Destroy##class_name##Instance);                                    \
			return &**m_p##class_name##TlsPtr;                                                     \
		}                                                                                          \
		CXTPMarkupType* class_name::GetType() const                                                \
		{                                                                                          \
			return MARKUP_TYPE(class_name);                                                        \
		}                                                                                          \
		void AFX_CDECL class_name::RegisterType()                                                  \
		{                                                                                          \
			_ASSERTE(!m_b##class_name##Unregistered);                                              \
			if (m_b##class_name##RegistrationAttempted)                                            \
				return;                                                                            \
			m_b##class_name##RegistrationAttempted = TRUE;                                         \
			MARKUP_TYPE(class_name)->Register();                                                   \
		}                                                                                          \
		void AFX_CDECL class_name::UnregisterMarkupClass()                                         \
		{                                                                                          \
			_ASSERTE(!m_b##class_name##Unregistered);                                              \
			_ASSERTE(m_b##class_name##RegistrationAttempted);                                      \
			m_b##class_name##Unregistered = TRUE;                                                  \
			if (NULL == m_p##class_name##TlsPtr)                                                   \
				return;                                                                            \
			delete m_p##class_name##TlsPtr;                                                        \
			m_p##class_name##TlsPtr = NULL;                                                        \
		}

#	define IMPLEMENT_MARKUPCLASS(class_tag, class_name, base_class_name)                          \
		IMPLEMENT_MARKUPCLASS_CUSTOM_BASE(class_tag, class_name, base_class_name,                  \
										  MARKUP_TYPE_(base_class_name))

#	ifdef _DEBUG
#		define MARKUP_STATICCAST(class_name, object)                                              \
			(static_cast<class_name*>(                                                             \
				CXTPMarkupType::StaticDownCast(MARKUP_TYPE(class_name), object)))
#	else
#		define MARKUP_STATICCAST(class_name, object) (static_cast<class_name*>(object))
#	endif

#	undef MARKUP_DYNAMICCAST
#	define MARKUP_DYNAMICCAST(class_name, object)                                                 \
		(static_cast<class_name*>(CXTPMarkupType::DynamicDownCast(MARKUP_TYPE(class_name), object)))

class _XTP_EXT_CLASS CXTPMarkupObject : public CXTPCmdTarget
{
	DECLARE_MARKUPCLASS(CXTPMarkupObject);

	friend class CXTPMarkupObjectAttachedPropertyElementSO;

public:
	/** @cond */
	enum Flags
	{
		flagNoCom = 1
	};
	/** @endcond */

	CXTPMarkupObject(int nReserved = 0);

protected:
	virtual ~CXTPMarkupObject();

public:
	CXTPMarkupContext* GetMarkupContext() const;

	XTPXML::IXMLDOMElement* GetSourceMarkupElement() const;
	void SetSourceMarkupElement(XTPXML::IXMLDOMElement* pElement);

	LPCWSTR GetKey() const;
	void SetKey(LPCWSTR lpszKey);

	LPCWSTR GetName() const;
	void SetName(LPCWSTR lpszName);

	void SetValue(CXTPMarkupDependencyProperty* pProperty, CXTPMarkupObject* pValue);
	CXTPMarkupObject* GetValue(CXTPMarkupDependencyProperty* pProperty) const;

	CXTPMarkupObject* GetValueSource(CXTPMarkupDependencyProperty* pProperty) const;

	virtual CXTPMarkupObject* GetValueCore(CXTPMarkupDependencyProperty* pProperty) const;

	CXTPMarkupDependencyProperty* GetAssociatedProperty() const;
	void SetAssociatedProperty(CXTPMarkupDependencyProperty* pAssociatedProperty);

	void SetLogicalParent(CXTPMarkupObject* pObject);
	CXTPMarkupObject* GetLogicalParent() const;

	void AddExtension(CXTPMarkupExtension* pExtension);
	CXTPMarkupExtension* GetNextExtension(const CXTPMarkupType* pClass = NULL);
	const CXTPMarkupExtension* GetNextExtension(const CXTPMarkupType* pClass = NULL) const;
	void ResetExtensionEnumerator();

	BOOL IsKindOf(const CXTPMarkupType* pClass) const;

public:
	DWORD AddRef();
	DWORD Release();

public:
	virtual UINT GetHashKey() const;
	virtual BOOL IsEqual(const CXTPMarkupObject* pObject) const;

	BOOL operator==(const CXTPMarkupObject* pObject) const;

public:
	void SetTagName(LPCWSTR lpszTagName);
	LPCWSTR GetTagName() const;

	CXTPMarkupObject* FindKey(LPCWSTR lpszKey);
	CXTPMarkupObject* FindName(LPCWSTR lpszName);

	virtual int GetLogicalChildrenCount() const;
	virtual CXTPMarkupObject* GetLogicalChild(int nIndex) const;

public:
	virtual void SetContentObject(CXTPMarkupBuilder* pBuilder, CXTPMarkupObject* pContent);
	virtual void SetPropertyObject(CXTPMarkupBuilder* pBuilder,
								   CXTPMarkupDependencyProperty* pProperty,
								   CXTPMarkupObject* pValue);
	virtual CXTPMarkupObject* ConvertFrom(CXTPMarkupBuilder* pBuilder,
										  CXTPMarkupObject* pObject) const;
	virtual BOOL HasContentObject() const;
	virtual BOOL AllowWhiteSpaceContent() const;

protected:
	virtual void OnPropertyChanged(CXTPMarkupDependencyProperty* pProperty,
								   CXTPMarkupObject* pOldValue, CXTPMarkupObject* pNewValue);
	virtual void OnSetAsProperty(CXTPMarkupDependencyProperty* pProperty,
								 CXTPMarkupObject* pTargetObject);
	virtual void OnLoaded(CXTPMarkupBuilder* pBuilder);

	void RecursePropertyChanged(CXTPMarkupDependencyProperty* pProperty,
								CXTPMarkupObject* pOldValue, CXTPMarkupObject* pNewValue);

	void OnSetValue(CXTPMarkupDependencyProperty* pProperty, CXTPMarkupObject* pOldValue,
					CXTPMarkupObject* pValue);

protected:
	virtual void OnFinalRelease();

	/** @cond */
public:
	DECLARE_DISPATCH_MAP()
	DECLARE_INTERFACE_MAP()
#	ifdef _XTP_ACTIVEX
	DECLARE_OLETYPELIB_EX(CXTPMarkupObject);
#	endif

#	pragma warning(push)
// C4616: #pragma warning : warning number '...' out of range, must be between '4001' and '4999'
// C4619: #pragma warning : there is no warning number 'number'
// C5204: '...': class has virtual functions, but its trivial destructor is not virtual; instances
// of objects derived from this class may not be destructed correctly
#	pragma warning(disable : 4616 4619 5204)
	BEGIN_INTERFACE_PART(DispatchEx, IDispatchEx)
	XTP_DECLARE_IDISPATCH()

	// IDispatchEx
	virtual HRESULT STDMETHODCALLTYPE GetDispID(
		/* [in] */ BSTR bstrName,
		/* [in] */ DWORD grfdex,
		/* [out] */ DISPID* pid);

	virtual /* [local] */ HRESULT STDMETHODCALLTYPE InvokeEx(
		/* [annotation][in] */
		DISPID id,
		/* [annotation][in] */
		LCID lcid,
		/* [annotation][in] */
		WORD wFlags,
		/* [annotation][in] */
		DISPPARAMS* pdp,
		/* [annotation][out] */
		VARIANT* pvarRes,
		/* [annotation][out] */
		EXCEPINFO* pei,
		/* [annotation][unique][in] */
		IServiceProvider* pspCaller);

	virtual HRESULT STDMETHODCALLTYPE DeleteMemberByName(
		/* [in] */ BSTR bstrName,
		/* [in] */ DWORD grfdex);

	virtual HRESULT STDMETHODCALLTYPE DeleteMemberByDispID(
		/* [in] */ DISPID id);

	virtual HRESULT STDMETHODCALLTYPE GetMemberProperties(
		/* [in] */ DISPID id,
		/* [in] */ DWORD grfdexFetch,
		/* [out] */ DWORD* pgrfdex);

	virtual HRESULT STDMETHODCALLTYPE GetMemberName(
		/* [in] */ DISPID id,
		/* [out] */ BSTR* pbstrName);

	virtual HRESULT STDMETHODCALLTYPE GetNextDispID(
		/* [in] */ DWORD grfdex,
		/* [in] */ DISPID id,
		/* [out] */ DISPID* pid);

	virtual HRESULT STDMETHODCALLTYPE GetNameSpaceParent(
		/* [out] */ IUnknown** ppunk);
	END_INTERFACE_PART(DispatchEx)
#	pragma warning(pop)

public:
	static CXTPMarkupObject* FromDispatch(LPDISPATCH pDisp, BOOL bAddRef = TRUE);
	static CXTPMarkupObject* FromDispatchAs(CXTPMarkupType* pType, LPDISPATCH pDisp,
											BOOL bAddRef = TRUE);

	void SetBeingLoaded(BOOL bBeingLoaded = TRUE);
	BOOL IsBeingLoaded() const;

	/** @endcond */

protected:
	CXTPMarkupObject* m_pLogicalParent;

	CXTPMarkupProperties* m_pProperties;
	CXTPMarkupDependencyProperty* m_pAssociatedProperty;

	CList<CXTPMarkupExtension*, CXTPMarkupExtension*> m_Extensions;
	POSITION m_posExtension;

	CXTPMarkupContext* m_pMarkupContext;

	XTPXML::IXMLDOMElement* m_pMarkupElement;
	LPWSTR m_lpszMarkupTag;

private:
	BOOL m_bBeingLoaded;
	CXTPMarkupObjectAttachedPropertyDispCollection* m_pDispColl;

protected:
	friend class CXTPMarkupBuilder;
	friend class CXTPMarkupStyle;
	static CXTPMarkupDependencyProperty* m_pNameProperty;
	static CXTPMarkupDependencyProperty* m_pKeyProperty;

	friend class CXTPMarkupProperties;
};

AFX_INLINE CXTPMarkupDependencyProperty* CXTPMarkupObject::GetAssociatedProperty() const
{
	return m_pAssociatedProperty;
}

AFX_INLINE void
	CXTPMarkupObject::SetAssociatedProperty(CXTPMarkupDependencyProperty* pAssociatedProperty)
{
	m_pAssociatedProperty = pAssociatedProperty;
}
/** @cond */
AFX_INLINE void CXTPMarkupObject::SetBeingLoaded(BOOL bBeingLoaded /*= TRUE*/)
{
	m_bBeingLoaded = bBeingLoaded;
}

AFX_INLINE BOOL CXTPMarkupObject::IsBeingLoaded() const
{
	return m_bBeingLoaded;
}
/** @endcond */
typedef CXTPMarkupObject* CXTPMarkupObjectPtr;

class _XTP_EXT_CLASS CXTPMarkupDependencyProperty : public CXTPMarkupObject
{
	DECLARE_MARKUPCLASS(CXTPMarkupDependencyProperty);

protected:
	CXTPMarkupDependencyProperty();

public:
	virtual ~CXTPMarkupDependencyProperty();

public:
	static CXTPMarkupDependencyProperty* AFX_CDECL
		Register(LPCWSTR lpszName, CXTPMarkupType* pPropetyType, CXTPMarkupType* pOwnerType,
				 CXTPMarkupPropertyMetadata* pMetadata = NULL);
	static CXTPMarkupDependencyProperty* AFX_CDECL
		RegisterAttached(LPCWSTR lpszName, CXTPMarkupType* pPropetyType, CXTPMarkupType* pOwnerType,
						 CXTPMarkupPropertyMetadata* pMetadata = NULL);
	CXTPMarkupDependencyProperty* AddOwner(CXTPMarkupType* pOwnerType);

public:
	LPCWSTR GetName() const;
	CXTPMarkupType* GetPropetyType() const;
	CXTPMarkupType* GetOwnerType() const;
	CXTPMarkupPropertyMetadata* GetMetadata() const;
	BOOL IsAttached() const;
	virtual BOOL IsEvent() const;

	DWORD GetFlags() const;

public:
	static CXTPMarkupDependencyProperty* AFX_CDECL FindProperty(CXTPMarkupType* pRuntimeClass,
																LPCWSTR lpszAttribute);

protected:
	static CXTPMarkupPropertyFromNameMap* AFX_CDECL GetPropertyMap();
	static CXTPMarkupDependencyProperty* AFX_CDECL RegisterCommon(CXTPMarkupDependencyProperty* dp,
																  LPCWSTR lpszName,
																  CXTPMarkupType* pPropetyType,
																  CXTPMarkupType* pOwnerType,
																  BOOL bAttached);

private:
	LPCWSTR m_lpszName;
	CXTPMarkupType* m_pPropetyType;
	CXTPMarkupType* m_pOwnerType;
	CXTPMarkupPropertyMetadata* m_pMetadata;
	BOOL m_bAttached;
	int m_nIndex;

	static int s_nCount;

	friend class CXTPMarkupBuilder;
	friend class CXTPMarkupRoutedEvent;
	friend class CXTPMarkupProperties;
};

class _XTP_EXT_CLASS CXTPMarkupPropertyChangedEventArgs
{
public:
	CXTPMarkupPropertyChangedEventArgs(CXTPMarkupDependencyProperty* pProperty,
									   CXTPMarkupObject* pOldValue, CXTPMarkupObject* pNewValue);

public:
	CXTPMarkupDependencyProperty* m_pProperty;
	CXTPMarkupObject* m_pOldValue;
	CXTPMarkupObject* m_pNewValue;
};

class _XTP_EXT_CLASS CXTPMarkupInt : public CXTPMarkupObject
{
	DECLARE_MARKUPCLASS(CXTPMarkupInt);
	DECLARE_DISPATCH_MAP();

public:
	CXTPMarkupInt(int nValue = 0);

	operator int() const
	{
		return m_nValue;
	}

	int GetValue() const
	{
		return m_nValue;
	}

public:
	CXTPMarkupObject* ConvertFrom(CXTPMarkupBuilder* pBuilder, CXTPMarkupObject* pObject) const;

public:
	virtual BOOL IsEqual(const CXTPMarkupObject* pObject) const;

protected:
	int m_nValue;
};

class _XTP_EXT_CLASS CXTPMarkupDouble : public CXTPMarkupObject
{
	DECLARE_MARKUPCLASS(CXTPMarkupDouble);

public:
	CXTPMarkupDouble(double dValue = 0);

	operator double() const
	{
		return m_dValue;
	}

public:
	CXTPMarkupObject* ConvertFrom(CXTPMarkupBuilder* pBuilder, CXTPMarkupObject* pObject) const;

public:
	virtual BOOL IsEqual(const CXTPMarkupObject* pObject) const;

protected:
	double m_dValue;
};

class _XTP_EXT_CLASS CXTPMarkupEnum : public CXTPMarkupObject
{
	DECLARE_MARKUPCLASS(CXTPMarkupEnum);

	struct EnumMapTag
	{
	};

public:
	CXTPMarkupEnum(int nValue = 0);

	operator int() const
	{
		return m_nValue;
	}

	int GetValue() const
	{
		return m_nValue;
	}

public:
	static CXTPMarkupEnum* AFX_CDECL CreateValue(int nValue);

public:
	CXTPMarkupObject* ConvertFrom(CXTPMarkupBuilder* pBuilder, CXTPMarkupObject* pObject) const;

public:
	virtual BOOL IsEqual(const CXTPMarkupObject* pObject) const;

protected:
	int m_nValue;
};

class _XTP_EXT_CLASS CXTPMarkupBool : public CXTPMarkupObject
{
	DECLARE_MARKUPCLASS(CXTPMarkupBool);

public:
	CXTPMarkupBool(BOOL bValue = FALSE);

	operator BOOL() const
	{
		return m_bValue;
	}

public:
	static CXTPMarkupBool* AFX_CDECL CreateTrueValue();
	static CXTPMarkupBool* AFX_CDECL CreateFalseValue();
	static CXTPMarkupBool* AFX_CDECL CreateValue(BOOL bValue);

public:
	CXTPMarkupObject* ConvertFrom(CXTPMarkupBuilder* pBuilder, CXTPMarkupObject* pObject) const;

public:
	virtual UINT GetHashKey() const;
	virtual BOOL IsEqual(const CXTPMarkupObject* pObject) const;

protected:
	BOOL m_bValue;
};

class _XTP_EXT_CLASS CXTPMarkupColor : public CXTPMarkupObject
{
	DECLARE_MARKUPCLASS(CXTPMarkupColor);

public:
	CXTPMarkupColor(COLORREF nValue = 0);
	CXTPMarkupColor(BYTE bAlpha, COLORREF nValue);

	operator COLORREF() const;

	COLORREF GetCOLORREF() const;
	DWORD GetARGB() const;
	BYTE GetAlpha() const;

	CXTPMarkupObject* ConvertFrom(CXTPMarkupBuilder* pBuilder, CXTPMarkupObject* pObject) const;

public:
	static BOOL AFX_CDECL ConvertFromString(LPCWSTR lpszValue, COLORREF& clr);

public:
	virtual BOOL IsEqual(const CXTPMarkupObject* pObject) const;

protected:
	void SetContentObject(CXTPMarkupBuilder* pBuilder, CXTPMarkupObject* /*pContent*/);

protected:
	COLORREF m_nValue;
};

AFX_INLINE CXTPMarkupColor::operator COLORREF() const
{
	return m_nValue;
}

AFX_INLINE COLORREF CXTPMarkupColor::GetCOLORREF() const
{
	return m_nValue & 0xFFFFFF;
}

AFX_INLINE DWORD CXTPMarkupColor::GetARGB() const
{
	return (m_nValue & 0xFF000000)
		   | RGB(GetBValue(m_nValue), GetGValue(m_nValue), GetRValue(m_nValue));
}

AFX_INLINE BYTE CXTPMarkupColor::GetAlpha() const
{
	return static_cast<BYTE>(m_nValue >> 24);
}

class _XTP_EXT_CLASS CXTPMarkupColorKey : public CXTPMarkupObject
{
	DECLARE_MARKUPCLASS(CXTPMarkupColorKey);

public:
	CXTPMarkupColorKey(int nIndex = 0);

public:
	int m_nIndex;
};

class _XTP_EXT_CLASS CXTPMarkupType : public CXTPMarkupObject
{
	DECLARE_MARKUPCLASS(CXTPMarkupType);

protected:
	class CClassList;
	static CClassList* AFX_CDECL GetClassList();

public:
	typedef CXTPMarkupObject*(AFX_CDECL* PFNCREATEOBJECT)(CXTPMarkupContext*);
	typedef CXTPMarkupType*(AFX_CDECL* PFNGETBASETYPE)();
	typedef void(AFX_CDECL* PFNREGISTERMARKUPCLASS)();

	CXTPMarkupObject* CreateObject(CXTPMarkupContext* pContext) const;

	static void AFX_CDECL RegisterAll();
	static void AFX_CDECL UnregisterAll();

	/** @cond */
	static void* AFX_CDECL RegisterTypeEntry(LPCWSTR lpTag, PFNGETBASETYPE pfnGetType);
	static void AFX_CDECL ResolveTypeEntry(void* pTypeEntry);
	/** @endcond */

public:
	CXTPMarkupType();
	CXTPMarkupType(LPCWSTR lpszTag, LPCWSTR lpszClassName, PFNCREATEOBJECT pfnCreateObject,
				   PFNGETBASETYPE pfnGetBaseType,
				   PFNREGISTERMARKUPCLASS pfnRegisterMarkupClass   = NULL,
				   PFNREGISTERMARKUPCLASS pfnUnregisterMarkupClass = NULL);

	virtual ~CXTPMarkupType();

public:
	BOOL IsDerivedFrom(const CXTPMarkupType* pType) const;
	BOOL IsEqualTo(const CXTPMarkupType* pBaseClass) const;
	UINT GetHashKey() const;

	static CXTPMarkupObject* AFX_CDECL DynamicDownCast(CXTPMarkupType* pType,
													   CXTPMarkupObject* pObject);
	static CXTPMarkupObject* AFX_CDECL StaticDownCast(CXTPMarkupType* pType,
													  CXTPMarkupObject* pObject);

	static CXTPMarkupType* AFX_CDECL LookupTag(LPCWSTR lpszTag);

	void Register();
	void Unregister();

	CXTPMarkupStyle* GetTypeStyle() const;
	void SetTypeStyle(CXTPMarkupStyle* pStyle);

	CXTPMarkupType* GetBaseType() const;

protected:
	CXTPMarkupObject* ConvertFrom(CXTPMarkupBuilder* pBuilder, CXTPMarkupObject* pObject) const;

public:
	LPCWSTR m_lpszTag;
	LPCWSTR m_lpszClassName;
	/** @cond */
	_XTP_DEPRECATED
	CXTPMarkupType* m_pNextType;
	/** @endcond */
protected:
	BOOL m_bRegister;
	PFNCREATEOBJECT m_pfnCreateObject;
	PFNGETBASETYPE m_pfnGetBaseType;
	PFNREGISTERMARKUPCLASS m_pfnRegisterMarkupClass;
	PFNREGISTERMARKUPCLASS m_pfnUnregisterMarkupClass;
	CXTPMarkupStyle* m_pTypeStyle;
};

class _XTP_EXT_CLASS CXTPMarkupCollection : public CXTPMarkupObject
{
	DECLARE_MARKUPCLASS(CXTPMarkupCollection);

public:
	CXTPMarkupCollection();
	virtual ~CXTPMarkupCollection();

public:
	int GetCount() const;
	void Add(CXTPMarkupObject* pElement);
	void Insert(int nIndex, CXTPMarkupObject* pElement);
	void RemoveAll();
	void Remove(int nIndex);
	int IndexOf(CXTPMarkupObject* pElement) const;

public:
	void SetContentObject(CXTPMarkupBuilder* pBuilder, CXTPMarkupObject* pContent);
	BOOL HasContentObject() const;

	CXTPMarkupType* GetElementType() const;

	virtual int GetLogicalChildrenCount() const;
	virtual CXTPMarkupObject* GetLogicalChild(int nIndex) const;

protected:
	virtual void OnItemAdded(CXTPMarkupObject* pItem, int nIndex);
	virtual void OnChanged();

protected:
	CArray<CXTPMarkupObject*, CXTPMarkupObject*> m_arrItems;
	CXTPMarkupType* m_pElementType;
	BOOL m_bLogicalParent;
};

class _XTP_EXT_CLASS CXTPMarkupProperties : public CXTPMarkupObject
{
public:
	CXTPMarkupProperties(CXTPMarkupObject* pOwner);
	virtual ~CXTPMarkupProperties();

public:
	BOOL IsPropertyValid(CXTPMarkupDependencyProperty* pProperty) const;

	CXTPMarkupObject* Lookup(CXTPMarkupDependencyProperty* pProperty) const;

	void Copy(CXTPMarkupProperties* pOwner);

	void Set(CXTPMarkupDependencyProperty* pProperty, CXTPMarkupObject* pValue);

	void Remove(CXTPMarkupDependencyProperty* pProperty);

protected:
	CXTPMarkupObject** m_pTable;
	int m_nTableSize;
	CXTPMarkupObject* m_pOwner;
};

class _XTP_EXT_CLASS CXTPMarkupAutoPtr
{
public:
	CXTPMarkupAutoPtr(CXTPMarkupObject* pObject = NULL);
	virtual ~CXTPMarkupAutoPtr();

public:
	void Assign(CXTPMarkupObject* pObject);
	CXTPMarkupObject* AddRef();
	CXTPMarkupObject* operator->();
	const CXTPMarkupObject* operator->() const;

public:
	CXTPMarkupObject* m_pObject;
};

class _XTP_EXT_CLASS CXTPMarkupDoubleCollection : public CXTPMarkupObject
{
	/** @cond */
	DECLARE_MARKUPCLASS(CXTPMarkupDoubleCollection)
	/** @endcond */
public:
	typedef CArray<float, float&> CDoubleArray;

public:
	CXTPMarkupDoubleCollection();
	CXTPMarkupDoubleCollection(CDoubleArray& arr);

public:
	int GetCount() const;
	const float* GetData() const;
	float GetAt(int nIndex) const;
	void RemoveAll();
	void Remove(int nIndex);
	void Add(float fValue);

protected:
	CXTPMarkupObject* ConvertFrom(CXTPMarkupBuilder* pBuilder, CXTPMarkupObject* pObject) const;
	static BOOL AFX_CDECL ConvertFromString(LPCWSTR lpszValue, CDoubleArray& arr);
	static BOOL AFX_CDECL GetNextValue(LPCWSTR& lpszValue, float& nValue);

protected:
	CDoubleArray m_arr;

	/** @cond */
public:
	DECLARE_DISPATCH_MAP()
#	ifdef _XTP_ACTIVEX
	DECLARE_INTERFACE_MAP()
	DECLARE_OLETYPELIB_EX(CXTPMarkupDoubleCollection);
#	endif

	afx_msg long OleGetItemCount();
	afx_msg void OleAdd(double dValue);
	afx_msg double OleGetItem(long nIndex);
	/** @endcond */
};

AFX_INLINE CXTPMarkupStyle* CXTPMarkupType::GetTypeStyle() const
{
	return m_pTypeStyle;
}
AFX_INLINE int CXTPMarkupCollection::GetCount() const
{
	return (int)m_arrItems.GetSize();
}
AFX_INLINE CXTPMarkupType* CXTPMarkupCollection::GetElementType() const
{
	return m_pElementType;
}
AFX_INLINE LPCWSTR CXTPMarkupDependencyProperty::GetName() const
{
	return m_lpszName;
}
AFX_INLINE CXTPMarkupType* CXTPMarkupDependencyProperty::GetPropetyType() const
{
	return m_pPropetyType;
}
AFX_INLINE CXTPMarkupType* CXTPMarkupDependencyProperty::GetOwnerType() const
{
	return m_pOwnerType;
}
AFX_INLINE CXTPMarkupPropertyMetadata* CXTPMarkupDependencyProperty::GetMetadata() const
{
	return m_pMetadata;
}
AFX_INLINE BOOL CXTPMarkupDependencyProperty::IsAttached() const
{
	return m_bAttached;
}
AFX_INLINE BOOL CXTPMarkupDependencyProperty::IsEvent() const
{
	return FALSE;
}
AFX_INLINE DWORD CXTPMarkupDependencyProperty::GetFlags() const
{
	return m_pMetadata ? m_pMetadata->m_dwFlags : 0;
}
AFX_INLINE CXTPMarkupContext* CXTPMarkupObject::GetMarkupContext() const
{
	return m_pMarkupContext;
}
AFX_INLINE UINT CXTPMarkupObject::GetHashKey() const
{
	return (UINT)(UINT_PTR)this;
}
AFX_INLINE BOOL CXTPMarkupObject::IsEqual(const CXTPMarkupObject* pObject) const
{
	return pObject == this;
}
AFX_INLINE BOOL CXTPMarkupObject::operator==(const CXTPMarkupObject* pObject) const
{
	return IsEqual(pObject);
}
AFX_INLINE bool AFXAPI operator==(const CXTPMarkupObject& s1, const CXTPMarkupObject& s2)
{
	return s1.IsEqual(&s2) ? true : false;
}
template<>
AFX_INLINE UINT AFXAPI HashKey(CXTPMarkupObject* key)
{
	_ASSERTE(NULL != key);

	return key->GetHashKey();
}
template<>
AFX_INLINE BOOL AFXAPI CompareElements(const CXTPMarkupObjectPtr* pElement1,
									   const CXTPMarkupObjectPtr* pElement2)
{
	_ASSERTE(NULL != pElement1);
	_ASSERTE(NULL != *pElement1);
	_ASSERTE(NULL != pElement2);

	return (*pElement1)->IsEqual(*pElement2);
}

AFX_INLINE BOOL IsEqual(CXTPMarkupObject* pNewValue, CXTPMarkupObject* pOldValue)
{
	if (pNewValue == NULL && pOldValue == NULL)
		return TRUE;

	if (pNewValue != NULL && pOldValue != NULL)
		return pNewValue->IsEqual(pOldValue);

	return FALSE;
}

#	include "Common/Base/Diagnostic/XTPEnableNoisyWarnings.h"
/** @cond */
#endif // !defined(__XTPMARKUPOBJECT_H__)
/** @endcond */