TnbMfcSubEditListCtrl.h

[詳解]

#pragma once
#include "TnbMfcDrawingListCtrl.h"
 
 
 
//TNB Library
namespace TNB {
namespace MFC {
 
 
 
struct ISelcEditFp
{
    virtual ~ISelcEditFp(void) {}
    virtual void SetStartRect(const RECT& rect, int clientWidth) = 0;
    virtual CEdit* GetEdit(void) = 0;
    virtual void OnEditEnd(void) = 0;
};
 
template<typename TYP>
class CSelcEditFpT : public TYP, public ISelcEditFp
{
    DEFSUPER(TYP);
public:
    CSelcEditFpT(void) : m_rect(0)
    {
    }
    void SetStartRect(const RECT& rect, int clientWidth)
    {
        m_rect = rect;
        m_clientWidth = clientWidth;
    }
    CEdit* GetEdit(void)
    {
        return this;
    }
    virtual void OnEditEnd(void) {}
protected:
    virtual LRESULT WindowProc(UINT message, WPARAM wParam, LPARAM lParam)
    {
        if ( message == WM_WINDOWPOSCHANGING )
        {
            WINDOWPOS* P = reinterpret_cast<WINDOWPOS*>(lParam);
            P->y = m_rect.top;
            P->cy = m_rect.Height();
            if ( (P->flags & (SWP_NOSIZE | SWP_NOMOVE)) == 0 )
            {
                P->x = m_rect.left;
                if ( P->cx < m_rect.Width() )
                {
                    P->cx = m_rect.Width();
                }
                if ( (P->x) + (P->cx) > m_clientWidth )
                {
                    // はみ出る
                    int d = m_clientWidth - (P->cx);
                    if ( d >= 0 )
                    {
                        P->x = d;
                    }
                    else
                    {
                        P->x = 0;
                        P->cx = m_clientWidth;
                    }
                }
            }
        }
        return _super::WindowProc(message, wParam, lParam);
    }
private:
    CRect   m_rect;         
    int     m_clientWidth;
};
 
 
 
class CSubEditListCtrl : public CDrawingListCtrl
{
    DEFSUPER(CDrawingListCtrl);
public:
 
    CSubEditListCtrl(void) : m_currentSubItem(-1), m_pSubclassEdit(NULL), m_isAutoEdit(false), m_editingSubItem(-1)
    {
    }
 
    void SetAutoEditMode(bool isEnable)
    {
        m_isAutoEdit = isEnable;
    }
 
    bool EditSubItemLabel(int iItem, int iSubItem)
    {
        m_currentSubItem = iSubItem;
        return _super::EditLabel(iItem) != NULL;
    }
 
    bool EditLabel(void)
    {
        int iItem = _super::GetSelectedItem();
        int iSubItem = m_currentSubItem;
        if ( iItem >= 0 && iSubItem >=0 )
        {
            return _super::EditLabel(iItem) != NULL;
        }
        return false;
    }
 
    bool IsEditingLabel(void) const
    {
        return m_editingSubItem >= 0;
    }
 
    int GetSelectedItem(void) const
    {
        return _super::GetSelectedItem();
    }
 
    int GetSelectedSubItem(void) const
    {
        return m_currentSubItem;
    }
 
    void SetSelectedItem(int item, int subItem)
    {
        m_currentSubItem = subItem;
        _super::SetSelectedItem(item);
    }
 
    BOOL EnsureVisibleEx(int item, int subItem)
    {
        BOOL r = _super::EnsureVisible(item, FALSE);
        m_ViewSubItem(subItem);
        return r;
    }
 
    void SetDefaultMarkDrawer(COLORREF base = ::GetSysColor(COLOR_WINDOW))
    {
        _super::SetDefaultMarkDrawer(base);
        _super::SetSelectMarkDrawer(
            CMySelectDrawer(this, ::GetSysColor(COLOR_HIGHLIGHT), base, true),
            CMySelectDrawer(this, ::GetSysColor(COLOR_BTNFACE), base, false)
        );
        _super::SetFocusMarkDrawer(CMyFoucsDrawer(this));
        CTextDrawer tx(*GetFont(), RGB(0, 0, 0), _T(""), DT_END_ELLIPSIS);
        _super::SetTextDrawer(tx);
    }
 
    bool SetSelectMarkDrawer(const IDrawable& draw, ESelectMarkType type = OVERLAP)
    {
        return false;
    }
    
    bool SetSelectMarkDrawer(const IDrawable& draw1, const IDrawable& draw2, ESelectMarkType type = OVERLAP)
    {
        return false;
    }
    
    bool SetFocusMarkDrawer(const IDrawable& draw)
    {
        return false;
    }
 
    CEdit* GetEditControl(void) const
    {
        if ( m_pSubclassEdit != NULL )
        {
            return m_pSubclassEdit->GetEdit();
        }
        return NULL;
    }
    
protected:
 
    virtual ISelcEditFp* GetSubItemEditControl(int item, int subItem)
    {
        return &m_myEdit;
    }
 
