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

**

** 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 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 "complexwidgets.h"

#include <qapplication.h>

#include <qabstractbutton.h>

#include <qevent.h>

#include <qheaderview.h>

#include <qtabbar.h>

#include <qcombobox.h>

#include <qlistview.h>

#include <qtableview.h>

#include <qlineedit.h>

#include <qstyle.h>

#include <qstyleoption.h>

#include <qtooltip.h>

#include <qwhatsthis.h>

#include <qtreeview.h>

#include <private/qtabbar_p.h>

#include <QAbstractScrollArea>

#include <QScrollArea>

#include <QScrollBar>

#include <QDebug>

#ifndef QT_NO_ACCESSIBILITY

QT_BEGIN_NAMESPACE

QString Q_GUI_EXPORT qt_accStripAmp(const QString &text);

#ifndef QT_NO_ITEMVIEWS

/*

The MSDN article "Exposing Data Tables through Microsoft Active Accessibility" explains

how data tables should be exposed. Url: http://msdn2.microsoft.com/en-us/library/ms971325.aspx

Basically, the model is like this:

ROLE_SYSTEM_TABLE

  |- ROLE_SYSTEM_ROW

  |  |- ROLE_SYSTEM_ROWHEADER

  |  |- ROLE_SYSTEM_COLUMNHEADER

  |  |- ROLE_SYSTEM_COLUMNHEADER

  |  |- ROLE_SYSTEM_COLUMNHEADER

  |     '- ..

  |- ROLE_SYSTEM_ROW

  |  |- ROLE_SYSTEM_ROWHEADER

  |  |- ROLE_SYSTEM_CELL

  |  |- ROLE_SYSTEM_CELL

  |  |- ROLE_SYSTEM_CELL

  |   '- ..

  |- ROLE_SYSTEM_ROW

  |  |- ROLE_SYSTEM_ROWHEADER

  |  |- ROLE_SYSTEM_CELL

  |  |- ROLE_SYSTEM_CELL

  |  |- ROLE_SYSTEM_CELL

  |   '- ..

   '- ..

The headers of QTreeView is also represented like this.

*/

QAccessibleItemRow::QAccessibleItemRow(QAbstractItemView *aView, const QModelIndex &index, bool isHeader)

    : row(index), view(aView), m_header(isHeader)

{

}

QHeaderView *QAccessibleItemRow::horizontalHeader() const

{

    QHeaderView *header = 0;

    if (m_header) {

        if (false) {

#ifndef QT_NO_TABLEVIEW

        } else if (const QTableView *tv = qobject_cast<const QTableView*>(view)) {

            header = tv->horizontalHeader();

#endif

#ifndef QT_NO_TREEVIEW

        } else if (const QTreeView *tv = qobject_cast<const QTreeView*>(view)) {

            header = tv->header();

#endif

        }

    }

    return header;

}

QHeaderView *QAccessibleItemRow::verticalHeader() const

{

    QHeaderView *header = 0;

#ifndef QT_NO_TABLEVIEW

    if (const QTableView *tv = qobject_cast<const QTableView*>(view))

        header = tv->verticalHeader();

#endif

    return header;

}

int QAccessibleItemRow::logicalFromChild(QHeaderView *header, int child) const

{

    int logical = -1;

    if (header->sectionsHidden()) {

        int kid = 0;

        for (int i = 0; i < header->count(); ++i) {

            if (!header->isSectionHidden(i))

                ++kid;

            if (kid == child) {

                logical = i;

                break;

            }

        }

    } else {

        logical = child - 1;

    }

    return logical;

}

QRect QAccessibleItemRow::rect(int child) const

{

    QRect r;

    if (view && view->isVisible()) {

        if (QHeaderView *header = horizontalHeader()) {

            if (!child) {

                r = header->rect();

            } else {

                if (QHeaderView *vheader = verticalHeader()) {

                    if (child == 1) {

                        int w = vheader->width();

                        int h = header->height();

                        r.setRect(0, 0, w, h);

                    }

                    --child;

                }

                if (child) {

                    int logical = logicalFromChild(header, child);

                    int w = header->sectionSize(logical);

                    r.setRect(header->sectionViewportPosition(logical), 0, w, header->height());

                    r.translate(header->mapTo(view, QPoint(0, 0)));

                }

            }

        } else if (row.isValid()) {

            if (!child) {

                QModelIndex parent = row.parent();

                const int colCount = row.model()->columnCount(parent);

                for (int i = 0; i < colCount; ++i)

                    r |= view->visualRect(row.model()->index(row.row(), i, parent));

                r.translate(view->viewport()->mapTo(view, QPoint(0,0)));

                if (const QHeaderView *vheader = verticalHeader()) { // include the section of the vertical header

                    QRect re;

                    int logicalRow = row.row();

                    int h = vheader->sectionSize(logicalRow);

                    re.setRect(0, vheader->sectionViewportPosition(logicalRow), vheader->width(), h);

                    re.translate(vheader->mapTo(view, QPoint(0, 0)));

                    r |= re;

                }

            } else {

                if (QHeaderView *vheader = verticalHeader()) {

                    if (child == 1) {

                        int logicalRow = row.row();

                        int h = vheader->sectionSize(logicalRow);

                        r.setRect(0, vheader->sectionViewportPosition(logicalRow), vheader->width(), h);

                        r.translate(vheader->mapTo(view, QPoint(0, 0)));

                    }

                    --child;

                }

                if (child) {

                    r = view->visualRect(childIndex(child));

                    r.translate(view->viewport()->mapTo(view, QPoint(0,0)));

                }

            }

        }

    }

    if (!r.isNull())

        r.translate(view->mapToGlobal(QPoint(0, 0)));

    return r;

}

