1 /****************************************************************************

     2 **

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

     4 ** All rights reserved.

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

     6 **

     7 ** This file is part of the plugins of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 #include "complexwidgets.h"

    43 

    44 #include <qapplication.h>

    45 #include <qabstractbutton.h>

    46 #include <qevent.h>

    47 #include <qheaderview.h>

    48 #include <qtabbar.h>

    49 #include <qcombobox.h>

    50 #include <qlistview.h>

    51 #include <qtableview.h>

    52 #include <qlineedit.h>

    53 #include <qstyle.h>

    54 #include <qstyleoption.h>

    55 #include <qtooltip.h>

    56 #include <qwhatsthis.h>

    57 #include <qtreeview.h>

    58 #include <private/qtabbar_p.h>

    59 #include <QAbstractScrollArea>

    60 #include <QScrollArea>

    61 #include <QScrollBar>

    62 #include <QDebug>

    63 

    64 #ifndef QT_NO_ACCESSIBILITY

    65 

    66 QT_BEGIN_NAMESPACE

    67 

    68 QString Q_GUI_EXPORT qt_accStripAmp(const QString &text);

    69 

    70 #ifndef QT_NO_ITEMVIEWS

    71 /*

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

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

    74 Basically, the model is like this:

    75 

    76 ROLE_SYSTEM_TABLE

    77   |- ROLE_SYSTEM_ROW

    78   |  |- ROLE_SYSTEM_ROWHEADER

    79   |  |- ROLE_SYSTEM_COLUMNHEADER

    80   |  |- ROLE_SYSTEM_COLUMNHEADER

    81   |  |- ROLE_SYSTEM_COLUMNHEADER

    82   |     '- ..

    83   |- ROLE_SYSTEM_ROW

    84   |  |- ROLE_SYSTEM_ROWHEADER

    85   |  |- ROLE_SYSTEM_CELL

    86   |  |- ROLE_SYSTEM_CELL

    87   |  |- ROLE_SYSTEM_CELL

    88   |   '- ..

    89   |- ROLE_SYSTEM_ROW

    90   |  |- ROLE_SYSTEM_ROWHEADER

    91   |  |- ROLE_SYSTEM_CELL

    92   |  |- ROLE_SYSTEM_CELL

    93   |  |- ROLE_SYSTEM_CELL

    94   |   '- ..

    95    '- ..

    96 

    97 The headers of QTreeView is also represented like this.

    98 */

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

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

   101 {

   102 }

   103 

   104 QHeaderView *QAccessibleItemRow::horizontalHeader() const

   105 {

   106     QHeaderView *header = 0;

   107     if (m_header) {

   108         if (false) {

   109 #ifndef QT_NO_TABLEVIEW

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

   111             header = tv->horizontalHeader();

   112 #endif

   113 #ifndef QT_NO_TREEVIEW

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

   115             header = tv->header();

   116 #endif

   117         }

   118     }

   119     return header;

   120 }

   121 

   122 QHeaderView *QAccessibleItemRow::verticalHeader() const

   123 {

   124     QHeaderView *header = 0;

   125 #ifndef QT_NO_TABLEVIEW

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

   127         header = tv->verticalHeader();

   128 #endif

   129     return header;

   130 }

   131 

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

   133 {

   134     int logical = -1;

   135     if (header->sectionsHidden()) {

   136         int kid = 0;

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

   138             if (!header->isSectionHidden(i))

   139                 ++kid;

   140             if (kid == child) {

   141                 logical = i;

   142                 break;

   143             }

   144         }

   145     } else {

   146         logical = child - 1;

   147     }

   148     return logical;

   149 }

   150 

   151 QRect QAccessibleItemRow::rect(int child) const

   152 {

   153     QRect r;

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

   155         if (QHeaderView *header = horizontalHeader()) {

   156             if (!child) {

   157                 r = header->rect();

   158             } else {

   159                 if (QHeaderView *vheader = verticalHeader()) {

   160                     if (child == 1) {

   161                         int w = vheader->width();

   162                         int h = header->height();

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

   164                     }

   165                     --child;

   166                 }

   167                 if (child) {

   168                     int logical = logicalFromChild(header, child);

   169                     int w = header->sectionSize(logical);

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

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

   172                 }

   173             }

   174         } else if (row.isValid()) {

   175             if (!child) {

   176                 QModelIndex parent = row.parent();

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

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

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

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

   181 

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

   183                     QRect re;

   184                     int logicalRow = row.row();

   185                     int h = vheader->sectionSize(logicalRow);

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

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

   188                     r |= re;

   189                 }

   190             } else {

   191                 if (QHeaderView *vheader = verticalHeader()) {

   192                     if (child == 1) {

   193                         int logicalRow = row.row();

   194                         int h = vheader->sectionSize(logicalRow);

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

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

   197                     }

   198                     --child;

   199                 }

   200                 if (child) {

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

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

   203                 }

   204             }

   205         }

   206     }

   207     if (!r.isNull())

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

   209 

   210     return r;

   211 }

   212 

   213 int QAccessibleItemRow::treeLevel() const

   214 {

   215     int level = 0;

   216     QModelIndex idx = row;

   217     while (idx.isValid()) {

   218         idx = idx.parent();

   219         ++level;

   220     }

   221     return level;

   222 }

   223 

   224 QString QAccessibleItemRow::text_helper(int child) const

   225 {

   226     QString value;

   227     if (m_header) {

   228         if (!child)

   229             return QString();

   230         if (verticalHeader()) {

   231             if (child == 1)

   232                 return QString();

   233             --child;

   234         }

   235         QHeaderView *header = horizontalHeader();

   236         int logical = logicalFromChild(header, child);

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

   238         if (value.isEmpty())

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

   240         return value;

   241     } else {

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

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

   244                 child = 1;

   245             else

   246                 return QString();

   247         }

   248         if (verticalHeader()) {

   249             if (child == 1) {

   250                 int logical = row.row();

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

   252                 if (value.isEmpty())

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

   254                 return value;

   255             } else {

   256                 --child;

   257             }

   258         }

   259     }

   260     if (value.isEmpty()) {

   261         QModelIndex idx = childIndex(child);

   262         if (idx.isValid()) {

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

   264             if (value.isEmpty())

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

   266         }

   267     }

   268     return value;

   269 }

   270 

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

   272 {

   273     QString value;

   274     if (t == Name) {

   275         value = text_helper(child);

   276     } else if (t == Value) {

   277 #ifndef QT_NO_TREEVIEW

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

   279             if (child == 0)

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

   281         } else

   282 #endif

   283         {

   284             value = text_helper(child);

   285         }

   286     } else if (t == Description) {

   287 #ifndef QT_NO_TREEVIEW

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

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

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

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

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

   293             // "L2": Tree Level 2

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

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

   296 

   297             // level

   298             int level = treeLevel();

   299 

   300             QAbstractItemModel *m = view->model();

   301             // totalSiblings and itemIndex

   302             QModelIndex parent = row.parent();

   303             int rowCount = m->rowCount(parent);

   304             int itemIndex = -1;

   305             int totalSiblings = 0;

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

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

   308                 if (!view->isIndexHidden(sibling))

   309                     ++totalSiblings;

   310                 if (row == sibling)

   311                     itemIndex = totalSiblings;

   312             }

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

   314                                                     // this simple and efficient.

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

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

   317         } else

   318 #endif // QT_NO_TREEVIEW

   319         {

   320             if (!m_header) {

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

   322                     child = 1;

   323                 if (verticalHeader()) {

   324                     if (child == 1) {

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

   326                     }

   327                     --child;

   328                 }

   329                 if (child) {

   330                     QModelIndex idx = childIndex(child);

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

   332                 }

   333 

   334             }

   335         }

   336     }

   337     return value;

   338 }

   339 

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

   341 {

   342     if (m_header) {

   343         if (child)

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

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

   346     } else {

   347         if (!child) {

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

   349                 child = 1;

   350             else

   351                 return;

   352         }

   353 

   354         if (verticalHeader()) {

   355             if (child == 1) {

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

   357                 return;

   358             }

   359             --child;

   360         }

   361         QModelIndex idx = childIndex(child);

   362         if (!idx.isValid())

   363             return;

   364 

   365         switch (t) {

   366         case Description:

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

   368                                              Qt::AccessibleDescriptionRole);

   369             break;

   370         case Value:

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

   372             break;

   373         default:

   374             break;

   375         }

   376     }

   377 }

   378 

   379 QModelIndex QAccessibleItemRow::childIndex(int child) const

   380 {

   381     QList<QModelIndex> kids = children();

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

   383     return kids.at(child - 1);

   384 }

   385 

   386 QList<QModelIndex> QAccessibleItemRow::children() const

   387 {

   388     QList<QModelIndex> kids;

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

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

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

   392             kids << idx;

   393         }

   394     }

   395     return kids;

   396 }

   397 

   398 bool QAccessibleItemRow::isValid() const

   399 {

   400     return m_header ? true : row.isValid();

   401 }

   402 

   403 QObject *QAccessibleItemRow::object() const

   404 {

   405     return 0;

   406 }

   407 

   408 int QAccessibleItemRow::childCount() const

   409 {

   410     int count = 0;

   411     if (QHeaderView *header = horizontalHeader()) {

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

   413     } else {

   414         count = children().count();

   415     }

   416 #ifndef QT_NO_TABLEVIEW

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

   418         if (verticalHeader())

   419             ++count;

   420     }

   421 #endif

   422     return count;

   423 }

   424 

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

   426 {

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

   428         return -1;

   429 

   430     //### meaningless code?

   431     QList<QModelIndex> kids = children();

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

   433     if (!idx.isValid())

   434         return -1;

   435     return kids.indexOf(idx) + 1;

   436 }

   437 

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

   439         int otherChild) const

   440 {

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

   442         return Child;

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

   444         return Self;

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

   446         return Ancestor;

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

   448         return Sibling;

   449     return Unrelated;

   450 }

   451 

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

   453 {

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

   455         return -1;

   456 

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

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

   459             return i;

   460     }

   461     return -1;

   462 }

   463 

   464 QAbstractItemView::CursorAction QAccessibleItemRow::toCursorAction(

   465                                            QAccessible::Relation rel)

   466 {

   467     switch (rel) {

   468     case QAccessible::Up:

   469         return QAbstractItemView::MoveUp;

   470     case QAccessible::Down:

   471         return QAbstractItemView::MoveDown;

   472     case QAccessible::Left:

   473         return QAbstractItemView::MoveLeft;

   474     case QAccessible::Right:

   475         return QAbstractItemView::MoveRight;

   476     default:

   477         Q_ASSERT(false);

   478     }

   479     // should never be reached.

   480     return QAbstractItemView::MoveRight;

   481 }

   482 

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

   484                                  QAccessibleInterface **iface) const

   485 {

   486     *iface = 0;

   487     if (!view)

   488         return -1;

   489 

   490     switch (relation) {

   491     case Ancestor: {

   492         if (!index)

   493             return -1;

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

   495         if (index == 1) {

   496             *iface = ancestor;

   497             return 0;

   498         } else if (index > 1) {

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

   500             delete ancestor;

   501             return ret;

   502         }

   503         }

   504     case Child: {

   505         if (!index)

   506             return -1;

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

   508             return -1;

   509 

   510         return index;}

   511     case Sibling:

   512         if (index) {

   513             QAccessibleInterface *ifaceParent = 0;

   514             navigate(Ancestor, 1, &ifaceParent);

   515             if (ifaceParent) {

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

   517                 delete ifaceParent;

   518                 return entry;

   519             }

   520         }

   521         return -1;

   522     case Up:

   523     case Down:

   524     case Left:

   525     case Right: {

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

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

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

   529         view->setUpdatesEnabled(false);

   530         const QModelIndex oldIdx = view->currentIndex();

   531         QList<QModelIndex> kids = children();

   532         const QModelIndex currentIndex = index ? kids.at(index - 1) : QModelIndex(row);

   533         const QItemSelection oldSelection = view->selectionModel()->selection();

   534         view->setCurrentIndex(currentIndex);

   535         const QModelIndex idx = view->moveCursor(toCursorAction(relation), Qt::NoModifier);

   536         view->setCurrentIndex(oldIdx);

   537         view->selectionModel()->select(oldSelection, QItemSelectionModel::ClearAndSelect);

   538         view->setUpdatesEnabled(true);

   539         if (!idx.isValid())

   540             return -1;

   541 

   542         if (idx.parent() != row.parent() || idx.row() != row.row())

   543             *iface = new QAccessibleItemRow(view, idx);

   544         return index ? kids.indexOf(idx) + 1 : 0; }

   545     default:

   546         break;

   547     }

   548 

   549     return -1;

   550 }

   551 

   552 QAccessible::Role QAccessibleItemRow::role(int child) const

   553 {

   554     if (false) {

   555 #ifndef QT_NO_TREEVIEW

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

   557         if (horizontalHeader()) {

   558             if (!child)

   559                 return Row;

   560             return ColumnHeader;

   561         }

   562         return TreeItem;

   563 #endif

   564 #ifndef QT_NO_LISTVIEW

   565     } else if (qobject_cast<const QListView*>(view)) {

   566         return ListItem;

   567 #endif

   568 #ifndef QT_NO_TABLEVIEW

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

   570         if (!child)

   571             return Row;

   572         if (child == 1) {

   573             if (verticalHeader())

   574                 return RowHeader;

   575         }

   576         if (m_header)

   577             return ColumnHeader;

   578 #endif

   579     }

   580     return Cell;

   581 }

   582 

   583 QAccessible::State QAccessibleItemRow::state(int child) const

   584 {

   585     State st = Normal;

   586 

   587     if (!view)

   588         return st;

   589 

   590     QAccessibleInterface *parent = 0;

   591     QRect globalRect;

   592     if (navigate(Ancestor, 1, &parent) == 0) {

   593         globalRect = parent->rect(0);

   594         delete parent;

   595     }

   596     if (!globalRect.intersects(rect(child)))

   597         st |= Invisible;

   598 

   599     if (!horizontalHeader()) {

   600         if (!(st & Invisible)) {

   601             if (child) {

   602                 if (QHeaderView *vheader = verticalHeader() ) {

   603                     if (child == 1) {

   604                         if (!vheader->isVisible())

   605                             st |= Invisible;

   606                     }

   607                     --child;

   608                 }

   609                 if (child) {

   610                     QModelIndex idx = childIndex(child);

   611                     if (!idx.isValid())

   612                         return st;

   613 

   614                     if (view->selectionModel()->isSelected(idx))

   615                         st |= Selected;

   616                     if (view->selectionModel()->currentIndex() == idx)

   617                         st |= Focused;

   618                     if (idx.model()->data(idx, Qt::CheckStateRole).toInt() == Qt::Checked)

   619                         st |= Checked;

   620 

   621                     Qt::ItemFlags flags = idx.flags();

   622                     if (flags & Qt::ItemIsSelectable) {

   623                         st |= Selectable;

   624                         if (view->selectionMode() == QAbstractItemView::MultiSelection)

   625                             st |= MultiSelectable;

   626                         if (view->selectionMode() == QAbstractItemView::ExtendedSelection)

   627                             st |= ExtSelectable;

   628                     }

   629                 }

   630             } else {

   631                 Qt::ItemFlags flags = row.flags();

   632                 if (flags & Qt::ItemIsSelectable) {

   633                     st |= Selectable;

   634                     st |= Focusable;

   635                 }

   636                 if (view->selectionModel()->isRowSelected(row.row(), row.parent()))

   637                     st |= Selected;

   638                 if (view->selectionModel()->currentIndex().row() == row.row())

   639                     st |= Focused;

   640             }

   641         }

   642     }

   643 

   644     return st;

   645 }

   646 

   647 int QAccessibleItemRow::userActionCount(int) const

   648 {

   649     return 0;

   650 }

   651 

   652 QString QAccessibleItemRow::actionText(int, Text, int) const

   653 {

   654     return QString();

   655 }

   656 

   657 static QItemSelection rowAt(const QModelIndex &idx)

   658 {

   659     return QItemSelection(idx.sibling(idx.row(), 0),

   660                 idx.sibling(idx.row(), idx.model()->columnCount(idx.parent())));

   661 }

   662 

   663 bool QAccessibleItemRow::doAction(int action, int child, const QVariantList & /*params*/)

   664 {

   665     if (!view)

   666         return false;

   667 

   668     if (verticalHeader())

   669         --child;

   670 

   671     QModelIndex idx = child ? childIndex(child) : QModelIndex(row);

   672     if (!idx.isValid())

   673         return false;

   674 

   675     QItemSelectionModel::SelectionFlags command = QItemSelectionModel::NoUpdate;

   676 

   677     switch  (action) {

   678     case SetFocus:

   679         view->setCurrentIndex(idx);

   680         return true;

   681     case ExtendSelection:

   682         if (!child)

   683             return false;

   684         view->selectionModel()->select(QItemSelection(view->currentIndex(), idx),

   685                     QItemSelectionModel::SelectCurrent);

   686         return true;

   687     case Select:

   688         command = QItemSelectionModel::ClearAndSelect;

   689         break;

   690     case ClearSelection:

   691         command = QItemSelectionModel::Clear;

   692         break;

   693     case RemoveSelection:

   694         command = QItemSelectionModel::Deselect;

   695         break;

   696     case AddToSelection:

   697         command = QItemSelectionModel::SelectCurrent;

   698         break;

   699     }

   700     if (command == QItemSelectionModel::NoUpdate)

   701         return false;

   702 

   703     if (child)

   704         view->selectionModel()->select(idx, command);

   705     else

   706         view->selectionModel()->select(rowAt(row), command);

   707     return true;

   708 }

   709 

   710 class ModelIndexIterator

   711 {

   712 public:

   713     ModelIndexIterator(QAbstractItemView *view, const QModelIndex &start = QModelIndex()) : m_view(view)

   714     {

   715 #ifndef QT_NO_LISTVIEW

   716         list = qobject_cast<QListView*>(m_view);

   717 #endif

   718 #ifndef QT_NO_TREEVIEW

   719         tree = qobject_cast<QTreeView*>(m_view);

   720 #endif

   721 #ifndef QT_NO_TABLEVIEW

   722         table = qobject_cast<QTableView*>(m_view);

   723 #endif

   724         if (start.isValid()) {

   725             m_current = start;

   726         } else if (m_view && m_view->model()) {

   727             m_current = view->model()->index(0, 0);

   728         }

   729     }

   730 

   731     bool next(int count = 1) {

   732         for (int i = 0; i < count; ++i) {

   733             do {

   734                 if (m_current.isValid()) {

   735                     const QAbstractItemModel *m = m_current.model();

   736 #ifndef QT_NO_TREEVIEW

   737                     if (tree && m_current.model()->hasChildren(m_current) && tree->isExpanded(m_current)) {

   738                         m_current = m_current.child(0, 0);

   739                     } else

   740 #endif

   741                     {

   742                         int row = m_current.row();

   743                         QModelIndex par = m_current.parent();

   744                         

   745                         // Go up to the parent if we reach the end of the rows

   746                         // If m_curent becomses invalid, stop going up.

   747                         while (row + 1 >= m->rowCount(par)) {

   748                             m_current = par;

   749                             if (m_current.isValid()) {

   750                                 row = m_current.row();

   751                                 par = m_current.parent();

   752                             } else {

   753                                 row = 0;

   754                                 par = QModelIndex();

   755                                 break;

   756                             }

   757                         }

   758 

   759                         if (m_current.isValid())

   760                             m_current = m_current.sibling(row + 1, 0);

   761                     }

   762                 }

   763             } while (isHidden());

   764         }

   765         return m_current.isValid();

   766     }

   767 

   768     bool isHidden() const {

   769         if (false) {

   770 #ifndef QT_NO_LISTVIEW

   771         } else if (list) {

   772             return list->isRowHidden(m_current.row());

   773 #endif

   774 #ifndef QT_NO_TREEVIEW

   775         } else if (tree) {

   776             return tree->isRowHidden(m_current.row(), m_current.parent());

   777 #endif

   778 #ifndef QT_NO_TABLEVIEW

   779         } else if (table) {

   780             return table->isRowHidden(m_current.row());

   781 #endif

   782         }

   783         return false;

   784     }

   785 

   786     QModelIndex current() const {

   787         return m_current;

   788     }

   789 

   790 private:

   791     QModelIndex m_current;

   792     QAbstractItemView *m_view;

   793 

   794 #ifndef QT_NO_TREEVIEW

   795     QTreeView *tree;

   796 #endif

   797 #ifndef QT_NO_LISTVIEW

   798     QListView *list;

   799 #endif

   800 #ifndef QT_NO_TABLEVIEW

   801     QTableView *table;

   802 #endif

   803 };

   804 

   805 QAccessibleItemView::QAccessibleItemView(QWidget *w)

   806     : QAccessibleAbstractScrollArea(w->objectName() == QLatin1String("qt_scrollarea_viewport") ? w->parentWidget() : w)

   807 {

   808     atVP = w->objectName() == QLatin1String("qt_scrollarea_viewport");

   809 

   810 }

   811 

   812 

   813 QHeaderView *QAccessibleItemView::horizontalHeader() const

   814 {

   815     QHeaderView *header = 0;

   816     if (false) {

   817 #ifndef QT_NO_TABLEVIEW

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

   819         header = tv->horizontalHeader();

   820 #endif

   821 #ifndef QT_NO_TREEVIEW

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

   823         header = tv->header();

   824 #endif

   825     }

   826     return header;

   827 }

   828 

   829 QHeaderView *QAccessibleItemView::verticalHeader() const

   830 {

   831     QHeaderView *header = 0;

   832     if (false) {

   833 #ifndef QT_NO_TABLEVIEW

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

   835         header = tv->verticalHeader();

   836 #endif

   837     }

   838     return header;

   839 }

   840 

   841 

   842 bool QAccessibleItemView::isValidChildRole(QAccessible::Role role) const

   843 {

   844     if (atViewport()) {

   845         if (false) {

   846 #ifndef QT_NO_TREEVIEW

   847         } else if (qobject_cast<const QTreeView*>(itemView())) {

   848             return (role == TreeItem || role == Row);

   849 #endif

   850 #ifndef QT_NO_LISTVIEW

   851         } else if (qobject_cast<const QListView*>(itemView())) {

   852             return (role == ListItem);

   853 #endif

   854         }

   855         // TableView

   856         return role == Row;

   857     } else {

   858         if (false) {

   859 #ifndef QT_NO_TREEVIEW

   860         } else if (qobject_cast<const QTreeView*>(itemView())) {

   861             return (role == Tree);

   862 #endif

   863 #ifndef QT_NO_LISTVIEW

   864         } else if (qobject_cast<const QListView*>(itemView())) {

   865             return (role == List);

   866 #endif

   867         }

   868         // TableView

   869         return (role == Table);

   870     }

   871 }

   872 

   873 QObject *QAccessibleItemView::object() const

   874 {

   875     QObject *view = QAccessibleAbstractScrollArea::object();

   876     Q_ASSERT(qobject_cast<const QAbstractItemView *>(view));

   877     if (atViewport())

   878         view = qobject_cast<const QAbstractItemView *>(view)->viewport();

   879     return view;

   880 }

   881 

   882 QAbstractItemView *QAccessibleItemView::itemView() const

   883 {

   884     return qobject_cast<QAbstractItemView *>(QAccessibleAbstractScrollArea::object());

   885 }

   886 

   887 int QAccessibleItemView::indexOfChild(const QAccessibleInterface *iface) const

   888 {

   889     if (atViewport()) {

   890         if (!iface || !isValidChildRole(iface->role(0)))

   891             return -1;

   892 

   893         int entry = -1;

   894         // ### This will fail if a row is hidden.

   895         const QAccessibleItemRow *ifRow = static_cast<const QAccessibleItemRow *>(iface);

   896         if (ifRow->horizontalHeader())

   897             return 1;

   898 

   899         QModelIndex idx = ifRow->row;

   900         if (!idx.isValid())

   901             return -1;

   902 

   903         entry = entryFromIndex(idx);

   904         if (horizontalHeader())

   905             ++entry;

   906 

   907         return entry;

   908 

   909     } else {

   910         return QAccessibleAbstractScrollArea::indexOfChild(iface);

   911     }

   912 }

   913 

   914 QModelIndex QAccessibleItemView::childIndex(int child) const

   915 {

   916     if (!atViewport())

   917         return QModelIndex();

   918     ModelIndexIterator it(itemView());

   919     it.next(child - 1);

   920     return it.current();

   921 }

   922 

   923 int QAccessibleItemView::entryFromIndex(const QModelIndex &index) const

   924 {

   925     int entry = -1;

   926     if (false) {

   927 #ifndef QT_NO_TREEVIEW

   928     } else if (QTreeView *tree = qobject_cast<QTreeView*>(itemView())) {

   929         entry = tree->visualIndex(index) + 1;

   930 #endif

   931 #ifndef QT_NO_LISTVIEW

   932     } else if (QListView *list = qobject_cast<QListView*>(itemView())) {

   933         entry = list->visualIndex(index) + 1;

   934 #endif

   935 #ifndef QT_NO_TABLEVIEW

   936     } else if (QTableView *table = qobject_cast<QTableView*>(itemView())) {

   937         entry = table->visualIndex(index) + 1;

   938 #endif

   939     }

   940     return entry;

   941 }

   942 

   943 int QAccessibleItemView::childCount() const

   944 {

   945     if (atViewport()) {

   946         if (itemView()->model() == 0)

   947             return 0;

   948         QAbstractItemModel *m = itemView()->model();

   949         QModelIndex idx = m->index(0,0);

   950         if (!idx.isValid())

   951             return 0;

   952         ModelIndexIterator it(itemView());

   953         int count = 1;

   954         while (it.next()) {

   955             ++count;

   956         }

   957         if (horizontalHeader())

   958             ++count;

   959 

   960         return count;

   961     } else {

   962         return QAccessibleAbstractScrollArea::childCount();

   963     }

   964 }

   965 

   966 QString QAccessibleItemView::text(Text t, int child) const

   967 {

   968     if (atViewport()) {

   969         if (!child)

   970             return QAccessibleAbstractScrollArea::text(t, child);

   971 

   972         QAccessibleItemRow item(itemView(), childIndex(child));

   973         return item.text(t, 1);

   974     } else {

   975         return QAccessibleAbstractScrollArea::text(t, child);

   976     }

   977 }

   978 

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

   980 {

   981     if (atViewport()) {

   982         if (!child) {

   983             QAccessibleAbstractScrollArea::setText(t, child, text);

   984             return;

   985         }

   986 

   987         QAccessibleItemRow item(itemView(), childIndex(child));

   988         item.setText(t, 1, text);

   989     } else {

   990         QAccessibleAbstractScrollArea::setText(t, child, text);

   991     }

   992 }

   993 

   994 QRect QAccessibleItemView::rect(int child) const

   995 {

   996     if (atViewport()) {

   997         QRect r;

   998         if (!child) {

   999             // Make sure that the rect *include* the vertical and horizontal headers, while

  1000             // not including the potential vertical and horizontal scrollbars.

  1001             QAbstractItemView *w = itemView();

  1002 

  1003             int vscrollWidth = 0;

  1004             const QScrollBar *sb = w->verticalScrollBar();

  1005             if (sb && sb->isVisible())

  1006                 vscrollWidth = sb->width();

  1007 

  1008             int hscrollHeight = 0;

  1009             sb = w->horizontalScrollBar();

  1010             if (sb && sb->isVisible())

  1011                 hscrollHeight = sb->height();

  1012 

  1013             QPoint globalPos = w->mapToGlobal(QPoint(0,0));

  1014             r = w->rect().translated(globalPos);

  1015             if (w->isRightToLeft()) {

  1016                 r.adjust(vscrollWidth, 0, 0, -hscrollHeight);

  1017             } else {

  1018                 r.adjust(0, 0, -vscrollWidth, -hscrollHeight);

  1019             }

  1020         } else {

  1021             QAccessibleInterface *iface = 0;

  1022             if (navigate(Child, child, &iface) == 0) {

  1023                 r = iface->rect(0);

  1024                 delete iface;

  1025             }

  1026         }

  1027         return r;

  1028     } else {

  1029         QRect r = QAccessibleAbstractScrollArea::rect(child);

  1030         if (child == 1) {

  1031             // include the potential vertical and horizontal headers

  1032 

  1033             const QHeaderView *header = verticalHeader();

  1034             int headerWidth = (header && header->isVisible()) ? header->width() : 0;

  1035             header = horizontalHeader();

  1036             int headerHeight= (header && header->isVisible()) ? header->height() : 0;

  1037             if (itemView()->isRightToLeft()) {

  1038                 r.adjust(0, -headerHeight, headerWidth, 0);

  1039             } else {

  1040                 r.adjust(-headerWidth, -headerHeight, 0, 0);

  1041             }

  1042         }

  1043         return r;

  1044     }

  1045 }

  1046 

  1047 int QAccessibleItemView::childAt(int x, int y) const

  1048 {

  1049     if (atViewport()) {

  1050         QPoint p(x, y);

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

  1052             if (rect(i).contains(p))

  1053                 return i;

  1054         }

  1055         return -1;

  1056     } else {

  1057         return QAccessibleAbstractScrollArea::childAt(x, y);

  1058     }

  1059 }

  1060 

  1061 QAccessible::Role QAccessibleItemView::role(int child) const

  1062 {

  1063     if ((!atViewport() && child) || (atViewport() && child == 0)) {

  1064         QAbstractItemView *view = itemView();

  1065 #ifndef QT_NO_TABLEVIEW

  1066         if (qobject_cast<QTableView *>(view))

  1067             return Table;

  1068 #endif

  1069 #ifndef QT_NO_LISTVIEW

  1070         if (qobject_cast<QListView *>(view))

  1071             return List;

  1072 #endif

  1073         return Tree;

  1074     }

  1075     if (atViewport()) {

  1076         if (child)

  1077             return Row;

  1078     }

  1079 

  1080     return QAccessibleAbstractScrollArea::role(child);

  1081 }

  1082 

  1083 QAccessible::State QAccessibleItemView::state(int child) const

  1084 {

  1085     State st = Normal;

  1086 

  1087     if (itemView() == 0)

  1088         return State(Unavailable);

  1089 

  1090     bool queryViewPort = (atViewport() && child == 0) || (!atViewport() && child == 1);

  1091     if (queryViewPort) {

  1092         if (itemView()->selectionMode() != QAbstractItemView::NoSelection) {

  1093             st |= Selectable;

  1094             st |= Focusable;

  1095         }

  1096     } else if (atViewport()) {    // children of viewport

  1097         if (horizontalHeader())

  1098             --child;

  1099         if (child) {

  1100             QAccessibleItemRow item(itemView(), childIndex(child));

  1101             st |= item.state(0);

  1102         }

  1103     } else if (!atViewport() && child != 1) {

  1104         st = QAccessibleAbstractScrollArea::state(child);

  1105     }

  1106     return st;

  1107 }

  1108 

  1109 bool QAccessibleItemView::isValid() const

  1110 {

  1111     if (atViewport())

  1112         return QAccessibleWidgetEx::isValid();

  1113     else

  1114         return QAccessibleAbstractScrollArea::isValid();

  1115 }

  1116 

  1117 int QAccessibleItemView::navigate(RelationFlag relation, int index,

  1118                                   QAccessibleInterface **iface) const

  1119 {

  1120     if (atViewport()) {

  1121         if (relation == Ancestor && index == 1) {

  1122             *iface = new QAccessibleItemView(itemView());

  1123             return 0;

  1124         } else if (relation == Child && index >= 1) {

  1125             if (horizontalHeader()) {

  1126                 if (index == 1) {

  1127                     *iface = new QAccessibleItemRow(itemView(), QModelIndex(), true);

  1128                     return 0;

  1129                 }

  1130                 --index;

  1131             }

  1132 

  1133             //###JAS hidden rows..

  1134             QModelIndex idx = childIndex(index);