Merge lp:~yuningdodo/nux/im-interface into lp:~wengxt/nux/fcitx-support

[Yu Ning]

Hi wengxt,

I had merged the XIM patches from lp:~paulliu/nux/nux and lp:~yuningdodo/nux/xim-preedit to your branch. However the initialize and events handling of XIM are still done in GraphicsDisplayX11. Further split of the code requires me to get more knowledge on X, this would take some time.

Please review my patch and ask me to improve it.

Thanks.
Yu Ning

By the way, I still think it is not quite suitable to add fcitx support inside nux, it would be much better if we build the fcitx code outside nux, but this would need nux to provide the ability to scan & load plugins, which should be discussed further with the nux-team.

[csslayer (wengxt)]

Well, I just pushed a new version to my branch, you can take a look at it, I change the InputMethod to a global one instead of "per" text entry, this is the idea used by most of the toolkit including gtk and qt. And it would be more easy to implement XIM support (Since XIM is global).

And one hint, Nux provide a x11Event filter, thus when InputMethodXim constructs, it can register a new filter and call "XFilterEvent" in the registered filter.

And so we can move all function into InputMethodXim, ProcessKeyEvent can simple return false for InputMethodXim, that's Ok.

As for fcitx support, we should move all separte support outside (including XIM, ibus), it's not hard to do this, the things need to be done before we move it out are
1. implementing xim support better,
2. remove the "friend class", and expose more interface for TextEntry.

[lp:~yuningdodo/nux/im-interface]

631. By Yu Ning on 2012-07-19

Move XIM events handling from GraphicsDisplayX11 to InputMethodXim.

We also:
* Add implement of InputMethodXim::UpdateCursorLocation().
* Add some error checking in XimClientData.

632. By Yu Ning on 2012-07-19

Move XFilterEvent() from GraphicsDisplayX11 to InputMethodXim.

633. By Yu Ning on 2012-07-19

Merge from lp:~wengxt/nux/fcitx-support

634. By Yu Ning on 2012-07-19

Seperate Xim from GraphicsDisplayX11 completely.

[Yu Ning (yuningdodo)]

Hi csslayer,

Thanks for your hint about the x11 event filter, and your work to make the im single-instance.

I had just updated my branch, separate xim stuff from GraphicsDisplayX11 completely. However I didn't mix XimClientData into XimIMEContext to keep the code clean.

Please review again.

Many thanks.
Yu Ning

review: Approve

[lp:~yuningdodo/nux/im-interface]

635. By Yu Ning on 2012-07-20

Provide wchar support in XIM callbacks.

We also optimize the preedit-string handling by reduce unnecessary string copy.

[csslayer (wengxt)]

Sorry for late, I'm out for travel last week.

Looks good for me.

review: Approve

[Yu Ning (yuningdodo)]

Hi csslayer,

Welcome back. Thanks for approving the branch. Hopes your branch can be finally merged into the main branch.

=== modified file 'Nux/InputMethod.cpp'
--- Nux/InputMethod.cpp	2012-07-18 17:44:33 +0000
+++ Nux/InputMethod.cpp	2012-07-20 05:33:28 +0000
@@ -26,6 +26,7 @@
 #include "InputMethod.h"
 #include "InputMethodIBus.h"
 #include "InputMethodFcitx.h"
