peranger/qskinny
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

new input panel code

Browse Source
This commit is contained in:
Peter Hartmann 2018-03-14 17:30:37 +01:00
parent 2e3834acf9
commit e365592457
8 changed files with 229 additions and 508 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
skins/material/QskMaterialSkin.cpp
View File

@ -525,6 +525,7 @@ void QskMaterialSkin::initInputPanelHints()
const ColorPalette& pal = m_data->palette;
/*
// key panel
setMargins( Q::KeyPanel | Margin, 2 );
@ -552,6 +553,7 @@ void QskMaterialSkin::initInputPanelHints()
setBoxBorderMetrics( Q::Panel, 0 );
setGradient( Q::Panel, pal.darker150 );
setBoxBorderColors( Q::Panel, pal.baseColor );
*/
}
void QskMaterialSkin::initScrollViewHints()

2
skins/squiek/QskSquiekSkin.cpp
View File

@ -558,6 +558,7 @@ void QskSquiekSkin::initInputPanelHints()
const ColorPalette& pal = m_data->palette;
/*
// key panel
setMargins( Q::KeyPanel | Margin, 2 ); // should be Panel | Spacing
@ -584,6 +585,7 @@ void QskSquiekSkin::initInputPanelHints()
setMargins( Q::Panel | Padding, 5 );
setMargins( Q::Panel | Spacing, 5 );
setPanel( Q::Panel, Raised );
*/
}
void QskSquiekSkin::initScrollViewHints()

409
src/controls/QskInputPanel.cpp
View File

