More fixes to insettabular/text (and some missing features added).

[lyx.git] / src / lyxlookup.C

diff --git a/src/lyxlookup.C b/src/lyxlookup.C
index 2d263c5ca8299593ecee2d1358a08df65cfc168d..16007c65522ce87cd8da2a757916408ec42ffc58 100644 (file)
--- a/src/lyxlookup.C
+++ b/src/lyxlookup.C
@@ -4,24 +4,32 @@
  *           LyX, The Document Processor
  *      
  *           Copyright 1995 Matthias Ettrich 
- *           Copyright 1995-1999 The LyX team.
+ *           Copyright 1995-2000 The LyX team.
  *
  * ====================================================== */
 
+#ifdef __GNUG__
+#pragma implementation
+#endif
+
 #include <config.h>
 
 #ifdef HAVE_XOPENIM
 // This part is the full blown Input Method manager for X11R5 and up.
 // For the plain-and-old-X11R4 version, see later.
-
 #include <X11/Xlib.h>
 #include <X11/Xutil.h>
 #include <X11/keysym.h>
 #ifdef HAVE_LOCALE_H
 #include <locale.h>
 #endif
+#include <clocale>
 
+#include "lyxlookup.h"
 #include "debug.h"
+#include "lyxrc.h"
+
+using std::endl;
 
 static XIM xim;
 static XIC xic;
@@ -31,7 +39,11 @@ XComposeStatus compose_status= {0, 0};
 void InitLyXLookup(Display * display, Window window) 
 {
        xic = 0;
-       
+
+       lyxerr[Debug::KEY]
+                       << "InitLyXLookup: creating an input context."
+                       << endl;
+
        // This part could be done before opening display
        setlocale(LC_CTYPE, "");
                if (!XSupportsLocale()) {
@@ -76,63 +88,69 @@ bool isDeadEvent(XEvent * event,
        XLookupString(&event->xkey, buffer_return,
                      bytes_buffer, keysym_return,
                      0);
+
+       // somehow it is necessary to do the lookup. Why? (JMarc)
+       if (!lyxrc.override_x_deadkeys)
+               return false;
+
        // Can this be done safely in any other way?
        // This is all the dead keys I know of in X11R6.1
-       if (false
+       switch (*keysym_return) {
 #ifdef XK_dead_grave
-           || *keysym_return == XK_dead_grave
+       case XK_dead_grave:
 #endif
 #ifdef XK_dead_acute
-           || *keysym_return == XK_dead_acute
+       case XK_dead_acute:
 #endif
 #ifdef XK_dead_circumflex
-           || *keysym_return == XK_dead_circumflex
+       case XK_dead_circumflex:
 #endif
 #ifdef XK_dead_tilde
-           || *keysym_return == XK_dead_tilde
+       case XK_dead_tilde:
 #endif
 #ifdef XK_dead_macron
-           || *keysym_return == XK_dead_macron
+       case XK_dead_macron:
 #endif
 #ifdef XK_dead_breve
-           || *keysym_return == XK_dead_breve
+       case XK_dead_breve:
 #endif
 #ifdef XK_dead_abovedot
-           || *keysym_return == XK_dead_abovedot
+       case XK_dead_abovedot:
 #endif
 #ifdef XK_dead_diaeresis
-           || *keysym_return == XK_dead_diaeresis
+       case XK_dead_diaeresis:
 #endif
 #ifdef XK_dead_abovering
-           || *keysym_return == XK_dead_abovering
+       case XK_dead_abovering:
 #endif
 #ifdef XK_dead_doubleacute
-           || *keysym_return == XK_dead_doubleacute
+       case XK_dead_doubleacute:
 #endif
 #ifdef XK_dead_caron
-           || *keysym_return == XK_dead_caron
+       case XK_dead_caron:
 #endif
 #ifdef XK_dead_cedilla
-           || *keysym_return == XK_dead_cedilla
+       case XK_dead_cedilla:
 #endif
 #ifdef XK_dead_ogonek
-           || *keysym_return == XK_dead_ogonek
+       case XK_dead_ogonek:
 #endif
 #ifdef XK_dead_iota
-           || *keysym_return == XK_dead_iota
+       case XK_dead_iota:
 #endif
 #ifdef XK_dead_voiced_sound
-           || *keysym_return == XK_dead_voiced_sound
+       case XK_dead_voiced_sound:
 #endif
 #ifdef XK_dead_semivoiced_sound
-           || *keysym_return == XK_dead_semivoiced_sound
+       case XK_dead_semivoiced_sound:
 #endif
 #ifdef XK_dead_belowdot
-           || *keysym_return == XK_dead_belowdot
+       case XK_dead_belowdot:
 #endif
-           )
                return true;
-       return false;
+       default:
+               return false;
+       }
 }
 
 
@@ -144,39 +162,55 @@ int LyXLookupString(XEvent * event,
        int result = 0;
        if (xic) {
                if (isDeadEvent(event, buffer_return, bytes_buffer,
-                                keysym_return)) {
+                               keysym_return)) {
+                       lyxerr[Debug::KEY]  
+                               << "LyXLookupString: found DeadEvent" << endl;
                        return 0;
                }
+#if 1
                if (XFilterEvent (event, None)) {
-                       //lyxerr <<"XFilterEvent");
+                       lyxerr[Debug::KEY] <<"XFilterEvent" << endl;
                        *keysym_return = NoSymbol;
                         return 0;
                }
+#endif
                if (event->type != KeyPress)
                        lyxerr << "LyXLookupString: wrong event type" 
                               <<  event->type << endl;
-               Status status_return;
+               Status status_return = 0;
                
                result =  XmbLookupString(xic, &event->xkey, buffer_return,
                                       bytes_buffer, keysym_return,
                                       &status_return);
-               switch(status_return) {
+               switch (status_return) {
+               case XBufferOverflow:
+                       lyxerr[Debug::KEY] << "XBufferOverflow" << endl;
+                       break;
                case XLookupBoth:
-                       //lyxerr <<"XLookupBoth");
+                       lyxerr[Debug::KEY] << "XLookupBoth "
+                                          << string(buffer_return, result)
+                                          << endl;
                        break;
                case XLookupChars:
-                       //lyxerr <<"XLookupChars");
+                       lyxerr[Debug::KEY] << "XLookupChars "
+                                          << string(buffer_return, result)
+                                          << endl;
+                       
                        *keysym_return = NoSymbol;
                        break;
                case XLookupKeySym:
-                       //lyxerr <<"XLookupKeySym");
+                       lyxerr[Debug::KEY] << "XLookupKeySym" << endl;
                        result = 0;
                        break;
-               default:
-                       //lyxerr <<"default");
+               case XLookupNone:
+                       lyxerr[Debug::KEY] << "XLookupNone" << endl;
                        *keysym_return = NoSymbol;
                        result = 0;
                        break;
+               default:
+                       lyxerr << "Unknown status_return from"
+                               " XmbLookupString" << endl;
+                       break;
                }
        } else {
                result = XLookupString(&event->xkey, buffer_return,
@@ -186,6 +220,7 @@ int LyXLookupString(XEvent * event,
        return result;
 }
 
+
 // This is called after the main window has been destroyed
 void CloseLyXLookup() 
 {
@@ -193,6 +228,7 @@ void CloseLyXLookup()
                lyxerr[Debug::KEY] << "CloseLyXLookup: destroying input context"
                               << endl;
                XDestroyIC(xic);
+               xic = 0;
                XCloseIM(xim);
        }
 }
@@ -229,3 +265,4 @@ void CloseLyXLookup()
 }
 
 #endif // HAVE_XOPENIM
+