TnbMfcEditHexData.h

[詳解]

#pragma once
#include "TnbMfcCommon.h"
#include "TnbClipboard.h"
#include "TnbBitmapImage.h"
#include "TnbMfcBitmapDC.h"
#include "TnbStrOperator.h"
#include "TnbDummyCollection.h"
#include "TnbSelectedBeltDrawer.h"
#include "TnbFontHandle.h"
#include "TnbDcSelectAssistant.h"
#include <imm.h>
#ifndef _WIN32_WCE
 #pragma comment(lib,"imm32.lib")
#endif
 
 
 
//TNB Library
namespace TNB {
namespace MFC {
 
 
 
template<int WIDTH = -1>
class CEditHexDataT : public CWnd
{
    DEFSUPER(CWnd);
public: 
 
    CEditHexDataT(void) : m_maxLength(-1), m_isInsertMode(false), m_isEnableNotify(false)
        , m_selectCaretIndex(-1), m_isCaletVisidle(false), m_isShowCaretAlways(false)
    {
        ASSERT( WIDTH != 0 );
        m_margin.x = 3;
        m_margin.y = 2;
        m_textColor = ::GetSysColor(COLOR_WINDOWTEXT);
        m_backColor = ::GetSysColor(COLOR_WINDOW);
        m_activeHighlightColor = ::GetSysColor(COLOR_HIGHLIGHT);
        m_inactiveHighlightColor = ::GetSysColor(COLOR_BTNSHADOW);
        m_hasCaret = false;
    }
    
    void SetMargins(const POINT& p)
    {
        m_margin = p;
        m_Redraw();
    }
 
    void SetInsertMode(bool isEnable)
    {
        m_isInsertMode = isEnable;
        m_Redraw();
    }
 
    bool IsInsertMode(void) const
    {
        return m_isInsertMode;
    }
 
    void SetLimitLength(int maxLength = -1, BYTE defaultData = 0)
    {
        m_maxLength = maxLength;
        m_defaultData = defaultData;
        m_SetData(CByteVector());
    }
 
    bool IsMultiLineMode(void) const
    {
        return WIDTH > 0;
    }
 
    const CByteVector& GetData(void) const
    {
        return m_data;
    }
 
    void SetData(const CByteVector& vb)
    {
        m_SetData(vb);
    }
 
    int GetVisibleLineCount(void) const
    {
        if ( IsMultiLineMode() )
        {
            CRect rc;
            _super::GetClientRect(rc);
            return (rc.Height() + m_charSize.cy - 1) / m_charSize.cy;
        }
        return 1;
    }
 
    int GetLineCount(void) const
    {
        if ( IsMultiLineMode() )
        {
            return (m_data.GetSize() + WIDTH - 1) / WIDTH;
        }
        return 1;
    }
 
    int GetFirstVisibleLine(void) const
    {
        if ( IsMultiLineMode() )
        {
            return m_viewPos.y / m_charSize.cy;
        }
        return 0;
    }
 
    void SetFirstVisibleLine(int line)
    {
        if ( IsMultiLineMode() )
        {
            int y = line;
            int l = GetLineCount() - GetVisibleLineCount() + 1;
            if ( y < 0 )
            {
                y = 0;
            }
            else if ( y > l )
            {
                y = l;
            }
            y *= m_charSize.cy;
            if ( y != m_viewPos.y )
            {
                m_viewPos.y = y;
                m_Redraw();
                NotifyToParent(EN_VSCROLL);
            }
        }
    }
 
    void SetSel(int index)
    {
        m_ReleaseSelect();
        m_SetCaretIndex(index);
        m_Redraw();
    }
 
    void SetSel(int startIndex, int endIndex)
    {
        if ( startIndex == endIndex )
        {
            m_ReleaseSelect();
            m_SetCaretIndex(startIndex);
            m_Redraw();
            return;
        }
        if ( endIndex < 0 )
        {
            endIndex = m_GetIndexMax();
        }
        m_ReleaseSelect();
        m_SetCaretIndex(startIndex, false, true);
        ASSERT( m_caretDrawPos.x >= 0 );
        m_SetSelect(m_caretIndex, m_caretDrawPos);
        m_SetCaretIndex(endIndex);
        m_Redraw();
    }
 
    void GetSel(int& _startIndex, int& _endIndex) const
    {
        if ( m_selectCaretIndex < 0 )
        {
            // 未選択状態
            _startIndex = m_caretIndex;
            _endIndex = m_caretIndex;
        }
        else
        {
            // 選択状態
            _startIndex = m_selectCaretIndex;
            _endIndex = m_caretIndex;
        }
    }
 
