X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Flyxlookup.C;h=39916ed893366559d45c3e75fe4771ca26cda4ab;hb=4590c8cfab02a3bc56813cfb1f2e80bd1119af9e;hp=ee36103f3be0aa6f1ba764931153e1fcfb2ae7f6;hpb=27de1486ca34aaad446adb798d71a77d6f6304da;p=lyx.git diff --git a/src/lyxlookup.C b/src/lyxlookup.C index ee36103f3b..39916ed893 100644 --- a/src/lyxlookup.C +++ b/src/lyxlookup.C @@ -1,181 +1,233 @@ /* This file is part of -* ====================================================== -* -* LyX, The Document Processor -* -* Copyright (C) 1995 Matthias Ettrich -* Copyright (C) 1995-1998 The LyX team. -* -*======================================================*/ + * ====================================================== + * + * LyX, The Document Processor + * + * Copyright 1995 Matthias Ettrich + * 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; + +namespace { + +XIM xim; +XIC xic; +XComposeStatus compose_status= {0, 0}; -#include "error.h" +} // namespace anon -static XIM xim; -static XIC xic; -XComposeStatus compose_status={NULL,0}; // This is called after the main LyX window has been created -void InitLyXLookup(Display* display, Window window) +void InitLyXLookup(Display * display, Window window) { - xic = NULL; + xic = 0; + + lyxerr[Debug::KEY] + << "InitLyXLookup: creating an input context." + << endl; // This part could be done before opening display - setlocale(LC_CTYPE,""); + string oldlocale = setlocale(LC_CTYPE, 0); + setlocale(LC_CTYPE, ""); if (!XSupportsLocale()) { - lyxerr.debug("InitLyXLookup: X does not support this locale."); + lyxerr[Debug::KEY] + << "InitLyXLookup: X does not support this locale." + << endl; return; - } - if (!XSetLocaleModifiers("")) { - lyxerr.debug("InitLyXLookup: Could not set modifiers " - "for this locale."); + } + // 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, NULL, NULL, NULL); + xim = XOpenIM (display, 0, 0, 0); if (xim) { - xic = XCreateIC (xim, - XNInputStyle, XIMPreeditNothing | XIMStatusNothing, - XNClientWindow, window, - XNFocusWindow, window, - NULL); + xic = XCreateIC(xim, + XNInputStyle, + XIMPreeditNothing|XIMStatusNothing, + XNClientWindow, window, + XNFocusWindow, window, + 0); if (!xic) { - lyxerr.debug("InitLyXLookup: could not create " - "an input context"); + lyxerr[Debug::KEY] << "InitLyXLookup: " + "could not create an input context" << endl; XCloseIM (xim); - xim = NULL; + xim = 0; } } else - lyxerr.debug("InitLyXLookup: could not open " - "an input method."); - + 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, - NULL); // 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.print("XFilterEvent"); + lyxerr[Debug::KEY] <<"XFilterEvent" << endl; *keysym_return = NoSymbol; return 0; } - if (event->type != KeyPress) - lyxerr.print("LyXLookupString: wrong event type" - +LString(event->type)); - 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.print("XLookupBoth"); + lyxerr[Debug::KEY] << "XLookupBoth " + << string(buffer_return, result) + << endl; break; case XLookupChars: - //lyxerr.print("XLookupChars"); + lyxerr[Debug::KEY] << "XLookupChars " + << string(buffer_return, result) + << endl; + *keysym_return = NoSymbol; break; case XLookupKeySym: - //lyxerr.print("XLookupKeySym"); + lyxerr[Debug::KEY] << "XLookupKeySym" << endl; result = 0; break; - default: - //lyxerr.print("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,12 +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); } } @@ -201,19 +256,19 @@ void CloseLyXLookup() #include #include -XComposeStatus compose_status={NULL,0}; +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, @@ -226,5 +281,5 @@ void CloseLyXLookup() // Nothing to do } - #endif // HAVE_XOPENIM +