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/brwbox.hxx>
21 : #include <svtools/brwhead.hxx>
22 : #include <o3tl/numeric.hxx>
23 : #include "datwin.hxx"
24 : #include <tools/debug.hxx>
25 : #include <tools/stream.hxx>
26 : #include <tools/fract.hxx>
27 :
28 : #include <functional>
29 : #include <algorithm>
30 : #include <com/sun/star/accessibility/AccessibleTableModelChange.hpp>
31 : #include <com/sun/star/accessibility/AccessibleTableModelChangeType.hpp>
32 : #include <com/sun/star/accessibility/AccessibleEventId.hpp>
33 : #include <com/sun/star/accessibility/XAccessible.hpp>
34 : #include <tools/multisel.hxx>
35 : #include "brwimpl.hxx"
36 :
37 :
38 : #define SCROLL_FLAGS (ScrollFlags::Clip | ScrollFlags::NoChildren)
39 : #define getDataWindow() (static_cast<BrowserDataWin*>(pDataWin.get()))
40 :
41 : using namespace com::sun::star::accessibility::AccessibleEventId;
42 : using namespace com::sun::star::accessibility::AccessibleTableModelChangeType;
43 : using com::sun::star::accessibility::AccessibleTableModelChange;
44 : using com::sun::star::lang::XComponent;
45 : using namespace ::com::sun::star::uno;
46 : using namespace svt;
47 :
48 : namespace
49 : {
50 0 : void disposeAndClearHeaderCell(::svt::BrowseBoxImpl::THeaderCellMap& _rHeaderCell)
51 : {
52 : ::std::for_each(
53 : _rHeaderCell.begin(),
54 : _rHeaderCell.end(),
55 : ::svt::BrowseBoxImpl::THeaderCellMapFunctorDispose()
56 0 : );
57 0 : _rHeaderCell.clear();
58 0 : }
59 : }
60 :
61 20 : void BrowseBox::ConstructImpl( BrowserMode nMode )
62 : {
63 : OSL_TRACE( "BrowseBox: %p->ConstructImpl", this );
64 20 : bMultiSelection = false;
65 20 : pColSel = 0;
66 20 : pDataWin = 0;
67 20 : pVScroll = 0;
68 :
69 20 : pDataWin = VclPtr<BrowserDataWin>::Create( this ).get();
70 20 : pCols = new BrowserColumns;
71 20 : m_pImpl.reset( new ::svt::BrowseBoxImpl() );
72 :
73 20 : aGridLineColor = Color( COL_LIGHTGRAY );
74 20 : InitSettings_Impl( this );
75 20 : InitSettings_Impl( pDataWin );
76 :
77 20 : bBootstrapped = false;
78 20 : nDataRowHeight = 0;
79 20 : nTitleLines = 1;
80 20 : nFirstCol = 0;
81 20 : nTopRow = 0;
82 20 : nCurRow = BROWSER_ENDOFSELECTION;
83 20 : nCurColId = 0;
84 20 : bResizing = false;
85 20 : bSelect = false;
86 20 : bSelecting = false;
87 20 : bScrolling = false;
88 20 : bSelectionIsVisible = false;
89 20 : bNotToggleSel = false;
90 20 : bRowDividerDrag = false;
91 20 : bHit = false;
92 20 : mbInteractiveRowHeight = false;
93 20 : bHideSelect = false;
94 20 : bHideCursor = TRISTATE_FALSE;
95 20 : nRowCount = 0;
96 20 : m_bFocusOnlyCursor = true;
97 20 : m_aCursorColor = COL_TRANSPARENT;
98 20 : m_nCurrentMode = BrowserMode::NONE;
99 20 : nControlAreaWidth = USHRT_MAX;
100 20 : uRow.nSel = BROWSER_ENDOFSELECTION;
101 :
102 20 : aHScroll->SetLineSize(1);
103 20 : aHScroll->SetScrollHdl( LINK( this, BrowseBox, ScrollHdl ) );
104 20 : aHScroll->SetEndScrollHdl( LINK( this, BrowseBox, EndScrollHdl ) );
105 20 : pDataWin->Show();
106 :
107 20 : SetMode( nMode );
108 20 : bSelectionIsVisible = bKeepHighlight;
109 20 : bHasFocus = HasChildPathFocus();
110 20 : getDataWindow()->nCursorHidden =
111 20 : ( bHasFocus ? 0 : 1 ) + ( GetUpdateMode() ? 0 : 1 );
112 20 : }
113 :
114 :
115 :
116 20 : BrowseBox::BrowseBox( vcl::Window* pParent, WinBits nBits, BrowserMode nMode )
117 : :Control( pParent, nBits | WB_3DLOOK )
118 : ,DragSourceHelper( this )
119 : ,DropTargetHelper( this )
120 20 : ,aHScroll( VclPtr<ScrollBar>::Create(this, WinBits( WB_HSCROLL )) )
121 : {
122 20 : ConstructImpl( nMode );
123 20 : }
124 :
125 :
126 :
127 0 : BrowseBox::BrowseBox( vcl::Window* pParent, const ResId& rId, BrowserMode nMode )
128 : :Control( pParent, rId )
129 : ,DragSourceHelper( this )
130 : ,DropTargetHelper( this )
131 0 : ,aHScroll( VclPtr<ScrollBar>::Create(this, WinBits(WB_HSCROLL)) )
132 : {
133 0 : ConstructImpl(nMode);
134 0 : }
135 :
136 :
137 40 : BrowseBox::~BrowseBox()
138 : {
139 20 : disposeOnce();
140 20 : }
141 :
142 20 : void BrowseBox::dispose()
143 : {
144 : OSL_TRACE( "BrowseBox: %p~", this );
145 :
146 20 : if ( m_pImpl->m_pAccessible )
147 : {
148 0 : disposeAndClearHeaderCell(m_pImpl->m_aColHeaderCellMap);
149 0 : disposeAndClearHeaderCell(m_pImpl->m_aRowHeaderCellMap);
150 0 : m_pImpl->m_pAccessible->dispose();
151 : }
152 :
153 20 : Hide();
154 20 : getDataWindow()->pHeaderBar.disposeAndClear();
155 20 : getDataWindow()->pCornerWin.disposeAndClear();
156 20 : pDataWin.disposeAndClear();
157 20 : pVScroll.disposeAndClear();
158 20 : aHScroll.disposeAndClear();
159 :
160 : // free columns-space
161 20 : for ( size_t i = 0, n = pCols->size(); i < n; ++i )
162 0 : delete (*pCols)[ i ];
163 20 : pCols->clear();
164 20 : delete pCols;
165 20 : delete pColSel;
166 20 : if ( bMultiSelection )
167 20 : delete uRow.pSel;
168 20 : Control::dispose();
169 20 : }
170 :
171 :
172 :
173 262 : short BrowseBox::GetCursorHideCount() const
174 : {
175 262 : return getDataWindow()->nCursorHidden;
176 : }
177 :
178 :
179 :
180 403 : void BrowseBox::DoShowCursor( const char * )
181 : {
182 403 : short nHiddenCount = --getDataWindow()->nCursorHidden;
183 403 : if (PaintCursorIfHiddenOnce())
184 : {
185 155 : if (1 == nHiddenCount)
186 131 : DrawCursor();
187 : }
188 : else
189 : {
190 248 : if (0 == nHiddenCount)
191 0 : DrawCursor();
192 : }
193 403 : }
194 :
195 :
196 :
197 403 : void BrowseBox::DoHideCursor( const char * )
198 : {
199 403 : short nHiddenCount = ++getDataWindow()->nCursorHidden;
200 403 : if (PaintCursorIfHiddenOnce())
201 : {
202 155 : if (2 == nHiddenCount)
203 131 : DrawCursor();
204 : }
205 : else
206 : {
207 248 : if (1 == nHiddenCount)
208 0 : DrawCursor();
209 : }
210 403 : }
211 :
212 :
213 :
214 67 : void BrowseBox::SetRealRowCount( const OUString &rRealRowCount )
215 : {
216 67 : getDataWindow()->aRealRowCount = rRealRowCount;
217 67 : }
218 :
219 :
220 :
221 0 : void BrowseBox::SetFont( const vcl::Font& rNewFont )
222 : {
223 0 : pDataWin->SetFont( rNewFont );
224 0 : ImpGetDataRowHeight();
225 0 : }
226 :
227 :
228 :
229 84 : sal_uLong BrowseBox::GetDefaultColumnWidth( const OUString& _rText ) const
230 : {
231 84 : return GetDataWindow().GetTextWidth( _rText ) + GetDataWindow().GetTextWidth(OUString('0')) * 4;
232 : }
233 :
234 :
235 :
236 33 : void BrowseBox::InsertHandleColumn( sal_uLong nWidth )
237 : {
238 :
239 : #if OSL_DEBUG_LEVEL > 0
240 : OSL_ENSURE( ColCount() == 0 || (*pCols)[0]->GetId() != HandleColumnId , "BrowseBox::InsertHandleColumn: there is already a handle column" );
241 : {
242 : BrowserColumns::iterator iCol = pCols->begin();
243 : const BrowserColumns::iterator colsEnd = pCols->end();
244 : if ( iCol != colsEnd )
245 : for (++iCol; iCol != colsEnd; ++iCol)
246 : OSL_ENSURE( (*iCol)->GetId() != HandleColumnId, "BrowseBox::InsertHandleColumn: there is a non-Handle column with handle ID" );
247 : }
248 : #endif
249 :
250 33 : pCols->insert( pCols->begin(), new BrowserColumn( 0, Image(), OUString(), nWidth, GetZoom() ) );
251 33 : FreezeColumn( 0 );
252 :
253 : // adjust headerbar
254 33 : if ( getDataWindow()->pHeaderBar )
255 : {
256 33 : getDataWindow()->pHeaderBar->SetPosSizePixel(
257 : Point(nWidth, 0),
258 66 : Size( GetOutputSizePixel().Width() - nWidth, GetTitleHeight() )
259 66 : );
260 : }
261 :
262 33 : ColumnInserted( 0 );
263 33 : }
264 :
265 :
266 :
267 69 : void BrowseBox::InsertDataColumn( sal_uInt16 nItemId, const OUString& rText,
268 : long nWidth, HeaderBarItemBits nBits, sal_uInt16 nPos )
269 : {
270 :
271 : OSL_ENSURE( nItemId != HandleColumnId, "BrowseBox::InsertDataColumn: nItemId is HandleColumnId" );
272 : OSL_ENSURE( nItemId != BROWSER_INVALIDID, "BrowseBox::InsertDataColumn: nItemId is reserved value BROWSER_INVALIDID" );
273 :
274 : #if OSL_DEBUG_LEVEL > 0
275 : {
276 : const BrowserColumns::iterator colsEnd = pCols->end();
277 : for (BrowserColumns::iterator iCol = pCols->begin(); iCol != colsEnd; ++iCol)
278 : OSL_ENSURE( (*iCol)->GetId() != nItemId, "BrowseBox::InsertDataColumn: duplicate column Id" );
279 : }
280 : #endif
281 :
282 69 : if ( nPos < pCols->size() )
283 : {
284 3 : BrowserColumns::iterator it = pCols->begin();
285 3 : ::std::advance( it, nPos );
286 3 : pCols->insert( it, new BrowserColumn( nItemId, Image(), rText, nWidth, GetZoom() ) );
287 : }
288 : else
289 : {
290 66 : pCols->push_back( new BrowserColumn( nItemId, Image(), rText, nWidth, GetZoom() ) );
291 : }
292 69 : if ( nCurColId == 0 )
293 0 : nCurColId = nItemId;
294 :
295 69 : if ( getDataWindow()->pHeaderBar )
296 : {
297 : // Handle column not in the header bar
298 69 : sal_uInt16 nHeaderPos = nPos;
299 69 : if (nHeaderPos != HEADERBAR_APPEND && GetColumnId(0) == HandleColumnId )
300 51 : nHeaderPos--;
301 69 : getDataWindow()->pHeaderBar->InsertItem(
302 138 : nItemId, rText, nWidth, nBits, nHeaderPos );
303 : }
304 69 : ColumnInserted( nPos );
305 69 : }
306 :
307 33 : sal_uInt16 BrowseBox::ToggleSelectedColumn()
308 : {
309 33 : sal_uInt16 nSelectedColId = BROWSER_INVALIDID;
310 33 : if ( pColSel && pColSel->GetSelectCount() )
311 : {
312 0 : DoHideCursor( "ToggleSelectedColumn" );
313 0 : ToggleSelection();
314 0 : long nSelected = pColSel->FirstSelected();
315 0 : if (nSelected != static_cast<long>(SFX_ENDOFSELECTION))
316 0 : nSelectedColId = (*pCols)[nSelected]->GetId();
317 0 : pColSel->SelectAll(false);
318 : }
319 33 : return nSelectedColId;
320 : }
321 :
322 33 : void BrowseBox::SetToggledSelectedColumn(sal_uInt16 _nSelectedColumnId)
323 : {
324 33 : if ( pColSel && _nSelectedColumnId != BROWSER_INVALIDID )
325 : {
326 0 : pColSel->Select( GetColumnPos( _nSelectedColumnId ) );
327 0 : ToggleSelection();
328 : OSL_TRACE( "BrowseBox: %p->SetToggledSelectedColumn", this );
329 0 : DoShowCursor( "SetToggledSelectedColumn" );
330 : }
331 33 : }
332 :
333 33 : void BrowseBox::FreezeColumn( sal_uInt16 nItemId, bool bFreeze )
334 : {
335 :
336 : // never unfreeze the handle-column
337 33 : if ( nItemId == HandleColumnId && !bFreeze )
338 0 : return;
339 :
340 : // get the position in the current array
341 33 : size_t nItemPos = GetColumnPos( nItemId );
342 33 : if ( nItemPos >= pCols->size() )
343 : // not available!
344 0 : return;
345 :
346 : // doesn't the state change?
347 33 : if ( (*pCols)[ nItemPos ]->IsFrozen() == bFreeze )
348 0 : return;
349 :
350 : // remark the column selection
351 33 : sal_uInt16 nSelectedColId = ToggleSelectedColumn();
352 :
353 : // freeze or unfreeze?
354 33 : if ( bFreeze )
355 : {
356 : // to be moved?
357 33 : if ( nItemPos != 0 && !(*pCols)[ nItemPos-1 ]->IsFrozen() )
358 : {
359 : // move to the right of the last frozen column
360 0 : sal_uInt16 nFirstScrollable = FrozenColCount();
361 0 : BrowserColumn *pColumn = (*pCols)[ nItemPos ];
362 0 : BrowserColumns::iterator it = pCols->begin();
363 0 : ::std::advance( it, nItemPos );
364 0 : pCols->erase( it );
365 0 : nItemPos = nFirstScrollable;
366 0 : it = pCols->begin();
367 0 : ::std::advance( it, nItemPos );
368 0 : pCols->insert( it, pColumn );
369 : }
370 :
371 : // adjust the number of the first scrollable and visible column
372 33 : if ( nFirstCol <= nItemPos )
373 33 : nFirstCol = nItemPos + 1;
374 : }
375 : else
376 : {
377 : // to be moved?
378 0 : if ( (sal_Int32)nItemPos != FrozenColCount()-1 )
379 : {
380 : // move to the leftmost scrollable column
381 0 : sal_uInt16 nFirstScrollable = FrozenColCount();
382 0 : BrowserColumn *pColumn = (*pCols)[ nItemPos ];
383 0 : BrowserColumns::iterator it = pCols->begin();
384 0 : ::std::advance( it, nItemPos );
385 0 : pCols->erase( it );
386 0 : nItemPos = nFirstScrollable;
387 0 : it = pCols->begin();
388 0 : ::std::advance( it, nItemPos );
389 0 : pCols->insert( it, pColumn );
390 : }
391 :
392 : // adjust the number of the first scrollable and visible column
393 0 : nFirstCol = nItemPos;
394 : }
395 :
396 : // toggle the freeze-state of the column
397 33 : (*pCols)[ nItemPos ]->Freeze( bFreeze );
398 :
399 : // align the scrollbar-range
400 33 : UpdateScrollbars();
401 :
402 : // repaint
403 33 : Control::Invalidate();
404 33 : getDataWindow()->Invalidate();
405 :
406 : // remember the column selection
407 33 : SetToggledSelectedColumn(nSelectedColId);
408 : }
409 :
410 :
411 :
412 0 : void BrowseBox::SetColumnPos( sal_uInt16 nColumnId, sal_uInt16 nPos )
413 : {
414 : // never set pos of the handle column
415 0 : if ( nColumnId == HandleColumnId )
416 0 : return;
417 :
418 : // get the position in the current array
419 0 : sal_uInt16 nOldPos = GetColumnPos( nColumnId );
420 0 : if ( nOldPos >= pCols->size() )
421 : // not available!
422 0 : return;
423 :
424 : // does the state change?
425 0 : if (nOldPos != nPos)
426 : {
427 : // remark the column selection
428 0 : sal_uInt16 nSelectedColId = ToggleSelectedColumn();
429 :
430 : // determine old column area
431 0 : Size aDataWinSize( pDataWin->GetSizePixel() );
432 0 : if ( getDataWindow()->pHeaderBar )
433 0 : aDataWinSize.Height() += getDataWindow()->pHeaderBar->GetSizePixel().Height();
434 :
435 0 : Rectangle aFromRect( GetFieldRect( nColumnId) );
436 0 : aFromRect.Right() += 2*MIN_COLUMNWIDTH;
437 :
438 0 : sal_uInt16 nNextPos = nOldPos + 1;
439 0 : if ( nOldPos > nPos )
440 0 : nNextPos = nOldPos - 1;
441 :
442 0 : BrowserColumn *pNextCol = (*pCols)[ nNextPos ];
443 0 : Rectangle aNextRect(GetFieldRect( pNextCol->GetId() ));
444 :
445 : // move column internally
446 : {
447 0 : BrowserColumns::iterator it = pCols->begin();
448 0 : ::std::advance( it, nOldPos );
449 0 : BrowserColumn* pTemp = *it;
450 0 : pCols->erase( it );
451 0 : it = pCols->begin();
452 0 : ::std::advance( it, nPos );
453 0 : pCols->insert( it, pTemp );
454 : }
455 :
456 : // determine new column area
457 0 : Rectangle aToRect( GetFieldRect( nColumnId ) );
458 0 : aToRect.Right() += 2*MIN_COLUMNWIDTH;
459 :
460 : // do scroll, let redraw
461 0 : if( pDataWin->GetBackground().IsScrollable() )
462 : {
463 0 : long nScroll = -aFromRect.GetWidth();
464 0 : Rectangle aScrollArea;
465 0 : if ( nOldPos > nPos )
466 : {
467 0 : long nFrozenWidth = GetFrozenWidth();
468 0 : if ( aToRect.Left() < nFrozenWidth )
469 0 : aToRect.Left() = nFrozenWidth;
470 0 : aScrollArea = Rectangle(Point(aToRect.Left(),0),
471 0 : Point(aNextRect.Right(),aDataWinSize.Height()));
472 0 : nScroll *= -1; // reverse direction
473 : }
474 : else
475 0 : aScrollArea = Rectangle(Point(aNextRect.Left(),0),
476 0 : Point(aToRect.Right(),aDataWinSize.Height()));
477 :
478 0 : pDataWin->Scroll( nScroll, 0, aScrollArea );
479 0 : aToRect.Top() = 0;
480 0 : aToRect.Bottom() = aScrollArea.Bottom();
481 0 : Invalidate( aToRect );
482 : }
483 : else
484 0 : pDataWin->Window::Invalidate( InvalidateFlags::NoChildren );
485 :
486 : // adjust header bar positions
487 0 : if ( getDataWindow()->pHeaderBar )
488 : {
489 0 : sal_uInt16 nNewPos = nPos;
490 0 : if ( GetColumnId(0) == HandleColumnId )
491 0 : --nNewPos;
492 0 : getDataWindow()->pHeaderBar->MoveItem(nColumnId,nNewPos);
493 : }
494 : // remember the column selection
495 0 : SetToggledSelectedColumn(nSelectedColId);
496 :
497 0 : if ( isAccessibleAlive() )
498 : {
499 : commitTableEvent(
500 : TABLE_MODEL_CHANGED,
501 : makeAny( AccessibleTableModelChange(
502 : DELETE,
503 : 0,
504 0 : GetRowCount(),
505 : nOldPos,
506 : nOldPos
507 : )
508 : ),
509 : Any()
510 0 : );
511 :
512 : commitTableEvent(
513 : TABLE_MODEL_CHANGED,
514 : makeAny( AccessibleTableModelChange(
515 : INSERT,
516 : 0,
517 0 : GetRowCount(),
518 : nPos,
519 : nPos
520 : )
521 : ),
522 : Any()
523 0 : );
524 : }
525 : }
526 :
527 : }
528 :
529 :
530 :
531 0 : void BrowseBox::SetColumnTitle( sal_uInt16 nItemId, const OUString& rTitle )
532 : {
533 :
534 : // never set title of the handle-column
535 0 : if ( nItemId == HandleColumnId )
536 0 : return;
537 :
538 : // get the position in the current array
539 0 : sal_uInt16 nItemPos = GetColumnPos( nItemId );
540 0 : if ( nItemPos >= pCols->size() )
541 : // not available!
542 0 : return;
543 :
544 : // does the state change?
545 0 : BrowserColumn *pCol = (*pCols)[ nItemPos ];
546 0 : if ( pCol->Title() != rTitle )
547 : {
548 0 : OUString sNew(rTitle);
549 0 : OUString sOld(pCol->Title());
550 :
551 0 : pCol->Title() = rTitle;
552 :
553 : // adjust headerbar column
554 0 : if ( getDataWindow()->pHeaderBar )
555 0 : getDataWindow()->pHeaderBar->SetItemText( nItemId, rTitle );
556 : else
557 : {
558 : // redraw visible columns
559 0 : if ( GetUpdateMode() && ( pCol->IsFrozen() || nItemPos > nFirstCol ) )
560 : Invalidate( Rectangle( Point(0,0),
561 0 : Size( GetOutputSizePixel().Width(), GetTitleHeight() ) ) );
562 : }
563 :
564 0 : if ( isAccessibleAlive() )
565 : {
566 : commitTableEvent( TABLE_COLUMN_DESCRIPTION_CHANGED,
567 : makeAny( sNew ),
568 : makeAny( sOld )
569 0 : );
570 0 : }
571 : }
572 : }
573 :
574 :
575 :
576 0 : void BrowseBox::SetColumnWidth( sal_uInt16 nItemId, sal_uLong nWidth )
577 : {
578 :
579 : // get the position in the current array
580 0 : size_t nItemPos = GetColumnPos( nItemId );
581 0 : if ( nItemPos >= pCols->size() )
582 0 : return;
583 :
584 : // does the state change?
585 0 : nWidth = QueryColumnResize( nItemId, nWidth );
586 0 : if ( nWidth >= LONG_MAX || (*pCols)[ nItemPos ]->Width() != nWidth )
587 : {
588 0 : long nOldWidth = (*pCols)[ nItemPos ]->Width();
589 :
590 : // adjust last column, if necessary
591 0 : if ( IsVisible() && nItemPos == pCols->size() - 1 )
592 : {
593 0 : long nMaxWidth = pDataWin->GetSizePixel().Width();
594 0 : nMaxWidth -= getDataWindow()->bAutoSizeLastCol
595 0 : ? GetFieldRect(nItemId).Left()
596 0 : : GetFrozenWidth();
597 0 : if ( static_cast<BrowserDataWin*>( pDataWin.get() )->bAutoSizeLastCol || nWidth > (sal_uLong)nMaxWidth )
598 : {
599 0 : nWidth = nMaxWidth > 16 ? nMaxWidth : nOldWidth;
600 0 : nWidth = QueryColumnResize( nItemId, nWidth );
601 : }
602 : }
603 :
604 : // OV
605 : // In AutoSizeLastColumn(), we call SetColumnWidth with nWidth==0xffff.
606 : // Thus, check here, if the width has actually changed.
607 0 : if( (sal_uLong)nOldWidth == nWidth )
608 0 : return;
609 :
610 : // do we want to display the change immediately?
611 0 : bool bUpdate = GetUpdateMode() &&
612 0 : ( (*pCols)[ nItemPos ]->IsFrozen() || nItemPos >= nFirstCol );
613 :
614 0 : if ( bUpdate )
615 : {
616 : // Selection hidden
617 0 : DoHideCursor( "SetColumnWidth" );
618 0 : ToggleSelection();
619 : //!getDataWindow()->Update();
620 : //!Control::Update();
621 : }
622 :
623 : // set width
624 0 : (*pCols)[ nItemPos ]->SetWidth(nWidth, GetZoom());
625 :
626 : // scroll and invalidate
627 0 : if ( bUpdate )
628 : {
629 : // get X-Pos of the column changed
630 0 : long nX = 0;
631 0 : for ( size_t nCol = 0; nCol < nItemPos; ++nCol )
632 : {
633 0 : BrowserColumn *pCol = (*pCols)[ nCol ];
634 0 : if ( pCol->IsFrozen() || nCol >= nFirstCol )
635 0 : nX += pCol->Width();
636 : }
637 :
638 : // actually scroll+invalidate
639 0 : pDataWin->SetClipRegion();
640 0 : bool bSelVis = bSelectionIsVisible;
641 0 : bSelectionIsVisible = false;
642 0 : if( GetBackground().IsScrollable() )
643 : {
644 :
645 0 : Rectangle aScrRect( nX + std::min( (sal_uLong)nOldWidth, nWidth ), 0,
646 0 : GetSizePixel().Width() , // the header is longer than the datawin
647 0 : pDataWin->GetPosPixel().Y() - 1 );
648 0 : Control::Scroll( nWidth-nOldWidth, 0, aScrRect, SCROLL_FLAGS );
649 0 : aScrRect.Bottom() = pDataWin->GetSizePixel().Height();
650 0 : getDataWindow()->Scroll( nWidth-nOldWidth, 0, aScrRect, SCROLL_FLAGS );
651 0 : Rectangle aInvRect( nX, 0, nX + std::max( nWidth, (sal_uLong)nOldWidth ), USHRT_MAX );
652 0 : Control::Invalidate( aInvRect, InvalidateFlags::NoChildren );
653 0 : static_cast<BrowserDataWin*>( pDataWin.get() )->Invalidate( aInvRect );
654 : }
655 : else
656 : {
657 0 : Control::Invalidate( InvalidateFlags::NoChildren );
658 0 : getDataWindow()->Window::Invalidate( InvalidateFlags::NoChildren );
659 : }
660 :
661 :
662 : //!getDataWindow()->Update();
663 : //!Control::Update();
664 0 : bSelectionIsVisible = bSelVis;
665 0 : ToggleSelection();
666 0 : DoShowCursor( "SetColumnWidth" );
667 : }
668 0 : UpdateScrollbars();
669 :
670 : // adjust headerbar column
671 0 : if ( getDataWindow()->pHeaderBar )
672 0 : getDataWindow()->pHeaderBar->SetItemSize(
673 0 : nItemId ? nItemId : USHRT_MAX - 1, nWidth );
674 :
675 : // adjust last column
676 0 : if ( nItemPos != pCols->size() - 1 )
677 0 : AutoSizeLastColumn();
678 :
679 : }
680 : }
681 :
682 :
683 :
684 368 : void BrowseBox::AutoSizeLastColumn()
685 : {
686 368 : if ( getDataWindow()->bAutoSizeLastCol &&
687 0 : getDataWindow()->GetUpdateMode() )
688 : {
689 0 : sal_uInt16 nId = GetColumnId( (sal_uInt16)pCols->size() - 1 );
690 0 : SetColumnWidth( nId, LONG_MAX );
691 0 : ColumnResized( nId );
692 : }
693 368 : }
694 :
695 :
696 :
697 22 : void BrowseBox::RemoveColumn( sal_uInt16 nItemId )
698 : {
699 :
700 : // get column position
701 22 : sal_uInt16 nPos = GetColumnPos(nItemId);
702 22 : if ( nPos >= ColCount() )
703 : // not available
704 22 : return;
705 :
706 : // correct column selection
707 22 : if ( pColSel )
708 22 : pColSel->Remove( nPos );
709 :
710 : // correct column cursor
711 22 : if ( nCurColId == nItemId )
712 0 : nCurColId = 0;
713 :
714 : // delete column
715 22 : BrowserColumns::iterator it = pCols->begin();
716 22 : ::std::advance( it, nPos );
717 22 : delete *it;
718 22 : pCols->erase( it );
719 22 : if ( nFirstCol >= nPos && nFirstCol > FrozenColCount() )
720 : {
721 : OSL_ENSURE(nFirstCol > 0,"FirstCol must be greater zero!");
722 12 : --nFirstCol;
723 : }
724 :
725 : // handlecolumn not in headerbar
726 22 : if (nItemId)
727 : {
728 10 : if ( getDataWindow()->pHeaderBar )
729 10 : getDataWindow()->pHeaderBar->RemoveItem( nItemId );
730 : }
731 : else
732 : {
733 : // adjust headerbar
734 12 : if ( getDataWindow()->pHeaderBar )
735 : {
736 12 : getDataWindow()->pHeaderBar->SetPosSizePixel(
737 : Point(0, 0),
738 24 : Size( GetOutputSizePixel().Width(), GetTitleHeight() )
739 24 : );
740 : }
741 : }
742 :
743 : // correct vertical scrollbar
744 22 : UpdateScrollbars();
745 :
746 : // trigger repaint, if necessary
747 22 : if ( GetUpdateMode() )
748 : {
749 22 : getDataWindow()->Invalidate();
750 22 : Control::Invalidate();
751 22 : if ( getDataWindow()->bAutoSizeLastCol && nPos ==ColCount() )
752 0 : SetColumnWidth( GetColumnId( nPos - 1 ), LONG_MAX );
753 : }
754 :
755 22 : if ( isAccessibleAlive() )
756 : {
757 : commitTableEvent(
758 : TABLE_MODEL_CHANGED,
759 : makeAny( AccessibleTableModelChange( DELETE,
760 : 0,
761 0 : GetRowCount(),
762 : nPos,
763 : nPos
764 : )
765 : ),
766 : Any()
767 0 : );
768 :
769 : commitHeaderBarEvent(
770 : CHILD,
771 : Any(),
772 0 : makeAny( CreateAccessibleColumnHeader( nPos ) ),
773 : true
774 0 : );
775 : }
776 : }
777 :
778 :
779 :
780 21 : void BrowseBox::RemoveColumns()
781 : {
782 21 : size_t nOldCount = pCols->size();
783 :
784 : // remove all columns
785 101 : for ( size_t i = 0; i < nOldCount; ++i )
786 80 : delete (*pCols)[ i ];
787 21 : pCols->clear();
788 :
789 : // correct column selection
790 21 : if ( pColSel )
791 : {
792 21 : pColSel->SelectAll(false);
793 21 : pColSel->SetTotalRange( Range( 0, 0 ) );
794 : }
795 :
796 : // correct column cursor
797 21 : nCurColId = 0;
798 21 : nFirstCol = 0;
799 :
800 21 : if ( getDataWindow()->pHeaderBar )
801 21 : getDataWindow()->pHeaderBar->Clear( );
802 :
803 : // correct vertical scrollbar
804 21 : UpdateScrollbars();
805 :
806 : // trigger repaint if necessary
807 21 : if ( GetUpdateMode() )
808 : {
809 21 : getDataWindow()->Invalidate();
810 21 : Control::Invalidate();
811 : }
812 :
813 21 : if ( isAccessibleAlive() )
814 : {
815 0 : if ( pCols->size() != nOldCount )
816 : {
817 : // all columns should be removed, so we remove the column header bar and append it again
818 : // to avoid to notify every column remove
819 : commitBrowseBoxEvent(
820 : CHILD,
821 : Any(),
822 : makeAny(m_pImpl->getAccessibleHeaderBar(BBTYPE_COLUMNHEADERBAR))
823 0 : );
824 :
825 : // and now append it again
826 : commitBrowseBoxEvent(
827 : CHILD,
828 : makeAny(m_pImpl->getAccessibleHeaderBar(BBTYPE_COLUMNHEADERBAR)),
829 : Any()
830 0 : );
831 :
832 : // notify a table model change
833 : commitTableEvent(
834 : TABLE_MODEL_CHANGED,
835 : makeAny ( AccessibleTableModelChange( DELETE,
836 : 0,
837 0 : GetRowCount(),
838 : 0,
839 : nOldCount
840 : )
841 : ),
842 : Any()
843 0 : );
844 : }
845 : }
846 21 : }
847 :
848 :
849 :
850 0 : OUString BrowseBox::GetColumnTitle( sal_uInt16 nId ) const
851 : {
852 :
853 0 : sal_uInt16 nItemPos = GetColumnPos( nId );
854 0 : if ( nItemPos >= pCols->size() )
855 0 : return OUString();
856 0 : return (*pCols)[ nItemPos ]->Title();
857 : }
858 :
859 :
860 :
861 121 : long BrowseBox::GetRowCount() const
862 : {
863 121 : return nRowCount;
864 : }
865 :
866 :
867 :
868 23 : sal_uInt16 BrowseBox::ColCount() const
869 : {
870 :
871 23 : return (sal_uInt16) pCols->size();
872 : }
873 :
874 :
875 :
876 66 : long BrowseBox::ImpGetDataRowHeight() const
877 : {
878 :
879 66 : BrowseBox *pThis = const_cast<BrowseBox*>(this);
880 66 : pThis->nDataRowHeight = pThis->CalcReverseZoom(pDataWin->GetTextHeight() + 2);
881 66 : pThis->Resize();
882 66 : getDataWindow()->Invalidate();
883 66 : return nDataRowHeight;
884 : }
885 :
886 :
887 :
888 46 : void BrowseBox::SetDataRowHeight( long nPixel )
889 : {
890 :
891 46 : nDataRowHeight = CalcReverseZoom(nPixel);
892 46 : Resize();
893 46 : getDataWindow()->Invalidate();
894 46 : }
895 :
896 :
897 :
898 0 : void BrowseBox::SetTitleLines( sal_uInt16 nLines )
899 : {
900 :
901 0 : nTitleLines = nLines;
902 0 : }
903 :
904 :
905 :
906 0 : long BrowseBox::ScrollColumns( long nCols )
907 : {
908 :
909 0 : if ( nFirstCol + nCols < 0 ||
910 0 : nFirstCol + nCols >= (long)pCols->size() )
911 0 : return 0;
912 :
913 : // implicitly hides cursor while scrolling
914 0 : StartScroll();
915 0 : bScrolling = true;
916 0 : bool bScrollable = pDataWin->GetBackground().IsScrollable();
917 0 : bool bInvalidateView = false;
918 :
919 : // scrolling one column to the right?
920 0 : if ( nCols == 1 )
921 : {
922 : // update internal value and scrollbar
923 0 : ++nFirstCol;
924 0 : aHScroll->SetThumbPos( nFirstCol - FrozenColCount() );
925 :
926 0 : if ( !bScrollable )
927 : {
928 0 : bInvalidateView = true;
929 : }
930 : else
931 : {
932 0 : long nDelta = (*pCols)[ nFirstCol-1 ]->Width();
933 0 : long nFrozenWidth = GetFrozenWidth();
934 :
935 : Rectangle aScrollRect( Point( nFrozenWidth + nDelta, 0 ),
936 0 : Size ( GetOutputSizePixel().Width() - nFrozenWidth - nDelta,
937 0 : GetTitleHeight() - 1
938 0 : ) );
939 :
940 : // scroll the header bar area (if there is no dedicated HeaderBar control)
941 0 : if ( !getDataWindow()->pHeaderBar && nTitleLines )
942 : {
943 : // actually scroll
944 0 : Scroll( -nDelta, 0, aScrollRect, SCROLL_FLAGS );
945 :
946 : // invalidate the area of the column which was scrolled out to the left hand side
947 0 : Rectangle aInvalidateRect( aScrollRect );
948 0 : aInvalidateRect.Left() = nFrozenWidth;
949 0 : aInvalidateRect.Right() = nFrozenWidth + nDelta - 1;
950 0 : Invalidate( aInvalidateRect );
951 : }
952 :
953 : // scroll the data-area
954 0 : aScrollRect.Bottom() = pDataWin->GetOutputSizePixel().Height();
955 :
956 : // actually scroll
957 0 : pDataWin->Scroll( -nDelta, 0, aScrollRect, SCROLL_FLAGS );
958 :
959 : // invalidate the area of the column which was scrolled out to the left hand side
960 0 : aScrollRect.Left() = nFrozenWidth;
961 0 : aScrollRect.Right() = nFrozenWidth + nDelta - 1;
962 0 : getDataWindow()->Invalidate( aScrollRect );
963 : }
964 : }
965 :
966 : // scrolling one column to the left?
967 0 : else if ( nCols == -1 )
968 : {
969 0 : --nFirstCol;
970 0 : aHScroll->SetThumbPos( nFirstCol - FrozenColCount() );
971 :
972 0 : if ( !bScrollable )
973 : {
974 0 : bInvalidateView = true;
975 : }
976 : else
977 : {
978 0 : long nDelta = (*pCols)[ nFirstCol ]->Width();
979 0 : long nFrozenWidth = GetFrozenWidth();
980 :
981 : Rectangle aScrollRect( Point( nFrozenWidth, 0 ),
982 0 : Size ( GetOutputSizePixel().Width() - nFrozenWidth,
983 0 : GetTitleHeight() - 1
984 0 : ) );
985 :
986 : // scroll the header bar area (if there is no dedicated HeaderBar control)
987 0 : if ( !getDataWindow()->pHeaderBar && nTitleLines )
988 : {
989 0 : Scroll( nDelta, 0, aScrollRect, SCROLL_FLAGS );
990 : }
991 :
992 : // scroll the data-area
993 0 : aScrollRect.Bottom() = pDataWin->GetOutputSizePixel().Height();
994 0 : pDataWin->Scroll( nDelta, 0, aScrollRect, SCROLL_FLAGS );
995 : }
996 : }
997 : else
998 : {
999 0 : if ( GetUpdateMode() )
1000 : {
1001 : Invalidate( Rectangle(
1002 : Point( GetFrozenWidth(), 0 ),
1003 0 : Size( GetOutputSizePixel().Width(), GetTitleHeight() ) ) );
1004 0 : getDataWindow()->Invalidate( Rectangle(
1005 : Point( GetFrozenWidth(), 0 ),
1006 0 : pDataWin->GetSizePixel() ) );
1007 : }
1008 :
1009 0 : nFirstCol = nFirstCol + (sal_uInt16)nCols;
1010 0 : aHScroll->SetThumbPos( nFirstCol - FrozenColCount() );
1011 : }
1012 :
1013 : // adjust external headerbar, if necessary
1014 0 : if ( getDataWindow()->pHeaderBar )
1015 : {
1016 0 : long nWidth = 0;
1017 0 : for ( size_t nCol = 0;
1018 0 : nCol < pCols->size() && nCol < nFirstCol;
1019 : ++nCol )
1020 : {
1021 : // not the handle column
1022 0 : if ( (*pCols)[ nCol ]->GetId() )
1023 0 : nWidth += (*pCols)[ nCol ]->Width();
1024 : }
1025 :
1026 0 : getDataWindow()->pHeaderBar->SetOffset( nWidth );
1027 : }
1028 :
1029 0 : if( bInvalidateView )
1030 : {
1031 0 : Control::Invalidate( InvalidateFlags::NoChildren );
1032 0 : pDataWin->Window::Invalidate( InvalidateFlags::NoChildren );
1033 : }
1034 :
1035 : // implicitly show cursor after scrolling
1036 0 : if ( nCols )
1037 : {
1038 0 : getDataWindow()->Update();
1039 0 : Update();
1040 : }
1041 0 : bScrolling = false;
1042 0 : EndScroll();
1043 :
1044 0 : return nCols;
1045 : }
1046 :
1047 :
1048 :
1049 352 : long BrowseBox::ScrollRows( long nRows )
1050 : {
1051 :
1052 : // out of range?
1053 352 : if ( getDataWindow()->bNoScrollBack && nRows < 0 )
1054 0 : return 0;
1055 :
1056 : // compute new top row
1057 352 : long nTmpMin = std::min( (long)(nTopRow + nRows), (long)(nRowCount - 1) );
1058 :
1059 352 : long nNewTopRow = std::max( (long)nTmpMin, (long)0 );
1060 :
1061 352 : if ( nNewTopRow == nTopRow )
1062 352 : return 0;
1063 :
1064 : sal_uInt16 nVisibleRows =
1065 0 : (sal_uInt16)(pDataWin->GetOutputSizePixel().Height() / GetDataRowHeight() + 1);
1066 :
1067 0 : VisibleRowsChanged(nNewTopRow, nVisibleRows);
1068 :
1069 : // compute new top row again (nTopRow might have changed!)
1070 0 : nTmpMin = std::min( (long)(nTopRow + nRows), (long)(nRowCount - 1) );
1071 :
1072 0 : nNewTopRow = std::max( (long)nTmpMin, (long)0 );
1073 :
1074 0 : StartScroll();
1075 :
1076 : // scroll area on screen and/or repaint
1077 0 : long nDeltaY = GetDataRowHeight() * ( nNewTopRow - nTopRow );
1078 0 : long nOldTopRow = nTopRow;
1079 0 : nTopRow = nNewTopRow;
1080 :
1081 0 : if ( GetUpdateMode() )
1082 : {
1083 0 : pVScroll->SetRange( Range( 0L, nRowCount ) );
1084 0 : pVScroll->SetThumbPos( nTopRow );
1085 :
1086 0 : if( pDataWin->GetBackground().IsScrollable() &&
1087 0 : std::abs( nDeltaY ) > 0 &&
1088 0 : std::abs( nDeltaY ) < pDataWin->GetSizePixel().Height() )
1089 : {
1090 0 : pDataWin->Scroll( 0, (short)-nDeltaY, SCROLL_FLAGS );
1091 : }
1092 : else
1093 0 : getDataWindow()->Invalidate();
1094 :
1095 0 : if ( nTopRow - nOldTopRow )
1096 0 : getDataWindow()->Update();
1097 : }
1098 :
1099 0 : EndScroll();
1100 :
1101 0 : return nTopRow - nOldTopRow;
1102 : }
1103 :
1104 :
1105 :
1106 118 : void BrowseBox::RowModified( long nRow, sal_uInt16 nColId )
1107 : {
1108 :
1109 118 : if ( !GetUpdateMode() )
1110 118 : return;
1111 :
1112 118 : Rectangle aRect;
1113 118 : if ( nColId == BROWSER_INVALIDID )
1114 : // invalidate the whole row
1115 2 : aRect = Rectangle( Point( 0, (nRow-nTopRow) * GetDataRowHeight() ),
1116 4 : Size( pDataWin->GetSizePixel().Width(), GetDataRowHeight() ) );
1117 : else
1118 : {
1119 : // invalidate the specific field
1120 116 : aRect = GetFieldRectPixel( nRow, nColId, false );
1121 : }
1122 118 : getDataWindow()->Invalidate( aRect );
1123 : }
1124 :
1125 :
1126 :
1127 2 : void BrowseBox::Clear()
1128 : {
1129 :
1130 : // adjust the total number of rows
1131 2 : DoHideCursor( "Clear" );
1132 2 : long nOldRowCount = nRowCount;
1133 2 : nRowCount = 0;
1134 2 : if(bMultiSelection)
1135 : {
1136 : assert(uRow.pSel);
1137 2 : *uRow.pSel = MultiSelection();
1138 : }
1139 : else
1140 0 : uRow.nSel = BROWSER_ENDOFSELECTION;
1141 2 : nCurRow = BROWSER_ENDOFSELECTION;
1142 2 : nTopRow = 0;
1143 2 : nCurColId = 0;
1144 :
1145 : // nFirstCol may not be reset, else the scrolling code will become confused.
1146 : // nFirstCol may only be changed when adding or deleting columns
1147 : // nFirstCol = 0; -> wrong!
1148 2 : aHScroll->SetThumbPos( 0 );
1149 2 : pVScroll->SetThumbPos( 0 );
1150 :
1151 2 : Invalidate();
1152 2 : UpdateScrollbars();
1153 2 : SetNoSelection();
1154 2 : DoShowCursor( "Clear" );
1155 2 : CursorMoved();
1156 :
1157 2 : if ( isAccessibleAlive() )
1158 : {
1159 : // all rows should be removed, so we remove the row header bar and append it again
1160 : // to avoid to notify every row remove
1161 0 : if ( nOldRowCount != nRowCount )
1162 : {
1163 : commitBrowseBoxEvent(
1164 : CHILD,
1165 : Any(),
1166 : makeAny( m_pImpl->getAccessibleHeaderBar( BBTYPE_ROWHEADERBAR ) )
1167 0 : );
1168 :
1169 : // and now append it again
1170 : commitBrowseBoxEvent(
1171 : CHILD,
1172 : makeAny( m_pImpl->getAccessibleHeaderBar( BBTYPE_ROWHEADERBAR ) ),
1173 : Any()
1174 0 : );
1175 :
1176 : // notify a table model change
1177 : commitTableEvent(
1178 : TABLE_MODEL_CHANGED,
1179 : makeAny( AccessibleTableModelChange( DELETE,
1180 : 0,
1181 : nOldRowCount,
1182 : 0,
1183 0 : GetColumnCount())
1184 : ),
1185 : Any()
1186 0 : );
1187 : }
1188 : }
1189 2 : }
1190 :
1191 1 : void BrowseBox::RowInserted( long nRow, long nNumRows, bool bDoPaint, bool bKeepSelection )
1192 : {
1193 :
1194 1 : if (nRow < 0)
1195 0 : nRow = 0;
1196 1 : else if (nRow > nRowCount) // maximal = nRowCount
1197 0 : nRow = nRowCount;
1198 :
1199 1 : if ( nNumRows <= 0 )
1200 1 : return;
1201 :
1202 : // adjust total row count
1203 1 : bool bLastRow = nRow >= nRowCount;
1204 1 : nRowCount += nNumRows;
1205 :
1206 1 : DoHideCursor( "RowInserted" );
1207 :
1208 : // must we paint the new rows?
1209 1 : long nOldCurRow = nCurRow;
1210 1 : Size aSz = pDataWin->GetOutputSizePixel();
1211 1 : if ( bDoPaint && nRow >= nTopRow &&
1212 0 : nRow <= nTopRow + aSz.Height() / GetDataRowHeight() )
1213 : {
1214 0 : long nY = (nRow-nTopRow) * GetDataRowHeight();
1215 0 : if ( !bLastRow )
1216 : {
1217 : // scroll down the rows behind the new row
1218 0 : pDataWin->SetClipRegion();
1219 0 : if( pDataWin->GetBackground().IsScrollable() )
1220 : {
1221 0 : pDataWin->Scroll( 0, GetDataRowHeight() * nNumRows,
1222 : Rectangle( Point( 0, nY ),
1223 0 : Size( aSz.Width(), aSz.Height() - nY ) ),
1224 0 : SCROLL_FLAGS );
1225 : }
1226 : else
1227 0 : pDataWin->Window::Invalidate( InvalidateFlags::NoChildren );
1228 : }
1229 : else
1230 : // scroll would cause a repaint, so we must explicitly invalidate
1231 0 : pDataWin->Invalidate( Rectangle( Point( 0, nY ),
1232 0 : Size( aSz.Width(), nNumRows * GetDataRowHeight() ) ) );
1233 : }
1234 :
1235 : // correct top row if necessary
1236 1 : if ( nRow < nTopRow )
1237 0 : nTopRow += nNumRows;
1238 :
1239 : // adjust the selection
1240 1 : if ( bMultiSelection )
1241 1 : uRow.pSel->Insert( nRow, nNumRows );
1242 0 : else if ( uRow.nSel != BROWSER_ENDOFSELECTION && nRow <= uRow.nSel )
1243 0 : uRow.nSel += nNumRows;
1244 :
1245 : // adjust the cursor
1246 1 : if ( nCurRow == BROWSER_ENDOFSELECTION )
1247 1 : GoToRow( 0, false, bKeepSelection );
1248 0 : else if ( nRow <= nCurRow )
1249 0 : GoToRow( nCurRow += nNumRows, false, bKeepSelection );
1250 :
1251 : // adjust the vertical scrollbar
1252 1 : if ( bDoPaint )
1253 : {
1254 0 : UpdateScrollbars();
1255 0 : AutoSizeLastColumn();
1256 : }
1257 :
1258 1 : DoShowCursor( "RowInserted" );
1259 : // notify accessible that rows were inserted
1260 1 : if ( isAccessibleAlive() )
1261 : {
1262 : commitTableEvent(
1263 : TABLE_MODEL_CHANGED,
1264 : makeAny( AccessibleTableModelChange(
1265 : INSERT,
1266 : nRow,
1267 : nRow + nNumRows,
1268 : 0,
1269 0 : GetColumnCount()
1270 : )
1271 : ),
1272 : Any()
1273 0 : );
1274 :
1275 0 : for (long i = nRow+1 ; i <= nRowCount ; ++i)
1276 : {
1277 : commitHeaderBarEvent(
1278 : CHILD,
1279 0 : makeAny( CreateAccessibleRowHeader( i ) ),
1280 : Any(),
1281 : false
1282 0 : );
1283 : }
1284 : }
1285 :
1286 1 : if ( nCurRow != nOldCurRow )
1287 1 : CursorMoved();
1288 :
1289 : DBG_ASSERT(nRowCount > 0,"BrowseBox: nRowCount <= 0");
1290 : DBG_ASSERT(nCurRow >= 0,"BrowseBox: nCurRow < 0");
1291 : DBG_ASSERT(nCurRow < nRowCount,"nCurRow >= nRowCount");
1292 : }
1293 :
1294 :
1295 :
1296 0 : void BrowseBox::RowRemoved( long nRow, long nNumRows, bool bDoPaint )
1297 : {
1298 :
1299 0 : if ( nRow < 0 )
1300 0 : nRow = 0;
1301 0 : else if ( nRow >= nRowCount )
1302 0 : nRow = nRowCount - 1;
1303 :
1304 0 : if ( nNumRows <= 0 )
1305 0 : return;
1306 :
1307 0 : if ( nRowCount <= 0 )
1308 0 : return;
1309 :
1310 0 : if ( bDoPaint )
1311 : {
1312 : // hide cursor and selection
1313 : OSL_TRACE( "BrowseBox: %p->HideCursor", this );
1314 0 : ToggleSelection();
1315 0 : DoHideCursor( "RowRemoved" );
1316 : }
1317 :
1318 : // adjust total row count
1319 0 : nRowCount -= nNumRows;
1320 0 : if (nRowCount < 0) nRowCount = 0;
1321 0 : long nOldCurRow = nCurRow;
1322 :
1323 : // adjust the selection
1324 0 : if ( bMultiSelection )
1325 : // uRow.pSel->Remove( nRow, nNumRows );
1326 0 : for ( long i = 0; i < nNumRows; i++ )
1327 0 : uRow.pSel->Remove( nRow );
1328 0 : else if ( nRow < uRow.nSel && uRow.nSel >= nNumRows )
1329 0 : uRow.nSel -= nNumRows;
1330 0 : else if ( nRow <= uRow.nSel )
1331 0 : uRow.nSel = BROWSER_ENDOFSELECTION;
1332 :
1333 : // adjust the cursor
1334 0 : if ( nRowCount == 0 ) // don't compare nRowCount with nNumRows as nNumRows already was subtracted from nRowCount
1335 0 : nCurRow = BROWSER_ENDOFSELECTION;
1336 0 : else if ( nRow < nCurRow )
1337 : {
1338 0 : nCurRow -= std::min( nCurRow - nRow, nNumRows );
1339 : // with the above nCurRow points a) to the first row after the removed block or b) to the same line
1340 : // as before, but moved up nNumRows
1341 : // case a) needs an additional correction if the last n lines were deleted, as 'the first row after the
1342 : // removed block' is an invalid position then
1343 : // FS - 09/28/99 - 68429
1344 0 : if (nCurRow == nRowCount)
1345 0 : --nCurRow;
1346 : }
1347 0 : else if( nRow == nCurRow && nCurRow == nRowCount )
1348 0 : nCurRow = nRowCount-1;
1349 :
1350 : // is the deleted row visible?
1351 0 : Size aSz = pDataWin->GetOutputSizePixel();
1352 0 : if ( nRow >= nTopRow &&
1353 0 : nRow <= nTopRow + aSz.Height() / GetDataRowHeight() )
1354 : {
1355 0 : if ( bDoPaint )
1356 : {
1357 : // scroll up the rows behind the deleted row
1358 : // if there are Rows behind
1359 0 : if (nRow < nRowCount)
1360 : {
1361 0 : long nY = (nRow-nTopRow) * GetDataRowHeight();
1362 0 : pDataWin->SetClipRegion();
1363 0 : if( pDataWin->GetBackground().IsScrollable() )
1364 : {
1365 0 : pDataWin->Scroll( 0, - (short) GetDataRowHeight() * nNumRows,
1366 0 : Rectangle( Point( 0, nY ), Size( aSz.Width(),
1367 0 : aSz.Height() - nY + nNumRows*GetDataRowHeight() ) ),
1368 0 : SCROLL_FLAGS );
1369 : }
1370 : else
1371 0 : pDataWin->Window::Invalidate( InvalidateFlags::NoChildren );
1372 : }
1373 : else
1374 : {
1375 : // Repaint the Rect of the deleted row
1376 : Rectangle aRect(
1377 0 : Point( 0, (nRow-nTopRow)*GetDataRowHeight() ),
1378 0 : Size( pDataWin->GetSizePixel().Width(),
1379 0 : nNumRows * GetDataRowHeight() ) );
1380 0 : pDataWin->Invalidate( aRect );
1381 : }
1382 : }
1383 : }
1384 : // is the deleted row above of the visible area?
1385 0 : else if ( nRow < nTopRow )
1386 0 : nTopRow = nTopRow >= nNumRows ? nTopRow-nNumRows : 0;
1387 :
1388 0 : if ( bDoPaint )
1389 : {
1390 : // reshow cursor and selection
1391 0 : ToggleSelection();
1392 : OSL_TRACE( "BrowseBox: %p->ShowCursor", this );
1393 0 : DoShowCursor( "RowRemoved" );
1394 :
1395 : // adjust the vertical scrollbar
1396 0 : UpdateScrollbars();
1397 0 : AutoSizeLastColumn();
1398 : }
1399 :
1400 0 : if ( isAccessibleAlive() )
1401 : {
1402 0 : if ( nRowCount == 0 )
1403 : {
1404 : // all columns should be removed, so we remove the column header bar and append it again
1405 : // to avoid to notify every column remove
1406 : commitBrowseBoxEvent(
1407 : CHILD,
1408 : Any(),
1409 : makeAny( m_pImpl->getAccessibleHeaderBar( BBTYPE_ROWHEADERBAR ) )
1410 0 : );
1411 :
1412 : // and now append it again
1413 : commitBrowseBoxEvent(
1414 : CHILD,
1415 : makeAny(m_pImpl->getAccessibleHeaderBar(BBTYPE_ROWHEADERBAR)),
1416 : Any()
1417 0 : );
1418 : commitBrowseBoxEvent(
1419 : CHILD,
1420 : Any(),
1421 : makeAny( m_pImpl->getAccessibleTable() )
1422 0 : );
1423 :
1424 : // and now append it again
1425 : commitBrowseBoxEvent(
1426 : CHILD,
1427 : makeAny( m_pImpl->getAccessibleTable() ),
1428 : Any()
1429 0 : );
1430 : }
1431 : else
1432 : {
1433 : commitTableEvent(
1434 : TABLE_MODEL_CHANGED,
1435 : makeAny( AccessibleTableModelChange(
1436 : DELETE,
1437 : nRow,
1438 : nRow + nNumRows,
1439 : 0,
1440 0 : GetColumnCount()
1441 : )
1442 : ),
1443 : Any()
1444 0 : );
1445 :
1446 0 : for (long i = nRow+1 ; i <= (nRow+nNumRows) ; ++i)
1447 : {
1448 : commitHeaderBarEvent(
1449 : CHILD,
1450 : Any(),
1451 0 : makeAny( CreateAccessibleRowHeader( i ) ),
1452 : false
1453 0 : );
1454 : }
1455 : }
1456 : }
1457 :
1458 0 : if ( nOldCurRow != nCurRow )
1459 0 : CursorMoved();
1460 :
1461 : DBG_ASSERT(nRowCount >= 0,"BrowseBox: nRowCount < 0");
1462 : DBG_ASSERT(nCurRow >= 0 || nRowCount == 0,"BrowseBox: nCurRow < 0 && nRowCount != 0");
1463 : DBG_ASSERT(nCurRow < nRowCount,"nCurRow >= nRowCount");
1464 : }
1465 :
1466 :
1467 :
1468 0 : bool BrowseBox::GoToRow( long nRow)
1469 : {
1470 0 : return GoToRow(nRow, false, false);
1471 : }
1472 :
1473 :
1474 :
1475 2 : bool BrowseBox::GoToRow( long nRow, bool bRowColMove, bool bKeepSelection )
1476 : {
1477 :
1478 2 : long nOldCurRow = nCurRow;
1479 :
1480 : // nothing to do?
1481 2 : if ( nRow == nCurRow && ( bMultiSelection || uRow.nSel == nRow ) )
1482 1 : return true;
1483 :
1484 : // out of range?
1485 1 : if ( nRow < 0 || nRow >= nRowCount )
1486 0 : return false;
1487 :
1488 : // not allowed?
1489 1 : if ( ( !bRowColMove && !IsCursorMoveAllowed( nRow, nCurColId ) ) )
1490 0 : return false;
1491 :
1492 1 : if ( getDataWindow()->bNoScrollBack && nRow < nTopRow )
1493 0 : nRow = nTopRow;
1494 :
1495 : // compute the last visible row
1496 1 : Size aSz( pDataWin->GetSizePixel() );
1497 1 : sal_uInt16 nVisibleRows = sal_uInt16( aSz.Height() / GetDataRowHeight() - 1 );
1498 1 : long nLastRow = nTopRow + nVisibleRows;
1499 :
1500 : // suspend Updates
1501 1 : getDataWindow()->EnterUpdateLock();
1502 :
1503 : // remove old highlight, if necessary
1504 1 : if ( !bMultiSelection && !bKeepSelection )
1505 0 : ToggleSelection();
1506 1 : DoHideCursor( "GoToRow" );
1507 :
1508 : // must we scroll?
1509 1 : bool bWasVisible = bSelectionIsVisible;
1510 1 : if (! bMultiSelection)
1511 : {
1512 0 : if( !bKeepSelection )
1513 0 : bSelectionIsVisible = false;
1514 : }
1515 1 : if ( nRow < nTopRow )
1516 0 : ScrollRows( nRow - nTopRow );
1517 1 : else if ( nRow > nLastRow )
1518 0 : ScrollRows( nRow - nLastRow );
1519 1 : bSelectionIsVisible = bWasVisible;
1520 :
1521 : // adjust cursor (selection) and thumb
1522 1 : if ( GetUpdateMode() )
1523 1 : pVScroll->SetThumbPos( nTopRow );
1524 :
1525 : // relative positioning (because nCurRow might have changed in the meantime)!
1526 1 : if (nCurRow != BROWSER_ENDOFSELECTION )
1527 0 : nCurRow = nCurRow + (nRow - nOldCurRow);
1528 :
1529 : // make sure that the current position is valid
1530 1 : if (nCurRow == BROWSER_ENDOFSELECTION && nRowCount > 0)
1531 1 : nCurRow = 0;
1532 0 : else if ( nCurRow >= nRowCount )
1533 0 : nCurRow = nRowCount - 1;
1534 1 : aSelRange = Range( nCurRow, nCurRow );
1535 :
1536 : // display new highlight if necessary
1537 1 : if ( !bMultiSelection && !bKeepSelection )
1538 0 : uRow.nSel = nRow;
1539 :
1540 : // resume Updates
1541 1 : getDataWindow()->LeaveUpdateLock();
1542 :
1543 : // Cursor+Highlight
1544 1 : if ( !bMultiSelection && !bKeepSelection)
1545 0 : ToggleSelection();
1546 1 : DoShowCursor( "GoToRow" );
1547 1 : if ( !bRowColMove && nOldCurRow != nCurRow )
1548 1 : CursorMoved();
1549 :
1550 1 : if ( !bMultiSelection && !bKeepSelection )
1551 : {
1552 0 : if ( !bSelecting )
1553 0 : Select();
1554 : else
1555 0 : bSelect = true;
1556 : }
1557 1 : return true;
1558 : }
1559 :
1560 :
1561 :
1562 0 : bool BrowseBox::GoToColumnId( sal_uInt16 nColId)
1563 : {
1564 0 : return GoToColumnId(nColId, true, false);
1565 : }
1566 :
1567 :
1568 1 : bool BrowseBox::GoToColumnId( sal_uInt16 nColId, bool bMakeVisible, bool bRowColMove)
1569 : {
1570 1 : if (!bColumnCursor)
1571 0 : return false;
1572 :
1573 : // allowed?
1574 1 : if (!bRowColMove && !IsCursorMoveAllowed( nCurRow, nColId ) )
1575 0 : return false;
1576 :
1577 1 : if ( nColId != nCurColId || (bMakeVisible && !IsFieldVisible(nCurRow, nColId, true)))
1578 : {
1579 1 : sal_uInt16 nNewPos = GetColumnPos(nColId);
1580 1 : BrowserColumn* pColumn = (nNewPos < pCols->size()) ? (*pCols)[ nNewPos ] : NULL;
1581 : DBG_ASSERT( pColumn, "no column object - invalid id?" );
1582 1 : if ( !pColumn )
1583 0 : return false;
1584 :
1585 1 : DoHideCursor( "GoToColumnId" );
1586 1 : nCurColId = nColId;
1587 :
1588 1 : bool bScrolled = false;
1589 :
1590 1 : sal_uInt16 nFirstPos = nFirstCol;
1591 1 : sal_uInt16 nWidth = (sal_uInt16)pColumn->Width();
1592 : sal_uInt16 nLastPos = GetColumnAtXPosPixel(
1593 1 : pDataWin->GetSizePixel().Width()-nWidth, false );
1594 1 : sal_uInt16 nFrozen = FrozenColCount();
1595 1 : if ( bMakeVisible && nLastPos &&
1596 1 : nNewPos >= nFrozen && ( nNewPos < nFirstPos || nNewPos > nLastPos ) )
1597 : {
1598 0 : if ( nNewPos < nFirstPos )
1599 0 : ScrollColumns( nNewPos-nFirstPos );
1600 0 : else if ( nNewPos > nLastPos )
1601 0 : ScrollColumns( nNewPos-nLastPos );
1602 0 : bScrolled = true;
1603 : }
1604 :
1605 1 : DoShowCursor( "GoToColumnId" );
1606 1 : if (!bRowColMove)
1607 : {
1608 : //try to move to nCurRow, nColId
1609 0 : CursorMoveAttempt aAttempt(nCurRow, nColId, bScrolled);
1610 : //Detect if we are already in a call to BrowseBox::GoToColumnId
1611 : //but the attempt is impossible and we are simply recursing
1612 : //into BrowseBox::GoToColumnId with the same impossible to
1613 : //fulfill conditions
1614 0 : if (m_aGotoStack.empty() || aAttempt != m_aGotoStack.top())
1615 : {
1616 0 : m_aGotoStack.push(aAttempt);
1617 0 : CursorMoved();
1618 0 : m_aGotoStack.pop();
1619 : }
1620 : }
1621 1 : return true;
1622 : }
1623 0 : return true;
1624 : }
1625 :
1626 :
1627 :
1628 1 : bool BrowseBox::GoToRowColumnId( long nRow, sal_uInt16 nColId )
1629 : {
1630 :
1631 : // out of range?
1632 1 : if ( nRow < 0 || nRow >= nRowCount )
1633 0 : return false;
1634 :
1635 1 : if (!bColumnCursor)
1636 0 : return false;
1637 :
1638 : // nothing to do ?
1639 4 : if ( nRow == nCurRow && ( bMultiSelection || uRow.nSel == nRow ) &&
1640 2 : nColId == nCurColId && IsFieldVisible(nCurRow, nColId, true))
1641 0 : return true;
1642 :
1643 : // allowed?
1644 1 : if (!IsCursorMoveAllowed(nRow, nColId))
1645 0 : return false;
1646 :
1647 1 : DoHideCursor( "GoToRowColumnId" );
1648 1 : bool bMoved = GoToRow(nRow, true) && GoToColumnId(nColId, true, true);
1649 1 : DoShowCursor( "GoToRowColumnId" );
1650 :
1651 1 : if (bMoved)
1652 1 : CursorMoved();
1653 :
1654 1 : return bMoved;
1655 : }
1656 :
1657 :
1658 :
1659 2 : void BrowseBox::SetNoSelection()
1660 : {
1661 :
1662 : // is there no selection
1663 6 : if ( ( !pColSel || !pColSel->GetSelectCount() ) &&
1664 2 : ( ( !bMultiSelection && uRow.nSel == BROWSER_ENDOFSELECTION ) ||
1665 2 : ( bMultiSelection && !uRow.pSel->GetSelectCount() ) ) )
1666 : // nothing to do
1667 4 : return;
1668 :
1669 : OSL_TRACE( "BrowseBox: %p->HideCursor", this );
1670 0 : ToggleSelection();
1671 :
1672 : // unselect all
1673 0 : if ( bMultiSelection )
1674 0 : uRow.pSel->SelectAll(false);
1675 : else
1676 0 : uRow.nSel = BROWSER_ENDOFSELECTION;
1677 0 : if ( pColSel )
1678 0 : pColSel->SelectAll(false);
1679 0 : if ( !bSelecting )
1680 0 : Select();
1681 : else
1682 0 : bSelect = true;
1683 :
1684 : // restore screen
1685 : OSL_TRACE( "BrowseBox: %p->ShowCursor", this );
1686 :
1687 0 : if ( isAccessibleAlive() )
1688 : {
1689 : commitTableEvent(
1690 : SELECTION_CHANGED,
1691 : Any(),
1692 : Any()
1693 0 : );
1694 : }
1695 : }
1696 :
1697 :
1698 :
1699 0 : void BrowseBox::SelectAll()
1700 : {
1701 :
1702 0 : if ( !bMultiSelection )
1703 0 : return;
1704 :
1705 : OSL_TRACE( "BrowseBox: %p->HideCursor", this );
1706 0 : ToggleSelection();
1707 :
1708 : // select all rows
1709 0 : if ( pColSel )
1710 0 : pColSel->SelectAll(false);
1711 0 : uRow.pSel->SelectAll(true);
1712 :
1713 : // don't highlight handle column
1714 0 : BrowserColumn *pFirstCol = (*pCols)[ 0 ];
1715 0 : long nOfsX = pFirstCol->GetId() ? 0 : pFirstCol->Width();
1716 :
1717 : // highlight the row selection
1718 0 : if ( !bHideSelect )
1719 : {
1720 0 : Rectangle aHighlightRect;
1721 : sal_uInt16 nVisibleRows =
1722 0 : (sal_uInt16)(pDataWin->GetOutputSizePixel().Height() / GetDataRowHeight() + 1);
1723 0 : for ( long nRow = std::max( nTopRow, uRow.pSel->FirstSelected() );
1724 0 : nRow != BROWSER_ENDOFSELECTION && nRow < nTopRow + nVisibleRows;
1725 0 : nRow = uRow.pSel->NextSelected() )
1726 : aHighlightRect.Union( Rectangle(
1727 0 : Point( nOfsX, (nRow-nTopRow)*GetDataRowHeight() ),
1728 0 : Size( pDataWin->GetSizePixel().Width(), GetDataRowHeight() ) ) );
1729 0 : pDataWin->Invalidate( aHighlightRect );
1730 : }
1731 :
1732 0 : if ( !bSelecting )
1733 0 : Select();
1734 : else
1735 0 : bSelect = true;
1736 :
1737 : // restore screen
1738 : OSL_TRACE( "BrowseBox: %p->ShowCursor", this );
1739 :
1740 0 : if ( isAccessibleAlive() )
1741 : {
1742 : commitTableEvent(
1743 : SELECTION_CHANGED,
1744 : Any(),
1745 : Any()
1746 0 : );
1747 : commitHeaderBarEvent(
1748 : SELECTION_CHANGED,
1749 : Any(),
1750 : Any(),
1751 : true
1752 0 : ); // column header event
1753 :
1754 : commitHeaderBarEvent(
1755 : SELECTION_CHANGED,
1756 : Any(),
1757 : Any(),
1758 : false
1759 0 : ); // row header event
1760 : }
1761 : }
1762 :
1763 :
1764 :
1765 0 : void BrowseBox::SelectRow( long nRow, bool _bSelect, bool bExpand )
1766 : {
1767 :
1768 0 : if ( !bMultiSelection )
1769 : {
1770 : // deselecting is impossible, selecting via cursor
1771 0 : if ( _bSelect )
1772 0 : GoToRow(nRow, false);
1773 0 : return;
1774 : }
1775 :
1776 : OSL_TRACE( "BrowseBox: %p->HideCursor", this );
1777 :
1778 : // remove old selection?
1779 0 : if ( !bExpand || !bMultiSelection )
1780 : {
1781 0 : ToggleSelection();
1782 0 : if ( bMultiSelection )
1783 0 : uRow.pSel->SelectAll(false);
1784 : else
1785 0 : uRow.nSel = BROWSER_ENDOFSELECTION;
1786 0 : if ( pColSel )
1787 0 : pColSel->SelectAll(false);
1788 : }
1789 :
1790 : // set new selection
1791 0 : if ( !bHideSelect
1792 0 : && ( ( bMultiSelection
1793 0 : && uRow.pSel->GetTotalRange().Max() >= nRow
1794 0 : && uRow.pSel->Select( nRow, _bSelect )
1795 : )
1796 0 : || ( !bMultiSelection
1797 0 : && ( uRow.nSel = nRow ) != BROWSER_ENDOFSELECTION )
1798 : )
1799 : )
1800 : {
1801 : // don't highlight handle column
1802 0 : BrowserColumn *pFirstCol = (*pCols)[ 0 ];
1803 0 : long nOfsX = pFirstCol->GetId() ? 0 : pFirstCol->Width();
1804 :
1805 : // highlight only newly selected part
1806 : Rectangle aRect(
1807 0 : Point( nOfsX, (nRow-nTopRow)*GetDataRowHeight() ),
1808 0 : Size( pDataWin->GetSizePixel().Width(), GetDataRowHeight() ) );
1809 0 : pDataWin->Invalidate( aRect );
1810 : }
1811 :
1812 0 : if ( !bSelecting )
1813 0 : Select();
1814 : else
1815 0 : bSelect = true;
1816 :
1817 : // restore screen
1818 : OSL_TRACE( "BrowseBox: %p->ShowCursor", this );
1819 :
1820 0 : if ( isAccessibleAlive() )
1821 : {
1822 : commitTableEvent(
1823 : SELECTION_CHANGED,
1824 : Any(),
1825 : Any()
1826 0 : );
1827 : commitHeaderBarEvent(
1828 : SELECTION_CHANGED,
1829 : Any(),
1830 : Any(),
1831 : false
1832 0 : ); // row header event
1833 : }
1834 : }
1835 :
1836 :
1837 :
1838 134 : long BrowseBox::GetSelectRowCount() const
1839 : {
1840 :
1841 134 : return bMultiSelection ? uRow.pSel->GetSelectCount() :
1842 268 : uRow.nSel == BROWSER_ENDOFSELECTION ? 0 : 1;
1843 : }
1844 :
1845 :
1846 :
1847 0 : void BrowseBox::SelectColumnPos( sal_uInt16 nNewColPos, bool _bSelect, bool bMakeVisible )
1848 : {
1849 :
1850 0 : if ( !bColumnCursor || nNewColPos == BROWSER_INVALIDID )
1851 0 : return;
1852 :
1853 0 : if ( !bMultiSelection )
1854 : {
1855 0 : if ( _bSelect )
1856 0 : GoToColumnId( (*pCols)[ nNewColPos ]->GetId(), bMakeVisible );
1857 0 : return;
1858 : }
1859 : else
1860 : {
1861 0 : if ( !GoToColumnId( (*pCols)[ nNewColPos ]->GetId(), bMakeVisible ) )
1862 0 : return;
1863 : }
1864 :
1865 : OSL_TRACE( "BrowseBox: %p->HideCursor", this );
1866 0 : ToggleSelection();
1867 0 : if ( bMultiSelection )
1868 0 : uRow.pSel->SelectAll(false);
1869 : else
1870 0 : uRow.nSel = BROWSER_ENDOFSELECTION;
1871 0 : pColSel->SelectAll(false);
1872 :
1873 0 : if ( pColSel->Select( nNewColPos, _bSelect ) )
1874 : {
1875 : // GoToColumnId( pCols->GetObject(nNewColPos)->GetId(), bMakeVisible );
1876 :
1877 : // only highlight painted areas
1878 0 : pDataWin->Update();
1879 0 : Rectangle aFieldRectPix( GetFieldRectPixel( nCurRow, nCurColId, false ) );
1880 : Rectangle aRect(
1881 0 : Point( aFieldRectPix.Left() - MIN_COLUMNWIDTH, 0 ),
1882 0 : Size( (*pCols)[ nNewColPos ]->Width(),
1883 0 : pDataWin->GetOutputSizePixel().Height() ) );
1884 0 : pDataWin->Invalidate( aRect );
1885 0 : if ( !bSelecting )
1886 0 : Select();
1887 : else
1888 0 : bSelect = true;
1889 :
1890 0 : if ( isAccessibleAlive() )
1891 : {
1892 : commitTableEvent(
1893 : SELECTION_CHANGED,
1894 : Any(),
1895 : Any()
1896 0 : );
1897 : commitHeaderBarEvent(
1898 : SELECTION_CHANGED,
1899 : Any(),
1900 : Any(),
1901 : true
1902 0 : ); // column header event
1903 : }
1904 : }
1905 :
1906 : // restore screen
1907 : OSL_TRACE( "BrowseBox: %p->ShowCursor", this );
1908 : }
1909 :
1910 :
1911 :
1912 41 : sal_uInt16 BrowseBox::GetSelectColumnCount() const
1913 : {
1914 :
1915 : // while bAutoSelect (==!pColSel), 1 if any rows (yes rows!) else none
1916 41 : return pColSel ? (sal_uInt16) pColSel->GetSelectCount() :
1917 82 : nCurRow >= 0 ? 1 : 0;
1918 : }
1919 :
1920 :
1921 0 : long BrowseBox::FirstSelectedColumn( ) const
1922 : {
1923 0 : return pColSel ? pColSel->FirstSelected() : BROWSER_ENDOFSELECTION;
1924 : }
1925 :
1926 :
1927 :
1928 0 : long BrowseBox::FirstSelectedRow( bool bInverse )
1929 : {
1930 :
1931 0 : return bMultiSelection ? uRow.pSel->FirstSelected(bInverse) : uRow.nSel;
1932 : }
1933 :
1934 :
1935 :
1936 0 : long BrowseBox::NextSelectedRow()
1937 : {
1938 :
1939 0 : return bMultiSelection ? uRow.pSel->NextSelected() : BROWSER_ENDOFSELECTION;
1940 : }
1941 :
1942 :
1943 :
1944 0 : long BrowseBox::LastSelectedRow()
1945 : {
1946 :
1947 0 : return bMultiSelection ? uRow.pSel->LastSelected() : uRow.nSel;
1948 : }
1949 :
1950 :
1951 :
1952 16 : bool BrowseBox::IsRowSelected( long nRow ) const
1953 : {
1954 :
1955 16 : return bMultiSelection ? uRow.pSel->IsSelected(nRow) : nRow == uRow.nSel;
1956 : }
1957 :
1958 :
1959 :
1960 112 : bool BrowseBox::IsColumnSelected( sal_uInt16 nColumnId ) const
1961 : {
1962 :
1963 112 : return pColSel ? pColSel->IsSelected( GetColumnPos(nColumnId) ) :
1964 224 : nCurColId == nColumnId;
1965 : }
1966 :
1967 :
1968 :
1969 0 : bool BrowseBox::MakeFieldVisible
1970 : (
1971 : long nRow, // line number of the field (starting with 0)
1972 : sal_uInt16 nColId, // column ID of the field
1973 : bool bComplete // (== false), true => make visible in its entirety
1974 : )
1975 :
1976 : /* [Description]
1977 :
1978 : Makes visible the field described in 'nRow' and 'nColId' by scrolling
1979 : accordingly. If 'bComplete' is set, the field should become visible in its
1980 : entirety.
1981 :
1982 : [Returned Value]
1983 :
1984 : bool true
1985 : The given field is already visible or was already visible.
1986 :
1987 : false
1988 : The given field could not be made visible or in the case of
1989 : 'bComplete' could not be made visible in its entirety.
1990 : */
1991 :
1992 : {
1993 0 : Size aTestSize = pDataWin->GetSizePixel();
1994 :
1995 0 : if ( !bBootstrapped ||
1996 0 : ( aTestSize.Width() == 0 && aTestSize.Height() == 0 ) )
1997 0 : return false;
1998 :
1999 : // is it visible already?
2000 0 : bool bVisible = IsFieldVisible( nRow, nColId, bComplete );
2001 0 : if ( bVisible )
2002 0 : return true;
2003 :
2004 : // calculate column position, field rectangle and painting area
2005 0 : sal_uInt16 nColPos = GetColumnPos( nColId );
2006 0 : Rectangle aFieldRect = GetFieldRectPixel( nRow, nColId, false );
2007 0 : Rectangle aDataRect = Rectangle( Point(0, 0), pDataWin->GetSizePixel() );
2008 :
2009 : // positioned outside on the left?
2010 0 : if ( nColPos >= FrozenColCount() && nColPos < nFirstCol )
2011 : // => scroll to the right
2012 0 : ScrollColumns( nColPos - nFirstCol );
2013 :
2014 : // while outside on the right
2015 0 : while ( aDataRect.Right() < ( bComplete
2016 0 : ? aFieldRect.Right()
2017 0 : : aFieldRect.Left()+aFieldRect.GetWidth()/2 ) )
2018 : {
2019 : // => scroll to the left
2020 0 : if ( ScrollColumns( 1 ) != 1 )
2021 : // no more need to scroll
2022 0 : break;
2023 0 : aFieldRect = GetFieldRectPixel( nRow, nColId, false );
2024 : }
2025 :
2026 : // positioned outside above?
2027 0 : if ( nRow < nTopRow )
2028 : // scroll further to the bottom
2029 0 : ScrollRows( nRow - nTopRow );
2030 :
2031 : // positioned outside below?
2032 0 : long nBottomRow = nTopRow + GetVisibleRows();
2033 : // decrement nBottomRow to make it the number of the last visible line
2034 : // (count starts with 0!).
2035 : // Example: BrowseBox contains exactly one entry. nBottomRow := 0 + 1 - 1
2036 0 : if( nBottomRow )
2037 0 : nBottomRow--;
2038 :
2039 0 : if ( nRow > nBottomRow )
2040 : // scroll further to the top
2041 0 : ScrollRows( nRow - nBottomRow );
2042 :
2043 : // it might still not actually fit, e.g. if the window is too small
2044 0 : return IsFieldVisible( nRow, nColId, bComplete );
2045 : }
2046 :
2047 :
2048 :
2049 0 : bool BrowseBox::IsFieldVisible( long nRow, sal_uInt16 nColumnId,
2050 : bool bCompletely ) const
2051 : {
2052 :
2053 : // hidden by frozen column?
2054 0 : sal_uInt16 nColPos = GetColumnPos( nColumnId );
2055 0 : if ( nColPos >= FrozenColCount() && nColPos < nFirstCol )
2056 0 : return false;
2057 :
2058 0 : Rectangle aRect( ImplFieldRectPixel( nRow, nColumnId ) );
2059 0 : if ( aRect.IsEmpty() )
2060 0 : return false;
2061 :
2062 : // get the visible area
2063 0 : Rectangle aOutRect( Point(0, 0), pDataWin->GetOutputSizePixel() );
2064 :
2065 0 : if ( bCompletely )
2066 : // test if the field is completely visible
2067 0 : return aOutRect.IsInside( aRect );
2068 : else
2069 : // test if the field is partly of completely visible
2070 0 : return !aOutRect.Intersection( aRect ).IsEmpty();
2071 : }
2072 :
2073 :
2074 :
2075 379 : Rectangle BrowseBox::GetFieldRectPixel( long nRow, sal_uInt16 nColumnId,
2076 : bool bRelToBrowser) const
2077 : {
2078 :
2079 : // get the rectangle relative to DataWin
2080 379 : Rectangle aRect( ImplFieldRectPixel( nRow, nColumnId ) );
2081 379 : if ( aRect.IsEmpty() )
2082 262 : return aRect;
2083 :
2084 : // adjust relative to BrowseBox's output area
2085 117 : Point aTopLeft( aRect.TopLeft() );
2086 117 : if ( bRelToBrowser )
2087 : {
2088 0 : aTopLeft = pDataWin->OutputToScreenPixel( aTopLeft );
2089 0 : aTopLeft = ScreenToOutputPixel( aTopLeft );
2090 : }
2091 :
2092 117 : return Rectangle( aTopLeft, aRect.GetSize() );
2093 : }
2094 :
2095 :
2096 :
2097 0 : Rectangle BrowseBox::GetRowRectPixel( long nRow, bool bRelToBrowser ) const
2098 : {
2099 :
2100 : // get the rectangle relative to DataWin
2101 0 : Rectangle aRect;
2102 0 : if ( nTopRow > nRow )
2103 : // row is above visible area
2104 0 : return aRect;
2105 : aRect = Rectangle(
2106 0 : Point( 0, GetDataRowHeight() * (nRow-nTopRow) ),
2107 0 : Size( pDataWin->GetOutputSizePixel().Width(), GetDataRowHeight() ) );
2108 0 : if ( aRect.TopLeft().Y() > pDataWin->GetOutputSizePixel().Height() )
2109 : // row is below visible area
2110 0 : return aRect;
2111 :
2112 : // adjust relative to BrowseBox's output area
2113 0 : Point aTopLeft( aRect.TopLeft() );
2114 0 : if ( bRelToBrowser )
2115 : {
2116 0 : aTopLeft = pDataWin->OutputToScreenPixel( aTopLeft );
2117 0 : aTopLeft = ScreenToOutputPixel( aTopLeft );
2118 : }
2119 :
2120 0 : return Rectangle( aTopLeft, aRect.GetSize() );
2121 : }
2122 :
2123 :
2124 :
2125 379 : Rectangle BrowseBox::ImplFieldRectPixel( long nRow, sal_uInt16 nColumnId ) const
2126 : {
2127 :
2128 : // compute the X-coordinate relative to DataWin by accumulation
2129 379 : long nColX = 0;
2130 379 : sal_uInt16 nFrozenCols = FrozenColCount();
2131 : size_t nCol;
2132 2188 : for ( nCol = 0;
2133 1094 : nCol < pCols->size() && (*pCols)[ nCol ]->GetId() != nColumnId;
2134 : ++nCol )
2135 715 : if ( (*pCols)[ nCol ]->IsFrozen() || nCol >= nFirstCol )
2136 715 : nColX += (*pCols)[ nCol ]->Width();
2137 :
2138 379 : if ( nCol >= pCols->size() || ( nCol >= nFrozenCols && nCol < nFirstCol ) )
2139 262 : return Rectangle();
2140 :
2141 : // compute the Y-coordinate relative to DataWin
2142 117 : long nRowY = GetDataRowHeight();
2143 117 : if ( nRow != BROWSER_ENDOFSELECTION ) // #105497# OJ
2144 2 : nRowY = ( nRow - nTopRow ) * GetDataRowHeight();
2145 :
2146 : // assemble the Rectangle relative to DataWin
2147 : return Rectangle(
2148 : Point( nColX + MIN_COLUMNWIDTH, nRowY ),
2149 117 : Size( (*pCols)[ nCol ]->Width() - 2*MIN_COLUMNWIDTH,
2150 234 : GetDataRowHeight() - 1 ) );
2151 : }
2152 :
2153 :
2154 :
2155 0 : long BrowseBox::GetRowAtYPosPixel( long nY, bool bRelToBrowser ) const
2156 : {
2157 :
2158 : // compute the Y-coordinate
2159 0 : if ( bRelToBrowser )
2160 : {
2161 0 : Point aDataTopLeft = pDataWin->OutputToScreenPixel( Point(0, 0) );
2162 0 : Point aTopLeft = OutputToScreenPixel( Point(0, 0) );
2163 0 : nY -= aDataTopLeft.Y() - aTopLeft.Y();
2164 : }
2165 :
2166 : // no row there (e.g. in the header)
2167 0 : if ( nY < 0 || nY >= pDataWin->GetOutputSizePixel().Height() )
2168 0 : return -1;
2169 :
2170 0 : return nY / GetDataRowHeight() + nTopRow;
2171 : }
2172 :
2173 :
2174 :
2175 0 : Rectangle BrowseBox::GetFieldRect( sal_uInt16 nColumnId ) const
2176 : {
2177 :
2178 0 : return GetFieldRectPixel( nCurRow, nColumnId );
2179 : }
2180 :
2181 :
2182 :
2183 356 : sal_uInt16 BrowseBox::GetColumnAtXPosPixel( long nX, bool ) const
2184 : {
2185 :
2186 : // accumulate the widths of the visible columns
2187 356 : long nColX = 0;
2188 1382 : for ( size_t nCol = 0; nCol < pCols->size(); ++nCol )
2189 : {
2190 1057 : BrowserColumn *pCol = (*pCols)[ nCol ];
2191 1057 : if ( pCol->IsFrozen() || nCol >= nFirstCol )
2192 1057 : nColX += pCol->Width();
2193 :
2194 1057 : if ( nColX > nX )
2195 31 : return nCol;
2196 : }
2197 :
2198 325 : return BROWSER_INVALIDID;
2199 : }
2200 :
2201 :
2202 :
2203 242 : void BrowseBox::ReserveControlArea( sal_uInt16 nWidth )
2204 : {
2205 :
2206 242 : if ( nWidth != nControlAreaWidth )
2207 : {
2208 : OSL_ENSURE(nWidth,"Control area of 0 is not allowed, Use USHRT_MAX instead!");
2209 23 : nControlAreaWidth = nWidth;
2210 23 : UpdateScrollbars();
2211 : }
2212 242 : }
2213 :
2214 :
2215 :
2216 1055 : Rectangle BrowseBox::GetControlArea() const
2217 : {
2218 :
2219 : return Rectangle(
2220 3165 : Point( 0, GetOutputSizePixel().Height() - aHScroll->GetSizePixel().Height() ),
2221 3165 : Size( GetOutputSizePixel().Width() - aHScroll->GetSizePixel().Width(),
2222 7385 : aHScroll->GetSizePixel().Height() ) );
2223 : }
2224 :
2225 :
2226 :
2227 60 : void BrowseBox::SetMode( BrowserMode nMode )
2228 : {
2229 :
2230 60 : getDataWindow()->bAutoHScroll = BrowserMode::AUTO_HSCROLL == ( nMode & BrowserMode::AUTO_HSCROLL );
2231 60 : getDataWindow()->bAutoVScroll = BrowserMode::AUTO_VSCROLL == ( nMode & BrowserMode::AUTO_VSCROLL );
2232 60 : getDataWindow()->bNoHScroll = BrowserMode::NO_HSCROLL == ( nMode & BrowserMode::NO_HSCROLL );
2233 60 : getDataWindow()->bNoVScroll = BrowserMode::NO_VSCROLL == ( nMode & BrowserMode::NO_VSCROLL );
2234 :
2235 : DBG_ASSERT( !( getDataWindow()->bAutoHScroll && getDataWindow()->bNoHScroll ),
2236 : "BrowseBox::SetMode: AutoHScroll *and* NoHScroll?" );
2237 : DBG_ASSERT( !( getDataWindow()->bAutoVScroll && getDataWindow()->bNoVScroll ),
2238 : "BrowseBox::SetMode: AutoVScroll *and* NoVScroll?" );
2239 60 : if ( getDataWindow()->bAutoHScroll )
2240 14 : getDataWindow()->bNoHScroll = false;
2241 60 : if ( getDataWindow()->bAutoVScroll )
2242 14 : getDataWindow()->bNoVScroll = false;
2243 :
2244 60 : if ( getDataWindow()->bNoHScroll )
2245 0 : aHScroll->Hide();
2246 :
2247 60 : nControlAreaWidth = USHRT_MAX;
2248 :
2249 60 : getDataWindow()->bNoScrollBack =
2250 60 : BrowserMode::NO_SCROLLBACK == ( nMode & BrowserMode::NO_SCROLLBACK);
2251 :
2252 60 : long nOldRowSel = bMultiSelection ? uRow.pSel->FirstSelected() : uRow.nSel;
2253 60 : MultiSelection *pOldRowSel = bMultiSelection ? uRow.pSel : 0;
2254 60 : MultiSelection *pOldColSel = pColSel;
2255 :
2256 60 : pVScroll.disposeAndClear();
2257 :
2258 60 : bThumbDragging = ( nMode & BrowserMode::THUMBDRAGGING ) == BrowserMode::THUMBDRAGGING;
2259 60 : bMultiSelection = ( nMode & BrowserMode::MULTISELECTION ) == BrowserMode::MULTISELECTION;
2260 60 : bColumnCursor = ( nMode & BrowserMode::COLUMNSELECTION ) == BrowserMode::COLUMNSELECTION;
2261 60 : bKeepHighlight = ( nMode & BrowserMode::KEEPHIGHLIGHT ) == BrowserMode::KEEPHIGHLIGHT;
2262 :
2263 60 : bHideSelect = ((nMode & BrowserMode::HIDESELECT) == BrowserMode::HIDESELECT);
2264 : // default: do not hide the cursor at all (untaken scrolling and such)
2265 60 : bHideCursor = TRISTATE_FALSE;
2266 :
2267 60 : if ( BrowserMode::SMART_HIDECURSOR == ( nMode & BrowserMode::SMART_HIDECURSOR ) )
2268 : { // smart cursor hide overrules hard cursor hide
2269 0 : bHideCursor = TRISTATE_INDET;
2270 : }
2271 60 : else if ( BrowserMode::HIDECURSOR == ( nMode & BrowserMode::HIDECURSOR ) )
2272 : {
2273 1 : bHideCursor = TRISTATE_TRUE;
2274 : }
2275 :
2276 60 : m_bFocusOnlyCursor = ((nMode & BrowserMode::CURSOR_WO_FOCUS) == BrowserMode::NONE);
2277 :
2278 60 : bHLines = ( nMode & BrowserMode::HLINES ) == BrowserMode::HLINES;
2279 60 : bVLines = ( nMode & BrowserMode::VLINES ) == BrowserMode::VLINES;
2280 :
2281 : WinBits nVScrollWinBits =
2282 60 : WB_VSCROLL | ( ( nMode & BrowserMode::THUMBDRAGGING ) ? WB_DRAG : 0 );
2283 180 : pVScroll = VclPtr<ScrollBar>(
2284 120 : ( nMode & BrowserMode::TRACKING_TIPS ) == BrowserMode::TRACKING_TIPS
2285 : ? VclPtr<BrowserScrollBar>::Create( this, nVScrollWinBits,
2286 60 : static_cast<BrowserDataWin*>( pDataWin.get() ) )
2287 60 : : VclPtr<ScrollBar>::Create( this, nVScrollWinBits ));
2288 60 : pVScroll->SetLineSize( 1 );
2289 60 : pVScroll->SetPageSize(1);
2290 60 : pVScroll->SetScrollHdl( LINK( this, BrowseBox, ScrollHdl ) );
2291 60 : pVScroll->SetEndScrollHdl( LINK( this, BrowseBox, EndScrollHdl ) );
2292 :
2293 60 : getDataWindow()->bAutoSizeLastCol =
2294 60 : BrowserMode::AUTOSIZE_LASTCOL == ( nMode & BrowserMode::AUTOSIZE_LASTCOL );
2295 60 : getDataWindow()->bOwnDataChangedHdl =
2296 60 : BrowserMode::OWN_DATACHANGED == ( nMode & BrowserMode::OWN_DATACHANGED );
2297 :
2298 : // create a headerbar. what happens, if a headerbar has to be created and
2299 : // there already are columns?
2300 60 : if ( BrowserMode::HEADERBAR_NEW == ( nMode & BrowserMode::HEADERBAR_NEW ) )
2301 : {
2302 60 : if (!getDataWindow()->pHeaderBar)
2303 20 : getDataWindow()->pHeaderBar = CreateHeaderBar( this );
2304 : }
2305 : else
2306 : {
2307 0 : getDataWindow()->pHeaderBar.disposeAndClear();
2308 : }
2309 :
2310 60 : if ( bColumnCursor )
2311 : {
2312 60 : pColSel = pOldColSel ? pOldColSel : new MultiSelection;
2313 60 : pColSel->SetTotalRange( Range( 0, pCols->size()-1 ) );
2314 : }
2315 : else
2316 : {
2317 0 : delete pColSel;
2318 0 : pColSel = 0;
2319 : }
2320 :
2321 60 : if ( bMultiSelection )
2322 : {
2323 60 : if ( pOldRowSel )
2324 40 : uRow.pSel = pOldRowSel;
2325 : else
2326 20 : uRow.pSel = new MultiSelection;
2327 : }
2328 : else
2329 : {
2330 0 : uRow.nSel = nOldRowSel;
2331 0 : delete pOldRowSel;
2332 : }
2333 :
2334 60 : if ( bBootstrapped )
2335 : {
2336 11 : StateChanged( StateChangedType::InitShow );
2337 11 : if ( bMultiSelection && !pOldRowSel &&
2338 : nOldRowSel != BROWSER_ENDOFSELECTION )
2339 0 : uRow.pSel->Select( nOldRowSel );
2340 : }
2341 :
2342 60 : if ( pDataWin )
2343 60 : pDataWin->Invalidate();
2344 :
2345 : // no cursor on handle column
2346 60 : if ( nCurColId == HandleColumnId )
2347 20 : nCurColId = GetColumnId( 1 );
2348 :
2349 60 : m_nCurrentMode = nMode;
2350 60 : }
2351 :
2352 :
2353 :
2354 0 : void BrowseBox::VisibleRowsChanged( long, sal_uInt16 )
2355 : {
2356 :
2357 : // old behavior: automatically correct NumRows:
2358 0 : if ( nRowCount < GetRowCount() )
2359 : {
2360 0 : RowInserted(nRowCount,GetRowCount() - nRowCount, false);
2361 : }
2362 0 : else if ( nRowCount > GetRowCount() )
2363 : {
2364 0 : RowRemoved(nRowCount-(nRowCount - GetRowCount()),nRowCount - GetRowCount(), false);
2365 : }
2366 0 : }
2367 :
2368 :
2369 :
2370 0 : bool BrowseBox::IsCursorMoveAllowed( long, sal_uInt16 ) const
2371 :
2372 : /* [Description]
2373 :
2374 : This virtual method is always called before the cursor is moved directly.
2375 : By means of 'return sal_False', we avoid doing this if e.g. a record
2376 : contradicts any rules.
2377 :
2378 : This method is not called, if the cursor movement results from removing or
2379 : deleting a row/column (thus, in cases where only a "cursor correction" happens).
2380 :
2381 : The base implementation currently always returns true.
2382 : */
2383 :
2384 : {
2385 0 : return true;
2386 : }
2387 :
2388 :
2389 :
2390 2937 : long BrowseBox::GetDataRowHeight() const
2391 : {
2392 2937 : return CalcZoom(nDataRowHeight ? nDataRowHeight : ImpGetDataRowHeight());
2393 : }
2394 :
2395 :
2396 :
2397 20 : VclPtr<BrowserHeader> BrowseBox::CreateHeaderBar( BrowseBox* pParent )
2398 : {
2399 20 : VclPtr<BrowserHeader> pNewBar = VclPtr<BrowserHeader>::Create( pParent );
2400 20 : pNewBar->SetStartDragHdl( LINK( this, BrowseBox, StartDragHdl ) );
2401 20 : return pNewBar;
2402 : }
2403 :
2404 20 : void BrowseBox::SetHeaderBar( BrowserHeader* pHeaderBar )
2405 : {
2406 20 : static_cast<BrowserDataWin*>( pDataWin.get() )->pHeaderBar.disposeAndClear();
2407 20 : static_cast<BrowserDataWin*>( pDataWin.get() )->pHeaderBar = pHeaderBar;
2408 20 : static_cast<BrowserDataWin*>( pDataWin.get() )->pHeaderBar->SetStartDragHdl( LINK( this, BrowseBox, StartDragHdl ) );
2409 20 : }
2410 :
2411 2439 : long BrowseBox::GetTitleHeight() const
2412 : {
2413 : long nHeight;
2414 : // ask the header bar for the text height (if possible), as the header bar's font is adjusted with
2415 : // our (and the header's) zoom factor
2416 2439 : HeaderBar* pHeaderBar = static_cast<BrowserDataWin*>( pDataWin.get() )->pHeaderBar;
2417 2439 : if ( pHeaderBar )
2418 2419 : nHeight = pHeaderBar->GetTextHeight();
2419 : else
2420 20 : nHeight = GetTextHeight();
2421 :
2422 2439 : return nTitleLines ? nTitleLines * nHeight + 4 : 0;
2423 : }
2424 :
2425 112 : long BrowseBox::CalcReverseZoom(long nVal)
2426 : {
2427 112 : if (IsZoom())
2428 : {
2429 0 : const Fraction& rZoom = GetZoom();
2430 0 : double n = (double)nVal;
2431 0 : n *= (double)rZoom.GetDenominator();
2432 0 : if (!rZoom.GetNumerator())
2433 0 : throw o3tl::divide_by_zero();
2434 0 : n /= (double)rZoom.GetNumerator();
2435 0 : nVal = n>0 ? (long)(n + 0.5) : -(long)(-n + 0.5);
2436 : }
2437 :
2438 112 : return nVal;
2439 : }
2440 :
2441 0 : void BrowseBox::CursorMoved()
2442 : {
2443 : // before implementing more here, please adjust the EditBrowseBox
2444 :
2445 0 : if ( isAccessibleAlive() && HasFocus() )
2446 : commitTableEvent(
2447 : ACTIVE_DESCENDANT_CHANGED,
2448 0 : makeAny( CreateAccessibleCell( GetCurRow(),GetColumnPos( GetCurColumnId() ) ) ),
2449 : Any()
2450 0 : );
2451 0 : }
2452 :
2453 0 : void BrowseBox::LoseFocus()
2454 : {
2455 : OSL_TRACE( "BrowseBox: %p->LoseFocus", this );
2456 :
2457 0 : if ( bHasFocus )
2458 : {
2459 : OSL_TRACE( "BrowseBox: %p->HideCursor", this );
2460 0 : DoHideCursor( "LoseFocus" );
2461 :
2462 0 : if ( !bKeepHighlight )
2463 : {
2464 0 : ToggleSelection();
2465 0 : bSelectionIsVisible = false;
2466 : }
2467 :
2468 0 : bHasFocus = false;
2469 : }
2470 0 : Control::LoseFocus();
2471 0 : }
2472 :
2473 :
2474 :
2475 0 : void BrowseBox::GetFocus()
2476 : {
2477 : OSL_TRACE( "BrowseBox: %p->GetFocus", this );
2478 :
2479 0 : if ( !bHasFocus )
2480 : {
2481 0 : if ( !bSelectionIsVisible )
2482 : {
2483 0 : bSelectionIsVisible = true;
2484 0 : if ( bBootstrapped )
2485 0 : ToggleSelection();
2486 : }
2487 :
2488 0 : bHasFocus = true;
2489 0 : DoShowCursor( "GetFocus" );
2490 : }
2491 0 : Control::GetFocus();
2492 0 : }
2493 :
2494 :
2495 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
