uidragdroptree.cpp

vc座的资源管理器源代码

			ASSERT(FALSE);
			return;
			break;
	}	
	if (m_bDragging)
	{
		// Select the drop target
		if (m_pImageList)
			m_pImageList->DragLeave(this);
		HTREEITEM hitem = GetFirstVisibleItem();

		switch( nScrollMode )
		  {
			case SCROLL_UP_SLOW:
			case SCROLL_UP_NORMAL:
			  {
				SelectDropTarget(hitem);
				m_hitemDrop = hitem;
				break;
			  }
			case SCROLL_DOWN_SLOW:
			case SCROLL_DOWN_NORMAL:
			  {
		// Get the last visible item in the control
				int nCount = GetVisibleCount();
				for ( int i=0; i<nCount-1; ++i )
					hitem = GetNextVisibleItem(hitem);
				SelectDropTarget(hitem);
				m_hitemDrop = hitem;
				break;
			  }
			default:
				ASSERT(FALSE);
				return;
				break;
		  }

		if (m_pImageList)
			m_pImageList->DragEnter(this, ptMouse);	CTreeCtrl::OnTimer(nIDEvent);
	}
}

void CUIDragDropTree::OnRButtonUp(UINT nFlags, CPoint point) 
{
	if (!m_bDragging)
		return;
	// Kill the timer and reset all variables
	EndDragging();
	CMenu menu;
	VERIFY(menu.LoadMenu(IDR_POPUPMENU_DRAGDROP));
	CMenu* pPopup = menu.GetSubMenu(0);
	ASSERT(pPopup != NULL);
	pPopup->SetDefaultItem(ID_POPUP_DD_MOVE);
	CPoint pts(point);
	ClientToScreen(&pts);
	if (GetRDragMenu(pPopup))
	{
		UINT nCmd = pPopup->TrackPopupMenu(TPM_LEFTALIGN | TPM_LEFTBUTTON | TPM_NONOTIFY | TPM_RIGHTBUTTON | TPM_RETURNCMD, pts.x, pts.y,this);
		if (nCmd == ID_POPUP_DD_MOVE)
		{
			OnButtonUp(true);
		}
		else if (nCmd == ID_POPUP_DD_COPY)
		{
			OnButtonUp(false);
		}
	}
	else
	{
		// otherwise just move
		OnButtonUp(true);
	}	
	SelectDropTarget(NULL);
	CTreeCtrl::OnRButtonUp(nFlags, point);
}

void CUIDragDropTree::OnMouseMove(UINT nFlags, CPoint point) 
{
	// TODO: Add your message handler code here and/or call default
	HTREEITEM			hItem;
	UINT				flags;

	if (!m_bDragging)
		return;
	CPoint ptScreen(point);
	ClientToScreen(&ptScreen);

	m_pImageList->DragMove(ptScreen);

	m_pImageList->DragShowNolock(FALSE);

	if ((hItem = HitTest(point, &flags)) != NULL)
	{
		CDD_OleDropTargetInfo Info(this->GetSafeHwnd(),point,NULL);
		Info.SetItem(hItem);
		LRESULT lResult = SendMessage(WM_APP_OLE_DD_OVER,(WPARAM)&Info);
		if (lResult == 0)
		{
			lResult = GetParent()->SendMessage(WM_APP_OLE_DD_OVER,(WPARAM)&Info);
		}
		if (lResult)
		{
			SelectDropTarget(hItem);
			m_hitemDrop = hItem;
		}
	}
	m_pImageList->DragShowNolock(TRUE);
	
	CTreeCtrl::OnMouseMove(nFlags, point);
}

void CUIDragDropTree::OnButtonUp(bool bMove)
{
	if (!m_bDragging)
		return;
	EndDragging();
	if (m_hitemDrag && m_hitemDrag != m_hitemDrop && !IsChildNodeOf(m_hitemDrop, m_hitemDrag) && 
								GetParentItem(m_hitemDrag) != m_hitemDrop)
	{
		CDD_OleDropTargetInfo Info(GetSafeHwnd(),CPoint(),NULL);
		Info.SetDropEffect(bMove ? DROPEFFECT_MOVE : DROPEFFECT_COPY);
		Info.SetItem(m_hitemDrop);
		LRESULT lResult = SendMessage(WM_APP_OLE_DD_DROP,(WPARAM)&Info);
		if (lResult == 0)
			lResult = GetParent()->SendMessage(WM_APP_OLE_DD_DROP,(WPARAM)&Info);
	}
}

void CUIDragDropTree::EndDragging()
{
	if (!m_bDragging)
		return;
	m_bDragging = FALSE;
	if (m_pImageList)
	{
		m_pImageList->DragLeave(this);
		m_pImageList->EndDrag();
	}
	delete m_pImageList;
	m_pImageList = NULL;
	ReleaseCapture();
	KillDragTimer();
}

void CUIDragDropTree::NewTransferItem(HTREEITEM hNewItem)
{
}

