qskinny/src/inputpanel/QskVirtualKeyboard.cpp

/******************************************************************************
 * QSkinny - Copyright (C) 2016 Uwe Rathmann
 * This file may be used under the terms of the QSkinny License, Version 1.0
 *****************************************************************************/

#include "QskVirtualKeyboard.h"
#include "QskPushButton.h"
#include "QskTextOptions.h"

#include <qguiapplication.h>
#include <qset.h>
#include <qstylehints.h>

namespace
{
    enum
    {
        RowCount = 5,
        ColumnCount = 12
    };

    using KeyRow = int[ ColumnCount ];

    class Button final : public QskPushButton
    {
      public:
        Button( int row, int column, QskVirtualKeyboard* parent )
            : QskPushButton( parent )
            , m_row( row )
            , m_column( column )
        {
            QskTextOptions options;
            options.setFontSizeMode( QskTextOptions::VerticalFit );
            setTextOptions( options );

            setFocusPolicy( Qt::TabFocus );
        }

        QskAspect::Subcontrol substitutedSubcontrol(
            QskAspect::Subcontrol subControl ) const override
        {
            auto keyBoard = static_cast< const QskVirtualKeyboard* >( parent() );

            if ( subControl == QskPushButton::Panel )
                return keyBoard->effectiveSubcontrol( QskVirtualKeyboard::ButtonPanel );

            if ( subControl == QskPushButton::Text )
                return keyBoard->effectiveSubcontrol( QskVirtualKeyboard::ButtonText );

            return QskPushButton::substitutedSubcontrol( subControl );
        }

        int row() const { return m_row; }
        int column() const { return m_column; }

      private:
        const int m_row;
        const int m_column;
    };
}

struct QskVirtualKeyboardLayouts
{
    struct KeyCodes
    {
        using Row = int[ ColumnCount ];
        Row data[ RowCount ];
    };

    using Layout = KeyCodes[ QskVirtualKeyboard::ModeCount ];

    Layout bg; // Bulgarian
    Layout cs; // Czech
    Layout de; // German
    Layout da; // Danish
    Layout el; // Greek
    Layout en_GB; // English (GB)
    Layout en_US; // English (US)
    Layout es; // Spanish
    Layout fi; // Finnish
    Layout fr; // French
    Layout hu; // Hungarian
    Layout it; // Italian
    Layout ja; // Japanese
    Layout lv; // Latvian
    Layout lt; // Lithuanian
    Layout nl; // Dutch
    Layout pt; // Portuguese
    Layout ro; // Romanian
    Layout ru; // Russian
    Layout sl; // Slovene
    Layout sk; // Slovak
    Layout tr; // Turkish
    Layout zh; // Chinese
};

#define LOWER( x ) int( x + 32 ) // Convert an uppercase key to lowercase
static constexpr const QskVirtualKeyboardLayouts qskKeyboardLayouts =
{
#include "QskVirtualKeyboardLayouts.cpp"
};
#undef LOWER

static qreal qskKeyStretch( int key )
{
    switch ( key )
    {
        case Qt::Key_Backspace:
        case Qt::Key_Shift:
        case Qt::Key_CapsLock:
            return 1.5;

        case Qt::Key_Space:
            return 3.5;

        case Qt::Key_Return:
        case Qt::Key_Mode_switch:

        // Possibly smaller
        default:
            break;
    }

    return 1.0;
}

static qreal qskRowStretch( const KeyRow& keyRow )
{
    qreal stretch = 0;

    for ( const auto& key : keyRow )
    {
        if ( !key )
        {
            continue;
        }

        stretch += qskKeyStretch( key );
    }

    if ( stretch == 0.0 )
    {
        stretch = ColumnCount;
    }

    return stretch;
}

static QString qskTextForKey( int key )
{
    // Special cases
    switch ( key )
    {
        case Qt::Key_Backspace:
        case Qt::Key_Muhenkan:
            return QChar( 0x232B );

        case Qt::Key_CapsLock:
        case Qt::Key_Kana_Lock:
            return QChar( 0x21E7 );

        case Qt::Key_Shift:
        case Qt::Key_Kana_Shift:
            return QChar( 0x2B06 );

        case Qt::Key_Mode_switch:
            return QChar( 0x2026 );

        case Qt::Key_Return:
        case Qt::Key_Kanji:
            return QChar( 0x23CE );

        case Qt::Key_Left:
            return QChar( 0x2190 );

        case Qt::Key_Right:
            return QChar( 0x2192 );

        case Qt::Key_ApplicationLeft:
            return QChar( 0x2B05 );

        case Qt::Key_ApplicationRight:
            return QChar( 0x27A1 );

        default:
            return QChar( key );
    }
}

static bool qskIsAutorepeat( int key )
{
    return (
        ( key != Qt::Key_Return ) &&
        ( key != Qt::Key_Enter ) &&
        ( key != Qt::Key_Shift ) &&
        ( key != Qt::Key_CapsLock ) &&
        ( key != Qt::Key_Mode_switch ) );
}

