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

[csslayer]

Hi Nux developer,

Modularize a little bit for input method support in nux, can be refactor to shared library in the future.

fcitx newer than 4.2.4 is required.

[lp:~wengxt/nux/fcitx-support]

630. By csslayer on 2012-07-17

merge nux/trunk

631. By csslayer on 2012-07-18

change the input method to a global component, not per-text entry

632. By csslayer on 2012-08-25

merge xim support

[csslayer (wengxt)]

Hi, I merged Xim support and change how input method works in nux (global instead of per textentry).

Please review.

[Andrea Azzarone (azzar1)]

Where are tests?

[Brandon Schaefer (brandontschaefer)]

Hello, sorry for be so late to review this....

There is something wrong with restarting IMs in the XIM part. ie. When you restart hime the text entry does not re initialize the xim again which leaves no im working (Only for XIM). Though that is an edge case. In the XIM destructor a XDestroyIC (xic) and XCloseIM(xim) should be there...

Also note this XIM support will not work in Unity. This is because the window getting set for the XIC is the root window for compiz. So when events come through for say the Dash window and get sent through XFilterEvent it will not match the compiz window which the XIC is setup with and fail.

I am also not sure if the XIM support will fit in this way for unity. As we will need an XIC for each window (Dash/Hud). So a possible fix for the XIM part is get the window related to the TextEntry and send that through when focusing the TextEntry...

Seems to be the way to get the window relating to a focused TextEntry.
nux::BaseWindow* window = static_cast<nux::BaseWindow*>(GetTopLevelViewWindow()))
window->GetInputWindowId()

I want to add this Fcitx support in as it communicates directly with fcitx as opposed to going through X. I think the more IMs that get added the harder it will be to maintain. I am really considering dropping all friend classes for the IM stuff and adding public methods into TextEntry to handle anything the IM stuff needs. I don't want to ruin encapsulation for a few protected variables. This will also reduce code in OnCommit for both ibus/fcitx and should for other things. Though this is my fault for programming it like this in the first place...

So right now...we need test for the fcitx support. Preferably in both Unity and Nux, but getting test in for Nux should be fine. Take a look at xtest-text-entry.cpp, this is where we have test for ibus. (It should be renamed to xtest-text-entry-ibus.cpp)

I also wanted to apologize for forcing IBus in Unity. It was not something I wanted to do and I really want to make sure everyone can use any IM they wish.

One last thing...we are in a FF (Feature Freeze) for 12.10. This being said I am not 100% if we can get a FF exception for this branch. If we cannot then this well get held back until 13.04.

Thank you again for this branch :)

review: Needs Fixing

[Yu Ning (yuningdodo)]

Hi Brandon Schaefer,

Thank you for your review and advises, I may try to improve & fix the XIM part in this branch. Due to I am not familiar with XIM, this may take some time.

Thanks again,
ning

[Christopher Townsend (townsend)]

Setting to Work in Progress to get it off the active review queue.

Unmerged revisions

632. By csslayer on 2012-08-25

merge xim support

631. By csslayer on 2012-07-18

change the input method to a global component, not per-text entry

630. By csslayer on 2012-07-17

merge nux/trunk

629. By csslayer on 2012-07-10

add fcitx support and make it a little bit modularize

=== added file 'Nux/InputMethod.cpp'
--- Nux/InputMethod.cpp	1970-01-01 00:00:00 +0000
+++ Nux/InputMethod.cpp	2012-08-25 13:11:19 +0000
@@ -0,0 +1,84 @@
+/*
+* 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: Brandon Schaefer <[e-mail]>
+*              Jay Taoko <[e-mail]>
+*
+*/
+
+
+#include "Nux.h"
+
+#include "InputMethod.h"
+#include "InputMethodIBus.h"
+#include "InputMethodFcitx.h"
+#include "InputMethodXim.h"
+
+namespace nux
+{
+  IMEContext* IMEContextFactory::global_context_ = NULL;
+
+  IMEContext::IMEContext()
+    : focused_widget_(NULL)
+  {
+  }
+
+  IMEContext::~IMEContext()
+  {
+  }
+
+  void IMEContext::SetFocusWidget(TextEntry* text_entry)
+  {
+    focused_widget_ = text_entry;
+  }
+
+  void IMEContext::BlurWidget(TextEntry* text_entry)
+  {
+    if (text_entry == focused_widget_)
+      SetFocusWidget(NULL);
+  }
+
+  TextEntry* IMEContext::FocusWidget()
+  {
+    return focused_widget_;
+  }
+
+  IMEContext* IMEContextFactory::Get() {
+     if (global_context_)
+       return global_context_;
+     /* guess user wanted input method */
+     const char* im = g_getenv("NUX_IM");
+     /* fallback to the gtk/qt im module to test */
+     if (!im)
+       im = g_getenv("GTK_IM_MODULE");
+     if (!im)
+       im = g_getenv("QT_IM_MODULE");
+
+     if (g_strcmp0(im, "ibus") == 0)
+       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();
+     return global_context_;
+  }
+}

