svtools/source/control/valueacc.cxx

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