bitmap_tree.cpp

Go to the documentation of this file.

#ifndef BITMAP_TREE_IMPLEMENTATION_FILE
#define BITMAP_TREE_IMPLEMENTATION_FILE

/*****************************************************************************\
*                                                                             *
*  Name   : bitmap_tree                                                       *
*  Author : came from an article about bitmaps, etc.  cannot locate.          *
*  Mods   : Chris Koeritz                                                     *
*                                                                             *
*******************************************************************************
* Copyright (c) 1998-$now By Author.  This program is free software; you can  *
* redistribute it and/or modify it under the terms of the GNU General Public  *
* License as published by the Free Software Foundation; either version 2 of   *
* the License or (at your option) any later version.  This is online at:      *
*     http://www.fsf.org/copyleft/gpl.html                                    *
* Please send any updates to: fred@gruntose.com                               *
\*****************************************************************************/

#include "bitmap_tree.h"

#include <basis/portable.h>
#include <textual/string_convert.h>

#define KEY_PRESSED 0x8000
#define EVENT_DRAG_SCROLL 1


BEGIN_MESSAGE_MAP(bitmap_tree, CTreeCtrl)
  ON_NOTIFY_REFLECT_EX(TVN_SELCHANGING, OnSelChanging)
  ON_NOTIFY_REFLECT_EX(TVN_ITEMEXPANDED, OnExpanded)
  ON_NOTIFY_REFLECT_EX(TVN_KEYDOWN, OnKey)
  ON_NOTIFY_REFLECT_EX(NM_CLICK, OnClick)
//  ON_NOTIFY_REFLECT_EX(NM_RCLICK, OnRClick)
  ON_NOTIFY_REFLECT_EX(NM_DBLCLK, OnDoubleClick)
  ON_NOTIFY_REFLECT_EX(TVN_BEGINDRAG, OnBeginDrag)
  ON_NOTIFY_REFLECT_EX(TVN_DELETEITEM, OnDelete)
  ON_WM_MOUSEMOVE()
  ON_WM_LBUTTONUP()
  ON_WM_TIMER()
END_MESSAGE_MAP()


// Comparison function for sorting; gives precedence to
// the node image type, then compares strings.
// lparam1 -- any structure, one member of which should be an HTREEITEM
// lparam2 -- any structure, one member of which should be an HTREEITEM
// lparamsort -- the bitmap_tree
// NOTE: the m_itemOffset member of the bitmap_tree should reference the
// place in the structure where the HTREEITEM lies.
int CALLBACK bitmap_tree::NodeTypeCompare(LPARAM lParam1, LPARAM lParam2, LPARAM lParamSort)
{
  bitmap_tree *ctd = (bitmap_tree *)lParamSort;
  if (!ctd) return 0;

  ASSERT(ctd->ItemOffset() != -1);

  HTREEITEM a = (HTREEITEM)(lParam1+ctd->ItemOffset());
  HTREEITEM b = (HTREEITEM)(lParam2+ctd->ItemOffset());

  int aimg = 0, bimg = 0, simg = 0;
  ctd->GetItemImage(b, bimg, simg);
  ctd->GetItemImage(a, aimg, simg);

  if (aimg == bimg) {
    istring sb = from_unicode_temp(ctd->GetItemText(b));
    istring sa = from_unicode_temp(ctd->GetItemText(a));
    return sa == sb;
  } else
    return aimg - bimg;
}

bool bitmap_tree::ClearSelection(bitmap_tree *bt, HTREEITEM h, LPARAM l)
{
  if (bt->GetSelectedItem() != h)
    bt->SelectAnotherItem(h, false);

  return true;
}

// Turn off selection of items which are not draggable.
bool bitmap_tree::PrepareDrag(bitmap_tree *bt, HTREEITEM h, LPARAM l)
{
  if (bt->GetSelectedItem() == h)
    bt->SelectAnotherItem(h, true);
  else {
    int img = 0, simg = 0;
    bt->GetItemImage(h, img, simg);
    if (!bt->IsDraggable(h, img))
      bt->SelectAnotherItem(h, false);
  }

  return true;
}