=== added file 'Nux/InputMethod.h'
--- Nux/InputMethod.h	1970-01-01 00:00:00 +0000
+++ Nux/InputMethod.h	2012-08-25 13:11:19 +0000
@@ -0,0 +1,127 @@
+/*
+* 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: Brandon Schaefer <[e-mail]>
+*              Jay Taoko <[e-mail]>
+*              Weng Xuetian <[e-mail]>
+*
+*/
+
+
+#ifndef INPUTMETHOD_H
+#define INPUTMETHOD_H
+
+#include <Nux/TextEntry.h>
+
+namespace nux
+{
+
+  class IMEContext;
+  class TextEntry;
+
+  // FIXME This class should be reworked to replace the mouse_state
+  // with the hardware key_code.
+  class KeyEvent
+  {
+  public:
+
+    KeyEvent(NuxEventType type,
+      unsigned int key_sym,
+      unsigned int key_code, unsigned int event_flags, const char* character)
+      : type_(type)
+      , key_sym_(key_sym)
+      , key_code_(key_code)
+      , key_modifiers_(event_flags)
+      , character_(character ? character : "")
+    {
+    }
+
+    NuxEventType type() const {return type_;}
+    unsigned int key_sym() const {return key_sym_;}
+    unsigned int key_code() const {return key_code_;}
+    unsigned int flags() const {return key_modifiers_;}
+    std::string character() const {return character_;}
+
+    bool IsShiftDown() const { return (key_modifiers_ & KEY_MODIFIER_SHIFT) != 0; }
+    bool IsControlDown() const { return (key_modifiers_ & KEY_MODIFIER_CTRL) != 0; }
+    bool IsCapsLockDown() const { return (key_modifiers_ & KEY_MODIFIER_CAPS_LOCK) != 0; }
+    bool IsAltDown() const { return (key_modifiers_ & KEY_MODIFIER_ALT) != 0; }
+
+  private:
+    EventType type_;
+    unsigned int key_sym_;
+    unsigned int key_code_;
+    unsigned int key_modifiers_;
+    std::string character_;
+
+    KeyEvent(const KeyEvent&);
+    void operator = (const KeyEvent&);
+  };
+
+  // Used for passing data to ProcessKeyEventDone function()
+  class ProcessKeyEventData
+  {
+  public:
+    ProcessKeyEventData(IMEContext* context,
+      const KeyEvent& event)
+      : context(context)
+      , event(event.type(), event.key_sym(), event.key_code(), event.flags(), event.character().c_str())
+    {
+
+    }
+    IMEContext* context;
+    KeyEvent event;
+  };
+
+  // Implements IMEContext to integrate ibus input method framework
+  class IMEContext
+  {
+  public:
+    explicit IMEContext();
+    virtual ~IMEContext();
+
+    // views::IMEContext implementations:
+    virtual void SetFocusWidget(TextEntry* text_entry);
+    virtual void BlurWidget(TextEntry* text_entry);
+    virtual void Reset() = 0;
+    virtual bool FilterKeyEvent(const KeyEvent& event) = 0;
+    virtual void SetSurrounding(const std::wstring& text, int cursor_pos) = 0;
+
+    virtual bool IsConnected() const = 0;
+    virtual bool IsHotkeyEvent(EventType type, unsigned long keysym, unsigned long modifiers) const = 0;
+    virtual bool IsIgnoredKey(unsigned long keysym, unsigned long modifiers) const = 0;
+
+    TextEntry* FocusWidget();
+
+  protected:
+    TextEntry* focused_widget_;
+
+  private:
+    IMEContext(const IMEContext&);
+    void operator = (const IMEContext&);
+  };
+
+  class IMEContextFactory
+  {
+  public:
+      static IMEContext* Get();
+  private:
+      static IMEContext* global_context_;
+  };
+}
+#endif  // INPUTMETHODIBUS_H
+

