svx/source/accessibility/svxpixelctlaccessiblecontext.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 <com/sun/star/accessibility/AccessibleRole.hpp>
  21 #include <com/sun/star/accessibility/AccessibleEventId.hpp>
  22 #include <com/sun/star/accessibility/AccessibleStateType.hpp>
  23 #include <com/sun/star/lang/IndexOutOfBoundsException.hpp>
  24 #include <toolkit/helper/vclunohelper.hxx>
  25 #include <utility>
  26 #include <vcl/svapp.hxx>
  27 #include <vcl/settings.hxx>
  28 #include <vcl/unohelp.hxx>
  29 #include <osl/mutex.hxx>
  30 #include <tools/debug.hxx>
  31 #include <tools/gen.hxx>
  32
  33 #include <svx/dlgctrl.hxx>
  34
  35 #include <svxpixelctlaccessiblecontext.hxx>
  36
  37 using namespace ::cppu;
  38 using namespace ::osl;
  39 using namespace ::com::sun::star;
  40 using namespace ::com::sun::star::uno;
  41 using namespace ::com::sun::star::accessibility;
  42
  43 SvxPixelCtlAccessible::SvxPixelCtlAccessible(SvxPixelCtl* pControl)
  44     : mpPixelCtl(pControl)
  45 {
  46 }
  47
  48 SvxPixelCtlAccessible::~SvxPixelCtlAccessible()
  49 {
  50     ensureDisposed();
  51 }
  52
  53 uno::Reference< XAccessibleContext > SvxPixelCtlAccessible::getAccessibleContext(  )
  54 {
  55     return this;
  56 }
  57
  58 sal_Int64 SvxPixelCtlAccessible::getAccessibleChildCount(  )
  59 {
  60     return SvxPixelCtl::GetSquares();
  61 }
  62 uno::Reference< XAccessible > SvxPixelCtlAccessible::getAccessibleChild( sal_Int64 i )
  63 {
  64     ::osl::MutexGuard   aGuard( m_aMutex );
  65     if ( i < 0 || i >= getAccessibleChildCount())
  66         throw lang::IndexOutOfBoundsException();
  67     Reference< XAccessible > xChild;
  68     if (mpPixelCtl)
  69         xChild = CreateChild(i, mpPixelCtl->IndexToPoint(i));
  70     return xChild;
  71 }
  72
  73 uno::Reference< XAccessible > SvxPixelCtlAccessible::getAccessibleParent(  )
  74 {
  75     ::osl::MutexGuard   aGuard( m_aMutex );
  76     if (mpPixelCtl)
  77         return mpPixelCtl->getAccessibleParent();
  78     return uno::Reference<css::accessibility::XAccessible>();
  79 }
  80
  81 sal_Int16 SvxPixelCtlAccessible::getAccessibleRole(  )
  82 {
  83     return AccessibleRole::LIST;
  84 }
  85
  86 OUString SvxPixelCtlAccessible::getAccessibleDescription(  )
  87 {
  88
  89     ::osl::MutexGuard   aGuard( m_aMutex );
  90     return mpPixelCtl ? mpPixelCtl->GetAccessibleDescription() : u""_ustr;
  91 }
  92
  93 OUString SvxPixelCtlAccessible::getAccessibleName(  )
  94 {
  95     ::osl::MutexGuard   aGuard( m_aMutex );
  96     return mpPixelCtl ? mpPixelCtl->GetAccessibleName() : u""_ustr;
  97 }
  98
  99 Reference< XAccessibleRelationSet > SAL_CALL SvxPixelCtlAccessible::getAccessibleRelationSet()
 100 {
 101     if (mpPixelCtl)
 102         return mpPixelCtl->get_accessible_relation_set();
 103     return uno::Reference<css::accessibility::XAccessibleRelationSet>();
 104 }
 105
 106 sal_Int64 SvxPixelCtlAccessible::getAccessibleStateSet(  )
 107 {
 108     ::osl::MutexGuard   aGuard( m_aMutex );
 109     sal_Int64 nStateSet = 0;
 110
 111     if (mpPixelCtl)
 112     {
 113         nStateSet |=
 114             AccessibleStateType::FOCUSABLE |
 115             AccessibleStateType::SELECTABLE |
 116             AccessibleStateType::SHOWING |
 117             AccessibleStateType::VISIBLE |
 118             AccessibleStateType::OPAQUE;
 119         if (mpPixelCtl->IsEnabled())
 120             nStateSet |= AccessibleStateType::ENABLED;
 121         if (mpPixelCtl->HasFocus())
 122             nStateSet |= AccessibleStateType::FOCUSED;
 123         nStateSet |= AccessibleStateType::MANAGES_DESCENDANTS;
 124     }
 125
 126     return nStateSet;
 127 }
 128
 129 uno::Reference<XAccessible > SAL_CALL SvxPixelCtlAccessible::getAccessibleAtPoint (
 130         const awt::Point& rPoint)
 131 {
 132     ::osl::MutexGuard   aGuard( m_aMutex );
 133
 134     Reference< XAccessible >    xRet;
 135
 136     if (mpPixelCtl)
 137     {
 138         tools::Long nIndex = mpPixelCtl->PointToIndex(Point(rPoint.X, rPoint.Y));
 139         xRet = CreateChild(nIndex, mpPixelCtl->IndexToPoint(nIndex));
 140     }
 141
 142     return xRet;
 143 }
 144
 145 awt::Rectangle SvxPixelCtlAccessible::implGetBounds()
 146 {
 147     ::osl::MutexGuard   aGuard( m_aMutex );
 148
 149     awt::Rectangle aRet;
 150
 151     if (mpPixelCtl)
 152     {
 153         const Point   aOutPos;
 154         Size          aOutSize(mpPixelCtl->GetOutputSizePixel());
 155
 156         aRet.X = aOutPos.X();
 157         aRet.Y = aOutPos.Y();
 158         aRet.Width = aOutSize.Width();
 159         aRet.Height = aOutSize.Height();
 160     }
 161
 162     return aRet;
 163 }
 164
 165 void SvxPixelCtlAccessible::grabFocus(  )
 166 {
 167     ::osl::MutexGuard   aGuard( m_aMutex );
 168     if (mpPixelCtl)
 169         mpPixelCtl->GrabFocus();
 170 }
 171
 172 sal_Int32 SvxPixelCtlAccessible::getForeground(  )
 173 {
 174     ::osl::MutexGuard   aGuard( m_aMutex );
 175
 176     //see SvxPixelCtl::Paint
 177     const StyleSettings& rStyles = Application::GetSettings().GetStyleSettings();
 178     return sal_Int32(rStyles.GetLabelTextColor());
 179 }
 180
 181 sal_Int32 SvxPixelCtlAccessible::getBackground(  )
 182 {
 183     ::osl::MutexGuard   aGuard( m_aMutex );
 184
 185     //see SvxPixelCtl::Paint
 186     const StyleSettings& rStyles = Application::GetSettings().GetStyleSettings();
 187     return sal_Int32(rStyles.GetDialogColor());
 188 }
 189
 190 void SvxPixelCtlAccessible::implSelect(sal_Int64 nChildIndex, bool bSelect)
 191 {
 192     ::osl::MutexGuard   aGuard( m_aMutex );
 193
 194     if ( nChildIndex < 0 || nChildIndex >= getAccessibleChildCount())
 195         throw lang::IndexOutOfBoundsException();
 196
 197     if (!mpPixelCtl)
 198         return;
 199
 200     tools::Long nIndex = mpPixelCtl->ShowPosition(mpPixelCtl->IndexToPoint(nChildIndex));
 201     NotifyChild(nIndex, bSelect, false);
 202 }
 203
 204 bool SvxPixelCtlAccessible::implIsSelected(sal_Int64 nChildIndex)
 205 {
 206     ::osl::MutexGuard   aGuard( m_aMutex );
 207
 208     if (!mpPixelCtl)
 209         return false;
 210
 211     return mpPixelCtl->GetFocusPosIndex() == nChildIndex;
 212 }
 213
 214 void SAL_CALL SvxPixelCtlAccessible::disposing()
 215 {
 216     ::osl::MutexGuard aGuard(m_aMutex);
 217     OAccessibleSelectionHelper::disposing();
 218     m_xCurChild.clear();
 219     mpPixelCtl = nullptr;
 220 }
 221
 222 void SvxPixelCtlAccessible::NotifyChild(tools::Long nIndex,bool bSelect ,bool bCheck)
 223 {
 224     DBG_ASSERT( !(!bSelect && !bCheck),"" );//non is false
 225
 226     rtl::Reference<SvxPixelCtlAccessibleChild> pChild = m_xCurChild;
 227     if (pChild && pChild->getAccessibleIndexInParent() == nIndex )
 228     {
 229         if (bSelect)
 230         {
 231             pChild->SelectChild(true);
 232         }
 233         if (bCheck)
 234         {
 235             pChild->ChangePixelColorOrBG(mpPixelCtl->GetBitmapPixel(sal_uInt16(nIndex)) != 0);
 236             pChild->CheckChild();
 237         }
 238         return;
 239     }
 240     rtl::Reference<SvxPixelCtlAccessibleChild> xNewChild = CreateChild(nIndex, mpPixelCtl->IndexToPoint(nIndex));
 241     DBG_ASSERT(xNewChild,"Child Must be Valid");
 242
 243     Any aNewValue,aOldValue;
 244     aNewValue <<= uno::Reference<XAccessible>(xNewChild);
 245     NotifyAccessibleEvent(AccessibleEventId::ACTIVE_DESCENDANT_CHANGED, aOldValue, aNewValue);
 246
 247     if (bSelect)
 248     {
 249         if (pChild)
 250         {
 251             pChild->SelectChild(false);
 252         }
 253         xNewChild->SelectChild(true);
 254     }
 255     if (bCheck)
 256     {
 257         xNewChild->CheckChild();
 258     }
 259     m_xCurChild = std::move(xNewChild);
 260 }
 261
 262 rtl::Reference<SvxPixelCtlAccessibleChild> SvxPixelCtlAccessible::CreateChild (tools::Long nIndex,Point mPoint)
 263 {
 264     bool bPixelColorOrBG = mpPixelCtl->GetBitmapPixel(sal_uInt16(nIndex)) != 0;
 265     Size size(mpPixelCtl->GetWidth() / SvxPixelCtl::GetLineCount(), mpPixelCtl->GetHeight() / SvxPixelCtl::GetLineCount());
 266     rtl::Reference<SvxPixelCtlAccessibleChild> xChild = new SvxPixelCtlAccessibleChild(*mpPixelCtl,
 267                 bPixelColorOrBG,
 268                 tools::Rectangle(mPoint,size),
 269                 this,
 270                 nIndex);
 271
 272     return xChild;
 273 }
 274
 275 void SvxPixelCtlAccessibleChild::CheckChild()
 276 {
 277     Any aChecked;
 278     aChecked <<= AccessibleStateType::CHECKED;
 279
 280     if (m_bPixelColorOrBG)//Current Child State
 281     {
 282         NotifyAccessibleEvent(AccessibleEventId::STATE_CHANGED, Any(), aChecked);
 283     }
 284     else
 285     {
 286         NotifyAccessibleEvent(AccessibleEventId::STATE_CHANGED, aChecked, Any());
 287     }
 288 }
 289
 290 void SvxPixelCtlAccessibleChild::SelectChild( bool bSelect)
 291 {
 292     Any aSelected;
 293     aSelected <<= AccessibleStateType::SELECTED;
 294
 295     if (bSelect)
 296     {
 297         NotifyAccessibleEvent(AccessibleEventId::STATE_CHANGED, Any(), aSelected);
 298     }
 299     else
 300     {
 301         NotifyAccessibleEvent(AccessibleEventId::STATE_CHANGED, aSelected, Any());
 302     }
 303 }
 304
 305 SvxPixelCtlAccessibleChild::SvxPixelCtlAccessibleChild( SvxPixelCtl& rWindow, bool bPixelColorOrBG,
 306     const tools::Rectangle& rBoundingBox, rtl::Reference<SvxPixelCtlAccessible> xParent,
 307     tools::Long nIndexInParent)
 308     : mrParentWindow( rWindow )
 309     , mxParent(std::move(xParent))
 310     , m_bPixelColorOrBG(bPixelColorOrBG)
 311     , maBoundingBox( rBoundingBox )
 312     , mnIndexInParent( nIndexInParent )
 313 {
 314 }
 315
 316 SvxPixelCtlAccessibleChild::~SvxPixelCtlAccessibleChild()
 317 {
 318     ensureDisposed();
 319 }
 320
 321 // XAccessible
 322 uno::Reference< XAccessibleContext> SAL_CALL SvxPixelCtlAccessibleChild::getAccessibleContext()
 323 {
 324     return this;
 325 }
 326
 327 uno::Reference< XAccessible > SAL_CALL SvxPixelCtlAccessibleChild::getAccessibleAtPoint( const awt::Point& )
 328 {
 329     return uno::Reference< XAccessible >();
 330 }
 331
 332 void SAL_CALL SvxPixelCtlAccessibleChild::grabFocus()
 333 {
 334 }
 335
 336 sal_Int32 SvxPixelCtlAccessibleChild::getForeground()
 337 {
 338     ::osl::MutexGuard   aGuard( m_aMutex );
 339     return mxParent.is() ? mxParent->getForeground() : -1;
 340 }
 341
 342 sal_Int32 SvxPixelCtlAccessibleChild::getBackground()
 343 {
 344     ::osl::MutexGuard   aGuard( m_aMutex );
 345     return mxParent.is() ? mxParent->getBackground() : -1;
 346 }
 347
 348 // XAccessibleContext
 349 sal_Int64 SAL_CALL SvxPixelCtlAccessibleChild::getAccessibleChildCount()
 350 {
 351     return 0;
 352 }
 353
 354 uno::Reference< XAccessible > SAL_CALL SvxPixelCtlAccessibleChild::getAccessibleChild( sal_Int64 )
 355 {
 356     throw lang::IndexOutOfBoundsException();
 357 }
 358
 359 uno::Reference< XAccessible > SAL_CALL SvxPixelCtlAccessibleChild::getAccessibleParent()
 360 {
 361     return mxParent;
 362 }
 363
 364 sal_Int16 SAL_CALL SvxPixelCtlAccessibleChild::getAccessibleRole()
 365 {
 366     return AccessibleRole::CHECK_BOX;
 367 }
 368
 369 OUString SAL_CALL SvxPixelCtlAccessibleChild::getAccessibleDescription()
 370 {
 371     ::osl::MutexGuard   aGuard( m_aMutex );
 372
 373     return  GetName();
 374 }
 375
 376 OUString SAL_CALL SvxPixelCtlAccessibleChild::getAccessibleName()
 377 {
 378     ::osl::MutexGuard   aGuard( m_aMutex );
 379     return  GetName();
 380 }
 381
 382 /** Return empty uno::Reference to indicate that the relation set is not
 383     supported.
 384 */
 385 uno::Reference<XAccessibleRelationSet> SAL_CALL SvxPixelCtlAccessibleChild::getAccessibleRelationSet()
 386 {
 387     return uno::Reference< XAccessibleRelationSet >();
 388 }
 389
 390 sal_Int64 SAL_CALL SvxPixelCtlAccessibleChild::getAccessibleStateSet()
 391 {
 392     ::osl::MutexGuard                       aGuard( m_aMutex );
 393     sal_Int64 nStateSet = 0;
 394
 395     if (!rBHelper.bDisposed)
 396     {
 397         nStateSet |= AccessibleStateType::TRANSIENT;
 398         nStateSet |= AccessibleStateType::ENABLED;
 399         nStateSet |= AccessibleStateType::OPAQUE;
 400         nStateSet |= AccessibleStateType::SELECTABLE;
 401         nStateSet |= AccessibleStateType::SHOWING;
 402         nStateSet |= AccessibleStateType::VISIBLE;
 403
 404         tools::Long nIndex = mrParentWindow.GetFocusPosIndex();
 405         if ( nIndex == mnIndexInParent)
 406         {
 407             nStateSet |= AccessibleStateType::SELECTED;
 408         }
 409         if (mrParentWindow.GetBitmapPixel(sal_uInt16(mnIndexInParent)))
 410         {
 411             nStateSet |= AccessibleStateType::CHECKED;
 412         }
 413     }
 414     else
 415         nStateSet |= AccessibleStateType::DEFUNC;
 416
 417     return nStateSet;
 418 }
 419
 420 void SAL_CALL SvxPixelCtlAccessibleChild::disposing()
 421 {
 422     OAccessibleComponentHelper::disposing();
 423     mxParent.clear();
 424 }
 425
 426 awt::Rectangle SvxPixelCtlAccessibleChild::implGetBounds()
 427 {
 428     // no guard necessary, because no one changes maBoundingBox after creating it
 429     return vcl::unohelper::ConvertToAWTRect(maBoundingBox);
 430 }
 431
 432 OUString SvxPixelCtlAccessibleChild::GetName() const
 433 {
 434     sal_Int32 nXIndex = mnIndexInParent % SvxPixelCtl::GetLineCount();
 435     sal_Int32 nYIndex = mnIndexInParent / SvxPixelCtl::GetLineCount();
 436
 437     OUString str = "("
 438                  + OUString::number(nXIndex)
 439                  + ","
 440                  + OUString::number(nYIndex)
 441                  + ")";
 442     return str;
 443 }
 444
 445 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */