vcl/qt5/QtAccessibleWidget.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <QtAccessibleWidget.hxx>
  21 #include <QtAccessibleWidget.moc>
  22
  23 #include <QtGui/QAccessibleInterface>
  24
  25 #include <QtAccessibleEventListener.hxx>
  26 #include <QtFrame.hxx>
  27 #include <QtTools.hxx>
  28 #include <QtWidget.hxx>
  29 #include <QtXAccessible.hxx>
  30
  31 #include <com/sun/star/accessibility/AccessibleRelationType.hpp>
  32 #include <com/sun/star/accessibility/AccessibleRole.hpp>
  33 #include <com/sun/star/accessibility/AccessibleScrollType.hpp>
  34 #include <com/sun/star/accessibility/AccessibleStateType.hpp>
  35 #include <com/sun/star/accessibility/AccessibleTextType.hpp>
  36 #include <com/sun/star/accessibility/XAccessible.hpp>
  37 #include <com/sun/star/accessibility/XAccessibleAction.hpp>
  38 #include <com/sun/star/accessibility/XAccessibleComponent.hpp>
  39 #include <com/sun/star/accessibility/XAccessibleEditableText.hpp>
  40 #include <com/sun/star/accessibility/XAccessibleEventBroadcaster.hpp>
  41 #include <com/sun/star/accessibility/XAccessibleEventListener.hpp>
  42 #include <com/sun/star/accessibility/XAccessibleKeyBinding.hpp>
  43 #include <com/sun/star/accessibility/XAccessibleRelationSet.hpp>
  44 #include <com/sun/star/accessibility/XAccessibleStateSet.hpp>
  45 #include <com/sun/star/accessibility/XAccessibleTable.hpp>
  46 #include <com/sun/star/accessibility/XAccessibleTableSelection.hpp>
  47 #include <com/sun/star/accessibility/XAccessibleText.hpp>
  48 #include <com/sun/star/accessibility/XAccessibleValue.hpp>
  49 #include <com/sun/star/awt/FontWeight.hpp>
  50 #include <com/sun/star/beans/PropertyValue.hpp>
  51 #include <com/sun/star/lang/DisposedException.hpp>
  52 #include <com/sun/star/uno/Sequence.hxx>
  53
  54 #include <comphelper/AccessibleImplementationHelper.hxx>
  55 #include <o3tl/any.hxx>
  56 #include <sal/log.hxx>
  57
  58 using namespace css;
  59 using namespace css::accessibility;
  60 using namespace css::beans;
  61 using namespace css::uno;
  62
  63 QtAccessibleWidget::QtAccessibleWidget(const Reference<XAccessible> xAccessible, QObject* pObject)
  64     : m_xAccessible(xAccessible)
  65     , m_pObject(pObject)
  66 {
  67     Reference<XAccessibleContext> xContext = xAccessible->getAccessibleContext();
  68     Reference<XAccessibleEventBroadcaster> xBroadcaster(xContext, UNO_QUERY);
  69     if (xBroadcaster.is())
  70     {
  71         Reference<XAccessibleEventListener> xListener(
  72             new QtAccessibleEventListener(xAccessible, this));
  73         xBroadcaster->addAccessibleEventListener(xListener);
  74     }
  75 }
  76
  77 Reference<XAccessibleContext> QtAccessibleWidget::getAccessibleContextImpl() const
  78 {
  79     Reference<XAccessibleContext> xAc;
  80
  81     if (m_xAccessible.is())
  82     {
  83         try
  84         {
  85             xAc = m_xAccessible->getAccessibleContext();
  86         }
  87         catch (css::lang::DisposedException /*ex*/)
  88         {
  89             SAL_WARN("vcl.qt", "Accessible context disposed already");
  90         }
  91         // sometimes getAccessibleContext throws also RuntimeException if context is no longer alive
  92         catch (css::uno::RuntimeException /*ex*/)
  93         {
  94             // so let's catch it here, cuz otherwise soffice falls flat on its face
  95             // with FatalError and nothing else
  96             SAL_WARN("vcl.qt", "Accessible context no longer alive");
  97         }
  98     }
  99
 100     return xAc;
 101 }
 102
 103 css::uno::Reference<css::accessibility::XAccessibleTable>
 104 QtAccessibleWidget::getAccessibleTableForParent() const
 105 {
 106     Reference<XAccessibleContext> xAcc = getAccessibleContextImpl();
 107     if (!xAcc.is())
 108         return nullptr;
 109
 110     Reference<XAccessible> xParent = xAcc->getAccessibleParent();
 111     if (!xParent.is())
 112         return nullptr;
 113
 114     Reference<XAccessibleContext> xParentContext = xParent->getAccessibleContext();
 115     if (!xParentContext.is())
 116         return nullptr;
 117
 118     return Reference<XAccessibleTable>(xParentContext, UNO_QUERY);
 119 }
 120
 121 QWindow* QtAccessibleWidget::window() const { return nullptr; }
 122
 123 int QtAccessibleWidget::childCount() const
 124 {
 125     Reference<XAccessibleContext> xAc = getAccessibleContextImpl();
 126     if (!xAc.is())
 127         return 0;
 128
 129     return xAc->getAccessibleChildCount();
 130 }
 131
 132 int QtAccessibleWidget::indexOfChild(const QAccessibleInterface* /* child */) const { return 0; }
 133
 134 namespace
 135 {
 136 sal_Int16 lcl_matchQtTextBoundaryType(QAccessible::TextBoundaryType boundaryType)
 137 {
 138     switch (boundaryType)
 139     {
 140         case QAccessible::CharBoundary:
 141             return com::sun::star::accessibility::AccessibleTextType::CHARACTER;
 142         case QAccessible::WordBoundary:
 143             return com::sun::star::accessibility::AccessibleTextType::WORD;
 144         case QAccessible::SentenceBoundary:
 145             return com::sun::star::accessibility::AccessibleTextType::SENTENCE;
 146         case QAccessible::ParagraphBoundary:
 147             return com::sun::star::accessibility::AccessibleTextType::PARAGRAPH;
 148         case QAccessible::LineBoundary:
 149             return com::sun::star::accessibility::AccessibleTextType::LINE;
 150         case QAccessible::NoBoundary:
 151             // assert here, better handle it directly at call site
 152             assert(false
 153                    && "No match for QAccessible::NoBoundary, handle it separately at call site.");
 154             break;
 155         default:
 156             break;
 157     }
 158
 159     SAL_WARN("vcl.qt", "Unmatched text boundary type: " << boundaryType);
 160     return -1;
 161 }
 162
 163 QAccessible::Relation lcl_matchUnoRelation(short relationType)
 164 {
 165     switch (relationType)
 166     {
 167         case AccessibleRelationType::CONTROLLER_FOR:
 168             return QAccessible::Controller;
 169         case AccessibleRelationType::CONTROLLED_BY:
 170             return QAccessible::Controlled;
 171         case AccessibleRelationType::LABEL_FOR:
 172             return QAccessible::Label;
 173         case AccessibleRelationType::LABELED_BY:
 174             return QAccessible::Labelled;
 175         case AccessibleRelationType::INVALID:
 176         case AccessibleRelationType::CONTENT_FLOWS_FROM:
 177         case AccessibleRelationType::CONTENT_FLOWS_TO:
 178         case AccessibleRelationType::MEMBER_OF:
 179         case AccessibleRelationType::SUB_WINDOW_OF:
 180         case AccessibleRelationType::NODE_CHILD_OF:
 181         case AccessibleRelationType::DESCRIBED_BY:
 182         default:
 183             SAL_WARN("vcl.qt", "Unmatched relation: " << relationType);
 184             return {};
 185     }
 186 }
 187
 188 short lcl_matchQtRelation(QAccessible::Relation relationType)
 189 {
 190     switch (relationType)
 191     {
 192         case QAccessible::Controller:
 193             return AccessibleRelationType::CONTROLLER_FOR;
 194         case QAccessible::Controlled:
 195             return AccessibleRelationType::CONTROLLED_BY;
 196         case QAccessible::Label:
 197             return AccessibleRelationType::LABEL_FOR;
 198         case QAccessible::Labelled:
 199             return AccessibleRelationType::LABELED_BY;
 200         default:
 201             SAL_WARN("vcl.qt", "Unmatched relation: " << relationType);
 202     }
 203     return 0;
 204 }
 205
 206 void lcl_appendRelation(QVector<QPair<QAccessibleInterface*, QAccessible::Relation>>* relations,
 207                         AccessibleRelation aRelation)
 208 {
 209     QAccessible::Relation aQRelation = lcl_matchUnoRelation(aRelation.RelationType);
 210     sal_uInt32 nTargetCount = aRelation.TargetSet.getLength();
 211
 212     for (sal_uInt32 i = 0; i < nTargetCount; i++)
 213     {
 214         Reference<XAccessible> xAccessible(aRelation.TargetSet[i], uno::UNO_QUERY);
 215         relations->append(
 216             { QAccessible::queryAccessibleInterface(new QtXAccessible(xAccessible)), aQRelation });
 217     }
 218 }
 219 }
 220
 221 QVector<QPair<QAccessibleInterface*, QAccessible::Relation>>
 222 QtAccessibleWidget::relations(QAccessible::Relation match) const
 223 {
 224     QVector<QPair<QAccessibleInterface*, QAccessible::Relation>> relations;
 225
 226     Reference<XAccessibleContext> xAc = getAccessibleContextImpl();
 227     if (!xAc.is())
 228         return relations;
 229
 230     Reference<XAccessibleRelationSet> xRelationSet = xAc->getAccessibleRelationSet();
 231     if (xRelationSet.is())
 232     {
 233         if (match == QAccessible::AllRelations)
 234         {
 235             int count = xRelationSet->getRelationCount();
 236             for (int i = 0; i < count; i++)
 237             {
 238                 AccessibleRelation aRelation = xRelationSet->getRelation(i);
 239                 lcl_appendRelation(&relations, aRelation);
 240             }
 241         }
 242         else
 243         {
 244             AccessibleRelation aRelation = xRelationSet->getRelation(lcl_matchQtRelation(match));
 245             lcl_appendRelation(&relations, aRelation);
 246         }
 247     }
 248
 249     return relations;
 250 }
 251
 252 QAccessibleInterface* QtAccessibleWidget::focusChild() const
 253 {
 254     /* if (m_pWindow->HasChildPathFocus())
 255         return QAccessible::queryAccessibleInterface(
 256             new QtXAccessible(m_xAccessible->getAccessibleContext()->getAccessibleChild(index))); */
 257     return QAccessible::queryAccessibleInterface(object());
 258 }
 259
 260 QRect QtAccessibleWidget::rect() const
 261 {
 262     Reference<XAccessibleContext> xAc = getAccessibleContextImpl();
 263     if (!xAc.is())
 264         return QRect();
 265
 266     Reference<XAccessibleComponent> xAccessibleComponent(xAc, UNO_QUERY);
 267     awt::Point aPoint = xAccessibleComponent->getLocation();
 268     awt::Size aSize = xAccessibleComponent->getSize();
 269
 270     return QRect(aPoint.X, aPoint.Y, aSize.Width, aSize.Height);
 271 }
 272
 273 QAccessibleInterface* QtAccessibleWidget::parent() const
 274 {
 275     Reference<XAccessibleContext> xAc = getAccessibleContextImpl();
 276     if (!xAc.is())
 277         return nullptr;
 278
 279     return QAccessible::queryAccessibleInterface(new QtXAccessible(xAc->getAccessibleParent()));
 280 }
 281 QAccessibleInterface* QtAccessibleWidget::child(int index) const
 282 {
 283     Reference<XAccessibleContext> xAc = getAccessibleContextImpl();
 284     if (!xAc.is())
 285         return nullptr;
 286
 287     return QAccessible::queryAccessibleInterface(new QtXAccessible(xAc->getAccessibleChild(index)));
 288 }
 289
 290 QString QtAccessibleWidget::text(QAccessible::Text text) const
 291 {
 292     Reference<XAccessibleContext> xAc = getAccessibleContextImpl();
 293     if (!xAc.is())
 294         return QString();
 295
 296     switch (text)
 297     {
 298         case QAccessible::Name:
 299             return toQString(xAc->getAccessibleName());
 300         case QAccessible::Description:
 301         case QAccessible::DebugDescription:
 302             return toQString(xAc->getAccessibleDescription());
 303         case QAccessible::Value:
 304         case QAccessible::Help:
 305         case QAccessible::Accelerator:
 306         case QAccessible::UserText:
 307         default:
 308             return QString("Unknown");
 309     }
 310 }
 311 QAccessible::Role QtAccessibleWidget::role() const
 312 {
 313     Reference<XAccessibleContext> xAc = getAccessibleContextImpl();
 314     if (!xAc.is())
 315         return QAccessible::NoRole;
 316
 317     switch (xAc->getAccessibleRole())
 318     {
 319         case AccessibleRole::UNKNOWN:
 320             return QAccessible::NoRole;
 321
 322         case AccessibleRole::ALERT:
 323             return QAccessible::AlertMessage;
 324
 325         case AccessibleRole::COLUMN_HEADER:
 326             return QAccessible::ColumnHeader;
 327
 328         case AccessibleRole::CANVAS:
 329             return QAccessible::Canvas;
 330
 331         case AccessibleRole::CHECK_BOX:
 332             return QAccessible::CheckBox;
 333
 334         case AccessibleRole::CHECK_MENU_ITEM:
 335             return QAccessible::MenuItem;
 336
 337         case AccessibleRole::COLOR_CHOOSER:
 338             return QAccessible::ColorChooser;
 339
 340         case AccessibleRole::COMBO_BOX:
 341             return QAccessible::ComboBox;
 342
 343         case AccessibleRole::DATE_EDITOR:
 344             return QAccessible::EditableText;
 345
 346         case AccessibleRole::DESKTOP_ICON:
 347             return QAccessible::Graphic;
 348
 349         case AccessibleRole::DESKTOP_PANE:
 350         case AccessibleRole::DIRECTORY_PANE:
 351             return QAccessible::Pane;
 352
 353         case AccessibleRole::DIALOG:
 354             return QAccessible::Dialog;
 355
 356         case AccessibleRole::DOCUMENT:
 357             return QAccessible::Document;
 358
 359         case AccessibleRole::EMBEDDED_OBJECT:
 360             return QAccessible::UserRole;
 361
 362         case AccessibleRole::END_NOTE:
 363             return QAccessible::Note;
 364
 365         case AccessibleRole::FILLER:
 366             return QAccessible::Whitespace;
 367
 368         case AccessibleRole::FONT_CHOOSER:
 369             return QAccessible::UserRole;
 370
 371         case AccessibleRole::FOOTER:
 372             return QAccessible::Footer;
 373
 374         case AccessibleRole::FOOTNOTE:
 375             return QAccessible::Note;
 376
 377         case AccessibleRole::FRAME: // top-level window with title bar
 378             return QAccessible::Window;
 379
 380         case AccessibleRole::GLASS_PANE:
 381             return QAccessible::UserRole;
 382
 383         case AccessibleRole::GRAPHIC:
 384             return QAccessible::Graphic;
 385
 386         case AccessibleRole::GROUP_BOX:
 387             return QAccessible::Grouping;
 388
 389         case AccessibleRole::HEADER:
 390             return QAccessible::UserRole;
 391
 392         case AccessibleRole::HEADING:
 393             return QAccessible::Heading;
 394
 395         case AccessibleRole::HYPER_LINK:
 396             return QAccessible::Link;
 397
 398         case AccessibleRole::ICON:
 399             return QAccessible::Graphic;
 400
 401         case AccessibleRole::INTERNAL_FRAME:
 402             return QAccessible::UserRole;
 403
 404         case AccessibleRole::LABEL:
 405             return QAccessible::StaticText;
 406
 407         case AccessibleRole::LAYERED_PANE:
 408             return QAccessible::Pane;
 409
 410         case AccessibleRole::LIST:
 411             return QAccessible::List;
 412
 413         case AccessibleRole::LIST_ITEM:
 414             return QAccessible::ListItem;
 415
 416         case AccessibleRole::MENU:
 417         case AccessibleRole::MENU_BAR:
 418             return QAccessible::MenuBar;
 419
 420         case AccessibleRole::MENU_ITEM:
 421             return QAccessible::MenuItem;
 422
 423         case AccessibleRole::OPTION_PANE:
 424             return QAccessible::Pane;
 425
 426         case AccessibleRole::PAGE_TAB:
 427             return QAccessible::PageTab;
 428
 429         case AccessibleRole::PAGE_TAB_LIST:
 430             return QAccessible::PageTabList;
 431
 432         case AccessibleRole::PANEL:
 433             return QAccessible::Pane;
 434
 435         case AccessibleRole::PARAGRAPH:
 436             return QAccessible::Paragraph;
 437
 438         case AccessibleRole::PASSWORD_TEXT:
 439             return QAccessible::EditableText;
 440
 441         case AccessibleRole::POPUP_MENU:
 442             return QAccessible::PopupMenu;
 443
 444         case AccessibleRole::PUSH_BUTTON:
 445             return QAccessible::Button;
 446
 447         case AccessibleRole::PROGRESS_BAR:
 448             return QAccessible::ProgressBar;
 449
 450         case AccessibleRole::RADIO_BUTTON:
 451             return QAccessible::RadioButton;
 452
 453         case AccessibleRole::RADIO_MENU_ITEM:
 454             return QAccessible::MenuItem;
 455
 456         case AccessibleRole::ROW_HEADER:
 457             return QAccessible::RowHeader;
 458
 459         case AccessibleRole::ROOT_PANE:
 460             return QAccessible::Pane;
 461
 462         case AccessibleRole::SCROLL_BAR:
 463             return QAccessible::ScrollBar;
 464
 465         case AccessibleRole::SCROLL_PANE:
 466             return QAccessible::Pane;
 467
 468         case AccessibleRole::SHAPE:
 469             return QAccessible::Graphic;
 470
 471         case AccessibleRole::SEPARATOR:
 472             return QAccessible::Separator;
 473
 474         case AccessibleRole::SLIDER:
 475             return QAccessible::Slider;
 476
 477         case AccessibleRole::SPIN_BOX:
 478             return QAccessible::SpinBox;
 479
 480         case AccessibleRole::SPLIT_PANE:
 481             return QAccessible::Pane;
 482
 483         case AccessibleRole::STATUS_BAR:
 484             return QAccessible::StatusBar;
 485
 486         case AccessibleRole::TABLE:
 487             return QAccessible::Table;
 488
 489         case AccessibleRole::TABLE_CELL:
 490             return QAccessible::Cell;
 491
 492         case AccessibleRole::TEXT:
 493             return QAccessible::EditableText;
 494
 495         case AccessibleRole::TEXT_FRAME:
 496             return QAccessible::UserRole;
 497
 498         case AccessibleRole::TOGGLE_BUTTON:
 499             return QAccessible::Button;
 500
 501         case AccessibleRole::TOOL_BAR:
 502             return QAccessible::ToolBar;
 503
 504         case AccessibleRole::TOOL_TIP:
 505             return QAccessible::ToolTip;
 506
 507         case AccessibleRole::TREE:
 508             return QAccessible::Tree;
 509
 510         case AccessibleRole::VIEW_PORT:
 511             return QAccessible::UserRole;
 512
 513         case AccessibleRole::BUTTON_DROPDOWN:
 514             return QAccessible::Button;
 515
 516         case AccessibleRole::BUTTON_MENU:
 517             return QAccessible::Button;
 518
 519         case AccessibleRole::CAPTION:
 520             return QAccessible::StaticText;
 521
 522         case AccessibleRole::CHART:
 523             return QAccessible::Chart;
 524
 525         case AccessibleRole::EDIT_BAR:
 526             return QAccessible::Equation;
 527
 528         case AccessibleRole::FORM:
 529             return QAccessible::Form;
 530
 531         case AccessibleRole::IMAGE_MAP:
 532             return QAccessible::Graphic;
 533
 534         case AccessibleRole::NOTE:
 535             return QAccessible::Note;
 536
 537         case AccessibleRole::RULER:
 538             return QAccessible::UserRole;
 539
 540         case AccessibleRole::SECTION:
 541             return QAccessible::Section;
 542
 543         case AccessibleRole::TREE_ITEM:
 544             return QAccessible::TreeItem;
 545
 546         case AccessibleRole::TREE_TABLE:
 547             return QAccessible::Tree;
 548
 549         case AccessibleRole::COMMENT:
 550             return QAccessible::Note;
 551
 552         case AccessibleRole::COMMENT_END:
 553             return QAccessible::UserRole;
 554
 555         case AccessibleRole::DOCUMENT_PRESENTATION:
 556             return QAccessible::Document;
 557
 558         case AccessibleRole::DOCUMENT_SPREADSHEET:
 559             return QAccessible::Document;
 560
 561         case AccessibleRole::DOCUMENT_TEXT:
 562             return QAccessible::Document;
 563
 564         case AccessibleRole::STATIC:
 565             return QAccessible::StaticText;
 566
 567         /* Ignore window objects for sub-menus, combo- and list boxes,
 568          *  which are exposed as children of their parents.
 569          */
 570         case AccessibleRole::WINDOW: // top-level window without title bar
 571         {
 572             return QAccessible::Window;
 573         }
 574     }
 575
 576     SAL_WARN("vcl.qt", "Unmapped role: " << getAccessibleContextImpl()->getAccessibleRole());
 577     return QAccessible::NoRole;
 578 }
 579
 580 namespace
 581 {
 582 void lcl_addState(QAccessible::State* state, sal_Int16 nState)
 583 {
 584     switch (nState)
 585     {
 586         case AccessibleStateType::INVALID:
 587             state->invalid = true;
 588             break;
 589         case AccessibleStateType::ACTIVE:
 590             state->active = true;
 591             break;
 592         case AccessibleStateType::ARMED:
 593             // No match
 594             break;
 595         case AccessibleStateType::BUSY:
 596             state->busy = true;
 597             break;
 598         case AccessibleStateType::CHECKED:
 599             state->checked = true;
 600             break;
 601         case AccessibleStateType::EDITABLE:
 602             state->editable = true;
 603             break;
 604         case AccessibleStateType::ENABLED:
 605             state->disabled = false;
 606             break;
 607         case AccessibleStateType::EXPANDABLE:
 608             state->expandable = true;
 609             break;
 610         case AccessibleStateType::EXPANDED:
 611             state->expanded = true;
 612             break;
 613         case AccessibleStateType::FOCUSABLE:
 614             state->focusable = true;
 615             break;
 616         case AccessibleStateType::FOCUSED:
 617             state->focused = true;
 618             break;
 619         case AccessibleStateType::HORIZONTAL:
 620             // No match
 621             break;
 622         case AccessibleStateType::ICONIFIED:
 623             // No match
 624             break;
 625         case AccessibleStateType::INDETERMINATE:
 626             // No match
 627             break;
 628         case AccessibleStateType::MANAGES_DESCENDANTS:
 629             // No match
 630             break;
 631         case AccessibleStateType::MODAL:
 632             state->modal = true;
 633             break;
 634         case AccessibleStateType::MOVEABLE:
 635             state->movable = true;
 636             break;
 637         case AccessibleStateType::MULTI_LINE:
 638             state->multiLine = true;
 639             break;
 640         case AccessibleStateType::OPAQUE:
 641             // No match
 642             break;
 643         case AccessibleStateType::PRESSED:
 644             state->pressed = true;
 645             break;
 646         case AccessibleStateType::RESIZABLE:
 647             state->sizeable = true;
 648             break;
 649         case AccessibleStateType::SELECTABLE:
 650             state->selectable = true;
 651             break;
 652         case AccessibleStateType::SELECTED:
 653             state->selected = true;
 654             break;
 655         case AccessibleStateType::SENSITIVE:
 656             // No match
 657             break;
 658         case AccessibleStateType::SHOWING:
 659             // No match
 660             break;
 661         case AccessibleStateType::SINGLE_LINE:
 662             // No match
 663             break;
 664         case AccessibleStateType::STALE:
 665             // No match
 666             break;
 667         case AccessibleStateType::TRANSIENT:
 668             // No match
 669             break;
 670         case AccessibleStateType::VERTICAL:
 671             // No match
 672             break;
 673         case AccessibleStateType::VISIBLE:
 674             state->invisible = false;
 675             break;
 676         case AccessibleStateType::DEFAULT:
 677             // No match
 678             break;
 679         case AccessibleStateType::DEFUNC:
 680             state->invalid = true;
 681             break;
 682         case AccessibleStateType::MULTI_SELECTABLE:
 683             state->multiSelectable = true;
 684             break;
 685         default:
 686             SAL_WARN("vcl.qt", "Unmapped state: " << nState);
 687             break;
 688     }
 689 }
 690 }
 691
 692 QAccessible::State QtAccessibleWidget::state() const
 693 {
 694     QAccessible::State state;
 695
 696     Reference<XAccessibleContext> xAc = getAccessibleContextImpl();
 697     if (!xAc.is())
 698         return state;
 699
 700     Reference<XAccessibleStateSet> xStateSet(xAc->getAccessibleStateSet());
 701
 702     if (!xStateSet.is())
 703         return state;
 704
 705     const Sequence<sal_Int16> aStates = xStateSet->getStates();
 706
 707     for (const sal_Int16 nState : aStates)
 708     {
 709         lcl_addState(&state, nState);
 710     }
 711
 712     return state;
 713 }
 714
 715 QColor QtAccessibleWidget::foregroundColor() const
 716 {
 717     Reference<XAccessibleContext> xAc = getAccessibleContextImpl();
 718     if (!xAc.is())
 719         return QColor();
 720
 721     Reference<XAccessibleComponent> xAccessibleComponent(xAc, UNO_QUERY);
 722     return toQColor(Color(ColorTransparency, xAccessibleComponent->getForeground()));
 723 }
 724
 725 QColor QtAccessibleWidget::backgroundColor() const
 726 {
 727     Reference<XAccessibleContext> xAc = getAccessibleContextImpl();
 728     if (!xAc.is())
 729         return QColor();
 730
 731     Reference<XAccessibleComponent> xAccessibleComponent(xAc, UNO_QUERY);
 732     return toQColor(Color(ColorTransparency, xAccessibleComponent->getBackground()));
 733 }
 734
 735 void* QtAccessibleWidget::interface_cast(QAccessible::InterfaceType t)
 736 {
 737     if (t == QAccessible::ActionInterface)
 738         return static_cast<QAccessibleActionInterface*>(this);
 739     if (t == QAccessible::TextInterface)
 740         return static_cast<QAccessibleTextInterface*>(this);
 741     if (t == QAccessible::EditableTextInterface)
 742         return static_cast<QAccessibleEditableTextInterface*>(this);
 743     if (t == QAccessible::ValueInterface)
 744         return static_cast<QAccessibleValueInterface*>(this);
 745     if (t == QAccessible::TableCellInterface)
 746         return static_cast<QAccessibleTableCellInterface*>(this);
 747     if (t == QAccessible::TableInterface)
 748         return static_cast<QAccessibleTableInterface*>(this);
 749     return nullptr;
 750 }
 751
 752 bool QtAccessibleWidget::isValid() const
 753 {
 754     Reference<XAccessibleContext> xAc = getAccessibleContextImpl();
 755     return xAc.is();
 756 }
 757
 758 QObject* QtAccessibleWidget::object() const { return m_pObject; }
 759
 760 void QtAccessibleWidget::setText(QAccessible::Text /* t */, const QString& /* text */) {}
 761
 762 QAccessibleInterface* QtAccessibleWidget::childAt(int x, int y) const
 763 {
 764     Reference<XAccessibleContext> xAc = getAccessibleContextImpl();
 765     if (!xAc.is())
 766         return nullptr;
 767
 768     Reference<XAccessibleComponent> xAccessibleComponent(xAc, UNO_QUERY);
 769     return QAccessible::queryAccessibleInterface(
 770         new QtXAccessible(xAccessibleComponent->getAccessibleAtPoint(awt::Point(x, y))));
 771 }
 772
 773 QAccessibleInterface* QtAccessibleWidget::customFactory(const QString& classname, QObject* object)
 774 {
 775     if (classname == QLatin1String("QtWidget") && object && object->isWidgetType())
 776     {
 777         QtWidget* pWidget = static_cast<QtWidget*>(object);
 778         vcl::Window* pWindow = pWidget->frame().GetWindow();
 779
 780         if (pWindow)
 781             return new QtAccessibleWidget(pWindow->GetAccessible(), object);
 782     }
 783     if (classname == QLatin1String("QtXAccessible") && object)
 784     {
 785         QtXAccessible* pXAccessible = dynamic_cast<QtXAccessible*>(object);
 786         if (pXAccessible && pXAccessible->m_xAccessible.is())
 787             return new QtAccessibleWidget(pXAccessible->m_xAccessible, object);
 788     }
 789
 790     return nullptr;
 791 }
 792
 793 // QAccessibleActionInterface
 794 QStringList QtAccessibleWidget::actionNames() const
 795 {
 796     QStringList actionNames;
 797     Reference<XAccessibleAction> xAccessibleAction(getAccessibleContextImpl(), UNO_QUERY);
 798     if (!xAccessibleAction.is())
 799         return actionNames;
 800
 801     int count = xAccessibleAction->getAccessibleActionCount();
 802     for (int i = 0; i < count; i++)
 803     {
 804         OUString desc = xAccessibleAction->getAccessibleActionDescription(i);
 805         actionNames.append(toQString(desc));
 806     }
 807     return actionNames;
 808 }
 809
 810 void QtAccessibleWidget::doAction(const QString& actionName)
 811 {
 812     Reference<XAccessibleAction> xAccessibleAction(getAccessibleContextImpl(), UNO_QUERY);
 813     if (!xAccessibleAction.is())
 814         return;
 815
 816     int index = actionNames().indexOf(actionName);
 817     if (index == -1)
 818         return;
 819     xAccessibleAction->doAccessibleAction(index);
 820 }
 821
 822 QStringList QtAccessibleWidget::keyBindingsForAction(const QString& actionName) const
 823 {
 824     QStringList keyBindings;
 825     Reference<XAccessibleAction> xAccessibleAction(getAccessibleContextImpl(), UNO_QUERY);
 826     if (!xAccessibleAction.is())
 827         return keyBindings;
 828
 829     int index = actionNames().indexOf(actionName);
 830     if (index == -1)
 831         return keyBindings;
 832
 833     Reference<XAccessibleKeyBinding> xKeyBinding
 834         = xAccessibleAction->getAccessibleActionKeyBinding(index);
 835
 836     if (!xKeyBinding.is())
 837         return keyBindings;
 838
 839     int count = xKeyBinding->getAccessibleKeyBindingCount();
 840     for (int i = 0; i < count; i++)
 841     {
 842         Sequence<awt::KeyStroke> keyStroke = xKeyBinding->getAccessibleKeyBinding(i);
 843         keyBindings.append(toQString(comphelper::GetkeyBindingStrByXkeyBinding(keyStroke)));
 844     }
 845     return keyBindings;
 846 }
 847
 848 // QAccessibleTextInterface
 849 void QtAccessibleWidget::addSelection(int /* startOffset */, int /* endOffset */)
 850 {
 851     SAL_INFO("vcl.qt", "Unsupported QAccessibleTextInterface::addSelection");
 852 }
 853
 854 namespace
 855 {
 856 OUString lcl_convertFontWeight(double fontWeight)
 857 {
 858     if (fontWeight == awt::FontWeight::THIN || fontWeight == awt::FontWeight::ULTRALIGHT)
 859         return "100";
 860     if (fontWeight == awt::FontWeight::LIGHT)
 861         return "200";
 862     if (fontWeight == awt::FontWeight::SEMILIGHT)
 863         return "300";
 864     if (fontWeight == awt::FontWeight::NORMAL)
 865         return "normal";
 866     if (fontWeight == awt::FontWeight::SEMIBOLD)
 867         return "500";
 868     if (fontWeight == awt::FontWeight::BOLD)
 869         return "bold";
 870     if (fontWeight == awt::FontWeight::ULTRABOLD)
 871         return "800";
 872     if (fontWeight == awt::FontWeight::BLACK)
 873         return "900";
 874
 875     // awt::FontWeight::DONTKNOW || fontWeight == awt::FontWeight::NORMAL
 876     return "normal";
 877 }
 878 }
 879
 880 QString QtAccessibleWidget::attributes(int offset, int* startOffset, int* endOffset) const
 881 {
 882     if (startOffset == nullptr || endOffset == nullptr)
 883         return QString();
 884
 885     *startOffset = -1;
 886     *endOffset = -1;
 887
 888     Reference<XAccessibleText> xText(getAccessibleContextImpl(), UNO_QUERY);
 889     if (!xText.is())
 890         return QString();
 891
 892     // handle special values for offset the same way base class's QAccessibleTextWidget::attributes does
 893     // (as defined in IAccessible 2: -1 -> length, -2 -> cursor position)
 894     if (offset == -2)
 895         offset = cursorPosition();
 896
 897     const int nTextLength = characterCount();
 898     if (offset == -1 || offset == nTextLength)
 899         offset = nTextLength - 1;
 900
 901     if (offset < 0 || offset > nTextLength)
 902         return QString();
 903
 904     const Sequence<PropertyValue> attribs
 905         = xText->getCharacterAttributes(offset, Sequence<OUString>());
 906     OUString aRet;
 907     for (PropertyValue const& prop : attribs)
 908     {
 909         OUString sAttribute;
 910         OUString sValue;
 911         if (prop.Name == "CharFontName")
 912         {
 913             sAttribute = "font-family";
 914             sValue = *o3tl::doAccess<OUString>(prop.Value);
 915         }
 916         else if (prop.Name == "CharHeight")
 917         {
 918             sAttribute = "font-size";
 919             sValue = OUString::number(*o3tl::doAccess<double>(prop.Value)) + "pt";
 920         }
 921         else if (prop.Name == "CharWeight")
 922         {
 923             sAttribute = "font-weight";
 924             sValue = lcl_convertFontWeight(*o3tl::doAccess<double>(prop.Value));
 925         }
 926
 927         if (!sAttribute.isEmpty() && !sValue.isEmpty())
 928             aRet += sAttribute + ":" + sValue + ";";
 929     }
 930     *startOffset = offset;
 931     *endOffset = offset + 1;
 932     return toQString(aRet);
 933 }
 934
 935 int QtAccessibleWidget::characterCount() const
 936 {
 937     Reference<XAccessibleText> xText(getAccessibleContextImpl(), UNO_QUERY);
 938     if (xText.is())
 939         return xText->getCharacterCount();
 940     return 0;
 941 }
 942 QRect QtAccessibleWidget::characterRect(int /* offset */) const
 943 {
 944     SAL_INFO("vcl.qt", "Unsupported QAccessibleTextInterface::characterRect");
 945     return QRect();
 946 }
 947
 948 int QtAccessibleWidget::cursorPosition() const
 949 {
 950     Reference<XAccessibleText> xText(getAccessibleContextImpl(), UNO_QUERY);
 951     if (xText.is())
 952         return xText->getCaretPosition();
 953     return 0;
 954 }
 955
 956 int QtAccessibleWidget::offsetAtPoint(const QPoint& /* point */) const
 957 {
 958     SAL_INFO("vcl.qt", "Unsupported QAccessibleTextInterface::offsetAtPoint");
 959     return 0;
 960 }
 961 void QtAccessibleWidget::removeSelection(int /* selectionIndex */)
 962 {
 963     SAL_INFO("vcl.qt", "Unsupported QAccessibleTextInterface::removeSelection");
 964 }
 965 void QtAccessibleWidget::scrollToSubstring(int startIndex, int endIndex)
 966 {
 967     Reference<XAccessibleText> xText(getAccessibleContextImpl(), UNO_QUERY);
 968     if (xText.is())
 969         xText->scrollSubstringTo(startIndex, endIndex, AccessibleScrollType_SCROLL_ANYWHERE);
 970 }
 971
 972 void QtAccessibleWidget::selection(int selectionIndex, int* startOffset, int* endOffset) const
 973 {
 974     if (!startOffset && !endOffset)
 975         return;
 976
 977     Reference<XAccessibleText> xText;
 978     if (selectionIndex == 0)
 979         xText = Reference<XAccessibleText>(getAccessibleContextImpl(), UNO_QUERY);
 980
 981     if (startOffset)
 982         *startOffset = xText.is() ? xText->getSelectionStart() : 0;
 983     if (endOffset)
 984         *endOffset = xText.is() ? xText->getSelectionEnd() : 0;
 985 }
 986
 987 int QtAccessibleWidget::selectionCount() const
 988 {
 989     Reference<XAccessibleText> xText(getAccessibleContextImpl(), UNO_QUERY);
 990     if (xText.is() && !xText->getSelectedText().isEmpty())
 991         return 1; // Only 1 selection supported atm
 992     return 0;
 993 }
 994 void QtAccessibleWidget::setCursorPosition(int position)
 995 {
 996     Reference<XAccessibleText> xText(getAccessibleContextImpl(), UNO_QUERY);
 997     if (xText.is())
 998         xText->setCaretPosition(position);
 999 }