=== added file 'Nux/InputMethodFcitx.cpp'
--- Nux/InputMethodFcitx.cpp	1970-01-01 00:00:00 +0000
+++ Nux/InputMethodFcitx.cpp	2012-08-25 13:11:19 +0000
@@ -0,0 +1,309 @@
+/*
+* Copyright 2012 Weng Xuetian
+*
+* 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]>
+*
+*/
+
+#include <fcitx/ui.h>
+#include <fcitx-config/hotkey.h>
+
+#include "Nux.h"
+
+#include "InputMethodFcitx.h"
+
+namespace nux
+{
+  FcitxIMEContext::FcitxIMEContext()
+    : IMEContext(),
+      client_(NULL)
+  {
+     client_ = fcitx_client_new();
+     g_signal_connect(client_, "connected",                G_CALLBACK(OnConnected_), this); 
+     g_signal_connect(client_, "commit-string",            G_CALLBACK(OnCommitText_), this);
+     g_signal_connect(client_, "update-formatted-preedit", G_CALLBACK(OnUpdatePreeditText_), this);
+     // todo(csslayer) forward key, surrounding text
+  }
+
+  FcitxIMEContext::~FcitxIMEContext()
+  {
+    g_object_unref(client_);
+    TextEntry* text_entry = FocusWidget();
+    if (!text_entry)
+      return;
+    text_entry->ResetPreedit();
+  }
+
+  void FcitxIMEContext::SetFocusWidget(TextEntry* text_entry)
+  {
+    TextEntry* old_entry_ = FocusWidget();
+
+    if (old_entry_ == text_entry)
+      return;
+
+    if (old_entry_)
+    {
+      old_entry_->ime_active_ = false;
+      if (fcitx_client_is_valid(client_))
+        fcitx_client_focus_out(client_);
+    }
+
+    IMEContext::SetFocusWidget(text_entry);
+
+    bool has_focus = (text_entry != NULL);
+
+    if (!fcitx_client_is_valid(client_))
+      return;
+
+    if (has_focus)
+    {
+      text_entry->ime_active_ = true;
+      fcitx_client_focus_in(client_);
+    }
+    else
+      fcitx_client_focus_out(client_);
+  }
+
+  void FcitxIMEContext::Reset()
+  {
+    if (fcitx_client_is_valid(client_))
+      fcitx_client_reset(client_);
+  }
+
+  void FcitxIMEContext::OnConnected(FcitxClient* client)
+  {
+    int flags = 16 | 2;
+ 
+    if (fcitx_client_is_valid(client_))
+      fcitx_client_set_capacity(client_, flags);
+  }
+
+  bool FcitxIMEContext::FilterKeyEvent(const KeyEvent& event)
+  {
+    guint keyval = event.key_sym(); // todo(jaytaoko): ui::GdkKeyCodeForWindowsKeyCode(event.key_code(), event.IsShiftDown() ^ event.IsCapsLockDown());
+
+    if (fcitx_client_is_valid(client_)) {
+      guint modifiers = 0;
+
+      if (event.flags() & FcitxKeyState_IgnoredMask)
+        return false;
+
+      if (event.IsShiftDown())
+        modifiers |= FcitxKeyState_Shift;
+      if (event.IsControlDown())
+        modifiers |= FcitxKeyState_Ctrl;
+      if (event.IsAltDown())
+        modifiers |= FcitxKeyState_Alt;
+      if (event.IsCapsLockDown())
+        modifiers |= FcitxKeyState_CapsLock;
+
+      struct timeval current_time;
+      gettimeofday(&current_time, NULL);
+      guint32 time = (current_time.tv_sec * 1000) + (current_time.tv_usec / 1000);
+      
+      fcitx_client_process_key(client_,
+        reinterpret_cast<GAsyncReadyCallback>(ProcessKeyEventDone),
+        new ProcessKeyEventData(this, event),
+        keyval, event.key_code(), modifiers,
+        (event.type() == EVENT_KEY_UP) ? 1 : 0,
+        time);
+
+      return true;
+    }
+    return false;
+  }
+
+  void FcitxIMEContext::SetSurrounding(const std::wstring& text, int cursor_pos)
+  {
+      // TODO(penghuang) support surrounding
+  }
+
+  bool FcitxIMEContext::IsConnected() const
+  {
+    return fcitx_client_is_valid(client_);
+  }
+
+  void FcitxIMEContext::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();
+
+    fcitx_client_set_cusor_rect(client_,
+      geo.x + window_geo.x + strong.x,
+      geo.y + window_geo.y,
+      0,
+      geo.height);
+  }
+
+  void FcitxIMEContext::OnCommitText(FcitxClient *context, char* text)
+  {
+    //nuxDebugMsg("***FcitxIMEContext::OnCommitText::%s***", text->text);
+    nuxAssert(client_ == context);
+
+    TextEntry* text_entry = FocusWidget();
+    if (!text_entry)
+      return;
+    text_entry->DeleteSelection();
+
+    if (text)
+    {
+      int cursor = text_entry->cursor_;
+      std::string new_text(text_entry->GetText());
+      std::string commit_text (text);
+      new_text.insert (cursor, commit_text);
+
+      text_entry->SetText(new_text.c_str());
+      text_entry->SetCursor(cursor + commit_text.length());
+      UpdateCursorLocation();
+    }
+  }
+
+  void FcitxIMEContext::OnUpdatePreeditText(FcitxClient* context, GPtrArray* array, guint cursor_pos)
+  {
+    //nuxDebugMsg("***FcitxIMEContext::OnUpdatePreeditText***");
+    nuxAssert(client_ == context);
+    TextEntry* text_entry = FocusWidget();
+    if (!text_entry)
+      return;
+
+    if (text_entry->preedit_.empty())
+      UpdateCursorLocation();
+
+    if (array->len)
+    {
+      GString* gstr = g_string_new(NULL);
+      PangoAttrList* preedit_attrs = pango_attr_list_new();
+      unsigned int i = 0;
+      for (i = 0; i < array->len; i++)
+      {
+        size_t bytelen = strlen(gstr->str);
+        FcitxPreeditItem* preedit = static_cast<FcitxPreeditItem*>(g_ptr_array_index(array, i));
+        const gchar* s = preedit->string;
+        gint type = preedit->type;
+
+        PangoAttribute *pango_attr = NULL;
+        if ((type & MSG_NOUNDERLINE) == 0) {
+          pango_attr = pango_attr_underline_new(PANGO_UNDERLINE_SINGLE);
+          pango_attr->start_index = bytelen;
+          pango_attr->end_index = bytelen + strlen(s);
+          pango_attr_list_insert(preedit_attrs, pango_attr);
+        }
+
+        if (type & MSG_HIGHLIGHT) {
+          guint16 fgred, fggreen, fgblue, bgred, bggreen, bgblue;
+
+          /* todo(csslayer) use style color*/
+          fgred = 0xffff;
+          fggreen = 0xffff;
+          fgblue = 0xffff;
+          bgred = 0x43ff;
+          bggreen = 0xacff;
+          bgblue = 0xe8ff;
+
+          pango_attr = pango_attr_foreground_new(fgred, fggreen, fgblue);
+          pango_attr->start_index = bytelen;
+          pango_attr->end_index = bytelen + strlen(s);
+          pango_attr_list_insert(preedit_attrs, pango_attr);
+          pango_attr = pango_attr_background_new(bgred, bggreen, bgblue);
+          pango_attr->start_index = bytelen;
+          pango_attr->end_index = bytelen + strlen(s);
+          pango_attr_list_insert(preedit_attrs, pango_attr);
+        }
+        gstr = g_string_append(gstr, s);
+      }
+
+      gchar* str = g_string_free(gstr, FALSE);
+      if (text_entry->preedit_attrs_)
+      {
+        pango_attr_list_unref(text_entry->preedit_attrs_);
+        text_entry->preedit_attrs_ = NULL;
+      }
+      text_entry->preedit_attrs_ = preedit_attrs;
+
+      std::string preedit(str);
+      text_entry->preedit_ = preedit;
+      text_entry->preedit_cursor_ = cursor_pos;
+      text_entry->QueueRefresh (true, true);
+    }
+    else
+    {
+      OnHidePreeditText(client_);
+    }
+  }
+
+  void FcitxIMEContext::OnHidePreeditText(FcitxClient *context)
+  {
+    //nuxDebugMsg("***FcitxIMEContext::OnHidePreeditText***");
+    nuxAssert(client_ == context);
+    TextEntry* text_entry = FocusWidget();
+    if (!text_entry)
+      return;
+
+    text_entry->ResetPreedit();
+    text_entry->QueueRefresh (true, true);
+  }
+
+  void FcitxIMEContext::ProcessKeyEventDone(FcitxClient *client, GAsyncResult* res, ProcessKeyEventData *data)
+  {
+    //nuxDebugMsg("***FcitxIMEContext::ProcessKeyEventDone***");
+      std::unique_ptr<ProcessKeyEventData> key_ev(data);
+      nuxAssert(key_ev->context->client_ == context);
+
+      GError *error = NULL;
+      int ret = -1;
+      GVariant* result = g_dbus_proxy_call_finish(G_DBUS_PROXY(client), res, &error);
+      if (error) {
+        g_warning ("Process Key Event failed: %s.", error->message);
+        g_error_free(error);
+      }
+      else if (result) {
+        g_variant_get(result, "(i)", &ret);
+      }
+
+      if (ret <= 0)
+      {
+        FcitxIMEContext* fcitxcontext = static_cast<FcitxIMEContext*>(key_ev->context);
+        TextEntry* text_entry = fcitxcontext->FocusWidget();
+        if (!text_entry)
+          return;
+    
+        text_entry->ProcessKeyEvent(key_ev->event.type(),
+                                    key_ev->event.key_sym(),
+                                    key_ev->event.flags() | FcitxKeyState_IgnoredMask,
+                                    key_ev->event.character().c_str(),
+                                    0);
+      }
+  }
+
+  bool FcitxIMEContext::IsHotkeyEvent(EventType type, unsigned long keysym, unsigned long modifiers) const
+  {
+    return false;
+  }
+
+  bool FcitxIMEContext::IsIgnoredKey(unsigned long keysym, unsigned long modifiers) const {
+    return modifiers & FcitxKeyState_IgnoredMask;
+  }
+}

