Attachment #431597 for bug #400520

View | Details | Raw Unified | Return to bug 400520
Collapse All | Expand All




#define NEED_EVENTS
#include "X11/Xproto.h"
#include "inputstr.h"
#include "xkbsrv.h"
#include "xkbstr.h"
#define XK_CYRILLIC
#include <X11/keysym.h>
#include <X11/Xatom.h>

#endif

#define KEY_IS_PRESSED(keycode) \
    (inputInfo.keyboard->key->down[(keycode) >> 3] & (1 << ((keycode) & 7)))

static void vncXConvertCase(KeySym sym, KeySym *lower, KeySym *upper);

static DeviceIntPtr ptrDevice = NULL;


void
vncSetKeyboardDevice(DeviceIntPtr kbd)
{
  // obsoleted by inputInfo
      return; /* set once */
   kbdDevice = kbd;
}



      mieqEnqueue(kbdDev, (InternalEvent*)(events + i)->event);
}

/* In-server and highly changed version of XkbKeycodeToKeysym */
static KeySym
_XkbKeycodeToKeysym(XkbDescPtr xkb, KeyCode kc, int group, int level)
{
    KeySym ks;

    if ((kc<xkb->min_key_code)||(kc>xkb->max_key_code))
	return NoSymbol;
    /* Treat single group elements as present in all groups */
    if (XkbKeyNumGroups (xkb,kc) == 1)
	group = 0;
    if ((group<0)||(level<0)||(group>=XkbKeyNumGroups(xkb,kc)))
	return NoSymbol;
    if (level < XkbKeyGroupWidth(xkb, kc, group))
	ks = XkbKeySymEntry(xkb, kc, level, group);
    else
	ks = NoSymbol;
    /* Treat 'K' as 'K K', */
    if (ks == NoSymbol && (level & 1) && level-1 < XkbKeyGroupWidth(xkb, kc, group))
	ks = XkbKeySymEntry(xkb, kc, level-1, group);
    return ks;
}

/*
 * Called when the rfbserver receives a rfbKeyEvent event from a client.
 * Put an X keyboard event into the event queue.

KbdAddEvent(Bool down, KeySym keySym, rfbClientPtr cl)
{
    const int type = down ? KeyPress : KeyRelease;
    XkbSrvInfoPtr xkbInfo;
    int i, group, level;
    int i;
    int keyCode = 0;
    int freeIndex = -1;
    Bool fakeShiftPress = FALSE;
    Bool fakeShiftLRelease = FALSE;
    Bool fakeShiftRRelease = FALSE;
    Bool shiftMustBeReleased = FALSE;
    Bool shiftMustBePressed = FALSE;
    Bool fakeLevel3Press = FALSE;
    Bool fakeLevel3Release = FALSE;
    Bool level3MustBeReleased = FALSE;
    Bool level3MustBePressed = FALSE;

    /* Incomplete maps may create NoSymbol - which lets us
     * select and/or overwrite otherwise valid entries.
     * E.g Level3+a in serbian layout creates NoSymbol on os11.4
     * 2011-05-24 mhopf@suse.de */
    if (keySym == NoSymbol) {
	ErrorF("KbdAddEvent: ignoring illegal NoSymbol\n");
	return;
    }

    xkbInfo = inputInfo.keyboard->key->xkbInfo;
    group   = xkbInfo->state.group;
    level   = (KEY_IS_PRESSED(ISO_LEVEL3_KEY_CODE) ? 2 : 0) |
	      (XkbStateFieldFromRec(&xkbInfo->state) & ShiftMask ? 1 : 0);
#if 0
    ErrorF ("VNCkbd:\t%s Sym %04x\n", down ? "+":"-", (int)keySym);
#endif

