void InputManager::HandleEvent( SDL_Event& ev )
{
if ( ev.type == SDL_MOUSEMOTION )
{
HandleMouseMotionEvent( *reinterpret_cast<SDL_MouseMotionEvent*>( &ev ) );
}
else if ( ev.type == SDL_MOUSEBUTTONDOWN )
{
HandleMouseButtonEvent( *reinterpret_cast<SDL_MouseButtonEvent*>( &ev ), ButtonState::Pressed );
}
else if ( ev.type == SDL_MOUSEBUTTONUP )
{
HandleMouseButtonEvent( *reinterpret_cast<SDL_MouseButtonEvent*>( &ev ), ButtonState::Released );
}
else if ( ev.type == SDL_MOUSEWHEEL )
{
HandleMouseWheelEvent( ev.wheel );
}
else if ( ev.type == SDL_KEYDOWN )
{
HandleKeyboardEvent( ev.key, ButtonState::Pressed );
}
else if ( ev.type == SDL_KEYUP )
{
HandleKeyboardEvent( ev.key, ButtonState::Released );
}
if ( FrameWork::GetGuiManager() && FrameWork::GetGuiManager()->GetFocusedInputArea() )
{
HandleInputAreaEvent( ev );
}
}
nsEventStatus
AccessibleCaretEventHub::HandleEvent(WidgetEvent* aEvent)
{
nsEventStatus status = nsEventStatus_eIgnore;
if (!mInitialized) {
return status;
}
MOZ_ASSERT(mRefCnt.get() > 1, "Expect caller holds us as well!");
switch (aEvent->mClass) {
case eMouseEventClass:
status = HandleMouseEvent(aEvent->AsMouseEvent());
break;
case eTouchEventClass:
status = HandleTouchEvent(aEvent->AsTouchEvent());
break;
case eKeyboardEventClass:
status = HandleKeyboardEvent(aEvent->AsKeyboardEvent());
break;
default:
break;
}
return status;
}
nsEventStatus
AccessibleCaretEventHub::HandleEvent(WidgetEvent* aEvent)
{
nsEventStatus status = nsEventStatus_eIgnore;
if (!mInitialized) {
return status;
}
switch (aEvent->mClass) {
case eMouseEventClass:
status = HandleMouseEvent(aEvent->AsMouseEvent());
break;
case eWheelEventClass:
status = HandleWheelEvent(aEvent->AsWheelEvent());
break;
case eTouchEventClass:
status = HandleTouchEvent(aEvent->AsTouchEvent());
break;
case eKeyboardEventClass:
status = HandleKeyboardEvent(aEvent->AsKeyboardEvent());
break;
default:
break;
}
return status;
}
// Handle keyboard events
//-----------------------------------------------------------------------------
CPUTEventHandledCode CPUT_DX11::CPUTHandleKeyboardEvent(CPUTKey key)
{
// dispatch event to GUI to handle GUI triggers (if any)
CPUTEventHandledCode handleCode = CPUTGuiControllerDX11::GetController()->HandleKeyboardEvent(key);
// dispatch event to users HandleMouseEvent() method
HEAPCHECK;
handleCode = HandleKeyboardEvent(key);
HEAPCHECK;
return handleCode;
}
// Handle keyboard events
//-----------------------------------------------------------------------------
CPUTEventHandledCode CPUT_OGL::CPUTHandleKeyboardEvent(CPUTKey key, CPUTKeyState state)
{
CPUTEventHandledCode handleCode;
// dispatch event to GUI to handle GUI triggers (if any) #### no GUI for now
//CPUTEventHandledCode handleCode = CPUTGuiController::GetController()->HandleKeyboardEvent(key);
// dispatch event to users HandleMouseEvent() method
HEAPCHECK;
handleCode = HandleKeyboardEvent(key, state);
HEAPCHECK;
return handleCode;
}
void HaikuDirectWindow::DispatchMessage(BMessage *message, BHandler *handler) {
switch (message->what) {
case B_MOUSE_DOWN:
case B_MOUSE_UP:
HandleMouseButton(message);
break;
case B_MOUSE_MOVED:
HandleMouseMoved(message);
break;
case B_MOUSE_WHEEL_CHANGED:
HandleMouseWheelChanged(message);
break;
case B_KEY_DOWN:
case B_KEY_UP:
HandleKeyboardEvent(message);
break;
case B_MODIFIERS_CHANGED:
HandleKeyboardModifierEvent(message);
break;
case B_WINDOW_RESIZED:
HandleWindowResized(message);
break;
case LOCKGL_MSG:
view->LockGL();
break;
case UNLOCKGL_MSG:
view->UnlockGL();
break;
default:
BDirectWindow::DispatchMessage(message, handler);
}
}
int main(int argc, char **argv) {
const char *optstring = "hd:c:t:FLRUDS:";
int o;
int delay = 0;
int device_type = 1;
char *device = NULL;
unsigned int set_event = 0;
unsigned int set_fire = 0, set_left = 0, set_right = 0;
unsigned int set_up = 0, set_down = 0, set_stop = 0;
//---------------------------------------------------------------------------
// Get args
o = getopt(argc, argv, optstring);
while (o != -1) {
switch (o) {
case 'h':
usage(argv[0]);
return 0;
case 'd':
debug_level = atoi(optarg);
fprintf(stderr, "debug_level set to %d\n", debug_level);
break;
case 'c':
device = optarg;
set_event = 1;
break;
case 't':
device_type = atoi(optarg);
break;
case 'F':
set_fire = 1;
break;
case 'U':
set_up = 1;
break;
case 'D':
set_down = 1;
break;
case 'L':
set_left = 1;
break;
case 'R':
set_right = 1;
break;
case 'S':
set_stop = 1;
delay = atoi(optarg);
break;
}
o = getopt(argc, argv, optstring);
}
//---------------------------------------------------------------------------
if (missile_usb_initialise() != 0) {
fprintf(stderr, "missile_usb_initalise failed: %s\n", strerror(errno));
return -1;
}
control = missile_usb_create(debug_level, USB_TIMEOUT);
if (control == NULL) {
fprintf(stderr, "missile_usb_create() failed\n");
return -1;
}
if (missile_usb_finddevice(control, 0, device_type) != 0) {
fprintf(stderr, "USBMissileLauncher device not found\n");
return -1;
}
if (debug_level)
fprintf(stderr, "Now we're ready. Move the thing around, and FIRE!\n");
//---------------------------------------------------------------------------
int fd;
struct input_event ev[64];
int events;
if (set_event) {
if (device == NULL) {
fprintf(stderr, "No device given\n");
usage(argv[0]);
return 0;
}
if (IEOpen(device, &fd) < 0) {
fprintf(stderr, "IEOpen(%s, fd) failed\n", device);
return -1;
}
while (1) {
if (IERead(fd, ev, &events) < 0) {
fprintf(stderr, "IERead() failed\n");
return -1;
}
if (HandleKeyboardEvent(ev, events, device_type) < 0) {
fprintf(stderr, "HandleKeyboardEvent() failed\n");
return -1;
}
usleep(200000);
}
}
//---------------------------------------------------------------------------
char msg = 0x00;
switch (device_type) {
case DEVICE_TYPE_MISSILE_LAUNCHER:
if (set_left)
msg |= MISSILE_LAUNCHER_CMD_LEFT;
if (set_right)
msg |= MISSILE_LAUNCHER_CMD_RIGHT;
if (set_up)
msg |= MISSILE_LAUNCHER_CMD_UP;
if (set_down)
msg |= MISSILE_LAUNCHER_CMD_DOWN;
if (set_fire)
msg |= MISSILE_LAUNCHER_CMD_FIRE;
missile_do(control, msg, device_type);
if (set_stop) {
usleep(delay * 1000);
missile_do(control, MISSILE_LAUNCHER_CMD_STOP, device_type);
}
break;
case DEVICE_TYPE_CIRCUS_CANNON:
if (set_left)
msg |= CIRCUS_CANNON_CMD_LEFT;
if (set_right)
msg |= CIRCUS_CANNON_CMD_RIGHT;
if (set_up)
msg |= CIRCUS_CANNON_CMD_UP;
if (set_down)
msg |= CIRCUS_CANNON_CMD_DOWN;
if (set_fire)
msg |= CIRCUS_CANNON_CMD_FIRE;
missile_do(control, msg, device_type);
if (set_stop) {
usleep(delay * 1000);
missile_do(control, CIRCUS_CANNON_CMD_STOP, device_type);
}
break;
default:
printf("Device Type (%d) not implemented, please do it!\n",
device_type);
return -1;
}
missile_usb_destroy(control);
//---------------------------------------------------------------------------
return 0;
}
bool LocalEvent::HandleEvents(bool delay)
{
SDL_Event event;
ResetModes(MOUSE_MOTION);
ResetModes(KEY_PRESSED);
while(SDL_PollEvent(&event))
{
switch(event.type)
{
case SDL_ACTIVEEVENT:
if(event.active.state & SDL_APPACTIVE)
{
#ifdef WITH_MIXER
if(Mixer::isValid())
{
//iconify
if(0 == event.active.gain)
{
Mixer::Reset();
Music::Pause();
loop_delay = 100;
}
else
loop_delay = 1;
}
#endif
}
break;
// keyboard
case SDL_KEYDOWN:
case SDL_KEYUP:
HandleKeyboardEvent(event.key);
break;
// mouse motion
case SDL_MOUSEMOTION:
HandleMouseMotionEvent(event.motion);
break;
// mouse button
case SDL_MOUSEBUTTONDOWN:
case SDL_MOUSEBUTTONUP:
HandleMouseButtonEvent(event.button);
break;
// exit
case SDL_QUIT:
Error::Except(__FUNCTION__, "SDL_QUIT");
return false;
default:
break;
}
// need for wheel up/down delay
if(SDL_BUTTON_WHEELDOWN == event.button.button || SDL_BUTTON_WHEELUP == event.button.button) break;
}
// emulate press right
if((modes & TAP_MODE) && (modes & CLOCK_ON))
{
clock.Stop();
if(clock_delay < clock.Get())
{
ResetModes(CLICK_LEFT);
ResetModes(CLOCK_ON);
mouse_pr = mouse_cu;
SetModes(MOUSE_PRESSED);
mouse_button = SDL_BUTTON_RIGHT;
}
}
if(delay) SDL_Delay(loop_delay);
return true;
}
