From cd48ed92670a0d086589b202364f38f14e7221c9 Mon Sep 17 00:00:00 2001 From: Alessandro Portale Date: Sat, 19 Sep 2009 13:37:38 +0200 Subject: Making Keypad Navigation more usable All changes of this commit are #ifdef'ed in QT_KEYPAD_NAVIGATION. Most desktop Qts won't notice any change. Navigating between QWidgets was not alwys a pleasure on keypad devices. This commit fixes the navigation behavior for some widgets, mostly itemviews. Furthermore, it adds a 'directional' navigation mode. Until now, the existing keypad navigation used the tab order do go back and forth between widgets. The new mode is supposed to provide a more intuitive navigation. It is the new default mode on Symbian. Screens (and their resolutions) become bigger, and also low resolution screens can be used in landscape mode. That's why the directional mode was requested. Another popular request was to put some more convenience into QSlider: If a (horizontal) slider has focus and the user presses left/right, the value of the slider may directing change without being selected (edit mode). This commit also adds the manual test 'keypadnavigation'. Reviewed-by: Shane Kearns --- src/gui/itemviews/qabstractitemview.cpp | 6 + src/gui/kernel/qapplication.cpp | 15 +- src/gui/kernel/qwidget.cpp | 90 +- src/gui/kernel/qwidget_p.h | 12 + src/gui/styles/qs60style.cpp | 9 +- src/gui/text/qtextcontrol.cpp | 4 +- src/gui/widgets/qabstractbutton.cpp | 5 +- src/gui/widgets/qabstractslider.cpp | 69 +- src/gui/widgets/qmenu.cpp | 5 - src/gui/widgets/qplaintextedit.cpp | 9 + tests/manual/keypadnavigation/keypadnavigation.pro | 2 + tests/manual/keypadnavigation/keypadnavigation.ui | 1226 ++++++++++++++++++++ tests/manual/keypadnavigation/main.cpp | 69 ++ 13 files changed, 1493 insertions(+), 28 deletions(-) create mode 100644 tests/manual/keypadnavigation/keypadnavigation.pro create mode 100644 tests/manual/keypadnavigation/keypadnavigation.ui create mode 100644 tests/manual/keypadnavigation/main.cpp diff --git a/src/gui/itemviews/qabstractitemview.cpp b/src/gui/itemviews/qabstractitemview.cpp index 757ded9..5c68928 100644 --- a/src/gui/itemviews/qabstractitemview.cpp +++ b/src/gui/itemviews/qabstractitemview.cpp @@ -2166,6 +2166,12 @@ void QAbstractItemView::keyPressEvent(QKeyEvent *event) #endif case Qt::Key_Left: case Qt::Key_Right: +#ifdef QT_KEYPAD_NAVIGATION + if (QApplication::navigationMode() == Qt::NavigationModeKeypadDirectional) { + event->accept(); // don't change horizontal focus in directional mode + break; + } +#endif // QT_KEYPAD_NAVIGATION case Qt::Key_Home: case Qt::Key_End: case Qt::Key_PageUp: diff --git a/src/gui/kernel/qapplication.cpp b/src/gui/kernel/qapplication.cpp index 0ff7314..df4a935 100644 --- a/src/gui/kernel/qapplication.cpp +++ b/src/gui/kernel/qapplication.cpp @@ -4781,13 +4781,13 @@ void QApplicationPrivate::emitLastWindowClosed() \note On Windows CE this feature is disabled by default for touch device mkspecs. To enable keypad navigation, build Qt with QT_KEYPAD_NAVIGATION defined. - + \note On Symbian, setting the mode to Qt::NavigationModeCursorAuto will enable a virtual mouse cursor on non touchscreen devices, which is controlled by the cursor keys if there is no analog pointer device. On other platforms and on touchscreen devices, it has the same meaning as Qt::NavigationModeNone. - + \since 4.6 \sa keypadNavigationEnabled() @@ -4810,10 +4810,10 @@ void QApplication::setNavigationMode(Qt::NavigationMode mode) \note On Windows CE this feature is disabled by default for touch device mkspecs. To enable keypad navigation, build Qt with QT_KEYPAD_NAVIGATION defined. - + \note On Symbian, the default mode is Qt::NavigationModeNone for touch devices, and Qt::NavigationModeKeypadDirectional. - + \since 4.6 \sa keypadNavigationEnabled() @@ -4829,12 +4829,11 @@ Qt::NavigationMode QApplication::navigationMode() This feature is available in Qt for Embedded Linux, Symbian and Windows CE only. - \note On Windows CE this feature is disabled by default for touch device mkspecs. To enable keypad navigation, build Qt with QT_KEYPAD_NAVIGATION defined. - + \deprecated \sa setNavigationMode() @@ -4846,7 +4845,7 @@ void QApplication::setKeypadNavigationEnabled(bool enable) QApplication::setNavigationMode(Qt::NavigationModeKeypadDirectional); #else QApplication::setNavigationMode(Qt::NavigationModeKeypadTabOrder); -#endif +#endif } else { QApplication::setNavigationMode(Qt::NavigationModeNone); @@ -4863,7 +4862,7 @@ void QApplication::setKeypadNavigationEnabled(bool enable) \note On Windows CE this feature is disabled by default for touch device mkspecs. To enable keypad navigation, build Qt with QT_KEYPAD_NAVIGATION defined. - + \deprecated \sa navigationMode() diff --git a/src/gui/kernel/qwidget.cpp b/src/gui/kernel/qwidget.cpp index 860b98b..4f1ab94 100644 --- a/src/gui/kernel/qwidget.cpp +++ b/src/gui/kernel/qwidget.cpp @@ -410,7 +410,6 @@ void QWidget::setEditFocus(bool on) QApplication::sendEvent(f, &event); QApplication::sendEvent(f->style(), &event); } - f->repaint(); // Widget might want to repaint a focus indicator } #endif @@ -6449,6 +6448,8 @@ void QWidgetPrivate::reparentFocusWidgets(QWidget * oldtlw) This function is called from QDesktopwidget::screen(QPoint) to find the closest screen for a point. + In directional KeypadNavigation, it is called to find the closest + widget to the current focus widget center. */ int QWidgetPrivate::pointToRect(const QPoint &p, const QRect &r) { @@ -7929,10 +7930,21 @@ bool QWidget::event(QEvent *event) #ifdef QT_KEYPAD_NAVIGATION if (!k->isAccepted() && QApplication::keypadNavigationEnabled() && !(k->modifiers() & (Qt::ControlModifier | Qt::AltModifier | Qt::ShiftModifier))) { - if (k->key() == Qt::Key_Up) - res = focusNextPrevChild(false); - else if (k->key() == Qt::Key_Down) - res = focusNextPrevChild(true); + if (QApplication::navigationMode() == Qt::NavigationModeKeypadTabOrder) { + if (k->key() == Qt::Key_Up) + res = focusNextPrevChild(false); + else if (k->key() == Qt::Key_Down) + res = focusNextPrevChild(true); + } else if (QApplication::navigationMode() == Qt::NavigationModeKeypadDirectional) { + if (k->key() == Qt::Key_Up) + res = QWidgetPrivate::navigateToDirection(QWidgetPrivate::DirectionNorth); + else if (k->key() == Qt::Key_Right) + res = QWidgetPrivate::navigateToDirection(QWidgetPrivate::DirectionEast); + else if (k->key() == Qt::Key_Down) + res = QWidgetPrivate::navigateToDirection(QWidgetPrivate::DirectionSouth); + else if (k->key() == Qt::Key_Left) + res = QWidgetPrivate::navigateToDirection(QWidgetPrivate::DirectionWest); + } if (res) { k->accept(); break; @@ -11373,6 +11385,74 @@ QRect QWidgetPrivate::frameStrut() const return maybeTopData() ? maybeTopData()->frameStrut : QRect(); } +#ifdef QT_KEYPAD_NAVIGATION +/*! + \internal + + Changes the focus from the current focusWidget to a widget in + the \a direction. + + Returns true, if there was a widget in that direction +*/ +bool QWidgetPrivate::navigateToDirection(Direction direction) +{ + QWidget *targetWidget = widgetInNavigationDirection(direction); + if (targetWidget) + targetWidget->setFocus(); + return (targetWidget != 0); +} + +/*! + \internal + + Searches for a widget that is positioned in the \a direction, starting + from the current focusWidget. + + Returns the pointer to a found widget or 0, if there was no widget in + that direction. +*/ +QWidget *QWidgetPrivate::widgetInNavigationDirection(Direction direction) +{ + const QWidget *sourceWidget = QApplication::focusWidget(); + if (!sourceWidget) + return 0; + const QRect sourceRect = sourceWidget->rect().translated(sourceWidget->mapToGlobal(QPoint())); + const int sourceX = + (direction == DirectionNorth || direction == DirectionSouth) ? + (sourceRect.left() + (sourceRect.right() - sourceRect.left()) / 2) + :(direction == DirectionEast ? sourceRect.right() : sourceRect.left()); + const int sourceY = + (direction == DirectionEast || direction == DirectionWest) ? + (sourceRect.top() + (sourceRect.bottom() - sourceRect.top()) / 2) + :(direction == DirectionSouth ? sourceRect.bottom() : sourceRect.top()); + const QPoint sourcePoint(sourceX, sourceY); + const QPoint sourceCenter = sourceRect.center(); + const QWidget *sourceWindow = sourceWidget->window(); + + QWidget *targetWidget = 0; + int shortestDistance = INT_MAX; + foreach(QWidget *targetCandidate, QApplication::allWidgets()) { + const QRect targetCandidateRect = targetCandidate->rect().translated(targetCandidate->mapToGlobal(QPoint())); + if ( targetCandidate != sourceWidget + && targetCandidate->focusPolicy() & Qt::TabFocus + && !(direction == DirectionNorth && targetCandidateRect.bottom() > sourceRect.top()) + && !(direction == DirectionEast && targetCandidateRect.left() < sourceRect.right()) + && !(direction == DirectionSouth && targetCandidateRect.top() < sourceRect.bottom()) + && !(direction == DirectionWest && targetCandidateRect.right() > sourceRect.left()) + && targetCandidate->isEnabled() + && targetCandidate->isVisible() + && targetCandidate->window() == sourceWindow) { + const int targetCandidateDistance = pointToRect(sourcePoint, targetCandidateRect); + if (targetCandidateDistance < shortestDistance) { + shortestDistance = targetCandidateDistance; + targetWidget = targetCandidate; + } + } + } + return targetWidget; +} +#endif + /*! \preliminary \since 4.2 diff --git a/src/gui/kernel/qwidget_p.h b/src/gui/kernel/qwidget_p.h index 7eb8f04..5e06c29 100644 --- a/src/gui/kernel/qwidget_p.h +++ b/src/gui/kernel/qwidget_p.h @@ -252,6 +252,13 @@ public: CloseWithSpontaneousEvent }; + enum Direction { + DirectionNorth = 0x01, + DirectionEast = 0x10, + DirectionSouth = 0x02, + DirectionWest = 0x20 + }; + // Functions. explicit QWidgetPrivate(int version = QObjectPrivateVersion); ~QWidgetPrivate(); @@ -398,6 +405,11 @@ public: void updateFrameStrut(); QRect frameStrut() const; +#ifdef QT_KEYPAD_NAVIGATION + static bool navigateToDirection(Direction direction); + static QWidget *widgetInNavigationDirection(Direction direction); +#endif + void setWindowIconText_sys(const QString &cap); void setWindowIconText_helper(const QString &cap); void setWindowTitle_sys(const QString &cap); diff --git a/src/gui/styles/qs60style.cpp b/src/gui/styles/qs60style.cpp index 664ee41..1e57167 100644 --- a/src/gui/styles/qs60style.cpp +++ b/src/gui/styles/qs60style.cpp @@ -706,10 +706,11 @@ void QS60StylePrivate::setThemePalette(QPalette *palette) const palette->setColor(QPalette::AlternateBase, Qt::transparent); palette->setBrush(QPalette::Base, Qt::transparent); // set button and tooltipbase based on pixel colors - const QColor buttonColor = this->colorFromFrameGraphics(SF_ButtonNormal); - palette->setColor(QPalette::Button, buttonColor ); - const QColor toolTipColor = this->colorFromFrameGraphics(SF_ToolTip); - palette->setColor(QPalette::ToolTipBase, toolTipColor ); +// After natitive pixmap support, colorFromFrameGraphics caused reproducable crashes on some setups. +// const QColor buttonColor = colorFromFrameGraphics(SF_ButtonNormal); +// palette->setColor(QPalette::Button, buttonColor); +// const QColor toolTipColor = colorFromFrameGraphics(SF_ToolTip); +// palette->setColor(QPalette::ToolTipBase, toolTipColor); palette->setColor(QPalette::Light, palette->color(QPalette::Button).lighter()); palette->setColor(QPalette::Dark, palette->color(QPalette::Button).darker()); palette->setColor(QPalette::Midlight, palette->color(QPalette::Button).lighter(125)); diff --git a/src/gui/text/qtextcontrol.cpp b/src/gui/text/qtextcontrol.cpp index 25006b1..6def06e 100644 --- a/src/gui/text/qtextcontrol.cpp +++ b/src/gui/text/qtextcontrol.cpp @@ -271,7 +271,9 @@ bool QTextControlPrivate::cursorMoveKeyEvent(QKeyEvent *e) } #ifdef QT_KEYPAD_NAVIGATION else if (QApplication::keypadNavigationEnabled() - && (e->key() == Qt::Key_Up || e->key() == Qt::Key_Down)) { + && ((e->key() == Qt::Key_Up || e->key() == Qt::Key_Down) + || QApplication::navigationMode() == Qt::NavigationModeKeypadDirectional + && (e->key() == Qt::Key_Left || e->key() == Qt::Key_Right))) { return false; } #endif diff --git a/src/gui/widgets/qabstractbutton.cpp b/src/gui/widgets/qabstractbutton.cpp index d2f4baf..cb46791 100644 --- a/src/gui/widgets/qabstractbutton.cpp +++ b/src/gui/widgets/qabstractbutton.cpp @@ -1172,7 +1172,10 @@ void QAbstractButton::keyPressEvent(QKeyEvent *e) case Qt::Key_Right: case Qt::Key_Down: #ifdef QT_KEYPAD_NAVIGATION - if (QApplication::keypadNavigationEnabled() && (e->key() == Qt::Key_Left || e->key() == Qt::Key_Right)) { + if ((QApplication::keypadNavigationEnabled() + && (e->key() == Qt::Key_Left || e->key() == Qt::Key_Right)) + || (!QApplication::navigationMode() == Qt::NavigationModeKeypadDirectional + || (e->key() == Qt::Key_Up || e->key() == Qt::Key_Down))) { e->ignore(); return; } diff --git a/src/gui/widgets/qabstractslider.cpp b/src/gui/widgets/qabstractslider.cpp index 34fe340..a50c105 100644 --- a/src/gui/widgets/qabstractslider.cpp +++ b/src/gui/widgets/qabstractslider.cpp @@ -47,6 +47,9 @@ #ifndef QT_NO_ACCESSIBILITY #include "qaccessible.h" #endif +#ifdef QT_KEYPAD_NAVIGATION +#include "qtabwidget.h" // Needed in inTabWidget() +#endif // QT_KEYPAD_NAVIGATION #include QT_BEGIN_NAMESPACE @@ -724,6 +727,45 @@ void QAbstractSlider::wheelEvent(QWheelEvent * e) } } #endif +#ifdef QT_KEYPAD_NAVIGATION +/*! + \internal + + Tells us if it there is currently a reachable widget by keypad navigation in + a certain \a orientation. + If no navigation is possible, occuring key events in that \a orientation may + be used to interact with the value in the focussed widget, even though it + currently has not the editFocus. + + \sa QWidgetPrivate::widgetInNavigationDirection(), QWidget::hasEditFocus() +*/ +inline static bool canKeypadNavigate(Qt::Orientation orientation) +{ + return orientation == Qt::Horizontal? + (QWidgetPrivate::widgetInNavigationDirection(QWidgetPrivate::DirectionEast) + || QWidgetPrivate::widgetInNavigationDirection(QWidgetPrivate::DirectionWest)) + :(QWidgetPrivate::widgetInNavigationDirection(QWidgetPrivate::DirectionNorth) + || QWidgetPrivate::widgetInNavigationDirection(QWidgetPrivate::DirectionSouth)); +} +/*! + \internal + + Checks, if the \a widget is inside a QTabWidget. If is is inside + one, left/right key events will be used to switch between tabs in keypad + navigation. If there is no QTabWidget, the horizontal key events can be used to + interact with the value in the focussed widget, even though it currently has + not the editFocus. + + \sa QWidget::hasEditFocus() +*/ +inline static bool inTabWidget(QWidget *widget) +{ + for (QWidget *tabWidget = widget; tabWidget; tabWidget = tabWidget->parentWidget()) + if (qobject_cast(tabWidget)) + return true; + return false; +} +#endif // QT_KEYPAD_NAVIGATION /*! \reimp */ @@ -751,7 +793,13 @@ void QAbstractSlider::keyPressEvent(QKeyEvent *ev) // It seems we need to use invertedAppearance for Left and right, otherwise, things look weird. case Qt::Key_Left: #ifdef QT_KEYPAD_NAVIGATION - if (QApplication::keypadNavigationEnabled() && !hasEditFocus()) { + // In QApplication::KeypadNavigationDirectional, we want to change the slider + // value if there is no left/right navigation possible and if this slider is not + // inside a tab widget. + if (QApplication::keypadNavigationEnabled() + && (!hasEditFocus() && QApplication::navigationMode() == Qt::NavigationModeKeypadTabOrder + || d->orientation == Qt::Vertical + || !hasEditFocus() && (canKeypadNavigate(Qt::Horizontal) || inTabWidget(this)))) { ev->ignore(); return; } @@ -766,7 +814,11 @@ void QAbstractSlider::keyPressEvent(QKeyEvent *ev) break; case Qt::Key_Right: #ifdef QT_KEYPAD_NAVIGATION - if (QApplication::keypadNavigationEnabled() && !hasEditFocus()) { + // Same logic as in Qt::Key_Left + if (QApplication::keypadNavigationEnabled() + && (!hasEditFocus() && QApplication::navigationMode() == Qt::NavigationModeKeypadTabOrder + || d->orientation == Qt::Vertical + || !hasEditFocus() && (canKeypadNavigate(Qt::Horizontal) || inTabWidget(this)))) { ev->ignore(); return; } @@ -781,7 +833,12 @@ void QAbstractSlider::keyPressEvent(QKeyEvent *ev) break; case Qt::Key_Up: #ifdef QT_KEYPAD_NAVIGATION - if (QApplication::keypadNavigationEnabled()) { + // In QApplication::KeypadNavigationDirectional, we want to change the slider + // value if there is no up/down navigation possible. + if (QApplication::keypadNavigationEnabled() + && (QApplication::navigationMode() == Qt::NavigationModeKeypadTabOrder + || d->orientation == Qt::Horizontal + || !hasEditFocus() && canKeypadNavigate(Qt::Vertical))) { ev->ignore(); break; } @@ -790,7 +847,11 @@ void QAbstractSlider::keyPressEvent(QKeyEvent *ev) break; case Qt::Key_Down: #ifdef QT_KEYPAD_NAVIGATION - if (QApplication::keypadNavigationEnabled()) { + // Same logic as in Qt::Key_Up + if (QApplication::keypadNavigationEnabled() + && (QApplication::navigationMode() == Qt::NavigationModeKeypadTabOrder + || d->orientation == Qt::Horizontal + || !hasEditFocus() && canKeypadNavigate(Qt::Vertical))) { ev->ignore(); break; } diff --git a/src/gui/widgets/qmenu.cpp b/src/gui/widgets/qmenu.cpp index d971ac2..925be02 100644 --- a/src/gui/widgets/qmenu.cpp +++ b/src/gui/widgets/qmenu.cpp @@ -570,11 +570,6 @@ void QMenuPrivate::setCurrentAction(QAction *action, int popup, SelectionReason // Since the menu is a pop-up, it uses the popup reason. if (!q->hasFocus()) { q->setFocus(Qt::PopupFocusReason); -#ifdef QT_KEYPAD_NAVIGATION - // TODO: aportale, remove KEYPAD_NAVIGATION_HACK when softkey stack - // handles focus related and user related actions separately... - QActionToKeyEventMapper::addSoftKey(QAction::CancelSoftKey, Qt::Key_Back, q); -#endif } } } diff --git a/src/gui/widgets/qplaintextedit.cpp b/src/gui/widgets/qplaintextedit.cpp index fda063a..d519bfe 100644 --- a/src/gui/widgets/qplaintextedit.cpp +++ b/src/gui/widgets/qplaintextedit.cpp @@ -1639,6 +1639,15 @@ void QPlainTextEdit::keyPressEvent(QKeyEvent *e) return; } break; + case Qt::Key_Left: + case Qt::Key_Right: + if (QApplication::keypadNavigationEnabled() + && QApplication::navigationMode() == Qt::NavigationModeKeypadDirectional) { + // Same as for Key_Up and Key_Down. + e->ignore(); + return; + } + break; case Qt::Key_Back: if (!e->isAutoRepeat()) { if (QApplication::keypadNavigationEnabled()) { diff --git a/tests/manual/keypadnavigation/keypadnavigation.pro b/tests/manual/keypadnavigation/keypadnavigation.pro new file mode 100644 index 0000000..6d12606 --- /dev/null +++ b/tests/manual/keypadnavigation/keypadnavigation.pro @@ -0,0 +1,2 @@ +SOURCES += main.cpp +FORMS += keypadnavigation.ui diff --git a/tests/manual/keypadnavigation/keypadnavigation.ui b/tests/manual/keypadnavigation/keypadnavigation.ui new file mode 100644 index 0000000..e0db662 --- /dev/null +++ b/tests/manual/keypadnavigation/keypadnavigation.ui @@ -0,0 +1,1226 @@ + + + KeypadNavigation + + + + 0 + 0 + 264 + 378 + + + + + 0 + 0 + + + + KeypadNavigation + + + + + 0 + + + + + 0 + + + + + 0 + + + + + Qt::NoFocus + + + QFrame::NoFrame + + + true + + + + + 0 + 0 + 248 + 501 + + + + + + + 'TabOrder' navigation mode friendly, vertical, 1-dimensional layout with basic widgets. The tab order goes from top to bottom. + + + true + + + + + + + + + Foo + + + + + + + + + + Bar + + + + + + + 10 + + + Qt::Horizontal + + + + + + + Foo + + + + + + + false + + + + + + + Bar + + + + + + + false + + + 10 + + + Qt::Horizontal + + + + + + + Foo + + + + + + + + + + Bar + + + + + + + + Item 1 + + + + + Item 2 + + + + + Item 3 + + + + + Item 4 + + + + + Item 5 + + + + + Item 6 + + + + + Item 7 + + + + + Item 9 + + + + + Item 10 + + + + + + + + + + + 16777215 + 80 + + + + Edit some text + + + + + + + + + Foo QPushButton + + + + + + + Foo + + + + + + Bar 1 + + + + + + + Bar 2 + + + + + + + + + + Foo + + + + + + CheckBox + + + + + + + CheckBox + + + + + + + + + + + + + + + + + + 0 + + + + + 0 + + + + Tab 1 + + + + 0 + + + + + QFrame::NoFrame + + + true + + + + + 0 + 0 + 242 + 472 + + + + + 9 + + + + + <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN" "http://www.w3.org/TR/REC-html40/strict.dtd"> +<html><head><meta name="qrichtext" content="1" /><style type="text/css"> +p, li { white-space: pre-wrap; } +</style></head><body style=" font-family:'MS Shell Dlg 2'; font-size:8.25pt; font-weight:400; font-style:normal;"> +<p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Challenes both navigation modes: Vertical, 1-dimensional layout with <span style=" font-weight:600;">complex</span> widgets. The tab order goes from top to bottom.</p></body></html> + + + true + + + + + + + + 1 + 1 + + + + + 16777215 + 80 + + + + + Item 1 + + + + + Item 2 + + + + + Item 3 + + + + + Item 4 + + + + + Item 5 + + + + + + + + + 16777215 + 80 + + + + + + + + + + B + + + + + A + + + Foo + + + + 1 + + + Bar + + + + a + + + Foo + + + + + b + + + Bar + + + + + c + + + Foo + + + + + + 2 + + + Bar + + + + a + + + Foo + + + + + b + + + Bar + + + + + c + + + Foo + + + + + + 3 + + + Bar + + + + a + + + Foo + + + + + b + + + Bar + + + + + c + + + Foo + + + + + + + B + + + Bar + + + + 1 + + + Foo + + + + + 2 + + + Bar + + + + + 3 + + + Foo + + + + + + + + + + 16777215 + 80 + + + + + 1 + + + + + 2 + + + + + 3 + + + + + A + + + + + B + + + + + C + + + + + Foo + + + + + Bar + + + + + Foo + + + + + Bar + + + + + Foo + + + + + Bar + + + + + Foo + + + + + Bar + + + + + Foo + + + + + + + + + 100 + 80 + + + + QCalendarWidget::SingleLetterDayNames + + + QCalendarWidget::NoVerticalHeader + + + + + + + + + + + + Tab 2 + + + + + + Congratulations! You changed the Tab :) + +As a reward you can try out the QDial, below. + + + + + + + + + + + + + + + + 0 + + + + + Qt::NoFocus + + + QFrame::NoFrame + + + true + + + + + 0 + 0 + 264 + 357 + + + + + + + 2-dimensional layout. Better usable with 'Directional' navigation mode. + + + true + + + + + + + + + + ... + + + + + + + ... + + + + + + + + + + + + + + + + ... + + + + + + + + + + Foo + + + + + + + + + + + + D + + + + + + + A + + + + + + + B + + + + + + + E + + + + + + + C + + + + + + + F + + + + + + + G + + + + + + + + + + + + Qt::Vertical + + + + 0 + 1 + + + + + + + + + + + + + + + + + ... + + + + + + + + + + + + + 0 + + + + + Qt::NoFocus + + + QFrame::NoFrame + + + true + + + + + 0 + 0 + 264 + 357 + + + + + + + If possible, the slider value changes on left/right. However, navigating horizontally and changing tabs has higher priority. + + + true + + + + + + + 10 + + + Qt::Horizontal + + + + + + + 10 + + + Qt::Horizontal + + + + + + + Qt::Vertical + + + + 0 + 0 + + + + + + + + + 0 + 0 + + + + 0 + + + + Tab 1 + + + + + + ... + + + + + + + 10 + + + Qt::Horizontal + + + + + + + 10 + + + Qt::Horizontal + + + + + + + + Tab 2 + + + + + + Qt::Horizontal + + + + + + + + + + + + + + ... + + + + + + + + + + + + + 0 + + + 0 + + + + + o + + + + + + + o + + + + + + + o + + + + + + + o + + + + + + + o + + + + + + + o + + + + + + + o + + + + + + + o + + + + + + + o + + + + + + + o + + + + + + + o + + + + + + + + + + + + + 0 + 0 + 264 + 21 + + + + + Ui-layout + + + + + + + + + + Navigation mode + + + + + + + + + + + + + Vertical Simple + + + + + Vertical Complex + + + + + Two-dimentional + + + + + Slider magic + + + + + Chaos! + + + + + None + + + + + KeypadTabOrder + + + + + KeypadDirectional + + + + + CursorAuto + + + + + CursorForceVisible + + + + + + lineEdit + horizontalSlider + lineEdit_4 + horizontalSlider_2 + dateEdit + comboBox + plainTextEdit + pushButton + radioButton + radioButton_2 + checkBox + checkBox_2 + listWidget + treeWidget + tableWidget + calendarWidget + plainTextEdit_2 + dial + horizontalSlider_7 + toolButton_3 + horizontalSlider_6 + horizontalSlider_5 + scrollArea_3 + lineEdit_13 + toolButton_31 + lineEdit_14 + toolButton_30 + lineEdit_2 + lineEdit_3 + lineEdit_5 + toolButton_32 + lineEdit_6 + lineEdit_8 + lineEdit_7 + lineEdit_9 + lineEdit_10 + toolButton_35 + pushButton_7 + pushButton_9 + pushButton_24 + pushButton_23 + pushButton_20 + pushButton_29 + pushButton_28 + toolButton_12 + toolButton_11 + toolButton_10 + toolButton_6 + toolButton_19 + toolButton_9 + toolButton_15 + toolButton_14 + toolButton_16 + tabWidget + scrollArea_2 + scrollArea + + + + + horizontalSlider_5 + valueChanged(int) + lcdNumber + display(int) + + + 201 + 326 + + + 245 + 324 + + + + + diff --git a/tests/manual/keypadnavigation/main.cpp b/tests/manual/keypadnavigation/main.cpp new file mode 100644 index 0000000..28ba628 --- /dev/null +++ b/tests/manual/keypadnavigation/main.cpp @@ -0,0 +1,69 @@ +#include +#include "ui_keypadnavigation.h" + +class KeypadNavigation : public QMainWindow +{ + Q_OBJECT + +public: + KeypadNavigation(QWidget *parent = 0) + : QMainWindow(parent) + , ui(new Ui_KeypadNavigation) + { + ui->setupUi(this); + + connect(ui->m_actionLayoutVerticalSimple, SIGNAL(triggered()), &m_layoutSignalMapper, SLOT(map())); + m_layoutSignalMapper.setMapping(ui->m_actionLayoutVerticalSimple, ui->m_pageVerticalSimple); + connect(ui->m_actionLayoutVerticalComplex, SIGNAL(triggered()), &m_layoutSignalMapper, SLOT(map())); + m_layoutSignalMapper.setMapping(ui->m_actionLayoutVerticalComplex, ui->m_pageVerticalComplex); + connect(ui->m_actionLayoutTwoDimensional, SIGNAL(triggered()), &m_layoutSignalMapper, SLOT(map())); + m_layoutSignalMapper.setMapping(ui->m_actionLayoutTwoDimensional, ui->m_pageTwoDimensional); + connect(ui->m_actionLayoutSliderMagic, SIGNAL(triggered()), &m_layoutSignalMapper, SLOT(map())); + m_layoutSignalMapper.setMapping(ui->m_actionLayoutSliderMagic, ui->m_pageSliderMagic); + connect(ui->m_actionLayoutChaos, SIGNAL(triggered()), &m_layoutSignalMapper, SLOT(map())); + m_layoutSignalMapper.setMapping(ui->m_actionLayoutChaos, ui->m_pageChaos); + connect(&m_layoutSignalMapper, SIGNAL(mapped(QWidget*)), ui->m_stackWidget, SLOT(setCurrentWidget(QWidget*))); + + connect(ui->m_actionModeNone, SIGNAL(triggered()), &m_modeSignalMapper, SLOT(map())); + m_modeSignalMapper.setMapping(ui->m_actionModeNone, int(Qt::NavigationModeNone)); + connect(ui->m_actionModeKeypadTabOrder, SIGNAL(triggered()), &m_modeSignalMapper, SLOT(map())); + m_modeSignalMapper.setMapping(ui->m_actionModeKeypadTabOrder, int(Qt::NavigationModeKeypadTabOrder)); + connect(ui->m_actionModeKeypadDirectional, SIGNAL(triggered()), &m_modeSignalMapper, SLOT(map())); + m_modeSignalMapper.setMapping(ui->m_actionModeKeypadDirectional, int(Qt::NavigationModeKeypadDirectional)); + connect(ui->m_actionModeCursorAuto, SIGNAL(triggered()), &m_modeSignalMapper, SLOT(map())); + m_modeSignalMapper.setMapping(ui->m_actionModeCursorAuto, int(Qt::NavigationModeCursorAuto)); + connect(ui->m_actionModeCursorForceVisible, SIGNAL(triggered()), &m_modeSignalMapper, SLOT(map())); + m_modeSignalMapper.setMapping(ui->m_actionModeCursorForceVisible, int(Qt::NavigationModeCursorForceVisible)); + connect(&m_modeSignalMapper, SIGNAL(mapped(int)), SLOT(setNavigationMode(int))); + } + + ~KeypadNavigation() + { + delete ui; + } + +public slots: + void setNavigationMode(int mode) + { + QApplication::setNavigationMode(Qt::NavigationMode(mode)); + } + +private: + Ui_KeypadNavigation *ui; + QSignalMapper m_layoutSignalMapper; + QSignalMapper m_modeSignalMapper; +}; + +int main(int argc, char *argv[]) +{ + QApplication a(argc, argv); + KeypadNavigation w; +#ifdef Q_WS_S60 + w.showMaximized(); +#else + w.show(); +#endif + return a.exec(); +} + +#include "main.moc" -- cgit v0.12