#ifdef CORBA
    if (cl) {

     *
     * Alan.
     */
    /* Never use predefined keys.
     * This is inherently incapable of dealing with changing
     * keyboard layouts. Not being able to work with non-local xmodmaps
     * is a nuisance at worst, and probably even preferred.
     * 2011-04-15 mhopf@suse.de */
#if 0
#if !XFREE86VNC
    /* First check if it's one of our predefined keys.  If so then we can make
       some attempt at allowing an xmodmap inside a VNC desktop behave

	}
    }
#endif
#endif

    if (!keyCode) {

	/* not one of our predefined keys - see if it's in the current keyboard
           mapping (i.e. we've already allocated an extra keycode for it) */

	for (keyCode = MIN_KEY_CODE; keyCode < MIN_KEY_CODE + NO_OF_KEYS; keyCode++) {
	    /* Check all keycodes, but only continue on those where
	     * backconversion results in keySym.
	     * 2011-05-20 mhopf@suse.de */
	    int j;

#if 0
	    ErrorF ("   keyCode %3d map# %4d++ level %d of %d:  keySyms",
		    keyCode, (i / keySyms->mapWidth) * keySyms->mapWidth,
		    i % keySyms->mapWidth, keySyms->mapWidth);
	    for (j = 0; j < keySyms->mapWidth; j++)
		ErrorF (" %02x", (int)keySyms->map[(i / keySyms->mapWidth) * keySyms->mapWidth + j]);
	    ErrorF ("\n");
#endif
#if 0
	    ErrorF ("   group %d of %d width %d:  keySyms",
		    group, XkbKeyNumGroups(xkbInfo->desc, keyCode),
		    XkbKeyGroupWidth(xkbInfo->desc, keyCode, group));
	    if (XkbKeyNumGroups(xkbInfo->desc, keyCode) > group)
		for (j = 0; j < XkbKeyGroupWidth(xkbInfo->desc, keyCode, group); j++)
		    ErrorF (" %02x", (int) XkbKeySymEntry(xkbInfo->desc, keyCode, j, group));
	    ErrorF ("\n");
#endif

	    /* Check whether keySym is reachable in current group
	     * by any shift/Level3_shift state (preferrable w/o change).
	     * This doesn't do real modifyer analysis, only Shift and Level3_Shift.
	     * 2011-05-23 mhopf@suse.de */
	    if (_XkbKeycodeToKeysym(xkbInfo->desc, keyCode, group, level) == keySym)
		break;
	    if (_XkbKeycodeToKeysym(xkbInfo->desc, keyCode, group, level ^ 2) == keySym) {
		if (level & 2)
		    level3MustBeReleased = TRUE;
		else
		    level3MustBePressed = TRUE;
			shiftMustBeReleased = TRUE;
		    else
			shiftMustBePressed = TRUE;
		}
		break;
	    }
	    if (_XkbKeycodeToKeysym(xkbInfo->desc, keyCode, group, level ^ 1) == keySym) {
		if (level & 1)
		    shiftMustBeReleased = TRUE;
		else
		    shiftMustBePressed = TRUE;
		break;
	    }
	    if (_XkbKeycodeToKeysym(xkbInfo->desc, keyCode, group, level ^ 3) == keySym) {
		if (level & 2)
		    level3MustBeReleased = TRUE;
		else
		    level3MustBePressed = TRUE;
		if (level & 1)
		    shiftMustBeReleased = TRUE;
		else
		    shiftMustBePressed = TRUE;
		break;
	    }
	}
	if (keyCode == MIN_KEY_CODE + NO_OF_KEYS)
	    keyCode = 0;
    }

    if (!keyCode) {
	KeySym lower, upper;
	KeySymsPtr keySyms = XkbGetCoreMap(inputInfo.keyboard);

	/* we don't have an existing keycode - make one up on the fly and add
	   it to the keyboard mapping.  Thanks to Vlad Harchev for pointing
	   out problems with non-ascii capitalisation. */

	/* Find free index for current group. */
	for (keyCode = MIN_KEY_CODE; keyCode < MIN_KEY_CODE + NO_OF_KEYS; keyCode++) {
	    /* A keyCode is free if no groups are assigned at all */
	    if (XkbKeyNumGroups(xkbInfo->desc, keyCode) == 0)
		break;
#if 0
	    /* We can use exact map positions for group 1+2, but only partially
	     * filling out xkb legacy maps may suddenly change the # of groups.
	     * Reason for that is unknown yet. Might be related to (fixed) NoSymbol issue.
	     * 2011-05-24 mhopf@suse.de */
	    /* For primary groups: A keyCode is free if current group is empty */
	    if (XkbKeyGroupWidth(xkbInfo->desc, keyCode, group) < 1 && group < 2)
		break;
	    /* Never touch groups that have a single level only (weird group?!?) */
	    if (XkbKeyGroupWidth(xkbInfo->desc, keyCode, group) < 2)
		continue;
	    /* For primary groups: A keyCode is free if only NoSymbol is assigned
	     * to available levels (only validating levels 0-3) */
	    if (group < 2 &&
		XkbKeySymEntry(xkbInfo->desc, keyCode, 0, group) == NoSymbol &&
		XkbKeySymEntry(xkbInfo->desc, keyCode, 1, group) == NoSymbol &&
		(XkbKeyGroupWidth(xkbInfo->desc, keyCode, group) < 3 ||
		 (XkbKeySymEntry(xkbInfo->desc, keyCode, 2, group) == NoSymbol &&
		  (XkbKeyGroupWidth(xkbInfo->desc, keyCode, group) < 4 ||
		   XkbKeySymEntry(xkbInfo->desc, keyCode, 3, group) == NoSymbol))))
		break;
#endif
	}

	if (keyCode == MIN_KEY_CODE + NO_OF_KEYS) {
	    ErrorF("KbdAddEvent: ignoring KeySym 0x%x - no free KeyCodes\n",
		   (int)keySym);
	    free (keySyms->map);
	    free (keySyms);
	    return;
	}

	keyCode = MIN_KEY_CODE + freeIndex / keySyms->mapWidth;

	vncXConvertCase(keySym, &lower, &upper);

	/* Adding keys is not using xkb mechanisms yet, but relying on support
	 * for changing keys in the legacy map. Should be changed, eventually.
	 * 2011-05-19 mhopf@suse.de */
#if 0
	if (group < 2) {
	    /* Only set mapping for active group. Will only work with dual layouts.
	     * 2011-05-23 mhopf@suse.de */
	    int active_group_offset = group ? 2 : 0;

	    if (lower == upper) {
		keySyms->map[(keyCode - MIN_KEY_CODE) * keySyms->mapWidth + active_group_offset] = keySym;
		keySyms->map[(keyCode - MIN_KEY_CODE) * keySyms->mapWidth + active_group_offset + 1] = NoSymbol;
	    } else {
		keySyms->map[(keyCode - MIN_KEY_CODE) * keySyms->mapWidth + active_group_offset] = lower;
		keySyms->map[(keyCode - MIN_KEY_CODE) * keySyms->mapWidth + active_group_offset + 1] = upper;
	    }
	}
#endif
	/* Generic layouts needs to set the full map width.
	 * Weird enough, mapWidth seems too big...
	 * 2011-05-23 mhopf@suse.de */
	for (i = 0; i < (keySyms->mapWidth & ~1); i += 2) {
	    if (lower == upper) {
		keySyms->map[(keyCode - MIN_KEY_CODE) * keySyms->mapWidth + i]     = keySym;
		keySyms->map[(keyCode - MIN_KEY_CODE) * keySyms->mapWidth + i + 1] = NoSymbol;
	    } else {
		keySyms->map[(keyCode - MIN_KEY_CODE) * keySyms->mapWidth + i]     = lower;
		keySyms->map[(keyCode - MIN_KEY_CODE) * keySyms->mapWidth + i + 1] = upper;
	    }
	}
	if (lower != upper) {
	    if (keySym == lower)
		shiftMustBeReleased = TRUE;
	    else
		shiftMustBePressed = TRUE;
	}
	level3MustBeReleased = TRUE;

	XkbApplyMappingChange(inputInfo.keyboard, keySyms, keyCode, 1, NULL, serverClient);

	ErrorF("KbdAddEvent: unknown KeySym 0x%x - allocating KeyCode %d\n",
	       (int)keySym, keyCode);
	free (keySyms->map);
	free (keySyms);
    }

