/* win32.FindWindow title ?class? */
static int
Win32_FindWindow(Jim_Interp *interp, int objc, Jim_Obj * const *objv)
{
const char *title = NULL, *class = NULL;
HWND hwnd = NULL;
int r = JIM_OK;
if (objc < 2 || objc > 3) {
Jim_WrongNumArgs(interp, 1, objv, "title ?class?");
return JIM_ERR;
}
title = Jim_String(objv[1]);
if (objc == 3)
class = Jim_String(objv[2]);
hwnd = FindWindowA(class, title);
if (hwnd == NULL) {
Jim_SetResult(interp,
Win32ErrorObj(interp, "FindWindow", GetLastError()));
r = JIM_ERR;
} else {
Jim_SetResult(interp, Jim_NewIntObj(interp, (long)hwnd));
}
return r;
}
// FIX ME: win2k+ so should do version checks really.
static int
Win32_GetPerformanceInfo(Jim_Interp *interp, int objc, Jim_Obj * const *objv)
{
Jim_Obj *a[26];
size_t n = 0;
PERFORMANCE_INFORMATION pi;
if (!GetPerformanceInfo(&pi, sizeof(pi))) {
Jim_SetResult(interp,
Win32ErrorObj(interp, "GetPerformanceInfo", GetLastError()));
return JIM_ERR;
}
#define JIMADD(name) \
a[n++] = Jim_NewStringObj(interp, #name, -1); \
a[n++] = Jim_NewIntObj(interp, pi. name )
JIMADD(CommitTotal);
JIMADD(CommitLimit);
JIMADD(CommitPeak);
JIMADD(PhysicalTotal);
JIMADD(PhysicalAvailable);
JIMADD(SystemCache);
JIMADD(KernelTotal);
JIMADD(KernelPaged);
JIMADD(KernelNonpaged);
JIMADD(PageSize);
JIMADD(HandleCount);
JIMADD(ProcessCount);
JIMADD(ThreadCount);
#undef JIMADD
Jim_SetResult(interp, Jim_NewListObj(interp, a, n));
return JIM_OK;
}
static int
Win32_LoadCursor(Jim_Interp *interp, int objc, Jim_Obj *const objv[])
{
HCURSOR hCursor;
int ndx;
static const char *name[] = {
"appstarting", "arrow", "cross", "hand", "help", "ibeam",
"icon", "no", "size", "sizeall", "sizenesw", "sizens",
"sizenwse", "sizewe", "uparrow", "wait", NULL
};
static LPCTSTR id[] = {
IDC_APPSTARTING, IDC_ARROW, IDC_CROSS, IDC_HAND, IDC_HELP, IDC_IBEAM,
IDC_ICON, IDC_NO, IDC_SIZEALL, IDC_SIZEALL, IDC_SIZENESW, IDC_SIZENS,
IDC_SIZENWSE, IDC_UPARROW, IDC_WAIT, NULL
};
if (objc != 2) {
Jim_WrongNumArgs(interp, 1, objv, "name");
return JIM_ERR;
}
if (Jim_GetEnum(interp, objv[1], name, &ndx, "cursor name", JIM_ERRMSG) != JIM_OK)
return JIM_ERR;
hCursor = LoadCursor((HINSTANCE)NULL, id[ndx]);
if (hCursor == NULL) {
Jim_SetResult(interp,
Win32ErrorObj(interp, "LoadCursor", GetLastError()));
return JIM_ERR;
}
Jim_SetResult(interp, Jim_NewIntObj(interp, (DWORD)hCursor));
return JIM_OK;
}
static int
Win32_AnimateWindow(Jim_Interp *interp, int objc, Jim_Obj *const objv[])
{
HWND hwnd;
DWORD dwTime = 0, dwFlags = 0;
struct map_t { const char* s; DWORD f; };
if (objc != 4) {
Jim_WrongNumArgs(interp, 1, objv, "windowhandle time flags");
return JIM_ERR;
}
if (Jim_GetLong(interp, objv[1], (long *)&hwnd) != JIM_OK)
return JIM_ERR;
if (Jim_GetLong(interp, objv[2], &dwTime) != JIM_OK)
return JIM_ERR;
if (GetAnimateWindowFlagsFromObj(interp, objv[3], &dwFlags) != JIM_OK)
return JIM_ERR;
if (!AnimateWindow(hwnd, dwTime, dwFlags)) {
DWORD err = GetLastError();
Jim_Obj *errObj;
if (err == ERROR_SUCCESS)
errObj = Jim_NewStringObj(interp, "error: "
" calling thread does not own the window", -1);
else
errObj = Win32ErrorObj(interp, "AnimateWindow", err);
Jim_SetResult(interp, errObj);
return JIM_ERR;
}
return JIM_OK;
}
static int
Win32_GetCursorInfo(Jim_Interp *interp, int objc, Jim_Obj *const objv[])
{
Jim_Obj *a[8];
size_t n = 0;
CURSORINFO ci;
JIM_NOTUSED(objc);
JIM_NOTUSED(objv);
ci.cbSize = sizeof(ci);
if (!GetCursorInfo(&ci)) {
Jim_SetResult(interp,
Win32ErrorObj(interp, "GetCursorInfo", GetLastError()));
return JIM_ERR;
}
#define JIMADDN(name) a[n++] = Jim_NewStringObj(interp, #name, -1);
#define JIMADDV(v) a[n++] = Jim_NewIntObj(interp, (v));
JIMADDN(flags); JIMADDV(ci.flags);
JIMADDN(hCursor); JIMADDV((DWORD)ci.hCursor);
JIMADDN(x); JIMADDV(ci.ptScreenPos.x);
JIMADDN(y); JIMADDV(ci.ptScreenPos.y);
#undef JIMADDN
#undef JIMADDV
Jim_SetResult(interp, Jim_NewListObj(interp, a, n));
return JIM_OK;
}
static BOOL
Win32_GetLastInputInfo(Jim_Interp *interp, int objc, Jim_Obj *const objv[])
{
struct lastinputinfo_t {
UINT cbSize;
DWORD dwTime;
} lii;
typedef BOOL (__stdcall *LPFNGETLASTINPUTINFO)(struct lastinputinfo_t *);
LPFNGETLASTINPUTINFO lpfnGetLastInputInfo = NULL;
HMODULE hLib = (HMODULE)Jim_CmdPrivData(interp);
JIM_NOTUSED(objc);
JIM_NOTUSED(objv);
if (hLib != NULL)
lpfnGetLastInputInfo = (LPFNGETLASTINPUTINFO)GetProcAddress(hLib, "GetLastInputInfo");
if (lpfnGetLastInputInfo == NULL) {
Jim_SetResultString(interp, "command not available on this platform", -1);
return JIM_ERR;
}
lii.cbSize = sizeof(lii);
if (!lpfnGetLastInputInfo(&lii)) {
Jim_SetResult(interp,
Win32ErrorObj(interp, "GetLastInputInfo", GetLastError()));
return JIM_ERR;
}
Jim_SetResult(interp, Jim_NewIntObj(interp, lii.dwTime));
return JIM_OK;
}
static int
Win32_ShowWindow(Jim_Interp *interp, int objc, Jim_Obj *const objv[])
{
HWND hwnd;
int cmd;
const char *cmds[] = {
"SW_HIDE", "SW_SHOWNORMAL", "SW_SHOWMINIMIZED", "SW_MAXIMIZE",
"SW_SHOWNOACTIVATE", "SW_SHOW", "SW_MINIMIZE", "SW_SHOWMINNOACTIVE",
"SW_SHOWNA", "SW_RESTORE", "SW_SHOWDEFAULT", "SW_FORCEMINIMIZE",
NULL
};
if (objc != 3) {
Jim_WrongNumArgs(interp, 1, objv, "windowhandle option");
return JIM_ERR;
}
if (Jim_GetLong(interp, objv[1], (long *)&hwnd) != JIM_OK)
return JIM_ERR;
if (Jim_GetEnum(interp, objv[2], cmds, &cmd, "command", JIM_ERRMSG) != JIM_OK)
return JIM_ERR;
if (!ShowWindow(hwnd, cmd)) {
Jim_SetResult(interp,
Win32ErrorObj(interp, "ShowWindow", GetLastError()));
return JIM_ERR;
}
return JIM_OK;
}
static int
Win32_GetModuleFileName(Jim_Interp *interp, int objc, Jim_Obj * const *objv)
{
HMODULE hModule = NULL;
char path[MAX_PATH];
DWORD len = 0;
if (objc > 2) {
Jim_WrongNumArgs(interp, 1, objv, "?moduleid?");
return JIM_ERR;
}
if (objc == 2) {
if (Jim_GetLong(interp, objv[1], (long *)&hModule) != JIM_OK) {
return JIM_ERR;
}
}
len = GetModuleFileNameA(hModule, path, MAX_PATH);
if (len != 0) {
Jim_Obj *pathObj = Jim_NewStringObj(interp, path, len);
Jim_SetResult(interp, pathObj);
} else {
Jim_SetResult(interp,
Win32ErrorObj(interp, "GetModuleFileName", GetLastError()));
return JIM_ERR;
}
return JIM_OK;
}
static int
FindInterpreterObject(
Tcl_Interp *interp,
const char *name,
LPDISPATCH *ppdisp)
{
LPRUNNINGOBJECTTABLE pROT = NULL;
int result = TCL_OK;
HRESULT hr = GetRunningObjectTable(0, &pROT);
if (SUCCEEDED(hr)) {
IBindCtx* pBindCtx = NULL;
hr = CreateBindCtx(0, &pBindCtx);
if (SUCCEEDED(hr)) {
LPMONIKER pmk = NULL;
hr = BuildMoniker(name, &pmk);
if (SUCCEEDED(hr)) {
IUnknown *pUnkInterp = NULL, **ppUnkInterp = &pUnkInterp;
hr = pROT->lpVtbl->IsRunning(pROT, pmk);
hr = pmk->lpVtbl->BindToObject(pmk, pBindCtx, NULL,
&IID_IUnknown, (void **) ppUnkInterp);
if (SUCCEEDED(hr)) {
hr = pUnkInterp->lpVtbl->QueryInterface(pUnkInterp,
&IID_IDispatch, (void **) ppdisp);
pUnkInterp->lpVtbl->Release(pUnkInterp);
} else {
Tcl_SetObjResult(interp, Tcl_ObjPrintf(
"no application named \"%s\"", name));
Tcl_SetErrorCode(interp, "TK", "LOOKUP", "APPLICATION",
NULL);
result = TCL_ERROR;
}
pmk->lpVtbl->Release(pmk);
}
pBindCtx->lpVtbl->Release(pBindCtx);
}
pROT->lpVtbl->Release(pROT);
}
if (FAILED(hr) && result == TCL_OK) {
Tcl_SetObjResult(interp, Win32ErrorObj(hr));
result = TCL_ERROR;
}
return result;
}
static int
Win32_GetPerformanceInfo(Jim_Interp *interp, int objc, Jim_Obj *const *objv)
{
Jim_Obj *a[26];
size_t n = 0;
PERFORMANCE_INFORMATION pi;
LPFNGETPERFORMANCEINFO lpfnGetPerformanceInfo = NULL;
HMODULE hLib = (HMODULE)Jim_CmdPrivData(interp);
JIM_NOTUSED(objc);
JIM_NOTUSED(objv);
if (hLib != NULL)
lpfnGetPerformanceInfo = (LPFNGETPERFORMANCEINFO)GetProcAddress(hLib, "GetPerformanceInfo");
if (lpfnGetPerformanceInfo == NULL) {
/* should never happen */
Jim_SetResultString(interp, "argh!", -1);
return JIM_ERR;
}
pi.cb = sizeof(pi);
if (!lpfnGetPerformanceInfo(&pi, sizeof(pi))) {
Jim_SetResult(interp,
Win32ErrorObj(interp, "GetPerformanceInfo", GetLastError()));
return JIM_ERR;
}
#define JIMADD(name) \
a[n++] = Jim_NewStringObj(interp, #name, -1); \
a[n++] = Jim_NewIntObj(interp, pi.name )
JIMADD(CommitTotal);
JIMADD(CommitLimit);
JIMADD(CommitPeak);
JIMADD(PhysicalTotal);
JIMADD(PhysicalAvailable);
JIMADD(SystemCache);
JIMADD(KernelTotal);
JIMADD(KernelPaged);
JIMADD(KernelNonpaged);
JIMADD(PageSize);
JIMADD(HandleCount);
JIMADD(ProcessCount);
JIMADD(ThreadCount);
#undef JIMADD
Jim_SetResult(interp, Jim_NewListObj(interp, a, n));
return JIM_OK;
}
static int
Win32_SetComputerName(Jim_Interp *interp, int objc, Jim_Obj * const *objv)
{
int r = JIM_OK;
const char *name;
if (objc != 2) {
Jim_WrongNumArgs(interp, 1, objv, "computername");
return JIM_ERR;
}
name = Jim_String(objv[1]);
if (!SetComputerNameA(name)) {
Jim_SetResult(interp,
Win32ErrorObj(interp, "SetComputerName", GetLastError()));
r = JIM_ERR;
}
return r;
}
static int
Win32_LoadLibrary(Jim_Interp *interp, int objc, Jim_Obj * const *objv)
{
HMODULE hLib = NULL;
if (objc != 2) {
Jim_WrongNumArgs(interp, 1, objv, "path");
return JIM_ERR;
}
hLib = LoadLibraryA(Jim_String(objv[1]));
if (hLib == NULL) {
Jim_SetResult(interp,
Win32ErrorObj(interp, "LoadLibrary", GetLastError()));
return JIM_ERR;
}
Jim_SetResult(interp, Jim_NewIntObj(interp, (unsigned long)hLib));
return JIM_OK;
}
static int
Win32_GetCursorPos(Jim_Interp *interp, int objc, Jim_Obj *const objv[])
{
Jim_Obj *a[2];
POINT pt;
JIM_NOTUSED(objc);
JIM_NOTUSED(objv);
if (!GetCursorPos(&pt)) {
Jim_SetResult(interp,
Win32ErrorObj(interp, "GetCursorPos", GetLastError()));
return JIM_ERR;
}
a[0] = Jim_NewIntObj(interp, pt.x);
a[1] = Jim_NewIntObj(interp, pt.y);
Jim_SetResult(interp, Jim_NewListObj(interp, a, 2));
return JIM_OK;
}
static int
Win32_UpdateWindow(Jim_Interp *interp, int objc, Jim_Obj *const objv[])
{
HWND hwnd;
if (objc != 2) {
Jim_WrongNumArgs(interp, 1, objv, "hwnd");
return JIM_ERR;
}
if (Jim_GetLong(interp, objv[1], (long *)&hwnd) != JIM_OK)
return JIM_ERR;
if (!UpdateWindow(hwnd)) {
Jim_SetResult(interp,
Win32ErrorObj(interp, "UpdateWindow", GetLastError()));
return JIM_ERR;
}
return JIM_OK;
}
/* win32.CloseWindow windowHandle */
static int
Win32_CloseWindow(Jim_Interp *interp, int objc, Jim_Obj * const *objv)
{
long hwnd;
if (objc != 2) {
Jim_WrongNumArgs(interp, 1, objv, "?windowHandle?");
return JIM_ERR;
}
if (Jim_GetLong(interp, objv[1], &hwnd) != JIM_OK)
return JIM_ERR;
if (!CloseWindow((HWND)hwnd)) {
Jim_SetResult(interp,
Win32ErrorObj(interp, "CloseWindow", GetLastError()));
return JIM_ERR;
}
return JIM_OK;
}
static int
Win32_RemoveDirectory(Jim_Interp *interp, int objc, Jim_Obj *const *objv)
{
const char * path;
if (objc != 2) {
Jim_WrongNumArgs(interp, 1, objv, "path");
return JIM_ERR;
}
path = Jim_GetString(objv[1], NULL);
if (!RemoveDirectoryA(path)) {
Jim_SetResult(interp,
Win32ErrorObj(interp, "RemoveDirectory", GetLastError()));
return JIM_ERR;
}
return JIM_OK;
}
static int
Win32_SetForegroundWindow(Jim_Interp *interp, int objc, Jim_Obj * const *objv)
{
HWND hwnd;
int r = JIM_OK;
if (objc != 2) {
Jim_WrongNumArgs(interp, 1, objv, "windowHandle");
return JIM_ERR;
}
r = Jim_GetLong(interp, objv[1], (long *)&hwnd);
if (r == JIM_OK) {
if (!SetForegroundWindow(hwnd)) {
Jim_SetResult(interp,
Win32ErrorObj(interp, "SetForegroundWindow", GetLastError()));
r = JIM_ERR;
}
}
return r;
}
static int
Win32_CreateWindow(Jim_Interp *interp, int objc, Jim_Obj *const objv[])
{
int r = JIM_ERR;
HWND hwnd, hwndParent = HWND_DESKTOP;
DWORD style = WS_VISIBLE | WS_OVERLAPPEDWINDOW;
UINT id = 0;
const char *class, *title;
if (objc < 3 || objc > 5) {
Jim_WrongNumArgs(interp, 1, objv, "class title ?parent? ?id?");
return JIM_ERR;
}
class = Jim_GetString(objv[1], NULL);
title = Jim_GetString(objv[2], NULL);
if (objc == 4) {
if (Jim_GetLong(interp, objv[3], (long *)&hwndParent) != JIM_OK)
return JIM_ERR;
style = WS_VISIBLE | WS_CHILD | WS_CLIPCHILDREN | WS_CLIPSIBLINGS;
}
if (objc == 5) {
if (Jim_GetLong(interp, objv[4], (long *)&id) != JIM_OK)
return JIM_ERR;
}
hwnd = CreateWindowA(class, title, style,
CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
hwndParent, (HMENU)id, g_hInstance, NULL);
if (hwnd) {
SetWindowLongPtr(hwnd, GWLP_USERDATA, (LONG_PTR)interp);
Jim_SetResult(interp, Jim_NewIntObj(interp, (DWORD)hwnd));
r = JIM_OK;
} else {
Jim_SetResult(interp,
Win32ErrorObj(interp, "CreateWindow", GetLastError()));
r = JIM_ERR;
}
return r;
}
static int
Win32_GetModuleHandle(Jim_Interp *interp, int objc, Jim_Obj * const *objv)
{
HMODULE hModule = NULL;
const char *name = NULL;
if (objc < 1 || objc > 2) {
Jim_WrongNumArgs(interp, 1, objv, "?name?");
return JIM_ERR;
}
if (objc == 2)
name = Jim_String(objv[1]);
hModule = GetModuleHandleA(name);
if (hModule == NULL) {
Jim_SetResult(interp,
Win32ErrorObj(interp, "GetModuleHandle", GetLastError()));
return JIM_ERR;
}
Jim_SetResult(interp, Jim_NewIntObj(interp, (unsigned long)hModule));
return JIM_OK;
}
/* win32.ShellExecute verb file args */
static int
Win32_ShellExecute(Jim_Interp *interp, int objc, Jim_Obj * const *objv)
{
ptrdiff_t r;
const char *verb, *file, *parm = NULL;
char cwd[MAX_PATH + 1];
if (objc < 3 || objc > 4) {
Jim_WrongNumArgs(interp, 1, objv, "verb path ?parameters?");
return JIM_ERR;
}
verb = Jim_String(objv[1]);
file = Jim_String(objv[2]);
GetCurrentDirectoryA(MAX_PATH + 1, cwd);
if (objc == 4)
parm = Jim_String(objv[3]);
r = (ptrdiff_t)ShellExecuteA(NULL, verb, file, parm, cwd, SW_SHOWNORMAL);
if (r < 33)
Jim_SetResult(interp,
Win32ErrorObj(interp, "ShellExecute", GetLastError()));
return (r < 33) ? JIM_ERR : JIM_OK;
}
static int
Win32_FreeLibrary(Jim_Interp *interp, int objc, Jim_Obj * const *objv)
{
HMODULE hModule = NULL;
int r = JIM_OK;
if (objc != 2) {
Jim_WrongNumArgs(interp, 1, objv, "hmodule");
return JIM_ERR;
}
r = Jim_GetLong(interp, objv[1], (long *)&hModule);
if (r == JIM_OK) {
if (!FreeLibrary(hModule)) {
Jim_SetResult(interp,
Win32ErrorObj(interp, "FreeLibrary", GetLastError()));
r = JIM_ERR;
}
}
return r;
}
static int
Win32_SetCursorPos(Jim_Interp *interp, int objc, Jim_Obj *const objv[])
{
int r = JIM_OK;
POINT pt;
if (objc != 3) {
Jim_WrongNumArgs(interp, 1, objv, "x y");
return JIM_ERR;
}
r = Jim_GetLong(interp, objv[1], &pt.x);
if (r == JIM_OK)
r = Jim_GetLong(interp, objv[2], &pt.y);
if (r == JIM_OK) {
if (!SetCursorPos(pt.x, pt.y)) {
Jim_SetResult(interp,
Win32ErrorObj(interp, "SetCursorPos", GetLastError()));
r = JIM_ERR;
}
}
return r;
}
static int
Win32_GetUserName(Jim_Interp *interp, int objc, Jim_Obj * const *objv)
{
char name[UNLEN + 1];
DWORD size = UNLEN;
int r = JIM_OK;
if (objc != 1) {
Jim_WrongNumArgs(interp, 1, objv, "");
return JIM_ERR;
}
if (GetUserNameA(name, &size)) {
Jim_Obj *nameObj = Jim_NewStringObj(interp, name, size);
Jim_SetResult(interp, nameObj);
} else {
Jim_SetResult(interp,
Win32ErrorObj(interp, "GetUserName", GetLastError()));
r = JIM_ERR;
}
return r;
}
static int
Win32_SetActiveWindow(Jim_Interp *interp, int objc, Jim_Obj * const *objv)
{
HWND hwnd, old;
int r = JIM_OK;
if (objc != 2) {
Jim_WrongNumArgs(interp, 1, objv, "windowHandle");
return JIM_ERR;
}
r = Jim_GetLong(interp, objv[1], (long *)&hwnd);
if (r == JIM_OK) {
old = SetActiveWindow(hwnd);
if (old == NULL) {
Jim_SetResult(interp,
Win32ErrorObj(interp, "SetActiveWindow", GetLastError()));
r = JIM_ERR;
} else {
Jim_SetResult(interp, Jim_NewIntObj(interp, (long)old));
}
}
return r;
}
static int
Win32_MoveWindow(Jim_Interp *interp, int objc, Jim_Obj *const objv[])
{
HWND hwnd;
int n, param[4];
if (objc != 6) {
Jim_WrongNumArgs(interp, 1, objv, "hwnd x y width height");
return JIM_ERR;
}
if (Jim_GetLong(interp, objv[1], (long *)&hwnd) != JIM_OK)
return JIM_ERR;
for (n = 2; n < 6; n++) {
if (Jim_GetLong(interp, objv[n], (long*)¶m[n-2]) != JIM_OK)
return JIM_ERR;
}
if (!MoveWindow(hwnd, param[0], param[1], param[2], param[3], TRUE)) {
Jim_SetResult(interp,
Win32ErrorObj(interp, "MoveWindow", GetLastError()));
return JIM_ERR;
}
return JIM_OK;
}
static int
Win32_RegisterClass(Jim_Interp *interp, int objc, Jim_Obj *const objv[])
{
WNDCLASSEXA wc;
if (objc < 2 || objc > 3) {
Jim_WrongNumArgs(interp, 1, objv, "classname ?windowproc?");
return JIM_ERR;
}
// FIX ME: deal with the windowproc
wc.cbSize = sizeof(WNDCLASSEX);
wc.style = CS_HREDRAW | CS_VREDRAW;
wc.lpfnWndProc = DefWindowProc;
wc.cbClsExtra = 16;
wc.cbWndExtra = 0;
wc.hInstance = g_hInstance;
wc.hIcon = LoadIcon(NULL, IDI_APPLICATION);
wc.hIconSm = LoadIcon(NULL, IDI_APPLICATION);
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
wc.hbrBackground = (HBRUSH)(COLOR_BTNFACE+1);
wc.lpszMenuName = wc.lpszClassName = Jim_GetString(objv[1], NULL);
if (objc == 3) {
wc.lpfnWndProc = JimWin32WindowProc;
}
if (!RegisterClassExA(&wc)) {
Jim_SetResult(interp,
Win32ErrorObj(interp, "RegisterClassEx", GetLastError()));
return JIM_ERR;
}
return JIM_OK;
}
static int
Win32_Beep(Jim_Interp *interp, int objc, Jim_Obj * const *objv)
{
long freq, duration;
int r = JIM_OK;
if (objc != 3) {
Jim_WrongNumArgs(interp, 1, objv, "freq duration");
return JIM_ERR;
}
r = Jim_GetLong(interp, objv[1], &freq);
if (r == JIM_OK)
r = Jim_GetLong(interp, objv[2], &duration);
if (freq < 0x25) freq = 0x25;
if (freq > 0x7fff) freq = 0x7fff;
if (r == JIM_OK) {
if (!Beep(freq, duration)) {
Jim_SetResult(interp,
Win32ErrorObj(interp, "Beep", GetLastError()));
r = JIM_ERR;
}
}
return r;
}
int
TkGetInterpNames(
Tcl_Interp *interp, /* Interpreter for returning a result. */
Tk_Window tkwin) /* Window whose display is to be used for the
* lookup. */
{
#ifndef TK_SEND_ENABLED_ON_WINDOWS
/*
* Temporarily disabled for bug #858822
*/
return TCL_OK;
#else /* TK_SEND_ENABLED_ON_WINDOWS */
LPRUNNINGOBJECTTABLE pROT = NULL;
LPCOLESTR oleszStub = TKWINSEND_REGISTRATION_BASE;
HRESULT hr = S_OK;
Tcl_Obj *objList = NULL;
int result = TCL_OK;
hr = GetRunningObjectTable(0, &pROT);
if (SUCCEEDED(hr)) {
IBindCtx* pBindCtx = NULL;
objList = Tcl_NewListObj(0, NULL);
hr = CreateBindCtx(0, &pBindCtx);
if (SUCCEEDED(hr)) {
IEnumMoniker* pEnum;
hr = pROT->lpVtbl->EnumRunning(pROT, &pEnum);
if (SUCCEEDED(hr)) {
IMoniker* pmk = NULL;
while (pEnum->lpVtbl->Next(pEnum, 1, &pmk, NULL) == S_OK) {
LPOLESTR olestr;
hr = pmk->lpVtbl->GetDisplayName(pmk, pBindCtx, NULL,
&olestr);
if (SUCCEEDED(hr)) {
IMalloc *pMalloc = NULL;
if (wcsncmp(olestr, oleszStub,
wcslen(oleszStub)) == 0) {
LPOLESTR p = olestr + wcslen(oleszStub);
if (*p) {
result = Tcl_ListObjAppendElement(interp,
objList, Tcl_NewUnicodeObj(p + 1, -1));
}
}
hr = CoGetMalloc(1, &pMalloc);
if (SUCCEEDED(hr)) {
pMalloc->lpVtbl->Free(pMalloc, (void*)olestr);
pMalloc->lpVtbl->Release(pMalloc);
}
}
pmk->lpVtbl->Release(pmk);
}
pEnum->lpVtbl->Release(pEnum);
}
pBindCtx->lpVtbl->Release(pBindCtx);
}
pROT->lpVtbl->Release(pROT);
}
if (FAILED(hr)) {
/*
* Expire the list if set.
*/
if (objList != NULL) {
Tcl_DecrRefCount(objList);
}
Tcl_SetObjResult(interp, Win32ErrorObj(hr));
result = TCL_ERROR;
}
if (result == TCL_OK) {
Tcl_SetObjResult(interp, objList);
}
return result;
#endif /* TK_SEND_ENABLED_ON_WINDOWS */
}
