Merge branch 'master' of git://scm.dev.nokia.troll.no/qt/qt-water-team

* 'master' of git://scm.dev.nokia.troll.no/qt/qt-water-team: (34 commits)
  Remove testing for Hide of mainwindow.
  Fix accessibility test for QWS.
  Fixes leaking X11 SyncCounter when widgets get open/destroyed
  Fix the timeout calculation for futexes in QMutex.
  Fix test for win and mac.
  namespace fix
  fix build
  get rid of unwanted dependencies and unused header includes
  sync qws_dataDir() with coreapp's internal qws_dataDir()
  Add constants to QAccessible::Event enum.
  Call QAccessible::updateAccessibility when setText is called on QLabel
  Added Solaris build fix to the changes file.
  Documentation fix.
  Fix autotest for accessible tables.
  make argument quoting code on windows less arcane
  fix argument quoting on windows
  Style cleanup - space after flow control keywords.
  Add IAccessible2 table2 implementation.
  Fix potential crash when clicking in a text edit
  Compensate for different rounding rule in CG engine
  ...

4 files changed, 1382 insertions, 10 deletions

diff --git a/src/plugins/accessible/widgets/itemviews.cpp b/src/plugins/accessible/widgets/itemviews.cpp
new file mode 100644
index 0000000..4618f87
--- /dev/null
+++ b/src/plugins/accessible/widgets/itemviews.cpp
@@ -0,0 +1,1029 @@
+/****************************************************************************
+**
+** 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$
+** GNU Lesser General Public License Usage
+** 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.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU General
+** Public License version 3.0 as published by the Free Software Foundation
+** and appearing in the file LICENSE.GPL included in the packaging of this
+** file. Please review the following information to ensure the GNU General
+** Public License version 3.0 requirements will be met:
+** http://www.gnu.org/copyleft/gpl.html.
+**
+** Other Usage
+** Alternatively, this file may be used in accordance with the terms and
+** conditions contained in a signed written agreement between you and Nokia.
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "itemviews.h"
+
+#include <qheaderview.h>
+#include <qtableview.h>
+#include <qlistview.h>
+#include <qtreeview.h>
+#include <private/qtreewidget_p.h>
+#include <qaccessible2.h>
+#include <QDebug>
+
+#ifndef QT_NO_ACCESSIBILITY
+
+QT_BEGIN_NAMESPACE
+
+QString Q_GUI_EXPORT qt_accStripAmp(const QString &text);
+
+#ifndef QT_NO_ITEMVIEWS
+/*
+Implementation of the IAccessible2 table2 interface. Much simpler than
+the other table interfaces since there is only the main table and cells:
+
+TABLE/LIST/TREE
+  |- HEADER CELL
+  |- CELL
+  |- CELL
+  ...
+*/
+
+int QAccessibleTable2::logicalIndex(const QModelIndex &index) const
+{
+    if (!index.isValid())
+        return -1;
+    int vHeader = verticalHeader() ? 1 : 0;
+    int hHeader = horizontalHeader() ? 1 : 0;
+    // row * number columns + column + 1 for one based counting
+    return (index.row() + hHeader)*(index.model()->columnCount() + vHeader) + (index.column() + vHeader) + 1;
+}
+
+QAccessibleInterface *QAccessibleTable2::childFromLogical(int logicalIndex) const
+{
+    logicalIndex--; // one based counting ftw
+    int vHeader = verticalHeader() ? 1 : 0;
+    int hHeader = horizontalHeader() ? 1 : 0;
+
+    int columns = view->model()->columnCount() + vHeader;
+
+    int row = logicalIndex / columns;
+    int column = logicalIndex % columns;
+
+    if (vHeader) {
+        if (column == 0) {
+            if (row == 0) {
+                return new QAccessibleTable2CornerButton(view);
+            }
+            return new QAccessibleTable2HeaderCell(view, row-1, Qt::Vertical);
+        }
+        --column;
+    }
+    if (hHeader) {
+        if (row == 0) {
+            return new QAccessibleTable2HeaderCell(view, column, Qt::Horizontal);
+        }
+        --row;
+    }
+    return new QAccessibleTable2Cell(view, view->model()->index(row, column), cellRole());
+}
+
+QAccessibleTable2::QAccessibleTable2(QWidget *w)
+    : QAccessibleObjectEx(w)
+{
+    view = qobject_cast<QAbstractItemView *>(w);
+    Q_ASSERT(view);
+
+    if (qobject_cast<const QTableView*>(view)) {
+        m_role = QAccessible::Table;
+    } else if (qobject_cast<const QTreeView*>(view)) {
+        m_role = QAccessible::Tree;
+    } else if (qobject_cast<const QListView*>(view)) {
+        m_role = QAccessible::List;
+    } else {
+        // is this our best guess?
+        m_role = QAccessible::Table;
+    }
+}
+
+QAccessibleTable2::~QAccessibleTable2()
+{
+}
+
+QHeaderView *QAccessibleTable2::horizontalHeader() const
+{
+    QHeaderView *header = 0;
+    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 *QAccessibleTable2::verticalHeader() const
+{
+    QHeaderView *header = 0;
+    if (false) {
+#ifndef QT_NO_TABLEVIEW
+    } else if (const QTableView *tv = qobject_cast<const QTableView*>(view)) {
+        header = tv->verticalHeader();
+#endif
+    }
+    return header;
+}
+
+void QAccessibleTable2::modelReset()
+{}
+
+void QAccessibleTable2::rowsInserted(const QModelIndex &, int first, int last)
+{
+    lastChange.firstRow = first;
+    lastChange.lastRow = last;
+    lastChange.firstColumn = 0;
+    lastChange.lastColumn = 0;
+    lastChange.type = QAccessible2::TableModelChangeInsert;
+}
+
+void QAccessibleTable2::rowsRemoved(const QModelIndex &, int first, int last)
+{
+    lastChange.firstRow = first;
+    lastChange.lastRow = last;
+    lastChange.firstColumn = 0;
+    lastChange.lastColumn = 0;
+    lastChange.type = QAccessible2::TableModelChangeDelete;
+}
+
+void QAccessibleTable2::columnsInserted(const QModelIndex &, int first, int last)
+{
+    lastChange.firstRow = 0;
+    lastChange.lastRow = 0;
+    lastChange.firstColumn = first;
+    lastChange.lastColumn = last;
+    lastChange.type = QAccessible2::TableModelChangeInsert;
+}
+
+void QAccessibleTable2::columnsRemoved(const QModelIndex &, int first, int last)
+{
+    lastChange.firstRow = 0;
+    lastChange.lastRow = 0;
+    lastChange.firstColumn = first;
+    lastChange.lastColumn = last;
+    lastChange.type = QAccessible2::TableModelChangeDelete;
+}
+
+void QAccessibleTable2::rowsMoved( const QModelIndex &, int, int, const QModelIndex &, int)
+{
+    lastChange.firstRow = 0;
+    lastChange.lastRow = 0;
+    lastChange.firstColumn = 0;
+    lastChange.lastColumn = 0;
+    lastChange.type = QAccessible2::TableModelChangeUpdate;
+}
+
+void QAccessibleTable2::columnsMoved( const QModelIndex &, int, int, const QModelIndex &, int)
+{
+    lastChange.firstRow = 0;
+    lastChange.lastRow = 0;
+    lastChange.firstColumn = 0;
+    lastChange.lastColumn = 0;
+    lastChange.type = QAccessible2::TableModelChangeUpdate;
+}
+
+QAccessibleTable2Cell *QAccessibleTable2::cell(const QModelIndex &index) const
+{
+    if (index.isValid())
+        return new QAccessibleTable2Cell(view, index, cellRole());
+    return 0;
+}
+
+QAccessibleTable2CellInterface *QAccessibleTable2::cellAt(int row, int column) const
+{
+    Q_ASSERT(role(0) != QAccessible::Tree);
+    QModelIndex index = view->model()->index(row, column);
+    //Q_ASSERT(index.isValid());
+    if (!index.isValid()) {
+        qWarning() << "QAccessibleTable2::cellAt: invalid index: " << index << " for " << view;
+        return 0;
+    }
+    return cell(index);
+}
+
+QAccessibleInterface *QAccessibleTable2::caption() const
+{
+    return 0;
+}
+
+QString QAccessibleTable2::columnDescription(int column) const
+{
+    return view->model()->headerData(column, Qt::Horizontal).toString();
+}
+
+int QAccessibleTable2::columnCount() const
+{
+    return view->model()->columnCount();
+}
+
+int QAccessibleTable2::rowCount() const
+{
+    return view->model()->rowCount();
+}
+
+int QAccessibleTable2::selectedCellCount() const
+{
+    return view->selectionModel()->selectedIndexes().count();
+}
+
+int QAccessibleTable2::selectedColumnCount() const
+{
+    return view->selectionModel()->selectedColumns().count();
+}
+
+int QAccessibleTable2::selectedRowCount() const
+{
+    return view->selectionModel()->selectedRows().count();
+}
+
+QString QAccessibleTable2::rowDescription(int row) const
+{
+    return view->model()->headerData(row, Qt::Vertical).toString();
+}
+
+QList<QAccessibleTable2CellInterface*> QAccessibleTable2::selectedCells() const
+{
+    QList<QAccessibleTable2CellInterface*> cells;
+    Q_FOREACH (const QModelIndex &index, view->selectionModel()->selectedIndexes()) {
+        cells.append(cell(index));
+    }
+    return cells;
+}
+
+QList<int> QAccessibleTable2::selectedColumns() const
+{
+    QList<int> columns;
+    Q_FOREACH (const QModelIndex &index, view->selectionModel()->selectedColumns()) {
+        columns.append(index.column());
+    }
+    return columns;
+}
+
+QList<int> QAccessibleTable2::selectedRows() const
+{
+    QList<int> rows;
+    Q_FOREACH (const QModelIndex &index, view->selectionModel()->selectedRows()) {
+        rows.append(index.row());
+    }
+    return rows;
+}
+
+QAccessibleInterface *QAccessibleTable2::summary() const
+{
+    return 0;
+}
+
+bool QAccessibleTable2::isColumnSelected(int column) const
+{
+    return view->selectionModel()->isColumnSelected(column, QModelIndex());
+}
+
+bool QAccessibleTable2::isRowSelected(int row) const
+{
+    return view->selectionModel()->isRowSelected(row, QModelIndex());
+}
+
+bool QAccessibleTable2::selectRow(int row)
+{
+    QModelIndex index = view->model()->index(row, 0);
+    if (!index.isValid() || view->selectionMode() & QAbstractItemView::NoSelection)
+        return false;
+    view->selectionModel()->select(index, QItemSelectionModel::Select);
+    return true;
+}
+
+bool QAccessibleTable2::selectColumn(int column)
+{
+    QModelIndex index = view->model()->index(0, column);
+    if (!index.isValid() || view->selectionMode() & QAbstractItemView::NoSelection)
+        return false;
+    view->selectionModel()->select(index, QItemSelectionModel::Select);
+    return true;
+}
+
+bool QAccessibleTable2::unselectRow(int row)
+{
+    QModelIndex index = view->model()->index(row, 0);
+    if (!index.isValid() || view->selectionMode() & QAbstractItemView::NoSelection)
+        return false;
+    view->selectionModel()->select(index, QItemSelectionModel::Deselect);
+    return true;
+}
+
+bool QAccessibleTable2::unselectColumn(int column)
+{
+    QModelIndex index = view->model()->index(0, column);
+    if (!index.isValid() || view->selectionMode() & QAbstractItemView::NoSelection)
+        return false;
+    view->selectionModel()->select(index, QItemSelectionModel::Columns & QItemSelectionModel::Deselect);
+    return true;
+}
+
+QAccessible2::TableModelChange QAccessibleTable2::modelChange() const
+{
+    QAccessible2::TableModelChange change;
+    // FIXME
+    return change;
+}
+
+QAccessible::Role QAccessibleTable2::role(int child) const
+{
+    Q_ASSERT(child >= 0);
+    if (child > 0)
+        return QAccessible::Cell;
+    return m_role;
+}
+
+QAccessible::State QAccessibleTable2::state(int child) const
+{
+    Q_ASSERT(child == 0);
+    return QAccessible::Normal | HasInvokeExtension;
+}
+
+int QAccessibleTable2::childAt(int x, int y) const
+{
+    QPoint viewportOffset = view->viewport()->mapTo(view, QPoint(0,0));
+    QPoint indexPosition = view->mapFromGlobal(QPoint(x, y) - viewportOffset);
+    // FIXME: if indexPosition < 0 in one coordinate, return header
+
+    QModelIndex index = view->indexAt(indexPosition);
+    if (index.isValid()) {
+        return logicalIndex(index);
+    }
+    return -1;
+}
+
+int QAccessibleTable2::childCount() const
+{
+    int vHeader = verticalHeader() ? 1 : 0;
+    int hHeader = horizontalHeader() ? 1 : 0;
+    return (view->model()->rowCount()+hHeader) * (view->model()->columnCount()+vHeader);
+}
+
+int QAccessibleTable2::indexOfChild(const QAccessibleInterface *iface) const
+{
+    Q_ASSERT(iface->role(0) != QAccessible::TreeItem); // should be handled by tree class
+    if (iface->role(0) == QAccessible::Cell || iface->role(0) == QAccessible::ListItem) {
+        const QAccessibleTable2Cell* cell = static_cast<const QAccessibleTable2Cell*>(iface);
+        return logicalIndex(cell->m_index);
+    } else if (iface->role(0) == QAccessible::ColumnHeader){
+        const QAccessibleTable2HeaderCell* cell = static_cast<const QAccessibleTable2HeaderCell*>(iface);
+        return cell->index + (verticalHeader() ? 1 : 0) + 1;
+    } else if (iface->role(0) == QAccessible::RowHeader){
+        const QAccessibleTable2HeaderCell* cell = static_cast<const QAccessibleTable2HeaderCell*>(iface);
+        return (cell->index+1) * (view->model()->rowCount()+1)  + 1;
+    } else if (iface->role(0) == QAccessible::Pane) {
+        return 1; // corner button
+    } else {
+        qWarning() << "WARNING QAccessibleTable2::indexOfChild Fix my children..."
+                   << iface->role(0) << iface->text(QAccessible::Name, 0);
+    }
+    // FIXME: we are in denial of our children. this should stop.
+    return -1;
+}
+
+QString QAccessibleTable2::text(Text t, int child) const
+{
+    Q_ASSERT(child == 0);
+    if (t == QAccessible::Description)
+        return view->accessibleDescription();
+    return view->accessibleName();
+}
+
+QRect QAccessibleTable2::rect(int child) const
+{
+    Q_ASSERT(!child);
+    if (!view->isVisible())
+        return QRect();
+    QPoint pos = view->mapToGlobal(QPoint(0, 0));
+    return QRect(pos.x(), pos.y(), view->width(), view->height());
+}
+
+int QAccessibleTable2::navigate(RelationFlag relation, int index, QAccessibleInterface **iface) const
+{
+    *iface = 0;
+    switch (relation) {
+    case Ancestor: {
+        if (index == 1 && view->parent()) {
+            *iface = QAccessible::queryAccessibleInterface(view->parent());
+            if (*iface)
+                return 0;
+        }
+        break;
+    }
+    case QAccessible::Child: {
+        Q_ASSERT(index > 0);
+        *iface = childFromLogical(index);
+        if (*iface) {
+            return 0;
+        }
+        break;
+    }
+    default:
+        break;
+    }
+    return -1;
+}
+
+QAccessible::Relation QAccessibleTable2::relationTo(int, const QAccessibleInterface *, int) const
+{
+    return QAccessible::Unrelated;
+}
+
+#ifndef QT_NO_ACTION
+int QAccessibleTable2::userActionCount(int) const
+{
+    return 0;
+}
+QString QAccessibleTable2::actionText(int, Text, int) const
+{
+    return QString();
+}
+bool QAccessibleTable2::doAction(int, int, const QVariantList &)
+{
+    return false;
+}
+#endif
+
+
+// TREE VIEW
+
+QModelIndex QAccessibleTree::indexFromLogical(int row, int column) const
+{
+    const QTreeView *treeView = qobject_cast<const QTreeView*>(view);
+    QModelIndex modelIndex = treeView->d_func()->viewItems.at(row).index;
+
+    if (modelIndex.isValid() && column > 0) {
+        modelIndex = view->model()->index(modelIndex.row(), column, modelIndex.parent());
+    }
+    return modelIndex;
+}
+
+int QAccessibleTree::childAt(int x, int y) const
+{
+    QPoint viewportOffset = view->viewport()->mapTo(view, QPoint(0,0));
+    QPoint indexPosition = view->mapFromGlobal(QPoint(x, y) - viewportOffset);
+
+    QModelIndex index = view->indexAt(indexPosition);
+    if (!index.isValid())
+        return -1;
+
+    const QTreeView *treeView = qobject_cast<const QTreeView*>(view);
+    int row = treeView->d_func()->viewIndex(index) + (horizontalHeader() ? 1 : 0);
+    int column = index.column();
+
+    int i = row * view->model()->columnCount() + column + 1;
+    Q_ASSERT(i > view->model()->columnCount());
+    return i;
+}
+
+int QAccessibleTree::childCount() const
+{
+    const QTreeView *treeView = qobject_cast<const QTreeView*>(view);
+    Q_ASSERT(treeView);
+    if (!view->model())
+        return 0;
+
+    int hHeader = horizontalHeader() ? 1 : 0;
+    return (treeView->d_func()->viewItems.count() + hHeader)* view->model()->columnCount();
+}
+
+int QAccessibleTree::rowCount() const
+{
+    const QTreeView *treeView = qobject_cast<const QTreeView*>(view);
+    Q_ASSERT(treeView);
+    return treeView->d_func()->viewItems.count();
+}
+
+int QAccessibleTree::indexOfChild(const QAccessibleInterface *iface) const
+{
+     if (iface->role(0) == QAccessible::TreeItem) {
+        const QAccessibleTable2Cell* cell = static_cast<const QAccessibleTable2Cell*>(iface);
+        const QTreeView *treeView = qobject_cast<const QTreeView*>(view);
+        Q_ASSERT(treeView);
+        int row = treeView->d_func()->viewIndex(cell->m_index) + (horizontalHeader() ? 1 : 0);
+        int column = cell->m_index.column();
+
+        int index = row * view->model()->columnCount() + column + 1;
+        //qDebug() << "QAccessibleTree::indexOfChild r " << row << " c " << column << "index " << index;
+        Q_ASSERT(index > treeView->model()->columnCount());
+        return index;
+    } else if (iface->role(0) == QAccessible::ColumnHeader){
+        const QAccessibleTable2HeaderCell* cell = static_cast<const QAccessibleTable2HeaderCell*>(iface);
+        //qDebug() << "QAccessibleTree::indexOfChild header " << cell->index << "is: " << cell->index + 1;
+        return cell->index + 1;
+    } else {
+        qWarning() << "WARNING QAccessibleTable2::indexOfChild invalid child"
+                   << iface->role(0) << iface->text(QAccessible::Name, 0);
+    }
+    // FIXME: add scrollbars and don't just ignore them
+    return -1;
+}
+
+int QAccessibleTree::navigate(RelationFlag relation, int index, QAccessibleInterface **iface) const
+{
+    switch (relation) {
+    case QAccessible::Child: {
+        Q_ASSERT(index > 0);
+        --index;
+        int hHeader = horizontalHeader() ? 1 : 0;
+
+        if (hHeader) {
+            if (index < view->model()->columnCount()) {
+                *iface = new QAccessibleTable2HeaderCell(view, index, Qt::Horizontal);
+                return 0;
+            } else {
+                index -= view->model()->columnCount();
+            }
+        }
+
+        int row = index / view->model()->columnCount();
+        int column = index % view->model()->columnCount();
+        QModelIndex modelIndex = indexFromLogical(row, column);
+        if (modelIndex.isValid()) {
+            *iface = cell(modelIndex);
+            return 0;
+        }
+        return -1;
+    }
+    default:
+        break;
+    }
+    return QAccessibleTable2::navigate(relation, index, iface);
+}
+
+QAccessible::Relation QAccessibleTree::relationTo(int, const QAccessibleInterface *, int) const
+{
+    return QAccessible::Unrelated;
+}
+
+QAccessibleTable2CellInterface *QAccessibleTree::cellAt(int row, int column) const
+{
+    QModelIndex index = indexFromLogical(row, column);
+    if (!index.isValid()) {
+        qWarning() << "Requested invalid tree cell: " << row << column;
+        return 0;
+    }
+    return new QAccessibleTable2Cell(view, index, cellRole());
+}
+
+QString QAccessibleTree::rowDescription(int) const
+{
+    return QString(); // no headers for rows in trees
+}
+
+bool QAccessibleTree::isRowSelected(int row) const
+{
+    QModelIndex index = indexFromLogical(row);
+    return view->selectionModel()->isRowSelected(index.row(), index.parent());
+}
+
+bool QAccessibleTree::selectRow(int row)
+{
+    QModelIndex index = indexFromLogical(row);
+    if (!index.isValid() || view->selectionMode() & QAbstractItemView::NoSelection)
+        return false;
+    view->selectionModel()->select(index, QItemSelectionModel::Select);
+    return true;
+}
+
+// TABLE CELL
+
+QAccessibleTable2Cell::QAccessibleTable2Cell(QAbstractItemView *view_, const QModelIndex &index_, QAccessible::Role role_)
+    : /* QAccessibleSimpleEditableTextInterface(this), */ view(view_), m_index(index_), m_role(role_)
+{
+    Q_ASSERT(index_.isValid());
+}
+
+int QAccessibleTable2Cell::columnExtent() const { return 1; }
+int QAccessibleTable2Cell::rowExtent() const { return 1; }
+
+QList<QAccessibleInterface*> QAccessibleTable2Cell::rowHeaderCells() const
+{
+    QList<QAccessibleInterface*> headerCell;
+    if (verticalHeader()) {
+        headerCell.append(new QAccessibleTable2HeaderCell(view, m_index.row(), Qt::Vertical));
+    }
+    return headerCell;
+}
+
+QList<QAccessibleInterface*> QAccessibleTable2Cell::columnHeaderCells() const
+{
+    QList<QAccessibleInterface*> headerCell;
+    if (horizontalHeader()) {
+        headerCell.append(new QAccessibleTable2HeaderCell(view, m_index.column(), Qt::Horizontal));
+    }
+    return headerCell;
+}
+
+QHeaderView *QAccessibleTable2Cell::horizontalHeader() const
+{
+    QHeaderView *header = 0;
+
+    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 *QAccessibleTable2Cell::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 QAccessibleTable2Cell::columnIndex() const
+{
+    return m_index.column();
+}
+
+int QAccessibleTable2Cell::rowIndex() const
+{
+    if (role(0) == QAccessible::TreeItem) {
+       const QTreeView *treeView = qobject_cast<const QTreeView*>(view);
+       Q_ASSERT(treeView);
+       int row = treeView->d_func()->viewIndex(m_index);
+       return row;
+    }
+    return m_index.row();
+}
+
+bool QAccessibleTable2Cell::isSelected() const
+{
+    return view->selectionModel()->isSelected(m_index);
+}
+
+void QAccessibleTable2Cell::rowColumnExtents(int *row, int *column, int *rowExtents, int *columnExtents, bool *selected) const
+{
+    *row = m_index.row();
+    *column = m_index.column();
+    *rowExtents = 1;
+    *columnExtents = 1;
+    *selected = isSelected();
+}
+
+QAccessibleTable2Interface* QAccessibleTable2Cell::table() const
+{
+    return QAccessible::queryAccessibleInterface(view)->table2Interface();
+}
+
+QAccessible::Role QAccessibleTable2Cell::role(int child) const
+{
+    Q_ASSERT(child == 0);
+    return m_role;
+}
+
+QAccessible::State QAccessibleTable2Cell::state(int child) const
+{
+    Q_ASSERT(child == 0);
+    State st = Normal;
+
+    QRect globalRect = view->rect();
+    globalRect.translate(view->mapToGlobal(QPoint(0,0)));
+    if (!globalRect.intersects(rect(0)))
+        st |= Invisible;
+
+    if (view->selectionModel()->isSelected(m_index))
+        st |= Selected;
+    if (view->selectionModel()->currentIndex() == m_index)
+        st |= Focused;
+    if (m_index.model()->data(m_index, Qt::CheckStateRole).toInt() == Qt::Checked)
+        st |= Checked;
+
+    Qt::ItemFlags flags = m_index.flags();
+    if (flags & Qt::ItemIsSelectable) {
+        st |= Selectable;
+        st |= Focusable;
+        if (view->selectionMode() == QAbstractItemView::MultiSelection)
+            st |= MultiSelectable;
+        if (view->selectionMode() == QAbstractItemView::ExtendedSelection)
+            st |= ExtSelectable;
+    }
+    if (m_role == QAccessible::TreeItem) {
+        const QTreeView *treeView = qobject_cast<const QTreeView*>(view);
+        if (treeView->isExpanded(m_index))
+            st |= Expanded;
+    }
+    return st;
+}
+
+bool QAccessibleTable2Cell::isExpandable() const
+{
+    return view->model()->hasChildren(m_index);
+}
+
+QRect QAccessibleTable2Cell::rect(int child) const
+{
+    Q_ASSERT(child == 0);
+
+    QRect r;
+    r = view->visualRect(m_index);
+
+    if (!r.isNull())
+        r.translate(view->viewport()->mapTo(view, QPoint(0,0)));
+        r.translate(view->mapToGlobal(QPoint(0, 0)));
+    return r;
+}
+
+QString QAccessibleTable2Cell::text(Text t, int child) const
+{
+    Q_ASSERT(child == 0);
+    QAbstractItemModel *model = view->model();
+    QString value;
+    switch (t) {
+    case QAccessible::Value:
+    case QAccessible::Name:
+        value = model->data(m_index, Qt::AccessibleTextRole).toString();
+        if (value.isEmpty())
+            value = model->data(m_index, Qt::DisplayRole).toString();
+        break;
+    case QAccessible::Description:
+        value = model->data(m_index, Qt::AccessibleDescriptionRole).toString();
+        break;
+    default:
+        break;
+    }
+    return value;
+}
+
+void QAccessibleTable2Cell::setText(Text /*t*/, int child, const QString &text)
+{
+    Q_ASSERT(child == 0);
+    if (!m_index.flags() & Qt::ItemIsEditable)
+        return;
+    view->model()->setData(m_index, text);
+}
+
+bool QAccessibleTable2Cell::isValid() const
+{
+    if (!m_index.isValid()) {
+        qDebug() << "Interface is not valid";
+    }
+
+    return m_index.isValid();
+}
+
+int QAccessibleTable2Cell::navigate(RelationFlag relation, int index, QAccessibleInterface **iface) const
+{
+    if (relation == Ancestor && index == 1) {
+        if (m_role == QAccessible::TreeItem) {
+            *iface = new QAccessibleTree(view);
+        } else {
+            *iface = new QAccessibleTable2(view);
+        }
+        return 0;
+    }
+
+    *iface = 0;
+    if (!view)
+        return -1;
+
+    switch (relation) {
+
+    case Child: {
+        return -1;
+    }
+    case Sibling:
+        if (index > 0) {
+            QAccessibleInterface *parent = queryAccessibleInterface(view);
+            int ret = parent->navigate(QAccessible::Child, index, iface);
+            delete parent;
+            if (*iface)
+                return ret;
+        }
+        return -1;
+
+// From table1 implementation:
+//    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
+//        view->setUpdatesEnabled(false);
+//        const QModelIndex oldIdx = view->currentIndex();
+//        QList<QModelIndex> kids = children();
+//        const QModelIndex currentIndex = index ? kids.at(index - 1) : QModelIndex(row);
+//        const QItemSelection oldSelection = view->selectionModel()->selection();
+//        view->setCurrentIndex(currentIndex);
+//        const QModelIndex idx = view->moveCursor(toCursorAction(relation), Qt::NoModifier);
+//        view->setCurrentIndex(oldIdx);
+//        view->selectionModel()->select(oldSelection, QItemSelectionModel::ClearAndSelect);
+//        view->setUpdatesEnabled(true);
+//        if (!idx.isValid())
+//            return -1;
+
+//        if (idx.parent() != row.parent() || idx.row() != row.row())
+//            *iface = cell(idx);
+//        return index ? kids.indexOf(idx) + 1 : 0; }
+    default:
+        break;
+    }
+
+    return -1;
+}
+
+QAccessible::Relation QAccessibleTable2Cell::relationTo(int child, const QAccessibleInterface *other, int otherChild) const
+{
+    Q_ASSERT(child == 0);
+    Q_ASSERT(otherChild == 0);
+    // we only check for parent-child relationships in trees
+    if (m_role == QAccessible::TreeItem && other->role(0) == QAccessible::TreeItem) {
+        QModelIndex otherIndex = static_cast<const QAccessibleTable2Cell*>(other)->m_index;
+        // is the other our parent?
+        if (otherIndex.parent() == m_index)
+            return QAccessible::Ancestor;
+        // are we the other's child?
+        if (m_index.parent() == otherIndex)
+            return QAccessible::Child;
+    }
+    return QAccessible::Unrelated;
+}
+
+#ifndef QT_NO_ACTION
+int QAccessibleTable2Cell::userActionCount(int) const
+{
+    return 0;
+}
+
+QString QAccessibleTable2Cell::actionText(int, Text, int) const
+{
+    return QString();
+}
+
+bool QAccessibleTable2Cell::doAction(int, int, const QVariantList &)
+{
+    return false;
+}
+
+QAccessibleTable2HeaderCell::QAccessibleTable2HeaderCell(QAbstractItemView *view_, int index_, Qt::Orientation orientation_)
+    : view(view_), index(index_), orientation(orientation_)
+{
+    Q_ASSERT(index_ >= 0);
+}
+
+QAccessible::Role QAccessibleTable2HeaderCell::role(int child) const
+{
+    Q_ASSERT(child == 0);
+    if (orientation == Qt::Horizontal)
+        return QAccessible::ColumnHeader;
+    return QAccessible::RowHeader;
+}
+
+QAccessible::State QAccessibleTable2HeaderCell::state(int child) const
+{
+    Q_ASSERT(child == 0);
+    return QAccessible::Normal;
+}
+
+QRect QAccessibleTable2HeaderCell::rect(int child) const
+{
+    Q_ASSERT(child == 0);
+
+    QHeaderView *header = 0;
+    if (false) {
+#ifndef QT_NO_TABLEVIEW
+    } else if (const QTableView *tv = qobject_cast<const QTableView*>(view)) {
+        if (orientation == Qt::Horizontal) {
+            header = tv->horizontalHeader();
+        } else {
+            header = tv->verticalHeader();
+        }
+#endif
+#ifndef QT_NO_TREEVIEW
+    } else if (const QTreeView *tv = qobject_cast<const QTreeView*>(view)) {
+        header = tv->header();
+#endif
+    }
+    QPoint zero = header->mapToGlobal(QPoint(0, 0));
+    int sectionSize = header->sectionSize(index);
+    int sectionPos = header->sectionPosition(index);
+    return orientation == Qt::Horizontal
+            ? QRect(zero.x() + sectionPos, zero.y(), sectionSize, header->height())
+            : QRect(zero.x(), zero.y() + sectionPos, header->width(), sectionSize);
+}
+
+QString QAccessibleTable2HeaderCell::text(Text t, int child) const
+{
+    Q_ASSERT(child == 0);
+    QAbstractItemModel *model = view->model();
+    QString value;
+    switch (t) {
+    case QAccessible::Value:
+    case QAccessible::Name:
+        value = model->headerData(index, orientation, Qt::AccessibleTextRole).toString();
+        if (value.isEmpty())
+            value = model->headerData(index, orientation, Qt::DisplayRole).toString();
+        break;
+    case QAccessible::Description:
+        value = model->headerData(index, orientation, Qt::AccessibleDescriptionRole).toString();
+        break;
+    default:
+        break;
+    }
+    return value;
+}
+
+void QAccessibleTable2HeaderCell::setText(Text, int, const QString &)
+{
+    return;
+}
+
+bool QAccessibleTable2HeaderCell::isValid() const
+{
+    return true;
+}
+
+int QAccessibleTable2HeaderCell::navigate(RelationFlag relation, int index, QAccessibleInterface **iface) const
+{
+    if (relation == QAccessible::Ancestor && index == 1) {
+        if (false) {
+#ifndef QT_NO_TREEVIEW
+        } else if (qobject_cast<const QTreeView*>(view)) {
+            *iface = new QAccessibleTree(view);
+            return 0;
+#endif
+        } else {
+            *iface = new QAccessibleTable2(view);
+            return 0;
+        }
+    }
+    *iface = 0;
+    return -1;
+}
+
+QAccessible::Relation QAccessibleTable2HeaderCell::relationTo(int, const QAccessibleInterface *, int) const
+{
+    return QAccessible::Unrelated;
+}
+
+#ifndef QT_NO_ACTION
+int QAccessibleTable2HeaderCell::userActionCount(int) const
+{
+    return 0;
+}
+
+QString QAccessibleTable2HeaderCell::actionText(int, Text, int) const
+{
+    return QString();
+}
+
+bool QAccessibleTable2HeaderCell::doAction(int, int, const QVariantList &)
+{
+    return false;
+}
+#endif
+
+
+
+#endif
+
+#endif // QT_NO_ITEMVIEWS
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_ACCESSIBILITY
diff --git a/src/plugins/accessible/widgets/itemviews.h b/src/plugins/accessible/widgets/itemviews.h
new file mode 100644
index 0000000..c8492e3
--- /dev/null
+++ b/src/plugins/accessible/widgets/itemviews.h
@@ -0,0 +1,319 @@
+/****************************************************************************
+**
+** 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$
+** GNU Lesser General Public License Usage
+** 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.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU General
+** Public License version 3.0 as published by the Free Software Foundation
+** and appearing in the file LICENSE.GPL included in the packaging of this
+** file. Please review the following information to ensure the GNU General
+** Public License version 3.0 requirements will be met:
+** http://www.gnu.org/copyleft/gpl.html.
+**
+** Other Usage
+** Alternatively, this file may be used in accordance with the terms and
+** conditions contained in a signed written agreement between you and Nokia.
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef ACCESSIBLE_ITEMVIEWS_H
+#define ACCESSIBLE_ITEMVIEWS_H
+
+#include <QtGui/qabstractitemview.h>
+#include <QtGui/qheaderview.h>
+#include <QtGui/qaccessible.h>
+#include <QtGui/qaccessible2.h>
+#include <QtGui/qaccessiblewidget.h>
+
+
+QT_BEGIN_NAMESPACE
+
+#ifndef QT_NO_ACCESSIBILITY
+
+#ifndef QT_NO_ITEMVIEWS
+
+class QAccessibleTable2Cell;
+class QAccessibleTable2HeaderCell;
+
+class QAccessibleTable2: public QAccessibleTable2Interface, public QAccessibleObjectEx
+{
+    Q_ACCESSIBLE_OBJECT
+public:
+    explicit QAccessibleTable2(QWidget *w);
+
+    virtual ~QAccessibleTable2();
+
+    QObject *object() const { return view; }
+    Role role(int child) const;
+    State state(int child) const;
+    QString text(Text t, int child) const;
+    QRect rect(int child) const;
+
+    int childAt(int x, int y) const;
+    int childCount() const;
+    int indexOfChild(const QAccessibleInterface *) const;
+
+    int navigate(RelationFlag relation, int index, QAccessibleInterface **iface) const;
+    Relation relationTo(int child, const QAccessibleInterface *other, int otherChild) const;
+
+#ifndef QT_NO_ACTION
+    int userActionCount(int child) const;
+    QString actionText(int action, Text t, int child) const;
+    bool doAction(int action, int child, const QVariantList &params);
+#endif
+    QVariant invokeMethodEx(Method, int, const QVariantList &) { return QVariant(); }
+
+    // table2 interface
+    virtual QAccessibleTable2CellInterface *cellAt(int row, int column) const;
+    virtual QAccessibleInterface *caption() const;
+    virtual QAccessibleInterface *summary() const;
+    virtual QString columnDescription(int column) const;
+    virtual QString rowDescription(int row) const;
+    virtual int columnCount() const;
+    virtual int rowCount() const;
+    virtual QAccessible2::TableModelChange modelChange() const;
+
+    // selection
+    virtual int selectedCellCount() const;
+    virtual int selectedColumnCount() const;
+    virtual int selectedRowCount() const;
+    virtual QList<QAccessibleTable2CellInterface*> selectedCells() const;
+    virtual QList<int> selectedColumns() const;
+    virtual QList<int> selectedRows() const;
+    virtual bool isColumnSelected(int column) const;
+    virtual bool isRowSelected(int row) const;
+    virtual bool selectRow(int row);
+    virtual bool selectColumn(int column);
+    virtual bool unselectRow(int row);
+    virtual bool unselectColumn(int column);
+
+protected:
+    virtual void modelReset();
+    virtual void rowsInserted(const QModelIndex &parent, int first, int last);
+    virtual void rowsRemoved(const QModelIndex &parent, int first, int last);
+    virtual void columnsInserted(const QModelIndex &parent, int first, int last);
+    virtual void columnsRemoved(const QModelIndex &parent, int first, int last);
+    virtual void rowsMoved( const QModelIndex &parent, int start, int end, const QModelIndex &destination, int row);
+    virtual void columnsMoved( const QModelIndex &parent, int start, int end, const QModelIndex &destination, int column);
+
+protected:
+    QAbstractItemView* view;
+    QAccessible2::TableModelChange lastChange;
+    inline QAccessibleTable2Cell *cell(const QModelIndex &index) const;
+    inline QAccessible::Role cellRole() const {
+        switch (m_role) {
+        case QAccessible::List:
+            return QAccessible::ListItem;
+        case QAccessible::Table:
+            return QAccessible::Cell;
+        case QAccessible::Tree:
+            return QAccessible::TreeItem;
+        default:
+            Q_ASSERT(0);
+        }
+        return QAccessible::NoRole;
+    }
+
+    QHeaderView *horizontalHeader() const;
+    QHeaderView *verticalHeader() const;
+private:
+    // the child index for a model index
+    inline int logicalIndex(const QModelIndex &index) const;
+    // the model index from the child index
+    QAccessibleInterface *childFromLogical(int logicalIndex) const;
+    QAccessible::Role m_role;
+};
+
+class QAccessibleTree :public QAccessibleTable2
+{
+public:
+    explicit QAccessibleTree(QWidget *w)
+        : QAccessibleTable2(w)
+    {}
+
+    virtual ~QAccessibleTree() {}
+
+    int childAt(int x, int y) const;
+    int childCount() const;
+    int indexOfChild(const QAccessibleInterface *) const;
+
+    int rowCount() const;
+
+    int navigate(RelationFlag relation, int index, QAccessibleInterface **iface) const;
+    Relation relationTo(int child, const QAccessibleInterface *other, int otherChild) const;
+
+    // table2 interface
+    QAccessibleTable2CellInterface *cellAt(int row, int column) const;
+    QString rowDescription(int row) const;
+    bool isRowSelected(int row) const;
+    bool selectRow(int row);
+
+private:
+    QModelIndex indexFromLogical(int row, int column = 0) const;
+};
+
+class QAccessibleTable2Cell: public QAccessibleTable2CellInterface /*), public QAccessibleTextInterface, public QAccessibleSimpleEditableTextInterface*/
+{
+public:
+    QAccessibleTable2Cell(QAbstractItemView *view, const QModelIndex &m_index, QAccessible::Role role);
+
+    QObject *object() const { return 0; }
+    Role role(int child) const;
+    State state(int child) const;
+    QRect rect(int child) const;
+    bool isValid() const;
+
+    int childAt(int, int) const { return 0; }
+    int childCount() const { return 0; }
+    int indexOfChild(const QAccessibleInterface *) const  { return -1; }
+
+    QString text(Text t, int child) const;
+    void setText(Text t, int child, const QString &text);
+
+    int navigate(RelationFlag relation, int m_index, QAccessibleInterface **iface) const;
+    Relation relationTo(int child, const QAccessibleInterface *other, int otherChild) const;
+
+    bool isExpandable() const;
+
+#ifndef QT_NO_ACTION
+    int userActionCount(int child) const;
+    QString actionText(int action, Text t, int child) const;
+    bool doAction(int action, int child, const QVariantList &params);
+#endif
+
+    // cell interface
+    virtual int columnExtent() const;
+    virtual QList<QAccessibleInterface*> columnHeaderCells() const;
+    virtual int columnIndex() const;
+    virtual int rowExtent() const;
+    virtual QList<QAccessibleInterface*> rowHeaderCells() const;
+    virtual int rowIndex() const;
+    virtual bool isSelected() const;
+    virtual void rowColumnExtents(int *row, int *column, int *rowExtents, int *columnExtents, bool *selected) const;
+    virtual QAccessibleTable2Interface* table() const;
+
+private:
+    QHeaderView *verticalHeader() const;
+    QHeaderView *horizontalHeader() const;
+    QAbstractItemView *view;
+    QModelIndex m_index;
+    QAccessible::Role m_role;
+
+friend class QAccessibleTable2;
+friend class QAccessibleTree;
+};
+
+
+class QAccessibleTable2HeaderCell: public QAccessibleInterface /*), public QAccessibleTextInterface, public QAccessibleSimpleEditableTextInterface*/
+{
+public:
+    // For header cells, pass the header view in addition
+    QAccessibleTable2HeaderCell(QAbstractItemView *view, int index, Qt::Orientation orientation);
+
+    QObject *object() const { return 0; }
+    Role role(int child) const;
+    State state(int child) const;
+    QRect rect(int child) const;
+    bool isValid() const;
+
+    int childAt(int, int) const { return 0; }
+    int childCount() const { return 0; }
+    int indexOfChild(const QAccessibleInterface *) const  { return -1; }
+
+    QString text(Text t, int child) const;
+    void setText(Text t, int child, const QString &text);
+
+    int navigate(RelationFlag relation, int index, QAccessibleInterface **iface) const;
+    Relation relationTo(int child, const QAccessibleInterface *other, int otherChild) const;
+
+#ifndef QT_NO_ACTION
+    int userActionCount(int child) const;
+    QString actionText(int action, Text t, int child) const;
+    bool doAction(int action, int child, const QVariantList &params);
+#endif
+
+private:
+    QAbstractItemView *view;
+    int index;
+    Qt::Orientation orientation;
+
+friend class QAccessibleTable2;
+friend class QAccessibleTree;
+};
+
+// This is the corner button on the top left of a table.
+// It can be used to select all cells or it is not active at all.
+// For now it is ignored.
+class QAccessibleTable2CornerButton: public QAccessibleInterface
+{
+public:
+    QAccessibleTable2CornerButton(QAbstractItemView *view_)
+        :view(view_)
+    {}
+
+    QObject *object() const { return 0; }
+    Role role(int child) const { Q_ASSERT(child == 0); return QAccessible::Pane; }
+    State state(int child) const { Q_ASSERT(child == 0); return QAccessible::Normal; }
+    QRect rect(int child) const { Q_ASSERT(child == 0); return QRect(); }
+    bool isValid() const { return true; }
+
+    int childAt(int, int) const { return 0; }
+    int childCount() const { return 0; }
+    int indexOfChild(const QAccessibleInterface *) const  { return -1; }
+
+    QString text(Text, int) const { return QString(); }
+    void setText(Text, int, const QString &) {}
+
+    int navigate(RelationFlag relation, int index, QAccessibleInterface **iface) const
+    {
+        if (relation == QAccessible::Ancestor && index == 1) {
+            *iface = QAccessible::queryAccessibleInterface(view);
+            return 0;
+        }
+        return -1;
+    }
+    Relation relationTo(int, const QAccessibleInterface *, int) const
+    {
+        return QAccessible::Unrelated;
+    }
+
+#ifndef QT_NO_ACTION
+    int userActionCount(int) const { return 0; }
+    QString actionText(int, Text, int) const { return QString(); }
+    bool doAction(int, int, const QVariantList &) { return false; }
+#endif
+private:
+    QAbstractItemView *view;
+};
+
+
+#endif
+
+#endif // QT_NO_ACCESSIBILITY
+
+QT_END_NAMESPACE
+
+#endif // ACCESSIBLE_ITEMVIEWS_H
diff --git a/src/plugins/accessible/widgets/main.cpp b/src/plugins/accessible/widgets/main.cpp
index aa5459c..cd17a6e 100644
--- a/src/plugins/accessible/widgets/main.cpp
+++ b/src/plugins/accessible/widgets/main.cpp
@@ -44,11 +44,13 @@
 #include "simplewidgets.h"
 #include "rangecontrols.h"
 #include "complexwidgets.h"
+#include "itemviews.h"
 
 #include <qaccessibleplugin.h>
 #include <qplugin.h>
 #include <qpushbutton.h>
 #include <qtoolbutton.h>
+#include <qtreeview.h>
 #include <qvariant.h>
 #include <qaccessible.h>
 
@@ -56,6 +58,7 @@
 
 QT_BEGIN_NAMESPACE
 
+
 class AccessibleFactory : public QAccessiblePlugin
 {
 public:
@@ -251,6 +254,22 @@ QAccessibleInterface *AccessibleFactory::create(const QString &classname, QObjec
         iface = new QAccessibleMenu(widget);
 #endif
 #ifndef QT_NO_ITEMVIEWS
+#ifdef Q_WS_X11
+    } else if (classname == QLatin1String("QAbstractItemView")) {
+        if (qobject_cast<const QTreeView*>(widget)) {
+            iface = new QAccessibleTree(widget);
+        } else {
+            iface = new QAccessibleTable2(widget);
+        }
+    } else if (classname == QLatin1String("QWidget")
+               && widget->objectName() == QLatin1String("qt_scrollarea_viewport")
+               && qobject_cast<QAbstractItemView*>(widget->parentWidget())) {
+        if (qobject_cast<const QTreeView*>(widget->parentWidget())) {
+            iface = new QAccessibleTree(widget->parentWidget());
+        } else {
+            iface = new QAccessibleTable2(widget->parentWidget());
+        }
+#else
     } else if (classname == QLatin1String("QHeaderView")) {
         iface = new QAccessibleHeader(widget);
     } else if (classname == QLatin1String("QAbstractItemView")) {
@@ -259,7 +278,8 @@ QAccessibleInterface *AccessibleFactory::create(const QString &classname, QObjec
                && widget->objectName() == QLatin1String("qt_scrollarea_viewport")
                && qobject_cast<QAbstractItemView*>(widget->parentWidget())) {
         iface = new QAccessibleItemView(widget);
-#endif
+#endif // Q_WS_X11
+#endif // QT_NO_ITEMVIEWS
 #ifndef QT_NO_TABBAR
     } else if (classname == QLatin1String("QTabBar")) {
         iface = new QAccessibleTabBar(widget);
diff --git a/src/plugins/accessible/widgets/widgets.pro b/src/plugins/accessible/widgets/widgets.pro
index 79110cb..9632f41 100644
--- a/src/plugins/accessible/widgets/widgets.pro
+++ b/src/plugins/accessible/widgets/widgets.pro
@@ -7,14 +7,18 @@ QTDIR_build:DESTDIR  = $$QT_BUILD_TREE/plugins/accessible
 QTDIR_build:REQUIRES += "contains(QT_CONFIG, accessibility)"
 
 SOURCES  += main.cpp \
-	    simplewidgets.cpp \
-	    rangecontrols.cpp \
-	    complexwidgets.cpp \
-	    qaccessiblewidgets.cpp \
-	    qaccessiblemenu.cpp
+            simplewidgets.cpp \
+            rangecontrols.cpp \
+            complexwidgets.cpp \
+            qaccessiblewidgets.cpp \
+            qaccessiblemenu.cpp \
+            itemviews.cpp
 
 HEADERS  += qaccessiblewidgets.h \
-	    simplewidgets.h \
-	    rangecontrols.h \
-	    complexwidgets.h \
-	    qaccessiblemenu.h
+            simplewidgets.h \
+            rangecontrols.h \
+            complexwidgets.h \
+            qaccessiblemenu.h \
+            itemviews.h
+
+