Example #1
0
int GewiEngine::EventFilter(SDL_Event *event)
{
    static char noChar = '\0';
    GewiEngine *gewi = GewiEngine::GetInstance();
    char ch;

    //called inside ZEngine::CheckEvents
    switch(event->type)
    {
        case SDL_MOUSEBUTTONDOWN:
            if(event->button.button == SDL_BUTTON_LEFT)
                gewi->SendMessage(event,GE_LDOWN,event->button.x,event->button.y,noChar);
            if(event->button.button == SDL_BUTTON_RIGHT)
                gewi->SendMessage(event,GE_RDOWN,event->button.x,event->button.y,noChar);
            break;
        case SDL_MOUSEBUTTONUP:
            if(event->button.button == SDL_BUTTON_LEFT)
                gewi->SendMessage(event,GE_LUP,event->button.x,event->button.y,noChar);
            if(event->button.button == SDL_BUTTON_RIGHT)
                gewi->SendMessage(event,GE_RUP,event->button.x,event->button.y,noChar);
            break;
        case SDL_KEYDOWN:
            ch = TranslateKey(event->key.keysym);
            gewi->SendMessage(event,GE_KDOWN,0,0,ch);
            break;
        case SDL_KEYUP:
            ch = TranslateKey(event->key.keysym);
            gewi->SendMessage(event,GE_KUP,0,0,ch);
            break;
        default:
            break;
    }
    return 1;   //pass the event on, allowing ZEngine to do what it needs
}
void ProcessKey(SDL_Event& e)
{
    switch(e.type)
    {
    case SDL_KEYDOWN:
    {
        dword flags = KF_DOWN|OpJoyKeyFlags();
        if(l_shift)
            flags |= KF_SHIFT;
        if(r_shift)
            flags |= KF_ALT;
        byte key = TranslateKey(e.key.keysym.sym, flags);
        Handler()->OnKey(key, flags);
    }
    break;
    case SDL_KEYUP:
    {
        dword flags = 0;
        if(l_shift)
            flags |= KF_SHIFT;
        if(r_shift)
            flags |= KF_ALT;
        byte key = TranslateKey(e.key.keysym.sym, flags);
        Handler()->OnKey(key, OpJoyKeyFlags());
    }
    break;
    default:
        break;
    }
}
		void SDLRunner::ProcessEvent(SDL_Event &event, client::Client *client) {
			switch (event.type) {
				case SDL_QUIT:
					client->Closing();
					//running = false;
					break;
				case SDL_MOUSEBUTTONDOWN:
					client->KeyEvent(TranslateButton(event.button.button), true);
					break;
				case SDL_MOUSEBUTTONUP:
					client->KeyEvent(TranslateButton(event.button.button), false);
					break;
				case SDL_MOUSEMOTION:
					if( mActive ) {
						client->MouseEvent(event.motion.xrel, event.motion.yrel);
					}
					break;
				case SDL_KEYDOWN:
					if(event.key.keysym.unicode){
						int uni = event.key.keysym.unicode;
						if(uni > 0 && uni < 128 &&
						   uni != 8 &&	// no backspace
						   uni != 13 && uni != 10 &&
						   uni != 127){ // no enter
							std::string s;
							s += (char)uni;
							client->CharEvent(s);
						}
					}
					client->KeyEvent(TranslateKey(event.key.keysym), true);
					break;
				case SDL_KEYUP:
					client->KeyEvent(TranslateKey(event.key.keysym), false);
					break;
				case SDL_ACTIVEEVENT:
					if( event.active.state & (SDL_APPACTIVE|SDL_APPINPUTFOCUS) ) {		//any of the 2 is good
						if(event.active.gain){
							SDL_ShowCursor(0);
							SDL_WM_GrabInput( SDL_GRAB_ON );
							mActive = true;
						}else{
							SDL_WM_GrabInput( SDL_GRAB_OFF );
							mActive = false;
							SDL_ShowCursor(1);
						}
					}
					break;
				default:
					break;
			}
		}
Example #4
0
    // ~IInputEventListener
    virtual bool OnInputEvent( const SInputEvent &event )
    {
        if (true == m_bActive)
        {
#if defined(ORBIS)	// FIXME: Using PS3 inputs for ORBIS
            int nThisKey = event.keyId;
            int nKey = -1;
            int nInput = GetPortInt(&m_actInfo, EIP_Key);
            int tableSize = sizeof(PS3KeyTable)/sizeof(PS3KeyTable[0]);
            if ( nInput>=0 && nInput<tableSize )
                nKey = PS3KeyTable[nInput];
#else
            // Translate key, check value
            const int nThisKey = TranslateKey(event.keyId);
            const int nKey = GetPortInt(&m_actInfo, EIP_Key);
#endif
            if (nKey == nThisKey)
            {
                // Return based on state
                if (eIS_Pressed == event.state)
                    ActivateOutput(&m_actInfo, EOP_Pressed, true);
                else if (eIS_Released == event.state)
                    ActivateOutput(&m_actInfo, EOP_Released, true);
            }
        }

        // Let other listeners handle it
        return false;
    }
