SDL_keyboard.c File Reference

#include "../SDL_internal.h"
#include "SDL_timer.h"
#include "SDL_events.h"
#include "SDL_events_c.h"
#include "../video/SDL_sysvideo.h"

Include dependency graph for SDL_keyboard.c:

Go to the source code of this file.

Data Structures
struct	SDL_Keyboard

Macros
#define	KEYBOARD_HARDWARE   0x01
#define	KEYBOARD_AUTORELEASE   0x02

Functions
char *	SDL_UCS4ToUTF8 (Uint32 ch, char *dst)
int	SDL_KeyboardInit (void)
void	SDL_ResetKeyboard (void)
void	SDL_GetDefaultKeymap (SDL_Keycode *keymap)
void	SDL_SetKeymap (int start, SDL_Keycode *keys, int length)
void	SDL_SetScancodeName (SDL_Scancode scancode, const char *name)
SDL_Window *	SDL_GetKeyboardFocus (void)
	Get the window which currently has keyboard focus. More...
void	SDL_SetKeyboardFocus (SDL_Window *window)
static int	SDL_SendKeyboardKeyInternal (Uint8 source, Uint8 state, SDL_Scancode scancode)
int	SDL_SendKeyboardKey (Uint8 state, SDL_Scancode scancode)
int	SDL_SendKeyboardKeyAutoRelease (SDL_Scancode scancode)
void	SDL_ReleaseAutoReleaseKeys (void)
SDL_bool	SDL_HardwareKeyboardKeyPressed (void)
int	SDL_SendKeyboardText (const char *text)
int	SDL_SendEditingText (const char *text, int start, int length)
void	SDL_KeyboardQuit (void)
const Uint8 *	SDL_GetKeyboardState (int *numkeys)
	Get a snapshot of the current state of the keyboard. More...
SDL_Keymod	SDL_GetModState (void)
	Get the current key modifier state for the keyboard. More...
void	SDL_SetModState (SDL_Keymod modstate)
	Set the current key modifier state for the keyboard. More...
void	SDL_ToggleModState (const SDL_Keymod modstate, const SDL_bool toggle)
SDL_Keycode	SDL_GetKeyFromScancode (SDL_Scancode scancode)
	Get the key code corresponding to the given scancode according to the current keyboard layout. More...
SDL_Scancode	SDL_GetScancodeFromKey (SDL_Keycode key)
	Get the scancode corresponding to the given key code according to the current keyboard layout. More...
const char *	SDL_GetScancodeName (SDL_Scancode scancode)
	Get a human-readable name for a scancode. More...
SDL_Scancode	SDL_GetScancodeFromName (const char *name)
	Get a scancode from a human-readable name. More...
const char *	SDL_GetKeyName (SDL_Keycode key)
	Get a human-readable name for a key. More...
SDL_Keycode	SDL_GetKeyFromName (const char *name)
	Get a key code from a human-readable name. More...

Variables
static SDL_Keyboard	SDL_keyboard
static const SDL_Keycode	SDL_default_keymap [SDL_NUM_SCANCODES]
static const char *	SDL_scancode_names [SDL_NUM_SCANCODES]

Macro Definition Documentation

KEYBOARD_AUTORELEASE

#define KEYBOARD_AUTORELEASE   0x02

Definition at line 36 of file SDL_keyboard.c.

KEYBOARD_HARDWARE

#define KEYBOARD_HARDWARE   0x01

Definition at line 35 of file SDL_keyboard.c.

Function Documentation

SDL_GetDefaultKeymap()

void SDL_GetDefaultKeymap

(

SDL_Keycode *

keymap

)

Definition at line 592 of file SDL_keyboard.c.

{
    SDL_memcpy(keymap, SDL_default_keymap, sizeof(SDL_default_keymap));
}

References SDL_default_keymap, and SDL_memcpy.

SDL_GetKeyboardFocus()

SDL_Window* SDL_GetKeyboardFocus

(

void

)

Get the window which currently has keyboard focus.

Definition at line 626 of file SDL_keyboard.c.

{
    SDL_Keyboard *keyboard = &SDL_keyboard;
 
    return keyboard->focus;
}

References SDL_Keyboard::focus, and SDL_keyboard.

SDL_GetKeyboardState()

const Uint8* SDL_GetKeyboardState

(

int *

numkeys

)