// Create a new tree item as a child of the target item.
// Delete the original.
bool MoveTreeItemCB(bitmap_tree *bt, HTREEITEM h, LPARAM l)
{
  HTREEITEM target = (HTREEITEM)l;
  TV_INSERTSTRUCT tvis;

  // valid target
  if (!target) return false;

  // get item info
  memset(&tvis, 0, sizeof(tvis));
  tvis.item.mask = (TVIF_IMAGE | TVIF_SELECTEDIMAGE | TVIF_PARAM | TVIF_STATE);
  tvis.item.hItem = h;
  bt->GetItem(&tvis.item);

  // dropping on top of itself?
  if ((bt->GetParentItem(h) == target) ||
      !(bt->IsDraggable(h, tvis.item.iImage)))
    return true;

  // get item text
  istring s = string_convert::to_istring(bt->GetItemText(h));
  to_unicode_persist(temp_s, s);
  tvis.item.pszText = temp_s;
  tvis.item.mask |= TVIF_TEXT;

  // move node
  bt->DeleteItem(h);
  tvis.hParent= target;
  tvis.hInsertAfter= TVI_LAST;
  bt->InsertItem(&tvis);

  return true;
}


bitmap_tree::bitmap_tree()
: m_numOverlays(0),
  m_itemOffset(-1),
  m_sStateImage(0, 0),
  m_sNormalImage(0, 0),
  m_ilNormal(),
  m_ilState(),
  m_toggle(0),
  m_overlaySet(false),
  m_multiSet(false),
  m_multiSelected(0),
  m_canChangeSel(true),
  m_lastSelected(NIL),
  m_firstKey(0),
  m_dragFunction(NIL),
  m_dragList(NIL),
  m_draggable(0),
  m_dropTarget(0),
  m_xDrag(0),
  m_docDrag(0),
  m_multiDrag(0)
{
  memset(&m_sortcb, 0, sizeof(m_sortcb));
}

bitmap_tree::~bitmap_tree()
{
  m_ilNormal.DeleteImageList();
  m_ilState.DeleteImageList();
}

void bitmap_tree::SetExpandable(int base)
{
  ASSERT(base < (sizeof(m_toggle)*8 -1));
  m_toggle|= (1UL << base);
}

bool bitmap_tree::IsExpandable(int base)
{
  ASSERT(base < (sizeof(m_toggle)*8 -1));
  return m_toggle & (1UL << base);
}

void bitmap_tree::SetDraggable(int base)
{
  ASSERT(base < (sizeof(m_draggable)*8 -1));
  m_draggable |= (1UL << base);
}

bool bitmap_tree::IsDraggable(HTREEITEM h, int base)
{
  ASSERT(base < (sizeof(m_draggable)*8 -1));
  return m_draggable & (1UL << base);
}

void bitmap_tree::SetDropTarget(int base)
{
  ASSERT(base < (sizeof(m_dropTarget)*8 -1));
  m_dropTarget |= (1UL << base);
}

bool bitmap_tree::IsDropTarget(HTREEITEM h, int base)
{
  ASSERT(base < (sizeof(m_dropTarget)*8 -1));
  return m_dropTarget & (1UL << base);
}

void bitmap_tree::SetMultiSelect(bool b)
{
  if (!b)
    ClearMultiSelect();
  m_multiSet = b;
}

// Call this function to add images to the TVSIL_NORMAL ImageList.
int bitmap_tree::SetNormalImages(UINT bitmap, int number, COLORREF mask)
{
  CBitmap b;
  int num = 0;

  // load bitmap
  HBITMAP hb = LoadBitmap(AfxGetInstanceHandle(), MAKEINTRESOURCE(bitmap));

  BITMAP bi;
  GetObject(hb, sizeof(BITMAP), &bi);
  ASSERT((bi.bmWidth % number) == 0);
  if (m_sNormalImage.cx == 0) {
    m_sNormalImage.cx= (bi.bmWidth/number);
    m_sNormalImage.cy= bi.bmHeight;
    m_ilNormal.Create(m_sNormalImage.cx, m_sNormalImage.cy, true, number,
        number);
    SetImageList(&m_ilNormal, TVSIL_NORMAL);
  }
  ASSERT(m_sNormalImage.cx == (bi.bmWidth/number));
  ASSERT(m_sNormalImage.cy == bi.bmHeight);

  // add images
  b.Attach(hb);
  num= m_ilNormal.Add(&b, mask);
  b.DeleteObject();

  return num;
}

