static LRESULT CALLBACK WndProc(HWND hwndMain, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
switch(uMsg)
{
case WM_PAINT:
{
HDC hdc = GetDC(hwndMain);
field->paint(hdc);
toolbox->draw(hdc);
toolbox->draw_pantone(hdc, RGB(0, 204, 0), 500, 100);
ReleaseDC(hwndMain, hdc);
}
break;
case WM_LBUTTONDOWN:
{
field->press_event(MouseEvent(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam)));
}
break;
case WM_LBUTTONUP:
{
field->release_event(MouseEvent(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam)));
}
break;
case WM_MOUSEMOVE:
{
field->move_event(MouseEvent(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam)));
}
break;
case WM_DESTROY:
PostQuitMessage(0);
break;
default:
return DefWindowProc(hwndMain, uMsg, wParam, lParam);
}
}
void InteractiveObject::handleEvent(const Event &event)
{
if (event.type == MouseEvent::MOUSE_MOVE || event.type == MouseEvent::CLICK || event.type == MouseEvent::MOUSE_DOWN || event.type == MouseEvent::MOUSE_UP)
{
MouseEvent* st = (MouseEvent*)(&event);
bool hit = hitTestPoint(st->getX(), st->getY());
if (event.type == MouseEvent::MOUSE_MOVE)
{
onMouseMove(event);
if (isHovered)
{
if (!hit)
{
onMouseOut(event);
dispatchEvent(MouseEvent(this, MouseEvent::MOUSE_OUT, st->getX(), st->getY()));
isHovered = !isHovered;
}
}
else
{
if (hit)
{
onMouseOver(event);
dispatchEvent(MouseEvent(this, MouseEvent::MOUSE_OVER, st->getX(), st->getY()));
isHovered = !isHovered;
}
}
}
else if (hit)
{
dispatchEvent(MouseEvent(this, event.type, st->getX(), st->getY()));
}
}
}
void mouse(int button, int state, int x, int y)
{
Window::Ptr window = getCurrentWindow();
if (window) {
if (state == GLUT_DOWN) {
window->mousePressed(MouseEvent(getModifiers(), getButton(button), Point(x, y)));
} else if (state == GLUT_UP) {
window->mouseReleased(MouseEvent(getModifiers(), getButton(button), Point(x, y)));
}
}
}
void passiveMotion(int x, int y)
{
Window::Ptr window = getCurrentWindow();
if (window) {
window->mouseMoved(MouseEvent(InputEvent::MODIFIER_NONE, MouseEvent::NONE, Point(x, y)));
}
}
bool UserInputListener::fireMouseButtonReleased( MouseButton p_button )
{
bool result = false;
if ( doHasHandlers() )
{
m_mouse.m_buttons[size_t( p_button )] = false;
m_mouse.m_changed = p_button;
auto current = doGetMouseTargetableHandler( m_mouse.m_position );
if ( current )
{
current->pushEvent( MouseEvent( MouseEventType::eReleased, m_mouse.m_position, p_button ) );
result = true;
m_activeHandler = current;
}
else
{
auto active = m_activeHandler.lock();
if ( active )
{
active->pushEvent( HandlerEvent( HandlerEventType::eDeactivate, current ) );
}
m_activeHandler.reset();
}
}
return result;
}
void mouseClicked(int button, int state, int x, int y)
{
button = (button == GLUT_LEFT_BUTTON ) ? MB_BUTTON1 :
(button == GLUT_RIGHT_BUTTON) ? MB_BUTTON2 : MB_BUTTON3;
MouseEvent event = MouseEvent(MB_BUTTON1, x, y, guiFrame.getHeight() - y);
guiFrame.checkMouseEvents(event, (state == GLUT_DOWN) ? ME_CLICKED: ME_RELEASED);
}
void MouseServer::OnWheelDown( int x,int y )
{
buffer.push( MouseEvent( MouseEvent::WheelDown,x,y ) );
if( buffer.size( ) > bufferSize )
{
buffer.pop( );
}
}
//==============================================================================
MouseEvent MouseEvent::getEventRelativeTo (Component* const otherComponent) const noexcept
{
jassert (otherComponent != nullptr);
return MouseEvent (source, otherComponent->getLocalPoint (eventComponent, getPosition()),
mods, otherComponent, originalComponent, eventTime,
otherComponent->getLocalPoint (eventComponent, mouseDownPos),
mouseDownTime, numberOfClicks, wasMovedSinceMouseDown != 0);
}
void OpenGLWindow::mouseReleaseEvent(QMouseEvent * e)
{
if (!focused) return;
if (e->button() == Qt::MouseButton::RightButton) {
ShowCursor();
}
MouseEvent(e, GLFW_RELEASE);
}
void MouseServer::OnLeftPressed( int x,int y )
{
leftIsPressed = true;
buffer.push( MouseEvent( MouseEvent::LPress,x,y ) );
if( buffer.size( ) > bufferSize )
{
buffer.pop( );
}
}
void MouseServer::OnLeftReleased( int x,int y )
{
leftIsPressed = false;
buffer.push( MouseEvent( MouseEvent::LRelease,x,y ) );
if( buffer.size( ) > bufferSize )
{
buffer.pop( );
}
}
void Window::PulseReceived( Pulse *pulse )
{
Rect oldFrame;
uint32 d1,d2,d3,d4,d5,d6;
d1 = (*pulse)[0];
d2 = (*pulse)[1];
d3 = (*pulse)[2];
d4 = (*pulse)[3];
d5 = (*pulse)[4];
d6 = (*pulse)[5];
switch (d1)
{
case PULSE:
if ( smk_getpid() != pulse->source_pid ) break; // Ignore the daemons.
Pulsed();
break;
case FOCUS:
m_focus = (d2 == 1);
Focus( m_focus );
break;
case MOUSE_DOWN:
case MOUSE_UP:
case MOUSE_MOVED:
MouseEvent( d1, d2, d3, d4 );
break;
case KEY_DOWN:
case KEY_UP:
KeyEvent( d1, d2, d3, d4 );
break;
case DRAW:
Draw( Rect(d2,d3,d4,d5) );
Sync();
break;
case MOVE:
oldFrame = m_frame;
m_frame.left += d2;
m_frame.right += d2;
m_frame.top += d3;
m_frame.bottom += d3;
WindowMoved( Frame() );
break;
default:
Looper::PulseReceived( pulse );
break;
}
}
void MouseServer::OnMouseMove( int x,int y )
{
this->x = x;
this->y = y;
buffer.push( MouseEvent( MouseEvent::Move,x,y ) );
if( buffer.size( ) > bufferSize )
{
buffer.pop( );
}
}
void OpenGLWindow::mousePressEvent(QMouseEvent * e)
{
if (!focused) return;
if (e->button() == Qt::MouseButton::RightButton) {
HideCursor();
CenterCursor();
}
MouseEvent(e, GLFW_PRESS);
}
bool DMenu::Responder (event_t *ev)
{
bool res = false;
if (ev->type == EV_GUI_Event)
{
if (ev->subtype == EV_GUI_LButtonDown)
{
res = MouseEventBack(MOUSE_Click, ev->data1, ev->data2);
// make the menu's mouse handler believe that the current coordinate is outside the valid range
if (res) ev->data2 = -1;
res |= MouseEvent(MOUSE_Click, ev->data1, ev->data2);
if (res)
{
SetCapture();
}
}
else if (ev->subtype == EV_GUI_MouseMove)
{
BackbuttonTime = BACKBUTTON_TIME;
if (mMouseCapture || m_use_mouse == 1)
{
res = MouseEventBack(MOUSE_Move, ev->data1, ev->data2);
if (res) ev->data2 = -1;
res |= MouseEvent(MOUSE_Move, ev->data1, ev->data2);
}
}
else if (ev->subtype == EV_GUI_LButtonUp)
{
if (mMouseCapture)
{
ReleaseCapture();
res = MouseEventBack(MOUSE_Release, ev->data1, ev->data2);
if (res) ev->data2 = -1;
res |= MouseEvent(MOUSE_Release, ev->data1, ev->data2);
}
}
}
return false;
}
MouseEvent MouseClient::ReadMouse()
{
if( server.buffer.size() > 0 )
{
MouseEvent e = server.buffer.front( );
server.buffer.pop( );
return e;
}
else
{
return MouseEvent( MouseEvent::Invalid,0,0 );
}
}
bool UserInputListener::fireMouseMove( Position const & p_position )
{
bool result = false;
if ( doHasHandlers() )
{
m_mouse.m_position = p_position;
auto current = doGetMouseTargetableHandler( p_position );
auto last = m_lastMouseTarget.lock();
if ( current != last )
{
if ( last )
{
castor::Logger::logDebug( castor::StringStream() << p_position.x() << "x" << p_position.y() );
last->pushEvent( MouseEvent( MouseEventType::eLeave, p_position ) );
last.reset();
m_lastMouseTarget.reset();
}
}
if ( current )
{
if ( current != last )
{
current->pushEvent( MouseEvent( MouseEventType::eEnter, p_position ) );
}
current->pushEvent( MouseEvent( MouseEventType::eMove, p_position ) );
result = true;
m_lastMouseTarget = current;
}
}
return result;
}
//-----------------------------------------------------------------------
void Window::eventCursor(const int x, const int y, const int rx, const int ry)
{
static int curX = -10000;
static int curY = -10000;
if ( curX == x && curY == y ) return;
curX = x;
curY = y;
for ( auto it = m_msgHandlers.begin(); it != m_msgHandlers.end(); ++it )
{
if ( !(*it) )
continue;
if ( (*it)->OnMouseMove(MouseEvent(x, y, rx, ry)) == true )
return;
}
}
bool UserInputListener::fireMouseWheel( Position const & p_offsets )
{
bool result = false;
if ( doHasHandlers() )
{
m_mouse.m_wheel += p_offsets;
auto current = doGetMouseTargetableHandler( m_mouse.m_position );
if ( current )
{
current->pushEvent( MouseEvent( MouseEventType::eWheel, p_offsets ) );
result = true;
}
}
return result;
}
inline void bbTooltip::_Timer(WPARAM wParam)
{
switch (wParam)
{
case _INITIAL_TIMER:
KillTimer(m_TipHwnd, _INITIAL_TIMER);
_Show();
break;
case _UPDATE_TIMER:
GetCursorPos(&m_timer_point);
GetWindowRect(m_hHost, &m_timer_rect);
if (!PtInRect(&m_timer_rect, m_timer_point)) {
ScreenToClient(m_hHost, &m_timer_point);
MouseEvent(m_timer_point, WM_MOUSEMOVE);
}
}
}
//Mouse functions
void mouse_handler(regs *a_r) //struct regs *a_r (not used but just there)
{
if(a_r->eax){}
switch(mouse_cycle)
{
case 0:
mouse_byte[0]=(int8_t) _8042_readPort();
mouse_cycle++;
break;
case 1:
mouse_byte[1]=(int8_t) _8042_readPort();
mouse_cycle++;
break;
case 2:
mouse_byte[2]=(int8_t) _8042_readPort();
mouse_cycle=0;
MouseEvent();
break;
}
}
void WinInputManager::Run(UINT const & msg, WPARAM wParam, LPARAM lParam)
{
if (m_listenerList.empty())
return;
eKeyCodes KeyIndex;
wchar_t buffer[1];
BYTE lpKeyState[256];
CursorEvent();
switch (msg)
{
case WM_KEYDOWN:
KeyIndex = static_cast<eKeyCodes>(wParam);
GetKeyboardState(lpKeyState);
ToUnicode(wParam, HIWORD(lParam) & 0xFF, lpKeyState, buffer, 1, 0);
KeyEvent(KeyIndex, buffer[0], true);
break;
case WM_KEYUP:
KeyIndex = static_cast<eKeyCodes>(wParam);
GetKeyboardState(lpKeyState);
ToUnicode(wParam, HIWORD(lParam) & 0xFF, lpKeyState, buffer, 1, 0);
KeyEvent(KeyIndex, buffer[0], false);
break;
case WM_LBUTTONDOWN:
MouseEvent(MOUSE_LEFT, true);
break;
case WM_LBUTTONUP:
MouseEvent(MOUSE_LEFT, false);
break;
case WM_RBUTTONDOWN:
MouseEvent(MOUSE_RIGHT, true);
break;
case WM_RBUTTONUP:
MouseEvent(MOUSE_RIGHT, false);
break;
case WM_MBUTTONDOWN:
MouseEvent(MOUSE_MIDDLE, true);
break;
case WM_MBUTTONUP:
MouseEvent(MOUSE_MIDDLE, false);
break;
case WM_MOUSEWHEEL:
MouseWheelEvent((short)GET_WHEEL_DELTA_WPARAM(wParam) / WHEEL_DELTA);
break;
}
}
void HandleRootWindowEvent(WSSvr_st *st, WS_Event *ev)
{
switch(ev->d.tag) {
case WS_EventType_Expose:
{
WS_Rectangle *r = &ev->d.u.Expose;
ExposeBackdrop(st, r->x1, r->y1, r->x2, r->y2);
break;
}
#if 0
case WS_EventType_Mouse:
{
MouseEvent(st, ev);
break;
#endif
default:
TRC(printf("Got event, tag is %d\n", ev->d.tag));
}
}
bool Dragonfly::clbkPanelMouseEvent (int id, int event, int mx, int my)
{
MouseEvent (id, event, mx, my);
return true;
}
MouseEvent MouseEvent::withNewPosition (const Point<int>& newPosition) const noexcept
{
return MouseEvent (source, newPosition, mods, eventComponent, originalComponent,
eventTime, mouseDownPos, mouseDownTime,
numberOfClicks, wasMovedSinceMouseDown != 0);
}
void mouse(int button, int state, int x, int y)
{
if(events)
events->Mouse(MouseEvent(button, state, float(x), float(y), 0));
}
void mousepassivemove(int x, int y)
{
if(events)
events->Mouse(MouseEvent(-1, 0, float(x), float(y), 0));
}
void mousewheel(int button, int dir, int x, int y)
{
if(events)
events->Mouse(MouseEvent(button, -1, float(x), float(y), float(dir)));
}
void Renderer::createMouseEvent ( sf::Event e )
{
switch ( e.type ) {
case Event::MouseButtonPressed: {
pg::Coord coord = getMouseCoord();
pg::Coord screenCoord = pg::Coord ( Mouse::getPosition ( *window ).x, Mouse::getPosition ( *window ).y );
if ( Mouse::isButtonPressed ( Mouse::Left ) && !mouse[0] ) {
MouseReader::notifyListeners ( MouseEvent ( MouseEvent::LEFT_DOWN, coord, screenCoord ) );
mouse[0] = 1;
}
if ( Mouse::isButtonPressed ( Mouse::Middle ) && !mouse[1] ) {
MouseReader::notifyListeners ( MouseEvent ( MouseEvent::MIDDLE_DOWN, coord, screenCoord ) );
mouse[1] = 1;
}
if ( Mouse::isButtonPressed ( Mouse::Right ) & !mouse[2] ) {
MouseReader::notifyListeners ( MouseEvent ( MouseEvent::RIGHT_DOWN, coord, screenCoord ) );
mouse[2] = 1;
}
break;
}
case Event::MouseButtonReleased: {
pg::Coord coord = getMouseCoord();
pg::Coord screenCoord = pg::Coord ( Mouse::getPosition ( *window ).x, Mouse::getPosition ( *window ).y );
if ( !Mouse::isButtonPressed ( Mouse::Left ) && mouse[0] ) {
MouseReader::notifyListeners ( MouseEvent ( MouseEvent::LEFT_UP, coord, screenCoord ) );
mouse[0] = 0;
}
if ( !Mouse::isButtonPressed ( Mouse::Middle ) && mouse[1] ) {
MouseReader::notifyListeners ( MouseEvent ( MouseEvent::MIDDLE_UP, coord, screenCoord ) );
mouse[1] = 0;
}
if ( !Mouse::isButtonPressed ( Mouse::Right ) && mouse[2] ) {
MouseReader::notifyListeners ( MouseEvent ( MouseEvent::RIGHT_UP, coord, screenCoord ) );
mouse[2] = 0;
}
break;
}
case Event::MouseMoved: {
pg::Coord coord = getMouseCoord();
pg::Coord screenCoord = pg::Coord ( Mouse::getPosition ( *window ).x, Mouse::getPosition ( *window ).y );
MouseReader::notifyListeners ( MouseEvent ( MouseEvent::MOVE, coord, screenCoord ) );
break;
}
case Event::MouseWheelMoved: {
// float x=((Event::MouseWheelEvent)e).delta;
pg::Coord coord = getMouseCoord();
pg::Coord screenCoord = pg::Coord ( Mouse::getPosition ( *window ).x, Mouse::getPosition ( *window ).y );
//e.mouseWheel;
// MouseReader::notifyListeners ( MouseEvent ( MouseEvent::MOVE, coord, screenCoord ) );
}
}
}
BOOL
consoleGetKey (
PKBDKEY Key,
BOOL fWait
)
/*++
Routine Description:
Gets the next key from the input buffer.
Arguments:
Key - Supplies a pointer to a key structure
fWait - Supplies a flag:
if TRUE, the function blocks until a key is ready.
if FALSE, the function returns immediately.
Return Value:
TRUE if keystroke read, FALSE otherwise.
--*/
{
PINPUT_RECORD pEvent;
do {
pEvent = NextEvent( ADVANCE, fWait );
if (pEvent) {
switch ( EVENT_TYPE(pEvent) ) {
case KEY_EVENT:
if (KeyEvent(PKEY_EVT(pEvent), Key)) {
return TRUE;
}
break;
case MOUSE_EVENT:
MouseEvent(PMOUSE_EVT(pEvent));
break;
case WINDOW_BUFFER_SIZE_EVENT:
WindowEvent(PWINDOW_EVT(pEvent));
break;
case MENU_EVENT:
MenuEvent(PMENU_EVT(pEvent));
break;
case FOCUS_EVENT:
if (FocusEvent(PFOCUS_EVT(pEvent), Key)) {
return TRUE;
}
break;
default:
break;
}
}
} while (fWait);
return FALSE;
}