static QSet< int > qskKeyCodes( const QskVirtualKeyboardLayouts::Layout& layout )
{
    QSet< int > codes;
    codes.reserve( RowCount * ColumnCount );

    for ( int mode = 0; mode <= QskVirtualKeyboard::ModeCount; mode++ )
    {
        const auto& keyCodes = layout[ mode ];

        for ( int row = 0; row < RowCount; row++ )
        {
            const auto& keys = keyCodes.data[ row ];

            for ( int col = 0; col < ColumnCount; col++ )
                codes += keys[ col ];
        }
    }

    return codes;
}

QSK_SUBCONTROL( QskVirtualKeyboard, Panel )
QSK_SUBCONTROL( QskVirtualKeyboard, ButtonPanel )
QSK_SUBCONTROL( QskVirtualKeyboard, ButtonText )

class QskVirtualKeyboard::PrivateData
{
  public:
    const QskVirtualKeyboardLayouts::Layout* currentLayout = nullptr;
    QskVirtualKeyboard::Mode mode = QskVirtualKeyboard::LowercaseMode;

    QVector< Button* > keyButtons;
    QSet< int > keyCodes;
};

QskVirtualKeyboard::QskVirtualKeyboard( QQuickItem* parent )
    : Inherited( parent )
    , m_data( new PrivateData )
{
    setPolishOnResize( true );
    initSizePolicy( QskSizePolicy::Expanding, QskSizePolicy::Constrained );

    m_data->keyButtons.reserve( RowCount * ColumnCount );

    const auto autoRepeatInterval =
        1000 / QGuiApplication::styleHints()->keyboardAutoRepeatRate();

    for ( int row = 0; row < RowCount; row++ )
    {
        for ( int col = 0; col < ColumnCount; col++ )
        {
            auto button = new Button( row, col, this );
            button->installEventFilter( this );

            button->setAutoRepeat( false );
            button->setAutoRepeatDelay( 500 );
            button->setAutoRepeatInterval( autoRepeatInterval );

            connect( button, &QskPushButton::pressed,
                this, &QskVirtualKeyboard::buttonPressed );

            m_data->keyButtons += button;
        }
    }

    connect( this, &QskControl::localeChanged,
        this, &QskVirtualKeyboard::updateLocale );

    updateLocale( locale() );
}

QskVirtualKeyboard::~QskVirtualKeyboard()
{
}

QskAspect::Subcontrol QskVirtualKeyboard::substitutedSubcontrol(
    QskAspect::Subcontrol subControl ) const
{
    if ( subControl == QskBox::Panel )
        return QskVirtualKeyboard::Panel;

#if 1
    // TODO ...
    if ( subControl == QskVirtualKeyboard::ButtonPanel )
        return QskPushButton::Panel;

    if ( subControl == QskVirtualKeyboard::ButtonText )
        return QskPushButton::Text;
#endif

    return Inherited::substitutedSubcontrol( subControl );
}

QskVirtualKeyboard::Mode QskVirtualKeyboard::mode() const
{
    return m_data->mode;
}

QSizeF QskVirtualKeyboard::layoutSizeHint(
    Qt::SizeHint which, const QSizeF& constraint ) const
{
    if ( which != Qt::PreferredSize )
        return QSizeF();

    constexpr qreal ratio = qreal( RowCount ) / ColumnCount;

    qreal w = constraint.width();
    qreal h = constraint.height();

    if ( h >= 0 )
    {
        const auto padding = innerPadding( Panel, QSizeF( h, h ) );
        const auto dw = padding.left() + padding.right();
        const auto dh = padding.top() + padding.bottom();

        w = ( h - dh ) / ratio + dw;
    }
    else
    {
        if ( w < 0 )
            w = 600;

        const auto padding = innerPadding( Panel, QSizeF( w, w ) );
        const auto dw = padding.left() + padding.right();
        const auto dh = padding.top() + padding.bottom();

        h = ( w - dw ) * ratio + dh;
    }

    return QSizeF( w, h );
}

void QskVirtualKeyboard::updateLayout()
{
    const auto r = layoutRect();
    if ( r.isEmpty() )
        return;

    const auto spacing = spacingHint( Panel );
    const auto totalVSpacing = ( RowCount - 1 ) * spacing;

    const auto keyHeight = ( r.height() - totalVSpacing ) / RowCount;

    const auto& keyCodes = ( *m_data->currentLayout )[ m_data->mode ];

    qreal yPos = r.top();

    for ( int row = 0; row < RowCount; row++ )
    {
        const auto& keys = keyCodes.data[ row ];

#if 1
        // there should be a better way
        auto totalHSpacing = -spacing;
        if ( spacing )
        {
            for ( int col = 0; col < ColumnCount; col++ )
            {
                if ( keys[ col ] != 0 )
                    totalHSpacing += spacing;
            }
        }
#endif
        const auto baseKeyWidth = ( r.width() - totalHSpacing ) / qskRowStretch( keys );
        qreal xPos = r.left();

        for ( int col = 0; col < ColumnCount; col++ )
        {
            const int key = keys[ col ];
            auto button = m_data->keyButtons[ row * ColumnCount + col ];

            button->setVisible( key != 0 );

            if ( button->isVisible() )
            {
                const qreal keyWidth = baseKeyWidth * qskKeyStretch( key );

                const QRectF rect( xPos, yPos, keyWidth, keyHeight );

                button->setGeometry( rect );
                button->setAutoRepeat( qskIsAutorepeat( key ) );
                button->setText( qskTextForKey( key ) );

                xPos += keyWidth + spacing;
            }
        }

        yPos += keyHeight + spacing;
    }
}

