/**
 * @file XTPFlowGraphNode.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(__XTPFLOWGRAPHNODE_H__)
#	define __XTPFLOWGRAPHNODE_H__
/** @endcond */

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

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

class CXTPFlowGraphPage;
class CXTPFlowGraphDrawContext;
class CXTPFlowGraphControl;
class CXTPFlowGraphConnectionPoints;
class CXTPFlowGraphConnectionPoint;
class CXTPFlowGraphNodeGroup;
class CXTPPropExchange;
class CXTPFlowGraphImage;
class CXTPFlowGraphSelectionRect;

class CXTPMarkupUIElement;
class CXTPMarkupObject;
class CXTPMarkupUIElementCollection;
class CXTPMarkupVisual;
class CXTPMarkupTextBlock;

#	define XAML_MARKUP_PROPERTY_CPNAME L"CPName"
#	define XAML_MARKUP_PROPERTY_CPTYPE L"CPType"
#	define XAML_MARKUP_PROPERTY_CANSETCOLOR L"CanSetColor"
#	define XAML_MARKUP_PROPERTY_CPOINTS_IN L"ConnectionPointsIn"
#	define XAML_MARKUP_PROPERTY_RESIZABLE L"Resizable"

#	define XAML_MARKUP_TAG_ITEMSCOLLECTION L"nodeItemsCollection"
#	define XAML_MARKUP_TAG_CUSTOMCONTROL L"nodeCustomControl"
#	define XAML_MARKUP_TAG_NODECAPTION L"nodeCaption"
#	define XAML_MARKUP_TAG_NODECAPTIONBORDER L"nodeCaptionBorder"
#	define XAML_MARKUP_TAG_NODE_ITEM_CAPTION L"nodeItemCaption"
#	define XAML_MARKUP_TAG_NODE_ITEM_IMAGE L"nodeItemImage"
#	define XAML_MARKUP_TAG_NODEIMAGE L"nodeImage"
#	define XAML_MARKUP_TAG_NODECONTENT L"nodeContent"

#	define XAML_MARKUP_CPNAME_PLACEHOLDER _T("%CPNAME%")
#	define XAML_MARKUP_CPCAPTION_PLACEHOLDER _T("%CPCAPTION%")

#	define XAML_MARKUP_RESOURCENAME_NODE _T("FLOWGRAPH_XAML_NODE")
#	define XAML_MARKUP_RESOURCENAME_NODE_ITEM _T("FLOWGRAPH_XAML_NODE_ITEM")
#	define XAML_MARKUP_RESOURCENAME_NODE_ITEM_IN _T("FLOWGRAPH_XAML_NODE_ITEM_IN")
#	define XAML_MARKUP_RESOURCENAME_NODE_ITEM_OUT _T("FLOWGRAPH_XAML_NODE_ITEM_OUT")
#	define XAML_MARKUP_RESOURCENAME_NODE_ITEM_INOUT _T("FLOWGRAPH_XAML_NODE_ITEM_INOUT")

/**
 * @brief
 * Node connection point types (input/output).
 * @details
 * The xtpFlowGraphConnectionPointType is used to specify whether a
 * CXTPFlowGraphConnection will have any connection points.
 * Connection points are used to make connections between connections
 * in different Nodes.
 * @see
 * CXTPFlowGraphConnectionPoint::SetType
 */
enum XTPFlowGraphConnectionPointType
{
	xtpFlowGraphPointNone   = 0, /**< Connection has no connection points.*/
	xtpFlowGraphPointInput  = 1, /**< Connection only has an input point.*/
	xtpFlowGraphPointOutput = 2, /**< Connection only has an output point.*/

	/**
	 * Connection has both input and output points. For the default node type.
	 * When iterating connection points, you will never find a connection point of
	 * this type. It is used to add a table row with actual 2 connection points:
	 * xtpFlowGraphPointInput and xtpFlowGraphPointOutput.
	 */
	xtpFlowGraphPointInputAndOutput = 3,

	/**
	 * A new connection point type for other shapes.
	 */
	xtpFlowGraphPointBoth = 4

};

