qohosinputcontext.cpp

Go to the documentation of this file.

// Copyright (C) 2025 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 "qohosinputcontext.h"
#include <QtCore/private/qnapi_p.h>
#include <QtCore/private/qohoslogger_p.h>
#include <QtCore/qnamespace.h>
#include <QtGui/private/qhighdpiscaling_p.h>
#include "qohosjsmain.h"
#include "qohosplatformintegration.h"
#include "qohosplatformscreen.h"
#include <QtCore/qrect.h>
#include <QtGui/qinputdevice.h>
#include <QtGui/qguiapplication.h>
#include <QtGui/qtextformat.h>
#include <algorithm>
#include <qohosjsutils.h>
#include <inputmethod/inputmethod_controller_capi.h>
 
QT_BEGIN_NAMESPACE
 
namespace {
 
const Qt::InputMethodHints defaultInputMethodHints = Qt::ImhNone;
const Qt::EnterKeyType defaultEnterKeyType = Qt::EnterKeyDefault;
 
::InputMethod_TextInputType mapQtInputMethodHintsToOhosImeTextInputType(Qt::InputMethodHints hints)
{
    using TextInputType = ::InputMethod_TextInputType;
    if (hints & Qt::ImhMultiLine) {
        return TextInputType::IME_TEXT_INPUT_TYPE_MULTILINE;
    } else if (hints & Qt::ImhDigitsOnly) {
        return (hints & Qt::ImhHiddenText)
            ? TextInputType::IME_TEXT_INPUT_TYPE_NUMBER_PASSWORD
            : TextInputType::IME_TEXT_INPUT_TYPE_NUMBER;
    } else if (hints & Qt::ImhDialableCharactersOnly) {
        return TextInputType::IME_TEXT_INPUT_TYPE_PHONE;
    } else if (hints & (Qt::ImhDate | Qt::ImhTime)) {
        return TextInputType::IME_TEXT_INPUT_TYPE_DATETIME;
    } else if (hints & Qt::ImhEmailCharactersOnly) {
        return TextInputType::IME_TEXT_INPUT_TYPE_EMAIL_ADDRESS;
    } else if (hints & Qt::ImhUrlCharactersOnly) {
        return TextInputType::IME_TEXT_INPUT_TYPE_URL;
    } else if (hints & Qt::ImhHiddenText) {
        return TextInputType::IME_TEXT_INPUT_TYPE_VISIBLE_PASSWORD;
    } else {
        return TextInputType::IME_TEXT_INPUT_TYPE_TEXT;
    }
}
 
std::optional<QOhosInputContext::Direction> tryMapInputMethodDirectionToQt(::InputMethod_Direction direction)
{
    switch (direction) {
    case ::InputMethod_Direction::IME_DIRECTION_NONE:
        return {};
    case ::InputMethod_Direction::IME_DIRECTION_UP:
        return QOhosInputContext::Direction::CURSOR_UP;
    case ::InputMethod_Direction::IME_DIRECTION_DOWN:
        return QOhosInputContext::Direction::CURSOR_DOWN;
    case ::InputMethod_Direction::IME_DIRECTION_LEFT:
        return QOhosInputContext::Direction::CURSOR_LEFT;
    case ::InputMethod_Direction::IME_DIRECTION_RIGHT:
        return QOhosInputContext::Direction::CURSOR_RIGHT;
    }
    return {};
}
 
::InputMethod_EnterKeyType mapQtToOhosImeEnterKeyType(Qt::EnterKeyType qtEnterKeyType)
{
    switch (qtEnterKeyType) {
    case Qt::EnterKeyType::EnterKeyReturn:
        return ::InputMethod_EnterKeyType::IME_ENTER_KEY_NEWLINE;
    case Qt::EnterKeyType::EnterKeyDone:
        return ::InputMethod_EnterKeyType::IME_ENTER_KEY_DONE;
    case Qt::EnterKeyType::EnterKeyGo:
        return ::InputMethod_EnterKeyType::IME_ENTER_KEY_GO;
    case Qt::EnterKeyType::EnterKeySend:
        return ::InputMethod_EnterKeyType::IME_ENTER_KEY_SEND;
    case Qt::EnterKeyType::EnterKeySearch:
        return ::InputMethod_EnterKeyType::IME_ENTER_KEY_SEARCH;
    case Qt::EnterKeyType::EnterKeyNext:
        return ::InputMethod_EnterKeyType::IME_ENTER_KEY_NEXT;
    case Qt::EnterKeyType::EnterKeyPrevious:
        return ::InputMethod_EnterKeyType::IME_ENTER_KEY_PREVIOUS;
    case Qt::EnterKeyType::EnterKeyDefault:
        return ::InputMethod_EnterKeyType::IME_ENTER_KEY_NONE;
    }
    qOhosPrintfError(
        "%s: Cannot map Qt::EnterKeyType to OHOS value. Returning ::InputMethod_EnterKeyType::IME_ENTER_KEY_UNSPECIFIED",
        Q_FUNC_INFO);
    return ::InputMethod_EnterKeyType::IME_ENTER_KEY_UNSPECIFIED;
}
 
::InputMethod_RequestKeyboardReason mapQtToOhosImeRequestReason(
    QOhosInputContext::RequestKeyboardReason qtRequestKeyboardReason)
{
    switch (qtRequestKeyboardReason) {
    case QOhosInputContext::RequestKeyboardReason::NONE:
        return ::InputMethod_RequestKeyboardReason::IME_REQUEST_REASON_NONE;
    case QOhosInputContext::RequestKeyboardReason::MOUSE:
        return ::InputMethod_RequestKeyboardReason::IME_REQUEST_REASON_MOUSE;
    case QOhosInputContext::RequestKeyboardReason::TOUCH:
        return ::InputMethod_RequestKeyboardReason::IME_REQUEST_REASON_TOUCH;
    case QOhosInputContext::RequestKeyboardReason::OTHER:
        return ::InputMethod_RequestKeyboardReason::IME_REQUEST_REASON_OTHER;
    }
    qOhosPrintfError(
        "%s: Cannot map QOhosInputContext::RequestKeyboardReason to OHOS value. Returning ::InputMethod_RequestKeyboardReason::IME_REQUEST_REASON_NONE",
        Q_FUNC_INFO);
    return ::InputMethod_RequestKeyboardReason::IME_REQUEST_REASON_NONE;
}
 
std::optional<int> tryGetIntPropertyFromQuery(Qt::InputMethodQuery property, QSharedPointer<QInputMethodQueryEvent> query)
{
    bool converted;
    const auto value = query->value(property).toInt(&converted);
    return converted ? std::optional(value) : std::nullopt;
}
 
inline QPoint clampToRect(const QPoint &p, const QRect &rect)
{
    int x = qBound(rect.left(), p.x(), rect.right());
    int y = qBound(rect.top(), p.y(), rect.bottom());
    return QPoint(x, y);
}
 
std::pair<QString, QString> queryQtImTextAroundCursorOrEmpty()
{
    auto *focusObject = QGuiApplication::focusObject();
    if (!focusObject)
        return {};
 
    QInputMethodQueryEvent directEvent(Qt::ImTextBeforeCursor | Qt::ImTextAfterCursor);
    QCoreApplication::sendEvent(focusObject, &directEvent);
 
    const auto textBeforeCursorResult = directEvent.value(Qt::ImTextBeforeCursor);
    const auto textAfterCursorResult = directEvent.value(Qt::ImTextAfterCursor);
    if (textBeforeCursorResult.canConvert<QString>() && textAfterCursorResult.canConvert<QString>())
        return {textBeforeCursorResult.toString(), textAfterCursorResult.toString()};
 
    QInputMethodQueryEvent fallbackEvent(Qt::ImSurroundingText | Qt::ImCursorPosition);
    QCoreApplication::sendEvent(focusObject, &fallbackEvent);
 
    const auto surroundingTextResult = fallbackEvent.value(Qt::ImSurroundingText);
    const auto cursorPositionResult = fallbackEvent.value(Qt::ImCursorPosition);
 
    if (!surroundingTextResult.canConvert<QString>() || !cursorPositionResult.canConvert<int>())
        return {};
 
    const auto cursorPos = cursorPositionResult.toInt();
    if (cursorPos < 0)
        return {};
 
    const QString text = surroundingTextResult.toString();
    return {text.left(cursorPos), text.mid(cursorPos)};
}
 
}
 
