git.oblomov.eu Git - wine/blob - dlls/comctl32/treeview.c

   1 /* Treeview control
   2  *
   3  * Copyright 1998 Eric Kohl <ekohl@abo.rhein-zeitung.de>
   4  * Copyright 1998,1999 Alex Priem <alexp@sci.kun.nl>
   5  * Copyright 1999 Sylvain St-Germain
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20  *
  21  * Note that TREEVIEW_INFO * and HTREEITEM are the same thing.
  22  *
  23  * Note2: All items always! have valid (allocated) pszText field.
  24  *      If item's text == LPSTR_TEXTCALLBACKA we allocate buffer
  25  *      of size TEXT_CALLBACK_SIZE in DoSetItem.
  26  *      We use callbackMask to keep track of fields to be updated.
  27  *
  28  * TODO:
  29  *   missing notifications: NM_SETCURSOR, TVN_GETINFOTIP, TVN_KEYDOWN,
  30  *      TVN_SETDISPINFO, TVN_SINGLEEXPAND
  31  *
  32  *   missing styles: TVS_FULLROWSELECT, TVS_INFOTIP, TVS_NOSCROLL,
  33  *      TVS_RTLREADING, TVS_TRACKSELECT
  34  *
  35  *   missing item styles: TVIS_CUT, TVIS_EXPANDPARTIAL
  36  *
  37  *   Make the insertion mark look right.
  38  *   Scroll (instead of repaint) as much as possible.
  39  */
  40
  41 #include <assert.h>
  42 #include <ctype.h>
  43 #include <string.h>
  44 #include <limits.h>
  45 #include <stdlib.h>
  46
  47 #include "winbase.h"
  48 #include "wingdi.h"
  49 #include "commctrl.h"
  50 #include "comctl32.h"
  51 #include "wine/debug.h"
  52
  53 /* internal structures */
  54
  55 typedef struct _TREEITEM    /* HTREEITEM is a _TREEINFO *. */
  56 {
  57   UINT      callbackMask;
  58   UINT      state;
  59   UINT      stateMask;
  60   LPSTR     pszText;
  61   int       cchTextMax;
  62   int       iImage;
  63   int       iSelectedImage;
  64   int       cChildren;
  65   LPARAM    lParam;
  66   int       iIntegral;      /* item height multiplier (1 is normal) */
  67   int       iLevel;         /* indentation level:0=root level */
  68   HTREEITEM parent;         /* handle to parent or 0 if at root */
  69   HTREEITEM firstChild;     /* handle to first child or 0 if no child */
  70   HTREEITEM lastChild;
  71   HTREEITEM prevSibling;    /* handle to prev item in list, 0 if first */
  72   HTREEITEM nextSibling;    /* handle to next item in list, 0 if last */
  73   RECT      rect;
  74   LONG      linesOffset;
  75   LONG      stateOffset;
  76   LONG      imageOffset;
  77   LONG      textOffset;
  78   LONG      textWidth;      /* horizontal text extent for pszText */
  79   LONG      visibleOrder;   /* visible ordering, 0 is first visible item */
  80 } TREEVIEW_ITEM;
  81
  82
  83 typedef struct tagTREEVIEW_INFO
  84 {
  85   HWND          hwnd;
  86   HWND          hwndNotify;     /* Owner window to send notifications to */
  87   DWORD         dwStyle;
  88   HTREEITEM     root;
  89   UINT          uInternalStatus;
  90   INT           Timer;
  91   UINT          uNumItems;      /* number of valid TREEVIEW_ITEMs */
  92   INT           cdmode;         /* last custom draw setting */
  93   UINT          uScrollTime;    /* max. time for scrolling in milliseconds */
  94   BOOL          bRedraw;        /* if FALSE we validate but don't redraw in TREEVIEW_Paint() */
  95
  96   UINT          uItemHeight;    /* item height */
  97   BOOL          bHeightSet;
  98
  99   LONG          clientWidth;    /* width of control window */
 100   LONG          clientHeight;   /* height of control window */
 101
 102   LONG          treeWidth;      /* width of visible tree items */
 103   LONG          treeHeight;     /* height of visible tree items */
 104
 105   UINT          uIndent;        /* indentation in pixels */
 106   HTREEITEM     selectedItem;   /* handle to selected item or 0 if none */
 107   HTREEITEM     hotItem;        /* handle currently under cursor, 0 if none */
 108   HTREEITEM     focusedItem;    /* item that was under the cursor when WM_LBUTTONDOWN was received */
 109
 110   HTREEITEM     firstVisible;   /* handle to first visible item */
 111   LONG          maxVisibleOrder;
 112   HTREEITEM     dropItem;       /* handle to item selected by drag cursor */
 113   HTREEITEM     insertMarkItem; /* item after which insertion mark is placed */
 114   BOOL          insertBeforeorAfter; /* flag used by TVM_SETINSERTMARK */
 115   HIMAGELIST    dragList;       /* Bitmap of dragged item */
 116   LONG          scrollX;
 117   COLORREF      clrBk;
 118   COLORREF      clrText;
 119   COLORREF      clrLine;
 120   COLORREF      clrInsertMark;
 121   HFONT         hFont;
 122   HFONT         hBoldFont;
 123   HWND          hwndToolTip;
 124
 125   HWND          hwndEdit;
 126   WNDPROC       wpEditOrig;     /* orig window proc for subclassing edit */
 127   BOOL          bIgnoreEditKillFocus;
 128   BOOL          bLabelChanged;
 129
 130   BOOL          bNtfUnicode;    /* TRUE if should send NOTIFY with W */
 131   BOOL          bUnicode;       /* set by CCM_SETUNICODEFORMAT       */
 132   HIMAGELIST    himlNormal;
 133   int           normalImageHeight;
 134   int           normalImageWidth;
 135   HIMAGELIST    himlState;
 136   int           stateImageHeight;
 137   int           stateImageWidth;
 138   HDPA          items;
 139
 140   DWORD lastKeyPressTimestamp; /* Added */
 141   WPARAM charCode; /* Added */
 142   INT nSearchParamLength; /* Added */
 143   CHAR szSearchParam[ MAX_PATH ]; /* Added */
 144 } TREEVIEW_INFO;
 145
 146
 147 /******** Defines that TREEVIEW_ProcessLetterKeys uses ****************/
 148 #define KEY_DELAY       450
 149
 150 /* bitflags for infoPtr->uInternalStatus */
 151
 152 #define TV_HSCROLL      0x01    /* treeview too large to fit in window */
 153 #define TV_VSCROLL      0x02    /* (horizontal/vertical) */
 154 #define TV_LDRAG                0x04    /* Lbutton pushed to start drag */
 155 #define TV_LDRAGGING    0x08    /* Lbutton pushed, mouse moved. */
 156 #define TV_RDRAG                0x10    /* dito Rbutton */
 157 #define TV_RDRAGGING    0x20
 158
 159 /* bitflags for infoPtr->timer */
 160
 161 #define TV_EDIT_TIMER    2
 162 #define TV_EDIT_TIMER_SET 2
 163
 164
 165 VOID TREEVIEW_Register (VOID);
 166 VOID TREEVIEW_Unregister (VOID);
 167
 168
 169 WINE_DEFAULT_DEBUG_CHANNEL(treeview);
 170
 171
 172 #define TEXT_CALLBACK_SIZE 260
 173
 174 #define TREEVIEW_LEFT_MARGIN 8
 175
 176 #define MINIMUM_INDENT 19
 177
 178 #define CALLBACK_MASK_ALL (TVIF_TEXT|TVIF_CHILDREN|TVIF_IMAGE|TVIF_SELECTEDIMAGE)
 179
 180 #define STATEIMAGEINDEX(x) (((x) >> 12) & 0x0f)
 181 #define OVERLAYIMAGEINDEX(x) (((x) >> 8) & 0x0f)
 182 #define ISVISIBLE(x)         ((x)->visibleOrder >= 0)
 183
 184
 185 typedef VOID (*TREEVIEW_ItemEnumFunc)(TREEVIEW_INFO *, TREEVIEW_ITEM *,LPVOID);
 186
 187
 188 static VOID TREEVIEW_Invalidate(TREEVIEW_INFO *, TREEVIEW_ITEM *);
 189
 190 static LRESULT TREEVIEW_DoSelectItem(TREEVIEW_INFO *, INT, HTREEITEM, INT);
 191 static VOID TREEVIEW_SetFirstVisible(TREEVIEW_INFO *, TREEVIEW_ITEM *, BOOL);
 192 static LRESULT TREEVIEW_EnsureVisible(TREEVIEW_INFO *, HTREEITEM, BOOL);
 193 static LRESULT TREEVIEW_RButtonUp(TREEVIEW_INFO *, LPPOINT);
 194 static LRESULT TREEVIEW_EndEditLabelNow(TREEVIEW_INFO *infoPtr, BOOL bCancel);
 195 static VOID TREEVIEW_UpdateScrollBars(TREEVIEW_INFO *infoPtr);
 196 static LRESULT TREEVIEW_HScroll(TREEVIEW_INFO *, WPARAM);
 197 static LRESULT TREEVIEW_NotifyFormat (TREEVIEW_INFO *infoPtr, WPARAM wParam, LPARAM lParam);
 198
 199
 200 /* Random Utilities *****************************************************/
 201
 202 #ifndef NDEBUG
 203 static inline void
 204 TREEVIEW_VerifyTree(TREEVIEW_INFO *infoPtr)
 205 {
 206     (void)infoPtr;
 207 }
 208 #else
 209 /* The definition is at the end of the file. */
 210 static void TREEVIEW_VerifyTree(TREEVIEW_INFO *infoPtr);
 211 #endif
 212
 213 /* Returns the treeview private data if hwnd is a treeview.
 214  * Otherwise returns an undefined value. */
 215 static TREEVIEW_INFO *
 216 TREEVIEW_GetInfoPtr(HWND hwnd)
 217 {
 218     return (TREEVIEW_INFO *)GetWindowLongA(hwnd, 0);
 219 }
 220
 221 /* Don't call this. Nothing wants an item index. */
 222 static inline int
 223 TREEVIEW_GetItemIndex(TREEVIEW_INFO *infoPtr, HTREEITEM handle)
 224 {
 225     assert(infoPtr != NULL);
 226
 227     return DPA_GetPtrIndex(infoPtr->items, handle);
 228 }
 229
 230 /***************************************************************************
 231  * This method checks that handle is an item for this tree.
 232  */
 233 static BOOL
 234 TREEVIEW_ValidItem(TREEVIEW_INFO *infoPtr, HTREEITEM handle)
 235 {
 236     if (TREEVIEW_GetItemIndex(infoPtr, handle) == -1)
 237     {
 238         TRACE("invalid item %p\n", handle);
 239         return FALSE;
 240     }
 241     else
 242         return TRUE;
 243 }
 244
 245 static HFONT
 246 TREEVIEW_CreateBoldFont(HFONT hOrigFont)
 247 {
 248     LOGFONTA font;
 249
 250     GetObjectA(hOrigFont, sizeof(font), &font);
 251     font.lfWeight = FW_BOLD;
 252     return CreateFontIndirectA(&font);
 253 }
 254
 255 static inline HFONT
 256 TREEVIEW_FontForItem(TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *item)
 257 {
 258     return (item->state & TVIS_BOLD) ? infoPtr->hBoldFont : infoPtr->hFont;
 259 }
 260
 261 /* for trace/debugging purposes only */
 262 static const char *
 263 TREEVIEW_ItemName(TREEVIEW_ITEM *item)
 264 {
 265     if (item == NULL) return "<null item>";
 266     if (item->pszText == LPSTR_TEXTCALLBACKA) return "<callback>";
 267     if (item->pszText == NULL) return "<null>";
 268     return item->pszText;
 269 }
 270
 271 /* An item is not a child of itself. */
 272 static BOOL
 273 TREEVIEW_IsChildOf(TREEVIEW_ITEM *parent, TREEVIEW_ITEM *child)
 274 {
 275     do
 276     {
 277         child = child->parent;
 278         if (child == parent) return TRUE;
 279     } while (child != NULL);
 280
 281     return FALSE;
 282 }
 283
 284
 285 /* Tree Traversal *******************************************************/
 286
 287 /***************************************************************************
 288  * This method returns the last expanded sibling or child child item
 289  * of a tree node
 290  */
 291 static TREEVIEW_ITEM *
 292 TREEVIEW_GetLastListItem(TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *wineItem)
 293 {
 294     if (!wineItem)
 295        return NULL;
 296
 297     while (wineItem->lastChild)
 298     {
 299        if (wineItem->state & TVIS_EXPANDED)
 300           wineItem = wineItem->lastChild;
 301        else
 302           break;
 303     }
 304
 305     if (wineItem == infoPtr->root)
 306         return NULL;
 307
 308     return wineItem;
 309 }
 310
 311 /***************************************************************************
 312  * This method returns the previous non-hidden item in the list not
 313  * considering the tree hierarchy.
 314  */
 315 static TREEVIEW_ITEM *
 316 TREEVIEW_GetPrevListItem(TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *tvItem)
 317 {
 318     if (tvItem->prevSibling)
 319     {
 320         /* This item has a prevSibling, get the last item in the sibling's tree. */
 321         TREEVIEW_ITEM *upItem = tvItem->prevSibling;
 322
 323         if ((upItem->state & TVIS_EXPANDED) && upItem->lastChild != NULL)
 324             return TREEVIEW_GetLastListItem(infoPtr, upItem->lastChild);
 325         else
 326             return upItem;
 327     }
 328     else
 329     {
 330         /* this item does not have a prevSibling, get the parent */
 331         return (tvItem->parent != infoPtr->root) ? tvItem->parent : NULL;
 332     }
 333 }
 334
 335
 336 /***************************************************************************
 337  * This method returns the next physical item in the treeview not
 338  * considering the tree hierarchy.
 339  */
 340 static TREEVIEW_ITEM *
 341 TREEVIEW_GetNextListItem(TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *tvItem)
 342 {
 343     assert(tvItem != NULL);
 344
 345     /*
 346      * If this item has children and is expanded, return the first child
 347      */
 348     if ((tvItem->state & TVIS_EXPANDED) && tvItem->firstChild != NULL)
 349     {
 350         return tvItem->firstChild;
 351     }
 352
 353
 354     /*
 355      * try to get the sibling
 356      */
 357     if (tvItem->nextSibling)
 358         return tvItem->nextSibling;
 359
 360     /*
 361      * Otherwise, get the parent's sibling.
 362      */
 363     while (tvItem->parent)
 364     {
 365         tvItem = tvItem->parent;
 366
 367         if (tvItem->nextSibling)
 368             return tvItem->nextSibling;
 369     }
 370
 371     return NULL;
 372 }
 373
 374 /***************************************************************************
 375  * This method returns the nth item starting at the given item.  It returns
 376  * the last item (or first) we we run out of items.
 377  *
 378  * Will scroll backward if count is <0.
 379  *             forward if count is >0.
 380  */
 381 static TREEVIEW_ITEM *
 382 TREEVIEW_GetListItem(TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *wineItem,
 383                      LONG count)
 384 {
 385     TREEVIEW_ITEM *(*next_item)(TREEVIEW_INFO *, TREEVIEW_ITEM *);
 386     TREEVIEW_ITEM *previousItem;
 387
 388     assert(wineItem != NULL);
 389
 390     if (count > 0)
 391     {
 392         next_item = TREEVIEW_GetNextListItem;
 393     }
 394     else if (count < 0)
 395     {
 396         count = -count;
 397         next_item = TREEVIEW_GetPrevListItem;
 398     }
 399     else
 400         return wineItem;
 401
 402     do
 403     {
 404         previousItem = wineItem;
 405         wineItem = next_item(infoPtr, wineItem);
 406
 407     } while (--count && wineItem != NULL);
 408
 409
 410     return wineItem ? wineItem : previousItem;
 411 }
 412
 413 /* Notifications ************************************************************/
 414
 415 static LRESULT
 416 TREEVIEW_SendRealNotify(TREEVIEW_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
 417 {
 418     if (infoPtr->bNtfUnicode)
 419         return (BOOL)SendMessageW(infoPtr->hwndNotify, WM_NOTIFY,
 420                                   wParam, lParam);
 421     else
 422         return (BOOL)SendMessageA(infoPtr->hwndNotify, WM_NOTIFY,
 423                                   wParam, lParam);
 424 }
 425
 426 static BOOL
 427 TREEVIEW_SendSimpleNotify(TREEVIEW_INFO *infoPtr, UINT code)
 428 {
 429     NMHDR nmhdr;
 430     HWND hwnd = infoPtr->hwnd;
 431
 432     TRACE("%x\n", code);
 433     nmhdr.hwndFrom = hwnd;
 434     nmhdr.idFrom = GetWindowLongA(hwnd, GWL_ID);
 435     nmhdr.code = code;
 436
 437     return (BOOL)TREEVIEW_SendRealNotify(infoPtr,
 438                                   (WPARAM)nmhdr.idFrom, (LPARAM)&nmhdr);
 439 }
 440
 441 static VOID
 442 TREEVIEW_TVItemFromItem(TREEVIEW_INFO *infoPtr, UINT mask, TVITEMA *tvItem, TREEVIEW_ITEM *item)
 443 {
 444     tvItem->mask = mask;
 445     tvItem->hItem = item;
 446     tvItem->state = item->state;
 447     tvItem->stateMask = 0;
 448     tvItem->iImage = item->iImage;
 449     tvItem->cchTextMax = item->cchTextMax;
 450     tvItem->iImage = item->iImage;
 451     tvItem->iSelectedImage = item->iSelectedImage;
 452     tvItem->cChildren = item->cChildren;
 453     tvItem->lParam = item->lParam;
 454
 455     /* **** **** **** **** WARNING **** **** **** **** */
 456     /* This control stores all the data in A format    */
 457     /* we will convert it to W if the notify format    */
 458     /* is Unicode.                                     */
 459     /* **** **** **** **** WARNING **** **** **** **** */
 460     if (infoPtr->bNtfUnicode) {
 461         INT len = MultiByteToWideChar( CP_ACP, 0, item->pszText, -1, NULL, 0 );
 462         if (len > 1) {
 463             tvItem->pszText = (LPSTR)COMCTL32_Alloc (len*sizeof(WCHAR));
 464             MultiByteToWideChar( CP_ACP, 0, item->pszText, -1, (LPWSTR)tvItem->pszText, len*sizeof(WCHAR) );
 465         }
 466     }
 467     else
 468         tvItem->pszText = item->pszText;
 469 }
 470
 471 static BOOL
 472 TREEVIEW_SendTreeviewNotify(TREEVIEW_INFO *infoPtr, UINT code, UINT action,
 473                             UINT mask, HTREEITEM oldItem, HTREEITEM newItem)
 474 {
 475     HWND hwnd = infoPtr->hwnd;
 476     NMTREEVIEWA nmhdr;
 477     BOOL ret;
 478
 479     TRACE("code:%x action:%x olditem:%p newitem:%p\n",
 480           code, action, oldItem, newItem);
 481
 482     ZeroMemory(&nmhdr, sizeof(NMTREEVIEWA));
 483
 484     nmhdr.hdr.hwndFrom = hwnd;
 485     nmhdr.hdr.idFrom = GetWindowLongA(hwnd, GWL_ID);
 486     nmhdr.hdr.code = code;
 487     nmhdr.action = action;
 488
 489     if (oldItem)
 490         TREEVIEW_TVItemFromItem(infoPtr, mask, &nmhdr.itemOld, oldItem);
 491
 492     if (newItem)
 493         TREEVIEW_TVItemFromItem(infoPtr, mask, &nmhdr.itemNew, newItem);
 494
 495     nmhdr.ptDrag.x = 0;
 496     nmhdr.ptDrag.y = 0;
 497
 498     ret = (BOOL)TREEVIEW_SendRealNotify(infoPtr,
 499                               (WPARAM)GetWindowLongA(hwnd, GWL_ID),
 500                               (LPARAM)&nmhdr);
 501     if (infoPtr->bNtfUnicode) {
 502         COMCTL32_Free(nmhdr.itemOld.pszText);
 503         COMCTL32_Free(nmhdr.itemNew.pszText);
 504     }
 505     return ret;
 506 }
 507
 508 static BOOL
 509 TREEVIEW_SendTreeviewDnDNotify(TREEVIEW_INFO *infoPtr, UINT code,
 510                                HTREEITEM dragItem, POINT pt)
 511 {
 512     HWND hwnd = infoPtr->hwnd;
 513     NMTREEVIEWA nmhdr;
 514
 515     TRACE("code:%x dragitem:%p\n", code, dragItem);
 516
 517     nmhdr.hdr.hwndFrom = hwnd;
 518     nmhdr.hdr.idFrom = GetWindowLongA(hwnd, GWL_ID);
 519     nmhdr.hdr.code = code;
 520     nmhdr.action = 0;
 521     nmhdr.itemNew.mask = TVIF_STATE | TVIF_PARAM | TVIF_HANDLE;
 522     nmhdr.itemNew.hItem = dragItem;
 523     nmhdr.itemNew.state = dragItem->state;
 524     nmhdr.itemNew.lParam = dragItem->lParam;
 525
 526     nmhdr.ptDrag.x = pt.x;
 527     nmhdr.ptDrag.y = pt.y;
 528
 529     return (BOOL)TREEVIEW_SendRealNotify(infoPtr,
 530                               (WPARAM)GetWindowLongA(hwnd, GWL_ID),
 531                               (LPARAM)&nmhdr);
 532 }
 533
 534
 535 static BOOL
 536 TREEVIEW_SendCustomDrawNotify(TREEVIEW_INFO *infoPtr, DWORD dwDrawStage,
 537                               HDC hdc, RECT rc)
 538 {
 539     HWND hwnd = infoPtr->hwnd;
 540     NMTVCUSTOMDRAW nmcdhdr;
 541     LPNMCUSTOMDRAW nmcd;
 542
 543     TRACE("drawstage:%lx hdc:%x\n", dwDrawStage, hdc);
 544
 545     nmcd = &nmcdhdr.nmcd;
 546     nmcd->hdr.hwndFrom = hwnd;
 547     nmcd->hdr.idFrom = GetWindowLongA(hwnd, GWL_ID);
 548     nmcd->hdr.code = NM_CUSTOMDRAW;
 549     nmcd->dwDrawStage = dwDrawStage;
 550     nmcd->hdc = hdc;
 551     nmcd->rc = rc;
 552     nmcd->dwItemSpec = 0;
 553     nmcd->uItemState = 0;
 554     nmcd->lItemlParam = 0;
 555     nmcdhdr.clrText = infoPtr->clrText;
 556     nmcdhdr.clrTextBk = infoPtr->clrBk;
 557     nmcdhdr.iLevel = 0;
 558
 559     return (BOOL)TREEVIEW_SendRealNotify(infoPtr,
 560                               (WPARAM)GetWindowLongA(hwnd, GWL_ID),
 561                               (LPARAM)&nmcdhdr);
 562 }
 563
 564
 565
 566 /* FIXME: need to find out when the flags in uItemState need to be set */
 567
 568 static BOOL
 569 TREEVIEW_SendCustomDrawItemNotify(TREEVIEW_INFO *infoPtr, HDC hdc,
 570                                   TREEVIEW_ITEM *wineItem, UINT uItemDrawState)
 571 {
 572     HWND hwnd = infoPtr->hwnd;
 573     NMTVCUSTOMDRAW nmcdhdr;
 574     LPNMCUSTOMDRAW nmcd;
 575     DWORD dwDrawStage, dwItemSpec;
 576     UINT uItemState;
 577     INT retval;
 578
 579     dwDrawStage = CDDS_ITEM | uItemDrawState;
 580     dwItemSpec = (DWORD)wineItem;
 581     uItemState = 0;
 582     if (wineItem->state & TVIS_SELECTED)
 583         uItemState |= CDIS_SELECTED;
 584     if (wineItem == infoPtr->selectedItem)
 585         uItemState |= CDIS_FOCUS;
 586     if (wineItem == infoPtr->hotItem)
 587         uItemState |= CDIS_HOT;
 588
 589     nmcd = &nmcdhdr.nmcd;
 590     nmcd->hdr.hwndFrom = hwnd;
 591     nmcd->hdr.idFrom = GetWindowLongA(hwnd, GWL_ID);
 592     nmcd->hdr.code = NM_CUSTOMDRAW;
 593     nmcd->dwDrawStage = dwDrawStage;
 594     nmcd->hdc = hdc;
 595     nmcd->rc = wineItem->rect;
 596     nmcd->dwItemSpec = dwItemSpec;
 597     nmcd->uItemState = uItemState;
 598     nmcd->lItemlParam = wineItem->lParam;
 599     nmcdhdr.clrText = infoPtr->clrText;
 600     nmcdhdr.clrTextBk = infoPtr->clrBk;
 601     nmcdhdr.iLevel = wineItem->iLevel;
 602
 603     TRACE("drawstage:%lx hdc:%x item:%lx, itemstate:%x, lItemlParam:%lx\n",
 604           nmcd->dwDrawStage, nmcd->hdc, nmcd->dwItemSpec,
 605           nmcd->uItemState, nmcd->lItemlParam);
 606
 607     retval = TREEVIEW_SendRealNotify(infoPtr,
 608                           (WPARAM)GetWindowLongA(hwnd, GWL_ID),
 609                           (LPARAM)&nmcdhdr);
 610
 611     infoPtr->clrText = nmcdhdr.clrText;
 612     infoPtr->clrBk = nmcdhdr.clrTextBk;
 613     return (BOOL)retval;
 614 }
 615
 616 static BOOL
 617 TREEVIEW_BeginLabelEditNotify(TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *editItem)
 618 {
 619     HWND hwnd = infoPtr->hwnd;
 620     LPSTR allocated = NULL;
 621     NMTVDISPINFOA tvdi;
 622     BOOL ret;
 623
 624     tvdi.hdr.hwndFrom = hwnd;
 625     tvdi.hdr.idFrom = GetWindowLongA(hwnd, GWL_ID);
 626     tvdi.hdr.code = TVN_BEGINLABELEDITA;
 627
 628     tvdi.item.mask = TVIF_HANDLE | TVIF_STATE | TVIF_PARAM | TVIF_TEXT;
 629     tvdi.item.hItem = editItem;
 630     tvdi.item.state = editItem->state;
 631     tvdi.item.lParam = editItem->lParam;
 632     if (infoPtr->bNtfUnicode) {
 633         INT len = MultiByteToWideChar( CP_ACP, 0, editItem->pszText, -1, NULL, 0 );
 634         if (len > 1) {
 635             tvdi.item.pszText = allocated = (LPSTR)COMCTL32_Alloc (len*sizeof(WCHAR));
 636             MultiByteToWideChar( CP_ACP, 0, editItem->pszText, -1, (LPWSTR)tvdi.item.pszText, len*sizeof(WCHAR) );
 637             tvdi.item.cchTextMax = len*sizeof(WCHAR);
 638         }
 639         else {
 640             tvdi.item.pszText = editItem->pszText;  /* ??? */
 641             tvdi.item.cchTextMax = editItem->cchTextMax;  /* ??? */
 642         }
 643     }
 644     else {
 645         tvdi.item.pszText = editItem->pszText;
 646         tvdi.item.cchTextMax = editItem->cchTextMax;
 647     }
 648
 649     ret = (BOOL)TREEVIEW_SendRealNotify(infoPtr,
 650                                          tvdi.hdr.idFrom,
 651                                         (LPARAM)&tvdi);
 652     if (allocated)
 653         COMCTL32_Free(allocated);
 654     return ret;
 655 }
 656
 657 static void
 658 TREEVIEW_UpdateDispInfo(TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *wineItem,
 659                         UINT mask)
 660 {
 661     NMTVDISPINFOA callback;
 662     HWND hwnd = infoPtr->hwnd;
 663
 664     mask &= wineItem->callbackMask;
 665
 666     if (mask == 0) return;
 667
 668     callback.hdr.hwndFrom         = hwnd;
 669     callback.hdr.idFrom           = GetWindowLongA(hwnd, GWL_ID);
 670     callback.hdr.code             = (infoPtr->bNtfUnicode) ? TVN_GETDISPINFOW :
 671                                                    TVN_GETDISPINFOA;
 672
 673     /* 'state' always contains valid value, as well as 'lParam'.
 674      * All other parameters are uninitialized.
 675      */
 676     callback.item.pszText         = wineItem->pszText;
 677     callback.item.cchTextMax      = wineItem->cchTextMax;
 678     callback.item.mask            = mask;
 679     callback.item.hItem           = wineItem;
 680     callback.item.state           = wineItem->state;
 681     callback.item.lParam          = wineItem->lParam;
 682
 683     /* If text is changed we need to recalculate textWidth */
 684     if (mask & TVIF_TEXT)
 685        wineItem->textWidth = 0;
 686
 687     TREEVIEW_SendRealNotify(infoPtr,
 688                             (WPARAM)callback.hdr.idFrom, (LPARAM)&callback);
 689
 690     /* It may have changed due to a call to SetItem. */
 691     mask &= wineItem->callbackMask;
 692
 693     if ((mask & TVIF_TEXT) && callback.item.pszText != wineItem->pszText)
 694     {
 695         /* Instead of copying text into our buffer user specified its own */
 696         if (infoPtr->bNtfUnicode) {
 697             LPWSTR newText;
 698             int buflen;
 699             int len = WideCharToMultiByte( CP_ACP, 0,
 700                                            (LPWSTR)callback.item.pszText, -1,
 701                                            NULL, 0, NULL, NULL );
 702             buflen = max((len+1)*sizeof(WCHAR), TEXT_CALLBACK_SIZE);
 703             newText = (LPWSTR)COMCTL32_ReAlloc(wineItem->pszText, buflen);
 704
 705             TRACE("returned wstr %s, len=%d, buflen=%d\n",
 706                   debugstr_w((LPWSTR)callback.item.pszText), len, buflen);
 707
 708             if (newText)
 709             {
 710                 wineItem->pszText = (LPSTR)newText;
 711                 WideCharToMultiByte( CP_ACP, 0,
 712                                      (LPWSTR)callback.item.pszText, -1,
 713                                      wineItem->pszText, buflen,
 714                                      NULL, NULL );
 715                 wineItem->cchTextMax = buflen;
 716             }
 717             /* If ReAlloc fails we have nothing to do, but keep original text */
 718         }
 719         else {
 720             int len = max(lstrlenA(callback.item.pszText) + 1,
 721                           TEXT_CALLBACK_SIZE);
 722             LPSTR newText = COMCTL32_ReAlloc(wineItem->pszText, len);
 723
 724             TRACE("returned str %s, len=%d\n",
 725                   debugstr_a(callback.item.pszText), len);
 726
 727             if (newText)
 728             {
 729                 wineItem->pszText = newText;
 730                 strcpy(wineItem->pszText, callback.item.pszText);
 731                 wineItem->cchTextMax = len;
 732             }
 733             /* If ReAlloc fails we have nothing to do, but keep original text */
 734         }
 735     }
 736     else if (mask & TVIF_TEXT) {
 737         /* User put text into our buffer, that is ok unless W string */
 738         if (infoPtr->bNtfUnicode) {
 739             LPWSTR newText;
 740             LPSTR oldText = NULL;
 741             int buflen;
 742             int len = WideCharToMultiByte( CP_ACP, 0,
 743                                            (LPWSTR)callback.item.pszText, -1,
 744                                            NULL, 0, NULL, NULL );
 745             buflen = max((len+1)*sizeof(WCHAR), TEXT_CALLBACK_SIZE);
 746             newText = (LPWSTR)COMCTL32_Alloc(buflen);
 747
 748             TRACE("same buffer wstr %s, len=%d, buflen=%d\n",
 749                   debugstr_w((LPWSTR)callback.item.pszText), len, buflen);
 750
 751             if (newText)
 752             {
 753                 oldText = wineItem->pszText;
 754                 wineItem->pszText = (LPSTR)newText;
 755                 WideCharToMultiByte( CP_ACP, 0,
 756                                      (LPWSTR)callback.item.pszText, -1,
 757                                      wineItem->pszText, buflen, NULL, NULL );
 758                 wineItem->cchTextMax = buflen;
 759                 if (oldText)
 760                     COMCTL32_Free(oldText);
 761             }
 762         }
 763     }
 764
 765     if (mask & TVIF_IMAGE)
 766         wineItem->iImage = callback.item.iImage;
 767
 768     if (mask & TVIF_SELECTEDIMAGE)
 769         wineItem->iSelectedImage = callback.item.iSelectedImage;
 770
 771     if (mask & TVIF_CHILDREN)
 772         wineItem->cChildren = callback.item.cChildren;
 773
 774     /* These members are now permanently set. */
 775     if (callback.item.mask & TVIF_DI_SETITEM)
 776         wineItem->callbackMask &= ~callback.item.mask;
 777 }
 778
 779 /***************************************************************************
 780  * This function uses cChildren field to decide whether the item has
 781  * children or not.
 782  * Note: if this returns TRUE, the child items may not actually exist,
 783  * they could be virtual.
 784  *
 785  * Just use wineItem->firstChild to check for physical children.
 786  */
 787 static BOOL
 788 TREEVIEW_HasChildren(TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *wineItem)
 789 {
 790     TREEVIEW_UpdateDispInfo(infoPtr, wineItem, TVIF_CHILDREN);
 791
 792     return wineItem->cChildren > 0;
 793 }
 794
 795
 796 /* Item Position ********************************************************/
 797
 798 /* Compute linesOffset, stateOffset, imageOffset, textOffset of an item. */
 799 static VOID
 800 TREEVIEW_ComputeItemInternalMetrics(TREEVIEW_INFO *infoPtr,
 801                                     TREEVIEW_ITEM *item)
 802 {
 803     /* Same effect, different optimisation. */
 804 #if 0
 805     BOOL lar = ((infoPtr->dwStyle & TVS_LINESATROOT)
 806                 && (infoPtr->dwStyle & (TVS_HASLINES|TVS_HASBUTTONS)));
 807 #else
 808     BOOL lar = ((infoPtr->dwStyle
 809                  & (TVS_LINESATROOT|TVS_HASLINES|TVS_HASBUTTONS))
 810                 > TVS_LINESATROOT);
 811 #endif
 812
 813     item->linesOffset = infoPtr->uIndent * (item->iLevel + lar - 1)
 814         - infoPtr->scrollX;
 815     item->stateOffset = item->linesOffset + infoPtr->uIndent;
 816     item->imageOffset = item->stateOffset
 817         + (STATEIMAGEINDEX(item->state) ? infoPtr->stateImageWidth : 0);
 818     item->textOffset  = item->imageOffset + infoPtr->normalImageWidth;
 819 }
 820
 821 static VOID
 822 TREEVIEW_ComputeTextWidth(TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *item, HDC hDC)
 823 {
 824     HDC hdc;
 825     HFONT hOldFont=0;
 826     SIZE sz;
 827
 828     /* DRAW's OM docker creates items like this */
 829     if (item->pszText == NULL)
 830     {
 831         item->textWidth = 0;
 832         return;
 833     }
 834
 835     if (item->textWidth != 0 && !(item->callbackMask & TVIF_TEXT))
 836        return;
 837
 838     if (hDC != 0)
 839     {
 840         hdc = hDC;
 841     }
 842     else
 843     {
 844         hdc = GetDC(infoPtr->hwnd);
 845         hOldFont = SelectObject(hdc, TREEVIEW_FontForItem(infoPtr, item));
 846     }
 847
 848     GetTextExtentPoint32A(hdc, item->pszText, strlen(item->pszText), &sz);
 849     item->textWidth = sz.cx;
 850
 851     if (hDC == 0)
 852     {
 853         SelectObject(hdc, hOldFont);
 854         ReleaseDC(0, hdc);
 855     }
 856 }
 857
 858 static VOID
 859 TREEVIEW_ComputeItemRect(TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *item)
 860 {
 861     item->rect.top = infoPtr->uItemHeight *
 862         (item->visibleOrder - infoPtr->firstVisible->visibleOrder);
 863
 864     item->rect.bottom = item->rect.top
 865         + infoPtr->uItemHeight * item->iIntegral - 1;
 866
 867     item->rect.left = 0;
 868     item->rect.right = infoPtr->clientWidth;
 869 }
 870
 871 /* We know that only items after start need their order updated. */
 872 static void
 873 TREEVIEW_RecalculateVisibleOrder(TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *start)
 874 {
 875     TREEVIEW_ITEM *item;
 876     int order;
 877
 878     if (!start)
 879     {
 880         start = infoPtr->root->firstChild;
 881         order = 0;
 882     }
 883     else
 884         order = start->visibleOrder;
 885
 886     for (item = start; item != NULL;
 887          item = TREEVIEW_GetNextListItem(infoPtr, item))
 888     {
 889         item->visibleOrder = order;
 890         order += item->iIntegral;
 891     }
 892
 893     infoPtr->maxVisibleOrder = order;
 894
 895     for (item = start; item != NULL;
 896          item = TREEVIEW_GetNextListItem(infoPtr, item))
 897     {
 898         TREEVIEW_ComputeItemRect(infoPtr, item);
 899     }
 900 }
 901
 902
 903 /* Update metrics of all items in selected subtree.
 904  * root must be expanded
 905  */
 906 static VOID
 907 TREEVIEW_UpdateSubTree(TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *root)
 908 {
 909    TREEVIEW_ITEM *sibling;
 910    HDC hdc;
 911    HFONT hOldFont;
 912
 913    if (!root->firstChild || !(root->state & TVIS_EXPANDED))
 914       return;
 915
 916    root->state &= ~TVIS_EXPANDED;
 917    sibling = TREEVIEW_GetNextListItem(infoPtr, root);
 918    root->state |= TVIS_EXPANDED;
 919
 920    hdc = GetDC(infoPtr->hwnd);
 921    hOldFont = SelectObject(hdc, infoPtr->hFont);
 922
 923    for (; root != sibling;
 924         root = TREEVIEW_GetNextListItem(infoPtr, root))
 925    {
 926       TREEVIEW_ComputeItemInternalMetrics(infoPtr, root);
 927
 928       if (root->callbackMask & TVIF_TEXT)
 929          TREEVIEW_UpdateDispInfo(infoPtr, root, TVIF_TEXT);
 930
 931       if (root->textWidth == 0)
 932       {
 933          SelectObject(hdc, TREEVIEW_FontForItem(infoPtr, root));
 934          TREEVIEW_ComputeTextWidth(infoPtr, root, hdc);
 935       }
 936    }
 937
 938    SelectObject(hdc, hOldFont);
 939    ReleaseDC(infoPtr->hwnd, hdc);
 940 }
 941
 942 /* Item Allocation **********************************************************/
 943
 944 static TREEVIEW_ITEM *
 945 TREEVIEW_AllocateItem(TREEVIEW_INFO *infoPtr)
 946 {
 947     TREEVIEW_ITEM *newItem = COMCTL32_Alloc(sizeof(TREEVIEW_ITEM));
 948
 949     if (!newItem)
 950         return NULL;
 951
 952     if (DPA_InsertPtr(infoPtr->items, INT_MAX, newItem) == -1)
 953     {
 954         COMCTL32_Free(newItem);
 955         return NULL;
 956     }
 957
 958     return newItem;
 959 }
 960
 961 /* Exact opposite of TREEVIEW_AllocateItem. In particular, it does not
 962  * free item->pszText. */
 963 static void
 964 TREEVIEW_FreeItem(TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *item)
 965 {
 966     DPA_DeletePtr(infoPtr->items, DPA_GetPtrIndex(infoPtr->items, item));
 967     COMCTL32_Free(item);
 968     if (infoPtr->selectedItem == item)
 969         infoPtr->selectedItem = NULL;
 970 }
 971
 972
 973 /* Item Insertion *******************************************************/
 974
 975 /***************************************************************************
 976  * This method inserts newItem before sibling as a child of parent.
 977  * sibling can be NULL, but only if parent has no children.
 978  */
 979 static void
 980 TREEVIEW_InsertBefore(TREEVIEW_ITEM *newItem, TREEVIEW_ITEM *sibling,
 981                       TREEVIEW_ITEM *parent)
 982 {
 983     assert(newItem != NULL);
 984     assert(parent != NULL);
 985
 986     if (sibling != NULL)
 987     {
 988         assert(sibling->parent == parent);
 989
 990         if (sibling->prevSibling != NULL)
 991             sibling->prevSibling->nextSibling = newItem;
 992
 993         newItem->prevSibling = sibling->prevSibling;
 994         sibling->prevSibling = newItem;
 995     }
 996     else
 997        newItem->prevSibling = NULL;
 998
 999     newItem->nextSibling = sibling;
1000
1001     if (parent->firstChild == sibling)
1002         parent->firstChild = newItem;
1003
1004     if (parent->lastChild == NULL)
1005         parent->lastChild = newItem;
1006 }
1007
1008 /***************************************************************************
1009  * This method inserts newItem after sibling as a child of parent.
1010  * sibling can be NULL, but only if parent has no children.
1011  */
1012 static void
1013 TREEVIEW_InsertAfter(TREEVIEW_ITEM *newItem, TREEVIEW_ITEM *sibling,
1014                      TREEVIEW_ITEM *parent)
1015 {
1016     assert(newItem != NULL);
1017     assert(parent != NULL);
1018
1019     if (sibling != NULL)
1020     {
1021         assert(sibling->parent == parent);
1022
1023         if (sibling->nextSibling != NULL)
1024             sibling->nextSibling->prevSibling = newItem;
1025
1026         newItem->nextSibling = sibling->nextSibling;
1027         sibling->nextSibling = newItem;
1028     }
1029     else
1030        newItem->nextSibling = NULL;
1031
1032     newItem->prevSibling = sibling;
1033
1034     if (parent->lastChild == sibling)
1035         parent->lastChild = newItem;
1036
1037     if (parent->firstChild == NULL)
1038         parent->firstChild = newItem;
1039 }
1040
1041 static BOOL
1042 TREEVIEW_DoSetItem(TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *wineItem,
1043                    const TVITEMEXA *tvItem)
1044 {
1045     UINT callbackClear = 0;
1046     UINT callbackSet = 0;
1047
1048     /* Do this first in case it fails. */
1049     if (tvItem->mask & TVIF_TEXT)
1050     {
1051         wineItem->textWidth = 0; /* force width recalculation */
1052         if (tvItem->pszText != LPSTR_TEXTCALLBACKA)
1053         {
1054             int len = lstrlenA(tvItem->pszText) + 1;
1055             LPSTR newText = COMCTL32_ReAlloc(wineItem->pszText, len);
1056
1057             if (newText == NULL) return FALSE;
1058
1059             callbackClear |= TVIF_TEXT;
1060
1061             wineItem->pszText = newText;
1062             wineItem->cchTextMax = len;
1063             lstrcpynA(wineItem->pszText, tvItem->pszText, len);
1064             TRACE("setting text %s, item %p\n",
1065                   debugstr_a(wineItem->pszText), wineItem);
1066         }
1067         else
1068         {
1069             callbackSet |= TVIF_TEXT;
1070
1071             wineItem->pszText = COMCTL32_ReAlloc(wineItem->pszText,
1072                                                  TEXT_CALLBACK_SIZE);
1073             wineItem->cchTextMax = TEXT_CALLBACK_SIZE;
1074             TRACE("setting callback, item %p\n",
1075                   wineItem);
1076         }
1077     }
1078
1079     if (tvItem->mask & TVIF_CHILDREN)
1080     {
1081         wineItem->cChildren = tvItem->cChildren;
1082
1083         if (wineItem->cChildren == I_CHILDRENCALLBACK)
1084             callbackSet |= TVIF_CHILDREN;
1085         else
1086             callbackClear |= TVIF_CHILDREN;
1087     }
1088
1089     if (tvItem->mask & TVIF_IMAGE)
1090     {
1091         wineItem->iImage = tvItem->iImage;
1092
1093         if (wineItem->iImage == I_IMAGECALLBACK)
1094             callbackSet |= TVIF_IMAGE;
1095         else
1096             callbackClear |= TVIF_IMAGE;
1097     }
1098
1099     if (tvItem->mask & TVIF_SELECTEDIMAGE)
1100     {
1101         wineItem->iSelectedImage = tvItem->iSelectedImage;
1102
1103         if (wineItem->iSelectedImage == I_IMAGECALLBACK)
1104             callbackSet |= TVIF_SELECTEDIMAGE;
1105         else
1106             callbackClear |= TVIF_SELECTEDIMAGE;
1107     }
1108
1109     if (tvItem->mask & TVIF_PARAM)
1110         wineItem->lParam = tvItem->lParam;
1111
1112     /* If the application sets TVIF_INTEGRAL without
1113      * supplying a TVITEMEX structure, it's toast. */
1114     if (tvItem->mask & TVIF_INTEGRAL)
1115         wineItem->iIntegral = tvItem->iIntegral;
1116
1117     if (tvItem->mask & TVIF_STATE)
1118     {
1119         TRACE("prevstate,state,mask:%x,%x,%x\n", wineItem->state, tvItem->state,
1120               tvItem->stateMask);
1121         wineItem->state &= ~tvItem->stateMask;
1122         wineItem->state |= (tvItem->state & tvItem->stateMask);
1123     }
1124
1125     wineItem->callbackMask |= callbackSet;
1126     wineItem->callbackMask &= ~callbackClear;
1127
1128     return TRUE;
1129 }
1130
1131 /* Note that the new item is pre-zeroed. */
1132 static LRESULT
1133 TREEVIEW_InsertItemA(TREEVIEW_INFO *infoPtr, LPARAM lParam)
1134 {
1135     const TVINSERTSTRUCTA *ptdi = (LPTVINSERTSTRUCTA) lParam;
1136     const TVITEMEXA *tvItem = &ptdi->DUMMYUNIONNAME.itemex;
1137     HTREEITEM insertAfter;
1138     TREEVIEW_ITEM *newItem, *parentItem;
1139     BOOL bTextUpdated = FALSE;
1140
1141     if (ptdi->hParent == TVI_ROOT || ptdi->hParent == 0)
1142     {
1143         parentItem = infoPtr->root;
1144     }
1145     else
1146     {
1147         parentItem = ptdi->hParent;
1148
1149         if (!TREEVIEW_ValidItem(infoPtr, parentItem))
1150         {
1151             WARN("invalid parent %p\n", parentItem);
1152             return (LRESULT)(HTREEITEM)NULL;
1153         }
1154     }
1155
1156     insertAfter = ptdi->hInsertAfter;
1157
1158     /* Validate this now for convenience. */
1159     switch ((DWORD)insertAfter)
1160     {
1161     case (DWORD)TVI_FIRST:
1162     case (DWORD)TVI_LAST:
1163     case (DWORD)TVI_SORT:
1164         break;
1165
1166     default:
1167         if (!TREEVIEW_ValidItem(infoPtr, insertAfter) ||
1168             insertAfter->parent != parentItem)
1169         {
1170             WARN("invalid insert after %p\n", insertAfter);
1171             insertAfter = TVI_LAST;
1172         }
1173     }
1174
1175     TRACE("parent %p position %p: '%s'\n", parentItem, insertAfter,
1176           (tvItem->mask & TVIF_TEXT)
1177           ? ((tvItem->pszText == LPSTR_TEXTCALLBACKA) ? "<callback>"
1178              : tvItem->pszText)
1179           : "<no label>");
1180
1181     newItem = TREEVIEW_AllocateItem(infoPtr);
1182     if (newItem == NULL)
1183         return (LRESULT)(HTREEITEM)NULL;
1184
1185     newItem->parent = parentItem;
1186     newItem->iIntegral = 1;
1187
1188     if (!TREEVIEW_DoSetItem(infoPtr, newItem, tvItem))
1189         return (LRESULT)(HTREEITEM)NULL;
1190
1191     /* After this point, nothing can fail. (Except for TVI_SORT.) */
1192
1193     infoPtr->uNumItems++;
1194
1195     switch ((DWORD)insertAfter)
1196     {
1197     case (DWORD)TVI_FIRST:
1198         TREEVIEW_InsertBefore(newItem, parentItem->firstChild, parentItem);
1199         if (infoPtr->firstVisible == parentItem->firstChild)
1200             TREEVIEW_SetFirstVisible(infoPtr, newItem, TRUE);
1201         break;
1202
1203     case (DWORD)TVI_LAST:
1204         TREEVIEW_InsertAfter(newItem, parentItem->lastChild, parentItem);
1205         break;
1206
1207         /* hInsertAfter names a specific item we want to insert after */
1208     default:
1209         TREEVIEW_InsertAfter(newItem, insertAfter, insertAfter->parent);
1210         break;
1211
1212     case (DWORD)TVI_SORT:
1213         {
1214             TREEVIEW_ITEM *aChild;
1215             TREEVIEW_ITEM *previousChild = NULL;
1216             BOOL bItemInserted = FALSE;
1217
1218             aChild = parentItem->firstChild;
1219
1220             bTextUpdated = TRUE;
1221             TREEVIEW_UpdateDispInfo(infoPtr, newItem, TVIF_TEXT);
1222
1223             /* Iterate the parent children to see where we fit in */
1224             while (aChild != NULL)
1225             {
1226                 INT comp;
1227
1228                 TREEVIEW_UpdateDispInfo(infoPtr, aChild, TVIF_TEXT);
1229                 comp = lstrcmpA(newItem->pszText, aChild->pszText);
1230
1231                 if (comp < 0)   /* we are smaller than the current one */
1232                 {
1233                     TREEVIEW_InsertBefore(newItem, aChild, parentItem);
1234                     bItemInserted = TRUE;
1235                     break;
1236                 }
1237                 else if (comp > 0)      /* we are bigger than the current one */
1238                 {
1239                     previousChild = aChild;
1240
1241                     /* This will help us to exit if there is no more sibling */
1242                     aChild = (aChild->nextSibling == 0)
1243                         ? NULL
1244                         : aChild->nextSibling;
1245
1246                     /* Look at the next item */
1247                     continue;
1248                 }
1249                 else if (comp == 0)
1250                 {
1251                     /*
1252                      * An item with this name is already existing, therefore,
1253                      * we add after the one we found
1254                      */
1255                     TREEVIEW_InsertAfter(newItem, aChild, parentItem);
1256                     bItemInserted = TRUE;
1257                     break;
1258                 }
1259             }
1260
1261             /*
1262              * we reach the end of the child list and the item has not
1263              * yet been inserted, therefore, insert it after the last child.
1264              */
1265             if ((!bItemInserted) && (aChild == NULL))
1266                 TREEVIEW_InsertAfter(newItem, previousChild, parentItem);
1267
1268             break;
1269         }
1270     }
1271
1272
1273     TRACE("new item %p; parent %p, mask %x\n", newItem,
1274           newItem->parent, tvItem->mask);
1275
1276     newItem->iLevel = newItem->parent->iLevel + 1;
1277
1278     if (newItem->parent->cChildren == 0)
1279         newItem->parent->cChildren = 1;
1280
1281     if (infoPtr->dwStyle & TVS_CHECKBOXES)
1282     {
1283         if (STATEIMAGEINDEX(newItem->state) == 0)
1284             newItem->state |= INDEXTOSTATEIMAGEMASK(1);
1285     }
1286
1287     if (infoPtr->firstVisible == NULL)
1288         infoPtr->firstVisible = newItem;
1289
1290     TREEVIEW_VerifyTree(infoPtr);
1291
1292     if (parentItem == infoPtr->root ||
1293         (ISVISIBLE(parentItem) && parentItem->state & TVIS_EXPANDED))
1294     {
1295        TREEVIEW_ITEM *item;
1296        TREEVIEW_ITEM *prev = TREEVIEW_GetPrevListItem(infoPtr, newItem);
1297
1298        TREEVIEW_RecalculateVisibleOrder(infoPtr, prev);
1299        TREEVIEW_ComputeItemInternalMetrics(infoPtr, newItem);
1300
1301        if (!bTextUpdated)
1302           TREEVIEW_UpdateDispInfo(infoPtr, newItem, TVIF_TEXT);
1303
1304        TREEVIEW_ComputeTextWidth(infoPtr, newItem, 0);
1305        TREEVIEW_UpdateScrollBars(infoPtr);
1306     /*
1307      * if the item was inserted in a visible part of the tree,
1308      * invalidate it, as well as those after it
1309      */
1310        for (item = newItem;
1311             item != NULL;
1312             item = TREEVIEW_GetNextListItem(infoPtr, item))
1313           TREEVIEW_Invalidate(infoPtr, item);
1314     }
1315     else
1316     {
1317        newItem->visibleOrder = -1;
1318
1319        /* refresh treeview if newItem is the first item inserted under parentItem */
1320        if (ISVISIBLE(parentItem) && newItem->prevSibling == newItem->nextSibling)
1321        {
1322           /* parent got '+' - update it */
1323           TREEVIEW_Invalidate(infoPtr, parentItem);
1324        }
1325     }
1326
1327     return (LRESULT)newItem;
1328 }
1329
1330
1331 static LRESULT
1332 TREEVIEW_InsertItemW(TREEVIEW_INFO *infoPtr, LPARAM lParam)
1333 {
1334     TVINSERTSTRUCTW *tvisW;
1335     TVINSERTSTRUCTA tvisA;
1336     LRESULT lRes;
1337
1338     tvisW = (LPTVINSERTSTRUCTW) lParam;
1339
1340     tvisA.hParent = tvisW->hParent;
1341     tvisA.hInsertAfter = tvisW->hInsertAfter;
1342
1343     tvisA.DUMMYUNIONNAME.item.mask = tvisW->DUMMYUNIONNAME.item.mask;
1344     tvisA.DUMMYUNIONNAME.item.hItem = tvisW->DUMMYUNIONNAME.item.hItem;
1345     tvisA.DUMMYUNIONNAME.item.state = tvisW->DUMMYUNIONNAME.item.state;
1346     tvisA.DUMMYUNIONNAME.item.stateMask = tvisW->DUMMYUNIONNAME.item.stateMask;
1347     tvisA.DUMMYUNIONNAME.item.cchTextMax =
1348         tvisW->DUMMYUNIONNAME.item.cchTextMax;
1349
1350     if (tvisW->DUMMYUNIONNAME.item.pszText)
1351     {
1352         if (tvisW->DUMMYUNIONNAME.item.pszText != LPSTR_TEXTCALLBACKW)
1353         {
1354             int len = WideCharToMultiByte( CP_ACP, 0, tvisW->DUMMYUNIONNAME.item.pszText, -1,
1355                                            NULL, 0, NULL, NULL );
1356             tvisA.DUMMYUNIONNAME.item.pszText = COMCTL32_Alloc(len);
1357             WideCharToMultiByte( CP_ACP, 0, tvisW->DUMMYUNIONNAME.item.pszText, -1,
1358                                  tvisA.DUMMYUNIONNAME.item.pszText, len, NULL, NULL );
1359         }
1360         else
1361         {
1362             tvisA.DUMMYUNIONNAME.item.pszText = LPSTR_TEXTCALLBACKA;
1363             tvisA.DUMMYUNIONNAME.item.cchTextMax = 0;
1364         }
1365     }
1366
1367     tvisA.DUMMYUNIONNAME.item.iImage = tvisW->DUMMYUNIONNAME.item.iImage;
1368     tvisA.DUMMYUNIONNAME.item.iSelectedImage =
1369         tvisW->DUMMYUNIONNAME.item.iSelectedImage;
1370     tvisA.DUMMYUNIONNAME.item.cChildren = tvisW->DUMMYUNIONNAME.item.cChildren;
1371     tvisA.DUMMYUNIONNAME.item.lParam = tvisW->DUMMYUNIONNAME.item.lParam;
1372
1373     lRes = TREEVIEW_InsertItemA(infoPtr, (LPARAM)&tvisA);
1374
1375     if (tvisA.DUMMYUNIONNAME.item.pszText != LPSTR_TEXTCALLBACKA)
1376     {
1377         COMCTL32_Free(tvisA.DUMMYUNIONNAME.item.pszText);
1378     }
1379
1380     return lRes;
1381
1382 }
1383
1384
1385 /* Item Deletion ************************************************************/
1386 static void
1387 TREEVIEW_RemoveItem(TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *wineItem);
1388
1389 static void
1390 TREEVIEW_RemoveAllChildren(TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *parentItem)
1391 {
1392     TREEVIEW_ITEM *kill = parentItem->firstChild;
1393
1394     while (kill != NULL)
1395     {
1396         TREEVIEW_ITEM *next = kill->nextSibling;
1397
1398         TREEVIEW_RemoveItem(infoPtr, kill);
1399
1400         kill = next;
1401     }
1402
1403     assert(parentItem->cChildren <= 0); /* I_CHILDRENCALLBACK or 0 */
1404     assert(parentItem->firstChild == NULL);
1405     assert(parentItem->lastChild == NULL);
1406 }
1407
1408 static void
1409 TREEVIEW_UnlinkItem(TREEVIEW_ITEM *item)
1410 {
1411     TREEVIEW_ITEM *parentItem = item->parent;
1412
1413     assert(item != NULL);
1414     assert(item->parent != NULL); /* i.e. it must not be the root */
1415
1416     if (parentItem->firstChild == item)
1417         parentItem->firstChild = item->nextSibling;
1418
1419     if (parentItem->lastChild == item)
1420         parentItem->lastChild = item->prevSibling;
1421
1422     if (parentItem->firstChild == NULL && parentItem->lastChild == NULL
1423         && parentItem->cChildren > 0)
1424         parentItem->cChildren = 0;
1425
1426     if (item->prevSibling)
1427         item->prevSibling->nextSibling = item->nextSibling;
1428
1429     if (item->nextSibling)
1430         item->nextSibling->prevSibling = item->prevSibling;
1431 }
1432
1433 static void
1434 TREEVIEW_RemoveItem(TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *wineItem)
1435 {
1436     TRACE("%p, (%s)\n", wineItem, TREEVIEW_ItemName(wineItem));
1437
1438     TREEVIEW_SendTreeviewNotify(infoPtr,
1439                                 (infoPtr->bNtfUnicode) ? TVN_DELETEITEMW :
1440                                                          TVN_DELETEITEMA,
1441                                 TVIF_HANDLE | TVIF_PARAM, 0, wineItem, 0);
1442
1443     if (wineItem->firstChild)
1444         TREEVIEW_RemoveAllChildren(infoPtr, wineItem);
1445
1446     TREEVIEW_UnlinkItem(wineItem);
1447
1448     infoPtr->uNumItems--;
1449
1450     if (wineItem->pszText != LPSTR_TEXTCALLBACKA)
1451         COMCTL32_Free(wineItem->pszText);
1452
1453     TREEVIEW_FreeItem(infoPtr, wineItem);
1454 }
1455
1456
1457 /* Empty out the tree. */
1458 static void
1459 TREEVIEW_RemoveTree(TREEVIEW_INFO *infoPtr)
1460 {
1461     TREEVIEW_RemoveAllChildren(infoPtr, infoPtr->root);
1462
1463     assert(infoPtr->uNumItems == 0);    /* root isn't counted in uNumItems */
1464 }
1465
1466 static LRESULT
1467 TREEVIEW_DeleteItem(TREEVIEW_INFO *infoPtr, HTREEITEM wineItem)
1468 {
1469     TREEVIEW_ITEM *oldSelection = infoPtr->selectedItem;
1470     TREEVIEW_ITEM *newSelection = oldSelection;
1471     TREEVIEW_ITEM *newFirstVisible = NULL;
1472     TREEVIEW_ITEM *parent, *prev = NULL;
1473     BOOL visible = FALSE;
1474
1475     if (wineItem == TVI_ROOT)
1476     {
1477         TRACE("TVI_ROOT\n");
1478         parent = infoPtr->root;
1479         newSelection = NULL;
1480         visible = TRUE;
1481         TREEVIEW_RemoveTree(infoPtr);
1482     }
1483     else
1484     {
1485         if (!TREEVIEW_ValidItem(infoPtr, wineItem))
1486             return FALSE;
1487
1488         TRACE("%p (%s)\n", wineItem, TREEVIEW_ItemName(wineItem));
1489         parent = wineItem->parent;
1490
1491         if (ISVISIBLE(wineItem))
1492         {
1493             prev = TREEVIEW_GetPrevListItem(infoPtr, wineItem);
1494             visible = TRUE;
1495         }
1496
1497         if (infoPtr->selectedItem != NULL
1498             && (wineItem == infoPtr->selectedItem
1499                 || TREEVIEW_IsChildOf(wineItem, infoPtr->selectedItem)))
1500         {
1501             if (wineItem->nextSibling)
1502                 newSelection = wineItem->nextSibling;
1503             else if (wineItem->parent != infoPtr->root)
1504                 newSelection = wineItem->parent;
1505         }
1506
1507         if (infoPtr->firstVisible == wineItem)
1508         {
1509             if (wineItem->nextSibling)
1510                newFirstVisible = wineItem->nextSibling;
1511             else if (wineItem->prevSibling)
1512                newFirstVisible = wineItem->prevSibling;
1513             else if (wineItem->parent != infoPtr->root)
1514                newFirstVisible = wineItem->parent;
1515         }
1516         else
1517             newFirstVisible = infoPtr->firstVisible;
1518
1519         TREEVIEW_RemoveItem(infoPtr, wineItem);
1520     }
1521
1522     /* Don't change if somebody else already has. */
1523     if (oldSelection == infoPtr->selectedItem)
1524     {
1525         if (TREEVIEW_ValidItem(infoPtr, newSelection))
1526             TREEVIEW_DoSelectItem(infoPtr, TVGN_CARET, newSelection, TVC_UNKNOWN);
1527         else
1528             infoPtr->selectedItem = 0;
1529     }
1530
1531     /* Validate insertMark dropItem.
1532      * hotItem ??? - used for comparison only.
1533      */
1534     if (!TREEVIEW_ValidItem(infoPtr, infoPtr->insertMarkItem))
1535         infoPtr->insertMarkItem = 0;
1536
1537     if (!TREEVIEW_ValidItem(infoPtr, infoPtr->dropItem))
1538         infoPtr->dropItem = 0;
1539
1540     if (!TREEVIEW_ValidItem(infoPtr, newFirstVisible))
1541         newFirstVisible = infoPtr->root->firstChild;
1542
1543     TREEVIEW_VerifyTree(infoPtr);
1544
1545
1546     if (visible)
1547     {
1548        TREEVIEW_RecalculateVisibleOrder(infoPtr, prev);
1549        TREEVIEW_SetFirstVisible(infoPtr, newFirstVisible, TRUE);
1550        TREEVIEW_UpdateScrollBars(infoPtr);
1551        TREEVIEW_Invalidate(infoPtr, NULL);
1552     }
1553     else if (ISVISIBLE(parent) && !TREEVIEW_HasChildren(infoPtr, parent))
1554     {
1555        /* parent lost '+/-' - update it */
1556        TREEVIEW_Invalidate(infoPtr, parent);
1557     }
1558
1559     return TRUE;
1560 }
1561
1562
1563 /* Get/Set Messages *********************************************************/
1564 static LRESULT
1565 TREEVIEW_SetRedraw(TREEVIEW_INFO* infoPtr, WPARAM wParam, LPARAM lParam)
1566 {
1567   if(wParam)
1568     infoPtr->bRedraw = TRUE;
1569   else
1570     infoPtr->bRedraw = FALSE;
1571
1572   return 0;
1573 }
1574
1575 static LRESULT
1576 TREEVIEW_GetIndent(TREEVIEW_INFO *infoPtr)
1577 {
1578     TRACE("\n");
1579     return infoPtr->uIndent;
1580 }
1581
1582 static LRESULT
1583 TREEVIEW_SetIndent(TREEVIEW_INFO *infoPtr, UINT newIndent)
1584 {
1585     TRACE("\n");
1586
1587     if (newIndent < MINIMUM_INDENT)
1588         newIndent = MINIMUM_INDENT;
1589
1590     if (infoPtr->uIndent != newIndent)
1591     {
1592         infoPtr->uIndent = newIndent;
1593         TREEVIEW_UpdateSubTree(infoPtr, infoPtr->root);
1594         TREEVIEW_UpdateScrollBars(infoPtr);
1595         TREEVIEW_Invalidate(infoPtr, NULL);
1596     }
1597
1598     return 0;
1599 }
1600
1601
1602 static LRESULT
1603 TREEVIEW_GetToolTips(TREEVIEW_INFO *infoPtr)
1604 {
1605     TRACE("\n");
1606     return infoPtr->hwndToolTip;
1607 }
1608
1609 static LRESULT
1610 TREEVIEW_SetToolTips(TREEVIEW_INFO *infoPtr, HWND hwndTT)
1611 {
1612     HWND prevToolTip;
1613
1614     TRACE("\n");
1615     prevToolTip = infoPtr->hwndToolTip;
1616     infoPtr->hwndToolTip = hwndTT;
1617
1618     return prevToolTip;
1619 }
1620
1621
1622 static LRESULT
1623 TREEVIEW_GetScrollTime(TREEVIEW_INFO *infoPtr)
1624 {
1625     return infoPtr->uScrollTime;
1626 }
1627
1628 static LRESULT
1629 TREEVIEW_SetScrollTime(TREEVIEW_INFO *infoPtr, UINT uScrollTime)
1630 {
1631     UINT uOldScrollTime = infoPtr->uScrollTime;
1632
1633     infoPtr->uScrollTime = min(uScrollTime, 100);
1634
1635     return uOldScrollTime;
1636 }
1637
1638
1639 static LRESULT
1640 TREEVIEW_GetImageList(TREEVIEW_INFO *infoPtr, WPARAM wParam)
1641 {
1642     TRACE("\n");
1643
1644     switch (wParam)
1645     {
1646     case (WPARAM)TVSIL_NORMAL:
1647         return (LRESULT)infoPtr->himlNormal;
1648
1649     case (WPARAM)TVSIL_STATE:
1650         return (LRESULT)infoPtr->himlState;
1651
1652     default:
1653         return 0;
1654     }
1655 }
1656
1657 static LRESULT
1658 TREEVIEW_SetImageList(TREEVIEW_INFO *infoPtr, WPARAM wParam, HIMAGELIST himlNew)
1659 {
1660     HIMAGELIST himlOld = 0;
1661     int oldWidth  = infoPtr->normalImageWidth;
1662     int oldHeight = infoPtr->normalImageHeight;
1663
1664
1665     TRACE("%x,%p\n", wParam, himlNew);
1666
1667     switch (wParam)
1668     {
1669     case (WPARAM)TVSIL_NORMAL:
1670         himlOld = infoPtr->himlNormal;
1671         infoPtr->himlNormal = himlNew;
1672
1673         if (himlNew != NULL)
1674             ImageList_GetIconSize(himlNew, &infoPtr->normalImageWidth,
1675                                   &infoPtr->normalImageHeight);
1676         else
1677         {
1678             infoPtr->normalImageWidth = 0;
1679             infoPtr->normalImageHeight = 0;
1680         }
1681
1682         break;
1683
1684     case (WPARAM)TVSIL_STATE:
1685         himlOld = infoPtr->himlState;
1686         infoPtr->himlState = himlNew;
1687
1688         if (himlNew != NULL)
1689             ImageList_GetIconSize(himlNew, &infoPtr->stateImageWidth,
1690                                   &infoPtr->stateImageHeight);
1691         else
1692         {
1693             infoPtr->stateImageWidth = 0;
1694             infoPtr->stateImageHeight = 0;
1695         }
1696
1697         break;
1698     }
1699
1700     if (oldWidth != infoPtr->normalImageWidth ||
1701         oldHeight != infoPtr->normalImageHeight)
1702     {
1703        TREEVIEW_UpdateSubTree(infoPtr, infoPtr->root);
1704        TREEVIEW_UpdateScrollBars(infoPtr);
1705     }
1706
1707     TREEVIEW_Invalidate(infoPtr, NULL);
1708
1709     return (LRESULT)himlOld;
1710 }
1711
1712 /* Compute the natural height (based on the font size) for items. */
1713 static UINT
1714 TREEVIEW_NaturalHeight(TREEVIEW_INFO *infoPtr)
1715 {
1716     TEXTMETRICA tm;
1717     HDC hdc = GetDC(0);
1718     HFONT hOldFont = SelectObject(hdc, infoPtr->hFont);
1719
1720     GetTextMetricsA(hdc, &tm);
1721
1722     SelectObject(hdc, hOldFont);
1723     ReleaseDC(0, hdc);
1724
1725     /* The 16 is a hack because our fonts are tiny. */
1726     /* add 2 for the focus border and 1 more for margin some apps assume */
1727     return max(16, tm.tmHeight + tm.tmExternalLeading + 3);
1728 }
1729
1730 static LRESULT
1731 TREEVIEW_SetItemHeight(TREEVIEW_INFO *infoPtr, INT newHeight)
1732 {
1733     INT prevHeight = infoPtr->uItemHeight;
1734
1735     TRACE("%d \n", newHeight);
1736     if (newHeight == -1)
1737     {
1738         infoPtr->uItemHeight = TREEVIEW_NaturalHeight(infoPtr);
1739         infoPtr->bHeightSet = FALSE;
1740     }
1741     else
1742     {
1743         infoPtr->uItemHeight = newHeight;
1744         infoPtr->bHeightSet = TRUE;
1745     }
1746
1747     /* Round down, unless we support odd ("non even") heights. */
1748     if (!(infoPtr->dwStyle) & TVS_NONEVENHEIGHT)
1749         infoPtr->uItemHeight &= ~1;
1750
1751     if (infoPtr->uItemHeight != prevHeight)
1752     {
1753         TREEVIEW_RecalculateVisibleOrder(infoPtr, NULL);
1754         TREEVIEW_UpdateScrollBars(infoPtr);
1755         TREEVIEW_Invalidate(infoPtr, NULL);
1756     }
1757
1758     return prevHeight;
1759 }
1760
1761 static LRESULT
1762 TREEVIEW_GetItemHeight(TREEVIEW_INFO *infoPtr)
1763 {
1764     TRACE("\n");
1765     return infoPtr->uItemHeight;
1766 }
1767
1768
1769 static LRESULT
1770 TREEVIEW_GetFont(TREEVIEW_INFO *infoPtr)
1771 {
1772     TRACE("%x\n", infoPtr->hFont);
1773     return infoPtr->hFont;
1774 }
1775
1776
1777 static INT CALLBACK
1778 TREEVIEW_ResetTextWidth(LPVOID pItem, DWORD unused)
1779 {
1780     (void)unused;
1781
1782     ((TREEVIEW_ITEM *)pItem)->textWidth = 0;
1783
1784     return 1;
1785 }
1786
1787 static LRESULT
1788 TREEVIEW_SetFont(TREEVIEW_INFO *infoPtr, HFONT hFont, BOOL bRedraw)
1789 {
1790     UINT uHeight = infoPtr->uItemHeight;
1791
1792     TRACE("%x %i\n", hFont, bRedraw);
1793
1794     infoPtr->hFont = hFont ? hFont : GetStockObject(SYSTEM_FONT);
1795
1796     DeleteObject(infoPtr->hBoldFont);
1797     infoPtr->hBoldFont = TREEVIEW_CreateBoldFont(infoPtr->hFont);
1798
1799     if (!infoPtr->bHeightSet)
1800         infoPtr->uItemHeight = TREEVIEW_NaturalHeight(infoPtr);
1801
1802     if (uHeight != infoPtr->uItemHeight)
1803        TREEVIEW_RecalculateVisibleOrder(infoPtr, NULL);
1804
1805     DPA_EnumCallback(infoPtr->items, TREEVIEW_ResetTextWidth, 0);
1806
1807     TREEVIEW_UpdateSubTree(infoPtr, infoPtr->root);
1808     TREEVIEW_UpdateScrollBars(infoPtr);
1809
1810     if (bRedraw)
1811         TREEVIEW_Invalidate(infoPtr, NULL);
1812
1813     return 0;
1814 }
1815
1816
1817 static LRESULT
1818 TREEVIEW_GetLineColor(TREEVIEW_INFO *infoPtr)
1819 {
1820     TRACE("\n");
1821     return (LRESULT)infoPtr->clrLine;
1822 }
1823
1824 static LRESULT
1825 TREEVIEW_SetLineColor(TREEVIEW_INFO *infoPtr, COLORREF color)
1826 {
1827     COLORREF prevColor = infoPtr->clrLine;
1828
1829     TRACE("\n");
1830     infoPtr->clrLine = color;
1831     return (LRESULT)prevColor;
1832 }
1833
1834
1835 static LRESULT
1836 TREEVIEW_GetTextColor(TREEVIEW_INFO *infoPtr)
1837 {
1838     TRACE("\n");
1839     return (LRESULT)infoPtr->clrText;
1840 }
1841
1842 static LRESULT
1843 TREEVIEW_SetTextColor(TREEVIEW_INFO *infoPtr, COLORREF color)
1844 {
1845     COLORREF prevColor = infoPtr->clrText;
1846
1847     TRACE("\n");
1848     infoPtr->clrText = color;
1849
1850     if (infoPtr->clrText != prevColor)
1851         TREEVIEW_Invalidate(infoPtr, NULL);
1852
1853     return (LRESULT)prevColor;
1854 }
1855
1856
1857 static LRESULT
1858 TREEVIEW_GetBkColor(TREEVIEW_INFO *infoPtr)
1859 {
1860     TRACE("\n");
1861     return (LRESULT)infoPtr->clrBk;
1862 }
1863
1864 static LRESULT
1865 TREEVIEW_SetBkColor(TREEVIEW_INFO *infoPtr, COLORREF newColor)
1866 {
1867     COLORREF prevColor = infoPtr->clrBk;
1868
1869     TRACE("\n");
1870     infoPtr->clrBk = newColor;
1871
1872     if (newColor != prevColor)
1873         TREEVIEW_Invalidate(infoPtr, NULL);
1874
1875     return (LRESULT)prevColor;
1876 }
1877
1878
1879 static LRESULT
1880 TREEVIEW_GetInsertMarkColor(TREEVIEW_INFO *infoPtr)
1881 {
1882     TRACE("\n");
1883     return (LRESULT)infoPtr->clrInsertMark;
1884 }
1885
1886 static LRESULT
1887 TREEVIEW_SetInsertMarkColor(TREEVIEW_INFO *infoPtr, COLORREF color)
1888 {
1889     COLORREF prevColor = infoPtr->clrInsertMark;
1890
1891     TRACE("%lx\n", color);
1892     infoPtr->clrInsertMark = color;
1893
1894     return (LRESULT)prevColor;
1895 }
1896
1897
1898 static LRESULT
1899 TREEVIEW_SetInsertMark(TREEVIEW_INFO *infoPtr, BOOL wParam, HTREEITEM item)
1900 {
1901     TRACE("%d %p\n", wParam, item);
1902
1903     if (!TREEVIEW_ValidItem(infoPtr, item))
1904         return 0;
1905
1906     infoPtr->insertBeforeorAfter = wParam;
1907     infoPtr->insertMarkItem = item;
1908
1909     TREEVIEW_Invalidate(infoPtr, NULL);
1910
1911     return 1;
1912 }
1913
1914
1915 /************************************************************************
1916  * Some serious braindamage here. lParam is a pointer to both the
1917  * input HTREEITEM and the output RECT.
1918  */
1919 static LRESULT
1920 TREEVIEW_GetItemRect(TREEVIEW_INFO *infoPtr, BOOL fTextRect, LPRECT lpRect)
1921 {
1922     TREEVIEW_ITEM *wineItem;
1923     const HTREEITEM *pItem = (HTREEITEM *)lpRect;
1924
1925     TRACE("\n");
1926     /*
1927      * validate parameters
1928      */
1929     if (pItem == NULL)
1930         return FALSE;
1931
1932     wineItem = *pItem;
1933     if (!TREEVIEW_ValidItem(infoPtr, wineItem) || !ISVISIBLE(wineItem))
1934         return FALSE;
1935
1936     /*
1937      * If wParam is TRUE return the text size otherwise return
1938      * the whole item size
1939      */
1940     if (fTextRect)
1941     {
1942         /* Windows does not send TVN_GETDISPINFO here. */
1943
1944         lpRect->top = wineItem->rect.top;
1945         lpRect->bottom = wineItem->rect.bottom;
1946
1947         lpRect->left = wineItem->textOffset;
1948         lpRect->right = wineItem->textOffset + wineItem->textWidth;
1949     }
1950     else
1951     {
1952         *lpRect = wineItem->rect;
1953     }
1954
1955     TRACE("%s [L:%d R:%d T:%d B:%d]\n", fTextRect ? "text" : "item",
1956           lpRect->left, lpRect->right, lpRect->top, lpRect->bottom);
1957
1958     return TRUE;
1959 }
1960
1961 static inline LRESULT
1962 TREEVIEW_GetVisibleCount(TREEVIEW_INFO *infoPtr)
1963 {
1964     /* Suprise! This does not take integral height into account. */
1965     return infoPtr->clientHeight / infoPtr->uItemHeight;
1966 }
1967
1968
1969 static LRESULT
1970 TREEVIEW_GetItemA(TREEVIEW_INFO *infoPtr, LPTVITEMEXA tvItem)
1971 {
1972     TREEVIEW_ITEM *wineItem;
1973
1974     wineItem = tvItem->hItem;
1975     if (!TREEVIEW_ValidItem(infoPtr, wineItem))
1976         return FALSE;
1977
1978     TREEVIEW_UpdateDispInfo(infoPtr, wineItem, tvItem->mask);
1979
1980     if (tvItem->mask & TVIF_CHILDREN)
1981         tvItem->cChildren = wineItem->cChildren;
1982
1983     if (tvItem->mask & TVIF_HANDLE)
1984         tvItem->hItem = wineItem;
1985
1986     if (tvItem->mask & TVIF_IMAGE)
1987         tvItem->iImage = wineItem->iImage;
1988
1989     if (tvItem->mask & TVIF_INTEGRAL)
1990         tvItem->iIntegral = wineItem->iIntegral;
1991
1992     /* undocumented: windows ignores TVIF_PARAM and
1993      * * always sets lParam
1994      */
1995     tvItem->lParam = wineItem->lParam;
1996
1997     if (tvItem->mask & TVIF_SELECTEDIMAGE)
1998         tvItem->iSelectedImage = wineItem->iSelectedImage;
1999
2000     if (tvItem->mask & TVIF_STATE)
2001         tvItem->state = wineItem->state & tvItem->stateMask;
2002
2003     if (tvItem->mask & TVIF_TEXT)
2004         lstrcpynA(tvItem->pszText, wineItem->pszText, tvItem->cchTextMax);
2005
2006     TRACE("item <%p>, txt %p, img %p, mask %x\n",
2007           wineItem, tvItem->pszText, &tvItem->iImage, tvItem->mask);
2008
2009     return TRUE;
2010 }
2011
2012 /* Beware MSDN Library Visual Studio 6.0. It says -1 on failure, 0 on success,
2013  * which is wrong. */
2014 static LRESULT
2015 TREEVIEW_SetItemA(TREEVIEW_INFO *infoPtr, LPTVITEMEXA tvItem)
2016 {
2017     TREEVIEW_ITEM *wineItem;
2018     TREEVIEW_ITEM originalItem;
2019
2020     wineItem = tvItem->hItem;
2021
2022     TRACE("item %d,mask %x\n", TREEVIEW_GetItemIndex(infoPtr, wineItem),
2023           tvItem->mask);
2024
2025     if (!TREEVIEW_ValidItem(infoPtr, wineItem))
2026         return FALSE;
2027
2028     if (!TREEVIEW_DoSetItem(infoPtr, wineItem, tvItem))
2029         return FALSE;
2030
2031     /* store the orignal item values */
2032     originalItem = *wineItem;
2033
2034     /* If the text or TVIS_BOLD was changed, and it is visible, recalculate. */
2035     if ((tvItem->mask & TVIF_TEXT
2036          || (tvItem->mask & TVIF_STATE && tvItem->stateMask & TVIS_BOLD))
2037         && ISVISIBLE(wineItem))
2038     {
2039         TREEVIEW_UpdateDispInfo(infoPtr, wineItem, TVIF_TEXT);
2040         TREEVIEW_ComputeTextWidth(infoPtr, wineItem, 0);
2041     }
2042
2043     if (tvItem->mask != 0 && ISVISIBLE(wineItem))
2044     {
2045         /* The refresh updates everything, but we can't wait until then. */
2046         TREEVIEW_ComputeItemInternalMetrics(infoPtr, wineItem);
2047
2048         /* if any of the items values changed, redraw the item */
2049         if(memcmp(&originalItem, wineItem, sizeof(TREEVIEW_ITEM)))
2050         {
2051             if (tvItem->mask & TVIF_INTEGRAL)
2052             {
2053                 TREEVIEW_RecalculateVisibleOrder(infoPtr, wineItem);
2054                 TREEVIEW_UpdateScrollBars(infoPtr);
2055
2056                 TREEVIEW_Invalidate(infoPtr, NULL);
2057             }
2058             else
2059             {
2060                 TREEVIEW_UpdateScrollBars(infoPtr);
2061                 TREEVIEW_Invalidate(infoPtr, wineItem);
2062             }
2063         }
2064     }
2065
2066     return TRUE;
2067 }
2068
2069 static LRESULT
2070 TREEVIEW_GetItemW(TREEVIEW_INFO *infoPtr, LPTVITEMEXW tvItem)
2071 {
2072     TREEVIEW_ITEM *wineItem;
2073     INT         iItem;
2074     iItem = (INT)tvItem->hItem;
2075
2076     wineItem = tvItem->hItem;
2077     if(!TREEVIEW_ValidItem (infoPtr, wineItem))
2078         return FALSE;
2079
2080     TREEVIEW_UpdateDispInfo(infoPtr, wineItem, tvItem->mask);
2081
2082     if (tvItem->mask & TVIF_CHILDREN) {
2083         if (TVIF_CHILDREN==I_CHILDRENCALLBACK)
2084             FIXME("I_CHILDRENCALLBACK not supported\n");
2085         tvItem->cChildren = wineItem->cChildren;
2086     }
2087
2088     if (tvItem->mask & TVIF_HANDLE) {
2089         tvItem->hItem = wineItem;
2090     }
2091     if (tvItem->mask & TVIF_IMAGE) {
2092         tvItem->iImage = wineItem->iImage;
2093     }
2094     if (tvItem->mask & TVIF_INTEGRAL) {
2095         tvItem->iIntegral = wineItem->iIntegral;
2096     }
2097     /* undocumented: windows ignores TVIF_PARAM and
2098      * always sets lParam           */
2099     tvItem->lParam = wineItem->lParam;
2100     if (tvItem->mask & TVIF_SELECTEDIMAGE) {
2101         tvItem->iSelectedImage = wineItem->iSelectedImage;
2102     }
2103     if (tvItem->mask & TVIF_STATE) {
2104         tvItem->state = wineItem->state & tvItem->stateMask;
2105     }
2106
2107     if (tvItem->mask & TVIF_TEXT) {
2108         if (wineItem->pszText == LPSTR_TEXTCALLBACKA) {
2109             tvItem->pszText = LPSTR_TEXTCALLBACKW;
2110             FIXME(" GetItem called with LPSTR_TEXTCALLBACK\n");
2111         }
2112         else if (wineItem->pszText) {
2113             TRACE("orig str %s at %p\n",
2114                   debugstr_a(wineItem->pszText), wineItem->pszText);
2115             MultiByteToWideChar(CP_ACP, 0, wineItem->pszText,
2116                                 -1 , tvItem->pszText, tvItem->cchTextMax);
2117         }
2118     }
2119
2120     TRACE("item %d<%p>, txt %p<%s>, img %p, action %x\n",
2121           iItem, tvItem, tvItem->pszText, debugstr_w(tvItem->pszText),
2122           &tvItem->iImage, tvItem->mask);
2123     return TRUE;
2124 }
2125
2126 static LRESULT
2127 TREEVIEW_SetItemW(TREEVIEW_INFO *infoPtr, LPTVITEMEXW tvItem)
2128 {
2129     TVITEMEXA tvItemA;
2130     INT len;
2131     LRESULT rc;
2132
2133     tvItemA.mask = tvItem->mask;
2134     tvItemA.hItem = tvItem->hItem;
2135     tvItemA.state = tvItem->state;
2136     tvItemA.stateMask = tvItem->stateMask;
2137     if (tvItem->mask & TVIF_TEXT) {
2138         len = WideCharToMultiByte(CP_ACP, 0, tvItem->pszText, -1,
2139                                   NULL ,0 , NULL,NULL);
2140         if (len) {
2141             len ++;
2142             tvItemA.pszText = HeapAlloc(GetProcessHeap(),0,len*sizeof(WCHAR));
2143             len = WideCharToMultiByte(CP_ACP, 0, tvItem->pszText, -1,
2144                                       tvItemA.pszText ,len*sizeof(WCHAR),
2145                                       NULL,NULL);
2146         }
2147         else
2148             tvItemA.pszText = NULL;
2149     }
2150     tvItemA.cchTextMax = tvItem->cchTextMax;
2151     tvItemA.iImage = tvItem->iImage;
2152     tvItemA.iSelectedImage = tvItem->iSelectedImage;
2153     tvItemA.cChildren = tvItem->cChildren;
2154     tvItemA.lParam = tvItem->lParam;
2155     tvItemA.iIntegral = tvItem->iIntegral;
2156
2157     rc = TREEVIEW_SetItemA(infoPtr,&tvItemA);
2158     HeapFree(GetProcessHeap(),0,tvItemA.pszText);
2159     return rc;
2160 }
2161
2162 static LRESULT
2163 TREEVIEW_GetItemState(TREEVIEW_INFO *infoPtr, HTREEITEM wineItem, UINT mask)
2164 {
2165     TRACE("\n");
2166
2167     if (!wineItem || !TREEVIEW_ValidItem(infoPtr, wineItem))
2168         return 0;
2169
2170     return (wineItem->state & mask);
2171 }
2172
2173 static LRESULT
2174 TREEVIEW_GetNextItem(TREEVIEW_INFO *infoPtr, UINT which, HTREEITEM wineItem)
2175 {
2176     TREEVIEW_ITEM *retval;
2177
2178     retval = 0;
2179
2180     /* handle all the global data here */
2181     switch (which)
2182     {
2183     case TVGN_CHILD:            /* Special case: child of 0 is root */
2184         if (wineItem)
2185             break;
2186         /* fall through */
2187     case TVGN_ROOT:
2188         retval = infoPtr->root->firstChild;
2189         break;
2190
2191     case TVGN_CARET:
2192         retval = infoPtr->selectedItem;
2193         break;
2194
2195     case TVGN_FIRSTVISIBLE:
2196         retval = infoPtr->firstVisible;
2197         break;
2198
2199     case TVGN_DROPHILITE:
2200         retval = infoPtr->dropItem;
2201         break;
2202
2203     case TVGN_LASTVISIBLE:
2204         retval = TREEVIEW_GetLastListItem(infoPtr, infoPtr->root);
2205         break;
2206     }
2207
2208     if (retval)
2209     {
2210         TRACE("flags:%x, returns %p\n", which, retval);
2211         return (LRESULT)retval;
2212     }
2213
2214     if (wineItem == TVI_ROOT) wineItem = infoPtr->root;
2215
2216     if (!TREEVIEW_ValidItem(infoPtr, wineItem))
2217         return FALSE;
2218
2219     switch (which)
2220     {
2221     case TVGN_NEXT:
2222         retval = wineItem->nextSibling;
2223         break;
2224     case TVGN_PREVIOUS:
2225         retval = wineItem->prevSibling;
2226         break;
2227     case TVGN_PARENT:
2228         retval = (wineItem->parent != infoPtr->root) ? wineItem->parent : NULL;
2229         break;
2230     case TVGN_CHILD:
2231         retval = wineItem->firstChild;
2232         break;
2233     case TVGN_NEXTVISIBLE:
2234         retval = TREEVIEW_GetNextListItem(infoPtr, wineItem);
2235         break;
2236     case TVGN_PREVIOUSVISIBLE:
2237         retval = TREEVIEW_GetPrevListItem(infoPtr, wineItem);
2238         break;
2239     default:
2240         TRACE("Unknown msg %x,item %p\n", which, wineItem);
2241         break;
2242     }
2243
2244     TRACE("flags:%x, item %p;returns %p\n", which, wineItem, retval);
2245     return (LRESULT)retval;
2246 }
2247
2248
2249 static LRESULT
2250 TREEVIEW_GetCount(TREEVIEW_INFO *infoPtr)
2251 {
2252     TRACE(" %d\n", infoPtr->uNumItems);
2253     return (LRESULT)infoPtr->uNumItems;
2254 }
2255
2256 static VOID
2257 TREEVIEW_ToggleItemState(TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *item)
2258 {
2259     if (infoPtr->dwStyle & TVS_CHECKBOXES)
2260     {
2261         static const unsigned int state_table[] = { 0, 2, 1 };
2262
2263         unsigned int state;
2264
2265         state = STATEIMAGEINDEX(item->state);
2266         TRACE("state:%x\n", state);
2267         item->state &= ~TVIS_STATEIMAGEMASK;
2268
2269         if (state < 3)
2270             state = state_table[state];
2271
2272         item->state |= INDEXTOSTATEIMAGEMASK(state);
2273
2274         TRACE("state:%x\n", state);
2275         TREEVIEW_Invalidate(infoPtr, item);
2276     }
2277 }
2278
2279
2280 /* Painting *************************************************************/
2281
2282 /* Draw the lines and expand button for an item. Also draws one section
2283  * of the line from item's parent to item's parent's next sibling. */
2284 static void
2285 TREEVIEW_DrawItemLines(TREEVIEW_INFO *infoPtr, HDC hdc, TREEVIEW_ITEM *item)
2286 {
2287     LONG centerx, centery;
2288     BOOL lar = ((infoPtr->dwStyle
2289                  & (TVS_LINESATROOT|TVS_HASLINES|TVS_HASBUTTONS))
2290                 > TVS_LINESATROOT);
2291
2292     if (!lar && item->iLevel == 0)
2293         return;
2294
2295     centerx = (item->linesOffset + item->stateOffset) / 2;
2296     centery = (item->rect.top + item->rect.bottom) / 2;
2297
2298     if (infoPtr->dwStyle & TVS_HASLINES)
2299     {
2300         HPEN hOldPen, hNewPen;
2301         HTREEITEM parent;
2302
2303         /*
2304          * Get a dotted grey pen
2305          */
2306         hNewPen = CreatePen(PS_ALTERNATE, 0, infoPtr->clrLine);
2307         hOldPen = SelectObject(hdc, hNewPen);
2308
2309         MoveToEx(hdc, item->stateOffset, centery, NULL);
2310         LineTo(hdc, centerx - 1, centery);
2311
2312         if (item->prevSibling || item->parent != infoPtr->root)
2313         {
2314             MoveToEx(hdc, centerx, item->rect.top, NULL);
2315             LineTo(hdc, centerx, centery);
2316         }
2317
2318         if (item->nextSibling)
2319         {
2320             MoveToEx(hdc, centerx, centery, NULL);
2321             LineTo(hdc, centerx, item->rect.bottom + 1);
2322         }
2323
2324         /* Draw the line from our parent to its next sibling. */
2325         parent = item->parent;
2326         while (parent != infoPtr->root)
2327         {
2328             int pcenterx = (parent->linesOffset + parent->stateOffset) / 2;
2329
2330             if (parent->nextSibling
2331                 /* skip top-levels unless TVS_LINESATROOT */
2332                 && parent->stateOffset > parent->linesOffset)
2333             {
2334                 MoveToEx(hdc, pcenterx, item->rect.top, NULL);
2335                 LineTo(hdc, pcenterx, item->rect.bottom + 1);
2336             }
2337
2338             parent = parent->parent;
2339         }
2340
2341         SelectObject(hdc, hOldPen);
2342         DeleteObject(hNewPen);
2343     }
2344
2345     /*
2346      * Display the (+/-) signs
2347      */
2348
2349     if (infoPtr->dwStyle & TVS_HASBUTTONS)
2350     {
2351         if (item->cChildren)
2352         {
2353             LONG height = item->rect.bottom - item->rect.top;
2354             LONG width  = item->stateOffset - item->linesOffset;
2355             LONG rectsize = min(height, width) / 4;
2356             /* plussize = ceil(rectsize * 3/4) */
2357             LONG plussize = (rectsize + 1) * 3 / 4;
2358
2359             HPEN hNewPen  = CreatePen(PS_SOLID, 0, infoPtr->clrLine);
2360             HPEN hOldPen  = SelectObject(hdc, hNewPen);
2361             HBRUSH hbr    = CreateSolidBrush(infoPtr->clrBk);
2362             HBRUSH hbrOld = SelectObject(hdc, hbr);
2363
2364             Rectangle(hdc, centerx - rectsize, centery - rectsize,
2365                       centerx + rectsize + 1, centery + rectsize + 1);
2366
2367             SelectObject(hdc, hbrOld);
2368             DeleteObject(hbr);
2369
2370             SelectObject(hdc, hOldPen);
2371             DeleteObject(hNewPen);
2372
2373             MoveToEx(hdc, centerx - plussize + 1, centery, NULL);
2374             LineTo(hdc, centerx + plussize, centery);
2375
2376             if (!(item->state & TVIS_EXPANDED))
2377             {
2378                 MoveToEx(hdc, centerx, centery - plussize + 1, NULL);
2379                 LineTo(hdc, centerx, centery + plussize);
2380             }
2381         }
2382     }
2383 }
2384
2385 static void
2386 TREEVIEW_DrawItem(TREEVIEW_INFO *infoPtr, HDC hdc, TREEVIEW_ITEM *wineItem)
2387 {
2388     INT cditem;
2389     HFONT hOldFont;
2390     int centery;
2391
2392     hOldFont = SelectObject(hdc, TREEVIEW_FontForItem(infoPtr, wineItem));
2393
2394     TREEVIEW_UpdateDispInfo(infoPtr, wineItem, CALLBACK_MASK_ALL);
2395
2396     /* The custom draw handler can query the text rectangle,
2397      * so get ready. */
2398     TREEVIEW_ComputeTextWidth(infoPtr, wineItem, hdc);
2399
2400     cditem = 0;
2401
2402     if (infoPtr->cdmode & CDRF_NOTIFYITEMDRAW)
2403     {
2404         cditem = TREEVIEW_SendCustomDrawItemNotify
2405             (infoPtr, hdc, wineItem, CDDS_ITEMPREPAINT);
2406         TRACE("prepaint:cditem-app returns 0x%x\n", cditem);
2407
2408         if (cditem & CDRF_SKIPDEFAULT)
2409         {
2410             SelectObject(hdc, hOldFont);
2411             return;
2412         }
2413     }
2414
2415     if (cditem & CDRF_NEWFONT)
2416         TREEVIEW_ComputeTextWidth(infoPtr, wineItem, hdc);
2417
2418     TREEVIEW_DrawItemLines(infoPtr, hdc, wineItem);
2419
2420     centery = (wineItem->rect.top + wineItem->rect.bottom) / 2;
2421
2422     /*
2423      * Display the images associated with this item
2424      */
2425     {
2426         INT imageIndex;
2427
2428         /* State images are displayed to the left of the Normal image
2429          * image number is in state; zero should be `display no image'.
2430          */
2431         imageIndex = STATEIMAGEINDEX(wineItem->state);
2432
2433         if (infoPtr->himlState && imageIndex)
2434         {
2435             ImageList_Draw(infoPtr->himlState, imageIndex, hdc,
2436                            wineItem->stateOffset,
2437                            centery - infoPtr->stateImageHeight / 2,
2438                            ILD_NORMAL);
2439         }
2440
2441         /* Now, draw the normal image; can be either selected or
2442          * non-selected image.
2443          */
2444
2445         if ((wineItem->state & TVIS_SELECTED) && (wineItem->iSelectedImage))
2446         {
2447             /* The item is currently selected */
2448             imageIndex = wineItem->iSelectedImage;
2449         }
2450         else
2451         {
2452             /* The item is not selected */
2453             imageIndex = wineItem->iImage;
2454         }
2455
2456         if (infoPtr->himlNormal)
2457         {
2458             int ovlIdx = wineItem->state & TVIS_OVERLAYMASK;
2459
2460             ImageList_Draw(infoPtr->himlNormal, imageIndex, hdc,
2461                            wineItem->imageOffset,
2462                            centery - infoPtr->normalImageHeight / 2,
2463                            ILD_NORMAL | ovlIdx);
2464         }
2465     }
2466
2467
2468     /*
2469      * Display the text associated with this item
2470      */
2471
2472     /* Don't paint item's text if it's being edited */
2473     if (!infoPtr->hwndEdit || (infoPtr->selectedItem != wineItem))
2474     {
2475         if (wineItem->pszText)
2476         {
2477             COLORREF oldTextColor = 0;
2478             INT oldBkMode;
2479             HBRUSH hbrBk = 0;
2480             BOOL inFocus = (GetFocus() == infoPtr->hwnd);
2481             RECT rcText;
2482
2483             oldBkMode = SetBkMode(hdc, TRANSPARENT);
2484
2485             /* - If item is drop target or it is selected and window is in focus -
2486              * use blue background (COLOR_HIGHLIGHT).
2487              * - If item is selected, window is not in focus, but it has style
2488              * TVS_SHOWSELALWAYS - use grey background (COLOR_BTNFACE)
2489              * - Otherwise - don't fill background
2490              */
2491             if ((wineItem->state & TVIS_DROPHILITED) || ((wineItem == infoPtr->focusedItem) && !(wineItem->state & TVIS_SELECTED)) ||
2492                 ((wineItem->state & TVIS_SELECTED) && (!infoPtr->focusedItem) &&
2493                  (inFocus || (infoPtr->dwStyle & TVS_SHOWSELALWAYS))))
2494             {
2495                 if ((wineItem->state & TVIS_DROPHILITED) || inFocus)
2496                 {
2497                     hbrBk = CreateSolidBrush(GetSysColor(COLOR_HIGHLIGHT));
2498                     oldTextColor =
2499                         SetTextColor(hdc, GetSysColor(COLOR_HIGHLIGHTTEXT));
2500                 }
2501                 else
2502                 {
2503                     hbrBk = CreateSolidBrush(GetSysColor(COLOR_BTNFACE));
2504
2505                     if (infoPtr->clrText == -1)
2506                         oldTextColor =
2507                             SetTextColor(hdc, GetSysColor(COLOR_WINDOWTEXT));
2508                     else
2509                         oldTextColor = SetTextColor(hdc, infoPtr->clrText);
2510                 }
2511             }
2512             else
2513             {
2514                 if (infoPtr->clrText == -1)
2515                     oldTextColor =
2516                         SetTextColor(hdc, GetSysColor(COLOR_WINDOWTEXT));
2517                 else
2518                     oldTextColor = SetTextColor(hdc, infoPtr->clrText);
2519             }
2520
2521             rcText.top = wineItem->rect.top;
2522             rcText.bottom = wineItem->rect.bottom;
2523             rcText.left = wineItem->textOffset;
2524             rcText.right = rcText.left + wineItem->textWidth + 4;
2525
2526             if (hbrBk)
2527             {
2528                 FillRect(hdc, &rcText, hbrBk);
2529                 DeleteObject(hbrBk);
2530             }
2531
2532             /* Draw the box around the selected item */
2533             if ((wineItem == infoPtr->selectedItem) && inFocus)
2534             {
2535                 DrawFocusRect(hdc,&rcText);
2536             }
2537
2538             InflateRect(&rcText, -2, -1); /* allow for the focus rect */
2539
2540             TRACE("drawing text %s at (%d,%d)-(%d,%d)\n",
2541                   debugstr_a(wineItem->pszText),
2542                   rcText.left, rcText.top, rcText.right, rcText.bottom);
2543
2544             /* Draw it */
2545             DrawTextA(hdc,
2546                       wineItem->pszText,
2547                       lstrlenA(wineItem->pszText),
2548                       &rcText,
2549                       DT_CENTER | DT_VCENTER | DT_SINGLELINE | DT_NOPREFIX);
2550
2551             /* Restore the hdc state */
2552             SetTextColor(hdc, oldTextColor);
2553
2554             if (oldBkMode != TRANSPARENT)
2555                 SetBkMode(hdc, oldBkMode);
2556         }
2557     }
2558
2559     /* Draw insertion mark if necessary */
2560
2561     if (infoPtr->insertMarkItem)
2562         TRACE("item:%d,mark:%d\n",
2563               TREEVIEW_GetItemIndex(infoPtr, wineItem),
2564               (int)infoPtr->insertMarkItem);
2565
2566     if (wineItem == infoPtr->insertMarkItem)
2567     {
2568         HPEN hNewPen, hOldPen;
2569         int offset;
2570         int left, right;
2571
2572         hNewPen = CreatePen(PS_SOLID, 2, infoPtr->clrInsertMark);
2573         hOldPen = SelectObject(hdc, hNewPen);
2574
2575         if (infoPtr->insertBeforeorAfter)
2576             offset = wineItem->rect.bottom - 1;
2577         else
2578             offset = wineItem->rect.top + 1;
2579
2580         left = wineItem->textOffset - 2;
2581         right = wineItem->textOffset + wineItem->textWidth + 2;
2582
2583         MoveToEx(hdc, left, offset - 3, NULL);
2584         LineTo(hdc, left, offset + 4);
2585
2586         MoveToEx(hdc, left, offset, NULL);
2587         LineTo(hdc, right + 1, offset);
2588
2589         MoveToEx(hdc, right, offset + 3, NULL);
2590         LineTo(hdc, right, offset - 4);
2591
2592         SelectObject(hdc, hOldPen);
2593         DeleteObject(hNewPen);
2594     }
2595
2596     if (cditem & CDRF_NOTIFYPOSTPAINT)
2597     {
2598         cditem = TREEVIEW_SendCustomDrawItemNotify
2599             (infoPtr, hdc, wineItem, CDDS_ITEMPOSTPAINT);
2600         TRACE("postpaint:cditem-app returns 0x%x\n", cditem);
2601     }
2602
2603     SelectObject(hdc, hOldFont);
2604 }
2605
2606 /* Computes treeHeight and treeWidth and updates the scroll bars.
2607  */
2608 static void
2609 TREEVIEW_UpdateScrollBars(TREEVIEW_INFO *infoPtr)
2610 {
2611     TREEVIEW_ITEM *wineItem;
2612     HWND hwnd = infoPtr->hwnd;
2613     BOOL vert = FALSE;
2614     BOOL horz = FALSE;
2615     SCROLLINFO si;
2616     LONG scrollX = infoPtr->scrollX;
2617
2618     infoPtr->treeWidth = 0;
2619     infoPtr->treeHeight = 0;
2620
2621     /* We iterate through all visible items in order to get the tree height
2622      * and width */
2623     wineItem = infoPtr->root->firstChild;
2624
2625     while (wineItem != NULL)
2626     {
2627         if (ISVISIBLE(wineItem))
2628         {
2629             /* actually we draw text at textOffset + 2 */
2630             if (2+wineItem->textOffset+wineItem->textWidth > infoPtr->treeWidth)
2631                 infoPtr->treeWidth = wineItem->textOffset+wineItem->textWidth+2;
2632
2633             /* This is scroll-adjusted, but we fix this below. */
2634             infoPtr->treeHeight = wineItem->rect.bottom;
2635         }
2636
2637         wineItem = TREEVIEW_GetNextListItem(infoPtr, wineItem);
2638     }
2639
2640     /* Fix the scroll adjusted treeHeight and treeWidth. */
2641     if (infoPtr->root->firstChild)
2642         infoPtr->treeHeight -= infoPtr->root->firstChild->rect.top;
2643
2644     infoPtr->treeWidth += infoPtr->scrollX;
2645
2646     if (infoPtr->dwStyle & TVS_NOSCROLL) return;
2647
2648     /* Adding one scroll bar may take up enough space that it forces us
2649      * to add the other as well. */
2650     if (infoPtr->treeHeight > infoPtr->clientHeight)
2651     {
2652         vert = TRUE;
2653
2654         if (infoPtr->treeWidth
2655             > infoPtr->clientWidth - GetSystemMetrics(SM_CXVSCROLL))
2656             horz = TRUE;
2657     }
2658     else if (infoPtr->treeWidth > infoPtr->clientWidth)
2659         horz = TRUE;
2660
2661     if (!vert && horz && infoPtr->treeHeight
2662         > infoPtr->clientHeight - GetSystemMetrics(SM_CYVSCROLL))
2663         vert = TRUE;
2664
2665     if (horz && (infoPtr->dwStyle & TVS_NOHSCROLL)) horz = FALSE;
2666
2667     si.cbSize = sizeof(SCROLLINFO);
2668     si.fMask  = SIF_POS|SIF_RANGE|SIF_PAGE;
2669     si.nMin   = 0;
2670
2671     if (vert)
2672     {
2673         si.nPage = TREEVIEW_GetVisibleCount(infoPtr);
2674         si.nPos  = infoPtr->firstVisible->visibleOrder;
2675         si.nMax  = infoPtr->maxVisibleOrder - 1;
2676
2677         SetScrollInfo(hwnd, SB_VERT, &si, TRUE);
2678
2679         if (!(infoPtr->uInternalStatus & TV_VSCROLL))
2680             ShowScrollBar(hwnd, SB_VERT, TRUE);
2681         infoPtr->uInternalStatus |= TV_VSCROLL;
2682     }
2683     else
2684     {
2685         if (infoPtr->uInternalStatus & TV_VSCROLL)
2686             ShowScrollBar(hwnd, SB_VERT, FALSE);
2687         infoPtr->uInternalStatus &= ~TV_VSCROLL;
2688     }
2689
2690     if (horz)
2691     {
2692         si.nPage = infoPtr->clientWidth;
2693         si.nPos  = infoPtr->scrollX;
2694         si.nMax  = infoPtr->treeWidth - 1;
2695
2696         if (si.nPos > si.nMax - max( si.nPage-1, 0 ))
2697         {
2698            si.nPos = si.nMax - max( si.nPage-1, 0 );
2699            scrollX = si.nPos;
2700         }
2701
2702         if (!(infoPtr->uInternalStatus & TV_HSCROLL))
2703             ShowScrollBar(hwnd, SB_HORZ, TRUE);
2704         infoPtr->uInternalStatus |= TV_HSCROLL;
2705
2706         SetScrollInfo(hwnd, SB_HORZ, &si, TRUE);
2707     }
2708     else
2709     {
2710         if (infoPtr->uInternalStatus & TV_HSCROLL)
2711             ShowScrollBar(hwnd, SB_HORZ, FALSE);
2712         infoPtr->uInternalStatus &= ~TV_HSCROLL;
2713
2714         scrollX = 0;
2715     }
2716
2717     if (infoPtr->scrollX != scrollX)
2718     {
2719         TREEVIEW_HScroll(infoPtr,
2720                          MAKEWPARAM(SB_THUMBPOSITION, scrollX));
2721     }
2722
2723     if (!horz)
2724         infoPtr->uInternalStatus &= ~TV_HSCROLL;
2725 }
2726
2727 /* CtrlSpy doesn't mention this, but CorelDRAW's object manager needs it. */
2728 static LRESULT
2729 TREEVIEW_EraseBackground(TREEVIEW_INFO *infoPtr, HDC hDC)
2730 {
2731     HBRUSH hBrush = CreateSolidBrush(infoPtr->clrBk);
2732     RECT rect;
2733
2734     GetClientRect(infoPtr->hwnd, &rect);
2735     FillRect(hDC, &rect, hBrush);
2736     DeleteObject(hBrush);
2737
2738     return 1;
2739 }
2740
2741 static void
2742 TREEVIEW_Refresh(TREEVIEW_INFO *infoPtr, HDC hdc, RECT *rc)
2743 {
2744     HWND hwnd = infoPtr->hwnd;
2745     RECT rect = *rc;
2746     TREEVIEW_ITEM *wineItem;
2747
2748     if (infoPtr->clientHeight == 0 || infoPtr->clientWidth == 0)
2749     {
2750         TRACE("empty window\n");
2751         return;
2752     }
2753
2754     infoPtr->cdmode = TREEVIEW_SendCustomDrawNotify(infoPtr, CDDS_PREPAINT,
2755                                                     hdc, rect);
2756
2757     if (infoPtr->cdmode == CDRF_SKIPDEFAULT)
2758     {
2759         ReleaseDC(hwnd, hdc);
2760         return;
2761     }
2762
2763     for (wineItem = infoPtr->root->firstChild;
2764          wineItem != NULL;
2765          wineItem = TREEVIEW_GetNextListItem(infoPtr, wineItem))
2766     {
2767         if (ISVISIBLE(wineItem))
2768         {
2769             /* Avoid unneeded calculations */
2770             if (wineItem->rect.top > rect.bottom)
2771                 break;
2772             if (wineItem->rect.bottom < rect.top)
2773                 continue;
2774
2775             TREEVIEW_DrawItem(infoPtr, hdc, wineItem);
2776         }
2777     }
2778
2779     TREEVIEW_UpdateScrollBars(infoPtr);
2780
2781     if (infoPtr->cdmode & CDRF_NOTIFYPOSTPAINT)
2782         infoPtr->cdmode =
2783             TREEVIEW_SendCustomDrawNotify(infoPtr, CDDS_POSTPAINT, hdc, rect);
2784 }
2785
2786 static void
2787 TREEVIEW_Invalidate(TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *item)
2788 {
2789     if (item != NULL)
2790         InvalidateRect(infoPtr->hwnd, &item->rect, TRUE);
2791     else
2792         InvalidateRect(infoPtr->hwnd, NULL, TRUE);
2793 }
2794
2795 static LRESULT
2796 TREEVIEW_Paint(TREEVIEW_INFO *infoPtr, WPARAM wParam)
2797 {
2798     HDC hdc;
2799     PAINTSTRUCT ps;
2800     RECT rc;
2801
2802     TRACE("\n");
2803
2804     if (wParam)
2805     {
2806         hdc = (HDC)wParam;
2807         if (!GetUpdateRect(infoPtr->hwnd, &rc, TRUE))
2808         {
2809             HBITMAP hbitmap;
2810             BITMAP bitmap;
2811             hbitmap = GetCurrentObject(hdc, OBJ_BITMAP);
2812             if (!hbitmap) return 0;
2813             GetObjectA(hbitmap, sizeof(BITMAP), &bitmap);
2814             rc.left = 0; rc.top = 0;
2815             rc.right = bitmap.bmWidth;
2816             rc.bottom = bitmap.bmHeight;
2817             TREEVIEW_EraseBackground(infoPtr, wParam);
2818         }
2819     }
2820     else
2821     {
2822         hdc = BeginPaint(infoPtr->hwnd, &ps);
2823         rc = ps.rcPaint;
2824     }
2825
2826     if(infoPtr->bRedraw) /* WM_SETREDRAW sets bRedraw */
2827         TREEVIEW_Refresh(infoPtr, hdc, &rc);
2828
2829     if (!wParam)
2830         EndPaint(infoPtr->hwnd, &ps);
2831
2832     return 0;
2833 }
2834
2835
2836 /* Sorting **************************************************************/
2837
2838 /***************************************************************************
2839  * Forward the DPA local callback to the treeview owner callback
2840  */
2841 static INT WINAPI
2842 TREEVIEW_CallBackCompare(TREEVIEW_ITEM *first, TREEVIEW_ITEM *second, LPTVSORTCB pCallBackSort)
2843 {
2844     /* Forward the call to the client-defined callback */
2845     return pCallBackSort->lpfnCompare(first->lParam,
2846                                       second->lParam,
2847                                       pCallBackSort->lParam);
2848 }
2849
2850 /***************************************************************************
2851  * Treeview native sort routine: sort on item text.
2852  */
2853 static INT WINAPI
2854 TREEVIEW_SortOnName(TREEVIEW_ITEM *first, TREEVIEW_ITEM *second,
2855                      TREEVIEW_INFO *infoPtr)
2856 {
2857     TREEVIEW_UpdateDispInfo(infoPtr, first, TVIF_TEXT);
2858     TREEVIEW_UpdateDispInfo(infoPtr, second, TVIF_TEXT);
2859
2860     return strcasecmp(first->pszText, second->pszText);
2861 }
2862
2863 /* Returns the number of physical children belonging to item. */
2864 static INT
2865 TREEVIEW_CountChildren(TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *item)
2866 {
2867     INT cChildren = 0;
2868     HTREEITEM hti;
2869
2870     for (hti = item->firstChild; hti != NULL; hti = hti->nextSibling)
2871         cChildren++;
2872
2873     return cChildren;
2874 }
2875
2876 /* Returns a DPA containing a pointer to each physical child of item in
2877  * sibling order. If item has no children, an empty DPA is returned. */
2878 static HDPA
2879 TREEVIEW_BuildChildDPA(TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *item)
2880 {
2881     HTREEITEM child = item->firstChild;
2882
2883     HDPA list = DPA_Create(8);
2884     if (list == 0) return NULL;
2885
2886     for (child = item->firstChild; child != NULL; child = child->nextSibling)
2887     {
2888         if (DPA_InsertPtr(list, INT_MAX, child) == -1)
2889         {
2890             DPA_Destroy(list);
2891             return NULL;
2892         }
2893     }
2894
2895     return list;
2896 }
2897
2898 /***************************************************************************
2899  * Setup the treeview structure with regards of the sort method
2900  * and sort the children of the TV item specified in lParam
2901  * fRecurse: currently unused. Should be zero.
2902  * parent: if pSort!=NULL, should equal pSort->hParent.
2903  *         otherwise, item which child items are to be sorted.
2904  * pSort:  sort method info. if NULL, sort on item text.
2905  *         if non-NULL, sort on item's lParam content, and let the
2906  *         application decide what that means. See also TVM_SORTCHILDRENCB.
2907  */
2908
2909 static LRESULT
2910 TREEVIEW_Sort(TREEVIEW_INFO *infoPtr, BOOL fRecurse, HTREEITEM parent,
2911               LPTVSORTCB pSort)
2912 {
2913     INT cChildren;
2914     PFNDPACOMPARE pfnCompare;
2915     LPARAM lpCompare;
2916
2917     /* undocumented feature: TVI_ROOT means `sort the whole tree' */
2918     if (parent == TVI_ROOT)
2919         parent = infoPtr->root;
2920
2921     /* Check for a valid handle to the parent item */
2922     if (!TREEVIEW_ValidItem(infoPtr, parent))
2923     {
2924         ERR("invalid item hParent=%x\n", (INT)parent);
2925         return FALSE;
2926     }
2927
2928     if (pSort)
2929     {
2930         pfnCompare = (PFNDPACOMPARE)TREEVIEW_CallBackCompare;
2931         lpCompare = (LPARAM)pSort;
2932     }
2933     else
2934     {
2935         pfnCompare = (PFNDPACOMPARE)TREEVIEW_SortOnName;
2936         lpCompare = (LPARAM)infoPtr;
2937     }
2938
2939     cChildren = TREEVIEW_CountChildren(infoPtr, parent);
2940
2941     /* Make sure there is something to sort */
2942     if (cChildren > 1)
2943     {
2944         /* TREEVIEW_ITEM rechaining */
2945         INT count = 0;
2946         HTREEITEM item = 0;
2947         HTREEITEM nextItem = 0;
2948         HTREEITEM prevItem = 0;
2949
2950         HDPA sortList = TREEVIEW_BuildChildDPA(infoPtr, parent);
2951
2952         if (sortList == NULL)
2953             return FALSE;
2954
2955         /* let DPA sort the list */
2956         DPA_Sort(sortList, pfnCompare, lpCompare);
2957
2958         /* The order of DPA entries has been changed, so fixup the
2959          * nextSibling and prevSibling pointers. */
2960
2961         item = (HTREEITEM)DPA_GetPtr(sortList, count++);
2962         while ((nextItem = (HTREEITEM)DPA_GetPtr(sortList, count++)) != NULL)
2963         {
2964             /* link the two current item toghether */
2965             item->nextSibling = nextItem;
2966             nextItem->prevSibling = item;
2967
2968             if (prevItem == NULL)
2969             {
2970                 /* this is the first item, update the parent */
2971                 parent->firstChild = item;
2972                 item->prevSibling = NULL;
2973             }
2974             else
2975             {
2976                 /* fix the back chaining */
2977                 item->prevSibling = prevItem;
2978             }
2979
2980             /* get ready for the next one */
2981             prevItem = item;
2982             item = nextItem;
2983         }
2984
2985         /* the last item is pointed to by item and never has a sibling */
2986         item->nextSibling = NULL;
2987         parent->lastChild = item;
2988
2989         DPA_Destroy(sortList);
2990
2991         TREEVIEW_VerifyTree(infoPtr);
2992
2993         if (parent->state & TVIS_EXPANDED)
2994         {
2995             int visOrder = infoPtr->firstVisible->visibleOrder;
2996
2997         if (parent == infoPtr->root)
2998             TREEVIEW_RecalculateVisibleOrder(infoPtr, NULL);
2999         else
3000             TREEVIEW_RecalculateVisibleOrder(infoPtr, parent);
3001
3002             if (TREEVIEW_IsChildOf(parent, infoPtr->firstVisible))
3003             {
3004                 TREEVIEW_ITEM *item;
3005
3006                 for (item = infoPtr->root->firstChild; item != NULL;
3007                      item = TREEVIEW_GetNextListItem(infoPtr, item))
3008                 {
3009                     if (item->visibleOrder == visOrder)
3010                         break;
3011                 }
3012
3013                 TREEVIEW_SetFirstVisible(infoPtr, item, FALSE);
3014             }
3015
3016             TREEVIEW_Invalidate(infoPtr, NULL);
3017         }
3018
3019         return TRUE;
3020     }
3021     return FALSE;
3022 }
3023
3024
3025 /***************************************************************************
3026  * Setup the treeview structure with regards of the sort method
3027  * and sort the children of the TV item specified in lParam
3028  */
3029 static LRESULT
3030 TREEVIEW_SortChildrenCB(TREEVIEW_INFO *infoPtr, WPARAM wParam, LPTVSORTCB pSort)
3031 {
3032     return TREEVIEW_Sort(infoPtr, wParam, pSort->hParent, pSort);
3033 }
3034
3035
3036 /***************************************************************************
3037  * Sort the children of the TV item specified in lParam.
3038  */
3039 static LRESULT
3040 TREEVIEW_SortChildren(TREEVIEW_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
3041 {
3042     return TREEVIEW_Sort(infoPtr, (BOOL)wParam, (HTREEITEM)lParam, NULL);
3043 }
3044
3045
3046 /* Expansion/Collapse ***************************************************/
3047
3048 static BOOL
3049 TREEVIEW_SendExpanding(TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *wineItem,
3050                        UINT action)
3051 {
3052     return !TREEVIEW_SendTreeviewNotify(infoPtr,
3053                                 (infoPtr->bNtfUnicode) ? TVN_ITEMEXPANDINGW :
3054                                                          TVN_ITEMEXPANDINGA,
3055                                 action,
3056                                         TVIF_HANDLE | TVIF_STATE | TVIF_PARAM
3057                                         | TVIF_IMAGE | TVIF_SELECTEDIMAGE,
3058                                         0, wineItem);
3059 }
3060
3061 static VOID
3062 TREEVIEW_SendExpanded(TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *wineItem,
3063                       UINT action)
3064 {
3065     TREEVIEW_SendTreeviewNotify(infoPtr,
3066                                 (infoPtr->bNtfUnicode) ? TVN_ITEMEXPANDEDW :
3067                                                          TVN_ITEMEXPANDEDA,
3068                                 action,
3069                                 TVIF_HANDLE | TVIF_STATE | TVIF_PARAM
3070                                 | TVIF_IMAGE | TVIF_SELECTEDIMAGE,
3071                                 0, wineItem);
3072 }
3073
3074
3075 /* This corresponds to TVM_EXPAND with TVE_COLLAPSE.
3076  * bRemoveChildren corresponds to TVE_COLLAPSERESET. */
3077 static BOOL
3078 TREEVIEW_Collapse(TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *wineItem,
3079                   BOOL bRemoveChildren, BOOL bUser)
3080 {
3081     UINT action = TVE_COLLAPSE | (bRemoveChildren ? TVE_COLLAPSERESET : 0);
3082     BOOL bSetSelection, bSetFirstVisible;
3083
3084     TRACE("TVE_COLLAPSE %p %s\n", wineItem, TREEVIEW_ItemName(wineItem));
3085
3086     if (!(wineItem->state & TVIS_EXPANDED) || wineItem->firstChild == NULL)
3087         return FALSE;
3088
3089     if (bUser)
3090         TREEVIEW_SendExpanding(infoPtr, wineItem, action);
3091
3092     wineItem->state &= ~TVIS_EXPANDED;
3093
3094     if (bUser)
3095         TREEVIEW_SendExpanded(infoPtr, wineItem, action);
3096
3097     bSetSelection = (infoPtr->selectedItem != NULL
3098                      && TREEVIEW_IsChildOf(wineItem, infoPtr->selectedItem));
3099
3100     bSetFirstVisible = (infoPtr->firstVisible != NULL
3101                         && TREEVIEW_IsChildOf(wineItem, infoPtr->firstVisible));
3102
3103     if (bRemoveChildren)
3104     {
3105         TRACE("TVE_COLLAPSERESET\n");
3106         wineItem->state &= ~TVIS_EXPANDEDONCE;
3107         TREEVIEW_RemoveAllChildren(infoPtr, wineItem);
3108     }
3109
3110     if (wineItem->firstChild)
3111     {
3112         TREEVIEW_ITEM *item, *sibling;
3113
3114         sibling = TREEVIEW_GetNextListItem(infoPtr, wineItem);
3115
3116         for (item = wineItem->firstChild; item != sibling;
3117              item = TREEVIEW_GetNextListItem(infoPtr, item))
3118         {
3119             item->visibleOrder = -1;
3120         }
3121     }
3122
3123     TREEVIEW_RecalculateVisibleOrder(infoPtr, wineItem);
3124
3125     TREEVIEW_SetFirstVisible(infoPtr, bSetFirstVisible ? wineItem
3126                              : infoPtr->firstVisible, TRUE);
3127
3128     if (bSetSelection)
3129     {
3130         /* Don't call DoSelectItem, it sends notifications. */
3131         if (TREEVIEW_ValidItem(infoPtr, infoPtr->selectedItem))
3132             infoPtr->selectedItem->state &= ~TVIS_SELECTED;
3133         wineItem->state |= TVIS_SELECTED;
3134         infoPtr->selectedItem = wineItem;
3135
3136         TREEVIEW_EnsureVisible(infoPtr, wineItem, FALSE);
3137     }
3138
3139     TREEVIEW_UpdateScrollBars(infoPtr);
3140     TREEVIEW_Invalidate(infoPtr, NULL);
3141
3142     return TRUE;
3143 }
3144
3145 static BOOL
3146 TREEVIEW_Expand(TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *wineItem,
3147                 BOOL bExpandPartial, BOOL bUser)
3148 {
3149     TRACE("\n");
3150
3151     if (!TREEVIEW_HasChildren(infoPtr, wineItem)
3152         || wineItem->state & TVIS_EXPANDED)
3153         return FALSE;
3154
3155     TRACE("TVE_EXPAND %p %s\n", wineItem, TREEVIEW_ItemName(wineItem));
3156
3157     if (bUser || !(wineItem->state & TVIS_EXPANDEDONCE))
3158     {
3159         if (!TREEVIEW_SendExpanding(infoPtr, wineItem, TVE_EXPAND))
3160         {
3161             TRACE("  TVN_ITEMEXPANDING returned TRUE, exiting...\n");
3162             return FALSE;
3163         }
3164
3165         wineItem->state |= TVIS_EXPANDED;
3166         TREEVIEW_SendExpanded(infoPtr, wineItem, TVE_EXPAND);
3167         wineItem->state |= TVIS_EXPANDEDONCE;
3168     }
3169     else
3170     {
3171         /* this item has already been expanded */
3172         wineItem->state |= TVIS_EXPANDED;
3173     }
3174
3175     if (bExpandPartial)
3176         FIXME("TVE_EXPANDPARTIAL not implemented\n");
3177
3178     TREEVIEW_RecalculateVisibleOrder(infoPtr, wineItem);
3179     TREEVIEW_UpdateSubTree(infoPtr, wineItem);
3180     TREEVIEW_UpdateScrollBars(infoPtr);
3181
3182     /* Scroll up so that as many children as possible are visible.
3183      * This looses when expanding causes an HScroll bar to appear, but we
3184      * don't know that yet, so the last item is obscured. */
3185     if (wineItem->firstChild != NULL)
3186     {
3187         int nChildren = wineItem->lastChild->visibleOrder
3188             - wineItem->firstChild->visibleOrder + 1;
3189
3190         int visible_pos = wineItem->visibleOrder
3191             - infoPtr->firstVisible->visibleOrder;
3192
3193         int rows_below = TREEVIEW_GetVisibleCount(infoPtr) - visible_pos - 1;
3194
3195         if (visible_pos > 0 && nChildren > rows_below)
3196         {
3197             int scroll = nChildren - rows_below;
3198
3199             if (scroll > visible_pos)
3200                 scroll = visible_pos;
3201
3202             if (scroll > 0)
3203             {
3204                 TREEVIEW_ITEM *newFirstVisible
3205                     = TREEVIEW_GetListItem(infoPtr, infoPtr->firstVisible,
3206                                            scroll);
3207
3208
3209                 TREEVIEW_SetFirstVisible(infoPtr, newFirstVisible, TRUE);
3210             }
3211         }
3212     }
3213
3214     TREEVIEW_Invalidate(infoPtr, NULL);
3215
3216     return TRUE;
3217 }
3218
3219 static BOOL
3220 TREEVIEW_Toggle(TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *wineItem, BOOL bUser)
3221 {
3222     TRACE("\n");
3223
3224     if (wineItem->state & TVIS_EXPANDED)
3225         return TREEVIEW_Collapse(infoPtr, wineItem, FALSE, bUser);
3226     else
3227         return TREEVIEW_Expand(infoPtr, wineItem, FALSE, bUser);
3228 }
3229
3230 static VOID
3231 TREEVIEW_ExpandAll(TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *item)
3232 {
3233     TREEVIEW_Expand(infoPtr, item, FALSE, TRUE);
3234
3235     for (item = item->firstChild; item != NULL; item = item->nextSibling)
3236     {
3237         if (TREEVIEW_HasChildren(infoPtr, item))
3238             TREEVIEW_ExpandAll(infoPtr, item);
3239     }
3240 }
3241
3242 /* Note:If the specified item is the child of a collapsed parent item,
3243    the parent's list of child items is (recursively) expanded to reveal the
3244    specified item. This is mentioned for TREEVIEW_SelectItem; don't
3245    know if it also applies here.
3246 */
3247
3248 static LRESULT
3249 TREEVIEW_ExpandMsg(TREEVIEW_INFO *infoPtr, UINT flag, HTREEITEM wineItem)
3250 {
3251     if (!TREEVIEW_ValidItem(infoPtr, wineItem))
3252         return 0;
3253
3254     TRACE("For (%s) item:%d, flags %x, state:%d\n",
3255               TREEVIEW_ItemName(wineItem), flag,
3256               TREEVIEW_GetItemIndex(infoPtr, wineItem), wineItem->state);
3257
3258     switch (flag & TVE_TOGGLE)
3259     {
3260     case TVE_COLLAPSE:
3261         return TREEVIEW_Collapse(infoPtr, wineItem, flag & TVE_COLLAPSERESET,
3262                                  FALSE);
3263
3264     case TVE_EXPAND:
3265         return TREEVIEW_Expand(infoPtr, wineItem, flag & TVE_EXPANDPARTIAL,
3266                                FALSE);
3267
3268     case TVE_TOGGLE:
3269         return TREEVIEW_Toggle(infoPtr, wineItem, TRUE);
3270
3271     default:
3272         return 0;
3273     }
3274
3275 #if 0
3276     TRACE("Exiting, Item %p state is now %d...\n", wineItem, wineItem->state);
3277 #endif
3278 }
3279
3280 /* Hit-Testing **********************************************************/
3281
3282 static TREEVIEW_ITEM *
3283 TREEVIEW_HitTestPoint(TREEVIEW_INFO *infoPtr, POINT pt)
3284 {
3285     TREEVIEW_ITEM *wineItem;
3286     LONG row;
3287
3288     if (!infoPtr->firstVisible)
3289         return NULL;
3290
3291     row = pt.y / infoPtr->uItemHeight + infoPtr->firstVisible->visibleOrder;
3292
3293     for (wineItem = infoPtr->firstVisible; wineItem != NULL;
3294          wineItem = TREEVIEW_GetNextListItem(infoPtr, wineItem))
3295     {
3296         if (row >= wineItem->visibleOrder
3297             && row < wineItem->visibleOrder + wineItem->iIntegral)
3298             break;
3299     }
3300
3301     return wineItem;
3302 }
3303
3304 static LRESULT
3305 TREEVIEW_HitTest(TREEVIEW_INFO *infoPtr, LPTVHITTESTINFO lpht)
3306 {
3307     TREEVIEW_ITEM *wineItem;
3308     RECT rect;
3309     UINT status;
3310     LONG x, y;
3311
3312     lpht->hItem = 0;
3313     GetClientRect(infoPtr->hwnd, &rect);
3314     status = 0;
3315     x = lpht->pt.x;
3316     y = lpht->pt.y;
3317
3318     if (x < rect.left)
3319     {
3320         status |= TVHT_TOLEFT;
3321     }
3322     else if (x > rect.right)
3323     {
3324         status |= TVHT_TORIGHT;
3325     }
3326
3327     if (y < rect.top)
3328     {
3329         status |= TVHT_ABOVE;
3330     }
3331     else if (y > rect.bottom)
3332     {
3333         status |= TVHT_BELOW;
3334     }
3335
3336     if (status)
3337     {
3338         lpht->flags = status;
3339         return (LRESULT)(HTREEITEM)NULL;
3340     }
3341
3342     wineItem = TREEVIEW_HitTestPoint(infoPtr, lpht->pt);
3343     if (!wineItem)
3344     {
3345         lpht->flags = TVHT_NOWHERE;
3346         return (LRESULT)(HTREEITEM)NULL;
3347     }
3348
3349     if (x >= wineItem->textOffset + wineItem->textWidth)
3350     {
3351         lpht->flags = TVHT_ONITEMRIGHT;
3352     }
3353     else if (x >= wineItem->textOffset)
3354     {
3355         lpht->flags = TVHT_ONITEMLABEL;
3356     }
3357     else if (x >= wineItem->imageOffset)
3358     {
3359         lpht->flags = TVHT_ONITEMICON;
3360     }
3361     else if (x >= wineItem->stateOffset)
3362     {
3363         lpht->flags = TVHT_ONITEMSTATEICON;
3364     }
3365     else if (x >= wineItem->linesOffset && infoPtr->dwStyle & TVS_HASBUTTONS)
3366     {
3367         lpht->flags = TVHT_ONITEMBUTTON;
3368     }
3369     else
3370     {
3371         lpht->flags = TVHT_ONITEMINDENT;
3372     }
3373
3374     lpht->hItem = wineItem;
3375     TRACE("(%ld,%ld):result %x\n", lpht->pt.x, lpht->pt.y, lpht->flags);
3376
3377     return (LRESULT)wineItem;
3378 }
3379
3380 /* Item Label Editing ***************************************************/
3381
3382 static LRESULT
3383 TREEVIEW_GetEditControl(TREEVIEW_INFO *infoPtr)
3384 {
3385     return infoPtr->hwndEdit;
3386 }
3387
3388 static LRESULT CALLBACK
3389 TREEVIEW_Edit_SubclassProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
3390 {
3391     TREEVIEW_INFO *infoPtr;
3392     BOOL bCancel = FALSE;
3393
3394     switch (uMsg)
3395     {
3396     case WM_PAINT:
3397         {
3398             LRESULT rc;
3399             TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(GetParent(hwnd));
3400
3401             TRACE("WM_PAINT start\n");
3402             rc = CallWindowProcA(infoPtr->wpEditOrig, hwnd, uMsg, wParam,
3403                                  lParam);
3404             TRACE("WM_PAINT done\n");
3405             return rc;
3406         }
3407
3408     case WM_KILLFOCUS:
3409     {
3410         TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(GetParent(hwnd));
3411         if (infoPtr->bIgnoreEditKillFocus)
3412             return TRUE;
3413
3414         break;
3415     }
3416
3417     case WM_GETDLGCODE:
3418         return DLGC_WANTARROWS | DLGC_WANTALLKEYS;
3419
3420     case WM_KEYDOWN:
3421         if (wParam == (WPARAM)VK_ESCAPE)
3422         {
3423             bCancel = TRUE;
3424             break;
3425         }
3426         else if (wParam == (WPARAM)VK_RETURN)
3427         {
3428             break;
3429         }
3430
3431         /* fall through */
3432     default:
3433         {
3434             TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(GetParent(hwnd));
3435
3436             return CallWindowProcA(infoPtr->wpEditOrig, hwnd, uMsg, wParam,
3437                                    lParam);
3438         }
3439     }
3440
3441     /* Processing TVN_ENDLABELEDIT message could kill the focus       */
3442     /* eg. Using a messagebox                                         */
3443
3444     infoPtr = TREEVIEW_GetInfoPtr(GetParent(hwnd));
3445     infoPtr->bIgnoreEditKillFocus = TRUE;
3446     TREEVIEW_EndEditLabelNow(infoPtr, bCancel || !infoPtr->bLabelChanged);
3447     infoPtr->bIgnoreEditKillFocus = FALSE;
3448
3449     return 0;
3450 }
3451
3452
3453 /* should handle edit control messages here */
3454
3455 static LRESULT
3456 TREEVIEW_Command(TREEVIEW_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
3457 {
3458     TRACE("%x %ld\n", wParam, lParam);
3459
3460     switch (HIWORD(wParam))
3461     {
3462     case EN_UPDATE:
3463         {
3464             /*
3465              * Adjust the edit window size
3466              */
3467             char buffer[1024];
3468             TREEVIEW_ITEM *editItem = infoPtr->selectedItem;
3469             HDC hdc = GetDC(infoPtr->hwndEdit);
3470             SIZE sz;
3471             int len;
3472             HFONT hFont, hOldFont = 0;
3473
3474             infoPtr->bLabelChanged = TRUE;
3475
3476             len = GetWindowTextA(infoPtr->hwndEdit, buffer, sizeof(buffer));
3477
3478             /* Select font to get the right dimension of the string */
3479             hFont = SendMessageA(infoPtr->hwndEdit, WM_GETFONT, 0, 0);
3480             if (hFont != 0)
3481             {
3482                 hOldFont = SelectObject(hdc, hFont);
3483             }
3484
3485             if (GetTextExtentPoint32A(hdc, buffer, strlen(buffer), &sz))
3486             {
3487                 TEXTMETRICA textMetric;
3488
3489                 /* Add Extra spacing for the next character */
3490                 GetTextMetricsA(hdc, &textMetric);
3491                 sz.cx += (textMetric.tmMaxCharWidth * 2);
3492
3493                 sz.cx = max(sz.cx, textMetric.tmMaxCharWidth * 3);
3494                 sz.cx = min(sz.cx,
3495                             infoPtr->clientWidth - editItem->textOffset + 2);
3496
3497                 SetWindowPos(infoPtr->hwndEdit,
3498                              HWND_TOP,
3499                              0,
3500                              0,
3501                              sz.cx,
3502                              editItem->rect.bottom - editItem->rect.top + 3,
3503                              SWP_NOMOVE | SWP_DRAWFRAME);
3504             }
3505
3506             if (hFont != 0)
3507             {
3508                 SelectObject(hdc, hOldFont);
3509             }
3510
3511             ReleaseDC(infoPtr->hwnd, hdc);
3512             break;
3513         }
3514
3515     default:
3516         return SendMessageA(GetParent(infoPtr->hwnd), WM_COMMAND, wParam, lParam);
3517     }
3518
3519     return 0;
3520 }
3521
3522 static HWND
3523 TREEVIEW_EditLabelA(TREEVIEW_INFO *infoPtr, HTREEITEM hItem)
3524 {
3525     HWND hwnd = infoPtr->hwnd;
3526     HWND hwndEdit;
3527     SIZE sz;
3528     TREEVIEW_ITEM *editItem = hItem;
3529     HINSTANCE hinst = GetWindowLongA(hwnd, GWL_HINSTANCE);
3530     HDC hdc;
3531     HFONT hOldFont=0;
3532     TEXTMETRICA textMetric;
3533
3534     TRACE("%x %p\n", (unsigned)hwnd, hItem);
3535     if (!TREEVIEW_ValidItem(infoPtr, editItem))
3536         return (HWND)NULL;
3537
3538     if (infoPtr->hwndEdit)
3539         return infoPtr->hwndEdit;
3540
3541     infoPtr->bLabelChanged = FALSE;
3542
3543     /* Make sure that edit item is selected */
3544     TREEVIEW_DoSelectItem(infoPtr, TVGN_CARET, hItem, TVC_UNKNOWN);
3545     TREEVIEW_EnsureVisible(infoPtr, hItem, TRUE);
3546
3547     TREEVIEW_UpdateDispInfo(infoPtr, editItem, TVIF_TEXT);
3548
3549     hdc = GetDC(hwnd);
3550     /* Select the font to get appropriate metric dimensions */
3551     if (infoPtr->hFont != 0)
3552     {
3553         hOldFont = SelectObject(hdc, infoPtr->hFont);
3554     }
3555
3556     /* Get string length in pixels */
3557     GetTextExtentPoint32A(hdc, editItem->pszText, strlen(editItem->pszText),
3558                           &sz);
3559
3560     /* Add Extra spacing for the next character */
3561     GetTextMetricsA(hdc, &textMetric);
3562     sz.cx += (textMetric.tmMaxCharWidth * 2);
3563
3564     sz.cx = max(sz.cx, textMetric.tmMaxCharWidth * 3);
3565     sz.cx = min(sz.cx, infoPtr->clientWidth - editItem->textOffset + 2);
3566
3567     if (infoPtr->hFont != 0)
3568     {
3569         SelectObject(hdc, hOldFont);
3570     }
3571
3572     ReleaseDC(hwnd, hdc);
3573     hwndEdit = CreateWindowExA(WS_EX_LEFT,
3574                                "EDIT",
3575                                0,
3576                                WS_CHILD | WS_BORDER | ES_AUTOHSCROLL |
3577                                WS_CLIPSIBLINGS | ES_WANTRETURN |
3578                                ES_LEFT, editItem->textOffset - 2,
3579                                editItem->rect.top - 1, sz.cx + 3,
3580                                editItem->rect.bottom -
3581                                editItem->rect.top + 3, hwnd, 0, hinst, 0);
3582 /* FIXME: (HMENU)IDTVEDIT,pcs->hInstance,0); */
3583
3584     infoPtr->hwndEdit = hwndEdit;
3585
3586     /* Get a 2D border. */
3587     SetWindowLongA(hwndEdit, GWL_EXSTYLE,
3588                    GetWindowLongA(hwndEdit, GWL_EXSTYLE) & ~WS_EX_CLIENTEDGE);
3589     SetWindowLongA(hwndEdit, GWL_STYLE,
3590                    GetWindowLongA(hwndEdit, GWL_STYLE) | WS_BORDER);
3591
3592     SendMessageA(hwndEdit, WM_SETFONT, TREEVIEW_FontForItem(infoPtr, editItem),
3593                  FALSE);
3594
3595     infoPtr->wpEditOrig = (WNDPROC)SetWindowLongA(hwndEdit, GWL_WNDPROC,
3596                                                   (DWORD)
3597                                                   TREEVIEW_Edit_SubclassProc);
3598
3599     if (TREEVIEW_BeginLabelEditNotify(infoPtr, editItem))
3600     {
3601         DestroyWindow(hwndEdit);
3602         infoPtr->hwndEdit = 0;
3603         return (HWND)NULL;
3604     }
3605
3606     infoPtr->selectedItem = hItem;
3607     SetWindowTextA(hwndEdit, editItem->pszText);
3608     SetFocus(hwndEdit);
3609     SendMessageA(hwndEdit, EM_SETSEL, 0, -1);
3610     ShowWindow(hwndEdit, SW_SHOW);
3611
3612     return hwndEdit;
3613 }
3614
3615
3616 static LRESULT
3617 TREEVIEW_EndEditLabelNow(TREEVIEW_INFO *infoPtr, BOOL bCancel)
3618 {
3619     HWND hwnd = infoPtr->hwnd;
3620     TREEVIEW_ITEM *editedItem = infoPtr->selectedItem;
3621     NMTVDISPINFOA tvdi;
3622     BOOL bCommit;
3623     char tmpText[1024] = { '\0' };
3624     int iLength = 0;
3625
3626     if (!infoPtr->hwndEdit)
3627         return FALSE;
3628
3629     tvdi.hdr.hwndFrom = hwnd;
3630     tvdi.hdr.idFrom = GetWindowLongA(hwnd, GWL_ID);
3631     tvdi.hdr.code = TVN_ENDLABELEDITA;
3632     tvdi.item.mask = 0;
3633     tvdi.item.hItem = editedItem;
3634     tvdi.item.state = editedItem->state;
3635     tvdi.item.lParam = editedItem->lParam;
3636
3637     if (!bCancel)
3638     {
3639         iLength = GetWindowTextA(infoPtr->hwndEdit, tmpText, 1023);
3640
3641         if (iLength >= 1023)
3642         {
3643             ERR("Insuficient space to retrieve new item label\n");
3644         }
3645
3646         tvdi.item.pszText = tmpText;
3647         tvdi.item.cchTextMax = iLength + 1;
3648     }
3649     else
3650     {
3651         tvdi.item.pszText = NULL;
3652         tvdi.item.cchTextMax = 0;
3653     }
3654
3655     bCommit = (BOOL)TREEVIEW_SendRealNotify(infoPtr,
3656                                  (WPARAM)tvdi.hdr.idFrom, (LPARAM)&tvdi);
3657
3658     if (!bCancel && bCommit)    /* Apply the changes */
3659     {
3660         if (strcmp(tmpText, editedItem->pszText) != 0)
3661         {
3662             if (NULL == COMCTL32_ReAlloc(editedItem->pszText, iLength + 1))
3663             {
3664                 ERR("OutOfMemory, cannot allocate space for label\n");
3665                 DestroyWindow(infoPtr->hwndEdit);
3666                 infoPtr->hwndEdit = 0;
3667                 return FALSE;
3668             }
3669             else
3670             {
3671                 editedItem->cchTextMax = iLength + 1;
3672                 lstrcpyA(editedItem->pszText, tmpText);
3673             }
3674         }
3675     }
3676
3677     ShowWindow(infoPtr->hwndEdit, SW_HIDE);
3678     DestroyWindow(infoPtr->hwndEdit);
3679     infoPtr->hwndEdit = 0;
3680     return TRUE;
3681 }
3682
3683 static LRESULT
3684 TREEVIEW_HandleTimer(TREEVIEW_INFO *infoPtr, WPARAM wParam)
3685 {
3686     if (wParam != TV_EDIT_TIMER)
3687     {
3688         ERR("got unknown timer\n");
3689         return 1;
3690     }
3691
3692     KillTimer(infoPtr->hwnd, TV_EDIT_TIMER);
3693     infoPtr->Timer &= ~TV_EDIT_TIMER_SET;
3694
3695     TREEVIEW_EditLabelA(infoPtr, infoPtr->selectedItem);
3696
3697     return 0;
3698 }
3699
3700
3701 /* Mouse Tracking/Drag **************************************************/
3702
3703 /***************************************************************************
3704  * This is quite unusual piece of code, but that's how it's implemented in
3705  * Windows.
3706  */
3707 static LRESULT
3708 TREEVIEW_TrackMouse(TREEVIEW_INFO *infoPtr, POINT pt)
3709 {
3710     INT cxDrag = GetSystemMetrics(SM_CXDRAG);
3711     INT cyDrag = GetSystemMetrics(SM_CYDRAG);
3712     RECT r;
3713     MSG msg;
3714
3715     r.top = pt.y - cyDrag;
3716     r.left = pt.x - cxDrag;
3717     r.bottom = pt.y + cyDrag;
3718     r.right = pt.x + cxDrag;
3719
3720     SetCapture(infoPtr->hwnd);
3721
3722     while (1)
3723     {
3724         if (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE | PM_NOYIELD))
3725         {
3726             if (msg.message == WM_MOUSEMOVE)
3727             {
3728                 pt.x = SLOWORD(msg.lParam);
3729                 pt.y = SHIWORD(msg.lParam);
3730                 if (PtInRect(&r, pt))
3731                     continue;
3732                 else
3733                 {
3734                     ReleaseCapture();
3735                     return 1;
3736                 }
3737             }
3738             else if (msg.message >= WM_LBUTTONDOWN &&
3739                      msg.message <= WM_RBUTTONDBLCLK)
3740             {
3741                 if (msg.message == WM_RBUTTONUP)
3742                     TREEVIEW_RButtonUp(infoPtr, &pt);
3743                 break;
3744             }
3745
3746             DispatchMessageA(&msg);
3747         }
3748
3749         if (GetCapture() != infoPtr->hwnd)
3750             return 0;
3751     }
3752
3753     ReleaseCapture();
3754     return 0;
3755 }
3756
3757
3758 static LRESULT
3759 TREEVIEW_LButtonDoubleClick(TREEVIEW_INFO *infoPtr, LPARAM lParam)
3760 {
3761     TREEVIEW_ITEM *wineItem;
3762     TVHITTESTINFO hit;
3763
3764     TRACE("\n");
3765     SetFocus(infoPtr->hwnd);
3766
3767     if (infoPtr->Timer & TV_EDIT_TIMER_SET)
3768     {
3769         /* If there is pending 'edit label' event - kill it now */
3770         KillTimer(infoPtr->hwnd, TV_EDIT_TIMER);
3771     }
3772
3773     hit.pt.x = SLOWORD(lParam);
3774     hit.pt.y = SHIWORD(lParam);
3775
3776     wineItem = (TREEVIEW_ITEM *)TREEVIEW_HitTest(infoPtr, &hit);
3777     if (!wineItem)
3778         return 0;
3779     TRACE("item %d\n", TREEVIEW_GetItemIndex(infoPtr, wineItem));
3780
3781     if (TREEVIEW_SendSimpleNotify(infoPtr, NM_DBLCLK) == FALSE)
3782     {                           /* FIXME! */
3783         switch (hit.flags)
3784         {
3785         case TVHT_ONITEMRIGHT:
3786             /* FIXME: we should not have sent NM_DBLCLK in this case. */
3787             break;
3788
3789         case TVHT_ONITEMINDENT:
3790             if (!(infoPtr->dwStyle & TVS_HASLINES))
3791             {
3792                 break;
3793             }
3794             else
3795             {
3796                 int level = hit.pt.x / infoPtr->uIndent;
3797                 if (!(infoPtr->dwStyle & TVS_LINESATROOT)) level++;
3798
3799                 while (wineItem->iLevel > level)
3800                 {
3801                     wineItem = wineItem->parent;
3802                 }
3803
3804                 /* fall through */
3805             }
3806
3807         case TVHT_ONITEMLABEL:
3808         case TVHT_ONITEMICON:
3809         case TVHT_ONITEMBUTTON:
3810             TREEVIEW_Toggle(infoPtr, wineItem, TRUE);
3811             break;
3812
3813         case TVHT_ONITEMSTATEICON:
3814            if (infoPtr->dwStyle & TVS_CHECKBOXES)
3815                TREEVIEW_ToggleItemState(infoPtr, wineItem);
3816            else
3817                TREEVIEW_Toggle(infoPtr, wineItem, TRUE);
3818            break;
3819         }
3820     }
3821     return TRUE;
3822 }
3823
3824
3825 static LRESULT
3826 TREEVIEW_LButtonDown(TREEVIEW_INFO *infoPtr, LPARAM lParam)
3827 {
3828     HWND hwnd = infoPtr->hwnd;
3829     TVHITTESTINFO ht;
3830     BOOL bTrack;
3831     HTREEITEM tempItem;
3832
3833     /* If Edit control is active - kill it and return.
3834      * The best way to do it is to set focus to itself.
3835      * Edit control subclassed procedure will automatically call
3836      * EndEditLabelNow.
3837      */
3838     if (infoPtr->hwndEdit)
3839     {
3840         SetFocus(hwnd);
3841         return 0;
3842     }
3843
3844     ht.pt.x = SLOWORD(lParam);
3845     ht.pt.y = SHIWORD(lParam);
3846
3847     TREEVIEW_HitTest(infoPtr, &ht);
3848     TRACE("item %d\n", TREEVIEW_GetItemIndex(infoPtr, ht.hItem));
3849
3850     /* update focusedItem and redraw both items */
3851     if(ht.hItem && (ht.flags & TVHT_ONITEM))
3852     {
3853         infoPtr->focusedItem = ht.hItem;
3854         InvalidateRect(hwnd, &(((HTREEITEM)(ht.hItem))->rect), TRUE);
3855
3856         if(infoPtr->selectedItem)
3857             InvalidateRect(hwnd, &(infoPtr->selectedItem->rect), TRUE);
3858     }
3859
3860     bTrack = (ht.flags & TVHT_ONITEM)
3861         && !(infoPtr->dwStyle & TVS_DISABLEDRAGDROP);
3862
3863     /* Send NM_CLICK right away */
3864     if (!bTrack)
3865         if (TREEVIEW_SendSimpleNotify(infoPtr, NM_CLICK))
3866             goto setfocus;
3867
3868     if (ht.flags & TVHT_ONITEMBUTTON)
3869     {
3870         TREEVIEW_Toggle(infoPtr, ht.hItem, TRUE);
3871         goto setfocus;
3872     }
3873     else if (bTrack)
3874     {   /* if TREEVIEW_TrackMouse == 1 dragging occurred and the cursor left the dragged item's rectangle */
3875         if (TREEVIEW_TrackMouse(infoPtr, ht.pt))
3876         {
3877             TREEVIEW_SendTreeviewDnDNotify(infoPtr, TVN_BEGINDRAGA, ht.hItem,
3878                                            ht.pt);
3879             infoPtr->dropItem = ht.hItem;
3880
3881             /* clean up focusedItem as we dragged and won't select this item */
3882             if(infoPtr->focusedItem)
3883             {
3884                 /* refresh the item that was focused */
3885                 tempItem = infoPtr->focusedItem;
3886                 infoPtr->focusedItem = 0;
3887                 InvalidateRect(infoPtr->hwnd, &tempItem->rect, TRUE);
3888
3889                 /* refresh the selected item to return the filled background */
3890                 InvalidateRect(infoPtr->hwnd, &(infoPtr->selectedItem->rect), TRUE);
3891             }
3892
3893             return 0;
3894         }
3895     }
3896
3897     if (TREEVIEW_SendSimpleNotify(infoPtr, NM_CLICK))
3898         goto setfocus;
3899
3900     /*
3901      * If the style allows editing and the node is already selected
3902      * and the click occurred on the item label...
3903      */
3904     if ((infoPtr->dwStyle & TVS_EDITLABELS) &&
3905                 (ht.flags & TVHT_ONITEMLABEL) && (infoPtr->selectedItem == ht.hItem))
3906     {
3907         if (infoPtr->Timer & TV_EDIT_TIMER_SET)
3908             KillTimer(hwnd, TV_EDIT_TIMER);
3909
3910         SetTimer(hwnd, TV_EDIT_TIMER, GetDoubleClickTime(), 0);
3911         infoPtr->Timer |= TV_EDIT_TIMER_SET;
3912     }
3913     else if (ht.flags & TVHT_ONITEM) /* select the item if the hit was inside of the icon or text */
3914     {
3915         /*
3916          * if we are TVS_SINGLEEXPAND then we want this single click to
3917          * do a bunch of things.
3918          */
3919         if((infoPtr->dwStyle & TVS_SINGLEEXPAND) &&
3920           (infoPtr->hwndEdit == 0))
3921         {
3922             TREEVIEW_ITEM *SelItem;
3923
3924             /*
3925              * Send the notification
3926              */
3927             TREEVIEW_SendTreeviewNotify(infoPtr, TVN_SINGLEEXPAND, TVIF_HANDLE | TVIF_PARAM,
3928                                 0, ht.hItem, 0);
3929
3930             /*
3931              * Close the previous selection all the way to the root
3932              * as long as the new selection is not a child
3933              */
3934             if((infoPtr->selectedItem)
3935                 && (infoPtr->selectedItem != ht.hItem))
3936             {
3937                 BOOL closeit = TRUE;
3938                 SelItem = ht.hItem;
3939
3940                 /* determine if the hitItem is a child of the currently selected item */
3941                 while(closeit && SelItem && TREEVIEW_ValidItem(infoPtr, SelItem) && (SelItem != infoPtr->root))
3942                 {
3943                     closeit = (SelItem != infoPtr->selectedItem);
3944                     SelItem = SelItem->parent;
3945                 }
3946
3947                 if(closeit)
3948                 {
3949                     if(TREEVIEW_ValidItem(infoPtr, infoPtr->selectedItem))
3950                         SelItem = infoPtr->selectedItem;
3951
3952                     while(SelItem && (SelItem != ht.hItem) && TREEVIEW_ValidItem(infoPtr, SelItem) && (SelItem != infoPtr->root))
3953                     {
3954                         TREEVIEW_Collapse(infoPtr, SelItem, FALSE, FALSE);
3955                         SelItem = SelItem->parent;
3956                     }
3957                 }
3958             }
3959
3960             /*
3961              * Expand the current item
3962              */
3963             TREEVIEW_Expand(infoPtr, ht.hItem, TVE_TOGGLE, FALSE);
3964         }
3965
3966         /* Select the current item */
3967         TREEVIEW_DoSelectItem(infoPtr, TVGN_CARET, ht.hItem, TVC_BYMOUSE);
3968     }
3969     else if (ht.flags & TVHT_ONITEMSTATEICON)
3970     {
3971         /* TVS_CHECKBOXES requires us to toggle the current state */
3972         if (infoPtr->dwStyle & TVS_CHECKBOXES)
3973             TREEVIEW_ToggleItemState(infoPtr, ht.hItem);
3974     }
3975
3976   setfocus:
3977     SetFocus(hwnd);
3978     return 0;
3979 }
3980
3981
3982 static LRESULT
3983 TREEVIEW_RButtonDown(TREEVIEW_INFO *infoPtr, LPARAM lParam)
3984 {
3985     TVHITTESTINFO ht;
3986
3987     if (infoPtr->hwndEdit)
3988     {
3989         SetFocus(infoPtr->hwnd);
3990         return 0;
3991     }
3992
3993     ht.pt.x = SLOWORD(lParam);
3994     ht.pt.y = SHIWORD(lParam);
3995
3996     TREEVIEW_HitTest(infoPtr, &ht);
3997
3998     if (TREEVIEW_TrackMouse(infoPtr, ht.pt))
3999     {
4000         if (ht.hItem)
4001         {
4002             TREEVIEW_SendTreeviewDnDNotify(infoPtr, TVN_BEGINRDRAGA, ht.hItem,
4003                                            ht.pt);
4004             infoPtr->dropItem = ht.hItem;
4005         }
4006     }
4007     else
4008     {
4009         SetFocus(infoPtr->hwnd);
4010         TREEVIEW_SendSimpleNotify(infoPtr, NM_RCLICK);
4011     }
4012
4013     return 0;
4014 }
4015
4016 static LRESULT
4017 TREEVIEW_RButtonUp(TREEVIEW_INFO *infoPtr, LPPOINT pPt)
4018 {
4019     return 0;
4020 }
4021
4022
4023 static LRESULT
4024 TREEVIEW_CreateDragImage(TREEVIEW_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
4025 {
4026     TREEVIEW_ITEM *dragItem = (HTREEITEM)lParam;
4027     INT cx, cy;
4028     HDC hdc, htopdc;
4029     HWND hwtop;
4030     HBITMAP hbmp, hOldbmp;
4031     SIZE size;
4032     RECT rc;
4033     HFONT hOldFont;
4034
4035     TRACE("\n");
4036
4037     if (!(infoPtr->himlNormal))
4038         return 0;
4039
4040     if (!dragItem || !TREEVIEW_ValidItem(infoPtr, dragItem))
4041         return 0;
4042
4043     TREEVIEW_UpdateDispInfo(infoPtr, dragItem, TVIF_TEXT);
4044
4045     hwtop = GetDesktopWindow();
4046     htopdc = GetDC(hwtop);
4047     hdc = CreateCompatibleDC(htopdc);
4048
4049     hOldFont = SelectObject(hdc, infoPtr->hFont);
4050     GetTextExtentPoint32A(hdc, dragItem->pszText, lstrlenA(dragItem->pszText),
4051                           &size);
4052     TRACE("%ld %ld %s %d\n", size.cx, size.cy, dragItem->pszText,
4053           lstrlenA(dragItem->pszText));
4054     hbmp = CreateCompatibleBitmap(htopdc, size.cx, size.cy);
4055     hOldbmp = SelectObject(hdc, hbmp);
4056
4057     ImageList_GetIconSize(infoPtr->himlNormal, &cx, &cy);
4058     size.cx += cx;
4059     if (cy > size.cy)
4060         size.cy = cy;
4061
4062     infoPtr->dragList = ImageList_Create(size.cx, size.cy, ILC_COLOR, 10, 10);
4063     ImageList_Draw(infoPtr->himlNormal, dragItem->iImage, hdc, 0, 0,
4064                    ILD_NORMAL);
4065
4066 /*
4067  ImageList_GetImageInfo (infoPtr->himlNormal, dragItem->hItem, &iminfo);
4068  ImageList_AddMasked (infoPtr->dragList, iminfo.hbmImage, CLR_DEFAULT);
4069 */
4070
4071 /* draw item text */
4072
4073     SetRect(&rc, cx, 0, size.cx, size.cy);
4074     DrawTextA(hdc, dragItem->pszText, lstrlenA(dragItem->pszText), &rc,
4075               DT_LEFT);
4076     SelectObject(hdc, hOldFont);
4077     SelectObject(hdc, hOldbmp);
4078
4079     ImageList_Add(infoPtr->dragList, hbmp, 0);
4080
4081     DeleteDC(hdc);
4082     DeleteObject(hbmp);
4083     ReleaseDC(hwtop, htopdc);
4084
4085     return (LRESULT)infoPtr->dragList;
4086 }
4087
4088 /* Selection ************************************************************/
4089
4090 static LRESULT
4091 TREEVIEW_DoSelectItem(TREEVIEW_INFO *infoPtr, INT action, HTREEITEM newSelect,
4092                       INT cause)
4093 {
4094     TREEVIEW_ITEM *prevSelect;
4095     RECT rcFocused;
4096
4097     assert(newSelect == NULL || TREEVIEW_ValidItem(infoPtr, newSelect));
4098
4099     TRACE("Entering item %p (%s), flag %x, cause %x, state %d\n",
4100           newSelect, TREEVIEW_ItemName(newSelect), action, cause,
4101           newSelect ? newSelect->state : 0);
4102
4103     /* reset and redraw focusedItem if focusedItem was set so we don't */
4104     /* have to worry about the previously focused item when we set a new one */
4105     if(infoPtr->focusedItem)
4106     {
4107         rcFocused = (infoPtr->focusedItem)->rect;
4108         infoPtr->focusedItem = 0;
4109         InvalidateRect(infoPtr->hwnd, &rcFocused, TRUE);
4110     }
4111
4112     switch (action)
4113     {
4114     case TVGN_CARET:
4115         prevSelect = infoPtr->selectedItem;
4116
4117         if (prevSelect == newSelect)
4118             return FALSE;
4119
4120         if (TREEVIEW_SendTreeviewNotify(infoPtr,
4121                                         TVN_SELCHANGINGA,
4122                                         cause,
4123                                         TVIF_HANDLE | TVIF_STATE | TVIF_PARAM,
4124                                         prevSelect,
4125                                         newSelect))
4126             return FALSE;
4127
4128         if (prevSelect)
4129             prevSelect->state &= ~TVIS_SELECTED;
4130         if (newSelect)
4131             newSelect->state |= TVIS_SELECTED;
4132
4133         infoPtr->selectedItem = newSelect;
4134
4135         TREEVIEW_EnsureVisible(infoPtr, infoPtr->selectedItem, FALSE);
4136
4137         TREEVIEW_SendTreeviewNotify(infoPtr,
4138                                     TVN_SELCHANGEDA,
4139                                     cause,
4140                                     TVIF_HANDLE | TVIF_STATE | TVIF_PARAM,
4141                                     prevSelect,
4142                                     newSelect);
4143         TREEVIEW_Invalidate(infoPtr, prevSelect);
4144         TREEVIEW_Invalidate(infoPtr, newSelect);
4145         break;
4146
4147     case TVGN_DROPHILITE:
4148         prevSelect = infoPtr->dropItem;
4149
4150         if (prevSelect)
4151             prevSelect->state &= ~TVIS_DROPHILITED;
4152
4153         infoPtr->dropItem = newSelect;
4154
4155         if (newSelect)
4156             newSelect->state |= TVIS_DROPHILITED;
4157
4158         TREEVIEW_Invalidate(infoPtr, prevSelect);
4159         TREEVIEW_Invalidate(infoPtr, newSelect);
4160         break;
4161
4162     case TVGN_FIRSTVISIBLE:
4163         TREEVIEW_EnsureVisible(infoPtr, newSelect, FALSE);
4164         TREEVIEW_SetFirstVisible(infoPtr, newSelect, TRUE);
4165         TREEVIEW_Invalidate(infoPtr, NULL);
4166         break;
4167     }
4168
4169     TRACE("Leaving state %d\n", newSelect ? newSelect->state : 0);
4170     return TRUE;
4171 }
4172
4173 /* FIXME: handle NM_KILLFOCUS etc */
4174 static LRESULT
4175 TREEVIEW_SelectItem(TREEVIEW_INFO *infoPtr, INT wParam, HTREEITEM item)
4176 {
4177     if (item != NULL && !TREEVIEW_ValidItem(infoPtr, item))
4178         return FALSE;
4179
4180     TRACE("%p (%s) %d\n", item, TREEVIEW_ItemName(item), wParam);
4181
4182     if (!TREEVIEW_DoSelectItem(infoPtr, wParam, item, TVC_UNKNOWN))
4183         return FALSE;
4184
4185     return TRUE;
4186 }
4187
4188 /*************************************************************************
4189  *              TREEVIEW_ProcessLetterKeys
4190  *
4191  *  Processes keyboard messages generated by pressing the letter keys
4192  *  on the keyboard.
4193  *  What this does is perform a case insensitive search from the
4194  *  current position with the following quirks:
4195  *  - If two chars or more are pressed in quick succession we search
4196  *    for the corresponding string (e.g. 'abc').
4197  *  - If there is a delay we wipe away the current search string and
4198  *    restart with just that char.
4199  *  - If the user keeps pressing the same character, whether slowly or
4200  *    fast, so that the search string is entirely composed of this
4201  *    character ('aaaaa' for instance), then we search for first item
4202  *    that starting with that character.
4203  *  - If the user types the above character in quick succession, then
4204  *    we must also search for the corresponding string ('aaaaa'), and
4205  *    go to that string if there is a match.
4206  *
4207  * RETURNS
4208  *
4209  *  Zero.
4210  *
4211  * BUGS
4212  *
4213  *  - The current implementation has a list of characters it will
4214  *    accept and it ignores averything else. In particular it will
4215  *    ignore accentuated characters which seems to match what
4216  *    Windows does. But I'm not sure it makes sense to follow
4217  *    Windows there.
4218  *  - We don't sound a beep when the search fails.
4219  *  - The search should start from the focused item, not from the selected
4220  *    item. One reason for this is to allow for multiple selections in trees.
4221  *    But currently infoPtr->focusedItem does not seem very usable.
4222  *
4223  * SEE ALSO
4224  *
4225  *  TREEVIEW_ProcessLetterKeys
4226  */
4227 static INT TREEVIEW_ProcessLetterKeys(
4228     HWND hwnd, /* handle to the window */
4229     WPARAM charCode, /* the character code, the actual character */
4230     LPARAM keyData /* key data */
4231     )
4232 {
4233     TREEVIEW_INFO *infoPtr;
4234     HTREEITEM nItem;
4235     HTREEITEM endidx,idx;
4236     TVITEMEXA item;
4237     CHAR buffer[MAX_PATH];
4238     DWORD timestamp,elapsed;
4239
4240     /* simple parameter checking */
4241     if (!hwnd || !charCode || !keyData)
4242         return 0;
4243
4244     infoPtr=(TREEVIEW_INFO*)GetWindowLongA(hwnd, 0);
4245     if (!infoPtr)
4246         return 0;
4247
4248     /* only allow the valid WM_CHARs through */
4249     if (!isalnum(charCode) &&
4250         charCode != '.' && charCode != '`' && charCode != '!' &&
4251         charCode != '@' && charCode != '#' && charCode != '$' &&
4252         charCode != '%' && charCode != '^' && charCode != '&' &&
4253         charCode != '*' && charCode != '(' && charCode != ')' &&
4254         charCode != '-' && charCode != '_' && charCode != '+' &&
4255         charCode != '=' && charCode != '\\'&& charCode != ']' &&
4256         charCode != '}' && charCode != '[' && charCode != '{' &&
4257         charCode != '/' && charCode != '?' && charCode != '>' &&
4258         charCode != '<' && charCode != ',' && charCode != '~')
4259         return 0;
4260
4261     /* compute how much time elapsed since last keypress */
4262     timestamp = GetTickCount();
4263     if (timestamp > infoPtr->lastKeyPressTimestamp) {
4264         elapsed=timestamp-infoPtr->lastKeyPressTimestamp;
4265     } else {
4266         elapsed=infoPtr->lastKeyPressTimestamp-timestamp;
4267     }
4268
4269     /* update the search parameters */
4270     infoPtr->lastKeyPressTimestamp=timestamp;
4271     if (elapsed < KEY_DELAY) {
4272         if (infoPtr->nSearchParamLength < sizeof(infoPtr->szSearchParam)) {
4273             infoPtr->szSearchParam[infoPtr->nSearchParamLength++]=charCode;
4274         }
4275         if (infoPtr->charCode != charCode) {
4276             infoPtr->charCode=charCode=0;
4277         }
4278     } else {
4279         infoPtr->charCode=charCode;
4280         infoPtr->szSearchParam[0]=charCode;
4281         infoPtr->nSearchParamLength=1;
4282         /* Redundant with the 1 char string */
4283         charCode=0;
4284     }
4285
4286     /* and search from the current position */
4287     nItem=NULL;
4288     if (infoPtr->selectedItem != NULL) {
4289         endidx=infoPtr->selectedItem;
4290         /* if looking for single character match,
4291          * then we must always move forward
4292          */
4293         if (infoPtr->nSearchParamLength == 1)
4294             idx=TREEVIEW_GetNextListItem(infoPtr,endidx);
4295         else
4296             idx=endidx;
4297     } else {
4298         endidx=NULL;
4299         idx=infoPtr->root->firstChild;
4300     }
4301     do {
4302         if (idx == NULL) {
4303             if (endidx == NULL)
4304                 break;
4305             idx=infoPtr->root->firstChild;
4306         }
4307
4308         /* get item */
4309         ZeroMemory(&item, sizeof(item));
4310         item.mask = TVIF_TEXT;
4311         item.hItem = idx;
4312         item.pszText = buffer;
4313         item.cchTextMax = sizeof(buffer);
4314         TREEVIEW_GetItemA( infoPtr, &item );
4315
4316         /* check for a match */
4317         if (strncasecmp(item.pszText,infoPtr->szSearchParam,infoPtr->nSearchParamLength) == 0) {
4318             nItem=idx;
4319             break;
4320         } else if ( (charCode != 0) && (nItem == NULL) &&
4321                     (nItem != infoPtr->selectedItem) &&
4322                     (strncasecmp(item.pszText,infoPtr->szSearchParam,1) == 0) ) {
4323             /* This would work but we must keep looking for a longer match */
4324             nItem=idx;
4325         }
4326         idx=TREEVIEW_GetNextListItem(infoPtr,idx);
4327     } while (idx != endidx);
4328
4329     if (nItem != NULL) {
4330         if (TREEVIEW_DoSelectItem(infoPtr, TVGN_CARET, nItem, TVC_BYKEYBOARD)) {
4331             TREEVIEW_EnsureVisible(infoPtr, nItem, FALSE);
4332         }
4333     }
4334
4335     return 0;
4336 }
4337
4338 /* Scrolling ************************************************************/
4339
4340 static LRESULT
4341 TREEVIEW_EnsureVisible(TREEVIEW_INFO *infoPtr, HTREEITEM item, BOOL bHScroll)
4342 {
4343     HTREEITEM newFirstVisible = NULL;
4344     int visible_pos;
4345
4346     if (!TREEVIEW_ValidItem(infoPtr, item))
4347         return FALSE;
4348
4349     if (!ISVISIBLE(item))
4350     {
4351         /* Expand parents as necessary. */
4352         HTREEITEM parent;
4353
4354         /* see if we are trying to ensure that root is vislble */
4355         if((item != infoPtr->root) && TREEVIEW_ValidItem(infoPtr, item))
4356           parent = item->parent;
4357         else
4358           parent = item; /* this item is the topmost item */
4359
4360         while (parent != infoPtr->root)
4361         {
4362             if (!(parent->state & TVIS_EXPANDED))
4363                 TREEVIEW_Expand(infoPtr, parent, FALSE, FALSE);
4364
4365             parent = parent->parent;
4366         }
4367     }
4368
4369     TRACE("%p (%s) %ld - %ld\n", item, TREEVIEW_ItemName(item), item->visibleOrder,
4370           infoPtr->firstVisible->visibleOrder);
4371
4372     visible_pos = item->visibleOrder - infoPtr->firstVisible->visibleOrder;
4373
4374     if (visible_pos < 0)
4375     {
4376         /* item is before the start of the list: put it at the top. */
4377         newFirstVisible = item;
4378     }
4379     else if (visible_pos >= TREEVIEW_GetVisibleCount(infoPtr)
4380              /* Sometimes, before we are displayed, GVC is 0, causing us to
4381               * spuriously scroll up. */
4382              && visible_pos > 0)
4383     {
4384         /* item is past the end of the list. */
4385         int scroll = visible_pos - TREEVIEW_GetVisibleCount(infoPtr);
4386
4387         newFirstVisible = TREEVIEW_GetListItem(infoPtr, infoPtr->firstVisible,
4388                                                scroll + 1);
4389     }
4390
4391     if (bHScroll)
4392     {
4393         /* Scroll window so item's text is visible as much as possible */
4394         /* Calculation of amount of extra space is taken from EditLabel code */
4395         INT pos, x;
4396         TEXTMETRICA textMetric;
4397         HDC hdc = GetWindowDC(infoPtr->hwnd);
4398
4399         x = item->textWidth;
4400
4401         GetTextMetricsA(hdc, &textMetric);
4402         ReleaseDC(infoPtr->hwnd, hdc);
4403
4404         x += (textMetric.tmMaxCharWidth * 2);
4405         x = max(x, textMetric.tmMaxCharWidth * 3);
4406
4407         if (item->textOffset < 0)
4408            pos = item->textOffset;
4409         else if (item->textOffset + x > infoPtr->clientWidth)
4410         {
4411            if (x > infoPtr->clientWidth)
4412               pos = item->textOffset;
4413            else
4414               pos = item->textOffset + x - infoPtr->clientWidth;
4415         }
4416         else
4417            pos = 0;
4418
4419         TREEVIEW_HScroll(infoPtr, MAKEWPARAM(SB_THUMBPOSITION, infoPtr->scrollX + pos));
4420     }
4421
4422     if (newFirstVisible != NULL && newFirstVisible != infoPtr->firstVisible)
4423     {
4424         TREEVIEW_SetFirstVisible(infoPtr, newFirstVisible, TRUE);
4425
4426         return TRUE;
4427     }
4428
4429     return FALSE;
4430 }
4431
4432 static VOID
4433 TREEVIEW_SetFirstVisible(TREEVIEW_INFO *infoPtr,
4434                          TREEVIEW_ITEM *newFirstVisible,
4435                          BOOL bUpdateScrollPos)
4436 {
4437     int gap_size;
4438
4439     TRACE("%p: %s\n", newFirstVisible, TREEVIEW_ItemName(newFirstVisible));
4440
4441     if (newFirstVisible != NULL)
4442     {
4443         /* Prevent an empty gap from appearing at the bottom... */
4444         gap_size = TREEVIEW_GetVisibleCount(infoPtr)
4445             - infoPtr->maxVisibleOrder + newFirstVisible->visibleOrder;
4446
4447         if (gap_size > 0)
4448         {
4449             newFirstVisible = TREEVIEW_GetListItem(infoPtr, newFirstVisible,
4450                                                    -gap_size);
4451
4452             /* ... unless we just don't have enough items. */
4453             if (newFirstVisible == NULL)
4454                 newFirstVisible = infoPtr->root->firstChild;
4455         }
4456     }
4457
4458     if (infoPtr->firstVisible != newFirstVisible)
4459     {
4460         if (infoPtr->firstVisible == NULL || newFirstVisible == NULL)
4461         {
4462             infoPtr->firstVisible = newFirstVisible;
4463             TREEVIEW_Invalidate(infoPtr, NULL);
4464         }
4465         else
4466         {
4467             TREEVIEW_ITEM *item;
4468             int scroll = infoPtr->uItemHeight *
4469                          (infoPtr->firstVisible->visibleOrder
4470                           - newFirstVisible->visibleOrder);
4471
4472             infoPtr->firstVisible = newFirstVisible;
4473
4474             for (item = infoPtr->root->firstChild; item != NULL;
4475                  item = TREEVIEW_GetNextListItem(infoPtr, item))
4476             {
4477                item->rect.top += scroll;
4478                item->rect.bottom += scroll;
4479             }
4480
4481             if (bUpdateScrollPos)
4482                 SetScrollPos(infoPtr->hwnd, SB_VERT,
4483                               newFirstVisible->visibleOrder, TRUE);
4484
4485             ScrollWindow(infoPtr->hwnd, 0, scroll, NULL, NULL);
4486             UpdateWindow(infoPtr->hwnd);
4487         }
4488     }
4489 }
4490
4491 /************************************************************************
4492  * VScroll is always in units of visible items. i.e. we always have a
4493  * visible item aligned to the top of the control. (Unless we have no
4494  * items at all.)
4495  */
4496 static LRESULT
4497 TREEVIEW_VScroll(TREEVIEW_INFO *infoPtr, WPARAM wParam)
4498 {
4499     TREEVIEW_ITEM *oldFirstVisible = infoPtr->firstVisible;
4500     TREEVIEW_ITEM *newFirstVisible = NULL;
4501
4502     int nScrollCode = LOWORD(wParam);
4503
4504     TRACE("wp %x\n", wParam);
4505
4506     if (!(infoPtr->uInternalStatus & TV_VSCROLL))
4507         return 0;
4508
4509     if (infoPtr->hwndEdit)
4510         SetFocus(infoPtr->hwnd);
4511
4512     if (!oldFirstVisible)
4513     {
4514         assert(infoPtr->root->firstChild == NULL);
4515         return 0;
4516     }
4517
4518     switch (nScrollCode)
4519     {
4520     case SB_TOP:
4521         newFirstVisible = infoPtr->root->firstChild;
4522         break;
4523
4524     case SB_BOTTOM:
4525         newFirstVisible = TREEVIEW_GetLastListItem(infoPtr, infoPtr->root);
4526         break;
4527
4528     case SB_LINEUP:
4529         newFirstVisible = TREEVIEW_GetPrevListItem(infoPtr, oldFirstVisible);
4530         break;
4531
4532     case SB_LINEDOWN:
4533         newFirstVisible = TREEVIEW_GetNextListItem(infoPtr, oldFirstVisible);
4534         break;
4535
4536     case SB_PAGEUP:
4537         newFirstVisible = TREEVIEW_GetListItem(infoPtr, oldFirstVisible,
4538                                                -max(1, TREEVIEW_GetVisibleCount(infoPtr)));
4539         break;
4540
4541     case SB_PAGEDOWN:
4542         newFirstVisible = TREEVIEW_GetListItem(infoPtr, oldFirstVisible,
4543                                                max(1, TREEVIEW_GetVisibleCount(infoPtr)));
4544         break;
4545
4546     case SB_THUMBTRACK:
4547     case SB_THUMBPOSITION:
4548         newFirstVisible = TREEVIEW_GetListItem(infoPtr,
4549                                                infoPtr->root->firstChild,
4550                                                (LONG)(SHORT)HIWORD(wParam));
4551         break;
4552
4553     case SB_ENDSCROLL:
4554         return 0;
4555     }
4556
4557     if (newFirstVisible != NULL)
4558     {
4559         if (newFirstVisible != oldFirstVisible)
4560             TREEVIEW_SetFirstVisible(infoPtr, newFirstVisible,
4561                                   nScrollCode != SB_THUMBTRACK);
4562         else if (nScrollCode == SB_THUMBPOSITION)
4563             SetScrollPos(infoPtr->hwnd, SB_VERT,
4564                          newFirstVisible->visibleOrder, TRUE);
4565     }
4566
4567     return 0;
4568 }
4569
4570 static LRESULT
4571 TREEVIEW_HScroll(TREEVIEW_INFO *infoPtr, WPARAM wParam)
4572 {
4573     int maxWidth;
4574     int scrollX = infoPtr->scrollX;
4575     int nScrollCode = LOWORD(wParam);
4576
4577     TRACE("wp %x\n", wParam);
4578
4579     if (!(infoPtr->uInternalStatus & TV_HSCROLL))
4580         return FALSE;
4581
4582     if (infoPtr->hwndEdit)
4583         SetFocus(infoPtr->hwnd);
4584
4585     maxWidth = infoPtr->treeWidth - infoPtr->clientWidth;
4586     /* shall never occur */
4587     if (maxWidth <= 0)
4588     {
4589        scrollX = 0;
4590        goto scroll;
4591     }
4592
4593     switch (nScrollCode)
4594     {
4595     case SB_LINELEFT:
4596         scrollX -= infoPtr->uItemHeight;
4597         break;
4598     case SB_LINERIGHT:
4599         scrollX += infoPtr->uItemHeight;
4600         break;
4601     case SB_PAGELEFT:
4602         scrollX -= infoPtr->clientWidth;
4603         break;
4604     case SB_PAGERIGHT:
4605         scrollX += infoPtr->clientWidth;
4606         break;
4607
4608     case SB_THUMBTRACK:
4609     case SB_THUMBPOSITION:
4610         scrollX = (int)(SHORT)HIWORD(wParam);
4611         break;
4612
4613     case SB_ENDSCROLL:
4614        return 0;
4615     }
4616
4617     if (scrollX > maxWidth)
4618         scrollX = maxWidth;
4619     else if (scrollX < 0)
4620         scrollX = 0;
4621
4622 scroll:
4623     if (scrollX != infoPtr->scrollX)
4624     {
4625         TREEVIEW_ITEM *item;
4626         LONG scroll_pixels = infoPtr->scrollX - scrollX;
4627
4628         for (item = infoPtr->root->firstChild; item != NULL;
4629              item = TREEVIEW_GetNextListItem(infoPtr, item))
4630         {
4631            item->linesOffset += scroll_pixels;
4632            item->stateOffset += scroll_pixels;
4633            item->imageOffset += scroll_pixels;
4634            item->textOffset  += scroll_pixels;
4635         }
4636
4637         ScrollWindow(infoPtr->hwnd, scroll_pixels, 0, NULL, NULL);
4638         infoPtr->scrollX = scrollX;
4639         UpdateWindow(infoPtr->hwnd);
4640     }
4641
4642     if (nScrollCode != SB_THUMBTRACK)
4643        SetScrollPos(infoPtr->hwnd, SB_HORZ, scrollX, TRUE);
4644
4645     return 0;
4646 }
4647
4648 static LRESULT
4649 TREEVIEW_MouseWheel(TREEVIEW_INFO *infoPtr, WPARAM wParam)
4650 {
4651     short gcWheelDelta;
4652     UINT pulScrollLines = 3;
4653
4654     if (infoPtr->firstVisible == NULL)
4655         return TRUE;
4656
4657     SystemParametersInfoW(SPI_GETWHEELSCROLLLINES, 0, &pulScrollLines, 0);
4658
4659     gcWheelDelta = -(short)HIWORD(wParam);
4660     pulScrollLines *= (gcWheelDelta / WHEEL_DELTA);
4661
4662     if (abs(gcWheelDelta) >= WHEEL_DELTA && pulScrollLines)
4663     {
4664         int newDy = infoPtr->firstVisible->visibleOrder + pulScrollLines;
4665         int maxDy = infoPtr->maxVisibleOrder;
4666
4667         if (newDy > maxDy)
4668             newDy = maxDy;
4669
4670         if (newDy < 0)
4671             newDy = 0;
4672
4673         TREEVIEW_VScroll(infoPtr, MAKEWPARAM(SB_THUMBPOSITION, newDy));
4674     }
4675     return TRUE;
4676 }
4677
4678 /* Create/Destroy *******************************************************/
4679
4680 static LRESULT
4681 TREEVIEW_Create(HWND hwnd)
4682 {
4683     RECT rcClient;
4684     TREEVIEW_INFO *infoPtr;
4685
4686     TRACE("wnd %x, style %lx\n", hwnd, GetWindowLongA(hwnd, GWL_STYLE));
4687
4688     infoPtr = (TREEVIEW_INFO *)COMCTL32_Alloc(sizeof(TREEVIEW_INFO));
4689
4690     if (infoPtr == NULL)
4691     {
4692         ERR("could not allocate info memory!\n");
4693         return 0;
4694     }
4695
4696     SetWindowLongA(hwnd, 0, (DWORD)infoPtr);
4697
4698     infoPtr->hwnd = hwnd;
4699     infoPtr->dwStyle = GetWindowLongA(hwnd, GWL_STYLE);
4700     infoPtr->uInternalStatus = 0;
4701     infoPtr->Timer = 0;
4702     infoPtr->uNumItems = 0;
4703     infoPtr->cdmode = 0;
4704     infoPtr->uScrollTime = 300; /* milliseconds */
4705     infoPtr->bRedraw = TRUE;
4706
4707     GetClientRect(hwnd, &rcClient);
4708
4709     /* No scroll bars yet. */
4710     infoPtr->clientWidth = rcClient.right;
4711     infoPtr->clientHeight = rcClient.bottom;
4712
4713     infoPtr->treeWidth = 0;
4714     infoPtr->treeHeight = 0;
4715
4716     infoPtr->uIndent = 19;
4717     infoPtr->selectedItem = 0;
4718     infoPtr->focusedItem = 0;
4719     /* hotItem? */
4720     infoPtr->firstVisible = 0;
4721     infoPtr->maxVisibleOrder = 0;
4722     infoPtr->dropItem = 0;
4723     infoPtr->insertMarkItem = 0;
4724     infoPtr->insertBeforeorAfter = 0;
4725     /* dragList */
4726
4727     infoPtr->scrollX = 0;
4728
4729     infoPtr->clrBk = GetSysColor(COLOR_WINDOW);
4730     infoPtr->clrText = -1;      /* use system color */
4731     infoPtr->clrLine = RGB(128, 128, 128);
4732     infoPtr->clrInsertMark = GetSysColor(COLOR_BTNTEXT);
4733
4734     /* hwndToolTip */
4735
4736     infoPtr->hwndEdit = 0;
4737     infoPtr->wpEditOrig = NULL;
4738     infoPtr->bIgnoreEditKillFocus = FALSE;
4739     infoPtr->bLabelChanged = FALSE;
4740
4741     infoPtr->himlNormal = NULL;
4742     infoPtr->himlState = NULL;
4743     infoPtr->normalImageWidth = 0;
4744     infoPtr->normalImageHeight = 0;
4745     infoPtr->stateImageWidth = 0;
4746     infoPtr->stateImageHeight = 0;
4747
4748     infoPtr->items = DPA_Create(16);
4749
4750     infoPtr->hFont = GetStockObject(DEFAULT_GUI_FONT);
4751     infoPtr->hBoldFont = TREEVIEW_CreateBoldFont(infoPtr->hFont);
4752
4753     infoPtr->uItemHeight = TREEVIEW_NaturalHeight(infoPtr);
4754
4755     infoPtr->root = TREEVIEW_AllocateItem(infoPtr);
4756     infoPtr->root->state = TVIS_EXPANDED;
4757     infoPtr->root->iLevel = -1;
4758     infoPtr->root->visibleOrder = -1;
4759
4760     infoPtr->hwndNotify = GetParent(hwnd);
4761 #if 0
4762     infoPtr->bTransparent = ( GetWindowLongA( hwnd, GWL_STYLE) & TBSTYLE_FLAT);
4763 #endif
4764
4765     infoPtr->hwndToolTip = 0;
4766
4767     infoPtr->bUnicode = IsWindowUnicode (hwnd);
4768
4769     /* Determine what type of notify should be issued */
4770     /* sets infoPtr->bNtfUnicode */
4771     TREEVIEW_NotifyFormat(infoPtr, 0, NF_REQUERY);
4772
4773     if (!(infoPtr->dwStyle & TVS_NOTOOLTIPS))
4774         infoPtr->hwndToolTip = COMCTL32_CreateToolTip(hwnd);
4775
4776     if (infoPtr->dwStyle & TVS_CHECKBOXES)
4777     {
4778         RECT rc;
4779         HBITMAP hbm, hbmOld;
4780         HDC hdc;
4781         int nIndex;
4782
4783         infoPtr->himlState =
4784             ImageList_Create(16, 16, ILC_COLOR | ILC_MASK, 3, 0);
4785
4786         hdc = CreateCompatibleDC(0);
4787         hbm = CreateCompatibleBitmap(hdc, 48, 16);
4788         hbmOld = SelectObject(hdc, hbm);
4789
4790         rc.left  = 0;   rc.top    = 0;
4791         rc.right = 48;  rc.bottom = 16;
4792         FillRect(hdc, &rc, (HBRUSH)(COLOR_WINDOW+1));
4793
4794         rc.left  = 18;   rc.top    = 2;
4795         rc.right = 30;   rc.bottom = 14;
4796         DrawFrameControl(hdc, &rc, DFC_BUTTON,
4797                           DFCS_BUTTONCHECK|DFCS_FLAT);
4798
4799         rc.left  = 34;   rc.right  = 46;
4800         DrawFrameControl(hdc, &rc, DFC_BUTTON,
4801                           DFCS_BUTTONCHECK|DFCS_FLAT|DFCS_CHECKED);
4802
4803         nIndex = ImageList_AddMasked(infoPtr->himlState, hbm,
4804                                       GetSysColor(COLOR_WINDOW));
4805         TRACE("chckbox index %d\n", nIndex);
4806         SelectObject(hdc, hbmOld);
4807         DeleteObject(hbm);
4808         DeleteDC(hdc);
4809
4810         infoPtr->stateImageWidth = 16;
4811         infoPtr->stateImageHeight = 16;
4812     }
4813     return 0;
4814 }
4815
4816
4817 static LRESULT
4818 TREEVIEW_Destroy(TREEVIEW_INFO *infoPtr)
4819 {
4820     TRACE("\n");
4821
4822     TREEVIEW_RemoveTree(infoPtr);
4823
4824     /* tool tip is automatically destroyed: we are its owner */
4825
4826     /* Restore original wndproc */
4827     if (infoPtr->hwndEdit)
4828         SetWindowLongA(infoPtr->hwndEdit, GWL_WNDPROC,
4829                        (LONG)infoPtr->wpEditOrig);
4830
4831     /* Deassociate treeview from the window before doing anything drastic. */
4832     SetWindowLongA(infoPtr->hwnd, 0, (LONG)NULL);
4833
4834     DeleteObject(infoPtr->hBoldFont);
4835     COMCTL32_Free(infoPtr);
4836
4837     return 0;
4838 }
4839
4840 /* Miscellaneous Messages ***********************************************/
4841
4842 static LRESULT
4843 TREEVIEW_ScrollKeyDown(TREEVIEW_INFO *infoPtr, WPARAM key)
4844 {
4845     static const struct
4846     {
4847         unsigned char code;
4848     }
4849     scroll[] =
4850     {
4851 #define SCROLL_ENTRY(dir, code) { ((dir) << 7) | (code) }
4852         SCROLL_ENTRY(SB_VERT, SB_PAGEUP),       /* VK_PRIOR */
4853         SCROLL_ENTRY(SB_VERT, SB_PAGEDOWN),     /* VK_NEXT */
4854         SCROLL_ENTRY(SB_VERT, SB_BOTTOM),       /* VK_END */
4855         SCROLL_ENTRY(SB_VERT, SB_TOP),          /* VK_HOME */
4856         SCROLL_ENTRY(SB_HORZ, SB_LINEUP),       /* VK_LEFT */
4857         SCROLL_ENTRY(SB_VERT, SB_LINEUP),       /* VK_UP */
4858         SCROLL_ENTRY(SB_HORZ, SB_LINEDOWN),     /* VK_RIGHT */
4859         SCROLL_ENTRY(SB_VERT, SB_LINEDOWN)      /* VK_DOWN */
4860 #undef SCROLL_ENTRY
4861     };
4862
4863     if (key >= VK_PRIOR && key <= VK_DOWN)
4864     {
4865         unsigned char code = scroll[key - VK_PRIOR].code;
4866
4867         (((code & (1 << 7)) == (SB_HORZ << 7))
4868          ? TREEVIEW_HScroll
4869          : TREEVIEW_VScroll)(infoPtr, code & 0x7F);
4870     }
4871
4872     return 0;
4873 }
4874
4875 /************************************************************************
4876  *        TREEVIEW_KeyDown
4877  *
4878  * VK_UP       Move selection to the previous non-hidden item.
4879  * VK_DOWN     Move selection to the next non-hidden item.
4880  * VK_HOME     Move selection to the first item.
4881  * VK_END      Move selection to the last item.
4882  * VK_LEFT     If expanded then collapse, otherwise move to parent.
4883  * VK_RIGHT    If collapsed then expand, otherwise move to first child.
4884  * VK_ADD      Expand.
4885  * VK_SUBTRACT Collapse.
4886  * VK_MULTIPLY Expand all.
4887  * VK_PRIOR    Move up GetVisibleCount items.
4888  * VK_NEXT     Move down GetVisibleCount items.
4889  * VK_BACK     Move to parent.
4890  * CTRL-Left,Right,Up,Down,PgUp,PgDown,Home,End: Scroll without changing selection
4891  */
4892 static LRESULT
4893 TREEVIEW_KeyDown(TREEVIEW_INFO *infoPtr, WPARAM wParam)
4894 {
4895     /* If it is non-NULL and different, it will be selected and visible. */
4896     TREEVIEW_ITEM *newSelection = NULL;
4897
4898     TREEVIEW_ITEM *prevItem = infoPtr->selectedItem;
4899
4900     TRACE("%x\n", wParam);
4901
4902     if (prevItem == NULL)
4903         return FALSE;
4904
4905     if (GetAsyncKeyState(VK_CONTROL) & 0x8000)
4906         return TREEVIEW_ScrollKeyDown(infoPtr, wParam);
4907
4908     switch (wParam)
4909     {
4910     case VK_UP:
4911         newSelection = TREEVIEW_GetPrevListItem(infoPtr, prevItem);
4912         if (!newSelection)
4913             newSelection = infoPtr->root->firstChild;
4914         break;
4915
4916     case VK_DOWN:
4917         newSelection = TREEVIEW_GetNextListItem(infoPtr, prevItem);
4918         break;
4919
4920     case VK_HOME:
4921         newSelection = infoPtr->root->firstChild;
4922         break;
4923
4924     case VK_END:
4925         newSelection = TREEVIEW_GetLastListItem(infoPtr, infoPtr->root);
4926         break;
4927
4928     case VK_LEFT:
4929         if (prevItem->state & TVIS_EXPANDED)
4930         {
4931             TREEVIEW_Collapse(infoPtr, prevItem, FALSE, TRUE);
4932         }
4933         else if (prevItem->parent != infoPtr->root)
4934         {
4935             newSelection = prevItem->parent;
4936         }
4937         break;
4938
4939     case VK_RIGHT:
4940         if (TREEVIEW_HasChildren(infoPtr, prevItem))
4941         {
4942             if (!(prevItem->state & TVIS_EXPANDED))
4943                 TREEVIEW_Expand(infoPtr, prevItem, FALSE, TRUE);
4944             else
4945             {
4946                 newSelection = prevItem->firstChild;
4947             }
4948         }
4949
4950         break;
4951
4952     case VK_MULTIPLY:
4953         TREEVIEW_ExpandAll(infoPtr, prevItem);
4954         break;
4955
4956     case VK_ADD:
4957         if (!(prevItem->state & TVIS_EXPANDED))
4958             TREEVIEW_Expand(infoPtr, prevItem, FALSE, TRUE);
4959         break;
4960
4961     case VK_SUBTRACT:
4962         if (prevItem->state & TVIS_EXPANDED)
4963             TREEVIEW_Collapse(infoPtr, prevItem, FALSE, TRUE);
4964         break;
4965
4966     case VK_PRIOR:
4967         newSelection
4968             = TREEVIEW_GetListItem(infoPtr, prevItem,
4969                                    -TREEVIEW_GetVisibleCount(infoPtr));
4970         break;
4971
4972     case VK_NEXT:
4973         newSelection
4974             = TREEVIEW_GetListItem(infoPtr, prevItem,
4975                                    TREEVIEW_GetVisibleCount(infoPtr));
4976         break;
4977
4978     case VK_BACK:
4979         newSelection = prevItem->parent;
4980         if (newSelection == infoPtr->root)
4981             newSelection = NULL;
4982         break;
4983
4984     case VK_SPACE:
4985         if (infoPtr->dwStyle & TVS_CHECKBOXES)
4986             TREEVIEW_ToggleItemState(infoPtr, prevItem);
4987         break;
4988     }
4989
4990     if (newSelection && newSelection != prevItem)
4991     {
4992         if (TREEVIEW_DoSelectItem(infoPtr, TVGN_CARET, newSelection,
4993                                   TVC_BYKEYBOARD))
4994         {
4995             TREEVIEW_EnsureVisible(infoPtr, newSelection, FALSE);
4996         }
4997     }
4998
4999     return FALSE;
5000 }
5001
5002 static LRESULT
5003 TREEVIEW_Notify(TREEVIEW_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
5004 {
5005     LPNMHDR lpnmh = (LPNMHDR)lParam;
5006
5007     if (lpnmh->code == PGN_CALCSIZE) {
5008         LPNMPGCALCSIZE lppgc = (LPNMPGCALCSIZE)lParam;
5009
5010         if (lppgc->dwFlag == PGF_CALCWIDTH) {
5011             lppgc->iWidth = infoPtr->treeWidth;
5012             TRACE("got PGN_CALCSIZE, returning horz size = %ld, client=%ld\n",
5013                   infoPtr->treeWidth, infoPtr->clientWidth);
5014         }
5015         else {
5016             lppgc->iHeight = infoPtr->treeHeight;
5017             TRACE("got PGN_CALCSIZE, returning vert size = %ld, client=%ld\n",
5018                   infoPtr->treeHeight, infoPtr->clientHeight);
5019         }
5020         return 0;
5021     }
5022     return DefWindowProcA(infoPtr->hwnd, WM_NOTIFY, wParam, lParam);
5023 }
5024
5025 static LRESULT
5026 TREEVIEW_NotifyFormat (TREEVIEW_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
5027 {
5028     INT i;
5029
5030     if (lParam == NF_REQUERY) {
5031         i = SendMessageA(GetParent (infoPtr->hwnd),
5032                          WM_NOTIFYFORMAT, infoPtr->hwnd, NF_QUERY);
5033         if ((i < NFR_ANSI) || (i > NFR_UNICODE)) {
5034             ERR("wrong response to WM_NOTIFYFORMAT (%d), assuming ANSI\n",
5035                 i);
5036             i = NFR_ANSI;
5037         }
5038         infoPtr->bNtfUnicode = (i == NFR_UNICODE) ? 1 : 0;
5039         return (LRESULT)i;
5040     }
5041     return (LRESULT)((infoPtr->bNtfUnicode) ? NFR_UNICODE : NFR_ANSI);
5042 }
5043
5044
5045 static LRESULT
5046 TREEVIEW_Size(TREEVIEW_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
5047 {
5048     if (wParam == SIZE_RESTORED)
5049     {
5050         infoPtr->clientWidth  = SLOWORD(lParam);
5051         infoPtr->clientHeight = SHIWORD(lParam);
5052
5053         TREEVIEW_RecalculateVisibleOrder(infoPtr, NULL);
5054         TREEVIEW_SetFirstVisible(infoPtr, infoPtr->firstVisible, TRUE);
5055         TREEVIEW_UpdateScrollBars(infoPtr);
5056     }
5057     else
5058     {
5059         FIXME("WM_SIZE flag %x %lx not handled\n", wParam, lParam);
5060     }
5061
5062     TREEVIEW_Invalidate(infoPtr, NULL);
5063     return 0;
5064 }
5065
5066 static LRESULT
5067 TREEVIEW_StyleChanged(TREEVIEW_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
5068 {
5069     TRACE("(%x %lx)\n", wParam, lParam);
5070
5071     if (wParam == GWL_STYLE)
5072     {
5073        DWORD dwNewStyle = ((LPSTYLESTRUCT)lParam)->styleNew;
5074
5075        /* we have to take special care about tooltips */
5076        if ((infoPtr->dwStyle ^ dwNewStyle) & TVS_NOTOOLTIPS)
5077        {
5078           if (infoPtr->dwStyle & TVS_NOTOOLTIPS)
5079           {
5080               infoPtr->hwndToolTip = COMCTL32_CreateToolTip(infoPtr->hwnd);
5081               TRACE("\n");
5082           }
5083           else
5084           {
5085              DestroyWindow(infoPtr->hwndToolTip);
5086              infoPtr->hwndToolTip = 0;
5087           }
5088        }
5089
5090        infoPtr->dwStyle = dwNewStyle;
5091     }
5092
5093     TREEVIEW_UpdateSubTree(infoPtr, infoPtr->root);
5094     TREEVIEW_UpdateScrollBars(infoPtr);
5095     TREEVIEW_Invalidate(infoPtr, NULL);
5096
5097     return 0;
5098 }
5099
5100 static LRESULT
5101 TREEVIEW_SetFocus(TREEVIEW_INFO *infoPtr)
5102 {
5103     TRACE("\n");
5104
5105     if (!infoPtr->selectedItem)
5106     {
5107         TREEVIEW_DoSelectItem(infoPtr, TVGN_CARET, infoPtr->firstVisible,
5108                               TVC_UNKNOWN);
5109     }
5110
5111     TREEVIEW_SendSimpleNotify(infoPtr, NM_SETFOCUS);
5112     TREEVIEW_Invalidate(infoPtr, infoPtr->selectedItem);
5113     return 0;
5114 }
5115
5116 static LRESULT
5117 TREEVIEW_KillFocus(TREEVIEW_INFO *infoPtr)
5118 {
5119     TRACE("\n");
5120
5121     TREEVIEW_SendSimpleNotify(infoPtr, NM_KILLFOCUS);
5122     TREEVIEW_Invalidate(infoPtr, infoPtr->selectedItem);
5123     return 0;
5124 }
5125
5126
5127 static LRESULT WINAPI
5128 TREEVIEW_WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
5129 {
5130     TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
5131     if (infoPtr) TREEVIEW_VerifyTree(infoPtr);
5132     else
5133     {
5134         if (uMsg == WM_CREATE)
5135             TREEVIEW_Create(hwnd);
5136         else
5137             goto def;
5138     }
5139
5140     switch (uMsg)
5141     {
5142     case TVM_CREATEDRAGIMAGE:
5143         return TREEVIEW_CreateDragImage(infoPtr, wParam, lParam);
5144
5145     case TVM_DELETEITEM:
5146         return TREEVIEW_DeleteItem(infoPtr, (HTREEITEM)lParam);
5147
5148     case TVM_EDITLABELA:
5149         return TREEVIEW_EditLabelA(infoPtr, (HTREEITEM)lParam);
5150
5151     case TVM_EDITLABELW:
5152         FIXME("Unimplemented msg TVM_EDITLABELW\n");
5153         return 0;
5154
5155     case TVM_ENDEDITLABELNOW:
5156         return TREEVIEW_EndEditLabelNow(infoPtr, (BOOL)wParam);
5157
5158     case TVM_ENSUREVISIBLE:
5159         return TREEVIEW_EnsureVisible(infoPtr, (HTREEITEM)lParam, TRUE);
5160
5161     case TVM_EXPAND:
5162         return TREEVIEW_ExpandMsg(infoPtr, (UINT)wParam, (HTREEITEM)lParam);
5163
5164     case TVM_GETBKCOLOR:
5165         return TREEVIEW_GetBkColor(infoPtr);
5166
5167     case TVM_GETCOUNT:
5168         return TREEVIEW_GetCount(infoPtr);
5169
5170     case TVM_GETEDITCONTROL:
5171         return TREEVIEW_GetEditControl(infoPtr);
5172
5173     case TVM_GETIMAGELIST:
5174         return TREEVIEW_GetImageList(infoPtr, wParam);
5175
5176     case TVM_GETINDENT:
5177         return TREEVIEW_GetIndent(infoPtr);
5178
5179     case TVM_GETINSERTMARKCOLOR:
5180         return TREEVIEW_GetInsertMarkColor(infoPtr);
5181
5182     case TVM_GETISEARCHSTRINGA:
5183         FIXME("Unimplemented msg TVM_GETISEARCHSTRINGA\n");
5184         return 0;
5185
5186     case TVM_GETISEARCHSTRINGW:
5187         FIXME("Unimplemented msg TVM_GETISEARCHSTRINGW\n");
5188         return 0;
5189
5190     case TVM_GETITEMA:
5191         return TREEVIEW_GetItemA(infoPtr, (LPTVITEMEXA)lParam);
5192
5193     case TVM_GETITEMW:
5194         return TREEVIEW_GetItemW(infoPtr, (LPTVITEMEXW)lParam);
5195
5196     case TVM_GETITEMHEIGHT:
5197         return TREEVIEW_GetItemHeight(infoPtr);
5198
5199     case TVM_GETITEMRECT:
5200         return TREEVIEW_GetItemRect(infoPtr, (BOOL)wParam, (LPRECT)lParam);
5201
5202     case TVM_GETITEMSTATE:
5203         return TREEVIEW_GetItemState(infoPtr, (HTREEITEM)wParam, (UINT)lParam);
5204
5205     case TVM_GETLINECOLOR:
5206         return TREEVIEW_GetLineColor(infoPtr);
5207
5208     case TVM_GETNEXTITEM:
5209         return TREEVIEW_GetNextItem(infoPtr, (UINT)wParam, (HTREEITEM)lParam);
5210
5211     case TVM_GETSCROLLTIME:
5212         return TREEVIEW_GetScrollTime(infoPtr);
5213
5214     case TVM_GETTEXTCOLOR:
5215         return TREEVIEW_GetTextColor(infoPtr);
5216
5217     case TVM_GETTOOLTIPS:
5218         return TREEVIEW_GetToolTips(infoPtr);
5219
5220     case TVM_GETUNICODEFORMAT:
5221         FIXME("Unimplemented msg TVM_GETUNICODEFORMAT\n");
5222         return 0;
5223
5224     case TVM_GETVISIBLECOUNT:
5225         return TREEVIEW_GetVisibleCount(infoPtr);
5226
5227     case TVM_HITTEST:
5228         return TREEVIEW_HitTest(infoPtr, (LPTVHITTESTINFO)lParam);
5229
5230     case TVM_INSERTITEMA:
5231         return TREEVIEW_InsertItemA(infoPtr, lParam);
5232
5233     case TVM_INSERTITEMW:
5234         return TREEVIEW_InsertItemW(infoPtr, lParam);
5235
5236     case TVM_SELECTITEM:
5237         return TREEVIEW_SelectItem(infoPtr, (INT)wParam, (HTREEITEM)lParam);
5238
5239     case TVM_SETBKCOLOR:
5240         return TREEVIEW_SetBkColor(infoPtr, (COLORREF)lParam);
5241
5242     case TVM_SETIMAGELIST:
5243         return TREEVIEW_SetImageList(infoPtr, wParam, (HIMAGELIST)lParam);
5244
5245     case TVM_SETINDENT:
5246         return TREEVIEW_SetIndent(infoPtr, (UINT)wParam);
5247
5248     case TVM_SETINSERTMARK:
5249         return TREEVIEW_SetInsertMark(infoPtr, (BOOL)wParam, (HTREEITEM)lParam);
5250
5251     case TVM_SETINSERTMARKCOLOR:
5252         return TREEVIEW_SetInsertMarkColor(infoPtr, (COLORREF)lParam);
5253
5254     case TVM_SETITEMA:
5255         return TREEVIEW_SetItemA(infoPtr, (LPTVITEMEXA)lParam);
5256
5257     case TVM_SETITEMW:
5258     return TREEVIEW_SetItemW(infoPtr, (LPTVITEMEXW)lParam);
5259         return 0;
5260
5261     case TVM_SETLINECOLOR:
5262         return TREEVIEW_SetLineColor(infoPtr, (COLORREF)lParam);
5263
5264     case TVM_SETITEMHEIGHT:
5265         return TREEVIEW_SetItemHeight(infoPtr, (INT)(SHORT)wParam);
5266
5267     case TVM_SETSCROLLTIME:
5268         return TREEVIEW_SetScrollTime(infoPtr, (UINT)wParam);
5269
5270     case TVM_SETTEXTCOLOR:
5271         return TREEVIEW_SetTextColor(infoPtr, (COLORREF)lParam);
5272
5273     case TVM_SETTOOLTIPS:
5274         return TREEVIEW_SetToolTips(infoPtr, (HWND)wParam);
5275
5276     case TVM_SETUNICODEFORMAT:
5277         FIXME("Unimplemented msg TVM_SETUNICODEFORMAT\n");
5278         return 0;
5279
5280     case TVM_SORTCHILDREN:
5281         return TREEVIEW_SortChildren(infoPtr, wParam, lParam);
5282
5283     case TVM_SORTCHILDRENCB:
5284         return TREEVIEW_SortChildrenCB(infoPtr, wParam, (LPTVSORTCB)lParam);
5285
5286     case WM_CHAR:
5287         return TREEVIEW_ProcessLetterKeys( hwnd, wParam, lParam );
5288
5289     case WM_COMMAND:
5290         return TREEVIEW_Command(infoPtr, wParam, lParam);
5291
5292     case WM_DESTROY:
5293         return TREEVIEW_Destroy(infoPtr);
5294
5295         /* WM_ENABLE */
5296
5297     case WM_ERASEBKGND:
5298         return TREEVIEW_EraseBackground(infoPtr, (HDC)wParam);
5299
5300     case WM_GETDLGCODE:
5301         return DLGC_WANTARROWS | DLGC_WANTCHARS;
5302
5303     case WM_GETFONT:
5304         return TREEVIEW_GetFont(infoPtr);
5305
5306     case WM_HSCROLL:
5307         return TREEVIEW_HScroll(infoPtr, wParam);
5308
5309     case WM_KEYDOWN:
5310         return TREEVIEW_KeyDown(infoPtr, wParam);
5311
5312     case WM_KILLFOCUS:
5313         return TREEVIEW_KillFocus(infoPtr);
5314
5315     case WM_LBUTTONDBLCLK:
5316         return TREEVIEW_LButtonDoubleClick(infoPtr, lParam);
5317
5318     case WM_LBUTTONDOWN:
5319         return TREEVIEW_LButtonDown(infoPtr, lParam);
5320
5321         /* WM_MBUTTONDOWN */
5322
5323         /* WM_MOUSEMOVE */
5324
5325     case WM_NOTIFY:
5326         return TREEVIEW_Notify(infoPtr, wParam, lParam);
5327
5328     case WM_NOTIFYFORMAT:
5329         return TREEVIEW_NotifyFormat(infoPtr, wParam, lParam);
5330
5331     case WM_PAINT:
5332         return TREEVIEW_Paint(infoPtr, wParam);
5333
5334         /* WM_PRINTCLIENT */
5335
5336     case WM_RBUTTONDOWN:
5337         return TREEVIEW_RButtonDown(infoPtr, lParam);
5338
5339     case WM_SETFOCUS:
5340         return TREEVIEW_SetFocus(infoPtr);
5341
5342     case WM_SETFONT:
5343         return TREEVIEW_SetFont(infoPtr, (HFONT)wParam, (BOOL)lParam);
5344
5345     case WM_SETREDRAW:
5346         return TREEVIEW_SetRedraw(infoPtr, wParam, lParam);
5347
5348     case WM_SIZE:
5349         return TREEVIEW_Size(infoPtr, wParam, lParam);
5350
5351     case WM_STYLECHANGED:
5352         return TREEVIEW_StyleChanged(infoPtr, wParam, lParam);
5353
5354         /* WM_SYSCOLORCHANGE */
5355
5356         /* WM_SYSKEYDOWN */
5357
5358     case WM_TIMER:
5359         return TREEVIEW_HandleTimer(infoPtr, wParam);
5360
5361     case WM_VSCROLL:
5362         return TREEVIEW_VScroll(infoPtr, wParam);
5363
5364         /* WM_WININICHANGE */
5365
5366     case WM_MOUSEWHEEL:
5367         if (wParam & (MK_SHIFT | MK_CONTROL))
5368             goto def;
5369         return TREEVIEW_MouseWheel(infoPtr, wParam);
5370
5371     case WM_DRAWITEM:
5372         TRACE("drawItem\n");
5373         goto def;
5374
5375     default:
5376         /* This mostly catches MFC and Delphi messages. :( */
5377         if (uMsg >= WM_USER)
5378             TRACE("Unknown msg %04x wp=%08x lp=%08lx\n", uMsg, wParam, lParam);
5379 def:
5380         return DefWindowProcA(hwnd, uMsg, wParam, lParam);
5381     }
5382     return 0;
5383 }
5384
5385
5386 /* Class Registration ***************************************************/
5387
5388 VOID
5389 TREEVIEW_Register(void)
5390 {
5391     WNDCLASSA wndClass;
5392
5393     TRACE("\n");
5394
5395     ZeroMemory(&wndClass, sizeof(WNDCLASSA));
5396     wndClass.style = CS_GLOBALCLASS | CS_DBLCLKS;
5397     wndClass.lpfnWndProc = (WNDPROC)TREEVIEW_WindowProc;
5398     wndClass.cbClsExtra = 0;
5399     wndClass.cbWndExtra = sizeof(TREEVIEW_INFO *);
5400
5401     wndClass.hCursor = LoadCursorA(0, IDC_ARROWA);
5402     wndClass.hbrBackground = 0;
5403     wndClass.lpszClassName = WC_TREEVIEWA;
5404
5405     RegisterClassA(&wndClass);
5406 }
5407
5408
5409 VOID
5410 TREEVIEW_Unregister(void)
5411 {
5412     UnregisterClassA(WC_TREEVIEWA, (HINSTANCE) NULL);
5413 }
5414
5415
5416 /* Tree Verification ****************************************************/
5417
5418 #ifdef NDEBUG
5419 static inline void
5420 TREEVIEW_VerifyChildren(TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *item);
5421
5422 static inline void TREEVIEW_VerifyItemCommon(TREEVIEW_INFO *infoPtr,
5423                                              TREEVIEW_ITEM *item)
5424 {
5425     assert(infoPtr != NULL);
5426     assert(item != NULL);
5427
5428     /* both NULL, or both non-null */
5429     assert((item->firstChild == NULL) == (item->lastChild == NULL));
5430
5431     assert(item->firstChild != item);
5432     assert(item->lastChild != item);
5433
5434     if (item->firstChild)
5435     {
5436         assert(item->firstChild->parent == item);
5437         assert(item->firstChild->prevSibling == NULL);
5438     }
5439
5440     if (item->lastChild)
5441     {
5442         assert(item->lastChild->parent == item);
5443         assert(item->lastChild->nextSibling == NULL);
5444     }
5445
5446     assert(item->nextSibling != item);
5447     if (item->nextSibling)
5448     {
5449         assert(item->nextSibling->parent == item->parent);
5450         assert(item->nextSibling->prevSibling == item);
5451     }
5452
5453     assert(item->prevSibling != item);
5454     if (item->prevSibling)
5455     {
5456         assert(item->prevSibling->parent == item->parent);
5457         assert(item->prevSibling->nextSibling == item);
5458     }
5459 }
5460
5461 static inline void
5462 TREEVIEW_VerifyItem(TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *item)
5463 {
5464     assert(item != NULL);
5465
5466     assert(item->parent != NULL);
5467     assert(item->parent != item);
5468     assert(item->iLevel == item->parent->iLevel + 1);
5469
5470     assert(DPA_GetPtrIndex(infoPtr->items, item) != -1);
5471
5472     TREEVIEW_VerifyItemCommon(infoPtr, item);
5473
5474     TREEVIEW_VerifyChildren(infoPtr, item);
5475 }
5476
5477 static inline void
5478 TREEVIEW_VerifyChildren(TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *item)
5479 {
5480     TREEVIEW_ITEM *child;
5481     assert(item != NULL);
5482
5483     for (child = item->firstChild; child != NULL; child = child->nextSibling)
5484         TREEVIEW_VerifyItem(infoPtr, child);
5485 }
5486
5487 static inline void
5488 TREEVIEW_VerifyRoot(TREEVIEW_INFO *infoPtr)
5489 {
5490     TREEVIEW_ITEM *root = infoPtr->root;
5491
5492     assert(root != NULL);
5493     assert(root->iLevel == -1);
5494     assert(root->parent == NULL);
5495     assert(root->prevSibling == NULL);
5496
5497     TREEVIEW_VerifyItemCommon(infoPtr, root);
5498
5499     TREEVIEW_VerifyChildren(infoPtr, root);
5500 }
5501
5502 static void
5503 TREEVIEW_VerifyTree(TREEVIEW_INFO *infoPtr)
5504 {
5505     assert(infoPtr != NULL);
5506
5507     TREEVIEW_VerifyRoot(infoPtr);
5508 }
5509 #endif