//____________________________________________________________________________
//
//  Microsoft Windows
//  Copyright (C) Microsoft Corporation, 1997 - 1999
//
//  File:       dd.cpp
//
//  Contents:
//
//  Classes:
//
//  Functions:
//
//  History:    8/3/1997   RaviR   Created
//____________________________________________________________________________
//


#include "stdafx.h"


#include "AMCDoc.h"         // AMC Console Document
#include "amcview.h"
#include "TreeCtrl.h"
#include "cclvctl.h"
#include "amcpriv.h"
#include "mainfrm.h"
#include "rsltitem.h"
#include "conview.h"

/***************************************************************************\
 *
 * CLASS:  CMMCDropSource
 *
 * PURPOSE: Implements everything required for drop source:
 *          a) com object to register with OLE
 *          b) static method to perform drag&drop operation
 *
 * USAGE:   All you need is to invoke CMMCDropSource::ScDoDragDrop static method
 *
\***************************************************************************/
class CMMCDropSource :
public IDropSource,
public CComObjectRoot
{
public:

BEGIN_COM_MAP(CMMCDropSource)
    COM_INTERFACE_ENTRY(IDropSource)
END_COM_MAP()

    // IDropSource methods
    STDMETHOD(QueryContinueDrag)( BOOL fEscapePressed,  DWORD grfKeyState );
    STDMETHOD(GiveFeedback)( DWORD dwEffect );

    // method to perform D&D
    static SC ScDoDragDrop(IDataObject *pDataObject, bool bCopyAllowed, bool bMoveAllowed);
};

/***************************************************************************\
 *
 * CLASS:  CMMCDropTarget
 *
 * PURPOSE: Implements com object to be osed by OLE for drop target operations
 *
 * USAGE:   Used by CMMCViewDropTarget, which creates and registers it with OLE
 *          to be invoked on OLE D&D opeartions on the window (target)
 *
\***************************************************************************/
class CMMCDropTarget :
public CTiedComObject<CMMCViewDropTarget>,
public IDropTarget,
public CComObjectRoot
{
public:
    typedef CMMCViewDropTarget MyTiedObject;

BEGIN_COM_MAP(CMMCDropTarget)
    COM_INTERFACE_ENTRY(IDropTarget)
END_COM_MAP()

    // IDropTarget methods

    STDMETHOD(DragEnter)( IDataObject * pDataObject, DWORD grfKeyState,
                          POINTL pt, DWORD * pdwEffect );
    STDMETHOD(DragOver)( DWORD grfKeyState, POINTL pt, DWORD * pdwEffect );
    STDMETHOD(DragLeave)(void);
    STDMETHOD(Drop)( IDataObject * pDataObject, DWORD grfKeyState,
                     POINTL pt, DWORD * pdwEffect  );
private:

    // implementation helpers

    SC ScDropOnTarget(bool bHitTestOnly, IDataObject * pDataObject, POINTL pt, bool& bCopyOperation);
    SC ScRemoveDropTargetHiliting();
    static SC ScAddMenuString(CMenu& menu, DWORD id, UINT idString);
    SC ScDisplayDropMenu(POINTL pt, DWORD dwEffectsAvailable, DWORD& dwSelected);
    DWORD CalculateEffect(DWORD dwEffectsAvailable, DWORD grfKeyState, bool bCopyPreferred);

private:
    IDataObjectPtr m_spDataObject;      // cached data object
    bool           m_bRightDrag;        // operation is right click drag
    bool           m_bCopyByDefault;    // if default operation is copy (not move)
};

//////////////////////////////////////////////////////////////////////////////
////////// CAMCTreeView methods for supporting d&d ///////////////////////////
//////////////////////////////////////////////////////////////////////////////

/***************************************************************************\
 *
 * METHOD:  CAMCTreeView::ScDropOnTarget
 *
 * PURPOSE: called to hittest or perform drop operation
 *
 * PARAMETERS:
 *    bool bHitTestOnly         [in] - HitTest / drop
 *    IDataObject * pDataObject [in] - data object to copy/move
 *    CPoint point              [in] - current cursor position
 *    bool& bCopyOperation      [in/out]
 *                                 [in] -  operation to perform (HitTest == false)
 *                                 [out] - default op. (HitTest == true)
 *
 * RETURNS:
 *    SC    - result code
 *
\***************************************************************************/
SC CAMCTreeView::ScDropOnTarget(bool bHitTestOnly, IDataObject * pDataObject, CPoint point, bool& bCopyOperation)
{
    DECLARE_SC(sc, TEXT("CAMCTreeView::ScDropOnTarget"));

    // 1. see where it falls
    CTreeCtrl& ctc = GetTreeCtrl();
    UINT flags;
    HTREEITEM htiDrop = ctc.HitTest(point, &flags);

    if (flags & TVHT_NOWHERE)
        return sc = S_FALSE; // not an error, but no paste;

    // 2. if we missed the tree item...
    if (!htiDrop)
    {
        // really mad if it was a paste
        if (! bHitTestOnly)
            MessageBeep(0);

        return sc = S_FALSE; // not an error, but no paste;
    }

    // 3. get the target node

    HNODE hNode = (HNODE) ctc.GetItemData(htiDrop);

    INodeCallback* pNC = GetNodeCallback();
    sc = ScCheckPointers(pNC, E_UNEXPECTED);
    if (sc)
        return sc;

    // 4. ask what snapin thinks about this paste
    bool bGetDataObjectFromClipboard = false;
    bool bPasteAllowed = false;
    bool bIsCopyDefaultOperation = false;
    sc = pNC->QueryPaste(hNode, /*bScope*/ true, /*LVDATA*/ NULL,
                         pDataObject, bPasteAllowed, bIsCopyDefaultOperation);
    if (sc)
        return sc;

    if (!bPasteAllowed)
        return sc = S_FALSE; // not an error, but no paste;

    // 5. visual effect
    ctc.SelectDropTarget(htiDrop);

    // 6. OK so far. If it was a test - we passed
    if (bHitTestOnly)
    {
        bCopyOperation = bIsCopyDefaultOperation;
        return sc;
    }

    // 7. do paste NOW
    sc = pNC->Drop(hNode, /*bScope*/TRUE, /*LVDATA*/NULL, pDataObject, !bCopyOperation);
    if (sc)
        return sc;

    return sc;
}

