cGraphCfg.h

Go to the documentation of this file.

//
//
#ifndef _INC_GraphCfg_H_
#define _INC_GraphCfg_H_
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif 
 
#include "GrayGraph.h"
#include "GrayLib/include/Geometry/cRectI.h"
#include "GrayLib/include/Math/cRandomFloat.h"
#include "GrayCore/include/cTimeFile.h"
 
#ifndef _MFC_VER
#include "GrayLib/include/Windows/cWndGDI.h"
#include "GrayLib/include/Windows/cWndDC.h"
#include "GrayLib/include/Windows/cWndDialog.h"
#include "GrayLib/include/Windows/cWndBitmap.h"
#include "GrayCore/include/cArchive.h"
#endif
 
namespace GrayGraph
{
        class GRAYGRAPH_LINK CGraphDataSource : public CObject
        {
                // data stream info.
        public:
                CString m_sURL;                         
 
                INT_PTR m_objId;                        
                static const INT_PTR k_EMPTY_OBJECT_ID = 0;     
 
        private:
                void Copy(const CGraphDataSource* pSrc);
        public:
                virtual void Serialize(CArchive& ar) override;
                const CGraphDataSource& operator=(const CGraphDataSource& src)
                {
                        Copy(&src);
                        return *this;
                }
                CGraphDataSource();
                CGraphDataSource(CGraphDataSource& src) // copy constructor
                {
                        Copy(&src);
                }
                ~CGraphDataSource();
 
                // Implementation
        protected:
                DECLARE_SERIAL(CGraphDataSource)
        };
 
        // Time stamp variable. 
        typedef FILETIME_t              GraphTime_t;                    // FILETIME in 64 bits QWORD
        typedef cTimeFile               CGraphTime;                             //   
        typedef cTimeSpanFile   CGraphTimeSpan;
 
#define CVT_TIME_TO_BASE(t) (t).get_Val()                               // convert to FILETIME_t units so it can be stored in 
#define CVT_SPAN_TO_BASE(t) 0 // (t).GetTotalSeconds()          // convert to FILETIME_t units
 
        typedef double GraphVal_t;                              
        typedef cRectT<GraphVal_t> CGraphRect;  
 
        class GRAYGRAPH_LINK CGraphFont : public CObject
        {
 
        public:
                cWinFontCfg m_FontCfg;          
 
        private:
                cWndFont m_Font;                
                COLORREF m_color;       
                                                        // COLORREF m_colorback;
        private:
                void Copy(const CGraphFont* psrc)
                {
                        SetFontChanged();
                        m_FontCfg = psrc->m_FontCfg;
                        m_color = psrc->m_color;
                }
 
        protected:
                DECLARE_SERIAL(CGraphFont)
 
        public:
                CGraphFont();
                CGraphFont(CGraphFont& src)     // copy constructor
                {
                        Copy(&src);
                }
 
                int GetWidth() const
                {
                        return m_FontCfg.get_FontWidthA() ;
                }
                int GetHeight() const
                {
                        return(m_FontCfg.get_FontSizeA());
                }
                void SetFontChanged()
                {
                        m_Font.DeleteObject();
                }
                CFont* GetFont()
                {
                        if (m_Font.m_hObject == WINHANDLE_NULL)
                        {
                                // We need to create it.
                                if (!m_Font.CreateFontIndirectX(&m_FontCfg))
                                        return nullptr;
                        }
                        return &m_Font;
                }
                const CGraphFont& operator=(const CGraphFont& src)
                {
                        Copy(&src);
                        return *this;
                }
 
                const cWinFontCfg& get_FontCfg() const
                {
                        return m_FontCfg ;
                }
                void put_FontCfg(const cWinFontCfg& fontcfg)
                {
                        if (m_FontCfg.IsSameFont(fontcfg))
                                return;
                        SetFontChanged();
                        m_FontCfg = fontcfg;
                }
 
