/*
*
* ChartAxis.cpp
*
* Written by C�dric Moonen (cedric_moonen@hotmail.com)
*
*
*
* This code may be used for any non-commercial and commercial purposes in a compiled form.
* The code may be redistributed as long as it remains unmodified and providing that the
* author name and this disclaimer remain intact. The sources can be modified WITH the author
* consent only.
*
* This code is provided without any garanties. I cannot be held responsible for the damage or
* the loss of time it causes. Use it at your own risks
*
* An e-mail to notify me that you are using this code is appreciated also.
*
*
* History:
* - 16/05/2006: Bug fix in ScreenToValue function
* - 18/05/2006: Added support for panning
* - 11/08/2006: Changes done for the automatic axis (Un/RegisterSeries, ...)
* - 12/08/2006: Tick increment can be set manually also
*
*/
#include "stdafx.h"
#include "ChartAxis.h"
#include "ChartAxisLabel.h"
#include "ChartGrid.h"
#include "ChartCtrl.h"
#include "Math.h"
#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
CChartAxis::CChartAxis(CChartCtrl* pParent,bool bHoriz):CChartObject(pParent)
{
m_bIsHorizontal = bHoriz;
m_bIsInverted = false;
m_bIsAutomatic = false;
m_bIsLogarithmic = false;
m_bIsSecondary = false;
m_MaxValue = m_UnzoomMax = 10;
m_MinValue = m_UnzoomMin = 0;
m_bAutoTicks = true;
m_TickIncrement = 1;
m_FirstTickVal = 0;
m_DecCount = 0;
m_StartPos = m_EndPos = 0;
m_nFontSize = 80;
m_strFontName = "Microsoft Sans Serif";
m_pAxisGrid = new CChartGrid(pParent,this,bHoriz);
m_pAxisLabel = new CChartAxisLabel(pParent,bHoriz);
}
CChartAxis::~CChartAxis()
{
if (m_pAxisGrid)
{
delete m_pAxisGrid;
m_pAxisGrid = NULL;
}
if (m_pAxisLabel)
{
delete m_pAxisLabel;
m_pAxisLabel = NULL;
}
}
int CChartAxis::ClipMargin(CRect ControlRect,CRect& MarginRect,CDC* pDC) const
{
if (!m_bIsVisible)
return 0;
int Size = 0;
CSize LabelSize = m_pAxisLabel->GetSize(pDC);
CFont* pOldFont;
CFont NewFont;
NewFont.CreatePointFont(m_nFontSize,m_strFontName.c_str(),pDC);
pOldFont = pDC->SelectObject(&NewFont);
CString Buffer;
Buffer.Format(_T("%.*f"),m_DecCount,m_MaxValue);
if (m_bIsHorizontal)
{
Size += 4 + 1; //Space above and under the text
CSize TextSize = pDC->GetTextExtent(Buffer);
Size += TextSize.cy;
Size +=LabelSize.cy;
if (!m_bIsSecondary)
{
ControlRect.bottom -= Size;
ControlRect.right -= TextSize.cx/2+3;
if (ControlRect.bottom < MarginRect.bottom)
MarginRect.bottom = ControlRect.bottom;
if (ControlRect.right < MarginRect.right)
MarginRect.right = ControlRect.right;
}
else
{
ControlRect.top += Size;
ControlRect.right -= TextSize.cx/2+3;
if (ControlRect.top > MarginRect.top)
MarginRect.top = ControlRect.top;
if (ControlRect.right < MarginRect.right)
MarginRect.right = ControlRect.right;
}
}
else
{
Size += 7 + 1; //Space before and after the text + Tick
char szBuffer[255];
if (!m_bIsLogarithmic)
{
int MaxChars = abs( (int)log10(fabs(m_MaxValue) )) + 1;
int MinChars = abs( (int)log10(fabs(m_MinValue) )) + 1;
if (m_MinValue<0)
MinChars++;
if (m_MaxValue<0)
MaxChars++;
if (MaxChars>MinChars)
sprintf(szBuffer,"%.*f",m_DecCount,m_MaxValue);
else
sprintf(szBuffer,"%.*f",m_DecCount,m_MinValue);
}
else
{
char BuffMax[255];
char BuffMin[255];
int MaxDecCount = (int)log10(m_MaxValue);
if (MaxDecCount < 0)
MaxDecCount = -MaxDecCount;
else
MaxDecCount = 0;
sprintf(BuffMax,"%.*f",MaxDecCount,m_MaxValue);
int MinDecCount = (int)log10(m_MinValue);
if (MinDecCount < 0)
MinDecCount = -MinDecCount;
else
MinDecCount = 0;
sprintf(BuffMin,"%.*f",MinDecCount,m_MinValue);
if (strlen(BuffMin) > strlen(BuffMax) )
strcpy(szBuffer,BuffMin);
else
strcpy(szBuffer,BuffMax);
}
CSize TextSize = pDC->GetTextExtent(szBuffer);
Size += TextSize.cx;
Size += LabelSize.cx + 2;
if (!m_bIsSecondary)
{
ControlRect.left += Size;
ControlRect.top += TextSize.cy/2+3;
if (ControlRect.top > MarginRect.top)
MarginRect.top = ControlRect.top;
if (ControlRect.left > MarginRect.left)
MarginRect.left = ControlRect.left;
}
else
{
ControlRect.right -= Size;
ControlRect.top += TextSize.cy/2+3;
if (ControlRect.top > MarginRect.top)
MarginRect.top = ControlRect.top;
if (ControlRect.right < MarginRect.right)
MarginRect.right = ControlRect.right;
}
}
pDC->SelectObject(pOldFont);
return Size;
}
void CChartAxis::SetAutomatic(bool bNewValue)
{
m_bIsAutomatic = bNewValue;
if (m_bIsAutomatic)
m_MinValue = m_MaxValue = 0;
RefreshAutoAxis();
}
void CChartAxis::SetTickIncrement(bool bAuto, double Increment)
{
m_bAutoTicks = bAuto;
if (!m_bAutoTicks)
m_TickIncrement = Increment;
else
CalculateTicksIncrement();
CalculateFirstTick();
m_pParent->RefreshCtrl();
}
void CChartAxis::SetAxisSize(CRect ControlRect,CRect MarginRect)
{
if (m_bIsHorizontal)
{
m_StartPos = MarginRect.left;
m_EndPos = MarginRect.right;
if (!m_bIsSecondary)
{
CRect AxisSize = ControlRect;
AxisSize.top = MarginRect.bottom;
SetRect(AxisSize);
}
else
{
CRect AxisSize = ControlRect;
AxisSize.bottom = MarginRect.top;
SetRect(AxisSize);
}
}
else
{
m_StartPos = MarginRect.bottom;
m_EndPos = MarginRect.top;
if (!m_bIsSecondary)
{
CRect AxisSize = ControlRect;
AxisSize.right = MarginRect.left;
SetRect(AxisSize);
}
else
{
CRect AxisSize = ControlRect;
AxisSize.left = MarginRect.right;
SetRect(AxisSize);
}
}
}
void CChartAxis::Draw(CDC *pDC)
{
if (!m_bIsVisible)
return;
CPen SolidPen(PS_SOLID,0,m_ObjectColor);
CPen* pOldPen;
CFont NewFont;
CFont* pOldFont;
if (pDC->GetSafeHdc() == NULL)
return;
CSize LabelSize = m_pAxisLabel->GetSize(pDC);
int HalfAxisPos = (int)fabs((m_EndPos + m_StartPos)/2.0);
int XPos = 0;
int YPos = 0;
if (m_bIsHorizontal)
{
if (!m_bIsSecondary)
{
YPos = m_ObjectRect.top + LabelSize.cy + 2;
XPos = HalfAxisPos - LabelSize.cx/2;
}
else
{
YPos = m_ObjectRect.top + 2;
XPos = HalfAxisPos - LabelSize.cx/2;
}
}
else
{
if (!m_bIsSecondary)
{
YPos = HalfAxisPos + LabelSize.cy/2;
XPos = m_ObjectRect.left + 0;
}
else
{
YPos = HalfAxisPos + LabelSize.cy/2;
XPos = m_ObjectRect.right - LabelSize.cx - 2;
}
}
m_pAxisLabel->SetPosition(XPos,YPos,pDC);
m_pAxisLabel->Draw(pDC);
NewFont.CreatePointFont(m_nFontSize,m_strFontName.c_str(),pDC) ;
pOldPen = pDC->SelectObject(&SolidPen);
pOldFont = pDC->SelectObject(&NewFont);
CalculateTicksIncrement();
char szBuffer[255];
int TickCount = 0;
int FirstTickPos = ValueToScreen(m_FirstTickVal);
double TickValue = m_FirstTickVal;
if (m_bIsHorizontal)
{
if (!m_bIsSecondary)
{
pDC->MoveTo(m_StartPos,m_ObjectRect.top+1);
pDC->LineTo(m_EndPos,m_ObjectRect.top+1);
}
else
{
pDC->MoveTo(m_StartPos,m_ObjectRect.bottom-1);
pDC->LineTo(m_EndPos,m_ObjectRect.bottom-1);
}
if (m_MinValue == m_MaxValue)
{
int HorizPos = m_StartPos + (int)fabs((m_EndPos-m_StartPos)/2.0);
if (!m_bIsSecondary)
{
pDC->MoveTo(HorizPos,m_ObjectRect.top+1);
pDC->LineTo(HorizPos,m_ObjectRect.top+4);
}
else
{
pDC->MoveTo(HorizPos,m_ObjectRect.bottom-1);
pDC->LineTo(HorizPos,m_ObjectRect.bottom-4);
}
if (!m_bIsLogarithmic)
sprintf(szBuffer,"%.*f",m_DecCount,m_MinValue);
else
{
int LogDecCount = (int)log10(m_MinValue);
sprintf(szBuffer,"%.*f",LogDecCount,m_MinValue);
}
CSize TextSize;
TextSize = pDC->GetTextExtent(szBuffer);
if (!m_bIsSecondary)
pDC->ExtTextOut(HorizPos-TextSize.cx/2,m_ObjectRect.top+5,ETO_CLIPPED|ETO_OPAQUE,NULL,szBuffer,NULL);
else
pDC->ExtTextOut(HorizPos-TextSize.cx/2,m_ObjectRect.bottom-5,ETO_CLIPPED|ETO_OPAQUE,NULL,szBuffer,NULL);
}
else while ( (TickValue<=m_MaxValue) || (TickValue-m_MaxValue < 0.0000001) )
{
int HorizPos = ValueToScreen(TickValue);
if (m_bIsInverted)
FirstTickPos = HorizPos;
if (!m_bIsSecondary)
{
pDC->MoveTo(HorizPos,m_ObjectRect.top+1);
pDC->LineTo(HorizPos,m_ObjectRect.top+4);
}
else
{
pDC->MoveTo(HorizPos,m_ObjectRect.bottom-1);
pDC->LineTo(HorizPos,m_ObjectRect.bottom-4);
}
if (!m_bIsLogarithmic)
sprintf(szBuffer,"%.*f",m_DecCount,TickValue);
else
{
int LogDecCount = (int)log10(TickValue);
if (LogDecCount<0)
LogDecCount = -(LogDecCount)-1;
else
LogDecCount = 0;
sprintf(szBuffer,"%.*f",LogDecCount,TickValue);
}
CSize TextSize = pDC->GetTextExtent(szBuffer);
if (!m_bIsSecondary)
pDC->ExtTextOut(HorizPos-TextSize.cx/2,m_ObjectRect.top+5,ETO_CLIPPED|ETO_OPAQUE,NULL,szBuffer,NULL);
else
pDC->ExtTextOut(HorizPos-TextSize.cx/2,m_ObjectRect.bottom-5-TextSize.cy,ETO_CLIPPED|ETO_OPAQUE,NULL,szBuffer,NULL);
if (!m_bIsLogarithmic)
TickValue += m_TickIncrement;
else
TickValue *= m_TickIncrement;
TickCount++;
}
}
else
{
if (!m_bIsSecondary)
{
pDC->MoveTo(m_ObjectRect.right-1,m_StartPos);
pDC->LineTo(m_ObjectRect.right-1,m_EndPos);
}
else
{
pDC->MoveTo(m_ObjectRect.left+1,m_StartPos);
pDC->LineTo(m_ObjectRect.left+1,m_EndPos);
}
if (m_MinValue == m_MaxValue)
{
int VertPos = m_EndPos + (int)fabs((m_EndPos-m_StartPos)/2.0);
if (!m_bIsSecondary)
{
pDC->MoveTo(m_ObjectRect.right-1,VertPos);
pDC->LineTo(m_ObjectRect.right-4,VertPos);
}
else
{
pDC->MoveTo(m_ObjectRect.left+1,VertPos);
pDC->LineTo(m_ObjectRect.left+4,VertPos);
}
if (!m_bIsLogarithmic)
sprintf(szBuffer,"%.*f",m_DecCount,TickValue);
else
{
int LogDecCount = (int)(log10(TickValue));
sprintf(szBuffer,"%.*f",LogDecCount,TickValue);
}
CSize TextSize = pDC->GetTextExtent(szBuffer);
if (!m_bIsSecondary)
pDC->ExtTextOut(LabelSize.cx+m_ObjectRect.left+2,VertPos-TextSize.cy/2,ETO_CLIPPED|ETO_OPAQUE,NULL,szBuffer,NULL);
else
pDC->ExtTextOut(m_ObjectRect.left+6,VertPos-TextSize.cy/2,ETO_CLIPPED|ETO_OPAQUE,NULL,szBuffer,NULL);
}
else while ( (TickValue<=m_MaxValue) || (TickValue-m_MaxValue < 0.0000001) )
{
int VertPos = ValueToScreen(TickValue);
if (!m_bIsInverted)
FirstTickPos = VertPos;
if (!m_bIsSecondary)
{
pDC->MoveTo(m_ObjectRect.right-1,VertPos);
pDC->LineTo(m_ObjectRect.right-4,VertPos);
}
else
{
pDC->MoveTo(m_ObjectRect.left+1,VertPos);
pDC->LineTo(m_ObjectRect.left+4,VertPos);
}
if (!m_bIsLogarithmic)
sprintf(szBuffer,"%.*f",m_DecCount,TickValue);
else
{
int LogDecCount = (int)(log10(TickValue));
if (LogDecCount<0)
LogDecCount = (int)fabs(LogDecCount*1.0)+1;
else
LogDecCount = 0;
sprintf(szBuffer,"%.*f",LogDecCount,TickValue);
}
CSize TextSize = pDC->GetTextExtent(szBuffer);
if(!m_bIsSecondary)
pDC->ExtTextOut(m_ObjectRect.left+LabelSize.cx+4,VertPos-TextSize.cy/2,ETO_CLIPPED|ETO_OPAQUE,NULL,szBuffer,NULL);
else
pDC->ExtTextOut(m_ObjectRect.left+6,VertPos-TextSize.cy/2,ETO_CLIPPED|ETO_OPAQUE,NULL,szBuffer,NULL);
if (!m_bIsLogarithmic)
TickValue += m_TickIncrement;
else
TickValue *= m_TickIncrement;
TickCount++;
}
}
CRect Size = m_pParent->GetPlottingRect();
m_pAxisGrid->SetRect(Size);
double TickSpace = 0;
if (m_bIsLogarithmic)
{
m_TickIncrement = 10;
TickSpace = log10(m_TickIncrement) * GetAxisLenght()/(log10(m_MaxValue)-log10(m_MinValue));
}
else
TickSpace = m_TickIncrement * GetAxisLenght()/(m_MaxValue-m_MinValue);
m_pAxisGrid->SetTicksCount(TickCount);
m_pAxisGrid->Draw(pDC);
pDC->SelectObject(pOldPen);
pDC->SelectObject(pOldFont);
}
void CChartAxis::SetMinMax(double Minimum, double Maximum)
{
if (Minimum > Maximum)
{
TRACE("Maximum axis value must be > minimum axis value");
return;
}
m_MinValue = m_UnzoomMin = Minimum;
m_MaxValue = m_UnzoomMax = Maximum;
}
void CChartAxis::SetInverted(bool bNewValue)
{
m_bIsInverted = bNewValue;
}
int CChartAxis::GetAxisLenght() const
{
int Length = (int)fabs( (m_EndPos-m_StartPos) * 1.0);
return Length;
}
void CChartAxis::CalculateTicksIncrement()
{
if (!m_bAutoTicks)
{
CalculateFirstTick();
return;
}
//Calculate the appropriate TickSpace (1 tick every 30 pixel +/-)
if (m_bIsLogarithmic)
m_TickIncrement = 10;
else
{
int PixelSpace;
if (m_bIsHorizontal)
PixelSpace = 25;
else
PixelSpace = 20;
int MaxTickNumber = (int)fabs((m_EndPos-m_StartPos)/PixelSpace * 1.0);
//Best Tick Space
double TempTickSpace = (m_MaxValue-m_MinValue)/MaxTickNumber;
// Calculate appropriate tickSpace (not rounded on 'strange values' but
// on something like 1, 2 or 5*10^X where X is optimalized for showing the most
// significant digits)
int Zeros = (int)floor(log10(TempTickSpace));
double MinTickSpace = pow(10.0,Zeros);
int Digits = 0;
if (Zeros<0) //must set digits
{
Digits = (int)fabs(Zeros*1.0);
}
if (MinTickSpace>=TempTickSpace)
{
m_TickIncrement = MinTickSpace;
SetDecimals(Digits);
}
else if (MinTickSpace*2>=TempTickSpace)
{
m_TickIncrement = MinTickSpace*2;
SetDecimals(Digits);
}
else if (MinTickSpace*5>=TempTickSpace)
{
m_TickIncrement = MinTickSpace*5;
SetDecimals(Digits);
}
else if (MinTickSpace*10>=TempTickSpace)
{
m_TickIncrement = MinTickSpace*10;
if (Digits)
SetDecimals(Digits-1);
else
SetDecimals(Digits);
}
}
CalculateFirstTick();
}
void CChartAxis::CalculateFirstTick()
{
if (m_bIsLogarithmic)
{
int LogBase = (int)log10(m_MinValue);
m_FirstTickVal = pow(10.0,LogBase);
}
else
{
m_FirstTickVal = 0;
if (m_TickIncrement!=0)
{
if (m_MinValue == 0)
m_FirstTickVal = 0;
else if (m_MinValue>0)
{
m_FirstTickVal = (int)(m_MinValue/m_TickIncrement) * m_TickIncrement;
while (m_FirstTickVal<m_MinValue)
m_FirstTickVal += m_TickIncrement;
}
else
{
m_FirstTickVal = (int)(m_MinValue/m_TickIncrement) * m_TickIncrement;
while (m_FirstTickVal>m_MinValue)
m_FirstTickVal -= m_TickIncrement;
if (!(m_FirstTickVal == m_MinValue))
m_FirstTickVal += m_TickIncrement;
}
}
}
}
long CChartAxis::GetTickScreenPos(int TickIndex) const
{
double TickVal = 0;
if (!m_bIsLogarithmic)
TickVal = m_FirstTickVal + TickIndex * m_TickIncrement;
else
TickVal = m_FirstTickVal * pow(m_TickIncrement,TickIndex);
return ValueToScreen(TickVal);
}
long CChartAxis::ValueToScreen(double Value) const
{
long Offset = 0;
if (m_bIsLogarithmic)
Offset = (int)floor((log10(Value)-log10(m_MinValue)) * GetAxisLenght()/(log10(m_MaxValue)-log10(m_MinValue)) );
else
{
Offset = (int)floor( (Value - m_MinValue) * GetAxisLenght()/(m_MaxValue-m_MinValue) );
}
if (m_bIsHorizontal)
{
if (!m_bIsInverted)
return (m_StartPos + Offset);
else
return (m_EndPos - Offset);
}
else
{
if (!m_bIsInverted)
return (m_StartPos - Offset);
else
return (m_EndPos + Offset);
}
}
double CChartAxis::ScreenToValue(long ScreenVal) const
{
int AxisOffset = 0;
if (!m_bIsHorizontal)
{
if (m_bIsInverted)
AxisOffset = ScreenVal - m_EndPos;
else
AxisOffset = m_StartPos - ScreenVal;
}
else
{
if (!m_bIsInverted)
AxisOffset = ScreenVal - m_StartPos;
else
AxisOffset = m_EndPos - ScreenVal;
}
if (!m_bIsLogarithmic)
return ( (AxisOffset * 1.0 / GetAxisLenght()*(m_MaxValue-m_MinValue)) + m_MinValue);
else
return (pow(10.0,(AxisOffset *1.0 / GetAxisLenght()*(log10(m_MaxValue)-log10(m_MinValue)) ) + log10(m_MinValue)) );
}
void CChartAxis::PanAxis(long PanStart, long PanEnd)
{
double StartVal = ScreenToValue(PanStart);
double EndVal = ScreenToValue(PanEnd);
if (!m_bIsLogarithmic)
{
double Shift = StartVal - EndVal;
SetZoomMinMax(m_MinValue+Shift,m_MaxValue+Shift);
}
else
{
double Factor = StartVal/EndVal;
SetZoomMinMax(m_MinValue*Factor,m_MaxValue*Factor);
}
}
void CChartAxis::SetZoomMinMax(double Minimum, double Maximum)
{
if (Minimum > Maximum)
{
TRACE("Maximum axis value must be > minimum axis value");
return;
}
m_MinValue = Minimum;
m_MaxValue = Maximum;
}
void CChartAxis::UndoZoom()
{
SetMinMax(m_UnzoomMin,m_UnzoomMax);
}
void CChartAxis::RegisterSeries(CChartSerie* pSeries)
{
// First check if the series is already present in the list
SeriesList::iterator iter = m_pRelatedSeries.begin();
for (iter; iter!=m_pRelatedSeries.end(); iter++)
{
if ( (*iter) == pSeries)
return;
}
m_pRelatedSeries.push_back(pSeries);
}
void CChartAxis::UnregisterSeries(CChartSerie* pSeries)
{
SeriesList::iterator iter = m_pRelatedSeries.begin();
for (iter; iter!=m_pRelatedSeries.end(); iter++)
{
if ( (*iter) == pSeries)
{
m_pRelatedSeries.erase(iter);
return;
}
}
}
void CChartAxis::RefreshAutoAxis()
{
if (!m_bIsAutomatic)
return;
double SeriesMin = 0;
double SeriesMax = 0;
double TempMin = 0;
double TempMax = 0;
SeriesList::iterator iter = m_pRelatedSeries.begin();
if (iter != m_pRelatedSeries.end())
{
if (m_bIsHorizontal)
(*iter)->GetSerieXMinMax(SeriesMin,SeriesMax);
else
(*iter)->GetSerieYMinMax(SeriesMin,SeriesMax);
}
for (iter; iter!=m_pRelatedSeries.end(); iter++)
{
if (m_bIsHorizontal)
(*iter)->GetSerieXMinMax(TempMin,TempMax);
else
(*iter)->GetSerieYMinMax(TempMin,TempMax);
if (TempMin < SeriesMin)
SeriesMin = TempMin;
if (TempMax > SeriesMax)
SeriesMax = TempMax;
}
if ( (SeriesMax>m_MaxValue) || (SeriesMin<m_MinValue) )
{
SetMinMax(SeriesMin,SeriesMax);
m_pParent->RefreshCtrl();
}
}