vcl/source/control/lstbox.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: lstbox.cxx,v $
  10  * $Revision: 1.43 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_vcl.hxx"
  33
  34 #include "tools/rc.h"
  35
  36 #include "vcl/svdata.hxx"
  37 #include "vcl/decoview.hxx"
  38 #include "vcl/event.hxx"
  39 #include "vcl/scrbar.hxx"
  40 #include "vcl/button.hxx"
  41 #include "vcl/edit.hxx"
  42 #include "vcl/subedit.hxx"
  43 #include "vcl/ilstbox.hxx"
  44 #include "vcl/lstbox.hxx"
  45 #include "vcl/combobox.hxx"
  46 #include "vcl/controllayout.hxx"
  47
  48 #include "tools/debug.hxx"
  49
  50
  51
  52 \f// =======================================================================
  53
  54 ListBox::ListBox( WindowType nType ) : Control( nType )
  55 {
  56     ImplInitListBoxData();
  57 }
  58
  59 // -----------------------------------------------------------------------
  60
  61 ListBox::ListBox( Window* pParent, WinBits nStyle ) : Control( WINDOW_LISTBOX )
  62 {
  63     ImplInitListBoxData();
  64     ImplInit( pParent, nStyle );
  65 }
  66
  67 // -----------------------------------------------------------------------
  68
  69 ListBox::ListBox( Window* pParent, const ResId& rResId ) :
  70     Control( WINDOW_LISTBOX )
  71 {
  72     ImplInitListBoxData();
  73     rResId.SetRT( RSC_LISTBOX );
  74     WinBits nStyle = ImplInitRes( rResId );
  75     ImplInit( pParent, nStyle );
  76     ImplLoadRes( rResId );
  77
  78     if ( !(nStyle & WB_HIDE ) )
  79         Show();
  80 }
  81
  82 // -----------------------------------------------------------------------
  83
  84 ListBox::~ListBox()
  85 {
  86     //#109201#
  87     ImplCallEventListeners( VCLEVENT_OBJECT_DYING );
  88
  89     delete mpImplLB;
  90
  91     // Beim zerstoeren des FloatWins macht TH ein GrabFocus auf den Parent,
  92     // also diese ListBox => PreNotify()...
  93     mpImplLB = NULL;
  94
  95     delete mpFloatWin;
  96     delete mpImplWin;
  97     delete mpBtn;
  98 }
  99
 100 // -----------------------------------------------------------------------
 101
 102 void ListBox::ImplInitListBoxData()
 103 {
 104     mpFloatWin          = NULL;
 105     mpImplWin           = NULL;
 106     mpBtn                       = NULL;
 107
 108     mnDDHeight          = 0;
 109     mbDDAutoSize        = TRUE;
 110     mnSaveValue         = LISTBOX_ENTRY_NOTFOUND;
 111 }
 112
 113 // -----------------------------------------------------------------------
 114
 115 void ListBox::ImplInit( Window* pParent, WinBits nStyle )
 116 {
 117     nStyle = ImplInitStyle( nStyle );
 118     if ( !(nStyle & WB_NOBORDER) && ( nStyle & WB_DROPDOWN ) )
 119         nStyle |= WB_BORDER;
 120
 121     Control::ImplInit( pParent, nStyle, NULL );
 122     SetBackground();
 123
 124     if( nStyle & WB_DROPDOWN )
 125     {
 126         sal_Int32 nLeft, nTop, nRight, nBottom;
 127         GetBorder( nLeft, nTop, nRight, nBottom );
 128         mnDDHeight = (USHORT)(GetTextHeight() + nTop + nBottom + 4);
 129
 130         if( IsNativeWidgetEnabled() &&
 131             IsNativeControlSupported( CTRL_LISTBOX, PART_ENTIRE_CONTROL ) )
 132         {
 133                 ImplControlValue aControlValue;
 134                 Region aCtrlRegion( Rectangle( (const Point&)Point(), Size( 20, mnDDHeight ) ) );
 135                 Region aBoundingRgn( aCtrlRegion );
 136                 Region aContentRgn( aCtrlRegion );
 137                 if( GetNativeControlRegion( CTRL_LISTBOX, PART_ENTIRE_CONTROL, aCtrlRegion,
 138                                             CTRL_STATE_ENABLED, aControlValue, rtl::OUString(),
 139                                             aBoundingRgn, aContentRgn ) )
 140                 {
 141                     sal_Int32 nHeight = aBoundingRgn.GetBoundRect().GetHeight();
 142                     if( nHeight > mnDDHeight )
 143                         mnDDHeight = static_cast<USHORT>(nHeight);
 144                 }
 145         }
 146
 147         mpFloatWin = new ImplListBoxFloatingWindow( this );
 148         mpFloatWin->SetAutoWidth( TRUE );
 149         mpFloatWin->SetPopupModeEndHdl( LINK( this, ListBox, ImplPopupModeEndHdl ) );
 150
 151         mpImplWin = new ImplWin( this, (nStyle & (WB_LEFT|WB_RIGHT|WB_CENTER))|WB_NOBORDER );
 152         mpImplWin->SetMBDownHdl( LINK( this, ListBox, ImplClickBtnHdl ) );
 153         mpImplWin->SetUserDrawHdl( LINK( this, ListBox, ImplUserDrawHdl ) );
 154         mpImplWin->Show();
 155
 156         mpBtn = new ImplBtn( this, WB_NOLIGHTBORDER | WB_RECTSTYLE );
 157         ImplInitDropDownButton( mpBtn );
 158         mpBtn->SetMBDownHdl( LINK( this, ListBox, ImplClickBtnHdl ) );
 159         mpBtn->Show();
 160
 161     }
 162
 163     Window* pLBParent = this;
 164     if ( mpFloatWin )
 165         pLBParent = mpFloatWin;
 166     mpImplLB = new ImplListBox( pLBParent, nStyle&(~WB_BORDER) );
 167     mpImplLB->SetSelectHdl( LINK( this, ListBox, ImplSelectHdl ) );
 168     mpImplLB->SetScrollHdl( LINK( this, ListBox, ImplScrollHdl ) );
 169     mpImplLB->SetCancelHdl( LINK( this, ListBox, ImplCancelHdl ) );
 170     mpImplLB->SetDoubleClickHdl( LINK( this, ListBox, ImplDoubleClickHdl ) );
 171     mpImplLB->SetUserDrawHdl( LINK( this, ListBox, ImplUserDrawHdl ) );
 172     mpImplLB->SetPosPixel( Point() );
 173     mpImplLB->Show();
 174
 175     if ( mpFloatWin )
 176     {
 177         mpFloatWin->SetImplListBox( mpImplLB );
 178         mpImplLB->SetSelectionChangedHdl( LINK( this, ListBox, ImplSelectionChangedHdl ) );
 179     }
 180     else
 181         mpImplLB->GetMainWindow()->AllowGrabFocus( TRUE );
 182
 183     SetCompoundControl( TRUE );
 184 }
 185
 186 // -----------------------------------------------------------------------
 187
 188 WinBits ListBox::ImplInitStyle( WinBits nStyle )
 189 {
 190     if ( !(nStyle & WB_NOTABSTOP) )
 191         nStyle |= WB_TABSTOP;
 192     if ( !(nStyle & WB_NOGROUP) )
 193         nStyle |= WB_GROUP;
 194     return nStyle;
 195 }
 196
 197 // -----------------------------------------------------------------------
 198
 199 void ListBox::ImplLoadRes( const ResId& rResId )
 200 {
 201     Control::ImplLoadRes( rResId );
 202
 203     USHORT nSelPos = ReadShortRes();
 204     USHORT nNumber = sal::static_int_cast<USHORT>(ReadLongRes());
 205
 206     for( USHORT i = 0; i < nNumber; i++ )
 207     {
 208         USHORT nPos = InsertEntry( ReadStringRes(), LISTBOX_APPEND );
 209
 210         long nId = ReadLongRes();
 211         if( nId )
 212             SetEntryData( nPos, (void *)nId );  // ID als UserData
 213     }
 214
 215     if( nSelPos < nNumber )
 216         SelectEntryPos( nSelPos );
 217 }
 218
 219 // -----------------------------------------------------------------------
 220
 221 IMPL_LINK( ListBox, ImplSelectHdl, void*, EMPTYARG )
 222 {
 223     BOOL bPopup = IsInDropDown();
 224     if( IsDropDownBox() )
 225     {
 226         if( !mpImplLB->IsTravelSelect() )
 227         {
 228             mpFloatWin->EndPopupMode();
 229             mpImplWin->GrabFocus();
 230         }
 231
 232         mpImplWin->SetItemPos( GetSelectEntryPos() );
 233         mpImplWin->SetString( GetSelectEntry() );
 234         if( mpImplLB->GetEntryList()->HasImages() )
 235         {
 236             Image aImage = mpImplLB->GetEntryList()->GetEntryImage( GetSelectEntryPos() );
 237             mpImplWin->SetImage( aImage );
 238         }
 239         mpImplWin->Invalidate();
 240     }
 241
 242     if ( ( !IsTravelSelect() || mpImplLB->IsSelectionChanged() ) || ( bPopup && !IsMultiSelectionEnabled() ) )
 243         Select();
 244
 245     return 1;
 246 }
 247
 248 // -----------------------------------------------------------------------
 249
 250 IMPL_LINK( ListBox, ImplScrollHdl, void*, EMPTYARG )
 251 {
 252     ImplCallEventListeners( VCLEVENT_LISTBOX_SCROLLED );
 253     return 1;
 254 }
 255
 256 // -----------------------------------------------------------------------
 257
 258 IMPL_LINK( ListBox, ImplCancelHdl, void*, EMPTYARG )
 259 {
 260     if( IsInDropDown() )
 261         mpFloatWin->EndPopupMode();
 262
 263     return 1;
 264 }
 265
 266 // -----------------------------------------------------------------------
 267
 268 IMPL_LINK( ListBox, ImplSelectionChangedHdl, void*, n )
 269 {
 270     if ( !mpImplLB->IsTrackingSelect() )
 271     {
 272         USHORT nChanged = (USHORT)(ULONG)n;
 273         const ImplEntryList* pEntryList = mpImplLB->GetEntryList();
 274         if ( pEntryList->IsEntryPosSelected( nChanged ) )
 275         {
 276             // Sollte mal ein ImplPaintEntry werden...
 277             if ( nChanged < pEntryList->GetMRUCount() )
 278                 nChanged = pEntryList->FindEntry( pEntryList->GetEntryText( nChanged ) );
 279             mpImplWin->SetItemPos( nChanged );
 280             mpImplWin->SetString( mpImplLB->GetEntryList()->GetEntryText( nChanged ) );
 281             if( mpImplLB->GetEntryList()->HasImages() )
 282             {
 283                 Image aImage = mpImplLB->GetEntryList()->GetEntryImage( nChanged );
 284                 mpImplWin->SetImage( aImage );
 285             }
 286             mpImplWin->Invalidate();
 287         }
 288     }
 289     return 1;
 290 }
 291
 292 // -----------------------------------------------------------------------
 293
 294 IMPL_LINK( ListBox, ImplDoubleClickHdl, void*, EMPTYARG )
 295 {
 296     DoubleClick();
 297     return 1;
 298 }
 299
 300 // -----------------------------------------------------------------------
 301
 302 IMPL_LINK( ListBox, ImplClickBtnHdl, void*, EMPTYARG )
 303 {
 304     if( !mpFloatWin->IsInPopupMode() )
 305     {
 306         ImplCallEventListeners( VCLEVENT_DROPDOWN_PRE_OPEN );
 307         mpImplWin->GrabFocus();
 308         mpBtn->SetPressed( TRUE );
 309         mpFloatWin->StartFloat( TRUE );
 310         ImplCallEventListeners( VCLEVENT_DROPDOWN_OPEN );
 311
 312         ImplClearLayoutData();
 313         if( mpImplLB )
 314             mpImplLB->GetMainWindow()->ImplClearLayoutData();
 315         if( mpImplWin )
 316             mpImplWin->ImplClearLayoutData();
 317     }
 318
 319     return 0;
 320 }
 321
 322 // -----------------------------------------------------------------------
 323
 324 IMPL_LINK( ListBox, ImplPopupModeEndHdl, void*, EMPTYARG )
 325 {
 326     if( mpFloatWin->IsPopupModeCanceled() )
 327     {
 328         if ( ( mpFloatWin->GetPopupModeStartSaveSelection() != LISTBOX_ENTRY_NOTFOUND )
 329                 && !IsEntryPosSelected( mpFloatWin->GetPopupModeStartSaveSelection() ) )
 330         {
 331             mpImplLB->SelectEntry( mpFloatWin->GetPopupModeStartSaveSelection(), TRUE );
 332             BOOL bTravelSelect = mpImplLB->IsTravelSelect();
 333             mpImplLB->SetTravelSelect( TRUE );
 334
 335             ImplDelData aCheckDelete;
 336             ImplAddDel( &aCheckDelete );
 337             Select();
 338             if ( aCheckDelete.IsDelete() )
 339                 return 0;
 340             ImplRemoveDel( &aCheckDelete );
 341
 342             mpImplLB->SetTravelSelect( bTravelSelect );
 343         }
 344     }
 345
 346     ImplClearLayoutData();
 347     if( mpImplLB )
 348         mpImplLB->GetMainWindow()->ImplClearLayoutData();
 349     if( mpImplWin )
 350         mpImplWin->ImplClearLayoutData();
 351
 352     mpBtn->SetPressed( FALSE );
 353     ImplCallEventListeners( VCLEVENT_DROPDOWN_CLOSE );
 354     return 0;
 355 }
 356
 357 // -----------------------------------------------------------------------
 358
 359 void ListBox::ToggleDropDown()
 360 {
 361     if( IsDropDownBox() )
 362     {
 363         if( mpFloatWin->IsInPopupMode() )
 364             mpFloatWin->EndPopupMode();
 365         else
 366         {
 367             ImplCallEventListeners( VCLEVENT_DROPDOWN_PRE_OPEN );
 368             mpImplWin->GrabFocus();
 369             mpBtn->SetPressed( TRUE );
 370             mpFloatWin->StartFloat( TRUE );
 371             ImplCallEventListeners( VCLEVENT_DROPDOWN_OPEN );
 372         }
 373     }
 374 }
 375
 376 // -----------------------------------------------------------------------
 377
 378 void ListBox::Draw( OutputDevice* pDev, const Point& rPos, const Size& rSize, ULONG nFlags )
 379 {
 380     mpImplLB->GetMainWindow()->ImplInitSettings( TRUE, TRUE, TRUE );
 381
 382     Point aPos = pDev->LogicToPixel( rPos );
 383     Size aSize = pDev->LogicToPixel( rSize );
 384     Font aFont = mpImplLB->GetMainWindow()->GetDrawPixelFont( pDev );
 385     OutDevType eOutDevType = pDev->GetOutDevType();
 386
 387     pDev->Push();
 388     pDev->SetMapMode();
 389     pDev->SetFont( aFont );
 390     pDev->SetTextFillColor();
 391
 392     // Border/Background
 393     pDev->SetLineColor();
 394     pDev->SetFillColor();
 395     BOOL bBorder = !(nFlags & WINDOW_DRAW_NOBORDER ) && (GetStyle() & WB_BORDER);
 396     BOOL bBackground = !(nFlags & WINDOW_DRAW_NOBACKGROUND) && IsControlBackground();
 397     if ( bBorder || bBackground )
 398     {
 399         Rectangle aRect( aPos, aSize );
 400         if ( bBorder )
 401         {
 402             ImplDrawFrame( pDev, aRect );
 403         }
 404         if ( bBackground )
 405         {
 406             pDev->SetFillColor( GetControlBackground() );
 407             pDev->DrawRect( aRect );
 408         }
 409     }
 410
 411     // Inhalt
 412     if ( ( nFlags & WINDOW_DRAW_MONO ) || ( eOutDevType == OUTDEV_PRINTER ) )
 413     {
 414         pDev->SetTextColor( Color( COL_BLACK ) );
 415     }
 416     else
 417     {
 418         if ( !(nFlags & WINDOW_DRAW_NODISABLE ) && !IsEnabled() )
 419         {
 420             const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
 421             pDev->SetTextColor( rStyleSettings.GetDisableColor() );
 422         }
 423         else
 424         {
 425             pDev->SetTextColor( GetTextColor() );
 426         }
 427     }
 428
 429     long        nOnePixel = GetDrawPixel( pDev, 1 );
 430     USHORT      nTextStyle = TEXT_DRAW_VCENTER;
 431     Rectangle   aTextRect( aPos, aSize );
 432
 433     if ( GetStyle() & WB_CENTER )
 434         nTextStyle |= TEXT_DRAW_CENTER;
 435     else if ( GetStyle() & WB_RIGHT )
 436         nTextStyle |= TEXT_DRAW_RIGHT;
 437     else
 438         nTextStyle |= TEXT_DRAW_LEFT;
 439
 440     aTextRect.Left() += 3*nOnePixel;
 441     aTextRect.Right() -= 3*nOnePixel;
 442
 443     if ( IsDropDownBox() )
 444     {
 445         XubString       aText = GetSelectEntry();
 446         long            nTextHeight = pDev->GetTextHeight();
 447         long            nTextWidth = pDev->GetTextWidth( aText );
 448         long            nOffX = 3*nOnePixel;
 449         long            nOffY = (aSize.Height()-nTextHeight) / 2;
 450
 451         // Clipping?
 452         if ( (nOffY < 0) ||
 453              ((nOffY+nTextHeight) > aSize.Height()) ||
 454              ((nOffX+nTextWidth) > aSize.Width()) )
 455         {
 456             Rectangle aClip( aPos, aSize );
 457             if ( nTextHeight > aSize.Height() )
 458                 aClip.Bottom() += nTextHeight-aSize.Height()+1;  // Damit HP-Drucker nicht 'weg-optimieren'
 459             pDev->IntersectClipRegion( aClip );
 460         }
 461
 462         pDev->DrawText( aTextRect, aText, nTextStyle );
 463     }
 464     else
 465     {
 466         long            nTextHeight = pDev->GetTextHeight();
 467         USHORT          nLines = (USHORT)(aSize.Height() / nTextHeight);
 468         Rectangle       aClip( aPos, aSize );
 469
 470         pDev->IntersectClipRegion( aClip );
 471
 472         if ( !nLines )
 473             nLines = 1;
 474
 475         for ( USHORT n = 0; n < nLines; n++ )
 476         {
 477             USHORT nEntry = n+mpImplLB->GetTopEntry();
 478             BOOL bSelected = mpImplLB->GetEntryList()->IsEntryPosSelected( nEntry );
 479             if ( bSelected )
 480             {
 481                 pDev->SetFillColor( COL_BLACK );
 482                 pDev->DrawRect( Rectangle(      Point( aPos.X(), aPos.Y() + n*nTextHeight ),
 483                                             Point( aPos.X() + aSize.Width(), aPos.Y() + (n+1)*nTextHeight + 2*nOnePixel ) ) );
 484                 pDev->SetFillColor();
 485                 pDev->SetTextColor( COL_WHITE );
 486             }
 487
 488             aTextRect.Top() = aPos.Y() + n*nTextHeight;
 489             aTextRect.Bottom() = aTextRect.Top() + nTextHeight;
 490
 491             pDev->DrawText( aTextRect, mpImplLB->GetEntryList()->GetEntryText( nEntry ), nTextStyle );
 492
 493             if ( bSelected )
 494                 pDev->SetTextColor( COL_BLACK );
 495         }
 496     }
 497
 498     pDev->Pop();
 499 }
 500
 501 // -----------------------------------------------------------------------
 502
 503 void ListBox::GetFocus()
 504 {
 505     if ( mpImplLB )
 506     {
 507         if( IsDropDownBox() )
 508             mpImplWin->GrabFocus();
 509         else
 510             mpImplLB->GrabFocus();
 511     }
 512
 513     Control::GetFocus();
 514 }
 515
 516 // -----------------------------------------------------------------------
 517
 518 Window* ListBox::GetPreferredKeyInputWindow()
 519 {
 520     if ( mpImplLB )
 521     {
 522         if( IsDropDownBox() )
 523             return mpImplWin->GetPreferredKeyInputWindow();
 524         else
 525             return mpImplLB->GetPreferredKeyInputWindow();
 526     }
 527
 528     return Control::GetPreferredKeyInputWindow();
 529 }
 530
 531 // -----------------------------------------------------------------------
 532
 533 void ListBox::LoseFocus()
 534 {
 535     if( IsDropDownBox() )
 536         mpImplWin->HideFocus();
 537     else
 538         mpImplLB->HideFocus();
 539
 540     Control::LoseFocus();
 541 }
 542
 543 // -----------------------------------------------------------------------
 544
 545 void ListBox::DataChanged( const DataChangedEvent& rDCEvt )
 546 {
 547     Control::DataChanged( rDCEvt );
 548
 549     if ( (rDCEvt.GetType() == DATACHANGED_FONTS) ||
 550          (rDCEvt.GetType() == DATACHANGED_FONTSUBSTITUTION) ||
 551          ((rDCEvt.GetType() == DATACHANGED_SETTINGS) &&
 552           (rDCEvt.GetFlags() & SETTINGS_STYLE)) )
 553     {
 554         SetBackground();    // due to a hack in Window::UpdateSettings the background must be reset
 555                             // otherwise it will overpaint NWF drawn listboxes
 556         Resize();
 557         mpImplLB->Resize(); // Wird nicht durch ListBox::Resize() gerufen, wenn sich die ImplLB nicht aendert.
 558
 559         if ( mpImplWin )
 560         {
 561             mpImplWin->SetSettings( GetSettings() );    // Falls noch nicht eingestellt...
 562             ImplInitFieldSettings( mpImplWin, TRUE, TRUE, TRUE );
 563
 564             mpBtn->SetSettings( GetSettings() );
 565             ImplInitDropDownButton( mpBtn );
 566         }
 567
 568
 569         if ( IsDropDownBox() )
 570             Invalidate();
 571     }
 572 }
 573
 574 // -----------------------------------------------------------------------
 575
 576 void ListBox::EnableAutoSize( BOOL bAuto )
 577 {
 578     mbDDAutoSize = bAuto;
 579     if ( mpFloatWin )
 580     {
 581         if ( bAuto && !mpFloatWin->GetDropDownLineCount() )
 582             mpFloatWin->SetDropDownLineCount( 5 );
 583         else if ( !bAuto )
 584             mpFloatWin->SetDropDownLineCount( 0 );
 585     }
 586 }
 587
 588 // -----------------------------------------------------------------------
 589
 590 void ListBox::EnableDDAutoWidth( BOOL b )
 591 {
 592     if ( mpFloatWin )
 593         mpFloatWin->SetAutoWidth( b );
 594 }
 595
 596 // -----------------------------------------------------------------------
 597
 598 BOOL ListBox::IsDDAutoWidthEnabled() const
 599 {
 600     return mpFloatWin ? mpFloatWin->IsAutoWidth() : FALSE;
 601 }
 602
 603 // -----------------------------------------------------------------------
 604
 605 void ListBox::SetDropDownLineCount( USHORT nLines )
 606 {
 607     mnLineCount = nLines;
 608     if ( mpFloatWin )
 609         mpFloatWin->SetDropDownLineCount( mnLineCount );
 610 }
 611
 612 // -----------------------------------------------------------------------
 613
 614 USHORT ListBox::GetDropDownLineCount() const
 615 {
 616     if ( mpFloatWin )
 617         return mpFloatWin->GetDropDownLineCount();
 618     return mnLineCount;
 619 }
 620
 621 // -----------------------------------------------------------------------
 622
 623 void ListBox::SetPosSizePixel( long nX, long nY, long nWidth, long nHeight, USHORT nFlags )
 624 {
 625     if( IsDropDownBox() && ( nFlags & WINDOW_POSSIZE_SIZE ) )
 626     {
 627         Size aPrefSz = mpFloatWin->GetPrefSize();
 628         if ( ( nFlags & WINDOW_POSSIZE_HEIGHT ) && ( nHeight >= 2*mnDDHeight ) )
 629             aPrefSz.Height() = nHeight-mnDDHeight;
 630         if ( nFlags & WINDOW_POSSIZE_WIDTH )
 631             aPrefSz.Width() = nWidth;
 632         mpFloatWin->SetPrefSize( aPrefSz );
 633
 634         if ( IsAutoSizeEnabled() && ! (nFlags & WINDOW_POSSIZE_DROPDOWN) )
 635             nHeight = mnDDHeight;
 636     }
 637
 638     Control::SetPosSizePixel( nX, nY, nWidth, nHeight, nFlags );
 639 }
 640
 641 // -----------------------------------------------------------------------
 642
 643 void ListBox::Resize()
 644 {
 645     Size aOutSz = GetOutputSizePixel();
 646     if( IsDropDownBox() )
 647     {
 648         // initialize the dropdown button size with the standard scrollbar width
 649         long nSBWidth = GetSettings().GetStyleSettings().GetScrollBarSize();
 650         long    nTop = 0;
 651         long    nBottom = aOutSz.Height();
 652
 653         // note: in case of no border, pBorder will actually be this
 654         Window *pBorder = GetWindow( WINDOW_BORDER );
 655         ImplControlValue aControlValue;
 656         Point aPoint;
 657         Region aContent, aBound;
 658
 659         // use the full extent of the control
 660         Region aArea( Rectangle(aPoint, pBorder->GetOutputSizePixel()) );
 661
 662         if ( GetNativeControlRegion( CTRL_LISTBOX, PART_BUTTON_DOWN,
 663                     aArea, 0, aControlValue, rtl::OUString(), aBound, aContent) )
 664         {
 665             // convert back from border space to local coordinates
 666             aPoint = pBorder->ScreenToOutputPixel( OutputToScreenPixel( aPoint ) );
 667             aContent.Move( -aPoint.X(), -aPoint.Y() );
 668
 669             // use the themes drop down size for the button
 670             aOutSz.Width() = aContent.GetBoundRect().Left();
 671             mpBtn->SetPosSizePixel( aContent.GetBoundRect().Left(), nTop, aContent.GetBoundRect().Right(), (nBottom-nTop) );
 672
 673             // adjust the size of the edit field
 674             if ( GetNativeControlRegion( CTRL_LISTBOX, PART_SUB_EDIT,
 675                         aArea, 0, aControlValue, rtl::OUString(), aBound, aContent) )
 676             {
 677                 // convert back from border space to local coordinates
 678                 aContent.Move( -aPoint.X(), -aPoint.Y() );
 679
 680                 // use the themes drop down size
 681                 Rectangle aContentRect = aContent.GetBoundRect();
 682                 if( ! (GetStyle() & WB_BORDER) && ImplGetSVData()->maNWFData.mbNoFocusRects )
 683                 {
 684                     // no border but focus ring behavior -> we have a problem; the
 685                     // native rect relies on the border to draw the focus
 686                     // let's do the best we can and center vertically, so it doesn't look
 687                     // completely wrong.
 688                     Size aSz( GetOutputSizePixel() );
 689                     long nDiff = aContentRect.Top() - (aSz.Height() - aContentRect.GetHeight())/2;
 690                     aContentRect.Top() -= nDiff;
 691                     aContentRect.Bottom() -= nDiff;
 692                 }
 693                 mpImplWin->SetPosSizePixel( aContentRect.TopLeft(), aContentRect.GetSize() );
 694             }
 695             else
 696                 mpImplWin->SetSizePixel( aOutSz );
 697         }
 698         else
 699         {
 700             nSBWidth = CalcZoom( nSBWidth );
 701             mpImplWin->SetPosSizePixel( 0, 0, aOutSz.Width() - nSBWidth, aOutSz.Height() );
 702             mpBtn->SetPosSizePixel( aOutSz.Width() - nSBWidth, 0, nSBWidth, aOutSz.Height() );
 703         }
 704     }
 705     else
 706     {
 707         mpImplLB->SetSizePixel( aOutSz );
 708     }
 709
 710     // FloatingWindow-Groesse auch im unsichtbare Zustand auf Stand halten,
 711     // weil KEY_PGUP/DOWN ausgewertet wird...
 712     if ( mpFloatWin )
 713         mpFloatWin->SetSizePixel( mpFloatWin->CalcFloatSize() );
 714
 715     Control::Resize();
 716 }
 717
 718 // -----------------------------------------------------------------------
 719
 720 void ListBox::FillLayoutData() const
 721 {
 722     mpLayoutData = new vcl::ControlLayoutData();
 723     const Control* pMainWin = mpImplLB->GetMainWindow();
 724     if( mpFloatWin )
 725     {
 726         // dropdown mode
 727         AppendLayoutData( *mpImplWin );
 728         mpImplWin->SetLayoutDataParent( this );
 729         if( mpFloatWin->IsReallyVisible() )
 730         {
 731             AppendLayoutData( *pMainWin );
 732             pMainWin->SetLayoutDataParent( this );
 733         }
 734     }
 735     else
 736     {
 737         AppendLayoutData( *pMainWin );
 738         pMainWin->SetLayoutDataParent( this );
 739     }
 740 }
 741
 742 // -----------------------------------------------------------------------
 743
 744 long ListBox::GetIndexForPoint( const Point& rPoint, USHORT& rPos ) const
 745 {
 746     if( ! mpLayoutData )
 747         FillLayoutData();
 748
 749     // check whether rPoint fits at all
 750     long nIndex = Control::GetIndexForPoint( rPoint );
 751     if( nIndex != -1 )
 752     {
 753         // point must be either in main list window
 754         // or in impl window (dropdown case)
 755         ImplListBoxWindow* pMain = mpImplLB->GetMainWindow();
 756
 757         // convert coordinates to ImplListBoxWindow pixel coordinate space
 758         Point aConvPoint = LogicToPixel( rPoint );
 759         aConvPoint = OutputToAbsoluteScreenPixel( aConvPoint );
 760         aConvPoint = pMain->AbsoluteScreenToOutputPixel( aConvPoint );
 761         aConvPoint = pMain->PixelToLogic( aConvPoint );
 762
 763         // try to find entry
 764         USHORT nEntry = pMain->GetEntryPosForPoint( aConvPoint );
 765         if( nEntry == LISTBOX_ENTRY_NOTFOUND )
 766         {
 767             // not found, maybe dropdown case
 768             if( mpImplWin && mpImplWin->IsReallyVisible() )
 769             {
 770                 // convert to impl window pixel coordinates
 771                 aConvPoint = LogicToPixel( rPoint );
 772                 aConvPoint = OutputToAbsoluteScreenPixel( aConvPoint );
 773                 aConvPoint = mpImplWin->AbsoluteScreenToOutputPixel( aConvPoint );
 774
 775                 // check whether converted point is inside impl window
 776                 Size aImplWinSize = mpImplWin->GetOutputSizePixel();
 777                 if( aConvPoint.X() >= 0 && aConvPoint.Y() >= 0 && aConvPoint.X() < aImplWinSize.Width() && aConvPoint.Y() < aImplWinSize.Height() )
 778                 {
 779                     // inside the impl window, the position is the current item pos
 780                     rPos = mpImplWin->GetItemPos();
 781                 }
 782                 else
 783                     nIndex = -1;
 784             }
 785             else
 786                 nIndex = -1;
 787         }
 788         else
 789             rPos = nEntry;
 790
 791         DBG_ASSERT( nIndex != -1, "found index for point, but relative index failed" );
 792     }
 793
 794     // get line relative index
 795     if( nIndex != -1 )
 796         nIndex = ToRelativeLineIndex( nIndex );
 797
 798     return nIndex;
 799 }
 800
 801 // -----------------------------------------------------------------------
 802
 803 void ListBox::StateChanged( StateChangedType nType )
 804 {
 805     if( nType == STATE_CHANGE_READONLY )
 806     {
 807         if( mpImplWin )
 808             mpImplWin->Enable( !IsReadOnly() );
 809         if( mpBtn )
 810             mpBtn->Enable( !IsReadOnly() );
 811     }
 812     else if( nType == STATE_CHANGE_ENABLE )
 813     {
 814         mpImplLB->Enable( IsEnabled() );
 815         if( mpImplWin )
 816         {
 817             mpImplWin->Enable( IsEnabled() );
 818             if ( IsNativeControlSupported(CTRL_LISTBOX, PART_ENTIRE_CONTROL)
 819                     && ! IsNativeControlSupported(CTRL_LISTBOX, PART_BUTTON_DOWN) )
 820             {
 821                 GetWindow( WINDOW_BORDER )->Invalidate( INVALIDATE_NOERASE );
 822             }
 823             else
 824                 mpImplWin->Invalidate();
 825         }
 826         if( mpBtn )
 827             mpBtn->Enable( IsEnabled() );
 828     }
 829     else if( nType == STATE_CHANGE_UPDATEMODE )
 830     {
 831         mpImplLB->SetUpdateMode( IsUpdateMode() );
 832     }
 833     else if ( nType == STATE_CHANGE_ZOOM )
 834     {
 835         mpImplLB->SetZoom( GetZoom() );
 836         if ( mpImplWin )
 837         {
 838             mpImplWin->SetZoom( GetZoom() );
 839             mpImplWin->SetFont( mpImplLB->GetMainWindow()->GetFont() );
 840             mpImplWin->Invalidate();
 841         }
 842         Resize();
 843     }
 844     else if ( nType == STATE_CHANGE_CONTROLFONT )
 845     {
 846         mpImplLB->SetControlFont( GetControlFont() );
 847         if ( mpImplWin )
 848         {
 849             mpImplWin->SetControlFont( GetControlFont() );
 850             mpImplWin->SetFont( mpImplLB->GetMainWindow()->GetFont() );
 851             mpImplWin->Invalidate();
 852         }
 853         Resize();
 854     }
 855     else if ( nType == STATE_CHANGE_CONTROLFOREGROUND )
 856     {
 857         mpImplLB->SetControlForeground( GetControlForeground() );
 858         if ( mpImplWin )
 859         {
 860             mpImplWin->SetControlForeground( GetControlForeground() );
 861             mpImplWin->SetTextColor( GetControlForeground() );
 862             mpImplWin->SetFont( mpImplLB->GetMainWindow()->GetFont() );
 863             mpImplWin->Invalidate();
 864         }
 865     }
 866     else if ( nType == STATE_CHANGE_CONTROLBACKGROUND )
 867     {
 868         mpImplLB->SetControlBackground( GetControlBackground() );
 869         if ( mpImplWin )
 870         {
 871             if ( mpImplWin->IsNativeControlSupported(CTRL_LISTBOX, PART_ENTIRE_CONTROL) )
 872             {
 873                 // Transparent background
 874                 mpImplWin->SetBackground();
 875                 mpImplWin->SetControlBackground();
 876             }
 877             else
 878             {
 879                 mpImplWin->SetBackground( mpImplLB->GetMainWindow()->GetControlBackground() );
 880                 mpImplWin->SetControlBackground( mpImplLB->GetMainWindow()->GetControlBackground() );
 881             }
 882             mpImplWin->SetFont( mpImplLB->GetMainWindow()->GetFont() );
 883             mpImplWin->Invalidate();
 884         }
 885     }
 886     else if ( nType == STATE_CHANGE_STYLE )
 887     {
 888         SetStyle( ImplInitStyle( GetStyle() ) );
 889         mpImplLB->GetMainWindow()->EnableSort( ( GetStyle() & WB_SORT ) ? TRUE : FALSE );
 890     }
 891     else if( nType == STATE_CHANGE_MIRRORING )
 892     {
 893         if( mpBtn )
 894         {
 895             mpBtn->EnableRTL( IsRTLEnabled() );
 896             ImplInitDropDownButton( mpBtn );
 897         }
 898         mpImplLB->EnableRTL( IsRTLEnabled() );
 899         if( mpImplWin )
 900             mpImplWin->EnableRTL( IsRTLEnabled() );
 901         Resize();
 902     }
 903
 904     Control::StateChanged( nType );
 905 }
 906
 907 // -----------------------------------------------------------------------
 908
 909 long ListBox::PreNotify( NotifyEvent& rNEvt )
 910 {
 911     long nDone = 0;
 912     if ( mpImplLB )
 913     {
 914         if( ( rNEvt.GetType() == EVENT_KEYINPUT ) && ( rNEvt.GetWindow() == mpImplWin ) )
 915         {
 916             KeyEvent aKeyEvt = *rNEvt.GetKeyEvent();
 917             switch( aKeyEvt.GetKeyCode().GetCode() )
 918             {
 919                 case KEY_DOWN:
 920                 {
 921                     if( mpFloatWin && !mpFloatWin->IsInPopupMode() &&
 922                         aKeyEvt.GetKeyCode().IsMod2() )
 923                     {
 924                         ImplCallEventListeners( VCLEVENT_DROPDOWN_PRE_OPEN );
 925                         mpBtn->SetPressed( TRUE );
 926                         mpFloatWin->StartFloat( FALSE );
 927                         ImplCallEventListeners( VCLEVENT_DROPDOWN_OPEN );
 928                         nDone = 1;
 929                     }
 930                     else
 931                     {
 932                         nDone = mpImplLB->ProcessKeyInput( aKeyEvt );
 933                     }
 934                 }
 935                 break;
 936                 case KEY_UP:
 937                 {
 938                     if( mpFloatWin && mpFloatWin->IsInPopupMode() &&
 939                         aKeyEvt.GetKeyCode().IsMod2() )
 940                     {
 941                         mpFloatWin->EndPopupMode();
 942                         nDone = 1;
 943                     }
 944                     else
 945                     {
 946                         nDone = mpImplLB->ProcessKeyInput( aKeyEvt );
 947                     }
 948                 }
 949                 break;
 950                 case KEY_RETURN:
 951                 {
 952                     if( IsInDropDown() )
 953                     {
 954                         mpImplLB->ProcessKeyInput( aKeyEvt );
 955                         nDone = 1;
 956                     }
 957                 }
 958                 break;
 959
 960                 default:
 961                 {
 962                     nDone = mpImplLB->ProcessKeyInput( aKeyEvt );
 963                 }
 964             }
 965         }
 966         else if ( rNEvt.GetType() == EVENT_LOSEFOCUS )
 967         {
 968             if ( IsInDropDown() && !HasChildPathFocus( TRUE ) )
 969                 mpFloatWin->EndPopupMode();
 970         }
 971         else if ( (rNEvt.GetType() == EVENT_COMMAND) &&
 972                   (rNEvt.GetCommandEvent()->GetCommand() == COMMAND_WHEEL) &&
 973                   (rNEvt.GetWindow() == mpImplWin) )
 974         {
 975             USHORT nWheelBehavior( GetSettings().GetMouseSettings().GetWheelBehavior() );
 976             if  (   ( nWheelBehavior == MOUSE_WHEEL_ALWAYS )
 977                 ||  (   ( nWheelBehavior == MOUSE_WHEEL_FOCUS_ONLY )
 978                     &&  HasChildPathFocus()
 979                     )
 980                 )
 981             {
 982                 nDone = mpImplLB->HandleWheelAsCursorTravel( *rNEvt.GetCommandEvent() );
 983             }
 984             else
 985             {
 986                 nDone = 0;  // don't eat this event, let the default handling happen (i.e. scroll the context)
 987             }
 988         }
 989     }
 990
 991     return nDone ? nDone : Control::PreNotify( rNEvt );
 992 }
 993
 994 // -----------------------------------------------------------------------
 995
 996 void ListBox::Select()
 997 {
 998     ImplCallEventListenersAndHandler( VCLEVENT_LISTBOX_SELECT, maSelectHdl, this );
 999 }
