xgraph.cpp

Displaying large amounts of technical data in a chart can be a frustrating task. You can find tons o

			pDC->MoveTo (m_oldCursorPoint.x, m_clInnerRect.top);
			pDC->LineTo (m_oldCursorPoint.x, m_clInnerRect.bottom);
		}

		if (m_nCursorFlags & XGC_HORIZ)
		{
			pDC->MoveTo (m_clInnerRect.left, m_oldCursorPoint.y);
			pDC->LineTo (m_clInnerRect.right, m_oldCursorPoint.y);
		}

		pDC->Rectangle(m_oldCursorPoint.x - (m_nSnapRange / 2), m_oldCursorPoint.y - (m_nSnapRange / 2), m_oldCursorPoint.x + (m_nSnapRange / 2) + 1, m_oldCursorPoint.y + (m_nSnapRange / 2) + 1);
	}

	if (m_nCursorFlags & XGC_VERT)
	{
		pDC->MoveTo (m_CurrentPoint.x, m_clInnerRect.top);
		pDC->LineTo (m_CurrentPoint.x, m_clInnerRect.bottom);
	}

	if (m_nCursorFlags & XGC_HORIZ)
	{
		pDC->MoveTo (m_clInnerRect.left, m_CurrentPoint.y);
		pDC->LineTo (m_clInnerRect.right, m_CurrentPoint.y);
	}
	
	pDC->Rectangle(m_CurrentPoint.x - (m_nSnapRange / 2), m_CurrentPoint.y - (m_nSnapRange / 2), m_CurrentPoint.x + (m_nSnapRange / 2) + 1, m_CurrentPoint.y + (m_nSnapRange / 2) + 1);

	m_oldCursorPoint = m_CurrentPoint;

	pDC->SetROP2 (nOldROP2);

	if (m_nCursorFlags & XGC_LEGEND)
		DrawCursorLegend(pDC);
}

void CXGraph::DrawCursorLegend (CDCEx* pDC)
{
	int    i;
    double fVal;

    CString cLabel = "", cFmt, cItem;

    m_CursorLabel.m_bVisible = true;
	   
    for (i = 0; i < m_XAxis.size(); i++)
    {
        //CHANGED: bugfix, correct handling of X axis in time mode
        fVal = m_XAxis[i].GetValueForPos (m_CurrentPoint.x);
        if(m_XAxis[i].m_bDateTime)
        {
			cFmt = m_XAxis[i].m_cDisplayFmt;
			cFmt.Replace (_T("\r"),_T(" "));
			cFmt.Replace (_T("\n"),_T(" "));
#ifndef _WIN32_WCE
            cFmt = _T("X[%02d] : ") + COleDateTime(fVal).Format(cFmt) + _T(" %s");
#else
			cFmt = _T("X[%02d] : ") + COleDateTime(fVal).Format() + _T(" %s");
#endif
            cItem.Format(cFmt, i+1, m_XAxis[i].m_cLabel);
            cLabel += (_T(" ") + cItem + _T("\r\n"));
        }
        else
        {
            cFmt = _T("X[%02d] : ") + m_XAxis[i].m_cDisplayFmt + _T(" %s");
            cItem.Format(cFmt, i+1, fVal, m_XAxis[i].m_cLabel);
            cLabel += (_T(" ") + cItem + _T("\r\n"));
        }
        //ENDCHANGES
    }
    
    for (i = 0; i < m_YAxis.size(); i++)
    {
        fVal = m_YAxis[i].GetValueForPos (m_CurrentPoint.y);
        cFmt = _T("Y[%02d] : ") + m_YAxis[i].m_cDisplayFmt + _T(" %s");
        cItem.Format(cFmt, i+1, fVal, m_YAxis[i].m_cLabel);
        cLabel += (_T(" ") + cItem + _T("\r\n"));
    }

    if (m_nSnappedCurve != -1)
    {
        //CHANGED: bugfix, correct handling of X axis in time mode
        CString cXFmt = m_XAxis[m_Data[m_nSnappedCurve].m_nXAxis].m_cDisplayFmt;
		cXFmt.Replace (_T("\r"),_T(" "));
		cXFmt.Replace (_T("\n"),_T(" "));
        CString cYFmt = m_YAxis[m_Data[m_nSnappedCurve].m_nYAxis].m_cDisplayFmt;
        if(m_XAxis[m_Data[m_nSnappedCurve].m_nXAxis].m_bDateTime)
        {			
#ifndef _WIN32_WCE
            cFmt = _T("%s[%02d] : ") + COleDateTime(m_fSnappedXVal).Format(cXFmt) + _T(", ") + cYFmt;
#else
			cFmt = _T("%s[%02d] : ") + COleDateTime(m_fSnappedXVal).Format() + _T(", ") + cYFmt;
#endif
            cItem.Format(cFmt, m_Data[m_nSnappedCurve].m_cLabel, m_nSnappedCurve + 1, m_fSnappedYVal);
            cLabel += (_T(" ") + cItem + _T("\r\n"));
        }
        else
        {
            cFmt = _T("%s[%02d] : ") + cXFmt + _T(", ") + cYFmt;
            cItem.Format(cFmt, m_Data[m_nSnappedCurve].m_cLabel, m_nSnappedCurve + 1, m_fSnappedXVal, m_fSnappedYVal);
            cLabel += (_T(" ") + cItem + _T("\r\n"));
        }
        //ENDCHANGES
    }

    m_CursorLabel.m_cText = cLabel;

    m_CursorLabel.Draw (pDC);
}