// Call this function to add images to the overlay list.  The
// index of the first overlay will be m_overlay1.  You must call
// SetNormalImages at least once before calling this function in order
// to initialize m_sNormalImage.  This function can only be called once.
int bitmap_tree::SetOverlayImages(UINT bitmap, COLORREF mask)
{
  int i = 0;
  CBitmap b;
  int num = 0;

  // number of images in the list before we add the overlays
  int numNormals = m_ilNormal.GetImageCount();

  ASSERT(!m_overlaySet && numNormals);
  if (m_overlaySet || !numNormals) return common::BAD_INPUT;
  m_overlaySet= true;

  // load bitmap
  HBITMAP hb = LoadBitmap(AfxGetInstanceHandle(), MAKEINTRESOURCE(bitmap));

  BITMAP obi;
  GetObject(hb, sizeof(BITMAP), &obi);

  // assert that overlay images are the same size as normal images and that there are
  // fewer than four of them (which is the maximum allowed by Windows)
  ASSERT((obi.bmWidth % m_sNormalImage.cx) == 0);
  ASSERT(obi.bmHeight == m_sNormalImage.cy);
  m_numOverlays= (obi.bmWidth / m_sNormalImage.cx);
  ASSERT(m_numOverlays <= 4);

  // add images to the normal list
  b.Attach(hb);
  num= m_ilNormal.Add(&b, mask);
  b.DeleteObject();

  // designate these images as overlays
  for(i= 0; i< m_numOverlays; i++)
    m_ilNormal.SetOverlayImage((numNormals+m_overlay1+i)-1, m_overlay1+i);

  return num;
}

// SetStateImages
// Call this function to add images to the TVSIL_STATE list.
int bitmap_tree::SetStateImages(UINT bitmap, int number, COLORREF mask)
{
  BITMAP bi;
  HBITMAP hb;
  CBitmap b;
  int num;

  // load bitmap
  hb= LoadBitmap(AfxGetInstanceHandle(),
                 MAKEINTRESOURCE(bitmap));
  GetObject(hb, sizeof(BITMAP), &bi);
  ASSERT((bi.bmWidth % number) == 0);
  if (m_sStateImage.cx == 0)
  {
    m_sStateImage.cx= (bi.bmWidth/number);
    m_sStateImage.cy= bi.bmHeight;
    m_ilState.Create(m_sStateImage.cx, m_sStateImage.cy, true, number, number);
    SetImageList(&m_ilState, TVSIL_STATE);
  }
  ASSERT(m_sStateImage.cx == (bi.bmWidth/number));
  ASSERT(m_sStateImage.cy == bi.bmHeight);

  // add images
  b.Attach(hb);
  num= m_ilState.Add(&b, mask);
  b.DeleteObject();

  return num;
}

HTREEITEM bitmap_tree::GetItemUnderMouse(TV_HITTESTINFO *tvhti)
{
  CPoint p;
  DWORD dwpos;

  // where did we hit?
  dwpos = GetMessagePos();
  p.x = LOWORD(dwpos);
  p.y = HIWORD(dwpos);
  ScreenToClient(&p);

  if (tvhti)
  {
    tvhti->pt= p;
    return HitTest(tvhti);
  }
  else
  {
    UINT f;
    return HitTest(p, &f);
  }
}

// For each item with the state TVIS_SELECTED, call the
// specified function.
bool bitmap_tree::DoForAllSelected(TREE_CALLBACK func, HTREEITEM hitem,
    LPARAM l)
{
  HTREEITEM child, sibling;
  bool proceed= true;

  // ensure hitem is nonnull
  if (hitem == NULL)
    hitem= GetRootItem();
  if (hitem == NULL)
    return false;

  // iterate through children and siblings
  while (hitem)
  {
    child= GetChildItem(hitem);
    if (child != NULL)
    {
      proceed= DoForAllSelected(func, child, l);
      if (!proceed)
        return proceed;
    }

    // get sibling item
    sibling= GetNextSiblingItem(hitem);

    // call function
    if (IsSelected(hitem))
    {
      SetSelChange(false);
      proceed= func(this, hitem, l);
      SetSelChange(true);

      if (!proceed)
        return proceed;
    }

    hitem= sibling;
  }

  return true;
}

// Clear TVIS_SELECTED from all item states except the item
// returned by GetSelectedItem()
void bitmap_tree::ClearMultiSelect()
{
  if (!m_multiSet || !m_multiSelected)
    return;

  m_lastSelected= NULL;
  DoForAllSelected(ClearSelection, NULL, 0);
  m_multiSelected= false;
}