+#include "InputMethodXim.h"
 
 namespace nux
 {
@@ -71,6 +72,10 @@
        global_context_ = new IBusIMEContext();
      else if (g_strcmp0(im, "fcitx") == 0)
        global_context_ = new FcitxIMEContext();
+     else if (g_strcmp0(im, "xim") == 0)
+       global_context_ = new XimIMEContext();
+     else if (g_getenv("XMODIFIERS"))
+       global_context_ = new XimIMEContext();
      else
        global_context_ = NULL;
 //       global_context_ = XimIMEContext();

=== added file 'Nux/InputMethodXim.cpp'
--- Nux/InputMethodXim.cpp	1970-01-01 00:00:00 +0000
+++ Nux/InputMethodXim.cpp	2012-07-20 05:33:28 +0000
@@ -0,0 +1,202 @@
+/*
+* Copyright 2010 Inalogic® Inc.
+*
+* This program is free software: you can redistribute it and/or modify it
+* under the terms of the GNU Lesser General Public License, as
+* published by the  Free Software Foundation; either version 2.1 or 3.0
+* of the License.
+*
+* This program is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranties of
+* MERCHANTABILITY, SATISFACTORY QUALITY or FITNESS FOR A PARTICULAR
+* PURPOSE.  See the applicable version of the GNU Lesser General Public
+* License for more details.
+*
+* You should have received a copy of both the GNU Lesser General Public
+* License along with this program. If not, see <http://www.gnu.org/licenses/>
+*
+* Authored by: Weng Xuetian <[e-mail]>
+*              Yu Ning <[e-mail]>
+*
+*/
+
+#include "Nux.h"
+
+#include "InputMethodXim.h"
+
+namespace nux
+{
+  extern unsigned int GetModifierKeyState(unsigned int);
+
+  XimIMEContext::XimIMEContext()
+    : IMEContext()
+  {
+    // XIM support
+    memset(&m_ximData,0,sizeof(m_ximData));
+    m_ximData.window = nux::GetGraphicsDisplay()->GetWindowHandle();
+    m_ximData.display = nux::GetGraphicsDisplay()->GetX11Display();
+    m_ximData.InitXIM();
+
+    long im_event_mask=0;
+    if (m_ximData.m_xic)
+    {
+      XGetICValues(m_ximData.m_xic, XNFilterEvents, &im_event_mask, NULL);
+      nux::GetGraphicsDisplay()->m_X11Attr.event_mask |= im_event_mask;
+    }
+
+    event_filter_.filter = XimIMEContext::XEventFilter;
+    event_filter_.data = this;
+    nux::GetGraphicsDisplay()->AddEventFilter(event_filter_);
+
+    // todo(csslayer) forward key, surrounding text
+  }
+
+  XimIMEContext::~XimIMEContext()
+  {
+    nux::GetGraphicsDisplay()->RemoveEventFilter(this);
+    m_ximData.UninitXIM();
+
+    TextEntry* text_entry = FocusWidget();
+    if (!text_entry)
+      return;
+    text_entry->ResetPreedit();
+  }
+
+  void XimIMEContext::SetFocusWidget(TextEntry* text_entry)
+  {
+    TextEntry* old_entry_ = FocusWidget();
+
+    if (old_entry_ == text_entry)
+      return;
+
+    if (old_entry_)
+    {
+      old_entry_->ime_active_ = false;
+      if (IsConnected())
+        m_ximData.XICUnFocus(old_entry_);
+    }
+
+    IMEContext::SetFocusWidget(text_entry);
+
+    bool has_focus = (text_entry != NULL);
+
+    if (!IsConnected())
+      return;
+
+    if (has_focus)
+    {
+      text_entry->ime_active_ = true;
+      m_ximData.XICFocus(text_entry);
+    }
+    else
+    {
+      m_ximData.XICUnFocus(text_entry);
+    }
+  }
+
+  void XimIMEContext::Reset()
+  {
+    if (IsConnected())
+      m_ximData.Reset();
+  }
+
+  bool XimIMEContext::FilterKeyEvent(const KeyEvent& event)
+  {
+    return false;
+  }
+
+  void XimIMEContext::SetSurrounding(const std::wstring& text, int cursor_pos)
+  {
+    // TODO(penghuang) support surrounding
+  }
+
+  bool XimIMEContext::IsConnected() const
+  {
+    return !!m_ximData.m_xic;
+  }
+
+  void XimIMEContext::UpdateCursorLocation()
+  {
+    nux::Rect strong, weak;
+    TextEntry* text_entry = FocusWidget();
+    if (!text_entry)
+      return;
+    text_entry->GetCursorRects(&strong, &weak);
+
+    // Get the position of the TextEntry in the Window.
+    nux::Geometry geo = text_entry->GetAbsoluteGeometry();
+
+    // Get the Geometry of the window on the display.
+    nux::Geometry window_geo = nux::GetGraphicsDisplay()->GetWindowGeometry();
+
+    if (IsConnected())
+      m_ximData.SetCursorLocation(geo.x + window_geo.x + strong.x, geo.y + window_geo.y, 0, 0);
+  }
+
+  bool XimIMEContext::XEventFilter(XEvent xevent, void * data)
+  {
+    XimIMEContext *context = (XimIMEContext*)data;
+    GraphicsDisplay *graphics_display = nux::GetGraphicsDisplay();
+    Event *m_pEvent = graphics_display->m_pEvent;
+
+    if (!context->IsConnected() || !context->m_ximData.textentry)
+      return false;
+
+    if (XFilterEvent(&xevent, None) == True)
+      return true;
+
+    switch(xevent.type)
+    {
+      case KeyPress:
+      {
+        //nuxDebugMsg("[InputMethodXim::XEventFilter]: KeyPress event.");
+        KeyCode keycode = xevent.xkey.keycode;
+        KeySym keysym = NoSymbol;
+        keysym = XKeycodeToKeysym(xevent.xany.display, keycode, 0);
+
+        m_pEvent->key_modifiers = GetModifierKeyState(xevent.xkey.state);
+        m_pEvent->key_repeat_count = 0;
+        m_pEvent->x11_keysym = keysym;
+        m_pEvent->x11_keycode = xevent.xkey.keycode;
+        m_pEvent->type = NUX_KEYDOWN;
+        m_pEvent->x11_timestamp = xevent.xkey.time;
+        m_pEvent->x11_key_state = xevent.xkey.state;
+
+        char buffer[NUX_EVENT_TEXT_BUFFER_SIZE];
+        Memset(m_pEvent->text, 0, NUX_EVENT_TEXT_BUFFER_SIZE);
+
+        bool skip = false;
+        if ((keysym == NUX_VK_BACKSPACE) ||
+            (keysym == NUX_VK_DELETE) ||
+            (keysym == NUX_VK_ESCAPE))
+        {
+          //temporary fix for TextEntry widget: filter some keys
+         skip = true; 
+        }
+        
+        int num_char_stored = XmbLookupString(context->m_ximData.m_xic, &xevent.xkey, buffer, NUX_EVENT_TEXT_BUFFER_SIZE, (KeySym*) &m_pEvent->x11_keysym, NULL);
+        if (num_char_stored && (!skip))
+        {
+          Memcpy(m_pEvent->text, buffer, num_char_stored);
+        }
+
+        return true;
+      }
+      default:
+      {
+        break;
+      }
+    }
+
+    return false;
+  }
+
+  bool XimIMEContext::IsHotkeyEvent(EventType type, unsigned long keysym, unsigned long modifiers) const
+  {
+    return false;
+  }
+
+  bool XimIMEContext::IsIgnoredKey(unsigned long keysym, unsigned long modifiers) const {
+    return false;
+  }
+}

=== added file 'Nux/InputMethodXim.h'
--- Nux/InputMethodXim.h	1970-01-01 00:00:00 +0000
+++ Nux/InputMethodXim.h	2012-07-20 05:33:28 +0000
@@ -0,0 +1,69 @@
+/*
+* Copyright 2010 Inalogic® Inc.
+*
+* This program is free software: you can redistribute it and/or modify it
+* under the terms of the GNU Lesser General Public License, as
+* published by the  Free Software Foundation; either version 2.1 or 3.0
+* of the License.
+*
+* This program is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranties of
+* MERCHANTABILITY, SATISFACTORY QUALITY or FITNESS FOR A PARTICULAR
+* PURPOSE.  See the applicable version of the GNU Lesser General Public
+* License for more details.
+*
+* You should have received a copy of both the GNU Lesser General Public
+* License along with this program. If not, see <http://www.gnu.org/licenses/>
+*
+* Authored by: Weng Xuetian <[e-mail]>
+*              Yu Ning <[e-mail]>
+*
+*/
+
+
+#ifndef INPUTMETHODXIM_H
+#define INPUTMETHODXIM_H
+
+#include <Nux/InputMethod.h>
+#include <Nux/XimClientData.h>
+
+namespace nux
+{
+
+  class XimIMEContext;
+  class TextEntry;
+
+  // Implements IMEContext to support XIM protocol
+  class XimIMEContext : public IMEContext
+  {
+  public:
+    explicit XimIMEContext();
+    virtual ~XimIMEContext();
+
+    // views::IMEContext implementations:
+    virtual void SetFocusWidget(TextEntry* text_entry);
+    virtual void Reset();
+    virtual bool FilterKeyEvent(const KeyEvent& event);
+    virtual void SetSurrounding(const std::wstring& text, int cursor_pos);
+
+    virtual bool IsConnected() const;
+    virtual bool IsHotkeyEvent(EventType type, unsigned long keysym, unsigned long modifiers) const;
+    virtual bool IsIgnoredKey(unsigned long keysym, unsigned long modifiers) const;
+
+  protected:
+  private:
+    void UpdateCursorLocation();
+
+    static bool XEventFilter(XEvent xevent, void * data);
+
+    struct XimClientData m_ximData;
+    GraphicsDisplay::EventFilterArg event_filter_;
+    bool is_focused_;
+    
+    XimIMEContext(const XimIMEContext&);
+    void operator = (const XimIMEContext&);
+  };
+
+}
+#endif  // INPUTMETHODXIM_H
+

=== modified file 'Nux/Makefile.am'
--- Nux/Makefile.am	2012-07-10 01:39:06 +0000
+++ Nux/Makefile.am	2012-07-20 05:33:28 +0000
@@ -99,6 +99,7 @@
   $(srcdir)/InputMethod.cpp \
   $(srcdir)/InputMethodIBus.cpp \
   $(srcdir)/InputMethodFcitx.cpp \
+  $(srcdir)/InputMethodXim.cpp \
   $(srcdir)/TextLoader.cpp \
   $(srcdir)/TextureArea.cpp \
   $(srcdir)/Timeline.cpp \
@@ -114,7 +115,8 @@
   $(srcdir)/VSplitter.cpp \
   $(srcdir)/WidgetMetrics.cpp \
   $(srcdir)/WindowCompositor.cpp \
-  $(srcdir)/WindowThread.cpp
+  $(srcdir)/WindowThread.cpp \
+  $(srcdir)/XimClientData.cpp
 
 source_h = \
   $(builddir)/ABI.h \
@@ -188,6 +190,7 @@
   $(srcdir)/InputMethod.h \
   $(srcdir)/InputMethodIBus.h \
   $(srcdir)/InputMethodFcitx.h \
+  $(srcdir)/InputMethodXim.h \
   $(srcdir)/TextLoader.h \
   $(srcdir)/TextureArea.h \
   $(srcdir)/Timeline.h \
@@ -203,7 +206,8 @@
   $(srcdir)/VSplitter.h \
   $(srcdir)/WidgetMetrics.h \
   $(srcdir)/WindowCompositor.h \
-  $(srcdir)/WindowThread.h
+  $(srcdir)/WindowThread.h \
+  $(srcdir)/XimClientData.h
 
 nuxprogramframework_cpp = \
   $(srcdir)/ProgramFramework/ProgramTemplate.cpp \

=== modified file 'Nux/TextEntry.h'
--- Nux/TextEntry.h	2012-07-17 17:38:14 +0000
+++ Nux/TextEntry.h	2012-07-20 05:33:28 +0000
@@ -479,6 +479,8 @@
     friend class IMEContext;
     friend class IBusIMEContext;
     friend class FcitxIMEContext;
+    friend class XimIMEContext;
+    friend struct XimClientData;
 #endif
 
     bool ime_active_;

=== added file 'Nux/XimClientData.cpp'
--- Nux/XimClientData.cpp	1970-01-01 00:00:00 +0000
+++ Nux/XimClientData.cpp	2012-07-20 05:33:28 +0000
@@ -0,0 +1,524 @@
+/*
+* Copyright 2010 Inalogic® Inc.
+*
+* This program is free software: you can redistribute it and/or modify it
+* under the terms of the GNU Lesser General Public License, as
+* published by the  Free Software Foundation; either version 2.1 or 3.0
+* of the License.
+*
+* This program is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranties of
+* MERCHANTABILITY, SATISFACTORY QUALITY or FITNESS FOR A PARTICULAR
+* PURPOSE.  See the applicable version of the GNU Lesser General Public
+* License for more details.
+*
+* You should have received a copy of both the GNU Lesser General Public
+* License along with this program. If not, see <http://www.gnu.org/licenses/>
+*
+* Authored by: Ying-Chun Liu <[e-mail]>
+*              Yu Ning <[e-mail]>
+*
+*/
+
+#include "Nux.h"
+#include "TextEntry.h"
+
+#include "XimClientData.h"
+
+namespace nux
+{
+
+#define PREEDIT_MASK (XIMPreeditCallbacks | XIMPreeditPosition | \
+                      XIMPreeditArea | XIMPreeditNothing | XIMPreeditNone)
+#define STATUS_MASK (XIMStatusCallbacks | XIMStatusArea | \
+                     XIMStatusNothing | XIMStatusNone)
+#define ALLOWED_MASK (XIMPreeditCallbacks | XIMPreeditNothing | XIMPreeditNone | \
+                      XIMStatusCallbacks | XIMStatusNothing | XIMStatusNone)
+
+  /* stolen from gtk+2.24.4/modules/input/gtkimcontextxim.c */
+  static XIMStyle 
+  choose_better_style (XIMStyle style1, XIMStyle style2) 
+  {
+    XIMStyle s1, s2, u; 
+    
+    if (style1 == 0) return style2;
+    if (style2 == 0) return style1;
+    if ((style1 & (PREEDIT_MASK | STATUS_MASK))
+          == (style2 & (PREEDIT_MASK | STATUS_MASK)))
+      return style1;
+
+    s1 = style1 & PREEDIT_MASK;
+    s2 = style2 & PREEDIT_MASK;
+    u = s1 | s2;
+    if (s1 != s2) {
+      if (u & XIMPreeditCallbacks)
+        return (s1 == XIMPreeditCallbacks) ? style1 : style2;
+      else if (u & XIMPreeditPosition)
+        return (s1 == XIMPreeditPosition) ? style1 :style2;
+      else if (u & XIMPreeditArea)
+        return (s1 == XIMPreeditArea) ? style1 : style2;
+      else if (u & XIMPreeditNothing)
+        return (s1 == XIMPreeditNothing) ? style1 : style2;
+      else if (u & XIMPreeditNone)
+        return (s1 == XIMPreeditNone) ? style1 : style2;
+    } else {
+      s1 = style1 & STATUS_MASK;
+      s2 = style2 & STATUS_MASK;
+      u = s1 | s2;
+      if (u & XIMStatusCallbacks)
+        return (s1 == XIMStatusCallbacks) ? style1 : style2;
+      else if (u & XIMStatusArea)
+        return (s1 == XIMStatusArea) ? style1 : style2;
+      else if (u & XIMStatusNothing)
+        return (s1 == XIMStatusNothing) ? style1 : style2;
+      else if (u & XIMStatusNone)
+        return (s1 == XIMStatusNone) ? style1 : style2;
+    }
+    return 0; /* Get rid of stupid warning */
+  }
+
+/* Mask of feedback bits that we render
+ */
+#define FEEDBACK_MASK (XIMReverse | XIMUnderline)
+
+  /* stolen from gtk+2.24.4/modules/input/gtkimcontextxim.c */
+  static void
+  add_feedback_attr (PangoAttrList *attrs,
+                     const gchar   *str,
+                     XIMFeedback    feedback,
+                     gint           start_pos,
+                     gint           end_pos)
+  {
+    PangoAttribute *attr;
+    
+    gint start_index = g_utf8_offset_to_pointer (str, start_pos) - str;
+    gint end_index = g_utf8_offset_to_pointer (str, end_pos) - str;
+
+    if (feedback & XIMUnderline)
+      {
+        attr = pango_attr_underline_new (PANGO_UNDERLINE_SINGLE);
+        attr->start_index = start_index;
+        attr->end_index = end_index;
+
+        pango_attr_list_change (attrs, attr);
+      }
+
+    if (feedback & XIMReverse)
+      {
+        attr = pango_attr_foreground_new (0xffff, 0xffff, 0xffff);
+        attr->start_index = start_index;
+        attr->end_index = end_index;
+
+        pango_attr_list_change (attrs, attr);
+
+        attr = pango_attr_background_new (0, 0, 0);
+        attr->start_index = start_index;
+        attr->end_index = end_index;
+
+        pango_attr_list_change (attrs, attr);
+      }
+
+    if (feedback & ~FEEDBACK_MASK)
+      g_warning ("Unrendered feedback style: %#lx", feedback & ~FEEDBACK_MASK);
+  }
+
+  /* derived from gtk+2.24.4/modules/input/gtkimcontextxim.c: gtk_im_context_xim_get_preedit_string() */
+  static void
+  feedbacks_to_pango_attr_list(PangoAttrList **attrs,
+                               const char     *utf8,
+                               int             nfeedbacks,
+                               XIMFeedback    *feedbacks)
+  {
+    int i;
+    XIMFeedback last_feedback = 0;
+    gint start = -1;
+    
+    if (attrs)
+      {
+        *attrs = pango_attr_list_new ();
+
+        for (i = 0; i < nfeedbacks; i++)
+          {
+            XIMFeedback new_feedback = feedbacks[i] & FEEDBACK_MASK;
+            if (new_feedback != last_feedback)
+              {
+                if (start >= 0)
+                  add_feedback_attr (*attrs, utf8, last_feedback, start, i);
+                
+                last_feedback = new_feedback;
+                start = i;
+              }
+          }
+
+        if (start >= 0)
+          add_feedback_attr (*attrs, utf8, last_feedback, start, i);
+      }
+  }
+
+  void XimClientData::InitXIM()
+  {
+#if 0
+    const char *xmodifier;
+
+    /* don't do anything if we are using ibus */
+    xmodifier = getenv("XMODIFIERS");
+    if (xmodifier && strstr(xmodifier,"ibus") != NULL)
+    {
+      nuxDebugMsg("[XimClientData::InitXIM] ibus natively supported");
+      return;
+    }
+#endif
+
+    if (setlocale(LC_ALL, "") == NULL)
+    {
+      nuxDebugMsg("[XimClientData::InitXIM] cannot setlocale");
+    }
+
+    if (!XSupportsLocale())
+    {
+      nuxDebugMsg("[XimClientData::InitXIM] no supported locale");
+    }
+
+    if (XSetLocaleModifiers("") == NULL)
+    {
+      nuxDebugMsg("[XimClientData::InitXIM] XSetLocaleModifiers failed.");
+    }
+
+    if (!XRegisterIMInstantiateCallback(this->display, NULL, NULL, NULL, XimClientData::XIMStartCallback, (XPointer)(this)))
+    {
+      nuxDebugMsg("[XimClientData::InitXIM] Cannot Register IM Init callback");
+    }
+  }
+
+  void XimClientData::UninitXIM()
+  {
+    XUnregisterIMInstantiateCallback(this->display, NULL, NULL, NULL,
+        XimClientData::XIMStartCallback, (XPointer)(this));
+  }
+
+  /* derived from gtk+2.24.4/modules/input/gtkimcontextxim.c: gtk_im_context_xim_reset() */
+  void XimClientData::Reset()
+  {
+    XIC ic = this->m_xic;
+    gchar *result;
+
+    /* restore conversion state after resetting ic later */
+    XIMPreeditState preedit_state = XIMPreeditUnKnown;
+    XVaNestedList preedit_attr;
+    gboolean have_preedit_state = FALSE;
+
+    if (!ic)
+      return;
+    
+
+    preedit_attr = XVaCreateNestedList(0,
+                                       XNPreeditState, &preedit_state,
+                                       NULL);
+    if (!XGetICValues(ic,
+                      XNPreeditAttributes, preedit_attr,
+                      NULL))
+      have_preedit_state = TRUE;
+
+    XFree(preedit_attr);
+
+    result = XmbResetIC (ic);
+
+    preedit_attr = XVaCreateNestedList(0,
+                                       XNPreeditState, preedit_state,
+                                       NULL);
+    if (have_preedit_state)
+      XSetICValues(ic,
+                   XNPreeditAttributes, preedit_attr,
+                   NULL);
+
+    XFree(preedit_attr);
+
+    XFree (result);
+  }
+
+  void XimClientData::XICFocus(TextEntry *textentry)
+  {
+    if (this->m_xic)
+    {
+      XSetICFocus(this->m_xic);
+      this->focus_stat=1;
+      this->textentry = textentry;
+    }
+  }
+
+  void XimClientData::XICUnFocus(TextEntry *textentry)
+  {
+    if (this->m_xic)
+    {
+      nuxAssert(this->textentry == textentry);
+      XUnsetICFocus(this->m_xic);
+      this->focus_stat=0;
+      this->textentry = NULL;
+    }
+  }
+
+  /* derived from gtk+2.24.4/modules/input/gtkimcontextxim.c: gtk_im_context_xim_set_cursor_location() */
+  void XimClientData::SetCursorLocation(int x, int y, int width, int height)
+  {
+    XIC ic = this->m_xic;
+
+    XVaNestedList preedit_attr;
+    XPoint          spot;
+
+    spot.x = x;
+    spot.y = y;
+
+    preedit_attr = XVaCreateNestedList (0,
+                                        XNSpotLocation, &spot,
+                                        NULL);
+    XSetICValues (ic,
+                  XNPreeditAttributes, preedit_attr,
+                  NULL);
+    XFree(preedit_attr);
+  }
+
+  void XimClientData::XIMEndCallback(Display *dpy, XPointer client_data, XPointer call_data)
+  {
+    struct XimClientData *data;
+
+    data = (struct XimClientData*)client_data;
+    data->m_xim = NULL;
+    data->m_xic = NULL;
+    data->textentry = NULL;
+  }
+
+  void XimClientData::XIMStartCallback(Display *dpy, XPointer client_data, XPointer call_data)
+  {
+    int i;
+    XIMCallback destroy;
+    XIMStyles *xim_styles = NULL;
+    XIMStyle root_style = (XIMPreeditNothing|XIMStatusNothing);
+    XIMStyle preferred_style = (XIMPreeditCallbacks|XIMStatusCallbacks);
+    XIMStyle choosed_style = 0;
+    XIMStyle im_style = 0;
+    const char * name1 = NULL;
+    XVaNestedList list1 = NULL;
+    const char * name2 = NULL;
+    XVaNestedList list2 = NULL;
+    Window win;
+    struct XimClientData *data;
+
+    data = (struct XimClientData*)client_data;
+    win = data->window;
+
+    data->m_xim = XOpenIM(dpy, NULL, NULL, NULL);
+    if (! (data->m_xim))
+    {
+      nuxDebugMsg("[XimClientData::XIMStartCallback] Failed to open IM.");
+      return;
+    }
+    memset(&destroy, 0, sizeof(destroy));
+    destroy.callback = (XIMProc)((XimClientData::XIMEndCallback));
+    destroy.client_data = (XPointer)data;
+    XSetIMValues((data->m_xim), XNDestroyCallback, &destroy, NULL);
+    XGetIMValues((data->m_xim), XNQueryInputStyle, &xim_styles, NULL);
+    for (i=0; i<xim_styles->count_styles; i++)
+    {
+      if (preferred_style == xim_styles->supported_styles[i])
+      {
+        choosed_style = preferred_style;
+        break;
+      }
+      choosed_style = choose_better_style(choosed_style,
+          xim_styles->supported_styles[i]);
+    }
+
+    if (choosed_style == 0)
+    {
+      for (i=0; i<xim_styles->count_styles; i++)
+      {
+        if (xim_styles->supported_styles[i] == root_style)
+        {
+          break;
+        }
+      }
+      if (i>=xim_styles->count_styles)
+      {
+        nuxDebugMsg("[XimClientData::XIMStartCallback] root styles not supported.");
+        return;
+      }
+      im_style = root_style;
+    }
+
+    if ((choosed_style & PREEDIT_MASK) == XIMPreeditCallbacks)
+    {
+      XIMCallback preedit_start;
+      XIMCallback preedit_done;
+      XIMCallback preedit_draw;
+      XIMCallback preedit_caret;
+
+      preedit_start.callback = (XIMProc)((XimClientData::XIMPreeditStartCallback));
+      preedit_start.client_data = (XPointer)data;
+      preedit_done.callback = (XIMProc)((XimClientData::XIMPreeditDoneCallback));
+      preedit_done.client_data = (XPointer)data;
+      preedit_draw.callback = (XIMProc)((XimClientData::XIMPreeditDrawCallback));
+      preedit_draw.client_data = (XPointer)data;
+      preedit_caret.callback = (XIMProc)((XimClientData::XIMPreeditCaretCallback));
+      preedit_caret.client_data = (XPointer)data;
+
+      name1 = XNPreeditAttributes;
+      list1 = XVaCreateNestedList(0,
+          XNPreeditStartCallback, &preedit_start,
+          XNPreeditDoneCallback, &preedit_done,
+          XNPreeditDrawCallback, &preedit_draw,
+          XNPreeditCaretCallback, &preedit_caret,
+          NULL);
+
+      im_style |= XIMPreeditCallbacks;
+    }
+    else if ((choosed_style & PREEDIT_MASK) == XIMPreeditNone)
+    {
+      im_style |= XIMPreeditNone;
+    }
+    else
+    {
+      im_style |= XIMPreeditNothing;
+    }
+
+#if 0
+    if ((choosed_style & STATUS_MASK) == XIMStatusCallbacks)
+    {
+      XIMCallback status_start;
+      XIMCallback status_done;
+      XIMCallback status_draw;
+
+      status_start.callback = (XIMProc)((XimClientData::XIMStatusStartCallback));
+      status_start.client_data = (XPointer)data;
+      status_done.callback = (XIMProc)((XimClientData::XIMStatusDoneCallback));
+      status_done.client_data = (XPointer)data;
+      status_draw.callback = (XIMProc)((XimClientData::XIMStatusDrawCallback));
+      status_draw.client_data = (XPointer)data;
+
+      name2 = XNStatusAttributes;
+      list2 = XVaCreateNestedList(0,
+          XNStatusStartCallback, &status_start,
+          XNStatusDoneCallback, &status_done,
+          XNStatusDrawCallback, &status_draw,
+          NULL);
+
+      im_style |= XIMStatusCallbacks;
+    }
+    else if ((choosed_style & STATUS_MASK) == XIMStatusNone)
+    {
+      im_style |= XIMStatusNone;
+    }
+    else
+    {
+      im_style |= XIMStatusNothing;
+    }
+#endif
+
+    if (name2 && !name1)
+    {
+      name1 = name2;
+      list1 = list2;
+      name2 = NULL;
+      list2 = NULL;
+    }
+
+    data->m_xic = XCreateIC(data->m_xim,
+        XNInputStyle, im_style,
+        XNClientWindow, win,
+        XNFocusWindow, win,
+        name1, list1,
+        name2, list2,
+        NULL);
+    if (!(data->m_xic))
+    {
+      nuxDebugMsg("[XimClientData::XIMStartCallback] failed to register xic");
+    }
+
+    /* TODO: string conversion support */
+
+    if (list1)
+      XFree(list1);
+    if (list2)
+      XFree(list2);
+
+    return;
+  }
+
+  int XimClientData::XIMPreeditStartCallback(XIC xic, XPointer client_data, XPointer call_data)
+  {
+    return -1; /* No Length Limit */
+  }
+
+  void XimClientData::XIMPreeditDoneCallback(XIC xic, XPointer client_data, XPointer call_data)
+  {
+    struct XimClientData *data = (struct XimClientData*)client_data;
+
+    if (data->textentry == NULL)
+      return;
+
+    data->textentry->ResetPreedit();
+    /* FIXME: If the preedit is accepted (press Return for example) then this
+     * QueueRefresh() will lead to a visiable blink in the entry.
+     * However without this QueueRefresh() then the display will not be
+     * refreshed if the preedit is cancelled (press Esc for example).
+     */
+    data->textentry->QueueRefresh(true, true);
+  }
+
+  void XimClientData::XIMPreeditDrawCallback(XIC xic, XPointer client_data,
+      XIMPreeditDrawCallbackStruct *call_data)
+  {
+    struct XimClientData *data = (struct XimClientData*)client_data;
+
+    if (data->textentry == NULL)
+      return;
+
+    if (call_data->text)
+    {
+      std::string &preedit = data->textentry->preedit_;
+      if (call_data->text->encoding_is_wchar)
+        preedit = NString(call_data->text->string.wide_char).GetTStringRef();
+      else
+        preedit = call_data->text->string.multi_byte;
+
+      const char *utf8 = preedit.c_str();
+      PangoAttrList *attrs;
+      feedbacks_to_pango_attr_list(&attrs, utf8,
+          call_data->text->length, call_data->text->feedback);
+
+      if (data->textentry->preedit_attrs_)
+        pango_attr_list_unref(data->textentry->preedit_attrs_);
+
+      data->textentry->preedit_cursor_ = preedit.length();
+      data->textentry->preedit_attrs_ = attrs;
+      data->textentry->QueueRefresh(true, true);
+    }
+  }
+
+  void XimClientData::XIMPreeditCaretCallback(XIC xic, XPointer client_data,
+      XIMPreeditCaretCallbackStruct *call_data)
+  {
+    nuxDebugMsg("[XimClientData::XIMPreeditCaretCallback] TODO");
+  }
+
+  void XimClientData::XIMStatusStartCallback(XIC xic, XPointer client_data, XPointer call_data)
+  {
+    nuxDebugMsg("[XimClientData::XIMStatusStartCallback] TODO");
+  }
+
+  void XimClientData::XIMStatusDoneCallback(XIC xic, XPointer client_data, XPointer call_data)
+  {
+    nuxDebugMsg("[XimClientData::XIMStatusDoneCallback] TODO");
+  }
+
+  void XimClientData::XIMStatusDrawCallback(XIC xic, XPointer client_data,
+      XIMStatusDrawCallbackStruct *call_data)
+  {
+    nuxDebugMsg("[XimClientData::XIMStatusDrawCallback] TODO");
+  }
+
+  void XimClientData::XIMStringConversionCallback(XIC xic, XPointer client_data,
+      XIMStringConversionCallbackStruct * call_data)
+  {
+    nuxDebugMsg("[XimClientData::XIMStringConversionCallback] TODO");
+  }
+}

