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

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

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

class CXTPChartDiagram;
class CXTPChartDiagram2D;
class CXTPChartAxisGridLines;
class CXTPChartAxisLabel;
class CXTPChartAxisTitle;
class CXTPChartAxisTickMarks;
class CXTPChartScaleTypeMap;
class CXTPChartAxisRange;
class CXTPChartAxisView;
class CXTPChartDiagramView;
class CXTPChartDeviceContext;
class CXTPChartAxisAppearance;
class CXTPChartFillStyle;
class CXTPChartAxisConstantLines;
class CXTPChartAxisCustomLabels;
class CXTPChartAxisStrips;
class CXTPChartElementView;

/**
 * @brief
 * Enumerates the axis alignment.
 */
enum XTPChartAxisAlignment
{
	xtpChartAxisNear, /**< For Y axis, near means left side of the chart. For X axis it is the
						 bottom side of the chart.*/
	xtpChartAxisFar   /**< For Y axis, far means right side of the chart. For X axis it is the top
						 side   of the chart.*/
};

/**
 * @brief
 * Enumerates the axis alignment.
 */
enum XTPChartAxisDateTimeScaleUnit
{
	xtpChartScaleMinute, /**< A minute scale unit */
	xtpChartScaleHour,   /**< An hour scale unit */
	xtpChartScaleDay,	/**< A day scale unit */
	xtpChartScaleMonth,  /**< A month scale unit */
	xtpChartScaleYear,   /**< A year scale unit */
};

/**
 * @brief
 * This abstract base class represents a chart axis as a kind of chart element.
 * It abstarcts all the features of a chart axis.
 *
 * @details
 * This is an abstract base class, act as the parent for the classes
 * CXTPChartAxisX and CXTPChartAxisY.
 */
class _XTP_EXT_CLASS CXTPChartAxis : public CXTPChartElement
{
	/** @cond */
	DECLARE_DYNAMIC(CXTPChartAxis)
	/** @endcond */
public:
	/**
	 * @brief
	 * Constructs a CXTPChartAxis object.
	 *
	 * @param pDiagram Pointer to a CXTPChartDiagram2D object.
	 */
	CXTPChartAxis(CXTPChartDiagram* pDiagram);

	/**
	 * @brief
	 * Destroys a CXTPChartAxis object, handles cleanup
	 */
	virtual ~CXTPChartAxis();

public:
	/**
	 * @brief
	 * This function creates the view (CXTPChartAxisView)of the axis.
	 *
	 * @param pDC The chart device context object pointer.
	 * @param pParentView The parent view of the axis.
	 *
	 * @return Returns an pointer to CXTPChartAxisView object newly created.
	 */
	virtual CXTPChartAxisView* CreateView(CXTPChartDeviceContext* pDC,
										  CXTPChartElementView* pParentView);

	/**
	 * @brief
	 * This function updates the axis, with respect to the series values.
	 * @param pDC A pointer to the device context
	 * @param pView Pointer to CXTPChartAxisView
	 * @details
	 * Call this function whenever there is a change in series values.
	 */
	void UpdateRange(CXTPChartDeviceContext* pDC, CXTPChartAxisView* pView);

	/**
	 * @brief
	 * Override this method to tell that whether the axis is vertical.
	 *
	 * @return Returns TRUE if the axis is vertical, FALSE if the axis is not vertical.
	 */
	virtual BOOL IsVertical() const = 0;

	/**
	 * @brief
	 * Override this method to tell that whether the axis is value type.
	 *
	 * @return Returns TRUE if the axis is value type, FALSE if the axis is not value type.
	 */
	virtual BOOL IsValuesAxis() const = 0;

	/**
	 * @brief
	 * Call this function to get the pointer to chart diagram 2D object associated
	 * with the chart axis object.
	 *
	 * @return Returns apointer to CXTPChartDiagram2D object.
	 */
	CXTPChartDiagram* GetDiagram() const;

	/**
	 * @brief
	 * Use this function to get the scale type used for the axis.
	 *
	 * @return Returns an enumerated value specifying the scale type used.
	 *
	 * @details
	 * The main scale types are - Qualitative, Numerical, Date time.
	 */
	XTPChartScaleType GetScaleType() const;

