diff --git a/widget/src/gtk2/Makefile.in b/widget/src/gtk2/Makefile.in
index 848128d881d..a8b1f17b08e 100644
--- a/widget/src/gtk2/Makefile.in
+++ b/widget/src/gtk2/Makefile.in
@@ -79,6 +79,7 @@ CPPSRCS		= \
 		nsImageToPixbuf.cpp \
 		nsAccessibilityHelper.cpp \
 		nsAccelerometerUnix.cpp \
+		nsGtkIMModule.cpp \
 		$(NULL)
 
 ifdef MOZ_X11
@@ -152,7 +153,6 @@ CXXFLAGS += $(MOZ_GCONF_CFLAGS)
 endif
 endif
 
-DEFINES         += -DUSE_XIM
 DEFINES		+= -DCAIRO_GFX
 
 ifdef MOZ_ENABLE_POSTSCRIPT
diff --git a/widget/src/gtk2/nsAppShell.cpp b/widget/src/gtk2/nsAppShell.cpp
index 3af4bc5f241..caa6641ceb0 100644
--- a/widget/src/gtk2/nsAppShell.cpp
+++ b/widget/src/gtk2/nsAppShell.cpp
@@ -51,7 +51,6 @@
 #ifdef PR_LOGGING
 PRLogModuleInfo *gWidgetLog = nsnull;
 PRLogModuleInfo *gWidgetFocusLog = nsnull;
-PRLogModuleInfo *gWidgetIMLog = nsnull;
 PRLogModuleInfo *gWidgetDragLog = nsnull;
 PRLogModuleInfo *gWidgetDrawLog = nsnull;
 #endif
@@ -89,8 +88,6 @@ nsAppShell::Init()
         gWidgetLog = PR_NewLogModule("Widget");
     if (!gWidgetFocusLog)
         gWidgetFocusLog = PR_NewLogModule("WidgetFocus");
-    if (!gWidgetIMLog)
-        gWidgetIMLog = PR_NewLogModule("WidgetIM");
     if (!gWidgetDragLog)
         gWidgetDragLog = PR_NewLogModule("WidgetDrag");
     if (!gWidgetDrawLog)
