starmath/source/AccessibleSmElementsControl.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 <AccessibleSmElementsControl.hxx>
  21 #include <AccessibleSmElement.hxx>
  22 #include <ElementsDockingWindow.hxx>
  23 #include <smmod.hxx>
  24
  25 #include <comphelper/accessiblewrapper.hxx>
  26 #include <comphelper/processfactory.hxx>
  27 #include <comphelper/types.hxx>
  28 #include <com/sun/star/accessibility/AccessibleEventId.hpp>
  29 #include <com/sun/star/accessibility/AccessibleRole.hpp>
  30 #include <com/sun/star/accessibility/AccessibleStateType.hpp>
  31 #include <com/sun/star/lang/IndexOutOfBoundsException.hpp>
  32 #include <cppuhelper/supportsservice.hxx>
  33 #include <cppuhelper/typeprovider.hxx>
  34 #include <o3tl/safeint.hxx>
  35 #include <toolkit/helper/convert.hxx>
  36 #include <unotools/accessiblerelationsethelper.hxx>
  37 #include <unotools/accessiblestatesethelper.hxx>
  38 #include <vcl/svapp.hxx>
  39 #include <vcl/vclevent.hxx>
  40
  41 using namespace ::com::sun::star;
  42 using namespace ::com::sun::star::accessibility;
  43 using OContextEntryGuard = ::comphelper::OContextEntryGuard;
  44 using OExternalLockGuard = ::comphelper::OExternalLockGuard;
  45
  46 // AccessibleSmElementsControl
  47
  48 AccessibleSmElementsControl::AccessibleSmElementsControl(SmElementsControl& rControl)
  49     : m_pControl(&rControl)
  50 {
  51 }
  52
  53 AccessibleSmElementsControl::~AccessibleSmElementsControl() {}
  54
  55 void AccessibleSmElementsControl::UpdateFocus(sal_uInt16 nPos)
  56 {
  57     const bool bSetFocus = (nPos == SAL_MAX_UINT16);
  58
  59     // submit events only if the widget has the focus to avoid sending events due to mouse move
  60     if (!m_pControl || (bSetFocus && !m_pControl->HasFocus()))
  61         return;
  62
  63     if (bSetFocus)
  64         nPos = m_pControl->itemHighlighted() - m_pControl->itemOffset();
  65
  66     if (nPos < m_aAccessibleChildren.size())
  67     {
  68         const auto& rxChild = m_aAccessibleChildren[nPos];
  69         if (rxChild.is())
  70             rxChild->SetFocus(bSetFocus);
  71     }
  72 }
  73
  74 void AccessibleSmElementsControl::ReleaseAllItems()
  75 {
  76     if (m_aAccessibleChildren.empty())
  77         return;
  78
  79     m_aAccessibleChildren.clear();
  80
  81     // The original toolbox accessibility code uses individual NAME_CHANGED
  82     // events in a loop. We can't do this, because on each remove event the
  83     // list of known children is rebuild. But since we rely on the child
  84     // count of the SmElementsControl, we'll always have no or all items.
  85     // In the latter case this would automatically recreate all items!
  86     assert(m_pControl && m_pControl->itemCount() == 0);
  87     NotifyAccessibleEvent(AccessibleEventId::INVALIDATE_ALL_CHILDREN, uno::Any(), uno::Any());
  88 }
  89
  90 void AccessibleSmElementsControl::AddAllItems()
  91 {
  92     assert(m_pControl);
  93     if (!m_pControl)
  94         return;
  95
  96     uno::Any aNewName(getAccessibleName());
  97     NotifyAccessibleEvent(AccessibleEventId::NAME_CHANGED, uno::Any(), aNewName);
  98
  99     // register the new items
 100     sal_uInt16 nCount = getAccessibleChildCount();
 101     for (sal_uInt16 i = 0; i < nCount; ++i)
 102     {
 103         uno::Any aNewValue;
 104         aNewValue <<= getAccessibleChild(static_cast<sal_Int32>(i));
 105         NotifyAccessibleEvent(AccessibleEventId::CHILD, uno::Any(), aNewValue);
 106     }
 107 }
 108
 109 IMPLEMENT_FORWARD_XINTERFACE2(AccessibleSmElementsControl, comphelper::OAccessibleComponentHelper,
 110                               AccessibleSmElementsControl_BASE)
 111
 112 IMPLEMENT_FORWARD_XTYPEPROVIDER2(AccessibleSmElementsControl,
 113                                  comphelper::OAccessibleComponentHelper,
 114                                  AccessibleSmElementsControl_BASE)
 115
 116 // XAccessible
 117 uno::Reference<XAccessibleContext> AccessibleSmElementsControl::getAccessibleContext()
 118 {
 119     return this;
 120 }
 121
 122 // XComponent
 123 void AccessibleSmElementsControl::disposing()
 124 {
 125     comphelper::OAccessibleComponentHelper::disposing();
 126     m_aAccessibleChildren.clear();
 127 }
 128
 129 void AccessibleSmElementsControl::grabFocus()
 130 {
 131     SolarMutexGuard aGuard;
 132     if (!m_pControl)
 133         throw uno::RuntimeException();
 134
 135     m_pControl->GrabFocus();
 136 }
 137
 138 sal_Int32 AccessibleSmElementsControl::getForeground()
 139 {
 140     SolarMutexGuard aGuard;
 141
 142     return static_cast<sal_Int32>(SmElementsControl::GetTextColor());
 143 }
 144
 145 sal_Int32 AccessibleSmElementsControl::getBackground()
 146 {
 147     SolarMutexGuard aGuard;
 148
 149     Color nCol = SmElementsControl::GetControlBackground();
 150     return static_cast<sal_Int32>(nCol);
 151 }
 152
 153 // XServiceInfo
 154 OUString AccessibleSmElementsControl::getImplementationName()
 155 {
 156     return "com.sun.star.comp.toolkit.AccessibleSmElementsControl";
 157 }
 158
 159 sal_Bool AccessibleSmElementsControl::supportsService(const OUString& rServiceName)
 160 {
 161     return cppu::supportsService(this, rServiceName);
 162 }
 163
 164 uno::Sequence<OUString> AccessibleSmElementsControl::getSupportedServiceNames()
 165 {
 166     return { "com.sun.star.accessibility.AccessibleContext",
 167              "com.sun.star.accessibility.AccessibleComponent",
 168              "com.sun.star.accessibility.AccessibleSelection",
 169              "com.sun.star.accessibility.AccessibleSmElementsControl" };
 170 }
 171
 172 // XAccessibleContext
 173 sal_Int32 AccessibleSmElementsControl::getAccessibleChildCount()
 174 {
 175     comphelper::OExternalLockGuard aGuard(this);
 176     sal_Int32 nCount = 0;
 177     if (m_pControl)
 178     {
 179         nCount = m_pControl->itemCount();
 180         if (m_aAccessibleChildren.size() != sal_uInt16(nCount))
 181             m_aAccessibleChildren.resize(nCount);
 182     }
 183     return nCount;
 184 }
 185
 186 uno::Reference<XAccessible> AccessibleSmElementsControl::getAccessibleChild(sal_Int32 c)
 187 {
 188     comphelper::OExternalLockGuard aGuard(this);
 189
 190     if (c < 0 || c >= getAccessibleChildCount())
 191         throw lang::IndexOutOfBoundsException();
 192
 193     rtl::Reference<AccessibleSmElement> xChild = m_aAccessibleChildren[c];
 194     const sal_uInt16 nItemId = m_pControl->itemOffset() + c;
 195     if (xChild.is() && xChild->itemId() != nItemId)
 196         xChild.clear();
 197     if (!xChild.is())
 198     {
 199         sal_uInt16 nHighlightItemId = m_pControl->itemHighlighted();
 200         AccessibleSmElement* pChild = new AccessibleSmElement(m_pControl, nItemId, c);
 201         if (pChild->itemId() == nHighlightItemId)
 202             pChild->SetFocus(true);
 203         m_aAccessibleChildren[c] = pChild;
 204         xChild = pChild;
 205     }
 206     return xChild.get();
 207 }
 208
 209 uno::Reference<XAccessible> AccessibleSmElementsControl::getAccessibleParent()
 210 {
 211     SolarMutexGuard aGuard;
 212     if (!m_pControl)
 213         throw uno::RuntimeException();
 214
 215     return m_pControl->GetDrawingArea()->get_accessible_parent();
 216 }
 217
 218 uno::Reference<XAccessible>
 219 AccessibleSmElementsControl::getAccessibleAtPoint(const awt::Point& rPoint)
 220 {
 221     comphelper::OExternalLockGuard aGuard(this);
 222
 223     uno::Reference<XAccessible> xAccessible;
 224     if (m_pControl)
 225     {
 226         sal_uInt16 nPos = m_pControl->itemAtPos(VCLPoint(rPoint));
 227         nPos -= m_pControl->itemOffset();
 228         if (nPos <= m_aAccessibleChildren.size())
 229             xAccessible = getAccessibleChild(nPos);
 230     }
 231     return xAccessible;
 232 }
 233
 234 sal_Int16 AccessibleSmElementsControl::getAccessibleRole() { return AccessibleRole::SCROLL_PANE; }
 235
 236 OUString AccessibleSmElementsControl::getAccessibleDescription() { return OUString(); }
 237
 238 OUString AccessibleSmElementsControl::getAccessibleName()
 239 {
 240     SolarMutexGuard aGuard;
 241     OUString aName;
 242     if (m_pControl)
 243         aName = SmResId(m_pControl->elementSetId().getStr());
 244     return aName;
 245 }
 246
 247 // XAccessibleSelection
 248 void AccessibleSmElementsControl::selectAccessibleChild(sal_Int32 nChildIndex)
 249 {
 250     OExternalLockGuard aGuard(this);
 251
 252     if ((!m_pControl) || nChildIndex < 0
 253         || o3tl::make_unsigned(nChildIndex) >= m_aAccessibleChildren.size())
 254         throw lang::IndexOutOfBoundsException();
 255
 256     m_pControl->setItemHighlighted(nChildIndex);
 257 }
 258
 259 sal_Bool AccessibleSmElementsControl::isAccessibleChildSelected(sal_Int32 nChildIndex)
 260 {
 261     OExternalLockGuard aGuard(this);
 262     if ((!m_pControl) || nChildIndex < 0
 263         || o3tl::make_unsigned(nChildIndex) >= m_aAccessibleChildren.size())
 264         throw lang::IndexOutOfBoundsException();
 265
 266     return (m_pControl->itemHighlighted() == nChildIndex);
 267 }
 268
 269 void AccessibleSmElementsControl::clearAccessibleSelection()
 270 {
 271     OExternalLockGuard aGuard(this);
 272     if (m_pControl)
 273         m_pControl->setItemHighlighted(SAL_MAX_UINT16);
 274 }
 275
 276 void AccessibleSmElementsControl::selectAllAccessibleChildren()
 277 {
 278     // intentionally empty
 279 }
 280
 281 sal_Int32 AccessibleSmElementsControl::getSelectedAccessibleChildCount()
 282 {
 283     OExternalLockGuard aGuard(this);
 284
 285     sal_Int32 nRet = 0;
 286     if (m_pControl
 287         && (m_pControl->itemHighlighted() - m_pControl->itemOffset()) < getAccessibleChildCount())
 288         nRet = 1;
 289     return nRet;
 290 }
 291
 292 uno::Reference<XAccessible>
 293 AccessibleSmElementsControl::getSelectedAccessibleChild(sal_Int32 nSelectedChildIndex)
 294 {
 295     OExternalLockGuard aGuard(this);
 296     if (nSelectedChildIndex != 0 || !m_pControl)
 297         throw lang::IndexOutOfBoundsException();
 298     return getAccessibleChild(m_pControl->itemHighlighted() - m_pControl->itemOffset());
 299 }
 300
 301 void AccessibleSmElementsControl::deselectAccessibleChild(sal_Int32 nChildIndex)
 302 {
 303     OExternalLockGuard aGuard(this);
 304     if (nChildIndex != 0 || nChildIndex >= getAccessibleChildCount())
 305         throw lang::IndexOutOfBoundsException();
 306     clearAccessibleSelection(); // there can be just one selected child
 307 }
 308
 309 void AccessibleSmElementsControl::TestControl()
 310 {
 311     if (!m_pControl)
 312         throw uno::RuntimeException();
 313 }
 314
 315 awt::Rectangle AccessibleSmElementsControl::implGetBounds()
 316 {
 317     SolarMutexGuard aGuard;
 318     TestControl();
 319
 320     awt::Rectangle aRet;
 321
 322     const Point aOutPos;
 323     Size aOutSize(m_pControl->GetOutputSizePixel());
 324
 325     aRet.X = aOutPos.X();
 326     aRet.Y = aOutPos.Y();
 327     aRet.Width = aOutSize.Width();
 328     aRet.Height = aOutSize.Height();
 329
 330     return aRet;
 331 }
 332
 333 sal_Bool AccessibleSmElementsControl::containsPoint(const awt::Point& aPoint)
 334 {
 335     SolarMutexGuard aGuard;
 336     TestControl();
 337     Size aSz(m_pControl->GetOutputSizePixel());
 338     return aPoint.X >= 0 && aPoint.Y >= 0 && aPoint.X < aSz.Width() && aPoint.Y < aSz.Height();
 339 }
 340
 341 uno::Reference<XAccessibleRelationSet> AccessibleSmElementsControl::getAccessibleRelationSet()
 342 {
 343     uno::Reference<XAccessibleRelationSet> xRelSet = new utl::AccessibleRelationSetHelper();
 344     return xRelSet; // empty relation set
 345 }
 346
 347 uno::Reference<XAccessibleStateSet> AccessibleSmElementsControl::getAccessibleStateSet()
 348 {
 349     SolarMutexGuard aGuard;
 350     ::utl::AccessibleStateSetHelper* pStateSet = new ::utl::AccessibleStateSetHelper;
 351
 352     uno::Reference<XAccessibleStateSet> xStateSet(pStateSet);
 353
 354     if (!m_pControl)
 355         pStateSet->AddState(AccessibleStateType::DEFUNC);
 356     else
 357     {
 358         pStateSet->AddState(AccessibleStateType::ENABLED);
 359         pStateSet->AddState(AccessibleStateType::FOCUSABLE);
 360         if (m_pControl->HasFocus())
 361             pStateSet->AddState(AccessibleStateType::FOCUSED);
 362         if (m_pControl->IsActive())
 363             pStateSet->AddState(AccessibleStateType::ACTIVE);
 364         if (m_pControl->IsVisible())
 365             pStateSet->AddState(AccessibleStateType::SHOWING);
 366         if (m_pControl->IsReallyVisible())
 367             pStateSet->AddState(AccessibleStateType::VISIBLE);
 368         if (COL_TRANSPARENT != SmElementsControl::GetControlBackground())
 369             pStateSet->AddState(AccessibleStateType::OPAQUE);
 370     }
 371
 372     return xStateSet;
 373 }
 374
 375 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */