static void remove_trashinfo_file(const char *info_dir, const char *base_name) { char *filename_buffer; filename_buffer = SHAlloc(lstrlenA(info_dir)+lstrlenA(base_name)+lstrlenA(trashinfo_suffix)+1); if (filename_buffer == NULL) return; sprintf(filename_buffer, "%s%s%s", info_dir, base_name, trashinfo_suffix); unlink(filename_buffer); SHFree(filename_buffer); }
/************************************************************************* * SHChangeNotifyRegister [SHELL32.2] * */ ULONG WINAPI SHChangeNotifyRegister( HWND hwnd, int fSources, LONG wEventMask, UINT uMsg, int cItems, SHChangeNotifyEntry *lpItems) { LPNOTIFICATIONLIST item; int i; item = (NOTIFICATIONLIST *)SHAlloc(sizeof(NOTIFICATIONLIST)); TRACE("(%p,0x%08x,0x%08x,0x%08x,%d,%p) item=%p\n", hwnd, fSources, wEventMask, uMsg, cItems, lpItems, item); item->next = NULL; item->prev = NULL; item->cidl = cItems; item->apidl = (SHChangeNotifyEntry *)SHAlloc(sizeof(SHChangeNotifyEntry) * cItems); for(i=0;i<cItems;i++) { item->apidl[i].pidl = ILClone(lpItems[i].pidl); item->apidl[i].fRecursive = lpItems[i].fRecursive; } item->hwnd = hwnd; item->uMsg = uMsg; item->wEventMask = wEventMask; item->wSignalledEvent = 0; item->dwFlags = fSources; TRACE("new node: %s\n", NodeName( item )); EnterCriticalSection(&SHELL32_ChangenotifyCS); AddNode(item); LeaveCriticalSection(&SHELL32_ChangenotifyCS); return (ULONG)item; }
static IContextMenu2* RecycleBinMenu_Constructor(UINT cidl, LPCITEMIDLIST *apidl, IShellFolder2 *folder) { RecycleBinMenu *This = SHAlloc(sizeof(RecycleBinMenu)); TRACE("(%u,%p)\n",cidl,apidl); This->IContextMenu2_iface.lpVtbl = &recycleBinMenuVtbl; This->cidl = cidl; This->apidl = _ILCopyaPidl(apidl,cidl); IShellFolder2_AddRef(folder); This->folder = folder; This->refCount = 1; return &This->IContextMenu2_iface; }
LPITEMIDLIST ILCreateFromNetworkPlaceW(LPCWSTR lpNetworkPlace) { int cbData = sizeof(WORD) + sizeof(WCHAR) * (wcslen(lpNetworkPlace)+1); LPITEMIDLIST pidl = (LPITEMIDLIST)SHAlloc(cbData + sizeof(WORD)); if (!pidl) return NULL; pidl->mkid.cb = cbData; wcscpy((WCHAR*)&pidl->mkid.abID[0], lpNetworkPlace); *(WORD*)((char*)pidl + cbData) = 0; return pidl; }
HRESULT WINAPI IEnumFORMATETCImpl::Initialize(UINT cfmt, const FORMATETC afmt[]) { DWORD size; size = cfmt * sizeof(FORMATETC); countFmt = cfmt; pFmt = (LPFORMATETC)SHAlloc(size); if (pFmt == NULL) return E_OUTOFMEMORY; memcpy(pFmt, afmt, size); return S_OK; }
BOOL WINAPI CRecycleBinEnum::CBEnumRecycleBin(IN HANDLE hDeletedFile) { PDELETED_FILE_DETAILS_W pFileDetails; DWORD dwSize; LPITEMIDLIST pidl = NULL; BOOL ret; if (!GetDeletedFileDetailsW(hDeletedFile, 0, NULL, &dwSize) && GetLastError() != ERROR_INSUFFICIENT_BUFFER) { ERR("GetDeletedFileDetailsW failed\n"); return FALSE; } pFileDetails = (DELETED_FILE_DETAILS_W *)SHAlloc(dwSize); if (!pFileDetails) { ERR("No memory\n"); return FALSE; } if (!GetDeletedFileDetailsW(hDeletedFile, dwSize, pFileDetails, NULL)) { ERR("GetDeletedFileDetailsW failed\n"); SHFree(pFileDetails); return FALSE; } pidl = _ILCreateRecycleItem(pFileDetails); if (!pidl) { SHFree(pFileDetails); return FALSE; } ret = AddToEnumList(pidl); if (!ret) SHFree(pidl); SHFree(pFileDetails); TRACE("Returning %d\n", ret); CloseRecycleBinHandle(hDeletedFile); return ret; }
HRESULT WINAPI CDesktopFolder::FinalConstruct() { WCHAR szMyPath[MAX_PATH]; HRESULT hr; /* Create the root pidl */ pidlRoot = _ILCreateDesktop(); if (!pidlRoot) return E_OUTOFMEMORY; /* Create the inner fs folder */ hr = SHELL32_CoCreateInitSF(pidlRoot, NULL, NULL, &CLSID_ShellFSFolder, CSIDL_DESKTOPDIRECTORY, IID_PPV_ARG(IShellFolder2, &m_DesktopFSFolder)); if (FAILED_UNEXPECTEDLY(hr)) return hr; /* Create the inner shared fs folder. Dont fail on failure. */ hr = SHELL32_CoCreateInitSF(pidlRoot, NULL, NULL, &CLSID_ShellFSFolder, CSIDL_COMMON_DESKTOPDIRECTORY, IID_PPV_ARG(IShellFolder2, &m_SharedDesktopFSFolder)); if (FAILED_UNEXPECTEDLY(hr)) return hr; /* Create the inner reg folder */ hr = CRegFolder_CreateInstance(&CLSID_ShellDesktop, pidlRoot, L"", IID_PPV_ARG(IShellFolder2, &m_regFolder)); if (FAILED_UNEXPECTEDLY(hr)) return hr; /* Cache the path to the user desktop directory */ if (!SHGetSpecialFolderPathW( 0, szMyPath, CSIDL_DESKTOPDIRECTORY, TRUE )) return E_UNEXPECTED; sPathTarget = (LPWSTR)SHAlloc((wcslen(szMyPath) + 1) * sizeof(WCHAR)); if (!sPathTarget) return E_OUTOFMEMORY; wcscpy(sPathTarget, szMyPath); return S_OK; }
LPTSTR SHGetCaption(HIDA hida) { UINT idFormat, uLen; TCHAR szTemplate[40]; TCHAR szName[MAX_PATH]; LPTSTR pszCaption = NULL; LPITEMIDLIST pidl; switch (HIDA_GetCount(hida)) { case 0: // Review: Can this ever happen? Assert(FALSE); goto Error1; case 1: idFormat = IDS_ONEFILEPROP; break; default: idFormat = IDS_MANYFILEPROP; break; } pidl = HIDA_ILClone(hida, 0); if (!pidl) { goto Error1; } if (FAILED(_SHGetNameAndFlags(pidl, SHGDN_NORMAL, szName, ARRAYSIZE(szName), NULL))) { goto Error2; } uLen = LoadString(HINST_THISDLL, idFormat, szTemplate, ARRAYSIZE(szTemplate)) + lstrlen(szName) + 1; pszCaption = SHAlloc(uLen*SIZEOF(TCHAR)); if (pszCaption) { wsprintf(pszCaption, szTemplate, (LPTSTR)szName); } Error2:; ILFree(pidl); Error1:; return(pszCaption); }
/* * The item ID of a trashed element is built as follows: * NUL byte - in most PIDLs the first byte is the type so we keep it constant * WIN32_FIND_DATAW structure - with data about original file attributes * bucket name - currently only an empty string meaning the home bucket is supported * trash file name - a NUL-terminated string */ static HRESULT TRASH_CreateSimplePIDL(LPCSTR filename, const WIN32_FIND_DATAW *data, LPITEMIDLIST *pidlOut) { LPITEMIDLIST pidl = SHAlloc(2+1+sizeof(WIN32_FIND_DATAW)+1+lstrlenA(filename)+1+2); *pidlOut = NULL; if (pidl == NULL) return E_OUTOFMEMORY; pidl->mkid.cb = (USHORT)(2+1+sizeof(WIN32_FIND_DATAW)+1+lstrlenA(filename)+1); pidl->mkid.abID[0] = 0; memcpy(pidl->mkid.abID+1, data, sizeof(WIN32_FIND_DATAW)); pidl->mkid.abID[1+sizeof(WIN32_FIND_DATAW)] = 0; lstrcpyA((LPSTR)(pidl->mkid.abID+1+sizeof(WIN32_FIND_DATAW)+1), filename); *(USHORT *)(pidl->mkid.abID+1+sizeof(WIN32_FIND_DATAW)+1+lstrlenA(filename)+1) = 0; *pidlOut = pidl; return S_OK; }
/************************************************************************** * ISF_Printers_fnGetDisplayNameOf * */ static HRESULT WINAPI ISF_Printers_fnGetDisplayNameOf (IShellFolder2 * iface, LPCITEMIDLIST pidl, DWORD dwFlags, LPSTRRET strRet) { LPWSTR pszName; IGenericSFImpl *This = (IGenericSFImpl *)iface; PIDLPrinterStruct * p; TRACE ("(%p)->(pidl=%p,0x%08lx,%p)\n", This, pidl, dwFlags, strRet); pdump (pidl); if (!strRet) { WARN("no strRet\n"); return E_INVALIDARG; } if (_ILIsPrinter(pidl)) { pszName = CoTaskMemAlloc(MAX_PATH * sizeof(WCHAR)); if (!pszName) return E_OUTOFMEMORY; if (LoadStringW(shell32_hInstance, IDS_PRINTERS, pszName, MAX_PATH)) { pszName[MAX_PATH-1] = L'\0'; strRet->uType = STRRET_WSTR; strRet->u.pOleStr = pszName; return S_OK; } CoTaskMemFree(pszName); return E_FAIL; } p = _ILGetPrinterStruct(pidl); if (!p) { WARN("no printer struct\n"); return E_INVALIDARG; } strRet->u.pOleStr = SHAlloc(p->offsServer * sizeof(WCHAR)); if (!strRet->u.pOleStr) return E_OUTOFMEMORY; memcpy((LPVOID)strRet->u.pOleStr, (LPVOID)p->szName, p->offsServer * sizeof(WCHAR)); TRACE("ret %s\n", debugstr_w(strRet->u.pOleStr)); return S_OK; }
BOOL WINAPI CBSearchRecycleBin(IN PVOID Context, IN HANDLE hDeletedFile) { PSEARCH_CONTEXT pContext = (PSEARCH_CONTEXT)Context; PDELETED_FILE_DETAILS_W pFileDetails; DWORD dwSize; BOOL ret; if (!GetDeletedFileDetailsW(hDeletedFile, 0, NULL, &dwSize) && GetLastError() != ERROR_INSUFFICIENT_BUFFER) { ERR("GetDeletedFileDetailsW failed\n"); return FALSE; } pFileDetails = (DELETED_FILE_DETAILS_W *)SHAlloc(dwSize); if (!pFileDetails) { ERR("No memory\n"); return FALSE; } if (!GetDeletedFileDetailsW(hDeletedFile, dwSize, pFileDetails, NULL)) { ERR("GetDeletedFileDetailsW failed\n"); SHFree(pFileDetails); return FALSE; } ret = memcmp(pFileDetails, pContext->pFileDetails, dwSize); if (!ret) { pContext->hDeletedFile = hDeletedFile; pContext->bFound = TRUE; } else CloseRecycleBinHandle(hDeletedFile); SHFree(pFileDetails); return ret; }
/************************************************************************** * CPrinterFolder::GetDisplayNameOf * */ HRESULT WINAPI CPrinterFolder::GetDisplayNameOf(PCUITEMID_CHILD pidl, DWORD dwFlags, LPSTRRET strRet) { LPWSTR pszName; PIDLPrinterStruct * p; TRACE ("(%p)->(pidl=%p,0x%08lx,%p)\n", this, pidl, dwFlags, strRet); pdump (pidl); if (!strRet) { WARN("no strRet\n"); return E_INVALIDARG; } if (!pidl->mkid.cb) { pszName = (LPWSTR)CoTaskMemAlloc(MAX_PATH * sizeof(WCHAR)); if (!pszName) return E_OUTOFMEMORY; if (LoadStringW(shell32_hInstance, IDS_PRINTERS, pszName, MAX_PATH)) { pszName[MAX_PATH-1] = L'\0'; strRet->uType = STRRET_WSTR; strRet->pOleStr = pszName; return S_OK; } CoTaskMemFree(pszName); return E_FAIL; } p = _ILGetPrinterStruct(pidl); if (!p) { WARN("no printer struct\n"); return E_INVALIDARG; } strRet->pOleStr = (LPWSTR)SHAlloc(p->offsServer * sizeof(WCHAR)); if (!strRet->pOleStr) return E_OUTOFMEMORY; memcpy((LPVOID)strRet->pOleStr, (LPVOID)p->szName, p->offsServer * sizeof(WCHAR)); TRACE("ret %s\n", debugstr_w(strRet->pOleStr)); return S_OK; }
/****************************************************************************** * XDG_WriteDesktopStringEntry [internal] * * Writes a key=value pair into the specified file descriptor. * * RETURNS * TRUE on success, else FALSE */ BOOL XDG_WriteDesktopStringEntry(int writer, const char *keyName, DWORD dwFlags, const char *value) { int keyLen = lstrlenA(keyName); int valueLen = escape_value(value, dwFlags, NULL); char *string = SHAlloc(keyLen+1+valueLen); BOOL ret; if (string == NULL) return FALSE; lstrcpyA(string, keyName); string[keyLen] = '='; escape_value(value, dwFlags, string+keyLen+1); string[keyLen+1+valueLen-1]='\n'; /* -1 because valueLen contains the last NUL character */ ret = (write(writer, string, keyLen+1+valueLen)!=-1); SHFree(string); return ret; }
HRESULT TRASH_EnumItems(const WCHAR *path, LPITEMIDLIST **pidls, int *count) { int ti_count; int pos=0, i; HRESULT err = E_OUTOFMEMORY; HDPA tinfs; if(path) FIXME("Ignoring path = %s\n", debugstr_w(path)); if (!TRASH_EnsureInitialized()) return E_FAIL; tinfs = enum_bucket_trashinfos(home_trash, &ti_count); if (tinfs == NULL) return E_FAIL; *pidls = SHAlloc(sizeof(LPITEMIDLIST)*ti_count); if (!*pidls) goto failed; for (i=0; i<ti_count; i++) { WIN32_FIND_DATAW data; LPCSTR filename; filename = DPA_GetPtr(tinfs, i); if (FAILED(err = TRASH_GetDetails(home_trash, filename, &data))) goto failed; if (err == S_FALSE) continue; if (FAILED(err = TRASH_CreateSimplePIDL(filename, &data, &(*pidls)[pos]))) goto failed; pos++; } *count = pos; DPA_DestroyCallback(tinfs, free_item_callback, NULL); return S_OK; failed: if (*pidls != NULL) { int j; for (j=0; j<pos; j++) SHFree((*pidls)[j]); SHFree(*pidls); } DPA_DestroyCallback(tinfs, free_item_callback, NULL); return err; }
static LPITEMIDLIST _ILCreatePrinterItem(PRINTER_INFO_4W *pi) { PIDLDATA tmp; LPITEMIDLIST pidl; PIDLPrinterStruct * p; int size0 = (char*)&tmp.u.cprinter.szName - (char*)&tmp.u.cprinter; int size = size0; tmp.type = 0x00; tmp.u.cprinter.dummy = 0xFF; if (pi->pPrinterName) tmp.u.cprinter.offsServer = wcslen(pi->pPrinterName) + 1; else tmp.u.cprinter.offsServer = 1; size += tmp.u.cprinter.offsServer * sizeof(WCHAR); if (pi->pServerName) size += (wcslen(pi->pServerName) + 1) * sizeof(WCHAR); else size += sizeof(WCHAR); pidl = (LPITEMIDLIST)SHAlloc(size + 4); if (!pidl) return pidl; pidl->mkid.cb = size + 2; memcpy(pidl->mkid.abID, &tmp, 2 + size0); p = &((PIDLDATA*)pidl->mkid.abID)->u.cprinter; p->Attributes = pi->Attributes; if (pi->pPrinterName) wcscpy(p->szName, pi->pPrinterName); else p->szName[0] = L'\0'; if (pi->pServerName) wcscpy(p->szName + p->offsServer, pi->pServerName); else p->szName[p->offsServer] = L'\0'; *(WORD*)((char*)pidl + (size + 2)) = 0; return pidl; }
static LPITEMIDLIST _ILCreateCPanelApplet(LPCSTR name, LPCSTR displayName, LPCSTR comment, int iconIdx) { PIDLCPanelStruct *p; LPITEMIDLIST pidl; PIDLDATA tmp; int size0 = (char*)&tmp.u.cpanel.szName-(char*)&tmp.u.cpanel; int size = size0; int l; tmp.type = PT_CPLAPPLET; tmp.u.cpanel.dummy = 0; tmp.u.cpanel.iconIdx = iconIdx; l = strlen(name); size += l+1; tmp.u.cpanel.offsDispName = l+1; l = strlen(displayName); size += l+1; tmp.u.cpanel.offsComment = tmp.u.cpanel.offsDispName+1+l; l = strlen(comment); size += l+1; pidl = SHAlloc(size+4); if (!pidl) return NULL; pidl->mkid.cb = size+2; memcpy(pidl->mkid.abID, &tmp, 2+size0); p = &((PIDLDATA*)pidl->mkid.abID)->u.cpanel; strcpy(p->szName, name); strcpy(p->szName+tmp.u.cpanel.offsDispName, displayName); strcpy(p->szName+tmp.u.cpanel.offsComment, comment); *(WORD*)((char*)pidl+(size+2)) = 0; pcheck(pidl); return pidl; }
// // A helper function to be called from ISF::GetDisplayNameOf implementation // HRESULT SHGetPathHelper(LPCITEMIDLIST pidlFolder, LPCITEMIDLIST pidl, LPSTRRET pStrRet) { HRESULT hres; LPITEMIDLIST pidlFull = ILCombine(pidlFolder, pidl); if (pidlFull) { #ifdef UNICODE TCHAR szName[MAX_PATH]; #endif pStrRet->uType = STRRET_CSTR; // Return no name if failure pStrRet->cStr[0] = '\0'; #ifdef UNICODE if (SHGetPathFromIDList(pidlFull, szName)) { pStrRet->pOleStr = (LPOLESTR)SHAlloc((lstrlen(szName)+1)*SIZEOF(TCHAR)); if ( pStrRet->pOleStr != NULL ) { lstrcpy(pStrRet->pOleStr, szName); pStrRet->uType = STRRET_OLESTR; hres = S_OK; } else { hres = E_OUTOFMEMORY; } } #else if (SHGetPathFromIDList(pidlFull, pStrRet->cStr)) { hres = NOERROR; } #endif else { hres = E_INVALIDARG; } ILFree(pidlFull); } else { hres = E_OUTOFMEMORY; } return hres; }
LPITEMIDLIST _ILAlloc(BYTE type, unsigned int size) { LPITEMIDLIST pidlOut = NULL; pidlOut = (LPITEMIDLIST)SHAlloc(size + 5); if(pidlOut) { LPPIDLDATA pData; ZeroMemory(pidlOut, size + 5); pidlOut->mkid.cb = size + 3; pData = _ILGetDataPointer(pidlOut); if (pData) pData->type = type; } return pidlOut; }
/************************************************************************** * ISF_Desktop_Constructor */ HRESULT WINAPI ISF_Desktop_Constructor ( IUnknown * pUnkOuter, REFIID riid, LPVOID * ppv) { static IGenericSFImpl *cached_sf; WCHAR szMyPath[MAX_PATH]; TRACE ("unkOut=%p %s\n", pUnkOuter, shdebugstr_guid (riid)); if (!ppv) return E_POINTER; if (pUnkOuter) return CLASS_E_NOAGGREGATION; if (!cached_sf) { IGenericSFImpl *sf; if (!SHGetSpecialFolderPathW( 0, szMyPath, CSIDL_DESKTOPDIRECTORY, TRUE )) return E_UNEXPECTED; sf = LocalAlloc( LMEM_ZEROINIT, sizeof (IGenericSFImpl) ); if (!sf) return E_OUTOFMEMORY; sf->ref = 1; sf->lpVtbl = &vt_MCFldr_ShellFolder2; sf->lpPF2 = &vt_FSFldr_PersistFolder2; sf->lpvtblSFHelper = &vt_FSFldr_ISFHelper; sf->pidlRoot = _ILCreateDesktop(); /* my qualified pidl */ sf->sPathTarget = SHAlloc( (wcslen(szMyPath) + 1)*sizeof(WCHAR) ); wcscpy( sf->sPathTarget, szMyPath ); if (InterlockedCompareExchangePointer((void *)&cached_sf, sf, NULL) != NULL) { /* some other thread already been here */ SHFree( sf->pidlRoot ); SHFree( sf->sPathTarget ); LocalFree( sf ); } } return IUnknown_QueryInterface( _IUnknown_(cached_sf), riid, ppv ); }
HRESULT WINAPI CDesktopFolder::FinalConstruct() { WCHAR szMyPath[MAX_PATH]; HRESULT hr; CComPtr<IPersistFolder3> ppf3; /* Create the root pidl */ pidlRoot = _ILCreateDesktop(); /* Create the inner fs folder */ hr = SHCoCreateInstance(NULL, &CLSID_ShellFSFolder, NULL, IID_PPV_ARG(IShellFolder2, &m_DesktopFSFolder)); if (FAILED(hr)) return hr; hr = m_DesktopFSFolder->QueryInterface(IID_PPV_ARG(IPersistFolder3, &ppf3)); if (FAILED(hr)) return hr; PERSIST_FOLDER_TARGET_INFO info; ZeroMemory(&info, sizeof(PERSIST_FOLDER_TARGET_INFO)); info.csidl = CSIDL_DESKTOPDIRECTORY; hr = ppf3->InitializeEx(NULL, pidlRoot, &info); /* Create the inner shared fs folder */ hr = SHCoCreateInstance(NULL, &CLSID_ShellFSFolder, NULL, IID_PPV_ARG(IShellFolder2, &m_SharedDesktopFSFolder)); if (FAILED(hr)) return hr; hr = m_SharedDesktopFSFolder->QueryInterface(IID_PPV_ARG(IPersistFolder3, &ppf3)); if (FAILED(hr)) return hr; info.csidl = CSIDL_COMMON_DESKTOPDIRECTORY; hr = ppf3->InitializeEx(NULL, pidlRoot, &info); if (!SHGetSpecialFolderPathW( 0, szMyPath, CSIDL_DESKTOPDIRECTORY, TRUE )) return E_UNEXPECTED; sPathTarget = (LPWSTR)SHAlloc((wcslen(szMyPath) + 1) * sizeof(WCHAR)); wcscpy(sPathTarget, szMyPath); return S_OK; }
/****************************************************************************** * XDG_MakeDirs [internal] * * Checks that all the directories on the specified path exists. If some don't exists * they are created with mask 0700 as required by many the freedeskop.org specs. * If the path doesn't end with '/' it is assumed to be a path to a file and the last * segment is not checked * * In case of a failure the errno is always set and can be used e.g for debugging * * RETURNS * TRUE on success, FALSE on error */ BOOL XDG_MakeDirs(const char *path) { int last_slash = 0; BOOL success = TRUE; struct stat tmp; char *buffer = SHAlloc(strlen(path)+1); if (buffer == NULL) { errno = ENOMEM; return FALSE; } lstrcpyA(buffer, path); TRACE("(%s)\n", debugstr_a(path)); while (1) { char *slash=strchr(buffer+last_slash+1, '/'); if (slash==NULL) break; /* cut the string at that position and create the directory if it doesn't exist */ *slash=0; TRACE("Checking path %s\n", debugstr_a(buffer)); success = (stat(buffer, &tmp)==0); if (!success && errno==ENOENT) { TRACE("Creating\n"); success = (mkdir(buffer, 0700)==0); } if (!success) { WARN("Couldn't process directory %s (errno=%d)\n", debugstr_a(buffer), errno); break; } *slash='/'; last_slash = slash-buffer; } SHFree(buffer); return success; }
HRESULT WINAPI RecycleBin_Constructor(IUnknown *pUnkOuter, REFIID riid, LPVOID *ppOutput) { RecycleBin *obj; HRESULT ret; if (pUnkOuter) return CLASS_E_NOAGGREGATION; obj = SHAlloc(sizeof(RecycleBin)); if (obj == NULL) return E_OUTOFMEMORY; ZeroMemory(obj, sizeof(RecycleBin)); obj->lpVtbl = &recycleBinVtbl; obj->lpPersistFolderVtbl = &recycleBinPersistVtbl; if (FAILED(ret = IUnknown_QueryInterface((IUnknown *)obj, riid, ppOutput))) { RecycleBin_Destructor(obj); return ret; } /* InterlockedIncrement(&objCount);*/ return S_OK; }
/***************************************************************************** * 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; }
/************************************************************************** * AddToEnumList() */ BOOL AddToEnumList( IEnumIDList * iface, LPITEMIDLIST pidl) { IEnumIDListImpl *This = (IEnumIDListImpl *)iface; LPENUMLIST pNew; TRACE("(%p)->(pidl=%p)\n",This,pidl); if (!iface || !pidl) return FALSE; pNew = SHAlloc(sizeof(ENUMLIST)); if(pNew) { /*set the next pointer */ pNew->pNext = NULL; pNew->pidl = pidl; /*is This the first item in the list? */ if(!This->mpFirst) { This->mpFirst = pNew; This->mpCurrent = pNew; } if(This->mpLast) { /*add the new item to the end of the list */ This->mpLast->pNext = pNew; } /*update the last item pointer */ This->mpLast = pNew; TRACE("-- (%p)->(first=%p, last=%p)\n",This,This->mpFirst,This->mpLast); return TRUE; } return FALSE; }
static LPITEMIDLIST _ILCreateCPanelApplet(LPCSTR pszName, LPCSTR pszDisplayName, LPCSTR pszComment, int iIconIdx) { PIDLCPanelStruct *pCP; LPITEMIDLIST pidl; LPPIDLDATA pData; int cchName, cchDisplayName, cchComment, cbData; /* Calculate lengths of given strings */ cchName = strlen(pszName); cchDisplayName = strlen(pszDisplayName); cchComment = strlen(pszComment); /* Allocate PIDL */ cbData = sizeof(pidl->mkid.cb) + sizeof(pData->type) + sizeof(pData->u.cpanel) - sizeof(pData->u.cpanel.szName) + cchName + cchDisplayName + cchComment + 3; pidl = (LPITEMIDLIST)SHAlloc(cbData + sizeof(WORD)); if (!pidl) return NULL; /* Copy data to allocated memory */ pidl->mkid.cb = cbData; pData = (PIDLDATA *)pidl->mkid.abID; pData->type = PT_CPLAPPLET; pCP = &pData->u.cpanel; pCP->dummy = 0; pCP->iconIdx = iIconIdx; strcpy(pCP->szName, pszName); pCP->offsDispName = cchName + 1; strcpy(pCP->szName + pCP->offsDispName, pszDisplayName); pCP->offsComment = pCP->offsDispName + cchDisplayName + 1; strcpy(pCP->szName + pCP->offsComment, pszComment); /* Add PIDL NULL terminator */ *(WORD*)(pCP->szName + pCP->offsComment + cchComment + 1) = 0; pcheck(pidl); return pidl; }
LPENUMFORMATETC IEnumFORMATETC_Constructor(UINT cfmt, const FORMATETC afmt[]) { IEnumFORMATETCImpl* ef; DWORD size=cfmt * sizeof(FORMATETC); ef = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IEnumFORMATETCImpl)); if(ef) { ef->ref=1; ef->lpVtbl=&efvt; ef->countFmt = cfmt; ef->pFmt = SHAlloc (size); if (ef->pFmt) memcpy(ef->pFmt, afmt, size); } TRACE("(%p)->(%u,%p)\n",ef, cfmt, afmt); return (LPENUMFORMATETC)ef; }
/****************************************************************************** * XDG_BuildPath [internal] * * Build a string with a subpath of one of the XDG standard paths. * The root can be one of XDG_DATA_HOME, XDG_CONFIG_HOME and XDG_CACHE_HOME. * The subpath is a path relative to that root (it shouldn't start with a slash) * * The returned path should be freed with SHFree. A return of NULL means that the * memory is exhausted or the parameters are invalid */ char *XDG_BuildPath(int root_id, const char *subpath) { const char *root_path = XDG_GetPath(root_id); char *ret_buffer; int root_len; if (root_id == XDG_DATA_DIRS || root_id == XDG_CONFIG_DIRS) { ERR("Invalid path id %d\n", root_id); return NULL; } if (root_path == NULL) return NULL; root_len = strlen(root_path); if (root_path[root_len-1]=='/') root_len--; ret_buffer = SHAlloc(root_len+1+strlen(subpath)+1); if (ret_buffer == NULL) return NULL; lstrcpyA(ret_buffer, root_path); ret_buffer[root_len]='/'; lstrcpyA(ret_buffer+root_len+1, subpath); return ret_buffer; }
/***************************************************************************** * SIC_IconAppend [internal] * * NOTES * appends a icon pair to the end of the cache */ static INT SIC_IconAppend (LPCSTR sSourceFile, INT dwSourceIndex, HICON hSmallIcon, HICON hBigIcon) { LPSIC_ENTRY lpsice; INT ret, index, index1; char *path; TRACE("%s %i %x %x\n", sSourceFile, dwSourceIndex, hSmallIcon ,hBigIcon); lpsice = (LPSIC_ENTRY) SHAlloc (sizeof (SIC_ENTRY)); path = PathFindFileNameA(sSourceFile); lpsice->sSourceFile = HeapAlloc( GetProcessHeap(), 0, strlen(path)+1 ); strcpy( lpsice->sSourceFile, path ); lpsice->dwSourceIndex = dwSourceIndex; EnterCriticalSection(&SHELL32_SicCS); index = pDPA_InsertPtr(sic_hdpa, 0x7fff, lpsice); if ( INVALID_INDEX == index ) { 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; }
/****************************************************************************** * InsertTreeViewItem [Internal] * * PARAMS * info [I] data for the dialog * lpsf [I] IShellFolder interface of the item's parent shell folder * pidl [I] ITEMIDLIST of the child to insert, relative to parent * pidlParent [I] ITEMIDLIST of the parent shell folder * pEnumIL [I] Iterator for the children of the item to be inserted * hParent [I] The treeview-item that represents the parent shell folder * * RETURNS * Success: Handle to the created and inserted treeview-item * Failure: NULL */ static HTREEITEM InsertTreeViewItem( browse_info *info, IShellFolder * lpsf, LPCITEMIDLIST pidl, LPCITEMIDLIST pidlParent, IEnumIDList* pEnumIL, HTREEITEM hParent) { TVITEMW tvi; TVINSERTSTRUCTW tvins; WCHAR szBuff[MAX_PATH]; LPTV_ITEMDATA lptvid=0; tvi.mask = TVIF_TEXT | TVIF_IMAGE | TVIF_SELECTEDIMAGE | TVIF_PARAM; tvi.cChildren= pEnumIL ? 1 : 0; tvi.mask |= TVIF_CHILDREN; lptvid = SHAlloc( sizeof(TV_ITEMDATA) ); if (!lptvid) return NULL; if (!GetName(lpsf, pidl, SHGDN_NORMAL, szBuff)) return NULL; tvi.pszText = szBuff; tvi.cchTextMax = MAX_PATH; tvi.lParam = (LPARAM)lptvid; IShellFolder_AddRef(lpsf); lptvid->lpsfParent = lpsf; lptvid->lpi = ILClone(pidl); lptvid->lpifq = pidlParent ? ILCombine(pidlParent, pidl) : ILClone(pidl); lptvid->pEnumIL = pEnumIL; GetNormalAndSelectedIcons(lptvid->lpifq, &tvi); tvins.u.item = tvi; tvins.hInsertAfter = NULL; tvins.hParent = hParent; return (HTREEITEM)SendMessageW(info->hwndTreeView, TVM_INSERTITEM, 0, (LPARAM)&tvins ); }
/* * Try to create a .trashinfo file. This function will make several attempts with * different filenames. It will return the filename that succeeded or NULL if a file * couldn't be created. */ static char *create_trashinfo(const char *info_dir, const char *file_path) { const char *base_name; char *filename_buffer; ULONG seed = GetTickCount(); int i; errno = ENOMEM; /* out-of-memory is the only case when errno isn't set */ base_name = strrchr(file_path, '/'); if (base_name == NULL) base_name = file_path; else base_name++; filename_buffer = SHAlloc(strlen(base_name)+9+1); if (filename_buffer == NULL) return NULL; lstrcpyA(filename_buffer, base_name); if (try_create_trashinfo_file(info_dir, filename_buffer, file_path)) return filename_buffer; for (i=0; i<30; i++) { sprintf(filename_buffer, "%s-%d", base_name, i+1); if (try_create_trashinfo_file(info_dir, filename_buffer, file_path)) return filename_buffer; } for (i=0; i<1000; i++) { sprintf(filename_buffer, "%s-%08x", base_name, RtlRandom(&seed)); if (try_create_trashinfo_file(info_dir, filename_buffer, file_path)) return filename_buffer; } WARN("Couldn't create trashinfo after 1031 tries (errno=%d)\n", errno); SHFree(filename_buffer); return NULL; }