    void ReplaceSel(LPCTSTR lpszText)
    {
        CString s = lpszText;
        if ( ! s.IsEmpty() )
        {
            bool nowInsertMode = m_isInsertMode;
            if ( m_selectCaretIndex >= 0 )
            {
                m_isInsertMode = true;
            }
            m_isEnableNotify = false;
            _super::SetRedraw(false);
            s.MakeUpper(); // 大文字化
            loop ( i, s.GetLength() )
            {
                m_Input(s.GetAt(i), false);
            }
            _super::SetRedraw(true);
            m_isEnableNotify = true;
            m_isInsertMode = nowInsertMode;
            NotifyToParent(EN_SELCHANGE);
            NotifyToParent(EN_CHANGE);
        }
        else
        {
            m_DeleteSelectedData();
            m_ReleaseSelect();
        }
        m_Redraw();
    }
 
    void ReplaceSel(const CByteVector& vb)
    {
        ReplaceSel(CStrOperator::BinaryToHexString(vb));
    }
 
    bool AddToolTip(void)
    {
        if ( ::IsWindow(GetSafeHwnd()) )
        {
            m_toolTip.Create(this, TTS_ALWAYSTIP);
            m_toolTip.AddTool(this, _T(""));
            m_toolTip.Activate(TRUE);
            return true;
        }
        return false;
    }
 
    void ShowCaretAlways(void)
    {
        m_isShowCaretAlways = true;
    }
 
    COLORREF SetTextColor(COLORREF color)
    {
        COLORREF r = m_textColor;
        m_textColor = color;
        m_Redraw();
        return r;
    }
 
    COLORREF SetBkColor(COLORREF color)
    {
        COLORREF r = m_backColor;
        m_backColor = color;
        m_Redraw();
        return r;
    }
 
    void SetHighlightColor(COLORREF activeColor, COLORREF inactiveColor)
    {
        m_activeHighlightColor = activeColor;
        m_inactiveHighlightColor = inactiveColor;
    }
 
    static bool MakeContextMenu(CMenu& _menu, bool canCopy, int topMenuId)
    {
        if ( _menu.GetSafeHmenu() != NULL )
        {
            _menu.DestroyMenu();
        }
        BOOL r = TRUE;
        r &= _menu.CreatePopupMenu();
        CClipboard clipb;
        bool canPaste = clipb.IsAvailable();
        r &= _menu.AppendMenu(MF_STRING | (canCopy ? 0 : MF_GRAYED), topMenuId + 0, _T("切り取り(&T)"));
        r &= _menu.AppendMenu(MF_STRING | (canCopy ? 0 : MF_GRAYED), topMenuId + 1, _T("コピー(&C)"));
        r &= _menu.AppendMenu(MF_STRING | (canPaste ? 0 : MF_GRAYED), topMenuId + 2, _T("貼り付け(&P)"));
        return !! r;
    }
 
protected:
 
    virtual void PreSubclassWindow(void)
    {
        m_hasCaret = false;
        ::ImmAssociateContext(_super::GetSafeHwnd(), NULL); // IME入力禁止
        ::SetClassLong(_super::GetSafeHwnd(), GCL_HCURSOR, reinterpret_cast<LONG>(::LoadCursor(NULL, IDC_IBEAM)));
        m_font.Set(_super::GetSafeHwnd());
        m_SetData(CByteVector());
        _super::PreSubclassWindow();
        m_isEnableNotify = true;
        m_CheckCharSize();
    }
        
    virtual BOOL PreTranslateMessage(MSG* pMsg)
    {
        if ( ::IsWindow(m_toolTip) )
        {
            m_toolTip.RelayEvent(pMsg);
        }
        return _super::PreTranslateMessage(pMsg);
    }
 