// Select only the visible items appearring between
// h1 and h3.
void bitmap_tree::SelectRange(HTREEITEM h1, HTREEITEM h2)
{
  HTREEITEM p= GetRootItem(), endrange;

  if ((h1 == NULL) || (h2 == NULL) || !m_multiSet)
    return;

  // mark as unselected
  while ((p != h1) && (p != h2) && (p != NULL))
  {
    SelectAnotherItem(p, false);
    p= GetNextVisibleItem(p);
  }

  if (p == NULL)
    return;

  (p == h1)?endrange= h2:endrange= h1;

  // mark as selected
  while ((p != endrange) && (p != NULL))
  {
    SelectAnotherItem(p, true);
    p= GetNextVisibleItem(p);
  }

  // mark as unselected
  while (p != NULL)
  {
    SelectAnotherItem(p, false);
    p= GetNextVisibleItem(p);
  }

  SelectAnotherItem(h1, true);
  SelectAnotherItem(h2, true);
}

// Sets/unsets the TVIS_SELECTED state for an item.
void bitmap_tree::SelectAnotherItem(HTREEITEM h, bool select)
{
  bool selected= IsSelected(h);

  if (!m_multiSet)
    return;

  if (select && !selected)
  {
    m_multiSelected= true;
    SetItemState(h, TVIS_SELECTED, TVIS_SELECTED);
  }
  else if (!select && selected)
  {
    SetItemState(h, 0, TVIS_SELECTED);
  }
}

void bitmap_tree::SetSortFunction(PFNTVCOMPARE func, LPARAM l)
{
  m_sortcb.lpfnCompare= func;
  m_sortcb.lParam= l;
}

// Set up a sort callback function which will sort by image first, name second.
void bitmap_tree::SetDocumentSortFunction(int offset)
{
  SetSortFunction(NodeTypeCompare, (LPARAM)this);

  m_itemOffset= offset;
}

// Sorts all descendants of a node (not just the immediate
// children like SortChildren does).
void bitmap_tree::SortTree(HTREEITEM hitem)
{
  HTREEITEM child;

  if (hitem == NULL)
  {
    if (m_sortcb.lpfnCompare)
    {
      m_sortcb.hParent= NULL;
      SortChildrenCB(&m_sortcb);
    }
    else
      SortChildren(NULL);
    hitem= GetRootItem();
  }

  while (hitem != NULL)
  {
    if (m_sortcb.lpfnCompare)
    {
      m_sortcb.hParent= hitem;
      SortChildrenCB(&m_sortcb);
    }
    else
      SortChildren(hitem);

    child= GetChildItem(hitem);
    if (child != NULL)
      SortTree(child);
    hitem= GetNextSiblingItem(hitem);
  }

  return;
}

void bitmap_tree::ToggleTree(UINT code, HTREEITEM hitem)
{
  if (hitem == NULL)
    hitem= GetRootItem();

  while (hitem != NULL)
  {
    if (ItemHasChildren(hitem))
    {
      HTREEITEM child;

      Expand(hitem, code);
      child= GetChildItem(hitem);
      if (child)
        ToggleTree(code, child);
    }
    hitem= GetNextSiblingItem(hitem);
  }
}

// change image when expanded
BOOL bitmap_tree::OnExpanded(NMHDR* pNMHDR, LRESULT* pResult)
{
  NM_TREEVIEW* pNMTreeView = (NM_TREEVIEW*)pNMHDR;
  TV_ITEM *tv= &pNMTreeView->itemNew;
  bool expand= (tv->state & TVIS_EXPANDED);
  int img = 0, simg = 0, offset = 0;

  if ((GetNormalImageCount() == 0) ||
      (m_toggle == 0) ||
      !(GetItemImage(tv->hItem, img, simg)))
    return false;

  offset= (expand)?0:-1;

  // can the base version of this image be toggled?
  if ((img+offset < 0) ||
      !(IsExpandable(img+offset)))
    return false;

  offset= (expand)?1:-1;

  // set the image to its companion
  SetItemImage(tv->hItem, img+offset, img+offset);

  *pResult = 0;
  return false;
}

// called when item selection changes
// setting pResult to false allows the selection to change, true prevents it
BOOL bitmap_tree::OnSelChanging(NMHDR* pNMHDR, LRESULT *pResult)
{
  *pResult= 0;

  if (!(m_canChangeSel) ||
      (m_multiSet &&
       ((GetAsyncKeyState(VK_CONTROL) & KEY_PRESSED) ||
        (GetAsyncKeyState(VK_SHIFT) & KEY_PRESSED))))
    *pResult= 1;

  return (BOOL)*pResult;
}