int QAccessibleItemRow::treeLevel() const

{

    int level = 0;

    QModelIndex idx = row;

    while (idx.isValid()) {

        idx = idx.parent();

        ++level;

    }

    return level;

}

QString QAccessibleItemRow::text_helper(int child) const

{

    QString value;

    if (m_header) {

        if (!child)

            return QString();

        if (verticalHeader()) {

            if (child == 1)

                return QString();

            --child;

        }

        QHeaderView *header = horizontalHeader();

        int logical = logicalFromChild(header, child);

        value = view->model()->headerData(logical, Qt::Horizontal, Qt::AccessibleTextRole).toString();

        if (value.isEmpty())

            value = view->model()->headerData(logical, Qt::Horizontal).toString();

        return value;

    } else {

        if (!child) {   // for one-column views (i.e. QListView)

            if (children().count() >= 1)

                child = 1;

            else

                return QString();

        }

        if (verticalHeader()) {

            if (child == 1) {

                int logical = row.row();

                value = view->model()->headerData(logical, Qt::Vertical, Qt::AccessibleTextRole).toString();

                if (value.isEmpty())

                    value = view->model()->headerData(logical, Qt::Vertical).toString();

                return value;

            } else {

                --child;

            }

        }

    }

    if (value.isEmpty()) {

        QModelIndex idx = childIndex(child);

        if (idx.isValid()) {

            value = idx.model()->data(idx, Qt::AccessibleTextRole).toString();

            if (value.isEmpty())

                value = idx.model()->data(idx, Qt::DisplayRole).toString();

        }

    }

    return value;

}

QString QAccessibleItemRow::text(Text t, int child) const

{

    QString value;

    if (t == Name) {

        value = text_helper(child);

    } else if (t == Value) {

#ifndef QT_NO_TREEVIEW

        if (qobject_cast<const QTreeView*>(view)) {

            if (child == 0)

                value = QString::number(treeLevel());

        } else

#endif

        {

            value = text_helper(child);

        }

    } else if (t == Description) {

#ifndef QT_NO_TREEVIEW

        if (child == 0 && qobject_cast<const QTreeView*>(view)) {

            // We store the tree coordinates of the current item in the description.

            // This enables some screen readers to report where the focus is

            // in a tree view. (works in JAWS). Also, Firefox does the same thing.

            // For instance the description "L2, 4 of 25 with 24" means

            // "L2": Tree Level 2

            // "4 of 25": We are item 4 out of in total 25 other siblings

            // "with 24": We have 24 children. (JAWS does not read this number)

            // level

            int level = treeLevel();

            QAbstractItemModel *m = view->model();

            // totalSiblings and itemIndex

            QModelIndex parent = row.parent();

            int rowCount = m->rowCount(parent);

            int itemIndex = -1;

            int totalSiblings = 0;

            for (int i = 0 ; i < rowCount; ++i) {

                QModelIndex sibling = row.sibling(i, 0);

                if (!view->isIndexHidden(sibling))

                    ++totalSiblings;

                if (row == sibling)

                    itemIndex = totalSiblings;

            }

            int totalChildren = m->rowCount(row);   // JAWS does not report child count, so we do

                                                    // this simple and efficient.

                                                    // (don't check if they are all visible).

            value = QString::fromAscii("L%1, %2 of %3 with %4").arg(level).arg(itemIndex).arg(totalSiblings).arg(totalChildren);

        } else

#endif // QT_NO_TREEVIEW

        {

            if (!m_header) {

                if (child == 0 && children().count() >= 1)

                    child = 1;

                if (verticalHeader()) {

                    if (child == 1) {

                        value = view->model()->headerData(row.row(), Qt::Vertical).toString();

                    }

                    --child;

                }

                if (child) {

                    QModelIndex idx = childIndex(child);

                    value = idx.model()->data(idx, Qt::AccessibleDescriptionRole).toString();

                }

            }

        }

    }

    return value;

}

void QAccessibleItemRow::setText(Text t, int child, const QString &text)