	/**
	 * @brief
	 * Call this function to get the scale type map object associated with the axis.
	 *
	 * @return Returns the pointer to a scale type map object.
	 *
	 * @details
	 * CXTPChartScaleTypeMap object keep track of the apparent and internal(actual)
	 * value of a point in the axis.
	 */
	CXTPChartScaleTypeMap* GetScaleTypeMap() const;

	/**
	 * @brief
	 * Override this function to return the side margin value of the chart axis.
	 *
	 * @param nMinValue The minimum value of the chart axis.
	 * @param nMaxValue The maximum value of the chart axis.
	 *
	 * @return Returns a double value, represents the margin.
	 */
	virtual double CalcSideMarginsValue(double nMinValue, double nMaxValue) const = 0;

	/**
	 * @brief
	 * Use this function to get object which represents the range of the axis.
	 *
	 * @return Returns the pointer to the chart axis range object.
	 *
	 * @details
	 * CXTPChartAxisRange object handles the range related things of an axis.
	 */
	CXTPChartAxisRange* GetRange() const;

	/**
	 * @brief
	 * Call this function to get object which represents the label of the axis.
	 *
	 * @return Returns the pointer to the axis label object.
	 *
	 * @details
	 * CXTPChartAxisLabel object handles the chart label and its appearance.
	 */
	CXTPChartAxisLabel* GetLabel() const;

	/**
	 * @brief
	 * Use this function to get object which represents the axis gridlines.
	 *
	 * @return Returns the pointer to the axis gridlines object.
	 *
	 * @details
	 * CXTPChartAxisGridLines object handles the axis gridlines and its appearance.
	 */
	CXTPChartAxisGridLines* GetGridLines() const;

	/**
	 * @brief
	 * Call this function to get the associated object which abstracts the axis
	 * tick marks.
	 *
	 * @return Returns the pointer to the axis tick marks object.
	 *
	 * @details
	 * CXTPChartAxisTickMarks object handles the axis tick marks and its appearance.
	 */
	CXTPChartAxisTickMarks* GetTickMarks() const;

	/**
	 * @brief
	 * Use this function to get the associated object which deals with constant lines
	 * parallel to the axis.
	 *
	 * @return Returns the pointer to the axis constant lines object.
	 */
	CXTPChartAxisConstantLines* GetConstantLines() const;

	/**
	 * @brief
	 * Use this function to get the associated object which deals with custom labels of aixs
	 *
	 * @return Returns the pointer to the axis custom labels object.
	 */
	CXTPChartAxisCustomLabels* GetCustomLabels() const;

	/**
	 * @brief
	 * Call this function to get the associated object which deals with strips
	 * parallel to the axis.
	 *
	 * @return Returns the pointer to the axis strips object.
	 */
	CXTPChartAxisStrips* GetStrips() const;

	/**
	 * @brief
	 * Use this function to get the associated object which deals the axis title
	 *
	 * @return Returns the pointer to the axis title object.
	 */
	CXTPChartAxisTitle* GetTitle() const;

	/**
	 * @brief
	 * Gets the color of the axis.
	 *
	 * @return Returns the pointer to CXTPChartColor object, which give ARGB color value.
	 */
	CXTPChartColor GetActualColor() const;

	/**
	 * @brief
	 * Gets the color of the axis.
	 *
	 * @return Returns the pointer to CXTPChartColor object, which give ARGB color value.
	 */
	CXTPChartColor GetColor() const;

	/**
	 * @brief
	 * Sets the color of the axis.
	 *
	 * @param color Color to be set.
	 */
	void SetColor(const CXTPChartColor& color);

	/**
	 * @brief
	 * Gets the first interlaced strips color of the axis.
	 *
	 * @return Returns the pointer to CXTPChartColor object, which give ARGB color value.
	 */
	CXTPChartColor GetInterlacedColor() const;

	/**
	 * @brief
	 * Gets the first interlaced strips color of the axis.
	 *
	 * @return Returns the pointer to CXTPChartColor object, which give ARGB color value.
	 */
	CXTPChartColor GetActualInterlacedColor() const;

	/**
	 * @brief
	 * Sets the first interlaced strips color of the axis.
	 *
	 * @param color Color to be set.
	 */
	void SetInterlacedColor(const CXTPChartColor& color);

