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 <tools/debug.hxx>
21 : #include <svtools/brwbox.hxx>
22 : #include "datwin.hxx"
23 : #include <svtools/colorcfg.hxx>
24 : #include <vcl/salgtype.hxx>
25 : #include <vcl/settings.hxx>
26 :
27 : #include <tools/multisel.hxx>
28 : #include <algorithm>
29 :
30 : using namespace ::com::sun::star::datatransfer;
31 :
32 : #define getDataWindow() (static_cast<BrowserDataWin*>(pDataWin))
33 :
34 :
35 :
36 0 : void BrowseBox::StartDrag( sal_Int8 /* _nAction */, const Point& /* _rPosPixel */ )
37 : {
38 : // not interested in this event
39 0 : }
40 :
41 :
42 :
43 0 : sal_Int8 BrowseBox::AcceptDrop( const AcceptDropEvent& _rEvt )
44 : {
45 0 : BrowserDataWin* pDataWindow = static_cast<BrowserDataWin*>(pDataWin);
46 0 : AcceptDropEvent aTransformed( _rEvt );
47 0 : aTransformed.maPosPixel = pDataWindow->ScreenToOutputPixel( OutputToScreenPixel( _rEvt.maPosPixel ) );
48 0 : return pDataWindow->AcceptDrop( aTransformed );
49 : }
50 :
51 :
52 :
53 0 : sal_Int8 BrowseBox::ExecuteDrop( const ExecuteDropEvent& _rEvt )
54 : {
55 0 : BrowserDataWin* pDataWindow = static_cast<BrowserDataWin*>(pDataWin);
56 0 : ExecuteDropEvent aTransformed( _rEvt );
57 0 : aTransformed.maPosPixel = pDataWindow->ScreenToOutputPixel( OutputToScreenPixel( _rEvt.maPosPixel ) );
58 0 : return pDataWindow->ExecuteDrop( aTransformed );
59 : }
60 :
61 :
62 :
63 0 : sal_Int8 BrowseBox::AcceptDrop( const BrowserAcceptDropEvent& )
64 : {
65 : // not interested in this event
66 0 : return DND_ACTION_NONE;
67 : }
68 :
69 :
70 :
71 0 : sal_Int8 BrowseBox::ExecuteDrop( const BrowserExecuteDropEvent& )
72 : {
73 : // not interested in this event
74 0 : return DND_ACTION_NONE;
75 : }
76 :
77 :
78 :
79 0 : void* BrowseBox::implGetDataFlavors() const
80 : {
81 0 : if (static_cast<BrowserDataWin*>(pDataWin)->bCallingDropCallback)
82 0 : return &static_cast<BrowserDataWin*>(pDataWin)->GetDataFlavorExVector();
83 0 : return &GetDataFlavorExVector();
84 : }
85 :
86 :
87 :
88 0 : bool BrowseBox::IsDropFormatSupported( SotFormatStringId _nFormat )
89 : {
90 0 : if ( static_cast< BrowserDataWin* >( pDataWin )->bCallingDropCallback )
91 0 : return static_cast< BrowserDataWin* >( pDataWin )->IsDropFormatSupported( _nFormat );
92 :
93 0 : return DropTargetHelper::IsDropFormatSupported( _nFormat );
94 : }
95 :
96 :
97 :
98 0 : bool BrowseBox::IsDropFormatSupported( SotFormatStringId _nFormat ) const
99 : {
100 0 : return const_cast< BrowseBox* >( this )->IsDropFormatSupported( _nFormat );
101 : }
102 :
103 :
104 :
105 0 : bool BrowseBox::IsDropFormatSupported( const DataFlavor& _rFlavor )
106 : {
107 0 : if ( static_cast< BrowserDataWin* >( pDataWin )->bCallingDropCallback )
108 0 : return static_cast< BrowserDataWin* >( pDataWin )->IsDropFormatSupported( _rFlavor );
109 :
110 0 : return DropTargetHelper::IsDropFormatSupported( _rFlavor );
111 : }
112 :
113 :
114 :
115 0 : bool BrowseBox::IsDropFormatSupported( const DataFlavor& _rFlavor ) const
116 : {
117 0 : return const_cast< BrowseBox* >( this )->IsDropFormatSupported( _rFlavor );
118 : }
119 :
120 :
121 :
122 0 : void BrowseBox::Command( const CommandEvent& rEvt )
123 : {
124 0 : if ( !getDataWindow()->bInCommand )
125 0 : Control::Command( rEvt );
126 0 : }
127 :
128 :
129 :
130 538 : void BrowseBox::StateChanged( StateChangedType nStateChange )
131 : {
132 538 : Control::StateChanged( nStateChange );
133 :
134 538 : if ( StateChangedType::MIRRORING == nStateChange )
135 : {
136 100 : getDataWindow()->EnableRTL( IsRTLEnabled() );
137 :
138 100 : HeaderBar* pHeaderBar = getDataWindow()->pHeaderBar;
139 100 : if ( pHeaderBar )
140 100 : pHeaderBar->EnableRTL( IsRTLEnabled() );
141 100 : aHScroll.EnableRTL( IsRTLEnabled() );
142 100 : if( pVScroll )
143 100 : pVScroll->EnableRTL( IsRTLEnabled() );
144 100 : Resize();
145 : }
146 438 : else if ( StateChangedType::INITSHOW == nStateChange )
147 : {
148 63 : bBootstrapped = true; // must be set first!
149 :
150 63 : Resize();
151 63 : if ( bMultiSelection )
152 63 : uRow.pSel->SetTotalRange( Range( 0, nRowCount - 1 ) );
153 63 : if ( nRowCount == 0 )
154 61 : nCurRow = BROWSER_ENDOFSELECTION;
155 2 : else if ( nCurRow == BROWSER_ENDOFSELECTION )
156 0 : nCurRow = 0;
157 :
158 :
159 63 : if ( HasFocus() )
160 : {
161 0 : bSelectionIsVisible = true;
162 0 : bHasFocus = true;
163 : }
164 63 : UpdateScrollbars();
165 63 : AutoSizeLastColumn();
166 63 : CursorMoved();
167 : }
168 375 : else if (StateChangedType::ZOOM == nStateChange)
169 : {
170 0 : pDataWin->SetZoom(GetZoom());
171 0 : HeaderBar* pHeaderBar = getDataWindow()->pHeaderBar;
172 0 : if (pHeaderBar)
173 0 : pHeaderBar->SetZoom(GetZoom());
174 :
175 : // let the columns calculate their new widths and adjust the header bar
176 0 : for ( size_t nPos = 0; nPos < pCols->size(); ++nPos )
177 : {
178 0 : (*pCols)[ nPos ]->ZoomChanged(GetZoom());
179 0 : if ( pHeaderBar )
180 0 : pHeaderBar->SetItemSize( (*pCols)[ nPos ]->GetId(), (*pCols)[ nPos ]->Width() );
181 : }
182 :
183 : // all our controls have to be repositioned
184 0 : Resize();
185 : }
186 375 : else if (StateChangedType::ENABLE == nStateChange)
187 : {
188 : // do we have a handle column?
189 12 : bool bHandleCol = !pCols->empty() && (0 == (*pCols)[ 0 ]->GetId());
190 : // do we have a header bar?
191 12 : bool bHeaderBar = (NULL != static_cast<BrowserDataWin&>(GetDataWindow()).pHeaderBar);
192 :
193 12 : if ( nTitleLines
194 12 : && ( !bHeaderBar
195 12 : || bHandleCol
196 : )
197 : )
198 : // we draw the text in our header bar in a color dependent on the enabled state. So if this state changed
199 : // -> redraw
200 12 : Invalidate(Rectangle(Point(0, 0), Size(GetOutputSizePixel().Width(), GetTitleHeight() - 1)));
201 : }
202 538 : }
203 :
204 :
205 :
206 0 : void BrowseBox::Select()
207 : {
208 0 : }
209 :
210 :
211 :
212 0 : void BrowseBox::DoubleClick( const BrowserMouseEvent & )
213 : {
214 0 : }
215 :
216 :
217 :
218 0 : long BrowseBox::QueryMinimumRowHeight()
219 : {
220 0 : return CalcZoom( 5 );
221 : }
222 :
223 :
224 :
225 0 : void BrowseBox::ImplStartTracking()
226 : {
227 0 : }
228 :
229 :
230 :
231 0 : void BrowseBox::ImplTracking()
232 : {
233 0 : }
234 :
235 :
236 :
237 0 : void BrowseBox::ImplEndTracking()
238 : {
239 0 : }
240 :
241 :
242 :
243 0 : void BrowseBox::RowHeightChanged()
244 : {
245 0 : }
246 :
247 :
248 :
249 0 : long BrowseBox::QueryColumnResize( sal_uInt16, long nWidth )
250 : {
251 0 : return nWidth;
252 : }
253 :
254 :
255 :
256 0 : void BrowseBox::ColumnResized( sal_uInt16 )
257 : {
258 0 : }
259 :
260 :
261 :
262 0 : void BrowseBox::ColumnMoved( sal_uInt16 )
263 : {
264 0 : }
265 :
266 :
267 :
268 0 : void BrowseBox::StartScroll()
269 : {
270 0 : DoHideCursor( "StartScroll" );
271 0 : }
272 :
273 :
274 :
275 0 : void BrowseBox::EndScroll()
276 : {
277 0 : UpdateScrollbars();
278 0 : AutoSizeLastColumn();
279 0 : DoShowCursor( "EndScroll" );
280 0 : }
281 :
282 :
283 :
284 0 : void BrowseBox::ToggleSelection( bool bForce )
285 : {
286 :
287 : // selection highlight-toggling allowed?
288 0 : if ( bHideSelect )
289 0 : return;
290 0 : if ( !bForce &&
291 0 : ( bNotToggleSel || !IsUpdateMode() || !bSelectionIsVisible ) )
292 0 : return;
293 :
294 : // only highlight painted areas!
295 0 : bNotToggleSel = true;
296 : if ( false && !getDataWindow()->bInPaint )
297 : pDataWin->Update();
298 :
299 : // accumulate areas of rows to highlight
300 0 : RectangleList aHighlightList;
301 0 : long nLastRowInRect = 0; // for the CFront
302 :
303 : // don't highlight handle column
304 0 : BrowserColumn *pFirstCol = pCols->empty() ? NULL : (*pCols)[ 0 ];
305 0 : long nOfsX = (!pFirstCol || pFirstCol->GetId()) ? 0 : pFirstCol->Width();
306 :
307 : // accumulate old row selection
308 0 : long nBottomRow = nTopRow +
309 0 : pDataWin->GetOutputSizePixel().Height() / GetDataRowHeight();
310 0 : if ( nBottomRow > GetRowCount() && GetRowCount() )
311 0 : nBottomRow = GetRowCount();
312 0 : for ( long nRow = bMultiSelection ? uRow.pSel->FirstSelected() : uRow.nSel;
313 0 : nRow != BROWSER_ENDOFSELECTION && nRow <= nBottomRow;
314 0 : nRow = bMultiSelection ? uRow.pSel->NextSelected() : BROWSER_ENDOFSELECTION )
315 : {
316 0 : if ( nRow < nTopRow )
317 0 : continue;
318 :
319 : Rectangle aAddRect(
320 0 : Point( nOfsX, (nRow-nTopRow)*GetDataRowHeight() ),
321 0 : Size( pDataWin->GetSizePixel().Width(), GetDataRowHeight() ) );
322 0 : if ( aHighlightList.size() && nLastRowInRect == ( nRow - 1 ) )
323 0 : aHighlightList[ 0 ]->Union( aAddRect );
324 : else
325 0 : aHighlightList.insert( aHighlightList.begin(), new Rectangle( aAddRect ) );
326 0 : nLastRowInRect = nRow;
327 : }
328 :
329 : // unhighlight the old selection (if any)
330 0 : for ( size_t i = aHighlightList.size(); i > 0; )
331 : {
332 0 : Rectangle *pRect = aHighlightList[ --i ];
333 0 : pDataWin->Invalidate( *pRect );
334 0 : delete pRect;
335 : }
336 0 : aHighlightList.clear();
337 :
338 : // unhighlight old column selection (if any)
339 0 : for ( long nColId = pColSel ? pColSel->FirstSelected() : BROWSER_ENDOFSELECTION;
340 : nColId != BROWSER_ENDOFSELECTION;
341 0 : nColId = pColSel->NextSelected() )
342 : {
343 : Rectangle aRect( GetFieldRectPixel(nCurRow,
344 0 : (*pCols)[ nColId ]->GetId(),
345 0 : false ) );
346 0 : aRect.Left() -= MIN_COLUMNWIDTH;
347 0 : aRect.Right() += MIN_COLUMNWIDTH;
348 0 : aRect.Top() = 0;
349 0 : aRect.Bottom() = pDataWin->GetOutputSizePixel().Height();
350 0 : pDataWin->Invalidate( aRect );
351 : }
352 :
353 0 : bNotToggleSel = false;
354 : }
355 :
356 :
357 :
358 246 : void BrowseBox::DrawCursor()
359 : {
360 246 : bool bReallyHide = false;
361 246 : if ( bHideCursor == TRISTATE_INDET )
362 : {
363 0 : if ( !GetSelectRowCount() && !GetSelectColumnCount() )
364 0 : bReallyHide = true;
365 : }
366 246 : else if ( bHideCursor == TRISTATE_TRUE )
367 : {
368 0 : bReallyHide = true;
369 : }
370 :
371 246 : bReallyHide |= !bSelectionIsVisible || !IsUpdateMode() || bScrolling || nCurRow < 0;
372 :
373 246 : if (PaintCursorIfHiddenOnce())
374 246 : bReallyHide |= ( GetCursorHideCount() > 1 );
375 : else
376 0 : bReallyHide |= ( GetCursorHideCount() > 0 );
377 :
378 : // no cursor on handle column
379 246 : if ( nCurColId == HandleColumnId )
380 0 : nCurColId = GetColumnId(1);
381 :
382 : // calculate cursor rectangle
383 246 : Rectangle aCursor;
384 246 : if ( bColumnCursor )
385 : {
386 246 : aCursor = GetFieldRectPixel( nCurRow, nCurColId, false );
387 246 : aCursor.Left() -= MIN_COLUMNWIDTH;
388 246 : aCursor.Right() += 1;
389 246 : aCursor.Bottom() += 1;
390 : }
391 : else
392 : aCursor = Rectangle(
393 0 : Point( ( !pCols->empty() && (*pCols)[ 0 ]->GetId() == 0 ) ?
394 0 : (*pCols)[ 0 ]->Width() : 0,
395 0 : (nCurRow - nTopRow) * GetDataRowHeight() + 1 ),
396 0 : Size( pDataWin->GetOutputSizePixel().Width() + 1,
397 0 : GetDataRowHeight() - 2 ) );
398 246 : if ( bHLines )
399 : {
400 246 : if ( !bMultiSelection )
401 0 : --aCursor.Top();
402 246 : --aCursor.Bottom();
403 : }
404 :
405 246 : if (m_aCursorColor == COL_TRANSPARENT)
406 : {
407 : // on these platforms, the StarView focus works correctly
408 219 : if ( bReallyHide )
409 219 : static_cast<Control*>(pDataWin)->HideFocus();
410 : else
411 0 : static_cast<Control*>(pDataWin)->ShowFocus( aCursor );
412 : }
413 : else
414 : {
415 27 : Color rCol = bReallyHide ? pDataWin->GetFillColor() : m_aCursorColor;
416 27 : Color aOldFillColor = pDataWin->GetFillColor();
417 27 : Color aOldLineColor = pDataWin->GetLineColor();
418 27 : pDataWin->SetFillColor();
419 27 : pDataWin->SetLineColor( rCol );
420 27 : pDataWin->DrawRect( aCursor );
421 27 : pDataWin->SetLineColor( aOldLineColor );
422 27 : pDataWin->SetFillColor( aOldFillColor );
423 : }
424 246 : }
425 :
426 :
427 :
428 0 : sal_uLong BrowseBox::GetColumnWidth( sal_uInt16 nId ) const
429 : {
430 :
431 0 : sal_uInt16 nItemPos = GetColumnPos( nId );
432 0 : if ( nItemPos >= pCols->size() )
433 0 : return 0;
434 0 : return (*pCols)[ nItemPos ]->Width();
435 : }
436 :
437 :
438 :
439 178 : sal_uInt16 BrowseBox::GetColumnId( sal_uInt16 nPos ) const
440 : {
441 :
442 178 : if ( nPos >= pCols->size() )
443 41 : return BROWSER_INVALIDID;
444 137 : return (*pCols)[ nPos ]->GetId();
445 : }
446 :
447 :
448 :
449 308 : sal_uInt16 BrowseBox::GetColumnPos( sal_uInt16 nId ) const
450 : {
451 :
452 1685 : for ( sal_uInt16 nPos = 0; nPos < pCols->size(); ++nPos )
453 1683 : if ( (*pCols)[ nPos ]->GetId() == nId )
454 306 : return nPos;
455 2 : return BROWSER_INVALIDID;
456 : }
457 :
458 :
459 :
460 0 : bool BrowseBox::IsFrozen( sal_uInt16 nColumnId ) const
461 : {
462 :
463 0 : for ( size_t nPos = 0; nPos < pCols->size(); ++nPos )
464 0 : if ( (*pCols)[ nPos ]->GetId() == nColumnId )
465 0 : return (*pCols)[ nPos ]->IsFrozen();
466 0 : return false;
467 : }
468 :
469 :
470 :
471 0 : void BrowseBox::ExpandRowSelection( const BrowserMouseEvent& rEvt )
472 : {
473 :
474 0 : DoHideCursor( "ExpandRowSelection" );
475 :
476 : // expand the last selection
477 0 : if ( bMultiSelection )
478 : {
479 0 : Range aJustifiedRange( aSelRange );
480 0 : aJustifiedRange.Justify();
481 :
482 0 : bool bSelectThis = ( bSelect != aJustifiedRange.IsInside( rEvt.GetRow() ) );
483 :
484 0 : if ( aJustifiedRange.IsInside( rEvt.GetRow() ) )
485 : {
486 : // down and up
487 0 : while ( rEvt.GetRow() < aSelRange.Max() )
488 : { // ZTC/Mac bug - don't put these statements together!
489 0 : SelectRow( aSelRange.Max(), bSelectThis, true );
490 0 : --aSelRange.Max();
491 : }
492 0 : while ( rEvt.GetRow() > aSelRange.Max() )
493 : { // ZTC/Mac bug - don't put these statements together!
494 0 : SelectRow( aSelRange.Max(), bSelectThis, true );
495 0 : ++aSelRange.Max();
496 : }
497 : }
498 : else
499 : {
500 : // up and down
501 0 : bool bOldSelecting = bSelecting;
502 0 : bSelecting = true;
503 0 : while ( rEvt.GetRow() < aSelRange.Max() )
504 : { // ZTC/Mac bug - don't put these statements together!
505 0 : --aSelRange.Max();
506 0 : if ( !IsRowSelected( aSelRange.Max() ) )
507 : {
508 0 : SelectRow( aSelRange.Max(), bSelectThis, true );
509 0 : bSelect = true;
510 : }
511 : }
512 0 : while ( rEvt.GetRow() > aSelRange.Max() )
513 : { // ZTC/Mac bug - don't put these statements together!
514 0 : ++aSelRange.Max();
515 0 : if ( !IsRowSelected( aSelRange.Max() ) )
516 : {
517 0 : SelectRow( aSelRange.Max(), bSelectThis, true );
518 0 : bSelect = true;
519 : }
520 : }
521 0 : bSelecting = bOldSelecting;
522 0 : if ( bSelect )
523 0 : Select();
524 : }
525 : }
526 : else
527 0 : if ( !bMultiSelection || !IsRowSelected( rEvt.GetRow() ) )
528 0 : SelectRow( rEvt.GetRow(), true );
529 :
530 0 : GoToRow( rEvt.GetRow(), false );
531 0 : DoShowCursor( "ExpandRowSelection" );
532 0 : }
533 :
534 :
535 :
536 472 : void BrowseBox::Resize()
537 : {
538 472 : if ( !bBootstrapped && IsReallyVisible() )
539 0 : BrowseBox::StateChanged( StateChangedType::INITSHOW );
540 472 : if ( pCols->empty() )
541 : {
542 0 : getDataWindow()->bResizeOnPaint = true;
543 472 : return;
544 : }
545 472 : getDataWindow()->bResizeOnPaint = false;
546 :
547 : // calc the size of the scrollbars
548 : // (we can't ask the scrollbars for their widths cause if we're zoomed they still have to be
549 : // resized - which is done in UpdateScrollbars)
550 472 : sal_uLong nSBSize = GetSettings().GetStyleSettings().GetScrollBarSize();
551 472 : if (IsZoom())
552 0 : nSBSize = (sal_uLong)(nSBSize * (double)GetZoom());
553 :
554 472 : DoHideCursor( "Resize" );
555 472 : sal_uInt16 nOldVisibleRows = 0;
556 : //fdo#42694, post #i111125# GetDataRowHeight() can be 0
557 472 : if (GetDataRowHeight())
558 472 : nOldVisibleRows = (sal_uInt16)(pDataWin->GetOutputSizePixel().Height() / GetDataRowHeight() + 1);
559 :
560 : // did we need a horizontal scroll bar or is there a Control Area?
561 944 : if ( !getDataWindow()->bNoHScroll &&
562 472 : ( ( pCols->size() - FrozenColCount() ) > 1 ) )
563 215 : aHScroll.Show();
564 : else
565 257 : aHScroll.Hide();
566 :
567 : // calculate the size of the data window
568 472 : long nDataHeight = GetOutputSizePixel().Height() - GetTitleHeight();
569 472 : if ( aHScroll.IsVisible() || ( nControlAreaWidth != USHRT_MAX ) )
570 241 : nDataHeight -= nSBSize;
571 :
572 472 : long nDataWidth = GetOutputSizePixel().Width();
573 472 : if ( pVScroll->IsVisible() )
574 70 : nDataWidth -= nSBSize;
575 :
576 : // adjust position and size of data window
577 : pDataWin->SetPosSizePixel(
578 472 : Point( 0, GetTitleHeight() ),
579 944 : Size( nDataWidth, nDataHeight ) );
580 :
581 472 : sal_uInt16 nVisibleRows = 0;
582 :
583 472 : if (GetDataRowHeight())
584 472 : nVisibleRows = (sal_uInt16)(pDataWin->GetOutputSizePixel().Height() / GetDataRowHeight() + 1);
585 :
586 : // TopRow is unchanged, but the number of visible lines has changed.
587 472 : if ( nVisibleRows != nOldVisibleRows )
588 105 : VisibleRowsChanged(nTopRow, nVisibleRows);
589 :
590 472 : UpdateScrollbars();
591 :
592 : // Control-Area
593 472 : Rectangle aInvalidArea( GetControlArea() );
594 472 : aInvalidArea.Right() = GetOutputSizePixel().Width();
595 472 : aInvalidArea.Left() = 0;
596 472 : Invalidate( aInvalidArea );
597 :
598 : // external header-bar
599 472 : HeaderBar* pHeaderBar = getDataWindow()->pHeaderBar;
600 472 : if ( pHeaderBar )
601 : {
602 : // take the handle column into account
603 472 : BrowserColumn *pFirstCol = (*pCols)[ 0 ];
604 472 : long nOfsX = pFirstCol->GetId() ? 0 : pFirstCol->Width();
605 472 : pHeaderBar->SetPosSizePixel( Point( nOfsX, 0 ), Size( GetOutputSizePixel().Width() - nOfsX, GetTitleHeight() ) );
606 : }
607 :
608 472 : AutoSizeLastColumn(); // adjust last column width
609 472 : DoShowCursor( "Resize" );
610 : }
611 :
612 :
613 :
614 82 : void BrowseBox::Paint( const Rectangle& rRect )
615 : {
616 :
617 : // initializations
618 82 : if ( !bBootstrapped && IsReallyVisible() )
619 5 : BrowseBox::StateChanged( StateChangedType::INITSHOW );
620 82 : if ( pCols->empty() )
621 82 : return;
622 :
623 82 : BrowserColumn *pFirstCol = (*pCols)[ 0 ];
624 82 : bool bHandleCol = pFirstCol && pFirstCol->GetId() == 0;
625 82 : bool bHeaderBar = getDataWindow()->pHeaderBar != NULL;
626 :
627 : // draw delimitational lines
628 82 : if ( !getDataWindow()->bNoHScroll )
629 164 : DrawLine( Point( 0, aHScroll.GetPosPixel().Y() ),
630 164 : Point( GetOutputSizePixel().Width(),
631 410 : aHScroll.GetPosPixel().Y() ) );
632 :
633 82 : if ( nTitleLines )
634 : {
635 82 : if ( !bHeaderBar )
636 0 : DrawLine( Point( 0, GetTitleHeight() - 1 ),
637 0 : Point( GetOutputSizePixel().Width(),
638 0 : GetTitleHeight() - 1 ) );
639 82 : else if ( bHandleCol )
640 82 : DrawLine( Point( 0, GetTitleHeight() - 1 ),
641 164 : Point( pFirstCol->Width(), GetTitleHeight() - 1 ) );
642 : }
643 :
644 : // Title Bar
645 : // If there is a handle column and if the header bar is available, only
646 : // take the HandleColumn into account
647 82 : if ( nTitleLines && (!bHeaderBar || bHandleCol) )
648 : {
649 : // iterate through columns to redraw
650 82 : long nX = 0;
651 : size_t nCol;
652 328 : for ( nCol = 0;
653 164 : nCol < pCols->size() && nX < rRect.Right();
654 : ++nCol )
655 : {
656 : // skip invisible columns between frozen and scrollable area
657 131 : if ( nCol < nFirstCol && !(*pCols)[ nCol ]->IsFrozen() )
658 0 : nCol = nFirstCol;
659 :
660 : // only the handle column?
661 131 : if (bHeaderBar && bHandleCol && nCol > 0)
662 49 : break;
663 :
664 82 : BrowserColumn *pCol = (*pCols)[ nCol ];
665 :
666 : // draw the column and increment position
667 82 : if ( pCol->Width() > 4 )
668 : {
669 : ButtonFrame aButtonFrame( Point( nX, 0 ),
670 112 : Size( pCol->Width()-1, GetTitleHeight()-1 ),
671 168 : pCol->Title(), false, false, !IsEnabled());
672 56 : aButtonFrame.Draw( *this );
673 56 : DrawLine( Point( nX + pCol->Width() - 1, 0 ),
674 112 : Point( nX + pCol->Width() - 1, GetTitleHeight()-1 ) );
675 : }
676 : else
677 : {
678 26 : Color aOldFillColor = GetFillColor();
679 26 : SetFillColor( Color( COL_BLACK ) );
680 26 : DrawRect( Rectangle( Point( nX, 0 ), Size( pCol->Width(), GetTitleHeight() - 1 ) ) );
681 26 : SetFillColor( aOldFillColor );
682 : }
683 :
684 : // skip column
685 82 : nX += pCol->Width();
686 : }
687 :
688 : // retouching
689 82 : if ( !bHeaderBar && nCol == pCols->size() )
690 : {
691 0 : const StyleSettings &rSettings = GetSettings().GetStyleSettings();
692 0 : Color aColFace( rSettings.GetFaceColor() );
693 0 : Color aOldFillColor = GetFillColor();
694 0 : Color aOldLineColor = GetLineColor();
695 0 : SetFillColor( aColFace );
696 0 : SetLineColor( aColFace );
697 : DrawRect( Rectangle(
698 : Point( nX, 0 ),
699 0 : Point( rRect.Right(), GetTitleHeight() - 2 ) ) );
700 0 : SetFillColor( aOldFillColor);
701 0 : SetLineColor( aOldLineColor);
702 : }
703 : }
704 : }
705 :
706 :
707 :
708 16 : void BrowseBox::PaintRow( OutputDevice&, const Rectangle& )
709 : {
710 16 : }
711 :
712 :
713 :
714 0 : void BrowseBox::Draw( OutputDevice* pDev, const Point& rPos, const Size& rSize, sal_uLong nFlags )
715 : {
716 0 : bool bDrawSelection = (nFlags & WINDOW_DRAW_NOSELECTION) == 0;
717 :
718 : // we need pixel coordinates
719 0 : Size aRealSize = pDev->LogicToPixel(rSize);
720 0 : Point aRealPos = pDev->LogicToPixel(rPos);
721 :
722 0 : if ((rSize.Width() < 3) || (rSize.Height() < 3))
723 : // we want to have two pixels frame ...
724 0 : return;
725 :
726 0 : vcl::Font aFont = GetDataWindow().GetDrawPixelFont( pDev );
727 : // the 'normal' painting uses always the data window as device to output to, so we have to calc the new font
728 : // relative to the data wins current settings
729 :
730 0 : pDev->Push();
731 0 : pDev->SetMapMode();
732 0 : pDev->SetFont( aFont );
733 :
734 : // draw a frame
735 0 : const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
736 0 : pDev->SetLineColor(rStyleSettings.GetDarkShadowColor());
737 0 : pDev->DrawLine(Point(aRealPos.X(), aRealPos.Y()),
738 0 : Point(aRealPos.X(), aRealPos.Y() + aRealSize.Height() - 1));
739 0 : pDev->DrawLine(Point(aRealPos.X(), aRealPos.Y()),
740 0 : Point(aRealPos.X() + aRealSize.Width() - 1, aRealPos.Y()));
741 0 : pDev->SetLineColor(rStyleSettings.GetShadowColor());
742 0 : pDev->DrawLine(Point(aRealPos.X() + aRealSize.Width() - 1, aRealPos.Y() + 1),
743 0 : Point(aRealPos.X() + aRealSize.Width() - 1, aRealPos.Y() + aRealSize.Height() - 1));
744 0 : pDev->DrawLine(Point(aRealPos.X() + aRealSize.Width() - 1, aRealPos.Y() + aRealSize.Height() - 1),
745 0 : Point(aRealPos.X() + 1, aRealPos.Y() + aRealSize.Height() - 1));
746 :
747 0 : HeaderBar* pBar = getDataWindow()->pHeaderBar;
748 :
749 : // we're drawing onto a foreign device, so we have to fake the DataRowHeight for the subsequent ImplPaintData
750 : // (as it is based on the settings of our data window, not the foreign device)
751 0 : if (!nDataRowHeight)
752 0 : ImpGetDataRowHeight();
753 0 : long nHeightLogic = PixelToLogic(Size(0, nDataRowHeight), MAP_10TH_MM).Height();
754 0 : long nForeignHeightPixel = pDev->LogicToPixel(Size(0, nHeightLogic), MAP_10TH_MM).Height();
755 :
756 0 : long nOriginalHeight = nDataRowHeight;
757 0 : nDataRowHeight = nForeignHeightPixel;
758 :
759 : // this counts for the column widths, too
760 : size_t nPos;
761 0 : for ( nPos = 0; nPos < pCols->size(); ++nPos )
762 : {
763 0 : BrowserColumn* pCurrent = (*pCols)[ nPos ];
764 :
765 0 : long nWidthLogic = PixelToLogic(Size(pCurrent->Width(), 0), MAP_10TH_MM).Width();
766 0 : long nForeignWidthPixel = pDev->LogicToPixel(Size(nWidthLogic, 0), MAP_10TH_MM).Width();
767 :
768 0 : pCurrent->SetWidth(nForeignWidthPixel, GetZoom());
769 0 : if ( pBar )
770 0 : pBar->SetItemSize( pCurrent->GetId(), pCurrent->Width() );
771 : }
772 :
773 : // a smaller area for the content
774 0 : ++aRealPos.X();
775 0 : ++aRealPos.Y();
776 0 : aRealSize.Width() -= 2;
777 0 : aRealSize.Height() -= 2;
778 :
779 : // let the header bar draw itself
780 0 : if ( pBar )
781 : {
782 : // the title height with respect to the font set for the given device
783 0 : long nTitleHeight = PixelToLogic(Size(0, GetTitleHeight()), MAP_10TH_MM).Height();
784 0 : nTitleHeight = pDev->LogicToPixel(Size(0, nTitleHeight), MAP_10TH_MM).Height();
785 :
786 0 : BrowserColumn* pFirstCol = !pCols->empty() ? (*pCols)[ 0 ] : NULL;
787 :
788 0 : Point aHeaderPos(pFirstCol && (pFirstCol->GetId() == 0) ? pFirstCol->Width() : 0, 0);
789 0 : Size aHeaderSize(aRealSize.Width() - aHeaderPos.X(), nTitleHeight);
790 :
791 0 : aHeaderPos += aRealPos;
792 : // do this before converting to logics !
793 :
794 : // the header's draw expects logic coordinates, again
795 0 : aHeaderPos = pDev->PixelToLogic(aHeaderPos);
796 0 : aHeaderSize = pDev->PixelToLogic(aHeaderSize);
797 :
798 0 : pBar->Draw(pDev, aHeaderPos, aHeaderSize, nFlags);
799 :
800 : // draw the "upper left cell" (the intersection between the header bar and the handle column)
801 0 : if (pFirstCol && (pFirstCol->GetId() == 0) && (pFirstCol->Width() > 4))
802 : {
803 : ButtonFrame aButtonFrame( aRealPos,
804 0 : Size( pFirstCol->Width()-1, nTitleHeight-1 ),
805 0 : pFirstCol->Title(), false, false, !IsEnabled());
806 0 : aButtonFrame.Draw( *pDev );
807 :
808 0 : pDev->Push( PushFlags::LINECOLOR );
809 0 : pDev->SetLineColor( Color( COL_BLACK ) );
810 :
811 0 : pDev->DrawLine( Point( aRealPos.X(), aRealPos.Y() + nTitleHeight-1 ),
812 0 : Point( aRealPos.X() + pFirstCol->Width() - 1, aRealPos.Y() + nTitleHeight-1 ) );
813 0 : pDev->DrawLine( Point( aRealPos.X() + pFirstCol->Width() - 1, aRealPos.Y() ),
814 0 : Point( aRealPos.X() + pFirstCol->Width() - 1, aRealPos.Y() + nTitleHeight-1 ) );
815 :
816 0 : pDev->Pop();
817 : }
818 :
819 0 : aRealPos.Y() += aHeaderSize.Height();
820 0 : aRealSize.Height() -= aHeaderSize.Height();
821 : }
822 :
823 : // draw our own content (with clipping)
824 0 : vcl::Region aRegion(Rectangle(aRealPos, aRealSize));
825 0 : pDev->SetClipRegion( pDev->PixelToLogic( aRegion ) );
826 :
827 : // do we have to paint the background
828 0 : bool bBackground = !(nFlags & WINDOW_DRAW_NOBACKGROUND) && GetDataWindow().IsControlBackground();
829 0 : if ( bBackground )
830 : {
831 0 : Rectangle aRect( aRealPos, aRealSize );
832 0 : pDev->SetFillColor( GetDataWindow().GetControlBackground() );
833 0 : pDev->DrawRect( aRect );
834 : }
835 :
836 0 : ImplPaintData( *pDev, Rectangle( aRealPos, aRealSize ), true, bDrawSelection );
837 :
838 : // restore the column widths/data row height
839 0 : nDataRowHeight = nOriginalHeight;
840 0 : for ( nPos = 0; nPos < pCols->size(); ++nPos )
841 : {
842 0 : BrowserColumn* pCurrent = (*pCols)[ nPos ];
843 :
844 0 : long nForeignWidthLogic = pDev->PixelToLogic(Size(pCurrent->Width(), 0), MAP_10TH_MM).Width();
845 0 : long nWidthPixel = LogicToPixel(Size(nForeignWidthLogic, 0), MAP_10TH_MM).Width();
846 :
847 0 : pCurrent->SetWidth(nWidthPixel, GetZoom());
848 0 : if ( pBar )
849 0 : pBar->SetItemSize( pCurrent->GetId(), pCurrent->Width() );
850 : }
851 :
852 0 : pDev->Pop();
853 : }
854 :
855 :
856 :
857 82 : void BrowseBox::ImplPaintData(OutputDevice& _rOut, const Rectangle& _rRect, bool _bForeignDevice, bool _bDrawSelections)
858 : {
859 82 : Point aOverallAreaPos = _bForeignDevice ? _rRect.TopLeft() : Point(0,0);
860 82 : Size aOverallAreaSize = _bForeignDevice ? _rRect.GetSize() : GetDataWindow().GetOutputSizePixel();
861 82 : Point aOverallAreaBRPos = _bForeignDevice ? _rRect.BottomRight() : Point( aOverallAreaSize.Width(), aOverallAreaSize.Height() );
862 :
863 82 : long nDataRowHeigt = GetDataRowHeight();
864 :
865 : // compute relative rows to redraw
866 82 : sal_uLong nRelTopRow = 0;
867 82 : sal_uLong nRelBottomRow = aOverallAreaSize.Height();
868 82 : if (!_bForeignDevice && nDataRowHeigt)
869 : {
870 82 : nRelTopRow = ((sal_uLong)_rRect.Top() / nDataRowHeigt);
871 82 : nRelBottomRow = (sal_uLong)(_rRect.Bottom()) / nDataRowHeigt;
872 : }
873 :
874 : // cache frequently used values
875 82 : Point aPos( aOverallAreaPos.X(), nRelTopRow * nDataRowHeigt + aOverallAreaPos.Y() );
876 82 : _rOut.SetLineColor( Color( COL_WHITE ) );
877 82 : const AllSettings& rAllSets = _rOut.GetSettings();
878 82 : const StyleSettings &rSettings = rAllSets.GetStyleSettings();
879 82 : const Color &rHighlightTextColor = rSettings.GetHighlightTextColor();
880 82 : const Color &rHighlightFillColor = rSettings.GetHighlightColor();
881 82 : Color aOldTextColor = _rOut.GetTextColor();
882 82 : Color aOldFillColor = _rOut.GetFillColor();
883 82 : Color aOldLineColor = _rOut.GetLineColor();
884 82 : long nHLineX = 0 == (*pCols)[ 0 ]->GetId() ? (*pCols)[ 0 ]->Width() : 0;
885 82 : nHLineX += aOverallAreaPos.X();
886 :
887 82 : Color aDelimiterLineColor( ::svtools::ColorConfig().GetColorValue( ::svtools::CALCGRID ).nColor );
888 :
889 : // redraw the invalid fields
890 114 : for ( sal_uLong nRelRow = nRelTopRow;
891 96 : nRelRow <= nRelBottomRow && (sal_uLong)nTopRow+nRelRow < (sal_uLong)nRowCount;
892 16 : ++nRelRow, aPos.Y() += nDataRowHeigt )
893 : {
894 : // get row
895 : // check valid area, to be on the safe side:
896 : DBG_ASSERT( (sal_uInt16)(nTopRow+nRelRow) < nRowCount, "BrowseBox::ImplPaintData: invalid seek" );
897 16 : if ( (nTopRow+long(nRelRow)) < 0 || (sal_uInt16)(nTopRow+nRelRow) >= nRowCount )
898 0 : continue;
899 :
900 : // prepare row
901 16 : sal_uLong nRow = nTopRow+nRelRow;
902 16 : if ( !SeekRow( nRow) ) {
903 : OSL_FAIL("BrowseBox::ImplPaintData: SeekRow failed");
904 : }
905 16 : _rOut.SetClipRegion();
906 16 : aPos.X() = aOverallAreaPos.X();
907 :
908 :
909 : // #73325# don't paint the row outside the painting rectangle (DG)
910 : // prepare auto-highlight
911 48 : Rectangle aRowRect( Point( _rRect.TopLeft().X(), aPos.Y() ),
912 64 : Size( _rRect.GetSize().Width(), nDataRowHeigt ) );
913 16 : PaintRow( _rOut, aRowRect );
914 :
915 : bool bRowSelected = _bDrawSelections
916 16 : && !bHideSelect
917 32 : && IsRowSelected( nRow );
918 16 : if ( bRowSelected )
919 : {
920 0 : _rOut.SetTextColor( rHighlightTextColor );
921 0 : _rOut.SetFillColor( rHighlightFillColor );
922 0 : _rOut.SetLineColor();
923 0 : _rOut.DrawRect( aRowRect );
924 : }
925 :
926 : // iterate through columns to redraw
927 : size_t nCol;
928 112 : for ( nCol = 0; nCol < pCols->size(); ++nCol )
929 : {
930 : // get column
931 112 : BrowserColumn *pCol = (*pCols)[ nCol ];
932 :
933 : // at end of invalid area
934 112 : if ( aPos.X() >= _rRect.Right() )
935 16 : break;
936 :
937 : // skip invisible columns between frozen and scrollable area
938 96 : if ( nCol < nFirstCol && !pCol->IsFrozen() )
939 : {
940 0 : nCol = nFirstCol;
941 0 : pCol = (nCol < pCols->size() ) ? (*pCols)[ nCol ] : NULL;
942 0 : if (!pCol)
943 : { // FS - 21.05.99 - 66325
944 : // actually this has been fixed elsewhere (in the right place),
945 : // but let's make sure...
946 : OSL_FAIL("BrowseBox::PaintData : nFirstCol is probably invalid !");
947 0 : break;
948 : }
949 : }
950 :
951 : // prepare Column-AutoHighlight
952 : bool bColAutoHighlight = _bDrawSelections
953 96 : && bColumnCursor
954 192 : && IsColumnSelected( pCol->GetId() );
955 96 : if ( bColAutoHighlight )
956 : {
957 0 : _rOut.SetClipRegion();
958 0 : _rOut.SetTextColor( rHighlightTextColor );
959 0 : _rOut.SetFillColor( rHighlightFillColor );
960 0 : _rOut.SetLineColor();
961 : Rectangle aFieldRect( aPos,
962 0 : Size( pCol->Width(), nDataRowHeigt ) );
963 0 : _rOut.DrawRect( aFieldRect );
964 : }
965 :
966 96 : if (!m_bFocusOnlyCursor && (pCol->GetId() == GetCurColumnId()) && (nRow == (sal_uLong)GetCurRow()))
967 0 : DrawCursor();
968 :
969 : // draw a single field.
970 : // else something is drawn to, e.g. handle column
971 96 : if (pCol->Width())
972 : {
973 : // clip the column's output to the field area
974 96 : if (_bForeignDevice)
975 : { // (not necessary if painting onto the data window)
976 0 : Size aFieldSize(pCol->Width(), nDataRowHeigt);
977 :
978 0 : if (aPos.X() + aFieldSize.Width() > aOverallAreaBRPos.X())
979 0 : aFieldSize.Width() = aOverallAreaBRPos.X() - aPos.X();
980 :
981 0 : if (aPos.Y() + aFieldSize.Height() > aOverallAreaBRPos.Y() + 1)
982 : {
983 : // for non-handle cols we don't clip vertically : we just don't draw the cell if the line isn't completely visible
984 0 : if (pCol->GetId() != 0)
985 0 : continue;
986 0 : aFieldSize.Height() = aOverallAreaBRPos.Y() + 1 - aPos.Y();
987 : }
988 :
989 0 : vcl::Region aClipToField(Rectangle(aPos, aFieldSize));
990 0 : _rOut.SetClipRegion(aClipToField);
991 : }
992 96 : pCol->Draw( *this, _rOut, aPos, false );
993 96 : if (_bForeignDevice)
994 0 : _rOut.SetClipRegion();
995 : }
996 :
997 : // reset Column-auto-highlight
998 96 : if ( bColAutoHighlight )
999 : {
1000 0 : _rOut.SetTextColor( aOldTextColor );
1001 0 : _rOut.SetFillColor( aOldFillColor );
1002 0 : _rOut.SetLineColor( aOldLineColor );
1003 : }
1004 :
1005 : // skip column
1006 96 : aPos.X() += pCol->Width();
1007 : }
1008 :
1009 : // reset auto-highlight
1010 16 : if ( bRowSelected )
1011 : {
1012 0 : _rOut.SetTextColor( aOldTextColor );
1013 0 : _rOut.SetFillColor( aOldFillColor );
1014 0 : _rOut.SetLineColor( aOldLineColor );
1015 : }
1016 :
1017 16 : if ( bHLines )
1018 : {
1019 : // draw horizontal delimitation lines
1020 16 : _rOut.SetClipRegion();
1021 16 : _rOut.Push( PushFlags::LINECOLOR );
1022 16 : _rOut.SetLineColor( aDelimiterLineColor );
1023 16 : long nY = aPos.Y() + nDataRowHeigt - 1;
1024 16 : if (nY <= aOverallAreaBRPos.Y())
1025 : _rOut.DrawLine( Point( nHLineX, nY ),
1026 : Point( bVLines
1027 56 : ? std::min(long(long(aPos.X()) - 1), aOverallAreaBRPos.X())
1028 0 : : aOverallAreaBRPos.X(),
1029 42 : nY ) );
1030 16 : _rOut.Pop();
1031 : }
1032 : }
1033 :
1034 82 : if (aPos.Y() > aOverallAreaBRPos.Y() + 1)
1035 2 : aPos.Y() = aOverallAreaBRPos.Y() + 1;
1036 : // needed for some of the following drawing
1037 :
1038 : // retouching
1039 82 : _rOut.SetClipRegion();
1040 82 : aOldLineColor = _rOut.GetLineColor();
1041 82 : aOldFillColor = _rOut.GetFillColor();
1042 82 : _rOut.SetFillColor( rSettings.GetFaceColor() );
1043 82 : if ( !pCols->empty() && ( (*pCols)[ 0 ]->GetId() == 0 ) && ( aPos.Y() <= _rRect.Bottom() ) )
1044 : {
1045 : // fill rectangle gray below handle column
1046 : // DG: fill it only until the end of the drawing rect and not to the end, as this may overpaint handle columns
1047 80 : _rOut.SetLineColor( Color( COL_BLACK ) );
1048 : _rOut.DrawRect( Rectangle(
1049 160 : Point( aOverallAreaPos.X() - 1, aPos.Y() - 1 ),
1050 80 : Point( aOverallAreaPos.X() + (*pCols)[ 0 ]->Width() - 1,
1051 320 : _rRect.Bottom() + 1) ) );
1052 : }
1053 82 : _rOut.SetFillColor( aOldFillColor );
1054 :
1055 : // draw vertical delimitational line between frozen and scrollable cols
1056 82 : _rOut.SetLineColor( COL_BLACK );
1057 82 : long nFrozenWidth = GetFrozenWidth()-1;
1058 164 : _rOut.DrawLine( Point( aOverallAreaPos.X() + nFrozenWidth, aPos.Y() ),
1059 82 : Point( aOverallAreaPos.X() + nFrozenWidth, bHLines
1060 82 : ? aPos.Y() - 1
1061 410 : : aOverallAreaBRPos.Y() ) );
1062 :
1063 : // draw vertical delimitational lines?
1064 82 : if ( bVLines )
1065 : {
1066 82 : _rOut.SetLineColor( aDelimiterLineColor );
1067 82 : Point aVertPos( aOverallAreaPos.X() - 1, aOverallAreaPos.Y() );
1068 82 : long nDeltaY = aOverallAreaBRPos.Y();
1069 255 : for ( size_t nCol = 0; nCol < pCols->size(); ++nCol )
1070 : {
1071 : // get column
1072 186 : BrowserColumn *pCol = (*pCols)[ nCol ];
1073 :
1074 : // skip invisible columns between frozen and scrollable area
1075 186 : if ( nCol < nFirstCol && !pCol->IsFrozen() )
1076 : {
1077 0 : nCol = nFirstCol;
1078 0 : pCol = (*pCols)[ nCol ];
1079 : }
1080 :
1081 : // skip column
1082 186 : aVertPos.X() += pCol->Width();
1083 :
1084 : // at end of invalid area
1085 : // invalid area is first reached when X > Right
1086 : // and not >=
1087 186 : if ( aVertPos.X() > _rRect.Right() )
1088 13 : break;
1089 :
1090 : // draw a single line
1091 173 : if ( pCol->GetId() != 0 )
1092 102 : _rOut.DrawLine( aVertPos, Point( aVertPos.X(),
1093 : bHLines
1094 102 : ? aPos.Y() - 1
1095 306 : : aPos.Y() + nDeltaY ) );
1096 : }
1097 : }
1098 :
1099 82 : _rOut.SetLineColor( aOldLineColor );
1100 82 : }
1101 :
1102 :
1103 :
1104 82 : void BrowseBox::PaintData( vcl::Window& rWin, const Rectangle& rRect )
1105 : {
1106 82 : if ( !bBootstrapped && IsReallyVisible() )
1107 0 : BrowseBox::StateChanged( StateChangedType::INITSHOW );
1108 :
1109 : // initializations
1110 82 : if ( !pCols || pCols->empty() || !rWin.IsUpdateMode() )
1111 82 : return;
1112 82 : if ( getDataWindow()->bResizeOnPaint )
1113 0 : Resize();
1114 : // MI: who was that? Window::Update();
1115 :
1116 82 : ImplPaintData(rWin, rRect, false, true);
1117 : }
1118 :
1119 :
1120 :
1121 951 : void BrowseBox::UpdateScrollbars()
1122 : {
1123 :
1124 951 : if ( !bBootstrapped || !IsUpdateMode() )
1125 880 : return;
1126 :
1127 : // protect against recursion
1128 511 : BrowserDataWin *pBDW = static_cast<BrowserDataWin*>( pDataWin );
1129 511 : if ( pBDW->bInUpdateScrollbars )
1130 : {
1131 0 : pBDW->bHadRecursion = true;
1132 0 : return;
1133 : }
1134 511 : pBDW->bInUpdateScrollbars = true;
1135 :
1136 : // the size of the corner window (and the width of the VSB/height of the HSB)
1137 511 : sal_uLong nCornerSize = GetSettings().GetStyleSettings().GetScrollBarSize();
1138 511 : if (IsZoom())
1139 0 : nCornerSize = (sal_uLong)(nCornerSize * (double)GetZoom());
1140 :
1141 511 : bool bNeedsVScroll = false;
1142 511 : long nMaxRows = 0;
1143 511 : if (GetDataRowHeight())
1144 : {
1145 : // needs VScroll?
1146 511 : nMaxRows = (pDataWin->GetSizePixel().Height()) / GetDataRowHeight();
1147 : bNeedsVScroll = getDataWindow()->bAutoVScroll
1148 223 : ? nTopRow || ( nRowCount > nMaxRows )
1149 734 : : !getDataWindow()->bNoVScroll;
1150 : }
1151 511 : Size aDataWinSize = pDataWin->GetSizePixel();
1152 511 : if ( !bNeedsVScroll )
1153 : {
1154 221 : if ( pVScroll->IsVisible() )
1155 : {
1156 2 : pVScroll->Hide();
1157 2 : Size aNewSize( aDataWinSize );
1158 2 : aNewSize.Width() = GetOutputSizePixel().Width();
1159 2 : aDataWinSize = aNewSize;
1160 : }
1161 : }
1162 290 : else if ( !pVScroll->IsVisible() )
1163 : {
1164 36 : Size aNewSize( aDataWinSize );
1165 36 : aNewSize.Width() = GetOutputSizePixel().Width() - nCornerSize;
1166 36 : aDataWinSize = aNewSize;
1167 : }
1168 :
1169 : // needs HScroll?
1170 511 : sal_uLong nLastCol = GetColumnAtXPosPixel( aDataWinSize.Width() - 1 );
1171 :
1172 511 : sal_uInt16 nFrozenCols = FrozenColCount();
1173 : bool bNeedsHScroll = getDataWindow()->bAutoHScroll
1174 223 : ? ( nFirstCol > nFrozenCols ) || ( nLastCol <= pCols->size() )
1175 734 : : !getDataWindow()->bNoHScroll;
1176 511 : if ( !bNeedsHScroll )
1177 : {
1178 219 : if ( aHScroll.IsVisible() )
1179 : {
1180 118 : aHScroll.Hide();
1181 : }
1182 219 : aDataWinSize.Height() = GetOutputSizePixel().Height() - GetTitleHeight();
1183 219 : if ( nControlAreaWidth != USHRT_MAX )
1184 60 : aDataWinSize.Height() -= nCornerSize;
1185 : }
1186 292 : else if ( !aHScroll.IsVisible() )
1187 : {
1188 30 : Size aNewSize( aDataWinSize );
1189 30 : aNewSize.Height() = GetOutputSizePixel().Height() - GetTitleHeight() - nCornerSize;
1190 30 : aDataWinSize = aNewSize;
1191 : }
1192 :
1193 : // adjust position and Width of horizontal scrollbar
1194 511 : sal_uLong nHScrX = nControlAreaWidth == USHRT_MAX
1195 : ? 0
1196 511 : : nControlAreaWidth;
1197 :
1198 : aHScroll.SetPosSizePixel(
1199 1022 : Point( nHScrX, GetOutputSizePixel().Height() - nCornerSize ),
1200 1533 : Size( aDataWinSize.Width() - nHScrX, nCornerSize ) );
1201 :
1202 : // total scrollable columns
1203 511 : short nScrollCols = short(pCols->size()) - (short)nFrozenCols;
1204 :
1205 : // visible columns
1206 : short nVisibleHSize = nLastCol == BROWSER_INVALIDID
1207 449 : ? (short)( pCols->size() - nFirstCol )
1208 960 : : (short)( nLastCol - nFirstCol );
1209 :
1210 511 : short nRange = std::max( nScrollCols, (short)0 );
1211 511 : aHScroll.SetVisibleSize( nVisibleHSize );
1212 511 : aHScroll.SetRange( Range( 0, nRange ));
1213 511 : if ( bNeedsHScroll && !aHScroll.IsVisible() )
1214 30 : aHScroll.Show();
1215 :
1216 : // adjust position and height of vertical scrollbar
1217 511 : pVScroll->SetPageSize( nMaxRows );
1218 :
1219 511 : if ( nTopRow > nRowCount )
1220 : {
1221 0 : nTopRow = nRowCount - 1;
1222 : OSL_FAIL("BrowseBox: nTopRow > nRowCount");
1223 : }
1224 :
1225 511 : if ( pVScroll->GetThumbPos() != nTopRow )
1226 0 : pVScroll->SetThumbPos( nTopRow );
1227 511 : long nVisibleSize = std::min( std::min( nRowCount, nMaxRows ), long(nRowCount-nTopRow) );
1228 511 : pVScroll->SetVisibleSize( nVisibleSize ? nVisibleSize : 1 );
1229 511 : pVScroll->SetRange( Range( 0, nRowCount ) );
1230 : pVScroll->SetPosSizePixel(
1231 1022 : Point( aDataWinSize.Width(), GetTitleHeight() ),
1232 1533 : Size( nCornerSize, aDataWinSize.Height()) );
1233 511 : long nLclDataRowHeight = GetDataRowHeight();
1234 511 : if ( nLclDataRowHeight > 0 && nRowCount < long( aDataWinSize.Height() / nLclDataRowHeight ) )
1235 505 : ScrollRows( -nTopRow );
1236 511 : if ( bNeedsVScroll && !pVScroll->IsVisible() )
1237 36 : pVScroll->Show();
1238 :
1239 : pDataWin->SetPosSizePixel(
1240 511 : Point( 0, GetTitleHeight() ),
1241 1022 : aDataWinSize );
1242 :
1243 : // needs corner-window?
1244 : // (do that AFTER positioning BOTH scrollbars)
1245 511 : sal_uLong nActualCorderWidth = 0;
1246 511 : if (aHScroll.IsVisible() && pVScroll && pVScroll->IsVisible() )
1247 : {
1248 : // if we have both scrollbars, the corner window fills the point of intersection of these two
1249 290 : nActualCorderWidth = nCornerSize;
1250 : }
1251 221 : else if ( !aHScroll.IsVisible() && ( nControlAreaWidth != USHRT_MAX ) )
1252 : {
1253 : // if we have no horizontal scrollbar, but a control area, we need the corner window to
1254 : // fill the space between the control are and the right border
1255 60 : nActualCorderWidth = GetOutputSizePixel().Width() - nControlAreaWidth;
1256 : }
1257 511 : if ( nActualCorderWidth )
1258 : {
1259 350 : if ( !getDataWindow()->pCornerWin )
1260 42 : getDataWindow()->pCornerWin = new ScrollBarBox( this, 0 );
1261 : getDataWindow()->pCornerWin->SetPosSizePixel(
1262 1050 : Point( GetOutputSizePixel().Width() - nActualCorderWidth, aHScroll.GetPosPixel().Y() ),
1263 1400 : Size( nActualCorderWidth, nCornerSize ) );
1264 350 : getDataWindow()->pCornerWin->Show();
1265 : }
1266 : else
1267 161 : DELETEZ( getDataWindow()->pCornerWin );
1268 :
1269 : // scroll headerbar, if necessary
1270 511 : if ( getDataWindow()->pHeaderBar )
1271 : {
1272 511 : long nWidth = 0;
1273 1932 : for ( size_t nCol = 0;
1274 966 : nCol < pCols->size() && nCol < nFirstCol;
1275 : ++nCol )
1276 : {
1277 : // not the handle column
1278 455 : if ( (*pCols)[ nCol ]->GetId() )
1279 0 : nWidth += (*pCols)[ nCol ]->Width();
1280 : }
1281 :
1282 511 : getDataWindow()->pHeaderBar->SetOffset( nWidth );
1283 : }
1284 :
1285 511 : pBDW->bInUpdateScrollbars = false;
1286 511 : if ( pBDW->bHadRecursion )
1287 : {
1288 0 : pBDW->bHadRecursion = false;
1289 0 : UpdateScrollbars();
1290 : }
1291 : }
1292 :
1293 :
1294 :
1295 86 : void BrowseBox::SetUpdateMode( bool bUpdate )
1296 : {
1297 :
1298 86 : bool bWasUpdate = IsUpdateMode();
1299 86 : if ( bWasUpdate == bUpdate )
1300 86 : return;
1301 :
1302 86 : Control::SetUpdateMode( bUpdate );
1303 : // If WB_CLIPCHILDREN is st at the BrowseBox (to minimize flicker),
1304 : // the data window is not invalidated by SetUpdateMode.
1305 86 : if( bUpdate )
1306 43 : getDataWindow()->Invalidate();
1307 86 : getDataWindow()->SetUpdateMode( bUpdate );
1308 :
1309 :
1310 86 : if ( bUpdate )
1311 : {
1312 43 : if ( bBootstrapped )
1313 : {
1314 2 : UpdateScrollbars();
1315 2 : AutoSizeLastColumn();
1316 : }
1317 43 : DoShowCursor( "SetUpdateMode" );
1318 : }
1319 : else
1320 43 : DoHideCursor( "SetUpdateMode" );
1321 : }
1322 :
1323 :
1324 :
1325 181 : bool BrowseBox::GetUpdateMode() const
1326 : {
1327 :
1328 181 : return getDataWindow()->IsUpdateMode();
1329 : }
1330 :
1331 :
1332 :
1333 82 : long BrowseBox::GetFrozenWidth() const
1334 : {
1335 :
1336 82 : long nWidth = 0;
1337 328 : for ( size_t nCol = 0;
1338 164 : nCol < pCols->size() && (*pCols)[ nCol ]->IsFrozen();
1339 : ++nCol )
1340 82 : nWidth += (*pCols)[ nCol ]->Width();
1341 82 : return nWidth;
1342 : }
1343 :
1344 :
1345 :
1346 208 : void BrowseBox::ColumnInserted( sal_uInt16 nPos )
1347 : {
1348 :
1349 208 : if ( pColSel )
1350 208 : pColSel->Insert( nPos );
1351 208 : UpdateScrollbars();
1352 208 : }
1353 :
1354 :
1355 :
1356 1308 : sal_uInt16 BrowseBox::FrozenColCount() const
1357 : {
1358 : sal_uInt16 nCol;
1359 3843 : for ( nCol = 0;
1360 2535 : nCol < pCols->size() && (*pCols)[ nCol ]->IsFrozen();
1361 : ++nCol )
1362 : /* empty loop */;
1363 1308 : return nCol;
1364 : }
1365 :
1366 :
1367 :
1368 0 : IMPL_LINK(BrowseBox,ScrollHdl,ScrollBar*,pBar)
1369 : {
1370 :
1371 0 : if ( pBar->GetDelta() == 0 )
1372 0 : return 0;
1373 :
1374 0 : if ( pBar->GetDelta() < 0 && getDataWindow()->bNoScrollBack )
1375 : {
1376 0 : UpdateScrollbars();
1377 0 : return 0;
1378 : }
1379 :
1380 0 : if ( pBar == &aHScroll )
1381 0 : ScrollColumns( aHScroll.GetDelta() );
1382 0 : if ( pBar == pVScroll )
1383 0 : ScrollRows( pVScroll->GetDelta() );
1384 :
1385 0 : return 0;
1386 : }
1387 :
1388 :
1389 :
1390 0 : IMPL_LINK_NOARG(BrowseBox, EndScrollHdl)
1391 : {
1392 :
1393 0 : if ( getDataWindow()->bNoScrollBack )
1394 : {
1395 0 : EndScroll();
1396 0 : return 0;
1397 : }
1398 :
1399 0 : return 0;
1400 : }
1401 :
1402 :
1403 :
1404 0 : IMPL_LINK( BrowseBox, StartDragHdl, HeaderBar*, pBar )
1405 : {
1406 0 : pBar->SetDragSize( pDataWin->GetOutputSizePixel().Height() );
1407 0 : return 0;
1408 : }
1409 :
1410 :
1411 : // usually only the first column was resized
1412 :
1413 0 : void BrowseBox::MouseButtonDown( const MouseEvent& rEvt )
1414 : {
1415 :
1416 0 : GrabFocus();
1417 :
1418 : // only mouse events in the title-line are supported
1419 0 : const Point &rEvtPos = rEvt.GetPosPixel();
1420 0 : if ( rEvtPos.Y() >= GetTitleHeight() )
1421 0 : return;
1422 :
1423 0 : long nX = 0;
1424 0 : long nWidth = GetOutputSizePixel().Width();
1425 0 : for ( size_t nCol = 0; nCol < pCols->size() && nX < nWidth; ++nCol )
1426 : {
1427 : // is this column visible?
1428 0 : BrowserColumn *pCol = (*pCols)[ nCol ];
1429 0 : if ( pCol->IsFrozen() || nCol >= nFirstCol )
1430 : {
1431 : // compute right end of column
1432 0 : long nR = nX + pCol->Width() - 1;
1433 :
1434 : // at the end of a column (and not handle column)?
1435 0 : if ( pCol->GetId() && std::abs( nR - rEvtPos.X() ) < 2 )
1436 : {
1437 : // start resizing the column
1438 0 : bResizing = true;
1439 0 : nResizeCol = nCol;
1440 0 : nDragX = nResizeX = rEvtPos.X();
1441 0 : SetPointer( Pointer( POINTER_HSPLIT ) );
1442 0 : CaptureMouse();
1443 : pDataWin->DrawLine( Point( nDragX, 0 ),
1444 0 : Point( nDragX, pDataWin->GetSizePixel().Height() ) );
1445 0 : nMinResizeX = nX + MIN_COLUMNWIDTH;
1446 0 : return;
1447 : }
1448 0 : else if ( nX < rEvtPos.X() && nR > rEvtPos.X() )
1449 : {
1450 : MouseButtonDown( BrowserMouseEvent(
1451 0 : this, rEvt, -1, nCol, pCol->GetId(), Rectangle() ) );
1452 0 : return;
1453 : }
1454 0 : nX = nR + 1;
1455 : }
1456 : }
1457 :
1458 : // event occurred out of data area
1459 0 : if ( rEvt.IsRight() )
1460 : pDataWin->Command(
1461 0 : CommandEvent( Point( 1, LONG_MAX ), COMMAND_CONTEXTMENU, true ) );
1462 : else
1463 0 : SetNoSelection();
1464 : }
1465 :
1466 :
1467 :
1468 0 : void BrowseBox::MouseMove( const MouseEvent& rEvt )
1469 : {
1470 : OSL_TRACE( "BrowseBox::MouseMove( MouseEvent )" );
1471 :
1472 0 : Pointer aNewPointer;
1473 :
1474 0 : sal_uInt16 nX = 0;
1475 0 : for ( size_t nCol = 0;
1476 0 : nCol < pCols->size() &&
1477 0 : ( nX + (*pCols)[ nCol ]->Width() ) < sal_uInt16(GetOutputSizePixel().Width());
1478 : ++nCol )
1479 : // is this column visible?
1480 0 : if ( (*pCols)[ nCol ]->IsFrozen() || nCol >= nFirstCol )
1481 : {
1482 : // compute right end of column
1483 0 : BrowserColumn *pCol = (*pCols)[ nCol ];
1484 0 : sal_uInt16 nR = (sal_uInt16)(nX + pCol->Width() - 1);
1485 :
1486 : // show resize-pointer?
1487 0 : if ( bResizing || ( pCol->GetId() &&
1488 0 : std::abs( ((long) nR ) - rEvt.GetPosPixel().X() ) < MIN_COLUMNWIDTH ) )
1489 : {
1490 0 : aNewPointer = Pointer( POINTER_HSPLIT );
1491 0 : if ( bResizing )
1492 : {
1493 : // delete old auxiliary line
1494 0 : pDataWin->HideTracking() ;
1495 :
1496 : // check allowed width and new delta
1497 0 : nDragX = std::max( rEvt.GetPosPixel().X(), nMinResizeX );
1498 0 : long nDeltaX = nDragX - nResizeX;
1499 0 : sal_uInt16 nId = GetColumnId(nResizeCol);
1500 0 : sal_uLong nOldWidth = GetColumnWidth(nId);
1501 0 : nDragX = QueryColumnResize( GetColumnId(nResizeCol),
1502 0 : nOldWidth + nDeltaX )
1503 0 : + nResizeX - nOldWidth;
1504 :
1505 : // draw new auxiliary line
1506 : pDataWin->ShowTracking( Rectangle( Point( nDragX, 0 ),
1507 0 : Size( 1, pDataWin->GetSizePixel().Height() ) ),
1508 0 : SHOWTRACK_SPLIT|SHOWTRACK_WINDOW );
1509 : }
1510 :
1511 : }
1512 :
1513 0 : nX = nR + 1;
1514 : }
1515 :
1516 0 : SetPointer( aNewPointer );
1517 0 : }
1518 :
1519 :
1520 :
1521 0 : void BrowseBox::MouseButtonUp( const MouseEvent & rEvt )
1522 : {
1523 :
1524 0 : if ( bResizing )
1525 : {
1526 : // delete auxiliary line
1527 0 : pDataWin->HideTracking();
1528 :
1529 : // width changed?
1530 0 : nDragX = std::max( rEvt.GetPosPixel().X(), nMinResizeX );
1531 0 : if ( (nDragX - nResizeX) != (long)(*pCols)[ nResizeCol ]->Width() )
1532 : {
1533 : // resize column
1534 0 : long nMaxX = pDataWin->GetSizePixel().Width();
1535 0 : nDragX = std::min( nDragX, nMaxX );
1536 0 : long nDeltaX = nDragX - nResizeX;
1537 0 : sal_uInt16 nId = GetColumnId(nResizeCol);
1538 0 : SetColumnWidth( GetColumnId(nResizeCol), GetColumnWidth(nId) + nDeltaX );
1539 0 : ColumnResized( nId );
1540 : }
1541 :
1542 : // end action
1543 0 : SetPointer( Pointer() );
1544 0 : ReleaseMouse();
1545 0 : bResizing = false;
1546 : }
1547 : else
1548 : MouseButtonUp( BrowserMouseEvent( static_cast<BrowserDataWin*>(pDataWin),
1549 0 : MouseEvent( Point( rEvt.GetPosPixel().X(),
1550 0 : rEvt.GetPosPixel().Y() - pDataWin->GetPosPixel().Y() ),
1551 0 : rEvt.GetClicks(), rEvt.GetMode(), rEvt.GetButtons(),
1552 0 : rEvt.GetModifier() ) ) );
1553 0 : }
1554 :
1555 :
1556 :
1557 : bool bExtendedMode = false;
1558 : bool bFieldMode = false;
1559 :
1560 0 : void BrowseBox::MouseButtonDown( const BrowserMouseEvent& rEvt )
1561 : {
1562 :
1563 0 : GrabFocus();
1564 :
1565 : // adjust selection while and after double-click
1566 0 : if ( rEvt.GetClicks() == 2 )
1567 : {
1568 0 : SetNoSelection();
1569 0 : if ( rEvt.GetRow() >= 0 )
1570 : {
1571 0 : GoToRow( rEvt.GetRow() );
1572 0 : SelectRow( rEvt.GetRow(), true, false );
1573 : }
1574 : else
1575 : {
1576 0 : if ( bColumnCursor && rEvt.GetColumn() != 0 )
1577 : {
1578 0 : if ( rEvt.GetColumn() < pCols->size() )
1579 0 : SelectColumnPos( rEvt.GetColumn(), true, false);
1580 : }
1581 : }
1582 0 : DoubleClick( rEvt );
1583 : }
1584 : // selections
1585 0 : else if ( ( rEvt.GetMode() & ( MOUSE_SELECT | MOUSE_SIMPLECLICK ) ) &&
1586 0 : ( bColumnCursor || rEvt.GetRow() >= 0 ) )
1587 : {
1588 0 : if ( rEvt.GetClicks() == 1 )
1589 : {
1590 : // initialise flags
1591 0 : bHit = false;
1592 : a1stPoint =
1593 0 : a2ndPoint = PixelToLogic( rEvt.GetPosPixel() );
1594 :
1595 : // selection out of range?
1596 0 : if ( rEvt.GetRow() >= nRowCount ||
1597 0 : rEvt.GetColumnId() == BROWSER_INVALIDID )
1598 : {
1599 0 : SetNoSelection();
1600 0 : return;
1601 : }
1602 :
1603 : // while selecting, no cursor
1604 0 : bSelecting = true;
1605 0 : DoHideCursor( "MouseButtonDown" );
1606 :
1607 : // DataRow?
1608 0 : if ( rEvt.GetRow() >= 0 )
1609 : {
1610 : // line selection?
1611 0 : if ( rEvt.GetColumnId() == HandleColumnId || !bColumnCursor )
1612 : {
1613 0 : if ( bMultiSelection )
1614 : {
1615 : // remove column-selection, if exists
1616 0 : if ( pColSel && pColSel->GetSelectCount() )
1617 : {
1618 0 : ToggleSelection();
1619 0 : if ( bMultiSelection )
1620 0 : uRow.pSel->SelectAll(false);
1621 : else
1622 0 : uRow.nSel = BROWSER_ENDOFSELECTION;
1623 0 : if ( pColSel )
1624 0 : pColSel->SelectAll(false);
1625 0 : bSelect = true;
1626 : }
1627 :
1628 : // expanding mode?
1629 0 : if ( rEvt.GetMode() & MOUSE_RANGESELECT )
1630 : {
1631 : // select the further touched rows too
1632 0 : bSelect = true;
1633 0 : ExpandRowSelection( rEvt );
1634 0 : return;
1635 : }
1636 :
1637 : // click in the selected area?
1638 0 : else if ( IsRowSelected( rEvt.GetRow() ) )
1639 : {
1640 : // wait for Drag&Drop
1641 0 : bHit = true;
1642 0 : bExtendedMode = MOUSE_MULTISELECT ==
1643 0 : ( rEvt.GetMode() & MOUSE_MULTISELECT );
1644 0 : return;
1645 : }
1646 :
1647 : // extension mode?
1648 0 : else if ( rEvt.GetMode() & MOUSE_MULTISELECT )
1649 : {
1650 : // determine the new selection range
1651 : // and selection/deselection
1652 0 : aSelRange = Range( rEvt.GetRow(), rEvt.GetRow() );
1653 : SelectRow( rEvt.GetRow(),
1654 0 : !uRow.pSel->IsSelected( rEvt.GetRow() ) );
1655 0 : bSelect = true;
1656 0 : return;
1657 : }
1658 : }
1659 :
1660 : // select directly
1661 0 : SetNoSelection();
1662 0 : GoToRow( rEvt.GetRow() );
1663 0 : SelectRow( rEvt.GetRow(), true );
1664 0 : aSelRange = Range( rEvt.GetRow(), rEvt.GetRow() );
1665 0 : bSelect = true;
1666 : }
1667 : else // Column/Field-Selection
1668 : {
1669 : // click in selected column
1670 0 : if ( IsColumnSelected( rEvt.GetColumn() ) ||
1671 0 : IsRowSelected( rEvt.GetRow() ) )
1672 : {
1673 0 : bHit = true;
1674 0 : bFieldMode = true;
1675 0 : return;
1676 : }
1677 :
1678 0 : SetNoSelection();
1679 0 : GoToRowColumnId( rEvt.GetRow(), rEvt.GetColumnId() );
1680 0 : bSelect = true;
1681 : }
1682 : }
1683 : else
1684 : {
1685 0 : if ( bMultiSelection && rEvt.GetColumnId() == HandleColumnId )
1686 : {
1687 : // toggle all-selection
1688 0 : if ( uRow.pSel->GetSelectCount() > ( GetRowCount() / 2 ) )
1689 0 : SetNoSelection();
1690 : else
1691 0 : SelectAll();
1692 : }
1693 : else
1694 0 : SelectColumnId( rEvt.GetColumnId(), true, false );
1695 : }
1696 :
1697 : // turn cursor on again, if necessary
1698 0 : bSelecting = false;
1699 0 : DoShowCursor( "MouseButtonDown" );
1700 0 : if ( bSelect )
1701 0 : Select();
1702 : }
1703 : }
1704 : }
1705 :
1706 :
1707 :
1708 0 : void BrowseBox::MouseMove( const BrowserMouseEvent& )
1709 : {
1710 0 : }
1711 :
1712 :
1713 :
1714 0 : void BrowseBox::MouseButtonUp( const BrowserMouseEvent &rEvt )
1715 : {
1716 :
1717 : // D&D was possible, but did not occur
1718 0 : if ( bHit )
1719 : {
1720 0 : aSelRange = Range( rEvt.GetRow(), rEvt.GetRow() );
1721 0 : if ( bExtendedMode )
1722 0 : SelectRow( rEvt.GetRow(), false );
1723 : else
1724 : {
1725 0 : SetNoSelection();
1726 0 : if ( bFieldMode )
1727 0 : GoToRowColumnId( rEvt.GetRow(), rEvt.GetColumnId() );
1728 : else
1729 : {
1730 0 : GoToRow( rEvt.GetRow() );
1731 0 : SelectRow( rEvt.GetRow(), true );
1732 : }
1733 : }
1734 0 : bSelect = true;
1735 0 : bExtendedMode = false;
1736 0 : bFieldMode = false;
1737 0 : bHit = false;
1738 : }
1739 :
1740 : // activate cursor
1741 0 : if ( bSelecting )
1742 : {
1743 0 : bSelecting = false;
1744 0 : DoShowCursor( "MouseButtonUp" );
1745 0 : if ( bSelect )
1746 0 : Select();
1747 : }
1748 0 : }
1749 :
1750 :
1751 :
1752 0 : void BrowseBox::KeyInput( const KeyEvent& rEvt )
1753 : {
1754 0 : if ( !ProcessKey( rEvt ) )
1755 0 : Control::KeyInput( rEvt );
1756 0 : }
1757 :
1758 :
1759 :
1760 0 : bool BrowseBox::ProcessKey( const KeyEvent& rEvt )
1761 : {
1762 :
1763 0 : sal_uInt16 nCode = rEvt.GetKeyCode().GetCode();
1764 0 : bool bShift = rEvt.GetKeyCode().IsShift();
1765 0 : bool bCtrl = rEvt.GetKeyCode().IsMod1();
1766 0 : bool bAlt = rEvt.GetKeyCode().IsMod2();
1767 :
1768 0 : sal_uInt16 nId = BROWSER_NONE;
1769 :
1770 0 : if ( !bAlt && !bCtrl && !bShift )
1771 : {
1772 0 : switch ( nCode )
1773 : {
1774 0 : case KEY_DOWN: nId = BROWSER_CURSORDOWN; break;
1775 0 : case KEY_UP: nId = BROWSER_CURSORUP; break;
1776 0 : case KEY_HOME: nId = BROWSER_CURSORHOME; break;
1777 0 : case KEY_END: nId = BROWSER_CURSOREND; break;
1778 : case KEY_TAB:
1779 0 : if ( !bColumnCursor )
1780 0 : break;
1781 0 : case KEY_RIGHT: nId = BROWSER_CURSORRIGHT; break;
1782 0 : case KEY_LEFT: nId = BROWSER_CURSORLEFT; break;
1783 0 : case KEY_SPACE: nId = BROWSER_SELECT; break;
1784 : }
1785 0 : if ( BROWSER_NONE != nId )
1786 0 : SetNoSelection();
1787 :
1788 0 : switch ( nCode )
1789 : {
1790 0 : case KEY_PAGEDOWN: nId = BROWSER_CURSORPAGEDOWN; break;
1791 0 : case KEY_PAGEUP: nId = BROWSER_CURSORPAGEUP; break;
1792 : }
1793 : }
1794 :
1795 0 : if ( !bAlt && !bCtrl && bShift )
1796 0 : switch ( nCode )
1797 : {
1798 0 : case KEY_DOWN: nId = BROWSER_SELECTDOWN; break;
1799 0 : case KEY_UP: nId = BROWSER_SELECTUP; break;
1800 : case KEY_TAB:
1801 0 : if ( !bColumnCursor )
1802 0 : break;
1803 0 : nId = BROWSER_CURSORLEFT; break;
1804 0 : case KEY_HOME: nId = BROWSER_SELECTHOME; break;
1805 0 : case KEY_END: nId = BROWSER_SELECTEND; break;
1806 : }
1807 :
1808 :
1809 0 : if ( !bAlt && bCtrl && !bShift )
1810 0 : switch ( nCode )
1811 : {
1812 0 : case KEY_DOWN: nId = BROWSER_CURSORDOWN; break;
1813 0 : case KEY_UP: nId = BROWSER_CURSORUP; break;
1814 0 : case KEY_PAGEDOWN: nId = BROWSER_CURSORENDOFFILE; break;
1815 0 : case KEY_PAGEUP: nId = BROWSER_CURSORTOPOFFILE; break;
1816 0 : case KEY_HOME: nId = BROWSER_CURSORTOPOFSCREEN; break;
1817 0 : case KEY_END: nId = BROWSER_CURSORENDOFSCREEN; break;
1818 0 : case KEY_SPACE: nId = BROWSER_ENHANCESELECTION; break;
1819 0 : case KEY_LEFT: nId = BROWSER_MOVECOLUMNLEFT; break;
1820 0 : case KEY_RIGHT: nId = BROWSER_MOVECOLUMNRIGHT; break;
1821 : }
1822 :
1823 0 : if ( nId != BROWSER_NONE )
1824 0 : Dispatch( nId );
1825 0 : return nId != BROWSER_NONE;
1826 : }
1827 :
1828 :
1829 :
1830 0 : void BrowseBox::Dispatch( sal_uInt16 nId )
1831 : {
1832 :
1833 0 : long nRowsOnPage = pDataWin->GetSizePixel().Height() / GetDataRowHeight();
1834 0 : bool bDone = false;
1835 :
1836 0 : switch ( nId )
1837 : {
1838 : case BROWSER_SELECTCOLUMN:
1839 0 : if ( ColCount() )
1840 0 : SelectColumnId( GetCurColumnId() );
1841 0 : break;
1842 :
1843 : case BROWSER_CURSORDOWN:
1844 0 : if ( ( GetCurRow() + 1 ) < nRowCount )
1845 0 : bDone = GoToRow( GetCurRow() + 1, false );
1846 0 : break;
1847 : case BROWSER_CURSORUP:
1848 0 : if ( GetCurRow() > 0 )
1849 0 : bDone = GoToRow( GetCurRow() - 1, false );
1850 0 : break;
1851 : case BROWSER_SELECTHOME:
1852 0 : if ( GetRowCount() )
1853 : {
1854 0 : DoHideCursor( "BROWSER_SELECTHOME" );
1855 0 : for ( long nRow = GetCurRow(); nRow >= 0; --nRow )
1856 0 : SelectRow( nRow );
1857 0 : GoToRow( 0, true );
1858 0 : DoShowCursor( "BROWSER_SELECTHOME" );
1859 : }
1860 0 : break;
1861 : case BROWSER_SELECTEND:
1862 0 : if ( GetRowCount() )
1863 : {
1864 0 : DoHideCursor( "BROWSER_SELECTEND" );
1865 0 : long nRows = GetRowCount();
1866 0 : for ( long nRow = GetCurRow(); nRow < nRows; ++nRow )
1867 0 : SelectRow( nRow );
1868 0 : GoToRow( GetRowCount() - 1, true );
1869 0 : DoShowCursor( "BROWSER_SELECTEND" );
1870 : }
1871 0 : break;
1872 : case BROWSER_SELECTDOWN:
1873 : {
1874 0 : if ( GetRowCount() && ( GetCurRow() + 1 ) < nRowCount )
1875 : {
1876 : // deselect the current row, if it isn't the first
1877 : // and there is no other selected row above
1878 0 : long nRow = GetCurRow();
1879 0 : bool bLocalSelect = ( !IsRowSelected( nRow ) ||
1880 0 : GetSelectRowCount() == 1 || IsRowSelected( nRow - 1 ) );
1881 0 : SelectRow( nRow, bLocalSelect, true );
1882 0 : bDone = GoToRow( GetCurRow() + 1, false );
1883 0 : if ( bDone )
1884 0 : SelectRow( GetCurRow(), true, true );
1885 : }
1886 : else
1887 0 : bDone = ScrollRows( 1 ) != 0;
1888 0 : break;
1889 : }
1890 : case BROWSER_SELECTUP:
1891 0 : if ( GetRowCount() )
1892 : {
1893 : // deselect the current row, if it isn't the first
1894 : // and there is no other selected row under
1895 0 : long nRow = GetCurRow();
1896 0 : bool bLocalSelect = ( !IsRowSelected( nRow ) ||
1897 0 : GetSelectRowCount() == 1 || IsRowSelected( nRow + 1 ) );
1898 0 : SelectRow( nCurRow, bLocalSelect, true );
1899 0 : bDone = GoToRow( nRow - 1, false );
1900 0 : if ( bDone )
1901 0 : SelectRow( GetCurRow(), true, true );
1902 : }
1903 0 : break;
1904 : case BROWSER_CURSORPAGEDOWN:
1905 0 : bDone = ScrollRows( nRowsOnPage );
1906 0 : break;
1907 : case BROWSER_CURSORPAGEUP:
1908 0 : bDone = ScrollRows( -nRowsOnPage );
1909 0 : break;
1910 : case BROWSER_CURSOREND:
1911 0 : if ( bColumnCursor )
1912 : {
1913 0 : sal_uInt16 nNewId = GetColumnId(ColCount() -1);
1914 0 : bDone = nNewId != HandleColumnId && GoToColumnId( nNewId );
1915 0 : break;
1916 : }
1917 : case BROWSER_CURSORENDOFFILE:
1918 0 : bDone = GoToRow( nRowCount - 1, false );
1919 0 : break;
1920 : case BROWSER_CURSORRIGHT:
1921 0 : if ( bColumnCursor )
1922 : {
1923 0 : sal_uInt16 nNewPos = GetColumnPos( GetCurColumnId() ) + 1;
1924 0 : sal_uInt16 nNewId = GetColumnId( nNewPos );
1925 0 : if (nNewId != BROWSER_INVALIDID) // At end of row ?
1926 0 : bDone = GoToColumnId( nNewId );
1927 : else
1928 : {
1929 0 : sal_uInt16 nColId = GetColumnId(0);
1930 0 : if ( nColId == BROWSER_INVALIDID || nColId == HandleColumnId )
1931 0 : nColId = GetColumnId(1);
1932 0 : if ( GetRowCount() )
1933 0 : bDone = ( nCurRow < GetRowCount() - 1 ) && GoToRowColumnId( nCurRow + 1, nColId );
1934 0 : else if ( ColCount() )
1935 0 : GoToColumnId( nColId );
1936 : }
1937 : }
1938 : else
1939 0 : bDone = ScrollColumns( 1 ) != 0;
1940 0 : break;
1941 : case BROWSER_CURSORHOME:
1942 0 : if ( bColumnCursor )
1943 : {
1944 0 : sal_uInt16 nNewId = GetColumnId(1);
1945 0 : bDone = (nNewId != HandleColumnId) && GoToColumnId( nNewId );
1946 0 : break;
1947 : }
1948 : case BROWSER_CURSORTOPOFFILE:
1949 0 : bDone = GoToRow( 0, false );
1950 0 : break;
1951 : case BROWSER_CURSORLEFT:
1952 0 : if ( bColumnCursor )
1953 : {
1954 0 : sal_uInt16 nNewPos = GetColumnPos( GetCurColumnId() ) - 1;
1955 0 : sal_uInt16 nNewId = GetColumnId( nNewPos );
1956 0 : if (nNewId != HandleColumnId)
1957 0 : bDone = GoToColumnId( nNewId );
1958 : else
1959 : {
1960 0 : if ( GetRowCount() )
1961 0 : bDone = (nCurRow > 0) && GoToRowColumnId(nCurRow - 1, GetColumnId(ColCount() -1));
1962 0 : else if ( ColCount() )
1963 0 : GoToColumnId( GetColumnId(ColCount() -1) );
1964 : }
1965 : }
1966 : else
1967 0 : bDone = ScrollColumns( -1 ) != 0;
1968 0 : break;
1969 : case BROWSER_ENHANCESELECTION:
1970 0 : if ( GetRowCount() )
1971 0 : SelectRow( GetCurRow(), !IsRowSelected( GetCurRow() ), true );
1972 0 : bDone = true;
1973 0 : break;
1974 : case BROWSER_SELECT:
1975 0 : if ( GetRowCount() )
1976 0 : SelectRow( GetCurRow(), !IsRowSelected( GetCurRow() ), false );
1977 0 : bDone = true;
1978 0 : break;
1979 : case BROWSER_MOVECOLUMNLEFT:
1980 : case BROWSER_MOVECOLUMNRIGHT:
1981 : { // check if column moving is allowed
1982 0 : BrowserHeader* pHeaderBar = getDataWindow()->pHeaderBar;
1983 0 : if ( pHeaderBar && pHeaderBar->IsDragable() )
1984 : {
1985 0 : sal_uInt16 nColId = GetCurColumnId();
1986 0 : bool bColumnSelected = IsColumnSelected(nColId);
1987 0 : sal_uInt16 nNewPos = GetColumnPos(nColId);
1988 0 : bool bMoveAllowed = false;
1989 0 : if ( BROWSER_MOVECOLUMNLEFT == nId && nNewPos > 1 )
1990 0 : --nNewPos,bMoveAllowed = true;
1991 0 : else if ( BROWSER_MOVECOLUMNRIGHT == nId && nNewPos < (ColCount()-1) )
1992 0 : ++nNewPos,bMoveAllowed = true;
1993 :
1994 0 : if ( bMoveAllowed )
1995 : {
1996 0 : SetColumnPos( nColId, nNewPos );
1997 0 : ColumnMoved( nColId );
1998 0 : MakeFieldVisible(GetCurRow(), nColId, true);
1999 0 : if ( bColumnSelected )
2000 0 : SelectColumnId(nColId);
2001 : }
2002 : }
2003 : }
2004 0 : break;
2005 : }
2006 :
2007 : //! return bDone;
2008 0 : }
2009 :
2010 :
2011 :
2012 82 : void BrowseBox::SetCursorColor(const Color& _rCol)
2013 : {
2014 82 : if (_rCol == m_aCursorColor)
2015 82 : return;
2016 :
2017 : // ensure the cursor is hidden
2018 82 : DoHideCursor("SetCursorColor");
2019 82 : if (!m_bFocusOnlyCursor)
2020 9 : DoHideCursor("SetCursorColor - force");
2021 :
2022 82 : m_aCursorColor = _rCol;
2023 :
2024 82 : if (!m_bFocusOnlyCursor)
2025 9 : DoShowCursor("SetCursorColor - force");
2026 82 : DoShowCursor("SetCursorColor");
2027 : }
2028 :
2029 0 : Rectangle BrowseBox::calcHeaderRect(bool _bIsColumnBar, bool _bOnScreen)
2030 : {
2031 0 : vcl::Window* pParent = NULL;
2032 0 : if ( !_bOnScreen )
2033 0 : pParent = GetAccessibleParentWindow();
2034 :
2035 0 : Point aTopLeft;
2036 : long nWidth;
2037 : long nHeight;
2038 0 : if ( _bIsColumnBar )
2039 : {
2040 0 : nWidth = GetDataWindow().GetOutputSizePixel().Width();
2041 0 : nHeight = GetDataRowHeight();
2042 : }
2043 : else
2044 : {
2045 0 : aTopLeft.Y() = GetDataRowHeight();
2046 0 : nWidth = GetColumnWidth(0);
2047 0 : nHeight = GetWindowExtentsRelative( pParent ).GetHeight() - aTopLeft.Y() - GetControlArea().GetSize().B();
2048 : }
2049 0 : aTopLeft += GetWindowExtentsRelative( pParent ).TopLeft();
2050 0 : return Rectangle(aTopLeft,Size(nWidth,nHeight));
2051 : }
2052 :
2053 0 : Rectangle BrowseBox::calcTableRect(bool _bOnScreen)
2054 : {
2055 0 : vcl::Window* pParent = NULL;
2056 0 : if ( !_bOnScreen )
2057 0 : pParent = GetAccessibleParentWindow();
2058 :
2059 0 : Rectangle aRect( GetWindowExtentsRelative( pParent ) );
2060 0 : Rectangle aRowBar = calcHeaderRect(false, pParent == NULL);
2061 :
2062 0 : long nX = aRowBar.Right() - aRect.Left();
2063 0 : long nY = aRowBar.Top() - aRect.Top();
2064 0 : Size aSize(aRect.GetSize());
2065 :
2066 0 : return Rectangle(aRowBar.TopRight(), Size(aSize.A() - nX, aSize.B() - nY - aHScroll.GetSizePixel().Height()) );
2067 : }
2068 :
2069 0 : Rectangle BrowseBox::GetFieldRectPixelAbs( sal_Int32 _nRowId, sal_uInt16 _nColId, bool /*_bIsHeader*/, bool _bOnScreen )
2070 : {
2071 0 : vcl::Window* pParent = NULL;
2072 0 : if ( !_bOnScreen )
2073 0 : pParent = GetAccessibleParentWindow();
2074 :
2075 0 : Rectangle aRect = GetFieldRectPixel(_nRowId,_nColId,_bOnScreen);
2076 :
2077 0 : Point aTopLeft = aRect.TopLeft();
2078 0 : aTopLeft += GetWindowExtentsRelative( pParent ).TopLeft();
2079 :
2080 0 : return Rectangle(aTopLeft,aRect.GetSize());
2081 1227 : }
2082 :
2083 : // ------------------------------------------------------------------------- EOF
2084 :
2085 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