/***************************************************************************\
 *
 * METHOD:  CAMCTreeView::RemoveDropTargetHiliting
 *
 * PURPOSE: called to remove hiliting put for drop target
 *
 * PARAMETERS:
 *
 * RETURNS:
 *    void
 *
\***************************************************************************/
void CAMCTreeView::RemoveDropTargetHiliting()
{
    CTreeCtrl& ctc = GetTreeCtrl();
    ctc.SelectDropTarget(NULL);
}

/***************************************************************************\
 *
 * METHOD:  CAMCTreeView::OnBeginRDrag
 *
 * PURPOSE: called when the drag operation is initiated with right mouse button
 *
 * PARAMETERS:
 *    NMHDR* pNMHDR
 *    LRESULT* pResult
 *
 * RETURNS:
 *    void
 *
\***************************************************************************/
void CAMCTreeView::OnBeginRDrag(NMHDR* pNMHDR, LRESULT* pResult)
{
    OnBeginDrag(pNMHDR, pResult);
}

/***************************************************************************\
 *
 * METHOD:  CAMCTreeView::OnBeginDrag
 *
 * PURPOSE: called when the drag operation is initiated with
 *
 * PARAMETERS:
 *    NMHDR* pNMHDR
 *    LRESULT* pResult
 *
 * RETURNS:
 *    SC    - result code
 *
\***************************************************************************/
void CAMCTreeView::OnBeginDrag(NMHDR* pNMHDR, LRESULT* pResult)
{
    DECLARE_SC(sc, TEXT("CAMCTreeView::OnBeginDrag"));

    // 1. parameter check
    sc = ScCheckPointers( pNMHDR, pResult );
    if (sc)
        return;

    *pResult = 0;

    // 2. get node calback
    CTreeCtrl& ctc = GetTreeCtrl();
    NM_TREEVIEW* pNMTreeView = (NM_TREEVIEW*)pNMHDR;
    HNODE hNode = (HNODE) ctc.GetItemData(pNMTreeView->itemNew.hItem);

    INodeCallback* pNC = GetNodeCallback();
    sc = ScCheckPointers( pNC, E_UNEXPECTED );
    if (sc)
        return;

    // 3. get data object
    IDataObjectPtr spDO;
    bool bCopyAllowed = false;
    bool bMoveAllowed = false;
    sc = pNC->GetDragDropDataObject(hNode, TRUE, 0, 0, &spDO, bCopyAllowed, bMoveAllowed);
    if ( sc != S_OK || spDO == NULL)
        return;

    // 4. start d&d
    sc = CMMCDropSource::ScDoDragDrop(spDO, bCopyAllowed, bMoveAllowed);
    if (sc)
        return;
}

//////////////////////////////////////////////////////////////////////////////
////////// CAMCListView methods for supporting d&d ///////////////////////////
//////////////////////////////////////////////////////////////////////////////

// helpers

INodeCallback* CAMCListView::GetNodeCallback()
{
    ASSERT (m_pAMCView != NULL);
    return (m_pAMCView->GetNodeCallback());
}

HNODE CAMCListView::GetScopePaneSelNode()
{
    ASSERT (m_pAMCView != NULL);
    return (m_pAMCView->GetSelectedNode());
}