1000 void QtAccessibleWidget::setSelection(int /* selectionIndex */, int startOffset, int endOffset)
1001 {
1002     Reference<XAccessibleText> xText(getAccessibleContextImpl(), UNO_QUERY);
1003     if (xText.is())
1004         xText->setSelection(startOffset, endOffset);
1005 }
1006 QString QtAccessibleWidget::text(int startOffset, int endOffset) const
1007 {
1008     Reference<XAccessibleText> xText(getAccessibleContextImpl(), UNO_QUERY);
1009     if (xText.is())
1010         return toQString(xText->getTextRange(startOffset, endOffset));
1011     return QString();
1012 }
1013 QString QtAccessibleWidget::textAfterOffset(int /* offset */,
1014                                             QAccessible::TextBoundaryType /* boundaryType */,
1015                                             int* /* startOffset */, int* /* endOffset */) const
1016 {
1017     SAL_INFO("vcl.qt", "Unsupported QAccessibleTextInterface::textAfterOffset");
1018     return QString();
1019 }
1020
1021 QString QtAccessibleWidget::textAtOffset(int offset, QAccessible::TextBoundaryType boundaryType,
1022                                          int* startOffset, int* endOffset) const
1023 {
1024     if (startOffset == nullptr || endOffset == nullptr)
1025         return QString();
1026
1027     if (boundaryType == QAccessible::NoBoundary)
1028     {
1029         const int nCharCount = characterCount();
1030         *startOffset = 0;
1031         *endOffset = nCharCount;
1032         return text(0, nCharCount);
1033     }
1034
1035     Reference<XAccessibleText> xText(getAccessibleContextImpl(), UNO_QUERY);
1036     if (!xText.is())
1037         return QString();
1038
1039     sal_Int16 nUnoBoundaryType = lcl_matchQtTextBoundaryType(boundaryType);
1040     assert(nUnoBoundaryType > 0);
1041
1042     const TextSegment segment = xText->getTextAtIndex(offset, nUnoBoundaryType);
1043     *startOffset = segment.SegmentStart;
1044     *endOffset = segment.SegmentEnd;
1045     return toQString(segment.SegmentText);
1046 }
1047
1048 QString QtAccessibleWidget::textBeforeOffset(int /* offset */,
1049                                              QAccessible::TextBoundaryType /* boundaryType */,
1050                                              int* /* startOffset */, int* /* endOffset */) const
1051 {
1052     SAL_INFO("vcl.qt", "Unsupported QAccessibleTextInterface::textBeforeOffset");
1053     return QString();
1054 }
1055
1056 // QAccessibleEditableTextInterface
1057
1058 void QtAccessibleWidget::deleteText(int startOffset, int endOffset)
1059 {
1060     Reference<XAccessibleContext> xAc = getAccessibleContextImpl();
1061     if (!xAc.is())
1062         return;
1063
1064     Reference<XAccessibleEditableText> xEditableText(xAc, UNO_QUERY);
1065     if (!xEditableText.is())
1066         return;
1067     xEditableText->deleteText(startOffset, endOffset);
1068 }
1069
1070 void QtAccessibleWidget::insertText(int offset, const QString& text)
1071 {
1072     Reference<XAccessibleContext> xAc = getAccessibleContextImpl();
1073     if (!xAc.is())
1074         return;
1075
1076     Reference<XAccessibleEditableText> xEditableText(xAc, UNO_QUERY);
1077     if (!xEditableText.is())
1078         return;
1079     xEditableText->insertText(toOUString(text), offset);
1080 }
1081
1082 void QtAccessibleWidget::replaceText(int startOffset, int endOffset, const QString& text)
1083 {
1084     Reference<XAccessibleContext> xAc = getAccessibleContextImpl();
1085     if (!xAc.is())
1086         return;
1087
1088     Reference<XAccessibleEditableText> xEditableText(xAc, UNO_QUERY);
1089     if (!xEditableText.is())
1090         return;
1091     xEditableText->replaceText(startOffset, endOffset, toOUString(text));
1092 }
1093
1094 // QAccessibleValueInterface
1095 QVariant QtAccessibleWidget::currentValue() const
1096 {
1097     Reference<XAccessibleContext> xAc = getAccessibleContextImpl();
1098     if (!xAc.is())
1099         return QVariant();
1100
1101     Reference<XAccessibleValue> xValue(xAc, UNO_QUERY);
1102     if (!xValue.is())
1103         return QVariant();
1104     double aDouble = 0;
1105     xValue->getCurrentValue() >>= aDouble;
1106     return QVariant(aDouble);
1107 }
1108
1109 QVariant QtAccessibleWidget::maximumValue() const
1110 {
1111     Reference<XAccessibleContext> xAc = getAccessibleContextImpl();
1112     if (!xAc.is())
1113         return QVariant();
1114
1115     Reference<XAccessibleValue> xValue(xAc, UNO_QUERY);
1116     if (!xValue.is())
1117         return QVariant();
1118     double aDouble = 0;
1119     xValue->getMaximumValue() >>= aDouble;
1120     return QVariant(aDouble);
1121 }
1122
1123 QVariant QtAccessibleWidget::minimumStepSize() const
1124 {
1125     Reference<XAccessibleContext> xAc = getAccessibleContextImpl();
1126     if (!xAc.is())
1127         return QVariant();
1128
1129     Reference<XAccessibleValue> xValue(xAc, UNO_QUERY);
1130     if (!xValue.is())
1131         return QVariant();
1132     double dMinStep = 0;
1133     xValue->getMinimumIncrement() >>= dMinStep;
1134     return QVariant(dMinStep);
1135 }
1136
1137 QVariant QtAccessibleWidget::minimumValue() const
1138 {
1139     Reference<XAccessibleContext> xAc = getAccessibleContextImpl();
1140     if (!xAc.is())
1141         return QVariant();
1142
1143     Reference<XAccessibleValue> xValue(xAc, UNO_QUERY);
1144     if (!xValue.is())
1145         return QVariant();
1146     double aDouble = 0;
1147     xValue->getMinimumValue() >>= aDouble;
1148     return QVariant(aDouble);
1149 }
1150
1151 void QtAccessibleWidget::setCurrentValue(const QVariant& value)
1152 {
1153     Reference<XAccessibleContext> xAc = getAccessibleContextImpl();
1154     if (!xAc.is())
1155         return;
1156
1157     Reference<XAccessibleValue> xValue(xAc, UNO_QUERY);
1158     if (!xValue.is())
1159         return;
1160     xValue->setCurrentValue(Any(value.toDouble()));
1161 }
1162
1163 // QAccessibleTable
1164 QAccessibleInterface* QtAccessibleWidget::caption() const
1165 {
1166     Reference<XAccessibleContext> xAc = getAccessibleContextImpl();
1167     if (!xAc.is())
1168         return nullptr;
1169
1170     Reference<XAccessibleTable> xTable(xAc, UNO_QUERY);
1171     if (!xTable.is())
1172         return nullptr;
1173     return QAccessible::queryAccessibleInterface(new QtXAccessible(xTable->getAccessibleCaption()));
1174 }
1175
1176 QAccessibleInterface* QtAccessibleWidget::cellAt(int row, int column) const
1177 {
1178     Reference<XAccessibleContext> xAc = getAccessibleContextImpl();
1179     if (!xAc.is())
1180         return nullptr;
1181
1182     Reference<XAccessibleTable> xTable(xAc, UNO_QUERY);
1183     if (!xTable.is())
1184         return nullptr;
1185     return QAccessible::queryAccessibleInterface(
1186         new QtXAccessible(xTable->getAccessibleCellAt(row, column)));
1187 }
1188
1189 int QtAccessibleWidget::columnCount() const
1190 {
1191     Reference<XAccessibleContext> xAc = getAccessibleContextImpl();
1192     if (!xAc.is())
1193         return 0;
1194
1195     Reference<XAccessibleTable> xTable(xAc, UNO_QUERY);
1196     if (!xTable.is())
1197         return 0;
1198     return xTable->getAccessibleColumnCount();
1199 }
1200
1201 QString QtAccessibleWidget::columnDescription(int column) const
1202 {
1203     Reference<XAccessibleContext> xAc = getAccessibleContextImpl();
1204     if (!xAc.is())
1205         return QString();
1206
1207     Reference<XAccessibleTable> xTable(xAc, UNO_QUERY);
1208     if (!xTable.is())
1209         return QString();
1210     return toQString(xTable->getAccessibleColumnDescription(column));
1211 }
1212
1213 bool QtAccessibleWidget::isColumnSelected(int nColumn) const
1214 {
1215     Reference<XAccessibleContext> xAc = getAccessibleContextImpl();
1216     if (!xAc.is())
1217         return false;
1218
1219     Reference<XAccessibleTable> xTable(xAc, UNO_QUERY);
1220     if (!xTable.is())
1221         return false;
1222
1223     return xTable->isAccessibleColumnSelected(nColumn);
1224 }
1225
1226 bool QtAccessibleWidget::isRowSelected(int nRow) const
1227 {
1228     Reference<XAccessibleContext> xAc = getAccessibleContextImpl();
1229     if (!xAc.is())
1230         return false;
1231
1232     Reference<XAccessibleTable> xTable(xAc, UNO_QUERY);
1233     if (!xTable.is())
1234         return false;
1235
1236     return xTable->isAccessibleRowSelected(nRow);
1237 }
1238
1239 void QtAccessibleWidget::modelChange(QAccessibleTableModelChangeEvent*) {}
1240
1241 int QtAccessibleWidget::rowCount() const
1242 {
1243     Reference<XAccessibleContext> xAc = getAccessibleContextImpl();
1244     if (!xAc.is())
1245         return 0;
1246
1247     Reference<XAccessibleTable> xTable(xAc, UNO_QUERY);
1248     if (!xTable.is())
1249         return 0;
1250     return xTable->getAccessibleRowCount();
1251 }
1252
1253 QString QtAccessibleWidget::rowDescription(int row) const
1254 {
1255     Reference<XAccessibleContext> xAc = getAccessibleContextImpl();
1256     if (!xAc.is())
1257         return QString();
1258
1259     Reference<XAccessibleTable> xTable(xAc, UNO_QUERY);
1260     if (!xTable.is())
1261         return QString();
1262     return toQString(xTable->getAccessibleRowDescription(row));
1263 }
1264
1265 bool QtAccessibleWidget::selectColumn(int column)
1266 {
1267     Reference<XAccessibleContext> xAc = getAccessibleContextImpl();
1268     if (!xAc.is())
1269         return false;
1270
1271     Reference<XAccessibleTableSelection> xTableSelection(xAc, UNO_QUERY);
1272     if (!xTableSelection.is())
1273         return false;
1274     return xTableSelection->selectColumn(column);
1275 }
1276
1277 bool QtAccessibleWidget::selectRow(int row)
1278 {
1279     Reference<XAccessibleContext> xAc = getAccessibleContextImpl();
1280     if (!xAc.is())
1281         return false;
1282
1283     Reference<XAccessibleTableSelection> xTableSelection(xAc, UNO_QUERY);
1284     if (!xTableSelection.is())
1285         return false;
1286     return xTableSelection->selectRow(row);
1287 }
1288
1289 int QtAccessibleWidget::selectedCellCount() const
1290 {
1291     SAL_INFO("vcl.qt", "Unsupported QAccessibleTableInterface::selectedCellCount");
1292     return 0;
1293 }
1294
1295 QList<QAccessibleInterface*> QtAccessibleWidget::selectedCells() const
1296 {
1297     SAL_INFO("vcl.qt", "Unsupported QAccessibleTableInterface::selectedCells");
1298     return QList<QAccessibleInterface*>();
1299 }
1300
1301 int QtAccessibleWidget::selectedColumnCount() const
1302 {
1303     Reference<XAccessibleContext> xAc = getAccessibleContextImpl();
1304     if (!xAc.is())
1305         return 0;
1306
1307     Reference<XAccessibleTable> xTable(xAc, UNO_QUERY);
1308     if (!xTable.is())
1309         return 0;
1310     return xTable->getSelectedAccessibleColumns().getLength();
1311 }
1312
1313 QList<int> QtAccessibleWidget::selectedColumns() const
1314 {
1315     Reference<XAccessibleContext> xAc = getAccessibleContextImpl();
1316     if (!xAc.is())
1317         return QList<int>();
1318
1319     Reference<XAccessibleTable> xTable(xAc, UNO_QUERY);
1320     if (!xTable.is())
1321         return QList<int>();
1322     return toQList(xTable->getSelectedAccessibleColumns());
1323 }
1324
1325 int QtAccessibleWidget::selectedRowCount() const
1326 {
1327     Reference<XAccessibleContext> xAc = getAccessibleContextImpl();
1328     if (!xAc.is())
1329         return 0;
1330
1331     Reference<XAccessibleTable> xTable(xAc, UNO_QUERY);
1332     if (!xTable.is())
1333         return 0;
1334     return xTable->getSelectedAccessibleRows().getLength();
1335 }
1336
1337 QList<int> QtAccessibleWidget::selectedRows() const
1338 {
1339     Reference<XAccessibleContext> xAc = getAccessibleContextImpl();
1340     if (!xAc.is())
1341         return QList<int>();
1342
1343     Reference<XAccessibleTable> xTable(xAc, UNO_QUERY);
1344     if (!xTable.is())
1345         return QList<int>();
1346     return toQList(xTable->getSelectedAccessibleRows());
1347 }
1348
1349 QAccessibleInterface* QtAccessibleWidget::summary() const
1350 {
1351     Reference<XAccessibleContext> xAc = getAccessibleContextImpl();
1352     if (!xAc.is())
1353         return nullptr;
1354
1355     Reference<XAccessibleTable> xTable(xAc, UNO_QUERY);
1356     if (!xTable.is())
1357         return nullptr;
1358     return QAccessible::queryAccessibleInterface(new QtXAccessible(xTable->getAccessibleSummary()));
1359 }
1360
1361 bool QtAccessibleWidget::unselectColumn(int column)
1362 {
1363     Reference<XAccessibleContext> xAc = getAccessibleContextImpl();
1364     if (!xAc.is())
1365         return false;
1366
1367     Reference<XAccessibleTableSelection> xTableSelection(xAc, UNO_QUERY);
1368     if (!xTableSelection.is())
1369         return false;
1370     return xTableSelection->unselectColumn(column);
1371 }
1372
1373 bool QtAccessibleWidget::unselectRow(int row)
1374 {
1375     Reference<XAccessibleContext> xAc = getAccessibleContextImpl();
1376     if (!xAc.is())
1377         return false;
1378
1379     Reference<XAccessibleTableSelection> xTableSelection(xAc, UNO_QUERY);
1380     if (!xTableSelection.is())
1381         return false;
1382     return xTableSelection->unselectRow(row);
1383 }
1384
1385 QList<QAccessibleInterface*> QtAccessibleWidget::columnHeaderCells() const
1386 {
1387     SAL_WARN("vcl.qt", "Unsupported QAccessibleTableCellInterface::columnHeaderCells");
1388     return QList<QAccessibleInterface*>();
1389 }
1390
1391 int QtAccessibleWidget::columnIndex() const
1392 {
1393     Reference<XAccessibleContext> xAcc = getAccessibleContextImpl();
1394     if (!xAcc.is())
1395         return -1;
1396
1397     Reference<XAccessibleTable> xTable = getAccessibleTableForParent();
1398     if (!xTable.is())
1399         return -1;
1400
1401     const sal_Int32 nIndexInParent = xAcc->getAccessibleIndexInParent();
1402     return xTable->getAccessibleColumn(nIndexInParent);
1403 }
1404
1405 bool QtAccessibleWidget::isSelected() const
1406 {
1407     Reference<XAccessibleContext> xAcc = getAccessibleContextImpl();
1408     if (!xAcc.is())
1409         return false;
1410
1411     Reference<XAccessibleTable> xTable = getAccessibleTableForParent();
1412     if (!xTable.is())
1413         return false;
1414
1415     const sal_Int32 nColumn = columnIndex();
1416     const sal_Int32 nRow = rowIndex();
1417     return xTable->isAccessibleSelected(nRow, nColumn);
1418 }
1419
1420 int QtAccessibleWidget::columnExtent() const
1421 {
1422     Reference<XAccessibleContext> xAcc = getAccessibleContextImpl();
1423     if (!xAcc.is())
1424         return -1;
1425
1426     Reference<XAccessibleTable> xTable = getAccessibleTableForParent();
1427     if (!xTable.is())
1428         return -1;
1429
1430     const sal_Int32 nColumn = columnIndex();
1431     const sal_Int32 nRow = rowIndex();
1432     return xTable->getAccessibleColumnExtentAt(nRow, nColumn);
1433 }
1434
1435 QList<QAccessibleInterface*> QtAccessibleWidget::rowHeaderCells() const
1436 {
1437     SAL_WARN("vcl.qt", "Unsupported QAccessibleTableCellInterface::rowHeaderCells");
1438     return QList<QAccessibleInterface*>();
1439 }
1440
1441 int QtAccessibleWidget::rowExtent() const
1442 {
1443     Reference<XAccessibleContext> xAcc = getAccessibleContextImpl();
1444     if (!xAcc.is())
1445         return -1;
1446
1447     Reference<XAccessibleTable> xTable = getAccessibleTableForParent();
1448     if (!xTable.is())
1449         return -1;
1450
1451     const sal_Int32 nColumn = columnIndex();
1452     const sal_Int32 nRow = rowIndex();
1453     return xTable->getAccessibleRowExtentAt(nRow, nColumn);
1454 }
1455
1456 int QtAccessibleWidget::rowIndex() const
1457 {
1458     Reference<XAccessibleContext> xAcc = getAccessibleContextImpl();
1459     if (!xAcc.is())
1460         return -1;
1461
1462     Reference<XAccessibleTable> xTable = getAccessibleTableForParent();
1463     if (!xTable.is())
1464         return -1;
1465
1466     const sal_Int32 nIndexInParent = xAcc->getAccessibleIndexInParent();
1467     return xTable->getAccessibleRow(nIndexInParent);
1468 }
1469
1470 QAccessibleInterface* QtAccessibleWidget::table() const
1471 {
1472     SAL_WARN("vcl.qt", "Unsupported QAccessibleTableCellInterface::table");
1473     return nullptr;
1474 }
1475
1476 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */