void HELENOS_PumpEvents(_THIS){ kbd_event_t kbd_event; pos_event_t pos_event; SDL_keysym keysym; int posted=0; while(canvas_pop_keyboard_event(&kbd_event)){ if(kbd_event.type == KEY_PRESS) { posted += SDL_PrivateKeyboard(SDL_PRESSED, HelenOS_TranslateKey(&kbd_event, &keysym)); } else if(kbd_event.type == KEY_RELEASE){ posted += SDL_PrivateKeyboard(SDL_RELEASED, HelenOS_TranslateKey(&kbd_event, &keysym)); } } while(canvas_pop_position_event(&pos_event)){ static int mouse_x = 0, mouse_y = 0; if(pos_event.type == POS_PRESS){ posted += SDL_PrivateMouseButton(SDL_PRESSED, (uint8_t)pos_event.btn_num, 0, 0); } else if(pos_event.type == POS_RELEASE){ posted += SDL_PrivateMouseButton(SDL_RELEASED, (uint8_t)pos_event.btn_num, 0, 0); } else if(pos_event.type == POS_UPDATE){ if (mouse_x != pos_event.hpos || mouse_y != pos_event.vpos) { mouse_x = pos_event.hpos; mouse_y = pos_event.vpos; // int x = pos_event.hpos - mouse_x; // int y = pos_event.vpos - mouse_y; posted += SDL_PrivateMouseMotion(0, 0, pos_event.hpos, pos_event.vpos); } } } }
void NDS_PumpEvents(_THIS) { scanKeys(); int i; SDL_keysym keysym; keysym.mod=KMOD_NONE; for(i=0;i<NDS_NUMKEYS;i++) { keysym.scancode=i; keysym.sym=keymap[i]; if(keysHeld()&(1<<i) && !keymem[i]) { keymem[i]=1; //printf("key released %d\n",i); SDL_PrivateKeyboard(SDL_RELEASED, &keysym); } if(!(keysHeld()&(1<<i)) && keymem[i]) { keymem[i]=0; //printf("key pressed %d\n",i); SDL_PrivateKeyboard(SDL_PRESSED, &keysym); } } //touchPosition touch; //touch=touchReadXY(); //if (touch.px!=0 || touch.py!=0) // SDL_PrivateMouseMotion(SDL_PRESSED, 0, touch.px, touch.py); }
void AtariIkbd_PumpEvents(_THIS) { int i, specialkeys; SDL_keysym keysym; /*--- Send keyboard events ---*/ for (i=0; i<ATARIBIOS_MAXKEYS; i++) { /* Key pressed ? */ if (SDL_AtariIkbd_keyboard[i]==KEY_PRESSED) { SDL_PrivateKeyboard(SDL_PRESSED, SDL_Atari_TranslateKey(i, &keysym, SDL_TRUE)); SDL_AtariIkbd_keyboard[i]=KEY_UNDEFINED; } /* Key released ? */ if (SDL_AtariIkbd_keyboard[i]==KEY_RELEASED) { SDL_PrivateKeyboard(SDL_RELEASED, SDL_Atari_TranslateKey(i, &keysym, SDL_FALSE)); SDL_AtariIkbd_keyboard[i]=KEY_UNDEFINED; } } /*--- Send mouse events ---*/ /* Mouse motion ? */ if (SDL_AtariIkbd_mousex || SDL_AtariIkbd_mousey) { SDL_PrivateMouseMotion(0, 1, SDL_AtariIkbd_mousex, SDL_AtariIkbd_mousey); SDL_AtariIkbd_mousex = SDL_AtariIkbd_mousey = 0; } /* Mouse button ? */ if (SDL_AtariIkbd_mouseb != atari_prevmouseb) { for (i=0;i<2;i++) { int curbutton, prevbutton; curbutton = SDL_AtariIkbd_mouseb & (1<<i); prevbutton = atari_prevmouseb & (1<<i); if (curbutton && !prevbutton) { SDL_PrivateMouseButton(SDL_PRESSED, atari_GetButton(i), 0, 0); } if (!curbutton && prevbutton) { SDL_PrivateMouseButton(SDL_RELEASED, atari_GetButton(i), 0, 0); } } atari_prevmouseb = SDL_AtariIkbd_mouseb; } }
void DirectFB_PumpEvents (_THIS) { DFBInputEvent evt; while (HIDDEN->eventbuffer->GetEvent (HIDDEN->eventbuffer, DFB_EVENT (&evt)) == DFB_OK) { SDL_keysym keysym; switch (evt.type) { case DIET_BUTTONPRESS: posted += SDL_PrivateMouseButton(SDL_PRESSED, DirectFB_TranslateButton (&evt), 0, 0); break; case DIET_BUTTONRELEASE: posted += SDL_PrivateMouseButton(SDL_RELEASED, DirectFB_TranslateButton (&evt), 0, 0); break; case DIET_KEYPRESS: posted += SDL_PrivateKeyboard(SDL_PRESSED, DirectFB_TranslateKey(&evt, &keysym)); break; case DIET_KEYRELEASE: posted += SDL_PrivateKeyboard(SDL_RELEASED, DirectFB_TranslateKey(&evt, &keysym)); break; case DIET_AXISMOTION: if (evt.flags & DIEF_AXISREL) { if (evt.axis == DIAI_X) posted += SDL_PrivateMouseMotion(0, 1, evt.axisrel, 0); else if (evt.axis == DIAI_Y) posted += SDL_PrivateMouseMotion(0, 1, 0, evt.axisrel); } else if (evt.flags & DIEF_AXISABS) { static int last_x, last_y; if (evt.axis == DIAI_X) last_x = evt.axisabs; else if (evt.axis == DIAI_Y) last_y = evt.axisabs; posted += SDL_PrivateMouseMotion(0, 0, last_x, last_y); } break; default: ; } } }
static void handle_keyboard(const int numevents, DIDEVICEOBJECTDATA *keybuf) { int i; SDL_keysym keysym; for ( i=0; i<numevents; ++i ) { if ( keybuf[i].dwData & 0x80 ) { posted = SDL_PrivateKeyboard(SDL_PRESSED, TranslateKey(keybuf[i].dwOfs, &keysym, 1)); } else { posted = SDL_PrivateKeyboard(SDL_RELEASED, TranslateKey(keybuf[i].dwOfs, &keysym, 0)); } } }
static void keyboard_update(void) { static SDL_keysym keysym; static XKEYBOARD_STROKE keystroke; if( 0 > XInputGetKeystroke(&keystroke) ) return; if (keystroke.ucKeyCode == 0) return; if ( keystroke.ucFlags & XKEYBOARD_KEYUP ) { SDL_PrivateKeyboard(SDL_RELEASED, TranslateKey(keystroke,&keysym, 1)); } else { SDL_PrivateKeyboard(SDL_PRESSED, TranslateKey(keystroke,&keysym, 0)); } }
void AtariGemdos_PumpEvents(_THIS) { int i; SDL_keysym keysym; /* Update pressed keys */ SDL_memset(gemdos_currentkeyboard, 0, ATARIBIOS_MAXKEYS); while (Cconis()!=DEV_BUSY) { unsigned long key_pressed; unsigned char scancode, asciicode; key_pressed=Cnecin(); asciicode = key_pressed; scancode = key_pressed >> 16; gemdos_currentkeyboard[scancode]=0xFF; gemdos_currentascii[scancode]=asciicode; } /* Read special keys */ UpdateSpecialKeys(Kbshift(-1)); /* Now generate events */ for (i=0; i<ATARIBIOS_MAXKEYS; i++) { /* Key pressed ? */ if (gemdos_currentkeyboard[i] && !gemdos_previouskeyboard[i]) SDL_PrivateKeyboard(SDL_PRESSED, TranslateKey(i, gemdos_currentascii[i], &keysym, SDL_TRUE)); /* Key unpressed ? */ if (gemdos_previouskeyboard[i] && !gemdos_currentkeyboard[i]) SDL_PrivateKeyboard(SDL_RELEASED, TranslateKey(i, gemdos_currentascii[i], &keysym, SDL_FALSE)); } if (use_dev_mouse) { SDL_AtariDevMouse_PostMouseEvents(this, SDL_TRUE); } else { SDL_AtariXbios_PostMouseEvents(this, SDL_TRUE); } /* Will be previous table */ SDL_memcpy(gemdos_previouskeyboard, gemdos_currentkeyboard, ATARIBIOS_MAXKEYS); }
int PG_HandleChar(struct pgEvent *evt) { SDL_keysym sym; memset(&sym,0,sizeof(sym)); sym.unicode = evt->e.kbd.key; sym.mod = evt->e.kbd.mods; SDL_PrivateKeyboard(evt->type == PG_WE_KBD_KEYDOWN, &sym); return 0; }
extern void SDL_ANDROID_PumpEvents() { static int oldMouseButtons = 0; SDL_Event ev; SDL_mutexP(BufferedEventsMutex); while( BufferedEventsStart != BufferedEventsEnd ) { ev = BufferedEvents[BufferedEventsStart]; BufferedEvents[BufferedEventsStart].type = 0; BufferedEventsStart++; if( BufferedEventsStart >= MAX_BUFFERED_EVENTS ) BufferedEventsStart = 0; SDL_mutexV(BufferedEventsMutex); switch( ev.type ) { case SDL_MOUSEMOTION: //__android_log_print(ANDROID_LOG_INFO, "libSDL", "SDL_MOUSEMOTION REAL: x=%i y=%i", ev.motion.x, ev.motion.y); if( SDL_ANDROID_sWindowWidth > 0 && SDL_ANDROID_sWindowHeight > 0 ) { int x = ev.motion.x * SDL_ANDROID_sFakeWindowWidth / SDL_ANDROID_sWindowWidth; int y = ev.motion.y * SDL_ANDROID_sFakeWindowHeight / SDL_ANDROID_sWindowHeight; //__android_log_print(ANDROID_LOG_INFO, "libSDL", "SDL_MOUSEMOTION: x=%i y=%i", x, y); SDL_PrivateMouseMotion(0, 0, x, y); } break; case SDL_MOUSEBUTTONDOWN: //__android_log_print(ANDROID_LOG_INFO, "libSDL", "SDL_MOUSEBUTTONDOWN: %i %i", ev.button.button, ev.button.state); if( ((oldMouseButtons & SDL_BUTTON(ev.button.button)) != 0) != ev.button.state ) { oldMouseButtons = (oldMouseButtons & ~SDL_BUTTON(ev.button.button)) | (ev.button.state ? SDL_BUTTON(ev.button.button) : 0); SDL_PrivateMouseButton( ev.button.state, ev.button.button, 0, 0 ); } break; case SDL_KEYDOWN: //__android_log_print(ANDROID_LOG_INFO, "libSDL", "SDL_KEYDOWN: %i %i", ev.key.keysym.sym, ev.key.state); SDL_PrivateKeyboard( ev.key.state, &ev.key.keysym ); break; // case SDL_VIDEOEXPOSE: { SDL_Surface* screen = SDL_GetVideoSurface(); if(screen) { SDL_Flip(screen); } } break; default: break; } SDL_mutexP(BufferedEventsMutex); } SDL_mutexV(BufferedEventsMutex); };
void AtariBios_PumpEvents(_THIS) { int i; SDL_keysym keysym; SDL_AtariMint_BackgroundTasks(); /* Update pressed keys */ SDL_memset(bios_currentkeyboard, 0, ATARIBIOS_MAXKEYS); while (Bconstat(_CON)) { unsigned long key_pressed; key_pressed=Bconin(_CON); bios_currentkeyboard[(key_pressed>>16)&(ATARIBIOS_MAXKEYS-1)]=0xFF; } /* Read special keys */ UpdateSpecialKeys(Kbshift(-1)); /* Now generate events */ for (i=0; i<ATARIBIOS_MAXKEYS; i++) { /* Key pressed ? */ if (bios_currentkeyboard[i] && !bios_previouskeyboard[i]) SDL_PrivateKeyboard(SDL_PRESSED, SDL_Atari_TranslateKey(i, &keysym, SDL_TRUE)); /* Key unpressed ? */ if (bios_previouskeyboard[i] && !bios_currentkeyboard[i]) SDL_PrivateKeyboard(SDL_RELEASED, SDL_Atari_TranslateKey(i, &keysym, SDL_FALSE)); } if (use_dev_mouse) { SDL_AtariDevMouse_PostMouseEvents(this, SDL_TRUE); } else { SDL_AtariXbios_PostMouseEvents(this, SDL_TRUE); } /* Will be previous table */ SDL_memcpy(bios_previouskeyboard, bios_currentkeyboard, sizeof(bios_previouskeyboard)); }
static void handleKeyboardEvent(screen_event_t event) { static const int KEYBOARD_TYPE_MASK = 0x20; int sym = 0; screen_get_event_property_iv(event, SCREEN_PROPERTY_KEY_SYM, &sym); int modifiers = 0; screen_get_event_property_iv(event, SCREEN_PROPERTY_KEY_MODIFIERS, &modifiers); int flags = 0; screen_get_event_property_iv(event, SCREEN_PROPERTY_KEY_FLAGS, &flags); int scan = 0; screen_get_event_property_iv(event, SCREEN_PROPERTY_KEY_SCAN, &scan); int cap = 0; screen_get_event_property_iv(event, SCREEN_PROPERTY_KEY_CAP, &cap); int shifted = 0; SDL_keysym keysym; if (flags & KEYBOARD_TYPE_MASK) { if (!TranslateBluetoothKeyboard(sym, modifiers, flags, scan, cap, &keysym)) { return; // No translation } } else { shifted = TranslateVKB(sym, modifiers, flags, scan, cap, &keysym); } if (shifted) { SDL_keysym temp; temp.scancode = 42; temp.sym = SDLK_LSHIFT; SDL_PrivateKeyboard(SDL_PRESSED, &temp); } SDL_PrivateKeyboard((flags & 0x1)?SDL_PRESSED:SDL_RELEASED, &keysym); if (shifted) { SDL_keysym temp; temp.scancode = 42; temp.sym = SDLK_LSHIFT; SDL_PrivateKeyboard(SDL_RELEASED, &temp); } }
void NSP_PumpEvents(_THIS) { int i; for ( i = 0; i < NSP_NUMKEYS; ++i ) { if ( sdlk_keymap[i] == SDLK_UNKNOWN ) continue; BOOL key_pressed = isKeyPressed(nspk_keymap[i]); SDL_keysym keysym; keysym.scancode = i; keysym.sym = sdlk_keymap[i]; if ( key_state[i] == SDL_RELEASED ) { if ( key_pressed ) { SDL_PrivateKeyboard(SDL_PRESSED, &keysym); key_state[i] = SDL_PRESSED; } } else if ( ! key_pressed ) { SDL_PrivateKeyboard(SDL_RELEASED, &keysym); key_state[i] = SDL_RELEASED; } } }
void ORBITAL_PumpEvents(_THIS) { struct Event event; while(read(this->hidden->fd, &event, sizeof(event)) > 0){ if ( event.code == EVENT_KEY ){ SDL_keysym keysym; keysym.unicode = event.a; keysym.scancode = event.b; keysym.sym = keymap[event.b]; keysym.mod = KMOD_NONE; if ( event.c > 0 ) { SDL_PrivateKeyboard(SDL_PRESSED, &keysym); } else { SDL_PrivateKeyboard(SDL_RELEASED, &keysym); } }else if( event.code == EVENT_MOUSE ){ SDL_PrivateMouseMotion(event.c, 0, event.a, event.b); //SDL_PrivateMouseButton(Uint8 state, Uint8 button, Sint16 x, Sint16 y); } } }
void CELL_DoKeyEventSDLK (enum HID_ID aID, uint32_t aState, uint32_t aUnicode) { const CELL_Key* key = CELL_GetKeyFromHID(aID); SDL_keysym sym; FillKeysym(&sym, key->Symbol, key->Scancode); if(SDL_TranslateUNICODE) { sym.unicode = aUnicode; } SDL_PrivateKeyboard(aState, &sym); }
void CELL_DoKeyEvent (enum HID_ID aID, uint32_t aState, uint32_t aModifiers, uint32_t aLeds) { const CELL_Key* key = CELL_GetKeyFromHID(aID); SDL_keysym sym; FillKeysym(&sym, key->Symbol, key->Scancode); if(SDL_TranslateUNICODE) { sym.unicode = cellKbCnvRawCode(CELL_KB_MAPPING_101, aModifiers, aLeds, key->HIDID); } SDL_PrivateKeyboard(aState, &sym); }
void AtariBios_PumpEvents(_THIS) { int i; SDL_keysym keysym; SDL_memset(bios_currentkeyboard, 0, ATARIBIOS_MAXKEYS); while (Bconstat(_CON)) { unsigned long key_pressed; key_pressed=Bconin(_CON); bios_currentkeyboard[(key_pressed>>16)&(ATARIBIOS_MAXKEYS-1)]=0xFF; } UpdateSpecialKeys(Kbshift(-1)); for (i=0; i<ATARIBIOS_MAXKEYS; i++) { if (bios_currentkeyboard[i] && !bios_previouskeyboard[i]) SDL_PrivateKeyboard(SDL_PRESSED, SDL_Atari_TranslateKey(i, &keysym, SDL_TRUE)); if (bios_previouskeyboard[i] && !bios_currentkeyboard[i]) SDL_PrivateKeyboard(SDL_RELEASED, SDL_Atari_TranslateKey(i, &keysym, SDL_FALSE)); } if (use_dev_mouse) { SDL_AtariDevMouse_PostMouseEvents(this, SDL_TRUE); } else { SDL_AtariXbios_PostMouseEvents(this, SDL_TRUE); } SDL_memcpy(bios_previouskeyboard, bios_currentkeyboard, sizeof(bios_previouskeyboard)); }
static int DGA_DispatchEvent(_THIS) { int posted; SDL_NAME(XDGAEvent) xevent; XNextEvent(DGA_Display, (XEvent *)&xevent); posted = 0; xevent.type -= DGA_event_base; switch (xevent.type) { /* Mouse motion? */ case MotionNotify: { if ( SDL_VideoSurface ) { posted = SDL_PrivateMouseMotion(0, 1, xevent.xmotion.dx, xevent.xmotion.dy); } } break; /* Mouse button press? */ case ButtonPress: { posted = SDL_PrivateMouseButton(SDL_PRESSED, xevent.xbutton.button, 0, 0); } break; /* Mouse button release? */ case ButtonRelease: { posted = SDL_PrivateMouseButton(SDL_RELEASED, xevent.xbutton.button, 0, 0); } break; /* Key press or release? */ case KeyPress: case KeyRelease: { SDL_keysym keysym; XKeyEvent xkey; SDL_NAME(XDGAKeyEventToXKeyEvent)(&xevent.xkey, &xkey); posted = SDL_PrivateKeyboard((xevent.type == KeyPress), X11_TranslateKey(DGA_Display, &xkey, xkey.keycode, &keysym)); } break; } return(posted); }
/* We lost the keyboard, so post key up messages for all pressed keys */ void SDL_ResetKeyboard(void) { SDL_keysym keysym; SDLKey key; SDL_memset(&keysym, 0, (sizeof keysym)); for ( key=SDLK_FIRST; key<SDLK_LAST; ++key ) { if ( SDL_KeyState[key] == SDL_PRESSED ) { keysym.sym = key; SDL_PrivateKeyboard(SDL_RELEASED, &keysym); } } SDL_KeyRepeat.timestamp = 0; }
int handleKey(int sym, int mod, int scancode, uint16_t unicode, int event) { int sdlEvent; switch (event) { case TCO_KB_DOWN: sdlEvent = SDL_PRESSED; break; case TCO_KB_UP: sdlEvent = SDL_RELEASED; break; default: return TCO_UNHANDLED; } SDL_keysym keysym; keysym.sym = sym; keysym.mod = mod; keysym.scancode = scancode; keysym.unicode = unicode; SDL_PrivateKeyboard(sdlEvent, &keysym); return TCO_SUCCESS; }
// Go check a Flash event queue for events SDL should be aware of! void FLASH_PumpEvents(_THIS) { if (!FLASH_EMPTY_PARAMS) FLASH_EMPTY_PARAMS = AS3_Array(""); // Event Vars AS3_Val mouseEvent, mouseEvents, mousePosition, keyboardEvent, keyboardEvents; int buttonState, rawKeyboardEvent, scanCode, keyState; SDL_keysym keysym; mousePosition = AS3_CallS( "pumpMousePosition", FLASH_EVENT_MANAGER_OBJECT, FLASH_EMPTY_PARAMS ); mouseEvents = AS3_CallS( "pumpMouseEvents", FLASH_EVENT_MANAGER_OBJECT, FLASH_EMPTY_PARAMS ); keyboardEvents = AS3_CallS( "pumpKeyEvents", FLASH_EVENT_MANAGER_OBJECT, FLASH_EMPTY_PARAMS ); // Mouse Position if (mousePosition) { AS3_ObjectValue( mousePosition, "x:IntType, y:IntType", &FLASH_mouseX, &FLASH_mouseY ); SDL_PrivateMouseMotion( 0, 0, FLASH_mouseX, FLASH_mouseY ); } // Mouse Click Events while( AS3_IntValue(AS3_GetS(mouseEvents, "size")) > 0 ) { mouseEvent = AS3_CallS( "dequeue", mouseEvents, FLASH_EMPTY_PARAMS ); buttonState = AS3_IntValue( mouseEvent )? SDL_PRESSED: SDL_RELEASED; SDL_PrivateMouseButton(buttonState, SDL_BUTTON_LEFT, FLASH_mouseX, FLASH_mouseY); } // Keyboard Events while( AS3_IntValue(AS3_GetS(keyboardEvents, "size")) > 0 ) { keyboardEvent = AS3_CallS( "dequeue", keyboardEvents, FLASH_EMPTY_PARAMS ); rawKeyboardEvent = AS3_IntValue( keyboardEvent ); scanCode = rawKeyboardEvent & 0xFF; // Packed event format: 9th bit for press/release, lower 8 bits for scan code keyState = rawKeyboardEvent >> 8; SDL_PrivateKeyboard(keyState, TranslateKey(scanCode, &keysym)); } }
void CELL_DoModifierEvent (SDLKey aKey, uint32_t aState) { SDL_keysym sym; FillKeysym(&sym, aKey, 0); SDL_PrivateKeyboard(aState, &sym); }
LRESULT DIB_HandleMessage(_THIS, HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) { extern int posted; switch (msg) { case WM_SYSKEYDOWN: case WM_KEYDOWN: { SDL_keysym keysym; #ifdef SDL_VIDEO_DRIVER_GAPI if(this->hidden->gapiInfo) { if (wParam == 0x84 || wParam == 0x5B) return 0; wParam = rotateKey(wParam, this->hidden->gapiInfo->coordinateTransform); } #endif if ( lParam&REPEATED_KEYMASK ) { return(0); } switch (wParam) { case VK_CONTROL: if ( lParam&EXTENDED_KEYMASK ) wParam = VK_RCONTROL; else wParam = VK_LCONTROL; break; case VK_SHIFT: { Uint8 *state = SDL_GetKeyState(NULL); if (state[SDLK_LSHIFT] == SDL_RELEASED && (GetKeyState(VK_LSHIFT) & 0x8000)) { wParam = VK_LSHIFT; } else if (state[SDLK_RSHIFT] == SDL_RELEASED && (GetKeyState(VK_RSHIFT) & 0x8000)) { wParam = VK_RSHIFT; } else { int sc = HIWORD(lParam) & 0xFF; if (sc == 0x2A) wParam = VK_LSHIFT; else if (sc == 0x36) wParam = VK_RSHIFT; else wParam = VK_LSHIFT; } } break; case VK_MENU: if ( lParam&EXTENDED_KEYMASK ) wParam = VK_RMENU; else wParam = VK_LMENU; break; } #ifdef NO_GETKEYBOARDSTATE if ( SDL_TranslateUNICODE ) { MSG m; m.hwnd = hwnd; m.message = msg; m.wParam = wParam; m.lParam = lParam; m.time = 0; if ( TranslateMessage(&m) && PeekMessage(&m, hwnd, 0, WM_USER, PM_NOREMOVE) && (m.message == WM_CHAR) ) { GetMessage(&m, hwnd, 0, WM_USER); wParam = m.wParam; } } #endif posted = SDL_PrivateKeyboard(SDL_PRESSED, TranslateKey(wParam,HIWORD(lParam),&keysym,1)); } return(0); case WM_SYSKEYUP: case WM_KEYUP: { SDL_keysym keysym; #ifdef SDL_VIDEO_DRIVER_GAPI if(this->hidden->gapiInfo) { if (wParam == 0x84 || wParam == 0x5B) return 0; wParam = rotateKey(wParam, this->hidden->gapiInfo->coordinateTransform); } #endif switch (wParam) { case VK_CONTROL: if ( lParam&EXTENDED_KEYMASK ) wParam = VK_RCONTROL; else wParam = VK_LCONTROL; break; case VK_SHIFT: { Uint8 *state = SDL_GetKeyState(NULL); if (state[SDLK_LSHIFT] == SDL_PRESSED && !(GetKeyState(VK_LSHIFT) & 0x8000)) { wParam = VK_LSHIFT; } else if (state[SDLK_RSHIFT] == SDL_PRESSED && !(GetKeyState(VK_RSHIFT) & 0x8000)) { wParam = VK_RSHIFT; } else { int sc = HIWORD(lParam) & 0xFF; if (sc == 0x2A) wParam = VK_LSHIFT; else if (sc == 0x36) wParam = VK_RSHIFT; else wParam = VK_LSHIFT; } } break; case VK_MENU: if ( lParam&EXTENDED_KEYMASK ) wParam = VK_RMENU; else wParam = VK_LMENU; break; } if ( wParam == VK_SNAPSHOT && SDL_GetKeyState(NULL)[SDLK_PRINT] == SDL_RELEASED ) { posted = SDL_PrivateKeyboard(SDL_PRESSED, TranslateKey(wParam,HIWORD(lParam),&keysym,1)); } posted = SDL_PrivateKeyboard(SDL_RELEASED, TranslateKey(wParam,HIWORD(lParam),&keysym,0)); } return(0); #if defined(SC_SCREENSAVE) && defined(SC_MONITORPOWER) case WM_SYSCOMMAND: { const DWORD val = (DWORD) (wParam & 0xFFF0); if ((val == SC_SCREENSAVE) || (val == SC_MONITORPOWER)) { if (this->hidden->dibInfo && !allow_screensaver) { return(0); } } } #endif default: { if ( SDL_ProcessEvents[SDL_SYSWMEVENT] == SDL_ENABLE ) { SDL_SysWMmsg wmmsg; SDL_VERSION(&wmmsg.version); wmmsg.hwnd = hwnd; wmmsg.msg = msg; wmmsg.wParam = wParam; wmmsg.lParam = lParam; posted = SDL_PrivateSysWMEvent(&wmmsg); } else if (userWindowProc) { return CallWindowProc(userWindowProc, hwnd, msg, wParam, lParam); } } break; } return(DefWindowProc(hwnd, msg, wParam, lParam)); }
static int DGA_DispatchEvent(_THIS) { int posted; SDL_NAME(XDGAEvent) xevent; XNextEvent(DGA_Display, (XEvent *)&xevent); posted = 0; xevent.type -= DGA_event_base; switch (xevent.type) { /* Mouse motion? */ case MotionNotify: { if ( SDL_VideoSurface ) { posted = SDL_PrivateMouseMotion(0, 1, xevent.xmotion.dx, xevent.xmotion.dy); } } break; /* Mouse button press? */ case ButtonPress: { posted = SDL_PrivateMouseButton(SDL_PRESSED, xevent.xbutton.button, 0, 0); } break; /* Mouse button release? */ case ButtonRelease: { posted = SDL_PrivateMouseButton(SDL_RELEASED, xevent.xbutton.button, 0, 0); } break; /* Key press? */ case KeyPress: { SDL_keysym keysym; KeyCode keycode; XKeyEvent xkey; SDL_NAME(XDGAKeyEventToXKeyEvent)(&xevent.xkey, &xkey); keycode = xkey.keycode; #ifdef DEBUG_XEVENTS printf("KeyPress (X11 keycode = 0x%X)\n", xkey.keycode); #endif /* Get the translated SDL virtual keysym */ keysym.scancode = keycode; keysym.sym = X11_TranslateKeycode(DGA_Display, keycode); keysym.mod = KMOD_NONE; keysym.unicode = 0; /* Look up the translated value for the key event */ if ( SDL_TranslateUNICODE ) { static XComposeStatus state; char keybuf[32]; if ( XLookupString(&xkey, keybuf, sizeof(keybuf), NULL, &state) ) { /* * FIXME: XLookupString() may yield more than one * character, so we need a mechanism to allow for * this (perhaps null keypress events with a * unicode value) */ keysym.unicode = (Uint8)keybuf[0]; } } posted = SDL_PrivateKeyboard(SDL_PRESSED, &keysym); } break; /* Key release? */ case KeyRelease: { SDL_keysym keysym; KeyCode keycode; XKeyEvent xkey; SDL_NAME(XDGAKeyEventToXKeyEvent)(&xevent.xkey, &xkey); keycode = xkey.keycode; #ifdef DEBUG_XEVENTS printf("KeyRelease (X11 keycode = 0x%X)\n", xkey.keycode); #endif /* Get the translated SDL virtual keysym */ keysym.scancode = keycode; keysym.sym = X11_TranslateKeycode(DGA_Display, keycode); keysym.mod = KMOD_NONE; keysym.unicode = 0; posted = SDL_PrivateKeyboard(SDL_RELEASED, &keysym); } break; } return(posted); }
/* The main Win32 event handler */ LRESULT DIB_HandleMessage(_THIS, HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) { extern int posted; switch (msg) { case WM_SYSKEYDOWN: case WM_KEYDOWN: { SDL_keysym keysym; #ifdef _WIN32_WCE // Drop GAPI artefacts if (wParam == 0x84 || wParam == 0x5B) return 0; // Rotate key if necessary if (this->hidden->orientation != SDL_ORIENTATION_UP) wParam = rotateKey(wParam, this->hidden->orientation); #endif /* Ignore repeated keys */ if ( lParam&REPEATED_KEYMASK ) { return(0); } switch (wParam) { case VK_CONTROL: if ( lParam&EXTENDED_KEYMASK ) wParam = VK_RCONTROL; else wParam = VK_LCONTROL; break; case VK_SHIFT: /* EXTENDED trick doesn't work here */ { Uint8 *state = SDL_GetKeyState(NULL); if (state[SDLK_LSHIFT] == SDL_RELEASED && (GetKeyState(VK_LSHIFT) & 0x8000)) { wParam = VK_LSHIFT; } else if (state[SDLK_RSHIFT] == SDL_RELEASED && (GetKeyState(VK_RSHIFT) & 0x8000)) { wParam = VK_RSHIFT; } else { /* Win9x */ int sc = HIWORD(lParam) & 0xFF; if (sc == 0x2A) wParam = VK_LSHIFT; else if (sc == 0x36) wParam = VK_RSHIFT; else wParam = VK_LSHIFT; } } break; case VK_MENU: if ( lParam&EXTENDED_KEYMASK ) wParam = VK_RMENU; else wParam = VK_LMENU; break; } #ifdef NO_GETKEYBOARDSTATE /* this is the workaround for the missing ToAscii() and ToUnicode() in CE (not necessary at KEYUP!) */ if ( SDL_TranslateUNICODE ) { MSG m; m.hwnd = hwnd; m.message = msg; m.wParam = wParam; m.lParam = lParam; m.time = 0; if ( TranslateMessage(&m) && PeekMessage(&m, hwnd, 0, WM_USER, PM_NOREMOVE) && (m.message == WM_CHAR) ) { GetMessage(&m, hwnd, 0, WM_USER); wParam = m.wParam; } } #endif /* NO_GETKEYBOARDSTATE */ posted = SDL_PrivateKeyboard(SDL_PRESSED, TranslateKey(wParam,HIWORD(lParam),&keysym,1)); } return(0); case WM_SYSKEYUP: case WM_KEYUP: { SDL_keysym keysym; #ifdef _WIN32_WCE // Drop GAPI artifacts if (wParam == 0x84 || wParam == 0x5B) return 0; // Rotate key if necessary if (this->hidden->orientation != SDL_ORIENTATION_UP) wParam = rotateKey(wParam, this->hidden->orientation); #endif switch (wParam) { case VK_CONTROL: if ( lParam&EXTENDED_KEYMASK ) wParam = VK_RCONTROL; else wParam = VK_LCONTROL; break; case VK_SHIFT: /* EXTENDED trick doesn't work here */ { Uint8 *state = SDL_GetKeyState(NULL); if (state[SDLK_LSHIFT] == SDL_PRESSED && !(GetKeyState(VK_LSHIFT) & 0x8000)) { wParam = VK_LSHIFT; } else if (state[SDLK_RSHIFT] == SDL_PRESSED && !(GetKeyState(VK_RSHIFT) & 0x8000)) { wParam = VK_RSHIFT; } else { /* Win9x */ int sc = HIWORD(lParam) & 0xFF; if (sc == 0x2A) wParam = VK_LSHIFT; else if (sc == 0x36) wParam = VK_RSHIFT; else wParam = VK_LSHIFT; } } break; case VK_MENU: if ( lParam&EXTENDED_KEYMASK ) wParam = VK_RMENU; else wParam = VK_LMENU; break; } /* Windows only reports keyup for print screen */ if ( wParam == VK_SNAPSHOT && SDL_GetKeyState(NULL)[SDLK_PRINT] == SDL_RELEASED ) { posted = SDL_PrivateKeyboard(SDL_PRESSED, TranslateKey(wParam,HIWORD(lParam),&keysym,1)); } posted = SDL_PrivateKeyboard(SDL_RELEASED, TranslateKey(wParam,HIWORD(lParam),&keysym,0)); } return(0); #if defined(SC_SCREENSAVE) && defined(SC_MONITORPOWER) case WM_SYSCOMMAND: { if ((wParam&0xFFF0)==SC_SCREENSAVE || (wParam&0xFFF0)==SC_MONITORPOWER) return(0); } /* Fall through to default processing */ #endif /* SC_SCREENSAVE && SC_MONITORPOWER */ default: { /* Only post the event if we're watching for it */ if ( SDL_ProcessEvents[SDL_SYSWMEVENT] == SDL_ENABLE ) { SDL_SysWMmsg wmmsg; SDL_VERSION(&wmmsg.version); wmmsg.hwnd = hwnd; wmmsg.msg = msg; wmmsg.wParam = wParam; wmmsg.lParam = lParam; posted = SDL_PrivateSysWMEvent(&wmmsg); /* DJM: If the user isn't watching for private messages in her SDL event loop, then pass it along to any win32 specific window proc. */ } else if (userWindowProc) { return CallWindowProc(userWindowProc, hwnd, msg, wParam, lParam); } } break; } return(DefWindowProc(hwnd, msg, wParam, lParam)); }
int EPOC_HandleWsEvent(_THIS, const TWsEvent& aWsEvent) { int posted = 0; SDL_keysym keysym; switch (aWsEvent.Type()) { case EEventPointer: /* Mouse pointer events */ { const TPointerEvent* pointerEvent = aWsEvent.Pointer(); TPoint mousePos = pointerEvent->iPosition; //SDL_TRACE1("SDL: EPOC_HandleWsEvent, pointerEvent->iType=%d", pointerEvent->iType); //!! if (Private->EPOC_ShrinkedHeight) { mousePos.iY <<= 1; /* Scale y coordinate to shrinked screen height */ } posted += SDL_PrivateMouseMotion(0, 0, mousePos.iX, mousePos.iY); /* Absolute position on screen */ if (pointerEvent->iType==TPointerEvent::EButton1Down) { posted += SDL_PrivateMouseButton(SDL_PRESSED, SDL_BUTTON_LEFT, 0, 0); } else if (pointerEvent->iType==TPointerEvent::EButton1Up) { posted += SDL_PrivateMouseButton(SDL_RELEASED, SDL_BUTTON_LEFT, 0, 0); } else if (pointerEvent->iType==TPointerEvent::EButton2Down) { posted += SDL_PrivateMouseButton(SDL_PRESSED, SDL_BUTTON_RIGHT, 0, 0); } else if (pointerEvent->iType==TPointerEvent::EButton2Up) { posted += SDL_PrivateMouseButton(SDL_RELEASED, SDL_BUTTON_RIGHT, 0, 0); } //!!posted += SDL_PrivateKeyboard(SDL_PRESSED, TranslateKey(aWsEvent.Key()->iScanCode, &keysym)); break; } case EEventKeyDown: /* Key events */ { (void*)TranslateKey(aWsEvent.Key()->iScanCode, &keysym); /* Special handling */ switch((int)keysym.sym) { case SDLK_CAPSLOCK: if (!isCursorVisible) { /* Enable virtual cursor */ HAL::Set(HAL::EMouseState, HAL::EMouseState_Visible); } else { /* Disable virtual cursor */ HAL::Set(HAL::EMouseState, HAL::EMouseState_Invisible); } isCursorVisible = !isCursorVisible; break; } posted += SDL_PrivateKeyboard(SDL_PRESSED, &keysym); break; } case EEventKeyUp: /* Key events */ { posted += SDL_PrivateKeyboard(SDL_RELEASED, TranslateKey(aWsEvent.Key()->iScanCode, &keysym)); break; } case EEventFocusGained: /* SDL window got focus */ { //Private->EPOC_IsWindowFocused = ETrue; /* Draw window background and screen buffer */ RedrawWindowL(_this); break; } case EEventFocusLost: /* SDL window lost focus */ { //Private->EPOC_IsWindowFocused = EFalse; // Wait and eat events until focus is gained again /* while (ETrue) { Private->EPOC_WsSession.EventReady(&Private->EPOC_WsEventStatus); User::WaitForRequest(Private->EPOC_WsEventStatus); Private->EPOC_WsSession.GetEvent(Private->EPOC_WsEvent); TInt eventType = Private->EPOC_WsEvent.Type(); Private->EPOC_WsEventStatus = KRequestPending; //Private->EPOC_WsSession.EventReady(&Private->EPOC_WsEventStatus); if (eventType == EEventFocusGained) { RedrawWindowL(_this); break; } } */ break; } case EEventModifiersChanged: { TModifiersChangedEvent* modEvent = aWsEvent.ModifiersChanged(); TUint modstate = KMOD_NONE; if (modEvent->iModifiers == EModifierLeftShift) modstate |= KMOD_LSHIFT; if (modEvent->iModifiers == EModifierRightShift) modstate |= KMOD_RSHIFT; if (modEvent->iModifiers == EModifierLeftCtrl) modstate |= KMOD_LCTRL; if (modEvent->iModifiers == EModifierRightCtrl) modstate |= KMOD_RCTRL; if (modEvent->iModifiers == EModifierLeftAlt) modstate |= KMOD_LALT; if (modEvent->iModifiers == EModifierRightAlt) modstate |= KMOD_RALT; if (modEvent->iModifiers == EModifierLeftFunc) modstate |= KMOD_LMETA; if (modEvent->iModifiers == EModifierRightFunc) modstate |= KMOD_RMETA; if (modEvent->iModifiers == EModifierCapsLock) modstate |= KMOD_CAPS; SDL_SetModState(STATIC_CAST(SDLMod,(modstate | KMOD_LSHIFT))); break; } default: break; } return posted; }
void PumpEvents() { #if 0 WPAD_ScanPads(); /* if (!keyboard_initialized) { wii_keyboard_init(); keyboard_initialized = 1; } */ WPADData *wd = WPAD_Data(0); #endif stat = KEYBOARD_getEvent(&ke); #if 0 mstat = MOUSE_getEvent(&me); int x, y; SDL_GetMouseState(&x, &y); if(wd->ir.valid) { //int x = (wd->ir.dot[0].rx*640)/1024; //int y = (wd->ir.dot[0].ry*480)/768; x = wd->ir.x; y = wd->ir.y; if(lastX!= x || lastY != y) { posted += SDL_PrivateMouseMotion(0, 0, x, y); lastX = x; lastY = y; } } Uint8 stateA = SDL_RELEASED; Uint8 stateB = SDL_RELEASED; if(wd->btns_h & WPAD_BUTTON_A) { stateA = SDL_PRESSED; } if(wd->btns_h & WPAD_BUTTON_B) { stateB = SDL_PRESSED; } if(stateA != lastButtonStateA) { lastButtonStateA = stateA; posted += SDL_PrivateMouseButton(stateA, SDL_BUTTON_LEFT, x, y); } if(stateB != lastButtonStateB) { lastButtonStateB = stateB; posted += SDL_PrivateMouseButton(stateB, SDL_BUTTON_RIGHT, x, y); } Uint8 stateHome = SDL_RELEASED; if(wd->btns_h & WPAD_BUTTON_HOME) { stateHome = SDL_PRESSED; } if(stateHome != lastButtonStateHome) { lastButtonStateHome = stateHome; /* SDL_keysym keysym; SDL_memset(&keysym, 0, (sizeof keysym)); keysym.sym = SDLK_ESCAPE; SDL_PrivateKeyboard(stateHome, &keysym);*/ if (stateHome == SDL_RELEASED) { /* SDL_Event event; event.type = SDL_QUIT; SDL_PushEvent(&event); */ } } #endif if (stat && (ke.type==KEYBOARD_RELEASED || ke.type==KEYBOARD_PRESSED) ) { SDL_keysym keysym; memset(&keysym, 0, sizeof(keysym)); Uint8 keystate = (ke.type==KEYBOARD_PRESSED)?SDL_PRESSED:SDL_RELEASED; keysym.sym = ke.scancode; SDL_SetModState(to_SDL_Modifiers(ke.modifiers)); posted += SDL_PrivateKeyboard(keystate, &keysym); } #if 0 if (mstat) { int x, y; posted +=SDL_PrivateMouseMotion(me.button, 1, me.rx, me.ry); u8 button = me.button; if ( button & 0x1 ) { if ( !(SDL_GetMouseState(NULL, NULL) & SDL_BUTTON(1)) ) { posted +=SDL_PrivateMouseButton(SDL_PRESSED, 1, 0, 0); } } else { if ( (SDL_GetMouseState(NULL, NULL) & SDL_BUTTON(1)) ) { posted +=SDL_PrivateMouseButton(SDL_RELEASED, 1, 0, 0); } } if ( button & 0x2 ) { if ( !(SDL_GetMouseState(NULL, NULL) & SDL_BUTTON(3)) ) { posted +=SDL_PrivateMouseButton(SDL_PRESSED, 3, 0, 0); } } else { if ( (SDL_GetMouseState(NULL, NULL) & SDL_BUTTON(3)) ) { posted +=SDL_PrivateMouseButton(SDL_RELEASED, 3, 0, 0); } } } #endif }
int EPOC_HandleWsEvent(_THIS, const TWsEvent& aWsEvent) { int posted = 0; SDL_keysym keysym; // SDL_TRACE1("hws %d", aWsEvent.Type()); switch (aWsEvent.Type()) { case EEventPointer: /* Mouse pointer events */ { const TPointerCursorMode mode = Private->EPOC_WsSession.PointerCursorMode(); if(mode == EPointerCursorNone) { return 0; //TODO: Find out why events are get despite of cursor should be off } const TPointerEvent* pointerEvent = aWsEvent.Pointer(); TPoint mousePos = pointerEvent->iPosition; /*!! TODO Pointer do not yet work properly //SDL_TRACE1("SDL: EPOC_HandleWsEvent, pointerEvent->iType=%d", pointerEvent->iType); //!! if (Private->EPOC_ShrinkedHeight) { mousePos.iY <<= 1; // Scale y coordinate to shrinked screen height } if (Private->EPOC_ShrinkedWidth) { mousePos.iX <<= 1; // Scale x coordinate to shrinked screen width } */ posted += SDL_PrivateMouseMotion(0, 0, mousePos.iX, mousePos.iY); /* Absolute position on screen */ switch (pointerEvent->iType) { case TPointerEvent::EButton1Down: posted += SDL_PrivateMouseButton(SDL_PRESSED, SDL_BUTTON_LEFT, 0, 0); break; case TPointerEvent::EButton1Up: posted += SDL_PrivateMouseButton(SDL_RELEASED, SDL_BUTTON_LEFT, 0, 0); break; case TPointerEvent::EButton2Down: posted += SDL_PrivateMouseButton(SDL_PRESSED, SDL_BUTTON_RIGHT, 0, 0); break; case TPointerEvent::EButton2Up: posted += SDL_PrivateMouseButton(SDL_RELEASED, SDL_BUTTON_RIGHT, 0, 0); break; case TPointerEvent::EButton3Down: posted += SDL_PrivateMouseButton(SDL_PRESSED, SDL_BUTTON_MIDDLE, 0, 0); break; case TPointerEvent::EButton3Up: posted += SDL_PrivateMouseButton(SDL_RELEASED, SDL_BUTTON_MIDDLE, 0, 0); break; } // switch break; } case EEventKeyDown: /* Key events */ { #ifdef SYMBIAN_CRYSTAL // special case: 9300/9500 rocker down, simulate left mouse button if (aWsEvent.Key()->iScanCode == EStdKeyDeviceA) { const TPointerCursorMode mode = Private->EPOC_WsSession.PointerCursorMode(); if(mode != EPointerCursorNone) posted += SDL_PrivateMouseButton(SDL_PRESSED, SDL_BUTTON_LEFT, 0, 0); } #endif (void*)TranslateKey(_this, aWsEvent.Key()->iScanCode, &keysym); #ifndef DISABLE_JOYSTICK /* Special handling */ switch((int)keysym.sym) { case SDLK_CAPSLOCK: if (!isCursorVisible) { /* Enable virtual cursor */ HAL::Set(HAL::EMouseState, HAL::EMouseState_Visible); } else { /* Disable virtual cursor */ HAL::Set(HAL::EMouseState, HAL::EMouseState_Invisible); } isCursorVisible = !isCursorVisible; break; } #endif posted += SDL_PrivateKeyboard(SDL_PRESSED, &keysym); break; } case EEventKeyUp: /* Key events */ { #ifdef SYMBIAN_CRYSTAL // special case: 9300/9500 rocker up, simulate left mouse button if (aWsEvent.Key()->iScanCode == EStdKeyDeviceA) { posted += SDL_PrivateMouseButton(SDL_RELEASED, SDL_BUTTON_LEFT, 0, 0); } #endif posted += SDL_PrivateKeyboard(SDL_RELEASED, TranslateKey(_this, aWsEvent.Key()->iScanCode, &keysym)); break; } case EEventFocusGained: /* SDL window got focus */ { Private->EPOC_IsWindowFocused = ETrue; posted += SDL_PrivateAppActive(1, SDL_APPINPUTFOCUS|SDL_APPMOUSEFOCUS); /* Draw window background and screen buffer */ DisableKeyBlocking(_this); //Markus: guess why:-) RedrawWindowL(_this); break; } case EEventFocusLost: /* SDL window lost focus */ { /* CFbsBitmap* bmp = new (ELeave) CFbsBitmap(); bmp->Create(Private->EPOC_ScreenSize, Private->EPOC_DisplayMode); Private->EPOC_WsScreen->CopyScreenToBitmap(bmp); Private->EPOC_WindowGc->Activate(Private->EPOC_WsWindow); Private->EPOC_WsWindow.BeginRedraw(TRect(Private->EPOC_WsWindow.Size())); Private->EPOC_WindowGc->BitBlt(TPoint(0, 0), bmp); Private->EPOC_WsWindow.EndRedraw(); Private->EPOC_WindowGc->Deactivate(); bmp->Save(_L("C:\\scr.mbm")); delete bmp; */ Private->EPOC_IsWindowFocused = EFalse; posted += SDL_PrivateAppActive(0, SDL_APPINPUTFOCUS|SDL_APPMOUSEFOCUS); RWsSession s; s.Connect(); RWindowGroup g(s); g.Construct(TUint32(&g), EFalse); g.EnableReceiptOfFocus(EFalse); RWindow w(s); w.Construct(g, TUint32(&w)); w.SetExtent(TPoint(0, 0), Private->EPOC_WsWindow.Size()); w.SetOrdinalPosition(0); w.Activate(); w.Close(); g.Close(); s.Close(); /* Private->EPOC_WsSession.SetWindowGroupOrdinalPosition(Private->EPOC_WsWindowGroupID, -1); SDL_Delay(500); TInt focus = -1; while(focus < 0) { const TInt curr = Private->EPOC_WsSession.GetFocusWindowGroup(); if(curr != Private->EPOC_WsWindowGroupID) focus = curr; else SDL_Delay(500); } if(1 < Private->EPOC_WsSession.GetWindowGroupOrdinalPriority(Private->EPOC_WsWindowGroupID)) { Private->EPOC_WsSession.SetWindowGroupOrdinalPosition(focus, -1); SDL_Delay(500); Private->EPOC_WsSession.SetWindowGroupOrdinalPosition(focus, 0); } */ /*//and the request redraw TRawEvent redrawEvent; redrawEvent.Set(TRawEvent::ERedraw); Private->EPOC_WsSession.SimulateRawEvent(redrawEvent); Private->EPOC_WsSession.Flush();*/ #if 0 //!! Not used // Wait and eat events until focus is gained again while (ETrue) { Private->EPOC_WsSession.EventReady(&Private->EPOC_WsEventStatus); User::WaitForRequest(Private->EPOC_WsEventStatus); Private->EPOC_WsSession.GetEvent(Private->EPOC_WsEvent); TInt eventType = Private->EPOC_WsEvent.Type(); Private->EPOC_WsEventStatus = KRequestPending; //Private->EPOC_WsSession.EventReady(&Private->EPOC_WsEventStatus); if (eventType == EEventFocusGained) { RedrawWindowL(_this); break; } } #endif break; } case EEventModifiersChanged: { TModifiersChangedEvent* modEvent = aWsEvent.ModifiersChanged(); TUint modstate = KMOD_NONE; if (modEvent->iModifiers == EModifierLeftShift) modstate |= KMOD_LSHIFT; if (modEvent->iModifiers == EModifierRightShift) modstate |= KMOD_RSHIFT; if (modEvent->iModifiers == EModifierLeftCtrl) modstate |= KMOD_LCTRL; if (modEvent->iModifiers == EModifierRightCtrl) modstate |= KMOD_RCTRL; if (modEvent->iModifiers == EModifierLeftAlt) modstate |= KMOD_LALT; if (modEvent->iModifiers == EModifierRightAlt) modstate |= KMOD_RALT; if (modEvent->iModifiers == EModifierLeftFunc) modstate |= KMOD_LMETA; if (modEvent->iModifiers == EModifierRightFunc) modstate |= KMOD_RMETA; if (modEvent->iModifiers == EModifierCapsLock) modstate |= KMOD_CAPS; SDL_SetModState(STATIC_CAST(SDLMod,(modstate | KMOD_LSHIFT))); break; } default: break; } return posted; }
void AA_PumpEvents(_THIS) { int posted = 0; int mouse_button, mouse_x, mouse_y; int evt; SDL_keysym keysym; static int prev_button = -1, prev_x = -1, prev_y = -1; if( ! this->screen ) /* Wait till we got the screen initialized */ return; do { posted = 0; /* Gather events */ /* Get mouse status */ SDL_mutexP(AA_mutex); aa_getmouse (AA_context, &mouse_x, &mouse_y, &mouse_button); SDL_mutexV(AA_mutex); mouse_x = mouse_x * this->screen->w / aa_scrwidth (AA_context); mouse_y = mouse_y * this->screen->h / aa_scrheight (AA_context); /* Compare against previous state and generate events */ if( prev_button != mouse_button ) { if( mouse_button & AA_BUTTON1 ) { if ( ! (prev_button & AA_BUTTON1) ) { posted += SDL_PrivateMouseButton(SDL_PRESSED, 1, 0, 0); } } else { if ( prev_button & AA_BUTTON1 ) { posted += SDL_PrivateMouseButton(SDL_RELEASED, 1, 0, 0); } } if( mouse_button & AA_BUTTON2 ) { if ( ! (prev_button & AA_BUTTON2) ) { posted += SDL_PrivateMouseButton(SDL_PRESSED, 2, 0, 0); } } else { if ( prev_button & AA_BUTTON2 ) { posted += SDL_PrivateMouseButton(SDL_RELEASED, 2, 0, 0); } } if( mouse_button & AA_BUTTON3 ) { if ( ! (prev_button & AA_BUTTON3) ) { posted += SDL_PrivateMouseButton(SDL_PRESSED, 3, 0, 0); } } else { if ( prev_button & AA_BUTTON3 ) { posted += SDL_PrivateMouseButton(SDL_RELEASED, 3, 0, 0); } } } if ( prev_x != mouse_x || prev_y != mouse_y ) { posted += SDL_PrivateMouseMotion(0, 0, mouse_x, mouse_y); } prev_button = mouse_button; prev_x = mouse_x; prev_y = mouse_y; /* Get keyboard event */ SDL_mutexP(AA_mutex); evt = aa_getevent(AA_context, 0); SDL_mutexV(AA_mutex); if ( (evt > AA_NONE) && (evt < AA_RELEASE) && (evt != AA_MOUSE) && (evt != AA_RESIZE) ) { /* Key pressed */ /* printf("Key pressed: %d (%c)\n", evt, evt); */ posted += SDL_PrivateKeyboard(SDL_PRESSED, TranslateKey(evt, &keysym)); } else if ( evt >= AA_RELEASE ) { /* Key released */ evt &= ~AA_RELEASE; /* printf("Key released: %d (%c)\n", evt, evt); */ posted += SDL_PrivateKeyboard(SDL_RELEASED, TranslateKey(evt, &keysym)); } } while ( posted ); }
void NX_PumpEvents (_THIS) { GR_EVENT event ; static GR_BUTTON last_button_down = 0 ; GrCheckNextEvent (& event) ; while (event.type != GR_EVENT_TYPE_NONE) { // dispatch event switch (event.type) { case GR_EVENT_TYPE_MOUSE_ENTER : { Dprintf ("mouse enter\n") ; SDL_PrivateAppActive (1, SDL_APPMOUSEFOCUS) ; break ; } case GR_EVENT_TYPE_MOUSE_EXIT : { Dprintf ("mouse exit\n") ; SDL_PrivateAppActive (0, SDL_APPMOUSEFOCUS) ; break ; } case GR_EVENT_TYPE_FOCUS_IN : { Dprintf ("focus in\n") ; SDL_PrivateAppActive (1, SDL_APPINPUTFOCUS) ; break ; } case GR_EVENT_TYPE_FOCUS_OUT : { Dprintf ("focus out\n") ; SDL_PrivateAppActive (0, SDL_APPINPUTFOCUS) ; break ; } case GR_EVENT_TYPE_MOUSE_MOTION : { Dprintf ("mouse motion\n") ; if (SDL_VideoSurface) { if (currently_fullscreen) { if (check_boundary (this, event.button.x, event.button.y)) { SDL_PrivateMouseMotion (0, 0, event.button.x - OffsetX, event.button.y - OffsetY) ; } } else { SDL_PrivateMouseMotion (0, 0, event.button.x, event.button.y) ; } } break ; } case GR_EVENT_TYPE_BUTTON_DOWN : { int button = event.button.buttons ; Dprintf ("button down\n") ; switch (button) { case MWBUTTON_L : button = 1 ; break ; case MWBUTTON_M : button = 2 ; break ; case MWBUTTON_R : button = 3 ; break ; default : button = 0 ; } last_button_down = button ; if (currently_fullscreen) { if (check_boundary (this, event.button.x, event.button.y)) { SDL_PrivateMouseButton (SDL_PRESSED, button, event.button.x - OffsetX, event.button.y - OffsetY) ; } } else { SDL_PrivateMouseButton (SDL_PRESSED, button, event.button.x, event.button.y) ; } break ; } // do not konw which button is released case GR_EVENT_TYPE_BUTTON_UP : { Dprintf ("button up\n") ; if (currently_fullscreen) { if (check_boundary (this, event.button.x, event.button.y)) { SDL_PrivateMouseButton (SDL_RELEASED, last_button_down, event.button.x - OffsetX, event.button.y - OffsetY) ; } } else { SDL_PrivateMouseButton (SDL_RELEASED, last_button_down, event.button.x, event.button.y) ; } last_button_down = 0 ; break ; } case GR_EVENT_TYPE_KEY_DOWN : { SDL_keysym keysym ; Dprintf ("key down\n") ; SDL_PrivateKeyboard (SDL_PRESSED, NX_TranslateKey (& event.keystroke, & keysym)) ; break ; } case GR_EVENT_TYPE_KEY_UP : { SDL_keysym keysym ; Dprintf ("key up\n") ; SDL_PrivateKeyboard (SDL_RELEASED, NX_TranslateKey (& event.keystroke, & keysym)) ; break ; } case GR_EVENT_TYPE_CLOSE_REQ : { Dprintf ("close require\n") ; SDL_PrivateQuit () ; break ; } case GR_EVENT_TYPE_EXPOSURE : { Dprintf ("event_type_exposure\n") ; if (SDL_VideoSurface) { NX_RefreshDisplay (this) ;//, & event.exposure) ; } break ; } case GR_EVENT_TYPE_UPDATE : { switch (event.update.utype) { case GR_UPDATE_MAP : { Dprintf ("GR_UPDATE_MAP\n") ; // If we're not active, make ourselves active if (!(SDL_GetAppState () & SDL_APPACTIVE)) { // Send an internal activate event SDL_PrivateAppActive (1, SDL_APPACTIVE) ; } if (SDL_VideoSurface) { NX_RefreshDisplay (this) ; } break ; } case GR_UPDATE_UNMAP : case GR_UPDATE_UNMAPTEMP : { Dprintf ("GR_UPDATE_UNMAP or GR_UPDATE_UNMAPTEMP\n") ; // If we're active, make ourselves inactive if (SDL_GetAppState () & SDL_APPACTIVE) { // Send an internal deactivate event SDL_PrivateAppActive (0, SDL_APPACTIVE | SDL_APPINPUTFOCUS) ; } break ; } case GR_UPDATE_SIZE : { Dprintf ("GR_UPDATE_SIZE\n") ; SDL_PrivateResize (event.update.width, event.update.height) ; break ; } case GR_UPDATE_MOVE : case GR_UPDATE_REPARENT : { Dprintf ("GR_UPDATE_MOVE or GR_UPDATE_REPARENT\n") ; #ifdef ENABLE_NANOX_DIRECT_FB if (Clientfb) { /* Get current window position and fb pointer*/ if (currently_fullscreen) GrGetWindowFBInfo(FSwindow, &fbinfo); else GrGetWindowFBInfo(SDL_Window, &fbinfo); } #endif break ; } default : Dprintf ("unknown GR_EVENT_TYPE_UPDATE\n") ; break ; } break ; } default : { Dprintf ("pump event default\n") ; } } GrCheckNextEvent (& event) ; } }
/* The main Win32 event handler */ LONG DIB_HandleMessage(_THIS, HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) { extern int posted; switch (msg) { case WM_SYSKEYDOWN: case WM_KEYDOWN: { SDL_keysym keysym; /* Ignore repeated keys */ if ( lParam&REPEATED_KEYMASK ) { return(0); } switch (wParam) { case VK_CONTROL: if ( lParam&EXTENDED_KEYMASK ) wParam = VK_RCONTROL; else wParam = VK_LCONTROL; break; case VK_SHIFT: /* EXTENDED trick doesn't work here */ if (!prev_shiftstates[0] && (GetKeyState(VK_LSHIFT) & 0x8000)) { wParam = VK_LSHIFT; prev_shiftstates[0] = TRUE; } else if (!prev_shiftstates[1] && (GetKeyState(VK_RSHIFT) & 0x8000)) { wParam = VK_RSHIFT; prev_shiftstates[1] = TRUE; } else { /* Huh? */ } break; case VK_MENU: if ( lParam&EXTENDED_KEYMASK ) wParam = VK_RMENU; else wParam = VK_LMENU; break; } #ifdef NO_GETKEYBOARDSTATE /* this is the workaround for the missing ToAscii() and ToUnicode() in CE (not necessary at KEYUP!) */ if ( SDL_TranslateUNICODE ) { MSG m; m.hwnd = hwnd; m.message = msg; m.wParam = wParam; m.lParam = lParam; m.time = 0; if ( TranslateMessage(&m) && PeekMessage(&m, hwnd, 0, WM_USER, PM_NOREMOVE) && (m.message == WM_CHAR) ) { GetMessage(&m, hwnd, 0, WM_USER); wParam = m.wParam; } else { wParam = 0; } } else { wParam = 0; } #endif /* NO_GETKEYBOARDSTATE */ posted = SDL_PrivateKeyboard(SDL_PRESSED, TranslateKey(wParam,HIWORD(lParam),&keysym,1)); } return(0); case WM_SYSKEYUP: case WM_KEYUP: { SDL_keysym keysym; switch (wParam) { case VK_CONTROL: if ( lParam&EXTENDED_KEYMASK ) wParam = VK_RCONTROL; else wParam = VK_LCONTROL; break; case VK_SHIFT: /* EXTENDED trick doesn't work here */ if (prev_shiftstates[0] && !(GetKeyState(VK_LSHIFT) & 0x8000)) { wParam = VK_LSHIFT; prev_shiftstates[0] = FALSE; } else if (prev_shiftstates[1] && !(GetKeyState(VK_RSHIFT) & 0x8000)) { wParam = VK_RSHIFT; prev_shiftstates[1] = FALSE; } else { /* Huh? */ } break; case VK_MENU: if ( lParam&EXTENDED_KEYMASK ) wParam = VK_RMENU; else wParam = VK_LMENU; break; } posted = SDL_PrivateKeyboard(SDL_RELEASED, TranslateKey(wParam,HIWORD(lParam),&keysym,0)); } return(0); #if defined(SC_SCREENSAVE) && defined(SC_MONITORPOWER) case WM_SYSCOMMAND: { if ((wParam&0xFFF0)==SC_SCREENSAVE || (wParam&0xFFF0)==SC_MONITORPOWER) return(0); } /* Fall through to default processing */ #endif /* SC_SCREENSAVE && SC_MONITORPOWER */ default: { /* Only post the event if we're watching for it */ if ( SDL_ProcessEvents[SDL_SYSWMEVENT] == SDL_ENABLE ) { SDL_SysWMmsg wmmsg; SDL_VERSION(&wmmsg.version); wmmsg.hwnd = hwnd; wmmsg.msg = msg; wmmsg.wParam = wParam; wmmsg.lParam = lParam; posted = SDL_PrivateSysWMEvent(&wmmsg); /* DJM: If the user isn't watching for private messages in her SDL event loop, then pass it along to any win32 specific window proc. */ } else if (userWindowProc) { return CallWindowProc(userWindowProc, hwnd, msg, wParam, lParam); } } break; } return(DefWindowProc(hwnd, msg, wParam, lParam)); }