	/**
	 * @brief
	 * Gets the second interlaced strips color of the axis.
	 *
	 * @return Returns the pointer to CXTPChartColor object, which give ARGB color value.
	 */
	CXTPChartColor GetInterlacedColor2() const;

	/**
	 * @brief
	 * Gets the second interlaced strips color of the axis.
	 *
	 * @return Returns the pointer to CXTPChartColor object, which give ARGB color value.
	 */
	CXTPChartColor GetActualInterlacedColor2() const;

	/**
	 * @brief
	 * Sets the second interlaced strips color of the axis.
	 *
	 * @param color Color to be set.
	 */
	void SetInterlacedColor2(const CXTPChartColor& color);

	/**
	 * @brief
	 * Call this function to get the second interlaced strips background
	 * fill style.
	 *
	 * @return Returns the pointer to CXTPChartFillStyle object, which abstracts
	 *		  various fill styles.
	 */
	CXTPChartFillStyle* GetInterlacedFillStyle() const;

	/**
	 * @brief
	 * Call this function to get the alignment of the axis.
	 *
	 * @return Returns an enumerated value XTPChartAxisAlignment,corresponding
	 *		  to the alignment selected.
	 *
	 * @details
	 *  Usage
	 *  xtpChartAxisNear - for Y axis, near means left side of the chart
	 *                    for X axis it is the bottom side of the chart.
	 *  xtpChartAxisFar -  for Y axis, near means right side of the chart
	 *                    for X axis it is the top side of the chart.
	 */
	XTPChartAxisAlignment GetAlignment() const;

	/**
	 * @brief
	 * Use this function to set the alignment of the axis.
	 *
	 * @param nAlignment enumerated value XTPChartAxisAlignment,corresponding
	 *				    to the alignment to be selected.
	 *
	 * @details
	 *  Usage
	 *  xtpChartAxisNear - for Y axis, near means left side of the chart
	 *                    for X axis it is the bottom side of the chart.
	 *  xtpChartAxisFar -  for Y axis, near means right side of the chart
	 *                    for X axis it is the top side of the chart.
	 */
	void SetAlignment(XTPChartAxisAlignment nAlignment);

	/**
	 * @brief
	 * Call this function to get whether the interlaced strips are used.
	 *
	 * @return Returns TRUE if the interlaced strips are enabled, FALSE if it is
	 *		  not enabled.
	 *
	 * @details
	 */
	BOOL IsInterlaced() const;

	/**
	 * @brief
	 * Call this function to enable/disable the interlaced strips.
	 *
	 * @param bInterlaced TRUE if the interlaced strips are to be enabled, FALSE
	 *					 to remove the interlaced strips.
	 */
	void SetInterlaced(BOOL bInterlaced);

	/**
	 * @brief
	 * Use this function to get whether the axis is visible.
	 *
	 * @return Returns TRUE if the axis is visible, FALSE if the axis is
	 *		  not visible.
	 */
	BOOL IsVisible() const;

	/**
	 * @brief
	 * Call this function to show/hide the axis.
	 *
	 * @param bVisible TRUE to make the axis visible, FALSE to hide the axis.
	 */
	void SetVisible(BOOL bVisible);

	/**
	 * @brief
	 * Call this function to get the thickness of the axis line.
	 *
	 * @return Returns an int value denoting the thickness of the axis line.
	 */
	int GetThickness() const;

	/**
	 * @brief
	 * Call this function to set the thickness of the axis line.
	 *
	 * @param nThicknes The thickness of the axis line.
	 */
	void SetThickness(int nThicknes);

	/**
	 * @brief
	 * Call this function to get index of the axis.
	 *
	 * @return Returns an int value denoting the index of the axis.
	 */
	int GetIndex() const;

	/**
	 * @brief
	 * Call this function to set the axis index.
	 *
	 * @param nIndex The index of axis.
	 */
	void SetIndex(int nIndex);

	/**
	 * @brief
	 * Call this function to set the minor count of the axis  grid lines.
	 *
	 * @param nMinorCount The number of minor grid lines.
	 */
	void SetMinorCount(int nMinorCount);

	/**
	 * @brief
	 * This function gives the minor count of the axis  grid lines.
	 *
	 * @return The number of minor grid lines.
	 */
	int GetMinorCount() const;