=== added file 'Nux/InputMethodFcitx.h'
--- Nux/InputMethodFcitx.h	1970-01-01 00:00:00 +0000
+++ Nux/InputMethodFcitx.h	2012-08-25 13:11:19 +0000
@@ -0,0 +1,83 @@
+/*
+* Copyright 2012 Weng Xuetian
+*
+* 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]>
+*
+*/
+
+
+#ifndef INPUTMETHODFCITX_H
+#define INPUTMETHODFCITX_H
+
+#include <Nux/TextEntry.h>
+#include <Nux/InputMethod.h>
+#include <fcitx-gclient/fcitxclient.h>
+
+namespace nux
+{
+
+  class FcitxIMEContext;
+  class TextEntry;
+
+  // Implements IMEContext to integrate fcitx input method framework
+  class FcitxIMEContext : public IMEContext
+  {
+  public:
+    explicit FcitxIMEContext();
+    virtual ~FcitxIMEContext();
+
+    // 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();
+
+    // Event Handlers for FcitxClient
+    static void OnConnected_(FcitxClient* client, void* data) {nuxDebugMsg("***FcitxIMEContext::OnConnected***"); static_cast<FcitxIMEContext*>(data)->OnConnected(client);}
+    void OnConnected(FcitxClient *client);
+
+    static void OnCommitText_(FcitxClient* client, gchar* text, void* data) {static_cast<FcitxIMEContext*>(data)->OnCommitText(client, text);}
+    void OnCommitText(FcitxClient *client, char* text);
+    
+    static void OnUpdatePreeditText_(FcitxClient* context, GPtrArray* array, guint cursor_pos, void* data) {reinterpret_cast<FcitxIMEContext*>(data)->OnUpdatePreeditText(context, array, cursor_pos);}
+    void OnUpdatePreeditText(FcitxClient *context, GPtrArray* array, guint cursor_pos);
+
+    void OnHidePreeditText(FcitxClient *context);
+
+    static void ProcessKeyEventDone(FcitxClient* context,
+      GAsyncResult* res,
+      ProcessKeyEventData* data);
+
+    FcitxClient* client_;
+    bool is_focused_;
+    TextEntry* focused_entry_;
+    
+    FcitxIMEContext(const FcitxIMEContext&);
+    void operator = (const FcitxIMEContext&);
+  };
+
+}
+#endif  // INPUTMETHODIBUS_H
+

