/****************************************************************************

**

** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the QtGui module of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

/****************************************************************************

**

** Implementation of QXIMInputContext class

**

** Copyright (C) 2003-2004 immodule for Qt Project.  All rights reserved.

**

** This file is written to contribute to Nokia Corporation and/or its subsidiary(-ies) under their own

** license. You may use this file under your Qt license. Following

** description is copied from their original file headers. Contact

** immodule-qt@freedesktop.org if any conditions of this licensing are

** not clear to you.

**

****************************************************************************/

#include "qplatformdefs.h"

#include "qdebug.h"

#include "qximinputcontext_p.h"

#if !defined(QT_NO_IM)

QT_BEGIN_NAMESPACE

#if !defined(QT_NO_XIM)

QT_BEGIN_INCLUDE_NAMESPACE

#include "qplatformdefs.h"

#include "qapplication.h"

#include "qwidget.h"

#include "qstring.h"

#include "qlist.h"

#include "qtextcodec.h"

#include "qevent.h"

#include "qtextformat.h"

#include "qx11info_x11.h"

#include <stdlib.h>

#include <limits.h>

QT_END_INCLUDE_NAMESPACE

// #define QT_XIM_DEBUG

#ifdef QT_XIM_DEBUG

#define XIM_DEBUG qDebug

#else

#define XIM_DEBUG if (0) qDebug

#endif

// from qapplication_x11.cpp

// #### move to X11 struct

extern XIMStyle	qt_xim_preferred_style;

extern char    *qt_ximServer;

extern int qt_ximComposingKeycode;

extern QTextCodec * qt_input_mapper;

XIMStyle QXIMInputContext::xim_style = 0;

// moved from qapplication_x11.cpp

static const XIMStyle xim_default_style = XIMPreeditCallbacks | XIMStatusNothing;

