Magellan Linux

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

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

    Parent Directory Parent Directory | Revision Log Revision Log

    Revision 639 - (hide 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 niro 639 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     }