=== modified file 'Nux/InputMethodIBus.cpp'
--- Nux/InputMethodIBus.cpp	2012-07-03 20:45:25 +0000
+++ Nux/InputMethodIBus.cpp	2012-08-25 13:11:19 +0000
@@ -32,10 +32,10 @@
 
   IBusBus* IBusIMEContext::bus_ = NULL;
 
-  IBusIMEContext::IBusIMEContext(TextEntry* text_entry)
-    : text_entry_(text_entry),
+  IBusIMEContext::IBusIMEContext()
+    : IMEContext(),
       context_(NULL),
-      is_focused_(false)
+      ime_active_(false)
   {
     // init ibus
     if (!bus_)
@@ -67,24 +67,33 @@
     DestroyContext();
   }
 
-  void IBusIMEContext::Focus()
+  void IBusIMEContext::SetFocusWidget(TextEntry* text_entry)
   {
-    if (is_focused_)
-      return;
-    is_focused_ = true;
-
-    if (context_)
+    TextEntry* old_entry_ = FocusWidget();
+
+    if (old_entry_ == text_entry)
+      return;
+
+    if (old_entry_)
+    {
+      old_entry_->ime_active_ = false;
+      if (context_)
+        ibus_input_context_focus_out(context_);
+    }
+
+    IMEContext::SetFocusWidget(text_entry);
+
+    bool has_focus = (text_entry != NULL);
+
+    if (!context_)
+      return;
+
+    if (has_focus)
+    {
+      text_entry->ime_active_ = ime_active_;
       ibus_input_context_focus_in(context_);
-  }
-
-  void IBusIMEContext::Blur()
-  {
-    if (!is_focused_)
-      return;
-
-    is_focused_ = false;
-
-    if (context_)
+    }
+    else
       ibus_input_context_focus_out(context_);
   }
 
@@ -143,7 +152,9 @@
       return;
     }
 
-    text_entry_->ime_active_ = false;
+    TextEntry* text_entry = FocusWidget();
+    if (text_entry)
+      text_entry->ime_active_ = false;
 
     // connect input context signals
     g_signal_connect(context_, "commit-text",         G_CALLBACK(OnCommitText_),        this);
@@ -159,7 +170,7 @@
       IBUS_CAP_SURROUNDING_TEXT;
     ibus_input_context_set_capabilities(context_, caps);
 
-    if (is_focused_)
+    if (FocusWidget())
       ibus_input_context_focus_in(context_);
 
     UpdateCursorLocation();
@@ -183,7 +194,9 @@
     if (!context_)
       return;
 
-    text_entry_->ResetPreedit();
+    TextEntry* text_entry = FocusWidget();
+    if (text_entry)
+      text_entry->ResetPreedit();
     ibus_proxy_destroy(reinterpret_cast<IBusProxy *>(context_));
 
     nuxAssert(!context_);
@@ -196,11 +209,15 @@
 
   void IBusIMEContext::UpdateCursorLocation()
   {
+    TextEntry* text_entry = FocusWidget();
+    if (!text_entry)
+      return;
+    
     nux::Rect strong, weak;
-    text_entry_->GetCursorRects(&strong, &weak);
+    text_entry->GetCursorRects(&strong, &weak);
 
     // Get the position of the TextEntry in the Window.
-    nux::Geometry geo = text_entry_->GetAbsoluteGeometry();
+    nux::Geometry geo = text_entry->GetAbsoluteGeometry();
 
     // Get the Geometry of the window on the display.
     nux::Geometry window_geo = nux::GetGraphicsDisplay()->GetWindowGeometry();
@@ -245,17 +262,20 @@
     //nuxDebugMsg("***IBusIMEContext::OnCommitText::%s***", text->text);
     nuxAssert(context_ == context);
 
-    text_entry_->DeleteSelection();
+    TextEntry* text_entry = FocusWidget();
+    if (!text_entry)
+      return;
+    text_entry->DeleteSelection();
 
     if (text->text)
     {
-      int cursor = text_entry_->cursor_;
-      std::string new_text(text_entry_->GetText());
+      int cursor = text_entry->cursor_;
+      std::string new_text(text_entry->GetText());
       std::string commit_text (text->text);
       new_text.insert (cursor, commit_text);
 
-      text_entry_->SetText(new_text.c_str());
-      text_entry_->SetCursor(cursor + commit_text.length());
+      text_entry->SetText(new_text.c_str());
+      text_entry->SetCursor(cursor + commit_text.length());
       UpdateCursorLocation();
     }
   }
@@ -265,8 +285,12 @@
     //nuxDebugMsg("***IBusIMEContext::OnUpdatePreeditText***");
     nuxAssert(context_ == context);
     nuxAssert(IBUS_IS_TEXT(text));
+    
+    TextEntry* text_entry = FocusWidget();
+    if (!text_entry)
+      return;
 
-    if (text_entry_->preedit_.empty())
+    if (text_entry->preedit_.empty())
       UpdateCursorLocation();
 
     if (visible)
@@ -306,19 +330,19 @@
           pango_attr->end_index = g_utf8_offset_to_pointer (text->text, attr->end_index) - text->text;
           pango_attr_list_insert (preedit_attrs, pango_attr);
         }
-        if (text_entry_->preedit_attrs_)
+        if (text_entry->preedit_attrs_)
         {
-          pango_attr_list_unref(text_entry_->preedit_attrs_);
-          text_entry_->preedit_attrs_ = NULL;
+          pango_attr_list_unref(text_entry->preedit_attrs_);
+          text_entry->preedit_attrs_ = NULL;
         }
-        text_entry_->preedit_attrs_ = preedit_attrs;
+        text_entry->preedit_attrs_ = preedit_attrs;
       }
       if (text->text)
       {
         std::string preedit(text->text);
-        text_entry_->preedit_ = preedit;
-        text_entry_->preedit_cursor_ = preedit.length();
-        text_entry_->QueueRefresh (true, true);
+        text_entry->preedit_ = preedit;
+        text_entry->preedit_cursor_ = preedit.length();
+        text_entry->QueueRefresh (true, true);
       }
     }
     else
@@ -337,18 +361,26 @@
   {
     //nuxDebugMsg("***IBusIMEContext::OnHidePreeditText***");
     nuxAssert(context_ == context);
+    TextEntry* text_entry = FocusWidget();
+    if (!text_entry)
+      return;
 
-    text_entry_->ResetPreedit();
-    text_entry_->QueueRefresh (true, true);
+    text_entry->ResetPreedit();
+    text_entry->QueueRefresh (true, true);
   }
 
   void IBusIMEContext::OnEnable(IBusInputContext *context)
   {
     //nuxDebugMsg("***IBusIMEContext::OnEnable***");
     nuxAssert(context_ == context);
-
-    text_entry_->ime_active_ = true;
-    text_entry_->text_changed.emit(text_entry_);
+    ime_active_ = true;
+
+    TextEntry* text_entry = FocusWidget();
+    if (!text_entry)
+      return;
+
+    text_entry->ime_active_ = true;
+    text_entry->text_changed.emit(text_entry);
     UpdateCursorLocation();
   }
 
@@ -356,9 +388,15 @@
   {
     //nuxDebugMsg("***IBusIMEContext::OnDisable***");
     nuxAssert(context_ == context);
-    text_entry_->ime_active_ = false;
-    text_entry_->ResetPreedit();
-    text_entry_->QueueRefresh (true, true);
+    ime_active_ = false;
+    
+    TextEntry* text_entry = FocusWidget();
+    if (!text_entry)
+      return;
+
+    text_entry->ime_active_ = false;
+    text_entry->ResetPreedit();
+    text_entry->QueueRefresh (true, true);
   }
 
   void IBusIMEContext::OnDestroy(IBusInputContext *context)
@@ -390,11 +428,16 @@
 
       if (!processed)
       {
-        key_ev->context->text_entry_->ProcessKeyEvent(key_ev->event.type(),
-                                                      key_ev->event.key_sym(),
-                                                      key_ev->event.flags() | IBUS_IGNORED_MASK,
-                                                      key_ev->event.character().c_str(),
-                                                      0);
+        IBusIMEContext* ibuscontext = static_cast<IBusIMEContext*>(key_ev->context);
+        TextEntry* text_entry = ibuscontext->FocusWidget();
+        if (!text_entry)
+          return;
+    
+        text_entry->ProcessKeyEvent(key_ev->event.type(),
+                                    key_ev->event.key_sym(),
+                                    key_ev->event.flags() | IBUS_IGNORED_MASK,
+                                    key_ev->event.character().c_str(),
+                                    0);
       }
   }
 
@@ -515,4 +558,8 @@
 
     return false;
   }
+
+  bool IBusIMEContext::IsIgnoredKey(unsigned long keysym, unsigned long modifiers) const {
+    return modifiers & IBUS_IGNORED_MASK;
+  }
 }

