/****************************************************************************

**

** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the QtGui module 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 "qaccessiblewidget.h"

#ifndef QT_NO_ACCESSIBILITY

#include "qaction.h"

#include "qapplication.h"

#include "qgroupbox.h"

#include "qlabel.h"

#include "qtooltip.h"

#include "qwhatsthis.h"

#include "qwidget.h"

#include "qdebug.h"

#include <qmath.h>

#include <QRubberBand>

#include <QtGui/QFocusFrame>

#include <QtGui/QMenu>

QT_BEGIN_NAMESPACE

static QList<QWidget*> childWidgets(const QWidget *widget)

{

    QList<QObject*> list = widget->children();

    QList<QWidget*> widgets;

    for (int i = 0; i < list.size(); ++i) {

        QWidget *w = qobject_cast<QWidget *>(list.at(i));

        if (w && !w->isWindow() 

            && !qobject_cast<QFocusFrame*>(w)

#if !defined(QT_NO_MENU)

            && !qobject_cast<QMenu*>(w)

#endif

            && w->objectName() != QLatin1String("qt_rubberband"))

            widgets.append(w);

    }

    return widgets;

}

static QString buddyString(const QWidget *widget)

{

    if (!widget)

        return QString();

    QWidget *parent = widget->parentWidget();

    if (!parent)

        return QString();

#ifndef QT_NO_SHORTCUT

    QObjectList ol = parent->children();

    for (int i = 0; i < ol.size(); ++i) {

        QLabel *label = qobject_cast<QLabel*>(ol.at(i));

        if (label && label->buddy() == widget)

            return label->text();

    }

#endif

#ifndef QT_NO_GROUPBOX

    QGroupBox *groupbox = qobject_cast<QGroupBox*>(parent);

    if (groupbox)

        return groupbox->title();

#endif

    return QString();

}

QString Q_GUI_EXPORT qt_accStripAmp(const QString &text)

{

    return QString(text).remove(QLatin1Char('&'));

}

QString Q_GUI_EXPORT qt_accHotKey(const QString &text)

{

#ifndef QT_NO_SHORTCUT

    if (text.isEmpty())

        return text;

    int fa = 0;

    QChar ac;

    while ((fa = text.indexOf(QLatin1Char('&'), fa)) != -1) {

        ++fa;

        if (fa < text.length()) {

            // ignore "&&"

            if (text.at(fa) == QLatin1Char('&')) {

                ++fa;

                continue;

            } else {

                ac = text.at(fa);

                break;

            }

        }

    }

    if (ac.isNull())

        return QString();

    return (QString)QKeySequence(Qt::ALT) + ac.toUpper();

#else

    Q_UNUSED(text);

    return QString();

#endif

}

class QAccessibleWidgetPrivate : public QAccessible

{

public:

    QAccessibleWidgetPrivate()

        :role(Client)

    {}

    Role role;

    QString name;

    QString description;

    QString value;

    QString help;

    QString accelerator;

    QStringList primarySignals;

    const QAccessibleInterface *asking;

};

/*!

    \class QAccessibleWidget

    \brief The QAccessibleWidget class implements the QAccessibleInterface for QWidgets.

    \ingroup accessibility

    This class is convenient to use as a base class for custom

    implementations of QAccessibleInterfaces that provide information

    about widget objects.

    The class provides functions to retrieve the parentObject() (the

    widget's parent widget), and the associated widget(). Controlling

    signals can be added with addControllingSignal(), and setters are

    provided for various aspects of the interface implementation, for

    example setValue(), setDescription(), setAccelerator(), and

    setHelp().

    \sa QAccessible, QAccessibleObject

*/

/*!

    Creates a QAccessibleWidget object for widget \a w.

    \a role and \a name are optional parameters that set the object's

    role and name properties.

*/

QAccessibleWidget::QAccessibleWidget(QWidget *w, Role role, const QString &name)

: QAccessibleObject(w)

{

    Q_ASSERT(widget());

    d = new QAccessibleWidgetPrivate();

    d->role = role;

    d->name = name;

    d->asking = 0;

}

/*!

    Destroys this object.

*/

QAccessibleWidget::~QAccessibleWidget()

{

    delete d;

}

/*!

    Returns the associated widget.

*/

QWidget *QAccessibleWidget::widget() const

{

    return qobject_cast<QWidget*>(object());

}