/**
 * @brief
 * Represents a Node object.
 * @details
 * Nodes are the main objects that are displayed in the flow graph.
 * In terms of a database, they can be thought of as tables. Nodes contain
 * many connection points, which are like the fields in a table. Finally,
 * there are connections that are used to draw a relationship between the
 * fields of two tables.
 */
class _XTP_EXT_CLASS CXTPFlowGraphNode : public CXTPFlowGraphElement
{
	DECLARE_SERIAL(CXTPFlowGraphNode);

public:
	/**
	 * @brief
	 * Constructs a CXTPFlowGraphNode object.
	 */
	CXTPFlowGraphNode();
	/**
	 * @brief
	 * Destroys a CXTPFlowGraphNode object, handles cleanup and
	 * deallocation.
	 */
	virtual ~CXTPFlowGraphNode();

public:
	/**
	 * @brief
	 * Sets the caption that is displayed for this Node.
	 * @param lpszCaption Caption to displayed for this Node.
	 * @details
	 * The Node's caption will be displayed at the top of the Node and
	 * its background color is the same color as the Node, which is, by
	 * default, a different color than the connection points that get
	 * added to the node.
	 */
	void SetCaption(LPCTSTR lpszCaption);
	/**
	 * @brief
	 * Gets the caption that is displayed for this Node.
	 * @details
	 * The Node's caption will be displayed at the top of the Node and
	 * its background color is the same color as the Node, which is, by
	 * default, a different color than the connection points that get
	 * added to the node.
	 * @return
	 * The caption that is displayed for this Node.
	 */
	CString GetCaption() const;

	/**
	 * @brief
	 * Sets the tooltip for this Node.
	 * @param lpszTooltip New tooltip for this Node.
	 * @details
	 * This is the text that is displayed when the mouse is hovered over
	 * the Node.
	 */
	void SetTooltip(LPCTSTR lpszTooltip);
	/**
	 * @brief
	 * Gets the tooltip for this Node.
	 * @details
	 * This is the text that is displayed when the mouse is hovered over
	 * the Node.
	 * @return
	 * The tooltip for this Node.
	 */
	CString GetTooltip() const;

	/**
	 * @brief
	 * Sets the color for the Node.
	 * @param clr New color for the Node.
	 * @param bAlpha Alpha value for Node.
	 */
	virtual void SetColor(COLORREF clr, BYTE bAlpha = 255);
	/**
	 * @brief
	 * Gets the color of the node.
	 * @return
	 * The color of the node.
	 */
	COLORREF GetColor() const;

	/**
	 * @brief
	 * Reserved for future use. Currently can be used as a "tag" property
	 * if needed.
	 * @param nStyle Style value.
	 */
	void SetStyle(int nStyle);
	/**
	 * @brief
	 * Reserved for future use. Currently can be used as a "tag" property
	 * if needed.
	 * @return Current style value.
	 */
	int GetStyle() const;

	/**
	 * @brief
	 * This method sets the 32-bit value associated with the Node.
	 * @param dwTag New 32-bit value to associate with the Node.
	 * @details
	 * The tag is used to store any arbitrary value that must be
	 * associated with the Node.
	 */
	void SetTag(DWORD_PTR dwTag);
	/**
	 * @brief
	 * This method retrieves the application-supplied, 32-bit value
	 * associated with the Node.
	 * @details
	 * The tag is used to store any arbitrary value that must be
	 * associated with the Node.
	 * @return
	 * The 32-bit value associated with the Node.
	 */
	DWORD_PTR GetTag() const;

	/**
	 * @brief
	 * Sets the ID used to identify this Node.
	 * @param nId New ID to be used to identify this Node.
	 */
	void SetID(int nId);
	/**
	 * @brief
	 * Gets the ID used to identify this Node.
	 * @return
	 * The ID used to identify this Node.
	 */
	int GetID() const;

	/**
	 * @brief
	 * Call this member to associate an object with the Node. This will
	 * tell the Node what to display (i.e. the HWND of a dialog).
	 * @param hWnd HWND of the object that should be displayed in the Node.
	 */
	virtual void SetWindowHandle(HWND hWnd);
	/**
	 * @brief
	 * Call this member to get the HWND of the object associated with the
	 * Node. This is the HWND of the object that is displayed in the Node.
	 * @return
	 * The HWND of the object associated with the Node.
	 */
	HWND GetWindowHandle() const;

