xkeymap.c File Reference

#include <X11/Xlib.h>
#include <X11/keysym.h>
#include <ctype.h>
#include <limits.h>
#include <time.h>
#include <string.h>
#include "rdesktop.h"
#include "scancodes.h"

Include dependency graph for xkeymap.c:

Go to the source code of this file.

Macros
#define	KEYMAP_MASK   0xffff
#define	KEYMAP_MAX_LINE_LENGTH   80

Functions
static void	update_modifier_state (RDPCLIENT *This, uint8 scancode, BOOL pressed)
static void	free_key_translation (key_translation *ptr)
static void	add_to_keymap (RDPCLIENT *This, char *keyname, uint8 scancode, uint16 modifiers, char *mapname)
static void	add_sequence (RDPCLIENT *This, char *rest, char *mapname)
BOOL	xkeymap_from_locale (RDPCLIENT *This, const char *locale)
static char *	pathjoin (const char *a, const char *b)
FILE *	xkeymap_open (const char *filename)
static BOOL	xkeymap_read (RDPCLIENT *This, char *mapname)
void	xkeymap_init (RDPCLIENT *This)
static void	send_winkey (RDPCLIENT *This, uint32 ev_time, BOOL pressed, BOOL leftkey)
static void	reset_winkey (RDPCLIENT *This, uint32 ev_time)
BOOL	handle_special_keys (RDPCLIENT *This, uint32 keysym, unsigned int state, uint32 ev_time, BOOL pressed)
key_translation	xkeymap_translate_key (RDPCLIENT *This, uint32 keysym, unsigned int keycode, unsigned int state)
void	xkeymap_send_keys (RDPCLIENT *This, uint32 keysym, unsigned int keycode, unsigned int state, uint32 ev_time, BOOL pressed, uint8 nesting)
uint16	xkeymap_translate_button (unsigned int button)
char *	get_ksname (uint32 keysym)
static BOOL	is_modifier (uint8 scancode)
void	save_remote_modifiers (RDPCLIENT *This, uint8 scancode)
void	restore_remote_modifiers (RDPCLIENT *This, uint32 ev_time, uint8 scancode)
void	ensure_remote_modifiers (RDPCLIENT *This, uint32 ev_time, key_translation tr)
unsigned int	read_keyboard_state (RDPCLIENT *This)
uint16	ui_get_numlock_state (RDPCLIENT *This, unsigned int state)
void	reset_modifier_keys (RDPCLIENT *This)
void	rdp_send_scancode (RDPCLIENT *This, uint32 time, uint16 flags, uint8 scancode)

Macro Definition Documentation

KEYMAP_MASK

#define KEYMAP_MASK   0xffff

Definition at line 37 of file xkeymap.c.

KEYMAP_MAX_LINE_LENGTH

#define KEYMAP_MAX_LINE_LENGTH   80

Definition at line 38 of file xkeymap.c.

Function Documentation

add_sequence()

static void add_sequence ( RDPCLIENT *  This, char *  rest, char *  mapname  )

static

Definition at line 83 of file xkeymap.c.

{
    KeySym keysym;
    key_translation *tr, **prev_next;
    size_t chars;
    char keyname[KEYMAP_MAX_LINE_LENGTH];
 
    /* Skip over whitespace after the sequence keyword */
    chars = strspn(rest, " \t");
    rest += chars;
 
    /* Fetch the keysym name */
    chars = strcspn(rest, " \t\0");
    STRNCPY(keyname, rest, chars + 1);
    rest += chars;
 
    keysym = XStringToKeysym(keyname);
    if (keysym == NoSymbol)
    {
        DEBUG_KBD(("Bad keysym \"%s\" in keymap %s (ignoring line)\n", keyname, mapname));
        return;
    }
 
 
    DEBUG_KBD(("Adding sequence for keysym (0x%lx, %s) -> ", keysym, keyname));
 
    free_key_translation(This->xkeymap.keymap[keysym & KEYMAP_MASK]);
    prev_next = &This->xkeymap.keymap[keysym & KEYMAP_MASK];
 
    while (*rest)
    {
        /* Skip whitespace */
        chars = strspn(rest, " \t");
        rest += chars;
 
        /* Fetch the keysym name */
        chars = strcspn(rest, " \t\0");
        STRNCPY(keyname, rest, chars + 1);
        rest += chars;
 
        keysym = XStringToKeysym(keyname);
        if (keysym == NoSymbol)
        {
            DEBUG_KBD(("Bad keysym \"%s\" in keymap %s (ignoring line)\n", keyname,
                   mapname));
            return;
        }
 
        /* Allocate space for key_translation structure */
        tr = (key_translation *) xmalloc(sizeof(key_translation));
        memset(tr, 0, sizeof(key_translation));
        *prev_next = tr;
        prev_next = &tr->next;
        tr->seq_keysym = keysym;
 
        DEBUG_KBD(("0x%x, ", (unsigned int) keysym));
    }
    DEBUG_KBD(("\n"));
}