diff --git a/widget/src/gtk2/nsGtkIMModule.cpp b/widget/src/gtk2/nsGtkIMModule.cpp
new file mode 100644
index 00000000000..459f0f31072
--- /dev/null
+++ b/widget/src/gtk2/nsGtkIMModule.cpp
@@ -0,0 +1,1276 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* vim:expandtab:shiftwidth=4:tabstop=4:
+ */
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is Christopher Blizzard
+ * <blizzard@mozilla.org>.  Portions created by the Initial Developer
+ * are Copyright (C) 2001 the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Mats Palmgren <mats.palmgren@bredband.net>
+ *   Masayuki Nakano <masayuki@d-toybox.com>
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+#ifdef MOZ_PLATFORM_MAEMO
+#define MAEMO_CHANGES
+#endif
+
+#ifdef MOZ_LOGGING
+#define FORCE_PR_LOG /* Allow logging in the release build */
+#endif // MOZ_LOGGING
+#include "prlog.h"
+
+#include "nsGtkIMModule.h"
+#include "nsWindow.h"
+
+#ifdef MOZ_PLATFORM_MAEMO
+#include "nsServiceManagerUtils.h"
+#include "nsIObserverService.h"
+#endif
+
+#ifdef PR_LOGGING
+PRLogModuleInfo* gGtkIMLog = nsnull;
+
+static const char*
+GetRangeTypeName(PRUint32 aRangeType)
+{
+    switch (aRangeType) {
+        case NS_TEXTRANGE_RAWINPUT:
+            return "NS_TEXTRANGE_RAWINPUT";
+        case NS_TEXTRANGE_CONVERTEDTEXT:
+            return "NS_TEXTRANGE_CONVERTEDTEXT";
+        case NS_TEXTRANGE_SELECTEDRAWTEXT:
+            return "NS_TEXTRANGE_SELECTEDRAWTEXT";
+        case NS_TEXTRANGE_SELECTEDCONVERTEDTEXT:
+            return "NS_TEXTRANGE_SELECTEDCONVERTEDTEXT";
+        case NS_TEXTRANGE_CARETPOSITION:
+            return "NS_TEXTRANGE_CARETPOSITION";
+        default:
+            return "UNKNOWN SELECTION TYPE!!";
+    }
+}
+
+static const char*
+GetEnabledStateName(PRUint32 aState)
+{
+    switch (aState) {
+        case nsIWidget::IME_STATUS_DISABLED:
+            return "DISABLED";
+        case nsIWidget::IME_STATUS_ENABLED:
+            return "ENABLED";
+        case nsIWidget::IME_STATUS_PASSWORD:
+            return "PASSWORD";
+        case nsIWidget::IME_STATUS_PLUGIN:
+            return "PLUG_IN";
+        default:
+            return "UNKNOWN ENABLED STATUS!!";
+    }
+}
+#endif
+
+nsGtkIMModule* nsGtkIMModule::sLastFocusedModule = nsnull;
+
+#ifdef MOZ_PLATFORM_MAEMO
+static PRBool gIsVirtualKeyboardOpened = PR_FALSE;
+#endif
+
+nsGtkIMModule::nsGtkIMModule(nsWindow* aOwnerWindow) :
+    mOwnerWindow(aOwnerWindow), mLastFocusedWindow(nsnull),
+    mContext(nsnull),
+#ifndef NS_IME_ENABLED_ON_PASSWORD_FIELD
+    mSimpleContext(nsnull),
+#endif
+    mDummyContext(nsnull), mEnabled(nsIWidget::IME_STATUS_ENABLED),
+    mCompositionStart(PR_UINT32_MAX), mProcessingKeyEvent(nsnull),
+    mIsComposing(PR_FALSE), mIsIMFocused(PR_FALSE),
+    mIgnoreNativeCompositionEvent(PR_FALSE)
+{
+#ifdef PR_LOGGING
+    if (!gGtkIMLog) {
+        gGtkIMLog = PR_NewLogModule("nsGtkIMModuleWidgets");
+    }
+#endif
+    Init();
+}
+
+void
+nsGtkIMModule::Init()
+{
+    PR_LOG(gGtkIMLog, PR_LOG_ALWAYS,
+        ("GtkIMModule(%p): Init, mOwnerWindow=%p",
+         this, mOwnerWindow));
+
+    MozContainer* container = mOwnerWindow->GetMozContainer();
+    NS_PRECONDITION(container, "container is null");
+    GdkWindow* gdkWindow = GTK_WIDGET(container)->window;
+
+    // NOTE: gtk_im_*_new() abort (kill) the whole process when it fails.
+    //       So, we don't need to check the result.
+
+    // Normal context.
+    mContext = gtk_im_multicontext_new();
+    gtk_im_context_set_client_window(mContext, gdkWindow);
+    g_signal_connect(mContext, "preedit_changed",
+                     G_CALLBACK(nsGtkIMModule::OnChangeCompositionCallback),
+                     this);
+    g_signal_connect(mContext, "commit",
+                     G_CALLBACK(nsGtkIMModule::OnCommitCompositionCallback),
+                     this);
+    g_signal_connect(mContext, "preedit_start",
+                     G_CALLBACK(nsGtkIMModule::OnStartCompositionCallback),
+                     this);
+    g_signal_connect(mContext, "preedit_end",
+                     G_CALLBACK(nsGtkIMModule::OnEndCompositionCallback),
+                     this);
+
+#ifndef NS_IME_ENABLED_ON_PASSWORD_FIELD
+    // Simple context
+    mSimpleContext = gtk_im_context_simple_new();
+    gtk_im_context_set_client_window(mSimpleContext, gdkWindow);
+    g_signal_connect(mSimpleContext, "preedit_changed",
+                     G_CALLBACK(&nsGtkIMModule::OnChangeCompositionCallback),
+                     this);
+    g_signal_connect(mSimpleContext, "commit",
+                     G_CALLBACK(&nsGtkIMModule::OnCommitCompositionCallback),
+                     this);
+    g_signal_connect(mSimpleContext, "preedit_start",
+                     G_CALLBACK(nsGtkIMModule::OnStartCompositionCallback),
+                     this);
+    g_signal_connect(mSimpleContext, "preedit_end",
+                     G_CALLBACK(nsGtkIMModule::OnEndCompositionCallback),
+                     this);
+#endif // NS_IME_ENABLED_ON_PASSWORD_FIELD
+
+    // Dummy context
+    mDummyContext = gtk_im_multicontext_new();
+    gtk_im_context_set_client_window(mDummyContext, gdkWindow);
+}
+
+nsGtkIMModule::~nsGtkIMModule()
+{
+    if (this == sLastFocusedModule) {
+        sLastFocusedModule = nsnull;
+    }
+    PR_LOG(gGtkIMLog, PR_LOG_ALWAYS,
+        ("GtkIMModule(%p) was gone", this));
+}
+
+void
+nsGtkIMModule::OnDestroyWindow(nsWindow* aWindow)
+{
+    PR_LOG(gGtkIMLog, PR_LOG_ALWAYS,
+        ("GtkIMModule(%p): OnDestroyWindow, aWindow=%p, mLastFocusedWindow=%p, mOwnerWindow=%p, mLastFocusedModule=%p",
+         this, aWindow, mLastFocusedWindow, mOwnerWindow, sLastFocusedModule));
+
+    NS_PRECONDITION(aWindow, "aWindow must not be null");
+
+    if (mLastFocusedWindow == aWindow) {
+        CancelIMEComposition(aWindow);
+        if (mIsIMFocused) {
+            Blur();
+        }
+        mLastFocusedWindow = nsnull;
+    }
+
+    if (mOwnerWindow != aWindow) {
+        return;
+    }
+
+    if (sLastFocusedModule == this) {
+        sLastFocusedModule = nsnull;
+    }
+
+    /**
+     * NOTE:
+     *   The given window is the owner of this, so, we must release the
+     *   contexts now.  But that might be referred from other nsWindows
+     *   (they are children of this.  But we don't know why there are the
+     *   cases).  So, we need to clear the pointers that refers to contexts
+     *   and this if the other referrers are still alive. See bug 349727.
+     */
+    if (mContext) {
+        PrepareToDestroyContext(mContext);
+        gtk_im_context_set_client_window(mContext, nsnull);
+        g_object_unref(G_OBJECT(mContext));
+        mContext = nsnull;
+    }
+
+#ifndef NS_IME_ENABLED_ON_PASSWORD_FIELD
+    if (mSimpleContext) {
+        gtk_im_context_set_client_window(mSimpleContext, nsnull);
+        g_object_unref(G_OBJECT(mSimpleContext));
+        mSimpleContext = nsnull;
+    }
+#endif // NS_IME_ENABLED_ON_PASSWORD_FIELD
+
+    if (mDummyContext) {
+        // mContext and mDummyContext have the same slaveType and signal_data
+        // so no need for another workaround_gtk_im_display_closed.
+        gtk_im_context_set_client_window(mDummyContext, nsnull);
+        g_object_unref(G_OBJECT(mDummyContext));
+        mDummyContext = nsnull;
+    }
+
+    mOwnerWindow = nsnull;
+    mLastFocusedWindow = nsnull;
+    mEnabled = nsIWidget::IME_STATUS_DISABLED;
+
+    PR_LOG(gGtkIMLog, PR_LOG_ALWAYS,
+        ("    SUCCEEDED, Completely destroyed"));
+}
+
+// Work around gtk bug http://bugzilla.gnome.org/show_bug.cgi?id=483223:
+// (and the similar issue of GTK+ IIIM)
+// The GTK+ XIM and IIIM modules register handlers for the "closed" signal
+// on the display, but:
+//  * The signal handlers are not disconnected when the module is unloaded.
+//
+// The GTK+ XIM module has another problem:
+//  * When the signal handler is run (with the module loaded) it tries
+//    XFree (and fails) on a pointer that did not come from Xmalloc.
+//
+// To prevent these modules from being unloaded, use static variables to
+// hold ref of GtkIMContext class.
+// For GTK+ XIM module, to prevent the signal handler from being run,
+// find the signal handlers and remove them.
+//
+// GtkIMContextXIMs share XOpenIM connections and display closed signal
+// handlers (where possible).
+
+void
+nsGtkIMModule::PrepareToDestroyContext(GtkIMContext *aContext)
+{
+    MozContainer* container = mOwnerWindow->GetMozContainer();
+    NS_PRECONDITION(container, "The container of the window is null");
+
+    GtkIMMulticontext *multicontext = GTK_IM_MULTICONTEXT(aContext);
+    GtkIMContext *slave = multicontext->slave;
+    if (!slave) {
+        return;
+    }
+
+    GType slaveType = G_TYPE_FROM_INSTANCE(slave);
+    const gchar *im_type_name = g_type_name(slaveType);
+    if (strcmp(im_type_name, "GtkIMContextXIM") == 0) {
+        if (gtk_check_version(2, 12, 1) == NULL) {
+            return; // gtk bug has been fixed
+        }
+
+        struct GtkIMContextXIM
+        {
+            GtkIMContext parent;
+            gpointer private_data;
+            // ... other fields
+        };
+
+        gpointer signal_data =
+            reinterpret_cast<GtkIMContextXIM*>(slave)->private_data;
+        if (!signal_data) {
+            return;
+        }
+
+        g_signal_handlers_disconnect_matched(
+            gtk_widget_get_display(GTK_WIDGET(container)),
+            G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL, signal_data);
+
+        // Add a reference to prevent the XIM module from being unloaded
+        // and reloaded: each time the module is loaded and used, it
+        // opens (and doesn't close) new XOpenIM connections.
+        static gpointer gtk_xim_context_class =
+            g_type_class_ref(slaveType);
+        // Mute unused variable warning:
+        gtk_xim_context_class = gtk_xim_context_class;
+    } else if (strcmp(im_type_name, "GtkIMContextIIIM") == 0) {
+        // Add a reference to prevent the IIIM module from being unloaded
+        static gpointer gtk_iiim_context_class =
+            g_type_class_ref(slaveType);
+        // Mute unused variable warning:
+        gtk_iiim_context_class = gtk_iiim_context_class;
+    }
+}
+
+void
+nsGtkIMModule::OnFocusWindow(nsWindow* aWindow)
+{
+    if (NS_UNLIKELY(IsDestroyed())) {
+        return;
+    }
+
+    PR_LOG(gGtkIMLog, PR_LOG_ALWAYS,
+        ("GtkIMModule(%p): OnFocusWindow, aWindow=%p, mLastFocusedWindow=%p",
+         this, aWindow));
+    mLastFocusedWindow = aWindow;
+    Focus();
+}
+
+void
+nsGtkIMModule::OnBlurWindow(nsWindow* aWindow)
+{
+    if (NS_UNLIKELY(IsDestroyed())) {
+        return;
+    }
+
+    PR_LOG(gGtkIMLog, PR_LOG_ALWAYS,
+        ("GtkIMModule(%p): OnBlurWindow, aWindow=%p, mLastFocusedWindow=%p, mIsIMFocused=%s",
+         this, aWindow, mLastFocusedWindow, mIsIMFocused ? "YES" : "NO"));
+
+    if (!mIsIMFocused || mLastFocusedWindow != aWindow) {
+        return;
+    }
+
+    Blur();
+}
+
+PRBool
+nsGtkIMModule::OnKeyEvent(nsWindow* aCaller, GdkEventKey* aEvent)
+{
+    NS_PRECONDITION(aEvent, "aEvent must be non-null");
+
+    if (!IsEditable() || NS_UNLIKELY(IsDestroyed())) {
+        return PR_FALSE;
+    }
+
+    PR_LOG(gGtkIMLog, PR_LOG_ALWAYS,
+        ("GtkIMModule(%p): OnKeyEvent, aCaller=%p",
+         this, aCaller));
+    PR_LOG(gGtkIMLog, PR_LOG_ALWAYS,
+        ("    aEvent: type=%s, keyval=0x%X, unicode=0x%X",
+         aEvent->type == GDK_KEY_PRESS ? "GDK_KEY_PRESS" :
+         aEvent->type == GDK_KEY_RELEASE ? "GDK_KEY_RELEASE" : "Unknown",
+         aEvent->keyval, gdk_keyval_to_unicode(aEvent->keyval)));
+
+    if (aCaller != mLastFocusedWindow) {
+        PR_LOG(gGtkIMLog, PR_LOG_ALWAYS,
+            ("    FAILED, the caller isn't focused window, mLastFocusedWindow=%p",
+             mLastFocusedWindow));
+        return PR_FALSE;
+    }
+
+    GtkIMContext* im = GetContext();
+    if (NS_UNLIKELY(!im)) {
+        PR_LOG(gGtkIMLog, PR_LOG_ALWAYS,
+            ("    FAILED, there are no context"));
+        return PR_FALSE;
+    }
+
+    mFilterKeyEvent = PR_TRUE;
+    mProcessingKeyEvent = aEvent;
+    gboolean isFiltered = gtk_im_context_filter_keypress(im, aEvent);
+    mProcessingKeyEvent = nsnull;
+
+    // We filter the key event if the event was not committed (because
+    // it's probably part of a composition) or if the key event was
+    // committed _and_ changed.  This way we still let key press
+    // events go through as simple key press events instead of
+    // composed characters.
+    // Note that we should eat all key events during composition.
+    PRBool filterThisEvent =
+        mIsComposing ? PR_TRUE : isFiltered && mFilterKeyEvent;
+    PR_LOG(gGtkIMLog, PR_LOG_ALWAYS,
+        ("    filterThisEvent=%s (isFiltered=%s, mFilterKeyEvent=%s)",
+         filterThisEvent ? "TRUE" : "FALSE", isFiltered ? "YES" : "NO",
+         mFilterKeyEvent ? "YES" : "NO"));
+
+    return filterThisEvent;
+}
+
+void
+nsGtkIMModule::OnFocusChangeInGecko(PRBool aFocus)
+{
+    PR_LOG(gGtkIMLog, PR_LOG_ALWAYS,
+        ("GtkIMModule(%p): OnFocusChangeInGecko, aFocus=%s mIsComposing=%s, mIsIMFocused=%s, mIgnoreNativeCompositionEvent=%s",
+         this, aFocus ? "YES" : "NO", mIsComposing ? "YES" : "NO",
+         mIsIMFocused ? "YES" : "NO",
+         mIgnoreNativeCompositionEvent ? "YES" : "NO"));
+    if (aFocus) {
+        // If we failed to commit forcedely in previous focused editor,
+        // we should reopen the gate for native signals in new focused editor.
+        mIgnoreNativeCompositionEvent = PR_FALSE;
+    }
+}
+
+void
+nsGtkIMModule::ResetIME()
+{
+    PR_LOG(gGtkIMLog, PR_LOG_ALWAYS,
+        ("GtkIMModule(%p): ResetIME, mIsComposing=%s, mIsIMFocused=%s",
+         this, mIsComposing ? "YES" : "NO", mIsIMFocused ? "YES" : "NO"));
+
+    GtkIMContext *im = GetContext();
+    if (NS_UNLIKELY(!im)) {
+        PR_LOG(gGtkIMLog, PR_LOG_ALWAYS,
+            ("    FAILED, there are no context"));
+        return;
+    }
+
+    mIgnoreNativeCompositionEvent = PR_TRUE;
+    gtk_im_context_reset(im);
+}
+
+nsresult
+nsGtkIMModule::ResetInputState(nsWindow* aCaller)
+{
+    if (NS_UNLIKELY(IsDestroyed())) {
+        return NS_OK;
+    }
+
+    PR_LOG(gGtkIMLog, PR_LOG_ALWAYS,
+        ("GtkIMModule(%p): ResetInputState, aCaller=%p, mIsComposing=%s",
+         this, aCaller, mIsComposing ? "YES" : "NO"));
+
+    if (aCaller != mLastFocusedWindow) {
+        PR_LOG(gGtkIMLog, PR_LOG_ALWAYS,
+            ("    WARNING: the caller isn't focused window, mLastFocusedWindow=%p",
+             mLastFocusedWindow));
+        return NS_OK;
+    }
+
+    if (!mIsComposing) {
+        return NS_OK;
+    }
+
+    // XXX We should commit composition ourselves temporary...
+    ResetIME();
+    CommitCompositionBy(mCompositionString);
+
+    return NS_OK;
+}
+
+nsresult
+nsGtkIMModule::CancelIMEComposition(nsWindow* aCaller)
+{
+    if (NS_UNLIKELY(IsDestroyed())) {
+        return NS_OK;
+    }
+
+    PR_LOG(gGtkIMLog, PR_LOG_ALWAYS,
+        ("GtkIMModule(%p): CancelIMEComposition, aCaller=%p",
+         this, aCaller));
+
+    if (aCaller != mLastFocusedWindow) {
+        PR_LOG(gGtkIMLog, PR_LOG_ALWAYS,
+            ("    FAILED, the caller isn't focused window, mLastFocusedWindow=%p",
+             mLastFocusedWindow));
+        return NS_OK;
+    }
+
+    GtkIMContext *im = GetContext();
+    if (NS_UNLIKELY(!im)) {
+        PR_LOG(gGtkIMLog, PR_LOG_ALWAYS,
+            ("    FAILED, there are no context"));
+        return NS_OK;
+    }
+
+    ResetIME();
+    CommitCompositionBy(EmptyString());
+
+    return NS_OK;
+}
+
+nsresult
+nsGtkIMModule::SetIMEEnabled(nsWindow* aCaller, PRUint32 aState)
+{
+    if (aState == mEnabled || NS_UNLIKELY(IsDestroyed())) {
+        return NS_OK;
+    }
+
+    PR_LOG(gGtkIMLog, PR_LOG_ALWAYS,
+        ("GtkIMModule(%p): SetIMEEnabled, aCaller=%p, aState=%s",
+         this, aCaller, GetEnabledStateName(aState)));
+
+    if (aCaller != mLastFocusedWindow) {
+        PR_LOG(gGtkIMLog, PR_LOG_ALWAYS,
+            ("    FAILED, the caller isn't focused window, mLastFocusedWindow=%p",
+             mLastFocusedWindow));
+        return NS_OK;
+    }
+
+    if (!mContext) {
+        PR_LOG(gGtkIMLog, PR_LOG_ALWAYS,
+            ("    FAILED, there are no context"));
+        return NS_ERROR_NOT_AVAILABLE;
+    }
+
+
+    if (sLastFocusedModule != this) {
+        mEnabled = aState;
+        PR_LOG(gGtkIMLog, PR_LOG_ALWAYS,
+            ("    SUCCEEDED, but we're not active"));
+        return NS_OK;
+    }
+
+    // Release current IME focus if IME is enabled.
+    if (IsEditable()) {
+        ResetInputState(mLastFocusedWindow);
+        Blur();
+    }
+
+    mEnabled = aState;
+
+    // Even when aState is not enabled state, we need to set IME focus.
+    // Because some IMs are updating the status bar of them at this time.
+    // Be aware, don't use aWindow here because this method shouldn't move
+    // focus actually.
+    Focus();
+
+#ifdef MOZ_PLATFORM_MAEMO
+    GtkIMContext *im = GetContext();
+    if (im) {
+        if (IsEnabled()) {
+            // It is not desired that the hildon's autocomplete mechanism displays
+            // user previous entered passwds, so lets make completions invisible
+            // in these cases.
+            int mode;
+            g_object_get(G_OBJECT(im), "hildon-input-mode", &mode, NULL);
+
+            if (mEnabled == nsIWidget::IME_STATUS_ENABLED ||
+                mEnabled == nsIWidget::IME_STATUS_PLUGIN) {
+                mode &= ~HILDON_GTK_INPUT_MODE_INVISIBLE;
+            } else if (mEnabled == nsIWidget::IME_STATUS_PASSWORD) {
+               mode |= HILDON_GTK_INPUT_MODE_INVISIBLE;
+            }
+
+            // Turn off auto-capitalization for editboxes
+            mode &= ~HILDON_GTK_INPUT_MODE_AUTOCAP;
+
+            g_object_set(G_OBJECT(im), "hildon-input-mode",
+                         (HildonGtkInputMode)mode, NULL);
+            gIsVirtualKeyboardOpened = PR_TRUE;
+            hildon_gtk_im_context_show(im);
+        } else {
+            gIsVirtualKeyboardOpened = PR_FALSE;
+            hildon_gtk_im_context_hide(im);
+        }
+    }
+
+    nsCOMPtr<nsIObserverService> observerService =
+        do_GetService("@mozilla.org/observer-service;1");
+    if (observerService) {
+        nsAutoString rectBuf;
+        PRInt32 x, y, w, h;
+        gdk_window_get_position(aCaller->GetGdkWindow(), &x, &y);
+        gdk_window_get_size(aCaller->GetGdkWindow(), &w, &h);
+        rectBuf.Assign(NS_LITERAL_STRING("{\"left\": "));
+        rectBuf.AppendInt(x);
+        rectBuf.Append(NS_LITERAL_STRING(" \"top\": "));
+        rectBuf.AppendInt(y);
+        rectBuf.Append(NS_LITERAL_STRING(", \"right\": "));
+        rectBuf.AppendInt(w);
+        rectBuf.Append(NS_LITERAL_STRING(", \"bottom\": "));
+        rectBuf.AppendInt(h);
+        rectBuf.Append(NS_LITERAL_STRING("}"));
+        observerService->NotifyObservers(nsnull, "softkb-change",
+                                         rectBuf.get());
+    }
+#endif
+
+    return NS_OK;
+}
+
+nsresult
+nsGtkIMModule::GetIMEEnabled(PRUint32* aState)
+{
+    NS_ENSURE_ARG_POINTER(aState);
+    *aState = mEnabled;
+    return NS_OK;
+}
+
+/* static */
+PRBool
+nsGtkIMModule::IsVirtualKeyboardOpened()
+{
+#ifdef MOZ_PLATFORM_MAEMO
+    return gIsVirtualKeyboardOpened;
+#else
+    return PR_FALSE;
+#endif
+}
+
+GtkIMContext*
+nsGtkIMModule::GetContext()
+{
+    if (IsEnabled()) {
+        return mContext;
+    }
+
+#ifndef NS_IME_ENABLED_ON_PASSWORD_FIELD
+    if (mEnabled == nsIWidget::IME_STATUS_PASSWORD) {
+        return mSimpleContext;
+    }
+#endif // NS_IME_ENABLED_ON_PASSWORD_FIELD
+
+    return mDummyContext;
+}
+
+PRBool
+nsGtkIMModule::IsEnabled()
+{
+    return mEnabled == nsIWidget::IME_STATUS_ENABLED ||
+#ifdef NS_IME_ENABLED_ON_PASSWORD_FIELD
+           mEnabled == nsIWidget::IME_STATUS_PASSWORD ||
+#endif // NS_IME_ENABLED_ON_PASSWORD_FIELD
+           mEnabled == nsIWidget::IME_STATUS_PLUGIN;
+}
+
+PRBool
+nsGtkIMModule::IsEditable()
+{
+    return mEnabled == nsIWidget::IME_STATUS_ENABLED ||
+           mEnabled == nsIWidget::IME_STATUS_PLUGIN ||
+           mEnabled == nsIWidget::IME_STATUS_PASSWORD;
+}
+
+void
+nsGtkIMModule::Focus()
+{
+    PR_LOG(gGtkIMLog, PR_LOG_ALWAYS,
+        ("GtkIMModule(%p): Focus, sLastFocusedModule=%p",
+         this, sLastFocusedModule));
+
+    if (mIsIMFocused) {
+        NS_ASSERTION(sLastFocusedModule == this,
+                     "We're not active, but the IM was focused?");
+        return;
+    }
+
+    GtkIMContext *im = GetContext();
+    if (!im) {
+        PR_LOG(gGtkIMLog, PR_LOG_ALWAYS,
+            ("    FAILED, there are no context",
+             this));
+        return;
+    }
+
+    if (sLastFocusedModule && sLastFocusedModule != this) {
+        sLastFocusedModule->Blur();
+    }
+
+    sLastFocusedModule = this;
+
+    gtk_im_context_focus_in(im);
+    mIsIMFocused = PR_TRUE;
+
+    if (!IsEnabled()) {
+        // We should release IME focus for uim and scim.
+        // These IMs are using snooper that is released at losing focus.
+        Blur();
+    }
+}
+
+void
+nsGtkIMModule::Blur()
+{
+    PR_LOG(gGtkIMLog, PR_LOG_ALWAYS,
+        ("GtkIMModule(%p): Blur, mIsIMFocused=%s",
+         this, mIsIMFocused ? "YES" : "NO"));
+
+    if (!mIsIMFocused) {
+        return;
+    }
+
+    GtkIMContext *im = GetContext();
+    if (!im) {
+        PR_LOG(gGtkIMLog, PR_LOG_ALWAYS,
+            ("    FAILED, there are no context"));
+        return;
+    }
+
+    gtk_im_context_focus_out(im);
+    mIsIMFocused = PR_FALSE;
+}
+
+/* static */
+void
+nsGtkIMModule::OnStartCompositionCallback(GtkIMContext *aContext,
+                                          nsGtkIMModule* aModule)
+{
+    aModule->OnStartCompositionNative(aContext);
+}
+
+void
+nsGtkIMModule::OnStartCompositionNative(GtkIMContext *aContext)
+{
+    PR_LOG(gGtkIMLog, PR_LOG_ALWAYS,
+        ("GtkIMModule(%p): OnStartCompositionNative, aContext=%p",
+         this, aContext));
+
+    // See bug 472635, we should do nothing if IM context doesn't match.
+    if (GetContext() != aContext) {
+        PR_LOG(gGtkIMLog, PR_LOG_ALWAYS,
+            ("    FAILED, given context doesn't match, GetContext()=%p",
+             GetContext()));
+        return;
+    }
+
+    if (!DispatchCompositionStart()) {
+        return;
+    }
+    SetCursorPosition(mCompositionStart);
+}
+
+/* static */
+void
+nsGtkIMModule::OnEndCompositionCallback(GtkIMContext *aContext,
+                                        nsGtkIMModule* aModule)
+{
+    aModule->OnEndCompositionNative(aContext);
+}
+
+void
+nsGtkIMModule::OnEndCompositionNative(GtkIMContext *aContext)
+{
+    PR_LOG(gGtkIMLog, PR_LOG_ALWAYS,
+        ("GtkIMModule(%p): OnEndCompositionNative, aContext=%p",
+         this, aContext));
+
+    // See bug 472635, we should do nothing if IM context doesn't match.
+    if (GetContext() != aContext) {
+        PR_LOG(gGtkIMLog, PR_LOG_ALWAYS,
+            ("    FAILED, given context doesn't match, GetContext()=%p",
+             GetContext()));
+        return;
+    }
+
+    // Finish the cancelling mode here rather than DispatchCompositionEnd()
+    // because DispatchCompositionEnd() is called ourselves when we need to
+    // commit the composition string *before* the focus moves completely.
+    // Note that the native commit can be fired *after* ResetIME().
+    mIgnoreNativeCompositionEvent = PR_FALSE;
+
+    if (!mIsComposing) {
+        // If we already handled the commit event, we should do nothing here.
+        return;
+    }
+
+#ifdef PR_LOGGING
+    if (!mCompositionString.IsEmpty()) {
+        PR_LOG(gGtkIMLog, PR_LOG_ALWAYS,
+            ("    WARNING, the composition string is still there"));
+    }
+#endif
+    DispatchCompositionEnd(); // Be aware, widget can be gone
+}
+
+/* static */
+void
+nsGtkIMModule::OnChangeCompositionCallback(GtkIMContext *aContext,
+                                           nsGtkIMModule* aModule)
+{
+    aModule->OnChangeCompositionNative(aContext);
+}
+
+void
+nsGtkIMModule::OnChangeCompositionNative(GtkIMContext *aContext)
+{
+    PR_LOG(gGtkIMLog, PR_LOG_ALWAYS,
+        ("GtkIMModule(%p): OnChangeCompositionNative, aContext=%p",
+         this, aContext));
+
+    // See bug 472635, we should do nothing if IM context doesn't match.
+    if (GetContext() != aContext) {
+        PR_LOG(gGtkIMLog, PR_LOG_ALWAYS,
+            ("    FAILED, given context doesn't match, GetContext()=%p",
+             GetContext()));
+        return;
+    }
+
+    if (ShouldIgnoreNativeCompositionEvent()) {
+        return;
+    }
+
+    GetCompositionString(mCompositionString);
+    if (!mIsComposing && mCompositionString.IsEmpty()) {
+        return; // Don't start the composition with empty string.
+    }
+
+    DispatchTextEvent(PR_TRUE); // Be aware, widget can be gone
+}
+
+/* static */
+void
+nsGtkIMModule::OnCommitCompositionCallback(GtkIMContext *aContext,
+                                           const gchar *aString,
+                                           nsGtkIMModule* aModule)
+{
+    aModule->OnCommitCompositionNative(aContext, aString);
+}
+
+void
+nsGtkIMModule::OnCommitCompositionNative(GtkIMContext *aContext,
+                                         const gchar *aUTF8Char)
+{
+    PR_LOG(gGtkIMLog, PR_LOG_ALWAYS,
+        ("GtkIMModule(%p): OnCommitCompositionNative, aContext=%p, current context=%p",
+         this, aContext, GetContext()));
+
+    // See bug 472635, we should do nothing if IM context doesn't match.
+    if (GetContext() != aContext) {
+        PR_LOG(gGtkIMLog, PR_LOG_ALWAYS,
+            ("    FAILED, given context doesn't match, GetContext()=%p",
+             GetContext()));
+        return;
+    }
+
+    if (ShouldIgnoreNativeCompositionEvent()) {
+        return;
+    }
+
+    // If IME doesn't change their keyevent that generated this commit,
+    // don't send it through XIM - just send it as a normal key press
+    // event.
+    if (!mIsComposing && mProcessingKeyEvent) {
+        char keyval_utf8[8]; /* should have at least 6 bytes of space */
+        gint keyval_utf8_len;
+        guint32 keyval_unicode;
+
+        keyval_unicode = gdk_keyval_to_unicode(mProcessingKeyEvent->keyval);
+        keyval_utf8_len = g_unichar_to_utf8(keyval_unicode, keyval_utf8);
+        keyval_utf8[keyval_utf8_len] = '\0';
+
+        if (!strcmp(aUTF8Char, keyval_utf8)) {
+            PR_LOG(gGtkIMLog, PR_LOG_ALWAYS,
+                ("GtkIMModule(%p): OnCommitCompositionNative, we'll send normal key event",
+                 this));
+            mFilterKeyEvent = PR_FALSE;
+            return;
+        }
+    }
+
+    NS_ConvertUTF8toUTF16 str(aUTF8Char);
+    CommitCompositionBy(str); // Be aware, widget can be gone
+}
+
+PRBool
+nsGtkIMModule::CommitCompositionBy(const nsAString& aString)
+{
+    PR_LOG(gGtkIMLog, PR_LOG_ALWAYS,
+        ("GtkIMModule(%p): CommitCompositionBy, aString=\"%s\", mCompositionString=\"%s\"",
+         this, NS_ConvertUTF16toUTF8(aString).get(),
+         NS_ConvertUTF16toUTF8(mCompositionString).get()));
+
+    mCompositionString = aString;
+    if (!DispatchTextEvent(PR_FALSE)) {
+        return PR_FALSE;
+    }
+    // We should dispatch the compositionend event here because some IMEs
+    // might not fire "preedit_end" native event.
+    return DispatchCompositionEnd(); // Be aware, widget can be gone
+}
+
+void
+nsGtkIMModule::GetCompositionString(nsAString &aCompositionString)
+{
+    gchar *preedit_string;
+    gint cursor_pos;
+    PangoAttrList *feedback_list;
+    gtk_im_context_get_preedit_string(GetContext(), &preedit_string,
+                                      &feedback_list, &cursor_pos);
+    if (preedit_string && *preedit_string) {
+        CopyUTF8toUTF16(preedit_string, aCompositionString);
+    } else {
+        aCompositionString.Truncate();
+    }
+    pango_attr_list_unref(feedback_list);
+    g_free(preedit_string);
+
+    PR_LOG(gGtkIMLog, PR_LOG_ALWAYS,
+        ("GtkIMModule(%p): GetCompositionString, result=\"%s\"",
+         this, preedit_string));
+}
+
+PRBool
+nsGtkIMModule::DispatchCompositionStart()
+{
+    PR_LOG(gGtkIMLog, PR_LOG_ALWAYS,
+        ("GtkIMModule(%p): DispatchCompositionStart", this));
+
+    if (mIsComposing) {
+        PR_LOG(gGtkIMLog, PR_LOG_ALWAYS,
+            ("    WARNING, we're already in composition"));
+        return PR_TRUE;
+    }
+
+    if (!mLastFocusedWindow) {
+        PR_LOG(gGtkIMLog, PR_LOG_ALWAYS,
+            ("    FAILED, there are no focused window in this module"));
+        return PR_FALSE;
+    }
+
+    nsEventStatus status;
+    nsQueryContentEvent selection(PR_TRUE, NS_QUERY_SELECTED_TEXT,
+                                  mLastFocusedWindow);
+    InitEvent(selection);
+    mLastFocusedWindow->DispatchEvent(&selection, status);
+
+    if (!selection.mSucceeded || selection.mReply.mOffset == PR_UINT32_MAX) {
+        PR_LOG(gGtkIMLog, PR_LOG_ALWAYS,
+            ("    FAILED, cannot query the selection offset"));
+        return PR_FALSE;
+    }
+
+    mCompositionStart = selection.mReply.mOffset;
+
+    if (mProcessingKeyEvent && mProcessingKeyEvent->type == GDK_KEY_PRESS) {
+        // If this composition is started by a native keydown event, we need to
+        // dispatch our keydown event here (before composition start).
+        nsCOMPtr<nsIWidget> kungFuDeathGrip = mLastFocusedWindow;
+        PRBool isCancelled;
+        mLastFocusedWindow->DispatchKeyDownEvent(mProcessingKeyEvent,
+                                                 &isCancelled);
+        if (static_cast<nsWindow*>(kungFuDeathGrip.get())->IsDestroyed() ||
+            kungFuDeathGrip != mLastFocusedWindow) {
+            PR_LOG(gGtkIMLog, PR_LOG_ALWAYS,
+                ("    NOTE, the focused widget was destroyed/changed by keydown event"));
+            return PR_FALSE;
+        }
+    }
+
+    if (mIgnoreNativeCompositionEvent) {
+        PR_LOG(gGtkIMLog, PR_LOG_ALWAYS,
+            ("    WARNING, mIgnoreNativeCompositionEvent is already TRUE, but we forcedly reset"));
+        mIgnoreNativeCompositionEvent = PR_FALSE;
+    }
+
+    PR_LOG(gGtkIMLog, PR_LOG_ALWAYS,
+        ("    mCompositionStart=%lu", mCompositionStart));
+    mIsComposing = PR_TRUE;
+    nsCompositionEvent compEvent(PR_TRUE, NS_COMPOSITION_START,
+                                 mLastFocusedWindow);
+    InitEvent(compEvent);
+    nsCOMPtr<nsIWidget> kungFuDeathGrip = mLastFocusedWindow;
+    mLastFocusedWindow->DispatchEvent(&compEvent, status);
+    if (static_cast<nsWindow*>(kungFuDeathGrip.get())->IsDestroyed() ||
+        kungFuDeathGrip != mLastFocusedWindow) {
+        PR_LOG(gGtkIMLog, PR_LOG_ALWAYS,
+            ("    NOTE, the focused widget was destroyed/changed by compositionstart event"));
+        return PR_FALSE;
+    }
+
+    return PR_TRUE;
+}
+
+PRBool
+nsGtkIMModule::DispatchCompositionEnd()
+{
+    PR_LOG(gGtkIMLog, PR_LOG_ALWAYS,
+        ("GtkIMModule(%p): DispatchCompositionEnd", this));
+
+    if (!mIsComposing) {
+        PR_LOG(gGtkIMLog, PR_LOG_ALWAYS,
+            ("    WARNING, we have alrady finished the composition"));
+        return PR_FALSE;
+    }
+
+    if (!mLastFocusedWindow) {
+        PR_LOG(gGtkIMLog, PR_LOG_ALWAYS,
+            ("    FAILED, there are no focused window in this module"));
+        return PR_FALSE;
+    }
+
+    nsCompositionEvent compEvent(PR_TRUE, NS_COMPOSITION_END,
+                                 mLastFocusedWindow);
+    InitEvent(compEvent);
+    nsEventStatus status;
+    nsCOMPtr<nsIWidget> kungFuDeathGrip = mLastFocusedWindow;
+    mLastFocusedWindow->DispatchEvent(&compEvent, status);
+    mIsComposing = PR_FALSE;
+    mCompositionStart = PR_UINT32_MAX;
+    mCompositionString.Truncate();
+    if (static_cast<nsWindow*>(kungFuDeathGrip.get())->IsDestroyed() ||
+        kungFuDeathGrip != mLastFocusedWindow) {
+        PR_LOG(gGtkIMLog, PR_LOG_ALWAYS,
+            ("    NOTE, the focused widget was destroyed/changed by compositionend event"));
+        return PR_FALSE;
+    }
+
+    return PR_TRUE;
+}
+
+PRBool
+nsGtkIMModule::DispatchTextEvent(PRBool aCheckAttr)
+{
+    PR_LOG(gGtkIMLog, PR_LOG_ALWAYS,
+        ("GtkIMModule(%p): DispatchTextEvent, aCheckAttr=%s",
+         this, aCheckAttr ? "TRUE" : "FALSE"));
+
+    if (!mLastFocusedWindow) {
+        PR_LOG(gGtkIMLog, PR_LOG_ALWAYS,
+            ("    FAILED, there are no focused window in this module"));
+        return PR_FALSE;
+    }
+
+    if (!mIsComposing) {
+        PR_LOG(gGtkIMLog, PR_LOG_ALWAYS,
+            ("    The composition wasn't started, force starting..."));
+        nsCOMPtr<nsIWidget> kungFuDeathGrip = mLastFocusedWindow;
+        if (!DispatchCompositionStart()) {
+            return PR_FALSE;
+        }
+    }
+
+    nsTextEvent textEvent(PR_TRUE, NS_TEXT_TEXT, mLastFocusedWindow);
+    InitEvent(textEvent);
+
+    PRUint32 targetOffset = mCompositionStart;
+
+    nsAutoTArray<nsTextRange, 4> textRanges;
+    if (aCheckAttr) {
+        SetTextRangeList(textRanges);
+        for (PRUint32 i = 0; i < textRanges.Length(); i++) {
+            nsTextRange& range = textRanges[i];
+            if (range.mRangeType == NS_TEXTRANGE_SELECTEDRAWTEXT ||
+                range.mRangeType == NS_TEXTRANGE_SELECTEDCONVERTEDTEXT) {
+                targetOffset += range.mStartOffset;
+                break;
+            }
+        }
+    }
+
+    textEvent.rangeCount = textRanges.Length();
+    textEvent.rangeArray = textRanges.Elements();
+    textEvent.theText = mCompositionString.get();
+
+    nsEventStatus status;
+    nsCOMPtr<nsIWidget> kungFuDeathGrip = mLastFocusedWindow;
+    mLastFocusedWindow->DispatchEvent(&textEvent, status);
+    if (static_cast<nsWindow*>(kungFuDeathGrip.get())->IsDestroyed() ||
+        kungFuDeathGrip != mLastFocusedWindow) {
+        PR_LOG(gGtkIMLog, PR_LOG_ALWAYS,
+            ("    NOTE, the focused widget was destroyed/changed by text event"));
+        return PR_FALSE;
+    }
+
+    SetCursorPosition(targetOffset);
+
+    return PR_TRUE;
+}
+
+void
+nsGtkIMModule::SetTextRangeList(nsTArray<nsTextRange> &aTextRangeList)
+{
+    PR_LOG(gGtkIMLog, PR_LOG_ALWAYS,
+        ("GtkIMModule(%p): SetTextRangeList", this));
+
+    NS_PRECONDITION(aTextRangeList.IsEmpty(), "aTextRangeList must be empty");
+
+    gchar *preedit_string;
+    gint cursor_pos;
+    PangoAttrList *feedback_list;
+    gtk_im_context_get_preedit_string(GetContext(), &preedit_string,
+                                      &feedback_list, &cursor_pos);
+    if (!preedit_string || !*preedit_string) {
+        PR_LOG(gGtkIMLog, PR_LOG_ALWAYS,
+            ("    preedit_string is null"));
+        pango_attr_list_unref(feedback_list);
+        g_free(preedit_string);
+        return;
+    }
+
+    PangoAttrIterator* iter;
+    iter = pango_attr_list_get_iterator(feedback_list);
+    if (!iter) {
+        PR_LOG(gGtkIMLog, PR_LOG_ALWAYS,
+            ("    FAILED, iterator couldn't be allocated"));
+        pango_attr_list_unref(feedback_list);
+        g_free(preedit_string);
+        return;
+    }
+
+    /*
+     * Depend on gtk2's implementation on XIM support.
+     * In aFeedback got from gtk2, there are only three types of data:
+     * PANGO_ATTR_UNDERLINE, PANGO_ATTR_FOREGROUND, PANGO_ATTR_BACKGROUND.
+     * Corresponding to XIMUnderline, XIMReverse.
+     * Don't take PANGO_ATTR_BACKGROUND into account, since
+     * PANGO_ATTR_BACKGROUND and PANGO_ATTR_FOREGROUND are always
+     * a couple.
+     */
+    do {
+        PangoAttribute* attrUnderline =
+            pango_attr_iterator_get(iter, PANGO_ATTR_UNDERLINE);
+        PangoAttribute* attrForeground =
+            pango_attr_iterator_get(iter, PANGO_ATTR_FOREGROUND);
+        if (!attrUnderline && !attrForeground) {
+            continue;
+        }
+
+        // Get the range of the current attribute(s)
+        gint start, end;
+        pango_attr_iterator_range(iter, &start, &end);
+
+        nsTextRange range;
+        // XIMReverse | XIMUnderline
+        if (attrUnderline && attrForeground) {
+            range.mRangeType = NS_TEXTRANGE_SELECTEDCONVERTEDTEXT;
+        }
+        // XIMUnderline
+        else if (attrUnderline) {
+            range.mRangeType = NS_TEXTRANGE_CONVERTEDTEXT;
+        }
+        // XIMReverse
+        else if (attrForeground) {
+            range.mRangeType = NS_TEXTRANGE_SELECTEDRAWTEXT;
+        } else {
+            range.mRangeType = NS_TEXTRANGE_RAWINPUT;
+        }
+
+        gunichar2* uniStr = nsnull;
+        if (start == 0) {
+            range.mStartOffset = 0;
+        } else {
+            glong uniStrLen;
+            uniStr = g_utf8_to_utf16(preedit_string, start,
+                                     NULL, &uniStrLen, NULL);
+            if (uniStr) {
+                range.mStartOffset = uniStrLen;
+                g_free(uniStr);
+                uniStr = nsnull;
+            }
+        }
+
+        glong uniStrLen;
+        uniStr = g_utf8_to_utf16(preedit_string + start, end - start,
+                                 NULL, &uniStrLen, NULL);
+        if (!uniStr) {
+            range.mEndOffset = range.mStartOffset;
+        } else {
+            range.mEndOffset = range.mStartOffset + uniStrLen;
+            g_free(uniStr);
+            uniStr = nsnull;
+        }
+
+        aTextRangeList.AppendElement(range);
+
+        PR_LOG(gGtkIMLog, PR_LOG_ALWAYS,
+            ("    mStartOffset=%lu, mEndOffset=%lu, mRangeType=%s",
+             range.mStartOffset, range.mEndOffset,
+             GetRangeTypeName(range.mRangeType)));
+    } while (pango_attr_iterator_next(iter));
+
+    nsTextRange range;
+    if (cursor_pos < 0) {
+        range.mStartOffset = 0;
+    } else if (PRUint32(cursor_pos) > mCompositionString.Length()) {
+        range.mStartOffset = mCompositionString.Length();
+    } else {
+        range.mStartOffset = PRUint32(cursor_pos);
+    }
+    range.mEndOffset = range.mStartOffset;
+    range.mRangeType = NS_TEXTRANGE_CARETPOSITION;
+    aTextRangeList.AppendElement(range);
+
+    PR_LOG(gGtkIMLog, PR_LOG_ALWAYS,
+        ("    mStartOffset=%lu, mEndOffset=%lu, mRangeType=%s",
+         range.mStartOffset, range.mEndOffset,
+         GetRangeTypeName(range.mRangeType)));
+
+    pango_attr_iterator_destroy(iter);
+    pango_attr_list_unref(feedback_list);
+    g_free(preedit_string);
+}
+
+void
+nsGtkIMModule::SetCursorPosition(PRUint32 aTargetOffset)
+{
+    PR_LOG(gGtkIMLog, PR_LOG_ALWAYS,
+        ("GtkIMModule(%p): SetCursorPosition, aTargetOffset=%lu",
+         this, aTargetOffset));
+
+    if (aTargetOffset == PR_UINT32_MAX) {
+        PR_LOG(gGtkIMLog, PR_LOG_ALWAYS,
+            ("    FAILED, aTargetOffset is wrong offset"));
+        return;
+    }
+
+    if (!mLastFocusedWindow) {
+        PR_LOG(gGtkIMLog, PR_LOG_ALWAYS,
+            ("    FAILED, there are no focused window"));
+        return;
+    }
+
+    GtkIMContext *im = GetContext();
+    if (!im) {
+        PR_LOG(gGtkIMLog, PR_LOG_ALWAYS,
+            ("    FAILED, there are no context"));
+        return;
+    }
+
+    nsQueryContentEvent charRect(PR_TRUE, NS_QUERY_TEXT_RECT,
+                                 mLastFocusedWindow);
+    charRect.InitForQueryTextRect(aTargetOffset, 1);
+    InitEvent(charRect);
+    nsEventStatus status;
+    mLastFocusedWindow->DispatchEvent(&charRect, status);
+    if (!charRect.mSucceeded) {
+        PR_LOG(gGtkIMLog, PR_LOG_ALWAYS,
+            ("    FAILED, NS_QUERY_TEXT_RECT was failed"));
+        return;
+    }
+    nsWindow* rootWindow =
+        static_cast<nsWindow*>(mLastFocusedWindow->GetTopLevelWidget());
+
+    // Get the position of the rootWindow in screen.
+    gint rootX, rootY;
+    gdk_window_get_origin(rootWindow->GetGdkWindow(), &rootX, &rootY);
+
+    // Get the position of IM context owner window in screen.
+    gint ownerX, ownerY;
+    gdk_window_get_origin(mOwnerWindow->GetGdkWindow(), &ownerX, &ownerY);
+
+    // Compute the caret position in the IM owner window.
+    GdkRectangle area;
+    area.x = charRect.mReply.mRect.x + rootX - ownerX;
+    area.y = charRect.mReply.mRect.y + rootY - ownerY;
+    area.width  = 0;
+    area.height = charRect.mReply.mRect.height;
+
+    gtk_im_context_set_cursor_location(im, &area);
+}
+
+void
+nsGtkIMModule::InitEvent(nsGUIEvent &aEvent)
+{
+    aEvent.time = PR_Now() / 1000;
+}
+
+PRBool
+nsGtkIMModule::ShouldIgnoreNativeCompositionEvent()
+{
+    PR_LOG(gGtkIMLog, PR_LOG_ALWAYS,
+        ("GtkIMModule(%p): ShouldIgnoreNativeCompositionEvent, mLastFocusedWindow=%p, mIgnoreNativeCompositionEvent=%s",
+         this, mLastFocusedWindow,
+         mIgnoreNativeCompositionEvent ? "YES" : "NO"));
+
+    if (!mLastFocusedWindow) {
+        return PR_TRUE; // cannot continue
+    }
+
+    return mIgnoreNativeCompositionEvent;
+}
diff --git a/widget/src/gtk2/nsGtkIMModule.h b/widget/src/gtk2/nsGtkIMModule.h
new file mode 100644
index 00000000000..016bee9b2c4
--- /dev/null
+++ b/widget/src/gtk2/nsGtkIMModule.h
@@ -0,0 +1,282 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* vim:expandtab:shiftwidth=4:tabstop=4:
+ */
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is Christopher Blizzard
+ * <blizzard@mozilla.org>.  Portions created by the Initial Developer
+ * are Copyright (C) 2001 the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Masayuki Nakano <masayuki@d-toybox.com>
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+#ifndef __nsGtkIMModule_h__
+#define __nsGtkIMModule_h__
+
+#include <gdk/gdk.h>
+#include <gtk/gtk.h>
+
+#include "nsString.h"
+#include "nsAutoPtr.h"
+#include "nsTArray.h"
+#include "nsGUIEvent.h"
+
+// If software keyboard is needed in password field and uses GTK2 IM module
+// for inputting characters, we need to enable IME in password field too.
+#ifdef MOZ_PLATFORM_MAEMO
+#define NS_IME_ENABLED_ON_PASSWORD_FIELD 1
+#endif
+
+class nsWindow;
+
+class nsGtkIMModule
+{
+public:
+    nsrefcnt AddRef()
+    {
+        NS_PRECONDITION(PRInt32(mRefCnt) >= 0, "mRefCnt is negative");
+        ++mRefCnt;
+        NS_LOG_ADDREF(this, mRefCnt, "nsGtkIMModule", sizeof(*this));
+        return mRefCnt;
+    }
+    nsrefcnt Release()
+    {
+        NS_PRECONDITION(mRefCnt != 0, "mRefCnt is alrady zero");
+        --mRefCnt;
+        NS_LOG_RELEASE(this, mRefCnt, "nsGtkIMModule");
+        if (mRefCnt == 0) {
+            mRefCnt = 1; /* stabilize */
+            NS_DELETEXPCOM(this);
+            return 0;
+        }
+        return mRefCnt;
+    }
+
+protected:
+    nsAutoRefCnt mRefCnt;
+
+public:
+    // aOwnerWindow is a pointer of the owner window.  When aOwnerWindow is
+    // destroyed, the related IME contexts are released (i.e., IME cannot be
+    // used with the instance after that).
+    nsGtkIMModule(nsWindow* aOwnerWindow);
+    ~nsGtkIMModule();
+
+    // OnFocusWindow is a notification that aWindow is going to be focused.
+    void OnFocusWindow(nsWindow* aWindow);
+    // OnBlurWindow is a notification that aWindow is going to be unfocused.
+    void OnBlurWindow(nsWindow* aWindow);
+    // OnDestroyWindow is a notification that aWindow is going to be destroyed.
+    void OnDestroyWindow(nsWindow* aWindow);
+    // OnFocusChangeInGecko is a notification that an editor gets focus.
+    void OnFocusChangeInGecko(PRBool aFocus);
+
+    // OnKeyEvent is called when aWindow gets a native key press event or a
+    // native key release event.  If this returns TRUE, the key event was
+    // filtered by IME.  Otherwise, this returns FALSE.
+    // NOTE: When the keypress event starts composition, this returns TRUE but
+    //       this dispatches keydown event before compositionstart event.
+    PRBool OnKeyEvent(nsWindow* aWindow, GdkEventKey* aEvent);
+
+    // IME related nsIWidget methods.
+    nsresult ResetInputState(nsWindow* aCaller);
+    nsresult SetIMEEnabled(nsWindow* aCaller, PRUint32 aState);
+    nsresult GetIMEEnabled(PRUint32* aState);
+    nsresult CancelIMEComposition(nsWindow* aCaller);
+
+    // If a software keyboard has been opened, this returns TRUE.
+    // Otherwise, FALSE.
+    static PRBool IsVirtualKeyboardOpened();
+
+protected:
+    // Owner of an instance of this class. This should be top level window.
+    // The owner window must release the contexts when it's destroyed because
+    // the IME contexts need the native window.  If OnDestroyWindow() is called
+    // with the owner window, it'll release IME contexts.  Otherwise, it'll
+    // just clean up any existing composition if it's related to the destroying
+    // child window.
+    nsWindow* mOwnerWindow;
+
+    // A last focused window in this class's context.
+    nsWindow* mLastFocusedWindow;
+
+    // Actual context. This is used for handling the user's input.
+    GtkIMContext       *mContext;
+
+#ifndef NS_IME_ENABLED_ON_PASSWORD_FIELD
+    // mSimpleContext is used for the password field and
+    // the |ime-mode: disabled;| editors.  These editors disable IME.
+    // But dead keys should work.  Fortunately, the simple IM context of
+    // GTK2 support only them.
+    GtkIMContext       *mSimpleContext;
+#endif // NS_IME_ENABLED_ON_PASSWORD_FIELD
+
+    // mDummyContext is a dummy context and will be used in Focus()
+    // when the state of mEnabled means disabled.  This context's IME state is
+    // always "closed", so it closes IME forcedly.
+    GtkIMContext       *mDummyContext;
+
+    // IME enabled state in this window.  The values is nsIWidget::IME_STATUS_*.
+    // Use following helper methods if you don't need the detail of the status.
+    PRUint32           mEnabled;
+
+    // mCompositionStart is the start offset of the composition string in the
+    // current content.  When <textarea> or <input> have focus, it means offset
+    // from the first character of them.  When a HTML editor has focus, it
+    // means offset from the first character of the root element of the editor.
+    PRUint32 mCompositionStart;
+
+    // mCompositionString is the current composing string. Even if this is
+    // empty, we can be composing.  See mIsComposing.
+    nsString mCompositionString;
+
+    // OnKeyEvent() temporarily sets mProcessingKeyEvent to the given native
+    // event.
+    GdkEventKey* mProcessingKeyEvent;
+
+
+    // mIsComposing is set to TRUE when we dispatch the composition start
+    // event.  And it's set to FALSE when we dispatches the composition end
+    // event.  Note that mCompositionString can be empty string even if this is
+    // TRUE.
+    PRPackedBool mIsComposing;
+    // mIsIMFocused is set to TRUE when we call gtk_im_context_focus_in(). And
+    // it's set to FALSE when we call gtk_im_context_focus_out().
+    PRPackedBool mIsIMFocused;
+    // mFilterKeyEvent is used by OnKeyEvent().  If the commit event should
+    // be processed as simple key event, this is set to TRUE by the commit
+    // handler.
+    PRPackedBool mFilterKeyEvent;
+    // When mIgnoreNativeCompositionEvent is TRUE, all native composition
+    // should be ignored except that the compositon should be restarted in
+    // another content (nsIContent).  Don't refer this value directly, use
+    // ShouldIgnoreNativeCompositionEvent().
+    PRPackedBool mIgnoreNativeCompositionEvent;
+
+    // sLastFocusedModule is a pointer to the last focused instance of this
+    // class.  When a instance is destroyed and sLastFocusedModule refers it,
+    // this is cleared.  So, this refers valid pointer always.
+    static nsGtkIMModule* sLastFocusedModule;
+
+    // Callback methods for native IME events.  These methods should call
+    // the related instance methods simply.
+    static void OnCommitCompositionCallback(GtkIMContext *aContext,
+                                            const gchar *aString,
+                                            nsGtkIMModule* aModule);
+    static void OnChangeCompositionCallback(GtkIMContext *aContext,
+                                            nsGtkIMModule* aModule);
+    static void OnStartCompositionCallback(GtkIMContext *aContext,
+                                           nsGtkIMModule* aModule);
+    static void OnEndCompositionCallback(GtkIMContext *aContext,
+                                         nsGtkIMModule* aModule);
+
+    // The instance methods for the native IME events.
+    void OnCommitCompositionNative(GtkIMContext *aContext,
+                                   const gchar *aString);
+    void OnChangeCompositionNative(GtkIMContext *aContext);
+    void OnStartCompositionNative(GtkIMContext *aContext);
+    void OnEndCompositionNative(GtkIMContext *aContext);
+
+
+    // GetContext() returns current IM context which is chosen by the enabled
+    // state.  So, this means *current* IM context.
+    GtkIMContext* GetContext();
+
+    // "Enabled" means the users can use all IMEs.
+    // I.e., the focus is in the normal editors.
+    PRBool IsEnabled();
+
+    // "Editable" means the users can input characters. They may be not able to
+    // use IMEs but they can use dead keys.
+    // I.e., the focus is in the normal editors or the password editors or
+    // the |ime-mode: disabled;| editors.
+    PRBool IsEditable();
+
+    // If the owner window and IM context have been destroyed, returns TRUE.
+    PRBool IsDestroyed() { return !mOwnerWindow; }
+
+    // Sets focus to the instance of this class.
+    void Focus();
+
+    // Steals focus from the instance of this class.
+    void Blur();
+
+    // Initializes the instance.
+    void Init();
+
+    // Reset the current composition of IME.  All native composition events
+    // during this processing are ignored.
+    void ResetIME();
+
+    // Gets the current composition string by the native APIs.
+    void GetCompositionString(nsAString &aCompositionString);
+
+    // Generates our text range list from current composition string.
+    void SetTextRangeList(nsTArray<nsTextRange> &aTextRangeList);
+
+    // Sets the offset's cursor position to IME.
+    void SetCursorPosition(PRUint32 aTargetOffset);
+
+    // Queries the current selection offset of the window.
+    PRUint32 GetSelectionOffset(nsWindow* aWindow);
+
+    // Initializes the GUI event.
+    void InitEvent(nsGUIEvent& aEvent);
+
+    // Called before destroying the context to work around some platform bugs.
+    void PrepareToDestroyContext(GtkIMContext *aContext);
+
+    PRBool ShouldIgnoreNativeCompositionEvent();
+
+    /**
+     *  WARNING:
+     *    Following methods dispatch gecko events.  Then, the focused widget
+     *    can be destroyed, and also it can be stolen focus.  If they returns
+     *    FALSE, callers cannot continue the composition.
+     *      - CommitCompositionBy
+     *      - DispatchCompositionStart
+     *      - DispatchCompositionEnd
+     *      - DispatchTextEvent
+     */
+
+    // Commits the current composition by the aString.
+    PRBool CommitCompositionBy(const nsAString& aString);
+
+    // Dispatches a composition start event or a composition end event.
+    PRBool DispatchCompositionStart();
+    PRBool DispatchCompositionEnd();
+
+    // Dispatches a text event.  If aCheckAttr is TRUE, dispatches a committed
+    // text event.  Otherwise, dispatches a composing text event.
+    PRBool DispatchTextEvent(PRBool aCheckAttr);
+
+};
+
+#endif // __nsGtkIMModule_h__
diff --git a/widget/src/gtk2/nsWindow.cpp b/widget/src/gtk2/nsWindow.cpp
index b59a4fcb0e7..317915be2e2 100644
--- a/widget/src/gtk2/nsWindow.cpp
+++ b/widget/src/gtk2/nsWindow.cpp
@@ -297,36 +297,8 @@ static PRBool                      gConsumeRollupEvent;
 
 #define NS_WINDOW_TITLE_MAX_LENGTH 4095
 