                COLORREF get_FontColor() const
                {
                        return m_color;
                }
                void put_FontColor(COLORREF color)
                {
                        m_color = color;
                }
 
                virtual void Serialize(CArchive& ar);
        };
 
        // configuration info.
 
        enum GraphPenStyle_Type
        {
                GraphPenStyle_Line,
                GraphPenStyle_LineFill,
                GraphPenStyle_Bar,
                GraphPenStyle_VLine,
                GraphPenStyle_HLine,
                GraphPenStyle_Points,
                GraphPenStyle_QTY,
        };
 
        enum GraphPenPoint_Type
        {
                GraphPenPoint_None,
                GraphPenPoint_Dot,
                GraphPenPoint_Square,
                GraphPenPoint_Triangle,
                GraphPenPoint_X,
                GraphPenPoint_Plus,
                GraphPenPoint_Diamond,
                GraphPenPoint_InvertTri,
                GraphPenPoint_QTY,
        };
 
        class GRAYGRAPH_LINK CGraphPenCfg : public CObject
        {
        private:
                static int sm_iNextUniqueID;
                int m_iUniqueID;        
 
                GraphPenStyle_Type m_Style;             
                GraphPenPoint_Type m_PointType; 
                COLORREF m_Color;       
 
        public:
                CString m_sLabel;       
 
                // The data sources.
                CGraphDataSource m_Src;
                // ??? Is there an external file archive for the data stream.
                BOOL m_bShowUnits;
                CString m_sUnits;               
 
                BOOL m_fMasked;                 
                BOOL m_bShowExp;                
                BOOL m_bShowAvg;                
 
                // Configure a time and unit range to display (by default)
                // This is here because all the pens can become unsynced.
 
                CGraphTime m_TimeStart;
                CGraphTime m_TimeStop;
 
                GraphVal_t m_valMinDisp;
                GraphVal_t m_valMaxDisp;
                GraphVal_t m_valMidDisp;        
 
                int m_iTmpDrawWidth;            
 
        private:
                void Copy(const CGraphPenCfg * pSrc);
 
                // Implementation
        protected:
                DECLARE_SERIAL(CGraphPenCfg)
        public:
                void SetNewUniqueID()
                {
                        m_iUniqueID = ++sm_iNextUniqueID;
                }
                int GetUniqueID() const
                {
                        return(m_iUniqueID);
                }
                const CGraphPenCfg& operator=(const CGraphPenCfg& src)
                {
                        Copy(&src);
                        return(*this);
                }
                cString GetListName(ITERATE_t i) const;
                static cString FindObjectName(const CGraphDataSource *pSrc);
 
                virtual void Serialize(CArchive& ar);
 
                void put_PenStyle(GraphPenStyle_Type style)
                {
                        ASSERT(style < GraphPenStyle_QTY);
                        m_Style = style;
                }
                GraphPenStyle_Type get_PenStyle() const
                {
                        return m_Style;
                }
 
                void put_PenPointType(GraphPenPoint_Type PointType)
                {
                        ASSERT(PointType < GraphPenPoint_QTY);
                        m_PointType = PointType;
                }
                GraphPenPoint_Type get_PenPointType() const
                {
                        return m_PointType;
                }
 
                COLORREF get_PenColor() const
                {
                        return(m_Color);
                }
                void put_PenColor(COLORREF color)
                {
                        m_Color = color;
                }
 
                static void DrawDataPoint(CDC& dc, int x, int y, GraphPenStyle_Type PenStyle, GraphPenPoint_Type PointType, int iSize);
                void DrawDataPoint(CDC& dc, int x, int y, int iSize)
                {
                        DrawDataPoint(dc, x, y, get_PenStyle(), get_PenPointType(), iSize);
                }
 
                void DrawPenLabel(CDC& dc, CRect& rect, int iPointWidth, int iPointSize, int iOffsetX, int iOffsetY);
 
                CGraphPenCfg();
                CGraphPenCfg(CGraphPenCfg& src) // copy constructor
                {
                        Copy(&src);
                }
                ~CGraphPenCfg();
        };
 
        enum GraphPlotBackFormat_Type
        {
                GraphPlotBackFormat_TopLeft,
                GraphPlotBackFormat_Center,
                GraphPlotBackFormat_Tile,
        };
 
        enum GraphPlotShowPens_Type
        {
                GraphPlotShowPens_None,
                GraphPlotShowPens_Bottom,
                GraphPlotShowPens_Right,
        };
 
        class GRAYGRAPH_LINK CGraphCfg : public CObject
        {
 
        private:
                // What pens are we showing?
                CArray<CGraphPenCfg, CGraphPenCfg&> m_PenCfg;
 
        public:
                BOOL m_fShowPenUnits;           
                BOOL m_fShowTimeScale;          
                int m_eShowPenLabels;           
                BOOL m_fShowLabel;                      
 
                // Frame Border
                int     m_iMarginSize;                  
                COLORREF m_BorderBackColor;     
 
                // Label Area
                CString m_sLabelText;   
 
                // Plot area
                GraphPlotBackFormat_Type m_ePlotBackFormat;     
                COLORREF m_PlotBackColor;       
                CString m_sPlotBackPic; 
                BOOL m_bPlotGrid;       
 
                CBitmap m_bmpPlotBack;  
 
                // Time Scale.
                BOOL m_fTimeScaleSync;                          
                TIMESECD_t m_iTimeScaleGap;                     
                BOOL m_fTimeScaleVertical;
 
                // Pen value units area.
                BOOL m_fPenUnitVertical;
                BOOL m_fPenUnitSync;                    
 
                // Fonts used for all sections.
                CGraphFont m_LabelFont;
                CGraphFont m_PenUnitsFont;
                CGraphFont m_TimeScaleFont;
                CGraphFont m_PenLabelsFont;
 
        private:
                void Copy(const CGraphCfg * psrc);
        protected:
                DECLARE_SERIAL(CGraphCfg)
        public:
                CGraphCfg();
                CGraphCfg(const CGraphCfg& src)
                {
                        Copy(&src);
                }
 
                ~CGraphCfg();
 
                const CGraphCfg& operator=(const CGraphCfg& src)
                {
                        Copy(&src);
                        return *this;
                }
                void CopyPenCfgs(const CGraphCfg * pSrc);
 
                ITERATE_t GetPenCfgQty() const
                {
                        return(m_PenCfg.GetSize());
                }
                const CGraphPenCfg* GetPenCfg(ITERATE_t i) const
                {
                        return(&(const_cast <CGraphCfg*>(this)->m_PenCfg.ElementAt(i)));
                }
                CGraphPenCfg * GetPenCfg(ITERATE_t i)
                {
                        return(&(m_PenCfg.ElementAt(i)));
                }
                ITERATE_t AddPenCfg(CGraphPenCfg & PenCfg)
                {
                        return m_PenCfg.Add(PenCfg);
                }
                void DelPenCfg(ITERATE_t i)
                {
                        m_PenCfg.RemoveAt(i);
                }
 
                void DrawPlotBackground(CDC&  dc, CRect&  rect);
                virtual void Serialize(CArchive& ar);
 
                bool LoadPlotBackground(CString & sFilename, bool fTest);
 
                void GetViewRect(CGraphRect& rectView, int iActivePen) const;
                void SetViewRect(CGraphRect& rectView, int iActivePen);
 
                bool IsPenColorUsed(COLORREF Color) const;
                COLORREF GetUnusedPenColor() const;
                bool IsPenPointTypeUsed(GraphPenPoint_Type ePenPoint) const;
                GraphPenPoint_Type GetUnusedPenPointType() const;
        };
};
 
#endif  // _INC_GraphCfg_H_