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