BOOL CUIDragDropTree::TransferItem(HTREEITEM hitemDrag, HTREEITEM hitemDrop)
{
	TV_INSERTSTRUCT		tvstruct;
	TCHAR				sztBuffer[256];
	HTREEITEM			hNewItem, hFirstChild;

		// avoid an infinite recursion situation
	tvstruct.item.hItem = hitemDrag;
	tvstruct.item.cchTextMax = sizeof(sztBuffer)-1;
	tvstruct.item.pszText = sztBuffer;
	tvstruct.item.mask = TVIF_CHILDREN | TVIF_HANDLE | TVIF_IMAGE | TVIF_SELECTEDIMAGE | TVIF_TEXT | TVIF_PARAM;
	GetItem(&tvstruct.item);  
	tvstruct.hParent = hitemDrop;
	tvstruct.hInsertAfter = TVI_SORT;
	tvstruct.item.mask = TVIF_IMAGE | TVIF_SELECTEDIMAGE | TVIF_TEXT | TVIF_PARAM;
	hNewItem = InsertItem(&tvstruct);
	NewTransferItem(hNewItem);

	while ((hFirstChild = GetChildItem(hitemDrag)) != NULL)
	{
		// recursively transfer all the items
		TransferItem(hFirstChild, hNewItem);  
		// delete the first child and all its children
		DeleteItem(hFirstChild);		
	}
	return TRUE;
}



BOOL CUIDragDropTree::NeedToScroll( CPoint ptMouse )
{
	if (m_bDragging)
	{
		return ptMouse.y < m_nUpperYCoor || ptMouse.y > m_nLowerYCoor;
	}
	else
	{
		return ptMouse.y < m_nUpperYCoor+10 || ptMouse.y > m_nLowerYCoor-30;
	}
}


CUIDragDropTree::SCROLLMODE CUIDragDropTree::RefineScrollMode( CPoint ptMouse )
{
	int nYCoor = ptMouse.y;
	CUIDragDropTree::SCROLLMODE nScrollMode;

	if (m_bDragging)
	{
		nScrollMode = nYCoor > m_nLowerYCoor + m_nScrollBarSize ? SCROLL_DOWN_NORMAL :
					  nYCoor > m_nLowerYCoor ? SCROLL_DOWN_SLOW :
					  nYCoor < m_nUpperYCoor - m_nScrollBarSize ? SCROLL_UP_NORMAL :
					  SCROLL_UP_SLOW;
	}
	else
	{
		nScrollMode = nYCoor > m_nLowerYCoor-30 ? SCROLL_DOWN_NORMAL : 
					nYCoor < m_nUpperYCoor-10 ? SCROLL_UP_NORMAL : SCROLL_UP_NORMAL;
	}
	return nScrollMode;
}

BOOL CUIDragDropTree::IsChildNodeOf(HTREEITEM hitemChild, HTREEITEM hitemSuspectedParent)
{
	do
	{
		if (hitemChild == hitemSuspectedParent)
			break;
	}
	while ((hitemChild = GetParentItem(hitemChild)) != NULL);

	return (hitemChild != NULL);
}

void CUIDragDropTree::RegisterDropTarget()
{
	if (GetDragDrop())
	{
		VERIFY(m_OleDropTarget.Register(this));
		if (GetDropFiles())
			DragAcceptFiles();
	}
}

DROPEFFECT CUIDragDropTree::SelectCurrentTarget(CDD_OleDropTargetInfo *pInfo)
{
	HTREEITEM hItem;
	UINT flags;
	if ((hItem = HitTest(pInfo->GetPoint(), &flags)) != NULL) 
	{
		// select it
		SelectDropTarget(hItem);
		// save it
		m_hitemDrop = hItem;
		// returns 1 if allowed
		pInfo->SetItem(hItem);
		LRESULT lResult = SendMessage(WM_APP_OLE_DD_OVER,(WPARAM)pInfo);
		if (lResult == 0)
		{
			lResult = GetParent()->SendMessage(WM_APP_OLE_DD_OVER,(WPARAM)pInfo);
		}
		if (lResult)
		{
			if (::GetKeyState(VK_LCONTROL) < 0) 
			{
				if (ItemHasChildren(hItem))
				{
					Expand(hItem, TVE_EXPAND);
				}
			}
			return pInfo->GetDropEffect();
		}
	}
	return DROPEFFECT_NONE;
}

void CUIDragDropTree::OnDestroy() 
{

	CTreeCtrl::OnDestroy();
	
	// TODO: Add your message handler code here
	
}

int CUIDragDropTree::OnCreate(LPCREATESTRUCT lpCreateStruct) 
{
	if (CTreeCtrl::OnCreate(lpCreateStruct) == -1)
		return -1;
	
	// TODO: Add your specialized creation code here
	RegisterDropTarget();
	
	return 0;
}

bool CUIDragDropTree::GetRDragMenu(CMenu *pMenu)
{
	return true;
}

void CUIDragDropTree::OnDDMove()
{
	m_CopyMode = eDDMove;
}

void CUIDragDropTree::OnDDCopy()
{
	m_CopyMode = eDDCopy;
}

void CUIDragDropTree::OnDDCancel()
{
	m_CopyMode = eDDCancel;
}