QOhosInputContext::QOhosInputContext()
    : QPlatformInputContext()
    , m_lastCursorRectangle(0, 0, 0, 0)
    , m_qtImEnabled(false)
    , m_qtInputMethodHints(defaultInputMethodHints)
    , m_qtEnterKeyType(defaultEnterKeyType)
    , m_jsScopeData(
        QtOhos::makeProxyWithJsThreadDeleter(
            std::make_shared<JsScopeData>()))
{
    auto __dbg = make_QCScopedDebug("QOhosInputContext::QOhosInputContext");
 
    QObject::connect(
        QGuiApplication::inputMethod(), &QInputMethod::cursorRectangleChanged,
        this, &QOhosInputContext::onCursorRectangleChanged);
 
    QGuiApplication::instance()->installEventFilter(this);
}
 
QOhosInputContext::~QOhosInputContext() = default;
 
void QOhosInputContext::reset()
{
    if (m_imConnectionState == ImConnectionState::Attached) {
        setImConnectionState(ImConnectionState::Detached);
        setImConnectionState(ImConnectionState::Attached);
    }
}
 
void QOhosInputContext::commit()
{
    auto __dbg = make_QCScopedDebug("QOhosInputContext::commit");
 
    const QString phrase = std::exchange(m_pendingPreeditText, {});
    const auto replaceRange = std::exchange(m_previewReplaceRange, {});
 
    if (phrase.isEmpty())
        return;
 
    QInputMethodEvent event;
    event.setCommitString(phrase, replaceRange.from, replaceRange.length);
    sendFocusObjectInputMethodEvent(&event);
}
 