	/**
	 * @brief
	 * Use this function to reverse order the axis values.
	 *
	 * @param bRevered TRUE for normal order, FALSE for reverse order.
	 */
	void SetReversed(BOOL bRevered);

	/**
	 * @brief
	 * This function gives whether the axis points are reverse ordered or not.
	 *
	 * @return TRUE for normal order, FALSE for reverse order.
	 */
	BOOL IsReversed() const;

	/**
	 * @brief
	 * This function returns the chart axis appeance object.
	 *
	 * @return The pointer to chart axis appeance object.
	 */
	CXTPChartAxisAppearance* GetAppearance() const;

	/**
	 * @brief
	 * Sets value specifies whether space between grid lines in calculated automatically
	 *
	 * @param bGridSpacingAuto TRUE to calculate space between grid lines automatically
	 *
	 * @details
	 * Call SetGridSpacing to set this space in case of bGridSpacingAuto = FALSE
	 */
	void SetGridSpacingAuto(BOOL bGridSpacingAuto);

	BOOL GetGridSpacingAuto() const;

	/**
	 * @brief
	 * Use this function to set the space between grid lines.
	 *
	 * @param dGridSpacing Space between grid lines.
	 *
	 * @details
	 * Call SetGridSpacingAuto(FALSE) before.
	 */
	void SetGridSpacing(double dGridSpacing);

	/**
	 * @brief
	 * Use this function to get the space between grid lines.
	 *
	 * @return The space between grid lines.
	 */
	double GetGridSpacing() const;

	BOOL IsSecondary() const;

	BOOL IsAllowZoom() const;
	void SetAllowZoom(BOOL bAllowZoom);

	/**
	 * @brief
	 * Set whether logarithmic scale should be used
	 *
	 * @param bLogarithmic TRUE to use logarithmic scale
	 *
	 * @see SetLogarithmicBase
	 */
	void SetLogarithmic(BOOL bLogarithmic);

	BOOL IsLogarithmic() const;

	/**
	 * @brief
	 * Set logarithmic base when logarithmic scale is used
	 *
	 * @param dLogarithmicBase logarithmic base
	 *
	 * @see SetLogarithmic
	 */
	void SetLogarithmicBase(double dLogarithmicBase);

	double GetLogarithmicBase() const;

	/**
	 * @brief
	 * Call this method to set single unit for date time scale
	 *
	 * @param unit new units to be set
	 *
	 * @see SetLogarithmic
	 */
	void SetDateTimeScaleUnit(XTPChartAxisDateTimeScaleUnit unit);

	XTPChartAxisDateTimeScaleUnit GetDateTimeScaleUnit() const;

	CXTPChartAxisView* GetAxisView() const;

public:
	void DoPropExchange(CXTPPropExchange* pPX);

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

	afx_msg LPDISPATCH OleGetConstantLines();
	afx_msg LPDISPATCH OleGetCustomLabels();
	afx_msg LPDISPATCH OleGetStrips();
	afx_msg LPDISPATCH OleGetLabel();
	afx_msg LPDISPATCH OleGetTickMarks();
	afx_msg LPDISPATCH OleGetTitle();
	afx_msg LPDISPATCH OleGetGridLines();
	afx_msg LPDISPATCH OleGetRange();
	afx_msg LPDISPATCH OleGetInterlacedFillStyle();

	afx_msg OLE_COLOR OleGetColor();
	afx_msg void OleSetColor(OLE_COLOR clr);
	afx_msg OLE_COLOR OleGetInterlacedColor();
	afx_msg void OleSetInterlacedColor(OLE_COLOR clr);
	afx_msg OLE_COLOR OleGetInterlacedColor2();
	afx_msg void OleSetInterlacedColor2(OLE_COLOR clr);

/** @endcond */
#	endif

protected:
	CXTPChartDiagram* m_pDiagram; /**< The pointer to chart digram 2d object.*/
	BOOL m_bVisible;			  /**< TRUE if the axis is visible, FALSE if invisible.*/
	BOOL m_bReversed;  /**< FALSE if the axis valus are in natural order, TRUE if it is in reverse
							order.*/
	int m_nThickness;  /**< The thickness of axis line.*/
	int m_nMinorCount; /**< The number of minors present.*/
	BOOL m_bSecondary;
	int m_nIndex;
	XTPChartAxisAlignment m_nAlignment;			/**< The chart axis alignment, near or far.*/
	CXTPChartColor m_clrColor;					/**< The chart color.					   */
	CXTPChartColor m_clrInterlacedColor;		/**< The first interlaced color.		   */
	CXTPChartColor m_clrInterlacedColor2;		/**< The second interlaced color.		   */
	CXTPChartFillStyle* m_pInterlacedFillStyle; /**< The fill style of interlaced strips.  */