@ -7,21 +7,19 @@
#include "QskAspect.h"
#include <QskPushButton.h>
#include <QskTextLabel.h>
#include <QskDialog.h>
#include <QFocusEvent>
#include <QGuiApplication>
#include <QStyleHints>
#include <QskLinearBox.h>
#include <QTimer>
#include <cmath>
#include <unordered_map>
QSK_SUBCONTROL( QskInputPanel, Panel )
QSK_SUBCONTROL( QskInputPanel, KeyPanel )
QSK_SUBCONTROL( QskInputPanel, KeyGlyph )
QSK_STATE( QskInputPanel, Checked, QskAspect::LastSystemState >> 3 )
QSK_STATE( QskInputPanel, Pressed, QskAspect::LastSystemState >> 2 )
namespace
{
struct KeyTable
@ -34,73 +32,6 @@ namespace
return int( intptr_t( value - data[0] ) );
}
};
QskInputPanel::KeyData* qskKeyDataAt( KeyTable& table, qreal x, qreal y )
{
if( x < 0 || x > 1 || y < 0 || y > 1 )
{
return nullptr;
}
auto rowIndex = size_t( std::floor( y * QskInputPanel::RowCount ) );
auto columnIndex = size_t( std::floor( x * QskInputPanel::KeyCount ) );
Q_FOREVER
{
const auto rect = table.data[ rowIndex ][ columnIndex ].rect;
if( rect.contains( x, y ) )
{
return &table.data[ rowIndex ][ columnIndex ];
}
// Look up/down
if( y < rect.top() )
{
if( rowIndex == 0 )
{
break;
}
rowIndex -= 1;
continue;
}
else if( y > rect.bottom() )
{
if( rowIndex == QskInputPanel::RowCount - 1 )
{
break;
}
rowIndex += 1;
continue;
}
// Look left/right
if( x < rect.left() )
{
if( columnIndex == 0 )
{
break;
}
columnIndex -= 1;
continue;
}
else if( x > rect.right() )
{
if( columnIndex == QskInputPanel::KeyCount - 1 )
{
break;
}
columnIndex += 1;
continue;
}
}
return nullptr;
}
}
struct QskInputPanelLayouts
@ -208,6 +139,64 @@ namespace
};
}
QSK_SUBCONTROL( QskKeyButton, Panel )
QSK_SUBCONTROL( QskKeyButton, Text )
QSK_SUBCONTROL( QskKeyButton, TextCancelButton )
QskKeyButton::QskKeyButton( int keyIndex, QskInputPanel* inputPanel, QQuickItem* parent ) :
Inherited( parent ),
m_keyIndex( keyIndex ),
m_inputPanel( inputPanel )
{
setFlag( QQuickItem::ItemAcceptsInputMethod );
updateText();
connect( this, &QskKeyButton::pressed, this, [ this ]()
{
m_inputPanel->handleKey( m_keyIndex );
} );
connect( m_inputPanel, &QskInputPanel::modeChanged, this, &QskKeyButton::updateText );
}
QskAspect::Subcontrol QskKeyButton::effectiveSubcontrol( QskAspect::Subcontrol subControl ) const
{
if( subControl == QskPushButton::Panel )
{
return QskKeyButton::Panel;
}
if( subControl == QskPushButton::Text )
{
// ### we could also introduce a state to not always query the button
return isCancelButton() ? QskKeyButton::TextCancelButton : QskKeyButton::Text;
}
return subControl;
}
void QskKeyButton::updateText()
{
QString text = m_inputPanel->currentTextForKeyIndex( m_keyIndex );
if( text.count() == 1 && text.at( 0 ) == Qt::Key_unknown )
{
setText( QStringLiteral( "" ) );
}
else
{
setText( text );
}
}
bool QskKeyButton::isCancelButton() const
{
auto keyData = m_inputPanel->keyDataAt( m_keyIndex );
bool isCancel = ( keyData.key == 0x2716 );
return isCancel;
}
class QskInputPanel::PrivateData
{
public:
@ -217,7 +206,8 @@ class QskInputPanel::PrivateData
focusKeyIndex( -1 ),
selectedGroup( -1 ),
candidateOffset( 0 ),
repeatKeyTimerId( -1 )
repeatKeyTimerId( -1 ),
isUIInitialized( false )
{
}
@ -238,12 +228,17 @@ class QskInputPanel::PrivateData
std::unordered_map< int, KeyCounter > activeKeys;
KeyTable keyTable[ ModeCount ];
QList< QskKeyButton* > keyButtons;
bool isUIInitialized;
};
QskInputPanel::QskInputPanel( QQuickItem* parent ):
QskControl( parent ),
m_data( new PrivateData )
{
qRegisterMetaType< Qt::Key >();
setFlag( ItemHasContents );
setAcceptedMouseButtons( Qt::LeftButton );
@ -353,6 +348,8 @@ QString QskInputPanel::displayLanguageName() const
default:
return QStringLiteral( "English (UK)" );
}
break;
}
case QLocale::Spanish:
@ -554,6 +551,7 @@ void QskInputPanel::setCandidateOffset( int candidateOffset )
}
else
{
keyData.isSuggestionKey = true; // ### reset when switching layouts etc.!
keyData.key = m_data->candidates.at( i + m_data->candidateOffset );
}
}
@ -566,166 +564,38 @@ void QskInputPanel::setCandidateOffset( int candidateOffset )
if( m_data->mode == LowercaseMode )
{
update();
updateUI();
}
}
QRectF QskInputPanel::keyboardRect() const
{
auto keyboardRect = rect(); // ### margins? would eliminate this thing below
if( QskDialog::instance()->policy() != QskDialog::TopLevelWindow )
{
keyboardRect.adjust( 0, keyboardRect.height() * 0.5, 0, 0 );
}
// if ( QskDialog::instance()->policy() != QskDialog::TopLevelWindow )
// keyboardRect.adjust( 0, keyboardRect.height() * 0.5, 0, 0 );
return keyboardRect;
}
void QskInputPanel::registerCompositionModelForLocale( const QLocale& locale,
QskInputCompositionModel* model )
{
Q_EMIT inputMethodRegistered( locale, model );
}
void QskInputPanel::geometryChanged(
const QRectF& newGeometry, const QRectF& oldGeometry )
{
Inherited::geometryChanged( newGeometry, oldGeometry );
if( newGeometry != oldGeometry && !newGeometry.size().isNull() && !m_data->isUIInitialized )
{
createUI();
m_data->isUIInitialized = true;
}
Q_EMIT keyboardRectChanged();
}
void QskInputPanel::mousePressEvent( QMouseEvent* e )
{
if( !keyboardRect().contains( e->pos() ) )
{
e->ignore();
return;
}
QTouchEvent::TouchPoint touchPoint( 0 );
touchPoint.setPos( e->pos() );
touchPoint.setState( Qt::TouchPointPressed );
QTouchEvent touchEvent( QTouchEvent::TouchBegin, nullptr,
e->modifiers(), Qt::TouchPointPressed, { touchPoint } );
QCoreApplication::sendEvent( this, &touchEvent );
e->setAccepted( touchEvent.isAccepted() );
}
void QskInputPanel::mouseMoveEvent( QMouseEvent* e )
{
QTouchEvent::TouchPoint touchPoint( 0 );
touchPoint.setPos( e->pos() );
touchPoint.setState( Qt::TouchPointMoved );
QTouchEvent touchEvent( QTouchEvent::TouchUpdate, nullptr,
e->modifiers(), Qt::TouchPointMoved, { touchPoint } );
QCoreApplication::sendEvent( this, &touchEvent );
e->setAccepted( touchEvent.isAccepted() );
}
void QskInputPanel::mouseReleaseEvent( QMouseEvent* e )
{
QTouchEvent::TouchPoint touchPoint( 0 );
touchPoint.setPos( e->pos() );
touchPoint.setState( Qt::TouchPointReleased );
QTouchEvent touchEvent( QTouchEvent::TouchEnd, nullptr,
e->modifiers(), Qt::TouchPointReleased, { touchPoint } );
QCoreApplication::sendEvent( this, &touchEvent );
e->setAccepted( touchEvent.isAccepted() );
}
// Try to handle touch-specific details here; once touch is resolved, send to handleKey()
void QskInputPanel::touchEvent( QTouchEvent* e )
{
if( e->type() == QEvent::TouchCancel )
{
for( auto& it : m_data->activeKeys )
{
keyDataAt( it.second.keyIndex ).key &= ~KeyPressed;
}
m_data->activeKeys.clear();
return;
}
const auto rect = keyboardRect();
for( const auto& tp : e->touchPoints() )
{
const auto pos = tp.pos();
const auto x = ( pos.x() - rect.x() ) / rect.width();
const auto y = ( pos.y() - rect.y() ) / rect.height();
auto keyData = qskKeyDataAt( m_data->keyTable[ m_data->mode ], x, y );
if( !keyData || ( !keyData->key || keyData->key == Qt::Key_unknown ) )
{
auto it = m_data->activeKeys.find( tp.id() );
if( it == m_data->activeKeys.cend() )
{
continue;
}
keyDataAt( it->second.keyIndex ).key &= ~KeyPressed;
m_data->activeKeys.erase( it );
continue;
}
const auto keyIndex = m_data->keyTable[ m_data->mode ].indexOf( keyData );
auto it = m_data->activeKeys.find( tp.id() );
if( tp.state() == Qt::TouchPointReleased )
{
const int repeatCount = it->second.count;
auto it = m_data->activeKeys.find( tp.id() );
keyDataAt( it->second.keyIndex ).key &= ~KeyPressed;
m_data->activeKeys.erase( it );
if( repeatCount < 0 )
{
continue; // Don't compose an accepted held key
}
handleKey( keyIndex );
continue;
}
if( it == m_data->activeKeys.end() )
{
m_data->activeKeys.emplace( tp.id(), KeyCounter { keyIndex, 0 } );
}
else
{
if( it->second.keyIndex != keyIndex )
{
keyDataAt( it->second.keyIndex ).key &= ~KeyPressed;
it->second.count = 0;
}
it->second.keyIndex = keyIndex;
}
keyDataAt( keyIndex ).key |= KeyPressed;
}
// Now start an update timer based on active keys
if( m_data->activeKeys.empty() && m_data->repeatKeyTimerId >= 0 )
{
killTimer( m_data->repeatKeyTimerId );
m_data->repeatKeyTimerId = -1;
}
else if( m_data->repeatKeyTimerId < 0 )
{
m_data->repeatKeyTimerId = startTimer( 1000
/ QGuiApplication::styleHints()->keyboardAutoRepeatRate() );
} /* else timer is already running as it should be */
update();
}
void QskInputPanel::timerEvent( QTimerEvent* e )
{
if( e->timerId() == m_data->repeatKeyTimerId )
@ -759,6 +629,76 @@ void QskInputPanel::timerEvent( QTimerEvent* e )
}
}
bool QskInputPanel::eventFilter( QObject* object, QEvent* event )
{
if( event->type() == QEvent::InputMethod )
{
QInputMethodEvent* inputMethodEvent = static_cast< QInputMethodEvent* >( event );
Q_EMIT inputMethodEventReceived( inputMethodEvent );
return true;
}
else if( event->type() == QEvent::KeyPress )
{
// Return, Backspace and others are covered here (maybe because they don't carry a 'commit string'):
QKeyEvent* keyEvent = static_cast< QKeyEvent* >( event );
Q_EMIT keyEventReceived( keyEvent );
return true;
}
else
{
return Inherited::eventFilter( object, event );
}
}
void QskInputPanel::createUI()
{
// deferring the UI creation until we are visible so that the contentsRect() returns the proper value
setAutoLayoutChildren( true );
auto& panelKeyData = keyData();
const auto contentsRect = keyboardRect();
const qreal sx = contentsRect.size().width();
const qreal sy = contentsRect.size().height();
QskLinearBox* outterBox = new QskLinearBox( Qt::Vertical, this );
outterBox->setAutoAddChildren( true );
for( const auto& keyRow : panelKeyData )
{
QskLinearBox* rowBox = new QskLinearBox( Qt::Horizontal, outterBox );
rowBox->setAutoAddChildren( true );
for( const auto& keyData : keyRow )
{
if( !keyData.key )
{
continue;
}
const QSizeF buttonSize( keyData.rect.width() * sx, keyData.rect.height() * sy );
int keyIndex = m_data->keyTable[ m_data->mode ].indexOf( &keyData );
QskKeyButton* button = new QskKeyButton( keyIndex, this, rowBox );
button->installEventFilter( this );
button->setMaximumWidth( buttonSize.width() ); // ### set min width as well?
button->setFixedHeight( buttonSize.height() );
m_data->keyButtons.append( button );
}
}
}
void QskInputPanel::updateUI()
{
for( QskKeyButton* button : m_data->keyButtons )
{
button->updateText();
}
}
QskInputPanel::KeyData& QskInputPanel::keyDataAt( int keyIndex ) const
{
const auto row = keyIndex / KeyCount;
@ -768,7 +708,8 @@ QskInputPanel::KeyData& QskInputPanel::keyDataAt( int keyIndex ) const
void QskInputPanel::handleKey( int keyIndex )
{
const auto key = keyDataAt( keyIndex ).key & ~KeyStates;
KeyData keyData = keyDataAt( keyIndex );
const auto key = keyData.key & ~KeyStates;
// Preedit keys
const auto row = keyIndex / KeyCount;
@ -821,12 +762,30 @@ void QskInputPanel::handleKey( int keyIndex )
: SpecialCharacterMode ) );
return;
// This is (one of) the cancel symbol, not Qt::Key_Cancel:
case Qt::Key( 10006 ):
Q_EMIT cancelPressed();
return;
default:
break;
}
// Normal keys
compose( key );
if( keyData.isSuggestionKey )
{
selectCandidate( keyIndex );
}
else
{
compose( key );
}
}
QString QskInputPanel::currentTextForKeyIndex( int keyIndex ) const
{
auto keyData = keyDataAt( keyIndex );
QString text = textForKey( keyData.key );
return text;
}
void QskInputPanel::compose( Qt::Key key )
@ -974,10 +933,6 @@ void QskInputPanel::updateLocale( const QLocale& locale )
m_data->currentLayout = &qskInputPanelLayouts.zh;
break;
case QLocale::C:
m_data->currentLayout = &qskInputPanelLayouts.en_US;
break;
default:
qWarning() << "QskInputPanel: unsupported locale:" << locale;
m_data->currentLayout = &qskInputPanelLayouts.en_US;
@ -1027,7 +982,7 @@ void QskInputPanel::updateKeyData()
void QskInputPanel::setMode( QskInputPanel::Mode mode )
{
m_data->mode = mode;
update();
Q_EMIT modeChanged( m_data->mode );
}
#include "QskInputPanel.moc"

