accessibility/source/extended/accessiblelistboxentry.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 <extended/accessiblelistboxentry.hxx>
  21 #include <vcl/treelistbox.hxx>
  22 #include <svtools/stringtransfer.hxx>
  23 #include <vcl/svlbitm.hxx>
  24 #include <com/sun/star/awt/Point.hpp>
  25 #include <com/sun/star/awt/Rectangle.hpp>
  26 #include <com/sun/star/awt/Size.hpp>
  27 #include <com/sun/star/accessibility/AccessibleEventId.hpp>
  28 #include <com/sun/star/accessibility/AccessibleRelationType.hpp>
  29 #include <com/sun/star/accessibility/AccessibleRole.hpp>
  30 #include <com/sun/star/accessibility/AccessibleStateType.hpp>
  31 #include <com/sun/star/lang/IndexOutOfBoundsException.hpp>
  32 #include <vcl/svapp.hxx>
  33 #include <vcl/controllayout.hxx>
  34 #include <vcl/settings.hxx>
  35 #include <toolkit/awt/vclxwindow.hxx>
  36 #include <toolkit/helper/convert.hxx>
  37 #include <unotools/accessiblestatesethelper.hxx>
  38 #include <unotools/accessiblerelationsethelper.hxx>
  39 #include <cppuhelper/supportsservice.hxx>
  40 #include <cppuhelper/typeprovider.hxx>
  41 #include <comphelper/accessibleeventnotifier.hxx>
  42 #include <helper/accresmgr.hxx>
  43 #include <strings.hrc>
  44 #include <com/sun/star/accessibility/XAccessibleValue.hpp>
  45 #define ACCESSIBLE_ACTION_COUNT 1
  46
  47 namespace
  48 {
  49     /// @throws css::lang::IndexOutOfBoundsException
  50     void checkActionIndex_Impl( sal_Int32 _nIndex )
  51     {
  52         if ( _nIndex < 0 || _nIndex >= ACCESSIBLE_ACTION_COUNT )
  53             // only three actions
  54             throw css::lang::IndexOutOfBoundsException();
  55     }
  56 }
  57
  58
  59 namespace accessibility
  60 {
  61     // class AccessibleListBoxEntry -----------------------------------------------------
  62
  63     using namespace ::com::sun::star::accessibility;
  64     using namespace ::com::sun::star::uno;
  65     using namespace ::com::sun::star::lang;
  66     using namespace ::com::sun::star;
  67     using namespace ::comphelper;
  68
  69
  70     // Ctor() and Dtor()
  71
  72     AccessibleListBoxEntry::AccessibleListBoxEntry( SvTreeListBox& _rListBox,
  73                                                     SvTreeListEntry* _pEntry,
  74                                                     const Reference< XAccessible >& _xParent ) :
  75
  76         AccessibleListBoxEntry_BASE ( m_aMutex ),
  77         ListBoxAccessibleBase( _rListBox ),
  78
  79         m_pSvLBoxEntry  ( _pEntry ),
  80         m_nClientId     ( 0 ),
  81         m_aParent       ( _xParent )
  82
  83     {
  84         _rListBox.FillEntryPath( _pEntry, m_aEntryPath );
  85     }
  86
  87     AccessibleListBoxEntry::~AccessibleListBoxEntry()
  88     {
  89         if ( IsAlive_Impl() )
  90         {
  91             // increment ref count to prevent double call of Dtor
  92             osl_atomic_increment( &m_refCount );
  93             dispose();
  94         }
  95     }
  96
  97     void AccessibleListBoxEntry::NotifyAccessibleEvent( sal_Int16 _nEventId,
  98                                                    const css::uno::Any& _aOldValue,
  99                                                    const css::uno::Any& _aNewValue )
 100     {
 101         Reference< uno::XInterface > xSource( *this );
 102         AccessibleEventObject aEventObj( xSource, _nEventId, _aNewValue, _aOldValue );
 103
 104         if (m_nClientId)
 105             comphelper::AccessibleEventNotifier::addEvent( m_nClientId, aEventObj );
 106     }
 107
 108
 109     tools::Rectangle AccessibleListBoxEntry::GetBoundingBox_Impl() const
 110     {
 111         tools::Rectangle aRect;
 112         SvTreeListEntry* pEntry = getListBox()->GetEntryFromPath( m_aEntryPath );
 113         if ( pEntry )
 114         {
 115             aRect = getListBox()->GetBoundingRect( pEntry );
 116             SvTreeListEntry* pParent = getListBox()->GetParent( pEntry );
 117             if ( pParent )
 118             {
 119                 // position relative to parent entry
 120                 Point aTopLeft = aRect.TopLeft();
 121                 aTopLeft -= getListBox()->GetBoundingRect( pParent ).TopLeft();
 122                 aRect = tools::Rectangle( aTopLeft, aRect.GetSize() );
 123             }
 124         }
 125
 126         return aRect;
 127     }
 128
 129     tools::Rectangle AccessibleListBoxEntry::GetBoundingBoxOnScreen_Impl() const
 130     {
 131         tools::Rectangle aRect;
 132         SvTreeListEntry* pEntry = getListBox()->GetEntryFromPath( m_aEntryPath );
 133         if ( pEntry )
 134         {
 135             aRect = getListBox()->GetBoundingRect( pEntry );
 136             Point aTopLeft = aRect.TopLeft();
 137             aTopLeft += getListBox()->GetWindowExtentsRelative( nullptr ).TopLeft();
 138             aRect = tools::Rectangle( aTopLeft, aRect.GetSize() );
 139         }
 140
 141         return aRect;
 142     }
 143
 144     bool AccessibleListBoxEntry::IsAlive_Impl() const
 145     {
 146         return ( !rBHelper.bDisposed && !rBHelper.bInDispose && isAlive() );
 147     }
 148
 149     bool AccessibleListBoxEntry::IsShowing_Impl() const
 150     {
 151         Reference< XAccessible > xParent = implGetParentAccessible( );
 152
 153         bool bShowing = false;
 154         Reference< XAccessibleContext > xParentContext =
 155             xParent.is() ? xParent->getAccessibleContext() : Reference< XAccessibleContext >();
 156         if( xParentContext.is() )
 157         {
 158             Reference< XAccessibleComponent > xParentComp( xParentContext, uno::UNO_QUERY );
 159             if( xParentComp.is() )
 160                 bShowing = GetBoundingBox_Impl().IsOver( VCLRectangle( xParentComp->getBounds() ) );
 161         }
 162
 163         return bShowing;
 164     }
 165
 166     tools::Rectangle AccessibleListBoxEntry::GetBoundingBox()
 167     {
 168         SolarMutexGuard aSolarGuard;
 169         ::osl::MutexGuard aGuard( m_aMutex );
 170
 171         EnsureIsAlive();
 172         return GetBoundingBox_Impl();
 173     }
 174
 175     tools::Rectangle AccessibleListBoxEntry::GetBoundingBoxOnScreen()
 176     {
 177         SolarMutexGuard aSolarGuard;
 178         ::osl::MutexGuard aGuard( m_aMutex );
 179
 180         EnsureIsAlive();
 181         return GetBoundingBoxOnScreen_Impl();
 182     }
 183
 184     void AccessibleListBoxEntry::EnsureIsAlive() const
 185     {
 186         if ( !IsAlive_Impl() )
 187             throw lang::DisposedException();
 188     }
 189
 190     OUString AccessibleListBoxEntry::implGetText()
 191     {
 192         OUString sRet;
 193         SvTreeListEntry* pEntry = getListBox()->GetEntryFromPath( m_aEntryPath );
 194         if ( pEntry )
 195             sRet = SvTreeListBox::SearchEntryTextWithHeadTitle( pEntry );
 196         return sRet;
 197     }
 198
 199     Locale AccessibleListBoxEntry::implGetLocale()
 200     {
 201         Locale aLocale;
 202         aLocale = Application::GetSettings().GetUILanguageTag().getLocale();
 203
 204         return aLocale;
 205     }
 206     void AccessibleListBoxEntry::implGetSelection( sal_Int32& nStartIndex, sal_Int32& nEndIndex )
 207     {
 208         nStartIndex = 0;
 209         nEndIndex = 0;
 210     }
 211
 212     // XTypeProvider
 213
 214
 215     Sequence< sal_Int8 > AccessibleListBoxEntry::getImplementationId()
 216     {
 217         return css::uno::Sequence<sal_Int8>();
 218     }
 219
 220
 221     // XComponent/ListBoxAccessibleBase
 222
 223     void SAL_CALL AccessibleListBoxEntry::dispose()
 224     {
 225         AccessibleListBoxEntry_BASE::dispose();
 226     }
 227
 228
 229     // XComponent
 230
 231     void SAL_CALL AccessibleListBoxEntry::disposing()
 232     {
 233         SolarMutexGuard aSolarGuard;
 234         ::osl::MutexGuard aGuard( m_aMutex );
 235
 236         Reference< XAccessible > xKeepAlive( this );
 237
 238         // Send a disposing to all listeners.
 239         if ( m_nClientId )
 240         {
 241             ::comphelper::AccessibleEventNotifier::TClientId nId = m_nClientId;
 242             m_nClientId =  0;
 243             ::comphelper::AccessibleEventNotifier::revokeClientNotifyDisposing( nId, *this );
 244         }
 245
 246         // clean up
 247         {
 248
 249             ListBoxAccessibleBase::disposing();
 250         }
 251         m_aParent.clear();
 252     }
 253
 254     // XServiceInfo
 255
 256     OUString SAL_CALL AccessibleListBoxEntry::getImplementationName()
 257     {
 258         return OUString( "com.sun.star.comp.svtools.AccessibleTreeListBoxEntry" );
 259     }
 260
 261     Sequence< OUString > SAL_CALL AccessibleListBoxEntry::getSupportedServiceNames()
 262     {
 263         return {"com.sun.star.accessibility.AccessibleContext",
 264                 "com.sun.star.accessibility.AccessibleComponent",
 265                 "com.sun.star.awt.AccessibleTreeListBoxEntry"};
 266     }
 267
 268     sal_Bool SAL_CALL AccessibleListBoxEntry::supportsService( const OUString& _rServiceName )
 269     {
 270         return cppu::supportsService(this, _rServiceName);
 271     }
 272
 273     // XAccessible
 274
 275     Reference< XAccessibleContext > SAL_CALL AccessibleListBoxEntry::getAccessibleContext(  )
 276     {
 277         EnsureIsAlive();
 278         return this;
 279     }
 280
 281     // XAccessibleContext
 282
 283     sal_Int32 SAL_CALL AccessibleListBoxEntry::getAccessibleChildCount(  )
 284     {
 285         SolarMutexGuard aSolarGuard;
 286         ::osl::MutexGuard aGuard( m_aMutex );
 287
 288         EnsureIsAlive();
 289         SvTreeListEntry* pEntry = getListBox()->GetEntryFromPath( m_aEntryPath );
 290         sal_Int32 nCount = 0;
 291         if ( pEntry )
 292             nCount = getListBox()->GetLevelChildCount( pEntry );
 293
 294         return nCount;
 295     }
 296
 297     Reference< XAccessible > SAL_CALL AccessibleListBoxEntry::getAccessibleChild( sal_Int32 i )
 298     {
 299         SolarMutexGuard aSolarGuard;
 300         ::osl::MutexGuard aGuard( m_aMutex );
 301         EnsureIsAlive();
 302
 303         SvTreeListEntry* pEntry = GetRealChild(i);
 304         if ( !pEntry )
 305             throw IndexOutOfBoundsException();
 306
 307         return new AccessibleListBoxEntry( *getListBox(), pEntry, this );
 308     }
 309
 310
 311     Reference< XAccessible > AccessibleListBoxEntry::implGetParentAccessible( ) const
 312     {
 313         Reference< XAccessible > xParent(m_aParent);
 314         if ( !xParent.is() )
 315         {
 316             OSL_ENSURE( m_aEntryPath.size(), "AccessibleListBoxEntry::getAccessibleParent: invalid path!" );
 317             if ( m_aEntryPath.size() == 1 )
 318             {   // we're a top level entry
 319                 // -> our parent is the tree listbox itself
 320                 if ( getListBox() )
 321                     xParent = getListBox()->GetAccessible( );
 322             }
 323             else
 324             {   // we have a entry as parent -> get its accessible
 325
 326                 // shorten our access path by one
 327                 std::deque< sal_Int32 > aParentPath( m_aEntryPath );
 328                 aParentPath.pop_back();
 329
 330                 // get the entry for this shortened access path
 331                 SvTreeListEntry* pParentEntry = getListBox()->GetEntryFromPath( aParentPath );
 332                 OSL_ENSURE( pParentEntry, "AccessibleListBoxEntry::implGetParentAccessible: could not obtain a parent entry!" );
 333
 334                 if ( pParentEntry )
 335                     pParentEntry = getListBox()->GetParent(pParentEntry);
 336                 if ( pParentEntry )
 337                     xParent = new AccessibleListBoxEntry( *getListBox(), pParentEntry, nullptr );
 338                     // note that we pass NULL here as parent-accessible:
 339                     // this is allowed, as the AccessibleListBoxEntry class will create its parent
 340                     // when needed
 341             }
 342         }
 343
 344         return xParent;
 345     }
 346
 347
 348     Reference< XAccessible > SAL_CALL AccessibleListBoxEntry::getAccessibleParent(  )
 349     {
 350         SolarMutexGuard aSolarGuard;
 351         ::osl::MutexGuard aGuard( m_aMutex );
 352         EnsureIsAlive();
 353
 354         return implGetParentAccessible( );
 355     }
 356
 357     sal_Int32 SAL_CALL AccessibleListBoxEntry::getAccessibleIndexInParent(  )
 358     {
 359         ::osl::MutexGuard aGuard( m_aMutex );
 360
 361         OSL_ENSURE( !m_aEntryPath.empty(), "empty path" );
 362         return m_aEntryPath.empty() ? -1 : m_aEntryPath.back();
 363     }
 364
 365     sal_Int32 AccessibleListBoxEntry::GetRoleType()
 366     {
 367         sal_Int32 nCase = 0;
 368         SvTreeListEntry* pEntry = getListBox()->GetEntry(0);
 369         if ( pEntry )
 370         {
 371             if( pEntry->HasChildrenOnDemand() || getListBox()->GetChildCount(pEntry) > 0  )
 372             {
 373                 nCase = 1;
 374                 return nCase;
 375             }
 376         }
 377
 378         bool bHasButtons = (getListBox()->GetStyle() & WB_HASBUTTONS)!=0;
 379         if( !(getListBox()->GetTreeFlags() & SvTreeFlags::CHKBTN) )
 380         {
 381             if( bHasButtons )
 382                 nCase = 1;
 383         }
 384         else
 385         {
 386             if( bHasButtons )
 387                 nCase = 2;
 388             else
 389                 nCase = 3;
 390         }
 391         return nCase;
 392     }
 393
 394     sal_Int16 SAL_CALL AccessibleListBoxEntry::getAccessibleRole(  )
 395     {
 396         SolarMutexGuard aSolarGuard;
 397         ::osl::MutexGuard aGuard( m_aMutex );
 398
 399         SvTreeListBox* pBox = getListBox();
 400         if(pBox)
 401         {
 402             SvTreeAccRoleType nType = pBox->GetAllEntriesAccessibleRoleType();
 403             if( nType == SvTreeAccRoleType::TREE)
 404                 return AccessibleRole::TREE_ITEM;
 405
 406             SvTreeFlags treeFlag = pBox->GetTreeFlags();
 407             if(treeFlag & SvTreeFlags::CHKBTN )
 408             {
 409                 SvTreeListEntry* pEntry = pBox->GetEntryFromPath( m_aEntryPath );
 410                 SvButtonState eState = pBox->GetCheckButtonState( pEntry );
 411                 switch( eState )
 412                 {
 413                 case SvButtonState::Checked:
 414                 case SvButtonState::Unchecked:
 415                     return AccessibleRole::CHECK_BOX;
 416                 case SvButtonState::Tristate:
 417                 default:
 418                     return AccessibleRole::LABEL;
 419                 }
 420             }
 421             if (GetRoleType() == 0)
 422                 return AccessibleRole::LIST_ITEM;
 423             else
 424                 //o is: return AccessibleRole::LABEL;
 425                 return AccessibleRole::TREE_ITEM;
 426         }
 427         return AccessibleRole::UNKNOWN;
 428     }
 429
 430     OUString SAL_CALL AccessibleListBoxEntry::getAccessibleDescription(  )
 431     {
 432         SolarMutexGuard aSolarGuard;
 433         ::osl::MutexGuard aGuard( m_aMutex );
 434
 435         SvTreeListEntry* pEntry = getListBox()->GetEntryFromPath( m_aEntryPath );
 436         if( getAccessibleRole() == AccessibleRole::TREE_ITEM )
 437         {
 438             return getListBox()->GetEntryLongDescription( pEntry );
 439         }
 440         //want to cout the real column number in the list box.
 441         sal_uInt16 iRealItemCount = 0;
 442         sal_uInt16 iCount = 0;
 443         sal_uInt16 iTotleItemCount = pEntry->ItemCount();
 444         while( iCount < iTotleItemCount )
 445         {
 446             const SvLBoxItem& rItem = pEntry->GetItem( iCount );
 447             if ( rItem.GetType() == SvLBoxItemType::String &&
 448                  !static_cast<const SvLBoxString&>( rItem ).GetText().isEmpty() )
 449             {
 450                 iRealItemCount++;
 451             }
 452             iCount++;
 453         }
 454         if(iRealItemCount<=1  )
 455         {
 456             return OUString();
 457         }
 458         else
 459         {
 460             return SvTreeListBox::SearchEntryTextWithHeadTitle( pEntry );
 461         }
 462     }
 463
 464     OUString SAL_CALL AccessibleListBoxEntry::getAccessibleName(  )
 465     {
 466         ::osl::MutexGuard aGuard( m_aMutex );
 467
 468         EnsureIsAlive();
 469
 470         OUString sRet(implGetText());
 471
 472         SvTreeListEntry* pEntry = getListBox()->GetEntryFromPath( m_aEntryPath );
 473
 474         OUString altText = getListBox()->GetEntryAltText( pEntry );
 475         if (!altText.isEmpty())
 476         {
 477             sRet += " " + altText;
 478         }
 479
 480         return sRet;
 481     }
 482
 483     Reference< XAccessibleRelationSet > SAL_CALL AccessibleListBoxEntry::getAccessibleRelationSet(  )
 484     {
 485         Reference< XAccessibleRelationSet > xRelSet;
 486         Reference< XAccessible > xParent;
 487         if ( m_aEntryPath.size() > 1 ) // not a root entry
 488             xParent = implGetParentAccessible();
 489         if ( xParent.is() )
 490         {
 491             utl::AccessibleRelationSetHelper* pRelationSetHelper = new utl::AccessibleRelationSetHelper;
 492             Sequence< Reference< XInterface > > aSequence { xParent };
 493             pRelationSetHelper->AddRelation(
 494                 AccessibleRelation( AccessibleRelationType::NODE_CHILD_OF, aSequence ) );
 495             xRelSet = pRelationSetHelper;
 496         }
 497         return xRelSet;
 498     }
 499
 500     Reference< XAccessibleStateSet > SAL_CALL AccessibleListBoxEntry::getAccessibleStateSet(  )
 501     {
 502         ::osl::MutexGuard aGuard( m_aMutex );
 503
 504         utl::AccessibleStateSetHelper* pStateSetHelper = new utl::AccessibleStateSetHelper;
 505         Reference< XAccessibleStateSet > xStateSet = pStateSetHelper;
 506
 507         if ( IsAlive_Impl() )
 508         {
 509             switch(getAccessibleRole())
 510             {
 511                 case AccessibleRole::LABEL:
 512                     pStateSetHelper->AddState( AccessibleStateType::TRANSIENT );
 513                     pStateSetHelper->AddState( AccessibleStateType::SELECTABLE );
 514                     pStateSetHelper->AddState( AccessibleStateType::ENABLED );
 515                     if (getListBox()->IsInplaceEditingEnabled())
 516                         pStateSetHelper->AddState( AccessibleStateType::EDITABLE );
 517                     if (IsShowing_Impl())
 518                         pStateSetHelper->AddState( AccessibleStateType::SHOWING );
 519                     break;
 520                 case AccessibleRole::CHECK_BOX:
 521                     pStateSetHelper->AddState( AccessibleStateType::TRANSIENT );
 522                     pStateSetHelper->AddState( AccessibleStateType::SELECTABLE );
 523                     pStateSetHelper->AddState( AccessibleStateType::ENABLED );
 524                     if (IsShowing_Impl())
 525                         pStateSetHelper->AddState( AccessibleStateType::SHOWING );
 526                     break;
 527             }
 528             SvTreeListEntry *pEntry = getListBox()->GetEntryFromPath(m_aEntryPath);
 529             if (pEntry)
 530                 getListBox()->FillAccessibleEntryStateSet(pEntry, *pStateSetHelper);
 531         }
 532         else
 533             pStateSetHelper->AddState( AccessibleStateType::DEFUNC );
 534
 535         return xStateSet;
 536     }
 537
 538     Locale SAL_CALL AccessibleListBoxEntry::getLocale(  )
 539     {
 540         SolarMutexGuard aSolarGuard;
 541         ::osl::MutexGuard aGuard( m_aMutex );
 542
 543         return implGetLocale();
 544     }
 545
 546     // XAccessibleComponent
 547
 548     sal_Bool SAL_CALL AccessibleListBoxEntry::containsPoint( const awt::Point& rPoint )
 549     {
 550         return tools::Rectangle( Point(), GetBoundingBox().GetSize() ).IsInside( VCLPoint( rPoint ) );
 551     }
 552
 553     Reference< XAccessible > SAL_CALL AccessibleListBoxEntry::getAccessibleAtPoint( const awt::Point& _aPoint )
 554     {
 555         SolarMutexGuard aSolarGuard;
 556         ::osl::MutexGuard aGuard( m_aMutex );
 557
 558         EnsureIsAlive();
 559         SvTreeListEntry* pEntry = getListBox()->GetEntry( VCLPoint( _aPoint ) );
 560         if ( !pEntry )
 561             throw RuntimeException();
 562
 563         Reference< XAccessible > xAcc;
 564         AccessibleListBoxEntry* pAccEntry = new AccessibleListBoxEntry( *getListBox(), pEntry, this );
 565         tools::Rectangle aRect = pAccEntry->GetBoundingBox_Impl();
 566         if ( aRect.IsInside( VCLPoint( _aPoint ) ) )
 567             xAcc = pAccEntry;
 568         return xAcc;
 569     }
 570
 571     awt::Rectangle SAL_CALL AccessibleListBoxEntry::getBounds(  )
 572     {
 573         return AWTRectangle( GetBoundingBox() );
 574     }
 575
 576     awt::Point SAL_CALL AccessibleListBoxEntry::getLocation(  )
 577     {
 578         return AWTPoint( GetBoundingBox().TopLeft() );
 579     }
 580
 581     awt::Point SAL_CALL AccessibleListBoxEntry::getLocationOnScreen(  )
 582     {
 583         return AWTPoint( GetBoundingBoxOnScreen().TopLeft() );
 584     }
 585
 586     awt::Size SAL_CALL AccessibleListBoxEntry::getSize(  )
 587     {
 588         return AWTSize( GetBoundingBox().GetSize() );
 589     }
 590
 591     void SAL_CALL AccessibleListBoxEntry::grabFocus(  )
 592     {
 593         // do nothing, because no focus for each item
 594     }
 595
 596     sal_Int32 AccessibleListBoxEntry::getForeground(    )
 597     {
 598         SolarMutexGuard aSolarGuard;
 599         ::osl::MutexGuard aGuard( m_aMutex );
 600
 601         sal_Int32 nColor = 0;
 602         Reference< XAccessible > xParent = getAccessibleParent();
 603         if ( xParent.is() )
 604         {
 605             Reference< XAccessibleComponent > xParentComp( xParent->getAccessibleContext(), UNO_QUERY );
 606             if ( xParentComp.is() )
 607                 nColor = xParentComp->getForeground();
 608         }
 609
 610         return nColor;
 611     }
 612
 613     sal_Int32 AccessibleListBoxEntry::getBackground(  )
 614     {
 615         SolarMutexGuard aSolarGuard;
 616         ::osl::MutexGuard aGuard( m_aMutex );
 617
 618         sal_Int32 nColor = 0;
 619         Reference< XAccessible > xParent = getAccessibleParent();
 620         if ( xParent.is() )
 621         {
 622             Reference< XAccessibleComponent > xParentComp( xParent->getAccessibleContext(), UNO_QUERY );
 623             if ( xParentComp.is() )
 624                 nColor = xParentComp->getBackground();
 625         }
 626
 627         return nColor;
 628     }
 629
 630     // XAccessibleText
 631
 632
 633     awt::Rectangle SAL_CALL AccessibleListBoxEntry::getCharacterBounds( sal_Int32 nIndex )
 634     {
 635         SolarMutexGuard aSolarGuard;
 636         ::osl::MutexGuard aGuard( m_aMutex );
 637
 638         EnsureIsAlive();
 639
 640         if ( !implIsValidIndex( nIndex, implGetText().getLength() ) )
 641             throw IndexOutOfBoundsException();
 642
 643         awt::Rectangle aBounds( 0, 0, 0, 0 );
 644         SvTreeListEntry* pEntry = getListBox()->GetEntryFromPath( m_aEntryPath );
 645         if ( pEntry )
 646         {
 647             vcl::ControlLayoutData aLayoutData;
 648             tools::Rectangle aItemRect = GetBoundingBox();
 649             getListBox()->RecordLayoutData( &aLayoutData, aItemRect );
 650             tools::Rectangle aCharRect = aLayoutData.GetCharacterBounds( nIndex );
 651             aCharRect.Move( -aItemRect.Left(), -aItemRect.Top() );
 652             aBounds = AWTRectangle( aCharRect );
 653         }
 654
 655         return aBounds;
 656     }
 657
 658     sal_Int32 SAL_CALL AccessibleListBoxEntry::getIndexAtPoint( const awt::Point& aPoint )
 659     {
 660         SolarMutexGuard aSolarGuard;
 661         ::osl::MutexGuard aGuard( m_aMutex );
 662         EnsureIsAlive();
 663         if(aPoint.X==0 && aPoint.Y==0) return 0;
 664
 665         sal_Int32 nIndex = -1;
 666         SvTreeListEntry* pEntry = getListBox()->GetEntryFromPath( m_aEntryPath );
 667         if ( pEntry )
 668         {
 669             vcl::ControlLayoutData aLayoutData;
 670             tools::Rectangle aItemRect = GetBoundingBox();
 671             getListBox()->RecordLayoutData( &aLayoutData, aItemRect );
 672             Point aPnt( VCLPoint( aPoint ) );
 673             aPnt += aItemRect.TopLeft();
 674             nIndex = aLayoutData.GetIndexForPoint( aPnt );
 675         }
 676
 677         return nIndex;
 678     }
 679
 680     sal_Bool SAL_CALL AccessibleListBoxEntry::copyText( sal_Int32 nStartIndex, sal_Int32 nEndIndex )
 681     {
 682         SolarMutexGuard aSolarGuard;
 683         ::osl::MutexGuard aGuard( m_aMutex );
 684         EnsureIsAlive();
 685
 686         OUString sText = implGetText();
 687         if  ( ( 0 > nStartIndex ) || ( sText.getLength() <= nStartIndex )
 688             || ( 0 > nEndIndex ) || ( sText.getLength() <= nEndIndex ) )
 689             throw IndexOutOfBoundsException();
 690
 691         sal_Int32 nLen = nEndIndex - nStartIndex + 1;
 692         ::svt::OStringTransfer::CopyString( sText.copy( nStartIndex, nLen ), getListBox() );
 693
 694         return true;
 695     }
 696
 697     // XAccessibleEventBroadcaster
 698
 699     void SAL_CALL AccessibleListBoxEntry::addAccessibleEventListener( const Reference< XAccessibleEventListener >& xListener )
 700     {
 701         if (xListener.is())
 702         {
 703             ::osl::MutexGuard aGuard( m_aMutex );
 704             if (!m_nClientId)
 705                 m_nClientId = comphelper::AccessibleEventNotifier::registerClient( );
 706             comphelper::AccessibleEventNotifier::addEventListener( m_nClientId, xListener );
 707         }
 708     }
 709
 710     void SAL_CALL AccessibleListBoxEntry::removeAccessibleEventListener( const Reference< XAccessibleEventListener >& xListener )
 711     {
 712         if (xListener.is())
 713         {
 714             ::osl::MutexGuard aGuard( m_aMutex );
 715
 716             sal_Int32 nListenerCount = comphelper::AccessibleEventNotifier::removeEventListener( m_nClientId, xListener );
 717             if ( !nListenerCount )
 718             {
 719                 // no listeners anymore
 720                 // -> revoke ourself. This may lead to the notifier thread dying (if we were the last client),
 721                 // and at least to us not firing any events anymore, in case somebody calls
 722                 // NotifyAccessibleEvent, again
 723                 sal_Int32 nId = m_nClientId;
 724                 m_nClientId = 0;
 725                 comphelper::AccessibleEventNotifier::revokeClient( nId );
 726
 727             }
 728         }
 729     }
 730
 731     // XAccessibleAction
 732
 733     sal_Int32 SAL_CALL AccessibleListBoxEntry::getAccessibleActionCount(  )
 734     {
 735         ::osl::MutexGuard aGuard( m_aMutex );
 736
 737         // three actions supported
 738         SvTreeListBox* pBox = getListBox();
 739         SvTreeFlags treeFlag = pBox->GetTreeFlags();
 740         bool bHasButtons = (getListBox()->GetStyle() & WB_HASBUTTONS)!=0;
 741         if( (treeFlag & SvTreeFlags::CHKBTN) && !bHasButtons)
 742         {
 743             sal_Int16 role = getAccessibleRole();
 744             if ( role == AccessibleRole::CHECK_BOX )
 745                 return 2;
 746             else if ( role == AccessibleRole::LABEL )
 747                 return 0;
 748         }
 749         else
 750             return ACCESSIBLE_ACTION_COUNT;
 751         return 0;
 752     }
 753
 754     sal_Bool SAL_CALL AccessibleListBoxEntry::doAccessibleAction( sal_Int32 nIndex )
 755     {
 756         SolarMutexGuard aSolarGuard;
 757         ::osl::MutexGuard aGuard( m_aMutex );
 758
 759         bool bRet = false;
 760         checkActionIndex_Impl( nIndex );
 761         EnsureIsAlive();
 762
 763         SvTreeFlags treeFlag = getListBox()->GetTreeFlags();
 764         if( nIndex == 0 && (treeFlag & SvTreeFlags::CHKBTN) )
 765         {
 766             if(getAccessibleRole() == AccessibleRole::CHECK_BOX)
 767             {
 768                 SvTreeListEntry* pEntry = getListBox()->GetEntryFromPath( m_aEntryPath );
 769                 SvButtonState state = getListBox()->GetCheckButtonState( pEntry );
 770                 if ( state == SvButtonState::Checked )
 771                     getListBox()->SetCheckButtonState(pEntry, SvButtonState::Unchecked);
 772                 else if (state == SvButtonState::Unchecked)
 773                     getListBox()->SetCheckButtonState(pEntry, SvButtonState::Checked);
 774             }
 775         }
 776         else if( (nIndex == 1 && (treeFlag & SvTreeFlags::CHKBTN) ) || (nIndex == 0) )
 777         {
 778             SvTreeListEntry* pEntry = getListBox()->GetEntryFromPath( m_aEntryPath );
 779             if ( pEntry )
 780             {
 781                 if ( getListBox()->IsExpanded( pEntry ) )
 782                     getListBox()->Collapse( pEntry );
 783                 else
 784                     getListBox()->Expand( pEntry );
 785                 bRet = true;
 786             }
 787         }
 788
 789         return bRet;
 790     }
 791
 792     OUString SAL_CALL AccessibleListBoxEntry::getAccessibleActionDescription( sal_Int32 nIndex )
 793     {
 794         SolarMutexGuard aSolarGuard;
 795         ::osl::MutexGuard aGuard( m_aMutex );
 796
 797         checkActionIndex_Impl( nIndex );
 798         EnsureIsAlive();
 799
 800         // sal_Bool bHasButtons = (getListBox()->GetStyle() & WB_HASBUTTONS)!=0;
 801         SvTreeListEntry* pEntry = getListBox()->GetEntryFromPath( m_aEntryPath );
 802         SvButtonState state = getListBox()->GetCheckButtonState( pEntry );
 803         SvTreeFlags treeFlag = getListBox()->GetTreeFlags();
 804         if(nIndex == 0 && (treeFlag & SvTreeFlags::CHKBTN))
 805         {
 806             if(getAccessibleRole() == AccessibleRole::CHECK_BOX)
 807             {
 808                 if ( state == SvButtonState::Checked )
 809                     return OUString("UnCheck");
 810                 else if (state == SvButtonState::Unchecked)
 811                     return OUString("Check");
 812             }
 813             else
 814             {
 815                 //Sometimes, a List or Tree may have both checkbox and label at the same time
 816                 return OUString();
 817             }
 818         }else if( (nIndex == 1 && (treeFlag & SvTreeFlags::CHKBTN)) || nIndex == 0 )
 819         {
 820             if( pEntry->HasChildren() || pEntry->HasChildrenOnDemand() )
 821                 return getListBox()->IsExpanded( pEntry ) ?
 822                 AccResId(STR_SVT_ACC_ACTION_COLLAPSE) :
 823                 AccResId(STR_SVT_ACC_ACTION_EXPAND);
 824             return OUString();
 825
 826         }
 827         throw IndexOutOfBoundsException();
 828     }
 829
 830     Reference< XAccessibleKeyBinding > AccessibleListBoxEntry::getAccessibleActionKeyBinding( sal_Int32 nIndex )
 831     {
 832         ::osl::MutexGuard aGuard( m_aMutex );
 833
 834         Reference< XAccessibleKeyBinding > xRet;
 835         checkActionIndex_Impl( nIndex );
 836         // ... which key?
 837         return xRet;
 838     }
 839
 840     // XAccessibleSelection
 841
 842     void SAL_CALL AccessibleListBoxEntry::selectAccessibleChild( sal_Int32 nChildIndex )
 843     {
 844         SolarMutexGuard aSolarGuard;
 845         ::osl::MutexGuard aGuard( m_aMutex );
 846
 847         EnsureIsAlive();
 848
 849         SvTreeListEntry* pEntry = GetRealChild(nChildIndex);
 850         if ( !pEntry )
 851             throw IndexOutOfBoundsException();
 852
 853         getListBox()->Select( pEntry );
 854     }
 855
 856     sal_Bool SAL_CALL AccessibleListBoxEntry::isAccessibleChildSelected( sal_Int32 nChildIndex )
 857     {
 858         SolarMutexGuard aSolarGuard;
 859         ::osl::MutexGuard aGuard( m_aMutex );
 860
 861         EnsureIsAlive();
 862
 863         SvTreeListEntry* pParent = getListBox()->GetEntryFromPath( m_aEntryPath );
 864         SvTreeListEntry* pEntry = getListBox()->GetEntry( pParent, nChildIndex );
 865         if ( !pEntry )
 866             throw IndexOutOfBoundsException();
 867
 868         return getListBox()->IsSelected( pEntry );
 869     }
 870
 871     void SAL_CALL AccessibleListBoxEntry::clearAccessibleSelection(  )
 872     {
 873         SolarMutexGuard aSolarGuard;
 874         ::osl::MutexGuard aGuard( m_aMutex );
 875
 876         EnsureIsAlive();
 877
 878         SvTreeListEntry* pParent = getListBox()->GetEntryFromPath( m_aEntryPath );
 879         if ( !pParent )
 880             throw RuntimeException();
 881         sal_Int32 nCount = getListBox()->GetLevelChildCount( pParent );
 882         for ( sal_Int32 i = 0; i < nCount; ++i )
 883         {
 884             SvTreeListEntry* pEntry = getListBox()->GetEntry( pParent, i );
 885             if ( getListBox()->IsSelected( pEntry ) )
 886                 getListBox()->Select( pEntry, false );
 887         }
 888     }
 889
 890     void SAL_CALL AccessibleListBoxEntry::selectAllAccessibleChildren(  )
 891     {
 892         SolarMutexGuard aSolarGuard;
 893         ::osl::MutexGuard aGuard( m_aMutex );
 894
 895         EnsureIsAlive();
 896
 897         SvTreeListEntry* pParent = getListBox()->GetEntryFromPath( m_aEntryPath );
 898         if ( !pParent )
 899             throw RuntimeException();
 900         sal_Int32 nCount = getListBox()->GetLevelChildCount( pParent );
 901         for ( sal_Int32 i = 0; i < nCount; ++i )
 902         {
 903             SvTreeListEntry* pEntry = getListBox()->GetEntry( pParent, i );
 904             if ( !getListBox()->IsSelected( pEntry ) )
 905                 getListBox()->Select( pEntry );
 906         }
 907     }
 908
 909     sal_Int32 SAL_CALL AccessibleListBoxEntry::getSelectedAccessibleChildCount(  )
 910     {
 911         SolarMutexGuard aSolarGuard;
 912         ::osl::MutexGuard aGuard( m_aMutex );
 913
 914         EnsureIsAlive();
 915
 916         sal_Int32 i, nSelCount = 0, nCount = 0;
 917
 918         SvTreeListEntry* pParent = getListBox()->GetEntryFromPath( m_aEntryPath );
 919         if ( !pParent )
 920             throw RuntimeException();
 921         nCount = getListBox()->GetLevelChildCount( pParent );
 922         for ( i = 0; i < nCount; ++i )
 923         {
 924             SvTreeListEntry* pEntry = getListBox()->GetEntry( pParent, i );
 925             if ( getListBox()->IsSelected( pEntry ) )
 926                 ++nSelCount;
 927         }
 928
 929         return nSelCount;
 930     }
 931
 932     Reference< XAccessible > SAL_CALL AccessibleListBoxEntry::getSelectedAccessibleChild( sal_Int32 nSelectedChildIndex )
 933     {
 934         SolarMutexGuard aSolarGuard;
 935         ::osl::MutexGuard aGuard( m_aMutex );
 936
 937         EnsureIsAlive();
 938
 939         if ( nSelectedChildIndex < 0 || nSelectedChildIndex >= getSelectedAccessibleChildCount() )
 940             throw IndexOutOfBoundsException();
 941
 942         Reference< XAccessible > xChild;
 943         sal_Int32 i, nSelCount = 0, nCount = 0;
 944
 945         SvTreeListEntry* pParent = getListBox()->GetEntryFromPath( m_aEntryPath );
 946         if ( !pParent )
 947             throw RuntimeException();
 948         nCount = getListBox()->GetLevelChildCount( pParent );
 949         for ( i = 0; i < nCount; ++i )
 950         {
 951             SvTreeListEntry* pEntry = getListBox()->GetEntry( pParent, i );
 952             if ( getListBox()->IsSelected( pEntry ) )
 953                 ++nSelCount;
 954
 955             if ( nSelCount == ( nSelectedChildIndex + 1 ) )
 956             {
 957                 xChild = new AccessibleListBoxEntry( *getListBox(), pEntry, this );
 958                 break;
 959             }
 960         }
 961
 962         return xChild;
 963     }
 964
 965     void SAL_CALL AccessibleListBoxEntry::deselectAccessibleChild( sal_Int32 nSelectedChildIndex )
 966     {
 967         SolarMutexGuard aSolarGuard;
 968         ::osl::MutexGuard aGuard( m_aMutex );
 969
 970         EnsureIsAlive();
 971
 972         SvTreeListEntry* pParent = getListBox()->GetEntryFromPath( m_aEntryPath );
 973         SvTreeListEntry* pEntry = getListBox()->GetEntry( pParent, nSelectedChildIndex );
 974         if ( !pEntry )
 975             throw IndexOutOfBoundsException();
 976
 977         getListBox()->Select( pEntry, false );
 978     }
 979     sal_Int32 SAL_CALL AccessibleListBoxEntry::getCaretPosition(  )
 980     {
 981         return -1;
 982     }
 983     sal_Bool SAL_CALL AccessibleListBoxEntry::setCaretPosition ( sal_Int32 nIndex )
 984     {
 985         SolarMutexGuard aSolarGuard;
 986         ::osl::MutexGuard aGuard( m_aMutex );
 987         EnsureIsAlive();
 988
 989         if ( !implIsValidRange( nIndex, nIndex, implGetText().getLength() ) )
 990             throw IndexOutOfBoundsException();
 991
 992         return false;
 993     }
 994     sal_Unicode SAL_CALL AccessibleListBoxEntry::getCharacter( sal_Int32 nIndex )
 995     {
 996         SolarMutexGuard aSolarGuard;
 997         ::osl::MutexGuard aGuard( m_aMutex );
 998         EnsureIsAlive();
 999         return OCommonAccessibleText::implGetCharacter( implGetText(), nIndex );
1000     }
1001     css::uno::Sequence< css::beans::PropertyValue > SAL_CALL AccessibleListBoxEntry::getCharacterAttributes( sal_Int32 nIndex, const css::uno::Sequence< OUString >& )
1002     {
1003         SolarMutexGuard aSolarGuard;
1004         ::osl::MutexGuard aGuard( m_aMutex );
1005         EnsureIsAlive();
1006
1007         OUString sText( implGetText() );
1008
1009         if ( !implIsValidIndex( nIndex, sText.getLength() ) )
1010             throw IndexOutOfBoundsException();
1011
1012         return css::uno::Sequence< css::beans::PropertyValue >();
1013     }
1014     sal_Int32 SAL_CALL AccessibleListBoxEntry::getCharacterCount(  )
1015     {
1016         SolarMutexGuard aSolarGuard;
1017         ::osl::MutexGuard aGuard( m_aMutex );
1018         EnsureIsAlive();
1019         return implGetText().getLength();
1020     }
1021
1022     OUString SAL_CALL AccessibleListBoxEntry::getSelectedText(  )
1023     {
1024         SolarMutexGuard aSolarGuard;
1025         ::osl::MutexGuard aGuard( m_aMutex );
1026         EnsureIsAlive();
1027         return OUString();
1028     }
1029     sal_Int32 SAL_CALL AccessibleListBoxEntry::getSelectionStart(  )
1030     {
1031         SolarMutexGuard aSolarGuard;
1032         ::osl::MutexGuard aGuard( m_aMutex );
1033         EnsureIsAlive();
1034         return 0;
1035     }
1036     sal_Int32 SAL_CALL AccessibleListBoxEntry::getSelectionEnd(  )
1037     {
1038         SolarMutexGuard aSolarGuard;
1039         ::osl::MutexGuard aGuard( m_aMutex );
1040         EnsureIsAlive();
1041         return 0;
1042     }
1043     sal_Bool SAL_CALL AccessibleListBoxEntry::setSelection( sal_Int32 nStartIndex, sal_Int32 nEndIndex )
1044     {
1045         SolarMutexGuard aSolarGuard;
1046         ::osl::MutexGuard aGuard( m_aMutex );
1047         EnsureIsAlive();
1048
1049         if ( !implIsValidRange( nStartIndex, nEndIndex, implGetText().getLength() ) )
1050             throw IndexOutOfBoundsException();
1051
1052         return false;
1053     }
1054     OUString SAL_CALL AccessibleListBoxEntry::getText(  )
1055     {
1056         SolarMutexGuard aSolarGuard;
1057         ::osl::MutexGuard aGuard( m_aMutex );
1058         EnsureIsAlive();
1059         return implGetText(  );
1060     }
1061     OUString SAL_CALL AccessibleListBoxEntry::getTextRange( sal_Int32 nStartIndex, sal_Int32 nEndIndex )
1062     {
1063         SolarMutexGuard aSolarGuard;
1064         ::osl::MutexGuard aGuard( m_aMutex );
1065         EnsureIsAlive();
1066         return OCommonAccessibleText::implGetTextRange( implGetText(), nStartIndex, nEndIndex );
1067     }
1068     css::accessibility::TextSegment SAL_CALL AccessibleListBoxEntry::getTextAtIndex( sal_Int32 nIndex, sal_Int16 aTextType )
1069     {
1070         SolarMutexGuard aSolarGuard;
1071         ::osl::MutexGuard aGuard( m_aMutex );
1072         EnsureIsAlive();
1073         return OCommonAccessibleText::getTextAtIndex( nIndex ,aTextType);
1074     }
1075     css::accessibility::TextSegment SAL_CALL AccessibleListBoxEntry::getTextBeforeIndex( sal_Int32 nIndex, sal_Int16 aTextType )
1076     {
1077         SolarMutexGuard aSolarGuard;
1078         ::osl::MutexGuard aGuard( m_aMutex );
1079         EnsureIsAlive();
1080         return OCommonAccessibleText::getTextBeforeIndex( nIndex ,aTextType);
1081     }
1082     css::accessibility::TextSegment SAL_CALL AccessibleListBoxEntry::getTextBehindIndex( sal_Int32 nIndex, sal_Int16 aTextType )
1083     {
1084         SolarMutexGuard aSolarGuard;
1085         ::osl::MutexGuard aGuard( m_aMutex );
1086         EnsureIsAlive();
1087
1088         return OCommonAccessibleText::getTextBehindIndex( nIndex ,aTextType);
1089     }
1090
1091     // XAccessibleValue
1092
1093
1094     Any AccessibleListBoxEntry::getCurrentValue(  )
1095     {
1096         ::osl::MutexGuard aGuard( m_aMutex );
1097         Any aValue;
1098         sal_Int32 level = (static_cast<sal_Int32>(m_aEntryPath.size()) - 1);
1099         level = level < 0 ?  0: level;
1100         aValue <<= level;
1101         return aValue;
1102     }
1103
1104
1105     sal_Bool AccessibleListBoxEntry::setCurrentValue( const Any& aNumber )
1106     {
1107         ::osl::MutexGuard aGuard( m_aMutex );
1108
1109
1110         bool bReturn = false;
1111         SvTreeListBox* pBox = getListBox();
1112         if(getAccessibleRole() == AccessibleRole::CHECK_BOX)
1113         {
1114             SvTreeListEntry* pEntry = pBox->GetEntryFromPath( m_aEntryPath );
1115             if ( pEntry )
1116             {
1117                 sal_Int32 nValue(0), nValueMin(0), nValueMax(0);
1118                 aNumber >>= nValue;
1119                 getMinimumValue() >>= nValueMin;
1120                 getMaximumValue() >>= nValueMax;
1121
1122                 if ( nValue < nValueMin )
1123                     nValue = nValueMin;
1124                 else if ( nValue > nValueMax )
1125                     nValue = nValueMax;
1126
1127                 pBox->SetCheckButtonState(pEntry,  static_cast<SvButtonState>(nValue) );
1128                 bReturn = true;
1129             }
1130         }
1131
1132         return bReturn;
1133     }
1134
1135
1136     Any AccessibleListBoxEntry::getMaximumValue(  )
1137     {
1138         ::osl::MutexGuard aGuard( m_aMutex );
1139
1140         Any aValue;
1141         // SvTreeListBox* pBox = getListBox();
1142         switch(getAccessibleRole())
1143         {
1144             case AccessibleRole::CHECK_BOX:
1145                 aValue <<= sal_Int32(1);
1146                 break;
1147             case AccessibleRole::LABEL:
1148             default:
1149                 break;
1150         }
1151
1152         return aValue;
1153     }
1154
1155
1156     Any AccessibleListBoxEntry::getMinimumValue(  )
1157     {
1158         ::osl::MutexGuard aGuard( m_aMutex );
1159
1160         Any aValue;
1161         // SvTreeListBox* pBox = getListBox();
1162         switch(getAccessibleRole())
1163         {
1164             case AccessibleRole::CHECK_BOX:
1165                 aValue <<= sal_Int32(0);
1166                 break;
1167             case AccessibleRole::LABEL:
1168             default:
1169                 break;
1170         }
1171
1172         return aValue;
1173     }
1174
1175
1176     SvTreeListEntry* AccessibleListBoxEntry::GetRealChild(sal_Int32 nIndex)
1177     {
1178         SvTreeListEntry* pEntry = nullptr;
1179         SvTreeListEntry* pParent = getListBox()->GetEntryFromPath( m_aEntryPath );
1180         if (pParent)
1181         {
1182             pEntry = getListBox()->GetEntry( pParent, nIndex );
1183             if ( !pEntry && getAccessibleChildCount() > 0 )
1184             {
1185                 getListBox()->RequestingChildren(pParent);
1186                 pEntry = getListBox()->GetEntry( pParent, nIndex );
1187             }
1188         }
1189         return pEntry;
1190     }
1191
1192 }// namespace accessibility
1193
1194
1195 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */