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