diff --git a/dlls/comctl32/treeview.c b/dlls/comctl32/treeview.c
index dd982b8..dd6356a 100644
--- a/dlls/comctl32/treeview.c
+++ b/dlls/comctl32/treeview.c
@@ -1,36 +1,46 @@
 /* Treeview control
  *
  * Copyright 1998 Eric Kohl <ekohl@abo.rhein-zeitung.de>
- * Copyright 1998 Alex Priem <alexp@sci.kun.nl>
+ * Copyright 1998,1999 Alex Priem <alexp@sci.kun.nl>
  *
  *
  * TODO:
- *   - Nearly all notifications.
- * 
- *   list-handling stuff: sort, sorted insertitem.
- *
+ *   list-handling stuff: sort, sorted insertitem. 
+ *           [should be merged with mm-handling stuff as done in listview]
  *   refreshtreeview: 	
 		-small array containing info about positions.
- 		-better implementation of DrawItem (connecting lines).
+ 		-better implementation of RefreshItem:
+              1) draw lines between parents
+              2) draw items
+			  3) draw lines from parent<->items.
 		-implement partial drawing?
- *   Expand:		-ctlmacro expands twice ->toggle.
- *  -drag&drop.
- *  -scrollbars.
+ *  -drag&drop: TVM_CREATEDRAGIMAGE should create drag bitmap.
+ *  -scrollbars: horizontal scrollbar doesn't work.
  *  -Unicode messages
- *  -TV_ITEMEX 
+ *  -check custom draw
+ *  -I_CHILDRENCALLBACK
+ *   FIXME: check fontsize. (uRealItemHeight)
+ *          test focusItem  (redraw in different color)
+			uHotItem
+			Edit: needs timer
+				  better implementation.
+ *   WM_HSCROLL is broken.
+ *   use separate routine to get item text/image.
+ *  
+ *   Separate drawing/calculation.
  *
- * FIXMEs:  
-   -GetNextItem: add flags for traversing child lists.
-                   (DESCEND_ALWAYS, DESCEND_NEVER, DESCEND_VISIBLE)
+ * FIXMEs  (for personal use)
+    Expand:		-ctlmacro expands twice ->toggle.
    -DblClick:	ctlmacro.exe's NM_DBLCLK seems to go wrong (returns FALSE).
+   -treehelper: stack corruption makes big window. 
 	     
  */
 
+
 #include <string.h>
 #include "windows.h"
 #include "commctrl.h"
 #include "treeview.h"
-#include "heap.h"
 #include "win.h"
 #include "debug.h"
 
@@ -50,22 +60,42 @@
 TREEVIEW_SendSimpleNotify (WND *wndPtr, UINT32 code);
 static BOOL32
 TREEVIEW_SendTreeviewNotify (WND *wndPtr, UINT32 code, UINT32 action, 
-			INT32 oldItem, INT32 newItem, POINT32 pt);
+			INT32 oldItem, INT32 newItem);
+static BOOL32
+TREEVIEW_SendTreeviewDnDNotify (WND *wndPtr, UINT32 code, INT32 dragItem, 
+			POINT32 pt);
+static BOOL32
+TREEVIEW_SendDispInfoNotify (WND *wndPtr, TREEVIEW_ITEM *wineItem, 
+			UINT32 code, UINT32 what);
+static BOOL32
+TREEVIEW_SendCustomDrawNotify (WND *wndPtr, DWORD dwDrawStage, HDC32 hdc,
+			RECT32 rc);
+static BOOL32
+TREEVIEW_SendCustomDrawItemNotify (WND *wndPtr, HDC32 hdc,
+            TREEVIEW_ITEM *tvItem, UINT32 uItemDrawState);
 static LRESULT
-TREEVIEW_SelectItem (WND *wndPtr, WPARAM32 wParam, LPARAM lParam);
+TREEVIEW_DoSelectItem (WND *wndPtr, INT32 action, INT32 newSelect, INT32 cause);
 static void
 TREEVIEW_Refresh (WND *wndPtr);
 