Example #5
0
// Translates a key and sends it
void SendKey(TKeyCode aCode, TUint aModifiers) {

    char buf[16];

    // Reset scrollback
    seen_key_event = 1;

    // Interrupt paste
    term_nopaste();

    // Try to translate as a control character
    int xbytes = TranslateKey(aCode, aModifiers, buf);
    assert(xbytes < 16);
    if ( xbytes > 0 ) {
        // Send control key codes as is
        ldisc_send(buf, xbytes, 1);
        
    } else if ( xbytes == -1 ) {
        // Not translated, probably a normal letter
        if ( aCode < ENonCharacterKeyBase ) {
            wchar_t wc = (wchar_t) aCode;
            luni_send(&wc, 1, 1);
        }
    }
}
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));
		}
	}
}
Example #7
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));
	}
}
Example #8
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);
}
Example #9
0
	void keydown( int key )
	{
		agk::KeyDown( TranslateKey(key) );
		int ch = AsciiKey(key);
		if ( ch != 0 )
		{
			agk::CharDown( ch );
		}
	}
Example #10
0
void I_HandleKeyboardEvent(SDL_Event *sdlevent)
{
    // XXX: passing pointers to event for access after this function
    // has terminated is undefined behaviour
    event_t event;

    switch (sdlevent->type)
    {
        case SDL_KEYDOWN:
            event.type = ev_keydown;
            event.data1 = TranslateKey(&sdlevent->key.keysym);
            event.data2 = GetLocalizedKey(&sdlevent->key.keysym);
            event.data3 = GetTypedChar(&sdlevent->key.keysym);

            if (event.data1 != 0)
            {
                D_PostEvent(&event);
            }
            break;

        case SDL_KEYUP:
            event.type = ev_keyup;
            event.data1 = TranslateKey(&sdlevent->key.keysym);

            // data2/data3 are initialized to zero for ev_keyup.
            // For ev_keydown it's the shifted Unicode character
            // that was typed, but if something wants to detect
            // key releases it should do so based on data1
            // (key ID), not the printable char.

            event.data2 = 0;
            event.data3 = 0;

            if (event.data1 != 0)
            {
                D_PostEvent(&event);
            }
            break;

        default:
            break;
    }
}
	virtual void OnKeyup(wxKeyEvent& event)
	{
		int key = event.GetKeyCode();
//		printf("ku:%c\n", key);
		dword flags = 0;
		if(event.AltDown())		flags |= KF_ALT;
		if(event.ShiftDown())	flags |= KF_SHIFT;
		TranslateKey(key, flags);
		Handler()->OnKey(key, OpJoyKeyFlags());
	}
Example #12
0
/*
 * TextInputKey:  User pressed a key on text input box.
 *   Return True iff key should NOT be passed on to Windows for default processing.
 */
Bool TextInputKey(HWND hwnd, UINT key, Bool fDown, int cRepeat, UINT flags)
{
   Bool held_down = (flags & 0x4000) ? True : False;  /* Is key being held down? */
   char string[MAXSAY + 1];
   int action;
   BOOL bValid;
   void *action_data;

   if (key == VK_RETURN && !held_down)
   {
      UserDidSomething();

      ComboBox_GetText(hwndInput, string, MAXSAY + 1);
      if (string[0] == 0)
	 return True;

      SetFocus(hMain);
      bValid = ParseGotText(string);

      // Add it to the history.
      if (*string && bValid)
      {
	 BOOL bAdd = TRUE;
	 int iCount;
	 char achHead[MAXSAY+1];
	 iCount = ComboBox_GetCount(hwndInput);
	 if (iCount > 0)
	 {
	    ComboBox_GetLBText(hwndInput, 0, achHead);
	    if (0 == strcmp(achHead, string))
	       bAdd = FALSE;
	 }
	 if (bAdd)
	 {
	    ComboBox_InsertString(hwndInput, 0, string);
	    if (iCount > EDITBOX_HISTORY)
	       ComboBox_DeleteString(hwndInput, iCount);
	 }
      }

      return True;
   }
   
   // Check for special keys
   action = TranslateKey(key, textin_key_table, &action_data);

   if (action == A_NOACTION)
      return False;

   PerformAction(action, action_data);

   return True;
}
void SDL_ANDROID_processAndroidTrackballDampening()
{
	SDL_keysym keysym;
	if( !TrackballDampening )
		return;
	if( SDL_GetTicks() - lastTrackballAction > TrackballDampening )
	{
		if( upPressed )
			SDL_SendKeyboardKey( SDL_RELEASED, TranslateKey(KEYCODE_DPAD_UP ,&keysym) );
		if( downPressed )
			SDL_SendKeyboardKey( SDL_RELEASED, TranslateKey(KEYCODE_DPAD_DOWN ,&keysym) );
		if( leftPressed )
			SDL_SendKeyboardKey( SDL_RELEASED, TranslateKey(KEYCODE_DPAD_LEFT ,&keysym) );
		if( rightPressed )
			SDL_SendKeyboardKey( SDL_RELEASED, TranslateKey(KEYCODE_DPAD_RIGHT ,&keysym) );
		upPressed = 0;
		downPressed = 0;
		leftPressed = 0;
		rightPressed = 0;
	}
}
Example #14
0
bool Video::SDLSystem::Update(Video::Event *E)
{
	SDL_Event SE;
	if (SDL_PollEvent(&SE))
	{
		switch (SE.type)
		{
		case SDL_KEYDOWN:
			E->Key.Type = EVT_KEYDOWN;
			E->Key.Key = TranslateKey(SE.key.keysym.sym);
			return true;
		case SDL_KEYUP:
			E->Key.Type = EVT_KEYUP;
			E->Key.Key = TranslateKey(SE.key.keysym.sym);
			return true;
		case SDL_MOUSEMOTION:
		case SDL_MOUSEBUTTONDOWN:
		case SDL_MOUSEBUTTONUP:
			E->Mouse.Type = EVT_MOUSE;
			E->Mouse.Buttons = SDL_GetMouseState(&E->Mouse.XOffset,&E->Mouse.YOffset);
			E->Mouse.XOffset -= Width / 2;
			E->Mouse.YOffset -= Height / 2;
			E->Mouse.XOffset *= 4;
			E->Mouse.YOffset *= -4;
			SDL_WarpMouse(Width / 2,Height / 2);
			return true;
		case SDL_QUIT:
			E->Type = EVT_QUIT;
			return true;
		default:
			return Update(E);
		}
	}
	else
	{
		return false;
	}
}
Example #15
0
//=============================================================================
//	eControl::keyReleaseEvent
//-----------------------------------------------------------------------------
void eControl::keyReleaseEvent(QKeyEvent* event)
{
	if(event->isAutoRepeat())
	{
		event->ignore();
		return;
	}
	int key = 0;
	dword flags = 0;
	EventKeyFlags(event, &key, &flags);
	TranslateKey(key, flags);
	Handler()->OnKey(key, OpJoyKeyFlags());
	key > 0 ? event->accept() : event->ignore();
}
	virtual void OnKeydown(wxKeyEvent& event)
	{
		int key = event.GetKeyCode();
		if(HasCapture() && key == WXK_ESCAPE)
		{
			KillMouseFocus();
			return;
		}
//		printf("kd:%c\n", key);
		dword flags = KF_DOWN|OpJoyKeyFlags();
		if(event.AltDown())		flags |= KF_ALT;
		if(event.ShiftDown())	flags |= KF_SHIFT;
		TranslateKey(key, flags);
		Handler()->OnKey(key, flags);
	}
