TnbMfcLineGraphViewCtrl.h

[詳解]

#pragma once
#include "TnbBitmapImage.h"
#include "TnbMfcBitmapDC.h"
#include "TnbMap.h"
#include "TnbTextDrawer.h"
#include <float.h>
#include <math.h>
 
 
 
//TNB Library
namespace TNB {
namespace MFC {
 
 
 
class CLineGraphViewCtrl : public CWnd, CCopyImpossible
{
    DEFSUPER(CWnd);
public:
 
    enum
    {
        EDGE_VALUE = 10000,             
        INTERNALLY_COLOR = RGB(1, 1, 1) 
    };
 
    enum ELineStyle
    {
        LineStyle_Non,      
        LineStyle_Solid,    
        LineStyle_Dot,      
        LineStyle_Bold,     
        LineStyle_EdgeDot,  
    };
 
    CLineGraphViewCtrl(void) : m_isReverseIndexMode(false), m_viewHorizontalPos(0), m_markerWidth(6), m_scrollOneStep(1)
        , m_viewTopValue(EDGE_VALUE), m_viewbottomValue(-EDGE_VALUE), m_scrollBarHeight(::GetSystemMetrics(SM_CYHSCROLL))
        , m_backColor(RGB(0, 0, 0)), m_isGraphImageDcLeading(false), m_isOndemandRemakeViewImage(false), m_horzIndexPixel(1)
        , m_isMouseButtonPressed(false), m_isScrollBarUsed(true)
    {
        m_viewHeight = m_viewTopValue - m_viewbottomValue + 0.0; //表示範囲
    }
 
    bool SetBackgroundWidth(COLORREF backgroundColor, size_t graphWidth = 0)
    {
        if ( ::IsWindow(GetSafeHwnd()) )
        {
            CRect rc;
            GetClientRect(&rc);
            CSize sz = rc.Size();
            m_backColor = backgroundColor;
            if ( graphWidth == 0 )
            {
                graphWidth = sz.cx;
            }
            if ( sz.cx == 0 || sz.cy == 0 )
            {
                return false;
            }
            m_Resize(sz, graphWidth);
            SetViewHorizontalPos(0);
            return true;
        }
        return false;
    }
 
    bool SetHorizontalIndexPixel(int pixel = 1, bool isReverseIndexMode = false)
    {
        if ( ::IsWindow(GetSafeHwnd()) )
        {
            m_horzIndexPixel = pixel;
            if ( m_horzIndexPixel <= 0 )
            {
                m_horzIndexPixel = 1;
            }
            m_isReverseIndexMode = isReverseIndexMode;
            m_Resize();
            return true;
        }
        return false;
    }
    
    int GetHorizontalIndexPixel(void) const
    {
        return m_horzIndexPixel;
    }
 
    size_t SetPointMakertSize(size_t width)
    {
        size_t r = m_markerWidth;
        m_markerWidth = width;
        return r;
    }
 
    void GetViewValueRange(double& _topValue, double& _bottomValue) const
    {
        _topValue = m_viewTopValue;
        _bottomValue = m_viewbottomValue;
    }
 
    bool SetViewValueRange(double topValue, double bottomValue)
    {
        if ( ::IsWindow(GetSafeHwnd()) )
        {
            if ( topValue < bottomValue )
            {
                Swap(topValue, bottomValue);
            }
            if ( m_viewTopValue == topValue && m_viewbottomValue == bottomValue )
            {
                return true;
            }
            m_viewTopValue = topValue;
            m_viewbottomValue = bottomValue;
            m_viewHeight = m_viewTopValue - m_viewbottomValue + 0.0; //表示範囲
            //
            const SIZE& sz = m_graphImage.GetSize();
            if ( m_graphImageDc.GetSafeHdc() != NULL )
            {
                m_graphImageDc.FillSolidRect(0, 0, sz.cx, sz.cy, INTERNALLY_COLOR);
            }
            m_pointMap.RemoveAll();
            return true;
        }
        return false;
    }
    