LRESULT CXGraph::WindowProc(UINT message, WPARAM wParam, LPARAM lParam) 
{
	return CWnd::WindowProc(message, wParam, lParam);
}

bool CXGraph::SelectCurve(int nCurve)
{
	if (nCurve < 0 || nCurve >= m_Data.size())
		return false;

	for (int i = 0; i < m_Data.size(); i++)
		m_Data[i].m_bSelected = (i == nCurve);

	Invalidate();

	return true;
}

bool CXGraph::SelectXAxis(int nAxis)
{
	if (nAxis < 0 || nAxis >= m_XAxis.size())
		return false;

	for (int i = 0; i < m_XAxis.size(); i++)
		m_XAxis[i].m_bSelected = (i == nAxis);

	Invalidate();

	return true;
}

bool CXGraph::SelectYAxis(int nAxis)
{
	if (nAxis < 0 || nAxis >= m_YAxis.size())
		return false;

	for (int i = 0; i < m_YAxis.size(); i++)
		m_YAxis[i].m_bSelected = (i == nAxis);

	Invalidate();
	
	return true;
}

void CXGraph::OnKeyUp(UINT nChar, UINT nRepCnt, UINT nFlags) 
{
	if (nChar == VK_HOME)
	{
		for (int i = 0; i < m_XAxis.size(); i++)
			m_XAxis[i].Reset ();
		
		for (i = 0; i < m_YAxis.size(); i++)
			m_YAxis[i].Reset();
		
		Invalidate();
	}

	if (nChar == VK_ADD)
	{
		for (int i = 0; i < m_XAxis.size(); i++)
		{
			double fStep = m_XAxis[i].m_fRange / 10.0;
			VERIFY(m_XAxis[i].SetCurrentRange (m_XAxis[i].m_fCurMin + fStep, m_XAxis[i].m_fCurMax - fStep));
		}
		for (i = 0; i < m_YAxis.size(); i++)
		{
			double fStep = m_YAxis[i].m_fRange / 10.0;
			VERIFY(m_YAxis[i].SetCurrentRange (m_YAxis[i].m_fCurMin + fStep, m_YAxis[i].m_fCurMax - fStep));
		}
		
		Invalidate();
	}

	if (nChar == VK_SUBTRACT)
	{
		for (int i = 0; i < m_XAxis.size(); i++)
		{
			double fStep = m_XAxis[i].m_fRange / 10.0;
			VERIFY(m_XAxis[i].SetCurrentRange (m_XAxis[i].m_fCurMin - fStep, m_XAxis[i].m_fCurMax + fStep));
		}
		for (i = 0; i < m_YAxis.size(); i++)
		{
			double fStep = m_YAxis[i].m_fRange / 10.0;
			VERIFY(m_YAxis[i].SetCurrentRange (m_YAxis[i].m_fCurMin - fStep, m_YAxis[i].m_fCurMax + fStep));
		}
		
		Invalidate();
	}

	if (nChar == VK_LEFT)
	{
		if (m_opOperation == opCursor)
			m_CurrentPoint.x --;
		else
		for (int i = 0; i < m_XAxis.size(); i++)
		{
			double fStep = m_XAxis[i].m_fRange / 10.0;
			VERIFY(m_XAxis[i].SetCurrentRange (m_XAxis[i].m_fCurMin + fStep, m_XAxis[i].m_fCurMax + fStep));
		}

		Invalidate();
	}
	
	if (nChar == VK_RIGHT)
	{
		if (m_opOperation == opCursor)
			m_CurrentPoint.x++;
		else
		for (int i = 0; i < m_XAxis.size(); i++)
		{
			double fStep = m_XAxis[i].m_fRange / 10.0;
			VERIFY(m_XAxis[i].SetCurrentRange (m_XAxis[i].m_fCurMin - fStep, m_XAxis[i].m_fCurMax - fStep));
		}

		Invalidate();
	}

	if (nChar == VK_UP)
	{
		if (m_opOperation == opCursor)
			m_CurrentPoint.y--;
		else
		for (int i = 0; i < m_YAxis.size(); i++)
		{
			double fStep = m_YAxis[i].m_fRange / 10.0;
			VERIFY(m_YAxis[i].SetCurrentRange (m_YAxis[i].m_fCurMin - fStep, m_YAxis[i].m_fCurMax - fStep));
		}

		Invalidate();
	}

	if (nChar == VK_DOWN)
	{
		if (m_opOperation == opCursor)
			m_CurrentPoint.y++;
		else
		for (int i = 0; i < m_YAxis.size(); i++)
		{
			double fStep = m_YAxis[i].m_fRange / 10.0;
			VERIFY(m_YAxis[i].SetCurrentRange (m_YAxis[i].m_fCurMin + fStep, m_YAxis[i].m_fCurMax + fStep));
		}

		Invalidate();
	}
	
	CWnd::OnKeyUp(nChar, nRepCnt, nFlags);
}