    virtual LRESULT WindowProc(UINT message, WPARAM wParam, LPARAM lParam)
    {
        switch ( message )
        {
        case WM_DESTROY:
            m_toolTip.DestroyWindow();
            m_isEnableNotify = false;
            break;
        case WM_SETFONT:
            {
                HFONT hFont = reinterpret_cast<HFONT>(wParam);
                if ( hFont != NULL )
                {
                    m_font.SetClone(hFont);
                    m_CheckCharSize();
                    if ( LOWORD(lParam) != 0 )
                    {
                        m_Redraw();
                    }
                }
            }
            break;
        case WM_PAINT:
            m_DrawClient(CPaintDC(this));
            return 0;
            break;
        case WM_SETTEXT:
            m_OnSetText(reinterpret_cast<LPCTSTR>(lParam));
            return 1;
            break;
        case WM_GETTEXTLENGTH:
            if ( m_dataString.GetLength() > 0 )
            {
                return (m_dataString.GetLength() - 1) * sizeof(TCHAR);
            }
            return 0;
            break;
        case WM_GETTEXT:
            if ( wParam > 0 && m_dataString.GetLength() > 0 )
            {
                LPTSTR pDst = reinterpret_cast<TCHAR*>(lParam);
                LPCTSTR pSrc = m_dataString;
                size_t n = m_dataString.GetLength() - 1; //最後はSPだから
                size_t m = min(wParam, n);
                loop ( i, m )
                {
                    *pDst++ = *pSrc++;
                }
                *pDst = 0;
                return m * sizeof(TCHAR);
            }
            return 0;
            break;
        case WM_SETFOCUS:
            m_Redraw();
            NotifyToParent(EN_SETFOCUS);
            return 0;
            break;
        case WM_KILLFOCUS:
            m_HideCaret();
            m_Redraw();
            NotifyToParent(EN_KILLFOCUS);
            return 0;
            break;
        case WM_KEYDOWN:
            return m_OnChar(wParam, lParam);
        case WM_KEYUP:
        case WM_CHAR:
            return 0;
        case WM_RBUTTONDOWN:
        case WM_RBUTTONUP:
            _super::SetFocus();
            break;
        case WM_LBUTTONDOWN:
        case WM_LBUTTONUP:
        case WM_MOUSEMOVE:
            return m_OnMouse(message, wParam, lParam);
            break;
        case WM_MOUSEWHEEL:
            {
                short d = HIWORD(wParam);
                SetFirstVisibleLine(GetFirstVisibleLine() - (d / 120));
            }
            break;
        case WM_ERASEBKGND:
            if ( IsMultiLineMode() )
            {
                return 0;
            }
            if ( IsWindowEnabled() )
            {
                HDC hdc = reinterpret_cast<HDC>(wParam);
                CRect rect;
                GetClientRect(rect);
                CBrush b(m_backColor);
                ::FillRect(hdc, &rect, b);
                return 0;
            }
            break;
        case WM_ENABLE:
            {
                CWnd* pParent = GetParent();
                if ( pParent != NULL )
                {
                    CRect rect;
                    GetClientRect(rect);
                    ClientToScreen(rect);
                    pParent->ScreenToClient(rect);
                    pParent->InvalidateRect(rect, TRUE);
                }
                Invalidate(TRUE);
            }
            return 0;
            break;
        case WM_GETDLGCODE:
            return DLGC_WANTCHARS | DLGC_WANTARROWS;
            break;
        case WM_COPY:
        case WM_CUT:
            if ( m_selectCaretIndex >= 0 && m_caretIndex != m_selectCaretIndex )
            {
                CClipboard clipb;
                int x1 = m_GetCaretIndex() / 2;
                int x2 = m_selectCaretIndex / 2;
                CStr s = CStrOperator::BinaryToHexString(m_data.Mid(min(x1, x2), ::abs(x1 - x2)));
                clipb.SetString(s);
                if ( message == WM_CUT )
                {
                    m_DeleteSelectedData();
                    m_ReleaseSelect();
                    m_Redraw();
                }
                return 1;
            }
            return 0;
            break;
        case WM_PASTE:
            ReplaceSel(CClipboard().GetString());
            return 1;
            break;
        case WM_CONTEXTMENU:
            {
                CMenu menu;
                bool canCopy = (m_selectCaretIndex >= 0);
                if ( MakeContextMenu(menu, canCopy, 100) )
                {
                    CPoint po(lParam);
                    if ( po.x == -1 && po.y == -1 )
                    {
                        po = _super::GetCaretPos();
                        if ( po.x < 0 )
                        {
                            ::GetCursorPos(&po);
                        }
                        else
                        {
                            _super::ClientToScreen(&po);
                            po.y += m_charSize.cy;
                        }
                    } 
                    TrackPopupMenuEx(menu, 0, po.x, po.y, _super::GetSafeHwnd(), NULL);
                }
                return 0;
            }
            break;
        case WM_COMMAND:
            {
                switch ( LOWORD(wParam) )
                {
                case 100:
                    SendMessage(WM_CUT);
                    break;
                case 101:
                    SendMessage(WM_COPY);
                    break;
                case 102:
                    SendMessage(WM_PASTE);
                    break;
                }
            }
            break;
        default:
            break;
        }
        return _super::WindowProc(message, wParam, lParam);
    }
 
    virtual void NotifyToParent(WORD notifyCode)
    {
        if ( m_isEnableNotify )
        {
            MFCLIB::SendCommandMessage(this, notifyCode);
        }
    }
 
    COLORREF GetTextColor(void) const
    {
        return IsWindowEnabled() ? m_textColor : ::GetSysColor(COLOR_GRAYTEXT);
    }
 
    COLORREF GetBkColor(void) const
    {
        return IsWindowEnabled() ? m_backColor : ::GetSysColor(COLOR_MENU);
    }
 
private:
    // 再表示
    void m_Redraw(void)
    {
        _super::Invalidate();
    }
 
    // 文字の大きさチェック
    void m_CheckCharSize(void)
    {
        CClientDC dc(this);
        HGDIOBJ hOld = ::SelectObject(dc, m_font);
        m_charSize = dc.GetTextExtent(_T("8"));
        ::SelectObject(dc, hOld);
    }
 
    int m_GetIndexMax(void) const
    {
        return m_data.GetSize() * 2;
    }
 