#if 0
    ErrorF ("\t%s Sym %04x Code%3d\tState x%02x %s%s%s\tSh %s%s\tL3 %s%s\n",
	    down ? "+":"-", (int)keySym, keyCode, XkbStateFieldFromRec(&xkbInfo->state),
	    KEY_IS_PRESSED(SHIFT_L_KEY_CODE) ? "Sl":"",
	    KEY_IS_PRESSED(SHIFT_R_KEY_CODE) ? "Sr":"",
	    KEY_IS_PRESSED(ISO_LEVEL3_KEY_CODE) ? "L3":"",
	    shiftMustBePressed ? "+":"", shiftMustBeReleased ? "-":"",
	    level3MustBePressed ? "+":"", level3MustBeReleased ? "-":"");
#endif
#if 0
    int back = _XkbKeycodeToKeysym (xkbInfo->desc, keyCode, group,
				    ((level3MustBePressed || (!level3MustBeReleased && (level & 2))) ? 2 : 0) |
				    ((shiftMustBePressed || (!shiftMustBeReleased && (level & 1))) ? 1 : 0));
    ErrorF ("\tvalidate code %d %-2s%-2s -> sym %04x %s\n\n", keyCode,
	    (shiftMustBePressed || (!shiftMustBeReleased && (level & 1)))   ? "Sh" : "",
	    (level3MustBePressed || (!level3MustBeReleased && (level & 2))) ? "L3" : "",
	    back, (back == keySym ? "ok" : "FAILED"));
#endif

    if (down) {
	/* TODO: would require to check which keycodes are actually
	 * bound to ISO_Level3_Shift and/or Shift_L.
	 * 2011-04-18 mhopf@suse.de */
	if (level3MustBePressed && !(level & 2)) {
	    fakeLevel3Press = TRUE;
	    EnqueueKey(inputInfo.keyboard, KeyPress, ISO_LEVEL3_KEY_CODE);
	}
	if (level3MustBeReleased && (level & 2)) {
	    fakeLevel3Release = TRUE;
	    EnqueueKey(inputInfo.keyboard, KeyRelease, ISO_LEVEL3_KEY_CODE);
	}
	if (shiftMustBePressed && !(level & 1)) {
	    fakeShiftPress = TRUE;
            EnqueueKey(inputInfo.keyboard, KeyPress, SHIFT_L_KEY_CODE);
	}
	if (shiftMustBeReleased && (level & 1)) {
	    if (KEY_IS_PRESSED(SHIFT_L_KEY_CODE)) {
		fakeShiftLRelease = TRUE;
                EnqueueKey(inputInfo.keyboard, KeyRelease, SHIFT_L_KEY_CODE);
	    }
	    if (KEY_IS_PRESSED(SHIFT_R_KEY_CODE)) {
		fakeShiftRRelease = TRUE;
                EnqueueKey(inputInfo.keyboard, KeyRelease, SHIFT_R_KEY_CODE);
	    }
	}
    }

    EnqueueKey(inputInfo.keyboard, type, keyCode);

    if (fakeShiftPress) {
        EnqueueKey(inputInfo.keyboard, KeyRelease, SHIFT_L_KEY_CODE);
    }
    if (fakeShiftLRelease) {
        EnqueueKey(inputInfo.keyboard, KeyPress, SHIFT_L_KEY_CODE);
    }
    if (fakeShiftRRelease) {
        EnqueueKey(inputInfo.keyboard, KeyPress, SHIFT_R_KEY_CODE);
    }
    if (fakeLevel3Press) {
        EnqueueKey(inputInfo.keyboard, KeyRelease, ISO_LEVEL3_KEY_CODE);
    }
    if (fakeLevel3Release) {
        EnqueueKey(inputInfo.keyboard, KeyPress, ISO_LEVEL3_KEY_CODE);
    }
}