/*!

    Returns the associated widget's parent object, which is either the

    parent widget, or qApp for top-level widgets.

*/

QObject *QAccessibleWidget::parentObject() const

{

    QObject *parent = object()->parent();

    if (!parent)

        parent = qApp;

    return parent;

}

/*! \reimp */

int QAccessibleWidget::childAt(int x, int y) const

{

    QWidget *w = widget();

    if (!w->isVisible())

        return -1;

    QPoint gp = w->mapToGlobal(QPoint(0, 0));

    if (!QRect(gp.x(), gp.y(), w->width(), w->height()).contains(x, y))

        return -1;

    QWidgetList list = childWidgets(w);

    int ccount = childCount();

    // a complex child

    if (list.size() < ccount) {

        for (int i = 1; i <= ccount; ++i) {

            if (rect(i).contains(x, y))

                return i;

        }

        return 0;

    }

    QPoint rp = w->mapFromGlobal(QPoint(x, y));

    for (int i = 0; i<list.size(); ++i) {

        QWidget *child = list.at(i);

        if (!child->isWindow() && !child->isHidden() && child->geometry().contains(rp)) {

            return i + 1;

        }

    }

    return 0;

}

/*! \reimp */

QRect QAccessibleWidget::rect(int child) const

{

    if (child) {

        qWarning("QAccessibleWidget::rect: This implementation does not support subelements! "

                 "(ID %d unknown for %s)", child, widget()->metaObject()->className());

    }

    QWidget *w = widget();

    if (!w->isVisible())

        return QRect();

    QPoint wpos = w->mapToGlobal(QPoint(0, 0));

    return QRect(wpos.x(), wpos.y(), w->width(), w->height());

}

QT_BEGIN_INCLUDE_NAMESPACE

#include <private/qobject_p.h>

QT_END_INCLUDE_NAMESPACE

class QACConnectionObject : public QObject

{

    Q_DECLARE_PRIVATE(QObject)

public:

    inline bool isSender(const QObject *receiver, const char *signal) const

    { return d_func()->isSender(receiver, signal); }

    inline QObjectList receiverList(const char *signal) const

    { return d_func()->receiverList(signal); }

    inline QObjectList senderList() const

    { return d_func()->senderList(); }

};

/*!

    Registers \a signal as a controlling signal.

    An object is a Controller to any other object connected to a

    controlling signal.

*/

void QAccessibleWidget::addControllingSignal(const QString &signal)

{

    QByteArray s = QMetaObject::normalizedSignature(signal.toAscii());

    if (object()->metaObject()->indexOfSignal(s) < 0)

        qWarning("Signal %s unknown in %s", s.constData(), object()->metaObject()->className());

    d->primarySignals << QLatin1String(s);

}

/*!

    Sets the value of this interface implementation to \a value.

    The default implementation of text() returns the set value for

    the Value text.

    Note that the object wrapped by this interface is not modified.

*/

void QAccessibleWidget::setValue(const QString &value)

{

    d->value = value;

}

/*!

    Sets the description of this interface implementation to \a desc.

    The default implementation of text() returns the set value for

    the Description text.

    Note that the object wrapped by this interface is not modified.

*/

void QAccessibleWidget::setDescription(const QString &desc)

{

    d->description = desc;

}

/*!

    Sets the help of this interface implementation to \a help.

    The default implementation of text() returns the set value for

    the Help text.

    Note that the object wrapped by this interface is not modified.

*/

void QAccessibleWidget::setHelp(const QString &help)

{

    d->help = help;

}

/*!

    Sets the accelerator of this interface implementation to \a accel.

    The default implementation of text() returns the set value for

    the Accelerator text.

    Note that the object wrapped by this interface is not modified.

*/

void QAccessibleWidget::setAccelerator(const QString &accel)

{

    d->accelerator = accel;

}

static inline bool isAncestor(const QObject *obj, const QObject *child)

{

    while (child) {

        if (child == obj)

            return true;

        child = child->parent();

    }

    return false;

}

/*! \reimp */

QAccessible::Relation QAccessibleWidget::relationTo(int child,

            const QAccessibleInterface *other, int otherChild) const