void CXGraph::ResetAll()
{
	m_XAxis.clear ();
	m_YAxis.clear ();
	m_Data.clear ();

	// Delete all objects
	// Spare 1st object (CursorLabel)
	while (m_Objects.GetCount () > 1)
		delete m_Objects.RemoveTail ();

}

#ifndef _WIN32_WCE
void CXGraph::OnRButtonDown(UINT nFlags, CPoint point) 
{
	m_bRButtonDown = true;
	
	CWnd::OnRButtonDown(nFlags, point);
}
#endif

void CXGraph::Serialize( CArchive& archive, UINT nFlags)
{	
	int nHelper;
	
	CWnd::Serialize (archive);

    if( archive.IsStoring() )
    {
		archive << nFlags;
		
		if (nFlags & PERSIST_PROPERTIES)
		{
			archive << m_crBackColor;
			archive << m_crGraphColor;
			archive << m_crInnerColor;
			archive << m_bDoubleBuffer;
			archive << m_bShowLegend;
			archive << (int) m_LegendAlignment;
			archive << m_bSnapCursor;
			archive << m_nSnapRange;
			archive << m_nLeftMargin;
			archive << m_nTopMargin;
			archive << m_nRightMargin;
			archive << m_nBottomMargin;
			archive << m_nAxisSpace;
			archive << m_nSelectedSerie;
		}

		if (nFlags & PERSIST_DATA)
		{
			archive << m_Data.size ();
			for (int i = 0; i < m_Data.size(); i++)
				m_Data[i].Serialize (archive);

			archive << m_XAxis.size ();
			for (i = 0; i < m_XAxis.size(); i++)
				m_XAxis[i].Serialize (archive);

			archive << m_YAxis.size ();
			for (i = 0; i < m_YAxis.size(); i++)
				m_YAxis[i].Serialize (archive);
		}

		if (nFlags & PERSIST_OBJECTS)
		{

			archive << m_Measures.size();
			for (int i = 0; i < m_Measures.size(); i++)
				archive.Write(&m_Measures[i], sizeof(MeasureDef));
		
			// Spare cursor label (1st object), created within constructor
			archive << m_Objects.GetCount () - 1;

			i = 0;

			for (POSITION pos = m_Objects.GetHeadPosition (); pos != NULL; i++ )
			{			
				CXGraphObject *pObject = (CXGraphObject*) m_Objects.GetNext (pos);
				if ( i > 0)
					archive << pObject;
		
			}
		}
	}
	else
    {
		archive >> nFlags;

		if (nFlags & PERSIST_PROPERTIES)
		{
			archive >> m_crBackColor;
			archive >> m_crGraphColor;
			archive >> m_crInnerColor;
			archive >> m_bDoubleBuffer;
			archive >> m_bShowLegend;
			archive >> nHelper;
			m_LegendAlignment = (EAlignment) nHelper;
			archive >> m_bSnapCursor;
			archive >> m_nSnapRange;
			archive >> m_nLeftMargin;
			archive >> m_nTopMargin;
			archive >> m_nRightMargin;
			archive >> m_nBottomMargin;
			archive >> m_nAxisSpace;
			archive >> m_nSelectedSerie;
		}

		if (nFlags & PERSIST_DATA)
		{
			archive >> nHelper;
			for (int i = 0; i < nHelper; i++)
			{
				CXGraphDataSerie serie;
				serie.Serialize (archive);
				serie.m_pGraph = this;
				m_Data.push_back (serie);
			}

			archive >> nHelper;
			for (i = 0; i < nHelper; i++)
			{
				CXGraphAxis axis;
				axis.Serialize (archive);
				axis.m_pGraph = this;
				m_XAxis.push_back (axis);
			}

			archive >> nHelper;
			for (i = 0; i < nHelper; i++)
			{
				CXGraphAxis axis;
				axis.Serialize (archive);
				axis.m_pGraph = this;
				m_YAxis.push_back (axis);
			}
		}

		if (nFlags & PERSIST_OBJECTS)
		{
			archive >> nHelper;

			for (int i = 0; i < nHelper; i++)
			{
				MeasureDef measure;
				archive.Read(&measure, sizeof(MeasureDef));
				m_Measures.push_back (measure);
			}
			
			archive >> nHelper;

			for (i = 0; i < nHelper; i++)
			{			
				CXGraphObject *pObject;
				archive >> pObject;
				pObject->m_pGraph = this;
				m_Objects.AddTail (pObject);
			}
		}

		Invalidate();
	}
}