{
    int i, j;

    if (!inputInfo.keyboard) 
	return;

    for (i = 0; i < DOWN_LENGTH; i++) {
	if (inputInfo.keyboard->key->down[i] != 0) {
	    for (j = 0; j < 8; j++) {
		if (inputInfo.keyboard->key->down[i] & (1 << j)) {
                    int detail = (i << 3) | j;
                    EnqueueKey(inputInfo.keyboard, KeyRelease, detail);
		}
	    }
	}

Lines 32-37 Link Here

(-)xorg-server-1.9.3/hw/vnc/keyboard.h (+1 lines)
32	#define META_R_KEY_CODE (MIN_KEY_CODE + 108)	32	#define META_R_KEY_CODE (MIN_KEY_CODE + 108)
33	#define ALT_L_KEY_CODE (MIN_KEY_CODE + 56)	33	#define ALT_L_KEY_CODE (MIN_KEY_CODE + 56)
34	#define ALT_R_KEY_CODE (MIN_KEY_CODE + 105)	34	#define ALT_R_KEY_CODE (MIN_KEY_CODE + 105)
		35	#define ISO_LEVEL3_KEY_CODE ALT_R_KEY_CODE
35		36
36	static KeySym map[MAX_KEY_CODE * GLYPHS_PER_KEY] = {	37	static KeySym map[MAX_KEY_CODE * GLYPHS_PER_KEY] = {
37	/* 0x00 */ NoSymbol, NoSymbol, NoSymbol, NoSymbol,	38	/* 0x00 */ NoSymbol, NoSymbol, NoSymbol, NoSymbol,

Return to bug 400520

Lines 33-38 Link Here

(-)xorg-server-1.9.3/hw/vnc/kbdptr.c (-62 / +227 lines)
33	#define NEED_EVENTS	33	#define NEED_EVENTS
34	#include "X11/Xproto.h"	34	#include "X11/Xproto.h"
35	#include "inputstr.h"	35	#include "inputstr.h"
		36	#include "xkbsrv.h"
		37	#include "xkbstr.h"
36	#define XK_CYRILLIC	38	#define XK_CYRILLIC
37	#include <X11/keysym.h>	39	#include <X11/keysym.h>
38	#include <X11/Xatom.h>	40	#include <X11/Xatom.h>
Lines 46-64 Link Here
46	#endif	48	#endif
47		49
48	#define KEY_IS_PRESSED(keycode) \	50	#define KEY_IS_PRESSED(keycode) \
49	(kbdDevice->key->down[(keycode) >> 3] & (1 << ((keycode) & 7)))	51	(inputInfo.keyboard->key->down[(keycode) >> 3] & (1 << ((keycode) & 7)))
50		52
51	static void vncXConvertCase(KeySym sym, KeySym lower, KeySym upper);	53	static void vncXConvertCase(KeySym sym, KeySym lower, KeySym upper);
52		54
53	static DeviceIntPtr ptrDevice = NULL, kbdDevice = NULL;	55	static DeviceIntPtr ptrDevice = NULL;
54		56
55		57
56	void	58	void
57	vncSetKeyboardDevice(DeviceIntPtr kbd)	59	vncSetKeyboardDevice(DeviceIntPtr kbd)
58	{	60	{
59	if (kbdDevice && kbd)	61	// obsoleted by inputInfo
60	return; /* set once */
61	kbdDevice = kbd;
62	}	62	}
63		63
64		64
Lines 126-131 EnqueueKey(DeviceIntPtr kbdDev, int type Link Here
126	mieqEnqueue(kbdDev, (InternalEvent*)(events + i)->event);	126	mieqEnqueue(kbdDev, (InternalEvent*)(events + i)->event);
127	}	127	}
128		128
		129	/* In-server and highly changed version of XkbKeycodeToKeysym */
		130	static KeySym
		131	_XkbKeycodeToKeysym(XkbDescPtr xkb, KeyCode kc, int group, int level)
		132	{
		133	KeySym ks;
		134
		135	if ((kc<xkb->min_key_code)\|\|(kc>xkb->max_key_code))
		136	return NoSymbol;
		137	/* Treat single group elements as present in all groups */
		138	if (XkbKeyNumGroups (xkb,kc) == 1)
		139	group = 0;
		140	if ((group<0)\|\|(level<0)\|\|(group>=XkbKeyNumGroups(xkb,kc)))
		141	return NoSymbol;
		142	if (level < XkbKeyGroupWidth(xkb, kc, group))
		143	ks = XkbKeySymEntry(xkb, kc, level, group);
		144	else
		145	ks = NoSymbol;
		146	/* Treat 'K' as 'K K', */
		147	if (ks == NoSymbol && (level & 1) && level-1 < XkbKeyGroupWidth(xkb, kc, group))
		148	ks = XkbKeySymEntry(xkb, kc, level-1, group);
		149	return ks;
		150	}
		151
129	/*	152	/*
130	* Called when the rfbserver receives a rfbKeyEvent event from a client.	153	* Called when the rfbserver receives a rfbKeyEvent event from a client.
131	* Put an X keyboard event into the event queue.	154	* Put an X keyboard event into the event queue.
Lines 134-154 void Link Here
134	KbdAddEvent(Bool down, KeySym keySym, rfbClientPtr cl)	157	KbdAddEvent(Bool down, KeySym keySym, rfbClientPtr cl)
135	{	158	{
136	const int type = down ? KeyPress : KeyRelease;	159	const int type = down ? KeyPress : KeyRelease;
137	KeySymsPtr keySyms;	160	XkbSrvInfoPtr xkbInfo;
138	XkbStateRec *xkb;	161	int i, group, level;
139	int i;
140	int keyCode = 0;	162	int keyCode = 0;
141	int freeIndex = -1;
142	Bool fakeShiftPress = FALSE;	163	Bool fakeShiftPress = FALSE;
143	Bool fakeShiftLRelease = FALSE;	164	Bool fakeShiftLRelease = FALSE;
144	Bool fakeShiftRRelease = FALSE;	165	Bool fakeShiftRRelease = FALSE;
145	Bool shiftMustBeReleased = FALSE;	166	Bool shiftMustBeReleased = FALSE;
146	Bool shiftMustBePressed = FALSE;	167	Bool shiftMustBePressed = FALSE;
		168	Bool fakeLevel3Press = FALSE;
		169	Bool fakeLevel3Release = FALSE;
		170	Bool level3MustBeReleased = FALSE;
		171	Bool level3MustBePressed = FALSE;
		172
		173	/* Incomplete maps may create NoSymbol - which lets us
		174	* select and/or overwrite otherwise valid entries.
		175	* E.g Level3+a in serbian layout creates NoSymbol on os11.4
		176	* 2011-05-24 mhopf@suse.de */
		177	if (keySym == NoSymbol) {
		178	ErrorF("KbdAddEvent: ignoring illegal NoSymbol\n");
		179	return;
		180	}
147		181
148	if (!kbdDevice)	182	xkbInfo = inputInfo.keyboard->key->xkbInfo;
149	return;	183	group = xkbInfo->state.group;
150		184	level = (KEY_IS_PRESSED(ISO_LEVEL3_KEY_CODE) ? 2 : 0) \|
151	keySyms = XkbGetCoreMap(kbdDevice);	185	(XkbStateFieldFromRec(&xkbInfo->state) & ShiftMask ? 1 : 0);
		186	#if 0
		187	ErrorF ("VNCkbd:\t%s Sym %04x\n", down ? "+":"-", (int)keySym);
		188	#endif
152		189
153	#ifdef CORBA	190	#ifdef CORBA
154	if (cl) {	191	if (cl) {
Lines 166-171 KbdAddEvent(Bool down, KeySym keySym, rf Link Here
166	*	203	*
167	* Alan.	204	* Alan.
168	*/	205	*/
		206	/* Never use predefined keys.
		207	* This is inherently incapable of dealing with changing
		208	* keyboard layouts. Not being able to work with non-local xmodmaps
		209	* is a nuisance at worst, and probably even preferred.
		210	* 2011-04-15 mhopf@suse.de */
		211	#if 0
169	#if !XFREE86VNC	212	#if !XFREE86VNC
170	/* First check if it's one of our predefined keys. If so then we can make	213	/* First check if it's one of our predefined keys. If so then we can make
171	some attempt at allowing an xmodmap inside a VNC desktop behave	214	some attempt at allowing an xmodmap inside a VNC desktop behave
Lines 192-298 KbdAddEvent(Bool down, KeySym keySym, rf Link Here
192	}	235	}
193	}	236	}
194	#endif	237	#endif
		238	#endif
195		239
196	if (!keyCode) {	240	if (!keyCode) {
197		241
198	/* not one of our predefined keys - see if it's in the current keyboard	242	/* not one of our predefined keys - see if it's in the current keyboard
199	mapping (i.e. we've already allocated an extra keycode for it) */	243	mapping (i.e. we've already allocated an extra keycode for it) */
200		244
201	if (keySyms->mapWidth < 2) {	245	for (keyCode = MIN_KEY_CODE; keyCode < MIN_KEY_CODE + NO_OF_KEYS; keyCode++) {
202	ErrorF("KbdAddEvent: Sanity check failed - Keyboard mapping has "	246	/* Check all keycodes, but only continue on those where
203	"less than 2 keysyms per keycode (KeySym 0x%x)\n", (int)keySym);	247	* backconversion results in keySym.
204	return;	248	* 2011-05-20 mhopf@suse.de */
205	}	249	int j;
		250
		251	#if 0
		252	ErrorF (" keyCode %3d map# %4d++ level %d of %d: keySyms",
		253	keyCode, (i / keySyms->mapWidth) * keySyms->mapWidth,
		254	i % keySyms->mapWidth, keySyms->mapWidth);
		255	for (j = 0; j < keySyms->mapWidth; j++)
		256	ErrorF (" %02x", (int)keySyms->map[(i / keySyms->mapWidth) * keySyms->mapWidth + j]);
		257	ErrorF ("\n");
		258	#endif
		259	#if 0
		260	ErrorF (" group %d of %d width %d: keySyms",
		261	group, XkbKeyNumGroups(xkbInfo->desc, keyCode),
		262	XkbKeyGroupWidth(xkbInfo->desc, keyCode, group));
		263	if (XkbKeyNumGroups(xkbInfo->desc, keyCode) > group)
		264	for (j = 0; j < XkbKeyGroupWidth(xkbInfo->desc, keyCode, group); j++)
		265	ErrorF (" %02x", (int) XkbKeySymEntry(xkbInfo->desc, keyCode, j, group));
		266	ErrorF ("\n");
		267	#endif
206		268
207	for (i = 0; i < NO_OF_KEYS * keySyms->mapWidth; i++) {	269	/* Check whether keySym is reachable in current group
208	if (keySym == keySyms->map[i]) {	270	* by any shift/Level3_shift state (preferrable w/o change).
209	keyCode = MIN_KEY_CODE + i / keySyms->mapWidth;	271	* This doesn't do real modifyer analysis, only Shift and Level3_Shift.
210		272	* 2011-05-23 mhopf@suse.de */
211	if (keySyms->map[(i / keySyms->mapWidth)	273	if (_XkbKeycodeToKeysym(xkbInfo->desc, keyCode, group, level) == keySym)
212	* keySyms->mapWidth + 1] != NoSymbol) {	274	break;
213		275	if (_XkbKeycodeToKeysym(xkbInfo->desc, keyCode, group, level ^ 2) == keySym) {
214	/* this keycode has more than one symbol associated with	276	if (level & 2)
215	it, so shift state is important */	277	level3MustBeReleased = TRUE;
216		278	else
217	if ((i % keySyms->mapWidth) == 0)	279	level3MustBePressed = TRUE;
218	shiftMustBeReleased = TRUE;
219	else
220	shiftMustBePressed = TRUE;
221	}
222	break;	280	break;
223	}	281	}
224	if ((freeIndex == -1) && (keySyms->map[i] == NoSymbol)	282	if (_XkbKeycodeToKeysym(xkbInfo->desc, keyCode, group, level ^ 1) == keySym) {
225	&& (i % keySyms->mapWidth) == 0)	283	if (level & 1)
226	{	284	shiftMustBeReleased = TRUE;
227	freeIndex = i;	285	else
		286	shiftMustBePressed = TRUE;
		287	break;
		288	}
		289	if (_XkbKeycodeToKeysym(xkbInfo->desc, keyCode, group, level ^ 3) == keySym) {
		290	if (level & 2)
		291	level3MustBeReleased = TRUE;
		292	else
		293	level3MustBePressed = TRUE;
		294	if (level & 1)
		295	shiftMustBeReleased = TRUE;
		296	else
		297	shiftMustBePressed = TRUE;
		298	break;
228	}	299	}
229	}	300	}
		301	if (keyCode == MIN_KEY_CODE + NO_OF_KEYS)
		302	keyCode = 0;
230	}	303	}
231		304
232	if (!keyCode) {	305	if (!keyCode) {
233	KeySym lower, upper;	306	KeySym lower, upper;
		307	KeySymsPtr keySyms = XkbGetCoreMap(inputInfo.keyboard);
234		308
235	/* we don't have an existing keycode - make one up on the fly and add	309	/* we don't have an existing keycode - make one up on the fly and add
236	it to the keyboard mapping. Thanks to Vlad Harchev for pointing	310	it to the keyboard mapping. Thanks to Vlad Harchev for pointing
237	out problems with non-ascii capitalisation. */	311	out problems with non-ascii capitalisation. */
238		312
239	if (freeIndex == -1) {	313	/* Find free index for current group. */
		314	for (keyCode = MIN_KEY_CODE; keyCode < MIN_KEY_CODE + NO_OF_KEYS; keyCode++) {
		315	/* A keyCode is free if no groups are assigned at all */
		316	if (XkbKeyNumGroups(xkbInfo->desc, keyCode) == 0)
		317	break;
		318	#if 0
		319	/* We can use exact map positions for group 1+2, but only partially
		320	* filling out xkb legacy maps may suddenly change the # of groups.
		321	* Reason for that is unknown yet. Might be related to (fixed) NoSymbol issue.
		322	* 2011-05-24 mhopf@suse.de */
		323	/* For primary groups: A keyCode is free if current group is empty */
		324	if (XkbKeyGroupWidth(xkbInfo->desc, keyCode, group) < 1 && group < 2)
		325	break;
		326	/* Never touch groups that have a single level only (weird group?!?) */
		327	if (XkbKeyGroupWidth(xkbInfo->desc, keyCode, group) < 2)
		328	continue;
		329	/* For primary groups: A keyCode is free if only NoSymbol is assigned
		330	* to available levels (only validating levels 0-3) */
		331	if (group < 2 &&
		332	XkbKeySymEntry(xkbInfo->desc, keyCode, 0, group) == NoSymbol &&
		333	XkbKeySymEntry(xkbInfo->desc, keyCode, 1, group) == NoSymbol &&
		334	(XkbKeyGroupWidth(xkbInfo->desc, keyCode, group) < 3 \|\|
		335	(XkbKeySymEntry(xkbInfo->desc, keyCode, 2, group) == NoSymbol &&
		336	(XkbKeyGroupWidth(xkbInfo->desc, keyCode, group) < 4 \|\|
		337	XkbKeySymEntry(xkbInfo->desc, keyCode, 3, group) == NoSymbol))))
		338	break;
		339	#endif
		340	}
		341
		342	if (keyCode == MIN_KEY_CODE + NO_OF_KEYS) {
240	ErrorF("KbdAddEvent: ignoring KeySym 0x%x - no free KeyCodes\n",	343	ErrorF("KbdAddEvent: ignoring KeySym 0x%x - no free KeyCodes\n",
241	(int)keySym);	344	(int)keySym);
		345	free (keySyms->map);
		346	free (keySyms);
242	return;	347	return;
243	}	348	}
244		349
245	keyCode = MIN_KEY_CODE + freeIndex / keySyms->mapWidth;
246
247	vncXConvertCase(keySym, &lower, &upper);	350	vncXConvertCase(keySym, &lower, &upper);
248		351
249	if (lower == upper) {	352	/* Adding keys is not using xkb mechanisms yet, but relying on support
250	keySyms->map[freeIndex] = keySym;	353	* for changing keys in the legacy map. Should be changed, eventually.
251		354	* 2011-05-19 mhopf@suse.de */
252	} else {	355	#if 0
253	keySyms->map[freeIndex] = lower;	356	if (group < 2) {
254	keySyms->map[freeIndex+1] = upper;	357	/* Only set mapping for active group. Will only work with dual layouts.
255		358	* 2011-05-23 mhopf@suse.de */
		359	int active_group_offset = group ? 2 : 0;
		360
		361	if (lower == upper) {
		362	keySyms->map[(keyCode - MIN_KEY_CODE) * keySyms->mapWidth + active_group_offset] = keySym;
		363	keySyms->map[(keyCode - MIN_KEY_CODE) * keySyms->mapWidth + active_group_offset + 1] = NoSymbol;
		364	} else {
		365	keySyms->map[(keyCode - MIN_KEY_CODE) * keySyms->mapWidth + active_group_offset] = lower;
		366	keySyms->map[(keyCode - MIN_KEY_CODE) * keySyms->mapWidth + active_group_offset + 1] = upper;
		367	}
		368	}
		369	#endif
		370	/* Generic layouts needs to set the full map width.
		371	* Weird enough, mapWidth seems too big...
		372	* 2011-05-23 mhopf@suse.de */
		373	for (i = 0; i < (keySyms->mapWidth & ~1); i += 2) {
		374	if (lower == upper) {
		375	keySyms->map[(keyCode - MIN_KEY_CODE) * keySyms->mapWidth + i] = keySym;
		376	keySyms->map[(keyCode - MIN_KEY_CODE) * keySyms->mapWidth + i + 1] = NoSymbol;
		377	} else {
		378	keySyms->map[(keyCode - MIN_KEY_CODE) * keySyms->mapWidth + i] = lower;
		379	keySyms->map[(keyCode - MIN_KEY_CODE) * keySyms->mapWidth + i + 1] = upper;
		380	}
		381	}
		382	if (lower != upper) {
256	if (keySym == lower)	383	if (keySym == lower)
257	shiftMustBeReleased = TRUE;	384	shiftMustBeReleased = TRUE;
258	else	385	else
259	shiftMustBePressed = TRUE;	386	shiftMustBePressed = TRUE;
260	}	387	}
		388	level3MustBeReleased = TRUE;
261		389
262	XkbApplyMappingChange(kbdDevice, keySyms, keyCode, 1, NULL, serverClient);	390	XkbApplyMappingChange(inputInfo.keyboard, keySyms, keyCode, 1, NULL, serverClient);
263		391
264	ErrorF("KbdAddEvent: unknown KeySym 0x%x - allocating KeyCode %d\n",	392	ErrorF("KbdAddEvent: unknown KeySym 0x%x - allocating KeyCode %d\n",
265	(int)keySym, keyCode);	393	(int)keySym, keyCode);
		394	free (keySyms->map);
		395	free (keySyms);
266	}	396	}
267		397
268	xkb = &kbdDevice->key->xkbInfo->state;	398	#if 0
		399	ErrorF ("\t%s Sym %04x Code%3d\tState x%02x %s%s%s\tSh %s%s\tL3 %s%s\n",
		400	down ? "+":"-", (int)keySym, keyCode, XkbStateFieldFromRec(&xkbInfo->state),
		401	KEY_IS_PRESSED(SHIFT_L_KEY_CODE) ? "Sl":"",
		402	KEY_IS_PRESSED(SHIFT_R_KEY_CODE) ? "Sr":"",
		403	KEY_IS_PRESSED(ISO_LEVEL3_KEY_CODE) ? "L3":"",
		404	shiftMustBePressed ? "+":"", shiftMustBeReleased ? "-":"",
		405	level3MustBePressed ? "+":"", level3MustBeReleased ? "-":"");
		406	#endif
		407	#if 0
		408	int back = _XkbKeycodeToKeysym (xkbInfo->desc, keyCode, group,
		409	((level3MustBePressed \|\| (!level3MustBeReleased && (level & 2))) ? 2 : 0) \|
		410	((shiftMustBePressed \|\| (!shiftMustBeReleased && (level & 1))) ? 1 : 0));
		411	ErrorF ("\tvalidate code %d %-2s%-2s -> sym %04x %s\n\n", keyCode,
		412	(shiftMustBePressed \|\| (!shiftMustBeReleased && (level & 1))) ? "Sh" : "",
		413	(level3MustBePressed \|\| (!level3MustBeReleased && (level & 2))) ? "L3" : "",
		414	back, (back == keySym ? "ok" : "FAILED"));
		415	#endif
		416
269	if (down) {	417	if (down) {
270	if (shiftMustBePressed && !(XkbStateFieldFromRec(xkb) & ShiftMask)) {	418	/* TODO: would require to check which keycodes are actually
		419	* bound to ISO_Level3_Shift and/or Shift_L.
		420	* 2011-04-18 mhopf@suse.de */
		421	if (level3MustBePressed && !(level & 2)) {
		422	fakeLevel3Press = TRUE;
		423	EnqueueKey(inputInfo.keyboard, KeyPress, ISO_LEVEL3_KEY_CODE);
		424	}
		425	if (level3MustBeReleased && (level & 2)) {
		426	fakeLevel3Release = TRUE;
		427	EnqueueKey(inputInfo.keyboard, KeyRelease, ISO_LEVEL3_KEY_CODE);
		428	}
		429	if (shiftMustBePressed && !(level & 1)) {
271	fakeShiftPress = TRUE;	430	fakeShiftPress = TRUE;
272	EnqueueKey(kbdDevice, KeyPress, SHIFT_L_KEY_CODE);	431	EnqueueKey(inputInfo.keyboard, KeyPress, SHIFT_L_KEY_CODE);
273	}	432	}
274	if (shiftMustBeReleased && (XkbStateFieldFromRec(xkb) & ShiftMask)) {	433	if (shiftMustBeReleased && (level & 1)) {
275	if (KEY_IS_PRESSED(SHIFT_L_KEY_CODE)) {	434	if (KEY_IS_PRESSED(SHIFT_L_KEY_CODE)) {
276	fakeShiftLRelease = TRUE;	435	fakeShiftLRelease = TRUE;
277	EnqueueKey(kbdDevice, KeyRelease, SHIFT_L_KEY_CODE);	436	EnqueueKey(inputInfo.keyboard, KeyRelease, SHIFT_L_KEY_CODE);
278	}	437	}
279	if (KEY_IS_PRESSED(SHIFT_R_KEY_CODE)) {	438	if (KEY_IS_PRESSED(SHIFT_R_KEY_CODE)) {
280	fakeShiftRRelease = TRUE;	439	fakeShiftRRelease = TRUE;
281	EnqueueKey(kbdDevice, KeyRelease, SHIFT_R_KEY_CODE);	440	EnqueueKey(inputInfo.keyboard, KeyRelease, SHIFT_R_KEY_CODE);
282	}	441	}
283	}	442	}
284	}	443	}
285		444
286	EnqueueKey(kbdDevice, type, keyCode);	445	EnqueueKey(inputInfo.keyboard, type, keyCode);
287		446
288	if (fakeShiftPress) {	447	if (fakeShiftPress) {
289	EnqueueKey(kbdDevice, KeyRelease, SHIFT_L_KEY_CODE);	448	EnqueueKey(inputInfo.keyboard, KeyRelease, SHIFT_L_KEY_CODE);
290	}	449	}
291	if (fakeShiftLRelease) {	450	if (fakeShiftLRelease) {
292	EnqueueKey(kbdDevice, KeyPress, SHIFT_L_KEY_CODE);	451	EnqueueKey(inputInfo.keyboard, KeyPress, SHIFT_L_KEY_CODE);
293	}	452	}
294	if (fakeShiftRRelease) {	453	if (fakeShiftRRelease) {
295	EnqueueKey(kbdDevice, KeyPress, SHIFT_R_KEY_CODE);	454	EnqueueKey(inputInfo.keyboard, KeyPress, SHIFT_R_KEY_CODE);
		455	}
		456	if (fakeLevel3Press) {
		457	EnqueueKey(inputInfo.keyboard, KeyRelease, ISO_LEVEL3_KEY_CODE);
		458	}
		459	if (fakeLevel3Release) {
		460	EnqueueKey(inputInfo.keyboard, KeyPress, ISO_LEVEL3_KEY_CODE);
296	}	461	}
297	}	462	}
298		463
Lines 343-357 KbdReleaseAllKeys(void) Link Here
343	{	508	{
344	int i, j;	509	int i, j;
345		510
346	if (!kbdDevice)	511	if (!inputInfo.keyboard)
347	return;	512	return;
348		513
349	for (i = 0; i < DOWN_LENGTH; i++) {	514	for (i = 0; i < DOWN_LENGTH; i++) {
350	if (kbdDevice->key->down[i] != 0) {	515	if (inputInfo.keyboard->key->down[i] != 0) {
351	for (j = 0; j < 8; j++) {	516	for (j = 0; j < 8; j++) {
352	if (kbdDevice->key->down[i] & (1 << j)) {	517	if (inputInfo.keyboard->key->down[i] & (1 << j)) {
353	int detail = (i << 3) \| j;	518	int detail = (i << 3) \| j;
354	EnqueueKey(kbdDevice, KeyRelease, detail);	519	EnqueueKey(inputInfo.keyboard, KeyRelease, detail);
355	}	520	}
356	}	521	}
357	}	522	}