int folder_dialog(HWND hwnd, char *path) { BROWSEINFO BINFO; LPITEMIDLIST pidl; LPMALLOC pMalloc; int res = 0; if (SUCCEEDED(SHGetMalloc(&pMalloc))) { memset(&BINFO, 0, sizeof(BINFO)); BINFO.hwndOwner = hwnd; #ifdef CHINESE BINFO.lpszTitle = "选择ROM文件夹"; #else BINFO.lpszTitle = "Select ROM folder"; #endif BINFO.ulFlags = BIF_RETURNONLYFSDIRS; pidl = SHBrowseForFolder(&BINFO); if (pidl) { res = SHGetPathFromIDList(pidl, path); IMalloc_Free(pMalloc, pidl); } IMalloc_Release(pMalloc); } return res; }
static NTSTATUS EnumRunningObjectTable( _In_ PVOID ThreadParam ) { IRunningObjectTable* iRunningObjectTable = NULL; IEnumMoniker* iEnumMoniker = NULL; IMoniker* iMoniker = NULL; IBindCtx* iBindCtx = NULL; IMalloc* iMalloc = NULL; ULONG count = 0; HWND listViewHandle = (HWND)ThreadParam; if (!SUCCEEDED(CoGetMalloc(1, &iMalloc))) return STATUS_INSUFFICIENT_RESOURCES; // Query the running object table address if (SUCCEEDED(GetRunningObjectTable(0, &iRunningObjectTable))) { // Enum the objects registered if (SUCCEEDED(IRunningObjectTable_EnumRunning(iRunningObjectTable, &iEnumMoniker))) { while (IEnumMoniker_Next(iEnumMoniker, 1, &iMoniker, &count) == S_OK) { if (SUCCEEDED(CreateBindCtx(0, &iBindCtx))) { OLECHAR* displayName = NULL; // Query the object name if (SUCCEEDED(IMoniker_GetDisplayName(iMoniker, iBindCtx, NULL, &displayName))) { // Set the items name column PhAddListViewItem(listViewHandle, MAXINT, displayName, NULL); // Free the object name IMalloc_Free(iMalloc, displayName); } IBindCtx_Release(iBindCtx); } IEnumMoniker_Release(iMoniker); } IEnumMoniker_Release(iEnumMoniker); } IRunningObjectTable_Release(iRunningObjectTable); } IMalloc_Release(iMalloc); return STATUS_SUCCESS; }
int main(int argc, char **argv) { void *p; com_result_t r; int n; size_t s; IMalloc *allocator; (void) argc; (void) argv; com_init("com.googlecode.libcom.test-1"); p = CoTaskMemAlloc(64); if(NULL == p) { fprintf(stderr, "Failed to allocate 64 bytes via CoTaskMemAlloc()\n"); exit(EXIT_FAILURE); } if(COM_S_OK != (r = CoGetMalloc(1, &allocator))) { fprintf(stderr, "Failed to obtain reference to task allocator; result = 0x%08x\n", r); exit(EXIT_FAILURE); } if(1 != (n = IMalloc_DidAlloc(allocator, p))) { if(0 == n) { fprintf(stderr, "IMalloc::DidAlloc() claims task allocator was not responsible for allocated block\n"); } else { fprintf(stderr, "IMalloc::DidAlloc() could not determine responsibility for allocated block\n"); } exit(EXIT_FAILURE); } if(64 != (s = IMalloc_GetSize(allocator, p))) { fprintf(stderr, "IMalloc::GetSize() returned an incorrect size (%ul bytes)\n", s); exit(EXIT_FAILURE); } IMalloc_Free(allocator, p); puts("PASS"); com_shutdown(); return 0; }
BOOL BrowseForDirectory(HWND hwnd, LPCTSTR pStartDir, TCHAR* pResult) { BOOL bResult = FALSE; IMalloc* piMalloc = 0; BROWSEINFO Info; LPITEMIDLIST pItemIDList = NULL; TCHAR buf[MAX_PATH]; if (!SUCCEEDED(SHGetMalloc(&piMalloc))) return FALSE; Info.hwndOwner = hwnd; Info.pidlRoot = NULL; Info.pszDisplayName = buf; Info.lpszTitle = TEXT("Directory name:"); Info.ulFlags = BIF_RETURNONLYFSDIRS; Info.lpfn = BrowseCallbackProc; Info.lParam = (LPARAM)pStartDir; pItemIDList = SHBrowseForFolder(&Info); if (pItemIDList != NULL) { if (SHGetPathFromIDList(pItemIDList, buf) == TRUE) { _sntprintf(pResult, MAX_PATH, TEXT("%s"), buf); bResult = TRUE; } IMalloc_Free(piMalloc, pItemIDList); } else { bResult = FALSE; } IMalloc_Release(piMalloc); return bResult; }
BOOL BrowseForDirectory(HWND hwnd, const char* pStartDir, char* pResult) { BOOL bResult = FALSE; IMalloc* piMalloc = 0; BROWSEINFO Info; ITEMIDLIST* pItemIDList = NULL; char buf[MAX_PATH]; if (!SUCCEEDED(SHGetMalloc(&piMalloc))) return FALSE; Info.hwndOwner = hwnd; Info.pidlRoot = NULL; Info.pszDisplayName = buf; Info.lpszTitle = (LPCSTR)"Directory name:"; Info.ulFlags = BIF_RETURNONLYFSDIRS; Info.lpfn = BrowseCallbackProc; Info.lParam = (LPARAM)pStartDir; pItemIDList = SHBrowseForFolder(&Info); if (pItemIDList != NULL) { if (SHGetPathFromIDList(pItemIDList, buf) == TRUE) { strncpy(pResult, buf, MAX_PATH); bResult = TRUE; } IMalloc_Free(piMalloc, pItemIDList); } else { bResult = FALSE; } IMalloc_Release(piMalloc); return bResult; }
/** * Cycle through available devices using the device enumerator devenum, * retrieve the device with type specified by devtype and return the * pointer to the object found in *pfilter. * If pfilter is NULL, list all device names. */ static int dshow_cycle_devices(AVFormatContext *avctx, ICreateDevEnum *devenum, enum dshowDeviceType devtype, enum dshowSourceFilterType sourcetype, IBaseFilter **pfilter) { struct dshow_ctx *ctx = avctx->priv_data; IBaseFilter *device_filter = NULL; IEnumMoniker *classenum = NULL; IMoniker *m = NULL; const char *device_name = ctx->device_name[devtype]; int skip = (devtype == VideoDevice) ? ctx->video_device_number : ctx->audio_device_number; int r; const GUID *device_guid[2] = { &CLSID_VideoInputDeviceCategory, &CLSID_AudioInputDeviceCategory }; const char *devtypename = (devtype == VideoDevice) ? "video" : "audio only"; const char *sourcetypename = (sourcetype == VideoSourceDevice) ? "video" : "audio"; r = ICreateDevEnum_CreateClassEnumerator(devenum, device_guid[sourcetype], (IEnumMoniker **) &classenum, 0); if (r != S_OK) { av_log(avctx, AV_LOG_ERROR, "Could not enumerate %s devices (or none found).\n", devtypename); return AVERROR(EIO); } while (!device_filter && IEnumMoniker_Next(classenum, 1, &m, NULL) == S_OK) { IPropertyBag *bag = NULL; char *friendly_name = NULL; char *unique_name = NULL; VARIANT var; IBindCtx *bind_ctx = NULL; LPOLESTR olestr = NULL; LPMALLOC co_malloc = NULL; int i; r = CoGetMalloc(1, &co_malloc); if (r != S_OK) goto fail1; r = CreateBindCtx(0, &bind_ctx); if (r != S_OK) goto fail1; /* GetDisplayname works for both video and audio, DevicePath doesn't */ r = IMoniker_GetDisplayName(m, bind_ctx, NULL, &olestr); if (r != S_OK) goto fail1; unique_name = dup_wchar_to_utf8(olestr); /* replace ':' with '_' since we use : to delineate between sources */ for (i = 0; i < strlen(unique_name); i++) { if (unique_name[i] == ':') unique_name[i] = '_'; } r = IMoniker_BindToStorage(m, 0, 0, &IID_IPropertyBag, (void *) &bag); if (r != S_OK) goto fail1; var.vt = VT_BSTR; r = IPropertyBag_Read(bag, L"FriendlyName", &var, NULL); if (r != S_OK) goto fail1; friendly_name = dup_wchar_to_utf8(var.bstrVal); if (pfilter) { if (strcmp(device_name, friendly_name) && strcmp(device_name, unique_name)) goto fail1; if (!skip--) { r = IMoniker_BindToObject(m, 0, 0, &IID_IBaseFilter, (void *) &device_filter); if (r != S_OK) { av_log(avctx, AV_LOG_ERROR, "Unable to BindToObject for %s\n", device_name); goto fail1; } } } else { av_log(avctx, AV_LOG_INFO, " \"%s\"\n", friendly_name); av_log(avctx, AV_LOG_INFO, " Alternative name \"%s\"\n", unique_name); } fail1: if (olestr && co_malloc) IMalloc_Free(co_malloc, olestr); if (bind_ctx) IBindCtx_Release(bind_ctx); av_free(friendly_name); av_free(unique_name); if (bag) IPropertyBag_Release(bag); IMoniker_Release(m); } IEnumMoniker_Release(classenum); if (pfilter) { if (!device_filter) { av_log(avctx, AV_LOG_ERROR, "Could not find %s device with name [%s] among source devices of type %s.\n", devtypename, device_name, sourcetypename); return AVERROR(EIO); } *pfilter = device_filter; } return 0; }
/* Process items in the StartUp group of the user's Programs under the Start Menu. Some installers put * shell links here to restart themselves after boot. */ static BOOL ProcessStartupItems(void) { BOOL ret = FALSE; HRESULT hr; IMalloc *ppM = NULL; IShellFolder *psfDesktop = NULL, *psfStartup = NULL; LPITEMIDLIST pidlStartup = NULL, pidlItem; ULONG NumPIDLs; IEnumIDList *iEnumList = NULL; STRRET strret; WCHAR wszCommand[MAX_PATH]; WINE_TRACE("Processing items in the StartUp folder.\n"); hr = SHGetMalloc(&ppM); if (FAILED(hr)) { WINE_ERR("Couldn't get IMalloc object.\n"); goto done; } hr = SHGetDesktopFolder(&psfDesktop); if (FAILED(hr)) { WINE_ERR("Couldn't get desktop folder.\n"); goto done; } hr = SHGetSpecialFolderLocation(NULL, CSIDL_STARTUP, &pidlStartup); if (FAILED(hr)) { WINE_TRACE("Couldn't get StartUp folder location.\n"); goto done; } hr = IShellFolder_BindToObject(psfDesktop, pidlStartup, NULL, &IID_IShellFolder, (LPVOID*)&psfStartup); if (FAILED(hr)) { WINE_TRACE("Couldn't bind IShellFolder to StartUp folder.\n"); goto done; } hr = IShellFolder_EnumObjects(psfStartup, NULL, SHCONTF_NONFOLDERS | SHCONTF_INCLUDEHIDDEN, &iEnumList); if (FAILED(hr)) { WINE_TRACE("Unable to enumerate StartUp objects.\n"); goto done; } while (IEnumIDList_Next(iEnumList, 1, &pidlItem, &NumPIDLs) == S_OK && (NumPIDLs) == 1) { hr = IShellFolder_GetDisplayNameOf(psfStartup, pidlItem, SHGDN_FORPARSING, &strret); if (FAILED(hr)) WINE_TRACE("Unable to get display name of enumeration item.\n"); else { hr = StrRetToBufW(&strret, pidlItem, wszCommand, MAX_PATH); if (FAILED(hr)) WINE_TRACE("Unable to parse display name.\n"); else { HINSTANCE hinst; hinst = ShellExecuteW(NULL, NULL, wszCommand, NULL, NULL, SW_SHOWNORMAL); if (PtrToUlong(hinst) <= 32) WINE_WARN("Error %p executing command %s.\n", hinst, wine_dbgstr_w(wszCommand)); } } IMalloc_Free(ppM, pidlItem); } /* Return success */ ret = TRUE; done: if (iEnumList) IEnumIDList_Release(iEnumList); if (psfStartup) IShellFolder_Release(psfStartup); if (pidlStartup) IMalloc_Free(ppM, pidlStartup); return ret; }
/*********************************************************************** * CoTaskMemFree [OLE32.@] * * Frees memory allocated from the current process memory allocator. * * PARAMS * ptr [I] Memory block to free. * * RETURNS * Nothing. */ VOID WINAPI CoTaskMemFree(LPVOID ptr) { IMalloc_Free((LPMALLOC)&Malloc32, ptr); }
/*********************************************************************** * CoTaskMemFree [OLE32.@] * * Frees memory allocated from the current process memory allocator. * * PARAMS * ptr [I] Memory block to free. * * RETURNS * Nothing. */ VOID WINAPI CoTaskMemFree(LPVOID ptr) { IMalloc_Free(&Malloc32.IMalloc_iface, ptr); }
void CoTaskMemFree( void *pvMem ) { if( initCount != 0 ) IMalloc_Free( pTaskMalloc, pvMem ); }