qinputmethod.cpp

Go to the documentation of this file.

// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include <qinputmethod.h>
#include <private/qinputmethod_p.h>
#include <qguiapplication.h>
#include <qtimer.h>
#include <qpa/qplatforminputcontext_p.h>
 
#include <QDebug>
 
QT_BEGIN_NAMESPACE
 
QInputMethod::QInputMethod()
    : QObject(*new QInputMethodPrivate)
{
}
 
QInputMethod::~QInputMethod()
{
}
 
QTransform QInputMethod::inputItemTransform() const
{
    Q_D(const QInputMethod);
    return d->inputItemTransform;
}
 
void QInputMethod::setInputItemTransform(const QTransform &transform)
{
    Q_D(QInputMethod);
    if (d->inputItemTransform == transform)
        return;
 
    d->inputItemTransform = transform;
    emit cursorRectangleChanged();
    emit anchorRectangleChanged();
}
 
 
QRectF QInputMethod::inputItemRectangle() const
{
    Q_D(const QInputMethod);
    return d->inputRectangle;
}
 
void QInputMethod::setInputItemRectangle(const QRectF &rect)
{
    Q_D(QInputMethod);
    d->inputRectangle = rect;
}
 
static QRectF inputMethodQueryRectangle_helper(Qt::InputMethodQuery imquery, const QTransform &xform)
{
    QRectF r;
    if (QObject *focusObject = qGuiApp->focusObject()) {
        QInputMethodQueryEvent query(imquery);
        QGuiApplication::sendEvent(focusObject, &query);
        r = query.value(imquery).toRectF();
        if (r.isValid())
            r = xform.mapRect(r);
    }
    return r;
}
 
QRectF QInputMethod::cursorRectangle() const
{
    Q_D(const QInputMethod);
    return inputMethodQueryRectangle_helper(Qt::ImCursorRectangle, d->inputItemTransform);
}
 
QRectF QInputMethod::anchorRectangle() const
{
    Q_D(const QInputMethod);
    return inputMethodQueryRectangle_helper(Qt::ImAnchorRectangle, d->inputItemTransform);
}
 
QRectF QInputMethod::keyboardRectangle() const
{
    Q_D(const QInputMethod);
    QPlatformInputContext *ic = d->platformInputContext();
    if (ic)
        return ic->keyboardRect();
    return QRectF();
}
 
QRectF QInputMethod::inputItemClipRectangle() const
{
    Q_D(const QInputMethod);
    return inputMethodQueryRectangle_helper(Qt::ImInputItemClipRectangle, d->inputItemTransform);
}
void QInputMethod::show()
{
    Q_D(QInputMethod);
    QPlatformInputContext *ic = d->platformInputContext();
    if (ic)
        ic->showInputPanel();
}
 
void QInputMethod::hide()
{
    Q_D(QInputMethod);
    QPlatformInputContext *ic = d->platformInputContext();
    if (ic)
        ic->hideInputPanel();
}
 
bool QInputMethod::isVisible() const
{
    Q_D(const QInputMethod);
    QPlatformInputContext *ic = d->platformInputContext();
    if (ic)
        return ic->isInputPanelVisible();
    return false;
}
 
void QInputMethod::setVisible(bool visible)
{
    visible ? show() : hide();
}
 
bool QInputMethod::isAnimating() const
{
    Q_D(const QInputMethod);
    QPlatformInputContext *ic = d->platformInputContext();
    if (ic)
        return ic->isAnimating();
    return false;
}
 
QLocale QInputMethod::locale() const
{
    Q_D(const QInputMethod);
    QPlatformInputContext *ic = d->platformInputContext();
    if (ic)
        return ic->locale();
    return QLocale::c();
}
 
Qt::LayoutDirection QInputMethod::inputDirection() const
{
    Q_D(const QInputMethod);
    QPlatformInputContext *ic = d->platformInputContext();
    if (ic)
        return ic->inputDirection();
    return Qt::LeftToRight;
}
 
void QInputMethod::update(Qt::InputMethodQueries queries)
{
    Q_D(QInputMethod);
 
    if (queries & Qt::ImEnabled) {
        QObject *focus = qApp->focusObject();
        bool enabled = d->objectAcceptsInputMethod(focus);
        QPlatformInputContextPrivate::setInputMethodAccepted(enabled);
    }
 
    QPlatformInputContext *ic = d->platformInputContext();
    if (ic)
        ic->update(queries);
 
    if (queries & Qt::ImCursorRectangle)
        emit cursorRectangleChanged();
 
    if (queries & (Qt::ImAnchorRectangle))
        emit anchorRectangleChanged();
 
    if (queries & (Qt::ImInputItemClipRectangle))
        emit inputItemClipRectangleChanged();
}
 
void QInputMethod::reset()
{
    Q_D(QInputMethod);
    QPlatformInputContext *ic = d->platformInputContext();
    if (ic)
        ic->reset();
}
 
void QInputMethod::commit()
{
    Q_D(QInputMethod);
    QPlatformInputContext *ic = d->platformInputContext();
    if (ic)
        ic->commit();
}
 
void QInputMethod::invokeAction(Action a, int cursorPosition)
{
    Q_D(QInputMethod);
    QPlatformInputContext *ic = d->platformInputContext();
    if (ic)
        ic->invokeAction(a, cursorPosition);
}
 
static inline bool platformSupportsHiddenText()
{
    const QPlatformInputContext *inputContext = QGuiApplicationPrivate::platformIntegration()->inputContext();
    return inputContext && inputContext->hasCapability(QPlatformInputContext::HiddenTextCapability);
}
 
bool QInputMethodPrivate::objectAcceptsInputMethod(QObject *object)
{
    bool enabled = false;
    if (object) {
        // If the platform does not support hidden text, query the hints
        // in addition and disable in case of ImhHiddenText.
        static const bool supportsHiddenText = platformSupportsHiddenText();
        QInputMethodQueryEvent query(supportsHiddenText
                                     ? Qt::InputMethodQueries(Qt::ImEnabled)
                                     : Qt::InputMethodQueries(Qt::ImEnabled | Qt::ImHints));
        QGuiApplication::sendEvent(object, &query);
        enabled = query.value(Qt::ImEnabled).toBool();
        if (enabled && !supportsHiddenText
            && Qt::InputMethodHints(query.value(Qt::ImHints).toInt()).testFlag(Qt::ImhHiddenText)) {
            enabled = false;
        }
    }
    return enabled;
}
 
QVariant QInputMethod::queryFocusObject(Qt::InputMethodQuery query, const QVariant &argument)
{
    QVariant retval;
    QObject *focusObject = qGuiApp->focusObject();
    if (!focusObject)
        return retval;
 
    static const char *signature = "inputMethodQuery(Qt::InputMethodQuery,QVariant)";
    const bool newMethodSupported = focusObject->metaObject()->indexOfMethod(signature) != -1;
    if (newMethodSupported) {
        const bool ok = QMetaObject::invokeMethod(focusObject, "inputMethodQuery",
                                                        Qt::DirectConnection,
                                                        Q_RETURN_ARG(QVariant, retval),
                                                        Q_ARG(Qt::InputMethodQuery, query),
                                                        Q_ARG(QVariant, argument));
        Q_ASSERT(ok);
        if (retval.isValid())
            return retval;
 
        // If the new API didn't have an answer to the query, we fall
        // back to use the old event-based API.
    }
 
    QInputMethodQueryEvent queryEvent(query);
    QCoreApplication::sendEvent(focusObject, &queryEvent);
    return queryEvent.value(query);
}
 
QT_END_NAMESPACE
 
#include "moc_qinputmethod.cpp"