Magellan Linux

  • Back to homepage
    • /[pkg-src]/trunk/vnc/patches/vnc-server-mieq.patch

    Contents of /trunk/vnc/patches/vnc-server-mieq.patch

    Parent Directory Parent Directory | Revision Log Revision Log

    Revision 639 - (show annotations) (download)
    Tue Jun 3 20:56:41 2008 UTC (15 years, 11 months ago) by niro
    File size: 19659 byte(s) 
    -renamed patch
    1 diff -up vnc-4_1_2-unixsrc/unix/xorg-x11-server-source/hw/vnc/XserverDesktop.cc.mieq vnc-4_1_2-unixsrc/unix/xorg-x11-server-source/hw/vnc/XserverDesktop.cc
    2 --- vnc-4_1_2-unixsrc/unix/xorg-x11-server-source/hw/vnc/XserverDesktop.cc.mieq 2006-05-15 18:56:20.000000000 +0200
    3 +++ vnc-4_1_2-unixsrc/unix/xorg-x11-server-source/hw/vnc/XserverDesktop.cc 2008-03-05 12:25:06.000000000 +0100
    4 @@ -50,12 +50,20 @@ extern char *display;
    5 #include "resource.h"
    6 #include "cursorstr.h"
    7 #include "windowstr.h"
    8 +#include "mi/mi.h"
    9 #define XK_CYRILLIC
    10 #include "keysym.h"
    11 #undef public
    12 #undef class
    13 }
    14
    15 +static xEvent *eventq = NULL;
    16 +static DeviceIntPtr vncKeyboard = NULL;
    17 +static DeviceIntPtr vncMouse = NULL;
    18 +
    19 +static int vfbKeybdProc (DeviceIntPtr pDev, int onoff);
    20 +static int vfbMouseProc (DeviceIntPtr pDev, int onoff);
    21 +
    22 using namespace rfb;
    23 using namespace network;
    24
    25 @@ -202,6 +210,21 @@ XserverDesktop::XserverDesktop(ScreenPtr
    26
    27 if (httpListener)
    28 httpServer = new FileHTTPServer(this);
    29 +
    30 +// XXX Memory leak here, eventq is not free()-d because it has to exist till server exits
    31 + if (!eventq)
    32 + eventq = (xEvent *) xcalloc(sizeof(xEvent), GetMaximumEventsNum());
    33 + if (!eventq)
    34 + FatalError("couldn't allocate room for events\n");
    35 +
    36 + if (vncMouse == NULL) {
    37 + vncMouse = AddInputDevice(vfbMouseProc, TRUE);
    38 + RegisterPointerDevice (vncMouse);
    39 + }
    40 + if (vncKeyboard == NULL) {
    41 + vncKeyboard = AddInputDevice(vfbKeybdProc, TRUE);
    42 + RegisterKeyboardDevice (vncKeyboard);
    43 + }
    44 }
    45
    46 XserverDesktop::~XserverDesktop()
    47 @@ -495,7 +518,7 @@ void XserverDesktop::positionCursor()
    48 {
    49 if (!cursorPos.equals(oldCursorPos)) {
    50 oldCursorPos = cursorPos;
    51 - (*pScreen->SetCursorPosition) (pScreen, cursorPos.x, cursorPos.y, FALSE);
    52 +// (*pScreen->SetCursorPosition) (pScreen, cursorPos.x, cursorPos.y, FALSE);
    53 server->setCursorPos(cursorPos);
    54 server->tryUpdate();
    55 }
    56 @@ -660,8 +683,8 @@ void XserverDesktop::approveConnection(v
    57
    58 void XserverDesktop::pointerEvent(const Point& pos, int buttonMask)
    59 {
    60 - xEvent ev;
    61 - DevicePtr dev = LookupPointerDevice();
    62 + BYTE detail;
    63 + int i, j, n, valuators[2];
    64
    65 // SetCursorPosition seems to be very expensive (at least on XFree86 3.3.6
    66 // for S3), so we delay calling it until positionCursor() is called at the
    67 @@ -670,14 +693,14 @@ void XserverDesktop::pointerEvent(const
    68
    69 NewCurrentScreen(pScreen, pos.x, pos.y);
    70
    71 - ev.u.u.type = MotionNotify;
    72 - ev.u.u.detail = 0;
    73 - ev.u.keyButtonPointer.rootX = pos.x;
    74 - ev.u.keyButtonPointer.rootY = pos.y;
    75 - ev.u.keyButtonPointer.time = GetTimeInMillis();
    76 -
    77 - if (!pos.equals(cursorPos))
    78 - (*dev->processInputProc)(&ev, (DeviceIntPtr)dev, 1);
    79 + if (!pos.equals(cursorPos)) {
    80 + valuators[0] = pos.x;
    81 + valuators[1] = pos.y;
    82 + n = GetPointerEvents (eventq, vncMouse, MotionNotify, 0,
    83 + POINTER_ABSOLUTE, 0, 2, valuators);
    84 + for (i = 0; i < n; i++)
    85 + mieqEnqueue (vncMouse, eventq + i);
    86 + }
    87
    88 for (int i = 0; i < 5; i++) {
    89 if ((buttonMask ^ oldButtonMask) & (1<<i)) {
    90 @@ -685,12 +708,15 @@ void XserverDesktop::pointerEvent(const
    91 // God knows why but some idiot decided to conditionally move the pointer
    92 // mapping out of DIX, so we guess here that if XINPUT is defined we have
    93 // to do it ourselves...
    94 - ev.u.u.detail = ((DeviceIntPtr)dev)->button->map[i + 1];
    95 + detail = vncMouse->button->map[i + 1];
    96 #else
    97 - ev.u.u.detail = i + 1;
    98 + detail = i + 1;
    99 #endif
    100 - ev.u.u.type = (buttonMask & (1<<i)) ? ButtonPress : ButtonRelease;
    101 - (*dev->processInputProc)(&ev, (DeviceIntPtr)dev, 1);
    102 + n = GetPointerEvents (eventq, vncMouse, (buttonMask & (1<<i)) ?
    103 + ButtonPress : ButtonRelease,
    104 + detail, POINTER_RELATIVE, 0, 0, NULL);
    105 + for (j = 0; j < n; j++)
    106 + mieqEnqueue (vncMouse, eventq + j);
    107 }
    108 }
    109
    110 @@ -771,8 +797,8 @@ void XserverDesktop::lookup(int index, i
    111
    112 class ModifierState {
    113 public:
    114 - ModifierState(DeviceIntPtr dev_, int modIndex_)
    115 - : dev(dev_), modIndex(modIndex_), nKeys(0), keys(0), pressed(false)
    116 + ModifierState(int modIndex_)
    117 + : modIndex(modIndex_), nKeys(0), keys(0), pressed(false)
    118 {
    119 }
    120 ~ModifierState() {
    121 @@ -781,7 +807,7 @@ public:
    122 delete [] keys;
    123 }
    124 void press() {
    125 - KeyClassPtr keyc = dev->key;
    126 + KeyClassPtr keyc = vncKeyboard->key;
    127 if (!(keyc->state & (1<<modIndex))) {
    128 tempKeyEvent(keyc->modifierKeyMap[modIndex * keyc->maxKeysPerModifier],
    129 true);
    130 @@ -789,7 +815,7 @@ public:
    131 }
    132 }
    133 void release() {
    134 - KeyClassPtr keyc = dev->key;
    135 + KeyClassPtr keyc = vncKeyboard->key;
    136 if (keyc->state & (1<<modIndex)) {
    137 for (int k = 0; k < keyc->maxKeysPerModifier; k++) {
    138 int keycode
    139 @@ -802,20 +828,19 @@ public:
    140 private:
    141 void tempKeyEvent(int keycode, bool down) {
    142 if (keycode) {
    143 - if (!keys) keys = new int[dev->key->maxKeysPerModifier];
    144 + if (!keys) keys = new int[vncKeyboard->key->maxKeysPerModifier];
    145 keys[nKeys++] = keycode;
    146 generateXKeyEvent(keycode, down);
    147 }
    148 }
    149 void generateXKeyEvent(int keycode, bool down) {
    150 - xEvent ev;
    151 - ev.u.u.type = down ? KeyPress : KeyRelease;
    152 - ev.u.u.detail = keycode;
    153 - ev.u.keyButtonPointer.time = GetTimeInMillis();
    154 - (*dev->c_public.processInputProc)(&ev, dev, 1);
    155 + int i, n;
    156 + n = GetKeyboardEvents (eventq, vncKeyboard,
    157 + down ? KeyPress : KeyRelease, keycode);
    158 + for (i = 0; i < n; i++)
    159 + mieqEnqueue (vncKeyboard, eventq + i);
    160 vlog.debug("fake keycode %d %s", keycode, down ? "down" : "up");
    161 }
    162 - DeviceIntPtr dev;
    163 int modIndex;
    164 int nKeys;
    165 int* keys;
    166 @@ -888,16 +913,16 @@ void XserverDesktop::keyEvent(rdr::U32 k
    167 vlog.debug("Ignoring caps lock");
    168 return;
    169 }
    170 - DeviceIntPtr dev = (DeviceIntPtr)LookupKeyboardDevice();
    171 - KeyClassPtr keyc = dev->key;
    172 + KeyClassPtr keyc = vncKeyboard->key;
    173 KeySymsPtr keymap = &keyc->curKeySyms;
    174 + int i, j, k, n;
    175
    176 // find which modifier Mode_switch is on.
    177 int modeSwitchMapIndex = 0;
    178 - for (int i = 3; i < 8; i++) {
    179 - for (int k = 0; k < keyc->maxKeysPerModifier; k++) {
    180 + for (i = 3; i < 8; i++) {
    181 + for (k = 0; k < keyc->maxKeysPerModifier; k++) {
    182 int keycode = keyc->modifierKeyMap[i * keyc->maxKeysPerModifier + k];
    183 - for (int j = 0; j < keymap->mapWidth; j++) {
    184 + for (j = 0; j < keymap->mapWidth; j++) {
    185 if (keycode != 0 &&
    186 keymap->map[(keycode - keymap->minKeyCode)
    187 * keymap->mapWidth + j] == XK_Mode_switch)
    188 @@ -926,7 +951,7 @@ void XserverDesktop::keyEvent(rdr::U32 k
    189 if (kc == 0) {
    190 // Not a direct match in the local keyboard mapping. Check for alternative
    191 // keysyms with the same meaning.
    192 - for (int i = 0; i < sizeof(altKeysym) / sizeof(altKeysym_t); i++) {
    193 + for (i = 0; i < sizeof(altKeysym) / sizeof(altKeysym_t); i++) {
    194 if (keysym == altKeysym[i].a)
    195 kc = KeysymToKeycode(keymap, altKeysym[i].b, &col);
    196 else if (keysym == altKeysym[i].b)
    197 @@ -954,16 +979,16 @@ void XserverDesktop::keyEvent(rdr::U32 k
    198
    199 // See if it's a modifier key. If so, then don't do any auto-repeat, because
    200 // the X server will translate each press into a release followed by a press.
    201 - for (int i = 0; i < 8; i++) {
    202 - for (int k = 0; k < keyc->maxKeysPerModifier; k++) {
    203 + for (i = 0; i < 8; i++) {
    204 + for (k = 0; k < keyc->maxKeysPerModifier; k++) {
    205 if (kc == keyc->modifierKeyMap[i * keyc->maxKeysPerModifier + k] &&
    206 IS_PRESSED(keyc,kc) && down)
    207 return;
    208 }
    209 }
    210
    211 - ModifierState shift(dev, ShiftMapIndex);
    212 - ModifierState modeSwitch(dev, modeSwitchMapIndex);
    213 + ModifierState shift(ShiftMapIndex);
    214 + ModifierState modeSwitch(modeSwitchMapIndex);
    215 if (down) {
    216 if (col & 1)
    217 shift.press();
    218 @@ -977,11 +1002,10 @@ void XserverDesktop::keyEvent(rdr::U32 k
    219 }
    220 }
    221 vlog.debug("keycode %d %s", kc, down ? "down" : "up");
    222 - xEvent ev;
    223 - ev.u.u.type = down ? KeyPress : KeyRelease;
    224 - ev.u.u.detail = kc;
    225 - ev.u.keyButtonPointer.time = GetTimeInMillis();
    226 - (*dev->c_public.processInputProc)(&ev, dev, 1);
    227 + n = GetKeyboardEvents (eventq, vncKeyboard, down ? KeyPress : KeyRelease,
    228 + kc);
    229 + for (i = 0; i < n; i++)
    230 + mieqEnqueue (vncKeyboard, eventq + i);
    231 }
    232
    233
    234 @@ -1150,3 +1174,208 @@ static KeyCode KeysymToKeycode(KeySymsPt
    235 }
    236 return 0;
    237 }
    238 +
    239 +void vncRingBell(int percent, int pitch, int duration)
    240 +{
    241 + if (percent > 0)
    242 + vncBell();
    243 +}
    244 +
    245 +/* Fairly standard US PC Keyboard */
    246 +
    247 +#define VFB_MIN_KEY 8
    248 +#define VFB_MAX_KEY 255
    249 +#define VFB_MAP_LEN (VFB_MAX_KEY - VFB_MIN_KEY + 1)
    250 +#define KEYSYMS_PER_KEY 2
    251 +KeySym keyboardMap[VFB_MAP_LEN * KEYSYMS_PER_KEY] = {
    252 + NoSymbol, NoSymbol,
    253 + XK_Escape, NoSymbol,
    254 + XK_1, XK_exclam,
    255 + XK_2, XK_at,
    256 + XK_3, XK_numbersign,
    257 + XK_4, XK_dollar,
    258 + XK_5, XK_percent,
    259 + XK_6, XK_asciicircum,
    260 + XK_7, XK_ampersand,
    261 + XK_8, XK_asterisk,
    262 + XK_9, XK_parenleft,
    263 + XK_0, XK_parenright,
    264 + XK_minus, XK_underscore,
    265 + XK_equal, XK_plus,
    266 + XK_BackSpace, NoSymbol,
    267 + XK_Tab, NoSymbol,
    268 + XK_q, XK_Q,
    269 + XK_w, XK_W,
    270 + XK_e, XK_E,
    271 + XK_r, XK_R,
    272 + XK_t, XK_T,
    273 + XK_y, XK_Y,
    274 + XK_u, XK_U,
    275 + XK_i, XK_I,
    276 + XK_o, XK_O,
    277 + XK_p, XK_P,
    278 + XK_bracketleft, XK_braceleft,
    279 + XK_bracketright, XK_braceright,
    280 + XK_Return, NoSymbol,
    281 + XK_Control_L, NoSymbol,
    282 + XK_a, XK_A,
    283 + XK_s, XK_S,
    284 + XK_d, XK_D,
    285 + XK_f, XK_F,
    286 + XK_g, XK_G,
    287 + XK_h, XK_H,
    288 + XK_j, XK_J,
    289 + XK_k, XK_K,
    290 + XK_l, XK_L,
    291 + XK_semicolon, XK_colon,
    292 + XK_apostrophe, XK_quotedbl,
    293 + XK_grave, XK_asciitilde,
    294 + XK_Shift_L, NoSymbol,
    295 + XK_backslash, XK_bar,
    296 + XK_z, XK_Z,
    297 + XK_x, XK_X,
    298 + XK_c, XK_C,
    299 + XK_v, XK_V,
    300 + XK_b, XK_B,
    301 + XK_n, XK_N,
    302 + XK_m, XK_M,
    303 + XK_comma, XK_less,
    304 + XK_period, XK_greater,
    305 + XK_slash, XK_question,
    306 + XK_Shift_R, NoSymbol,
    307 + XK_KP_Multiply, NoSymbol,
    308 + XK_Alt_L, XK_Meta_L,
    309 + XK_space, NoSymbol,
    310 + /*XK_Caps_Lock*/ NoSymbol, NoSymbol,
    311 + XK_F1, NoSymbol,
    312 + XK_F2, NoSymbol,
    313 + XK_F3, NoSymbol,
    314 + XK_F4, NoSymbol,
    315 + XK_F5, NoSymbol,
    316 + XK_F6, NoSymbol,
    317 + XK_F7, NoSymbol,
    318 + XK_F8, NoSymbol,
    319 + XK_F9, NoSymbol,
    320 + XK_F10, NoSymbol,
    321 + XK_Num_Lock, XK_Pointer_EnableKeys,
    322 + XK_Scroll_Lock, NoSymbol,
    323 + XK_KP_Home, XK_KP_7,
    324 + XK_KP_Up, XK_KP_8,
    325 + XK_KP_Prior, XK_KP_9,
    326 + XK_KP_Subtract, NoSymbol,
    327 + XK_KP_Left, XK_KP_4,
    328 + XK_KP_Begin, XK_KP_5,
    329 + XK_KP_Right, XK_KP_6,
    330 + XK_KP_Add, NoSymbol,
    331 + XK_KP_End, XK_KP_1,
    332 + XK_KP_Down, XK_KP_2,
    333 + XK_KP_Next, XK_KP_3,
    334 + XK_KP_Insert, XK_KP_0,
    335 + XK_KP_Delete, XK_KP_Decimal,
    336 + NoSymbol, NoSymbol,
    337 + NoSymbol, NoSymbol,
    338 + NoSymbol, NoSymbol,
    339 + XK_F11, NoSymbol,
    340 + XK_F12, NoSymbol,
    341 + XK_Home, NoSymbol,
    342 + XK_Up, NoSymbol,
    343 + XK_Prior, NoSymbol,
    344 + XK_Left, NoSymbol,
    345 + NoSymbol, NoSymbol,
    346 + XK_Right, NoSymbol,
    347 + XK_End, NoSymbol,
    348 + XK_Down, NoSymbol,
    349 + XK_Next, NoSymbol,
    350 + XK_Insert, NoSymbol,
    351 + XK_Delete, NoSymbol,
    352 + XK_KP_Enter, NoSymbol,
    353 + XK_Control_R, NoSymbol,
    354 + XK_Pause, XK_Break,
    355 + XK_Print, XK_Execute,
    356 + XK_KP_Divide, NoSymbol,
    357 + XK_Alt_R, XK_Meta_R,
    358 +};
    359 +
    360 +static Bool GetMappings(KeySymsPtr pKeySyms, CARD8 *pModMap)
    361 +{
    362 + int i;
    363 +
    364 + for (i = 0; i < MAP_LENGTH; i++)
    365 + pModMap[i] = NoSymbol;
    366 +
    367 + for (i = 0; i < VFB_MAP_LEN; i++) {
    368 + if (keyboardMap[i * KEYSYMS_PER_KEY] == XK_Caps_Lock)
    369 + pModMap[i + VFB_MIN_KEY] = LockMask;
    370 + else if (keyboardMap[i * KEYSYMS_PER_KEY] == XK_Shift_L ||
    371 + keyboardMap[i * KEYSYMS_PER_KEY] == XK_Shift_R)
    372 + pModMap[i + VFB_MIN_KEY] = ShiftMask;
    373 + else if (keyboardMap[i * KEYSYMS_PER_KEY] == XK_Control_L ||
    374 + keyboardMap[i * KEYSYMS_PER_KEY] == XK_Control_R) {
    375 + pModMap[i + VFB_MIN_KEY] = ControlMask;
    376 + }
    377 + else if (keyboardMap[i * KEYSYMS_PER_KEY] == XK_Alt_L ||
    378 + keyboardMap[i * KEYSYMS_PER_KEY] == XK_Alt_R)
    379 + pModMap[i + VFB_MIN_KEY] = Mod1Mask;
    380 + }
    381 +
    382 + pKeySyms->minKeyCode = VFB_MIN_KEY;
    383 + pKeySyms->maxKeyCode = VFB_MAX_KEY;
    384 + pKeySyms->mapWidth = KEYSYMS_PER_KEY;
    385 + pKeySyms->map = keyboardMap;
    386 +
    387 + return TRUE;
    388 +}
    389 +
    390 +static int vfbKeybdProc(DeviceIntPtr pDev, int onoff)
    391 +{
    392 + KeySymsRec keySyms;
    393 + CARD8 modMap[MAP_LENGTH];
    394 +
    395 + switch (onoff)
    396 + {
    397 + case DEVICE_INIT:
    398 + GetMappings(&keySyms, modMap);
    399 + InitKeyboardDeviceStruct(&pDev->c_public, &keySyms, modMap,
    400 + (BellProcPtr)vncRingBell, (KbdCtrlProcPtr)NoopDDA);
    401 + break;
    402 + case DEVICE_ON:
    403 + pDev->c_public.on = TRUE;
    404 + break;
    405 + case DEVICE_OFF:
    406 + pDev->c_public.on = FALSE;
    407 + break;
    408 + case DEVICE_CLOSE:
    409 + break;
    410 + }
    411 + return Success;
    412 +}
    413 +
    414 +static int vfbMouseProc(DeviceIntPtr pDev, int onoff)
    415 +{
    416 + BYTE map[6];
    417 +
    418 + switch (onoff)
    419 + {
    420 + case DEVICE_INIT:
    421 + map[1] = 1;
    422 + map[2] = 2;
    423 + map[3] = 3;
    424 + map[4] = 4;
    425 + map[5] = 5;
    426 + InitPointerDeviceStruct(&pDev->c_public, map, 5, GetMotionHistory,
    427 + (PtrCtrlProcPtr)NoopDDA, GetMotionHistorySize(), 2);
    428 + break;
    429 +
    430 + case DEVICE_ON:
    431 + pDev->c_public.on = TRUE;
    432 + break;
    433 +
    434 + case DEVICE_OFF:
    435 + pDev->c_public.on = FALSE;
    436 + break;
    437 +
    438 + case DEVICE_CLOSE:
    439 + break;
    440 + }
    441 + return Success;
    442 +}
    443 diff -up vnc-4_1_2-unixsrc/unix/xorg-x11-server-source/hw/vnc/xvnc.cc.mieq vnc-4_1_2-unixsrc/unix/xorg-x11-server-source/hw/vnc/xvnc.cc
    444 --- vnc-4_1_2-unixsrc/unix/xorg-x11-server-source/hw/vnc/xvnc.cc.mieq 2008-03-04 12:08:05.000000000 +0100
    445 +++ vnc-4_1_2-unixsrc/unix/xorg-x11-server-source/hw/vnc/xvnc.cc 2008-03-05 11:52:34.000000000 +0100
    446 @@ -125,6 +125,8 @@ static bool displaySpecified = false;
    447 static bool wellKnownSocketsCreated = false;
    448 static char displayNumStr[16];
    449
    450 +extern void vncRingBell (int percent, int pitch, int duration);
    451 +
    452 #define swapcopy16(_dst, _src) \
    453 if (needswap) { CARD16 _s = _src; cpswaps(_s, _dst); } \
    454 else _dst = _src;
    455 @@ -925,7 +927,7 @@ void InitOutput(ScreenInfo *screenInfo,
    456 int SelectWaitTime = 10000; /* usec */
    457 #endif
    458
    459 -Bool LegalModifier(unsigned int key, DevicePtr pDev)
    460 +Bool LegalModifier(unsigned int key, DeviceIntPtr pDev)
    461 {
    462 return TRUE;
    463 }
    464 @@ -936,223 +938,14 @@ void ProcessInputEvents()
    465 miPointerUpdate();
    466 }
    467
    468 -/* Fairly standard US PC Keyboard */
    469 -
    470 -#define VFB_MIN_KEY 8
    471 -#define VFB_MAX_KEY 255
    472 -#define VFB_MAP_LEN (VFB_MAX_KEY - VFB_MIN_KEY + 1)
    473 -#define KEYSYMS_PER_KEY 2
    474 -KeySym keyboardMap[VFB_MAP_LEN * KEYSYMS_PER_KEY] = {
    475 - NoSymbol, NoSymbol,
    476 - XK_Escape, NoSymbol,
    477 - XK_1, XK_exclam,
    478 - XK_2, XK_at,
    479 - XK_3, XK_numbersign,
    480 - XK_4, XK_dollar,
    481 - XK_5, XK_percent,
    482 - XK_6, XK_asciicircum,
    483 - XK_7, XK_ampersand,
    484 - XK_8, XK_asterisk,
    485 - XK_9, XK_parenleft,
    486 - XK_0, XK_parenright,
    487 - XK_minus, XK_underscore,
    488 - XK_equal, XK_plus,
    489 - XK_BackSpace, NoSymbol,
    490 - XK_Tab, NoSymbol,
    491 - XK_q, XK_Q,
    492 - XK_w, XK_W,
    493 - XK_e, XK_E,
    494 - XK_r, XK_R,
    495 - XK_t, XK_T,
    496 - XK_y, XK_Y,
    497 - XK_u, XK_U,
    498 - XK_i, XK_I,
    499 - XK_o, XK_O,
    500 - XK_p, XK_P,
    501 - XK_bracketleft, XK_braceleft,
    502 - XK_bracketright, XK_braceright,
    503 - XK_Return, NoSymbol,
    504 - XK_Control_L, NoSymbol,
    505 - XK_a, XK_A,
    506 - XK_s, XK_S,
    507 - XK_d, XK_D,
    508 - XK_f, XK_F,
    509 - XK_g, XK_G,
    510 - XK_h, XK_H,
    511 - XK_j, XK_J,
    512 - XK_k, XK_K,
    513 - XK_l, XK_L,
    514 - XK_semicolon, XK_colon,
    515 - XK_apostrophe, XK_quotedbl,
    516 - XK_grave, XK_asciitilde,
    517 - XK_Shift_L, NoSymbol,
    518 - XK_backslash, XK_bar,
    519 - XK_z, XK_Z,
    520 - XK_x, XK_X,
    521 - XK_c, XK_C,
    522 - XK_v, XK_V,
    523 - XK_b, XK_B,
    524 - XK_n, XK_N,
    525 - XK_m, XK_M,
    526 - XK_comma, XK_less,
    527 - XK_period, XK_greater,
    528 - XK_slash, XK_question,
    529 - XK_Shift_R, NoSymbol,
    530 - XK_KP_Multiply, NoSymbol,
    531 - XK_Alt_L, XK_Meta_L,
    532 - XK_space, NoSymbol,
    533 - /*XK_Caps_Lock*/ NoSymbol, NoSymbol,
    534 - XK_F1, NoSymbol,
    535 - XK_F2, NoSymbol,
    536 - XK_F3, NoSymbol,
    537 - XK_F4, NoSymbol,
    538 - XK_F5, NoSymbol,
    539 - XK_F6, NoSymbol,
    540 - XK_F7, NoSymbol,
    541 - XK_F8, NoSymbol,
    542 - XK_F9, NoSymbol,
    543 - XK_F10, NoSymbol,
    544 - XK_Num_Lock, XK_Pointer_EnableKeys,
    545 - XK_Scroll_Lock, NoSymbol,
    546 - XK_KP_Home, XK_KP_7,
    547 - XK_KP_Up, XK_KP_8,
    548 - XK_KP_Prior, XK_KP_9,
    549 - XK_KP_Subtract, NoSymbol,
    550 - XK_KP_Left, XK_KP_4,
    551 - XK_KP_Begin, XK_KP_5,
    552 - XK_KP_Right, XK_KP_6,
    553 - XK_KP_Add, NoSymbol,
    554 - XK_KP_End, XK_KP_1,
    555 - XK_KP_Down, XK_KP_2,
    556 - XK_KP_Next, XK_KP_3,
    557 - XK_KP_Insert, XK_KP_0,
    558 - XK_KP_Delete, XK_KP_Decimal,
    559 - NoSymbol, NoSymbol,
    560 - NoSymbol, NoSymbol,
    561 - NoSymbol, NoSymbol,
    562 - XK_F11, NoSymbol,
    563 - XK_F12, NoSymbol,
    564 - XK_Home, NoSymbol,
    565 - XK_Up, NoSymbol,
    566 - XK_Prior, NoSymbol,
    567 - XK_Left, NoSymbol,
    568 - NoSymbol, NoSymbol,
    569 - XK_Right, NoSymbol,
    570 - XK_End, NoSymbol,
    571 - XK_Down, NoSymbol,
    572 - XK_Next, NoSymbol,
    573 - XK_Insert, NoSymbol,
    574 - XK_Delete, NoSymbol,
    575 - XK_KP_Enter, NoSymbol,
    576 - XK_Control_R, NoSymbol,
    577 - XK_Pause, XK_Break,
    578 - XK_Print, XK_Execute,
    579 - XK_KP_Divide, NoSymbol,
    580 - XK_Alt_R, XK_Meta_R,
    581 -};
    582 -
    583 -static Bool GetMappings(KeySymsPtr pKeySyms, CARD8 *pModMap)
    584 -{
    585 - int i;
    586 -
    587 - for (i = 0; i < MAP_LENGTH; i++)
    588 - pModMap[i] = NoSymbol;
    589 -
    590 - for (i = 0; i < VFB_MAP_LEN; i++) {
    591 - if (keyboardMap[i * KEYSYMS_PER_KEY] == XK_Caps_Lock)
    592 - pModMap[i + VFB_MIN_KEY] = LockMask;
    593 - else if (keyboardMap[i * KEYSYMS_PER_KEY] == XK_Shift_L ||
    594 - keyboardMap[i * KEYSYMS_PER_KEY] == XK_Shift_R)
    595 - pModMap[i + VFB_MIN_KEY] = ShiftMask;
    596 - else if (keyboardMap[i * KEYSYMS_PER_KEY] == XK_Control_L ||
    597 - keyboardMap[i * KEYSYMS_PER_KEY] == XK_Control_R) {
    598 - pModMap[i + VFB_MIN_KEY] = ControlMask;
    599 - }
    600 - else if (keyboardMap[i * KEYSYMS_PER_KEY] == XK_Alt_L ||
    601 - keyboardMap[i * KEYSYMS_PER_KEY] == XK_Alt_R)
    602 - pModMap[i + VFB_MIN_KEY] = Mod1Mask;
    603 - }
    604 -
    605 - pKeySyms->minKeyCode = VFB_MIN_KEY;
    606 - pKeySyms->maxKeyCode = VFB_MAX_KEY;
    607 - pKeySyms->mapWidth = KEYSYMS_PER_KEY;
    608 - pKeySyms->map = keyboardMap;
    609 -
    610 - return TRUE;
    611 -}
    612 -
    613 -static void vfbBell(int percent, DeviceIntPtr device, pointer ctrl, int class_)
    614 -{
    615 - if (percent > 0)
    616 - vncBell();
    617 -}
    618 -
    619 -static int vfbKeybdProc(DeviceIntPtr pDevice, int onoff)
    620 -{
    621 - KeySymsRec keySyms;
    622 - CARD8 modMap[MAP_LENGTH];
    623 - DevicePtr pDev = (DevicePtr)pDevice;
    624 -
    625 - switch (onoff)
    626 - {
    627 - case DEVICE_INIT:
    628 - GetMappings(&keySyms, modMap);
    629 - InitKeyboardDeviceStruct(pDev, &keySyms, modMap,
    630 - (BellProcPtr)vfbBell, (KbdCtrlProcPtr)NoopDDA);
    631 - break;
    632 - case DEVICE_ON:
    633 - pDev->on = TRUE;
    634 - break;
    635 - case DEVICE_OFF:
    636 - pDev->on = FALSE;
    637 - break;
    638 - case DEVICE_CLOSE:
    639 - break;
    640 - }
    641 - return Success;
    642 -}
    643 -
    644 -static int vfbMouseProc(DeviceIntPtr pDevice, int onoff)
    645 +void DDXRingBell(int percent, int pitch, int duration)
    646 {
    647 - BYTE map[6];
    648 - DevicePtr pDev = (DevicePtr)pDevice;
    649 -
    650 - switch (onoff)
    651 - {
    652 - case DEVICE_INIT:
    653 - map[1] = 1;
    654 - map[2] = 2;
    655 - map[3] = 3;
    656 - map[4] = 4;
    657 - map[5] = 5;
    658 - InitPointerDeviceStruct(pDev, map, 5, miPointerGetMotionEvents,
    659 - (PtrCtrlProcPtr)NoopDDA, miPointerGetMotionBufferSize());
    660 - break;
    661 -
    662 - case DEVICE_ON:
    663 - pDev->on = TRUE;
    664 - break;
    665 -
    666 - case DEVICE_OFF:
    667 - pDev->on = FALSE;
    668 - break;
    669 -
    670 - case DEVICE_CLOSE:
    671 - break;
    672 - }
    673 - return Success;
    674 + vncRingBell (percent, pitch, duration);
    675 }
    676 -
    677 // InitInput is called after InitExtensions, so we're guaranteed that
    678 // vncExtensionInit() has already been called.
    679
    680 void InitInput(int argc, char *argv[])
    681 {
    682 - DeviceIntPtr p, k;
    683 - p = AddInputDevice(vfbMouseProc, TRUE);
    684 - k = AddInputDevice(vfbKeybdProc, TRUE);
    685 - RegisterPointerDevice(p);
    686 - RegisterKeyboardDevice(k);
    687 - miRegisterPointerDevice(screenInfo.screens[0], p);
    688 - (void)mieqInit ((DevicePtr)k, (DevicePtr)p);
    689 + mieqInit ();
    690 }