1088 lines
27 KiB
C
1088 lines
27 KiB
C
#include "ctlspriv.h"
|
|
#include "treeview.h"
|
|
|
|
BOOL NEAR TV_EnsureVisible(PTREE pTree, TREEITEM FAR * hItem);
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
// Updates the iShownIndex for every item below (in list order) a given item
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
int NEAR TV_UpdateShownIndexes(PTREE pTree, HTREEITEM hWalk)
|
|
{
|
|
WORD iShownIndex;
|
|
|
|
if (hWalk == pTree->hRoot) {
|
|
hWalk = pTree->hRoot->hKids;
|
|
if (hWalk) {
|
|
hWalk->iShownIndex = 0;
|
|
} else {
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
iShownIndex = hWalk->iShownIndex + 1;
|
|
if (iShownIndex <= 0)
|
|
{
|
|
// BUGBUG: We should #define the special TVITEM_HIDDEN value and check
|
|
// for it explicitly
|
|
// This can happen if TV_SortCB passes in a hidden item
|
|
return(-1);
|
|
}
|
|
|
|
while ((hWalk = TV_GetNextVisItem(hWalk)) != NULL)
|
|
hWalk->iShownIndex = iShownIndex++;
|
|
|
|
//#ifdef DEBUG
|
|
// DebugMsg(DM_TRACE, "tv: updated show indexes (now %d items)", (int)iShownIndex);
|
|
//#endif
|
|
return (int)iShownIndex;
|
|
}
|
|
|
|
|
|
// in:
|
|
// hItem expanded node to count decendants of
|
|
|
|
// returns:
|
|
// total number of expanded descendants below the given item.
|
|
|
|
|
|
UINT NEAR TV_CountVisibleDescendants(HTREEITEM hItem)
|
|
{
|
|
UINT cnt;
|
|
|
|
for (cnt = 0, hItem = hItem->hKids; hItem; hItem = hItem->hNext)
|
|
{
|
|
cnt++;
|
|
if (hItem->hKids && (hItem->state & TVIS_EXPANDED))
|
|
cnt += TV_CountVisibleDescendants(hItem);
|
|
}
|
|
return cnt;
|
|
}
|
|
|
|
|
|
|
|
UINT NEAR TV_ScrollBelow(PTREE pTree, HTREEITEM hItem, BOOL fRedrawParent, BOOL fDown)
|
|
{
|
|
RECT rc;
|
|
int iTop;
|
|
UINT cnt;
|
|
|
|
// Do nothing if the item is not visible
|
|
if (!ITEM_VISIBLE(hItem))
|
|
return 0;
|
|
|
|
iTop = hItem->iShownIndex - pTree->hTop->iShownIndex;
|
|
|
|
rc.left = 0;
|
|
rc.top = iTop * pTree->cyItem;
|
|
rc.right = pTree->cxWnd;
|
|
rc.bottom = pTree->cyWnd;
|
|
if (pTree->fRedraw)
|
|
InvalidateRect(pTree->hwnd, &rc, TRUE);
|
|
|
|
if (fRedrawParent)
|
|
{
|
|
cnt = TV_CountVisibleDescendants(hItem);
|
|
}
|
|
else
|
|
{
|
|
cnt = 1;
|
|
}
|
|
|
|
return(cnt);
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
// Returns the width of the widest shown item in the tree
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
UINT NEAR TV_RecomputeMaxWidth(PTREE pTree)
|
|
{
|
|
HTREEITEM hItem;
|
|
WORD wMax = 0;
|
|
|
|
// REVIEW: this might not be the most efficient traversal of the tree
|
|
|
|
for (hItem = pTree->hRoot->hKids; hItem; hItem = TV_GetNextVisItem(hItem))
|
|
{
|
|
if (wMax < FULL_WIDTH(pTree, hItem))
|
|
wMax = FULL_WIDTH(pTree, hItem);
|
|
}
|
|
|
|
return((UINT)wMax);
|
|
}
|
|
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
// Returns the horizontal text extent of the given item's text
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
WORD NEAR TV_GetItemTextWidth(HDC hdc, PTREE pTree, HTREEITEM hItem)
|
|
{
|
|
TV_ITEM sItem;
|
|
char szTemp[MAX_PATH];
|
|
SIZE size = {0,0};
|
|
|
|
sItem.pszText = szTemp;
|
|
sItem.cchTextMax = sizeof(szTemp);
|
|
|
|
TV_GetItem(pTree, hItem, TVIF_TEXT, &sItem);
|
|
|
|
GetTextExtentPoint(hdc, sItem.pszText, lstrlen(sItem.pszText), &size);
|
|
return size.cx + (g_cxLabelMargin * 2);
|
|
}
|
|
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
// Compute the text extent and the full width (indent, image, and text) of
|
|
// the given item.
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
void NEAR TV_ComputeItemWidth(PTREE pTree, HTREEITEM hItem, HDC hdc)
|
|
{
|
|
HDC hdcToUse;
|
|
HFONT hOldFont;
|
|
TV_ITEM sItem;
|
|
|
|
if (hdc == NULL) {
|
|
HFONT hFont;
|
|
// compute text width and full width
|
|
hdcToUse = GetDC(pTree->hwnd);
|
|
sItem.stateMask = TVIS_BOLD;
|
|
TV_GetItem(pTree, hItem, TVIF_STATE, &sItem);
|
|
hFont = sItem.state & TVIS_BOLD
|
|
? pTree->hFontBold : pTree->hFont;
|
|
hOldFont = (hFont) ? SelectObject(hdcToUse, hFont) : NULL;
|
|
}
|
|
else
|
|
{
|
|
hdcToUse = hdc;
|
|
}
|
|
hItem->iWidth = TV_GetItemTextWidth(hdcToUse, pTree, hItem);
|
|
|
|
if (hdc == NULL)
|
|
{
|
|
if (hOldFont)
|
|
SelectObject(hdcToUse, hOldFont);
|
|
ReleaseDC(pTree->hwnd, hdcToUse);
|
|
}
|
|
}
|
|
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
// Returns TRUE if the item is expanded, FALSE otherwise
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
BOOL NEAR TV_IsShowing(HTREEITEM hItem)
|
|
{
|
|
for (hItem = hItem->hParent; hItem; hItem = hItem->hParent)
|
|
if (!(hItem->state & TVIS_EXPANDED))
|
|
return FALSE;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
// If the added item is showing, update the shown (expanded) count, the max
|
|
// item width -- then recompute the scroll bars.
|
|
|
|
// sets cxMax, cShowing
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
BOOL NEAR TV_ScrollBarsAfterAdd(PTREE pTree, HTREEITEM hItem)
|
|
{
|
|
HTREEITEM hPrev;
|
|
|
|
if (!TV_IsShowing(hItem))
|
|
{
|
|
// item isn't visible -- set index to NOTVISIBLE and return
|
|
hItem->iShownIndex = (WORD)-1;
|
|
return FALSE;
|
|
}
|
|
|
|
hPrev = TV_GetPrevVisItem(hItem);
|
|
|
|
// increment every shown index after newly added item
|
|
|
|
hItem->iShownIndex = (hPrev) ? hPrev->iShownIndex + 1 : 0;
|
|
|
|
TV_UpdateShownIndexes(pTree, hItem);
|
|
|
|
pTree->cShowing++;
|
|
|
|
TV_ComputeItemWidth(pTree, hItem, NULL);
|
|
|
|
if (pTree->cxMax < FULL_WIDTH(pTree, hItem))
|
|
pTree->cxMax = FULL_WIDTH(pTree, hItem);
|
|
|
|
TV_CalcScrollBars(pTree);
|
|
return(TRUE);
|
|
}
|
|
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
// If the removed item was showing, update the shown (expanded) count, the max
|
|
// item width -- then recompute the scroll bars.
|
|
|
|
// sets cxMax, cShowing
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
BOOL NEAR TV_ScrollBarsAfterRemove(PTREE pTree, HTREEITEM hItem)
|
|
{
|
|
HTREEITEM hWalk;
|
|
if (!ITEM_VISIBLE(hItem))
|
|
return FALSE;
|
|
|
|
// decrement every shown index after removed item
|
|
hItem->iShownIndex = (WORD)-1;
|
|
|
|
hWalk = TV_GetNextVisItem(hItem);
|
|
if (hWalk) {
|
|
--hWalk->iShownIndex;
|
|
TV_UpdateShownIndexes(pTree, hWalk);
|
|
|
|
// If we delete the top item, the tree scrolls to the end, so ...
|
|
if (pTree->hTop == hItem) {
|
|
TV_SetTopItem(pTree, hWalk->iShownIndex);
|
|
Assert(pTree->hTop != hItem);
|
|
}
|
|
}
|
|
|
|
pTree->cShowing--;
|
|
|
|
if (pTree->fRedraw) {
|
|
if (!hItem->iWidth)
|
|
TV_ComputeItemWidth(pTree, hItem, NULL);
|
|
|
|
if (pTree->cxMax == FULL_WIDTH(pTree, hItem))
|
|
pTree->cxMax = TV_RecomputeMaxWidth(pTree);
|
|
|
|
TV_CalcScrollBars(pTree);
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
// If the expanded items are showing, update the shown (expanded) count,
|
|
// the max item width -- then recompute the scroll bars.
|
|
|
|
// sets cxMax, cShowing
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
BOOL NEAR TV_ScrollBarsAfterExpand(PTREE pTree, HTREEITEM hParent)
|
|
{
|
|
WORD cxMax = 0;
|
|
HTREEITEM hWalk;
|
|
|
|
if (!ITEM_VISIBLE(hParent))
|
|
return FALSE;
|
|
|
|
for (hWalk = hParent->hKids;
|
|
hWalk && (hWalk->iLevel > hParent->iLevel);
|
|
hWalk = TV_GetNextVisItem(hWalk))
|
|
{
|
|
if (!hWalk->iWidth)
|
|
TV_ComputeItemWidth(pTree, hWalk, NULL);
|
|
if (cxMax < FULL_WIDTH(pTree, hWalk))
|
|
cxMax = FULL_WIDTH(pTree, hWalk);
|
|
}
|
|
|
|
// update every shown index after expanded parent
|
|
pTree->cShowing = TV_UpdateShownIndexes(pTree, hParent);
|
|
|
|
if (cxMax > pTree->cxMax)
|
|
pTree->cxMax = cxMax;
|
|
|
|
TV_CalcScrollBars(pTree);
|
|
return(TRUE);
|
|
}
|
|
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
// If the collapsed items were showing, update the shown (expanded) count,
|
|
// the max item width -- then recompute the scroll bars.
|
|
|
|
// sets cxMax, cShowing
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
BOOL NEAR TV_ScrollBarsAfterCollapse(PTREE pTree, HTREEITEM hParent)
|
|
{
|
|
WORD cxMax = 0;
|
|
HTREEITEM hWalk;
|
|
|
|
if (!ITEM_VISIBLE(hParent))
|
|
return FALSE;
|
|
|
|
for (hWalk = hParent->hKids;
|
|
hWalk && (hWalk->iLevel > hParent->iLevel);
|
|
hWalk = TV_GetNextVisItem(hWalk))
|
|
{
|
|
hWalk->iShownIndex = (WORD)-1;
|
|
if (!hWalk->iWidth)
|
|
TV_ComputeItemWidth(pTree, hWalk, NULL);
|
|
if (cxMax < FULL_WIDTH(pTree, hWalk))
|
|
cxMax = FULL_WIDTH(pTree, hWalk);
|
|
}
|
|
|
|
// update every shown index after expanded parent
|
|
pTree->cShowing = TV_UpdateShownIndexes(pTree, hParent);
|
|
|
|
if (cxMax == pTree->cxMax)
|
|
pTree->cxMax = TV_RecomputeMaxWidth(pTree);
|
|
|
|
TV_CalcScrollBars(pTree);
|
|
return(TRUE);
|
|
}
|
|
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
// Returns the item just below the given item in the tree.
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
TREEITEM FAR * NEAR TV_GetNext(TREEITEM FAR * hItem)
|
|
{
|
|
ValidateTreeItem(hItem, FALSE);
|
|
|
|
if (hItem->hKids)
|
|
return hItem->hKids;
|
|
|
|
checkNext:
|
|
if (hItem->hNext)
|
|
return hItem->hNext;
|
|
|
|
hItem = hItem->hParent;
|
|
if (hItem)
|
|
goto checkNext;
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
// Go through all the items in the tree, recomputing each item's text extent
|
|
// and full width (indent, image, and text).
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
void NEAR TV_RecomputeItemWidths(PTREE pTree)
|
|
{
|
|
HDC hdc = GetDC(pTree->hwnd);
|
|
HFONT hOldFont = NULL;
|
|
HTREEITEM hItem = pTree->hRoot->hKids;
|
|
|
|
if (pTree->hFont)
|
|
hOldFont = SelectObject(hdc, pTree->hFont);
|
|
|
|
while (hItem)
|
|
{
|
|
|
|
//BUGBUG: Optimize TV_ComputeItemWidth so it
|
|
// can be called every time.
|
|
|
|
|
|
if (hItem->state & TVIS_BOLD)
|
|
TV_ComputeItemWidth(pTree, hItem, NULL);
|
|
else
|
|
hItem->iWidth = TV_GetItemTextWidth(hdc, pTree, hItem);
|
|
hItem = TV_GetNext(hItem);
|
|
}
|
|
|
|
if (hOldFont)
|
|
SelectObject(hdc, hOldFont);
|
|
|
|
ReleaseDC(pTree->hwnd, hdc);
|
|
}
|
|
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
// If a single item's width changed, alter the max width if needed.
|
|
// If all widths changed, recompute widths and max width.
|
|
// Then recompute the scroll bars.
|
|
|
|
// sets cxMax
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
BOOL NEAR TV_ScrollBarsAfterSetWidth(PTREE pTree, HTREEITEM hItem)
|
|
{
|
|
if (hItem)
|
|
{
|
|
UINT iOldWidth = FULL_WIDTH(pTree, hItem);
|
|
TV_ComputeItemWidth(pTree, hItem, NULL);
|
|
|
|
if (pTree->cxMax < FULL_WIDTH(pTree, hItem))
|
|
pTree->cxMax = FULL_WIDTH(pTree, hItem);
|
|
else if (pTree->cxMax == iOldWidth)
|
|
pTree->cxMax = TV_RecomputeMaxWidth(pTree);
|
|
else
|
|
return(FALSE);
|
|
}
|
|
else
|
|
{
|
|
TV_RecomputeItemWidths(pTree);
|
|
pTree->cxMax = TV_RecomputeMaxWidth(pTree);
|
|
}
|
|
|
|
TV_CalcScrollBars(pTree);
|
|
return(TRUE);
|
|
}
|
|
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
// Scroll window vertically as needed to make given item fully visible
|
|
// vertically
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
BOOL NEAR TV_ScrollVertIntoView(PTREE pTree, HTREEITEM hItem)
|
|
{
|
|
// Do nothing if this item is not visible
|
|
if (!ITEM_VISIBLE(hItem))
|
|
return FALSE;
|
|
|
|
if (hItem->iShownIndex < pTree->hTop->iShownIndex)
|
|
return(TV_SetTopItem(pTree, hItem->iShownIndex));
|
|
|
|
if (hItem->iShownIndex >= (pTree->hTop->iShownIndex + pTree->cFullVisible))
|
|
return(TV_SetTopItem(pTree, hItem->iShownIndex + 1 - pTree->cFullVisible));
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
// Scroll window vertically and horizontally as needed to make given item
|
|
// fully visible vertically and horizontally
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
BOOL NEAR TV_ScrollIntoView(PTREE pTree, HTREEITEM hItem)
|
|
{
|
|
UINT iWidth, iOffset;
|
|
BOOL fChange;
|
|
|
|
fChange = TV_ScrollVertIntoView(pTree, hItem);
|
|
|
|
// ensure that item's text is fully visible horizontally
|
|
iWidth = pTree->cxImage + pTree->cxState + hItem->iWidth;
|
|
if (iWidth > (UINT)pTree->cxWnd)
|
|
iWidth = pTree->cxWnd; //hItem->iWidth;
|
|
|
|
iOffset = ITEM_OFFSET(pTree, hItem);
|
|
|
|
if ((int) (iOffset) < pTree->xPos)
|
|
fChange |= TV_SetLeft(pTree, iOffset);
|
|
else if ((iOffset + iWidth) > (UINT)(pTree->xPos + pTree->cxWnd))
|
|
fChange |= TV_SetLeft(pTree, iOffset + iWidth - pTree->cxWnd);
|
|
|
|
return fChange;
|
|
}
|
|
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
// Sets position of horizontal scroll bar and scrolls window to match that
|
|
// position
|
|
|
|
// sets xPos
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
BOOL NEAR TV_SetLeft(PTREE pTree, int x)
|
|
{
|
|
if (!pTree->fHorz)
|
|
return(FALSE);
|
|
|
|
if (x > (int) (pTree->cxMax - pTree->cxWnd))
|
|
x = (pTree->cxMax - pTree->cxWnd);
|
|
if (x < 0)
|
|
x = 0;
|
|
|
|
if (x == pTree->xPos)
|
|
return(FALSE);
|
|
|
|
if (pTree->fRedraw) {
|
|
ScrollWindowEx(pTree->hwnd, pTree->xPos - x, 0, NULL, NULL, NULL, NULL, SW_INVALIDATE | SW_ERASE);
|
|
}
|
|
|
|
pTree->xPos = x;
|
|
|
|
SetScrollPos(pTree->hwnd, SB_HORZ, x, TRUE);
|
|
|
|
return(TRUE);
|
|
}
|
|
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
// Returns the tree's item that has the given shown index, NULL if no item
|
|
// found with that index.
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
HTREEITEM NEAR TV_GetShownIndexItem(HTREEITEM hItem, UINT wShownIndex)
|
|
{
|
|
HTREEITEM hWalk;
|
|
|
|
if (hItem == NULL)
|
|
return NULL;
|
|
|
|
Assert((int)wShownIndex >= 0);
|
|
|
|
for (hWalk = hItem->hNext;
|
|
hWalk && (hWalk->iShownIndex <= wShownIndex);
|
|
hWalk = hWalk->hNext)
|
|
hItem = hWalk;
|
|
|
|
if (hItem->iShownIndex == wShownIndex)
|
|
return hItem;
|
|
|
|
// Assert(hItem->hKids == NULL);
|
|
|
|
return TV_GetShownIndexItem(hItem->hKids, wShownIndex);
|
|
}
|
|
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
// Sets position of vertical scroll bar and scrolls window to match that
|
|
// position
|
|
|
|
// sets hTop
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
BOOL NEAR TV_SetTopItem(PTREE pTree, UINT wNewTop)
|
|
{
|
|
HTREEITEM hItem = pTree->hRoot->hKids;
|
|
UINT wOldTop;
|
|
|
|
if (!hItem)
|
|
return FALSE;
|
|
|
|
if ((wNewTop == (UINT)-1) || (pTree->cShowing <= pTree->cFullVisible)) {
|
|
// we've wrapped around (treat as a negative index) -- use min pos
|
|
// or there aren't enough items to scroll
|
|
wNewTop = 0;
|
|
} else if (wNewTop > (UINT)(pTree->cShowing - pTree->cFullVisible)) {
|
|
// we've gone too far down -- use max pos
|
|
wNewTop = (pTree->cShowing - pTree->cFullVisible);
|
|
|
|
}
|
|
|
|
// if there's no room for anything to show. peg at the end
|
|
if (wNewTop > 0 && wNewTop >= pTree->cShowing) {
|
|
wNewTop = pTree->cShowing - 1;
|
|
}
|
|
|
|
|
|
hItem = TV_GetShownIndexItem(hItem, wNewTop);
|
|
|
|
Assert(hItem);
|
|
|
|
if (pTree->hTop == hItem)
|
|
return FALSE;
|
|
|
|
wOldTop = pTree->hTop->iShownIndex;
|
|
|
|
pTree->hTop = hItem;
|
|
|
|
if (pTree->fRedraw) {
|
|
ScrollWindowEx(pTree->hwnd, 0, (int) (wOldTop - wNewTop) * (int) pTree->cyItem,
|
|
NULL, NULL, NULL, NULL, SW_INVALIDATE | SW_ERASE);
|
|
}
|
|
|
|
SetScrollPos(pTree->hwnd, SB_VERT, wNewTop, TRUE);
|
|
|
|
return(TRUE);
|
|
}
|
|
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
// Computes the horizontal and vertical scroll bar ranges, pages, and
|
|
// positions, adding or removing the scroll bars as needed.
|
|
|
|
// sets fHorz, fVert
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
BOOL NEAR TV_CalcScrollBars(PTREE pTree)
|
|
{
|
|
// UINT wMaxPos;
|
|
BOOL fChange = FALSE;
|
|
SCROLLINFO si;
|
|
|
|
si.cbSize = sizeof(SCROLLINFO);
|
|
|
|
if ((SHORT)pTree->cxMax > (SHORT)pTree->cxWnd)
|
|
{
|
|
if (!pTree->fHorz)
|
|
{
|
|
fChange = TRUE;
|
|
pTree->fHorz = TRUE;
|
|
}
|
|
|
|
si.fMask = SIF_PAGE | SIF_RANGE;
|
|
si.nMin = 0;
|
|
si.nMax = pTree->cxMax - 1;
|
|
si.nPage = pTree->cxWnd;
|
|
|
|
#ifdef IEWIN31_25
|
|
SetScrollRange(pTree->hwnd, SB_HORZ, (int)si.nMin, (int)(si.nMax-si.nPage+1), TRUE);
|
|
TV_SetLeft(pTree, GetScrollPos( pTree->hwnd, SB_HORZ));
|
|
#else
|
|
TV_SetLeft(pTree, (UINT)SetScrollInfo(pTree->hwnd, SB_HORZ, &si, TRUE));
|
|
#endif
|
|
}
|
|
else if (pTree->fHorz)
|
|
{
|
|
TV_SetLeft(pTree, 0);
|
|
SetScrollRange(pTree->hwnd, SB_HORZ, 0, 0, TRUE);
|
|
|
|
pTree->fHorz = FALSE;
|
|
fChange = TRUE;
|
|
}
|
|
|
|
if (pTree->cShowing > pTree->cFullVisible)
|
|
{
|
|
if (!pTree->fVert)
|
|
{
|
|
pTree->fVert = TRUE;
|
|
fChange = TRUE;
|
|
}
|
|
|
|
si.fMask = SIF_PAGE | SIF_RANGE;
|
|
si.nMin = 0;
|
|
si.nMax = pTree->cShowing - 1;
|
|
si.nPage = pTree->cFullVisible;
|
|
|
|
#ifdef IEWIN31_25
|
|
SetScrollRange(pTree->hwnd, SB_VERT, (int)si.nMin, (int)(si.nMax-si.nPage+1), TRUE);
|
|
TV_SetTopItem(pTree, GetScrollPos( pTree->hwnd, SB_VERT));
|
|
#else
|
|
TV_SetTopItem(pTree, (UINT)SetScrollInfo(pTree->hwnd, SB_VERT, &si, TRUE));
|
|
#endif
|
|
|
|
}
|
|
else if (pTree->fVert)
|
|
{
|
|
TV_SetTopItem(pTree, 0);
|
|
SetScrollRange(pTree->hwnd, SB_VERT, 0, 0, TRUE);
|
|
|
|
pTree->fVert = FALSE;
|
|
fChange = TRUE;
|
|
}
|
|
|
|
if (fChange)
|
|
TV_SizeWnd(pTree, 0, 0);
|
|
|
|
return(TRUE);
|
|
}
|
|
|
|
#define MAGIC_HORZLINE 5
|
|
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
// Handles horizontal scrolling.
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
BOOL NEAR TV_HorzScroll(PTREE pTree, UINT wCode, UINT wNewPos)
|
|
{
|
|
BOOL fChanged;
|
|
|
|
TV_DismissEdit(pTree, FALSE);
|
|
|
|
switch (wCode)
|
|
{
|
|
case SB_BOTTOM:
|
|
wNewPos = pTree->cxMax - pTree->cxWnd;
|
|
|
|
case SB_ENDSCROLL:
|
|
wNewPos = pTree->xPos;
|
|
break;
|
|
|
|
case SB_LINEDOWN:
|
|
wNewPos = pTree->xPos + MAGIC_HORZLINE;
|
|
break;
|
|
|
|
case SB_LINEUP:
|
|
wNewPos = pTree->xPos - MAGIC_HORZLINE;
|
|
break;
|
|
|
|
case SB_PAGEDOWN:
|
|
wNewPos = pTree->xPos + (pTree->cxWnd - MAGIC_HORZLINE);
|
|
break;
|
|
|
|
case SB_PAGEUP:
|
|
wNewPos = pTree->xPos - (pTree->cxWnd - MAGIC_HORZLINE);
|
|
break;
|
|
|
|
case SB_THUMBPOSITION:
|
|
case SB_THUMBTRACK:
|
|
break;
|
|
|
|
case SB_TOP:
|
|
wNewPos = 0;
|
|
break;
|
|
}
|
|
|
|
if (fChanged = TV_SetLeft(pTree, wNewPos))
|
|
UpdateWindow(pTree->hwnd);
|
|
|
|
return(fChanged);
|
|
}
|
|
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
// Handles vertical scrolling.
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
BOOL NEAR TV_VertScroll(PTREE pTree, UINT wCode, UINT wPos)
|
|
{
|
|
UINT wNewPos;
|
|
UINT wOldPos = pTree->hTop->iShownIndex;
|
|
BOOL fChanged;
|
|
|
|
TV_DismissEdit(pTree, FALSE);
|
|
|
|
switch (wCode)
|
|
{
|
|
case SB_BOTTOM:
|
|
wNewPos = pTree->cShowing - pTree->cFullVisible;
|
|
break;
|
|
|
|
case SB_ENDSCROLL:
|
|
wNewPos = wOldPos;
|
|
break;
|
|
|
|
case SB_LINEDOWN:
|
|
wNewPos = wOldPos + 1;
|
|
break;
|
|
|
|
case SB_LINEUP:
|
|
wNewPos = wOldPos - 1;
|
|
if (wNewPos > wOldPos)
|
|
wNewPos = 0;
|
|
break;
|
|
|
|
case SB_PAGEDOWN:
|
|
wNewPos = wOldPos + (pTree->cFullVisible - 1);
|
|
break;
|
|
|
|
case SB_PAGEUP:
|
|
wNewPos = wOldPos - (pTree->cFullVisible - 1);
|
|
if (wNewPos > wOldPos)
|
|
wNewPos = 0;
|
|
break;
|
|
|
|
case SB_THUMBPOSITION:
|
|
case SB_THUMBTRACK:
|
|
wNewPos = wPos;
|
|
break;
|
|
|
|
case SB_TOP:
|
|
wNewPos = 0;
|
|
break;
|
|
}
|
|
|
|
if (fChanged = TV_SetTopItem(pTree, wNewPos))
|
|
UpdateWindow(pTree->hwnd);
|
|
return(fChanged);
|
|
}
|
|
|
|
|
|
#ifdef DEBUG
|
|
static int nCompares;
|
|
#endif
|
|
|
|
typedef struct {
|
|
LPSTR lpstr;
|
|
BOOL bCallBack;
|
|
HTREEITEM hItem;
|
|
} TVCOMPARE, FAR *LPTVCOMPARE;
|
|
|
|
// Pointer comparision function for Sort and Search functions.
|
|
// lParam is lParam passed to sort/search functions. Returns
|
|
// -1 if p1 < p2, 0 if p1 == p2, and 1 if p1 > p2.
|
|
|
|
int CALLBACK TV_DefCompare(LPTVCOMPARE sCmp1, LPTVCOMPARE sCmp2, LPARAM lParam)
|
|
{
|
|
#ifdef DEBUG
|
|
++nCompares;
|
|
#endif
|
|
|
|
return lstrcmpi(sCmp1->lpstr, sCmp2->lpstr);
|
|
}
|
|
|
|
|
|
int CALLBACK TV_CompareItems(LPTVCOMPARE sCmp1, LPTVCOMPARE sCmp2, LPARAM lParam)
|
|
{
|
|
TV_SORTCB FAR *pSortCB = (TV_SORTCB FAR *)lParam;
|
|
#ifdef DEBUG
|
|
++nCompares;
|
|
#endif
|
|
|
|
return(pSortCB->lpfnCompare(sCmp1->hItem->lParam, sCmp2->hItem->lParam,
|
|
pSortCB->lParam));
|
|
}
|
|
|
|
|
|
UINT NEAR TV_CountKids(HTREEITEM hItem)
|
|
{
|
|
int cnt;
|
|
|
|
for (cnt = 0, hItem = hItem->hKids; hItem; hItem = hItem->hNext)
|
|
cnt++;
|
|
|
|
return cnt;
|
|
}
|
|
|
|
|
|
// BUGBUG: bRecurse not implemented
|
|
|
|
BOOL PASCAL TV_SortCB(PTREE pTree, TV_SORTCB FAR *pSortCB, BOOL bRecurse,
|
|
PFNDPACOMPARE lpfnDPACompare)
|
|
{
|
|
HDPA dpaSort;
|
|
HDSA dsaCmp;
|
|
HTREEITEM hItem, hNext, hFirstMoved;
|
|
LPTVCOMPARE psCompare, FAR *ppsCompare;
|
|
int i, cKids;
|
|
HTREEITEM hParent = pSortCB->hParent;
|
|
|
|
#ifdef DEBUG
|
|
DWORD dwTime = GetTickCount();
|
|
nCompares = 0;
|
|
#endif
|
|
|
|
if (!hParent || hParent == TVI_ROOT)
|
|
hParent = pTree->hRoot;
|
|
|
|
// Code below assumes at least one kid
|
|
cKids = TV_CountKids(hParent);
|
|
if (!cKids)
|
|
return FALSE;
|
|
|
|
// Create a DSA for all the extra info we'll need
|
|
dsaCmp = DSA_Create(sizeof(TVCOMPARE), cKids);
|
|
if (!dsaCmp)
|
|
goto Error1;
|
|
|
|
// Create a DPA containing all the tree items
|
|
dpaSort = DPA_Create(cKids);
|
|
if (!dpaSort)
|
|
goto Error2;
|
|
|
|
for (hItem = hParent->hKids; hItem; hItem = hItem->hNext)
|
|
{
|
|
TVCOMPARE sCompare;
|
|
int nItem;
|
|
|
|
// If I can't sort all of them, I don't want to sort any of them
|
|
|
|
// We want to cache the text callback for default processing
|
|
if (!lpfnDPACompare && hItem->lpstr==LPSTR_TEXTCALLBACK)
|
|
{
|
|
TV_ITEM sItem;
|
|
char szTemp[MAX_PATH];
|
|
|
|
sItem.pszText = szTemp;
|
|
sItem.cchTextMax = sizeof(szTemp);
|
|
TV_GetItem(pTree, hItem, TVIF_TEXT, &sItem);
|
|
|
|
sCompare.lpstr = NULL;
|
|
sCompare.bCallBack = TRUE;
|
|
Str_Set(&sCompare.lpstr, sItem.pszText);
|
|
if (!sCompare.lpstr)
|
|
{
|
|
goto Error3;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
sCompare.lpstr = hItem->lpstr;
|
|
sCompare.bCallBack = FALSE;
|
|
}
|
|
|
|
// Create the pointer for this guy and add it to the DPA list
|
|
sCompare.hItem = hItem;
|
|
nItem = DSA_InsertItem(dsaCmp, 0x7fff, &sCompare);
|
|
if (nItem < 0)
|
|
{
|
|
if (sCompare.bCallBack)
|
|
{
|
|
Str_Set(&sCompare.lpstr, NULL);
|
|
}
|
|
goto Error3;
|
|
}
|
|
|
|
if (DPA_InsertPtr(dpaSort, 0x7fff, DSA_GetItemPtr(dsaCmp, nItem)) < 0)
|
|
{
|
|
goto Error3;
|
|
}
|
|
}
|
|
|
|
// Sort the DPA, then stick them back under the parent in the new order
|
|
DPA_Sort(dpaSort, lpfnDPACompare ? lpfnDPACompare : TV_DefCompare,
|
|
(LPARAM)pSortCB);
|
|
|
|
// Look for the first moved item, so we can invalidate a smaller area
|
|
ppsCompare = (LPTVCOMPARE FAR *)DPA_GetPtrPtr(dpaSort);
|
|
if (hParent->hKids != (*ppsCompare)->hItem)
|
|
{
|
|
hParent->hKids = (*ppsCompare)->hItem;
|
|
hFirstMoved = hParent->hKids;
|
|
}
|
|
else
|
|
{
|
|
hFirstMoved = NULL;
|
|
}
|
|
|
|
// We do n-1 iterations here
|
|
for (i = DPA_GetPtrCount(dpaSort) - 1; i > 0; --i, ++ppsCompare)
|
|
{
|
|
hNext = (*(ppsCompare+1))->hItem;
|
|
if ((*ppsCompare)->hItem->hNext != hNext && !hFirstMoved)
|
|
{
|
|
hFirstMoved = hNext;
|
|
}
|
|
(*ppsCompare)->hItem->hNext = hNext;
|
|
}
|
|
(*ppsCompare)->hItem->hNext = NULL;
|
|
|
|
TV_UpdateShownIndexes(pTree, hParent);
|
|
if ((pSortCB->hParent == TVI_ROOT) || !hParent) {
|
|
if (pTree->cShowing < pTree->cFullVisible) {
|
|
pTree->hTop = pTree->hRoot->hKids;
|
|
}
|
|
}
|
|
|
|
if (hFirstMoved && (hParent->state & TVIS_EXPANDED))
|
|
{
|
|
RECT rcUpdate;
|
|
|
|
TV_GetItemRect(pTree, hFirstMoved, &rcUpdate, FALSE);
|
|
if (hParent->hNext)
|
|
{
|
|
RECT rcTemp;
|
|
|
|
TV_GetItemRect(pTree, hParent->hNext, &rcTemp, FALSE);
|
|
rcUpdate.bottom = rcTemp.bottom;
|
|
}
|
|
else
|
|
{
|
|
RECT rcClient;
|
|
GetClientRect(pTree->hwnd, &rcClient);
|
|
// Set to maximal positive number, so the whole rest of
|
|
// the treeview gets invalidated
|
|
rcUpdate.bottom = rcClient.bottom;
|
|
}
|
|
if (pTree->fRedraw)
|
|
InvalidateRect(pTree->hwnd, &rcUpdate, TRUE);
|
|
}
|
|
|
|
Error3:
|
|
DPA_Destroy(dpaSort);
|
|
Error2:
|
|
for (i = DSA_GetItemCount(dsaCmp) - 1; i >= 0; --i)
|
|
{
|
|
psCompare = DSA_GetItemPtr(dsaCmp, i);
|
|
if (psCompare->bCallBack)
|
|
{
|
|
Str_Set(&(psCompare->lpstr), NULL);
|
|
}
|
|
}
|
|
DSA_Destroy(dsaCmp);
|
|
Error1:
|
|
|
|
#ifdef DEBUG
|
|
DebugMsg(DM_TRACE, "tv.sort: %ld ms; %d cmps", GetTickCount()-dwTime, nCompares);
|
|
#endif
|
|
|
|
{
|
|
int wNewPos;
|
|
// restore the scroll position
|
|
if (GetWindowStyle(pTree->hwnd) & WS_VSCROLL) {
|
|
#ifdef IEWIN31_25
|
|
wNewPos = GetScrollPos( pTree->hwnd, SB_VERT );
|
|
#else
|
|
SCROLLINFO si;
|
|
|
|
si.cbSize = sizeof(SCROLLINFO);
|
|
si.fMask = SIF_POS;
|
|
wNewPos = 0;
|
|
if (GetScrollInfo(pTree->hwnd, SB_VERT, &si)) {
|
|
wNewPos = si.nPos;
|
|
}
|
|
#endif //IEWIN31_25
|
|
|
|
} else {
|
|
wNewPos = 0;
|
|
}
|
|
|
|
if (TV_SetTopItem(pTree, wNewPos))
|
|
UpdateWindow(pTree->hwnd);
|
|
}
|
|
|
|
// if the caret is the child of the thing that was sorted, make sure it's
|
|
// visible (but if we're sorting something completely unrelated, don't bother
|
|
if (pTree->hCaret) {
|
|
hItem = pTree->hCaret;
|
|
do {
|
|
// do this first. if hParent is hCaret, we don't want to ensure visible...
|
|
// only if it's an eventual child
|
|
hItem = hItem->hParent;
|
|
if (hParent == hItem) {
|
|
TV_EnsureVisible(pTree, pTree->hCaret);
|
|
}
|
|
} while(hItem && hItem != pTree->hRoot);
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
BOOL NEAR TV_SortChildrenCB(PTREE pTree, LPTV_SORTCB pSortCB, BOOL bRecurse)
|
|
{
|
|
return(TV_SortCB(pTree, pSortCB, bRecurse, TV_CompareItems));
|
|
}
|
|
|
|
|
|
BOOL NEAR TV_SortChildren(PTREE pTree, HTREEITEM hParent, BOOL bRecurse)
|
|
{
|
|
TV_SORTCB sSortCB;
|
|
|
|
sSortCB.hParent = hParent;
|
|
return(TV_SortCB(pTree, &sSortCB, bRecurse, NULL));
|
|
}
|