472 lines
13 KiB
C++
472 lines
13 KiB
C++
/******************************************************************************
|
|
* QSkinny - Copyright (C) 2016 Uwe Rathmann
|
|
* This file may be used under the terms of the QSkinny License, Version 1.0
|
|
*****************************************************************************/
|
|
|
|
#include "QskInputContext.h"
|
|
#include "QskVirtualKeyboard.h"
|
|
|
|
#include "QskInputCompositionModel.h"
|
|
#include "QskPinyinCompositionModel.h"
|
|
|
|
#include <QskDialog.h>
|
|
#include <QskWindow.h>
|
|
#include <QskControl.h>
|
|
#include <QskSetup.h>
|
|
|
|
#include <QGuiApplication>
|
|
#include <QHash>
|
|
#include <QPointer>
|
|
|
|
void qskSetLocale( QQuickItem* inputPanel, const QLocale& locale )
|
|
{
|
|
if ( auto control = qobject_cast< QskControl* >( inputPanel ) )
|
|
{
|
|
control->setLocale( locale );
|
|
}
|
|
else
|
|
{
|
|
const auto mo = inputPanel->metaObject();
|
|
|
|
const auto property = mo->property( mo->indexOfProperty( "locale" ) );
|
|
if ( property.isWritable() )
|
|
property.write( inputPanel, locale );
|
|
}
|
|
}
|
|
|
|
QLocale qskLocale( const QQuickItem* inputPanel )
|
|
{
|
|
if ( inputPanel == nullptr )
|
|
return QLocale();
|
|
|
|
if ( auto control = qobject_cast< const QskControl* >( inputPanel ) )
|
|
return control->locale();
|
|
|
|
return inputPanel->property( "locale" ).toLocale();
|
|
}
|
|
|
|
QskVirtualKeyboard* qskVirtualKeyboard( QQuickItem* inputPanel )
|
|
{
|
|
// we should not depend on QskVirtualKeyboard TODO ...
|
|
|
|
if ( inputPanel )
|
|
return inputPanel->findChild< QskVirtualKeyboard* >();
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
class QskInputContext::PrivateData
|
|
{
|
|
public:
|
|
QPointer< QQuickItem > inputItem;
|
|
QPointer< QQuickItem > inputPanel;
|
|
|
|
QskInputCompositionModel* compositionModel;
|
|
QHash< QLocale, QskInputCompositionModel* > compositionModels;
|
|
};
|
|
|
|
QskInputContext::QskInputContext():
|
|
m_data( new PrivateData() )
|
|
{
|
|
setObjectName( "InputContext" );
|
|
|
|
m_data->compositionModel = new QskInputCompositionModel( this );
|
|
|
|
connect( m_data->compositionModel, &QskInputCompositionModel::candidatesChanged,
|
|
this, &QskInputContext::handleCandidatesChanged );
|
|
|
|
connect( qskSetup, &QskSetup::inputPanelChanged,
|
|
this, &QskInputContext::setInputPanel );
|
|
|
|
#if 1
|
|
setCompositionModel( QLocale::Chinese, new QskPinyinCompositionModel( this ) );
|
|
#endif
|
|
|
|
setInputPanel( qskSetup->inputPanel() );
|
|
}
|
|
|
|
QskInputContext::~QskInputContext()
|
|
{
|
|
#if 1
|
|
if ( m_data->inputPanel )
|
|
delete m_data->inputPanel;
|
|
#endif
|
|
}
|
|
|
|
bool QskInputContext::isValid() const
|
|
{
|
|
return true;
|
|
}
|
|
|
|
bool QskInputContext::hasCapability( Capability ) const
|
|
{
|
|
// what is QPlatformInputContext::HiddenTextCapability ???
|
|
return true;
|
|
}
|
|
|
|
void QskInputContext::update( Qt::InputMethodQueries queries )
|
|
{
|
|
if ( m_data->inputItem == nullptr )
|
|
return;
|
|
|
|
const auto queryEvent = queryInputMethod( queries );
|
|
|
|
// Qt::ImCursorRectangle
|
|
// Qt::ImFont
|
|
// Qt::ImCursorPosition
|
|
// Qt::ImSurroundingText // important for chinese input
|
|
// Qt::ImCurrentSelection // important for prediction
|
|
// Qt::ImMaximumTextLength // should be monitored
|
|
// Qt::ImAnchorPosition
|
|
|
|
if ( queries & Qt::ImHints )
|
|
{
|
|
#if 0
|
|
const auto hints = static_cast< Qt::InputMethodHints >(
|
|
queryEvent.value( Qt::ImHints ).toInt() );
|
|
|
|
//ImhHiddenText = 0x1, // might need to disable certain checks
|
|
//ImhSensitiveData = 0x2, // shouldn't change anything
|
|
//ImhNoAutoUppercase = 0x4, // if we support auto uppercase, disable it
|
|
//ImhPreferNumbers = 0x8, // default to number keyboard
|
|
//ImhPreferUppercase = 0x10, // start with shift on
|
|
//ImhPreferLowercase = 0x20, // start with shift off
|
|
//ImhNoPredictiveText = 0x40, // ignored for now
|
|
|
|
//ImhDate = 0x80, // ignored for now (no date keyboard)
|
|
//ImhTime = 0x100, // ignored for know (no time keyboard)
|
|
|
|
//ImhPreferLatin = 0x200, // can be used to launch chinese kb in english mode
|
|
|
|
//ImhMultiLine = 0x400, // not useful?
|
|
|
|
//ImhDigitsOnly // default to number keyboard, disable other keys
|
|
//ImhFormattedNumbersOnly // hard to say
|
|
//ImhUppercaseOnly // caps-lock, disable shift
|
|
//ImhLowercaseOnly // disable shift
|
|
//ImhDialableCharactersOnly // dial pad (calculator?)
|
|
//ImhEmailCharactersOnly // disable certain symbols (email-only kb?)
|
|
//ImhUrlCharactersOnly // disable certain symbols (url-only kb?)
|
|
//ImhLatinOnly // disable chinese input
|
|
#endif
|
|
}
|
|
|
|
if ( queries & Qt::ImPreferredLanguage )
|
|
{
|
|
const auto locale = queryEvent.value( Qt::ImPreferredLanguage ).toLocale();
|
|
|
|
auto oldModel = compositionModel();
|
|
|
|
if( m_data->inputPanel )
|
|
qskSetLocale( m_data->inputPanel, locale );
|
|
|
|
auto newModel = compositionModel();
|
|
|
|
if( oldModel != newModel )
|
|
{
|
|
connect( newModel, &QskInputCompositionModel::candidatesChanged,
|
|
this, &QskInputContext::handleCandidatesChanged );
|
|
|
|
if ( auto keyboard = qskVirtualKeyboard( m_data->inputPanel ) )
|
|
keyboard->setCandidateBarVisible( newModel->supportsSuggestions() );
|
|
}
|
|
}
|
|
|
|
// Qt::ImAbsolutePosition
|
|
// Qt::ImTextBeforeCursor // important for chinese
|
|
// Qt::ImTextAfterCursor // important for chinese
|
|
// Qt::ImPlatformData // hard to say...
|
|
}
|
|
|
|
QQuickItem* QskInputContext::inputItem()
|
|
{
|
|
return m_data->inputItem;
|
|
}
|
|
|
|
void QskInputContext::setInputItem( QQuickItem* item )
|
|
{
|
|
m_data->inputItem = item;
|
|
}
|
|
|
|
QRectF QskInputContext::keyboardRect() const
|
|
{
|
|
if ( m_data->inputPanel
|
|
&& QskDialog::instance()->policy() != QskDialog::TopLevelWindow )
|
|
{
|
|
return qskItemGeometry( m_data->inputPanel );
|
|
}
|
|
|
|
return Inherited::keyboardRect();
|
|
}
|
|
|
|
bool QskInputContext::isAnimating() const
|
|
{
|
|
return false;
|
|
}
|
|
|
|
void QskInputContext::showInputPanel()
|
|
{
|
|
if ( !m_data->inputPanel )
|
|
{
|
|
setInputPanel( new QskVirtualKeyboard() );
|
|
|
|
if ( QskDialog::instance()->policy() == QskDialog::TopLevelWindow )
|
|
{
|
|
auto window = new QskWindow;
|
|
window->setFlags( Qt::Tool | Qt::WindowDoesNotAcceptFocus );
|
|
window->resize( 800, 240 ); // ### what size?
|
|
m_data->inputPanel->setParentItem( window->contentItem() );
|
|
connect( window, &QskWindow::visibleChanged,
|
|
this, &QskInputContext::emitInputPanelVisibleChanged );
|
|
}
|
|
else
|
|
{
|
|
auto window = qobject_cast< QQuickWindow* >( QGuiApplication::focusWindow() );
|
|
if ( window )
|
|
{
|
|
m_data->inputPanel->setParentItem( window->contentItem() );
|
|
m_data->inputPanel->setSize( window->size() );
|
|
}
|
|
}
|
|
}
|
|
|
|
auto window = m_data->inputPanel->window();
|
|
if ( window && window != QGuiApplication::focusWindow() )
|
|
window->show();
|
|
else
|
|
m_data->inputPanel->setVisible( true );
|
|
}
|
|
|
|
void QskInputContext::hideInputPanel()
|
|
{
|
|
if ( m_data->inputPanel == nullptr )
|
|
return;
|
|
|
|
auto window = m_data->inputPanel->window();
|
|
if ( window && window != QGuiApplication::focusWindow() )
|
|
window->hide();
|
|
else
|
|
m_data->inputPanel->setVisible( false );
|
|
}
|
|
|
|
bool QskInputContext::isInputPanelVisible() const
|
|
{
|
|
auto panel = m_data->inputPanel;
|
|
|
|
return panel && panel->isVisible()
|
|
&& panel->window() && panel->window()->isVisible();
|
|
}
|
|
|
|
QLocale QskInputContext::locale() const
|
|
{
|
|
return qskLocale( m_data->inputPanel );
|
|
}
|
|
|
|
Qt::LayoutDirection QskInputContext::inputDirection() const
|
|
{
|
|
return Inherited::inputDirection();
|
|
}
|
|
|
|
void QskInputContext::setFocusObject( QObject* focusObject )
|
|
{
|
|
if ( focusObject == nullptr )
|
|
{
|
|
setInputItem( nullptr );
|
|
return;
|
|
}
|
|
|
|
bool inputItemChanged = false;
|
|
|
|
auto focusItem = qobject_cast< QQuickItem* >( focusObject );
|
|
if( focusItem )
|
|
{
|
|
// Do not change the input item when panel buttons get the focus:
|
|
if( qskNearestFocusScope( focusItem ) != m_data->inputPanel )
|
|
{
|
|
setInputItem( focusItem );
|
|
inputItemChanged = true;
|
|
}
|
|
}
|
|
|
|
if( inputItemChanged )
|
|
{
|
|
const auto queryEvent = queryInputMethod( Qt::ImEnabled );
|
|
if ( !queryEvent.value( Qt::ImEnabled ).toBool() )
|
|
{
|
|
hideInputPanel();
|
|
return;
|
|
}
|
|
}
|
|
|
|
update( Qt::InputMethodQuery( Qt::ImQueryAll & ~Qt::ImEnabled ) );
|
|
}
|
|
|
|
void QskInputContext::setCompositionModel(
|
|
const QLocale& locale, QskInputCompositionModel* model )
|
|
{
|
|
auto& models = m_data->compositionModels;
|
|
|
|
if ( model )
|
|
{
|
|
const auto it = models.find( locale );
|
|
if ( it != models.end() )
|
|
{
|
|
if ( it.value() == model )
|
|
return;
|
|
|
|
delete it.value();
|
|
*it = model;
|
|
}
|
|
else
|
|
{
|
|
models.insert( locale, model );
|
|
}
|
|
|
|
connect( model, &QskInputCompositionModel::candidatesChanged,
|
|
this, &QskInputContext::handleCandidatesChanged );
|
|
}
|
|
else
|
|
{
|
|
const auto it = models.find( locale );
|
|
if ( it != models.end() )
|
|
{
|
|
delete it.value();
|
|
models.erase( it );
|
|
}
|
|
}
|
|
}
|
|
|
|
QskInputCompositionModel* QskInputContext::compositionModel() const
|
|
{
|
|
return m_data->compositionModels.value( locale(), m_data->compositionModel );
|
|
}
|
|
|
|
void QskInputContext::invokeAction( QInputMethod::Action action, int value )
|
|
{
|
|
auto model = compositionModel();
|
|
|
|
switch ( static_cast< int >( action ) )
|
|
{
|
|
case QskVirtualKeyboard::Compose:
|
|
{
|
|
model->composeKey( static_cast< Qt::Key >( value ) );
|
|
break;
|
|
}
|
|
case QskVirtualKeyboard::SelectCandidate:
|
|
{
|
|
model->commitCandidate( value );
|
|
|
|
if ( auto keyboard = qskVirtualKeyboard( m_data->inputPanel ) )
|
|
keyboard->setPreeditCandidates( QVector< QString >() );
|
|
|
|
break;
|
|
}
|
|
case QInputMethod::Click:
|
|
case QInputMethod::ContextMenu:
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void QskInputContext::handleCandidatesChanged()
|
|
{
|
|
const auto model = compositionModel();
|
|
if ( model == nullptr || m_data->inputPanel == nullptr )
|
|
return;
|
|
|
|
const auto count = model->candidateCount();
|
|
|
|
QVector< QString > candidates;
|
|
candidates.reserve( count );
|
|
|
|
for( int i = 0; i < count; i++ )
|
|
candidates += model->candidate( i );
|
|
|
|
if ( auto keyboard = qskVirtualKeyboard( m_data->inputPanel ) )
|
|
keyboard->setPreeditCandidates( candidates );
|
|
}
|
|
|
|
void QskInputContext::setInputPanel( QQuickItem* inputPanel )
|
|
{
|
|
if ( m_data->inputPanel == inputPanel )
|
|
return;
|
|
|
|
auto model = compositionModel();
|
|
|
|
if ( m_data->inputPanel )
|
|
{
|
|
m_data->inputPanel->disconnect( this );
|
|
|
|
if ( model )
|
|
model->disconnect( m_data->inputPanel );
|
|
}
|
|
|
|
m_data->inputPanel = inputPanel;
|
|
|
|
if ( inputPanel )
|
|
{
|
|
// maybe using a QQuickItemChangeListener instead
|
|
#if 1
|
|
connect( inputPanel, &QQuickItem::visibleChanged,
|
|
this, &QPlatformInputContext::emitInputPanelVisibleChanged );
|
|
|
|
connect( inputPanel, &QQuickItem::xChanged,
|
|
this, &QPlatformInputContext::emitKeyboardRectChanged );
|
|
|
|
connect( inputPanel, &QQuickItem::yChanged,
|
|
this, &QPlatformInputContext::emitKeyboardRectChanged );
|
|
|
|
connect( inputPanel, &QQuickItem::widthChanged,
|
|
this, &QPlatformInputContext::emitKeyboardRectChanged );
|
|
|
|
connect( inputPanel, &QQuickItem::heightChanged,
|
|
this, &QPlatformInputContext::emitKeyboardRectChanged );
|
|
#endif
|
|
|
|
if ( auto control = qobject_cast< QskControl* >( inputPanel ) )
|
|
{
|
|
connect( control, &QskControl::localeChanged,
|
|
this, &QPlatformInputContext::emitLocaleChanged );
|
|
}
|
|
|
|
if ( model )
|
|
{
|
|
if ( auto keyboard = qskVirtualKeyboard( inputPanel ) )
|
|
keyboard->setCandidateBarVisible( model->supportsSuggestions() );
|
|
}
|
|
}
|
|
}
|
|
|
|
void QskInputContext::reset()
|
|
{
|
|
}
|
|
|
|
void QskInputContext::commit()
|
|
{
|
|
}
|
|
|
|
bool QskInputContext::filterEvent( const QEvent* event )
|
|
{
|
|
// called from QXcbKeyboard, but what about other platforms
|
|
Q_UNUSED( event )
|
|
return false;
|
|
}
|
|
|
|
QInputMethodQueryEvent QskInputContext::queryInputMethod(
|
|
Qt::InputMethodQueries queries ) const
|
|
{
|
|
QInputMethodQueryEvent event( queries );
|
|
sendEventToInputItem( &event );
|
|
|
|
return event;
|
|
}
|
|
|
|
void QskInputContext::sendEventToInputItem( QEvent* event ) const
|
|
{
|
|
if ( m_data->inputItem && event )
|
|
QCoreApplication::sendEvent( m_data->inputItem, event );
|
|
}
|
|
|
|
#include "moc_QskInputContext.cpp"
|