Get a snapshot of the current state of the keyboard.

Parameters

numkeys

if non-NULL, receives the length of the returned array.

Returns

An array of key states. Indexes into this array are obtained by using SDL_Scancode values.

Example:

const Uint8 *state = SDL_GetKeyboardState(NULL);
if ( state[SDL_SCANCODE_RETURN] )   {
    printf("<RETURN> is pressed.\n");
}

Definition at line 896 of file SDL_keyboard.c.

{
    SDL_Keyboard *keyboard = &SDL_keyboard;
 
    if (numkeys != (int *) 0) {
        *numkeys = SDL_NUM_SCANCODES;
    }
    return keyboard->keystate;
}

References SDL_Keyboard::keystate, SDL_keyboard, and SDL_NUM_SCANCODES.

SDL_GetKeyFromName()

SDL_Keycode SDL_GetKeyFromName

(

const char *

name

)

Get a key code from a human-readable name.

Returns

key code, or SDLK_UNKNOWN if the name wasn't recognized

See also

SDL_Keycode

Definition at line 1041 of file SDL_keyboard.c.

{
    SDL_Keycode key;
 
    /* Check input */
    if (name == NULL) {
        return SDLK_UNKNOWN;
    }
 
    /* If it's a single UTF-8 character, then that's the keycode itself */
    key = *(const unsigned char *)name;
    if (key >= 0xF0) {
        if (SDL_strlen(name) == 4) {
            int i = 0;
            key  = (Uint16)(name[i]&0x07) << 18;
            key |= (Uint16)(name[++i]&0x3F) << 12;
            key |= (Uint16)(name[++i]&0x3F) << 6;
            key |= (Uint16)(name[++i]&0x3F);
            return key;
        }
        return SDLK_UNKNOWN;
    } else if (key >= 0xE0) {
        if (SDL_strlen(name) == 3) {
            int i = 0;
            key  = (Uint16)(name[i]&0x0F) << 12;
            key |= (Uint16)(name[++i]&0x3F) << 6;
            key |= (Uint16)(name[++i]&0x3F);
            return key;
        }
        return SDLK_UNKNOWN;
    } else if (key >= 0xC0) {
        if (SDL_strlen(name) == 2) {
            int i = 0;
            key  = (Uint16)(name[i]&0x1F) << 6;
            key |= (Uint16)(name[++i]&0x3F);
            return key;
        }
        return SDLK_UNKNOWN;
    } else {
        if (SDL_strlen(name) == 1) {
            if (key >= 'A' && key <= 'Z') {
                key += 32;
            }
            return key;
        }
 
        /* Get the scancode for this name, and the associated keycode */
        return SDL_default_keymap[SDL_GetScancodeFromName(name)];
    }
}

References i, NULL, SDL_default_keymap, SDL_GetScancodeFromName(), SDL_strlen, and SDLK_UNKNOWN.

SDL_GetKeyFromScancode()

SDL_Keycode SDL_GetKeyFromScancode

(

SDL_Scancode

scancode

)

Get the key code corresponding to the given scancode according to the current keyboard layout.

See SDL_Keycode for details.

See also

SDL_GetKeyName()

Definition at line 936 of file SDL_keyboard.c.

{
    SDL_Keyboard *keyboard = &SDL_keyboard;
 
    if (((int)scancode) < SDL_SCANCODE_UNKNOWN || scancode >= SDL_NUM_SCANCODES) {
          SDL_InvalidParamError("scancode");
          return 0;
    }
 
    return keyboard->keymap[scancode];
}

References SDL_Keyboard::keymap, SDL_InvalidParamError, SDL_keyboard, SDL_NUM_SCANCODES, and SDL_SCANCODE_UNKNOWN.

SDL_GetKeyName()

const char* SDL_GetKeyName

(

SDL_Keycode

key

)

Get a human-readable name for a key.

Returns

A pointer to a UTF-8 string that stays valid at least until the next call to this function. If you need it around any longer, you must copy it. If the key doesn't have a name, this function returns an empty string ("").

See also

SDL_Keycode

Definition at line 1002 of file SDL_keyboard.c.

