void Gui::handleMouseInput()
{
while (!mInput->isMouseQueueEmpty())
{
MouseInput mouseInput = mInput->dequeueMouseInput();
// Save the current mouse state. It will be needed if modal focus
// changes or modal mouse input focus changes.
mLastMouseX = mouseInput.getX();
mLastMouseY = mouseInput.getY();
switch (mouseInput.getType())
{
case MouseInput::PRESSED:
handleMousePressed(mouseInput);
break;
case MouseInput::RELEASED:
handleMouseReleased(mouseInput);
break;
case MouseInput::MOVED:
handleMouseMoved(mouseInput);
break;
case MouseInput::WHEEL_MOVED_DOWN:
handleMouseWheelMovedDown(mouseInput);
break;
case MouseInput::WHEEL_MOVED_UP:
handleMouseWheelMovedUp(mouseInput);
break;
default:
throw GCN_EXCEPTION("Unknown mouse input type.");
break;
}
}
}
//-------------------------------------------------------------------------------------------------
ALVR_RESULT HandleKeyboard(UINT_PTR ch)
{
if(ch == 'E' || ch == 'e')
{
g_MouseInput.SetEmulation(!g_MouseInput.GetEmulation());
}
else if(ch == 'L' || ch == 'l')
{
g_bLateLatchRight = !g_bLateLatchRight;
}
else if(ch == 'A' || ch == 'a')
{
g_bRotate = !g_bRotate;
}
else if(ch == VK_UP)
{
ChangeDrawRepeat(true);
}
else if(ch == VK_DOWN)
{
ChangeDrawRepeat(false);
}
else
{
return ALVR_FALSE;
}
return ALVR_OK;
}
Qt3DCore::QBackendNode *MouseInputFunctor::create(Qt3DCore::QNode *frontend, const Qt3DCore::QBackendNodeFactory *factory) const
{
MouseInput *input = m_handler->mouseInputManager()->getOrCreateResource(frontend->id());
input->setFactory(factory);
input->setInputHandler(m_handler);
input->setPeer(frontend);
return input;
}
void GLUTInput::pushMotionInput(int x, int y)
{
MouseInput mouseInput;
mouseInput.setX(x);
mouseInput.setY(y);
mouseInput.setButton(MouseInput::EMPTY);
mouseInput.setType(MouseInput::MOVED);
mMouseInputQueue.push(mouseInput);
}
void GenericInput::pushMouseWheelMovedDown(int x, int y)
{
MouseInput mouseInput;
mouseInput.setX(x);
mouseInput.setY(y);
mouseInput.setType(MouseInput::WHEEL_MOVED_DOWN);
mMouseInputQueue.push(mouseInput);
}
void GenericInput::pushMouseMoved(int x, int y)
{
MouseInput mouseInput;
mouseInput.setX(x);
mouseInput.setY(y);
mouseInput.setType(MouseInput::MOVED);
mMouseInputQueue.push(mouseInput);
}
void GenericInput::pushMouseButtonReleased(int x, int y, int button)
{
MouseInput mouseInput;
mouseInput.setX(x);
mouseInput.setY(y);
mouseInput.setButton(button);
mouseInput.setType(MouseInput::RELEASED);
mMouseInputQueue.push(mouseInput);
}
void
DragBlockState::DispatchEvent(const InputData& aEvent) const
{
MouseInput mouseInput = aEvent.AsMouseInput();
if (!mouseInput.TransformToLocal(mTransformToApzc)) {
return;
}
GetTargetApzc()->HandleDragEvent(mouseInput, mDragMetrics);
}
int main(int argc, char ** argv) {
std::cout << "Starting Controller Mouse Emulator" << std::endl;
float mouseSpeed = 15;
float scrollSpeed = 25;
MouseInput mouseInput;
Gamepad gamepad;
int dx, dy;
int sy;
while (true) {
gamepad.update();
dx = (int)(gamepad.getLThumbX() * mouseSpeed);
dy = (int)(-gamepad.getLThumbY() * mouseSpeed);
sy = (int)(gamepad.getRThumbY() * scrollSpeed);
mouseInput.moveMouse(dx, dy);
mouseInput.scrollWheel(sy);
if (gamepad.aPressed())
mouseInput.setLeftMouseDown(true);
else if (gamepad.aReleased())
mouseInput.setLeftMouseDown(false);
if (gamepad.bPressed())
mouseInput.setRightMouseDown(true);
else if (gamepad.bReleased())
mouseInput.setRightMouseDown(false);
if (gamepad.rsPressed())
mouseInput.setMiddleMouseDown(true);
else if (gamepad.rsReleased())
mouseInput.setMiddleMouseDown(false);
if (gamepad.rbPressed() && mouseSpeed < MAX_MOUSE_SPEED) {
mouseSpeed += SPEED_INCREMENT;
std::cout << "Mouse speed: " << mouseSpeed << std::endl;
}
if (gamepad.lbPressed() && mouseSpeed > SPEED_INCREMENT) {
mouseSpeed -= SPEED_INCREMENT;
std::cout << "Mouse speed: " << mouseSpeed << std::endl;
}
gamepad.updateInput();
Sleep(15);
}
return 0;
}
static void ConvertMouseEvent( wxMouseEvent& event, MouseInput& input )
{
uint32_t buttons = 0x0;
buttons |= event.LeftIsDown() ? MouseButtons::Left : 0x0;
buttons |= event.MiddleIsDown() ? MouseButtons::Middle : 0x0;
buttons |= event.RightIsDown() ? MouseButtons::Right : 0x0;
buttons |= event.Aux1IsDown() ? MouseButtons::Backward : 0x0;
buttons |= event.Aux2IsDown() ? MouseButtons::Forward : 0x0;
buttons |= event.AltDown() ? AcceleratorButtons::Alt : 0x0;
buttons |= event.ControlDown() ? AcceleratorButtons::Ctrl : 0x0;
buttons |= event.ShiftDown() ? AcceleratorButtons::Shift : 0x0;
input.SetButtons( buttons );
input.SetPosition( Point( event.GetX(), event.GetY() ) );
}
void Gui::handleMouseWheelMovedUp(const MouseInput& mouseInput)
{
WidgetPtr sourceWidget = GetMouseEventSource(mouseInput.getX(), mouseInput.getY());
if (mFocusHandler->GetDraggedWidget() != NULL)
{
sourceWidget = mFocusHandler->GetDraggedWidget();
}
int sourceWidgetX, sourceWidgetY;
sourceWidget->getAbsolutePosition(sourceWidgetX, sourceWidgetY);
distributeMouseEvent(sourceWidget,
MouseEvent::WHEEL_MOVED_UP,
mouseInput.getButton(),
mouseInput.getX(),
mouseInput.getY());
}
void SDLInput::simulateMouseClick(const int x, const int y,
const MouseButton::Type button)
{
MouseInput mouseInput;
mouseInput.setX(x);
mouseInput.setY(y);
mouseInput.setReal(x, y);
mouseInput.setButton(button);
mouseInput.setType(MouseEventType::PRESSED);
mouseInput.setTimeStamp(SDL_GetTicks());
mMouseInputQueue.push(mouseInput);
mouseInput.setType(MouseEventType::RELEASED);
mouseInput.setTimeStamp(SDL_GetTicks());
mMouseInputQueue.push(mouseInput);
}
void Gui::handleMousePressed(const MouseInput& mouseInput)
{
WidgetPtr sourceWidget = GetMouseEventSource(mouseInput.getX(), mouseInput.getY());
if (mFocusHandler->GetDraggedWidget())
{
sourceWidget = mFocusHandler->GetDraggedWidget();
}
int sourceWidgetX, sourceWidgetY;
sourceWidget->getAbsolutePosition(sourceWidgetX, sourceWidgetY);
if ((mFocusHandler->GetModalFocused() != NULL
&& sourceWidget->isModalFocused())
|| mFocusHandler->GetModalFocused() == NULL)
{
sourceWidget->requestFocus();
}
if (mouseInput.getTimeStamp() - mLastMousePressTimeStamp < 250
&& mLastMousePressButton == mouseInput.getButton())
{
mClickCount++;
}
else
{
mClickCount = 1;
}
distributeMouseEvent(sourceWidget,
MouseEvent::PRESSED,
mouseInput.getButton(),
mouseInput.getX(),
mouseInput.getY());
mFocusHandler->SetLastWidgetPressed(sourceWidget);
mFocusHandler->SetDraggedWidget(sourceWidget);
mLastMouseDragButton = mouseInput.getButton();
mLastMousePressButton = mouseInput.getButton();
mLastMousePressTimeStamp = mouseInput.getTimeStamp();
}
void mouseInputMotion(int x, int y)
{
g_MouseInput.LastLocation.X = x;
g_MouseInput.LastLocation.Y = y;
if (g_MouseInput.pCursorCallback != NULL)
g_MouseInput.pCursorCallback(g_MouseInput.LastLocation);
if (g_MouseInput.nSelectionState == SELECTION_ACTIVE)
mouseInputCallSelection();
}
void Gui::handleMouseReleased(const MouseInput& mouseInput)
{
WidgetPtr sourceWidget = GetMouseEventSource(mouseInput.getX(), mouseInput.getY());
if (mFocusHandler->GetDraggedWidget())
{
if (sourceWidget != mFocusHandler->GetLastWidgetPressed())
{
mFocusHandler->SetLastWidgetPressed(WidgetPtr());
}
sourceWidget = mFocusHandler->GetDraggedWidget();
}
int sourceWidgetX, sourceWidgetY;
sourceWidget->getAbsolutePosition(sourceWidgetX, sourceWidgetY);
distributeMouseEvent(sourceWidget,
MouseEvent::RELEASED,
mouseInput.getButton(),
mouseInput.getX(),
mouseInput.getY());
if (mouseInput.getButton() == mLastMousePressButton
&& mFocusHandler->GetLastWidgetPressed() == sourceWidget)
{
distributeMouseEvent(sourceWidget,
MouseEvent::CLICKED,
mouseInput.getButton(),
mouseInput.getX(),
mouseInput.getY());
mFocusHandler->SetLastWidgetPressed(WidgetPtr());
}
else
{
mLastMousePressButton = 0;
mClickCount = 0;
}
if (mFocusHandler->GetDraggedWidget())
{
mFocusHandler->SetDraggedWidget(WidgetPtr());
}
}
void mouseInputCallSelection()
{
if (g_MouseInput.pSelectionCallback != NULL)
{
UIntRect selection;
selection.uBottom = XN_MIN(g_MouseInput.StartSelection.Y, g_MouseInput.LastLocation.Y);
selection.uTop = XN_MAX(g_MouseInput.StartSelection.Y, g_MouseInput.LastLocation.Y);
selection.uLeft = XN_MIN(g_MouseInput.StartSelection.X, g_MouseInput.LastLocation.X);
selection.uRight = XN_MAX(g_MouseInput.StartSelection.X, g_MouseInput.LastLocation.X);
g_MouseInput.pSelectionCallback(g_MouseInput.nSelectionState, selection);
}
}
//-------------------------------------------------------------------------------------------------
ALVR_RESULT Terminate()
{
g_MouseInput.Terminate();
g_pFenceD3D11.Release();
g_pLvrDevice.Release();
::DestroyWindow(g_hWindow);
g_D3DHelper.Terminate();
#if defined(AFFINITY_WORK_AROUND)
m_pLvrAffinity.Release();
#endif
g_pFactory = NULL;
::FreeLibrary(g_hLiquidVRDLL);
return ALVR_OK;
}
void GLUTInput::pushMouseInput(int button, int state, int x, int y)
{
MouseInput mouseInput;
mouseInput.setX(x);
mouseInput.setY(y);
mouseInput.setButton(convertMouseButton(button));
if (state == GLUT_DOWN)
{
mouseInput.setType(MouseInput::PRESSED);
}
else
{
mouseInput.setType(MouseInput::RELEASED);
}
mMouseInputQueue.push(mouseInput);
}
void SDLInput::pushInput(const SDL_Event &event)
{
BLOCK_START("SDLInput::pushInput")
KeyInput keyInput;
MouseInput mouseInput;
switch (event.type)
{
case SDL_KEYDOWN:
{
keyInput.setType(KeyEventType::PRESSED);
convertKeyEventToKey(event, keyInput);
mKeyInputQueue.push(keyInput);
break;
}
case SDL_KEYUP:
{
keyInput.setType(KeyEventType::RELEASED);
convertKeyEventToKey(event, keyInput);
mKeyInputQueue.push(keyInput);
break;
}
#ifdef USE_SDL2
case SDL_TEXTINPUT:
keyInput.setType(KeyEventType::PRESSED);
keyInput.setKey(Key(Key::TEXTINPUT));
keyInput.setText(event.text.text);
mKeyInputQueue.push(keyInput);
break;
case SDL_MOUSEWHEEL:
{
const int y = event.wheel.y;
if (y)
{
mouseInput.setX(gui->getLastMouseX());
mouseInput.setY(gui->getLastMouseY());
#ifdef ANDROID
mouseInput.setReal(0, 0);
#endif
mouseInput.setButton(MouseButton::WHEEL);
if (y > 0)
mouseInput.setType(MouseEventType::WHEEL_MOVED_UP);
else
mouseInput.setType(MouseEventType::WHEEL_MOVED_DOWN);
mouseInput.setTimeStamp(SDL_GetTicks());
mMouseInputQueue.push(mouseInput);
}
break;
}
#endif
#ifdef ANDROID
#ifndef USE_SDL2
case SDL_ACCELEROMETER:
break;
#endif
#endif
case SDL_MOUSEBUTTONDOWN:
{
mMouseDown = true;
const int scale = mainGraphics->getScale();
const int x = event.button.x / scale;
const int y = event.button.y / scale;
mouseInput.setX(x);
mouseInput.setY(y);
#ifdef ANDROID
#ifdef USE_SDL2
mouseInput.setReal(x, y);
#else
mouseInput.setReal(event.button.realx / scale,
event.button.realy / scale);
#endif
#endif
mouseInput.setButton(convertMouseButton(event.button.button));
#ifndef USE_SDL2
if (event.button.button == SDL_BUTTON_WHEELDOWN)
mouseInput.setType(MouseEventType::WHEEL_MOVED_DOWN);
else if (event.button.button == SDL_BUTTON_WHEELUP)
mouseInput.setType(MouseEventType::WHEEL_MOVED_UP);
else
#endif
mouseInput.setType(MouseEventType::PRESSED);
mouseInput.setTimeStamp(SDL_GetTicks());
mMouseInputQueue.push(mouseInput);
break;
}
case SDL_MOUSEBUTTONUP:
{
mMouseDown = false;
const int scale = mainGraphics->getScale();
const int x = event.button.x / scale;
const int y = event.button.y / scale;
mouseInput.setX(x);
mouseInput.setY(y);
#ifdef ANDROID
#ifdef USE_SDL2
mouseInput.setReal(x, y);
#else
mouseInput.setReal(event.button.realx / scale,
event.button.realy / scale);
#endif
#endif
mouseInput.setButton(convertMouseButton(event.button.button));
mouseInput.setType(MouseEventType::RELEASED);
mouseInput.setTimeStamp(SDL_GetTicks());
mMouseInputQueue.push(mouseInput);
break;
}
case SDL_MOUSEMOTION:
{
const int scale = mainGraphics->getScale();
const int x = event.motion.x / scale;
const int y = event.motion.y / scale;
mouseInput.setX(x);
mouseInput.setY(y);
#ifdef ANDROID
#ifdef USE_SDL2
mouseInput.setReal(x, y);
#else
mouseInput.setReal(event.motion.realx / scale,
event.motion.realy / scale);
#endif
#endif
mouseInput.setButton(MouseButton::EMPTY);
mouseInput.setType(MouseEventType::MOVED);
mouseInput.setTimeStamp(SDL_GetTicks());
mMouseInputQueue.push(mouseInput);
break;
}
#ifndef USE_SDL2
case SDL_ACTIVEEVENT:
/*
* This occurs when the mouse leaves the window and the Gui-chan
* application loses its mousefocus.
*/
if ((event.active.state & SDL_APPMOUSEFOCUS) && !event.active.gain)
{
mMouseInWindow = false;
if (!mMouseDown)
{
mouseInput.setX(-1);
mouseInput.setY(-1);
mouseInput.setButton(MouseButton::EMPTY);
mouseInput.setType(MouseEventType::MOVED);
mMouseInputQueue.push(mouseInput);
}
}
if ((event.active.state & SDL_APPMOUSEFOCUS) && event.active.gain)
mMouseInWindow = true;
break;
#endif
default:
break;
} // end switch
BLOCK_END("SDLInput::pushInput")
}
//-------------------------------------------------------------------------------------------------
ALVR_RESULT Init()
{
HRESULT hr = S_OK;
//---------------------------------------------------------------------------------------------
// Init ALVR
//---------------------------------------------------------------------------------------------
ALVR_RESULT res = ALVR_OK;
g_hLiquidVRDLL = LoadLibraryW(ALVR_DLL_NAME);
CHECK_RETURN(g_hLiquidVRDLL != NULL, ALVR_FAIL, L"DLL " << ALVR_DLL_NAME << L" is not found");
ALVRInit_Fn pInit = (ALVRInit_Fn)GetProcAddress(g_hLiquidVRDLL, ALVR_INIT_FUNCTION_NAME);
res = pInit(ALVR_FULL_VERSION, (void**)&g_pFactory);
CHECK_ALVR_ERROR_RETURN(res, ALVR_INIT_FUNCTION_NAME << L"failed");
#if defined(AFFINITY_WORK_AROUND)
res = g_pFactory->CreateGpuAffinity(&m_pLvrAffinity);
// CHECK_ALVR_ERROR_RETURN(res, L"CreateGpuAffinity() failed");
if(m_pLvrAffinity != NULL)
{
res = m_pLvrAffinity->EnableGpuAffinity(ALVR_GPU_AFFINITY_FLAGS_NONE);
CHECK_ALVR_ERROR_RETURN(res, L"EnableGpuAffinity() failed");
res = m_pLvrAffinity->DisableGpuAffinity();
CHECK_ALVR_ERROR_RETURN(res, L"EnableGpuAffinity() failed");
}
#endif
//---------------------------------------------------------------------------------------------
// create D3D11 device
//---------------------------------------------------------------------------------------------
res = g_D3DHelper.CreateD3D11Device();
CHECK_ALVR_ERROR_RETURN(res, L"CreateD3D11Device() failed");
res = g_pFactory->CreateALVRDeviceExD3D11(g_D3DHelper.m_pd3dDevice, NULL, &g_pLvrDevice);
CHECK_ALVR_ERROR_RETURN(res, L"CreateALVRDeviceExD3D11() failed");
res = g_pLvrDevice->CreateFence(&g_pFenceD3D11);
CHECK_ALVR_ERROR_RETURN(res, L"CreateFence() failed");
//---------------------------------------------------------------------------------------------
// create window
//---------------------------------------------------------------------------------------------
HINSTANCE hInstance = (HINSTANCE)GetModuleHandle(NULL);
WNDCLASSEX wcex = {0};
wcex.cbSize = sizeof(WNDCLASSEX);
wcex.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
wcex.lpfnWndProc = MyDefWindowProcW;
wcex.cbClsExtra = 0;
wcex.cbWndExtra = 0;
wcex.hInstance = hInstance;
wcex.hIcon = NULL;
wcex.hCursor = LoadCursor(NULL, IDC_ARROW);
wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
wcex.lpszClassName = L"SimpleMGPU";
wcex.hIconSm = NULL;
RegisterClassEx(&wcex);
int posX = 0;
int posY = 0;
UINT count=0;
int adapterIDLocal = 0;
DISPLAY_DEVICE displayDevice;
displayDevice.cb = sizeof(displayDevice);
while(true)
{
if(EnumDisplayDevices(NULL, count, &displayDevice, 0) == FALSE)
{
break;
}
if(displayDevice.StateFlags & DISPLAY_DEVICE_ACTIVE)
{
if(displayDevice.StateFlags & DISPLAY_DEVICE_PRIMARY_DEVICE)
{
break;
}
adapterIDLocal++;
}
count++;
}
EnumDisplayMonitors(NULL, NULL, MyDisplayEnumProc, (LPARAM)displayDevice.DeviceName);
// find adapter and provide coordinates
unsigned int width = (g_MonitorWorkArea.right - g_MonitorWorkArea.left) * 2 / 3;
unsigned int height = (g_MonitorWorkArea.bottom - g_MonitorWorkArea.top) * 2 / 3;
posX = (g_MonitorWorkArea.left + g_MonitorWorkArea.right) / 2 - width / 2;
posY = (g_MonitorWorkArea.top + g_MonitorWorkArea.bottom) / 2 - height / 2;
// GetWindowPosition(posX, posY);
g_hWindow = CreateWindow(L"SimpleMGPU", L"SimpleMGPU", WS_POPUP,
posX, posY, width, height, NULL, NULL, hInstance, NULL);
CHECK_RETURN(g_hWindow != NULL, ALVR_FAIL, L"Window failed to create");
::ShowWindow(g_hWindow, SW_NORMAL);
::UpdateWindow(g_hWindow);
//---------------------------------------------------------------------------------------------
// Create swap chain
//---------------------------------------------------------------------------------------------
res = g_D3DHelper.CreateSwapChain(g_hWindow, g_iBackbufferCount);
CHECK_ALVR_ERROR_RETURN(res, L"CreateSwapChain() failed");
//---------------------------------------------------------------------------------------------
// prepare 3D scene
//---------------------------------------------------------------------------------------------
res = g_D3DHelper.Create3DScene(width, height, true);
CHECK_ALVR_ERROR_RETURN(res, L"Create3DScene() failed");
g_MouseInput.Init((HINSTANCE)GetModuleHandle(NULL), g_hWindow, &g_D3DHelper, 200);
g_MouseInput.SetEmulation(true);
return ALVR_OK;
}
void Widget::_mouseInputMessage(const MouseInput& mouseInput)
{
if (mFocusHandler == NULL)
{
//throw GCN_EXCEPTION("No focushandler set (did you add the widget to the gui?).");
assert(!"No focushandler set (did you add the widget to the gui?).");
}
if (!mEnabled || (mFocusHandler->getModalFocused() != NULL &&
!hasModalFocus()))
{
return;
}
int x = mouseInput.x;
int y = mouseInput.y;
int b = mouseInput.getButton();
int ts = mouseInput.getTimeStamp();
MouseListenerIterator iter;
switch(mouseInput.getType())
{
case MouseInput::MOTION:
for (iter = mMouseListeners.begin(); iter != mMouseListeners.end(); ++iter)
{
(*iter)->mouseMotion(x, y);
}
break;
case MouseInput::PRESS:
if (hasMouse())
{
requestFocus();
mFocusHandler->requestDrag(this);
}
if (b != MouseInput::WHEEL_UP && b != MouseInput::WHEEL_DOWN)
{
for (iter = mMouseListeners.begin(); iter != mMouseListeners.end(); ++iter)
{
(*iter)->mousePress(x, y, b);
}
if (hasMouse())
{
if (ts - mClickTimeStamp < 300 && mClickButton == b)
{
mClickCount++;
}
else
{
mClickCount = 0;
}
mClickButton = b;
mClickTimeStamp = ts;
}
else
{
mClickButton = 0;
}
}
else if (b == MouseInput::WHEEL_UP)
{
for (iter = mMouseListeners.begin(); iter != mMouseListeners.end(); ++iter)
{
(*iter)->mouseWheelUp(x, y);
}
}
else
{
for (iter = mMouseListeners.begin(); iter != mMouseListeners.end(); ++iter)
{
(*iter)->mouseWheelDown(x, y);
}
}
setDirty(true);
break;
case MouseInput::RELEASE:
if (isDragged())
{
mFocusHandler->dragNone();
}
if (b != MouseInput::WHEEL_UP && b != MouseInput::WHEEL_DOWN)
{
for (iter = mMouseListeners.begin(); iter != mMouseListeners.end(); ++iter)
{
(*iter)->mouseRelease(x, y, b);
}
}
if (mHasMouse)
{
if (b == mClickButton)
{
for (iter = mMouseListeners.begin(); iter != mMouseListeners.end(); ++iter)
{
(*iter)->mouseClick(x, y, b, mClickCount + 1);
}
}
else
{
mClickButton = 0;
mClickCount = 0;
}
}
else
{
mClickCount = 0;
mClickTimeStamp = 0;
}
setDirty(true);
break;
}
}
void SDLInput::pushInput(SDL_Event event)
{
KeyInput keyInput;
MouseInput mouseInput;
switch (event.type)
{
case SDL_KEYDOWN:
keyInput.setKey(convertKeyCharacter(event.key.keysym));
keyInput.setType(KeyInput::PRESS);
mKeyInputQueue.push(keyInput);
break;
case SDL_KEYUP:
keyInput.setKey(convertKeyCharacter(event.key.keysym));
keyInput.setType(KeyInput::RELEASE);
mKeyInputQueue.push(keyInput);
break;
case SDL_MOUSEBUTTONDOWN:
mMouseDown = true;
mouseInput.x = event.button.x;
mouseInput.y = event.button.y;
mouseInput.setButton(convertMouseButton(event.button.button));
mouseInput.setType(MouseInput::PRESS);
mouseInput.setTimeStamp(SDL_GetTicks());
mMouseInputQueue.push(mouseInput);
break;
case SDL_MOUSEBUTTONUP:
mMouseDown = false;
mouseInput.x = event.button.x;
mouseInput.y = event.button.y;
mouseInput.setButton(convertMouseButton(event.button.button));
mouseInput.setType(MouseInput::RELEASE);
mouseInput.setTimeStamp(SDL_GetTicks());
mMouseInputQueue.push(mouseInput);
break;
case SDL_MOUSEMOTION:
mouseInput.x = event.button.x;
mouseInput.y = event.button.y;
mouseInput.setButton(MouseInput::EMPTY);
mouseInput.setType(MouseInput::MOTION);
mouseInput.setTimeStamp(SDL_GetTicks());
mMouseInputQueue.push(mouseInput);
break;
case SDL_ACTIVEEVENT:
/*
* This occurs when the mouse leaves the window and the Gui-chan
* application loses its mousefocus.
*/
if ((event.active.state & SDL_APPMOUSEFOCUS)
&& !event.active.gain)
{
mMouseInWindow = false;
if (!mMouseDown)
{
mouseInput.x = -1;
mouseInput.y = -1;
mouseInput.setButton(MouseInput::EMPTY);
mouseInput.setType(MouseInput::MOTION);
mMouseInputQueue.push(mouseInput);
}
}
if ((event.active.state & SDL_APPMOUSEFOCUS)
&& event.active.gain)
{
mMouseInWindow = true;
}
break;
} // end switch
}
void Gui::handleMouseMoved(const MouseInput& mouseInput)
{
// Check if the mouse leaves the application window.
if (!mWidgetWithMouseQueue.empty()
&& (mouseInput.getX() < 0
|| mouseInput.getY() < 0
|| !mTop->GetDimension().isPointInRect(mouseInput.getX(), mouseInput.getY()))
)
{
// Distribute an event to all widgets in the "widget with mouse" queue.
while (!mWidgetWithMouseQueue.empty())
{
WidgetPtr widget = mWidgetWithMouseQueue.front();
if (Widget::widgetExists(widget))
{
distributeMouseEvent(widget,
MouseEvent::EXITED,
mouseInput.getButton(),
mouseInput.getX(),
mouseInput.getY(),
true,
true);
}
mWidgetWithMouseQueue.pop_front();
}
return;
}
// Check if there is a need to send mouse exited events by
// traversing the "widget with mouse" queue.
bool widgetWithMouseQueueCheckDone = mWidgetWithMouseQueue.empty();
while (!widgetWithMouseQueueCheckDone)
{
unsigned int iterations = 0;
std::deque<WidgetPtr>::iterator iter;
for (iter = mWidgetWithMouseQueue.begin();
iter != mWidgetWithMouseQueue.end();
iter++)
{
WidgetPtr widget = *iter;
// If a widget in the "widget with mouse queue" doesn't
// exists anymore it should be removed from the queue.
if (!Widget::widgetExists(widget))
{
mWidgetWithMouseQueue.erase(iter);
break;
}
else
{
int x, y;
widget->getAbsolutePosition(x, y);
if (x > mouseInput.getX()
|| y > mouseInput.getY()
|| x + widget->GetWidth() <= mouseInput.getX()
|| y + widget->GetHeight() <= mouseInput.getY()
|| !widget->IsVisible())
{
distributeMouseEvent(widget,
MouseEvent::EXITED,
mouseInput.getButton(),
mouseInput.getX(),
mouseInput.getY(),
true,
true);
mClickCount = 1;
mLastMousePressTimeStamp = 0;
mWidgetWithMouseQueue.erase(iter);
break;
}
}
iterations++;
}
widgetWithMouseQueueCheckDone = iterations == mWidgetWithMouseQueue.size();
}
// Check all widgets below the mouse to see if they are
// present in the "widget with mouse" queue. If a widget
// is not then it should be added and an entered event should
// be sent to it.
WidgetPtr parent = GetMouseEventSource(mouseInput.getX(), mouseInput.getY());
WidgetPtr widget = parent;
// If a widget has modal mouse input focus then it will
// always be returned from getMouseEventSource, but we only wan't to send
// mouse entered events if the mouse has actually entered the widget with
// modal mouse input focus, hence we need to check if that's the case. If
// it's not we should simply ignore to send any mouse entered events.
if (mFocusHandler->GetModalMouseInputFocused()
&& widget == mFocusHandler->GetModalMouseInputFocused()
&& Widget::widgetExists(widget))
{
int x, y;
widget->getAbsolutePosition(x, y);
if (x > mouseInput.getX()
|| y > mouseInput.getY()
|| x + widget->GetWidth() <= mouseInput.getX()
|| y + widget->GetHeight() <= mouseInput.getY())
{
parent.reset();
}
}
while (parent)
{
parent = widget->GetParent();
// Check if the widget is present in the "widget with mouse" queue.
bool widgetIsPresentInQueue = false;
std::deque<WidgetPtr>::iterator iter;
for (iter = mWidgetWithMouseQueue.begin();
iter != mWidgetWithMouseQueue.end();
iter++)
{
if (*iter == widget)
{
widgetIsPresentInQueue = true;
break;
}
}
// Widget is not present, send an entered event and add
// it to the "widget with mouse" queue.
if (!widgetIsPresentInQueue
&& Widget::widgetExists(widget))
{
distributeMouseEvent(widget,
MouseEvent::ENTERED,
mouseInput.getButton(),
mouseInput.getX(),
mouseInput.getY(),
true,
true);
mWidgetWithMouseQueue.push_front(widget);
}
WidgetPtr swap = widget;
widget = parent;
parent = (WidgetPtr)swap->GetParent();
}
if (mFocusHandler->GetDraggedWidget())
{
distributeMouseEvent(mFocusHandler->GetDraggedWidget(),
MouseEvent::DRAGGED,
mLastMouseDragButton,
mouseInput.getX(),
mouseInput.getY());
}
else
{
WidgetPtr sourceWidget = GetMouseEventSource(mouseInput.getX(), mouseInput.getY());
distributeMouseEvent(sourceWidget,
MouseEvent::MOVED,
mouseInput.getButton(),
mouseInput.getX(),
mouseInput.getY());
}
}
void DirectX3DInput:: dispatchMessage(HWND window, MSG message)
{
KeyInput keyInput;
MouseInput mouseInput;
WPARAM wParam = message.wParam;
LPARAM lParam = message.lParam;
switch (message.message)
{
case WM_SYSKEYDOWN:
case WM_KEYDOWN:
{
unsigned char kbstate[256];
GetKeyboardState(kbstate);
keyInput.setKey(Key(convertKeyCharacter(wParam, lParam, kbstate)));
keyInput.setType(KeyInput::Pressed);
keyInput.setShiftPressed(kbstate[VK_SHIFT] & 0x80);
keyInput.setControlPressed(kbstate[VK_CONTROL] & 0x80);
keyInput.setAltPressed(kbstate[VK_MENU] & 0x80);
keyInput.setNumericPad(wParam >= VK_NUMPAD0
&& wParam <= VK_DIVIDE);
mKeyInputQueue.push(keyInput);
}
break;
case WM_SYSKEYUP:
case WM_KEYUP:
{
unsigned char kbstate[256];
GetKeyboardState(kbstate);
keyInput.setKey(Key(convertKeyCharacter(wParam, lParam, kbstate)));
keyInput.setType(KeyInput::Released);
keyInput.setShiftPressed(kbstate[VK_SHIFT] & 0x80);
keyInput.setControlPressed(kbstate[VK_CONTROL] & 0x80);
keyInput.setAltPressed(kbstate[VK_MENU] & 0x80);
keyInput.setNumericPad(wParam >= VK_NUMPAD0
&& wParam <= VK_DIVIDE);
mKeyInputQueue.push(keyInput);
}
break;
case WM_LBUTTONDOWN:
{
int x = (int)((signed short)(LOWORD(lParam)));
int y = (int)((signed short)(HIWORD(lParam)));
mouseInput.setX(x);
mouseInput.setY(y);
mouseInput.setButton(MouseInput::Left);
mouseInput.setType(MouseInput::Pressed);
mouseInput.setTimeStamp(GetTickCount());
mMouseInputQueue.push(mouseInput);
mMouseDown = true;
SetCapture(window);
break;
}
case WM_MBUTTONDOWN:
{
int x = (int)((signed short)(LOWORD(lParam)));
int y = (int)((signed short)(HIWORD(lParam)));
mouseInput.setX(x);
mouseInput.setY(y);
mouseInput.setButton(MouseInput::Middle);
mouseInput.setType(MouseInput::Pressed);
mouseInput.setTimeStamp(GetTickCount());
mMouseInputQueue.push(mouseInput);
mMouseDown = true;
SetCapture(window);
break;
}
case WM_RBUTTONDOWN:
{
int x = (int)((signed short)(LOWORD(lParam)));
int y = (int)((signed short)(HIWORD(lParam)));
mouseInput.setX(x);
mouseInput.setY(y);
mouseInput.setButton(MouseInput::Right);
mouseInput.setType(MouseInput::Pressed);
mouseInput.setTimeStamp(GetTickCount());
mMouseInputQueue.push(mouseInput);
mMouseDown = true;
SetCapture(window);
break;
}
case WM_LBUTTONUP:
{
int x = (int)((signed short)(LOWORD(lParam)));
int y = (int)((signed short)(HIWORD(lParam)));
mouseInput.setX(x);
mouseInput.setY(y);
mouseInput.setButton(MouseInput::Left);
mouseInput.setType(MouseInput::Released);
mouseInput.setTimeStamp(GetTickCount());
mMouseInputQueue.push(mouseInput);
mMouseDown = false;
ReleaseCapture();
break;
}
case WM_MBUTTONUP:
{
int x = (int)((signed short)(LOWORD(lParam)));
int y = (int)((signed short)(HIWORD(lParam)));
mouseInput.setX(x);
mouseInput.setY(y);
mouseInput.setButton(MouseInput::Middle);
mouseInput.setType(MouseInput::Released);
mouseInput.setTimeStamp(GetTickCount());
mMouseInputQueue.push(mouseInput);
mMouseDown = false;
ReleaseCapture();
break;
}
case WM_RBUTTONUP:
{
int x = (int)((signed short)(LOWORD(lParam)));
int y = (int)((signed short)(HIWORD(lParam)));
mouseInput.setX(x);
mouseInput.setY(y);
mouseInput.setButton(MouseInput::Right);
mouseInput.setType(MouseInput::Released);
mouseInput.setTimeStamp(GetTickCount());
mMouseInputQueue.push(mouseInput);
mMouseDown = false;
ReleaseCapture();
break;
}
case WM_MOUSEMOVE:
{
int x = (int)((signed short)(LOWORD(lParam)));
int y = (int)((signed short)(HIWORD(lParam)));
/*
POINT point = {x,y};
ScreenToClient(hWnd, &point);
RECT rect;
GetClientRect(hWnd, &rect);*/
/*
if (!mMouseDown
&& mMouseInWindow
&& (point.x < 0
|| point.y < 0
|| point.x > rect.right
|| point.y > rect.bottom))
{
mouseInput.setX(-1);
mouseInput.setY(-1);
mouseInput.setButton(MouseInput::Empty);
mouseInput.setType(MouseInput::Moved);
mouseInput.setTimeStamp(GetTickCount());
mMouseInputQueue.push(mouseInput);
mMouseInWindow = false;
}
else if (mMouseDown
|| (point.x >= 0
&& point.y >= 0
&& point.x < rect.right
&& point.y < rect.bottom))
{
mouseInput.setX(point.x);
mouseInput.setY(point.y);
mouseInput.setButton(MouseInput::Empty);
mouseInput.setType(MouseInput::Moved);
mouseInput.setTimeStamp(GetTickCount());
mMouseInputQueue.push(mouseInput);
}
mMouseInWindow = point.x >= 0
&& point.y >= 0
&& point.x < rect.right
&& point.y < rect.bottom;
*/
mouseInput.setX(x);
mouseInput.setY(y);
mouseInput.setButton(MouseInput::Empty);
mouseInput.setType(MouseInput::Moved);
mouseInput.setTimeStamp(GetTickCount());
mMouseInputQueue.push(mouseInput);
break;
}
// For some reason WM_MOUSEWHEEL isn't defined at some systems
// (including mine), but 0x020A should be equal to the WM_MOUSEWHEEL
// value.
case 0x020A: // WM_MOUSEWHEEL
int mouseZ = (short)HIWORD(wParam);
int x = (int)((signed short)(LOWORD(lParam)));
int y = (int)((signed short)(HIWORD(lParam)));
POINT point = {x,y};
ScreenToClient(window, &point);
RECT rect;
GetClientRect(window, &rect);
if (point.x < 0
|| point.y < 0
|| point.x > rect.right
|| point.y > rect.bottom)
{
break;
}
// Mouse wheels doesn't have to move 120 units anymore, new
// mouses can move less than 120, therefore we need to check
// that the mouse has at least moved 120 units before we push
// an input event.
if (mLastMouseZ + mouseZ >= 120)
{
mMouseInputQueue.push(MouseInput(MouseInput::Empty,
MouseInput::WheelMovedUp,
point.x,
point.y,
GetTickCount()));
mLastMouseZ = 0;
}
else if (mLastMouseZ + mouseZ <= -120)
{
mMouseInputQueue.push(MouseInput(MouseInput::Empty,
MouseInput::WheelMovedDown,
point.x,
point.y,
GetTickCount()));
mLastMouseZ = 0;
}
else
{
mLastMouseZ += mouseZ;
}
break;
} // end switch
}
void SDLInput::pushInput(SDL_Event event)
{
KeyInput keyInput;
MouseInput mouseInput;
switch (event.type)
{
case SDL_KEYDOWN:
{
int value = convertSDLEventToGuichanKeyValue(event);
if (value == -1)
{
value = (int)event.key.keysym.unicode;
}
keyInput.setKey(Key(value));
keyInput.setType(KeyInput::PRESSED);
keyInput.setShiftPressed(event.key.keysym.mod & KMOD_SHIFT);
keyInput.setControlPressed(event.key.keysym.mod & KMOD_CTRL);
keyInput.setAltPressed(event.key.keysym.mod & KMOD_ALT);
keyInput.setMetaPressed(event.key.keysym.mod & KMOD_META);
keyInput.setNumericPad(event.key.keysym.sym >= SDLK_KP0
&& event.key.keysym.sym <= SDLK_KP_EQUALS);
mKeyInputQueue.push(keyInput);
break;
}
case SDL_KEYUP:
{
int value = convertSDLEventToGuichanKeyValue(event);
if (value == -1)
{
value = (int)event.key.keysym.sym;
}
keyInput.setKey(Key(value));
keyInput.setType(KeyInput::RELEASED);
keyInput.setShiftPressed(event.key.keysym.mod & KMOD_SHIFT);
keyInput.setControlPressed(event.key.keysym.mod & KMOD_CTRL);
keyInput.setAltPressed(event.key.keysym.mod & KMOD_ALT);
keyInput.setMetaPressed(event.key.keysym.mod & KMOD_META);
keyInput.setNumericPad(event.key.keysym.sym >= SDLK_KP0
&& event.key.keysym.sym <= SDLK_KP_EQUALS);
mKeyInputQueue.push(keyInput);
break;
}
case SDL_MOUSEBUTTONDOWN:
mMouseDown = true;
mouseInput.setX(event.button.x);
mouseInput.setY(event.button.y);
mouseInput.setButton(convertMouseButton(event.button.button));
if (event.button.button == SDL_BUTTON_WHEELDOWN)
{
mouseInput.setType(MouseInput::WHEEL_MOVED_DOWN);
}
else if (event.button.button == SDL_BUTTON_WHEELUP)
{
mouseInput.setType(MouseInput::WHEEL_MOVED_UP);
}
else
{
mouseInput.setType(MouseInput::PRESSED);
}
mouseInput.setTimeStamp(SDL_GetTicks());
mMouseInputQueue.push(mouseInput);
break;
case SDL_MOUSEBUTTONUP:
mMouseDown = false;
mouseInput.setX(event.button.x);
mouseInput.setY(event.button.y);
mouseInput.setButton(convertMouseButton(event.button.button));
mouseInput.setType(MouseInput::RELEASED);
mouseInput.setTimeStamp(SDL_GetTicks());
mMouseInputQueue.push(mouseInput);
break;
case SDL_MOUSEMOTION:
mouseInput.setX(event.button.x);
mouseInput.setY(event.button.y);
mouseInput.setButton(MouseInput::EMPTY);
mouseInput.setType(MouseInput::MOVED);
mouseInput.setTimeStamp(SDL_GetTicks());
mMouseInputQueue.push(mouseInput);
break;
case SDL_ACTIVEEVENT:
/*
* This occurs when the mouse leaves the window and the Gui-chan
* application loses its mousefocus.
*/
if ((event.active.state & SDL_APPMOUSEFOCUS)
&& !event.active.gain)
{
mMouseInWindow = false;
if (!mMouseDown)
{
mouseInput.setX(-1);
mouseInput.setY(-1);
mouseInput.setButton(MouseInput::EMPTY);
mouseInput.setType(MouseInput::MOVED);
mMouseInputQueue.push(mouseInput);
}
}
if ((event.active.state & SDL_APPMOUSEFOCUS)
&& event.active.gain)
{
mMouseInWindow = true;
}
break;
} // end switch
}