=== modified file 'Nux/InputMethodIBus.h'
--- Nux/InputMethodIBus.h	2012-06-26 22:35:16 +0000
+++ Nux/InputMethodIBus.h	2012-08-25 13:11:19 +0000
@@ -25,6 +25,7 @@
 #define INPUTMETHODIBUS_H
 
 #include <Nux/TextEntry.h>
+#include <Nux/InputMethod.h>
 #include <ibus.h>
 
 namespace nux
@@ -33,76 +34,22 @@
   class IBusIMEContext;
   class TextEntry;
 
-  // FIXME This class should be reworked to replace the mouse_state
-  // with the hardware key_code.
-  class KeyEvent
-  {
-  public:
-
-    KeyEvent(NuxEventType type,
-      unsigned int key_sym,
-      unsigned int key_code, unsigned int event_flags, const char* character)
-      : type_(type)
-      , key_sym_(key_sym)
-      , key_code_(key_code)
-      , key_modifiers_(event_flags)
-      , character_(character ? character : "")
-    {
-    }
-
-    NuxEventType type() const {return type_;}
-    unsigned int key_sym() const {return key_sym_;}
-    unsigned int key_code() const {return key_code_;}
-    unsigned int flags() const {return key_modifiers_;}
-    std::string character() const {return character_;}
-
-    bool IsShiftDown() const { return (key_modifiers_ & KEY_MODIFIER_SHIFT) != 0; }
-    bool IsControlDown() const { return (key_modifiers_ & KEY_MODIFIER_CTRL) != 0; }
-    bool IsCapsLockDown() const { return (key_modifiers_ & KEY_MODIFIER_CAPS_LOCK) != 0; }
-    bool IsAltDown() const { return (key_modifiers_ & KEY_MODIFIER_ALT) != 0; }
-
-  private:
-    EventType type_;
-    unsigned int key_sym_;
-    unsigned int key_code_;
-    unsigned int key_modifiers_;
-    std::string character_;
-
-    KeyEvent(const KeyEvent&);
-    void operator = (const KeyEvent&);
-  };
-
-  // Used for passing data to ProcessKeyEventDone function()
-  class ProcessKeyEventData
-  {
-  public:
-    ProcessKeyEventData(IBusIMEContext* context,
-      const KeyEvent& event)
-      : context(context)
-      , event(event.type(), event.key_sym(), event.key_code(), event.flags(), event.character().c_str())
-    {
-
-    }
-    IBusIMEContext* context;
-    KeyEvent event;
-  };
-
   // Implements IMEContext to integrate ibus input method framework
-  class IBusIMEContext
+  class IBusIMEContext : public IMEContext
   {
   public:
-    explicit IBusIMEContext(TextEntry* text_entry);
+    explicit IBusIMEContext();
     virtual ~IBusIMEContext();
 
     // views::IMEContext implementations:
-    virtual void Focus();
-    virtual void Blur();
+    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);
 
-    bool IsConnected() const;
-    bool IsHotkeyEvent(EventType type, unsigned long keysym, unsigned long modifiers) const;
+    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:
     static std::vector<Event> ParseIBusHotkeys(const gchar** keybindings);
@@ -159,9 +106,8 @@
       GAsyncResult* res,
       ProcessKeyEventData* data);
 
-    TextEntry* text_entry_;
     IBusInputContext* context_;
-    bool is_focused_;
+    bool ime_active_;
 
     static IBusBus* bus_;
     static std::vector<Event> hotkeys_;

=== added file 'Nux/InputMethodXim.cpp'
--- Nux/InputMethodXim.cpp	1970-01-01 00:00:00 +0000
+++ Nux/InputMethodXim.cpp	2012-08-25 13:11:19 +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-08-25 13:11:19 +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-27 19:40:40 +0000
+++ Nux/Makefile.am	2012-08-25 13:11:19 +0000
@@ -16,15 +16,24 @@
   $(GCC_FLAGS) \
   $(NUX_CFLAGS) \
   $(IBUS_CFLAGS) \
+<<<<<<< TREE
   $(GEIS_CFLAGS) \
+=======
+  $(FCITX_CFLAGS) \
+>>>>>>> MERGE-SOURCE
   $(MAINTAINER_CFLAGS)
 
 libnux_@NUX_API_VERSION@_la_LIBADD = \
   $(top_builddir)/NuxCore/libnux-core-@NUX_API_VERSION@.la \
   $(top_builddir)/NuxGraphics/libnux-graphics-@NUX_API_VERSION@.la \
   $(NUX_LIBS) \
+<<<<<<< TREE
   $(IBUS_LIBS) \
   $(GEIS_LIBS)
+=======
+  $(IBUS_LIBS) \
+  $(FCITX_LIBS)
+>>>>>>> MERGE-SOURCE
 
 libnux_@NUX_API_VERSION@_la_LDFLAGS = \
   $(NUX_LT_LDFLAGS)
@@ -96,7 +105,10 @@
   $(srcdir)/SystemThread.cpp \
   $(srcdir)/TabView.cpp \
   $(srcdir)/TextEntry.cpp \
+  $(srcdir)/InputMethod.cpp \
   $(srcdir)/InputMethodIBus.cpp \
