WC3MouseCapture::WC3MouseCapture(QWidget *parent)
: QWidget(parent), m_icon(QIcon(ICON_NAME), this), m_timer(this), m_menu(this),
m_exitAction(EXIT_ACTION_TITLE, this), m_isDisabled(false) {
// Set up trayicon
m_icon.show();
// Hide widget
//QTimer::singleShot(0, this, SLOT(hide()));
// Set up menu
m_menu.addAction(&m_exitAction);
m_icon.setContextMenu(&m_menu);
// Save default mouse rect
GetClipCursor(&m_defaultRect);
// Connect signals & slots
QObject::connect(&m_timer, SIGNAL(timeout()), this, SLOT(checkActiveWindow()));
QObject::connect(this, SIGNAL(wc3Activated(HWND&)), this, SLOT(captureMouse(HWND&)));
QObject::connect(this, SIGNAL(wc3Deactivated()), this, SLOT(endCapture()));
QObject::connect(&m_exitAction, SIGNAL(activated()), this, SLOT(close()));
// Start the timer
m_timer.start(DEFAULT_TIMEOUT);
// Register hotkey
RegisterHotKey(QWidget::winId(), NULL, NULL, DEFAULT_HOTKEY);
}
//锁定鼠标到某一个范围
void DesignerHook::MouseLock(TControl* Sender)
{
TRect Rect;
SetCaptureControl(Sender);
GetClipCursor(&MouseRect_);
if(NULL == Sender->Parent){
return;
}
Rect= Sender->Parent->ClientRect;
//Rect = Sender->Parent->ClientToScreen(Rect);
TPoint PtTopLeft,PtBottomRight;
PtTopLeft.x = Rect.Left;
PtTopLeft.y = Rect.Top;
PtTopLeft = Sender->Parent->ClientToScreen(PtTopLeft);
Rect.Top= PtTopLeft.y;
Rect.Left= PtTopLeft.x;
PtBottomRight.x = Rect.right;
PtBottomRight.y = Rect.bottom;
PtBottomRight = Sender->Parent->ClientToScreen(PtBottomRight);
Rect.bottom= PtBottomRight.y;
Rect.right= PtBottomRight.x;
ClipCursor(&Rect); //把鼠标锁定在固定区?
}
static void warp_check( SysMouseImpl* This, BOOL force )
{
DWORD now = GetCurrentTime();
const DWORD interval = This->clipped ? 500 : 10;
if (force || (This->need_warp && (now - This->last_warped > interval)))
{
RECT rect, new_rect;
POINT mapped_center;
This->last_warped = now;
This->need_warp = FALSE;
if (!GetClientRect(This->base.win, &rect)) return;
MapWindowPoints( This->base.win, 0, (POINT *)&rect, 2 );
if (!This->clipped)
{
mapped_center.x = (rect.left + rect.right) / 2;
mapped_center.y = (rect.top + rect.bottom) / 2;
TRACE("Warping mouse to %d - %d\n", mapped_center.x, mapped_center.y);
SetCursorPos( mapped_center.x, mapped_center.y );
}
if (This->base.dwCoopLevel & DISCL_EXCLUSIVE)
{
/* make sure we clip even if the window covers the whole screen */
rect.left = max( rect.left, GetSystemMetrics( SM_XVIRTUALSCREEN ) + 1 );
rect.top = max( rect.top, GetSystemMetrics( SM_YVIRTUALSCREEN ) + 1 );
rect.right = min( rect.right, rect.left + GetSystemMetrics( SM_CXVIRTUALSCREEN ) - 2 );
rect.bottom = min( rect.bottom, rect.top + GetSystemMetrics( SM_CYVIRTUALSCREEN ) - 2 );
TRACE("Clipping mouse to %s\n", wine_dbgstr_rect( &rect ));
ClipCursor( &rect );
This->clipped = GetClipCursor( &new_rect ) && EqualRect( &rect, &new_rect );
}
}
}
void FD3D11Viewport::ConditionalResetSwapChain(bool bIgnoreFocus)
{
if(!bIsValid)
{
// Check if the viewport's window is focused before resetting the swap chain's fullscreen state.
HWND FocusWindow = ::GetFocus();
const bool bIsFocused = FocusWindow == WindowHandle;
const bool bIsIconic = !!::IsIconic( WindowHandle );
if(bIgnoreFocus || (bIsFocused && !bIsIconic) )
{
FlushRenderingCommands();
// Store the current cursor clip rectangle as it can be lost when fullscreen is reset.
RECT OriginalCursorRect;
GetClipCursor(&OriginalCursorRect);
HRESULT Result = SwapChain->SetFullscreenState(bIsFullscreen,NULL);
if(SUCCEEDED(Result))
{
ClipCursor(&OriginalCursorRect);
bIsValid = true;
}
else
{
// Even though the docs say SetFullscreenState always returns S_OK, that doesn't always seem to be the case.
UE_LOG(LogD3D11RHI, Log, TEXT("IDXGISwapChain::SetFullscreenState returned %08x; waiting for the next frame to try again."),Result);
}
}
}
}
static int get_clip_cursor (int cli, int clifd, void* buff, size_t len)
{
RECT cliprc;
GetClipCursor (&cliprc);
return ServerSendReply (clifd, &cliprc, sizeof (RECT));
}
static void hugsprim_GetClipCursor_9(HugsStackPtr hugs_root)
{
HsPtr arg1;
HsBool res1;
arg1 = hugs->getPtr();
res1 = GetClipCursor(arg1);
hugs->putBool(res1);
hugs->returnIO(hugs_root,1);
}
static void setdisplaymode(int i)
{
HRESULT rc;
rc = IDirectDraw_SetCooperativeLevel(lpDD,
hwnd, DDSCL_ALLOWMODEX | DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN);
ok(rc==DD_OK,"SetCooperativeLevel returned: %x\n",rc);
if (modes[i].dwFlags & DDSD_PIXELFORMAT)
{
if (modes[i].ddpfPixelFormat.dwFlags & DDPF_RGB)
{
rc = IDirectDraw_SetDisplayMode(lpDD,
modes[i].dwWidth, modes[i].dwHeight,
U1(modes[i].ddpfPixelFormat).dwRGBBitCount);
ok(DD_OK==rc || DDERR_UNSUPPORTED==rc,"SetDisplayMode returned: %x\n",rc);
if (rc == DD_OK)
{
RECT r, scrn, virt;
SetRect(&virt, 0, 0, GetSystemMetrics(SM_CXVIRTUALSCREEN), GetSystemMetrics(SM_CYVIRTUALSCREEN));
OffsetRect(&virt, GetSystemMetrics(SM_XVIRTUALSCREEN), GetSystemMetrics(SM_YVIRTUALSCREEN));
SetRect(&scrn, 0, 0, GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN));
trace("Mode (%dx%d) [%dx%d] (%d %d)x(%d %d)\n", modes[i].dwWidth, modes[i].dwHeight,
scrn.right, scrn.bottom, virt.left, virt.top, virt.right, virt.bottom);
ok(GetClipCursor(&r), "GetClipCursor() failed\n");
/* ddraw sets clip rect here to the screen size, even for
multiple monitors */
ok(EqualRect(&r, &scrn), "Invalid clip rect: (%d %d) x (%d %d)\n",
r.left, r.top, r.right, r.bottom);
ok(ClipCursor(NULL), "ClipCursor() failed\n");
ok(GetClipCursor(&r), "GetClipCursor() failed\n");
ok(EqualRect(&r, &virt), "Invalid clip rect: (%d %d) x (%d %d)\n",
r.left, r.top, r.right, r.bottom);
rc = IDirectDraw_RestoreDisplayMode(lpDD);
ok(DD_OK==rc,"RestoreDisplayMode returned: %x\n",rc);
}
}
}
}
void _releaseInputGrab_() {
#ifdef G3D_WIN32
GetCursorPos(&oldCursorPos);
// Stop hiding the cursor if the application hid it.
oldShowCursorCount = ShowCursor(true) - 1;
if (oldShowCursorCount < -1) {
for (int c = oldShowCursorCount; c < -1; ++c) {
ShowCursor(true);
}
}
// Set the default cursor in case the application
// set the cursor to NULL.
oldCursor = GetCursor();
SetCursor(LoadCursor(NULL, IDC_ARROW));
// Allow the cursor full access to the screen
GetClipCursor(&oldCursorRect);
ClipCursor(NULL);
#elif defined(G3D_LINUX)
#if 0 /* G3DFIX: Disabled to avoid requirement for X11 libraries */
if (x11Display != NULL) {
XUngrabPointer(x11Display, CurrentTime);
XUngrabKeyboard(x11Display, CurrentTime);
if (x11Window != 0) {
//XUndefineCursor(x11Display, x11Window);
// TODO: Note that we leak this cursor; it should be
// freed in the restore code.
Cursor c = XCreateFontCursor(x11Display, 68);
XDefineCursor(x11Display, x11Window, c);
}
XSync(x11Display, false);
XAllowEvents(x11Display, AsyncPointer, CurrentTime);
XFlush(x11Display);
}
#endif
#elif defined(G3D_OSX)
// TODO: OS X
#endif
}
void
WIN_UpdateClipCursor(SDL_Window *window)
{
SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
SDL_Mouse *mouse = SDL_GetMouse();
RECT rect;
if (data->focus_click_pending) {
return;
}
if ((mouse->relative_mode || (window->flags & SDL_WINDOW_INPUT_GRABBED)) &&
(window->flags & SDL_WINDOW_INPUT_FOCUS)) {
if (mouse->relative_mode && !mouse->relative_mode_warp) {
LONG cx, cy;
GetWindowRect(data->hwnd, &rect);
cx = (rect.left + rect.right) / 2;
cy = (rect.top + rect.bottom) / 2;
/* Make an absurdly small clip rect */
rect.left = cx - 1;
rect.right = cx + 1;
rect.top = cy - 1;
rect.bottom = cy + 1;
if (ClipCursor(&rect)) {
data->cursor_clipped_rect = rect;
}
} else {
if (GetClientRect(data->hwnd, &rect) && !IsRectEmpty(&rect)) {
ClientToScreen(data->hwnd, (LPPOINT) & rect);
ClientToScreen(data->hwnd, (LPPOINT) & rect + 1);
if (ClipCursor(&rect)) {
data->cursor_clipped_rect = rect;
}
}
}
} else if (GetClipCursor(&rect) && SDL_memcmp(&rect, &data->cursor_clipped_rect, sizeof(rect)) == 0) {
ClipCursor(NULL);
SDL_zero(data->cursor_clipped_rect);
}
}
//*************************************************************//
// SET CURSOR POSITION
bool InputManager::SetCursorPosition( Point position )
{
// Sanity-check the wrapper's status
assert( m_eStatus == E_INITIALIZED && "InputManager::SetCursorPosition - wrapper has not been initialized" );
if( m_eStatus != E_INITIALIZED )
return false;
// Attempt to move the Windows cursor
POINT cursor = { (LONG)position.x, (LONG)position.y };
ClientToScreen( m_hWnd, &cursor );
BOOL result = SetCursorPos( (int)cursor.x, (int)cursor.y );
if( result == FALSE )
{
// MESSAGE
char szBuffer[ 64 ];
_snprintf_s( szBuffer, 64, _TRUNCATE, "!!! InputManager::SetCursorPosition - failed to set Windows cursor position !!!\n" );
OutputDebugStringA( szBuffer );
return false;
}
// Store updated mouse position
RECT clip = { };
GetCursorPos( &cursor );
ScreenToClient( m_hWnd, &cursor );
GetClipCursor( &clip );
if( clip.left > 0 )
cursor.x -= clip.left;
if( clip.top > 0 )
cursor.y -= clip.top;
m_vCursorMovement = Vector{ (float)cursor.x - m_ptCursor.x, (float)cursor.y - m_ptCursor.y };
m_ptCursor = Point{ (float)cursor.x, (float)cursor.y };
return true;
}
static void setdisplaymode(int i)
{
HRESULT rc;
RECT orig_rect;
SetRect(&orig_rect, 0, 0, GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN));
rc = IDirectDraw_SetCooperativeLevel(lpDD,
hwnd, DDSCL_ALLOWMODEX | DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN);
ok(rc==DD_OK,"SetCooperativeLevel returned: %x\n",rc);
if (modes[i].dwFlags & DDSD_PIXELFORMAT)
{
if (modes[i].ddpfPixelFormat.dwFlags & DDPF_RGB)
{
rc = IDirectDraw_SetDisplayMode(lpDD,
modes[i].dwWidth, modes[i].dwHeight,
U1(modes[i].ddpfPixelFormat).dwRGBBitCount);
ok(DD_OK==rc || DDERR_UNSUPPORTED==rc,"SetDisplayMode returned: %x\n",rc);
if (rc == DD_OK)
{
RECT r, scrn, test, virt;
SetRect(&virt, 0, 0, GetSystemMetrics(SM_CXVIRTUALSCREEN), GetSystemMetrics(SM_CYVIRTUALSCREEN));
OffsetRect(&virt, GetSystemMetrics(SM_XVIRTUALSCREEN), GetSystemMetrics(SM_YVIRTUALSCREEN));
SetRect(&scrn, 0, 0, GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN));
trace("Mode (%dx%d) [%dx%d] (%d %d)x(%d %d)\n", modes[i].dwWidth, modes[i].dwHeight,
scrn.right, scrn.bottom, virt.left, virt.top, virt.right, virt.bottom);
if (!EqualRect(&scrn, &orig_rect))
{
HRESULT rect_result;
/* Check that the client rect was resized */
rc = GetClientRect(hwnd, &test);
ok(rc!=0, "GetClientRect returned %x\n", rc);
rc = EqualRect(&scrn, &test);
todo_wine ok(rc!=0, "Fullscreen window has wrong size\n");
/* Check that switching to normal cooperative level
does not restore the display mode */
rc = IDirectDraw_SetCooperativeLevel(lpDD, hwnd, DDSCL_NORMAL);
ok(rc==DD_OK, "SetCooperativeLevel returned %x\n", rc);
SetRect(&test, 0, 0, GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN));
rect_result = EqualRect(&scrn, &test);
ok(rect_result!=0, "Setting cooperative level to DDSCL_NORMAL changed the display mode\n");
/* Go back to fullscreen */
rc = IDirectDraw_SetCooperativeLevel(lpDD,
hwnd, DDSCL_ALLOWMODEX | DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN);
ok(rc==DD_OK, "SetCooperativeLevel returned: %x\n",rc);
/* If the display mode was changed, set the correct mode
to avoid irrelevant failures */
if (rect_result == 0)
{
rc = IDirectDraw_SetDisplayMode(lpDD,
modes[i].dwWidth, modes[i].dwHeight,
U1(modes[i].ddpfPixelFormat).dwRGBBitCount);
ok(DD_OK==rc, "SetDisplayMode returned: %x\n",rc);
}
}
ok(GetClipCursor(&r), "GetClipCursor() failed\n");
/* ddraw sets clip rect here to the screen size, even for
multiple monitors */
ok(EqualRect(&r, &scrn), "Invalid clip rect: (%d %d) x (%d %d)\n",
r.left, r.top, r.right, r.bottom);
ok(ClipCursor(NULL), "ClipCursor() failed\n");
ok(GetClipCursor(&r), "GetClipCursor() failed\n");
ok(EqualRect(&r, &virt), "Invalid clip rect: (%d %d) x (%d %d)\n",
r.left, r.top, r.right, r.bottom);
rc = IDirectDraw_RestoreDisplayMode(lpDD);
ok(DD_OK==rc,"RestoreDisplayMode returned: %x\n",rc);
}
}
}
}
LRESULT CALLBACK WindowProcedure (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
HMENU hmenu;
RECT rect;
int c;
LRESULT r;
switch (message)
{
case WM_COMMAND:
hmenu = GetMenu(hwnd);
switch (LOWORD(wParam))
{
case IDM_FILE_RESET:
EnterCriticalSection(&cs);
main_reset();
LeaveCriticalSection(&cs);
break;
case IDM_FILE_LSTATE:
EnterCriticalSection(&cs);
if (!getfile(hwnd, "Save State (*.SNP)\0*.SNP\0All files (*.*)\0*.*\0\0", savestate_name))
{
CheckMenuItem(hmenu, IDM_TUBE_6502 + selecttube, MF_UNCHECKED);
CheckMenuItem(hmenu, IDM_MODEL_0 + curmodel, MF_UNCHECKED);
savestate_load();
CheckMenuItem(hmenu, IDM_TUBE_6502 + selecttube, MF_CHECKED);
CheckMenuItem(hmenu, IDM_MODEL_0 + curmodel, MF_CHECKED);
}
main_cleardrawit();
LeaveCriticalSection(&cs);
break;
case IDM_FILE_SSTATE:
EnterCriticalSection(&cs);
if (curtube != -1)
{
log_error("Second processor save states not supported yet.");
}
else
{
if (!getsfile(hwnd, "Save State (*.SNP)\0*.SNP\0All files (*.*)\0*.*\0\0", savestate_name, "SNP"))
savestate_save();
}
main_cleardrawit();
LeaveCriticalSection(&cs);
break;
case IDM_FILE_EXIT:
PostQuitMessage (0); /* send a WM_QUIT to the message queue */
break;
case IDM_DISC_AUTOBOOT:
if (!getfile(hwnd, "Disc image (*.SSD;*.DSD;*.IMG;*.ADF;*.ADL;*.FDI)\0*.SSD;*.DSD;*.IMG;*.ADF;*.ADL;*.FDI\0All files (*.*)\0*.*\0", discfns[0]))
{
doautoboot = 1;
}
break;
case IDM_DISC_LOAD_0:
if (!getfile(hwnd, "Disc image (*.SSD;*.DSD;*.IMG;*.ADF;*.ADL;*.FDI)\0*.SSD;*.DSD;*.IMG;*.ADF;*.ADL;*.FDI\0All files (*.*)\0*.*\0", discfns[0]))
{
disc_close(0);
disc_load(0, discfns[0]);
if (defaultwriteprot) writeprot[0] = 1;
CheckMenuItem(hmenu, IDM_DISC_WPROT_0, (writeprot[0]) ? MF_CHECKED : MF_UNCHECKED);
}
break;
case IDM_DISC_LOAD_1:
if (!getfile(hwnd, "Disc image (*.SSD;*.DSD;*.IMG;*.ADF;*.ADL;*.FDI)\0*.SSD;*.DSD;*.IMG;*.ADF;*.ADL;*.FDI\0All files (*.*)\0*.*\0", discfns[1]))
{
disc_close(1);
disc_load(1, discfns[1]);
if (defaultwriteprot) writeprot[1] = 1;
CheckMenuItem(hmenu, IDM_DISC_WPROT_1, (writeprot[1]) ? MF_CHECKED : MF_UNCHECKED);
}
break;
case IDM_DISC_EJECT_0:
disc_close(0);
discfns[0][0] = 0;
setejecttext(0, "");
break;
case IDM_DISC_EJECT_1:
disc_close(1);
discfns[1][0] = 0;
setejecttext(1, "");
break;
case IDM_DISC_NEW_0:
if (!getsfile(hwnd, "Disc image (*.SSD;*.DSD;*.ADF;*.ADL)\0*.SSD;*.DSD;*.ADF;*.ADL\0All files (*.*)\0*.*\0", discfns[0], "SSD"))
{
disc_close(0);
disc_new(0, discfns[0]);
if (defaultwriteprot) writeprot[0] = 1;
CheckMenuItem(hmenu, IDM_DISC_WPROT_0, (writeprot[0]) ? MF_CHECKED : MF_UNCHECKED);
}
break;
case IDM_DISC_NEW_1:
if (!getsfile(hwnd, "Disc image (*.SSD;*.DSD;*.ADF;*.ADL)\0*.SSD;*.DSD;*.ADF;*.ADL\0All files (*.*)\0*.*\0", discfns[1], "SSD"))
{
disc_close(1);
disc_new(1, discfns[1]);
if (defaultwriteprot) writeprot[1] = 1;
CheckMenuItem(hmenu, IDM_DISC_WPROT_1, (writeprot[1]) ? MF_CHECKED : MF_UNCHECKED);
}
break;
case IDM_DISC_WPROT_0:
writeprot[0] = !writeprot[0];
if (fwriteprot[0]) writeprot[0] = 1;
CheckMenuItem(hmenu, IDM_DISC_WPROT_0, (writeprot[0]) ? MF_CHECKED : MF_UNCHECKED);
break;
case IDM_DISC_WPROT_1:
writeprot[1] = !writeprot[1];
if (fwriteprot[1]) writeprot[1] = 1;
CheckMenuItem(hmenu, IDM_DISC_WPROT_1, (writeprot[1]) ? MF_CHECKED : MF_UNCHECKED);
break;
case IDM_DISC_WPROT_D:
defaultwriteprot = !defaultwriteprot;
CheckMenuItem(hmenu, IDM_DISC_WPROT_D, (defaultwriteprot) ? MF_CHECKED : MF_UNCHECKED);
break;
case IDM_DISC_VDFS_ENABLE:
vdfs_enabled = !vdfs_enabled;
CheckMenuItem(hmenu, IDM_DISC_VDFS_ENABLE, (vdfs_enabled) ? MF_CHECKED : MF_UNCHECKED);
break;
case IDM_DISC_VDFS_ROOT:
strncpy(openfilestring, vdfs_get_root(), MAX_PATH);
if (!getDir(hwnd, "VDFS Root"))
vdfs_set_root(openfilestring);
break;
case IDM_TAPE_LOAD:
if (!getfile(hwnd, "Tape image (*.UEF;*.CSW)\0*.UEF;*.CSW\0All files (*.*)\0*.*\0", tape_fn))
{
tape_close();
tape_load(tape_fn);
tape_loaded = 1;
}
break;
case IDM_TAPE_EJECT:
tape_close();
tape_loaded = 0;
break;
case IDM_TAPE_REWIND:
tape_close();
tape_load(tape_fn);
break;
case IDM_TAPE_CAT:
showcatalogue(hinstance, ghwnd);
break;
case IDM_TAPES_NORMAL: case IDM_TAPES_FAST:
fasttape = LOWORD(wParam) - IDM_TAPES_NORMAL;
CheckMenuItem(hmenu, IDM_TAPES_NORMAL, MF_UNCHECKED);
CheckMenuItem(hmenu, IDM_TAPES_FAST, MF_UNCHECKED);
CheckMenuItem(hmenu, LOWORD(wParam), MF_CHECKED);
break;
case IDM_VIDEO_NOBORDERS: case IDM_VIDEO_MBORDERS: case IDM_VIDEO_FBORDERS:
CheckMenuItem(hmenu, IDM_VIDEO_NOBORDERS + vid_fullborders, MF_UNCHECKED);
vid_fullborders = LOWORD(wParam) - IDM_VIDEO_NOBORDERS;
CheckMenuItem(hmenu, IDM_VIDEO_NOBORDERS + vid_fullborders, MF_CHECKED);
break;
case IDM_VIDEO_FULLSCR:
fullscreen = 1;
EnterCriticalSection(&cs);
video_enterfullscreen();
LeaveCriticalSection(&cs);
break;
case IDM_VIDEO_NULA:
if (nula_disable)
nula_disable = 0;
else
nula_disable = 1;
break;
case IDM_VIDEO_RESIZE:
videoresize = !videoresize;
CheckMenuItem(hmenu, IDM_VIDEO_RESIZE, (videoresize) ? MF_CHECKED : MF_UNCHECKED);
if (videoresize) SetWindowLong(hwnd, GWL_STYLE, WS_OVERLAPPEDWINDOW | WS_VISIBLE);
else SetWindowLong(hwnd, GWL_STYLE, (WS_OVERLAPPEDWINDOW & ~WS_SIZEBOX & ~WS_THICKFRAME & ~WS_MAXIMIZEBOX) | WS_VISIBLE);
GetWindowRect(hwnd, &rect);
SetWindowPos(hwnd, 0, rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top, SWP_NOZORDER | SWP_FRAMECHANGED);
break;
case IDM_VIDEO_SLINEDBL: case IDM_VIDEO_LINEDBL: case IDM_VIDEO_SCANLINES: case IDM_VIDEO_INTERLACED: case IDM_VIDEO_PAL: case IDM_VIDEO_PALI:
CheckMenuItem(hmenu, IDM_VIDEO_SLINEDBL, MF_UNCHECKED);
CheckMenuItem(hmenu, IDM_VIDEO_LINEDBL, MF_UNCHECKED);
CheckMenuItem(hmenu, IDM_VIDEO_SCANLINES, MF_UNCHECKED);
CheckMenuItem(hmenu, IDM_VIDEO_INTERLACED, MF_UNCHECKED);
CheckMenuItem(hmenu, IDM_VIDEO_PAL, MF_UNCHECKED);
CheckMenuItem(hmenu, IDM_VIDEO_PALI, MF_UNCHECKED);
CheckMenuItem(hmenu, LOWORD(wParam), MF_CHECKED);
vid_scanlines = vid_interlace = vid_linedbl = vid_pal = 0;
if (LOWORD(wParam) == IDM_VIDEO_INTERLACED) vid_interlace = 1;
if (LOWORD(wParam) == IDM_VIDEO_SCANLINES) vid_scanlines = 1;
if (LOWORD(wParam) == IDM_VIDEO_SLINEDBL) vid_linedbl = 1;
if (LOWORD(wParam) == IDM_VIDEO_PAL) vid_pal = 1;
if (LOWORD(wParam) == IDM_VIDEO_PALI) vid_interlace = vid_pal = 1;
video_clearscreen();
break;
case IDM_TUBE_NONE: case IDM_TUBE_6502: case IDM_TUBE_Z80: case IDM_TUBE_65816: case IDM_TUBE_32016:
CheckMenuItem(hmenu, IDM_TUBE_NONE, MF_UNCHECKED);
CheckMenuItem(hmenu, IDM_TUBE_6502, MF_UNCHECKED);
CheckMenuItem(hmenu, IDM_TUBE_65816, MF_UNCHECKED);
CheckMenuItem(hmenu, IDM_TUBE_Z80, MF_UNCHECKED);
CheckMenuItem(hmenu, IDM_TUBE_32016, MF_UNCHECKED);
CheckMenuItem(hmenu, LOWORD(wParam), MF_CHECKED);
selecttube = LOWORD(wParam) - IDM_TUBE_6502;
main_restart();
break;
case IDM_TUBES_4: case IDM_TUBES_8: case IDM_TUBES_16: case IDM_TUBES_32: case IDM_TUBES_64:
CheckMenuItem(hmenu, IDM_TUBES_4, MF_UNCHECKED);
CheckMenuItem(hmenu, IDM_TUBES_8, MF_UNCHECKED);
CheckMenuItem(hmenu, IDM_TUBES_16, MF_UNCHECKED);
CheckMenuItem(hmenu, IDM_TUBES_32, MF_UNCHECKED);
CheckMenuItem(hmenu, IDM_TUBES_64, MF_UNCHECKED);
CheckMenuItem(hmenu, LOWORD(wParam), MF_CHECKED);
tube_6502_speed = (LOWORD(wParam) - IDM_TUBES_4) + 1;
tube_updatespeed();
break;
case IDM_SOUND_INTERNAL:
sound_internal = !sound_internal;
CheckMenuItem(hmenu, IDM_SOUND_INTERNAL, (sound_internal) ? MF_CHECKED : MF_UNCHECKED);
break;
case IDM_SOUND_BEEBSID:
sound_beebsid = !sound_beebsid;
CheckMenuItem(hmenu, IDM_SOUND_BEEBSID, (sound_beebsid) ? MF_CHECKED : MF_UNCHECKED);
break;
case IDM_SOUND_MUSIC5000:
sound_music5000 = !sound_music5000;
CheckMenuItem(hmenu, IDM_SOUND_MUSIC5000, (sound_music5000) ? MF_CHECKED : MF_UNCHECKED);
break;
case IDM_SOUND_DAC:
sound_dac = !sound_dac;
CheckMenuItem(hmenu, IDM_SOUND_DAC, (sound_dac) ? MF_CHECKED : MF_UNCHECKED);
break;
case IDM_SOUND_DDNOISE:
sound_ddnoise = !sound_ddnoise;
CheckMenuItem(hmenu, IDM_SOUND_DDNOISE, (sound_ddnoise) ? MF_CHECKED : MF_UNCHECKED);
break;
case IDM_SOUND_TAPE:
sound_tape = !sound_tape;
CheckMenuItem(hmenu, IDM_SOUND_TAPE, (sound_tape) ? MF_CHECKED : MF_UNCHECKED);
break;
case IDM_SOUND_FILTER:
sound_filter = !sound_filter;
CheckMenuItem(hmenu, IDM_SOUND_FILTER, (sound_filter) ? MF_CHECKED : MF_UNCHECKED);
break;
case IDM_WAVE_SQUARE: case IDM_WAVE_SAW: case IDM_WAVE_SINE: case IDM_WAVE_TRI: case IDM_WAVE_SID:
CheckMenuItem(hmenu, IDM_WAVE_SQUARE + curwave, MF_UNCHECKED);
curwave = LOWORD(wParam) - IDM_WAVE_SQUARE;
CheckMenuItem(hmenu, IDM_WAVE_SQUARE + curwave, MF_CHECKED);
break;
case IDM_SID_INTERP: case IDM_SID_RESAMP:
CheckMenuItem(hmenu, IDM_SID_INTERP, MF_UNCHECKED);
CheckMenuItem(hmenu, IDM_SID_RESAMP, MF_UNCHECKED);
CheckMenuItem(hmenu, LOWORD(wParam), MF_CHECKED);
sidmethod = LOWORD(wParam) - IDM_SID_INTERP;
sid_settype(sidmethod, cursid);
break;
case IDM_DDV_33: case IDM_DDV_66: case IDM_DDV_100:
CheckMenuItem(hmenu, (IDM_DDV_33 + ddnoise_vol) - 1, MF_UNCHECKED);
ddnoise_vol = (LOWORD(wParam) - IDM_DDV_33) + 1;
CheckMenuItem(hmenu, (IDM_DDV_33 + ddnoise_vol) - 1, MF_CHECKED);
break;
case IDM_DDT_525: case IDM_DDT_35:
CheckMenuItem(hmenu, IDM_DDT_525 + ddnoise_type, MF_UNCHECKED);
ddnoise_type = LOWORD(wParam) - IDM_DDT_525;
CheckMenuItem(hmenu, IDM_DDT_525 + ddnoise_type, MF_CHECKED);
ddnoise_close();
ddnoise_init();
break;
case IDM_DEBUGGER:
EnterCriticalSection(&cs);
rest(200);
debug_toggle_core();
CheckMenuItem(hmenu, IDM_DEBUGGER, (debug_core) ? MF_CHECKED: MF_UNCHECKED);
LeaveCriticalSection(&cs);
break;
case IDM_DEBUG_TUBE:
EnterCriticalSection(&cs);
rest(200);
debug_toggle_tube();
CheckMenuItem(hmenu, IDM_DEBUG_TUBE, (debug_tube) ? MF_CHECKED: MF_UNCHECKED);
LeaveCriticalSection(&cs);
break;
case IDM_BREAK:
debug_step = 1;
break;
case IDM_SCRSHOT:
if (!getsfile(hwnd, "Bitmap file (*.BMP)\0*.BMP\0All files (*.*)\0*.*\0", vid_scrshotname, "BMP"))
{
vid_savescrshot = 1;
}
break;
case IDM_KEY_REDEFINE:
redefinekeys();
break;
case IDM_KEY_AS:
keyas = !keyas;
CheckMenuItem(hmenu, IDM_KEY_AS, (keyas) ? MF_CHECKED : MF_UNCHECKED);
break;
case IDM_MOUSE_AMX:
mouse_amx = !mouse_amx;
CheckMenuItem(hmenu, IDM_MOUSE_AMX, (mouse_amx) ? MF_CHECKED : MF_UNCHECKED);
main_setmouse();
updatewindowtitle();
break;
case IDM_SCSI_ENABLE:
EnterCriticalSection(&cs);
CheckMenuItem(hmenu, IDM_SCSI_ENABLE, (!scsi_enabled) ? MF_CHECKED : MF_UNCHECKED);
scsi_enabled = !scsi_enabled;
main_restart();
LeaveCriticalSection(&cs);
break;
case IDM_IDE_ENABLE:
EnterCriticalSection(&cs);
CheckMenuItem(hmenu, IDM_IDE_ENABLE, (!ide_enable) ? MF_CHECKED : MF_UNCHECKED);
ide_enable = !ide_enable;
main_restart();
LeaveCriticalSection(&cs);
break;
case IDM_SPD_10: case IDM_SPD_25: case IDM_SPD_50: case IDM_SPD_75: case IDM_SPD_100:
case IDM_SPD_150: case IDM_SPD_200: case IDM_SPD_300: case IDM_SPD_400: case IDM_SPD_500:
CheckMenuItem(hmenu, IDM_SPD_10 + emuspeed, MF_UNCHECKED);
emuspeed = curmodel = LOWORD(wParam) - IDM_SPD_10;
changetimerspeed(timerspeeds[emuspeed]);
vid_fskipmax = frameskips[emuspeed];
CheckMenuItem(hmenu, IDM_SPD_10 + emuspeed, MF_CHECKED);
break;
}
if (LOWORD(wParam) >= IDM_MODEL_0 && LOWORD(wParam) < (IDM_MODEL_0 + 50))
{
CheckMenuItem(hmenu, IDM_MODEL_0 + curmodel, MF_UNCHECKED);
oldmodel = curmodel;
curmodel = LOWORD(wParam) - IDM_MODEL_0;
CheckMenuItem(hmenu, IDM_MODEL_0 + curmodel, MF_CHECKED);
main_restart();
updatewindowtitle();
}
if (LOWORD(wParam) >= IDM_SID_TYPE && LOWORD(wParam) < (IDM_SID_TYPE + 100))
{
CheckMenuItem(hmenu, IDM_SID_TYPE + cursid, MF_UNCHECKED);
cursid = LOWORD(wParam) - IDM_SID_TYPE;
CheckMenuItem(hmenu, IDM_SID_TYPE + cursid, MF_CHECKED);
sid_settype(sidmethod, cursid);
}
return 0;
case WM_USER:
if (videoresize) SetWindowLong(hwnd, GWL_STYLE, WS_OVERLAPPEDWINDOW | WS_VISIBLE);
else SetWindowLong(hwnd, GWL_STYLE, (WS_OVERLAPPEDWINDOW & ~WS_SIZEBOX & ~WS_THICKFRAME & ~WS_MAXIMIZEBOX) | WS_VISIBLE);
GetWindowRect(hwnd, &rect);
SetWindowPos(hwnd, 0, rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top, SWP_NOZORDER | SWP_FRAMECHANGED);
break;
case WM_USER+1:
if (videoresize) SetWindowLong(hwnd, GWL_STYLE, WS_OVERLAPPEDWINDOW & ~WS_VISIBLE);
else SetWindowLong(hwnd, GWL_STYLE, (WS_OVERLAPPEDWINDOW & ~WS_SIZEBOX & ~WS_THICKFRAME & ~WS_MAXIMIZEBOX) & ~WS_VISIBLE);
GetWindowRect(hwnd,&rect);
SetWindowPos(hwnd, 0, rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top, SWP_NOZORDER | SWP_FRAMECHANGED);
break;
case WM_DESTROY:
PostQuitMessage (0); /* send a WM_QUIT to the message queue */
break;
case WM_KILLFOCUS:
// log_debug("KillFocus\n");
// infocus=0;
// spdcount=0;
if (mousecapture)
{
ClipCursor(&oldclip);
mousecapture = 0;
updatewindowtitle();
}
break;
case WM_LBUTTONUP:
if (!mousecapture && (curtube == 3 || mouse_amx))
{
GetClipCursor(&oldclip);
GetWindowRect(hwnd, &newclip);
newclip.left += GetSystemMetrics(SM_CXFIXEDFRAME) + 10;
newclip.right -= GetSystemMetrics(SM_CXFIXEDFRAME) + 10;
newclip.top += GetSystemMetrics(SM_CXFIXEDFRAME) + GetSystemMetrics(SM_CYMENUSIZE) + GetSystemMetrics(SM_CYCAPTION) + 10;
newclip.bottom -= GetSystemMetrics(SM_CXFIXEDFRAME) + 10;
ClipCursor(&newclip);
mousecapture = 1;
updatewindowtitle();
}
break;
case WM_ENTERMENULOOP:
// log_debug("EnterMenuLoop\n");
bempause = 1;
//EnterCriticalSection(&cs);
break;
case WM_EXITMENULOOP:
// log_debug("ExitMenuLoop\n");
bempause = 0;
key_clear();
for (c = 0; c < 128; c++) key[c] = 0;
//LeaveCriticalSection(&cs);
break;
case WM_SETFOCUS:
// log_debug("SetFocus\n");
key_clear();
for (c = 0; c < 128; c++) key[c] = 0;
bempause = 0;
break;
case WM_SIZE:
winsizex = lParam & 0xFFFF;
winsizey = lParam >> 16;
break;
case WM_SYSKEYDOWN:
case WM_KEYDOWN:
if (LOWORD(wParam) != 255)
{
//log_debug("Key %04X %04X\n",LOWORD(wParam),VK_LEFT);
c = MapVirtualKey(LOWORD(wParam),0);
c = hw_to_mycode[c];
// log_debug("MVK %i %i %i\n",c,hw_to_mycode[c],KEY_PGUP);
if (LOWORD(wParam) == VK_LEFT) c = KEY_LEFT;
if (LOWORD(wParam) == VK_RIGHT) c = KEY_RIGHT;
if (LOWORD(wParam) == VK_UP) c = KEY_UP;
if (LOWORD(wParam) == VK_DOWN) c = KEY_DOWN;
if (LOWORD(wParam) == VK_HOME) c = KEY_HOME;
if (LOWORD(wParam) == VK_END) c = KEY_END;
if (LOWORD(wParam) == VK_INSERT) c = KEY_INSERT;
if (LOWORD(wParam) == VK_DELETE) c = KEY_DEL;
if (LOWORD(wParam) == VK_PRIOR) c = KEY_PGUP;
if (LOWORD(wParam) == VK_NEXT) c = KEY_PGDN;
//log_debug("MVK2 %i %i %i\n",c,hw_to_mycode[c],KEY_PGUP);
key[c]=1;
}
break;
case WM_SYSKEYUP:
case WM_KEYUP:
if (LOWORD(wParam) != 255)
{
// log_debug("Key %04X %04X\n",LOWORD(wParam),VK_LEFT);
c = MapVirtualKey(LOWORD(wParam), 0);
c = hw_to_mycode[c];
if (LOWORD(wParam) == VK_LEFT) c = KEY_LEFT;
if (LOWORD(wParam) == VK_RIGHT) c = KEY_RIGHT;
if (LOWORD(wParam) == VK_UP) c = KEY_UP;
if (LOWORD(wParam) == VK_DOWN) c = KEY_DOWN;
if (LOWORD(wParam) == VK_HOME) c = KEY_HOME;
if (LOWORD(wParam) == VK_END) c = KEY_END;
if (LOWORD(wParam) == VK_INSERT) c = KEY_INSERT;
if (LOWORD(wParam) == VK_DELETE) c = KEY_DEL;
if (LOWORD(wParam) == VK_PRIOR) c = KEY_PGUP;
if (LOWORD(wParam) == VK_NEXT) c = KEY_PGDN;
// log_debug("MVK %i\n",c);
key[c] = 0;
}
break;
case WM_CREATE:
// initbbc(argc,argv);
// free(argv);
// mainthread=(HANDLE)_beginthread(_mainthread,0,NULL);
break;
default:
r = DefWindowProc (hwnd, message, wParam, lParam);
return r;
}
return 0;
}
//*************************************************************//
// UPDATE
bool InputManager::Update( void )
{
// Sanity-check the wrapper's status
assert( m_eStatus == E_INITIALIZED && "InputManager::Update - wrapper has not been initialized" );
if( m_eStatus != E_INITIALIZED )
return false;
// Store cursor position
POINT cursor = { };
RECT clip = { };
GetCursorPos( &cursor );
ScreenToClient( m_hWnd, &cursor );
GetClipCursor( &clip );
if( clip.left > 0 )
cursor.x -= clip.left;
if( clip.top > 0 )
cursor.y -= clip.top;
m_vCursorMovement = Vector{ (float)cursor.x - m_ptCursor.x, (float)cursor.y - m_ptCursor.y };
m_ptCursor = Point{ (float)cursor.x, (float)cursor.y };
// Poll keyboard/mouse key states ONLY if window has focus
BYTE keyboard[256] = { };
GetKeyState( 0 );
if( GetForegroundWindow() == m_hWnd )
GetKeyboardState( keyboard );
// Ignore: 0, 7, 10-11, 14-15, 21-26, 28-31, 58-64, 94, 136-143, 146-159, 184-185, 193-218, 224-225, 227-245, 252, 255
#define UPDATE_KEY( key ) m_aKeyboard[ key ] = ((m_aKeyboard[ key ] & Bit_Current) >> 1) | (keyboard[ key ])
#define UPDATE_KEYS( start, stop ) for( int i = start; i <= stop; i++ ) UPDATE_KEY(i);
UPDATE_KEYS( 1, 6 );
UPDATE_KEYS( 8, 9 );
UPDATE_KEYS( 12, 13 );
UPDATE_KEYS( 16, 20 );
UPDATE_KEY( 27 );
UPDATE_KEYS( 32, 57 );
UPDATE_KEYS( 65, 93 );
UPDATE_KEYS( 95, 135 );
UPDATE_KEYS( 144, 145 );
UPDATE_KEYS( 160, 183 );
UPDATE_KEYS( 186, 192 );
UPDATE_KEYS( 219, 223 );
UPDATE_KEY( 226 );
UPDATE_KEYS( 246, 251 );
UPDATE_KEYS( 253, 254 );
#undef UPDATE_KEYS
#undef UPDATE_KEY
// Update gamepads
for( unsigned int i = 0; i < m_vGamepads.size(); i++ )
{
GamepadInfo& info = m_vGamepads[ i ];
// Read device state
DIJOYSTATE state;
HRESULT hResult = info.pDevice->GetDeviceState( sizeof( DIJOYSTATE ), &state );
if( FAILED( hResult ) )
{
hResult = info.pDevice->Acquire();
if( FAILED( hResult ) )
{
info = GamepadInfo{ info.id, info.pDevice, info.wszName, info.bHasTriggerAxis, false };
continue;
}
}
info.bConnected = true;
// Interpret the dpad / point-of-view hat
info.ePreviousDPad = info.eDPad;
DWORD dpad0 = state.rgdwPOV[ 0 ];
if( dpad0 == 0xFFFFFFFF || dpad0 == 0xFFFF )
info.eDPad = DPad::Neutral;
else if( dpad0 < 2250 )
info.eDPad = DPad::Up;
else if( dpad0 < 6750 )
info.eDPad = DPad::UpRight;
else if( dpad0 < 11250 )
info.eDPad = DPad::Right;
else if( dpad0 < 15750 )
info.eDPad = DPad::DownRight;
else if( dpad0 < 20250 )
info.eDPad = DPad::Down;
else if( dpad0 < 24750 )
info.eDPad = DPad::DownLeft;
else if( dpad0 < 29250 )
info.eDPad = DPad::Left;
else if( dpad0 < 33750 )
info.eDPad = DPad::UpLeft;
else if( dpad0 <= 36000 )
info.eDPad = DPad::Up;
else // invalid?
info.eDPad = DPad::Neutral;
// Interpret the buttons
for( int b = 0; b < 32; b++ )
info.aButtons[ b ] = ((info.aButtons[ b ] & Bit_Current) >> 1) | state.rgbButtons[ b ];
// Interpret the joysticks
info.fLeftX = state.lX * 0.001f;
info.fLeftY = state.lY * 0.001f;
if( info.bHasTriggerAxis == true )
{
// Right stick *should* be separate
info.fRightX = state.lRx * 0.001f;
info.fRightY = state.lRy * 0.001f;
info.fTrigger = -state.lZ * 0.001f; // left is negative
}
else
{
// Right stick uses left z ... somehow
info.fRightX = state.lZ * 0.001f;
info.fRightY = state.lRz * 0.001f;
info.fTrigger = 0.0f;
}
}
return true;
}
//*************************************************************//
// INITIALIZE
bool InputManager::Initialize( void )
{
// Sanity-check the wrapper's status
assert( m_eStatus == E_UNINITIALIZED && "InputManager::Initialize - wrapper has already been initialized" );
if( m_eStatus != E_UNINITIALIZED )
return false;
// Validate the thread's window handle
HWND hWnd = GetActiveWindow();
assert( hWnd != nullptr && "InputManager::Initialize - invalid window handle" );
if( hWnd == nullptr )
{
// MESSAGE
char szBuffer[ 64 ];
_snprintf_s( szBuffer, 64, _TRUNCATE, "!!! InputManager::Initialize - invalid window handle !!!\n" );
OutputDebugStringA( szBuffer );
return false;
}
// When using a COM object, the thread should be CoInitialized
CoInitializeEx( nullptr, COINIT_MULTITHREADED );
// Attempt to create the DirectInput8 interface
HRESULT hResult = S_OK;
hResult = DirectInput8Create( (HINSTANCE)GetModuleHandle( nullptr ), DIRECTINPUT_VERSION, IID_IDirectInput8W, (void**)&m_pDirectInput, NULL);
if( FAILED( hResult ) )
{
CoUninitialize();
// MESSAGE
char szBuffer[ 128 ];
_snprintf_s( szBuffer, 128, _TRUNCATE, "!!! InputManager::Initialize - failed to initialize DirectInput (0x%X) !!!\n", hResult );
OutputDebugStringA( szBuffer );
return false;
}
// Store window
m_hWnd = hWnd;
// Store cursor position
POINT cursor = { };
RECT clip = { };
GetCursorPos( &cursor );
ScreenToClient( m_hWnd, &cursor );
GetClipCursor( &clip );
if( clip.left > 0 )
cursor.x -= clip.left;
if( clip.top > 0 )
cursor.y -= clip.top;
m_vCursorMovement = Vector{ 0.0f, 0.0f };
m_ptCursor = Point{ (float)cursor.x, (float)cursor.y };
// Success!
m_eStatus = E_INITIALIZED;
// Check for joysticks
CheckForNewControllers();
return true;
}
/**
* Window procedure to handle events on the main program window
*
* @param hdlg Handle to current program instance
* @param message Event type this window has just received
* @param wParam message specific data
* @param lParam message specific data
* @return
*/
static LRESULT CALLBACK WindowProcedure(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
HMENU hmenu;
switch (message) /* handle the messages */
{
case WM_CREATE:
strcpy(config.isoname, "");
return 0;
case WM_COMMAND:
hmenu=GetMenu(hwnd);
switch (LOWORD(wParam))
{
case IDM_FILE_RESET:
resetrpc();
return 0;
case IDM_FILE_EXIT:
closevideo();
PostQuitMessage(0);
return 0;
case IDM_DISC_LD0:
changedisc(ghwnd,0);
return 0;
case IDM_DISC_LD1:
changedisc(ghwnd,1);
return 0;
case IDM_CONFIG:
DialogBox(hinstance,TEXT("ConfigureDlg"),ghwnd,configdlgproc);
return 0;
case IDM_NETWORKING:
DialogBox(hinstance, TEXT("NetworkDlg"), ghwnd, networkdlgproc);
return 0;
case IDM_FULLSCR:
if (mousecapture)
{
ClipCursor(&oldclip);
mousecapture=0;
}
togglefullscreen(1);
return 0;
case IDM_CPUIDLE:
if (MessageBox(ghwnd, "This will reset RPCEmu!\nOkay to continue?", "RPCEmu", MB_OKCANCEL) == IDOK) {
config.cpu_idle ^= 1;
resetrpc();
CheckMenuItem(hmenu, IDM_CPUIDLE, config.cpu_idle ? MF_CHECKED : MF_UNCHECKED);
}
return 0;
case IDM_CDROM_DISABLED:
if (config.cdromenabled)
{
if (MessageBox(ghwnd, "This will reset RPCEmu!\nOkay to continue?", "RPCEmu", MB_OKCANCEL) == IDOK)
{
config.cdromenabled = 0;
resetrpc();
CheckMenuItem(hmenu, IDM_CDROM_DISABLED + config.cdromtype, MF_UNCHECKED);
config.cdromtype = IDM_CDROM_DISABLED - IDM_CDROM_DISABLED;
CheckMenuItem(hmenu, IDM_CDROM_DISABLED + config.cdromtype, MF_CHECKED);
}
}
return 0;
case IDM_CDROM_EMPTY:
if (!config.cdromenabled)
{
if (MessageBox(ghwnd, "This will reset RPCEmu!\nOkay to continue?", "RPCEmu", MB_OKCANCEL) == IDOK)
{
config.cdromenabled = 1;
resetrpc();
}
else
return 0;
}
atapi->exit();
iso_init();
CheckMenuItem(hmenu, IDM_CDROM_DISABLED + config.cdromtype, MF_UNCHECKED);
config.cdromtype = IDM_CDROM_EMPTY - IDM_CDROM_DISABLED;
CheckMenuItem(hmenu, IDM_CDROM_DISABLED + config.cdromtype, MF_CHECKED);
return 0;
case IDM_CDROM_ISO:
if (selectiso(ghwnd))
{
if (!config.cdromenabled)
{
if (MessageBox(ghwnd, "This will reset RPCEmu!\nOkay to continue?", "RPCEmu", MB_OKCANCEL) == IDOK)
{
config.cdromenabled = 1;
resetrpc();
}
else
return 0;
}
atapi->exit();
iso_open(config.isoname);
}
CheckMenuItem(hmenu, IDM_CDROM_DISABLED + config.cdromtype, MF_UNCHECKED);
config.cdromtype = IDM_CDROM_ISO - IDM_CDROM_DISABLED;
CheckMenuItem(hmenu, IDM_CDROM_DISABLED + config.cdromtype, MF_CHECKED);
return 0;
case IDM_MOUSE_FOL:
CheckMenuItem(hmenu,IDM_MOUSE_FOL,MF_CHECKED);
CheckMenuItem(hmenu,IDM_MOUSE_CAP,MF_UNCHECKED);
config.mousehackon = 1;
if (mousecapture)
{
ClipCursor(&oldclip);
mousecapture=0;
}
return 0;
case IDM_MOUSE_CAP:
CheckMenuItem(hmenu,IDM_MOUSE_FOL,MF_UNCHECKED);
CheckMenuItem(hmenu,IDM_MOUSE_CAP,MF_CHECKED);
config.mousehackon = 0;
return 0;
case IDM_MOUSE_TWOBUTTON:
config.mousetwobutton ^= 1;
CheckMenuItem(hmenu, IDM_MOUSE_TWOBUTTON,
config.mousetwobutton ? MF_CHECKED : MF_UNCHECKED);
return 0;
case IDM_HELP_ONLINE_MANUAL:
launch_url(URL_MANUAL);
return 0;
case IDM_HELP_VISIT_WEBSITE:
launch_url(URL_WEBSITE);
return 0;
case IDM_HELP_ABOUT:
if (!IsWindow(hwnd_about)) {
hwnd_about = CreateDialog(hinstance, MAKEINTRESOURCE(IDD_ABOUT), ghwnd, about_dlg_proc);
window_centre_parent(hwnd_about, ghwnd);
ShowWindow(hwnd_about, SW_SHOW);
}
return 0;
}
if (LOWORD(wParam)>=IDM_CDROM_REAL && LOWORD(wParam)<(IDM_CDROM_REAL+100))
{
if (!config.cdromenabled)
{
if (MessageBox(ghwnd, "This will reset RPCEmu!\nOkay to continue?", "RPCEmu", MB_OKCANCEL) == IDOK)
{
config.cdromenabled = 1;
resetrpc();
}
else
return 0;
}
atapi->exit();
ioctl_open(LOWORD(wParam)-IDM_CDROM_REAL);
CheckMenuItem(hmenu, IDM_CDROM_DISABLED + config.cdromtype, MF_UNCHECKED);
config.cdromtype = LOWORD(wParam) - IDM_CDROM_DISABLED;
CheckMenuItem(hmenu, IDM_CDROM_DISABLED + config.cdromtype, MF_CHECKED);
return 0;
}
break;
case WM_DESTROY:
closevideo();
PostQuitMessage (0); /* send a WM_QUIT to the message queue */
break;
case WM_SETFOCUS:
resetbuffer();
break;
case WM_KILLFOCUS:
if (mousecapture)
{
ClipCursor(&oldclip);
mousecapture=0;
}
break;
case WM_LBUTTONUP:
if (!mousecapture && !fullscreen && !config.mousehackon)
{
RECT arcclip;
GetClipCursor(&oldclip);
GetWindowRect(hwnd,&arcclip);
arcclip.left+=GetSystemMetrics(SM_CXFIXEDFRAME)+10;
arcclip.right-=GetSystemMetrics(SM_CXFIXEDFRAME)+10;
arcclip.top+=GetSystemMetrics(SM_CXFIXEDFRAME)+GetSystemMetrics(SM_CYMENUSIZE)+GetSystemMetrics(SM_CYCAPTION)+10;
arcclip.bottom-=GetSystemMetrics(SM_CXFIXEDFRAME)+10;
ClipCursor(&arcclip);
mousecapture=1;
updatemips=1;
}
break;
default: /* for messages that we don't deal with */
return DefWindowProc (hwnd, message, wParam, lParam);
}
return 0;
}
BOOL jcwin32::jcwin32_getClipCursor(RECT* lpRect)
{
return GetClipCursor(lpRect);
}