	BOOL m_bInterlaced; /**< TRUE if the chart has interlaced strips parallel to the axis.*/

	double m_dGridSpacing;   /**< The spacing of the grid lines.*/
	BOOL m_bGridSpacingAuto; /**< TURE if automatic spaceing of grid lines selected.FALSE for
								specific values.*/
	BOOL m_bAllowZoom;

	BOOL m_bLogarithmic;	   /**< Logarithmic	   */
	double m_dLogarithmicBase; /**< Logarithic base*/

	CXTPChartAxisGridLines* m_pGridLines;		  /**< Pointer to axis gridlines object.	 */
	CXTPChartAxisLabel* m_pLabel;				  /**< Pointer to axis lable object.		 */
	CXTPChartAxisTitle* m_pTitle;				  /**< Pointer to axis title object.		 */
	CXTPChartAxisTickMarks* m_pTickMarks;		  /**< Pointer to axis tick marks object.	 */
	CXTPChartScaleTypeMap* m_pScaleTypeMap;		  /**< Pointer to axis scale type object.	 */
	CXTPChartAxisRange* m_pRange;				  /**< Pointer to axis range object.		 */
	CXTPChartAxisConstantLines* m_pConstantLines; /**< Pointer to axis constant lines object.*/
	CXTPChartAxisCustomLabels* m_pCustomLabels;   /**< Pointer to axis custom labels object. */
	CXTPChartAxisStrips* m_pStrips;				  /**< Pointer to axis strips object.		 */

	XTPChartScaleType m_nScaleType; /**< Enumeated value denote the axis scale type.*/

	XTPChartAxisDateTimeScaleUnit m_nDateTimeScaleUnit;

	CXTPChartAxisView* m_pAxisView;

	friend class CXTPChartDiagram2DAxisView;
	friend class CXTPChartRadarAxisView;
	friend class CXTPChartRadarAxisXView;
	friend class CXTPChartRadarAxisYView;
	friend class CXTPChartDiagram2D;
};

/**
 * @brief
 * CXTPChartAxisX is a derived class from the CXTPChartAxis class
 * and represents the X axis of a chart.
 *
 * @details
 * It includes the features specific to the X axis of a chart.
 */
class _XTP_EXT_CLASS CXTPChartAxisX : public CXTPChartAxis
{
public:
	/**
	 * @brief
	 * Constructs a CXTPChartAxisX object.
	 *
	 * @param pDiagram Pointer to a CXTPChartDiagram2D object.
	 */
	CXTPChartAxisX(CXTPChartDiagram2D* pDiagram);

public:
	/**
	 * @brief
	 * This method overrides the base class member and determines if
	 * the X axis is vertical.
	 *
	 * @return Returns TRUE if the X axis is vertical, FALSE if the X axis is not vertical.
	 */
	virtual BOOL IsVertical() const;

	/**
	 * @brief
	 * This method overrides the base class member and determines if
	 * the X axis is value type.
	 *
	 * @return Returns TRUE if the X axis is value type, FALSE if the X axis is not value type.
	 */
	virtual BOOL IsValuesAxis() const;

	/**
	 * @brief
	 * This method overrides the base class member and returns the
	 * side margin value of the chart's X axis.
	 *
	 * @param nMinValue The minimum value of the chart's X axis.
	 * @param nMaxValue The maximum value of the chart's X axis.
	 *
	 * @return Returns a double value that represents the margin.
	 */
	virtual double CalcSideMarginsValue(double nMinValue, double nMaxValue) const;

protected:
	/**
	 * @brief
	 * This function creates the view (CXTPChartAxisView) of the axis.
	 *
	 * @param pDC The chart device context object pointer.
	 * @param pParentView The parent view of the axis.
	 *
	 * @return Returns a pointer to the newly created CXTPChartAxisView object.
	 */
	virtual CXTPChartAxisView* CreateView(CXTPChartDeviceContext* pDC,
										  CXTPChartElementView* pParentView);
};

