Archon: archon/display/x11/implementation.C Source File

00001 /*
00002  * This file is part of the "Archon" framework.
00003  * (http://files3d.sourceforge.net)
00004  *
00005  * Copyright Â© 2006 by Kristian Spangsege and Brian Kristiansen.
00006  *
00007  * Permission to use, copy, modify, and distribute this software and
00008  * its documentation under the terms of the GNU General Public License is
00009  * hereby granted. No representations are made about the suitability of
00010  * this software for any purpose. It is provided "as is" without express
00011  * or implied warranty. See the GNU General Public License
00012  * (http://www.gnu.org/copyleft/gpl.html) for more details.
00013  *
00014  * The characters in this file are ISO8859-1 encoded.
00015  *
00016  * The documentation in this file is in "Doxygen" style
00017  * (http://www.doxygen.org).
00018  */
00019 
00020 #include <X11/Xlib.h>
00021 #include <X11/keysym.h>
00022 #include <GL/glx.h>
00023 #include <X11/extensions/Xrender.h>
00024 
00025 #include <stdexcept>
00026 #include <string>
00027 #include <map>
00028 #include <bitset>
00029 
00030 #include <archon/util/exception.H>
00031 #include <archon/util/ref.H>
00032 #include <archon/util/memory.H>
00033 #include <archon/util/text.H>
00034 #include <archon/util/condition.H>
00035 #include <archon/util/image.H>
00036 #include <archon/display/x11/implementation.H>
00037 
00038 namespace Archon
00039 {
00040   namespace Display
00041   {
00042     using namespace Archon::Utilities;
00043 
00044     struct ImplementationX11;
00045     struct ConnectionX11;
00046     struct ScreenX11;
00047     struct VisualX11;
00048     struct WindowX11;
00049     struct ContextX11;
00050 
00051 
00052 
00053     struct ContextX11: Context
00054     {
00055       GLXContext ctx;
00056       Ref<VisualX11> visual;
00057       ContextX11(GLXContext ctx, Ref<VisualX11> visual);
00058       ~ContextX11();
00059       Ref<Visual> getVisual();
00060       bool isDirect();
00061       void bind(const Ref<Drawable> &d, bool block)
00062         throw(ContextAlreadyBoundException, NestedBindingException, invalid_argument);
00063       void unbind();
00064       Mutex bindMutex;
00065       bool bound; // Protected by bindMutex
00066       Condition unbindCond; // Protected by bindMutex
00067     };
00068 
00069     struct WindowX11: Window
00070     {
00071       ::Window win;
00072       int width, height;
00073       Ref<VisualX11> visual;
00074       WindowX11(::Window win, int width, int height, Ref<VisualX11> visual);
00075       ~WindowX11();
00076       Ref<Visual> getVisual();
00077       void setTitle(string title);
00078       void move(int left, int top);
00079       void resize(int width, int height);
00080       int getWidth();
00081       int getHeight();
00082       void swapBuffers();
00083       void processEvents(EventHandler *);
00084       typedef bitset<256> KeyStates;
00085       KeyStates keyStates;
00086       void processKeyEvent(EventHandler *, XKeyEvent *event, bool press);
00087     };
00088 
00089     struct VisualX11: Visual
00090     {
00091       int index;
00092       Ref<ScreenX11> screen;
00093       VisualX11(int index, Ref<ScreenX11> screen);
00094       ~VisualX11();
00095       Ref<Screen> getScreen();
00096       Ref<Window> newWindow(int left, int top, int width, int height,
00097                             string title) throw(NoWindowsException);
00098       Ref<Context> newContext(bool direct, Ref<Context> shareWith)
00099         throw(invalid_argument);
00100       int getAttrib(int attrib);
00101       int getRedBufferSize();
00102       int getGreenBufferSize();
00103       int getBlueBufferSize();
00104       int getAlphaBufferSize();
00105       int getDepthBufferSize();
00106       int getStencilBufferSize();
00107       int getAccumRedBufferSize();
00108       int getAccumGreenBufferSize();
00109       int getAccumBlueBufferSize();
00110       int getAccumAlphaBufferSize();
00111     };
00112 
00113     struct ScreenX11: Screen
00114     {
00115       int index;
00116       Ref<ConnectionX11> connection;
00117       Mutex visualsMutex;
00118       vector<VisualX11 *> visuals; // Elements protected by visualsMutex (vector is constant)
00119       XVisualInfo *info; // Pointer to array of XVisualInfo with length equal to visuals
00120       int defaultVisual; // Index of default visual
00121       ScreenX11(int index, Ref<ConnectionX11> connection);
00122       ~ScreenX11();
00123       Ref<Connection> getConnection();
00124       Ref<Visual> getDefaultVisual();
00125       Ref<Visual> chooseVisual(bool doubleBuffer, bool stereo,
00126                                int red, int green, int blue, int alpha,
00127                                int depth, int stencil,
00128                                int accumRed, int accumGreen,
00129                                int accumBlue, int accumAlpha)
00130         throw(NoSuchVisualException);
00131       int getNumberOfVisuals();
00132       Ref<Visual> getVisual(int index) throw(out_of_range);
00133       void removeVisual(int index, VisualX11 *);
00134       int getWidth();
00135       int getHeight();
00136       double getHorizontalDotPitch();
00137       double getVerticalDotPitch();
00138     };
00139 
00140     struct ConnectionX11: Connection
00141     {
00142       ::Display *dpy;
00143       Ref<ImplementationX11> implementation;
00144       Mutex screensMutex;
00145       vector<ScreenX11 *> screens; // Elements protected by screensMutex (vector is constant)
00146       ConnectionX11(string displayName, Ref<ImplementationX11> implementation)
00147         throw(NoDisplayException);
00148       ~ConnectionX11();
00149       Ref<Implementation> getImplementation();
00150       Ref<Screen> getDefaultScreen();
00151       int getNumberOfScreens();
00152       Ref<Screen> getScreen(int index) throw(out_of_range);
00153       void removeScreen(int index, ScreenX11 *);
00154     };
00155 
00156     struct ImplementationX11: Implementation
00157     {
00158       string getMnemonic();
00159       Ref<Connection> newConnection() throw(NoDisplayException);
00160     };
00161 
00162 
00163 
00164     Ref<Implementation> getImplementationX11()
00165     {
00166       return new ImplementationX11();
00167     }
00168 
00169 
00170 
00171 
00172     string ImplementationX11::getMnemonic()
00173     {
00174       return "x11";
00175     }
00176 
00177     Ref<Connection> ImplementationX11::newConnection()
00178       throw(NoDisplayException)
00179     {
00180       return new ConnectionX11("", this);
00181     }
00182 
00183 
00184 
00185 
00186     namespace
00187     {
00188       string actualDisplayName(string n)
00189       {
00190         return XDisplayName(n.empty() ? 0 : n.c_str());
00191       }
00192     }
00193 
00194     ConnectionX11::ConnectionX11(string displayName,
00195                                  Ref<ImplementationX11> implementation)
00196       throw(NoDisplayException): implementation(implementation)
00197     {
00198       dpy = XOpenDisplay(displayName.empty() ? 0 : displayName.c_str());
00199       if(!dpy) ARCHON_THROW1(NoDisplayException,
00200                              "Could not connect to display '" +
00201                              actualDisplayName(displayName) + "'");
00202       
00203       if(!glXQueryExtension(dpy, 0, 0))
00204         ARCHON_THROW1(NoDisplayException, "OpenGL GLX extension not "
00205                       "supported by display '" +
00206                       actualDisplayName(displayName) + "'");
00207       screens.resize(ScreenCount(dpy), 0);
00208     }
00209 
00213     ConnectionX11::~ConnectionX11()
00214     {
00215       XCloseDisplay(dpy);
00216     }
00217 
00218     Ref<Implementation> ConnectionX11::getImplementation()
00219     {
00220       return implementation;
00221     }
00222 
00223     Ref<Screen> ConnectionX11::getDefaultScreen()
00224     {
00225       return getScreen(DefaultScreen(dpy));
00226     }
00227 
00228     int ConnectionX11::getNumberOfScreens()
00229     {
00230       return screens.size();
00231     }
00232 
00233     Ref<Screen> ConnectionX11::getScreen(int index) throw(out_of_range)
00234     {
00235       Mutex::Lock l(screensMutex);
00236       Ref<ScreenX11> screen(screens.at(index), RefSafeIncTag());
00237       if(!screen)
00238       {
00239         screen.reset(new ScreenX11(index, this));
00240         screens[index] = screen.get();
00241       }
00242       return screen;
00243     }
00244 
00245     void ConnectionX11::removeScreen(int index, ScreenX11 *screen)
00246     {
00247       Mutex::Lock l(screensMutex);
00248       ScreenX11 *&p = screens[index];
00249       if(p == screen) p = 0;
00250     }
00251 
00252 
00253 
00254     ScreenX11::ScreenX11(int index, Ref<ConnectionX11> connection):
00255       index(index), connection(connection), defaultVisual(0)
00256     {
00257       VisualID defaultId = XVisualIDFromVisual(DefaultVisual(connection->dpy, index));
00258       XVisualInfo t;
00259       t.screen = index;
00260       int n;
00261       info = XGetVisualInfo(connection->dpy, VisualScreenMask, &t, &n);
00262       if(info)
00263       {
00264         visuals.resize(n, 0);
00265         for(int i=0; i<n; ++i) if(info[i].visualid == defaultId)
00266         {
00267           defaultVisual = i;
00268           break;
00269         }
00270       }
00271     }
00272 
00273     ScreenX11::~ScreenX11()
00274     {
00275       connection->removeScreen(index, this);
00276       if(info) XFree(info);
00277     }
00278 
00279     Ref<Connection> ScreenX11::getConnection()
00280     {
00281       return connection;
00282     }
00283 
00284     Ref<Visual> ScreenX11::getDefaultVisual()
00285     {
00286       return getVisual(defaultVisual);
00287     }
00288 
00289     Ref<Visual> ScreenX11::chooseVisual(bool doubleBuffer,
00290                                         bool stereo,
00291                                         int red, int green,
00292                                         int blue, int alpha,
00293                                         int depth, int stencil,
00294                                         int accumRed, int accumGreen,
00295                                         int accumBlue, int accumAlpha)
00296       throw(NoSuchVisualException)
00297     {
00298       int attribs[32];
00299       int i = 0;
00300 
00301       attribs[i++] = GLX_RGBA;
00302 
00303       if(doubleBuffer) attribs[i++] = GLX_DOUBLEBUFFER;
00304       if(stereo)       attribs[i++] = GLX_STEREO;
00305 
00306       if(red)     { attribs[i++] = GLX_RED_SIZE;     attribs[i++] = red;     }
00307       if(green)   { attribs[i++] = GLX_GREEN_SIZE;   attribs[i++] = green;   }
00308       if(blue)    { attribs[i++] = GLX_BLUE_SIZE;    attribs[i++] = blue;    }
00309       if(alpha)   { attribs[i++] = GLX_ALPHA_SIZE;   attribs[i++] = alpha;   }
00310       if(depth)   { attribs[i++] = GLX_DEPTH_SIZE;   attribs[i++] = depth;   }
00311       if(stencil) { attribs[i++] = GLX_STENCIL_SIZE; attribs[i++] = stencil; }
00312 
00313       if(accumRed)
00314       {
00315         attribs[i++] = GLX_ACCUM_RED_SIZE;
00316         attribs[i++] = accumRed;
00317       }
00318 
00319       if(accumGreen)
00320       {
00321         attribs[i++] = GLX_ACCUM_GREEN_SIZE;
00322         attribs[i++] = accumGreen;
00323       }
00324 
00325       if(accumBlue)
00326       {
00327         attribs[i++] = GLX_ACCUM_BLUE_SIZE;
00328         attribs[i++] = accumBlue;
00329       }
00330 
00331       if(accumAlpha)
00332       {
00333         attribs[i++] = GLX_ACCUM_ALPHA_SIZE;
00334         attribs[i++] = accumAlpha;
00335       }
00336 
00337       attribs[i] = None;
00338 
00339       XVisualInfo *vis = glXChooseVisual(connection->dpy, index, attribs);
00340       if(!vis) ARCHON_THROW(NoSuchVisualException);
00341       VisualID id = vis->visualid;
00342       XFree(vis);
00343 
00344       // Find visual index
00345       for(int j=0; j<static_cast<int>(visuals.size()); ++j) if(info[j].visualid == id) return getVisual(j);
00346       ARCHON_THROW1(InternalException, "Unable to find visual ID");
00347     }
00348 
00349     int ScreenX11::getNumberOfVisuals()
00350     {
00351       return visuals.size();
00352     }
00353 
00354     Ref<Visual> ScreenX11::getVisual(int index) throw(out_of_range)
00355     {
00356       Mutex::Lock l(visualsMutex);
00357       Ref<VisualX11> visual(visuals.at(index), RefSafeIncTag());
00358       if(!visual)
00359       {
00360         visual.reset(new VisualX11(index, this));
00361         visuals[index] = visual.get();
00362       }
00363       return visual;
00364     }
00365 
00366     void ScreenX11::removeVisual(int index, VisualX11 *visual)
00367     {
00368       Mutex::Lock l(visualsMutex);
00369       VisualX11 *&p = visuals[index];
00370       if(p == visual) p = 0;
00371     }
00372 
00373     int ScreenX11::getWidth()
00374     {
00375       return WidthOfScreen(ScreenOfDisplay(connection->dpy, index));
00376     }
00377 
00378     int ScreenX11::getHeight()
00379     {
00380       return HeightOfScreen(ScreenOfDisplay(connection->dpy, index));
00381     }
00382 
00383     double ScreenX11::getHorizontalDotPitch()
00384     {
00385       double v = WidthMMOfScreen(ScreenOfDisplay(connection->dpy, index));
00386       return v / getWidth() / 1000;
00387     }
00388 
00389     double ScreenX11::getVerticalDotPitch()
00390     {
00391       double v = HeightMMOfScreen(ScreenOfDisplay(connection->dpy, index));
00392       return v / getHeight() / 1000;
00393     }
00394 
00395 
00396 
00397 
00398     VisualX11::VisualX11(int index, Ref<ScreenX11> screen):
00399       index(index), screen(screen)
00400     {
00401     }
00402 
00403     VisualX11::~VisualX11()
00404     {
00405       screen->removeVisual(index, this);
00406     }
00407 
00408     Ref<Screen> VisualX11::getScreen()
00409     {
00410       return screen;
00411     }
00412 
00413     Ref<Window> VisualX11::newWindow(int left, int top, int width, int height,
00414                                      string title) throw(NoWindowsException)
00415     {
00416       XSetWindowAttributes swa;
00417 
00418       swa.event_mask = FocusChangeMask | EnterWindowMask | LeaveWindowMask |
00419         ButtonPressMask | ButtonReleaseMask | PointerMotionMask |
00420         KeyPressMask | KeyRelease | StructureNotifyMask;
00421       swa.background_pixmap = None;
00422       swa.background_pixel  = 0;
00423       swa.border_pixel = 0;
00424 
00425       ::Display *dpy = screen->connection->dpy;
00426       XVisualInfo *vis = &screen->info[index];
00427       ::Window root = RootWindow(dpy, vis->screen);
00428 
00429       swa.colormap = XCreateColormap(dpy, root, vis->visual, AllocNone);
00430 
00431       ::Window win =
00432           XCreateWindow(dpy, root, left, top, width, height, 0, vis->depth,
00433                         InputOutput, vis->visual, CWEventMask|CWBackPixmap|
00434                         CWBorderPixel|CWColormap, &swa);
00435 
00436       // Set up some window manager hints
00437 
00438       XSizeHints sizeHints;
00439       sizeHints.flags = 0;
00440       if(true) sizeHints.flags |= USPosition; 
00441       if(true) sizeHints.flags |= USSize;     
00442       sizeHints.x      = left;
00443       sizeHints.y      = top;
00444       sizeHints.width  = width;
00445       sizeHints.height = height;
00446 
00447       XWMHints wmHints;
00448       wmHints.flags = StateHint;
00449       wmHints.initial_state = false ? IconicState : NormalState; 
00450 
00451       XTextProperty textProperty;
00452       const char *t = title.c_str();
00453       XStringListToTextProperty(const_cast<char **>(&t), 1, &textProperty);
00454 
00455       XSetWMProperties(dpy, win,
00456                        &textProperty, // Window title
00457                        &textProperty, // Icon title
00458                        0,             // argv (of application)
00459                        0,             // argc (of application)
00460                        &sizeHints,
00461                        &wmHints,
00462                        0);            // Class hints
00463       XFree(textProperty.value);
00464 
00465       // Ask X to notify rather than kill us when user attempts to close the window.
00466       Atom deleteWindow = XInternAtom(dpy, "WM_DELETE_WINDOW", False);
00467       XSetWMProtocols(dpy, win, &deleteWindow, 1);
00468 
00469       XMapWindow(dpy, win);
00470 
00471       XFlush(dpy);
00472 
00473 
00474       int xrender_eventbase, xrender_errorbase;
00475       if(!XRenderQueryExtension(dpy, &xrender_eventbase, &xrender_errorbase)) {
00476         printf("Xrender extension is required, but not available.\n");
00477         exit(1);
00478       }
00479 
00480       int major = 0;
00481       int minor = 0;
00482       if(!XRenderQueryVersion(dpy, &major, &minor)) {
00483         printf("Error querying Xrender version.\n");
00484         exit(1);
00485       }
00486 
00487       Utilities::Image uImage("/home/kristian/persist/devel/cvs/files3d/scenes/img/g-small.png");
00488       int iwidth = uImage.getWidth();
00489       int iheight = uImage.getHeight();
00490       if(64 < iwidth) iwidth = 64;
00491       if(64 < iheight) iheight = 64;
00492       Pixmap pixmap = XCreatePixmap(dpy, win, iwidth, iheight, 24);
00493       GC gc = XCreateGC(dpy, pixmap, 0, NULL);
00494       XImage image;
00495       image.width = iwidth;
00496       image.height = iheight;           // size of image
00497       image.xoffset = 0;                // number of pixels offset in X direction
00498       image.format = ZPixmap;           // XYBitmap, XYPixmap, ZPixmap
00499       image.data = uImage.getPixelBuffer(); // pointer to image data
00500       image.byte_order = LSBFirst;      // data byte order, LSBFirst, MSBFirst
00501       image.bitmap_unit = 8;            // quant. of scanline 8, 16, 32
00502       //image.bitmap_bit_order = MSBFirst; // LSBFirst, MSBFirst
00503       //image.bitmap_pad = 8;           // 8, 16, 32 either XY or ZPixmap
00504       image.depth = 24;                 // depth of image
00505       image.bytes_per_line = uImage.getCharsPerRow(); // accelerator to next scanline
00506       image.bits_per_pixel = 8 * uImage.getCharsPerPixel(); // bits per pixel (ZPixmap)
00507       //image.red_mask   = 0xFF << 16;  // bits in z arrangement
00508       //image.green_mask = 0xFF <<  8;
00509       //image.blue_mask  = 0xFF <<  0;
00510       XInitImage(&image);
00511       XPutImage(dpy, pixmap, gc, &image, 0, 0, 0, 0, iwidth, iheight);
00512       //XSetForeground(dpy, gc, WhitePixel(dpy, screen->index));
00513       //XFillRectangle(dpy, pixmap, gc, 0, 0, iwidth, iheight);
00514       // XCreatePixmap(Display *display, Drawable d, unsigned int width, unsigned int height, unsigned int depth);
00515       // XFreePixmap(Display *display, Pixmap pixmap);
00516       // XRenderPictFormat *format = XRenderFindStandardFormat(dpy, PictStandardARGB32);
00517       XRenderPictFormat *format = XRenderFindVisualFormat(dpy, vis->visual);
00518       cerr << "Red:       " << format->direct.red << endl;
00519       cerr << "RedMask:   " << format->direct.redMask << endl;
00520       cerr << "Green:     " << format->direct.green << endl;
00521       cerr << "GreenMask: " << format->direct.greenMask << endl;
00522       cerr << "Blue:      " << format->direct.blue << endl;
00523       cerr << "BlueMask:  " << format->direct.blueMask << endl;
00524       cerr << "Alpha:     " << format->direct.alpha << endl;
00525       cerr << "AlphaMask: " << format->direct.alphaMask << endl;
00526       format->direct.red = 0;
00527       format->direct.blue = 16;
00528       cerr << "Red:       " << format->direct.red << endl;
00529       cerr << "RedMask:   " << format->direct.redMask << endl;
00530       cerr << "Green:     " << format->direct.green << endl;
00531       cerr << "GreenMask: " << format->direct.greenMask << endl;
00532       cerr << "Blue:      " << format->direct.blue << endl;
00533       cerr << "BlueMask:  " << format->direct.blueMask << endl;
00534       cerr << "Alpha:     " << format->direct.alpha << endl;
00535       cerr << "AlphaMask: " << format->direct.alphaMask << endl;
00536       XRenderPictureAttributes attributes;
00537       Picture picture = XRenderCreatePicture(dpy, pixmap, format, 0, &attributes);
00538       Cursor cursor = XRenderCreateCursor(dpy, picture, 0, 0);
00539       XDefineCursor(dpy, win, cursor);
00540       XRenderFreePicture(dpy, picture);
00541       XFreeGC(dpy, gc);
00542 
00543       Ref<WindowX11> w = new WindowX11(win, width, height, this);
00544       if(title.size()) w->setTitle(title);
00545       return w;
00546     }
00547 
00548     Ref<Context> VisualX11::newContext(bool direct, Ref<Context> shareWith)
00549       throw(invalid_argument)
00550     {
00551       ContextX11 *s = dynamic_cast<ContextX11 *>(shareWith.get());
00552       if(shareWith && !s) throw invalid_argument("Implementation mismatch");
00553 
00554       GLXContext ctx =
00555         glXCreateContext(screen->connection->dpy, &screen->info[index],
00556                          s ? s->ctx : 0, direct);
00557 
00558       return new ContextX11(ctx, this);
00559     }
00560 
00561     int VisualX11::getAttrib(int attrib)
00562     {
00563       int v;
00564       if(glXGetConfig(screen->connection->dpy, &screen->info[index], attrib, &v))
00565         ARCHON_THROW1(InternalException, "glXGetConfig failed");
00566       return v;
00567     }
00568 
00569     int VisualX11::getRedBufferSize()
00570     {
00571       return getAttrib(GLX_RED_SIZE);
00572     }
00573 
00574     int VisualX11::getGreenBufferSize()
00575     {
00576       return getAttrib(GLX_GREEN_SIZE);
00577     }
00578 
00579     int VisualX11::getBlueBufferSize()
00580     {
00581        return getAttrib(GLX_BLUE_SIZE);
00582     }
00583 
00584     int VisualX11::getAlphaBufferSize()
00585     {
00586       return getAttrib(GLX_ALPHA_SIZE);
00587     }
00588 
00589     int VisualX11::getDepthBufferSize()
00590     {
00591       return getAttrib(GLX_DEPTH_SIZE);
00592     }
00593 
00594     int VisualX11::getStencilBufferSize()
00595     {
00596       return getAttrib(GLX_STENCIL_SIZE);
00597     }
00598 
00599     int VisualX11::getAccumRedBufferSize()
00600     {
00601       return getAttrib(GLX_ACCUM_RED_SIZE);
00602     }
00603 
00604     int VisualX11::getAccumGreenBufferSize()
00605     {
00606       return getAttrib(GLX_ACCUM_GREEN_SIZE);
00607     }
00608 
00609     int VisualX11::getAccumBlueBufferSize()
00610     {
00611       return getAttrib(GLX_ACCUM_BLUE_SIZE);
00612     }
00613 
00614     int VisualX11::getAccumAlphaBufferSize()
00615     {
00616       return getAttrib(GLX_ACCUM_ALPHA_SIZE);
00617     }
00618 
00619 
00620 
00621 
00622     WindowX11::WindowX11(::Window win, int width, int height, Ref<VisualX11> visual):
00623       win(win), width(width), height(height), visual(visual)
00624     {
00625     }
00626 
00627     WindowX11::~WindowX11()
00628     {
00629       XDestroyWindow(visual->screen->connection->dpy, win);
00630     }
00631 
00632     Ref<Visual> WindowX11::getVisual()
00633     {
00634       return visual;
00635     }
00636 
00637     void WindowX11::setTitle(string title)
00638     {
00639       ::Display *dpy = visual->screen->connection->dpy;
00640       XTextProperty textProperty;
00641       const char *t = title.c_str();
00642       XStringListToTextProperty(const_cast<char **>(&t), 1, &textProperty);
00643       XSetWMName(dpy, win, &textProperty);
00644       XSetWMIconName(dpy, win, &textProperty);
00645       XFree(textProperty.value);
00646     }
00647 
00648     void WindowX11::move(int left, int top)
00649     {
00650       XMoveWindow(visual->screen->connection->dpy, win, left, top);
00651     }
00652 
00653     void WindowX11::resize(int width, int height)
00654     {
00655       XResizeWindow(visual->screen->connection->dpy, win, width, height);
00656     }
00657 
00658     int WindowX11::getWidth()
00659     {
00660       return width;
00661     }
00662 
00663     int WindowX11::getHeight()
00664     {
00665       return height;
00666     }
00667 
00668     void WindowX11::swapBuffers()
00669     {
00670       glXSwapBuffers(visual->screen->connection->dpy, win);
00671     }
00672 
00673     void WindowX11::processEvents(EventHandler *h)
00674     {
00675       ::Display *dpy = visual->screen->connection->dpy;
00676       while(XPending(dpy))
00677       {
00678         XEvent e;
00679         XNextEvent(dpy, &e);
00680         switch(e.type)
00681         {
00682         case MotionNotify:
00683           //cerr << e.xmotion.x << "," << e.xmotion.y << endl;
00684           break;
00685 
00686         case FocusIn:
00687           h->focusIn();
00688           break;
00689 
00690         case FocusOut:
00691           h->focusOut();
00692           break;
00693 
00694         case EnterNotify:
00695           h->mouseIn();
00696           break;
00697 
00698         case LeaveNotify:
00699           h->mouseOut();
00700           break;
00701 
00702         case KeyPress:
00703           processKeyEvent(h, &e.xkey, true);
00704           break;
00705 
00706         case KeyRelease:
00707 
00708           // Filter out events from repeating keys. We cannot use
00709           // XAutoRepeatOff/XAutoRepeatOn since they are not local to
00710           // each window. The following trick is copied from LibSDL -
00711           // thanks :) The trick assumes that whenever a key is
00712           // repeating a KeyRelease event is immediately followed be
00713           // the next KeyPress event on the queue without any
00714           // intermediate events.
00715           if(XPending(dpy))
00716           {
00717             XEvent next;
00718             XPeekEvent(dpy, &next);
00719             if(next.type == KeyPress &&
00720                next.xkey.keycode == e.xkey.keycode &&
00721                next.xkey.time - e.xkey.time < 2)
00722             {
00723               // Discard the next KeyPress event as well as the
00724               // current KeyRelease event
00725               XNextEvent(dpy, &next);
00726               break;
00727             }
00728           }
00729 
00730           processKeyEvent(h, &e.xkey, false);
00731           break;
00732 
00733         case ConfigureNotify:
00734           // Check for resize
00735           if(e.xconfigure.width != width || e.xconfigure.height != height)
00736           {
00737             width  = e.xconfigure.width;
00738             height = e.xconfigure.height;
00739             h->resize(width, height);
00740           }
00741           break;
00742 
00743         case ClientMessage:
00744           Atom deleteWindow = XInternAtom(dpy, "WM_DELETE_WINDOW", False);
00745           if(e.xclient.format == 32 && static_cast<Atom>(e.xclient.data.l[0]) == deleteWindow) h->close();
00746           break;
00747         }
00748       }
00749     }
00750 
00751 
00752 
00753 
00754     ContextX11::ContextX11(GLXContext ctx, Ref<VisualX11> visual):
00755       ctx(ctx), visual(visual), unbindCond(bindMutex)
00756     {
00757     }
00758 
00759     ContextX11::~ContextX11()
00760     {
00761       glXDestroyContext(visual->screen->connection->dpy, ctx);
00762     }
00763 
00764     Ref<Visual> ContextX11::getVisual()
00765     {
00766       return visual;
00767     }
00768 
00769     bool ContextX11::isDirect()
00770     {
00771       return glXIsDirect(visual->screen->connection->dpy, ctx);
00772     }
00773 
00774     void ContextX11::bind(const Ref<Drawable> &d, bool block)
00775       throw(ContextAlreadyBoundException, NestedBindingException, invalid_argument)
00776     {
00777       // Check that this thread is not already bound to a context
00778       if(glXGetCurrentContext()) ARCHON_THROW(NestedBindingException);
00779 
00780       WindowX11 *w = dynamic_cast<WindowX11 *>(d.get());
00781       if(!w) throw invalid_argument("Implementation mismatch");
00782 
00783       ::Display *dpy = visual->screen->connection->dpy;
00784       GLXDrawable drb = static_cast<GLXDrawable>(w->win);
00785 
00786       // Attempt to bind to the context
00787       {
00788         Mutex::Lock l(bindMutex);
00789         while(bound)
00790         {
00791           if(!block) ARCHON_THROW(ContextAlreadyBoundException);
00792           unbindCond.wait();
00793         }
00794 
00795         if(!glXMakeCurrent(dpy, drb, ctx))
00796           ARCHON_THROW1(InternalException, "Unknown error from glXMakeCurrent()");
00797 
00798         bound = true;
00799       }
00800     }
00801 
00802     void ContextX11::unbind()
00803     {
00804       glXMakeCurrent(visual->screen->connection->dpy, None, 0);
00805 
00806       {
00807         Mutex::Lock l(bindMutex);
00808         bound = false;
00809       }
00810 
00811       unbindCond.notifyAll();
00812     }
00813 
00814 
00815 
00816 
00817     struct KeySymMapper
00818     {
00819       Display::KeySym map(::KeySym xKeySym) const
00820       {
00821         PageMap::const_iterator page = pageMap.find(xKeySym >> 8);
00822         if(page == pageMap.end()) return KeySym_None;
00823         return page->second[xKeySym & 255];
00824       }
00825 
00826       KeySymMapper();
00827 
00828     private:
00833       void add(::KeySym xKeySym, Display::KeySym aKeySym)
00834       {
00835         if(aKeySym == KeySym_None) ARCHON_THROW1(InternalException, "Invalid mapping from X KeySym '"+
00836                                                  Text::toString(static_cast<long>(xKeySym))+"' to 'None'");
00837         Array<Display::KeySym> &page = pageMap[xKeySym >> 8];
00838         if(!page) page.reset(256, KeySym_None); // Allocate memery for each new page
00839         Display::KeySym &sym = page[xKeySym & 255];
00840         if(sym != KeySym_None) ARCHON_THROW1(InternalException, "Redefinition of X KeySym '"+
00841                                              Text::toString(static_cast<long>(xKeySym))+"'");
00842         sym = aKeySym;
00843       }
00844 
00845       typedef std::map<long, Array<Display::KeySym> > PageMap;
00846       PageMap pageMap;
00847     };
00848 
00849     void WindowX11::processKeyEvent(EventHandler *h, XKeyEvent *event, bool down)
00850     {
00851       // Xlibs KeyCodes (or scan codes) have the property of being
00852       // small, therefore they can be used as indexes into an array.
00853       int i = event->keycode;
00854       KeyStates::reference b = keyStates[i];
00855       if(b == down) return; // Ignore events that does not change state
00856       b = down;
00857 
00858       // Map the KeyCodes to a keyboard independant symbol identifier
00859       // (in general the symbol in the lower left corner on the
00860       // corresponding key)
00861       ::KeySym xsym = XKeycodeToKeysym(visual->screen->connection->dpy, i, 0);
00862 
00863       // To decouple our symbol identifiers from Xlib we map them once
00864       // again to Archon KeySym identifiers.
00865       static KeySymMapper mapper;
00866       Display::KeySym sym = mapper.map(xsym);
00867       if(down) h->keyDown(sym);
00868       else h->keyUp(sym);
00869       //cerr << (down?"KeyPress: ":"KeyRelease: ") << i << " -> " << XKeysymToString(xsym) << " -> " << sym << endl;
00870     }
00871 
00872     KeySymMapper::KeySymMapper()
00873     {
00874       /*
00875        * TTY Functions
00876        */
00877       add(XK_BackSpace,                   KeySym_BackSpace);
00878       add(XK_Tab,                         KeySym_Tab);
00879       add(XK_Linefeed,                    KeySym_Linefeed);
00880       add(XK_Clear,                       KeySym_Clear);
00881       add(XK_Return,                      KeySym_Return);
00882       add(XK_Pause,                       KeySym_Pause);
00883       add(XK_Scroll_Lock,                 KeySym_Scroll_Lock);
00884       add(XK_Sys_Req,                     KeySym_Sys_Req);
00885       add(XK_Escape,                      KeySym_Escape);
00886       add(XK_Delete,                      KeySym_Delete);
00887 
00888 
00889       /*
00890        * International & multi-key character composition
00891        */
00892       add(XK_Multi_key,                   KeySym_Multi_key);
00893       add(XK_Codeinput,                   KeySym_Codeinput);
00894       add(XK_SingleCandidate,             KeySym_SingleCandidate);
00895       add(XK_MultipleCandidate,           KeySym_MultipleCandidate);
00896       add(XK_PreviousCandidate,           KeySym_PreviousCandidate);
00897 
00898 
00899       /*
00900        * Japanese keyboard support
00901        */
00902       add(XK_Kanji,                       KeySym_Kanji);
00903       add(XK_Muhenkan,                    KeySym_Muhenkan);
00904       add(XK_Henkan_Mode,                 KeySym_Henkan_Mode);
00905       add(XK_Romaji,                      KeySym_Romaji);
00906       add(XK_Hiragana,                    KeySym_Hiragana);
00907       add(XK_Katakana,                    KeySym_Katakana);
00908       add(XK_Hiragana_Katakana,           KeySym_Hiragana_Katakana);
00909       add(XK_Zenkaku,                     KeySym_Zenkaku);
00910       add(XK_Hankaku,                     KeySym_Hankaku);
00911       add(XK_Zenkaku_Hankaku,             KeySym_Zenkaku_Hankaku);
00912       add(XK_Touroku,                     KeySym_Touroku);
00913       add(XK_Massyo,                      KeySym_Massyo);
00914       add(XK_Kana_Lock,                   KeySym_Kana_Lock);
00915       add(XK_Kana_Shift,                  KeySym_Kana_Shift);
00916       add(XK_Eisu_Shift,                  KeySym_Eisu_Shift);
00917       add(XK_Eisu_toggle,                 KeySym_Eisu_toggle);
00918 
00919 
00920       /*
00921        * Cursor control & motion
00922        */
00923       add(XK_Home,                        KeySym_Home);
00924       add(XK_Left,                        KeySym_Left);
00925       add(XK_Up,                          KeySym_Up);
00926       add(XK_Right,                       KeySym_Right);
00927       add(XK_Down,                        KeySym_Down);
00928       add(XK_Prior,                       KeySym_Prior);
00929       add(XK_Next,                        KeySym_Next);
00930       add(XK_End,                         KeySym_End);
00931       add(XK_Begin,                       KeySym_Begin);
00932 
00933 
00934       /*
00935        * Misc Functions
00936        */
00937       add(XK_Select,                      KeySym_Select);
00938       add(XK_Print,                       KeySym_Print);
00939       add(XK_Execute,                     KeySym_Execute);
00940       add(XK_Insert,                      KeySym_Insert);
00941       add(XK_Undo,                        KeySym_Undo);
00942       add(XK_Redo,                        KeySym_Redo);
00943       add(XK_Menu,                        KeySym_Menu);
00944       add(XK_Find,                        KeySym_Find);
00945       add(XK_Cancel,                      KeySym_Cancel);
00946       add(XK_Help,                        KeySym_Help);
00947       add(XK_Break,                       KeySym_Break);
00948       add(XK_Mode_switch,                 KeySym_Mode_switch);
00949       add(XK_Num_Lock,                    KeySym_Num_Lock);
00950 
00951 
00952       /*
00953        * Keypad Functions
00954        */
00955       add(XK_KP_Space,                    KeySym_KP_Space);
00956       add(XK_KP_Tab,                      KeySym_KP_Tab);
00957       add(XK_KP_Enter,                    KeySym_KP_Enter);
00958       add(XK_KP_F1,                       KeySym_KP_F1);
00959       add(XK_KP_F2,                       KeySym_KP_F2);
00960       add(XK_KP_F3,                       KeySym_KP_F3);
00961       add(XK_KP_F4,                       KeySym_KP_F4);
00962       add(XK_KP_Home,                     KeySym_KP_Home);
00963       add(XK_KP_Left,                     KeySym_KP_Left);
00964       add(XK_KP_Up,                       KeySym_KP_Up);
00965       add(XK_KP_Right,                    KeySym_KP_Right);
00966       add(XK_KP_Down,                     KeySym_KP_Down);
00967       add(XK_KP_Prior,                    KeySym_KP_Prior);
00968       add(XK_KP_Next,                     KeySym_KP_Next);
00969       add(XK_KP_End,                      KeySym_KP_End);
00970       add(XK_KP_Begin,                    KeySym_KP_Begin);
00971       add(XK_KP_Insert,                   KeySym_KP_Insert);
00972       add(XK_KP_Delete,                   KeySym_KP_Delete);
00973       add(XK_KP_Equal,                    KeySym_KP_Equal);
00974       add(XK_KP_Multiply,                 KeySym_KP_Multiply);
00975       add(XK_KP_Add,                      KeySym_KP_Add);
00976       add(XK_KP_Separator,                KeySym_KP_Separator);
00977       add(XK_KP_Subtract,                 KeySym_KP_Subtract);
00978       add(XK_KP_Decimal,                  KeySym_KP_Decimal);
00979       add(XK_KP_Divide,                   KeySym_KP_Divide);
00980 
00981       add(XK_KP_0,                        KeySym_KP_0);
00982       add(XK_KP_1,                        KeySym_KP_1);
00983       add(XK_KP_2,                        KeySym_KP_2);
00984       add(XK_KP_3,                        KeySym_KP_3);
00985       add(XK_KP_4,                        KeySym_KP_4);
00986       add(XK_KP_5,                        KeySym_KP_5);
00987       add(XK_KP_6,                        KeySym_KP_6);
00988       add(XK_KP_7,                        KeySym_KP_7);
00989       add(XK_KP_8,                        KeySym_KP_8);
00990       add(XK_KP_9,                        KeySym_KP_9);
00991 
00992 
00993       /*
00994        * Auxilliary Functions
00995        */
00996       add(XK_F1,                          KeySym_F1);
00997       add(XK_F2,                          KeySym_F2);
00998       add(XK_F3,                          KeySym_F3);
00999       add(XK_F4,                          KeySym_F4);
01000       add(XK_F5,                          KeySym_F5);
01001       add(XK_F6,                          KeySym_F6);
01002       add(XK_F7,                          KeySym_F7);
01003       add(XK_F8,                          KeySym_F8);
01004       add(XK_F9,                          KeySym_F9);
01005       add(XK_F10,                         KeySym_F10);
01006       add(XK_F11,                         KeySym_F11);
01007       add(XK_F12,                         KeySym_F12);
01008       add(XK_F13,                         KeySym_F13);
01009       add(XK_F14,                         KeySym_F14);
01010       add(XK_F15,                         KeySym_F15);
01011       add(XK_F16,                         KeySym_F16);
01012       add(XK_F17,                         KeySym_F17);
01013       add(XK_F18,                         KeySym_F18);
01014       add(XK_F19,                         KeySym_F19);
01015       add(XK_F20,                         KeySym_F20);
01016       add(XK_F21,                         KeySym_F21);
01017       add(XK_F22,                         KeySym_F22);
01018       add(XK_F23,                         KeySym_F23);
01019       add(XK_F24,                         KeySym_F24);
01020       add(XK_F25,                         KeySym_F25);
01021       add(XK_F26,                         KeySym_F26);
01022       add(XK_F27,                         KeySym_F27);
01023       add(XK_F28,                         KeySym_F28);
01024       add(XK_F29,                         KeySym_F29);
01025       add(XK_F30,                         KeySym_F30);
01026       add(XK_F31,                         KeySym_F31);
01027       add(XK_F32,                         KeySym_F32);
01028       add(XK_F33,                         KeySym_F33);
01029       add(XK_F34,                         KeySym_F34);
01030       add(XK_F35,                         KeySym_F35);
01031 
01032 
01033       /*
01034        * Modifiers
01035        */
01036       add(XK_Shift_L,                     KeySym_Shift_L);
01037       add(XK_Shift_R,                     KeySym_Shift_R);
01038       add(XK_Control_L,                   KeySym_Control_L);
01039       add(XK_Control_R,                   KeySym_Control_R);
01040       add(XK_Caps_Lock,                   KeySym_Caps_Lock);
01041       add(XK_Shift_Lock,                  KeySym_Shift_Lock);
01042 
01043       add(XK_Meta_L,                      KeySym_Meta_L);
01044       add(XK_Meta_R,                      KeySym_Meta_R);
01045       add(XK_Alt_L,                       KeySym_Alt_L);
01046       add(XK_Alt_R,                       KeySym_Alt_R);
01047       add(XK_Super_L,                     KeySym_Super_L);
01048       add(XK_Super_R,                     KeySym_Super_R);
01049       add(XK_Hyper_L,                     KeySym_Hyper_L);
01050       add(XK_Hyper_R,                     KeySym_Hyper_R);
01051 
01052 
01053       /*
01054        * ISO 9995 Function and Modifier Keys
01055        */
01056       add(XK_ISO_Lock,                    KeySym_ISO_Lock);
01057       add(XK_ISO_Level2_Latch,            KeySym_ISO_Level2_Latch);
01058       add(XK_ISO_Level3_Shift,            KeySym_ISO_Level3_Shift);
01059       add(XK_ISO_Level3_Latch,            KeySym_ISO_Level3_Latch);
01060       add(XK_ISO_Level3_Lock,             KeySym_ISO_Level3_Lock);
01061       add(XK_ISO_Group_Latch,             KeySym_ISO_Group_Latch);
01062       add(XK_ISO_Group_Lock,              KeySym_ISO_Group_Lock);
01063       add(XK_ISO_Next_Group,              KeySym_ISO_Next_Group);
01064       add(XK_ISO_Next_Group_Lock,         KeySym_ISO_Next_Group_Lock);
01065       add(XK_ISO_Prev_Group,              KeySym_ISO_Prev_Group);
01066       add(XK_ISO_Prev_Group_Lock,         KeySym_ISO_Prev_Group_Lock);
01067       add(XK_ISO_First_Group,             KeySym_ISO_First_Group);
01068       add(XK_ISO_First_Group_Lock,        KeySym_ISO_First_Group_Lock);
01069       add(XK_ISO_Last_Group,              KeySym_ISO_Last_Group);
01070       add(XK_ISO_Last_Group_Lock,         KeySym_ISO_Last_Group_Lock);
01071 
01072       add(XK_ISO_Left_Tab,                KeySym_ISO_Left_Tab);
01073       add(XK_ISO_Move_Line_Up,            KeySym_ISO_Move_Line_Up);
01074       add(XK_ISO_Move_Line_Down,          KeySym_ISO_Move_Line_Down);
01075       add(XK_ISO_Partial_Line_Up,         KeySym_ISO_Partial_Line_Up);
01076       add(XK_ISO_Partial_Line_Down,       KeySym_ISO_Partial_Line_Down);
01077       add(XK_ISO_Partial_Space_Left,      KeySym_ISO_Partial_Space_Left);
01078       add(XK_ISO_Partial_Space_Right,     KeySym_ISO_Partial_Space_Right);
01079       add(XK_ISO_Set_Margin_Left,         KeySym_ISO_Set_Margin_Left);
01080       add(XK_ISO_Set_Margin_Right,        KeySym_ISO_Set_Margin_Right);
01081       add(XK_ISO_Release_Margin_Left,     KeySym_ISO_Release_Margin_Left);
01082       add(XK_ISO_Release_Margin_Right,    KeySym_ISO_Release_Margin_Right);
01083       add(XK_ISO_Release_Both_Margins,    KeySym_ISO_Release_Both_Margins);
01084       add(XK_ISO_Fast_Cursor_Left,        KeySym_ISO_Fast_Cursor_Left);
01085       add(XK_ISO_Fast_Cursor_Right,       KeySym_ISO_Fast_Cursor_Right);
01086       add(XK_ISO_Fast_Cursor_Up,          KeySym_ISO_Fast_Cursor_Up);
01087       add(XK_ISO_Fast_Cursor_Down,        KeySym_ISO_Fast_Cursor_Down);
01088       add(XK_ISO_Continuous_Underline,    KeySym_ISO_Continuous_Underline);
01089       add(XK_ISO_Discontinuous_Underline, KeySym_ISO_Discontinuous_Underline);
01090       add(XK_ISO_Emphasize,               KeySym_ISO_Emphasize);
01091       add(XK_ISO_Center_Object,           KeySym_ISO_Center_Object);
01092       add(XK_ISO_Enter,                   KeySym_ISO_Enter);
01093 
01094       add(XK_dead_grave,                  KeySym_dead_grave);
01095       add(XK_dead_acute,                  KeySym_dead_acute);
01096       add(XK_dead_circumflex,             KeySym_dead_circumflex);
01097       add(XK_dead_tilde,                  KeySym_dead_tilde);
01098       add(XK_dead_macron,                 KeySym_dead_macron);
01099       add(XK_dead_breve,                  KeySym_dead_breve);
01100       add(XK_dead_abovedot,               KeySym_dead_abovedot);
01101       add(XK_dead_diaeresis,              KeySym_dead_diaeresis);
01102       add(XK_dead_abovering,              KeySym_dead_abovering);
01103       add(XK_dead_doubleacute,            KeySym_dead_doubleacute);
01104       add(XK_dead_caron,                  KeySym_dead_caron);
01105       add(XK_dead_cedilla,                KeySym_dead_cedilla);
01106       add(XK_dead_ogonek,                 KeySym_dead_ogonek);
01107       add(XK_dead_iota,                   KeySym_dead_iota);
01108       add(XK_dead_voiced_sound,           KeySym_dead_voiced_sound);
01109       add(XK_dead_semivoiced_sound,       KeySym_dead_semivoiced_sound);
01110       add(XK_dead_belowdot,               KeySym_dead_belowdot);
01111       add(XK_dead_hook,                   KeySym_dead_hook);
01112       add(XK_dead_horn,                   KeySym_dead_horn);
01113 
01114       add(XK_First_Virtual_Screen,        KeySym_First_Virtual_Screen);
01115       add(XK_Prev_Virtual_Screen,         KeySym_Prev_Virtual_Screen);
01116       add(XK_Next_Virtual_Screen,         KeySym_Next_Virtual_Screen);
01117       add(XK_Last_Virtual_Screen,         KeySym_Last_Virtual_Screen);
01118       add(XK_Terminate_Server,            KeySym_Terminate_Server);
01119 
01120       add(XK_AccessX_Enable,              KeySym_AccessX_Enable);
01121       add(XK_AccessX_Feedback_Enable,     KeySym_AccessX_Feedback_Enable);
01122       add(XK_RepeatKeys_Enable,           KeySym_RepeatKeys_Enable);
01123       add(XK_SlowKeys_Enable,             KeySym_SlowKeys_Enable);
01124       add(XK_BounceKeys_Enable,           KeySym_BounceKeys_Enable);
01125       add(XK_StickyKeys_Enable,           KeySym_StickyKeys_Enable);
01126       add(XK_MouseKeys_Enable,            KeySym_MouseKeys_Enable);
01127       add(XK_MouseKeys_Accel_Enable,      KeySym_MouseKeys_Accel_Enable);
01128       add(XK_Overlay1_Enable,             KeySym_Overlay1_Enable);
01129       add(XK_Overlay2_Enable,             KeySym_Overlay2_Enable);
01130       add(XK_AudibleBell_Enable,          KeySym_AudibleBell_Enable);
01131 
01132       add(XK_Pointer_Left,                KeySym_Pointer_Left);
01133       add(XK_Pointer_Right,               KeySym_Pointer_Right);
01134       add(XK_Pointer_Up,                  KeySym_Pointer_Up);
01135       add(XK_Pointer_Down,                KeySym_Pointer_Down);
01136       add(XK_Pointer_UpLeft,              KeySym_Pointer_UpLeft);
01137       add(XK_Pointer_UpRight,             KeySym_Pointer_UpRight);
01138       add(XK_Pointer_DownLeft,            KeySym_Pointer_DownLeft);
01139       add(XK_Pointer_DownRight,           KeySym_Pointer_DownRight);
01140       add(XK_Pointer_Button_Dflt,         KeySym_Pointer_Button_Dflt);
01141       add(XK_Pointer_Button1,             KeySym_Pointer_Button1);
01142       add(XK_Pointer_Button2,             KeySym_Pointer_Button2);
01143       add(XK_Pointer_Button3,             KeySym_Pointer_Button3);
01144       add(XK_Pointer_Button4,             KeySym_Pointer_Button4);
01145       add(XK_Pointer_Button5,             KeySym_Pointer_Button5);
01146       add(XK_Pointer_DblClick_Dflt,       KeySym_Pointer_DblClick_Dflt);
01147       add(XK_Pointer_DblClick1,           KeySym_Pointer_DblClick1);
01148       add(XK_Pointer_DblClick2,           KeySym_Pointer_DblClick2);
01149       add(XK_Pointer_DblClick3,           KeySym_Pointer_DblClick3);
01150       add(XK_Pointer_DblClick4,           KeySym_Pointer_DblClick4);
01151       add(XK_Pointer_DblClick5,           KeySym_Pointer_DblClick5);
01152       add(XK_Pointer_Drag_Dflt,           KeySym_Pointer_Drag_Dflt);
01153       add(XK_Pointer_Drag1,               KeySym_Pointer_Drag1);
01154       add(XK_Pointer_Drag2,               KeySym_Pointer_Drag2);
01155       add(XK_Pointer_Drag3,               KeySym_Pointer_Drag3);
01156       add(XK_Pointer_Drag4,               KeySym_Pointer_Drag4);
01157       add(XK_Pointer_Drag5,               KeySym_Pointer_Drag5);
01158 
01159       add(XK_Pointer_EnableKeys,          KeySym_Pointer_EnableKeys);
01160       add(XK_Pointer_Accelerate,          KeySym_Pointer_Accelerate);
01161       add(XK_Pointer_DfltBtnNext,         KeySym_Pointer_DfltBtnNext);
01162       add(XK_Pointer_DfltBtnPrev,         KeySym_Pointer_DfltBtnPrev);
01163 
01164 
01165       /*
01166        * 3270 Terminal Keys
01167        */
01168       /*
01169       add(XK_3270_Duplicate,              KeySym_3270_Duplicate);
01170       add(XK_3270_FieldMark,              KeySym_3270_FieldMark);
01171       add(XK_3270_Right2,                 KeySym_3270_Right2);
01172       add(XK_3270_Left2,                  KeySym_3270_Left2);
01173       add(XK_3270_BackTab,                KeySym_3270_BackTab);
01174       add(XK_3270_EraseEOF,               KeySym_3270_EraseEOF);
01175       add(XK_3270_EraseInput,             KeySym_3270_EraseInput);
01176       add(XK_3270_Reset,                  KeySym_3270_Reset);
01177       add(XK_3270_Quit,                   KeySym_3270_Quit);
01178       add(XK_3270_PA1,                    KeySym_3270_PA1);
01179       add(XK_3270_PA2,                    KeySym_3270_PA2);
01180       add(XK_3270_PA3,                    KeySym_3270_PA3);
01181       add(XK_3270_Test,                   KeySym_3270_Test);
01182       add(XK_3270_Attn,                   KeySym_3270_Attn);
01183       add(XK_3270_CursorBlink,            KeySym_3270_CursorBlink);
01184       add(XK_3270_AltCursor,              KeySym_3270_AltCursor);
01185       add(XK_3270_KeyClick,               KeySym_3270_KeyClick);
01186       add(XK_3270_Jump,                   KeySym_3270_Jump);
01187       add(XK_3270_Ident,                  KeySym_3270_Ident);
01188       add(XK_3270_Rule,                   KeySym_3270_Rule);
01189       add(XK_3270_Copy,                   KeySym_3270_Copy);
01190       add(XK_3270_Play,                   KeySym_3270_Play);
01191       add(XK_3270_Setup,                  KeySym_3270_Setup);
01192       add(XK_3270_Record,                 KeySym_3270_Record);
01193       add(XK_3270_ChangeScreen,           KeySym_3270_ChangeScreen);
01194       add(XK_3270_DeleteWord,             KeySym_3270_DeleteWord);
01195       add(XK_3270_ExSelect,               KeySym_3270_ExSelect);
01196       add(XK_3270_CursorSelect,           KeySym_3270_CursorSelect);
01197       add(XK_3270_PrintScreen,            KeySym_3270_PrintScreen);
01198       add(XK_3270_Enter,                  KeySym_3270_Enter);
01199       */
01200 
01201 
01202       /*
01203        *  Latin 1
01204        */
01205       add(XK_space,                       KeySym_space);
01206       add(XK_exclam,                      KeySym_exclam);
01207       add(XK_quotedbl,                    KeySym_quotedbl);
01208       add(XK_numbersign,                  KeySym_numbersign);
01209       add(XK_dollar,                      KeySym_dollar);
01210       add(XK_percent,                     KeySym_percent);
01211       add(XK_ampersand,                   KeySym_ampersand);
01212       add(XK_apostrophe,                  KeySym_apostrophe);
01213       add(XK_parenleft,                   KeySym_parenleft);
01214       add(XK_parenright,                  KeySym_parenright);
01215       add(XK_asterisk,                    KeySym_asterisk);
01216       add(XK_plus,                        KeySym_plus);
01217       add(XK_comma,                       KeySym_comma);
01218       add(XK_minus,                       KeySym_minus);
01219       add(XK_period,                      KeySym_period);
01220       add(XK_slash,                       KeySym_slash);
01221       add(XK_0,                           KeySym_0);
01222       add(XK_1,                           KeySym_1);
01223       add(XK_2,                           KeySym_2);
01224       add(XK_3,                           KeySym_3);
01225       add(XK_4,                           KeySym_4);
01226       add(XK_5,                           KeySym_5);
01227       add(XK_6,                           KeySym_6);
01228       add(XK_7,                           KeySym_7);
01229       add(XK_8,                           KeySym_8);
01230       add(XK_9,                           KeySym_9);
01231       add(XK_colon,                       KeySym_colon);
01232       add(XK_semicolon,                   KeySym_semicolon);
01233       add(XK_less,                        KeySym_less);
01234       add(XK_equal,                       KeySym_equal);
01235       add(XK_greater,                     KeySym_greater);
01236       add(XK_question,                    KeySym_question);
01237       add(XK_at,                          KeySym_at);
01238       add(XK_A,                           KeySym_A);
01239       add(XK_B,                           KeySym_B);
01240       add(XK_C,                           KeySym_C);
01241       add(XK_D,                           KeySym_D);
01242       add(XK_E,                           KeySym_E);
01243       add(XK_F,                           KeySym_F);
01244       add(XK_G,                           KeySym_G);
01245       add(XK_H,                           KeySym_H);
01246       add(XK_I,                           KeySym_I);
01247       add(XK_J,                           KeySym_J);
01248       add(XK_K,                           KeySym_K);
01249       add(XK_L,                           KeySym_L);
01250       add(XK_M,                           KeySym_M);
01251       add(XK_N,                           KeySym_N);
01252       add(XK_O,                           KeySym_O);
01253       add(XK_P,                           KeySym_P);
01254       add(XK_Q,                           KeySym_Q);
01255       add(XK_R,                           KeySym_R);
01256       add(XK_S,                           KeySym_S);
01257       add(XK_T,                           KeySym_T);
01258       add(XK_U,                           KeySym_U);
01259       add(XK_V,                           KeySym_V);
01260       add(XK_W,                           KeySym_W);
01261       add(XK_X,                           KeySym_X);
01262       add(XK_Y,                           KeySym_Y);
01263       add(XK_Z,                           KeySym_Z);
01264       add(XK_bracketleft,                 KeySym_bracketleft);
01265       add(XK_backslash,                   KeySym_backslash);
01266       add(XK_bracketright,                KeySym_bracketright);
01267       add(XK_asciicircum,                 KeySym_asciicircum);
01268       add(XK_underscore,                  KeySym_underscore);
01269       add(XK_grave,                       KeySym_grave);
01270       add(XK_a,                           KeySym_a);
01271       add(XK_b,                           KeySym_b);
01272       add(XK_c,                           KeySym_c);
01273       add(XK_d,                           KeySym_d);
01274       add(XK_e,                           KeySym_e);
01275       add(XK_f,                           KeySym_f);
01276       add(XK_g,                           KeySym_g);
01277       add(XK_h,                           KeySym_h);
01278       add(XK_i,                           KeySym_i);
01279       add(XK_j,                           KeySym_j);
01280       add(XK_k,                           KeySym_k);
01281       add(XK_l,                           KeySym_l);
01282       add(XK_m,                           KeySym_m);
01283       add(XK_n,                           KeySym_n);
01284       add(XK_o,                           KeySym_o);
01285       add(XK_p,                           KeySym_p);
01286       add(XK_q,                           KeySym_q);
01287       add(XK_r,                           KeySym_r);
01288       add(XK_s,                           KeySym_s);
01289       add(XK_t,                           KeySym_t);
01290       add(XK_u,                           KeySym_u);
01291       add(XK_v,                           KeySym_v);
01292       add(XK_w,                           KeySym_w);
01293       add(XK_x,                           KeySym_x);
01294       add(XK_y,                           KeySym_y);
01295       add(XK_z,                           KeySym_z);
01296       add(XK_braceleft,                   KeySym_braceleft);
01297       add(XK_bar,                         KeySym_bar);
01298       add(XK_braceright,                  KeySym_braceright);
01299       add(XK_asciitilde,                  KeySym_asciitilde);
01300 
01301       add(XK_nobreakspace,                KeySym_nobreakspace);
01302       add(XK_exclamdown,                  KeySym_exclamdown);
01303       add(XK_cent,                        KeySym_cent);
01304       add(XK_sterling,                    KeySym_sterling);
01305       add(XK_currency,                    KeySym_currency);
01306       add(XK_yen,                         KeySym_yen);
01307       add(XK_brokenbar,                   KeySym_brokenbar);
01308       add(XK_section,                     KeySym_section);
01309       add(XK_diaeresis,                   KeySym_diaeresis);
01310       add(XK_copyright,                   KeySym_copyright);
01311       add(XK_ordfeminine,                 KeySym_ordfeminine);
01312       add(XK_guillemotleft,               KeySym_guillemotleft);
01313       add(XK_notsign,                     KeySym_notsign);
01314       add(XK_hyphen,                      KeySym_hyphen);
01315       add(XK_registered,                  KeySym_registered);
01316       add(XK_macron,                      KeySym_macron);
01317       add(XK_degree,                      KeySym_degree);
01318       add(XK_plusminus,                   KeySym_plusminus);
01319       add(XK_twosuperior,                 KeySym_twosuperior);
01320       add(XK_threesuperior,               KeySym_threesuperior);
01321       add(XK_acute,                       KeySym_acute);
01322       add(XK_mu,                          KeySym_mu);
01323       add(XK_paragraph,                   KeySym_paragraph);
01324       add(XK_periodcentered,              KeySym_periodcentered);
01325       add(XK_cedilla,                     KeySym_cedilla);
01326       add(XK_onesuperior,                 KeySym_onesuperior);
01327       add(XK_masculine,                   KeySym_masculine);
01328       add(XK_guillemotright,              KeySym_guillemotright);
01329       add(XK_onequarter,                  KeySym_onequarter);
01330       add(XK_onehalf,                     KeySym_onehalf);
01331       add(XK_threequarters,               KeySym_threequarters);
01332       add(XK_questiondown,                KeySym_questiondown);
01333       add(XK_Agrave,                      KeySym_Agrave);
01334       add(XK_Aacute,                      KeySym_Aacute);
01335       add(XK_Acircumflex,                 KeySym_Acircumflex);
01336       add(XK_Atilde,                      KeySym_Atilde);
01337       add(XK_Adiaeresis,                  KeySym_Adiaeresis);
01338       add(XK_Aring,                       KeySym_Aring);
01339       add(XK_AE,                          KeySym_AE);
01340       add(XK_Ccedilla,                    KeySym_Ccedilla);
01341       add(XK_Egrave,                      KeySym_Egrave);
01342       add(XK_Eacute,                      KeySym_Eacute);
01343       add(XK_Ecircumflex,                 KeySym_Ecircumflex);
01344       add(XK_Ediaeresis,                  KeySym_Ediaeresis);
01345       add(XK_Igrave,                      KeySym_Igrave);
01346       add(XK_Iacute,                      KeySym_Iacute);
01347       add(XK_Icircumflex,                 KeySym_Icircumflex);
01348       add(XK_Idiaeresis,                  KeySym_Idiaeresis);
01349       add(XK_ETH,                         KeySym_ETH);
01350       add(XK_Ntilde,                      KeySym_Ntilde);
01351       add(XK_Ograve,                      KeySym_Ograve);
01352       add(XK_Oacute,                      KeySym_Oacute);
01353       add(XK_Ocircumflex,                 KeySym_Ocircumflex);
01354       add(XK_Otilde,                      KeySym_Otilde);
01355       add(XK_Odiaeresis,                  KeySym_Odiaeresis);
01356       add(XK_multiply,                    KeySym_multiply);
01357       add(XK_Ooblique,                    KeySym_Ooblique);
01358       add(XK_Ugrave,                      KeySym_Ugrave);
01359       add(XK_Uacute,                      KeySym_Uacute);
01360       add(XK_Ucircumflex,                 KeySym_Ucircumflex);
01361       add(XK_Udiaeresis,                  KeySym_Udiaeresis);
01362       add(XK_Yacute,                      KeySym_Yacute);
01363       add(XK_THORN,                       KeySym_THORN);
01364       add(XK_ssharp,                      KeySym_ssharp);
01365       add(XK_agrave,                      KeySym_agrave);
01366       add(XK_aacute,                      KeySym_aacute);
01367       add(XK_acircumflex,                 KeySym_acircumflex);
01368       add(XK_atilde,                      KeySym_atilde);
01369       add(XK_adiaeresis,                  KeySym_adiaeresis);
01370       add(XK_aring,                       KeySym_aring);
01371       add(XK_ae,                          KeySym_ae);
01372       add(XK_ccedilla,                    KeySym_ccedilla);
01373       add(XK_egrave,                      KeySym_egrave);
01374       add(XK_eacute,                      KeySym_eacute);
01375       add(XK_ecircumflex,                 KeySym_ecircumflex);
01376       add(XK_ediaeresis,                  KeySym_ediaeresis);
01377       add(XK_igrave,                      KeySym_igrave);
01378       add(XK_iacute,                      KeySym_iacute);
01379       add(XK_icircumflex,                 KeySym_icircumflex);
01380       add(XK_idiaeresis,                  KeySym_idiaeresis);
01381       add(XK_eth,                         KeySym_eth);
01382       add(XK_ntilde,                      KeySym_ntilde);
01383       add(XK_ograve,                      KeySym_ograve);
01384       add(XK_oacute,                      KeySym_oacute);
01385       add(XK_ocircumflex,                 KeySym_ocircumflex);
01386       add(XK_otilde,                      KeySym_otilde);
01387       add(XK_odiaeresis,                  KeySym_odiaeresis);
01388       add(XK_division,                    KeySym_division);
01389       add(XK_ooblique,                    KeySym_ooblique);
01390       add(XK_ugrave,                      KeySym_ugrave);
01391       add(XK_uacute,                      KeySym_uacute);
01392       add(XK_ucircumflex,                 KeySym_ucircumflex);
01393       add(XK_udiaeresis,                  KeySym_udiaeresis);
01394       add(XK_yacute,                      KeySym_yacute);
01395       add(XK_thorn,                       KeySym_thorn);
01396       add(XK_ydiaeresis,                  KeySym_ydiaeresis);
01397 
01398 
01399       /*
01400        *   Latin 2
01401        */
01402       add(XK_Aogonek,                     KeySym_Aogonek);
01403       add(XK_breve,                       KeySym_breve);
01404       add(XK_Lstroke,                     KeySym_Lstroke);
01405       add(XK_Lcaron,                      KeySym_Lcaron);
01406       add(XK_Sacute,                      KeySym_Sacute);
01407       add(XK_Scaron,                      KeySym_Scaron);
01408       add(XK_Scedilla,                    KeySym_Scedilla);
01409       add(XK_Tcaron,                      KeySym_Tcaron);
01410       add(XK_Zacute,                      KeySym_Zacute);
01411       add(XK_Zcaron,                      KeySym_Zcaron);
01412       add(XK_Zabovedot,                   KeySym_Zabovedot);
01413       add(XK_aogonek,                     KeySym_aogonek);
01414       add(XK_ogonek,                      KeySym_ogonek);
01415       add(XK_lstroke,                     KeySym_lstroke);
01416       add(XK_lcaron,                      KeySym_lcaron);
01417       add(XK_sacute,                      KeySym_sacute);
01418       add(XK_caron,                       KeySym_caron);
01419       add(XK_scaron,                      KeySym_scaron);
01420       add(XK_scedilla,                    KeySym_scedilla);
01421       add(XK_tcaron,                      KeySym_tcaron);
01422       add(XK_zacute,                      KeySym_zacute);
01423       add(XK_doubleacute,                 KeySym_doubleacute);
01424       add(XK_zcaron,                      KeySym_zcaron);
01425       add(XK_zabovedot,                   KeySym_zabovedot);
01426       add(XK_Racute,                      KeySym_Racute);
01427       add(XK_Abreve,                      KeySym_Abreve);
01428       add(XK_Lacute,                      KeySym_Lacute);
01429       add(XK_Cacute,                      KeySym_Cacute);
01430       add(XK_Ccaron,                      KeySym_Ccaron);
01431       add(XK_Eogonek,                     KeySym_Eogonek);
01432       add(XK_Ecaron,                      KeySym_Ecaron);
01433       add(XK_Dcaron,                      KeySym_Dcaron);
01434       add(XK_Dstroke,                     KeySym_Dstroke);
01435       add(XK_Nacute,                      KeySym_Nacute);
01436       add(XK_Ncaron,                      KeySym_Ncaron);
01437       add(XK_Odoubleacute,                KeySym_Odoubleacute);
01438       add(XK_Rcaron,                      KeySym_Rcaron);
01439       add(XK_Uring,                       KeySym_Uring);
01440       add(XK_Udoubleacute,                KeySym_Udoubleacute);
01441       add(XK_Tcedilla,                    KeySym_Tcedilla);
01442       add(XK_racute,                      KeySym_racute);
01443       add(XK_abreve,                      KeySym_abreve);
01444       add(XK_lacute,                      KeySym_lacute);
01445       add(XK_cacute,                      KeySym_cacute);
01446       add(XK_ccaron,                      KeySym_ccaron);
01447       add(XK_eogonek,                     KeySym_eogonek);
01448       add(XK_ecaron,                      KeySym_ecaron);
01449       add(XK_dcaron,                      KeySym_dcaron);
01450       add(XK_dstroke,                     KeySym_dstroke);
01451       add(XK_nacute,                      KeySym_nacute);
01452       add(XK_ncaron,                      KeySym_ncaron);
01453       add(XK_odoubleacute,                KeySym_odoubleacute);
01454       add(XK_udoubleacute,                KeySym_udoubleacute);
01455       add(XK_rcaron,                      KeySym_rcaron);
01456       add(XK_uring,                       KeySym_uring);
01457       add(XK_tcedilla,                    KeySym_tcedilla);
01458       add(XK_abovedot,                    KeySym_abovedot);
01459 
01460 
01461       /*
01462        *   Latin 3
01463        */
01464       add(XK_Hstroke,                     KeySym_Hstroke);
01465       add(XK_Hcircumflex,                 KeySym_Hcircumflex);
01466       add(XK_Iabovedot,                   KeySym_Iabovedot);
01467       add(XK_Gbreve,                      KeySym_Gbreve);
01468       add(XK_Jcircumflex,                 KeySym_Jcircumflex);
01469       add(XK_hstroke,                     KeySym_hstroke);
01470       add(XK_hcircumflex,                 KeySym_hcircumflex);
01471       add(XK_idotless,                    KeySym_idotless);
01472       add(XK_gbreve,                      KeySym_gbreve);
01473       add(XK_jcircumflex,                 KeySym_jcircumflex);
01474       add(XK_Cabovedot,                   KeySym_Cabovedot);
01475       add(XK_Ccircumflex,                 KeySym_Ccircumflex);
01476       add(XK_Gabovedot,                   KeySym_Gabovedot);
01477       add(XK_Gcircumflex,                 KeySym_Gcircumflex);
01478       add(XK_Ubreve,                      KeySym_Ubreve);
01479       add(XK_Scircumflex,                 KeySym_Scircumflex);
01480       add(XK_cabovedot,                   KeySym_cabovedot);
01481       add(XK_ccircumflex,                 KeySym_ccircumflex);
01482       add(XK_gabovedot,                   KeySym_gabovedot);
01483       add(XK_gcircumflex,                 KeySym_gcircumflex);
01484       add(XK_ubreve,                      KeySym_ubreve);
01485       add(XK_scircumflex,                 KeySym_scircumflex);
01486 
01487 
01488       /*
01489        *   Latin 4
01490        */
01491       add(XK_kra,                         KeySym_kra);
01492       add(XK_Rcedilla,                    KeySym_Rcedilla);
01493       add(XK_Itilde,                      KeySym_Itilde);
01494       add(XK_Lcedilla,                    KeySym_Lcedilla);
01495       add(XK_Emacron,                     KeySym_Emacron);
01496       add(XK_Gcedilla,                    KeySym_Gcedilla);
01497       add(XK_Tslash,                      KeySym_Tslash);
01498       add(XK_rcedilla,                    KeySym_rcedilla);
01499       add(XK_itilde,                      KeySym_itilde);
01500       add(XK_lcedilla,                    KeySym_lcedilla);
01501       add(XK_emacron,                     KeySym_emacron);
01502       add(XK_gcedilla,                    KeySym_gcedilla);
01503       add(XK_tslash,                      KeySym_tslash);
01504       add(XK_ENG,                         KeySym_ENG);
01505       add(XK_eng,                         KeySym_eng);
01506       add(XK_Amacron,                     KeySym_Amacron);
01507       add(XK_Iogonek,                     KeySym_Iogonek);
01508       add(XK_Eabovedot,                   KeySym_Eabovedot);
01509       add(XK_Imacron,                     KeySym_Imacron);
01510       add(XK_Ncedilla,                    KeySym_Ncedilla);
01511       add(XK_Omacron,                     KeySym_Omacron);
01512       add(XK_Kcedilla,                    KeySym_Kcedilla);
01513       add(XK_Uogonek,                     KeySym_Uogonek);
01514       add(XK_Utilde,                      KeySym_Utilde);
01515       add(XK_Umacron,                     KeySym_Umacron);
01516       add(XK_amacron,                     KeySym_amacron);
01517       add(XK_iogonek,                     KeySym_iogonek);
01518       add(XK_eabovedot,                   KeySym_eabovedot);
01519       add(XK_imacron,                     KeySym_imacron);
01520       add(XK_ncedilla,                    KeySym_ncedilla);
01521       add(XK_omacron,                     KeySym_omacron);
01522       add(XK_kcedilla,                    KeySym_kcedilla);
01523       add(XK_uogonek,                     KeySym_uogonek);
01524       add(XK_utilde,                      KeySym_utilde);
01525       add(XK_umacron,                     KeySym_umacron);
01526 
01527 
01528       /*
01529        * Latin-8
01530        */
01531       add(XK_Babovedot,                   KeySym_Babovedot);
01532       add(XK_babovedot,                   KeySym_babovedot);
01533       add(XK_Dabovedot,                   KeySym_Dabovedot);
01534       add(XK_Wgrave,                      KeySym_Wgrave);
01535       add(XK_Wacute,                      KeySym_Wacute);
01536       add(XK_dabovedot,                   KeySym_dabovedot);
01537       add(XK_Ygrave,                      KeySym_Ygrave);
01538       add(XK_Fabovedot,                   KeySym_Fabovedot);
01539       add(XK_fabovedot,                   KeySym_fabovedot);
01540       add(XK_Mabovedot,                   KeySym_Mabovedot);
01541       add(XK_mabovedot,                   KeySym_mabovedot);
01542       add(XK_Pabovedot,                   KeySym_Pabovedot);
01543       add(XK_wgrave,                      KeySym_wgrave);
01544       add(XK_pabovedot,                   KeySym_pabovedot);
01545       add(XK_wacute,                      KeySym_wacute);
01546       add(XK_Sabovedot,                   KeySym_Sabovedot);
01547       add(XK_ygrave,                      KeySym_ygrave);
01548       add(XK_Wdiaeresis,                  KeySym_Wdiaeresis);
01549       add(XK_wdiaeresis,                  KeySym_wdiaeresis);
01550       add(XK_sabovedot,                   KeySym_sabovedot);
01551       add(XK_Wcircumflex,                 KeySym_Wcircumflex);
01552       add(XK_Tabovedot,                   KeySym_Tabovedot);
01553       add(XK_Ycircumflex,                 KeySym_Ycircumflex);
01554       add(XK_wcircumflex,                 KeySym_wcircumflex);
01555       add(XK_tabovedot,                   KeySym_tabovedot);
01556       add(XK_ycircumflex,                 KeySym_ycircumflex);
01557 
01558 
01559       /*
01560        * Latin-9 (a.k.a. Latin-0)
01561        */
01562       add(XK_OE,                          KeySym_OE);
01563       add(XK_oe,                          KeySym_oe);
01564       add(XK_Ydiaeresis,                  KeySym_Ydiaeresis);
01565 
01566 
01567       /*
01568        * Katakana
01569        */
01570       add(XK_overline,                    KeySym_overline);
01571       add(XK_kana_fullstop,               KeySym_kana_fullstop);
01572       add(XK_kana_openingbracket,         KeySym_kana_openingbracket);
01573       add(XK_kana_closingbracket,         KeySym_kana_closingbracket);
01574       add(XK_kana_comma,                  KeySym_kana_comma);
01575       add(XK_kana_conjunctive,            KeySym_kana_conjunctive);
01576       add(XK_kana_WO,                     KeySym_kana_WO);
01577       add(XK_kana_a,                      KeySym_kana_a);
01578       add(XK_kana_i,                      KeySym_kana_i);
01579       add(XK_kana_u,                      KeySym_kana_u);
01580       add(XK_kana_e,                      KeySym_kana_e);
01581       add(XK_kana_o,                      KeySym_kana_o);
01582       add(XK_kana_ya,                     KeySym_kana_ya);
01583       add(XK_kana_yu,                     KeySym_kana_yu);
01584       add(XK_kana_yo,                     KeySym_kana_yo);
01585       add(XK_kana_tsu,                    KeySym_kana_tsu);
01586       add(XK_prolongedsound,              KeySym_prolongedsound);
01587       add(XK_kana_A,                      KeySym_kana_A);
01588       add(XK_kana_I,                      KeySym_kana_I);
01589       add(XK_kana_U,                      KeySym_kana_U);
01590       add(XK_kana_E,                      KeySym_kana_E);
01591       add(XK_kana_O,                      KeySym_kana_O);
01592       add(XK_kana_KA,                     KeySym_kana_KA);
01593       add(XK_kana_KI,                     KeySym_kana_KI);
01594       add(XK_kana_KU,                     KeySym_kana_KU);
01595       add(XK_kana_KE,                     KeySym_kana_KE);
01596       add(XK_kana_KO,                     KeySym_kana_KO);
01597       add(XK_kana_SA,                     KeySym_kana_SA);
01598       add(XK_kana_SHI,                    KeySym_kana_SHI);
01599       add(XK_kana_SU,                     KeySym_kana_SU);
01600       add(XK_kana_SE,                     KeySym_kana_SE);
01601       add(XK_kana_SO,                     KeySym_kana_SO);
01602       add(XK_kana_TA,                     KeySym_kana_TA);
01603       add(XK_kana_CHI,                    KeySym_kana_CHI);
01604       add(XK_kana_TSU,                    KeySym_kana_TSU);
01605       add(XK_kana_TE,                     KeySym_kana_TE);
01606       add(XK_kana_TO,                     KeySym_kana_TO);
01607       add(XK_kana_NA,                     KeySym_kana_NA);
01608       add(XK_kana_NI,                     KeySym_kana_NI);
01609       add(XK_kana_NU,                     KeySym_kana_NU);
01610       add(XK_kana_NE,                     KeySym_kana_NE);
01611       add(XK_kana_NO,                     KeySym_kana_NO);
01612       add(XK_kana_HA,                     KeySym_kana_HA);
01613       add(XK_kana_HI,                     KeySym_kana_HI);
01614       add(XK_kana_FU,                     KeySym_kana_FU);
01615       add(XK_kana_HE,                     KeySym_kana_HE);
01616       add(XK_kana_HO,                     KeySym_kana_HO);
01617       add(XK_kana_MA,                     KeySym_kana_MA);
01618       add(XK_kana_MI,                     KeySym_kana_MI);
01619       add(XK_kana_MU,                     KeySym_kana_MU);
01620       add(XK_kana_ME,                     KeySym_kana_ME);
01621       add(XK_kana_MO,                     KeySym_kana_MO);
01622       add(XK_kana_YA,                     KeySym_kana_YA);
01623       add(XK_kana_YU,                     KeySym_kana_YU);
01624       add(XK_kana_YO,                     KeySym_kana_YO);
01625       add(XK_kana_RA,                     KeySym_kana_RA);
01626       add(XK_kana_RI,                     KeySym_kana_RI);
01627       add(XK_kana_RU,                     KeySym_kana_RU);
01628       add(XK_kana_RE,                     KeySym_kana_RE);
01629       add(XK_kana_RO,                     KeySym_kana_RO);
01630       add(XK_kana_WA,                     KeySym_kana_WA);
01631       add(XK_kana_N,                      KeySym_kana_N);
01632       add(XK_voicedsound,                 KeySym_voicedsound);
01633       add(XK_semivoicedsound,             KeySym_semivoicedsound);
01634 
01635 
01636       /*
01637        *  Arabic
01638        */
01639       add(XK_Farsi_0,                     KeySym_Farsi_0);
01640       add(XK_Farsi_1,                     KeySym_Farsi_1);
01641       add(XK_Farsi_2,                     KeySym_Farsi_2);
01642       add(XK_Farsi_3,                     KeySym_Farsi_3);
01643       add(XK_Farsi_4,                     KeySym_Farsi_4);
01644       add(XK_Farsi_5,                     KeySym_Farsi_5);
01645       add(XK_Farsi_6,                     KeySym_Farsi_6);
01646       add(XK_Farsi_7,                     KeySym_Farsi_7);
01647       add(XK_Farsi_8,                     KeySym_Farsi_8);
01648       add(XK_Farsi_9,                     KeySym_Farsi_9);
01649       add(XK_Arabic_percent,              KeySym_Arabic_percent);
01650       add(XK_Arabic_superscript_alef,     KeySym_Arabic_superscript_alef);
01651       add(XK_Arabic_tteh,                 KeySym_Arabic_tteh);
01652       add(XK_Arabic_peh,                  KeySym_Arabic_peh);
01653       add(XK_Arabic_tcheh,                KeySym_Arabic_tcheh);
01654       add(XK_Arabic_ddal,                 KeySym_Arabic_ddal);
01655       add(XK_Arabic_rreh,                 KeySym_Arabic_rreh);
01656       add(XK_Arabic_comma,                KeySym_Arabic_comma);
01657       add(XK_Arabic_fullstop,             KeySym_Arabic_fullstop);
01658       add(XK_Arabic_0,                    KeySym_Arabic_0);
01659       add(XK_Arabic_1,                    KeySym_Arabic_1);
01660       add(XK_Arabic_2,                    KeySym_Arabic_2);
01661       add(XK_Arabic_3,                    KeySym_Arabic_3);
01662       add(XK_Arabic_4,                    KeySym_Arabic_4);
01663       add(XK_Arabic_5,                    KeySym_Arabic_5);
01664       add(XK_Arabic_6,                    KeySym_Arabic_6);
01665       add(XK_Arabic_7,                    KeySym_Arabic_7);
01666       add(XK_Arabic_8,                    KeySym_Arabic_8);
01667       add(XK_Arabic_9,                    KeySym_Arabic_9);
01668       add(XK_Arabic_semicolon,            KeySym_Arabic_semicolon);
01669       add(XK_Arabic_question_mark,        KeySym_Arabic_question_mark);
01670       add(XK_Arabic_hamza,                KeySym_Arabic_hamza);
01671       add(XK_Arabic_maddaonalef,          KeySym_Arabic_maddaonalef);
01672       add(XK_Arabic_hamzaonalef,          KeySym_Arabic_hamzaonalef);
01673       add(XK_Arabic_hamzaonwaw,           KeySym_Arabic_hamzaonwaw);
01674       add(XK_Arabic_hamzaunderalef,       KeySym_Arabic_hamzaunderalef);
01675       add(XK_Arabic_hamzaonyeh,           KeySym_Arabic_hamzaonyeh);
01676       add(XK_Arabic_alef,                 KeySym_Arabic_alef);
01677       add(XK_Arabic_beh,                  KeySym_Arabic_beh);
01678       add(XK_Arabic_tehmarbuta,           KeySym_Arabic_tehmarbuta);
01679       add(XK_Arabic_teh,                  KeySym_Arabic_teh);
01680       add(XK_Arabic_theh,                 KeySym_Arabic_theh);
01681       add(XK_Arabic_jeem,                 KeySym_Arabic_jeem);
01682       add(XK_Arabic_hah,                  KeySym_Arabic_hah);
01683       add(XK_Arabic_khah,                 KeySym_Arabic_khah);
01684       add(XK_Arabic_dal,                  KeySym_Arabic_dal);
01685       add(XK_Arabic_thal,                 KeySym_Arabic_thal);
01686       add(XK_Arabic_ra,                   KeySym_Arabic_ra);
01687       add(XK_Arabic_zain,                 KeySym_Arabic_zain);
01688       add(XK_Arabic_seen,                 KeySym_Arabic_seen);
01689       add(XK_Arabic_sheen,                KeySym_Arabic_sheen);
01690       add(XK_Arabic_sad,                  KeySym_Arabic_sad);
01691       add(XK_Arabic_dad,                  KeySym_Arabic_dad);
01692       add(XK_Arabic_tah,                  KeySym_Arabic_tah);
01693       add(XK_Arabic_zah,                  KeySym_Arabic_zah);
01694       add(XK_Arabic_ain,                  KeySym_Arabic_ain);
01695       add(XK_Arabic_ghain,                KeySym_Arabic_ghain);
01696       add(XK_Arabic_tatweel,              KeySym_Arabic_tatweel);
01697       add(XK_Arabic_feh,                  KeySym_Arabic_feh);
01698       add(XK_Arabic_qaf,                  KeySym_Arabic_qaf);
01699       add(XK_Arabic_kaf,                  KeySym_Arabic_kaf);
01700       add(XK_Arabic_lam,                  KeySym_Arabic_lam);
01701       add(XK_Arabic_meem,                 KeySym_Arabic_meem);
01702       add(XK_Arabic_noon,                 KeySym_Arabic_noon);
01703       add(XK_Arabic_ha,                   KeySym_Arabic_ha);
01704       add(XK_Arabic_waw,                  KeySym_Arabic_waw);
01705       add(XK_Arabic_alefmaksura,          KeySym_Arabic_alefmaksura);
01706       add(XK_Arabic_yeh,                  KeySym_Arabic_yeh);
01707       add(XK_Arabic_fathatan,             KeySym_Arabic_fathatan);
01708       add(XK_Arabic_dammatan,             KeySym_Arabic_dammatan);
01709       add(XK_Arabic_kasratan,             KeySym_Arabic_kasratan);
01710       add(XK_Arabic_fatha,                KeySym_Arabic_fatha);
01711       add(XK_Arabic_damma,                KeySym_Arabic_damma);
01712       add(XK_Arabic_kasra,                KeySym_Arabic_kasra);
01713       add(XK_Arabic_shadda,               KeySym_Arabic_shadda);
01714       add(XK_Arabic_sukun,                KeySym_Arabic_sukun);
01715       add(XK_Arabic_madda_above,          KeySym_Arabic_madda_above);
01716       add(XK_Arabic_hamza_above,          KeySym_Arabic_hamza_above);
01717       add(XK_Arabic_hamza_below,          KeySym_Arabic_hamza_below);
01718       add(XK_Arabic_jeh,                  KeySym_Arabic_jeh);
01719       add(XK_Arabic_veh,                  KeySym_Arabic_veh);
01720       add(XK_Arabic_keheh,                KeySym_Arabic_keheh);
01721       add(XK_Arabic_gaf,                  KeySym_Arabic_gaf);
01722       add(XK_Arabic_noon_ghunna,          KeySym_Arabic_noon_ghunna);
01723       add(XK_Arabic_heh_doachashmee,      KeySym_Arabic_heh_doachashmee);
01724       add(XK_Farsi_yeh,                   KeySym_Farsi_yeh);
01725       add(XK_Arabic_yeh_baree,            KeySym_Arabic_yeh_baree);
01726       add(XK_Arabic_heh_goal,             KeySym_Arabic_heh_goal);
01727 
01728 
01729       /*
01730        * Cyrillic
01731         */
01732       add(XK_Cyrillic_GHE_bar,            KeySym_Cyrillic_GHE_bar);
01733       add(XK_Cyrillic_ghe_bar,            KeySym_Cyrillic_ghe_bar);
01734       add(XK_Cyrillic_ZHE_descender,      KeySym_Cyrillic_ZHE_descender);
01735       add(XK_Cyrillic_zhe_descender,      KeySym_Cyrillic_zhe_descender);
01736       add(XK_Cyrillic_KA_descender,       KeySym_Cyrillic_KA_descender);
01737       add(XK_Cyrillic_ka_descender,       KeySym_Cyrillic_ka_descender);
01738       add(XK_Cyrillic_KA_vertstroke,      KeySym_Cyrillic_KA_vertstroke);
01739       add(XK_Cyrillic_ka_vertstroke,      KeySym_Cyrillic_ka_vertstroke);
01740       add(XK_Cyrillic_EN_descender,       KeySym_Cyrillic_EN_descender);
01741       add(XK_Cyrillic_en_descender,       KeySym_Cyrillic_en_descender);
01742       add(XK_Cyrillic_U_straight,         KeySym_Cyrillic_U_straight);
01743       add(XK_Cyrillic_u_straight,         KeySym_Cyrillic_u_straight);
01744       add(XK_Cyrillic_U_straight_bar,     KeySym_Cyrillic_U_straight_bar);
01745       add(XK_Cyrillic_u_straight_bar,     KeySym_Cyrillic_u_straight_bar);
01746       add(XK_Cyrillic_HA_descender,       KeySym_Cyrillic_HA_descender);
01747       add(XK_Cyrillic_ha_descender,       KeySym_Cyrillic_ha_descender);
01748       add(XK_Cyrillic_CHE_descender,      KeySym_Cyrillic_CHE_descender);
01749       add(XK_Cyrillic_che_descender,      KeySym_Cyrillic_che_descender);
01750       add(XK_Cyrillic_CHE_vertstroke,     KeySym_Cyrillic_CHE_vertstroke);
01751       add(XK_Cyrillic_che_vertstroke,     KeySym_Cyrillic_che_vertstroke);
01752       add(XK_Cyrillic_SHHA,               KeySym_Cyrillic_SHHA);
01753       add(XK_Cyrillic_shha,               KeySym_Cyrillic_shha);
01754 
01755       add(XK_Cyrillic_SCHWA,              KeySym_Cyrillic_SCHWA);
01756       add(XK_Cyrillic_schwa,              KeySym_Cyrillic_schwa);
01757       add(XK_Cyrillic_I_macron,           KeySym_Cyrillic_I_macron);
01758       add(XK_Cyrillic_i_macron,           KeySym_Cyrillic_i_macron);
01759       add(XK_Cyrillic_O_bar,              KeySym_Cyrillic_O_bar);
01760       add(XK_Cyrillic_o_bar,              KeySym_Cyrillic_o_bar);
01761       add(XK_Cyrillic_U_macron,           KeySym_Cyrillic_U_macron);
01762       add(XK_Cyrillic_u_macron,           KeySym_Cyrillic_u_macron);
01763 
01764       add(XK_Serbian_dje,                 KeySym_Serbian_dje);
01765       add(XK_Macedonia_gje,               KeySym_Macedonia_gje);
01766       add(XK_Cyrillic_io,                 KeySym_Cyrillic_io);
01767       add(XK_Ukrainian_ie,                KeySym_Ukrainian_ie);
01768       add(XK_Macedonia_dse,               KeySym_Macedonia_dse);
01769       add(XK_Ukrainian_i,                 KeySym_Ukrainian_i);
01770       add(XK_Ukrainian_yi,                KeySym_Ukrainian_yi);
01771       add(XK_Cyrillic_je,                 KeySym_Cyrillic_je);
01772       add(XK_Cyrillic_lje,                KeySym_Cyrillic_lje);
01773       add(XK_Cyrillic_nje,                KeySym_Cyrillic_nje);
01774       add(XK_Serbian_tshe,                KeySym_Serbian_tshe);
01775       add(XK_Macedonia_kje,               KeySym_Macedonia_kje);
01776       add(XK_Ukrainian_ghe_with_upturn,   KeySym_Ukrainian_ghe_with_upturn);
01777       add(XK_Byelorussian_shortu,         KeySym_Byelorussian_shortu);
01778       add(XK_Cyrillic_dzhe,               KeySym_Cyrillic_dzhe);
01779       add(XK_numerosign,                  KeySym_numerosign);
01780       add(XK_Serbian_DJE,                 KeySym_Serbian_DJE);
01781       add(XK_Macedonia_GJE,               KeySym_Macedonia_GJE);
01782       add(XK_Cyrillic_IO,                 KeySym_Cyrillic_IO);
01783       add(XK_Ukrainian_IE,                KeySym_Ukrainian_IE);
01784       add(XK_Macedonia_DSE,               KeySym_Macedonia_DSE);
01785       add(XK_Ukrainian_I,                 KeySym_Ukrainian_I);
01786       add(XK_Ukrainian_YI,                KeySym_Ukrainian_YI);
01787       add(XK_Cyrillic_JE,                 KeySym_Cyrillic_JE);
01788       add(XK_Cyrillic_LJE,                KeySym_Cyrillic_LJE);
01789       add(XK_Cyrillic_NJE,                KeySym_Cyrillic_NJE);
01790       add(XK_Serbian_TSHE,                KeySym_Serbian_TSHE);
01791       add(XK_Macedonia_KJE,               KeySym_Macedonia_KJE);
01792       add(XK_Ukrainian_GHE_WITH_UPTURN,   KeySym_Ukrainian_GHE_WITH_UPTURN);
01793       add(XK_Byelorussian_SHORTU,         KeySym_Byelorussian_SHORTU);
01794       add(XK_Cyrillic_DZHE,               KeySym_Cyrillic_DZHE);
01795       add(XK_Cyrillic_yu,                 KeySym_Cyrillic_yu);
01796       add(XK_Cyrillic_a,                  KeySym_Cyrillic_a);
01797       add(XK_Cyrillic_be,                 KeySym_Cyrillic_be);
01798       add(XK_Cyrillic_tse,                KeySym_Cyrillic_tse);
01799       add(XK_Cyrillic_de,                 KeySym_Cyrillic_de);
01800       add(XK_Cyrillic_ie,                 KeySym_Cyrillic_ie);
01801       add(XK_Cyrillic_ef,                 KeySym_Cyrillic_ef);
01802       add(XK_Cyrillic_ghe,                KeySym_Cyrillic_ghe);
01803       add(XK_Cyrillic_ha,                 KeySym_Cyrillic_ha);
01804       add(XK_Cyrillic_i,                  KeySym_Cyrillic_i);
01805       add(XK_Cyrillic_shorti,             KeySym_Cyrillic_shorti);
01806       add(XK_Cyrillic_ka,                 KeySym_Cyrillic_ka);
01807       add(XK_Cyrillic_el,                 KeySym_Cyrillic_el);
01808       add(XK_Cyrillic_em,                 KeySym_Cyrillic_em);
01809       add(XK_Cyrillic_en,                 KeySym_Cyrillic_en);
01810       add(XK_Cyrillic_o,                  KeySym_Cyrillic_o);
01811       add(XK_Cyrillic_pe,                 KeySym_Cyrillic_pe);
01812       add(XK_Cyrillic_ya,                 KeySym_Cyrillic_ya);
01813       add(XK_Cyrillic_er,                 KeySym_Cyrillic_er);
01814       add(XK_Cyrillic_es,                 KeySym_Cyrillic_es);
01815       add(XK_Cyrillic_te,                 KeySym_Cyrillic_te);
01816       add(XK_Cyrillic_u,                  KeySym_Cyrillic_u);
01817       add(XK_Cyrillic_zhe,                KeySym_Cyrillic_zhe);
01818       add(XK_Cyrillic_ve,                 KeySym_Cyrillic_ve);
01819       add(XK_Cyrillic_softsign,           KeySym_Cyrillic_softsign);
01820       add(XK_Cyrillic_yeru,               KeySym_Cyrillic_yeru);
01821       add(XK_Cyrillic_ze,                 KeySym_Cyrillic_ze);
01822       add(XK_Cyrillic_sha,                KeySym_Cyrillic_sha);
01823       add(XK_Cyrillic_e,                  KeySym_Cyrillic_e);
01824       add(XK_Cyrillic_shcha,              KeySym_Cyrillic_shcha);
01825       add(XK_Cyrillic_che,                KeySym_Cyrillic_che);
01826       add(XK_Cyrillic_hardsign,           KeySym_Cyrillic_hardsign);
01827       add(XK_Cyrillic_YU,                 KeySym_Cyrillic_YU);
01828       add(XK_Cyrillic_A,                  KeySym_Cyrillic_A);
01829       add(XK_Cyrillic_BE,                 KeySym_Cyrillic_BE);
01830       add(XK_Cyrillic_TSE,                KeySym_Cyrillic_TSE);
01831       add(XK_Cyrillic_DE,                 KeySym_Cyrillic_DE);
01832       add(XK_Cyrillic_IE,                 KeySym_Cyrillic_IE);
01833       add(XK_Cyrillic_EF,                 KeySym_Cyrillic_EF);
01834       add(XK_Cyrillic_GHE,                KeySym_Cyrillic_GHE);
01835       add(XK_Cyrillic_HA,                 KeySym_Cyrillic_HA);
01836       add(XK_Cyrillic_I,                  KeySym_Cyrillic_I);
01837       add(XK_Cyrillic_SHORTI,             KeySym_Cyrillic_SHORTI);
01838       add(XK_Cyrillic_KA,                 KeySym_Cyrillic_KA);
01839       add(XK_Cyrillic_EL,                 KeySym_Cyrillic_EL);
01840       add(XK_Cyrillic_EM,                 KeySym_Cyrillic_EM);
01841       add(XK_Cyrillic_EN,                 KeySym_Cyrillic_EN);
01842       add(XK_Cyrillic_O,                  KeySym_Cyrillic_O);
01843       add(XK_Cyrillic_PE,                 KeySym_Cyrillic_PE);
01844       add(XK_Cyrillic_YA,                 KeySym_Cyrillic_YA);
01845       add(XK_Cyrillic_ER,                 KeySym_Cyrillic_ER);
01846       add(XK_Cyrillic_ES,                 KeySym_Cyrillic_ES);
01847       add(XK_Cyrillic_TE,                 KeySym_Cyrillic_TE);
01848       add(XK_Cyrillic_U,                  KeySym_Cyrillic_U);
01849       add(XK_Cyrillic_ZHE,                KeySym_Cyrillic_ZHE);
01850       add(XK_Cyrillic_VE,                 KeySym_Cyrillic_VE);
01851       add(XK_Cyrillic_SOFTSIGN,           KeySym_Cyrillic_SOFTSIGN);
01852       add(XK_Cyrillic_YERU,               KeySym_Cyrillic_YERU);
01853       add(XK_Cyrillic_ZE,                 KeySym_Cyrillic_ZE);
01854       add(XK_Cyrillic_SHA,                KeySym_Cyrillic_SHA);
01855       add(XK_Cyrillic_E,                  KeySym_Cyrillic_E);
01856       add(XK_Cyrillic_SHCHA,              KeySym_Cyrillic_SHCHA);
01857       add(XK_Cyrillic_CHE,                KeySym_Cyrillic_CHE);
01858       add(XK_Cyrillic_HARDSIGN,           KeySym_Cyrillic_HARDSIGN);
01859 
01860 
01861       /*
01862        * Greek
01863        */
01864       add(XK_Greek_ALPHAaccent,           KeySym_Greek_ALPHAaccent);
01865       add(XK_Greek_EPSILONaccent,         KeySym_Greek_EPSILONaccent);
01866       add(XK_Greek_ETAaccent,             KeySym_Greek_ETAaccent);
01867       add(XK_Greek_IOTAaccent,            KeySym_Greek_IOTAaccent);
01868       add(XK_Greek_IOTAdieresis,          KeySym_Greek_IOTAdieresis);
01869       add(XK_Greek_OMICRONaccent,         KeySym_Greek_OMICRONaccent);
01870       add(XK_Greek_UPSILONaccent,         KeySym_Greek_UPSILONaccent);
01871       add(XK_Greek_UPSILONdieresis,       KeySym_Greek_UPSILONdieresis);
01872       add(XK_Greek_OMEGAaccent,           KeySym_Greek_OMEGAaccent);
01873       add(XK_Greek_accentdieresis,        KeySym_Greek_accentdieresis);
01874       add(XK_Greek_horizbar,              KeySym_Greek_horizbar);
01875       add(XK_Greek_alphaaccent,           KeySym_Greek_alphaaccent);
01876       add(XK_Greek_epsilonaccent,         KeySym_Greek_epsilonaccent);
01877       add(XK_Greek_etaaccent,             KeySym_Greek_etaaccent);
01878       add(XK_Greek_iotaaccent,            KeySym_Greek_iotaaccent);
01879       add(XK_Greek_iotadieresis,          KeySym_Greek_iotadieresis);
01880       add(XK_Greek_iotaaccentdieresis,    KeySym_Greek_iotaaccentdieresis);
01881       add(XK_Greek_omicronaccent,         KeySym_Greek_omicronaccent);
01882       add(XK_Greek_upsilonaccent,         KeySym_Greek_upsilonaccent);
01883       add(XK_Greek_upsilondieresis,       KeySym_Greek_upsilondieresis);
01884       add(XK_Greek_upsilonaccentdieresis, KeySym_Greek_upsilonaccentdieresis);
01885       add(XK_Greek_omegaaccent,           KeySym_Greek_omegaaccent);
01886       add(XK_Greek_ALPHA,                 KeySym_Greek_ALPHA);
01887       add(XK_Greek_BETA,                  KeySym_Greek_BETA);
01888       add(XK_Greek_GAMMA,                 KeySym_Greek_GAMMA);
01889       add(XK_Greek_DELTA,                 KeySym_Greek_DELTA);
01890       add(XK_Greek_EPSILON,               KeySym_Greek_EPSILON);
01891       add(XK_Greek_ZETA,                  KeySym_Greek_ZETA);
01892       add(XK_Greek_ETA,                   KeySym_Greek_ETA);
01893       add(XK_Greek_THETA,                 KeySym_Greek_THETA);
01894       add(XK_Greek_IOTA,                  KeySym_Greek_IOTA);
01895       add(XK_Greek_KAPPA,                 KeySym_Greek_KAPPA);
01896       add(XK_Greek_LAMBDA,                KeySym_Greek_LAMBDA);
01897       add(XK_Greek_MU,                    KeySym_Greek_MU);
01898       add(XK_Greek_NU,                    KeySym_Greek_NU);
01899       add(XK_Greek_XI,                    KeySym_Greek_XI);
01900       add(XK_Greek_OMICRON,               KeySym_Greek_OMICRON);
01901       add(XK_Greek_PI,                    KeySym_Greek_PI);
01902       add(XK_Greek_RHO,                   KeySym_Greek_RHO);
01903       add(XK_Greek_SIGMA,                 KeySym_Greek_SIGMA);
01904       add(XK_Greek_TAU,                   KeySym_Greek_TAU);
01905       add(XK_Greek_UPSILON,               KeySym_Greek_UPSILON);
01906       add(XK_Greek_PHI,                   KeySym_Greek_PHI);
01907       add(XK_Greek_CHI,                   KeySym_Greek_CHI);
01908       add(XK_Greek_PSI,                   KeySym_Greek_PSI);
01909       add(XK_Greek_OMEGA,                 KeySym_Greek_OMEGA);
01910       add(XK_Greek_alpha,                 KeySym_Greek_alpha);
01911       add(XK_Greek_beta,                  KeySym_Greek_beta);
01912       add(XK_Greek_gamma,                 KeySym_Greek_gamma);
01913       add(XK_Greek_delta,                 KeySym_Greek_delta);
01914       add(XK_Greek_epsilon,               KeySym_Greek_epsilon);
01915       add(XK_Greek_zeta,                  KeySym_Greek_zeta);
01916       add(XK_Greek_eta,                   KeySym_Greek_eta);
01917       add(XK_Greek_theta,                 KeySym_Greek_theta);
01918       add(XK_Greek_iota,                  KeySym_Greek_iota);
01919       add(XK_Greek_kappa,                 KeySym_Greek_kappa);
01920       add(XK_Greek_lambda,                KeySym_Greek_lambda);
01921       add(XK_Greek_mu,                    KeySym_Greek_mu);
01922       add(XK_Greek_nu,                    KeySym_Greek_nu);
01923       add(XK_Greek_xi,                    KeySym_Greek_xi);
01924       add(XK_Greek_omicron,               KeySym_Greek_omicron);
01925       add(XK_Greek_pi,                    KeySym_Greek_pi);
01926       add(XK_Greek_rho,                   KeySym_Greek_rho);
01927       add(XK_Greek_sigma,                 KeySym_Greek_sigma);
01928       add(XK_Greek_finalsmallsigma,       KeySym_Greek_finalsmallsigma);
01929       add(XK_Greek_tau,                   KeySym_Greek_tau);
01930       add(XK_Greek_upsilon,               KeySym_Greek_upsilon);
01931       add(XK_Greek_phi,                   KeySym_Greek_phi);
01932       add(XK_Greek_chi,                   KeySym_Greek_chi);
01933       add(XK_Greek_psi,                   KeySym_Greek_psi);
01934       add(XK_Greek_omega,                 KeySym_Greek_omega);
01935 
01936 
01937       /*
01938        * Technical
01939        */
01940       /*
01941       add(XK_leftradical,                 KeySym_leftradical);
01942       add(XK_topleftradical,              KeySym_topleftradical);
01943       add(XK_horizconnector,              KeySym_horizconnector);
01944       add(XK_topintegral,                 KeySym_topintegral);
01945       add(XK_botintegral,                 KeySym_botintegral);
01946       add(XK_vertconnector,               KeySym_vertconnector);
01947       add(XK_topleftsqbracket,            KeySym_topleftsqbracket);
01948       add(XK_botleftsqbracket,            KeySym_botleftsqbracket);
01949       add(XK_toprightsqbracket,           KeySym_toprightsqbracket);
01950       add(XK_botrightsqbracket,           KeySym_botrightsqbracket);
01951       add(XK_topleftparens,               KeySym_topleftparens);
01952       add(XK_botleftparens,               KeySym_botleftparens);
01953       add(XK_toprightparens,              KeySym_toprightparens);
01954       add(XK_botrightparens,              KeySym_botrightparens);
01955       add(XK_leftmiddlecurlybrace,        KeySym_leftmiddlecurlybrace);
01956       add(XK_rightmiddlecurlybrace,       KeySym_rightmiddlecurlybrace);
01957       add(XK_topleftsummation,            KeySym_topleftsummation);
01958       add(XK_botleftsummation,            KeySym_botleftsummation);
01959       add(XK_topvertsummationconnector,   KeySym_topvertsummationconnector);
01960       add(XK_botvertsummationconnector,   KeySym_botvertsummationconnector);
01961       add(XK_toprightsummation,           KeySym_toprightsummation);
01962       add(XK_botrightsummation,           KeySym_botrightsummation);
01963       add(XK_rightmiddlesummation,        KeySym_rightmiddlesummation);
01964       add(XK_lessthanequal,               KeySym_lessthanequal);
01965       add(XK_notequal,                    KeySym_notequal);
01966       add(XK_greaterthanequal,            KeySym_greaterthanequal);
01967       add(XK_integral,                    KeySym_integral);
01968       add(XK_therefore,                   KeySym_therefore);
01969       add(XK_variation,                   KeySym_variation);
01970       add(XK_infinity,                    KeySym_infinity);
01971       add(XK_nabla,                       KeySym_nabla);
01972       add(XK_approximate,                 KeySym_approximate);
01973       add(XK_similarequal,                KeySym_similarequal);
01974       add(XK_ifonlyif,                    KeySym_ifonlyif);
01975       add(XK_implies,                     KeySym_implies);
01976       add(XK_identical,                   KeySym_identical);
01977       add(XK_radical,                     KeySym_radical);
01978       add(XK_includedin,                  KeySym_includedin);
01979       add(XK_includes,                    KeySym_includes);
01980       add(XK_intersection,                KeySym_intersection);
01981       add(XK_union,                       KeySym_union);
01982       add(XK_logicaland,                  KeySym_logicaland);
01983       add(XK_logicalor,                   KeySym_logicalor);
01984       add(XK_partialderivative,           KeySym_partialderivative);
01985       add(XK_function,                    KeySym_function);
01986       add(XK_leftarrow,                   KeySym_leftarrow);
01987       add(XK_uparrow,                     KeySym_uparrow);
01988       add(XK_rightarrow,                  KeySym_rightarrow);
01989       add(XK_downarrow,                   KeySym_downarrow);
01990       */
01991 
01992       /*
01993        *  Special
01994        */
01995       /*
01996       add(XK_blank,                       KeySym_blank);
01997       add(XK_soliddiamond,                KeySym_soliddiamond);
01998       add(XK_checkerboard,                KeySym_checkerboard);
01999       add(XK_ht,                          KeySym_ht);
02000       add(XK_ff,                          KeySym_ff);
02001       add(XK_cr,                          KeySym_cr);
02002       add(XK_lf,                          KeySym_lf);
02003       add(XK_nl,                          KeySym_nl);
02004       add(XK_vt,                          KeySym_vt);
02005       add(XK_lowrightcorner,              KeySym_lowrightcorner);
02006       add(XK_uprightcorner,               KeySym_uprightcorner);
02007       add(XK_upleftcorner,                KeySym_upleftcorner);
02008       add(XK_lowleftcorner,               KeySym_lowleftcorner);
02009       add(XK_crossinglines,               KeySym_crossinglines);
02010       add(XK_horizlinescan1,              KeySym_horizlinescan1);
02011       add(XK_horizlinescan3,              KeySym_horizlinescan3);
02012       add(XK_horizlinescan5,              KeySym_horizlinescan5);
02013       add(XK_horizlinescan7,              KeySym_horizlinescan7);
02014       add(XK_horizlinescan9,              KeySym_horizlinescan9);
02015       add(XK_leftt,                       KeySym_leftt);
02016       add(XK_rightt,                      KeySym_rightt);
02017       add(XK_bott,                        KeySym_bott);
02018       add(XK_topt,                        KeySym_topt);
02019       add(XK_vertbar,                     KeySym_vertbar);
02020       */
02021 
02022       /*
02023        *  Publishing
02024        */
02025       /*
02026       add(XK_emspace,                     KeySym_emspace);
02027       add(XK_enspace,                     KeySym_enspace);
02028       add(XK_em3space,                    KeySym_em3space);
02029       add(XK_em4space,                    KeySym_em4space);
02030       add(XK_digitspace,                  KeySym_digitspace);
02031       add(XK_punctspace,                  KeySym_punctspace);
02032       add(XK_thinspace,                   KeySym_thinspace);
02033       add(XK_hairspace,                   KeySym_hairspace);
02034       add(XK_emdash,                      KeySym_emdash);
02035       add(XK_endash,                      KeySym_endash);
02036       add(XK_signifblank,                 KeySym_signifblank);
02037       add(XK_ellipsis,                    KeySym_ellipsis);
02038       add(XK_doubbaselinedot,             KeySym_doubbaselinedot);
02039       add(XK_onethird,                    KeySym_onethird);
02040       add(XK_twothirds,                   KeySym_twothirds);
02041       add(XK_onefifth,                    KeySym_onefifth);
02042       add(XK_twofifths,                   KeySym_twofifths);
02043       add(XK_threefifths,                 KeySym_threefifths);
02044       add(XK_fourfifths,                  KeySym_fourfifths);
02045       add(XK_onesixth,                    KeySym_onesixth);
02046       add(XK_fivesixths,                  KeySym_fivesixths);
02047       add(XK_careof,                      KeySym_careof);
02048       add(XK_figdash,                     KeySym_figdash);
02049       add(XK_leftanglebracket,            KeySym_leftanglebracket);
02050       add(XK_decimalpoint,                KeySym_decimalpoint);
02051       add(XK_rightanglebracket,           KeySym_rightanglebracket);
02052       add(XK_marker,                      KeySym_marker);
02053       add(XK_oneeighth,                   KeySym_oneeighth);
02054       add(XK_threeeighths,                KeySym_threeeighths);
02055       add(XK_fiveeighths,                 KeySym_fiveeighths);
02056       add(XK_seveneighths,                KeySym_seveneighths);
02057       add(XK_trademark,                   KeySym_trademark);
02058       add(XK_signaturemark,               KeySym_signaturemark);
02059       add(XK_trademarkincircle,           KeySym_trademarkincircle);
02060       add(XK_leftopentriangle,            KeySym_leftopentriangle);
02061       add(XK_rightopentriangle,           KeySym_rightopentriangle);
02062       add(XK_emopencircle,                KeySym_emopencircle);
02063       add(XK_emopenrectangle,             KeySym_emopenrectangle);
02064       add(XK_leftsinglequotemark,         KeySym_leftsinglequotemark);
02065       add(XK_rightsinglequotemark,        KeySym_rightsinglequotemark);
02066       add(XK_leftdoublequotemark,         KeySym_leftdoublequotemark);
02067       add(XK_rightdoublequotemark,        KeySym_rightdoublequotemark);
02068       add(XK_prescription,                KeySym_prescription);
02069       add(XK_minutes,                     KeySym_minutes);
02070       add(XK_seconds,                     KeySym_seconds);
02071       add(XK_latincross,                  KeySym_latincross);
02072       add(XK_hexagram,                    KeySym_hexagram);
02073       add(XK_filledrectbullet,            KeySym_filledrectbullet);
02074       add(XK_filledlefttribullet,         KeySym_filledlefttribullet);
02075       add(XK_filledrighttribullet,        KeySym_filledrighttribullet);
02076       add(XK_emfilledcircle,              KeySym_emfilledcircle);
02077       add(XK_emfilledrect,                KeySym_emfilledrect);
02078       add(XK_enopencircbullet,            KeySym_enopencircbullet);
02079       add(XK_enopensquarebullet,          KeySym_enopensquarebullet);
02080       add(XK_openrectbullet,              KeySym_openrectbullet);
02081       add(XK_opentribulletup,             KeySym_opentribulletup);
02082       add(XK_opentribulletdown,           KeySym_opentribulletdown);
02083       add(XK_openstar,                    KeySym_openstar);
02084       add(XK_enfilledcircbullet,          KeySym_enfilledcircbullet);
02085       add(XK_enfilledsqbullet,            KeySym_enfilledsqbullet);
02086       add(XK_filledtribulletup,           KeySym_filledtribulletup);
02087       add(XK_filledtribulletdown,         KeySym_filledtribulletdown);
02088       add(XK_leftpointer,                 KeySym_leftpointer);
02089       add(XK_rightpointer,                KeySym_rightpointer);
02090       add(XK_club,                        KeySym_club);
02091       add(XK_diamond,                     KeySym_diamond);
02092       add(XK_heart,                       KeySym_heart);
02093       add(XK_maltesecross,                KeySym_maltesecross);
02094       add(XK_dagger,                      KeySym_dagger);
02095       add(XK_doubledagger,                KeySym_doubledagger);
02096       add(XK_checkmark,                   KeySym_checkmark);
02097       add(XK_ballotcross,                 KeySym_ballotcross);
02098       add(XK_musicalsharp,                KeySym_musicalsharp);
02099       add(XK_musicalflat,                 KeySym_musicalflat);
02100       add(XK_malesymbol,                  KeySym_malesymbol);
02101       add(XK_femalesymbol,                KeySym_femalesymbol);
02102       add(XK_telephone,                   KeySym_telephone);
02103       add(XK_telephonerecorder,           KeySym_telephonerecorder);
02104       add(XK_phonographcopyright,         KeySym_phonographcopyright);
02105       add(XK_caret,                       KeySym_caret);
02106       add(XK_singlelowquotemark,          KeySym_singlelowquotemark);
02107       add(XK_doublelowquotemark,          KeySym_doublelowquotemark);
02108       add(XK_cursor,                      KeySym_cursor);
02109       */
02110 
02111       /*
02112        *  APL
02113        */
02114       /*
02115       add(XK_leftcaret,                   KeySym_leftcaret);
02116       add(XK_rightcaret,                  KeySym_rightcaret);
02117       add(XK_downcaret,                   KeySym_downcaret);
02118       add(XK_upcaret,                     KeySym_upcaret);
02119       add(XK_overbar,                     KeySym_overbar);
02120       add(XK_downtack,                    KeySym_downtack);
02121       add(XK_upshoe,                      KeySym_upshoe);
02122       add(XK_downstile,                   KeySym_downstile);
02123       add(XK_underbar,                    KeySym_underbar);
02124       add(XK_jot,                         KeySym_jot);
02125       add(XK_quad,                        KeySym_quad);
02126       add(XK_uptack,                      KeySym_uptack);
02127       add(XK_circle,                      KeySym_circle);
02128       add(XK_upstile,                     KeySym_upstile);
02129       add(XK_downshoe,                    KeySym_downshoe);
02130       add(XK_rightshoe,                   KeySym_rightshoe);
02131       add(XK_leftshoe,                    KeySym_leftshoe);
02132       add(XK_lefttack,                    KeySym_lefttack);
02133       add(XK_righttack,                   KeySym_righttack);
02134       */
02135 
02136       /*
02137        * Hebrew
02138        */
02139       add(XK_hebrew_doublelowline,        KeySym_hebrew_doublelowline);
02140       add(XK_hebrew_aleph,                KeySym_hebrew_aleph);
02141       add(XK_hebrew_bet,                  KeySym_hebrew_bet);
02142       add(XK_hebrew_gimel,                KeySym_hebrew_gimel);
02143       add(XK_hebrew_dalet,                KeySym_hebrew_dalet);
02144       add(XK_hebrew_he,                   KeySym_hebrew_he);
02145       add(XK_hebrew_waw,                  KeySym_hebrew_waw);
02146       add(XK_hebrew_zain,                 KeySym_hebrew_zain);
02147       add(XK_hebrew_chet,                 KeySym_hebrew_chet);
02148       add(XK_hebrew_tet,                  KeySym_hebrew_tet);
02149       add(XK_hebrew_yod,                  KeySym_hebrew_yod);
02150       add(XK_hebrew_finalkaph,            KeySym_hebrew_finalkaph);
02151       add(XK_hebrew_kaph,                 KeySym_hebrew_kaph);
02152       add(XK_hebrew_lamed,                KeySym_hebrew_lamed);
02153       add(XK_hebrew_finalmem,             KeySym_hebrew_finalmem);
02154       add(XK_hebrew_mem,                  KeySym_hebrew_mem);
02155       add(XK_hebrew_finalnun,             KeySym_hebrew_finalnun);
02156       add(XK_hebrew_nun,                  KeySym_hebrew_nun);
02157       add(XK_hebrew_samech,               KeySym_hebrew_samech);
02158       add(XK_hebrew_ayin,                 KeySym_hebrew_ayin);
02159       add(XK_hebrew_finalpe,              KeySym_hebrew_finalpe);
02160       add(XK_hebrew_pe,                   KeySym_hebrew_pe);
02161       add(XK_hebrew_finalzade,            KeySym_hebrew_finalzade);
02162       add(XK_hebrew_zade,                 KeySym_hebrew_zade);
02163       add(XK_hebrew_qoph,                 KeySym_hebrew_qoph);
02164       add(XK_hebrew_resh,                 KeySym_hebrew_resh);
02165       add(XK_hebrew_shin,                 KeySym_hebrew_shin);
02166       add(XK_hebrew_taw,                  KeySym_hebrew_taw);
02167 
02168 
02169       /*
02170        * Thai
02171        */
02172       add(XK_Thai_kokai,                  KeySym_Thai_kokai);
02173       add(XK_Thai_khokhai,                KeySym_Thai_khokhai);
02174       add(XK_Thai_khokhuat,               KeySym_Thai_khokhuat);
02175       add(XK_Thai_khokhwai,               KeySym_Thai_khokhwai);
02176       add(XK_Thai_khokhon,                KeySym_Thai_khokhon);
02177       add(XK_Thai_khorakhang,             KeySym_Thai_khorakhang);
02178       add(XK_Thai_ngongu,                 KeySym_Thai_ngongu);
02179       add(XK_Thai_chochan,                KeySym_Thai_chochan);
02180       add(XK_Thai_choching,               KeySym_Thai_choching);
02181       add(XK_Thai_chochang,               KeySym_Thai_chochang);
02182       add(XK_Thai_soso,                   KeySym_Thai_soso);
02183       add(XK_Thai_chochoe,                KeySym_Thai_chochoe);
02184       add(XK_Thai_yoying,                 KeySym_Thai_yoying);
02185       add(XK_Thai_dochada,                KeySym_Thai_dochada);
02186       add(XK_Thai_topatak,                KeySym_Thai_topatak);
02187       add(XK_Thai_thothan,                KeySym_Thai_thothan);
02188       add(XK_Thai_thonangmontho,          KeySym_Thai_thonangmontho);
02189       add(XK_Thai_thophuthao,             KeySym_Thai_thophuthao);
02190       add(XK_Thai_nonen,                  KeySym_Thai_nonen);
02191       add(XK_Thai_dodek,                  KeySym_Thai_dodek);
02192       add(XK_Thai_totao,                  KeySym_Thai_totao);
02193       add(XK_Thai_thothung,               KeySym_Thai_thothung);
02194       add(XK_Thai_thothahan,              KeySym_Thai_thothahan);
02195       add(XK_Thai_thothong,               KeySym_Thai_thothong);
02196       add(XK_Thai_nonu,                   KeySym_Thai_nonu);
02197       add(XK_Thai_bobaimai,               KeySym_Thai_bobaimai);
02198       add(XK_Thai_popla,                  KeySym_Thai_popla);
02199       add(XK_Thai_phophung,               KeySym_Thai_phophung);
02200       add(XK_Thai_fofa,                   KeySym_Thai_fofa);
02201       add(XK_Thai_phophan,                KeySym_Thai_phophan);
02202       add(XK_Thai_fofan,                  KeySym_Thai_fofan);
02203       add(XK_Thai_phosamphao,             KeySym_Thai_phosamphao);
02204       add(XK_Thai_moma,                   KeySym_Thai_moma);
02205       add(XK_Thai_yoyak,                  KeySym_Thai_yoyak);
02206       add(XK_Thai_rorua,                  KeySym_Thai_rorua);
02207       add(XK_Thai_ru,                     KeySym_Thai_ru);
02208       add(XK_Thai_loling,                 KeySym_Thai_loling);
02209       add(XK_Thai_lu,                     KeySym_Thai_lu);
02210       add(XK_Thai_wowaen,                 KeySym_Thai_wowaen);
02211       add(XK_Thai_sosala,                 KeySym_Thai_sosala);
02212       add(XK_Thai_sorusi,                 KeySym_Thai_sorusi);
02213       add(XK_Thai_sosua,                  KeySym_Thai_sosua);
02214       add(XK_Thai_hohip,                  KeySym_Thai_hohip);
02215       add(XK_Thai_lochula,                KeySym_Thai_lochula);
02216       add(XK_Thai_oang,                   KeySym_Thai_oang);
02217       add(XK_Thai_honokhuk,               KeySym_Thai_honokhuk);
02218       add(XK_Thai_paiyannoi,              KeySym_Thai_paiyannoi);
02219       add(XK_Thai_saraa,                  KeySym_Thai_saraa);
02220       add(XK_Thai_maihanakat,             KeySym_Thai_maihanakat);
02221       add(XK_Thai_saraaa,                 KeySym_Thai_saraaa);
02222       add(XK_Thai_saraam,                 KeySym_Thai_saraam);
02223       add(XK_Thai_sarai,                  KeySym_Thai_sarai);
02224       add(XK_Thai_saraii,                 KeySym_Thai_saraii);
02225       add(XK_Thai_saraue,                 KeySym_Thai_saraue);
02226       add(XK_Thai_sarauee,                KeySym_Thai_sarauee);
02227       add(XK_Thai_sarau,                  KeySym_Thai_sarau);
02228       add(XK_Thai_sarauu,                 KeySym_Thai_sarauu);
02229       add(XK_Thai_phinthu,                KeySym_Thai_phinthu);
02230       add(XK_Thai_maihanakat_maitho,      KeySym_Thai_maihanakat_maitho);
02231       add(XK_Thai_baht,                   KeySym_Thai_baht);
02232       add(XK_Thai_sarae,                  KeySym_Thai_sarae);
02233       add(XK_Thai_saraae,                 KeySym_Thai_saraae);
02234       add(XK_Thai_sarao,                  KeySym_Thai_sarao);
02235       add(XK_Thai_saraaimaimuan,          KeySym_Thai_saraaimaimuan);
02236       add(XK_Thai_saraaimaimalai,         KeySym_Thai_saraaimaimalai);
02237       add(XK_Thai_lakkhangyao,            KeySym_Thai_lakkhangyao);
02238       add(XK_Thai_maiyamok,               KeySym_Thai_maiyamok);
02239       add(XK_Thai_maitaikhu,              KeySym_Thai_maitaikhu);
02240       add(XK_Thai_maiek,                  KeySym_Thai_maiek);
02241       add(XK_Thai_maitho,                 KeySym_Thai_maitho);
02242       add(XK_Thai_maitri,                 KeySym_Thai_maitri);
02243       add(XK_Thai_maichattawa,            KeySym_Thai_maichattawa);
02244       add(XK_Thai_thanthakhat,            KeySym_Thai_thanthakhat);
02245       add(XK_Thai_nikhahit,               KeySym_Thai_nikhahit);
02246       add(XK_Thai_leksun,                 KeySym_Thai_leksun);
02247       add(XK_Thai_leknung,                KeySym_Thai_leknung);
02248       add(XK_Thai_leksong,                KeySym_Thai_leksong);
02249       add(XK_Thai_leksam,                 KeySym_Thai_leksam);
02250       add(XK_Thai_leksi,                  KeySym_Thai_leksi);
02251       add(XK_Thai_lekha,                  KeySym_Thai_lekha);
02252       add(XK_Thai_lekhok,                 KeySym_Thai_lekhok);
02253       add(XK_Thai_lekchet,                KeySym_Thai_lekchet);
02254       add(XK_Thai_lekpaet,                KeySym_Thai_lekpaet);
02255       add(XK_Thai_lekkao,                 KeySym_Thai_lekkao);
02256 
02257 
02258       /*
02259        *   Korean
02260        */
02261       add(XK_Hangul,                      KeySym_Hangul);
02262       add(XK_Hangul_Start,                KeySym_Hangul_Start);
02263       add(XK_Hangul_End,                  KeySym_Hangul_End);
02264       add(XK_Hangul_Hanja,                KeySym_Hangul_Hanja);
02265       add(XK_Hangul_Jamo,                 KeySym_Hangul_Jamo);
02266       add(XK_Hangul_Romaja,               KeySym_Hangul_Romaja);
02267       add(XK_Hangul_Jeonja,               KeySym_Hangul_Jeonja);
02268       add(XK_Hangul_Banja,                KeySym_Hangul_Banja);
02269       add(XK_Hangul_PreHanja,             KeySym_Hangul_PreHanja);
02270       add(XK_Hangul_PostHanja,            KeySym_Hangul_PostHanja);
02271       add(XK_Hangul_Special,              KeySym_Hangul_Special);
02272       // Hangul Consonant Characters
02273       add(XK_Hangul_Kiyeog,               KeySym_Hangul_Kiyeog);
02274       add(XK_Hangul_SsangKiyeog,          KeySym_Hangul_SsangKiyeog);
02275       add(XK_Hangul_KiyeogSios,           KeySym_Hangul_KiyeogSios);
02276       add(XK_Hangul_Nieun,                KeySym_Hangul_Nieun);
02277       add(XK_Hangul_NieunJieuj,           KeySym_Hangul_NieunJieuj);
02278       add(XK_Hangul_NieunHieuh,           KeySym_Hangul_NieunHieuh);
02279       add(XK_Hangul_Dikeud,               KeySym_Hangul_Dikeud);
02280       add(XK_Hangul_SsangDikeud,          KeySym_Hangul_SsangDikeud);
02281       add(XK_Hangul_Rieul,                KeySym_Hangul_Rieul);
02282       add(XK_Hangul_RieulKiyeog,          KeySym_Hangul_RieulKiyeog);
02283       add(XK_Hangul_RieulMieum,           KeySym_Hangul_RieulMieum);
02284       add(XK_Hangul_RieulPieub,           KeySym_Hangul_RieulPieub);
02285       add(XK_Hangul_RieulSios,            KeySym_Hangul_RieulSios);
02286       add(XK_Hangul_RieulTieut,           KeySym_Hangul_RieulTieut);
02287       add(XK_Hangul_RieulPhieuf,          KeySym_Hangul_RieulPhieuf);
02288       add(XK_Hangul_RieulHieuh,           KeySym_Hangul_RieulHieuh);
02289       add(XK_Hangul_Mieum,                KeySym_Hangul_Mieum);
02290       add(XK_Hangul_Pieub,                KeySym_Hangul_Pieub);
02291       add(XK_Hangul_SsangPieub,           KeySym_Hangul_SsangPieub);
02292       add(XK_Hangul_PieubSios,            KeySym_Hangul_PieubSios);
02293       add(XK_Hangul_Sios,                 KeySym_Hangul_Sios);
02294       add(XK_Hangul_SsangSios,            KeySym_Hangul_SsangSios);
02295       add(XK_Hangul_Ieung,                KeySym_Hangul_Ieung);
02296       add(XK_Hangul_Jieuj,                KeySym_Hangul_Jieuj);
02297       add(XK_Hangul_SsangJieuj,           KeySym_Hangul_SsangJieuj);
02298       add(XK_Hangul_Cieuc,                KeySym_Hangul_Cieuc);
02299       add(XK_Hangul_Khieuq,               KeySym_Hangul_Khieuq);
02300       add(XK_Hangul_Tieut,                KeySym_Hangul_Tieut);
02301       add(XK_Hangul_Phieuf,               KeySym_Hangul_Phieuf);
02302       add(XK_Hangul_Hieuh,                KeySym_Hangul_Hieuh);
02303       // Hangul Vowel Characters
02304       add(XK_Hangul_A,                    KeySym_Hangul_A);
02305       add(XK_Hangul_AE,                   KeySym_Hangul_AE);
02306       add(XK_Hangul_YA,                   KeySym_Hangul_YA);
02307       add(XK_Hangul_YAE,                  KeySym_Hangul_YAE);
02308       add(XK_Hangul_EO,                   KeySym_Hangul_EO);
02309       add(XK_Hangul_E,                    KeySym_Hangul_E);
02310       add(XK_Hangul_YEO,                  KeySym_Hangul_YEO);
02311       add(XK_Hangul_YE,                   KeySym_Hangul_YE);
02312       add(XK_Hangul_O,                    KeySym_Hangul_O);
02313       add(XK_Hangul_WA,                   KeySym_Hangul_WA);
02314       add(XK_Hangul_WAE,                  KeySym_Hangul_WAE);
02315       add(XK_Hangul_OE,                   KeySym_Hangul_OE);
02316       add(XK_Hangul_YO,                   KeySym_Hangul_YO);
02317       add(XK_Hangul_U,                    KeySym_Hangul_U);
02318       add(XK_Hangul_WEO,                  KeySym_Hangul_WEO);
02319       add(XK_Hangul_WE,                   KeySym_Hangul_WE);
02320       add(XK_Hangul_WI,                   KeySym_Hangul_WI);
02321       add(XK_Hangul_YU,                   KeySym_Hangul_YU);
02322       add(XK_Hangul_EU,                   KeySym_Hangul_EU);
02323       add(XK_Hangul_YI,                   KeySym_Hangul_YI);
02324       add(XK_Hangul_I,                    KeySym_Hangul_I);
02325       // Hangul syllable-final (JongSeong) Characters
02326       add(XK_Hangul_J_Kiyeog,             KeySym_Hangul_J_Kiyeog);
02327       add(XK_Hangul_J_SsangKiyeog,        KeySym_Hangul_J_SsangKiyeog);
02328       add(XK_Hangul_J_KiyeogSios,         KeySym_Hangul_J_KiyeogSios);
02329       add(XK_Hangul_J_Nieun,              KeySym_Hangul_J_Nieun);
02330       add(XK_Hangul_J_NieunJieuj,         KeySym_Hangul_J_NieunJieuj);
02331       add(XK_Hangul_J_NieunHieuh,         KeySym_Hangul_J_NieunHieuh);
02332       add(XK_Hangul_J_Dikeud,             KeySym_Hangul_J_Dikeud);
02333       add(XK_Hangul_J_Rieul,              KeySym_Hangul_J_Rieul);
02334       add(XK_Hangul_J_RieulKiyeog,        KeySym_Hangul_J_RieulKiyeog);
02335       add(XK_Hangul_J_RieulMieum,         KeySym_Hangul_J_RieulMieum);
02336       add(XK_Hangul_J_RieulPieub,         KeySym_Hangul_J_RieulPieub);
02337       add(XK_Hangul_J_RieulSios,          KeySym_Hangul_J_RieulSios);
02338       add(XK_Hangul_J_RieulTieut,         KeySym_Hangul_J_RieulTieut);
02339       add(XK_Hangul_J_RieulPhieuf,        KeySym_Hangul_J_RieulPhieuf);
02340       add(XK_Hangul_J_RieulHieuh,         KeySym_Hangul_J_RieulHieuh);
02341       add(XK_Hangul_J_Mieum,              KeySym_Hangul_J_Mieum);
02342       add(XK_Hangul_J_Pieub,              KeySym_Hangul_J_Pieub);
02343       add(XK_Hangul_J_PieubSios,          KeySym_Hangul_J_PieubSios);
02344       add(XK_Hangul_J_Sios,               KeySym_Hangul_J_Sios);
02345       add(XK_Hangul_J_SsangSios,          KeySym_Hangul_J_SsangSios);
02346       add(XK_Hangul_J_Ieung,              KeySym_Hangul_J_Ieung);
02347       add(XK_Hangul_J_Jieuj,              KeySym_Hangul_J_Jieuj);
02348       add(XK_Hangul_J_Cieuc,              KeySym_Hangul_J_Cieuc);
02349       add(XK_Hangul_J_Khieuq,             KeySym_Hangul_J_Khieuq);
02350       add(XK_Hangul_J_Tieut,              KeySym_Hangul_J_Tieut);
02351       add(XK_Hangul_J_Phieuf,             KeySym_Hangul_J_Phieuf);
02352       add(XK_Hangul_J_Hieuh,              KeySym_Hangul_J_Hieuh);
02353       // Ancient Hangul Consonant Characters
02354       add(XK_Hangul_RieulYeorinHieuh,     KeySym_Hangul_RieulYeorinHieuh);
02355       add(XK_Hangul_SunkyeongeumMieum,    KeySym_Hangul_SunkyeongeumMieum);
02356       add(XK_Hangul_SunkyeongeumPieub,    KeySym_Hangul_SunkyeongeumPieub);
02357       add(XK_Hangul_PanSios,              KeySym_Hangul_PanSios);
02358       add(XK_Hangul_KkogjiDalrinIeung,    KeySym_Hangul_KkogjiDalrinIeung);
02359       add(XK_Hangul_SunkyeongeumPhieuf,   KeySym_Hangul_SunkyeongeumPhieuf);
02360       add(XK_Hangul_YeorinHieuh,          KeySym_Hangul_YeorinHieuh);
02361       // Ancient Hangul Vowel Characters
02362       add(XK_Hangul_AraeA,                KeySym_Hangul_AraeA);
02363       add(XK_Hangul_AraeAE,               KeySym_Hangul_AraeAE);
02364       // Ancient Hangul syllable-final (JongSeong) Characters
02365       add(XK_Hangul_J_PanSios,            KeySym_Hangul_J_PanSios);
02366       add(XK_Hangul_J_KkogjiDalrinIeung,  KeySym_Hangul_J_KkogjiDalrinIeung);
02367       add(XK_Hangul_J_YeorinHieuh,        KeySym_Hangul_J_YeorinHieuh);
02368       // Korean currency symbol
02369       add(XK_Korean_Won,                  KeySym_Korean_Won);
02370 
02371 
02372       /*
02373        *   Armenian
02374        */
02375       add(XK_Armenian_eternity,           KeySym_Armenian_eternity);
02376       add(XK_Armenian_ligature_ew,        KeySym_Armenian_ligature_ew);
02377       add(XK_Armenian_full_stop,          KeySym_Armenian_full_stop);
02378       add(XK_Armenian_parenright,         KeySym_Armenian_parenright);
02379       add(XK_Armenian_parenleft,          KeySym_Armenian_parenleft);
02380       add(XK_Armenian_guillemotright,     KeySym_Armenian_guillemotright);
02381       add(XK_Armenian_guillemotleft,      KeySym_Armenian_guillemotleft);
02382       add(XK_Armenian_em_dash,            KeySym_Armenian_em_dash);
02383       add(XK_Armenian_dot,                KeySym_Armenian_dot);
02384       add(XK_Armenian_separation_mark,    KeySym_Armenian_separation_mark);
02385       add(XK_Armenian_comma,              KeySym_Armenian_comma);
02386       add(XK_Armenian_en_dash,            KeySym_Armenian_en_dash);
02387       add(XK_Armenian_hyphen,             KeySym_Armenian_hyphen);
02388       add(XK_Armenian_ellipsis,           KeySym_Armenian_ellipsis);
02389       add(XK_Armenian_exclam,             KeySym_Armenian_exclam);
02390       add(XK_Armenian_accent,             KeySym_Armenian_accent);
02391       add(XK_Armenian_question,           KeySym_Armenian_question);
02392       add(XK_Armenian_AYB,                KeySym_Armenian_AYB);
02393       add(XK_Armenian_ayb,                KeySym_Armenian_ayb);
02394       add(XK_Armenian_BEN,                KeySym_Armenian_BEN);
02395       add(XK_Armenian_ben,                KeySym_Armenian_ben);
02396       add(XK_Armenian_GIM,                KeySym_Armenian_GIM);
02397       add(XK_Armenian_gim,                KeySym_Armenian_gim);
02398       add(XK_Armenian_DA,                 KeySym_Armenian_DA);
02399       add(XK_Armenian_da,                 KeySym_Armenian_da);
02400       add(XK_Armenian_YECH,               KeySym_Armenian_YECH);
02401       add(XK_Armenian_yech,               KeySym_Armenian_yech);
02402       add(XK_Armenian_ZA,                 KeySym_Armenian_ZA);
02403       add(XK_Armenian_za,                 KeySym_Armenian_za);
02404       add(XK_Armenian_E,                  KeySym_Armenian_E);
02405       add(XK_Armenian_e,                  KeySym_Armenian_e);
02406       add(XK_Armenian_AT,                 KeySym_Armenian_AT);
02407       add(XK_Armenian_at,                 KeySym_Armenian_at);
02408       add(XK_Armenian_TO,                 KeySym_Armenian_TO);
02409       add(XK_Armenian_to,                 KeySym_Armenian_to);
02410       add(XK_Armenian_ZHE,                KeySym_Armenian_ZHE);
02411       add(XK_Armenian_zhe,                KeySym_Armenian_zhe);
02412       add(XK_Armenian_INI,                KeySym_Armenian_INI);
02413       add(XK_Armenian_ini,                KeySym_Armenian_ini);
02414       add(XK_Armenian_LYUN,               KeySym_Armenian_LYUN);
02415       add(XK_Armenian_lyun,               KeySym_Armenian_lyun);
02416       add(XK_Armenian_KHE,                KeySym_Armenian_KHE);
02417       add(XK_Armenian_khe,                KeySym_Armenian_khe);
02418       add(XK_Armenian_TSA,                KeySym_Armenian_TSA);
02419       add(XK_Armenian_tsa,                KeySym_Armenian_tsa);
02420       add(XK_Armenian_KEN,                KeySym_Armenian_KEN);
02421       add(XK_Armenian_ken,                KeySym_Armenian_ken);
02422       add(XK_Armenian_HO,                 KeySym_Armenian_HO);
02423       add(XK_Armenian_ho,                 KeySym_Armenian_ho);
02424       add(XK_Armenian_DZA,                KeySym_Armenian_DZA);
02425       add(XK_Armenian_dza,                KeySym_Armenian_dza);
02426       add(XK_Armenian_GHAT,               KeySym_Armenian_GHAT);
02427       add(XK_Armenian_ghat,               KeySym_Armenian_ghat);
02428       add(XK_Armenian_TCHE,               KeySym_Armenian_TCHE);
02429       add(XK_Armenian_tche,               KeySym_Armenian_tche);
02430       add(XK_Armenian_MEN,                KeySym_Armenian_MEN);
02431       add(XK_Armenian_men,                KeySym_Armenian_men);
02432       add(XK_Armenian_HI,                 KeySym_Armenian_HI);
02433       add(XK_Armenian_hi,                 KeySym_Armenian_hi);
02434       add(XK_Armenian_NU,                 KeySym_Armenian_NU);
02435       add(XK_Armenian_nu,                 KeySym_Armenian_nu);
02436       add(XK_Armenian_SHA,                KeySym_Armenian_SHA);
02437       add(XK_Armenian_sha,                KeySym_Armenian_sha);
02438       add(XK_Armenian_VO,                 KeySym_Armenian_VO);
02439       add(XK_Armenian_vo,                 KeySym_Armenian_vo);
02440       add(XK_Armenian_CHA,                KeySym_Armenian_CHA);
02441       add(XK_Armenian_cha,                KeySym_Armenian_cha);
02442       add(XK_Armenian_PE,                 KeySym_Armenian_PE);
02443       add(XK_Armenian_pe,                 KeySym_Armenian_pe);
02444       add(XK_Armenian_JE,                 KeySym_Armenian_JE);
02445       add(XK_Armenian_je,                 KeySym_Armenian_je);
02446       add(XK_Armenian_RA,                 KeySym_Armenian_RA);
02447       add(XK_Armenian_ra,                 KeySym_Armenian_ra);
02448       add(XK_Armenian_SE,                 KeySym_Armenian_SE);
02449       add(XK_Armenian_se,                 KeySym_Armenian_se);
02450       add(XK_Armenian_VEV,                KeySym_Armenian_VEV);
02451       add(XK_Armenian_vev,                KeySym_Armenian_vev);
02452       add(XK_Armenian_TYUN,               KeySym_Armenian_TYUN);
02453       add(XK_Armenian_tyun,               KeySym_Armenian_tyun);
02454       add(XK_Armenian_RE,                 KeySym_Armenian_RE);
02455       add(XK_Armenian_re,                 KeySym_Armenian_re);
02456       add(XK_Armenian_TSO,                KeySym_Armenian_TSO);
02457       add(XK_Armenian_tso,                KeySym_Armenian_tso);
02458       add(XK_Armenian_VYUN,               KeySym_Armenian_VYUN);
02459       add(XK_Armenian_vyun,               KeySym_Armenian_vyun);
02460       add(XK_Armenian_PYUR,               KeySym_Armenian_PYUR);
02461       add(XK_Armenian_pyur,               KeySym_Armenian_pyur);
02462       add(XK_Armenian_KE,                 KeySym_Armenian_KE);
02463       add(XK_Armenian_ke,                 KeySym_Armenian_ke);
02464       add(XK_Armenian_O,                  KeySym_Armenian_O);
02465       add(XK_Armenian_o,                  KeySym_Armenian_o);
02466       add(XK_Armenian_FE,                 KeySym_Armenian_FE);
02467       add(XK_Armenian_fe,                 KeySym_Armenian_fe);
02468       add(XK_Armenian_apostrophe,         KeySym_Armenian_apostrophe);
02469       add(XK_Armenian_section_sign,       KeySym_Armenian_section_sign);
02470 
02471 
02472       /*
02473        *   Georgian
02474        */
02475       add(XK_Georgian_an,                 KeySym_Georgian_an);
02476       add(XK_Georgian_ban,                KeySym_Georgian_ban);
02477       add(XK_Georgian_gan,                KeySym_Georgian_gan);
02478       add(XK_Georgian_don,                KeySym_Georgian_don);
02479       add(XK_Georgian_en,                 KeySym_Georgian_en);
02480       add(XK_Georgian_vin,                KeySym_Georgian_vin);
02481       add(XK_Georgian_zen,                KeySym_Georgian_zen);
02482       add(XK_Georgian_tan,                KeySym_Georgian_tan);
02483       add(XK_Georgian_in,                 KeySym_Georgian_in);
02484       add(XK_Georgian_kan,                KeySym_Georgian_kan);
02485       add(XK_Georgian_las,                KeySym_Georgian_las);
02486       add(XK_Georgian_man,                KeySym_Georgian_man);
02487       add(XK_Georgian_nar,                KeySym_Georgian_nar);
02488       add(XK_Georgian_on,                 KeySym_Georgian_on);
02489       add(XK_Georgian_par,                KeySym_Georgian_par);
02490       add(XK_Georgian_zhar,               KeySym_Georgian_zhar);
02491       add(XK_Georgian_rae,                KeySym_Georgian_rae);
02492       add(XK_Georgian_san,                KeySym_Georgian_san);
02493       add(XK_Georgian_tar,                KeySym_Georgian_tar);
02494       add(XK_Georgian_un,                 KeySym_Georgian_un);
02495       add(XK_Georgian_phar,               KeySym_Georgian_phar);
02496       add(XK_Georgian_khar,               KeySym_Georgian_khar);
02497       add(XK_Georgian_ghan,               KeySym_Georgian_ghan);
02498       add(XK_Georgian_qar,                KeySym_Georgian_qar);
02499       add(XK_Georgian_shin,               KeySym_Georgian_shin);
02500       add(XK_Georgian_chin,               KeySym_Georgian_chin);
02501       add(XK_Georgian_can,                KeySym_Georgian_can);
02502       add(XK_Georgian_jil,                KeySym_Georgian_jil);
02503       add(XK_Georgian_cil,                KeySym_Georgian_cil);
02504       add(XK_Georgian_char,               KeySym_Georgian_char);
02505       add(XK_Georgian_xan,                KeySym_Georgian_xan);
02506       add(XK_Georgian_jhan,               KeySym_Georgian_jhan);
02507       add(XK_Georgian_hae,                KeySym_Georgian_hae);
02508       add(XK_Georgian_he,                 KeySym_Georgian_he);
02509       add(XK_Georgian_hie,                KeySym_Georgian_hie);
02510       add(XK_Georgian_we,                 KeySym_Georgian_we);
02511       add(XK_Georgian_har,                KeySym_Georgian_har);
02512       add(XK_Georgian_hoe,                KeySym_Georgian_hoe);
02513       add(XK_Georgian_fi,                 KeySym_Georgian_fi);
02514 
02515 
02516       /*
02517        * Azeri (and other Turkic or Caucasian languages of ex-USSR)
02518        */
02519       // latin
02520       add(XK_Ccedillaabovedot,            KeySym_Ccedillaabovedot);
02521       add(XK_Xabovedot,                   KeySym_Xabovedot);
02522       add(XK_Qabovedot,                   KeySym_Qabovedot);
02523       add(XK_Ibreve,                      KeySym_Ibreve);
02524       add(XK_IE,                          KeySym_IE);
02525       add(XK_UO,                          KeySym_UO);
02526       add(XK_Zstroke,                     KeySym_Zstroke);
02527       add(XK_Gcaron,                      KeySym_Gcaron);
02528       add(XK_Obarred,                     KeySym_Obarred);
02529       add(XK_ccedillaabovedot,            KeySym_ccedillaabovedot);
02530       add(XK_xabovedot,                   KeySym_xabovedot);
02531       add(XK_Ocaron,                      KeySym_Ocaron);
02532       add(XK_qabovedot,                   KeySym_qabovedot);
02533       add(XK_ibreve,                      KeySym_ibreve);
02534       add(XK_ie,                          KeySym_ie);
02535       add(XK_uo,                          KeySym_uo);
02536       add(XK_zstroke,                     KeySym_zstroke);
02537       add(XK_gcaron,                      KeySym_gcaron);
02538       add(XK_ocaron,                      KeySym_ocaron);
02539       add(XK_obarred,                     KeySym_obarred);
02540       add(XK_SCHWA,                       KeySym_SCHWA);
02541       add(XK_schwa,                       KeySym_schwa);
02542       // For Inupiak
02543       add(XK_Lbelowdot,                   KeySym_Lbelowdot);
02544       add(XK_Lstrokebelowdot,             KeySym_Lstrokebelowdot);
02545       add(XK_lbelowdot,                   KeySym_lbelowdot);
02546       add(XK_lstrokebelowdot,             KeySym_lstrokebelowdot);
02547       // For Guarani
02548       add(XK_Gtilde,                      KeySym_Gtilde);
02549       add(XK_gtilde,                      KeySym_gtilde);
02550 
02551 
02552       /*
02553        *   Vietnamese
02554        */
02555       add(XK_Abelowdot,                   KeySym_Abelowdot);
02556       add(XK_abelowdot,                   KeySym_abelowdot);
02557       add(XK_Ahook,                       KeySym_Ahook);
02558       add(XK_ahook,                       KeySym_ahook);
02559       add(XK_Acircumflexacute,            KeySym_Acircumflexacute);
02560       add(XK_acircumflexacute,            KeySym_acircumflexacute);
02561       add(XK_Acircumflexgrave,            KeySym_Acircumflexgrave);
02562       add(XK_acircumflexgrave,            KeySym_acircumflexgrave);
02563       add(XK_Acircumflexhook,             KeySym_Acircumflexhook);
02564       add(XK_acircumflexhook,             KeySym_acircumflexhook);
02565       add(XK_Acircumflextilde,            KeySym_Acircumflextilde);
02566       add(XK_acircumflextilde,            KeySym_acircumflextilde);
02567       add(XK_Acircumflexbelowdot,         KeySym_Acircumflexbelowdot);
02568       add(XK_acircumflexbelowdot,         KeySym_acircumflexbelowdot);
02569       add(XK_Abreveacute,                 KeySym_Abreveacute);
02570       add(XK_abreveacute,                 KeySym_abreveacute);
02571       add(XK_Abrevegrave,                 KeySym_Abrevegrave);
02572       add(XK_abrevegrave,                 KeySym_abrevegrave);
02573       add(XK_Abrevehook,                  KeySym_Abrevehook);
02574       add(XK_abrevehook,                  KeySym_abrevehook);
02575       add(XK_Abrevetilde,                 KeySym_Abrevetilde);
02576       add(XK_abrevetilde,                 KeySym_abrevetilde);
02577       add(XK_Abrevebelowdot,              KeySym_Abrevebelowdot);
02578       add(XK_abrevebelowdot,              KeySym_abrevebelowdot);
02579       add(XK_Ebelowdot,                   KeySym_Ebelowdot);
02580       add(XK_ebelowdot,                   KeySym_ebelowdot);
02581       add(XK_Ehook,                       KeySym_Ehook);
02582       add(XK_ehook,                       KeySym_ehook);
02583       add(XK_Etilde,                      KeySym_Etilde);
02584       add(XK_etilde,                      KeySym_etilde);
02585       add(XK_Ecircumflexacute,            KeySym_Ecircumflexacute);
02586       add(XK_ecircumflexacute,            KeySym_ecircumflexacute);
02587       add(XK_Ecircumflexgrave,            KeySym_Ecircumflexgrave);
02588       add(XK_ecircumflexgrave,            KeySym_ecircumflexgrave);
02589       add(XK_Ecircumflexhook,             KeySym_Ecircumflexhook);
02590       add(XK_ecircumflexhook,             KeySym_ecircumflexhook);
02591       add(XK_Ecircumflextilde,            KeySym_Ecircumflextilde);
02592       add(XK_ecircumflextilde,            KeySym_ecircumflextilde);
02593       add(XK_Ecircumflexbelowdot,         KeySym_Ecircumflexbelowdot);
02594       add(XK_ecircumflexbelowdot,         KeySym_ecircumflexbelowdot);
02595       add(XK_Ihook,                       KeySym_Ihook);
02596       add(XK_ihook,                       KeySym_ihook);
02597       add(XK_Ibelowdot,                   KeySym_Ibelowdot);
02598       add(XK_ibelowdot,                   KeySym_ibelowdot);
02599       add(XK_Obelowdot,                   KeySym_Obelowdot);
02600       add(XK_obelowdot,                   KeySym_obelowdot);
02601       add(XK_Ohook,                       KeySym_Ohook);
02602       add(XK_ohook,                       KeySym_ohook);
02603       add(XK_Ocircumflexacute,            KeySym_Ocircumflexacute);
02604       add(XK_ocircumflexacute,            KeySym_ocircumflexacute);
02605       add(XK_Ocircumflexgrave,            KeySym_Ocircumflexgrave);
02606       add(XK_ocircumflexgrave,            KeySym_ocircumflexgrave);
02607       add(XK_Ocircumflexhook,             KeySym_Ocircumflexhook);
02608       add(XK_ocircumflexhook,             KeySym_ocircumflexhook);
02609       add(XK_Ocircumflextilde,            KeySym_Ocircumflextilde);
02610       add(XK_ocircumflextilde,            KeySym_ocircumflextilde);
02611       add(XK_Ocircumflexbelowdot,         KeySym_Ocircumflexbelowdot);
02612       add(XK_ocircumflexbelowdot,         KeySym_ocircumflexbelowdot);
02613       add(XK_Ohornacute,                  KeySym_Ohornacute);
02614       add(XK_ohornacute,                  KeySym_ohornacute);
02615       add(XK_Ohorngrave,                  KeySym_Ohorngrave);
02616       add(XK_ohorngrave,                  KeySym_ohorngrave);
02617       add(XK_Ohornhook,                   KeySym_Ohornhook);
02618       add(XK_ohornhook,                   KeySym_ohornhook);
02619       add(XK_Ohorntilde,                  KeySym_Ohorntilde);
02620       add(XK_ohorntilde,                  KeySym_ohorntilde);
02621       add(XK_Ohornbelowdot,               KeySym_Ohornbelowdot);
02622       add(XK_ohornbelowdot,               KeySym_ohornbelowdot);
02623       add(XK_Ubelowdot,                   KeySym_Ubelowdot);
02624       add(XK_ubelowdot,                   KeySym_ubelowdot);
02625       add(XK_Uhook,                       KeySym_Uhook);
02626       add(XK_uhook,                       KeySym_uhook);
02627       add(XK_Uhornacute,                  KeySym_Uhornacute);
02628       add(XK_uhornacute,                  KeySym_uhornacute);
02629       add(XK_Uhorngrave,                  KeySym_Uhorngrave);
02630       add(XK_uhorngrave,                  KeySym_uhorngrave);
02631       add(XK_Uhornhook,                   KeySym_Uhornhook);
02632       add(XK_uhornhook,                   KeySym_uhornhook);
02633       add(XK_Uhorntilde,                  KeySym_Uhorntilde);
02634       add(XK_uhorntilde,                  KeySym_uhorntilde);
02635       add(XK_Uhornbelowdot,               KeySym_Uhornbelowdot);
02636       add(XK_uhornbelowdot,               KeySym_uhornbelowdot);
02637       add(XK_Ybelowdot,                   KeySym_Ybelowdot);
02638       add(XK_ybelowdot,                   KeySym_ybelowdot);
02639       add(XK_Yhook,                       KeySym_Yhook);
02640       add(XK_yhook,                       KeySym_yhook);
02641       add(XK_Ytilde,                      KeySym_Ytilde);
02642       add(XK_ytilde,                      KeySym_ytilde);
02643       add(XK_Ohorn,                       KeySym_Ohorn);
02644       add(XK_ohorn,                       KeySym_ohorn);
02645       add(XK_Uhorn,                       KeySym_Uhorn);
02646       add(XK_uhorn,                       KeySym_uhorn);
02647 
02648       add(XK_combining_tilde,             KeySym_combining_tilde);
02649       add(XK_combining_grave,             KeySym_combining_grave);
02650       add(XK_combining_acute,             KeySym_combining_acute);
02651       add(XK_combining_hook,              KeySym_combining_hook);
02652       add(XK_combining_belowdot,          KeySym_combining_belowdot);
02653 
02654 
02658       add(XK_EcuSign,                     KeySym_EcuSign);
02659       add(XK_ColonSign,                   KeySym_ColonSign);
02660       add(XK_CruzeiroSign,                KeySym_CruzeiroSign);
02661       add(XK_FFrancSign,                  KeySym_FFrancSign);
02662       add(XK_LiraSign,                    KeySym_LiraSign);
02663       add(XK_MillSign,                    KeySym_MillSign);
02664       add(XK_NairaSign,                   KeySym_NairaSign);
02665       add(XK_PesetaSign,                  KeySym_PesetaSign);
02666       add(XK_RupeeSign,                   KeySym_RupeeSign);
02667       add(XK_WonSign,                     KeySym_WonSign);
02668       add(XK_NewSheqelSign,               KeySym_NewSheqelSign);
02669       add(XK_DongSign,                    KeySym_DongSign);
02670       add(XK_EuroSign,                    KeySym_EuroSign);
02671     }
02672   }
02673 }