	/**
	 * @brief
	 * Sets the size of the window for the external control that is
	 * attached to the Node (if applicable).
	 * @param sz New size of the window.
	 * @details
	 * This will set the size for the attached external control (i.e. if
	 * a tree control is attached to the node). You would attach the
	 * external control using the SetWindowHandle method.
	 */
	virtual void SetWindowSize(CSize sz);
	/**
	 * @brief
	 * Gets the size of the window for the external control that is
	 * attached to the Node (if applicable).
	 * @details
	 * This will get the size for the attached external control (i.e. if
	 * a tree control is attached to the node). This is the size of the
	 * window of the control that was attached using the SetWindowHandle
	 * method.
	 * @return
	 * The size of the window for the external control that is attached
	 * to the Node.
	 */
	CSize GetWindowSize() const;

	/**
	 * @brief
	 * Sets the ID of the image to display next to the caption text of
	 * the Node.
	 * @param nImageIndex The ID of the image to display next to the caption
	 * text of the Node.
	 * @details
	 * Use the image index to specify the index of the previously loaded
	 * image to display next to the caption text of the node.
	 */
	void SetImageIndex(int nImageIndex);
	/**
	 * @brief
	 * Gets the ID of the image to display next to the caption text of
	 * the Node.
	 * @return
	 * The ID of the image to display next to the caption text of the Node.
	 */
	int GetImageIndex() const;

	/**
	 * @brief
	 * Sets the locked state of the Node.
	 * @param bLocked TRUE to set the Node to locked, FALSE otherwise.
	 * @details
	 * If the Node is locked, then its connection points
	 * cannot accept connection lines and any connection
	 * lines that were added cannot be removed.
	 */
	void SetLocked(BOOL bLocked = TRUE);

	/**
	 * @brief
	 * Gets the locked state of the Node.
	 * @details
	 * If the Node is locked, then its connection points
	 * cannot accept connection lines and any connection
	 * lines that were added cannot be removed.
	 * @return
	 * TRUE if the Node is locked, otherwise FALSE.
	 */
	BOOL IsLocked() const;

	/**
	 * @brief
	 * Sets the visibility of the Node and its connections.
	 * @param bVisible TRUE to set the Node and its connections to visible,
	 * FALSE to set the Node and its connections to invisible.
	 */
	void SetVisible(BOOL bVisible = TRUE);

	/**
	 * @brief
	 * Gets the visibility of the Node and its connections.
	 * @return
	 * TRUE if the Node and its connections are visible, otherwise FALSE.
	 */
	BOOL IsVisible() const;

public:
	/**
	 * @brief
	 * Sets the location of the Node.
	 * @param ptLocation Point containing the x- and y- coordinates for the
	 * location of the Node.
	 */
	void SetLocation(CPoint ptLocation);
	/**
	 * @brief
	 * Gets the location of the Node.
	 * @return
	 * A point containing the x- and y- coordinates of the location of
	 * the Node.
	 */
	CPoint GetLocation() const;

	/**
	 * @brief
	 * Sets the size for the Node (Node's Markup!).
	 * @param sz New size for the Node.
	 */
	virtual void SetSize(CSize sz);

	/**
	 * @brief
	 * Sets the size for the Node.
	 * @param sz New size for the Node.
	 */
	void SetSizeCore(CSize sz);

	/**
	 * @brief
	 * Gets the size of the Node.
	 * @return
	 * A CSize object containing the size of the Node.
	 */
	CSize GetSize() const;

	/**
	 * @brief
	 * Gets the size of the Node (including user resizing).
	 * @return
	 * The size of the Node.
	 */
	CSize GetUserSize() const;

	/**
	 * @brief
	 * Checks if the Node is resizable.
	 * @return
	 * TRUE if the Node is resizable.
	 */
	BOOL IsResizable() const;

	/**
	 * @brief
	 * Gets the minimum size of the Node; calculated in the CalcMinSize method.
	 * @return
	 * The minimum size of the Node
	 */
	CSize GetMinSize() const;

