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