bool CXGraph::Save(const CString cFile, UINT nFlags)
{
	CFile file;

	if (nFlags == 0)
		return false;

	m_pTracker = NULL;
	m_pCurrentObject = NULL;

	if (!file.Open (cFile, CFile::modeCreate | CFile::modeWrite ))
		return false;

#ifndef _WIN32_WCE
	try	
	{
#endif
		CArchive ar(&file, CArchive::store);
		Serialize(ar, nFlags);
#ifndef _WIN32_WCE
	} 
	catch (CException* e)	
	{
		e->Delete ();
		return false;
	}
#endif

	return true;
}

bool CXGraph::Load(const CString cFile)
{
	CFile file;
	
	if (!file.Open (cFile, CFile::modeRead ))
		return false;

	ResetAll();
#ifndef _WIN32_WCE
	try
#endif
	{

		CArchive ar(&file, CArchive::load);
		Serialize(ar, 0);
	} 
#ifndef _WIN32_WCE
	catch (CException* e)
	{
		e->Delete ();
		return false;
	}
#endif
	return true;
}

void CXGraph::ParentCallback()
{
	::PostMessage(GetParent()->m_hWnd, IDM_PARENTCALLBACK, 0, (long) this);		
}

#ifndef _WIN32_WCE
HANDLE CXGraph::DDBToDIB( CBitmap& bitmap, DWORD dwCompression, CPalette* pPal ) 
{
	BITMAP			bm;
	BITMAPINFOHEADER	bi;
	LPBITMAPINFOHEADER 	lpbi;
	DWORD			dwLen;
	HANDLE			hDIB;
	HANDLE			handle;
	HDC 			hDC;
	HPALETTE		hPal;


	ASSERT( bitmap.GetSafeHandle() );

	// The function has no arg for bitfields
	if( dwCompression == BI_BITFIELDS )
		return NULL;

	// If a palette has not been supplied use defaul palette
	hPal = (HPALETTE) pPal->GetSafeHandle();
	if (hPal==NULL)
		hPal = (HPALETTE) GetStockObject(DEFAULT_PALETTE);

	// Get bitmap information
	bitmap.GetObject(sizeof(bm),(LPSTR)&bm);

	// Initialize the bitmapinfoheader
	bi.biSize		= sizeof(BITMAPINFOHEADER);
	bi.biWidth		= bm.bmWidth;
	bi.biHeight 		= bm.bmHeight;