JNIEXPORT jboolean JNICALL 
JAVA_EXPORT_NAME(SDLSurfaceView_nativeKey) ( JNIEnv*  env, jobject thiz, jint key, jint action, jint unicode )
{
	if( isTrackballUsed )
		if( processAndroidTrackball(key, action) )
			return;

	SDL_keysym keysym;
        SDL_keysym *ks = TranslateKey(key, &keysym);
		ks->unicode = unicode;

        if (ks->sym == KEYCODE_UNKNOWN) {
            return 0;
        } else {                   
            SDL_SendKeyboardKey( action ? SDL_PRESSED : SDL_RELEASED, ks);
            return 1;
        }
}
JNIEXPORT jint JNICALL
JAVA_EXPORT_NAME(DemoGLSurfaceView_nativeKey) ( JNIEnv*  env, jobject thiz, jint key, jint action )
{
    if( !SDL_CurrentVideoSurface )
        return 1;

    SDL_scancode sdlKey = TranslateKey(key);

    if( sdlKey == SDLK_NO_REMAP || sdlKey == SDLK_UNKNOWN )
        return 0;

    if( sdlKey == SDLK_LCLICK ) {
        SDL_ANDROID_MainThreadPushMouseButton( action ? SDL_PRESSED : SDL_RELEASED, SDL_BUTTON_LEFT );
    } else if( sdlKey == SDLK_RCLICK ) {
        SDL_ANDROID_MainThreadPushMouseButton( action ? SDL_PRESSED : SDL_RELEASED, SDL_BUTTON_RIGHT );
    } else {
        SDL_ANDROID_MainThreadPushKeyboardKey( action ? SDL_PRESSED : SDL_RELEASED, sdlKey );
    }
    return 1;
}
Example #19
0
// Get the localized version of the key press. This takes into account the
// keyboard layout, but does not apply any changes due to modifiers, (eg.
// shift-, alt-, etc.)
static int GetLocalizedKey(SDL_Keysym *sym)
{
    // When using Vanilla mapping, we just base everything off the scancode
    // and always pretend the user is using a US layout keyboard.
    if (vanilla_keyboard_mapping)
    {
        return TranslateKey(sym);
    }
    else
    {
        int result = sym->sym;

        if (result < 0 || result >= 128)
        {
            result = 0;
        }

        return result;
    }
}
Example #20
0
static int GetTypedChar(SDL_Event *event)
{
    int key;

    // If Vanilla keyboard mapping enabled, the keyboard
    // scan code is used to give the character typed.
    // This does not change depending on keyboard layout.
    // If you have a German keyboard, pressing 'z' will
    // give 'y', for example.  It is desirable to be able
    // to fix this so that people with non-standard 
    // keyboard mappings can type properly.  If vanilla
    // mode is disabled, use the properly translated 
    // version.

    if (vanilla_keyboard_mapping)
    {
        key = TranslateKey(&event->key.keysym);

        // Is shift held down?  If so, perform a translation.

        if (shiftdown > 0)
        {
            if (key >= 0 && key < arrlen(shiftxform))
            {
                key = shiftxform[key];
            }
            else
            {
                key = 0;
            }
        }

        return key;
    }
    else
    {
        // Unicode value, from key layout.

        return tolower(event->key.keysym.unicode);
    }
}
Example #21
0
      KeyEvent::KeyEvent(const MSG& msg)
      {
        int     res;
        BYTE    keys[256];
        wchar_t buffer[256];

        event=msg;
        
        if (msg.message==WM_KEYDOWN || msg.message==WM_SYSKEYDOWN) {
          type=down;
        }
        else {
          type=up;
        }

        /* ignore */ GetKeyboardState(keys);
        res=::ToUnicode(msg.wParam,(msg.lParam/65536) % 2048,keys,buffer,sizeof(buffer)/sizeof(wchar_t),0);
        if (res>0) {
          text=std::wstring(buffer,res);
        }
        else {
          text=L"";
        }

        qualifier=EvaluateKeyQualifier(keys);
        key=TranslateKey(msg.wParam,qualifier);

        if (text.empty() && (qualifier & (qualifierControlLeft|qualifierControlRight))) {
          if (msg.wParam>=65 && msg.wParam<=90) {
            if (qualifier & (qualifierShiftLeft|qualifierShiftRight)) {
              text.assign(1,(wchar_t)msg.wParam);
            }
            else {
              text.assign(1,(wchar_t)msg.wParam+L'a'-L'A');
            }
          }
          else if (msg.wParam!=VK_CONTROL) {
            text.assign(1,(wchar_t)msg.wParam);
          }
        }
      }