    void m_OnSetText(LPCTSTR lpsz)
    {
        m_SetData(CStrOperator::HexStringToBinary(lpsz));
    }
 
    void m_SetData(const CByteVector& vb)
    {
        m_data = vb;
        if ( m_maxLength > 0 && ToInt(m_data.GetSize()) > m_maxLength )
        {
            m_data.SetSize(m_maxLength);
        }
        m_MakeViewData();
        m_viewPos.x = 0;
        m_viewPos.y = 0;
        m_SetCaretIndex(0);
        m_ReleaseSelect();
        m_Redraw();
        NotifyToParent(EN_SELCHANGE);
        NotifyToParent(EN_CHANGE);
        NotifyToParent(EN_VSCROLL);
        NotifyToParent(EN_HSCROLL);
    }
    
    void m_SetCaretIndex(int p, bool isNotify = true, bool isCalcDrawPos = false)
    {
        if ( p < 0 )
        {
            p = 0;
        }
        int im = m_GetIndexMax();
        if ( p > im )
        {
            p = im;
        }
        bool r = (m_caretIndex != p);
        if ( r )
        {
            m_caretIndex = p;
            m_caretDrawPos.x = -1;
        }
        if ( isCalcDrawPos && m_caretDrawPos.x < 0 )
        {
            CClientDC dc(this);
            HGDIOBJ hOld = ::SelectObject(dc, m_font);
            m_caretDrawPos = m_IndexToClientPoint(dc, m_caretIndex);
            ::SelectObject(dc, hOld);
        }
        if ( r )
        {
            m_isCaletVisidle = true;
            if ( isNotify )
            {
                NotifyToParent(EN_SELCHANGE);
            }
        }
    }
 
    // カレットのインデックス取得
    int m_GetCaretIndex(void) const
    {
        return m_caretIndex;
    }
 
    LRESULT m_OnMouse(UINT message, WPARAM wParam, LPARAM lParam)
    {
        bool isCaptrued = (::GetCapture() == _super::GetSafeHwnd());
        if ( message == WM_LBUTTONUP )
        {
            // UP
            if ( isCaptrued )
            {
                ::ReleaseCapture();
                if ( m_selectCaretIndex == m_GetCaretIndex() )
                {
                    m_ReleaseSelect();
                    m_Redraw();
                }
            }
            return 0;
        }
        if ( message == WM_MOUSEMOVE && ! isCaptrued )
        {
            return 0;
        }
        CPoint po(lParam);
        CClientDC dc(this);
        HGDIOBJ hOld = ::SelectObject(dc, m_font);
        int l = m_ClientPointToIndex(dc, po);
        ::SelectObject(dc, hOld);
        if ( message == WM_LBUTTONDOWN )
        {
            bool isShift = (::GetAsyncKeyState(VK_SHIFT) < 0);
            if ( m_selectCaretIndex < 0 )
            {
                if ( isShift )
                {
                    m_SetSelect(m_caretIndex, m_caretDrawPos);
                    ::SetCapture(_super::GetSafeHwnd());
                }
            }
            else
            {
                if ( ! isShift )
                {
                    m_ReleaseSelect();
                }
            }
        }
        m_SetCaretIndex(l, true, true);
        if ( ! isCaptrued )
        {
            CPoint spo = po - m_margin;
            _super::ClientToScreen(&spo);
            if ( ::DragDetect(m_hWnd, spo) )
            {
                // プレス！
                m_SetSelect(m_caretIndex, m_caretDrawPos);
                ::SetCapture(_super::GetSafeHwnd());
            }
        }
        _super::SetFocus();
        m_Redraw();
        return 0;
    }
    
    LRESULT m_OnChar(WPARAM wParam, LPARAM lParam)
    {
        if ( (lParam & _BIT(31)) != 0 )
        {
            //離された時はなにもすることがない。
            return 0;
        }
        bool isShift = (::GetAsyncKeyState(VK_SHIFT) < 0);
        bool isCtrl = (::GetAsyncKeyState(VK_CONTROL) < 0);
        //
        if ( isShift && wParam == VK_INSERT )
        {
            isShift = false;
            isCtrl = true;
            wParam = 'V';
        }
        if ( isCtrl )
        {
            switch ( wParam )
            {
            case 'A':
                SetSel(0, -1);
                break;
            case 'C':
                SendMessage(WM_COPY);
                break;
            case 'X':
                SendMessage(WM_CUT);
                break;
            case 'V':
                SendMessage(WM_PASTE);
                break;
            default:
                break;
            }
            return 0;
        }
        m_Input(wParam, isShift);
        return 0;
    }
 
