54#define new(TYPE, numElems) \
55 HeapAlloc(GetProcessHeap(), 0, (numElems) * sizeof(TYPE))
57 HeapFree(GetProcessHeap(), 0, (ptr))
63#define GWLP_USERDATA GWL_USERDATA
66#define GWLP_WNDPROC GWL_WNDPROC
69#ifndef SetWindowLongPtr
70#define SetWindowLongPtr SetWindowLong
72#ifndef GetWindowLongPtr
73#define GetWindowLongPtr GetWindowLong
76#define DWORD_PTR DWORD
83#define str_len (unsigned)wcslen
85#define str_ncpy wcsncpy
86#define str_ncmp wcsncmp
87#define str_icmp _wcsicmp
89#define str_len (unsigned)strlen
91#define str_ncpy strncpy
92#define str_ncmp strncmp
93#define str_icmp _stricmp
96#define WM_MOUSEWHEEL 0x020A
99#define WHEEL_DELTA 120
102#define MAX_COLUMNS 32
105#define EN_SETTEXT 0x1000
106#define EN_RETURN 0x1578
107#define EN_ESCAPE 0x1579
108#define ID_TOOLTIPCHECK 0x3912
109#define SORT_NOUPDATE 1234567
110#define VK_ISACHAR 0x01000000
111#define FIRST_LINE 0xFFFFFFFE
112#define FROM_HEADER 0x88776655
113#define I_CCB I_CHILDRENCALLBACK
114#define U(h) ((unsigned)(ULONG_PTR)(h))
115#define THEMEIMGLIST ((HIMAGELIST)1)
116#define GetHandle(h) ((TreeListData*)GetWindowLongPtr(h,0))
117#define TVIF_ALL (TVIF_CHILDREN|TVIF_HANDLE|TVIF_IMAGE|TVIF_PARAM|TVIF_SELECTEDIMAGE|TVIF_STATE|TVIF_TEXT)
118#define UNLOCK(d) ReleaseSemaphore(d->hSem,1,NULL)
119#define LOCK(d) WaitForSingleObject(d->hSem,INFINITE)
120#define TVIS_EDIT(m) ((1<<m)&((1<<TVAX_EDIT)|(1<<TVAX_COMBO)|(1<<TVAX_STEPED)|(1<<TVAX_CHECKED)))
121#define TVIS_BASEFLAGS (TVIS_EXPANDED|TVIS_EXPANDEDONCE|TVIS_EXPANDPARTIAL|TVIS_SELECTED)
122#define TVIS_TRACKED (TVIX_TRACKED<<16)
123#define TVIS_BKCOLOR (TVIX_BKCOLOR<<16)
125#define TVIS_FOCUSED (TVIX_FOCUSED<<16)
126#define TVIS_TEXTCOLOR (TVIX_TEXTCOLOR<<16)
127#define TVC_ONLYFOCUS TVIF_ONLYFOCUS
128#define TVC_UNSELECT 0x4000
129#define TVC_DESELECT 0x8000
130#define DEFAULT_IDENT 19
131#define DEFAULT_SHIFT 7
132#ifndef BPBF_COMPATIBLEBITMAP
133#define BPBF_COMPATIBLEBITMAP 0
147#ifndef CBS_UNCHECKEDNORMAL
148#define CBS_UNCHECKEDNORMAL 1
150#ifndef CBS_CHECKEDNORMAL
151#define CBS_CHECKEDNORMAL 5
155#define TVAX_NONE (TVAE_NONE >>TVAE_MODEPOS)
156#define TVAX_EDIT (TVAE_EDIT >>TVAE_MODEPOS)
157#define TVAX_COMBO (TVAE_COMBO >>TVAE_MODEPOS)
158#define TVAX_CBLIST (TVAE_CBLIST >>TVAE_MODEPOS)
159#define TVAX_STEP (TVAE_STEP >>TVAE_MODEPOS)
160#define TVAX_STEPED (TVAE_STEPED >>TVAE_MODEPOS)
161#define TVAX_CHECK (TVAE_CHECK >>TVAE_MODEPOS)
162#define TVAX_CHECKED (TVAE_CHECKED>>TVAE_MODEPOS)
164#define TVIX_VARBUTTON 0x01
165#define TVIX_HASBUTTON 0x02
166#define TVIX_HASIMAGE 0x04
167#define TVIX_TRACKED 0x08
168#define TVIX_TEXTCOLOR 0x10
169#define TVIX_BKCOLOR 0x20
170#define TVIX_FOCUSED 0x40
223 BYTE bDummy[32 - 23 -
sizeof(
void *)];
396 static int iIsRegistered =
FALSE;
406 memset(&sClass, 0,
sizeof(sClass));
407 sClass.
cbSize =
sizeof(sClass);
424 iIsRegistered =
TRUE;
555 sInfo.item.lParam =
pEntry->lParam;
557 sInfo.item.state =
pEntry->uState;
558 sInfo.item.stateMask = 0xFFFFFFFF;
566 pData->cTempText2[0] = 0;
567 sInfo.item.pszText =
pData->cTempText2;
568 sInfo.item.cchTextMax =
sizeof(
pData->cTempText2) /
sizeof(
TCHAR) - 1;
571 pData->cTempText1[0] = 0;
572 sInfo.item.pszText =
pData->cTempText1;
573 sInfo.item.cchTextMax =
sizeof(
pData->cTempText1) /
sizeof(
TCHAR) - 1;
576 sInfo.item.pszText = 0;
577 sInfo.item.cchTextMax = 0;
580 sInfo.hdr.hwndFrom =
pData->hWnd;
590 *iImage = sInfo.item.iImage;
594 *iImage = sInfo.item.iSelectedImage;
598 switch(sInfo.item.cChildren) {
600 pEntry->bFlags &= ~TVIX_HASBUTTON;
605 pEntry->bFlags &= ~TVIX_VARBUTTON;
616 pEntry->bFlags &= ~TVIX_HASBUTTON;
621 *
pText = sInfo.item.pszText;
622 *uTextSize =
str_len(sInfo.item.pszText);
644 sInfo.item.lParam =
pEntry->lParam;
646 sInfo.item.state = pExtra->
uState;
648 sInfo.item.stateMask = 0xFFFFFFFF;
651 sInfo.item.cChildren = uSub;
655 pData->cTempText1[0] = 0;
656 sInfo.item.pszText =
pData->cTempText1;
657 sInfo.item.cchTextMax =
sizeof(
pData->cTempText1) /
sizeof(
TCHAR) - 1;
659 sInfo.item.pszText = 0;
660 sInfo.item.cchTextMax = 0;
663 sInfo.hdr.hwndFrom =
pData->hWnd;
673 *iImage = sInfo.item.iImage;
675 *
pText = sInfo.item.pszText;
676 *uTextSize =
str_len(sInfo.item.pszText);
709 pProc =
pData->pProcId3;
748 if(
pData->uEditMode && iId == 3)
751 if(dwStart || dwStop)
759 if(
pData->uEditMode && iId == 3)
763 if(dwCount > dwStart)
882 iAll =
pData->iAllWeight;
883 iCnt =
pData->uColumnCountVar;
886 for(uPos = 0; uPos <
pData->uColumnCount; uPos++) {
887 iWeight =
pData->aColumn[uPos].bWeight;
891 iValue =
pData->aColumn[uPos].sSize;
896 pData->iVarSize = iValue;
898 if(sItem.cxy <
pData->aColumn[uPos].sMin) {
899 sItem.cxy =
pData->aColumn[uPos].sMin;
902 if(
pData->aColumn[uPos].sReal != sItem.cxy) {
903 pData->aColumn[uPos].sReal = (
short)sItem.cxy;
911 sNotify.
iSize = sItem.cxy;
932 for(uPos = 0;; uPos++) {
933 iWeight =
pData->aColumn[uPos].bWeight;
944 iSize = iDelta / iAll;
945 iRest = iDelta % iAll;
950 iValue =
pData->aColumn[uPos].sSize;
951 iValue += iSize * iWeight;
952 iPoint += iRest * iWeight;
960 if(iWeight >=
pData->aColumn[uPos].bWeight) {
968 if(uPos >=
pData->uColumnCount)
970 iWeight =
pData->aColumn[uPos].bWeight;
974 iValue =
pData->aColumn[uPos].sSize;
978 iValue += iSize * iWeight;
979 iPoint += iRest * iWeight;
985 iValue += iSize * iWeight;
994 iCnt =
pData->uColumnCountVar;
996 for(uPos = 0; iCnt > 0; uPos++) {
997 iWeight =
pData->aColumn[uPos].bWeight;
999 iFix +=
pData->aColumn[uPos].sSize;
1003 iVar +=
pData->aColumn[uPos].sSize;
1004 sItem.cxy =
pData->aColumn[uPos].sSize;
1006 if(sItem.cxy <
pData->aColumn[uPos].sMin) {
1007 sItem.cxy =
pData->aColumn[uPos].sMin;
1010 if(
pData->aColumn[uPos].sReal != sItem.cxy) {
1011 pData->aColumn[uPos].sReal = (
short)sItem.cxy;
1019 sNotify.
iSize = sItem.cxy;
1030 pData->iFixSize = iFix;
1031 pData->iVarSize = iVar;
1054 pData->hToolTip =
CreateWindow(
TOOLTIPS_CLASS,
NULL,
WS_POPUP,
CW_USEDEFAULT,
CW_USEDEFAULT,
CW_USEDEFAULT,
CW_USEDEFAULT,
pData->hWnd,
NULL,
NULL,
NULL);
1059 sInfo.hwnd =
pData->hWnd;
1092 if(!
pData->hThemeBt) {
1096 if(
pData->hThemeBt) {
1103 pData->iChecksXsize = 16;
1104 pData->iChecksYsize = 16;
1105 pData->iChecksMode = 1;
1112 pData->iStatesXsize = 16;
1113 pData->iStatesYsize = 16;
1114 pData->iStatesMode = 1;
1138 Rectangle(hDc, -1, -1, 16 * 3 + 2, 16 + 2);
1142 sRect.
left = 16 * 1 + 8 - 7;
1143 sRect.
right = 16 * 1 + 8 + 6;
1147 sRect.
left = 16 * 2 + 8 - 7;
1148 sRect.
right = 16 * 2 + 8 + 6;
1175 pData->iStatesXsize = 16;
1176 pData->iStatesYsize = 16;
1177 pData->iStatesMode = 1;
1182 pData->iChecksXsize = 16;
1183 pData->iChecksYsize = 16;
1184 pData->iChecksMode = 1;
1225 if(uItem >
pData->uTreeItemsMax)
1232 iHeigh =
pData->iFontHeight;
1235 if(uSub >=
pData->uColumnCount)
1238 pExtra =
pData->pExtraItems[uSub - 1][uItem];
1243 iWidth =
pData->iFontHeight * 4;
1256 uTSize =
pEntry->uTextSize;
1258 iWidth =
pEntry->iTextPixels;
1265 if(
pData->hImages && iImage >= 0) {
1266 if(iHeigh < pData->iImagesYsize)
1267 iHeigh =
pData->iImagesYsize;
1268 iAdd =
pData->iImagesXsize + 2;
1280 pMem =
new(
BYTE, iHeigh * (iWidth + 4) * 4 + 1024);
1297 sRect.
right = iWidth;
1298 iYpos = (iHeigh -
pData->iFontHeight) / 2;
1388 pData->cGlyphOk = 1;
1390 pData->cGlyphOk = 0;
1401 iDiff = ((uColOdd) & 0xFF) - ((
pData->uColors[
TVC_EVEN]) & 0xFF);
1402 iSum = iDiff * iDiff;
1403 iDiff = ((uColOdd >> 8) & 0xFF) - ((
pData->uColors[
TVC_EVEN] >> 8) & 0xFF);
1404 iSum += iDiff * iDiff;
1405 iDiff = ((uColOdd >> 16) & 0xFF) - ((
pData->uColors[
TVC_EVEN] >> 16) & 0xFF);
1406 iSum += iDiff * iDiff;
1410 uColOdd |= ((
pData->uColors[
TVC_EVEN] & 0x00FF0000) - 0x00080000) & 0x00FF0000;
1418 if(uColor & 0x00F00000)
1419 uColor -= 0x00100000;
1420 if(uColor & 0x0000F000)
1421 uColor -= 0x00001000;
1422 if(uColor & 0x000000F0)
1423 uColor -= 0x00000010;
1430 if(uColor & 0x00F00000)
1431 uColor -= 0x00100000;
1432 if(uColor & 0x0000F000)
1433 uColor -= 0x00001000;
1434 if(uColor & 0x000000F0)
1435 uColor -= 0x00000010;
1442 if(uColor & 0x00F00000)
1443 uColor -= 0x00100000;
1444 if(uColor & 0x0000F000)
1445 uColor -= 0x00001000;
1446 if(uColor & 0x000000F0)
1447 uColor -= 0x00000010;
1475 if(
pData->cFixedHeight)
1481 if(iHeight < pData->iChecksYsize + 2)
1482 iHeight =
pData->iChecksYsize + 2;
1484 if(iHeight < pData->iStatesYsize + 2)
1485 iHeight =
pData->iStatesYsize + 2;
1486 if(iHeight < pData->iSubImgYsize + 2)
1487 iHeight =
pData->iSubImgYsize + 2;
1488 if(iHeight < pData->iImagesYsize + 2)
1489 iHeight =
pData->iImagesYsize + 2;
1490 if(iHeight < pData->iFontHeight + 2)
1491 iHeight =
pData->iFontHeight + 2;
1496 if(
pData->iRowHeight == iHeight)
1499 pData->iRowHeight = iHeight;
1505 pData->uMaxEnties = 0;
1541 if(uPos >=
pData->uMaxEnties)
1544 uNext =
pData->aColumn[uSub].bNext;
1550 sRect.
top +=
pData->iRowHeight * uPos;
1572 if(uColumn >=
pData->uColumnCount)
1575 sRect.
left =
pData->aColumnXpos[uColumn];
1580 uNext =
pData->aColumn[uColumn].bNext;
1615 if(uPos >=
pData->uMaxEnties)
1621 sRect.
top +=
pData->iRowHeight * uPos;
1664 uCols =
pData->uColumnCount;
1666 uSize =
pData->aColumnXpos[uCols] - 1;
1668 uSize =
pData->iMaxSizeX - 1;
1671 if(
pData->uOldXCount == uSize)
1677 pData->uOldXCount = uSize;
1695 if(sInfo.
nMax > 0) {
1702 pData->uScrollX = 0;
1706 if(
pData->hHeader) {
1728 if(
pData->uOldYCount ==
pData->uItemPosCount)
1752 pData->uScrollY = 0;
1791 if(
pData->uToolTipItem)
1799 if(
pData->uToolTipItem != uItem ||
pData->uToolTipSub != 0) {
1800 if(!
pData->pTreeItems[uItem]) {
1817 sNotify.itemNew.stateMask = 0xFFFFFFFF;
1818 sNotify.itemNew.state =
pEntry->uState;
1819 sNotify.itemNew.lParam =
pEntry->lParam;
1820 sNotify.itemNew.pszText =
pEntry->pText;
1821 sNotify.itemNew.cchTextMax =
pEntry->uTextSize;
1822 sNotify.itemNew.cChildren = 0;
1823 sNotify.itemOld.mask = 0;
1824 sNotify.ptDrag.x = sRect.
left;
1825 sNotify.ptDrag.y = sRect.
top;
1838 sToolNv.lParam =
pEntry->lParam;
1839 sToolNv.pszText = cTemp;
1850 sNotify.itemNew.pszText = sToolNv.pszText;
1851 sNotify.itemNew.cchTextMax =
str_len(sToolNv.pszText);
1852 sNotify.itemNew.cChildren = 0;
1853 sNotify.itemNew.stateMask = 0xFFFFFFFF;
1854 sNotify.itemNew.state =
pEntry->uState;
1855 sNotify.itemNew.lParam =
pEntry->lParam;
1856 sNotify.ptDrag.x = sRect.
left;
1857 sNotify.ptDrag.y = sRect.
top;
1864 uSize =
pEntry->uTextSize;
1874 if(uLen >=
pData->uToolTipSize) {
1875 delete(
pData->pToolTipText);
1876 pData->uToolTipSize = (uLen + 255)&~0xFF;
1884 hToolTip =
pData->hToolTip;
1893 sInfo.cbSize =
sizeof(sInfo);
1894 sInfo.hwnd =
pData->hWnd;
1897 if(
pData->uToolTipItem) {
1899 pData->uToolTipItem = 0;
1907 pData->uToolTipItem = uItem;
1908 pData->uToolTipShow = 0;
1909 pData->uToolTipSub = 0;
1913 if(
pData->uToolTipItem)
1925 pExtra =
pData->pExtraItems[uCol - 1][uItem];
1935 sNotify.itemNew.state = pExtra->
uState;
1936 sNotify.itemNew.pszText = pExtra->
pText;
1937 sNotify.itemNew.cchTextMax = pExtra->
uTextSize;
1939 sNotify.itemNew.state = 0;
1940 sNotify.itemNew.cchTextMax = 0;
1941 sNotify.itemNew.pszText =
_T(
"");
1946 sNotify.itemNew.lParam =
pEntry->lParam;
1949 sNotify.itemNew.stateMask = 0xFFFFFFFF;
1950 sNotify.itemNew.cChildren = uCol;
1951 sNotify.itemOld.mask = 0;
1952 sNotify.ptDrag.x = sRect.
left;
1953 sNotify.ptDrag.y = sRect.
top;
1982 if(uLen >=
pData->uToolTipSize) {
1983 delete(
pData->pToolTipText);
1984 pData->uToolTipSize = (uLen + 255)&~0xFF;
1994 hToolTip =
pData->hToolTip;
2001 sInfo.cbSize =
sizeof(sInfo);
2002 sInfo.hwnd =
pData->hWnd;
2005 if(
pData->uToolTipItem) {
2007 pData->uToolTipItem = 0;
2015 pData->uToolTipItem = uItem;
2016 pData->uToolTipSub = uCol;
2017 pData->uToolTipShow = 0;
2021 if(
pData->uToolTipItem)
2025 if(
pData->uToolTipItem)
2035 if(
pData->uToolTipItem) {
2038 sInfo.cbSize =
sizeof(sInfo);
2039 sInfo.hwnd =
pData->hWnd;
2046 pData->uToolTipItem = 0;
2047 pData->uToolTipSub = 0;
2048 pData->uToolTipShow = 0;
2057 pText = sNotify.itemNew.pszText;
2058 uSize = sNotify.itemNew.cchTextMax;
2059 sRect.
left = sNotify.ptDrag.x;
2060 sRect.
top = sNotify.ptDrag.y;
2066 if(uLen >=
pData->uToolTipSize) {
2068 delete(
pData->pToolTipText);
2069 pData->uToolTipSize = (uLen + 255)&~0xFF;
2077 pData->sToolTipPos = sNotify.ptDrag;
2079 hToolTip =
pData->hToolTip;
2082 if((sNotify.itemNew.mask &
TVIF_TOOLTIPTIME) && sNotify.itemNew.lParam > 0) {
2083 pData->uToolTipShow = (
unsigned)(sNotify.itemNew.lParam + 499) / 500;
2084 pData->uToolTipSub = sNotify.itemNew.cChildren;
2085 pData->uToolTipItem = uItem;
2094 sInfo.cbSize =
sizeof(sInfo);
2095 sInfo.hwnd =
pData->hWnd;
2098 if(
pData->uToolTipItem) {
2100 pData->uToolTipItem = 0;
2108 pData->uToolTipShow = 0;
2109 pData->uToolTipItem = uItem;
2110 pData->uToolTipSub = sNotify.itemNew.cChildren;
2134 pData->hFontB = hBold;
2198 iPos =
pData->uTreeItemsMax;
2200 for(; iPos >= 0; iPos--) {
2209 for(uSub = 1; uSub <
pData->uColumnCount; uSub++) {
2210 iPos =
pData->uTreeItemsMax;
2213 for(; iPos >= 0; iPos--) {
2262 uOld =
pData->uItemPosCount;
2263 pLines =
pData->pItemPos;
2267 uItem =
pData->uFirstChild;
2272 for(uNum = 0; uNum < uOld; uNum++) {
2273 uTemp = pLines[uNum];
2283 pData->uItemPosCount = 0;
2288 memset(pLines, 0,
sizeof(
unsigned)*uOld);
2292 for(uNum = 0; uNum < uOld; uNum++) {
2293 uTemp = pLines[uNum];
2316 for(uNum = uPos; uNum < uOld; uNum++) {
2317 uTemp = pLines[uNum];
2330 uItem =
pEntry->uFirstChild;
2333 uItem =
pEntry->uNextItem;
2342 uItem =
pEntry->uNextItem;
2353 if(pLines[uPos] != uItem) {
2354 pLines[uPos] = uItem;
2364 pData->uItemPosCount = uPos;
2366 if(uStart >
pData->uScrollY)
2367 uStart -=
pData->uScrollY;
2373 sRect.
top =
pData->uStartPixel +
pData->iRowHeight * uStart;
2405 hHeader =
pData->hHeader;
2407 pData->aColumnXpos[0] = 0;
2413 for(uCol = 0; uCol <
pData->uColumnCount;) {
2414 uSub =
pData->aColumnPos[uCol];
2415 iSize =
pData->aColumn[uSub].sReal;
2416 uSub =
pData->aColumn[uSub].bNext;
2425 if(uSub ==
pData->uColumnCount)
2426 if(iNow >= (
int)
pData->uSizeX - 1) {
2430 iNum =
pData->aColumnXpos[uSub];
2441 if(
pData->uSelectedItem) {
2442 uNext =
pData->aColumn[
pData->uSelectedSub].bNext;
2448 if(
pData->uTrackedItem) {
2449 uNext =
pData->aColumn[
pData->uTrackedSub].bNext;
2456 pData->aColumnXpos[uSub] = iNow;
2460 while(uCol < pData->uColumnCount) {
2462 uSub =
pData->aColumnPos[uCol];
2463 iNow +=
pData->aColumn[uSub].sReal;
2464 uSub =
pData->aColumn[uSub].bNext;
2467 if(uCol ==
pData->uColumnCount)
2468 if(iNow >= (
int)
pData->uSizeX - 1) {
2472 pData->aColumnXpos[uSub] = iNow;
2508 if(aArray[0] != 0) {
2512 for(uCol =
pData->uColumnCount; uCol > 0; uCol++) {
2514 aArray[uCol] = uCol;
2518 uItems =
pData->uColumnCount;
2521 if(
pData->uColumnCount != uItems || uItems == 0 || *pArray) {
2526 memset(aFlags, 0,
sizeof(aFlags) - 1);
2528 for(uCol = 0, uDiff = 0; uCol < uItems; uCol++) {
2529 uSub = pArray[uCol];
2535 aFlags[uSub] = (
BYTE)uCol;
2537 uDiff |= uCol ^
pData->aColumnPos[uSub];
2545 aFlags[uItems] = (
BYTE)uItems;
2547 for(uCol = 1; uCol < uItems; uCol++) {
2548 pData->aColumnPos[uCol] = (
BYTE)pArray[uCol];
2551 for(uCol = 0; uCol < uItems; uCol++) {
2552 uSub = aFlags[uCol];
2553 pData->aColumn[uCol].bIndex = (
BYTE)uSub;
2554 pData->aColumn[uCol].bNext =
pData->aColumnPos[uSub + 1];
2564 for(uCol = 0; uCol < uItems; uCol++) {
2605 if(uItem >
pData->uTreeItemsMax)
2613 uAction = uAddFlags & 0x0F;
2618 sNotify.action = uAction;
2622 sNotify.itemNew.stateMask = 0xFFFFFFFF;
2623 sNotify.itemNew.state =
pEntry->uState;
2624 sNotify.itemNew.lParam =
pEntry->lParam;
2625 sNotify.itemNew.pszText = (
LPTSTR) - 1;
2626 sNotify.itemNew.cchTextMax = -1;
2627 sNotify.itemOld.mask = 0;
2628 sNotify.ptDrag.x = 0;
2629 sNotify.ptDrag.y = 0;
2653 pEntry->uState &= ~TVIS_EXPANDED;
2657 pEntry->uState &= ~TVIS_EXPANDPARTIAL;
2658 pEntry->uState |= uAddFlags&~0x0F;
2660 if(
pEntry->uShowPos && bDo) {
2663 uNext =
pEntry->uFirstChild;
2666 pTemp =
pList[uNext];
2691 sNotify.action = uAction;
2695 sNotify.itemNew.stateMask = 0xFFFFFFFF;
2696 sNotify.itemNew.state =
pEntry->uState;
2697 sNotify.itemNew.lParam =
pEntry->lParam;
2698 sNotify.itemNew.pszText = (
LPTSTR) - 1;
2699 sNotify.itemNew.cchTextMax = -1;
2700 sNotify.itemOld.mask = 0;
2701 sNotify.ptDrag.x = 0;
2702 sNotify.ptDrag.y = 0;
2720 if(
pData->uSelectedItem && bDo) {
2723 pData->uSelectedItem = 0;
2724 pData->uSelectedSub = 0;
2727 while(!
pEntry->uShowPos) {
2763 if(uItem >
pData->uTreeItemsMax) {
2775 if(uPos >=
pData->uMaxEnties) {
2781 pRect->
top +=
pData->iRowHeight * uPos;
2786 if(uSub >=
pData->uColumnCount)
2789 uNext =
pData->aColumn[uSub].bNext;
2803 pExtra =
pData ->pExtraItems[uSub - 1][uItem];
2816 if(
pData->cHasRootRow) {
2822 if(
pData->hStates) {
2875 if(uItem >
pData->uTreeItemsMax)
2889 pTemp =
pData->pTreeItems[uTemp];
2910 if(uPos < pData->uScrollY) {
2911 pData->uScrollY = uPos;
2916 if(uPos !=
pData->uScrollY) {
2917 pData->uScrollY = uPos;
2924 if(uPos >=
pData->uScrollY +
pData->uPageEnties) {
2925 iOff = uPos - (
pData->uPageEnties - 1);
2926 iMax =
pData->uItemPosCount;
2927 iMax -=
pData->uPageEnties - 1;
2933 if(iOff != (
int)
pData->uScrollY) {
2934 pData->uScrollY = iOff;
2940 if(uSub < pData->uColumnCount) {
2941 uNext =
pData->aColumn[uSub].bNext;
2942 iNum =
pData->uSizeX;
2943 iOff =
pData->uScrollX;
2944 iAnf =
pData->aColumnXpos[uSub ];
2945 iEnd =
pData->aColumnXpos[uNext];
2947 if(iOff + iNum < iAnf)
2951 if(iOff + iNum < iEnd)
2956 iMax =
pData->aColumnXpos[
pData->uColumnCount];
2957 iMax -=
pData->uSizeX / 2;
2963 if(iOff != (
int)
pData->uScrollX) {
2964 pData->uScrollX = iOff;
3000 if(uItem >
pData->uTreeItemsMax)
3013 if(uPos < pData->uScrollY) {
3018 if(uPos >=
pData->uScrollY +
pData->uMaxEnties) {
3022 if(uPos ==
pData->uScrollY +
pData->uPageEnties) {
3023 if(uSub < pData->uColumnCount) {
3024 uNext =
pData->aColumn[uSub].bNext;
3025 iNum =
pData->uSizeX;
3026 iOff =
pData->uScrollX;
3027 iAnf =
pData->aColumnXpos[uSub ];
3028 iEnd =
pData->aColumnXpos[uNext];
3030 if(iOff + iNum < iAnf)
3039 if(uSub < pData->uColumnCount) {
3040 uNext =
pData->aColumn[uSub].bNext;
3041 iNum =
pData->uSizeX;
3042 iOff =
pData->uScrollX;
3043 iAnf =
pData->aColumnXpos[uSub ];
3044 iEnd =
pData->aColumnXpos[uNext];
3046 if(iOff + iNum < iAnf)
3050 if(iOff + iNum < iEnd)
3083 if(
pData->cLockChanges)
3086 if(uItem >
pData->uTreeItemsMax) {
3089 if(
pData->uLastChild == 0)
3092 while(
pData->uLastChild) {
3096 pData->uItemPosCount = 0;
3108 if(
pData->uLastChild == 0)
3111 while(
pData->uLastChild) {
3115 pData->uItemPosCount = 0;
3124 if(!
pEntry->uFirstChild) {
3128 while(
pEntry->uLastChild) {
3140 while(
pEntry->uLastChild) {
3144 if(uItem ==
pData->uSelectedItem) {
3149 sNotify.itemOld.stateMask = 0xFFFFFFFF;
3150 sNotify.itemOld.state =
pEntry->uState&~TVIS_SELECTED;
3151 sNotify.itemOld.lParam =
pEntry->lParam;
3152 sNotify.itemOld.cChildren = 0;
3153 sNotify.itemOld.pszText = (
LPTSTR) - 1;
3154 sNotify.itemOld.cchTextMax = -1;
3156 sNotify.itemNew.hItem =
NULL;
3157 sNotify.itemNew.stateMask = 0xFFFFFFFF;
3158 sNotify.itemNew.state = 0;
3159 sNotify.itemNew.lParam = 0;
3160 sNotify.itemNew.cChildren = 0;
3161 sNotify.itemNew.pszText = (
LPTSTR) - 1;
3162 sNotify.itemNew.cchTextMax = -1;
3163 sNotify.ptDrag.x = 0;
3164 sNotify.ptDrag.y = 0;
3170 pData->uSelectedItem = 0;
3171 pData->uSelectedSub = 0;
3175 sNotify.itemNew.mask = 0;
3178 sNotify.itemOld.lParam =
pEntry->lParam;
3179 sNotify.itemOld.pszText = (
LPTSTR) - 1;
3180 sNotify.itemNew.stateMask = 0xFFFFFFFF;
3181 sNotify.itemNew.state =
pEntry->uState;
3182 sNotify.itemOld.cchTextMax = -1;
3183 sNotify.ptDrag.x = 0;
3184 sNotify.ptDrag.y = 0;
3194 if(uItem ==
pData->uTrackedItem) {
3195 pData->uTrackedItem = 0;
3196 pData->uTrackedSub = 0;
3199 if(
pData->uInsertMark == uItem) {
3200 pData->uInsertMark = 0;
3203 if(
pData->uSingleSel == uItem) {
3204 pData->uSingleSel = 0;
3228 pTemp->
bFlags &= ~TVIX_HASBUTTON;
3235 for(uPos = 1; uPos <
pData->uColumnCount; uPos++) {
3238 pExtra =
pList[uItem];
3246 delete(pExtra->
pText);
3261 uItem =
pEntry->uPrevItem;
3262 if(!uItem && !
pEntry->uNextItem) {
3267 uPos =
pData->pTreeItems[uItem]->uShowPos;
3278 if(
pData->uSelectedCount > 0) {
3279 pData->uSelectedCount--;
3284 pData->uTreeItemsCount--;
3286 iOff =
pData->uScrollY;
3287 iMax =
pData->uItemPosCount;
3288 iMax -=
pData->uPageEnties - 1;
3294 if(iOff != (
int)
pData->uScrollY) {
3295 pData->uScrollY = iOff;
3327 if(uItem ==
pData->uSelectedItem)
3333 sNotify.action =
iMode;
3336 sNotify.itemNew.stateMask = 0xFFFFFFFF;
3337 sNotify.itemNew.state =
pEntry->uState;
3338 sNotify.itemNew.lParam =
pEntry->lParam;
3339 sNotify.itemNew.cChildren = 0;
3340 sNotify.itemNew.pszText = (
LPTSTR) - 1;
3341 sNotify.itemNew.cchTextMax = -1;
3343 sNotify.itemOld.hItem =
NULL;
3344 sNotify.itemOld.stateMask = 0xFFFFFFFF;
3345 sNotify.itemOld.state = 0;
3346 sNotify.itemOld.lParam = 0;
3347 sNotify.itemOld.cChildren = 0;
3348 sNotify.itemOld.pszText = (
LPTSTR) - 1;
3349 sNotify.itemOld.cchTextMax = -1;
3350 sNotify.ptDrag.x = 0;
3351 sNotify.ptDrag.y = 0;
3366 sNotify.action =
iMode;
3369 sNotify.itemNew.stateMask = 0xFFFFFFFF;
3370 sNotify.itemNew.state =
pEntry->uState;
3371 sNotify.itemNew.lParam =
pEntry->lParam;
3372 sNotify.itemNew.cChildren = 0;
3373 sNotify.itemNew.pszText = (
LPTSTR) - 1;
3374 sNotify.itemNew.cchTextMax = -1;
3376 sNotify.itemOld.hItem =
NULL;
3377 sNotify.itemOld.stateMask = 0xFFFFFFFF;
3378 sNotify.itemOld.state = 0;
3379 sNotify.itemOld.lParam = 0;
3380 sNotify.itemOld.cChildren = 0;
3381 sNotify.itemOld.pszText = (
LPTSTR) - 1;
3382 sNotify.itemOld.cchTextMax = -1;
3383 sNotify.ptDrag.x = 0;
3384 sNotify.ptDrag.y = 0;
3402 pData->uSelectedCount++;
3404 pData->uSelectedCount--;
3425 if(!
pData->uFocusItem)
3428 uItem =
pData->uFocusItem;
3432 pEntry->bFlags &= ~TVIX_FOCUSED;
3434 uSub =
pData->uFocusSub;
3437 pExtra =
pData->pExtraItems[uSub - 1][uItem];
3439 pExtra->
bFlags &= ~TVIX_FOCUSED;
3445 pData->uFocusItem = 0;
3446 pData->uFocusSub = 0;
3467 if(
pData->uFocusItem) {
3468 if(uSub == 0xFFFFFFFF)
3469 uSub =
pData->uFocusSub;
3470 if(uItem == 0xFFFFFFFF)
3471 uItem =
pData->uFocusItem;
3473 if(uSub == 0xFFFFFFFF)
3474 uSub =
pData->uSelectedSub;
3475 if(uItem == 0xFFFFFFFF)
3476 uItem =
pData->uSelectedItem;
3479 if(
pData->uFocusItem == uItem)
3480 if(
pData->uFocusSub == uSub)
3489 if(uItem >
pData->uTreeItemsMax) {
3505 uTemp =
pData->uFocusItem;
3506 pTemp =
pData->pTreeItems[uTemp];
3509 pTemp->
bFlags &= ~TVIX_FOCUSED;
3510 uCol =
pData->uFocusSub;
3513 pExtra =
pData->pExtraItems[uCol - 1][uTemp];
3515 pExtra->
bFlags &= ~TVIX_FOCUSED;
3523 pExtra =
pData->pExtraItems[uSub - 1][uItem];
3530 pData->uFocusItem = uItem;
3531 pData->uFocusSub = uSub;
3534 if(
pData->uSelectedItem != uItem) {
3535 uTemp =
pData->uSelectedItem;
3536 uCol =
pData->uSelectedSub;
3539 uCol =
pData->uSelectedSub;
3542 pData->uSelectedItem = uItem;
3543 pData->uSelectedSub = uSub;
3605 uOld =
pData->uSelectedItem;
3606 uSub =
pData->uSelectedSub;
3608 if(uSubItem >=
pData->uColumnCount && uSubItem > 0)
3610 if(uItem >
pData->uTreeItemsMax)
3613 if(uSubItem == uSub)
3630 if(
pData->uSelectedCount > 1 &&
pData->uTreeItemsMax) {
3631 for(uPos =
pData->uTreeItemsMax; uPos; uPos--) {
3636 if(!
pData->uSelectedCount)
3642 iMode &= ~TVC_ONLYFOCUS;
3661 pExtra =
pData->pExtraItems[uSubItem - 1][uItem];
3663 uState |= pExtra->
uState;
3667 pTemp =
pData->pTreeItems[uOld];
3677 pExtra =
pData->pExtraItems[uSub - 1][uOld];
3679 uStOld |= pExtra->
uState;
3684 sNotify.action =
iMode;
3687 sNotify.itemNew.stateMask = 0xFFFFFFFF;
3688 sNotify.itemNew.state = uState;
3689 sNotify.itemNew.lParam =
lParam;
3690 sNotify.itemNew.cChildren = uSubItem;
3691 sNotify.itemNew.pszText = (
LPTSTR) - 1;
3692 sNotify.itemNew.cchTextMax = -1;
3695 sNotify.itemOld.stateMask = 0xFFFFFFFF;
3696 sNotify.itemOld.state = uStOld;
3697 sNotify.itemNew.lParam = lPaOld;
3698 sNotify.itemOld.cChildren = uSub;
3699 sNotify.itemOld.pszText = (
LPTSTR) - 1;
3700 sNotify.itemOld.cchTextMax = -1;
3701 sNotify.ptDrag.x = 0;
3702 sNotify.ptDrag.y = 0;
3721 uOld =
pData->uSelectedItem;
3722 pTemp =
pData->pTreeItems[uOld];
3735 uStOld &= ~TVIS_SELECTED;
3736 pTemp->
uState &= ~TVIS_SELECTED;
3738 if(
pData->uSelectedCount > 0) {
3739 pData->uSelectedCount -= 1;
3743 pData->uSelectedSub = 0;
3744 pData->uSelectedItem = 0;
3753 uState &= ~TVIS_SELECTED;
3754 pEntry->uState &= ~TVIS_SELECTED;
3755 if(
pData->uSelectedCount)
3756 pData->uSelectedCount--;
3762 pData->uSelectedCount += 1;
3766 if(uSubItem && uSubItem < pData->uColumnCount) {
3767 pExtra =
pData->pExtraItems[uSubItem - 1][uItem];
3773 pData->pExtraItems[uSubItem - 1][uItem] = pExtra;
3789 pData->uSelectedSub = uSubItem;
3790 pData->uSelectedItem = uItem;
3792 pData->uSelectedItem = 0;
3793 pData->uSelectedSub = 0;
3798 sNotify.action =
iMode;
3801 sNotify.itemNew.stateMask = 0xFFFFFFFF;
3802 sNotify.itemNew.state = uState;
3803 sNotify.itemNew.lParam =
lParam;
3804 sNotify.itemNew.cChildren = uSubItem;
3805 sNotify.itemNew.pszText = (
LPTSTR) - 1;
3806 sNotify.itemNew.cchTextMax = -1;
3809 sNotify.itemOld.stateMask = 0xFFFFFFFF;
3810 sNotify.itemOld.state = uStOld;
3811 sNotify.itemOld.lParam = lPaOld;
3812 sNotify.itemOld.cChildren = uSub;
3813 sNotify.itemOld.pszText = (
LPTSTR) - 1;
3814 sNotify.itemOld.cchTextMax = -1;
3815 sNotify.ptDrag.x = 0;
3816 sNotify.ptDrag.y = 0;
3824 if(
pData->uSelectedItem) {
3836 sNotify.action =
iMode;
3839 sNotify.itemNew.stateMask = 0xFFFFFFFF;
3841 sNotify.itemNew.cChildren = 0;
3842 sNotify.itemNew.pszText = (
LPTSTR) - 1;
3843 sNotify.itemNew.cchTextMax = -1;
3846 sNotify.itemOld.stateMask = 0xFFFFFFFF;
3847 sNotify.itemOld.state = (pTemp) ? pTemp->
uState : 0;
3848 sNotify.itemOld.cChildren = 0;
3849 sNotify.itemOld.pszText = (
LPTSTR) - 1;
3850 sNotify.itemOld.cchTextMax = -1;
3851 sNotify.ptDrag.x = 0;
3852 sNotify.ptDrag.y = 0;
3859 pTemp =
pData->pTreeItems[uOld ];
3890 pTemp =
pData->pTreeItems[uNext];
3903 pTemp =
pData->pTreeItems[uNext];
3927 if(
pData->uSelectedItem) {
3957 uItem =
pData->uFirstChild;
3959 if(uItem >
pData->uTreeItemsMax)
3963 if(!
pData->pTreeItems[uItem]) {
3979 uItem =
pEntry->uFirstChild;
3985 uItem =
pEntry->uNextItem;
4014 PFNTVSORTEX pCompare;
4042 if(
pData->cLockChanges)
4045 uParent =
U(pInsert->hParent);
4046 if(uParent >
pData->uTreeItemsMax) {
4061 if(
pData->uTreeItemsCount + 1 >
pData->uTreeItemsMax) {
4062 pPosOld =
pData->pItemPos;
4063 pOld =
pData->pTreeItems;
4064 uMax =
pData->uTreeItemsMax;
4065 uMax +=
pData->uTreeItemsMax / 2;
4079 for(uPos = 1; uPos <
pData->uColumnCount; uPos++) {
4080 pExOld[uPos] =
pData->pExtraItems[uPos - 1];
4081 pExNew[uPos] =
new(
ExtraItem*, uMax + 1);
4084 for(uPos--; uPos > 0; uPos--)
4085 delete(pExNew[uPos]);
4094 memcpy(pPosNew,
pData->pItemPos ,
sizeof(
unsigned) * (
pData->uTreeItemsCount));
4095 memset(pPosNew +
pData->uTreeItemsCount, 0,
sizeof(
unsigned) * (uMax -
pData->uTreeItemsCount));
4097 for(uPos = 1; uPos <
pData->uColumnCount; uPos++) {
4100 pData->pExtraItems[uPos - 1] = pExNew[uPos];
4101 delete(pExOld[uPos]);
4104 pData->uTreeItemsMax = uMax;
4106 pData->pItemPos = pPosNew;
4113 uPos =
pData->uNextSeachPos + 1;
4121 if(
pData->uUserDataSize) {
4126 if(uPos >
pData->uTreeItemsMax)
4132 pData->uNextSeachPos = uPos;
4138 uBits = pInsert->item.mask;
4141 pNew->
uState = pInsert->item.state & pInsert->item.stateMask;
4150 pNew->
lParam = pInsert->item.lParam;
4154 pNew->
iImage = pInsert->item.iImage;
4166 switch(pInsert->item.cChildren) {
4185 pNew->
uState &= ~TVIS_EXPANDED;
4208 uFirst = 0xFFFFFFFF;
4209 pFirst = &
pData->uFirstChild;
4210 pLast = &
pData->uLastChild;
4214 uFirst =
pParent->uFirstChild;
4215 pFirst = &
pParent->uFirstChild;
4225 uAfter =
U(pInsert->hInsertAfter);
4239 uFirst = 0xFFFFFFFF;
4240 pFirst = &
pData->uFirstChild;
4241 pLast = &
pData->uLastChild;
4245 uFirst =
pParent->uFirstChild;
4246 pFirst = &
pParent->uFirstChild;
4255 uAfter =
pEntry->uPrevItem;
4263 pEntry->uPrevItem = uPos;
4277 pFirst = &
pData->uFirstChild;
4278 pLast = &
pData->uLastChild;
4283 pEntry->uNextItem = uPos;
4312 pData->cLockChanges = 1;
4314 pCompare = (PFNTVSORTEX)(pInsert->item.hItem);
4323 uNext =
pItems[uNext]->uNextItem;
4327 iShift = iCount / 2;
4331 uNext =
pItems[uNext]->uNextItem;
4342 pTextTemp =
pEntry->pText;
4347 iCount -= (iCount + 1) / 2;
4352 iCount -= iCount / 2 + 1;
4354 uItem =
pItems[uNext]->uNextItem;
4358 uBefore =
pEntry->uPrevItem;
4363 pData->cLockChanges = 0;
4370 pEntry->uNextItem = uPos;
4377 pEntry->uPrevItem = uPos;
4400 pData->cLockChanges = 1;
4408 uNext =
pItems[uNext]->uNextItem;
4412 iShift = iCount / 2;
4416 uNext =
pItems[uNext]->uNextItem;
4428 pTextTemp =
pEntry->pText;
4434 iCount -= (iCount + 1) / 2;
4439 iCount -= iCount / 2 + 1;
4441 uItem =
pItems[uNext]->uNextItem;
4445 uBefore =
pEntry->uPrevItem;
4451 pData->cLockChanges = 0;
4458 pEntry->uNextItem = uPos;
4465 pEntry->uPrevItem = uPos;
4483 uFirst = 0xFFFFFFFF;
4484 pFirst = &
pData->uFirstChild;
4485 pLast = &
pData->uLastChild;
4489 uFirst =
pParent->uFirstChild;
4490 pFirst = &
pParent->uFirstChild;
4509 if(uAfter >
pData->uTreeItemsMax) {
4510 if((uAfter & 0xFFF00000) == 0xFFE00000) {
4522 pEntry->uPrevItem = uPos;
4531 for(; uItem; uItem =
pItems[uItem]->uNextItem) {
4534 if(uNum == uAfter) {
4535 uItem =
pItems[uItem]->uNextItem;
4547 pEntry->uNextItem = uPos;
4554 pEntry->uPrevItem = uPos;
4568 uItem =
pEntry->uNextItem;
4580 pEntry->uNextItem = uPos;
4587 pEntry->uPrevItem = uPos;
4596 pData->uTreeItemsCount++;
4646 uItem =
U(pItem->hItem);
4647 if(uItem >
pData->uTreeItemsMax)
4654 uBits = pItem->mask;
4657 uSub = pItem->cChildren;
4659 if(uSub >=
pData->uColumnCount)
4662 pExtra =
pList[uItem];
4669 pList[uItem] = pExtra;
4673 pEntry->lParam = pItem->lParam;
4679 pExtra->
iImage = pItem->iImage;
4689 delete(pExtra->
pText);
4695 uLen =
str_len(pItem->pszText);
4699 delete(pExtra->
pText);
4712 uMask = pItem->stateMask&~TVIS_BASEFLAGS;
4713 uBits = uMask & (pExtra->
uState ^ pItem->state);
4715 pExtra->
uState &= ~uMask;
4716 pExtra->
uState |= uMask & pItem->state;
4756 pExtra =
pList[uItem];
4766 if(!uChange || !
pEntry->uShowPos)
4774 uBits &= ~TVIF_CHILDREN;
4779 pEntry->lParam = pItem->lParam;
4783 pEntry->iImage = pItem->iImage;
4793 pEntry->iSelectedImage = pItem->iSelectedImage;
4803 bCall =
pEntry->bCallback;
4806 switch(pItem->cChildren) {
4808 pEntry->bCallback &= ~TVIF_CHILDREN;
4809 pEntry->bFlags &= ~TVIX_HASBUTTON;
4814 pEntry->bCallback &= ~TVIF_CHILDREN;
4821 pEntry->bFlags &= ~TVIX_VARBUTTON;
4826 pEntry->bCallback &= ~TVIF_CHILDREN;
4832 pEntry->bFlags &= ~TVIX_HASBUTTON;
4835 if(bCall !=
pEntry->bCallback || bFlags !=
pEntry->bFlags) {
4849 uLen =
str_len(pItem->pszText);
4851 if(uLen >
pEntry->uTextSize) {
4858 pEntry->bCallback &= ~TVIF_TEXT;
4866 uMask = pItem->stateMask;
4869 uMask &= ~TVIS_EXPANDED;
4872 uBits = uMask & (
pEntry->uState ^ pItem->state);
4873 pEntry->uState &= ~uMask;
4874 pEntry->uState |= uMask & pItem->state;
4882 if(
pData->hStates) {
4887 if(
pEntry->uState & 0x1000) {
4888 pData->uSingleSel = uItem;
4890 if(
pData->uSingleSel == uItem) {
4891 pData->uSingleSel = 0;
4895 pData->uSingleSel = uItem;
4897 if(
pData->uSingleSel == uItem) {
4898 pData->uSingleSel = 0;
4933 pEntry->uState ^= uBits & uMask;
4934 iVal = uMask & pItem->state;
4938 if(uChange &&
pEntry->uShowPos) {
4945 pEntry->uState &= ~uMask;
4950 if(uChange &&
pEntry->uShowPos) {
4976 uItem =
U(pItem->hItem);
4977 if(uItem >
pData->uTreeItemsMax)
4984 uBits = pItem->mask;
4987 uSub = pItem->cChildren;
4989 if(uSub >=
pData->uColumnCount)
4992 pExtra =
pList[uItem];
4999 pList[uItem] = pExtra;
5003 pItem->lParam =
pEntry->lParam;
5007 pItem->iImage = pExtra->
iImage;
5015 if(!pExtra->
pText) {
5016 pItem->pszText =
_T(
"");
5017 pItem->cchTextMax = 0;
5019 pItem->pszText = pExtra->
pText;
5020 pItem->cchTextMax = pExtra->
uTextSize + 1;
5025 if(pItem->cchTextMax < (
int)uLen) {
5026 if(pItem->cchTextMax <= 0) {
5029 uLen = pItem->cchTextMax - 1;
5030 pItem->pszText[uLen] = 0;
5036 if(pItem->cchTextMax > 0) {
5037 pItem->pszText[0] = 0;
5044 pItem->state = pExtra->
uState&~TVIS_BASEFLAGS;
5045 pItem->state &= pItem->stateMask;
5054 pItem->cChildren = (
pEntry->uFirstChild) ? 1 : 0;
5056 uBits &= ~TVIF_CHILDREN;
5062 pItem->lParam =
pEntry->lParam;
5066 pItem->iImage =
pEntry->iImage;
5070 pItem->iSelectedImage =
pEntry->iSelectedImage;
5077 pItem->cChildren = (
pEntry->uFirstChild) ? 1 : 0;
5085 pItem->pszText =
pEntry->pText;
5086 pItem->cchTextMax =
pEntry->uTextSize + 1;
5088 uLen =
pEntry->uTextSize + 1;
5089 if(pItem->cchTextMax < (
int)uLen) {
5090 if(pItem->cchTextMax <= 0) {
5093 uLen = pItem->cchTextMax - 1;
5094 pItem->pszText[uLen] = 0;
5103 pItem->state =
pEntry->uState;
5104 pItem->state &= pItem->stateMask;
5139 if(uCol >=
pData->uColumnCount)
5142 if(uCol && uCol ==
pData->uSelectedSub) {
5146 if(uCol && uCol ==
pData->uEditSub) {
5147 pData->uEditSub = 0;
5148 pData->uEditItem = 0;
5152 if(uCol && uCol ==
pData->uFocusSub) {
5153 pData->uFocusSub = 0;
5154 pData->uFocusItem = 0;
5157 if(uCol ==
pData->uTrackedSub) {
5158 pData->uTrackedSub = 0;
5159 pData->uTrackedItem = 0;
5164 iDelta =
pData->aColumn[uCol].sSize;
5165 iSub =
pData->aColumn[uCol].bWeight;
5171 for(uPos = 0; uPos <
pData->uColumnCount; uPos++) {
5174 if(
pData->aColumn[uPos].bWeight == 0) {
5175 iFix +=
pData->aColumn[uPos].sSize;
5179 iVar +=
pData->aColumn[uPos].sSize;
5180 iAll +=
pData->aColumn[uPos].bWeight;
5185 pData->uColumnCount--;
5187 if(
pData->uColumnCount > 0) {
5194 for(uItem = 0; uItem <=
pData->uTreeItemsMax; uItem++) {
5195 pExtra =
pList[uItem];
5201 delete(pExtra->
pText);
5215 if(
pData->aColumn[uCol].bWeight) {
5216 pData->uColumnCountVar--;
5219 if(
pData->aColumn[uCol].bMark) {
5220 pData->uMarkedCols--;
5223 uSub =
pData->aColumnPos[uCol];
5227 for(uIndex = 0; uIndex < uSub; uIndex++) {
5228 bItem =
pData->aColumnPos[uIndex - 1];
5233 pData->aColumnPos[uIndex] = bItem;
5236 for(; uIndex <=
pData->uColumnCount; uIndex++) {
5237 bItem =
pData->aColumnPos[uIndex + 1];
5243 pData->aColumnPos[uIndex] = bItem;
5246 for(uIndex =
pData->uColumnCount; uIndex > 0;) {
5248 bByte =
pData->aColumn[uIndex].bIndex;
5252 pData->aColumn[uIndex].bIndex = bByte;
5255 pData->aColumn[uIndex].bNext =
pData->aColumnPos[bByte + 1];
5258 pData->iFixSize = iFix;
5259 pData->iAllWeight = iAll;
5260 pData->aColumn[
pData->uColumnCount].bWeight = 0;
5262 if(iCnt && iDelta) {
5266 pData->iVarSize = 0;
5270 if(
pData->uSelectedSub > uCol) {
5271 pData->uSelectedSub--;
5274 if(
pData->uEditSub > uCol) {
5278 if(
pData->uFocusSub > uCol) {
5282 if(
pData->uTrackedSub > uCol) {
5283 pData->uTrackedSub--;
5286 if(!
pData->uColumnCount) {
5289 pData->uStartPixel = 0;
5290 pData->iRowHeight = 1;
5296 if(iXoff < 0x10000) {
5347 if(!
pData->hHeader) {
5355 pData->hHeader =
CreateWindow(
WC_HEADER,
NULL,
WS_VISIBLE |
WS_CHILD |
HDS_HORZ |
HDS_BUTTONS |
HDS_DRAGDROP, sRect.
left, sRect.
top, sRect.
right, iYoff,
pData->hWnd, (
HMENU)1,
NULL,
NULL);
5360 pData->iRowHeight = 1;
5372 pData->uSizeYsub = 0;
5381 memset(&sItem, 0,
sizeof(sItem));
5383 if(uCol >=
pData->uColumnCount) {
5384 uCol =
pData->uColumnCount;
5389 sItem.fmt = pColumn->fmt;
5408 sItem.iImage = pColumn->iImage;
5413 sItem.pszText = pColumn->pszText;
5417 iMin = pColumn->iOrder;
5432 sItem.cxy = pColumn->cx;
5433 iSize = pColumn->cx;
5434 iDelta = -pColumn->cx;
5438 iWeight = pColumn->cx;
5442 iVar =
pData->iVarSize;
5443 iFix =
pData->iFixSize;
5444 iAll =
pData->iAllWeight;
5445 iSize =
pData->uSizeX - iVar - iFix;
5452 if(
pData->uColumnCountVar) {
5453 iSize = (iVar * iWeight) / (iAll + iWeight);
5463 if(sItem.cxy < iMin)
5468 if(uCol & 0x80000000)
5471 if(
pData->uColumnCount > 0) {
5490 for(uIndex =
pData->uColumnCount + 2; uIndex > uCol; uIndex--) {
5491 bItem =
pData->aColumnPos[uIndex - 1];
5495 pData->aColumnPos[uIndex] = bItem;
5503 bItem =
pData->aColumnPos[uIndex];
5508 pData->aColumnPos[uIndex] = bItem;
5511 for(uIndex =
pData->uColumnCount;;) {
5512 bByte =
pData->aColumn[uIndex].bIndex;
5516 pData->aColumn[uIndex].bIndex = bByte;
5534 sFixed = (
short)((sItem.cxy > 0) ? sItem.cxy : 100);
5537 pData->aColumn[uCol].bWeight = (
BYTE)iWeight;
5538 pData->aColumn[uCol].sReal = (
short)sItem.cxy;
5539 pData->aColumn[uCol].sSize = (
short)iSize;
5541 pData->aColumn[uCol].bIndex = (
BYTE)uCol;
5542 pData->aColumn[uCol].bMinEx = bMinEx;
5543 pData->aColumn[uCol].bAlign = bAlign;
5544 pData->aColumn[uCol].bMark = bMark;
5545 pData->aColumn[uCol].sFixed = sFixed;
5546 pData->uMarkedCols += bMark;
5549 for(uIndex =
pData->uColumnCount;;) {
5550 bByte =
pData->aColumn[uIndex].bIndex;
5551 pData->aColumn[uIndex].bNext =
pData->aColumnPos[bByte + 1];
5557 if(
pData->uColumnCountVar) {
5560 pData->iVarSize -= iDelta;
5563 pData->iFixSize += iSize;
5567 pData->iVarSize = iSize;
5569 pData->iFixSize += iSize;
5572 pData->iAllWeight += iWeight;
5573 pData->uColumnCountVar += iAdd;
5574 pData->uColumnCount += 1;
5576 if(
pData->uSelectedSub > 0 &&
pData->uSelectedSub >= uCol) {
5577 pData->uSelectedSub++;
5580 if(
pData->uTrackedSub > 0 &&
pData->uTrackedSub >= uCol) {
5581 pData->uTrackedSub++;
5584 if(
pData->uFocusSub > 0 &&
pData->uFocusSub >= uCol) {
5588 if(
pData->uEditSub > 0 &&
pData->uEditSub >= uCol) {
5593 if(iXoff < 0x10000) {
5602 if(
pData->uInsertMark) {
5608 sSet.cChildren = uCol;
5612 pExtra =
pData->pExtraItems[uCol - 1][
pData->uInsertMark];
5654 if(uSub >=
pData->uColumnCount)
5659 pPList =
pData->pItemPos;
5662 for(uPos = 0; uPos <
pData->uItemPosCount; uPos++) {
5663 pExtra =
pItems[pPList[uPos]];
5671 iPos =
pData->iSubImgXsize;
5684 pPList =
pData->pItemPos;
5687 for(uPos = 0; uPos <
pData->uItemPosCount; uPos++) {
5691 iPos =
pData->iImagesXsize;
5696 iPos +=
pEntry->iTextPixels + 8;
5705 if(
pData->cHasRootRow) {
5706 iMax +=
pData->iIndent;
5709 if(
pData->hStates) {
5710 iMax +=
pData->iStatesXsize;
5740 iXpos = pInfo->pt.x;
5741 iYpos = pInfo->pt.y;
5743 if((
unsigned)iXpos >=
pData->uSizeX) {
5744 pInfo->hItem =
NULL;
5749 iYpos -=
pData->uStartPixel;
5751 if((
unsigned)iYpos >=
pData->uSizeY) {
5752 pInfo->hItem =
NULL;
5757 iZpos = iYpos /
pData->iRowHeight;
5758 iZpos +=
pData->uScrollY;
5760 if((
unsigned)iZpos >=
pData->uItemPosCount) {
5761 pInfo->hItem =
NULL;
5766 iXpos +=
pData->uScrollX;
5767 uItem =
pData->pItemPos [iZpos];
5774 uSub =
pData->aColumnPos[1];
5776 if(iXpos >=
pData->aColumnXpos[uSub]) {
5777 for(uCol = 1; uCol <
pData->uColumnCount; uCol++) {
5778 uSub =
pData->aColumnPos[uCol ];
5779 uNext =
pData->aColumnPos[uCol + 1];
5781 if(iXpos >=
pData->aColumnXpos[uNext])
5783 iXpos -=
pData->aColumnXpos[uSub ];
5785 pExtra =
pData->pExtraItems[uSub - 1][uItem];
5789 iIcon =
pData->iChecksXsize;
5792 iIcon =
pData->iImagesXsize;
5797 pInfo->flags = uSub << 24;
5809 switch(
pData->aColumn[uSub].bAlign) {
5812 if(iXpos - iIcon < pExtra->iTextPixels + 5) {
5819 iWidth =
pData->aColumnXpos[uNext];
5820 iWidth -=
pData->aColumnXpos[uSub ];
5829 iWidth =
pData->aColumnXpos[uNext];
5830 iWidth -=
pData->aColumnXpos[uSub ];
5835 if(iXpos <= iWidth + pExtra->iTextPixels / 2 + 3) {
5852 if(!
pData->cHasRootRow) {
5853 iXpos +=
pData->iIndent;
5858 if(iXpos < pData->iIndent) {
5861 if(iXpos >=
pData->iShift - 6)
5862 if(iXpos <= pData->iShift + 7) {
5863 iYpos %=
pData->iRowHeight;
5864 iYpos -=
pData->iRowHeight / 2;
5866 if(iYpos >= -6 && iYpos <= 7) {
5877 iXpos -=
pData->iIndent;
5883 if(
pData->hStates) {
5884 iXpos -=
pData->iStatesXsize;
5893 iXpos -=
pData->iImagesXsize;
5904 if(iXpos < pEntry->iTextPixels + 5 || !
pEntry->pText || !
pEntry->pText[0]) {
5931 if(
pData->uInsertMark) {
5933 pData->uInsertMark = 0;
5940 if(uItem >
pData->uTreeItemsMax)
5948 uItem =
pEntry->uPrevItem;
5969 for(uSub = 1; uSub <
pData->uColumnCount; uSub++) {
5970 sInsert.item.cChildren = uSub;
5974 pExtra =
pData->pExtraItems[uSub - 1][uItem];
5979 pData->uInsertMark = uItem;
6001 if(uItem >
pData->uTreeItemsMax)
6009 if(uSub >=
pData->uColumnCount)
6012 pExtra =
pData->pExtraItems[uSub - 1][uItem];
6049 if(uItem >
pData->uTreeItemsMax)
6057 if(
pData->uColumnCount) {
6058 for(uSub =
pData->uColumnCount; uSub > 0; uSub--) {
6067 if(uSub >=
pData->uColumnCount)
6070 pExtra =
pData->pExtraItems[uSub - 1][uItem];
6074 sSet.cChildren = uSub;
6079 pExtra =
pData->pExtraItems[uSub - 1][uItem];
6086 pExtra->
bFlags &= ~TVIX_TEXTCOLOR;
6095 pExtra->
bFlags &= ~TVIX_BKCOLOR;
6106 pEntry->bFlags &= ~TVIX_TEXTCOLOR;
6109 pEntry->uColorText = uColor;
6115 pEntry->bFlags &= ~TVIX_BKCOLOR;
6118 pEntry->uColorBk = uColor;
6123 if(uColor != uOld) {
6149 if(uSub >=
pData->uColumnCount) {
6156 if(uItem >
pData->uTreeItemsMax) {
6161 if(uItem ==
pData->uTrackedItem)
6162 if(uSub ==
pData->uTrackedSub) {
6167 if(
pData->uTrackedItem) {
6168 if(
pData->uTrackedSub) {
6169 pExtra =
pData->pExtraItems[
pData->uTrackedSub - 1][
pData->uTrackedItem];
6171 pExtra->
bFlags &= ~TVIX_TRACKED;
6177 pEntry->bFlags &= ~TVIX_TRACKED;
6185 pExtra =
pData->pExtraItems[uSub - 1][uItem];
6187 pData->uTrackedSub = uSub;
6188 pData->uTrackedItem = uItem;
6197 pData->uTrackedSub = 0;
6198 pData->uTrackedItem = uItem;
6206 pData->uTrackedSub = 0;
6207 pData->uTrackedItem = 0;
6230 return pData->uFirstChild;
6233 if(uItem >
pData->uTreeItemsMax) {
6241 return pEntry->uNextItem;
6244 if(uItem >
pData->uTreeItemsMax) {
6252 return pEntry->uPrevItem;
6255 if(uItem >
pData->uTreeItemsMax) {
6266 if(uItem >
pData->uTreeItemsMax) {
6268 return pData->uFirstChild;
6276 return pEntry->uFirstChild;
6279 if(uItem >
pData->uTreeItemsMax) {
6281 return pData->uLastChild;
6289 return pEntry->uLastChild;
6292 if(
pData->uItemPosCount <= 0)
6299 if(uItem >
pData->uTreeItemsMax || !
pData->pTreeItems[uItem]) {
6306 if(uItem >
pData->uTreeItemsMax) {
6309 if(
pData->uFirstChild == 0)
6315 if(uPos <= pData->uScrollY)
6318 return pData->uFirstChild;
6326 if(uPos <= pData->uScrollY)
6328 if(uPos >
pData->uScrollY +
pData->uPageEnties)
6331 uItem =
pData->pItemPos[uPos];
6333 if(uItem >
pData->uTreeItemsMax || !
pData->pTreeItems[uItem]) {
6340 if(uItem >
pData->uTreeItemsMax) {
6344 uItem =
pData->uFirstChild;
6358 if(
pEntry->uFirstChild) {
6359 uItem =
pEntry->uFirstChild;
6362 uItem =
pEntry->uNextItem;
6370 uItem =
pEntry->uNextItem;
6386 if(uItem >
pData->uTreeItemsMax) {
6390 uItem =
pData->uFirstChild;
6408 if(
pEntry->uFirstChild) {
6409 uItem =
pEntry->uFirstChild;
6412 uItem =
pEntry->uNextItem;
6422 uItem =
pEntry->uNextItem;
6438 if(uItem >
pData->uTreeItemsMax) {
6442 uItem =
pData->uFirstChild;
6456 if(
pEntry->uFirstChild) {
6457 uItem =
pEntry->uFirstChild;
6460 uItem =
pEntry->uNextItem;
6468 uItem =
pEntry->uNextItem;
6484 if(uItem >
pData->uTreeItemsMax) {
6492 uPos =
pEntry->uShowPos - 1;
6493 if(uPos <= pData->uScrollY)
6495 if(uPos >
pData->uScrollY +
pData->uPageEnties)
6498 return pData->pItemPos[uPos - 1];
6501 uPos =
pData->uItemPosCount;
6504 return pData->pItemPos[uPos - 1];
6507 return pData->uTrackedItem;
6510 return pData->uTrackedSub;
6513 return pData->uSelectedItem;
6516 return pData->uSelectedSub;
6519 return (
pData->uFocusItem) ?
pData->uFocusItem :
pData->uSelectedItem;
6553 if(uItem >
pData->uTreeItemsMax) {
6556 uItem =
pData->uFirstChild;
6562 uItem =
pEntry->uFirstChild;
6565 if(uItem >
pData->uTreeItemsMax) {
6574 uItem =
pEntry->uNextItem;
6589 for(; uItem; uItem =
pEntry->uNextItem) {
6606 if(uSub >=
pData->uColumnCount)
6609 pExtra =
pData->pExtraItems[uSub - 1][uItem];
6614 pCmpText = pExtra->
pText;
6623 pCmpText =
pEntry->pText;
6626 uTextSize =
pEntry->uTextSize;
6630 if(uTextLen != uTextSize)
6659 if(uItem >
pData->uTreeItemsMax) {
6663 uItem =
pData->uFirstChild;
6676 if(!
pEntry->uFirstChild && uItem == uStop)
6681 if(
pEntry->uFirstChild) {
6682 uItem =
pEntry->uFirstChild;
6687 uItem =
pEntry->uNextItem;
6699 uItem =
pEntry->uNextItem;
6731 if(uItem >
pData->uTreeItemsMax) {
6735 uItem =
pData->uFirstChild;
6748 if(!
pEntry->uFirstChild && uItem == uStop)
6753 if(
pEntry->uFirstChild) {
6754 uItem =
pEntry->uFirstChild;
6759 uItem =
pEntry->uNextItem;
6771 uItem =
pEntry->uNextItem;
6806 sNotify.itemOld.mask = 0;
6807 sNotify.itemOld.hItem = 0;
6813 pTemp =
pData->pTreeItems[
pData->uSingleSel];
6815 if(
pData->uSingleSel == uItem) {
6824 if(
pData->uSingleSel && pTemp) {
6834 sNotify.itemOld.stateMask = 0xFFFFFFFF;
6835 sNotify.itemOld.state = pTemp->
uState;
6836 sNotify.itemOld.lParam = pTemp->
lParam;
6837 sNotify.itemOld.pszText = pTemp->
pText;
6838 sNotify.itemOld.cchTextMax = pTemp->
uTextSize;
6839 sNotify.itemOld.cChildren = 0;
6848 sItem.state = (uBits ^ 0x1000);
6850 sItem.state = (uBits & 0x1000) ? 0x2000 : 0x1000;
6853 pData->uSingleSel = uItem;
6859 sNotify.itemNew.stateMask = 0xFFFFFFFF;
6860 sNotify.itemNew.state =
pEntry->uState;
6861 sNotify.itemNew.lParam =
pEntry->lParam;
6862 sNotify.itemNew.pszText =
pEntry->pText;
6863 sNotify.itemNew.cchTextMax =
pEntry->uTextSize;
6864 sNotify.itemNew.cChildren = 0;
6865 sNotify.ptDrag.x = iPosX;
6866 sNotify.ptDrag.y = iPosY;
6897 sNotify.itemNew.stateMask = 0xFFFFFFFF;
6898 sNotify.itemNew.state =
pEntry->uState;
6899 sNotify.itemNew.lParam =
pEntry->lParam;
6902 sNotify.itemNew.stateMask = 0;
6903 sNotify.itemNew.state = 0;
6904 sNotify.itemNew.lParam = 0;
6908 sNotify.hdr.code = uMsg;
6911 sNotify.itemNew.pszText = (
LPTSTR) - 1;
6912 sNotify.itemNew.cchTextMax = -1;
6913 sNotify.itemOld.mask = 0;
6954 if(!
pData->cIsEnabled) {
6958 if(!
pData->cHasFocus) {
6969 pData->cHasFocus = 1;
7007 if(sInfo.flags & uMaskItem) {
7011 pData->uDragItem = uItem;
7012 pData->uDragSub = 0;
7017 pData->uDragItem = uItem;
7018 pData->uDragSub = 0;
7024 if(
pData->uSelectedCount > 1) {
7033 if(
pData->uSelectedCount > 0) {
7036 pData->cClickFlag = 1;
7037 pData->cClickEdit = 0;
7052 pData->cClickEdit = 0;
7054 uTemp =
pData->uSelectedItem;
7056 uTemp =
pData->uFocusItem;
7057 if(!uTemp || !
pData->cReSelect)
7062 uLine =
pEntry->uShowPos;
7067 uStop =
pEntry->uShowPos;
7071 if(
pData->uSelectedCount <= 1) {
7072 pData->uSelectedBase = uTemp;
7076 if(
pData->cReSelect &&
pData->uSelectedBase) {
7080 uTemp =
pData->uSelectedBase;
7081 pTemp =
pData->pTreeItems[uTemp];
7084 while(pTemp && pTemp->
uShowPos == 0) {
7110 pData->cReSelect = 0;
7116 iAdd = (uLine > uStop) ? -1 : 1;
7128 if(
pEntry->uShowPos > uPos && uPos > uStop)
7132 if(
pEntry->uShowPos < uPos && uPos < uStop)
7138 for(;; uPos += iAdd) {
7139 uTemp =
pData->pItemPos [uPos - 1];
7143 if(uTemp !=
pData->uSelectedBase || !uSel) {
7152 for(uNum = uTemp;;) {
7159 for(uNum = uTemp;;) {
7179 pData->uFocusSub = uSub;
7180 pData->uFocusItem = uItem;
7183 pExtra =
pData->pExtraItems[uSub - 1][uItem];
7199 pData->uSelectedBase = uItem;
7200 pData->cReSelect = 1;
7201 pData->cClickEdit = 0;
7215 for(uTemp = uItem;;) {
7223 uTemp =
pData->uFocusItem;
7232 pData->uFocusItem = uItem;
7233 pData->uFocusSub = uSub;
7236 pExtra =
pData->pExtraItems[uSub - 1][uItem];
7256 uOldSub =
pData->uSelectedSub;
7257 uOldItem =
pData->uSelectedItem;
7282 if(uOldSub ==
pData->uSelectedSub && uOldItem ==
pData->uSelectedItem) {
7283 pData->cClickEdit = 1;
7291 if(uOldSub ==
pData->uSelectedSub && uOldItem ==
pData->uSelectedItem) {
7292 pData->cClickEdit = 1;
7295 if(
pData->cClickEdit) {
7296 pData->cClickEdit = 0;
7298 if(
pData->aColumn[0].bEdit) {
7306 if(sInfo.flags & uMaskSub) {
7315 pData->uDragItem = uItem;
7316 pData->uDragSub = uSub;
7321 pData->uDragItem = uItem;
7322 pData->uDragSub = uSub;
7340 for(uTemp = uItem;;) {
7350 pData->cClickEdit = 0;
7351 pData->uFocusItem = uItem;
7352 pData->uFocusSub = uSub;
7355 pExtra =
pData->pExtraItems[uSub - 1][uItem];
7373 uOldSub =
pData->uSelectedSub;
7374 uOldItem =
pData->uSelectedItem;
7382 if(
pData->aColumn[uSub].bEdit &&
7394 if(
pData->aColumn[uSub].bEdit)
7403 if(uOldSub ==
pData->uSelectedSub && uOldItem ==
pData->uSelectedItem) {
7404 pData->cClickEdit = 1;
7408 if(
pData->cClickEdit) {
7409 pData->cClickEdit = 0;
7411 if(
pData->aColumn[uSub].bEdit) {
7452 sNotify.itemNew.stateMask = 0xFFFFFFFF;
7453 sNotify.itemNew.state =
pEntry->uState;
7454 sNotify.itemNew.lParam =
pEntry->lParam;
7457 sNotify.itemNew.stateMask = 0;
7458 sNotify.itemNew.state = 0;
7459 sNotify.itemNew.lParam = 0;
7465 sNotify.itemNew.pszText = (
LPTSTR) - 1;
7466 sNotify.itemNew.cchTextMax = -1;
7467 sNotify.itemOld.mask = 0;
7507 if(
pData->cKeyIgnore)
7510 iMax =
pData->uItemPosCount;
7511 uSub =
pData->uSelectedSub;
7527 iNum =
pData->uSelectedItem;
7529 iNum =
pData->pTreeItems[iNum]->uShowPos - 1;
7534 if((nChar >=
'a' && nChar <=
'z') ||
7535 (nChar >= 224 && nChar <= 254)) {
7542 uDelta = (
uKeyPos > 0) ? 750 : 500;
7567 for(
i = iNum + 1;
i != iNum;
i++) {
7568 if(
i >= iMax) {
i = -1;
continue;}
7569 uItem =
pData->pItemPos[
i];
7573 pExtra = pExtra =
pData->pExtraItems[uSub - 1][uItem];
7575 pExtra =
pData->pExtraItems[uSub - 1][uItem];
7583 for(uPos = 0; uPos <
uKeyPos; uPos++) {
7587 uVal = ((
unsigned char *)
pName)[uPos];
7590 if((uVal >=
'a' && uVal <=
'z') ||
7591 (uVal >= 224 && uVal <= 254)) {
7660 if(!
pData->cIsEnabled) {
7664 if(!
pData->cHasFocus) {
7674 pData->cHasFocus = 1;
7688 iSub =
pData->uSelectedSub;
7690 if(
pData->aColumn[iSub].bEdit) {
7717 iSub =
pData->uScrollX;
7768 iMax =
pData->uItemPosCount;
7769 iMax -=
pData->uPageEnties - 1;
7783 if(iSub != (
int)
pData->uScrollX) {
7784 uVal =
pData->uColumnCount;
7786 iMax =
pData->aColumnXpos[uVal] -
pData->uSizeX / 2;
7788 iMax =
pData->iMaxSizeX;
7795 if(iSub != (
int)
pData->uScrollX)
7797 pData->uScrollX = iSub;
7801 if(
pData->hHeader) {
7807 iSub =
pData->uSelectedSub;
7808 iCol =
pData->aColumn[iSub].bIndex;
7816 uTemp =
pData->uFocusItem;
7818 pTemp =
pData->pTreeItems[uTemp];
7826 iSub =
pData->uFocusSub;
7827 iCol =
pData->aColumn[iSub].bIndex;
7830 if(
pData->uSelectedCount > 1) {
7842 uTemp =
pData->uSelectedItem;
7858 iSub =
pData->aColumnPos[iCol];
7859 if(
pData->aColumn[iSub].sReal > 0)
7881 while(iCol + 1 < (
int)
pData->uColumnCount) {
7883 iSub =
pData->aColumnPos[iCol];
7884 if(
pData->aColumn[iSub].sReal > 0)
7910 iAdd =
pData->uPageEnties - 1;
7917 iAdd =
pData->uPageEnties - 1;
7929 iLine =
pData->pTreeItems[uItem]->uShowPos - 1;
7949 if(iCol >= (
int)
pData->uColumnCount)
7950 iCol =
pData->uColumnCount - 1;
7961 if(
pData->uItemPosCount > 0)
7962 if(
iLine != iOldLine || iCol != iOldCol) {
7963 if(
pData->uSelectedCount > 1) {
7966 pData->uSelectedBase = uTemp;
7971 if(
pData->cReSelect) {
7976 pTemp =
pData->pTreeItems[uItem];
7977 iSub =
pData->aColumnPos[iCol ];
7986 if(
pData->cReSelect &&
pData->uSelectedBase) {
7987 uTemp =
pData->uSelectedBase;
7988 pTemp =
pData->pTreeItems[uTemp];
7991 while(pTemp && pTemp->
uShowPos == 0) {
7997 if(pTemp && !iShift) {
8003 if(iLineCmp <
iLine) {
8018 pData->cReSelect = 0;
8022 uVal =
pData->uSelectedBase;
8023 pTemp =
pData->pTreeItems[uVal];
8024 iBase = (pTemp) ? pTemp->
uShowPos - 1 : -1;
8026 if(
iLine > iOldLine) {
8027 iMax = (iOldLine > iBase) ? iOldLine + 1 : iOldLine;
8033 iPos = (iOldLine < iBase) ? iOldLine - 1 : iOldLine;
8038 for(; iPos >= iMax; iPos--) {
8039 uItem =
pData->pItemPos[iPos];
8041 if(iPos !=
iLine && iPos != iBase) {
8046 pTemp =
pData->pTreeItems[uItem];
8053 for(uTemp = uItem;;) {
8060 for(uTemp = uItem;;) {
8109 unsigned *pItemList;
8111 unsigned uEnties[128];
8120 int iLower, iUpper, iMiddle, iCmp;
8121 int uMemL[30], uMemU[30];
8130 if(uParent >
pData->uTreeItemsMax) {
8134 uLast =
pData->uLastChild;
8135 uFirst =
pData->uFirstChild;
8138 if(uFirst == uLast) {
8139 pNext =
pList[uFirst];
8158 uFirst =
pParent->uFirstChild;
8161 if(uFirst == uLast) {
8162 pNext =
pList[uFirst];
8175 pNext =
pList[uFirst];
8195 pItemList = uEnties;
8203 memcpy(pItemNew, pItemList, uPos *
sizeof(pItemList[0]));
8206 pItemList = pItemNew;
8209 pItemList[uPos] = uItem;
8210 pNext =
pList[uItem];
8217#define XCHANGE_MEM(a,b) uTemp=pItemList[a];pItemList[a]=pItemList[b];pItemList[b]=uTemp;
8219 pData->cLockChanges = 1;
8222 hTreeWnd =
pData->hWnd;
8224 lParamSort = pSortData->
lParam;
8231 iMiddle = (
iStart + iLast) >> 1;
8236 uItem = pItemList[
iStart];
8238 lParamTemp =
pList[uItem]->lParam;
8245 uItem = pItemList[iLower];
8253 uItem = pItemList[iUpper];
8265 if(iUpper - 1 -
iStart >= iLast - iLower) {
8266 if(
iStart + 1 < iUpper) {
8268 uMemU[iLevel] = iUpper - 1;
8271 if(iLower < iLast) {
8276 if(iLower < iLast) {
8277 uMemL[iLevel] = iLower;
8278 uMemU[iLevel] = iLast;
8282 if(
iStart + 1 < iUpper) {
8292 iLast = uMemU[iLevel];
8300 pData->cLockChanges = 0;
8307 pData->uFirstChild = pItemList[ 0 ];
8308 pData->uLastChild = pItemList[uPos];
8310 pEntry->uFirstChild = pItemList[ 0 ];
8311 pEntry->uLastChild = pItemList[uPos];
8315 uItem = pItemList[0];
8317 for(uNum = 0; uNum < uPos;) {
8319 pEntry->uPrevItem = uLast;
8323 uItem = pItemList[uNum];
8325 pEntry->uNextItem = uItem;
8329 pEntry->uPrevItem = uLast;
8337 if(
pData->uSelectedItem) {
8371 unsigned *pItemList;
8373 unsigned uEnties[128];
8380 int iLower, iUpper, iMiddle, iCmp;
8381 int uMemL[30], uMemU[30];
8388 uParent =
U(pSortData->hParent);
8389 if(uParent >
pData->uTreeItemsMax) {
8393 uLast =
pData->uLastChild;
8394 uFirst =
pData->uFirstChild;
8397 if(uFirst == uLast) {
8398 pNext =
pList[uFirst];
8403 sSort.lParam = pSortData->lParam;
8404 sSort.lpfnCompare = pSortData->lpfnCompare;
8416 uLast =
pData->uLastChild;
8417 uFirst =
pParent->uFirstChild;
8420 if(uFirst == uLast) {
8421 pNext =
pList[uFirst];
8426 sSort.lParam = pSortData->lParam;
8427 sSort.lpfnCompare = pSortData->lpfnCompare;
8434 pNext =
pList[uFirst];
8436 sSort.lParam = pSortData->lParam;
8437 sSort.lpfnCompare = pSortData->lpfnCompare;
8454 pItemList = uEnties;
8462 memcpy(pItemNew, pItemList, uPos *
sizeof(pItemList[0]));
8465 pItemList = pItemNew;
8468 pItemList[uPos] = uItem;
8469 pNext =
pList[uItem];
8475#define XCHANGE_MEM(a,b) uTemp=pItemList[a];pItemList[a]=pItemList[b];pItemList[b]=uTemp;
8477 pData->cLockChanges = 1;
8480 pCompare = pSortData->lpfnCompare;
8481 lParamSort = pSortData->lParam;
8488 iMiddle = (
iStart + iLast) >> 1;
8493 uItem = pItemList[
iStart];
8494 lParamTemp =
pList[uItem]->lParam;
8501 uItem = pItemList[iLower];
8502 iCmp = pCompare(
pList[uItem]->
lParam, lParamTemp, lParamSort);
8509 uItem = pItemList[iUpper];
8510 iCmp = pCompare(
pList[uItem]->
lParam, lParamTemp, lParamSort);
8521 if(iUpper - 1 -
iStart >= iLast - iLower) {
8522 if(
iStart + 1 < iUpper) {
8524 uMemU[iLevel] = iUpper - 1;
8527 if(iLower < iLast) {
8532 if(iLower < iLast) {
8533 uMemL[iLevel] = iLower;
8534 uMemU[iLevel] = iLast;
8538 if(
iStart + 1 < iUpper) {
8548 iLast = uMemU[iLevel];
8556 pData->cLockChanges = 0;
8563 pData->uFirstChild = pItemList[ 0 ];
8564 pData->uLastChild = pItemList[uPos];
8566 pEntry->uFirstChild = pItemList[ 0 ];
8567 pEntry->uLastChild = pItemList[uPos];
8571 uItem = pItemList[0];
8573 for(uNum = 0; uNum < uPos;) {
8575 pEntry->uPrevItem = uLast;
8579 uItem = pItemList[uNum];
8581 pEntry->uNextItem = uItem;
8585 pEntry->uPrevItem = uLast;
8593 if(
pData->uSelectedItem) {
8625 unsigned *pItemList;
8627 unsigned uEnties[128];
8633 int iLower, iUpper, iMiddle, iCmp;
8634 int uMemL[30], uMemU[30];
8643 if(uParent >
pData->uTreeItemsMax) {
8647 uLast =
pData->uLastChild;
8648 uFirst =
pData->uFirstChild;
8651 if(uFirst ==
pData->uLastChild) {
8652 pNext =
pList[uFirst];
8669 uFirst =
pParent->uFirstChild;
8672 if(uFirst ==
pParent->uLastChild) {
8673 pNext =
pList[uFirst];
8686 pNext =
pList[uItem];
8700 pItemList = uEnties;
8708 memcpy(pItemNew, pItemList, uPos *
sizeof(pItemList[0]));
8711 pItemList = pItemNew;
8714 pItemList[uPos] = uItem;
8715 pNext =
pList[uItem];
8721#define XCHANGE_MEM(a,b) uTemp=pItemList[a];pItemList[a]=pItemList[b];pItemList[b]=uTemp;
8723 pData->cLockChanges = 1;
8732 iMiddle = (
iStart + iLast) >> 1;
8737 uItem = pItemList[
iStart];
8745 pTextTemp =
pEntry->pText;
8754 uItem = pItemList[iLower];
8773 uItem = pItemList[iUpper];
8794 if(iUpper - 1 -
iStart >= iLast - iLower) {
8795 if(
iStart + 1 < iUpper) {
8797 uMemU[iLevel] = iUpper - 1;
8800 if(iLower < iLast) {
8805 if(iLower < iLast) {
8806 uMemL[iLevel] = iLower;
8807 uMemU[iLevel] = iLast;
8811 if(
iStart + 1 < iUpper) {
8821 iLast = uMemU[iLevel];
8829 pData->cLockChanges = 0;
8836 pData->uFirstChild = pItemList[ 0 ];
8837 pData->uLastChild = pItemList[uPos];
8839 pEntry->uFirstChild = pItemList[ 0 ];
8840 pEntry->uLastChild = pItemList[uPos];
8844 uItem = pItemList[0];
8846 for(uNum = 0; uNum < uPos;) {
8848 pEntry->uPrevItem = uLast;
8852 uItem = pItemList[uNum];
8854 pEntry->uNextItem = uItem;
8858 pEntry->uPrevItem = uLast;
8866 if(
pData->uSelectedItem) {
8911 uItem =
pData->uEditItem;
8912 uSub =
pData->uEditSub;
8913 cCb =
pData->cEditCb;
8915 pData->uEditItem = 0;
8916 pData->uEditSub = 0;
8919 if(uItem >
pData->uTreeItemsMax || uSub >=
pData->uColumnCount) {
8930 cText[
sizeof(cText) /
sizeof(cText[0]) - 1] = 0;
8932 sNotify.item.cchTextMax =
sizeof(cText) /
sizeof(cText[0]) - 1;
8933 sNotify.item.pszText = cText;
8935 if(
pData->cColumnStart) {
8944 sNotify.item.pszText =
NULL;
8945 sNotify.item.cchTextMax = 0;
8950 sNotify.item.stateMask = 0xFFFFFFFF;
8951 sNotify.item.cChildren = uSub;
8954 pExtra =
pData->pExtraItems[uSub - 1][uItem];
8956 sNotify.item.state = 0;
8957 sNotify.item.lParam = 0;
8960 sNotify.item.state |= pExtra->
uState;
8961 sNotify.item.lParam =
pEntry->lParam;
8964 sNotify.item.state =
pEntry->uState;
8965 sNotify.item.lParam =
pEntry->lParam;
8981 sNotify.item.cChildren = uSub;
8987 pGetT = sNotify.item.pszText;
8989 sSet.cchTextMax = sNotify.item.cchTextMax;
8991 sSet.pszText = pGetT;
8992 sSet.cChildren = uSub;
8994 iIcon =
pData->aColumn[uSub].iCbIcon;
8995 iAuto =
pData->aColumn[uSub].bEdit;
9003 sSet.iImage = iIcon + iPos;
9004 sSet.iSelectedImage = sSet.iImage;
9008 iMax =
pData->aColumn[uSub].bCbSize;
9017 for(iPos = 0; iPos < iMax; iPos++) {
9027 for(iPos = 0; iPos < iMax; iPos++) {
9028 for(iLen = 0;
pText[iLen]; iLen++) {
9029 if(
pText[iLen] == cChar)
9039 if(
pText[0] == cChar)
9047 sSet.iImage = iIcon + iSel;
9048 sSet.iSelectedImage = sSet.iImage;
9054 if(!
pData->cColumnStart) {
9056 pExtra =
pData->pExtraItems[uSub - 1][uItem];
9057 if(pExtra && pExtra->
pText) {
9138 uSel = (uSub >> 8) & 0x0FFFFF;
9141 if(uSub >=
pData->uColumnCount)
9143 if(uItem >
pData->uTreeItemsMax)
9149 if(uItem !=
pData->uSelectedItem || uSub !=
pData->uSelectedSub) {
9163 pData->hEdit =
CreateWindow(
_T(
"COMBOBOX"),
NULL,
WS_BORDER |
WS_CHILD |
CBS_AUTOHSCROLL |
CBS_DROPDOWN |
WS_VSCROLL, 0, 0, 0, 0,
pData->hWnd, (
HMENU)3,
NULL,
NULL);
9164 pData->uEditMode = 1;
9169 pData->hEdit =
CreateWindow(
_T(
"COMBOBOX"),
NULL,
WS_BORDER |
WS_CHILD |
CBS_AUTOHSCROLL |
CBS_DROPDOWNLIST |
WS_VSCROLL, 0, 0, 0, 0,
pData->hWnd, (
HMENU)3,
NULL,
NULL);
9170 pData->uEditMode = 2;
9185 pData->hEdit =
CreateWindow(
_T(
"EDIT"),
NULL,
WS_BORDER |
WS_CHILD |
ES_AUTOHSCROLL |
uFlags, 0, 0, 0, 0,
pData->hWnd, (
HMENU)3,
NULL,
NULL);
9186 pData->uEditMode = 0;
9213 if(
pData->uEditMode >= 1) {
9221 uSize =
pEntry->uTextSize;
9222 iPixels =
pEntry->iTextPixels + 10;
9233 iPixels = sRect.
right - sRect.
left + 10;
9239 uNext =
pData->aColumnPos[1];
9246 if(
pData->uEditMode) {
9258 if(
pData->uEditMode) {
9275 pExtra =
pData->pExtraItems[uSub - 1][uItem];
9277 pData->cTempText1[0] = 0;
9279 uSize =
sizeof(
pData->cTempText1) /
sizeof(
pData->cTempText1[0]);
9280 iPixels = sRect.
right - sRect.
left + 10;
9311 if(
pData->uEditMode) {
9323 if(
pData->uEditMode) {
9327 switch(
pData->aColumn[uSub].bAlign) {
9330 sRect.
left += iWidth - iPixels;
9335 sRect.
left += (iWidth - iPixels) / 2;
9347 sNotify.item.lParam =
lParam;
9348 sNotify.item.state = uState;
9349 sNotify.item.cchTextMax = uSize;
9350 sNotify.item.stateMask = 0xFFFFFFFF;
9351 sNotify.item.cChildren = uSub;
9366 if(
pData->uToolTipItem) {
9374 if(
pData->uEditMode) {
9378 uHeight =
pData->iFontHeight + 4;
9381 if(
pData->uEditMode) {
9389 cTemp =
pData->cColumnStart;
9393 pData->cColumnStart = cTemp;
9395 switch(uSel >> 18) {
9397 uStart = (uSel) & 0x01FF;
9398 uSize = (uSel >> 9) & 0x01FF;
9402 uStart = uSel & 0x3FFFF;
9414 if(uSize > 0 && iWidth < (
int)uSize - 1) {
9416 uSel += sSize.
cx / 2;
9422 if(sSize.
cx <= (
int)uSel) {
9437 switch(
pData->uEditMode) {
9454 pData->uEditItem = uItem;
9455 pData->uEditSub = uSub;
9457 return pData->hEdit;
9500 if(uItem == 0 || uItem >
pData->uTreeItemsMax)
9502 if(uSub > 0 && uSub >=
pData->uColumnCount)
9527 sNotify.
item.stateMask = 0xFFFFFFFF;
9529 sNotify.
item.cChildren = uSub;
9538 pExtra =
pData->pExtraItems[uSub - 1][
pData->uSelectedItem];
9541 sNotify.
item.state = pExtra->
uState&~TVIS_BASEFLAGS;
9545 sNotify.
item.state = 0;
9546 sNotify.
item.cchTextMax = 0;
9547 sNotify.
item.pszText =
_T(
"");
9579 cChar = (
TCHAR)((lRet >> 8) & 0xFF);
9595 for(uCnt = 0; uCnt < uMax; uCnt++) {
9612 for(uCnt = 0; uCnt < uMax; uCnt++) {
9613 for(uLen = 0;
pText[uLen]; uLen++) {
9614 if(
pText[uLen] == cChar)
9618 if(!uLen && !
pText[uLen])
9622 if(uNum >=
sizeof(cText) /
sizeof(
TCHAR)) {
9623 uNum =
sizeof(cText) /
sizeof(
TCHAR) - 1;
9635 if(!cChar || *
pText)
9663 pData->cColumnStart = 1;
9674 pData->cColumnStart = 0;
9718 if(
pData->uEditItem)
9720 if(
pData->uColumnCount <= uColumn)
9725 uBits =
pData->aColumn[uColumn].bFlags;
9726 uMode =
pData->aColumn[uColumn].bEdit;
9733 pExtra =
pData->pExtraItems[uColumn - 1][
pData->uSelectedItem];
9750 pData->cColumnStart = 1;
9752 pData->cColumnStart = 0;
9755 uMax =
pData->aColumn[uColumn].bCbSize;
9762 sItem.stateMask = 0xFFFFFFFF;
9764 sItem.cChildren = uColumn;
9778 uFlag = sItem.state & (~TVIS_STATEIMAGEMASK);
9781 sItem.state = (sItem.state ^ 0x1000);
9783 sItem.state = (sItem.state & 0x1000) ? 0x2000 : 0x1000;
9785 sItem.state |= uFlag;
9787 sItem.mask &= ~TVIF_STATE;
9796 sItem.mask &= ~TVIF_TEXT;
9797 pText = sItem.pszText;
9802 for(uPos = 0;; uPos++) {
9803 if(uPos >= uMax || !
pList[uPos]){
9809 if(uPos >= uMax || !
pList[uPos])
9818 sItem.mask &= ~TVIF_TEXT;
9819 pText = sItem.pszText;
9823 cChar = (
TCHAR)
pData->aColumn[uColumn].bCbChar;
9829 sItem.mask &= ~TVIF_TEXT;
9830 pText = sItem.pszText;
9835 for(uPos = 0;; uPos++) {
9842 for(uLen = 0;
pText[uLen]; uLen++) {
9843 if(
pText[uLen] == cChar)
9847 if(sItem.cchTextMax == (
int)uLen)
9858 if(
pText[0] == cChar)
9869 if(
pText[0] == cChar)
9879 for(uLen = 0;
pText[uLen] && uLen < 256; uLen++) {
9880 if(
pText[uLen] == cChar)
9882 cBuffer[uLen] =
pText[uLen];
9891 sItem.mask &= ~TVIF_TEXTPTR;
9894 sItem.pszText =
pText;
9895 sItem.cchTextMax = 256;
9896 sItem.cChildren = uColumn;
9897 iIcon =
pData->aColumn[uColumn].iCbIcon;
9901 sItem.iImage = iIcon + uPos;
9902 sItem.iSelectedImage = sItem.iImage;
9910 sNotify.itemNew.stateMask = 0xFFFFFFFF;
9911 sNotify.itemNew.hItem = sItem.hItem;
9912 sNotify.itemNew.state = sItem.state;
9913 sNotify.itemNew.lParam = sItem.lParam;
9914 sNotify.itemNew.pszText = sItem.pszText;
9915 sNotify.itemNew.cchTextMax = sItem.cchTextMax;
9916 sNotify.itemNew.cChildren = uColumn;
9917 sNotify.itemOld.mask = 0;
9931 uSub = (uMode - 1) << 29;
9952 sItem.cChildren = uColumn;
9960 for(uPos = 0; uPos < uMax; uPos++) {
9969 cChar = (
TCHAR)
pData->aColumn[uColumn].bCbChar;
9972 for(uPos = 0; uPos < uMax; uPos++) {
9973 for(uLen = 0;
pText[uLen]; uLen++) {
9974 if(
pText[uLen] == cChar)
9978 if(sItem.cchTextMax == (
int)uLen)
9998 if(
pText[0] == cChar)
10057 pData->uToolTipSize = 256;
10059 if(!
pData->pToolTipText) {
10065 if(!
pData->pTreeItems) {
10066 delete(
pData->pToolTipText);
10072 if(!
pData->pItemPos) {
10073 delete(
pData->pToolTipText);
10074 delete(
pData->pTreeItems);
10081 pData->pItemPos [0] = 0;
10091 pData->iAutoAdd = 1;
10092 pData->aColumnPos[0] = 0;
10093 pData->aColumnPos[1] = 1;
10096 pData->cHasRootRow = 0;
10131 pData->hStates = 0;
10133 pData->hChecks = 0;
10138 if(
pData->hHeader){
10140 pData->hHeader = 0;
10142 if(
pData->hToolTip){
10144 pData->hToolTip = 0;
10146 if(
pData->hStates){
10148 pData->hStates = 0;
10154 pData->hStates = 0;
10158 pData->hChecks = 0;
10160 pData->hImages = 0;
10161 pData->hSubImg = 0;
10162 pData->hHeadImg = 0;
10164 if(
pData->hStates){
10166 pData->hStates = 0;
10168 if(
pData->hChecks){
10170 pData->hChecks = 0;
10172 if(
pData->hImages){
10174 pData->hImages = 0;
10176 if(
pData->hSubImg){
10178 pData->hSubImg = 0;
10180 if(
pData->hHeadImg){
10183 pData->hHeadImg = 0;
10187 if(
pData->hThemeBt){
10189 pData->hThemeBt = 0;
10196 for(uVal = 1; uVal <
pData->uColumnCount; uVal++) {
10197 delete(
pData->pExtraItems[uVal - 1]);
10198 pData->pExtraItems[uVal - 1] = 0;
10206 pData->uColumnCount = 0;
10218 delete(
pData->pToolTipText);
10219 delete(
pData->pTreeItems);
10220 delete(
pData->pItemPos);
10249 pData->uOldXCount = 0xFFFF;
10250 pData->uOldYCount = 0xFFFF;
10266 if(uVal && uVal !=
pData->uSizeX) {
10267 uOld =
pData->uSizeX;
10268 pData->uSizeX = uVal;
10270 if(
pData->uColumnCountVar) {
10275 iDelta = uVal - uOld;
10291 sRect.
right = uVal;
10296 pData->aColumnXpos[
pData->uColumnCount + 1] = uVal + 1;
10303 if(uVal && uVal !=
pData->uSizeY) {
10304 if(uVal >
pData->uSizeY) {
10316 pData->uSizeY = uVal;
10317 pData->uSizeYsub = (uVal <=
pData->uStartPixel) ? 0 : uVal -
pData->uStartPixel;
10323 pData->uMaxEnties = 0;
10331 if(uFlag &&
pData->uPageEnties > 2 &&
pData->uScrollY > 0) {
10332 if(
pData->uScrollY +
pData->uPageEnties + 1 >
pData->uItemPosCount) {
10333 iPos =
pData->uItemPosCount -
pData->uPageEnties + 1;
10336 if(
U(iPos) !=
pData->uScrollY) {
10337 pData->uScrollY = iPos;
10358 uVal &= (0xFFFF0000 & ~WS_DISABLED);
10368 if(!
pData->cHasFocus) {
10372 pData->cHasFocus = 1;
10374 if(
pData->uSelectedCount <= 1) {
10375 if(
pData->uSelectedItem) {
10396 if(
pData->cHasFocus) {
10400 pData->cHasFocus = 0;
10402 if(
pData->uSelectedCount <= 1) {
10403 if(
pData->uSelectedItem) {
10428 if(!
pData->cIsEnabled) {
10443 if(!
pData->cIsEnabled) {
10477 if(iDiffX <= 2 && iDiffY <= 2) {
10483 if(
pData->uDragItem >
pData->uTreeItemsMax) {
10498 sNotify.itemNew.stateMask = 0xFFFFFFFF;
10499 sNotify.itemNew.state =
pEntry->uState;
10500 sNotify.itemNew.lParam =
pEntry->lParam;
10501 sNotify.itemNew.cChildren =
pData->uDragSub;
10502 sNotify.itemNew.pszText = (
LPTSTR) - 1;
10503 sNotify.itemNew.cchTextMax = -1;
10504 sNotify.itemOld.mask = 0;
10507 pData->uDragFlags = 0;
10508 pData->cClickFlag = 0;
10509 pData->cClickEdit = 0;
10523 pData->uDragFlags &= ~MK_LBUTTON;
10525 if(
pData->cClickFlag ||
pData->cClickEdit) {
10527 pData->cClickFlag = 0;
10528 pData->cClickEdit = 0;
10538 pData->uDragFlags &= ~MK_RBUTTON;
10552 if(
pData->cButtonFlag &&
pData->uToolTipItem) {
10553 pData->cButtonFlag = 0;
10554 uDelta = uTime -
pData->uButtonLast;
10567 pData->cButtonFlag = 1;
10568 pData->uButtonLast = uTime;
10583 pData->cButtonFlag = 0;
10606 for(iPos = 0; iPos < iMax; iPos++) {
10626 if(
pData->uEditItem)
10638 iPos =
pData->uScrollY - iDif;
10639 iMax =
pData->uItemPosCount;
10640 iMax -=
pData->uPageEnties - 1;
10646 if(iPos != (
int)
pData->uScrollY)
10648 pData->uScrollY = iPos;
10661 iPos =
pData->uScrollX;
10663 if(
pData->uEditItem)
10674 iPos +=
pData->uSizeX;
10677 iPos -=
pData->uSizeX;
10687 uVal =
pData->uColumnCount;
10689 iMax =
pData->aColumnXpos[uVal] -
pData->uSizeX / 2;
10691 iMax =
pData->iMaxSizeX;
10692 iMax -=
pData->uSizeX / 2;
10698 if(iPos != (
int)
pData->uScrollX) {
10699 pData->uScrollX = iPos;
10703 if(
pData->hHeader) {
10713 iPos =
pData->uScrollY;
10715 if(
pData->uEditItem)
10726 iPos += (
pData->uPageEnties > 1) ?
pData->uPageEnties - 1 : 1;
10729 iPos -= (
pData->uPageEnties > 1) ?
pData->uPageEnties - 1 : 1;
10733 if(
pData->uItemPosCount < 0x7F00) {
10743 iMax =
pData->uItemPosCount;
10744 iMax -=
pData->uPageEnties - 1;
10750 if(iPos != (
int)
pData->uScrollY) {
10751 pData->uScrollY = iPos;
10764 if(
pData->hTheme) {
10769 if(
pData->hThemeBt) {
10779 if(
pData->iStatesMode)
10781 if(
pData->iChecksMode)
10817 case WM_STYLECHANGED:
10839 pData->iStatesMode = 0;
10849 pData->cHasRootRow = 0;
10858 pData->uOldYCount = 0xFFFF;
10859 pData->uOldXCount = 0xFFFF;
10876 if(!
pData->cIsEnabled)
10902 if(hBufferedPaint) {
10921 if(
pData->uToolTipItem) {
10922 if(
pData->uToolTipShow) {
10923 pData->uToolTipShow--;
10924 if(
pData->uToolTipShow)
10931 sInfo.pt.x = sPoint.
x;
10932 sInfo.pt.y = sPoint.
y;
10944 if(
pData->uToolTipItem ==
U(sInfo.hItem) &&
pData->uToolTipSub == 0) {
10949 sInfo.cbSize =
sizeof(sInfo);
10950 sInfo.hwnd =
pData->hWnd;
10953 if(
pData->uToolTipItem) {
10969 sInfo.cbSize =
sizeof(sInfo);
10970 sInfo.hwnd =
pData->hWnd;
10973 if(
pData->uToolTipItem) {
11005 if(
pData->uEditItem) {
11009 if(
pData->uEditMode)
11017 if(
pData->uEditItem) {
11021 if(
pData->uEditMode)
11028 pData->cColumnStart = 1;
11047 iCode = pHdr->hdr.code;
11051 iCol = pHdr->iItem;
11053 if(
pData->aColumn[iCol].sReal != pHdr->pitem->cxy) {
11069 if(pHdr->pitem->iOrder == 0 || pHdr->iItem == 0) {
11087 if(!
pData->cHasFocus) {
11096 iNext =
pData->aColumn[pHdr->iItem].bIndex;
11098 for(iNext++;; iNext++) {
11099 if(
U(iNext) >=
pData->uColumnCount) {
11103 iSub =
pData->aColumnPos[iNext];
11105 if(
pData->aColumn[iSub].sFixed == 0) {
11111 if(
U(pHdr->iItem) <
pData->uColumnCount)
11112 if(
pData->aColumn[pHdr->iItem].sFixed) {
11117 if(
pData->aColumn[pHdr->iItem].sReal || pHdr->iItem < 0) {
11126 iCol =
pData->aColumn[pHdr->iItem].bIndex;
11127 iSub =
pData->aColumnPos[iCol - 1];
11138 if(!
pData->cHasFocus) {
11146 if(
U(pHdr->iItem) <
pData->uColumnCount)
11147 if(
pData->aColumn[pHdr->iItem].sFixed) {
11156 pHdr->pitem = &sItem;
11159 if(
pData->aColumn[pHdr->iItem].bMinEx)
11160 if(
pData->aColumn[pHdr->iItem].sMin > sItem.cxy) {
11161 sItem.cxy =
pData->aColumn[pHdr->iItem].sMin;
11177 iCol = pHdr->iItem;
11179 sItem.cxy = pHdr->pitem->cxy;
11181 if(
pData->aColumn[iCol].bMinEx)
11182 if(
pData->aColumn[iCol].sMin > sItem.cxy) {
11183 sItem.cxy =
pData->aColumn[iCol].sMin;
11184 pHdr->pitem->cxy = sItem.cxy;
11186 if(sItem.cxy ==
pData->aColumn[iCol].sSize) {
11193 if(iCol == 0 && sItem.cxy <= 0) {
11195 pHdr->pitem->cxy = 1;
11197 if(sItem.cxy ==
pData->aColumn[iCol].sSize) {
11203 iNext =
pData->aColumn[iCol].bIndex;
11205 for(iNext++;; iNext++) {
11206 if(
U(iNext) >=
pData->uColumnCount) {
11211 iSub =
pData->aColumnPos[iNext];
11213 if(
pData->aColumn[iSub].sFixed == 0) {
11218 iDelta =
pData->aColumn[iCol].sReal - sItem.cxy;
11219 sTemp.cxy =
pData->aColumn[iSub].sReal + iDelta;
11222 if(sTemp.cxy < 0) {
11224 iDelta = -
pData->aColumn[iSub].sReal;
11225 sItem.cxy =
pData->aColumn[iCol].sReal - iDelta;
11228 if(
pData->aColumn[iSub].bMinEx)
11229 if(
pData->aColumn[iSub].sMin > sTemp.cxy) {
11230 iDelta +=
pData->aColumn[iSub].sMin - sTemp.cxy;
11231 sTemp.cxy =
pData->aColumn[iSub].sMin;
11232 sItem.cxy =
pData->aColumn[iCol].sReal - iDelta;
11235 pHdr->pitem->cxy = sItem.cxy;
11243 if(
pData->aColumn[iSub].bWeight) {
11244 pData->iVarSize -=
pData->aColumn[iSub].sSize;
11245 pData->iVarSize += sTemp.cxy;
11247 pData->iFixSize -=
pData->aColumn[iSub].sSize;
11248 pData->iFixSize += sTemp.cxy;
11253 iDif =
pData->aColumn[iSub].sReal;
11254 pData->aColumn[iSub].sSize = (
short)sTemp.cxy;
11255 pData->aColumn[iSub].sReal = (
short)sTemp.cxy;
11266 sNotify.
iSize = sTemp.cxy;
11274 if(
pData->aColumn[iCol].bWeight) {
11275 pData->iVarSize -=
pData->aColumn[iCol].sSize;
11276 pData->iVarSize += sItem.cxy;
11278 pData->iFixSize -=
pData->aColumn[iCol].sSize;
11279 pData->iFixSize += sItem.cxy;
11282 iDif =
pData->aColumn[iCol].sReal;
11283 pData->aColumn[iCol].sSize = (
short)sItem.cxy;
11284 pData->aColumn[iCol].sReal = (
short)sItem.cxy;
11288 if(iSize < 0x10000) {
11290 sRect.
left = iSize;
11306 sNotify.
iSize = sItem.cxy;
11317 if(!
pData->cHasFocus) {
11327 switch(pHdr->
code) {
11332 pInfo->lpszText =
pData->pToolTipText;
11380 if(!
pData->hImages) {
11381 pData->iImagesXsize = 0;
11382 pData->iImagesYsize = 0;
11393 pData->iSubImgMode = 0;
11399 if(!
pData->cFixedHeight) {
11400 pData->iRowHeight = 1;
11423 if(!
pData->cFixedHeight) {
11424 pData->iRowHeight = 1;
11437 if(
pData->iStatesMode) {
11442 pData->iStatesMode = 0;
11446 if(!
pData->hStates) {
11447 pData->iStatesXsize = 0;
11448 pData->iStatesYsize = 0;
11455 pData->iStatesXsize = 16;
11456 pData->iStatesYsize = 16;
11457 pData->iStatesMode = 1;
11458 if(!
pData->hThemeBt)
11465 pData->iStatesMode = 0;
11468 if(!
pData->cFixedHeight) {
11469 pData->iRowHeight = 1;
11483 if(
pData->iChecksMode) {
11488 pData->iChecksMode = 0;
11492 if(!
pData->hChecks) {
11493 pData->iChecksXsize = 0;
11494 pData->iChecksYsize = 0;
11496 for(uVal = 0; uVal <
pData->uColumnCount; uVal++) {
11504 pData->iChecksXsize = 16;
11505 pData->iChecksYsize = 16;
11506 pData->iChecksMode = 1;
11507 if(!
pData->hThemeBt)
11514 pData->iChecksMode = 0;
11517 if(!
pData->cFixedHeight) {
11518 pData->iRowHeight = 1;
11532 if(
pData->iSubImgMode) {
11534 pData->iSubImgMode = 0;
11539 pData->iSubImgMode = 0;
11548 pData->iSubImgMode = 1;
11551 if(!
pData->cFixedHeight) {
11552 pData->iRowHeight = 1;
11603 lRet =
pData->iAutoAdd;
11609 if(
pData->uItemPosCount > 0) {
11719 return pData->uStyleEx;
11730 if(
pData->uStyleEx != uVal) {
11732 uChange =
pData->uStyleEx ^ uVal;
11733 pData->uStyleEx = uVal;
11756 if(
pData->hHeader){
11894 lRet = (lRet < 0) ? 0 : 1;
11913 if(!
pData->hHeader)
11930 return pData->uTreeItemsCount;
11935 return pData->iIndent;
11940 lRet =
pData->iIndent;
11957 return pData->iRowHeight;
11962 lRet =
pData->iRowHeight;
11966 pData->cFixedHeight = 0;
11983 pData->cFixedHeight = 1;
11994 return pData->uPageEnties;
12027 uVal = *(
unsigned *)
lParam;
12058 wParam &= ~TVE_EXPANDNEXT;
12066 pEntry->uState &= ~TVIS_EXPANDPARTIAL;
12073 while(
pEntry->uLastChild) {
12257 return pData->uItemPosCount;
12263 return pData->uMaxEnties;
12277 lRet =
pEntry->uShowPos - 1;
12296 pData->cColumnStart = 0;
12323 if(lParam < 0 || lParam > 0x1000000)
12329 if(
pData->uTreeItemsCount > 0) {
12343 return pData->uUserDataSize;
12374 if(
pData->aColumn[uCol].sFixed > 0) {
12375 uVal =
pData->aColumn[uCol].sFixed;
12377 uVal =
pData->aColumn[uCol].sReal;
12384 if(uBit != 0 &&
pData->aColumn[uCol].sFixed == 0) {
12385 pData->aColumn[uCol].sFixed =
pData->aColumn[uCol].sReal;
12386 if(!
pData->aColumn[uCol].sFixed)
12387 pData->aColumn[uCol].sFixed = 100;
12390 if(uBit == 0 &&
pData->aColumn[uCol].sFixed != 0) {
12391 pData->aColumn[uCol].sFixed = 0;
12402 sItem.iImage = pCol->iImage;
12407 pData->aColumn[uCol].sSize = (
short)sItem.cxy;
12411 sItem.pszText = pCol->pszText;
12412 sItem.cchTextMax = pCol->cchTextMax;
12421 if(lRet && (pCol->mask &
TVCF_FMT)) {
12424 switch(pCol->fmt) {
12427 default: bAlign =
DT_LEFT;
break;
12430 if(
pData->aColumn[uCol].bAlign != bAlign) {
12431 pData->aColumn[uCol].bAlign = bAlign;
12441 if(uVal !=
pData->aColumn[uCol].bMark) {
12442 pData->aColumn[uCol].bMark = (
BYTE)uVal;
12443 pData->uMarkedCols += uVal * 2 - 1;
12445 uNext =
pData->aColumn [uCol ].bNext;
12446 sRect.
left =
pData->aColumnXpos[uCol ];
12447 sRect.
right =
pData->aColumnXpos[uNext] + 1;
12462 if(
pData->hHeader) {
12482 sItem.pszText = pCol->pszText;
12483 sItem.cchTextMax = pCol->cchTextMax;
12492 pCol->fmt = sItem.fmt;
12494 if(bWantMark &&
pData->aColumn[uCol].bMark)
12496 if(!
pData->aColumn[uCol].sReal &&
pData->aColumn[uCol].sFixed)
12501 pCol->iImage = sItem.iImage;
12505 pCol->cx = sItem.cxy;
12509 pCol->pszText = sItem.pszText;
12510 pCol->cchTextMax = sItem.cchTextMax;
12548 uVal = (
wParam >> 11) & 0x3F;
12550 if(uVal >=
pData->uColumnCount) {
12568 pData->aColumn[uVal].bEdit = (
BYTE)(uMode);
12573 pData->aColumn[uVal].iCbIcon = -1;
12576 if(!
pData->hChecks) {
12600 if(uVal >=
pData->uColumnCount || !
pData->aColumn[uVal].bEdit) {
12615 if(
pData->hHeader) {
12649 return (uDelta <= 750) ?
uKeyPos : 0;
12707 unsigned uTextSize;
12708 unsigned uRgnCount;
12709 unsigned uAutoMask;
12710 unsigned uFirstPos;
12752 pOffsets =
pData->aColumnXpos;
12755 uMax =
pData->uColumnCount;
12761 for(uPos = 0; uPos < uMax; uPos++) {
12762 uExtra =
pData->aColumnPos[uPos ];
12763 uNext =
pData->aColumnPos[uPos + 1];
12771 uRgnCount = uMax + 1;
12774 iHeight =
pData->iRowHeight;
12775 uStyleEx =
pData->uStyleEx;
12776 uStyle =
pData->uStyle;
12777 iIndent =
pData->iIndent;
12778 iShift =
pData->iShift;
12779 uPos =
pData->uScrollY;
12780 uMax =
pData->uMaxEnties + uPos;
12781 uNext = (
pData->uColumnCount <= 1) ? 1 :
pData->aColumn[1].bIndex;
12782 uFirstPos =
pData->aColumnXpos[uNext];
12785 iMaxX =
pData->iMaxSizeX;
12787 iMaxX = uFirstPos - 1;
12799 if(uMax >
pData->uItemPosCount) {
12800 uMax =
pData->uItemPosCount;
12812 uOdColor = uBkColor;
12813 uEvColor = uBkColor;
12818 if(!
pData->cIsEnabled)
12821 uEvColor = uEcColor;
12822 uOdColor = uOcColor;
12839 for(; uPos < uMax; uPos++) {
12840 uItem =
pData->pItemPos[uPos];
12852 uMark = (
unsigned)~TVIS_BKCOLOR;
12856 uColMark =
pData->aColumn[0].bMark;
12857 uOutColor = (uColMark) ? uOcColor : uOdColor;
12858 uMark = 0xFFFFFFFF;
12860 uColMark =
pData->aColumn[0].bMark;
12861 uOutColor = (uColMark) ? uEcColor : uEvColor;
12862 uMark = 0xFFFFFFFF;
12866 sArea.
left = iXscroll;
12867 iLevel =
pEntry->uLevel;
12873 uBits =
pEntry->uState & 0xFFFF;
12874 uBits |=
pEntry->bFlags << 16;
12878 uTextSize =
pEntry->uTextSize;
12880 if(
pData->uSelectedSub && uItem ==
pData->uSelectedItem) {
12882 uBits &= ~TVIS_SELECTED;
12898 sButton.
right = iIndent * (iLevel + 1) + 2;
12906 if(
pData->aColumn[0].bMark) {
12912 if(
pData->cHasRootRow)
12933 sArea.
left += iIndent * iLevel + 1;
12935 for(
i = iLevel;
i > 0;
i--) {
12937 sArea.
left -= iIndent;
12941 iXpos = sArea.
left + iShift;
12953 sArea.
left += iIndent * iLevel;
12956 sArea.
right = sArea.
left + iIndent * iLevel;
12964 iXpos = sArea.
left + iShift;
12965 iYpos = sArea.
top +
pData->iRowHeight / 2;
12975 LineTo(hDc, iXpos, iYpos + 1);
12982 sButton.
left = iXpos - 4;
12983 sButton.
top = iYpos - 4;
12984 sButton.
right = iXpos + 5;
12985 sButton.
bottom = iYpos + 5;
12987 if(
pData->cGlyphOk) {
12996 sButton.
right -= 1;
13002 sButton.
left = iXpos - 2;
13003 sButton.
top = iYpos ;
13004 sButton.
right = iXpos + 3;
13005 sButton.
bottom = iYpos + 1;
13012 sButton.
left = iXpos ;
13013 sButton.
top = iYpos - 2;
13014 sButton.
right = iXpos + 1;
13015 sButton.
bottom = iYpos + 3;
13023 sArea.
left += iIndent;
13029 iYpos = sArea.
top +
pData->iRowHeight / 2;
13030 iXpos = sArea.
left + iShift;
13036 LineTo(hDc, iXpos, iYpos + 1);
13041 sArea.
left += iIndent;
13078 if(
pData->hStates) {
13080 iYpos = sArea.
top + (iHeight -
pData->iStatesYsize) / 2;
13083 sArea.
right += iAdd;
13085 sArea.
left += iAdd;
13091 if(
i >= 1 &&
i <= 2) {
13106 iImage &= ~TV_NOAUTOEXPAND;
13108 if((
pEntry->uState & uAutoMask) &&
pEntry->uFirstChild) {
13114 iYpos = sArea.
top + (iHeight -
pData->iSubImgYsize) / 2;
13117 sArea.
right += iAdd;
13119 sArea.
left += iAdd;
13126 iImage &= ~TV_NOAUTOEXPAND;
13128 if((
pEntry->uState & uAutoMask) &&
pEntry->uFirstChild) {
13129 iImage +=
pData->iAutoAdd;
13133 iYpos = sArea.
top + (iHeight -
pData->iImagesYsize) / 2;
13136 sArea.
right += iAdd;
13138 sArea.
left += iAdd;
13145 pEntry->bFlags &= ~TVIX_HASIMAGE;
13148 sArea.
right = uFirstPos;
13149 iYpos = sArea.
top + (iHeight -
pData->iFontHeight) / 2;
13154 INT *pPos = (
INT *)
new(
INT, uTextSize + 4);
13158 sButton.
top = iYpos;
13164 sButton.
right -= 2;
13166 pEntry->iTextPixels = 0;
13169 if(
pData->cHasFocus == 0 || uItem !=
pData->uSelectedItem ||
pData->uSelectedSub)
13192 uTextSize = iCount + 3;
13209 if(
pData->cHasFocus) {
13215 uTempColor =
pEntry->uColorText;
13233 uTempColor =
pEntry->uColorText;
13268 if(!
pEntry->iTextPixels && uTextSize) {
13269 sButton.
top = iYpos;
13281 INT *pPos = (
INT *)
new(
INT, uTextSize);
13293 sArea.
right = sArea.
left + 2 + pPos[iCount - 1];
13311 i = sArea.
left - iXscroll;
13312 i +=
pEntry->iTextPixels + 5;
13328 sArea.
top += iHeight;
13334 sArea.
top -= iHeight;
13341 uNextColor = uOutColor;
13343 if(
pData->aColumn[0].bMark) {
13347 for(uColumn = 1; uColumn <=
pData->uColumnCount; uColumn++) {
13348 uExtra =
pData->aColumnPos[uColumn ];
13349 uNext =
pData->aColumnPos[uColumn + 1];
13351 if(
pData->aColumn[uExtra].sReal == 0)
13352 if(uColumn < pData->uColumnCount) {
13356 if(uColMark !=
pData->aColumn[uExtra].bMark)
13359 uColMark =
pData->aColumn[uExtra].bMark;
13360 uOutColor = (uColMark) ? uOcColor : uOdColor;
13362 uColMark =
pData->aColumn[uExtra].bMark;
13363 uOutColor = (uColMark) ? uEcColor : uEvColor;
13374 sArea.
left =
pData->aColumnXpos[uExtra];
13375 sArea.
left += iXscroll;
13386 sArea.
top += iHeight;
13389 if(uColumn < pData->uColumnCount)
13390 sArea.
right += iXscroll;
13394 sArea.
top -= iHeight;
13404 if(uColumn < pData->uColumnCount) {
13405 sArea.
right += iXscroll;
13406 pExtra =
pData->pExtraItems[uExtra - 1][uItem];
13408 uNextColor = uOutColor;
13417 iSize =
pData->iSubImgXsize;
13418 hImgList =
pData->hSubImg;
13419 iImage = pExtra->
iImage;
13422 uBits = (pExtra->
uState & 0xFFFF);
13423 uBits |= (pExtra->
bFlags << 16);
13427 if(uExtra !=
pData->uSelectedSub) {
13428 uBits &= ~TVIS_SELECTED;
13433 pExtra =
pData->pExtraItems[uExtra - 1][uItem];
13442 hImgList =
pData->hChecks;
13443 iSize =
pData->iChecksXsize;
13445 uBits &= ~TVIS_OVERLAYMASK;
13455 iYpos = sArea.
top + (iHeight - iSize) / 2;
13465 if(iImage == 1 || iImage == 2) {
13473 sArea.
left += iSize + 1;
13475 sArea.
right += iXscroll;
13477 pExtra->
bFlags &= ~TVIX_HASIMAGE;
13480 iYpos = sArea.
top + (iHeight -
pData->iFontHeight) / 2;
13486 INT *pPos = (
INT *)
new(
INT, uTextSize + 4);
13490 sButton.
top = iYpos;
13497 sButton.
right -= 2;
13502 if(
pData->cHasFocus == 0 || uItem !=
pData->uSelectedItem)
13513 if(uTextSize > 253)
13516 iSize = sArea.
right - sButton.
left - 2;
13528 uTextSize = iCount + 3;
13532 switch(
pData->aColumn[uExtra].bAlign) {
13535 iDelta -= sButton.
right - sButton.
left;
13538 sButton.
right += iDelta;
13539 sButton.
left += iDelta;
13544 iDelta -= sButton.
right - sButton.
left;
13546 sButton.
right += iDelta;
13547 sButton.
left += iDelta;
13565 uTempColor =
pEntry->uColorText;
13618 sButton.
top = iYpos;
13632 INT *pPos = (
INT *)
new(
INT, uTextSize);
13644 sArea.
right = sArea.
left + 2 + pPos[iCount - 1];
13658 switch(
pData->aColumn[uExtra].bAlign) {
13691 for(uColumn = 0; uColumn <
pData->uColumnCount; uColumn++) {
13692 uExtra =
pData->aColumnPos[uColumn ];
13693 uNext =
pData->aColumnPos[uColumn + 1];
13694 uMark =
pData->aColumn[uExtra].bMark;
13697 sRect.
right =
pData->aColumnXpos[uNext] + uMark;
13717 if(
pData->iMaxSizeX != iMaxX) {
13718 pData->iMaxSizeX = iMaxX;
13719 if(
pData->uColumnCount == 0)
13720 if(
pData->iMaxSizeX != (
int)
pData->uOldXCount) {
13729 for(uPos = 0; uPos < uRgnCount; uPos++) {
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
#define InterlockedIncrement
#define InterlockedDecrement
BOOL WINAPI ImageList_Draw(HIMAGELIST himl, INT i, HDC hdc, INT x, INT y, UINT fStyle)
BOOL WINAPI ImageList_GetImageInfo(HIMAGELIST himl, INT i, IMAGEINFO *pImageInfo)
BOOL WINAPI ImageList_Destroy(HIMAGELIST himl)
INT WINAPI ImageList_AddMasked(HIMAGELIST himl, HBITMAP hBitmap, COLORREF clrMask)
HIMAGELIST WINAPI ImageList_Create(INT cx, INT cy, UINT flags, INT cInitial, INT cGrow)
#define GetProcAddress(x, y)
DWORD WINAPI GetTickCount(VOID)
unsigned int(__cdecl typeof(jpeg_read_scanlines))(struct jpeg_decompress_struct *
unsigned short(__cdecl typeof(TIFFCurrentDirectory))(struct tiff *)
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
void WINAPI SHIM_OBJ_NAME() OutputDebugStringA(LPCSTR lpOutputString)
#define memcpy(s1, s2, n)
#define memmove(s1, s2, n)
#define sprintf(buf, format,...)
static DWORD *static HFONT(WINAPI *pCreateFontIndirectExA)(const ENUMLOGFONTEXDVA *)
static unsigned(__cdecl *hash_bstr)(bstr_t s)
static const CLSID *static CLSID *static const GUID VARIANT VARIANT *static IServiceProvider DWORD *static HMENU
static int int const SCRIPT_CONTROL const SCRIPT_STATE SCRIPT_ITEM * pItems
unsigned __int3264 UINT_PTR
int(CALLBACK * PFNTVCOMPARE)(LPARAM lParam1, LPARAM lParam2, LPARAM lParamSort)
#define TVM_CREATEDRAGIMAGE
#define TVE_COLLAPSERESET
#define TVM_SORTCHILDRENCB
#define HDN_DIVIDERDBLCLICK
#define TVGN_FIRSTVISIBLE
#define TVN_BEGINLABELEDIT
#define TVM_ENDEDITLABELNOW
#define Header_SetItem(hwndHD, i, phdi)
#define TVGN_PREVIOUSVISIBLE
#define TVM_GETISEARCHSTRING
#define TVE_EXPANDPARTIAL
#define TVIS_EXPANDEDONCE
#define Header_GetOrderArray(hwnd, iCount, lpi)
#define TVHT_ONITEMINDENT
#define TVM_GETUNICODEFORMAT
struct _IMAGELIST * HIMAGELIST
#define Header_SetOrderArray(hwnd, iCount, lpi)
#define TVM_GETITEMHEIGHT
#define Header_InsertItem(hwndHD, i, phdi)
#define TVHT_ONITEMBUTTON
#define TVS_SHOWSELALWAYS
#define TVS_FULLROWSELECT
struct _TREEITEM * HTREEITEM
#define Header_DeleteItem(hwndHD, i)
#define LPSTR_TEXTCALLBACK
#define TVM_SETINSERTMARKCOLOR
#define TVHT_ONITEMSTATEICON
#define TVS_NONEVENHEIGHT
#define TVM_GETEDITCONTROL
#define TTM_TRACKPOSITION
#define TVM_SETINSERTMARK
#define I_CHILDRENCALLBACK
#define TVM_GETVISIBLECOUNT
#define TVIS_STATEIMAGEMASK
#define TVIS_EXPANDPARTIAL
#define TVM_ENSUREVISIBLE
#define TVN_ITEMEXPANDING
#define TVS_DISABLEDRAGDROP
#define TVM_GETINSERTMARKCOLOR
#define LVIS_STATEIMAGEMASK
#define TTM_TRACKACTIVATE
#define TVIF_SELECTEDIMAGE
#define TTM_SETMAXTIPWIDTH
#define TVM_SETITEMHEIGHT
PFNTVCOMPAREEX lpfnCompare
BITMAPINFOHEADER bmiHeader
static int TreeListSetItem(TreeListData *pData, const TV_ITEM *pItem)
static int TreeListDeleteColumn(TreeListData *pData, unsigned uCol)
#define CBS_UNCHECKEDNORMAL
static BeginBufferedPnT pBeginBufferedPt
static int UpdateFont(TreeListData *pData)
static TCHAR cKeyData[16]
static void GlobalDeinit()
static int TreeListIsVisible(TreeListData *pData, unsigned uItem, unsigned uSub)
static void CreateStateImageList(TreeListData *pData, int iMode)
static int TreeListXorSelectItem(TreeListData *pData, unsigned uItem, int iMode)
LPVOID(WINAPI * OpenThemeDataT)(HWND hwnd, LPCWSTR pszClassList)
static int TreeListSetTrackItem(TreeListData *pData, unsigned uItem, unsigned uSub)
static void UpdateColorsList(TreeListData *pData)
static int UpdateHeight(TreeListData *pData)
static unsigned TreeListHitTest(TreeListData *pData, TV_HITTESTINFO *pInfo)
static HFONT hDefaultFontB
static unsigned TreeListGetNextItem(TreeListData *pData, unsigned uItem, unsigned uFlags)
static LRESULT CALLBACK TreeListProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
static HWND TreeListEditLabel(TreeListData *pData, unsigned uItem, unsigned uSub)
static IsAppThemedT pIsAppThemed
static int TreeListSortItemsCb(TreeListData *pData, TV_SORTCB *pSortData, int iMode)
static void UpdateScrollX(TreeListData *pData)
static void CreateToolTip(TreeListData *pData)
static int TreeListToggleItem(TreeListData *pData, unsigned uItem, unsigned uAddFlags)
static GetThemeBackgRcT pGetThemeBackgRc
#define CBS_CHECKEDNORMAL
static IsThemeActiveT pIsThemeActive
static HIMAGELIST CreateDragImage(TreeListData *pData, unsigned uItem, unsigned uSub)
static LRESULT SendNotify(TreeListData *pData, NMHDR *pNotify)
static int UpdateRow(TreeListData *pData, unsigned uItem)
static int TreeListSortItems(TreeListData *pData, unsigned uParent, int iMode)
static LRESULT CALLBACK EditProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
static int TreeListStartNotifyEdit(TreeListData *pData, unsigned uItem, unsigned uSub, WPARAM wParam, LPARAM lParam)
static void TreeListChangeCheckbox(TreeListData *pData, UINT uItem, int iPosX, int iPosY)
static HFONT hDefaultFontN
static unsigned TreeListFindItem(TreeListData *pData, unsigned uItem, TVFIND *pFind)
static int TreeListSelectChilds(TreeListData *pData, unsigned uItem, int iMode)
static int TreeListSortItemsEx(TreeListData *pData, TV_SORTEX *pSortData, int iMode)
static LRESULT CALLBACK ToolProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
static LRESULT TreeListGetItemColor(TreeListData *pData, unsigned uItem, unsigned uSub, int iMode)
static void CallbackExtra(TreeListData *pData, BaseItem *pEntry, ExtraItem *pExtra, unsigned uItem, unsigned uSub, unsigned uFlags, int *iImage, unsigned *uTextSize, LPCTSTR *pText)
int TreeListRegister(HINSTANCE hInstance)
BOOL(WINAPI * IsAppThemedT)()
static void TreeListDraw(HWND hWnd, HDC hDc, RECT *pRect)
static int TreeListScanColumn(TreeListData *pData, unsigned uSub)
static int TreeListInsertColumn(TreeListData *pData, unsigned uCol, TV_COLUMN *pColumn)
static void UpdateScrollY(TreeListData *pData)
static void UpdateView(TreeListData *pData)
static BufferedPtInitT pBufferedPtExit
static int TreeListGetItemRect(TreeListData *pData, unsigned uItem, unsigned uFlags, RECT *pRect)
static void TreeListMouseNotify(TreeListData *pData, UINT uMsg, WPARAM wParam, LPARAM lParam)
#define XCHANGE_MEM(a, b)
static int UpdateRect(TreeListData *pData, unsigned uItem, unsigned uSub)
static int CreateFontset(TreeListData *pData, HFONT hFont)
static int TreeListSelectItem(TreeListData *pData, unsigned uItem, unsigned uSubItem, int iMode)
static CloseThemeDataT pCloseThemeData
static unsigned TreeListSetInsertMark(TreeListData *pData, unsigned uItem, int iMode)
HRESULT(WINAPI * EndBufferedPtT)(HANDLE, BOOL)
HRESULT(WINAPI * SetWindowThemeT)(HWND, LPCWSTR, LPCWSTR)
HRESULT(WINAPI * BufferedPtInitT)(VOID)
static unsigned TreeListNextUnselUntil(TreeListData *pData, unsigned uItem, unsigned uStop)
static void TreeListKeyDown(TreeListData *pData, WPARAM wParam, LPARAM lParam)
static void UpdateToolTip(TreeListData *pData, unsigned uItem, unsigned uFlags)
static void TreeListRemoveFocus(TreeListData *pData)
static HMODULE hUxThemeDll
static void CallbackEntry(TreeListData *pData, BaseItem *pEntry, unsigned uItem, unsigned uFlags, int *iImage, unsigned *uTextSize, LPCTSTR *pText)
static int TreeListDeleteItem(TreeListData *pData, unsigned uItem, int iMode)
static int TreeListSetOrderArray(TreeListData *pData, unsigned uItems, unsigned *pArray)
HRESULT(WINAPI * CloseThemeDataT)(LPVOID)
static void UpdateItems(TreeListData *pData, unsigned uItem)
HRESULT(WINAPI * GetThemeBackgRcT)(LPVOID, HDC, int, int, LPCRECT, LPRECT)
static int TreeListSetFocus(TreeListData *pData, unsigned uItem, unsigned uSub)
static void ChangeColSize(TreeListData *pData, int iDelta)
static unsigned TreeListInsertItem(TreeListData *pData, TV_INSERTSTRUCT *pInsert)
static int UpdateColRect(TreeListData *pData, unsigned uColumn)
static unsigned TreeListGetItem(TreeListData *pData, TV_ITEM *pItem)
static BOOL bDrawWithTheme
BOOL(WINAPI * IsThemeActiveT)()
#define BPBF_COMPATIBLEBITMAP
static int TreeListStartAutoEdit(TreeListData *pData, unsigned uColumn, WPARAM wParam, LPARAM lParam)
static BufferedPtInitT pBufferedPtInit
HRESULT(WINAPI * DrawThemeBackgT)(LPVOID, HDC, int, int, const RECT *, const RECT *)
static void TreeListMouseClick(TreeListData *pData, UINT uMsg, WPARAM wParam, LPARAM lParam)
static DrawThemeBackgT pDrawThemeBackg
static int TreeListEndLabelEdit(TreeListData *pData, int iMode)
HANDLE(WINAPI * BeginBufferedPnT)(HDC, RECT *, DWORD, LPVOID, HDC *)
static SetWindowThemeT pSetWindowTheme
static COLORREF TreeListSetItemColor(TreeListData *pData, unsigned uItem, unsigned uSub, COLORREF uColor, int iMode)
static int TreeListEnsureVisible(TreeListData *pData, unsigned uItem, unsigned uSub)
static unsigned TreeListNextSelUntil(TreeListData *pData, unsigned uItem, unsigned uStop)
static OpenThemeDataT pOpenThemeData
static void TreeListChar(TreeListData *pData, UINT nChar, LPARAM lParam)
static int UpdateColumns(TreeListData *pData)
BOOL TreeListUnregister(HINSTANCE hInstance)
static EndBufferedPtT pEndBufferedPt
#define TVS_EX_NOCHARSELCET
#define TVGN_NEXTSELECTED
#define TVS_EX_SINGLECHECKBOX
#define TVS_EX_SHAREIMAGELISTS
#define TVM_SELECTSUBITEM
#define TVHT_ONRIGHTSPACE
#define TVGN_DROPHILITESUB
#define TVGN_NEXTSELCHILD
#define TVM_GETCOLUMNORDERARRAY
#define TVM_SORTCHILDRENEX
#define TVS_EX_HIDEHEADERS
#define TVS_EX_HOMEENDSELECT
#define TVIR_EDITCOMBODOWN
#define TVS_EX_HEADERCHGNOTIFY
#define TVM_COLUMNAUTOICON
#define TVIR_EDITCOMBOBOX
#define TVE_EXPANDRECURSIVE
#define TVM_SETUSERDATASIZE
#define TVM_GETEXTENDEDSTYLE
#define TVM_GETUSERDATASIZE
#define TVM_ISITEMVISIBLE
#define TVS_EX_ALTERNATECOLOR
#define TVM_GETCOLUMNCOUNT
#define TVM_SETITEMTEXTCOLOR
#define TVN_COLUMNCHANGED
#define TVS_EX_NOCOLUMNRESIZE
#define TVS_EX_BITCHECKBOX
#define TVS_EX_NOCURSORSET
#define TVN_CBSTATECHANGED
#define TVM_GETCOLUMNWIDTH
#define TVM_GETITEMTEXTCOLOR
#define TVM_SETCOLUMNWIDTH
int(CALLBACK * PFNTVCOMPAREEX)(HWND hWnd, HTREEITEM hItem1, HTREEITEM hItem2, LPARAM lParam1, LPARAM lParam2, LPARAM lParam)
#define TVS_EX_HEADEROWNIMGLIST
#define TVM_GETITEMBKCOLOR
#define TVS_EX_FULLROWMARK
#define TVIR_EDITCOMBOLIST
#define TVM_COLUMNAUTOEDIT
#define TVS_EX_GRAYEDDISABLE
#define TVS_EX_HEADERDRAGDROP
#define TVS_EX_TOOLTIPNOTIFY
#define TVS_EX_MULTISELECT
#define TVS_EX_FIXEDCOLSIZE
#define TVS_EX_AUTOHSCROLL
#define TVS_EX_FULLROWITEMS
#define TVS_EX_AUTOEXPANDICON
#define TVN_STEPSTATECHANGED
#define TVOP_AUTOEXPANDOFF
#define TVM_SETCOLUMNORDERARRAY
#define TVM_SETEXTENDEDSTYLE
#define TVM_GETCOUNTPERPAGE
#define TVIR_EDITCOMBODEL
#define TVM_SETITEMBKCOLOR
TW_UINT32 TW_UINT16 TW_UINT16 TW_MEMREF pData
TW_UINT32 TW_UINT16 TW_UINT16 MSG
#define OutputDebugString
#define GetTextExtentExPoint
HGDIOBJ WINAPI GetStockObject(_In_ int)
int WINAPI GetDeviceCaps(_In_opt_ HDC, _In_ int)
COLORREF WINAPI SetBkColor(_In_ HDC, _In_ COLORREF)
HRGN WINAPI CreateRectRgn(_In_ int, _In_ int, _In_ int, _In_ int)
HPEN WINAPI ExtCreatePen(_In_ DWORD iPenStyle, _In_ DWORD cWidth, _In_ const LOGBRUSH *plbrush, _In_ DWORD cStyle, _In_reads_opt_(cStyle) const DWORD *pstyle)
int WINAPI GetDIBits(_In_ HDC hdc, _In_ HBITMAP hbm, _In_ UINT start, _In_ UINT cLines, _Out_opt_ LPVOID lpvBits, _At_((LPBITMAPINFOHEADER) lpbmi, _Inout_) LPBITMAPINFO lpbmi, _In_ UINT usage)
UINT WINAPI SetTextAlign(_In_ HDC, _In_ UINT)
int WINAPI SetDIBits(_In_opt_ HDC, _In_ HBITMAP, _In_ UINT, _In_ UINT, _In_ CONST VOID *, _In_ CONST BITMAPINFO *, _In_ UINT)
HGDIOBJ WINAPI SelectObject(_In_ HDC, _In_ HGDIOBJ)
BOOL WINAPI MoveToEx(_In_ HDC, _In_ int, _In_ int, _Out_opt_ LPPOINT)
HDC WINAPI CreateCompatibleDC(_In_opt_ HDC hdc)
int WINAPI CombineRgn(_In_opt_ HRGN hrgnDest, _In_opt_ HRGN hrgnSrc1, _In_opt_ HRGN hrgnSrc2, _In_ int fnCombineMode)
HBITMAP WINAPI CreateCompatibleBitmap(_In_ HDC hdc, _In_ INT cx, _In_ INT cy)
BOOL WINAPI Rectangle(_In_ HDC, _In_ int, _In_ int, _In_ int, _In_ int)
int WINAPI SetBkMode(_In_ HDC, _In_ int)
COLORREF WINAPI SetTextColor(_In_ HDC, _In_ COLORREF)
BOOL WINAPI DeleteDC(_In_ HDC)
HPEN WINAPI CreatePen(_In_ int, _In_ int, _In_ COLORREF)
#define CreateFontIndirect
BOOL WINAPI LineTo(_In_ HDC, _In_ int, _In_ int)
int WINAPI GetRgnBox(_In_ HRGN, _Out_ LPRECT)
HWND WINAPI GetFocus(void)
int WINAPI ReleaseDC(_In_opt_ HWND, _In_ HDC)
DWORD WINAPI GetSysColor(_In_ int)
#define CB_SETDROPPEDWIDTH
BOOL WINAPI RedrawWindow(_In_opt_ HWND, _In_opt_ LPCRECT, _In_opt_ HRGN, _In_ UINT)
BOOL WINAPI TranslateMessage(_In_ const MSG *)
BOOL WINAPI ShowWindow(_In_ HWND, _In_ int)
struct tagSCROLLINFO SCROLLINFO
BOOL WINAPI DrawFrameControl(_In_ HDC, _Inout_ LPRECT, _In_ UINT, _In_ UINT)
BOOL WINAPI SetWindowPos(_In_ HWND, _In_opt_ HWND, _In_ int, _In_ int, _In_ int, _In_ int, _In_ UINT)
HBRUSH WINAPI GetSysColorBrush(_In_ int)
BOOL WINAPI GetCursorPos(_Out_ LPPOINT)
#define SPI_GETICONTITLELOGFONT
#define WM_SYSCOLORCHANGE
int WINAPI SetScrollPos(_In_ HWND, _In_ int, _In_ int, _In_ BOOL)
BOOL WINAPI ClientToScreen(_In_ HWND, _Inout_ LPPOINT)
UINT_PTR WINAPI SetTimer(_In_opt_ HWND, _In_ UINT_PTR, _In_ UINT, _In_opt_ TIMERPROC)
BOOL WINAPI GetClientRect(_In_ HWND, _Out_ LPRECT)
HWND WINAPI SetFocus(_In_opt_ HWND)
BOOL WINAPI EndPaint(_In_ HWND, _In_ const PAINTSTRUCT *)
#define COLOR_HIGHLIGHTTEXT
HDC WINAPI GetDC(_In_opt_ HWND)
#define CB_GETDROPPEDSTATE
BOOL WINAPI IsWindowEnabled(_In_ HWND)
#define GetNextWindow(h, c)
HWND WINAPI GetParent(_In_ HWND)
HWND WINAPI GetWindow(_In_ HWND, _In_ UINT)
HWND WINAPI WindowFromPoint(_In_ POINT)
int WINAPI SetScrollInfo(_In_ HWND, _In_ int, _In_ LPCSCROLLINFO, _In_ BOOL)
SHORT WINAPI GetAsyncKeyState(_In_ int)
BOOL WINAPI InvalidateRect(_In_opt_ HWND, _In_opt_ LPCRECT, _In_ BOOL)
LRESULT(CALLBACK * WNDPROC)(HWND, UINT, WPARAM, LPARAM)
HDC WINAPI BeginPaint(_In_ HWND, _Out_ LPPAINTSTRUCT)
BOOL WINAPI KillTimer(_In_opt_ HWND, _In_ UINT_PTR)
#define SystemParametersInfo
BOOL WINAPI GetScrollInfo(_In_ HWND, _In_ int, _Inout_ LPSCROLLINFO)
BOOL WINAPI DestroyWindow(_In_ HWND)
int WINAPI GetSystemMetrics(_In_ int)
BOOL WINAPI MoveWindow(_In_ HWND, _In_ int, _In_ int, _In_ int, _In_ int, _In_ BOOL)
SHORT WINAPI GetKeyState(_In_ int)
BOOL WINAPI ScreenToClient(_In_ HWND, _Inout_ LPPOINT)