Referenced by xkeymap_read().

add_to_keymap()

static void add_to_keymap ( RDPCLIENT *  This, char *  keyname, uint8  scancode, uint16  modifiers, char *  mapname  )

static

Definition at line 57 of file xkeymap.c.

{
    KeySym keysym;
    key_translation *tr;
 
    keysym = XStringToKeysym(keyname);
    if (keysym == NoSymbol)
    {
        DEBUG_KBD(("Bad keysym \"%s\" in keymap %s (ignoring)\n", keyname, mapname));
        return;
    }
 
    DEBUG_KBD(("Adding translation, keysym=0x%x, scancode=0x%x, "
           "modifiers=0x%x\n", (unsigned int) keysym, scancode, modifiers));
 
    tr = (key_translation *) xmalloc(sizeof(key_translation));
    memset(tr, 0, sizeof(key_translation));
    tr->scancode = scancode;
    tr->modifiers = modifiers;
    free_key_translation(This->xkeymap.keymap[keysym & KEYMAP_MASK]);
    This->xkeymap.keymap[keysym & KEYMAP_MASK] = tr;
 
    return;
}

Referenced by xkeymap_read().

ensure_remote_modifiers()

void ensure_remote_modifiers	(	RDPCLIENT *	This,
		uint32	ev_time,
		key_translation	tr
	)

Definition at line 790 of file xkeymap.c.

{
    /* If this key is a modifier, do nothing */
    if (is_modifier(tr.scancode))
        return;
 
    if (!This->numlock_sync)
    {
        /* NumLock */
        if (MASK_HAS_BITS(tr.modifiers, MapNumLockMask)
            != MASK_HAS_BITS(This->xkeymap.remote_modifier_state, MapNumLockMask))
        {
            /* The remote modifier state is not correct */
            uint16 new_remote_state;
 
            if (MASK_HAS_BITS(tr.modifiers, MapNumLockMask))
            {
                DEBUG_KBD(("Remote NumLock state is incorrect, activating NumLock.\n"));
                new_remote_state = KBD_FLAG_NUMLOCK;
                This->xkeymap.remote_modifier_state = MapNumLockMask;
            }
            else
            {
                DEBUG_KBD(("Remote NumLock state is incorrect, deactivating NumLock.\n"));
                new_remote_state = 0;
                This->xkeymap.remote_modifier_state = 0;
            }
 
            rdp_send_input(This, 0, RDP_INPUT_SYNCHRONIZE, 0, new_remote_state, 0);
        }
    }
 
 
    /* Shift. Left shift and right shift are treated as equal; either is fine. */
    if (MASK_HAS_BITS(tr.modifiers, MapShiftMask)
        != MASK_HAS_BITS(This->xkeymap.remote_modifier_state, MapShiftMask))
    {
        /* The remote modifier state is not correct */
        if (MASK_HAS_BITS(tr.modifiers, MapLeftShiftMask))
        {
            /* Needs left shift. Send down. */
            rdp_send_scancode(This, ev_time, RDP_KEYPRESS, SCANCODE_CHAR_LSHIFT);
        }
        else if (MASK_HAS_BITS(tr.modifiers, MapRightShiftMask))
        {
            /* Needs right shift. Send down. */
            rdp_send_scancode(This, ev_time, RDP_KEYPRESS, SCANCODE_CHAR_RSHIFT);
        }
        else
        {
            /* Should not use this modifier. Send up for shift currently pressed. */
            if (MASK_HAS_BITS(This->xkeymap.remote_modifier_state, MapLeftShiftMask))
                /* Left shift is down */
                rdp_send_scancode(This, ev_time, RDP_KEYRELEASE, SCANCODE_CHAR_LSHIFT);
            else
                /* Right shift is down */
                rdp_send_scancode(This, ev_time, RDP_KEYRELEASE, SCANCODE_CHAR_RSHIFT);
        }
    }
 
    /* AltGr */
    if (MASK_HAS_BITS(tr.modifiers, MapAltGrMask)
        != MASK_HAS_BITS(This->xkeymap.remote_modifier_state, MapAltGrMask))
    {
        /* The remote modifier state is not correct */
        if (MASK_HAS_BITS(tr.modifiers, MapAltGrMask))
        {
            /* Needs this modifier. Send down. */
            rdp_send_scancode(This, ev_time, RDP_KEYPRESS, SCANCODE_CHAR_RALT);
        }
        else
        {
            /* Should not use this modifier. Send up. */
            rdp_send_scancode(This, ev_time, RDP_KEYRELEASE, SCANCODE_CHAR_RALT);
        }
    }
 
 
}

