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 );
}