void QOhosInputContext::update(Qt::InputMethodQueries queries)
{
    if (!focusObjectOrNull()) {
        hideInputPanel();
        return;
    }
 
    m_qtImEnabled = queryImEnabled();
    const auto qtInputMethodHintsValue = queryInputMethodHints();
    const auto qtEnterKeyTypeValue = queryEnterKeyType();
 
    const bool imStateChanged =
        m_qtInputMethodHints != qtInputMethodHintsValue
        || m_qtEnterKeyType != qtEnterKeyTypeValue;
 
    auto imAlreadyAttached = m_imConnectionState == ImConnectionState::Attached;
    if (imAlreadyAttached && imStateChanged)
        updateInputMethodControllerAttributes(qtInputMethodHintsValue, qtEnterKeyTypeValue);
 
    m_qtInputMethodHints = qtInputMethodHintsValue;
    m_qtEnterKeyType = qtEnterKeyTypeValue;
 
    if (inputMethodAccepted() && m_qtImEnabled) {
        if (imAlreadyAttached) {
            pushTextAroundCursorToProxy();
            updateSelection();
        }
 
        auto updateCausedByWidgetTransform = queries == Qt::ImInputItemClipRectangle;
        auto updateCausedByQueryAllImParameters = queries == Qt::ImQueryAll;
 
        if (updateCausedByQueryAllImParameters)
            return;
 
        if (!updateCausedByWidgetTransform || !imAlreadyAttached) {
            showInputPanel();
        }
    } else {
        hideInputPanel();
    }
}
 
void QOhosInputContext::invokeAction(QInputMethod::Action, int)
{
    auto __dbg = make_QCScopedDebug("QOhosInputContext::invokeAction");
}
 
QRectF QOhosInputContext::keyboardRect() const
{
    auto __dbg = make_QCScopedDebug("QOhosInputContext::keyboardRect");
    return {};
}
 
bool QOhosInputContext::isAnimating() const
{
    auto __dbg = make_QCScopedDebug("QOhosInputContext::isAnimating");
    return {};
}
 
void QOhosInputContext::showInputPanel()
{
    auto __dbg = make_QCScopedDebug("QOhosInputContext::showInputPanel");
    setImConnectionState(ImConnectionState::Attached);
}
 
void QOhosInputContext::hideInputPanel()
{
    auto __dbg = make_QCScopedDebug("QOhosInputContext::hideInputPanel");
    setImConnectionState(ImConnectionState::Detached);
}
 
bool QOhosInputContext::isInputPanelVisible() const
{
    auto __dbg = make_QCScopedDebug("QOhosInputContext::isInputPanelVisible");
    return m_imConnectionRequestedState == ImConnectionState::Attached;
}
 
void QOhosInputContext::setFocusObject(QObject *object)
{
    if (object == m_focusObject)
        return;
 
    const bool wasAttached = m_imConnectionState == ImConnectionState::Attached;
 
    if (!m_pendingPreeditText.isEmpty())
        commit();
 
    m_focusObject = object;
 
    if (wasAttached && object != nullptr) {
        m_qtImEnabled = queryImEnabled();
        if (m_qtImEnabled)
            reset();
    }
}
 
QObject *QOhosInputContext::focusObjectOrNull() const
{
    return m_focusObject;
}
 
void QOhosInputContext::setImConnectionState(ImConnectionState requestedState)
{
    if (requestedState != m_imConnectionRequestedState) {
        setImConnectionStateImpl(requestedState);
    } else {
        if (m_imConnectionState == ImConnectionState::Attached && !m_softwareKeyboardVisible)
            showTextInput();
    }
}
 
void QOhosInputContext::setImConnectionStateImpl(ImConnectionState requestedState)
{
    m_imConnectionRequestedState = m_qtImEnabled ? requestedState : ImConnectionState::Detached;
 
    if (!m_imConnectionRequestActive) {
        m_imConnectionRequestActive = true;
 
        dispatchRequestedImStateChange(requestedState);
    }
}
 
void QOhosInputContext::dispatchRequestedImStateChange(ImConnectionState requestedState)
{
    auto result = false;
    if (requestedState == ImConnectionState::Attached)
        result = attachToInputMethodController();
    else
        result = detachFromInputMethodController();
    handleRequestedImConnectionState(requestedState, result);
}
 
bool QOhosInputContext::attachToInputMethodController()
{
    class ImCallbacks : public QOhosInputMethodProxy::ClientCallbacks
    {
    public:
        ImCallbacks(QOhosInputContext &inputContext)
            : m_inputContext(inputContext)
        {
        }
 
    private:
        void onInsertText(std::string text) override
        {
            m_inputContext.sendInsertedTextToQt(std::move(text));
        }
 
        void onInsertPreviewText(std::string previewText, int start, int end) override
        {
            m_inputContext.sendInsertedPreviewTextToQt(std::move(previewText), start, end);
        }
 
        void onFinishPreviewText() override
        {
            m_inputContext.commit();
        }
 
        void onDeleteForward(int length) override
        {
            m_inputContext.sendFocusObjectFunctionalKeyEvent(Qt::Key_Delete, QStringLiteral("\u007F"), length);
        }
 
        void onDeleteBackward(int length) override
        {
            m_inputContext.sendFocusObjectFunctionalKeyEvent(Qt::Key_Backspace, QStringLiteral("\u0008"), length);
        }
 
        void onSendKeyboardStatus(::InputMethod_KeyboardStatus keyboardStatus) override
        {
            bool ohosKeyboardShown = keyboardStatus == ::InputMethod_KeyboardStatus::IME_KEYBOARD_STATUS_SHOW;
            m_inputContext.setSoftwareKeyboardVisibilityStatus(ohosKeyboardShown);
        }
 
        void onSendEnterKey(::InputMethod_EnterKeyType) override
        {
            m_inputContext.sendFocusObjectFunctionalKeyEvent(Qt::Key_Enter, QStringLiteral("\u000D"));
        }
 
        void onMoveCursor(::InputMethod_Direction direction) override
        {
            auto qtDirection = tryMapInputMethodDirectionToQt(direction);
            if (!qtDirection.has_value()) {
                qOhosPrintfWarning(
                    "got unsupported InputMethod_Direction value (%d), cursor won't be moved!",
                    static_cast<int>(direction));
                return;
            }
 
            m_inputContext.sendCursorMoveToQt(qtDirection.value());
        }
 
        QOhosInputContext &m_inputContext;
    };
 
    if (m_imProxy)
        qOhosPrintfWarning("%s: proxy already exists!", Q_FUNC_INFO);
 
    m_imProxy = std::make_shared<QOhosInputMethodProxy>(
        std::make_shared<ImCallbacks>(*this),
        mapQtToOhosImeRequestReason(
            m_lastInputTypeToTriggerSoftKeyboard.value_or(RequestKeyboardReason::OTHER)));
 
    if (m_imProxy->hasAttachedSuccessfully()) {
        pushTextAroundCursorToProxy();
        m_imProxy->notifyConfigurationChange(
            mapQtToOhosImeEnterKeyType(m_qtEnterKeyType),
            mapQtInputMethodHintsToOhosImeTextInputType(m_qtInputMethodHints));
        return true;
    }
    return false;
}
 
