1 /************************************************************** 2 * 3 * Licensed to the Apache Software Foundation (ASF) under one 4 * or more contributor license agreements. See the NOTICE file 5 * distributed with this work for additional information 6 * regarding copyright ownership. The ASF licenses this file 7 * to you under the Apache License, Version 2.0 (the 8 * "License"); you may not use this file except in compliance 9 * with the License. You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, 14 * software distributed under the License is distributed on an 15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 16 * KIND, either express or implied. See the License for the 17 * specific language governing permissions and limitations 18 * under the License. 19 * 20 *************************************************************/ 21 22 23 24 // MARKER(update_precomp.py): autogen include statement, do not remove 25 #include "precompiled_svx.hxx" 26 27 #include <accessiblecell.hxx> 28 29 #include "svx/DescriptionGenerator.hxx" 30 31 #include <com/sun/star/accessibility/AccessibleRole.hpp> 32 #include <com/sun/star/accessibility/AccessibleStateType.hpp> 33 34 #include <vcl/svapp.hxx> 35 36 #include <unotools/accessiblestatesethelper.hxx> 37 38 #include <editeng/outlobj.hxx> 39 #include <svx/unoshtxt.hxx> 40 #include <svx/svdotext.hxx> 41 42 using ::rtl::OUString; 43 using namespace ::sdr::table; 44 using namespace ::com::sun::star; 45 using namespace ::com::sun::star::uno; 46 using namespace ::com::sun::star::accessibility; 47 using namespace ::com::sun::star::lang; 48 using namespace ::com::sun::star::container; 49 50 namespace accessibility { 51 52 // -------------------------------------------------------------------- 53 // AccessibleCell 54 // -------------------------------------------------------------------- 55 56 AccessibleCell::AccessibleCell( const ::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessible>& rxParent, const sdr::table::CellRef& rCell, sal_Int32 nIndex, const AccessibleShapeTreeInfo& rShapeTreeInfo ) 57 : AccessibleCellBase( rxParent, AccessibleRole::TABLE_CELL ) 58 , maShapeTreeInfo( rShapeTreeInfo ) 59 , mnIndexInParent( nIndex ) 60 , mpText( NULL ) 61 , mxCell( rCell ) 62 { 63 //Init the pAccTable var 64 pAccTable = dynamic_cast <AccessibleTableShape *> (rxParent.get()); 65 } 66 67 // -------------------------------------------------------------------- 68 69 AccessibleCell::~AccessibleCell (void) 70 { 71 DBG_ASSERT( mpText == 0, "svx::AccessibleCell::~AccessibleCell(), not disposed!?" ); 72 } 73 74 // -------------------------------------------------------------------- 75 76 void AccessibleCell::Init (void) 77 { 78 SdrView* pView = maShapeTreeInfo.GetSdrView(); 79 const Window* pWindow = maShapeTreeInfo.GetWindow (); 80 if( (pView != NULL) && (pWindow != NULL) && mxCell.is()) 81 { 82 OutlinerParaObject* pOutlinerParaObject = mxCell->GetEditOutlinerParaObject(); // Get the OutlinerParaObject if text edit is active 83 84 bool bOwnParaObject = pOutlinerParaObject != 0; 85 86 if( !pOutlinerParaObject ) 87 pOutlinerParaObject = mxCell->GetOutlinerParaObject(); 88 89 // create AccessibleTextHelper to handle this shape's text 90 if( pOutlinerParaObject ) 91 { 92 // non-empty text -> use full-fledged edit source right away 93 ::std::auto_ptr<SvxEditSource> pEditSource( new SvxTextEditSource( mxCell->GetObject(), mxCell.get(), *pView, *pWindow) ); 94 mpText = new AccessibleTextHelper( pEditSource ); 95 mpText->SetEventSource(this); 96 } 97 98 if( bOwnParaObject) 99 delete pOutlinerParaObject; 100 } 101 } 102 103 // -------------------------------------------------------------------- 104 105 sal_Bool AccessibleCell::SetState (sal_Int16 aState) 106 { 107 sal_Bool bStateHasChanged = sal_False; 108 109 if (aState == AccessibleStateType::FOCUSED && mpText != NULL) 110 { 111 // Offer FOCUSED state to edit engine and detect whether the state 112 // changes. 113 sal_Bool bIsFocused = mpText->HaveFocus (); 114 mpText->SetFocus (sal_True); 115 bStateHasChanged = (bIsFocused != mpText->HaveFocus ()); 116 } 117 else 118 bStateHasChanged = AccessibleContextBase::SetState (aState); 119 120 return bStateHasChanged; 121 } 122 123 // -------------------------------------------------------------------- 124 125 sal_Bool AccessibleCell::ResetState (sal_Int16 aState) 126 { 127 sal_Bool bStateHasChanged = sal_False; 128 129 if (aState == AccessibleStateType::FOCUSED && mpText != NULL) 130 { 131 // Try to remove FOCUSED state from the edit engine and detect 132 // whether the state changes. 133 sal_Bool bIsFocused = mpText->HaveFocus (); 134 mpText->SetFocus (sal_False); 135 bStateHasChanged = (bIsFocused != mpText->HaveFocus ()); 136 } 137 else 138 bStateHasChanged = AccessibleContextBase::ResetState (aState); 139 140 return bStateHasChanged; 141 } 142 143 // -------------------------------------------------------------------- 144 145 sal_Bool AccessibleCell::GetState (sal_Int16 aState) 146 { 147 if (aState == AccessibleStateType::FOCUSED && mpText != NULL) 148 { 149 // Just delegate the call to the edit engine. The state is not 150 // merged into the state set. 151 return mpText->HaveFocus(); 152 } 153 else 154 return AccessibleContextBase::GetState (aState); 155 } 156 157 //----------------------------------------------------------------------------- 158 159 bool AccessibleCell::operator== (const AccessibleCell& rAccessibleCell) 160 { 161 return this == &rAccessibleCell; 162 } 163 164 //----------------------------------------------------------------------------- 165 // XInterface 166 //----------------------------------------------------------------------------- 167 168 Any SAL_CALL AccessibleCell::queryInterface( const Type& aType ) throw (RuntimeException) 169 { 170 return AccessibleCellBase::queryInterface( aType ); 171 } 172 173 //----------------------------------------------------------------------------- 174 175 void SAL_CALL AccessibleCell::acquire( ) throw () 176 { 177 AccessibleCellBase::acquire(); 178 } 179 180 //----------------------------------------------------------------------------- 181 182 void SAL_CALL AccessibleCell::release( ) throw () 183 { 184 AccessibleCellBase::release(); 185 } 186 187 // -------------------------------------------------------------------- 188 // XAccessibleContext 189 // -------------------------------------------------------------------- 190 191 /** The children of this cell come from the paragraphs of text. 192 */ 193 sal_Int32 SAL_CALL AccessibleCell::getAccessibleChildCount() throw (::com::sun::star::uno::RuntimeException) 194 { 195 ::vos::OGuard aSolarGuard (::Application::GetSolarMutex()); 196 ThrowIfDisposed (); 197 return mpText != NULL ? mpText->GetChildCount () : 0; 198 } 199 200 // -------------------------------------------------------------------- 201 202 /** Forward the request to the shape. Return the requested shape or throw 203 an exception for a wrong index. 204 */ 205 Reference<XAccessible> SAL_CALL AccessibleCell::getAccessibleChild (sal_Int32 nIndex) throw (IndexOutOfBoundsException, RuntimeException) 206 { 207 ::vos::OGuard aSolarGuard (::Application::GetSolarMutex()); 208 ThrowIfDisposed (); 209 210 // todo: does GetChild throw IndexOutOfBoundsException? 211 return mpText->GetChild (nIndex); 212 } 213 214 // -------------------------------------------------------------------- 215 216 /** Return a copy of the state set. 217 Possible states are: 218 ENABLED 219 SHOWING 220 VISIBLE 221 */ 222 Reference<XAccessibleStateSet> SAL_CALL AccessibleCell::getAccessibleStateSet (void) throw (RuntimeException) 223 { 224 ::vos::OGuard aSolarGuard (::Application::GetSolarMutex()); 225 ::osl::MutexGuard aGuard (maMutex); 226 Reference<XAccessibleStateSet> xStateSet; 227 228 if (rBHelper.bDisposed || mpText == NULL) 229 { 230 // Return a minimal state set that only contains the DEFUNC state. 231 xStateSet = AccessibleContextBase::getAccessibleStateSet (); 232 } 233 else 234 { 235 ::utl::AccessibleStateSetHelper* pStateSet = static_cast< ::utl::AccessibleStateSetHelper*>(mxStateSet.get()); 236 237 if(pStateSet) 238 { 239 // Merge current FOCUSED state from edit engine. 240 if (mpText != NULL) 241 { 242 if (mpText->HaveFocus()) 243 pStateSet->AddState (AccessibleStateType::FOCUSED); 244 else 245 pStateSet->RemoveState (AccessibleStateType::FOCUSED); 246 } 247 // Set the invisible state for merged cell 248 if (mxCell.is() && mxCell->isMerged()) 249 pStateSet->RemoveState(AccessibleStateType::VISIBLE); 250 else 251 pStateSet->AddState(AccessibleStateType::VISIBLE); 252 253 254 //Solution:Just when the parent table is not read-only,set states EDITABLE,RESIZABLE,MOVEABLE 255 ::com::sun::star::uno::Reference<XAccessible> xTempAcc = getAccessibleParent(); 256 if( xTempAcc.is() ) 257 { 258 ::com::sun::star::uno::Reference<XAccessibleContext> 259 xTempAccContext = xTempAcc->getAccessibleContext(); 260 if( xTempAccContext.is() ) 261 { 262 ::com::sun::star::uno::Reference<XAccessibleStateSet> rState = 263 xTempAccContext->getAccessibleStateSet(); 264 if( rState.is() ) { 265 com::sun::star::uno::Sequence<short> pStates = rState->getStates(); 266 int count = pStates.getLength(); 267 for( int iIndex = 0;iIndex < count;iIndex++ ) 268 { 269 if( pStates[iIndex] == AccessibleStateType::EDITABLE ) 270 { 271 pStateSet->AddState (AccessibleStateType::EDITABLE); 272 pStateSet->AddState (AccessibleStateType::RESIZABLE); 273 pStateSet->AddState (AccessibleStateType::MOVEABLE); 274 break; 275 } 276 } 277 } 278 } 279 } 280 // Create a copy of the state set that may be modified by the 281 // caller without affecting the current state set. 282 xStateSet = Reference<XAccessibleStateSet>(new ::utl::AccessibleStateSetHelper (*pStateSet)); 283 } 284 } 285 286 return xStateSet; 287 } 288 289 // -------------------------------------------------------------------- 290 // XAccessibleComponent 291 // -------------------------------------------------------------------- 292 293 sal_Bool SAL_CALL AccessibleCell::containsPoint( const ::com::sun::star::awt::Point& aPoint) throw (::com::sun::star::uno::RuntimeException) 294 { 295 return AccessibleComponentBase::containsPoint( aPoint ); 296 } 297 298 /** The implementation below is at the moment straightforward. It iterates 299 over all children (and thereby instances all children which have not 300 been already instatiated) until a child covering the specifed point is 301 found. 302 This leaves room for improvement. For instance, first iterate only over 303 the already instantiated children and only if no match is found 304 instantiate the remaining ones. 305 */ 306 Reference<XAccessible > SAL_CALL AccessibleCell::getAccessibleAtPoint ( const ::com::sun::star::awt::Point& aPoint) throw(RuntimeException) 307 { 308 ::vos::OGuard aSolarGuard (::Application::GetSolarMutex()); 309 ::osl::MutexGuard aGuard (maMutex); 310 311 sal_Int32 nChildCount = getAccessibleChildCount (); 312 for (sal_Int32 i=0; i<nChildCount; ++i) 313 { 314 Reference<XAccessible> xChild (getAccessibleChild (i)); 315 if (xChild.is()) 316 { 317 Reference<XAccessibleComponent> xChildComponent (xChild->getAccessibleContext(), uno::UNO_QUERY); 318 if (xChildComponent.is()) 319 { 320 awt::Rectangle aBBox (xChildComponent->getBounds()); 321 if ( (aPoint.X >= aBBox.X) 322 && (aPoint.Y >= aBBox.Y) 323 && (aPoint.X < aBBox.X+aBBox.Width) 324 && (aPoint.Y < aBBox.Y+aBBox.Height) ) 325 return xChild; 326 } 327 } 328 } 329 330 // Have not found a child under the given point. Returning empty 331 // reference to indicate this. 332 return uno::Reference<XAccessible>(); 333 } 334 335 // -------------------------------------------------------------------- 336 337 ::com::sun::star::awt::Rectangle SAL_CALL AccessibleCell::getBounds(void) throw(RuntimeException) 338 { 339 ::vos::OGuard aSolarGuard (::Application::GetSolarMutex()); 340 ::osl::MutexGuard aGuard (maMutex); 341 342 ThrowIfDisposed (); 343 ::com::sun::star::awt::Rectangle aBoundingBox; 344 if( mxCell.is() ) 345 { 346 // Get the cell's bounding box in internal coordinates (in 100th of mm) 347 const ::Rectangle aCellRect( mxCell->getCellRect() ); 348 349 // Transform coordinates from internal to pixel. 350 if (maShapeTreeInfo.GetViewForwarder() == NULL) 351 throw uno::RuntimeException (::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("AccessibleCell has no valid view forwarder")),static_cast<uno::XWeak*>(this)); 352 353 ::Size aPixelSize( maShapeTreeInfo.GetViewForwarder()->LogicToPixel(::Size(aCellRect.GetWidth(), aCellRect.GetHeight())) ); 354 ::Point aPixelPosition( maShapeTreeInfo.GetViewForwarder()->LogicToPixel( aCellRect.TopLeft() )); 355 356 // Clip the shape's bounding box with the bounding box of its parent. 357 Reference<XAccessibleComponent> xParentComponent ( getAccessibleParent(), uno::UNO_QUERY); 358 if (xParentComponent.is()) 359 { 360 // Make the coordinates relative to the parent. 361 awt::Point aParentLocation (xParentComponent->getLocationOnScreen()); 362 int x = aPixelPosition.getX() - aParentLocation.X; 363 int y = aPixelPosition.getY() - aParentLocation.Y; 364 365 // Clip with parent (with coordinates relative to itself). 366 ::Rectangle aBBox ( x, y, x + aPixelSize.getWidth(), y + aPixelSize.getHeight()); 367 awt::Size aParentSize (xParentComponent->getSize()); 368 ::Rectangle aParentBBox (0,0, aParentSize.Width, aParentSize.Height); 369 aBBox = aBBox.GetIntersection (aParentBBox); 370 aBoundingBox = awt::Rectangle ( aBBox.getX(), aBBox.getY(), aBBox.getWidth(), aBBox.getHeight()); 371 } 372 else 373 { 374 OSL_TRACE ("parent does not support component"); 375 aBoundingBox = awt::Rectangle (aPixelPosition.getX(), aPixelPosition.getY(),aPixelSize.getWidth(), aPixelSize.getHeight()); 376 } 377 } 378 379 return aBoundingBox; 380 } 381 382 // -------------------------------------------------------------------- 383 384 ::com::sun::star::awt::Point SAL_CALL AccessibleCell::getLocation(void) throw (RuntimeException) 385 { 386 ThrowIfDisposed (); 387 ::com::sun::star::awt::Rectangle aBoundingBox(getBounds()); 388 return ::com::sun::star::awt::Point(aBoundingBox.X, aBoundingBox.Y); 389 } 390 391 // -------------------------------------------------------------------- 392 393 ::com::sun::star::awt::Point SAL_CALL AccessibleCell::getLocationOnScreen(void) throw(RuntimeException) 394 { 395 ThrowIfDisposed (); 396 397 // Get relative position... 398 ::com::sun::star::awt::Point aLocation(getLocation ()); 399 400 // ... and add absolute position of the parent. 401 Reference<XAccessibleComponent> xParentComponent( getAccessibleParent(), uno::UNO_QUERY); 402 if(xParentComponent.is()) 403 { 404 ::com::sun::star::awt::Point aParentLocation(xParentComponent->getLocationOnScreen()); 405 aLocation.X += aParentLocation.X; 406 aLocation.Y += aParentLocation.Y; 407 } 408 else 409 { 410 OSL_TRACE ("getLocation: parent does not support XAccessibleComponent"); 411 } 412 413 return aLocation; 414 } 415 416 // -------------------------------------------------------------------- 417 418 awt::Size SAL_CALL AccessibleCell::getSize (void) throw (RuntimeException) 419 { 420 ThrowIfDisposed (); 421 awt::Rectangle aBoundingBox (getBounds()); 422 return awt::Size (aBoundingBox.Width, aBoundingBox.Height); 423 } 424 425 // -------------------------------------------------------------------- 426 427 void SAL_CALL AccessibleCell::addFocusListener ( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XFocusListener >& xListener) throw (::com::sun::star::uno::RuntimeException) 428 { 429 AccessibleComponentBase::addFocusListener( xListener ); 430 } 431 432 // -------------------------------------------------------------------- 433 434 void SAL_CALL AccessibleCell::removeFocusListener (const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XFocusListener >& xListener ) throw (::com::sun::star::uno::RuntimeException) 435 { 436 AccessibleComponentBase::removeFocusListener( xListener ); 437 } 438 439 // -------------------------------------------------------------------- 440 441 void SAL_CALL AccessibleCell::grabFocus (void) throw (::com::sun::star::uno::RuntimeException) 442 { 443 AccessibleComponentBase::grabFocus(); 444 } 445 446 // -------------------------------------------------------------------- 447 448 sal_Int32 SAL_CALL AccessibleCell::getForeground(void) throw (RuntimeException) 449 { 450 ThrowIfDisposed (); 451 sal_Int32 nColor (0x0ffffffL); 452 453 // todo 454 return nColor; 455 } 456 457 // -------------------------------------------------------------------- 458 459 sal_Int32 SAL_CALL AccessibleCell::getBackground (void) throw (RuntimeException) 460 { 461 ThrowIfDisposed (); 462 sal_Int32 nColor (0L); 463 464 // todo 465 return nColor; 466 } 467 468 // -------------------------------------------------------------------- 469 // XAccessibleExtendedComponent 470 // -------------------------------------------------------------------- 471 472 ::com::sun::star::uno::Reference< ::com::sun::star::awt::XFont > SAL_CALL AccessibleCell::getFont (void) throw (::com::sun::star::uno::RuntimeException) 473 { 474 //todo 475 return AccessibleComponentBase::getFont(); 476 } 477 478 // -------------------------------------------------------------------- 479 480 ::rtl::OUString SAL_CALL AccessibleCell::getTitledBorderText (void) throw (::com::sun::star::uno::RuntimeException) 481 { 482 return AccessibleComponentBase::getTitledBorderText(); 483 } 484 485 // -------------------------------------------------------------------- 486 487 ::rtl::OUString SAL_CALL AccessibleCell::getToolTipText (void) throw (::com::sun::star::uno::RuntimeException) 488 { 489 return AccessibleComponentBase::getToolTipText(); 490 } 491 492 // -------------------------------------------------------------------- 493 // XAccessibleEventBroadcaster 494 // -------------------------------------------------------------------- 495 496 void SAL_CALL AccessibleCell::addEventListener( const Reference<XAccessibleEventListener >& rxListener) throw (RuntimeException) 497 { 498 ::vos::OGuard aSolarGuard (::Application::GetSolarMutex()); 499 ::osl::MutexGuard aGuard (maMutex); 500 if (rBHelper.bDisposed || rBHelper.bInDispose) 501 { 502 Reference<XInterface> xSource( static_cast<XComponent *>(this) ); 503 lang::EventObject aEventObj(xSource); 504 rxListener->disposing(aEventObj); 505 } 506 else 507 { 508 AccessibleContextBase::addEventListener (rxListener); 509 if (mpText != NULL) 510 mpText->AddEventListener (rxListener); 511 } 512 } 513 514 // -------------------------------------------------------------------- 515 516 void SAL_CALL AccessibleCell::removeEventListener( const Reference<XAccessibleEventListener >& rxListener) throw (RuntimeException) 517 { 518 ::vos::OGuard aSolarGuard (::Application::GetSolarMutex()); 519 AccessibleContextBase::removeEventListener(rxListener); 520 if (mpText != NULL) 521 mpText->RemoveEventListener (rxListener); 522 } 523 524 // -------------------------------------------------------------------- 525 // XServiceInfo 526 // -------------------------------------------------------------------- 527 528 OUString SAL_CALL AccessibleCell::getImplementationName(void) throw (RuntimeException) 529 { 530 return OUString(RTL_CONSTASCII_USTRINGPARAM("AccessibleCell")); 531 } 532 533 // -------------------------------------------------------------------- 534 535 Sequence<OUString> SAL_CALL AccessibleCell::getSupportedServiceNames(void) throw (RuntimeException) 536 { 537 ThrowIfDisposed (); 538 539 // Get list of supported service names from base class... 540 uno::Sequence<OUString> aServiceNames = AccessibleContextBase::getSupportedServiceNames(); 541 sal_Int32 nCount (aServiceNames.getLength()); 542 543 // ...and add additional names. 544 aServiceNames.realloc (nCount + 1); 545 static const OUString sAdditionalServiceName (RTL_CONSTASCII_USTRINGPARAM("com.sun.star.drawing.AccessibleCell")); 546 aServiceNames[nCount] = sAdditionalServiceName; 547 548 return aServiceNames; 549 } 550 551 // -------------------------------------------------------------------- 552 // IAccessibleViewForwarderListener 553 // -------------------------------------------------------------------- 554 555 void AccessibleCell::ViewForwarderChanged (ChangeType /*aChangeType*/, const IAccessibleViewForwarder* /*pViewForwarder*/) 556 { 557 // Inform all listeners that the graphical representation (i.e. size 558 // and/or position) of the shape has changed. 559 CommitChange(AccessibleEventId::VISIBLE_DATA_CHANGED, Any(), Any()); 560 561 // update our children that our screen position might have changed 562 if( mpText ) 563 mpText->UpdateChildren(); 564 } 565 566 // -------------------------------------------------------------------- 567 // protected 568 // -------------------------------------------------------------------- 569 570 void AccessibleCell::disposing (void) 571 { 572 ::vos::OGuard aSolarGuard (::Application::GetSolarMutex()); 573 ::osl::MutexGuard aGuard (maMutex); 574 575 // Make sure to send an event that this object looses the focus in the 576 // case that it has the focus. 577 ::utl::AccessibleStateSetHelper* pStateSet = static_cast< ::utl::AccessibleStateSetHelper*>(mxStateSet.get()); 578 if (pStateSet != NULL) 579 pStateSet->RemoveState(AccessibleStateType::FOCUSED); 580 581 if (mpText != NULL) 582 { 583 mpText->Dispose(); 584 delete mpText; 585 mpText = NULL; 586 } 587 588 // Cleanup. Remove references to objects to allow them to be 589 // destroyed. 590 mxCell.clear(); 591 maShapeTreeInfo = AccessibleShapeTreeInfo(); 592 593 // Call base classes. 594 AccessibleContextBase::dispose (); 595 } 596 597 sal_Int32 SAL_CALL AccessibleCell::getAccessibleIndexInParent (void) throw (RuntimeException) 598 { 599 ThrowIfDisposed (); 600 return mnIndexInParent; 601 } 602 603 sdr::table::CellRef AccessibleCell::getCellRef() 604 { 605 return mxCell; 606 } 607 ::rtl::OUString AccessibleCell::getCellName( sal_Int32 nCol, sal_Int32 nRow ) 608 { 609 rtl::OUStringBuffer aBuf; 610 611 if (nCol < 26*26) 612 { 613 if (nCol < 26) 614 aBuf.append( static_cast<sal_Unicode>( 'A' + 615 static_cast<sal_uInt16>(nCol))); 616 else 617 { 618 aBuf.append( static_cast<sal_Unicode>( 'A' + 619 (static_cast<sal_uInt16>(nCol) / 26) - 1)); 620 aBuf.append( static_cast<sal_Unicode>( 'A' + 621 (static_cast<sal_uInt16>(nCol) % 26))); 622 } 623 } 624 else 625 { 626 String aStr; 627 while (nCol >= 26) 628 { 629 sal_Int32 nC = nCol % 26; 630 aStr += static_cast<sal_Unicode>( 'A' + 631 static_cast<sal_uInt16>(nC)); 632 nCol = nCol - nC; 633 nCol = nCol / 26 - 1; 634 } 635 aStr += static_cast<sal_Unicode>( 'A' + 636 static_cast<sal_uInt16>(nCol)); 637 aStr.Reverse(); 638 aBuf.append( aStr); 639 } 640 aBuf.append( OUString::valueOf(nRow+1) ); 641 return aBuf.makeStringAndClear(); 642 } 643 ::rtl::OUString SAL_CALL AccessibleCell::getAccessibleName (void) throw (::com::sun::star::uno::RuntimeException) 644 { 645 ThrowIfDisposed (); 646 ::vos::OGuard aSolarGuard (::Application::GetSolarMutex()); 647 648 if( pAccTable ) 649 try 650 { 651 sal_Int32 nRow = 0, nCol = 0; 652 pAccTable->getColumnAndRow(mnIndexInParent, nCol, nRow); 653 return getCellName( nCol, nRow ); 654 } 655 catch( Exception& ) 656 { 657 } 658 659 return AccessibleCellBase::getAccessibleName(); 660 } 661 void AccessibleCell::UpdateChildren() 662 { 663 if (mpText) 664 mpText->UpdateChildren(); 665 } 666 667 /* MT: Above getAccessibleName was introduced with IA2 CWS, while below was introduce in 3.3 meanwhile. Check which one is correct 668 If this is correct, we also don't need sdr::table::CellRef getCellRef(), UpdateChildren(), getCellName( sal_Int32 nCol, sal_Int32 nRow ) above 669 670 ::rtl::OUString SAL_CALL AccessibleCell::getAccessibleName (void) throw (::com::sun::star::uno::RuntimeException) 671 { 672 ThrowIfDisposed (); 673 ::vos::OGuard aSolarGuard (::Application::GetSolarMutex()); 674 675 if( mxCell.is() ) 676 return mxCell->getName(); 677 678 return AccessibleCellBase::getAccessibleName(); 679 } 680 */ 681 682 } // end of namespace accessibility 683