    bool SetScrollBarHeight(int height = 0)
    {
        if ( ::IsWindow(GetSafeHwnd()) )
        {
            m_scrollBarHeight = height;
            if ( height <= 0 )
            {
                m_scrollBarHeight = ::GetSystemMetrics(SM_CYHSCROLL);
            }
            m_isScrollBarUsed = (height >= 0);
            m_Resize();
            return true;
        }
        return false;
    }
 
 
    void SetScrollOneStep(size_t os = 1)
    {
        m_scrollOneStep = os;
    }
 
    void SetScaleLine(COLORREF color, ELineStyle style = LineStyle_Solid)
    {
        m_scaleLine.Set(style, color, 0.0);
    }
 
    bool SetSubScaleLine(INDEX number, ELineStyle style = LineStyle_Non, COLORREF color = 0, double step = 0.0)
    {
        if ( number >= 1 && number <= 3 )
        {
            TScaleLineInfo& I = m_subScaleLines[number - 1];
            if ( step <= 0.0 )
            {
                style = LineStyle_Non;
            }
            I.Set(style, color, step);
            return true;
        }
        return false;
    }
 
    bool SetOverlayText(INDEX pos, COLORREF color = RGB(0, 0, 0), LPCTSTR lpsz = NULL, HFONT hFont = NULL)
    {
        if ( pos > 0 && pos < 10 )
        {
            TTextInfo& t = m_testInfo[pos];
            t.hFont =hFont;
            t.text = lpsz;
            t.color = color;
            return true;
        }
        return false;
    }
 
    bool IsReverseHorizontalIndexMode(void) const
    {
        return m_isReverseIndexMode;
    }
 
    bool HasScrollBar(void) const
    {
        return !! ::IsWindow(m_scrollBar);
    }
 
    CDC* GetImageDC(void)
    {
        if ( m_isGraphImageDcLeading || m_graphImageDc.GetSafeHdc() == NULL )
        {
            return NULL;
        }
        m_isGraphImageDcLeading = true;
        return &m_graphImageDc;
    }
 
    void ReleaseImageDC(void)
    {
        if ( m_isGraphImageDcLeading )
        {
            m_isGraphImageDcLeading = false;
        }
    }
 
    const SIZE& GetImageSize(void) const
    {
        return m_graphImage.GetSize();
    }
 
    int HorizontalIndexToX(INDEX horizontalIndex)
    {
        int xx = ToInt(horizontalIndex * m_horzIndexPixel + m_horzIndexPixel / 2);
        if ( m_isReverseIndexMode )
        {
            xx = (m_graphImage.GetSize().cx - 1) - xx;
        }
        return xx;
    }
 
    void Shift(int count = 1)
    {
        if ( m_graphImageDc.GetSafeHdc() != NULL )
        {
            const SIZE& sz = m_graphImage.GetSize();
            count *= m_horzIndexPixel;
            if ( m_isReverseIndexMode )
            {
                count = -count;
            }
            m_graphImageDc.ScrollDC(count, 0, NULL, NULL, NULL, NULL);
            if ( count > 0 )
            {
                m_graphImageDc.FillSolidRect(0, 0, count, sz.cy, INTERNALLY_COLOR);
            }
            else if ( count < 0 )
            {
                m_graphImageDc.FillSolidRect(sz.cx + count, 0, -count, sz.cy, INTERNALLY_COLOR);
            }
            loop ( i, m_pointMap )
            {
                m_pointMap.Ref(i).second->point.x += count;
            }
        }
    }
 
    INDEX GetHorizontalIndexLimit(void) const
    {
        return m_graphImage.GetSize().cx / m_horzIndexPixel;
    }
 
    void ClearPoint(void)
    {
        if ( m_graphImageDc.GetSafeHdc() != NULL )
        {
            const SIZE& sz = m_graphImage.GetSize();
            m_graphImageDc.FillSolidRect(0, 0, sz.cx, sz.cy, INTERNALLY_COLOR);
            m_pointMap.RemoveAll();
        }
    }
 
