/*****************************************************************************
* SIC_IconAppend [internal]
*
* NOTES
* appends an icon pair to the end of the cache
*/
static INT SIC_IconAppend (LPCWSTR sSourceFile, INT dwSourceIndex, HICON hSmallIcon, HICON hBigIcon, DWORD dwFlags)
{
LPSIC_ENTRY lpsice;
INT ret, index, index1, indexDPA;
WCHAR path[MAX_PATH];
TRACE("%s %i %p %p\n", debugstr_w(sSourceFile), dwSourceIndex, hSmallIcon ,hBigIcon);
lpsice = (LPSIC_ENTRY) SHAlloc (sizeof (SIC_ENTRY));
GetFullPathNameW(sSourceFile, MAX_PATH, path, NULL);
lpsice->sSourceFile = (LPWSTR)HeapAlloc( GetProcessHeap(), 0, (wcslen(path)+1)*sizeof(WCHAR) );
wcscpy( lpsice->sSourceFile, path );
lpsice->dwSourceIndex = dwSourceIndex;
lpsice->dwFlags = dwFlags;
EnterCriticalSection(&SHELL32_SicCS);
indexDPA = DPA_Search (sic_hdpa, lpsice, 0, SIC_CompareEntries, 0, DPAS_SORTED|DPAS_INSERTAFTER);
indexDPA = DPA_InsertPtr(sic_hdpa, indexDPA, lpsice);
if ( -1 == indexDPA )
{
ret = INVALID_INDEX;
goto leave;
}
index = ImageList_AddIcon (ShellSmallIconList, hSmallIcon);
index1= ImageList_AddIcon (ShellBigIconList, hBigIcon);
/* Something went wrong when allocating a new image in the list. Abort. */
if((index == -1) || (index1 == -1))
{
WARN("Something went wrong when adding the icon to the list: small - 0x%x, big - 0x%x.\n",
index, index1);
if(index != -1) ImageList_Remove(ShellSmallIconList, index);
if(index1 != -1) ImageList_Remove(ShellBigIconList, index1);
ret = INVALID_INDEX;
goto leave;
}
if (index!=index1)
{
FIXME("iconlists out of sync 0x%x 0x%x\n", index, index1);
/* What to do ???? */
}
lpsice->dwListIndex = index;
ret = lpsice->dwListIndex;
leave:
if(ret == INVALID_INDEX)
{
if(indexDPA != -1) DPA_DeletePtr(sic_hdpa, indexDPA);
HeapFree(GetProcessHeap(), 0, lpsice->sSourceFile);
SHFree(lpsice);
}
LeaveCriticalSection(&SHELL32_SicCS);
return ret;
}
/*****************************************************************************
* SIC_IconAppend [internal]
*
* NOTES
* appends an icon pair to the end of the cache
*/
static INT SIC_IconAppend (LPCWSTR sSourceFile, INT dwSourceIndex, HICON hSmallIcon, HICON hBigIcon, DWORD dwFlags)
{ LPSIC_ENTRY lpsice;
INT ret, index, index1;
WCHAR path[MAX_PATH];
TRACE("%s %i %p %p\n", debugstr_w(sSourceFile), dwSourceIndex, hSmallIcon ,hBigIcon);
lpsice = SHAlloc(sizeof(SIC_ENTRY));
GetFullPathNameW(sSourceFile, MAX_PATH, path, NULL);
lpsice->sSourceFile = HeapAlloc( GetProcessHeap(), 0, (strlenW(path)+1)*sizeof(WCHAR) );
strcpyW( lpsice->sSourceFile, path );
lpsice->dwSourceIndex = dwSourceIndex;
lpsice->dwFlags = dwFlags;
EnterCriticalSection(&SHELL32_SicCS);
index = DPA_InsertPtr(sic_hdpa, 0x7fff, lpsice);
if ( INVALID_INDEX == index )
{
HeapFree(GetProcessHeap(), 0, lpsice->sSourceFile);
SHFree(lpsice);
ret = INVALID_INDEX;
}
else
{
index = ImageList_AddIcon (ShellSmallIconList, hSmallIcon);
index1= ImageList_AddIcon (ShellBigIconList, hBigIcon);
if (index!=index1)
{
FIXME("iconlists out of sync 0x%x 0x%x\n", index, index1);
}
lpsice->dwListIndex = index;
ret = lpsice->dwListIndex;
}
LeaveCriticalSection(&SHELL32_SicCS);
return ret;
}
static HDPA enum_bucket_trashinfos(const TRASH_BUCKET *bucket, int *count)
{
HDPA ret = DPA_Create(32);
struct dirent *entry;
DIR *dir = NULL;
errno = ENOMEM;
*count = 0;
if (ret == NULL) goto failed;
dir = opendir(bucket->info_dir);
if (dir == NULL) goto failed;
while ((entry = readdir(dir)) != NULL)
{
LPSTR filename;
int namelen = lstrlenA(entry->d_name);
int suffixlen = lstrlenA(trashinfo_suffix);
if (namelen <= suffixlen ||
lstrcmpA(entry->d_name+namelen-suffixlen, trashinfo_suffix) != 0)
continue;
filename = StrDupA(entry->d_name);
if (filename == NULL)
goto failed;
if (DPA_InsertPtr(ret, DPA_APPEND, filename) == -1)
{
LocalFree(filename);
goto failed;
}
(*count)++;
}
closedir(dir);
return ret;
failed:
if (dir) closedir(dir);
if (ret)
DPA_DestroyCallback(ret, free_item_callback, NULL);
return NULL;
}
/**************************************************************************
* DPA_Merge [COMCTL32.11]
*
* Merge two dynamic pointers arrays.
*
* PARAMS
* hdpa1 [I] handle to a dynamic pointer array
* hdpa2 [I] handle to a dynamic pointer array
* dwFlags [I] flags
* pfnCompare [I] pointer to sort function
* pfnMerge [I] pointer to merge function
* lParam [I] application specific value
*
* RETURNS
* Success: TRUE
* Failure: FALSE
*
* NOTES
* No more information available yet!
*/
BOOL WINAPI DPA_Merge (HDPA hdpa1, HDPA hdpa2, DWORD dwFlags,
PFNDPACOMPARE pfnCompare, PFNDPAMERGE pfnMerge,
LPARAM lParam)
{
INT nCount;
LPVOID *pWork1, *pWork2;
INT nResult, i;
INT nIndex;
TRACE("%p %p %08x %p %p %08lx)\n",
hdpa1, hdpa2, dwFlags, pfnCompare, pfnMerge, lParam);
if (IsBadWritePtr (hdpa1, sizeof(*hdpa1)))
return FALSE;
if (IsBadWritePtr (hdpa2, sizeof(*hdpa2)))
return FALSE;
if (IsBadCodePtr ((FARPROC)pfnCompare))
return FALSE;
if (IsBadCodePtr ((FARPROC)pfnMerge))
return FALSE;
if (!(dwFlags & DPAM_SORTED)) {
TRACE("sorting dpa's!\n");
if (hdpa1->nItemCount > 0)
DPA_Sort (hdpa1, pfnCompare, lParam);
TRACE ("dpa 1 sorted!\n");
if (hdpa2->nItemCount > 0)
DPA_Sort (hdpa2, pfnCompare, lParam);
TRACE ("dpa 2 sorted!\n");
}
if (hdpa2->nItemCount < 1)
return TRUE;
TRACE("hdpa1->nItemCount=%d hdpa2->nItemCount=%d\n",
hdpa1->nItemCount, hdpa2->nItemCount);
/* working but untrusted implementation */
pWork1 = &(hdpa1->ptrs[hdpa1->nItemCount - 1]);
pWork2 = &(hdpa2->ptrs[hdpa2->nItemCount - 1]);
nIndex = hdpa1->nItemCount - 1;
nCount = hdpa2->nItemCount - 1;
do
{
if (nIndex < 0) {
if ((nCount >= 0) && (dwFlags & DPAM_UNION)) {
/* Now insert the remaining new items into DPA 1 */
TRACE("%d items to be inserted at start of DPA 1\n",
nCount+1);
for (i=nCount; i>=0; i--) {
PVOID ptr;
ptr = (pfnMerge)(DPAMM_INSERT, *pWork2, NULL, lParam);
if (!ptr)
return FALSE;
DPA_InsertPtr (hdpa1, 0, ptr);
pWork2--;
}
}
break;
}
nResult = (pfnCompare)(*pWork1, *pWork2, lParam);
TRACE("compare result=%d, dpa1.cnt=%d, dpa2.cnt=%d\n",
nResult, nIndex, nCount);
if (nResult == 0)
{
PVOID ptr;
ptr = (pfnMerge)(DPAMM_MERGE, *pWork1, *pWork2, lParam);
if (!ptr)
return FALSE;
nCount--;
pWork2--;
*pWork1 = ptr;
nIndex--;
pWork1--;
}
else if (nResult > 0)
{
/* item in DPA 1 missing from DPA 2 */
if (dwFlags & DPAM_INTERSECT)
{
/* Now delete the extra item in DPA1 */
PVOID ptr;
ptr = DPA_DeletePtr (hdpa1, nIndex);
(pfnMerge)(DPAMM_DELETE, ptr, NULL, lParam);
}
nIndex--;
pWork1--;
}
else
{
/* new item in DPA 2 */
if (dwFlags & DPAM_UNION)
{
/* Now insert the new item in DPA 1 */
PVOID ptr;
ptr = (pfnMerge)(DPAMM_INSERT, *pWork2, NULL, lParam);
if (!ptr)
return FALSE;
DPA_InsertPtr (hdpa1, nIndex+1, ptr);
}
nCount--;
pWork2--;
}
}
while (nCount >= 0);
return TRUE;
}
BOOL PASCAL TV_SortCB(PTREE pTree, TV_SORTCB FAR *pSortCB, BOOL bRecurse,
PFNDPACOMPARE lpfnDPACompare)
{
HDPA dpaSort;
HDSA dsaCmp;
HTREEITEM hItem, hNext, hFirstMoved;
LPTVCOMPARE psCompare, FAR *ppsCompare;
int i, cKids;
HTREEITEM hParent = pSortCB->hParent;
#ifdef DEBUG
DWORD dwTime = GetTickCount();
nCompares = 0;
#endif
if (!hParent || hParent == TVI_ROOT)
hParent = pTree->hRoot;
// Code below assumes at least one kid
cKids = TV_CountKids(hParent);
if (!cKids)
return FALSE;
// Create a DSA for all the extra info we'll need
dsaCmp = DSA_Create(sizeof(TVCOMPARE), cKids);
if (!dsaCmp)
goto Error1;
// Create a DPA containing all the tree items
dpaSort = DPA_Create(cKids);
if (!dpaSort)
goto Error2;
for (hItem = hParent->hKids; hItem; hItem = hItem->hNext)
{
TVCOMPARE sCompare;
int nItem;
// If I can't sort all of them, I don't want to sort any of them
// We want to cache the text callback for default processing
if (!lpfnDPACompare && hItem->lpstr==LPSTR_TEXTCALLBACK)
{
TV_ITEM sItem;
TCHAR szTemp[MAX_PATH];
sItem.pszText = szTemp;
sItem.cchTextMax = ARRAYSIZE(szTemp);
TV_GetItem(pTree, hItem, TVIF_TEXT, &sItem);
sCompare.lpstr = NULL;
sCompare.bCallBack = TRUE;
Str_Set(&sCompare.lpstr, sItem.pszText);
if (!sCompare.lpstr)
{
goto Error3;
}
}
else
{
sCompare.lpstr = hItem->lpstr;
sCompare.bCallBack = FALSE;
}
// Create the pointer for this guy and add it to the DPA list
sCompare.hItem = hItem;
nItem = DSA_InsertItem(dsaCmp, 0x7fff, &sCompare);
if (nItem < 0)
{
if (sCompare.bCallBack)
{
Str_Set(&sCompare.lpstr, NULL);
}
goto Error3;
}
if (DPA_InsertPtr(dpaSort, 0x7fff, DSA_GetItemPtr(dsaCmp, nItem)) < 0)
{
goto Error3;
}
}
// Sort the DPA, then stick them back under the parent in the new order
DPA_Sort(dpaSort, lpfnDPACompare ? (PFNDPACOMPARE)lpfnDPACompare :
(PFNDPACOMPARE) TV_DefCompare, (LPARAM)pSortCB);
// Look for the first moved item, so we can invalidate a smaller area
ppsCompare = (LPTVCOMPARE FAR *)DPA_GetPtrPtr(dpaSort);
if (hParent->hKids != (*ppsCompare)->hItem)
{
hParent->hKids = (*ppsCompare)->hItem;
hFirstMoved = hParent->hKids;
}
else
{
hFirstMoved = NULL;
}
// We do n-1 iterations here
for (i = DPA_GetPtrCount(dpaSort) - 1; i > 0; --i, ++ppsCompare)
{
hNext = (*(ppsCompare+1))->hItem;
if ((*ppsCompare)->hItem->hNext != hNext && !hFirstMoved)
{
hFirstMoved = hNext;
}
(*ppsCompare)->hItem->hNext = hNext;
}
(*ppsCompare)->hItem->hNext = NULL;
TV_UpdateShownIndexes(pTree, hParent);
if ((pSortCB->hParent == TVI_ROOT) || !hParent) {
if (pTree->cShowing < pTree->cFullVisible) {
pTree->hTop = pTree->hRoot->hKids;
}
}
if (hFirstMoved && (hParent->state & TVIS_EXPANDED))
{
RECT rcUpdate;
TV_GetItemRect(pTree, hFirstMoved, &rcUpdate, FALSE);
if (hParent->hNext)
{
RECT rcTemp;
TV_GetItemRect(pTree, hParent->hNext, &rcTemp, FALSE);
rcUpdate.bottom = rcTemp.bottom;
}
else
{
RECT rcClient;
GetClientRect(pTree->ci.hwnd, &rcClient);
// Set to maximal positive number, so the whole rest of
// the treeview gets invalidated
rcUpdate.bottom = rcClient.bottom;
}
if (pTree->fRedraw)
InvalidateRect(pTree->ci.hwnd, &rcUpdate, TRUE);
}
Error3:
DPA_Destroy(dpaSort);
Error2:
for (i = DSA_GetItemCount(dsaCmp) - 1; i >= 0; --i)
{
psCompare = DSA_GetItemPtr(dsaCmp, i);
if (psCompare->bCallBack)
{
Str_Set(&(psCompare->lpstr), NULL);
}
}
DSA_Destroy(dsaCmp);
Error1:
#ifdef DEBUG
DebugMsg(DM_TRACE, TEXT("tv.sort: %ld ms; %d cmps"), GetTickCount()-dwTime, nCompares);
#endif
{
int wNewPos;
// restore the scroll position
if (GetWindowStyle(pTree->ci.hwnd) & WS_VSCROLL) {
SCROLLINFO si;
si.cbSize = sizeof(SCROLLINFO);
si.fMask = SIF_POS;
wNewPos = 0;
if (GetScrollInfo(pTree->ci.hwnd, SB_VERT, &si)) {
wNewPos = si.nPos;
}
} else {
wNewPos = 0;
}
if (TV_SetTopItem(pTree, wNewPos))
UpdateWindow(pTree->ci.hwnd);
}
// if the caret is the child of the thing that was sorted, make sure it's
// visible (but if we're sorting something completely unrelated, don't bother
if (pTree->hCaret) {
hItem = pTree->hCaret;
do {
// do this first. if hParent is hCaret, we don't want to ensure visible...
// only if it's an eventual child
hItem = hItem->hParent;
if (hParent == hItem) {
TV_EnsureVisible(pTree, pTree->hCaret);
}
} while(hItem && hItem != pTree->hRoot);
}
return TRUE;
}