+static LRESULT CALLBACK
+TREEVIEW_Edit_SubclassProc (HWND32 hwnd, UINT32 uMsg, WPARAM32 wParam, 
+							LPARAM lParam);
+
 
 
 
 
 /* helper functions. Work with the assumption that validity of operands 
-   is checked beforehand */
+   is checked beforehand, and that tree state is valid.  */
 
 /* FIXME: MS documentation says `GetNextVisibleItem' returns NULL 
-   if not succesfull'. Probably means derefencing, and not whether 
-   there is a next `visible' child. */
+   if not succesfull'. Probably only applies to derefencing infoPtr
+   (ie we are offered a valid treeview structure)
+   and not whether there is a next `visible' child. 
+   FIXME: check other failures.
+ */
+
 
 
 static TREEVIEW_ITEM *
@@ -113,9 +143,10 @@
 {
  TREEVIEW_ITEM *wineItem;
 
- if ((tvItem->firstChild) && (tvItem->state & TVIS_EXPANDED)) 
+  if ((tvItem->firstChild) && (tvItem->state & TVIS_EXPANDED)) 
 		return (& infoPtr->items[tvItem->firstChild]);
 
+
  if (tvItem->sibling) 
 		return (& infoPtr->items[tvItem->sibling]);
 
@@ -126,17 +157,16 @@
                 return (& infoPtr->items [wineItem->sibling]);
  } 
 
- return wineItem;
+ return NULL;  /* was wineItem */
 }
 
-static TREEVIEW_ITEM *TREEVIEW_GetLastListItem (TREEVIEW_INFO *infoPtr)
+static TREEVIEW_ITEM *TREEVIEW_GetLastListItem (TREEVIEW_INFO *infoPtr,
+					TREEVIEW_ITEM *tvItem)
 
 {
-  TREEVIEW_ITEM *wineItem;
-  
- wineItem=NULL;
- if (infoPtr->TopRootItem) 
-	wineItem=& infoPtr->items [infoPtr->TopRootItem];
+ TREEVIEW_ITEM *wineItem;
+
+ wineItem=tvItem;
  while (wineItem->sibling) 
 	wineItem=& infoPtr->items [wineItem->sibling];
 
@@ -144,12 +174,40 @@
 }
 	
  
+static void TREEVIEW_RemoveAllChildren (WND *wndPtr,
+					   TREEVIEW_ITEM *parentItem)
+
+{
+ TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr);
+ TREEVIEW_ITEM *killItem;
+ INT32	kill;
+ 
+ kill=parentItem->firstChild;
+ while (kill) {
+ 	tv_set_bit ( kill, infoPtr->freeList);
+ 	killItem=& infoPtr->items[kill];
+	if (killItem->pszText!=LPSTR_TEXTCALLBACK32A) 
+		COMCTL32_Free (killItem->pszText);
+ 	TREEVIEW_SendTreeviewNotify (wndPtr, TVN_DELETEITEM, 0, kill, 0);
+	if (killItem->firstChild) 
+			TREEVIEW_RemoveAllChildren (wndPtr, killItem);
+	kill=killItem->sibling;
+ }
+
+ if (parentItem->cChildren>0) {
+ 	infoPtr->uNumItems -= parentItem->cChildren;
+ 	parentItem->firstChild = 0;
+ 	parentItem->cChildren  = 0;
+ }
+
+}
 
 
 static void
-TREEVIEW_RemoveItem (TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *wineItem)
+TREEVIEW_RemoveItem (WND *wndPtr, TREEVIEW_ITEM *wineItem)
 
 {
+ TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr);
  TREEVIEW_ITEM *parentItem, *upsiblingItem, *siblingItem;
  INT32 iItem;
 
@@ -160,16 +218,25 @@
  if (wineItem->pszText!=LPSTR_TEXTCALLBACK32A) 
 	COMCTL32_Free (wineItem->pszText);
 
+ TREEVIEW_SendTreeviewNotify (wndPtr, TVN_DELETEITEM, 0, iItem, 0);
+
+ if (wineItem->firstChild) 
+ 	TREEVIEW_RemoveAllChildren (wndPtr,wineItem);
+
  if (wineItem->parent) {
-	parentItem=& infoPtr->items[ wineItem->parent];
-	if (parentItem->cChildren==1) {
-		parentItem->cChildren=0;
-		parentItem->firstChild=0;    
-		return;
-	} else {
-		parentItem->cChildren--;
-		if (parentItem->firstChild==iItem) 
-			parentItem->firstChild=wineItem->sibling;
+	parentItem=& infoPtr->items [wineItem->parent];
+	switch (parentItem->cChildren) {
+		case I_CHILDRENCALLBACK: 
+				FIXME (treeview,"we don't handle I_CHILDRENCALLBACK yet\n");
+				break;
+		case 1:
+			parentItem->cChildren=0;
+			parentItem->firstChild=0;    
+			return;
+		default:
+			parentItem->cChildren--;
+			if (parentItem->firstChild==iItem) 
+				parentItem->firstChild=wineItem->sibling;
 		}
  }
 
@@ -183,48 +250,30 @@
 	siblingItem=& infoPtr->items [wineItem->sibling];
 	siblingItem->upsibling=wineItem->upsibling;
  }
+
 }
 
 
 
-static void TREEVIEW_RemoveAllChildren (TREEVIEW_INFO *infoPtr, 
-					   TREEVIEW_ITEM *parentItem)
-
-{
- TREEVIEW_ITEM *killItem;
- INT32	kill;
- 
- kill=parentItem->firstChild;
- while (kill) {
- 	tv_set_bit ( kill, infoPtr->freeList);
- 	killItem=& infoPtr->items[kill];
-	if (killItem->pszText!=LPSTR_TEXTCALLBACK32A) 
-		COMCTL32_Free (killItem->pszText);
-	kill=killItem->sibling;
- }
- infoPtr->uNumItems -= parentItem->cChildren;
- parentItem->firstChild = 0;
- parentItem->cChildren = 0;
-}
-
-
 /* Note:TREEVIEW_RemoveTree doesn't remove infoPtr itself */
 
-static void TREEVIEW_RemoveTree (TREEVIEW_INFO *infoPtr)
+static void TREEVIEW_RemoveTree (WND *wndPtr)
 					   
-
 {
- 	TREEVIEW_ITEM *killItem;
- 	int i;
+ TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr);
+ TREEVIEW_ITEM *killItem;
+ int i;
 
-    for (i=1; i<=infoPtr->uMaxHandle; i++) 
-		if (!tv_test_bit (i, infoPtr->freeList)) {
-			killItem=& infoPtr->items [i];	
-			if (killItem->pszText!=LPSTR_TEXTCALLBACK32A)
-				COMCTL32_Free (killItem->pszText);
+ for (i=1; i<=infoPtr->uMaxHandle; i++) 
+	if (!tv_test_bit (i, infoPtr->freeList)) {
+		killItem=& infoPtr->items [i];	
+		if (killItem->pszText!=LPSTR_TEXTCALLBACK32A)
+			COMCTL32_Free (killItem->pszText);
+		TREEVIEW_SendTreeviewNotify 
+					(wndPtr, TVN_DELETEITEM, 0, killItem->hItem, 0);
 		} 
 
-    if (infoPtr->uNumPtrsAlloced) {
+ if (infoPtr->uNumPtrsAlloced) {
         COMCTL32_Free (infoPtr->items);
         COMCTL32_Free (infoPtr->freeList);
         infoPtr->uNumItems=0;
@@ -239,9 +288,6 @@
 
 
 
-
-
-
 static LRESULT
 TREEVIEW_GetImageList (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
 {
@@ -258,9 +304,6 @@
   return 0;
 }
 
-
-
-
 static LRESULT
 TREEVIEW_SetImageList (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
 {
@@ -289,21 +332,20 @@
 TREEVIEW_SetItemHeight (WND *wndPtr, WPARAM32 wParam)
 {
   TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr);
-  INT32 prevHeight=infoPtr->uItemHeight;
+  INT32 cx,cy,prevHeight=infoPtr->uItemHeight;
   HDC32 hdc;
-  TEXTMETRIC32A tm;
 
   TRACE (treeview,"\n");
   if (wParam==-1) {
 	hdc=GetDC32 (wndPtr->hwndSelf);
 	infoPtr->uItemHeight=-1;
-	GetTextMetrics32A (hdc, &tm);
-    infoPtr->uRealItemHeight= tm.tmHeight + tm.tmExternalLeading;
-	ReleaseDC32 (wndPtr->hwndSelf, hdc);
 	return prevHeight;
   }
 
-	/* FIXME: check wParam > imagelist height */
+  ImageList_GetIconSize (infoPtr->himlNormal, &cx, &cy);
+
+  if (wParam>cy) cy=wParam;
+  infoPtr->uItemHeight=cy;
 
   if (!(wndPtr->dwStyle & TVS_NONEVENHEIGHT))
 	infoPtr->uItemHeight = (INT32) wParam & 0xfffffffe;
@@ -331,7 +373,7 @@
 }
 
 static LRESULT
-TREEVIEW_GetTextColor (WND *wndPtr)
+TREEVIEW_GetBkColor (WND *wndPtr)
 {
   TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr);
 	
@@ -339,24 +381,75 @@
   return (LRESULT) infoPtr->clrText;
 }
 
-
-static INT32
-TREEVIEW_DrawItem (WND *wndPtr, HDC32 hdc, TREEVIEW_ITEM *wineItem, 
-		   TREEVIEW_ITEM *upperItem, int indent)
+static LRESULT
+TREEVIEW_SetBkColor (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
 {
   TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr);
-  INT32  oldBkMode,center,xpos;
+  COLORREF prevColor=infoPtr->clrBk;
+
+  TRACE (treeview,"\n");
+  infoPtr->clrBk=(COLORREF) lParam;
+  return (LRESULT) prevColor;
+}
+
+static LRESULT
+TREEVIEW_GetTextColor (WND *wndPtr)
+{
+  TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr);
+	
+  TRACE (treeview,"\n");
+  return (LRESULT) infoPtr->clrBk;
+}
+
+
+
+
+
+/* FIXME: draw background (infoPtr->clrBk) */
+
+
+/* cdmode: custom draw mode as received from app. in first NMCUSTOMDRAW 
+           notification */
+
+static void
+TREEVIEW_DrawItem (WND *wndPtr, HDC32 hdc, TREEVIEW_ITEM *wineItem)
+
+{
+  TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr);
+  INT32  oldBkMode,center,xpos,cx,cy, cditem, drawmode;
+  TREEVIEW_ITEM *parentItem;
   COLORREF oldBkColor;
+  HFONT32 hOldFont;
   UINT32 uTextJustify = DT_LEFT;
-  HPEN32 hOldPen, hnewPen /* ,hRootPen */ ;
+  HPEN32 hOldPen, hnewPen;
   RECT32 r,upper;
+
+  HIMAGELIST *himlp;
+  
+  if (wineItem->state & TVIS_BOLD) 
+  	hOldFont = SelectObject32 (hdc, infoPtr->hBoldFont);
+  else 
+  	hOldFont = SelectObject32 (hdc, infoPtr->hFont);
+
+  cditem=0;
+  if (infoPtr->cdmode & CDRF_NOTIFYITEMDRAW) {
+		drawmode=CDDS_ITEMPREPAINT;
+		if (infoPtr->cdmode & CDRF_NOTIFYSUBITEMDRAW) drawmode|=CDDS_SUBITEM;
+		cditem=TREEVIEW_SendCustomDrawItemNotify (wndPtr, hdc, wineItem, drawmode);
+		TRACE (treeview,"cditem:%d\n",cditem);
+		if (cditem & CDRF_SKIPDEFAULT) 
+			return;
+	}
+ 
   
   hnewPen = CreatePen32(PS_DOT, 0, GetSysColor32(COLOR_WINDOWTEXT) );
   hOldPen = SelectObject32( hdc, hnewPen );
  
   r=wineItem->rect;
-  if (upperItem) 
-	upper=upperItem->rect;
+  if (wineItem->parent) {
+	parentItem=TREEVIEW_ValidItem (infoPtr, wineItem->parent);
+	upper=parentItem->rect;
+  }
   else {
 	upper.top=0;
 	upper.left=8;
@@ -366,7 +459,7 @@
 
   if (wndPtr->dwStyle & TVS_HASLINES) {
 	POINT32 points[3];
-	if ((wndPtr->dwStyle & TVS_LINESATROOT) && (indent==0)) {
+	if ((wndPtr->dwStyle & TVS_LINESATROOT) && (wineItem->iLevel==0)) {
 		points[0].y=points[1].y=center;
 		points[2].y=upper.top;
 		points[1].x=points[2].x=upper.left;
@@ -388,38 +481,48 @@
   DeleteObject32(hnewPen);
   SelectObject32(hdc, hOldPen);
 
-  if ((wndPtr->dwStyle & TVS_HASBUTTONS) && (wineItem->cChildren)) {
-/*
-  	hRootPen = CreatePen32(PS_SOLID, 0, GetSysColor32(COLOR_WINDOW) );
-  	SelectObject32( hdc, hRootPen );
-*/
-
-	Rectangle32 (hdc, xpos-4, center-4, xpos+5, center+5);
-	MoveToEx32 (hdc, xpos-2, center, NULL);
-	LineTo32   (hdc, xpos+3, center);
-	if (!(wineItem->state & TVIS_EXPANDED)) {
-		MoveToEx32 (hdc, xpos,   center-2, NULL);
-		LineTo32   (hdc, xpos,   center+3);
+  if ((wndPtr->dwStyle & TVS_HASBUTTONS) && (wndPtr->dwStyle & TVS_HASLINES) && 
+		(wineItem->cChildren)) {
+		Rectangle32 (hdc, xpos-4, center-4, xpos+5, center+5);
+		MoveToEx32 (hdc, xpos-2, center, NULL);
+		LineTo32   (hdc, xpos+3, center);
+		if (!(wineItem->state & TVIS_EXPANDED)) {
+			MoveToEx32 (hdc, xpos,   center-2, NULL);
+			LineTo32   (hdc, xpos,   center+3);
 	}
- /* 	DeleteObject32(hRootPen); */
-        }
+   }
 
 
   xpos+=13;
 
-  if (wineItem->mask & TVIF_IMAGE) {
-	if (wineItem->iImage!=I_IMAGECALLBACK) {
-  		if (infoPtr->himlNormal) {
-  			ImageList_Draw (infoPtr->himlNormal,wineItem->iImage, hdc,
-                      			xpos-2, r.top+1, ILD_NORMAL);
-  			xpos+=15;
-		}
-	}
-  }
+  if (wineItem->mask & (TVIF_IMAGE|TVIF_SELECTEDIMAGE)) {
+
+    himlp=NULL;
+	if (infoPtr->himlNormal) himlp=&infoPtr->himlNormal;
+
+	if ((wineItem->state & TVIS_SELECTED) && (wineItem->iSelectedImage)) {
+		if (infoPtr->himlState) himlp=&infoPtr->himlState;
+		if (wineItem->iSelectedImage==I_IMAGECALLBACK) 
+			TREEVIEW_SendDispInfoNotify (wndPtr, wineItem, 
+										TVN_GETDISPINFO, TVIF_SELECTEDIMAGE);
+	} else { /* NOT selected */
+		if (wineItem->iImage==I_IMAGECALLBACK) 
+			TREEVIEW_SendDispInfoNotify (wndPtr, wineItem,
+										TVN_GETDISPINFO, TVIF_IMAGE);
+  	}
+
+ 	if (himlp) {
+ 	ImageList_Draw (*himlp, wineItem->iImage, hdc, xpos-2, r.top+1, ILD_NORMAL);
+ 	ImageList_GetIconSize (*himlp, &cx, &cy);
+ 	xpos+=cx;
+ 	}
+ }
+
 
   r.left=xpos;
   if ((wineItem->mask & TVIF_TEXT) && (wineItem->pszText)) {
-	    if (wineItem->state & TVIS_SELECTED) {
+
+	    if (wineItem->state & (TVIS_SELECTED | TVIS_DROPHILITED) ) {
            	oldBkMode = SetBkMode32(hdc, OPAQUE);
 			oldBkColor= SetBkColor32 (hdc, GetSysColor32( COLOR_HIGHLIGHT));
 			SetTextColor32 (hdc, GetSysColor32(COLOR_HIGHLIGHTTEXT));
@@ -428,24 +531,33 @@
 	    }
         r.left += 3;
         r.right -= 3;
+		wineItem->text.left=r.left;
+		wineItem->text.right=r.right;
 		if (infoPtr->clrText==-1)
            	SetTextColor32 (hdc, COLOR_BTNTEXT);
 		else 
-			SetTextColor32 (hdc, infoPtr->clrText);  /* FIXME: retval */
-		if (wineItem->pszText!= LPSTR_TEXTCALLBACK32A) 
-        	DrawText32A (hdc, wineItem->pszText, lstrlen32A(wineItem->pszText),
-                  &r, uTextJustify|DT_VCENTER|DT_SINGLELINE);
-		else {
-			/* send TVN_GETDISPINFO notification */
+			SetTextColor32 (hdc, infoPtr->clrText);  /* FIXME: setback retval */
+
+		if (wineItem->pszText== LPSTR_TEXTCALLBACK32A) {
 			TRACE (treeview,"LPSTR_TEXTCALLBACK\n");
+			TREEVIEW_SendDispInfoNotify (wndPtr, wineItem, 
+											TVN_GETDISPINFO, TVIF_TEXT);
 		}
+
+       	DrawText32A (hdc, wineItem->pszText, lstrlen32A(wineItem->pszText), &r, 
+						uTextJustify|DT_VCENTER|DT_SINGLELINE);
+
         if (oldBkMode != TRANSPARENT)
             SetBkMode32(hdc, oldBkMode);
-	    if (wineItem->state & TVIS_SELECTED)
+	    if (wineItem->state & (TVIS_SELECTED | TVIS_DROPHILITED))
 			SetBkColor32 (hdc, oldBkColor);
         }
 
- return wineItem->rect.right;
+  if (cditem & CDRF_NOTIFYPOSTPAINT)
+		TREEVIEW_SendCustomDrawItemNotify (wndPtr, hdc, wineItem, 
+											CDDS_ITEMPOSTPAINT);
+
+  SelectObject32 (hdc, hOldFont);
 }
 
 
@@ -459,18 +571,21 @@
 {
   TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr);
   TREEVIEW_ITEM *wineItem;
-  INT32 iItem;
+  HTREEITEM *iItem;
   LPRECT32 lpRect;
 
   TRACE (treeview,"\n");
   if (infoPtr==NULL) return FALSE;
+
+  if (infoPtr->Timer & TV_REFRESH_TIMER_SET)          
+		TREEVIEW_Refresh (wndPtr);	/* we want a rect for the current view */
   
-  iItem = (INT32)lParam;
-  wineItem = TREEVIEW_ValidItem (infoPtr, iItem);
+  iItem = (HTREEITEM *) lParam;
+  wineItem = TREEVIEW_ValidItem (infoPtr, *iItem);
   if (!wineItem) return FALSE;
 
-  wineItem=& infoPtr->items[ iItem ];
-  if (!wineItem->visible) return FALSE;
+  wineItem=& infoPtr->items[ *iItem ];
+  if (!wineItem->visible) return FALSE; 
 
   lpRect = (LPRECT32)lParam;
   if (lpRect == NULL) return FALSE;
@@ -479,7 +594,7 @@
   	lpRect->left	= wineItem->text.left;
 	lpRect->right	= wineItem->text.right;
 	lpRect->bottom	= wineItem->text.bottom;
-	lpRect->top	= wineItem->text.top;
+	lpRect->top	    = wineItem->text.top;
   } else {
 	lpRect->left 	= wineItem->rect.left;
 	lpRect->right	= wineItem->rect.right;
@@ -487,6 +602,8 @@
 	lpRect->top	= wineItem->rect.top;
   }
 
+  TRACE (treeview,"[L:%d R:%d T:%d B:%d]\n", lpRect->left,lpRect->right,
+									lpRect->top,lpRect->bottom);
   return TRUE;
 }
 
@@ -498,21 +615,20 @@
 {
   TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr);
 
-  TRACE (treeview,"\n");
   return (LRESULT) infoPtr->uVisibleHeight / infoPtr->uRealItemHeight;
 }
 
 
 
 static LRESULT
-TREEVIEW_SetItem (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
+TREEVIEW_SetItem32A (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
 {
   TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr);
   TREEVIEW_ITEM *wineItem;
-  TV_ITEM *tvItem;
+  TVITEMEX32A *tvItem;
   INT32 iItem,len;
 
-  tvItem=(LPTV_ITEM) lParam;
+  tvItem=(LPTVITEMEX32A) lParam;
   iItem=tvItem->hItem;
   TRACE (treeview,"item %d,mask %x\n",iItem,tvItem->mask);
 
@@ -528,7 +644,8 @@
   }
 
   if (tvItem->mask & TVIF_INTEGRAL) {
-/*        wineItem->iIntegral=tvItem->iIntegral; */
+        wineItem->iIntegral=tvItem->iIntegral; 
+        FIXME (treeview," TVIF_INTEGRAL not supported yet\n");
   }
 
   if (tvItem->mask & TVIF_PARAM) {
@@ -544,10 +661,18 @@
   }
 
   if (tvItem->mask & TVIF_TEXT) {
+		if (tvItem->pszText!=LPSTR_TEXTCALLBACK32A) {
         len=lstrlen32A (tvItem->pszText);
         if (len>wineItem->cchTextMax) 
 			wineItem->pszText= COMCTL32_ReAlloc (wineItem->pszText, len+1);
         lstrcpyn32A (wineItem->pszText, tvItem->pszText,len);
+		} else {
+			if (wineItem->cchTextMax) {
+				COMCTL32_Free (wineItem->pszText);
+				wineItem->cchTextMax=0;
+			}
+		wineItem->pszText=LPSTR_TEXTCALLBACK32A;
+		}
    }
 
   return TRUE;
@@ -562,11 +687,11 @@
 
 {
     TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr);
-    HFONT32 hFont, hOldFont;
+	TEXTMETRIC32A tm;
+	HBRUSH32 hbrBk;
     RECT32 rect;
-    HBRUSH32 hbrBk;
 	HDC32 hdc;
-    INT32 iItem, indent, x, y, height;
+    INT32 iItem, indent, x, y, cx, height, itemHeight;
     INT32 viewtop,viewbottom,viewleft,viewright;
     TREEVIEW_ITEM *wineItem, *prevItem;
 
@@ -582,21 +707,30 @@
     
     GetClientRect32 (wndPtr->hwndSelf, &rect);
     if ((rect.left-rect.right ==0) || (rect.top-rect.bottom==0)) return;
+
+    infoPtr->cdmode=TREEVIEW_SendCustomDrawNotify 
+						(wndPtr, CDDS_PREPAINT, hdc, rect);
+
+	if (infoPtr->cdmode==CDRF_SKIPDEFAULT) {
+		  ReleaseDC32 (wndPtr->hwndSelf, hdc);
+		  return;
+	}
+
+	infoPtr->uVisibleHeight= rect.bottom-rect.top;
+	infoPtr->uVisibleWidth= rect.right-rect.left;
+
     viewtop=infoPtr->cy;
     viewbottom=infoPtr->cy + rect.bottom-rect.top;
     viewleft=infoPtr->cx;
     viewright=infoPtr->cx + rect.right-rect.left;
 
-	infoPtr->uVisibleHeight=viewbottom - viewtop;
 
-    hFont = infoPtr->hFont;
-    hOldFont = SelectObject32 (hdc, hFont);
 
     /* draw background */
-    hbrBk = GetSysColorBrush32(COLOR_WINDOW);
+    
+    hbrBk = GetSysColorBrush32 (COLOR_WINDOW);
     FillRect32(hdc, &rect, hbrBk);
 
-
     iItem=infoPtr->TopRootItem;
     infoPtr->firstVisible=0;
     wineItem=NULL;
@@ -607,26 +741,55 @@
     while (iItem) {
 		prevItem=wineItem;
         wineItem= & infoPtr->items[iItem];
+		wineItem->iLevel=indent;
 
+        ImageList_GetIconSize (infoPtr->himlNormal, &cx, &itemHeight);
+        if (infoPtr->uItemHeight>itemHeight)
+		    itemHeight=infoPtr->uItemHeight;
+
+	    GetTextMetrics32A (hdc, &tm);
+ 	    if ((tm.tmHeight + tm.tmExternalLeading) > itemHeight)
+		     itemHeight=tm.tmHeight + tm.tmExternalLeading;
+
+        infoPtr->uRealItemHeight=itemHeight;	
+
+
+/* FIXME: remove this in later stage  */
+/*
+		if (wineItem->pszText!=LPSTR_TEXTCALLBACK32A) 
 		TRACE (treeview, "%d %d [%d %d %d %d] (%s)\n",y,x,
 			wineItem->rect.top, wineItem->rect.bottom,
 			wineItem->rect.left, wineItem->rect.right,
 			wineItem->pszText);
+		else 
+		TRACE (treeview, "%d [%d %d %d %d] (CALLBACK)\n",
+				wineItem->hItem,
+				wineItem->rect.top, wineItem->rect.bottom,
+				wineItem->rect.left, wineItem->rect.right);
+*/
 
-		height=infoPtr->uRealItemHeight * wineItem->iIntegral;
+		height=itemHeight * wineItem->iIntegral +1;
 		if ((y >= viewtop) && (y <= viewbottom) &&
 	    	(x >= viewleft  ) && (x <= viewright)) {
+				wineItem->visible = TRUE;
         		wineItem->rect.top = y - infoPtr->cy + rect.top;
         		wineItem->rect.bottom = wineItem->rect.top + height ;
          		wineItem->rect.left = x - infoPtr->cx + rect.left;
         		wineItem->rect.right = rect.right;
+				wineItem->text.left = wineItem->rect.left;
+				wineItem->text.top  = wineItem->rect.top;
+				wineItem->text.right= wineItem->rect.right;
+				wineItem->text.bottom=wineItem->rect.bottom;
 			if (!infoPtr->firstVisible)
 				infoPtr->firstVisible=wineItem->hItem;
-        		TREEVIEW_DrawItem (wndPtr, hdc, wineItem, prevItem, indent);
+       		TREEVIEW_DrawItem (wndPtr, hdc, wineItem);
 		}
 		else {
-			wineItem->rect.top  = wineItem->rect.bottom = -1;
-			wineItem->rect.left = wineItem->rect.right = -1;
+			wineItem->visible   = FALSE;
+			wineItem->rect.left = wineItem->rect.top    = 0;
+			wineItem->rect.right= wineItem->rect.bottom = 0;
+			wineItem->text.left = wineItem->text.top    = 0;
+			wineItem->text.right= wineItem->text.bottom = 0;
  		}
 
 		/* look up next item */
@@ -635,6 +798,8 @@
 			iItem=wineItem->firstChild;
 			indent++;
 			x+=infoPtr->uIndent;
+			if (x>infoPtr->uTotalWidth) 	
+				infoPtr->uTotalWidth=x;
 		}
 		else {
 			iItem=wineItem->sibling;
@@ -649,6 +814,9 @@
         y +=height;
     }				/* while */
 
+/* FIXME: infoPtr->uTotalWidth should also take item label into account */
+/* FIXME: or should query item sizes (ie check CDRF_NEWFONT) */
+
     infoPtr->uTotalHeight=y;
     if (y >= (viewbottom-viewtop)) {
  		if (!(infoPtr->uInternalStatus & TV_VSCROLL))
@@ -665,8 +833,12 @@
 	}
 
 
-    SelectObject32 (hdc, hOldFont);
+	if (infoPtr->cdmode & CDRF_NOTIFYPOSTPAINT) 
+    	infoPtr->cdmode=TREEVIEW_SendCustomDrawNotify 
+								(wndPtr, CDDS_POSTPAINT, hdc, rect);
+
     ReleaseDC32 (wndPtr->hwndSelf, hdc);
+    TRACE (treeview,"done\n");
 }
 
 
@@ -682,12 +854,14 @@
 	case TV_REFRESH_TIMER:
 		KillTimer32 (wndPtr->hwndSelf, TV_REFRESH_TIMER);
 		infoPtr->Timer &= ~TV_REFRESH_TIMER_SET;
-		TREEVIEW_Refresh (wndPtr);
+		SendMessage32A (wndPtr->hwndSelf, WM_PAINT, 0, 0);
 		return 0;
 	case TV_EDIT_TIMER:
 		KillTimer32 (wndPtr->hwndSelf, TV_EDIT_TIMER);
 		infoPtr->Timer &= ~TV_EDIT_TIMER_SET;
 		return 0;
+	default:
+		ERR (treeview,"got unknown timer\n");
  }
 		
  return 1;
@@ -712,22 +886,24 @@
 
 
 static LRESULT
-TREEVIEW_GetItem (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
+TREEVIEW_GetItem32A (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
 {
   TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr);
-  LPTV_ITEM      tvItem;
+  LPTVITEMEX32A    tvItem;
   TREEVIEW_ITEM *wineItem;
   INT32         iItem;
 
-  TRACE (treeview,"\n");
-  tvItem=(LPTV_ITEM) lParam;
+  tvItem=(LPTVITEMEX32A) lParam;
   iItem=tvItem->hItem;
+  TRACE (treeview,"item %d<%p>, txt %p, img %p, action %x\n", iItem,
+tvItem, tvItem->pszText, & tvItem->iImage, tvItem->mask);
 
   wineItem = TREEVIEW_ValidItem (infoPtr, iItem);
   if (!wineItem) return FALSE;
 
-
    if (tvItem->mask & TVIF_CHILDREN) {
+		if (TVIF_CHILDREN==I_CHILDRENCALLBACK) 
+			FIXME (treeview,"I_CHILDRENCALLBACK not supported\n");
         tvItem->cChildren=wineItem->cChildren;
    }
 
@@ -740,7 +916,8 @@
    }
 
    if (tvItem->mask & TVIF_INTEGRAL) {
-/*        tvItem->iIntegral=wineItem->iIntegral; */
+        tvItem->iIntegral=wineItem->iIntegral; 
+		FIXME (treeview," TVIF_INTEGRAL not supported yet\n");
    }
 
    if (tvItem->mask & TVIF_PARAM) {
@@ -757,7 +934,8 @@
 
    if (tvItem->mask & TVIF_TEXT) {
 	if (wineItem->pszText == LPSTR_TEXTCALLBACK32A) {
-	    tvItem->pszText = LPSTR_TEXTCALLBACK32A;
+	    tvItem->pszText = LPSTR_TEXTCALLBACK32A;  /* FIXME:send notification? */
+		ERR (treeview," GetItem called with LPSTR_TEXTCALLBACK\n");
 	}
 	else if (wineItem->pszText) {
 	    lstrcpyn32A (tvItem->pszText, wineItem->pszText, tvItem->cchTextMax);
@@ -771,58 +949,74 @@
 
 /* FIXME: check implementation of TVGN_NEXT/TVGN_NEXTVISIBLE */
 
-
 static LRESULT
-TREEVIEW_GetNextItem32 (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
+TREEVIEW_GetNextItem (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
 
 {
   TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr);
-  TREEVIEW_ITEM *wineItem;
-  INT32 iItem, flag;
+  TREEVIEW_ITEM *wineItem, *returnItem;
+  INT32 iItem, retval, flag;
 
 
-  TRACE (treeview,"item:%lu, flags:%x\n", lParam, wParam);
   if (!infoPtr) return FALSE;
-
-  flag= (INT32) wParam;
+  flag  = (INT32) wParam;
+  iItem = (INT32) lParam;
+  retval=0;
   switch (flag) {
-	case TVGN_ROOT: 	return (LRESULT) infoPtr->TopRootItem;
-	case TVGN_CARET: 	return (LRESULT) infoPtr->selectedItem;
+	case TVGN_ROOT: retval=infoPtr->TopRootItem;
+					break;
+	case TVGN_CARET:retval=infoPtr->selectedItem;
+					break;
 	case TVGN_FIRSTVISIBLE: 
-        				TREEVIEW_Refresh (wndPtr);
-						return (LRESULT) infoPtr->firstVisible;
+         			TREEVIEW_Refresh (wndPtr);       
+/* FIXME:we should only recalculate, not redraw */
+					retval=infoPtr->firstVisible;
+					break;
 	case TVGN_DROPHILITE:
-						return (LRESULT) infoPtr->dropItem;
+					retval=infoPtr->dropItem;
+					break;
 	}
-	
-  iItem= (INT32) lParam;
+  if (retval) {
+  		TRACE (treeview,"flags:%x, returns %u\n", flag, retval);
+		return retval;
+  }
+ 
   wineItem = TREEVIEW_ValidItem (infoPtr, iItem);
+  returnItem = NULL;
   if (!wineItem) return FALSE;
 
   switch (flag)	{
-	case TVGN_NEXT: 	return (LRESULT) wineItem->sibling;
-	case TVGN_PREVIOUS:	return (LRESULT) wineItem->upsibling;
-	case TVGN_PARENT: 	return (LRESULT) wineItem->parent;
-	case TVGN_CHILD: 	return (LRESULT) wineItem->firstChild;
+	case TVGN_NEXT: retval=wineItem->sibling;
+					break;
+	case TVGN_PREVIOUS:	
+					retval=wineItem->upsibling;
+					break;
+	case TVGN_PARENT:
+					retval=wineItem->parent;
+					break;
+	case TVGN_CHILD:retval=wineItem->firstChild;
+					break;
 	case TVGN_LASTVISIBLE:  
-				wineItem=TREEVIEW_GetLastListItem (infoPtr);
-				break;
+					returnItem=TREEVIEW_GetLastListItem (infoPtr,wineItem);
+					break;
 	case TVGN_NEXTVISIBLE:  
-				wineItem=TREEVIEW_GetNextListItem (infoPtr,wineItem);
-				TRACE (treeview,"(%s)\n",wineItem->pszText);
-				break;
+					returnItem=TREEVIEW_GetNextListItem (infoPtr,wineItem);
+					break;
 	case TVGN_PREVIOUSVISIBLE: 
-				wineItem=TREEVIEW_GetPrevListItem (infoPtr, wineItem);
-				TRACE (treeview,"(%s)\n",wineItem->pszText);
-				break;
-	default:	FIXME (treeview,"Unknown msg %x,item %x\n", flag,iItem);
-				break;
+					returnItem=TREEVIEW_GetPrevListItem (infoPtr, wineItem);
+					break;
+	default:		FIXME (treeview,"Unknown msg %x,item %x\n", flag,iItem);
+					break;
 	}
 
-	if (wineItem) return (LRESULT) wineItem->hItem;
+  if (returnItem) {
+		  TRACE (treeview,"flags:%x, item %d;returns %d\n", flag, iItem,
+							returnItem->hItem);
+		  return returnItem->hItem;
+  }
 
- FIXME (treeview, "returning 0\n");
- return 0;
+  TRACE (treeview,"flags:%x, item %d;returns %d\n", flag, iItem,retval);
+  return retval;
 }
 
 
@@ -831,7 +1025,7 @@
 {
  TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr);
 
- TRACE (treeview,"\n");
+ TRACE (treeview," %d\n",infoPtr->uNumItems);
  return (LRESULT) infoPtr->uNumItems;
 }
 
@@ -841,22 +1035,20 @@
 /* the method used below isn't the most memory-friendly, but it avoids 
    a lot of memory reallocations */ 
 
-/* BTW: we waste handle 0; 0 is not an allowed handle. Fix this by
-        decreasing infoptr->items with 1, and increasing it by 1 if 
-        it is referenced in mm-handling stuff? */
+/* BTW: we waste handle 0; 0 is not an allowed handle. */
+
 
 static LRESULT
 TREEVIEW_InsertItem32A (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
 
 {
   TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr);
-  TVINSERTSTRUCTA  *ptdi;
-  TV_ITEM 	*tvItem;
+  TVINSERTSTRUCT32A  *ptdi;
+  TVITEMEX32A 	*tvItem;
   TREEVIEW_ITEM *wineItem, *parentItem, *prevsib, *sibItem;
   INT32		iItem,listItems,i,len;
   
-  TRACE (treeview,"\n");
-  ptdi = (TVINSERTSTRUCTA *) lParam;
+  ptdi = (LPTVINSERTSTRUCT32A) lParam;
 
 	/* check if memory is available */
 
@@ -872,17 +1064,17 @@
 	INT32 *oldfreeList = infoPtr->freeList;
 
 	infoPtr->uNumPtrsAlloced*=2;
-        infoPtr->items = COMCTL32_Alloc ( infoPtr->uNumPtrsAlloced * sizeof (TREEVIEW_ITEM));
-        infoPtr->freeList= COMCTL32_Alloc ((1+(infoPtr->uNumPtrsAlloced>>5))*sizeof (INT32));
+    infoPtr->items = COMCTL32_Alloc (infoPtr->uNumPtrsAlloced*sizeof (TREEVIEW_ITEM));
+    infoPtr->freeList= COMCTL32_Alloc ((1+(infoPtr->uNumPtrsAlloced>>5))*sizeof (INT32));
 
-        memcpy (&infoPtr->items[0], &oldItems[0],
+    memcpy (&infoPtr->items[0], &oldItems[0],
                     infoPtr->uNumPtrsAlloced/2 * sizeof(TREEVIEW_ITEM));
-        memcpy (&infoPtr->freeList[0], &oldfreeList[0],
+    memcpy (&infoPtr->freeList[0], &oldfreeList[0],
                     infoPtr->uNumPtrsAlloced>>6 * sizeof(INT32));
 
-         COMCTL32_Free (oldItems);  
-         COMCTL32_Free (oldfreeList);  
-    }
+    COMCTL32_Free (oldItems);  
+    COMCTL32_Free (oldfreeList);  
+   }
 
   iItem=0;
   infoPtr->uNumItems++;
@@ -890,23 +1082,25 @@
   if (infoPtr->uMaxHandle==(infoPtr->uNumItems-1))  { 
   	iItem=infoPtr->uNumItems;
   	infoPtr->uMaxHandle++;
-  } 
-  else {					 /* check freelist */
+  } else {					 /* check freelist */
 	for (i=0; i<infoPtr->uNumPtrsAlloced>>5; i++) {
 		if (infoPtr->freeList[i]) {
-			iItem=ffs (infoPtr->freeList[i]);
+			iItem=ffs (infoPtr->freeList[i])-1;
 			tv_clear_bit(iItem,&infoPtr->freeList[i]);
+ 			iItem+=i<<5;
 			break;
 		}
   	 } 
   }
+ 
+ for (i=0; i<infoPtr->uNumPtrsAlloced>>5; i++) 
+	TRACE (treeview,"%8x\n",infoPtr->freeList[i]);
+
   if (!iItem) ERR (treeview, "Argh -- can't find free item.\n");
   
-  tvItem= & ptdi->item;
+  tvItem= & ptdi->DUMMYUNIONNAME.itemex;
   wineItem=& infoPtr->items[iItem];
 
-
-
   if ((ptdi->hParent==TVI_ROOT) || (ptdi->hParent==0)) {
 	parentItem=NULL;
 	wineItem->parent=0; 
@@ -926,38 +1120,51 @@
   wineItem->upsibling=0;  /* needed in case we're the first item in a list */ 
   wineItem->sibling=0;     
   wineItem->firstChild=0;
+  wineItem->hItem=iItem;
 
   if (listItems>1) {
      prevsib=NULL;
      switch (ptdi->hInsertAfter) {
-		case TVI_FIRST: wineItem->sibling=infoPtr->TopRootItem;
-			infoPtr->TopRootItem=iItem;
+		case TVI_FIRST: 
+			if (wineItem->parent) {
+				wineItem->sibling=parentItem->firstChild;
+				parentItem->firstChild=iItem;
+			} else {
+				wineItem->sibling=infoPtr->TopRootItem;
+				infoPtr->TopRootItem=iItem;
+			}
+			sibItem->upsibling=iItem;
 			break;
 		case TVI_LAST:  
+			if (sibItem==wineItem) break;
 			while (sibItem->sibling) {
 				prevsib=sibItem;
 				sibItem=&infoPtr->items [sibItem->sibling];
 			}
 			sibItem->sibling=iItem;
-			if (prevsib!=NULL) 
-				wineItem->upsibling=prevsib->hItem;
-			else
-  				wineItem->sibling=0; 	/* terminate list */
+			wineItem->upsibling=sibItem->hItem;
 			break;
 		case TVI_SORT:  
 			FIXME (treeview, "Sorted insert not implemented yet\n");
 			break;
-		default:	
-			while ((sibItem->sibling) && (sibItem->sibling!=iItem)) {
+		default:
+			while ((sibItem->sibling) && (sibItem->hItem!=ptdi->hInsertAfter))
+				{
 				prevsib=sibItem;
                 sibItem=&infoPtr->items [sibItem->sibling];
-            }
-			if (sibItem->sibling) 
-				WARN (treeview, "Buggy program tried to insert item after nonexisting handle.");
-			sibItem->upsibling=iItem;
-			wineItem->sibling=sibItem->hItem;
-			if (prevsib!=NULL) 
-				wineItem->upsibling=prevsib->hItem;
+              }
+			if (sibItem->hItem!=ptdi->hInsertAfter) {
+			 ERR (treeview, "tried to insert item after nonexisting handle.\n");
+			 break;
+			}
+			prevsib=sibItem;
+			if (sibItem->sibling) {
+            	sibItem=&infoPtr->items [sibItem->sibling];
+				sibItem->upsibling=iItem;
+				wineItem->sibling=sibItem->hItem;
+			}
+			prevsib->sibling=iItem;
+			wineItem->upsibling=prevsib->hItem;
 			break;
    	}
    }	
@@ -965,20 +1172,27 @@
 
 /* Fill in info structure */
 
-   TRACE (treeview,"item %d, mask %x\n",iItem, tvItem->mask);
+   TRACE (treeview,"new item %d; parent %d, mask %x\n", iItem, 
+			wineItem->parent,tvItem->mask);
+
    wineItem->mask=tvItem->mask;
-   wineItem->hItem=iItem;
    wineItem->iIntegral=1; 
 
-   if (tvItem->mask & TVIF_CHILDREN)
+   if (tvItem->mask & TVIF_CHILDREN) {
 	 wineItem->cChildren=tvItem->cChildren;
+	 if (tvItem->cChildren==I_CHILDRENCALLBACK) 
+			FIXME (treeview," I_CHILDRENCALLBACK not supported\n");
+	}
+
 
    if (tvItem->mask & TVIF_IMAGE) 
 	wineItem->iImage=tvItem->iImage;
 
-/*   if (tvItem->mask & TVIF_INTEGRAL) 
-   	wineItem->iIntegral=tvItem->iIntegral;  */
-   
+		/* If the application sets TVIF_INTEGRAL without
+			supplying a TVITEMEX structure, it's toast */
+
+   if (tvItem->mask & TVIF_INTEGRAL) 
+   		wineItem->iIntegral=tvItem->iIntegral;   
 
    if (tvItem->mask & TVIF_PARAM) 
 	wineItem->lParam=tvItem->lParam;
@@ -992,16 +1206,16 @@
    }
 
    if (tvItem->mask & TVIF_TEXT) {
-   	TRACE (treeview,"(%s)\n", tvItem->pszText); 
 	if (tvItem->pszText!=LPSTR_TEXTCALLBACK32A) {
+   		TRACE (treeview,"(%p,%s)\n", &tvItem->pszText, tvItem->pszText); 
 		len = lstrlen32A (tvItem->pszText)+1;
 		wineItem->pszText= COMCTL32_Alloc (len+1);
 		lstrcpy32A (wineItem->pszText, tvItem->pszText);
 		wineItem->cchTextMax=len;
 	}
 	else {
-	    wineItem->pszText = LPSTR_TEXTCALLBACK32A;
 		TRACE (treeview,"LPSTR_TEXTCALLBACK\n");
+	    wineItem->pszText = LPSTR_TEXTCALLBACK32A;
 	    wineItem->cchTextMax = 0;
 	}
    }
@@ -1013,25 +1227,26 @@
 
 
 
+
+
 static LRESULT
 TREEVIEW_DeleteItem (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
 {
   TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr);
   INT32 iItem;
-  POINT32 pt;
   TREEVIEW_ITEM *wineItem;
 
   TRACE (treeview,"\n");
   if (!infoPtr) return FALSE;
 
   if ((INT32) lParam == TVI_ROOT) {
-	TREEVIEW_RemoveTree (infoPtr);
+	TREEVIEW_RemoveTree (wndPtr);
   } else {
   	iItem= (INT32) lParam;
   	wineItem = TREEVIEW_ValidItem (infoPtr, iItem);
   	if (!wineItem) return FALSE;
-	TREEVIEW_SendTreeviewNotify (wndPtr, TVN_DELETEITEM, 0, iItem, 0, pt);
-	TREEVIEW_RemoveItem (infoPtr, wineItem);
+    TRACE (treeview,"%s\n",wineItem->pszText);
+	TREEVIEW_RemoveItem (wndPtr, wineItem);
   }
 
   TREEVIEW_QueueRefresh (wndPtr);
@@ -1040,6 +1255,7 @@
 }
 
 
+
 static LRESULT
 TREEVIEW_GetIndent (WND *wndPtr)
 {
@@ -1089,18 +1305,117 @@
 }
 
 
+LRESULT CALLBACK
+TREEVIEW_GetEditControl (WND *wndPtr)
+
+{
+ TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr);
+
+ return infoPtr->hwndEdit;
+}
+
+LRESULT CALLBACK
+TREEVIEW_Edit_SubclassProc (HWND32 hwnd, UINT32 uMsg, WPARAM32 wParam, 
+							LPARAM lParam)
+{
+  switch (uMsg) {
+   case WM_ERASEBKGND: {
+           RECT32 rc;
+           HDC32  hdc = (HDC32) wParam;
+           GetClientRect32 (hwnd, &rc);
+           Rectangle32 (hdc, rc.left, rc.top, rc.right, rc.bottom);
+           return -1;
+		}
+   case WM_GETDLGCODE:
+            return DLGC_WANTARROWS | DLGC_WANTALLKEYS;
+   default:
+			 return DefWindowProc32A (hwnd, uMsg, wParam, lParam);
+  }
+  return 0;
+}
+
+
+/* should handle edit control messages here */
+
+static LRESULT
+TREEVIEW_Command (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
+
+{
+  TRACE (treeview, "%x %ld\n",wParam, lParam);
+ 
+  switch (HIWORD(wParam)) {
+		case EN_UPDATE:
+			 FIXME (treeview, "got EN_UPDATE.\n");
+			 break;
+		case EN_KILLFOCUS:
+			 FIXME (treeview, "got EN_KILLFOCUS.\n");
+			 break;
+		default:
+			 return SendMessage32A (GetParent32 (wndPtr->hwndSelf), 
+										WM_COMMAND, wParam, lParam);
+	}
+ return 0;
+}
 
 
 
 
 static LRESULT
+TREEVIEW_Size (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
+
+{
+  TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr);
+  RECT32 parent_rect;
+  UINT32  cx,cy;
+  HWND32 parent;
+
+  if (infoPtr->bAutoSize) {
+    infoPtr->bAutoSize = FALSE;
+    return 0;
+    }
+    infoPtr->bAutoSize = TRUE;
+
+    if (!wParam)  {
+    parent = GetParent32 (wndPtr->hwndSelf);
+    GetClientRect32(parent, &parent_rect);
+    cx=LOWORD (lParam);
+  	cy=HIWORD (lParam);
+	SetWindowPos32 (wndPtr->hwndSelf, 0, parent_rect.left, parent_rect.top, 
+			cx, cy, SWP_NOZORDER);
+   } else {
+	FIXME (treeview,"WM_SIZE flag %x %lx not handled\n", wParam, lParam);
+  }
+
+  TREEVIEW_QueueRefresh (wndPtr);
+  return 0;
+}
+
+
+
+static LRESULT
+TREEVIEW_StyleChanged (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
+{
+  LPSTYLESTRUCT lpss=(LPSTYLESTRUCT) lParam;
+
+  TRACE (treeview,"(%x %lx)\n",wParam,lParam);
+  
+  if (wParam & (GWL_STYLE)) 
+	wndPtr->dwStyle=lpss->styleNew;
+  if (wParam & (GWL_EXSTYLE)) 
+	wndPtr->dwExStyle=lpss->styleNew;
+
+  return 0;
+}
+
+static LRESULT
 TREEVIEW_Create (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
 {
     TREEVIEW_INFO *infoPtr;
-	HDC32 hdc;
+ 	LOGFONT32A logFont;
     TEXTMETRIC32A tm;
+	HDC32 hdc;
   
-    TRACE (treeview,"\n");
+    TRACE (treeview,"wnd %x\n",wndPtr->hwndSelf);
       /* allocate memory for info structure */
       infoPtr = (TREEVIEW_INFO *) COMCTL32_Alloc (sizeof(TREEVIEW_INFO));
 
@@ -1131,8 +1446,10 @@
 	infoPtr->uItemHeight = -1;
     GetTextMetrics32A (hdc, &tm);
     infoPtr->hFont = GetStockObject32 (DEFAULT_GUI_FONT);
-    infoPtr->uRealItemHeight= tm.tmHeight + tm.tmExternalLeading;
-
+	GetObject32A (infoPtr->hFont, sizeof (LOGFONT32A), &logFont);
+	logFont.lfWeight=FW_BOLD;
+    infoPtr->hBoldFont = CreateFontIndirect32A (&logFont);
+    
     infoPtr->items = NULL;
     infoPtr->selectedItem=0;
     infoPtr->clrText=-1;	/* use system color */
@@ -1175,8 +1492,20 @@
         SetRectEmpty32 (&ti.rect);
 
         SendMessage32A (infoPtr->hwndToolTip, TTM_ADDTOOL32A, 0, (LPARAM)&ti);
-
     }
+
+
+ 	infoPtr->hwndEdit = CreateWindowEx32A ( 0, "EDIT",NULL,
+                 WS_CHILD | WS_BORDER | ES_AUTOHSCROLL | ES_WANTRETURN,
+                 0, 0, 0, 0,
+                 wndPtr->hwndSelf, 0,0,0);
+				/* FIXME:   (HMENU)IDTVEDIT, pcs->hInstance, 0); */
+
+    SendMessage32A ( infoPtr->hwndEdit, WM_SETFONT, infoPtr->hFont, FALSE);
+	infoPtr->wpEditOrig= (WNDPROC32)
+                    SetWindowLong32A (infoPtr->hwndEdit,GWL_WNDPROC, 
+					(LONG) TREEVIEW_Edit_SubclassProc);
+
     ReleaseDC32 (wndPtr->hwndSelf, hdc);
 
     return 0;
@@ -1190,7 +1519,7 @@
    TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr);
      
    TRACE (treeview,"\n");
-   TREEVIEW_RemoveTree (infoPtr);
+   TREEVIEW_RemoveTree (wndPtr);
    if (infoPtr->Timer & TV_REFRESH_TIMER_SET) 
         KillTimer32 (wndPtr->hwndSelf, TV_REFRESH_TIMER);
    if (infoPtr->hwndToolTip) 
@@ -1202,20 +1531,36 @@
 
 
 static LRESULT
-TREEVIEW_Paint (WND *wndPtr, WPARAM32 wParam)
+TREEVIEW_Paint (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
 {
     HDC32 hdc;
     PAINTSTRUCT32 ps;
 
     TRACE (treeview,"\n");
     hdc = wParam==0 ? BeginPaint32 (wndPtr->hwndSelf, &ps) : (HDC32)wParam;
-    TREEVIEW_QueueRefresh (wndPtr);
+    TREEVIEW_Refresh (wndPtr);
     if(!wParam)
         EndPaint32 (wndPtr->hwndSelf, &ps);
-    return 0;
+    TRACE (treeview,"done\n");
+      
+    return DefWindowProc32A (wndPtr->hwndSelf, WM_PAINT, wParam, lParam);
 }
 
+static LRESULT
+TREEVIEW_SetFocus (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
+{
+   TREEVIEW_SendSimpleNotify (wndPtr, NM_SETFOCUS);
+   SendMessage32A (wndPtr->hwndSelf, WM_PAINT, 0, 0);
+   return 0;
+}
 
+static LRESULT
+TREEVIEW_KillFocus (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
+{
+   TREEVIEW_SendSimpleNotify (wndPtr, NM_KILLFOCUS);
+   SendMessage32A (wndPtr->hwndSelf, WM_PAINT, 0, 0);
+   return 0;
+}
 
 static LRESULT
 TREEVIEW_EraseBackground (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
@@ -1236,6 +1581,9 @@
 
 
   
+/* Notifications */
+
+  
 
 
 
@@ -1255,13 +1603,13 @@
 
 
 
-
 static BOOL32
 TREEVIEW_SendTreeviewNotify (WND *wndPtr, UINT32 code, UINT32 action, 
-			INT32 oldItem, INT32 newItem, POINT32 pt)
+			INT32 oldItem, INT32 newItem)
+
 {
   TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr);
-  NM_TREEVIEW nmhdr;
+  NMTREEVIEW32A nmhdr;
   TREEVIEW_ITEM  *wineItem;
 
   TRACE (treeview,"code:%x action:%x olditem:%x newitem:%x\n",
@@ -1276,13 +1624,13 @@
   	nmhdr.itemOld.hItem		= wineItem->hItem;
   	nmhdr.itemOld.state		= wineItem->state;
   	nmhdr.itemOld.stateMask	= wineItem->stateMask;
-  	nmhdr.itemOld.iImage 		= wineItem->iImage;
+  	nmhdr.itemOld.iImage 	= wineItem->iImage;
   	nmhdr.itemOld.pszText 	= wineItem->pszText;
-  	nmhdr.itemOld.cchTextMax 	= wineItem->cchTextMax;
-  	nmhdr.itemOld.iImage 		= wineItem->iImage;
+  	nmhdr.itemOld.cchTextMax= wineItem->cchTextMax;
+  	nmhdr.itemOld.iImage 	= wineItem->iImage;
   	nmhdr.itemOld.iSelectedImage 	= wineItem->iSelectedImage;
-  	nmhdr.itemOld.cChildren 	= wineItem->cChildren;
-  	nmhdr.itemOld.lParam		= wineItem->lParam;
+  	nmhdr.itemOld.cChildren = wineItem->cChildren;
+  	nmhdr.itemOld.lParam	= wineItem->lParam;
   }
 
   if (newItem) {
@@ -1291,15 +1639,43 @@
   	nmhdr.itemNew.hItem		= wineItem->hItem;
   	nmhdr.itemNew.state		= wineItem->state;
   	nmhdr.itemNew.stateMask	= wineItem->stateMask;
-  	nmhdr.itemNew.iImage 		= wineItem->iImage;
+  	nmhdr.itemNew.iImage 	= wineItem->iImage;
   	nmhdr.itemNew.pszText 	= wineItem->pszText;
-  	nmhdr.itemNew.cchTextMax 	= wineItem->cchTextMax;
-  	nmhdr.itemNew.iImage 		= wineItem->iImage;
+  	nmhdr.itemNew.cchTextMax= wineItem->cchTextMax;
+  	nmhdr.itemNew.iImage 	= wineItem->iImage;
   	nmhdr.itemNew.iSelectedImage 	= wineItem->iSelectedImage;
-  	nmhdr.itemNew.cChildren 	= wineItem->cChildren;
-  	nmhdr.itemNew.lParam		= wineItem->lParam;
+  	nmhdr.itemNew.cChildren = wineItem->cChildren;
+  	nmhdr.itemNew.lParam	= wineItem->lParam;
   }
 
+  nmhdr.ptDrag.x = 0;
+  nmhdr.ptDrag.y = 0;
+
+  return (BOOL32)SendMessage32A (GetParent32 (wndPtr->hwndSelf), WM_NOTIFY,
+                                   (WPARAM32)wndPtr->wIDmenu, (LPARAM)&nmhdr);
+
+}
+
+static BOOL32
+TREEVIEW_SendTreeviewDnDNotify (WND *wndPtr, UINT32 code, INT32 dragItem, 
+								POINT32 pt)
+{
+  TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr);
+  NMTREEVIEW32A nmhdr;
+  TREEVIEW_ITEM  *wineItem;
+
+  TRACE (treeview,"code:%x dragitem:%x\n", code,dragItem);
+
+  nmhdr.hdr.hwndFrom = wndPtr->hwndSelf;
+  nmhdr.hdr.idFrom = wndPtr->wIDmenu;
+  nmhdr.hdr.code = code;
+  nmhdr.action = 0;
+  wineItem=& infoPtr->items[dragItem];
+  nmhdr.itemNew.mask 	= wineItem->mask;
+  nmhdr.itemNew.hItem	= wineItem->hItem;
+  nmhdr.itemNew.state	= wineItem->state;
+  nmhdr.itemNew.lParam	= wineItem->lParam;
+
   nmhdr.ptDrag.x = pt.x;
   nmhdr.ptDrag.y = pt.y;
 
@@ -1310,23 +1686,156 @@
 
 
 
+static BOOL32
+TREEVIEW_SendDispInfoNotify (WND *wndPtr, TREEVIEW_ITEM *wineItem, 
+								UINT32 code, UINT32 what)
+{
+  NMTVDISPINFO32A tvdi;
+  BOOL32 retval;
+  char *buf;
+
+  TRACE (treeview,"item %d, action %x\n",wineItem->hItem,what);
+
+  tvdi.hdr.hwndFrom	= wndPtr->hwndSelf;
+  tvdi.hdr.idFrom	= wndPtr->wIDmenu;
+  tvdi.hdr.code		= code;
+  tvdi.item.mask	= what;
+  tvdi.item.hItem	= wineItem->hItem;
+  tvdi.item.state	= wineItem->state;
+  tvdi.item.lParam	= wineItem->lParam;
+  tvdi.item.pszText = COMCTL32_Alloc (128*sizeof(char));
+  buf = tvdi.item.pszText;
+  retval=(BOOL32)SendMessage32A (GetParent32 (wndPtr->hwndSelf), WM_NOTIFY,
+                                   (WPARAM32)wndPtr->wIDmenu, (LPARAM)&tvdi);
+  if (what & TVIF_TEXT) {
+		wineItem->pszText        = tvdi.item.pszText;
+		if (buf==tvdi.item.pszText) {
+			wineItem->cchTextMax = 128;
+		} else { 
+			TRACE (treeview,"user-supplied buffer\n");
+			COMCTL32_Free (buf);
+			wineItem->cchTextMax = 0;
+		}
+	}
+  if (what & TVIF_SELECTEDIMAGE) 
+		wineItem->iSelectedImage = tvdi.item.iSelectedImage;
+  if (what & TVIF_IMAGE) 
+		wineItem->iImage         = tvdi.item.iImage;
+  if (what & TVIF_CHILDREN) 
+		wineItem->cChildren      = tvdi.item.cChildren;
+
+ return retval;
+}
+
+
+
+static BOOL32
+TREEVIEW_SendCustomDrawNotify (WND *wndPtr, DWORD dwDrawStage, HDC32 hdc,
+			RECT32 rc)
+{
+  TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr);
+  NMTVCUSTOMDRAW nmcdhdr;
+  LPNMCUSTOMDRAW nmcd;
+
+  TRACE (treeview,"drawstage:%lx hdc:%x\n", dwDrawStage, hdc);
+
+  nmcd= & nmcdhdr.nmcd;
+  nmcd->hdr.hwndFrom = wndPtr->hwndSelf;
+  nmcd->hdr.idFrom = wndPtr->wIDmenu;
+  nmcd->hdr.code   = NM_CUSTOMDRAW;
+  nmcd->dwDrawStage= dwDrawStage;
+  nmcd->hdc		   = hdc;
+  nmcd->rc.left    = rc.left;
+  nmcd->rc.right   = rc.right;
+  nmcd->rc.bottom  = rc.bottom;
+  nmcd->rc.top     = rc.top;
+  nmcd->dwItemSpec = 0;
+  nmcd->uItemState = 0;
+  nmcd->lItemlParam= 0;
+  nmcdhdr.clrText  = infoPtr->clrText;
+  nmcdhdr.clrTextBk= infoPtr->clrBk;
+  nmcdhdr.iLevel   = 0;
+
+  return (BOOL32)SendMessage32A (GetParent32 (wndPtr->hwndSelf), WM_NOTIFY,
+                               (WPARAM32)wndPtr->wIDmenu, (LPARAM)&nmcdhdr);
+
+}
+
+
+
+/* FIXME: need to find out when the flags in uItemState need to be set */
+
+static BOOL32
+TREEVIEW_SendCustomDrawItemNotify (WND *wndPtr, HDC32 hdc,
+  			TREEVIEW_ITEM *wineItem, UINT32 uItemDrawState)
+{
+ TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr);
+ NMTVCUSTOMDRAW nmcdhdr;
+ LPNMCUSTOMDRAW nmcd;
+ DWORD dwDrawStage,dwItemSpec;
+ UINT32 uItemState;
+ 
+ dwDrawStage=CDDS_ITEM | uItemDrawState;
+ dwItemSpec=wineItem->hItem;
+ uItemState=0;
+ if (wineItem->hItem==infoPtr->selectedItem) uItemState|=CDIS_SELECTED;
+ if (wineItem->hItem==infoPtr->focusItem)	 uItemState|=CDIS_FOCUS;
+ if (wineItem->hItem==infoPtr->hotItem)      uItemState|=CDIS_HOT;
+
+ nmcd= & nmcdhdr.nmcd;
+ nmcd->hdr.hwndFrom = wndPtr->hwndSelf;
+ nmcd->hdr.idFrom = wndPtr->wIDmenu;
+ nmcd->hdr.code   = NM_CUSTOMDRAW;
+ nmcd->dwDrawStage= dwDrawStage;
+ nmcd->hdc		  = hdc;
+ nmcd->rc.left    = wineItem->rect.left;
+ nmcd->rc.right   = wineItem->rect.right;
+ nmcd->rc.bottom  = wineItem->rect.bottom;
+ nmcd->rc.top     = wineItem->rect.top;
+ nmcd->dwItemSpec = dwItemSpec;
+ nmcd->uItemState = uItemState;
+ nmcd->lItemlParam= wineItem->lParam;
+
+ nmcdhdr.clrText  = infoPtr->clrText;
+ nmcdhdr.clrTextBk= infoPtr->clrBk;
+ nmcdhdr.iLevel   = wineItem->iLevel;
+
+ TRACE (treeview,"drawstage:%lx hdc:%x item:%lx, itemstate:%x\n",
+		  dwDrawStage, hdc, dwItemSpec, uItemState);
+
+ return (BOOL32)SendMessage32A (GetParent32 (wndPtr->hwndSelf), WM_NOTIFY,
+                               (WPARAM32)wndPtr->wIDmenu, (LPARAM)&nmcdhdr);
+}
+
+
+
+/* Note:If the specified item is the child of a collapsed parent item,
+   the parent's list of child items is (recursively) expanded to reveal the 
+   specified item. This is mentioned for TREEVIEW_SelectItem; don't 
+   know if it also applies here.
+*/
+
 
 static LRESULT
 TREEVIEW_Expand (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
 {
  TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr);
- TREEVIEW_ITEM *wineItem;
+ TREEVIEW_ITEM *wineItem, *parentItem;
  UINT32 flag;
- INT32 expandItem;
- POINT32 pt;
+ INT32 expand;
  
  flag= (UINT32) wParam;
- expandItem= (INT32) lParam;
- TRACE (treeview,"flags:%x item:%x\n", expandItem, wParam);
- wineItem = TREEVIEW_ValidItem (infoPtr, expandItem);
+ expand= (INT32) lParam;
+ TRACE (treeview,"flags:%x item:%x\n", expand, wParam);
+ wineItem = TREEVIEW_ValidItem (infoPtr, expand);
  if (!wineItem) return 0;
  if (!wineItem->cChildren) return 0;
 
+ if (wineItem->cChildren==I_CHILDRENCALLBACK) {
+		FIXME (treeview,"we don't handle I_CHILDRENCALLBACK yet\n");
+		return 0;
+ }
+
  if (flag & TVE_TOGGLE) {		/* FIXME: check exact behaviour here */
 	flag &= ~TVE_TOGGLE;		/* ie: bitwise ops or 'case' ops */
 	if (wineItem->state & TVIS_EXPANDED) 
@@ -1339,7 +1848,7 @@
     case TVE_COLLAPSERESET: 
    		if (!wineItem->state & TVIS_EXPANDED) return 0;
 		wineItem->state &= ~(TVIS_EXPANDEDONCE | TVIS_EXPANDED);
-		TREEVIEW_RemoveAllChildren (infoPtr, wineItem);
+		TREEVIEW_RemoveAllChildren (wndPtr, wineItem);
 		break;
 
     case TVE_COLLAPSE: 
@@ -1349,14 +1858,18 @@
 
     case TVE_EXPAND: 
 		if (wineItem->state & TVIS_EXPANDED) return 0;
+		if (wineItem->parent) {
+				parentItem=TREEVIEW_ValidItem(infoPtr,wineItem->parent);
+				TREEVIEW_Expand (wndPtr, wParam, (LPARAM) wineItem->parent);
+		}
 		if (!(wineItem->state & TVIS_EXPANDEDONCE)) {
     		if (TREEVIEW_SendTreeviewNotify (wndPtr, TVN_ITEMEXPANDING, 
-											0, 0, expandItem, pt))
+											0, 0, expand))
 					return FALSE; 	/* FIXME: OK? */
-		wineItem->state |= TVIS_EXPANDED | TVIS_EXPANDEDONCE;
-    	TREEVIEW_SendTreeviewNotify (wndPtr, TVN_ITEMEXPANDED, 
-											0, 0, expandItem, pt);
- 	}
+            wineItem->state |= TVIS_EXPANDED | TVIS_EXPANDEDONCE;
+    		TREEVIEW_SendTreeviewNotify (wndPtr, TVN_ITEMEXPANDED, 
+                                         0, 0, expand);
+        }
 	wineItem->state |= TVIS_EXPANDED;
 	break;
    case TVE_EXPANDPARTIAL:
@@ -1373,63 +1886,71 @@
 
 
 
-static HTREEITEM
-TREEVIEW_HitTest (WND *wndPtr, LPTVHITTESTINFO lpht)
+
+
+static TREEVIEW_ITEM *
+TREEVIEW_HitTest (WND *wndPtr, POINT32 pt)
 {
  TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr);
  TREEVIEW_ITEM *wineItem;
  RECT32 rect;
- UINT32 status,x,y;
- 
-
 
  GetClientRect32 (wndPtr->hwndSelf, &rect);
- TRACE (treeview,"(%d,%d)\n",lpht->pt.x, lpht->pt.y);
 
- status=0;
- x=lpht->pt.x;
- y=lpht->pt.y;
- if (x < rect.left)  status|=TVHT_TOLEFT;
- if (x > rect.right) status|=TVHT_TORIGHT;
- if (y < rect.top )  status|=TVHT_ABOVE;
- if (y > rect.bottom) status|=TVHT_BELOW;
- if (status) {
-	lpht->flags=status;
-	return 0;
- }
+ if (!infoPtr->firstVisible) return NULL;
 
- if (!infoPtr->firstVisible) WARN (treeview,"Can't fetch first visible item");
  wineItem=&infoPtr->items [infoPtr->firstVisible];
 
- while ((wineItem!=NULL) && (y > wineItem->rect.bottom))
+ while ((wineItem!=NULL) && (pt.y > wineItem->rect.bottom))
        wineItem=TREEVIEW_GetNextListItem (infoPtr,wineItem);
 	
- if (wineItem==NULL) {
-	lpht->flags=TVHT_NOWHERE;
+ if (!wineItem) 
+	return NULL;
+
+ return wineItem;
+}
+
+
+
+
+static LRESULT
+TREEVIEW_HitTest32 (WND *wndPtr, LPARAM lParam)
+{
+  LPTVHITTESTINFO lpht=(LPTVHITTESTINFO) lParam;
+  TREEVIEW_ITEM *wineItem;
+  RECT32 rect;
+  UINT32 status,x,y;
+
+  GetClientRect32 (wndPtr->hwndSelf, &rect);
+  status=0;
+  x=lpht->pt.x;
+  y=lpht->pt.y;
+  if (x < rect.left)  status|=TVHT_TOLEFT;
+  if (x > rect.right) status|=TVHT_TORIGHT;
+  if (y < rect.top )  status|=TVHT_ABOVE;
+  if (y > rect.bottom) status|=TVHT_BELOW;
+  if (status) {
+	lpht->flags=status;
 	return 0;
- }
+  }
+
+  wineItem=TREEVIEW_HitTest (wndPtr, lpht->pt);
+  if (!wineItem) {	
+		lpht->flags=TVHT_NOWHERE;
+		return 0;
+  }
 
  if (x>wineItem->rect.right) {
 	lpht->flags|=TVHT_ONITEMRIGHT;
 	return wineItem->hItem;
  }
  
-	
  if (x<wineItem->rect.left+10) lpht->flags|=TVHT_ONITEMBUTTON;
 
  lpht->flags=TVHT_ONITEMLABEL;    /* FIXME: implement other flags */
-	
-
  lpht->hItem=wineItem->hItem;
- return wineItem->hItem;
-}
 
-
-static LRESULT
-TREEVIEW_HitTest32 (WND *wndPtr, LPARAM lParam)
-{
- 
-  return (LRESULT) TREEVIEW_HitTest (wndPtr, (LPTVHITTESTINFO) lParam);
+ return (LRESULT) wineItem->hItem;
 }
 
 
@@ -1438,24 +1959,21 @@
 LRESULT
 TREEVIEW_LButtonDoubleClick (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
 {
-  TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr);
   TREEVIEW_ITEM *wineItem;
-  INT32 iItem;
-  TVHITTESTINFO ht;
+  POINT32 pt;
 
   TRACE (treeview,"\n");
-  ht.pt.x = (INT32)LOWORD(lParam);
-  ht.pt.y = (INT32)HIWORD(lParam);
+  pt.x = (INT32)LOWORD(lParam);
+  pt.y = (INT32)HIWORD(lParam);
   SetFocus32 (wndPtr->hwndSelf);
 
-  iItem=TREEVIEW_HitTest (wndPtr, &ht);
-  TRACE (treeview,"item %d \n",iItem);
-  wineItem=TREEVIEW_ValidItem (infoPtr, iItem);
+  wineItem=TREEVIEW_HitTest (wndPtr, pt);
   if (!wineItem) return 0;
+  TRACE (treeview,"item %d \n",wineItem->hItem);
  
   if (TREEVIEW_SendSimpleNotify (wndPtr, NM_DBLCLK)!=TRUE) {     /* FIXME!*/
 	wineItem->state &= ~TVIS_EXPANDEDONCE;
-	TREEVIEW_Expand (wndPtr, (WPARAM32) TVE_TOGGLE, (LPARAM) iItem);
+	TREEVIEW_Expand (wndPtr, (WPARAM32) TVE_TOGGLE, (LPARAM) wineItem->hItem);
  }
  return TRUE;
 }
@@ -1465,79 +1983,234 @@
 static LRESULT
 TREEVIEW_LButtonDown (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
 {
+  TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr);
   INT32 iItem;
   TVHITTESTINFO ht;
 
-  TRACE (treeview,"\n");
   ht.pt.x = (INT32)LOWORD(lParam);
   ht.pt.y = (INT32)HIWORD(lParam);
 
   SetFocus32 (wndPtr->hwndSelf);
-  iItem=TREEVIEW_HitTest (wndPtr, &ht);
+  iItem=TREEVIEW_HitTest32 (wndPtr, (LPARAM) &ht);
   TRACE (treeview,"item %d \n",iItem);
   if (ht.flags & TVHT_ONITEMBUTTON) {
 	TREEVIEW_Expand (wndPtr, (WPARAM32) TVE_TOGGLE, (LPARAM) iItem);
   }
+
+  infoPtr->uInternalStatus|=TV_LDRAG;
 	
-  if (TREEVIEW_SelectItem (wndPtr, (WPARAM32) TVGN_CARET, (LPARAM) iItem))
+  if (TREEVIEW_DoSelectItem (wndPtr, TVGN_CARET, iItem, TVC_BYMOUSE))
 	 return 0;
 
   
  return 0;
 }
 
+static LRESULT
+TREEVIEW_LButtonUp (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
+{
+ TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr);
+ TREEVIEW_ITEM *editItem;
+ INT32 ret;
+ POINT32 pt;
+
+ pt.x = (INT32)LOWORD(lParam);
+ pt.y = (INT32)HIWORD(lParam);
+
+ TRACE (treeview,"\n");
+ if (TREEVIEW_SendSimpleNotify (wndPtr, NM_CLICK)) return 0;
+ editItem=TREEVIEW_HitTest (wndPtr, pt);    
+ if (!editItem) return 0;
+
+ infoPtr->uInternalStatus &= ~(TV_LDRAG | TV_LDRAGGING);
+
+ if (wndPtr->dwStyle & TVS_EDITLABELS) {
+		RECT32 *r;
+		ret=TREEVIEW_SendDispInfoNotify (wndPtr, editItem, 
+											TVN_BEGINLABELEDIT, 0);
+		if (ret) return 0;
+		printf ("edit started..\n");
+		r=& editItem->rect;
+		infoPtr->editItem=editItem->hItem;
+		SetWindowPos32 ( infoPtr->hwndEdit, HWND_TOP, r->left, r->top,
+                           r->right - r->left + 5,
+                           r->bottom - r->top + 2,
+                           SWP_SHOWWINDOW );
+		SetFocus32 (infoPtr->hwndEdit);
+		SetWindowText32A ( infoPtr->hwndEdit, editItem->pszText );
+        SendMessage32A ( infoPtr->hwndEdit, EM_SETSEL32, 0, -1 );
+	}
+
+
+ 
+ return 0;
+}
+
 
 static LRESULT
 TREEVIEW_RButtonDown (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
 {
+ TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr);
 
  TRACE (treeview,"\n");
+ infoPtr->uInternalStatus|=TV_RDRAG;
+ return 0;
+}
+
+static LRESULT
+TREEVIEW_RButtonUp (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
+{
+ TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr);
+
+ TRACE (treeview,"\n");
+ if (TREEVIEW_SendSimpleNotify (wndPtr, NM_RCLICK)) return 0;
+ infoPtr->uInternalStatus&= ~(TV_RDRAG | TV_RDRAGGING);
  return 0;
 }
 
 
-
-
-/* FIXME: If the specified item is the child of a collapsed parent item,
-expand parent's list of child items to reveal the specified item.
-*/
-
 static LRESULT
-TREEVIEW_SelectItem (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
+TREEVIEW_MouseMove (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
 {
  TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr);
- TREEVIEW_ITEM *prevItem,*wineItem;
- INT32 action,prevSelect, newSelect;
- POINT32 dummy;
+ TREEVIEW_ITEM *hotItem;
+ POINT32 pt;
 
-  TRACE (treeview,"item %lx, flag %x\n", lParam, wParam);
-  newSelect= (INT32) lParam;
+ pt.x=(INT32) LOWORD (lParam);
+ pt.y=(INT32) HIWORD (lParam);
+ hotItem=TREEVIEW_HitTest (wndPtr, pt);
+ if (!hotItem) return 0;
+ infoPtr->focusItem=hotItem->hItem;
+
+ if (wndPtr->dwStyle & TVS_DISABLEDRAGDROP) return 0;
+
+ if (infoPtr->uInternalStatus & TV_LDRAG) {
+	TREEVIEW_SendTreeviewDnDNotify (wndPtr, TVN_BEGINDRAG, hotItem->hItem, pt);
+	infoPtr->uInternalStatus &= ~TV_LDRAG;
+	infoPtr->uInternalStatus |= TV_LDRAGGING;
+	infoPtr->dropItem=hotItem->hItem;
+	return 0;
+ }
+
+ if (infoPtr->uInternalStatus & TV_RDRAG) {
+	TREEVIEW_SendTreeviewDnDNotify (wndPtr, TVN_BEGINRDRAG, hotItem->hItem, pt);
+	infoPtr->uInternalStatus &= ~TV_RDRAG;
+	infoPtr->uInternalStatus |= TV_RDRAGGING;
+	infoPtr->dropItem=hotItem->hItem;
+	return 0;
+ }
+ 
+ return 0;
+}
+
+
+static LRESULT
+TREEVIEW_CreateDragImage (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
+{
+ TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr);
+ TREEVIEW_ITEM *dragItem;
+ INT32 cx,cy;
+ HDC32    hdc,htopdc;
+ HWND32 hwtop;
+ HBITMAP32 hbmp,hOldbmp;
+ SIZE32  size;
+ RECT32  rc;
+ HFONT32 hOldFont;
+ char    *itemtxt;
+ 
+ TRACE (treeview,"\n");
+ if (!(infoPtr->himlNormal))  return 0;
+ dragItem=TREEVIEW_ValidItem (infoPtr, (UINT32) lParam);
+ 
+ if (!dragItem) return 0;
+ itemtxt=dragItem->pszText;
+
+ hwtop=GetDesktopWindow32 ();
+ htopdc= GetDC32 (hwtop);
+ hdc=CreateCompatibleDC32 (htopdc); 
+ 
+ hOldFont=SelectObject32 (hdc, infoPtr->hFont);
+ GetTextExtentPoint32 (hdc, itemtxt, lstrlen32A (itemtxt), &size);
+ TRACE (treeview,"%d %d %s %d\n",size.cx,size.cy,itemtxt,lstrlen32A(itemtxt));
+ hbmp=CreateCompatibleBitmap32 (htopdc, size.cx, size.cy);
+ hOldbmp=SelectObject32 (hdc, hbmp);
+
+ ImageList_GetIconSize (infoPtr->himlNormal, &cx, &cy);
+ size.cx+=cx;
+ if (cy>size.cy) size.cy=cy;
+
+ infoPtr->dragList=ImageList_Create (size.cx, size.cy, ILC_COLOR, 10, 10);
+ ImageList_Draw (infoPtr->himlNormal, dragItem->iImage, hdc, 0, 0, ILD_NORMAL);
+
+/*
+ ImageList_GetImageInfo (infoPtr->himlNormal, dragItem->hItem, &iminfo);
+ ImageList_AddMasked (infoPtr->dragList, iminfo.hbmImage, CLR_DEFAULT);
+*/
+
+/* draw item text */
+
+ SetRect32 (&rc, cx, 0, size.cx,size.cy);
+ DrawText32A (hdc, itemtxt, lstrlen32A (itemtxt), &rc, DT_LEFT);
+ SelectObject32 (hdc, hOldFont);
+ SelectObject32 (hdc, hOldbmp);
+
+ ImageList_Add (infoPtr->dragList, hbmp, 0);
+
+ DeleteDC32 (hdc);
+ DeleteObject32 (hbmp);
+ ReleaseDC32 (hwtop, htopdc);
+
+ return (LRESULT)infoPtr->dragList;
+}
+
+
+
+/* FIXME: handle NM_KILLFocus enzo */
+
+static LRESULT
+TREEVIEW_DoSelectItem (WND *wndPtr, INT32 action, INT32 newSelect, INT32 cause)
+
+{
+ TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr);
+ TREEVIEW_ITEM *prevItem,*wineItem, *parentItem;
+ INT32 prevSelect;
+
+  TRACE (treeview,"item %x, flag %x, cause %x\n", newSelect, action, cause);
   wineItem = TREEVIEW_ValidItem (infoPtr, newSelect);
-  if (!wineItem) return FALSE;
-  prevSelect=infoPtr->selectedItem;
-  prevItem= TREEVIEW_ValidItem (infoPtr, prevSelect);
-  dummy.x=0;
-  dummy.y=0;
 
-  action= (INT32) wParam;
+  if (wineItem) {
+	if (wineItem->parent) {
+  	parentItem=TREEVIEW_ValidItem (infoPtr, wineItem->parent);
+	if (!(parentItem->state & TVIS_EXPANDED)) 
+		TREEVIEW_Expand (wndPtr, TVE_EXPAND, (LPARAM) wineItem->parent);
+  	}
+  }
 
   switch (action) {
 	case TVGN_CARET: 
-	    if (TREEVIEW_SendTreeviewNotify (wndPtr, TVN_SELCHANGING, TVC_BYMOUSE, 
-										prevSelect, newSelect,dummy)) 
+  		prevSelect=infoPtr->selectedItem;
+		if (prevSelect==newSelect) return FALSE;
+  		prevItem= TREEVIEW_ValidItem (infoPtr, prevSelect);
+		if (newSelect) 
+	    	if (TREEVIEW_SendTreeviewNotify (wndPtr, TVN_SELCHANGING, 
+							cause, prevSelect, newSelect)) 
 			return FALSE;       /* FIXME: OK? */
 		
 	    if (prevItem) prevItem->state &= ~TVIS_SELECTED;
   		infoPtr->selectedItem=newSelect;
-		wineItem->state |=TVIS_SELECTED;
-		TREEVIEW_SendTreeviewNotify (wndPtr, TVN_SELCHANGED, 
-				TVC_BYMOUSE, prevSelect, newSelect, dummy);
+		if (wineItem) wineItem->state |=TVIS_SELECTED;
+		if (newSelect)
+			TREEVIEW_SendTreeviewNotify (wndPtr, TVN_SELCHANGED, 
+				cause, prevSelect, newSelect);
 		break;
 	case TVGN_DROPHILITE: 
-		FIXME (treeview, "DROPHILITE not implemented");
+  		prevItem= TREEVIEW_ValidItem (infoPtr, infoPtr->dropItem);
+		if (prevItem) prevItem->state &= ~TVIS_DROPHILITED;
+		infoPtr->dropItem=newSelect;
+		if (wineItem) wineItem->state |=TVIS_DROPHILITED;
 		break;
 	case TVGN_FIRSTVISIBLE:
-		FIXME (treeview, "FIRSTVISIBLE not implemented");
+		FIXME (treeview, "FIRSTVISIBLE not implemented\n");
 		break;
  }
  
@@ -1547,6 +2220,14 @@
 }
 
 
+static LRESULT
+TREEVIEW_SelectItem (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
+
+{
+ return TREEVIEW_DoSelectItem (wndPtr, wParam, (HTREEITEM) lParam, TVC_UNKNOWN);
+}
+
+
 
    
 static LRESULT
@@ -1565,7 +2246,9 @@
 {
  TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr);
  TEXTMETRIC32A tm;
+ LOGFONT32A logFont;
  HFONT32 hFont, hOldFont;
+ INT32 height;
  HDC32 hdc;
 
  TRACE (treeview,"%x %lx\n",wParam, lParam);
@@ -1574,10 +2257,16 @@
 
  hFont = infoPtr->hFont ? infoPtr->hFont : GetStockObject32 (SYSTEM_FONT);
 
+ GetObject32A (infoPtr->hFont, sizeof (LOGFONT32A), &logFont);
+ logFont.lfWeight=FW_BOLD;
+ infoPtr->hBoldFont = CreateFontIndirect32A (&logFont);
+
  hdc = GetDC32 (0);
  hOldFont = SelectObject32 (hdc, hFont);
  GetTextMetrics32A (hdc, &tm);
- infoPtr->uRealItemHeight= tm.tmHeight + tm.tmExternalLeading;
+ height= tm.tmHeight + tm.tmExternalLeading;
+ if (height>infoPtr->uRealItemHeight) 
+ 	infoPtr->uRealItemHeight=height;
  SelectObject32 (hdc, hOldFont);
  ReleaseDC32 (0, hdc);
 
@@ -1589,7 +2278,7 @@
 
 
 /* FIXME: does KEYDOWN also send notifications?? If so, use 
-   TREEVIEW_SelectItem.
+   TREEVIEW_DoSelectItem.
 */
 
 
@@ -1622,7 +2311,8 @@
 		newItem=& infoPtr->items[infoPtr->TopRootItem];
 		break;
 	case VK_END:
-		newItem=TREEVIEW_GetLastListItem (infoPtr);
+		newItem=& infoPtr->items[infoPtr->TopRootItem];
+		newItem=TREEVIEW_GetLastListItem (infoPtr, newItem);
 		break;
 	case VK_PRIOR:
 	case VK_NEXT:
@@ -1696,10 +2386,44 @@
 TREEVIEW_HScroll (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) 
 {
   TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr);
+  int maxWidth;
 
   TRACE (treeview,"wp %lx, lp %x\n", lParam, wParam);
 	
   if (!infoPtr->uInternalStatus & TV_HSCROLL) return FALSE;
+
+  switch (LOWORD (wParam)) {
+	case SB_LINEUP: 
+			if (!infoPtr->cx) return FALSE;
+			infoPtr->cx -= infoPtr->uRealItemHeight;
+			if (infoPtr->cx < 0) infoPtr->cx=0;
+			break;
+	case SB_LINEDOWN: 
+			maxWidth=infoPtr->uTotalWidth-infoPtr->uVisibleWidth;
+			if (infoPtr->cx == maxWidth) return FALSE;
+			infoPtr->cx += infoPtr->uRealItemHeight; /*FIXME */
+			if (infoPtr->cx > maxWidth) 
+				infoPtr->cx = maxWidth;
+			break;
+	case SB_PAGEUP:	
+			if (!infoPtr->cx) return FALSE;
+			infoPtr->cx -= infoPtr->uVisibleWidth;
+			if (infoPtr->cx < 0) infoPtr->cx=0;
+			break;
+	case SB_PAGEDOWN:
+			maxWidth=infoPtr->uTotalWidth-infoPtr->uVisibleWidth;
+			if (infoPtr->cx == maxWidth) return FALSE;
+			infoPtr->cx += infoPtr->uVisibleWidth;
+            if (infoPtr->cx > maxWidth)
+                infoPtr->cx = maxWidth;
+			break;
+	case SB_THUMBTRACK: 
+			infoPtr->cx = HIWORD (wParam);
+			break;
+			
+  }
+  
+  TREEVIEW_QueueRefresh (wndPtr);
   return TRUE;
 }
 
@@ -1745,20 +2469,20 @@
 	    	return TREEVIEW_SetImageList (wndPtr, wParam, lParam);
 
     	case TVM_GETNEXTITEM:
-      		return TREEVIEW_GetNextItem32 (wndPtr, wParam, lParam);
+      		return TREEVIEW_GetNextItem (wndPtr, wParam, lParam);
 
     	case TVM_SELECTITEM:
       		return TREEVIEW_SelectItem (wndPtr, wParam, lParam);
 
     	case TVM_GETITEM32A:
-      		return TREEVIEW_GetItem (wndPtr, wParam, lParam);
+      		return TREEVIEW_GetItem32A (wndPtr, wParam, lParam);
 
     	case TVM_GETITEM32W:
       		FIXME (treeview, "Unimplemented msg TVM_GETITEM32W\n");
       		return 0;
 
     	case TVM_SETITEM32A:
-      		return TREEVIEW_SetItem (wndPtr, wParam, lParam);
+      		return TREEVIEW_SetItem32A (wndPtr, wParam, lParam);
 
     	case TVM_SETITEM32W:
       		FIXME (treeview, "Unimplemented msg TVM_SETITEMW\n");
@@ -1773,8 +2497,7 @@
       		return 0;
 
     	case TVM_GETEDITCONTROL:
-      		FIXME (treeview, "Unimplemented msg TVM_GETEDITCONTROL\n");
-      		return 0;
+      		return TREEVIEW_GetEditControl (wndPtr);
 
     	case TVM_GETVISIBLECOUNT:
       		return TREEVIEW_GetVisibleCount (wndPtr, wParam, lParam);
@@ -1783,8 +2506,7 @@
       		return TREEVIEW_HitTest32 (wndPtr, lParam);
 
     	case TVM_CREATEDRAGIMAGE:
-      		FIXME (treeview, "Unimplemented msg TVM_CREATEDRAGIMAGE\n");
-      		return 0;
+      		return TREEVIEW_CreateDragImage (wndPtr, wParam, lParam);
   
     	case TVM_SORTCHILDREN:
       		FIXME (treeview, "Unimplemented msg TVM_SORTCHILDREN\n");
@@ -1827,15 +2549,13 @@
       		return TREEVIEW_GetItemHeight (wndPtr);
   
     	case TVM_SETBKCOLOR:
-      		FIXME (treeview, "Unimplemented msg TVM_SETBKCOLOR\n");
-      		return 0;
+      		return TREEVIEW_SetBkColor (wndPtr, wParam, lParam);
 	
     	case TVM_SETTEXTCOLOR:
       		return TREEVIEW_SetTextColor (wndPtr, wParam, lParam);
   
     	case TVM_GETBKCOLOR:
-      		FIXME (treeview, "Unimplemented msg TVM_GETBKCOLOR\n");
-      		return 0;
+      		return TREEVIEW_GetBkColor (wndPtr);
   
     	case TVM_GETTEXTCOLOR:
       		return TREEVIEW_GetTextColor (wndPtr);
@@ -1860,7 +2580,8 @@
       		FIXME (treeview, "Unimplemented msg TVM_GETUNICODEFORMAT\n");
       		return 0;
   
-/*		case WM_COMMAND: */
+		case WM_COMMAND: 
+			 return TREEVIEW_Command (wndPtr, wParam, lParam);
   
 		case WM_CREATE:
 			return TREEVIEW_Create (wndPtr, wParam, lParam);
@@ -1871,13 +2592,13 @@
 /*		case WM_ENABLE: */
   
 		case WM_ERASEBKGND:
-	    	return TREEVIEW_EraseBackground (wndPtr, wParam, lParam);
+			return TREEVIEW_EraseBackground (wndPtr, wParam, lParam);
   
 		case WM_GETDLGCODE:
 	    	return DLGC_WANTARROWS | DLGC_WANTCHARS;
   
 		case WM_PAINT:
-	    	return TREEVIEW_Paint (wndPtr, wParam);
+	    	return TREEVIEW_Paint (wndPtr, wParam, lParam);
   
 		case WM_GETFONT:
 	    	return TREEVIEW_GetFont (wndPtr, wParam, lParam);
@@ -1889,33 +2610,54 @@
 			return TREEVIEW_KeyDown (wndPtr, wParam, lParam);
   
   
-/*		case WM_KILLFOCUS: */
-/*		case WM_SETFOCUS: */
+		case WM_SETFOCUS: 
+			return TREEVIEW_SetFocus (wndPtr, wParam, lParam);
+
+		case WM_KILLFOCUS: 
+			return TREEVIEW_KillFocus (wndPtr, wParam, lParam);
   
   
 		case WM_LBUTTONDOWN:
 			return TREEVIEW_LButtonDown (wndPtr, wParam, lParam);
+
+		case WM_LBUTTONUP:
+			return TREEVIEW_LButtonUp (wndPtr, wParam, lParam);
   
 		case WM_LBUTTONDBLCLK:
 			return TREEVIEW_LButtonDoubleClick (wndPtr, wParam, lParam);
   
 		case WM_RBUTTONDOWN:
 			return TREEVIEW_RButtonDown (wndPtr, wParam, lParam);
+
+		case WM_RBUTTONUP:
+			return TREEVIEW_RButtonUp (wndPtr, wParam, lParam);
+
+		case WM_MOUSEMOVE:
+			return TREEVIEW_MouseMove (wndPtr, wParam, lParam);
+  
   
   
 /*		case WM_SYSCOLORCHANGE: */
-/*		case WM_STYLECHANGED: */
+		case WM_STYLECHANGED: 
+			return TREEVIEW_StyleChanged (wndPtr, wParam, lParam);
+
 /*		case WM_SETREDRAW: */
   
 		case WM_TIMER:
 			return TREEVIEW_HandleTimer (wndPtr, wParam, lParam);
-  
-/*		case WM_SIZE: */
+ 
+		case WM_SIZE: 
+			return TREEVIEW_Size (wndPtr, wParam,lParam);
+
 		case WM_HSCROLL: 
 			return TREEVIEW_HScroll (wndPtr, wParam, lParam);
 		case WM_VSCROLL: 
 			return TREEVIEW_VScroll (wndPtr, wParam, lParam);
   
+		case WM_DRAWITEM:
+			printf ("drawItem\n");
+			return DefWindowProc32A (hwnd, uMsg, wParam, lParam);
+  
 		default:
 	    	if (uMsg >= WM_USER)
 		FIXME (treeview, "Unknown msg %04x wp=%08x lp=%08lx\n",
diff --git a/dlls/shell32/brsfolder.c b/dlls/shell32/brsfolder.c
index 212bd0d..9b2dfb1 100644
--- a/dlls/shell32/brsfolder.c
+++ b/dlls/shell32/brsfolder.c
@@ -64,7 +64,7 @@
 	return sfi.iIcon;
 }
 
-static void GetNormalAndSelectedIcons(LPITEMIDLIST lpifq,LPTV_ITEM lpTV_ITEM)
+static void GetNormalAndSelectedIcons(LPITEMIDLIST lpifq,LPTVITEM32A lpTV_ITEM)
 {	TRACE (shell,"%p %p\n",lpifq, lpTV_ITEM);
 
 	lpTV_ITEM->iImage = GetIcon(lpifq, SHGFI_PIDL | SHGFI_SYSICONINDEX | SHGFI_SMALLICON);
@@ -98,8 +98,8 @@
 
 static void FillTreeView(LPSHELLFOLDER lpsf, LPITEMIDLIST  pidl, HTREEITEM hParent)
 {
-	TV_ITEM         tvi;
-	TV_INSERTSTRUCT tvins;
+	TVITEM32A 			tvi;
+	TVINSERTSTRUCT32A 	tvins;
 	HTREEITEM       hPrev = 0;
 	LPENUMIDLIST    lpe=0;
 	LPITEMIDLIST	pidlTemp=0;
@@ -145,7 +145,7 @@
 	        lptvid->lpifq	= ILCombine(pidl, pidlTemp);
 	        GetNormalAndSelectedIcons(lptvid->lpifq, &tvi);
 
-	        tvins.item         = tvi;
+	        tvins.DUMMYUNIONNAME.item         = tvi;
 	        tvins.hInsertAfter = hPrev;
 	        tvins.hParent      = hParent;
 
@@ -168,7 +168,7 @@
 
 static LRESULT MsgNotify(HWND32 hWnd,  UINT32 CtlID, LPNMHDR lpnmh)
 {	
-	NM_TREEVIEW	*pnmtv   = (NM_TREEVIEW *)lpnmh;
+	NMTREEVIEW32A	*pnmtv   = (NMTREEVIEW32A *)lpnmh;
 	LPTV_ITEMDATA	lptvid;  //Long pointer to TreeView item data
 	LPSHELLFOLDER	lpsf2=0;
 	
diff --git a/include/commctrl.h b/include/commctrl.h
index baa8015..dd6d821 100644
--- a/include/commctrl.h
+++ b/include/commctrl.h
@@ -184,7 +184,13 @@
 
 #define STATUSCLASSNAME16	"msctls_statusbar"
 #define STATUSCLASSNAME32A	"msctls_statusbar32"
-#define STATUSCLASSNAME32W	L"msctls_statusbar32"
+/* Does not work. gcc creates 4 byte wide strings.
+ * #define STATUSCLASSNAME32W	L"msctls_statusbar32"
+ */
+static const WCHAR	_scn32w[] = {
+'m','s','c','t','l','s','_','s','t','a','t','u','s','b','a','r','3','2',0
+};
+#define STATUSCLASSNAME32W	_scn32w
 #define STATUSCLASSNAME		WINELIB_NAME_AW(STATUSCLASSNAME)
 
 #define SBT_NOBORDERS		0x0100
@@ -1755,7 +1761,7 @@
       INT32  iSelectedImage;
       INT32  cChildren;
       LPARAM lParam;
-} TVITEMA, *LPTVITEMA;
+} TVITEM32A, *LPTVITEM32A;
 
 typedef struct {
       UINT32 mask;
@@ -1763,15 +1769,15 @@
       UINT32 state;
       UINT32 stateMask;
       LPWSTR pszText;
-      int cchTextMax;
-      int iImage;
-      int iSelectedImage;
-      int cChildren;
+      INT32 cchTextMax;
+      INT32 iImage;
+      INT32 iSelectedImage;
+      INT32 cChildren;
       LPARAM lParam;
-} TVITEMW, *LPTVITEMW;
+} TVITEM32W, *LPTVITEM32W;
 
-#define LPTV_ITEM LPTVITEMA
-#define TV_ITEM TVITEMA
+#define TV_ITEM     WINELIB_NAME(TV_ITEM)
+#define LPTV_ITEM   WINELIB_NAME(LPTV_ITEM)
 
 typedef struct {
       UINT32 mask;
@@ -1784,8 +1790,8 @@
       INT32  iSelectedImage;
       INT32  cChildren;
       LPARAM lParam;
-      int iIntegral;
-} TVITEMEXA, *LPTVITEMEXA;
+      INT32 iIntegral;
+} TVITEMEX32A, *LPTVITEMEX32A;
 
 typedef struct {
       UINT32 mask;
@@ -1793,63 +1799,78 @@
       UINT32 state;
       UINT32 stateMask;
       LPWSTR pszText;
-      int cchTextMax;
-      int iImage;
-      int iSelectedImage;
-      int cChildren;
+      INT32 cchTextMax;
+      INT32 iImage;
+      INT32 iSelectedImage;
+      INT32 cChildren;
       LPARAM lParam;
-      int iIntegral;
-} TVITEMEXW, *LPTV_ITEMEXW;
+      INT32 iIntegral;
+} TVITEMEX32W, *LPTV_ITEMEX32W;
 
-#define TV_ITEMEX TVITEMEXA
-#define LPTV_ITEMEXA LPTVITEMEXA
+#define TV_ITEMEX   WINELIB_NAME(TV_ITEM)
+#define LPTV_ITEMEX WINELIB_NAME(LPTV_ITEM)
 
-typedef struct tagTVINSERTSTRUCTA {
+
+typedef struct tagTVINSERTSTRUCT32A {
         HTREEITEM hParent;
         HTREEITEM hInsertAfter;
-        TVITEMA item;
-} TVINSERTSTRUCTA, *LPTVINSERTSTRUCTA;
+        union {
+           TVITEMEX32A itemex;
+           TVITEM32A   item;
+        } DUMMYUNIONNAME;
+} TVINSERTSTRUCT32A, *LPTVINSERTSTRUCT32A;
 
-typedef struct tagTVINSERTSTRUCTW {
+typedef struct tagTVINSERTSTRUCT32W {
         HTREEITEM hParent;
         HTREEITEM hInsertAfter;
-        TVITEMW item;
-} TVINSERTSTRUCTW, *LPTVINSERTSTRUCTW;
+        union {
+           TVITEMEX32W itemex;
+           TVITEM32W   item;
+        } DUMMYUNIONNAME;
+} TVINSERTSTRUCT32W, *LPTVINSERTSTRUCT32W;
 
-#define TV_INSERTSTRUCT TVINSERTSTRUCTA
-#define LPTV_INSERTSTRUCT LPTVINSERTSTRUCTA
+#define TV_INSERTSTRUCT   WINELIB_NAME(TVINSERTSTRUCT)
+#define LPTV_INSERTSTRUCT WINELIB_NAME(LPTVINSERTSTRUCT)
 
-typedef struct tagNMTREEVIEWA {
+#define TVINSERTSTRUCT_V1_SIZE32A CCSIZEOF_STRUCT(TVINSERTSTRUCT32A, item)
+#define TVINSERTSTRUCT_V1_SIZE32W CCSIZEOF_STRUCT(TVINSERTSTRUCT32W, item)
+#define TVINSERTSTRUCT_V1_SIZE    WINELIB_NAME_AW(TVINSERTSTRUCT_V1_SIZE)
+
+
+
+
+typedef struct tagNMTREEVIEW32A {
 	NMHDR	hdr;
 	UINT32	action;
-	TVITEMA	itemOld;
-	TVITEMA	itemNew;
+	TVITEM32A	itemOld;
+	TVITEM32A	itemNew;
 	POINT32	ptDrag;
-} NMTREEVIEWA, *LPNMTREEVIEWA;
+} NMTREEVIEW32A, *LPNMTREEVIEW32A;
 
-typedef struct tagNMTREEVIEWW {
+typedef struct tagNMTREEVIEW32W {
 	NMHDR	hdr;
 	UINT32	action;
-	TVITEMW	itemOld;
-	TVITEMW	itemNew;
+	TVITEM32W	itemOld;
+	TVITEM32W	itemNew;
 	POINT32	ptDrag;
-} NMTREEVIEWW, *LPNMTREEVIEWW;
+} NMTREEVIEW32W, *LPNMTREEVIEW32W;
 
-#define NM_TREEVIEW NMTREEVIEWA
-#define LPNM_TREEVIEW LPNMTREEVIEWA
+#define NMTREEVIEW     WINELIB_NAME_AW(NMTREEVIEW)
+#define LPNMTREEVIEW   WINELIB_NAME_AW(LPNMTREEVIEW)
 
-typedef struct tagTVDISPINFOA {
+typedef struct tagTVDISPINFO32A {
 	NMHDR	hdr;
-	TVITEMA	item;
-} NMTVDISPINFOA, *LPNMTVDISPINFOA;
+	TVITEM32A	item;
+} NMTVDISPINFO32A, *LPNMTVDISPINFO32A;
 
-typedef struct tagTVDISPINFOW {
+typedef struct tagTVDISPINFO32W {
 	NMHDR	hdr;
-	TVITEMW	item;
-} NMTVDISPINFOW, *LPNMTVDISPINFOW;
+	TVITEM32W	item;
+} NMTVDISPINFO32W, *LPNMTVDISPINFO32W;
 
-#define NMTVDISPINFO            NMTVDISPINFOA
-#define LPNMTVDISPINFO          LPNMTVDISPINFOA
+#define NMTVDISPINFO            WINELIB_NAME_AW(NMTVDISPINFO)
+#define LPNMTVDISPINFO          WINELIB_NAME_AW(LPNMTVDISPINFO)
+#define TV_DISPINFO             NMTVDISPINFO
 
 typedef INT32 (CALLBACK *PFNTVCOMPARE)(LPARAM, LPARAM, LPARAM);
 
@@ -1871,9 +1892,51 @@
 
 #define TV_HITTESTINFO TVHITTESTINFO
 
+
+/* Custom Draw Treeview */
+
+#define NMTVCUSTOMDRAW_V3_SIZE CCSIZEOF_STRUCT(NMTVCUSTOMDRAW, clrTextBk)
+
+#define TVCDRF_NOIMAGES     0x00010000
+
+typedef struct tagNMTVCUSTOMDRAW
+{
+    NMCUSTOMDRAW nmcd;
+    COLORREF     clrText;
+    COLORREF     clrTextBk;
+    INT32 iLevel;                 /* IE>0x0400 */
+} NMTVCUSTOMDRAW, *LPNMTVCUSTOMDRAW;
+
+/* Treeview tooltips */
+
+typedef struct tagNMTVGETINFOTIP32A
+{
+    NMHDR hdr;
+    LPSTR pszText;
+    INT32 cchTextMax;
+    HTREEITEM hItem;
+    LPARAM lParam;
+} NMTVGETINFOTIP32A, *LPNMTVGETINFOTIP32A;
+
+typedef struct tagNMTVGETINFOTIP32W
+{
+    NMHDR hdr;
+    LPWSTR pszText;
+    INT32 cchTextMax;
+    HTREEITEM hItem;
+    LPARAM lParam;
+} NMTVGETINFOTIP32W, *LPNMTVGETINFOTIP32W;
+
+
+#define NMTVGETINFOTIP          WINELIB_NAME(NMTVGETINFOTIP)
+
+
+
+
+
 #define TreeView_InsertItem32A(hwnd, phdi) \
   (INT32)SendMessage32A((hwnd), TVM_INSERTITEM32A, 0, \
-                            (LPARAM)(LPTVINSERTSTRUCTA)(phdi))
+                            (LPARAM)(LPTVINSERTSTRUCT32A)(phdi))
 #define TreeView_DeleteItem(hwnd, hItem) \
   (BOOL32)SendMessage32A((hwnd), TVM_DELETEITEM, 0, (LPARAM)(HTREEITEM)(hItem))
 #define TreeView_DeleteAllItems(hwnd) \
@@ -1945,10 +2008,10 @@
 */
 
 #define TreeView_GetItem32A(hwnd, pitem) \
- (BOOL32)SendMessage32A((hwnd), TVM_GETITEM32A, 0, (LPARAM) (TVITEMA *)(pitem))
+ (BOOL32)SendMessage32A((hwnd), TVM_GETITEM32A, 0, (LPARAM) (TVITEM32A *)(pitem))
 
 #define TreeView_SetItem32A(hwnd, pitem) \
- (BOOL32)SendMessage32A((hwnd), TVM_SETITEM32A, 0, (LPARAM)(const TVITEMA *)(pitem)) 
+ (BOOL32)SendMessage32A((hwnd), TVM_SETITEM32A, 0, (LPARAM)(const TVITEM32A *)(pitem)) 
 
 #define TreeView_EditLabel(hwnd, hitem) \
     (HWND)SendMessage32A((hwnd), TVM_EDITLABEL, 0, (LPARAM)(HTREEITEM)(hitem))
@@ -2432,6 +2495,7 @@
 #define TCS_BOTTOM              0x0002
 #define TCS_RIGHT               0x0002
 #define TCS_MULTISELECT         0x0004  /* allow multi-select in button mode */
+#define TCS_FLATBUTTONS         0x0008
 #define TCS_FORCEICONLEFT       0x0010
 #define TCS_FORCELABELLEFT      0x0020
 #define TCS_HOTTRACK            0x0040
@@ -2447,6 +2511,9 @@
 #define TCS_OWNERDRAWFIXED      0x2000
 #define TCS_TOOLTIPS            0x4000
 #define TCS_FOCUSNEVER          0x8000
+#define TCS_EX_FLATSEPARATORS   0x00000001  /* to be used with */
+#define TCS_EX_REGISTERDROP     0x00000002  /* TCM_SETEXTENDEDSTYLE */
+
 
 #define TCM_FIRST		0x1300
 
@@ -2493,6 +2560,17 @@
 #define TCIF_PARAM		0x0008
 #define TCIF_STATE		0x0010
 
+#define TCIS_BUTTONPRESSED      0x0001
+#define TCIS_HIGHLIGHTED 0x0002
+
+
+/* constants for TCHITTESTINFO */
+
+#define TCHT_NOWHERE      0x01
+#define TCHT_ONITEMICON   0x02
+#define TCHT_ONITEMLABEL  0x04
+#define TCHT_ONITEM       (TCHT_ONITEMICON | TCHT_ONITEMLABEL)
+
 
 typedef struct tagTCITEM32A {
     UINT32 mask;
diff --git a/include/treeview.h b/include/treeview.h
index 68b9c28..e2403c8 100644
--- a/include/treeview.h
+++ b/include/treeview.h
@@ -9,15 +9,10 @@
 #define __WINE_TREEVIEW_H
 
 #define MINIMUM_INDENT 10
-
-
-#define TVITEM_ALLOC	16
-#define TV_REFRESH_TIMER 1	
-#define TV_EDIT_TIMER    2
-#define TV_REFRESH_TIMER_SET 1  
-#define TV_EDIT_TIMER_SET 2  
 #define TV_REFRESH_DELAY 100     /* 100 ms delay between two refreshes */
-#define TV_DEFAULTITEMHEIGHT 15
+#define TV_DEFAULTITEMHEIGHT 16
+#define TVITEM_ALLOC	16	/* default nr of items to allocate at first try */
+
 
 /* internal structures */
 
@@ -33,7 +28,8 @@
     int cChildren;
     LPARAM lParam;
     int iIntegral;
-	int clrText;
+	int iLevel;			/* indentation level:0=root level */
+	COLORREF clrText;
 	
 	int parent;	    /* handle to parent or 0 if at root*/
 	int firstChild;     /* handle to first child or 0 if no child*/
@@ -45,31 +41,40 @@
 } TREEVIEW_ITEM;
 
 
-#define TV_HSCROLL 	0x01    /* treeview too large to fit in window */
-#define TV_VSCROLL 	0x02	/* (horizontal/vertical) */
 
 typedef struct tagTREEVIEW_INFO
 {
     UINT32	uInternalStatus;		
+	UINT32  bAutoSize;			/* merge with uInternalStatus */
 	INT32	Timer;
     UINT32  uNumItems;	/* number of valid TREEVIEW_ITEMs */
     UINT32	uNumPtrsAlloced; 
     UINT32	uMaxHandle;	/* needed for delete_item */
     HTREEITEM 	TopRootItem;	/* handle to first item in treeview */
+	INT32	cdmode;		/* last custom draw setting */
 
 	UINT32	uItemHeight;		/* item height, -1 for default item height */
-	UINT32 	uRealItemHeight;	/* real item height in pixels */
+	UINT32 	uRealItemHeight;	/* current item height in pixels */
 	UINT32	uVisibleHeight;	    /* visible height of treeview in pixels */
     UINT32	uTotalHeight;		/* total height of treeview in pixels */
-    UINT32		uIndent;		/* indentation in pixels */
+	UINT32	uVisibleWidth;	    
+    UINT32	uTotalWidth;	
+    UINT32	uIndent;			/* indentation in pixels */
     HTREEITEM	selectedItem;   /* handle to selected item or 0 if none */
+	HTREEITEM	focusItem;		/* handle to item that has focus, 0 if none */
+	HTREEITEM	hotItem;		/* handle currently under cursor, 0 if none */
+    HTREEITEM	editItem;   /* handle to item currently editted, 0 if none */
     HTREEITEM   firstVisible;	/* handle to first visible item */
     HTREEITEM   dropItem;	/* handle to item selected by drag cursor */
+	HIMAGELIST  dragList;	/* Bitmap of dragged item */
     INT32		cx,cy;		/* current x/y place in list */
     COLORREF	clrBk;		
     COLORREF	clrText;
     HFONT32 	hFont;
+    HFONT32 	hBoldFont;
 	HWND32		hwndToolTip;
+	HWND32		hwndEdit;
+	WNDPROC32   wpEditOrig;     /* needed for subclassing edit control */
 
     HIMAGELIST	himlNormal;	
     HIMAGELIST	himlState;
@@ -81,6 +86,24 @@
 } TREEVIEW_INFO;
 
 
+
+/* bitflags for infoPtr->uInternalStatus */
+
+#define TV_HSCROLL 	0x01    /* treeview too large to fit in window */
+#define TV_VSCROLL 	0x02	/* (horizontal/vertical) */
+#define TV_LDRAG		0x04	/* Lbutton pushed to start drag */
+#define TV_LDRAGGING	0x08	/* Lbutton pushed, mouse moved.  */
+#define TV_RDRAG		0x10	/* dito Rbutton */
+#define TV_RDRAGGING	0x20	
+
+/* bitflags for infoPtr->timer */
+
+#define TV_REFRESH_TIMER 1	
+#define TV_EDIT_TIMER    2
+#define TV_REFRESH_TIMER_SET 1  
+#define TV_EDIT_TIMER_SET 2  
+
+
 extern VOID TREEVIEW_Register (VOID);
 extern VOID TREEVIEW_Unregister (VOID);