	/**
	 * @brief
	 * Sets the minimum size for the Node.
	 * @param sz New minimum size for the Node.
	 */
	void SetMinSize(CSize sz);

	/**
	 * @brief
	 * Gets the screen coordinates for the Node.
	 * @param bIncludeConnectionPointsEllipses TRUE to include connection points ellipses
	 * @return
	 * The screen coordinates for the Node.
	 */
	CRect GetScreenRect(BOOL bIncludeConnectionPointsEllipses = TRUE) const;

	virtual CRect GetBoundingRectangle(BOOL bIncludeConnectionPointsEllipses = TRUE) const;

public:
	/**
	 * @brief
	 * Gets a reference to the page that this Node belongs to.
	 * @return
	 * A reference to the page that this Node belongs to.
	 */
	CXTPFlowGraphPage* GetPage() const;
	/**
	 * @brief
	 * Retrieves the group that this Node is a part of (if any).
	 * @details
	 * A group is just a "box" that is used to visually group Nodes
	 * together. By default, the group will only be shown when a Node in
	 * the group is selected, but you can choose to always show the
	 * groups with ShowNodeGroupsAlways.
	 * @return
	 * A reference to the group that this Node is a part of (if any),
	 * otherwise NULL.
	 */
	CXTPFlowGraphNodeGroup* GetGroup() const;
	/**
	 * @brief
	 * Gets the image to display next to the caption text of the Node.
	 * @return
	 * A pointer to the image to display next to the caption text of the Node.
	 */
	CXTPFlowGraphImage* GetImage() const;
	/**
	 * @brief
	 * Gets the connection points collection for this Node.
	 * @return
	 * A pointer to the connection points collection for this Node.
	 */
	CXTPFlowGraphConnectionPoints* GetConnectionPoints() const;
	/**
	 * @brief
	 * Gets a reference to the parent FlowGraph control.
	 * @return
	 * A reference to the parent FlowGraph control.
	 */
	CXTPFlowGraphControl* GetControl() const;

public:
	/**
	 * @brief
	 * Removes this node from the flow graph.
	 */
	void Remove();

public:
	/**
	 * @brief
	 * Determines which connection point, if any, is at a specified point.
	 * @param point Point to be tested.
	 * @return
	 * A pointer to the connection point found at the specified point, if any,
	 * or NULL if no connection point is found.
	 */
	virtual CXTPFlowGraphConnectionPoint* HitTestConnectionPoint(CPoint point);

	/**
	 * @brief
	 * Updates the window position of the attached external control.
	 * @details
	 * This method is also called internally when the Node is drawn.
	 */
	virtual void UpdateWindowPosition();

	/**
	 * @brief
	 * Draws the contents of the Node.
	 * @param pDC Pointer to a CXTPFlowGraphDrawContext object.
	 */
	virtual void DrawWindowContent(CXTPFlowGraphDrawContext* pDC);

	/**
	 * @brief
	 * Specifies the selected state of the Node.
	 * @param bSelect TRUE to set the Node to selected, FALSE otherwise.
	 */
	virtual void Select(BOOL bSelect = TRUE);

public:
	/**
	 * @brief
	 * Call this member function to store/load a Node using the specified data object.
	 * @param pPX Source/destination CXTPPropExchange data object reference.
	 * @details
	 * This member function is used to store/load Node data to/from storage.
	 */
	virtual void DoPropExchange(CXTPPropExchange* pPX);

	/**
	 * @brief
	 * Stores/loads Node common properties (for both default and derived Nodes).
	 * @param pPX Source/destination CXTPPropExchange data object reference.
	 * @details
	 * This function is called automatically in both default and custom Nodes.
	 */
	void DoCommonPropExchange(CXTPPropExchange* pPX);

public:
	/**
	 * @details
	 * Recalculates the layout of the Node.
	 * @details
	 * Call this functions to correctly reposition the connections within
	 * the Node. This also will readjust the layout when the size or
	 * caption has changed.
	 */
	virtual void RecalLayout();
	/**
	 * @brief
	 * This method is called to draw the Node.
	 * @param pDC Pointer to a valid device context.
	 */
	virtual void Draw(CXTPFlowGraphDrawContext* pDC);