{

    Relation relation = Unrelated;

    if (d->asking == this) // recursive call

        return relation;

    QObject *o = other ? other->object() : 0;

    if (!o)

        return relation;

    QWidget *focus = widget()->focusWidget();

    if (object() == focus && isAncestor(o, focus))

        relation |= FocusChild;

    QACConnectionObject *connectionObject = (QACConnectionObject*)object();

    for (int sig = 0; sig < d->primarySignals.count(); ++sig) {

        if (connectionObject->isSender(o, d->primarySignals.at(sig).toAscii())) {

            relation |= Controller;

            break;

        }

    }

    // test for passive relationships.

    // d->asking protects from endless recursion.

    d->asking = this;

    int inverse = other->relationTo(otherChild, this, child);

    d->asking = 0;

    if (inverse & Controller)

        relation |= Controlled;

    if (inverse & Label)

        relation |= Labelled;

    if(o == object()) {

        if (child && !otherChild)

            return relation | Child;

        if (!child && otherChild)

            return relation | Ancestor;

        if (!child && !otherChild)

            return relation | Self;

    }

    QObject *parent = object()->parent();

    if (o == parent)

        return relation | Child;

    if (o->parent() == parent) {

        relation |= Sibling;

        QAccessibleInterface *sibIface = QAccessible::queryAccessibleInterface(o);

        Q_ASSERT(sibIface);

        QRect wg = rect(0);

        QRect sg = sibIface->rect(0);

        if (wg.intersects(sg)) {

            QAccessibleInterface *pIface = 0;

            sibIface->navigate(Ancestor, 1, &pIface);

            if (pIface && !((sibIface->state(0) | state(0)) & Invisible)) {

                int wi = pIface->indexOfChild(this);

                int si = pIface->indexOfChild(sibIface);

                if (wi > si)

                    relation |= QAccessible::Covers;

                else

                    relation |= QAccessible::Covered;

            }

            delete pIface;

        } else {

            QPoint wc = wg.center();

            QPoint sc = sg.center();

            if (wc.x() < sc.x())

                relation |= QAccessible::Left;

            else if(wc.x() > sc.x())

                relation |= QAccessible::Right;

            if (wc.y() < sc.y())

                relation |= QAccessible::Up;

            else if (wc.y() > sc.y())

                relation |= QAccessible::Down;

        }

        delete sibIface;

        return relation;

    }

    if (isAncestor(o, object()))

        return relation | Descendent;

    if (isAncestor(object(), o))

        return relation | Ancestor;

    return relation;

}

/*! \reimp */

int QAccessibleWidget::navigate(RelationFlag relation, int entry,

                                QAccessibleInterface **target) const

{

    if (!target)

        return -1;

    *target = 0;

    QObject *targetObject = 0;

    QWidgetList childList = childWidgets(widget());

    bool complexWidget = childList.size() < childCount();

    switch (relation) {

    // Hierarchical

    case Self:

        targetObject = object();

        break;

    case Child:

        if (complexWidget) {

            if (entry > 0 && entry <= childCount())

                return entry;

            return -1;

        }else {

            if (entry > 0 && childList.size() >= entry)

                targetObject = childList.at(entry - 1);

        }

        break;

    case Ancestor:

        {

            if (entry <= 0)

                return -1;

            targetObject = widget()->parentWidget();

            int i;

            for (i = entry; i > 1 && targetObject; --i)

                targetObject = targetObject->parent();

            if (!targetObject && i == 1)

                targetObject = qApp;

        }

        break;

    case Sibling:

        {

            QAccessibleInterface *iface = QAccessible::queryAccessibleInterface(parentObject());

            if (!iface)

                return -1;

            iface->navigate(Child, entry, target);

            delete iface;

            if (*target)

                return 0;

        }

        break;

    // Geometrical

    case QAccessible::Left:

        if (complexWidget && entry) {

            if (entry < 2 || widget()->height() > widget()->width() + 20) // looks vertical

                return -1;

            return entry - 1;

        }

        // fall through

    case QAccessible::Right:

        if (complexWidget && entry) {

            if (entry >= childCount() || widget()->height() > widget()->width() + 20) // looks vertical

                return -1;

            return entry + 1;

        }

        // fall through

    case QAccessible::Up:

        if (complexWidget && entry) {

            if (entry < 2 || widget()->width() > widget()->height() + 20) // looks horizontal

                return - 1;

            return entry - 1;

        }

        // fall through

    case QAccessible::Down:

        if (complexWidget && entry) {

            if (entry >= childCount() || widget()->width() > widget()->height()  + 20) // looks horizontal

                return - 1;