{
    static char name[8];
    char *end;
 
    if (key & SDLK_SCANCODE_MASK) {
        return
            SDL_GetScancodeName((SDL_Scancode) (key & ~SDLK_SCANCODE_MASK));
    }
 
    switch (key) {
    case SDLK_RETURN:
        return SDL_GetScancodeName(SDL_SCANCODE_RETURN);
    case SDLK_ESCAPE:
        return SDL_GetScancodeName(SDL_SCANCODE_ESCAPE);
    case SDLK_BACKSPACE:
        return SDL_GetScancodeName(SDL_SCANCODE_BACKSPACE);
    case SDLK_TAB:
        return SDL_GetScancodeName(SDL_SCANCODE_TAB);
    case SDLK_SPACE:
        return SDL_GetScancodeName(SDL_SCANCODE_SPACE);
    case SDLK_DELETE:
        return SDL_GetScancodeName(SDL_SCANCODE_DELETE);
    default:
        /* Unaccented letter keys on latin keyboards are normally
           labeled in upper case (and probably on others like Greek or
           Cyrillic too, so if you happen to know for sure, please
           adapt this). */
        if (key >= 'a' && key <= 'z') {
            key -= 32;
        }
 
        end = SDL_UCS4ToUTF8((Uint32) key, name);
        *end = '\0';
        return name;
    }
}

References SDL_GetScancodeName(), SDL_SCANCODE_BACKSPACE, SDL_SCANCODE_DELETE, SDL_SCANCODE_ESCAPE, SDL_SCANCODE_RETURN, SDL_SCANCODE_SPACE, SDL_SCANCODE_TAB, SDL_UCS4ToUTF8(), SDLK_BACKSPACE, SDLK_DELETE, SDLK_ESCAPE, SDLK_RETURN, SDLK_SCANCODE_MASK, SDLK_SPACE, and SDLK_TAB.

SDL_GetModState()

SDL_Keymod SDL_GetModState

(

void

)

Get the current key modifier state for the keyboard.

Definition at line 907 of file SDL_keyboard.c.

{
    SDL_Keyboard *keyboard = &SDL_keyboard;
 
    return (SDL_Keymod) keyboard->modstate;
}

References SDL_Keyboard::modstate, and SDL_keyboard.

SDL_GetScancodeFromKey()

SDL_Scancode SDL_GetScancodeFromKey

(

SDL_Keycode

key

)

Get the scancode corresponding to the given key code according to the current keyboard layout.

See SDL_Scancode for details.

See also

SDL_GetScancodeName()

Definition at line 949 of file SDL_keyboard.c.

{
    SDL_Keyboard *keyboard = &SDL_keyboard;
    SDL_Scancode scancode;
 
    for (scancode = SDL_SCANCODE_UNKNOWN; scancode < SDL_NUM_SCANCODES;
         ++scancode) {
        if (keyboard->keymap[scancode] == key) {
            return scancode;
        }
    }
    return SDL_SCANCODE_UNKNOWN;
}

References SDL_Keyboard::keymap, SDL_keyboard, SDL_NUM_SCANCODES, and SDL_SCANCODE_UNKNOWN.

SDL_GetScancodeFromName()

SDL_Scancode SDL_GetScancodeFromName

(

const char *

name

)

Get a scancode from a human-readable name.

Returns

scancode, or SDL_SCANCODE_UNKNOWN if the name wasn't recognized

See also

SDL_Scancode

Definition at line 979 of file SDL_keyboard.c.

{
    int i;
 
    if (!name || !*name) {
            SDL_InvalidParamError("name");
        return SDL_SCANCODE_UNKNOWN;
    }
 
    for (i = 0; i < SDL_arraysize(SDL_scancode_names); ++i) {
        if (!SDL_scancode_names[i]) {
            continue;
        }
        if (SDL_strcasecmp(name, SDL_scancode_names[i]) == 0) {
            return (SDL_Scancode)i;
        }
    }
 
    SDL_InvalidParamError("name");
    return SDL_SCANCODE_UNKNOWN;
}

References i, SDL_arraysize, SDL_InvalidParamError, SDL_scancode_names, SDL_SCANCODE_UNKNOWN, and SDL_strcasecmp.

Referenced by SDL_GetKeyFromName().

SDL_GetScancodeName()

const char* SDL_GetScancodeName

(

SDL_Scancode

scancode

)

Get a human-readable name for a scancode.

Returns

A pointer to the name for the scancode. If the scancode doesn't have a name, this function returns an empty string ("").

See also

SDL_Scancode