Example #22
0
void CRBXInput::ReadKeys( KEYS& _key, bool& _keypressed )
{

    static KEYS lastkey = NOKEY;

    neutrino_msg_t      msg;
    neutrino_msg_data_t data;

    ReadFromLircd( _key );


    if( NOKEY != _key )
    {
        _keypressed = true;
        lastkey = _key;
    }
    else
    {
        if( NOKEY != lastkey )
        {
            _key = lastkey;
            _keypressed = false;
        }
        lastkey = NOKEY;
    }

    rcinput.getMsg_ms(&msg, &data, 100 );

    if( msg != CRCInput::RC_nokey && msg != CRCInput::RC_timeout )
    {
        std::cout << "got something from rcinput!" << std::endl;
        _key = TranslateKey( (int)msg );
        _keypressed = !data;
    }

}
Example #23
0
/*
 * StatInputKey:  User pressed a key on stat group button or list box.
 *   Return True iff key should NOT be passed on to Windows for default processing.
 */
Bool StatInputKey(HWND hwnd, UINT key, Bool fDown, int cRepeat, UINT flags)
{
   Bool held_down = (flags & 0x4000) ? True : False;  /* Is key being held down? */
   int action;
   void *action_data;

   UserDidSomething();
   
   /* See if stat button handles this key */
   action = TranslateKey(key, stats_key_table, &action_data); 
   if (action == A_NOACTION)
      return False;

   switch(action)
   {
   case A_TABFWD:
      TextInputSetFocus(True);
      break;
   case A_TABBACK:
		SetFocus(cinfo->hMain);	//	ajw
		//InventorySetFocus(False);
		break;
   case A_NEXT:
      StatsMoveButtonFocus(hwnd, True);
      break;
   case A_PREV:
      StatsMoveButtonFocus(hwnd, False);
      break;

   default:
      if (!held_down)
	 PerformAction(action, action_data);
      break;
   }
   return True;
}
Example #24
0
// 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));
	}
}
Example #25
0
/*
 * InventoryKey:  User pressed a key on the inventory list.
 *   Return True iff key should NOT be passed on to Windows for default processing.
 */
Bool InventoryKey(HWND hwnd, UINT key, Bool fDown, int cRepeat, UINT flags)
{
    ID id;
    Bool held_down = (flags & 0x4000) ? True : False;  /* Is key being held down? */
    int action, params;
    InvItem *item;
    void *action_data;
    Bool inform;

    UserDidSomething();

    /* See if inventory handles this key specially */
    action = TranslateKey(key, inventory_key_table, &action_data);
    if (action == A_NOACTION)
        return False;

    // Skip held-down keys, except for moving cursor around
    if (held_down && !IsCursorAction(action))
        return True;

    item = InventoryGetCurrentItem();
    if (item == NULL)
        id = INVALID_ID;
    else id = item->obj->id;

    // See if we should inform modules about event
    inform = True;
    switch (action)
    {
    case A_TABFWD:
    case A_TABBACK:
    case A_TOGGLEUSE:
    case A_USE:
    case A_UNUSE:
    case A_DROP:
    case A_APPLY:
    case A_LOOKINVENTORY:
    case A_SELECT:
        action_data = (void *) id;
        break;

    default:
        inform = False;   // Modules will be informed in PerformAction call below
    }

    // See if a module wants to handle this action
    if (inform)
        if (ModuleEvent(EVENT_USERACTION, action, action_data) == False)
            return True;

    if (IsCursorAction(action))
    {
        InventoryCursorMove(action);
        return True;
    }

    switch (action)
    {
    case A_TABFWD:
        TextInputSetFocus(True);	//	ajw
        //StatsSetFocus(True);
        break;

    case A_TABBACK:
        SetFocus(cinfo->hMain);
        break;

    case A_TOGGLEUSE:
        if (id != INVALID_ID)
        {
            if (item->obj->flags & OF_APPLYABLE)
                StartApply(id);
            else ToggleUse(id);
        }
        break;

    case A_USE:
        if (id != INVALID_ID)
            RequestUse(id);
        break;

    case A_UNUSE:
        if (id != INVALID_ID)
            RequestUnuse(id);
        break;

    case A_DROP:
        if (id != INVALID_ID)
            InventoryDropCurrentItem(NULL);
        break;

    case A_APPLY:
        if (id != INVALID_ID)
            StartApply(id);
        break;

    case A_LOOKINVENTORY:
        if (id == INVALID_ID)
            break;

        params = DESC_DROP;
        if (item->is_using)
            params |= DESC_UNUSE;
        else if (item->obj->flags & OF_APPLYABLE)
            params |= DESC_APPLY;
        else params |= DESC_USE;
        SetDescParams(cinfo->hMain, params);
        RequestLook(id);
        break;

    case A_SELECT:
        if (id != INVALID_ID)
            SelectedObject(id);
        break;

    default:
        PerformAction(action, action_data);
        break;
    }
    return True;
}
Example #26
0
/*
 * Translates key and button events.
 */