Referenced by restore_remote_modifiers(), and xkeymap_send_keys().

free_key_translation()

static void free_key_translation ( key_translation *  ptr )

static

Definition at line 44 of file xkeymap.c.

{
    key_translation *next;
 
    while (ptr)
    {
        next = ptr->next;
        xfree(ptr);
        ptr = next;
    }
}

Referenced by add_sequence(), and add_to_keymap().

get_ksname()

char * get_ksname

(

uint32

keysym

)

Definition at line 734 of file xkeymap.c.

{
    char *ksname = NULL;
 
    if (keysym == NoSymbol)
        ksname = "NoSymbol";
    else if (!(ksname = XKeysymToString(keysym)))
        ksname = "(no name)";
 
    return ksname;
}

Referenced by xkeymap_translate_key(), and xwin_process_events().

handle_special_keys()

BOOL handle_special_keys	(	RDPCLIENT *	This,
		uint32	keysym,
		unsigned int	state,
		uint32	ev_time,
		BOOL	pressed
	)

Definition at line 489 of file xkeymap.c.

{
    switch (keysym)
    {
        case XK_Return:
            if ((get_key_state(This, state, XK_Alt_L) || get_key_state(This, state, XK_Alt_R))
                && (get_key_state(This, state, XK_Control_L)
                || get_key_state(This, state, XK_Control_R)))
            {
                /* Ctrl-Alt-Enter: toggle full screen */
                if (pressed)
                    xwin_toggle_fullscreen(This);
                return True;
            }
            break;
 
        case XK_Break:
            /* Send Break sequence E0 46 E0 C6 */
            if (pressed)
            {
                rdp_send_scancode(This, ev_time, RDP_KEYPRESS,
                          (SCANCODE_EXTENDED | 0x46));
                rdp_send_scancode(This, ev_time, RDP_KEYPRESS,
                          (SCANCODE_EXTENDED | 0xc6));
            }
            /* No release sequence */
            return True;
            break;
 
        case XK_Pause:
            /* According to MS Keyboard Scan Code
               Specification, pressing Pause should result
               in E1 1D 45 E1 9D C5. I'm not exactly sure
               of how this is supposed to be sent via
               RDP. The code below seems to work, but with
               the side effect that Left Ctrl stays
               down. Therefore, we release it when Pause
               is released. */
            if (pressed)
            {
                rdp_send_input(This, ev_time, RDP_INPUT_SCANCODE, RDP_KEYPRESS, 0xe1, 0);
                rdp_send_input(This, ev_time, RDP_INPUT_SCANCODE, RDP_KEYPRESS, 0x1d, 0);
                rdp_send_input(This, ev_time, RDP_INPUT_SCANCODE, RDP_KEYPRESS, 0x45, 0);
                rdp_send_input(This, ev_time, RDP_INPUT_SCANCODE, RDP_KEYPRESS, 0xe1, 0);
                rdp_send_input(This, ev_time, RDP_INPUT_SCANCODE, RDP_KEYPRESS, 0x9d, 0);
                rdp_send_input(This, ev_time, RDP_INPUT_SCANCODE, RDP_KEYPRESS, 0xc5, 0);
            }
            else
            {
                /* Release Left Ctrl */
                rdp_send_input(This, ev_time, RDP_INPUT_SCANCODE, RDP_KEYRELEASE,
                           0x1d, 0);
            }
            return True;
            break;
 
        case XK_Meta_L: /* Windows keys */
        case XK_Super_L:
        case XK_Hyper_L:
            send_winkey(This, ev_time, pressed, True);
            return True;
            break;
 
        case XK_Meta_R:
        case XK_Super_R:
        case XK_Hyper_R:
            send_winkey(This, ev_time, pressed, False);
            return True;
            break;
 
        case XK_space:
            /* Prevent access to the Windows system menu in single app mode */
            if (This->win_button_size
                && (get_key_state(This, state, XK_Alt_L) || get_key_state(This, state, XK_Alt_R)))
                return True;
            break;
 
        case XK_Num_Lock:
            /* Synchronize on key release */
            if (This->numlock_sync && !pressed)
                rdp_send_input(This, 0, RDP_INPUT_SYNCHRONIZE, 0,
                           ui_get_numlock_state(This, read_keyboard_state(This)), 0);
 
            /* Inhibit */
            return True;
            break;
        case XK_Overlay1_Enable:
            /* Toggle SeamlessRDP */
            if (pressed)
                ui_seamless_toggle(This);
            break;
 
    }
    return False;
}

is_modifier()

static BOOL is_modifier ( uint8  scancode )

static

Definition at line 747 of file xkeymap.c.