	/**
	 * @brief
	 * Retrieves the Node's selection rectangle (visible only when the Node is selected).
	 * @return
	 * The Node's selection rectangle.
	 */
	CRect GetSelectionRect() const;

	/**
	 * @brief
	 * This virtual method is called to draw the Node's selection rectangle.
	 * @param pDC Pointer to a valid device context.
	 */
	virtual void DrawSelectionRect(CXTPFlowGraphDrawContext* pDC);

	/**
	 * @brief
	 * A virtual method that draws the Node's connection points (circles)
	 * in their placeholders.
	 * @param pDC Pointer to a valid device context.
	 */
	virtual void DrawConnectionPoints(CXTPFlowGraphDrawContext* pDC);

	/**
	 * @brief
	 * A virtual method that calculates the minimum size of the Node
	 * (used in resizing mechanism).
	 */
	virtual void CalcMinSize();

	// Default Markup support:

public:
	/**
	 * @brief
	 * Adds a table row to the Node (of default type), with none, one, or
	 * two real connection points.
	 * @param szName Unique name.
	 * @param szCaption Caption of the table row. Uses szName if not specified.
	 * @param type Type.
	 * @details
	 * Parameters :
	 * xtpFlowGraphPointNone           No actual connection points.
	 * xtpFlowGraphPointInput          One connection point (in the left of the row).
	 * xtpFlowGraphPointOutput         One connection point (in the right of the row).
	 * xtpFlowGraphPointInputAndOutput Two connection points (in the left and right of the
	 * row).
	 */
	virtual void AddNamedConnectionPoints(
		LPCTSTR szName, XTPFlowGraphConnectionPointType type = xtpFlowGraphPointNone,
		LPCTSTR szCaption = NULL);

	/**
	 * @brief
	 * An important common method used to get a rectangle of any visual
	 * Markup element.
	 * @details
	 * Rectangle coordinates are relative to the Markup root element
	 * (\<Border>\ for example).
	 * @param pElementVisual Pointer to a valid visual markup element.
	 * @return
	 * The rectangle of the visual markup element.
	 */
	CRect GetMarkupVisualElementRect(const CXTPMarkupVisual* pElementVisual) const;

	/**
	 * @brief
	 * Retrieves the index of a table row in the list (to insert a new one).
	 * @param pPoint    Pointer to a connection point object located in this row.
	 * @param pChildren Pointer to a collection of markup elements from which
	 * the index of the element associated with the specified
	 * connection point object is to be returned.
	 * @return
	 * The index of the collection element associated with the
	 * specified connection point object.
	 */
	int GetMarkupTableRowIndex(CXTPFlowGraphConnectionPoint* pPoint,
							   CXTPMarkupUIElementCollection* pChildren);

	/**
	 * @brief
	 * Removes a table row (with its connection points) from a default Node.
	 * @param pPoint Pointer to a connection point that is located in the table row.
	 * @return
	 * The index of the removed table row in the table rows list.
	 */
	int RemoveMarkupTableRow(CXTPFlowGraphConnectionPoint* pPoint);

	/**
	 * @brief
	 * Retrieves the XAML TextBlock element for a table row of a default Node.
	 * @param strConnectionPointName The name of a connection point located within
	 * the table row with the XAML TextBlock element
	 * to be retrieved.
	 * @return
	 * A pointer to a CXTPMarkupTextBlock element.
	 */
	CXTPMarkupTextBlock* GetTableRowTextBlock(const CString& strConnectionPointName) const;

	/**
	 * @brief
	 * Retrieves the rectangle of a XAML TextBlock element for a table row of
	 * a default Node.
	 * @param pPoint Pointer to a connection point that is located in the table row.
	 * @return
	 * The rectangle of the XAML TextBlock element. Coordinates are relative
	 * to the Node's location.
	 */
	CRect GetTableRowCaptionRect(CXTPFlowGraphConnectionPoint* pPoint) const;

	/**
	 * @brief
	 * Sets the default XAML Markup for a default Node with zero table rows.
	 */
	virtual void SetDefaultMarkup();

