static int mallegro_Poll(void)
{
#if _ANDROID_
if(al_is_bitmap_locked(scrmem)){
al_unlock_bitmap(scrmem);
al_set_target_bitmap(al_get_backbuffer(display));
//al_draw_bitmap(scrmem, 0, 0, 0);
al_draw_scaled_rotated_bitmap(scrmem, 0, 0, 0, 0, zoomfactor, zoomfactor, 0, 0);
//al_draw_scaled_rotated_bitmap(scrmem, 0, al_get_bitmap_height(al_get_backbuffer(display)), 0, 0, 2, 2, ALLEGRO_PI/2, 0);
//al_draw_scaled_rotated_bitmap(scrmem, 0, 500, 0, 0, 3, 3, ALLEGRO_PI/2, 0); //would have to recalculate mouse
al_flip_display();
}
#else
if(al_is_bitmap_locked(display_bitmap)) {
al_unlock_bitmap(display_bitmap);
al_flip_display();
}
#endif
if (!al_is_mouse_installed()) return 0;
if (al_peek_next_event(a_event_queue_m, &a_event)) return 1; //read event in read function
return 0;
}
WPJInputUtil::~WPJInputUtil()
{
ClearAllTriggedEvents();
if (al_is_keyboard_installed())
al_unregister_event_source(m_pEventQueue, al_get_keyboard_event_source());
if (al_is_mouse_installed())
al_unregister_event_source(m_pEventQueue, al_get_mouse_event_source());
al_destroy_event_queue(m_pEventQueue);
}
bool System::shutdownSharedSystem()
{
if (al_is_joystick_installed())
al_uninstall_joystick();
if (al_is_mouse_installed())
al_uninstall_mouse();
if (al_is_keyboard_installed())
al_uninstall_keyboard();
al_shutdown_image_addon();
if (al_is_system_installed())
al_uninstall_system();
return true;
}
bool WPJInputUtil::Init()
{
int bRet;
// init input hardware driver
bRet = al_is_keyboard_installed() && al_is_mouse_installed();
// init event_queue
m_pEventQueue = al_create_event_queue();
if (bRet && m_pEventQueue)
{
al_register_event_source(m_pEventQueue, al_get_keyboard_event_source());
al_register_event_source(m_pEventQueue, al_get_mouse_event_source());
al_register_event_source(m_pEventQueue, al_get_display_event_source(m_pDisplay));
}
return bRet;
}
static void handle_mouse_capture(bool down, HWND hWnd)
{
int i;
bool any_button_down = false;
ALLEGRO_MOUSE_STATE state;
if (!al_is_mouse_installed())
return;
al_get_mouse_state(&state);
for (i = 1; i <= 5; i++) {
any_button_down |= al_mouse_button_down(&state, i);
}
if (down && GetCapture() != hWnd) {
SetCapture(hWnd);
}
else if (!any_button_down) {
ReleaseCapture();
}
}
/*
* The window must be created in the same thread that
* runs the message loop.
*/
static void display_thread_proc(void *arg)
{
WGL_DISPLAY_PARAMETERS *ndp = arg;
ALLEGRO_DISPLAY *disp = (ALLEGRO_DISPLAY*)ndp->display;
ALLEGRO_DISPLAY_WGL *wgl_disp = (void*)disp;
ALLEGRO_DISPLAY_WIN *win_disp = (void*)disp;
MSG msg;
al_set_new_window_position(ndp->window_x, ndp->window_y);
/* So that we can call the functions using TLS from this thread. */
al_set_new_display_flags(disp->flags);
if (disp->flags & ALLEGRO_FULLSCREEN) {
if (!change_display_mode(disp)) {
win_disp->thread_ended = true;
destroy_display_internals(wgl_disp);
SetEvent(ndp->AckEvent);
return;
}
}
else if (disp->flags & ALLEGRO_FULLSCREEN_WINDOW) {
ALLEGRO_MONITOR_INFO mi;
int adapter = win_disp->adapter;
al_get_monitor_info(adapter, &mi);
win_disp->toggle_w = disp->w;
win_disp->toggle_h = disp->h;
disp->w = mi.x2 - mi.x1;
disp->h = mi.y2 - mi.y1;
}
else {
win_disp->toggle_w = disp->w;
win_disp->toggle_h = disp->h;
}
win_disp->window = _al_win_create_window(disp, disp->w, disp->h, disp->flags);
if (!win_disp->window) {
win_disp->thread_ended = true;
destroy_display_internals(wgl_disp);
SetEvent(ndp->AckEvent);
return;
}
/* FIXME: can't _al_win_create_window() do this? */
if ((disp->flags & ALLEGRO_FULLSCREEN) ||
(disp->flags & ALLEGRO_FULLSCREEN_WINDOW)) {
RECT rect;
rect.left = 0;
rect.right = disp->w;
rect.top = 0;
rect.bottom = disp->h;
SetWindowPos(win_disp->window, 0, rect.left, rect.top,
rect.right - rect.left, rect.bottom - rect.top,
SWP_NOZORDER | SWP_FRAMECHANGED);
}
if (disp->flags & ALLEGRO_FULLSCREEN_WINDOW) {
bool frameless = true;
_al_win_set_window_frameless(disp, win_disp->window, disp->w, disp->h, frameless);
}
/* Yep, the following is really needed sometimes. */
/* ... Or is it now that we have dumped DInput? */
/* <rohannessian> Win98/2k/XP's window forground rules don't let us
* make our window the topmost window on launch. This causes issues on
* full-screen apps, as DInput loses input focus on them.
* We use this trick to force the window to be topmost, when switching
* to full-screen only. Note that this only works for Win98 and greater.
* Win95 will ignore our SystemParametersInfo() calls.
*
* See http://support.microsoft.com:80/support/kb/articles/Q97/9/25.asp
* for details.
*/
{
DWORD lock_time;
HWND wnd = win_disp->window;
#define SPI_GETFOREGROUNDLOCKTIMEOUT 0x2000
#define SPI_SETFOREGROUNDLOCKTIMEOUT 0x2001
if (disp->flags & ALLEGRO_FULLSCREEN) {
SystemParametersInfo(SPI_GETFOREGROUNDLOCKTIMEOUT,
0, (LPVOID)&lock_time, 0);
SystemParametersInfo(SPI_SETFOREGROUNDLOCKTIMEOUT,
0, (LPVOID)0, SPIF_SENDWININICHANGE | SPIF_UPDATEINIFILE);
}
ShowWindow(wnd, SW_SHOWNORMAL);
SetForegroundWindow(wnd);
/* In some rare cases, it doesn't seem to work without the loop. And we
* absolutely need this to succeed, else we trap the user in a
* fullscreen window without input.
*/
while (GetForegroundWindow() != wnd) {
al_rest(0.01);
SetForegroundWindow(wnd);
}
UpdateWindow(wnd);
if (disp->flags & ALLEGRO_FULLSCREEN) {
SystemParametersInfo(SPI_SETFOREGROUNDLOCKTIMEOUT,
0, (LPVOID)(DWORD)lock_time, SPIF_SENDWININICHANGE | SPIF_UPDATEINIFILE);
}
#undef SPI_GETFOREGROUNDLOCKTIMEOUT
#undef SPI_SETFOREGROUNDLOCKTIMEOUT
}
#if 0
if (disp->flags & ALLEGRO_FULLSCREEN && al_is_mouse_installed()) {
RAWINPUTDEVICE rid[1];
rid[0].usUsagePage = 0x01;
rid[0].usUsage = 0x02;
rid[0].dwFlags = RIDEV_NOLEGACY;
rid[0].hwndTarget = 0;
if (RegisterRawInputDevices(rid, 1, sizeof(rid[0])) == FALSE) {
ALLEGRO_ERROR(
"Failed to init mouse. %s\n", get_error_desc(GetLastError()));
}
}
#endif
/* get the device context of our window */
wgl_disp->dc = GetDC(win_disp->window);
win_disp->thread_ended = false;
win_disp->end_thread = false;
ndp->init_failed = false;
SetEvent(ndp->AckEvent);
while (!win_disp->end_thread) {
/* get a message from the queue */
if (GetMessage(&msg, NULL, 0, 0) != 0)
DispatchMessage(&msg);
else
break; /* WM_QUIT received or error (GetMessage returned -1) */
}
if (wgl_disp->glrc) {
wglDeleteContext(wgl_disp->glrc);
wgl_disp->glrc = NULL;
}
if (wgl_disp->dc) {
ReleaseDC(win_disp->window, wgl_disp->dc);
wgl_disp->dc = NULL;
}
if (disp->flags & ALLEGRO_FULLSCREEN && !_wgl_do_not_change_display_mode) {
ChangeDisplaySettings(NULL, 0);
}
if (win_disp->window) {
DestroyWindow(win_disp->window);
win_disp->window = NULL;
}
ALLEGRO_INFO("wgl display thread exits\n");
win_disp->thread_ended = true;
}
static int mallegro_Read(MWCOORD *dx, MWCOORD *dy, MWCOORD *dz, int *bp)
{
static int mz;
static int hidingmouse;
if (!al_is_mouse_installed()) return 0;
int buttons = 0;
int mickeyz = 0;
al_get_next_event(a_event_queue_m, &a_event); //remove from queue
switch(a_event.type){
case ALLEGRO_EVENT_MOUSE_AXES:
case ALLEGRO_EVENT_MOUSE_BUTTON_DOWN:
case ALLEGRO_EVENT_MOUSE_BUTTON_UP:
break;
case ALLEGRO_EVENT_MOUSE_ENTER_DISPLAY:
case ALLEGRO_EVENT_MOUSE_LEAVE_DISPLAY:
default:
return 0;
}
al_get_mouse_state_axis(&mstate, 2); // 2= read z-axis vertical wheel
//calculate wheel button (up/down)
if(mstate.z != mz)
mickeyz = mstate.z - mz;
else
mickeyz = 0;
mz = mstate.z;
al_get_mouse_state(&mstate); //call above returns no button press
//microwindows expects the mouse position at the unzoomed position - so divide
*dx=mstate.x/zoomfactor;
*dy=mstate.y/zoomfactor;
*dz = 0; //unused
*bp = 0;
if (mstate.buttons & 1) {
/* Primary (e.g. left) mouse button is held. */
buttons |= MWBUTTON_L;
}
if (mstate.buttons & 2) {
buttons |= MWBUTTON_R;
/* Secondary (e.g. right) mouse button is held. */
}
if (mstate.buttons & 4) {
/* Tertiary (e.g. middle) mouse button is held. */
buttons |= MWBUTTON_M;
}
if (mickeyz > 0)
buttons |= MWBUTTON_U;
if (mickeyz < 0)
buttons |= MWBUTTON_D;
*bp = buttons;
return 2; //2=absolute mouse position
}
VALUE rbal_mouse_init_p(VALUE rself) {
return RBH_INT_BOOL(al_is_mouse_installed());
}
static LRESULT CALLBACK window_callback(HWND hWnd, UINT message,
WPARAM wParam, LPARAM lParam)
{
ALLEGRO_DISPLAY *d = NULL;
ALLEGRO_DISPLAY_WIN *win_display = NULL;
unsigned int i;
ALLEGRO_EVENT_SOURCE *es = NULL;
ALLEGRO_SYSTEM *system = al_get_system_driver();
if (message == _al_win_msg_call_proc) {
((void (*)(void*))wParam) ((void*)lParam);
return 0;
}
if (!system) {
return DefWindowProc(hWnd,message,wParam,lParam);
}
if (message == _al_win_msg_suicide && wParam) {
win_display = (ALLEGRO_DISPLAY_WIN*)wParam;
break_window_message_pump(win_display, hWnd);
DestroyWindow(hWnd);
return 0;
}
for (i = 0; i < system->displays._size; i++) {
ALLEGRO_DISPLAY **dptr = _al_vector_ref(&system->displays, i);
d = *dptr;
win_display = (void*)d;
if (win_display->window == hWnd) {
es = &d->es;
break;
}
}
if (i == system->displays._size)
return DefWindowProc(hWnd,message,wParam,lParam);
if (message == _al_win_msg_suicide) {
break_window_message_pump(win_display, hWnd);
DestroyWindow(hWnd);
return 0;
}
switch (message) {
case WM_INPUT:
{
/* RAW Input is currently unused. */
UINT dwSize;
LPBYTE lpb;
RAWINPUT* raw;
/* We can't uninstall WM_INPUT mesages. */
if (!al_is_mouse_installed())
break;
GetRawInputData((HRAWINPUT)lParam, RID_INPUT, NULL, &dwSize,
sizeof(RAWINPUTHEADER));
lpb = al_malloc(sizeof(BYTE)*dwSize);
if (lpb == NULL)
break;
GetRawInputData((HRAWINPUT)lParam, RID_INPUT, lpb, &dwSize, sizeof(RAWINPUTHEADER));
raw = (RAWINPUT*)lpb;
if (raw->header.dwType != RIM_TYPEMOUSE) {
al_free(lpb);
break;
}
{
RAWMOUSE *rm = &raw->data.mouse;
int x = raw->data.mouse.lLastX;
int y = raw->data.mouse.lLastY;
bool abs = (rm->usFlags & (MOUSE_MOVE_ABSOLUTE
| MOUSE_VIRTUAL_DESKTOP)) != 0;
if (abs || x || y)
_al_win_mouse_handle_move(x, y, abs, win_display);
if (rm->usButtonFlags & RI_MOUSE_BUTTON_1_DOWN)
_al_win_mouse_handle_button(1, true, x, y, abs, win_display);
if (rm->usButtonFlags & RI_MOUSE_BUTTON_1_UP)
_al_win_mouse_handle_button(1, false, x, y, abs, win_display);
if (rm->usButtonFlags & RI_MOUSE_BUTTON_2_DOWN)
_al_win_mouse_handle_button(2, true, x, y, abs, win_display);
if (rm->usButtonFlags & RI_MOUSE_BUTTON_2_UP)
_al_win_mouse_handle_button(2, false, x, y, abs, win_display);
if (rm->usButtonFlags & RI_MOUSE_BUTTON_3_DOWN)
_al_win_mouse_handle_button(3, true, x, y, abs, win_display);
if (rm->usButtonFlags & RI_MOUSE_BUTTON_3_UP)
_al_win_mouse_handle_button(3, false, x, y, abs, win_display);
if (rm->usButtonFlags & RI_MOUSE_BUTTON_4_DOWN)
_al_win_mouse_handle_button(4, true, x, y, abs, win_display);
if (rm->usButtonFlags & RI_MOUSE_BUTTON_4_UP)
_al_win_mouse_handle_button(4, false, x, y, abs, win_display);
if (rm->usButtonFlags & RI_MOUSE_BUTTON_5_DOWN)
_al_win_mouse_handle_button(5, true, x, y, abs, win_display);
if (rm->usButtonFlags & RI_MOUSE_BUTTON_5_UP)
_al_win_mouse_handle_button(5, false, x, y, abs, win_display);
if (rm->usButtonFlags & RI_MOUSE_WHEEL) {
SHORT z = (SHORT)rm->usButtonData;
_al_win_mouse_handle_wheel(z / WHEEL_DELTA, false, win_display);
}
}
al_free(lpb);
break;
}
case WM_LBUTTONDOWN:
case WM_LBUTTONUP: {
int mx = GET_X_LPARAM(lParam);
int my = GET_Y_LPARAM(lParam);
bool down = (message == WM_LBUTTONDOWN);
_al_win_mouse_handle_button(1, down, mx, my, true, win_display);
handle_mouse_capture(down, hWnd);
break;
}
case WM_MBUTTONDOWN:
case WM_MBUTTONUP: {
int mx = GET_X_LPARAM(lParam);
int my = GET_Y_LPARAM(lParam);
bool down = (message == WM_MBUTTONDOWN);
_al_win_mouse_handle_button(3, down, mx, my, true, win_display);
handle_mouse_capture(down, hWnd);
break;
}
case WM_RBUTTONDOWN:
case WM_RBUTTONUP: {
int mx = GET_X_LPARAM(lParam);
int my = GET_Y_LPARAM(lParam);
bool down = (message == WM_RBUTTONDOWN);
_al_win_mouse_handle_button(2, down, mx, my, true, win_display);
handle_mouse_capture(down, hWnd);
break;
}
case WM_XBUTTONDOWN:
case WM_XBUTTONUP: {
int mx = GET_X_LPARAM(lParam);
int my = GET_Y_LPARAM(lParam);
int button = HIWORD(wParam);
bool down = (message == WM_XBUTTONDOWN);
if (button == XBUTTON1)
_al_win_mouse_handle_button(4, down, mx, my, true, win_display);
else if (button == XBUTTON2)
_al_win_mouse_handle_button(5, down, mx, my, true, win_display);
handle_mouse_capture(down, hWnd);
return TRUE;
}
case WM_MOUSEWHEEL: {
int d = GET_WHEEL_DELTA_WPARAM(wParam);
_al_win_mouse_handle_wheel(d / WHEEL_DELTA, false, win_display);
return TRUE;
}
case WM_MOUSEHWHEEL: {
int d = GET_WHEEL_DELTA_WPARAM(wParam);
_al_win_mouse_handle_hwheel(d / WHEEL_DELTA, false, win_display);
return TRUE;
}
case WM_MOUSEMOVE: {
TRACKMOUSEEVENT tme;
int mx = GET_X_LPARAM(lParam);
int my = GET_Y_LPARAM(lParam);
if (win_display->mouse_cursor_shown && we_hid_the_mouse) {
we_hid_the_mouse = false;
win_display->display.vt->hide_mouse_cursor((void*)win_display);
}
_al_win_mouse_handle_move(mx, my, true, win_display);
if (mx >= 0 && my >= 0 && mx < d->w && my < d->h) {
tme.cbSize = sizeof(tme);
tme.dwFlags = TME_QUERY;
if (TrackMouseEvent(&tme) && !tme.hwndTrack) {
tme.dwFlags = TME_LEAVE;
tme.hwndTrack = hWnd;
tme.dwHoverTime = 0;
TrackMouseEvent(&tme);
_al_win_mouse_handle_enter(win_display);
}
}
/* WM_SETCURSOR messages are not received while the mouse is
* captured. We call SetCursor here so that changing the mouse
* cursor has an effect while the user is holding down the mouse
* button.
*/
if (GetCapture() == hWnd && win_display->mouse_cursor_shown) {
SetCursor(win_display->mouse_selected_hcursor);
}
break;
}
case WM_MOUSELEAVE: {
_al_win_mouse_handle_leave(win_display);
break;
}
case WM_CAPTURECHANGED: {
if (al_is_mouse_installed()) {
int i;
ALLEGRO_MOUSE_STATE state;
if (!lParam || (HWND)lParam == hWnd)
break;
al_get_mouse_state(&state);
for (i = 1; i <= 5; i++) {
if (al_mouse_button_down(&state, i))
_al_win_mouse_handle_button(i, 0, 0, 0, true, win_display);
}
}
break;
}
case WM_NCMOUSEMOVE: {
if (!win_display->mouse_cursor_shown) {
we_hid_the_mouse = true;
win_display->display.vt->show_mouse_cursor((void*)win_display);
}
break;
}
case WM_SYSKEYDOWN: {
int vcode = wParam;
bool extended = (lParam >> 24) & 0x1;
bool repeated = (lParam >> 30) & 0x1;
_al_win_kbd_handle_key_press(0, vcode, extended, repeated, win_display);
break;
}
case WM_KEYDOWN: {
int vcode = wParam;
int scode = (lParam >> 16) & 0xff;
bool extended = (lParam >> 24) & 0x1;
bool repeated = (lParam >> 30) & 0x1;
/* We can't use TranslateMessage() because we don't know if it will
produce a WM_CHAR or not. */
_al_win_kbd_handle_key_press(scode, vcode, extended, repeated, win_display);
break;
}
case WM_SYSKEYUP:
case WM_KEYUP: {
int vcode = wParam;
int scode = (lParam >> 16) & 0xff;
bool extended = (lParam >> 24) & 0x1;
_al_win_kbd_handle_key_release(scode, vcode, extended, win_display);
break;
}
case WM_SYSCOMMAND: {
if (_al_win_disable_screensaver &&
((wParam & 0xfff0) == SC_MONITORPOWER || (wParam & 0xfff0) == SC_SCREENSAVE)) {
return 0;
}
else if ((wParam & 0xfff0) == SC_KEYMENU) {
/* Prevent Windows from intercepting the ALT key.
(Disables opening menus via the ALT key.) */
return 0;
}
break;
}
case WM_PAINT: {
if (win_display->display.flags & ALLEGRO_GENERATE_EXPOSE_EVENTS) {
RECT r;
HRGN hrgn;
GetWindowRect(win_display->window, &r);
hrgn = CreateRectRgn(r.left, r.top, r.right, r.bottom);
if (GetUpdateRgn(win_display->window, hrgn, false) != ERROR) {
PAINTSTRUCT ps;
DWORD size;
LPRGNDATA rgndata;
int n;
int i;
RECT *rects;
BeginPaint(win_display->window, &ps);
size = GetRegionData(hrgn, 0, NULL);
rgndata = al_malloc(size);
GetRegionData(hrgn, size, rgndata);
n = rgndata->rdh.nCount;
rects = (RECT *)rgndata->Buffer;
_al_event_source_lock(es);
if (_al_event_source_needs_to_generate_event(es)) {
ALLEGRO_EVENT event;
event.display.type = ALLEGRO_EVENT_DISPLAY_EXPOSE;
event.display.timestamp = al_get_time();
for (i = 0; i < n; i++) {
event.display.x = rects[i].left;
event.display.y = rects[i].top;
event.display.width = rects[i].right - rects[i].left;
event.display.height = rects[i].bottom - rects[i].top;
_al_event_source_emit_event(es, &event);
}
}
_al_event_source_unlock(es);
al_free(rgndata);
EndPaint(win_display->window, &ps);
DeleteObject(hrgn);
}
return 0;
}
break;
}
case WM_SETCURSOR:
switch (LOWORD(lParam)) {
case HTLEFT:
case HTRIGHT:
SetCursor(LoadCursor(NULL, IDC_SIZEWE));
break;
case HTBOTTOM:
case HTTOP:
SetCursor(LoadCursor(NULL, IDC_SIZENS));
break;
case HTBOTTOMLEFT:
case HTTOPRIGHT:
SetCursor(LoadCursor(NULL, IDC_SIZENESW));
break;
case HTBOTTOMRIGHT:
case HTTOPLEFT:
SetCursor(LoadCursor(NULL, IDC_SIZENWSE));
break;
default:
if (win_display->mouse_cursor_shown) {
SetCursor(win_display->mouse_selected_hcursor);
}
else {
SetCursor(NULL);
}
break;
}
return 1;
case WM_ACTIVATE:
if (HIWORD(wParam) && LOWORD(wParam) != WA_INACTIVE)
break;
if (HIWORD(wParam))
d->flags |= ALLEGRO_MINIMIZED;
else
d->flags &= ~ALLEGRO_MINIMIZED;
if (LOWORD(wParam) != WA_INACTIVE) {
// Make fullscreen windows TOPMOST again
if (d->flags & ALLEGRO_FULLSCREEN_WINDOW) {
SetWindowPos(win_display->window, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
}
if (d->vt->switch_in)
d->vt->switch_in(d);
_al_win_fix_modifiers();
_al_event_source_lock(es);
if (_al_event_source_needs_to_generate_event(es)) {
ALLEGRO_EVENT event;
memset(&event, 0, sizeof(event));
event.display.type = ALLEGRO_EVENT_DISPLAY_SWITCH_IN;
event.display.timestamp = al_get_time();
_al_event_source_emit_event(es, &event);
}
_al_event_source_unlock(es);
_al_win_grab_input(win_display);
return 0;
}
else {
// Remove TOPMOST flag from fullscreen windows so we can alt-tab. Also must raise the new activated window
if (d->flags & ALLEGRO_FULLSCREEN_WINDOW) {
SetWindowPos(win_display->window, HWND_NOTOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
SetWindowPos(GetForegroundWindow(), HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
}
// Show the taskbar in case we hid it
SetWindowPos(FindWindow("Shell_traywnd", ""), 0, 0, 0, 0, 0, SWP_SHOWWINDOW);
if (d->flags & ALLEGRO_FULLSCREEN) {
d->vt->switch_out(d);
}
_al_event_source_lock(es);
if (_al_event_source_needs_to_generate_event(es)) {
ALLEGRO_EVENT event;
memset(&event, 0, sizeof(event));
event.display.type = ALLEGRO_EVENT_DISPLAY_SWITCH_OUT;
event.display.timestamp = al_get_time();
_al_event_source_emit_event(es, &event);
}
_al_event_source_unlock(es);
return 0;
}
break;
case WM_MENUCHAR :
return (MNC_CLOSE << 16) | (wParam & 0xffff);
case WM_CLOSE:
_al_event_source_lock(es);
if (_al_event_source_needs_to_generate_event(es)) {
ALLEGRO_EVENT event;
memset(&event, 0, sizeof(event));
event.display.type = ALLEGRO_EVENT_DISPLAY_CLOSE;
event.display.timestamp = al_get_time();
_al_event_source_emit_event(es, &event);
}
_al_event_source_unlock(es);
return 0;
case WM_SIZE:
if (wParam == SIZE_RESTORED || wParam == SIZE_MAXIMIZED || wParam == SIZE_MINIMIZED) {
/*
* Delay the resize event so we don't get bogged down with them
*/
if (!resize_postponed) {
resize_postponed = true;
_beginthread(postpone_thread_proc, 0, (void *)d);
}
}
return 0;
case WM_ENTERSIZEMOVE:
/* DefWindowProc for WM_ENTERSIZEMOVE enters a modal loop, which also
* ends up blocking the loop in d3d_display_thread_proc (which is
* where we are called from, if using D3D). Rather than batching up
* intermediate resize events which the user cannot acknowledge in the
* meantime anyway, make it so only a single resize event is generated
* at WM_EXITSIZEMOVE.
*/
if (d->flags & ALLEGRO_DIRECT3D) {
resize_postponed = true;
}
break;
case WM_EXITSIZEMOVE:
if (resize_postponed) {
win_generate_resize_event(win_display);
win_display->ignore_resize = false;
resize_postponed = false;
win_display->can_acknowledge = true;
}
break;
}
return DefWindowProc(hWnd,message,wParam,lParam);
}
static void generate_touch_input_event(int type, double timestamp, int id, float x, float y, float dx, float dy, bool primary, ALLEGRO_DISPLAY_WIN *win_disp)
{
ALLEGRO_EVENT event;
bool want_touch_event = _al_event_source_needs_to_generate_event(&touch_input.es);
bool want_mouse_emulation_event = _al_event_source_needs_to_generate_event(&touch_input.mouse_emulation_es) && primary && al_is_mouse_installed();
if (touch_input.mouse_emulation_mode == ALLEGRO_MOUSE_EMULATION_NONE)
want_mouse_emulation_event = false;
else if (touch_input.mouse_emulation_mode == ALLEGRO_MOUSE_EMULATION_INCLUSIVE)
want_touch_event = want_mouse_emulation_event ? (want_touch_event && !primary) : want_touch_event;
else if (touch_input.mouse_emulation_mode == ALLEGRO_MOUSE_EMULATION_EXCLUSIVE)
want_touch_event = want_mouse_emulation_event ? false : want_touch_event;
if (!want_touch_event && !want_mouse_emulation_event)
return;
if (want_touch_event) {
event.touch.type = type;
event.touch.display = (ALLEGRO_DISPLAY*)win_disp;
event.touch.timestamp = timestamp;
event.touch.id = id;
event.touch.x = x;
event.touch.y = y;
event.touch.dx = dx;
event.touch.dy = dy;
event.touch.primary = primary;
_al_event_source_lock(&touch_input.es);
_al_event_source_emit_event(&touch_input.es, &event);
_al_event_source_unlock(&touch_input.es);
}
if (want_mouse_emulation_event) {
ALLEGRO_MOUSE_STATE state;
switch (type) {
case ALLEGRO_EVENT_TOUCH_BEGIN: type = ALLEGRO_EVENT_MOUSE_BUTTON_DOWN; break;
case ALLEGRO_EVENT_TOUCH_CANCEL:
case ALLEGRO_EVENT_TOUCH_END: type = ALLEGRO_EVENT_MOUSE_BUTTON_UP; break;
case ALLEGRO_EVENT_TOUCH_MOVE: type = ALLEGRO_EVENT_MOUSE_AXES; break;
}
al_get_mouse_state(&state);
event.mouse.type = type;
event.mouse.timestamp = timestamp;
event.mouse.display = (ALLEGRO_DISPLAY*)win_disp;
event.mouse.x = (int)x;
event.mouse.y = (int)y;
event.mouse.z = state.z;
event.mouse.w = state.w;
event.mouse.dx = (int)dx;
event.mouse.dy = (int)dy;
event.mouse.dz = 0;
event.mouse.dw = 0;
event.mouse.button = 1;
event.mouse.pressure = state.pressure;
al_set_mouse_xy(event.mouse.display, event.mouse.x, event.mouse.y);
_al_event_source_lock(&touch_input.mouse_emulation_es);
_al_event_source_emit_event(&touch_input.mouse_emulation_es, &event);
_al_event_source_unlock(&touch_input.mouse_emulation_es);
}
}
static LRESULT CALLBACK window_callback(HWND hWnd, UINT message,
WPARAM wParam, LPARAM lParam)
{
ALLEGRO_DISPLAY *d = NULL;
ALLEGRO_DISPLAY_WIN *win_display = NULL;
WINDOWINFO wi;
int w;
int h;
int x;
int y;
unsigned int i;
ALLEGRO_EVENT_SOURCE *es = NULL;
ALLEGRO_SYSTEM *system = al_get_system_driver();
wi.cbSize = sizeof(WINDOWINFO);
if (message == _al_win_msg_call_proc) {
((void (*)(void*))wParam) ((void*)lParam);
return 0;
}
if (!system) {
return DefWindowProc(hWnd,message,wParam,lParam);
}
if (message == _al_win_msg_suicide && wParam) {
win_display = (ALLEGRO_DISPLAY_WIN*)wParam;
win_display->end_thread = true;
DestroyWindow(hWnd);
return 0;
}
for (i = 0; i < system->displays._size; i++) {
ALLEGRO_DISPLAY **dptr = _al_vector_ref(&system->displays, i);
d = *dptr;
win_display = (void*)d;
if (win_display->window == hWnd) {
es = &d->es;
break;
}
}
if (i == system->displays._size)
return DefWindowProc(hWnd,message,wParam,lParam);
if (message == _al_win_msg_suicide) {
win_display->end_thread = true;
DestroyWindow(hWnd);
return 0;
}
switch (message) {
case WM_INPUT:
{
UINT dwSize;
LPBYTE lpb;
RAWINPUT* raw;
/* We can't uninstall WM_INPUT mesages. */
if (!al_is_mouse_installed())
break;
GetRawInputData((HRAWINPUT)lParam, RID_INPUT, NULL, &dwSize,
sizeof(RAWINPUTHEADER));
lpb = malloc(sizeof(BYTE)*dwSize);
if (lpb == NULL)
break;
GetRawInputData((HRAWINPUT)lParam, RID_INPUT, lpb, &dwSize, sizeof(RAWINPUTHEADER));
raw = (RAWINPUT*)lpb;
if (raw->header.dwType != RIM_TYPEMOUSE) {
free(lpb);
break;
}
{
RAWMOUSE *rm = &raw->data.mouse;
int x = raw->data.mouse.lLastX;
int y = raw->data.mouse.lLastY;
bool abs = rm->usFlags & (MOUSE_MOVE_ABSOLUTE
|| MOUSE_VIRTUAL_DESKTOP);
if (abs || x || y)
_al_win_mouse_handle_move(x, y, abs, win_display);
if (rm->usButtonFlags & RI_MOUSE_BUTTON_1_DOWN)
_al_win_mouse_handle_button(1, true, x, y, abs, win_display);
if (rm->usButtonFlags & RI_MOUSE_BUTTON_1_UP)
_al_win_mouse_handle_button(1, false, x, y, abs, win_display);
if (rm->usButtonFlags & RI_MOUSE_BUTTON_2_DOWN)
_al_win_mouse_handle_button(2, true, x, y, abs, win_display);
if (rm->usButtonFlags & RI_MOUSE_BUTTON_2_UP)
_al_win_mouse_handle_button(2, false, x, y, abs, win_display);
if (rm->usButtonFlags & RI_MOUSE_BUTTON_3_DOWN)
_al_win_mouse_handle_button(3, true, x, y, abs, win_display);
if (rm->usButtonFlags & RI_MOUSE_BUTTON_3_UP)
_al_win_mouse_handle_button(3, false, x, y, abs, win_display);
if (rm->usButtonFlags & RI_MOUSE_BUTTON_4_DOWN)
_al_win_mouse_handle_button(4, true, x, y, abs, win_display);
if (rm->usButtonFlags & RI_MOUSE_BUTTON_4_UP)
_al_win_mouse_handle_button(4, false, x, y, abs, win_display);
if (rm->usButtonFlags & RI_MOUSE_BUTTON_5_DOWN)
_al_win_mouse_handle_button(5, true, x, y, abs, win_display);
if (rm->usButtonFlags & RI_MOUSE_BUTTON_5_UP)
_al_win_mouse_handle_button(5, false, x, y, abs, win_display);
if (rm->usButtonFlags & RI_MOUSE_WHEEL) {
SHORT z = (SHORT)rm->usButtonData;
_al_win_mouse_handle_wheel(z / WHEEL_DELTA, false, win_display);
}
}
free(lpb);
break;
}
case WM_LBUTTONDOWN:
case WM_LBUTTONUP: {
int mx = GET_X_LPARAM(lParam);
int my = GET_Y_LPARAM(lParam);
bool down = (message == WM_LBUTTONDOWN);
_al_win_mouse_handle_button(1, down, mx, my, true, win_display);
handle_mouse_capture(down, hWnd);
break;
}
case WM_MBUTTONDOWN:
case WM_MBUTTONUP: {
int mx = GET_X_LPARAM(lParam);
int my = GET_Y_LPARAM(lParam);
bool down = (message == WM_MBUTTONDOWN);
_al_win_mouse_handle_button(3, down, mx, my, true, win_display);
handle_mouse_capture(down, hWnd);
break;
}
case WM_RBUTTONDOWN:
case WM_RBUTTONUP: {
int mx = GET_X_LPARAM(lParam);
int my = GET_Y_LPARAM(lParam);
bool down = (message == WM_RBUTTONDOWN);
_al_win_mouse_handle_button(2, down, mx, my, true, win_display);
handle_mouse_capture(down, hWnd);
break;
}
case WM_XBUTTONDOWN:
case WM_XBUTTONUP: {
int mx = GET_X_LPARAM(lParam);
int my = GET_Y_LPARAM(lParam);
int button = HIWORD(wParam);
bool down = (message == WM_XBUTTONDOWN);
if (button == XBUTTON1)
_al_win_mouse_handle_button(4, down, mx, my, true, win_display);
else if (button == XBUTTON2)
_al_win_mouse_handle_button(5, down, mx, my, true, win_display);
handle_mouse_capture(down, hWnd);
return TRUE;
}
case WM_MOUSEWHEEL: {
int d = GET_WHEEL_DELTA_WPARAM(wParam);
_al_win_mouse_handle_wheel(d / WHEEL_DELTA, false, win_display);
return TRUE;
}
case WM_MOUSEMOVE: {
TRACKMOUSEEVENT tme;
int mx = GET_X_LPARAM(lParam);
int my = GET_Y_LPARAM(lParam);
if (win_display->mouse_cursor_shown && we_hid_the_mouse) {
we_hid_the_mouse = false;
win_display->display.vt->hide_mouse_cursor((void*)win_display);
}
_al_win_mouse_handle_move(mx, my, true, win_display);
if (mx >= 0 && my >= 0 && mx < d->w && my < d->h) {
tme.cbSize = sizeof(tme);
tme.dwFlags = TME_QUERY;
if (TrackMouseEvent(&tme) && !tme.hwndTrack) {
tme.dwFlags = TME_LEAVE;
tme.hwndTrack = hWnd;
tme.dwHoverTime = 0;
TrackMouseEvent(&tme);
_al_win_mouse_handle_enter(win_display);
}
}
break;
}
case WM_MOUSELEAVE: {
_al_win_mouse_handle_leave(win_display);
break;
}
case WM_CAPTURECHANGED: if (al_is_mouse_installed()) {
int i;
ALLEGRO_MOUSE_STATE state;
if (!lParam || (HWND)lParam == hWnd)
break;
al_get_mouse_state(&state);
for (i = 1; i <= 5; i++) {
if (al_mouse_button_down(&state, i))
_al_win_mouse_handle_button(i, 0, 0, 0, true, win_display);
}
break;
}
case WM_NCMOUSEMOVE: {
if (!win_display->mouse_cursor_shown) {
we_hid_the_mouse = true;
win_display->display.vt->show_mouse_cursor((void*)win_display);
}
break;
}
case WM_SYSKEYDOWN: {
int vcode = wParam;
bool repeated = (lParam >> 30) & 0x1;
_al_win_kbd_handle_key_press(0, vcode, repeated, win_display);
break;
}
case WM_KEYDOWN: {
int vcode = wParam;
int scode = (lParam >> 16) & 0xff;
bool repeated = (lParam >> 30) & 0x1;
/* We can't use TranslateMessage() because we don't know if it will
produce a WM_CHAR or not. */
_al_win_kbd_handle_key_press(scode, vcode, repeated, win_display);
break;
}
case WM_SYSKEYUP:
case WM_KEYUP: {
int vcode = wParam;
_al_win_kbd_handle_key_release(vcode, win_display);
break;
}
case WM_SYSCOMMAND: {
if (_al_win_disable_screensaver &&
((wParam & 0xfff0) == SC_MONITORPOWER || (wParam & 0xfff0) == SC_SCREENSAVE)) {
return 0;
}
else if ((wParam & 0xfff0) == SC_KEYMENU) {
/* Prevent Windows from intercepting the ALT key.
(Disables opening menus via the ALT key.) */
return 0;
}
break;
}
case WM_PAINT: {
if ((win_display->display.flags & ALLEGRO_GENERATE_EXPOSE_EVENTS) &&
_al_event_source_needs_to_generate_event(es)) {
RECT r;
HRGN hrgn;
GetWindowRect(win_display->window, &r);
hrgn = CreateRectRgn(r.left, r.top, r.right, r.bottom);
if (GetUpdateRgn(win_display->window, hrgn, false) != ERROR) {
PAINTSTRUCT ps;
DWORD size;
LPRGNDATA rgndata;
int n;
int i;
RECT *rects;
BeginPaint(win_display->window, &ps);
size = GetRegionData(hrgn, 0, NULL);
rgndata = _AL_MALLOC(size);
GetRegionData(hrgn, size, rgndata);
n = rgndata->rdh.nCount;
rects = (RECT *)rgndata->Buffer;
//GetWindowInfo(win_display->window, &wi);
_al_event_source_lock(es);
for (i = 0; i < n; i++) {
ALLEGRO_EVENT event;
event.display.type = ALLEGRO_EVENT_DISPLAY_EXPOSE;
event.display.timestamp = al_current_time();
event.display.x = rects[i].left;
event.display.y = rects[i].top;
event.display.width = rects[i].right - rects[i].left;
event.display.height = rects[i].bottom - rects[i].top;
_al_event_source_emit_event(es, &event);
}
_al_event_source_unlock(es);
_AL_FREE(rgndata);
EndPaint(win_display->window, &ps);
DeleteObject(hrgn);
}
return 0;
}
break;
}
case WM_SETCURSOR:
switch (LOWORD(lParam)) {
case HTLEFT:
case HTRIGHT:
SetCursor(LoadCursor(NULL, IDC_SIZEWE));
break;
case HTBOTTOM:
case HTTOP:
SetCursor(LoadCursor(NULL, IDC_SIZENS));
break;
case HTBOTTOMLEFT:
case HTTOPRIGHT:
SetCursor(LoadCursor(NULL, IDC_SIZENESW));
break;
case HTBOTTOMRIGHT:
case HTTOPLEFT:
SetCursor(LoadCursor(NULL, IDC_SIZENWSE));
break;
default:
if (win_display->mouse_cursor_shown) {
SetCursor(win_display->mouse_selected_hcursor);
}
else {
SetCursor(NULL);
}
break;
}
return 1;
case WM_ACTIVATE:
if (LOWORD(wParam) != WA_INACTIVE) {
/* This SetWindowPos is for faux-fullscreen windows that lost focus
* so they can get placed back on top
*/
// FIXME: this doesn't seem to work
//SetWindowPos(win_display->window, HWND_TOP, 0, 0, 0, 0,
// SWP_NOMOVE | SWP_NOSIZE);
if (d->vt->switch_in)
d->vt->switch_in(d);
_al_event_source_lock(es);
if (_al_event_source_needs_to_generate_event(es)) {
ALLEGRO_EVENT event;
event.display.type = ALLEGRO_EVENT_DISPLAY_SWITCH_IN;
event.display.timestamp = al_current_time();
_al_event_source_emit_event(es, &event);
}
_al_event_source_unlock(es);
_al_win_grab_input(win_display);
return 0;
}
else {
if (d->flags & ALLEGRO_FULLSCREEN) {
d->vt->switch_out(d);
}
_al_event_source_lock(es);
if (_al_event_source_needs_to_generate_event(es)) {
ALLEGRO_EVENT event;
event.display.type = ALLEGRO_EVENT_DISPLAY_SWITCH_OUT;
event.display.timestamp = al_current_time();
_al_event_source_emit_event(es, &event);
}
_al_event_source_unlock(es);
return 0;
}
break;
case WM_MENUCHAR :
return (MNC_CLOSE << 16) | (wParam & 0xffff);
case WM_CLOSE:
_al_event_source_lock(es);
if (_al_event_source_needs_to_generate_event(es)) {
ALLEGRO_EVENT event;
event.display.type = ALLEGRO_EVENT_DISPLAY_CLOSE;
event.display.timestamp = al_current_time();
_al_event_source_emit_event(es, &event);
}
_al_event_source_unlock(es);
return 0;
case WM_SIZE:
if (wParam == SIZE_RESTORED || wParam == SIZE_MAXIMIZED || wParam == SIZE_MINIMIZED) {
/*
* Delay the resize event so we don't get bogged down with them
*/
if (!resize_postponed) {
resize_postponed = true;
postpone_resize(win_display->window);
}
}
return 0;
case WM_USER+0:
/* Generate a resize event if the size has changed. We cannot asynchronously
* change the display size here yet, since the user will only know about a
* changed size after receiving the resize event. Here we merely add the
* event to the queue.
*/
GetWindowInfo(win_display->window, &wi);
x = wi.rcClient.left;
y = wi.rcClient.top;
w = wi.rcClient.right - wi.rcClient.left;
h = wi.rcClient.bottom - wi.rcClient.top;
if (d->w != w || d->h != h) {
_al_event_source_lock(es);
if (_al_event_source_needs_to_generate_event(es)) {
ALLEGRO_EVENT event;
event.display.type = ALLEGRO_EVENT_DISPLAY_RESIZE;
event.display.timestamp = al_current_time();
event.display.x = x;
event.display.y = y;
event.display.width = w;
event.display.height = h;
_al_event_source_emit_event(es, &event);
}
/* Generate an expose event. */
if (_al_event_source_needs_to_generate_event(es)) {
ALLEGRO_EVENT event;
event.display.type = ALLEGRO_EVENT_DISPLAY_EXPOSE;
event.display.timestamp = al_current_time();
event.display.x = x;
event.display.y = y;
event.display.width = w;
event.display.height = h;
_al_event_source_emit_event(es, &event);
}
_al_event_source_unlock(es);
}
resize_postponed = false;
win_display->can_acknowledge = true;
return 0;
}
return DefWindowProc(hWnd,message,wParam,lParam);
}
static ALLEGRO_DISPLAY *raspberrypi_create_display(int w, int h)
{
ALLEGRO_DISPLAY_RASPBERRYPI *d = al_calloc(1, sizeof *d);
ALLEGRO_DISPLAY *display = (void*)d;
ALLEGRO_OGL_EXTRAS *ogl = al_calloc(1, sizeof *ogl);
display->ogl_extras = ogl;
display->vt = _al_get_raspberrypi_display_interface();
display->flags = al_get_new_display_flags();
ALLEGRO_SYSTEM_RASPBERRYPI *system = (void *)al_get_system_driver();
/* Add ourself to the list of displays. */
ALLEGRO_DISPLAY_RASPBERRYPI **add;
add = _al_vector_alloc_back(&system->system.displays);
*add = d;
/* Each display is an event source. */
_al_event_source_init(&display->es);
display->extra_settings.settings[ALLEGRO_COMPATIBLE_DISPLAY] = 1;
display->w = w;
display->h = h;
if (!pi_create_display(display)) {
// FIXME: cleanup
return NULL;
}
if (getenv("DISPLAY")) {
_al_mutex_lock(&system->lock);
Window root = RootWindow(
system->x11display, DefaultScreen(system->x11display));
XWindowAttributes attr;
XGetWindowAttributes(system->x11display, root, &attr);
d->window = XCreateWindow(
system->x11display,
root,
0,
0,
attr.width,
attr.height,
0, 0,
InputOnly,
DefaultVisual(system->x11display, 0),
0,
NULL
);
XGetWindowAttributes(system->x11display, d->window, &attr);
XSelectInput(
system->x11display,
d->window,
PointerMotionMask | KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask
);
XMapWindow(system->x11display, d->window);
_al_xwin_reset_size_hints(display);
_al_xwin_set_fullscreen_window(display, 2);
_al_xwin_set_size_hints(display, INT_MAX, INT_MAX);
d->wm_delete_window_atom = XInternAtom(system->x11display,
"WM_DELETE_WINDOW", False);
XSetWMProtocols(system->x11display, d->window, &d->wm_delete_window_atom, 1);
_al_mutex_unlock(&system->lock);
}
al_grab_mouse(display);
_al_ogl_manage_extensions(display);
_al_ogl_set_extensions(ogl->extension_api);
setup_gl(display);
al_set_blender(ALLEGRO_ADD, ALLEGRO_ONE, ALLEGRO_INVERSE_ALPHA);
display->flags |= ALLEGRO_OPENGL;
if (al_is_mouse_installed() && !getenv("DISPLAY")) {
_al_evdev_set_mouse_range(0, 0, display->w-1, display->h-1);
}
set_cursor_data(d, default_cursor, DEFAULT_CURSOR_WIDTH, DEFAULT_CURSOR_HEIGHT);
return display;
}
MouseHandler :: MouseHandler()
{
if (!al_is_mouse_installed()) al_install_mouse();
}
static int allua_mouse_is_installed(lua_State * L)
{
lua_pushboolean(L, al_is_mouse_installed());
return 1;
}