    virtual LRESULT OnItemPainting(TDrawParam* P)
    {
        m_drawingSubItem = P->subItemNo;
        return _super::OnItemPainting(P);
    }
 
    virtual BOOL OnChildNotify(UINT message, WPARAM wParam, LPARAM lParam, LRESULT* _pResult)
    {
        if ( message == WM_NOTIFY )
        {
            LPNMHDR lpNmHdr = reinterpret_cast<LPNMHDR>(lParam);
            if ( lpNmHdr->hwndFrom == m_hWnd)
            {
                NMLVDISPINFO* lpLv = reinterpret_cast<NMLVDISPINFO*>(lParam);
                if ( lpLv->hdr.code == LVN_BEGINLABELEDIT )
                {
                    LVITEM& item = lpLv->item;
                    if ( m_currentSubItem >= 0 ) 
                    {
                        item.iSubItem = m_currentSubItem;
                        m_editingSubItem = m_currentSubItem;
                        if ( _super::GetItemDrawer(item.iItem, item.iSubItem) != NULL )
                        {
                            // 描画情報がある枠
                            *_pResult = TRUE;
                            return TRUE;
                        }
                        ISelcEditFp* pIEdit = GetSubItemEditControl(item.iItem, item.iSubItem);
                        if ( pIEdit == NULL )
                        {
                            *_pResult = TRUE;
                            return TRUE;
                        }
                        CEdit* pEdit = pIEdit->GetEdit();
                        m_ViewSubItem(m_currentSubItem);
                        CRect rect;
                        _super::GetSubItemRect(item.iItem, m_currentSubItem, LVIR_LABEL, rect);
                        CSize sz(max(rect.Width() + 2, 50), rect.Height() + 3);
                        CRect clRc;
                        GetClientRect(clRc);
                        CPoint pos = rect.TopLeft();
                        pos.x -= 2;
                        pos.y -= 2;
                        if ( pos.x + sz.cx > clRc.right )
                        {
                            pos.x = clRc.right - sz.cx;
                        }
                        if ( pos.x < 0 )
                        {
                            pos.x = 0;
                        }
                        CEdit* pNowEdit = _super::GetEditControl();
                        pNowEdit->SetWindowText(GetItemText(item.iItem, m_currentSubItem));
                        pIEdit->SetStartRect(CRect(pos, sz), clRc.Width());
                        pEdit->SubclassWindow(pNowEdit->m_hWnd);
                        m_pSubclassEdit = pIEdit;
                    }
                    return FALSE;
                }
                else if ( lpLv->hdr.code == LVN_ENDLABELEDIT )
                {
                    if ( m_pSubclassEdit != NULL )
                    {
                        CEdit* pEd = m_pSubclassEdit->GetEdit();
                        LVITEM& item = lpLv->item;
                        if ( m_editingSubItem >= 0 && pEd->GetSafeHwnd() != NULL ) 
                        {
                            item.iSubItem = m_editingSubItem;
                            m_editingSubItem = -1;
                            if ( m_isAutoEdit && (item.mask & LVIF_TEXT) != 0 )
                            {
                                m_pSubclassEdit->OnEditEnd();
                                CString s;
                                pEd->GetWindowText(s);
                                _super::SetItemText(item.iItem, item.iSubItem, s);
                            }
                            pEd->UnsubclassWindow();
                            m_pSubclassEdit = NULL;
                        }
                    }
                    return FALSE;
                }
            }
        } 
        return _super::OnChildNotify(message, wParam, lParam, _pResult);
    }
 
    virtual LRESULT WindowProc(UINT message, WPARAM wParam, LPARAM lParam)
    {
        switch ( message )
        {
        case CMySelectDrawer::WM_SELC_DRAWINGSUBITEM:
            return m_drawingSubItem;
            break;
        case WM_KEYDOWN:
            if ( wParam == VK_F2 )
            {
                if ( m_currentSubItem >= 0 )
                {
                    _super::EditLabel(_super::GetSelectedItem());
                }
            }
            else if ( wParam == VK_RIGHT || wParam == VK_LEFT )
            {
                CWnd* P = _super::GetParent();
                if ( P != NULL )
                {
                    // 親に通知
                    NMLVKEYDOWN nm;
                    nm.hdr.code = LVN_KEYDOWN;
                    nm.hdr.hwndFrom = _super::GetSafeHwnd();
                    nm.hdr.idFrom = _super::GetDlgCtrlID();
                    nm.wVKey = static_cast<WORD>(wParam);
                    nm.flags = 0;
                    P->SendMessage(WM_NOTIFY, nm.hdr.idFrom, reinterpret_cast<LPARAM>(&nm));
                }
                CHeaderCtrl* H = _super::GetHeaderCtrl();
                int m = H->GetItemCount();
                int c = m_currentSubItem;
                if ( wParam == VK_RIGHT )
                {
                    if ( m_currentSubItem < 0 )
                    {
                        m_currentSubItem = 0;
                    }
                    else if ( m_currentSubItem < m - 1 )
                    {
                        m_currentSubItem++;
                    }
                }
                else //if ( wParam == VK_LEFT )
                {
                    if ( m_currentSubItem < 0 )
                    {
                        m_currentSubItem = m - 1;
                    }
                    else if ( m_currentSubItem > 0 )
                    {
                        m_currentSubItem--;
                    }
                }
                if ( c != m_currentSubItem )
                {
                    m_ViewSubItem(m_currentSubItem);
                    CRect rc;
                    _super::GetItemRect(GetSelectedItem(), rc, LVIR_BOUNDS);
                    _super::InvalidateRect(rc, FALSE);
                }
                return 0;
            }
            break;
        case WM_LBUTTONDOWN:
        case WM_RBUTTONDOWN:
            {
                LVHITTESTINFO ht;
                ht.pt = CPoint(lParam);
                if ( _super::SubItemHitTest(&ht) >= 0 )
                {
                    if ( m_currentSubItem != ht.iSubItem )
                    {
                        m_currentSubItem = ht.iSubItem;
                        DWORD ff = (_super::GetStyle() & LVS_EDITLABELS);   //編集スタイル状態取得
                        _super::ModifyStyle(ff, 0); //編集スタイルOFF。
                        LRESULT r = _super::WindowProc(message, wParam, lParam);
                        _super::ModifyStyle(0, ff); //編集スタイル元へ。
                        CRect rc;
                        _super::GetItemRect(ht.iItem, rc, LVIR_BOUNDS);
                        _super::InvalidateRect(rc, FALSE);
                        return r;
                    }
                }
            }
            break;
        }
        return _super::WindowProc(message, wParam, lParam);
    }
 
