/* Treeview control * * Copyright 1998 Eric Kohl * Copyright 1998,1999 Alex Priem * * * TODO: * 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 RefreshItem: 1) draw lines between parents 2) draw items 3) draw lines from parent<->items. -implement partial drawing? * -drag&drop: TVM_CREATEDRAGIMAGE should create drag bitmap. * -scrollbars: horizontal scrollbar doesn't work. * -Unicode messages * -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 (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 #include "windows.h" #include "commctrl.h" #include "treeview.h" #include "win.h" #include "debug.h" /* ffs should be in . */ /* Defines, since they do not need to return previous state, and nr * has no side effects in this file. */ #define tv_test_bit(nr,bf) (((LPBYTE)bf)[nr>>3]&(1<<(nr&7))) #define tv_set_bit(nr,bf) ((LPBYTE)bf)[nr>>3]|=(1<<(nr&7)) #define tv_clear_bit(nr,bf) ((LPBYTE)bf)[nr>>3]&=~(1<<(nr&7)) #define TREEVIEW_GetInfoPtr(wndPtr) ((TREEVIEW_INFO *)wndPtr->wExtra[0]) static BOOL32 TREEVIEW_SendSimpleNotify (WND *wndPtr, UINT32 code); static BOOL32 TREEVIEW_SendTreeviewNotify (WND *wndPtr, UINT32 code, UINT32 action, 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_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, and that tree state is valid. */ /* FIXME: MS documentation says `GetNextVisibleItem' returns NULL 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 * TREEVIEW_ValidItem (TREEVIEW_INFO *infoPtr,int handle) { if ((!handle) || (handle>infoPtr->uMaxHandle)) return NULL; if (tv_test_bit (handle, infoPtr->freeList)) return NULL; return & infoPtr->items[handle]; } static TREEVIEW_ITEM *TREEVIEW_GetPrevListItem (TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *tvItem) { TREEVIEW_ITEM *wineItem; if (tvItem->upsibling) { wineItem=& infoPtr->items[tvItem->upsibling]; if ((wineItem->firstChild) && (wineItem->state & TVIS_EXPANDED)) { wineItem=& infoPtr->items[wineItem->firstChild]; while (wineItem->sibling) wineItem= & infoPtr->items[wineItem->sibling]; } return wineItem; } wineItem=tvItem; while (wineItem->parent) { wineItem=& infoPtr->items[wineItem->parent]; if (wineItem->upsibling) return (& infoPtr->items[wineItem->upsibling]); } return wineItem; } static TREEVIEW_ITEM *TREEVIEW_GetNextListItem (TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *tvItem) { TREEVIEW_ITEM *wineItem; if ((tvItem->firstChild) && (tvItem->state & TVIS_EXPANDED)) return (& infoPtr->items[tvItem->firstChild]); if (tvItem->sibling) return (& infoPtr->items[tvItem->sibling]); wineItem=tvItem; while (wineItem->parent) { wineItem=& infoPtr->items [wineItem->parent]; if (wineItem->sibling) return (& infoPtr->items [wineItem->sibling]); } return NULL; /* was wineItem */ } static TREEVIEW_ITEM *TREEVIEW_GetLastListItem (TREEVIEW_INFO *infoPtr, TREEVIEW_ITEM *tvItem) { TREEVIEW_ITEM *wineItem; wineItem=tvItem; while (wineItem->sibling) wineItem=& infoPtr->items [wineItem->sibling]; return wineItem; } 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 (WND *wndPtr, TREEVIEW_ITEM *wineItem) { TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr); TREEVIEW_ITEM *parentItem, *upsiblingItem, *siblingItem; INT32 iItem; iItem=wineItem->hItem; tv_set_bit(iItem,infoPtr->freeList); infoPtr->uNumItems--; parentItem=NULL; 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]; 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; } } if (iItem==infoPtr->TopRootItem) infoPtr->TopRootItem=wineItem->sibling; if (wineItem->upsibling) { upsiblingItem=& infoPtr->items [wineItem->upsibling]; upsiblingItem->sibling=wineItem->sibling; } if (wineItem->sibling) { siblingItem=& infoPtr->items [wineItem->sibling]; siblingItem->upsibling=wineItem->upsibling; } } /* Note:TREEVIEW_RemoveTree doesn't remove infoPtr itself */ static void TREEVIEW_RemoveTree (WND *wndPtr) { 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); TREEVIEW_SendTreeviewNotify (wndPtr, TVN_DELETEITEM, 0, killItem->hItem, 0); } if (infoPtr->uNumPtrsAlloced) { COMCTL32_Free (infoPtr->items); COMCTL32_Free (infoPtr->freeList); infoPtr->uNumItems=0; infoPtr->uNumPtrsAlloced=0; infoPtr->uMaxHandle=0; } } static LRESULT TREEVIEW_GetImageList (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) { TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr); TRACE (treeview,"\n"); if (infoPtr==NULL) return 0; if ((INT32)wParam == TVSIL_NORMAL) return (LRESULT) infoPtr->himlNormal; if ((INT32)wParam == TVSIL_STATE) return (LRESULT) infoPtr->himlState; return 0; } static LRESULT TREEVIEW_SetImageList (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) { TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr); HIMAGELIST himlTemp; TRACE (treeview,"\n"); switch ((INT32)wParam) { case TVSIL_NORMAL: himlTemp = infoPtr->himlNormal; infoPtr->himlNormal = (HIMAGELIST)lParam; return (LRESULT)himlTemp; case TVSIL_STATE: himlTemp = infoPtr->himlState; infoPtr->himlState = (HIMAGELIST)lParam; return (LRESULT)himlTemp; } return (LRESULT)NULL; } static LRESULT TREEVIEW_SetItemHeight (WND *wndPtr, WPARAM32 wParam) { TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr); INT32 cx,cy,prevHeight=infoPtr->uItemHeight; HDC32 hdc; TRACE (treeview,"\n"); if (wParam==-1) { hdc=GetDC32 (wndPtr->hwndSelf); infoPtr->uItemHeight=-1; return prevHeight; } ImageList_GetIconSize (infoPtr->himlNormal, &cx, &cy); if (wParam>cy) cy=wParam; infoPtr->uItemHeight=cy; if (!(wndPtr->dwStyle & TVS_NONEVENHEIGHT)) infoPtr->uItemHeight = (INT32) wParam & 0xfffffffe; return prevHeight; } static LRESULT TREEVIEW_GetItemHeight (WND *wndPtr) { TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr); TRACE (treeview,"\n"); return infoPtr->uItemHeight; } static LRESULT TREEVIEW_SetTextColor (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) { TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr); COLORREF prevColor=infoPtr->clrText; TRACE (treeview,"\n"); infoPtr->clrText=(COLORREF) lParam; return (LRESULT) prevColor; } static LRESULT TREEVIEW_GetBkColor (WND *wndPtr) { TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr); TRACE (treeview,"\n"); return (LRESULT) infoPtr->clrText; } static LRESULT TREEVIEW_SetBkColor (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) { TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr); 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; 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 (wineItem->parent) { parentItem=TREEVIEW_ValidItem (infoPtr, wineItem->parent); upper=parentItem->rect; } else { upper.top=0; upper.left=8; } center=(r.top+r.bottom)/2; xpos=r.left+8; if (wndPtr->dwStyle & TVS_HASLINES) { POINT32 points[3]; 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; points[0].x=upper.left+12; points[2].y+=5; Polyline32 (hdc,points,3); } else { points[0].y=points[1].y=center; points[2].y=upper.top; points[1].x=points[2].x=upper.left+13; points[0].x=upper.left+25; points[2].y+=5; Polyline32 (hdc,points,3); } } DeleteObject32(hnewPen); SelectObject32(hdc, hOldPen); 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); } } xpos+=13; 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 | TVIS_DROPHILITED) ) { oldBkMode = SetBkMode32(hdc, OPAQUE); oldBkColor= SetBkColor32 (hdc, GetSysColor32( COLOR_HIGHLIGHT)); SetTextColor32 (hdc, GetSysColor32(COLOR_HIGHLIGHTTEXT)); } else { oldBkMode = SetBkMode32(hdc, TRANSPARENT); } 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: 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 | TVIS_DROPHILITED)) SetBkColor32 (hdc, oldBkColor); } if (cditem & CDRF_NOTIFYPOSTPAINT) TREEVIEW_SendCustomDrawItemNotify (wndPtr, hdc, wineItem, CDDS_ITEMPOSTPAINT); SelectObject32 (hdc, hOldFont); } static LRESULT TREEVIEW_GetItemRect (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) { TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr); TREEVIEW_ITEM *wineItem; 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 = (HTREEITEM *) lParam; wineItem = TREEVIEW_ValidItem (infoPtr, *iItem); if (!wineItem) return FALSE; wineItem=& infoPtr->items[ *iItem ]; if (!wineItem->visible) return FALSE; lpRect = (LPRECT32)lParam; if (lpRect == NULL) return FALSE; if ((INT32) wParam) { lpRect->left = wineItem->text.left; lpRect->right = wineItem->text.right; lpRect->bottom = wineItem->text.bottom; lpRect->top = wineItem->text.top; } else { lpRect->left = wineItem->rect.left; lpRect->right = wineItem->rect.right; lpRect->bottom = wineItem->rect.bottom; 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; } static LRESULT TREEVIEW_GetVisibleCount (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) { TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr); return (LRESULT) infoPtr->uVisibleHeight / infoPtr->uRealItemHeight; } static LRESULT TREEVIEW_SetItem32A (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) { TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr); TREEVIEW_ITEM *wineItem; TVITEMEX32A *tvItem; INT32 iItem,len; tvItem=(LPTVITEMEX32A) lParam; iItem=tvItem->hItem; TRACE (treeview,"item %d,mask %x\n",iItem,tvItem->mask); wineItem = TREEVIEW_ValidItem (infoPtr, iItem); if (!wineItem) return FALSE; if (tvItem->mask & TVIF_CHILDREN) { wineItem->cChildren=tvItem->cChildren; } if (tvItem->mask & TVIF_IMAGE) { wineItem->iImage=tvItem->iImage; } if (tvItem->mask & TVIF_INTEGRAL) { wineItem->iIntegral=tvItem->iIntegral; FIXME (treeview," TVIF_INTEGRAL not supported yet\n"); } if (tvItem->mask & TVIF_PARAM) { wineItem->lParam=tvItem->lParam; } if (tvItem->mask & TVIF_SELECTEDIMAGE) { wineItem->iSelectedImage=tvItem->iSelectedImage; } if (tvItem->mask & TVIF_STATE) { wineItem->state=tvItem->state & tvItem->stateMask; } 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; } static void TREEVIEW_Refresh (WND *wndPtr) { TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr); TEXTMETRIC32A tm; HBRUSH32 hbrBk; RECT32 rect; HDC32 hdc; INT32 iItem, indent, x, y, cx, height, itemHeight; INT32 viewtop,viewbottom,viewleft,viewright; TREEVIEW_ITEM *wineItem, *prevItem; TRACE (treeview,"\n"); hdc=GetDC32 (wndPtr->hwndSelf); if (infoPtr->Timer & TV_REFRESH_TIMER_SET) { KillTimer32 (wndPtr->hwndSelf, TV_REFRESH_TIMER); infoPtr->Timer &= ~TV_REFRESH_TIMER_SET; } 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; /* draw background */ hbrBk = GetSysColorBrush32 (COLOR_WINDOW); FillRect32(hdc, &rect, hbrBk); iItem=infoPtr->TopRootItem; infoPtr->firstVisible=0; wineItem=NULL; indent=0; x=y=0; TRACE (treeview, "[%d %d %d %d]\n",viewtop,viewbottom,viewleft,viewright); 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=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); } else { 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 */ if ((wineItem->firstChild) && (wineItem->state & TVIS_EXPANDED)) { iItem=wineItem->firstChild; indent++; x+=infoPtr->uIndent; if (x>infoPtr->uTotalWidth) infoPtr->uTotalWidth=x; } else { iItem=wineItem->sibling; while ((!iItem) && (indent>0)) { indent--; x-=infoPtr->uIndent; prevItem=wineItem; wineItem=&infoPtr->items[wineItem->parent]; iItem=wineItem->sibling; } } 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)) ShowScrollBar32 (wndPtr->hwndSelf, SB_VERT, TRUE); infoPtr->uInternalStatus |=TV_VSCROLL; SetScrollRange32 (wndPtr->hwndSelf, SB_VERT, 0, y - infoPtr->uVisibleHeight, FALSE); SetScrollPos32 (wndPtr->hwndSelf, SB_VERT, infoPtr->cy, TRUE); } else { if (infoPtr->uInternalStatus & TV_VSCROLL) ShowScrollBar32 (wndPtr->hwndSelf, SB_VERT, FALSE); infoPtr->uInternalStatus &= ~TV_VSCROLL; } if (infoPtr->cdmode & CDRF_NOTIFYPOSTPAINT) infoPtr->cdmode=TREEVIEW_SendCustomDrawNotify (wndPtr, CDDS_POSTPAINT, hdc, rect); ReleaseDC32 (wndPtr->hwndSelf, hdc); TRACE (treeview,"done\n"); } static LRESULT TREEVIEW_HandleTimer ( WND *wndPtr, WPARAM32 wParam, LPARAM lParam) { TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr); TRACE (treeview, " %d\n",wParam); if (!infoPtr) return FALSE; switch (wParam) { case TV_REFRESH_TIMER: KillTimer32 (wndPtr->hwndSelf, TV_REFRESH_TIMER); infoPtr->Timer &= ~TV_REFRESH_TIMER_SET; 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; } static void TREEVIEW_QueueRefresh (WND *wndPtr) { TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr); TRACE (treeview,"\n"); if (infoPtr->Timer & TV_REFRESH_TIMER_SET) { KillTimer32 (wndPtr->hwndSelf, TV_REFRESH_TIMER); } SetTimer32 (wndPtr->hwndSelf, TV_REFRESH_TIMER, TV_REFRESH_DELAY, 0); infoPtr->Timer|=TV_REFRESH_TIMER_SET; } static LRESULT TREEVIEW_GetItem32A (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) { TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr); LPTVITEMEX32A tvItem; TREEVIEW_ITEM *wineItem; INT32 iItem; 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; } if (tvItem->mask & TVIF_HANDLE) { tvItem->hItem=wineItem->hItem; } if (tvItem->mask & TVIF_IMAGE) { tvItem->iImage=wineItem->iImage; } if (tvItem->mask & TVIF_INTEGRAL) { tvItem->iIntegral=wineItem->iIntegral; FIXME (treeview," TVIF_INTEGRAL not supported yet\n"); } if (tvItem->mask & TVIF_PARAM) { tvItem->lParam=wineItem->lParam; } if (tvItem->mask & TVIF_SELECTEDIMAGE) { tvItem->iSelectedImage=wineItem->iSelectedImage; } if (tvItem->mask & TVIF_STATE) { tvItem->state=wineItem->state & tvItem->stateMask; } if (tvItem->mask & TVIF_TEXT) { if (wineItem->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); } } return TRUE; } /* FIXME: check implementation of TVGN_NEXT/TVGN_NEXTVISIBLE */ static LRESULT TREEVIEW_GetNextItem (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) { TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr); TREEVIEW_ITEM *wineItem, *returnItem; INT32 iItem, retval, flag; if (!infoPtr) return FALSE; flag = (INT32) wParam; iItem = (INT32) lParam; retval=0; switch (flag) { case TVGN_ROOT: retval=infoPtr->TopRootItem; break; case TVGN_CARET:retval=infoPtr->selectedItem; break; case TVGN_FIRSTVISIBLE: TREEVIEW_Refresh (wndPtr); /* FIXME:we should only recalculate, not redraw */ retval=infoPtr->firstVisible; break; case TVGN_DROPHILITE: retval=infoPtr->dropItem; break; } 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: 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: returnItem=TREEVIEW_GetLastListItem (infoPtr,wineItem); break; case TVGN_NEXTVISIBLE: returnItem=TREEVIEW_GetNextListItem (infoPtr,wineItem); break; case TVGN_PREVIOUSVISIBLE: returnItem=TREEVIEW_GetPrevListItem (infoPtr, wineItem); break; default: FIXME (treeview,"Unknown msg %x,item %x\n", flag,iItem); break; } if (returnItem) { TRACE (treeview,"flags:%x, item %d;returns %d\n", flag, iItem, returnItem->hItem); return returnItem->hItem; } TRACE (treeview,"flags:%x, item %d;returns %d\n", flag, iItem,retval); return retval; } static LRESULT TREEVIEW_GetCount (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) { TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr); TRACE (treeview," %d\n",infoPtr->uNumItems); return (LRESULT) infoPtr->uNumItems; } /* 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. */ static LRESULT TREEVIEW_InsertItem32A (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) { TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr); TVINSERTSTRUCT32A *ptdi; TVITEMEX32A *tvItem; TREEVIEW_ITEM *wineItem, *parentItem, *prevsib, *sibItem; INT32 iItem,listItems,i,len; ptdi = (LPTVINSERTSTRUCT32A) lParam; /* check if memory is available */ if (infoPtr->uNumPtrsAlloced==0) { infoPtr->items = COMCTL32_Alloc (TVITEM_ALLOC*sizeof (TREEVIEW_ITEM)); infoPtr->freeList= COMCTL32_Alloc ((1+(TVITEM_ALLOC>>5)) * sizeof (INT32)); infoPtr->uNumPtrsAlloced=TVITEM_ALLOC; infoPtr->TopRootItem=1; } if (infoPtr->uNumItems == (infoPtr->uNumPtrsAlloced-1) ) { TREEVIEW_ITEM *oldItems = infoPtr->items; 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)); memcpy (&infoPtr->items[0], &oldItems[0], infoPtr->uNumPtrsAlloced/2 * sizeof(TREEVIEW_ITEM)); memcpy (&infoPtr->freeList[0], &oldfreeList[0], infoPtr->uNumPtrsAlloced>>6 * sizeof(INT32)); COMCTL32_Free (oldItems); COMCTL32_Free (oldfreeList); } iItem=0; infoPtr->uNumItems++; if (infoPtr->uMaxHandle==(infoPtr->uNumItems-1)) { iItem=infoPtr->uNumItems; infoPtr->uMaxHandle++; } else { /* check freelist */ for (i=0; iuNumPtrsAlloced>>5; i++) { if (infoPtr->freeList[i]) { iItem=ffs (infoPtr->freeList[i])-1; tv_clear_bit(iItem,&infoPtr->freeList[i]); iItem+=i<<5; break; } } } for (i=0; iuNumPtrsAlloced>>5; i++) TRACE (treeview,"%8x\n",infoPtr->freeList[i]); if (!iItem) ERR (treeview, "Argh -- can't find free item.\n"); tvItem= & ptdi->DUMMYUNIONNAME.itemex; wineItem=& infoPtr->items[iItem]; if ((ptdi->hParent==TVI_ROOT) || (ptdi->hParent==0)) { parentItem=NULL; wineItem->parent=0; sibItem=&infoPtr->items [infoPtr->TopRootItem]; listItems=infoPtr->uNumItems; } else { parentItem= &infoPtr->items[ptdi->hParent]; if (!parentItem->firstChild) parentItem->firstChild=iItem; wineItem->parent=ptdi->hParent; sibItem=&infoPtr->items [parentItem->firstChild]; parentItem->cChildren++; listItems=parentItem->cChildren; } 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: 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; wineItem->upsibling=sibItem->hItem; break; case TVI_SORT: FIXME (treeview, "Sorted insert not implemented yet\n"); break; default: while ((sibItem->sibling) && (sibItem->hItem!=ptdi->hInsertAfter)) { prevsib=sibItem; sibItem=&infoPtr->items [sibItem->sibling]; } 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; } } /* Fill in info structure */ TRACE (treeview,"new item %d; parent %d, mask %x\n", iItem, wineItem->parent,tvItem->mask); wineItem->mask=tvItem->mask; wineItem->iIntegral=1; 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 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; if (tvItem->mask & TVIF_SELECTEDIMAGE) wineItem->iSelectedImage=tvItem->iSelectedImage; if (tvItem->mask & TVIF_STATE) { wineItem->state=tvItem->state; wineItem->stateMask=tvItem->stateMask; } if (tvItem->mask & TVIF_TEXT) { 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 { TRACE (treeview,"LPSTR_TEXTCALLBACK\n"); wineItem->pszText = LPSTR_TEXTCALLBACK32A; wineItem->cchTextMax = 0; } } TREEVIEW_QueueRefresh (wndPtr); return (LRESULT) iItem; } static LRESULT TREEVIEW_DeleteItem (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) { TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr); INT32 iItem; TREEVIEW_ITEM *wineItem; TRACE (treeview,"\n"); if (!infoPtr) return FALSE; if ((INT32) lParam == TVI_ROOT) { TREEVIEW_RemoveTree (wndPtr); } else { iItem= (INT32) lParam; wineItem = TREEVIEW_ValidItem (infoPtr, iItem); if (!wineItem) return FALSE; TRACE (treeview,"%s\n",wineItem->pszText); TREEVIEW_RemoveItem (wndPtr, wineItem); } TREEVIEW_QueueRefresh (wndPtr); return TRUE; } static LRESULT TREEVIEW_GetIndent (WND *wndPtr) { TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr); TRACE (treeview,"\n"); return infoPtr->uIndent; } static LRESULT TREEVIEW_SetIndent (WND *wndPtr, WPARAM32 wParam) { TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr); INT32 newIndent; TRACE (treeview,"\n"); newIndent=(INT32) wParam; if (newIndent < MINIMUM_INDENT) newIndent=MINIMUM_INDENT; infoPtr->uIndent=newIndent; return 0; } static LRESULT TREEVIEW_GetToolTips (WND *wndPtr) { TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr); TRACE (treeview,"\n"); return infoPtr->hwndToolTip; } static LRESULT TREEVIEW_SetToolTips (WND *wndPtr, WPARAM32 wParam) { TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr); HWND32 prevToolTip; TRACE (treeview,"\n"); prevToolTip=infoPtr->hwndToolTip; infoPtr->hwndToolTip= (HWND32) wParam; return prevToolTip; } 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; LOGFONT32A logFont; TEXTMETRIC32A tm; HDC32 hdc; TRACE (treeview,"wnd %x\n",wndPtr->hwndSelf); /* allocate memory for info structure */ infoPtr = (TREEVIEW_INFO *) COMCTL32_Alloc (sizeof(TREEVIEW_INFO)); wndPtr->wExtra[0] = (DWORD)infoPtr; if (infoPtr == NULL) { ERR (treeview, "could not allocate info memory!\n"); return 0; } if ((TREEVIEW_INFO*)wndPtr->wExtra[0] != infoPtr) { ERR (treeview, "pointer assignment error!\n"); return 0; } hdc=GetDC32 (wndPtr->hwndSelf); /* set default settings */ infoPtr->uInternalStatus=0; infoPtr->uNumItems=0; infoPtr->clrBk = GetSysColor32 (COLOR_WINDOW); infoPtr->clrText = GetSysColor32 (COLOR_BTNTEXT); infoPtr->cy = 0; infoPtr->cx = 0; infoPtr->uIndent = 15; infoPtr->himlNormal = NULL; infoPtr->himlState = NULL; infoPtr->uItemHeight = -1; GetTextMetrics32A (hdc, &tm); infoPtr->hFont = GetStockObject32 (DEFAULT_GUI_FONT); 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 */ infoPtr->dropItem=0; /* infoPtr->hwndNotify = GetParent32 (wndPtr->hwndSelf); infoPtr->bTransparent = (wndPtr->dwStyle & TBSTYLE_FLAT); */ infoPtr->hwndToolTip=0; if (!(wndPtr->dwStyle & TVS_NOTOOLTIPS)) { /* Create tooltip control */ TTTOOLINFO32A ti; infoPtr->hwndToolTip = CreateWindowEx32A (0, TOOLTIPS_CLASS32A, NULL, 0, CW_USEDEFAULT32, CW_USEDEFAULT32, CW_USEDEFAULT32, CW_USEDEFAULT32, wndPtr->hwndSelf, 0, 0, 0); /* Send NM_TOOLTIPSCREATED notification */ if (infoPtr->hwndToolTip) { NMTOOLTIPSCREATED nmttc; nmttc.hdr.hwndFrom = wndPtr->hwndSelf; nmttc.hdr.idFrom = wndPtr->wIDmenu; nmttc.hdr.code = NM_TOOLTIPSCREATED; nmttc.hwndToolTips = infoPtr->hwndToolTip; SendMessage32A (GetParent32 (wndPtr->hwndSelf), WM_NOTIFY, (WPARAM32)wndPtr->wIDmenu, (LPARAM)&nmttc); } ZeroMemory (&ti, sizeof(TTTOOLINFO32A)); ti.cbSize = sizeof(TTTOOLINFO32A); ti.uFlags = TTF_IDISHWND | TTF_TRACK | TTF_TRANSPARENT ; ti.hwnd = wndPtr->hwndSelf; ti.uId = 0; ti.lpszText = "Test"; /* LPSTR_TEXTCALLBACK; */ 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; } static LRESULT TREEVIEW_Destroy (WND *wndPtr) { TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr); TRACE (treeview,"\n"); TREEVIEW_RemoveTree (wndPtr); if (infoPtr->Timer & TV_REFRESH_TIMER_SET) KillTimer32 (wndPtr->hwndSelf, TV_REFRESH_TIMER); if (infoPtr->hwndToolTip) DestroyWindow32 (infoPtr->hwndToolTip); COMCTL32_Free (infoPtr); return 0; } static LRESULT 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_Refresh (wndPtr); if(!wParam) EndPaint32 (wndPtr->hwndSelf, &ps); 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) { TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr); HBRUSH32 hBrush = CreateSolidBrush32 (infoPtr->clrBk); RECT32 rect; TRACE (treeview,"\n"); GetClientRect32 (wndPtr->hwndSelf, &rect); FillRect32 ((HDC32)wParam, &rect, hBrush); DeleteObject32 (hBrush); return TRUE; } /* Notifications */ static BOOL32 TREEVIEW_SendSimpleNotify (WND *wndPtr, UINT32 code) { NMHDR nmhdr; TRACE (treeview, "%x\n",code); nmhdr.hwndFrom = wndPtr->hwndSelf; nmhdr.idFrom = wndPtr->wIDmenu; nmhdr.code = code; return (BOOL32) SendMessage32A (GetParent32 (wndPtr->hwndSelf), WM_NOTIFY, (WPARAM32)nmhdr.idFrom, (LPARAM)&nmhdr); } static BOOL32 TREEVIEW_SendTreeviewNotify (WND *wndPtr, UINT32 code, UINT32 action, INT32 oldItem, INT32 newItem) { TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr); NMTREEVIEW32A nmhdr; TREEVIEW_ITEM *wineItem; TRACE (treeview,"code:%x action:%x olditem:%x newitem:%x\n", code,action,oldItem,newItem); nmhdr.hdr.hwndFrom = wndPtr->hwndSelf; nmhdr.hdr.idFrom = wndPtr->wIDmenu; nmhdr.hdr.code = code; nmhdr.action = action; if (oldItem) { wineItem=& infoPtr->items[oldItem]; nmhdr.itemOld.mask = wineItem->mask; nmhdr.itemOld.hItem = wineItem->hItem; nmhdr.itemOld.state = wineItem->state; nmhdr.itemOld.stateMask = wineItem->stateMask; nmhdr.itemOld.iImage = wineItem->iImage; nmhdr.itemOld.pszText = wineItem->pszText; 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; } if (newItem) { wineItem=& infoPtr->items[newItem]; nmhdr.itemNew.mask = wineItem->mask; nmhdr.itemNew.hItem = wineItem->hItem; nmhdr.itemNew.state = wineItem->state; nmhdr.itemNew.stateMask = wineItem->stateMask; nmhdr.itemNew.iImage = wineItem->iImage; nmhdr.itemNew.pszText = wineItem->pszText; 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.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; return (BOOL32)SendMessage32A (GetParent32 (wndPtr->hwndSelf), WM_NOTIFY, (WPARAM32)wndPtr->wIDmenu, (LPARAM)&nmhdr); } 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, *parentItem; UINT32 flag; INT32 expand; flag= (UINT32) wParam; 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) flag |= TVE_COLLAPSE; else flag |= TVE_EXPAND; } switch (flag) { case TVE_COLLAPSERESET: if (!wineItem->state & TVIS_EXPANDED) return 0; wineItem->state &= ~(TVIS_EXPANDEDONCE | TVIS_EXPANDED); TREEVIEW_RemoveAllChildren (wndPtr, wineItem); break; case TVE_COLLAPSE: if (!wineItem->state & TVIS_EXPANDED) return 0; wineItem->state &= ~TVIS_EXPANDED; break; 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, expand)) return FALSE; /* FIXME: OK? */ wineItem->state |= TVIS_EXPANDED | TVIS_EXPANDEDONCE; TREEVIEW_SendTreeviewNotify (wndPtr, TVN_ITEMEXPANDED, 0, 0, expand); } wineItem->state |= TVIS_EXPANDED; break; case TVE_EXPANDPARTIAL: FIXME (treeview, "TVE_EXPANDPARTIAL not implemented\n"); wineItem->state ^=TVIS_EXPANDED; wineItem->state |=TVIS_EXPANDEDONCE; break; } TREEVIEW_QueueRefresh (wndPtr); return TRUE; } static TREEVIEW_ITEM * TREEVIEW_HitTest (WND *wndPtr, POINT32 pt) { TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr); TREEVIEW_ITEM *wineItem; RECT32 rect; GetClientRect32 (wndPtr->hwndSelf, &rect); if (!infoPtr->firstVisible) return NULL; wineItem=&infoPtr->items [infoPtr->firstVisible]; while ((wineItem!=NULL) && (pt.y > wineItem->rect.bottom)) wineItem=TREEVIEW_GetNextListItem (infoPtr,wineItem); 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 (xrect.left+10) lpht->flags|=TVHT_ONITEMBUTTON; lpht->flags=TVHT_ONITEMLABEL; /* FIXME: implement other flags */ lpht->hItem=wineItem->hItem; return (LRESULT) wineItem->hItem; } LRESULT TREEVIEW_LButtonDoubleClick (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) { TREEVIEW_ITEM *wineItem; POINT32 pt; TRACE (treeview,"\n"); pt.x = (INT32)LOWORD(lParam); pt.y = (INT32)HIWORD(lParam); SetFocus32 (wndPtr->hwndSelf); 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) wineItem->hItem); } return TRUE; } static LRESULT TREEVIEW_LButtonDown (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) { TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr); INT32 iItem; TVHITTESTINFO ht; ht.pt.x = (INT32)LOWORD(lParam); ht.pt.y = (INT32)HIWORD(lParam); SetFocus32 (wndPtr->hwndSelf); 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_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; } static LRESULT TREEVIEW_MouseMove (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) { TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr); TREEVIEW_ITEM *hotItem; POINT32 pt; 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) { 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: 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; if (wineItem) wineItem->state |=TVIS_SELECTED; if (newSelect) TREEVIEW_SendTreeviewNotify (wndPtr, TVN_SELCHANGED, cause, prevSelect, newSelect); break; case TVGN_DROPHILITE: 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\n"); break; } TREEVIEW_QueueRefresh (wndPtr); return TRUE; } static LRESULT TREEVIEW_SelectItem (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) { return TREEVIEW_DoSelectItem (wndPtr, wParam, (HTREEITEM) lParam, TVC_UNKNOWN); } static LRESULT TREEVIEW_GetFont (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) { TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr); TRACE (treeview,"%x\n",infoPtr->hFont); return infoPtr->hFont; } static LRESULT TREEVIEW_SetFont (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) { TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr); TEXTMETRIC32A tm; LOGFONT32A logFont; HFONT32 hFont, hOldFont; INT32 height; HDC32 hdc; TRACE (treeview,"%x %lx\n",wParam, lParam); infoPtr->hFont = (HFONT32)wParam; 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); height= tm.tmHeight + tm.tmExternalLeading; if (height>infoPtr->uRealItemHeight) infoPtr->uRealItemHeight=height; SelectObject32 (hdc, hOldFont); ReleaseDC32 (0, hdc); if (lParam) TREEVIEW_QueueRefresh (wndPtr); return 0; } /* FIXME: does KEYDOWN also send notifications?? If so, use TREEVIEW_DoSelectItem. */ static LRESULT TREEVIEW_KeyDown (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) { TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr); TREEVIEW_ITEM *prevItem,*newItem; int prevSelect; TRACE (treeview,"%x %lx\n",wParam, lParam); prevSelect=infoPtr->selectedItem; if (!prevSelect) return FALSE; prevItem= TREEVIEW_ValidItem (infoPtr, prevSelect); newItem=NULL; switch (wParam) { case VK_UP: newItem=TREEVIEW_GetPrevListItem (infoPtr, prevItem); if (!newItem) newItem=& infoPtr->items[infoPtr->TopRootItem]; break; case VK_DOWN: newItem=TREEVIEW_GetNextListItem (infoPtr, prevItem); if (!newItem) newItem=prevItem; break; case VK_HOME: newItem=& infoPtr->items[infoPtr->TopRootItem]; break; case VK_END: newItem=& infoPtr->items[infoPtr->TopRootItem]; newItem=TREEVIEW_GetLastListItem (infoPtr, newItem); break; case VK_PRIOR: case VK_NEXT: case VK_BACK: case VK_RETURN: FIXME (treeview, "%x not implemented\n", wParam); break; } if (!newItem) return FALSE; if (prevItem!=newItem) { prevItem->state &= ~TVIS_SELECTED; newItem->state |= TVIS_SELECTED; infoPtr->selectedItem=newItem->hItem; TREEVIEW_QueueRefresh (wndPtr); return TRUE; } return FALSE; } static LRESULT TREEVIEW_VScroll (WND *wndPtr, WPARAM32 wParam, LPARAM lParam) { TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(wndPtr); int maxHeight; TRACE (treeview,"wp %x, lp %lx\n", wParam, lParam); if (!infoPtr->uInternalStatus & TV_VSCROLL) return FALSE; switch (LOWORD (wParam)) { case SB_LINEUP: if (!infoPtr->cy) return FALSE; infoPtr->cy -= infoPtr->uRealItemHeight; if (infoPtr->cy < 0) infoPtr->cy=0; break; case SB_LINEDOWN: maxHeight=infoPtr->uTotalHeight-infoPtr->uVisibleHeight; if (infoPtr->cy == maxHeight) return FALSE; infoPtr->cy += infoPtr->uRealItemHeight; if (infoPtr->cy > maxHeight) infoPtr->cy = maxHeight; break; case SB_PAGEUP: if (!infoPtr->cy) return FALSE; infoPtr->cy -= infoPtr->uVisibleHeight; if (infoPtr->cy < 0) infoPtr->cy=0; break; case SB_PAGEDOWN: maxHeight=infoPtr->uTotalHeight-infoPtr->uVisibleHeight; if (infoPtr->cy == maxHeight) return FALSE; infoPtr->cy += infoPtr->uVisibleHeight; if (infoPtr->cy > maxHeight) infoPtr->cy = maxHeight; break; case SB_THUMBTRACK: infoPtr->cy = HIWORD (wParam); break; } TREEVIEW_QueueRefresh (wndPtr); return TRUE; } static LRESULT 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; } LRESULT WINAPI TREEVIEW_WindowProc (HWND32 hwnd, UINT32 uMsg, WPARAM32 wParam, LPARAM lParam) { WND *wndPtr = WIN_FindWndPtr(hwnd); switch (uMsg) { case TVM_INSERTITEM32A: return TREEVIEW_InsertItem32A (wndPtr, wParam, lParam); case TVM_INSERTITEM32W: FIXME (treeview, "Unimplemented msg TVM_INSERTITEM32W\n"); return 0; case TVM_DELETEITEM: return TREEVIEW_DeleteItem (wndPtr, wParam, lParam); case TVM_EXPAND: return TREEVIEW_Expand (wndPtr, wParam, lParam); case TVM_GETITEMRECT: return TREEVIEW_GetItemRect (wndPtr, wParam, lParam); case TVM_GETCOUNT: return TREEVIEW_GetCount (wndPtr, wParam, lParam); case TVM_GETINDENT: return TREEVIEW_GetIndent (wndPtr); case TVM_SETINDENT: return TREEVIEW_SetIndent (wndPtr, wParam); case TVM_GETIMAGELIST: return TREEVIEW_GetImageList (wndPtr, wParam, lParam); case TVM_SETIMAGELIST: return TREEVIEW_SetImageList (wndPtr, wParam, lParam); case TVM_GETNEXTITEM: return TREEVIEW_GetNextItem (wndPtr, wParam, lParam); case TVM_SELECTITEM: return TREEVIEW_SelectItem (wndPtr, wParam, lParam); case TVM_GETITEM32A: return TREEVIEW_GetItem32A (wndPtr, wParam, lParam); case TVM_GETITEM32W: FIXME (treeview, "Unimplemented msg TVM_GETITEM32W\n"); return 0; case TVM_SETITEM32A: return TREEVIEW_SetItem32A (wndPtr, wParam, lParam); case TVM_SETITEM32W: FIXME (treeview, "Unimplemented msg TVM_SETITEMW\n"); return 0; case TVM_EDITLABEL32A: FIXME (treeview, "Unimplemented msg TVM_EDITLABEL32A \n"); return 0; case TVM_EDITLABEL32W: FIXME (treeview, "Unimplemented msg TVM_EDITLABEL32W \n"); return 0; case TVM_GETEDITCONTROL: return TREEVIEW_GetEditControl (wndPtr); case TVM_GETVISIBLECOUNT: return TREEVIEW_GetVisibleCount (wndPtr, wParam, lParam); case TVM_HITTEST: return TREEVIEW_HitTest32 (wndPtr, lParam); case TVM_CREATEDRAGIMAGE: return TREEVIEW_CreateDragImage (wndPtr, wParam, lParam); case TVM_SORTCHILDREN: FIXME (treeview, "Unimplemented msg TVM_SORTCHILDREN\n"); return 0; case TVM_ENSUREVISIBLE: FIXME (treeview, "Unimplemented msg TVM_ENSUREVISIBLE\n"); return 0; case TVM_SORTCHILDRENCB: FIXME (treeview, "Unimplemented msg TVM_SORTCHILDRENCB\n"); return 0; case TVM_ENDEDITLABELNOW: FIXME (treeview, "Unimplemented msg TVM_ENDEDITLABELNOW\n"); return 0; case TVM_GETISEARCHSTRING32A: FIXME (treeview, "Unimplemented msg TVM_GETISEARCHSTRING32A\n"); return 0; case TVM_GETISEARCHSTRING32W: FIXME (treeview, "Unimplemented msg TVM_GETISEARCHSTRING32W\n"); return 0; case TVM_GETTOOLTIPS: return TREEVIEW_GetToolTips (wndPtr); case TVM_SETTOOLTIPS: return TREEVIEW_SetToolTips (wndPtr, wParam); case TVM_SETINSERTMARK: FIXME (treeview, "Unimplemented msg TVM_SETINSERTMARK\n"); return 0; case TVM_SETITEMHEIGHT: return TREEVIEW_SetItemHeight (wndPtr, wParam); case TVM_GETITEMHEIGHT: return TREEVIEW_GetItemHeight (wndPtr); case TVM_SETBKCOLOR: return TREEVIEW_SetBkColor (wndPtr, wParam, lParam); case TVM_SETTEXTCOLOR: return TREEVIEW_SetTextColor (wndPtr, wParam, lParam); case TVM_GETBKCOLOR: return TREEVIEW_GetBkColor (wndPtr); case TVM_GETTEXTCOLOR: return TREEVIEW_GetTextColor (wndPtr); case TVM_SETSCROLLTIME: FIXME (treeview, "Unimplemented msg TVM_SETSCROLLTIME\n"); return 0; case TVM_GETSCROLLTIME: FIXME (treeview, "Unimplemented msg TVM_GETSCROLLTIME\n"); return 0; case TVM_SETINSERTMARKCOLOR: FIXME (treeview, "Unimplemented msg TVM_SETINSERTMARKCOLOR\n"); return 0; case TVM_SETUNICODEFORMAT: FIXME (treeview, "Unimplemented msg TVM_SETUNICODEFORMAT\n"); return 0; case TVM_GETUNICODEFORMAT: FIXME (treeview, "Unimplemented msg TVM_GETUNICODEFORMAT\n"); return 0; case WM_COMMAND: return TREEVIEW_Command (wndPtr, wParam, lParam); case WM_CREATE: return TREEVIEW_Create (wndPtr, wParam, lParam); case WM_DESTROY: return TREEVIEW_Destroy (wndPtr); /* case WM_ENABLE: */ case WM_ERASEBKGND: return TREEVIEW_EraseBackground (wndPtr, wParam, lParam); case WM_GETDLGCODE: return DLGC_WANTARROWS | DLGC_WANTCHARS; case WM_PAINT: return TREEVIEW_Paint (wndPtr, wParam, lParam); case WM_GETFONT: return TREEVIEW_GetFont (wndPtr, wParam, lParam); case WM_SETFONT: return TREEVIEW_SetFont (wndPtr, wParam, lParam); case WM_KEYDOWN: return TREEVIEW_KeyDown (wndPtr, wParam, lParam); 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: return TREEVIEW_StyleChanged (wndPtr, wParam, lParam); /* case WM_SETREDRAW: */ case WM_TIMER: return TREEVIEW_HandleTimer (wndPtr, wParam, lParam); 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", uMsg, wParam, lParam); return DefWindowProc32A (hwnd, uMsg, wParam, lParam); } return 0; } VOID TREEVIEW_Register (VOID) { WNDCLASS32A wndClass; TRACE (treeview,"\n"); if (GlobalFindAtom32A (WC_TREEVIEW32A)) return; ZeroMemory (&wndClass, sizeof(WNDCLASS32A)); wndClass.style = CS_GLOBALCLASS | CS_DBLCLKS; wndClass.lpfnWndProc = (WNDPROC32)TREEVIEW_WindowProc; wndClass.cbClsExtra = 0; wndClass.cbWndExtra = sizeof(TREEVIEW_INFO *); wndClass.hCursor = LoadCursor32A (0, IDC_ARROW32A); wndClass.hbrBackground = 0; wndClass.lpszClassName = WC_TREEVIEW32A; RegisterClass32A (&wndClass); } VOID TREEVIEW_Unregister (VOID) { if (GlobalFindAtom32A (WC_TREEVIEW32A)) UnregisterClass32A (WC_TREEVIEW32A, (HINSTANCE32)NULL); }