extern "C" {

#ifdef USE_X11R6_XIM

    static void xim_create_callback(XIM /*im*/,

                                    XPointer client_data,

                                    XPointer /*call_data*/)

    {

        QXIMInputContext *qic = reinterpret_cast<QXIMInputContext *>(client_data);

        // qDebug("xim_create_callback");

        qic->create_xim();

    }

    static void xim_destroy_callback(XIM /*im*/,

                                     XPointer client_data,

                                     XPointer /*call_data*/)

    {

        QXIMInputContext *qic = reinterpret_cast<QXIMInputContext *>(client_data);

        // qDebug("xim_destroy_callback");

        qic->close_xim();

        XRegisterIMInstantiateCallback(X11->display, 0, 0, 0,

                                       (XIMProc) xim_create_callback, reinterpret_cast<char *>(qic));

    }

#endif // USE_X11R6_XIM

    static int xic_start_callback(XIC, XPointer client_data, XPointer) {

	QXIMInputContext *qic = (QXIMInputContext *) client_data;

	if (!qic) {

	    XIM_DEBUG("xic_start_callback: no qic");

	    return 0;

	}

        QXIMInputContext::ICData *data = qic->icData();

        if (!data) {

            XIM_DEBUG("xic_start_callback: no ic data");

            return 0;

        }

	XIM_DEBUG("xic_start_callback");

	data->clear();

        data->composing = true;

	return 0;

    }

    static int xic_draw_callback(XIC, XPointer client_data, XPointer call_data) {

	QXIMInputContext *qic = (QXIMInputContext *) client_data;

	if (!qic) {

	    XIM_DEBUG("xic_draw_callback: no qic");

	    return 0;

	}

        QXIMInputContext::ICData *data = qic->icData();

	if (!data) {

	    XIM_DEBUG("xic_draw_callback: no ic data");

	    return 0;

	}

        XIM_DEBUG("xic_draw_callback");

	if(!data->composing) {

	    data->clear();

            data->composing = true;

        }

	XIMPreeditDrawCallbackStruct *drawstruct = (XIMPreeditDrawCallbackStruct *) call_data;

	XIMText *text = (XIMText *) drawstruct->text;

	int cursor = drawstruct->caret, sellen = 0, selstart = 0;

	if (!drawstruct->caret && !drawstruct->chg_first && !drawstruct->chg_length && !text) {

	    if(data->text.isEmpty()) {

		XIM_DEBUG("compose emptied");

		// if the composition string has been emptied, we need

		// to send an InputMethodEnd event

                QInputMethodEvent e;

		qic->sendEvent(e);

		data->clear();

		// if the commit string has coming after here, InputMethodStart

		// will be sent dynamically

	    }

	    return 0;

	}

	if (text) {

	    char *str = 0;

	    if (text->encoding_is_wchar) {

		int l = wcstombs(NULL, text->string.wide_char, text->length);

		if (l != -1) {

		    str = new char[l + 1];

		    wcstombs(str, text->string.wide_char, l);

		    str[l] = 0;

		}

	    } else

		str = text->string.multi_byte;

	    if (!str)

		return 0;

	    QString s = QString::fromLocal8Bit(str);

	    if (text->encoding_is_wchar)

		delete [] str;

	    if (drawstruct->chg_length < 0)

		data->text.replace(drawstruct->chg_first, INT_MAX, s);

	    else

		data->text.replace(drawstruct->chg_first, drawstruct->chg_length, s);

	    if (data->selectedChars.size() < data->text.length()) {

		// expand the selectedChars array if the compose string is longer

		int from = data->selectedChars.size();

		data->selectedChars.resize(data->text.length());

                for (int x = from; x < data->selectedChars.size(); ++x)

                    data->selectedChars.clearBit(x);

	    }

            // determine if the changed chars are selected based on text->feedback

            for (int x = 0; x < text->length; ++x)

                data->selectedChars.setBit(x + drawstruct->chg_first,

                                           (text->feedback ? (text->feedback[x] & XIMReverse) : 0));

            // figure out where the selection starts, and how long it is

            bool started = false;

            for (int x = 0; x < qMin(data->selectedChars.size(), data->text.length()); ++x) {

                if (started) {

                    if (data->selectedChars.testBit(x)) ++sellen;

                    else break;

                } else {

                    if (data->selectedChars.testBit(x)) {

                        selstart = x;

                        started = true;

                        sellen = 1;

                    }

                }

            }

	} else {

	    if (drawstruct->chg_length == 0)

		drawstruct->chg_length = -1;

	    data->text.remove(drawstruct->chg_first, drawstruct->chg_length);

	    bool qt_compose_emptied = data->text.isEmpty();

	    if (qt_compose_emptied) {

		XIM_DEBUG("compose emptied 2 text=%s", data->text.toUtf8().constData());

		// if the composition string has been emptied, we need

		// to send an InputMethodEnd event

                QInputMethodEvent e;

		qic->sendEvent(e);

		data->clear();

		// if the commit string has coming after here, InputMethodStart

		// will be sent dynamically

		return 0;

	    }

	}

        XIM_DEBUG("sending compose: '%s', cursor=%d, sellen=%d",

                  data->text.toUtf8().constData(), cursor, sellen);

        QList<QInputMethodEvent::Attribute> attrs;

        if (selstart > 0)

            attrs << QInputMethodEvent::Attribute(QInputMethodEvent::TextFormat, 0, selstart,

                                                  qic->standardFormat(QInputContext::PreeditFormat));

        if (sellen)

            attrs << QInputMethodEvent::Attribute(QInputMethodEvent::TextFormat, selstart, sellen,

                                                  qic->standardFormat(QInputContext::SelectionFormat));

        if (selstart + sellen < data->text.length())

            attrs << QInputMethodEvent::Attribute(QInputMethodEvent::TextFormat,

                                                  selstart + sellen, data->text.length() - selstart - sellen,

                                                  qic->standardFormat(QInputContext::PreeditFormat));

        attrs << QInputMethodEvent::Attribute(QInputMethodEvent::Cursor, cursor, sellen ? 0 : 1, QVariant());

        QInputMethodEvent e(data->text, attrs);

        data->preeditEmpty = data->text.isEmpty();

	qic->sendEvent(e);

	return 0;

    }

    static int xic_done_callback(XIC, XPointer client_data, XPointer) {

	QXIMInputContext *qic = (QXIMInputContext *) client_data;

	if (!qic)

	    return 0;

        XIM_DEBUG("xic_done_callback");

	// Don't send InputMethodEnd here. QXIMInputContext::x11FilterEvent()

	// handles InputMethodEnd with commit string.

	return 0;

    }

}