    void m_Input(WPARAM ch, bool isShift)
    {
        bool isWork = true;
        bool isSendChange = false;
        int nowPosition = m_GetCaretIndex();
        POINT nowDrawPos = m_caretDrawPos;
        //
        if ( ! IsMultiLineMode() )
        {
            // SingleLine
            switch( ch )
            {
            case VK_UP:
            case VK_PRIOR:
                ch = VK_HOME;
                break;
            case VK_DOWN:
            case VK_NEXT:
                ch = VK_END;
                break;
            }
        }
        //
        switch ( ch )
        {
        case VK_INSERT:
            m_isInsertMode = ! m_isInsertMode;
            NotifyToParent(EN_SELCHANGE);
            isWork = false;
            if ( m_hasCaret )
            {
                POINT p = _super::GetCaretPos();
                if ( m_isInsertMode )
                {
                    _super::CreateSolidCaret(2, m_charSize.cy);
                }
                else
                {
                    _super::CreateSolidCaret(m_charSize.cx, m_charSize.cy);
                }
                _super::ShowCaret();
                _super::SetCaretPos(p);
            }
            break;
        case VK_DELETE:
            if ( ! m_DeleteSelectedData() )
            {
                int x = m_GetCaretIndex() / 2;
                m_SetCaretIndex(x * 2);
                m_data.Remove(x);
                m_MakeViewData();
                isSendChange = true;
            }
            else
            {
                m_ReleaseSelect();
            }
            isShift = false;
            break;
        case VK_BACK:
            if ( ! m_DeleteSelectedData() )
            {
                if ( m_GetCaretIndex() == 0 )
                {
                    break;
                }
                int x = (m_GetCaretIndex() - 1) / 2;
                m_SetCaretIndex(x * 2);
                m_data.Remove(x);
                m_MakeViewData();
                isSendChange = true;
            }
            else
            {
                m_ReleaseSelect();
            }
            isShift = false;
            break;
        case VK_HOME:
            m_SetCaretIndex(0);
            break;
        case VK_END:
            m_SetCaretIndex(m_GetIndexMax());
            break;
        case VK_PRIOR:
        case VK_NEXT:
            {
                int s = ((nowPosition & 1) == 0) ? 0 : 1;
                int w = WIDTH * 2 * (GetVisibleLineCount() - 1);
                if  ( ch == VK_PRIOR )
                {
                    w = -w;
                }
                int n = nowPosition + w + s;
                m_SetCaretIndex(n);
            }
            break;
        case VK_UP:
            {
                int s = ((nowPosition & 1) == 0) ? 0 : 1;
                int n = nowPosition - WIDTH * 2 - s;
                if ( n >= 0 )
                {
                    m_SetCaretIndex(n);
                }
            }
            break;
        case VK_DOWN:
            {
                int s = ((nowPosition & 1) == 0) ? 0 : 1;
                int n = nowPosition + WIDTH * 2 + s;
                if ( n < m_GetIndexMax() )
                {
                    m_SetCaretIndex(n);
                }
            }
            break;
        case VK_RIGHT:
            if ( ! isShift && m_selectCaretIndex >= 0 )
            {
                // 選択状態
                if ( m_selectCaretIndex < nowPosition )
                {
                    break;
                }
            }
            if ( m_GetIndexMax() > nowPosition )
            {
                int s = ((nowPosition & 1) == 0) ? 2 : 1;
                m_SetCaretIndex(nowPosition + s);
            }
            break;
        case VK_LEFT:
            if ( ! isShift && m_selectCaretIndex >= 0 )
            {
                // 選択状態
                if ( m_selectCaretIndex > nowPosition )
                {
                    break;
                }
            }
            if ( nowPosition > 0 )
            {
                int s = ((nowPosition & 1) == 0) ? 2 : 1;
                m_SetCaretIndex(nowPosition - s);
            }
            break;
        default:
            if ( isShift )
            {
                isWork = false;
            }
            else
            {
                int c = -1;
                if ( ch >= VK_NUMPAD0 && ch <= VK_NUMPAD9 )
                {
                    c = ch - VK_NUMPAD0;
                }
                else
                {
                    c = STRLIB::HexCharToInt(ch);
                }
                if ( c < 0 )
                {
                    isWork = false;
                }
                else
                {
                    bool isDeleted = m_DeleteSelectedData();
                    bool isLead = ((m_GetCaretIndex() & 1) == 0);
                    INDEX x = m_GetCaretIndex() / 2;
                    if ( m_data.GetSize() <= x )
                    {
                        //末にある
                        if ( m_maxLength > 0 && m_maxLength <= ToInt(m_data.GetSize()) )
                        {
                            break;
                        }
                        else
                        {
                            x = m_data.GetSize();
                            m_data.SetSize(x + 1);
                            m_data[x] = static_cast<BYTE>(c << 4);
                            m_MakeViewData();
                            isSendChange = true;
                        }
                    }
                    else if ( isLead )
                    {
                        if ( m_isInsertMode || isDeleted )
                        {
                            if ( IsMultiLineMode() && m_maxLength > 0 )
                            {
                                // マルチライン＆リミット
                                m_data.Insert(x, static_cast<BYTE>(c << 4));
                                m_MakeViewData();
                                isSendChange = true;
                            }
                            else 
                            {
                                if ( m_maxLength > 0 && m_maxLength <= ToInt(m_data.GetSize()) )
                                {
                                    break;
                                }
                                else
                                {
                                    m_data.Insert(x, static_cast<BYTE>(c << 4));
                                    m_MakeViewData();
                                    isSendChange = true;
                                }
                            }
                        }
                        else
                        {
                            m_data[x] &= 0x0F;
                            m_data[x] |= static_cast<BYTE>(c << 4);
                            m_MakeViewData();
                            isSendChange = true;
                        }
                    }
                    else
                    {
                        m_data[x] &= 0xF0;
                        m_data[x] |= static_cast<BYTE>(c);
                        m_MakeViewData();
                        isSendChange = true;
                    }
                    m_SetCaretIndex(m_GetCaretIndex() + 1);
                }
            }
            break;
        }
        if ( isWork )
        {
            if ( isShift && m_selectCaretIndex < 0 )
            {
                m_SetSelect(nowPosition, nowDrawPos);
            }
            if ( ! isShift && m_selectCaretIndex >= 0 )
            {
                m_ReleaseSelect();
            }
            m_Redraw();
        }
        if ( isSendChange )
        {
            NotifyToParent(EN_CHANGE);
        }
    }
 