bool QOhosInputContext::detachFromInputMethodController()
{
    if (!m_imProxy)
        qOhosPrintfWarning("%s: proxy doesn't exist!", Q_FUNC_INFO);
 
    m_imProxy.reset();
    return true;
}
 
void QOhosInputContext::handleRequestedImConnectionState(ImConnectionState requestedState, bool success)
{
    m_imConnectionRequestActive = false;
 
    if (!success) {
        qOhosWarning(QtForOhos)
            << "Cannot "
            << (requestedState == ImConnectionState::Attached ? "attach to" : "detach from")
            << " IMC!";
        return;
    }
 
    m_imConnectionState = requestedState;
 
    if (m_imConnectionRequestedState != m_imConnectionState)
        setImConnectionStateImpl(m_imConnectionRequestedState);
 
    onCursorRectangleChanged();
}
 
void QOhosInputContext::showTextInput()
{
    if (m_imProxy == nullptr) {
        qOhosPrintfError("%s: proxy doesn't exist!", Q_FUNC_INFO);
        return;
    }
 
    m_imProxy->showTextInput(mapQtToOhosImeRequestReason(
        m_lastInputTypeToTriggerSoftKeyboard.value_or(RequestKeyboardReason::OTHER)));
}
 
void QOhosInputContext::setSoftwareKeyboardVisibilityStatus(bool visible)
{
    m_softwareKeyboardVisible = visible;
}
 
void QOhosInputContext::setLastInputTypeToTriggerSoftKeyboard(RequestKeyboardReason inputType)
{
    m_lastInputTypeToTriggerSoftKeyboard = inputType;
}
 
void QOhosInputContext::onCursorRectangleChanged()
{
    if (m_imConnectionState == ImConnectionState::Detached) {
        qOhosDebug(QtForOhos) << "Cursor rectangle changed while detached; deferring update until attach";
        m_updateCursorRectangleAfterAttaching = true;
        return;
    }
 
    auto *focusedWindow = QGuiApplication::focusWindow();
    if (focusedWindow == nullptr) {
        qOhosCritical(QtForOhos)
            << "Could not retrieve focused window. Updating cursor position isn't possible";
        return;
    }
 
    auto focusedWindowPosition = focusedWindow->mapToGlobal(QPoint(0, 0));
    QRect cursorRectangle = QGuiApplication::inputMethod()->cursorRectangle().toRect();
    if (!m_updateCursorRectangleAfterAttaching
        && cursorRectangle == m_lastCursorRectangle
        && m_lastFocusedWindowPosition == focusedWindowPosition) {
        return;
    }
 
    m_lastCursorRectangle = cursorRectangle;
    m_lastFocusedWindowPosition = focusedWindowPosition;
    auto globalInputItemRectangle =
        QGuiApplication::inputMethod()->inputItemClipRectangle()
        .translated(m_lastFocusedWindowPosition)
        .toRect();
    auto globalCursorRectangle = m_lastCursorRectangle.translated(m_lastFocusedWindowPosition);
    auto inputItemClampedCursorPos = clampToRect(
        {globalCursorRectangle.x(), globalCursorRectangle.y()},
        globalInputItemRectangle.isValid()
            ? globalInputItemRectangle
            : QRect(focusedWindowPosition, focusedWindow->size()));
    auto nativeCursorPos = QHighDpiScaling::mapPositionToNative(
        inputItemClampedCursorPos, focusedWindow->screen()->handle());
    auto screenBasedCursorPos = nativeCursorPos - focusedWindow->screen()->handle()->geometry().topLeft();
    updateOhosCursor({
        screenBasedCursorPos.x(), screenBasedCursorPos.y(),
        globalCursorRectangle.width(), globalCursorRectangle.height()
    });
    m_updateCursorRectangleAfterAttaching = false;
}
 
void QOhosInputContext::updateInputMethodControllerAttributes(
    Qt::InputMethodHints qtInputMethodHints, Qt::EnterKeyType qtEnterKeyType)
{
    if (m_imProxy == nullptr) {
        qOhosPrintfError("%s: proxy doesn't exist!", Q_FUNC_INFO);
        return;
    }
 
    m_imProxy->notifyConfigurationChange(
        mapQtToOhosImeEnterKeyType(qtEnterKeyType),
        mapQtInputMethodHintsToOhosImeTextInputType(qtInputMethodHints));
}
 
