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