void QXIMInputContext::ICData::clear()

{

    text = QString();

    selectedChars.clear();

    composing = false;

    preeditEmpty = true;

}

QXIMInputContext::ICData *QXIMInputContext::icData() const

{

    if (QWidget *w = focusWidget())

        return ximData.value(w->effectiveWinId());

    return 0;

}

/* The cache here is needed, as X11 leaks a few kb for every

   XFreeFontSet call, so we avoid creating and deletion of fontsets as

   much as possible

*/

static XFontSet fontsetCache[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };

static int fontsetRefCount = 0;

static const char * const fontsetnames[] = {

    "-*-fixed-medium-r-*-*-16-*,-*-*-medium-r-*-*-16-*",

    "-*-fixed-medium-i-*-*-16-*,-*-*-medium-i-*-*-16-*",

    "-*-fixed-bold-r-*-*-16-*,-*-*-bold-r-*-*-16-*",

    "-*-fixed-bold-i-*-*-16-*,-*-*-bold-i-*-*-16-*",

    "-*-fixed-medium-r-*-*-24-*,-*-*-medium-r-*-*-24-*",

    "-*-fixed-medium-i-*-*-24-*,-*-*-medium-i-*-*-24-*",

    "-*-fixed-bold-r-*-*-24-*,-*-*-bold-r-*-*-24-*",

    "-*-fixed-bold-i-*-*-24-*,-*-*-bold-i-*-*-24-*"

};

static XFontSet getFontSet(const QFont &f)

{

    int i = 0;

    if (f.italic())

        i |= 1;

    if (f.bold())

        i |= 2;

    if (f.pointSize() > 20)

        i += 4;

    if (!fontsetCache[i]) {

        Display* dpy = X11->display;

        int missCount;

        char** missList;

        fontsetCache[i] = XCreateFontSet(dpy, fontsetnames[i], &missList, &missCount, 0);

        if(missCount > 0)

            XFreeStringList(missList);

        if (!fontsetCache[i]) {

            fontsetCache[i] = XCreateFontSet(dpy, "-*-fixed-*-*-*-*-16-*", &missList, &missCount, 0);

            if(missCount > 0)

                XFreeStringList(missList);

            if (!fontsetCache[i])

                fontsetCache[i] = (XFontSet)-1;

        }

    }

    return (fontsetCache[i] == (XFontSet)-1) ? 0 : fontsetCache[i];

}

QXIMInputContext::QXIMInputContext()

{

    if (!qt_xim_preferred_style) // no configured input style, use the default

        qt_xim_preferred_style = xim_default_style;

    xim = 0;

    QByteArray ximServerName(qt_ximServer);

    if (qt_ximServer)

        ximServerName.prepend("@im=");

    else

        ximServerName = "";

    if (!XSupportsLocale())

#ifndef QT_NO_DEBUG

        qWarning("Qt: Locale not supported on X server")

#endif

            ;

#ifdef USE_X11R6_XIM

    else if (XSetLocaleModifiers (ximServerName.constData()) == 0)

        qWarning("Qt: Cannot set locale modifiers: %s", ximServerName.constData());

    else

        XRegisterIMInstantiateCallback(X11->display, 0, 0, 0,

                                       (XIMProc) xim_create_callback, reinterpret_cast<char *>(this));

#else // !USE_X11R6_XIM

    else if (XSetLocaleModifiers ("") == 0)

        qWarning("Qt: Cannot set locale modifiers");

    else

        QXIMInputContext::create_xim();

#endif // USE_X11R6_XIM

}

/*!\internal

  Creates the application input method.

*/

void QXIMInputContext::create_xim()

