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