Definition at line 964 of file SDL_keyboard.c.

{
    const char *name;
    if (((int)scancode) < SDL_SCANCODE_UNKNOWN || scancode >= SDL_NUM_SCANCODES) {
          SDL_InvalidParamError("scancode");
          return "";
    }
 
    name = SDL_scancode_names[scancode];
    if (name)
        return name;
    else
        return "";
}

References SDL_InvalidParamError, SDL_NUM_SCANCODES, SDL_scancode_names, and SDL_SCANCODE_UNKNOWN.

Referenced by SDL_GetKeyName(), and SDL_SendKeyboardKeyInternal().

SDL_HardwareKeyboardKeyPressed()

SDL_bool SDL_HardwareKeyboardKeyPressed

(

void

)

Definition at line 834 of file SDL_keyboard.c.

{
    SDL_Keyboard *keyboard = &SDL_keyboard;
    SDL_Scancode scancode;
 
    for (scancode = SDL_SCANCODE_UNKNOWN; scancode < SDL_NUM_SCANCODES; ++scancode) {
        if ((keyboard->keysource[scancode] & KEYBOARD_HARDWARE) != 0) {
            return SDL_TRUE;
        }
    }
    return SDL_FALSE;
}

References KEYBOARD_HARDWARE, SDL_Keyboard::keysource, SDL_FALSE, SDL_keyboard, SDL_NUM_SCANCODES, SDL_SCANCODE_UNKNOWN, and SDL_TRUE.

SDL_KeyboardInit()

int SDL_KeyboardInit

(

void

)

Definition at line 566 of file SDL_keyboard.c.

{
    SDL_Keyboard *keyboard = &SDL_keyboard;
 
    /* Set the default keymap */
    SDL_memcpy(keyboard->keymap, SDL_default_keymap, sizeof(SDL_default_keymap));
    return (0);
}

References SDL_Keyboard::keymap, SDL_default_keymap, SDL_keyboard, and SDL_memcpy.

Referenced by SDL_VideoInit().

SDL_KeyboardQuit()

void SDL_KeyboardQuit

(

void

)

Definition at line 891 of file SDL_keyboard.c.

{
}

Referenced by SDL_VideoQuit().

SDL_ReleaseAutoReleaseKeys()

void SDL_ReleaseAutoReleaseKeys

(

void

)

Definition at line 818 of file SDL_keyboard.c.

{
    SDL_Keyboard *keyboard = &SDL_keyboard;
    SDL_Scancode scancode;
 
    if (keyboard->autorelease_pending) {
        for (scancode = SDL_SCANCODE_UNKNOWN; scancode < SDL_NUM_SCANCODES; ++scancode) {
            if (keyboard->keysource[scancode] == KEYBOARD_AUTORELEASE) {
                SDL_SendKeyboardKeyInternal(KEYBOARD_AUTORELEASE, SDL_RELEASED, scancode);
            }
        }
        keyboard->autorelease_pending = SDL_FALSE;
    }
}

References SDL_Keyboard::autorelease_pending, KEYBOARD_AUTORELEASE, SDL_Keyboard::keysource, SDL_FALSE, SDL_keyboard, SDL_NUM_SCANCODES, SDL_RELEASED, SDL_SCANCODE_UNKNOWN, and SDL_SendKeyboardKeyInternal().

Referenced by SDL_PumpEvents().

SDL_ResetKeyboard()

void SDL_ResetKeyboard

(

void

)

Definition at line 576 of file SDL_keyboard.c.

{
    SDL_Keyboard *keyboard = &SDL_keyboard;
    SDL_Scancode scancode;
 
#ifdef DEBUG_KEYBOARD
    printf("Resetting keyboard\n");
#endif
    for (scancode = (SDL_Scancode) 0; scancode < SDL_NUM_SCANCODES; ++scancode) {
        if (keyboard->keystate[scancode] == SDL_PRESSED) {
            SDL_SendKeyboardKey(SDL_RELEASED, scancode);
        }
    }
}

References SDL_Keyboard::keystate, SDL_keyboard, SDL_NUM_SCANCODES, SDL_PRESSED, SDL_RELEASED, and SDL_SendKeyboardKey().

Referenced by SDL_SetKeyboardFocus(), and SDL_ShowMessageBox().

SDL_SendEditingText()