-#ifdef USE_XIM
-
-static nsWindow    *gIMEFocusWindow = NULL;
-static GdkEventKey *gKeyEvent = NULL;
-static PRBool       gKeyEventCommitted = PR_FALSE;
-static PRBool       gKeyEventChanged = PR_FALSE;
-static PRBool       gIMESuppressCommit = PR_FALSE;
-#ifdef MOZ_PLATFORM_MAEMO
-static PRBool       gIMEVirtualKeyboardOpened = PR_FALSE;
-#endif
-
-static void IM_commit_cb              (GtkIMContext *aContext,
-                                       const gchar *aString,
-                                       nsWindow *aWindow);
-static void IM_commit_cb_internal     (const gchar *aString,
-                                       nsWindow *aWindow);
-static void IM_preedit_changed_cb     (GtkIMContext *aContext,
-                                       nsWindow *aWindow);
-static void IM_set_text_range         (const PRInt32 aLen,
-                                       const gchar *aPreeditString,
-                                       const gint aCursorPos,
-                                       const PangoAttrList *aFeedback,
-                                       PRUint32 *aTextRangeListLengthResult,
-                                       nsTextRangeArray *aTextRangeListResult);
-
-static GtkIMContext *IM_get_input_context(nsWindow *window);
-
 // If after selecting profile window, the startup fail, please refer to
 // http://bugzilla.gnome.org/show_bug.cgi?id=88940