/***************************************************************************\
 *
 * METHOD:  CAMCListView::ScDropOnTarget
 *
 * PURPOSE: called to hittest or perform drop operation
 *
 * PARAMETERS:
 *    bool bHitTestOnly         [in] - HitTest / drop
 *    IDataObject * pDataObject [in] - data object to copy/move
 *    CPoint point              [in] - current cursor position
 *    bool& bCopyOperation      [in/out]
 *                                 [in] -  operation to perform (HitTest == false)
 *                                 [out] - default op. (HitTest == true)
 *
 * RETURNS:
 *    SC    - result code
 *
\***************************************************************************/
SC CAMCListView::ScDropOnTarget(bool bHitTestOnly, IDataObject * pDataObject, CPoint point, bool& bCopyOperation)
{
    DECLARE_SC(sc, TEXT("CAMCListView::ScDropOnTarget"));

    // 1. sanity check
    sc = ScCheckPointers( m_pAMCView , E_UNEXPECTED );
    if (sc)
        return sc;

    // 2. see if view does not have a paste tabu (listpads do)
    if (!m_pAMCView->CanDoDragDrop())
        return sc = (bHitTestOnly ? S_FALSE : E_FAIL); // not an error if testing

    // 3. HitTest the target
    HNODE  hNode  = NULL;
    bool   bScope = false;
    LPARAM lvData = NULL;
    int    iDrop  = -1;

    sc = ScGetDropTarget(point, hNode, bScope, lvData, iDrop);
    if (sc.IsError() || (sc == SC(S_FALSE)))
        return sc;

    // 4. get the callback
    INodeCallback* pNC = GetNodeCallback();
    sc = ScCheckPointers(pNC, E_UNEXPECTED);
    if (sc)
        return sc;

    // 5. ask what snapin thinks about this paste
    const bool bGetDataObjectFromClipboard = false;
    bool bPasteAllowed = false;
    bool bIsCopyDefaultOperation = false;
    sc = pNC->QueryPaste(hNode, bScope, lvData,
                         pDataObject, bPasteAllowed, bIsCopyDefaultOperation);
    if (sc)
        return sc;

    if (!bPasteAllowed)
        return sc = S_FALSE; // not an error, but no paste;

    // 6. visual effect
    SelectDropTarget(iDrop);

    // 7. OK so far. If it was a test - we passed
    if (bHitTestOnly)
    {
        bCopyOperation = bIsCopyDefaultOperation;
        return sc;
    }

    // 8. do paste NOW
    sc = pNC->Drop(hNode, bScope, lvData, pDataObject, !bCopyOperation);
    if (sc)
        return sc;

    return sc;
}

/***************************************************************************\
 *
 * METHOD:  CAMCListView::RemoveDropTargetHiliting
 *
 * PURPOSE: called to remove target hiliting
 *
 * PARAMETERS:
 *
 * RETURNS:
 *    void
 *
\***************************************************************************/
void CAMCListView::RemoveDropTargetHiliting()
{
    SelectDropTarget(-1);
}

//+-------------------------------------------------------------------
//
//  Member:      CAMCListView::ScGetDropTarget
//
//  Synopsis:    Get the drop target item (result item or scope item).
//
//  Arguments:   [point]  - where the drop is done.
//               [hNode]  - Owner node of result pane.
//               [bScope] - scope or result selected.
//               [lvData] - If result the LPARAM of result item.
//               [iDrop]  - index of the lv item that is drop target.
//
//  Returns:     SC, S_FALSE means no drop target item.
//
//--------------------------------------------------------------------
SC CAMCListView::ScGetDropTarget(const CPoint& point, HNODE& hNode, bool& bScope, LPARAM& lvData, int& iDrop)
{
    DECLARE_SC(sc, _T("CAMCListView::ScGetDropTarget"));

    hNode = NULL;
    bScope = false;
    lvData = NULL;
    iDrop  = -1;

    CListCtrl& lc = GetListCtrl();
    UINT flags;
    iDrop = lc.HitTest(point, &flags);

    // background is drop target.
    if (iDrop < 0)
    {
        hNode = GetScopePaneSelNode();
        bScope = true;
        return sc;
    }

    // Need to change this to LVIS_DROPHILITED.
    if (lc.GetItemState(iDrop, LVIS_SELECTED) & LVIS_SELECTED)
    {
        HWND hWnd = ::GetForegroundWindow();
        if (hWnd && (hWnd == m_hWnd))
            return (sc = S_FALSE);
    }

	/*
	 * virtual list?  lvData is the item index, hNode is the item selected
	 * in the scope pane
	 */
	if (m_bVirtual)
	{
		hNode  = GetScopePaneSelNode();
		lvData = iDrop;
		bScope = false;
	}
	else
	{
		LPARAM  lParam = lc.GetItemData(iDrop);
		ASSERT (lParam != 0);
		if (lParam == 0)
			return (sc = S_FALSE);

		CResultItem* pri = CResultItem::FromHandle(lParam);

		if (pri == NULL)
			return (sc = S_FALSE);

		if (pri->IsScopeItem())
		{
			hNode = pri->GetScopeNode();
			bScope = true;
		}
		else
		{
			hNode = GetScopePaneSelNode();
			lvData = lParam;
		}
	}

    sc = ScCheckPointers(hNode, E_UNEXPECTED);
    if (sc)
        return sc;

    return (sc);
}


/***************************************************************************\
 *
 * METHOD:  CAMCListView::OnBeginRDrag
 *
 * PURPOSE: called when the drag operation is initiated with right mouse button
 *
 * PARAMETERS:
 *    NMHDR* pNMHDR
 *    LRESULT* pResult
 *
 * RETURNS:
 *    void
 *
\***************************************************************************/
void CAMCListView::OnBeginRDrag(NMHDR* pNMHDR, LRESULT* pResult)
{
    OnBeginDrag(pNMHDR, pResult);
}