int SDL_SendEditingText	(	const char *	text,
		int	start,
		int	length
	)

Definition at line 871 of file SDL_keyboard.c.

{
    SDL_Keyboard *keyboard = &SDL_keyboard;
    int posted;
 
    /* Post the event, if desired */
    posted = 0;
    if (SDL_GetEventState(SDL_TEXTEDITING) == SDL_ENABLE) {
        SDL_Event event;
        event.edit.type = SDL_TEXTEDITING;
        event.edit.windowID = keyboard->focus ? keyboard->focus->id : 0;
        event.edit.start = start;
        event.edit.length = length;
        SDL_utf8strlcpy(event.edit.text, text, SDL_arraysize(event.edit.text));
        posted = (SDL_PushEvent(&event) > 0);
    }
    return (posted);
}

References SDL_Keyboard::focus, SDL_Window::id, SDL_arraysize, SDL_ENABLE, SDL_GetEventState, SDL_keyboard, SDL_PushEvent, SDL_TEXTEDITING, SDL_utf8strlcpy, and text.

Referenced by DBus_MessageFilter().

SDL_SendKeyboardKey()

int SDL_SendKeyboardKey	(	Uint8	state,
		SDL_Scancode	scancode
	)

Definition at line 806 of file SDL_keyboard.c.

{
    return SDL_SendKeyboardKeyInternal(KEYBOARD_HARDWARE, state, scancode);
}

References KEYBOARD_HARDWARE, SDL_SendKeyboardKeyInternal(), and state.

Referenced by SDL_BApp::_HandleKey(), handleKeyboardEvent(), SDL_ResetKeyboard(), and WINRT_OnBackButtonPressed().

SDL_SendKeyboardKeyAutoRelease()

int SDL_SendKeyboardKeyAutoRelease

(

SDL_Scancode

scancode

)

Definition at line 812 of file SDL_keyboard.c.

{
    return SDL_SendKeyboardKeyInternal(KEYBOARD_AUTORELEASE, SDL_PRESSED, scancode);
}

References KEYBOARD_AUTORELEASE, SDL_PRESSED, and SDL_SendKeyboardKeyInternal().

SDL_SendKeyboardKeyInternal()

static int SDL_SendKeyboardKeyInternal ( Uint8  source, Uint8  state, SDL_Scancode  scancode  )

static

Definition at line 683 of file SDL_keyboard.c.

{
    SDL_Keyboard *keyboard = &SDL_keyboard;
    int posted;
    SDL_Keymod modifier;
    SDL_Keycode keycode;
    Uint32 type;
    Uint8 repeat = SDL_FALSE;
 
    if (scancode == SDL_SCANCODE_UNKNOWN) {
        return 0;
    }
 
#ifdef DEBUG_KEYBOARD
    printf("The '%s' key has been %s\n", SDL_GetScancodeName(scancode),
           state == SDL_PRESSED ? "pressed" : "released");
#endif
 
    /* Figure out what type of event this is */
    switch (state) {
    case SDL_PRESSED:
        type = SDL_KEYDOWN;
        break;
    case SDL_RELEASED:
        type = SDL_KEYUP;
        break;
    default:
        /* Invalid state -- bail */
        return 0;
    }
 
    /* Drop events that don't change state */
    if (state) {
        if (keyboard->keystate[scancode]) {
            if (!(keyboard->keysource[scancode] & source)) {
                keyboard->keysource[scancode] |= source;
                return 0;
            }
            repeat = SDL_TRUE;
        }
        keyboard->keysource[scancode] |= source;
    } else {
        if (!keyboard->keystate[scancode]) {
            return 0;
        }
        keyboard->keysource[scancode] = 0;
    }
 
    /* Update internal keyboard state */
    keyboard->keystate[scancode] = state;
 
    keycode = keyboard->keymap[scancode];
 
    if (source == KEYBOARD_AUTORELEASE) {
        keyboard->autorelease_pending = SDL_TRUE;
    }
 
    /* Update modifiers state if applicable */
    switch (keycode) {
    case SDLK_LCTRL:
        modifier = KMOD_LCTRL;
        break;
    case SDLK_RCTRL:
        modifier = KMOD_RCTRL;
        break;
    case SDLK_LSHIFT:
        modifier = KMOD_LSHIFT;
        break;
    case SDLK_RSHIFT:
        modifier = KMOD_RSHIFT;
        break;
    case SDLK_LALT:
        modifier = KMOD_LALT;
        break;
    case SDLK_RALT:
        modifier = KMOD_RALT;
        break;
    case SDLK_LGUI:
        modifier = KMOD_LGUI;
        break;
    case SDLK_RGUI:
        modifier = KMOD_RGUI;
        break;
    case SDLK_MODE:
        modifier = KMOD_MODE;
        break;
    default:
        modifier = KMOD_NONE;
        break;
    }
    if (SDL_KEYDOWN == type) {
        switch (keycode) {
        case SDLK_NUMLOCKCLEAR:
            keyboard->modstate ^= KMOD_NUM;
            break;
        case SDLK_CAPSLOCK:
            keyboard->modstate ^= KMOD_CAPS;
            break;
        default:
            keyboard->modstate |= modifier;
            break;
        }
    } else {
        keyboard->modstate &= ~modifier;
    }
 
    /* Post the event, if desired */
    posted = 0;
    if (SDL_GetEventState(type) == SDL_ENABLE) {
        SDL_Event event;
        event.key.type = type;
        event.key.state = state;
        event.key.repeat = repeat;
        event.key.keysym.scancode = scancode;
        event.key.keysym.sym = keycode;
        event.key.keysym.mod = keyboard->modstate;
        event.key.windowID = keyboard->focus ? keyboard->focus->id : 0;
        posted = (SDL_PushEvent(&event) > 0);
    }
    return (posted);
}