void QOhosInputContext::updateOhosCursor(const QRect &globalCursorRect)
{
    if (m_imProxy == nullptr) {
        qOhosPrintfError("%s: proxy doesn't exist!", Q_FUNC_INFO);
        return;
    }
 
    m_imProxy->notifyCursorUpdate(globalCursorRect);
}
 
void QOhosInputContext::pushTextAroundCursorToProxy()
{
    if (m_imProxy == nullptr) {
        qOhosPrintfError("%s: proxy doesn't exist!", Q_FUNC_INFO);
        return;
    }
 
    const auto textAroundCursor = queryQtImTextAroundCursorOrEmpty();
    m_imProxy->setTextAroundCursor(
        textAroundCursor.first.toStdU16String(),
        textAroundCursor.second.toStdU16String(),
        tryQueryCursorPosition().value_or(0));
}
 
void QOhosInputContext::updateSelection()
{
    if (m_imProxy == nullptr) {
        qOhosPrintfError("%s: proxy doesn't exist!", Q_FUNC_INFO);
        return;
    }
 
    auto query = tryQueryFocusObjectInputMethod(
        Qt::ImSurroundingText | Qt::ImCursorPosition | Qt::ImAnchorPosition);
    if (query.isNull())
        return;
 
    const auto surroundingText = query->value(Qt::ImSurroundingText);
    const auto cursorPosition = query->value(Qt::ImCursorPosition);
    const auto anchorPosition = query->value(Qt::ImAnchorPosition);
 
    if (!surroundingText.canConvert<QString>() || !cursorPosition.canConvert<int>()
        || !anchorPosition.canConvert<int>())
        return;
 
    const int cursor = cursorPosition.toInt();
    const int anchor = anchorPosition.toInt();
 
    m_imProxy->notifySelectionChange(
        surroundingText.toString().toStdU16String(), std::min(anchor, cursor), std::max(anchor, cursor));
}
 
void QOhosInputContext::handleFocusInEvent(QObject *obj, QFocusEvent *event)
{
    if (obj->isWidgetType() && queryImEnabled()) {
        auto focusReason = event->reason();
        if (focusReason == Qt::OtherFocusReason || focusReason == Qt::ActiveWindowFocusReason)
            setLastInputTypeToTriggerSoftKeyboard(RequestKeyboardReason::NONE);
    }
}
 
bool QOhosInputContext::eventFilter(QObject *obj, QEvent *event)
{
    if (event->type() == QEvent::FocusIn)
        handleFocusInEvent(obj, static_cast<QFocusEvent *>(event));
    return false;
}
 
void QOhosInputContext::sendInsertedTextToQt(const std::string &textToInsert)
{
    auto query = tryQueryFocusObjectInputMethod(Qt::ImEnabled);
    if (query.isNull())
        return;
 
    if (!query->value(Qt::ImEnabled).toBool()) {
        qOhosDebug(QtForOhos) << "onInsertText(): focus object is not able to handle InputMethod";
        return;
    }
 
    m_pendingPreeditText.clear();
    m_previewReplaceRange = {};
 
    QInputMethodEvent event;
    event.setCommitString(QString::fromStdString(textToInsert));
    sendFocusObjectInputMethodEvent(&event);
}
 
void QOhosInputContext::sendInsertedPreviewTextToQt(std::string previewText, int start, int end)
{
    auto query = tryQueryFocusObjectInputMethod(Qt::ImEnabled);
    if (query.isNull())
        return;
 
    if (!query->value(Qt::ImEnabled).toBool()) {
        qOhosPrintfDebug("%s: focus object is not able to handle InputMethod", Q_FUNC_INFO);
        return;
    }
 
    m_previewReplaceRange = {};
    const auto cursor = tryQueryCursorPosition();
    if (cursor && !(start < 0 && end < 0)) {
        const int from = qMin(start, end);
        const int to = qMax(start, end);
        m_previewReplaceRange = { from - *cursor, to - from };
    }
 
    const QString previewString = QString::fromStdString(previewText);
    QList<QInputMethodEvent::Attribute> imEventAttributes;
    if (!previewString.isEmpty()) {
        QTextCharFormat format;
        format.setFontUnderline(true);
        imEventAttributes.append(
            QInputMethodEvent::Attribute(
                QInputMethodEvent::TextFormat, 0, previewString.length(), format));
    }
 
    m_pendingPreeditText = previewString;
 
    QInputMethodEvent preeditStringEvent(previewString, imEventAttributes);
    sendFocusObjectInputMethodEvent(&preeditStringEvent);
}
 