    int m_ClientPointToIndex(CDC& dc, const POINT& point)
    {
        CPoint po = point;
        po = po - m_margin + m_viewPos;
        if ( po.x < 0 )
        {
            po.x = 0;
        }
        if ( po.y < 0 )
        {
            po.y = 0;
        }
        int w = (po.x) / m_charSize.cx;
        int h = (po.y) / m_charSize.cy;
        if ( IsMultiLineMode() )
        {
            //== Multi Line
            w = w / 3 * 2;
            if ( w > WIDTH * 2 )
            {
                w = WIDTH * 2;
            }
            return w + h * (WIDTH * 2);
        }
        //== Single Line
        while ( m_dataString.GetLength() > w )
        {
            if ( po.x < dc.GetTextExtent(m_dataString.Left(w + 1)).cx )
            {
                break;
            }
            w++;
        }
        w = w / 3 * 2;
        if ( w > m_GetIndexMax() )
        {
            w = m_GetIndexMax();
        }
        return w;
    }
 
    CPoint m_IndexToClientPoint(CDC& dc, int index)
    {
        CPoint pos;
        if ( IsMultiLineMode() )
        {
            //== MultiLine
            int x = index % (WIDTH * 2);
            pos.x = (x + (x / 2)) * m_charSize.cx;
            pos.y = (index / (WIDTH * 2)) * m_charSize.cy;
            if ( m_maxLength > 0 )
            {
                //リミット有り
                if ( index == m_GetIndexMax() )
                {
                    pos.x = (WIDTH * 3) * m_charSize.cx;
                    pos.y -= m_charSize.cy;
                }
            }
        }
        else
        {
            //== SingleLine
            int l = index + (index / 2);
            CPoint p = dc.GetTextExtent(m_dataString.Left(l));
            pos.x = p.x;
            pos.y = 0;
        }
        return pos;
    }
 
    bool m_DeleteSelectedData(void)
    {
        if ( m_selectCaretIndex >= 0 && m_caretIndex != m_selectCaretIndex )
        {
            int x1 = m_GetCaretIndex() / 2;
            int x2 = m_selectCaretIndex / 2;
            m_data.RemoveElements(min(x1, x2), ::abs(x1 - x2));
            m_MakeViewData();
            if ( m_GetCaretIndex() > m_selectCaretIndex )
            {
                m_SetCaretIndex(m_selectCaretIndex);
            }
            return true;
        }
        return false;
    }
 
    void m_MakeViewData(void)
    {
        if ( IsMultiLineMode() && m_maxLength > 0 )
        {
            // マルチライン＆リミット
            if ( ToInt(m_data.GetSize()) > m_maxLength )
            {
                m_data.SetSize(m_maxLength);
            }
            CDummyCollectionT<BYTE> dc(m_defaultData);
            dc.SetSize(m_maxLength - m_data.GetSize());
            m_data.Append(dc);
            ASSERT( ToInt(m_data.GetSize()) == m_maxLength );
        }
        //
        TCHAR* P = m_dataString.GetBuffer(m_data.GetSize() * 3 + 1);
        loop ( i, m_data )
        {
            BYTE b = m_data[i];
            *P++ = STRLIB::IntToHexChar(b >> 4);
            *P++ = STRLIB::IntToHexChar(b & 0x0F);
            *P++ = ' ';
        }
        *P = '\0';
        m_dataString.ReleaseBuffer();
        if ( ::IsWindow(m_toolTip) )
        {
            m_toolTip.UpdateTipText(CStr::Fmt(_T("has %d byte(s)."), m_data.GetSize()), this);
        }
//      NotifyToParent(EN_CHANGE);
    }
 