/**
 * @brief
 * CXTPChartAxisY is a derived class from the CXTPChartAxis class
 * and represents the Y axis of a chart.
 *
 * @details
 * It includes the features specific to the Y axis of a chart.
 */
class _XTP_EXT_CLASS CXTPChartAxisY : public CXTPChartAxis
{
public:
	/**
	 * @brief
	 * Constructs a CXTPChartAxisY object.
	 *
	 * @param pDiagram Pointer to a CXTPChartDiagram2D object.
	 */
	CXTPChartAxisY(CXTPChartDiagram2D* pDiagram);

public:
	/**
	 * @brief
	 * This method overrides the base class member and determines if
	 * the Y axis is vertical.
	 *
	 * @return Returns TRUE if the Y axis is vertical, FALSE if the Y axis is not vertical.
	 */
	virtual BOOL IsVertical() const;

	/**
	 * @brief
	 * This method overrides the base class member and determines if
	 * the Y axis is value type.
	 *
	 * @return Returns TRUE if the Y axis is value type, FALSE if the Y axis is not value type.
	 */
	virtual BOOL IsValuesAxis() const;

	/**
	 * @brief
	 * This method overrides the base class member and returns the
	 * side margin value of the chart's Y axis.
	 *
	 * @param nMinValue The minimum value of the chart's Y axis.
	 * @param nMaxValue The maximum value of the chart's Y axis.
	 *
	 * @return Returns a double value that represents the margin.
	 */
	virtual double CalcSideMarginsValue(double nMinValue, double nMaxValue) const;

protected:
	/**
	 * @brief
	 * This function creates the view (CXTPChartAxisView) of the axis.
	 *
	 * @param pDC The chart device context object pointer.
	 * @param pParentView The parent view of the axis.
	 *
	 * @return Returns a pointer to the newly created CXTPChartAxisView object.
	 */
	virtual CXTPChartAxisView* CreateView(CXTPChartDeviceContext* pDC,
										  CXTPChartElementView* pParentView);
};

AFX_INLINE CXTPChartDiagram* CXTPChartAxis::GetDiagram() const
{
	return m_pDiagram;
}
AFX_INLINE XTPChartScaleType CXTPChartAxis::GetScaleType() const
{
	return m_nScaleType;
}
AFX_INLINE CXTPChartAxisRange* CXTPChartAxis::GetRange() const
{
	return m_pRange;
}
AFX_INLINE CXTPChartAxisLabel* CXTPChartAxis::GetLabel() const
{
	return m_pLabel;
}

AFX_INLINE CXTPChartAxisGridLines* CXTPChartAxis::GetGridLines() const
{
	return m_pGridLines;
}
AFX_INLINE CXTPChartAxisConstantLines* CXTPChartAxis::GetConstantLines() const
{
	return m_pConstantLines;
}
AFX_INLINE CXTPChartAxisCustomLabels* CXTPChartAxis::GetCustomLabels() const
{
	return m_pCustomLabels;
}
AFX_INLINE CXTPChartAxisStrips* CXTPChartAxis::GetStrips() const
{
	return m_pStrips;
}
AFX_INLINE CXTPChartAxisTickMarks* CXTPChartAxis::GetTickMarks() const
{
	return m_pTickMarks;
}
AFX_INLINE BOOL CXTPChartAxis::IsInterlaced() const
{
	return m_bInterlaced;
}
AFX_INLINE void CXTPChartAxis::SetInterlaced(BOOL bInterlaced)
{
	m_bInterlaced = bInterlaced;
	OnChartChanged();
}
AFX_INLINE CXTPChartScaleTypeMap* CXTPChartAxis::GetScaleTypeMap() const
{
	return m_pScaleTypeMap;
}
AFX_INLINE CXTPChartAxisTitle* CXTPChartAxis::GetTitle() const
{
	return m_pTitle;
}
AFX_INLINE XTPChartAxisAlignment CXTPChartAxis::GetAlignment() const
{
	return m_nAlignment;
}
AFX_INLINE void CXTPChartAxis::SetAlignment(XTPChartAxisAlignment nAlignment)
{
	m_nAlignment = nAlignment;
	OnChartChanged();
}
AFX_INLINE BOOL CXTPChartAxis::IsVisible() const
{
	return m_bVisible;
}
AFX_INLINE void CXTPChartAxis::SetVisible(BOOL bVisible)
{
	m_bVisible = bVisible;
	OnChartChanged();
}
AFX_INLINE int CXTPChartAxis::GetThickness() const
{
	return m_nThickness;
}
AFX_INLINE void CXTPChartAxis::SetThickness(int nThickness)
{
	m_nThickness = nThickness;
	OnChartChanged();
}
AFX_INLINE int CXTPChartAxis::GetMinorCount() const
{
	return m_nMinorCount;
}
AFX_INLINE void CXTPChartAxis::SetMinorCount(int nMinorCount)
{
	m_nMinorCount = nMinorCount;
	OnChartChanged();
}