{

    if (m_header) {

        if (child)

            view->model()->setHeaderData(child - 1, Qt::Horizontal, text);

        // child == 0 means the cell to the left of the horizontal header, which is empty!?

    } else {

        if (!child) {

            if (children().count() == 1)

                child = 1;

            else

                return;

        }

        if (verticalHeader()) {

            if (child == 1) {

                view->model()->setHeaderData(row.row(), Qt::Vertical, text);

                return;

            }

            --child;

        }

        QModelIndex idx = childIndex(child);

        if (!idx.isValid())

            return;

        switch (t) {

        case Description:

            const_cast<QAbstractItemModel *>(idx.model())->setData(idx, text,

                                             Qt::AccessibleDescriptionRole);

            break;

        case Value:

            const_cast<QAbstractItemModel *>(idx.model())->setData(idx, text, Qt::EditRole);

            break;

        default:

            break;

        }

    }

}

QModelIndex QAccessibleItemRow::childIndex(int child) const

{

    QList<QModelIndex> kids = children();

    Q_ASSERT(child >= 1 && child <= kids.count());

    return kids.at(child - 1);

}

QList<QModelIndex> QAccessibleItemRow::children() const

{

    QList<QModelIndex> kids;

    for (int i = 0; i < row.model()->columnCount(row.parent()); ++i) {

        QModelIndex idx = row.model()->index(row.row(), i, row.parent());

        if (!view->isIndexHidden(idx)) {

            kids << idx;

        }

    }

    return kids;

}

bool QAccessibleItemRow::isValid() const

{

    return m_header ? true : row.isValid();

}

QObject *QAccessibleItemRow::object() const

{

    return 0;

}

int QAccessibleItemRow::childCount() const

{

    int count = 0;

    if (QHeaderView *header = horizontalHeader()) {

        count = header->count() - header->hiddenSectionCount();

    } else {

        count = children().count();

    }

#ifndef QT_NO_TABLEVIEW

    if (qobject_cast<const QTableView*>(view)) {

        if (verticalHeader())

            ++count;

    }

#endif

    return count;

}

int QAccessibleItemRow::indexOfChild(const QAccessibleInterface *iface) const

{

    if (!iface || iface->role(0) != Row)

        return -1;

    //### meaningless code?

    QList<QModelIndex> kids = children();

    QModelIndex idx = static_cast<const QAccessibleItemRow *>(iface)->row;

    if (!idx.isValid())

        return -1;

    return kids.indexOf(idx) + 1;

}

QAccessible::Relation QAccessibleItemRow::relationTo(int child, const QAccessibleInterface *other,

        int otherChild) const

{

    if (!child && !otherChild && other->object() == view)

        return Child;

    if (!child && !otherChild && other == this)

        return Self;

    if (!child && otherChild && other == this)

        return Ancestor;

    if (child && otherChild && other == this)

        return Sibling;

    return Unrelated;

}

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

{

    if (!view || !view->isVisible())

        return -1;

    for (int i = childCount(); i >= 0; --i) {

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

            return i;

    }

    return -1;

}

QAbstractItemView::CursorAction QAccessibleItemRow::toCursorAction(

                                           QAccessible::Relation rel)

{

    switch (rel) {

    case QAccessible::Up:

        return QAbstractItemView::MoveUp;

    case QAccessible::Down:

        return QAbstractItemView::MoveDown;

    case QAccessible::Left:

        return QAbstractItemView::MoveLeft;

    case QAccessible::Right:

        return QAbstractItemView::MoveRight;

    default:

        Q_ASSERT(false);

    }

    // should never be reached.

    return QAbstractItemView::MoveRight;

}

int QAccessibleItemRow::navigate(RelationFlag relation, int index,

                                 QAccessibleInterface **iface) const

{

    *iface = 0;

    if (!view)

        return -1;

    switch (relation) {

    case Ancestor: {

        if (!index)

            return -1;

        QAccessibleItemView *ancestor = new QAccessibleItemView(view->viewport());

        if (index == 1) {

            *iface = ancestor;

            return 0;

        } else if (index > 1) {

            int ret = ancestor->navigate(Ancestor, index - 1, iface);

            delete ancestor;

            return ret;

        }

        }

    case Child: {

        if (!index)

            return -1;

        if (index < 1 && index > childCount())

            return -1;

        return index;}

    case Sibling:

        if (index) {

            QAccessibleInterface *ifaceParent = 0;

            navigate(Ancestor, 1, &ifaceParent);

            if (ifaceParent) {

                int entry = ifaceParent->navigate(Child, index, iface);

                delete ifaceParent;

                return entry;

            }

        }

        return -1;

    case Up:

    case Down:

    case Left:

    case Right: {

        // This is in the "not so nice" category. In order to find out which item

        // is geometrically around, we have to set the current index, navigate

        // and restore the index as well as the old selection