// called when key is pressed
BOOL bitmap_tree::OnKey(NMHDR* pNMHDR, LRESULT* pResult)
{
  TV_KEYDOWN *tvk= (TV_KEYDOWN *) pNMHDR;
  HTREEITEM hitem= GetSelectedItem(), newselect;
  bool down= (tvk->wVKey == VK_DOWN);

  if (!m_multiSet ||
      (hitem == NULL) ||
      (!down && (tvk->wVKey != VK_UP)))
    return false;

  if (GetAsyncKeyState(VK_SHIFT) & KEY_PRESSED)
  {
    if (m_lastSelected == NULL)
    {
      ClearMultiSelect();
      m_lastSelected= hitem;
      m_firstKey= tvk->wVKey;
    }

    if (down)
      newselect= GetNextItem(m_lastSelected, TVGN_NEXTVISIBLE);
    else
      newselect= GetNextItem(m_lastSelected, TVGN_PREVIOUSVISIBLE);
    if (newselect == NULL)
      return false;

    if ((m_firstKey != tvk->wVKey) && (IsSelected(m_lastSelected)))
      SelectAnotherItem(m_lastSelected, false);
    else if (newselect != hitem)
      SelectAnotherItem(newselect, (m_firstKey == tvk->wVKey));

    int err= EnsureVisible(newselect);

    if (newselect == hitem)
      m_lastSelected= NULL;
    else
      m_lastSelected= newselect;
  }
  else
    ClearMultiSelect();

  return false;
}

// called when item is clicked upon
BOOL bitmap_tree::OnClick(NMHDR* pNMHDR, LRESULT* pResult)
{
  bool shift= (GetAsyncKeyState(VK_SHIFT) & KEY_PRESSED);
  HTREEITEM hitem;

  // clear multiselection
  if (!m_multiSet ||
      (!(shift) &&
       !(GetAsyncKeyState(VK_CONTROL) & KEY_PRESSED)))
  {
    ClearMultiSelect();
    return false;
  }

  // do multiselection
  hitem= GetItemUnderMouse();
  if (shift) {
    HTREEITEM hselected= GetSelectedItem();

    if (hselected)
      SelectRange(hitem, hselected);
  } else
    SelectAnotherItem(hitem, !(IsSelected(hitem)));

  return false;
}

/*
BOOL bitmap_tree::OnRClick(NMHDR* pNMHDR, LRESULT* pResult)
{
  if (!(GetAsyncKeyState(VK_SHIFT) & KEY_PRESSED) &&
      !(GetAsyncKeyState(VK_CONTROL) & KEY_PRESSED))
    ClearMultiSelect();
  *pResult = 0;
  return false;
}
*/

BOOL bitmap_tree::OnDoubleClick(NMHDR *pNMHDR, LRESULT *pResult)
{
  ClearMultiSelect();
  *pResult = 0;
  return false;
}

BOOL bitmap_tree::OnDelete(NMHDR* pNMHDR, LRESULT* pResult)
{
  NM_TREEVIEW* pNMTreeView = (NM_TREEVIEW*)pNMHDR;
  HTREEITEM h;

  if (!(m_canChangeSel)) {
    h= pNMTreeView->itemOld.hItem;
    m_postSelect= GetNextSiblingItem(h);
    if (m_postSelect == NULL)
      m_postSelect= GetPrevSiblingItem(h);
    if (m_postSelect == NULL)
      m_postSelect= GetParentItem(h);
  }

  *pResult= 0;
  return false;
}

void bitmap_tree::OnLButtonUp(UINT nFlags, CPoint point)
{
  if (m_dragList)
  {
    HTREEITEM target;

    KillTimer(EVENT_DRAG_SCROLL);

    ReleaseCapture();
    m_dragList->EndDrag();
    ShowCursor(true);

    m_dragList= NULL;

    if ((target = GetDropHilightItem()) != NULL)
    {
      DoForAllSelected(m_dragFunction, NULL, (LPARAM) target);

      SelectDropTarget(NULL);
      SelectItem(target);
    }

    ClearMultiSelect();
  }

  CTreeCtrl::OnLButtonUp(nFlags, point);
}