{
    switch (scancode)
    {
        case SCANCODE_CHAR_LSHIFT:
        case SCANCODE_CHAR_RSHIFT:
        case SCANCODE_CHAR_LCTRL:
        case SCANCODE_CHAR_RCTRL:
        case SCANCODE_CHAR_LALT:
        case SCANCODE_CHAR_RALT:
        case SCANCODE_CHAR_LWIN:
        case SCANCODE_CHAR_RWIN:
        case SCANCODE_CHAR_NUMLOCK:
            return True;
        default:
            break;
    }
    return False;
}

Referenced by ensure_remote_modifiers(), restore_remote_modifiers(), and save_remote_modifiers().

pathjoin()

static char * pathjoin ( const char *  a, const char *  b  )

static

Definition at line 202 of file xkeymap.c.

{
    char *result;
    result = xmalloc(PATH_MAX * 2 + 1);
 
    if (b[0] == '/')
    {
        strncpy(result, b, PATH_MAX);
    }
    else
    {
        strncpy(result, a, PATH_MAX);
        strcat(result, "/");
        strncat(result, b, PATH_MAX);
    }
    return result;
}

Referenced by xkeymap_open().

rdp_send_scancode()

void rdp_send_scancode	(	RDPCLIENT *	This,
		uint32	time,
		uint16	flags,
		uint8	scancode
	)

Definition at line 1001 of file xkeymap.c.

{
    update_modifier_state(This, scancode, !(flags & RDP_KEYRELEASE));
 
    if (scancode & SCANCODE_EXTENDED)
    {
        DEBUG_KBD(("Sending extended scancode=0x%x, flags=0x%x\n",
               scancode & ~SCANCODE_EXTENDED, flags));
        rdp_send_input(This, time, RDP_INPUT_SCANCODE, flags | KBD_FLAG_EXT,
                   scancode & ~SCANCODE_EXTENDED, 0);
    }
    else
    {
        DEBUG_KBD(("Sending scancode=0x%x, flags=0x%x\n", scancode, flags));
        rdp_send_input(This, time, RDP_INPUT_SCANCODE, flags, scancode, 0);
    }
}

Referenced by ensure_remote_modifiers(), handle_special_keys(), reset_modifier_keys(), reset_winkey(), send_winkey(), and xkeymap_send_keys().

read_keyboard_state()

unsigned int read_keyboard_state

(

RDPCLIENT *

This

)

Definition at line 872 of file xkeymap.c.

{
#ifdef RDP2VNC
    return 0;
#else
    unsigned int state;
    Window wdummy;
    int dummy;
 
    XQueryPointer(This->display, This->wnd, &wdummy, &wdummy, &dummy, &dummy, &dummy, &dummy, &state);
    return state;
#endif
}

reset_modifier_keys()

void reset_modifier_keys

(

RDPCLIENT *

This

)

Definition at line 900 of file xkeymap.c.

{
    unsigned int state = read_keyboard_state(This);
 
    /* reset keys */
    uint32 ev_time;
    ev_time = time(NULL);
 
    if (MASK_HAS_BITS(This->xkeymap.remote_modifier_state, MapLeftShiftMask)
        && !get_key_state(This, state, XK_Shift_L))
        rdp_send_scancode(This, ev_time, RDP_KEYRELEASE, SCANCODE_CHAR_LSHIFT);
 
    if (MASK_HAS_BITS(This->xkeymap.remote_modifier_state, MapRightShiftMask)
        && !get_key_state(This, state, XK_Shift_R))
        rdp_send_scancode(This, ev_time, RDP_KEYRELEASE, SCANCODE_CHAR_RSHIFT);
 
    if (MASK_HAS_BITS(This->xkeymap.remote_modifier_state, MapLeftCtrlMask)
        && !get_key_state(This, state, XK_Control_L))
        rdp_send_scancode(This, ev_time, RDP_KEYRELEASE, SCANCODE_CHAR_LCTRL);
 
    if (MASK_HAS_BITS(This->xkeymap.remote_modifier_state, MapRightCtrlMask)
        && !get_key_state(This, state, XK_Control_R))
        rdp_send_scancode(This, ev_time, RDP_KEYRELEASE, SCANCODE_CHAR_RCTRL);
 
    if (MASK_HAS_BITS(This->xkeymap.remote_modifier_state, MapLeftAltMask) && !get_key_state(This, state, XK_Alt_L))
        rdp_send_scancode(This, ev_time, RDP_KEYRELEASE, SCANCODE_CHAR_LALT);
 
    if (MASK_HAS_BITS(This->xkeymap.remote_modifier_state, MapRightAltMask) &&
        !get_key_state(This, state, XK_Alt_R) && !get_key_state(This, state, XK_Mode_switch)
        && !get_key_state(This, state, XK_ISO_Level3_Shift))
        rdp_send_scancode(This, ev_time, RDP_KEYRELEASE, SCANCODE_CHAR_RALT);
 
    reset_winkey(This, ev_time);
 
    if (This->numlock_sync)
        rdp_send_input(This, ev_time, RDP_INPUT_SYNCHRONIZE, 0, ui_get_numlock_state(This, state), 0);
}