-#endif
 
 // needed for imgIContainer cursors
 // GdkDisplay* was added in 2.2
@@ -450,10 +422,6 @@ nsWindow::nsWindow()
     mDragMotionTimerID = 0;
     mLastMotionPressure = 0;
 
-#ifdef USE_XIM
-    mIMEData = nsnull;
-#endif
-
 #ifdef ACCESSIBILITY
     mRootAccessible  = nsnull;
 #endif
@@ -769,9 +737,9 @@ nsWindow::Destroy(void)
 
     NativeShow(PR_FALSE);
 
-#ifdef USE_XIM
-    IMEDestroyContext();
-#endif
+    if (mIMModule) {
+        mIMModule->OnDestroyWindow(this);
+    }
 
     // make sure that we remove ourself as the focus window
     if (gFocusWindow == this) {
@@ -1428,24 +1396,12 @@ nsWindow::SetFocus(PRBool aRaise)
         return NS_OK;
     }
 
-#ifdef USE_XIM
-    if (gFocusWindow) {
-        // If the focus window and this window share the same input
-        // context we don't have to change the focus of the IME
-        // context
-        nsRefPtr<nsWindow> kungFuDeathGrip = gFocusWindow;
-        if (IM_get_input_context(this) !=
-            IM_get_input_context(gFocusWindow))
-            gFocusWindow->IMELoseFocus();
-    }
-#endif
-
     // Set this window to be the focused child window
     gFocusWindow = this;
 
