//鼠标消息
VOID CPasswordKeyboard::OnLButtonUp(UINT nFlags, CPoint Point)
{
__super::OnLButtonUp(nFlags,Point);
//取消捕获
if (m_bMouseDown==true)
{
//取消捕获
ReleaseCapture();
//设置变量
m_bMouseDown=false;
//获取光标
CPoint MousePoint;
GetCursorPos(&MousePoint);
ScreenToClient(&MousePoint);
//更新位置
WORD wHoverRow=m_wHoverRow;
WORD wHoverLine=m_wHoverLine;
SetCurrentStation(MousePoint);
//点击处理
if ((m_wHoverRow==wHoverRow)&&(m_wHoverLine==wHoverLine))
{
//关闭按钮
if ((m_wHoverLine==LINE_FUNCTION)&&(m_wHoverRow==ROW_CLOSE_KEY))
{
//设置焦点
CONTAINING_RECORD(this,CPasswordControl,m_PasswordKeyboard)->m_edPassword.SetFocus();
//销毁窗口
DestroyWindow();
return;
}
//虚拟编码
WORD wViraulCode=GetVirualKeyCode(m_wHoverLine,m_wHoverRow);
//按钮处理
switch (wViraulCode)
{
case VK_SHIFT: //切换按钮
{
//设置变量
m_bShiftStatus=!m_bShiftStatus;
break;
}
case VK_CAPITAL: //大写按钮
{
//变量定义
INPUT Input[2];
ZeroMemory(Input,sizeof(Input));
//设置变量
Input[1].ki.dwFlags=KEYEVENTF_KEYUP;
Input[0].type=Input[1].type=INPUT_KEYBOARD;
Input[0].ki.wVk=Input[1].ki.wVk=wViraulCode;
//模拟输入
SendInput(CountArray(Input),Input,sizeof(INPUT));
break;
}
default: //默认按钮
{
//设置变量
m_bShiftStatus=(GetKeyState(VK_SHIFT)&0xF0)>0;
//发送消息
CPasswordControl * pPasswordControl=CONTAINING_RECORD(this,CPasswordControl,m_PasswordKeyboard);
if (pPasswordControl!=NULL) pPasswordControl->m_edPassword.SendMessage(WM_CHAR,wViraulCode,0L);
break;
}
}
}
//更新界面
RedrawWindow(NULL,NULL,RDW_FRAME|RDW_ERASE|RDW_INVALIDATE|RDW_UPDATENOW|RDW_ERASENOW);
}
return;
}
LRESULT CALLBACK
winWindowProc (HWND hwnd, UINT message,
WPARAM wParam, LPARAM lParam)
{
static winPrivScreenPtr s_pScreenPriv = NULL;
static winScreenInfo *s_pScreenInfo = NULL;
static ScreenPtr s_pScreen = NULL;
static HWND s_hwndLastPrivates = NULL;
static HINSTANCE s_hInstance;
static Bool s_fTracking = FALSE;
static unsigned long s_ulServerGeneration = 0;
static UINT s_uTaskbarRestart = 0;
int iScanCode;
int i;
#if CYGDEBUG
winDebugWin32Message("winWindowProc", hwnd, message, wParam, lParam);
#endif
/* Watch for server regeneration */
if (g_ulServerGeneration != s_ulServerGeneration)
{
/* Store new server generation */
s_ulServerGeneration = g_ulServerGeneration;
}
/* Only retrieve new privates pointers if window handle is null or changed */
if ((s_pScreenPriv == NULL || hwnd != s_hwndLastPrivates)
&& (s_pScreenPriv = GetProp (hwnd, WIN_SCR_PROP)) != NULL)
{
#if CYGDEBUG
winDebug ("winWindowProc - Setting privates handle\n");
#endif
s_pScreenInfo = s_pScreenPriv->pScreenInfo;
s_pScreen = s_pScreenInfo->pScreen;
s_hwndLastPrivates = hwnd;
}
else if (s_pScreenPriv == NULL)
{
/* For safety, handle case that should never happen */
s_pScreenInfo = NULL;
s_pScreen = NULL;
s_hwndLastPrivates = NULL;
}
/* Branch on message type */
switch (message)
{
case WM_TRAYICON:
return winHandleIconMessage (hwnd, message, wParam, lParam,
s_pScreenPriv);
case WM_CREATE:
#if CYGDEBUG
winDebug ("winWindowProc - WM_CREATE\n");
#endif
/*
* Add a property to our display window that references
* this screens' privates.
*
* This allows the window procedure to refer to the
* appropriate window DC and shadow DC for the window that
* it is processing. We use this to repaint exposed
* areas of our display window.
*/
s_pScreenPriv = ((LPCREATESTRUCT) lParam)->lpCreateParams;
s_hInstance = ((LPCREATESTRUCT) lParam)->hInstance;
s_pScreenInfo = s_pScreenPriv->pScreenInfo;
s_pScreen = s_pScreenInfo->pScreen;
s_hwndLastPrivates = hwnd;
s_uTaskbarRestart = RegisterWindowMessage(TEXT("TaskbarCreated"));
SetProp (hwnd, WIN_SCR_PROP, s_pScreenPriv);
/* Setup tray icon */
if (!s_pScreenInfo->fNoTrayIcon)
{
/*
* NOTE: The WM_CREATE message is processed before CreateWindowEx
* returns, so s_pScreenPriv->hwndScreen is invalid at this point.
* We go ahead and copy our hwnd parameter over top of the screen
* privates hwndScreen so that we have a valid value for
* that member. Otherwise, the tray icon will disappear
* the first time you move the mouse over top of it.
*/
s_pScreenPriv->hwndScreen = hwnd;
winInitNotifyIcon (s_pScreenPriv);
}
return 0;
case WM_DISPLAYCHANGE:
/*
WM_DISPLAYCHANGE seems to be sent when the monitor layout or
any monitor's resolution or depth changes, but it's lParam and
wParam always indicate the resolution and bpp for the primary
monitor (so ignore that as we could be on any monitor...)
*/
/* We cannot handle a display mode change during initialization */
if (s_pScreenInfo == NULL)
FatalError ("winWindowProc - WM_DISPLAYCHANGE - The display "
"mode changed while we were intializing. This is "
"very bad and unexpected. Exiting.\n");
/*
* We do not care about display changes with
* fullscreen DirectDraw engines, because those engines set
* their own mode when they become active.
*/
if (s_pScreenInfo->fFullScreen
&& (s_pScreenInfo->dwEngine == WIN_SERVER_SHADOW_DD
|| s_pScreenInfo->dwEngine == WIN_SERVER_SHADOW_DDNL
#ifdef XWIN_PRIMARYFB
|| s_pScreenInfo->dwEngine == WIN_SERVER_PRIMARY_DD
#endif
))
{
break;
}
ErrorF ("winWindowProc - WM_DISPLAYCHANGE - new width: %d "
"new height: %d new bpp: %d\n",
LOWORD (lParam), HIWORD (lParam), wParam);
/* 0 bpp has no defined meaning, ignore this message */
if (wParam == 0)
break;
/*
* Check for a disruptive change in depth.
* We can only display a message for a disruptive depth change,
* we cannot do anything to correct the situation.
*/
/*
XXX: maybe we need to check if GetSystemMetrics(SM_SAMEDISPLAYFORMAT)
has changed as well...
*/
if (s_pScreenInfo->dwBPP != GetDeviceCaps (s_pScreenPriv->hdcScreen, BITSPIXEL))
{
if ((s_pScreenInfo->dwEngine == WIN_SERVER_SHADOW_DD
|| s_pScreenInfo->dwEngine == WIN_SERVER_SHADOW_DDNL
#ifdef XWIN_PRIMARYFB
|| s_pScreenInfo->dwEngine == WIN_SERVER_PRIMARY_DD
#endif
))
{
/* Cannot display the visual until the depth is restored */
ErrorF ("winWindowProc - Disruptive change in depth\n");
/* Display depth change dialog */
winDisplayDepthChangeDialog (s_pScreenPriv);
/* Flag that we have an invalid screen depth */
s_pScreenPriv->fBadDepth = TRUE;
/* Minimize the display window */
ShowWindow (hwnd, SW_MINIMIZE);
}
else
{
/* For GDI, performance may suffer until original depth is restored */
ErrorF ("winWindowProc - Performance may be non-optimal after change in depth\n");
}
}
else
{
/* Flag that we have a valid screen depth */
s_pScreenPriv->fBadDepth = FALSE;
}
/*
If we could cheaply check if this WM_DISPLAYCHANGE change
affects the monitor(s) which this X screen is displayed on
then we should do so here. For the moment, assume it does.
(this is probably usually the case so that might be an
overoptimization)
*/
{
/*
In rootless modes which are monitor or virtual desktop size
use RandR to resize the X screen
*/
if ((!s_pScreenInfo->fUserGaveHeightAndWidth) &&
(s_pScreenInfo->iResizeMode == resizeWithRandr) &&
(FALSE
#ifdef XWIN_MULTIWINDOWEXTWM
|| s_pScreenInfo->fMWExtWM
#endif
|| s_pScreenInfo->fRootless
#ifdef XWIN_MULTIWINDOW
|| s_pScreenInfo->fMultiWindow
#endif
))
{
DWORD dwWidth, dwHeight;
if (s_pScreenInfo->fMultipleMonitors)
{
/* resize to new virtual desktop size */
dwWidth = GetSystemMetrics(SM_CXVIRTUALSCREEN);
dwHeight = GetSystemMetrics(SM_CYVIRTUALSCREEN);
}
else
{
/* resize to new size of specified monitor */
struct GetMonitorInfoData data;
if (QueryMonitor(s_pScreenInfo->iMonitor, &data))
{
if (data.bMonitorSpecifiedExists == TRUE)
{
dwWidth = data.monitorWidth;
dwHeight = data.monitorHeight;
/*
XXX: monitor may have changed position,
so we might need to update xinerama data
*/
}
else
{
ErrorF ("Monitor number %d no longer exists!\n", s_pScreenInfo->iMonitor);
}
}
}
/*
XXX: probably a small bug here: we don't compute the work area
and allow for task bar
XXX: generally, we don't allow for the task bar being moved after
the server is started
*/
/* Set screen size to match new size, if it is different to current */
if ((s_pScreenInfo->dwWidth != dwWidth) ||
(s_pScreenInfo->dwHeight != dwHeight))
{
winDoRandRScreenSetSize(s_pScreen,
dwWidth,
dwHeight,
(dwWidth * 25.4) / monitorResolution,
(dwHeight * 25.4) / monitorResolution);
}
}
else
{
/*
* We can simply recreate the same-sized primary surface when
* the display dimensions change.
*/
/*
* NOTE: The non-DirectDraw engines set the ReleasePrimarySurface
* and CreatePrimarySurface function pointers to point
* to the no operation function, NoopDDA. This allows us
* to blindly call these functions, even if they are not
* relevant to the current engine (e.g., Shadow GDI).
*/
winDebug ("winWindowProc - WM_DISPLAYCHANGE - Releasing and recreating primary surface\n");
/* Release the old primary surface */
(*s_pScreenPriv->pwinReleasePrimarySurface) (s_pScreen);
/* Create the new primary surface */
(*s_pScreenPriv->pwinCreatePrimarySurface) (s_pScreen);
}
}
break;
case WM_SIZE:
{
SCROLLINFO si;
RECT rcWindow;
int iWidth, iHeight;
#if CYGDEBUG
winDebug ("winWindowProc - WM_SIZE\n");
#endif
/* Break if we do not allow resizing */
if ((s_pScreenInfo->iResizeMode == notAllowed)
|| !s_pScreenInfo->fDecoration
#ifdef XWIN_MULTIWINDOWEXTWM
|| s_pScreenInfo->fMWExtWM
#endif
|| s_pScreenInfo->fRootless
#ifdef XWIN_MULTIWINDOW
|| s_pScreenInfo->fMultiWindow
#endif
|| s_pScreenInfo->fFullScreen)
break;
/* No need to resize if we get minimized */
if (wParam == SIZE_MINIMIZED)
return 0;
ErrorF ("winWindowProc - WM_SIZE - new client area w: %d h: %d\n",
LOWORD (lParam), HIWORD (lParam));
if (s_pScreenInfo->iResizeMode == resizeWithRandr)
{
/* Actual resizing is done on WM_EXITSIZEMOVE */
return 0;
}
/* Otherwise iResizeMode == resizeWithScrollbars */
/*
* Get the size of the whole window, including client area,
* scrollbars, and non-client area decorations (caption, borders).
* We do this because we need to check if the client area
* without scrollbars is large enough to display the whole visual.
* The new client area size passed by lParam already subtracts
* the size of the scrollbars if they are currently displayed.
* So checking is LOWORD(lParam) == visual_width and
* HIWORD(lParam) == visual_height will never tell us to hide
* the scrollbars because the client area would always be too small.
* GetClientRect returns the same sizes given by lParam, so we
* cannot use GetClientRect either.
*/
GetWindowRect (hwnd, &rcWindow);
iWidth = rcWindow.right - rcWindow.left;
iHeight = rcWindow.bottom - rcWindow.top;
/* Subtract the frame size from the window size. */
iWidth -= 2 * GetSystemMetrics (SM_CXSIZEFRAME);
iHeight -= (2 * GetSystemMetrics (SM_CYSIZEFRAME)
+ GetSystemMetrics (SM_CYCAPTION));
/*
* Update scrollbar page sizes.
* NOTE: If page size == range, then the scrollbar is
* automatically hidden.
*/
/* Is the naked client area large enough to show the whole visual? */
if (iWidth < s_pScreenInfo->dwWidth
|| iHeight < s_pScreenInfo->dwHeight)
{
/* Client area too small to display visual, use scrollbars */
iWidth -= GetSystemMetrics (SM_CXVSCROLL);
iHeight -= GetSystemMetrics (SM_CYHSCROLL);
}
/* Set the horizontal scrollbar page size */
si.cbSize = sizeof (si);
si.fMask = SIF_PAGE | SIF_RANGE;
si.nMin = 0;
si.nMax = s_pScreenInfo->dwWidth - 1;
si.nPage = iWidth;
SetScrollInfo (hwnd, SB_HORZ, &si, TRUE);
/* Set the vertical scrollbar page size */
si.cbSize = sizeof (si);
si.fMask = SIF_PAGE | SIF_RANGE;
si.nMin = 0;
si.nMax = s_pScreenInfo->dwHeight - 1;
si.nPage = iHeight;
SetScrollInfo (hwnd, SB_VERT, &si, TRUE);
/*
* NOTE: Scrollbars may have moved if they were at the
* far right/bottom, so we query their current position.
*/
/* Get the horizontal scrollbar position and set the offset */
si.cbSize = sizeof (si);
si.fMask = SIF_POS;
GetScrollInfo (hwnd, SB_HORZ, &si);
s_pScreenInfo->dwXOffset = -si.nPos;
/* Get the vertical scrollbar position and set the offset */
si.cbSize = sizeof (si);
si.fMask = SIF_POS;
GetScrollInfo (hwnd, SB_VERT, &si);
s_pScreenInfo->dwYOffset = -si.nPos;
}
return 0;
case WM_ENTERSIZEMOVE:
ErrorF("winWindowProc - WM_ENTERSIZEMOVE\n");
break;
case WM_EXITSIZEMOVE:
ErrorF("winWindowProc - WM_EXITSIZEMOVE\n");
if (s_pScreenInfo->iResizeMode == resizeWithRandr)
{
/* Set screen size to match new client area, if it is different to current */
RECT rcClient;
DWORD dwWidth, dwHeight;
GetClientRect (hwnd, &rcClient);
dwWidth = rcClient.right - rcClient.left;
dwHeight = rcClient.bottom - rcClient.top;
if ((s_pScreenInfo->dwWidth != dwWidth) ||
(s_pScreenInfo->dwHeight != dwHeight))
{
/* mm = dots * (25.4 mm / inch) / (dots / inch) */
winDoRandRScreenSetSize(s_pScreen,
dwWidth,
dwHeight,
(dwWidth * 25.4) / monitorResolution,
(dwHeight * 25.4) / monitorResolution);
}
}
break;
case WM_VSCROLL:
{
SCROLLINFO si;
int iVertPos;
#if CYGDEBUG
winDebug ("winWindowProc - WM_VSCROLL\n");
#endif
/* Get vertical scroll bar info */
si.cbSize = sizeof (si);
si.fMask = SIF_ALL;
GetScrollInfo (hwnd, SB_VERT, &si);
/* Save the vertical position for comparison later */
iVertPos = si.nPos;
/*
* Don't forget:
* moving the scrollbar to the DOWN, scroll the content UP
*/
switch (LOWORD(wParam))
{
case SB_TOP:
si.nPos = si.nMin;
break;
case SB_BOTTOM:
si.nPos = si.nMax - si.nPage + 1;
break;
case SB_LINEUP:
si.nPos -= 1;
break;
case SB_LINEDOWN:
si.nPos += 1;
break;
case SB_PAGEUP:
si.nPos -= si.nPage;
break;
case SB_PAGEDOWN:
si.nPos += si.nPage;
break;
case SB_THUMBTRACK:
si.nPos = si.nTrackPos;
break;
default:
break;
}
/*
* We retrieve the position after setting it,
* because Windows may adjust it.
*/
si.fMask = SIF_POS;
SetScrollInfo (hwnd, SB_VERT, &si, TRUE);
GetScrollInfo (hwnd, SB_VERT, &si);
/* Scroll the window if the position has changed */
if (si.nPos != iVertPos)
{
/* Save the new offset for bit block transfers, etc. */
s_pScreenInfo->dwYOffset = -si.nPos;
/* Change displayed region in the window */
ScrollWindowEx (hwnd,
0,
iVertPos - si.nPos,
NULL,
NULL,
NULL,
NULL,
SW_INVALIDATE);
/* Redraw the window contents */
UpdateWindow (hwnd);
}
}
return 0;
case WM_HSCROLL:
{
SCROLLINFO si;
int iHorzPos;
#if CYGDEBUG
winDebug ("winWindowProc - WM_HSCROLL\n");
#endif
/* Get horizontal scroll bar info */
si.cbSize = sizeof (si);
si.fMask = SIF_ALL;
GetScrollInfo (hwnd, SB_HORZ, &si);
/* Save the horizontal position for comparison later */
iHorzPos = si.nPos;
/*
* Don't forget:
* moving the scrollbar to the RIGHT, scroll the content LEFT
*/
switch (LOWORD(wParam))
{
case SB_LEFT:
si.nPos = si.nMin;
break;
case SB_RIGHT:
si.nPos = si.nMax - si.nPage + 1;
break;
case SB_LINELEFT:
si.nPos -= 1;
break;
case SB_LINERIGHT:
si.nPos += 1;
break;
case SB_PAGELEFT:
si.nPos -= si.nPage;
break;
case SB_PAGERIGHT:
si.nPos += si.nPage;
break;
case SB_THUMBTRACK:
si.nPos = si.nTrackPos;
break;
default:
break;
}
/*
* We retrieve the position after setting it,
* because Windows may adjust it.
*/
si.fMask = SIF_POS;
SetScrollInfo (hwnd, SB_HORZ, &si, TRUE);
GetScrollInfo (hwnd, SB_HORZ, &si);
/* Scroll the window if the position has changed */
if (si.nPos != iHorzPos)
{
/* Save the new offset for bit block transfers, etc. */
s_pScreenInfo->dwXOffset = -si.nPos;
/* Change displayed region in the window */
ScrollWindowEx (hwnd,
iHorzPos - si.nPos,
0,
NULL,
NULL,
NULL,
NULL,
SW_INVALIDATE);
/* Redraw the window contents */
UpdateWindow (hwnd);
}
}
return 0;
case WM_GETMINMAXINFO:
{
MINMAXINFO *pMinMaxInfo = (MINMAXINFO *) lParam;
int iCaptionHeight;
int iBorderHeight, iBorderWidth;
#if CYGDEBUG
winDebug ("winWindowProc - WM_GETMINMAXINFO - pScreenInfo: %08x\n",
s_pScreenInfo);
#endif
/* Can't do anything without screen info */
if (s_pScreenInfo == NULL
|| (s_pScreenInfo->iResizeMode != resizeWithScrollbars)
|| s_pScreenInfo->fFullScreen
|| !s_pScreenInfo->fDecoration
#ifdef XWIN_MULTIWINDOWEXTWM
|| s_pScreenInfo->fMWExtWM
#endif
|| s_pScreenInfo->fRootless
#ifdef XWIN_MULTIWINDOW
|| s_pScreenInfo->fMultiWindow
#endif
)
break;
/*
* Here we can override the maximum tracking size, which
* is the largest size that can be assigned to our window
* via the sizing border.
*/
/*
* FIXME: Do we only need to do this once, since our visual size
* does not change? Does Windows store this value statically
* once we have set it once?
*/
/* Get the border and caption sizes */
iCaptionHeight = GetSystemMetrics (SM_CYCAPTION);
iBorderWidth = 2 * GetSystemMetrics (SM_CXSIZEFRAME);
iBorderHeight = 2 * GetSystemMetrics (SM_CYSIZEFRAME);
/* Allow the full visual to be displayed */
pMinMaxInfo->ptMaxTrackSize.x
= s_pScreenInfo->dwWidth + iBorderWidth;
pMinMaxInfo->ptMaxTrackSize.y
= s_pScreenInfo->dwHeight + iBorderHeight + iCaptionHeight;
}
return 0;
case WM_ERASEBKGND:
#if CYGDEBUG
winDebug ("winWindowProc - WM_ERASEBKGND\n");
#endif
/*
* Pretend that we did erase the background but we don't care,
* the application uses the full window estate. This avoids some
* flickering when resizing.
*/
return TRUE;
case WM_PAINT:
#if CYGDEBUG
winDebug ("winWindowProc - WM_PAINT\n");
#endif
/* Only paint if we have privates and the server is enabled */
if (s_pScreenPriv == NULL
|| !s_pScreenPriv->fEnabled
|| (s_pScreenInfo->fFullScreen && !s_pScreenPriv->fActive)
|| s_pScreenPriv->fBadDepth)
{
/* We don't want to paint */
break;
}
/* Break out here if we don't have a valid paint routine */
if (s_pScreenPriv->pwinBltExposedRegions == NULL)
break;
/* Call the engine dependent repainter */
(*s_pScreenPriv->pwinBltExposedRegions) (s_pScreen);
return 0;
case WM_PALETTECHANGED:
{
#if CYGDEBUG
winDebug ("winWindowProc - WM_PALETTECHANGED\n");
#endif
/*
* Don't process if we don't have privates or a colormap,
* or if we have an invalid depth.
*/
if (s_pScreenPriv == NULL
|| s_pScreenPriv->pcmapInstalled == NULL
|| s_pScreenPriv->fBadDepth)
break;
/* Return if we caused the palette to change */
if ((HWND) wParam == hwnd)
{
/* Redraw the screen */
(*s_pScreenPriv->pwinRedrawScreen) (s_pScreen);
return 0;
}
/* Reinstall the windows palette */
(*s_pScreenPriv->pwinRealizeInstalledPalette) (s_pScreen);
/* Redraw the screen */
(*s_pScreenPriv->pwinRedrawScreen) (s_pScreen);
return 0;
}
case WM_MOUSEMOVE:
/* We can't do anything without privates */
if (s_pScreenPriv == NULL || s_pScreenInfo->fIgnoreInput)
break;
/* We can't do anything without g_pwinPointer */
if (g_pwinPointer == NULL)
break;
/* Has the mouse pointer crossed screens? */
if (s_pScreen != miPointerGetScreen(g_pwinPointer))
miPointerSetScreen (g_pwinPointer, s_pScreenInfo->dwScreen,
GET_X_LPARAM(lParam)-s_pScreenInfo->dwXOffset,
GET_Y_LPARAM(lParam)-s_pScreenInfo->dwYOffset);
/* Are we tracking yet? */
if (!s_fTracking)
{
TRACKMOUSEEVENT tme;
/* Setup data structure */
ZeroMemory (&tme, sizeof (tme));
tme.cbSize = sizeof (tme);
tme.dwFlags = TME_LEAVE;
tme.hwndTrack = hwnd;
/* Call the tracking function */
if (!TrackMouseEvent(&tme))
ErrorF ("winWindowProc - TrackMouseEvent failed\n");
/* Flag that we are tracking now */
s_fTracking = TRUE;
}
/* Hide or show the Windows mouse cursor */
if (g_fSoftwareCursor && g_fCursor && (s_pScreenPriv->fActive || s_pScreenInfo->fLessPointer))
{
/* Hide Windows cursor */
g_fCursor = FALSE;
ShowCursor (FALSE);
}
else if (g_fSoftwareCursor && !g_fCursor && !s_pScreenPriv->fActive
&& !s_pScreenInfo->fLessPointer)
{
/* Show Windows cursor */
g_fCursor = TRUE;
ShowCursor (TRUE);
}
/* Deliver absolute cursor position to X Server */
winEnqueueMotion(GET_X_LPARAM(lParam)-s_pScreenInfo->dwXOffset,
GET_Y_LPARAM(lParam)-s_pScreenInfo->dwYOffset);
return 0;
case WM_NCMOUSEMOVE:
/*
* We break instead of returning 0 since we need to call
* DefWindowProc to get the mouse cursor changes
* and min/max/close button highlighting in Windows XP.
* The Platform SDK says that you should return 0 if you
* process this message, but it fails to mention that you
* will give up any default functionality if you do return 0.
*/
/* We can't do anything without privates */
if (s_pScreenPriv == NULL || s_pScreenInfo->fIgnoreInput)
break;
/* Non-client mouse movement, show Windows cursor */
if (g_fSoftwareCursor && !g_fCursor)
{
g_fCursor = TRUE;
ShowCursor (TRUE);
}
break;
case WM_MOUSELEAVE:
/* Mouse has left our client area */
/* Flag that we are no longer tracking */
s_fTracking = FALSE;
/* Show the mouse cursor, if necessary */
if (g_fSoftwareCursor && !g_fCursor)
{
g_fCursor = TRUE;
ShowCursor (TRUE);
}
return 0;
case WM_LBUTTONDBLCLK:
case WM_LBUTTONDOWN:
if (s_pScreenPriv == NULL || s_pScreenInfo->fIgnoreInput)
break;
if (s_pScreenInfo->fRootless
#ifdef XWIN_MULTIWINDOWEXTWM
|| s_pScreenInfo->fMWExtWM
#endif
)
SetCapture (hwnd);
return winMouseButtonsHandle (s_pScreen, ButtonPress, Button1, wParam);
case WM_LBUTTONUP:
if (s_pScreenPriv == NULL || s_pScreenInfo->fIgnoreInput)
break;
if (s_pScreenInfo->fRootless
#ifdef XWIN_MULTIWINDOWEXTWM
|| s_pScreenInfo->fMWExtWM
#endif
)
ReleaseCapture ();
return winMouseButtonsHandle (s_pScreen, ButtonRelease, Button1, wParam);
case WM_MBUTTONDBLCLK:
case WM_MBUTTONDOWN:
if (s_pScreenPriv == NULL || s_pScreenInfo->fIgnoreInput)
break;
if (s_pScreenInfo->fRootless
#ifdef XWIN_MULTIWINDOWEXTWM
|| s_pScreenInfo->fMWExtWM
#endif
)
SetCapture (hwnd);
return winMouseButtonsHandle (s_pScreen, ButtonPress, Button2, wParam);
case WM_MBUTTONUP:
if (s_pScreenPriv == NULL || s_pScreenInfo->fIgnoreInput)
break;
if (s_pScreenInfo->fRootless
#ifdef XWIN_MULTIWINDOWEXTWM
|| s_pScreenInfo->fMWExtWM
#endif
)
ReleaseCapture ();
return winMouseButtonsHandle (s_pScreen, ButtonRelease, Button2, wParam);
case WM_RBUTTONDBLCLK:
case WM_RBUTTONDOWN:
if (s_pScreenPriv == NULL || s_pScreenInfo->fIgnoreInput)
break;
if (s_pScreenInfo->fRootless
#ifdef XWIN_MULTIWINDOWEXTWM
|| s_pScreenInfo->fMWExtWM
#endif
)
SetCapture (hwnd);
return winMouseButtonsHandle (s_pScreen, ButtonPress, Button3, wParam);
case WM_RBUTTONUP:
if (s_pScreenPriv == NULL || s_pScreenInfo->fIgnoreInput)
break;
if (s_pScreenInfo->fRootless
#ifdef XWIN_MULTIWINDOWEXTWM
|| s_pScreenInfo->fMWExtWM
#endif
)
ReleaseCapture ();
return winMouseButtonsHandle (s_pScreen, ButtonRelease, Button3, wParam);
case WM_XBUTTONDBLCLK:
case WM_XBUTTONDOWN:
if (s_pScreenPriv == NULL || s_pScreenInfo->fIgnoreInput)
break;
if (s_pScreenInfo->fRootless
#ifdef XWIN_MULTIWINDOWEXTWM
|| s_pScreenInfo->fMWExtWM
#endif
)
SetCapture (hwnd);
return winMouseButtonsHandle (s_pScreen, ButtonPress, HIWORD(wParam) + 5, wParam);
case WM_XBUTTONUP:
if (s_pScreenPriv == NULL || s_pScreenInfo->fIgnoreInput)
break;
if (s_pScreenInfo->fRootless
#ifdef XWIN_MULTIWINDOWEXTWM
|| s_pScreenInfo->fMWExtWM
#endif
)
ReleaseCapture ();
return winMouseButtonsHandle (s_pScreen, ButtonRelease, HIWORD(wParam) + 5, wParam);
case WM_TIMER:
if (s_pScreenPriv == NULL || s_pScreenInfo->fIgnoreInput)
break;
/* Branch on the timer id */
switch (wParam)
{
case WIN_E3B_TIMER_ID:
/* Send delayed button press */
winMouseButtonsSendEvent (ButtonPress,
s_pScreenPriv->iE3BCachedPress);
/* Kill this timer */
KillTimer (s_pScreenPriv->hwndScreen, WIN_E3B_TIMER_ID);
/* Clear screen privates flags */
s_pScreenPriv->iE3BCachedPress = 0;
break;
case WIN_POLLING_MOUSE_TIMER_ID:
{
POINT point;
WPARAM wL, wM, wR, wShift, wCtrl;
LPARAM lPos;
/* Get the current position of the mouse cursor */
GetCursorPos (&point);
/* Map from screen (-X, -Y) to root (0, 0) */
point.x -= GetSystemMetrics (SM_XVIRTUALSCREEN);
point.y -= GetSystemMetrics (SM_YVIRTUALSCREEN);
/* Deliver absolute cursor position to X Server */
winEnqueueMotion(point.x , point.y);
/* Check if a button was released but we didn't see it */
GetCursorPos (&point);
wL = (GetKeyState (VK_LBUTTON) & 0x8000)?MK_LBUTTON:0;
wM = (GetKeyState (VK_MBUTTON) & 0x8000)?MK_MBUTTON:0;
wR = (GetKeyState (VK_RBUTTON) & 0x8000)?MK_RBUTTON:0;
wShift = (GetKeyState (VK_SHIFT) & 0x8000)?MK_SHIFT:0;
wCtrl = (GetKeyState (VK_CONTROL) & 0x8000)?MK_CONTROL:0;
lPos = MAKELPARAM(point.x, point.y);
if (g_fButton[0] & !wL)
PostMessage (hwnd, WM_LBUTTONUP, wCtrl|wM|wR|wShift, lPos);
if (g_fButton[1] & !wM)
PostMessage (hwnd, WM_MBUTTONUP, wCtrl|wL|wR|wShift, lPos);
if (g_fButton[2] & !wR)
PostMessage (hwnd, WM_RBUTTONUP, wCtrl|wL|wM|wShift, lPos);
}
}
return 0;
case WM_CTLCOLORSCROLLBAR:
FatalError ("winWindowProc - WM_CTLCOLORSCROLLBAR - We are not "
"supposed to get this message. Exiting.\n");
return 0;
case WM_MOUSEWHEEL:
if (s_pScreenPriv == NULL || s_pScreenInfo->fIgnoreInput)
break;
#if CYGDEBUG
winDebug ("winWindowProc - WM_MOUSEWHEEL\n");
#endif
winMouseWheel (s_pScreen, GET_WHEEL_DELTA_WPARAM(wParam));
break;
case WM_SETFOCUS:
if (s_pScreenPriv == NULL || s_pScreenInfo->fIgnoreInput)
break;
/* Restore the state of all mode keys */
winRestoreModeKeyStates ();
/* Add the keyboard hook if possible */
if (g_fKeyboardHookLL)
g_fKeyboardHookLL = winInstallKeyboardHookLL ();
return 0;
case WM_KILLFOCUS:
if (s_pScreenPriv == NULL || s_pScreenInfo->fIgnoreInput)
break;
/* Release any pressed keys */
winKeybdReleaseKeys ();
/* Remove our keyboard hook if it is installed */
winRemoveKeyboardHookLL ();
return 0;
case WM_SYSKEYDOWN:
case WM_KEYDOWN:
if (s_pScreenPriv == NULL || s_pScreenInfo->fIgnoreInput)
break;
/*
* FIXME: Catching Alt-F4 like this is really terrible. This should
* be generalized to handle other Windows keyboard signals. Actually,
* the list keys to catch and the actions to perform when caught should
* be configurable; that way user's can customize the keys that they
* need to have passed through to their window manager or apps, or they
* can remap certain actions to new key codes that do not conflict
* with the X apps that they are using. Yeah, that'll take awhile.
*/
if ((s_pScreenInfo->fUseWinKillKey && wParam == VK_F4
&& (GetKeyState (VK_MENU) & 0x8000))
|| (s_pScreenInfo->fUseUnixKillKey && wParam == VK_BACK
&& (GetKeyState (VK_MENU) & 0x8000)
&& (GetKeyState (VK_CONTROL) & 0x8000)))
{
/*
* Better leave this message here, just in case some unsuspecting
* user enters Alt + F4 and is surprised when the application
* quits.
*/
ErrorF ("winWindowProc - WM_*KEYDOWN - Closekey hit, quitting\n");
/* Display Exit dialog */
winDisplayExitDialog (s_pScreenPriv);
return 0;
}
/*
* Don't do anything for the Windows keys, as focus will soon
* be returned to Windows. We may be able to trap the Windows keys,
* but we should determine if that is desirable before doing so.
*/
if ((wParam == VK_LWIN || wParam == VK_RWIN) && !g_fKeyboardHookLL)
break;
/* Discard fake Ctrl_L events that precede AltGR on non-US keyboards */
if (winIsFakeCtrl_L (message, wParam, lParam))
return 0;
/*
* Discard presses generated from Windows auto-repeat
*/
if (lParam & (1<<30))
{
switch (wParam)
{
/* ago: Pressing LControl while RControl is pressed is
* Indicated as repeat. Fix this!
*/
case VK_CONTROL:
case VK_SHIFT:
if (winCheckKeyPressed(wParam, lParam))
return 0;
break;
default:
return 0;
}
}
/* Translate Windows key code to X scan code */
winTranslateKey (wParam, lParam, &iScanCode);
/* Ignore repeats for CapsLock */
if (wParam == VK_CAPITAL)
lParam = 1;
/* Send the key event(s) */
for (i = 0; i < LOWORD(lParam); ++i)
winSendKeyEvent (iScanCode, TRUE);
return 0;
case WM_SYSKEYUP:
case WM_KEYUP:
if (s_pScreenPriv == NULL || s_pScreenInfo->fIgnoreInput)
break;
/*
* Don't do anything for the Windows keys, as focus will soon
* be returned to Windows. We may be able to trap the Windows keys,
* but we should determine if that is desirable before doing so.
*/
if ((wParam == VK_LWIN || wParam == VK_RWIN) && !g_fKeyboardHookLL)
break;
/* Ignore the fake Ctrl_L that follows an AltGr release */
if (winIsFakeCtrl_L (message, wParam, lParam))
return 0;
/* Enqueue a keyup event */
winTranslateKey (wParam, lParam, &iScanCode);
winSendKeyEvent (iScanCode, FALSE);
/* Release all pressed shift keys */
if (wParam == VK_SHIFT)
winFixShiftKeys (iScanCode);
return 0;
case WM_HOTKEY:
if (s_pScreenPriv == NULL)
break;
/* Call the engine-specific hot key handler */
(*s_pScreenPriv->pwinHotKeyAltTab) (s_pScreen);
return 0;
case WM_ACTIVATE:
if (s_pScreenPriv == NULL
|| s_pScreenInfo->fIgnoreInput)
break;
/* TODO: Override display of window when we have a bad depth */
if (LOWORD(wParam) != WA_INACTIVE && s_pScreenPriv->fBadDepth)
{
ErrorF ("winWindowProc - WM_ACTIVATE - Bad depth, trying "
"to override window activation\n");
/* Minimize the window */
ShowWindow (hwnd, SW_MINIMIZE);
/* Display dialog box */
if (g_hDlgDepthChange != NULL)
{
/* Make the existing dialog box active */
SetActiveWindow (g_hDlgDepthChange);
}
else
{
/* TODO: Recreate the dialog box and bring to the top */
ShowWindow (g_hDlgDepthChange, SW_SHOWDEFAULT);
}
/* Don't do any other processing of this message */
return 0;
}
#if CYGDEBUG
winDebug ("winWindowProc - WM_ACTIVATE\n");
#endif
/*
* Focus is being changed to another window.
* The other window may or may not belong to
* our process.
*/
/* Clear any lingering wheel delta */
s_pScreenPriv->iDeltaZ = 0;
/* Reshow the Windows mouse cursor if we are being deactivated */
if (g_fSoftwareCursor && LOWORD(wParam) == WA_INACTIVE
&& !g_fCursor)
{
/* Show Windows cursor */
g_fCursor = TRUE;
ShowCursor (TRUE);
}
return 0;
case WM_ACTIVATEAPP:
if (s_pScreenPriv == NULL
|| s_pScreenInfo->fIgnoreInput)
break;
#if CYGDEBUG || TRUE
winDebug ("winWindowProc - WM_ACTIVATEAPP\n");
#endif
/* Activate or deactivate */
s_pScreenPriv->fActive = wParam;
/* Reshow the Windows mouse cursor if we are being deactivated */
if (g_fSoftwareCursor && !s_pScreenPriv->fActive
&& !g_fCursor)
{
/* Show Windows cursor */
g_fCursor = TRUE;
ShowCursor (TRUE);
}
#ifdef XWIN_CLIPBOARD
/* Make sure the clipboard chain is ok. */
winFixClipboardChain ();
#endif
/* Call engine specific screen activation/deactivation function */
(*s_pScreenPriv->pwinActivateApp) (s_pScreen);
#ifdef XWIN_MULTIWINDOWEXTWM
if (s_pScreenPriv->fActive)
{
/* Restack all window unless using built-in wm. */
if (s_pScreenInfo->fInternalWM && s_pScreenInfo->fAnotherWMRunning)
winMWExtWMRestackWindows (s_pScreen);
}
#endif
return 0;
case WM_COMMAND:
switch (LOWORD (wParam))
{
case ID_APP_EXIT:
/* Display Exit dialog */
winDisplayExitDialog (s_pScreenPriv);
return 0;
#ifdef XWIN_MULTIWINDOW
case ID_APP_HIDE_ROOT:
if (s_pScreenPriv->fRootWindowShown)
ShowWindow (s_pScreenPriv->hwndScreen, SW_HIDE);
else
ShowWindow (s_pScreenPriv->hwndScreen, SW_SHOW);
s_pScreenPriv->fRootWindowShown = !s_pScreenPriv->fRootWindowShown;
return 0;
#endif
case ID_APP_ABOUT:
/* Display the About box */
winDisplayAboutDialog (s_pScreenPriv);
return 0;
default:
/* It's probably one of the custom menus... */
if (HandleCustomWM_COMMAND (0, LOWORD (wParam)))
return 0;
}
break;
case WM_ENDSESSION:
case WM_GIVEUP:
/* Tell X that we are giving up */
#ifdef XWIN_MULTIWINDOW
if (s_pScreenInfo->fMultiWindow)
winDeinitMultiWindowWM ();
#endif
GiveUp (0);
return 0;
case WM_CLOSE:
/* Display Exit dialog */
winDisplayExitDialog (s_pScreenPriv);
return 0;
case WM_SETCURSOR:
if (LOWORD(lParam) == HTCLIENT)
{
if (!g_fSoftwareCursor) SetCursor (s_pScreenPriv->cursor.handle);
return TRUE;
}
break;
#ifdef XWIN_MULTIWINDOWEXTWM
case WM_MANAGE:
ErrorF ("winWindowProc - WM_MANAGE\n");
s_pScreenInfo->fAnotherWMRunning = FALSE;
if (s_pScreenInfo->fInternalWM)
{
EnumThreadWindows (g_dwCurrentThreadID, winMWExtWMDecorateWindow, 0);
//RootlessRepositionWindows (s_pScreen);
}
break;
case WM_UNMANAGE:
ErrorF ("winWindowProc - WM_UNMANAGE\n");
s_pScreenInfo->fAnotherWMRunning = TRUE;
if (s_pScreenInfo->fInternalWM)
{
EnumThreadWindows (g_dwCurrentThreadID, winMWExtWMDecorateWindow, 0);
winMWExtWMRestackWindows (s_pScreen);
}
break;
#endif
default:
if(message == s_uTaskbarRestart)
{
winInitNotifyIcon (s_pScreenPriv);
}
break;
}
return DefWindowProc (hwnd, message, wParam, lParam);
}
void CBrushPaletteWnd::OnPaint()
{
{
CPaintDC dc(this); // device context for painting
}
// skip if already drawing
extern BOOL _bInTestGame;
if( _bInTestGame) return;
if( m_iTimerID == -1)
{
m_iTimerID = (int) SetTimer( 1, 10, NULL);
}
POINT ptMouse;
GetCursorPos( &ptMouse);
ScreenToClient( &ptMouse);
// if there is a valid drawport, and the drawport can be locked
if( m_pDrawPort != NULL ) {
m_pDrawPort->SetAsCurrent();
CWorldEditorView *pWorldEditorView = theApp.GetActiveView();
ASSERT( pWorldEditorView != NULL);
// clear background
m_pDrawPort->Fill( C_lGRAY|CT_OPAQUE);
// erase z-buffer
m_pDrawPort->FillZBuffer(ZBUF_BACK);
// for all brushes
for( INDEX iBrush=0; iBrush<CT_BRUSHES; iBrush++)
{
// get current brush's box in pixels inside window
PIXaabbox2D boxBrush = GetBrushBBox( iBrush);
RenderBrushShape( iBrush, boxBrush, m_pDrawPort);
TIME tm=_pTimer->GetRealTimeTick();
// if we are drawing selected brush
if(iBrush==theApp.m_fCurrentTerrainBrush)
{
m_pDrawPort->SetAsCurrent();
FLOAT fFactor=sin(tm*8)/2.0f+0.5f;
COLOR colSelected=LerpColor(C_lGRAY,C_RED,fFactor);
m_pDrawPort->DrawBorder(boxBrush.Min()(1)-1, boxBrush.Min()(2)-1,
boxBrush.Max()(1)-boxBrush.Min()(1)+2, boxBrush.Max()(2)-boxBrush.Min()(2)+2,
colSelected|CT_OPAQUE);
}
PIXaabbox2D boxPoint( PIX2D( ptMouse.x, ptMouse.y), PIX2D(ptMouse.x, ptMouse.y) );
if( (boxBrush & boxPoint) == boxPoint)
{
m_pDrawPort->SetAsCurrent();
INDEX iRot=((ULONG)(tm*25.0f))&7;
ULONG ulLineType=0x0f0f0f0f<<iRot;
m_pDrawPort->DrawBorder(boxBrush.Min()(1)-1, boxBrush.Min()(2)-1,
boxBrush.Max()(1)-boxBrush.Min()(1)+2, boxBrush.Max()(2)-boxBrush.Min()(2)+2,
C_BLUE|CT_OPAQUE, ulLineType);
}
}
// if there is a valid viewport
if (m_pViewPort!=NULL)
{
m_pViewPort->SwapBuffers();
}
}
}
void CQListCtrl::OnTimer(UINT_PTR nIDEvent)
{
//http://support.microsoft.com/kb/200054
//OnTimer() Is Not Called Repeatedly for a List Control
bool callBase = true;
switch(nIDEvent)
{
case TIMER_SHOW_PROPERTIES:
{
if( theApp.m_bShowingQuickPaste )
ShowFullDescription(true);
KillTimer(TIMER_SHOW_PROPERTIES);
callBase = false;
}
break;
case TIMER_HIDE_SCROL:
{
CPoint cursorPos;
GetCursorPos(&cursorPos);
CRect crWindow;
this->GetWindowRect(&crWindow);
//check and see if they moved out of the scroll area
//If they did tell our parent so
if(MouseInScrollBarArea(crWindow, cursorPos) == false)
{
StopHideScrollBarTimer();
}
callBase = false;
}
break;
case TIMER_SHOW_SCROLL:
{
CPoint cursorPos;
GetCursorPos(&cursorPos);
CRect crWindow;
this->GetWindowRect(&crWindow);
//Adjust for the v-scroll bar being off of the screen
crWindow.right -= theApp.m_metrics.ScaleX(GetSystemMetrics(SM_CXVSCROLL));
crWindow.bottom -= theApp.m_metrics.ScaleX(::GetSystemMetrics(SM_CXHSCROLL));
//Check and see if we are still in the cursor area
if(MouseInScrollBarArea(crWindow, cursorPos))
{
m_timerToHideScrollAreaSet = true;
GetParent()->SendMessage(NM_SHOW_HIDE_SCROLLBARS, 1, 0);
//Start looking to hide the scroll bars
SetTimer(TIMER_HIDE_SCROL, 1000, NULL);
}
KillTimer(TIMER_SHOW_SCROLL);
callBase = false;
}
break;
}
if(callBase)
{
CListCtrl::OnTimer(nIDEvent);
}
}
/*
===========
IN_MouseMove
===========
*/
void IN_MouseMove (usercmd_t *cmd)
{
int mx, my;
HDC hdc;
int i;
DIDEVICEOBJECTDATA od;
DWORD dwElements;
HRESULT hr;
if (!mouseactive)
return;
if (dinput)
{
mx = 0;
my = 0;
for (;;)
{
dwElements = 1;
hr = IDirectInputDevice_GetDeviceData(g_pMouse,
sizeof(DIDEVICEOBJECTDATA), &od, &dwElements, 0);
if ((hr == DIERR_INPUTLOST) || (hr == DIERR_NOTACQUIRED))
{
dinput_acquired = true;
IDirectInputDevice_Acquire(g_pMouse);
break;
}
/* Unable to read data or no data available */
if (FAILED(hr) || dwElements == 0)
{
break;
}
/* Look at the element to see what happened */
switch (od.dwOfs)
{
case DIMOFS_X:
mx += od.dwData;
break;
case DIMOFS_Y:
my += od.dwData;
break;
case DIMOFS_BUTTON0:
if (od.dwData & 0x80)
mstate_di |= 1;
else
mstate_di &= ~1;
break;
case DIMOFS_BUTTON1:
if (od.dwData & 0x80)
mstate_di |= (1<<1);
else
mstate_di &= ~(1<<1);
break;
case DIMOFS_BUTTON2:
if (od.dwData & 0x80)
mstate_di |= (1<<2);
else
mstate_di &= ~(1<<2);
break;
}
}
// perform button actions
for (i=0 ; i<mouse_buttons ; i++)
{
if ( (mstate_di & (1<<i)) &&
!(mouse_oldbuttonstate & (1<<i)) )
{
Key_Event (K_MOUSE1 + i, true);
}
if ( !(mstate_di & (1<<i)) &&
(mouse_oldbuttonstate & (1<<i)) )
{
Key_Event (K_MOUSE1 + i, false);
}
}
mouse_oldbuttonstate = mstate_di;
}
else
{
GetCursorPos (¤t_pos);
mx = current_pos.x - window_center_x + mx_accum;
my = current_pos.y - window_center_y + my_accum;
mx_accum = 0;
my_accum = 0;
}
//if (mx || my)
// Con_DPrintf("mx=%d, my=%d\n", mx, my);
if (m_filter.value)
{
mouse_x = (mx + old_mouse_x) * 0.5;
mouse_y = (my + old_mouse_y) * 0.5;
}
else
{
mouse_x = mx;
mouse_y = my;
}
old_mouse_x = mx;
old_mouse_y = my;
mouse_x *= sensitivity.value;
mouse_y *= sensitivity.value;
// add mouse X/Y movement to cmd
if ( (in_strafe.state & 1) || (lookstrafe.value && (in_mlook.state & 1) ))
cmd->sidemove += m_side.value * mouse_x;
else
cl.viewangles[YAW] -= m_yaw.value * mouse_x;
if (in_mlook.state & 1)
V_StopPitchDrift ();
if ( (in_mlook.state & 1) && !(in_strafe.state & 1))
{
cl.viewangles[PITCH] += m_pitch.value * mouse_y;
if (cl.viewangles[PITCH] > 80)
cl.viewangles[PITCH] = 80;
if (cl.viewangles[PITCH] < -70)
cl.viewangles[PITCH] = -70;
}
else
{
if ((in_strafe.state & 1) && noclip_anglehack)
cmd->upmove -= m_forward.value * mouse_y;
else
cmd->forwardmove -= m_forward.value * mouse_y;
}
// if the mouse has moved, force it to the center, so there's room to move
if (mx || my)
{
SetCursorPos (window_center_x, window_center_y);
}
}
void CGUIDialogKeyboardGeneric::MoveCursor(int iAmount)
{
if (!m_strEditing.IsEmpty())
return;
SetCursorPos(GetCursorPos() + iAmount);
}
void CToolTipCtrlEx::OnPaint()
{
POINT Pos;
GetCursorPos(&Pos);
CRect PRect;
WindowFromPoint(Pos)->GetWindowRect(PRect);
CPaintDC dc(this); // device context for painting
CRect Rect,R1;
CRect WRect;
Orientations Orient=NW;
BOOL Over=0,Left=0;
Over=Pos.y >(PRect.top+(PRect.bottom-PRect.top)/2);
Left=Pos.x <(PRect.left+(PRect.right-PRect.left)/2);
if(Over & Left)Orient=NW;
else
if(Over & !Left)Orient=NE;
else
if(!Over & Left)Orient=SW;
else
if(!Over & !Left)Orient=SE;
dc.SelectObject(GetFont());
CString Tip=_T(""),TStr=_T("");
GetWindowText(Tip);
UINT Width=0;
UINT Rows=1;
UINT iPos=0;
Tip.Replace(_T("\r"),_T(""));
while(iPos<Tip.GetLength())
{
if(Tip.GetAt(iPos)=='\n')
{
CSize Sz1=dc.GetTextExtent(TStr);
Width=(Width > Sz1.cx) ? Width : Sz1.cx;
Rows+=1;
TStr=_T("");
}
else
{
TStr+=Tip.GetAt(iPos);
}
iPos++;
}
if(TStr.GetLength())
{
CSize Sz1=dc.GetTextExtent(TStr);
Width=(Width > Sz1.cx) ? Width : Sz1.cx;
}
if(Rows==1)
{
CSize Sz1=dc.GetTextExtent(Tip);
Width=(Width > Sz1.cx) ? Width : Sz1.cx;
}
Width+=2;
GetWindowRect(WRect);
TEXTMETRIC TM;
dc.GetTextMetrics(&TM);
if(Over)
{
WRect.bottom=PRect.top;
WRect.top=WRect.bottom-(Rows*(TM.tmHeight)+4);
}
else
{
WRect.top=PRect.bottom;
WRect.bottom=WRect.top+(Rows*(TM.tmHeight)+4);
}
UINT T=WRect.Width()-(20+Width);
WRect.left=Pos.x;
WRect.right=WRect.left+20+Width;
if(WRect.right>GetSystemMetrics(SM_CXSCREEN)-25)
{
WRect.OffsetRect(-(WRect.right-(GetSystemMetrics(SM_CXSCREEN)-25)),0);
}
MoveWindow(&WRect,1);
ShowWindow(1);
GetClientRect(Rect);
dc.FillSolidRect(Rect,m_bkColor);
R1=Rect;
R1.right=R1.left+15;
dc.FillSolidRect(R1,m_leftColor);
Rect.left=R1.right+1;
dc.SetBkMode(TRANSPARENT);
Rect.top+=1;
UINT iT=(Rect.Width()-Width)/2;
Rect.left+=iT;
dc.SetTextColor(m_textColor);
if(Rows==1)
{
dc.DrawText(Tip,Rect,DT_LEFT|DT_VCENTER|DT_SINGLELINE);
}
else
{
dc.DrawText(Tip,Rect,DT_TOP|DT_LEFT|DT_WORDBREAK);
}
Rect.top-=1;
Rect.left-=iT;
GetClientRect(Rect);
// Rect.InflateRect(1,1,1,1);
dc.Draw3dRect(Rect,m_frameColor,m_frameColor);
CPen Pen,*OldPen=0;
Pen.CreatePen(PS_SOLID,1,m_arrowColor);
OldPen=dc.SelectObject(&Pen);
switch(Orient)
{
case SE:
{
CPoint ArrowPt=CPoint(R1.left+2,R1.top+2);
POINT Pt[18]=
{
{ArrowPt.x, ArrowPt.y},
{ArrowPt.x, ArrowPt.y + 6},
{ArrowPt.x + 1, ArrowPt.y + 6},
{ArrowPt.x + 1, ArrowPt.y},
{ArrowPt.x + 6, ArrowPt.y},
{ArrowPt.x + 6, ArrowPt.y + 1},
{ArrowPt.x + 2, ArrowPt.y + 1},
{ArrowPt.x + 2, ArrowPt.y + 4},
{ArrowPt.x + 5, ArrowPt.y + 7},
{ArrowPt.x + 6, ArrowPt.y + 7},
{ArrowPt.x + 3, ArrowPt.y + 4},
{ArrowPt.x + 3, ArrowPt.y + 3},
{ArrowPt.x + 6, ArrowPt.y + 6},
{ArrowPt.x + 7, ArrowPt.y + 6},
{ArrowPt.x + 3, ArrowPt.y + 2},
{ArrowPt.x + 4, ArrowPt.y + 2},
{ArrowPt.x + 7, ArrowPt.y + 5},
{ArrowPt.x + 7, ArrowPt.y + 6}
};
dc.Polyline(Pt,18);
}
break;
case SW:
{
CPoint ArrowPt=CPoint(R1.right - 3, R1.top + 2);
POINT Pt[18]=
{
{ArrowPt.x, ArrowPt.y}, {ArrowPt.x, ArrowPt.y + 6},
{ArrowPt.x - 1, ArrowPt.y + 6}, {ArrowPt.x - 1, ArrowPt.y},
{ArrowPt.x - 6, ArrowPt.y}, {ArrowPt.x - 6, ArrowPt.y + 1},
{ArrowPt.x - 2, ArrowPt.y + 1}, {ArrowPt.x - 2, ArrowPt.y + 4},
{ArrowPt.x - 5, ArrowPt.y + 7}, {ArrowPt.x - 6, ArrowPt.y + 7},
{ArrowPt.x - 3, ArrowPt.y + 4}, {ArrowPt.x - 3, ArrowPt.y + 3},
{ArrowPt.x - 6, ArrowPt.y + 6}, {ArrowPt.x - 7, ArrowPt.y + 6},
{ArrowPt.x - 3, ArrowPt.y + 2}, {ArrowPt.x - 4, ArrowPt.y + 2},
{ArrowPt.x - 7, ArrowPt.y + 5}, {ArrowPt.x - 7, ArrowPt.y + 6}
};
dc.Polyline(Pt,18);
}
break;
case NE:
{
CPoint ArrowPt=CPoint(R1.left+ 3, R1.bottom - 3);
POINT Pt[18]=
{
{ArrowPt.x, ArrowPt.y}, {ArrowPt.x, ArrowPt.y - 6},
{ArrowPt.x + 1, ArrowPt.y - 6}, {ArrowPt.x + 1, ArrowPt.y},
{ArrowPt.x + 6, ArrowPt.y}, {ArrowPt.x + 6, ArrowPt.y - 1},
{ArrowPt.x + 2, ArrowPt.y - 1}, {ArrowPt.x + 2, ArrowPt.y - 4},
{ArrowPt.x + 5, ArrowPt.y - 7}, {ArrowPt.x + 6, ArrowPt.y - 7},
{ArrowPt.x + 3, ArrowPt.y - 4}, {ArrowPt.x + 3, ArrowPt.y - 3},
{ArrowPt.x + 6, ArrowPt.y - 6}, {ArrowPt.x + 7, ArrowPt.y - 6},
{ArrowPt.x + 3, ArrowPt.y - 2}, {ArrowPt.x + 4, ArrowPt.y - 2},
{ArrowPt.x + 7, ArrowPt.y - 5}, {ArrowPt.x + 7, ArrowPt.y - 6}
};
dc.Polyline(Pt,18);
}
break;
case NW:
{
CPoint ArrowPt=CPoint(R1.right- 3, R1.bottom - 3);
POINT Pt[18]=
{
{ArrowPt.x, ArrowPt.y}, {ArrowPt.x, ArrowPt.y - 6},
{ArrowPt.x - 1, ArrowPt.y - 6}, {ArrowPt.x - 1, ArrowPt.y},
{ArrowPt.x - 6, ArrowPt.y}, {ArrowPt.x - 6, ArrowPt.y - 1},
{ArrowPt.x - 2, ArrowPt.y - 1}, {ArrowPt.x - 2, ArrowPt.y - 4},
{ArrowPt.x - 5, ArrowPt.y - 7}, {ArrowPt.x - 6, ArrowPt.y - 7},
{ArrowPt.x - 3, ArrowPt.y - 4}, {ArrowPt.x - 3, ArrowPt.y - 3},
{ArrowPt.x - 6, ArrowPt.y - 6}, {ArrowPt.x - 7, ArrowPt.y - 6},
{ArrowPt.x - 3, ArrowPt.y - 2}, {ArrowPt.x - 4, ArrowPt.y - 2},
{ArrowPt.x - 7, ArrowPt.y - 5}, {ArrowPt.x - 7, ArrowPt.y - 6}
};
dc.Polyline(Pt,18);
}
break;
};
dc.SelectObject(OldPen);
Pen.DeleteObject();
}
void GiveFocusToScreen(unsigned int ScreenIndex, tree_node *FocusNode, bool Mouse, bool UpdateFocus)
{
screen_info *Screen = GetDisplayFromScreenID(ScreenIndex);
if(Screen && Screen != KWMScreen.Current)
{
KWMScreen.PrevSpace = KWMScreen.Current->ActiveSpace;
KWMScreen.Current = Screen;
Screen->ActiveSpace = GetActiveSpaceOfDisplay(Screen);
ShouldActiveSpaceBeManaged();
space_info *Space = GetActiveSpaceOfScreen(Screen);
DEBUG("GiveFocusToScreen() " << ScreenIndex << \
": Space transition ended " << KWMScreen.PrevSpace << \
" -> " << Screen->ActiveSpace);
if(UpdateFocus)
{
if(Space->Initialized && FocusNode)
{
DEBUG("Populated Screen 'Window -f Focus'");
UpdateActiveWindowList(Screen);
FilterWindowList(Screen);
SetWindowFocusByNode(FocusNode);
MoveCursorToCenterOfFocusedWindow();
}
else if(Space->Initialized && Space->RootNode)
{
DEBUG("Populated Screen Key/Mouse Focus");
UpdateActiveWindowList(Screen);
FilterWindowList(Screen);
bool WindowBelowCursor = IsAnyWindowBelowCursor();
if(Mouse && !WindowBelowCursor)
ClearFocusedWindow();
else if(Mouse && WindowBelowCursor)
FocusWindowBelowCursor();
if(!Mouse)
{
if(Space->FocusedWindowID == -1)
{
if(Space->Settings.Mode == SpaceModeBSP)
{
void *FocusNode = NULL;
GetFirstLeafNode(Space->RootNode, (void**)&FocusNode);
Space->FocusedWindowID = ((tree_node*)FocusNode)->WindowID;
}
else if(Space->Settings.Mode == SpaceModeMonocle)
{
if(Space->RootNode->List)
Space->FocusedWindowID = Space->RootNode->List->WindowID;
}
}
FocusWindowByID(Space->FocusedWindowID);
MoveCursorToCenterOfFocusedWindow();
}
}
else
{
if(!Space->Initialized ||
Space->Settings.Mode == SpaceModeFloating ||
!Space->RootNode)
{
DEBUG("Uninitialized Screen");
ClearFocusedWindow();
if(!Mouse)
CGWarpMouseCursorPosition(CGPointMake(Screen->X + (Screen->Width / 2), Screen->Y + (Screen->Height / 2)));
if(Space->Settings.Mode != SpaceModeFloating && !Space->RootNode)
{
CGPoint ClickPos = GetCursorPos();
CGEventRef ClickEvent = CGEventCreateMouseEvent(NULL, kCGEventLeftMouseDown, ClickPos, kCGMouseButtonLeft);
CGEventSetFlags(ClickEvent, 0);
CGEventPost(kCGHIDEventTap, ClickEvent);
CFRelease(ClickEvent);
ClickEvent = CGEventCreateMouseEvent(NULL, kCGEventLeftMouseUp, ClickPos, kCGMouseButtonLeft);
CGEventSetFlags(ClickEvent, 0);
CGEventPost(kCGHIDEventTap, ClickEvent);
CFRelease(ClickEvent);
}
}
}
}
}
}
void ShowTrayMenu() {
POINT pt;
GetCursorPos(&pt);
WCHAR szBuff[MAX_LANGLEN];
HMENU hmenu = CreatePopupMenu();
for (int i = 0; i <= (IDM_EXIT - IDM_STTRAYNEXT); i++) {
LangLoadString(IDS_STTRAYNEXT + i, szBuff, SIZEOF_ARRAY(szBuff));
AppendMenu(hmenu, MF_STRING, IDM_STTRAYNEXT + i, szBuff);
}
InsertMenu(hmenu, IDM_CONFIG, MF_SEPARATOR | MF_BYCOMMAND, 0, NULL);
InsertMenu(hmenu, IDM_EXIT, MF_SEPARATOR | MF_BYCOMMAND, 0, NULL);
HMENU hmenuPopup = CreatePopupMenu();
for (int i = 0; i <= (IDM_ABOUT - IDM_DOCUMENTATION); i++) {
LangLoadString(IDS_DOCUMENTATION + i, szBuff, SIZEOF_ARRAY(szBuff));
AppendMenu(hmenuPopup, MF_STRING, IDM_DOCUMENTATION + i, szBuff);
}
LangLoadString(IDS_HELP, szBuff, SIZEOF_ARRAY(szBuff));
InsertMenu(hmenu, IDM_CONFIG, MF_STRING | MF_BYCOMMAND | MF_POPUP,
(UINT_PTR)hmenuPopup, szBuff);
InsertMenu(hmenu, 4, MF_SEPARATOR | MF_BYPOSITION, 0, NULL);
hmenuPopup = CreatePopupMenu();
for (int i = 0; i <= (IDM_NEWEXCLUSION - IDM_HIDE); i++) {
LangLoadString(IDS_HIDE + i, szBuff, SIZEOF_ARRAY(szBuff));
AppendMenu(hmenuPopup, MF_STRING, IDM_HIDE + i, szBuff);
}
InsertMenu(hmenuPopup, IDM_NEWEXCLUSION, MF_SEPARATOR | MF_BYCOMMAND, 0, NULL);
InsertMenu(hmenuPopup, IDM_REPLACEALTTAB, MF_SEPARATOR | MF_BYCOMMAND, 0, NULL);
CheckMenuItem(hmenuPopup, IDM_REPLACEALTTAB, !(g_dwFlags & TSF_NOREPLACEALTTAB)
? (MF_BYCOMMAND | MF_CHECKED) : (MF_BYCOMMAND | MF_UNCHECKED));
CheckMenuItem(hmenuPopup, IDM_INSTSWITCHER, (g_dwFlags & TSF_INSTSWITCHER)
? (MF_BYCOMMAND | MF_CHECKED) : (MF_BYCOMMAND | MF_UNCHECKED));
CheckMenuItem(hmenuPopup, IDM_STICKYALTTAB, (g_dwFlags & TSF_STICKYALTTAB)
? (MF_BYCOMMAND | MF_CHECKED) : (MF_BYCOMMAND | MF_UNCHECKED));
CheckMenuItem(hmenuPopup, IDM_HOOKALTTAB, (g_dwFlags & TSF_HOOKALTTAB)
? (MF_BYCOMMAND | MF_CHECKED) : (MF_BYCOMMAND | MF_UNCHECKED));
// CheckMenuItem(hmenuPopup, IDM_EXTMOUSE, (g_dwFlags & TSF_EXTMOUSE)
// ? (MF_BYCOMMAND | MF_CHECKED) : (MF_BYCOMMAND | MF_UNCHECKED));
LangLoadString(IDS_QUICKCONFIG, szBuff, SIZEOF_ARRAY(szBuff));
InsertMenu(hmenu, IDM_CONFIG, MF_STRING | MF_BYCOMMAND | MF_POPUP,
(UINT_PTR)hmenuPopup, szBuff);
SetForegroundWindow(g_hwndMain);
UINT uMenuID = (UINT)TrackPopupMenu(hmenu,
TPM_RIGHTBUTTON | TPM_RIGHTALIGN | TPM_NONOTIFY | TPM_RETURNCMD,
pt.x, pt.y, 0, g_hwndMain, NULL);
PostMessage(g_hwndMain, WM_NULL, 0, 0);
DestroyMenu(hmenu);
switch (uMenuID) {
case IDM_STTRAYNEXT:
ShowTaskSwitchWnd(IDH_STTRAYNEXT);
break;
case IDM_STITRAYNEXT:
ShowTaskSwitchWnd(IDH_STITRAYNEXT);
break;
case IDM_CONFIG:
ConfigTaskSwitchXP();
break;
case IDM_HIDE:
ShowTrayIcon(FALSE);
break;
case IDM_REPLACEALTTAB:
ReplaceAltTab((g_dwFlags & TSF_NOREPLACEALTTAB)
? (g_dwFlags & ~TSF_NOREPLACEALTTAB) : (g_dwFlags | TSF_NOREPLACEALTTAB));
break;
case IDM_INSTSWITCHER:
ReplaceAltTab((g_dwFlags & TSF_INSTSWITCHER)
? (g_dwFlags & ~TSF_INSTSWITCHER) : (g_dwFlags | TSF_INSTSWITCHER));
break;
case IDM_STICKYALTTAB:
g_dwFlags ^= TSF_STICKYALTTAB;
break;
case IDM_HOOKALTTAB:
ReplaceAltTab((g_dwFlags & TSF_HOOKALTTAB)
? (g_dwFlags & ~TSF_HOOKALTTAB) : (g_dwFlags | TSF_HOOKALTTAB));
break;
// case IDM_EXTMOUSE:
// EnableExtMouse(!(g_dwFlags & TSF_EXTMOUSE), g_dwFlags & TSF_WHEELTAB);
// break;
case IDM_NEWEXCLUSION:
ConfigTaskSwitchXP(L"/newexcl");
break;
case IDM_DOCUMENTATION:
HelpTaskSwitchXP();
break;
case IDM_HOMEPAGE:
ShellExecute(NULL, L"open", L"http://www.ntwind.com/taskswitchxp/", NULL, NULL, SW_SHOWNORMAL);
break;
case IDM_ABOUT:
ConfigTaskSwitchXP(L"/about");
break;
case IDM_EXIT:
DestroyWindow(g_hwndMain);
break;
}
}
int main()
{
srand(time(NULL));
// Create the main window
sf::RenderWindow window(sf::VideoMode(800, 600), "Astroides");
//used for getting the mouse posistion.
sf::VideoMode desktop = sf::VideoMode::getDesktopMode();
const int window_height = desktop.height;
const int window_width = desktop.width;
window.setFramerateLimit(60);
sf::Clock clock = sf::Clock();
sf::Time elapsedTime;
//BackGround
sf::Texture backGroundTexture;
sf::Sprite backGroundSprite;
backGroundTexture.loadFromFile("Resorces/Img/background.png");
backGroundSprite.setTexture(backGroundTexture);
backGroundSprite.setPosition(0, 0);
//Entities
Player player = Player();
EnemyManager eManager;
ProjectileManager* projectileMgr = ProjectileManager::instance();
InputManager* inputMgr = InputManager::instance();
//set up world.
sf::Vector2f worldBounds = sf::Vector2f(MAP_WIDTH, MAP_HEIGHT);
int numPacksSwarmers = 10;
int numSwarmersPerPack = 10;
int numSwarmerEnemies = numPacksSwarmers * numSwarmersPerPack;
int numFactories = 20;
//create some Enemies
for (int i = 0; i < numPacksSwarmers; i++)
{
for (int z = 0; z < numSwarmersPerPack; z++)
{
Swarmer * e = new Swarmer((1000 * i), (700 * i)); //Starts all enemy in the center of the screen.
eManager.addEnemy(e);
}
}
for (int i = 0; i < numFactories; i++)
{
Factory * f = new Factory(&eManager);
eManager.addFactory(f);
}
// Start game loop
while (window.isOpen())
{
// Process events
sf::Event Event;
while (window.pollEvent(Event))
{
if (Event.type == Event.KeyPressed && Event.key.code == sf::Keyboard::Escape)
{
window.close();
}
switch (Event.type)
{
// Close window : exit
case sf::Event::Closed:
window.close();
break;
default:
break;
}//end switch
}//end while
InputManager::instance()->UpdatePressedKeys(Event);
player.Update(worldBounds);
projectileMgr->Update(window);
//Get the mouse posistion and send it to the swarm method.
POINT mousePos;
if (GetCursorPos(&mousePos))
{
if (ScreenToClient(window.getSystemHandle(), &mousePos))
{
//std::cout << "mouse pos : (" << mousePos.x << ", " << mousePos.y << ")" << std::endl;
eManager.swarmEAI(player.GetPos());
}
}
//eManager.flocking();
eManager.CheckCollisions();
eManager.UpdateFactories(&player);
eManager.UpdatePredators(player.GetPos());
eManager.CollisionSwarm(&player);
eManager.CollisionPred(&player);
//prepare frame
window.clear();
window.setView(player.getView());
window.draw(backGroundSprite);
player.Draw(window);
projectileMgr->Draw(window);
eManager.Draw(window, worldBounds);
window.setView(player.getMiniMapView());
window.draw(backGroundSprite);
player.Draw(window);
projectileMgr->Draw(window);
eManager.Draw(window, worldBounds);
// Finally, display rendered frame on screen
window.display();
clock.restart();
} //loop back for next frame
return EXIT_SUCCESS;
}
// Called from the Windows notification handler thread, in its message loop
LRESULT CALLBACK
DesktopIndicatorHandler::WndProc
(HWND hWnd, UINT uMessage, WPARAM wParam, LPARAM lParam)
{
// Check for our special notification message
if ((uMessage != WM_DESKTOPINDICATOR_CLICK)) {
return DefWindowProc(hWnd, uMessage, wParam, lParam);
}
DesktopIndicatorHandler *pthis = (DesktopIndicatorHandler *)
GetWindowLong(hWnd, GWL_USERDATA);
switch (lParam) {
case WM_LBUTTONDBLCLK:
// Execute the default action of the right-click popup menu
pthis->restoreApplication();
break;
//case WM_LBUTTONDOWN:
//case WM_RBUTTONDOWN:
//case WM_LBUTTONUP:
//break;
case WM_RBUTTONUP: // Display popup menu on right click
{
SetForegroundWindow(hWnd);
POINT pos;
GetCursorPos(&pos);
int cxMenuCheck = GetSystemMetrics(SM_CXMENUCHECK);
int cyMenuCheck = GetSystemMetrics(SM_CYMENUCHECK);
HMENU hMenu = CreatePopupMenu();
UAppendMenu(hMenu, MF_STRING, MNU_RESTORE,
pthis->m_lpwszItemRestore); // L"Restore";
UAppendMenu(hMenu, MF_STRING, MNU_ABOUT,
pthis->m_lpwszItemAbout); // L"About...";
UAppendMenu(hMenu, MF_SEPARATOR, 0, (LPCWSTR)NULL);
UAppendMenu(hMenu, MF_STRING, MNU_EXIT_AFTER,
pthis->m_lpwszItemExitLater); // L"Exit After Transfers";
UAppendMenu(hMenu, MF_STRING, MNU_EXIT,
pthis->m_lpwszItemExit); // L"Exit";
//Load 15x15 bitmaps for unchecked state of menu options
//Remap colors #000000, #808080, #C0C0C0, #DFDFDF, #FFFFFF
//to 3D colors: DlgText, 3DDark, 3DFace, 3DLight, WindowBg
HBITMAP hbmpRestore = (HBITMAP)LoadImageA(
::g_hInstance, MAKEINTRESOURCEA(IDB_RESTORE),
IMAGE_BITMAP, cxMenuCheck, cyMenuCheck,
LR_LOADMAP3DCOLORS);
HBITMAP hbmpHelp = (HBITMAP)LoadImageA(
::g_hInstance, MAKEINTRESOURCEA(IDB_HELP),
IMAGE_BITMAP, cxMenuCheck, cyMenuCheck,
LR_LOADMAP3DCOLORS);
HBITMAP hbmpWaitClose = (HBITMAP)LoadImageA(
::g_hInstance, MAKEINTRESOURCEA(IDB_WAITCLOSE),
IMAGE_BITMAP, cxMenuCheck, cyMenuCheck,
LR_LOADMAP3DCOLORS);
HBITMAP hbmpClose = (HBITMAP)LoadImageA(
::g_hInstance, MAKEINTRESOURCEA(IDB_CLOSE),
IMAGE_BITMAP, cxMenuCheck, cyMenuCheck,
LR_LOADMAP3DCOLORS);
SetMenuItemBitmaps(hMenu, MNU_RESTORE, MF_BYCOMMAND,
hbmpRestore, (HBITMAP)NULL);
SetMenuItemBitmaps(hMenu, MNU_ABOUT, MF_BYCOMMAND,
hbmpHelp, (HBITMAP)NULL);
SetMenuItemBitmaps(hMenu, MNU_EXIT_AFTER, MF_BYCOMMAND,
hbmpWaitClose, (HBITMAP)NULL);
SetMenuItemBitmaps(hMenu, MNU_EXIT, MF_BYCOMMAND,
hbmpClose, (HBITMAP)NULL);
SetMenuDefaultItem(hMenu, MNU_RESTORE, MF_BYCOMMAND);
switch (TrackPopupMenu(hMenu,
TPM_CENTERALIGN | TPM_BOTTOMALIGN |
TPM_LEFTBUTTON |
TPM_NONOTIFY | TPM_RETURNCMD, /* return an item.wID instead of BOOL */
pos.x, pos.y,
0, hWnd, (LPCRECT)NULL)) {
case MNU_RESTORE:
pthis->restoreApplication();
break;
case MNU_ABOUT:
pthis->showAboutWindow();
break;
case MNU_EXIT_AFTER:
pthis->exitAfterTransfers();
break;
case MNU_EXIT:
pthis->exitApplication();
break;
}
DestroyMenu(hMenu);
DeleteObject((HGDIOBJ)hbmpRestore);
DeleteObject((HGDIOBJ)hbmpClose);
}
break;
case WM_DESTROY:
PostQuitMessage(0);
break;
}
return 0;
}
void ProcessPageShowContextMenu(DWORD dwProcessId)
{
HMENU hMenu;
HMENU hSubMenu;
HMENU hPriorityMenu;
POINT pt;
SYSTEM_INFO si;
HANDLE hProcess;
DWORD dwProcessPriorityClass;
WCHAR strDebugger[260];
DWORD dwDebuggerSize;
HKEY hKey;
memset(&si, 0, sizeof(SYSTEM_INFO));
GetCursorPos(&pt);
GetSystemInfo(&si);
hMenu = LoadMenuW(hInst, MAKEINTRESOURCEW(IDR_PROCESS_PAGE_CONTEXT));
hSubMenu = GetSubMenu(hMenu, 0);
hPriorityMenu = GetSubMenu(hSubMenu, 4);
hProcess = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, dwProcessId);
dwProcessPriorityClass = GetPriorityClass(hProcess);
CloseHandle(hProcess);
if (si.dwNumberOfProcessors < 2)
RemoveMenu(hSubMenu, ID_PROCESS_PAGE_SETAFFINITY, MF_BYCOMMAND);
if (!DebugChannelsAreSupported())
RemoveMenu(hSubMenu, ID_PROCESS_PAGE_DEBUGCHANNELS, MF_BYCOMMAND);
switch (dwProcessPriorityClass) {
case REALTIME_PRIORITY_CLASS:
CheckMenuRadioItem(hPriorityMenu, ID_PROCESS_PAGE_SETPRIORITY_REALTIME, ID_PROCESS_PAGE_SETPRIORITY_LOW, ID_PROCESS_PAGE_SETPRIORITY_REALTIME, MF_BYCOMMAND);
break;
case HIGH_PRIORITY_CLASS:
CheckMenuRadioItem(hPriorityMenu, ID_PROCESS_PAGE_SETPRIORITY_REALTIME, ID_PROCESS_PAGE_SETPRIORITY_LOW, ID_PROCESS_PAGE_SETPRIORITY_HIGH, MF_BYCOMMAND);
break;
case ABOVE_NORMAL_PRIORITY_CLASS:
CheckMenuRadioItem(hPriorityMenu, ID_PROCESS_PAGE_SETPRIORITY_REALTIME, ID_PROCESS_PAGE_SETPRIORITY_LOW, ID_PROCESS_PAGE_SETPRIORITY_ABOVENORMAL, MF_BYCOMMAND);
break;
case NORMAL_PRIORITY_CLASS:
CheckMenuRadioItem(hPriorityMenu, ID_PROCESS_PAGE_SETPRIORITY_REALTIME, ID_PROCESS_PAGE_SETPRIORITY_LOW, ID_PROCESS_PAGE_SETPRIORITY_NORMAL, MF_BYCOMMAND);
break;
case BELOW_NORMAL_PRIORITY_CLASS:
CheckMenuRadioItem(hPriorityMenu, ID_PROCESS_PAGE_SETPRIORITY_REALTIME, ID_PROCESS_PAGE_SETPRIORITY_LOW, ID_PROCESS_PAGE_SETPRIORITY_BELOWNORMAL, MF_BYCOMMAND);
break;
case IDLE_PRIORITY_CLASS:
CheckMenuRadioItem(hPriorityMenu, ID_PROCESS_PAGE_SETPRIORITY_REALTIME, ID_PROCESS_PAGE_SETPRIORITY_LOW, ID_PROCESS_PAGE_SETPRIORITY_LOW, MF_BYCOMMAND);
break;
}
if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, L"Software\\Microsoft\\Windows NT\\CurrentVersion\\AeDebug", 0, KEY_READ, &hKey) == ERROR_SUCCESS)
{
dwDebuggerSize = sizeof(strDebugger);
if (RegQueryValueExW(hKey, L"Debugger", NULL, NULL, (LPBYTE)strDebugger, &dwDebuggerSize) == ERROR_SUCCESS)
{
CharUpper(strDebugger);
if (wcsstr(strDebugger, L"DRWTSN32"))
EnableMenuItem(hSubMenu, ID_PROCESS_PAGE_DEBUG, MF_BYCOMMAND|MF_DISABLED|MF_GRAYED);
}
else
EnableMenuItem(hSubMenu, ID_PROCESS_PAGE_DEBUG, MF_BYCOMMAND|MF_DISABLED|MF_GRAYED);
RegCloseKey(hKey);
} else {
EnableMenuItem(hSubMenu, ID_PROCESS_PAGE_DEBUG, MF_BYCOMMAND|MF_DISABLED|MF_GRAYED);
}
TrackPopupMenu(hSubMenu, TPM_LEFTALIGN|TPM_TOPALIGN|TPM_LEFTBUTTON, pt.x, pt.y, 0, hMainWnd, NULL);
DestroyMenu(hMenu);
}
static VOID ShowStatusMenu(
_In_ HWND hwndDlg
)
{
PPH_STRING cacheEntryName;
cacheEntryName = PhGetSelectedListViewItemText(ListViewWndHandle);
if (cacheEntryName)
{
POINT cursorPos;
PPH_EMENU menu;
PPH_EMENU_ITEM selectedItem;
GetCursorPos(&cursorPos);
menu = PhCreateEMenu();
PhInsertEMenuItem(menu, PhCreateEMenuItem(0, 1, L"Remove", NULL, NULL), -1);
selectedItem = PhShowEMenu(
menu,
ListViewWndHandle,
PH_EMENU_SHOW_LEFTRIGHT,
PH_ALIGN_LEFT | PH_ALIGN_TOP,
cursorPos.x,
cursorPos.y
);
if (selectedItem && selectedItem->Id != -1)
{
switch (selectedItem->Id)
{
case 1:
{
INT lvItemIndex = PhFindListViewItemByFlags(
ListViewWndHandle,
-1,
LVNI_SELECTED
);
if (lvItemIndex != -1)
{
if (!PhGetIntegerSetting(L"EnableWarnings") || PhShowConfirmMessage(
hwndDlg,
L"remove",
cacheEntryName->Buffer,
NULL,
FALSE
))
{
PATOM_TABLE_INFORMATION atomTable = NULL;
if (!NT_SUCCESS(PhEnumAtomTable(&atomTable)))
return;
for (ULONG i = 0; i < atomTable->NumberOfAtoms; i++)
{
PATOM_BASIC_INFORMATION atomInfo = NULL;
if (!NT_SUCCESS(PhQueryAtomTableEntry(atomTable->Atoms[i], &atomInfo)))
continue;
if (!PhEqualStringZ(atomInfo->Name, cacheEntryName->Buffer, TRUE))
continue;
do
{
if (!NT_SUCCESS(NtDeleteAtom(atomTable->Atoms[i])))
{
break;
}
PhFree(atomInfo);
atomInfo = NULL;
if (!NT_SUCCESS(PhQueryAtomTableEntry(atomTable->Atoms[i], &atomInfo)))
break;
} while (atomInfo->UsageCount >= 1);
ListView_DeleteItem(ListViewWndHandle, lvItemIndex);
if (atomInfo)
{
PhFree(atomInfo);
}
}
PhFree(atomTable);
}
}
}
break;
}
}
PhDestroyEMenu(menu);
PhDereferenceObject(cacheEntryName);
}
}
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
switch (message)
{
case WM_COMMAND:
switch (LOWORD(wParam))
{
case ID_PM_REALTIME:
SetProcessPriority(REALTIME_PRIORITY_CLASS);
break;
case ID_PM_HIGH:
SetProcessPriority(HIGH_PRIORITY_CLASS);
break;
case ID_PM_ABOVE_NORMAL:
SetProcessPriority(ABOVE_NORMAL_PRIORITY_CLASS);
break;
case ID_PM_NORMAL:
SetProcessPriority(NORMAL_PRIORITY_CLASS);
break;
case ID_PM_BELOW_NORMAL:
SetProcessPriority(BELOW_NORMAL_PRIORITY_CLASS);
break;
case ID_PM_IDLE:
SetProcessPriority(IDLE_PRIORITY_CLASS);
break;
}
switch (HIWORD(wParam))
{
case 1:
{
if (lParam == (LPARAM)ListBoxProcess)
ShowModule();
}
break;
default:
return DefWindowProc(hWnd, message, wParam, lParam);
break;
}
break;
case WM_CONTEXTMENU:
if (SendMessage(ListBoxProcess, LB_GETCURSEL, 0, 0) != LB_ERR)
{
POINT cursorPosition;
GetCursorPos(&cursorPosition);
TrackPopupMenu(PopupMenu, TPM_BOTTOMALIGN | TPM_LEFTALIGN, cursorPosition.x, cursorPosition.y, 0, hWnd, NULL);
}
break;
case WM_DESTROY:
PostQuitMessage(0);
break;
default:
return DefWindowProc(hWnd, message, wParam, lParam);
break;
}
return 0;
}
void EMU::update_input()
{
#ifdef USE_SHIFT_NUMPAD_KEY
// update numpad key status
if(key_shift_pressed && !key_shift_released) {
if(key_status[VK_SHIFT] == 0) {
// shift key is newly pressed
key_status[VK_SHIFT] = 0x80;
#ifdef NOTIFY_KEY_DOWN
vm->key_down(VK_SHIFT, false);
#endif
}
}
else if(!key_shift_pressed && key_shift_released) {
if(key_status[VK_SHIFT] != 0) {
// shift key is newly released
key_status[VK_SHIFT] = 0;
#ifdef NOTIFY_KEY_DOWN
vm->key_up(VK_SHIFT);
#endif
// check l/r shift
if(!(GetAsyncKeyState(VK_LSHIFT) & 0x8000)) key_status[VK_LSHIFT] &= 0x7f;
if(!(GetAsyncKeyState(VK_RSHIFT) & 0x8000)) key_status[VK_RSHIFT] &= 0x7f;
}
}
key_shift_pressed = key_shift_released = false;
#endif
// release keys
#ifdef USE_AUTO_KEY
if(lost_focus && autokey_phase == 0) {
#else
if(lost_focus) {
#endif
// we lost key focus so release all pressed keys
for(int i = 0; i < 256; i++) {
if(key_status[i] & 0x80) {
key_status[i] &= 0x7f;
#ifdef NOTIFY_KEY_DOWN
if(!key_status[i]) {
vm->key_up(i);
}
#endif
}
}
}
else {
for(int i = 0; i < 256; i++) {
if(key_status[i] & 0x7f) {
key_status[i] = (key_status[i] & 0x80) | ((key_status[i] & 0x7f) - 1);
#ifdef NOTIFY_KEY_DOWN
if(!key_status[i]) {
vm->key_up(i);
}
#endif
}
}
}
lost_focus = false;
// update joystick status
memset(joy_status, 0, sizeof(joy_status));
for(int i = 0; i < joy_num && i < 2; i++) {
JOYINFOEX joyinfo;
joyinfo.dwSize = sizeof(JOYINFOEX);
joyinfo.dwFlags = JOY_RETURNALL;
if(joyGetPosEx(i, &joyinfo) == JOYERR_NOERROR) {
if(joyinfo.dwYpos < 0x3fff) joy_status[i] |= 0x01; // up
if(joyinfo.dwYpos > 0xbfff) joy_status[i] |= 0x02; // down
if(joyinfo.dwXpos < 0x3fff) joy_status[i] |= 0x04; // left
if(joyinfo.dwXpos > 0xbfff) joy_status[i] |= 0x08; // right
joy_status[i] |= ((joyinfo.dwButtons & joy_mask[i]) << 4);
}
}
#ifdef USE_KEY_TO_JOY
// emulate joystick #1 with keyboard
if(key_status[0x26]) joy_status[0] |= 0x01; // up
if(key_status[0x28]) joy_status[0] |= 0x02; // down
if(key_status[0x25]) joy_status[0] |= 0x04; // left
if(key_status[0x27]) joy_status[0] |= 0x08; // right
#endif
// update mouse status
memset(mouse_status, 0, sizeof(mouse_status));
if(mouse_enabled) {
// get current status
POINT pt;
GetCursorPos(&pt);
ScreenToClient(main_window_handle, &pt);
mouse_status[0] = pt.x - display_width / 2;
mouse_status[1] = pt.y - display_height / 2;
mouse_status[2] = (GetAsyncKeyState(VK_LBUTTON) & 0x8000) ? 1 : 0;
mouse_status[2] |= (GetAsyncKeyState(VK_RBUTTON) & 0x8000) ? 2 : 0;
mouse_status[2] |= (GetAsyncKeyState(VK_MBUTTON) & 0x8000) ? 4 : 0;
// move mouse cursor to the center of window
if(!(mouse_status[0] == 0 && mouse_status[1] == 0)) {
pt.x = display_width / 2;
pt.y = display_height / 2;
ClientToScreen(main_window_handle, &pt);
SetCursorPos(pt.x, pt.y);
}
}
#ifdef USE_AUTO_KEY
// auto key
switch(autokey_phase) {
case 1:
if(autokey_buffer && !autokey_buffer->empty()) {
// update shift key status
int shift = autokey_buffer->read_not_remove(0) & 0x100;
if(shift && !autokey_shift) {
key_down(VK_SHIFT, false);
}
else if(!shift && autokey_shift) {
key_up(VK_SHIFT);
}
autokey_shift = shift;
autokey_phase++;
break;
}
case 3:
if(autokey_buffer && !autokey_buffer->empty()) {
key_down(autokey_buffer->read_not_remove(0) & 0xff, false);
}
autokey_phase++;
break;
case USE_AUTO_KEY:
if(autokey_buffer && !autokey_buffer->empty()) {
key_up(autokey_buffer->read_not_remove(0) & 0xff);
}
autokey_phase++;
break;
case USE_AUTO_KEY_RELEASE:
if(autokey_buffer && !autokey_buffer->empty()) {
// wait enough while vm analyzes one line
if(autokey_buffer->read() == 0xd) {
autokey_phase++;
break;
}
}
case 30:
if(autokey_buffer && !autokey_buffer->empty()) {
autokey_phase = 1;
}
else {
stop_auto_key();
}
break;
default:
if(autokey_phase) {
autokey_phase++;
}
}
#endif
}
#ifdef USE_SHIFT_NUMPAD_KEY
static const int numpad_table[256] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x65, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
// 0x00, 0x69, 0x63, 0x61, 0x67, 0x64, 0x68, 0x66, 0x62, 0x00, 0x00, 0x00, 0x00, 0x60, 0x6e, 0x00,
0x00, 0x69, 0x63, 0x61, 0x67, 0x64, 0x68, 0x66, 0x62, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, // remove shift + period
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
#endif
void EMU::key_down(int code, bool repeat)
{
bool keep_frames = false;
if(code == VK_SHIFT) {
if(GetAsyncKeyState(VK_LSHIFT) & 0x8000) key_status[VK_LSHIFT] = 0x80;
if(GetAsyncKeyState(VK_RSHIFT) & 0x8000) key_status[VK_RSHIFT] = 0x80;
if(!(key_status[VK_LSHIFT] || key_status[VK_RSHIFT])) key_status[VK_LSHIFT] = 0x80;
}
else if(code == VK_CONTROL) {
if(GetAsyncKeyState(VK_LCONTROL) & 0x8000) key_status[VK_LCONTROL] = 0x80;
if(GetAsyncKeyState(VK_RCONTROL) & 0x8000) key_status[VK_RCONTROL] = 0x80;
if(!(key_status[VK_LCONTROL] || key_status[VK_RCONTROL])) key_status[VK_LCONTROL] = 0x80;
}
else if(code == VK_MENU) {
if(GetAsyncKeyState(VK_LMENU) & 0x8000) key_status[VK_LMENU] = 0x80;
if(GetAsyncKeyState(VK_RMENU) & 0x8000) key_status[VK_RMENU] = 0x80;
if(!(key_status[VK_LMENU] || key_status[VK_RMENU])) key_status[VK_LMENU] = 0x80;
}
else if(code == 0xf0) {
code = VK_CAPITAL;
keep_frames = true;
}
else if(code == 0xf2) {
code = VK_KANA;
keep_frames = true;
}
else if(code == 0xf3 || code == 0xf4) {
code = VK_KANJI;
keep_frames = true;
}
#ifdef USE_SHIFT_NUMPAD_KEY
if(code == VK_SHIFT) {
key_shift_pressed = true;
return;
}
else if(numpad_table[code] != 0) {
if(key_shift_pressed || key_shift_released) {
key_converted[code] = 1;
key_shift_pressed = true;
code = numpad_table[code];
}
}
#endif
if(!(code == VK_SHIFT || code == VK_CONTROL || code == VK_MENU)) {
code = keycode_conv[code];
}
#ifdef DONT_KEEEP_KEY_PRESSED
if(!(code == VK_SHIFT || code == VK_CONTROL || code == VK_MENU)) {
key_status[code] = KEY_KEEP_FRAMES;
}
else
#endif
key_status[code] = keep_frames ? KEY_KEEP_FRAMES : 0x80;
#ifdef NOTIFY_KEY_DOWN
if(keep_frames) {
repeat = false;
}
vm->key_down(code, repeat);
#endif
}
WebMouseWheelEvent WebInputEventFactory::mouseWheelEvent(HWND hwnd, UINT message,
WPARAM wparam, LPARAM lparam)
{
WebMouseWheelEvent result; //(WebInputEvent::Uninitialized());
result.type = WebInputEvent::MouseWheel;
// TODO(pkasting): http://b/1117926 Are we guaranteed that the message that
// GetMessageTime() refers to is the same one that we're passed in? Perhaps
// one of the construction parameters should be the time passed by the
// caller, who would know for sure.
result.timeStampSeconds = GetMessageTime() / 1000.0;
result.button = WebMouseEvent::ButtonNone;
// Get key state, coordinates, and wheel delta from event.
typedef SHORT (WINAPI *GetKeyStateFunction)(int key);
GetKeyStateFunction getKeyState;
UINT keyState;
float wheelDelta;
bool horizontalScroll = false;
if ((message == WM_VSCROLL) || (message == WM_HSCROLL)) {
// Synthesize mousewheel event from a scroll event. This is needed to
// simulate middle mouse scrolling in some laptops. Use GetAsyncKeyState
// for key state since we are synthesizing the input event.
getKeyState = GetAsyncKeyState;
keyState = 0;
if (getKeyState(VK_SHIFT))
keyState |= MK_SHIFT;
if (getKeyState(VK_CONTROL))
keyState |= MK_CONTROL;
// NOTE: There doesn't seem to be a way to query the mouse button state
// in this case.
POINT cursorPosition = {0};
GetCursorPos(&cursorPosition);
result.globalX = cursorPosition.x;
result.globalY = cursorPosition.y;
switch (LOWORD(wparam)) {
case SB_LINEUP: // == SB_LINELEFT
wheelDelta = WHEEL_DELTA;
break;
case SB_LINEDOWN: // == SB_LINERIGHT
wheelDelta = -WHEEL_DELTA;
break;
case SB_PAGEUP:
wheelDelta = 1;
result.scrollByPage = true;
break;
case SB_PAGEDOWN:
wheelDelta = -1;
result.scrollByPage = true;
break;
default: // We don't supoprt SB_THUMBPOSITION or SB_THUMBTRACK here.
wheelDelta = 0;
break;
}
if (message == WM_HSCROLL)
horizontalScroll = true;
} else {
// Non-synthesized event; we can just read data off the event.
getKeyState = GetKeyState;
keyState = GET_KEYSTATE_WPARAM(wparam);
result.globalX = static_cast<short>(LOWORD(lparam));
result.globalY = static_cast<short>(HIWORD(lparam));
wheelDelta = static_cast<float>(GET_WHEEL_DELTA_WPARAM(wparam));
if (message == WM_MOUSEHWHEEL) {
horizontalScroll = true;
wheelDelta = -wheelDelta; // Windows is <- -/+ ->, WebKit <- +/- ->.
}
}
if (keyState & MK_SHIFT)
horizontalScroll = true;
// Set modifiers based on key state.
if (keyState & MK_SHIFT)
result.modifiers |= WebInputEvent::ShiftKey;
if (keyState & MK_CONTROL)
result.modifiers |= WebInputEvent::ControlKey;
if (getKeyState(VK_MENU) & 0x8000)
result.modifiers |= WebInputEvent::AltKey;
if (keyState & MK_LBUTTON)
result.modifiers |= WebInputEvent::LeftButtonDown;
if (keyState & MK_MBUTTON)
result.modifiers |= WebInputEvent::MiddleButtonDown;
if (keyState & MK_RBUTTON)
result.modifiers |= WebInputEvent::RightButtonDown;
// Set coordinates by translating event coordinates from screen to client.
POINT clientPoint = { result.globalX, result.globalY };
MapWindowPoints(0, hwnd, &clientPoint, 1);
result.x = clientPoint.x;
result.y = clientPoint.y;
result.windowX = result.x;
result.windowY = result.y;
// Convert wheel delta amount to a number of pixels to scroll.
//
// How many pixels should we scroll per line? Gecko uses the height of the
// current line, which means scroll distance changes as you go through the
// page or go to different pages. IE 7 is ~50 px/line, although the value
// seems to vary slightly by page and zoom level. Since IE 7 has a smoothing
// algorithm on scrolling, it can get away with slightly larger scroll values
// without feeling jerky. Here we use 100 px per three lines (the default
// scroll amount is three lines per wheel tick).
static const float scrollbarPixelsPerLine = 100.0f / 3.0f;
wheelDelta /= WHEEL_DELTA;
float scrollDelta = wheelDelta;
if (horizontalScroll) {
unsigned long scrollChars = defaultScrollCharsPerWheelDelta;
SystemParametersInfo(SPI_GETWHEELSCROLLCHARS, 0, &scrollChars, 0);
// TODO(pkasting): Should probably have a different multiplier
// scrollbarPixelsPerChar here.
scrollDelta *= static_cast<float>(scrollChars) * scrollbarPixelsPerLine;
} else {
unsigned long scrollLines = defaultScrollLinesPerWheelDelta;
SystemParametersInfo(SPI_GETWHEELSCROLLLINES, 0, &scrollLines, 0);
if (scrollLines == WHEEL_PAGESCROLL)
result.scrollByPage = true;
if (!result.scrollByPage)
scrollDelta *= static_cast<float>(scrollLines) * scrollbarPixelsPerLine;
}
// Set scroll amount based on above calculations. WebKit expects positive
// deltaY to mean "scroll up" and positive deltaX to mean "scroll left".
if (horizontalScroll) {
result.deltaX = scrollDelta;
result.wheelTicksX = wheelDelta;
} else {
result.deltaY = scrollDelta;
result.wheelTicksY = wheelDelta;
}
return result;
}
bool CGUIDialogKeyboardGeneric::OnAction(const CAction &action)
{
bool handled(true);
if (action.GetID() == ACTION_BACKSPACE)
{
Backspace();
}
else if (action.GetID() == ACTION_ENTER)
{
OnOK();
}
else if (action.GetID() == ACTION_CURSOR_LEFT)
{
MoveCursor( -1);
}
else if (action.GetID() == ACTION_CURSOR_RIGHT)
{
if (m_strEditing.IsEmpty() && (unsigned int) GetCursorPos() == m_strEdit.size() && (m_strEdit.size() == 0 || m_strEdit[m_strEdit.size() - 1] != ' '))
{ // add a space
Character(L' ');
}
else
MoveCursor(1);
}
else if (action.GetID() == ACTION_SHIFT)
{
OnShift();
}
else if (action.GetID() == ACTION_SYMBOLS)
{
OnSymbols();
}
else if (action.GetID() >= REMOTE_0 && action.GetID() <= REMOTE_9)
{
OnRemoteNumberClick(action.GetID());
}
else if (action.GetID() == ACTION_PASTE)
{
OnPasteClipboard();
}
else if (action.GetID() >= KEY_VKEY && action.GetID() < KEY_ASCII)
{ // input from the keyboard (vkey, not ascii)
if (!m_strEditing.IsEmpty())
return handled;
uint8_t b = action.GetID() & 0xFF;
if (b == XBMCVK_HOME)
{
SetCursorPos(0);
}
else if (b == XBMCVK_END)
{
SetCursorPos(m_strEdit.GetLength());
}
else if (b == XBMCVK_LEFT)
{
MoveCursor( -1);
}
else if (b == XBMCVK_RIGHT)
{
MoveCursor(1);
}
else if (b == XBMCVK_RETURN || b == XBMCVK_NUMPADENTER)
{
OnOK();
}
else if (b == XBMCVK_DELETE)
{
if (GetCursorPos() < m_strEdit.GetLength())
{
MoveCursor(1);
Backspace();
}
}
else if (b == XBMCVK_BACK) Backspace();
else if (b == XBMCVK_ESCAPE) Close();
}
else if (action.GetID() >= KEY_ASCII)
{ // input from the keyboard
//char ch = action.GetID() & 0xFF;
int ch = action.GetUnicode();
// Ignore non-printing characters
if ( !((0 <= ch && ch < 0x8) || (0xE <= ch && ch < 0x1B) || (0x1C <= ch && ch < 0x20)) )
{
switch (ch)
{
case 0x8: // backspace
Backspace();
break;
case 0x9: // Tab (do nothing)
case 0xB: // Non-printing character, ignore
case 0xC: // Non-printing character, ignore
break;
case 0xA: // enter
case 0xD: // enter
OnOK();
break;
case 0x1B: // escape
Close();
break;
case 0x7F: // Delete
if (GetCursorPos() < m_strEdit.GetLength())
{
MoveCursor(1);
Backspace();
}
break;
default: //use character input
// When we support text input method, we only accept text by gui text message.
if (!g_Windowing.IsTextInputEnabled())
Character(action.GetUnicode());
break;
}
}
}
else // unhandled by us - let's see if the baseclass wants it
handled = CGUIDialog::OnAction(action);
if (handled && m_pCharCallback)
{ // we did _something_, so make sure our search message filter is reset
m_pCharCallback(this, GetText());
}
return handled;
}
//--------------------------------------------------------------------------------------//
void CBCGPDragFrameImpl::MoveDragFrame (BOOL bForceMove)
{
ASSERT_VALID (m_pDraggedWnd);
m_pFinalTargetBar = NULL;
if (m_pDraggedWnd == NULL || m_pDockManager == NULL)
{
return;
}
if (m_pWndDummy == NULL)
{
m_pWndDummy = new CBCGPDummyDockingControlBar;
m_pWndDummy->CreateEx (0, _T (""), BCGCBProGetTopLevelFrame (m_pDraggedWnd), CRect (0, 0, 0, 0),
FALSE, BCGP_DUMMY_WND_ID, WS_CHILD);
}
CSize szSencitivity = CBCGPDockingControlBar::GetDragSencitivity ();
CPoint ptMouse;
GetCursorPos (&ptMouse);
CPoint ptOffset = ptMouse - m_ptHot;
if (abs (ptOffset.x) < szSencitivity.cx &&
abs (ptOffset.y) < szSencitivity.cy &&
m_rectDrag.IsRectEmpty () && !bForceMove)
{
return;
}
m_bDragStarted = TRUE;
m_pDockManager->LockUpdate (TRUE);
CRect rectOld = m_rectExpectedDocked.IsRectEmpty () ? m_rectDrag : m_rectExpectedDocked;
BOOL bFirstTime = FALSE;
if (m_rectDrag.IsRectEmpty ())
{
if (m_pDraggedWnd->IsKindOf (RUNTIME_CLASS (CBCGPMiniFrameWnd)))
{
m_pDraggedWnd->GetWindowRect (m_rectDrag);
}
else if (m_pDraggedWnd->IsKindOf (RUNTIME_CLASS (CBCGPControlBar)))
{
CBCGPControlBar* pBar =
DYNAMIC_DOWNCAST (CBCGPControlBar, m_pDraggedWnd);
ASSERT_VALID (pBar);
m_pDraggedWnd->GetWindowRect (m_rectDrag);
// if the bar is docked then the floating rect has to be set to recent floating rect
if (pBar->GetParentMiniFrame () == NULL)
{
m_rectDrag.right =
m_rectDrag.left + pBar->m_recentDockInfo.m_rectRecentFloatingRect.Width ();
m_rectDrag.bottom =
m_rectDrag.top + pBar->m_recentDockInfo.m_rectRecentFloatingRect.Height ();
}
if (!m_rectDrag.PtInRect (m_ptHot))
{
int nOffset = m_rectDrag.left - m_ptHot.x;
m_rectDrag.OffsetRect (-nOffset - 5, 0); // offset of mouse pointer
// from the drag rect bound
}
}
bFirstTime = TRUE;
}
BOOL bDrawTab = FALSE;
CBCGPDockingControlBar* pOldTargetBar = m_pTargetBar;
CRect rectExpected; rectExpected.SetRectEmpty ();
CBCGPSmartDockingManager* pSDManager = NULL;
BOOL bSDockingIsOn = FALSE;
if (m_pDockManager != NULL
&& (pSDManager = m_pDockManager->GetSDManagerPermanent()) != NULL
&& pSDManager->IsStarted())
{
bSDockingIsOn = TRUE;
}
m_pDockManager->CalcExpectedDockedRect (m_pDraggedWnd, ptMouse,
rectExpected, bDrawTab, &m_pTargetBar);
if (pOldTargetBar != NULL && m_nInsertedTabID != -1 &&
(pOldTargetBar != m_pTargetBar || !bDrawTab))
{
RemoveTabPreDocking (pOldTargetBar);
bFirstTime = TRUE;
}
BOOL bCanBeAttached = TRUE;
if (m_pDraggedWnd->IsKindOf (RUNTIME_CLASS (CBCGPMiniFrameWnd)))
{
}
else if (m_pDraggedWnd->IsKindOf (RUNTIME_CLASS (CBCGPControlBar)))
{
CBCGPControlBar* pBar =
DYNAMIC_DOWNCAST (CBCGPControlBar, m_pDraggedWnd);
bCanBeAttached = pBar->CanBeAttached ();
}
if (m_pTargetBar != NULL && bCanBeAttached)
{
CBCGPBaseTabbedBar* pTabbedBar =
DYNAMIC_DOWNCAST (CBCGPBaseTabbedBar, m_pTargetBar);
if (pTabbedBar != NULL && bDrawTab &&
(pTabbedBar->GetVisibleTabsNum () > 1 && pTabbedBar->IsHideSingleTab () ||
pTabbedBar->GetVisibleTabsNum () > 0 && !pTabbedBar->IsHideSingleTab ()))
{
PlaceTabPreDocking (pTabbedBar, bFirstTime);
return;
}
else if (bDrawTab)
{
if (m_nInsertedTabID != -1)
{
return;
}
if (!bFirstTime)
{
EndDrawDragFrame (FALSE);
}
DrawFrameTab (m_pTargetBar, FALSE);
m_nInsertedTabID = 1;
return;
}
}
m_rectDrag.OffsetRect (ptOffset);
m_ptHot = ptMouse;
m_rectExpectedDocked = rectExpected;
int nNewThickness = m_rectExpectedDocked.IsRectEmpty ()?
globalData.m_nDragFrameThiknessFloat :
globalData.m_nDragFrameThiknessDock;
CRect rectDocked;
if (m_rectExpectedDocked.IsRectEmpty ())
{
if (!m_rectDrag.PtInRect (ptMouse))
{
CPoint ptMiddleRect (m_rectDrag.TopLeft ().x + m_rectDrag.Width () / 2,
m_rectDrag.top + 5);
CPoint ptOffset = ptMouse - ptMiddleRect;
m_rectDrag.OffsetRect (ptOffset);
}
rectDocked = m_rectDrag;
}
else
{
rectDocked = m_rectExpectedDocked;
}
if (!bSDockingIsOn || !m_rectExpectedDocked.IsRectEmpty ())
{
DrawDragFrame (rectOld, rectDocked, bFirstTime, nNewThickness, m_nOldThikness);
m_nOldThikness = nNewThickness;
}
}
bool CGUIDialogKeyboard::OnAction(const CAction &action)
{
// check if we're doing a search, and if so, interrupt the search timer.
DWORD now = timeGetTime();
if (m_lastSearchUpdate || m_lastSearchUpdate + SEARCH_DELAY >= now)
m_lastSearchUpdate = now;
if (action.wID == ACTION_BACKSPACE
#ifdef __APPLE__
|| action.wID == ACTION_PARENT_DIR
#endif
)
{
Backspace();
return true;
}
else if (action.wID == ACTION_ENTER)
{
OnOK();
return true;
}
else if (action.wID == ACTION_CURSOR_LEFT)
{
MoveCursor( -1);
return true;
}
else if (action.wID == ACTION_CURSOR_RIGHT)
{
if ((unsigned int) GetCursorPos() == m_strEdit.size() && (m_strEdit.size() == 0 || m_strEdit[m_strEdit.size() - 1] != ' '))
{ // add a space
Character(L' ');
}
else
MoveCursor(1);
return true;
}
else if (action.wID == ACTION_SHIFT)
{
OnShift();
return true;
}
else if (action.wID == ACTION_SYMBOLS)
{
OnSymbols();
return true;
}
else if (action.wID >= REMOTE_0 && action.wID <= REMOTE_9)
{
OnRemoteNumberClick(action.wID);
return true;
}
else if (action.wID >= (WORD)KEY_VKEY && action.wID < (WORD)KEY_ASCII)
{ // input from the keyboard (vkey, not ascii)
BYTE b = action.wID & 0xFF;
if (b == 0x25) MoveCursor( -1); // left
else if (b == 0x27) MoveCursor(1); // right
else if (b == 0x0D) OnOK(); // enter
else if (b == 0x08) Backspace(); // backspace
else if (b == 0x1B) Close(); // escape
else if (b == 0x20) Character(b); // space
return true;
}
else if (action.wID >= KEY_ASCII)
{ // input from the keyboard
//char ch = action.wID & 0xFF;
switch (action.unicode)
{
case 13: // enter
case 10: // enter
OnOK();
break;
case 8: // backspace
Backspace();
break;
case 27: // escape
Close();
break;
default: //use character input
Character(action.unicode);
break;
}
return true;
}
return CGUIDialog::OnAction(action);
}
//
// Process mouse click in the target list. For a worker, assign the selected
// target. For a manager, distribute the assigned targets among its net servers.
//
void CPageNetwork::OnClickTTargets(NMHDR* pNMHDR, LRESULT* pResult)
{
CPoint point;
TV_HITTESTINFO test_info;
TargetSelType state;
// Get the cursor position.
GetCursorPos( &point );
test_info.pt = point;
m_TTargets.ScreenToClient( &(test_info.pt) );
// Check to see whether the cursor is on an item.
m_TTargets.HitTest( &test_info );
// Check that we have an interface item.
if ( !test_info.hItem || !m_TTargets.GetParentItem( test_info.hItem ) )
return;
// A new target assignment is being made. Clear the results since they are
// for a configuration we no longer have.
theApp.pView->ResetDisplayforNewTest();
// Toggle the selection if the control key is pressed.
if ( GetKeyState( VK_CONTROL ) & 0x8000 &&
GetSelectionCheck( test_info.hItem ) == TargetChecked )
{
state = TargetUnChecked;
}
else
{
state = TargetChecked;
}
switch ( theApp.pView->m_pWorkerView->GetSelectedType() )
{
case WORKER:
// All clicks work the same for the worker.
SelectRange( test_info.hItem, test_info.hItem, TRUE, state );
break;
case MANAGER:
// A shift click extends the selection from the last selected item
// to the currently focused item. When the control key is also
// pressed, any previous selection is not cleared.
if ( (GetKeyState( VK_SHIFT ) & 0x8000 ) && selected )
{
// We have a previous item (not the first click) and the shift
// key is down.
SelectRange( selected, test_info.hItem,
!(GetKeyState( VK_CONTROL ) & 0x8000) );
}
else if ( GetKeyState( VK_CONTROL ) & 0x8000 )
{
// The control key is down.
SelectRange( test_info.hItem, test_info.hItem, FALSE, state );
}
else
{
SelectRange( test_info.hItem, test_info.hItem, TRUE, state );
}
break;
default:
ErrorMessage( "Unexpected selection type in CPageNetwork::"
"OnClickTTargets()." );
return;
}
// immediately refresh the display (create/delete NetClients as needed)
StoreTargetSelection();
ShowSettings();
EnableWindow();
*pResult = 0;
}
void CNewRandom::Initialize()
{
++g_dwNewRandomInstanceCounter;
DWORD dw;
dw = timeGetTime();
AddRandomObject(&dw, 4);
LARGE_INTEGER li;
QueryPerformanceCounter(&li);
AddRandomObject(&li, sizeof(LARGE_INTEGER));
SYSTEMTIME st;
ZeroMemory(&st, sizeof(SYSTEMTIME));
GetLocalTime(&st);
AddRandomObject(&st, sizeof(SYSTEMTIME));
POINT pt;
GetCursorPos(&pt);
AddRandomObject(&pt, sizeof(POINT));
WORD ww;
ww = (WORD)(rand());
AddRandomObject(&ww, 2);
ww = (WORD)(rand());
AddRandomObject(&ww, 2);
ww = (WORD)(rand());
AddRandomObject(&ww, 2);
GetCaretPos(&pt);
AddRandomObject(&pt, sizeof(POINT));
MEMORYSTATUS ms;
GlobalMemoryStatus(&ms);
AddRandomObject(&ms, sizeof(MEMORYSTATUS));
dw = (DWORD)(UINT_PTR)GetActiveWindow();
AddRandomObject(&dw, 4);
dw = (DWORD)(UINT_PTR)GetCapture();
AddRandomObject(&dw, 4);
dw = (DWORD)(UINT_PTR)GetClipboardOwner();
AddRandomObject(&dw, 4);
#ifndef _WIN32_WCE
// No support under Windows CE
dw = (DWORD)(UINT_PTR)GetClipboardViewer();
AddRandomObject(&dw, 4);
#endif
dw = GetCurrentProcessId();
AddRandomObject(&dw, 4);
dw = (DWORD)(UINT_PTR)GetCurrentProcess();
AddRandomObject(&dw, 4);
dw = (DWORD)(UINT_PTR)GetActiveWindow();
AddRandomObject(&dw, 4);
dw = GetCurrentThreadId();
AddRandomObject(&dw, 4);
dw = (DWORD)(UINT_PTR)GetCurrentThread();
AddRandomObject(&dw, 4);
dw = (DWORD)(UINT_PTR)GetDesktopWindow();
AddRandomObject(&dw, 4);
dw = (DWORD)(UINT_PTR)GetFocus();
AddRandomObject(&dw, 4);
dw = (DWORD)(UINT_PTR)GetForegroundWindow();
AddRandomObject(&dw, 4);
#ifndef _WIN32_WCE
dw = (DWORD)GetInputState();
AddRandomObject(&dw, 4);
#endif
dw = GetMessagePos();
AddRandomObject(&dw, 4);
#ifndef _WIN32_WCE
dw = (DWORD)GetMessageTime();
AddRandomObject(&dw, 4);
#endif
dw = (DWORD)(UINT_PTR)GetOpenClipboardWindow();
AddRandomObject(&dw, 4);
dw = (DWORD)(UINT_PTR)GetProcessHeap();
AddRandomObject(&dw, 4);
SYSTEM_INFO si;
GetSystemInfo(&si);
AddRandomObject(&si, sizeof(SYSTEM_INFO));
dw = (DWORD)randXorShift();
AddRandomObject(&dw, 4);
#ifndef _WIN32_WCE
STARTUPINFO sui;
GetStartupInfo(&sui);
AddRandomObject(&sui, sizeof(STARTUPINFO));
#endif
GUID guid;
VERIFY(CoCreateGuid(&guid) == S_OK);
AddRandomObject(&guid, sizeof(GUID));
BYTE pbCrypt[64];
CNewRandom::SysCryptGetRandom(&pbCrypt[0], 64);
AddRandomObject(&pbCrypt[0], 64);
AddRandomObject(&g_dwNewRandomInstanceCounter, 4);
}
INT_PTR CALLBACK DlgProcIconImport(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
static HWND hwndParent, hwndDragOver;
static int dragging;
static int dragItem, dropHiLite;
static HWND hPreview = NULL;
switch (msg) {
case WM_INITDIALOG:
TranslateDialogDefault(hwndDlg);
hwndParent = (HWND)lParam;
hPreview = GetDlgItem(hwndDlg, IDC_PREVIEW);
dragging = dragItem = 0;
ListView_SetImageList(hPreview, ImageList_Create(GetSystemMetrics(SM_CXSMICON), GetSystemMetrics(SM_CYSMICON), ILC_COLOR32|ILC_MASK, 0, 100), LVSIL_NORMAL);
ListView_SetIconSpacing(hPreview, 56, 67);
{
RECT rcThis, rcParent;
int cxScreen = GetSystemMetrics(SM_CXSCREEN);
GetWindowRect(hwndDlg, &rcThis);
GetWindowRect(hwndParent, &rcParent);
OffsetRect(&rcThis, rcParent.right-rcThis.left, 0);
OffsetRect(&rcThis, 0, rcParent.top-rcThis.top);
GetWindowRect(GetParent(hwndParent), &rcParent);
if (rcThis.right > cxScreen) {
OffsetRect(&rcParent, cxScreen-rcThis.right, 0);
OffsetRect(&rcThis, cxScreen-rcThis.right, 0);
MoveWindow(GetParent(hwndParent), rcParent.left, rcParent.top, rcParent.right-rcParent.left, rcParent.bottom-rcParent.top, TRUE);
}
MoveWindow(hwndDlg, rcThis.left, rcThis.top, rcThis.right-rcThis.left, rcThis.bottom-rcThis.top, FALSE);
GetClientRect(hwndDlg, &rcThis);
SendMessage(hwndDlg, WM_SIZE, 0, MAKELPARAM(rcThis.right-rcThis.left, rcThis.bottom-rcThis.top));
}
SHAutoComplete( GetDlgItem(hwndDlg, IDC_ICONSET), 1);
SetDlgItemText(hwndDlg, IDC_ICONSET, _T("icons.dll"));
return TRUE;
case DM_REBUILDICONSPREVIEW:
{
MySetCursor(IDC_WAIT);
ListView_DeleteAllItems(hPreview);
HIMAGELIST hIml = ListView_GetImageList(hPreview, LVSIL_NORMAL);
ImageList_RemoveAll(hIml);
TCHAR filename[MAX_PATH], caption[64];
GetDlgItemText(hwndDlg, IDC_ICONSET, filename, SIZEOF(filename));
{
RECT rcPreview, rcGroup;
GetWindowRect(hPreview, &rcPreview);
GetWindowRect( GetDlgItem(hwndDlg, IDC_IMPORTMULTI), &rcGroup);
//SetWindowPos(hPreview, 0, 0, 0, rcPreview.right-rcPreview.left, rcGroup.bottom-rcPreview.top, SWP_NOZORDER|SWP_NOMOVE);
}
if ( _taccess(filename, 0) != 0) {
MySetCursor(IDC_ARROW);
break;
}
LVITEM lvi;
lvi.mask = LVIF_TEXT|LVIF_IMAGE|LVIF_PARAM;
lvi.iSubItem = 0;
lvi.iItem = 0;
int count = (int)_ExtractIconEx(filename, -1, 16, 16, NULL, LR_DEFAULTCOLOR);
for (int i=0; i < count; lvi.iItem++, i++) {
mir_sntprintf(caption, SIZEOF(caption), _T("%d"), i+1);
lvi.pszText = caption;
HICON hIcon;
_ExtractIconEx(filename, i, 16, 16, &hIcon, LR_DEFAULTCOLOR);
lvi.iImage = ImageList_AddIcon(hIml, hIcon);
DestroyIcon(hIcon);
lvi.lParam = i;
ListView_InsertItem(hPreview, &lvi);
}
MySetCursor(IDC_ARROW);
}
break;
case WM_COMMAND:
switch(LOWORD(wParam)) {
case IDC_BROWSE:
{
TCHAR str[MAX_PATH], *file;
GetDlgItemText(hwndDlg, IDC_ICONSET, str, SIZEOF(str));
if (!(file = OpenFileDlg(GetParent(hwndDlg), str, TRUE)))
break;
SetDlgItemText(hwndDlg, IDC_ICONSET, file);
SAFE_FREE((void**)&file);
}
break;
case IDC_GETMORE:
OpenIconsPage();
break;
case IDC_ICONSET:
if (HIWORD(wParam) == EN_CHANGE)
SendMessage(hwndDlg, DM_REBUILDICONSPREVIEW, 0, 0);
break;
}
break;
case WM_MOUSEMOVE:
if (dragging) {
LVHITTESTINFO lvhti;
int onItem = 0;
HWND hwndOver;
RECT rc;
POINT ptDrag;
HWND hPPreview = GetDlgItem(hwndParent, IDC_PREVIEW);
lvhti.pt.x = (short)LOWORD(lParam); lvhti.pt.y = (short)HIWORD(lParam);
ClientToScreen(hwndDlg, &lvhti.pt);
hwndOver = WindowFromPoint(lvhti.pt);
GetWindowRect(hwndOver, &rc);
ptDrag.x = lvhti.pt.x - rc.left; ptDrag.y = lvhti.pt.y - rc.top;
if (hwndOver != hwndDragOver) {
ImageList_DragLeave(hwndDragOver);
hwndDragOver = hwndOver;
ImageList_DragEnter(hwndDragOver, ptDrag.x, ptDrag.y);
}
ImageList_DragMove(ptDrag.x, ptDrag.y);
if (hwndOver == hPPreview) {
ScreenToClient(hPPreview, &lvhti.pt);
if (ListView_HitTest(hPPreview, &lvhti) != -1) {
if (lvhti.iItem != dropHiLite) {
ImageList_DragLeave(hwndDragOver);
if (dropHiLite != -1)
ListView_SetItemState(hPPreview, dropHiLite, 0, LVIS_DROPHILITED);
dropHiLite = lvhti.iItem;
ListView_SetItemState(hPPreview, dropHiLite, LVIS_DROPHILITED, LVIS_DROPHILITED);
UpdateWindow(hPPreview);
ImageList_DragEnter(hwndDragOver, ptDrag.x, ptDrag.y);
}
onItem = 1;
}
}
if (!onItem && dropHiLite != -1) {
ImageList_DragLeave(hwndDragOver);
ListView_SetItemState(hPPreview, dropHiLite, 0, LVIS_DROPHILITED);
UpdateWindow(hPPreview);
ImageList_DragEnter(hwndDragOver, ptDrag.x, ptDrag.y);
dropHiLite = -1;
}
MySetCursor(onItem ? IDC_ARROW : IDC_NO);
}
break;
case WM_LBUTTONUP:
if (dragging) {
ReleaseCapture();
ImageList_EndDrag();
dragging = 0;
if (dropHiLite != -1) {
TCHAR path[MAX_PATH], fullPath[MAX_PATH], filename[MAX_PATH];
LVITEM lvi;
GetDlgItemText(hwndDlg, IDC_ICONSET, fullPath, SIZEOF(fullPath));
PathToRelativeT(fullPath, filename);
lvi.mask = LVIF_PARAM;
lvi.iItem = dragItem; lvi.iSubItem = 0;
ListView_GetItem(hPreview, &lvi);
mir_sntprintf(path, SIZEOF(path), _T("%s,%d"), filename, (int)lvi.lParam);
SendMessage(hwndParent, DM_CHANGEICON, dropHiLite, (LPARAM)path);
ListView_SetItemState( GetDlgItem(hwndParent, IDC_PREVIEW), dropHiLite, 0, LVIS_DROPHILITED);
}
}
break;
case WM_NOTIFY:
switch (((LPNMHDR)lParam)->idFrom) {
case IDC_PREVIEW:
switch (((LPNMHDR)lParam)->code) {
case LVN_BEGINDRAG:
SetCapture(hwndDlg);
dragging = 1;
dragItem = ((LPNMLISTVIEW)lParam)->iItem;
dropHiLite = -1;
ImageList_BeginDrag(ListView_GetImageList(hPreview, LVSIL_NORMAL), dragItem, GetSystemMetrics(SM_CXICON)/2, GetSystemMetrics(SM_CYICON)/2);
{
POINT pt;
RECT rc;
GetCursorPos(&pt);
GetWindowRect(hwndDlg, &rc);
ImageList_DragEnter(hwndDlg, pt.x - rc.left, pt.y - rc.top);
hwndDragOver = hwndDlg;
}
break;
}
break;
}
break;
case WM_SIZE: // make the dlg resizeable
if (!IsIconic(hwndDlg)) {
UTILRESIZEDIALOG urd = {0};
urd.cbSize = sizeof(urd);
urd.hInstance = hInst;
urd.hwndDlg = hwndDlg;
urd.lParam = 0; // user-defined
urd.lpTemplate = MAKEINTRESOURCEA(IDD_ICOLIB_IMPORT);
urd.pfnResizer = IconDlg_Resize;
CallService(MS_UTILS_RESIZEDIALOG, 0, (LPARAM)&urd);
}
break;
case WM_CLOSE:
DestroyWindow(hwndDlg);
EnableWindow( GetDlgItem(hwndParent, IDC_IMPORT), TRUE);
break;
}
return FALSE;
}
static int
gather_random_fast( void (*add)(const void*, size_t, int), int requester )
{
static int addedFixedItems = 0;
if ( debug_me )
log_debug ("rndw32#gather_random_fast: req=%d\n", requester );
/* Get various basic pieces of system information: Handle of active
* window, handle of window with mouse capture, handle of clipboard owner
* handle of start of clpboard viewer list, pseudohandle of current
* process, current process ID, pseudohandle of current thread, current
* thread ID, handle of desktop window, handle of window with keyboard
* focus, whether system queue has any events, cursor position for last
* message, 1 ms time for last message, handle of window with clipboard
* open, handle of process heap, handle of procs window station, types of
* events in input queue, and milliseconds since Windows was started */
{ byte buffer[20*sizeof(ulong)], *bufptr;
bufptr = buffer;
#define ADD(f) do { ulong along = (ulong)(f); \
memcpy (bufptr, &along, sizeof (along) ); \
bufptr += sizeof (along); } while (0)
ADD ( GetActiveWindow ());
ADD ( GetCapture ());
ADD ( GetClipboardOwner ());
ADD ( GetClipboardViewer ());
ADD ( GetCurrentProcess ());
ADD ( GetCurrentProcessId ());
ADD ( GetCurrentThread ());
ADD ( GetCurrentThreadId ());
ADD ( GetDesktopWindow ());
ADD ( GetFocus ());
ADD ( GetInputState ());
ADD ( GetMessagePos ());
ADD ( GetMessageTime ());
ADD ( GetOpenClipboardWindow ());
ADD ( GetProcessHeap ());
ADD ( GetProcessWindowStation ());
ADD ( GetQueueStatus (QS_ALLEVENTS));
ADD ( GetTickCount ());
assert ( bufptr-buffer < sizeof (buffer) );
(*add) ( buffer, bufptr-buffer, requester );
#undef ADD
}
/* Get multiword system information: Current caret position, current
* mouse cursor position */
{ POINT point;
GetCaretPos (&point);
(*add) ( &point, sizeof (point), requester );
GetCursorPos (&point);
(*add) ( &point, sizeof (point), requester );
}
/* Get percent of memory in use, bytes of physical memory, bytes of free
* physical memory, bytes in paging file, free bytes in paging file, user
* bytes of address space, and free user bytes */
{ MEMORYSTATUS memoryStatus;
memoryStatus.dwLength = sizeof (MEMORYSTATUS);
GlobalMemoryStatus (&memoryStatus);
(*add) ( &memoryStatus, sizeof (memoryStatus), requester );
}
/* Get thread and process creation time, exit time, time in kernel mode,
and time in user mode in 100ns intervals */
{ HANDLE handle;
FILETIME creationTime, exitTime, kernelTime, userTime;
DWORD minimumWorkingSetSize, maximumWorkingSetSize;
handle = GetCurrentThread ();
GetThreadTimes (handle, &creationTime, &exitTime,
&kernelTime, &userTime);
(*add) ( &creationTime, sizeof (creationTime), requester );
(*add) ( &exitTime, sizeof (exitTime), requester );
(*add) ( &kernelTime, sizeof (kernelTime), requester );
(*add) ( &userTime, sizeof (userTime), requester );
handle = GetCurrentProcess ();
GetProcessTimes (handle, &creationTime, &exitTime,
&kernelTime, &userTime);
(*add) ( &creationTime, sizeof (creationTime), requester );
(*add) ( &exitTime, sizeof (exitTime), requester );
(*add) ( &kernelTime, sizeof (kernelTime), requester );
(*add) ( &userTime, sizeof (userTime), requester );
/* Get the minimum and maximum working set size for the current process */
GetProcessWorkingSetSize (handle, &minimumWorkingSetSize,
&maximumWorkingSetSize);
(*add) ( &minimumWorkingSetSize,
sizeof (&minimumWorkingSetSize), requester );
(*add) ( &maximumWorkingSetSize,
sizeof (&maximumWorkingSetSize), requester );
}
/* The following are fixed for the lifetime of the process so we only
* add them once */
if (!addedFixedItems) {
STARTUPINFO startupInfo;
/* Get name of desktop, console window title, new window position and
* size, window flags, and handles for stdin, stdout, and stderr */
startupInfo.cb = sizeof (STARTUPINFO);
GetStartupInfo (&startupInfo);
(*add) ( &startupInfo, sizeof (STARTUPINFO), requester );
addedFixedItems = 1;
}
/* The performance of QPC varies depending on the architecture it's
* running on and on the OS. Under NT it reads the CPU's 64-bit timestamp
* counter (at least on a Pentium and newer '486's, it hasn't been tested
* on anything without a TSC), under Win95 it reads the 1.193180 MHz PIC
* timer. There are vague mumblings in the docs that it may fail if the
* appropriate hardware isn't available (possibly '386's or MIPS machines
* running NT), but who's going to run NT on a '386? */
{ LARGE_INTEGER performanceCount;
if (QueryPerformanceCounter (&performanceCount)) {
if ( debug_me )
log_debug ("rndw32#gather_random_fast: perf data\n");
(*add) (&performanceCount, sizeof (&performanceCount), requester);
}
else { /* Millisecond accuracy at best... */
DWORD aword = GetTickCount ();
(*add) (&aword, sizeof (aword), requester );
}
}
return 0;
}
void doFlyEffect(LICE_IBitmap *fb, HWND hwnd)
{
static int initted;
if (!initted)
{
initted=1;
cam = new pl_Cam;
cam->Fov=90.0;
cam->WantZBuffer=true;
if (cam->WantZBuffer) cam->Sort = -1;
cam->Y = 800; // move the camera up from the ground
cam->Pitch = 180.0;
setup_materials(mat); // intialize materials and palette
land = setup_landscape(mat[0],mat[1],mat[2]); // create landscape
sky = land->Children.Get(0); // unhierarchicalize the sky from the land
land->Children.Delete(0);
sky2 = land->Children.Get(0);
land->Children.Delete(0);
int x;
for(x=0; x<sizeof(lights)/sizeof(lights[0]); x++)
{
lights[x].Set(PL_LIGHT_POINT,(x%4 - 1.5) * LAND_SIZE /4.0,
500+(rand()%1000),
(x/4-1.5)*LAND_SIZE/4.0,(rand()%1000)/700.0,(rand()%1000)/700.0,(rand()%1000)/700.0,LAND_SIZE*1.0);
}
}
LICE_Clear(fb,0);
cam->Begin(fb);
int x;
for(x=0; x<sizeof(lights)/sizeof(lights[0]); x++)
cam->RenderLight(&lights[x]);
// lots of rendering special casing
if (draw_sky) { // if we're drawing the sky
if (cam->Y > 2000) { // if above the sky, only render the skies, with
// no far clip plane
cam->RenderObject(sky);
cam->RenderObject(sky2);
} else { // otherwise, render the sky (but not the second sky),
// and the land, with a far clip plane
cam->RenderObject(sky);
cam->RenderObject(land);
}
} else { // not drawing sky, just render the land
cam->RenderObject(land);
}
cam->End(); // finish rendering
static POINT lpos;
POINT p;
GetCursorPos(&p);
int mouse_x = 0;
int mouse_y = 0;
int mouse_b=0;
if (hwnd)
{
mouse_x = p.x-lpos.x;
mouse_y = p.y-lpos.y;
if (GetAsyncKeyState(VK_LBUTTON)&0x8000) mouse_b|=2;
RECT r;
GetWindowRect(hwnd,&r);
p.x=(r.right+r.left)/2;
p.y=(r.bottom+r.top)/2;
SetCursorPos(p.x,p.y);
}
lpos=p;
// We calculate the amount of time in thousanths of seconds this frame took
double prevtime = 10; //((uclock() / (float) UCLOCKS_PER_SEC) - prevtime)*1000.0;
if (mouse_b & 2) { // if right button hit, we go forward quickly
cam->X -=
prevtime*4*sin(cam->Pan*PL_PI/180.0)*cos(cam->Pitch*PL_PI/180.0);
cam->Z +=
prevtime*4*cos(cam->Pan*PL_PI/180.0)*cos(cam->Pitch*PL_PI/180.0);
cam->Y +=
prevtime*4*sin(cam->Pitch*PL_PI/180.0);
} else if (mouse_b & 1) { // if left button hit, we go forward slowly
cam->X -=
prevtime*2*sin(cam->Pan*PL_PI/180.0)*cos(cam->Pitch*PL_PI/180.0);
cam->Z +=
prevtime*2*cos(cam->Pan*PL_PI/180.0)*cos(cam->Pitch*PL_PI/180.0);
cam->Y +=
prevtime*2*sin(cam->Pitch*PL_PI/180.0);
}
cam->Pitch += (mouse_y*mouse_sens); // update pitch and pan of ship
cam->Pan += (mouse_x*mouse_sens)*(-cos(cam->Pitch*PL_PI/180.0));
if (cam->X > LAND_SIZE/2) cam->X = LAND_SIZE/2; // make sure we don't go
if (cam->X < -LAND_SIZE/2) cam->X = -LAND_SIZE/2; // too far away
if (cam->Z > LAND_SIZE/2) cam->Z = LAND_SIZE/2;
if (cam->Z < -LAND_SIZE/2) cam->Z = -LAND_SIZE/2;
if (cam->Y < 0) cam->Y = 0;
if (cam->Y > 8999) cam->Y = 8999;
#if 0
while (kbhit()) switch(getch()) { // handle keystrokes
case 27:
done++;
break; // ESC == quit
// + is for zooming in.
case '=':
case '+':
cam->Fov -= 1.0;
if (cam->Fov < 1.0) cam->Fov = 1.0;
sprintf(lastmessage,"FOV: %2.f",cam->Fov);
break;
// - is for zooming out
case '-':
cam->Fov += 1.0;
if (cam->Fov > 179.0) cam->Fov = 179.0;
sprintf(lastmessage,"FOV: %2.f",cam->Fov);
break;
// [ decreases mouse sensitivity
case '[':
mouse_sens /= 1.1;
sprintf(lastmessage,"MouseSens: %.3f",mouse_sens);
break;
// ] increases mouse sensitivity
case ']':
mouse_sens *= 1.1;
sprintf(lastmessage,"MouseSens: %.3f",mouse_sens);
break;
// v toggles vsync
case 'v':
wait_vsync ^= 1;
sprintf(lastmessage,"VSync %s",wait_vsync ? "on" : "off");
break;
// s toggles sky
case 's':
draw_sky ^= 1;
sprintf(lastmessage,"Sky %s",draw_sky ? "on" : "off");
break;
}
#endif
//LICE_ScaledBlit(fb,mat[2]->Texture,0,0,fb->getWidth(),fb->getHeight(),0,0,mat[2]->Texture->getWidth(),mat[2]->Texture->getHeight(),1.0f,0);
}
LRESULT CALLBACK DialogProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
switch (message)
{
case WM_INITDIALOG:
Init(hDlg);
return TRUE;
case WM_COMMAND:
{
int id = LOWORD(wParam);
if (id == IDC_BUTTON_START)
{
server.Start();
}
if (id == ID_NOTITYICONMENU_EXIT) // 点击退出菜单，退出应用
{
Shell_NotifyIcon(NIM_DELETE,&g_nid);
EndDialog(hDlg, 0);
}
break;
}
case WM_SYSCOMMAND:
if (wParam == SC_CLOSE) // 暂时隐藏程序，不退出
{
ShowWindow(g_hMainWnd, SW_HIDE);
}
break;
case WM_AIRSOUND_NOTIFY:
if(wParam == IDC_NOTIFYICON)
{
if(lParam == WM_LBUTTONDOWN)
{
ShowWindow(g_hMainWnd, SW_SHOWNORMAL);
SetForegroundWindow(g_hMainWnd);
return TRUE;
}
if (lParam == WM_RBUTTONDOWN)
{
HMENU hMenu = LoadMenu(g_hInst, MAKEINTRESOURCE(IDR_MENU_NOTIFYICON));
POINT point;
GetCursorPos(&point);
TrackPopupMenu(hMenu,
TPM_RIGHTBUTTON,
point.x,
point.y,
0,
g_hMainWnd,
NULL);
PostMessage(g_hMainWnd, WM_NULL, NULL, NULL);
}
}
case WM_PAINT:
{
BOOL bCompEnabled;
DwmIsCompositionEnabled(&bCompEnabled);
if (bCompEnabled)
{
PAINTSTRUCT ps;
HDC hDC = BeginPaint(g_hMainWnd, &ps);
RECT rcClient;
GetClientRect(g_hMainWnd, &rcClient);
HBRUSH hBrush = CreateSolidBrush(RGB(0, 0, 0));
FillRect(hDC, &rcClient, hBrush);
DrawGlowingText(hDC, IDC_STATIC);
EndPaint(g_hMainWnd, &ps);
}
}
break;
}
return FALSE;
}
void
CMainFrame::updateImageInfo()
{
const CFlyCapDoc* pDoc = (CFlyCapDoc*)GetActiveDocument();
CView* pView = (CView*)GetActiveView();
if( m_wndStatusBar &&
pDoc != NULL &&
pView != NULL )
{
char pszText[ 64 ];
if( m_ImageInfoMode == TIMESTAMP )
{
// Setup the timestamp information
FlyCaptureTimestamp timeStamp = pDoc->m_imageRaw.timeStamp;
#if defined (WIN64)
__time64_t tmpTime = timeStamp.ulSeconds;
char* pszTemp = ::_ctime64( &tmpTime );
#elif defined (WIN32)
time_t lTemp = timeStamp.ulSeconds;
char* pszTemp = ::ctime( &lTemp );
#else
#error ** No time conversion **
#endif
if( pszTemp == NULL )
{
return;
}
int iMilliSec = timeStamp.ulMicroSeconds / 1000;
sprintf(
pszText,
"%.19s.%.03d %s (%03u,%04u)\n",
pszTemp,
iMilliSec,
&pszTemp[ 20 ],
timeStamp.ulCycleSeconds,
timeStamp.ulCycleCount );
}
else if( m_ImageInfoMode == CURSOR )
{
// Setup the cursor and image information
CRect rect;
CPoint pt;
COLORREF cr;
int iWidth = 0;
int iHeight = 0;
int iSBOffsetX = 0; // the offset of the horizontal scrollbar
int iSBOffsetY = 0; // the offset of the vertical scrollbar
// get the position of the scroll bars.
// used to calculate the co-ordinates of the image.
iSBOffsetX = pView->GetScrollPos(SB_HORZ);
iSBOffsetY = pView->GetScrollPos(SB_VERT);
pDoc->getImageSize( &iWidth, &iHeight );
CDC* pDC = pView->GetDC();
pDC->GetClipBox( &rect );
GetCursorPos( &pt );
pView->ScreenToClient( &pt );
cr = GetPixel( pDC->GetSafeHdc(), pt.x, pt.y );
pView->ReleaseDC( pDC );
// Check that this window is active and
// that the cursor is within bounds of the clipping rect
if( this == GetActiveWindow() &&
pt.x >= 0 && pt.x < rect.Width() && pt.y >= 0 && pt.y < rect.Height() )
{
sprintf( pszText, "Image(%dx%d) Cursor(%d,%d) RGB(%u,%u,%u)",
iWidth,
iHeight,
pt.x + iSBOffsetX,
pt.y + iSBOffsetY,
cr & 0xFF,
(cr & 0xFF00) >> 8,
(cr & 0xFF0000) >> 16 );
}
static LRESULT CALLBACK EventArea_WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
switch(msg) {
case WM_MEASUREITEM:
{
MEASUREITEMSTRUCT *lpi = (LPMEASUREITEMSTRUCT) lParam;
MENUITEMINFOA mii = {0};
mii.cbSize = sizeof(mii);
mii.fMask = MIIM_DATA | MIIM_ID;
if (GetMenuItemInfoA(g_CluiData.hMenuNotify, lpi->itemID, FALSE, &mii) != 0) {
if (mii.dwItemData == lpi->itemData) {
lpi->itemWidth = 8 + 16;
lpi->itemHeight = 0;
return TRUE;
}
}
}
break;
case WM_DRAWITEM:
{
LPDRAWITEMSTRUCT dis = (LPDRAWITEMSTRUCT) lParam;
if (dis->hwndItem == (HWND) g_CluiData.hMenuNotify) {
NotifyMenuItemExData *nmi = 0;
MENUITEMINFOA mii = {0};
mii.cbSize = sizeof(mii);
mii.fMask = MIIM_DATA;
if (GetMenuItemInfoA(g_CluiData.hMenuNotify, (UINT) dis->itemID, FALSE, &mii) != 0) {
nmi = (NotifyMenuItemExData *) mii.dwItemData;
if (nmi) {
int iIcon = cli_GetContactIcon(nmi->hContact);
ske_ImageList_DrawEx(g_himlCListClc, nmi->iIcon, dis->hDC, 2, (dis->rcItem.bottom + dis->rcItem.top - GetSystemMetrics(SM_CYSMICON)) / 2, GetSystemMetrics(SM_CXSMICON), GetSystemMetrics(SM_CYSMICON), CLR_NONE, CLR_NONE, ILD_NORMAL);
ske_ImageList_DrawEx(g_himlCListClc, iIcon, dis->hDC, 2+GetSystemMetrics(SM_CXSMICON)+2, (dis->rcItem.bottom + dis->rcItem.top - GetSystemMetrics(SM_CYSMICON)) / 2, GetSystemMetrics(SM_CXSMICON), GetSystemMetrics(SM_CYSMICON), CLR_NONE, CLR_NONE, ILD_NORMAL);
return TRUE;
}
}
}
break;
}
case WM_LBUTTONUP:
if (g_CluiData.bEventAreaEnabled)
SendMessage(hwnd, WM_COMMAND, MAKEWPARAM(IDC_NOTIFYBUTTON, 0), 0);
break;
case WM_COMMAND:
if (LOWORD(wParam) == IDC_NOTIFYBUTTON) {
int iSelection;
MENUITEMINFO mii = {0};
POINT pt;
struct NotifyMenuItemExData *nmi = 0;
int iCount = GetMenuItemCount(g_CluiData.hMenuNotify);
BOOL result;
GetCursorPos(&pt);
mii.cbSize = sizeof(mii);
mii.fMask = MIIM_DATA;
if (iCount > 1)
iSelection = TrackPopupMenu(g_CluiData.hMenuNotify, TPM_RETURNCMD, pt.x, pt.y, 0, hwnd, NULL);
else
iSelection = GetMenuItemID(g_CluiData.hMenuNotify, 0);
result = GetMenuItemInfo(g_CluiData.hMenuNotify, (UINT) iSelection, FALSE, &mii);
if (result != 0) {
nmi = (struct NotifyMenuItemExData *) mii.dwItemData;
if (nmi) {
CLISTEVENT *cle = MyGetEvent(iSelection);
if (cle) {
CLISTEVENT *cle1 = NULL;
CallService(cle->pszService, (WPARAM) NULL, (LPARAM) cle);
// re-obtain the pointer, it may already be invalid/point to another event if the
// event we're interested in was removed by the service (nasty one...)
cle1 = MyGetEvent(iSelection);
if (cle1 != NULL)
CallService(MS_CLIST_REMOVEEVENT, (WPARAM) cle->hContact, (LPARAM) cle->hDbEvent);
}
}
}
break;
}
break;
case WM_SIZE:
if (!g_CluiData.fLayered)
InvalidateRect(hwnd,NULL,FALSE);
return DefWindowProc(hwnd, msg, wParam, lParam);
case WM_ERASEBKGND:
return 1;
case WM_PAINT:
if (GetParent(hwnd) == pcli->hwndContactList && g_CluiData.fLayered)
CallService(MS_SKINENG_INVALIDATEFRAMEIMAGE,(WPARAM)hwnd,0);
else if (GetParent(hwnd) == pcli->hwndContactList && !g_CluiData.fLayered) {
HDC hdc, hdc2;
HBITMAP hbmp,hbmpo;
RECT rc = {0};
GetClientRect(hwnd,&rc);
rc.right++;
rc.bottom++;
hdc = GetDC(hwnd);
hdc2 = CreateCompatibleDC(hdc);
hbmp = ske_CreateDIB32(rc.right,rc.bottom);
hbmpo = (HBITMAP)SelectObject(hdc2,hbmp);
ske_BltBackImage(hwnd,hdc2,&rc);
EventArea_DrawWorker(hwnd,hdc2);
BitBlt(hdc,rc.left,rc.top,rc.right-rc.left,rc.bottom-rc.top,
hdc2,rc.left,rc.top,SRCCOPY);
SelectObject(hdc2,hbmpo);
DeleteObject(hbmp);
DeleteDC(hdc2);
SelectObject(hdc,GetStockObject(DEFAULT_GUI_FONT));
ReleaseDC(hwnd,hdc);
ValidateRect(hwnd,NULL);
}
else {
HDC hdc, hdc2;
HBITMAP hbmp, hbmpo;
RECT rc;
PAINTSTRUCT ps;
HBRUSH br = GetSysColorBrush(COLOR_3DFACE);
GetClientRect(hwnd,&rc);
hdc = BeginPaint(hwnd,&ps);
hdc2 = CreateCompatibleDC(hdc);
hbmp = ske_CreateDIB32(rc.right,rc.bottom);
hbmpo = (HBITMAP)SelectObject(hdc2,hbmp);
FillRect(hdc2,&ps.rcPaint,br);
EventArea_DrawWorker(hwnd,hdc2);
BitBlt(hdc,ps.rcPaint.left,ps.rcPaint.top,ps.rcPaint.right-ps.rcPaint.left,ps.rcPaint.bottom-ps.rcPaint.top,
hdc2,ps.rcPaint.left,ps.rcPaint.top,SRCCOPY);
SelectObject(hdc2,hbmpo);
DeleteObject(hbmp);
DeleteDC(hdc2);
ps.fErase = FALSE;
EndPaint(hwnd,&ps);
}
default:
return DefWindowProc(hwnd, msg, wParam, lParam);
}
return TRUE;
}
static void handle_mouse(const int numevents, DIDEVICEOBJECTDATA *ptrbuf)
{
int i;
Sint16 xrel, yrel;
Uint8 state;
Uint8 button;
DWORD timestamp = 0;
/* Sanity check. Mailing list reports this being NULL unexpectedly. */
if (SDL_PublicSurface == NULL) {
return;
}
/* If the mouse was lost, regain some sense of mouse state */
if ( mouse_lost && (SDL_GetAppState() & SDL_APPMOUSEFOCUS) ) {
POINT mouse_pos;
Uint8 old_state;
Uint8 new_state;
/* Set ourselves up with the current cursor position */
GetCursorPos(&mouse_pos);
ScreenToClient(SDL_Window, &mouse_pos);
post_mouse_motion( 0, (Sint16)mouse_pos.x, (Sint16)mouse_pos.y);
/* Check for mouse button changes */
old_state = SDL_GetMouseState(NULL, NULL);
new_state = 0;
{ /* Get the new DirectInput button state for the mouse */
#if DIRECTINPUT_VERSION >= 0x700
DIMOUSESTATE2 distate;
#else
DIMOUSESTATE distate;
#endif
HRESULT result;
result=IDirectInputDevice2_GetDeviceState(SDL_DIdev[1],
sizeof(distate), &distate);
if ( result != DI_OK ) {
/* Try again next time */
SetDIerror(
"IDirectInputDevice2::GetDeviceState", result);
return;
}
for ( i=3; i>=0; --i ) {
if ( (distate.rgbButtons[i]&0x80) == 0x80 ) {
new_state |= 0x01;
}
new_state <<= 1;
}
}
for ( i=0; i<8; ++i ) {
if ( (old_state&0x01) != (new_state&0x01) ) {
button = (Uint8)(i+1);
/* Map DI button numbers to SDL */
switch ( button ) {
case 2: button = SDL_BUTTON_RIGHT; break;
case 3: button = SDL_BUTTON_MIDDLE; break;
case 4: button = SDL_BUTTON_X1; break;
case 5: button = SDL_BUTTON_X2; break;
default: break;
}
if ( new_state & 0x01 ) {
/* Grab mouse so we get mouse-up */
if ( ++mouse_pressed > 0 ) {
SetCapture(SDL_Window);
}
state = SDL_PRESSED;
} else {
/* Release mouse after all mouse-ups */
if ( --mouse_pressed <= 0 ) {
ReleaseCapture();
mouse_pressed = 0;
}
state = SDL_RELEASED;
}
if ( mouse_buttons_swapped ) {
if ( button == 1 ) button = 3;
else
if ( button == 3 ) button = 1;
}
posted = SDL_PrivateMouseButton(state, button,
0, 0);
}
old_state >>= 1;
new_state >>= 1;
}
mouse_lost = 0;
return;
}
void AppClass::ProcessMouse(void)
{
m_bArcBall = false;
m_bFPC = false;
float fSpeed = 0.01f;
#pragma region ON_MOUSE_PRESS_RELEASE
static bool bLastLeft = false, bLastMiddle = false, bLastRight = false;
#define ON_MOUSE_PRESS_RELEASE(key, pressed_action, released_action){ \
bool pressed = sf::Mouse::isButtonPressed(sf::Mouse::Button::key); \
if(pressed){ \
if(!bLast##key) pressed_action;}/*Just pressed? */\
else if(bLast##key) released_action;/*Just released?*/\
bLast##key = pressed; } //remember the state
#pragma endregion
bool bLeft = false;
ON_MOUSE_PRESS_RELEASE(Left, NULL, bLeft = true)
if (bLeft)
{
//Turn off the visibility of all BOs for all instances
m_pMeshMngr->SetVisibleBO(BD_NONE, "ALL", -1);
//Get the Position and direction of the click on the screen
std::pair<vector3, vector3> pair =
m_pCameraMngr->GetClickAndDirectionOnWorldSpace(sf::Mouse::getPosition().x, sf::Mouse::getPosition().y);
float fDistance = 0;//Stores the distance to the first colliding object
m_selection = m_pMeshMngr->IsColliding(pair.first, pair.second, fDistance);
//If there is a collision
if (m_selection.first >= 0)
{
//Turn on the BO of the group
m_pMeshMngr->SetVisibleBO(BD_OB, m_selection.first, m_selection.second);
//Turn of the BO of the instance but not the group
m_pMeshMngr->SetVisibleBO(BD_NONE, m_selection.first, -2);
}
}
if(sf::Mouse::isButtonPressed(sf::Mouse::Button::Middle))
m_bArcBall = true;
if(sf::Mouse::isButtonPressed(sf::Mouse::Button::Right))
m_bFPC = true;
if (m_bFPC) {
//the following code is taken from ReEngAppClass.h CameraRotation ln 351
UINT MouseX, MouseY; // Coordinates for the mouse
UINT CenterX, CenterY; // Coordinates for the center of the screen.
//Initialize the position of the pointer to the middle of the screen
CenterX = m_pSystem->GetWindowX() + m_pSystem->GetWindowWidth() / 2;
CenterY = m_pSystem->GetWindowY() + m_pSystem->GetWindowHeight() / 2;
//Calculate the position of the mouse and store it
POINT pt;
GetCursorPos(&pt);
MouseX = pt.x;
MouseY = pt.y;
//Calculate the difference in view with the angle
float fAngleX = 0.0f;
float fAngleY = 0.0f;
float fDeltaMouse = 0.0f;
if (MouseX < CenterX)
{
fDeltaMouse = static_cast<float>(CenterX - MouseX);
fAngleY += fDeltaMouse * fSpeed;
}
else if (MouseX > CenterX)
{
fDeltaMouse = static_cast<float>(MouseX - CenterX);
fAngleY -= fDeltaMouse * fSpeed;
}
if (MouseY < CenterY)
{
fDeltaMouse = static_cast<float>(CenterY - MouseY);
fAngleX -= fDeltaMouse * fSpeed;
}
else if (MouseY > CenterY)
{
fDeltaMouse = static_cast<float>(MouseY - CenterY);
fAngleX += fDeltaMouse * fSpeed;
}
//Change the Yaw and the Pitch of the camera
myCam->ChangeYaw(-fAngleY * 3.0f);
myCam->ChangePitch(fAngleX * 3.0f);
SetCursorPos(CenterX, CenterY);//Position the mouse in the center
}
}
void MUS_RenewMouse( HWND hwnd, int active, int Flag_MenuSelected )
{
int i;
int x,y;
int mx,my;
MOUSE_CHECK *mc;
POINT mp;
static int bl=OFF,bm=OFF,br=OFF;
static int lcnt=0, mcnt=0, rcnt=0;
int rect_err;
GetCursorPos( &mp );
ScreenToClient( hwnd, &mp );
MouseStruct.mx = mx = mp.x;
MouseStruct.my = my = mp.y;
x = mx-400;
y = my-300;
MouseStruct.interval = x*x + y*y;
MouseStruct.active = active;
rect_err = !(0 < mx && 0 < my && MouseStruct.disp_w >= mx && MouseStruct.disp_h >= my);
MouseStruct.no = -1;
if( !rect_err ){
for(i=0; i<MOUSE_REST_MAX ;i++){
mc = &MouseCheck[MouseStruct.lno][i];
if( mc->flag ){
if( mc->sx <= mx && mc->sy <= my &&
mc->sx+mc->w > mx && mc->sy+mc->h > my ){
MouseStruct.no = i;
break;
}
}
}
}
MouseStruct.wheel = MouseStruct.wheel_get;
if( MouseStruct.wheel_get ){
MouseStruct.wheel_get = 0;
}
if( !MouseStruct.click_through && active ){
if(MouseStruct.same_time){
if( !(MouseStruct.bl || MouseStruct.br || MouseStruct.bm) ){
MouseStruct.bl = (GetAsyncKeyState(VK_LBUTTON)&0x8001)?ON:OFF;
if( !MouseStruct.bl ){
MouseStruct.br = (GetAsyncKeyState(VK_RBUTTON)&0x8001)?ON:OFF;
if( !MouseStruct.br ){
MouseStruct.bm = (GetAsyncKeyState(VK_MBUTTON)&0x8001)?ON:OFF;
}
}
}else{
if(MouseStruct.bl) MouseStruct.bl = (GetAsyncKeyState(VK_LBUTTON)&0x8001)?ON:OFF;
else GetAsyncKeyState(VK_LBUTTON);
if(MouseStruct.br) MouseStruct.br = (GetAsyncKeyState(VK_RBUTTON)&0x8001)?ON:OFF;
else GetAsyncKeyState(VK_RBUTTON);
if(MouseStruct.bm) MouseStruct.bm = (GetAsyncKeyState(VK_MBUTTON)&0x8001)?ON:OFF;
else GetAsyncKeyState(VK_MBUTTON);
if( !(MouseStruct.bl || MouseStruct.br || MouseStruct.bm) ){
MouseStruct.bl = (GetAsyncKeyState(VK_LBUTTON)&0x8001)?ON:OFF;
if( !MouseStruct.bl ){
MouseStruct.br = (GetAsyncKeyState(VK_RBUTTON)&0x8001)?ON:OFF;
if( !MouseStruct.br ){
MouseStruct.bm = (GetAsyncKeyState(VK_MBUTTON)&0x8001)?ON:OFF;
}
}
}
}
}else{
MouseStruct.bl = (GetAsyncKeyState(VK_LBUTTON)&0x8001)?ON:OFF;
MouseStruct.br = (GetAsyncKeyState(VK_RBUTTON)&0x8001)?ON:OFF;
MouseStruct.bm = (GetAsyncKeyState(VK_MBUTTON)&0x8001)?ON:OFF;
}
if(Flag_MenuSelected>0){
Flag_MenuSelected--;
MouseStruct.bl = OFF;
MouseStruct.br = OFF;
MouseStruct.bm = OFF;
}
}else{
MouseStruct.click_through = 0;
GetAsyncKeyState(VK_LBUTTON);
GetAsyncKeyState(VK_RBUTTON);
GetAsyncKeyState(VK_MBUTTON);
}
if( GetSystemMetrics(SM_SWAPBUTTON) ){
int work = MouseStruct.bl;
MouseStruct.bl = MouseStruct.br;
MouseStruct.br = work;
}
lcnt = (MouseStruct.bl) ? min(8,lcnt+1) : 0;
rcnt = (MouseStruct.br) ? min(8,rcnt+1) : 0;
mcnt = (MouseStruct.bm) ? min(8,mcnt+1) : 0;
MouseStruct.btl = (lcnt==8) || (lcnt==1);
MouseStruct.btr = (rcnt==8) || (rcnt==1);
MouseStruct.btm = (mcnt==8) || (mcnt==1);
if(bl==OFF && MouseStruct.bl==ON ){
MouseStruct.tl = ON;
MouseStruct.dragl.x = mx;
MouseStruct.dragl.y = my;
}else{
MouseStruct.tl = OFF;
}
if(br==OFF && MouseStruct.br==ON ){
MouseStruct.tr = ON;
MouseStruct.dragr.x = mx;
MouseStruct.dragr.y = my;
}else{
MouseStruct.tr = OFF;
}
if(bm==OFF && MouseStruct.bm==ON ){
MouseStruct.tm = ON;
MouseStruct.dragm.x = mx;
MouseStruct.dragm.y = my;
}else{
MouseStruct.tm = OFF;
}
if( bl==ON && MouseStruct.bl==OFF ) { MouseStruct.rtl = ON; }
else { MouseStruct.rtl = OFF; }
if( br==ON && MouseStruct.br==OFF ) { MouseStruct.rtr = ON; }
else { MouseStruct.rtr = OFF; }
if( bm==ON && MouseStruct.bm==OFF ) { MouseStruct.rtm = ON; }
else { MouseStruct.rtm = OFF; }
if( !MouseStruct.bl ) { MouseStruct.dragl.x = -1; MouseStruct.dragl.y = -1; }
if( !MouseStruct.br ) { MouseStruct.dragr.x = -1; MouseStruct.dragr.y = -1; }
if( !MouseStruct.bm ) { MouseStruct.dragm.x = -1; MouseStruct.dragm.y = -1; }
bl = MouseStruct.bl;
br = MouseStruct.br;
bm = MouseStruct.bm;
}