    void SetPoint(COLORREF color, double value, INDEX horizontalIndex = 0, bool withContinuousLine = true)
    {
        if ( m_graphImageDc.GetSafeHdc() != NULL )
        {
            int xx = HorizontalIndexToX(horizontalIndex);
            m_SetMaker(m_graphImageDc, xx, value, color, withContinuousLine);
        }
    }
 
    void SetVerticalLine(COLORREF color, INDEX horizontalIndex, int length = -1)
    {
        if ( m_graphImageDc.GetSafeHdc() != NULL )
        {
            int xx = HorizontalIndexToX(horizontalIndex);
            CPen pen((length != -2)  ? PS_SOLID : PS_DASH, 1, color);
            CPen* pOldPen = m_graphImageDc.SelectObject(&pen);
            if ( length <= 0 )
            {
                m_graphImageDc.MoveTo(xx, 0);
                m_graphImageDc.LineTo(xx, m_clientSize.cy);
            }
            else
            {
                int yy = m_CalcDrawY(0.0);
                m_graphImageDc.MoveTo(xx, yy - length);
                m_graphImageDc.LineTo(xx, yy + length);
            }
            m_graphImageDc.SelectObject(pOldPen);
        }
    }
 
    void Settle(bool isForce = false)
    {
        if ( isForce )
        {
            m_MakeViewImage();
        }
        else
        {
            OndemandRemakeViewImage();
        }
        RedrawWindow();
    }
 
    size_t GetViewHorizontalPosLimit(void)
    {
        return m_scrollBar.GetScrollLimit();
    }
 
    INDEX GetViewHorizontalPos(void) const
    {
        return m_viewHorizontalPos / m_horzIndexPixel;
    }
 
    void SetViewHorizontalPos(INDEX pos)
    {
        if ( ::IsWindow(m_scrollBar) )
        {
            INDEX xx = pos;
            if ( m_isReverseIndexMode )
            {
                xx = m_scrollBar.GetScrollLimit() - xx;
            }
            m_scrollBar.SetScrollPos(ToInt(xx));
            xx = m_scrollBar.GetScrollPos();
            if ( m_isReverseIndexMode )
            {
                xx = m_scrollBar.GetScrollLimit() - xx;
            }
            m_viewHorizontalPos = xx * m_horzIndexPixel;
            OndemandRemakeViewImage();
            RedrawWindow();
        }
    }
 
protected:
 
    void OndemandRemakeViewImage(void)
    {
        m_isOndemandRemakeViewImage = true;
    }
 
    virtual void OnMadeViewImage(CDC* pDC, const SIZE& sz)
    {
    }
 
    virtual void PreSubclassWindow(void)
    {
        _super::PreSubclassWindow();
        CRect rc;
        GetClientRect(&rc);
        m_clientSize = rc.Size();
        const SIZE& sz = m_clientSize;
        m_viewImage.Set(sz.cx, sz.cy, m_backColor);
        m_graphImageDc.Detach();
        m_graphImage.Set(sz.cx, sz.cy, INTERNALLY_COLOR);
        m_graphImageDc.Attach(&m_graphImage);
    }
 