+  $(srcdir)/InputMethodFcitx.cpp \
+  $(srcdir)/InputMethodXim.cpp \
   $(srcdir)/TextLoader.cpp \
   $(srcdir)/TextureArea.cpp \
   $(srcdir)/Timeline.cpp \
@@ -112,7 +124,8 @@
   $(srcdir)/VSplitter.cpp \
   $(srcdir)/WidgetMetrics.cpp \
   $(srcdir)/WindowCompositor.cpp \
-  $(srcdir)/WindowThread.cpp
+  $(srcdir)/WindowThread.cpp \
+  $(srcdir)/XimClientData.cpp
 
 if HAVE_GEIS
 source_cpp += \
@@ -192,7 +205,10 @@
   $(srcdir)/TabView.h \
   $(srcdir)/TextEntry.h \
   $(srcdir)/TextEntryComposeSeqs.h \
+  $(srcdir)/InputMethod.h \
   $(srcdir)/InputMethodIBus.h \
+  $(srcdir)/InputMethodFcitx.h \
+  $(srcdir)/InputMethodXim.h \
   $(srcdir)/TextLoader.h \
   $(srcdir)/TextureArea.h \
   $(srcdir)/Timeline.h \
@@ -208,7 +224,8 @@
   $(srcdir)/VSplitter.h \
   $(srcdir)/WidgetMetrics.h \
   $(srcdir)/WindowCompositor.h \
-  $(srcdir)/WindowThread.h
+  $(srcdir)/WindowThread.h \
+  $(srcdir)/XimClientData.h
 
 if HAVE_GEIS
 source_h += \

=== modified file 'Nux/TextEntry.cpp'
--- Nux/TextEntry.cpp	2012-07-17 23:41:38 +0000
+++ Nux/TextEntry.cpp	2012-08-25 13:11:19 +0000
@@ -31,7 +31,7 @@
 
 #if defined(NUX_OS_LINUX)
 #include <X11/cursorfont.h>
-#include "InputMethodIBus.h"
+#include "InputMethod.h"
 #endif
 
 namespace nux
@@ -154,7 +154,7 @@
     , align_(CairoGraphics::ALIGN_LEFT)
 #if defined(NUX_OS_LINUX)
     , caret_cursor_(None)
-    , ime_(new IBusIMEContext(this))
+    , ime_(IMEContextFactory::Get())
 #endif
     , ime_active_(false)
     , text_input_mode_(false)
@@ -200,7 +200,7 @@
 
 #if defined(NUX_OS_LINUX)
     if (ime_)
-      delete ime_;
+      ime_->BlurWidget(this);
 #endif
     delete canvas_;
     ResetLayout();
@@ -866,7 +866,7 @@
       {
         need_im_reset_ = true;
 #if defined(NUX_OS_LINUX)
-        ime_->Focus();
+        ime_->SetFocusWidget(this);
 #endif
         //gtk_im_context_focus_in(im_context_);
         //UpdateIMCursorLocation();
@@ -888,7 +888,7 @@
       {
         need_im_reset_ = true;
 #if defined(NUX_OS_LINUX)
-        ime_->Blur();
+        ime_->BlurWidget(this);
 #endif
         //gtk_im_context_focus_out(im_context_);
       }

=== modified file 'Nux/TextEntry.h'
--- Nux/TextEntry.h	2012-07-17 23:41:38 +0000
+++ Nux/TextEntry.h	2012-08-25 13:11:19 +0000
@@ -29,7 +29,7 @@
 namespace nux
 {
   class CairoGraphics;
-  class IBusIMEContext;
+  class IMEContext;
 
   class CairoFont
   {
@@ -485,8 +485,12 @@
     std::list<Rect> cursor_region_;
 
 #if defined(NUX_OS_LINUX)
-    IBusIMEContext* ime_;
+    IMEContext* ime_;
+    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-08-25 13:11:19 +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-08-25 13:11:19 +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-05-31 21:32:52 +0000
+++ NuxGraphics/GraphicsDisplayX11.h	2012-08-25 13:11:19 +0000
@@ -465,6 +465,7 @@
 
     friend class DisplayAccessController;
     friend class GraphicsEngine;
+    friend class XimIMEContext;
   };
 
 }

=== modified file 'configure.ac'
--- configure.ac	2012-08-13 20:48:38 +0000
+++ configure.ac	2012-08-25 13:11:19 +0000
@@ -192,6 +192,7 @@
 AC_SUBST(IBUS_CFLAGS)
 AC_SUBST(IBUS_LIBS)
 
+<<<<<<< TREE
 dnl *********************************************************
 dnl Enable/disable gestures (geis, from Open Input Framework)
 dnl *********************************************************
@@ -244,6 +245,16 @@
 AC_SUBST(GEIS_LIBS)
 AC_SUBST(GEIS_PKGS)
 
+=======
+PKG_CHECK_MODULES(FCITX,
+                  fcitx-gclient
+                  fcitx-config
+                  )
+
+AC_SUBST(FCITX_CFLAGS)
+AC_SUBST(FCITX_LIBS)
+
+>>>>>>> MERGE-SOURCE
 dnl ************************************
 dnl Enable/disable tests
 dnl ************************************