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