/***************************************************************************\
 *
 * METHOD:  CAMCListView::OnBeginDrag
 *
 * PURPOSE: called when the drag operation is initiated
 *
 * PARAMETERS:
 *    NMHDR* pNMHDR
 *    LRESULT* pResult
 *
 * RETURNS:
 *    void
 *
\***************************************************************************/
void CAMCListView::OnBeginDrag(NMHDR* pNMHDR, LRESULT* pResult)
{
    DECLARE_SC(sc, TEXT("CAMCListView::OnBeginDrag"));

    // 1. parameter check
    sc = ScCheckPointers( pNMHDR, pResult );
    if (sc)
        return;

    *pResult = 0;

    // 2. sanity check
    sc = ScCheckPointers( m_pAMCView, E_UNEXPECTED );
    if (sc)
        return;

    // 3. see if view does not have a paste tabu (listpads do)
    if (!m_pAMCView->CanDoDragDrop())
        return;

    // 4. get selected items
    CListCtrl& lc = GetListCtrl();
    UINT cSel = lc.GetSelectedCount();
    if (cSel <= 0)
    {
        sc = E_UNEXPECTED;
        return;
    }

    // 5. get node callback
    HNODE hNode = GetScopePaneSelNode();
    long iSel = lc.GetNextItem(-1, LVIS_SELECTED);
    LONG_PTR lvData = m_bVirtual ? iSel : lc.GetItemData(iSel);

    INodeCallback* pNC = GetNodeCallback();
    sc = ScCheckPointers( pNC, E_UNEXPECTED );
    if (sc)
        return;

    // 6. retrieve data object
    IDataObjectPtr spDO;
    bool bCopyAllowed = false;
    bool bMoveAllowed = false;
    sc = pNC->GetDragDropDataObject(hNode, FALSE, (cSel > 1), lvData, &spDO, bCopyAllowed, bMoveAllowed);
    if ( sc != S_OK || spDO == NULL)
	{
		/*
		 * Problem: 
		 * If snapin does not return dataobject then drag & drop is not possible.
		 * Assume focus in on tree, user downclick's and drags a result item
		 * At this time common control sends LVN_ITEMCHANGED to mmc. MMC translates
		 * this to MMCN_SELECT and tells snapin that result item is selected.
		 * Now when user releases the mouse the tree item still has focus & selection,
		 * but the snapin thinks result item is selected (also verbs correspond to 
		 * result item). 
		 *
		 * Solution:
		 * So we will set focus to the result pane.
		 */
		sc = m_pAMCView->ScSetFocusToPane(CConsoleView::ePane_Results);
        return;
	}

    // 7. do d&d
    sc = CMMCDropSource::ScDoDragDrop(spDO, bCopyAllowed, bMoveAllowed);
    if (sc)
        return;

	/*
	 * Problem:
	 * If a result item is dropped into another result item or another
	 * scope item in list-view then focus disappears from that item.
	 * But there should be always an item selected after any de-select. 
	 * We cannot change the focus to result pane because if focus is already
	 * in result pane, this change focus does nothing and no item is selected.
	 * So we change the focus to scope pane. For this we first change the focus
	 * to result pane and then to scope pane. Because if tree already has focus, 
	 * setting focus to tree does nothing (CAMCView::ScOnTreeViewActivated).
	 *
	 * Solution:
	 * So we change the focus to result pane and then to scope pane.
	 */
	sc = m_pAMCView->ScSetFocusToPane(CConsoleView::ePane_Results);
	if (sc)
		return;

	sc = m_pAMCView->ScSetFocusToPane(CConsoleView::ePane_ScopeTree);
	if (sc)
		return;

	return;
}

//////////////////////////////////////////////////////////////////////////////
///////////////////// CMMCViewDropTarget methods /////////////////////////////
//////////////////////////////////////////////////////////////////////////////

/***************************************************************************\
 *
 * METHOD:  CMMCViewDropTarget::CMMCViewDropTarget
 *
 * PURPOSE: constructor
 *
 * PARAMETERS:
 *
\***************************************************************************/
CMMCViewDropTarget::CMMCViewDropTarget() : m_hwndOwner(0)
{
}

/***************************************************************************\
 *
 * METHOD:  CMMCViewDropTarget::~CMMCViewDropTarget
 *
 * PURPOSE: destructor. Revokes drop target for derived view class
 *
\***************************************************************************/
CMMCViewDropTarget::~CMMCViewDropTarget()
{
    DECLARE_SC(sc, TEXT("CViewDropTarget::~CViewDropTarget"));

    if (m_hwndOwner != NULL)
        sc = RevokeDragDrop(m_hwndOwner);
}

