/**
* \brief Update screen information.
*
* This function should be called in libvo's "control" callback
* with parameter VOCTRL_UPDATE_SCREENINFO.
* Note that this also enables the new API where geometry and aspect
* calculations are done in video_out.c:config_video_out
*
* Global libvo variables changed:
* xinerama_x
* xinerama_y
* vo_screenwidth
* vo_screenheight
*/
void w32_update_xinerama_info(struct vo *vo)
{
struct vo_w32_state *w32 = vo->w32;
struct mp_vo_opts *opts = vo->opts;
int screen = opts->fs ? opts->fsscreen_id : opts->screen_id;
vo->xinerama_x = vo->xinerama_y = 0;
if (opts->fs && screen == -2) {
int tmp;
vo->xinerama_x = GetSystemMetrics(SM_XVIRTUALSCREEN);
vo->xinerama_y = GetSystemMetrics(SM_YVIRTUALSCREEN);
tmp = GetSystemMetrics(SM_CXVIRTUALSCREEN);
if (tmp) vo->opts->screenwidth = tmp;
tmp = GetSystemMetrics(SM_CYVIRTUALSCREEN);
if (tmp) vo->opts->screenheight = tmp;
} else if (screen == -1) {
MONITORINFO mi;
HMONITOR m = MonitorFromWindow(w32->window, MONITOR_DEFAULTTOPRIMARY);
mi.cbSize = sizeof(mi);
GetMonitorInfoW(m, &mi);
vo->xinerama_x = mi.rcMonitor.left;
vo->xinerama_y = mi.rcMonitor.top;
vo->opts->screenwidth = mi.rcMonitor.right - mi.rcMonitor.left;
vo->opts->screenheight = mi.rcMonitor.bottom - mi.rcMonitor.top;
} else if (screen >= 0) {
w32->mon_cnt = 0;
w32->mon_id = screen;
EnumDisplayMonitors(NULL, NULL, mon_enum, (LONG_PTR)vo);
}
aspect_save_screenres(vo, vo->opts->screenwidth,
vo->opts->screenheight);
}
void ToggleFullscreen(HWND Window, WINDOWPLACEMENT &WindowPosition)
{
// This follows Raymond Chen's prescription
// for fullscreen toggling, see:
// http://blogs.msdn.com/b/oldnewthing/archive/2010/04/12/9994016.aspx
DWORD Style = GetWindowLongW(Window, GWL_STYLE);
if (Style & WS_OVERLAPPEDWINDOW)
{
MONITORINFO MonitorInfo = { sizeof(MonitorInfo) };
if (GetWindowPlacement(Window, &WindowPosition) &&
GetMonitorInfoW(MonitorFromWindow(Window, MONITOR_DEFAULTTOPRIMARY), &MonitorInfo))
{
SetWindowLongW(Window, GWL_STYLE, Style & ~WS_OVERLAPPEDWINDOW);
SetWindowPos(Window, HWND_TOP,
MonitorInfo.rcMonitor.left, MonitorInfo.rcMonitor.top,
MonitorInfo.rcMonitor.right - MonitorInfo.rcMonitor.left,
MonitorInfo.rcMonitor.bottom - MonitorInfo.rcMonitor.top,
SWP_NOOWNERZORDER | SWP_FRAMECHANGED);
}
}
else
{
SetWindowLongW(Window, GWL_STYLE, Style | WS_OVERLAPPEDWINDOW);
SetWindowPlacement(Window, &WindowPosition);
SetWindowPos(Window, 0, 0, 0, 0, 0,
SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER |
SWP_NOOWNERZORDER | SWP_FRAMECHANGED);
}
}
INTBOOL __stdcall MonitorEnumProc( HANDLE hMonitor, HANDLE hdcMonitor, RECT* lprcMonitor, DWORD dwData )
{
DWORD monitorCount;
MONITORINFOEXW monitorInformation;
UNICODE_STRING deviceName;
DWORD numPhysicalMonitorHandlesInArray;
static int monEnums = 0;
monitorInformation.cbSize = sizeof(MONITORINFOEXW);
GetMonitorInfoW(hMonitor, &monitorInformation);
deviceName.Buffer = monitorInformation.szDevice;
deviceName.Length = 24;
deviceName.MaximumLength = 26;
GetNumberOfPhysicalMonitors(&deviceName, &monitorCount);
numPhysicalMonitorHandlesInArray = 0;
GetPhysicalMonitors(&deviceName, monitorCount, &numPhysicalMonitorHandlesInArray, &MonitorHandles[monEnums++]);
return TRUE;
}
static HRESULT STDMETHODCALLTYPE dxgi_output_GetDesc(IDXGIOutput *iface, DXGI_OUTPUT_DESC *desc)
{
struct dxgi_output *This = impl_from_IDXGIOutput(iface);
struct wined3d *wined3d;
MONITORINFOEXW monitor_info;
FIXME("iface %p, desc %p semi-stub!\n", iface, desc);
if (!desc)
return DXGI_ERROR_INVALID_CALL;
wined3d = This->adapter->parent->wined3d;
EnterCriticalSection(&dxgi_cs);
desc->Monitor = wined3d_get_adapter_monitor(wined3d, This->adapter->ordinal);
LeaveCriticalSection(&dxgi_cs);
if (!desc->Monitor)
return DXGI_ERROR_INVALID_CALL;
monitor_info.cbSize = sizeof(monitor_info);
if (!GetMonitorInfoW(desc->Monitor, (MONITORINFO *)&monitor_info))
return DXGI_ERROR_INVALID_CALL;
memcpy(&desc->DeviceName, &monitor_info.szDevice, sizeof(desc->DeviceName));
memcpy(&desc->DesktopCoordinates, &monitor_info.rcMonitor, sizeof(RECT));
desc->AttachedToDesktop = TRUE;
desc->Rotation = DXGI_MODE_ROTATION_IDENTITY;
return S_OK;
}
static void MoveOnScreen(RECT* rect)
{
HMONITOR hMonitor;
MONITORINFO mi;
/* find the nearest monitor ... */
hMonitor = MonitorFromRect(rect, MONITOR_DEFAULTTONEAREST);
/* ... and move it into the work area (ie excluding task bar)*/
mi.cbSize = sizeof(mi);
GetMonitorInfoW(hMonitor, &mi);
ShiftBetween(&rect->left, &rect->right, mi.rcWork.left, mi.rcWork.right);
ShiftBetween(&rect->top, &rect->bottom, mi.rcWork.top, mi.rcWork.bottom);
}
// Callback for EnumDisplayMonitors in createMonitor
//
static BOOL CALLBACK monitorCallback(HMONITOR handle,
HDC dc,
RECT* rect,
LPARAM data)
{
MONITORINFOEXW mi;
ZeroMemory(&mi, sizeof(mi));
mi.cbSize = sizeof(mi);
if (GetMonitorInfoW(handle, (MONITORINFO*) &mi))
{
_GLFWmonitor* monitor = (_GLFWmonitor*) data;
if (wcscmp(mi.szDevice, monitor->win32.adapterName) == 0)
monitor->win32.handle = handle;
}
return TRUE;
}
/***********************************************************************
* GetMonitorInfoA (USER32.@)
*/
BOOL WINAPI GetMonitorInfoA(HMONITOR hMonitor, LPMONITORINFO lpMonitorInfo)
{
MONITORINFOEXW miW;
MONITORINFOEXA *miA = (MONITORINFOEXA*)lpMonitorInfo;
BOOL ret;
miW.cbSize = sizeof(miW);
ret = GetMonitorInfoW(hMonitor, (MONITORINFO*)&miW);
if(!ret) return ret;
miA->rcMonitor = miW.rcMonitor;
miA->rcWork = miW.rcWork;
miA->dwFlags = miW.dwFlags;
if(miA->cbSize >= offsetof(MONITORINFOEXA, szDevice) + sizeof(miA->szDevice))
WideCharToMultiByte(CP_ACP, 0, miW.szDevice, -1, miA->szDevice, sizeof(miA->szDevice), NULL, NULL);
return ret;
}
BOOL GetNearestMonitorSize(HWND hwndOwner, LPRECT lprc)
{
if (GetSystemMetrics(SM_CMONITORS) == 1) {
GetAllMonitorSize(lprc);
}
else {
HMONITOR hmonitor = MonitorFromWindow(hwndOwner, MONITOR_DEFAULTTONEAREST);
MONITORINFO mInfo = {
sizeof(MONITORINFO),
};
if (hmonitor == NULL) {
return FALSE;
}
GetMonitorInfoW(hmonitor, &mInfo);
*lprc = mInfo.rcWork;
}
return TRUE;
}
/* helper callback for MonitorFromRect */
static BOOL CALLBACK monitor_enum( HMONITOR monitor, HDC hdc, LPRECT rect, LPARAM lp )
{
struct monitor_enum_info *info = (struct monitor_enum_info *)lp;
RECT intersect;
if (IntersectRect( &intersect, rect, &info->rect ))
{
/* check for larger intersecting area */
UINT area = (intersect.right - intersect.left) * (intersect.bottom - intersect.top);
if (area > info->max_area)
{
info->max_area = area;
info->ret = monitor;
}
}
else if (!info->max_area) /* if not intersecting, check for min distance */
{
UINT distance;
UINT x, y;
if (info->rect.right <= rect->left) x = rect->left - info->rect.right;
else if (rect->right <= info->rect.left) x = info->rect.left - rect->right;
else x = 0;
if (info->rect.bottom <= rect->top) y = rect->top - info->rect.bottom;
else if (rect->bottom <= info->rect.top) y = info->rect.top - rect->bottom;
else y = 0;
distance = x * x + y * y;
if (distance < info->min_distance)
{
info->min_distance = distance;
info->nearest = monitor;
}
}
if (!info->primary)
{
MONITORINFO mon_info;
mon_info.cbSize = sizeof(mon_info);
GetMonitorInfoW( monitor, &mon_info );
if (mon_info.dwFlags & MONITORINFOF_PRIMARY) info->primary = monitor;
}
return TRUE;
}
static void
get_fullscreen_rect (ClutterStageWin32 *stage_win32)
{
HMONITOR monitor;
MONITORINFO monitor_info;
/* If we already have a window then try to use the same monitor that
is already on */
if (stage_win32->hwnd)
monitor = MonitorFromWindow (stage_win32->hwnd, MONITOR_DEFAULTTONEAREST);
else
{
/* Otherwise just guess that they will want the monitor where
the cursor is */
POINT cursor;
GetCursorPos (&cursor);
monitor = MonitorFromPoint (cursor, MONITOR_DEFAULTTONEAREST);
}
monitor_info.cbSize = sizeof (monitor_info);
GetMonitorInfoW (monitor, &monitor_info);
stage_win32->fullscreen_rect = monitor_info.rcMonitor;
}
/***********************************************************************
*
* WinMain
*/
int WINAPI _tWinMain(HINSTANCE hInstance, HINSTANCE prev, LPTSTR cmdline, int show)
{
MSG msg;
HACCEL hAccel;
WNDCLASSEX wndclass;
HMONITOR monitor;
MONITORINFO info;
INT x, y;
static const TCHAR className[] = _T("NPClass");
static const TCHAR winName[] = _T("Notepad");
UNREFERENCED_PARAMETER(prev);
aFINDMSGSTRING = (ATOM) RegisterWindowMessage(FINDMSGSTRING);
ZeroMemory(&Globals, sizeof(Globals));
Globals.hInstance = hInstance;
LoadSettings();
ZeroMemory(&wndclass, sizeof(wndclass));
wndclass.cbSize = sizeof(wndclass);
wndclass.lpfnWndProc = NOTEPAD_WndProc;
wndclass.hInstance = Globals.hInstance;
wndclass.hIcon = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_NPICON));
wndclass.hCursor = LoadCursor(0, IDC_ARROW);
wndclass.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
wndclass.lpszMenuName = MAKEINTRESOURCE(MAIN_MENU);
wndclass.lpszClassName = className;
wndclass.hIconSm = (HICON)LoadImage(hInstance, MAKEINTRESOURCE(IDI_NPICON),
IMAGE_ICON, 16, 16, 0);
if (!RegisterClassEx(&wndclass)) return FALSE;
/* Setup windows */
monitor = MonitorFromRect( &Globals.main_rect, MONITOR_DEFAULTTOPRIMARY );
info.cbSize = sizeof(info);
GetMonitorInfoW( monitor, &info );
x = Globals.main_rect.left;
y = Globals.main_rect.top;
if (Globals.main_rect.left >= info.rcWork.right ||
Globals.main_rect.top >= info.rcWork.bottom ||
Globals.main_rect.right < info.rcWork.left ||
Globals.main_rect.bottom < info.rcWork.top)
x = y = CW_USEDEFAULT;
Globals.hMainWnd =
CreateWindow(className, winName, WS_OVERLAPPEDWINDOW,
x, y, Globals.main_rect.right - Globals.main_rect.left,
Globals.main_rect.bottom - Globals.main_rect.top,
NULL, NULL, Globals.hInstance, NULL);
if (!Globals.hMainWnd)
{
ShowLastError();
ExitProcess(1);
}
DoCreateEditWindow();
NOTEPAD_InitData();
DIALOG_FileNew();
ShowWindow(Globals.hMainWnd, show);
UpdateWindow(Globals.hMainWnd);
DragAcceptFiles(Globals.hMainWnd, TRUE);
DIALOG_ViewStatusBar();
HandleCommandLine(cmdline);
hAccel = LoadAccelerators( hInstance, MAKEINTRESOURCE(ID_ACCEL) );
while (GetMessage(&msg, 0, 0, 0))
{
if (!IsDialogMessage(Globals.hFindReplaceDlg, &msg) &&
!TranslateAccelerator(Globals.hMainWnd, hAccel, &msg))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
return (int) msg.wParam;
}
/*****
* Internal functions to help with IME window management
*/
static void PaintDefaultIMEWnd(HIMC hIMC, HWND hwnd)
{
PAINTSTRUCT ps;
RECT rect;
HDC hdc;
LPCOMPOSITIONSTRING compstr;
LPBYTE compdata = NULL;
HMONITOR monitor;
MONITORINFO mon_info;
INT offX=0, offY=0;
LPINPUTCONTEXT lpIMC;
lpIMC = LockRealIMC(hIMC);
if (lpIMC == NULL)
return;
hdc = BeginPaint(hwnd,&ps);
GetClientRect(hwnd,&rect);
FillRect(hdc, &rect, (HBRUSH)(COLOR_WINDOW + 1));
compdata = ImmLockIMCC(lpIMC->hCompStr);
compstr = (LPCOMPOSITIONSTRING)compdata;
if (compstr->dwCompStrLen && compstr->dwCompStrOffset)
{
SIZE size;
POINT pt;
HFONT oldfont = NULL;
LPWSTR CompString;
LPIMEPRIVATE myPrivate;
CompString = (LPWSTR)(compdata + compstr->dwCompStrOffset);
myPrivate = ImmLockIMCC(lpIMC->hPrivate);
if (myPrivate->textfont)
oldfont = SelectObject(hdc,myPrivate->textfont);
ImmUnlockIMCC(lpIMC->hPrivate);
GetTextExtentPoint32W(hdc, CompString, compstr->dwCompStrLen, &size);
pt.x = size.cx;
pt.y = size.cy;
LPtoDP(hdc,&pt,1);
/*
* How this works based on tests on windows:
* CFS_POINT: then we start our window at the point and grow it as large
* as it needs to be for the string.
* CFS_RECT: we still use the ptCurrentPos as a starting point and our
* window is only as large as we need for the string, but we do not
* grow such that our window exceeds the given rect. Wrapping if
* needed and possible. If our ptCurrentPos is outside of our rect
* then no window is displayed.
* CFS_FORCE_POSITION: appears to behave just like CFS_POINT
* maybe because the default MSIME does not do any IME adjusting.
*/
if (lpIMC->cfCompForm.dwStyle != CFS_DEFAULT)
{
POINT cpt = lpIMC->cfCompForm.ptCurrentPos;
ClientToScreen(lpIMC->hWnd,&cpt);
rect.left = cpt.x;
rect.top = cpt.y;
rect.right = rect.left + pt.x;
rect.bottom = rect.top + pt.y;
monitor = MonitorFromPoint(cpt, MONITOR_DEFAULTTOPRIMARY);
}
else /* CFS_DEFAULT */
{
/* Windows places the default IME window in the bottom left */
HWND target = lpIMC->hWnd;
if (!target) target = GetFocus();
GetWindowRect(target,&rect);
rect.top = rect.bottom;
rect.right = rect.left + pt.x + 20;
rect.bottom = rect.top + pt.y + 20;
offX=offY=10;
monitor = MonitorFromWindow(target, MONITOR_DEFAULTTOPRIMARY);
}
if (lpIMC->cfCompForm.dwStyle == CFS_RECT)
{
RECT client;
client =lpIMC->cfCompForm.rcArea;
MapWindowPoints( lpIMC->hWnd, 0, (POINT *)&client, 2 );
IntersectRect(&rect,&rect,&client);
/* TODO: Wrap the input if needed */
}
if (lpIMC->cfCompForm.dwStyle == CFS_DEFAULT)
{
/* make sure we are on the desktop */
mon_info.cbSize = sizeof(mon_info);
GetMonitorInfoW(monitor, &mon_info);
if (rect.bottom > mon_info.rcWork.bottom)
{
int shift = rect.bottom - mon_info.rcWork.bottom;
rect.top -= shift;
rect.bottom -= shift;
}
if (rect.left < 0)
{
rect.right -= rect.left;
rect.left = 0;
}
if (rect.right > mon_info.rcWork.right)
{
int shift = rect.right - mon_info.rcWork.right;
rect.left -= shift;
rect.right -= shift;
}
}
SetWindowPos(hwnd, HWND_TOPMOST, rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top, SWP_NOACTIVATE);
TextOutW(hdc, offX,offY, CompString, compstr->dwCompStrLen);
if (oldfont)
SelectObject(hdc,oldfont);
}
ImmUnlockIMCC(lpIMC->hCompStr);
EndPaint(hwnd,&ps);
UnlockRealIMC(hIMC);
}
// ITfEditSession
STDMETHODIMP DoEditSession(TfEditCookie ec)
{
TF_SELECTION tfSelection;
ULONG cFetched = 0;
if(_pContext->GetSelection(ec, TF_DEFAULT_SELECTION, 1, &tfSelection, &cFetched) != S_OK)
{
return E_FAIL;
}
if(cFetched != 1)
{
SafeRelease(&tfSelection.range);
return E_FAIL;
}
RECT rc;
BOOL fClipped;
if(_pContextView->GetTextExt(ec, tfSelection.range, &rc, &fClipped) != S_OK)
{
SafeRelease(&tfSelection.range);
return E_FAIL;
}
//ignore abnormal position (from CUAS ?)
if((rc.top == rc.bottom) && ((rc.right - rc.left) == 1))
{
SafeRelease(&tfSelection.range);
return E_FAIL;
}
POINT pt;
pt.x = rc.left;
pt.y = rc.bottom;
HMONITOR hMonitor = MonitorFromPoint(pt, MONITOR_DEFAULTTONEAREST);
MONITORINFO mi;
mi.cbSize = sizeof(mi);
GetMonitorInfoW(hMonitor, &mi);
RECT rw;
_pInputModeWindow->_GetRect(&rw);
LONG height = rw.bottom - rw.top;
LONG width = rw.right - rw.left;
if(rc.left < mi.rcWork.left)
{
rc.left = mi.rcWork.left;
}
if(mi.rcWork.right < rc.right)
{
rc.left = mi.rcWork.right - width;
}
if(mi.rcWork.bottom < rc.top)
{
rc.bottom = mi.rcWork.bottom - height - IM_MERGIN_Y;
}
else if(mi.rcWork.bottom < (rc.bottom + height + IM_MERGIN_Y))
{
rc.bottom = rc.top - height - IM_MERGIN_Y * 2;
}
if(rc.bottom < mi.rcWork.top)
{
rc.bottom = mi.rcWork.top - IM_MERGIN_Y;
}
_pInputModeWindow->_Move(rc.left, rc.bottom + IM_MERGIN_Y);
_pInputModeWindow->_Show(TRUE);
SafeRelease(&tfSelection.range);
return S_OK;
}
UINT WINAPI
WinPosGetMinMaxInfo(HWND hwnd, POINT* maxSize, POINT* maxPos,
POINT* minTrack, POINT* maxTrack)
{
MINMAXINFO MinMax;
HMONITOR monitor;
INT xinc, yinc;
LONG style = GetWindowLongW( hwnd, GWL_STYLE );
LONG adjustedStyle;
LONG exstyle = GetWindowLongW( hwnd, GWL_EXSTYLE );
RECT rc;
WND *win;
/* Compute default values */
GetWindowRect(hwnd, &rc);
MinMax.ptReserved.x = rc.left;
MinMax.ptReserved.y = rc.top;
if ((style & WS_CAPTION) == WS_CAPTION)
adjustedStyle = style & ~WS_BORDER; /* WS_CAPTION = WS_DLGFRAME | WS_BORDER */
else
adjustedStyle = style;
GetClientRect(GetAncestor(hwnd,GA_PARENT), &rc);
AdjustWindowRectEx(&rc, adjustedStyle, ((style & WS_POPUP) && GetMenu(hwnd)), exstyle);
xinc = -rc.left;
yinc = -rc.top;
MinMax.ptMaxSize.x = rc.right - rc.left;
MinMax.ptMaxSize.y = rc.bottom - rc.top;
if (style & (WS_DLGFRAME | WS_BORDER))
{
MinMax.ptMinTrackSize.x = GetSystemMetrics(SM_CXMINTRACK);
MinMax.ptMinTrackSize.y = GetSystemMetrics(SM_CYMINTRACK);
}
else
{
MinMax.ptMinTrackSize.x = 2 * xinc;
MinMax.ptMinTrackSize.y = 2 * yinc;
}
MinMax.ptMaxTrackSize.x = GetSystemMetrics(SM_CXMAXTRACK);
MinMax.ptMaxTrackSize.y = GetSystemMetrics(SM_CYMAXTRACK);
MinMax.ptMaxPosition.x = -xinc;
MinMax.ptMaxPosition.y = -yinc;
if ((win = ValidateHwnd( hwnd )) )//&& win != WND_DESKTOP && win != WND_OTHER_PROCESS)
{
if (!EMPTYPOINT(win->InternalPos.MaxPos)) MinMax.ptMaxPosition = win->InternalPos.MaxPos;
}
SendMessageW( hwnd, WM_GETMINMAXINFO, 0, (LPARAM)&MinMax );
/* if the app didn't change the values, adapt them for the current monitor */
if ((monitor = MonitorFromWindow( hwnd, MONITOR_DEFAULTTOPRIMARY )))
{
RECT rc_work;
MONITORINFO mon_info;
mon_info.cbSize = sizeof(mon_info);
GetMonitorInfoW( monitor, &mon_info );
rc_work = mon_info.rcMonitor;
if (style & WS_MAXIMIZEBOX)
{
if ((style & WS_CAPTION) == WS_CAPTION || !(style & (WS_CHILD | WS_POPUP)))
rc_work = mon_info.rcWork;
}
if (MinMax.ptMaxSize.x == GetSystemMetrics(SM_CXSCREEN) + 2 * xinc &&
MinMax.ptMaxSize.y == GetSystemMetrics(SM_CYSCREEN) + 2 * yinc)
{
MinMax.ptMaxSize.x = (rc_work.right - rc_work.left) + 2 * xinc;
MinMax.ptMaxSize.y = (rc_work.bottom - rc_work.top) + 2 * yinc;
}
if (MinMax.ptMaxPosition.x == -xinc && MinMax.ptMaxPosition.y == -yinc)
{
MinMax.ptMaxPosition.x = rc_work.left - xinc;
MinMax.ptMaxPosition.y = rc_work.top - yinc;
}
}
/* Some sanity checks */
TRACE("%d %d / %d %d / %d %d / %d %d\n",
MinMax.ptMaxSize.x, MinMax.ptMaxSize.y,
MinMax.ptMaxPosition.x, MinMax.ptMaxPosition.y,
MinMax.ptMaxTrackSize.x, MinMax.ptMaxTrackSize.y,
MinMax.ptMinTrackSize.x, MinMax.ptMinTrackSize.y);
MinMax.ptMaxTrackSize.x = max( MinMax.ptMaxTrackSize.x,
MinMax.ptMinTrackSize.x );
MinMax.ptMaxTrackSize.y = max( MinMax.ptMaxTrackSize.y,
MinMax.ptMinTrackSize.y );
if (maxSize) *maxSize = MinMax.ptMaxSize;
if (maxPos) *maxPos = MinMax.ptMaxPosition;
if (minTrack) *minTrack = MinMax.ptMinTrackSize;
if (maxTrack) *maxTrack = MinMax.ptMaxTrackSize;
return 0; //FIXME: what does it return? Wine returns MINMAXINFO.
}
/***********************************************************************
*
* OSK_DlgInitDialog
*
* Handling of WM_INITDIALOG
*/
int OSK_DlgInitDialog(HWND hDlg)
{
HICON hIcon, hIconSm;
HMONITOR monitor;
MONITORINFO info;
POINT Pt;
RECT rcWindow;
/* Save handle */
Globals.hMainWnd = hDlg;
/* Check the checked menu item before displaying the modal box */
if (Globals.bIsEnhancedKeyboard)
{
/* Enhanced keyboard dialog chosen, set the respective menu item as checked */
CheckMenuItem(GetMenu(hDlg), IDM_ENHANCED_KB, MF_BYCOMMAND | MF_CHECKED);
CheckMenuItem(GetMenu(hDlg), IDM_STANDARD_KB, MF_BYCOMMAND | MF_UNCHECKED);
}
else
{
/* Standard keyboard dialog chosen, set the respective menu item as checked */
CheckMenuItem(GetMenu(hDlg), IDM_STANDARD_KB, MF_BYCOMMAND | MF_CHECKED);
CheckMenuItem(GetMenu(hDlg), IDM_ENHANCED_KB, MF_BYCOMMAND | MF_UNCHECKED);
}
/* Set the application's icon */
hIcon = LoadImageW(Globals.hInstance, MAKEINTRESOURCEW(IDI_OSK), IMAGE_ICON, 0, 0, LR_SHARED | LR_DEFAULTSIZE);
hIconSm = CopyImage(hIcon, IMAGE_ICON, GetSystemMetrics(SM_CXSMICON), GetSystemMetrics(SM_CYSMICON), LR_COPYFROMRESOURCE);
if (hIcon || hIconSm)
{
/* Set the window icons (they are deleted when the process terminates) */
SendMessageW(Globals.hMainWnd, WM_SETICON, ICON_BIG, (LPARAM)hIcon);
SendMessageW(Globals.hMainWnd, WM_SETICON, ICON_SMALL, (LPARAM)hIconSm);
}
/* Get screen info */
memset(&Pt, 0, sizeof(Pt));
monitor = MonitorFromPoint(Pt, MONITOR_DEFAULTTOPRIMARY);
info.cbSize = sizeof(info);
GetMonitorInfoW(monitor, &info);
/* Move the dialog on the bottom of main screen */
GetWindowRect(hDlg, &rcWindow);
MoveWindow(hDlg,
(info.rcMonitor.left + info.rcMonitor.right) / 2 - // Center of screen
(rcWindow.right - rcWindow.left) / 2, // - half size of dialog
info.rcMonitor.bottom - // Bottom of screen
(rcWindow.bottom - rcWindow.top), // - size of window
rcWindow.right - rcWindow.left, // Width
rcWindow.bottom - rcWindow.top, // Height
TRUE);
/* Set icon on visual buttons */
OSK_SetImage(SCAN_CODE_15, IDI_BACK);
OSK_SetImage(SCAN_CODE_16, IDI_TAB);
OSK_SetImage(SCAN_CODE_30, IDI_CAPS_LOCK);
OSK_SetImage(SCAN_CODE_43, IDI_RETURN);
OSK_SetImage(SCAN_CODE_44, IDI_SHIFT);
OSK_SetImage(SCAN_CODE_57, IDI_SHIFT);
OSK_SetImage(SCAN_CODE_127, IDI_REACTOS);
OSK_SetImage(SCAN_CODE_128, IDI_REACTOS);
OSK_SetImage(SCAN_CODE_129, IDI_MENU);
OSK_SetImage(SCAN_CODE_80, IDI_HOME);
OSK_SetImage(SCAN_CODE_85, IDI_PG_UP);
OSK_SetImage(SCAN_CODE_86, IDI_PG_DOWN);
OSK_SetImage(SCAN_CODE_79, IDI_LEFT);
OSK_SetImage(SCAN_CODE_83, IDI_TOP);
OSK_SetImage(SCAN_CODE_84, IDI_BOTTOM);
OSK_SetImage(SCAN_CODE_89, IDI_RIGHT);
/* Create a green brush for leds */
Globals.hBrushGreenLed = CreateSolidBrush(RGB(0, 255, 0));
/* Set a timer for periodics tasks */
Globals.iTimer = SetTimer(hDlg, 0, 200, NULL);
return TRUE;
}