53
src/controls/QskInputPanel.h
View File

@ -7,9 +7,35 @@
#define QSK_INPUT_PANEL_H
#include "QskControl.h"
#include "QskPushButton.h"
#include <QRectF>
class QskInputCompositionModel;
class QskInputPanel;
class QskKeyButton : public QskPushButton
{
Q_OBJECT
using Inherited = QskPushButton;
public:
QSK_SUBCONTROLS( Panel, Text, TextCancelButton )
QskKeyButton( int keyIndex, QskInputPanel* inputPanel, QQuickItem* parent = nullptr );
virtual QskAspect::Subcontrol effectiveSubcontrol( QskAspect::Subcontrol subControl ) const override;
public Q_SLOTS:
void updateText();
private:
bool isCancelButton() const;
const int m_keyIndex;
QskInputPanel* m_inputPanel;
};
class QSK_EXPORT QskInputPanel : public QskControl
{
Q_OBJECT
@ -22,12 +48,10 @@ class QSK_EXPORT QskInputPanel : public QskControl
using Inherited = QskControl;
public:
QSK_SUBCONTROLS( Panel, KeyPanel, KeyGlyph )
QSK_STATES( Checked, Pressed )
struct KeyData
{
Qt::Key key = Qt::Key( 0 );
bool isSuggestionKey = false;
QRectF rect;
};
@ -74,6 +98,10 @@ public:
QRectF keyboardRect() const;
// takes ownership:
void registerCompositionModelForLocale( const QLocale& locale,
QskInputCompositionModel* model );
public Q_SLOTS:
void setPreeditGroups( const QVector< Qt::Key >& );
void setPreeditCandidates( const QVector< Qt::Key >& );
@ -82,19 +110,19 @@ public Q_SLOTS:
bool deactivateFocusKey();
void clearFocusKey();
void handleKey( int keyIndex );
KeyData& keyDataAt( int ) const;
QString currentTextForKeyIndex( int keyIndex ) const;
protected:
virtual void geometryChanged( const QRectF&, const QRectF& ) override;
virtual void mousePressEvent( QMouseEvent* ) override;
virtual void mouseMoveEvent( QMouseEvent* ) override;
virtual void mouseReleaseEvent( QMouseEvent* ) override;
virtual void touchEvent( QTouchEvent* ) override;
virtual void timerEvent( QTimerEvent* ) override;
virtual bool eventFilter( QObject* object, QEvent* event ) override;
private:
KeyData& keyDataAt( int ) const;
void createUI();
void updateUI(); // e.g. called when updating Pinyin suggestions
void handleKey( int );
void compose( Qt::Key );
void selectGroup( int );
void selectCandidate( int );
@ -105,6 +133,11 @@ private:
Q_SIGNALS:
void keyboardRectChanged();
void displayLanguageNameChanged();
void inputMethodRegistered( const QLocale& locale, QskInputCompositionModel* model );
void inputMethodEventReceived( QInputMethodEvent* inputMethodEvent );
void keyEventReceived( QKeyEvent* keyEvent );
void modeChanged( QskInputPanel::Mode mode );
void cancelPressed();
public:
class PrivateData;

222
src/controls/QskInputPanelSkinlet.cpp
View File

@ -1,222 +0,0 @@
/******************************************************************************
* QSkinny - Copyright (C) 2016 Uwe Rathmann
* This file may be used under the terms of the QSkinny License, Version 1.0
*****************************************************************************/
#include "QskInputPanelSkinlet.h"
#include "QskInputPanel.h"
#include "QskAspect.h"
#include "QskSkin.h"
#include "QskTextOptions.h"
#include "QskTextNode.h"
#include "QskBoxNode.h"
static constexpr const QSGNode::Flag IsSubtreeBlocked =
static_cast< QSGNode::Flag >( 0x100000 );
static constexpr const QSGNode::Flag KeyFrameNode =
static_cast< QSGNode::Flag >( 0x200000 );
static constexpr const QSGNode::Flag KeyGlyphNode =
static_cast< QSGNode::Flag >( 0x400000 );
namespace
{
class KeySkinnable: public QskSkinnable
{
public:
KeySkinnable( QskInputPanel* panel ):
m_panel( panel )
{
}
void setKey( Qt::Key key )
{
setSkinStateFlag( QskInputPanel::Pressed, key & Qt::ShiftModifier );
setSkinStateFlag( QskInputPanel::Checked, key & Qt::ControlModifier );
setSkinStateFlag( QskInputPanel::Focused, key & Qt::MetaModifier );
}
const QMetaObject* metaObject() const override final
{
// Use the parent skinlet
return &QskInputPanelSkinlet::staticMetaObject;
}
protected:
virtual const QskSkinlet* effectiveSkinlet() const override final
{
return m_panel->effectiveSkinlet();
}
private:
virtual QskControl* owningControl() const override final
{
return const_cast< QskInputPanel* >( m_panel );
}
private:
QskInputPanel* m_panel;
};
class FrameNode final : public QskBoxNode, public KeySkinnable
{
public:
FrameNode( QskInputPanel* panel ):
KeySkinnable( panel )
{
setFlag( KeyFrameNode );
}
};
class TextNode final : public QskTextNode, public KeySkinnable
{
public:
TextNode( QskInputPanel* panel ):
KeySkinnable( panel )
{
setFlag( KeyGlyphNode );
}
};
class InputPanelNode final : public QskBoxNode
{
public:
InputPanelNode()
{
}
virtual bool isSubtreeBlocked() const override final
{
return flags() & IsSubtreeBlocked;
}
using Row = QSGNode*[ QskInputPanel::KeyCount ];
Row frames[ QskInputPanel::RowCount ] = {};
Row glyphs[ QskInputPanel::RowCount ] = {};
};
}
static_assert( QskInputPanel::RowCount * QskInputPanel::KeyCount < 255,
"The number of keys must fit into an unsigned byte." );
QskInputPanelSkinlet::QskInputPanelSkinlet( QskSkin* skin ):
Inherited( skin )
{
setNodeRoles( { Panel0, Panel1, Panel2 } );
}
QskInputPanelSkinlet::~QskInputPanelSkinlet()
{
}
QSGNode* QskInputPanelSkinlet::updateSubNode(
const QskSkinnable* control, quint8 nodeRole, QSGNode* node ) const
{
auto inputPanel = static_cast< const QskInputPanel* >( control );
const bool blockSubtree = inputPanel->mode() != nodeRole;
auto panelNode = static_cast< InputPanelNode* >( node );
if ( panelNode && panelNode->isSubtreeBlocked() != blockSubtree )
{
panelNode->setFlag( IsSubtreeBlocked, blockSubtree );
panelNode->markDirty( QSGNode::DirtySubtreeBlocked );
}
if ( !blockSubtree )
node = updatePanelNode( inputPanel, panelNode );
return node;
}
QSGNode* QskInputPanelSkinlet::updatePanelNode(
const QskInputPanel* panel, QSGNode* node ) const
{
auto panelNode = static_cast< InputPanelNode* >( node );
if ( panelNode == nullptr )
panelNode = new InputPanelNode;
const auto contentsRect = panel->keyboardRect();
auto& panelKeyData = panel->keyData();
for ( const auto& keyRow : panelKeyData )
{
const auto rowIndex = &keyRow - panelKeyData;
auto& frames = panelNode->frames[ rowIndex ];
auto& glyphs = panelNode->glyphs[ rowIndex ];
for ( const auto& keyData : keyRow )
{
const auto colIndex = &keyData - keyRow;
auto& frame = frames[ colIndex ];
auto& glyph = glyphs[ colIndex ];
if ( !keyData.key || keyData.key == Qt::Key_unknown )
{
delete frame;
frame = nullptr;
delete glyph;
glyph = nullptr;
continue;
}
const qreal sx = contentsRect.size().width();
const qreal sy = contentsRect.size().height();
const QRectF keyRect(
contentsRect.x() + keyData.rect.x() * sx,
contentsRect.y() + keyData.rect.y() * sy,
keyData.rect.width() * sx,
keyData.rect.height() * sy );
frame = updateKeyFrameNode( panel, frame, keyRect, keyData.key );
if ( frame->parent() != panelNode )
panelNode->appendChildNode( frame );
glyph = updateKeyGlyphNode( panel, glyph, keyRect, keyData.key );
if ( glyph->parent() != panelNode )
panelNode->appendChildNode( glyph );
}
}
updateBoxNode( panel, panelNode, contentsRect, QskInputPanel::Panel );
return panelNode;
}
QSGNode* QskInputPanelSkinlet::updateKeyFrameNode(
const QskInputPanel* panel, QSGNode* node,
const QRectF& rect, Qt::Key key ) const
{
auto frameNode = static_cast< FrameNode* >( node );
if ( frameNode == nullptr )
frameNode = new FrameNode( const_cast< QskInputPanel* >( panel ) );
frameNode->setKey( key );
updateBoxNode( frameNode, frameNode, rect, QskInputPanel::KeyPanel );
return frameNode;
}
QSGNode* QskInputPanelSkinlet::updateKeyGlyphNode(
const QskInputPanel* panel, QSGNode* node,
const QRectF& rect, Qt::Key key ) const
{
auto textNode = static_cast< TextNode* >( node );
if ( textNode == nullptr )
textNode = new TextNode( const_cast< QskInputPanel* >( panel ) );
textNode->setKey( key );
QskTextOptions options;
options.setFontSizeMode( QskTextOptions::VerticalFit );
const auto alignment = textNode->flagHint< Qt::Alignment >(
QskInputPanel::KeyGlyph | QskAspect::Alignment, Qt::AlignCenter );
return updateTextNode( panel, textNode, rect, alignment,
panel->textForKey( key ), options, QskInputPanel::KeyGlyph );
}
#include "moc_QskInputPanelSkinlet.cpp"

43
src/controls/QskInputPanelSkinlet.h
View File

@ -1,43 +0,0 @@
/******************************************************************************
* QSkinny - Copyright (C) 2016 Uwe Rathmann
* This file may be used under the terms of the QSkinny License, Version 1.0
*****************************************************************************/
#ifndef QSK_INPUT_PANEL_SKINLET_H
#define QSK_INPUT_PANEL_SKINLET_H
#include "QskSkinlet.h"
class QskInputPanel;
class QSK_EXPORT QskInputPanelSkinlet : public QskSkinlet
{
Q_GADGET
using Inherited = QskSkinlet;
enum NodeRole
{
Panel0,
Panel1,
Panel2
};
public:
Q_INVOKABLE QskInputPanelSkinlet( QskSkin* = nullptr );
virtual ~QskInputPanelSkinlet();
protected:
virtual QSGNode* updateSubNode( const QskSkinnable*,
quint8, QSGNode* ) const override;
virtual QSGNode* updatePanelNode( const QskInputPanel*, QSGNode* ) const;
virtual QSGNode* updateKeyFrameNode( const QskInputPanel*,
QSGNode*, const QRectF&, Qt::Key ) const;
virtual QSGNode* updateKeyGlyphNode( const QskInputPanel*,
QSGNode*, const QRectF&, Qt::Key ) const;
};
#endif

4
src/controls/QskSkin.cpp
View File

@ -39,9 +39,6 @@ QSK_QT_PRIVATE_END
#include "QskGraphicLabel.h"
#include "QskGraphicLabelSkinlet.h"
#include "QskInputPanel.h"
#include "QskInputPanelSkinlet.h"
#include "QskListView.h"
#include "QskListViewSkinlet.h"
@ -130,7 +127,6 @@ QskSkin::QskSkin( QObject* parent ):
declareSkinlet< QskBox, QskBoxSkinlet >();
declareSkinlet< QskFocusIndicator, QskFocusIndicatorSkinlet >();
declareSkinlet< QskGraphicLabel, QskGraphicLabelSkinlet >();
declareSkinlet< QskInputPanel, QskInputPanelSkinlet >();
declareSkinlet< QskListView, QskListViewSkinlet >();
declareSkinlet< QskPageIndicator, QskPageIndicatorSkinlet >();
declareSkinlet< QskPopup, QskPopupSkinlet >();

2
src/src.pro
View File

@ -136,7 +136,6 @@ HEADERS += \
controls/QskGraphicLabelSkinlet.h \
controls/QskHintAnimator.h \
controls/QskInputPanel.h \
controls/QskInputPanelSkinlet.h \
controls/QskListView.h \
controls/QskListViewSkinlet.h \
controls/QskObjectTree.h \
@ -201,7 +200,6 @@ SOURCES += \
controls/QskGraphicLabelSkinlet.cpp \
controls/QskHintAnimator.cpp \
controls/QskInputPanel.cpp \
controls/QskInputPanelSkinlet.cpp \
controls/QskListView.cpp \
controls/QskListViewSkinlet.cpp \
controls/QskObjectTree.cpp \