TnbMfcDrag.h

[詳解]

#pragma once
#include "TnbMfcCommon.h"
#include "TnbBitmapImage.h"
#include "TnbDrawable.h"
 
 
 
//TNB Library
namespace TNB {
namespace MFC {
 
 
 
template<typename TYP = CStatic>
class CDragAddinT : public TYP
{
    DEFSUPER(TYP);
public:
 
    enum EDragNotifyCode
    {
        START = 0,      
        HOVER,          
        LEAVE,          
        CANCEL,         
        INVALID,        
        DROP,           
        ISDROP,         
    };
 
    enum EDropCtrlCode
    {
        CANDROP = 100,  
    };
    
    struct TDropParam
    {
        int     dragID; 
        POINT   point;  
        HRGN    hRgn;   
        WORD    ctrlID; 
    };
    
    static UINT GetDragNotifyMessage(void)
    {
        return ::RegisterWindowMessage(_T("TnbMfcDragAddin"));
    }
 
    CDragAddinT(void) 
        : m_targetMarkColor(::GetSysColor(COLOR_HIGHLIGHT)), m_targetMarkThick(2)
        , m_arrowIcon(NULL), m_noIcon(NULL)
        , m_wGroupID(0), m_boCanDragging(true), m_boCanDropping(true)
        , m_boIsDragging(false), m_nowDropItem(-1), m_nowDropItemRgn(NULL)
    {
        m_nMessageCode = GetDragNotifyMessage();
        m_nowDropItemRgn = ::CreateRectRgn(0, 0, 0, 0);
    }
 
    ~CDragAddinT(void)
    {
        _DeleteObject(m_nowDropItemRgn);
    }
 
    void SetDragGroupID(WORD w)
    {
        m_wGroupID = w;
    }
 
    WORD GetDragGroupID(void) const
    {
        return m_wGroupID;
    }
 
    void SetDraggingBitmap(CBitmapHandle bmp)
    {
        m_bmpDragging = bmp;
    }
 
    template<typename T>
    void SetDropTargetMark(const CDragAddinT<T>& other)
    {
        const IDrawable*    draw = NULL;
        COLORREF            color;
        int                 thick;
        other.GetDropTargetMark(draw, color, thick);
        if ( draw != NULL )
        {
            m_targetMarkDrawer = draw->Clone();
        }
        m_targetMarkColor = color;
        m_targetMarkThick = thick;
    }
 
    void SetDropTargetMark(const IDrawable& draw)
    {
        m_targetMarkDrawer = draw.Clone();
    }
 
    void SetDropTargetMark(COLORREF color, int thick = 0)
    {
        m_targetMarkDrawer.Null();
        m_targetMarkColor = color;
        if ( thick > 0 )
        {
            m_targetMarkThick = thick;
        }
    }
 
    void GetDropTargetMark(const IDrawable*& _draw, COLORREF& _color, int& _thick) const
    {
        _draw = m_targetMarkDrawer;
        _color = m_targetMarkColor;
        _thick = m_targetMarkThick;
    }
 
    void SetDragMode(bool can)
    {
        m_boCanDragging = can;
    }
 
    bool CanDragging(void) const
    {
        return m_boCanDragging;
    }
 
    void SetDropMode(bool can)
    {
        m_boCanDropping = can;
    }
 
    bool CanDropping(void) const
    {
        return m_boCanDropping;
    }
 
protected:
 
    bool SendNofityMessage(CWnd* pWnd, WPARAM wParam, LPARAM lParam) const
    {
        return !! ::SendMessage(*pWnd, m_nMessageCode, wParam, lParam);
    }
 
    bool IsNofityMessage(UINT message) const
    {
        return m_nMessageCode == message;
    }
 
    virtual LRESULT WindowProc(UINT message, WPARAM wParam, LPARAM lParam)
    {
        if ( message == m_nMessageCode )
        {
            if ( wParam == static_cast<WPARAM>(MAKELONG(CANDROP, m_wGroupID)) )
            {
                return m_boCanDropping;
            }
        }
        else if ( message == WM_LBUTTONDOWN )
        {
            if ( m_BeginDrag() )
            {
                m_SendCommand(START, 0);
                return 0;
            }
        }
        else if ( message == WM_LBUTTONUP )
        {
            if ( m_EndDrag() )
            {
                if ( m_nowDropItem >= 0 )
                {
                    m_SendCommand(DROP, m_nowDropItem);
                }
                else
                {
                    m_SendCommand(INVALID, 0);
                }
                return 0;
            }
        }
        else if ( message == WM_CAPTURECHANGED || message == WM_RBUTTONDOWN )
        {
            if ( m_EndDrag() )
            {
                m_SendCommand(CANCEL, 0);
            }
        }
        else if ( message == WM_MOUSEMOVE )
        {
            if ( m_boIsDragging )
            {
                m_OnMouseMove();
            }
        }
        else if ( message == WM_DESTROY )
        {
            m_EndDrag();
        }
        return _super::WindowProc(message, wParam, lParam);
    }
 
