diff -urN rdesktop-1.5.0.org/vnc/vnc.c rdesktop-1.5.0/vnc/vnc.c --- rdesktop-1.5.0.org/vnc/vnc.c 1970-01-01 01:00:00.000000000 +0100 +++ rdesktop-1.5.0/vnc/vnc.c 2004-10-07 15:00:29.000000000 +0200 @@ -0,0 +1,1376 @@ +/* + rdesktop: A Remote Desktop Protocol client. + User interface services - VNC target + Copyright (C) Matthew Chapman 1999-2000 + Copyright (C) 2000 Tim Edmonds + Copyright (C) 2001 James "Wez" Weatherall + Copyright (C) 2001 Johannes E. Schindelin + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. +*/ + + +#include +#include + +#ifdef WIN32 +#define close closesocket +#define strcasecmp _strcmpi +#else +#include +#include /* timeval */ +#include +#endif + +#include "../rdesktop.h" +#undef VERSION + +#ifdef WIN32 +#define HBITMAP R_HBITMAP +#define HCURSOR R_HCURSOR +#define WORD R_WORD +#endif +#include "vnc.h" +#ifdef WIN32 +#undef HBITMAP +#undef HCURSOR +#undef WORD +#endif + +#include +#include +extern int ListenOnTCPPort(int port); +extern int rfbClientSocket; + +#include + +#define BITSPERBYTES 8 +#define TOBYTES(bits) ((bits)/BITSPERBYTES) + +extern int g_width; +extern int g_height; +extern int keylayout; +extern BOOL sendmotion; +#ifdef ENABLE_SHADOW +extern int client_counter; +#endif + + +int rfb_port = 5923; +int defer_time = 5; +int rfbClientSocket = 0; +static rfbScreenInfoPtr server = NULL; +static vncBuffer *frameBuffer = NULL; +static uint8_t reverseByte[0x100]; +BOOL g_enable_compose = False; +int g_display = 0; + +/* ignored */ +BOOL owncolmap = False; +BOOL enable_compose = False; + +void +vncHideCursor() +{ + if (server->clientHead) + rfbUndrawCursor(server); +} + +/* -=- mouseLookup + * Table converting mouse button number (0-2) to flag + */ + +int mouseLookup[3] = { + MOUSE_FLAG_BUTTON1, MOUSE_FLAG_BUTTON3, MOUSE_FLAG_BUTTON2 +}; + +int clipX, clipY, clipW, clipH; + +BOOL +vncwinClipRect(int *x, int *y, int *cx, int *cy) +{ + if (*x + *cx > clipX + clipW) + *cx = clipX + clipW - *x; + if (*y + *cy > clipY + clipH) + *cy = clipY + clipH - *y; + if (*x < clipX) + { + *cx -= clipX - *x; + *x = clipX; + } + if (*y < clipY) + { + *cy -= clipY - *y; + *y = clipY; + } + if (*cx < 0 || *cy < 0) + *cx = *cy = 0; + return (*cx > 0 && *cy > 0 && *x < server->width && *y < server->height); +} + +void +xwin_toggle_fullscreen(void) +{ +} + +static int lastbuttons = 0; + +#define FIRST_MODIFIER XK_Shift_L +#define LAST_MODIFIER XK_Hyper_R + +static BOOL keystate[LAST_MODIFIER - FIRST_MODIFIER]; + +void +init_keyboard() +{ + int i; + for (i = 0; i < LAST_MODIFIER - FIRST_MODIFIER; i++) + keystate[i] = 0; + + xkeymap_init(); +} + +BOOL +get_key_state(unsigned int state, uint32 keysym) +{ + if (keysym >= FIRST_MODIFIER && keysym <= LAST_MODIFIER) + return keystate[keysym - FIRST_MODIFIER]; + return 0; +} + +void +vncKey(rfbBool down, rfbKeySym keysym, struct _rfbClientRec *cl) +{ + uint32 ev_time = time(NULL); + key_translation tr = { 0, 0 }; + + if (keysym >= FIRST_MODIFIER && keysym <= LAST_MODIFIER) + { + /* TODO: fake local state */ + keystate[keysym - FIRST_MODIFIER] = down; + } + + if (down) + { + /* TODO: fake local state */ + if (handle_special_keys(keysym, 0, ev_time, True)) + return; + + /* TODO: fake local state */ + tr = xkeymap_translate_key(keysym, 0, 0); + + if (tr.scancode == 0) + return; + + ensure_remote_modifiers(ev_time, tr); + + rdp_send_scancode(ev_time, RDP_KEYPRESS, tr.scancode); + } + else + { + /* todO: fake local state */ + if (handle_special_keys(keysym, 0, ev_time, False)) + return; + + /* todO: fake local state */ + tr = xkeymap_translate_key(keysym, 0, 0); + + if (tr.scancode == 0) + return; + + rdp_send_scancode(ev_time, RDP_KEYRELEASE, tr.scancode); + } +} + +void +vncMouse(int buttonMask, int x, int y, struct _rfbClientRec *cl) +{ + int b; + uint32 ev_time = time(NULL); + + rdp_send_input(ev_time, RDP_INPUT_MOUSE, MOUSE_FLAG_MOVE, x, y); + + for (b = 0; b < 3; b++) + { + int bb = 1 << (b); + if (!(lastbuttons & bb) && (buttonMask & bb)) + { + rdp_send_input(ev_time, RDP_INPUT_MOUSE, + (mouseLookup[b]) | MOUSE_FLAG_DOWN, x, y); + } + else if ((lastbuttons & bb) && !(buttonMask & bb)) + { + rdp_send_input(ev_time, RDP_INPUT_MOUSE, (mouseLookup[b]), x, y); + } + } + lastbuttons = buttonMask; + + /* handle cursor */ + rfbDefaultPtrAddEvent(buttonMask, x, y, cl); +} + + +void +rdp2vnc_connect(char *server, uint32 flags, char *domain, char *password, + char *shell, char *directory) +{ + struct sockaddr addr; + fd_set fdset; + struct timeval tv; + int rfbListenSock, addrlen = sizeof(addr); + + rfbListenSock = rfbListenOnTCPPort(rfb_port); + fprintf(stderr, "Listening on VNC port %d\n", rfb_port); + if (rfbListenSock <= 0) + error("Cannot listen on port %d", rfb_port); + else + while (1) + { + FD_ZERO(&fdset); + FD_SET(rfbListenSock, &fdset); + tv.tv_sec = 5; + tv.tv_usec = 0; + if (select(rfbListenSock + 1, &fdset, NULL, NULL, &tv) > 0) + { + rfbClientSocket = accept(rfbListenSock, &addr, &addrlen); + if (rfbClientSocket < 0) + { + error("Error accepting client (%d: %s.\n", + errno, strerror(errno)); + continue; + } + ui_create_window(); + if (!rdp_connect(server, flags, domain, password, shell, directory)) + { + error("Error connecting to RDP server.\n"); + continue; + } + if (!fork()) + { + BOOL deactivated; + uint32_t ext_disc_reason; + printf("Connection successful.\n"); + rdp_main_loop(&deactivated, &ext_disc_reason); + printf("Disconnecting...\n"); + rdp_disconnect(); + ui_destroy_window(); + exit(0); + } + } + } +} + + + + + +extern char g_title[]; +BOOL +ui_create_window() +{ + int i; + + for (i = 0; i < 0x100; i++) + reverseByte[i] = + (((i >> 7) & 1)) | (((i >> 6) & 1) << 1) | (((i >> 5) & 1) << 2) | + (((i >> 4) & 1) << 3) | (((i >> 3) & 1) << 4) | (((i >> 2) & 1) << 5) | + (((i >> 1) & 1) << 6) | (((i >> 0) & 1) << 7); + + server = rfbGetScreen(0, NULL, g_width, g_height, 8, 1, 1); + server->desktopName = g_title; + server->frameBuffer = (char *) malloc(g_width * g_height); + server->ptrAddEvent = vncMouse; + server->kbdAddEvent = vncKey; +#ifdef ENABLE_SHADOW + server->httpPort = 6124 + client_counter; + server->port = 5924 + client_counter; + rfbInitSockets(server); + server->alwaysShared = TRUE; + server->neverShared = FALSE; +#else + server->port = -1; + server->alwaysShared = FALSE; + server->neverShared = FALSE; +#endif + server->inetdSock = rfbClientSocket; + server->serverFormat.trueColour = FALSE; /* activate colour maps */ + server->deferUpdateTime = defer_time; + + frameBuffer = (vncBuffer *) malloc(sizeof(vncBuffer)); + frameBuffer->w = g_width; + frameBuffer->h = g_height; + frameBuffer->linew = g_width; + frameBuffer->data = server->frameBuffer; + frameBuffer->owner = FALSE; + frameBuffer->format = &server->serverFormat; + + ui_set_clip(0, 0, g_width, g_height); + + rfbInitServer(server); +#ifndef ENABLE_SHADOW + server->port = rfb_port; +#else + fprintf(stderr, "server listening on port %d (socket %d)\n", server->port, + server->listenSock); +#endif + + init_keyboard(); + + return (server != NULL); +} + +void +ui_destroy_window() +{ + rfbCloseClient(server->clientHead); +} + + +int +ui_select(int rdpSocket) +{ + fd_set fds; + struct timeval tv; + int n, m = server->maxFd; + + if (rdpSocket > m) + m = rdpSocket; + while (1) + { + fds = server->allFds; + FD_SET(rdpSocket, &fds); + tv.tv_sec = defer_time / 1000; + tv.tv_usec = (defer_time % 1000) * 1000; + n = select(m + 1, &fds, NULL, NULL, &tv); + rfbProcessEvents(server, 0); + /* if client is gone, close connection */ + if (!server->clientHead) + close(rdpSocket); + if (FD_ISSET(rdpSocket, &fds)) + return 1; + } + return 0; +} + +void +ui_move_pointer(int x, int y) +{ + // TODO: Is there a way to send x,y even if cursor encoding is active? + rfbUndrawCursor(server); + server->cursorX = x; + server->cursorY = y; +} + +HBITMAP +ui_create_bitmap(int width, int height, uint8 * data) +{ + vncBuffer *buf; + + buf = vncNewBuffer(width, height, 8); + memcpy(buf->data, data, width * height); + + return (HBITMAP) buf; +} + +void +ui_paint_bitmap(int x, int y, int cx, int cy, int width, int height, uint8 * data) +{ + vncBuffer *buf; + buf = ui_create_bitmap(width, height, data); + vncCopyBlitFrom(server, x, y, cx, cy, buf, 0, 0); + vncDeleteBuffer(buf); +} + +void +ui_destroy_bitmap(HBITMAP bmp) +{ + vncDeleteBuffer((vncBuffer *) bmp); +} + +uint8_t +vncLookupColour(rfbColourMap * colourMap, uint8_t * p) +{ + uint8_t i, i1 = 0; + uint8_t *cm = colourMap->data.bytes; + uint32_t m, m1 = abs(cm[0] - p[0]) + abs(cm[1] - p[1]) + abs(cm[2] - p[2]); + for (i = 1; i < 255; i++) + { + m = abs(cm[i * 3] - p[0]) + abs(cm[i * 3 + 1] - p[1]) + abs(cm[i * 3 + 2] - p[2]); + if (m < m1) + { + m1 = m; + i1 = i; + } + } + return (i1); +} + +HCURSOR +ui_create_cursor(unsigned int x, unsigned int y, int width, int height, uint8 * mask, uint8 * data) +{ + int i, j; + uint8_t *d0, *d1; + uint8_t *cdata; + uint8_t white[3] = { 0xff, 0xff, 0xff }; + uint8_t black[3] = { 0, 0, 0 }; + uint8_t *cur; + rfbCursorPtr cursor; + rfbColourMap *colourMap = &server->colourMap; + + cdata = xmalloc(sizeof(uint8_t) * width * height); + d0 = xmalloc(sizeof(uint32_t) * width * height / 4); + d1 = (uint8_t *) mask; + for (j = 0; j < height; j++) + for (i = 0; i < width / 8; i++) + { + d0[j * width / 8 + i] = d1[(height - 1 - j) * width / 8 + i] ^ 0xffffffff; + } + for (j = 0; j < height; j++) + { + for (i = 0; i < width; i++) + { + //strange that the pointer is in 24bit depth when everything + //else is in 8bit palletized. + cur = data + ((height - 1 - j) * width + i) * 3; + if (cur[0] > 0x80 || cur[1] > 0x80 || cur[2] > 0x80) + { + if (!(d0[(j * width + i) / 8] & (0x80 >> (i & 7)))) + { + /* text cursor! */ + cdata[j * width + i] = vncLookupColour(colourMap, black); + d0[(j * width + i) / 8] |= 0x80 >> (i & 7); + } + else + cdata[j * width + i] = vncLookupColour(colourMap, white); + } + else + cdata[j * width + i] = vncLookupColour(colourMap, cur); + } + } + cursor = (rfbCursorPtr) xmalloc(sizeof(rfbCursor)); + cursor->width = width; + cursor->height = height; + cursor->xhot = x; + cursor->yhot = y; + cursor->mask = (char *) d0; + cursor->source = 0; + cursor->richSource = cdata; + cursor->cleanup = 0; // workaround: this produces a memleak + + cursor->backRed = cursor->backGreen = cursor->backBlue = 0xffff; + cursor->foreRed = cursor->foreGreen = cursor->foreBlue = 0; + + return (HCURSOR) cursor; +} + +void +ui_set_cursor(HCURSOR cursor) +{ + /* FALSE means: don't delete old cursor */ + rfbSetCursor(server, (rfbCursorPtr) cursor, FALSE); +} + +void +ui_destroy_cursor(HCURSOR cursor) +{ + if (cursor) + rfbFreeCursor((rfbCursorPtr) cursor); +} + +void +ui_set_null_cursor(void) +{ + rfbSetCursor(server, 0, FALSE); +} + +HGLYPH +ui_create_glyph(int width, int height, uint8 * data) +{ + int x, y; + vncBuffer *buf; + + buf = vncNewBuffer(width, height, 8); + + //data is padded to multiple of 16bit line lengths + for (y = 0; y < height; y++) + { + for (x = 0; x < width; x++) + { + int byte = x / 8 + (y * ((width + 7) / 8)); + byte = rfbEndianTest ? reverseByte[data[byte]] : data[byte]; + byte = (byte >> (x & 7)) & 0x01; + vncSetPixel(buf, x, y, byte ? 0x7f : 0x00); + } + } + + return (HGLYPH) buf; +} + +void +ui_destroy_glyph(HGLYPH glyph) +{ + ui_destroy_bitmap((HBITMAP) glyph); +} + +HCOLOURMAP +ui_create_colourmap(COLOURMAP * colours) +{ + int i; + rfbColourMap *map = vncNewColourMap(server, colours->ncolours); + for (i = 0; i < colours->ncolours; i++) + { + vncSetColourMapEntry(map, i, colours->colours[i].red, + colours->colours[i].green, colours->colours[i].blue); + } + return map; +} + +void +ui_destroy_colourmap(HCOLOURMAP map) +{ + vncDeleteColourMap(map); +} + +void +ui_set_colourmap(HCOLOURMAP map) +{ + vncSetColourMap(server, map); +} + +void +ui_set_clip(int x, int y, int cx, int cy) +{ + clipX = x; + clipY = y; + clipW = cx; + clipH = cy; +} + +void +ui_reset_clip() +{ + clipX = 0; + clipY = 0; + clipW = 64000; + clipH = 64000; +} + +void +ui_bell() +{ + rfbSendBell(server); +} + +void +ui_destblt(uint8 opcode, + /* dest */ int x, int y, int cx, int cy) +{ + int i; + vncBuffer *buf; + + switch (opcode) + { + case 0: + case 15: + ui_rect(x, y, cx, cy, 0xff); + break; + case 5: // invert + buf = vncGetRect(server, x, y, cx, cy); + for (i = 0; i < cx * cy; i++) + ((char *) (buf->data))[i] = !((char *) (buf->data))[i]; + break; + default: + unimpl("ui_destblt: opcode=%d %d,%d %dx%d\n", opcode, x, y, cx, cy); + } +} + +void +ui_patblt(uint8 opcode, + /* dest */ int x, int y, int cx, int cy, + /* brush */ BRUSH * brush, int bgcolour, int fgcolour) +{ + switch (brush->style) + { + case 0: /* Solid */ + switch (opcode) + { + case ROP2_XOR: + { + int xx, yy; + vncBuffer *fill = vncNewBuffer(cx, cy, 8); + for (yy = 0; yy < cy; yy++) + for (xx = 0; xx < cx; xx++) + vncSetPixel(fill, xx, yy, fgcolour); + if (vncwinClipRect(&x, &y, &cx, &cy)) + vncXorBlitFrom(server, x, y, cx, cy, fill, + 0, 0); + break; + } + + default: + if (vncwinClipRect(&x, &y, &cx, &cy)) + vncSetRect(server, x, y, cx, cy, fgcolour); + } + break; + + case 3: /* Pattern */ + { + int xx, yy; + vncBuffer *fill; + fill = (vncBuffer *) ui_create_glyph(8, 8, brush->pattern); + + for (yy = 0; yy < 8; yy++) + { + for (xx = 0; xx < 8; xx++) + { + vncSetPixel(fill, xx, yy, + vncGetPixel(fill, xx, + yy) ? fgcolour : bgcolour); + } + } + + if (vncwinClipRect(&x, &y, &cx, &cy)) + { + switch (opcode) + { + case ROP2_COPY: + vncCopyBlitFrom(server, x, y, cx, cy, fill, + 0, 0); + break; + case ROP2_XOR: + vncXorBlitFrom(server, x, y, cx, cy, fill, + 0, 0); + break; + default: + unimpl("pattern blit (%d,%d) opcode=%d bg=%d fg=%d\n", x, y, opcode, bgcolour, fgcolour); + vncCopyBlitFrom(server, x, y, cx, cy, fill, + 0, 0); + break; + } + } + + ui_destroy_glyph((HGLYPH) fill); + break; + + } + default: + unimpl("brush %d\n", brush->style); + } +} + +void +ui_screenblt(uint8 opcode, + /* dest */ int x, int y, int cx, int cy, + /* src */ int srcx, int srcy) +{ + int ox, oy; + + ox = x; + oy = y; + if (vncwinClipRect(&x, &y, &cx, &cy)) + { + //if we clipped top or left, we have to adjust srcx,srcy; + srcx += x - ox; + srcy += y - oy; + vncCopyBlit(server, x, y, cx, cy, srcx, srcy); + } +} + +void +ui_memblt(uint8 opcode, + /* dest */ int x, int y, int cx, int cy, + /* src */ HBITMAP src, int srcx, int srcy) +{ + int ox, oy; + ox = x; + oy = y; + + if (vncwinClipRect(&x, &y, &cx, &cy)) + { + //if we clipped top or left, we have to adjust srcx,srcy; + srcx += x - ox; + srcy += y - oy; + switch (ROP2_S(opcode)) + { + case ROP2_OR: + vncTransBlitFrom(server, x, y, cx, cy, (vncBuffer *) src, srcx, + srcy, 0x0); + break; + case ROP2_XOR: + vncXorBlitFrom(server, x, y, cx, cy, (vncBuffer *) src, srcx, srcy); + break; + case ROP2_AND: + vncAndBlitFrom(server, x, y, cx, cy, (vncBuffer *) src, srcx, srcy); + break; + case ROP2_COPY: + vncCopyBlitFrom(server, x, y, cx, cy, (vncBuffer *) src, srcx, + srcy); + break; + default: + unimpl("ui_memblt: op%d %d,%d %dx%d\n", opcode, x, y, cx, cy); + vncCopyBlitFrom(server, x, y, cx, cy, (vncBuffer *) src, srcx, + srcy); + break; + } + } +} + +void +ui_triblt(uint8 opcode, + /* dest */ int x, int y, int cx, int cy, + /* src */ HBITMAP src, int srcx, int srcy, + /* brush */ BRUSH * brush, int bgcolour, int fgcolour) +{ + /* This is potentially difficult to do in general. Until someone + comes up with a more efficient way of doing it I am using cases. */ + + switch (opcode) + { + case 0x69: /* PDSxxn */ + ui_memblt(ROP2_XOR, x, y, cx, cy, src, srcx, srcy); + ui_patblt(ROP2_NXOR, x, y, cx, cy, brush, bgcolour, fgcolour); + break; + + case 0xb8: /* PSDPxax */ + ui_patblt(ROP2_XOR, x, y, cx, cy, brush, bgcolour, fgcolour); + ui_memblt(ROP2_AND, x, y, cx, cy, src, srcx, srcy); + ui_patblt(ROP2_XOR, x, y, cx, cy, brush, bgcolour, fgcolour); + break; + + default: + unimpl("ui_triblt 1x%x\n", opcode); + ui_memblt(ROP2_COPY, x, y, cx, cy, src, srcx, srcy); + } + +} + +void +ui_line(uint8 opcode, + /* dest */ int startx, int starty, int endx, int endy, + /* pen */ PEN * pen) +{ + //vncSetRect(server,startx,starty,1+endx-startx,endy-starty,pen->colour); + //unimpl("drawline: pen colour=%d\n",pen->colour); + /* TODO: implement opcodes */ + rfbDrawLine(server, startx, starty, endx, endy, pen->colour); +} + +void +ui_rect( + /* dest */ int x, int y, int cx, int cy, + /* brush */ int colour) +{ + if (vncwinClipRect(&x, &y, &cx, &cy)) + { + vncSetRect(server, x, y, cx, cy, colour); + } +} + +void +ui_draw_glyph(int mixmode, + /* dest */ int x, int y, int cx, int cy, + /* src */ HGLYPH glyph, int srcx, int srcy, + /* colours */ int bgcolour, int fgcolour) +{ + int xx, yy; + int ox, oy; + vncBuffer *buf = vncDupBuffer(glyph); + + x &= 0xffff; + y &= 0xffff; + + /* yes, sometimes same fgcolour and bgcolour are sent, but because + * of transparency, we have to change that! */ + if (mixmode == MIX_TRANSPARENT && fgcolour == bgcolour) + bgcolour = fgcolour ^ 0xff; + + ox = x; + oy = y; + + for (yy = srcy; yy < srcy + cy; yy++) + { + for (xx = srcx; xx < srcx + cx; xx++) + { + vncSetPixel(buf, xx, yy, vncGetPixel(buf, xx, yy) ? fgcolour : bgcolour); + } + } + + switch (mixmode) + { + case MIX_TRANSPARENT: + if (vncwinClipRect(&x, &y, &cx, &cy)) + { + //if we clipped top or left, we have to adjust srcx,srcy; + srcx += x - ox; + srcy += y - oy; + vncTransBlitFrom(server, x, y, cx, cy, buf, srcx, srcy, bgcolour); + } + break; + case MIX_OPAQUE: + if (vncwinClipRect(&x, &y, &cx, &cy)) + { + //if we clipped top or left, we have to adjust srcx,srcy; + srcx += x - ox; + srcy += y - oy; + vncCopyBlitFrom(server, x, y, cx, cy, buf, srcx, srcy); + } + break; + + default: + unimpl("mix %d\n", mixmode); + } + vncDeleteBuffer(buf); +} + +#define DO_GLYPH(ttext,idx) \ +{\ + glyph = cache_get_font (font, ttext[idx]);\ + if (!(flags & TEXT2_IMPLICIT_X))\ + {\ + offset = ttext[++idx];\ + if ((offset & 0x80))\ + offset = ((offset & 0x7f) << 8) | ttext[++idx];\ + if (flags & TEXT2_VERTICAL)\ + y += offset;\ + else\ + x += offset;\ + }\ + if (glyph != NULL)\ + {\ + ui_draw_glyph (mixmode, x + (short) glyph->offset,\ + y + (short) glyph->baseline,\ + glyph->width, glyph->height,\ + glyph->pixmap, 0, 0, bgcolour, fgcolour);\ + if (flags & TEXT2_IMPLICIT_X)\ + x += glyph->width;\ + }\ +} + + +void +ui_draw_text(uint8 font, uint8 flags, int mixmode, int x, int y, + int clipx, int clipy, int clipcx, int clipcy, + int boxx, int boxy, int boxcx, int boxcy, + int bgcolour, int fgcolour, uint8 * text, uint8 length) +{ + FONTGLYPH *glyph; + int i, j, offset; + DATABLOB *entry; + + if (boxcx > 1) + { + ui_rect(boxx, boxy, boxcx, boxcy, bgcolour); + } + else if (mixmode == MIX_OPAQUE) + { + ui_rect(clipx, clipy, clipcx, clipcy, bgcolour); + } + + /* Paint text, character by character */ + for (i = 0; i < length;) + { + switch (text[i]) + { + case 0xff: + if (i + 2 < length) + cache_put_text(text[i + 1], &(text[i - text[i + 2]]), + text[i + 2]); + else + { + error("this shouldn't be happening\n"); + break; + } + /* this will move pointer from start to first character after FF command */ + length -= i + 3; + text = &(text[i + 3]); + i = 0; + break; + + case 0xfe: + entry = cache_get_text(text[i + 1]); + if (entry != NULL) + { + if ((((uint8 *) (entry->data))[1] == 0) + && (!(flags & TEXT2_IMPLICIT_X))) + { + if (flags & 0x04) /* vertical text */ + y += text[i + 2]; + else + x += text[i + 2]; + } + if (i + 2 < length) + i += 3; + else + i += 2; + length -= i; + /* this will move pointer from start to first character after FE command */ + text = &(text[i]); + i = 0; + for (j = 0; j < entry->size; j++) + DO_GLYPH(((uint8 *) (entry->data)), j); + } + break; + default: + DO_GLYPH(text, i); + i++; + break; + } + } +} + +void +ui_desktop_save(uint32 offset, int x, int y, int cx, int cy) +{ + vncBuffer *buf; + + buf = vncGetRect(server, x, y, cx, cy); + offset *= TOBYTES(server->serverFormat.bitsPerPixel); + cache_put_desktop(offset, cx, cy, cx, TOBYTES(server->serverFormat.bitsPerPixel), + (buf->data)); +} + +void +ui_desktop_restore(uint32 offset, int x, int y, int cx, int cy) +{ + uint8 *data; + vncBuffer *buf; + int ox, oy, srcx, srcy; + + srcx = srcy = 0; + ox = x; + oy = y; + + offset *= TOBYTES(server->serverFormat.bitsPerPixel); + data = cache_get_desktop(offset, cx, cy, TOBYTES(server->serverFormat.bitsPerPixel)); + if (data == NULL) + return; + + buf = vncNewBuffer(cx, cy, 8); + memcpy(buf->data, data, cx * cy * 1); + + if (vncwinClipRect(&x, &y, &cx, &cy)) + { + srcx += x - ox; + srcy += y - oy; + vncCopyBlitFrom(server, x, y, cx, cy, buf, srcx, srcy); + } + vncDeleteBuffer(buf); +} + +rfbPixelFormat vnc_formats[] = { + /* bpp, depth,BE,TC, rmax, gmax, bmax, rsh, gsh, bsh */ + {8, 8, 1, 0, 7, 7, 3, 0, 3, 6} + , + {16, 16, 1, 1, 31, 63, 31, 0, 5, 10} + , + {32, 24, 1, 1, 255, 255, 255, 0, 8, 16} + , //non-existant + {32, 32, 1, 1, 2047, 2047, 1023, 0, 11, 22} +}; + +rfbPixelFormat * +vncNewFormat(int depth) +{ + return &(vnc_formats[(depth + 1) / 8 - 1]); +} + +vncBuffer * +vncNewBuffer(int w, int h, int depth) +{ + vncBuffer *b = (vncBuffer *) xmalloc(sizeof(vncBuffer)); + b->format = vncNewFormat(depth); + b->data = (void *) xmalloc(w * h * (b->format->bitsPerPixel / 8)); + b->owner = 1; + b->w = w; + b->h = h; + b->linew = w; + return b; +} + +vncBuffer * +vncDupBuffer(vncBuffer * b) +{ + vncBuffer *buf = vncNewBuffer(b->w, b->h, b->format->depth); + memcpy(buf->data, b->data, b->linew * b->h * b->format->bitsPerPixel / 8); + return buf; +} + +void +vncPrintStats() +{ + if (server && server->clientHead) + rfbPrintStats(server->clientHead); +} + +/* blit */ + +#define GETPIXEL(buf,x,y) \ + (((uint8_t*)(buf->data))[(x)+((y)*buf->linew)]) +#define SETPIXEL(buf,x,y,p) \ + (((uint8_t*)(buf->data))[(x)+((y)*buf->linew)] = (uint8_t)p) + +void +vncCopyBlitFromNoEncode(rfbScreenInfoPtr s, int x, int y, int w, int h, + vncBuffer * src, int srcx, int srcy) +{ + int xx, yy; + + vncHideCursor(); + + if (s->serverFormat.bitsPerPixel == src->format->bitsPerPixel + && srcx + w <= src->w && srcy + h <= src->h) + { + //simple copy + uint8_t *srcdata, *dstdata; + srcdata = src->data + (srcy * src->linew + srcx); + dstdata = s->frameBuffer + (y * s->paddedWidthInBytes + x); + for (yy = 0; yy < h; yy++) + { + memcpy(dstdata, srcdata, w); + dstdata += s->paddedWidthInBytes; + srcdata += src->linew; + } + } + else + { + // xsrc,ysrc provide tiling copy support. + for (yy = y; yy < y + h; yy++) + { + int ysrc = srcy + yy - y; + while (ysrc >= src->h) + ysrc -= src->h; + for (xx = x; xx < x + w; xx++) + { + vncPixel p; + int xsrc = srcx + xx - x; + while (xsrc >= src->linew) + xsrc -= src->linew; + p = GETPIXEL(src, xsrc, ysrc); + SETPIXEL(frameBuffer, xx, yy, p); + } + } + } +} + +void +vncCopyBlit(rfbScreenInfoPtr s, int x, int y, int w, int h, int srcx, int srcy) +{ + /* LibVNCServer already knows how to copy the data. */ + rfbDoCopyRect(s, x, y, x + w, y + h, x - srcx, y - srcy); +} + +void +vncCopyBlitFrom(rfbScreenInfoPtr s, int x, int y, int w, int h, vncBuffer * src, int srcx, int srcy) +{ + vncCopyBlitFromNoEncode(s, x, y, w, h, src, srcx, srcy); + rfbMarkRectAsModified(s, x, y, x + w, y + h); +} + +void +vncTransBlitFrom(rfbScreenInfoPtr s, int x, int y, int w, int h, + vncBuffer * src, int srcx, int srcy, int bg) +{ + int xx, yy; + + vncHideCursor(); + + // xsrc,ysrc provide tiling copy support. + for (yy = y; yy < y + h; yy++) + { + int ysrc = srcy + yy - y; + while (ysrc >= src->h) + ysrc -= src->h; + for (xx = x; xx < x + w; xx++) + { + vncPixel p; + int xsrc = srcx + xx - x; + while (xsrc >= src->linew) + xsrc -= src->linew; + p = GETPIXEL(src, xsrc, ysrc); + // transparent blit! + if (p != bg) + SETPIXEL(frameBuffer, xx, yy, p); + } + } + + rfbMarkRectAsModified(s, x, y, x + w, y + h); +} + +void +vncXorBlitFrom(rfbScreenInfoPtr s, int x, int y, int w, int h, vncBuffer * src, int srcx, int srcy) +{ + int xx, yy; + + vncHideCursor(); + + // xsrc,ysrc provide tiling copy support. + for (yy = y; yy < y + h; yy++) + { + int ysrc = srcy + yy - y; + while (ysrc >= src->h) + ysrc -= src->h; + for (xx = x; xx < x + w; xx++) + { + vncPixel p, pp; + int xsrc = srcx + xx - x; + while (xsrc >= src->linew) + xsrc -= src->linew; + p = GETPIXEL(src, xsrc, ysrc); + pp = GETPIXEL(frameBuffer, xx, yy); + // xor blit! + SETPIXEL(frameBuffer, xx, yy, p ^ pp); + } + } + + rfbMarkRectAsModified(s, x, y, x + w, y + h); +} + +void +vncAndBlitFrom(rfbScreenInfoPtr s, int x, int y, int w, int h, vncBuffer * src, int srcx, int srcy) +{ + int xx, yy; + + vncHideCursor(); + + // xsrc,ysrc provide tiling copy support. + for (yy = y; yy < y + h; yy++) + { + int ysrc = srcy + yy - y; + while (ysrc >= src->h) + ysrc -= src->h; + for (xx = x; xx < x + w; xx++) + { + vncPixel p, pp; + int xsrc = srcx + xx - x; + while (xsrc >= src->linew) + xsrc -= src->linew; + p = GETPIXEL(src, xsrc, ysrc); + pp = GETPIXEL(frameBuffer, xx, yy); + // and blit! + SETPIXEL(frameBuffer, xx, yy, p & pp); + } + } + + rfbMarkRectAsModified(s, x, y, x + w, y + h); +} + +void +vncDeleteBuffer(vncBuffer * b) +{ + if (b->owner) + xfree(b->data); + xfree(b); +} + +/* cursor */ +rfbCursorPtr +vncNewCursor(vncBuffer * mask, vncBuffer * pointer, int hotx, int hoty) +{ + int i, j, w = (mask->w + 7) / 8, mask_size = w * mask->h, + pointer_size = pointer->w * pointer->h; + rfbCursorPtr c = (rfbCursorPtr) xmalloc(sizeof(rfbCursor)); + + if (mask->w != pointer->w || mask->h != pointer->h) + error("ERROR! Mask is %dx%d, Pointer is %dx%d\n", + mask->w, mask->h, pointer->w, pointer->h); + + c->xhot = hotx; + c->yhot = hoty; + c->width = mask->w; + c->height = mask->h; + + c->mask = (char *) xmalloc(mask_size); + for (j = 0; j < c->height; j++) + for (i = 0; i < w; i++) + c->mask[j * w + i] = + reverseByte[((unsigned char *) mask->data)[(j) * w + i]]; + vncDeleteBuffer(mask); + + c->source = 0; + c->richSource = (char *) xmalloc(pointer_size); + memcpy(c->richSource, pointer->data, pointer_size); + vncDeleteBuffer(pointer); + + return c; +} + +/* No FreeCursor, because the cursors are buffered. We only get a "HANDLE" */ +void +vncSetCursor(rfbScreenInfoPtr s, rfbCursorPtr c) +{ + rfbSetCursor(s, c, FALSE); +} + +/* these functions work even if vncBuffer's pixel format is not 1 byte/pixel */ +vncPixel +vncGetPixel(vncBuffer * b, int x, int y) +{ + unsigned long offset = (x + (y * (b->linew))) * (b->format->bitsPerPixel >> 3); + return ((uint8_t *) (b->data))[offset]; +} + +void +vncSetPixel(vncBuffer * b, int x, int y, vncPixel c) +{ + unsigned long offset = (x + (y * (b->linew))) * (b->format->bitsPerPixel >> 3); + ((uint8_t *) (b->data))[offset] = c; +} + +void +vncSetRect(rfbScreenInfoPtr s, int x, int y, int w, int h, vncPixel c) +{ + int xx, yy; + + if (x + w > s->width) + w = s->width - x; + if (y + h > s->height) + h = s->height - y; + if (w <= 0 || h <= 0) + return; + + vncHideCursor(); + + // - Fill the rect in the local framebuffer + if (s->serverFormat.bitsPerPixel == 8) + { + // - Simple 8-bit fill + uint8_t *dstdata; + dstdata = s->frameBuffer + (y * s->paddedWidthInBytes + x); + for (yy = 0; yy < h; yy++) + { + memset(dstdata, c, w); + dstdata += s->paddedWidthInBytes; + } + } + else + { + for (yy = y; yy < y + h; yy++) + { + for (xx = x; xx < x + w; xx++) + { + SETPIXEL(frameBuffer, xx, yy, c); + } + } + } + + rfbMarkRectAsModified(s, x, y, x + w, y + h); +} + +vncBuffer * +vncGetRect(rfbScreenInfoPtr s, int x, int y, int w, int h) +{ + int xx, yy; + vncBuffer *b = vncNewBuffer(w, h, s->serverFormat.depth); + + vncHideCursor(); + + if (s->serverFormat.bitsPerPixel == 8) + { + //simple copy + int srcstep, dststep; + char *srcdata, *dstdata; + srcstep = s->paddedWidthInBytes * s->serverFormat.bitsPerPixel / 8; + dststep = w * s->serverFormat.bitsPerPixel / 8; + dstdata = b->data; + srcdata = s->frameBuffer + (y * srcstep + x * s->serverFormat.bitsPerPixel / 8); + for (yy = 0; yy < h; yy++) + { + memcpy(dstdata, srcdata, dststep); + dstdata += dststep; + srcdata += srcstep; + } + } + else + { + for (yy = y; yy < y + h; yy++) + { + for (xx = x; xx < x + w; xx++) + { + SETPIXEL(b, xx - x, yy - y, GETPIXEL(frameBuffer, xx, yy)); + } + } + } + + return b; +} + +/* colourmap */ + +rfbColourMap * +vncNewColourMap(rfbScreenInfoPtr s, int n) +{ + rfbColourMap *m = (rfbColourMap *) xmalloc(sizeof(rfbColourMap)); + m->is16 = FALSE; + m->count = n; + m->data.bytes = (uint8_t *) xmalloc(n * 3); + return m; +} + +void +vncSetColourMapEntry(rfbColourMap * m, int i, vncPixel r, vncPixel g, vncPixel b) +{ + if (i < m->count) + { + m->data.bytes[3 * i + 0] = r; + m->data.bytes[3 * i + 1] = g; + m->data.bytes[3 * i + 2] = b; + } +} + +void +vncDeleteColourMap(rfbColourMap * m) +{ + if (m->data.bytes) + free(m->data.bytes); + m->count = 0; +} + +void +vncSetColourMap(rfbScreenInfoPtr s, rfbColourMap * m) +{ + vncDeleteColourMap(&s->colourMap); + s->colourMap = *m; + rfbSetClientColourMaps(s, 0, 0); +} + +void +ui_begin_update() +{ +} + +void +ui_end_update() +{ +} + +void +ui_resize_window() +{ + rfbClientIteratorPtr iter; + rfbClientPtr cl; + + server->width = g_width; + server->height = g_height; + server->frameBuffer = (char *) realloc(server->frameBuffer, g_width * g_height); + server->paddedWidthInBytes = g_width; + + iter = rfbGetClientIterator(server); + while ((cl = rfbClientIteratorNext(iter))) + if (cl->useNewFBSize) + cl->newFBSizePending = TRUE; + else + rfbLog("Warning: Client %s does not support NewFBSize!\n ", cl->host); + rfbReleaseClientIterator(iter); +} diff -urN rdesktop-1.5.0.org/vnc/vnc.h rdesktop-1.5.0/vnc/vnc.h --- rdesktop-1.5.0.org/vnc/vnc.h 1970-01-01 01:00:00.000000000 +0100 +++ rdesktop-1.5.0/vnc/vnc.h 2003-02-20 13:17:04.000000000 +0100 @@ -0,0 +1,68 @@ +#ifndef VNC_H +#define VNC_H + +#define BOOL rfb_BOOL +#include +#undef BOOL + +typedef unsigned int vncPixel; + +typedef struct +{ + uint16_t w, h; + uint16_t linew; + rfbPixelFormat *format; + char *data; + BOOL owner; +} +vncBuffer; + +extern int vncPreparedClientSocket; +extern int vncPreparedServerSocket; + +/* - Buffer management */ +extern vncBuffer *vncNewBuffer(int w, int h, int depth); +extern vncBuffer *vncDupBuffer(vncBuffer * b); +extern void vncDeleteBuffer(vncBuffer * b); + +/* - Colourmaps */ +typedef struct +{ + uint8_t r, g, b; +} +vncColour; + +extern void vncSetColourMap(rfbScreenInfoPtr s, rfbColourMap * m); +extern rfbColourMap *vncNewColourMap(rfbScreenInfoPtr s, int n); +extern void vncSetColourMapEntry(rfbColourMap * m, int i, vncPixel r, vncPixel g, vncPixel b); +extern void vncDeleteColourMap(rfbColourMap * m); + +/* - Simple pixel manipulation */ +extern vncPixel vncGetPixel(vncBuffer * b, int x, int y); +extern void vncSetPixel(vncBuffer * b, int x, int y, vncPixel c); + +/* - Drawing primitives */ +extern void vncSetRect(rfbScreenInfoPtr s, int x, int y, int w, int h, vncPixel c); +extern void vncCopyBlit(rfbScreenInfoPtr s, int x, int y, int w, int h, int srcx, int srcy); +extern void vncCopyBlitFrom(rfbScreenInfoPtr s, int x, int y, int w, int h, + vncBuffer * b, int srcx, int srcy); +extern void vncTransBlitFrom(rfbScreenInfoPtr s, int x, int y, int w, int h, + vncBuffer * b, int srcx, int srcy, int bg); +extern void vncXorBlitFrom(rfbScreenInfoPtr s, int x, int y, int w, int h, + vncBuffer * b, int srcx, int srcy); +extern void vncAndBlitFrom(rfbScreenInfoPtr s, int x, int y, int w, int h, + vncBuffer * b, int srcx, int srcy); +extern vncBuffer *vncGetRect(rfbScreenInfoPtr s, int x, int y, int w, int h); + +// - Low level VNC update primitives upon which the rest are based +extern void vncQueueCopyRect(rfbScreenInfoPtr s, int x, int y, int w, int h, int src_x, int src_y); +extern void vncQueueUpdate(rfbScreenInfoPtr s, int x, int y, int w, int h); + +/* cursor */ +extern rfbCursorPtr vncNewCursor(vncBuffer * mask, vncBuffer * pointer, int hotx, int hoty); +extern void vncSetCursor(rfbScreenInfoPtr s, rfbCursorPtr c); + +int vncListenAtTcpAddr(unsigned short port); +void vncPrintStats(); + +#endif diff -urN rdesktop-1.5.0.org/vnc/x11stubs.c rdesktop-1.5.0/vnc/x11stubs.c --- rdesktop-1.5.0.org/vnc/x11stubs.c 1970-01-01 01:00:00.000000000 +0100 +++ rdesktop-1.5.0/vnc/x11stubs.c 2003-02-20 13:14:13.000000000 +0100 @@ -0,0 +1,1405 @@ +/* + +This file fakes some of X11's key handling for the special purpose of running +a standalone rdp2vnc (without linking to X11) + +*/ + +#include "x11stubs.h" +#include + +/* ignored */ +int *display; + +typedef struct +{ + const char *string; + KeySym keysym; +} +StringToKeysym_t; + +StringToKeysym_t StringToKeysym[] = { +#ifndef KEYSYMFAKE_H + {"VoidSymbol", XK_VoidSymbol}, +#ifdef XK_MISCELLANY + {"BackSpace", XK_BackSpace}, + {"Tab", XK_Tab}, + {"Linefeed", XK_Linefeed}, + {"Clear", XK_Clear}, + {"Return", XK_Return}, + {"Pause", XK_Pause}, + {"Scroll_Lock", XK_Scroll_Lock}, + {"Sys_Req", XK_Sys_Req}, + {"Escape", XK_Escape}, + {"Delete", XK_Delete}, + {"Multi_key", XK_Multi_key}, + {"SingleCandidate", XK_SingleCandidate}, + {"MultipleCandidate", XK_MultipleCandidate}, + {"PreviousCandidate", XK_PreviousCandidate}, + {"Kanji", XK_Kanji}, + {"Muhenkan", XK_Muhenkan}, + {"Henkan_Mode", XK_Henkan_Mode}, + {"Henkan", XK_Henkan}, + {"Romaji", XK_Romaji}, + {"Hiragana", XK_Hiragana}, + {"Katakana", XK_Katakana}, + {"Hiragana_Katakana", XK_Hiragana_Katakana}, + {"Zenkaku", XK_Zenkaku}, + {"Hankaku", XK_Hankaku}, + {"Zenkaku_Hankaku", XK_Zenkaku_Hankaku}, + {"Touroku", XK_Touroku}, + {"Massyo", XK_Massyo}, + {"Kana_Lock", XK_Kana_Lock}, + {"Kana_Shift", XK_Kana_Shift}, + {"Eisu_Shift", XK_Eisu_Shift}, + {"Eisu_toggle", XK_Eisu_toggle}, + {"Zen_Koho", XK_Zen_Koho}, + {"Mae_Koho", XK_Mae_Koho}, + {"Home", XK_Home}, + {"Left", XK_Left}, + {"Up", XK_Up}, + {"Right", XK_Right}, + {"Down", XK_Down}, + {"Prior", XK_Prior}, + {"Page_Up", XK_Page_Up}, + {"Next", XK_Next}, + {"Page_Down", XK_Page_Down}, + {"End", XK_End}, + {"Begin", XK_Begin}, + {"Select", XK_Select}, + {"Print", XK_Print}, + {"Execute", XK_Execute}, + {"Insert", XK_Insert}, + {"Undo", XK_Undo}, + {"Redo", XK_Redo}, + {"Menu", XK_Menu}, + {"Find", XK_Find}, + {"Cancel", XK_Cancel}, + {"Help", XK_Help}, + {"Break", XK_Break}, + {"Mode_switch", XK_Mode_switch}, + {"script_switch", XK_script_switch}, + {"Num_Lock", XK_Num_Lock}, + {"KP_Space", XK_KP_Space}, + {"KP_Tab", XK_KP_Tab}, + {"KP_Enter", XK_KP_Enter}, + {"KP_F1", XK_KP_F1}, + {"KP_F2", XK_KP_F2}, + {"KP_F3", XK_KP_F3}, + {"KP_F4", XK_KP_F4}, + {"KP_Home", XK_KP_Home}, + {"KP_Left", XK_KP_Left}, + {"KP_Up", XK_KP_Up}, + {"KP_Right", XK_KP_Right}, + {"KP_Down", XK_KP_Down}, + {"KP_Prior", XK_KP_Prior}, + {"KP_Page_Up", XK_KP_Page_Up}, + {"KP_Next", XK_KP_Next}, + {"KP_Page_Down", XK_KP_Page_Down}, + {"KP_End", XK_KP_End}, + {"KP_Begin", XK_KP_Begin}, + {"KP_Insert", XK_KP_Insert}, + {"KP_Delete", XK_KP_Delete}, + {"KP_Equal", XK_KP_Equal}, + {"KP_Multiply", XK_KP_Multiply}, + {"KP_Add", XK_KP_Add}, + {"KP_Separator", XK_KP_Separator}, + {"KP_Subtract", XK_KP_Subtract}, + {"KP_Decimal", XK_KP_Decimal}, + {"KP_Divide", XK_KP_Divide}, + {"KP_0", XK_KP_0}, + {"KP_1", XK_KP_1}, + {"KP_2", XK_KP_2}, + {"KP_3", XK_KP_3}, + {"KP_4", XK_KP_4}, + {"KP_5", XK_KP_5}, + {"KP_6", XK_KP_6}, + {"KP_7", XK_KP_7}, + {"KP_8", XK_KP_8}, + {"KP_9", XK_KP_9}, + {"F1", XK_F1}, + {"F2", XK_F2}, + {"F3", XK_F3}, + {"F4", XK_F4}, + {"F5", XK_F5}, + {"F6", XK_F6}, + {"F7", XK_F7}, + {"F8", XK_F8}, + {"F9", XK_F9}, + {"F10", XK_F10}, + {"F11", XK_F11}, + {"L1", XK_L1}, + {"F12", XK_F12}, + {"L2", XK_L2}, + {"F13", XK_F13}, + {"L3", XK_L3}, + {"F14", XK_F14}, + {"L4", XK_L4}, + {"F15", XK_F15}, + {"L5", XK_L5}, + {"F16", XK_F16}, + {"L6", XK_L6}, + {"F17", XK_F17}, + {"L7", XK_L7}, + {"F18", XK_F18}, + {"L8", XK_L8}, + {"F19", XK_F19}, + {"L9", XK_L9}, + {"F20", XK_F20}, + {"L10", XK_L10}, + {"F21", XK_F21}, + {"R1", XK_R1}, + {"F22", XK_F22}, + {"R2", XK_R2}, + {"F23", XK_F23}, + {"R3", XK_R3}, + {"F24", XK_F24}, + {"R4", XK_R4}, + {"F25", XK_F25}, + {"R5", XK_R5}, + {"F26", XK_F26}, + {"R6", XK_R6}, + {"F27", XK_F27}, + {"R7", XK_R7}, + {"F28", XK_F28}, + {"R8", XK_R8}, + {"F29", XK_F29}, + {"R9", XK_R9}, + {"F30", XK_F30}, + {"R10", XK_R10}, + {"F31", XK_F31}, + {"R11", XK_R11}, + {"F32", XK_F32}, + {"R12", XK_R12}, + {"F33", XK_F33}, + {"R13", XK_R13}, + {"F34", XK_F34}, + {"R14", XK_R14}, + {"F35", XK_F35}, + {"R15", XK_R15}, + {"Shift_L", XK_Shift_L}, + {"Shift_R", XK_Shift_R}, + {"Control_L", XK_Control_L}, + {"Control_R", XK_Control_R}, + {"Caps_Lock", XK_Caps_Lock}, + {"Shift_Lock", XK_Shift_Lock}, + {"Meta_L", XK_Meta_L}, + {"Meta_R", XK_Meta_R}, + {"Alt_L", XK_Alt_L}, + {"Alt_R", XK_Alt_R}, + {"Super_L", XK_Super_L}, + {"Super_R", XK_Super_R}, + {"Hyper_L", XK_Hyper_L}, + {"Hyper_R", XK_Hyper_R}, +#endif /* XK_MISCELLANY */ +#ifdef XK_XKB_KEYS + {"ISO_Lock", XK_ISO_Lock}, + {"ISO_Level2_Latch", XK_ISO_Level2_Latch}, + {"ISO_Level3_Shift", XK_ISO_Level3_Shift}, + {"ISO_Level3_Latch", XK_ISO_Level3_Latch}, + {"ISO_Level3_Lock", XK_ISO_Level3_Lock}, + {"ISO_Group_Shift", XK_ISO_Group_Shift}, + {"ISO_Group_Latch", XK_ISO_Group_Latch}, + {"ISO_Group_Lock", XK_ISO_Group_Lock}, + {"ISO_Next_Group", XK_ISO_Next_Group}, + {"ISO_Next_Group_Lock", XK_ISO_Next_Group_Lock}, + {"ISO_Prev_Group", XK_ISO_Prev_Group}, + {"ISO_Prev_Group_Lock", XK_ISO_Prev_Group_Lock}, + {"ISO_First_Group", XK_ISO_First_Group}, + {"ISO_First_Group_Lock", XK_ISO_First_Group_Lock}, + {"ISO_Last_Group", XK_ISO_Last_Group}, + {"ISO_Last_Group_Lock", XK_ISO_Last_Group_Lock}, + {"ISO_Left_Tab", XK_ISO_Left_Tab}, + {"ISO_Move_Line_Up", XK_ISO_Move_Line_Up}, + {"ISO_Move_Line_Down", XK_ISO_Move_Line_Down}, + {"ISO_Partial_Line_Up", XK_ISO_Partial_Line_Up}, + {"ISO_Partial_Line_Down", XK_ISO_Partial_Line_Down}, + {"ISO_Partial_Space_Left", XK_ISO_Partial_Space_Left}, + {"ISO_Partial_Space_Right", XK_ISO_Partial_Space_Right}, + {"ISO_Set_Margin_Left", XK_ISO_Set_Margin_Left}, + {"ISO_Set_Margin_Right", XK_ISO_Set_Margin_Right}, + {"ISO_Release_Margin_Left", XK_ISO_Release_Margin_Left}, + {"ISO_Release_Margin_Right", XK_ISO_Release_Margin_Right}, + {"ISO_Release_Both_Margins", XK_ISO_Release_Both_Margins}, + {"ISO_Fast_Cursor_Left", XK_ISO_Fast_Cursor_Left}, + {"ISO_Fast_Cursor_Right", XK_ISO_Fast_Cursor_Right}, + {"ISO_Fast_Cursor_Up", XK_ISO_Fast_Cursor_Up}, + {"ISO_Fast_Cursor_Down", XK_ISO_Fast_Cursor_Down}, + {"ISO_Continuous_Underline", XK_ISO_Continuous_Underline}, + {"ISO_Discontinuous_Underline", XK_ISO_Discontinuous_Underline}, + {"ISO_Emphasize", XK_ISO_Emphasize}, + {"ISO_Center_Object", XK_ISO_Center_Object}, + {"ISO_Enter", XK_ISO_Enter}, + {"dead_grave", XK_dead_grave}, + {"dead_acute", XK_dead_acute}, + {"dead_circumflex", XK_dead_circumflex}, + {"dead_tilde", XK_dead_tilde}, + {"dead_macron", XK_dead_macron}, + {"dead_breve", XK_dead_breve}, + {"dead_abovedot", XK_dead_abovedot}, + {"dead_diaeresis", XK_dead_diaeresis}, + {"dead_abovering", XK_dead_abovering}, + {"dead_doubleacute", XK_dead_doubleacute}, + {"dead_caron", XK_dead_caron}, + {"dead_cedilla", XK_dead_cedilla}, + {"dead_ogonek", XK_dead_ogonek}, + {"dead_iota", XK_dead_iota}, + {"dead_voiced_sound", XK_dead_voiced_sound}, + {"dead_semivoiced_sound", XK_dead_semivoiced_sound}, + {"dead_belowdot", XK_dead_belowdot}, + {"First_Virtual_Screen", XK_First_Virtual_Screen}, + {"Prev_Virtual_Screen", XK_Prev_Virtual_Screen}, + {"Next_Virtual_Screen", XK_Next_Virtual_Screen}, + {"Last_Virtual_Screen", XK_Last_Virtual_Screen}, + {"Terminate_Server", XK_Terminate_Server}, + {"AccessX_Enable", XK_AccessX_Enable}, + {"AccessX_Feedback_Enable", XK_AccessX_Feedback_Enable}, + {"RepeatKeys_Enable", XK_RepeatKeys_Enable}, + {"SlowKeys_Enable", XK_SlowKeys_Enable}, + {"BounceKeys_Enable", XK_BounceKeys_Enable}, + {"StickyKeys_Enable", XK_StickyKeys_Enable}, + {"MouseKeys_Enable", XK_MouseKeys_Enable}, + {"MouseKeys_Accel_Enable", XK_MouseKeys_Accel_Enable}, + {"Overlay1_Enable", XK_Overlay1_Enable}, + {"Overlay2_Enable", XK_Overlay2_Enable}, + {"AudibleBell_Enable", XK_AudibleBell_Enable}, + {"Pointer_Left", XK_Pointer_Left}, + {"Pointer_Right", XK_Pointer_Right}, + {"Pointer_Up", XK_Pointer_Up}, + {"Pointer_Down", XK_Pointer_Down}, + {"Pointer_UpLeft", XK_Pointer_UpLeft}, + {"Pointer_UpRight", XK_Pointer_UpRight}, + {"Pointer_DownLeft", XK_Pointer_DownLeft}, + {"Pointer_DownRight", XK_Pointer_DownRight}, + {"Pointer_Button_Dflt", XK_Pointer_Button_Dflt}, + {"Pointer_Button1", XK_Pointer_Button1}, + {"Pointer_Button2", XK_Pointer_Button2}, + {"Pointer_Button3", XK_Pointer_Button3}, + {"Pointer_Button4", XK_Pointer_Button4}, + {"Pointer_Button5", XK_Pointer_Button5}, + {"Pointer_DblClick_Dflt", XK_Pointer_DblClick_Dflt}, + {"Pointer_DblClick1", XK_Pointer_DblClick1}, + {"Pointer_DblClick2", XK_Pointer_DblClick2}, + {"Pointer_DblClick3", XK_Pointer_DblClick3}, + {"Pointer_DblClick4", XK_Pointer_DblClick4}, + {"Pointer_DblClick5", XK_Pointer_DblClick5}, + {"Pointer_Drag_Dflt", XK_Pointer_Drag_Dflt}, + {"Pointer_Drag1", XK_Pointer_Drag1}, + {"Pointer_Drag2", XK_Pointer_Drag2}, + {"Pointer_Drag3", XK_Pointer_Drag3}, + {"Pointer_Drag4", XK_Pointer_Drag4}, + {"Pointer_Drag5", XK_Pointer_Drag5}, + {"Pointer_EnableKeys", XK_Pointer_EnableKeys}, + {"Pointer_Accelerate", XK_Pointer_Accelerate}, + {"Pointer_DfltBtnNext", XK_Pointer_DfltBtnNext}, + {"Pointer_DfltBtnPrev", XK_Pointer_DfltBtnPrev}, +#endif +#ifdef XK_3270 + {"3270_Duplicate", XK_3270_Duplicate}, + {"3270_FieldMark", XK_3270_FieldMark}, + {"3270_Right2", XK_3270_Right2}, + {"3270_Left2", XK_3270_Left2}, + {"3270_BackTab", XK_3270_BackTab}, + {"3270_EraseEOF", XK_3270_EraseEOF}, + {"3270_EraseInput", XK_3270_EraseInput}, + {"3270_Reset", XK_3270_Reset}, + {"3270_Quit", XK_3270_Quit}, + {"3270_PA1", XK_3270_PA1}, + {"3270_PA2", XK_3270_PA2}, + {"3270_PA3", XK_3270_PA3}, + {"3270_Test", XK_3270_Test}, + {"3270_Attn", XK_3270_Attn}, + {"3270_CursorBlink", XK_3270_CursorBlink}, + {"3270_AltCursor", XK_3270_AltCursor}, + {"3270_KeyClick", XK_3270_KeyClick}, + {"3270_Jump", XK_3270_Jump}, + {"3270_Ident", XK_3270_Ident}, + {"3270_Rule", XK_3270_Rule}, + {"3270_Copy", XK_3270_Copy}, + {"3270_Play", XK_3270_Play}, + {"3270_Setup", XK_3270_Setup}, + {"3270_Record", XK_3270_Record}, + {"3270_ChangeScreen", XK_3270_ChangeScreen}, + {"3270_DeleteWord", XK_3270_DeleteWord}, + {"3270_ExSelect", XK_3270_ExSelect}, + {"3270_CursorSelect", XK_3270_CursorSelect}, + {"3270_PrintScreen", XK_3270_PrintScreen}, + {"3270_Enter", XK_3270_Enter}, +#endif +#ifdef XK_LATIN1 + {"space", XK_space}, + {"exclam", XK_exclam}, + {"quotedbl", XK_quotedbl}, + {"numbersign", XK_numbersign}, + {"dollar", XK_dollar}, + {"percent", XK_percent}, + {"ampersand", XK_ampersand}, + {"apostrophe", XK_apostrophe}, + {"quoteright", XK_quoteright}, + {"parenleft", XK_parenleft}, + {"parenright", XK_parenright}, + {"asterisk", XK_asterisk}, + {"plus", XK_plus}, + {"comma", XK_comma}, + {"minus", XK_minus}, + {"period", XK_period}, + {"slash", XK_slash}, + {"0", XK_0}, + {"1", XK_1}, + {"2", XK_2}, + {"3", XK_3}, + {"4", XK_4}, + {"5", XK_5}, + {"6", XK_6}, + {"7", XK_7}, + {"8", XK_8}, + {"9", XK_9}, + {"colon", XK_colon}, + {"semicolon", XK_semicolon}, + {"less", XK_less}, + {"equal", XK_equal}, + {"greater", XK_greater}, + {"question", XK_question}, + {"at", XK_at}, + {"A", XK_A}, + {"B", XK_B}, + {"C", XK_C}, + {"D", XK_D}, + {"E", XK_E}, + {"F", XK_F}, + {"G", XK_G}, + {"H", XK_H}, + {"I", XK_I}, + {"J", XK_J}, + {"K", XK_K}, + {"L", XK_L}, + {"M", XK_M}, + {"N", XK_N}, + {"O", XK_O}, + {"P", XK_P}, + {"Q", XK_Q}, + {"R", XK_R}, + {"S", XK_S}, + {"T", XK_T}, + {"U", XK_U}, + {"V", XK_V}, + {"W", XK_W}, + {"X", XK_X}, + {"Y", XK_Y}, + {"Z", XK_Z}, + {"bracketleft", XK_bracketleft}, + {"backslash", XK_backslash}, + {"bracketright", XK_bracketright}, + {"asciicircum", XK_asciicircum}, + {"underscore", XK_underscore}, + {"grave", XK_grave}, + {"quoteleft", XK_quoteleft}, + {"a", XK_a}, + {"b", XK_b}, + {"c", XK_c}, + {"d", XK_d}, + {"e", XK_e}, + {"f", XK_f}, + {"g", XK_g}, + {"h", XK_h}, + {"i", XK_i}, + {"j", XK_j}, + {"k", XK_k}, + {"l", XK_l}, + {"m", XK_m}, + {"n", XK_n}, + {"o", XK_o}, + {"p", XK_p}, + {"q", XK_q}, + {"r", XK_r}, + {"s", XK_s}, + {"t", XK_t}, + {"u", XK_u}, + {"v", XK_v}, + {"w", XK_w}, + {"x", XK_x}, + {"y", XK_y}, + {"z", XK_z}, + {"braceleft", XK_braceleft}, + {"bar", XK_bar}, + {"braceright", XK_braceright}, + {"asciitilde", XK_asciitilde}, + {"nobreakspace", XK_nobreakspace}, + {"exclamdown", XK_exclamdown}, + {"cent", XK_cent}, + {"sterling", XK_sterling}, + {"currency", XK_currency}, + {"yen", XK_yen}, + {"brokenbar", XK_brokenbar}, + {"section", XK_section}, + {"diaeresis", XK_diaeresis}, + {"copyright", XK_copyright}, + {"ordfeminine", XK_ordfeminine}, + {"guillemotleft", XK_guillemotleft}, + {"notsign", XK_notsign}, + {"hyphen", XK_hyphen}, + {"registered", XK_registered}, + {"macron", XK_macron}, + {"degree", XK_degree}, + {"plusminus", XK_plusminus}, + {"twosuperior", XK_twosuperior}, + {"threesuperior", XK_threesuperior}, + {"acute", XK_acute}, + {"mu", XK_mu}, + {"paragraph", XK_paragraph}, + {"periodcentered", XK_periodcentered}, + {"cedilla", XK_cedilla}, + {"onesuperior", XK_onesuperior}, + {"masculine", XK_masculine}, + {"guillemotright", XK_guillemotright}, + {"onequarter", XK_onequarter}, + {"onehalf", XK_onehalf}, + {"threequarters", XK_threequarters}, + {"questiondown", XK_questiondown}, + {"Agrave", XK_Agrave}, + {"Aacute", XK_Aacute}, + {"Acircumflex", XK_Acircumflex}, + {"Atilde", XK_Atilde}, + {"Adiaeresis", XK_Adiaeresis}, + {"Aring", XK_Aring}, + {"AE", XK_AE}, + {"Ccedilla", XK_Ccedilla}, + {"Egrave", XK_Egrave}, + {"Eacute", XK_Eacute}, + {"Ecircumflex", XK_Ecircumflex}, + {"Ediaeresis", XK_Ediaeresis}, + {"Igrave", XK_Igrave}, + {"Iacute", XK_Iacute}, + {"Icircumflex", XK_Icircumflex}, + {"Idiaeresis", XK_Idiaeresis}, + {"ETH", XK_ETH}, + {"Eth", XK_Eth}, + {"Ntilde", XK_Ntilde}, + {"Ograve", XK_Ograve}, + {"Oacute", XK_Oacute}, + {"Ocircumflex", XK_Ocircumflex}, + {"Otilde", XK_Otilde}, + {"Odiaeresis", XK_Odiaeresis}, + {"multiply", XK_multiply}, + {"Ooblique", XK_Ooblique}, + {"Ugrave", XK_Ugrave}, + {"Uacute", XK_Uacute}, + {"Ucircumflex", XK_Ucircumflex}, + {"Udiaeresis", XK_Udiaeresis}, + {"Yacute", XK_Yacute}, + {"THORN", XK_THORN}, + {"Thorn", XK_Thorn}, + {"ssharp", XK_ssharp}, + {"agrave", XK_agrave}, + {"aacute", XK_aacute}, + {"acircumflex", XK_acircumflex}, + {"atilde", XK_atilde}, + {"adiaeresis", XK_adiaeresis}, + {"aring", XK_aring}, + {"ae", XK_ae}, + {"ccedilla", XK_ccedilla}, + {"egrave", XK_egrave}, + {"eacute", XK_eacute}, + {"ecircumflex", XK_ecircumflex}, + {"ediaeresis", XK_ediaeresis}, + {"igrave", XK_igrave}, + {"iacute", XK_iacute}, + {"icircumflex", XK_icircumflex}, + {"idiaeresis", XK_idiaeresis}, + {"eth", XK_eth}, + {"ntilde", XK_ntilde}, + {"ograve", XK_ograve}, + {"oacute", XK_oacute}, + {"ocircumflex", XK_ocircumflex}, + {"otilde", XK_otilde}, + {"odiaeresis", XK_odiaeresis}, + {"division", XK_division}, + {"oslash", XK_oslash}, + {"ugrave", XK_ugrave}, + {"uacute", XK_uacute}, + {"ucircumflex", XK_ucircumflex}, + {"udiaeresis", XK_udiaeresis}, + {"yacute", XK_yacute}, + {"thorn", XK_thorn}, + {"ydiaeresis", XK_ydiaeresis}, +#endif /* XK_LATIN1 */ +#ifdef XK_LATIN2 + {"Aogonek", XK_Aogonek}, + {"breve", XK_breve}, + {"Lstroke", XK_Lstroke}, + {"Lcaron", XK_Lcaron}, + {"Sacute", XK_Sacute}, + {"Scaron", XK_Scaron}, + {"Scedilla", XK_Scedilla}, + {"Tcaron", XK_Tcaron}, + {"Zacute", XK_Zacute}, + {"Zcaron", XK_Zcaron}, + {"Zabovedot", XK_Zabovedot}, + {"aogonek", XK_aogonek}, + {"ogonek", XK_ogonek}, + {"lstroke", XK_lstroke}, + {"lcaron", XK_lcaron}, + {"sacute", XK_sacute}, + {"caron", XK_caron}, + {"scaron", XK_scaron}, + {"scedilla", XK_scedilla}, + {"tcaron", XK_tcaron}, + {"zacute", XK_zacute}, + {"doubleacute", XK_doubleacute}, + {"zcaron", XK_zcaron}, + {"zabovedot", XK_zabovedot}, + {"Racute", XK_Racute}, + {"Abreve", XK_Abreve}, + {"Lacute", XK_Lacute}, + {"Cacute", XK_Cacute}, + {"Ccaron", XK_Ccaron}, + {"Eogonek", XK_Eogonek}, + {"Ecaron", XK_Ecaron}, + {"Dcaron", XK_Dcaron}, + {"Dstroke", XK_Dstroke}, + {"Nacute", XK_Nacute}, + {"Ncaron", XK_Ncaron}, + {"Odoubleacute", XK_Odoubleacute}, + {"Rcaron", XK_Rcaron}, + {"Uring", XK_Uring}, + {"Udoubleacute", XK_Udoubleacute}, + {"Tcedilla", XK_Tcedilla}, + {"racute", XK_racute}, + {"abreve", XK_abreve}, + {"lacute", XK_lacute}, + {"cacute", XK_cacute}, + {"ccaron", XK_ccaron}, + {"eogonek", XK_eogonek}, + {"ecaron", XK_ecaron}, + {"dcaron", XK_dcaron}, + {"dstroke", XK_dstroke}, + {"nacute", XK_nacute}, + {"ncaron", XK_ncaron}, + {"odoubleacute", XK_odoubleacute}, + {"udoubleacute", XK_udoubleacute}, + {"rcaron", XK_rcaron}, + {"uring", XK_uring}, + {"tcedilla", XK_tcedilla}, + {"abovedot", XK_abovedot}, +#endif /* XK_LATIN2 */ +#ifdef XK_LATIN3 + {"Hstroke", XK_Hstroke}, + {"Hcircumflex", XK_Hcircumflex}, + {"Iabovedot", XK_Iabovedot}, + {"Gbreve", XK_Gbreve}, + {"Jcircumflex", XK_Jcircumflex}, + {"hstroke", XK_hstroke}, + {"hcircumflex", XK_hcircumflex}, + {"idotless", XK_idotless}, + {"gbreve", XK_gbreve}, + {"jcircumflex", XK_jcircumflex}, + {"Cabovedot", XK_Cabovedot}, + {"Ccircumflex", XK_Ccircumflex}, + {"Gabovedot", XK_Gabovedot}, + {"Gcircumflex", XK_Gcircumflex}, + {"Ubreve", XK_Ubreve}, + {"Scircumflex", XK_Scircumflex}, + {"cabovedot", XK_cabovedot}, + {"ccircumflex", XK_ccircumflex}, + {"gabovedot", XK_gabovedot}, + {"gcircumflex", XK_gcircumflex}, + {"ubreve", XK_ubreve}, + {"scircumflex", XK_scircumflex}, +#endif /* XK_LATIN3 */ +#ifdef XK_LATIN4 + {"kra", XK_kra}, + {"kappa", XK_kappa}, + {"Rcedilla", XK_Rcedilla}, + {"Itilde", XK_Itilde}, + {"Lcedilla", XK_Lcedilla}, + {"Emacron", XK_Emacron}, + {"Gcedilla", XK_Gcedilla}, + {"Tslash", XK_Tslash}, + {"rcedilla", XK_rcedilla}, + {"itilde", XK_itilde}, + {"lcedilla", XK_lcedilla}, + {"emacron", XK_emacron}, + {"gcedilla", XK_gcedilla}, + {"tslash", XK_tslash}, + {"ENG", XK_ENG}, + {"eng", XK_eng}, + {"Amacron", XK_Amacron}, + {"Iogonek", XK_Iogonek}, + {"Eabovedot", XK_Eabovedot}, + {"Imacron", XK_Imacron}, + {"Ncedilla", XK_Ncedilla}, + {"Omacron", XK_Omacron}, + {"Kcedilla", XK_Kcedilla}, + {"Uogonek", XK_Uogonek}, + {"Utilde", XK_Utilde}, + {"Umacron", XK_Umacron}, + {"amacron", XK_amacron}, + {"iogonek", XK_iogonek}, + {"eabovedot", XK_eabovedot}, + {"imacron", XK_imacron}, + {"ncedilla", XK_ncedilla}, + {"omacron", XK_omacron}, + {"kcedilla", XK_kcedilla}, + {"uogonek", XK_uogonek}, + {"utilde", XK_utilde}, + {"umacron", XK_umacron}, +#endif /* XK_LATIN4 */ +#ifdef XK_KATAKANA + {"overline", XK_overline}, + {"kana_fullstop", XK_kana_fullstop}, + {"kana_openingbracket", XK_kana_openingbracket}, + {"kana_closingbracket", XK_kana_closingbracket}, + {"kana_comma", XK_kana_comma}, + {"kana_conjunctive", XK_kana_conjunctive}, + {"kana_middledot", XK_kana_middledot}, + {"kana_WO", XK_kana_WO}, + {"kana_a", XK_kana_a}, + {"kana_i", XK_kana_i}, + {"kana_u", XK_kana_u}, + {"kana_e", XK_kana_e}, + {"kana_o", XK_kana_o}, + {"kana_ya", XK_kana_ya}, + {"kana_yu", XK_kana_yu}, + {"kana_yo", XK_kana_yo}, + {"kana_tsu", XK_kana_tsu}, + {"kana_tu", XK_kana_tu}, + {"prolongedsound", XK_prolongedsound}, + {"kana_A", XK_kana_A}, + {"kana_I", XK_kana_I}, + {"kana_U", XK_kana_U}, + {"kana_E", XK_kana_E}, + {"kana_O", XK_kana_O}, + {"kana_KA", XK_kana_KA}, + {"kana_KI", XK_kana_KI}, + {"kana_KU", XK_kana_KU}, + {"kana_KE", XK_kana_KE}, + {"kana_KO", XK_kana_KO}, + {"kana_SA", XK_kana_SA}, + {"kana_SHI", XK_kana_SHI}, + {"kana_SU", XK_kana_SU}, + {"kana_SE", XK_kana_SE}, + {"kana_SO", XK_kana_SO}, + {"kana_TA", XK_kana_TA}, + {"kana_CHI", XK_kana_CHI}, + {"kana_TI", XK_kana_TI}, + {"kana_TSU", XK_kana_TSU}, + {"kana_TU", XK_kana_TU}, + {"kana_TE", XK_kana_TE}, + {"kana_TO", XK_kana_TO}, + {"kana_NA", XK_kana_NA}, + {"kana_NI", XK_kana_NI}, + {"kana_NU", XK_kana_NU}, + {"kana_NE", XK_kana_NE}, + {"kana_NO", XK_kana_NO}, + {"kana_HA", XK_kana_HA}, + {"kana_HI", XK_kana_HI}, + {"kana_FU", XK_kana_FU}, + {"kana_HU", XK_kana_HU}, + {"kana_HE", XK_kana_HE}, + {"kana_HO", XK_kana_HO}, + {"kana_MA", XK_kana_MA}, + {"kana_MI", XK_kana_MI}, + {"kana_MU", XK_kana_MU}, + {"kana_ME", XK_kana_ME}, + {"kana_MO", XK_kana_MO}, + {"kana_YA", XK_kana_YA}, + {"kana_YU", XK_kana_YU}, + {"kana_YO", XK_kana_YO}, + {"kana_RA", XK_kana_RA}, + {"kana_RI", XK_kana_RI}, + {"kana_RU", XK_kana_RU}, + {"kana_RE", XK_kana_RE}, + {"kana_RO", XK_kana_RO}, + {"kana_WA", XK_kana_WA}, + {"kana_N", XK_kana_N}, + {"voicedsound", XK_voicedsound}, + {"semivoicedsound", XK_semivoicedsound}, + {"kana_switch", XK_kana_switch}, +#endif /* XK_KATAKANA */ +#ifdef XK_ARABIC + {"Arabic_comma", XK_Arabic_comma}, + {"Arabic_semicolon", XK_Arabic_semicolon}, + {"Arabic_question_mark", XK_Arabic_question_mark}, + {"Arabic_hamza", XK_Arabic_hamza}, + {"Arabic_maddaonalef", XK_Arabic_maddaonalef}, + {"Arabic_hamzaonalef", XK_Arabic_hamzaonalef}, + {"Arabic_hamzaonwaw", XK_Arabic_hamzaonwaw}, + {"Arabic_hamzaunderalef", XK_Arabic_hamzaunderalef}, + {"Arabic_hamzaonyeh", XK_Arabic_hamzaonyeh}, + {"Arabic_alef", XK_Arabic_alef}, + {"Arabic_beh", XK_Arabic_beh}, + {"Arabic_tehmarbuta", XK_Arabic_tehmarbuta}, + {"Arabic_teh", XK_Arabic_teh}, + {"Arabic_theh", XK_Arabic_theh}, + {"Arabic_jeem", XK_Arabic_jeem}, + {"Arabic_hah", XK_Arabic_hah}, + {"Arabic_khah", XK_Arabic_khah}, + {"Arabic_dal", XK_Arabic_dal}, + {"Arabic_thal", XK_Arabic_thal}, + {"Arabic_ra", XK_Arabic_ra}, + {"Arabic_zain", XK_Arabic_zain}, + {"Arabic_seen", XK_Arabic_seen}, + {"Arabic_sheen", XK_Arabic_sheen}, + {"Arabic_sad", XK_Arabic_sad}, + {"Arabic_dad", XK_Arabic_dad}, + {"Arabic_tah", XK_Arabic_tah}, + {"Arabic_zah", XK_Arabic_zah}, + {"Arabic_ain", XK_Arabic_ain}, + {"Arabic_ghain", XK_Arabic_ghain}, + {"Arabic_tatweel", XK_Arabic_tatweel}, + {"Arabic_feh", XK_Arabic_feh}, + {"Arabic_qaf", XK_Arabic_qaf}, + {"Arabic_kaf", XK_Arabic_kaf}, + {"Arabic_lam", XK_Arabic_lam}, + {"Arabic_meem", XK_Arabic_meem}, + {"Arabic_noon", XK_Arabic_noon}, + {"Arabic_ha", XK_Arabic_ha}, + {"Arabic_heh", XK_Arabic_heh}, + {"Arabic_waw", XK_Arabic_waw}, + {"Arabic_alefmaksura", XK_Arabic_alefmaksura}, + {"Arabic_yeh", XK_Arabic_yeh}, + {"Arabic_fathatan", XK_Arabic_fathatan}, + {"Arabic_dammatan", XK_Arabic_dammatan}, + {"Arabic_kasratan", XK_Arabic_kasratan}, + {"Arabic_fatha", XK_Arabic_fatha}, + {"Arabic_damma", XK_Arabic_damma}, + {"Arabic_kasra", XK_Arabic_kasra}, + {"Arabic_shadda", XK_Arabic_shadda}, + {"Arabic_sukun", XK_Arabic_sukun}, + {"Arabic_switch", XK_Arabic_switch}, +#endif /* XK_ARABIC */ +#ifdef XK_CYRILLIC + {"Serbian_dje", XK_Serbian_dje}, + {"Macedonia_gje", XK_Macedonia_gje}, + {"Cyrillic_io", XK_Cyrillic_io}, + {"Ukrainian_ie", XK_Ukrainian_ie}, + {"Ukranian_je", XK_Ukranian_je}, + {"Macedonia_dse", XK_Macedonia_dse}, + {"Ukrainian_i", XK_Ukrainian_i}, + {"Ukranian_i", XK_Ukranian_i}, + {"Ukrainian_yi", XK_Ukrainian_yi}, + {"Ukranian_yi", XK_Ukranian_yi}, + {"Cyrillic_je", XK_Cyrillic_je}, + {"Serbian_je", XK_Serbian_je}, + {"Cyrillic_lje", XK_Cyrillic_lje}, + {"Serbian_lje", XK_Serbian_lje}, + {"Cyrillic_nje", XK_Cyrillic_nje}, + {"Serbian_nje", XK_Serbian_nje}, + {"Serbian_tshe", XK_Serbian_tshe}, + {"Macedonia_kje", XK_Macedonia_kje}, + {"Byelorussian_shortu", XK_Byelorussian_shortu}, + {"Cyrillic_dzhe", XK_Cyrillic_dzhe}, + {"Serbian_dze", XK_Serbian_dze}, + {"numerosign", XK_numerosign}, + {"Serbian_DJE", XK_Serbian_DJE}, + {"Macedonia_GJE", XK_Macedonia_GJE}, + {"Cyrillic_IO", XK_Cyrillic_IO}, + {"Ukrainian_IE", XK_Ukrainian_IE}, + {"Ukranian_JE", XK_Ukranian_JE}, + {"Macedonia_DSE", XK_Macedonia_DSE}, + {"Ukrainian_I", XK_Ukrainian_I}, + {"Ukranian_I", XK_Ukranian_I}, + {"Ukrainian_YI", XK_Ukrainian_YI}, + {"Ukranian_YI", XK_Ukranian_YI}, + {"Cyrillic_JE", XK_Cyrillic_JE}, + {"Serbian_JE", XK_Serbian_JE}, + {"Cyrillic_LJE", XK_Cyrillic_LJE}, + {"Serbian_LJE", XK_Serbian_LJE}, + {"Cyrillic_NJE", XK_Cyrillic_NJE}, + {"Serbian_NJE", XK_Serbian_NJE}, + {"Serbian_TSHE", XK_Serbian_TSHE}, + {"Macedonia_KJE", XK_Macedonia_KJE}, + {"Byelorussian_SHORTU", XK_Byelorussian_SHORTU}, + {"Cyrillic_DZHE", XK_Cyrillic_DZHE}, + {"Serbian_DZE", XK_Serbian_DZE}, + {"Cyrillic_yu", XK_Cyrillic_yu}, + {"Cyrillic_a", XK_Cyrillic_a}, + {"Cyrillic_be", XK_Cyrillic_be}, + {"Cyrillic_tse", XK_Cyrillic_tse}, + {"Cyrillic_de", XK_Cyrillic_de}, + {"Cyrillic_ie", XK_Cyrillic_ie}, + {"Cyrillic_ef", XK_Cyrillic_ef}, + {"Cyrillic_ghe", XK_Cyrillic_ghe}, + {"Cyrillic_ha", XK_Cyrillic_ha}, + {"Cyrillic_i", XK_Cyrillic_i}, + {"Cyrillic_shorti", XK_Cyrillic_shorti}, + {"Cyrillic_ka", XK_Cyrillic_ka}, + {"Cyrillic_el", XK_Cyrillic_el}, + {"Cyrillic_em", XK_Cyrillic_em}, + {"Cyrillic_en", XK_Cyrillic_en}, + {"Cyrillic_o", XK_Cyrillic_o}, + {"Cyrillic_pe", XK_Cyrillic_pe}, + {"Cyrillic_ya", XK_Cyrillic_ya}, + {"Cyrillic_er", XK_Cyrillic_er}, + {"Cyrillic_es", XK_Cyrillic_es}, + {"Cyrillic_te", XK_Cyrillic_te}, + {"Cyrillic_u", XK_Cyrillic_u}, + {"Cyrillic_zhe", XK_Cyrillic_zhe}, + {"Cyrillic_ve", XK_Cyrillic_ve}, + {"Cyrillic_softsign", XK_Cyrillic_softsign}, + {"Cyrillic_yeru", XK_Cyrillic_yeru}, + {"Cyrillic_ze", XK_Cyrillic_ze}, + {"Cyrillic_sha", XK_Cyrillic_sha}, + {"Cyrillic_e", XK_Cyrillic_e}, + {"Cyrillic_shcha", XK_Cyrillic_shcha}, + {"Cyrillic_che", XK_Cyrillic_che}, + {"Cyrillic_hardsign", XK_Cyrillic_hardsign}, + {"Cyrillic_YU", XK_Cyrillic_YU}, + {"Cyrillic_A", XK_Cyrillic_A}, + {"Cyrillic_BE", XK_Cyrillic_BE}, + {"Cyrillic_TSE", XK_Cyrillic_TSE}, + {"Cyrillic_DE", XK_Cyrillic_DE}, + {"Cyrillic_IE", XK_Cyrillic_IE}, + {"Cyrillic_EF", XK_Cyrillic_EF}, + {"Cyrillic_GHE", XK_Cyrillic_GHE}, + {"Cyrillic_HA", XK_Cyrillic_HA}, + {"Cyrillic_I", XK_Cyrillic_I}, + {"Cyrillic_SHORTI", XK_Cyrillic_SHORTI}, + {"Cyrillic_KA", XK_Cyrillic_KA}, + {"Cyrillic_EL", XK_Cyrillic_EL}, + {"Cyrillic_EM", XK_Cyrillic_EM}, + {"Cyrillic_EN", XK_Cyrillic_EN}, + {"Cyrillic_O", XK_Cyrillic_O}, + {"Cyrillic_PE", XK_Cyrillic_PE}, + {"Cyrillic_YA", XK_Cyrillic_YA}, + {"Cyrillic_ER", XK_Cyrillic_ER}, + {"Cyrillic_ES", XK_Cyrillic_ES}, + {"Cyrillic_TE", XK_Cyrillic_TE}, + {"Cyrillic_U", XK_Cyrillic_U}, + {"Cyrillic_ZHE", XK_Cyrillic_ZHE}, + {"Cyrillic_VE", XK_Cyrillic_VE}, + {"Cyrillic_SOFTSIGN", XK_Cyrillic_SOFTSIGN}, + {"Cyrillic_YERU", XK_Cyrillic_YERU}, + {"Cyrillic_ZE", XK_Cyrillic_ZE}, + {"Cyrillic_SHA", XK_Cyrillic_SHA}, + {"Cyrillic_E", XK_Cyrillic_E}, + {"Cyrillic_SHCHA", XK_Cyrillic_SHCHA}, + {"Cyrillic_CHE", XK_Cyrillic_CHE}, + {"Cyrillic_HARDSIGN", XK_Cyrillic_HARDSIGN}, +#endif /* XK_CYRILLIC */ +#ifdef XK_GREEK + {"Greek_ALPHAaccent", XK_Greek_ALPHAaccent}, + {"Greek_EPSILONaccent", XK_Greek_EPSILONaccent}, + {"Greek_ETAaccent", XK_Greek_ETAaccent}, + {"Greek_IOTAaccent", XK_Greek_IOTAaccent}, + {"Greek_IOTAdieresis", XK_Greek_IOTAdieresis}, + {"Greek_OMICRONaccent", XK_Greek_OMICRONaccent}, + {"Greek_UPSILONaccent", XK_Greek_UPSILONaccent}, + {"Greek_UPSILONdieresis", XK_Greek_UPSILONdieresis}, + {"Greek_OMEGAaccent", XK_Greek_OMEGAaccent}, + {"Greek_accentdieresis", XK_Greek_accentdieresis}, + {"Greek_horizbar", XK_Greek_horizbar}, + {"Greek_alphaaccent", XK_Greek_alphaaccent}, + {"Greek_epsilonaccent", XK_Greek_epsilonaccent}, + {"Greek_etaaccent", XK_Greek_etaaccent}, + {"Greek_iotaaccent", XK_Greek_iotaaccent}, + {"Greek_iotadieresis", XK_Greek_iotadieresis}, + {"Greek_iotaaccentdieresis", XK_Greek_iotaaccentdieresis}, + {"Greek_omicronaccent", XK_Greek_omicronaccent}, + {"Greek_upsilonaccent", XK_Greek_upsilonaccent}, + {"Greek_upsilondieresis", XK_Greek_upsilondieresis}, + {"Greek_upsilonaccentdieresis", XK_Greek_upsilonaccentdieresis}, + {"Greek_omegaaccent", XK_Greek_omegaaccent}, + {"Greek_ALPHA", XK_Greek_ALPHA}, + {"Greek_BETA", XK_Greek_BETA}, + {"Greek_GAMMA", XK_Greek_GAMMA}, + {"Greek_DELTA", XK_Greek_DELTA}, + {"Greek_EPSILON", XK_Greek_EPSILON}, + {"Greek_ZETA", XK_Greek_ZETA}, + {"Greek_ETA", XK_Greek_ETA}, + {"Greek_THETA", XK_Greek_THETA}, + {"Greek_IOTA", XK_Greek_IOTA}, + {"Greek_KAPPA", XK_Greek_KAPPA}, + {"Greek_LAMDA", XK_Greek_LAMDA}, + {"Greek_LAMBDA", XK_Greek_LAMBDA}, + {"Greek_MU", XK_Greek_MU}, + {"Greek_NU", XK_Greek_NU}, + {"Greek_XI", XK_Greek_XI}, + {"Greek_OMICRON", XK_Greek_OMICRON}, + {"Greek_PI", XK_Greek_PI}, + {"Greek_RHO", XK_Greek_RHO}, + {"Greek_SIGMA", XK_Greek_SIGMA}, + {"Greek_TAU", XK_Greek_TAU}, + {"Greek_UPSILON", XK_Greek_UPSILON}, + {"Greek_PHI", XK_Greek_PHI}, + {"Greek_CHI", XK_Greek_CHI}, + {"Greek_PSI", XK_Greek_PSI}, + {"Greek_OMEGA", XK_Greek_OMEGA}, + {"Greek_alpha", XK_Greek_alpha}, + {"Greek_beta", XK_Greek_beta}, + {"Greek_gamma", XK_Greek_gamma}, + {"Greek_delta", XK_Greek_delta}, + {"Greek_epsilon", XK_Greek_epsilon}, + {"Greek_zeta", XK_Greek_zeta}, + {"Greek_eta", XK_Greek_eta}, + {"Greek_theta", XK_Greek_theta}, + {"Greek_iota", XK_Greek_iota}, + {"Greek_kappa", XK_Greek_kappa}, + {"Greek_lamda", XK_Greek_lamda}, + {"Greek_lambda", XK_Greek_lambda}, + {"Greek_mu", XK_Greek_mu}, + {"Greek_nu", XK_Greek_nu}, + {"Greek_xi", XK_Greek_xi}, + {"Greek_omicron", XK_Greek_omicron}, + {"Greek_pi", XK_Greek_pi}, + {"Greek_rho", XK_Greek_rho}, + {"Greek_sigma", XK_Greek_sigma}, + {"Greek_finalsmallsigma", XK_Greek_finalsmallsigma}, + {"Greek_tau", XK_Greek_tau}, + {"Greek_upsilon", XK_Greek_upsilon}, + {"Greek_phi", XK_Greek_phi}, + {"Greek_chi", XK_Greek_chi}, + {"Greek_psi", XK_Greek_psi}, + {"Greek_omega", XK_Greek_omega}, + {"Greek_switch", XK_Greek_switch}, +#endif /* XK_GREEK */ +#ifdef XK_TECHNICAL + {"leftradical", XK_leftradical}, + {"topleftradical", XK_topleftradical}, + {"horizconnector", XK_horizconnector}, + {"topintegral", XK_topintegral}, + {"botintegral", XK_botintegral}, + {"vertconnector", XK_vertconnector}, + {"topleftsqbracket", XK_topleftsqbracket}, + {"botleftsqbracket", XK_botleftsqbracket}, + {"toprightsqbracket", XK_toprightsqbracket}, + {"botrightsqbracket", XK_botrightsqbracket}, + {"topleftparens", XK_topleftparens}, + {"botleftparens", XK_botleftparens}, + {"toprightparens", XK_toprightparens}, + {"botrightparens", XK_botrightparens}, + {"leftmiddlecurlybrace", XK_leftmiddlecurlybrace}, + {"rightmiddlecurlybrace", XK_rightmiddlecurlybrace}, + {"topleftsummation", XK_topleftsummation}, + {"botleftsummation", XK_botleftsummation}, + {"topvertsummationconnector", XK_topvertsummationconnector}, + {"botvertsummationconnector", XK_botvertsummationconnector}, + {"toprightsummation", XK_toprightsummation}, + {"botrightsummation", XK_botrightsummation}, + {"rightmiddlesummation", XK_rightmiddlesummation}, + {"lessthanequal", XK_lessthanequal}, + {"notequal", XK_notequal}, + {"greaterthanequal", XK_greaterthanequal}, + {"integral", XK_integral}, + {"therefore", XK_therefore}, + {"variation", XK_variation}, + {"infinity", XK_infinity}, + {"nabla", XK_nabla}, + {"approximate", XK_approximate}, + {"similarequal", XK_similarequal}, + {"ifonlyif", XK_ifonlyif}, + {"implies", XK_implies}, + {"identical", XK_identical}, + {"radical", XK_radical}, + {"includedin", XK_includedin}, + {"includes", XK_includes}, + {"intersection", XK_intersection}, + {"union", XK_union}, + {"logicaland", XK_logicaland}, + {"logicalor", XK_logicalor}, + {"partialderivative", XK_partialderivative}, + {"function", XK_function}, + {"leftarrow", XK_leftarrow}, + {"uparrow", XK_uparrow}, + {"rightarrow", XK_rightarrow}, + {"downarrow", XK_downarrow}, +#endif /* XK_TECHNICAL */ +#ifdef XK_SPECIAL + {"blank", XK_blank}, + {"soliddiamond", XK_soliddiamond}, + {"checkerboard", XK_checkerboard}, + {"ht", XK_ht}, + {"ff", XK_ff}, + {"cr", XK_cr}, + {"lf", XK_lf}, + {"nl", XK_nl}, + {"vt", XK_vt}, + {"lowrightcorner", XK_lowrightcorner}, + {"uprightcorner", XK_uprightcorner}, + {"upleftcorner", XK_upleftcorner}, + {"lowleftcorner", XK_lowleftcorner}, + {"crossinglines", XK_crossinglines}, + {"horizlinescan1", XK_horizlinescan1}, + {"horizlinescan3", XK_horizlinescan3}, + {"horizlinescan5", XK_horizlinescan5}, + {"horizlinescan7", XK_horizlinescan7}, + {"horizlinescan9", XK_horizlinescan9}, + {"leftt", XK_leftt}, + {"rightt", XK_rightt}, + {"bott", XK_bott}, + {"topt", XK_topt}, + {"vertbar", XK_vertbar}, +#endif /* XK_SPECIAL */ +#ifdef XK_PUBLISHING + {"emspace", XK_emspace}, + {"enspace", XK_enspace}, + {"em3space", XK_em3space}, + {"em4space", XK_em4space}, + {"digitspace", XK_digitspace}, + {"punctspace", XK_punctspace}, + {"thinspace", XK_thinspace}, + {"hairspace", XK_hairspace}, + {"emdash", XK_emdash}, + {"endash", XK_endash}, + {"signifblank", XK_signifblank}, + {"ellipsis", XK_ellipsis}, + {"doubbaselinedot", XK_doubbaselinedot}, + {"onethird", XK_onethird}, + {"twothirds", XK_twothirds}, + {"onefifth", XK_onefifth}, + {"twofifths", XK_twofifths}, + {"threefifths", XK_threefifths}, + {"fourfifths", XK_fourfifths}, + {"onesixth", XK_onesixth}, + {"fivesixths", XK_fivesixths}, + {"careof", XK_careof}, + {"figdash", XK_figdash}, + {"leftanglebracket", XK_leftanglebracket}, + {"decimalpoint", XK_decimalpoint}, + {"rightanglebracket", XK_rightanglebracket}, + {"marker", XK_marker}, + {"oneeighth", XK_oneeighth}, + {"threeeighths", XK_threeeighths}, + {"fiveeighths", XK_fiveeighths}, + {"seveneighths", XK_seveneighths}, + {"trademark", XK_trademark}, + {"signaturemark", XK_signaturemark}, + {"trademarkincircle", XK_trademarkincircle}, + {"leftopentriangle", XK_leftopentriangle}, + {"rightopentriangle", XK_rightopentriangle}, + {"emopencircle", XK_emopencircle}, + {"emopenrectangle", XK_emopenrectangle}, + {"leftsinglequotemark", XK_leftsinglequotemark}, + {"rightsinglequotemark", XK_rightsinglequotemark}, + {"leftdoublequotemark", XK_leftdoublequotemark}, + {"rightdoublequotemark", XK_rightdoublequotemark}, + {"prescription", XK_prescription}, + {"minutes", XK_minutes}, + {"seconds", XK_seconds}, + {"latincross", XK_latincross}, + {"hexagram", XK_hexagram}, + {"filledrectbullet", XK_filledrectbullet}, + {"filledlefttribullet", XK_filledlefttribullet}, + {"filledrighttribullet", XK_filledrighttribullet}, + {"emfilledcircle", XK_emfilledcircle}, + {"emfilledrect", XK_emfilledrect}, + {"enopencircbullet", XK_enopencircbullet}, + {"enopensquarebullet", XK_enopensquarebullet}, + {"openrectbullet", XK_openrectbullet}, + {"opentribulletup", XK_opentribulletup}, + {"opentribulletdown", XK_opentribulletdown}, + {"openstar", XK_openstar}, + {"enfilledcircbullet", XK_enfilledcircbullet}, + {"enfilledsqbullet", XK_enfilledsqbullet}, + {"filledtribulletup", XK_filledtribulletup}, + {"filledtribulletdown", XK_filledtribulletdown}, + {"leftpointer", XK_leftpointer}, + {"rightpointer", XK_rightpointer}, + {"club", XK_club}, + {"diamond", XK_diamond}, + {"heart", XK_heart}, + {"maltesecross", XK_maltesecross}, + {"dagger", XK_dagger}, + {"doubledagger", XK_doubledagger}, + {"checkmark", XK_checkmark}, + {"ballotcross", XK_ballotcross}, + {"musicalsharp", XK_musicalsharp}, + {"musicalflat", XK_musicalflat}, + {"malesymbol", XK_malesymbol}, + {"femalesymbol", XK_femalesymbol}, + {"telephone", XK_telephone}, + {"telephonerecorder", XK_telephonerecorder}, + {"phonographcopyright", XK_phonographcopyright}, + {"caret", XK_caret}, + {"singlelowquotemark", XK_singlelowquotemark}, + {"doublelowquotemark", XK_doublelowquotemark}, + {"cursor", XK_cursor}, +#endif /* XK_PUBLISHING */ +#ifdef XK_APL + {"leftcaret", XK_leftcaret}, + {"rightcaret", XK_rightcaret}, + {"downcaret", XK_downcaret}, + {"upcaret", XK_upcaret}, + {"overbar", XK_overbar}, + {"downtack", XK_downtack}, + {"upshoe", XK_upshoe}, + {"downstile", XK_downstile}, + {"underbar", XK_underbar}, + {"jot", XK_jot}, + {"quad", XK_quad}, + {"uptack", XK_uptack}, + {"circle", XK_circle}, + {"upstile", XK_upstile}, + {"downshoe", XK_downshoe}, + {"rightshoe", XK_rightshoe}, + {"leftshoe", XK_leftshoe}, + {"lefttack", XK_lefttack}, + {"righttack", XK_righttack}, +#endif /* XK_APL */ +#ifdef XK_HEBREW + {"hebrew_doublelowline", XK_hebrew_doublelowline}, + {"hebrew_aleph", XK_hebrew_aleph}, + {"hebrew_bet", XK_hebrew_bet}, + {"hebrew_beth", XK_hebrew_beth}, + {"hebrew_gimel", XK_hebrew_gimel}, + {"hebrew_gimmel", XK_hebrew_gimmel}, + {"hebrew_dalet", XK_hebrew_dalet}, + {"hebrew_daleth", XK_hebrew_daleth}, + {"hebrew_he", XK_hebrew_he}, + {"hebrew_waw", XK_hebrew_waw}, + {"hebrew_zain", XK_hebrew_zain}, + {"hebrew_zayin", XK_hebrew_zayin}, + {"hebrew_chet", XK_hebrew_chet}, + {"hebrew_het", XK_hebrew_het}, + {"hebrew_tet", XK_hebrew_tet}, + {"hebrew_teth", XK_hebrew_teth}, + {"hebrew_yod", XK_hebrew_yod}, + {"hebrew_finalkaph", XK_hebrew_finalkaph}, + {"hebrew_kaph", XK_hebrew_kaph}, + {"hebrew_lamed", XK_hebrew_lamed}, + {"hebrew_finalmem", XK_hebrew_finalmem}, + {"hebrew_mem", XK_hebrew_mem}, + {"hebrew_finalnun", XK_hebrew_finalnun}, + {"hebrew_nun", XK_hebrew_nun}, + {"hebrew_samech", XK_hebrew_samech}, + {"hebrew_samekh", XK_hebrew_samekh}, + {"hebrew_ayin", XK_hebrew_ayin}, + {"hebrew_finalpe", XK_hebrew_finalpe}, + {"hebrew_pe", XK_hebrew_pe}, + {"hebrew_finalzade", XK_hebrew_finalzade}, + {"hebrew_finalzadi", XK_hebrew_finalzadi}, + {"hebrew_zade", XK_hebrew_zade}, + {"hebrew_zadi", XK_hebrew_zadi}, + {"hebrew_qoph", XK_hebrew_qoph}, + {"hebrew_kuf", XK_hebrew_kuf}, + {"hebrew_resh", XK_hebrew_resh}, + {"hebrew_shin", XK_hebrew_shin}, + {"hebrew_taw", XK_hebrew_taw}, + {"hebrew_taf", XK_hebrew_taf}, + {"Hebrew_switch", XK_Hebrew_switch}, +#endif /* XK_HEBREW */ +#ifdef XK_THAI + {"Thai_kokai", XK_Thai_kokai}, + {"Thai_khokhai", XK_Thai_khokhai}, + {"Thai_khokhuat", XK_Thai_khokhuat}, + {"Thai_khokhwai", XK_Thai_khokhwai}, + {"Thai_khokhon", XK_Thai_khokhon}, + {"Thai_khorakhang", XK_Thai_khorakhang}, + {"Thai_ngongu", XK_Thai_ngongu}, + {"Thai_chochan", XK_Thai_chochan}, + {"Thai_choching", XK_Thai_choching}, + {"Thai_chochang", XK_Thai_chochang}, + {"Thai_soso", XK_Thai_soso}, + {"Thai_chochoe", XK_Thai_chochoe}, + {"Thai_yoying", XK_Thai_yoying}, + {"Thai_dochada", XK_Thai_dochada}, + {"Thai_topatak", XK_Thai_topatak}, + {"Thai_thothan", XK_Thai_thothan}, + {"Thai_thonangmontho", XK_Thai_thonangmontho}, + {"Thai_thophuthao", XK_Thai_thophuthao}, + {"Thai_nonen", XK_Thai_nonen}, + {"Thai_dodek", XK_Thai_dodek}, + {"Thai_totao", XK_Thai_totao}, + {"Thai_thothung", XK_Thai_thothung}, + {"Thai_thothahan", XK_Thai_thothahan}, + {"Thai_thothong", XK_Thai_thothong}, + {"Thai_nonu", XK_Thai_nonu}, + {"Thai_bobaimai", XK_Thai_bobaimai}, + {"Thai_popla", XK_Thai_popla}, + {"Thai_phophung", XK_Thai_phophung}, + {"Thai_fofa", XK_Thai_fofa}, + {"Thai_phophan", XK_Thai_phophan}, + {"Thai_fofan", XK_Thai_fofan}, + {"Thai_phosamphao", XK_Thai_phosamphao}, + {"Thai_moma", XK_Thai_moma}, + {"Thai_yoyak", XK_Thai_yoyak}, + {"Thai_rorua", XK_Thai_rorua}, + {"Thai_ru", XK_Thai_ru}, + {"Thai_loling", XK_Thai_loling}, + {"Thai_lu", XK_Thai_lu}, + {"Thai_wowaen", XK_Thai_wowaen}, + {"Thai_sosala", XK_Thai_sosala}, + {"Thai_sorusi", XK_Thai_sorusi}, + {"Thai_sosua", XK_Thai_sosua}, + {"Thai_hohip", XK_Thai_hohip}, + {"Thai_lochula", XK_Thai_lochula}, + {"Thai_oang", XK_Thai_oang}, + {"Thai_honokhuk", XK_Thai_honokhuk}, + {"Thai_paiyannoi", XK_Thai_paiyannoi}, + {"Thai_saraa", XK_Thai_saraa}, + {"Thai_maihanakat", XK_Thai_maihanakat}, + {"Thai_saraaa", XK_Thai_saraaa}, + {"Thai_saraam", XK_Thai_saraam}, + {"Thai_sarai", XK_Thai_sarai}, + {"Thai_saraii", XK_Thai_saraii}, + {"Thai_saraue", XK_Thai_saraue}, + {"Thai_sarauee", XK_Thai_sarauee}, + {"Thai_sarau", XK_Thai_sarau}, + {"Thai_sarauu", XK_Thai_sarauu}, + {"Thai_phinthu", XK_Thai_phinthu}, + {"Thai_maihanakat_maitho", XK_Thai_maihanakat_maitho}, + {"Thai_baht", XK_Thai_baht}, + {"Thai_sarae", XK_Thai_sarae}, + {"Thai_saraae", XK_Thai_saraae}, + {"Thai_sarao", XK_Thai_sarao}, + {"Thai_saraaimaimuan", XK_Thai_saraaimaimuan}, + {"Thai_saraaimaimalai", XK_Thai_saraaimaimalai}, + {"Thai_lakkhangyao", XK_Thai_lakkhangyao}, + {"Thai_maiyamok", XK_Thai_maiyamok}, + {"Thai_maitaikhu", XK_Thai_maitaikhu}, + {"Thai_maiek", XK_Thai_maiek}, + {"Thai_maitho", XK_Thai_maitho}, + {"Thai_maitri", XK_Thai_maitri}, + {"Thai_maichattawa", XK_Thai_maichattawa}, + {"Thai_thanthakhat", XK_Thai_thanthakhat}, + {"Thai_nikhahit", XK_Thai_nikhahit}, + {"Thai_leksun", XK_Thai_leksun}, + {"Thai_leknung", XK_Thai_leknung}, + {"Thai_leksong", XK_Thai_leksong}, + {"Thai_leksam", XK_Thai_leksam}, + {"Thai_leksi", XK_Thai_leksi}, + {"Thai_lekha", XK_Thai_lekha}, + {"Thai_lekhok", XK_Thai_lekhok}, + {"Thai_lekchet", XK_Thai_lekchet}, + {"Thai_lekpaet", XK_Thai_lekpaet}, + {"Thai_lekkao", XK_Thai_lekkao}, +#endif /* XK_THAI */ +#ifdef XK_KOREAN + {"Hangul", XK_Hangul}, + {"Hangul_Start", XK_Hangul_Start}, + {"Hangul_End", XK_Hangul_End}, + {"Hangul_Hanja", XK_Hangul_Hanja}, + {"Hangul_Jamo", XK_Hangul_Jamo}, + {"Hangul_Romaja", XK_Hangul_Romaja}, + {"Hangul_Codeinput", XK_Hangul_Codeinput}, + {"Hangul_Jeonja", XK_Hangul_Jeonja}, + {"Hangul_Banja", XK_Hangul_Banja}, + {"Hangul_PreHanja", XK_Hangul_PreHanja}, + {"Hangul_PostHanja", XK_Hangul_PostHanja}, + {"Hangul_SingleCandidate", XK_Hangul_SingleCandidate}, + {"Hangul_MultipleCandidate", XK_Hangul_MultipleCandidate}, + {"Hangul_PreviousCandidate", XK_Hangul_PreviousCandidate}, + {"Hangul_Special", XK_Hangul_Special}, + {"Hangul_switch", XK_Hangul_switch}, + {"Hangul_Kiyeog", XK_Hangul_Kiyeog}, + {"Hangul_SsangKiyeog", XK_Hangul_SsangKiyeog}, + {"Hangul_KiyeogSios", XK_Hangul_KiyeogSios}, + {"Hangul_Nieun", XK_Hangul_Nieun}, + {"Hangul_NieunJieuj", XK_Hangul_NieunJieuj}, + {"Hangul_NieunHieuh", XK_Hangul_NieunHieuh}, + {"Hangul_Dikeud", XK_Hangul_Dikeud}, + {"Hangul_SsangDikeud", XK_Hangul_SsangDikeud}, + {"Hangul_Rieul", XK_Hangul_Rieul}, + {"Hangul_RieulKiyeog", XK_Hangul_RieulKiyeog}, + {"Hangul_RieulMieum", XK_Hangul_RieulMieum}, + {"Hangul_RieulPieub", XK_Hangul_RieulPieub}, + {"Hangul_RieulSios", XK_Hangul_RieulSios}, + {"Hangul_RieulTieut", XK_Hangul_RieulTieut}, + {"Hangul_RieulPhieuf", XK_Hangul_RieulPhieuf}, + {"Hangul_RieulHieuh", XK_Hangul_RieulHieuh}, + {"Hangul_Mieum", XK_Hangul_Mieum}, + {"Hangul_Pieub", XK_Hangul_Pieub}, + {"Hangul_SsangPieub", XK_Hangul_SsangPieub}, + {"Hangul_PieubSios", XK_Hangul_PieubSios}, + {"Hangul_Sios", XK_Hangul_Sios}, + {"Hangul_SsangSios", XK_Hangul_SsangSios}, + {"Hangul_Ieung", XK_Hangul_Ieung}, + {"Hangul_Jieuj", XK_Hangul_Jieuj}, + {"Hangul_SsangJieuj", XK_Hangul_SsangJieuj}, + {"Hangul_Cieuc", XK_Hangul_Cieuc}, + {"Hangul_Khieuq", XK_Hangul_Khieuq}, + {"Hangul_Tieut", XK_Hangul_Tieut}, + {"Hangul_Phieuf", XK_Hangul_Phieuf}, + {"Hangul_Hieuh", XK_Hangul_Hieuh}, + {"Hangul_A", XK_Hangul_A}, + {"Hangul_AE", XK_Hangul_AE}, + {"Hangul_YA", XK_Hangul_YA}, + {"Hangul_YAE", XK_Hangul_YAE}, + {"Hangul_EO", XK_Hangul_EO}, + {"Hangul_E", XK_Hangul_E}, + {"Hangul_YEO", XK_Hangul_YEO}, + {"Hangul_YE", XK_Hangul_YE}, + {"Hangul_O", XK_Hangul_O}, + {"Hangul_WA", XK_Hangul_WA}, + {"Hangul_WAE", XK_Hangul_WAE}, + {"Hangul_OE", XK_Hangul_OE}, + {"Hangul_YO", XK_Hangul_YO}, + {"Hangul_U", XK_Hangul_U}, + {"Hangul_WEO", XK_Hangul_WEO}, + {"Hangul_WE", XK_Hangul_WE}, + {"Hangul_WI", XK_Hangul_WI}, + {"Hangul_YU", XK_Hangul_YU}, + {"Hangul_EU", XK_Hangul_EU}, + {"Hangul_YI", XK_Hangul_YI}, + {"Hangul_I", XK_Hangul_I}, + {"Hangul_J_Kiyeog", XK_Hangul_J_Kiyeog}, + {"Hangul_J_SsangKiyeog", XK_Hangul_J_SsangKiyeog}, + {"Hangul_J_KiyeogSios", XK_Hangul_J_KiyeogSios}, + {"Hangul_J_Nieun", XK_Hangul_J_Nieun}, + {"Hangul_J_NieunJieuj", XK_Hangul_J_NieunJieuj}, + {"Hangul_J_NieunHieuh", XK_Hangul_J_NieunHieuh}, + {"Hangul_J_Dikeud", XK_Hangul_J_Dikeud}, + {"Hangul_J_Rieul", XK_Hangul_J_Rieul}, + {"Hangul_J_RieulKiyeog", XK_Hangul_J_RieulKiyeog}, + {"Hangul_J_RieulMieum", XK_Hangul_J_RieulMieum}, + {"Hangul_J_RieulPieub", XK_Hangul_J_RieulPieub}, + {"Hangul_J_RieulSios", XK_Hangul_J_RieulSios}, + {"Hangul_J_RieulTieut", XK_Hangul_J_RieulTieut}, + {"Hangul_J_RieulPhieuf", XK_Hangul_J_RieulPhieuf}, + {"Hangul_J_RieulHieuh", XK_Hangul_J_RieulHieuh}, + {"Hangul_J_Mieum", XK_Hangul_J_Mieum}, + {"Hangul_J_Pieub", XK_Hangul_J_Pieub}, + {"Hangul_J_PieubSios", XK_Hangul_J_PieubSios}, + {"Hangul_J_Sios", XK_Hangul_J_Sios}, + {"Hangul_J_SsangSios", XK_Hangul_J_SsangSios}, + {"Hangul_J_Ieung", XK_Hangul_J_Ieung}, + {"Hangul_J_Jieuj", XK_Hangul_J_Jieuj}, + {"Hangul_J_Cieuc", XK_Hangul_J_Cieuc}, + {"Hangul_J_Khieuq", XK_Hangul_J_Khieuq}, + {"Hangul_J_Tieut", XK_Hangul_J_Tieut}, + {"Hangul_J_Phieuf", XK_Hangul_J_Phieuf}, + {"Hangul_J_Hieuh", XK_Hangul_J_Hieuh}, + {"Hangul_RieulYeorinHieuh", XK_Hangul_RieulYeorinHieuh}, + {"Hangul_SunkyeongeumMieum", XK_Hangul_SunkyeongeumMieum}, + {"Hangul_SunkyeongeumPieub", XK_Hangul_SunkyeongeumPieub}, + {"Hangul_PanSios", XK_Hangul_PanSios}, + {"Hangul_KkogjiDalrinIeung", XK_Hangul_KkogjiDalrinIeung}, + {"Hangul_SunkyeongeumPhieuf", XK_Hangul_SunkyeongeumPhieuf}, + {"Hangul_YeorinHieuh", XK_Hangul_YeorinHieuh}, + {"Hangul_AraeA", XK_Hangul_AraeA}, + {"Hangul_AraeAE", XK_Hangul_AraeAE}, + {"Hangul_J_PanSios", XK_Hangul_J_PanSios}, + {"Hangul_J_KkogjiDalrinIeung", XK_Hangul_J_KkogjiDalrinIeung}, + {"Hangul_J_YeorinHieuh", XK_Hangul_J_YeorinHieuh}, + {"Korean_Won", XK_Korean_Won}, +#endif /* XK_KOREAN */ + {"EuroSign", XK_EuroSign}, +#endif + {"NoSymbol", NoSymbol} +}; + +KeySym +XStringToKeysym(const char *str) +{ + int i; + for (i = 0; StringToKeysym[i].keysym != NoSymbol + && strcmp(StringToKeysym[i].string, str); i++); + return StringToKeysym[i].keysym; +} + +const char * +XKeysymToString(KeySym keysym) +{ + int i; + for (i = 0; StringToKeysym[i].keysym != NoSymbol + && StringToKeysym[i].keysym != keysym; i++); + return StringToKeysym[i].string; +} + +void +XDisplayKeycodes(Display * display, int *min_keycode, int *max_keycode) +{ + /* VNC keycodes are non-existant */ + *min_keycode = 0xffff; + *max_keycode = 0; +} diff -urN rdesktop-1.5.0.org/vnc/x11stubs.h rdesktop-1.5.0/vnc/x11stubs.h --- rdesktop-1.5.0.org/vnc/x11stubs.h 1970-01-01 01:00:00.000000000 +0100 +++ rdesktop-1.5.0/vnc/x11stubs.h 2004-04-10 11:34:52.000000000 +0200 @@ -0,0 +1,33 @@ +#ifndef NOXKEYMAP_H +#define NOXKEYMAP_H + +/* Fake a few X11 calls */ + +#define XK_MISCELLANY +#include +#include + +#define NoSymbol 0L +#define ShiftMask (1<<0) +#define LockMask (1<<1) +#define ControlMask (1<<2) +#define Mod1Mask (1<<3) +#define Mod2Mask (1<<4) +#define Mod3Mask (1<<5) +#define Mod4Mask (1<<6) +#define Mod5Mask (1<<7) +#define Button1 1 +#define Button2 2 +#define Button3 3 +#define Button4 4 +#define Button5 5 + +typedef int Display; +typedef int Window; +typedef rfbKeySym KeySym; + +KeySym XStringToKeysym(const char *str); +const char *XKeysymToString(KeySym keysym); +void XDisplayKeycodes(Display * display, int *min_keycode, int *max_keycode); + +#endif