1000
1001 // -----------------------------------------------------------------------
1002
1003 void ListBox::DoubleClick()
1004 {
1005     ImplCallEventListenersAndHandler( VCLEVENT_LISTBOX_DOUBLECLICK, maDoubleClickHdl, this );
1006 }
1007
1008 // -----------------------------------------------------------------------
1009
1010 void ListBox::Clear()
1011 {
1012     mpImplLB->Clear();
1013     if( IsDropDownBox() )
1014     {
1015         mpImplWin->SetItemPos( LISTBOX_ENTRY_NOTFOUND );
1016         mpImplWin->SetString( ImplGetSVEmptyStr() );
1017         Image aImage;
1018         mpImplWin->SetImage( aImage );
1019         mpImplWin->Invalidate();
1020     }
1021     CallEventListeners( VCLEVENT_LISTBOX_ITEMREMOVED, (void*) sal_IntPtr(-1) );
1022 }
1023
1024 // -----------------------------------------------------------------------
1025
1026 void ListBox::SetNoSelection()
1027 {
1028     mpImplLB->SetNoSelection();
1029     if( IsDropDownBox() )
1030     {
1031         mpImplWin->SetItemPos( LISTBOX_ENTRY_NOTFOUND );
1032         mpImplWin->SetString( ImplGetSVEmptyStr() );
1033         Image aImage;
1034         mpImplWin->SetImage( aImage );
1035         mpImplWin->Invalidate();
1036     }
1037 }
1038
1039 // -----------------------------------------------------------------------
1040
1041 USHORT ListBox::InsertEntry( const XubString& rStr, USHORT nPos )
1042 {
1043     USHORT nRealPos = mpImplLB->InsertEntry( nPos + mpImplLB->GetEntryList()->GetMRUCount(), rStr );
1044     nRealPos = sal::static_int_cast<USHORT>(nRealPos - mpImplLB->GetEntryList()->GetMRUCount());
1045     CallEventListeners( VCLEVENT_LISTBOX_ITEMADDED, (void*) sal_IntPtr(nRealPos) );
1046     return nRealPos;
1047 }
1048
1049 // -----------------------------------------------------------------------
1050
1051 USHORT ListBox::InsertEntry( const Image& rImage, USHORT nPos )
1052 {
1053     USHORT nRealPos = mpImplLB->InsertEntry( nPos + mpImplLB->GetEntryList()->GetMRUCount(), rImage );
1054     nRealPos = sal::static_int_cast<USHORT>(nRealPos - mpImplLB->GetEntryList()->GetMRUCount());
1055     CallEventListeners( VCLEVENT_LISTBOX_ITEMADDED, (void*) sal_IntPtr(nRealPos) );
1056     return nRealPos;
1057 }
1058
1059 // -----------------------------------------------------------------------
1060
1061 USHORT ListBox::InsertEntry( const XubString& rStr, const Image& rImage, USHORT nPos )
1062 {
1063     USHORT nRealPos = mpImplLB->InsertEntry( nPos + mpImplLB->GetEntryList()->GetMRUCount(), rStr, rImage );
1064     nRealPos = sal::static_int_cast<USHORT>(nRealPos - mpImplLB->GetEntryList()->GetMRUCount());
1065     CallEventListeners( VCLEVENT_LISTBOX_ITEMADDED, (void*) sal_IntPtr(nRealPos) );
1066     return nRealPos;
1067 }
1068
1069 // -----------------------------------------------------------------------
1070
1071 void ListBox::RemoveEntry( const XubString& rStr )
1072 {
1073     RemoveEntry( GetEntryPos( rStr ) );
1074 }
1075
1076 // -----------------------------------------------------------------------
1077
1078 void ListBox::RemoveEntry( USHORT nPos )
1079 {
1080     mpImplLB->RemoveEntry( nPos + mpImplLB->GetEntryList()->GetMRUCount() );
1081     CallEventListeners( VCLEVENT_LISTBOX_ITEMREMOVED, (void*) sal_IntPtr(nPos) );
1082 }
1083
1084 // -----------------------------------------------------------------------
1085
1086 USHORT ListBox::GetEntryPos( const XubString& rStr ) const
1087 {
1088     USHORT nPos = mpImplLB->GetEntryList()->FindEntry( rStr );
1089     if ( nPos != LISTBOX_ENTRY_NOTFOUND )
1090         nPos = sal::static_int_cast<USHORT>(nPos - mpImplLB->GetEntryList()->GetMRUCount());
1091     return nPos;
1092 }
1093
1094 // -----------------------------------------------------------------------
1095
1096 USHORT ListBox::GetEntryPos( const void* pData ) const
1097 {
1098     USHORT nPos = mpImplLB->GetEntryList()->FindEntry( pData );
1099     if ( nPos != LISTBOX_ENTRY_NOTFOUND )
1100         nPos = sal::static_int_cast<USHORT>(nPos - mpImplLB->GetEntryList()->GetMRUCount());
1101     return nPos;
1102 }
1103
1104 // -----------------------------------------------------------------------
1105
1106 XubString ListBox::GetEntry( USHORT nPos ) const
1107 {
1108     return mpImplLB->GetEntryList()->GetEntryText( nPos + mpImplLB->GetEntryList()->GetMRUCount() );
1109 }
1110
1111 // -----------------------------------------------------------------------
1112
1113 USHORT ListBox::GetEntryCount() const
1114 {
1115     return mpImplLB->GetEntryList()->GetEntryCount() - mpImplLB->GetEntryList()->GetMRUCount();
1116 }
1117
1118 // -----------------------------------------------------------------------
1119
1120 XubString ListBox::GetSelectEntry( USHORT nIndex ) const
1121 {
1122     return GetEntry( GetSelectEntryPos( nIndex ) );
1123 }
1124
1125 // -----------------------------------------------------------------------
1126
1127 USHORT ListBox::GetSelectEntryCount() const
1128 {
1129     return mpImplLB->GetEntryList()->GetSelectEntryCount();
1130 }
1131
1132 // -----------------------------------------------------------------------
1133
1134 USHORT ListBox::GetSelectEntryPos( USHORT nIndex ) const
1135 {
1136     USHORT nPos = mpImplLB->GetEntryList()->GetSelectEntryPos( nIndex );
1137     if ( nPos != LISTBOX_ENTRY_NOTFOUND )
1138     {
1139         if ( nPos < mpImplLB->GetEntryList()->GetMRUCount() )
1140             nPos = mpImplLB->GetEntryList()->FindEntry( mpImplLB->GetEntryList()->GetEntryText( nPos ) );
1141         nPos = sal::static_int_cast<USHORT>(nPos - mpImplLB->GetEntryList()->GetMRUCount());
1142     }
1143     return nPos;
1144 }
1145
1146 // -----------------------------------------------------------------------
1147
1148 BOOL ListBox::IsEntrySelected( const XubString& rStr ) const
1149 {
1150     return IsEntryPosSelected( GetEntryPos( rStr ) );
1151 }
1152
1153 // -----------------------------------------------------------------------
1154
1155 BOOL ListBox::IsEntryPosSelected( USHORT nPos ) const
1156 {
1157     return mpImplLB->GetEntryList()->IsEntryPosSelected( nPos + mpImplLB->GetEntryList()->GetMRUCount() );
1158 }
1159
1160 // -----------------------------------------------------------------------
1161
1162 void ListBox::SelectEntry( const XubString& rStr, BOOL bSelect )
1163 {
1164     SelectEntryPos( GetEntryPos( rStr ), bSelect );
1165 }
1166
1167 // -----------------------------------------------------------------------
1168
1169 void ListBox::SelectEntryPos( USHORT nPos, BOOL bSelect )
1170 {
1171     if ( nPos < mpImplLB->GetEntryList()->GetEntryCount() )
1172         mpImplLB->SelectEntry( nPos + mpImplLB->GetEntryList()->GetMRUCount(), bSelect );
1173 }
1174
1175 // -----------------------------------------------------------------------
1176
1177 void ListBox::SetEntryData( USHORT nPos, void* pNewData )
1178 {
1179     mpImplLB->SetEntryData( nPos + mpImplLB->GetEntryList()->GetMRUCount(), pNewData );
1180 }
1181
1182 // -----------------------------------------------------------------------
1183
1184 void* ListBox::GetEntryData( USHORT nPos ) const
1185 {
1186     return mpImplLB->GetEntryList()->GetEntryData( nPos + mpImplLB->GetEntryList()->GetMRUCount() );
1187 }
1188
1189 // -----------------------------------------------------------------------
1190
1191 void ListBox::SetEntryFlags( USHORT nPos, long nFlags )
1192 {
1193     mpImplLB->SetEntryFlags( nPos + mpImplLB->GetEntryList()->GetMRUCount(), nFlags );
1194 }
1195
1196 // -----------------------------------------------------------------------
1197
1198 long ListBox::GetEntryFlags( USHORT nPos ) const
1199 {
1200     return mpImplLB->GetEntryList()->GetEntryFlags( nPos + mpImplLB->GetEntryList()->GetMRUCount() );
1201 }
1202
1203 // -----------------------------------------------------------------------
1204
1205 void ListBox::SetTopEntry( USHORT nPos )
1206 {
1207     mpImplLB->SetTopEntry( nPos + mpImplLB->GetEntryList()->GetMRUCount() );
1208 }
1209
1210 // -----------------------------------------------------------------------
1211
1212 USHORT ListBox::GetTopEntry() const
1213 {
1214     USHORT nPos = GetEntryCount() ? mpImplLB->GetTopEntry() : LISTBOX_ENTRY_NOTFOUND;
1215     if ( nPos < mpImplLB->GetEntryList()->GetMRUCount() )
1216         nPos = 0;
1217     return nPos;
1218 }
1219
1220 // -----------------------------------------------------------------------
1221
1222 BOOL ListBox::IsTravelSelect() const
1223 {
1224     return mpImplLB->IsTravelSelect();
1225 }
1226
1227 // -----------------------------------------------------------------------
1228
1229 BOOL ListBox::IsInDropDown() const
1230 {
1231     return mpFloatWin && mpFloatWin->IsInPopupMode();
1232 }
1233
1234 // -----------------------------------------------------------------------
1235
1236 long ListBox::CalcWindowSizePixel( USHORT nLines ) const
1237 {
1238     return mpImplLB->GetEntryHeight() * nLines;
1239 }
1240
1241 Rectangle ListBox::GetBoundingRectangle( USHORT nItem ) const
1242 {
1243     Rectangle aRect = mpImplLB->GetMainWindow()->GetBoundingRectangle( nItem );
1244     Rectangle aOffset = mpImplLB->GetMainWindow()->GetWindowExtentsRelative( (Window*)this );
1245     aRect.Move( aOffset.TopLeft().X(), aOffset.TopLeft().Y() );
1246     return aRect;
1247 }
1248
1249 // -----------------------------------------------------------------------
1250
1251 void ListBox::EnableMultiSelection( BOOL bMulti )
1252 {
1253     EnableMultiSelection( bMulti, FALSE );
1254 }
1255
1256 void ListBox::EnableMultiSelection( BOOL bMulti, BOOL bStackSelection )
1257 {
1258     mpImplLB->EnableMultiSelection( bMulti, bStackSelection );
1259
1260     // WB_SIMPLEMODE:
1261     // Die MultiListBox verh�lt sich wie eine normale ListBox.
1262     // Die Mehrfachselektion kann nur �ber entsprechende Zusatztasten erfolgen.
1263
1264     BOOL bSimpleMode = ( GetStyle() & WB_SIMPLEMODE ) ? TRUE : FALSE;
1265     mpImplLB->SetMultiSelectionSimpleMode( bSimpleMode );
1266
1267     // ohne Focus ist das Traveln in einer MultiSelection nicht zu sehen:
1268     if ( mpFloatWin )
1269         mpImplLB->GetMainWindow()->AllowGrabFocus( bMulti );
1270 }
1271
1272 // -----------------------------------------------------------------------
1273
1274 BOOL ListBox::IsMultiSelectionEnabled() const
1275 {
1276     return mpImplLB->IsMultiSelectionEnabled();
1277 }
1278
1279 // -----------------------------------------------------------------------
1280
1281 Size ListBox::CalcMinimumSize() const
1282 {
1283     Size aSz;
1284     if ( !IsDropDownBox() )
1285         aSz = mpImplLB->CalcSize (mnLineCount ? mnLineCount : mpImplLB->GetEntryList()->GetEntryCount());
1286     else
1287     {
1288         aSz.Height() = mpImplLB->CalcSize( 1 ).Height();
1289         if( aSz.Height() < mnDDHeight )
1290         {
1291             aSz.Height() = mnDDHeight;
1292             // FIXME: this is currently only on mac/aqua
1293             if( ImplGetSVData()->maNWFData.mbNoFocusRects &&
1294                 IsNativeWidgetEnabled() &&
1295                 const_cast<ListBox*>(this)->IsNativeControlSupported( CTRL_LISTBOX, PART_ENTIRE_CONTROL ) )
1296             {
1297                 ImplControlValue aControlValue;
1298                 Region aCtrlRegion( Rectangle( (const Point&)Point(), Size( 20, mnDDHeight ) ) );
1299                 Region aBoundingRgn( aCtrlRegion );
1300                 Region aContentRgn( aCtrlRegion );
1301                 // adjust the size of the edit field
1302                 if( const_cast<ListBox*>(this)->GetNativeControlRegion( CTRL_LISTBOX, PART_ENTIRE_CONTROL,
1303                                    aCtrlRegion, 0, aControlValue, rtl::OUString(), aBoundingRgn, aContentRgn) )
1304                 {
1305                     aSz.Height() = aContentRgn.GetBoundRect().GetHeight();
1306                 }
1307             }
1308         }
1309         aSz.Width() = mpImplLB->GetMaxEntryWidth();
1310         aSz.Width() += GetSettings().GetStyleSettings().GetScrollBarSize();
1311     }
1312
1313     aSz = CalcWindowSize( aSz );
1314     return aSz;
1315 }
1316
1317 // -----------------------------------------------------------------------
1318
1319 Size ListBox::GetOptimalSize(WindowSizeType eType) const
1320 {
1321     switch (eType) {
1322     case WINDOWSIZE_MINIMUM:
1323         return CalcMinimumSize();
1324     default:
1325         return Control::GetOptimalSize( eType );
1326     }
1327 }
1328
1329 // -----------------------------------------------------------------------
1330
1331 Size ListBox::CalcAdjustedSize( const Size& rPrefSize ) const
1332 {
1333     Size aSz = rPrefSize;
1334     sal_Int32 nLeft, nTop, nRight, nBottom;
1335     ((Window*)this)->GetBorder( nLeft, nTop, nRight, nBottom );
1336     aSz.Height() -= nTop+nBottom;
1337     if ( !IsDropDownBox() )
1338     {
1339         long nEntryHeight = CalcSize( 1, 1 ).Height();
1340         long nLines = aSz.Height() / nEntryHeight;
1341         if ( nLines < 1 )
1342             nLines = 1;
1343         aSz.Height() = nLines * nEntryHeight;
1344     }
1345     else
1346     {
1347         aSz.Height() = mnDDHeight;
1348     }
1349     aSz.Height() += nTop+nBottom;
1350
1351     aSz = CalcWindowSize( aSz );
1352     return aSz;
1353 }
1354
1355 // -----------------------------------------------------------------------
1356
1357 Size ListBox::CalcSize( USHORT nColumns, USHORT nLines ) const
1358 {
1359     // ggf. werden ScrollBars eingeblendet
1360     Size aMinSz = CalcMinimumSize();
1361 //      aMinSz = ImplCalcOutSz( aMinSz );
1362
1363     Size aSz;
1364
1365     // Hoehe
1366     if ( nLines )
1367     {
1368         if ( !IsDropDownBox() )
1369             aSz.Height() = mpImplLB->CalcSize( nLines ).Height();
1370         else
1371             aSz.Height() = mnDDHeight;
1372     }
1373     else
1374         aSz.Height() = aMinSz.Height();
1375
1376     // Breite
1377     if ( nColumns )
1378         aSz.Width() = nColumns * GetTextWidth( XubString( 'X' ) );
1379     else
1380         aSz.Width() = aMinSz.Width();
1381
1382     if ( IsDropDownBox() )
1383         aSz.Width() += GetSettings().GetStyleSettings().GetScrollBarSize();
1384
1385     if ( !IsDropDownBox() )
1386     {
1387         if ( aSz.Width() < aMinSz.Width() )
1388             aSz.Height() += GetSettings().GetStyleSettings().GetScrollBarSize();
1389         if ( aSz.Height() < aMinSz.Height() )
1390             aSz.Width() += GetSettings().GetStyleSettings().GetScrollBarSize();
1391     }
1392
1393     aSz = CalcWindowSize( aSz );
1394     return aSz;
1395 }
1396
1397 // -----------------------------------------------------------------------
1398
1399 void ListBox::GetMaxVisColumnsAndLines( USHORT& rnCols, USHORT& rnLines ) const
1400 {
1401     long nCharWidth = GetTextWidth( UniString( 'x' ) );
1402     if ( !IsDropDownBox() )
1403     {
1404         Size aOutSz = mpImplLB->GetMainWindow()->GetOutputSizePixel();
1405         rnCols = (USHORT) (aOutSz.Width()/nCharWidth);
1406         rnLines = (USHORT) (aOutSz.Height()/mpImplLB->GetEntryHeight());
1407     }
1408     else
1409     {
1410         Size aOutSz = mpImplWin->GetOutputSizePixel();
1411         rnCols = (USHORT) (aOutSz.Width()/nCharWidth);
1412         rnLines = 1;
1413     }
1414 }
1415
1416 // -----------------------------------------------------------------------
1417
1418 IMPL_LINK( ListBox, ImplUserDrawHdl, UserDrawEvent*, pEvent )
1419 {
1420     UserDraw( *pEvent );
1421     return 1;
1422 }
1423
1424 // -----------------------------------------------------------------------
1425
1426 void ListBox::UserDraw( const UserDrawEvent& )
1427 {
1428 }
1429
1430 // -----------------------------------------------------------------------
1431
1432 void ListBox::DrawEntry( const UserDrawEvent& rEvt, BOOL bDrawImage, BOOL bDrawText, BOOL bDrawTextAtImagePos )
1433 {
1434     if ( rEvt.GetDevice() == mpImplLB->GetMainWindow() )
1435         mpImplLB->GetMainWindow()->DrawEntry( rEvt.GetItemId(), bDrawImage, bDrawText, bDrawTextAtImagePos );
1436     else if ( rEvt.GetDevice() == mpImplWin )
1437         mpImplWin->DrawEntry( bDrawImage, bDrawText, bDrawTextAtImagePos );
1438 }
1439
1440 // -----------------------------------------------------------------------
1441
1442 void ListBox::SetUserItemSize( const Size& rSz )
1443 {
1444     mpImplLB->GetMainWindow()->SetUserItemSize( rSz );
1445     if ( mpImplWin )
1446         mpImplWin->SetUserItemSize( rSz );
1447 }
1448
1449 // -----------------------------------------------------------------------
1450
1451 const Size& ListBox::GetUserItemSize() const
1452 {
1453     return mpImplLB->GetMainWindow()->GetUserItemSize();
1454 }
1455
1456 // -----------------------------------------------------------------------
1457
1458 void ListBox::EnableUserDraw( BOOL bUserDraw )
1459 {
1460     mpImplLB->GetMainWindow()->EnableUserDraw( bUserDraw );
1461     if ( mpImplWin )
1462         mpImplWin->EnableUserDraw( bUserDraw );
1463 }
1464
1465 // -----------------------------------------------------------------------
1466
1467 BOOL ListBox::IsUserDrawEnabled() const
1468 {
1469     return mpImplLB->GetMainWindow()->IsUserDrawEnabled();
1470 }
1471
1472 // -----------------------------------------------------------------------
1473
1474 void ListBox::SetReadOnly( BOOL bReadOnly )
1475 {
1476     if ( mpImplLB->IsReadOnly() != bReadOnly )
1477     {
1478         mpImplLB->SetReadOnly( bReadOnly );
1479         StateChanged( STATE_CHANGE_READONLY );
1480     }
1481 }
1482
1483 // -----------------------------------------------------------------------
1484
1485 BOOL ListBox::IsReadOnly() const
1486 {
1487     return mpImplLB->IsReadOnly();
1488 }
1489
1490 // -----------------------------------------------------------------------
1491
1492 void ListBox::SetSeparatorPos( USHORT n )
1493 {
1494     mpImplLB->SetSeparatorPos( n );
1495 }
1496
1497 // -----------------------------------------------------------------------
1498
1499 void ListBox::SetSeparatorPos()
1500 {
1501     mpImplLB->SetSeparatorPos( LISTBOX_ENTRY_NOTFOUND );
1502 }
1503
1504 // -----------------------------------------------------------------------
1505
1506 USHORT ListBox::GetSeparatorPos() const
1507 {
1508     return mpImplLB->GetSeparatorPos();
1509 }
1510
1511 // -----------------------------------------------------------------------
1512
1513 void ListBox::SetMRUEntries( const XubString& rEntries, xub_Unicode cSep )
1514 {
1515     mpImplLB->SetMRUEntries( rEntries, cSep );
1516 }
1517
1518 // -----------------------------------------------------------------------
1519
1520 XubString ListBox::GetMRUEntries( xub_Unicode cSep ) const
1521 {
1522     return mpImplLB->GetMRUEntries( cSep );
1523 }
1524
1525 // -----------------------------------------------------------------------
1526
1527 void ListBox::SetMaxMRUCount( USHORT n )
1528 {
1529     mpImplLB->SetMaxMRUCount( n );
1530 }
1531
1532 // -----------------------------------------------------------------------
1533
1534 USHORT ListBox::GetMaxMRUCount() const
1535 {
1536     return mpImplLB->GetMaxMRUCount();
1537 }
1538
1539 // -----------------------------------------------------------------------
1540
1541 USHORT ListBox::GetDisplayLineCount() const
1542 {
1543     return mpImplLB->GetDisplayLineCount();
1544 }
1545
1546 // -----------------------------------------------------------------------
1547
1548 // pb: #106948# explicit mirroring for calc
1549
1550 void ListBox::EnableMirroring()
1551 {
1552     mpImplLB->EnableMirroring();
1553 }
1554
1555 // -----------------------------------------------------------------------
1556
1557 Rectangle ListBox::GetDropDownPosSizePixel() const
1558 {
1559     return mpFloatWin ? mpFloatWin->GetWindowExtentsRelative( const_cast<ListBox*>(this) ) : Rectangle();
1560 }
1561
1562 // -----------------------------------------------------------------------
1563
1564 const Wallpaper& ListBox::GetDisplayBackground() const
1565 {
1566     // !!! recursion does not occur because the ImplListBox is default
1567     // initialized to a nontransparent color in Window::ImplInitData
1568     return mpImplLB->GetDisplayBackground();
1569 }
1570
1571 // =======================================================================
1572 \f
1573 MultiListBox::MultiListBox( Window* pParent, WinBits nStyle ) :
1574     ListBox( WINDOW_MULTILISTBOX )
1575 {
1576     ImplInit( pParent, nStyle );
1577     EnableMultiSelection( TRUE );
1578 }
1579
1580 // -----------------------------------------------------------------------
1581
1582 MultiListBox::MultiListBox( Window* pParent, const ResId& rResId ) :
1583     ListBox( WINDOW_MULTILISTBOX )
1584 {
1585     rResId.SetRT( RSC_MULTILISTBOX );
1586     WinBits nStyle = ImplInitRes( rResId );
1587     ImplInit( pParent, nStyle );
1588     ImplLoadRes( rResId );
1589
1590     if ( !(nStyle & WB_HIDE ) )
1591         Show();
1592     EnableMultiSelection( TRUE );
1593 }