    virtual LRESULT WindowProc(UINT message, WPARAM wParam, LPARAM lParam)
    {
        switch ( message )
        {
        case WM_ERASEBKGND:
            return 0;
        case WM_PRINTCLIENT:
            if ( m_isOndemandRemakeViewImage )
            {
                m_isOndemandRemakeViewImage = false;
                m_MakeViewImage();
            }
            m_viewImage.Draw(reinterpret_cast<HDC>(wParam));
            return 0;
        case WM_PAINT:
            if ( m_isOndemandRemakeViewImage )
            {
                m_isOndemandRemakeViewImage = false;
                m_MakeViewImage();
            }
            m_viewImage.Draw(CPaintDC(this));
            return 0;
        case WM_ENABLE:
            return 0;
        case WM_SIZE:
            {
                CSize sz(LOWORD(lParam), HIWORD(lParam));
                if ( sz != m_clientSize )
                {
                    CSize gsz = m_graphImage.GetSize();
                    m_Resize(sz, gsz.cx);
                    OndemandRemakeViewImage();
                }
            }
            break;
        case WM_HSCROLL:
            if ( reinterpret_cast<HWND>(lParam) == m_scrollBar )
            {
                int sbCode = LOWORD(wParam);
                int nPos = HIWORD(wParam);
                switch ( sbCode )
                {
                case SB_THUMBPOSITION: // 絶対位置へスクロール。現在位置はパラメータ nPos で指定されます。
                case SB_THUMBTRACK: // スクロール ボックスを指定位置へドラッグ。現在位置はパラメータ nPos で指定されます。
                    {
                        SCROLLINFO si;
                        if ( m_scrollBar.GetScrollInfo(&si, SIF_TRACKPOS) )
                        {
                            nPos = si.nTrackPos;
                        }
                    }
                    break;
                }
                m_OnScrollBar(sbCode, nPos);
            }
            break;
        case WM_LBUTTONDOWN:
            if ( ::IsWindow(m_scrollBar) )
            {
                m_isMouseButtonPressed = true;
                SetCapture();
                m_pressedPos = CPoint(lParam);
            }
            #ifdef _WIN32_WCE
                return _super::DefWindowProc(message, wParam, lParam);
            #endif
            break;
        case WM_LBUTTONUP:
            if ( m_isMouseButtonPressed )
            {
                m_isMouseButtonPressed = false;
                ReleaseCapture();
            }
            break;
        case WM_MOUSEMOVE:
            if ( m_isMouseButtonPressed )
            {
                if ( GetCapture() != this )
                {
                    m_isMouseButtonPressed = false;
                }
                else
                {
                    CPoint pos(lParam);
                    int d = (pos.x - m_pressedPos.x) / m_horzIndexPixel;
                    if ( d != 0 )
                    {
                        m_OnScrollBar(SB_THUMBPOSITION, m_scrollBar.GetScrollPos() - d);
                        m_pressedPos = pos;
                        Invalidate();
                        UpdateWindow();
                    }
                }
            }
            break;
        }
        return _super::WindowProc(message, wParam, lParam);
    }
 
private:
    struct TTextInfo
    {
        HFONT       hFont;  
        CStr        text;   
        COLORREF    color;  
        //コンストラクタ
        TTextInfo(void) : hFont(NULL)
        {
        }
    };
    struct TLineInfo : CCopyImpossible
    {
        ELineStyle  style;      
        CPen        colorPen;   
        //コンストラクタ
        TLineInfo(void) : style(LineStyle_Non)
        {
        }
        void Set(ELineStyle ls, COLORREF color)
        {
            style = ls;
            if ( colorPen.GetSafeHandle() != NULL )
            {
                colorPen.DeleteObject();
            }
            CPen* pPen = NULL;
            switch ( style )
            {
            case LineStyle_Solid:   // 実線
            case LineStyle_EdgeDot: // 両端のみ
                pPen = new CPen(PS_SOLID, 1, color);
                break;
            case LineStyle_Bold:    // 太線
                pPen = new CPen(PS_SOLID, 3, color);
                break;
            case LineStyle_Dot: // 破線
                pPen = new CPen(PS_DOT, 1, color);
                break;
            }
            if ( pPen != NULL )
            {
                colorPen.Attach(pPen->Detach());
                delete pPen;
            }
        }
    };
    struct TScaleLineInfo : TLineInfo
    {
        double          step;   
        void Set(ELineStyle ls, COLORREF color, double sp)
        {
            step = sp;
            TLineInfo::Set(ls, color);
        }
    };
    class CMyScrollBar : public CScrollBar
    {
        DEFSUPER(CScrollBar);
    protected:
        virtual LRESULT WindowProc(UINT message, WPARAM wParam, LPARAM lParam)
        {
            if ( message == WM_LBUTTONDOWN )
            {
                return _super::DefWindowProc(message, wParam, lParam);
            }
            return _super::WindowProc(message, wParam, lParam);
        }
    };
 
    int m_CalcDrawY(double y) const
    {   
        double yy = (m_viewTopValue - y);
        yy *= (m_clientSize.cy - 1);
        yy /= m_viewHeight;
        return down_cast<int>(yy);
    }
 
    void m_OnScrollBar(int sbCode, int nPos)
    {
        INT_PTR np = GetViewHorizontalPos();
        INT_PTR maxPos = m_scrollBar.GetScrollLimit();
        INT_PTR p = m_scrollBar.GetScrollPos();
        switch ( sbCode )
        {
        case SB_LEFT: // 左端へスクロール。
            p = 0;
            break;
        case SB_ENDSCROLL: // スクロール終了。
            return;
        case SB_LINELEFT: // 左へスクロール。
            p -= m_scrollOneStep;
            break;
        case SB_LINERIGHT: // 右へスクロール。
            p += m_scrollOneStep;
            break;
        case SB_PAGELEFT: // 1 ページ左へスクロール。
            p -= m_clientSize.cx / m_horzIndexPixel;
            break;
        case SB_PAGERIGHT: // 1 ページ右へスクロール。
            p += m_clientSize.cx / m_horzIndexPixel;
            break;
        case SB_RIGHT: // 右端へスクロール。
            p = maxPos;
            break;
        case SB_THUMBPOSITION: // 絶対位置へスクロール。現在位置はパラメータ nPos で指定されます。
        case SB_THUMBTRACK: // スクロール ボックスを指定位置へドラッグ。現在位置はパラメータ nPos で指定されます。
            p = nPos;
            break;
        default:
            ASSERT( false );
            break;
        }
        m_scrollBar.SetScrollPos(ToInt(p));
        p = m_scrollBar.GetScrollPos();
        if ( m_isReverseIndexMode )
        {
            p = m_scrollBar.GetScrollLimit() - p;
        }
        if ( np != p )
        {
            SetViewHorizontalPos(p);
            CWnd* pParent = GetParent();
            if ( pParent != NULL )
            {
                pParent->SendMessage(WM_HSCROLL, MAKELONG(SB_THUMBPOSITION, p), reinterpret_cast<LPARAM>(GetSafeHwnd()));
            }
        }
    }
    void m_Resize(const SIZE& sz, size_t graphWidth)
    {
        if ( sz.cx < 0 || sz.cx > 0x7FFF || sz.cy < 0 || sz.cy > 0x7FFF )
        {
            return;
        }
        m_clientSize = sz;
        //== スクロールバーを消す
        if ( ::IsWindow(m_scrollBar) )
        {
            m_scrollBar.DestroyWindow();
        }
        if ( ToInt(graphWidth) > m_clientSize.cx )
        {
            //== スクロールバー用意
            DWORD style = SBS_HORZ | WS_CHILD;
            if ( m_isScrollBarUsed )
            {
                m_clientSize.cy -= ToInt(m_scrollBarHeight);
                style |= WS_VISIBLE;
            }
            m_scrollBar.Create(style, CRect(0, m_clientSize.cy, m_clientSize.cx, ToInt(m_clientSize.cy + m_scrollBarHeight)), this, 1000);
            SCROLLINFO si;
            m_scrollBar.GetScrollInfo(&si);
            si.nPage = m_clientSize.cx / m_horzIndexPixel;
            si.nMin = 0;
            si.nMax = ToInt(graphWidth / m_horzIndexPixel);
            if ( m_isReverseIndexMode )
            {
                si.nPos = si.nMax;
            }
            m_scrollBar.SetScrollInfo(&si);
        }
        m_viewImage.Set(sz.cx, sz.cy, m_backColor);
        m_graphImageDc.Detach();
        if ( sz.cx > 0 && sz.cy > 0 && m_clientSize.cy > 0 )
        {
            VERIFY( m_graphImage.Set(ToInt(graphWidth), m_clientSize.cy, INTERNALLY_COLOR) );
            m_graphImageDc.Attach(&m_graphImage);
        }
        m_pointMap.RemoveAll();
    }
    void m_Resize(void)
    {
        const CSize& gsz = m_graphImage.GetSize();
        CRect rc;
        GetClientRect(&rc);
        m_Resize(rc.Size(), gsz.cx);
    }
    void m_SetMaker(CDC& dc, int xx, double y, COLORREF color, bool withContinuousLine)
    {
        if ( ! IS_RGBVALUE(color) )
        {
            return;
        }
        if ( ! ::_finite(y) )
        {
            return;
        }
        int yy = m_CalcDrawY(y);
        bool hasColorKey = m_pointMap.HasKey(color);
        //== ブラシ、ペン、作成
        if ( ! hasColorKey )
        {
            m_pointMap[color] = new TPointInfo(color);
        }
        TPointInfo* P = m_pointMap[color];
        ASSERT( P != NULL );
        CPen* pOldPen = dc.SelectObject(&P->pen);
        {
            //== 連続線描画
            if ( withContinuousLine && hasColorKey )
            {
                dc.MoveTo(P->point);
                dc.LineTo(xx, yy);
            }
            //== マーカー描画
            if ( m_markerWidth <= 1 )
            {
                dc.SetPixel(xx, yy, color);
            }
            else if ( m_markerWidth <= 3 )
            {
                int mw = ToInt(m_markerWidth);
                int d1 = mw / 2;
                dc.FillSolidRect(xx - d1, yy - d1, mw, mw, color);
            }
            else
            {
                CBrush* pOldBrush = dc.SelectObject(&P->brush);
                int d1 = ToInt(m_markerWidth / 2);
                int d2 = ToInt(m_markerWidth - d1);
                dc.Ellipse(xx - d1, yy - d1, xx + d2, yy + d2);
                dc.SelectObject(pOldBrush);
            }
        }
        dc.SelectObject(pOldPen);
        //== 記憶
        P->point.x = xx;
        P->point.y = yy;
    }
    DWORD m_ToDtStyle(INDEX idx) const
    {
        DWORD r = 0;
        switch ( idx )
        {
        case 1: r = DT_LEFT     | DT_BOTTOM;    break;
        case 2: r = DT_CENTER   | DT_BOTTOM;    break;
        case 3: r = DT_RIGHT    | DT_BOTTOM;    break;
        case 4: r = DT_LEFT     | DT_VCENTER;   break;
        case 5: r = DT_CENTER   | DT_VCENTER;   break;
        case 6: r = DT_RIGHT    | DT_VCENTER;   break;
        case 7: r = DT_LEFT     | DT_TOP;       break;
        case 8: r = DT_CENTER   | DT_TOP;       break;
        case 9: r = DT_RIGHT    | DT_TOP;       break;
        }
        return r;
    }
    // 再構築
    void m_MakeViewImage(void)
    {
        const SIZE& sz = m_clientSize;
        CBitmapDC dc(&m_viewImage);
        dc.FillSolidRect(0, 0, sz.cx, sz.cy, m_backColor);
        //== Scale描画
        m_DrawScaleLine(dc, m_subScaleLines[2], false);
        m_DrawScaleLine(dc, m_subScaleLines[1], false);
        m_DrawScaleLine(dc, m_subScaleLines[0], false);
        m_DrawScaleLine(dc, m_scaleLine, true);
        //== グラフ描画（重ね合わせ）
        if ( ! m_graphImage.IsEmpty() )
        {
            const SIZE& sz = m_graphImage.GetSize();
            INT_PTR x = -down_cast<INT_PTR>(m_viewHorizontalPos);
            if ( m_isReverseIndexMode )
            {
                x = m_clientSize.cx - sz.cx + m_viewHorizontalPos;
            }
            ::TransparentBlt(dc, ToInt(x), 0, sz.cx, sz.cy, m_graphImageDc, 0, 0, sz.cx, sz.cy, INTERNALLY_COLOR);
        }
        //== 文字描画
        {
            CRect rc(2, 2, sz.cx - 2, sz.cy - 2);
            CWnd* pParent = GetParent();
            CFont* pParentFont = GetFont();
            if ( pParent != NULL )
            {
                pParentFont = pParent->GetFont();
            }
            CFont* pOldFont = dc.SelectObject(GetFont());
            dc.SetBkMode(TRANSPARENT);
            loop ( i, 9 )
            {
                INDEX idx = i + 1;
                const TTextInfo& t = m_testInfo[idx];
                if ( ! t.text.IsEmpty() )
                {
                    if ( t.hFont == NULL  )
                    {
                        dc.SelectObject(pParentFont);
                    }
                    else
                    {
                        ::SelectObject(dc, t.hFont);
                    }
                    CTextDrawer::DrawTextRect(dc, rc, m_ToDtStyle(idx), t.color, t.text);
                }
            }
            dc.SelectObject(pOldFont);
        }
        //==
        OnMadeViewImage(&dc, sz);
        //==
        dc.Detach();
    }
    // 指定スタイル水平線描画
    void m_DrawStyleHorzLine(CDC& dc, bool isEdgeDotMode, int yy)
    {
        dc.MoveTo(0, yy);
        if ( ! isEdgeDotMode )
        {
            // 線
            dc.LineTo(m_clientSize.cx, yy);
        }
        else
        {
            // 両端のみ
            dc.LineTo(4, yy);
            dc.MoveTo(m_clientSize.cx, yy);
            dc.LineTo(m_clientSize.cx - 4, yy);
        }
    }
    // スケール線描画
    void m_DrawScaleLine(CDC& dc, TScaleLineInfo& sli, bool isMaster)
    {
        if ( sli.colorPen.GetSafeHandle() == NULL )
        {
            return;
        }
        bool isEdgeDotMode = (sli.style == LineStyle_EdgeDot);
        dc.SetBkColor(m_backColor);
        CPen* pOldPen = dc.SelectObject(&sli.colorPen);
        if ( isMaster )
        {
            m_DrawStyleHorzLine(dc, isEdgeDotMode, m_CalcDrawY(0));
        }
        else
        {
            double ss = sli.step;
            double hh = max(::fabs(m_viewTopValue), ::fabs(m_viewbottomValue));
            while ( ss <= hh )
            {
                m_DrawStyleHorzLine(dc, isEdgeDotMode, m_CalcDrawY(ss));
                m_DrawStyleHorzLine(dc, isEdgeDotMode, m_CalcDrawY(-ss));
                ss += sli.step;
            }
        }
        dc.SelectObject(pOldPen);
    }
    // ポイント管理型
    struct TPointInfo
    {
        CPoint  point;
        CBrush  brush;
        CPen    pen;
        TPointInfo(COLORREF c) : brush(c), pen(PS_SOLID, 1, c)
        {
        }
    };
    // ポイント管理マップクラス
    typedef CMapT<COLORREF, CPointerHandleT<TPointInfo> >  CMyPointMap;
 
    bool                m_isScrollBarUsed;          
    CMyScrollBar        m_scrollBar;                
    size_t              m_scrollBarHeight;          
    size_t              m_scrollOneStep;            
    TTextInfo           m_testInfo[10];             
    CMyPointMap         m_pointMap;                 
    TScaleLineInfo      m_scaleLine;                
    TScaleLineInfo      m_subScaleLines[3];         
    COLORREF            m_backColor;                
    size_t              m_markerWidth;              
    double              m_viewTopValue;             
    double              m_viewbottomValue;          
    double              m_viewHeight;               
    bool                m_isReverseIndexMode;       
    CSize               m_clientSize;               
    CBitmapDC           m_graphImageDc;             
    CBitmapImage        m_graphImage;               
    CBitmapImage        m_viewImage;                
    bool                m_isGraphImageDcLeading;    
    INDEX               m_viewHorizontalPos;        
    bool                m_isOndemandRemakeViewImage;
    int                 m_horzIndexPixel;           
    bool                m_isMouseButtonPressed;     
    CPoint              m_pressedPos;               
};
 
 
 
};//MFC
};//TNB