{

    ++fontsetRefCount;

#ifndef QT_NO_XIM

    xim = XOpenIM(X11->display, 0, 0, 0);

    if (xim) {

#ifdef USE_X11R6_XIM

        XIMCallback destroy;

        destroy.callback = (XIMProc) xim_destroy_callback;

        destroy.client_data = XPointer(this);

        if (XSetIMValues(xim, XNDestroyCallback, &destroy, (char *) 0) != 0)

            qWarning("Xlib doesn't support destroy callback");

#endif // USE_X11R6_XIM

        XIMStyles *styles = 0;

        XGetIMValues(xim, XNQueryInputStyle, &styles, (char *) 0, (char *) 0);

        if (styles) {

            int i;

            for (i = 0; !xim_style && i < styles->count_styles; i++) {

                if (styles->supported_styles[i] == qt_xim_preferred_style) {

                    xim_style = qt_xim_preferred_style;

                    break;

                }

            }

            // if the preferred input style couldn't be found, look for

            // Nothing

            for (i = 0; !xim_style && i < styles->count_styles; i++) {

                if (styles->supported_styles[i] == (XIMPreeditNothing | XIMStatusNothing)) {

                    xim_style = XIMPreeditNothing | XIMStatusNothing;

                    break;

                }

            }

            // ... and failing that, None.

            for (i = 0; !xim_style && i < styles->count_styles; i++) {

                if (styles->supported_styles[i] == (XIMPreeditNone |

                                                    XIMStatusNone)) {

                    xim_style = XIMPreeditNone | XIMStatusNone;

                    break;

                }

            }

            // qDebug("QApplication: using im style %lx", xim_style);

            XFree((char *)styles);

        }

        if (xim_style) {

#ifdef USE_X11R6_XIM

            XUnregisterIMInstantiateCallback(X11->display, 0, 0, 0,

                                             (XIMProc) xim_create_callback, reinterpret_cast<char *>(this));

#endif // USE_X11R6_XIM

            if (QWidget *focusWidget = QApplication::focusWidget()) {

                // reinitialize input context after the input method

                // server (like SCIM) has been launched without

                // requiring the user to manually switch focus.

                if (focusWidget->testAttribute(Qt::WA_InputMethodEnabled)

                    && focusWidget->testAttribute(Qt::WA_WState_Created)

                    && focusWidget->isEnabled())

                    setFocusWidget(focusWidget);

            }

            // following code fragment is not required for immodule

            // version of XIM

#if 0

            QWidgetList list = qApp->topLevelWidgets();

            for (int i = 0; i < list.size(); ++i) {

                QWidget *w = list.at(i);

                w->d->createTLSysExtra();

            }

#endif

        } else {

            // Give up

            qWarning("No supported input style found."

                     "  See InputMethod documentation.");

            close_xim();

        }

    }

#endif // QT_NO_XIM

}

/*!\internal

  Closes the application input method.

*/

void QXIMInputContext::close_xim()

{

    for(QHash<WId, ICData *>::const_iterator i = ximData.constBegin(),

                                             e = ximData.constEnd(); i != e; ++i) {

        ICData *data = i.value();

        if (data->ic)

            XDestroyIC(data->ic);

        delete data;

    }

    ximData.clear();

    if ( --fontsetRefCount == 0 ) {

	Display *dpy = X11->display;

	for ( int i = 0; i < 8; i++ ) {

	    if ( fontsetCache[i] && fontsetCache[i] != (XFontSet)-1 ) {

		XFreeFontSet(dpy, fontsetCache[i]);

		fontsetCache[i] = 0;

	    }

	}

    }

    setFocusWidget(0);

    xim = 0;

}

QXIMInputContext::~QXIMInputContext()

{

    XIM old_xim = xim; // close_xim clears xim pointer.

    close_xim();

    if (old_xim)

        XCloseIM(old_xim);

}

QString QXIMInputContext::identifierName()

{

    // the name should be "xim" rather than "XIM" to be consistent

    // with corresponding immodule of GTK+

    return QLatin1String("xim");

}

QString QXIMInputContext::language()

{

    QString language;

    if (xim) {

        QByteArray locale(XLocaleOfIM(xim));

        if (locale.startsWith("zh")) {

            // Chinese language should be formed as "zh_CN", "zh_TW", "zh_HK"

            language = QLatin1String(locale.left(5));

        } else {

            // other languages should be two-letter ISO 639 language code

            language = QLatin1String(locale.left(2));

        }

    }

    return language;

}

void QXIMInputContext::reset()