svtools/source/control/valueacc.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 <unotools/accessiblestatesethelper.hxx>
  21 #include <vcl/svapp.hxx>
  22 #include <svtools/valueset.hxx>
  23 #include "valueimp.hxx"
  24 #include <comphelper/servicehelper.hxx>
  25 #include <com/sun/star/accessibility/AccessibleEventId.hpp>
  26 #include <com/sun/star/accessibility/AccessibleRole.hpp>
  27 #include <com/sun/star/accessibility/AccessibleStateType.hpp>
  28
  29 using namespace ::com::sun::star;
  30
  31 // ----------------
  32 // - ValueSetItem -
  33 // ----------------
  34
  35 ValueSetItem::ValueSetItem( ValueSet& rParent )
  36     : mrParent(rParent)
  37     , mnId(0)
  38     , meType(VALUESETITEM_NONE)
  39     , mbVisible(true)
  40     , mpData(NULL)
  41     , mpxAcc(NULL)
  42 {
  43 }
  44
  45 // -----------------------------------------------------------------------
  46
  47 ValueSetItem::~ValueSetItem()
  48 {
  49     if( mpxAcc )
  50     {
  51         static_cast< ValueItemAcc* >( mpxAcc->get() )->ParentDestroyed();
  52         delete mpxAcc;
  53     }
  54 }
  55
  56 // -----------------------------------------------------------------------
  57
  58 uno::Reference< accessibility::XAccessible > ValueSetItem::GetAccessible( bool bIsTransientChildrenDisabled )
  59 {
  60     if( !mpxAcc )
  61         mpxAcc = new uno::Reference< accessibility::XAccessible >( new ValueItemAcc( this, bIsTransientChildrenDisabled ) );
  62
  63     return *mpxAcc;
  64 }
  65
  66 // ---------------
  67 // - ValueSetAcc -
  68 // ---------------
  69
  70 ValueSetAcc::ValueSetAcc( ValueSet* pParent, bool bIsTransientChildrenDisabled ) :
  71     ValueSetAccComponentBase (m_aMutex),
  72     mpParent( pParent ),
  73     mbIsTransientChildrenDisabled( bIsTransientChildrenDisabled ),
  74     mbIsFocused(false)
  75 {
  76 }
  77
  78 // -----------------------------------------------------------------------------
  79
  80 ValueSetAcc::~ValueSetAcc()
  81 {
  82 }
  83
  84 // -----------------------------------------------------------------------
  85
  86 void ValueSetAcc::FireAccessibleEvent( short nEventId, const uno::Any& rOldValue, const uno::Any& rNewValue )
  87 {
  88     if( nEventId )
  89     {
  90         ::std::vector< uno::Reference< accessibility::XAccessibleEventListener > >                  aTmpListeners( mxEventListeners );
  91         accessibility::AccessibleEventObject                                                        aEvtObject;
  92
  93         aEvtObject.EventId = nEventId;
  94         aEvtObject.Source = static_cast<uno::XWeak*>(this);
  95         aEvtObject.NewValue = rNewValue;
  96         aEvtObject.OldValue = rOldValue;
  97
  98         for (::std::vector< uno::Reference< accessibility::XAccessibleEventListener > >::const_iterator aIter( aTmpListeners.begin() );
  99             aIter != aTmpListeners.end() ; ++aIter)
 100         {
 101             try
 102             {
 103                 (*aIter)->notifyEvent( aEvtObject );
 104             }
 105             catch(const uno::Exception&)
 106             {
 107             }
 108         }
 109     }
 110 }
 111
 112 namespace
 113 {
 114     class theValueSetAccUnoTunnelId : public rtl::Static< UnoTunnelIdInit, theValueSetAccUnoTunnelId > {};
 115 }
 116
 117 const uno::Sequence< sal_Int8 >& ValueSetAcc::getUnoTunnelId()
 118 {
 119     return theValueSetAccUnoTunnelId::get().getSeq();
 120 }
 121
 122 // -----------------------------------------------------------------------------
 123
 124 ValueSetAcc* ValueSetAcc::getImplementation( const uno::Reference< uno::XInterface >& rxData )
 125     throw()
 126 {
 127     try
 128     {
 129         uno::Reference< lang::XUnoTunnel > xUnoTunnel( rxData, uno::UNO_QUERY );
 130         return( xUnoTunnel.is() ? reinterpret_cast<ValueSetAcc*>(sal::static_int_cast<sal_IntPtr>(xUnoTunnel->getSomething( ValueSetAcc::getUnoTunnelId() ))) : NULL );
 131     }
 132     catch(const ::com::sun::star::uno::Exception&)
 133     {
 134         return NULL;
 135     }
 136 }
 137
 138
 139 // -----------------------------------------------------------------------------
 140
 141 void ValueSetAcc::GetFocus (void)
 142 {
 143     mbIsFocused = true;
 144
 145     // Boradcast the state change.
 146     ::com::sun::star::uno::Any aOldState, aNewState;
 147     aNewState <<= ::com::sun::star::accessibility::AccessibleStateType::FOCUSED;
 148     FireAccessibleEvent(
 149         ::com::sun::star::accessibility::AccessibleEventId::STATE_CHANGED,
 150         aOldState, aNewState);
 151 }
 152
 153 // -----------------------------------------------------------------------------
 154
 155 void ValueSetAcc::LoseFocus (void)
 156 {
 157     mbIsFocused = false;
 158
 159     // Boradcast the state change.
 160     ::com::sun::star::uno::Any aOldState, aNewState;
 161     aOldState <<= ::com::sun::star::accessibility::AccessibleStateType::FOCUSED;
 162     FireAccessibleEvent(
 163         ::com::sun::star::accessibility::AccessibleEventId::STATE_CHANGED,
 164         aOldState, aNewState);
 165 }
 166
 167 // -----------------------------------------------------------------------------
 168
 169 uno::Reference< accessibility::XAccessibleContext > SAL_CALL ValueSetAcc::getAccessibleContext()
 170     throw (uno::RuntimeException)
 171 {
 172     ThrowIfDisposed();
 173     return this;
 174 }
 175
 176 // -----------------------------------------------------------------------------
 177
 178 sal_Int32 SAL_CALL ValueSetAcc::getAccessibleChildCount()
 179     throw (uno::RuntimeException)
 180 {
 181     const SolarMutexGuard aSolarGuard;
 182     ThrowIfDisposed();
 183
 184     sal_Int32 nCount = mpParent->ImplGetVisibleItemCount();
 185     if (HasNoneField())
 186         nCount += 1;
 187     return nCount;
 188 }
 189
 190 // -----------------------------------------------------------------------------
 191
 192 uno::Reference< accessibility::XAccessible > SAL_CALL ValueSetAcc::getAccessibleChild( sal_Int32 i )
 193     throw (lang::IndexOutOfBoundsException, uno::RuntimeException)
 194 {
 195     ThrowIfDisposed();
 196     const SolarMutexGuard aSolarGuard;
 197     uno::Reference< accessibility::XAccessible >    xRet;
 198     ValueSetItem* pItem = getItem (sal::static_int_cast< sal_uInt16 >(i));
 199
 200     if( pItem )
 201         xRet = pItem->GetAccessible( mbIsTransientChildrenDisabled );
 202     else
 203         throw lang::IndexOutOfBoundsException();
 204
 205     return xRet;
 206 }
 207
 208 // -----------------------------------------------------------------------------
 209
 210 uno::Reference< accessibility::XAccessible > SAL_CALL ValueSetAcc::getAccessibleParent()
 211     throw (uno::RuntimeException)
 212 {
 213     ThrowIfDisposed();
 214     const SolarMutexGuard aSolarGuard;
 215     Window*                                         pParent = mpParent->GetParent();
 216     uno::Reference< accessibility::XAccessible >    xRet;
 217
 218     if( pParent )
 219         xRet = pParent->GetAccessible();
 220
 221     return xRet;
 222 }
 223
 224 // -----------------------------------------------------------------------------
 225
 226 sal_Int32 SAL_CALL ValueSetAcc::getAccessibleIndexInParent()
 227     throw (uno::RuntimeException)
 228 {
 229     ThrowIfDisposed();
 230     const SolarMutexGuard aSolarGuard;
 231     Window*                 pParent = mpParent->GetParent();
 232     sal_Int32               nRet = 0;
 233
 234     if( pParent )
 235     {
 236         sal_Bool bFound = sal_False;
 237
 238         for( sal_uInt16 i = 0, nCount = pParent->GetChildCount(); ( i < nCount ) && !bFound; i++ )
 239         {
 240             if( pParent->GetChild( i ) == mpParent )
 241             {
 242                 nRet = i;
 243                 bFound = sal_True;
 244             }
 245         }
 246     }
 247
 248     return nRet;
 249 }
 250
 251 // -----------------------------------------------------------------------------
 252
 253 sal_Int16 SAL_CALL ValueSetAcc::getAccessibleRole()
 254     throw (uno::RuntimeException)
 255 {
 256     ThrowIfDisposed();
 257     // #i73746# As the Java Access Bridge (v 2.0.1) uses "managesDescendants"
 258     // always if the role is LIST, we need a different role in this case
 259     return (mbIsTransientChildrenDisabled
 260             ? accessibility::AccessibleRole::PANEL
 261             : accessibility::AccessibleRole::LIST );
 262 }
 263
 264 // -----------------------------------------------------------------------------
 265
 266 OUString SAL_CALL ValueSetAcc::getAccessibleDescription()
 267     throw (uno::RuntimeException)
 268 {
 269     ThrowIfDisposed();
 270     const SolarMutexGuard aSolarGuard;
 271     String              aRet( RTL_CONSTASCII_USTRINGPARAM( "ValueSet" ) );
 272
 273     return aRet;
 274 }
 275
 276 // -----------------------------------------------------------------------------
 277
 278 OUString SAL_CALL ValueSetAcc::getAccessibleName()
 279     throw (uno::RuntimeException)
 280 {
 281     ThrowIfDisposed();
 282     const SolarMutexGuard aSolarGuard;
 283     String              aRet;
 284
 285     if ( mpParent )
 286         aRet = mpParent->GetAccessibleName();
 287
 288     if ( !aRet.Len() )
 289     {
 290         Window* pLabel = mpParent->GetAccessibleRelationLabeledBy();
 291         if ( pLabel && pLabel != mpParent )
 292             aRet = OutputDevice::GetNonMnemonicString( pLabel->GetText() );
 293     }
 294
 295     return aRet;
 296 }
 297
 298 // -----------------------------------------------------------------------------
 299
 300 uno::Reference< accessibility::XAccessibleRelationSet > SAL_CALL ValueSetAcc::getAccessibleRelationSet()
 301     throw (uno::RuntimeException)
 302 {
 303     ThrowIfDisposed();
 304     return uno::Reference< accessibility::XAccessibleRelationSet >();
 305 }
 306
 307 // -----------------------------------------------------------------------------
 308
 309 uno::Reference< accessibility::XAccessibleStateSet > SAL_CALL ValueSetAcc::getAccessibleStateSet()
 310     throw (uno::RuntimeException)
 311 {
 312     ThrowIfDisposed();
 313     ::utl::AccessibleStateSetHelper* pStateSet = new ::utl::AccessibleStateSetHelper();
 314
 315     // Set some states.
 316     pStateSet->AddState (accessibility::AccessibleStateType::ENABLED);
 317     pStateSet->AddState (accessibility::AccessibleStateType::SENSITIVE);
 318     pStateSet->AddState (accessibility::AccessibleStateType::SHOWING);
 319     pStateSet->AddState (accessibility::AccessibleStateType::VISIBLE);
 320     if ( !mbIsTransientChildrenDisabled )
 321         pStateSet->AddState (accessibility::AccessibleStateType::MANAGES_DESCENDANTS);
 322     pStateSet->AddState (accessibility::AccessibleStateType::FOCUSABLE);
 323     if (mbIsFocused)
 324         pStateSet->AddState (accessibility::AccessibleStateType::FOCUSED);
 325
 326     return pStateSet;
 327 }
 328
 329 // -----------------------------------------------------------------------------
 330
 331 lang::Locale SAL_CALL ValueSetAcc::getLocale()
 332     throw (accessibility::IllegalAccessibleComponentStateException, uno::RuntimeException)
 333 {
 334     ThrowIfDisposed();
 335     const SolarMutexGuard aSolarGuard;
 336     const OUString                           aEmptyStr;
 337     uno::Reference< accessibility::XAccessible >    xParent( getAccessibleParent() );
 338     lang::Locale                                    aRet( aEmptyStr, aEmptyStr, aEmptyStr );
 339
 340     if( xParent.is() )
 341     {
 342         uno::Reference< accessibility::XAccessibleContext > xParentContext( xParent->getAccessibleContext() );
 343
 344         if( xParentContext.is() )
 345             aRet = xParentContext->getLocale ();
 346     }
 347
 348     return aRet;
 349 }
 350
 351 // -----------------------------------------------------------------------------
 352
 353 void SAL_CALL ValueSetAcc::addAccessibleEventListener( const uno::Reference< accessibility::XAccessibleEventListener >& rxListener )
 354     throw (uno::RuntimeException)
 355 {
 356     ThrowIfDisposed();
 357     ::osl::MutexGuard aGuard (m_aMutex);
 358
 359     if( rxListener.is() )
 360     {
 361            ::std::vector< uno::Reference< accessibility::XAccessibleEventListener > >::const_iterator aIter = mxEventListeners.begin();
 362         sal_Bool bFound = sal_False;
 363
 364         while( !bFound && ( aIter != mxEventListeners.end() ) )
 365         {
 366             if( *aIter == rxListener )
 367                 bFound = sal_True;
 368             else
 369                 ++aIter;
 370         }
 371
 372         if (!bFound)
 373             mxEventListeners.push_back( rxListener );
 374     }
 375 }
 376
 377 // -----------------------------------------------------------------------------
 378
 379 void SAL_CALL ValueSetAcc::removeAccessibleEventListener( const uno::Reference< accessibility::XAccessibleEventListener >& rxListener )
 380     throw (uno::RuntimeException)
 381 {
 382     ThrowIfDisposed();
 383     ::osl::MutexGuard aGuard (m_aMutex);
 384
 385     if( rxListener.is() )
 386     {
 387            ::std::vector< uno::Reference< accessibility::XAccessibleEventListener > >::iterator aIter = mxEventListeners.begin();
 388         sal_Bool bFound = sal_False;
 389
 390         while( !bFound && ( aIter != mxEventListeners.end() ) )
 391         {
 392             if( *aIter == rxListener )
 393             {
 394                 mxEventListeners.erase( aIter );
 395                 bFound = sal_True;
 396             }
 397             else
 398                 ++aIter;
 399         }
 400     }
 401 }
 402
 403 // -----------------------------------------------------------------------------
 404
 405 sal_Bool SAL_CALL ValueSetAcc::containsPoint( const awt::Point& aPoint )
 406     throw (uno::RuntimeException)
 407 {
 408     ThrowIfDisposed();
 409     const awt::Rectangle    aRect( getBounds() );
 410     const Point             aSize( aRect.Width, aRect.Height );
 411     const Point             aNullPoint, aTestPoint( aPoint.X, aPoint.Y );
 412
 413     return Rectangle( aNullPoint, aSize ).IsInside( aTestPoint );
 414 }
 415
 416 // -----------------------------------------------------------------------------
 417
 418 uno::Reference< accessibility::XAccessible > SAL_CALL ValueSetAcc::getAccessibleAtPoint( const awt::Point& aPoint )
 419     throw (uno::RuntimeException)
 420 {
 421     ThrowIfDisposed();
 422     const SolarMutexGuard aSolarGuard;
 423     const sal_uInt16                                    nItemId = mpParent->GetItemId( Point( aPoint.X, aPoint.Y ) );
 424     uno::Reference< accessibility::XAccessible >    xRet;
 425
 426     if ( nItemId )
 427     {
 428         const size_t nItemPos = mpParent->GetItemPos( nItemId );
 429
 430         if( VALUESET_ITEM_NONEITEM != nItemPos )
 431         {
 432             ValueSetItem *const pItem = mpParent->mItemList[nItemPos];
 433             xRet = pItem->GetAccessible( mbIsTransientChildrenDisabled );
 434         }
 435     }
 436
 437     return xRet;
 438 }
 439
 440 // -----------------------------------------------------------------------------
 441
 442 awt::Rectangle SAL_CALL ValueSetAcc::getBounds()
 443     throw (uno::RuntimeException)
 444 {
 445     ThrowIfDisposed();
 446     const SolarMutexGuard aSolarGuard;
 447     const Point         aOutPos( mpParent->GetPosPixel() );
 448     const Size          aOutSize( mpParent->GetOutputSizePixel() );
 449     awt::Rectangle      aRet;
 450
 451     aRet.X = aOutPos.X();
 452     aRet.Y = aOutPos.Y();
 453     aRet.Width = aOutSize.Width();
 454     aRet.Height = aOutSize.Height();
 455
 456     return aRet;
 457 }
 458
 459 // -----------------------------------------------------------------------------
 460
 461 awt::Point SAL_CALL ValueSetAcc::getLocation()
 462     throw (uno::RuntimeException)
 463 {
 464     ThrowIfDisposed();
 465     const awt::Rectangle    aRect( getBounds() );
 466     awt::Point              aRet;
 467
 468     aRet.X = aRect.X;
 469     aRet.Y = aRect.Y;
 470
 471     return aRet;
 472 }
 473
 474 // -----------------------------------------------------------------------------
 475
 476 awt::Point SAL_CALL ValueSetAcc::getLocationOnScreen()
 477     throw (uno::RuntimeException)
 478 {
 479     ThrowIfDisposed();
 480     const SolarMutexGuard aSolarGuard;
 481     const Point         aScreenPos( mpParent->OutputToAbsoluteScreenPixel( Point() ) );
 482     awt::Point          aRet;
 483
 484     aRet.X = aScreenPos.X();
 485     aRet.Y = aScreenPos.Y();
 486
 487     return aRet;
 488 }
 489
 490 // -----------------------------------------------------------------------------
 491
 492 awt::Size SAL_CALL ValueSetAcc::getSize()
 493     throw (uno::RuntimeException)
 494 {
 495     ThrowIfDisposed();
 496     const awt::Rectangle    aRect( getBounds() );
 497     awt::Size               aRet;
 498
 499     aRet.Width = aRect.Width;
 500     aRet.Height = aRect.Height;
 501
 502     return aRet;
 503 }
 504
 505 // -----------------------------------------------------------------------------
 506
 507 void SAL_CALL ValueSetAcc::grabFocus()
 508     throw (uno::RuntimeException)
 509 {
 510     ThrowIfDisposed();
 511     const SolarMutexGuard aSolarGuard;
 512     mpParent->GrabFocus();
 513 }
 514
 515 // -----------------------------------------------------------------------------
 516
 517 uno::Any SAL_CALL ValueSetAcc::getAccessibleKeyBinding()
 518     throw (uno::RuntimeException)
 519 {
 520     ThrowIfDisposed();
 521     return uno::Any();
 522 }
 523
 524 // -----------------------------------------------------------------------------
 525
 526 sal_Int32 SAL_CALL ValueSetAcc::getForeground(  )
 527     throw (uno::RuntimeException)
 528 {
 529     ThrowIfDisposed();
 530     sal_uInt32 nColor = Application::GetSettings().GetStyleSettings().GetWindowTextColor().GetColor();
 531     return static_cast<sal_Int32>(nColor);
 532 }
 533
 534 // -----------------------------------------------------------------------------
 535
 536 sal_Int32 SAL_CALL ValueSetAcc::getBackground(  )
 537     throw (uno::RuntimeException)
 538 {
 539     ThrowIfDisposed();
 540     sal_uInt32 nColor = Application::GetSettings().GetStyleSettings().GetWindowColor().GetColor();
 541     return static_cast<sal_Int32>(nColor);
 542 }
 543
 544 // -----------------------------------------------------------------------------
 545
 546 void SAL_CALL ValueSetAcc::selectAccessibleChild( sal_Int32 nChildIndex )
 547     throw (lang::IndexOutOfBoundsException, uno::RuntimeException)
 548 {
 549     ThrowIfDisposed();
 550     const SolarMutexGuard aSolarGuard;
 551     ValueSetItem* pItem = getItem (sal::static_int_cast< sal_uInt16 >(nChildIndex));
 552
 553     if(pItem != NULL)
 554     {
 555         mpParent->SelectItem( pItem->mnId );
 556         mpParent->Select ();
 557     }
 558     else
 559         throw lang::IndexOutOfBoundsException();
 560 }
 561
 562 // -----------------------------------------------------------------------------
 563
 564 sal_Bool SAL_CALL ValueSetAcc::isAccessibleChildSelected( sal_Int32 nChildIndex )
 565     throw (lang::IndexOutOfBoundsException, uno::RuntimeException)
 566 {
 567     ThrowIfDisposed();
 568     const SolarMutexGuard aSolarGuard;
 569     ValueSetItem* pItem = getItem (sal::static_int_cast< sal_uInt16 >(nChildIndex));
 570     sal_Bool            bRet = sal_False;
 571
 572     if (pItem != NULL)
 573         bRet = mpParent->IsItemSelected( pItem->mnId );
 574     else
 575         throw lang::IndexOutOfBoundsException();
 576
 577     return bRet;
 578 }
 579
 580 // -----------------------------------------------------------------------------
 581
 582 void SAL_CALL ValueSetAcc::clearAccessibleSelection()
 583     throw (uno::RuntimeException)
 584 {
 585     ThrowIfDisposed();
 586     const SolarMutexGuard aSolarGuard;
 587     mpParent->SetNoSelection();
 588 }
 589
 590 // -----------------------------------------------------------------------------
 591
 592 void SAL_CALL ValueSetAcc::selectAllAccessibleChildren()
 593     throw (uno::RuntimeException)
 594 {
 595     ThrowIfDisposed();
 596     // unsupported due to single selection only
 597 }
 598
 599 // -----------------------------------------------------------------------------
 600
 601 sal_Int32 SAL_CALL ValueSetAcc::getSelectedAccessibleChildCount()
 602     throw (uno::RuntimeException)
 603 {
 604     ThrowIfDisposed();
 605     const SolarMutexGuard aSolarGuard;
 606     sal_Int32           nRet = 0;
 607
 608     for( sal_uInt16 i = 0, nCount = getItemCount(); i < nCount; i++ )
 609     {
 610         ValueSetItem* pItem = getItem (i);
 611
 612         if( pItem && mpParent->IsItemSelected( pItem->mnId ) )
 613             ++nRet;
 614     }
 615
 616     return nRet;
 617 }
 618
 619 // -----------------------------------------------------------------------------
 620
 621 uno::Reference< accessibility::XAccessible > SAL_CALL ValueSetAcc::getSelectedAccessibleChild( sal_Int32 nSelectedChildIndex )
 622     throw (lang::IndexOutOfBoundsException, uno::RuntimeException)
 623 {
 624     ThrowIfDisposed();
 625     const SolarMutexGuard aSolarGuard;
 626     uno::Reference< accessibility::XAccessible >    xRet;
 627
 628     for( sal_uInt16 i = 0, nCount = getItemCount(), nSel = 0; ( i < nCount ) && !xRet.is(); i++ )
 629     {
 630         ValueSetItem* pItem = getItem(i);
 631
 632         if( pItem && mpParent->IsItemSelected( pItem->mnId ) && ( nSelectedChildIndex == static_cast< sal_Int32 >( nSel++ ) ) )
 633             xRet = pItem->GetAccessible( mbIsTransientChildrenDisabled );
 634     }
 635
 636     return xRet;
 637 }
 638
 639 // -----------------------------------------------------------------------------
 640
 641 void SAL_CALL ValueSetAcc::deselectAccessibleChild( sal_Int32 nChildIndex )
 642     throw (lang::IndexOutOfBoundsException, uno::RuntimeException)
 643 {
 644     ThrowIfDisposed();
 645     const SolarMutexGuard aSolarGuard;
 646     // Because of the single selection we can reset the whole selection when
 647     // the specified child is currently selected.
 648     if (isAccessibleChildSelected(nChildIndex))
 649         mpParent->SetNoSelection();
 650 }
 651
 652 // -----------------------------------------------------------------------------
 653
 654 sal_Int64 SAL_CALL ValueSetAcc::getSomething( const uno::Sequence< sal_Int8 >& rId ) throw( uno::RuntimeException )
 655 {
 656     sal_Int64 nRet;
 657
 658     if( ( rId.getLength() == 16 ) && ( 0 == memcmp( ValueSetAcc::getUnoTunnelId().getConstArray(), rId.getConstArray(), 16 ) ) )
 659         nRet = reinterpret_cast< sal_Int64 >( this );
 660     else
 661         nRet = 0;
 662
 663     return nRet;
 664 }
 665
 666
 667
 668
 669 void SAL_CALL ValueSetAcc::disposing (void)
 670 {
 671     ::std::vector<uno::Reference<accessibility::XAccessibleEventListener> > aListenerListCopy;
 672
 673     {
 674         // Make a copy of the list and clear the original.
 675         const SolarMutexGuard aSolarGuard;
 676         ::osl::MutexGuard aGuard (m_aMutex);
 677         aListenerListCopy = mxEventListeners;
 678         mxEventListeners.clear();
 679
 680         // Reset the pointer to the parent.  It has to be the one who has
 681         // disposed us because he is dying.
 682         mpParent = NULL;
 683     }
 684
 685     // Inform all listeners that this objects is disposing.
 686     ::std::vector<uno::Reference<accessibility::XAccessibleEventListener> >::const_iterator
 687           aListenerIterator (aListenerListCopy.begin());
 688     lang::EventObject aEvent (static_cast<accessibility::XAccessible*>(this));
 689     while (aListenerIterator != aListenerListCopy.end())
 690     {
 691         try
 692         {
 693             (*aListenerIterator)->disposing (aEvent);
 694         }
 695         catch(const uno::Exception&)
 696         {
 697             // Ignore exceptions.
 698         }
 699
 700         ++aListenerIterator;
 701     }
 702 }
 703
 704
 705 sal_uInt16 ValueSetAcc::getItemCount (void) const
 706 {
 707     sal_uInt16 nCount = mpParent->ImplGetVisibleItemCount();
 708     // When the None-Item is visible then increase the number of items by
 709     // one.
 710     if (HasNoneField())
 711         nCount += 1;
 712     return nCount;
 713 }
 714
 715
 716 ValueSetItem* ValueSetAcc::getItem (sal_uInt16 nIndex) const
 717 {
 718     ValueSetItem* pItem = NULL;
 719
 720     if (HasNoneField())
 721     {
 722         if (nIndex == 0)
 723             // When present the first item is the then always visible none field.
 724             pItem = mpParent->ImplGetItem (VALUESET_ITEM_NONEITEM);
 725         else
 726             // Shift down the index to compensate for the none field.
 727             nIndex -= 1;
 728     }
 729     if (pItem == NULL)
 730         pItem = mpParent->ImplGetVisibleItem (static_cast<sal_uInt16>(nIndex));
 731
 732     return pItem;
 733 }
 734
 735
 736
 737
 738 void ValueSetAcc::ThrowIfDisposed (void)
 739     throw (::com::sun::star::lang::DisposedException)
 740 {
 741     if (rBHelper.bDisposed || rBHelper.bInDispose)
 742     {
 743         OSL_TRACE ("Calling disposed object. Throwing exception:");
 744         throw lang::DisposedException (
 745             OUString("object has been already disposed"),
 746             static_cast<uno::XWeak*>(this));
 747     }
 748     else
 749     {
 750         DBG_ASSERT (mpParent!=NULL, "ValueSetAcc not disposed but mpParent == NULL");
 751     }
 752 }
 753
 754
 755
 756 bool ValueSetAcc::HasNoneField (void) const
 757 {
 758     DBG_ASSERT (mpParent!=NULL, "ValueSetAcc::HasNoneField called with mpParent==NULL");
 759     return ((mpParent->GetStyle() & WB_NONEFIELD) != 0);
 760 }
 761
 762
 763
 764
 765 // ----------------
 766 // - ValueItemAcc -
 767 // ----------------
 768
 769 ValueItemAcc::ValueItemAcc( ValueSetItem* pParent, bool bIsTransientChildrenDisabled ) :
 770     mpParent( pParent ),
 771     mbIsTransientChildrenDisabled( bIsTransientChildrenDisabled )
 772 {
 773 }
 774
 775 // -----------------------------------------------------------------------------
 776
 777 ValueItemAcc::~ValueItemAcc()
 778 {
 779 }
 780
 781 // -----------------------------------------------------------------------
 782
 783 void ValueItemAcc::FireAccessibleEvent( short nEventId, const uno::Any& rOldValue, const uno::Any& rNewValue )
 784 {
 785     if( nEventId )
 786     {
 787         ::std::vector< uno::Reference< accessibility::XAccessibleEventListener > >                  aTmpListeners( mxEventListeners );
 788         accessibility::AccessibleEventObject                                                        aEvtObject;
 789
 790         aEvtObject.EventId = nEventId;
 791         aEvtObject.Source = static_cast<uno::XWeak*>(this);
 792         aEvtObject.NewValue = rNewValue;
 793         aEvtObject.OldValue = rOldValue;
 794
 795         for (::std::vector< uno::Reference< accessibility::XAccessibleEventListener > >::const_iterator aIter( aTmpListeners.begin() );
 796              aIter != aTmpListeners.end() ; ++aIter)
 797         {
 798             (*aIter)->notifyEvent( aEvtObject );
 799         }
 800     }
 801 }
 802
 803 // -----------------------------------------------------------------------------
 804
 805 void ValueItemAcc::ParentDestroyed()
 806 {
 807     const ::osl::MutexGuard aGuard( maMutex );
 808     mpParent = NULL;
 809 }
 810
 811 namespace
 812 {
 813     class theValueItemAccUnoTunnelId : public rtl::Static< UnoTunnelIdInit, theValueItemAccUnoTunnelId > {};
 814 }
 815
 816 const uno::Sequence< sal_Int8 >& ValueItemAcc::getUnoTunnelId()
 817 {
 818     return theValueItemAccUnoTunnelId::get().getSeq();
 819 }
 820
 821 // -----------------------------------------------------------------------------
 822
 823 ValueItemAcc* ValueItemAcc::getImplementation( const uno::Reference< uno::XInterface >& rxData )
 824     throw()
 825 {
 826     try
 827     {
 828         uno::Reference< lang::XUnoTunnel > xUnoTunnel( rxData, uno::UNO_QUERY );
 829         return( xUnoTunnel.is() ? reinterpret_cast<ValueItemAcc*>(sal::static_int_cast<sal_IntPtr>(xUnoTunnel->getSomething( ValueItemAcc::getUnoTunnelId() ))) : NULL );
 830     }
 831     catch(const ::com::sun::star::uno::Exception&)
 832     {
 833         return NULL;
 834     }
 835 }
 836
 837 // -----------------------------------------------------------------------------
 838
 839 uno::Reference< accessibility::XAccessibleContext > SAL_CALL ValueItemAcc::getAccessibleContext()
 840     throw (uno::RuntimeException)
 841 {
 842     return this;
 843 }
 844
 845 // -----------------------------------------------------------------------------
 846
 847 sal_Int32 SAL_CALL ValueItemAcc::getAccessibleChildCount()
 848     throw (uno::RuntimeException)
 849 {
 850     return 0;
 851 }
 852
 853 // -----------------------------------------------------------------------------
 854
 855 uno::Reference< accessibility::XAccessible > SAL_CALL ValueItemAcc::getAccessibleChild( sal_Int32 )
 856     throw (lang::IndexOutOfBoundsException, uno::RuntimeException)
 857 {
 858     throw lang::IndexOutOfBoundsException();
 859 }
 860
 861 // -----------------------------------------------------------------------------
 862
 863 uno::Reference< accessibility::XAccessible > SAL_CALL ValueItemAcc::getAccessibleParent()
 864     throw (uno::RuntimeException)
 865 {
 866     const SolarMutexGuard aSolarGuard;
 867     uno::Reference< accessibility::XAccessible >    xRet;
 868
 869     if( mpParent )
 870         xRet = mpParent->mrParent.GetAccessible();
 871
 872     return xRet;
 873 }
 874
 875 // -----------------------------------------------------------------------------
 876
 877 sal_Int32 SAL_CALL ValueItemAcc::getAccessibleIndexInParent()
 878     throw (uno::RuntimeException)
 879 {
 880     const SolarMutexGuard aSolarGuard;
 881     // The index defaults to -1 to indicate the child does not belong to its
 882     // parent.
 883     sal_Int32 nIndexInParent = -1;
 884
 885     if( mpParent )
 886     {
 887         bool bDone = false;
 888
 889         sal_uInt16 nCount = mpParent->mrParent.ImplGetVisibleItemCount();
 890         ValueSetItem* pItem;
 891         for (sal_uInt16 i=0; i<nCount && !bDone; i++)
 892         {
 893             // Guard the retrieval of the i-th child with a try/catch block
 894             // just in case the number of children changes in the mean time.
 895             try
 896             {
 897                 pItem = mpParent->mrParent.ImplGetVisibleItem (i);
 898             }
 899             catch (const lang::IndexOutOfBoundsException&)
 900             {
 901                 pItem = NULL;
 902             }
 903
 904             // Do not create an accessible object for the test.
 905             if (pItem != NULL && pItem->mpxAcc != NULL)
 906                 if (pItem->GetAccessible( mbIsTransientChildrenDisabled ).get() == this )
 907                 {
 908                     nIndexInParent = i;
 909                     bDone = true;
 910                 }
 911         }
 912     }
 913
 914     return nIndexInParent;
 915 }
 916
 917 // -----------------------------------------------------------------------------
 918
 919 sal_Int16 SAL_CALL ValueItemAcc::getAccessibleRole()
 920     throw (uno::RuntimeException)
 921 {
 922     return accessibility::AccessibleRole::LIST_ITEM;
 923 }
 924
 925 // -----------------------------------------------------------------------------
 926
 927 OUString SAL_CALL ValueItemAcc::getAccessibleDescription()
 928     throw (uno::RuntimeException)
 929 {
 930     return OUString();
 931 }
 932
 933 // -----------------------------------------------------------------------------
 934
 935 OUString SAL_CALL ValueItemAcc::getAccessibleName()
 936     throw (uno::RuntimeException)
 937 {
 938     const SolarMutexGuard aSolarGuard;
 939     OUString aRet;
 940
 941     if( mpParent )
 942     {
 943         aRet = mpParent->maText;
 944
 945         if( aRet.isEmpty() )
 946         {
 947             OUStringBuffer aBuffer("Item ");
 948             aBuffer.append(static_cast<sal_Int32>(mpParent->mnId));
 949             aRet = aBuffer.makeStringAndClear();
 950         }
 951     }
 952
 953     return aRet;
 954 }
 955
 956 // -----------------------------------------------------------------------------
 957
 958 uno::Reference< accessibility::XAccessibleRelationSet > SAL_CALL ValueItemAcc::getAccessibleRelationSet()
 959     throw (uno::RuntimeException)
 960 {
 961     return uno::Reference< accessibility::XAccessibleRelationSet >();
 962 }
 963
 964 // -----------------------------------------------------------------------------
 965
 966 uno::Reference< accessibility::XAccessibleStateSet > SAL_CALL ValueItemAcc::getAccessibleStateSet()
 967     throw (uno::RuntimeException)
 968 {
 969     const SolarMutexGuard aSolarGuard;
 970     ::utl::AccessibleStateSetHelper*    pStateSet = new ::utl::AccessibleStateSetHelper;
 971
 972     if( mpParent )
 973     {
 974         pStateSet->AddState (accessibility::AccessibleStateType::ENABLED);
 975         pStateSet->AddState (accessibility::AccessibleStateType::SENSITIVE);
 976         pStateSet->AddState (accessibility::AccessibleStateType::SHOWING);
 977         pStateSet->AddState (accessibility::AccessibleStateType::VISIBLE);
 978         if ( !mbIsTransientChildrenDisabled )
 979             pStateSet->AddState (accessibility::AccessibleStateType::TRANSIENT);
 980
 981         // SELECTABLE
 982         pStateSet->AddState( accessibility::AccessibleStateType::SELECTABLE );
 983         //      pStateSet->AddState( accessibility::AccessibleStateType::FOCUSABLE );
 984
 985         // SELECTED
 986         if( mpParent->mrParent.GetSelectItemId() == mpParent->mnId )
 987         {
 988             pStateSet->AddState( accessibility::AccessibleStateType::SELECTED );
 989             //              pStateSet->AddState( accessibility::AccessibleStateType::FOCUSED );
 990         }
 991     }
 992
 993     return pStateSet;
 994 }
 995
 996 // -----------------------------------------------------------------------------
 997
 998 lang::Locale SAL_CALL ValueItemAcc::getLocale()
 999     throw (accessibility::IllegalAccessibleComponentStateException, uno::RuntimeException)
