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