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/list.hxx> 27 #include <tools/debug.hxx> 28 #include <vcl/decoview.hxx> 29 #include <vcl/svapp.hxx> 30 #ifndef _SCRBAR_HXX 31 #include <vcl/scrbar.hxx> 32 #endif 33 #ifndef _HELP_HXX 34 #include <vcl/help.hxx> 35 #endif 36 #include <com/sun/star/accessibility/AccessibleEventObject.hpp> 37 #include <com/sun/star/accessibility/AccessibleEventId.hpp> 38 #include <com/sun/star/accessibility/AccessibleStateType.hpp> 39 #include <com/sun/star/lang/XComponent.hpp> 40 #include <rtl/ustring.hxx> 41 #include "valueimp.hxx" 42 43 #define _SV_VALUESET_CXX 44 #include <svtools/valueset.hxx> 45 46 // ------------ 47 // - ValueSet - 48 // ------------ 49 50 void ValueSet::ImplInit() 51 { 52 // Size aWinSize = GetSizePixel(); 53 mpImpl = new ValueSet_Impl; 54 mpNoneItem = NULL; 55 mpScrBar = NULL; 56 mnTextOffset = 0; 57 mnVisLines = 0; 58 mnLines = 0; 59 mnUserItemWidth = 0; 60 mnUserItemHeight = 0; 61 mnFirstLine = 0; 62 mnOldItemId = 0; 63 mnSelItemId = 0; 64 mnHighItemId = 0; 65 mnDropPos = VALUESET_ITEM_NOTFOUND; 66 mnCols = 0; 67 mnCurCol = 0; 68 mnUserCols = 0; 69 mnUserVisLines = 0; 70 mnSpacing = 0; 71 mnFrameStyle = 0; 72 mbFormat = true; 73 mbHighlight = false; 74 mbSelection = false; 75 mbNoSelection = true; 76 mbDrawSelection = true; 77 mbBlackSel = false; 78 mbDoubleSel = false; 79 mbScroll = false; 80 mbDropPos = false; 81 mbFullMode = true; 82 mbEdgeBlending = false; 83 84 // #106446#, #106601# force mirroring of virtual device 85 maVirDev.EnableRTL( GetParent()->IsRTLEnabled() ); 86 87 ImplInitSettings( sal_True, sal_True, sal_True ); 88 } 89 90 // ----------------------------------------------------------------------- 91 92 ValueSet::ValueSet( Window* pParent, WinBits nWinStyle, bool bDisableTransientChildren ) : 93 Control( pParent, nWinStyle ), 94 maVirDev( *this ), 95 maColor( COL_TRANSPARENT ) 96 { 97 ImplInit(); 98 if( mpImpl ) 99 mpImpl->mbIsTransientChildrenDisabled = bDisableTransientChildren; 100 } 101 102 // ----------------------------------------------------------------------- 103 104 ValueSet::ValueSet( Window* pParent, const ResId& rResId, bool bDisableTransientChildren ) : 105 Control( pParent, rResId ), 106 maVirDev( *this ), 107 maColor( COL_TRANSPARENT ) 108 { 109 ImplInit(); 110 if( mpImpl ) 111 mpImpl->mbIsTransientChildrenDisabled = bDisableTransientChildren; 112 } 113 114 // ----------------------------------------------------------------------- 115 116 ValueSet::~ValueSet() 117 { 118 ::com::sun::star::uno::Reference< ::com::sun::star::lang::XComponent> 119 xComponent (GetAccessible(sal_False), ::com::sun::star::uno::UNO_QUERY); 120 if (xComponent.is()) 121 xComponent->dispose (); 122 123 if ( mpScrBar ) 124 delete mpScrBar; 125 126 if ( mpNoneItem ) 127 delete mpNoneItem; 128 129 ImplDeleteItems(); 130 delete mpImpl; 131 } 132 133 // ----------------------------------------------------------------------- 134 135 void ValueSet::ImplDeleteItems() 136 { 137 for( ValueSetItem* pItem = mpImpl->mpItemList->First(); pItem; pItem = mpImpl->mpItemList->Next() ) 138 { 139 if( !pItem->maRect.IsEmpty() && ImplHasAccessibleListeners() ) 140 { 141 ::com::sun::star::uno::Any aOldAny, aNewAny; 142 143 aOldAny <<= pItem->GetAccessible( mpImpl->mbIsTransientChildrenDisabled ); 144 ImplFireAccessibleEvent( ::com::sun::star::accessibility::AccessibleEventId::CHILD, aOldAny, aNewAny ); 145 } 146 147 delete pItem; 148 } 149 150 mpImpl->mpItemList->Clear(); 151 } 152 153 // ----------------------------------------------------------------------- 154 155 void ValueSet::ImplInitSettings( sal_Bool bFont, sal_Bool bForeground, sal_Bool bBackground ) 156 { 157 const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings(); 158 159 if ( bFont ) 160 { 161 Font aFont; 162 aFont = rStyleSettings.GetAppFont(); 163 if ( IsControlFont() ) 164 aFont.Merge( GetControlFont() ); 165 SetZoomedPointFont( aFont ); 166 } 167 168 if ( bForeground || bFont ) 169 { 170 Color aColor; 171 if ( IsControlForeground() ) 172 aColor = GetControlForeground(); 173 else 174 aColor = rStyleSettings.GetButtonTextColor(); 175 SetTextColor( aColor ); 176 SetTextFillColor(); 177 } 178 179 if ( bBackground ) 180 { 181 Color aColor; 182 if ( IsControlBackground() ) 183 aColor = GetControlBackground(); 184 else if ( GetStyle() & WB_MENUSTYLEVALUESET ) 185 aColor = rStyleSettings.GetMenuColor(); 186 else if ( IsEnabled() && (GetStyle() & WB_FLATVALUESET) ) 187 aColor = rStyleSettings.GetWindowColor(); 188 else 189 aColor = rStyleSettings.GetFaceColor(); 190 SetBackground( aColor ); 191 } 192 } 193 194 // ----------------------------------------------------------------------- 195 196 void ValueSet::ImplInitScrollBar() 197 { 198 if ( GetStyle() & WB_VSCROLL ) 199 { 200 if ( !mpScrBar ) 201 { 202 mpScrBar = new ScrollBar( this, WB_VSCROLL | WB_DRAG ); 203 mpScrBar->SetScrollHdl( LINK( this, ValueSet, ImplScrollHdl ) ); 204 } 205 else 206 { 207 // Wegen Einstellungsaenderungen passen wir hier die Breite an 208 long nScrBarWidth = GetSettings().GetStyleSettings().GetScrollBarSize(); 209 mpScrBar->SetPosSizePixel( 0, 0, nScrBarWidth, 0, WINDOW_POSSIZE_WIDTH ); 210 } 211 } 212 } 213 214 // ----------------------------------------------------------------------- 215 216 void ValueSet::ImplFormatItem( ValueSetItem* pItem ) 217 { 218 if ( pItem->meType == VALUESETITEM_SPACE ) 219 return; 220 221 Rectangle aRect = pItem->maRect; 222 WinBits nStyle = GetStyle(); 223 if ( nStyle & WB_ITEMBORDER ) 224 { 225 aRect.Left()++; 226 aRect.Top()++; 227 aRect.Right()--; 228 aRect.Bottom()--; 229 if ( nStyle & WB_FLATVALUESET ) 230 { 231 if ( nStyle & WB_DOUBLEBORDER ) 232 { 233 aRect.Left() += 2; 234 aRect.Top() += 2; 235 aRect.Right() -= 2; 236 aRect.Bottom() -= 2; 237 } 238 else 239 { 240 aRect.Left()++; 241 aRect.Top()++; 242 aRect.Right()--; 243 aRect.Bottom()--; 244 } 245 } 246 else 247 { 248 DecorationView aView( &maVirDev ); 249 aRect = aView.DrawFrame( aRect, mnFrameStyle ); 250 } 251 } 252 253 if ( pItem == mpNoneItem ) 254 pItem->maText = GetText(); 255 256 if ( (aRect.GetHeight() > 0) && (aRect.GetWidth() > 0) ) 257 { 258 const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings(); 259 260 if ( pItem == mpNoneItem ) 261 { 262 maVirDev.SetFont( GetFont() ); 263 maVirDev.SetTextColor( ( nStyle & WB_MENUSTYLEVALUESET ) ? rStyleSettings.GetMenuTextColor() : rStyleSettings.GetWindowTextColor() ); 264 maVirDev.SetTextFillColor(); 265 maVirDev.SetFillColor( ( nStyle & WB_MENUSTYLEVALUESET ) ? rStyleSettings.GetMenuColor() : rStyleSettings.GetWindowColor() ); 266 maVirDev.DrawRect( aRect ); 267 Point aTxtPos( aRect.Left()+2, aRect.Top() ); 268 long nTxtWidth = GetTextWidth( pItem->maText ); 269 if ( nStyle & WB_RADIOSEL ) 270 { 271 aTxtPos.X() += 4; 272 aTxtPos.Y() += 4; 273 } 274 if ( (aTxtPos.X()+nTxtWidth) > aRect.Right() ) 275 { 276 maVirDev.SetClipRegion( Region( aRect ) ); 277 maVirDev.DrawText( aTxtPos, pItem->maText ); 278 maVirDev.SetClipRegion(); 279 } 280 else 281 maVirDev.DrawText( aTxtPos, pItem->maText ); 282 } 283 else if ( pItem->meType == VALUESETITEM_COLOR ) 284 { 285 maVirDev.SetFillColor( pItem->maColor ); 286 maVirDev.DrawRect( aRect ); 287 } 288 else 289 { 290 if ( IsColor() ) 291 maVirDev.SetFillColor( maColor ); 292 else if ( nStyle & WB_MENUSTYLEVALUESET ) 293 maVirDev.SetFillColor( rStyleSettings.GetMenuColor() ); 294 else if ( IsEnabled() ) 295 maVirDev.SetFillColor( rStyleSettings.GetWindowColor() ); 296 else 297 maVirDev.SetFillColor( rStyleSettings.GetFaceColor() ); 298 maVirDev.DrawRect( aRect ); 299 300 if ( pItem->meType == VALUESETITEM_USERDRAW ) 301 { 302 UserDrawEvent aUDEvt( &maVirDev, aRect, pItem->mnId ); 303 UserDraw( aUDEvt ); 304 } 305 else 306 { 307 Size aImageSize = pItem->maImage.GetSizePixel(); 308 Size aRectSize = aRect.GetSize(); 309 Point aPos( aRect.Left(), aRect.Top() ); 310 aPos.X() += (aRectSize.Width()-aImageSize.Width())/2; 311 aPos.Y() += (aRectSize.Height()-aImageSize.Height())/2; 312 313 sal_uInt16 nImageStyle = 0; 314 if( !IsEnabled() ) 315 nImageStyle |= IMAGE_DRAW_DISABLE; 316 317 if ( (aImageSize.Width() > aRectSize.Width()) || 318 (aImageSize.Height() > aRectSize.Height()) ) 319 { 320 maVirDev.SetClipRegion( Region( aRect ) ); 321 maVirDev.DrawImage( aPos, pItem->maImage, nImageStyle); 322 maVirDev.SetClipRegion(); 323 } 324 else 325 maVirDev.DrawImage( aPos, pItem->maImage, nImageStyle ); 326 } 327 } 328 329 const sal_uInt16 nEdgeBlendingPercent(GetEdgeBlending() ? rStyleSettings.GetEdgeBlending() : 0); 330 331 if(nEdgeBlendingPercent) 332 { 333 const Color& rTopLeft(rStyleSettings.GetEdgeBlendingTopLeftColor()); 334 const Color& rBottomRight(rStyleSettings.GetEdgeBlendingBottomRightColor()); 335 const sal_uInt8 nAlpha((nEdgeBlendingPercent * 255) / 100); 336 const BitmapEx aBlendFrame(createBlendFrame(aRect.GetSize(), nAlpha, rTopLeft, rBottomRight)); 337 338 if(!aBlendFrame.IsEmpty()) 339 { 340 maVirDev.DrawBitmapEx(aRect.TopLeft(), aBlendFrame); 341 } 342 } 343 } 344 } 345 346 // ----------------------------------------------------------------------- 347 348 ::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessible > ValueSet::CreateAccessible() 349 { 350 return new ValueSetAcc( this, mpImpl->mbIsTransientChildrenDisabled ); 351 } 352 353 // ----------------------------------------------------------------------- 354 355 void ValueSet::Format() 356 { 357 Size aWinSize = GetOutputSizePixel(); 358 sal_uLong nItemCount = mpImpl->mpItemList->Count(); 359 WinBits nStyle = GetStyle(); 360 long nTxtHeight = GetTextHeight(); 361 long nOff; 362 long nSpace; 363 long nNoneHeight; 364 long nNoneSpace; 365 ScrollBar* pDelScrBar = NULL; 366 367 // Scrolling beruecksichtigen 368 if ( nStyle & WB_VSCROLL ) 369 ImplInitScrollBar(); 370 else 371 { 372 if ( mpScrBar ) 373 { 374 // ScrollBar erst spaeter zerstoeren, damit keine rekursiven 375 // Aufrufe entstehen koennen 376 pDelScrBar = mpScrBar; 377 mpScrBar = NULL; 378 } 379 } 380 381 // Item-Offset berechnen 382 if ( nStyle & WB_ITEMBORDER ) 383 { 384 if ( nStyle & WB_DOUBLEBORDER ) 385 nOff = ITEM_OFFSET_DOUBLE; 386 else 387 nOff = ITEM_OFFSET; 388 } 389 else 390 nOff = 0; 391 nSpace = mnSpacing; 392 393 // Groesse beruecksichtigen, wenn NameField vorhanden 394 if ( nStyle & WB_NAMEFIELD ) 395 { 396 mnTextOffset = aWinSize.Height()-nTxtHeight-NAME_OFFSET; 397 aWinSize.Height() -= nTxtHeight+NAME_OFFSET; 398 399 if ( !(nStyle & WB_FLATVALUESET) ) 400 { 401 mnTextOffset -= NAME_LINE_HEIGHT+NAME_LINE_OFF_Y; 402 aWinSize.Height() -= NAME_LINE_HEIGHT+NAME_LINE_OFF_Y; 403 } 404 } 405 else 406 mnTextOffset = 0; 407 408 // Offset und Groesse beruecksichtigen, wenn NoneField vorhanden 409 if ( nStyle & WB_NONEFIELD ) 410 { 411 nNoneHeight = nTxtHeight+nOff; 412 nNoneSpace = nSpace; 413 if ( nStyle & WB_RADIOSEL ) 414 nNoneHeight += 8; 415 } 416 else 417 { 418 nNoneHeight = 0; 419 nNoneSpace = 0; 420 421 if ( mpNoneItem ) 422 { 423 delete mpNoneItem; 424 mpNoneItem = NULL; 425 } 426 } 427 428 // Breite vom ScrollBar berechnen 429 long nScrBarWidth = 0; 430 if ( mpScrBar ) 431 nScrBarWidth = mpScrBar->GetSizePixel().Width()+SCRBAR_OFFSET; 432 433 // Spaltenanzahl berechnen 434 if ( !mnUserCols ) 435 { 436 if ( mnUserItemWidth ) 437 { 438 mnCols = (sal_uInt16)((aWinSize.Width()-nScrBarWidth+nSpace) / (mnUserItemWidth+nSpace)); 439 if ( !mnCols ) 440 mnCols = 1; 441 } 442 else 443 mnCols = 1; 444 } 445 else 446 mnCols = mnUserCols; 447 448 // Zeilenanzahl berechnen 449 mbScroll = false; 450 mnLines = (long)mpImpl->mpItemList->Count() / mnCols; 451 if ( mpImpl->mpItemList->Count() % mnCols ) 452 mnLines++; 453 else if ( !mnLines ) 454 mnLines = 1; 455 456 long nCalcHeight = aWinSize.Height()-nNoneHeight; 457 if ( mnUserVisLines ) 458 mnVisLines = mnUserVisLines; 459 else if ( mnUserItemHeight ) 460 { 461 mnVisLines = (nCalcHeight-nNoneSpace+nSpace) / (mnUserItemHeight+nSpace); 462 if ( !mnVisLines ) 463 mnVisLines = 1; 464 } 465 else 466 mnVisLines = mnLines; 467 if ( mnLines > mnVisLines ) 468 mbScroll = true; 469 if ( mnLines <= mnVisLines ) 470 mnFirstLine = 0; 471 else 472 { 473 if ( mnFirstLine > (sal_uInt16)(mnLines-mnVisLines) ) 474 mnFirstLine = (sal_uInt16)(mnLines-mnVisLines); 475 } 476 477 // Itemgroessen berechnen 478 long nColSpace = (mnCols-1)*nSpace; 479 long nLineSpace = ((mnVisLines-1)*nSpace)+nNoneSpace; 480 long nItemWidth; 481 long nItemHeight; 482 if ( mnUserItemWidth && !mnUserCols ) 483 { 484 nItemWidth = mnUserItemWidth; 485 if ( nItemWidth > aWinSize.Width()-nScrBarWidth-nColSpace ) 486 nItemWidth = aWinSize.Width()-nScrBarWidth-nColSpace; 487 } 488 else 489 nItemWidth = (aWinSize.Width()-nScrBarWidth-nColSpace) / mnCols; 490 if ( mnUserItemHeight && !mnUserVisLines ) 491 { 492 nItemHeight = mnUserItemHeight; 493 if ( nItemHeight > nCalcHeight-nNoneSpace ) 494 nItemHeight = nCalcHeight-nNoneSpace; 495 } 496 else 497 { 498 nCalcHeight -= nLineSpace; 499 nItemHeight = nCalcHeight / mnVisLines; 500 } 501 502 // Init VirDev 503 maVirDev.SetSettings( GetSettings() ); 504 maVirDev.SetBackground( GetBackground() ); 505 maVirDev.SetOutputSizePixel( aWinSize, sal_True ); 506 507 // Bei zu kleinen Items machen wir nichts 508 long nMinHeight = 2; 509 if ( nStyle & WB_ITEMBORDER ) 510 nMinHeight = 4; 511 if ( (nItemWidth <= 0) || (nItemHeight <= nMinHeight) || !nItemCount ) 512 { 513 if ( nStyle & WB_NONEFIELD ) 514 { 515 if ( mpNoneItem ) 516 { 517 mpNoneItem->maRect.SetEmpty(); 518 mpNoneItem->maText = GetText(); 519 } 520 } 521 522 for ( sal_uLong i = 0; i < nItemCount; i++ ) 523 { 524 ValueSetItem* pItem = mpImpl->mpItemList->GetObject( i ); 525 pItem->maRect.SetEmpty(); 526 } 527 528 if ( mpScrBar ) 529 mpScrBar->Hide(); 530 } 531 else 532 { 533 // Frame-Style ermitteln 534 if ( nStyle & WB_DOUBLEBORDER ) 535 mnFrameStyle = FRAME_DRAW_DOUBLEIN; 536 else 537 mnFrameStyle = FRAME_DRAW_IN; 538 539 // Selektionsfarben und -breiten ermitteln 540 // Gegebenenfalls die Farben anpassen, damit man die Selektion besser 541 // erkennen kann 542 const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings(); 543 Color aHighColor( rStyleSettings.GetHighlightColor() ); 544 if ( ((aHighColor.GetRed() > 0x80) || (aHighColor.GetGreen() > 0x80) || 545 (aHighColor.GetBlue() > 0x80)) || 546 ((aHighColor.GetRed() == 0x80) && (aHighColor.GetGreen() == 0x80) && 547 (aHighColor.GetBlue() == 0x80)) ) 548 mbBlackSel = true; 549 else 550 mbBlackSel = false; 551 552 // Wenn die Items groesser sind, dann die Selektion doppelt so breit 553 // zeichnen 554 if ( (nStyle & WB_DOUBLEBORDER) && 555 ((nItemWidth >= 25) && (nItemHeight >= 20)) ) 556 mbDoubleSel = true; 557 else 558 mbDoubleSel = false; 559 560 // Calculate offsets 561 long nStartX; 562 long nStartY; 563 if ( mbFullMode ) 564 { 565 long nAllItemWidth = (nItemWidth*mnCols)+nColSpace; 566 long nAllItemHeight = (nItemHeight*mnVisLines)+nNoneHeight+nLineSpace; 567 nStartX = (aWinSize.Width()-nScrBarWidth-nAllItemWidth)/2; 568 nStartY = (aWinSize.Height()-nAllItemHeight)/2; 569 } 570 else 571 { 572 nStartX = 0; 573 nStartY = 0; 574 } 575 576 // Items berechnen und zeichnen 577 maVirDev.SetLineColor(); 578 long x = nStartX; 579 long y = nStartY; 580 581 // NoSelection-Field erzeugen und anzeigen 582 if ( nStyle & WB_NONEFIELD ) 583 { 584 if ( !mpNoneItem ) 585 mpNoneItem = new ValueSetItem( *this ); 586 587 mpNoneItem->mnId = 0; 588 mpNoneItem->meType = VALUESETITEM_NONE; 589 mpNoneItem->maRect.Left() = x; 590 mpNoneItem->maRect.Top() = y; 591 mpNoneItem->maRect.Right() = mpNoneItem->maRect.Left()+aWinSize.Width()-x-1; 592 mpNoneItem->maRect.Bottom() = y+nNoneHeight-1; 593 594 ImplFormatItem( mpNoneItem ); 595 596 y += nNoneHeight+nNoneSpace; 597 } 598 599 // draw items 600 sal_uLong nFirstItem = mnFirstLine * mnCols; 601 sal_uLong nLastItem = nFirstItem + (mnVisLines * mnCols); 602 603 if ( !mbFullMode ) 604 { 605 // If want also draw parts of items in the last line, 606 // then we add one more line if parts of these line are 607 // visible 608 if ( y+(mnVisLines*(nItemHeight+nSpace)) < aWinSize.Height() ) 609 nLastItem += mnCols; 610 } 611 for ( sal_uLong i = 0; i < nItemCount; i++ ) 612 { 613 ValueSetItem* pItem = mpImpl->mpItemList->GetObject( i ); 614 615 if ( (i >= nFirstItem) && (i < nLastItem) ) 616 { 617 const sal_Bool bWasEmpty = pItem->maRect.IsEmpty(); 618 619 pItem->maRect.Left() = x; 620 pItem->maRect.Top() = y; 621 pItem->maRect.Right() = pItem->maRect.Left()+nItemWidth-1; 622 pItem->maRect.Bottom() = pItem->maRect.Top()+nItemHeight-1; 623 624 if( bWasEmpty && ImplHasAccessibleListeners() ) 625 { 626 ::com::sun::star::uno::Any aOldAny, aNewAny; 627 628 aNewAny <<= pItem->GetAccessible( mpImpl->mbIsTransientChildrenDisabled ); 629 ImplFireAccessibleEvent( ::com::sun::star::accessibility::AccessibleEventId::CHILD, aOldAny, aNewAny ); 630 } 631 632 ImplFormatItem( pItem ); 633 634 if ( !((i+1) % mnCols) ) 635 { 636 x = nStartX; 637 y += nItemHeight+nSpace; 638 } 639 else 640 x += nItemWidth+nSpace; 641 } 642 else 643 { 644 if( !pItem->maRect.IsEmpty() && ImplHasAccessibleListeners() ) 645 { 646 ::com::sun::star::uno::Any aOldAny, aNewAny; 647 648 aOldAny <<= pItem->GetAccessible( mpImpl->mbIsTransientChildrenDisabled ); 649 ImplFireAccessibleEvent( ::com::sun::star::accessibility::AccessibleEventId::CHILD, aOldAny, aNewAny ); 650 } 651 652 pItem->maRect.SetEmpty(); 653 } 654 } 655 656 // ScrollBar anordnen, Werte setzen und anzeigen 657 if ( mpScrBar ) 658 { 659 Point aPos( aWinSize.Width()-nScrBarWidth+SCRBAR_OFFSET, 0 ); 660 Size aSize( nScrBarWidth-SCRBAR_OFFSET, aWinSize.Height() ); 661 // If a none field is visible, then we center the scrollbar 662 if ( nStyle & WB_NONEFIELD ) 663 { 664 aPos.Y() = nStartY+nNoneHeight+1; 665 aSize.Height() = ((nItemHeight+nSpace)*mnVisLines)-2-nSpace; 666 } 667 mpScrBar->SetPosSizePixel( aPos, aSize ); 668 mpScrBar->SetRangeMax( mnLines ); 669 mpScrBar->SetVisibleSize( mnVisLines ); 670 mpScrBar->SetThumbPos( (long)mnFirstLine ); 671 long nPageSize = mnVisLines; 672 if ( nPageSize < 1 ) 673 nPageSize = 1; 674 mpScrBar->SetPageSize( nPageSize ); 675 mpScrBar->Show(); 676 } 677 } 678 679 // Jetzt haben wir formatiert und warten auf das naechste 680 mbFormat = false; 681 682 // ScrollBar loeschen 683 if ( pDelScrBar ) 684 delete pDelScrBar; 685 } 686 687 // ----------------------------------------------------------------------- 688 689 void ValueSet::ImplDrawItemText( const XubString& rText ) 690 { 691 if ( !(GetStyle() & WB_NAMEFIELD) ) 692 return; 693 694 Size aWinSize = GetOutputSizePixel(); 695 long nTxtWidth = GetTextWidth( rText ); 696 long nTxtOffset = mnTextOffset; 697 698 // Rechteck loeschen und Text ausgeben 699 if ( GetStyle() & WB_FLATVALUESET ) 700 { 701 const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings(); 702 SetLineColor(); 703 SetFillColor( rStyleSettings.GetFaceColor() ); 704 DrawRect( Rectangle( Point( 0, nTxtOffset ), Point( aWinSize.Width(), aWinSize.Height() ) ) ); 705 SetTextColor( rStyleSettings.GetButtonTextColor() ); 706 } 707 else 708 { 709 nTxtOffset += NAME_LINE_HEIGHT+NAME_LINE_OFF_Y; 710 Erase( Rectangle( Point( 0, nTxtOffset ), Point( aWinSize.Width(), aWinSize.Height() ) ) ); 711 } 712 DrawText( Point( (aWinSize.Width()-nTxtWidth) / 2, nTxtOffset+(NAME_OFFSET/2) ), rText ); 713 } 714 715 // ----------------------------------------------------------------------- 716 717 void ValueSet::ImplDrawSelect() 718 { 719 if ( !IsReallyVisible() ) 720 return; 721 722 sal_Bool bFocus = HasFocus(); 723 sal_Bool bDrawSel; 724 725 if ( (mbNoSelection && !mbHighlight) || (!mbDrawSelection && mbHighlight) ) 726 bDrawSel = sal_False; 727 else 728 bDrawSel = sal_True; 729 730 if ( !bFocus && 731 ((mbNoSelection && !mbHighlight) || (!mbDrawSelection && mbHighlight)) ) 732 { 733 XubString aEmptyStr; 734 ImplDrawItemText( aEmptyStr ); 735 return; 736 } 737 738 sal_uInt16 nItemId = mnSelItemId; 739 740 for( int stage = 0; stage < 2; stage++ ) 741 { 742 if( stage == 1 ) 743 { 744 if ( mbHighlight ) 745 nItemId = mnHighItemId; 746 else 747 break; 748 } 749 750 ValueSetItem* pItem; 751 if ( nItemId ) 752 pItem = mpImpl->mpItemList->GetObject( GetItemPos( nItemId ) ); 753 else 754 { 755 if ( mpNoneItem ) 756 pItem = mpNoneItem; 757 else 758 { 759 pItem = ImplGetFirstItem(); 760 if ( !bFocus || !pItem ) 761 continue; 762 } 763 } 764 765 if ( pItem->maRect.IsEmpty() ) 766 continue; 767 768 // Selection malen 769 const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings(); 770 Rectangle aRect = pItem->maRect; 771 Control::SetFillColor(); 772 773 Color aDoubleColor( rStyleSettings.GetHighlightColor() ); 774 Color aSingleColor( rStyleSettings.GetHighlightTextColor() ); 775 if( ! mbDoubleSel ) 776 { 777 /* 778 * #99777# contrast enhancement for thin mode 779 */ 780 const Wallpaper& rWall = GetDisplayBackground(); 781 if( ! rWall.IsBitmap() && ! rWall.IsGradient() ) 782 { 783 const Color& rBack = rWall.GetColor(); 784 if( rBack.IsDark() && ! aDoubleColor.IsBright() ) 785 { 786 aDoubleColor = Color( COL_WHITE ); 787 aSingleColor = Color( COL_BLACK ); 788 } 789 else if( rBack.IsBright() && ! aDoubleColor.IsDark() ) 790 { 791 aDoubleColor = Color( COL_BLACK ); 792 aSingleColor = Color( COL_WHITE ); 793 } 794 } 795 } 796 797 // Selectionsausgabe festlegen 798 WinBits nStyle = GetStyle(); 799 if ( nStyle & WB_MENUSTYLEVALUESET ) 800 { 801 if ( bFocus ) 802 ShowFocus( aRect ); 803 804 if ( bDrawSel ) 805 { 806 if ( mbBlackSel ) 807 SetLineColor( Color( COL_BLACK ) ); 808 else 809 SetLineColor( aDoubleColor ); 810 DrawRect( aRect ); 811 } 812 } 813 else if ( nStyle & WB_RADIOSEL ) 814 { 815 aRect.Left() += 3; 816 aRect.Top() += 3; 817 aRect.Right() -= 3; 818 aRect.Bottom() -= 3; 819 if ( nStyle & WB_DOUBLEBORDER ) 820 { 821 aRect.Left()++; 822 aRect.Top()++; 823 aRect.Right()--; 824 aRect.Bottom()--; 825 } 826 827 if ( bFocus ) 828 ShowFocus( aRect ); 829 830 aRect.Left()++; 831 aRect.Top()++; 832 aRect.Right()--; 833 aRect.Bottom()--; 834 835 if ( bDrawSel ) 836 { 837 SetLineColor( aDoubleColor ); 838 aRect.Left()++; 839 aRect.Top()++; 840 aRect.Right()--; 841 aRect.Bottom()--; 842 DrawRect( aRect ); 843 aRect.Left()++; 844 aRect.Top()++; 845 aRect.Right()--; 846 aRect.Bottom()--; 847 DrawRect( aRect ); 848 } 849 } 850 else 851 { 852 if ( bDrawSel ) 853 { 854 if ( mbBlackSel ) 855 SetLineColor( Color( COL_BLACK ) ); 856 else 857 SetLineColor( aDoubleColor ); 858 DrawRect( aRect ); 859 } 860 if ( mbDoubleSel ) 861 { 862 aRect.Left()++; 863 aRect.Top()++; 864 aRect.Right()--; 865 aRect.Bottom()--; 866 if ( bDrawSel ) 867 DrawRect( aRect ); 868 } 869 aRect.Left()++; 870 aRect.Top()++; 871 aRect.Right()--; 872 aRect.Bottom()--; 873 Rectangle aRect2 = aRect; 874 aRect.Left()++; 875 aRect.Top()++; 876 aRect.Right()--; 877 aRect.Bottom()--; 878 if ( bDrawSel ) 879 DrawRect( aRect ); 880 if ( mbDoubleSel ) 881 { 882 aRect.Left()++; 883 aRect.Top()++; 884 aRect.Right()--; 885 aRect.Bottom()--; 886 if ( bDrawSel ) 887 DrawRect( aRect ); 888 } 889 890 if ( bDrawSel ) 891 { 892 if ( mbBlackSel ) 893 SetLineColor( Color( COL_WHITE ) ); 894 else 895 SetLineColor( aSingleColor ); 896 } 897 else 898 SetLineColor( Color( COL_LIGHTGRAY ) ); 899 DrawRect( aRect2 ); 900 901 if ( bFocus ) 902 ShowFocus( aRect2 ); 903 } 904 905 ImplDrawItemText( pItem->maText ); 906 } 907 } 908 909 // ----------------------------------------------------------------------- 910 911 void ValueSet::ImplHideSelect( sal_uInt16 nItemId ) 912 { 913 Rectangle aRect; 914 915 sal_uInt16 nItemPos = GetItemPos( nItemId ); 916 if ( nItemPos != sal::static_int_cast<sal_uInt16>(LIST_ENTRY_NOTFOUND) ) 917 aRect = mpImpl->mpItemList->GetObject( nItemPos )->maRect; 918 else 919 { 920 if ( mpNoneItem ) 921 aRect = mpNoneItem->maRect; 922 } 923 924 if ( !aRect.IsEmpty() ) 925 { 926 HideFocus(); 927 Point aPos = aRect.TopLeft(); 928 Size aSize = aRect.GetSize(); 929 DrawOutDev( aPos, aSize, aPos, aSize, maVirDev ); 930 } 931 } 932 933 // ----------------------------------------------------------------------- 934 935 void ValueSet::ImplHighlightItem( sal_uInt16 nItemId, sal_Bool bIsSelection ) 936 { 937 if ( mnHighItemId != nItemId ) 938 { 939 // Alten merken, um vorherige Selektion zu entfernen 940 sal_uInt16 nOldItem = mnHighItemId; 941 mnHighItemId = nItemId; 942 943 // Wenn keiner selektiert ist, dann Selektion nicht malen 944 if ( !bIsSelection && mbNoSelection ) 945 mbDrawSelection = false; 946 947 // Neu ausgeben und alte Selection wegnehmen 948 ImplHideSelect( nOldItem ); 949 ImplDrawSelect(); 950 mbDrawSelection = true; 951 } 952 } 953 954 // ----------------------------------------------------------------------- 955 956 void ValueSet::ImplDrawDropPos( sal_Bool bShow ) 957 { 958 if ( (mnDropPos != VALUESET_ITEM_NOTFOUND) && mpImpl->mpItemList->Count() ) 959 { 960 sal_uInt16 nItemPos = mnDropPos; 961 sal_uInt16 nItemId1; 962 sal_uInt16 nItemId2 = 0; 963 sal_Bool bRight; 964 if ( nItemPos >= mpImpl->mpItemList->Count() ) 965 { 966 nItemPos = (sal_uInt16)(mpImpl->mpItemList->Count()-1); 967 bRight = sal_True; 968 } 969 else 970 bRight = sal_False; 971 972 nItemId1 = GetItemId( nItemPos ); 973 if ( (nItemId1 != mnSelItemId) && (nItemId1 != mnHighItemId) ) 974 nItemId1 = 0; 975 Rectangle aRect2 = mpImpl->mpItemList->GetObject( nItemPos )->maRect; 976 Rectangle aRect1; 977 if ( bRight ) 978 { 979 aRect1 = aRect2; 980 aRect2.SetEmpty(); 981 } 982 else if ( nItemPos > 0 ) 983 { 984 aRect1 = mpImpl->mpItemList->GetObject( nItemPos-1 )->maRect; 985 nItemId2 = GetItemId( nItemPos-1 ); 986 if ( (nItemId2 != mnSelItemId) && (nItemId2 != mnHighItemId) ) 987 nItemId2 = 0; 988 } 989 990 // Items ueberhaupt sichtbar (nur Erstes/Letztes) 991 if ( !aRect1.IsEmpty() || !aRect2.IsEmpty() ) 992 { 993 if ( nItemId1 ) 994 ImplHideSelect( nItemId1 ); 995 if ( nItemId2 ) 996 ImplHideSelect( nItemId2 ); 997 998 if ( bShow ) 999 { 1000 const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings(); 1001 long nX; 1002 long nY; 1003 SetLineColor( rStyleSettings.GetButtonTextColor() ); 1004 if ( !aRect1.IsEmpty() ) 1005 { 1006 Point aPos = aRect1.RightCenter(); 1007 nX = aPos.X()-2; 1008 nY = aPos.Y(); 1009 for ( sal_uInt16 i = 0; i < 4; i++ ) 1010 DrawLine( Point( nX-i, nY-i ), Point( nX-i, nY+i ) ); 1011 } 1012 if ( !aRect2.IsEmpty() ) 1013 { 1014 Point aPos = aRect2.LeftCenter(); 1015 nX = aPos.X()+2; 1016 nY = aPos.Y(); 1017 for ( sal_uInt16 i = 0; i < 4; i++ ) 1018 DrawLine( Point( nX+i, nY-i ), Point( nX+i, nY+i ) ); 1019 } 1020 } 1021 else 1022 { 1023 if ( !aRect1.IsEmpty() ) 1024 { 1025 Point aPos = aRect1.TopLeft(); 1026 Size aSize = aRect1.GetSize(); 1027 DrawOutDev( aPos, aSize, aPos, aSize, maVirDev ); 1028 } 1029 if ( !aRect2.IsEmpty() ) 1030 { 1031 Point aPos = aRect2.TopLeft(); 1032 Size aSize = aRect2.GetSize(); 1033 DrawOutDev( aPos, aSize, aPos, aSize, maVirDev ); 1034 } 1035 } 1036 1037 if ( nItemId1 || nItemId2 ) 1038 ImplDrawSelect(); 1039 } 1040 } 1041 } 1042 1043 // ----------------------------------------------------------------------- 1044 1045 void ValueSet::ImplDraw() 1046 { 1047 if ( mbFormat ) 1048 Format(); 1049 1050 HideFocus(); 1051 1052 Point aDefPos; 1053 Size aSize = maVirDev.GetOutputSizePixel(); 1054 1055 if ( mpScrBar && mpScrBar->IsVisible() ) 1056 { 1057 Point aScrPos = mpScrBar->GetPosPixel(); 1058 Size aScrSize = mpScrBar->GetSizePixel(); 1059 Point aTempPos( 0, aScrPos.Y() ); 1060 Size aTempSize( aSize.Width(), aScrPos.Y() ); 1061 1062 DrawOutDev( aDefPos, aTempSize, aDefPos, aTempSize, maVirDev ); 1063 aTempSize.Width() = aScrPos.X()-1; 1064 aTempSize.Height() = aScrSize.Height(); 1065 DrawOutDev( aTempPos, aTempSize, aTempPos, aTempSize, maVirDev ); 1066 aTempPos.Y() = aScrPos.Y()+aScrSize.Height(); 1067 aTempSize.Width() = aSize.Width(); 1068 aTempSize.Height() = aSize.Height()-aTempPos.Y(); 1069 DrawOutDev( aTempPos, aTempSize, aTempPos, aTempSize, maVirDev ); 1070 } 1071 else 1072 DrawOutDev( aDefPos, aSize, aDefPos, aSize, maVirDev ); 1073 1074 // Trennlinie zum Namefield zeichnen 1075 if ( GetStyle() & WB_NAMEFIELD ) 1076 { 1077 if ( !(GetStyle() & WB_FLATVALUESET) ) 1078 { 1079 const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings(); 1080 Size aWinSize = GetOutputSizePixel(); 1081 Point aPos1( NAME_LINE_OFF_X, mnTextOffset+NAME_LINE_OFF_Y ); 1082 Point aPos2( aWinSize.Width()-(NAME_LINE_OFF_X*2), mnTextOffset+NAME_LINE_OFF_Y ); 1083 if ( !(rStyleSettings.GetOptions() & STYLE_OPTION_MONO) ) 1084 { 1085 SetLineColor( rStyleSettings.GetShadowColor() ); 1086 DrawLine( aPos1, aPos2 ); 1087 aPos1.Y()++; 1088 aPos2.Y()++; 1089 SetLineColor( rStyleSettings.GetLightColor() ); 1090 } 1091 else 1092 SetLineColor( rStyleSettings.GetWindowTextColor() ); 1093 DrawLine( aPos1, aPos2 ); 1094 } 1095 } 1096 1097 ImplDrawSelect(); 1098 } 1099 1100 // ----------------------------------------------------------------------- 1101 1102 sal_Bool ValueSet::ImplScroll( const Point& rPos ) 1103 { 1104 Size aOutSize = GetOutputSizePixel(); 1105 long nScrBarWidth; 1106 1107 if ( mpScrBar ) 1108 nScrBarWidth = mpScrBar->GetSizePixel().Width(); 1109 else 1110 nScrBarWidth = 0; 1111 1112 if ( !mbScroll || (rPos.X() < 0) || (rPos.X() > aOutSize.Width()-nScrBarWidth) ) 1113 return sal_False; 1114 1115 long nScrollOffset; 1116 sal_uInt16 nOldLine = mnFirstLine; 1117 const Rectangle& rTopRect = mpImpl->mpItemList->GetObject( mnFirstLine*mnCols )->maRect; 1118 if ( rTopRect.GetHeight() <= 16 ) 1119 nScrollOffset = VALUESET_SCROLL_OFFSET/2; 1120 else 1121 nScrollOffset = VALUESET_SCROLL_OFFSET; 1122 if ( (mnFirstLine > 0) && (rPos.Y() >= 0) ) 1123 { 1124 long nTopPos = rTopRect.Top(); 1125 if ( (rPos.Y() >= nTopPos) && (rPos.Y() <= nTopPos+nScrollOffset) ) 1126 mnFirstLine--; 1127 } 1128 if ( (mnFirstLine == nOldLine) && 1129 (mnFirstLine < (sal_uInt16)(mnLines-mnVisLines)) && (rPos.Y() < aOutSize.Height()) ) 1130 { 1131 long nBottomPos = mpImpl->mpItemList->GetObject( (mnFirstLine+mnVisLines-1)*mnCols )->maRect.Bottom(); 1132 if ( (rPos.Y() >= nBottomPos-nScrollOffset) && (rPos.Y() <= nBottomPos) ) 1133 mnFirstLine++; 1134 } 1135 1136 if ( mnFirstLine != nOldLine ) 1137 { 1138 mbFormat = true; 1139 ImplDraw(); 1140 return sal_True; 1141 } 1142 else 1143 return sal_False; 1144 } 1145 1146 // ----------------------------------------------------------------------- 1147 1148 sal_uInt16 ValueSet::ImplGetItem( const Point& rPos, sal_Bool bMove ) const 1149 { 1150 if ( mpNoneItem ) 1151 { 1152 if ( mpNoneItem->maRect.IsInside( rPos ) ) 1153 return VALUESET_ITEM_NONEITEM; 1154 } 1155 1156 Point aDefPos; 1157 Rectangle aWinRect( aDefPos, maVirDev.GetOutputSizePixel() ); 1158 1159 sal_uLong nItemCount = mpImpl->mpItemList->Count(); 1160 for ( sal_uLong i = 0; i < nItemCount; i++ ) 1161 { 1162 ValueSetItem* pItem = mpImpl->mpItemList->GetObject( i ); 1163 if ( pItem->maRect.IsInside( rPos ) ) 1164 { 1165 if ( aWinRect.IsInside( rPos ) ) 1166 return (sal_uInt16)i; 1167 else 1168 return VALUESET_ITEM_NOTFOUND; 1169 } 1170 } 1171 1172 // Wenn Spacing gesetzt ist, wird der vorher selektierte 1173 // Eintrag zurueckgegeben, wenn die Maus noch nicht das Fenster 1174 // verlassen hat 1175 if ( bMove && mnSpacing && mnHighItemId ) 1176 { 1177 if ( aWinRect.IsInside( rPos ) ) 1178 return GetItemPos( mnHighItemId ); 1179 } 1180 1181 return VALUESET_ITEM_NOTFOUND; 1182 } 1183 1184 // ----------------------------------------------------------------------- 1185 1186 ValueSetItem* ValueSet::ImplGetItem( sal_uInt16 nPos ) 1187 { 1188 if ( nPos == VALUESET_ITEM_NONEITEM ) 1189 return mpNoneItem; 1190 else 1191 return mpImpl->mpItemList->GetObject( nPos ); 1192 } 1193 1194 // ----------------------------------------------------------------------- 1195 1196 ValueSetItem* ValueSet::ImplGetFirstItem() 1197 { 1198 sal_uInt16 nItemCount = (sal_uInt16)mpImpl->mpItemList->Count(); 1199 sal_uInt16 i = 0; 1200 1201 while ( i < nItemCount ) 1202 { 1203 ValueSetItem* pItem = mpImpl->mpItemList->GetObject( i ); 1204 if ( pItem->meType != VALUESETITEM_SPACE ) 1205 return pItem; 1206 i++; 1207 } 1208 1209 return NULL; 1210 } 1211 1212 // ----------------------------------------------------------------------- 1213 1214 sal_uInt16 ValueSet::ImplGetVisibleItemCount() const 1215 { 1216 sal_uInt16 nRet = 0; 1217 1218 for( sal_Int32 n = 0, nItemCount = mpImpl->mpItemList->Count(); n < nItemCount; n++ ) 1219 { 1220 ValueSetItem* pItem = mpImpl->mpItemList->GetObject( n ); 1221 1222 //IAccessible2 implementation - also count empty rectangles as visible... 1223 if( pItem->meType != VALUESETITEM_SPACE ) 1224 nRet++; 1225 } 1226 1227 return nRet; 1228 } 1229 1230 // ----------------------------------------------------------------------- 1231 1232 ValueSetItem* ValueSet::ImplGetVisibleItem( sal_uInt16 nVisiblePos ) 1233 { 1234 ValueSetItem* pRet = NULL; 1235 sal_uInt16 nFoundPos = 0; 1236 1237 for( sal_Int32 n = 0, nItemCount = mpImpl->mpItemList->Count(); ( n < nItemCount ) && !pRet; n++ ) 1238 { 1239 ValueSetItem* pItem = mpImpl->mpItemList->GetObject( n ); 1240 1241 if( ( pItem->meType != VALUESETITEM_SPACE ) && !pItem->maRect.IsEmpty() && ( nVisiblePos == nFoundPos++ ) ) 1242 pRet = pItem; 1243 } 1244 1245 return pRet; 1246 } 1247 1248 // ----------------------------------------------------------------------- 1249 1250 void ValueSet::ImplFireAccessibleEvent( short nEventId, const ::com::sun::star::uno::Any& rOldValue, const ::com::sun::star::uno::Any& rNewValue ) 1251 { 1252 ValueSetAcc* pAcc = ValueSetAcc::getImplementation( GetAccessible( sal_False ) ); 1253 1254 if( pAcc ) 1255 pAcc->FireAccessibleEvent( nEventId, rOldValue, rNewValue ); 1256 } 1257 1258 // ----------------------------------------------------------------------- 1259 1260 sal_Bool ValueSet::ImplHasAccessibleListeners() 1261 { 1262 ValueSetAcc* pAcc = ValueSetAcc::getImplementation( GetAccessible( sal_False ) ); 1263 return( pAcc && pAcc->HasAccessibleListeners() ); 1264 } 1265 1266 // ----------------------------------------------------------------------- 1267 1268 IMPL_LINK( ValueSet,ImplScrollHdl, ScrollBar*, pScrollBar ) 1269 { 1270 sal_uInt16 nNewFirstLine = (sal_uInt16)pScrollBar->GetThumbPos(); 1271 if ( nNewFirstLine != mnFirstLine ) 1272 { 1273 mnFirstLine = nNewFirstLine; 1274 mbFormat = true; 1275 ImplDraw(); 1276 } 1277 return 0; 1278 } 1279 1280 // ----------------------------------------------------------------------- 1281 1282 IMPL_LINK( ValueSet,ImplTimerHdl, Timer*, EMPTYARG ) 1283 { 1284 ImplTracking( GetPointerPosPixel(), sal_True ); 1285 return 0; 1286 } 1287 1288 // ----------------------------------------------------------------------- 1289 1290 void ValueSet::ImplTracking( const Point& rPos, sal_Bool bRepeat ) 1291 { 1292 if ( bRepeat || mbSelection ) 1293 { 1294 if ( ImplScroll( rPos ) ) 1295 { 1296 if ( mbSelection ) 1297 { 1298 maTimer.SetTimeoutHdl( LINK( this, ValueSet, ImplTimerHdl ) ); 1299 maTimer.SetTimeout( GetSettings().GetMouseSettings().GetScrollRepeat() ); 1300 maTimer.Start(); 1301 } 1302 } 1303 } 1304 1305 ValueSetItem* pItem = ImplGetItem( ImplGetItem( rPos ) ); 1306 if ( pItem && (pItem->meType != VALUESETITEM_SPACE) ) 1307 { 1308 if( GetStyle() & WB_MENUSTYLEVALUESET ) 1309 mbHighlight = true; 1310 1311 ImplHighlightItem( pItem->mnId ); 1312 } 1313 else 1314 { 1315 if( GetStyle() & WB_MENUSTYLEVALUESET ) 1316 mbHighlight = true; 1317 1318 ImplHighlightItem( mnSelItemId, sal_False ); 1319 } 1320 } 1321 1322 // ----------------------------------------------------------------------- 1323 1324 void ValueSet::ImplEndTracking( const Point& rPos, sal_Bool bCancel ) 1325 { 1326 ValueSetItem* pItem; 1327 1328 // Bei Abbruch, den alten Status wieder herstellen 1329 if ( bCancel ) 1330 pItem = NULL; 1331 else 1332 pItem = ImplGetItem( ImplGetItem( rPos ) ); 1333 1334 if ( pItem && (pItem->meType != VALUESETITEM_SPACE) ) 1335 { 1336 SelectItem( pItem->mnId ); 1337 if ( !mbSelection && !(GetStyle() & WB_NOPOINTERFOCUS) ) 1338 GrabFocus(); 1339 mbHighlight = false; 1340 mbSelection = false; 1341 Select(); 1342 } 1343 else 1344 { 1345 ImplHighlightItem( mnSelItemId, sal_False ); 1346 mbHighlight = false; 1347 mbSelection = false; 1348 } 1349 } 1350 1351 // ----------------------------------------------------------------------- 1352 1353 void ValueSet::MouseButtonDown( const MouseEvent& rMEvt ) 1354 { 1355 if ( rMEvt.IsLeft() ) 1356 { 1357 ValueSetItem* pItem = ImplGetItem( ImplGetItem( rMEvt.GetPosPixel() ) ); 1358 if ( mbSelection ) 1359 { 1360 mbHighlight = true; 1361 if ( pItem && (pItem->meType != VALUESETITEM_SPACE) ) 1362 { 1363 mnOldItemId = mnSelItemId; 1364 mnHighItemId = mnSelItemId; 1365 ImplHighlightItem( pItem->mnId ); 1366 } 1367 1368 return; 1369 } 1370 else 1371 { 1372 if ( pItem && (pItem->meType != VALUESETITEM_SPACE) && !rMEvt.IsMod2() ) 1373 { 1374 if ( (pItem->mnBits & VIB_NODOUBLECLICK) || (rMEvt.GetClicks() == 1) ) 1375 { 1376 mnOldItemId = mnSelItemId; 1377 mbHighlight = true; 1378 mnHighItemId = mnSelItemId; 1379 ImplHighlightItem( pItem->mnId ); 1380 StartTracking( STARTTRACK_SCROLLREPEAT ); 1381 } 1382 else if ( rMEvt.GetClicks() == 2 ) 1383 DoubleClick(); 1384 1385 return; 1386 } 1387 } 1388 } 1389 1390 Control::MouseButtonDown( rMEvt ); 1391 } 1392 1393 // ----------------------------------------------------------------------- 1394 1395 void ValueSet::MouseButtonUp( const MouseEvent& rMEvt ) 1396 { 1397 // Wegen SelectionMode 1398 if ( rMEvt.IsLeft() && mbSelection ) 1399 ImplEndTracking( rMEvt.GetPosPixel(), sal_False ); 1400 else 1401 Control::MouseButtonUp( rMEvt ); 1402 } 1403 1404 // ----------------------------------------------------------------------- 1405 1406 void ValueSet::MouseMove( const MouseEvent& rMEvt ) 1407 { 1408 // Wegen SelectionMode 1409 if ( mbSelection || (GetStyle() & WB_MENUSTYLEVALUESET) ) 1410 ImplTracking( rMEvt.GetPosPixel(), sal_False ); 1411 Control::MouseMove( rMEvt ); 1412 } 1413 1414 // ----------------------------------------------------------------------- 1415 1416 void ValueSet::Tracking( const TrackingEvent& rTEvt ) 1417 { 1418 Point aMousePos = rTEvt.GetMouseEvent().GetPosPixel(); 1419 1420 if ( rTEvt.IsTrackingEnded() ) 1421 ImplEndTracking( aMousePos, rTEvt.IsTrackingCanceled() ); 1422 else 1423 ImplTracking( aMousePos, rTEvt.IsTrackingRepeat() ); 1424 } 1425 1426 // ----------------------------------------------------------------------- 1427 1428 void ValueSet::KeyInput( const KeyEvent& rKEvt ) 1429 { 1430 sal_uInt16 nLastItem = (sal_uInt16)mpImpl->mpItemList->Count(); 1431 sal_uInt16 nItemPos = VALUESET_ITEM_NOTFOUND; 1432 sal_uInt16 nCurPos = VALUESET_ITEM_NONEITEM; 1433 sal_uInt16 nCalcPos; 1434 1435 if ( !nLastItem || !ImplGetFirstItem() ) 1436 { 1437 Control::KeyInput( rKEvt ); 1438 return; 1439 } 1440 else 1441 nLastItem--; 1442 1443 if ( mnSelItemId ) 1444 nCurPos = GetItemPos( mnSelItemId ); 1445 nCalcPos = nCurPos; 1446 1447 //switch off selection mode if key travelling is used 1448 sal_Bool bDefault = sal_False; 1449 switch ( rKEvt.GetKeyCode().GetCode() ) 1450 { 1451 case KEY_HOME: 1452 if ( mpNoneItem ) 1453 nItemPos = VALUESET_ITEM_NONEITEM; 1454 else 1455 { 1456 nItemPos = 0; 1457 while ( ImplGetItem( nItemPos )->meType == VALUESETITEM_SPACE ) 1458 nItemPos++; 1459 } 1460 break; 1461 1462 case KEY_END: 1463 nItemPos = nLastItem; 1464 while ( ImplGetItem( nItemPos )->meType == VALUESETITEM_SPACE ) 1465 { 1466 if ( nItemPos == 0 ) 1467 nItemPos = VALUESET_ITEM_NONEITEM; 1468 else 1469 nItemPos--; 1470 } 1471 break; 1472 1473 case KEY_LEFT: 1474 case KEY_RIGHT: 1475 if ( rKEvt.GetKeyCode().GetCode()==KEY_LEFT ) 1476 { 1477 do 1478 { 1479 if ( nCalcPos == VALUESET_ITEM_NONEITEM ) 1480 nItemPos = nLastItem; 1481 else if ( !nCalcPos ) 1482 { 1483 if ( mpNoneItem ) 1484 nItemPos = VALUESET_ITEM_NONEITEM; 1485 else 1486 nItemPos = nLastItem; 1487 } 1488 else 1489 nItemPos = nCalcPos-1; 1490 nCalcPos = nItemPos; 1491 } 1492 while ( ImplGetItem( nItemPos )->meType == VALUESETITEM_SPACE ); 1493 } 1494 else 1495 { 1496 do 1497 { 1498 if ( nCalcPos == VALUESET_ITEM_NONEITEM ) 1499 nItemPos = 0; 1500 else if ( nCalcPos == nLastItem ) 1501 { 1502 if ( mpNoneItem ) 1503 nItemPos = VALUESET_ITEM_NONEITEM; 1504 else 1505 nItemPos = 0; 1506 } 1507 else 1508 nItemPos = nCalcPos+1; 1509 nCalcPos = nItemPos; 1510 } 1511 while ( ImplGetItem( nItemPos )->meType == VALUESETITEM_SPACE ); 1512 } 1513 break; 1514 1515 case KEY_UP: 1516 case KEY_PAGEUP: 1517 { 1518 if( rKEvt.GetKeyCode().GetCode() != KEY_PAGEUP || 1519 ( !rKEvt.GetKeyCode().IsShift() && !rKEvt.GetKeyCode().IsMod1() && !rKEvt.GetKeyCode().IsMod2() ) ) 1520 { 1521 const long nLineCount = ( ( KEY_UP == rKEvt.GetKeyCode().GetCode() ) ? 1 : mnVisLines ); 1522 do 1523 { 1524 if ( nCalcPos == VALUESET_ITEM_NONEITEM ) 1525 { 1526 if ( nLastItem+1 <= mnCols ) 1527 nItemPos = mnCurCol; 1528 else 1529 { 1530 nItemPos = ((((nLastItem+1)/mnCols)-1)*mnCols)+(mnCurCol%mnCols); 1531 if ( nItemPos+mnCols <= nLastItem ) 1532 nItemPos = nItemPos + mnCols; 1533 } 1534 } 1535 else if ( nCalcPos >= ( nLineCount * mnCols ) ) 1536 nItemPos = sal::static_int_cast< sal_uInt16 >( 1537 nCalcPos - ( nLineCount * mnCols )); 1538 else 1539 { 1540 if ( mpNoneItem ) 1541 { 1542 mnCurCol = nCalcPos%mnCols; 1543 nItemPos = VALUESET_ITEM_NONEITEM; 1544 } 1545 else 1546 { 1547 if ( nLastItem+1 <= mnCols ) 1548 nItemPos = nCalcPos; 1549 else 1550 { 1551 nItemPos = ((((nLastItem+1)/mnCols)-1)*mnCols)+(nCalcPos%mnCols); 1552 if ( nItemPos+mnCols <= nLastItem ) 1553 nItemPos = nItemPos + mnCols; 1554 } 1555 } 1556 } 1557 nCalcPos = nItemPos; 1558 } 1559 while ( ImplGetItem( nItemPos )->meType == VALUESETITEM_SPACE ); 1560 } 1561 else 1562 Control::KeyInput( rKEvt ); 1563 } 1564 break; 1565 1566 case KEY_DOWN: 1567 case KEY_PAGEDOWN: 1568 { 1569 if( rKEvt.GetKeyCode().GetCode() != KEY_PAGEDOWN || 1570 ( !rKEvt.GetKeyCode().IsShift() && !rKEvt.GetKeyCode().IsMod1() && !rKEvt.GetKeyCode().IsMod2() ) ) 1571 { 1572 const long nLineCount = ( ( KEY_DOWN == rKEvt.GetKeyCode().GetCode() ) ? 1 : mnVisLines ); 1573 do 1574 { 1575 if ( nCalcPos == VALUESET_ITEM_NONEITEM ) 1576 nItemPos = mnCurCol; 1577 else if ( nCalcPos + ( nLineCount * mnCols ) <= nLastItem ) 1578 nItemPos = sal::static_int_cast< sal_uInt16 >( 1579 nCalcPos + ( nLineCount * mnCols )); 1580 else 1581 { 1582 #if 0 1583 if( (KEY_DOWN == rKEvt.GetKeyCode().GetCode() ) && (GetStyle() & WB_MENUSTYLEVALUESET) ) 1584 { 1585 Window* pParent = GetParent(); 1586 pParent->GrabFocus(); 1587 pParent->KeyInput( rKEvt ); 1588 break; 1589 } 1590 else 1591 #endif 1592 { 1593 if ( mpNoneItem ) 1594 { 1595 mnCurCol = nCalcPos%mnCols; 1596 nItemPos = VALUESET_ITEM_NONEITEM; 1597 } 1598 else 1599 nItemPos = nCalcPos%mnCols; 1600 } 1601 } 1602 nCalcPos = nItemPos; 1603 } 1604 while ( ImplGetItem( nItemPos )->meType == VALUESETITEM_SPACE ); 1605 } 1606 else 1607 Control::KeyInput( rKEvt ); 1608 1609 } 1610 break; 1611 case KEY_RETURN: 1612 //enable default handling of KEY_RETURN in dialogs 1613 if(0 != (GetStyle()&WB_NO_DIRECTSELECT)) 1614 { 1615 Select(); 1616 break; 1617 } 1618 //no break; 1619 default: 1620 Control::KeyInput( rKEvt ); 1621 bDefault = sal_True; 1622 break; 1623 } 1624 if(!bDefault) 1625 EndSelection(); 1626 if ( nItemPos != VALUESET_ITEM_NOTFOUND ) 1627 { 1628 sal_uInt16 nItemId; 1629 if ( nItemPos != VALUESET_ITEM_NONEITEM ) 1630 nItemId = GetItemId( nItemPos ); 1631 else 1632 nItemId = 0; 1633 1634 if ( nItemId != mnSelItemId ) 1635 { 1636 SelectItem( nItemId ); 1637 //select only if WB_NO_DIRECTSELECT is not set 1638 if(0 == (GetStyle()&WB_NO_DIRECTSELECT)) 1639 Select(); 1640 } 1641 } 1642 } 1643 1644 // ----------------------------------------------------------------------- 1645 1646 void ValueSet::Command( const CommandEvent& rCEvt ) 1647 { 1648 if ( (rCEvt.GetCommand() == COMMAND_WHEEL) || 1649 (rCEvt.GetCommand() == COMMAND_STARTAUTOSCROLL) || 1650 (rCEvt.GetCommand() == COMMAND_AUTOSCROLL) ) 1651 { 1652 if ( HandleScrollCommand( rCEvt, NULL, mpScrBar ) ) 1653 return; 1654 } 1655 1656 Control::Command( rCEvt ); 1657 } 1658 1659 // ----------------------------------------------------------------------- 1660 1661 void ValueSet::Paint( const Rectangle& ) 1662 { 1663 if ( GetStyle() & WB_FLATVALUESET ) 1664 { 1665 const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings(); 1666 SetLineColor(); 1667 SetFillColor( rStyleSettings.GetFaceColor() ); 1668 long nOffY = maVirDev.GetOutputSizePixel().Height(); 1669 Size aWinSize = GetOutputSizePixel(); 1670 DrawRect( Rectangle( Point( 0, nOffY ), Point( aWinSize.Width(), aWinSize.Height() ) ) ); 1671 } 1672 1673 ImplDraw(); 1674 } 1675 1676 // ----------------------------------------------------------------------- 1677 1678 void ValueSet::GetFocus() 1679 { 1680 OSL_TRACE ("value set getting focus"); 1681 ImplDrawSelect(); 1682 Control::GetFocus(); 1683 1684 // Tell the accessible object that we got the focus. 1685 ValueSetAcc* pAcc = ValueSetAcc::getImplementation( GetAccessible( sal_False ) ); 1686 if( pAcc ) 1687 pAcc->GetFocus(); 1688 } 1689 1690 // ----------------------------------------------------------------------- 1691 1692 void ValueSet::LoseFocus() 1693 { 1694 OSL_TRACE ("value set losing focus"); 1695 if ( mbNoSelection && mnSelItemId ) 1696 ImplHideSelect( mnSelItemId ); 1697 else 1698 HideFocus(); 1699 Control::LoseFocus(); 1700 1701 // Tell the accessible object that we lost the focus. 1702 ValueSetAcc* pAcc = ValueSetAcc::getImplementation( GetAccessible( sal_False ) ); 1703 if( pAcc ) 1704 pAcc->LoseFocus(); 1705 } 1706 1707 // ----------------------------------------------------------------------- 1708 1709 void ValueSet::Resize() 1710 { 1711 mbFormat = true; 1712 if ( IsReallyVisible() && IsUpdateMode() ) 1713 Invalidate(); 1714 Control::Resize(); 1715 } 1716 1717 // ----------------------------------------------------------------------- 1718 1719 void ValueSet::RequestHelp( const HelpEvent& rHEvt ) 1720 { 1721 if ( (rHEvt.GetMode() & (HELPMODE_QUICK | HELPMODE_BALLOON)) == HELPMODE_QUICK ) 1722 { 1723 Point aPos = ScreenToOutputPixel( rHEvt.GetMousePosPixel() ); 1724 sal_uInt16 nItemPos = ImplGetItem( aPos ); 1725 if ( nItemPos != VALUESET_ITEM_NOTFOUND ) 1726 { 1727 ValueSetItem* pItem = ImplGetItem( nItemPos ); 1728 Rectangle aItemRect = pItem->maRect; 1729 Point aPt = OutputToScreenPixel( aItemRect.TopLeft() ); 1730 aItemRect.Left() = aPt.X(); 1731 aItemRect.Top() = aPt.Y(); 1732 aPt = OutputToScreenPixel( aItemRect.BottomRight() ); 1733 aItemRect.Right() = aPt.X(); 1734 aItemRect.Bottom() = aPt.Y(); 1735 Help::ShowQuickHelp( this, aItemRect, GetItemText( pItem->mnId ) ); 1736 return; 1737 } 1738 } 1739 1740 Control::RequestHelp( rHEvt ); 1741 } 1742 1743 // ----------------------------------------------------------------------- 1744 1745 void ValueSet::StateChanged( StateChangedType nType ) 1746 { 1747 Control::StateChanged( nType ); 1748 1749 if ( nType == STATE_CHANGE_INITSHOW ) 1750 { 1751 if ( mbFormat ) 1752 Format(); 1753 } 1754 else if ( nType == STATE_CHANGE_UPDATEMODE ) 1755 { 1756 if ( IsReallyVisible() && IsUpdateMode() ) 1757 Invalidate(); 1758 } 1759 else if ( nType == STATE_CHANGE_TEXT ) 1760 { 1761 if ( mpNoneItem && !mbFormat && IsReallyVisible() && IsUpdateMode() ) 1762 { 1763 ImplFormatItem( mpNoneItem ); 1764 Invalidate( mpNoneItem->maRect ); 1765 } 1766 } 1767 else if ( (nType == STATE_CHANGE_ZOOM) || 1768 (nType == STATE_CHANGE_CONTROLFONT) ) 1769 { 1770 ImplInitSettings( sal_True, sal_False, sal_False ); 1771 Invalidate(); 1772 } 1773 else if ( nType == STATE_CHANGE_CONTROLFOREGROUND ) 1774 { 1775 ImplInitSettings( sal_False, sal_True, sal_False ); 1776 Invalidate(); 1777 } 1778 else if ( nType == STATE_CHANGE_CONTROLBACKGROUND ) 1779 { 1780 ImplInitSettings( sal_False, sal_False, sal_True ); 1781 Invalidate(); 1782 } 1783 else if ( (nType == STATE_CHANGE_STYLE) || (nType == STATE_CHANGE_ENABLE) ) 1784 { 1785 mbFormat = true; 1786 ImplInitSettings( sal_False, sal_False, sal_True ); 1787 Invalidate(); 1788 } 1789 } 1790 1791 // ----------------------------------------------------------------------- 1792 1793 void ValueSet::DataChanged( const DataChangedEvent& rDCEvt ) 1794 { 1795 Control::DataChanged( rDCEvt ); 1796 1797 if ( (rDCEvt.GetType() == DATACHANGED_FONTS) || 1798 (rDCEvt.GetType() == DATACHANGED_DISPLAY) || 1799 (rDCEvt.GetType() == DATACHANGED_FONTSUBSTITUTION) || 1800 ((rDCEvt.GetType() == DATACHANGED_SETTINGS) && 1801 (rDCEvt.GetFlags() & SETTINGS_STYLE)) ) 1802 { 1803 mbFormat = true; 1804 ImplInitSettings( sal_True, sal_True, sal_True ); 1805 Invalidate(); 1806 } 1807 } 1808 1809 // ----------------------------------------------------------------------- 1810 1811 void ValueSet::Select() 1812 { 1813 maSelectHdl.Call( this ); 1814 } 1815 1816 // ----------------------------------------------------------------------- 1817 1818 void ValueSet::DoubleClick() 1819 { 1820 maDoubleClickHdl.Call( this ); 1821 } 1822 1823 // ----------------------------------------------------------------------- 1824 1825 void ValueSet::UserDraw( const UserDrawEvent& ) 1826 { 1827 } 1828 1829 // ----------------------------------------------------------------------- 1830 1831 void ValueSet::InsertItem( sal_uInt16 nItemId, const Image& rImage, sal_uInt16 nPos ) 1832 { 1833 DBG_ASSERT( nItemId, "ValueSet::InsertItem(): ItemId == 0" ); 1834 DBG_ASSERT( GetItemPos( nItemId ) == VALUESET_ITEM_NOTFOUND, 1835 "ValueSet::InsertItem(): ItemId already exists" ); 1836 1837 ValueSetItem* pItem = new ValueSetItem( *this ); 1838 pItem->mnId = nItemId; 1839 pItem->meType = VALUESETITEM_IMAGE; 1840 pItem->maImage = rImage; 1841 mpImpl->mpItemList->Insert( pItem, (sal_uLong)nPos ); 1842 1843 mbFormat = true; 1844 if ( IsReallyVisible() && IsUpdateMode() ) 1845 Invalidate(); 1846 } 1847 1848 // ----------------------------------------------------------------------- 1849 1850 void ValueSet::InsertItem( sal_uInt16 nItemId, const Color& rColor, sal_uInt16 nPos ) 1851 { 1852 DBG_ASSERT( nItemId, "ValueSet::InsertItem(): ItemId == 0" ); 1853 DBG_ASSERT( GetItemPos( nItemId ) == VALUESET_ITEM_NOTFOUND, 1854 "ValueSet::InsertItem(): ItemId already exists" ); 1855 1856 ValueSetItem* pItem = new ValueSetItem( *this ); 1857 pItem->mnId = nItemId; 1858 pItem->meType = VALUESETITEM_COLOR; 1859 pItem->maColor = rColor; 1860 mpImpl->mpItemList->Insert( pItem, (sal_uLong)nPos ); 1861 1862 mbFormat = true; 1863 if ( IsReallyVisible() && IsUpdateMode() ) 1864 Invalidate(); 1865 } 1866 1867 // ----------------------------------------------------------------------- 1868 1869 void ValueSet::InsertItem( sal_uInt16 nItemId, const Image& rImage, 1870 const XubString& rText, sal_uInt16 nPos ) 1871 { 1872 DBG_ASSERT( nItemId, "ValueSet::InsertItem(): ItemId == 0" ); 1873 DBG_ASSERT( GetItemPos( nItemId ) == VALUESET_ITEM_NOTFOUND, 1874 "ValueSet::InsertItem(): ItemId already exists" ); 1875 1876 ValueSetItem* pItem = new ValueSetItem( *this ); 1877 pItem->mnId = nItemId; 1878 pItem->meType = VALUESETITEM_IMAGE; 1879 pItem->maImage = rImage; 1880 pItem->maText = rText; 1881 mpImpl->mpItemList->Insert( pItem, (sal_uLong)nPos ); 1882 1883 mbFormat = true; 1884 if ( IsReallyVisible() && IsUpdateMode() ) 1885 Invalidate(); 1886 } 1887 1888 // ----------------------------------------------------------------------- 1889 1890 void ValueSet::InsertItem( sal_uInt16 nItemId, const Color& rColor, 1891 const XubString& rText, sal_uInt16 nPos ) 1892 { 1893 DBG_ASSERT( nItemId, "ValueSet::InsertItem(): ItemId == 0" ); 1894 DBG_ASSERT( GetItemPos( nItemId ) == VALUESET_ITEM_NOTFOUND, 1895 "ValueSet::InsertItem(): ItemId already exists" ); 1896 1897 ValueSetItem* pItem = new ValueSetItem( *this ); 1898 pItem->mnId = nItemId; 1899 pItem->meType = VALUESETITEM_COLOR; 1900 pItem->maColor = rColor; 1901 pItem->maText = rText; 1902 mpImpl->mpItemList->Insert( pItem, (sal_uLong)nPos ); 1903 1904 mbFormat = true; 1905 if ( IsReallyVisible() && IsUpdateMode() ) 1906 Invalidate(); 1907 } 1908 1909 //method to set accessible when the style is user draw. 1910 void ValueSet::InsertItem( sal_uInt16 nItemId, const XubString& rText, sal_uInt16 nPos ) 1911 { 1912 DBG_ASSERT( nItemId, "ValueSet::InsertItem(): ItemId == 0" ); 1913 DBG_ASSERT( GetItemPos( nItemId ) == VALUESET_ITEM_NOTFOUND, 1914 "ValueSet::InsertItem(): ItemId already exists" ); 1915 ValueSetItem* pItem = new ValueSetItem( *this ); 1916 pItem->mnId = nItemId; 1917 pItem->meType = VALUESETITEM_USERDRAW; 1918 pItem->maText = rText; 1919 mpImpl->mpItemList->Insert( pItem, (sal_uLong)nPos ); 1920 mbFormat = sal_True; 1921 if ( IsReallyVisible() && IsUpdateMode() ) 1922 Invalidate(); 1923 } 1924 1925 // ----------------------------------------------------------------------- 1926 1927 void ValueSet::InsertItem( sal_uInt16 nItemId, sal_uInt16 nPos ) 1928 { 1929 DBG_ASSERT( nItemId, "ValueSet::InsertItem(): ItemId == 0" ); 1930 DBG_ASSERT( GetItemPos( nItemId ) == VALUESET_ITEM_NOTFOUND, 1931 "ValueSet::InsertItem(): ItemId already exists" ); 1932 1933 ValueSetItem* pItem = new ValueSetItem( *this ); 1934 pItem->mnId = nItemId; 1935 pItem->meType = VALUESETITEM_USERDRAW; 1936 mpImpl->mpItemList->Insert( pItem, (sal_uLong)nPos ); 1937 1938 mbFormat = true; 1939 if ( IsReallyVisible() && IsUpdateMode() ) 1940 Invalidate(); 1941 } 1942 1943 // ----------------------------------------------------------------------- 1944 1945 void ValueSet::InsertSpace( sal_uInt16 nItemId, sal_uInt16 nPos ) 1946 { 1947 DBG_ASSERT( nItemId, "ValueSet::InsertSpace(): ItemId == 0" ); 1948 DBG_ASSERT( GetItemPos( nItemId ) == VALUESET_ITEM_NOTFOUND, 1949 "ValueSet::InsertSpace(): ItemId already exists" ); 1950 1951 ValueSetItem* pItem = new ValueSetItem( *this ); 1952 pItem->mnId = nItemId; 1953 pItem->meType = VALUESETITEM_SPACE; 1954 mpImpl->mpItemList->Insert( pItem, (sal_uLong)nPos ); 1955 1956 mbFormat = true; 1957 if ( IsReallyVisible() && IsUpdateMode() ) 1958 Invalidate(); 1959 } 1960 1961 // ----------------------------------------------------------------------- 1962 1963 void ValueSet::RemoveItem( sal_uInt16 nItemId ) 1964 { 1965 sal_uInt16 nPos = GetItemPos( nItemId ); 1966 1967 if ( nPos == VALUESET_ITEM_NOTFOUND ) 1968 return; 1969 1970 delete mpImpl->mpItemList->Remove( nPos ); 1971 1972 // Variablen zuruecksetzen 1973 if ( (mnHighItemId == nItemId) || (mnSelItemId == nItemId) ) 1974 { 1975 mnCurCol = 0; 1976 mnOldItemId = 0; 1977 mnHighItemId = 0; 1978 mnSelItemId = 0; 1979 mbNoSelection = true; 1980 } 1981 1982 mbFormat = true; 1983 if ( IsReallyVisible() && IsUpdateMode() ) 1984 Invalidate(); 1985 } 1986 1987 // ----------------------------------------------------------------------- 1988 1989 void ValueSet::CopyItems( const ValueSet& rValueSet ) 1990 { 1991 ImplDeleteItems(); 1992 1993 ValueSetItem* pItem = rValueSet.mpImpl->mpItemList->First(); 1994 while ( pItem ) 1995 { 1996 ValueSetItem* pNewItem = new ValueSetItem( *this ); 1997 1998 pNewItem->mnId = pItem->mnId; 1999 pNewItem->mnBits = pItem->mnBits; 2000 pNewItem->meType = pItem->meType; 2001 pNewItem->maImage = pItem->maImage; 2002 pNewItem->maColor = pItem->maColor; 2003 pNewItem->maText = pItem->maText; 2004 pNewItem->mpData = pItem->mpData; 2005 pNewItem->maRect = pItem->maRect; 2006 pNewItem->mpxAcc = NULL; 2007 2008 mpImpl->mpItemList->Insert( pNewItem ); 2009 pItem = rValueSet.mpImpl->mpItemList->Next(); 2010 } 2011 2012 // Variablen zuruecksetzen 2013 mnFirstLine = 0; 2014 mnCurCol = 0; 2015 mnOldItemId = 0; 2016 mnHighItemId = 0; 2017 mnSelItemId = 0; 2018 mbNoSelection = true; 2019 2020 mbFormat = true; 2021 if ( IsReallyVisible() && IsUpdateMode() ) 2022 Invalidate(); 2023 } 2024 2025 // ----------------------------------------------------------------------- 2026 2027 void ValueSet::Clear() 2028 { 2029 ImplDeleteItems(); 2030 2031 // Variablen zuruecksetzen 2032 mnFirstLine = 0; 2033 mnCurCol = 0; 2034 mnOldItemId = 0; 2035 mnHighItemId = 0; 2036 mnSelItemId = 0; 2037 mbNoSelection = true; 2038 2039 mbFormat = true; 2040 if ( IsReallyVisible() && IsUpdateMode() ) 2041 Invalidate(); 2042 } 2043 2044 // ----------------------------------------------------------------------- 2045 2046 sal_uInt16 ValueSet::GetItemCount() const 2047 { 2048 return (sal_uInt16)mpImpl->mpItemList->Count(); 2049 } 2050 2051 // ----------------------------------------------------------------------- 2052 2053 sal_uInt16 ValueSet::GetItemPos( sal_uInt16 nItemId ) const 2054 { 2055 ValueSetItem* pItem = mpImpl->mpItemList->First(); 2056 while ( pItem ) 2057 { 2058 if ( pItem->mnId == nItemId ) 2059 return (sal_uInt16)mpImpl->mpItemList->GetCurPos(); 2060 pItem = mpImpl->mpItemList->Next(); 2061 } 2062 2063 return VALUESET_ITEM_NOTFOUND; 2064 } 2065 2066 // ----------------------------------------------------------------------- 2067 2068 sal_uInt16 ValueSet::GetItemId( sal_uInt16 nPos ) const 2069 { 2070 ValueSetItem* pItem = mpImpl->mpItemList->GetObject( nPos ); 2071 2072 if ( pItem ) 2073 return pItem->mnId; 2074 else 2075 return 0; 2076 } 2077 2078 // ----------------------------------------------------------------------- 2079 2080 sal_uInt16 ValueSet::GetItemId( const Point& rPos ) const 2081 { 2082 sal_uInt16 nItemPos = ImplGetItem( rPos ); 2083 if ( nItemPos != VALUESET_ITEM_NOTFOUND ) 2084 return GetItemId( nItemPos ); 2085 2086 return 0; 2087 } 2088 2089 // ----------------------------------------------------------------------- 2090 2091 Rectangle ValueSet::GetItemRect( sal_uInt16 nItemId ) const 2092 { 2093 sal_uInt16 nPos = GetItemPos( nItemId ); 2094 2095 if ( nPos != VALUESET_ITEM_NOTFOUND ) 2096 return mpImpl->mpItemList->GetObject( nPos )->maRect; 2097 else 2098 return Rectangle(); 2099 } 2100 2101 // ----------------------------------------------------------------------- 2102 2103 void ValueSet::EnableFullItemMode( bool bFullMode ) 2104 { 2105 mbFullMode = bFullMode; 2106 } 2107 2108 // ----------------------------------------------------------------------- 2109 2110 void ValueSet::SetColCount( sal_uInt16 nNewCols ) 2111 { 2112 if ( mnUserCols != nNewCols ) 2113 { 2114 mnUserCols = nNewCols; 2115 mbFormat = true; 2116 if ( IsReallyVisible() && IsUpdateMode() ) 2117 Invalidate(); 2118 } 2119 } 2120 2121 // ----------------------------------------------------------------------- 2122 2123 void ValueSet::SetLineCount( sal_uInt16 nNewLines ) 2124 { 2125 if ( mnUserVisLines != nNewLines ) 2126 { 2127 mnUserVisLines = nNewLines; 2128 mbFormat = true; 2129 if ( IsReallyVisible() && IsUpdateMode() ) 2130 Invalidate(); 2131 } 2132 } 2133 2134 // ----------------------------------------------------------------------- 2135 2136 void ValueSet::SetItemWidth( long nNewItemWidth ) 2137 { 2138 if ( mnUserItemWidth != nNewItemWidth ) 2139 { 2140 mnUserItemWidth = nNewItemWidth; 2141 mbFormat = true; 2142 if ( IsReallyVisible() && IsUpdateMode() ) 2143 Invalidate(); 2144 } 2145 } 2146 2147 // ----------------------------------------------------------------------- 2148 2149 void ValueSet::SetItemHeight( long nNewItemHeight ) 2150 { 2151 if ( mnUserItemHeight != nNewItemHeight ) 2152 { 2153 mnUserItemHeight = nNewItemHeight; 2154 mbFormat = true; 2155 if ( IsReallyVisible() && IsUpdateMode() ) 2156 Invalidate(); 2157 } 2158 } 2159 2160 // ----------------------------------------------------------------------- 2161 2162 void ValueSet::SetFirstLine( sal_uInt16 nNewLine ) 2163 { 2164 if ( mnFirstLine != nNewLine ) 2165 { 2166 mnFirstLine = nNewLine; 2167 mbFormat = true; 2168 if ( IsReallyVisible() && IsUpdateMode() ) 2169 Invalidate(); 2170 } 2171 } 2172 2173 // ----------------------------------------------------------------------- 2174 2175 void ValueSet::SelectItem( sal_uInt16 nItemId ) 2176 { 2177 sal_uInt16 nItemPos = 0; 2178 2179 if ( nItemId ) 2180 { 2181 nItemPos = GetItemPos( nItemId ); 2182 if ( nItemPos == VALUESET_ITEM_NOTFOUND ) 2183 return; 2184 if ( mpImpl->mpItemList->GetObject( nItemPos )->meType == VALUESETITEM_SPACE ) 2185 return; 2186 } 2187 2188 if ( (mnSelItemId != nItemId) || mbNoSelection ) 2189 { 2190 sal_uInt16 nOldItem = mnSelItemId ? mnSelItemId : 1; 2191 mnSelItemId = nItemId; 2192 mbNoSelection = false; 2193 2194 sal_Bool bNewOut; 2195 sal_Bool bNewLine; 2196 if ( !mbFormat && IsReallyVisible() && IsUpdateMode() ) 2197 bNewOut = sal_True; 2198 else 2199 bNewOut = sal_False; 2200 bNewLine = sal_False; 2201 2202 // Gegebenenfalls in den sichtbaren Bereich scrollen 2203 if ( mbScroll && nItemId ) 2204 { 2205 sal_uInt16 nNewLine = (sal_uInt16)(nItemPos / mnCols); 2206 if ( nNewLine < mnFirstLine ) 2207 { 2208 mnFirstLine = nNewLine; 2209 bNewLine = sal_True; 2210 } 2211 else if ( nNewLine > (sal_uInt16)(mnFirstLine+mnVisLines-1) ) 2212 { 2213 mnFirstLine = (sal_uInt16)(nNewLine-mnVisLines+1); 2214 bNewLine = sal_True; 2215 } 2216 } 2217 2218 if ( bNewOut ) 2219 { 2220 if ( bNewLine ) 2221 { 2222 // Falls sich der sichtbare Bereich geaendert hat, 2223 // alles neu ausgeben 2224 mbFormat = true; 2225 ImplDraw(); 2226 } 2227 else 2228 { 2229 // alte Selection wegnehmen und neue ausgeben 2230 ImplHideSelect( nOldItem ); 2231 ImplDrawSelect(); 2232 } 2233 } 2234 2235 if( ImplHasAccessibleListeners() ) 2236 { 2237 // focus event (deselect) 2238 if( nOldItem ) 2239 { 2240 const sal_uInt16 nPos = GetItemPos( nItemId ); 2241 2242 if( nPos != VALUESET_ITEM_NOTFOUND ) 2243 { 2244 ValueItemAcc* pItemAcc = ValueItemAcc::getImplementation( 2245 mpImpl->mpItemList->GetObject( nPos )->GetAccessible( mpImpl->mbIsTransientChildrenDisabled ) ); 2246 2247 if( pItemAcc ) 2248 { 2249 ::com::sun::star::uno::Any aOldAny, aNewAny; 2250 if( !mpImpl->mbIsTransientChildrenDisabled) 2251 { 2252 aOldAny <<= ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface >( 2253 static_cast< ::cppu::OWeakObject* >( pItemAcc )); 2254 ImplFireAccessibleEvent (::com::sun::star::accessibility::AccessibleEventId::ACTIVE_DESCENDANT_CHANGED, aOldAny, aNewAny ); 2255 } 2256 else 2257 { 2258 aOldAny <<= ::com::sun::star::accessibility::AccessibleStateType::FOCUSED; 2259 pItemAcc->FireAccessibleEvent( ::com::sun::star::accessibility::AccessibleEventId::STATE_CHANGED, aOldAny, aNewAny ); 2260 } 2261 } 2262 } 2263 } 2264 2265 // focus event (select) 2266 const sal_uInt16 nPos = GetItemPos( mnSelItemId ); 2267 2268 ValueSetItem* pItem; 2269 if( nPos != VALUESET_ITEM_NOTFOUND ) 2270 pItem = mpImpl->mpItemList->GetObject(nPos); 2271 else 2272 pItem = mpNoneItem; 2273 2274 ValueItemAcc* pItemAcc = NULL; 2275 if (pItem != NULL) 2276 pItemAcc = ValueItemAcc::getImplementation(pItem->GetAccessible( mpImpl->mbIsTransientChildrenDisabled ) ); 2277 2278 if( pItemAcc ) 2279 { 2280 ::com::sun::star::uno::Any aOldAny, aNewAny; 2281 if( !mpImpl->mbIsTransientChildrenDisabled) 2282 { 2283 aNewAny <<= ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface >( 2284 static_cast< ::cppu::OWeakObject* >( pItemAcc )); 2285 ImplFireAccessibleEvent( ::com::sun::star::accessibility::AccessibleEventId::ACTIVE_DESCENDANT_CHANGED, aOldAny, aNewAny ); 2286 } 2287 else 2288 { 2289 aNewAny <<= ::com::sun::star::accessibility::AccessibleStateType::FOCUSED; 2290 pItemAcc->FireAccessibleEvent( ::com::sun::star::accessibility::AccessibleEventId::STATE_CHANGED, aOldAny, aNewAny ); 2291 } 2292 } 2293 2294 // selection event 2295 ::com::sun::star::uno::Any aOldAny, aNewAny; 2296 ImplFireAccessibleEvent( ::com::sun::star::accessibility::AccessibleEventId::SELECTION_CHANGED, aOldAny, aNewAny ); 2297 } 2298 mpImpl->maHighlightHdl.Call(this); 2299 } 2300 } 2301 2302 // ----------------------------------------------------------------------- 2303 2304 void ValueSet::SetNoSelection() 2305 { 2306 mbNoSelection = true; 2307 mbHighlight = false; 2308 mbSelection = false; 2309 2310 if ( IsReallyVisible() && IsUpdateMode() ) 2311 ImplDraw(); 2312 } 2313 2314 // ----------------------------------------------------------------------- 2315 2316 void ValueSet::SetItemBits( sal_uInt16 nItemId, sal_uInt16 nItemBits ) 2317 { 2318 sal_uInt16 nPos = GetItemPos( nItemId ); 2319 2320 if ( nPos != VALUESET_ITEM_NOTFOUND ) 2321 mpImpl->mpItemList->GetObject( nPos )->mnBits = nItemBits; 2322 } 2323 2324 // ----------------------------------------------------------------------- 2325 2326 sal_uInt16 ValueSet::GetItemBits( sal_uInt16 nItemId ) const 2327 { 2328 sal_uInt16 nPos = GetItemPos( nItemId ); 2329 2330 if ( nPos != VALUESET_ITEM_NOTFOUND ) 2331 return mpImpl->mpItemList->GetObject( nPos )->mnBits; 2332 else 2333 return 0; 2334 } 2335 2336 // ----------------------------------------------------------------------- 2337 2338 void ValueSet::SetItemImage( sal_uInt16 nItemId, const Image& rImage ) 2339 { 2340 sal_uInt16 nPos = GetItemPos( nItemId ); 2341 2342 if ( nPos == VALUESET_ITEM_NOTFOUND ) 2343 return; 2344 2345 ValueSetItem* pItem = mpImpl->mpItemList->GetObject( nPos ); 2346 pItem->meType = VALUESETITEM_IMAGE; 2347 pItem->maImage = rImage; 2348 2349 if ( !mbFormat && IsReallyVisible() && IsUpdateMode() ) 2350 { 2351 ImplFormatItem( pItem ); 2352 Invalidate( pItem->maRect ); 2353 } 2354 else 2355 mbFormat = true; 2356 } 2357 2358 // ----------------------------------------------------------------------- 2359 2360 Image ValueSet::GetItemImage( sal_uInt16 nItemId ) const 2361 { 2362 sal_uInt16 nPos = GetItemPos( nItemId ); 2363 2364 if ( nPos != VALUESET_ITEM_NOTFOUND ) 2365 return mpImpl->mpItemList->GetObject( nPos )->maImage; 2366 else 2367 return Image(); 2368 } 2369 2370 // ----------------------------------------------------------------------- 2371 2372 void ValueSet::SetItemColor( sal_uInt16 nItemId, const Color& rColor ) 2373 { 2374 sal_uInt16 nPos = GetItemPos( nItemId ); 2375 2376 if ( nPos == VALUESET_ITEM_NOTFOUND ) 2377 return; 2378 2379 ValueSetItem* pItem = mpImpl->mpItemList->GetObject( nPos ); 2380 pItem->meType = VALUESETITEM_COLOR; 2381 pItem->maColor = rColor; 2382 2383 if ( !mbFormat && IsReallyVisible() && IsUpdateMode() ) 2384 { 2385 ImplFormatItem( pItem ); 2386 Invalidate( pItem->maRect ); 2387 } 2388 else 2389 mbFormat = true; 2390 } 2391 2392 // ----------------------------------------------------------------------- 2393 2394 Color ValueSet::GetItemColor( sal_uInt16 nItemId ) const 2395 { 2396 sal_uInt16 nPos = GetItemPos( nItemId ); 2397 2398 if ( nPos != VALUESET_ITEM_NOTFOUND ) 2399 return mpImpl->mpItemList->GetObject( nPos )->maColor; 2400 else 2401 return Color(); 2402 } 2403 2404 // ----------------------------------------------------------------------- 2405 2406 void ValueSet::SetItemData( sal_uInt16 nItemId, void* pData ) 2407 { 2408 sal_uInt16 nPos = GetItemPos( nItemId ); 2409 2410 if ( nPos == VALUESET_ITEM_NOTFOUND ) 2411 return; 2412 2413 ValueSetItem* pItem = mpImpl->mpItemList->GetObject( nPos ); 2414 pItem->mpData = pData; 2415 2416 if ( pItem->meType == VALUESETITEM_USERDRAW ) 2417 { 2418 if ( !mbFormat && IsReallyVisible() && IsUpdateMode() ) 2419 { 2420 ImplFormatItem( pItem ); 2421 Invalidate( pItem->maRect ); 2422 } 2423 else 2424 mbFormat = true; 2425 } 2426 } 2427 2428 // ----------------------------------------------------------------------- 2429 2430 void* ValueSet::GetItemData( sal_uInt16 nItemId ) const 2431 { 2432 sal_uInt16 nPos = GetItemPos( nItemId ); 2433 2434 if ( nPos != VALUESET_ITEM_NOTFOUND ) 2435 return mpImpl->mpItemList->GetObject( nPos )->mpData; 2436 else 2437 return NULL; 2438 } 2439 2440 // ----------------------------------------------------------------------- 2441 2442 void ValueSet::SetItemText( sal_uInt16 nItemId, const XubString& rText ) 2443 { 2444 sal_uInt16 nPos = GetItemPos( nItemId ); 2445 2446 if ( nPos == VALUESET_ITEM_NOTFOUND ) 2447 return; 2448 2449 2450 ValueSetItem* pItem = mpImpl->mpItemList->GetObject( nPos ); 2451 2452 // Remember old and new name for accessibility event. 2453 ::com::sun::star::uno::Any aOldName, aNewName; 2454 ::rtl::OUString sString (pItem->maText); 2455 aOldName <<= sString; 2456 sString = rText; 2457 aNewName <<= sString; 2458 2459 pItem->maText = rText; 2460 2461 if ( !mbFormat && IsReallyVisible() && IsUpdateMode() ) 2462 { 2463 sal_uInt16 nTempId = mnSelItemId; 2464 2465 if ( mbHighlight ) 2466 nTempId = mnHighItemId; 2467 2468 if ( nTempId == nItemId ) 2469 ImplDrawItemText( pItem->maText ); 2470 } 2471 2472 if (ImplHasAccessibleListeners()) 2473 { 2474 ::com::sun::star::uno::Reference< 2475 ::com::sun::star::accessibility::XAccessible> xAccessible ( 2476 pItem->GetAccessible( mpImpl->mbIsTransientChildrenDisabled ) ); 2477 static_cast<ValueItemAcc*>(xAccessible.get())->FireAccessibleEvent ( 2478 ::com::sun::star::accessibility::AccessibleEventId::NAME_CHANGED, 2479 aOldName, aNewName); 2480 } 2481 } 2482 2483 // ----------------------------------------------------------------------- 2484 2485 XubString ValueSet::GetItemText( sal_uInt16 nItemId ) const 2486 { 2487 sal_uInt16 nPos = GetItemPos( nItemId ); 2488 2489 if ( nPos != VALUESET_ITEM_NOTFOUND ) 2490 return mpImpl->mpItemList->GetObject( nPos )->maText; 2491 else 2492 return XubString(); 2493 } 2494 2495 // ----------------------------------------------------------------------- 2496 2497 void ValueSet::SetColor( const Color& rColor ) 2498 { 2499 maColor = rColor; 2500 mbFormat = true; 2501 if ( IsReallyVisible() && IsUpdateMode() ) 2502 ImplDraw(); 2503 } 2504 2505 // ----------------------------------------------------------------------- 2506 2507 void ValueSet::SetExtraSpacing( sal_uInt16 nNewSpacing ) 2508 { 2509 if ( GetStyle() & WB_ITEMBORDER ) 2510 { 2511 mnSpacing = nNewSpacing; 2512 2513 mbFormat = true; 2514 if ( IsReallyVisible() && IsUpdateMode() ) 2515 Invalidate(); 2516 } 2517 } 2518 2519 // ----------------------------------------------------------------------- 2520 2521 void ValueSet::StartSelection() 2522 { 2523 mnOldItemId = mnSelItemId; 2524 mbHighlight = true; 2525 mbSelection = true; 2526 mnHighItemId = mnSelItemId; 2527 } 2528 2529 // ----------------------------------------------------------------------- 2530 2531 void ValueSet::EndSelection() 2532 { 2533 if ( mbHighlight ) 2534 { 2535 if ( IsTracking() ) 2536 EndTracking( ENDTRACK_CANCEL ); 2537 2538 ImplHighlightItem( mnSelItemId ); 2539 mbHighlight = false; 2540 } 2541 mbSelection = false; 2542 } 2543 2544 // ----------------------------------------------------------------------- 2545 2546 sal_Bool ValueSet::StartDrag( const CommandEvent& rCEvt, Region& rRegion ) 2547 { 2548 if ( rCEvt.GetCommand() != COMMAND_STARTDRAG ) 2549 return sal_False; 2550 2551 // Gegebenenfalls eine vorhandene Aktion abbrechen 2552 EndSelection(); 2553 2554 // Testen, ob angeklickte Seite selektiert ist. Falls dies nicht 2555 // der Fall ist, setzen wir ihn als aktuellen Eintrag. Falls Drag and 2556 // Drop auch mal ueber Tastatur ausgeloest werden kann, testen wir 2557 // dies nur bei einer Mausaktion. 2558 sal_uInt16 nSelId; 2559 if ( rCEvt.IsMouseEvent() ) 2560 nSelId = GetItemId( rCEvt.GetMousePosPixel() ); 2561 else 2562 nSelId = mnSelItemId; 2563 2564 // Falls kein Eintrag angeklickt wurde, starten wir kein Dragging 2565 if ( !nSelId ) 2566 return sal_False; 2567 2568 // Testen, ob Seite selektiertiert ist. Falls nicht, als aktuelle 2569 // Seite setzen und Select rufen. 2570 if ( nSelId != mnSelItemId ) 2571 { 2572 SelectItem( nSelId ); 2573 Update(); 2574 Select(); 2575 } 2576 2577 Region aRegion; 2578 2579 // Region zuweisen 2580 rRegion = aRegion; 2581 2582 return sal_True; 2583 } 2584 2585 // ----------------------------------------------------------------------- 2586 2587 Size ValueSet::CalcWindowSizePixel( const Size& rItemSize, sal_uInt16 nDesireCols, 2588 sal_uInt16 nDesireLines ) 2589 { 2590 long nCalcCols = (long)nDesireCols; 2591 long nCalcLines = (long)nDesireLines; 2592 2593 if ( !nCalcCols ) 2594 { 2595 if ( mnUserCols ) 2596 nCalcCols = (long)mnUserCols; 2597 else 2598 nCalcCols = 1; 2599 } 2600 2601 if ( !nCalcLines ) 2602 { 2603 nCalcLines = mnVisLines; 2604 2605 if ( mbFormat ) 2606 { 2607 if ( mnUserVisLines ) 2608 nCalcLines = mnUserVisLines; 2609 else 2610 { 2611 nCalcLines = (long)mpImpl->mpItemList->Count() / nCalcCols; 2612 if ( mpImpl->mpItemList->Count() % nCalcCols ) 2613 nCalcLines++; 2614 else if ( !nCalcLines ) 2615 nCalcLines = 1; 2616 } 2617 } 2618 } 2619 2620 Size aSize( rItemSize.Width()*nCalcCols, rItemSize.Height()*nCalcLines ); 2621 WinBits nStyle = GetStyle(); 2622 long nTxtHeight = GetTextHeight(); 2623 long nSpace; 2624 long n; 2625 2626 if ( nStyle & WB_ITEMBORDER ) 2627 { 2628 if ( nStyle & WB_DOUBLEBORDER ) 2629 n = ITEM_OFFSET_DOUBLE; 2630 else 2631 n = ITEM_OFFSET; 2632 2633 aSize.Width() += n*nCalcCols; 2634 aSize.Height() += n*nCalcLines; 2635 } 2636 else 2637 n = 0; 2638 2639 if ( mnSpacing ) 2640 { 2641 nSpace = mnSpacing; 2642 aSize.Width() += mnSpacing*(nCalcCols-1); 2643 aSize.Height() += mnSpacing*(nCalcLines-1); 2644 } 2645 else 2646 nSpace = 0; 2647 2648 if ( nStyle & WB_NAMEFIELD ) 2649 { 2650 aSize.Height() += nTxtHeight + NAME_OFFSET; 2651 if ( !(nStyle & WB_FLATVALUESET) ) 2652 aSize.Height() += NAME_LINE_HEIGHT+NAME_LINE_OFF_Y; 2653 } 2654 2655 if ( nStyle & WB_NONEFIELD ) 2656 { 2657 aSize.Height() += nTxtHeight + n + nSpace; 2658 if ( nStyle & WB_RADIOSEL ) 2659 aSize.Height() += 8; 2660 } 2661 2662 // Evt. ScrollBar-Breite aufaddieren 2663 aSize.Width() += GetScrollWidth(); 2664 2665 return aSize; 2666 } 2667 2668 // ----------------------------------------------------------------------- 2669 2670 Size ValueSet::CalcItemSizePixel( const Size& rItemSize, bool bOut ) const 2671 { 2672 Size aSize = rItemSize; 2673 2674 WinBits nStyle = GetStyle(); 2675 if ( nStyle & WB_ITEMBORDER ) 2676 { 2677 long n; 2678 2679 if ( nStyle & WB_DOUBLEBORDER ) 2680 n = ITEM_OFFSET_DOUBLE; 2681 else 2682 n = ITEM_OFFSET; 2683 2684 if ( bOut ) 2685 { 2686 aSize.Width() += n; 2687 aSize.Height() += n; 2688 } 2689 else 2690 { 2691 aSize.Width() -= n; 2692 aSize.Height() -= n; 2693 } 2694 } 2695 2696 return aSize; 2697 } 2698 2699 // ----------------------------------------------------------------------- 2700 2701 long ValueSet::GetScrollWidth() const 2702 { 2703 if ( GetStyle() & WB_VSCROLL ) 2704 { 2705 ((ValueSet*)this)->ImplInitScrollBar(); 2706 return mpScrBar->GetSizePixel().Width()+SCRBAR_OFFSET; 2707 } 2708 else 2709 return 0; 2710 } 2711 2712 // ----------------------------------------------------------------------- 2713 2714 sal_uInt16 ValueSet::ShowDropPos( const Point& rPos ) 2715 { 2716 mbDropPos = true; 2717 2718 // Gegebenenfalls scrollen 2719 ImplScroll( rPos ); 2720 2721 // DropPosition ermitteln 2722 sal_uInt16 nPos = ImplGetItem( rPos, sal_True ); 2723 if ( nPos == VALUESET_ITEM_NONEITEM ) 2724 nPos = 0; 2725 else if ( nPos == VALUESET_ITEM_NOTFOUND ) 2726 { 2727 Size aOutSize = GetOutputSizePixel(); 2728 if ( GetStyle() & WB_NAMEFIELD ) 2729 aOutSize.Height() = mnTextOffset; 2730 if ( (rPos.X() >= 0) && (rPos.X() < aOutSize.Width()) && 2731 (rPos.Y() >= 0) && (rPos.Y() < aOutSize.Height()) ) 2732 nPos = (sal_uInt16)mpImpl->mpItemList->Count(); 2733 } 2734 else 2735 { 2736 // Im letzten viertel, dann wird ein Item spaeter eingefuegt 2737 Rectangle aRect = mpImpl->mpItemList->GetObject( nPos )->maRect; 2738 if ( rPos.X() > aRect.Left()+aRect.GetWidth()-(aRect.GetWidth()/4) ) 2739 nPos++; 2740 } 2741 2742 if ( nPos != mnDropPos ) 2743 { 2744 ImplDrawDropPos( sal_False ); 2745 mnDropPos = nPos; 2746 ImplDrawDropPos( sal_True ); 2747 } 2748 2749 return mnDropPos; 2750 } 2751 2752 // ----------------------------------------------------------------------- 2753 2754 void ValueSet::HideDropPos() 2755 { 2756 if ( mbDropPos ) 2757 { 2758 ImplDrawDropPos( sal_False ); 2759 mbDropPos = false; 2760 } 2761 } 2762 2763 // ----------------------------------------------------------------------- 2764 2765 bool ValueSet::IsRTLActive (void) 2766 { 2767 return Application::GetSettings().GetLayoutRTL() && IsRTLEnabled(); 2768 } 2769 2770 // ----------------------------------------------------------------------- 2771 2772 void ValueSet::SetHighlightHdl( const Link& rLink ) 2773 { 2774 mpImpl->maHighlightHdl = rLink; 2775 } 2776 2777 // ----------------------------------------------------------------------- 2778 2779 const Link& ValueSet::GetHighlightHdl() const 2780 { 2781 return mpImpl->maHighlightHdl; 2782 } 2783 2784 // ----------------------------------------------------------------------- 2785 2786 void ValueSet::SetEdgeBlending(bool bNew) 2787 { 2788 if(mbEdgeBlending != bNew) 2789 { 2790 mbEdgeBlending = bNew; 2791 mbFormat = true; 2792 2793 if(IsReallyVisible() && IsUpdateMode()) 2794 { 2795 Invalidate(); 2796 } 2797 } 2798 } 2799 //For sending out the focused event on the first focused item when this valueset is first focused. 2800 // MT: Focus notifications changed in DEV300 meanwhile, so this is not used for now. 2801 // Just keeping it here for reference, in case something in out implementation doesn't work as expected... 2802 /* 2803 void ValueSet::SetFocusedItem(sal_Bool bFocused) 2804 { 2805 if( ImplHasAccessibleListeners() ) 2806 { 2807 // selection event 2808 ::com::sun::star::uno::Any aSelOldAny, aSelNewAny; 2809 if ( mnSelItemId >= 0) 2810 { 2811 // focus event (select) 2812 sal_uInt16 nPos = GetItemPos( mnSelItemId ); 2813 2814 ValueSetItem* pItem; 2815 if ((GetStyle() & WB_NONEFIELD) != 0 2816 && nPos == VALUESET_ITEM_NOTFOUND 2817 && mnSelItemId == 0) 2818 { 2819 // When present the first item is the then allways visible none field. 2820 pItem = ImplGetItem (VALUESET_ITEM_NONEITEM); 2821 } 2822 else 2823 { 2824 if (nPos == VALUESET_ITEM_NOTFOUND) 2825 nPos = 0; 2826 pItem = mpImpl->mpItemList->GetObject(nPos); 2827 } 2828 ValueItemAcc* pItemAcc = NULL; 2829 if (pItem != NULL) 2830 pItemAcc = ValueItemAcc::getImplementation(pItem->GetAccessible(mpImpl->mbIsTransientChildrenDisabled) ); 2831 if( pItemAcc ) 2832 { 2833 if (bFocused) 2834 aSelNewAny <<= pItem->GetAccessible(mpImpl->mbIsTransientChildrenDisabled); 2835 else 2836 aSelOldAny <<= pItem->GetAccessible(mpImpl->mbIsTransientChildrenDisabled); 2837 } 2838 ImplFireAccessibleEvent( ::com::sun::star::accessibility::AccessibleEventId::ACTIVE_DESCENDANT_CHANGED, aSelOldAny, aSelNewAny ); 2839 if (pItemAcc && bFocused) 2840 { 2841 pItemAcc->FireAccessibleEvent( 2842 ::com::sun::star::accessibility::AccessibleEventId::SELECTION_CHANGED, 2843 ::com::sun::star::uno::Any(),::com::sun::star::uno::Any()); 2844 } 2845 } 2846 } 2847 } 2848 */ 2849 //end 2850 2851 2852 // ----------------------------------------------------------------------- 2853 // eof 2854