reset_winkey()

static void reset_winkey ( RDPCLIENT *  This, uint32  ev_time  )

static

Definition at line 477 of file xkeymap.c.

{
    if (This->use_rdp5)
    {
        /* For some reason, it seems to suffice to release
         *either* the left or right winkey. */
        rdp_send_scancode(This, ev_time, RDP_KEYRELEASE, SCANCODE_CHAR_LWIN);
    }
}

Referenced by reset_modifier_keys().

restore_remote_modifiers()

void restore_remote_modifiers	(	RDPCLIENT *	This,
		uint32	ev_time,
		uint8	scancode
	)

Definition at line 777 of file xkeymap.c.

{
    key_translation dummy;
 
    if (is_modifier(scancode))
        return;
 
    dummy.scancode = 0;
    dummy.modifiers = This->xkeymap.saved_remote_modifier_state;
    ensure_remote_modifiers(This, ev_time, dummy);
}

Referenced by xkeymap_send_keys().

save_remote_modifiers()

void save_remote_modifiers	(	RDPCLIENT *	This,
		uint8	scancode
	)

Definition at line 768 of file xkeymap.c.

{
    if (is_modifier(scancode))
        return;
 
    This->xkeymap.saved_remote_modifier_state = This->xkeymap.remote_modifier_state;
}

Referenced by xkeymap_send_keys().

send_winkey()

static void send_winkey ( RDPCLIENT *  This, uint32  ev_time, BOOL  pressed, BOOL  leftkey  )

static

Definition at line 439 of file xkeymap.c.

{
    uint8 winkey;
 
    if (leftkey)
        winkey = SCANCODE_CHAR_LWIN;
    else
        winkey = SCANCODE_CHAR_RWIN;
 
    if (pressed)
    {
        if (This->use_rdp5)
        {
            rdp_send_scancode(This, ev_time, RDP_KEYPRESS, winkey);
        }
        else
        {
            /* RDP4 doesn't support winkey. Fake with Ctrl-Esc */
            rdp_send_scancode(This, ev_time, RDP_KEYPRESS, SCANCODE_CHAR_LCTRL);
            rdp_send_scancode(This, ev_time, RDP_KEYPRESS, SCANCODE_CHAR_ESC);
        }
    }
    else
    {
        /* key released */
        if (This->use_rdp5)
        {
            rdp_send_scancode(This, ev_time, RDP_KEYRELEASE, winkey);
        }
        else
        {
            rdp_send_scancode(This, ev_time, RDP_KEYRELEASE, SCANCODE_CHAR_ESC);
            rdp_send_scancode(This, ev_time, RDP_KEYRELEASE, SCANCODE_CHAR_LCTRL);
        }
    }
}

Referenced by handle_special_keys().

ui_get_numlock_state()

uint16 ui_get_numlock_state	(	RDPCLIENT *	This,
		unsigned int	state
	)

Definition at line 888 of file xkeymap.c.

{
    uint16 numlock_state = 0;
 
    if (get_key_state(This, state, XK_Num_Lock))
        numlock_state = KBD_FLAG_NUMLOCK;
 
    return numlock_state;
}

Referenced by handle_special_keys(), and reset_modifier_keys().

update_modifier_state()

static void update_modifier_state ( RDPCLIENT *  This, uint8  scancode, BOOL  pressed  )

static

Definition at line 940 of file xkeymap.c.