    void m_DrawClient(CDC& dc)
    {
        CPoint nowPos = m_viewPos;
        CRect rc;
        GetClientRect(rc);
        HGDIOBJ hOld = ::SelectObject(dc, m_font);
        dc.IntersectClipRect(rc);
        if ( m_caretDrawPos.x < 0 )
        {
            m_caretDrawPos = m_IndexToClientPoint(dc, m_caretIndex);
        }
        dc.SetBkMode(TRANSPARENT);
        if ( IsMultiLineMode() )
        {
            m_DrawMultiLineMode(dc, rc);
        }
        else
        {
            m_DrawSingleLineMode(dc, rc);
        }
        ::SelectObject(dc, hOld);
        //
        if ( m_HasFocus() )
        {
            CPoint p = m_caretDrawPos - m_viewPos;
            if ( rc.PtInRect(p) && rc.PtInRect(p + m_charSize) )
            {
                p.x--;
            }
            else
            {
                p.x = 60000;
            }
            _super::SetCaretPos(p + m_margin);
            if ( ! m_hasCaret )
            {
                m_hasCaret = true;
                if ( m_isInsertMode )
                {
                    _super::CreateSolidCaret(2, m_charSize.cy);
                }
                else
                {
                    _super::CreateSolidCaret(m_charSize.cx, m_charSize.cy);
                }
                _super::ShowCaret();
                _super::SetCaretPos(p + m_margin);
            }
        }
        if ( nowPos.x != m_viewPos.x )
        {
            NotifyToParent(EN_HSCROLL);
        }
        if ( nowPos.y != m_viewPos.y )
        {
            NotifyToParent(EN_VSCROLL);
        }
    }
 
    void m_DrawMultiLineMode(CDC& targetDC, const CRect& clientRect)
    {
        CRect rc = clientRect;
        rc.left += m_margin.x;
        rc.top += m_margin.y;
        //== 表示位置補正
        if ( m_isCaletVisidle )
        {
            m_isCaletVisidle = false;
            CPoint p = m_IndexToClientPoint(targetDC, m_caretIndex);
            if ( rc.Width() - m_charSize.cx < p.x - m_viewPos.x )
            {
                m_viewPos.x = p.x - (rc.Width() - m_charSize.cx);
            }
            if ( p.x < m_viewPos.x )
            {
                m_viewPos.x = p.x;
            }
            int hh = rc.Height() / m_charSize.cy * m_charSize.cy;
            if ( hh - m_charSize.cy < p.y - m_viewPos.y )
            {
                m_viewPos.y = p.y - (hh - m_charSize.cy);
            }
            if ( p.y < m_viewPos.y )
            {
                m_viewPos.y = p.y;
            }
        }
        CBitmapImage bi;
        bi.Set(clientRect.Width(), clientRect.Height(), GetBkColor());
        //== 裏画面で画像作成
        {
            CBitmapDC dc(&bi);
            CDcSelectAssistant dca(dc);
            dc.SetWindowOrg(m_viewPos);
            dca.SelectFont(m_font);
            dca.SetTextColor(GetTextColor());
            dca.SetBkColor(GetBkColor());
            //== 文字表示
            rc.right += m_viewPos.x;
            rc.bottom = rc.top + m_charSize.cy;
            int d = WIDTH * 3;
            loop ( i, m_dataString.GetLength() / d + 1 )
            {
                if ( dc.RectVisible(rc) )
                {
                    CString ss = m_dataString.Mid(i * d, d);
                    dc.DrawText(ss, rc, DT_LEFT);
                }
                rc.top += m_charSize.cy;
                rc.bottom += m_charSize.cy;
            }
            //== 選択表示
            bool hasFocus = m_HasFocus();
            if ( m_selectCaretIndex >= 0 && m_selectCaretIndex != m_caretIndex )
            {
                POINT p1 = m_selectCaretDrawPos;
                POINT p2 = m_caretDrawPos;
                if ( p1.y == p2.y )
                {
                    if ( p1.x > p2.x )
                    {
                        Swap(p1.x, p2.x);
                    }
                    CRect rc(p1.x, p1.y, p2.x - m_charSize.cx, p1.y + m_charSize.cy);
                    m_DrawSelectMark(dc, rc + m_margin, hasFocus);
                }
                else
                {
                    if ( p1.y > p2.y )
                    {
                        Swap(p1, p2);
                    }
                    loop ( i, (p2.y - p1.y) / m_charSize.cy - 1 )
                    {
                        CPoint ps(0, p1.y + (i + 1) * m_charSize.cy);
                        CSize sz(m_charSize.cx * (WIDTH * 3 - 1), m_charSize.cy);
                        m_DrawSelectMark(dc, CRect(ps, sz) + m_margin, hasFocus);
                    }
                    CRect rc1(p1.x, p1.y, m_charSize.cx * (WIDTH * 3 - 1), p1.y + m_charSize.cy);
                    m_DrawSelectMark(dc, rc1 + m_margin, hasFocus);
                    CRect rc2(0, p2.y, p2.x - m_charSize.cx, p2.y + m_charSize.cy);
                    m_DrawSelectMark(dc, rc2 + m_margin, hasFocus);
                }
            }
            else if ( m_isShowCaretAlways && ! hasFocus )
            {
                CRect rc(m_caretDrawPos, m_charSize);
                if ( m_isInsertMode )
                {
                    rc.right = rc.left + 1;
                }
                rc.left--;
                rc += m_margin;
                m_DrawSelectMark(dc, rc, false);
            }
        }
        bi.Draw(targetDC, 0, 0);
    }
 
