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