{
#ifdef WITH_DEBUG_KBD
    uint16 old_modifier_state;
 
    old_modifier_state = This->xkeymap.remote_modifier_state;
#endif
 
    switch (scancode)
    {
        case SCANCODE_CHAR_LSHIFT:
            MASK_CHANGE_BIT(This->xkeymap.remote_modifier_state, MapLeftShiftMask, pressed);
            break;
        case SCANCODE_CHAR_RSHIFT:
            MASK_CHANGE_BIT(This->xkeymap.remote_modifier_state, MapRightShiftMask, pressed);
            break;
        case SCANCODE_CHAR_LCTRL:
            MASK_CHANGE_BIT(This->xkeymap.remote_modifier_state, MapLeftCtrlMask, pressed);
            break;
        case SCANCODE_CHAR_RCTRL:
            MASK_CHANGE_BIT(This->xkeymap.remote_modifier_state, MapRightCtrlMask, pressed);
            break;
        case SCANCODE_CHAR_LALT:
            MASK_CHANGE_BIT(This->xkeymap.remote_modifier_state, MapLeftAltMask, pressed);
            break;
        case SCANCODE_CHAR_RALT:
            MASK_CHANGE_BIT(This->xkeymap.remote_modifier_state, MapRightAltMask, pressed);
            break;
        case SCANCODE_CHAR_LWIN:
            MASK_CHANGE_BIT(This->xkeymap.remote_modifier_state, MapLeftWinMask, pressed);
            break;
        case SCANCODE_CHAR_RWIN:
            MASK_CHANGE_BIT(This->xkeymap.remote_modifier_state, MapRightWinMask, pressed);
            break;
        case SCANCODE_CHAR_NUMLOCK:
            /* KeyReleases for NumLocks are sent immediately. Toggle the
               modifier state only on Keypress */
            if (pressed && !This->numlock_sync)
            {
                BOOL newNumLockState;
                newNumLockState =
                    (MASK_HAS_BITS
                     (This->xkeymap.remote_modifier_state, MapNumLockMask) == False);
                MASK_CHANGE_BIT(This->xkeymap.remote_modifier_state,
                        MapNumLockMask, newNumLockState);
            }
    }
 
#ifdef WITH_DEBUG_KBD
    if (old_modifier_state != This->xkeymap.remote_modifier_state)
    {
        DEBUG_KBD(("Before updating modifier_state:0x%x, pressed=0x%x\n",
               old_modifier_state, pressed));
        DEBUG_KBD(("After updating modifier_state:0x%x\n", This->xkeymap.remote_modifier_state));
    }
#endif
 
}

Referenced by rdp_send_scancode().

xkeymap_from_locale()

BOOL xkeymap_from_locale	(	RDPCLIENT *	This,
		const char *	locale
	)

Definition at line 144 of file xkeymap.c.

{
    char *str, *ptr;
    FILE *fp;
 
    /* Create a working copy */
    str = xstrdup(locale);
 
    /* Truncate at dot and at */
    ptr = strrchr(str, '.');
    if (ptr)
        *ptr = '\0';
    ptr = strrchr(str, '@');
    if (ptr)
        *ptr = '\0';
 
    /* Replace _ with - */
    ptr = strrchr(str, '_');
    if (ptr)
        *ptr = '-';
 
    /* Convert to lowercase */
    ptr = str;
    while (*ptr)
    {
        *ptr = tolower((int) *ptr);
        ptr++;
    }
 
    /* Try to open this keymap (da-dk) */
    fp = xkeymap_open(str);
    if (fp == NULL)
    {
        /* Truncate at dash */
        ptr = strrchr(str, '-');
        if (ptr)
            *ptr = '\0';
 
        /* Try the short name (da) */
        fp = xkeymap_open(str);
    }
 
    if (fp)
    {
        fclose(fp);
        STRNCPY(This->keymapname, str, sizeof(This->keymapname));
        xfree(str);
        return True;
    }
 
    xfree(str);
    return False;
}

xkeymap_init()

void xkeymap_init

(

RDPCLIENT *

This

)

Definition at line 425 of file xkeymap.c.

{
    unsigned int max_keycode;
 
    if (strcmp(This->keymapname, "none"))
    {
        if (xkeymap_read(This, This->keymapname))
            This->xkeymap.keymap_loaded = True;
    }
 
    XDisplayKeycodes(This->display, &This->xkeymap.min_keycode, (int *) &max_keycode);
}

xkeymap_open()

FILE * xkeymap_open

(

const char *

filename

)

Definition at line 222 of file xkeymap.c.

{
    char *path1, *path2;
    char *home;
    FILE *fp;
 
    /* Try ~/.rdesktop/keymaps */
    home = getenv("HOME");
    if (home)
    {
        path1 = pathjoin(home, ".rdesktop/keymaps");
        path2 = pathjoin(path1, filename);
        xfree(path1);
        fp = fopen(path2, "r");
        xfree(path2);
        if (fp)
            return fp;
    }
 
    /* Try KEYMAP_PATH */
    path1 = pathjoin(KEYMAP_PATH, filename);
    fp = fopen(path1, "r");
    xfree(path1);
    if (fp)
        return fp;
 
    /* Try current directory, in case we are running from the source
       tree */
    path1 = pathjoin("keymaps", filename);
    fp = fopen(path1, "r");
    xfree(path1);
    if (fp)
        return fp;
 
    return NULL;
}

Referenced by xkeymap_from_locale(), and xkeymap_read().

xkeymap_read()

static BOOL xkeymap_read ( RDPCLIENT *  This, char *  mapname  )

static

Definition at line 260 of file xkeymap.c.