    void m_DrawSingleLineMode(CDC& dc, const CRect& clientRect)
    {
        CRect rc = clientRect;
        rc.left += m_margin.x;
        rc.top += m_margin.y;
        //== 表示位置補正
        if ( m_isCaletVisidle )
        {
            m_isCaletVisidle = false;
            CPoint p = m_IndexToClientPoint(dc, m_caretIndex);
            if ( rc.Width() - m_charSize.cx < p.x - m_viewPos.x )
            {
                m_viewPos.x = (p.x - (rc.Width() - m_charSize.cx));
            }
            if ( p.x < m_viewPos.x )
            {
                m_viewPos.x = p.x;
            }
            m_viewPos.y = 0;
        }
        dc.SetWindowOrg(m_viewPos);
        //== 文字表示
        rc.right += m_viewPos.x;
        dc.SetTextColor(GetTextColor());
        dc.SetBkColor(GetBkColor());
        dc.DrawText(m_dataString, rc, DT_LEFT);
        //== 選択表示
        if ( m_selectCaretIndex >= 0 && m_selectCaretIndex != m_caretIndex )
        {
            int x1 = m_selectCaretDrawPos.x;
            int x2 = m_caretDrawPos.x;
            if ( x1 > x2 )
            {
                Swap(x1, x2);
            }
            CRect rc(x1, 0, x2 - m_charSize.cx + 2, m_charSize.cy);
            m_DrawSelectMark(dc, rc + m_margin);
        }
        else if ( m_isShowCaretAlways && ! m_HasFocus() )
        {
            CRect rc(m_caretDrawPos, m_charSize);
            if ( m_isInsertMode )
            {
                rc.right = rc.left + 1;
            }
            rc.left--;
            rc += m_margin;
            ::DrawFocusRect(dc, &rc);
        }
    }
    
    void m_DrawSelectMark(CDC& dc, const CRect& rect, bool isActive = true)
    {
        COLORREF color = isActive ? m_activeHighlightColor : m_inactiveHighlightColor;
        CSelectedBeltDrawer d(rect.Size(), color, GetBkColor(), isActive);
        d.Draw(dc, rect.left, rect.top);
    }
 
    void m_SetSelect(int index, const POINT& drawPos)
    {
        m_selectCaretIndex = index;
        m_selectCaretDrawPos = drawPos;
        if ( (index & 1) != 0 )
        {
            // 奇数なら
            m_selectCaretIndex--;
            m_selectCaretDrawPos.x -= m_charSize.cx;
        }
    }
 
    void m_ReleaseSelect(void)
    {
        if ( m_selectCaretIndex >= 0 )
        {
            m_selectCaretIndex = -1;
        }
    }
 
    void m_HideCaret(void)
    {
        m_hasCaret = false;
        _super::HideCaret();
//      ::DestroyCaret();
    }
 
    bool m_HasFocus(void) const
    {
        return (::GetFocus() == _super::GetSafeHwnd());
    }
 
    // 表示関係
    CFontHandle     m_font;                 
    CSize           m_charSize;             
    CPoint          m_margin;               
    CToolTipCtrl    m_toolTip;              
    COLORREF        m_textColor;            
    COLORREF        m_backColor;            
    COLORREF        m_activeHighlightColor; 
    COLORREF        m_inactiveHighlightColor;
    // 状態関係
    bool            m_isInsertMode;         
    int             m_maxLength;            
    bool            m_isEnableNotify;       
    // データ関係
    CByteVector     m_data;                 
    CString         m_dataString;           
    BYTE            m_defaultData;
    // カレット関係
    int             m_caretIndex;           
    CPoint          m_caretDrawPos;         
    int             m_selectCaretIndex;     
    CPoint          m_selectCaretDrawPos;   
    bool            m_isShowCaretAlways;    
    bool            m_hasCaret;             
    // スクロール関係
    bool            m_isCaletVisidle;       
    CPoint          m_viewPos;              
};
 
 
 
class CEditHexData : public CEditHexDataT<>
{
};
 
 
 
class CEditHexData16 : public CEditHexDataT<16>
{
};
 
 
 
}; //MFC
}; //TNB