-#ifdef USE_XIM
-    IMESetFocus();
-#endif
+    if (mIMModule) {
+        mIMModule->OnFocusWindow(this);
+    }
 
     LOGFOCUS(("  widget now has focus in SetFocus() [%p]\n",
               (void *)this));
@@ -3111,9 +3067,9 @@ nsWindow::OnContainerFocusOutEvent(GtkWidget *aWidget, GdkEventFocus *aEvent)
  foundit:
 
     nsRefPtr<nsWindow> kungFuDeathGrip = gFocusWindow;
-#ifdef USE_XIM
-    gFocusWindow->IMELoseFocus();
-#endif
+    if (gFocusWindow->mIMModule) {
+        gFocusWindow->mIMModule->OnBlurWindow(gFocusWindow);
+    }
 
     // We only dispatch a deactivate event if we are a toplevel
     // window, otherwise the embedding code takes care of it.
@@ -3173,26 +3129,56 @@ IsBasicLatinLetterOrNumeral(PRUint32 aChar)
            (aChar >= '0' && aChar <= '9');
 }
 
+static PRBool
+IsCtrlAltTab(GdkEventKey *aEvent)
+{
+    return aEvent->keyval == GDK_Tab &&
+        aEvent->state & GDK_CONTROL_MASK && aEvent->state & GDK_MOD1_MASK;
+}
+
+PRBool
+nsWindow::DispatchKeyDownEvent(GdkEventKey *aEvent, PRBool *aCancelled)
+{
+    NS_PRECONDITION(aCancelled, "aCancelled must not be null");
+
+    *aCancelled = PR_FALSE;
+
+    if (IsCtrlAltTab(aEvent)) {
+        return PR_FALSE;
+    }
+
+    PRUint32 domVirtualKeyCode = GdkKeyCodeToDOMKeyCode(aEvent->keyval);
+
+    if (IsKeyDown(domVirtualKeyCode)) {
+        return PR_FALSE;
+    }
+
+    SetKeyDownFlag(domVirtualKeyCode);
+
+    // send the key down event
+    nsEventStatus status;
+    nsKeyEvent downEvent(PR_TRUE, NS_KEY_DOWN, this);
+    InitKeyEvent(downEvent, aEvent);
+    DispatchEvent(&downEvent, status);
+    *aCancelled = (status == nsEventStatus_eConsumeNoDefault);
+    return PR_TRUE;
+}
+
 gboolean
 nsWindow::OnKeyPressEvent(GtkWidget *aWidget, GdkEventKey *aEvent)
 {
     LOGFOCUS(("OnKeyPressEvent [%p]\n", (void *)this));
 
-#ifdef USE_XIM
     // if we are in the middle of composing text, XIM gets to see it
     // before mozilla does.
-   LOGIM(("key press [%p]: composing %d val %d\n",
-           (void *)this, IMEComposingWindow() != nsnull, aEvent->keyval));
-   if (IMEFilterEvent(aEvent))
-       return TRUE;
-   LOGIM(("sending as regular key press event\n"));
-#endif
+    if (mIMModule && mIMModule->OnKeyEvent(this, aEvent)) {
+        return TRUE;
+    }
 
     nsEventStatus status;
 
     // work around for annoying things.
-    if (aEvent->keyval == GDK_Tab && aEvent->state & GDK_CONTROL_MASK &&
-        aEvent->state & GDK_MOD1_MASK) {
+    if (IsCtrlAltTab(aEvent)) {
         return TRUE;
     }
 
@@ -3205,19 +3191,9 @@ nsWindow::OnKeyPressEvent(GtkWidget *aWidget, GdkEventKey *aEvent)
     // us.
 
     PRBool isKeyDownCancelled = PR_FALSE;
-
-    PRUint32 domVirtualKeyCode = GdkKeyCodeToDOMKeyCode(aEvent->keyval);
-
-    if (!IsKeyDown(domVirtualKeyCode)) {
-        SetKeyDownFlag(domVirtualKeyCode);
-
-        // send the key down event
-        nsKeyEvent downEvent(PR_TRUE, NS_KEY_DOWN, this);
-        InitKeyEvent(downEvent, aEvent);
-        DispatchEvent(&downEvent, status);
-        if (NS_UNLIKELY(mIsDestroyed))
-            return PR_TRUE;
-        isKeyDownCancelled = (status == nsEventStatus_eConsumeNoDefault);
+    if (DispatchKeyDownEvent(aEvent, &isKeyDownCancelled) &&
+        NS_UNLIKELY(mIsDestroyed)) {
+        return TRUE;
     }
 
     // Don't pass modifiers as NS_KEY_PRESS events.
@@ -3355,9 +3331,7 @@ nsWindow::OnKeyPressEvent(GtkWidget *aWidget, GdkEventKey *aEvent)
     }
 
     // If the event was consumed, return.
-    LOGIM(("status %d\n", status));
     if (status == nsEventStatus_eConsumeNoDefault) {
-        LOGIM(("key press consumed\n"));
         return TRUE;
     }
 
@@ -3369,10 +3343,9 @@ nsWindow::OnKeyReleaseEvent(GtkWidget *aWidget, GdkEventKey *aEvent)
 {
     LOGFOCUS(("OnKeyReleaseEvent [%p]\n", (void *)this));
 
-#ifdef USE_XIM
-    if (IMEFilterEvent(aEvent))
+    if (mIMModule && mIMModule->OnKeyEvent(this, aEvent)) {
         return TRUE;
-#endif
+    }
 
     // send the key event as a key up event
     nsKeyEvent event(PR_TRUE, NS_KEY_UP, this);
@@ -3386,7 +3359,6 @@ nsWindow::OnKeyReleaseEvent(GtkWidget *aWidget, GdkEventKey *aEvent)
 
     // If the event was consumed, return.
     if (status == nsEventStatus_eConsumeNoDefault) {
-        LOGIM(("key release consumed\n"));
         return TRUE;
     }
 
@@ -3466,19 +3438,16 @@ nsWindow::OnVisibilityNotifyEvent(GtkWidget *aWidget,
 
         mIsFullyObscured = PR_FALSE;
 
-#ifdef MOZ_PLATFORM_MAEMO
-#ifdef USE_XIM
         // In Hildon/Maemo, a browser window will get into 'patially visible' state wheneven an
         // autocomplete feature is dropped down (from urlbar or from an entry form completion),
         // and there are no much further ways for that to happen in the plaftorm. In such cases, if hildon
         // virtual keyboard is up, we can not grab focus to any dropdown list. Reason: nsWindow::EnsureGrabs()
         // calls gdk_pointer_grab() which grabs the pointer (usually a mouse) so that all events are passed
         // to this it until the pointer is ungrabbed.
-        if(!gIMEVirtualKeyboardOpened)
-#endif // USE_XIM
-#endif // MOZ_PLATFORM_MAEMO
-        // if we have to retry the grab, retry it.
-        EnsureGrabs();
+        if (!nsGtkIMModule::IsVirtualKeyboardOpened()) {
+            // if we have to retry the grab, retry it.
+            EnsureGrabs();
+        }
         break;
     default: // includes GDK_VISIBILITY_FULLY_OBSCURED
         mIsFullyObscured = PR_TRUE;
@@ -4238,12 +4207,16 @@ nsWindow::Create(nsIWidget        *aParent,
         g_signal_connect(G_OBJECT(mContainer), "drag_data_received",
                          G_CALLBACK(drag_data_received_event_cb), NULL);
 
-#ifdef USE_XIM
         // We create input contexts for all containers, except for
         // toplevel popup windows
-        if (mWindowType != eWindowType_popup)
-            IMECreateContext();
-#endif
+        if (mWindowType != eWindowType_popup) {
+            mIMModule = new nsGtkIMModule(this);
+        }
+    } else if (!mIMModule) {
+        nsWindow *container = GetContainerWindow();
+        if (container) {
+            mIMModule = container->mIMModule;
+        }
     }
 
     LOG(("nsWindow [%p]\n", (void *)this));
@@ -6535,583 +6508,41 @@ nsChildWindow::~nsChildWindow()
 {
 }
 
-#ifdef USE_XIM
-
-void
-nsWindow::IMEInitData(void)
-{
-    if (mIMEData)
-        return;
-    nsWindow *win = GetContainerWindow();
-    if (!win)
-        return;
-    mIMEData = win->mIMEData;
-    if (!mIMEData)
-        return;
-    mIMEData->mRefCount++;
-}
-
-void
-nsWindow::IMEReleaseData(void)
-{
-    if (!mIMEData)
-        return;
-
-    mIMEData->mRefCount--;
-    if (mIMEData->mRefCount != 0)
-        return;
-
-    delete mIMEData;
-    mIMEData = nsnull;
-}
-
-// Work around gtk bug http://bugzilla.gnome.org/show_bug.cgi?id=483223:
-// (and the similar issue of GTK+ IIIM)
-// The GTK+ XIM and IIIM modules register handlers for the "closed" signal
-// on the display, but:
-//  * The signal handlers are not disconnected when the module is unloaded.
-//
-// The GTK+ XIM module has another problem:
-//  * When the signal handler is run (with the module loaded) it tries
-//    XFree (and fails) on a pointer that did not come from Xmalloc.
-//
-// To prevent these modules from being unloaded, use static variables to
-// hold ref of GtkIMContext class.
-// For GTK+ XIM module, to prevent the signal handler from being run,
-// find the signal handlers and remove them.
-//
-// GtkIMContextXIMs share XOpenIM connections and display closed signal
-// handlers (where possible).
-
-static void workaround_gtk_im_display_closed(GtkWidget *aGtkWidget,
-                                             GtkIMContext *aContext)
-{
-    GtkIMMulticontext *multicontext = GTK_IM_MULTICONTEXT (aContext);
-    GtkIMContext *slave = multicontext->slave;
-    if (!slave)
-        return;
-
-    GType slaveType = G_TYPE_FROM_INSTANCE(slave);
-    const gchar *im_type_name = g_type_name(slaveType);
-    if (strcmp(im_type_name, "GtkIMContextXIM") == 0) {
-        if (gtk_check_version(2, 12, 1) == NULL) // gtk bug has been fixed
-            return;
-
-        struct GtkIMContextXIM
-        {
-            GtkIMContext parent;
-            gpointer private_data;
-            // ... other fields
-        };
-        gpointer signal_data =
-            reinterpret_cast<GtkIMContextXIM*>(slave)->private_data;
-        if (!signal_data)
-            return; // no corresponding handler
-
-        g_signal_handlers_disconnect_matched(gtk_widget_get_display(aGtkWidget),
-                                             G_SIGNAL_MATCH_DATA, 0, 0, NULL,
-                                             NULL, signal_data);
-
-        // Add a reference to prevent the XIM module from being unloaded
-        // and reloaded: each time the module is loaded and used, it
-        // opens (and doesn't close) new XOpenIM connections.
-        static gpointer gtk_xim_context_class =
-            g_type_class_ref(slaveType);
-        // Mute unused variable warning:
-        gtk_xim_context_class = gtk_xim_context_class;
-    }
-    else if (strcmp(im_type_name, "GtkIMContextIIIM") == 0) {
-        // Add a reference to prevent the IIIM module from being unloaded
-        static gpointer gtk_iiim_context_class =
-            g_type_class_ref(slaveType);
-        // Mute unused variable warning:
-        gtk_iiim_context_class = gtk_iiim_context_class;
-    }
-}
-
-void
-nsWindow::IMEDestroyContext(void)
-{
-    if (!mIMEData || mIMEData->mOwner != this) {
-        // This nsWindow is not the owner of the instance of mIMEData.
-        if (IMEComposingWindow() == this)
-            CancelIMEComposition();
-        if (gIMEFocusWindow == this)
-            gIMEFocusWindow = nsnull;
-        IMEReleaseData();
-        return;
-    }
-
-    /* NOTE:
-     * This nsWindow is the owner of the instance of mIMEData,
-     * so, we must release the contexts now. But that might be referred from
-     * other nsWindows.(They are children of this. But we don't know why there
-     * are the cases.) So, we need to clear the pointers that refers to contexts
-     * and this if the other referrers are still alive. See bug 349727.
-     */
-
-    // If this is the focus window and we have an IM context we need
-    // to unset the focus on this window before we destroy the window.
-    GtkIMContext *im = IMEGetContext();
-    if (im && gIMEFocusWindow && gIMEFocusWindow->IMEGetContext() == im) {
-        gIMEFocusWindow->IMELoseFocus();
-        gIMEFocusWindow = nsnull;
-    }
-
-    mIMEData->mOwner   = nsnull;
-    mIMEData->mEnabled = nsIWidget::IME_STATUS_DISABLED;
-
-    if (mIMEData->mContext) {
-        workaround_gtk_im_display_closed(GTK_WIDGET(mContainer),
-                                         mIMEData->mContext);
-        gtk_im_context_set_client_window(mIMEData->mContext, nsnull);
-        g_object_unref(G_OBJECT(mIMEData->mContext));
-        mIMEData->mContext = nsnull;
-    }
-
-    if (mIMEData->mSimpleContext) {
-        gtk_im_context_set_client_window(mIMEData->mSimpleContext, nsnull);
-        g_object_unref(G_OBJECT(mIMEData->mSimpleContext));
-        mIMEData->mSimpleContext = nsnull;
-    }
-
-    if (mIMEData->mDummyContext) {
-        // mIMEData->mContext and mIMEData->mDummyContext have the same
-        // slaveType and signal_data so no need for another
-        // workaround_gtk_im_display_closed.
-        gtk_im_context_set_client_window(mIMEData->mDummyContext, nsnull);
-        g_object_unref(G_OBJECT(mIMEData->mDummyContext));
-        mIMEData->mDummyContext = nsnull;
-    }
-
-    IMEReleaseData();
-}
-
-void
-nsWindow::IMESetFocus(void)
-{
-    IMEInitData();
-
-    LOGIM(("IMESetFocus %p\n", (void *)this));
-    GtkIMContext *im = IMEGetContext();
-    if (!im)
-        return;
-
-    gtk_im_context_focus_in(im);
-    gIMEFocusWindow = this;
-
-    if (!IMEIsEnabledState()) {
-        // We should release IME focus for uim and scim.
-        // These IMs are using snooper that is released at losing focus.
-        IMELoseFocus();
-    }
-}
-
-void
-nsWindow::IMELoseFocus(void)
-{
-    LOGIM(("IMELoseFocus %p\n", (void *)this));
-    GtkIMContext *im = IMEGetContext();
-    if (!im)
-        return;
-
-    gtk_im_context_focus_out(im);
-}
-
-void
-nsWindow::IMEComposeStart(void)
-{
-    LOGIM(("IMEComposeStart [%p]\n", (void *)this));
-
-    if (!mIMEData) {
-        NS_ERROR("This widget doesn't support IM");
-        return;
-    }
-
-    if (IMEComposingWindow()) {
-        NS_WARNING("tried to re-start text composition\n");
-        return;
-    }
-
-    mIMEData->mComposingWindow = this;
-
-    nsCompositionEvent compEvent(PR_TRUE, NS_COMPOSITION_START, this);
-
-    nsEventStatus status;
-    DispatchEvent(&compEvent, status);
-
-    if (NS_UNLIKELY(mIsDestroyed))
-        return;
-
-    IMESetCursorPosition(compEvent.theReply);
-}
-
-void
-nsWindow::IMEComposeText(const PRUnichar *aText,
-                         const PRInt32 aLen,
-                         const gchar *aPreeditString,
-                         const gint aCursorPos,
-                         const PangoAttrList *aFeedback)
-{
-    if (!mIMEData) {
-        NS_ERROR("This widget doesn't support IM");
-        return;
-    }
-
-    // Send our start composition event if we need to
-    if (!IMEComposingWindow()) {
-        IMEComposeStart();
-        if (NS_UNLIKELY(mIsDestroyed))
-            return;
-    }
-
-
-    LOGIM(("IMEComposeText\n"));
-    nsTextEvent textEvent(PR_TRUE, NS_TEXT_TEXT, this);
-
-    if (aLen != 0) {
-        textEvent.theText = (PRUnichar*)aText;
-
-        if (aPreeditString && aFeedback && (aLen > 0)) {
-            IM_set_text_range(aLen, aPreeditString, aCursorPos, aFeedback,
-                              &(textEvent.rangeCount),
-                              &(textEvent.rangeArray));
-        }
-    }
-
-    nsEventStatus status;
-    DispatchEvent(&textEvent, status);
-
-    if (textEvent.rangeArray) {
-        delete[] textEvent.rangeArray;
-    }
-
-    if (NS_UNLIKELY(mIsDestroyed))
-        return;
-
-    IMESetCursorPosition(textEvent.theReply);
-}
-
-void
-nsWindow::IMEComposeEnd(void)
-{
-    LOGIM(("IMEComposeEnd [%p]\n", (void *)this));
-    NS_ASSERTION(mIMEData, "This widget doesn't support IM");
-
-    if (!IMEComposingWindow()) {
-        NS_WARNING("tried to end text composition before it was started");
-        return;
-    }
-
-    mIMEData->mComposingWindow = nsnull;
-
-    nsCompositionEvent compEvent(PR_TRUE, NS_COMPOSITION_END, this);
-
-    nsEventStatus status;
-    DispatchEvent(&compEvent, status);
-}
-
-GtkIMContext*
-nsWindow::IMEGetContext()
-{
-    return IM_get_input_context(this);
-}
-
-static PRBool
-IsIMEEnabledState(PRUint32 aState)
-{
-#ifdef MOZ_PLATFORM_MAEMO
-    return aState == nsIWidget::IME_STATUS_ENABLED ||
-           aState == nsIWidget::IME_STATUS_PLUGIN  ||
-           aState == nsIWidget::IME_STATUS_PASSWORD;
-#else
-    return aState == nsIWidget::IME_STATUS_ENABLED ||
-           aState == nsIWidget::IME_STATUS_PLUGIN;
-#endif
-}
-
-PRBool
-nsWindow::IMEIsEnabledState(void)
-{
-    return mIMEData ? IsIMEEnabledState(mIMEData->mEnabled) : PR_FALSE;
-}
-
-static PRBool
-IsIMEEditableState(PRUint32 aState)
-{
-    return aState == nsIWidget::IME_STATUS_ENABLED ||
-           aState == nsIWidget::IME_STATUS_PLUGIN ||
-           aState == nsIWidget::IME_STATUS_PASSWORD;
-}
-
-PRBool
-nsWindow::IMEIsEditableState(void)
-{
-    return mIMEData ? IsIMEEditableState(mIMEData->mEnabled) : PR_FALSE;
-}
-
-nsWindow*
-nsWindow::IMEComposingWindow(void)
-{
-    return mIMEData ? mIMEData->mComposingWindow : nsnull;
-}
-
-void
-nsWindow::IMECreateContext(void)
-{
-    mIMEData = new nsIMEData(this);
-    if (!mIMEData)
-        return;
-
-    mIMEData->mContext = gtk_im_multicontext_new();
-    mIMEData->mSimpleContext = gtk_im_context_simple_new();
-    mIMEData->mDummyContext = gtk_im_multicontext_new();
-    if (!mIMEData->mContext || !mIMEData->mSimpleContext ||
-        !mIMEData->mDummyContext) {
-        NS_ERROR("failed to create IM context.");
-        IMEDestroyContext();
-        return;
-    }
-
-    gtk_im_context_set_client_window(mIMEData->mContext,
-                                     GTK_WIDGET(mContainer)->window);
-    gtk_im_context_set_client_window(mIMEData->mSimpleContext,
-                                     GTK_WIDGET(mContainer)->window);
-    gtk_im_context_set_client_window(mIMEData->mDummyContext,
-                                     GTK_WIDGET(mContainer)->window);
-
-    g_signal_connect(G_OBJECT(mIMEData->mContext), "preedit_changed",
-                     G_CALLBACK(IM_preedit_changed_cb), this);
-    g_signal_connect(G_OBJECT(mIMEData->mContext), "commit",
-                     G_CALLBACK(IM_commit_cb), this);
-    g_signal_connect(G_OBJECT(mIMEData->mSimpleContext), "preedit_changed",
-                     G_CALLBACK(IM_preedit_changed_cb), this);
-    g_signal_connect(G_OBJECT(mIMEData->mSimpleContext), "commit",
-                     G_CALLBACK(IM_commit_cb), this);
-}
-
-PRBool
-nsWindow::IMEFilterEvent(GdkEventKey *aEvent)
-{
-    if (!IMEIsEditableState())
-        return FALSE;
-
-    GtkIMContext *im = IMEGetContext();
-    if (!im)
-        return FALSE;
-
-    gKeyEvent = aEvent;
-    gboolean filtered = gtk_im_context_filter_keypress(im, aEvent);
-    gKeyEvent = NULL;
-
-    LOGIM(("key filtered: %d committed: %d changed: %d\n",
-           filtered, gKeyEventCommitted, gKeyEventChanged));
-
-    // We filter the key event if the event was not committed (because
-    // it's probably part of a composition) or if the key event was
-    // committed _and_ changed.  This way we still let key press
-    // events go through as simple key press events instead of
-    // composed characters.
-
-    PRBool retval = PR_FALSE;
-    if (filtered &&
-        (!gKeyEventCommitted || (gKeyEventCommitted && gKeyEventChanged)))
-        retval = PR_TRUE;
-
-    gKeyEventChanged = PR_FALSE;
-    gKeyEventCommitted = PR_FALSE;
-    gKeyEventChanged = PR_FALSE;
-
-    return retval;
-}
-
-void
-nsWindow::IMESetCursorPosition(const nsTextEventReply& aReply)
-{
-    nsIWidget *refWidget = aReply.mReferenceWidget;
-    if (!refWidget) {
-        NS_WARNING("mReferenceWidget is null");
-        refWidget = this;
-    }
-    nsWindow* refWindow = static_cast<nsWindow*>(refWidget);
-
-    nsWindow* ownerWindow = GetContainerWindow();
-    if (!ownerWindow) {
-        NS_ERROR("there is no owner");
-        return;
-    }
-
-    // Get the position of the refWindow in screen.
-    gint refX, refY;
-    gdk_window_get_origin(refWindow->mGdkWindow, &refX, &refY);
-
-    // Get the position of IM context owner window in screen.
-    gint ownerX, ownerY;
-    gdk_window_get_origin(ownerWindow->mGdkWindow, &ownerX, &ownerY);
-
-    // Compute the caret position in the IM owner window.
-    GdkRectangle area;
-    area.x = aReply.mCursorPosition.x + refX - ownerX;
-    area.y = aReply.mCursorPosition.y + refY - ownerY;
-    area.width  = 0;
-    area.height = aReply.mCursorPosition.height;
-
-    gtk_im_context_set_cursor_location(IMEGetContext(), &area);
-}
-
 NS_IMETHODIMP
 nsWindow::ResetInputState()
 {
-    IMEInitData();
-
-    nsRefPtr<nsWindow> win = IMEComposingWindow();
-    if (win) {
-        GtkIMContext *im = IMEGetContext();
-        if (!im)
-            return NS_OK;
-
-        gchar *preedit_string;
-        gint cursor_pos;
-        PangoAttrList *feedback_list;
-        gtk_im_context_get_preedit_string(im, &preedit_string,
-                                          &feedback_list, &cursor_pos);
-        if (preedit_string && *preedit_string) {
-            IM_commit_cb_internal(preedit_string, win);
-            g_free(preedit_string);
-        }
-        if (feedback_list)
-            pango_attr_list_unref(feedback_list);
-    }
-
-    CancelIMEComposition();
-
-    return NS_OK;
-}
-
-NS_IMETHODIMP
-nsWindow::SetIMEOpenState(PRBool aState)
-{
-    return NS_ERROR_NOT_IMPLEMENTED;
-}
-
-NS_IMETHODIMP
-nsWindow::GetIMEOpenState(PRBool* aState)
-{
-    return NS_ERROR_NOT_IMPLEMENTED;
+    return mIMModule ? mIMModule->ResetInputState(this) : NS_OK;
 }
 
 NS_IMETHODIMP
 nsWindow::SetIMEEnabled(PRUint32 aState)
 {
-    IMEInitData();
-    if (!mIMEData)
-        return NS_OK;
-
-    if (aState == mIMEData->mEnabled)
-        return NS_OK;
-
-    GtkIMContext *focusedIm = nsnull;
-    // XXX Don't we need to check gFocusWindow?
-    nsRefPtr<nsWindow> focusedWin = gIMEFocusWindow;
-    if (focusedWin && focusedWin->mIMEData)
-        focusedIm = focusedWin->mIMEData->mContext;
-
-    if (focusedIm && focusedIm == mIMEData->mContext) {
-        // Release current IME focus if IME is enabled.
-        if (IsIMEEditableState(mIMEData->mEnabled)) {
-            focusedWin->ResetInputState();
-            focusedWin->IMELoseFocus();
-        }
-
-        mIMEData->mEnabled = aState;
-
-        // Even when aState is not PR_TRUE, we need to set IME focus.
-        // Because some IMs are updating the status bar of them in this time.
-        focusedWin->IMESetFocus();
-#ifdef MOZ_PLATFORM_MAEMO
-        if (mIMEData->mEnabled) {
-            // It is not desired that the hildon's autocomplete mechanism displays
-            // user previous entered passwds, so lets make completions invisible
-            // in these cases.
-            int mode;
-            g_object_get (G_OBJECT(IMEGetContext()), "hildon-input-mode", &mode, NULL);
-
-            if (mIMEData->mEnabled == nsIWidget::IME_STATUS_ENABLED ||
-                mIMEData->mEnabled == nsIWidget::IME_STATUS_PLUGIN)
-                mode &= ~HILDON_GTK_INPUT_MODE_INVISIBLE;
-            else if (mIMEData->mEnabled == nsIWidget::IME_STATUS_PASSWORD)
-               mode |= HILDON_GTK_INPUT_MODE_INVISIBLE;
-
-            // Turn off auto-capitalization for editboxes
-            mode &= ~HILDON_GTK_INPUT_MODE_AUTOCAP;
-
-            g_object_set (G_OBJECT(IMEGetContext()), "hildon-input-mode", (HildonGtkInputMode)mode, NULL);
-            gIMEVirtualKeyboardOpened = PR_TRUE;
-            hildon_gtk_im_context_show (IMEGetContext());
-        } else {
-            gIMEVirtualKeyboardOpened = PR_FALSE;
-            hildon_gtk_im_context_hide (IMEGetContext());
-        }
-        nsCOMPtr<nsIObserverService> observerService = do_GetService("@mozilla.org/observer-service;1");
-        if (observerService) {
-            nsAutoString rectBuf;
-            PRInt32 x, y, w, h;
-            gdk_window_get_position(mGdkWindow, &x, &y);
-            gdk_window_get_size(mGdkWindow, &w, &h);
-            rectBuf.Assign(NS_LITERAL_STRING("{\"left\": "));
-            rectBuf.AppendInt(x);
-            rectBuf.Append(NS_LITERAL_STRING(" \"top\": "));
-            rectBuf.AppendInt(y);
-            rectBuf.Append(NS_LITERAL_STRING(", \"right\": "));
-            rectBuf.AppendInt(w);
-            rectBuf.Append(NS_LITERAL_STRING(", \"bottom\": "));
-            rectBuf.AppendInt(h);
-            rectBuf.Append(NS_LITERAL_STRING("}"));
-            observerService->NotifyObservers(nsnull, "softkb-change", rectBuf.get());
-        }
-#endif
-    } else {
-        if (IsIMEEditableState(mIMEData->mEnabled))
-            ResetInputState();
-        mIMEData->mEnabled = aState;
-    }
-
-    return NS_OK;
+    return mIMModule ? mIMModule->SetIMEEnabled(this, aState) : NS_OK;
 }
 
 NS_IMETHODIMP
 nsWindow::GetIMEEnabled(PRUint32* aState)
 {
-    NS_ENSURE_ARG_POINTER(aState);
-
-    IMEInitData();
-
-    *aState =
-      mIMEData ? mIMEData->mEnabled : nsIWidget::IME_STATUS_DISABLED;
-    return NS_OK;
+  NS_ENSURE_ARG_POINTER(aState);
+  if (!mIMModule) {
+      *aState = nsIWidget::IME_STATUS_DISABLED;
+      return NS_OK;
+  }
+  return mIMModule->GetIMEEnabled(aState);
 }
 
 NS_IMETHODIMP
 nsWindow::CancelIMEComposition()
 {
-    IMEInitData();
+    return mIMModule ? mIMModule->CancelIMEComposition(this) : NS_OK;
+}
 
-    GtkIMContext *im = IMEGetContext();
-    if (!im)
-        return NS_OK;
-
-    NS_ASSERTION(!gIMESuppressCommit,
-                 "CancelIMEComposition is already called!");
-    gIMESuppressCommit = PR_TRUE;
-    gtk_im_context_reset(im);
-    gIMESuppressCommit = PR_FALSE;
-
-    nsRefPtr<nsWindow> win = IMEComposingWindow();
-    if (win) {
-        win->IMEComposeText(nsnull, 0, nsnull, 0, nsnull);
-        win->IMEComposeEnd();
+NS_IMETHODIMP
+nsWindow::OnIMEFocusChange(PRBool aFocus)
+{
+    if (mIMModule) {
+      mIMModule->OnFocusChangeInGecko(aFocus);
     }
-
     return NS_OK;
 }
 
@@ -7146,274 +6577,6 @@ nsWindow::GetToggledKeyState(PRUint32 aKeyCode, PRBool* aLEDState)
 #endif /* MOZ_X11 */
 }
 
-/* static */
-void
-IM_preedit_changed_cb(GtkIMContext *aContext,
-                      nsWindow     *aWindow)
-{
-    gchar *preedit_string;
-    gint cursor_pos;
-    PangoAttrList *feedback_list;
-
-    // if gFocusWindow is null, use the last focused gIMEFocusWindow
-    nsRefPtr<nsWindow> window = gFocusWindow ? gFocusWindow : gIMEFocusWindow;
-    if (!window || IM_get_input_context(window) != aContext)
-        return;
-
-    // Should use cursor_pos ?
-    // Of course!!!
-    gtk_im_context_get_preedit_string(aContext, &preedit_string,
-                                      &feedback_list, &cursor_pos);
-
-    LOGIM(("preedit string is: %s   length is: %d\n",
-           preedit_string, strlen(preedit_string)));
-
-    if (!preedit_string || !*preedit_string) {
-        LOGIM(("preedit ended\n"));
-        window->IMEComposeText(NULL, 0, NULL, 0, NULL);
-        window->IMEComposeEnd();
-        return;
-    }
-
-    LOGIM(("preedit len %d\n", strlen(preedit_string)));
-
-    gunichar2 * uniStr;
-    glong uniStrLen;
-
-    uniStr = NULL;
-    uniStrLen = 0;
-    uniStr = g_utf8_to_utf16(preedit_string, -1, NULL, &uniStrLen, NULL);
-
-    if (!uniStr) {
-        g_free(preedit_string);
-        LOG(("utf8-utf16 string tranfer failed!\n"));
-        if (feedback_list)
-            pango_attr_list_unref(feedback_list);
-        return;
-    }
-
-    if (uniStrLen) {
-        window->IMEComposeText(static_cast<const PRUnichar *>(uniStr),
-                               uniStrLen, preedit_string, cursor_pos, feedback_list);
-    }
-
-    g_free(preedit_string);
-    g_free(uniStr);
-
-    if (feedback_list)
-        pango_attr_list_unref(feedback_list);
-}
-
-/* static */
-void
-IM_commit_cb(GtkIMContext *aContext,
-             const gchar  *aUtf8_str,
-             nsWindow     *aWindow)
-{
-    if (gIMESuppressCommit)
-        return;
-
-    LOGIM(("IM_commit_cb\n"));
-
-    gKeyEventCommitted = PR_TRUE;
-
-    // if gFocusWindow is null, use the last focused gIMEFocusWindow
-    nsRefPtr<nsWindow> window = gFocusWindow ? gFocusWindow : gIMEFocusWindow;
-
-    if (!window || IM_get_input_context(window) != aContext)
-        return;
-
-    /* If IME doesn't change they keyevent that generated this commit,
-       don't send it through XIM - just send it as a normal key press
-       event. */
-
-    if (gKeyEvent) {
-        char keyval_utf8[8]; /* should have at least 6 bytes of space */
-        gint keyval_utf8_len;
-        guint32 keyval_unicode;
-
-        keyval_unicode = gdk_keyval_to_unicode(gKeyEvent->keyval);
-        keyval_utf8_len = g_unichar_to_utf8(keyval_unicode, keyval_utf8);
-        keyval_utf8[keyval_utf8_len] = '\0';
-
-        if (!strcmp(aUtf8_str, keyval_utf8)) {
-            gKeyEventChanged = PR_FALSE;
-            return;
-        }
-    }
-
-    gKeyEventChanged = PR_TRUE;
-    IM_commit_cb_internal(aUtf8_str, window);
-}
-
-/* static */
-void
-IM_commit_cb_internal(const gchar  *aUtf8_str,
-                      nsWindow     *aWindow)
-{
-    gunichar2 *uniStr = nsnull;
-    glong uniStrLen = 0;
-    uniStr = g_utf8_to_utf16(aUtf8_str, -1, NULL, &uniStrLen, NULL);
-
-    if (!uniStr) {
-        LOGIM(("utf80utf16 string tranfer failed!\n"));
-        return;
-    }
-
-    if (uniStrLen) {
-        aWindow->IMEComposeText((const PRUnichar *)uniStr,
-                                (PRInt32)uniStrLen, nsnull, 0, nsnull);
-        aWindow->IMEComposeEnd();
-    }
-
-    g_free(uniStr);
-}
-
-#define	START_OFFSET(I)	\
-    (*aTextRangeListResult)[I].mStartOffset
-
-#define	END_OFFSET(I) \
-    (*aTextRangeListResult)[I].mEndOffset
-
-#define	SET_FEEDBACKTYPE(I,T) (*aTextRangeListResult)[I].mRangeType = T
-
-/* static */
-void
-IM_set_text_range(const PRInt32 aLen,
-                  const gchar *aPreeditString,
-                  const gint aCursorPos,
-                  const PangoAttrList *aFeedback,
-                  PRUint32 *aTextRangeListLengthResult,
-                  nsTextRangeArray *aTextRangeListResult)
-{
-    if (aLen == 0) {
-        aTextRangeListLengthResult = 0;
-        aTextRangeListResult = NULL;
-        return;
-    }
-
-    PangoAttrIterator * aFeedbackIterator;
-    aFeedbackIterator = pango_attr_list_get_iterator((PangoAttrList*)aFeedback);
-    //(reinterpret_cast<PangoAttrList*>(aFeedback));
-    // Since some compilers don't permit this casting -- from const to un-const
-    if (aFeedbackIterator == NULL) return;
-
-    /*
-     * Don't use pango_attr_iterator_range, it'll mislead you.
-     * As for going through the list to get the attribute number,
-     * it take much time for performance.
-     * Now it's simple and enough, although maybe waste a little space.
-    */
-    PRInt32 aMaxLenOfTextRange;
-    aMaxLenOfTextRange = 2*aLen + 1;
-    *aTextRangeListResult = new nsTextRange[aMaxLenOfTextRange];
-    NS_ASSERTION(*aTextRangeListResult, "No enough memory.");
-
-    // Set caret's postion
-    SET_FEEDBACKTYPE(0, NS_TEXTRANGE_CARETPOSITION);
-    START_OFFSET(0) = aCursorPos;
-    END_OFFSET(0) = aCursorPos;
-
-    int count = 0;
-    PangoAttribute * aPangoAttr;
-    PangoAttribute * aPangoAttrReverse, * aPangoAttrUnderline;
-    /*
-     * Depend on gtk2's implementation on XIM support.
-     * In aFeedback got from gtk2, there are only three types of data:
-     * PANGO_ATTR_UNDERLINE, PANGO_ATTR_FOREGROUND, PANGO_ATTR_BACKGROUND.
-     * Corresponding to XIMUnderline, XIMReverse.
-     * Don't take PANGO_ATTR_BACKGROUND into account, since
-     * PANGO_ATTR_BACKGROUND and PANGO_ATTR_FOREGROUND are always
-     * a couple.
-     */
-    gint start, end;
-    gunichar2 * uniStr;
-    glong uniStrLen;
-    do {
-        aPangoAttrUnderline = pango_attr_iterator_get(aFeedbackIterator,
-                                                      PANGO_ATTR_UNDERLINE);
-        aPangoAttrReverse = pango_attr_iterator_get(aFeedbackIterator,
-                                                    PANGO_ATTR_FOREGROUND);
-        if (!aPangoAttrUnderline && !aPangoAttrReverse)
-            continue;
-
-        // Get the range of the current attribute(s)
-        pango_attr_iterator_range(aFeedbackIterator, &start, &end);
-
-        PRUint32 feedbackType = 0;
-        // XIMReverse | XIMUnderline
-        if (aPangoAttrUnderline && aPangoAttrReverse) {
-            feedbackType = NS_TEXTRANGE_SELECTEDCONVERTEDTEXT;
-            // Doesn't matter which attribute we use here since we
-            // are using pango_attr_iterator_range to determine the
-            // range of the attributes.
-            aPangoAttr = aPangoAttrUnderline;
-        }
-        // XIMUnderline
-        else if (aPangoAttrUnderline) {
-            feedbackType = NS_TEXTRANGE_CONVERTEDTEXT;
-            aPangoAttr = aPangoAttrUnderline;
-        }
-        // XIMReverse
-        else if (aPangoAttrReverse) {
-            feedbackType = NS_TEXTRANGE_SELECTEDRAWTEXT;
-            aPangoAttr = aPangoAttrReverse;
-        }
-
-        count++;
-        START_OFFSET(count) = 0;
-        END_OFFSET(count) = 0;
-
-        uniStr = NULL;
-        if (start > 0) {
-            uniStr = g_utf8_to_utf16(aPreeditString, start,
-                                     NULL, &uniStrLen, NULL);
-        }
-        if (uniStr) {
-            START_OFFSET(count) = uniStrLen;
-            g_free(uniStr);
-        }
-
-        uniStr = NULL;
-        uniStr = g_utf8_to_utf16(aPreeditString + start, end - start,
-                                 NULL, &uniStrLen, NULL);
-        if (uniStr) {
-            END_OFFSET(count) = START_OFFSET(count) + uniStrLen;
-            SET_FEEDBACKTYPE(count, feedbackType);
-            g_free(uniStr);
-        }
-
-    } while ((count < aMaxLenOfTextRange - 1) &&
-             (pango_attr_iterator_next(aFeedbackIterator)));
-
-   *aTextRangeListLengthResult = count + 1;
-
-   pango_attr_iterator_destroy(aFeedbackIterator);
-}
-
-/* static */
-GtkIMContext *
-IM_get_input_context(nsWindow *aWindow)
-{
-    if (!aWindow)
-        return nsnull;
-    nsWindow::nsIMEData *data = aWindow->mIMEData;
-    if (!data)
-        return nsnull;
-    if (data->mEnabled == nsIWidget::IME_STATUS_ENABLED ||
-        data->mEnabled == nsIWidget::IME_STATUS_PLUGIN)
-        return data->mContext;
-    if (data->mEnabled == nsIWidget::IME_STATUS_PASSWORD)
-#ifdef MOZ_PLATFORM_MAEMO
-        return data->mContext;
-#else
-        return data->mSimpleContext;
-#endif
-    return data->mDummyContext;
-}
-
-#endif
-
 #ifdef MOZ_X11
 /* static */ already_AddRefed<gfxASurface>
 nsWindow::GetSurfaceForGdkDrawable(GdkDrawable* aDrawable,
diff --git a/widget/src/gtk2/nsWindow.h b/widget/src/gtk2/nsWindow.h
index c6ae378fc64..1e36e0b1299 100644
--- a/widget/src/gtk2/nsWindow.h
+++ b/widget/src/gtk2/nsWindow.h
@@ -81,15 +81,15 @@
 #include "prlog.h"
 #include "nsTArray.h"
 
+#include "nsGtkIMModule.h"
+
 extern PRLogModuleInfo *gWidgetLog;
 extern PRLogModuleInfo *gWidgetFocusLog;
-extern PRLogModuleInfo *gWidgetIMLog;
 extern PRLogModuleInfo *gWidgetDragLog;
 extern PRLogModuleInfo *gWidgetDrawLog;
 
 #define LOG(args) PR_LOG(gWidgetLog, 4, args)
 #define LOGFOCUS(args) PR_LOG(gWidgetFocusLog, 4, args)
-#define LOGIM(args) PR_LOG(gWidgetIMLog, 4, args)
 #define LOGDRAG(args) PR_LOG(gWidgetDragLog, 4, args)
 #define LOGDRAW(args) PR_LOG(gWidgetDrawLog, 4, args)
 
@@ -97,7 +97,6 @@ extern PRLogModuleInfo *gWidgetDrawLog;
 
 #define LOG(args)
 #define LOGFOCUS(args)
-#define LOGIM(args)
 #define LOGDRAG(args)
 #define LOGDRAW(args)
 
@@ -310,91 +309,22 @@ public:
 
     NS_IMETHOD         BeginResizeDrag   (nsGUIEvent* aEvent, PRInt32 aHorizontal, PRInt32 aVertical);
 
-#ifdef USE_XIM
-    void               IMEInitData       (void);
-    void               IMEReleaseData    (void);
-    void               IMEDestroyContext (void);
-    void               IMESetFocus       (void);
-    void               IMELoseFocus      (void);
-    void               IMEComposeStart   (void);
-    void               IMEComposeText    (const PRUnichar *aText,
-                                          const PRInt32 aLen,
-                                          const gchar *aPreeditString,
-                                          const gint aCursorPos,
-                                          const PangoAttrList *aFeedback);
-    void               IMEComposeEnd     (void);
-    GtkIMContext*      IMEGetContext     (void);
-    // "Enabled" means the users can use all IMEs.
-    // I.e., the focus is in the normal editors.
-    PRBool             IMEIsEnabledState (void);
-    // "Editable" means the users can input characters. They may be not able to
-    // use IMEs but they can use dead keys.
-    // I.e., the forcus is in the normal editors or the password editors or
-    // the |ime-mode: disabled;| editors.
-    PRBool             IMEIsEditableState(void);
-    nsWindow*          IMEComposingWindow(void);
-    void               IMECreateContext  (void);
-    PRBool             IMEFilterEvent    (GdkEventKey *aEvent);
-    void               IMESetCursorPosition(const nsTextEventReply& aReply);
+    MozContainer*      GetMozContainer() { return mContainer; }
+    GdkWindow*         GetGdkWindow() { return mGdkWindow; }
+    PRBool             IsDestroyed() { return mIsDestroyed; }
 
-    /*
-     *  |mIMEData| has all IME data for the window and its children widgets.
-     *  Only stand-alone windows and child windows embedded in non-Mozilla GTK
-     *  containers own IME contexts.
-     *  But this is referred from all children after the widget gets focus.
-     *  The children refers to its owning window's object.
-     */
-    struct nsIMEData {
-        // Actual context. This is used for handling the user's input.
-        GtkIMContext       *mContext;
-        // mSimpleContext is used for the password field and
-        // the |ime-mode: disabled;| editors. These editors disable IME.
-        // But dead keys should work. Fortunately, the simple IM context of
-        // GTK2 support only them.
-        GtkIMContext       *mSimpleContext;
-        // mDummyContext is a dummy context and will be used in IMESetFocus()
-        // when mEnabled is false. This mDummyContext IM state is always
-        // "off", so it works to switch conversion mode to OFF on IM status
-        // window.
-        GtkIMContext       *mDummyContext;
-        // This mComposingWindow is set in IMEComposeStart(), when user starts
-        // composition, then unset in IMEComposeEnd() when user ends the
-        // composition. We will keep the widget where the actual composition is
-        // started. During the composition, we may get some events like
-        // ResetInputStateInternal() and CancelIMECompositionInternal() by
-        // changing input focus, we will use the original widget of
-        // mComposingWindow to commit or reset the composition.
-        nsWindow           *mComposingWindow;
-        // Owner of this struct.
-        // The owner window must release the contexts at destroying.
-        nsWindow           *mOwner;
-        // The reference counter. When this will be zero by the decrement,
-        // the decrementer must free the instance.
-        PRUint32           mRefCount;
-        // IME enabled state in this window.
-        PRUint32           mEnabled;
-        nsIMEData(nsWindow* aOwner) {
-            mContext         = nsnull;
-            mSimpleContext   = nsnull;
-            mDummyContext    = nsnull;
-            mComposingWindow = nsnull;
-            mOwner           = aOwner;
-            mRefCount        = 1;
-            mEnabled         = nsIWidget::IME_STATUS_ENABLED;
-        }
-    };
-    nsIMEData          *mIMEData;
+    // If this dispatched the keydown event actually, this returns TRUE,
+    // otherwise, FALSE.
+    PRBool             DispatchKeyDownEvent(GdkEventKey *aEvent,
+                                            PRBool *aIsCancelled);
 
     NS_IMETHOD ResetInputState();
-    NS_IMETHOD SetIMEOpenState(PRBool aState);
-    NS_IMETHOD GetIMEOpenState(PRBool* aState);
     NS_IMETHOD SetIMEEnabled(PRUint32 aState);
     NS_IMETHOD GetIMEEnabled(PRUint32* aState);
     NS_IMETHOD CancelIMEComposition();
+    NS_IMETHOD OnIMEFocusChange(PRBool aFocus);
     NS_IMETHOD GetToggledKeyState(PRUint32 aKeyCode, PRBool* aLEDState);
 
-#endif
-
    void                ResizeTransparencyBitmap(PRInt32 aNewWidth, PRInt32 aNewHeight);
    void                ApplyTransparencyBitmap();
    virtual void        SetTransparencyMode(nsTransparencyMode aMode);
@@ -568,6 +498,20 @@ private:
         *flag &= ~mask;
     }
 
+    /**
+     * |mIMModule| takes all IME related stuff.
+     *
+     * This is owned by the top-level nsWindow or the topmost child
+     * nsWindow embedded in a non-Gecko widget.
+     *
+     * The instance is created when the top level widget is created.  And when
+     * the widget is destroyed, it's released.  All child windows refer its
+     * ancestor widget's instance.  So, one set of IM contexts is created for
+     * all windows in a hierarchy.  If the children are released after the top
+     * level window is released, the children still have a valid pointer,
+     * however, IME doesn't work at that time.
+     */
+    nsRefPtr<nsGtkIMModule> mIMModule;
 };
 
 class nsChildWindow : public nsWindow {
diff --git a/widget/src/gtkxtbin/Makefile.in b/widget/src/gtkxtbin/Makefile.in
index 2841fde41fd..888da7315ff 100644
--- a/widget/src/gtkxtbin/Makefile.in
+++ b/widget/src/gtkxtbin/Makefile.in
@@ -65,7 +65,7 @@ ifdef MOZ_ENABLE_GTK2
 CFLAGS		+= $(MOZ_GTK2_CFLAGS)
 endif
 
-DEFINES		+= -D_IMPL_GTKXTBIN_API -DUSE_XIM
+DEFINES		+= -D_IMPL_GTKXTBIN_API
 
 ifeq ($(OS_ARCH), OpenVMS)
 DEFINES		+= -DGENERIC_MOTIF_REDEFINES