{
    FILE *fp;
    char line[KEYMAP_MAX_LINE_LENGTH];
    unsigned int line_num = 0;
    unsigned int line_length = 0;
    char *keyname, *p;
    char *line_rest;
    uint8 scancode;
    uint16 modifiers;
 
    fp = xkeymap_open(mapname);
    if (fp == NULL)
    {
        error("Failed to open keymap %s\n", mapname);
        return False;
    }
 
    /* FIXME: More tolerant on white space */
    while (fgets(line, sizeof(line), fp) != NULL)
    {
        line_num++;
 
        /* Replace the \n with \0 */
        p = strchr(line, '\n');
        if (p != NULL)
            *p = 0;
 
        line_length = strlen(line);
 
        /* Completely empty line */
        if (strspn(line, " \t\n\r\f\v") == line_length)
        {
            continue;
        }
 
        /* Include */
        if (str_startswith(line, "include "))
        {
            if (!xkeymap_read(This, line + sizeof("include ") - 1))
                return False;
            continue;
        }
 
        /* map */
        if (str_startswith(line, "map "))
        {
            This->keylayout = strtoul(line + sizeof("map ") - 1, NULL, 16);
            DEBUG_KBD(("Keylayout 0x%x\n", This->keylayout));
            continue;
        }
 
        /* compose */
        if (str_startswith(line, "enable_compose"))
        {
            DEBUG_KBD(("Enabling compose handling\n"));
            This->enable_compose = True;
            continue;
        }
 
        /* sequence */
        if (str_startswith(line, "sequence"))
        {
            add_sequence(This, line + sizeof("sequence") - 1, mapname);
            continue;
        }
 
        /* keyboard_type */
        if (str_startswith(line, "keyboard_type "))
        {
            This->keyboard_type = strtol(line + sizeof("keyboard_type ") - 1, NULL, 16);
            DEBUG_KBD(("keyboard_type 0x%x\n", This->keyboard_type));
            continue;
        }
 
        /* keyboard_subtype */
        if (str_startswith(line, "keyboard_subtype "))
        {
            This->keyboard_subtype =
                strtol(line + sizeof("keyboard_subtype ") - 1, NULL, 16);
            DEBUG_KBD(("keyboard_subtype 0x%x\n", This->keyboard_subtype));
            continue;
        }
 
        /* keyboard_functionkeys */
        if (str_startswith(line, "keyboard_functionkeys "))
        {
            This->keyboard_functionkeys =
                strtol(line + sizeof("keyboard_functionkeys ") - 1, NULL, 16);
            DEBUG_KBD(("keyboard_functionkeys 0x%x\n", This->keyboard_functionkeys));
            continue;
        }
 
        /* Comment */
        if (line[0] == '#')
        {
            continue;
        }
 
        /* Normal line */
        keyname = line;
        p = strchr(line, ' ');
        if (p == NULL)
        {
            error("Bad line %d in keymap %s\n", line_num, mapname);
            continue;
        }
        else
        {
            *p = 0;
        }
 
        /* scancode */
        p++;
        scancode = strtol(p, &line_rest, 16);
 
        /* flags */
        /* FIXME: Should allow case-insensitive flag names.
           Fix by using lex+yacc... */
        modifiers = 0;
        if (strstr(line_rest, "altgr"))
        {
            MASK_ADD_BITS(modifiers, MapAltGrMask);
        }
 
        if (strstr(line_rest, "shift"))
        {
            MASK_ADD_BITS(modifiers, MapLeftShiftMask);
        }
 
        if (strstr(line_rest, "numlock"))
        {
            MASK_ADD_BITS(modifiers, MapNumLockMask);
        }
 
        if (strstr(line_rest, "localstate"))
        {
            MASK_ADD_BITS(modifiers, MapLocalStateMask);
        }
 
        if (strstr(line_rest, "inhibit"))
        {
            MASK_ADD_BITS(modifiers, MapInhibitMask);
        }
 
        add_to_keymap(This, keyname, scancode, modifiers, mapname);
 
        if (strstr(line_rest, "addupper"))
        {
            /* Automatically add uppercase key, with same modifiers
               plus shift */
            for (p = keyname; *p; p++)
                *p = toupper((int) *p);
            MASK_ADD_BITS(modifiers, MapLeftShiftMask);
            add_to_keymap(This, keyname, scancode, modifiers, mapname);
        }
    }
 
    fclose(fp);
    return True;
}

Referenced by xkeymap_init(), and xkeymap_read().

xkeymap_send_keys()

void xkeymap_send_keys	(	RDPCLIENT *	This,
		uint32	keysym,
		unsigned int	keycode,
		unsigned int	state,
		uint32	ev_time,
		BOOL	pressed,
		uint8	nesting
	)

Definition at line 664 of file xkeymap.c.