/***************************************************************************\
 *
 * METHOD:  CMMCViewDropTarget::ScRegisterAsDropTarget
 *
 * PURPOSE: This method is called by the derived class after the view window
 *          is created. Method registers the drop target for the window.
 *
 * PARAMETERS:
 *    HWND hWnd [in] - drop target view handle
 *
 * RETURNS:
 *    SC    - result code
 *
\***************************************************************************/
SC CMMCViewDropTarget::ScRegisterAsDropTarget(HWND hWnd)
{
    DECLARE_SC(sc, TEXT("CMMCViewDropTarget::ScRegister"));

    // 1. parameter check
    if (hWnd == NULL)
        return sc = E_INVALIDARG;

    // 2. sanity check - should not come here twice
    if (m_spTarget != NULL)
        return sc = E_UNEXPECTED;

    // 3. create a drop target com object
    IDropTargetPtr spTarget;
    sc = ScCreateTarget(&spTarget);
    if (sc)
        return sc;

    // 4. recheck
    sc = ScCheckPointers(spTarget, E_UNEXPECTED);
    if (sc)
        return sc;

    // 5. register with OLE
    sc = RegisterDragDrop(hWnd, spTarget);
    if (sc)
        return sc;

    // 6. store info into members
    m_spTarget.Attach( spTarget.Detach() );
    m_hwndOwner = hWnd;

    return sc;
}

/***************************************************************************\
 *
 * METHOD:  CMMCViewDropTarget::ScCreateTarget
 *
 * PURPOSE: helper. creates tied com object to regiter with OLE
 *
 * PARAMETERS:
 *    IDropTarget **ppTarget [out] tied com object
 *
 * RETURNS:
 *    SC    - result code
 *
\***************************************************************************/
SC CMMCViewDropTarget::ScCreateTarget(IDropTarget **ppTarget)
{
    DECLARE_SC(sc, TEXT("CMMCViewDropTarget::ScCreateTarget"));

    // 1. check parameters
    sc = ScCheckPointers(ppTarget);
    if (sc)
        return sc;

    // 2. init out parameter
    *ppTarget = NULL;

    // 3. create com object to register as target
    IDropTargetPtr spDropTarget;
    sc = CTiedComObjectCreator<CMMCDropTarget>::ScCreateAndConnect(*this, spDropTarget);
    if (sc)
        return sc;

    sc = ScCheckPointers(spDropTarget, E_UNEXPECTED);
    if (sc)
        return sc;

    // 4. pass reference to client
    *ppTarget = spDropTarget.Detach();

    return sc;
}

/*---------------------------------------------------------------------------*\
|                   class CMMCDropSource methods                              |
\*---------------------------------------------------------------------------*/

/***************************************************************************\
 *
 * METHOD:  CMMCDropSource::QueryContinueDrag
 *
 * PURPOSE: implements IDropSource::QueryContinueDrag interface used bu OLE
 *
 * PARAMETERS:
 *    BOOL fEscapePressed   [in] - ESC was pressed
 *    DWORD grfKeyState     [in] - mouse & control button state
 *
 * RETURNS:
 *    HRESULT  - error or  S_OK(continue), DRAGDROP_S_CANCEL(cancel), DRAGDROP_S_DROP(drop)
 *
\***************************************************************************/
STDMETHODIMP CMMCDropSource::QueryContinueDrag( BOOL fEscapePressed,  DWORD grfKeyState )
{
    DECLARE_SC(sc, TEXT("CMMCDropSource::QueryContinueDrag"));

    // 1. quit on cancel
    if (fEscapePressed)
        return (sc = DRAGDROP_S_CANCEL).ToHr();

    // 2. inspect mouse buttons
    DWORD mButtons = (grfKeyState & (MK_LBUTTON | MK_RBUTTON | MK_MBUTTON) );
    if ( mButtons == 0 ) // all released?
        return (sc = DRAGDROP_S_DROP).ToHr();

    // 3. quit also if more than one mouse button is pressed
    if ( mButtons != MK_LBUTTON && mButtons != MK_RBUTTON && mButtons != MK_MBUTTON )
        return (sc = DRAGDROP_S_CANCEL).ToHr();

    // 4. else just continue ...

    return sc.ToHr();
}

/***************************************************************************\
 *
 * METHOD:  CMMCDropSource::GiveFeedback
 *
 * PURPOSE: Gives feedback for d&d operations
 *
 * PARAMETERS:
 *    DWORD dwEffect
 *
 * RETURNS:
 *    DRAGDROP_S_USEDEFAULTCURSORS
 *
\***************************************************************************/
STDMETHODIMP CMMCDropSource::GiveFeedback( DWORD dwEffect )
{
    // nothing special by now
    return DRAGDROP_S_USEDEFAULTCURSORS;
}

/***************************************************************************\
 *
 * METHOD:  CMMCDropSource::ScDoDragDrop
 *
 * PURPOSE: Performs DragAndDrop operation
 *          This is static method to be used to initiate drag and drop
 *
 * PARAMETERS:
 *    IDataObject *pDataObject [in] data object to copy/move
 *    bool bCopyAllowed        [in] if copy is allowed
 *    bool bMoveAllowed        [in] if move is allowed
 *
 * RETURNS:
 *    SC    - result code
 *
\***************************************************************************/
SC CMMCDropSource::ScDoDragDrop(IDataObject *pDataObject, bool bCopyAllowed, bool bMoveAllowed)
{
    DECLARE_SC(sc, TEXT("CMMCDropSource::ScDoDragDrop"));

    // 1. cocreate com object for OLE
    typedef CComObject<CMMCDropSource> ComCMMCDropSource;
    ComCMMCDropSource *pSource = NULL;
    sc = ComCMMCDropSource::CreateInstance(&pSource);
    if (sc)
        return sc;

    // 2. recheck
    sc = ScCheckPointers(pSource, E_UNEXPECTED);
    if (sc)
    {
        delete pSource;
        return sc;
    }

    // 3. QI for IDropSource interface
    IDropSourcePtr spDropSource = pSource;
    sc = ScCheckPointers(spDropSource, E_UNEXPECTED);
    if (sc)
    {
        delete pSource;
        return sc;
    }

    // 4. perform DragDrop
    DWORD dwEffect = DROPEFFECT_NONE;
    const DWORD dwEffectAvailable = (bCopyAllowed ? DROPEFFECT_COPY : 0)
                                   |(bMoveAllowed ? DROPEFFECT_MOVE : 0);
    sc = DoDragDrop(pDataObject, spDropSource, dwEffectAvailable, &dwEffect);
    if (sc)
        return sc;

    return sc;
}

