vcl/source/window/toolbox2.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: toolbox2.cxx,v $
  10  * $Revision: 1.55 $
  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 #include <tools/list.hxx>
  34 #include <tools/debug.hxx>
  35
  36 #ifndef _SV_RC_H
  37 #include <tools/rc.h>
  38 #endif
  39 #include <vcl/svdata.hxx>
  40 #include <vcl/svapp.hxx>
  41 #include <vcl/help.hxx>
  42 #include <vcl/bitmap.hxx>
  43 #include <vcl/toolbox.hxx>
  44 #include <vcl/toolbox.h>
  45 #include <vcl/mnemonic.hxx>
  46 #include <vcl/menu.hxx>
  47 #include <vcl/brdwin.hxx>
  48
  49 #include <vcl/unohelp.hxx>
  50 #include <unotools/confignode.hxx>
  51
  52 #include <vcl/ImageListProvider.hxx>
  53 #include <com/sun/star/lang/IllegalArgumentException.hpp>
  54
  55 using namespace vcl;
  56 using namespace rtl;
  57
  58 // =======================================================================
  59
  60 #define TB_SEP_SIZE                     8
  61
  62 ButtonType determineButtonType( ImplToolItem* pItem, ButtonType defaultType );
  63
  64 // -----------------------------------------------------------------------
  65
  66 ImplToolBoxPrivateData::ImplToolBoxPrivateData() :
  67         m_pLayoutData( NULL ),
  68         mpImageListProvider( NULL ),
  69         meImageListType( vcl::IMAGELISTTYPE_UNKNOWN )
  70 {
  71     meButtonSize = TOOLBOX_BUTTONSIZE_DONTCARE;
  72     mpMenu = new PopupMenu();
  73     mnEventId = 0;
  74
  75     maMenuType = TOOLBOX_MENUTYPE_NONE;
  76     maMenubuttonItem.maItemSize = Size( TB_MENUBUTTON_SIZE+TB_MENUBUTTON_OFFSET, TB_MENUBUTTON_SIZE+TB_MENUBUTTON_OFFSET );
  77     maMenubuttonItem.meState = STATE_NOCHECK;
  78     mnMenuButtonWidth = TB_MENUBUTTON_SIZE;
  79
  80
  81     mbIsLocked = FALSE;
  82     mbNativeButtons = FALSE;
  83     mbIsPaintLocked = FALSE;
  84     mbAssumeDocked = FALSE;
  85     mbAssumePopupMode = FALSE;
  86     mbAssumeFloating = FALSE;
  87     mbKeyInputDisabled = FALSE;
  88     mbMenubuttonSelected = FALSE;
  89     mbPageScroll = FALSE;
  90     mbWillUsePopupMode = FALSE;
  91     mbDropDownByKeyboard = FALSE;
  92 }
  93
  94 ImplToolBoxPrivateData::~ImplToolBoxPrivateData()
  95 {
  96     if( m_pLayoutData )
  97         delete m_pLayoutData;
  98     delete mpMenu;
  99 }
 100
 101 // -----------------------------------------------------------------------
 102 ImplToolItem::ImplToolItem()
 103 {
 104     mnId                        = 0;
 105     mpWindow            = NULL;
 106     mpUserData          = NULL;
 107     mnHelpId            = 0;
 108     meType                      = TOOLBOXITEM_BUTTON;
 109     mnBits                      = 0;
 110     meState             = STATE_NOCHECK;
 111     mbEnabled           = TRUE;
 112     mbVisible           = TRUE;
 113     mbEmptyBtn          = TRUE;
 114     mbShowWindow        = FALSE;
 115     mbBreak             = FALSE;
 116     mnSepSize           = TB_SEP_SIZE;
 117     mnDropDownArrowWidth = TB_DROPDOWNARROWWIDTH;
 118     mnImageAngle        = 0;
 119     mbMirrorMode        = FALSE;
 120     mbVisibleText   = FALSE;
 121 }
 122
 123 // -----------------------------------------------------------------------
 124
 125 ImplToolItem::ImplToolItem( USHORT nItemId, const Image& rImage,
 126                             ToolBoxItemBits nItemBits ) :
 127     maImage( rImage )
 128 {
 129     mnId                        = nItemId;
 130     mpWindow            = NULL;
 131     mpUserData          = NULL;
 132     mnHelpId            = 0;
 133     meType                      = TOOLBOXITEM_BUTTON;
 134     mnBits                      = nItemBits;
 135     meState             = STATE_NOCHECK;
 136     mbEnabled           = TRUE;
 137     mbVisible           = TRUE;
 138     mbEmptyBtn          = FALSE;
 139     mbShowWindow        = FALSE;
 140     mbBreak             = FALSE;
 141     mnSepSize           = TB_SEP_SIZE;
 142     mnDropDownArrowWidth = TB_DROPDOWNARROWWIDTH;
 143     mnImageAngle        = 0;
 144     mbMirrorMode        = false;
 145     mbVisibleText   = false;
 146 }
 147
 148 // -----------------------------------------------------------------------
 149
 150 ImplToolItem::ImplToolItem( USHORT nItemId, const XubString& rText,
 151                             ToolBoxItemBits nItemBits ) :
 152     maText( rText )
 153 {
 154     mnId                        = nItemId;
 155     mpWindow            = NULL;
 156     mpUserData          = NULL;
 157     mnHelpId            = 0;
 158     meType                      = TOOLBOXITEM_BUTTON;
 159     mnBits                      = nItemBits;
 160     meState             = STATE_NOCHECK;
 161     mbEnabled           = TRUE;
 162     mbVisible           = TRUE;
 163     mbEmptyBtn          = FALSE;
 164     mbShowWindow        = FALSE;
 165     mbBreak             = FALSE;
 166     mnSepSize           = TB_SEP_SIZE;
 167     mnDropDownArrowWidth = TB_DROPDOWNARROWWIDTH;
 168     mnImageAngle        = 0;
 169     mbMirrorMode        = false;
 170     mbVisibleText   = false;
 171 }
 172
 173 // -----------------------------------------------------------------------
 174
 175 ImplToolItem::ImplToolItem( USHORT nItemId, const Image& rImage,
 176                             const XubString& rText, ToolBoxItemBits nItemBits ) :
 177     maImage( rImage ),
 178     maText( rText )
 179 {
 180     mnId                        = nItemId;
 181     mpWindow            = NULL;
 182     mpUserData          = NULL;
 183     mnHelpId            = 0;
 184     meType                      = TOOLBOXITEM_BUTTON;
 185     mnBits                      = nItemBits;
 186     meState             = STATE_NOCHECK;
 187     mbEnabled           = TRUE;
 188     mbVisible           = TRUE;
 189     mbEmptyBtn          = FALSE;
 190     mbShowWindow        = FALSE;
 191     mbBreak             = FALSE;
 192     mnSepSize           = TB_SEP_SIZE;
 193     mnDropDownArrowWidth = TB_DROPDOWNARROWWIDTH;
 194     mnImageAngle        = 0;
 195     mbMirrorMode        = false;
 196     mbVisibleText   = false;
 197 }
 198
 199 // -----------------------------------------------------------------------
 200
 201 ImplToolItem::ImplToolItem( const ImplToolItem& rItem ) :
 202         mpWindow                                ( rItem.mpWindow ),
 203         mpUserData                              ( rItem.mpUserData ),
 204         maImage                                 ( rItem.maImage ),
 205         maHighImage                             ( rItem.maHighImage ),
 206         mnImageAngle                    ( rItem.mnImageAngle ),
 207         mbMirrorMode                    ( rItem.mbMirrorMode ),
 208         maText                                  ( rItem.maText ),
 209         maQuickHelpText                 ( rItem.maQuickHelpText ),
 210         maHelpText                              ( rItem.maHelpText ),
 211         maCommandStr                    ( rItem.maCommandStr ),
 212         mnHelpId                                ( rItem.mnHelpId ),
 213         maRect                                  ( rItem.maRect ),
 214         maCalcRect                              ( rItem.maCalcRect ),
 215         maItemSize                              ( rItem.maItemSize ),
 216         mnSepSize                               ( rItem.mnSepSize ),
 217         mnDropDownArrowWidth    ( rItem.mnDropDownArrowWidth ),
 218         meType                                  ( rItem.meType ),
 219         mnBits                                  ( rItem.mnBits ),
 220         meState                                 ( rItem.meState ),
 221         mnId                                    ( rItem.mnId ),
 222         mbEnabled                               ( rItem.mbEnabled ),
 223         mbVisible                               ( rItem.mbVisible ),
 224         mbEmptyBtn                              ( rItem.mbEmptyBtn ),
 225         mbShowWindow                    ( rItem.mbShowWindow ),
 226         mbBreak                                 ( rItem.mbBreak ),
 227         mbVisibleText                   ( rItem.mbVisibleText )
 228 {
 229 }
 230
 231 // -----------------------------------------------------------------------
 232
 233 ImplToolItem::~ImplToolItem()
 234 {
 235 }
 236
 237 // -----------------------------------------------------------------------
 238
 239 ImplToolItem& ImplToolItem::operator=( const ImplToolItem& rItem )
 240 {
 241     mpWindow                            = rItem.mpWindow;
 242     mpUserData                          = rItem.mpUserData;
 243     maImage                                     = rItem.maImage;
 244     maHighImage                         = rItem.maHighImage;
 245     mnImageAngle                        = rItem.mnImageAngle;
 246     mbMirrorMode                        = rItem.mbMirrorMode;
 247     maText                                      = rItem.maText;
 248     maQuickHelpText                     = rItem.maQuickHelpText;
 249     maHelpText                          = rItem.maHelpText;
 250     maCommandStr                        = rItem.maCommandStr;
 251     mnHelpId                            = rItem.mnHelpId;
 252     maRect                                      = rItem.maRect;
 253     maCalcRect                          = rItem.maCalcRect;
 254     mnSepSize                           = rItem.mnSepSize;
 255     mnDropDownArrowWidth    = rItem.mnDropDownArrowWidth;
 256     maItemSize                          = rItem.maItemSize;
 257     mbVisibleText                       = rItem.mbVisibleText;
 258     meType                                      = rItem.meType;
 259     mnBits                                      = rItem.mnBits;
 260     meState                                     = rItem.meState;
 261     mnId                                        = rItem.mnId;
 262     mbEnabled                           = rItem.mbEnabled;
 263     mbVisible                           = rItem.mbVisible;
 264     mbEmptyBtn                          = rItem.mbEmptyBtn;
 265     mbShowWindow                        = rItem.mbShowWindow;
 266     mbBreak                                     = rItem.mbBreak;
 267     return *this;
 268 }
 269
 270 // -----------------------------------------------------------------------
 271
 272 Size ImplToolItem::GetSize( BOOL bHorz, BOOL bCheckMaxWidth, long maxWidth, const Size& rDefaultSize )
 273 {
 274     Size aSize( rDefaultSize ); // the size of 'standard' toolbox items
 275                                 // non-standard items are eg windows or buttons with text
 276
 277     if ( (meType == TOOLBOXITEM_BUTTON) || (meType == TOOLBOXITEM_SPACE) )
 278     {
 279         aSize = maItemSize;
 280
 281         if ( mpWindow && bHorz )
 282         {
 283             // get size of item window and check if it fits
 284             // no windows in vertical toolbars (the default is mbShowWindow=FALSE)
 285             Size aWinSize = mpWindow->GetSizePixel();
 286             if ( !bCheckMaxWidth || (aWinSize.Width() <= maxWidth) )
 287             {
 288                 aSize.Width()   = aWinSize.Width();
 289                 aSize.Height()  = aWinSize.Height();
 290                 mbShowWindow = TRUE;
 291             }
 292             else
 293             {
 294                 if ( mbEmptyBtn )
 295                 {
 296                     aSize.Width()   = 0;
 297                     aSize.Height()  = 0;
 298                 }
 299             }
 300         }
 301     }
 302     else if ( meType == TOOLBOXITEM_SEPARATOR )
 303     {
 304         if ( bHorz )
 305         {
 306             aSize.Width()   = mnSepSize;
 307             aSize.Height()  = rDefaultSize.Height();
 308         }
 309         else
 310         {
 311             aSize.Width()   = rDefaultSize.Width();
 312             aSize.Height()  = mnSepSize;
 313         }
 314     }
 315     else if ( meType == TOOLBOXITEM_BREAK )
 316     {
 317         aSize.Width()   = 0;
 318         aSize.Height()  = 0;
 319     }
 320
 321     return aSize;
 322 }
 323
 324 // -----------------------------------------------------------------------
 325
 326 void ImplToolItem::DetermineButtonDrawStyle( ButtonType eButtonType, BOOL& rbImage, BOOL& rbText ) const
 327 {
 328     if ( meType != TOOLBOXITEM_BUTTON )
 329     {
 330         // no button -> draw nothing
 331         rbImage = rbText = FALSE;
 332         return;
 333     }
 334
 335     BOOL bHasImage;
 336     BOOL bHasText;
 337
 338     // check for image and/or text
 339     if ( !(maImage) )
 340         bHasImage = FALSE;
 341     else
 342         bHasImage = TRUE;
 343     if ( !maText.Len() )
 344         bHasText = FALSE;
 345     else
 346         bHasText = TRUE;
 347
 348     // prefer images if symbolonly buttons are drawn
 349     // prefer texts if textonly buttons are dreawn
 350
 351     if ( eButtonType == BUTTON_SYMBOL )         // drawing icons only
 352     {
 353         if( bHasImage || !bHasText )
 354         {
 355             rbImage = TRUE;
 356             rbText  = FALSE;
 357         }
 358         else
 359         {
 360             rbImage = FALSE;
 361             rbText  = TRUE;
 362         }
 363     }
 364     else if ( eButtonType == BUTTON_TEXT )      // drawing text only
 365     {
 366         if( bHasText || !bHasImage )
 367         {
 368             rbImage = FALSE;
 369             rbText  = TRUE;
 370         }
 371         else
 372         {
 373             rbImage = TRUE;
 374             rbText  = FALSE;
 375         }
 376     }
 377     else                                        // drawing icons and text both
 378     {
 379         rbImage = TRUE;
 380         rbText  = TRUE;
 381     }
 382 }
 383
 384 // -----------------------------------------------------------------------
 385
 386 Rectangle ImplToolItem::GetDropDownRect( BOOL bHorz ) const
 387 {
 388     Rectangle aRect;
 389     if( (mnBits & TIB_DROPDOWN) && !maRect.IsEmpty() )
 390     {
 391         aRect = maRect;
 392         if( mbVisibleText && !bHorz )
 393             // item will be rotated -> place dropdown to the bottom
 394             aRect.Top() = aRect.Bottom() - mnDropDownArrowWidth;
 395         else
 396             // place dropdown to the right
 397             aRect.Left() = aRect.Right() - mnDropDownArrowWidth;
 398     }
 399     return aRect;
 400 }
 401
 402 // -----------------------------------------------------------------------
 403
 404 BOOL ImplToolItem::IsClipped() const
 405 {
 406     return ( meType == TOOLBOXITEM_BUTTON && mbVisible && maRect.IsEmpty() );
 407 }
 408
 409 // -----------------------------------------------------------------------
 410 // -----------------------------------------------------------------------
 411
 412 const XubString& ToolBox::ImplConvertMenuString( const XubString& rStr )
 413 {
 414     maCvtStr = rStr;
 415     if ( mbMenuStrings )
 416         maCvtStr.EraseTrailingChars( '.' );
 417     maCvtStr = MnemonicGenerator::EraseAllMnemonicChars( maCvtStr );
 418     return maCvtStr;
 419 }
 420
 421 // -----------------------------------------------------------------------
 422
 423 void ToolBox::ImplInvalidate( BOOL bNewCalc, BOOL bFullPaint )
 424 {
 425     ImplUpdateInputEnable();
 426
 427     if ( bNewCalc )
 428         mbCalc = TRUE;
 429
 430     if ( bFullPaint )
 431     {
 432         mbFormat = TRUE;
 433
 434         // Muss ueberhaupt eine neue Ausgabe erfolgen
 435         if ( IsReallyVisible() && IsUpdateMode() )
 436         {
 437             Invalidate( Rectangle( mnLeftBorder, mnTopBorder,
 438                                    mnDX-mnRightBorder-1, mnDY-mnBottomBorder-1 ) );
 439             maTimer.Stop();
 440         }
 441     }
 442     else
 443     {
 444         if ( !mbFormat )
 445         {
 446             mbFormat = TRUE;
 447
 448             // Muss ueberhaupt eine neue Ausgabe erfolgen
 449             if ( IsReallyVisible() && IsUpdateMode() )
 450                 maTimer.Start();
 451         }
 452     }
 453
 454     // request new layout by layoutmanager
 455     ImplCallEventListeners( VCLEVENT_TOOLBOX_FORMATCHANGED );
 456 }
 457
 458 // -----------------------------------------------------------------------
 459
 460 void ToolBox::ImplUpdateItem( USHORT nIndex )
 461 {
 462     // Muss ueberhaupt eine neue Ausgabe erfolgen
 463     if ( IsReallyVisible() && IsUpdateMode() )
 464     {
 465         if ( nIndex == 0xFFFF )
 466         {
 467             // #i52217# no immediate draw as this might lead to paint problems
 468             Invalidate( Rectangle( mnLeftBorder, mnTopBorder,
 469                                     mnDX-mnRightBorder-1, mnDY-mnBottomBorder-1 ) );
 470         }
 471         else
 472         {
 473             if ( !mbFormat )
 474             {
 475                 // #i52217# no immediate draw as this might lead to paint problems
 476                 Invalidate( mpData->m_aItems[nIndex].maRect );
 477             }
 478             else
 479                 maPaintRect.Union( mpData->m_aItems[nIndex].maRect );
 480         }
 481     }
 482 }
 483
 484 // -----------------------------------------------------------------------
 485
 486 void ToolBox::Click()
 487 {
 488     ImplCallEventListeners( VCLEVENT_TOOLBOX_CLICK );
 489     maClickHdl.Call( this );
 490 }
 491
 492 // -----------------------------------------------------------------------
 493
 494 void ToolBox::DoubleClick()
 495 {
 496     ImplCallEventListeners( VCLEVENT_TOOLBOX_DOUBLECLICK );
 497     maDoubleClickHdl.Call( this );
 498 }
 499
 500 // -----------------------------------------------------------------------
 501
 502 void ToolBox::Activate()
 503 {
 504     mnActivateCount++;
 505     ImplCallEventListeners( VCLEVENT_TOOLBOX_ACTIVATE );
 506     maActivateHdl.Call( this );
 507 }
 508
 509 // -----------------------------------------------------------------------
 510
 511 void ToolBox::Deactivate()
 512 {
 513     mnActivateCount--;
 514     ImplCallEventListeners( VCLEVENT_TOOLBOX_DEACTIVATE );
 515     maDeactivateHdl.Call( this );
 516
 517     if ( mbHideStatusText )
 518     {
 519         GetpApp()->HideHelpStatusText();
 520         mbHideStatusText = FALSE;
 521     }
 522 }
 523
 524 // -----------------------------------------------------------------------
 525
 526 void ToolBox::Highlight()
 527 {
 528     ImplCallEventListeners( VCLEVENT_TOOLBOX_HIGHLIGHT );
 529     maHighlightHdl.Call( this );
 530
 531     XubString aStr = GetHelpText( mnCurItemId );
 532     if ( aStr.Len() || mbHideStatusText )
 533     {
 534         GetpApp()->ShowHelpStatusText( aStr );
 535         mbHideStatusText = TRUE;
 536     }
 537 }
 538
 539 // -----------------------------------------------------------------------
 540
 541 void ToolBox::Select()
 542 {
 543     ImplDelData aDelData;
 544     ImplAddDel( &aDelData );
 545
 546     ImplCallEventListeners( VCLEVENT_TOOLBOX_SELECT );
 547     maSelectHdl.Call( this );
 548
 549     if ( aDelData.IsDelete() )
 550         return;
 551     ImplRemoveDel( &aDelData );
 552
 553     // TODO: GetFloatingWindow in DockingWindow is currently inline, change it to check dockingwrapper
 554     ImplDockingWindowWrapper *pWrapper = ImplGetDockingManager()->GetDockingWindowWrapper( this );
 555     if( pWrapper && pWrapper->GetFloatingWindow() && pWrapper->GetFloatingWindow()->IsInPopupMode() )
 556         pWrapper->GetFloatingWindow()->EndPopupMode();
 557 }
 558
 559 // -----------------------------------------------------------------------
 560
 561 void ToolBox::NextToolBox()
 562 {
 563     maNextToolBoxHdl.Call( this );
 564 }
 565
 566 // -----------------------------------------------------------------------
 567
 568 void ToolBox::Customize( const ToolBoxCustomizeEvent& )
 569 {
 570 }
 571
 572 // -----------------------------------------------------------------------
 573
 574 void ToolBox::UserDraw( const UserDrawEvent& )
 575 {
 576 }
 577
 578 // -----------------------------------------------------------------------
 579
 580 void ToolBox::InsertItem( const ResId& rResId, USHORT nPos )
 581 {
 582     ULONG                                       nObjMask;
 583     BOOL                                        bImage = FALSE;         // Wurde Image gesetzt
 584
 585     // Item anlegen
 586     ImplToolItem aItem;
 587
 588     GetRes( rResId.SetRT( RSC_TOOLBOXITEM ) );
 589     nObjMask                    = ReadLongRes();
 590
 591     if ( nObjMask & RSC_TOOLBOXITEM_ID )
 592         aItem.mnId = sal::static_int_cast<USHORT>(ReadLongRes());
 593     else
 594         aItem.mnId = 1;
 595
 596     if ( nObjMask & RSC_TOOLBOXITEM_TYPE )
 597         aItem.meType = (ToolBoxItemType)ReadLongRes();
 598
 599     if ( nObjMask & RSC_TOOLBOXITEM_STATUS )
 600         aItem.mnBits = (ToolBoxItemBits)ReadLongRes();
 601
 602     if( nObjMask & RSC_TOOLBOXITEM_HELPID )
 603         aItem.mnHelpId = ReadLongRes();
 604
 605     if ( nObjMask & RSC_TOOLBOXITEM_TEXT )
 606     {
 607         aItem.maText = ReadStringRes();
 608         aItem.maText = ImplConvertMenuString( aItem.maText );
 609     }
 610     if ( nObjMask & RSC_TOOLBOXITEM_HELPTEXT )
 611         aItem.maHelpText = ReadStringRes();
 612
 613     if ( nObjMask & RSC_TOOLBOXITEM_BITMAP )
 614     {
 615         Bitmap aBmp = Bitmap( ResId( (RSHEADER_TYPE*)GetClassRes(), *rResId.GetResMgr() ) );
 616         IncrementRes( GetObjSizeRes( (RSHEADER_TYPE*)GetClassRes() ) );
 617         aItem.maImage = Image( aBmp, IMAGE_STDBTN_COLOR );
 618         bImage = TRUE;
 619     }
 620     if ( nObjMask & RSC_TOOLBOXITEM_IMAGE )
 621     {
 622         aItem.maImage = Image( ResId( (RSHEADER_TYPE*)GetClassRes(), *rResId.GetResMgr() ) );
 623         IncrementRes( GetObjSizeRes( (RSHEADER_TYPE*)GetClassRes() ) );
 624         bImage = TRUE;
 625     }
 626     if ( nObjMask & RSC_TOOLBOXITEM_DISABLE )
 627         aItem.mbEnabled = !(BOOL)ReadShortRes();
 628
 629     if ( nObjMask & RSC_TOOLBOXITEM_STATE )
 630         aItem.meState   = (TriState)ReadLongRes();
 631
 632     if ( nObjMask & RSC_TOOLBOXITEM_HIDE )
 633         aItem.mbVisible = !((BOOL)ReadShortRes());
 634
 635     if ( nObjMask & RSC_TOOLBOXITEM_COMMAND )
 636         aItem.maCommandStr = ReadStringRes();
 637
 638     // Wenn kein Image geladen wurde, versuchen wir das Image aus der
 639     // Image-Liste zu holen
 640     if ( !bImage && aItem.mnId )
 641         aItem.maImage = maImageList.GetImage( aItem.mnId );
 642
 643     // Wenn es sich um ein ButtonItem handelt, die ID ueberpruefen
 644     BOOL bNewCalc;
 645     if ( aItem.meType != TOOLBOXITEM_BUTTON )
 646     {
 647         bNewCalc = FALSE;
 648         aItem.mnId = 0;
 649     }
 650     else
 651     {
 652         bNewCalc = TRUE;
 653
 654         DBG_ASSERT( aItem.mnId, "ToolBox::InsertItem(): ItemId == 0" );
 655         DBG_ASSERT( GetItemPos( aItem.mnId ) == TOOLBOX_ITEM_NOTFOUND,
 656                     "ToolBox::InsertItem(): ItemId already exists" );
 657     }
 658
 659     // Item anlegen und in die Liste einfuegen
 660     mpData->m_aItems.insert( (nPos < mpData->m_aItems.size()) ? mpData->m_aItems.begin()+nPos : mpData->m_aItems.end(), aItem );
 661     mpData->ImplClearLayoutData();
 662
 663     // ToolBox neu brechnen und neu ausgeben
 664     ImplInvalidate( bNewCalc );
 665
 666     // Notify
 667     USHORT nNewPos = sal::static_int_cast<USHORT>(( nPos == TOOLBOX_APPEND ) ? ( mpData->m_aItems.size() - 1 ) : nPos);
 668     ImplCallEventListeners( VCLEVENT_TOOLBOX_ITEMADDED, reinterpret_cast< void* >( nNewPos ) );
 669 }
 670
 671 // -----------------------------------------------------------------------
 672
 673 void ToolBox::InsertItem( USHORT nItemId, const Image& rImage,
 674                           ToolBoxItemBits nBits, USHORT nPos )
 675 {
 676     DBG_ASSERT( nItemId, "ToolBox::InsertItem(): ItemId == 0" );
 677     DBG_ASSERT( GetItemPos( nItemId ) == TOOLBOX_ITEM_NOTFOUND,
 678                 "ToolBox::InsertItem(): ItemId already exists" );
 679
 680     // Item anlegen und in die Liste einfuegen
 681     mpData->m_aItems.insert( (nPos < mpData->m_aItems.size()) ? mpData->m_aItems.begin()+nPos : mpData->m_aItems.end(), ImplToolItem( nItemId, rImage, nBits ) );
 682     mpData->ImplClearLayoutData();
 683
 684     ImplInvalidate( TRUE );
 685
 686     // Notify
 687     USHORT nNewPos = sal::static_int_cast<USHORT>(( nPos == TOOLBOX_APPEND ) ? ( mpData->m_aItems.size() - 1 ) : nPos);
 688     ImplCallEventListeners( VCLEVENT_TOOLBOX_ITEMADDED, reinterpret_cast< void* >(nNewPos ) );
 689 }
 690
 691 // -----------------------------------------------------------------------
 692
 693 void ToolBox::InsertItem( USHORT nItemId, const Image& rImage,
 694                           const XubString& rText,
 695                           ToolBoxItemBits nBits, USHORT nPos )
 696 {
 697     DBG_ASSERT( nItemId, "ToolBox::InsertItem(): ItemId == 0" );
 698     DBG_ASSERT( GetItemPos( nItemId ) == TOOLBOX_ITEM_NOTFOUND,
 699                 "ToolBox::InsertItem(): ItemId already exists" );
 700
 701     // Item anlegen und in die Liste einfuegen
 702     mpData->m_aItems.insert( (nPos < mpData->m_aItems.size()) ? mpData->m_aItems.begin()+nPos : mpData->m_aItems.end(), ImplToolItem( nItemId, rImage, ImplConvertMenuString( rText ), nBits ) );
 703     mpData->ImplClearLayoutData();
 704
 705     ImplInvalidate( TRUE );
 706
 707     // Notify
 708     USHORT nNewPos = sal::static_int_cast<USHORT>(( nPos == TOOLBOX_APPEND ) ? ( mpData->m_aItems.size() - 1 ) : nPos);
 709     ImplCallEventListeners( VCLEVENT_TOOLBOX_ITEMADDED, reinterpret_cast< void* >( nNewPos ) );
 710 }
 711
 712 // -----------------------------------------------------------------------
 713
 714 void ToolBox::InsertItem( USHORT nItemId, const XubString& rText,
 715                           ToolBoxItemBits nBits, USHORT nPos )
 716 {
 717     DBG_ASSERT( nItemId, "ToolBox::InsertItem(): ItemId == 0" );
 718     DBG_ASSERT( GetItemPos( nItemId ) == TOOLBOX_ITEM_NOTFOUND,
 719                 "ToolBox::InsertItem(): ItemId already exists" );
 720
 721     // Item anlegen und in die Liste einfuegen
 722     mpData->m_aItems.insert( (nPos < mpData->m_aItems.size()) ? mpData->m_aItems.begin()+nPos : mpData->m_aItems.end(), ImplToolItem( nItemId, ImplConvertMenuString( rText ), nBits ) );
 723     mpData->ImplClearLayoutData();
 724
 725     ImplInvalidate( TRUE );
 726
 727     // Notify
 728     USHORT nNewPos = sal::static_int_cast<USHORT>(( nPos == TOOLBOX_APPEND ) ? ( mpData->m_aItems.size() - 1 ) : nPos);
 729     ImplCallEventListeners( VCLEVENT_TOOLBOX_ITEMADDED, reinterpret_cast< void* >( nNewPos ) );
 730 }
 731
 732 // -----------------------------------------------------------------------
 733
 734 void ToolBox::InsertWindow( USHORT nItemId, Window* pWindow,
 735                             ToolBoxItemBits nBits, USHORT nPos )
 736 {
 737     DBG_ASSERT( nItemId, "ToolBox::InsertWindow(): ItemId == 0" );
 738     DBG_ASSERT( GetItemPos( nItemId ) == TOOLBOX_ITEM_NOTFOUND,
 739                 "ToolBox::InsertWindow(): ItemId already exists" );
 740
 741     // Item anlegen und in die Liste einfuegen
 742     ImplToolItem aItem;
 743     aItem.mnId           = nItemId;
 744     aItem.meType         = TOOLBOXITEM_BUTTON;
 745     aItem.mnBits         = nBits;
 746     aItem.mpWindow       = pWindow;
 747     mpData->m_aItems.insert( (nPos < mpData->m_aItems.size()) ? mpData->m_aItems.begin()+nPos : mpData->m_aItems.end(), aItem );
 748     mpData->ImplClearLayoutData();
 749
 750     if ( pWindow )
 751         pWindow->Hide();
 752
 753     ImplInvalidate( TRUE );
 754
 755     // Notify
 756     USHORT nNewPos = sal::static_int_cast<USHORT>(( nPos == TOOLBOX_APPEND ) ? ( mpData->m_aItems.size() - 1 ) : nPos);
 757     ImplCallEventListeners( VCLEVENT_TOOLBOX_ITEMADDED, reinterpret_cast< void* >( nNewPos ) );
 758 }
 759
 760 // -----------------------------------------------------------------------
 761
 762 void ToolBox::InsertSpace( USHORT nPos )
 763 {
 764     // Item anlegen und in die Liste einfuegen
 765     ImplToolItem aItem;
 766     aItem.meType         = TOOLBOXITEM_SPACE;
 767     aItem.mbEnabled      = FALSE;
 768     mpData->m_aItems.insert( (nPos < mpData->m_aItems.size()) ? mpData->m_aItems.begin()+nPos : mpData->m_aItems.end(), aItem );
 769     mpData->ImplClearLayoutData();
 770
 771     ImplInvalidate( FALSE );
 772
 773     // Notify
 774     USHORT nNewPos = sal::static_int_cast<USHORT>(( nPos == TOOLBOX_APPEND ) ? ( mpData->m_aItems.size() - 1 ) : nPos);
 775     ImplCallEventListeners( VCLEVENT_TOOLBOX_ITEMADDED, reinterpret_cast< void* >( nNewPos ) );
 776 }
 777
 778 // -----------------------------------------------------------------------
 779
 780 void ToolBox::InsertSeparator( USHORT nPos, USHORT nPixSize )
 781 {
 782     // Item anlegen und in die Liste einfuegen
 783     ImplToolItem aItem;
 784     aItem.meType         = TOOLBOXITEM_SEPARATOR;
 785     aItem.mbEnabled      = FALSE;
 786     if ( nPixSize )
 787         aItem.mnSepSize = nPixSize;
 788     mpData->m_aItems.insert( (nPos < mpData->m_aItems.size()) ? mpData->m_aItems.begin()+nPos : mpData->m_aItems.end(), aItem );
 789     mpData->ImplClearLayoutData();
 790
 791     ImplInvalidate( FALSE );
 792
 793     // Notify
 794     USHORT nNewPos = sal::static_int_cast<USHORT>(( nPos == TOOLBOX_APPEND ) ? ( mpData->m_aItems.size() - 1 ) : nPos);
 795     ImplCallEventListeners( VCLEVENT_TOOLBOX_ITEMADDED, reinterpret_cast< void* >( nNewPos ) );
 796 }
 797
 798 // -----------------------------------------------------------------------
 799
 800 void ToolBox::InsertBreak( USHORT nPos )
 801 {
 802     // Item anlegen und in die Liste einfuegen
 803     ImplToolItem aItem;
 804     aItem.meType         = TOOLBOXITEM_BREAK;
 805     aItem.mbEnabled      = FALSE;
 806     mpData->m_aItems.insert( (nPos < mpData->m_aItems.size()) ? mpData->m_aItems.begin()+nPos : mpData->m_aItems.end(), aItem );
 807     mpData->ImplClearLayoutData();
 808
 809     ImplInvalidate( FALSE );
 810
 811     // Notify
 812     USHORT nNewPos = sal::static_int_cast<USHORT>(( nPos == TOOLBOX_APPEND ) ? ( mpData->m_aItems.size() - 1 ) : nPos);
 813     ImplCallEventListeners( VCLEVENT_TOOLBOX_ITEMADDED, reinterpret_cast< void* >( nNewPos ) );
 814 }
 815
 816 // -----------------------------------------------------------------------
 817
 818 void ToolBox::RemoveItem( USHORT nPos )
 819 {
 820     if( nPos < mpData->m_aItems.size() )
 821     {
 822         BOOL bMustCalc;
 823         if ( mpData->m_aItems[nPos].meType == TOOLBOXITEM_BUTTON )
 824             bMustCalc = TRUE;
 825         else
 826             bMustCalc = FALSE;
 827
 828         if ( mpData->m_aItems[nPos].mpWindow )
 829             mpData->m_aItems[nPos].mpWindow->Hide();
 830
 831         // PaintRect um das removete Item erweitern
 832         maPaintRect.Union( mpData->m_aItems[nPos].maRect );
 833
 834         // Absichern gegen das Loeschen im Select-Handler
 835         if ( mpData->m_aItems[nPos].mnId == mnCurItemId )
 836             mnCurItemId = 0;
 837         if ( mpData->m_aItems[nPos].mnId == mnHighItemId )
 838             mnHighItemId = 0;
 839
 840         ImplInvalidate( bMustCalc );
 841
 842         mpData->m_aItems.erase( mpData->m_aItems.begin()+nPos );
 843         mpData->ImplClearLayoutData();
 844
 845         // Notify
 846         ImplCallEventListeners( VCLEVENT_TOOLBOX_ITEMREMOVED, reinterpret_cast< void* >( nPos ) );
 847     }
 848 }
 849
 850 // -----------------------------------------------------------------------
 851
 852 void ToolBox::MoveItem( USHORT nItemId, USHORT nNewPos )
 853 {
 854     USHORT nPos = GetItemPos( nItemId );
 855
 856     if ( nPos == nNewPos )
 857         return;
 858
 859     if ( nPos < nNewPos )
 860         nNewPos--;
 861
 862     // Existiert Item
 863     if ( nPos != TOOLBOX_ITEM_NOTFOUND )
 864     {
 865         // ToolBox-Item in der Liste verschieben
 866         ImplToolItem aItem = mpData->m_aItems[nPos];
 867         mpData->m_aItems.erase( mpData->m_aItems.begin()+nPos );
 868         mpData->m_aItems.insert( (nNewPos < mpData->m_aItems.size()) ? mpData->m_aItems.begin()+nNewPos : mpData->m_aItems.end(), aItem );
 869         mpData->ImplClearLayoutData();
 870
 871         // ToolBox neu ausgeben
 872         ImplInvalidate( FALSE );
 873
 874         // Notify
 875         if( nPos < nNewPos )    // only send one event, all indices above this item are invalid anyway
 876             ImplCallEventListeners( VCLEVENT_TOOLBOX_ITEMREMOVED, reinterpret_cast< void* >( nPos ) );
 877         else
 878         {
 879             USHORT nNewPos2 = sal::static_int_cast<USHORT>(( nNewPos == TOOLBOX_APPEND ) ? ( mpData->m_aItems.size() - 1 ) : nNewPos);
 880             ImplCallEventListeners( VCLEVENT_TOOLBOX_ITEMADDED, reinterpret_cast< void* >( nNewPos2 ) );
 881         }
 882     }
 883 }
 884
 885 // -----------------------------------------------------------------------
 886
 887 void ToolBox::CopyItem( const ToolBox& rToolBox, USHORT nItemId,
 888                         USHORT nNewPos )
 889 {
 890     DBG_ASSERT( GetItemPos( nItemId ) == TOOLBOX_ITEM_NOTFOUND,
 891                 "ToolBox::CopyItem(): ItemId already exists" );
 892
 893     USHORT nPos = rToolBox.GetItemPos( nItemId );
 894
 895     // Existiert Item
 896     if ( nPos != TOOLBOX_ITEM_NOTFOUND )
 897     {
 898         // ToolBox-Item in der Liste verschieben
 899         ImplToolItem aNewItem = rToolBox.mpData->m_aItems[nPos];
 900         // Bestimme Daten zuruecksetzen
 901         aNewItem.mpWindow          = NULL;
 902         aNewItem.mbShowWindow = FALSE;
 903
 904         mpData->m_aItems.insert( (nNewPos < mpData->m_aItems.size()) ? mpData->m_aItems.begin()+nNewPos : mpData->m_aItems.end(), aNewItem );
 905         mpData->ImplClearLayoutData();
 906         // ToolBox neu ausgeben
 907         ImplInvalidate( FALSE );
 908
 909         // Notify
 910         USHORT nNewPos2 = sal::static_int_cast<USHORT>(( nNewPos == TOOLBOX_APPEND ) ? ( mpData->m_aItems.size() - 1 ) : nNewPos);
 911         ImplCallEventListeners( VCLEVENT_TOOLBOX_ITEMADDED, reinterpret_cast< void* >( nNewPos2 ) );
 912     }
 913 }
 914
 915 // -----------------------------------------------------------------------
 916
 917 void ToolBox::CopyItems( const ToolBox& rToolBox )
 918 {
 919     mpData->ImplClearLayoutData();
 920     mpData->m_aItems = rToolBox.mpData->m_aItems;
 921     // Absichern gegen das Loeschen im Select-Handler
 922     mnCurItemId = 0;
 923     mnHighItemId = 0;
 924
 925     for( std::vector< ImplToolItem >::iterator it = mpData->m_aItems.begin();
 926          it != mpData->m_aItems.end(); ++it )
 927     {
 928         it->mpWindow            = NULL;
 929         it->mbShowWindow        = FALSE;
 930     }
 931
 932     ImplInvalidate( TRUE, TRUE );
 933
 934     // Notify
 935     ImplCallEventListeners( VCLEVENT_TOOLBOX_ALLITEMSCHANGED );
 936 }
 937
 938 // -----------------------------------------------------------------------
 939
 940 void ToolBox::Clear()
 941 {
 942     mpData->m_aItems.clear();
 943     mpData->ImplClearLayoutData();
 944
 945     // Absichern gegen das Loeschen im Select-Handler
 946     mnCurItemId = 0;
 947     mnHighItemId = 0;
 948
 949     ImplInvalidate( TRUE, TRUE );
 950
 951     // Notify
 952     ImplCallEventListeners( VCLEVENT_TOOLBOX_ALLITEMSCHANGED );
 953 }
 954
 955 // -----------------------------------------------------------------------
 956
 957 void ToolBox::SetButtonType( ButtonType eNewType )
 958 {
 959     if ( meButtonType != eNewType )
 960     {
 961         meButtonType = eNewType;
 962
 963         // Hier besser alles neu ausgeben, da es ansonsten zu Problemen
 964         // mit den per CopyBits kopierten Bereichen geben kann
 965         ImplInvalidate( TRUE );
 966     }
 967 }
 968
 969 // -----------------------------------------------------------------------
 970
 971 void ToolBox::SetToolboxButtonSize( ToolBoxButtonSize eSize )
 972 {
 973     if( mpData->meButtonSize != eSize )
 974     {
 975         mpData->meButtonSize = eSize;
 976         mbCalc = TRUE;
 977         mbFormat = TRUE;
 978     }
 979 }
 980
 981 ToolBoxButtonSize ToolBox::GetToolboxButtonSize() const
 982 {
 983     return mpData->meButtonSize;
 984 }
 985
 986 // -----------------------------------------------------------------------
 987
 988 const Size& ToolBox::GetDefaultImageSize() const
 989 {
 990     static Size aSmallButtonSize( TB_SMALLIMAGESIZE, TB_SMALLIMAGESIZE );
 991
 992     static ULONG s_nSymbolsStyle = STYLE_SYMBOLS_DEFAULT;
 993     static Size aLargeButtonSize( TB_LARGEIMAGESIZE, TB_LARGEIMAGESIZE );
 994
 995     ULONG nSymbolsStyle = Application::GetSettings().GetStyleSettings().GetCurrentSymbolsStyle();
 996     if ( s_nSymbolsStyle != nSymbolsStyle )
 997     {
 998         s_nSymbolsStyle = nSymbolsStyle;
 999         switch ( nSymbolsStyle )
1000         {
1001             case STYLE_SYMBOLS_INDUSTRIAL:
1002                 aLargeButtonSize = Size( TB_LARGEIMAGESIZE_INDUSTRIAL, TB_LARGEIMAGESIZE_INDUSTRIAL );
1003                 break;
1004             case STYLE_SYMBOLS_CRYSTAL:
1005                 aLargeButtonSize = Size( TB_LARGEIMAGESIZE_CRYSTAL, TB_LARGEIMAGESIZE_CRYSTAL );
1006                 break;
1007             default:
1008                 aLargeButtonSize = Size( TB_LARGEIMAGESIZE, TB_LARGEIMAGESIZE );
1009         }
1010     }
1011
1012     return GetToolboxButtonSize() == TOOLBOX_BUTTONSIZE_LARGE ? aLargeButtonSize : aSmallButtonSize;
1013 }
1014
1015 // -----------------------------------------------------------------------
1016
1017 void ToolBox::SetAlign( WindowAlign eNewAlign )
1018 {
1019     if ( meAlign != eNewAlign )
1020     {
1021         meAlign = eNewAlign;
1022
1023         if ( !ImplIsFloatingMode() )
1024         {
1025             // Setzen, ob Items horizontal oder vertikal angeordnet werden sollen
1026             if ( (eNewAlign == WINDOWALIGN_LEFT) || (eNewAlign == WINDOWALIGN_RIGHT) )
1027                 mbHorz = FALSE;
1028             else
1029                 mbHorz = TRUE;
1030
1031             // Hier alles neu ausgeben, da sich Border auch aendert
1032             mbCalc = TRUE;
1033             mbFormat = TRUE;
1034             if ( IsReallyVisible() && IsUpdateMode() )
1035                 Invalidate();
1036         }
1037     }
1038 }
1039
1040 // -----------------------------------------------------------------------
1041
1042 void ToolBox::SetLineCount( USHORT nNewLines )
1043 {
1044     if ( !nNewLines )
1045         nNewLines = 1;
1046
1047     if ( mnLines != nNewLines )
1048     {
1049         mnLines = nNewLines;
1050
1051         // Hier besser alles neu ausgeben, da es ansonsten zu Problemen
1052         // mit den per CopyBits kopierten Bereichen geben kann
1053         ImplInvalidate( FALSE );
1054     }
1055 }
1056
1057 // -----------------------------------------------------------------------
1058
1059 void ToolBox::SetPageScroll( BOOL b )
1060 {
1061     mpData->mbPageScroll = b;
1062 }
1063
1064 BOOL ToolBox::GetPageScroll()
1065 {
1066     return mpData->mbPageScroll;
1067 }
1068
1069 // -----------------------------------------------------------------------
1070
1071 void ToolBox::SetNextToolBox( const XubString& rStr )
1072 {
1073     BOOL bCalcNew = (!maNextToolBoxStr.Len() != !rStr.Len());
1074     maNextToolBoxStr = rStr;
1075     if ( bCalcNew )
1076         ImplInvalidate( TRUE, FALSE );
1077 }
1078
1079 // -----------------------------------------------------------------------
1080
1081 USHORT ToolBox::GetItemCount() const
1082 {
1083     return (USHORT)mpData->m_aItems.size();
1084 }
1085
1086 // -----------------------------------------------------------------------
1087
1088 ToolBoxItemType ToolBox::GetItemType( USHORT nPos ) const
1089 {
1090     return (nPos < mpData->m_aItems.size()) ? mpData->m_aItems[nPos].meType : TOOLBOXITEM_DONTKNOW;
1091 }
1092
1093 // -----------------------------------------------------------------------
1094
1095 USHORT ToolBox::GetItemPos( USHORT nItemId ) const
1096 {
1097     int nCount = mpData->m_aItems.size();
1098     for( int nPos = 0; nPos < nCount; nPos++ )
1099         if( mpData->m_aItems[nPos].mnId == nItemId )
1100             return (USHORT)nPos;
1101
1102     return TOOLBOX_ITEM_NOTFOUND;
1103 }
1104
1105 // -----------------------------------------------------------------------
1106
1107 USHORT ToolBox::GetItemPos( const Point& rPos ) const
1108 {
1109     // search the item position on the given point
1110     USHORT nRet = TOOLBOX_ITEM_NOTFOUND;
1111     USHORT nPos = 0;
1112     std::vector< ImplToolItem >::const_iterator it = mpData->m_aItems.begin();
1113     while( it != mpData->m_aItems.end() )
1114     {
1115         if ( it->maRect.IsInside( rPos ) )
1116         {
1117             // item found -> save position and break
1118             nRet = nPos;
1119             break;
1120         }
1121
1122         ++it;
1123         ++nPos;
1124     }
1125
1126     return nRet;
1127 }
1128
1129 // -----------------------------------------------------------------------
1130
1131 USHORT ToolBox::GetItemId( USHORT nPos ) const
1132 {
1133     return (nPos < mpData->m_aItems.size()) ? mpData->m_aItems[nPos].mnId : 0;
1134 }
1135
1136 // -----------------------------------------------------------------------
1137
1138 USHORT ToolBox::GetItemId( const Point& rPos ) const
1139 {
1140     // Item suchen, das geklickt wurde
1141     std::vector< ImplToolItem >::const_iterator it = mpData->m_aItems.begin();
1142     while( it != mpData->m_aItems.end() )
1143     {
1144         // Ist es dieses Item
1145         if ( it->maRect.IsInside( rPos ) )
1146         {
1147             if ( it->meType == TOOLBOXITEM_BUTTON )
1148                 return it->mnId;
1149             else
1150                 return 0;
1151         }
1152
1153         ++it;
1154     }
1155
1156     return 0;
1157 }
1158
1159 // -----------------------------------------------------------------------
1160
1161 Point ToolBox::ImplGetPopupPosition( const Rectangle& rRect, const Size& rSize ) const
1162 {
1163     Point aPos;
1164     if( !rRect.IsEmpty() )
1165     {
1166         Rectangle aScreen = GetDesktopRectPixel();
1167
1168         // the popup should be positioned so that it will not cover
1169         // the item rect and that it fits the desktop
1170         // the preferred direction is always towards the center of
1171         // the application window
1172
1173         Point devPos;           // the position in device coordinates for screen comparison
1174         switch( meAlign )
1175         {
1176             case WINDOWALIGN_TOP:
1177                 aPos = rRect.BottomLeft();
1178                 aPos.Y()++;
1179                 devPos = OutputToAbsoluteScreenPixel( aPos );
1180                 if( devPos.Y() + rSize.Height() >= aScreen.Bottom() )
1181                     aPos.Y() = rRect.Top() - rSize.Height();
1182                 break;
1183             case WINDOWALIGN_BOTTOM:
1184                 aPos = rRect.TopLeft();
1185                 aPos.Y()--;
1186                 devPos = OutputToAbsoluteScreenPixel( aPos );
1187                 if( devPos.Y() - rSize.Height() > aScreen.Top() )
1188                     aPos.Y() -= rSize.Height();
1189                 else
1190                     aPos.Y() = rRect.Bottom();
1191                 break;
1192             case WINDOWALIGN_LEFT:
1193                 aPos = rRect.TopRight();
1194                 aPos.X()++;
1195                 devPos = OutputToAbsoluteScreenPixel( aPos );
1196                 if( devPos.X() + rSize.Width() >= aScreen.Right() )
1197                     aPos.X() = rRect.Left() - rSize.Width();
1198                 break;
1199             case WINDOWALIGN_RIGHT:
1200                 aPos = rRect.TopLeft();
1201                 aPos.X()--;
1202                 devPos = OutputToAbsoluteScreenPixel( aPos );
1203                 if( devPos.X() - rSize.Width() > aScreen.Left() )
1204                     aPos.X() -= rSize.Width();
1205                 else
1206                     aPos.X() = rRect.Right();
1207                 break;
1208             default:
1209                 break;
1210         };
1211     }
1212     return aPos;
1213 }
1214
1215
1216 Point ToolBox::GetItemPopupPosition( USHORT nItemId, const Size& rSize ) const
1217 {
1218     return ImplGetPopupPosition( GetItemRect( nItemId ), rSize );
1219 }
1220
1221 // -----------------------------------------------------------------------
1222
1223 Rectangle ToolBox::GetItemRect( USHORT nItemId ) const
1224 {
1225     if ( mbCalc || mbFormat )
1226         ((ToolBox*)this)->ImplFormat();
1227
1228     USHORT nPos = GetItemPos( nItemId );
1229     return GetItemPosRect( nPos );
1230 }
1231
1232 // -----------------------------------------------------------------------
1233
1234 Rectangle ToolBox::GetItemPosRect( USHORT nPos ) const
1235 {
1236     if ( mbCalc || mbFormat )
1237         ((ToolBox*)this)->ImplFormat();
1238
1239     if ( nPos < mpData->m_aItems.size() )
1240         return mpData->m_aItems[nPos].maRect;
1241     else
1242         return Rectangle();
1243 }
1244
1245 // -----------------------------------------------------------------------
1246 Rectangle ToolBox::GetItemDropDownRect( USHORT nItemId ) const
1247 {
1248     if ( mbCalc || mbFormat )
1249         ((ToolBox*)this)->ImplFormat();
1250
1251     USHORT nPos = GetItemPos( nItemId );
1252     return GetItemPosDropDownRect( nPos );
1253 }
1254
1255 // -----------------------------------------------------------------------
1256
1257 Rectangle ToolBox::GetItemPosDropDownRect( USHORT nPos ) const
1258 {
1259     if ( mbCalc || mbFormat )
1260         ((ToolBox*)this)->ImplFormat();
1261
1262     if ( nPos < mpData->m_aItems.size() )
1263         return mpData->m_aItems[nPos].GetDropDownRect( mbHorz );
1264     else
1265         return Rectangle();
1266 }
1267
1268 // -----------------------------------------------------------------------
1269
1270 Rectangle ToolBox::GetMenubuttonRect() const
1271 {
1272     return mpData->maMenubuttonItem.maRect;
1273 }
1274
1275 BOOL ToolBox::ImplHasExternalMenubutton()
1276 {
1277     // check if the borderwindow (i.e. the decoration) provides the menu button
1278     BOOL bRet = FALSE;
1279     if( ImplIsFloatingMode() )
1280     {
1281         // custom menu is placed in the decoration
1282         ImplBorderWindow *pBorderWin = dynamic_cast<ImplBorderWindow*>( GetWindow( WINDOW_BORDER ) );
1283         if( pBorderWin && !pBorderWin->GetMenuRect().IsEmpty() )
1284             bRet = TRUE;
1285     }
1286     return bRet;
1287 }
1288 // -----------------------------------------------------------------------
1289
1290 void ToolBox::SetItemBits( USHORT nItemId, ToolBoxItemBits nBits )
1291 {
1292     USHORT nPos = GetItemPos( nItemId );
1293
1294     if ( nPos < mpData->m_aItems.size() )
1295     {
1296         ToolBoxItemBits nOldBits = mpData->m_aItems[nPos].mnBits;
1297         mpData->m_aItems[nPos].mnBits = nBits;
1298         nBits &= TIB_LEFT | TIB_AUTOSIZE | TIB_DROPDOWN;
1299         nOldBits &= TIB_LEFT | TIB_AUTOSIZE | TIB_DROPDOWN;
1300         // trigger reformat when the item width has changed (dropdown arrow)
1301         BOOL bFormat = (nBits & TIB_DROPDOWN) != (nOldBits & TIB_DROPDOWN);
1302         if ( nBits != nOldBits )
1303             ImplInvalidate( TRUE, bFormat );
1304     }
1305 }
1306
1307 // -----------------------------------------------------------------------
1308
1309 ToolBoxItemBits ToolBox::GetItemBits( USHORT nItemId ) const
1310 {
1311     ImplToolItem* pItem = ImplGetItem( nItemId );
1312
1313     if ( pItem )
1314         return pItem->mnBits;
1315     else
1316         return 0;
1317 }
1318
1319 // -----------------------------------------------------------------------
1320
1321 void ToolBox::SetItemData( USHORT nItemId, void* pNewData )
1322 {
1323     USHORT nPos = GetItemPos( nItemId );
1324
1325     if ( nPos < mpData->m_aItems.size() )
1326     {
1327         mpData->m_aItems[nPos].mpUserData = pNewData;
1328         ImplUpdateItem( nPos );
1329     }
1330 }
1331
1332 // -----------------------------------------------------------------------
1333
1334 void* ToolBox::GetItemData( USHORT nItemId ) const
1335 {
1336     ImplToolItem* pItem = ImplGetItem( nItemId );
1337
1338     if ( pItem )
1339         return pItem->mpUserData;
1340     else
1341         return NULL;
1342 }
1343
1344 // -----------------------------------------------------------------------
1345
1346 void ToolBox::SetItemImage( USHORT nItemId, const Image& rImage )
1347 {
1348     USHORT nPos = GetItemPos( nItemId );
1349
1350     if ( nPos != TOOLBOX_ITEM_NOTFOUND )
1351     {
1352         ImplToolItem* pItem = &mpData->m_aItems[nPos];
1353         // Nur wenn alles berechnet ist, mehr Aufwand treiben
1354         if ( !mbCalc )
1355         {
1356             Size aOldSize = pItem->maImage.GetSizePixel();
1357             pItem->maImage = rImage;
1358             if ( aOldSize != pItem->maImage.GetSizePixel() )
1359                 ImplInvalidate( TRUE );
1360             else
1361                 ImplUpdateItem( nPos );
1362         }
1363         else
1364             pItem->maImage = rImage;
1365     }
1366 }
1367
1368 // -----------------------------------------------------------------------
1369
1370 void ToolBox::SetImageList( const ImageList& rImageList )
1371 {
1372     maImageList = rImageList;
1373
1374     USHORT nCount = (USHORT)mpData->m_aItems.size();
1375     for( USHORT i = 0; i < nCount; i++ )
1376     {
1377         Image aImage;
1378         if ( mpData->m_aItems[i].mnId )
1379             aImage = maImageList.GetImage( mpData->m_aItems[i].mnId );
1380         if( !!aImage )
1381             SetItemImage( mpData->m_aItems[i].mnId, aImage );
1382     }
1383 }
1384
1385 // -----------------------------------------------------------------------
1386
1387 static Image ImplRotImage( const Image& rImage, long nAngle10 )
1388 {
1389     Image               aRet;
1390     BitmapEx    aRotBitmapEx( rImage.GetBitmapEx() );
1391
1392     aRotBitmapEx.Rotate( nAngle10, Color( COL_WHITE ) );
1393
1394     return Image( aRotBitmapEx );
1395 }
1396
1397 void ToolBox::SetItemImageAngle( USHORT nItemId, long nAngle10 )
1398 {
1399     USHORT nPos = GetItemPos( nItemId );
1400
1401     if ( nPos != TOOLBOX_ITEM_NOTFOUND )
1402     {
1403         ImplToolItem* pItem = &mpData->m_aItems[nPos];
1404         Size aOldSize = pItem->maImage.GetSizePixel();
1405
1406         long nDeltaAngle = (nAngle10 - pItem->mnImageAngle) % 3600;
1407         while( nDeltaAngle < 0 )
1408             nDeltaAngle += 3600;
1409
1410         pItem->mnImageAngle = nAngle10;
1411         if( nDeltaAngle && !!pItem->maImage )
1412         {
1413             pItem->maImage = ImplRotImage( pItem->maImage, nDeltaAngle );
1414             if( !!pItem->maHighImage )
1415                 pItem->maHighImage = ImplRotImage( pItem->maHighImage, nDeltaAngle );
1416         }
1417
1418         if ( !mbCalc )
1419         {
1420             if ( aOldSize != pItem->maImage.GetSizePixel() )
1421                 ImplInvalidate( TRUE );
1422             else
1423                 ImplUpdateItem( nPos );
1424         }
1425     }
1426 }
1427
1428 // -----------------------------------------------------------------------
1429
1430 static Image ImplMirrorImage( const Image& rImage )
1431 {
1432     Image               aRet;
1433     BitmapEx    aMirrBitmapEx( rImage.GetBitmapEx() );
1434
1435     aMirrBitmapEx.Mirror( BMP_MIRROR_HORZ );
1436
1437     return Image( aMirrBitmapEx );
1438 }
1439
1440 void ToolBox::SetItemImageMirrorMode( USHORT nItemId, BOOL bMirror )
1441 {
1442     USHORT nPos = GetItemPos( nItemId );
1443
1444     if ( nPos != TOOLBOX_ITEM_NOTFOUND )
1445     {
1446         ImplToolItem* pItem = &mpData->m_aItems[nPos];
1447
1448         if( ( pItem->mbMirrorMode && ! bMirror ) ||
1449             ( ! pItem->mbMirrorMode && bMirror )
1450             )
1451         {
1452             pItem->mbMirrorMode = bMirror ? true : false;
1453             if( !!pItem->maImage )
1454             {
1455                 pItem->maImage = ImplMirrorImage( pItem->maImage );
1456                 if( !!pItem->maHighImage )
1457                     pItem->maHighImage = ImplMirrorImage( pItem->maHighImage );
1458             }
1459
1460             if ( !mbCalc )
1461                 ImplUpdateItem( nPos );
1462         }
1463     }
1464 }
1465
1466 // -----------------------------------------------------------------------
1467
1468 Image ToolBox::GetItemImage( USHORT nItemId ) const
1469 {
1470     ImplToolItem* pItem = ImplGetItem( nItemId );
1471
1472     if ( pItem )
1473         return pItem->maImage;
1474     else
1475         return Image();
1476 }
1477
1478 // -----------------------------------------------------------------------
1479
1480 long ToolBox::GetItemImageAngle( USHORT nItemId ) const
1481 {
1482     ImplToolItem* pItem = ImplGetItem( nItemId );
1483
1484     if ( pItem )
1485         return pItem->mnImageAngle;
1486     else
1487         return 0;
1488 }
1489
1490 // -----------------------------------------------------------------------
1491
1492 BOOL ToolBox::GetItemImageMirrorMode( USHORT nItemId ) const
1493 {
1494     ImplToolItem* pItem = ImplGetItem( nItemId );
1495
1496     if ( pItem )
1497         return pItem->mbMirrorMode;
1498     else
1499         return FALSE;
1500 }
1501
1502 // -----------------------------------------------------------------------
1503
1504 void ToolBox::SetItemHighImage( USHORT nItemId, const Image& rImage )
1505 {
1506     ImplToolItem* pItem = ImplGetItem( nItemId );
1507     if ( pItem )
1508     {
1509         DBG_ASSERT( (pItem->maImage.GetSizePixel() == rImage.GetSizePixel()) ||
1510                     ((!rImage) == TRUE), "ToolBox::SetItemHighImage() - ImageSize != HighImageSize" );
1511         pItem->maHighImage = rImage;
1512     }
1513 }
1514
1515 // -----------------------------------------------------------------------
1516
1517 Image ToolBox::GetItemHighImage( USHORT nItemId ) const
1518 {
1519     ImplToolItem* pItem = ImplGetItem( nItemId );
1520
1521     if ( pItem )
1522         return pItem->maHighImage;
1523     else
1524         return Image();
1525 }
1526
1527 // -----------------------------------------------------------------------
1528
1529 void ToolBox::SetItemText( USHORT nItemId, const XubString& rText )
1530 {
1531     USHORT nPos = GetItemPos( nItemId );
1532
1533     if ( nPos != TOOLBOX_ITEM_NOTFOUND )
1534     {
1535         ImplToolItem* pItem = &mpData->m_aItems[nPos];
1536         // Nur wenn alles berechnet ist, mehr Aufwand treiben
1537         if ( !mbCalc &&
1538              ((meButtonType != BUTTON_SYMBOL) || !pItem->maImage) )
1539         {
1540             long nOldWidth = GetCtrlTextWidth( pItem->maText );
1541             pItem->maText = ImplConvertMenuString( rText );
1542             mpData->ImplClearLayoutData();
1543             if ( nOldWidth != GetCtrlTextWidth( pItem->maText ) )
1544                 ImplInvalidate( TRUE );
1545             else
1546                 ImplUpdateItem( nPos );
1547         }
1548         else
1549             pItem->maText = ImplConvertMenuString( rText );
1550
1551         // Notify button changed event to prepare accessibility bridge
1552         ImplCallEventListeners( VCLEVENT_TOOLBOX_BUTTONSTATECHANGED, reinterpret_cast< void* >( nPos ) );
1553
1554         // Notify
1555         ImplCallEventListeners( VCLEVENT_TOOLBOX_ITEMTEXTCHANGED, reinterpret_cast< void* >( nPos ) );
1556     }
1557 }
1558
1559 // -----------------------------------------------------------------------
1560
1561 const XubString& ToolBox::GetItemText( USHORT nItemId ) const
1562 {
1563     ImplToolItem* pItem = ImplGetItem( nItemId );
1564
1565     if ( pItem )
1566         return pItem->maText;
1567     else
1568         return ImplGetSVEmptyStr();
1569 }
1570
1571 // -----------------------------------------------------------------------
1572
1573 void ToolBox::SetItemWindow( USHORT nItemId, Window* pNewWindow )
1574 {
1575     USHORT nPos = GetItemPos( nItemId );
1576
1577     if ( nPos != TOOLBOX_ITEM_NOTFOUND )
1578     {
1579         ImplToolItem* pItem = &mpData->m_aItems[nPos];
1580         pItem->mpWindow = pNewWindow;
1581         if ( pNewWindow )
1582             pNewWindow->Hide();
1583         ImplInvalidate( TRUE );
1584         ImplCallEventListeners( VCLEVENT_TOOLBOX_ITEMWINDOWCHANGED, reinterpret_cast< void* >( nPos ) );
1585     }
1586 }
1587
1588 // -----------------------------------------------------------------------
1589
1590 Window* ToolBox::GetItemWindow( USHORT nItemId ) const
1591 {
1592     ImplToolItem* pItem = ImplGetItem( nItemId );
1593
1594     if ( pItem )
1595         return pItem->mpWindow;
1596     else
1597         return NULL;
1598 }
1599
1600 // -----------------------------------------------------------------------
1601
1602 void ToolBox::StartSelection()
1603 {
1604     if ( mbDrag )
1605         EndSelection();
1606
1607     if ( !mbSelection )
1608     {
1609         mbSelection  = TRUE;
1610         mnCurPos         = TOOLBOX_ITEM_NOTFOUND;
1611         mnCurItemId  = 0;
1612         Activate();
1613     }
1614 }
1615
1616 // -----------------------------------------------------------------------
1617
1618 void ToolBox::EndSelection()
1619 {
1620     mbCommandDrag = FALSE;
1621
1622     if ( mbDrag || mbSelection )
1623     {
1624         // Daten zuruecksetzen
1625         mbDrag = FALSE;
1626         mbSelection = FALSE;
1627         if ( mnCurPos != TOOLBOX_ITEM_NOTFOUND )
1628             ImplDrawItem( mnCurPos );
1629         EndTracking();
1630         ReleaseMouse();
1631         Deactivate();
1632     }
1633
1634     mnCurPos            = TOOLBOX_ITEM_NOTFOUND;
1635     mnCurItemId         = 0;
1636     mnDownItemId        = 0;
1637     mnMouseClicks       = 0;
1638     mnMouseModifier = 0;
1639 }
1640
1641 // -----------------------------------------------------------------------
1642
1643 void ToolBox::SetItemDown( USHORT nItemId, BOOL bDown, BOOL bRelease )
1644 {
1645     USHORT nPos = GetItemPos( nItemId );
1646
1647     if ( nPos != TOOLBOX_ITEM_NOTFOUND )
1648     {
1649         if ( bDown )
1650         {
1651             if ( nPos != mnCurPos )
1652             {
1653                 mnCurPos = nPos;
1654                 ImplDrawItem( mnCurPos, TRUE );
1655                 Flush();
1656             }
1657         }
1658         else
1659         {
1660             if ( nPos == mnCurPos )
1661             {
1662                 ImplDrawItem( mnCurPos, FALSE );
1663                 Flush();
1664                 mnCurPos = TOOLBOX_ITEM_NOTFOUND;
1665             }
1666         }
1667
1668         if ( bRelease )
1669         {
1670             if ( mbDrag || mbSelection )
1671             {
1672                 mbDrag = FALSE;
1673                 mbSelection = FALSE;
1674                 EndTracking();
1675                 ReleaseMouse();
1676                 Deactivate();
1677             }
1678
1679             mnCurItemId         = 0;
1680             mnDownItemId        = 0;
1681             mnMouseClicks       = 0;
1682             mnMouseModifier = 0;
1683         }
1684     }
1685 }
1686
1687 // -----------------------------------------------------------------------
1688
1689 BOOL ToolBox::IsItemDown( USHORT nItemId ) const
1690 {
1691     USHORT nPos = GetItemPos( nItemId );
1692
1693     if ( nPos != TOOLBOX_ITEM_NOTFOUND )
1694         return (nPos == mnCurPos);
1695     else
1696         return FALSE;
1697 }
1698
1699 // -----------------------------------------------------------------------
1700
1701 void ToolBox::SetItemState( USHORT nItemId, TriState eState )
1702 {
1703     USHORT nPos = GetItemPos( nItemId );
1704
1705     if ( nPos != TOOLBOX_ITEM_NOTFOUND )
1706     {
1707         ImplToolItem* pItem = &mpData->m_aItems[nPos];
1708
1709         // Hat sich der Status geaendert
1710         if ( pItem->meState != eState )
1711         {
1712             // Wenn RadioCheck, dann vorherigen unchecken
1713             if ( (eState == STATE_CHECK) && (pItem->mnBits & TIB_AUTOCHECK) &&
1714                  (pItem->mnBits & TIB_RADIOCHECK) )
1715             {
1716                 ImplToolItem*    pGroupItem;
1717                 USHORT                  nGroupPos;
1718                 USHORT                  nItemCount = GetItemCount();
1719
1720                 nGroupPos = nPos;
1721                 while ( nGroupPos )
1722                 {
1723                     pGroupItem = &mpData->m_aItems[nGroupPos-1];
1724                     if ( pGroupItem->mnBits & TIB_RADIOCHECK )
1725                     {
1726                         if ( pGroupItem->meState != STATE_NOCHECK )
1727                             SetItemState( pGroupItem->mnId, STATE_NOCHECK );
1728                     }
1729                     else
1730                         break;
1731                     nGroupPos--;
1732                 }
1733
1734                 nGroupPos = nPos+1;
1735                 while ( nGroupPos < nItemCount )
1736                 {
1737                     pGroupItem = &mpData->m_aItems[nGroupPos];
1738                     if ( pGroupItem->mnBits & TIB_RADIOCHECK )
1739                     {
1740                         if ( pGroupItem->meState != STATE_NOCHECK )
1741                             SetItemState( pGroupItem->mnId, STATE_NOCHECK );
1742                     }
1743                     else
1744                         break;
1745                     nGroupPos++;
1746                 }
1747             }
1748
1749             pItem->meState = eState;
1750             ImplUpdateItem( nPos );
1751
1752             // Notify button changed event to prepare accessibility bridge
1753             ImplCallEventListeners( VCLEVENT_TOOLBOX_BUTTONSTATECHANGED, reinterpret_cast< void* >( nPos ) );
1754
1755             // Notify
1756             ImplCallEventListeners( VCLEVENT_TOOLBOX_CLICK, reinterpret_cast< void* >( nPos ) );
1757         }
1758     }
1759 }
1760
1761 // -----------------------------------------------------------------------
1762
1763 TriState ToolBox::GetItemState( USHORT nItemId ) const
1764 {
1765     ImplToolItem* pItem = ImplGetItem( nItemId );
1766
1767     if ( pItem )
1768         return pItem->meState;
1769     else
1770         return STATE_NOCHECK;
1771 }
1772
1773 // -----------------------------------------------------------------------
1774
1775 void ToolBox::EnableItem( USHORT nItemId, BOOL bEnable )
1776 {
1777     USHORT nPos = GetItemPos( nItemId );
1778
1779     if ( nPos != TOOLBOX_ITEM_NOTFOUND )
1780     {
1781         ImplToolItem* pItem = &mpData->m_aItems[nPos];
1782         if ( bEnable )
1783             bEnable = TRUE;
1784         if ( pItem->mbEnabled != bEnable )
1785         {
1786             pItem->mbEnabled = bEnable;
1787
1788             // Gegebenenfalls das Fenster mit updaten
1789             if ( pItem->mpWindow )
1790                 pItem->mpWindow->Enable( pItem->mbEnabled );
1791
1792             // Item updaten
1793             ImplUpdateItem( nPos );
1794
1795             ImplUpdateInputEnable();
1796
1797             // Notify button changed event to prepare accessibility bridge
1798             ImplCallEventListeners( VCLEVENT_TOOLBOX_BUTTONSTATECHANGED, reinterpret_cast< void* >( nPos ) );
1799
1800             ImplCallEventListeners( bEnable ? VCLEVENT_TOOLBOX_ITEMENABLED : VCLEVENT_TOOLBOX_ITEMDISABLED, reinterpret_cast< void* >( nPos ) );
1801         }
1802     }
1803 }
1804
1805 // -----------------------------------------------------------------------
1806
1807 BOOL ToolBox::IsItemEnabled( USHORT nItemId ) const
1808 {
1809     ImplToolItem* pItem = ImplGetItem( nItemId );
1810
1811     if ( pItem )
1812         return pItem->mbEnabled;
1813     else
1814         return FALSE;
1815 }
1816
1817 // -----------------------------------------------------------------------
1818
1819 void ToolBox::ShowItem( USHORT nItemId, BOOL bVisible )
1820 {
1821     USHORT nPos = GetItemPos( nItemId );
1822     mpData->ImplClearLayoutData();
1823
1824     if ( nPos != TOOLBOX_ITEM_NOTFOUND )
1825     {
1826         ImplToolItem* pItem = &mpData->m_aItems[nPos];
1827         if ( pItem->mbVisible != bVisible )
1828         {
1829             pItem->mbVisible = bVisible;
1830             ImplInvalidate( FALSE );
1831         }
1832     }
1833 }
1834
1835 // -----------------------------------------------------------------------
1836
1837 BOOL ToolBox::IsItemVisible( USHORT nItemId ) const
1838 {
1839     ImplToolItem* pItem = ImplGetItem( nItemId );
1840
1841     if ( pItem )
1842         return pItem->mbVisible;
1843     else
1844         return FALSE;
1845 }
1846
1847 // -----------------------------------------------------------------------
1848
1849 BOOL ToolBox::IsItemReallyVisible( USHORT nItemId ) const
1850 {
1851     // is the item on the visible area of the toolbox?
1852     BOOL bRet = FALSE;
1853     Rectangle aRect( mnLeftBorder, mnTopBorder, mnDX-mnRightBorder, mnDY-mnBottomBorder );
1854     ImplToolItem* pItem = ImplGetItem( nItemId );
1855
1856     if ( pItem && pItem->mbVisible &&
1857          !pItem->maRect.IsEmpty() && aRect.IsOver( pItem->maRect ) )
1858     {
1859         bRet = TRUE;
1860     }
1861
1862     return bRet;
1863 }
1864
1865 // -----------------------------------------------------------------------
1866
1867 void ToolBox::SetItemCommand( USHORT nItemId, const XubString& rCommand )
1868 {
1869     ImplToolItem* pItem = ImplGetItem( nItemId );
1870
1871     if ( pItem )
1872         pItem->maCommandStr = rCommand;
1873 }
1874
1875 // -----------------------------------------------------------------------
1876
1877 const XubString& ToolBox::GetItemCommand( USHORT nItemId ) const
1878 {
1879     ImplToolItem* pItem = ImplGetItem( nItemId );
1880
1881     if ( pItem )
1882         return pItem->maCommandStr;
1883     else
1884         return ImplGetSVEmptyStr();
1885 }
1886
1887 // -----------------------------------------------------------------------
1888
1889 void ToolBox::SetQuickHelpText( USHORT nItemId, const XubString& rText )
1890 {
1891     ImplToolItem* pItem = ImplGetItem( nItemId );
1892
1893     if ( pItem )
1894         pItem->maQuickHelpText = rText;
1895 }
1896
1897 // -----------------------------------------------------------------------
1898
1899 const XubString& ToolBox::GetQuickHelpText( USHORT nItemId ) const
1900 {
1901     ImplToolItem* pItem = ImplGetItem( nItemId );
1902
1903     if ( pItem )
1904         return pItem->maQuickHelpText;
1905     else
1906         return ImplGetSVEmptyStr();
1907 }
1908
1909 // -----------------------------------------------------------------------
1910
1911 void ToolBox::SetHelpText( USHORT nItemId, const XubString& rText )
1912 {
1913     ImplToolItem* pItem = ImplGetItem( nItemId );
1914
1915     if ( pItem )
1916         pItem->maHelpText = rText;
1917 }
1918
1919 // -----------------------------------------------------------------------
1920
1921 const XubString& ToolBox::GetHelpText( USHORT nItemId ) const
1922 {
1923     return ImplGetHelpText( nItemId );
1924 }
1925
1926 // -----------------------------------------------------------------------
1927
1928 void ToolBox::SetHelpId( USHORT nItemId, ULONG nHelpId )
1929 {
1930     ImplToolItem* pItem = ImplGetItem( nItemId );
1931
1932     if ( pItem )
1933         pItem->mnHelpId = nHelpId;
1934 }
1935
1936 // -----------------------------------------------------------------------
1937
1938 ULONG ToolBox::GetHelpId( USHORT nItemId ) const
1939 {
1940     ImplToolItem* pItem = ImplGetItem( nItemId );
1941
1942     if ( pItem )
1943         return pItem->mnHelpId;
1944     else
1945         return 0;
1946 }
1947
1948 // -----------------------------------------------------------------------
1949
1950 void ToolBox::SetBorder( long nX, long nY )
1951 {
1952     mnBorderX = nX;
1953     mnBorderY = nY;
1954
1955     ImplInvalidate( TRUE, TRUE );
1956 }
1957
1958 // -----------------------------------------------------------------------
1959
1960 void ToolBox::SetOutStyle( USHORT nNewStyle )
1961 {
1962     // always force flat looking toolbars since NWF
1963     nNewStyle |= TOOLBOX_STYLE_FLAT;
1964
1965     if ( mnOutStyle != nNewStyle )
1966     {
1967         mnOutStyle = nNewStyle;
1968         ImplDisableFlatButtons();
1969
1970         // Damit das ButtonDevice neu angelegt wird
1971         if ( !(mnOutStyle & TOOLBOX_STYLE_FLAT) )
1972         {
1973             mnMaxItemWidth  = 1;
1974             mnMaxItemHeight = 1;
1975         }
1976
1977         ImplInvalidate( TRUE, TRUE );
1978     }
1979 }
1980
1981 // -----------------------------------------------------------------------
1982
1983 void ToolBox::RecalcItems()
1984 {
1985     ImplInvalidate( TRUE );
1986 }
1987
1988 // -----------------------------------------------------------------------
1989
1990 // disable key input if all items are disabled
1991
1992 void ToolBox::ImplUpdateInputEnable()
1993 {
1994     for( std::vector< ImplToolItem >::const_iterator it = mpData->m_aItems.begin();
1995          it != mpData->m_aItems.end(); ++it )
1996     {
1997         if( it->mbEnabled )
1998         {
1999             // at least one useful entry
2000             mpData->mbKeyInputDisabled = FALSE;
2001             return;
2002         }
2003     }
2004     mpData->mbKeyInputDisabled = TRUE;
2005 }
2006
2007 // -----------------------------------------------------------------------
2008
2009 void ToolBox::ImplFillLayoutData() const
2010 {
2011     mpData->m_pLayoutData = new ToolBoxLayoutData();
2012
2013     USHORT nCount = (USHORT)mpData->m_aItems.size();
2014     for( USHORT i = 0; i < nCount; i++ )
2015     {
2016         ImplToolItem* pItem = &mpData->m_aItems[i];
2017
2018         // Nur malen, wenn Rechteck im PaintRectangle liegt
2019         if ( !pItem->maRect.IsEmpty() )
2020             const_cast<ToolBox*>(this)->ImplDrawItem( i, FALSE, FALSE, TRUE );
2021     }
2022 }
2023
2024 // -----------------------------------------------------------------------
2025
2026 String ToolBox::GetDisplayText() const
2027 {
2028     if( ! mpData->m_pLayoutData )
2029         ImplFillLayoutData();
2030     return mpData->m_pLayoutData ? mpData->m_pLayoutData->m_aDisplayText : String();
2031 }
2032
2033 // -----------------------------------------------------------------------
2034
2035 Rectangle ToolBox::GetCharacterBounds( USHORT nItemID, long nIndex ) const
2036 {
2037     long nItemIndex = -1;
2038     if( ! mpData->m_pLayoutData )
2039         ImplFillLayoutData();
2040     if( mpData->m_pLayoutData )
2041     {
2042         for( ULONG i = 0; i < mpData->m_pLayoutData->m_aLineItemIds.size(); i++ )
2043         {
2044             if( mpData->m_pLayoutData->m_aLineItemIds[i] == nItemID )
2045             {
2046                 nItemIndex = mpData->m_pLayoutData->m_aLineIndices[i];
2047                 break;
2048             }
2049         }
2050     }
2051     return (mpData->m_pLayoutData && nItemIndex != -1) ? mpData->m_pLayoutData->GetCharacterBounds( nItemIndex+nIndex ) : Rectangle();
2052 }
2053
2054 // -----------------------------------------------------------------------
2055
2056 long ToolBox::GetIndexForPoint( const Point& rPoint, USHORT& rItemID ) const
2057 {
2058     long nIndex = -1;
2059     rItemID = 0;
2060     if( ! mpData->m_pLayoutData )
2061         ImplFillLayoutData();
2062     if( mpData->m_pLayoutData )
2063     {
2064         nIndex = mpData->m_pLayoutData->GetIndexForPoint( rPoint );
2065         for( ULONG i = 0; i < mpData->m_pLayoutData->m_aLineIndices.size(); i++ )
2066         {
2067             if( mpData->m_pLayoutData->m_aLineIndices[i] <= nIndex &&
2068                 (i == mpData->m_pLayoutData->m_aLineIndices.size()-1 || mpData->m_pLayoutData->m_aLineIndices[i+1] > nIndex) )
2069             {
2070                 rItemID = mpData->m_pLayoutData->m_aLineItemIds[i];
2071                 break;
2072             }
2073         }
2074     }
2075     return nIndex;
2076 }
2077
2078 // -----------------------------------------------------------------------
2079
2080 long ToolBox::GetTextCount() const
2081 {
2082     if( ! mpData->m_pLayoutData )
2083         ImplFillLayoutData();
2084     return mpData->m_pLayoutData ? mpData->m_pLayoutData->GetLineCount() : 0;
2085 }
2086
2087 // -----------------------------------------------------------------------
2088
2089 Pair ToolBox::GetTextStartEnd( long nText ) const
2090 {
2091     if( ! mpData->m_pLayoutData )
2092         ImplFillLayoutData();
2093     return mpData->m_pLayoutData ? mpData->m_pLayoutData->GetLineStartEnd( nText ) : Pair( -1, -1 );
2094 }
2095
2096 // -----------------------------------------------------------------------
2097
2098 USHORT ToolBox::GetDisplayItemId( long nText ) const
2099 {
2100     USHORT nItemId = 0;
2101     if( ! mpData->m_pLayoutData )
2102         ImplFillLayoutData();
2103     if( mpData->m_pLayoutData && nText >= 0 && (ULONG)nText < mpData->m_pLayoutData->m_aLineItemIds.size() )
2104         nItemId = mpData->m_pLayoutData->m_aLineItemIds[nText];
2105     return nItemId;
2106 }
2107
2108
2109 // -----------------------------------------------------------------------
2110
2111 void ToolBox::SetDropdownClickHdl( const Link& rLink )
2112 {
2113     mpData->maDropdownClickHdl = rLink;
2114 }
2115
2116 const Link& ToolBox::GetDropdownClickHdl() const
2117 {
2118     return mpData->maDropdownClickHdl;
2119 }
2120
2121 // -----------------------------------------------------------------------
2122
2123 void ToolBox::SetMenuType( USHORT aType )
2124 {
2125     if( aType != mpData->maMenuType )
2126     {
2127         mpData->maMenuType = aType;
2128         if( IsFloatingMode() )
2129         {
2130             // the menu button may have to be moved into the decoration which changes the layout
2131             ImplDockingWindowWrapper *pWrapper = ImplGetDockingManager()->GetDockingWindowWrapper( this );
2132             if( pWrapper )
2133                 pWrapper->ShowTitleButton( TITLE_BUTTON_MENU, ( aType & TOOLBOX_MENUTYPE_CUSTOMIZE) ? TRUE : FALSE );
2134
2135             mbFormat = TRUE;
2136             ImplFormat();
2137             ImplSetMinMaxFloatSize( this );
2138         }
2139         else
2140         {
2141             // trigger redraw of menu button
2142             if( !mpData->maMenubuttonItem.maRect.IsEmpty() )
2143                 Invalidate(mpData->maMenubuttonItem.maRect);
2144         }
2145     }
2146 }
2147
2148 USHORT ToolBox::GetMenuType() const
2149 {
2150     return mpData->maMenuType;
2151 }
2152
2153 BOOL ToolBox::IsMenuEnabled() const
2154 {
2155     return mpData->maMenuType != TOOLBOX_MENUTYPE_NONE;
2156 }
2157
2158 PopupMenu* ToolBox::GetMenu() const
2159 {
2160     return mpData->mpMenu;
2161 }
2162
2163 void ToolBox::SetMenuButtonHdl( const Link& rLink )
2164 {
2165     mpData->maMenuButtonHdl = rLink;
2166 }
2167
2168 const Link& ToolBox::GetMenuButtonHdl() const
2169 {
2170     return mpData->maMenuButtonHdl;
2171 }
2172
2173 // -----------------------------------------------------------------------
2174
2175 BOOL ToolBox::ImplHasClippedItems()
2176 {
2177     // are any items currently clipped ?
2178     ImplFormat();
2179     std::vector< ImplToolItem >::const_iterator it = mpData->m_aItems.begin();
2180     while ( it != mpData->m_aItems.end() )
2181     {
2182         if( it->IsClipped() )
2183             return TRUE;
2184         it++;
2185     }
2186     return FALSE;
2187 }
2188
2189 void ToolBox::ImplUpdateCustomMenu()
2190 {
2191     // fill clipped items into menu
2192     if( !IsMenuEnabled() )
2193         return;
2194
2195     PopupMenu *pMenu = GetMenu();
2196
2197     USHORT i = 0;
2198     // remove old entries
2199     while( i < pMenu->GetItemCount() )
2200     {
2201         if( pMenu->GetItemId( i ) >= TOOLBOX_MENUITEM_START )
2202         {
2203             pMenu->RemoveItem( i );
2204             i = 0;
2205         }
2206         else
2207             i++;
2208     }
2209
2210     // add menu items, starting from the end and inserting at pos 0
2211     if ( !mpData->m_aItems.empty() )
2212     {
2213         for ( std::vector< ImplToolItem >::reverse_iterator it(mpData->m_aItems.rbegin());
2214                 it != mpData->m_aItems.rend(); ++it)
2215         {
2216             if( it->IsClipped() )
2217             {
2218                 USHORT id = it->mnId + TOOLBOX_MENUITEM_START;
2219                 pMenu->InsertItem( id, it->maText, it->maImage, 0, 0 );
2220                 pMenu->EnableItem( id, it->mbEnabled );
2221                 pMenu->CheckItem( id, it->meState == STATE_CHECK );
2222             }
2223         }
2224     }
2225 }
2226
2227 IMPL_LINK( ToolBox, ImplCustomMenuListener, VclMenuEvent*, pEvent )
2228 {
2229     if( pEvent->GetMenu() == GetMenu() && pEvent->GetId() == VCLEVENT_MENU_SELECT )
2230     {
2231         USHORT id = GetMenu()->GetItemId( pEvent->GetItemPos() );
2232         if( id >= TOOLBOX_MENUITEM_START )
2233             TriggerItem( id - TOOLBOX_MENUITEM_START, FALSE, FALSE );
2234     }
2235     return 0;
2236 }
2237
2238 IMPL_LINK( ToolBox, ImplCallExecuteCustomMenu, void*, EMPTYARG )
2239 {
2240     mpData->mnEventId = 0;
2241     ImplExecuteCustomMenu();
2242     return 0;
2243 }
2244
2245 void ToolBox::ImplExecuteCustomMenu()
2246 {
2247     if( IsMenuEnabled() )
2248     {
2249         if( GetMenuType() & TOOLBOX_MENUTYPE_CUSTOMIZE )
2250             // call button handler to allow for menu customization
2251             mpData->maMenuButtonHdl.Call( this );
2252
2253         // register handler
2254         GetMenu()->AddEventListener( LINK( this, ToolBox, ImplCustomMenuListener ) );
2255
2256         // make sure all disabled entries will be shown
2257         GetMenu()->SetMenuFlags(
2258             GetMenu()->GetMenuFlags() | MENU_FLAG_ALWAYSSHOWDISABLEDENTRIES );
2259
2260         // toolbox might be destroyed during execute
2261         ImplDelData aDelData;
2262         ImplAddDel( &aDelData );
2263         ImplDelData aBorderDel;
2264         bool bBorderDel = false;
2265
2266         Window *pWin = this;
2267         Rectangle aMenuRect = mpData->maMenubuttonItem.maRect;
2268         if( IsFloatingMode() )
2269         {
2270             // custom menu is placed in the decoration
2271             ImplBorderWindow *pBorderWin = dynamic_cast<ImplBorderWindow*>( GetWindow( WINDOW_BORDER ) );
2272             if( pBorderWin && !pBorderWin->GetMenuRect().IsEmpty() )
2273             {
2274                 pWin = pBorderWin;
2275                 aMenuRect = pBorderWin->GetMenuRect();
2276                 pWin->ImplAddDel( &aBorderDel );
2277                 bBorderDel = true;
2278             }
2279         }
2280
2281         USHORT uId = GetMenu()->Execute( pWin, Rectangle( ImplGetPopupPosition( aMenuRect, Size() ), Size() ),
2282                                 POPUPMENU_EXECUTE_DOWN | POPUPMENU_NOMOUSEUPCLOSE );
2283
2284         if ( aDelData.IsDelete() )
2285             return;
2286         ImplRemoveDel( &aDelData );
2287
2288         if( GetMenu() )
2289             GetMenu()->RemoveEventListener( LINK( this, ToolBox, ImplCustomMenuListener ) );
2290         if( bBorderDel )
2291         {
2292             if( aBorderDel.IsDelete() )
2293                 return;
2294             pWin->ImplRemoveDel( &aBorderDel );
2295         }
2296
2297         pWin->Invalidate( aMenuRect );
2298
2299         if( uId )
2300             GrabFocusToDocument();
2301     }
2302 }
2303
2304 void ToolBox::ExecuteCustomMenu()
2305 {
2306     if( IsMenuEnabled() )
2307     {
2308         // handle custom menu asynchronously
2309         // to avoid problems if the toolbox is closed during menu execute
2310         ImplUpdateCustomMenu();
2311         Application::PostUserEvent( mpData->mnEventId, LINK( this, ToolBox, ImplCallExecuteCustomMenu ) );
2312     }
2313 }
2314
2315 // -----------------------------------------------------------------------
2316
2317 // checks override first, useful during calculation of sizes
2318 BOOL ToolBox::ImplIsFloatingMode() const
2319 {
2320     DBG_ASSERT( !(mpData->mbAssumeDocked && mpData->mbAssumeFloating),
2321         "ToolBox::ImplIsFloatingMode(): cannot assume docked and floating" );
2322
2323     if( mpData->mbAssumeDocked )
2324         return FALSE;
2325     else if( mpData->mbAssumeFloating )
2326         return TRUE;
2327     else
2328         return IsFloatingMode();
2329 }
2330
2331 // checks override first, useful during calculation of sizes
2332 BOOL ToolBox::ImplIsInPopupMode() const
2333 {
2334     if( mpData->mbAssumePopupMode )
2335         return TRUE;
2336     else
2337     {
2338         ImplDockingWindowWrapper *pWrapper = ImplGetDockingManager()->GetDockingWindowWrapper( this );
2339         return ( pWrapper && pWrapper->GetFloatingWindow() && pWrapper->GetFloatingWindow()->IsInPopupMode() );
2340     }
2341 }
2342
2343 // -----------------------------------------------------------------------
2344
2345 void ToolBox::Lock( BOOL bLock )
2346 {
2347     ImplDockingWindowWrapper *pWrapper = ImplGetDockingManager()->GetDockingWindowWrapper( this );
2348     if( !pWrapper )
2349         return;
2350     if( mpData->mbIsLocked != bLock )
2351     {
2352         mpData->mbIsLocked = bLock;
2353         if( !ImplIsFloatingMode() )
2354         {
2355             mbCalc = TRUE;
2356             mbFormat = TRUE;
2357             SetSizePixel( CalcWindowSizePixel(1) );
2358             Invalidate();
2359         }
2360     }
2361 }
2362
2363 // -----------------------------------------------------------------------
2364
2365 BOOL ToolBox::AlwaysLocked()
2366 {
2367     // read config item to determine toolbox behaviour, used for subtoolbars
2368
2369     static int nAlwaysLocked = -1;
2370
2371     if( nAlwaysLocked == -1 )
2372     {
2373         nAlwaysLocked = 0; // ask configuration only once
2374
2375         utl::OConfigurationNode aNode = utl::OConfigurationTreeRoot::tryCreateWithServiceFactory(
2376             vcl::unohelper::GetMultiServiceFactory(),
2377             OUString::createFromAscii( "/org.openoffice.Office.UI.GlobalSettings/Toolbars" ) );    // note: case sensisitive !
2378         if ( aNode.isValid() )
2379         {
2380             // feature enabled ?
2381             BOOL bStatesEnabled = BOOL();
2382             ::com::sun::star::uno::Any aValue = aNode.getNodeValue( OUString::createFromAscii( "StatesEnabled" ) );
2383             if( aValue >>= bStatesEnabled )
2384             {
2385                 if( bStatesEnabled == TRUE )
2386                 {
2387                     // now read the locking state
2388                     utl::OConfigurationNode aNode2 = utl::OConfigurationTreeRoot::tryCreateWithServiceFactory(
2389                         vcl::unohelper::GetMultiServiceFactory(),
2390                         OUString::createFromAscii( "/org.openoffice.Office.UI.GlobalSettings/Toolbars/States" ) );    // note: case sensisitive !
2391
2392                     BOOL bLocked = BOOL();
2393                     ::com::sun::star::uno::Any aValue2 = aNode2.getNodeValue( OUString::createFromAscii( "Locked" ) );
2394                     if( aValue2 >>= bLocked )
2395                         nAlwaysLocked = (bLocked == TRUE) ? 1 : 0;
2396                 }
2397             }
2398         }
2399     }
2400
2401     return nAlwaysLocked == 1 ? TRUE : FALSE;
2402 }
2403
2404 BOOL ToolBox::WillUsePopupMode() const
2405 {
2406     return mpData->mbWillUsePopupMode;
2407 }
2408
2409 void ToolBox::WillUsePopupMode( BOOL b )
2410 {
2411     mpData->mbWillUsePopupMode = b;
2412 }
2413
2414 void ToolBox::ImplUpdateImageList()
2415 {
2416     if (mpData->mpImageListProvider != NULL)
2417     {
2418         BOOL bIsDark = GetSettings().GetStyleSettings().GetFaceColor().IsDark();
2419         try
2420         {
2421             ImageListType eType = bIsDark ? vcl::HIGHCONTRAST_YES : vcl::HIGHCONTRAST_NO;
2422
2423             if (eType != mpData->meImageListType)
2424             {
2425                 vcl::IImageListProvider* pImageListProvider = mpData->mpImageListProvider;
2426                 SetImageList( pImageListProvider->getImageList(eType) );
2427                 mpData->meImageListType = eType;
2428             }
2429         }
2430         catch (com::sun::star::lang::IllegalArgumentException &) {}
2431     }
2432 }
2433
2434 void ToolBox::SetImageListProvider(vcl::IImageListProvider* _pProvider)
2435 {
2436     mpData->mpImageListProvider = _pProvider;
2437     ImplUpdateImageList();
2438 }
2439 // -----------------------------------------------------------------------