bool QskVirtualKeyboard::hasKey( int keyCode ) const
{
    return m_data->keyCodes.contains( keyCode );
}

void QskVirtualKeyboard::buttonPressed()
{
    const auto button = static_cast< const Button* >( sender() );
    if ( button == nullptr )
        return;

    const auto& keyCodes = ( *m_data->currentLayout )[ m_data->mode ];
    const int key = keyCodes.data[ button->row() ][ button->column() ];

    // Mode-switching keys
    switch ( key )
    {
        case Qt::Key_CapsLock:
        case Qt::Key_Kana_Lock:
        {
            setMode( UppercaseMode ); // Lock caps
            break;
        }

        case Qt::Key_Shift:
        case Qt::Key_Kana_Shift:
        {
            setMode( LowercaseMode ); // Unlock caps
            break;
        }

        case Qt::Key_Mode_switch: // Cycle through modes, but skip caps
        {
            setMode( static_cast< QskVirtualKeyboard::Mode >(
                m_data->mode ? ( ( m_data->mode + 1 ) % QskVirtualKeyboard::ModeCount )
                             : SpecialCharacterMode ) );

            break;
        }
        default:
        {
            Q_EMIT keySelected( key );
        }
    }
}

void QskVirtualKeyboard::updateLocale( const QLocale& locale )
{
    const QskVirtualKeyboardLayouts::Layout* newLayout = nullptr;

    switch ( locale.language() )
    {
        case QLocale::Bulgarian:
            newLayout = &qskKeyboardLayouts.bg;
            break;

        case QLocale::Czech:
            newLayout = &qskKeyboardLayouts.cs;
            break;

        case QLocale::German:
            newLayout = &qskKeyboardLayouts.de;
            break;

        case QLocale::Danish:
            newLayout = &qskKeyboardLayouts.da;
            break;

        case QLocale::Greek:
            newLayout = &qskKeyboardLayouts.el;
            break;

        case QLocale::English:
        {
            switch ( locale.country() )
            {
                case QLocale::Canada:
                case QLocale::UnitedStates:
                case QLocale::UnitedStatesMinorOutlyingIslands:
                case QLocale::UnitedStatesVirginIslands:
                    newLayout = &qskKeyboardLayouts.en_US;
                    break;

                default:
                    newLayout = &qskKeyboardLayouts.en_GB;
                    break;
            }

            break;
        }

        case QLocale::Spanish:
            newLayout = &qskKeyboardLayouts.es;
            break;

        case QLocale::Finnish:
            newLayout = &qskKeyboardLayouts.fi;
            break;

        case QLocale::French:
            newLayout = &qskKeyboardLayouts.fr;
            break;

        case QLocale::Hungarian:
            newLayout = &qskKeyboardLayouts.hu;
            break;

        case QLocale::Italian:
            newLayout = &qskKeyboardLayouts.it;
            break;

        case QLocale::Japanese:
            newLayout = &qskKeyboardLayouts.ja;
            break;

        case QLocale::Latvian:
            newLayout = &qskKeyboardLayouts.lv;
            break;

        case QLocale::Lithuanian:
            newLayout = &qskKeyboardLayouts.lt;
            break;

        case QLocale::Dutch:
            newLayout = &qskKeyboardLayouts.nl;
            break;

        case QLocale::Portuguese:
            newLayout = &qskKeyboardLayouts.pt;
            break;

        case QLocale::Romanian:
            newLayout = &qskKeyboardLayouts.ro;
            break;

        case QLocale::Russian:
            newLayout = &qskKeyboardLayouts.ru;
            break;

        case QLocale::Slovenian:
            newLayout = &qskKeyboardLayouts.sl;
            break;

        case QLocale::Slovak:
            newLayout = &qskKeyboardLayouts.sk;
            break;

        case QLocale::Turkish:
            newLayout = &qskKeyboardLayouts.tr;
            break;

        case QLocale::Chinese:
            newLayout = &qskKeyboardLayouts.zh;
            break;
#if 1
        case QLocale::C:
            newLayout = &qskKeyboardLayouts.en_US;
            break;
#endif
        default:
            qWarning() << "QskVirtualKeyboard: unsupported locale:" << locale;
            newLayout = &qskKeyboardLayouts.en_US;
    }

    if ( newLayout != m_data->currentLayout )
    {
        m_data->currentLayout = newLayout;
        m_data->keyCodes = qskKeyCodes( *newLayout );

        setMode( LowercaseMode );
        polish();
    }
}

void QskVirtualKeyboard::setMode( QskVirtualKeyboard::Mode mode )
{
    m_data->mode = mode;
    polish();

    Q_EMIT modeChanged( m_data->mode );
}

#include "moc_QskVirtualKeyboard.cpp"