    virtual void PreSubclassWindow(void)
    {
        _super::PreSubclassWindow();
        _super::ModifyStyle(0, LVS_SINGLESEL);
        _super::SetExtendedStyle(LVS_EX_FULLROWSELECT | _super::GetExtendedStyle());
        _super::SetAdjustWidthMode(false);
        SetDefaultMarkDrawer();
    }
 
private:
    //  @note 使用禁止
    CEdit* EditLabel(int item);
 
    void m_ViewSubItem(int subItem)
    {
        CRect rc;
        //見えている範囲
        GetClientRect(rc);
        int cx1 = rc.Width();
        int x1 = GetScrollPos(SB_HORZ);
        //見せたいアイテムの範囲
        CHeaderCtrl* H = _super::GetHeaderCtrl();
        H->GetItemRect(subItem, rc);
        int cx2 = rc.Width();
        int x2 = rc.left;
        //調整
        int xx = x1;
        if ( (x1 + cx1) < (x2 + cx2) )
        {
            xx = (x2 + cx2) - cx1;
        }
        if ( x1 > x2 )
        {
            xx = x2;
        }
        Scroll(CSize(xx - x1, 0));
    }
    class CMySelectDrawer : public CSelectedBeltDrawer
    {
        DEFSUPER(CSelectedBeltDrawer);
    public:
        enum
        {
            WM_SELC_DRAWINGSUBITEM = WM_APP,
        };
        CMySelectDrawer(CSubEditListCtrl* H, COLORREF beltColor, COLORREF backColor, bool isTextInvert = true)
            : m_pCtrl(H), _super(beltColor, backColor, isTextInvert)
        {
        }
        // [作成] クローン作成.
        virtual IDrawable* Clone(void) const
        {
            CMySelectDrawer* P = new CMySelectDrawer(m_pCtrl, 0, 0, false);
            *P = *this;
            return P;
        }
        // [描画] 描画.
        virtual void Draw(HDC dc, int x = 0, int y = 0) const
        {
            if ( m_pCtrl->SendMessage(WM_SELC_DRAWINGSUBITEM) == m_pCtrl->GetSelectedSubItem() )
            {
                _super::Draw(dc, x , y);
            }
        }
    private:
        CSubEditListCtrl*   m_pCtrl; 
    };
 
    class CMyFoucsDrawer : public CNullDrawer
    {
    public:
        CMyFoucsDrawer(CSubEditListCtrl* H) : m_pCtrl(H)
        {
        }
        // [作成] クローン作成.
        virtual IDrawable* Clone(void) const
        {
            return new CMyFoucsDrawer(m_pCtrl);
        }
        // [描画] 描画.
        virtual void Draw(HDC dc, int x = 0, int y = 0) const
        {
            CHeaderCtrl* H = m_pCtrl->GetHeaderCtrl();
            if ( H != NULL )
            {
                CRect rc;
                H->GetItemRect(m_pCtrl->GetSelectedSubItem(), rc);
                rc.OffsetRect(x, y);
                rc.bottom = rc.top + m_size.cy;
                ::DrawFocusRect(dc, rc);
            }
        }
    private:
        CSubEditListCtrl*   m_pCtrl; 
    };
 
    class CMyEdit : public CSelcEditFpT<CEdit>
    {
    };
 
    CMyEdit         m_myEdit;           
    ISelcEditFp*    m_pSubclassEdit;    
    bool            m_isAutoEdit;       
    int             m_currentSubItem;   
    int             m_drawingSubItem;   
    int             m_editingSubItem;   
};
 
 
 
}; // MFC
}; // TNB