You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
388 lines
19 KiB
C
388 lines
19 KiB
C
2 years ago
|
// XTPMarkupUIElement.h: interface for the CXTPMarkupUIElement class.
|
||
|
|
//
|
||
|
|
// This file is a part of the XTREME TOOLKIT PRO MFC class library.
|
||
|
|
// (c)1998-2012 Codejock Software, All Rights Reserved.
|
||
|
|
//
|
||
|
|
// THIS SOURCE FILE IS THE PROPERTY OF CODEJOCK SOFTWARE AND IS NOT TO BE
|
||
|
|
// RE-DISTRIBUTED BY ANY MEANS WHATSOEVER WITHOUT THE EXPRESSED WRITTEN
|
||
|
|
// CONSENT OF CODEJOCK SOFTWARE.
|
||
|
|
//
|
||
|
|
// THIS SOURCE CODE CAN ONLY BE USED UNDER THE TERMS AND CONDITIONS OUTLINED
|
||
|
|
// IN THE XTREME TOOLKIT PRO LICENSE AGREEMENT. CODEJOCK SOFTWARE GRANTS TO
|
||
|
|
// YOU (ONE SOFTWARE DEVELOPER) THE LIMITED RIGHT TO USE THIS SOFTWARE ON A
|
||
|
|
// SINGLE COMPUTER.
|
||
|
|
//
|
||
|
|
// CONTACT INFORMATION:
|
||
|
|
// support@codejock.com
|
||
|
|
// http://www.codejock.com
|
||
|
|
//
|
||
|
|
/////////////////////////////////////////////////////////////////////////////
|
||
|
|
|
||
|
|
//{{AFX_CODEJOCK_PRIVATE
|
||
|
|
#if !defined(__XTPMARKUPUIELEMENT_H__)
|
||
|
|
#define __XTPMARKUPUIELEMENT_H__
|
||
|
|
//}}AFX_CODEJOCK_PRIVATE
|
||
|
|
|
||
|
|
#if _MSC_VER > 1000
|
||
|
|
#pragma once
|
||
|
|
#endif // _MSC_VER > 1000
|
||
|
|
|
||
|
|
class CXTPMarkupContext;
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
//===========================================================================
|
||
|
|
// Summary: Provides rendering support for XML Markup, which includes hit testing,
|
||
|
|
// coordinate transformation, and bounding box calculations.
|
||
|
|
//===========================================================================
|
||
|
|
class _XTP_EXT_CLASS CXTPMarkupVisual : public CXTPMarkupInputElement
|
||
|
|
{
|
||
|
|
DECLARE_MARKUPCLASS(CXTPMarkupVisual);
|
||
|
|
public:
|
||
|
|
|
||
|
|
//-------------------------------------------------------------------------
|
||
|
|
// Summary: Provides the base initialization for objects derived from the
|
||
|
|
// CXTPMarkupVisual class.
|
||
|
|
//-------------------------------------------------------------------------
|
||
|
|
CXTPMarkupVisual();
|
||
|
|
|
||
|
|
public:
|
||
|
|
//-------------------------------------------------------------------------
|
||
|
|
// Summary: Call this method to draw Visual object inside drawing context.
|
||
|
|
// Parameters: drawingContext - Drawing context to draw in.
|
||
|
|
//-------------------------------------------------------------------------
|
||
|
|
void Render(CXTPMarkupDrawingContext* drawingContext);
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------
|
||
|
|
// Input: point - Point to test.
|
||
|
|
// Summary: Detects if a point belongs to this object.
|
||
|
|
// Returns: The CXTPMarkupInputElement at the specified point.
|
||
|
|
//-----------------------------------------------------------------------
|
||
|
|
CXTPMarkupInputElement* InputHitTest(CPoint point) const;
|
||
|
|
|
||
|
|
public:
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------
|
||
|
|
// Summary: Gets the number of child elements for the Visual.
|
||
|
|
// Remarks: By default, a Visual has no children. Therefore, the default
|
||
|
|
// implementation always returns 0.
|
||
|
|
// Returns: The number of child elements.
|
||
|
|
//-----------------------------------------------------------------------
|
||
|
|
virtual int GetVisualChildrenCount() const;
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------
|
||
|
|
// Input: nIndex - The index of the visual object in the VisualCollection.
|
||
|
|
// Summary: Returns the specified Visual in the parent VisualCollection.
|
||
|
|
// Returns: The child in the VisualCollection at the specified index value.
|
||
|
|
//-----------------------------------------------------------------------
|
||
|
|
virtual CXTPMarkupVisual* GetVisualChild(int nIndex) const;
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------
|
||
|
|
// Summary: Number of child elements of object
|
||
|
|
// Returns: The number of logical child elements of this object.
|
||
|
|
//-----------------------------------------------------------------------
|
||
|
|
virtual int GetLogicalChildrenCount() const;
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------
|
||
|
|
// Summary: Returns logical child elements of this object.
|
||
|
|
// Parameters: nIndex - The index of the object in the logical objects tree.
|
||
|
|
// Returns: Returns the specified logical child object in the parent collection
|
||
|
|
// Remarks: LogicalChildren allows you to iterate over child elements.
|
||
|
|
// This is useful for elements that may not have a defined, dedicated collection but still contain more than one child element
|
||
|
|
//-----------------------------------------------------------------------
|
||
|
|
virtual CXTPMarkupObject* GetLogicalChild(int nIndex) const;
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------
|
||
|
|
// Summary: Returns bounding rectangle of the element
|
||
|
|
// Returns: Bounding rectangle of the element
|
||
|
|
//-----------------------------------------------------------------------
|
||
|
|
CRect GetBoundRect() const;
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------
|
||
|
|
// Summary: Gets the final render size of this element.
|
||
|
|
// Returns: The rendered size for this element.
|
||
|
|
//-----------------------------------------------------------------------
|
||
|
|
CSize GetRenderSize() const;
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------
|
||
|
|
// Summary: Gets or sets the offset value of the visual object.
|
||
|
|
// Returns: The offset value of the visual object.
|
||
|
|
//-----------------------------------------------------------------------
|
||
|
|
CPoint GetVisualOffset() const;
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------
|
||
|
|
// Input: rc - The available size provided by the element.
|
||
|
|
// Summary: Returns an alternative clipping geometry.
|
||
|
|
// Returns: The potential clipping geometry.
|
||
|
|
//-----------------------------------------------------------------------
|
||
|
|
virtual BOOL GetLayoutClip(CRect& rc) const;
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------
|
||
|
|
// Summary: Gets the visual tree parent of the visual object.
|
||
|
|
// Returns: The Visual parent.
|
||
|
|
//-----------------------------------------------------------------------
|
||
|
|
CXTPMarkupVisual* GetVisualParent() const;
|
||
|
|
|
||
|
|
protected:
|
||
|
|
//-----------------------------------------------------------------------
|
||
|
|
// Summary: When overridden in a derived class, participates in rendering operations that are directed by the layout system
|
||
|
|
// Parameters: drawingContext - Drawing context to draw in.
|
||
|
|
//-----------------------------------------------------------------------
|
||
|
|
virtual void OnRender(CXTPMarkupDrawingContext* drawingContext);
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------
|
||
|
|
// Summary: This method is called to render focus rectangle of focused object
|
||
|
|
// Parameters: drawingContext - Drawing context to draw in.
|
||
|
|
//-----------------------------------------------------------------------
|
||
|
|
virtual void OnRenderFocusVisual(CXTPMarkupDrawingContext* drawingContext);
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------
|
||
|
|
// Summary: Override this method in derived class to provide visual hit testing of child object
|
||
|
|
// Parameters: point - POisiotn of cursor to test.
|
||
|
|
//-----------------------------------------------------------------------
|
||
|
|
virtual CXTPMarkupInputElement* InputHitTestOverride(CPoint point) const;
|
||
|
|
|
||
|
|
virtual void RenderClipped(CXTPMarkupDrawingContext* drawingContext);
|
||
|
|
|
||
|
|
//{{AFX_CODEJOCK_PRIVATE
|
||
|
|
// Internal methods
|
||
|
|
protected:
|
||
|
|
void UpdateBoundRect();
|
||
|
|
//}}AFX_CODEJOCK_PRIVATE
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
protected:
|
||
|
|
CPoint m_ptVisualOffset; // The offset value of the visual object.
|
||
|
|
CSize m_szRenderSize; // The rendered size for this element.
|
||
|
|
CRect m_rcBoundRect; // Bounding rectangle of the element
|
||
|
|
};
|
||
|
|
|
||
|
|
|
||
|
|
//===========================================================================
|
||
|
|
// Summary: Base class for XML Markup core level implementations.
|
||
|
|
//===========================================================================
|
||
|
|
class _XTP_EXT_CLASS CXTPMarkupUIElement : public CXTPMarkupVisual
|
||
|
|
{
|
||
|
|
DECLARE_MARKUPCLASS(CXTPMarkupUIElement);
|
||
|
|
|
||
|
|
protected:
|
||
|
|
|
||
|
|
//-------------------------------------------------------------------------
|
||
|
|
// Summary: Initializes a new instance of the CXTPMarkupUIElement class.
|
||
|
|
//-------------------------------------------------------------------------
|
||
|
|
CXTPMarkupUIElement();
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------
|
||
|
|
// Summary:
|
||
|
|
// Destroys a CXTPMarkupUIElement object, handles cleanup and deallocation
|
||
|
|
//-----------------------------------------------------------------------
|
||
|
|
virtual ~CXTPMarkupUIElement();
|
||
|
|
|
||
|
|
public:
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------
|
||
|
|
// Input: rcFinalRect - The final size that the parent computes for the child
|
||
|
|
// element, provided as a CRect instance.
|
||
|
|
// Summary: Positions child elements and determines a size for a CXTPMarkupUIElement.
|
||
|
|
// Parent elements call this method from their ArrangeOverride implementation
|
||
|
|
// to form a recursive layout update. This method constitutes the
|
||
|
|
// second pass of a layout update.
|
||
|
|
//-----------------------------------------------------------------------
|
||
|
|
void Arrange(CRect rcFinalRect);
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------
|
||
|
|
// Input: pDC - Pointer to a CXTPMarkupDrawingContext.
|
||
|
|
// szAvailableSize - The available space that a parent element can allocate
|
||
|
|
// a child element. A child element can request a larger
|
||
|
|
// space than what is available; the provided size might
|
||
|
|
// be accommodated if scrolling is possible in the
|
||
|
|
// content model for the current element.
|
||
|
|
// Summary: Updates the DesiredSize of a CXTPMarkupUIElement. Parent elements call
|
||
|
|
// this method from their own MeasureOvveride implementations to form
|
||
|
|
// a recursive layout update. Calling this method constitutes
|
||
|
|
// the first pass (the "Measure" pass) of a layout update.
|
||
|
|
//-----------------------------------------------------------------------
|
||
|
|
void Measure(CXTPMarkupDrawingContext* pDC, CSize szAvailableSize);
|
||
|
|
|
||
|
|
public:
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------
|
||
|
|
// Summary: Gets the size that this element computed during the measure pass of the layout process.
|
||
|
|
// Returns: The computed size, which becomes the desired size for the arrange pass.
|
||
|
|
// Remarks: DesiredSize is typically checked as one of the measurement
|
||
|
|
// factors when you implement layout behavior overrides such
|
||
|
|
// as ArrangeOverride, MeasureOverride or OnRender.
|
||
|
|
//-----------------------------------------------------------------------
|
||
|
|
CSize GetDesiredSize() const;
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------
|
||
|
|
// Summary: Gets the final render size of this element.
|
||
|
|
// Returns: The rendered size for this element.
|
||
|
|
//-----------------------------------------------------------------------
|
||
|
|
CRect GetFinalRect() const;
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------
|
||
|
|
// Summary: Gets the user interface (UI) visibility of this element. This
|
||
|
|
// is a dependency property.
|
||
|
|
// Returns: XTPMarkupVisibility enumerator.
|
||
|
|
//-----------------------------------------------------------------------
|
||
|
|
XTPMarkupVisibility GetVisibility() const;
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------
|
||
|
|
// Input: visibility - A value of the XTPMarkupVisibility enumeration. The default value is Visible.
|
||
|
|
// Summary: Sets the user interface (UI) visibility of this element. This
|
||
|
|
// is a dependency property.
|
||
|
|
//-----------------------------------------------------------------------
|
||
|
|
void SetVisibility(XTPMarkupVisibility visibility);
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------
|
||
|
|
// Summary: Gets or sets a value that indicates whether the element can
|
||
|
|
// receive focus. This is a dependency property.
|
||
|
|
// Returns: TRUE if the element is focusable; otherwise false. The
|
||
|
|
// default is false, but see Remarks.
|
||
|
|
//-----------------------------------------------------------------------
|
||
|
|
BOOL IsFocusable() const;
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------
|
||
|
|
// Summary: Gets a value indicating whether this element is visible in
|
||
|
|
// the user interface (UI). This is a dependency property.
|
||
|
|
// Returns: true if the element is visible; otherwise, false.
|
||
|
|
//-----------------------------------------------------------------------
|
||
|
|
BOOL IsVisible() const;
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------
|
||
|
|
// Summary: Gets or sets a value indicating whether this element is
|
||
|
|
// enabled in the user interface (UI). This is a dependency property.
|
||
|
|
// Returns: true if the element is enabled; otherwise, false. The
|
||
|
|
// default value is true.
|
||
|
|
//-----------------------------------------------------------------------
|
||
|
|
BOOL IsEnabled() const;
|
||
|
|
|
||
|
|
public:
|
||
|
|
|
||
|
|
//-------------------------------------------------------------------------
|
||
|
|
// Summary: Invalidates the arrange state (layout) for the element.
|
||
|
|
// Remarks: Frequent calls to InvalidateArrange have significant performance
|
||
|
|
// consequences. Therefore, avoid calling this method unless you
|
||
|
|
// absolutely require precise layout state for subsequent calls to
|
||
|
|
// other APIs in your code.
|
||
|
|
//-------------------------------------------------------------------------
|
||
|
|
virtual void InvalidateArrange();
|
||
|
|
|
||
|
|
//-------------------------------------------------------------------------
|
||
|
|
// Summary: Invalidates the rendering of the element, and forces a complete
|
||
|
|
// new layout pass. OnRender is called after the layout cycle is completed.
|
||
|
|
// Remarks: This method calls InvalidateArrange internally.
|
||
|
|
//-------------------------------------------------------------------------
|
||
|
|
virtual void InvalidateVisual();
|
||
|
|
|
||
|
|
//-------------------------------------------------------------------------
|
||
|
|
// Summary: Invalidates the measurement state (layout) for the element.
|
||
|
|
// Remarks: Calling this method also calls InvalidateArrange internally,
|
||
|
|
// there is no need to call InvalidateMeasure and
|
||
|
|
// InvalidateArrange in succession.
|
||
|
|
//-------------------------------------------------------------------------
|
||
|
|
virtual void InvalidateMeasure();
|
||
|
|
|
||
|
|
protected:
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------
|
||
|
|
// Input: rcFinalRect - The final area within the parent that element
|
||
|
|
// should use to arrange itself and its child elements.
|
||
|
|
// Summary: Defines the template for the core-level arrange layout definition.
|
||
|
|
//-----------------------------------------------------------------------
|
||
|
|
virtual void ArrangeCore(CRect rcFinalRect);
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------
|
||
|
|
// Input: szAvailableSize - The available size that the parent element can
|
||
|
|
// allocate for the child.
|
||
|
|
// pDC - Device context.
|
||
|
|
// Summary: When overridden in a derived class, provides measurement logic
|
||
|
|
// for sizing this element properly, with consideration of the
|
||
|
|
// size of any child element content.
|
||
|
|
// Returns: The desired size of this element in layout.
|
||
|
|
//-----------------------------------------------------------------------
|
||
|
|
virtual CSize MeasureCore(CXTPMarkupDrawingContext* pDC, CSize szAvailableSize);
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------
|
||
|
|
// Input: rc - The available size provided by the element.
|
||
|
|
// Summary: Returns an alternative clipping geometry that represents the
|
||
|
|
// region that would be clipped if m_pClipToBoundsProperty were set to true.
|
||
|
|
// Returns: The potential clipping geometry.
|
||
|
|
//-----------------------------------------------------------------------
|
||
|
|
virtual BOOL GetLayoutClip(CRect& rc) const;
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------
|
||
|
|
// Summary: Override this method to provide custom reaction on InvalidateMeasure call.
|
||
|
|
// Parameters: pDC - Device context to measure.
|
||
|
|
//-----------------------------------------------------------------------
|
||
|
|
virtual void InvalidateMeasureOverride(CXTPMarkupDrawingContext* pDC);
|
||
|
|
|
||
|
|
|
||
|
|
protected:
|
||
|
|
CSize m_szDesiredSize; // Gets the size that this element computed during the measure pass of the layout process.
|
||
|
|
CRect m_rcFinalRect; // Final position of visual element
|
||
|
|
BOOL m_bMeasureDirty; // TRUE if object haven't recalculate its size
|
||
|
|
BOOL m_bNeverMeasured; // TRUE if object never run Measure to update its size
|
||
|
|
CSize m_szPreviousAvailableSize; // Previous available size of measure call
|
||
|
|
BOOL m_bArrangeDirty; // TRUE if object position can be invalid
|
||
|
|
BOOL m_bNeverArranged; // TRUE if Arrange never called for this object
|
||
|
|
BOOL m_bArrangeInProgress; // TRUE if Arrange is currently executed.
|
||
|
|
BOOL m_bMeasureInProgress; // TRUE if Measure is currently executed.
|
||
|
|
|
||
|
|
public:
|
||
|
|
static CXTPMarkupDependencyProperty* m_pClipToBoundsProperty; // Gets or sets a value indicating whether to
|
||
|
|
// clip the content of this element (or content
|
||
|
|
// coming from the child elements of this element)
|
||
|
|
// to fit into the size of the containing element. This is a dependency property.
|
||
|
|
static CXTPMarkupDependencyProperty* m_pVisibilityProperty; // A value indicating whether this element is visible in the user interface (UI).
|
||
|
|
static CXTPMarkupDependencyProperty* m_pFocusableProperty; // A value that indicates whether the element can receive focus.
|
||
|
|
static CXTPMarkupDependencyProperty* m_pIsEnabledProperty; // A value indicating whether this element is enabled in the user interface (UI).
|
||
|
|
};
|
||
|
|
|
||
|
|
|
||
|
|
AFX_INLINE void CXTPMarkupVisual::OnRender(CXTPMarkupDrawingContext* /*drawingContext*/) {
|
||
|
|
|
||
|
|
}
|
||
|
|
AFX_INLINE void CXTPMarkupVisual::OnRenderFocusVisual(CXTPMarkupDrawingContext* /*drawingContext*/) {
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
AFX_INLINE CSize CXTPMarkupVisual::GetRenderSize() const {
|
||
|
|
return m_szRenderSize;
|
||
|
|
}
|
||
|
|
AFX_INLINE CRect CXTPMarkupVisual::GetBoundRect() const {
|
||
|
|
return m_rcBoundRect;
|
||
|
|
}
|
||
|
|
AFX_INLINE CPoint CXTPMarkupVisual::GetVisualOffset() const {
|
||
|
|
return m_ptVisualOffset;
|
||
|
|
}
|
||
|
|
AFX_INLINE CSize CXTPMarkupUIElement::GetDesiredSize() const {
|
||
|
|
return m_szDesiredSize;
|
||
|
|
}
|
||
|
|
AFX_INLINE CRect CXTPMarkupUIElement::GetFinalRect() const {
|
||
|
|
return m_rcFinalRect;
|
||
|
|
}
|
||
|
|
AFX_INLINE XTPMarkupVisibility CXTPMarkupUIElement::GetVisibility() const {
|
||
|
|
CXTPMarkupEnum* pValue = MARKUP_STATICCAST(CXTPMarkupEnum, GetValue(m_pVisibilityProperty));
|
||
|
|
return pValue ? (XTPMarkupVisibility)(int)*pValue : xtpMarkupVisibilityVisible;
|
||
|
|
}
|
||
|
|
AFX_INLINE void CXTPMarkupUIElement::SetVisibility(XTPMarkupVisibility visibility) {
|
||
|
|
SetValue(m_pVisibilityProperty, CXTPMarkupEnum::CreateValue(visibility));
|
||
|
|
}
|
||
|
|
AFX_INLINE BOOL CXTPMarkupUIElement::IsFocusable() const {
|
||
|
|
CXTPMarkupBool* pValue = MARKUP_STATICCAST(CXTPMarkupBool, GetValue(m_pFocusableProperty));
|
||
|
|
return pValue ? (BOOL)*pValue : FALSE;
|
||
|
|
}
|
||
|
|
AFX_INLINE BOOL CXTPMarkupUIElement::IsVisible() const {
|
||
|
|
return GetVisibility() == xtpMarkupVisibilityVisible;
|
||
|
|
}
|
||
|
|
AFX_INLINE BOOL CXTPMarkupUIElement::IsEnabled() const {
|
||
|
|
CXTPMarkupBool* pValue = MARKUP_STATICCAST(CXTPMarkupBool, GetValue(m_pIsEnabledProperty));
|
||
|
|
return pValue ? (BOOL)*pValue : TRUE;
|
||
|
|
}
|
||
|
|
|
||
|
|
#endif // !defined(__XTPMARKUPUIELEMENT_H__)
|