bool DEV_EventConsumer::processEvent(GHOST_IEvent *event)
{
GHOST_TEventDataPtr eventData = ((GHOST_IEvent*)event)->getData();
switch (event->getType()) {
case GHOST_kEventButtonDown:
{
HandleButtonEvent(eventData, true);
break;
}
case GHOST_kEventButtonUp:
{
HandleButtonEvent(eventData, false);
break;
}
case GHOST_kEventWheel:
{
HandleWheelEvent(eventData);
break;
}
case GHOST_kEventCursorMove:
{
HandleCursorEvent(eventData, event->getWindow());
break;
}
case GHOST_kEventKeyDown:
{
HandleKeyEvent(eventData, true);
break;
}
case GHOST_kEventKeyUp:
{
HandleKeyEvent(eventData, false);
break;
}
case GHOST_kEventWindowSize:
case GHOST_kEventWindowClose:
case GHOST_kEventQuit:
{
HandleWindowEvent(event->getType());
break;
}
default:
break;
}
return true;
}
EXTERNC
int getch() {
BOOL rv;
DWORD n;
INPUT_RECORD buf;
if (thData.ungetCount > 0) {
thData.ungetCount--;
return thData.ungetBuf[thData.ungetCount];
};
if (thData.charCount > 0) {
thData.charCount--;
if (thData.charCount & 1 && thData.charFlag) return 0;
else return thData.charValue;
};
while (true) {
rv = ReadConsoleInput(thData.input, &buf, 1, &n);
if (rv == false) continue;
if (buf.EventType != KEY_EVENT) continue;
if (buf.Event.KeyEvent.bKeyDown == false) continue;
if (HandleKeyEvent(&buf)) break;
};
thData.charCount--;
if (thData.charCount & 1 && thData.charFlag) return 0;
else return thData.charValue;
};
void PaletteWindow::HandleEvents(sf::RenderWindow& window)
{
// Handle all events.
sf::Event event;
while (window.pollEvent(event))
{
if (event.type == sf::Event::Closed)
{
// Ignore -- we only close if the main map editor closes.
}
else if (event.type == sf::Event::MouseButtonPressed)
{
// Selecting something, figure out which.
bool swappedTerrain = false;
for (int i = 0; i < (int)TerrainType::COUNT; i++)
{
if (terrainRectangles[(TerrainType)i].getGlobalBounds().contains(sf::Vector2f((float)event.mouseButton.x, (float)event.mouseButton.y)))
{
std::cout << "Switching to terrain type " << GetTerrainName((TerrainType)i) << std::endl;
terrainRectangles[selectedTerrain].setOutlineThickness(0);
terrainRectangles[(TerrainType)i].setOutlineThickness(1.0f);
selectedTerrain = (TerrainType)i;
swappedTerrain = true;
break;
}
}
if (!swappedTerrain)
{
// Determine if we instead swapped tools.
for (int i = 0; i < (int)Tool::COUNT_TOOL; i++)
{
if (toolRectangles[(Tool)i].getGlobalBounds().contains(sf::Vector2f((float)event.mouseButton.x, (float)event.mouseButton.y)))
{
std::cout << "Switching to tool " << GetToolName((Tool)i) << std::endl;
toolRectangles[selectedTool].setOutlineThickness(0);
toolRectangles[(Tool)i].setOutlineThickness(1.0f);
selectedTool = (Tool)i;
break;
}
}
}
}
else if (event.type == sf::Event::KeyPressed)
{
HandleKeyEvent(event);
}
}
}
void plKeyboardDevice::HandleWindowActivate(bool bActive, HWND hWnd)
{
if (bActive)
{
// Refresh the caps lock state
HandleKeyEvent(KEYDOWN, KEY_CAPSLOCK, nil, false);
}
else
{
ReleaseAllKeys(); // send key-up events for everything since we're losing focus
}
}
void StringBrowser::Handle (Event& e) {
if (e.eventType == KeyEvent) {
HandleKeyEvent(e);
} else {
boolean done = false;
do {
switch (e.eventType) {
case DownEvent:
done = HandleDownEvent(e);
break;
case KeyEvent:
done = HandleKeyEvent(e);
break;
}
if (!done) {
Read(e);
}
} while (!done);
}
}
void Arti3DApp::HandleEvent(const SDL_Event& event, Arti3DApp *pApp)
{
switch (event.type)
{
case SDL_QUIT:
pApp->m_bRunning = false;
break;
case SDL_KEYDOWN:
HandleKeyEvent(event, pApp);
break;
default:
break;
}
}
void
MIR_HandleInput(MirSurface* surface, MirEvent const* ev, void* context)
{
SDL_Window* window = (SDL_Window*)context;
switch (ev->type) {
case (mir_event_type_key):
HandleKeyEvent(ev->key, window);
break;
case (mir_event_type_motion):
HandleMotionEvent(ev->motion, window);
break;
default:
break;
}
}
// OnKey handles system keys by first interpreting some Ctrl+Key combinations
// in a special way and passing the rest of them to the movie.
void FxPlayerTiny::OnKey(UInt keyCode, bool downFlag)
{
if (!pMovie) return;
bool ctrl = ControlKeyDown;
if (keyCode == VK_CONTROL)
{
ControlKeyDown = downFlag;
return;
}
if (keyCode == VK_MENU && downFlag)
ControlKeyDown = false; // to enable Ctrl-Alt-... combinations to work
if (ctrl && downFlag)
{
switch(keyCode)
{
/*
case 'W':
Wireframe = !Wireframe;
break;
case 'A':
AAEnabled = ! AAEnabled;
{
UInt32 rendererFlags = pRenderConfig->GetRenderFlags() &
~GFxRenderConfig::RF_EdgeAA;
if (AAEnabled)
rendererFlags |= GFxRenderConfig::RF_EdgeAA;
pRenderConfig->SetRenderFlags(rendererFlags);
}
break;
case 'P':
Paused = !Paused;
break;
*/
}
}
else if (!ctrl)
{
HandleKeyEvent(keyCode, downFlag);
}
}
EXTERNC
int kbhit() {
BOOL rv;
DWORD n;
INPUT_RECORD buf;
if (thData.ungetCount > 0) return 1;
if (thData.charCount > 0) return 1;
rv = PeekConsoleInput(thData.input, &buf, 1, &n);
if (!rv) return 0;
if (n == 0) return 0;
rv = ReadConsoleInput(thData.input, &buf, 1, &n);
if (rv == false) return 0;
if (buf.EventType != KEY_EVENT) return 0;
if (buf.Event.KeyEvent.bKeyDown == false) return 0;
return HandleKeyEvent(&buf) ? 1 : 0;
};
static void
HandleInput(MirInputEvent const* input_event, SDL_Window* window)
{
switch (MIR_mir_input_event_get_type(input_event)) {
case (mir_input_event_type_key):
HandleKeyEvent(MIR_mir_input_event_get_keyboard_event(input_event), window);
break;
case (mir_input_event_type_pointer):
HandleMouseEvent(MIR_mir_input_event_get_pointer_event(input_event), window);
break;
case (mir_input_event_type_touch):
HandleTouchEvent(MIR_mir_input_event_get_touch_event(input_event),
MIR_mir_input_event_get_device_id(input_event),
window);
break;
default:
break;
}
}
void Widget::HandleEvent( const sf::Event& event ) {
if( !IsGloballyVisible() ) {
return;
}
// Ignore the event if widget is insensitive
if ( GetState() == INSENSITIVE ) {
return;
}
// Ignore the event if another widget is active.
if( !IsActiveWidget() && !IsActiveWidget( PtrConst() ) ) {
return;
}
// Ignore the event if another widget is modal.
if( HasModal() && !IsModal() ) {
return;
}
// Set widget active in context.
Context::Get().SetActiveWidget( shared_from_this() );
Container::Ptr parent( m_parent.lock() );
switch( event.type ) {
case sf::Event::MouseMoved:
// Check if pointer inside of widget's allocation.
if( GetAllocation().contains( static_cast<float>( event.mouseMove.x ), static_cast<float>( event.mouseMove.y ) ) ) {
// Check for enter event.
if( !IsMouseInWidget() ) {
// Flip the mouse_in bit.
m_bitfield ^= static_cast<unsigned char>( 0x10 );
GetSignals().Emit( OnMouseEnter );
HandleMouseEnter( event.mouseMove.x, event.mouseMove.y );
}
GetSignals().Emit( OnMouseMove );
}
else if( IsMouseInWidget() ) { // Check for leave event.
// Flip the mouse_in bit.
m_bitfield ^= static_cast<unsigned char>( 0x10 );
GetSignals().Emit( OnMouseLeave );
HandleMouseLeave( event.mouseMove.x, event.mouseMove.y );
}
HandleMouseMoveEvent( event.mouseMove.x, event.mouseMove.y );
break;
case sf::Event::MouseButtonPressed:
if( ( ( m_bitfield & static_cast<unsigned char>( 0xe0 ) ) == static_cast<unsigned char>( 0xe0 ) ) && IsMouseInWidget() ) {
// Clear the mouse_button_down bits to 0s.
m_bitfield &= static_cast<unsigned char>( 0x1f );
// Set the mouse_button_down bits.
m_bitfield |= static_cast<unsigned char>( event.mouseButton.button << 5 );
}
HandleMouseButtonEvent( event.mouseButton.button, true, event.mouseButton.x, event.mouseButton.y );
if( IsMouseInWidget() ) {
if( event.mouseButton.button == sf::Mouse::Left ) {
GetSignals().Emit( OnMouseLeftPress );
}
else if( event.mouseButton.button == sf::Mouse::Right ) {
GetSignals().Emit( OnMouseRightPress );
}
}
break;
case sf::Event::MouseButtonReleased:
// Only process as a click when mouse button has been pressed inside the widget before.
if( ( ( m_bitfield & 0xe0 ) >> 5 ) == event.mouseButton.button ) {
// Set the mouse_button_down bits to 111 (none).
m_bitfield |= static_cast<unsigned char>( 0xe0 );
// When released inside the widget, the event can be considered a click.
if( IsMouseInWidget() ) {
HandleMouseClick( event.mouseButton.button, event.mouseButton.x, event.mouseButton.y );
if( event.mouseButton.button == sf::Mouse::Left ) {
GetSignals().Emit( OnLeftClick );
}
else if( event.mouseButton.button == sf::Mouse::Right ) {
GetSignals().Emit( OnRightClick );
}
}
}
HandleMouseButtonEvent( event.mouseButton.button, false, event.mouseButton.x, event.mouseButton.y );
if( IsMouseInWidget() ) {
if( event.mouseButton.button == sf::Mouse::Left ) {
GetSignals().Emit( OnMouseLeftRelease );
}
else if( event.mouseButton.button == sf::Mouse::Right ) {
GetSignals().Emit( OnMouseRightRelease );
}
}
break;
case sf::Event::KeyPressed:
if( HasFocus() ) {
// TODO: Delegate event too when widget's not active?
HandleKeyEvent( event.key.code, true );
GetSignals().Emit( OnKeyPress );
}
break;
case sf::Event::KeyReleased:
if( HasFocus() ) {
// TODO: Delegate event too when widget's not active?
HandleKeyEvent( event.key.code, false );
GetSignals().Emit( OnKeyRelease );
}
break;
case sf::Event::TextEntered:
if( HasFocus() ) {
// TODO: Delegate event too when widget's not active?
HandleTextEvent( event.text.unicode );
GetSignals().Emit( OnText );
}
break;
default:
break;
}
}
void StreamThread(void *args) {
HWND hWnd = ((ArgList *)args)->hWnd;
SOCKET clientSocket = ((ArgList *)args)->socket;
static MouseEvent event, prevevent;
int button;
int timeout = 5*1000; //ms
setsockopt(clientSocket, SOL_SOCKET, SO_RCVTIMEO, (const char *)&timeout, sizeof(timeout));
MouseEvent versionEvent = {htonl(EVENT_VERSION), htonl(kVersionWindowsCurrent), 0, 0};
send(clientSocket, (const char *)&versionEvent, sizeof(versionEvent), 0);
while (TRUE) {
int recvsize = recv(clientSocket, (char *)&event, sizeof(event), 0);
if (recvsize == sizeof(event)) {
event.type = ntohl(event.type);
event.value = ntohl(event.value);
event.tv_sec = ntohl(event.tv_sec);
event.tv_nsec = ntohl(event.tv_nsec);
switch (event.type) {
case EVENT_MOUSE_DELTA_X:
break;
case EVENT_MOUSE_DELTA_Y:
if (prevevent.type == EVENT_MOUSE_DELTA_X)
mouse_event(MOUSEEVENTF_MOVE, prevevent.value, event.value, 0, 0);
break;
case EVENT_MOUSE_DELTA_W:
mouse_event( MOUSEEVENTF_HWHEEL, 0, 0, event.value, 0 );
break;
case EVENT_MOUSE_DELTA_Z:
mouse_event( MOUSEEVENTF_WHEEL, 0, 0, -event.value, 0 );
break;
case EVENT_MOUSE_DOWN:
button = MouseNumber(event.value);
if (button < 0 || kNumButtons <= button)
button = 0;
mouse_event(flagButtonDown[button], 0, 0, dataXButton[button], 0 );
break;
case EVENT_MOUSE_UP:
button = MouseNumber(event.value);
if (button < 0 || kNumButtons <= button)
button = 0;
mouse_event(flagButtonUp[button], 0, 0, dataXButton[button], 0 );
break;
case EVENT_KEY_DOWN:
HandleKeyEvent(event);
break;
case EVENT_KEY_UP:
HandleKeyEvent(event);
break;
case EVENT_ASCII:
SimulateKeyWithUnichar(event);
break;
default:
break;
}
prevevent = event;
//sending a ACK packet for the winsock 200ms problem
MouseEvent nullEvent = {htonl(EVENT_NULL), 0, 0, 0};
send(clientSocket, (const char *)&nullEvent, sizeof(nullEvent), 0);
} else if (recvsize == 0) {
connectionStatus = statusNotConnected;
break;
} else if (recvsize == SOCKET_ERROR) {
int errorno = WSAGetLastError();
if (errorno == WSAETIMEDOUT) {
// sending a keep-alive packet
MouseEvent nullEvent = {htonl(EVENT_NULL), 0, 0, 0};
send(clientSocket, (const char *)&nullEvent, sizeof(nullEvent), 0);
} else {
connectionStatus = errorno;
break;
}
}
}
RepaintWindow(hWnd);
Shell_NotifyIcon(NIM_MODIFY, &trayIcon[trayIconNotConnected]);
EnableMenuItem(GetMenu(hWnd), IDM_DISCONNECT, MF_BYCOMMAND | MF_GRAYED);
shutdown(clientSocket, SD_BOTH);
closesocket(clientSocket);
_endthread();
return;
}
void EventLoop(void)
{
while (1)
{
if (PendingEvent()) /* got event */
{
Event event;
while (NextValidEvent(&event))
{
switch (event.type)
{
case EVENT_BUTTONPRESS:
case EVENT_BUTTONRELEASE:
HandleButtonEvent((ButtonEvent *) &event);
break;
case EVENT_MOTIONNOTIFY:
HandleMotionEvent((MotionEvent *) &event);
break;
case EVENT_KEYPRESS:
case EVENT_KEYRELEASE:
HandleKeyEvent((KeyEvent *) &event);
break;
default:
HandleOtherEvents(&event);
break;
}
}
}
else
{
/* when playing, display a special mouse pointer inside the playfield */
if (game_status == GAME_MODE_PLAYING && !tape.pausing)
{
if (!playfield_cursor_set && cursor_inside_playfield &&
DelayReached(&playfield_cursor_delay, 1000))
{
SetMouseCursor(CURSOR_PLAYFIELD);
playfield_cursor_set = TRUE;
}
}
else if (playfield_cursor_set)
{
SetMouseCursor(CURSOR_DEFAULT);
playfield_cursor_set = FALSE;
}
HandleNoEvent();
}
/* don't use all CPU time when idle; the main loop while playing
has its own synchronization and is CPU friendly, too */
if (game_status == GAME_MODE_PLAYING)
{
HandleGameActions();
}
else
{
SyncDisplay();
if (!PendingEvent()) /* delay only if no pending events */
Delay(10);
}
/* refresh window contents from drawing buffer, if needed */
BackToFront();
if (game_status == GAME_MODE_QUIT)
return;
}
}
/*
* function : DiversionFormHandleEvent
*
* Handles all events directed at the form.
*
* Returns true if the event is handled
*/
Boolean DiversionFormHandleEvent(EventPtr event)
{
Boolean handled = false;
char *alphaInput;
switch (PFEventGetType(event))
{
case frmOpenEvent:
DiversionFormInit();
GUIFormResize(false, false);
UpdateDisplay();
handled = true;
break;
case winDisplayChangedEvent:
if (GUIFormResize(false, false)) UpdateDisplay();
handled = true;
break;
case evtGPSFix:
case evtGPSFixLost:
case evtGPSPositionUpdate:
case nilEvent:
/*
* turn scanning on/off according to state of GPS
*
*/
if (GPSState) {
if ( (scanState != disabled && GPS.sat.fixType < 2) ||
(scanState == disabled && GPS.sat.fixType > 1)) {
ResetScan();
if (!GUIMenuIsDisplayed()) UpdateDisplay();
} else if (GUIFieldIsDirty(DvSearchStr)) {
LOGTAG("Dirty field");
GUIFieldClean(DvSearchStr);
ResetScan();
if (!GUIMenuIsDisplayed()) UpdateDisplay();
} else if (scanState != disabled) {
/*
* update the display if the scan is completed or while
* we're still searching
*
*/
// if (ScanForWaypoints(PFTicksPerSecond()*3/4,true) || newProxList == &proxList)
(void)ScanForWaypoints(PFTicksPerSecond()*3/4,true);
if (!GUIMenuIsDisplayed()) UpdateDisplay();
}
} else {
/*
* if (FpIsBlank(FlightPlan)) {
*
* GUIObjectHide( MapPanToWaypointButton);
*
* }
*
* No GPS on, we're using our reference position
*
*/
if (ScanForWaypoints(PFTicksPerSecond()*3/4,true) || newProxList == &proxList)
if (!GUIMenuIsDisplayed()) UpdateDisplay();
}
handled = true;
break;
case keyDownEvent:
handled = HandleKeyEvent(event);
break;
case menuEvent:
switch (PFEventGetMenuID(event)) {
case MnDivertEmergency:
GUIFormGoto(MapForm);
handled = true;
break;
case MnInformation:
if (selectedWaypointID != UNSELECTED) {
/*
* waypoint is locked here, but will be unlocked by
* the WPInfoDialog
*
*/
WPInfoSetWaypointInfo(selectedWaypointID);
GUIFormPopup(WPInfoDialog);
}
handled = true;
break;
}
break;
case ctlSelectEvent:
handled = HandleCtlSelectEvent(event);
break;
case sclEnterEvent:
case sclRepeatEvent:
case sclExitEvent:
handled = true;
break;
case penDownEvent:
if (PFScreenPointInRectangle(PFEventGetX(event)*2, PFEventGetY(event)*2,
&proxDisplayArea)) {
handled = HandleProxSelectEvent(event);
}
break;
case fldEnterEvent:
AlphaPadDialogInit(GUIFieldGetText(DvSearchStr));
GUIFormPopup(AlphaPadDialog);
handled = true;
break;
case evtAlphaInput:
alphaInput = AlphaPadGetInput();
GUIFieldSetText(DvSearchStr, alphaInput, true);
PFMemFree(alphaInput);
ResetScan();
UpdateDisplay();
handled = true;
break;
case frmCloseEvent:
DiversionFormDeInit();
handled = false;
break;
case evtWaypointInfoReq:
/*
* this is sent by the command popup dialog
*
*/
default:
break;
}
return handled;
}
void Widget::HandleEvent( const sf::Event& event ) {
if( !IsGloballyVisible() ) {
return;
}
// Ignore the event if widget is insensitive
if ( GetState() == State::INSENSITIVE ) {
return;
}
// Ignore the event if another widget is active.
if( !IsActiveWidget() && !IsActiveWidget( PtrConst() ) ) {
return;
}
// Ignore the event if another widget is modal.
if( HasModal() && !IsModal() ) {
return;
}
// Set widget active in context.
Context::Get().SetActiveWidget( shared_from_this() );
auto parent = m_parent.lock();
auto emit_leave = false;
auto emit_enter = false;
auto emit_move = false;
auto emit_left_click = false;
auto emit_right_click = false;
try {
switch( event.type ) {
case sf::Event::MouseLeft:
if( IsMouseInWidget() ) {
SetMouseInWidget( false );
HandleMouseLeave( std::numeric_limits<int>::min(), std::numeric_limits<int>::min() );
emit_leave = true;
}
HandleMouseMoveEvent( std::numeric_limits<int>::min(), std::numeric_limits<int>::min() );
SetMouseButtonDown();
HandleMouseButtonEvent( sf::Mouse::Left, false, std::numeric_limits<int>::min(), std::numeric_limits<int>::min() );
HandleMouseButtonEvent( sf::Mouse::Right, false, std::numeric_limits<int>::min(), std::numeric_limits<int>::min() );
if( emit_leave ) {
GetSignals().Emit( OnMouseLeave );
}
break;
case sf::Event::MouseMoved:
// Check if pointer inside of widget's allocation.
if( GetAllocation().contains( static_cast<float>( event.mouseMove.x ), static_cast<float>( event.mouseMove.y ) ) ) {
// Check for enter event.
if( !IsMouseInWidget() ) {
SetMouseInWidget( true );
emit_enter = true;
HandleMouseEnter( event.mouseMove.x, event.mouseMove.y );
}
emit_move = true;
}
else if( IsMouseInWidget() ) { // Check for leave event.
SetMouseInWidget( false );
emit_leave = true;
HandleMouseLeave( event.mouseMove.x, event.mouseMove.y );
}
HandleMouseMoveEvent( event.mouseMove.x, event.mouseMove.y );
if( emit_move ) {
if( emit_enter ) {
GetSignals().Emit( OnMouseEnter );
}
GetSignals().Emit( OnMouseMove );
}
else if( emit_leave ) {
GetSignals().Emit( OnMouseLeave );
}
break;
case sf::Event::MouseButtonPressed:
if( !IsMouseButtonDown() && IsMouseInWidget() ) {
SetMouseButtonDown( event.mouseButton.button );
}
HandleMouseButtonEvent( event.mouseButton.button, true, event.mouseButton.x, event.mouseButton.y );
if( IsMouseInWidget() ) {
if( event.mouseButton.button == sf::Mouse::Left ) {
GetSignals().Emit( OnMouseLeftPress );
}
else if( event.mouseButton.button == sf::Mouse::Right ) {
GetSignals().Emit( OnMouseRightPress );
}
}
break;
case sf::Event::MouseButtonReleased:
// Only process as a click when mouse button has been pressed inside the widget before.
if( IsMouseButtonDown( event.mouseButton.button ) ) {
SetMouseButtonDown();
// When released inside the widget, the event can be considered a click.
if( IsMouseInWidget() ) {
HandleMouseClick( event.mouseButton.button, event.mouseButton.x, event.mouseButton.y );
if( event.mouseButton.button == sf::Mouse::Left ) {
emit_left_click = true;
}
else if( event.mouseButton.button == sf::Mouse::Right ) {
emit_right_click = true;
}
}
}
HandleMouseButtonEvent( event.mouseButton.button, false, event.mouseButton.x, event.mouseButton.y );
if( emit_left_click ) {
GetSignals().Emit( OnLeftClick );
}
else if( emit_right_click ) {
GetSignals().Emit( OnRightClick );
}
if( IsMouseInWidget() ) {
if( event.mouseButton.button == sf::Mouse::Left ) {
GetSignals().Emit( OnMouseLeftRelease );
}
else if( event.mouseButton.button == sf::Mouse::Right ) {
GetSignals().Emit( OnMouseRightRelease );
}
}
break;
case sf::Event::KeyPressed:
if( HasFocus() ) {
// TODO: Delegate event too when widget's not active?
HandleKeyEvent( event.key.code, true );
GetSignals().Emit( OnKeyPress );
}
break;
case sf::Event::KeyReleased:
if( HasFocus() ) {
// TODO: Delegate event too when widget's not active?
HandleKeyEvent( event.key.code, false );
GetSignals().Emit( OnKeyRelease );
}
break;
case sf::Event::TextEntered:
if( HasFocus() ) {
// TODO: Delegate event too when widget's not active?
HandleTextEvent( event.text.unicode );
GetSignals().Emit( OnText );
}
break;
default:
break;
}
}
catch( ... ) {
SetState( State::NORMAL );
throw;
}
}
void Widget::HandleEvent( const sf::Event& event ) {
if( !IsVisible() ) {
return;
}
// Set widget active in context.
Context::Get().SetActiveWidget( shared_from_this() );
Container::Ptr parent( m_parent.lock() );
switch( event.Type ) {
case sf::Event::MouseMoved:
// Check if pointer inside of widget's allocation.
if( GetAllocation().Contains( static_cast<float>( event.MouseMove.X ), static_cast<float>( event.MouseMove.Y ) ) ) {
// Check for enter event.
if( m_mouse_in == false ) {
m_mouse_in = true;
OnMouseEnter();
HandleMouseEnter( event.MouseMove.X, event.MouseMove.Y );
}
OnMouseMove();
}
else if( m_mouse_in == true ) { // Check for leave event.
m_mouse_in = false;
OnMouseLeave();
HandleMouseLeave( event.MouseMove.X, event.MouseMove.Y );
}
HandleMouseMoveEvent( event.MouseMove.X, event.MouseMove.Y );
break;
case sf::Event::MouseButtonPressed:
// If a mouse button has already been pressed for this widget, drop further
// presses. This maybe needs changing, but up to now, I can't think of any
// cases where it would be useful to have such a functionality.
if( m_mouse_button_down == -1 ) {
if( m_mouse_in ) {
m_mouse_button_down = event.MouseButton.Button;
HandleMouseButtonEvent( event.MouseButton.Button, true, event.MouseButton.X, event.MouseButton.Y );
OnMouseButtonPress();
}
}
break;
case sf::Event::MouseButtonReleased:
// Only process when mouse button has been clicked inside the widget before.
if( m_mouse_button_down == event.MouseButton.Button ) {
m_mouse_button_down = -1;
// When released inside the widget, the event can be considered a click.
if( m_mouse_in ) {
HandleMouseClick( event.MouseButton.Button, event.MouseButton.X, event.MouseButton.Y );
}
OnMouseButtonRelease();
}
HandleMouseButtonEvent( event.MouseButton.Button, false, event.MouseButton.X, event.MouseButton.Y );
break;
case sf::Event::KeyPressed:
if( GetState() == Active ) {
// TODO: Delegate event too when widget's not active?
HandleKeyEvent( event.Key.Code, true );
OnKeyPress();
}
break;
case sf::Event::KeyReleased:
if( GetState() == Active ) {
// TODO: Delegate event too when widget's not active?
HandleKeyEvent( event.Key.Code, false );
OnKeyRelease();
}
break;
case sf::Event::TextEntered:
if( GetState() == Active ) {
// TODO: Delegate event too when widget's not active?
HandleTextEvent( event.Text.Unicode );
OnText();
}
break;
default:
break;
}
}
bool
StreamReaderWin::ReadInput(size_t& nRead, InputData& in) {
DWORD NRead = 0;
in.SetModifier(InputData::kModNone);
char C;
if (fIsConsole) {
INPUT_RECORD buf;
if (!::ReadConsoleInput(fIn, &buf, 1, &NRead)) {
HandleError("reading console input");
return false;
}
switch (buf.EventType) {
case KEY_EVENT:
{
if (!buf.Event.KeyEvent.bKeyDown) return false;
WORD Key = buf.Event.KeyEvent.wVirtualKeyCode;
if (buf.Event.KeyEvent.dwControlKeyState
& (LEFT_CTRL_PRESSED | RIGHT_CTRL_PRESSED)) {
if (buf.Event.KeyEvent.dwControlKeyState
& (LEFT_ALT_PRESSED | RIGHT_ALT_PRESSED)) {
// special "Alt Gr" case (equivalent to Ctrl+Alt)...
in.SetModifier(InputData::kModNone);
}
else {
in.SetModifier(InputData::kModCtrl);
}
}
if ((Key >= 0x30 && Key <= 0x5A /*0-Z*/)
|| (Key >= VK_NUMPAD0 && Key <= VK_DIVIDE)
|| (Key >= VK_OEM_1 && Key <= VK_OEM_102)
|| Key == VK_SPACE) {
C = buf.Event.KeyEvent.uChar.AsciiChar;
if (buf.Event.KeyEvent.dwControlKeyState
& (LEFT_CTRL_PRESSED | RIGHT_CTRL_PRESSED)) {
// C is already 1..
}
} else {
switch (Key) {
case VK_BACK:
in.SetExtended(InputData::kEIBackSpace);
break;
case VK_TAB:
in.SetExtended(InputData::kEITab);
break;
case VK_RETURN:
in.SetExtended(InputData::kEIEnter);
break;
case VK_ESCAPE:
in.SetExtended(InputData::kEIEsc);
break;
case VK_PRIOR:
in.SetExtended(InputData::kEIPgUp);
break;
case VK_NEXT:
in.SetExtended(InputData::kEIPgDown);
break;
case VK_END:
in.SetExtended(InputData::kEIEnd);
break;
case VK_HOME:
in.SetExtended(InputData::kEIHome);
break;
case VK_LEFT:
in.SetExtended(InputData::kEILeft);
break;
case VK_UP:
in.SetExtended(InputData::kEIUp);
break;
case VK_RIGHT:
in.SetExtended(InputData::kEIRight);
break;
case VK_DOWN:
in.SetExtended(InputData::kEIDown);
break;
case VK_INSERT:
in.SetExtended(InputData::kEIIns);
break;
case VK_DELETE:
in.SetExtended(InputData::kEIDel);
break;
case VK_F1:
in.SetExtended(InputData::kEIF1);
break;
case VK_F2:
in.SetExtended(InputData::kEIF2);
break;
case VK_F3:
in.SetExtended(InputData::kEIF3);
break;
case VK_F4:
in.SetExtended(InputData::kEIF4);
break;
case VK_F5:
in.SetExtended(InputData::kEIF5);
break;
case VK_F6:
in.SetExtended(InputData::kEIF6);
break;
case VK_F7:
in.SetExtended(InputData::kEIF7);
break;
case VK_F8:
in.SetExtended(InputData::kEIF8);
break;
case VK_F9:
in.SetExtended(InputData::kEIF9);
break;
case VK_F10:
in.SetExtended(InputData::kEIF10);
break;
case VK_F11:
in.SetExtended(InputData::kEIF11);
break;
case VK_F12:
in.SetExtended(InputData::kEIF12);
break;
default:
in.SetExtended(InputData::kEIUninitialized);
return false;
}
return true;
}
break;
}
case WINDOW_BUFFER_SIZE_EVENT:
in.SetExtended(InputData::kEIResizeEvent);
++nRead;
return true;
break;
default:
return false;
}
} else {
if (!::ReadFile(fIn, &C, 1, &NRead, NULL)) {
HandleError("reading file input");
return false;
}
}
HandleKeyEvent(C, in);
++nRead;
return true;
}
