X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Flyxlookup.C;h=39916ed893366559d45c3e75fe4771ca26cda4ab;hb=757e2c55d8c15db0db5b4127bb3f6f22e4d7d81b;hp=8783facc013ad76d8c5a6677e2672955899b06d4;hpb=a040c0bc6f017d0591bbc7ad1aa590589dbc40ff;p=lyx.git diff --git a/src/lyxlookup.C b/src/lyxlookup.C index 8783facc01..39916ed893 100644 --- a/src/lyxlookup.C +++ b/src/lyxlookup.C @@ -4,178 +4,230 @@ * LyX, The Document Processor * * Copyright 1995 Matthias Ettrich - * Copyright 1995-1999 The LyX team. + * Copyright 1995-2001 The LyX team. * * ====================================================== */ +#ifdef __GNUG__ +#pragma implementation +#endif + #include #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 #include #include #ifdef HAVE_LOCALE_H #include #endif +#include +#include "lyxlookup.h" #include "debug.h" +#include "lyxrc.h" + +using std::endl; -static XIM xim; -static XIC xic; +namespace { + +XIM xim; +XIC xic; XComposeStatus compose_status= {0, 0}; +} // namespace anon + + // This is called after the main LyX window has been created -void InitLyXLookup(Display* display, Window window) +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 + string oldlocale = setlocale(LC_CTYPE, 0); setlocale(LC_CTYPE, ""); if (!XSupportsLocale()) { - lyxerr.debug() << "InitLyXLookup: X does not support this locale." << endl; + lyxerr[Debug::KEY] + << "InitLyXLookup: X does not support this locale." + << endl; return; - } - if (!XSetLocaleModifiers("")) { - lyxerr.debug() << "InitLyXLookup: Could not set modifiers " + } + // reset the LC_CTYPE locale to previous value. + setlocale(LC_CTYPE, oldlocale.c_str()); + + char const * locmod; + if (!(locmod = XSetLocaleModifiers(""))) { + lyxerr[Debug::KEY] << "InitLyXLookup: Could not set modifiers " "for this locale." << endl; return; } - + else + lyxerr[Debug::KEY] << "InitLyXLookup: X locale modifiers are `" + << locmod << '\'' << endl; + // This part will have to be done for each frame xim = XOpenIM (display, 0, 0, 0); if (xim) { - xic = XCreateIC (xim, - XNInputStyle, XIMPreeditNothing | XIMStatusNothing, - XNClientWindow, window, - XNFocusWindow, window, - 0); + xic = XCreateIC(xim, + XNInputStyle, + XIMPreeditNothing|XIMStatusNothing, + XNClientWindow, window, + XNFocusWindow, window, + 0); if (!xic) { - lyxerr.debug() << "InitLyXLookup: could not create " - "an input context" << endl; + lyxerr[Debug::KEY] << "InitLyXLookup: " + "could not create an input context" << endl; XCloseIM (xim); xim = 0; } } else - lyxerr.debug() << "InitLyXLookup: could not open " + lyxerr[Debug::KEY] << "InitLyXLookup: could not open " "an input method." << endl; - } -static -bool isDeadEvent(XEvent *event, - char *buffer_return, int bytes_buffer, - KeySym *keysym_return) +namespace { + +bool isDeadEvent(KeySym keysym) { - XLookupString(&event->xkey, buffer_return, - bytes_buffer, keysym_return, - 0); // 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) { #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; + } } +} // namespace anon + // This is called instead of XLookupString() -int LyXLookupString(XEvent *event, - char *buffer_return, int bytes_buffer, - KeySym *keysym_return) +int LyXLookupString(XEvent * event, + char * buffer_return, int bytes_buffer, + KeySym * keysym_return) { + if (event->type != KeyPress) { + lyxerr << "LyXLookupString: wrong event type: " + << event->type << endl; + return 0; + } + int result = 0; if (xic) { - if (isDeadEvent(event, buffer_return, bytes_buffer, - keysym_return)) { +#if 1 + // somehow it is necessary to do the lookup. Why? (JMarc) + XLookupString(&event->xkey, buffer_return, + bytes_buffer, keysym_return, + 0); + + if (lyxrc.override_x_deadkeys && + isDeadEvent(*keysym_return)) { + lyxerr[Debug::KEY] + << "LyXLookupString: found DeadEvent" << endl; return 0; } +#endif +#if 1 if (XFilterEvent (event, None)) { - //lyxerr <<"XFilterEvent"); + lyxerr[Debug::KEY] <<"XFilterEvent" << endl; *keysym_return = NoSymbol; return 0; } - if (event->type != KeyPress) - lyxerr << "LyXLookupString: wrong event type" - << event->type << endl; - Status status_return; +#endif + 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, @@ -185,13 +237,15 @@ int LyXLookupString(XEvent *event, return result; } + // This is called after the main window has been destroyed void CloseLyXLookup() { if (xic) { - lyxerr.debug() << "CloseLyXLookup: destroying input context" + lyxerr[Debug::KEY] << "CloseLyXLookup: destroying input context" << endl; XDestroyIC(xic); + xic = 0; XCloseIM(xim); } } @@ -205,16 +259,16 @@ void CloseLyXLookup() XComposeStatus compose_status= {0, 0}; // This is called after the main LyX window has been created -void InitLyXLookup(Display* , Window ) +void InitLyXLookup(Display *, Window ) { //Nothing to do. } // This is called instead of XLookupString(). I this particular case, // this *is* XLookupString... -int LyXLookupString(XEvent *event, - char *buffer_return, int bytes_buffer, - KeySym *keysym_return) +int LyXLookupString(XEvent * event, + char * buffer_return, int bytes_buffer, + KeySym * keysym_return) { return XLookupString(&event->xkey, buffer_return, bytes_buffer, keysym_return, @@ -227,5 +281,5 @@ void CloseLyXLookup() // Nothing to do } - #endif // HAVE_XOPENIM +