BOOL bitmap_tree::OnBeginDrag(NMHDR* pNMHDR, LRESULT* pResult)
{
  NM_TREEVIEW* pNMTreeView = (NM_TREEVIEW*)pNMHDR;
  HTREEITEM h= pNMTreeView->itemNew.hItem;
  int img, simg;
  CPoint point;

  if ((m_dragFunction == NULL) ||
      (h == NULL))
    return false;

  ASSERT(GetNormalImageCount());

  if (m_multiSelected)
  {
    // turn off selection of nodes that can't be dragged
    DoForAllSelected(PrepareDrag, NULL, 0);
  }
  else
  {
    // if we have started dragging an unselected item, we need to complete
    // the selection change before dragging it
    SelectItem(h);
  }

  // can we drag this node?
  GetItemImage(h, img, simg);
  if (!(IsDraggable(h, img)))
    return false;

  // set up drag list
  if (m_ilDrag.m_hImageList != NULL)
    m_dragList= &m_ilDrag;
  else
  {
    m_dragList= CreateDragImage(h);
    if (m_dragList == NULL)
      return false;
  }

  if (m_multiSelected)
    m_dragList->BeginDrag(m_multiDrag, CPoint(0,0));
  else
    m_dragList->BeginDrag(m_docDrag, CPoint(0,0));

  MapWindowPoints(NULL, &pNMTreeView->ptDrag, 1);
  m_dragList->DragEnter(NULL, pNMTreeView->ptDrag);

  ShowCursor(false);
  SetCapture();

  // allow scrolling to occur while dragging
  start_timer();

  *pResult= 0;
  return false;
}

void bitmap_tree::start_timer()
{
  SetTimer(EVENT_DRAG_SCROLL, 250, NULL);
}

void bitmap_tree::stop_timer()
{
  KillTimer(EVENT_DRAG_SCROLL);
}

void bitmap_tree::OnTimer(UINT nIDEvent)
{
  switch (nIDEvent) {
    case EVENT_DRAG_SCROLL: {
      stop_timer();
      CRect r, itemr;
      CPoint point;
      HTREEITEM h;

      if (!m_dragList) {
        start_timer();
        return;
      }

      // get dimensions
      GetCursorPos(&point);
      GetClientRect(&r);
      ClientToScreen(&r);

      h= GetFirstVisibleItem();
      if (!h) {
        start_timer();
        return;
      }

      // scroll the tree control window
      if (point.y > r.bottom) {
        h= GetNextVisibleItem(h);
        if (h) {
          m_dragList->DragLeave(NULL);
          SelectSetFirstVisible(h);
          UpdateWindow();
          m_dragList->DragEnter(NULL, point);
        }
      } else if (point.y < r.top) {
        h= GetPrevVisibleItem(h);
        if (h) {
          m_dragList->DragLeave(NULL);
          SelectSetFirstVisible(h);
          UpdateWindow();
          m_dragList->DragEnter(NULL, point);
        }
      }

      start_timer();
      break;
    }
    default: {
//pass to base class?  ignore?  currently ignoring.
      break;
    }
  }
}

void bitmap_tree::OnMouseMove(UINT nFlags, CPoint point)
{
  if (m_dragList) {
    bool target_set= false, has_drag_images= (m_ilDrag.m_hImageList != NULL);
    HTREEITEM target;
    CPoint screen= point;

    MapWindowPoints(NULL, &screen, 1);

    // which item are we over?
    if ((target = GetItemUnderMouse()) != NULL)
    {
      int img, simg;

      if (has_drag_images)
      {
        if (m_multiSelected)
          m_dragList->SetDragCursorImage(m_multiDrag, CPoint(0,0));
        else
          m_dragList->SetDragCursorImage(m_docDrag, CPoint(0,0));
      }

      while (target)
      {
        GetItemImage(target, img, simg);
        if (IsDropTarget(target, img))
        {
          m_dragList->DragLeave(NULL);
          SelectDropTarget(target);
          m_dragList->DragEnter(NULL, screen);
          target_set= true;
          break;
        }
        target= GetParentItem(target);
      }
    }
    else
    {
      // not over a valid area
      if (has_drag_images)
        m_dragList->SetDragCursorImage(m_xDrag, CPoint(0,0));
    }

    if (!(target_set))
    {
      m_dragList->DragLeave(NULL);
      SelectDropTarget(NULL);
      m_dragList->DragEnter(NULL, screen);
    }

  }

  CTreeCtrl::OnMouseMove(nFlags, point);
}


#endif //BITMAP_TREE_IMPLEMENTATION_FILE

---