bool CLinuxInputDevice::KeyEvent(const struct input_event& levt, XBMC_Event& devt)
{
  int code = levt.code;

  /* map touchscreen and smartpad events to button mouse */
  if (code == BTN_TOUCH || code == BTN_TOOL_FINGER)
    code = BTN_MOUSE;

  if ((code >= BTN_MOUSE && code < BTN_JOYSTICK) || code == BTN_TOUCH)
  {
    /* ignore repeat events for buttons */
    if (levt.value == 2)
      return false;

    devt.type = levt.value ? XBMC_MOUSEBUTTONDOWN : XBMC_MOUSEBUTTONUP;
    devt.button.state = levt.value ? XBMC_PRESSED : XBMC_RELEASED;
    devt.button.type = devt.type;
    devt.button.x = m_mouseX;
    devt.button.y = m_mouseY;

    switch (levt.code)
    {
      case BTN_RIGHT:
        devt.button.button = XBMC_BUTTON_RIGHT;
        break;

      case BTN_LEFT:
        devt.button.button = XBMC_BUTTON_LEFT;
        break;

      case BTN_MIDDLE:
        devt.button.button = XBMC_BUTTON_RIGHT;
        break;

      case BTN_FORWARD:
        devt.button.button = XBMC_BUTTON_WHEELDOWN;
        break;

      case BTN_BACK:
        devt.button.button = XBMC_BUTTON_WHEELUP;
        break;

      case BTN_TOUCH:
        devt.button.button = XBMC_BUTTON_LEFT;
        break;

      case BTN_TOOL_DOUBLETAP:
        devt.button.button = XBMC_BUTTON_RIGHT;
        break;

      default:
        CLog::Log(LOGWARNING, "CLinuxInputDevice::KeyEvent: Unknown mouse button code: %d\n", levt.code);
        return false;
    }
  }
  else
  {
    XBMCKey key = TranslateKey(code);

    if (key == XBMCK_UNKNOWN)
    {
      CLog::Log(LOGDEBUG, "CLinuxInputDevice::KeyEvent: TranslateKey returned XBMCK_UNKNOWN from code(%d)", code);
      return false;
    }

    devt.type = levt.value ? XBMC_KEYDOWN : XBMC_KEYUP;
    devt.key.type = devt.type;
    // warning, key.keysym.scancode is unsigned char so 0 - 255 only
    devt.key.keysym.scancode = code;
    devt.key.keysym.sym = key;
    devt.key.keysym.mod = UpdateModifiers(devt);
    devt.key.keysym.unicode = 0;

    KeymapEntry entry;
    entry.code = code;
    if (GetKeymapEntry(entry))
    {
      int keyMapValue;
      if (devt.key.keysym.mod & (XBMCKMOD_SHIFT | XBMCKMOD_CAPS)) keyMapValue = entry.shift;
      else if (devt.key.keysym.mod & XBMCKMOD_ALT) keyMapValue = entry.alt;
      else if (devt.key.keysym.mod & XBMCKMOD_META) keyMapValue = entry.altShift;
      else keyMapValue = entry.base;

      if (keyMapValue != XBMCK_UNKNOWN)
      {
        devt.key.keysym.sym = (XBMCKey) keyMapValue;
        if (keyMapValue > 0 && keyMapValue < 127)
        {
          devt.key.keysym.unicode = devt.key.keysym.sym;
        }
      }
    }
  }

  return true;
}
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));
}
Example #28
0
LRESULT CALLBACK CWinEventsWin32::WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
  XBMC_Event newEvent;
  ZeroMemory(&newEvent, sizeof(newEvent));
  static HDEVNOTIFY hDeviceNotify;

  if (uMsg == WM_CREATE)
  {
    SetWindowLongPtr(hWnd, GWLP_USERDATA, (LONG)(((LPCREATESTRUCT)lParam)->lpCreateParams));
    DIB_InitOSKeymap();
    g_uQueryCancelAutoPlay = RegisterWindowMessage(TEXT("QueryCancelAutoPlay"));
    shcne.pidl = NULL;
    shcne.fRecursive = TRUE;
    long fEvents = SHCNE_DRIVEADD | SHCNE_DRIVEREMOVED | SHCNE_MEDIAREMOVED | SHCNE_MEDIAINSERTED;
    SHChangeNotifyRegister(hWnd, SHCNRF_ShellLevel | SHCNRF_NewDelivery, fEvents, WM_MEDIA_CHANGE, 1, &shcne);
    RegisterDeviceInterfaceToHwnd(USB_HID_GUID, hWnd, &hDeviceNotify);
    return 0;
  }

  m_pEventFunc = (PHANDLE_EVENT_FUNC)GetWindowLongPtr(hWnd, GWLP_USERDATA);
  if (!m_pEventFunc)
    return DefWindowProc(hWnd, uMsg, wParam, lParam);

  if(g_uQueryCancelAutoPlay != 0 && uMsg == g_uQueryCancelAutoPlay)
    return S_FALSE;

  switch (uMsg)
  {
    case WM_CLOSE:
    case WM_QUIT:
    case WM_DESTROY:
      newEvent.type = XBMC_QUIT;
      m_pEventFunc(newEvent);
      break;
    case WM_SHOWWINDOW:
      {
        bool active = g_application.m_AppActive;
        g_application.m_AppActive = wParam != 0;
        if (g_application.m_AppActive != active)
          g_Windowing.NotifyAppActiveChange(g_application.m_AppActive);
        CLog::Log(LOGDEBUG, __FUNCTION__"Window is %s", g_application.m_AppActive ? "shown" : "hidden");
      }
      break;
    case WM_ACTIVATE:
      {
        bool active = g_application.m_AppActive;
        if (HIWORD(wParam))
        {
          g_application.m_AppActive = false;
        }
        else
        {
          WINDOWPLACEMENT lpwndpl;
          lpwndpl.length = sizeof(lpwndpl);
          if (LOWORD(wParam) != WA_INACTIVE)
          {
            if (GetWindowPlacement(hWnd, &lpwndpl))
              g_application.m_AppActive = lpwndpl.showCmd != SW_HIDE;
          }
          else
          {
            g_application.m_AppActive = g_Windowing.WindowedMode();
          }
        }
        if (g_application.m_AppActive != active)
          g_Windowing.NotifyAppActiveChange(g_application.m_AppActive);
        CLog::Log(LOGDEBUG, __FUNCTION__"Window is %s", g_application.m_AppActive ? "active" : "inactive");
      }
      break;
    case WM_SETFOCUS:
    case WM_KILLFOCUS:
      g_application.m_AppFocused = uMsg == WM_SETFOCUS;
      g_Windowing.NotifyAppFocusChange(g_application.m_AppFocused);
      if (uMsg == WM_KILLFOCUS)
      {
        CStdString procfile;
        if (CWIN32Util::GetFocussedProcess(procfile))
          CLog::Log(LOGDEBUG, __FUNCTION__": Focus switched to process %s", procfile.c_str());
      }
      break;
    case WM_SYSKEYDOWN:
      switch (wParam)
      {
        case VK_F4: //alt-f4, default event quit.
          return(DefWindowProc(hWnd, uMsg, wParam, lParam));
        case VK_RETURN: //alt-return
          if ((lParam & REPEATED_KEYMASK) == 0)
            g_graphicsContext.ToggleFullScreenRoot();
          return 0;
      }
      //deliberate fallthrough
    case WM_KEYDOWN:
    {
      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 (GetKeyState(VK_LSHIFT) & 0x8000)
            wParam = VK_LSHIFT;
          else if (GetKeyState(VK_RSHIFT) & 0x8000)
            wParam = VK_RSHIFT;
          break;
        case VK_MENU:
          if ( lParam & EXTENDED_KEYMASK )
            wParam = VK_RMENU;
          else
            wParam = VK_LMENU;
          break;
      }
      XBMC_keysym keysym;
      TranslateKey(wParam, HIWORD(lParam), &keysym, 1);

      newEvent.type = XBMC_KEYDOWN;
      newEvent.key.keysym = keysym;
      m_pEventFunc(newEvent);
    }
    return(0);

    case WM_SYSKEYUP:
    case WM_KEYUP:
      {
      switch (wParam)
      {
        case VK_CONTROL:
          if ( lParam&EXTENDED_KEYMASK )
            wParam = VK_RCONTROL;
          else
            wParam = VK_LCONTROL;
          break;
        case VK_SHIFT:
          {
            uint32_t scanCodeL = MapVirtualKey(VK_LSHIFT, MAPVK_VK_TO_VSC);
            uint32_t scanCodeR = MapVirtualKey(VK_RSHIFT, MAPVK_VK_TO_VSC);
            uint32_t keyCode = (uint32_t)((lParam & 0xFF0000) >> 16);
            if (keyCode == scanCodeL)
              wParam = VK_LSHIFT;
            else if (keyCode == scanCodeR)
              wParam = VK_RSHIFT;
          }
          break;
        case VK_MENU:
          if ( lParam&EXTENDED_KEYMASK )
            wParam = VK_RMENU;
          else
            wParam = VK_LMENU;
          break;
      }
      XBMC_keysym keysym;
      TranslateKey(wParam, HIWORD(lParam), &keysym, 1);

      if (wParam == VK_SNAPSHOT)
        newEvent.type = XBMC_KEYDOWN;
      else
        newEvent.type = XBMC_KEYUP;
      newEvent.key.keysym = keysym;
      m_pEventFunc(newEvent);
    }
    return(0);
    case WM_APPCOMMAND: // MULTIMEDIA keys are mapped to APPCOMMANDS
    {
      CLog::Log(LOGDEBUG, "WinEventsWin32.cpp: APPCOMMAND %d", GET_APPCOMMAND_LPARAM(lParam));
      newEvent.appcommand.type = XBMC_APPCOMMAND;
      newEvent.appcommand.action = GET_APPCOMMAND_LPARAM(lParam);
      if (m_pEventFunc(newEvent))
        return TRUE;
      else
        return DefWindowProc(hWnd, uMsg, wParam, lParam);
    }
    case WM_GESTURENOTIFY:
    {
      OnGestureNotify(hWnd, lParam);
      return DefWindowProc(hWnd, WM_GESTURENOTIFY, wParam, lParam);
    }
    case WM_GESTURE:
    {
      OnGesture(hWnd, lParam);
      return 0;
    }
    case WM_SYSCHAR:
      if (wParam == VK_RETURN) //stop system beep on alt-return
        return 0;
      break;
    case WM_SETCURSOR:
      if (HTCLIENT != LOWORD(lParam))
        g_Windowing.ShowOSMouse(true);
      break;
    case WM_MOUSEMOVE:
      newEvent.type = XBMC_MOUSEMOTION;
      newEvent.motion.x = GET_X_LPARAM(lParam);
      newEvent.motion.y = GET_Y_LPARAM(lParam);
      newEvent.motion.state = 0;
      m_pEventFunc(newEvent);
      return(0);
    case WM_LBUTTONDOWN:
    case WM_MBUTTONDOWN:
    case WM_RBUTTONDOWN:
      newEvent.type = XBMC_MOUSEBUTTONDOWN;
      newEvent.button.state = XBMC_PRESSED;
      newEvent.button.x = GET_X_LPARAM(lParam);
      newEvent.button.y = GET_Y_LPARAM(lParam);
      newEvent.button.button = 0;
      if (uMsg == WM_LBUTTONDOWN) newEvent.button.button = XBMC_BUTTON_LEFT;
      else if (uMsg == WM_MBUTTONDOWN) newEvent.button.button = XBMC_BUTTON_MIDDLE;
      else if (uMsg == WM_RBUTTONDOWN) newEvent.button.button = XBMC_BUTTON_RIGHT;
      m_pEventFunc(newEvent);
      return(0);
    case WM_LBUTTONUP:
    case WM_MBUTTONUP:
    case WM_RBUTTONUP:
      newEvent.type = XBMC_MOUSEBUTTONUP;
      newEvent.button.state = XBMC_RELEASED;
      newEvent.button.x = GET_X_LPARAM(lParam);
      newEvent.button.y = GET_Y_LPARAM(lParam);
      newEvent.button.button = 0;
      if (uMsg == WM_LBUTTONUP) newEvent.button.button = XBMC_BUTTON_LEFT;
      else if (uMsg == WM_MBUTTONUP) newEvent.button.button = XBMC_BUTTON_MIDDLE;
      else if (uMsg == WM_RBUTTONUP) newEvent.button.button = XBMC_BUTTON_RIGHT;
      m_pEventFunc(newEvent);
      return(0);
    case WM_MOUSEWHEEL:
      {
        // SDL, which our events system is based off, sends a MOUSEBUTTONDOWN message
        // followed by a MOUSEBUTTONUP message.  As this is a momentary event, we just
        // react on the MOUSEBUTTONUP message, resetting the state after processing.
        newEvent.type = XBMC_MOUSEBUTTONDOWN;
        newEvent.button.state = XBMC_PRESSED;
        // the coordinates in WM_MOUSEWHEEL are screen, not client coordinates
        POINT point;
        point.x = GET_X_LPARAM(lParam);
        point.y = GET_Y_LPARAM(lParam);
        WindowFromScreenCoords(hWnd, &point);
        newEvent.button.x = (uint16_t)point.x;
        newEvent.button.y = (uint16_t)point.y;
        newEvent.button.button = GET_Y_LPARAM(wParam) > 0 ? XBMC_BUTTON_WHEELUP : XBMC_BUTTON_WHEELDOWN;
        m_pEventFunc(newEvent);
        newEvent.type = XBMC_MOUSEBUTTONUP;
        newEvent.button.state = XBMC_RELEASED;
        m_pEventFunc(newEvent);
      }
      return(0);
    case WM_SIZE:
      newEvent.type = XBMC_VIDEORESIZE;
      newEvent.resize.type = XBMC_VIDEORESIZE;
      newEvent.resize.w = GET_X_LPARAM(lParam);
      newEvent.resize.h = GET_Y_LPARAM(lParam);
      if (newEvent.resize.w * newEvent.resize.h)
        m_pEventFunc(newEvent);
      return(0);
    case WM_MEDIA_CHANGE:
      {
        // There may be multiple notifications for one event
        // There are also a few events we're not interested in, but they cause no harm
        // For example SD card reader insertion/removal
        long lEvent;
        PIDLIST_ABSOLUTE *ppidl;
        HANDLE hLock = SHChangeNotification_Lock((HANDLE)wParam, (DWORD)lParam, &ppidl, &lEvent);

        if (hLock)
        {
          char drivePath[MAX_PATH+1];
          if (!SHGetPathFromIDList(ppidl[0], drivePath))
            break;

          switch(lEvent)
          {
            case SHCNE_DRIVEADD:
            case SHCNE_MEDIAINSERTED:
              CLog::Log(LOGDEBUG, __FUNCTION__": Drive %s Media has arrived.", drivePath);
              if (GetDriveType(drivePath) == DRIVE_CDROM)
                g_application.getApplicationMessenger().OpticalMount(drivePath, true);
              else
                CWin32StorageProvider::SetEvent();
              break;

            case SHCNE_DRIVEREMOVED:
            case SHCNE_MEDIAREMOVED:
              CLog::Log(LOGDEBUG, __FUNCTION__": Drive %s Media was removed.", drivePath);
              if (GetDriveType(drivePath) == DRIVE_CDROM)
                g_application.getApplicationMessenger().OpticalUnMount(drivePath);
              else
                CWin32StorageProvider::SetEvent();
              break;
          }
          SHChangeNotification_Unlock(hLock);
        }
        break;
      }
    case WM_POWERBROADCAST:
      if (wParam==PBT_APMSUSPEND)
      {
        CLog::Log(LOGDEBUG,"WM_POWERBROADCAST: PBT_APMSUSPEND event was sent");
        CWin32PowerSyscall::SetOnSuspend();
      }
      else if(wParam==PBT_APMRESUMEAUTOMATIC)
      {
        CLog::Log(LOGDEBUG,"WM_POWERBROADCAST: PBT_APMRESUMEAUTOMATIC event was sent");
        CWin32PowerSyscall::SetOnResume();
      }
      break;
    case WM_DEVICECHANGE:
      {
        PDEV_BROADCAST_DEVICEINTERFACE b = (PDEV_BROADCAST_DEVICEINTERFACE) lParam;
        CStdString dbcc_name(b->dbcc_name);
        dbcc_name = CKeymapLoader::ParseWin32HIDName(b->dbcc_name);
        switch (wParam)
        {
          case DBT_DEVICEARRIVAL:
            CKeymapLoader().DeviceAdded(dbcc_name);
            break;
          case DBT_DEVICEREMOVECOMPLETE:
            CKeymapLoader().DeviceRemoved(dbcc_name);
            break;
          case DBT_DEVNODES_CHANGED:
            //CLog::Log(LOGDEBUG, "HID Device Changed");
            //We generally don't care about Change notifications, only need to know if a device is removed or added to rescan the device list
            break;
        }
        break;
      }
    case WM_PAINT:
      //some other app has painted over our window, mark everything as dirty
      g_windowManager.MarkDirty();
      break;
  }
  return(DefWindowProc(hWnd, uMsg, wParam, lParam));
}
Example #29
0
/* 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));
}
Example #30
0
void CRBXInput::ReadFromLircd( KEYS& _key )
{
    if( -1 == lircd ) return;

//	std::cout << "read from LIRCD :" << std::endl;

    fd_set		read_sock;
    struct 		timeval	tv;
    int 		rc = 0;

    _key = NOKEY;

//	std::cout << "read data from lircd" << std::endl;

    tv.tv_sec	= 0;
    tv.tv_usec	= 0;

    FD_ZERO( &read_sock );
    FD_SET( lircd, &read_sock );

    rc = select( lircd + 1, &read_sock, NULL, NULL, &tv );

    if( 0 == rc )
    {
//		std::cout << "read from LIRCD 2:" << std::endl;
        return; // nothing  to read from lircd
    }

//	std::cout << "read from LIRCD 0:" << std::endl;

    if( -1 == rc )
    {
        //something wrong, don't read from lircd anymore
//		std::cout << "read from LIRCD 1:" << std::endl;
        close( lircd );
        lircd = -1;
        return;
    }


    std::string	instring;
    char		buffer[128];

//	std::cout << "read data from socket" << std::endl;

    while( 0 < ( rc = recv( lircd, buffer, 128, 0 ) ) )
    {
        int i;

        for( i = 0; i < rc; i++ )
        {
            instring += buffer[i];
        }

        if( rc < 128 ) break;
    }

    if( 0 == rc )
    {
        //lircd closed connection or some problems, don't read any more from lircd

        close( lircd );
        lircd = -1;
        return;
    }
    else if( rc < 0 && errno != EAGAIN )
    {
        std::cout << "Error on lircd socket while reading" << std::endl;
        close( lircd );
        lircd = -1;
        return;
    }

    if( 0 == instring.size() )
        return;

    std::cout << "Data read from lircd:" << std::endl << instring << std::endl;

//	Parse strings

    std::string::size_type	start = 0;
    std::string::size_type	end = 0;

    while( end < instring.size() )
    {
        for( int part = 0; part < 4; part++ )
        {
            std::string sub;
            std::string delim = (part == 3)?"\n":" ";

            end = instring.find( delim, start );
            sub = instring.substr( start, end - start );

//			std::cout << "part: " << part << std::endl;

            switch( part )
            {
            case 0: /* internal code */
            case 1: /* repeat count */
            case 3: /* rc name */
                break;
            case 2: /* button name */
                _key = TranslateKey( sub );
//					std::cout << sub << " translated = " << this->key << std::endl;
                break;
            }

            start = ++end;
        }

    }

}