diff options
Diffstat (limited to 'src/plugins/accessible/widgets/rangecontrols.cpp')
| -rw-r--r-- | src/plugins/accessible/widgets/rangecontrols.cpp | 991 |
1 files changed, 991 insertions, 0 deletions
diff --git a/src/plugins/accessible/widgets/rangecontrols.cpp b/src/plugins/accessible/widgets/rangecontrols.cpp new file mode 100644 index 0000000000..1f5407a631 --- /dev/null +++ b/src/plugins/accessible/widgets/rangecontrols.cpp @@ -0,0 +1,991 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the plugins of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "rangecontrols.h" + +#include <qslider.h> +#include <qdial.h> +#include <qspinbox.h> +#include <qscrollbar.h> +#include <qstyle.h> +#include <qstyleoption.h> +#include <qdebug.h> +#include <qglobal.h> +#include <QDoubleSpinBox> +#include <QDial> +#include <qmath.h> +#include <private/qmath_p.h> + +QT_BEGIN_NAMESPACE + +#ifndef QT_NO_ACCESSIBILITY +extern QString Q_GUI_EXPORT qt_accStripAmp(const QString &text); +#ifndef QT_NO_SCROLLBAR +extern QStyleOptionSlider Q_GUI_EXPORT qt_qscrollbarStyleOption(QScrollBar *scrollBar); +#endif +#ifndef QT_NO_SLIDER +extern QStyleOptionSlider Q_GUI_EXPORT qt_qsliderStyleOption(QSlider *slider); +#endif + +#ifndef QT_NO_SPINBOX +QAccessibleAbstractSpinBox::QAccessibleAbstractSpinBox(QWidget *w) +: QAccessibleWidgetEx(w, SpinBox) +{ + Q_ASSERT(abstractSpinBox()); +} + +/*! + Returns the underlying QAbstractSpinBox. +*/ +QAbstractSpinBox *QAccessibleAbstractSpinBox::abstractSpinBox() const +{ + return qobject_cast<QAbstractSpinBox*>(object()); +} + +/*! \reimp */ +int QAccessibleAbstractSpinBox::childCount() const +{ + if (!abstractSpinBox()->isVisible()) + return 0; + return ValueDown; +} + +/*! \reimp */ +QRect QAccessibleAbstractSpinBox::rect(int child) const +{ + QRect rect; + if (!abstractSpinBox()->isVisible()) + return rect; + QStyleOptionSpinBox so; + so.rect = widget()->rect(); + switch(child) { + case Editor: + rect = widget()->style()->subControlRect(QStyle::CC_SpinBox, &so, + QStyle::SC_SpinBoxEditField, widget()); + break; + case ValueUp: + rect = widget()->style()->subControlRect(QStyle::CC_SpinBox, &so, + QStyle::SC_SpinBoxUp, widget()); + break; + case ValueDown: + rect = widget()->style()->subControlRect(QStyle::CC_SpinBox, &so, + QStyle::SC_SpinBoxDown, widget()); + break; + default: + rect = so.rect; + break; + } + QPoint tl = widget()->mapToGlobal(QPoint(0, 0)); + return QRect(tl.x() + rect.x(), tl.y() + rect.y(), rect.width(), rect.height()); +} + +/*! \reimp */ +int QAccessibleAbstractSpinBox::navigate(RelationFlag rel, int entry, QAccessibleInterface **target) const +{ + *target = 0; + + if (entry) switch (rel) { + case Child: + return entry <= childCount() ? entry : -1; + case QAccessible::Left: + return (entry == ValueUp || entry == ValueDown) ? Editor : -1; + case QAccessible::Right: + return entry == Editor ? ValueUp : -1; + case QAccessible::Up: + return entry == ValueDown ? ValueUp : -1; + case QAccessible::Down: + return entry == ValueUp ? ValueDown : -1; + default: + break; + } + return QAccessibleWidgetEx::navigate(rel, entry, target); +} + +/*! \reimp */ +QString QAccessibleAbstractSpinBox::text(Text t, int child) const +{ + if (!abstractSpinBox()->isVisible()) + return QString(); + switch (t) { + case Name: + switch (child) { + case ValueUp: + return QSpinBox::tr("More"); + case ValueDown: + return QSpinBox::tr("Less"); + } + break; + case Value: + if (child == Editor || child == SpinBoxSelf) + return abstractSpinBox()->text(); + break; + default: + break; + } + return QAccessibleWidgetEx::text(t, 0); +} + +/*! \reimp */ +QAccessible::Role QAccessibleAbstractSpinBox::role(int child) const +{ + switch(child) { + case Editor: + return EditableText; + case ValueUp: + case ValueDown: + return PushButton; + default: + break; + } + return QAccessibleWidgetEx::role(child); +} + +/*! \reimp */ +bool QAccessibleAbstractSpinBox::doAction(int action, int child, const QVariantList ¶ms) +{ + if (!widget()->isEnabled()) + return false; + + if (action == Press) { + switch(child) { + case ValueUp: + abstractSpinBox()->stepUp(); + return true; + case ValueDown: + abstractSpinBox()->stepDown(); + return true; + default: + break; + } + } + return QAccessibleWidgetEx::doAction(action, 0, params); +} + +QVariant QAccessibleAbstractSpinBox::currentValue() +{ + QVariant result = abstractSpinBox()->property("value"); + QVariant::Type type = result.type(); + + // IA2 only allows numeric types + if (type == QVariant::Int || type == QVariant::UInt || type == QVariant::LongLong + || type == QVariant::ULongLong || type == QVariant::Double) + return result; + + return QVariant(); +} + +void QAccessibleAbstractSpinBox::setCurrentValue(const QVariant &value) +{ + abstractSpinBox()->setProperty("setValue", value); +} + +QVariant QAccessibleAbstractSpinBox::maximumValue() +{ + return abstractSpinBox()->property("maximum"); +} + +QVariant QAccessibleAbstractSpinBox::minimumValue() +{ + return abstractSpinBox()->property("minimum"); +} + +QVariant QAccessibleAbstractSpinBox::invokeMethodEx(Method method, int child, const QVariantList ¶ms) +{ + switch (method) { + case ListSupportedMethods: { + QSet<QAccessible::Method> set; + set << ListSupportedMethods; + return QVariant::fromValue(set | qvariant_cast<QSet<QAccessible::Method> >( + QAccessibleWidgetEx::invokeMethodEx(method, child, params))); + } + default: + return QAccessibleWidgetEx::invokeMethodEx(method, child, params); + } +} + + +/*! + \class QAccessibleSpinBox + \brief The QAccessibleSpinBox class implements the QAccessibleInterface for spinbox widgets. + \internal + + \ingroup accessibility +*/ + +/*! + \enum QAccessibleAbstractSpinBox::SpinBoxElements + + This enum identifies the components of the spin box. + + \value SpinBoxSelf The spin box as a whole + \value Editor The line edit sub-widget. + \value ValueUp The up sub-widget (i.e. the up arrow or + button) + \value ValueDown The down sub-widget (i.e. the down arrow or - button) +*/ + +/*! + Constructs a QAccessibleSpinWidget object for \a w. +*/ +QAccessibleSpinBox::QAccessibleSpinBox(QWidget *w) +: QAccessibleAbstractSpinBox(w) +{ + Q_ASSERT(spinBox()); + addControllingSignal(QLatin1String("valueChanged(int)")); + addControllingSignal(QLatin1String("valueChanged(QString)")); +} + +/*! + Returns the underlying QSpinBox. +*/ +QSpinBox *QAccessibleSpinBox::spinBox() const +{ + return qobject_cast<QSpinBox*>(object()); +} + +/*! \reimp */ +QAccessible::State QAccessibleSpinBox::state(int child) const +{ + State state = QAccessibleAbstractSpinBox::state(child); + switch(child) { + case ValueUp: + if (spinBox()->value() >= spinBox()->maximum()) + state |= Unavailable; + return state; + case ValueDown: + if (spinBox()->value() <= spinBox()->minimum()) + state |= Unavailable; + return state; + default: + break; + } + return state; +} + +/*! \reimp */ +bool QAccessibleSpinBox::doAction(int action, int child, const QVariantList ¶ms) +{ + if (!widget()->isEnabled()) + return false; + + if (action == Press) { + switch(child) { + case ValueUp: + if (spinBox()->value() >= spinBox()->maximum()) + return false; + spinBox()->stepUp(); + return true; + case ValueDown: + if (spinBox()->value() <= spinBox()->minimum()) + return false; + spinBox()->stepDown(); + return true; + default: + break; + } + } + return QAccessibleAbstractSpinBox::doAction(action, 0, params); +} + +// ================================== QAccessibleDoubleSpinBox ================================== +QAccessibleDoubleSpinBox::QAccessibleDoubleSpinBox(QWidget *widget) + : QAccessibleWidgetEx(widget, SpinBox) +{ + Q_ASSERT(qobject_cast<QDoubleSpinBox *>(widget)); + addControllingSignal(QLatin1String("valueChanged(double)")); + addControllingSignal(QLatin1String("valueChanged(QString)")); +} + +/*! + Returns the underlying QDoubleSpinBox. +*/ +QDoubleSpinBox *QAccessibleDoubleSpinBox::doubleSpinBox() const +{ + return static_cast<QDoubleSpinBox*>(object()); +} + +/*! \reimp */ +int QAccessibleDoubleSpinBox::childCount() const +{ + if (!doubleSpinBox()->isVisible()) + return 0; + return ValueDown; +} + +/*! \reimp */ +QRect QAccessibleDoubleSpinBox::rect(int child) const +{ + QRect rect; + if (!doubleSpinBox()->isVisible()) + return rect; + QStyleOptionSpinBox spinBoxOption; + spinBoxOption.initFrom(doubleSpinBox()); + switch (child) { + case Editor: + rect = doubleSpinBox()->style()->subControlRect(QStyle::CC_SpinBox, &spinBoxOption, + QStyle::SC_SpinBoxEditField, doubleSpinBox()); + break; + case ValueUp: + rect = doubleSpinBox()->style()->subControlRect(QStyle::CC_SpinBox, &spinBoxOption, + QStyle::SC_SpinBoxUp, doubleSpinBox()); + break; + case ValueDown: + rect = doubleSpinBox()->style()->subControlRect(QStyle::CC_SpinBox, &spinBoxOption, + QStyle::SC_SpinBoxDown, doubleSpinBox()); + break; + default: + rect = spinBoxOption.rect; + break; + } + const QPoint globalPos = doubleSpinBox()->mapToGlobal(QPoint(0, 0)); + return QRect(globalPos.x() + rect.x(), globalPos.y() + rect.y(), rect.width(), rect.height()); +} + +/*! \reimp */ +int QAccessibleDoubleSpinBox::navigate(RelationFlag relation, int entry, QAccessibleInterface **target) const +{ + if (entry <= 0) + return QAccessibleWidgetEx::navigate(relation, entry, target); + + *target = 0; + switch (relation) { + case Child: + return entry <= childCount() ? entry : -1; + case QAccessible::Left: + return (entry == ValueUp || entry == ValueDown) ? Editor : -1; + case QAccessible::Right: + return entry == Editor ? ValueUp : -1; + case QAccessible::Up: + return entry == ValueDown ? ValueUp : -1; + case QAccessible::Down: + return entry == ValueUp ? ValueDown : -1; + default: + break; + } + return QAccessibleWidgetEx::navigate(relation, entry, target); +} + +QVariant QAccessibleDoubleSpinBox::invokeMethodEx(QAccessible::Method, int, const QVariantList &) +{ + return QVariant(); +} + +/*! \reimp */ +QString QAccessibleDoubleSpinBox::text(Text textType, int child) const +{ + if (!doubleSpinBox()->isVisible()) + return QString(); + switch (textType) { + case Name: + if (child == ValueUp) + return QDoubleSpinBox::tr("More"); + else if (child == ValueDown) + return QDoubleSpinBox::tr("Less"); + break; + case Value: + if (child == Editor || child == SpinBoxSelf) + return doubleSpinBox()->textFromValue(doubleSpinBox()->value()); + break; + default: + break; + } + return QAccessibleWidgetEx::text(textType, 0); +} + +/*! \reimp */ +QAccessible::Role QAccessibleDoubleSpinBox::role(int child) const +{ + switch (child) { + case Editor: + return EditableText; + case ValueUp: + case ValueDown: + return PushButton; + default: + break; + } + return QAccessibleWidgetEx::role(child); +} + +/*! \reimp */ +QAccessible::State QAccessibleDoubleSpinBox::state(int child) const +{ + State state = QAccessibleWidgetEx::state(child); + switch (child) { + case ValueUp: + if (doubleSpinBox()->value() >= doubleSpinBox()->maximum()) + state |= Unavailable; + break; + case ValueDown: + if (doubleSpinBox()->value() <= doubleSpinBox()->minimum()) + state |= Unavailable; + break; + default: + break; + } + return state; +} +#endif // QT_NO_SPINBOX + +#ifndef QT_NO_SCROLLBAR +/*! + \class QAccessibleScrollBar + \brief The QAccessibleScrollBar class implements the QAccessibleInterface for scroll bars. + \internal + + \ingroup accessibility +*/ + +/*! + \enum QAccessibleScrollBar::ScrollBarElements + + This enum identifies the components of the scroll bar. + + \value ScrollBarSelf The scroll bar as a whole. + \value LineUp The up arrow button. + \value PageUp The area between the position and the up arrow button. + \value Position The position marking rectangle. + \value PageDown The area between the position and the down arrow button. + \value LineDown The down arrow button. +*/ + +/*! + Constructs a QAccessibleScrollBar object for \a w. + \a name is propagated to the QAccessibleWidgetEx constructor. +*/ +QAccessibleScrollBar::QAccessibleScrollBar(QWidget *w) +: QAccessibleAbstractSlider(w, ScrollBar) +{ + Q_ASSERT(scrollBar()); + addControllingSignal(QLatin1String("valueChanged(int)")); +} + +/*! Returns the scroll bar. */ +QScrollBar *QAccessibleScrollBar::scrollBar() const +{ + return qobject_cast<QScrollBar*>(object()); +} + +/*! \reimp */ +QRect QAccessibleScrollBar::rect(int child) const +{ + if (!scrollBar()->isVisible()) + return QRect(); + + QStyle::SubControl subControl; + switch (child) { + case LineUp: + subControl = QStyle ::SC_ScrollBarSubLine; + break; + case PageUp: + subControl = QStyle::SC_ScrollBarSubPage; + break; + case Position: + subControl = QStyle::SC_ScrollBarSlider; + break; + case PageDown: + subControl = QStyle::SC_ScrollBarAddPage; + break; + case LineDown: + subControl = QStyle::SC_ScrollBarAddLine; + break; + default: + return QAccessibleAbstractSlider::rect(child); + } + + const QStyleOptionSlider option = qt_qscrollbarStyleOption(scrollBar()); + const QRect rect = scrollBar()->style()->subControlRect(QStyle::CC_ScrollBar, &option, + subControl, scrollBar()); + const QPoint tp = scrollBar()->mapToGlobal(QPoint(0,0)); + return QRect(tp.x() + rect.x(), tp.y() + rect.y(), rect.width(), rect.height()); +} + +/*! \reimp */ +int QAccessibleScrollBar::childCount() const +{ + if (!scrollBar()->isVisible()) + return 0; + return LineDown; +} + +/*! \reimp */ +QString QAccessibleScrollBar::text(Text t, int child) const +{ + if (!scrollBar()->isVisible()) + return QString(); + switch (t) { + case Value: + if (!child || child == Position) + return QString::number(scrollBar()->value()); + return QString(); + case Name: + switch (child) { + case LineUp: + return QScrollBar::tr("Line up"); + case PageUp: + return QScrollBar::tr("Page up"); + case Position: + return QScrollBar::tr("Position"); + case PageDown: + return QScrollBar::tr("Page down"); + case LineDown: + return QScrollBar::tr("Line down"); + } + break; + default: + break; + } + return QAccessibleAbstractSlider::text(t, child); +} + +/*! \reimp */ +QAccessible::Role QAccessibleScrollBar::role(int child) const +{ + switch (child) { + case LineUp: + case PageUp: + case PageDown: + case LineDown: + return PushButton; + case Position: + return Indicator; + default: + return ScrollBar; + } +} + +/*! \reimp */ +QAccessible::State QAccessibleScrollBar::state(int child) const +{ + const State parentState = QAccessibleAbstractSlider::state(0); + + if (child == 0) + return parentState; + + // Inherit the Invisible state from parent. + State state = parentState & QAccessible::Invisible; + + // Disable left/right if we are at the minimum/maximum. + const QScrollBar * const scrollBar = QAccessibleScrollBar::scrollBar(); + switch (child) { + case LineUp: + case PageUp: + if (scrollBar->value() <= scrollBar->minimum()) + state |= Unavailable; + break; + case LineDown: + case PageDown: + if (scrollBar->value() >= scrollBar->maximum()) + state |= Unavailable; + break; + case Position: + default: + break; + } + + return state; +} +#endif // QT_NO_SCROLLBAR + +#ifndef QT_NO_SLIDER +/*! + \class QAccessibleSlider + \brief The QAccessibleSlider class implements the QAccessibleInterface for sliders. + \internal + + \ingroup accessibility +*/ + +/*! + \enum QAccessibleSlider::SliderElements + + This enum identifies the components of the slider. + + \value SliderSelf The slider as a whole. + \value PageLeft The area to the left of the position. + \value Position The position indicator. + \value PageRight The area to the right of the position. +*/ + +/*! + Constructs a QAccessibleScrollBar object for \a w. + \a name is propagated to the QAccessibleWidgetEx constructor. +*/ +QAccessibleSlider::QAccessibleSlider(QWidget *w) +: QAccessibleAbstractSlider(w) +{ + Q_ASSERT(slider()); + addControllingSignal(QLatin1String("valueChanged(int)")); +} + +/*! Returns the slider. */ +QSlider *QAccessibleSlider::slider() const +{ + return qobject_cast<QSlider*>(object()); +} + +/*! \reimp */ +QRect QAccessibleSlider::rect(int child) const +{ + QRect rect; + if (!slider()->isVisible()) + return rect; + const QStyleOptionSlider option = qt_qsliderStyleOption(slider()); + QRect srect = slider()->style()->subControlRect(QStyle::CC_Slider, &option, + QStyle::SC_SliderHandle, slider()); + + switch (child) { + case PageLeft: + if (slider()->orientation() == Qt::Vertical) + rect = QRect(0, 0, slider()->width(), srect.y()); + else + rect = QRect(0, 0, srect.x(), slider()->height()); + break; + case Position: + rect = srect; + break; + case PageRight: + if (slider()->orientation() == Qt::Vertical) + rect = QRect(0, srect.y() + srect.height(), slider()->width(), slider()->height()- srect.y() - srect.height()); + else + rect = QRect(srect.x() + srect.width(), 0, slider()->width() - srect.x() - srect.width(), slider()->height()); + break; + default: + return QAccessibleAbstractSlider::rect(child); + } + + QPoint tp = slider()->mapToGlobal(QPoint(0,0)); + return QRect(tp.x() + rect.x(), tp.y() + rect.y(), rect.width(), rect.height()); +} + +/*! \reimp */ +int QAccessibleSlider::childCount() const +{ + if (!slider()->isVisible()) + return 0; + return PageRight; +} + +/*! \reimp */ +QString QAccessibleSlider::text(Text t, int child) const +{ + if (!slider()->isVisible()) + return QString(); + switch (t) { + case Value: + if (!child || child == 2) + return QString::number(slider()->value()); + return QString(); + case Name: + switch (child) { + case PageLeft: + return slider()->orientation() == Qt::Horizontal ? + QSlider::tr("Page left") : QSlider::tr("Page up"); + case Position: + return QSlider::tr("Position"); + case PageRight: + return slider()->orientation() == Qt::Horizontal ? + QSlider::tr("Page right") : QSlider::tr("Page down"); + } + break; + default: + break; + } + return QAccessibleAbstractSlider::text(t, child); +} + +/*! \reimp */ +QAccessible::Role QAccessibleSlider::role(int child) const +{ + switch (child) { + case PageLeft: + case PageRight: + return PushButton; + case Position: + return Indicator; + default: + return Slider; + } +} + +/*! \reimp */ +QAccessible::State QAccessibleSlider::state(int child) const +{ + const State parentState = QAccessibleAbstractSlider::state(0); + + if (child == 0) + return parentState; + + // Inherit the Invisible state from parent. + State state = parentState & QAccessible::Invisible; + + // Disable left/right if we are at the minimum/maximum. + const QSlider * const slider = QAccessibleSlider::slider(); + switch (child) { + case PageLeft: + if (slider->value() <= slider->minimum()) + state |= Unavailable; + break; + case PageRight: + if (slider->value() >= slider->maximum()) + state |= Unavailable; + break; + case Position: + default: + break; + } + + return state; +} + +/*! + \fn int QAccessibleSlider::defaultAction(int child) const + + Returns the default action for the given \a child. The base class + implementation returns 0. +*/ +int QAccessibleSlider::defaultAction(int /*child*/) const +{ +/* + switch (child) { + case SliderSelf: + return SetFocus; + case PageLeft: + return Press; + case PageRight: + return Press; + } +*/ + return 0; +} + +/*! \internal */ +QString QAccessibleSlider::actionText(int /*action*/, Text /*t*/, int /*child*/) const +{ + return QLatin1String(""); +} + +QAccessibleAbstractSlider::QAccessibleAbstractSlider(QWidget *w, Role r) + : QAccessibleWidgetEx(w, r) +{ + Q_ASSERT(qobject_cast<QAbstractSlider *>(w)); +} + +QVariant QAccessibleAbstractSlider::invokeMethodEx(Method method, int child, const QVariantList ¶ms) +{ + switch (method) { + case ListSupportedMethods: { + QSet<QAccessible::Method> set; + set << ListSupportedMethods; + return QVariant::fromValue(set | qvariant_cast<QSet<QAccessible::Method> >( + QAccessibleWidgetEx::invokeMethodEx(method, child, params))); + } + default: + return QAccessibleWidgetEx::invokeMethodEx(method, child, params); + } +} + +QVariant QAccessibleAbstractSlider::currentValue() +{ + return abstractSlider()->value(); +} + +void QAccessibleAbstractSlider::setCurrentValue(const QVariant &value) +{ + abstractSlider()->setValue(value.toInt()); +} + +QVariant QAccessibleAbstractSlider::maximumValue() +{ + return abstractSlider()->maximum(); +} + +QVariant QAccessibleAbstractSlider::minimumValue() +{ + return abstractSlider()->minimum(); +} + +QAbstractSlider *QAccessibleAbstractSlider::abstractSlider() const +{ + return static_cast<QAbstractSlider *>(object()); +} + +#endif // QT_NO_SLIDER + +#ifndef QT_NO_DIAL +// ======================================= QAccessibleDial ====================================== +QAccessibleDial::QAccessibleDial(QWidget *widget) + : QAccessibleWidgetEx(widget, Dial) +{ + Q_ASSERT(qobject_cast<QDial *>(widget)); + addControllingSignal(QLatin1String("valueChanged(int)")); +} + +QRect QAccessibleDial::rect(int child) const +{ + QRect rect; + if (!dial()->isVisible()) + return rect; + switch (child) { + case Self: + return QAccessibleWidgetEx::rect(child); + case SpeedoMeter: { + // Mixture from qcommonstyle.cpp (focus rect). + int width = dial()->width(); + int height = dial()->height(); + qreal radius = qMin(width, height) / 2.0; + qreal delta = radius / 6.0; + qreal dx = delta + (width - 2 * radius) / 2.0; + qreal dy = delta + (height - 2 * radius) / 2.0; + rect = QRect(int(dx), int(dy), int(radius * 2 - 2 * delta), int(radius * 2 - 2 * delta)); + if (dial()->notchesVisible()) { + rect.translate(int(-radius / 6), int(-radius / 6)); + rect.setWidth(rect.width() + int(radius / 3)); + rect.setHeight(rect.height() + int(radius / 3)); + } + break; + } + case SliderHandle: { + // Mixture from qcommonstyle.cpp and qdial.cpp. + int sliderValue = !dial()->invertedAppearance() ? dial()->value() + : (dial()->maximum() - dial()->value()); + qreal angle = 0; + if (dial()->maximum() == dial()->minimum()) { + angle = Q_PI / 2; + } else if (dial()->wrapping()) { + angle = Q_PI * 3 / 2 - (sliderValue - dial()->minimum()) * 2 * Q_PI + / (dial()->maximum() - dial()->minimum()); + } else { + angle = (Q_PI * 8 - (sliderValue - dial()->minimum()) * 10 * Q_PI + / (dial()->maximum() - dial()->minimum())) / 6; + } + + int width = dial()->rect().width(); + int height = dial()->rect().height(); + int radius = qMin(width, height) / 2; + int xc = width / 2; + int yc = height / 2; + int bigLineSize = radius / 6; + if (bigLineSize < 4) + bigLineSize = 4; + if (bigLineSize > radius / 2) + bigLineSize = radius / 2; + int len = radius - bigLineSize - 5; + if (len < 5) + len = 5; + int back = len / 2; + + QPolygonF arrow(3); + arrow[0] = QPointF(0.5 + xc + len * qCos(angle), + 0.5 + yc - len * qSin(angle)); + arrow[1] = QPointF(0.5 + xc + back * qCos(angle + Q_PI * 5 / 6), + 0.5 + yc - back * qSin(angle + Q_PI * 5 / 6)); + arrow[2] = QPointF(0.5 + xc + back * qCos(angle - Q_PI * 5 / 6), + 0.5 + yc - back * qSin(angle - Q_PI * 5 / 6)); + rect = arrow.boundingRect().toRect(); + break; + } + default: + return QRect(); + } + + QPoint globalPos = dial()->mapToGlobal(QPoint(0,0)); + return QRect(globalPos.x() + rect.x(), globalPos.y() + rect.y(), rect.width(), rect.height()); +} + +int QAccessibleDial::childCount() const +{ + if (!dial()->isVisible()) + return 0; + return SliderHandle; +} + +QString QAccessibleDial::text(Text textType, int child) const +{ + if (!dial()->isVisible()) + return QString(); + if (textType == Value && child >= Self && child <= SliderHandle) + return QString::number(dial()->value()); + if (textType == Name) { + switch (child) { + case Self: + if (!widget()->accessibleName().isEmpty()) + return widget()->accessibleName(); + return QDial::tr("QDial"); + case SpeedoMeter: + return QDial::tr("SpeedoMeter"); + case SliderHandle: + return QDial::tr("SliderHandle"); + } + } + return QAccessibleWidgetEx::text(textType, child); +} + +QAccessible::Role QAccessibleDial::role(int child) const +{ + if (child == SpeedoMeter) + return Slider; + else if (child == SliderHandle) + return Indicator; + return QAccessibleWidgetEx::role(child); +} + +QAccessible::State QAccessibleDial::state(int child) const +{ + const State parentState = QAccessibleWidgetEx::state(0); + if (child == SliderHandle) + return parentState | HotTracked; + return parentState; +} + +QVariant QAccessibleDial::invokeMethodEx(Method, int, const QVariantList &) +{ + return QVariant(); +} + +QDial *QAccessibleDial::dial() const +{ + return static_cast<QDial*>(object()); +} +#endif // QT_NO_DIAL + +#endif // QT_NO_ACCESSIBILITY + +QT_END_NAMESPACE |