/*---------------------------------------------------------------------------*\
|                   class CMMCDropTarget methods                              |
\*---------------------------------------------------------------------------*/

/***************************************************************************\
 *
 * METHOD:  CMMCDropTarget::DragEnter
 *
 * PURPOSE: Invoked by OLE when d&d cursor enters the window for which
 *          this target was registered.
 *
 * PARAMETERS:
 *    IDataObject * pDataObject [in] - data object to copy/move
 *    DWORD grfKeyState         [in] - current key state
 *    POINTL pt                 [in] - current cursor position
 *    DWORD * pdwEffect         [out] - operations supported
 *
 * RETURNS:
 *    HRESULT    - result code
 *
\***************************************************************************/
STDMETHODIMP CMMCDropTarget::DragEnter( IDataObject * pDataObject, DWORD grfKeyState,
                                        POINTL pt, DWORD * pdwEffect )
{
    DECLARE_SC(sc, TEXT("CMMCDropTarget::DragEnter"));

    // 1. cache for drag over
    m_spDataObject = pDataObject;

    // 2. parameter check
    sc = ScCheckPointers(pDataObject, pdwEffect);
    if (sc)
        return sc.ToHr();

    // 3. let it happen - will do more exact filtering on DragOver
    *pdwEffect = DROPEFFECT_MOVE | DROPEFFECT_COPY;

    return sc.ToHr();
}

/***************************************************************************\
 *
 * METHOD:  CMMCDropTarget::DragOver
 *
 * PURPOSE: called continuosly while cursor is drgged over the window
 *
 * PARAMETERS:
 *    DWORD grfKeyState         [in] - current key state
 *    POINTL pt                 [in] - current cursor position
 *    DWORD * pdwEffect         [out] - operations supported
 *
 * RETURNS:
 *    HRESULT    - result code
 *
\***************************************************************************/
STDMETHODIMP CMMCDropTarget::DragOver( DWORD grfKeyState, POINTL pt, DWORD * pdwEffect )
{
    DECLARE_SC(sc, TEXT("CMMCDropTarget::DragOver"));

    // 1. parameter check
    sc = ScCheckPointers(pdwEffect);
    if (sc)
        return sc.ToHr();

    // 2. sanity check
    sc = ScCheckPointers(m_spDataObject, E_UNEXPECTED);
    if (sc)
        return sc.ToHr();

    bool bCopyByDefault = false; // initially we are to move

    // 3. ask the view to estimate what can be done in this position
    sc = ScDropOnTarget( true /*bHitTestOnly*/, m_spDataObject, pt, bCopyByDefault );
    if ( sc == S_OK )
        *pdwEffect = CalculateEffect( *pdwEffect, grfKeyState, bCopyByDefault );
    else
        *pdwEffect = DROPEFFECT_NONE; // no-op on failure or S_FALSE

    return sc.ToHr();
}

/***************************************************************************\
 *
 * METHOD:  CMMCDropTarget::DragLeave
 *
 * PURPOSE: called when cursor leave the window
 *
 * PARAMETERS:
 *    void
 *
 * RETURNS:
 *    HRESULT    - result code
 *
\***************************************************************************/
STDMETHODIMP CMMCDropTarget::DragLeave(void)
{
    DECLARE_SC(sc, TEXT("DragLeave"));

    // 1. release data object
    m_spDataObject = NULL;

    // 2. ask the view to remove hiliting it put on target
    sc = ScRemoveDropTargetHiliting();
    if (sc)
        sc.TraceAndClear();

    return S_OK;
}

