sc/source/ui/Accessibility/AccessibleEditObject.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 <sal/config.h>
  21
  22 #include <memory>
  23 #include <utility>
  24
  25 #include "AccessibleEditObject.hxx"
  26 #include "scitems.hxx"
  27 #include <editeng/eeitem.hxx>
  28 #include "AccessibleText.hxx"
  29 #include "editsrc.hxx"
  30 #include "scmod.hxx"
  31 #include "inputhdl.hxx"
  32
  33 #include <unotools/accessiblestatesethelper.hxx>
  34 #include <com/sun/star/accessibility/AccessibleRole.hpp>
  35 #include <com/sun/star/accessibility/AccessibleStateType.hpp>
  36 #include <com/sun/star/sheet/XSpreadsheetDocument.hpp>
  37 #include <com/sun/star/sheet/XSpreadsheet.hpp>
  38 #include <comphelper/servicehelper.hxx>
  39 #include <svx/AccessibleTextHelper.hxx>
  40 #include <editeng/editview.hxx>
  41 #include <editeng/editeng.hxx>
  42 #include <svx/svdmodel.hxx>
  43 #include <vcl/svapp.hxx>
  44 #include <sfx2/objsh.hxx>
  45
  46 #include "unonames.hxx"
  47 #include "document.hxx"
  48 #include "AccessibleDocument.hxx"
  49 #include <com/sun/star/accessibility/AccessibleRelationType.hpp>
  50 #include <unotools/accessiblerelationsethelper.hxx>
  51 #include <com/sun/star/accessibility/XAccessibleText.hpp>
  52
  53 using ::com::sun::star::lang::IndexOutOfBoundsException;
  54 using ::com::sun::star::uno::RuntimeException;
  55 using namespace ::com::sun::star;
  56 using namespace ::com::sun::star::accessibility;
  57
  58 //=====  internal  ============================================================
  59
  60 ScAccessibleEditObject::ScAccessibleEditObject(
  61         const uno::Reference<XAccessible>& rxParent,
  62         EditView* pEditView, vcl::Window* pWin, const OUString& rName,
  63         const OUString& rDescription, EditObjectType eObjectType)
  64     :
  65     ScAccessibleContextBase(rxParent, AccessibleRole::TEXT_FRAME),
  66     mpTextHelper(NULL),
  67     mpEditView(pEditView),
  68     mpWindow(pWin),
  69     meObjectType(eObjectType),
  70     mbHasFocus(false)
  71 {
  72     CreateTextHelper();
  73     SetName(rName);
  74     SetDescription(rDescription);
  75     if( meObjectType == CellInEditMode)
  76     {
  77         const ScAccessibleDocument *pAccDoc = static_cast<ScAccessibleDocument*>(rxParent.get());
  78         if (pAccDoc)
  79         {
  80             m_pScDoc = pAccDoc->GetDocument();
  81             m_curCellAddress =pAccDoc->GetCurCellAddress();
  82         }
  83         else
  84         {
  85             m_pScDoc=NULL;
  86         }
  87     }
  88     else
  89         m_pScDoc=NULL;
  90 }
  91
  92 ScAccessibleEditObject::~ScAccessibleEditObject()
  93 {
  94     if (!ScAccessibleContextBase::IsDefunc() && !rBHelper.bInDispose)
  95     {
  96         // increment refcount to prevent double call off dtor
  97         osl_atomic_increment( &m_refCount );
  98         // call dispose to inform object which have a weak reference to this object
  99         dispose();
 100     }
 101 }
 102
 103 void SAL_CALL ScAccessibleEditObject::disposing()
 104 {
 105     SolarMutexGuard aGuard;
 106     if (mpTextHelper)
 107         DELETEZ(mpTextHelper);
 108
 109     ScAccessibleContextBase::disposing();
 110 }
 111
 112 void ScAccessibleEditObject::LostFocus()
 113 {
 114     mbHasFocus = false;
 115     if (mpTextHelper)
 116         mpTextHelper->SetFocus(false);
 117     CommitFocusLost();
 118 }
 119
 120 void ScAccessibleEditObject::GotFocus()
 121 {
 122     mbHasFocus = true;
 123     CommitFocusGained();
 124     if (mpTextHelper)
 125         mpTextHelper->SetFocus(true);
 126 }
 127
 128 //=====  XInterface  ==========================================================
 129
 130 com::sun::star::uno::Any SAL_CALL
 131     ScAccessibleEditObject::queryInterface (const com::sun::star::uno::Type & rType)
 132     throw (::com::sun::star::uno::RuntimeException, std::exception)
 133 {
 134     ::com::sun::star::uno::Any aReturn = ScAccessibleContextBase::queryInterface (rType);
 135     if ( ! aReturn.hasValue())
 136         aReturn = ::cppu::queryInterface (rType,
 137             static_cast< ::com::sun::star::accessibility::XAccessibleSelection* >(this)
 138             );
 139     return aReturn;
 140 }
 141 void SAL_CALL
 142     ScAccessibleEditObject::acquire()
 143     throw ()
 144 {
 145     ScAccessibleContextBase::acquire ();
 146 }
 147 void SAL_CALL
 148     ScAccessibleEditObject::release()
 149     throw ()
 150 {
 151     ScAccessibleContextBase::release ();
 152 }
 153     //=====  XAccessibleComponent  ============================================
 154
 155 uno::Reference< XAccessible > SAL_CALL ScAccessibleEditObject::getAccessibleAtPoint(
 156         const awt::Point& rPoint )
 157         throw (uno::RuntimeException, std::exception)
 158 {
 159     uno::Reference<XAccessible> xRet;
 160     if (containsPoint(rPoint))
 161     {
 162          SolarMutexGuard aGuard;
 163         IsObjectValid();
 164
 165         if(!mpTextHelper)
 166             CreateTextHelper();
 167
 168         xRet = mpTextHelper->GetAt(rPoint);
 169     }
 170
 171     return xRet;
 172 }
 173
 174 Rectangle ScAccessibleEditObject::GetBoundingBoxOnScreen() const
 175         throw (uno::RuntimeException, std::exception)
 176 {
 177     Rectangle aScreenBounds;
 178
 179     if ( mpWindow )
 180     {
 181         if ( meObjectType == CellInEditMode )
 182         {
 183             if ( mpEditView && mpEditView->GetEditEngine() )
 184             {
 185                 MapMode aMapMode( mpEditView->GetEditEngine()->GetRefMapMode() );
 186                 aScreenBounds = mpWindow->LogicToPixel( mpEditView->GetOutputArea(), aMapMode );
 187                 Point aCellLoc = aScreenBounds.TopLeft();
 188                 Rectangle aWindowRect = mpWindow->GetWindowExtentsRelative( NULL );
 189                 Point aWindowLoc = aWindowRect.TopLeft();
 190                 Point aPos( aCellLoc.getX() + aWindowLoc.getX(), aCellLoc.getY() + aWindowLoc.getY() );
 191                 aScreenBounds.SetPos( aPos );
 192             }
 193         }
 194         else
 195         {
 196             aScreenBounds = mpWindow->GetWindowExtentsRelative( NULL );
 197         }
 198     }
 199
 200     return aScreenBounds;
 201 }
 202
 203 Rectangle ScAccessibleEditObject::GetBoundingBox() const
 204         throw (uno::RuntimeException, std::exception)
 205 {
 206     Rectangle aBounds( GetBoundingBoxOnScreen() );
 207
 208     if ( mpWindow )
 209     {
 210         uno::Reference< XAccessible > xThis( mpWindow->GetAccessible() );
 211         if ( xThis.is() )
 212         {
 213             uno::Reference< XAccessibleContext > xContext( xThis->getAccessibleContext() );
 214             if ( xContext.is() )
 215             {
 216                 uno::Reference< XAccessible > xParent( xContext->getAccessibleParent() );
 217                 if ( xParent.is() )
 218                 {
 219                     uno::Reference< XAccessibleComponent > xParentComponent( xParent->getAccessibleContext(), uno::UNO_QUERY );
 220                     if ( xParentComponent.is() )
 221                     {
 222                         Point aScreenLoc = aBounds.TopLeft();
 223                         awt::Point aParentScreenLoc = xParentComponent->getLocationOnScreen();
 224                         Point aPos( aScreenLoc.getX() - aParentScreenLoc.X, aScreenLoc.getY() - aParentScreenLoc.Y );
 225                         aBounds.SetPos( aPos );
 226                     }
 227                 }
 228             }
 229         }
 230     }
 231
 232     return aBounds;
 233 }
 234
 235     //=====  XAccessibleContext  ==============================================
 236
 237 sal_Int32 SAL_CALL
 238     ScAccessibleEditObject::getAccessibleChildCount()
 239                     throw (uno::RuntimeException, std::exception)
 240 {
 241     SolarMutexGuard aGuard;
 242     IsObjectValid();
 243     if (!mpTextHelper)
 244         CreateTextHelper();
 245     return mpTextHelper->GetChildCount();
 246 }
 247
 248 uno::Reference< XAccessible > SAL_CALL
 249     ScAccessibleEditObject::getAccessibleChild(sal_Int32 nIndex)
 250         throw (uno::RuntimeException,
 251         lang::IndexOutOfBoundsException, std::exception)
 252 {
 253     SolarMutexGuard aGuard;
 254     IsObjectValid();
 255     if (!mpTextHelper)
 256         CreateTextHelper();
 257     return mpTextHelper->GetChild(nIndex);
 258 }
 259
 260 uno::Reference<XAccessibleStateSet> SAL_CALL
 261     ScAccessibleEditObject::getAccessibleStateSet()
 262     throw (uno::RuntimeException, std::exception)
 263 {
 264     SolarMutexGuard aGuard;
 265     uno::Reference<XAccessibleStateSet> xParentStates;
 266     if (getAccessibleParent().is())
 267     {
 268         uno::Reference<XAccessibleContext> xParentContext = getAccessibleParent()->getAccessibleContext();
 269         xParentStates = xParentContext->getAccessibleStateSet();
 270     }
 271     utl::AccessibleStateSetHelper* pStateSet = new utl::AccessibleStateSetHelper();
 272     if (IsDefunc(xParentStates))
 273         pStateSet->AddState(AccessibleStateType::DEFUNC);
 274     else
 275     {
 276         // all states are const, because this object exists only in one state
 277         pStateSet->AddState(AccessibleStateType::EDITABLE);
 278         pStateSet->AddState(AccessibleStateType::ENABLED);
 279         pStateSet->AddState(AccessibleStateType::SENSITIVE);
 280         pStateSet->AddState(AccessibleStateType::MULTI_LINE);
 281         pStateSet->AddState(AccessibleStateType::MULTI_SELECTABLE);
 282         pStateSet->AddState(AccessibleStateType::SHOWING);
 283         pStateSet->AddState(AccessibleStateType::VISIBLE);
 284     }
 285     return pStateSet;
 286 }
 287
 288 OUString SAL_CALL
 289     ScAccessibleEditObject::createAccessibleDescription()
 290     throw (uno::RuntimeException)
 291 {
 292 //    OSL_FAIL("Should never be called, because is set in the constructor.")
 293     return OUString();
 294 }
 295
 296 OUString SAL_CALL
 297     ScAccessibleEditObject::createAccessibleName()
 298     throw (uno::RuntimeException, std::exception)
 299 {
 300     OSL_FAIL("Should never be called, because is set in the constructor.");
 301     return OUString();
 302 }
 303
 304     ///=====  XAccessibleEventBroadcaster  =====================================
 305
 306 void SAL_CALL
 307     ScAccessibleEditObject::addAccessibleEventListener(const uno::Reference<XAccessibleEventListener>& xListener)
 308         throw (uno::RuntimeException, std::exception)
 309 {
 310     if (!mpTextHelper)
 311         CreateTextHelper();
 312
 313     mpTextHelper->AddEventListener(xListener);
 314
 315     ScAccessibleContextBase::addAccessibleEventListener(xListener);
 316 }
 317
 318 void SAL_CALL
 319     ScAccessibleEditObject::removeAccessibleEventListener(const uno::Reference<XAccessibleEventListener>& xListener)
 320         throw (uno::RuntimeException, std::exception)
 321 {
 322     if (!mpTextHelper)
 323         CreateTextHelper();
 324
 325     mpTextHelper->RemoveEventListener(xListener);
 326
 327     ScAccessibleContextBase::removeAccessibleEventListener(xListener);
 328 }
 329
 330     //=====  XServiceInfo  ====================================================
 331
 332 OUString SAL_CALL ScAccessibleEditObject::getImplementationName()
 333         throw (uno::RuntimeException, std::exception)
 334 {
 335     return OUString("ScAccessibleEditObject");
 336 }
 337
 338 //=====  XTypeProvider  =======================================================
 339
 340 uno::Sequence<sal_Int8> SAL_CALL
 341     ScAccessibleEditObject::getImplementationId()
 342     throw (uno::RuntimeException, std::exception)
 343 {
 344     return css::uno::Sequence<sal_Int8>();
 345 }
 346
 347     //====  internal  =========================================================
 348
 349 bool ScAccessibleEditObject::IsDefunc(
 350     const uno::Reference<XAccessibleStateSet>& rxParentStates)
 351 {
 352     return ScAccessibleContextBase::IsDefunc() || !getAccessibleParent().is() ||
 353          (rxParentStates.is() && rxParentStates->contains(AccessibleStateType::DEFUNC));
 354 }
 355
 356 void ScAccessibleEditObject::CreateTextHelper()
 357 {
 358     if (!mpTextHelper)
 359     {
 360         ::std::unique_ptr < ScAccessibleTextData > pAccessibleTextData;
 361         if (meObjectType == CellInEditMode || meObjectType == EditControl)
 362         {
 363             pAccessibleTextData.reset
 364                 (new ScAccessibleEditObjectTextData(mpEditView, mpWindow));
 365         }
 366         else
 367         {
 368             pAccessibleTextData.reset
 369                 (new ScAccessibleEditLineTextData(NULL, mpWindow));
 370         }
 371
 372         ::std::unique_ptr< SvxEditSource > pEditSource (new ScAccessibilityEditSource(std::move(pAccessibleTextData)));
 373         mpTextHelper = new ::accessibility::AccessibleTextHelper(std::move(pEditSource));
 374         mpTextHelper->SetEventSource(this);
 375
 376         const ScInputHandler* pInputHdl = SC_MOD()->GetInputHdl();
 377         if ( pInputHdl && pInputHdl->IsEditMode() )
 378         {
 379             mpTextHelper->SetFocus(true);
 380         }
 381         else
 382         {
 383             mpTextHelper->SetFocus(mbHasFocus);
 384         }
 385
 386         // #i54814# activate cell in edit mode
 387         if( meObjectType == CellInEditMode )
 388         {
 389             // do not activate cell object, if top edit line is active
 390             if( pInputHdl && !pInputHdl->IsTopMode() )
 391             {
 392                 SdrHint aHint( HINT_BEGEDIT );
 393                 mpTextHelper->GetEditSource().GetBroadcaster().Broadcast( aHint );
 394             }
 395         }
 396     }
 397 }
 398
 399 sal_Int32 SAL_CALL ScAccessibleEditObject::getForeground(  )
 400         throw (::com::sun::star::uno::RuntimeException, std::exception)
 401 {
 402     return GetFgBgColor(OUString(SC_UNONAME_CCOLOR));
 403 }
 404
 405 sal_Int32 SAL_CALL ScAccessibleEditObject::getBackground(  )
 406         throw (::com::sun::star::uno::RuntimeException, std::exception)
 407 {
 408     return GetFgBgColor(OUString(SC_UNONAME_CELLBACK));
 409 }
 410
 411 sal_Int32 ScAccessibleEditObject::GetFgBgColor( const OUString &strPropColor)
 412 {
 413     SolarMutexGuard aGuard;
 414     sal_Int32 nColor(0);
 415     if (m_pScDoc)
 416     {
 417         SfxObjectShell* pObjSh = m_pScDoc->GetDocumentShell();
 418         if ( pObjSh )
 419         {
 420             uno::Reference <sheet::XSpreadsheetDocument> xSpreadDoc( pObjSh->GetModel(), uno::UNO_QUERY );
 421             if ( xSpreadDoc.is() )
 422             {
 423                 uno::Reference<sheet::XSpreadsheets> xSheets = xSpreadDoc->getSheets();
 424                 uno::Reference<container::XIndexAccess> xIndex( xSheets, uno::UNO_QUERY );
 425                 if ( xIndex.is() )
 426                 {
 427                     uno::Any aTable = xIndex->getByIndex(m_curCellAddress.Tab());
 428                     uno::Reference<sheet::XSpreadsheet> xTable;
 429                     if (aTable>>=xTable)
 430                     {
 431                         uno::Reference<table::XCell> xCell = xTable->getCellByPosition(m_curCellAddress.Col(), m_curCellAddress.Row());
 432                         if (xCell.is())
 433                         {
 434                             uno::Reference<beans::XPropertySet> xCellProps(xCell, uno::UNO_QUERY);
 435                             if (xCellProps.is())
 436                             {
 437                                 uno::Any aAny = xCellProps->getPropertyValue(strPropColor);
 438                                 aAny >>= nColor;
 439                             }
 440                         }
 441                     }
 442                 }
 443             }
 444         }
 445     }
 446     return nColor;
 447 }
 448 //=====  XAccessibleSelection  ============================================
 449
 450 void SAL_CALL ScAccessibleEditObject::selectAccessibleChild( sal_Int32 )
 451 throw ( IndexOutOfBoundsException, RuntimeException, std::exception )
 452 {
 453 }
 454
 455 sal_Bool SAL_CALL ScAccessibleEditObject::isAccessibleChildSelected( sal_Int32 nChildIndex )
 456 throw ( IndexOutOfBoundsException,
 457        RuntimeException, std::exception )
 458 {
 459     uno::Reference<XAccessible> xAcc = getAccessibleChild( nChildIndex );
 460     uno::Reference<XAccessibleContext> xContext;
 461     if( xAcc.is() )
 462         xContext = xAcc->getAccessibleContext();
 463     if( xContext.is() )
 464     {
 465         if( xContext->getAccessibleRole() == AccessibleRole::PARAGRAPH )
 466         {
 467             uno::Reference< ::com::sun::star::accessibility::XAccessibleText >
 468                 xText(xAcc, uno::UNO_QUERY);
 469             if( xText.is() )
 470             {
 471                 if( xText->getSelectionStart() >= 0 ) return sal_True;
 472             }
 473         }
 474     }
 475     return sal_False;
 476 }
 477
 478 void SAL_CALL ScAccessibleEditObject::clearAccessibleSelection(  )
 479 throw ( RuntimeException, std::exception )
 480 {
 481 }
 482
 483 void SAL_CALL ScAccessibleEditObject::selectAllAccessibleChildren(  )
 484 throw ( RuntimeException, std::exception )
 485 {
 486 }
 487
 488 sal_Int32 SAL_CALL ScAccessibleEditObject::getSelectedAccessibleChildCount()
 489 throw ( RuntimeException, std::exception )
 490 {
 491     sal_Int32 nCount = 0;
 492     sal_Int32 TotalCount = getAccessibleChildCount();
 493     for( sal_Int32 i = 0; i < TotalCount; i++ )
 494         if( isAccessibleChildSelected(i) ) nCount++;
 495     return nCount;
 496 }
 497
 498 uno::Reference<XAccessible> SAL_CALL ScAccessibleEditObject::getSelectedAccessibleChild( sal_Int32 nSelectedChildIndex )
 499 throw ( IndexOutOfBoundsException, RuntimeException, std::exception)
 500 {
 501     if ( nSelectedChildIndex > getSelectedAccessibleChildCount() )
 502         throw IndexOutOfBoundsException();
 503     sal_Int32 i1, i2;
 504     for( i1 = 0, i2 = 0; i1 < getAccessibleChildCount(); i1++ )
 505         if( isAccessibleChildSelected(i1) )
 506         {
 507             if( i2 == nSelectedChildIndex )
 508                 return getAccessibleChild( i1 );
 509             i2++;
 510         }
 511     return uno::Reference<XAccessible>();
 512 }
 513
 514 void SAL_CALL ScAccessibleEditObject::deselectAccessibleChild(
 515                                                             sal_Int32 )
 516                                                             throw ( IndexOutOfBoundsException,
 517                                                             RuntimeException, std::exception )
 518 {
 519 }
 520
 521 uno::Reference< XAccessibleRelationSet > ScAccessibleEditObject::getAccessibleRelationSet(  )
 522     throw (uno::RuntimeException, std::exception)
 523 {
 524     SolarMutexGuard aGuard;
 525     vcl::Window* pWindow = mpWindow;
 526     utl::AccessibleRelationSetHelper* rRelationSet = new utl::AccessibleRelationSetHelper;
 527     uno::Reference< XAccessibleRelationSet > rSet = rRelationSet;
 528     if ( pWindow )
 529     {
 530         vcl::Window *pLabeledBy = pWindow->GetAccessibleRelationLabeledBy();
 531         if ( pLabeledBy && pLabeledBy != pWindow )
 532         {
 533             uno::Sequence< uno::Reference< uno::XInterface > > aSequence(1);
 534             aSequence[0] = pLabeledBy->GetAccessible();
 535             rRelationSet->AddRelation( AccessibleRelation( AccessibleRelationType::LABELED_BY, aSequence ) );
 536         }
 537         vcl::Window* pMemberOf = pWindow->GetAccessibleRelationMemberOf();
 538         if ( pMemberOf && pMemberOf != pWindow )
 539         {
 540             uno::Sequence< uno::Reference< uno::XInterface > > aSequence(1);
 541             aSequence[0] = pMemberOf->GetAccessible();
 542             rRelationSet->AddRelation( AccessibleRelation( AccessibleRelationType::MEMBER_OF, aSequence ) );
 543         }
 544         return rSet;
 545     }
 546     return uno::Reference< XAccessibleRelationSet >();
 547 }
 548
 549 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */