void CMyTreeCtrl::HandleScrollTimer()
{
// Doesn't matter that we didn't initialize m_timerticks
m_timerticks++;
POINT pt, clientPt;
GetCursorPos( &pt );
RECT rect;
GetClientRect( &rect );
ClientToScreen( &rect );
clientPt = pt;
ScreenToClient( &clientPt );
CImageList::DragMove(clientPt);
HTREEITEM hitem = GetFirstVisibleItem();
if( pt.y < rect.top + 10 )
{
// We need to scroll up
// Scroll slowly if cursor near the treeview control
int slowscroll = 6 - (rect.top + 10 - pt.y) / 4;
if( 0 == ( m_timerticks % (slowscroll > 0? slowscroll : 1) ) )
{
CImageList::DragShowNolock(FALSE);
SendMessage( WM_VSCROLL, SB_LINEUP);
SelectDropTarget(hitem);
m_hitemDrop = hitem;
CImageList::DragShowNolock(TRUE);
}
}
else if( pt.y > rect.bottom - 10 )
{
// We need to scroll down
// Scroll slowly if cursor near the treeview control
int slowscroll = 6 - (pt.y - rect.bottom + 10 ) / 4;
if( 0 == ( m_timerticks % (slowscroll > 0? slowscroll : 1) ) )
{
CImageList::DragShowNolock(FALSE);
SendMessage( WM_VSCROLL, SB_LINEDOWN);
int nCount = GetVisibleCount();
for ( int i=0; i<nCount-1; ++i )
hitem = GetNextVisibleItem(hitem);
if( hitem )
SelectDropTarget(hitem);
m_hitemDrop = hitem;
CImageList::DragShowNolock(TRUE);
}
}
}
void CTreeCtrlEx::OnMouseMove(UINT nFlags, CPoint point)
{
HTREEITEM hitem;
UINT flags;
if(m_bLDragging)
{
if(nFlags==0)
{
m_bLDragging=FALSE;
}
else
{
POINT pt = point;
ClientToScreen( &pt );
CImageList::DragMove(pt);
if ((hitem = HitTest(point, &flags)) != NULL)
{
CImageList::DragShowNolock(FALSE);
SelectDropTarget(hitem);
m_hitemDrop = hitem;
if(GetItemData(hitem)>=1000 || GetItemData(hitem)==0)
CImageList::DragShowNolock(TRUE);
else
m_hitemDrop=NULL;
}
}
}
CTreeCtrl::OnMouseMove(nFlags, point);
}
void CMyTreeCtrl::OnButtonUp()
{
if (m_bDragging)
{
ASSERT(m_pimagelist != NULL);
m_pimagelist->DragLeave(this);
m_pimagelist->EndDrag();
delete m_pimagelist;
m_pimagelist = NULL;
if (m_hitemDrag != m_hitemDrop &&
!IsChildNodeOf(m_hitemDrop, m_hitemDrag) &&
GetParentItem(m_hitemDrag) != m_hitemDrop &&
GetParentItem(m_hitemDrag) != NULL &&
GetParentItem(m_hitemDrop) == NULL )
{
m_hitemDragParent = GetParentItem(m_hitemDrag);
GetParent()->SendMessage(TV_PREDROP,(unsigned int)m_hitemDrag,(long)m_hitemDrop);
TransferItem(m_hitemDrag, m_hitemDrop);
DeleteItem(m_hitemDrag);
GetParent()->PostMessage(TV_POSTDROP,(unsigned int)m_hitemDragParent,NULL);
m_bItemChanged = TRUE;
}
else
MessageBeep(0);
ReleaseCapture();
m_bDragging = FALSE;
SelectDropTarget(NULL);
KillTimer(1000);
}
}
BOOL CGroupEditTree::PreTranslateMessage(MSG* pMsg)
{
if (pMsg->message == WM_KEYDOWN)
{
if (GetEditControl()
&& (pMsg->wParam == VK_RETURN
|| pMsg->wParam == VK_ESCAPE))
{
::TranslateMessage(pMsg);
::DispatchMessage(pMsg);
return TRUE; // DO NOT process further
}
if (pMsg->wParam == VK_ESCAPE
&& m_bDragging)
{
m_bDragging = 0;
CImageList::DragLeave(NULL);
CImageList::EndDrag();
ReleaseCapture();
SelectDropTarget(NULL);
delete m_pDragImage;
return TRUE; // DO NOT process further
}
}
return CTreeCtrl::PreTranslateMessage(pMsg);
}
void CGroupEditTree::OnLButtonUp(UINT nFlags, CPoint point)
{
CTreeCtrl::OnLButtonUp(nFlags, point);
if (m_bDragging)
{
m_bDragging = FALSE;
CImageList::DragLeave(this);
CImageList::EndDrag();
ReleaseCapture();
delete m_pDragImage;
// Remove drop target highlighting
SelectDropTarget(NULL);
if (m_hitemDrag == m_hitemDrop || m_hitemDrop == NULL)
return;
// If Drag item is an ancestor of Drop item then return
HTREEITEM htiParent = m_hitemDrop;
while ((htiParent = GetParentItem(htiParent)) != NULL)
if (htiParent == m_hitemDrag)
return;
Expand(m_hitemDrop, TVE_EXPAND);
DWORD source = GetItemData(m_hitemDrag);
DWORD dest = GetItemData(m_hitemDrop) - 0xFFFF;
TV_INSERTSTRUCT tvstruct;
tvstruct.hParent = m_hitemDrop;
tvstruct.hInsertAfter = TVI_SORT;
tvstruct.item.lParam = source;
tvstruct.item.mask = TVIF_PARAM | TVIF_TEXT | TVIF_IMAGE | TVIF_SELECTEDIMAGE;
DeleteItem(m_hitemDrag);
if (source < 0xFFFF)
{
opts->piecesgroups[source] = opts->groups[dest];
tvstruct.item.iImage = 2;
tvstruct.item.iSelectedImage = 2;
tvstruct.item.pszText = (char*)opts->pieces[source]->GetName();
InsertItem(&tvstruct);
}
else
{
opts->groupsgroups[source - 0xFFFF] = opts->groups[dest];
tvstruct.item.iImage = 0;
tvstruct.item.iSelectedImage = 1;
tvstruct.item.pszText = opts->groups[source - 0xFFFF]->m_strName;
HTREEITEM hti = InsertItem(&tvstruct);
AddChildren(hti, opts->groups[source - 0xFFFF]);
}
// AddChildren(m_hitemDrop, opts->groups[dest]);
}
}
void CGroupEditTree::OnMouseMove(UINT nFlags, CPoint point)
{
HTREEITEM hitem;
UINT flags;
if (m_bDragging)
{
POINT pt = point;
ClientToScreen(&pt);
CImageList::DragMove(pt);
if ((hitem = HitTest(point, &flags)) != NULL)
{
CImageList::DragShowNolock(FALSE);
m_hitemDrop = GetDropTarget(hitem);
SelectDropTarget(m_hitemDrop);
CImageList::DragShowNolock(TRUE);
}
else
m_hitemDrop = NULL;
if (m_hitemDrop)
SetCursor(m_dropCursor);
else
SetCursor(m_noDropCursor);
}
CTreeCtrl::OnMouseMove(nFlags, point);
}
void CLTWinTreeMgr::OnMouseMove(UINT nFlags, CPoint pt)
{
CTreeCtrl::OnMouseMove(nFlags, pt);
//make sure we are in a drag operation
if(!IsInDrag())
{
return;
}
//hilite the drop target if one exists
CLTWinTreeItem* pHit = GetDropTarget(pt);
if(pHit)
{
//this is a valid drop target, so make it look like one
SelectDropTarget(pHit->m_hTreeItem);
}
//move the drag image
if(m_pDragImage)
{
m_pDragImage->DragMove(pt);
}
}
void CMyTreeCtrl::OnMouseMove(UINT nFlags, CPoint point)
{
HTREEITEM hitem;
UINT flags;
if ( m_nTimerIDHover )
{
KillTimer( m_nTimerIDHover );
m_nTimerIDHover = 0;
}
if (m_bDragging)
{
ASSERT(m_pimagelist != NULL);
m_pimagelist->DragMove(point);
// Start the hover timer
m_nTimerIDHover = SetTimer(TIMER_ID_HOVER, 500, NULL);
m_hoverPoint=point;
if ((hitem = HitTest(point, &flags)) != NULL)
{
m_pimagelist->DragLeave(this);
SelectDropTarget(hitem);
m_hitemDrop = hitem;
m_pimagelist->DragEnter(this, point);
}
else
{
m_hitemDrop = NULL;
}
}
CTreeCtrl::OnMouseMove(nFlags, point);
}
void CMyTreeCtrl::OnButtonUp()
{
if (m_bDragging)
{
KillTimer( m_nTimerIDScroll );
ASSERT(m_pimagelist != NULL);
m_pimagelist->DragLeave(this);
m_pimagelist->EndDrag();
delete m_pimagelist;
m_pimagelist = NULL;
if (m_hitemDrag != m_hitemDrop && !IsChildNodeOf(m_hitemDrop, m_hitemDrag) &&
GetParentItem(m_hitemDrag) != m_hitemDrop)
{
TransferItem(m_hitemDrag, m_hitemDrop);
DeleteItem(m_hitemDrag);
}
else
MessageBeep(0);
m_bDragging = FALSE;
ReleaseCapture();
SelectDropTarget(NULL);
}
}
void EXTreeCtrl::OnLButtonUp(UINT nFlags, CPoint point)
{
EXWaitingTreeCtrl::OnLButtonUp(nFlags, point);
if (m_bLDragging)
{
m_bLDragging = FALSE;
CImageList::DragLeave(this);
CImageList::EndDrag();
ReleaseCapture();
delete m_pDragImage;
// Remove drop target highlighting
SelectDropTarget(NULL);
if( m_hitemDrag == m_hitemDrop )
return;
// If Drag item is an ancestor of Drop item then return
HTREEITEM htiParent = m_hitemDrop;
while( (htiParent = GetParentItem( htiParent )) != NULL )
{
if( htiParent == m_hitemDrag ) return;
}
// Move in data...
bool bRes = false;
HTREEITEM htiPrevParent = GetParentItem( m_hitemDrag );
/* EBaseItem * pFromParentItem = (EBaseItem *)GetItemData(htiPrevParent);
EBaseItem * pToParentItem = (EBaseItem *)GetItemData(m_hitemDrop);
EBaseItem * pDraggedItem = (EBaseItem *)GetItemData(m_hitemDrag);
if(pFromParentItem && pFromParentItem->m_pITreeMember &&
pToParentItem && pToParentItem->m_pITreeMember &&
pDraggedItem && pDraggedItem->m_pITreeMember)
{
bRes = pDraggedItem->m_pITreeMember->MoveItem(pFromParentItem->m_pITreeMember,pToParentItem->m_pITreeMember);
}*/
IXTreeItem * pFromParentItem = (IXTreeItem *)GetItemData(htiPrevParent);
IXTreeItem * pToParentItem = (IXTreeItem *)GetItemData(m_hitemDrop);
IXTreeItem * pDraggedItem = (IXTreeItem *)GetItemData(m_hitemDrag);
if(pFromParentItem && pToParentItem && pDraggedItem)
{
bRes = pDraggedItem->MoveItem(pFromParentItem,pToParentItem);
}
if(!bRes)
return;
// Move in tree
Expand( m_hitemDrop, TVE_EXPAND ) ;
HTREEITEM htiNew = CopyBranch( m_hitemDrag, m_hitemDrop, TVI_LAST );
SelectItem( htiNew );
if(m_hitemDrop)
RefreshSubItems(m_hitemDrop);
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : eDropType -
// nFlags -
// point -
//-----------------------------------------------------------------------------
void CGroupList::Drop(DropType_t eDropType, UINT nFlags, CPoint point)
{
SelectDropTarget(NULL);
HTREEITEM hDragItem = m_hDragItem;
m_hDragItem = NULL;
//
// We are dragging. Drop!
//
if (m_pDragImageList)
{
m_pDragImageList->DragLeave(this);
m_pDragImageList->EndDrag();
delete m_pDragImageList;
m_pDragImageList = NULL;
}
//
// Get the group that we were dragging.
//
CVisGroup *pDragGroup = (CVisGroup *)GetItemData(hDragItem);
//
// Determine what group was dropped onto.
//
HTREEITEM hDropItem = HitTest(point);
if (hDropItem == hDragItem)
{
return;
}
CVisGroup *pDropGroup = NULL;
if (hDropItem)
{
pDropGroup = (CVisGroup *)GetItemData(hDropItem);
}
if (pDragGroup == pDropGroup)
{
// Shouldn't happen, but just in case.
return;
}
CWnd *pwndParent = GetParent();
if (pwndParent != NULL)
{
if (eDropType == DROP_LEFT)
{
pwndParent->PostMessage(g_uLeftDragDropMsg, (WPARAM)pDragGroup, (LPARAM)pDropGroup);
}
else
{
pwndParent->PostMessage(g_uRightDragDropMsg, (WPARAM)pDragGroup, (LPARAM)pDropGroup);
}
}
}
void CNZProjectTreeCtrl::OnLButtonUp(UINT nFlags, CPoint point)
{
CTreeCtrl::OnLButtonUp(nFlags, point);
if (m_bDragging)
{
// end dragging
m_bDragging = FALSE;
try
{
CImageList::DragLeave(this);
CImageList::EndDrag();
ReleaseCapture();
delete m_pDragImage;
// Remove drop target highlighting
SelectDropTarget(NULL);
m_htiOldDrop = NULL;
// If Drag item is a child of Drop item or they ar ethe same node then return
if( m_htiDrag == m_htiDrop || GetParentItem(m_htiDrag) == m_htiDrop )
throw "";
CXNode* pNewNode = NULL;
CXNode* pDragNode = (CXNode*)GetItemData(m_htiDrag);
CXNode* pDropNode = (CXNode*)GetItemData(m_htiDrop);
if (pDropNode->m_enNodeType == XNODE_FILE)
throw"";
this->MoveNode(pDragNode, (CXFolder*)pDropNode);
}
catch (...)
{}
// kill the expand timer
if( m_nExpandTimer )
{
KillTimer( m_nExpandTimer );
m_nExpandTimer = 0;
}
// kill the scroll timer
if( m_nScrollTimer )
{
KillTimer( m_nScrollTimer );
m_nScrollTimer = 0;
}
}
}
void CTreeCtrlEx::OnLButtonUp(UINT nFlags, CPoint point)
{
CTreeCtrl::OnLButtonUp(nFlags, point);
if(m_bLDragging)
{
m_bLDragging=FALSE;
CImageList::DragLeave(this);
CImageList::EndDrag();
ReleaseCapture();
delete m_pDragImage;
SelectDropTarget(NULL);
if(m_hitemDrop!=NULL && m_hitemDrag!=NULL)
{
if(GetItemData(m_hitemDrop)!=0)
{
if(m_pIdentify->GetGestureById((int)GetItemData(m_hitemDrop))->m_GroupStatus!=1)
{
m_hitemDrop=GetParentItem(m_hitemDrop);
}
if( (m_hitemDrag==m_hitemDrop) || (m_hitemDrop==NULL) || (GetParentItem(m_hitemDrag)==m_hitemDrop) )
{
SelectItem(m_hitemDrag);
return;
}
}
HTREEITEM htiParent = m_hitemDrop;
while( (htiParent = GetParentItem( htiParent )) != NULL )
{
if( htiParent == m_hitemDrag ) return;
}
Expand(m_hitemDrop, TVE_EXPAND);
int dataDrag=(int)GetItemData(m_hitemDrag);
int dataDrop=(int)GetItemData(m_hitemDrop);
// перемещаем жесты в основном массиве, там внутри модифицируется тунель
m_pIdentify->Move(
m_pIdentify->m_Tunnel.GetNumberById(dataDrag),
m_pIdentify->m_Tunnel.GetNumberById(dataDrop)
);
HTREEITEM htiNew=CopyBranch(m_hitemDrag,m_hitemDrop,TVI_SORT);
DeleteItem(m_hitemDrag);
SelectItem(htiNew);
}
}
}
void CLTWinTreeMgr::OnLButtonUp(UINT nFlags, CPoint pt)
{
CTreeCtrl::OnLButtonUp(nFlags, pt);
//make sure we are in a drag operation
if(!IsInDrag())
{
return;
}
//see if we have a place to drop it
CLTWinTreeItem* pHit = GetDropTarget(pt);
if(pHit)
{
//we are moving it, so lets make the move
//first erase the old tree
CTreeCtrl::DeleteItem(m_pDragItem->m_hTreeItem);
//unlink the item
UnlinkFromSiblings(m_pDragItem);
//now build the new tree recursively
RebuildDraggedTree(m_pDragItem, pHit);
//select the moved item
CTreeCtrl::SelectItem(m_pDragItem->m_hTreeItem);
}
//clear the drop target
SelectDropTarget(NULL);
//clean up the drag stuff
m_bDragging = FALSE;
m_pDragItem = NULL;
//clean up the image list
if(m_pDragImage)
{
m_pDragImage->EndDrag();
delete m_pDragImage;
m_pDragImage = NULL;
}
//clean up the cursor
ReleaseCapture();
}
void CTreeFileCtrl::OnMouseMove(UINT nFlags, CPoint point)
{
if (IsDragging())
{
CRect clientRect;
GetClientRect(&clientRect);
//Draw the drag
POINT pt = point;
ClientToScreen(&pt);
CImageList::DragMove(pt);
//Only select the drop item if we are in the client area
HTREEITEM hItem = NULL;
if (clientRect.PtInRect(point))
{
UINT flags;
hItem = HitTest(point, &flags);
if (m_hItemDrop != hItem)
{
CImageList::DragShowNolock(FALSE);
SelectDropTarget(hItem);
m_hItemDrop = hItem;
CImageList::DragShowNolock(TRUE);
}
}
if (hItem)
hItem = GetDropTarget(hItem);
//Change the cursor to give feedback
if (hItem)
{
if ((GetKeyState(VK_CONTROL) & 0x8000))
SetCursor(m_DropCopyCursor);
else
SetCursor(m_DropMoveCursor);
}
else
{
if ((GetKeyState(VK_CONTROL) & 0x8000))
SetCursor(m_NoDropCopyCursor);
else
SetCursor(m_NoDropMoveCursor);
}
}
//Let the parent class do its thing
CTreeCtrl::OnMouseMove(nFlags, point);
}
void CSharedDirsTreeCtrl::OnCancelMode()
{
if (m_pDraggingItem != NULL){
CImageList::DragLeave(NULL);
CImageList::EndDrag();
ReleaseCapture();
ShowCursor(TRUE);
SelectDropTarget(NULL);
delete m_pDraggingItem;
m_pDraggingItem = NULL;
RedrawWindow();
}
CTreeCtrl::OnCancelMode();
}
HTREEITEM CDragDropTreeCtrl::HighlightDropTarget(CPoint point)
{
// Find out which item (if any) the cursor is over.
UINT nFlags;
HTREEITEM hItem = HitTest(point, &nFlags);
// Highlight the item, or unhighlight all items if the cursor isn't
// over an item.
m_pImageList->DragShowNolock(FALSE);
SelectDropTarget(hItem);
m_pImageList->DragShowNolock(TRUE);
// Return the handle of the highlighted item.
return hItem;
}
void CDragDropTreeCtrl::OnLButtonUp(UINT nFlags, CPoint point)
{
CTreeCtrl::OnLButtonUp(nFlags, point);
if (m_bDragging && m_pImageList != NULL)
{
// Stop the scroll timer if it's running.
KillTimer(1);
// Terminate the dragging operation and release the mouse.
m_pImageList->DragLeave(this);
m_pImageList->EndDrag();
::ReleaseCapture();
m_bDragging = FALSE;
SelectDropTarget(NULL);
// Delete the image list created by CreateDragImage.
delete m_pImageList;
m_pImageList = NULL;
// Get the HTREEITEM of the drop target and exit now if it's NULL.
UINT nHitFlags;
HTREEITEM hItem = HitTest(point, &nHitFlags);
if (hItem == NULL)
return;
if (hItem == m_hDragItem)
return;
else if (hItem == GetParentItem(m_hDragItem))
return;
else if (IsChildOf(hItem, m_hDragItem))
return;
// Move the dragged item and its subitems (if any) to the drop point.
MoveTree(hItem, m_hDragItem);
// Mark the item as having children
TVITEM tvItem;
tvItem.mask = TVIF_CHILDREN | TVIF_HANDLE;
tvItem.cChildren = 1;
tvItem.hItem = hItem;
SetItem(&tvItem);
m_hDragItem = NULL;
if (m_WMOnDropped)
GetParent()->SendMessage(m_WMOnDropped, (WPARAM)hItem);
}
}
void CSiteGroupsTree::OnMouseMove(UINT flags, CPoint point)
{
if (m_isDragging) {
CImageList::DragMove(point);
UINT hitFlags;
HTREEITEM item = HitTest(point, &hitFlags);
if (item != m_droppedItem) {
CImageList::DragShowNolock(FALSE);
SelectDropTarget(item);
m_droppedItem = item;
CImageList::DragShowNolock(TRUE);
}
}
CTreeCtrl::OnMouseMove(flags, point);
}
void KGTreeCtrl::OnMouseMove(UINT nFlags, CPoint point)
{
HTREEITEM hItem;
UINT flags;
if (m_nHoverTimerID)
{
KillTimer(m_nHoverTimerID);
m_nHoverTimerID = 0;
}
m_nHoverTimerID = SetTimer(1, 800, NULL);
m_HoverPoint = point;
if (m_bDragging)
{
CPoint pt = point;
CImageList::DragMove(pt);
CImageList::DragShowNolock(false);
hItem = HitTest(point, &flags);
if (hItem)
{
SelectDropTarget(hItem);
CRect rect;
GetItemRect(hItem, &rect, true);
rect.left -= 35;
m_curPointLeft.x = rect.left;
m_curPointLeft.y = rect.bottom;
m_curPointRigh.x = rect.right;
m_curPointRigh.y = rect.bottom;
m_hItemDragD = hItem;
}
CImageList::DragShowNolock(true);
CRect rect;
GetClientRect(&rect);
if (point.x < rect.left + 20)
m_hItemDragD = NULL;
}
CTreeCtrl::OnMouseMove(nFlags, point);
}
void CNZProjectTreeCtrl::OnMouseMove(UINT nFlags, CPoint point)
{
// TODO: Add your message handler code here and/or call default
HTREEITEM hitem;
UINT flags;
if (m_bDragging)
{
//TRACE0("MOUSE MOVE/t");
POINT pt = point;
ClientToScreen( &pt );
CImageList::DragMove(pt);
if ((hitem = HitTest(point, &flags)) != NULL)
{
if( m_htiOldDrop == NULL )
m_htiOldDrop = GetDropHilightItem();
CXNode* pNode = (CXNode*)GetItemData(hitem);
if (pNode->m_enNodeType == XNODE_FILE)
{
// use the file's parent (folder or project)
hitem = pNode->m_pParent->m_hTreeItem;
ASSERT(hitem);
}
// select the node to which we can drop
CImageList::DragShowNolock(FALSE);
SelectDropTarget(hitem);
m_htiDrop = hitem;
CImageList::DragShowNolock(TRUE);
// kill the timer if selection changed
if( m_nExpandTimer && hitem == m_htiOldDrop )
{
KillTimer( m_nExpandTimer );
m_nExpandTimer = 0;
}
// start the timer again
if( !m_nExpandTimer )
m_nExpandTimer = SetTimer( 1000, EXPAND_TIMER, NULL );
}
}
CTreeCtrl::OnMouseMove(nFlags, point);
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : nFlags -
// point -
//-----------------------------------------------------------------------------
void CGroupList::OnMouseMove(UINT nFlags, CPoint point)
{
CTreeCtrl::OnMouseMove(nFlags, point);
if (m_bRButtonDown && !m_hDragItem && (point.x != m_ptRButtonDown.x) && (point.y != m_ptRButtonDown.y))
{
// First mouse move since a right button down. Start dragging.
HTREEITEM hItem = HitTest(m_ptRButtonDown);
BeginDrag(point, hItem);
}
if (!m_hDragItem)
{
return;
}
if (m_pDragImageList)
{
m_pDragImageList->DragMove(point);
}
//
// Highlight the item we hit.
//
HTREEITEM hItem = HitTest(point);
if (hItem == GetDropHilightItem())
{
return;
}
// hide image first
if (m_pDragImageList)
{
m_pDragImageList->DragLeave(this);
m_pDragImageList->DragShowNolock(FALSE);
}
SelectDropTarget(hItem);
if (m_pDragImageList)
{
m_pDragImageList->DragEnter(this, point);
}
}
void CSharedDirsTreeCtrl::OnLButtonUp(UINT nFlags, CPoint point){
if (m_pDraggingItem != NULL){
CPoint pt;
pt = point;
ClientToScreen(&pt);
TVHITTESTINFO tvhti;
tvhti.pt = pt;
ScreenToClient(&tvhti.pt);
HTREEITEM hItemSel = HitTest(&tvhti);
CDirectoryItem* pDragTarget;
if (hItemSel != NULL && (pDragTarget = (CDirectoryItem*)GetItemData(hItemSel)) != NULL){
//only allow dragging to shared folders
if (pDragTarget->m_eItemType == SDI_DIRECTORY || pDragTarget->m_eItemType == SDI_NO){
CDirectoryItem* pRealDragItem;
HTREEITEM htReal = m_pRootUnsharedDirectries->FindItem(m_pDraggingItem);
// get the original drag src
if (htReal != NULL && (pRealDragItem = (CDirectoryItem*)GetItemData(htReal)) != NULL){
EditSharedDirectories(pRealDragItem, true, false);
}
else{
// item was deleted - no problem as when we dont need to update the visible part
// we can just as well use the contentcopy
EditSharedDirectories(m_pDraggingItem, true, false);
}
}
}
CImageList::DragLeave(NULL);
CImageList::EndDrag();
ReleaseCapture();
ShowCursor(TRUE);
SelectDropTarget(NULL);
delete m_pDraggingItem;
m_pDraggingItem = NULL;
RedrawWindow();
}
CTreeCtrl::OnLButtonUp(nFlags, point);
}
void KGTreeCtrl::OnLButtonUp(UINT nFlags, CPoint point)
{
CTreeCtrl::OnLButtonUp(nFlags, point);
if (m_bDragging)
{
m_bDragging = false;
CImageList::DragLeave(this);
CImageList::EndDrag();
ReleaseCapture();
delete m_pDragImage;
SelectDropTarget(NULL);
m_eMoveType = MOVE_TYPE_CUT;
OnStick((WPARAM)m_hItemDragD, (LPARAM)0);
KillTimer(m_nScrollTimerID);
KillTimer(m_nDrawLineTimerID);
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : pt -
// hItem -
//-----------------------------------------------------------------------------
void CGroupList::BeginDrag(CPoint point, HTREEITEM hItem)
{
m_hDragItem = hItem;
if (m_hDragItem)
{
m_pDragImageList = CreateDragImage(m_hDragItem);
if (m_pDragImageList)
{
CPoint ptHotSpot(0, 0);
m_pDragImageList->BeginDrag(0, ptHotSpot);
m_pDragImageList->DragEnter(this, point);
SelectDropTarget(NULL);
}
// Timer handles scrolling the list control when dragging outside the window bounds.
SetTimer(TIMER_GROUP_DRAG_SCROLL, 300, NULL);
SetCapture();
}
}
void CSiteGroupsTree::OnLButtonUp(UINT flags, CPoint point)
{
CTreeCtrl::OnLButtonUp(flags, point);
if (m_isDragging == false)
return;
// User is dropping an item
m_isDragging = false;
CImageList::DragLeave(this);
CImageList::EndDrag();
ReleaseCapture();
m_dragImageList.reset(0);
SelectDropTarget(0);
// Determine whether dropping the item has an effect
// Here we allow a group to be dropped on itself without any effect and without any
// error message
if ((m_draggedItem == m_droppedItem) || (m_droppedItem == 0))
return;
if (IsDroppableItem(m_draggedItem) == false)
return;
WebWatch::SiteItemGroup & draggedGroup = GetGroupFromItem(m_draggedItem);
WebWatch::SiteItemGroup & droppedGroup = GetGroupFromItem(m_droppedItem);
if (WebWatch::IsChildOf(draggedGroup, droppedGroup) == true) {
GetParent()->MessageBox("Cannot move a group into one of its child groups", "Error", MB_OK | MB_ICONERROR);
return;
}
// Do the actual moving
droppedGroup.MoveGroup(draggedGroup);
BuildTree();
SelectGroup(draggedGroup, true);
}
void CSharedDirsTreeCtrl::OnMouseMove(UINT nFlags, CPoint point)
{
if (m_pDraggingItem != NULL)
{
CPoint pt;
/* drag the item to the current position */
pt = point;
ClientToScreen(&pt);
CImageList::DragMove(pt);
CImageList::DragShowNolock(FALSE);
if (CWnd::WindowFromPoint(pt) != this)
SetCursor(AfxGetApp()->LoadStandardCursor(IDC_NO));
else
{
TVHITTESTINFO tvhti;
tvhti.pt = pt;
ScreenToClient(&tvhti.pt);
HTREEITEM hItemSel = HitTest(&tvhti);
CDirectoryItem* pDragTarget;
if (hItemSel != NULL && (pDragTarget = (CDirectoryItem*)GetItemData(hItemSel)) != NULL){
//only allow dragging to shared folders
if (pDragTarget->m_eItemType == SDI_DIRECTORY || pDragTarget->m_eItemType == SDI_NO){
SetCursor(AfxGetApp()->LoadStandardCursor(IDC_ARROW));
SelectDropTarget(pDragTarget->m_htItem);
}
else
SetCursor(AfxGetApp()->LoadStandardCursor(IDC_NO));
}
else{
SetCursor(AfxGetApp()->LoadStandardCursor(IDC_NO));
}
}
CImageList::DragShowNolock(TRUE);
}
CTreeCtrl::OnMouseMove(nFlags, point);
}
HTREEITEM CEditTreeCtrl::GetDropTarget(EDropHint & hint) {
ASSERT(m_pDragData != 0);
CPoint pt;
GetCursorPos(&pt);
ScreenToClient(&pt);
UINT flags;
HTREEITEM hDrop = HitTest(pt, &flags);
hint = GetDropHint(flags);
m_pDragData->SetDropTarget(hDrop);
if(hDrop) {
m_pDragData->DragLeave(); // allow updates
SelectDropTarget(hDrop);
if(m_pDragData->CheckExpand(hDrop))
Expand(hDrop, TVE_EXPAND);
// Make sure the surrounding items are visible, too
// This will scroll the tree if necessary.
HTREEITEM hPrev = GetPrevVisibleItem(hDrop);
if(hPrev)
EnsureVisible(hPrev);
HTREEITEM hNext = GetNextVisibleItem(hDrop);
if(hNext)
EnsureVisible(hNext);
// if the drop target is a descendent of the dragged item, then
// disallow dropping the item here...
if(IsAncestor(m_pDragData->GetDragItem(), hDrop) || !CanDropItem(m_pDragData->GetDragItem(), hDrop, hint))
hint = DROP_NODROP;
m_pDragData->DragEnter(pt);
} else if(hint != DROP_NODROP && !CanDropItem(m_pDragData->GetDragItem(), hDrop, hint))
hint = DROP_NODROP;
return hDrop;
}
void EXTreeCtrl::OnMouseMove(UINT nFlags, CPoint point)
{
m_bContextMenuActivated = false; // Hack
HTREEITEM hitem;
UINT flags;
if (m_bLDragging)
{
POINT pt = point;
ClientToScreen( &pt );
CImageList::DragMove(pt);
if ((hitem = HitTest(point, &flags)) != NULL)
{
CImageList::DragShowNolock(FALSE);
SelectDropTarget(hitem);
m_hitemDrop = hitem;
CImageList::DragShowNolock(TRUE);
}
}
EXWaitingTreeCtrl::OnMouseMove(nFlags, point);
}
// the timer event for expanding nodes in drag n drop procedure
void CNZProjectTreeCtrl::OnTimer(UINT nIDEvent)
{
if( nIDEvent == m_nExpandTimer )
{
HTREEITEM htiFloat = GetDropHilightItem();
if( htiFloat && htiFloat == m_htiDrop )
{
if( ItemHasChildren( htiFloat ) )
Expand( htiFloat, TVE_EXPAND );
}
}
else if( nIDEvent == m_nScrollTimer )
{
// Doesn't matter that we didn't initialize m_timerticks
m_timerticks++;
POINT pt;
GetCursorPos( &pt );
RECT rect;
GetClientRect( &rect );
ClientToScreen( &rect );
// NOTE: Screen coordinate is being used because the call
// to DragEnter had used the Desktop window.
//CImageList::DragMove(pt);
HTREEITEM hitem = GetFirstVisibleItem();
if( pt.y < rect.top + 10 ) // scroll up
{
// Scroll slowly if cursor near the treeview control
int slowscroll = 6 - (rect.top + 10 - pt.y) / 20;
if( 0 == ( m_timerticks % (slowscroll > 0? slowscroll : 1) ) )
{
CImageList::DragShowNolock(FALSE);
SendMessage( WM_VSCROLL, SB_LINEUP);
SelectDropTarget(hitem);
m_htiDrop = hitem;
CImageList::DragShowNolock(TRUE);
}
}
else if( pt.y > rect.bottom - 10 ) // scroll down
{
// Scroll slowly if cursor near the treeview control
int slowscroll = 6 - (pt.y - rect.bottom + 10 ) / 20;
if( 0 == ( m_timerticks % (slowscroll > 0? slowscroll : 1) ) )
{
CImageList::DragShowNolock(FALSE);
SendMessage( WM_VSCROLL, SB_LINEDOWN);
int nCount = GetVisibleCount();
for ( int i=0; i<nCount-1; ++i )
hitem = GetNextVisibleItem(hitem);
if( hitem )
SelectDropTarget(hitem);
m_htiDrop = hitem;
CImageList::DragShowNolock(TRUE);
}
}
}
CTreeCtrl::OnTimer(nIDEvent);
}