/***************************************************************************\
 *
 * METHOD:  CMMCDropTarget::Drop
 *
 * PURPOSE: Called when data is dropped on target
 *
 * PARAMETERS:
 *    IDataObject * pDataObject [in] - data object to copy/move
 *    DWORD grfKeyState         [in] - current key state
 *    POINTL pt                 [in] - current cursor position
 *    DWORD * pdwEffect         [out] - operation performed
 *
 * RETURNS:
 *    HRESULT    - result code
 *
\***************************************************************************/
STDMETHODIMP CMMCDropTarget::Drop( IDataObject * pDataObject, DWORD grfKeyState,
                                   POINTL pt, DWORD * pdwEffect  )
{
    DECLARE_SC(sc, TEXT("CMMCDropTarget::DragEnter"));

    // 1. release in case we have anything
    m_spDataObject = NULL;

    // 2. parameter check
    sc = ScCheckPointers(pDataObject, pdwEffect);
    if (sc)
        return sc.ToHr();

    // 3. init operation with cached value
    bool bCopyOperation = m_bCopyByDefault;

    // 4. see what operation to perform
    if (m_bRightDrag)
    {
        // 4.1. give user the choice
        DWORD dwSelected = ( m_bCopyByDefault ? DROPEFFECT_COPY : DROPEFFECT_MOVE );
        sc = ScDisplayDropMenu( pt, *pdwEffect, dwSelected );
        if (sc)
            return sc.ToHr();

        *pdwEffect = dwSelected;
    }
    else
    {
        // 4.2. inspect keyboard
        *pdwEffect = CalculateEffect(*pdwEffect, grfKeyState, bCopyOperation);
    }

    // 5. perform
    if (*pdwEffect != DROPEFFECT_NONE) // not canceled yet?
    {
        // now the final decision - copy or move
        bCopyOperation = ( *pdwEffect & DROPEFFECT_COPY );

        // Let it happen. Drop.
        sc = ScDropOnTarget( false /*bHitTestOnly*/, pDataObject, pt, bCopyOperation );
        if ( sc != S_OK )
            *pdwEffect = DROPEFFECT_NONE;
    }

    // 6. remove hiliting. reuse DragLeave (don't care about the results)
    DragLeave();

    return sc.ToHr();
}

/***************************************************************************\
 *
 * METHOD:  CMMCDropTarget::ScDropOnTarget
 *
 * PURPOSE: helper, forwarding calls to the view
 *          Called as a request to hittest / perform drop operation
 *
 * PARAMETERS:
 *    bool bHitTestOnly         [in] - HitTest / drop
 *    IDataObject * pDataObject [in] - data object to copy/move
 *    POINTL pt                 [in] - current cursor position
 *    bool& bCopyOperation      [in/out]
 *                                 [in] -  operation to perform (HitTest == false)
 *                                 [out] - default op. (HitTest == true)
 * RETURNS:
 *    SC    - result code
 *
\***************************************************************************/
SC CMMCDropTarget::ScDropOnTarget(bool bHitTestOnly, IDataObject * pDataObject, POINTL pt, bool& bCopyOperation)
{
    DECLARE_SC(sc, TEXT("CMMCDropTarget::ScDropOnTarget"));

    // 1. get tied object - view
    CMMCViewDropTarget *pTarget = NULL;
    sc = ScGetTiedObject(pTarget);
    if (sc)
        return sc;

    // 2. recheck
    sc = ScCheckPointers(pTarget, E_UNEXPECTED);
    if (sc)
        return sc;

    // 3. calculate client coordinates
    CPoint point(pt.x, pt.y);
    ScreenToClient(pTarget->GetWindowHandle(), &point);

    // 4. forward to the view
    sc = pTarget->ScDropOnTarget( bHitTestOnly, pDataObject, point, bCopyOperation );
    if ( sc != S_OK )
        ScRemoveDropTargetHiliting(); // remove hiliting if missed the traget
    if (sc)
        return sc;

    return sc;
}

/***************************************************************************\
 *
 * METHOD:  CMMCDropTarget::ScRemoveDropTargetHiliting
 *
 * PURPOSE: helper, forwarding calls to the view
 *          Called to cancel visual effects on target
 *
 * PARAMETERS:
 *
 * RETURNS:
 *    SC    - result code
 *
\***************************************************************************/
SC CMMCDropTarget::ScRemoveDropTargetHiliting()
{
    DECLARE_SC(sc, TEXT("CMMCDropTarget::ScRemoveDropTargetHiliting"));

    // `. get tied object - view
    CMMCViewDropTarget *pTarget = NULL;
    sc = ScGetTiedObject(pTarget);
    if (sc)
        return sc;

    sc = ScCheckPointers(pTarget, E_UNEXPECTED);
    if (sc)
        return sc;

    // 2. forward to the view
    pTarget->RemoveDropTargetHiliting();

    return sc;
}

/***************************************************************************\
 *
 * METHOD:  CMMCDropTarget::ScAddMenuString
 *
 * PURPOSE: Helper. Adds resource string to paste context menu
 *
 * PARAMETERS:
 *    CMenu& menu   [in] - menu to modify
 *    DWORD id      [in] - menu command
 *    UINT idString [in] - id of resource string
 *
 * RETURNS:
 *    SC    - result code
 *
\***************************************************************************/
SC CMMCDropTarget::ScAddMenuString(CMenu& menu, DWORD id, UINT idString)
{
    DECLARE_SC(sc, TEXT("CMMCDropTarget::ScAddMenuString"));

    // 1. load the string
    CString strItem;
    bool bOK = LoadString( strItem, idString );
    if ( !bOK )
        return sc = E_FAIL;

    // 2. add to the menu
    bOK = menu.AppendMenu( MF_STRING, id, strItem );
    if ( !bOK )
        return sc = E_FAIL;

    return sc;
}