	/**
	 * @brief
	 * Updates the Markup point caption (when changed or restored using DoPropExchange).
	 * @param pPoint Pointer to a CXTPFlowGraphConnectionPoint object.
	 */
	void UpdateMarkupPointCaption(CXTPFlowGraphConnectionPoint* pPoint);

	/**
	 * @brief
	 * Updates the Markup point name (when changed or restored using DoPropExchange).
	 * @param pPoint Pointer to a CXTPFlowGraphConnectionPoint object.
	 */
	void UpdateMarkupPointName(CXTPFlowGraphConnectionPoint* pPoint);

	/**
	 * @brief
	 * Updates the Markup point color (when changed or restored using DoPropExchange).
	 * @param pPoint Pointer to a CXTPFlowGraphConnectionPoint object.
	 */
	virtual void UpdateMarkupPointColor(CXTPFlowGraphConnectionPoint* pPoint);

	/**
	 * @brief
	 * Updates the markup point image (when changed or restored using DoPropExchange).
	 * @param pPoint Pointer to a CXTPFlowGraphConnectionPoint object.
	 */
	void UpdateMarkupPointImage(CXTPFlowGraphConnectionPoint* pPoint);

	/**
	 * @brief
	 * Sets Markup text for the Node (for a custom Node).
	 * @param szMarkupText Markup text to set.
	 * @return
	 * TRUE if successful, otherwise FALSE.
	 */
	BOOL SetMarkupText(LPCTSTR szMarkupText);

	/**
	 * @brief
	 * A virtual function that determines if the Node is a custom Node
	 * (a Node with custom XAML markup).
	 * @return
	 * TRUE if the Node is a custom Node, otherwise FALSE.
	 */
	virtual BOOL IsCustomMarkup() const
	{
		return FALSE;
	}

	/**
	 * @brief
	 * A virtual method that finds and updates real connection points in the Markup.
	 * @param pRootElement An XAML element used to search for connection points in
	 * its children.
	 * @details
	 * Implementation of this method for default Nodes is recursive.
	 * A rectangle for a connection point is defined by the \<Rectangle\> element
	 * in XAML for default Nodes.
	 * Implementation of this method for custom Nodes uses an absolutely different
	 * approach (see CXTPFlowGraphNodeCustom::UpdateConnectionPoints).
	 */
	virtual void UpdateConnectionPoints(CXTPMarkupObject* pRootElement);

	/**
	 * @brief
	 * A recursive method to update/set the color of a Node.
	 * @param pRootElement An XAML element used to search for XAML elements that can have
	 * a color property (see XAML_MARKUP_PROPERTY_CANSETCOLOR).
	 * @param clrColor     Color to be set.
	 */
	virtual void UpdateColorRecursive(CXTPMarkupObject* pRootElement, COLORREF clrColor);

	/**
	 * @brief
	 * Updates the foreground color of the CXTPMarkupTextBlock element
	 * of the Node's caption.
	 */
	virtual void UpdateCaptionColor();

	/**
	 * @brief
	 * Updates the Node's image.
	 */
	virtual void UpdateMarkupImage();

	/**
	 * @brief
	 * Updates Node's caption \<TextBlock\> element with Node's caption text
	 * (m_strCaption).
	 * @return
	 * A pointer to a CXTPMarkupTextBlock element.
	 */
	virtual CXTPMarkupTextBlock* UpdateMarkupCaption();

	/**
	 * @brief
	 * Get the Node's caption \<TextBlock\> element.
	 * @return
	 * A pointer to a CXTPMarkupTextBlock element.
	 */
	CXTPMarkupTextBlock* GetCaptionTextBlock() const;

	/**
	 * @brief
	 * Get the Node's caption \<TextBlock\> rectangle.
	 * @return
	 * The Node's caption \<TextBlock\> rectangle. Coordinates are relative
	 * to the Node's location.
	 */
	CRect GetCaptionRect() const;

	/**
	 * @brief
	 * Updates the default font defined in the paint manager; used in Markup drawing.
	 */
	virtual void UpdateMarkupFont();

protected:
	/**
	 * @brief
	 * This method is called when the Node is removed.
	 */
	virtual void OnRemoved();

	static LRESULT CALLBACK ControlWindowProc(HWND hwnd, UINT uMsg, WPARAM wParam,
											  LPARAM lParam); // New window procedure.

	void SetCustomWndProc();
	void ResetCustomWndProc();

protected:
	CXTPFlowGraphPage* m_pPage; /**< Pointer to the page this Node is displayed on. */

	CXTPFlowGraphNode* m_pNextVisibleNode; /**< Pointer to the next visible node. */

	CString m_strCaption; /**< Caption displayed for this node. */

	CString m_strMarkup;

	CXTPMarkupUIElement* m_pMarkup; /**< Markup that is responsible for drawing this Node. */

	CPoint m_ptLocation; /**< Point that contains the coordinates of the Node. */

	CSize m_szUserSize;   /**< Current size of the Node including user resizing. */
	CSize m_szActualSize; /**< Real size of the Node before the user might have resized it. */
	CSize m_szMinSize;
	CSize m_szUserMinSize; /**< Manually set minimum size. */

	BOOL m_bResizable;

	CString m_strTooltip; /**< Tooltip of the item. */
	COLORREF m_clrNode;   /**< Color of the Node. */

	BYTE m_bAlpha; /**< Alpha channel 0-255 */

	int m_nStyle; /**< Reserved for future use. Currently can be used as a "tag" property if needed.
				   */
	DWORD_PTR m_dwTag; /**< The 32-bit value associated with the item. */
	int m_nId;		   /**< ID of the node. */

	HWND m_hWnd;				   /**< Handle of the window inside the Node. */
	WNDPROC m_pOriginalWindowProc; /**< Window procedure pointer. */
	CSize m_szWindow; /**< Size of the window of the attached control (if applicable). For example,
						   if a tree control was attached to the Node, this would be it's window
						 size. */

	static CMap<HWND, HWND, CXTPFlowGraphNode*, CXTPFlowGraphNode*>
		m_WindowToNodeHash; /**< Used in the custom window 'ControlWindowProc'. */

	CXTPFlowGraphSelectionRect* m_pSelectionRect;

	int m_nGroupId; /**< ID of the group this Node belongs to (if any). */

	int m_nImageIndex; /**< Index of an image to display next to the caption text of the Node. */

	BOOL m_bLocked; /**< Specifies whether the Node is locked. TRUE if the node if locked, FALSE
					   otherwise. */

	BOOL m_bVisible; /**< Specifies whether the Node is visible. TRUE if the node if visible, FALSE
						otherwise. */

	CXTPFlowGraphConnectionPoints* m_pConnectionPoints; /**< Collection of connection points that
														   are displayed for this Node. */
	CXTPFlowGraphNodeGroup* m_pGroup; /**< Pointer to the group this Node belongs to (if any). */

	friend class CXTPFlowGraphNodes;
	friend class CXTPFlowGraphNodeGroup;
	friend class CXTPFlowGraphPaintManager;
	friend class CXTPFlowGraphPage;
	friend class CXTPFlowGraphControl;

	/** @cond */
private:
	int m_nArrangeIndex;
	int m_nArrangeLevel;
	int m_nArrangeComponent;
	/** @endcond */

	/** @cond */

	// Paint Manager Properties:

public:
	CRect m_rcWindow;
	/** @endcond */

#	ifdef _XTP_ACTIVEX
	/** @cond */

	DECLARE_DISPATCH_MAP()
	DECLARE_INTERFACE_MAP()

	DECLARE_OLETYPELIB_EX(CXTPFlowGraphNode)

	afx_msg void OleSetCaption(LPCTSTR lpszCaption);
	afx_msg BSTR OleGetCaption();
	afx_msg void OleSetTooltip(LPCTSTR lpszTooltip);
	afx_msg BSTR OleGetTooltip();
	afx_msg void OleSetColor(OLE_COLOR clr);
	afx_msg OLE_COLOR OleGetColor();
	afx_msg void OleSetStyle(int nStyle);
	afx_msg int OleGetStyle();
	afx_msg LPDISPATCH OleGetConnectionPoints();