void QOhosInputContext::sendFocusObjectInputMethodEvent(QInputMethodEvent *event)
{
    auto *focusObject = focusObjectOrNull();
    if (focusObject == nullptr) {
        qOhosWarning(QtForOhos) << "sendFocusObjectInputMethodEvent(): no focus object to send event to!";
        return;
    }
 
    QCoreApplication::sendEvent(focusObject, event);
}
 
void QOhosInputContext::sendCursorMoveToQt(QOhosInputContext::Direction direction)
{
    switch (direction) {
    case QOhosInputContext::Direction::CURSOR_UP:
        sendFocusObjectFunctionalKeyEvent(Qt::Key_Up);
        break;
    case QOhosInputContext::Direction::CURSOR_DOWN:
        sendFocusObjectFunctionalKeyEvent(Qt::Key_Down);
        break;
    case QOhosInputContext::Direction::CURSOR_LEFT:
        sendFocusObjectFunctionalKeyEvent(Qt::Key_Left);
        break;
    case QOhosInputContext::Direction::CURSOR_RIGHT:
        sendFocusObjectFunctionalKeyEvent(Qt::Key_Right);
        break;
    }
}
 
void QOhosInputContext::sendFocusObjectFunctionalKeyEvent(Qt::Key key, const QString &keyText, int repeatCount)
{
    auto *focusObject = focusObjectOrNull();
    if (focusObject == nullptr) {
        qOhosWarning(QtForOhos) << "sendFocusObjectFunctionalKeyEvent(): no focus object to send event to!";
        return;
    }
 
    for (int i = 0; i < repeatCount; ++i) {
        QGuiApplication::postEvent(focusObject, new QKeyEvent(QEvent::KeyPress, key, Qt::NoModifier, keyText));
        QGuiApplication::postEvent(focusObject, new QKeyEvent(QEvent::KeyRelease, key, Qt::NoModifier, keyText));
    }
}
 
bool QOhosInputContext::queryImEnabled() const
{
    auto query = tryQueryFocusObjectInputMethod(Qt::ImEnabled);
    return !query.isNull() && query->value(Qt::ImEnabled).toBool();
}
 
Qt::InputMethodHints QOhosInputContext::queryInputMethodHints() const
{
    std::optional<Qt::InputMethodHints> hints;
    auto query = tryQueryFocusObjectInputMethod(Qt::ImHints);
    if (!query.isNull()) {
        auto imHintsInt = tryGetIntPropertyFromQuery(Qt::ImHints, query);
        if (imHintsInt.has_value())
            hints = static_cast<Qt::InputMethodHints>(imHintsInt.value());
    }
 
    return hints.value_or(defaultInputMethodHints);
}
 
Qt::EnterKeyType QOhosInputContext::queryEnterKeyType() const
{
    std::optional<Qt::EnterKeyType> enterKeyType;
    auto query = tryQueryFocusObjectInputMethod(Qt::ImEnterKeyType);
    if (!query.isNull()) {
        auto imEnterKeyTypeInt = tryGetIntPropertyFromQuery(Qt::ImEnterKeyType, query);
        if (imEnterKeyTypeInt.has_value())
            enterKeyType = static_cast<Qt::EnterKeyType>(imEnterKeyTypeInt.value());
    }
 
    return enterKeyType.value_or(defaultEnterKeyType);
}
 
std::optional<int> QOhosInputContext::tryQueryCursorPosition() const
{
    auto query = tryQueryFocusObjectInputMethod(Qt::ImCursorPosition);
    return !query.isNull()
        ? tryGetIntPropertyFromQuery(Qt::ImCursorPosition, query)
        : std::nullopt;
}
 
QSharedPointer<QInputMethodQueryEvent> QOhosInputContext::tryQueryFocusObjectInputMethod(Qt::InputMethodQueries queries) const
{
    auto *focusObject = focusObjectOrNull();
    if (focusObject == nullptr) {
        qOhosWarning(QtForOhos) << "tryQueryFocusObjectInputMethod(): no focus object to query information from!";
        return {};
    }
 
    auto imqEvent = QSharedPointer<QInputMethodQueryEvent>::create(queries);
    QCoreApplication::sendEvent(focusObject, imqEvent.data());
    return imqEvent;
}
 
QT_END_NAMESPACE