References SDL_Keyboard::autorelease_pending, SDL_Keyboard::focus, SDL_Window::id, KEYBOARD_AUTORELEASE, SDL_Keyboard::keymap, SDL_Keyboard::keysource, SDL_Keyboard::keystate, KMOD_CAPS, KMOD_LALT, KMOD_LCTRL, KMOD_LGUI, KMOD_LSHIFT, KMOD_MODE, KMOD_NONE, KMOD_NUM, KMOD_RALT, KMOD_RCTRL, KMOD_RGUI, KMOD_RSHIFT, SDL_Keyboard::modstate, SDL_ENABLE, SDL_FALSE, SDL_GetEventState, SDL_GetScancodeName(), SDL_keyboard, SDL_KEYDOWN, SDL_KEYUP, SDL_PRESSED, SDL_PushEvent, SDL_RELEASED, SDL_SCANCODE_UNKNOWN, SDL_TRUE, SDLK_CAPSLOCK, SDLK_LALT, SDLK_LCTRL, SDLK_LGUI, SDLK_LSHIFT, SDLK_MODE, SDLK_NUMLOCKCLEAR, SDLK_RALT, SDLK_RCTRL, SDLK_RGUI, SDLK_RSHIFT, and state.

Referenced by SDL_ReleaseAutoReleaseKeys(), SDL_SendKeyboardKey(), and SDL_SendKeyboardKeyAutoRelease().

SDL_SendKeyboardText()

int SDL_SendKeyboardText

(

const char *

text

)

Definition at line 848 of file SDL_keyboard.c.

{
    SDL_Keyboard *keyboard = &SDL_keyboard;
    int posted;
 
    /* Don't post text events for unprintable characters */
    if ((unsigned char)*text < ' ' || *text == 127) {
        return 0;
    }
 
    /* Post the event, if desired */
    posted = 0;
    if (SDL_GetEventState(SDL_TEXTINPUT) == SDL_ENABLE) {
        SDL_Event event;
        event.text.type = SDL_TEXTINPUT;
        event.text.windowID = keyboard->focus ? keyboard->focus->id : 0;
        SDL_utf8strlcpy(event.text.text, text, SDL_arraysize(event.text.text));
        posted = (SDL_PushEvent(&event) > 0);
    }
    return (posted);
}

References SDL_Keyboard::focus, SDL_Window::id, SDL_arraysize, SDL_ENABLE, SDL_GetEventState, SDL_keyboard, SDL_PushEvent, SDL_TEXTINPUT, SDL_utf8strlcpy, and text.

Referenced by SDL_BApp::_HandleKey(), and DBus_MessageFilter().

SDL_SetKeyboardFocus()

void SDL_SetKeyboardFocus

(

SDL_Window *

window

)

Definition at line 634 of file SDL_keyboard.c.