	afx_msg int OleGetLeft();
	afx_msg void OleSetLeft(int nLeft);
	afx_msg int OleGetTop();
	afx_msg void OleSetTop(int nTop);
	afx_msg int OleGetWidth();
	afx_msg int OleGetHeight();

	afx_msg LPDISPATCH OleGetPage();
	afx_msg BOOL OleGetSelected();
	afx_msg void OleSetSelected(BOOL bSelected);

	afx_msg LPDISPATCH OleGetGroup();
	afx_msg LPDISPATCH OleHitTestConnectionPoint(long x, long y);

	afx_msg void OleAddNamedConnectionPoints(LPCTSTR lpszName, long type);
	afx_msg void OleAddNamedConnectionPointsWithCaption(LPCTSTR lpszName, long type,
														LPCTSTR lpszCaption);

	afx_msg void OleSetWindowHandle(HWND hWnd);
	afx_msg HWND OleGetWindowHandle();

	afx_msg int OleGetWindowWidth();
	afx_msg void OleSetWindowWidth(int nWidth);

	afx_msg int OleGetWindowHeight();
	afx_msg void OleSetWindowHeight(int nHeight);

	afx_msg void OleSetWidth(int nWidth);
	afx_msg void OleSetHeight(int nHeight);

/** @endcond */
#	endif
};

AFX_INLINE CString CXTPFlowGraphNode::GetCaption() const
{
	return m_strCaption;
}
AFX_INLINE CPoint CXTPFlowGraphNode::GetLocation() const
{
	return m_ptLocation;
}
AFX_INLINE CXTPFlowGraphConnectionPoints* CXTPFlowGraphNode::GetConnectionPoints() const
{
	return m_pConnectionPoints;
}
AFX_INLINE void CXTPFlowGraphNode::SetTooltip(LPCTSTR lpszTooltip)
{
	m_strTooltip = lpszTooltip;
}
AFX_INLINE CString CXTPFlowGraphNode::GetTooltip() const
{
	return m_strTooltip;
}
AFX_INLINE COLORREF CXTPFlowGraphNode::GetColor() const
{
	return m_clrNode;
}
AFX_INLINE void CXTPFlowGraphNode::SetStyle(int nStyle)
{
	m_nStyle = nStyle;
	OnGraphChanged();
}
AFX_INLINE int CXTPFlowGraphNode::GetStyle() const
{
	return m_nStyle;
}
AFX_INLINE CXTPFlowGraphPage* CXTPFlowGraphNode::GetPage() const
{
	return m_pPage;
}
AFX_INLINE void CXTPFlowGraphNode::SetTag(DWORD_PTR dwTag)
{
	m_dwTag = dwTag;
}
AFX_INLINE DWORD_PTR CXTPFlowGraphNode::GetTag() const
{
	return m_dwTag;
}
AFX_INLINE void CXTPFlowGraphNode::SetID(int nId)
{
	m_nId = nId;
}
AFX_INLINE int CXTPFlowGraphNode::GetID() const
{
	return m_nId;
}
AFX_INLINE HWND CXTPFlowGraphNode::GetWindowHandle() const
{
	return m_hWnd;
}
AFX_INLINE CSize CXTPFlowGraphNode::GetWindowSize() const
{
	return m_szWindow;
}
AFX_INLINE CXTPFlowGraphNodeGroup* CXTPFlowGraphNode::GetGroup() const
{
	return m_pGroup;
}
AFX_INLINE int CXTPFlowGraphNode::GetImageIndex() const
{
	return m_nImageIndex;
}
AFX_INLINE void CXTPFlowGraphNode::SetLocked(BOOL bLocked)
{
	m_bLocked = bLocked;
}
AFX_INLINE BOOL CXTPFlowGraphNode::IsLocked() const
{
	return m_bLocked;
}
AFX_INLINE BOOL CXTPFlowGraphNode::IsVisible() const
{
	return m_bVisible;
}
AFX_INLINE BOOL CXTPFlowGraphNode::IsResizable() const
{
	return m_bResizable;
}
/** @cond */
#	include "Common/Base/Diagnostic/XTPEnableNoisyWarnings.h"
#endif //#if !defined(__XTPFLOWGRAPHNODE_H__)
/** @endcond */