/***************************************************************************\
 *
 * METHOD:  CMMCDropTarget::ScDisplayDropMenu
 *
 * PURPOSE: Helper. Displays paste context menu
 *
 * PARAMETERS:
 *    POINTL pt                 [in] - point where the menu should appear
 *    DWORD dwEffectsAvailable  [in] - available commands
 *    DWORD& dwSelected         [in] - selected command
 *
 * RETURNS:
 *    SC    - result code
 *
\***************************************************************************/
SC CMMCDropTarget::ScDisplayDropMenu(POINTL pt, DWORD dwEffectsAvailable, DWORD& dwSelected)
{
    DECLARE_SC(sc, TEXT("CMMCDropTarget::ScDisplayDropMenu"));

    CMenu menu;

    // 0. create the menu
    bool bOK = menu.CreatePopupMenu();
    if ( !bOK )
        return sc = E_FAIL;

    // 1. add choice for copy
    if ( dwEffectsAvailable & DROPEFFECT_COPY )
    {
        sc = ScAddMenuString(menu, DROPEFFECT_COPY, IDS_DragDrop_CopyHere);
        if (sc)
            return sc;
    }

    // 2. add choice for move
    if ( dwEffectsAvailable & DROPEFFECT_MOVE )
    {
        sc = ScAddMenuString(menu, DROPEFFECT_MOVE, IDS_DragDrop_MoveHere);
        if (sc)
            return sc;
    }

    // 3. add separator if copy or paste was added
    if ( dwEffectsAvailable & ( DROPEFFECT_COPY | DROPEFFECT_MOVE ) )
    {
        bool bOK = menu.AppendMenu( MF_SEPARATOR );
        if ( !bOK )
            return sc = E_FAIL;
    }

    // 4. always add choice for cancel
    sc = ScAddMenuString(menu, DROPEFFECT_NONE, IDS_DragDrop_Cancel);
    if (sc)
        return sc;

    // 5. set the default item
    if ( dwSelected != DROPEFFECT_NONE )
    {
        bool bOK = menu.SetDefaultItem( dwSelected );
        if ( !bOK )
            return sc = E_FAIL;
    }

    // 6. find the tied object
    CMMCViewDropTarget *pTarget = NULL;
    sc = ScGetTiedObject(pTarget);
    if (sc)
        return sc;

    sc = ScCheckPointers(pTarget, E_UNEXPECTED);
    if (sc)
        return sc;

    // 7. display the menu
    dwSelected = menu.TrackPopupMenu(TPM_RETURNCMD | TPM_NONOTIFY | TPM_RIGHTBUTTON | TPM_LEFTBUTTON,
                                     pt.x, pt.y, CWnd::FromHandlePermanent( pTarget->GetWindowHandle() ) );

    return sc;
}

/***************************************************************************\
 *
 * METHOD:  CMMCDropTarget::CalculateEffect
 *
 * PURPOSE: Helper. calculates drop effect by combining:
 *          a) available operations
 *          b) the default operation
 *          c) keyboard key combination
 *
 * PARAMETERS:
 *    DWORD dwEffectsAvailable [in] available operations
 *    DWORD grfKeyState        [in] keyboard / mouse state
 *    bool  bCopyPreferred      [in] default operation
 *
 * RETURNS:
 *    SC    - result code
 *
\***************************************************************************/
DWORD CMMCDropTarget::CalculateEffect(DWORD dwEffectsAvailable, DWORD grfKeyState, bool bCopyPreferred)
{
    const bool bShiftPressed =   (grfKeyState & MK_SHIFT);
    const bool bControlPressed = (grfKeyState & MK_CONTROL);
    const bool bRightClickDrag  = (grfKeyState & MK_RBUTTON);

    m_bRightDrag = bRightClickDrag;
    m_bCopyByDefault = bCopyPreferred;

    if (!bRightClickDrag) // affected by keyboard only in non-right-drag
    {
        // do nothing if user holds on shift+control
        if ( bShiftPressed && bControlPressed )
            return DROPEFFECT_NONE;

        // modify by user interactive preferences
        if ( bShiftPressed )
        {
            // if user cannot get what he wants to - indicate it
            if ( !(dwEffectsAvailable & DROPEFFECT_MOVE) )
                return DROPEFFECT_NONE;

            bCopyPreferred = false;
        }
        else if ( bControlPressed )
        {
            // if user cannot get what he wants to - indicate it
            if ( !(dwEffectsAvailable & DROPEFFECT_COPY) )
                return DROPEFFECT_NONE;

            bCopyPreferred = true;
        }
    }

    // return preferred, if available
    if ( bCopyPreferred && (dwEffectsAvailable & DROPEFFECT_COPY) )
        return DROPEFFECT_COPY;

    if ( !bCopyPreferred && (dwEffectsAvailable & DROPEFFECT_MOVE) )
        return DROPEFFECT_MOVE;

    // preferred not available - return what is available

    if ( dwEffectsAvailable & DROPEFFECT_COPY )
    {
        m_bCopyByDefault = true;
        return DROPEFFECT_COPY;
    }
    else if ( dwEffectsAvailable & DROPEFFECT_MOVE )
    {
        m_bCopyByDefault = false;
        return DROPEFFECT_MOVE;
    }

    return DROPEFFECT_NONE;
}