=== added file 'Nux/XimClientData.h'
--- Nux/XimClientData.h	1970-01-01 00:00:00 +0000
+++ Nux/XimClientData.h	2012-07-20 05:33:28 +0000
@@ -0,0 +1,64 @@
+/*
+* Copyright 2010 Inalogic庐 Inc.
+*
+* This program is free software: you can redistribute it and/or modify it
+* under the terms of the GNU Lesser General Public License, as
+* published by the  Free Software Foundation; either version 2.1 or 3.0
+* of the License.
+*
+* This program is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranties of
+* MERCHANTABILITY, SATISFACTORY QUALITY or FITNESS FOR A PARTICULAR
+* PURPOSE.  See the applicable version of the GNU Lesser General Public
+* License for more details.
+*
+* You should have received a copy of both the GNU Lesser General Public
+* License along with this program. If not, see <http://www.gnu.org/licenses/>
+*
+* Authored by: Ying-Chun Liu <[e-mail]>
+*              Yu Ning <[e-mail]>
+*
+*/
+
+
+#ifndef XIMCLIENTDATA_H
+#define XIMCLIENTDATA_H
+
+#include <Nux/Nux.h>
+
+namespace nux
+{
+
+  class TextEntry;
+
+  struct XimClientData
+  {
+    XIM m_xim;
+    XIC m_xic;
+    Window window;
+    Display *display;
+    int focus_stat;
+    TextEntry *textentry;
+
+    void InitXIM();
+    void UninitXIM();
+    void Reset();
+    void XICFocus(TextEntry *textentry);
+    void XICUnFocus(TextEntry *textentry);
+    void SetCursorLocation(int x, int y, int width, int height);
+
+    static void XIMEndCallback(Display *dpy, XPointer client_data, XPointer call_data);
+    static void XIMStartCallback(Display *dpy, XPointer client_data, XPointer call_data);
+    static int XIMPreeditStartCallback(XIC xic, XPointer client_data, XPointer call_data);
+    static void XIMPreeditDoneCallback(XIC xic, XPointer client_data, XPointer call_data);
+    static void XIMPreeditDrawCallback(XIC xic, XPointer client_data, XIMPreeditDrawCallbackStruct *call_data);
+    static void XIMPreeditCaretCallback(XIC xic, XPointer client_data, XIMPreeditCaretCallbackStruct *call_data);
+    static void XIMStatusStartCallback(XIC xic, XPointer client_data, XPointer call_data);
+    static void XIMStatusDoneCallback(XIC xic, XPointer client_data, XPointer call_data);
+    static void XIMStatusDrawCallback(XIC xic, XPointer client_data, XIMStatusDrawCallbackStruct *call_data);
+    static void XIMStringConversionCallback(XIC xic, XPointer client_data, XIMStringConversionCallbackStruct * call_data);
+  };
+
+}
+#endif  // XIMCLIENTDATA_H
+

=== modified file 'NuxGraphics/GraphicsDisplayX11.h'
--- NuxGraphics/GraphicsDisplayX11.h	2012-01-26 23:01:57 +0000
+++ NuxGraphics/GraphicsDisplayX11.h	2012-07-20 05:33:28 +0000
@@ -462,6 +462,7 @@
 
     friend class DisplayAccessController;
     friend class GraphicsEngine;
+    friend class XimIMEContext;
   };
 
 }