AFX_INLINE void CXTPChartAxis::SetReversed(BOOL bRevered)
{
	m_bReversed = bRevered;
	OnChartChanged();
}
AFX_INLINE BOOL CXTPChartAxis::IsReversed() const
{
	return m_bReversed;
}
AFX_INLINE BOOL CXTPChartAxis::GetGridSpacingAuto() const
{
	return m_bGridSpacingAuto;
}
AFX_INLINE void CXTPChartAxis::SetGridSpacingAuto(BOOL bGridSpacingAuto)
{
	m_bGridSpacingAuto = bGridSpacingAuto;
	OnChartChanged();
}
AFX_INLINE double CXTPChartAxis::GetGridSpacing() const
{
	return m_dGridSpacing;
}
AFX_INLINE void CXTPChartAxis::SetGridSpacing(double dGridSpacing)
{
	m_dGridSpacing = dGridSpacing;
	OnChartChanged();
}
AFX_INLINE BOOL CXTPChartAxis::IsSecondary() const
{
	return m_bSecondary;
}
AFX_INLINE void CXTPChartAxis::SetColor(const CXTPChartColor& color)
{
	m_clrColor = color;
	OnChartChanged();
}
AFX_INLINE void CXTPChartAxis::SetInterlacedColor(const CXTPChartColor& color)
{
	m_clrInterlacedColor = color;
	OnChartChanged();
}
AFX_INLINE void CXTPChartAxis::SetInterlacedColor2(const CXTPChartColor& color)
{
	m_clrInterlacedColor2 = color;
	OnChartChanged();
}
AFX_INLINE BOOL CXTPChartAxis::IsAllowZoom() const
{
	return m_bAllowZoom;
}
AFX_INLINE void CXTPChartAxis::SetAllowZoom(BOOL bAllowZoom)
{
	m_bAllowZoom = bAllowZoom;
}
AFX_INLINE void CXTPChartAxis::SetLogarithmic(BOOL bLogarithmic)
{
	m_bLogarithmic = bLogarithmic;
	OnChartChanged();
}
AFX_INLINE BOOL CXTPChartAxis::IsLogarithmic() const
{
	return m_bLogarithmic;
}
AFX_INLINE void CXTPChartAxis::SetLogarithmicBase(double dLogarithmicBase)
{
	m_dLogarithmicBase = dLogarithmicBase;
	OnChartChanged();
}
AFX_INLINE double CXTPChartAxis::GetLogarithmicBase() const
{
	return m_dLogarithmicBase;
}
AFX_INLINE void CXTPChartAxis::SetDateTimeScaleUnit(XTPChartAxisDateTimeScaleUnit unit)
{
	m_nDateTimeScaleUnit = unit;
	OnChartChanged();
}
AFX_INLINE XTPChartAxisDateTimeScaleUnit CXTPChartAxis::GetDateTimeScaleUnit() const
{
	return m_nDateTimeScaleUnit;
}
AFX_INLINE int CXTPChartAxis::GetIndex() const
{
	return m_nIndex;
}
AFX_INLINE void CXTPChartAxis::SetIndex(int nIndex)
{
	m_nIndex = nIndex;
	OnChartChanged();
}

AFX_INLINE CXTPChartAxisView* CXTPChartAxis::GetAxisView() const
{
	return m_pAxisView;
}
/** @cond */
#	include "Common/Base/Diagnostic/XTPEnableNoisyWarnings.h"
#endif //#if !defined(__XTPCHARTAXIS_H__)
/** @endcond */