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