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