{
    SDL_Keyboard *keyboard = &SDL_keyboard;
 
    if (keyboard->focus && !window) {
        /* We won't get anymore keyboard messages, so reset keyboard state */
        SDL_ResetKeyboard();
    }
 
    /* See if the current window has lost focus */
    if (keyboard->focus && keyboard->focus != window) {
 
        /* new window shouldn't think it has mouse captured. */
        SDL_assert(!window || !(window->flags & SDL_WINDOW_MOUSE_CAPTURE));
 
        /* old window must lose an existing mouse capture. */
        if (keyboard->focus->flags & SDL_WINDOW_MOUSE_CAPTURE) {
            SDL_CaptureMouse(SDL_FALSE);  /* drop the capture. */
            SDL_assert(!(keyboard->focus->flags & SDL_WINDOW_MOUSE_CAPTURE));
        }
 
        SDL_SendWindowEvent(keyboard->focus, SDL_WINDOWEVENT_FOCUS_LOST,
                            0, 0);
 
        /* Ensures IME compositions are committed */
        if (SDL_EventState(SDL_TEXTINPUT, SDL_QUERY)) {
            SDL_VideoDevice *video = SDL_GetVideoDevice();
            if (video && video->StopTextInput) {
                video->StopTextInput(video);
            }
        }
    }
 
    keyboard->focus = window;
 
    if (keyboard->focus) {
        SDL_SendWindowEvent(keyboard->focus, SDL_WINDOWEVENT_FOCUS_GAINED,
                            0, 0);
 
        if (SDL_EventState(SDL_TEXTINPUT, SDL_QUERY)) {
            SDL_VideoDevice *video = SDL_GetVideoDevice();
            if (video && video->StartTextInput) {
                video->StartTextInput(video);
            }
        }
    }
}

References SDL_Window::flags, SDL_Keyboard::focus, SDL_assert, SDL_CaptureMouse, SDL_EventState, SDL_FALSE, SDL_GetVideoDevice(), SDL_keyboard, SDL_QUERY, SDL_ResetKeyboard(), SDL_SendWindowEvent(), SDL_TEXTINPUT, SDL_WINDOW_MOUSE_CAPTURE, SDL_WINDOWEVENT_FOCUS_GAINED, SDL_WINDOWEVENT_FOCUS_LOST, SDL_VideoDevice::StartTextInput, and SDL_VideoDevice::StopTextInput.

Referenced by SDL_BApp::_HandleKeyboardFocus(), and SDL_DestroyWindow().

SDL_SetKeymap()

void SDL_SetKeymap	(	int	start,
		SDL_Keycode *	keys,
		int	length
	)

Definition at line 598 of file SDL_keyboard.c.

{
    SDL_Keyboard *keyboard = &SDL_keyboard;
    SDL_Scancode scancode;
 
    if (start < 0 || start + length > SDL_NUM_SCANCODES) {
        return;
    }
 
    SDL_memcpy(&keyboard->keymap[start], keys, sizeof(*keys) * length);
 
    /* The number key scancodes always map to the number key keycodes.
     * On AZERTY layouts these technically are symbols, but users (and games)
     * always think of them and view them in UI as number keys.
     */
    keyboard->keymap[SDL_SCANCODE_0] = SDLK_0;
    for (scancode = SDL_SCANCODE_1; scancode <= SDL_SCANCODE_9; ++scancode) {
        keyboard->keymap[scancode] = SDLK_1 + (scancode - SDL_SCANCODE_1);
    }
}

References SDL_Keyboard::keymap, SDL_keyboard, SDL_memcpy, SDL_NUM_SCANCODES, SDL_SCANCODE_0, SDL_SCANCODE_1, SDL_SCANCODE_9, SDLK_0, and SDLK_1.

SDL_SetModState()

void SDL_SetModState

(

SDL_Keymod

modstate

)

Set the current key modifier state for the keyboard.

Note

This does not change the keyboard state, only the key modifier flags.

Definition at line 915 of file SDL_keyboard.c.

{
    SDL_Keyboard *keyboard = &SDL_keyboard;
 
    keyboard->modstate = modstate;
}

References SDL_Keyboard::modstate, and SDL_keyboard.

SDL_SetScancodeName()

void SDL_SetScancodeName	(	SDL_Scancode	scancode,
		const char *	name
	)

Definition at line 620 of file SDL_keyboard.c.