{
    key_translation tr, *ptr;
    tr = xkeymap_translate_key(This, keysym, keycode, state);
 
    if (tr.seq_keysym == 0)
    {
        /* Scancode translation */
        if (tr.scancode == 0)
            return;
 
        if (pressed)
        {
            save_remote_modifiers(This, tr.scancode);
            ensure_remote_modifiers(This, ev_time, tr);
            rdp_send_scancode(This, ev_time, RDP_KEYPRESS, tr.scancode);
            restore_remote_modifiers(This, ev_time, tr.scancode);
        }
        else
        {
            rdp_send_scancode(This, ev_time, RDP_KEYRELEASE, tr.scancode);
        }
        return;
    }
 
    /* Sequence, only on key down */
    if (pressed)
    {
        ptr = &tr;
        do
        {
            DEBUG_KBD(("Handling sequence element, keysym=0x%x\n",
                   (unsigned int) ptr->seq_keysym));
 
            if (nesting++ > 32)
            {
                error("Sequence nesting too deep\n");
                return;
            }
 
            xkeymap_send_keys(This, ptr->seq_keysym, keycode, state, ev_time, True, nesting);
            xkeymap_send_keys(This, ptr->seq_keysym, keycode, state, ev_time, False, nesting);
            ptr = ptr->next;
        }
        while (ptr);
    }
}

Referenced by xkeymap_send_keys().

xkeymap_translate_button()

uint16 xkeymap_translate_button

(

unsigned int

button

)

Definition at line 714 of file xkeymap.c.

{
    switch (button)
    {
        case Button1:   /* left */
            return MOUSE_FLAG_BUTTON1;
        case Button2:   /* middle */
            return MOUSE_FLAG_BUTTON3;
        case Button3:   /* right */
            return MOUSE_FLAG_BUTTON2;
        case Button4:   /* wheel up */
            return MOUSE_FLAG_BUTTON4;
        case Button5:   /* wheel down */
            return MOUSE_FLAG_BUTTON5;
    }
 
    return 0;
}

Referenced by handle_button_event().

xkeymap_translate_key()

key_translation xkeymap_translate_key	(	RDPCLIENT *	This,
		uint32	keysym,
		unsigned int	keycode,
		unsigned int	state
	)

Definition at line 587 of file xkeymap.c.

{
    key_translation tr = { 0, 0, 0, 0 };
    key_translation *ptr;
 
    ptr = This->xkeymap.keymap[keysym & KEYMAP_MASK];
    if (ptr)
    {
        tr = *ptr;
        if (tr.seq_keysym == 0) /* Normal scancode translation */
        {
            if (MASK_HAS_BITS(tr.modifiers, MapInhibitMask))
            {
                DEBUG_KBD(("Inhibiting key\n"));
                tr.scancode = 0;
                return tr;
            }
 
            if (MASK_HAS_BITS(tr.modifiers, MapLocalStateMask))
            {
                /* The modifiers to send for this key should be obtained
                   from the local state. Currently, only shift is implemented. */
                if (MASK_HAS_BITS(state, ShiftMask))
                {
                    tr.modifiers = MapLeftShiftMask;
                }
            }
 
            /* Windows interprets CapsLock+Ctrl+key
               differently from Shift+Ctrl+key. Since we
               are simulating CapsLock with Shifts, things
               like Ctrl+f with CapsLock on breaks. To
               solve this, we are releasing Shift if Ctrl
               is on, but only if Shift isn't physically pressed. */
            if (MASK_HAS_BITS(tr.modifiers, MapShiftMask)
                && MASK_HAS_BITS(This->xkeymap.remote_modifier_state, MapCtrlMask)
                && !MASK_HAS_BITS(state, ShiftMask))
            {
                DEBUG_KBD(("Non-physical Shift + Ctrl pressed, releasing Shift\n"));
                MASK_REMOVE_BITS(tr.modifiers, MapShiftMask);
            }
 
            DEBUG_KBD(("Found scancode translation, scancode=0x%x, modifiers=0x%x\n",
                   tr.scancode, tr.modifiers));
        }
    }
    else
    {
        if (This->xkeymap.keymap_loaded)
            warning("No translation for (keysym 0x%lx, %s)\n", keysym,
                get_ksname(keysym));
 
        /* not in keymap, try to interpret the raw scancode */
        if (((int) keycode >= This->xkeymap.min_keycode) && (keycode <= 0x60))
        {
            tr.scancode = keycode - This->xkeymap.min_keycode;
 
            /* The modifiers to send for this key should be
               obtained from the local state. Currently, only
               shift is implemented. */
            if (MASK_HAS_BITS(state, ShiftMask))
            {
                tr.modifiers = MapLeftShiftMask;
            }
 
            DEBUG_KBD(("Sending guessed scancode 0x%x\n", tr.scancode));
        }
        else
        {
            DEBUG_KBD(("No good guess for keycode 0x%x found\n", keycode));
        }
    }
 
    return tr;
}

Referenced by xkeymap_send_keys().