    virtual int OnBeginDrag(RECT& _rc, const POINT& po)
    {
        if ( ! ::DragDetect(m_hWnd, po) )   //これ以外で対応したい
        {
            return 0;
        }
        return _super::GetDlgCtrlID();
    }   
 
    virtual void OnDragNofity(UINT cmd, int draggingItem, int dropedItem)
    {
    }
 
private:
    //-設定
    IDrawable::Ptr      m_targetMarkDrawer; 
    COLORREF            m_targetMarkColor;  
    int                 m_targetMarkThick;  
    CBitmapHandle       m_bmpDragging;      
    WORD                m_wGroupID;         
    bool                m_boCanDragging;    
    bool                m_boCanDropping;    
    //-動作 Work
    UINT                m_nMessageCode;     
    int                 m_draggingItemID;   
    HICON               m_arrowIcon;        
    HICON               m_noIcon;           
    CImageList          m_imglist;          
    bool                m_boIsDragging;     
    CPoint              m_dragOffset;       
    //-MOVE中
    int                 m_nowDropItem;      
    HRGN                m_nowDropItemRgn;   
    CWnd*               m_nowDropWnd;       
    void m_DrawTargetMark(CDC* pDC, HRGN hRgn)
    {
        if ( m_targetMarkDrawer.IsNull() )
        {
            CBrush br;
            br.CreateSolidBrush(m_targetMarkColor);
            ::FrameRgn(*pDC, m_nowDropItemRgn, br, m_targetMarkThick, m_targetMarkThick);
        }
        else
        {
            CRect rc;
            ::GetRgnBox(hRgn, &rc);
            ::SelectClipRgn(*pDC, hRgn);
            m_targetMarkDrawer->Resize(rc.Size());
            m_targetMarkDrawer->Draw(*pDC, rc.left, rc.top);
            ::SelectClipRgn(*pDC, NULL);
        }
    }
    void m_OnMouseMove(void)
    {
        if ( m_arrowIcon == NULL ) { m_arrowIcon = ::GetCursor(); }
        CPoint pos;
        ::GetCursorPos(&pos);
        m_imglist.DragMove(pos - m_dragOffset);
        //
        CWnd* pParent = _super::GetParent();
        if ( pParent == NULL )
        {
            return;
        }
        int backupDropItem = m_nowDropItem;
        CWnd* pBackupDropWnd = m_nowDropWnd;
        RECT backupDropRect;
        ::GetRgnBox(m_nowDropItemRgn, &backupDropRect);
        m_nowDropItem = -1;
        HCURSOR hCursor = NULL;
        //
        CWnd* P = pParent->GetParentOwner();
        if ( P == NULL )
        {
            return;
        }
        CRect rc;
        P->GetClientRect(&rc);
        P->ClientToScreen(&rc);
        if ( rc.PtInRect(pos) )
        {
            pParent->ScreenToClient(&pos);
            CWnd* P = pParent->ChildWindowFromPoint(pos, CWP_SKIPINVISIBLE);
            if ( P != NULL )
            {
                TDropParam param;
                param.dragID = m_draggingItemID;
                param.ctrlID = static_cast<WORD>(P->GetDlgCtrlID());
                if ( param.ctrlID != 0 )
                {
                    pParent->ClientToScreen(&pos);
                    P->ScreenToClient(&pos);
                    param.point = pos;
                    RECT rect;
                    P->GetClientRect(&rect);
                    param.hRgn = ::CreateRectRgn(0, 0, rect.right, rect.bottom);
                    P->GetWindowRgn(param.hRgn);
                    if ( m_CanDropping(P, param) )
                    {
                        if ( param.ctrlID != m_draggingItemID )
                        {
                            _DeleteObject(m_nowDropItemRgn);
                            m_nowDropItemRgn = param.hRgn;
                            m_nowDropItem = param.ctrlID;
                            m_nowDropWnd = P;
                            hCursor = m_arrowIcon;
                        }
                        else
                        {
                            _DeleteObject(param.hRgn);
                        }
                    }
                    else
                    {
                        _DeleteObject(param.hRgn);
                    }
                }
            }
        }
        if ( hCursor == NULL )
        {
            if ( m_noIcon == NULL ) { m_noIcon = ::LoadCursor(NULL, IDC_NO); }
            hCursor = m_noIcon;
        }
        ::SetCursor(hCursor);
        if ( backupDropItem != m_nowDropItem )
        {
            if ( backupDropItem >= 0 )
            {
                m_SendCommand(LEAVE, backupDropItem);
                m_imglist.DragShowNolock(false);
                CWnd* P = pBackupDropWnd->GetParent();
                if ( P != NULL )
                {
                    pBackupDropWnd->ClientToScreen(&backupDropRect);
                    P->ScreenToClient(&backupDropRect);
                    P->RedrawWindow(&backupDropRect);
                }
                else
                {
                    pBackupDropWnd->RedrawWindow(&backupDropRect);
                }
                m_imglist.DragShowNolock(true);
            }
            if ( m_nowDropItem >= 0 )
            {
                m_SendCommand(HOVER, m_nowDropItem);
                if ( IS_RGBVALUE(m_targetMarkColor) )
                {
                    CDC* pDC = m_nowDropWnd->GetDC();
                    m_imglist.DragShowNolock(false);
                    m_DrawTargetMark(pDC, m_nowDropItemRgn);
                    m_imglist.DragShowNolock(true);
                    m_nowDropWnd->ReleaseDC(pDC);
                }
            }
        }
    }
    bool m_CanDropping(CWnd* P, TDropParam& _param)
    {
        ASSERTLIB( P != NULL );
        ASSERTLIB( _param.ctrlID != 0 );
        WPARAM wParam = MAKELONG(CANDROP, m_wGroupID);
        LPARAM lParam = reinterpret_cast<LPARAM>(&_param);
        if ( P->SendMessage(m_nMessageCode, wParam, lParam) )
        {
            return true;
        }
        if ( m_SendCommand(ISDROP, _param.ctrlID) )
        {
            return true;
        }
        return false;
    }
    //　アイテムのドラッグ開始
    bool m_BeginDrag(void)
    {
        if ( m_boIsDragging )
        {
            m_EndDrag();
        }
        if ( ! m_boCanDragging ) { return false; }
        CPoint pos;
        ::GetCursorPos(&pos);
        CRect rect;
        _super::GetWindowRect(rect);
        CRect winRect = rect;
        m_draggingItemID = OnBeginDrag(rect, pos);
        if ( m_draggingItemID <= 0 )
        {
            return false;
        }
        CPoint controlPoint = rect.TopLeft();
        m_dragOffset = pos - controlPoint;
        CBitmapHandle hh = m_bmpDragging;
        CSize size;
        if ( hh.IsNull() )
        {
            CBitmapImage bi;
            bi.SetFromWindow(m_hWnd, RGB(0, 0, 1));
            rect.OffsetRect(-winRect.TopLeft());
            hh = bi.Cut(rect).GetBitmapHandle();
            hh.GetSize(size);
        }
        else
        {
            VERIFY( hh.GetSize(size) );
        }
        m_imglist.Create(size.cx, size.cy, ILC_MASK, 0, 1);
        m_imglist.Add(CBitmap::FromHandle(hh), RGB(0, 0, 1));
        m_imglist.BeginDrag(0, CPoint(0, 0));
        m_imglist.DragEnter(NULL, controlPoint);
        m_imglist.DragMove(controlPoint);
        SetCapture();
        m_boIsDragging = true;
        return true;
    }
    // ドラッグの終了
    bool m_EndDrag(void)
    {
        if ( ! m_boIsDragging ) { return false; }
        m_boIsDragging = false;
        m_imglist.EndDrag();
        m_imglist.DeleteImageList();
        if ( m_nowDropItem >= 0 && ::IsWindow(*m_nowDropWnd) )
        {
            m_nowDropWnd->Invalidate();
        }
        ReleaseCapture();
        return true;
    }
    bool m_SendCommand(UINT uCmd, int item)
    {
        WPARAM wParam = MAKELONG(uCmd, m_wGroupID);
        LPARAM lParam = MAKELONG(m_draggingItemID, item);
        LRESULT r = 0;
        CWnd* pWnd = _super::GetParent();
        if ( pWnd != NULL )
        {
            r = pWnd->SendMessage(m_nMessageCode, wParam, lParam);
        }
        OnDragNofity(uCmd, m_draggingItemID, item);
        return !! r;
    }
};
 
 
 
}; //MFC
}; //TNB