1000 {
1001     const SolarMutexGuard aSolarGuard;
1002     const OUString                           aEmptyStr;
1003     uno::Reference< accessibility::XAccessible >    xParent( getAccessibleParent() );
1004     lang::Locale                                    aRet( aEmptyStr, aEmptyStr, aEmptyStr );
1005
1006     if( xParent.is() )
1007     {
1008         uno::Reference< accessibility::XAccessibleContext > xParentContext( xParent->getAccessibleContext() );
1009
1010         if( xParentContext.is() )
1011             aRet = xParentContext->getLocale();
1012     }
1013
1014     return aRet;
1015 }
1016
1017 // -----------------------------------------------------------------------------
1018
1019 void SAL_CALL ValueItemAcc::addAccessibleEventListener( const uno::Reference< accessibility::XAccessibleEventListener >& rxListener )
1020     throw (uno::RuntimeException)
1021 {
1022     const ::osl::MutexGuard aGuard( maMutex );
1023
1024     if( rxListener.is() )
1025     {
1026            ::std::vector< uno::Reference< accessibility::XAccessibleEventListener > >::const_iterator aIter = mxEventListeners.begin();
1027         sal_Bool bFound = sal_False;
1028
1029         while( !bFound && ( aIter != mxEventListeners.end() ) )
1030         {
1031             if( *aIter == rxListener )
1032                 bFound = sal_True;
1033             else
1034                 ++aIter;
1035         }
1036
1037         if (!bFound)
1038             mxEventListeners.push_back( rxListener );
1039     }
1040 }
1041
1042 // -----------------------------------------------------------------------------
1043
1044 void SAL_CALL ValueItemAcc::removeAccessibleEventListener( const uno::Reference< accessibility::XAccessibleEventListener >& rxListener )
1045     throw (uno::RuntimeException)
1046 {
1047     const ::osl::MutexGuard aGuard( maMutex );
1048
1049     if( rxListener.is() )
1050     {
1051            ::std::vector< uno::Reference< accessibility::XAccessibleEventListener > >::iterator aIter = mxEventListeners.begin();
1052         sal_Bool bFound = sal_False;
1053
1054         while( !bFound && ( aIter != mxEventListeners.end() ) )
1055         {
1056             if( *aIter == rxListener )
1057             {
1058                 mxEventListeners.erase( aIter );
1059                 bFound = sal_True;
1060             }
1061             else
1062                 ++aIter;
1063         }
1064     }
1065 }
1066
1067 // -----------------------------------------------------------------------------
1068
1069 sal_Bool SAL_CALL ValueItemAcc::containsPoint( const awt::Point& aPoint )
1070     throw (uno::RuntimeException)
1071 {
1072     const awt::Rectangle    aRect( getBounds() );
1073     const Point             aSize( aRect.Width, aRect.Height );
1074     const Point             aNullPoint, aTestPoint( aPoint.X, aPoint.Y );
1075
1076     return Rectangle( aNullPoint, aSize ).IsInside( aTestPoint );
1077 }
1078
1079 // -----------------------------------------------------------------------------
1080
1081 uno::Reference< accessibility::XAccessible > SAL_CALL ValueItemAcc::getAccessibleAtPoint( const awt::Point& )
1082     throw (uno::RuntimeException)
1083 {
1084     uno::Reference< accessibility::XAccessible > xRet;
1085     return xRet;
1086 }
1087
1088 // -----------------------------------------------------------------------------
1089
1090 awt::Rectangle SAL_CALL ValueItemAcc::getBounds()
1091     throw (uno::RuntimeException)
1092 {
1093     const SolarMutexGuard aSolarGuard;
1094     awt::Rectangle      aRet;
1095
1096     if( mpParent )
1097     {
1098         Rectangle   aRect( mpParent->mrParent.GetItemRect(mpParent->mnId) );
1099         Point       aOrigin;
1100         Rectangle   aParentRect( aOrigin, mpParent->mrParent.GetOutputSizePixel() );
1101
1102         aRect.Intersection( aParentRect );
1103
1104         aRet.X = aRect.Left();
1105         aRet.Y = aRect.Top();
1106         aRet.Width = aRect.GetWidth();
1107         aRet.Height = aRect.GetHeight();
1108     }
1109
1110     return aRet;
1111 }
1112
1113 // -----------------------------------------------------------------------------
1114
1115 awt::Point SAL_CALL ValueItemAcc::getLocation()
1116     throw (uno::RuntimeException)
1117 {
1118     const awt::Rectangle    aRect( getBounds() );
1119     awt::Point              aRet;
1120
1121     aRet.X = aRect.X;
1122     aRet.Y = aRect.Y;
1123
1124     return aRet;
1125 }
1126
1127 // -----------------------------------------------------------------------------
1128
1129 awt::Point SAL_CALL ValueItemAcc::getLocationOnScreen()
1130     throw (uno::RuntimeException)
1131 {
1132     const SolarMutexGuard aSolarGuard;
1133     awt::Point          aRet;
1134
1135     if( mpParent )
1136     {
1137         const Point aPos = mpParent->mrParent.GetItemRect(mpParent->mnId).TopLeft();
1138         const Point aScreenPos( mpParent->mrParent.OutputToAbsoluteScreenPixel( aPos ) );
1139
1140         aRet.X = aScreenPos.X();
1141         aRet.Y = aScreenPos.Y();
1142     }
1143
1144     return aRet;
1145 }
1146
1147 // -----------------------------------------------------------------------------
1148
1149 awt::Size SAL_CALL ValueItemAcc::getSize()
1150     throw (uno::RuntimeException)
1151 {
1152     const awt::Rectangle    aRect( getBounds() );
1153     awt::Size               aRet;
1154
1155     aRet.Width = aRect.Width;
1156     aRet.Height = aRect.Height;
1157
1158     return aRet;
1159 }
1160
1161 // -----------------------------------------------------------------------------
1162
1163 void SAL_CALL ValueItemAcc::grabFocus()
1164     throw (uno::RuntimeException)
1165 {
1166     // nothing to do
1167 }
1168
1169 // -----------------------------------------------------------------------------
1170
1171 uno::Any SAL_CALL ValueItemAcc::getAccessibleKeyBinding()
1172     throw (uno::RuntimeException)
1173 {
1174     return uno::Any();
1175 }
1176
1177 // -----------------------------------------------------------------------------
1178
1179 sal_Int32 SAL_CALL ValueItemAcc::getForeground(  )
1180     throw (uno::RuntimeException)
1181 {
1182     sal_uInt32 nColor = Application::GetSettings().GetStyleSettings().GetWindowTextColor().GetColor();
1183     return static_cast<sal_Int32>(nColor);
1184 }
1185
1186 // -----------------------------------------------------------------------------
1187
1188 sal_Int32 SAL_CALL ValueItemAcc::getBackground(  )
1189     throw (uno::RuntimeException)
1190 {
1191     sal_uInt32 nColor;
1192     if (mpParent && mpParent->meType == VALUESETITEM_COLOR)
1193         nColor = mpParent->maColor.GetColor();
1194     else
1195         nColor = Application::GetSettings().GetStyleSettings().GetWindowColor().GetColor();
1196     return static_cast<sal_Int32>(nColor);
1197 }
1198
1199 // -----------------------------------------------------------------------------
1200
1201 sal_Int64 SAL_CALL ValueItemAcc::getSomething( const uno::Sequence< sal_Int8 >& rId ) throw( uno::RuntimeException )
1202 {
1203     sal_Int64 nRet;
1204
1205     if( ( rId.getLength() == 16 ) && ( 0 == memcmp( ValueItemAcc::getUnoTunnelId().getConstArray(), rId.getConstArray(), 16 ) ) )
1206         nRet = reinterpret_cast< sal_Int64 >( this );
1207     else
1208         nRet = 0;
1209
1210     return nRet;
1211 }
1212
1213 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */