svtools/source/contnr/svtabbx.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: svtabbx.cxx,v $
  10  * $Revision: 1.30 $
  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 #include <svtools/svtabbx.hxx>
  34 #include <svtools/headbar.hxx>
  35 #include <svtools/svtdata.hxx>
  36 #ifndef _SVTOOLS_HRC
  37 #include <svtools/svtools.hrc>
  38 #endif
  39 #include <com/sun/star/accessibility/AccessibleStateType.hpp>
  40 #include <com/sun/star/accessibility/AccessibleEventId.hpp>
  41 #ifndef SVTOOLS_ACCESSIBLE_FACTORY_HXX
  42 #include "svtaccessiblefactory.hxx"
  43 #endif
  44
  45 using namespace ::com::sun::star::uno;
  46 using namespace ::com::sun::star::accessibility;
  47
  48 #define MYTABMASK \
  49     ( SV_LBOXTAB_ADJUST_RIGHT | SV_LBOXTAB_ADJUST_LEFT | SV_LBOXTAB_ADJUST_CENTER | SV_LBOXTAB_ADJUST_NUMERIC )
  50
  51 // SvTreeListBox-Callback
  52
  53 void SvTabListBox::SetTabs()
  54 {
  55     SvTreeListBox::SetTabs();
  56     if( nTabCount )
  57     {
  58         DBG_ASSERT(pTabList,"TabList ?");
  59
  60         // die TreeListBox hat jetzt ihre Tabulatoren in die Liste eingefuegt.
  61         // jetzt plustern wir die Liste mit zusaetzlichen Tabulatoren auf,
  62         // und passen den ganz rechten Tab der Treelistbox an.
  63
  64         // den ganz rechten Tab nehmen
  65         // HACK fuer den Explorer! Wenn der ViewParent != 0 ist, dann wird
  66         // der erste Tab der TreeListBox von der TreelistBox berechnet!
  67         // Dies wird fuer ButtonsOnRoot benoetigt, da der Explorer nicht
  68         // weiss, welchen zusaetzlichen Offset er in diesem Modus auf
  69         // den Tabulator addieren muss. Die TreeListBox weiss es!
  70         /*
  71         if( !pViewParent )
  72         {
  73         SvLBoxTab* pFirstTab = (SvLBoxTab*)aTabs.GetObject( aTabs.Count()-1 );
  74         pFirstTab->SetPos( pTabList[0].GetPos() );
  75         pFirstTab->nFlags &= ~MYTABMASK;
  76         pFirstTab->nFlags |= pTabList[0].nFlags;
  77         }
  78         */
  79
  80         // alle anderen Tabs an Liste haengen
  81         for( USHORT nCurTab = 1; nCurTab < nTabCount; nCurTab++ )
  82         {
  83             SvLBoxTab* pTab = pTabList+nCurTab;
  84             AddTab( pTab->GetPos(), pTab->nFlags );
  85         }
  86     }
  87 }
  88
  89 void SvTabListBox::InitEntry( SvLBoxEntry* pEntry, const XubString& rStr,
  90     const Image& rColl, const Image& rExp, SvLBoxButtonKind eButtonKind )
  91 {
  92     SvTreeListBox::InitEntry( pEntry, rStr, rColl, rExp, eButtonKind );
  93     XubString aToken;
  94
  95     const xub_Unicode* pCurToken = aCurEntry.GetBuffer();
  96     USHORT nCurTokenLen;
  97     const xub_Unicode* pNextToken = GetToken( pCurToken, nCurTokenLen );
  98     USHORT nCount = nTabCount; nCount--;
  99     for( USHORT nToken = 0; nToken < nCount; nToken++ )
 100     {
 101         if( pCurToken && nCurTokenLen )
 102             // aToken.Assign( pCurToken, nCurTokenLen );
 103             aToken = XubString( pCurToken, nCurTokenLen );
 104         else
 105             aToken.Erase();
 106         SvLBoxString* pStr = new SvLBoxString( pEntry, 0, aToken );
 107         pEntry->AddItem( pStr );
 108         pCurToken = pNextToken;
 109         if( pCurToken )
 110             pNextToken = GetToken( pCurToken, nCurTokenLen );
 111         else
 112             nCurTokenLen = 0;
 113     }
 114 }
 115
 116
 117 SvTabListBox::SvTabListBox( Window* pParent, WinBits nBits )
 118     : SvTreeListBox( pParent, nBits )
 119 {
 120     pTabList = 0;
 121     nTabCount = 0;
 122     pViewParent = 0;
 123     SetHighlightRange();        // ueber volle Breite selektieren
 124 }
 125
 126 SvTabListBox::SvTabListBox( Window* pParent, const ResId& rResId )
 127     : SvTreeListBox( pParent, rResId )
 128 {
 129     pTabList = 0;
 130     nTabCount = 0;
 131     pViewParent = 0;
 132     SvTabListBox::Resize();
 133     SetHighlightRange();
 134 }
 135
 136 SvTabListBox::~SvTabListBox()
 137 {
 138     // array-delete
 139     delete [] pTabList;
 140 #ifdef DBG_UTIL
 141     pTabList = 0;
 142     nTabCount = 0;
 143 #endif
 144 }
 145
 146 void SvTabListBox::SetTabs( long* pTabs, MapUnit eMapUnit )
 147 {
 148     DBG_ASSERT(pTabs,"SetTabs:NULL-Ptr");
 149     if( !pTabs )
 150         return;
 151
 152     delete [] pTabList;
 153     USHORT nCount = (USHORT)(*pTabs);
 154     pTabList = new SvLBoxTab[ nCount ];
 155     nTabCount = nCount;
 156
 157     MapMode aMMSource( eMapUnit );
 158     MapMode aMMDest( MAP_PIXEL );
 159
 160     pTabs++;
 161     for( USHORT nIdx = 0; nIdx < nCount; nIdx++, pTabs++ )
 162     {
 163         Size aSize( *pTabs, 0 );
 164         aSize = LogicToLogic( aSize, &aMMSource, &aMMDest );
 165         long nNewTab = aSize.Width();
 166         pTabList[nIdx].SetPos( nNewTab );
 167         pTabList[nIdx].nFlags=(SV_LBOXTAB_ADJUST_LEFT| SV_LBOXTAB_INV_ALWAYS);
 168     }
 169     SvTreeListBox::nTreeFlags |= TREEFLAG_RECALCTABS;
 170     if( IsUpdateMode() )
 171         Invalidate();
 172 }
 173
 174 void SvTabListBox::SetTab( USHORT nTab,long nValue,MapUnit eMapUnit )
 175 {
 176     DBG_ASSERT(nTab<nTabCount,"Invalid Tab-Pos");
 177     if( nTab < nTabCount )
 178     {
 179         DBG_ASSERT(pTabList,"TabList?");
 180         MapMode aMMSource( eMapUnit );
 181         MapMode aMMDest( MAP_PIXEL );
 182         Size aSize( nValue, 0 );
 183         aSize = LogicToLogic( aSize, &aMMSource, &aMMDest );
 184         nValue = aSize.Width();
 185         pTabList[ nTab ].SetPos( nValue );
 186         SvTreeListBox::nTreeFlags |= TREEFLAG_RECALCTABS;
 187         if( IsUpdateMode() )
 188             Invalidate();
 189     }
 190 }
 191
 192 SvLBoxEntry* SvTabListBox::InsertEntry( const XubString& rText, SvLBoxEntry* pParent,
 193                                         BOOL /*bChildsOnDemand*/,
 194                                         ULONG nPos, void* pUserData,
 195                                         SvLBoxButtonKind )
 196 {
 197     return InsertEntryToColumn( rText, pParent, nPos, 0xffff, pUserData );
 198 }
 199
 200 SvLBoxEntry* SvTabListBox::InsertEntry( const XubString& rText,
 201                                         const Image& rExpandedEntryBmp,
 202                                         const Image& rCollapsedEntryBmp,
 203                                         SvLBoxEntry* pParent,
 204                                         BOOL /*bChildsOnDemand*/,
 205                                         ULONG nPos, void* pUserData,
 206                                         SvLBoxButtonKind )
 207 {
 208     return InsertEntryToColumn( rText, rExpandedEntryBmp, rCollapsedEntryBmp,
 209                                 pParent, nPos, 0xffff, pUserData );
 210 }
 211
 212 SvLBoxEntry* SvTabListBox::InsertEntryToColumn(const XubString& rStr,SvLBoxEntry* pParent,ULONG nPos,USHORT nCol,
 213     void* pUser )
 214 {
 215     XubString aStr;
 216     if( nCol != 0xffff )
 217     {
 218         while( nCol )
 219         {
 220             aStr += '\t';
 221             nCol--;
 222         }
 223     }
 224     aStr += rStr;
 225     XubString aFirstStr( aStr );
 226     USHORT nEnd = aFirstStr.Search( '\t' );
 227     if( nEnd != STRING_NOTFOUND )
 228     {
 229         aFirstStr.Erase( nEnd );
 230         aCurEntry = aStr;
 231         aCurEntry.Erase( 0, ++nEnd );
 232     }
 233     else
 234         aCurEntry.Erase();
 235     return SvTreeListBox::InsertEntry( aFirstStr, pParent, FALSE, nPos, pUser );
 236 }
 237
 238 SvLBoxEntry* SvTabListBox::InsertEntryToColumn( const XubString& rStr,
 239     const Image& rExpandedEntryBmp,     const Image& rCollapsedEntryBmp,
 240     SvLBoxEntry* pParent,ULONG nPos,USHORT nCol, void* pUser )
 241 {
 242     XubString aStr;
 243     if( nCol != 0xffff )
 244     {
 245         while( nCol )
 246         {
 247             aStr += '\t';
 248             nCol--;
 249         }
 250     }
 251     aStr += rStr;
 252     XubString aFirstStr( aStr );
 253     USHORT nEnd = aFirstStr.Search( '\t' );
 254     if( nEnd != STRING_NOTFOUND )
 255     {
 256         aFirstStr.Erase( nEnd );
 257         aCurEntry = aStr;
 258         aCurEntry.Erase( 0, ++nEnd );
 259     }
 260     else
 261         aCurEntry.Erase();
 262
 263     return SvTreeListBox::InsertEntry(
 264         aFirstStr,
 265         rExpandedEntryBmp, rCollapsedEntryBmp,
 266         pParent, FALSE, nPos, pUser );
 267 }
 268
 269 SvLBoxEntry* SvTabListBox::InsertEntryToColumn( const XubString& rStr, ULONG nPos,
 270     USHORT nCol, void* pUser )
 271 {
 272     return InsertEntryToColumn( rStr,0,nPos, nCol, pUser );
 273 }
 274
 275 String SvTabListBox::GetEntryText( SvLBoxEntry* pEntry ) const
 276 {
 277     return GetEntryText( pEntry, 0xffff );
 278 }
 279
 280 String SvTabListBox::GetEntryText( SvLBoxEntry* pEntry, USHORT nCol ) const
 281 {
 282     DBG_ASSERT(pEntry,"GetEntryText:Invalid Entry");
 283     XubString aResult;
 284     if( pEntry )
 285     {
 286         USHORT nCount = pEntry->ItemCount();
 287         USHORT nCur = 0;
 288         while( nCur < nCount )
 289         {
 290             SvLBoxItem* pStr = pEntry->GetItem( nCur );
 291             if( pStr->IsA() == SV_ITEM_ID_LBOXSTRING )
 292             {
 293                 if( nCol == 0xffff )
 294                 {
 295                     if( aResult.Len() )
 296                         aResult += '\t';
 297                     aResult += static_cast<SvLBoxString*>( pStr )->GetText();
 298                 }
 299                 else
 300                 {
 301                     if( nCol == 0 )
 302                         return static_cast<SvLBoxString*>( pStr )->GetText();
 303                     nCol--;
 304                 }
 305             }
 306             nCur++;
 307         }
 308     }
 309     return aResult;
 310 }
 311
 312 String SvTabListBox::GetEntryText( ULONG nPos, USHORT nCol ) const
 313 {
 314     SvLBoxEntry* pEntry = GetEntryOnPos( nPos );
 315     return GetEntryText( pEntry, nCol );
 316 }
 317
 318 void SvTabListBox::SetEntryText( const XubString& rStr, ULONG nPos, USHORT nCol )
 319 {
 320     SvLBoxEntry* pEntry = SvTreeListBox::GetEntry( nPos );
 321     SetEntryText( rStr, pEntry, nCol );
 322 }
 323
 324 void SvTabListBox::SetEntryText( const XubString& rStr, SvLBoxEntry* pEntry, USHORT nCol )
 325 {
 326     DBG_ASSERT(pEntry,"SetEntryText:Invalid Entry");
 327     if( !pEntry )
 328         return;
 329
 330     String sOldText = GetEntryText( pEntry, nCol );
 331     if ( sOldText == rStr )
 332         return;
 333
 334     USHORT nTextColumn = nCol;
 335     const xub_Unicode* pCurToken = rStr.GetBuffer();
 336     USHORT nCurTokenLen;
 337     const xub_Unicode* pNextToken = GetToken( pCurToken, nCurTokenLen );
 338
 339     XubString aTemp;
 340     USHORT nCount = pEntry->ItemCount();
 341     USHORT nCur = 0;
 342     while( nCur < nCount )
 343     {
 344         SvLBoxItem* pStr = pEntry->GetItem( nCur );
 345         if( pStr && pStr->IsA() == SV_ITEM_ID_LBOXSTRING )
 346         {
 347             if( nCol == 0xffff )
 348             {
 349                 if( pCurToken )
 350                     aTemp = XubString( pCurToken, nCurTokenLen );
 351                 else
 352                     aTemp.Erase(); // alle Spalten ohne Token loeschen
 353                 ((SvLBoxString*)pStr)->SetText( pEntry, aTemp );
 354                 pCurToken = pNextToken;
 355                 pNextToken = GetToken( pCurToken, nCurTokenLen );
 356             }
 357             else
 358             {
 359                 if( !nCol )
 360                 {
 361                     aTemp = XubString( pCurToken, nCurTokenLen );
 362                     ((SvLBoxString*)pStr)->SetText( pEntry, aTemp );
 363                     if( !pNextToken )
 364                         break;
 365                     pCurToken = pNextToken;
 366                     pNextToken = GetToken( pCurToken, nCurTokenLen );
 367                 }
 368                 else
 369                     nCol--;
 370             }
 371         }
 372         nCur++;
 373     }
 374     GetModel()->InvalidateEntry( pEntry );
 375
 376     TabListBoxEventData* pData = new TabListBoxEventData( pEntry, nTextColumn, sOldText );
 377     ImplCallEventListeners( VCLEVENT_TABLECELL_NAMECHANGED, pData );
 378     delete pData;
 379 }
 380
 381 String SvTabListBox::GetCellText( ULONG nPos, USHORT nCol ) const
 382 {
 383     SvLBoxEntry* pEntry = GetEntryOnPos( nPos );
 384     DBG_ASSERT( pEntry, "SvTabListBox::GetCellText(): Invalid Entry" );
 385     XubString aResult;
 386     if ( pEntry && pEntry->ItemCount() > ( nCol + 1 ) )
 387     {
 388         SvLBoxItem* pStr = pEntry->GetItem( nCol + 1 );
 389         if ( pStr && pStr->IsA() == SV_ITEM_ID_LBOXSTRING )
 390             aResult = static_cast< SvLBoxString* >( pStr )->GetText();
 391     }
 392     return aResult;
 393 }
 394
 395 ULONG SvTabListBox::GetEntryPos( const XubString& rStr, USHORT nCol )
 396 {
 397     ULONG nPos = 0;
 398     SvLBoxEntry* pEntry = First();
 399     while( pEntry )
 400     {
 401         XubString aStr( GetEntryText( pEntry, nCol ));
 402         if( aStr == rStr )
 403             return nPos;
 404         pEntry = Next( pEntry );
 405         nPos++;
 406     }
 407     return 0xffffffff;
 408 }
 409
 410 ULONG SvTabListBox::GetEntryPos( const SvLBoxEntry* pEntry ) const
 411 {
 412     ULONG nPos = 0;
 413     SvLBoxEntry* pTmpEntry = First();
 414     while( pTmpEntry )
 415     {
 416         if ( pTmpEntry == pEntry )
 417             return nPos;
 418         pTmpEntry = Next( pTmpEntry );
 419         ++nPos;
 420     }
 421     return 0xffffffff;
 422 }
 423
 424 void __EXPORT SvTabListBox::Resize()
 425 {
 426     SvTreeListBox::Resize();
 427 }
 428
 429 // static
 430 const xub_Unicode* SvTabListBox::GetToken( const xub_Unicode* pPtr, USHORT& rLen )
 431 {
 432     if( !pPtr || *pPtr == 0 )
 433     {
 434         rLen = 0;
 435         return 0;
 436     }
 437     xub_Unicode c = *pPtr;
 438     USHORT nLen = 0;
 439     while( c != '\t' && c != 0 )
 440     {
 441         pPtr++;
 442         nLen++;
 443         c = *pPtr;
 444     }
 445     if( c )
 446         pPtr++; // Tab ueberspringen
 447     else
 448         pPtr = 0;
 449     rLen = nLen;
 450     return pPtr;
 451 }
 452
 453 String SvTabListBox::GetTabEntryText( ULONG nPos, USHORT nCol ) const
 454 {
 455     SvLBoxEntry* pEntry = SvTreeListBox::GetEntry( nPos );
 456     DBG_ASSERT( pEntry, "GetTabEntryText(): Invalid entry " );
 457     XubString aResult;
 458     if ( pEntry )
 459     {
 460         USHORT nCount = pEntry->ItemCount();
 461         USHORT nCur = ( 0 == nCol && IsCellFocusEnabled() ) ? GetCurrentTabPos() : 0;
 462         while( nCur < nCount )
 463         {
 464             SvLBoxItem* pStr = pEntry->GetItem( nCur );
 465             if ( pStr->IsA() == SV_ITEM_ID_LBOXSTRING )
 466             {
 467                 if ( nCol == 0xffff )
 468                 {
 469                     if ( aResult.Len() )
 470                         aResult += '\t';
 471                     aResult += static_cast<SvLBoxString*>( pStr )->GetText();
 472                 }
 473                 else
 474                 {
 475                     if ( nCol == 0 )
 476                     {
 477                         String sRet = static_cast<SvLBoxString*>( pStr )->GetText();
 478                         if ( sRet.Len() == 0 )
 479                             sRet = String( SvtResId( STR_SVT_ACC_EMPTY_FIELD ) );
 480                         return sRet;
 481                     }
 482                     --nCol;
 483                 }
 484             }
 485             ++nCur;
 486         }
 487     }
 488     return aResult;
 489 }
 490
 491 SvLBoxEntry* SvTabListBox::GetEntryOnPos( ULONG _nEntryPos ) const
 492 {
 493     SvLBoxEntry* pEntry = NULL;
 494     ULONG i, nPos = 0, nCount = GetLevelChildCount( NULL );
 495     for ( i = 0; i < nCount; ++i )
 496     {
 497         SvLBoxEntry* pParent = GetEntry(i);
 498         if ( nPos == _nEntryPos )
 499         {
 500             pEntry = pParent;
 501             break;
 502         }
 503         else
 504         {
 505             nPos++;
 506             pEntry = GetChildOnPos( pParent, _nEntryPos, nPos );
 507             if ( pEntry )
 508                 break;
 509         }
 510     }
 511
 512     return pEntry;
 513 }
 514
 515 SvLBoxEntry* SvTabListBox::GetChildOnPos( SvLBoxEntry* _pParent, ULONG _nEntryPos, ULONG& _rPos ) const
 516 {
 517     ULONG i, nCount = GetLevelChildCount( _pParent );
 518     for ( i = 0; i < nCount; ++i )
 519     {
 520         SvLBoxEntry* pParent = GetEntry( _pParent, i );
 521         if ( _rPos == _nEntryPos )
 522             return pParent;
 523         else
 524         {
 525             _rPos++;
 526             SvLBoxEntry* pEntry = GetChildOnPos( pParent, _nEntryPos, _rPos );
 527             if ( pEntry )
 528                 return pEntry;
 529         }
 530     }
 531
 532     return NULL;
 533 }
 534
 535 void SvTabListBox::SetTabJustify( USHORT nTab, SvTabJustify eJustify)
 536 {
 537     if( nTab >= nTabCount )
 538         return;
 539     SvLBoxTab* pTab = &(pTabList[ nTab ]);
 540     USHORT nFlags = pTab->nFlags;
 541     nFlags &= (~MYTABMASK);
 542     nFlags |= (USHORT)eJustify;
 543     pTab->nFlags = nFlags;
 544     SvTreeListBox::nTreeFlags |= TREEFLAG_RECALCTABS;
 545     if( IsUpdateMode() )
 546         Invalidate();
 547 }
 548
 549 SvTabJustify SvTabListBox::GetTabJustify( USHORT nTab ) const
 550 {
 551     SvTabJustify eResult = AdjustLeft;
 552     if( nTab >= nTabCount )
 553         return eResult;
 554     SvLBoxTab* pTab = &(pTabList[ nTab ]);
 555     USHORT nFlags = pTab->nFlags;
 556     nFlags &= MYTABMASK;
 557     eResult = (SvTabJustify)nFlags;
 558     return eResult;
 559 }
 560
 561 long SvTabListBox::GetLogicTab( USHORT nTab )
 562 {
 563     if( SvTreeListBox::nTreeFlags & TREEFLAG_RECALCTABS )
 564         ((SvTabListBox*)this)->SetTabs();
 565
 566     DBG_ASSERT(nTab<nTabCount,"GetTabPos:Invalid Tab");
 567     return ((SvLBoxTab*)aTabs.GetObject( nTab ))->GetPos();
 568 }
 569
 570 // class SvHeaderTabListBoxImpl ------------------------------------------
 571
 572 namespace svt
 573 {
 574     struct SvHeaderTabListBoxImpl
 575     {
 576         HeaderBar*              m_pHeaderBar;
 577         AccessibleFactoryAccess m_aFactoryAccess;
 578
 579         SvHeaderTabListBoxImpl() : m_pHeaderBar( NULL ) { }
 580     };
 581 }
 582
 583 // class SvHeaderTabListBox ----------------------------------------------
 584
 585 SvHeaderTabListBox::SvHeaderTabListBox( Window* pParent, WinBits nWinStyle ) :
 586
 587     SvTabListBox( pParent, nWinStyle ),
 588
 589     m_bFirstPaint       ( TRUE ),
 590     m_pImpl         ( new ::svt::SvHeaderTabListBoxImpl ),
 591     m_pAccessible       ( NULL )
 592 {
 593 }
 594
 595 // -----------------------------------------------------------------------
 596
 597 SvHeaderTabListBox::SvHeaderTabListBox( Window* pParent, const ResId& rResId ) :
 598
 599     SvTabListBox( pParent, rResId ),
 600
 601     m_bFirstPaint       ( TRUE ),
 602     m_pImpl         ( new ::svt::SvHeaderTabListBoxImpl ),
 603     m_pAccessible       ( NULL )
 604 {
 605 }
 606
 607 // -----------------------------------------------------------------------
 608
 609 SvHeaderTabListBox::~SvHeaderTabListBox()
 610 {
 611     delete m_pImpl;
 612 }
 613
 614 // -----------------------------------------------------------------------
 615
 616 void SvHeaderTabListBox::Paint( const Rectangle& rRect )
 617 {
 618     if ( m_bFirstPaint )
 619     {
 620         m_bFirstPaint = FALSE;
 621         RepaintScrollBars();
 622     }
 623     SvTabListBox::Paint( rRect );
 624 }
 625
 626 // -----------------------------------------------------------------------
 627
 628 void SvHeaderTabListBox::InitHeaderBar( HeaderBar* pHeaderBar )
 629 {
 630     DBG_ASSERT( !m_pImpl->m_pHeaderBar, "header bar already initialized" );
 631     DBG_ASSERT( pHeaderBar, "invalid header bar initialization" );
 632     m_pImpl->m_pHeaderBar = pHeaderBar;
 633     SetScrolledHdl( LINK( this, SvHeaderTabListBox, ScrollHdl_Impl ) );
 634     m_pImpl->m_pHeaderBar->SetCreateAccessibleHdl( LINK( this, SvHeaderTabListBox, CreateAccessibleHdl_Impl ) );
 635 }
 636
 637 // -----------------------------------------------------------------------
 638
 639 sal_Bool SvHeaderTabListBox::IsItemChecked( SvLBoxEntry* pEntry, USHORT nCol ) const
 640 {
 641     SvButtonState eState = SV_BUTTON_UNCHECKED;
 642     SvLBoxButton* pItem = (SvLBoxButton*)( pEntry->GetItem( nCol + 1 ) );
 643
 644     if ( pItem && ( (SvLBoxItem*)pItem )->IsA() == SV_ITEM_ID_LBOXBUTTON )
 645     {
 646         USHORT nButtonFlags = pItem->GetButtonFlags();
 647         eState = pCheckButtonData->ConvertToButtonState( nButtonFlags );
 648     }
 649
 650     return ( eState == SV_BUTTON_CHECKED );
 651 }
 652
 653 // -----------------------------------------------------------------------
 654
 655 SvLBoxEntry* SvHeaderTabListBox::InsertEntryToColumn(
 656     const XubString& rStr, ULONG nPos, USHORT nCol, void* pUserData )
 657 {
 658     SvLBoxEntry* pEntry = SvTabListBox::InsertEntryToColumn( rStr, nPos, nCol, pUserData );
 659     RecalculateAccessibleChildren();
 660     return pEntry;
 661 }
 662
 663 // -----------------------------------------------------------------------
 664
 665 SvLBoxEntry* SvHeaderTabListBox::InsertEntryToColumn(
 666     const XubString& rStr, SvLBoxEntry* pParent, ULONG nPos, USHORT nCol, void* pUserData )
 667 {
 668     SvLBoxEntry* pEntry = SvTabListBox::InsertEntryToColumn( rStr, pParent, nPos, nCol, pUserData );
 669     RecalculateAccessibleChildren();
 670     return pEntry;
 671 }
 672
 673 // -----------------------------------------------------------------------
 674
 675 SvLBoxEntry* SvHeaderTabListBox::InsertEntryToColumn(
 676     const XubString& rStr, const Image& rExpandedEntryBmp, const Image& rCollapsedEntryBmp,
 677     SvLBoxEntry* pParent, ULONG nPos, USHORT nCol, void* pUserData )
 678 {
 679     SvLBoxEntry* pEntry = SvTabListBox::InsertEntryToColumn(
 680         rStr, rExpandedEntryBmp, rCollapsedEntryBmp, pParent, nPos, nCol, pUserData );
 681     RecalculateAccessibleChildren();
 682     return pEntry;
 683 }
 684
 685 // -----------------------------------------------------------------------
 686
 687 ULONG SvHeaderTabListBox::Insert(
 688     SvLBoxEntry* pEnt, SvLBoxEntry* pPar, ULONG nPos )
 689 {
 690     ULONG n = SvTabListBox::Insert( pEnt, pPar, nPos );
 691     RecalculateAccessibleChildren();
 692     return n;
 693 }
 694
 695 // -----------------------------------------------------------------------
 696
 697 ULONG SvHeaderTabListBox::Insert( SvLBoxEntry* pEntry, ULONG nRootPos )
 698 {
 699     ULONG nPos = SvTabListBox::Insert( pEntry, nRootPos );
 700     RecalculateAccessibleChildren();
 701     return nPos;
 702 }
 703
 704 // -----------------------------------------------------------------------
 705
 706 void SvHeaderTabListBox::RemoveEntry( SvLBoxEntry* _pEntry )
 707 {
 708     GetModel()->Remove( _pEntry );
 709     m_aAccessibleChildren.clear();
 710 }
 711
 712 // -----------------------------------------------------------------------
 713
 714 void SvHeaderTabListBox::Clear()
 715 {
 716     SvTabListBox::Clear();
 717     m_aAccessibleChildren.clear();
 718 }
 719
 720 // -----------------------------------------------------------------------
 721
 722 IMPL_LINK( SvHeaderTabListBox, ScrollHdl_Impl, SvTabListBox*, EMPTYARG )
 723 {
 724     m_pImpl->m_pHeaderBar->SetOffset( -GetXOffset() );
 725     return 0;
 726 }
 727
 728 // -----------------------------------------------------------------------
 729
 730 IMPL_LINK( SvHeaderTabListBox, CreateAccessibleHdl_Impl, HeaderBar*, EMPTYARG )
 731 {
 732     Window* pParent = m_pImpl->m_pHeaderBar->GetAccessibleParentWindow();
 733     DBG_ASSERT( pParent, "SvHeaderTabListBox..CreateAccessibleHdl_Impl - accessible parent not found" );
 734     if ( pParent )
 735     {
 736         ::com::sun::star::uno::Reference< XAccessible > xAccParent = pParent->GetAccessible();
 737         if ( xAccParent.is() )
 738         {
 739             Reference< XAccessible > xAccessible = m_pImpl->m_aFactoryAccess.getFactory().createAccessibleBrowseBoxHeaderBar(
 740                 xAccParent, *this, ::svt::BBTYPE_COLUMNHEADERBAR );
 741             m_pImpl->m_pHeaderBar->SetAccessible( xAccessible );
 742         }
 743     }
 744     return 0;
 745 }
 746
 747 // -----------------------------------------------------------------------
 748
 749 void SvHeaderTabListBox::RecalculateAccessibleChildren()
 750 {
 751     if ( !m_aAccessibleChildren.empty() )
 752     {
 753         sal_uInt32 nCount = ( GetRowCount() + 1 ) * GetColumnCount();
 754         if ( m_aAccessibleChildren.size() < nCount )
 755             m_aAccessibleChildren.resize( nCount );
 756         else
 757         {
 758             DBG_ASSERT( m_aAccessibleChildren.size() == nCount, "wrong children count" );
 759         }
 760     }
 761 }
 762
 763 // -----------------------------------------------------------------------
 764
 765 sal_Bool SvHeaderTabListBox::IsCellCheckBox( long _nRow, sal_uInt16 _nColumn, TriState& _rState )
 766 {
 767     sal_Bool bRet = sal_False;
 768     SvLBoxEntry* pEntry = GetEntry( _nRow );
 769     if ( pEntry )
 770     {
 771         USHORT nItemCount = pEntry->ItemCount();
 772         if ( nItemCount > ( _nColumn + 1 ) )
 773         {
 774             SvLBoxButton* pItem = (SvLBoxButton*)( pEntry->GetItem( _nColumn + 1 ) );
 775             if ( pItem && ( (SvLBoxItem*)pItem )->IsA() == SV_ITEM_ID_LBOXBUTTON )
 776             {
 777                 bRet = sal_True;
 778                 _rState = ( ( pItem->GetButtonFlags() & SV_ITEMSTATE_UNCHECKED ) == 0 )
 779                             ? STATE_CHECK : STATE_NOCHECK;
 780             }
 781         }
 782         else
 783         {
 784             DBG_ERRORFILE( "SvHeaderTabListBox::IsCellCheckBox(): column out of range" );
 785         }
 786     }
 787     return bRet;
 788 }
 789
 790 // -----------------------------------------------------------------------
 791 long SvHeaderTabListBox::GetRowCount() const
 792 {
 793     return GetEntryCount();
 794 }
 795 // -----------------------------------------------------------------------
 796 sal_uInt16 SvHeaderTabListBox::GetColumnCount() const
 797 {
 798     return m_pImpl->m_pHeaderBar->GetItemCount();
 799 }
 800 // -----------------------------------------------------------------------
 801 sal_Int32 SvHeaderTabListBox::GetCurrRow() const
 802 {
 803     sal_Int32 nRet = -1;
 804     SvLBoxEntry* pEntry = GetCurEntry();
 805     if ( pEntry )
 806     {
 807         ULONG nCount = GetEntryCount();
 808         for ( ULONG i = 0; i < nCount; ++i )
 809         {
 810             if ( pEntry == GetEntry(i) )
 811             {
 812                 nRet = i;
 813                 break;
 814             }
 815         }
 816     }
 817
 818     return nRet;
 819 }
 820 // -----------------------------------------------------------------------
 821 sal_uInt16 SvHeaderTabListBox::GetCurrColumn() const
 822 {
 823     sal_uInt16 nPos = GetCurrentTabPos() - 1;
 824     return nPos;
 825 }
 826 // -----------------------------------------------------------------------
 827 ::rtl::OUString SvHeaderTabListBox::GetRowDescription( sal_Int32 _nRow ) const
 828 {
 829     return ::rtl::OUString( GetEntryText( _nRow ) );
 830 }
 831 // -----------------------------------------------------------------------
 832 ::rtl::OUString SvHeaderTabListBox::GetColumnDescription( sal_uInt16 _nColumn ) const
 833 {
 834     return ::rtl::OUString( m_pImpl->m_pHeaderBar->GetItemText( m_pImpl->m_pHeaderBar->GetItemId( _nColumn ) ) );
 835 }
 836 // -----------------------------------------------------------------------
 837 sal_Bool SvHeaderTabListBox::HasRowHeader() const
 838 {
 839     return sal_False;
 840 }
 841 // -----------------------------------------------------------------------
 842 sal_Bool SvHeaderTabListBox::IsCellFocusable() const
 843 {
 844     return IsCellFocusEnabled();
 845 }
 846 // -----------------------------------------------------------------------
 847 sal_Bool SvHeaderTabListBox::GoToCell( sal_Int32 _nRow, sal_uInt16 _nColumn )
 848 {
 849     sal_Bool bRet = ( IsCellFocusEnabled() == TRUE );
 850     if ( bRet )
 851     {
 852         // first set cursor to _nRow
 853         SetCursor( GetEntry( _nRow ), TRUE );
 854         // then set the focus into _nColumn
 855         bRet = ( SetCurrentTabPos( _nColumn ) == true );
 856     }
 857     return bRet;
 858 }
 859 // -----------------------------------------------------------------------
 860 void SvHeaderTabListBox::SetNoSelection()
 861 {
 862     SvLBox::SelectAll( FALSE );
 863 }
 864 // -----------------------------------------------------------------------
 865 void SvHeaderTabListBox::SelectAll()
 866 {
 867     SvLBox::SelectAll( TRUE );
 868 }
 869 // -----------------------------------------------------------------------
 870 void SvHeaderTabListBox::SelectAll( BOOL bSelect, BOOL bPaint )
 871 {
 872     // overwritten just to disambiguate the SelectAll() from the base' class SelectAll( BOOl, BOOL )
 873     SvTabListBox::SelectAll( bSelect, bPaint );
 874 }
 875
 876 // -----------------------------------------------------------------------
 877 void SvHeaderTabListBox::SelectRow( long _nRow, BOOL _bSelect, BOOL )
 878 {
 879     Select( GetEntry( _nRow ), _bSelect );
 880 }
 881 // -----------------------------------------------------------------------
 882 void SvHeaderTabListBox::SelectColumn( sal_uInt16, sal_Bool )
 883 {
 884 }
 885 // -----------------------------------------------------------------------
 886 sal_Int32 SvHeaderTabListBox::GetSelectedRowCount() const
 887 {
 888     return GetSelectionCount();
 889 }
 890 // -----------------------------------------------------------------------
 891 sal_Int32 SvHeaderTabListBox::GetSelectedColumnCount() const
 892 {
 893     return 0;
 894 }
 895 // -----------------------------------------------------------------------
 896 bool SvHeaderTabListBox::IsRowSelected( long _nRow ) const
 897 {
 898     SvLBoxEntry* pEntry = GetEntry( _nRow );
 899     return ( pEntry && IsSelected( pEntry ) );
 900 }
 901 // -----------------------------------------------------------------------
 902 sal_Bool SvHeaderTabListBox::IsColumnSelected( long ) const
 903 {
 904     return FALSE;
 905 }
 906 // -----------------------------------------------------------------------
 907 void SvHeaderTabListBox::GetAllSelectedRows( ::com::sun::star::uno::Sequence< sal_Int32 >& ) const
 908 {
 909 }
 910 // -----------------------------------------------------------------------
 911 void SvHeaderTabListBox::GetAllSelectedColumns( ::com::sun::star::uno::Sequence< sal_Int32 >& ) const
 912 {
 913 }
 914 // -----------------------------------------------------------------------
 915 sal_Bool SvHeaderTabListBox::IsCellVisible( sal_Int32, sal_uInt16 ) const
 916 {
 917     return sal_True;
 918 }
 919 // -----------------------------------------------------------------------
 920 String SvHeaderTabListBox::GetAccessibleCellText( long _nRow, USHORT _nColumnPos ) const
 921 {
 922     return ::rtl::OUString( GetTabEntryText( _nRow, _nColumnPos ) );
 923 }
 924 // -----------------------------------------------------------------------
 925 Rectangle SvHeaderTabListBox::calcHeaderRect( sal_Bool _bIsColumnBar, BOOL _bOnScreen )
 926 {
 927     Rectangle aRect;
 928     if ( _bIsColumnBar )
 929     {
 930         Window* pParent = NULL;
 931         if ( !_bOnScreen )
 932             pParent = m_pImpl->m_pHeaderBar->GetAccessibleParentWindow();
 933
 934         aRect = m_pImpl->m_pHeaderBar->GetWindowExtentsRelative( pParent );
 935     }
 936     return aRect;
 937 }
 938 // -----------------------------------------------------------------------
 939 Rectangle SvHeaderTabListBox::calcTableRect( BOOL _bOnScreen )
 940 {
 941     Window* pParent = NULL;
 942     if ( !_bOnScreen )
 943         pParent = GetAccessibleParentWindow();
 944
 945     Rectangle aRect( GetWindowExtentsRelative( pParent ) );
 946     return aRect;
 947 }
 948 // -----------------------------------------------------------------------
 949 Rectangle SvHeaderTabListBox::GetFieldRectPixelAbs( sal_Int32 _nRow, sal_uInt16 _nColumn, BOOL _bIsHeader, BOOL _bOnScreen )
 950 {
 951     DBG_ASSERT( !_bIsHeader || 0 == _nRow, "invalid parameters" );
 952     Rectangle aRect;
 953     SvLBoxEntry* pEntry = GetEntry( _nRow );
 954     if ( pEntry )
 955     {
 956         aRect = _bIsHeader ? calcHeaderRect( sal_True, FALSE ) : GetBoundingRect( pEntry );
 957         Point aTopLeft = aRect.TopLeft();
 958         DBG_ASSERT( m_pImpl->m_pHeaderBar->GetItemCount() > _nColumn, "invalid column" );
 959         Rectangle aItemRect = m_pImpl->m_pHeaderBar->GetItemRect( m_pImpl->m_pHeaderBar->GetItemId( _nColumn ) );
 960         aTopLeft.X() = aItemRect.Left();
 961         Size aSize = aItemRect.GetSize();
 962         aRect = Rectangle( aTopLeft, aSize );
 963         Window* pParent = NULL;
 964         if ( !_bOnScreen )
 965             pParent = GetAccessibleParentWindow();
 966         aTopLeft = aRect.TopLeft();
 967         aTopLeft += GetWindowExtentsRelative( pParent ).TopLeft();
 968         aRect = Rectangle( aTopLeft, aRect.GetSize() );
 969     }
 970
 971     return aRect;
 972 }
 973 // -----------------------------------------------------------------------
 974 Reference< XAccessible > SvHeaderTabListBox::CreateAccessibleCell( sal_Int32 _nRow, sal_uInt16 _nColumnPos )
 975 {
 976     OSL_ENSURE( m_pAccessible, "Invalid call: Accessible is null" );
 977
 978     Reference< XAccessible > xChild;
 979     sal_Int32 nIndex = -1;
 980
 981     if ( !AreChildrenTransient() )
 982     {
 983         const sal_uInt16 nColumnCount = GetColumnCount();
 984
 985         // first call? -> initial list
 986         if ( m_aAccessibleChildren.empty() )
 987         {
 988             sal_Int32 nCount = ( GetRowCount() + 1 ) * nColumnCount;
 989             m_aAccessibleChildren.assign( nCount, Reference< XAccessible >() );
 990         }
 991
 992         nIndex = ( _nRow * nColumnCount ) + _nColumnPos + nColumnCount;
 993         xChild = m_aAccessibleChildren[ nIndex ];
 994     }
 995
 996     if ( !xChild.is() )
 997     {
 998         TriState eState = STATE_DONTKNOW;
 999         sal_Bool bIsCheckBox = IsCellCheckBox( _nRow, _nColumnPos, eState );
1000         if ( bIsCheckBox )
1001             xChild = m_pImpl->m_aFactoryAccess.getFactory().createAccessibleCheckBoxCell(
1002                 m_pAccessible->getAccessibleChild( 0 ), *this, NULL, _nRow, _nColumnPos, eState, sal_True, sal_False );
1003         else
1004             xChild = m_pImpl->m_aFactoryAccess.getFactory().createAccessibleBrowseBoxTableCell(
1005                 m_pAccessible->getAccessibleChild( 0 ), *this, NULL, _nRow, _nColumnPos, OFFSET_NONE );
1006
1007         // insert into list
1008         if ( !AreChildrenTransient() )
1009             m_aAccessibleChildren[ nIndex ] = xChild;
1010     }
1011
1012     return xChild;
1013 }
1014 // -----------------------------------------------------------------------
1015 Reference< XAccessible > SvHeaderTabListBox::CreateAccessibleRowHeader( sal_Int32 )
1016 {
1017     Reference< XAccessible > xHeader;
1018     return xHeader;
1019 }
1020 // -----------------------------------------------------------------------
1021 Reference< XAccessible > SvHeaderTabListBox::CreateAccessibleColumnHeader( sal_uInt16 _nColumn )
1022 {
1023     // first call? -> initial list
1024     if ( m_aAccessibleChildren.empty() )
1025     {
1026         const sal_uInt16 nColumnCount = GetColumnCount();
1027         sal_Int32 nCount = AreChildrenTransient() ?
1028                 nColumnCount : ( GetRowCount() + 1 ) * nColumnCount;
1029         m_aAccessibleChildren.assign( nCount, Reference< XAccessible >() );
1030     }
1031
1032     // get header
1033     Reference< XAccessible > xChild = m_aAccessibleChildren[ _nColumn ];
1034     // already exists?
1035     if ( !xChild.is() && m_pAccessible )
1036     {
1037         // no -> create new header cell
1038         xChild = m_pImpl->m_aFactoryAccess.getFactory().createAccessibleBrowseBoxHeaderCell(
1039             _nColumn, m_pAccessible->getHeaderBar( ::svt::BBTYPE_COLUMNHEADERBAR ),
1040             *this, NULL, ::svt::BBTYPE_COLUMNHEADERCELL
1041         );
1042
1043         // insert into list
1044         m_aAccessibleChildren[ _nColumn ] = xChild;
1045     }
1046
1047     return xChild;
1048 }
1049 // -----------------------------------------------------------------------
1050 sal_Int32 SvHeaderTabListBox::GetAccessibleControlCount() const
1051 {
1052     return -1;
1053 }
1054 // -----------------------------------------------------------------------
1055 Reference< XAccessible > SvHeaderTabListBox::CreateAccessibleControl( sal_Int32 )
1056 {
1057     Reference< XAccessible > xControl;
1058     return xControl;
1059 }
1060 // -----------------------------------------------------------------------
1061 sal_Bool SvHeaderTabListBox::ConvertPointToControlIndex( sal_Int32&, const Point& )
1062 {
1063     return sal_False;
1064 }
1065 // -----------------------------------------------------------------------
1066 sal_Bool SvHeaderTabListBox::ConvertPointToCellAddress( sal_Int32&, sal_uInt16&, const Point& )
1067 {
1068     return sal_False;
1069 }
1070 // -----------------------------------------------------------------------
1071 sal_Bool SvHeaderTabListBox::ConvertPointToRowHeader( sal_Int32&, const Point& )
1072 {
1073     return sal_False;
1074 }
1075 // -----------------------------------------------------------------------
1076 sal_Bool SvHeaderTabListBox::ConvertPointToColumnHeader( sal_uInt16&, const Point& )
1077 {
1078     return sal_False;
1079 }
1080 // -----------------------------------------------------------------------
1081 ::rtl::OUString SvHeaderTabListBox::GetAccessibleObjectName( ::svt::AccessibleBrowseBoxObjType _eType, sal_Int32 _nPos ) const
1082 {
1083     ::rtl::OUString aRetText;
1084     switch( _eType )
1085     {
1086         case ::svt::BBTYPE_BROWSEBOX:
1087         case ::svt::BBTYPE_TABLE:
1088         case ::svt::BBTYPE_COLUMNHEADERBAR:
1089             // should be empty now (see #i63983)
1090             aRetText = ::rtl::OUString();
1091             break;
1092
1093         case ::svt::BBTYPE_TABLECELL:
1094         {
1095             // here we need a valid pos, we can not handle -1
1096             if ( _nPos >= 0 )
1097             {
1098                 sal_uInt16 nColumnCount = GetColumnCount();
1099                 if (nColumnCount > 0)
1100                 {
1101                     sal_Int32 nRow = _nPos / nColumnCount;
1102                     sal_uInt16 nColumn  = static_cast< sal_uInt16 >( _nPos % nColumnCount );
1103                     aRetText = GetCellText( nRow, nColumn );
1104                 }
1105             }
1106             break;
1107         }
1108         case ::svt::BBTYPE_CHECKBOXCELL:
1109         {
1110             break; // checkbox cells have no name
1111         }
1112         case ::svt::BBTYPE_COLUMNHEADERCELL:
1113         {
1114             aRetText = m_pImpl->m_pHeaderBar->GetItemText( m_pImpl->m_pHeaderBar->GetItemId( (USHORT)_nPos ) );
1115             break;
1116         }
1117
1118         case ::svt::BBTYPE_ROWHEADERBAR:
1119         case ::svt::BBTYPE_ROWHEADERCELL:
1120             aRetText = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "error" ) );
1121             break;
1122
1123         default:
1124             OSL_ENSURE(0,"BrowseBox::GetAccessibleName: invalid enum!");
1125     }
1126     return aRetText;
1127 }
1128 // -----------------------------------------------------------------------
1129 ::rtl::OUString SvHeaderTabListBox::GetAccessibleObjectDescription( ::svt::AccessibleBrowseBoxObjType _eType, sal_Int32 _nPos ) const
1130 {
1131     ::rtl::OUString aRetText;
1132
1133     if( _eType == ::svt::BBTYPE_TABLECELL && _nPos != -1 )
1134     {
1135         static const String sVar1( RTL_CONSTASCII_USTRINGPARAM( "%1" ) );
1136         static const String sVar2( RTL_CONSTASCII_USTRINGPARAM( "%2" ) );
1137
1138         sal_uInt16 nColumnCount = GetColumnCount();
1139         if (nColumnCount > 0)
1140         {
1141             sal_Int32 nRow = _nPos / nColumnCount;
1142             sal_uInt16 nColumn  = static_cast< sal_uInt16 >( _nPos % nColumnCount );
1143
1144             String aText( SvtResId( STR_SVT_ACC_DESC_TABLISTBOX ) );
1145             aText.SearchAndReplace( sVar1, String::CreateFromInt32( nRow ) );
1146             String sColHeader = m_pImpl->m_pHeaderBar->GetItemText( m_pImpl->m_pHeaderBar->GetItemId( nColumn ) );
1147             if ( sColHeader.Len() == 0 )
1148                 sColHeader = String::CreateFromInt32( nColumn );
1149             aText.SearchAndReplace( sVar2, sColHeader );
1150             aRetText = aText;
1151         }
1152     }
1153
1154     return aRetText;
1155 }
1156 // -----------------------------------------------------------------------
1157 void SvHeaderTabListBox::FillAccessibleStateSet( ::utl::AccessibleStateSetHelper& _rStateSet, ::svt::AccessibleBrowseBoxObjType _eType ) const
1158 {
1159     switch( _eType )
1160     {
1161         case ::svt::BBTYPE_BROWSEBOX:
1162         case ::svt::BBTYPE_TABLE:
1163         {
1164             _rStateSet.AddState( AccessibleStateType::FOCUSABLE );
1165             if ( HasFocus() )
1166                 _rStateSet.AddState( AccessibleStateType::FOCUSED );
1167             if ( IsActive() )
1168                 _rStateSet.AddState( AccessibleStateType::ACTIVE );
1169             if ( IsEnabled() )
1170             {
1171                 _rStateSet.AddState( AccessibleStateType::ENABLED );
1172                 _rStateSet.AddState( AccessibleStateType::SENSITIVE );
1173             }
1174             if ( IsReallyVisible() )
1175                 _rStateSet.AddState( AccessibleStateType::VISIBLE );
1176             if ( _eType == ::svt::BBTYPE_TABLE )
1177             {
1178
1179                 if ( AreChildrenTransient() )
1180                     _rStateSet.AddState( AccessibleStateType::MANAGES_DESCENDANTS );
1181                 _rStateSet.AddState( AccessibleStateType::MULTI_SELECTABLE );
1182             }
1183             break;
1184         }
1185
1186         case ::svt::BBTYPE_COLUMNHEADERBAR:
1187         {
1188             sal_Int32 nCurRow = GetCurrRow();
1189             sal_uInt16 nCurColumn = GetCurrColumn();
1190             if ( IsCellVisible( nCurRow, nCurColumn ) )
1191                 _rStateSet.AddState( AccessibleStateType::VISIBLE );
1192             _rStateSet.AddState( AccessibleStateType::TRANSIENT );
1193             break;
1194         }
1195
1196         case ::svt::BBTYPE_ROWHEADERCELL:
1197         case ::svt::BBTYPE_COLUMNHEADERCELL:
1198         {
1199             _rStateSet.AddState( AccessibleStateType::VISIBLE );
1200             _rStateSet.AddState( AccessibleStateType::FOCUSABLE );
1201             _rStateSet.AddState( AccessibleStateType::TRANSIENT );
1202             break;
1203         }
1204         default:
1205             break;
1206     }
1207 }
1208 // -----------------------------------------------------------------------
1209 void SvHeaderTabListBox::FillAccessibleStateSetForCell( ::utl::AccessibleStateSetHelper& _rStateSet, sal_Int32 _nRow, sal_uInt16 _nColumn ) const
1210 {
1211     _rStateSet.AddState( AccessibleStateType::SELECTABLE );
1212     if ( AreChildrenTransient() )
1213         _rStateSet.AddState( AccessibleStateType::TRANSIENT );
1214
1215     if ( IsCellVisible( _nRow, _nColumn ) )
1216     {
1217         _rStateSet.AddState( AccessibleStateType::VISIBLE );
1218         _rStateSet.AddState( AccessibleStateType::ENABLED );
1219     }
1220
1221     if ( IsRowSelected( _nRow ) )
1222     {
1223         _rStateSet.AddState( AccessibleStateType::ACTIVE );
1224         _rStateSet.AddState( AccessibleStateType::SELECTED );
1225     }
1226 }
1227 // -----------------------------------------------------------------------
1228 void SvHeaderTabListBox::GrabTableFocus()
1229 {
1230     GrabFocus();
1231 }
1232 // -----------------------------------------------------------------------
1233 BOOL SvHeaderTabListBox::GetGlyphBoundRects( const Point& rOrigin, const String& rStr, int nIndex, int nLen, int nBase, MetricVector& rVector )
1234 {
1235     return Control::GetGlyphBoundRects( rOrigin, rStr, nIndex, nLen, nBase, rVector );
1236 }
1237 // -----------------------------------------------------------------------
1238 Rectangle SvHeaderTabListBox::GetWindowExtentsRelative( Window *pRelativeWindow )
1239 {
1240     return Control::GetWindowExtentsRelative( pRelativeWindow );
1241 }
1242 // -----------------------------------------------------------------------
1243 void SvHeaderTabListBox::GrabFocus()
1244 {
1245     Control::GrabFocus();
1246 }
1247 // -----------------------------------------------------------------------
1248 Reference< XAccessible > SvHeaderTabListBox::GetAccessible( BOOL bCreate )
1249 {
1250     return Control::GetAccessible( bCreate );
1251 }
1252 // -----------------------------------------------------------------------
1253 Window* SvHeaderTabListBox::GetAccessibleParentWindow() const
1254 {
1255     return Control::GetAccessibleParentWindow();
1256 }
1257 // -----------------------------------------------------------------------
1258 Window* SvHeaderTabListBox::GetWindowInstance()
1259 {
1260     return this;
1261 }
1262 // -----------------------------------------------------------------------
1263 Reference< XAccessible > SvHeaderTabListBox::CreateAccessible()
1264 {
1265     Window* pParent = GetAccessibleParentWindow();
1266     DBG_ASSERT( pParent, "SvHeaderTabListBox::::CreateAccessible - accessible parent not found" );
1267
1268     Reference< XAccessible > xAccessible;
1269     if ( m_pAccessible ) xAccessible = m_pAccessible->getMyself();
1270
1271     if( pParent && !m_pAccessible )
1272     {
1273         Reference< XAccessible > xAccParent = pParent->GetAccessible();
1274         if ( xAccParent.is() )
1275         {
1276             m_pAccessible = m_pImpl->m_aFactoryAccess.getFactory().createAccessibleTabListBox( xAccParent, *this );
1277             if ( m_pAccessible )
1278                 xAccessible = m_pAccessible->getMyself();
1279         }
1280     }
1281     return xAccessible;
1282 }
1283 // -----------------------------------------------------------------------------
1284 Rectangle SvHeaderTabListBox::GetFieldCharacterBounds(sal_Int32,sal_Int32,sal_Int32)
1285 {
1286     Rectangle aRect;
1287     return aRect;
1288 }
1289 // -----------------------------------------------------------------------------
1290 sal_Int32 SvHeaderTabListBox::GetFieldIndexAtPoint(sal_Int32 _nRow,sal_Int32 _nColumnPos,const Point& _rPoint)
1291 {
1292     String sText = GetAccessibleCellText( _nRow, static_cast< USHORT >( _nColumnPos ) );
1293     MetricVector aRects;
1294     if ( GetGlyphBoundRects(Point(0,0),sText,0,STRING_LEN,0,aRects) )
1295     {
1296         for (MetricVector::iterator aIter = aRects.begin(); aIter != aRects.end(); ++aIter)
1297         {
1298             if( aIter->IsInside(_rPoint) )
1299                 return aIter - aRects.begin();
1300         }
1301     }
1302
1303     return -1;
1304 }
1305 // -----------------------------------------------------------------------------
1306
1307