{
    SDL_scancode_names[scancode] = name;
}

References SDL_scancode_names.

SDL_ToggleModState()

void SDL_ToggleModState	(	const SDL_Keymod	modstate,
		const SDL_bool	toggle
	)

Definition at line 924 of file SDL_keyboard.c.

{
    SDL_Keyboard *keyboard = &SDL_keyboard;
    if (toggle) {
        keyboard->modstate |= modstate;
    } else {
        keyboard->modstate &= ~modstate;
    }
}

References SDL_Keyboard::modstate, and SDL_keyboard.

SDL_UCS4ToUTF8()

char* SDL_UCS4ToUTF8	(	Uint32	ch,
		char *	dst
	)

Definition at line 524 of file SDL_keyboard.c.

{
    Uint8 *p = (Uint8 *) dst;
    if (ch <= 0x7F) {
        *p = (Uint8) ch;
        ++dst;
    } else if (ch <= 0x7FF) {
        p[0] = 0xC0 | (Uint8) ((ch >> 6) & 0x1F);
        p[1] = 0x80 | (Uint8) (ch & 0x3F);
        dst += 2;
    } else if (ch <= 0xFFFF) {
        p[0] = 0xE0 | (Uint8) ((ch >> 12) & 0x0F);
        p[1] = 0x80 | (Uint8) ((ch >> 6) & 0x3F);
        p[2] = 0x80 | (Uint8) (ch & 0x3F);
        dst += 3;
    } else if (ch <= 0x1FFFFF) {
        p[0] = 0xF0 | (Uint8) ((ch >> 18) & 0x07);
        p[1] = 0x80 | (Uint8) ((ch >> 12) & 0x3F);
        p[2] = 0x80 | (Uint8) ((ch >> 6) & 0x3F);
        p[3] = 0x80 | (Uint8) (ch & 0x3F);
        dst += 4;
    } else if (ch <= 0x3FFFFFF) {
        p[0] = 0xF8 | (Uint8) ((ch >> 24) & 0x03);
        p[1] = 0x80 | (Uint8) ((ch >> 18) & 0x3F);
        p[2] = 0x80 | (Uint8) ((ch >> 12) & 0x3F);
        p[3] = 0x80 | (Uint8) ((ch >> 6) & 0x3F);
        p[4] = 0x80 | (Uint8) (ch & 0x3F);
        dst += 5;
    } else {
        p[0] = 0xFC | (Uint8) ((ch >> 30) & 0x01);
        p[1] = 0x80 | (Uint8) ((ch >> 24) & 0x3F);
        p[2] = 0x80 | (Uint8) ((ch >> 18) & 0x3F);
        p[3] = 0x80 | (Uint8) ((ch >> 12) & 0x3F);
        p[4] = 0x80 | (Uint8) ((ch >> 6) & 0x3F);
        p[5] = 0x80 | (Uint8) (ch & 0x3F);
        dst += 6;
    }
    return dst;
}

Referenced by SDL_GetKeyName().

Variable Documentation

SDL_default_keymap

const SDL_Keycode SDL_default_keymap[SDL_NUM_SCANCODES]

static

Definition at line 53 of file SDL_keyboard.c.

Referenced by SDL_GetDefaultKeymap(), SDL_GetKeyFromName(), and SDL_KeyboardInit().

SDL_keyboard

SDL_Keyboard SDL_keyboard

static

Definition at line 51 of file SDL_keyboard.c.

Referenced by SDL_GetKeyboardFocus(), SDL_GetKeyboardState(), SDL_GetKeyFromScancode(), SDL_GetModState(), SDL_GetScancodeFromKey(), SDL_HardwareKeyboardKeyPressed(), SDL_KeyboardInit(), SDL_ReleaseAutoReleaseKeys(), SDL_ResetKeyboard(), SDL_SendEditingText(), SDL_SendKeyboardKeyInternal(), SDL_SendKeyboardText(), SDL_SetKeyboardFocus(), SDL_SetKeymap(), SDL_SetModState(), and SDL_ToggleModState().

SDL_scancode_names

const char* SDL_scancode_names[SDL_NUM_SCANCODES]

static

Definition at line 286 of file SDL_keyboard.c.

Referenced by SDL_GetScancodeFromName(), SDL_GetScancodeName(), and SDL_SetScancodeName().