svtools/source/control/headbar.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: headbar.cxx,v $
  10  * $Revision: 1.15 $
  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_svtools.hxx"
  33
  34 #define _SV_HEADBAR_CXX
  35 #include <svtools/headbar.hxx>
  36 #include <tools/debug.hxx>
  37 #ifndef _TOOLS_LIST_HXX
  38 #include <tools/list.hxx>
  39 #endif
  40
  41 #ifndef _VCL_APP_HXX
  42 #include <vcl/svapp.hxx>
  43 #endif
  44 #ifndef _VCL_HELP_HXX
  45 #include <vcl/help.hxx>
  46 #endif
  47 #ifndef _VCL_IMAGE_HXX
  48 #include <vcl/image.hxx>
  49 #endif
  50 #include <com/sun/star/accessibility/XAccessible.hpp>
  51
  52 // =======================================================================
  53
  54 struct ImplHeadItem
  55 {
  56     USHORT                              mnId;
  57     HeaderBarItemBits   mnBits;
  58     long                                mnSize;
  59     ULONG                               mnHelpId;
  60     Image                               maImage;
  61     XubString                   maOutText;
  62     XubString                   maText;
  63     XubString                   maHelpText;
  64     void*                               mpUserData;
  65 };
  66
  67 DECLARE_LIST( ImplHeadItemList, ImplHeadItem* )
  68
  69 // =======================================================================
  70
  71 #define HEAD_ARROWSIZE1                         4
  72 #define HEAD_ARROWSIZE2                         7
  73
  74 #define HEADERBAR_TEXTOFF                       2
  75 #define HEADERBAR_ARROWOFF                      5
  76 #define HEADERBAR_SPLITOFF                      3
  77
  78 #define HEADERBAR_DRAGOFF                       4
  79 #define HEADERBAR_DRAGOUTOFF            15
  80
  81 #define HEAD_HITTEST_ITEM                       ((USHORT)0x0001)
  82 #define HEAD_HITTEST_DIVIDER            ((USHORT)0x0002)
  83
  84 // =======================================================================
  85
  86 void HeaderBar::ImplInit( WinBits nWinStyle )
  87 {
  88     mpItemList          = new ImplHeadItemList;
  89     mnBorderOff1        = 0;
  90     mnBorderOff2        = 0;
  91     mnOffset            = 0;
  92     mnDX                        = 0;
  93     mnDY                        = 0;
  94     mnDragSize          = 0;
  95     mnStartPos          = 0;
  96     mnDragPos           = 0;
  97     mnMouseOff          = 0;
  98     mnCurItemId         = 0;
  99     mnItemDragPos       = HEADERBAR_ITEM_NOTFOUND;
 100     mbDrag                      = FALSE;
 101     mbItemDrag          = FALSE;
 102     mbOutDrag           = FALSE;
 103     mbItemMode          = FALSE;
 104
 105     // StyleBits auswerten
 106     if ( nWinStyle & WB_DRAG )
 107         mbDragable = TRUE;
 108     else
 109         mbDragable = FALSE;
 110     if ( nWinStyle & WB_BUTTONSTYLE )
 111         mbButtonStyle = TRUE;
 112     else
 113         mbButtonStyle = FALSE;
 114     if ( nWinStyle & WB_BORDER )
 115     {
 116         mnBorderOff1 = 1;
 117         mnBorderOff2 = 1;
 118     }
 119     else
 120     {
 121         if ( nWinStyle & WB_BOTTOMBORDER )
 122             mnBorderOff2 = 1;
 123     }
 124
 125     ImplInitSettings( TRUE, TRUE, TRUE );
 126 }
 127
 128 // -----------------------------------------------------------------------
 129
 130 HeaderBar::HeaderBar( Window* pParent, WinBits nWinStyle ) :
 131     Window( pParent, nWinStyle & WB_3DLOOK )
 132 {
 133     ImplInit( nWinStyle );
 134     SetSizePixel( CalcWindowSizePixel() );
 135 }
 136
 137 // -----------------------------------------------------------------------
 138
 139 HeaderBar::HeaderBar( Window* pParent, const ResId& rResId ) :
 140     Window( pParent, rResId )
 141 {
 142     ImplInit( rResId.GetWinBits() );
 143 }
 144
 145 // -----------------------------------------------------------------------
 146
 147 HeaderBar::~HeaderBar()
 148 {
 149     // Alle Items loeschen
 150     ImplHeadItem* pItem = mpItemList->First();
 151     while ( pItem )
 152     {
 153         delete pItem;
 154         pItem = mpItemList->Next();
 155     }
 156
 157     delete mpItemList;
 158 }
 159
 160 // -----------------------------------------------------------------------
 161
 162 void HeaderBar::ImplInitSettings( BOOL bFont,
 163                                   BOOL bForeground, BOOL bBackground )
 164 {
 165     const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
 166
 167     if ( bFont )
 168     {
 169         Font aFont;
 170         aFont = rStyleSettings.GetToolFont();
 171         if ( IsControlFont() )
 172             aFont.Merge( GetControlFont() );
 173         SetZoomedPointFont( aFont );
 174     }
 175
 176     if ( bForeground || bFont )
 177     {
 178         Color aColor;
 179         if ( IsControlForeground() )
 180             aColor = GetControlForeground();
 181         else
 182             aColor = rStyleSettings.GetButtonTextColor();
 183         SetTextColor( aColor );
 184         SetTextFillColor();
 185     }
 186
 187     if ( bBackground )
 188     {
 189         Color aColor;
 190         if ( IsControlBackground() )
 191             aColor = GetControlBackground();
 192         else
 193             aColor = rStyleSettings.GetFaceColor();
 194         SetBackground( aColor );
 195     }
 196 }
 197
 198 // -----------------------------------------------------------------------
 199
 200 long HeaderBar::ImplGetItemPos( USHORT nPos ) const
 201 {
 202     long nX = -mnOffset;
 203     for ( USHORT i = 0; i < nPos; i++ )
 204         nX += mpItemList->GetObject( i )->mnSize;
 205     return nX;
 206 }
 207
 208 // -----------------------------------------------------------------------
 209
 210 Rectangle HeaderBar::ImplGetItemRect( USHORT nPos ) const
 211 {
 212     Rectangle aRect( ImplGetItemPos( nPos ), 0, 0, mnDY-1 );
 213     aRect.Right() = aRect.Left() + mpItemList->GetObject( nPos )->mnSize - 1;
 214     // Gegen Ueberlauf auf einigen Systemen testen
 215     if ( aRect.Right() > 16000 )
 216         aRect.Right() = 16000;
 217     return aRect;
 218 }
 219
 220 // -----------------------------------------------------------------------
 221
 222 USHORT HeaderBar::ImplHitTest( const Point& rPos,
 223                                long& nMouseOff, USHORT& nPos ) const
 224 {
 225     ImplHeadItem*       pItem;
 226     USHORT                      nCount = (USHORT)mpItemList->Count();
 227     BOOL                        bLastFixed = TRUE;
 228     long                        nX = -mnOffset;
 229
 230     for ( USHORT i = 0; i < nCount; i++ )
 231     {
 232         pItem = mpItemList->GetObject( i );
 233
 234         if ( rPos.X() < (nX+pItem->mnSize) )
 235         {
 236             USHORT nMode;
 237
 238             if ( !bLastFixed && (rPos.X() < (nX+HEADERBAR_SPLITOFF)) )
 239             {
 240                 nMode = HEAD_HITTEST_DIVIDER;
 241                 nPos = i-1;
 242                 nMouseOff = rPos.X()-nX+1;
 243             }
 244             else
 245             {
 246                 nPos = i;
 247
 248                 if ( !(pItem->mnBits & HIB_FIXED) && (rPos.X() >= (nX+pItem->mnSize-HEADERBAR_SPLITOFF)) )
 249                 {
 250                     nMode = HEAD_HITTEST_DIVIDER;
 251                     nMouseOff = rPos.X()-(nX+pItem->mnSize);
 252                 }
 253                 else
 254                 {
 255                     nMode = HEAD_HITTEST_ITEM;
 256                     nMouseOff = rPos.X()-nX;
 257                 }
 258             }
 259
 260             return nMode;
 261         }
 262
 263         if ( pItem->mnBits & HIB_FIXED )
 264             bLastFixed = TRUE;
 265         else
 266             bLastFixed = FALSE;
 267
 268         nX += pItem->mnSize;
 269     }
 270
 271     if ( !bLastFixed )
 272     {
 273         pItem = mpItemList->GetObject( nCount-1 );
 274         if ( (pItem->mnSize < 4)  && (rPos.X() < (nX+HEADERBAR_SPLITOFF)) )
 275         {
 276             nPos = nCount-1;
 277             nMouseOff = rPos.X()-nX+1;
 278             return HEAD_HITTEST_DIVIDER;
 279         }
 280     }
 281
 282     return 0;
 283 }
 284
 285 // -----------------------------------------------------------------------
 286
 287 void HeaderBar::ImplInvertDrag( USHORT nStartPos, USHORT nEndPos )
 288 {
 289     Rectangle aRect1 = ImplGetItemRect( nStartPos );
 290     Rectangle aRect2 = ImplGetItemRect( nEndPos );
 291     Point         aStartPos = aRect1.Center();
 292     Point         aEndPos = aStartPos;
 293     Rectangle aStartRect( aStartPos.X()-2, aStartPos.Y()-2,
 294                           aStartPos.X()+2, aStartPos.Y()+2 );
 295
 296     if ( nEndPos > nStartPos )
 297     {
 298         aStartPos.X() += 3;
 299         aEndPos.X() = aRect2.Right()-6;
 300     }
 301     else
 302     {
 303         aStartPos.X() -= 3;
 304         aEndPos.X() = aRect2.Left()+6;
 305     }
 306
 307     SetRasterOp( ROP_INVERT );
 308     DrawRect( aStartRect );
 309     DrawLine( aStartPos, aEndPos );
 310     if ( nEndPos > nStartPos )
 311     {
 312         DrawLine( Point( aEndPos.X()+1, aEndPos.Y()-3 ),
 313                   Point( aEndPos.X()+1, aEndPos.Y()+3 ) );
 314         DrawLine( Point( aEndPos.X()+2, aEndPos.Y()-2 ),
 315                   Point( aEndPos.X()+2, aEndPos.Y()+2 ) );
 316         DrawLine( Point( aEndPos.X()+3, aEndPos.Y()-1 ),
 317                   Point( aEndPos.X()+3, aEndPos.Y()+1 ) );
 318         DrawPixel( Point( aEndPos.X()+4, aEndPos.Y() ) );
 319     }
 320     else
 321     {
 322         DrawLine( Point( aEndPos.X()-1, aEndPos.Y()-3 ),
 323                   Point( aEndPos.X()-1, aEndPos.Y()+3 ) );
 324         DrawLine( Point( aEndPos.X()-2, aEndPos.Y()-2 ),
 325                   Point( aEndPos.X()-2, aEndPos.Y()+2 ) );
 326         DrawLine( Point( aEndPos.X()-3, aEndPos.Y()-1 ),
 327                   Point( aEndPos.X()-3, aEndPos.Y()+1 ) );
 328         DrawPixel( Point( aEndPos.X()-4, aEndPos.Y() ) );
 329     }
 330     SetRasterOp( ROP_OVERPAINT );
 331 }
 332
 333 // -----------------------------------------------------------------------
 334
 335 void HeaderBar::ImplDrawItem( OutputDevice* pDev,
 336                               USHORT nPos, BOOL bHigh, BOOL bDrag,
 337                               const Rectangle& rItemRect,
 338                               const Rectangle* pRect,
 339                               ULONG )
 340 {
 341     Rectangle aRect = rItemRect;
 342
 343     // Wenn kein Platz, dann brauchen wir auch nichts ausgeben
 344     if ( aRect.GetWidth() <= 1 )
 345         return;
 346
 347     // Feststellen, ob Rectangle ueberhaupt sichtbar
 348     if ( pRect )
 349     {
 350         if ( aRect.Right() < pRect->Left() )
 351             return;
 352         else if ( aRect.Left() > pRect->Right() )
 353             return;
 354     }
 355     else
 356     {
 357         if ( aRect.Right() < 0 )
 358             return;
 359         else if ( aRect.Left() > mnDX )
 360             return;
 361     }
 362
 363     ImplHeadItem*                       pItem  = mpItemList->GetObject( nPos );
 364     HeaderBarItemBits           nBits = pItem->mnBits;
 365     const StyleSettings&        rStyleSettings = GetSettings().GetStyleSettings();
 366
 367     // Border muss nicht gemalt werden
 368     aRect.Top()         += mnBorderOff1;
 369     aRect.Bottom()      -= mnBorderOff2;
 370
 371     // Hintergrund loeschen
 372     if ( !pRect || bDrag )
 373     {
 374         if ( bDrag )
 375         {
 376             pDev->SetLineColor();
 377             pDev->SetFillColor( rStyleSettings.GetCheckedColor() );
 378             pDev->DrawRect( aRect );
 379         }
 380         else
 381             pDev->DrawWallpaper( aRect, GetBackground() );
 382     }
 383
 384     // Trennlinie malen
 385     pDev->SetLineColor( rStyleSettings.GetDarkShadowColor() );
 386     pDev->DrawLine( Point( aRect.Right(), aRect.Top() ),
 387                     Point( aRect.Right(), aRect.Bottom() ) );
 388
 389     // ButtonStyle malen
 390     // avoid 3D borders
 391     Color aSelectionTextColor( COL_TRANSPARENT );
 392     if( bHigh )
 393         DrawSelectionBackground( aRect, 1, TRUE, FALSE, FALSE, &aSelectionTextColor );
 394     else if ( !mbButtonStyle || (nBits & HIB_FLAT) )
 395         DrawSelectionBackground( aRect, 0, TRUE, FALSE, FALSE, &aSelectionTextColor );
 396
 397     // Wenn kein Platz, dann brauchen wir auch nichts ausgeben
 398     if ( aRect.GetWidth() < 1 )
 399         return;
 400
 401     // Positionen und Groessen berechnen und Inhalt ausgeben
 402     pItem->maOutText = pItem->maText;
 403     Size aImageSize = pItem->maImage.GetSizePixel();
 404     Size aTxtSize( pDev->GetTextWidth( pItem->maOutText ), 0  );
 405     if ( pItem->maOutText.Len() )
 406         aTxtSize.Height() = pDev->GetTextHeight();
 407     long nArrowWidth = 0;
 408     if ( nBits & (HIB_UPARROW | HIB_DOWNARROW) )
 409         nArrowWidth = HEAD_ARROWSIZE2+HEADERBAR_ARROWOFF;
 410
 411     // Wenn kein Platz fuer Image, dann nicht ausgeben
 412     long nTestHeight = aImageSize.Height();
 413     if ( !(nBits & (HIB_LEFTIMAGE | HIB_RIGHTIMAGE)) )
 414         nTestHeight += aTxtSize.Height();
 415     if ( (aImageSize.Width() > aRect.GetWidth()) || (nTestHeight > aRect.GetHeight()) )
 416     {
 417         aImageSize.Width() = 0;
 418         aImageSize.Height() = 0;
 419     }
 420
 421     // Text auf entsprechende Laenge kuerzen
 422     BOOL bLeftText = FALSE;
 423     long nMaxTxtWidth = aRect.GetWidth()-(HEADERBAR_TEXTOFF*2)-nArrowWidth;
 424     if ( nBits & (HIB_LEFTIMAGE | HIB_RIGHTIMAGE) )
 425         nMaxTxtWidth -= aImageSize.Width();
 426     long nTxtWidth = aTxtSize.Width();
 427     if ( nTxtWidth > nMaxTxtWidth )
 428     {
 429         bLeftText = TRUE;
 430         // 3 == Len of "..."
 431         pItem->maOutText.AppendAscii( "..." );
 432         do
 433         {
 434             pItem->maOutText.Erase( pItem->maOutText.Len()-3-1, 1 );
 435             nTxtWidth = pDev->GetTextWidth( pItem->maOutText );
 436         }
 437         while ( (nTxtWidth > nMaxTxtWidth) && (pItem->maOutText.Len() > 3) );
 438         if ( pItem->maOutText.Len() == 3 )
 439         {
 440             nTxtWidth = 0;
 441             pItem->maOutText.Erase();
 442         }
 443     }
 444
 445     // Text/Imageposition berechnen
 446     long nTxtPos;
 447     if ( !bLeftText && (nBits & HIB_RIGHT) )
 448     {
 449         nTxtPos = aRect.Right()-nTxtWidth-HEADERBAR_TEXTOFF;
 450         if ( nBits & HIB_RIGHTIMAGE )
 451             nTxtPos -= aImageSize.Width();
 452     }
 453     else if ( !bLeftText && (nBits & HIB_CENTER) )
 454     {
 455         long nTempWidth = nTxtWidth;
 456         if ( nBits & (HIB_LEFTIMAGE | HIB_RIGHTIMAGE) )
 457             nTempWidth += aImageSize.Width();
 458         nTxtPos = aRect.Left()+(aRect.GetWidth()-nTempWidth)/2;
 459         if ( nBits & HIB_LEFTIMAGE )
 460             nTxtPos += aImageSize.Width();
 461         if ( nArrowWidth )
 462         {
 463             if ( nTxtPos+nTxtWidth+nArrowWidth >= aRect.Right() )
 464             {
 465                 nTxtPos = aRect.Left()+HEADERBAR_TEXTOFF;
 466                 if ( nBits & HIB_LEFTIMAGE )
 467                     nTxtPos += aImageSize.Width();
 468             }
 469         }
 470     }
 471     else
 472     {
 473         nTxtPos = aRect.Left()+HEADERBAR_TEXTOFF;
 474         if ( nBits & HIB_LEFTIMAGE )
 475             nTxtPos += aImageSize.Width();
 476         if ( nBits & HIB_RIGHT )
 477             nTxtPos += nArrowWidth;
 478     }
 479
 480     // TextPosition berechnen
 481     long nTxtPosY = 0;
 482     if ( pItem->maOutText.Len() || (nArrowWidth && aTxtSize.Height()) )
 483     {
 484         if ( nBits & HIB_TOP )
 485         {
 486             nTxtPosY = aRect.Top();
 487             if ( !(nBits & (HIB_LEFTIMAGE | HIB_RIGHTIMAGE)) )
 488                 nTxtPosY += aImageSize.Height();
 489         }
 490         else if ( nBits & HIB_BOTTOM )
 491             nTxtPosY = aRect.Bottom()-aTxtSize.Height();
 492         else
 493         {
 494             long nTempHeight = aTxtSize.Height();
 495             if ( !(nBits & (HIB_LEFTIMAGE | HIB_RIGHTIMAGE)) )
 496                 nTempHeight += aImageSize.Height();
 497             nTxtPosY = aRect.Top()+((aRect.GetHeight()-nTempHeight)/2);
 498             if ( !(nBits & (HIB_LEFTIMAGE | HIB_RIGHTIMAGE)) )
 499                 nTxtPosY += aImageSize.Height();
 500         }
 501     }
 502
 503     // Text ausgebeben
 504     if ( pItem->maOutText.Len() )
 505     {
 506         if( aSelectionTextColor != Color( COL_TRANSPARENT ) )
 507         {
 508             pDev->Push( PUSH_TEXTCOLOR );
 509             pDev->SetTextColor( aSelectionTextColor );
 510         }
 511         if ( IsEnabled() )
 512             pDev->DrawText( Point( nTxtPos, nTxtPosY ), pItem->maOutText );
 513         else
 514             pDev->DrawCtrlText( Point( nTxtPos, nTxtPosY ), pItem->maOutText, 0, STRING_LEN, TEXT_DRAW_DISABLE );
 515         if( aSelectionTextColor != Color( COL_TRANSPARENT ) )
 516             pDev->Pop();
 517     }
 518
 519     // Wenn Image vorhanden, Position berechnen und ausgeben
 520     long nImagePosY = 0;
 521     if ( aImageSize.Width() && aImageSize.Height() )
 522     {
 523         long nImagePos = nTxtPos;
 524         if ( nBits & HIB_LEFTIMAGE )
 525         {
 526             nImagePos -= aImageSize.Width();
 527             if ( nBits & HIB_RIGHT )
 528                 nImagePos -= nArrowWidth;
 529         }
 530         else if ( nBits & HIB_RIGHTIMAGE )
 531         {
 532             nImagePos += nTxtWidth;
 533             if ( !(nBits & HIB_RIGHT) )
 534                 nImagePos += nArrowWidth;
 535         }
 536         else
 537         {
 538             if ( nBits & HIB_RIGHT )
 539                 nImagePos = aRect.Right()-aImageSize.Width();
 540             else if ( nBits & HIB_CENTER )
 541                 nImagePos = aRect.Left()+(aRect.GetWidth()-aImageSize.Width())/2;
 542             else
 543                 nImagePos = aRect.Left()+HEADERBAR_TEXTOFF;
 544         }
 545
 546         if ( nBits & HIB_TOP )
 547             nImagePosY = aRect.Top();
 548         else if ( nBits & HIB_BOTTOM )
 549         {
 550             nImagePosY = aRect.Bottom()-aImageSize.Height();
 551             if ( !(nBits & (HIB_LEFTIMAGE | HIB_RIGHTIMAGE)) )
 552                 nImagePosY -= aTxtSize.Height();
 553         }
 554         else
 555         {
 556             long nTempHeight = aImageSize.Height();
 557             if ( !(nBits & (HIB_LEFTIMAGE | HIB_RIGHTIMAGE)) )
 558                 nTempHeight += aTxtSize.Height();
 559             nImagePosY = aRect.Top()+((aRect.GetHeight()-nTempHeight)/2);
 560         }
 561         if ( nImagePos+aImageSize.Width() <= aRect.Right() )
 562         {
 563             USHORT nStyle = 0;
 564             if ( !IsEnabled() )
 565                 nStyle |= IMAGE_DRAW_DISABLE;
 566             pDev->DrawImage( Point( nImagePos, nImagePosY ), pItem->maImage, nStyle );
 567         }
 568     }
 569
 570     if ( nBits & (HIB_UPARROW | HIB_DOWNARROW) )
 571     {
 572         long nArrowX = nTxtPos;
 573         if ( nBits & HIB_RIGHT )
 574             nArrowX -= nArrowWidth;
 575         else
 576             nArrowX += nTxtWidth+HEADERBAR_ARROWOFF;
 577         if ( !(nBits & (HIB_LEFTIMAGE | HIB_RIGHTIMAGE)) && !pItem->maText.Len() )
 578         {
 579             if ( nBits & HIB_RIGHT )
 580                 nArrowX -= aImageSize.Width();
 581             else
 582                 nArrowX += aImageSize.Width();
 583         }
 584
 585         // Feststellen, ob Platz genug ist, das Item zu malen
 586         BOOL bDraw = TRUE;
 587         if ( nArrowX < aRect.Left()+HEADERBAR_TEXTOFF )
 588             bDraw = FALSE;
 589         else if ( nArrowX+HEAD_ARROWSIZE2 > aRect.Right() )
 590             bDraw = FALSE;
 591
 592         if ( bDraw )
 593         {
 594             long nArrowY;
 595             if ( aTxtSize.Height() )
 596                 nArrowY = nTxtPosY+(aTxtSize.Height()/2);
 597             else if ( aImageSize.Width() && aImageSize.Height() )
 598                 nArrowY = nImagePosY+(aImageSize.Height()/2);
 599             else
 600             {
 601                 if ( nBits & HIB_TOP )
 602                     nArrowY = aRect.Top()+1;
 603                 else if ( nBits & HIB_BOTTOM )
 604                     nArrowY = aRect.Bottom()-HEAD_ARROWSIZE2-1;
 605                 else
 606                     nArrowY = aRect.Top()+((aRect.GetHeight()-HEAD_ARROWSIZE2)/2);;
 607             }
 608             nArrowY -= HEAD_ARROWSIZE1-1;
 609             if ( nBits & HIB_DOWNARROW )
 610             {
 611                 pDev->SetLineColor( rStyleSettings.GetLightColor() );
 612                 pDev->DrawLine( Point( nArrowX, nArrowY ),
 613                                 Point( nArrowX+HEAD_ARROWSIZE2, nArrowY ) );
 614                 pDev->DrawLine( Point( nArrowX, nArrowY ),
 615                                 Point( nArrowX+HEAD_ARROWSIZE1, nArrowY+HEAD_ARROWSIZE2 ) );
 616                 pDev->SetLineColor( rStyleSettings.GetShadowColor() );
 617                 pDev->DrawLine( Point( nArrowX+HEAD_ARROWSIZE1, nArrowY+HEAD_ARROWSIZE2 ),
 618                                 Point( nArrowX+HEAD_ARROWSIZE2, nArrowY ) );
 619             }
 620             else
 621             {
 622                 pDev->SetLineColor( rStyleSettings.GetLightColor() );
 623                 pDev->DrawLine( Point( nArrowX, nArrowY+HEAD_ARROWSIZE2 ),
 624                                 Point( nArrowX+HEAD_ARROWSIZE1, nArrowY ) );
 625                 pDev->SetLineColor( rStyleSettings.GetShadowColor() );
 626                 pDev->DrawLine( Point( nArrowX, nArrowY+HEAD_ARROWSIZE2 ),
 627                                 Point( nArrowX+HEAD_ARROWSIZE2, nArrowY+HEAD_ARROWSIZE2 ) );
 628                 pDev->DrawLine( Point( nArrowX+HEAD_ARROWSIZE2, nArrowY+HEAD_ARROWSIZE2 ),
 629                                 Point( nArrowX+HEAD_ARROWSIZE1, nArrowY ) );
 630             }
 631         }
 632     }
 633
 634     // Gegebenenfalls auch UserDraw aufrufen
 635     if ( nBits & HIB_USERDRAW )
 636     {
 637         Region aRegion( aRect );
 638         if ( pRect )
 639             aRegion.Intersect( *pRect );
 640         pDev->SetClipRegion( aRegion );
 641         UserDrawEvent aODEvt( pDev, aRect, pItem->mnId );
 642         UserDraw( aODEvt );
 643         pDev->SetClipRegion();
 644     }
 645 }
 646
 647 // -----------------------------------------------------------------------
 648
 649 void HeaderBar::ImplDrawItem( USHORT nPos, BOOL bHigh, BOOL bDrag,
 650                               const Rectangle* pRect )
 651 {
 652     Rectangle aRect = ImplGetItemRect( nPos );
 653     ImplDrawItem( this, nPos, bHigh, bDrag, aRect, pRect, 0 );
 654 }
 655
 656 // -----------------------------------------------------------------------
 657
 658 void HeaderBar::ImplUpdate( USHORT nPos, BOOL bEnd, BOOL bDirect )
 659 {
 660     if ( IsVisible() && IsUpdateMode() )
 661     {
 662         if ( !bDirect )
 663         {
 664             Rectangle   aRect;
 665             USHORT              nItemCount = (USHORT)(mpItemList->Count());
 666             if ( nPos < nItemCount )
 667                 aRect = ImplGetItemRect( nPos );
 668             else
 669             {
 670                 aRect.Bottom() = mnDY-1;
 671                 if ( nItemCount )
 672                     aRect.Left() = ImplGetItemRect( nItemCount-1 ).Right();
 673             }
 674             if ( bEnd )
 675                 aRect.Right() = mnDX-1;
 676             aRect.Top()         += mnBorderOff1;
 677             aRect.Bottom()      -= mnBorderOff2;
 678             Invalidate( aRect );
 679         }
 680         else
 681         {
 682             for ( USHORT i = nPos; i < mpItemList->Count(); i++ )
 683                 ImplDrawItem( i );
 684             if ( bEnd )
 685             {
 686                 Rectangle aRect = ImplGetItemRect( (USHORT)mpItemList->Count() );
 687                 aRect.Left()  = aRect.Right();
 688                 aRect.Right() = mnDX-1;
 689                 if ( aRect.Left() < aRect.Right() )
 690                 {
 691                     aRect.Top()         += mnBorderOff1;
 692                     aRect.Bottom()      -= mnBorderOff2;
 693                     Erase( aRect );
 694                 }
 695             }
 696         }
 697     }
 698 }
 699
 700 // -----------------------------------------------------------------------
 701
 702 void HeaderBar::ImplStartDrag( const Point& rMousePos, BOOL bCommand )
 703 {
 704     USHORT      nPos;
 705     USHORT      nHitTest = ImplHitTest( rMousePos, mnMouseOff, nPos );
 706     if ( nHitTest )
 707     {
 708         mbDrag = FALSE;
 709         ImplHeadItem* pItem = mpItemList->GetObject( nPos );
 710         if ( nHitTest & HEAD_HITTEST_DIVIDER )
 711             mbDrag = TRUE;
 712         else
 713         {
 714             if ( ((pItem->mnBits & HIB_CLICKABLE) && !(pItem->mnBits & HIB_FLAT)) ||
 715                  (mbDragable && !(pItem->mnBits & HIB_FIXEDPOS)) )
 716             {
 717                 mbItemMode = TRUE;
 718                 mbDrag = TRUE;
 719                 if ( bCommand )
 720                 {
 721                     if ( mbDragable )
 722                         mbItemDrag = TRUE;
 723                     else
 724                     {
 725                         mbItemMode = FALSE;
 726                         mbDrag = FALSE;
 727                     }
 728                 }
 729             }
 730             else
 731             {
 732                 if ( !bCommand )
 733                 {
 734                     mnCurItemId = pItem->mnId;
 735                     Select();
 736                     mnCurItemId = 0;
 737                 }
 738             }
 739         }
 740
 741         if ( mbDrag )
 742         {
 743             mbOutDrag = FALSE;
 744             mnCurItemId = pItem->mnId;
 745             mnItemDragPos = nPos;
 746             StartTracking();
 747             mnStartPos = rMousePos.X()-mnMouseOff;
 748             mnDragPos = mnStartPos;
 749             StartDrag();
 750             if ( mbItemMode )
 751                 ImplDrawItem( nPos, TRUE, mbItemDrag );
 752             else
 753             {
 754                 Rectangle aSizeRect( mnDragPos, 0, mnDragPos, mnDragSize+mnDY );
 755                 ShowTracking( aSizeRect, SHOWTRACK_SPLIT );
 756             }
 757         }
 758         else
 759             mnMouseOff = 0;
 760     }
 761 }
 762
 763 // -----------------------------------------------------------------------
 764
 765 void HeaderBar::ImplDrag( const Point& rMousePos )
 766 {
 767     BOOL        bNewOutDrag;
 768     USHORT      nPos = GetItemPos( mnCurItemId );
 769
 770     mnDragPos = rMousePos.X()-mnMouseOff;
 771     if ( mbItemMode )
 772     {
 773         Rectangle aItemRect = ImplGetItemRect( nPos );
 774         if ( aItemRect.IsInside( rMousePos ) )
 775             bNewOutDrag = FALSE;
 776         else
 777             bNewOutDrag = TRUE;
 778
 779         // Evt. ItemDrag anschalten
 780         if ( bNewOutDrag && mbDragable && !mbItemDrag &&
 781              !(mpItemList->GetObject(nPos)->mnBits & HIB_FIXEDPOS) )
 782         {
 783             if ( (rMousePos.Y() >= aItemRect.Top()) && (rMousePos.Y() <= aItemRect.Bottom()) )
 784             {
 785                 mbItemDrag = TRUE;
 786                 ImplDrawItem( nPos, TRUE, mbItemDrag );
 787             }
 788         }
 789
 790         USHORT nOldItemDragPos = mnItemDragPos;
 791         if ( mbItemDrag )
 792         {
 793             if ( (rMousePos.Y() < -HEADERBAR_DRAGOUTOFF) || (rMousePos.Y() > mnDY+HEADERBAR_DRAGOUTOFF) )
 794                 bNewOutDrag = TRUE;
 795             else
 796                 bNewOutDrag = FALSE;
 797
 798             if ( bNewOutDrag )
 799                 mnItemDragPos = HEADERBAR_ITEM_NOTFOUND;
 800             else
 801             {
 802                 USHORT nTempId = GetItemId( Point( rMousePos.X(), 2 ) );
 803                 if ( nTempId )
 804                     mnItemDragPos = GetItemPos( nTempId );
 805                 else
 806                 {
 807                     if ( rMousePos.X() <= 0 )
 808                         mnItemDragPos = 0;
 809                     else
 810                         mnItemDragPos = GetItemCount()-1;
 811                 }
 812
 813                 // Nicht verschiebbare Items aussparen
 814                 if ( mnItemDragPos < nPos )
 815                 {
 816                     while ( (mpItemList->GetObject(mnItemDragPos)->mnBits & HIB_FIXEDPOS) &&
 817                             (mnItemDragPos < nPos) )
 818                         mnItemDragPos++;
 819                 }
 820                 else if ( mnItemDragPos > nPos )
 821                 {
 822                     while ( (mpItemList->GetObject(mnItemDragPos)->mnBits & HIB_FIXEDPOS) &&
 823                             (mnItemDragPos > nPos) )
 824                         mnItemDragPos--;
 825                 }
 826             }
 827
 828             if ( (mnItemDragPos != nOldItemDragPos) &&
 829                  (nOldItemDragPos != nPos) &&
 830                  (nOldItemDragPos != HEADERBAR_ITEM_NOTFOUND) )
 831             {
 832                 ImplInvertDrag( nPos, nOldItemDragPos );
 833                 ImplDrawItem( nOldItemDragPos );
 834             }
 835         }
 836
 837         if ( bNewOutDrag != mbOutDrag )
 838             ImplDrawItem( nPos, !bNewOutDrag, mbItemDrag );
 839
 840         if ( mbItemDrag  )
 841         {
 842             if ( (mnItemDragPos != nOldItemDragPos) &&
 843                  (mnItemDragPos != nPos) &&
 844                  (mnItemDragPos != HEADERBAR_ITEM_NOTFOUND) )
 845             {
 846                 ImplDrawItem( mnItemDragPos, FALSE, TRUE );
 847                 ImplInvertDrag( nPos, mnItemDragPos );
 848             }
 849         }
 850
 851         mbOutDrag = bNewOutDrag;
 852     }
 853     else
 854     {
 855         Rectangle aItemRect = ImplGetItemRect( nPos );
 856         if ( mnDragPos < aItemRect.Left() )
 857             mnDragPos = aItemRect.Left();
 858         if ( (mnDragPos < 0) || (mnDragPos > mnDX-1) )
 859             HideTracking();
 860         else
 861         {
 862             Rectangle aSizeRect( mnDragPos, 0, mnDragPos, mnDragSize+mnDY );
 863             ShowTracking( aSizeRect, SHOWTRACK_SPLIT );
 864         }
 865     }
 866
 867     Drag();
 868 }
 869
 870 // -----------------------------------------------------------------------
 871
 872 void HeaderBar::ImplEndDrag( BOOL bCancel )
 873 {
 874     HideTracking();
 875
 876     if ( bCancel || mbOutDrag )
 877     {
 878         if ( mbItemMode && (!mbOutDrag || mbItemDrag) )
 879         {
 880             USHORT nPos = GetItemPos( mnCurItemId );
 881             ImplDrawItem( nPos );
 882         }
 883
 884         mnCurItemId = 0;
 885     }
 886     else
 887     {
 888         USHORT nPos = GetItemPos( mnCurItemId );
 889         if ( mbItemMode )
 890         {
 891             if ( mbItemDrag )
 892             {
 893                 Pointer aPointer( POINTER_ARROW );
 894                 SetPointer( aPointer );
 895                 if ( (mnItemDragPos != nPos) &&
 896                      (mnItemDragPos != HEADERBAR_ITEM_NOTFOUND) )
 897                 {
 898                     ImplInvertDrag( nPos, mnItemDragPos );
 899                     MoveItem( mnCurItemId, mnItemDragPos );
 900                 }
 901                 else
 902                     ImplDrawItem( nPos );
 903             }
 904             else
 905             {
 906                 Select();
 907                 ImplUpdate( nPos );
 908             }
 909         }
 910         else
 911         {
 912             long nDelta = mnDragPos - mnStartPos;
 913             if ( nDelta )
 914             {
 915                 ImplHeadItem* pItem = mpItemList->GetObject( nPos );
 916                 pItem->mnSize += nDelta;
 917                 ImplUpdate( nPos, TRUE );
 918             }
 919         }
 920     }
 921
 922     mbDrag                      = FALSE;
 923     EndDrag();
 924     mnCurItemId         = 0;
 925     mnItemDragPos       = HEADERBAR_ITEM_NOTFOUND;
 926     mbOutDrag           = FALSE;
 927     mbItemMode          = FALSE;
 928     mbItemDrag          = FALSE;
 929 }
 930
 931 // -----------------------------------------------------------------------
 932
 933 void HeaderBar::MouseButtonDown( const MouseEvent& rMEvt )
 934 {
 935     if ( rMEvt.IsLeft() )
 936     {
 937         if ( rMEvt.GetClicks() == 2 )
 938         {
 939             long        nTemp;
 940             USHORT      nPos;
 941             USHORT      nHitTest = ImplHitTest( rMEvt.GetPosPixel(), nTemp, nPos );
 942             if ( nHitTest )
 943             {
 944                 ImplHeadItem* pItem = mpItemList->GetObject( nPos );
 945                 if ( nHitTest & HEAD_HITTEST_DIVIDER )
 946                     mbItemMode = FALSE;
 947                 else
 948                     mbItemMode = TRUE;
 949                 mnCurItemId = pItem->mnId;
 950                 DoubleClick();
 951                 mbItemMode = FALSE;
 952                 mnCurItemId = 0;
 953             }
 954         }
 955         else
 956             ImplStartDrag( rMEvt.GetPosPixel(), FALSE );
 957     }
 958 }
 959
 960 // -----------------------------------------------------------------------
 961
 962 void HeaderBar::MouseMove( const MouseEvent& rMEvt )
 963 {
 964     long                        nTemp1;
 965     USHORT                      nTemp2;
 966     PointerStyle        eStyle = POINTER_ARROW;
 967     USHORT                      nHitTest = ImplHitTest( rMEvt.GetPosPixel(), nTemp1, nTemp2 );
 968
 969     if ( nHitTest & HEAD_HITTEST_DIVIDER )
 970         eStyle = POINTER_HSIZEBAR;
 971     Pointer aPtr( eStyle );
 972     SetPointer( aPtr );
 973 }
 974
 975 // -----------------------------------------------------------------------
 976
 977 void HeaderBar::Tracking( const TrackingEvent& rTEvt )
 978 {
 979     Point aMousePos = rTEvt.GetMouseEvent().GetPosPixel();
 980
 981     if ( rTEvt.IsTrackingEnded() )
 982         ImplEndDrag( rTEvt.IsTrackingCanceled() );
 983     else
 984         ImplDrag( aMousePos );
 985 }
 986
 987 // -----------------------------------------------------------------------
 988
 989 void HeaderBar::Paint( const Rectangle& rRect )
 990 {
 991     if ( mnBorderOff1 || mnBorderOff2 )
 992     {
 993         SetLineColor( GetSettings().GetStyleSettings().GetDarkShadowColor() );
 994         if ( mnBorderOff1 )
 995             DrawLine( Point( 0, 0 ), Point( mnDX-1, 0 ) );
 996         if ( mnBorderOff2 )
 997             DrawLine( Point( 0, mnDY-1 ), Point( mnDX-1, mnDY-1 ) );
 998         // #i40393# draw left and right border, if WB_BORDER was set in ImplInit()
 999         if ( mnBorderOff1 && mnBorderOff2 )
1000         {
1001             DrawLine( Point( 0, 0 ), Point( 0, mnDY-1 ) );
1002             DrawLine( Point( mnDX-1, 0 ), Point( mnDX-1, mnDY-1 ) );
1003         }
1004     }
1005
1006     USHORT nCurItemPos;
1007     if ( mbDrag )
1008         nCurItemPos = GetItemPos( mnCurItemId );
1009     else
1010         nCurItemPos = HEADERBAR_ITEM_NOTFOUND;
1011     USHORT nItemCount = (USHORT)mpItemList->Count();
1012     for ( USHORT i = 0; i < nItemCount; i++ )
1013         ImplDrawItem( i, (i == nCurItemPos) ? TRUE : FALSE, FALSE, &rRect );
1014 }
1015
1016 // -----------------------------------------------------------------------
1017
1018 void HeaderBar::Draw( OutputDevice* pDev, const Point& rPos, const Size& rSize,
1019                       ULONG nFlags )
1020 {
1021     Point               aPos  = pDev->LogicToPixel( rPos );
1022     Size                aSize = pDev->LogicToPixel( rSize );
1023     Rectangle   aRect( aPos, aSize );
1024     Font                aFont = GetDrawPixelFont( pDev );
1025
1026     pDev->Push();
1027     pDev->SetMapMode();
1028     pDev->SetFont( aFont );
1029     if ( nFlags & WINDOW_DRAW_MONO )
1030         pDev->SetTextColor( Color( COL_BLACK ) );
1031     else
1032         pDev->SetTextColor( GetTextColor() );
1033     pDev->SetTextFillColor();
1034
1035     if ( !(nFlags & WINDOW_DRAW_NOBACKGROUND) )
1036     {
1037         pDev->DrawWallpaper( aRect, GetBackground() );
1038         if ( mnBorderOff1 || mnBorderOff2 )
1039         {
1040             pDev->SetLineColor( GetSettings().GetStyleSettings().GetDarkShadowColor() );
1041             if ( mnBorderOff1 )
1042                 pDev->DrawLine( aRect.TopLeft(), Point( aRect.Right(), aRect.Top() ) );
1043             if ( mnBorderOff2 )
1044                 pDev->DrawLine( Point( aRect.Left(), aRect.Bottom() ), Point( aRect.Right(), aRect.Bottom() ) );
1045             // #i40393# draw left and right border, if WB_BORDER was set in ImplInit()
1046             if ( mnBorderOff1 && mnBorderOff2 )
1047             {
1048                 pDev->DrawLine( aRect.TopLeft(), Point( aRect.Left(), aRect.Bottom() ) );
1049                 pDev->DrawLine( Point( aRect.Right(), aRect.Top() ), Point( aRect.Right(), aRect.Bottom() ) );
1050             }
1051         }
1052     }
1053
1054     Rectangle aItemRect( aRect );
1055 //        aItemRect.Bottom()--;
1056     USHORT nItemCount = (USHORT)mpItemList->Count();
1057     for ( USHORT i = 0; i < nItemCount; i++ )
1058     {
1059         aItemRect.Left() = aRect.Left()+ImplGetItemPos( i );
1060         aItemRect.Right() = aItemRect.Left() + mpItemList->GetObject( i )->mnSize - 1;
1061         // Gegen Ueberlauf auf einigen Systemen testen
1062         if ( aItemRect.Right() > 16000 )
1063             aItemRect.Right() = 16000;
1064         Region aRegion( aRect );
1065         pDev->SetClipRegion( aRegion );
1066         ImplDrawItem( pDev, i, FALSE, FALSE, aItemRect, &aRect, nFlags );
1067         pDev->SetClipRegion();
1068     }
1069
1070     pDev->Pop();
1071 }
1072
1073 // -----------------------------------------------------------------------
1074
1075 void HeaderBar::Resize()
1076 {
1077     Size aSize = GetOutputSizePixel();
1078     if ( IsVisible() && (mnDY != aSize.Height()) )
1079         Invalidate();
1080     mnDX = aSize.Width();
1081     mnDY = aSize.Height();
1082 }
1083
1084 // -----------------------------------------------------------------------
1085
1086 void HeaderBar::Command( const CommandEvent& rCEvt )
1087 {
1088     if ( rCEvt.IsMouseEvent() && (rCEvt.GetCommand() == COMMAND_STARTDRAG) && !mbDrag )
1089     {
1090         ImplStartDrag( rCEvt.GetMousePosPixel(), TRUE );
1091         return;
1092     }
1093
1094     Window::Command( rCEvt );
1095 }
1096
1097 // -----------------------------------------------------------------------
1098
1099 void HeaderBar::RequestHelp( const HelpEvent& rHEvt )
1100 {
1101     USHORT nItemId = GetItemId( ScreenToOutputPixel( rHEvt.GetMousePosPixel() ) );
1102     if ( nItemId )
1103     {
1104         if ( rHEvt.GetMode() & (HELPMODE_QUICK | HELPMODE_BALLOON) )
1105         {
1106             Rectangle aItemRect = GetItemRect( nItemId );
1107             Point aPt = OutputToScreenPixel( aItemRect.TopLeft() );
1108             aItemRect.Left()   = aPt.X();
1109             aItemRect.Top()    = aPt.Y();
1110             aPt = OutputToScreenPixel( aItemRect.BottomRight() );
1111             aItemRect.Right()  = aPt.X();
1112             aItemRect.Bottom() = aPt.Y();
1113
1114             XubString aStr = GetHelpText( nItemId );
1115             if ( !aStr.Len() || !(rHEvt.GetMode() & HELPMODE_BALLOON) )
1116             {
1117                 ImplHeadItem* pItem = mpItemList->GetObject( GetItemPos( nItemId ) );
1118                 // Wir zeigen die Quick-Hilfe nur an, wenn Text nicht
1119                 // vollstaendig sichtbar, ansonsten zeigen wir den Hilfetext
1120                 // an, wenn das Item keinen Text besitzt
1121                 if ( pItem->maOutText != pItem->maText )
1122                     aStr = pItem->maText;
1123                 else if ( pItem->maText.Len() )
1124                     aStr.Erase();
1125             }
1126
1127             if ( aStr.Len() )
1128             {
1129                 if ( rHEvt.GetMode() & HELPMODE_BALLOON )
1130                     Help::ShowBalloon( this, aItemRect.Center(), aItemRect, aStr );
1131                 else
1132                     Help::ShowQuickHelp( this, aItemRect, aStr );
1133                 return;
1134             }
1135         }
1136         else if ( rHEvt.GetMode() & HELPMODE_EXTENDED )
1137         {
1138             ULONG nHelpId = GetHelpId( nItemId );
1139             if ( nHelpId )
1140             {
1141                 // Wenn eine Hilfe existiert, dann ausloesen
1142                 Help* pHelp = Application::GetHelp();
1143                 if ( pHelp )
1144                     pHelp->Start( nHelpId, this );
1145                 return;
1146             }
1147         }
1148     }
1149
1150     Window::RequestHelp( rHEvt );
1151 }
1152
1153 // -----------------------------------------------------------------------
1154
1155 void HeaderBar::StateChanged( StateChangedType nType )
1156 {
1157     Window::StateChanged( nType );
1158
1159     if ( nType == STATE_CHANGE_ENABLE )
1160         Invalidate();
1161     else if ( (nType == STATE_CHANGE_ZOOM) ||
1162               (nType == STATE_CHANGE_CONTROLFONT) )
1163     {
1164         ImplInitSettings( TRUE, FALSE, FALSE );
1165         Invalidate();
1166     }
1167     else if ( nType == STATE_CHANGE_CONTROLFOREGROUND )
1168     {
1169         ImplInitSettings( FALSE, TRUE, FALSE );
1170         Invalidate();
1171     }
1172     else if ( nType == STATE_CHANGE_CONTROLBACKGROUND )
1173     {
1174         ImplInitSettings( FALSE, FALSE, TRUE );
1175         Invalidate();
1176     }
1177 }
1178
1179 // -----------------------------------------------------------------------
1180
1181 void HeaderBar::DataChanged( const DataChangedEvent& rDCEvt )
1182 {
1183     Window::DataChanged( rDCEvt );
1184
1185     if ( (rDCEvt.GetType() == DATACHANGED_FONTS) ||
1186          (rDCEvt.GetType() == DATACHANGED_FONTSUBSTITUTION) ||
1187          ((rDCEvt.GetType() == DATACHANGED_SETTINGS) &&
1188           (rDCEvt.GetFlags() & SETTINGS_STYLE)) )
1189     {
1190         ImplInitSettings( TRUE, TRUE, TRUE );
1191         Invalidate();
1192     }
1193 }
1194
1195 // -----------------------------------------------------------------------
1196
1197 void HeaderBar::UserDraw( const UserDrawEvent& )
1198 {
1199 }
1200
1201 // -----------------------------------------------------------------------
1202
1203 void HeaderBar::StartDrag()
1204 {
1205     maStartDragHdl.Call( this );
1206 }
1207
1208 // -----------------------------------------------------------------------
1209
1210 void HeaderBar::Drag()
1211 {
1212     maDragHdl.Call( this );
1213 }
1214
1215 // -----------------------------------------------------------------------
1216
1217 void HeaderBar::EndDrag()
1218 {
1219     maEndDragHdl.Call( this );
1220 }
1221
1222 // -----------------------------------------------------------------------
1223
1224 void HeaderBar::Select()
1225 {
1226     maSelectHdl.Call( this );
1227 }
1228
1229 // -----------------------------------------------------------------------
1230
1231 void HeaderBar::DoubleClick()
1232 {
1233     maDoubleClickHdl.Call( this );
1234 }
1235
1236 // -----------------------------------------------------------------------
1237
1238 void HeaderBar::InsertItem( USHORT nItemId, const Image& rImage,
1239                             long nSize, HeaderBarItemBits nBits, USHORT nPos )
1240 {
1241     DBG_ASSERT( nItemId, "HeaderBar::InsertItem(): ItemId == 0" );
1242     DBG_ASSERT( GetItemPos( nItemId ) == HEADERBAR_ITEM_NOTFOUND,
1243                 "HeaderBar::InsertItem(): ItemId already exists" );
1244
1245     // Item anlegen und in die Liste einfuegen
1246     ImplHeadItem* pItem = new ImplHeadItem;
1247     pItem->mnId                 = nItemId;
1248     pItem->mnBits               = nBits;
1249     pItem->mnSize               = nSize;
1250     pItem->maImage              = rImage;
1251     pItem->mpUserData   = 0;
1252     mpItemList->Insert( pItem, nPos );
1253
1254     // Ausgabe updaten
1255     ImplUpdate( nPos, TRUE );
1256 }
1257
1258 // -----------------------------------------------------------------------
1259
1260 void HeaderBar::InsertItem( USHORT nItemId, const XubString& rText,
1261                             long nSize, HeaderBarItemBits nBits, USHORT nPos )
1262 {
1263     DBG_ASSERT( nItemId, "HeaderBar::InsertItem(): ItemId == 0" );
1264     DBG_ASSERT( GetItemPos( nItemId ) == HEADERBAR_ITEM_NOTFOUND,
1265                 "HeaderBar::InsertItem(): ItemId already exists" );
1266
1267     // Item anlegen und in die Liste einfuegen
1268     ImplHeadItem* pItem = new ImplHeadItem;
1269     pItem->mnId                 = nItemId;
1270     pItem->mnBits               = nBits;
1271     pItem->mnSize               = nSize;
1272     pItem->mnHelpId     = 0;
1273     pItem->maText               = rText;
1274     pItem->mpUserData   = 0;
1275     mpItemList->Insert( pItem, nPos );
1276
1277     // Ausgabe updaten
1278     ImplUpdate( nPos, TRUE );
1279 }
1280
1281 // -----------------------------------------------------------------------
1282
1283 void HeaderBar::InsertItem( USHORT nItemId,
1284                             const Image& rImage, const XubString& rText,
1285                             long nSize, HeaderBarItemBits nBits,
1286                             USHORT nPos )
1287 {
1288     DBG_ASSERT( nItemId, "HeaderBar::InsertItem(): ItemId == 0" );
1289     DBG_ASSERT( GetItemPos( nItemId ) == HEADERBAR_ITEM_NOTFOUND,
1290                 "HeaderBar::InsertItem(): ItemId already exists" );
1291
1292     // Item anlegen und in die Liste einfuegen
1293     ImplHeadItem* pItem = new ImplHeadItem;
1294     pItem->mnId                 = nItemId;
1295     pItem->mnBits               = nBits;
1296     pItem->mnSize               = nSize;
1297     pItem->mnHelpId     = 0;
1298     pItem->maImage              = rImage;
1299     pItem->maText               = rText;
1300     pItem->mpUserData   = 0;
1301     mpItemList->Insert( pItem, nPos );
1302
1303     // Ausgabe updaten
1304     ImplUpdate( nPos, TRUE );
1305 }
1306
1307 // -----------------------------------------------------------------------
1308
1309 void HeaderBar::RemoveItem( USHORT nItemId )
1310 {
1311     USHORT nPos = GetItemPos( nItemId );
1312     if ( nPos != HEADERBAR_ITEM_NOTFOUND )
1313     {
1314         ImplHeadItem* pItem = mpItemList->Remove( nPos );
1315         delete pItem;
1316         ImplUpdate( nPos, TRUE );
1317     }
1318 }
1319
1320 // -----------------------------------------------------------------------
1321
1322 void HeaderBar::MoveItem( USHORT nItemId, USHORT nNewPos )
1323 {
1324     USHORT nPos = GetItemPos( nItemId );
1325     if ( nPos != HEADERBAR_ITEM_NOTFOUND )
1326     {
1327         if ( nPos != nNewPos )
1328         {
1329             ImplHeadItem* pItem = mpItemList->Remove( nPos );
1330             if ( nNewPos < nPos )
1331                 nPos = nNewPos;
1332             mpItemList->Insert( pItem, nNewPos );
1333             ImplUpdate( nPos, TRUE );
1334         }
1335     }
1336 }
1337
1338 // -----------------------------------------------------------------------
1339
1340 void HeaderBar::Clear()
1341 {
1342     // Alle Items loeschen
1343     ImplHeadItem* pItem = mpItemList->First();
1344     while ( pItem )
1345     {
1346         delete pItem;
1347         pItem = mpItemList->Next();
1348     }
1349     mpItemList->Clear();
1350
1351     ImplUpdate( 0, TRUE );
1352 }
1353
1354 // -----------------------------------------------------------------------
1355
1356 void HeaderBar::SetOffset( long nNewOffset )
1357 {
1358     // Hier erstmal neu zeichnen, damit mit alten Offset noch das
1359     // richtige gemalt wird
1360     //Update();
1361
1362     // Bereich verschieben
1363     Rectangle aRect( 0, mnBorderOff1, mnDX-1, mnDY-mnBorderOff1-mnBorderOff2-1 );
1364     long nDelta = mnOffset-nNewOffset;
1365     mnOffset = nNewOffset;
1366     Scroll( nDelta, 0, aRect );
1367 }
1368
1369 // -----------------------------------------------------------------------
1370
1371 USHORT HeaderBar::GetItemCount() const
1372 {
1373     return (USHORT)mpItemList->Count();
1374 }
1375
1376 // -----------------------------------------------------------------------
1377
1378 USHORT HeaderBar::GetItemPos( USHORT nItemId ) const
1379 {
1380     ImplHeadItem* pItem = mpItemList->First();
1381     while ( pItem )
1382     {
1383         if ( pItem->mnId == nItemId )
1384             return (USHORT)mpItemList->GetCurPos();
1385         pItem = mpItemList->Next();
1386     }
1387
1388     return HEADERBAR_ITEM_NOTFOUND;
1389 }
1390
1391 // -----------------------------------------------------------------------
1392
1393 USHORT HeaderBar::GetItemId( USHORT nPos ) const
1394 {
1395     ImplHeadItem* pItem = mpItemList->GetObject( nPos );
1396     if ( pItem )
1397         return pItem->mnId;
1398     else
1399         return 0;
1400 }
1401
1402 // -----------------------------------------------------------------------
1403
1404 USHORT HeaderBar::GetItemId( const Point& rPos ) const
1405 {
1406     USHORT nPos = 0;
1407     while ( nPos < mpItemList->Count() )
1408     {
1409         if ( ImplGetItemRect( nPos ).IsInside( rPos ) )
1410             return GetItemId( nPos );
1411
1412         nPos++;
1413     }
1414
1415     return 0;
1416 }
1417
1418 // -----------------------------------------------------------------------
1419
1420 Rectangle HeaderBar::GetItemRect( USHORT nItemId ) const
1421 {
1422     Rectangle aRect;
1423     USHORT nPos = GetItemPos( nItemId );
1424     if ( nPos != HEADERBAR_ITEM_NOTFOUND )
1425         aRect = ImplGetItemRect( nPos );
1426     return aRect;
1427 }
1428
1429 // -----------------------------------------------------------------------
1430
1431 void HeaderBar::SetItemSize( USHORT nItemId, long nNewSize )
1432 {
1433     USHORT nPos = GetItemPos( nItemId );
1434     if ( nPos != HEADERBAR_ITEM_NOTFOUND )
1435     {
1436         ImplHeadItem* pItem = mpItemList->GetObject( nPos );
1437         if ( pItem->mnSize != nNewSize )
1438         {
1439             pItem->mnSize = nNewSize;
1440             ImplUpdate( nPos, TRUE );
1441         }
1442     }
1443 }
1444
1445 // -----------------------------------------------------------------------
1446
1447 long HeaderBar::GetItemSize( USHORT nItemId ) const
1448 {
1449     USHORT nPos = GetItemPos( nItemId );
1450     if ( nPos != HEADERBAR_ITEM_NOTFOUND )
1451         return mpItemList->GetObject( nPos )->mnSize;
1452     else
1453         return 0;
1454 }
1455
1456 // -----------------------------------------------------------------------
1457
1458 void HeaderBar::SetItemBits( USHORT nItemId, HeaderBarItemBits nNewBits )
1459 {
1460     USHORT nPos = GetItemPos( nItemId );
1461     if ( nPos != HEADERBAR_ITEM_NOTFOUND )
1462     {
1463         ImplHeadItem* pItem = mpItemList->GetObject( nPos );
1464         if ( pItem->mnBits != nNewBits )
1465         {
1466             pItem->mnBits = nNewBits;
1467             ImplUpdate( nPos );
1468         }
1469     }
1470 }
1471
1472 // -----------------------------------------------------------------------
1473
1474 HeaderBarItemBits HeaderBar::GetItemBits( USHORT nItemId ) const
1475 {
1476     USHORT nPos = GetItemPos( nItemId );
1477     if ( nPos != HEADERBAR_ITEM_NOTFOUND )
1478         return mpItemList->GetObject( nPos )->mnBits;
1479     else
1480         return 0;
1481 }
1482
1483 // -----------------------------------------------------------------------
1484
1485 void HeaderBar::SetItemData( USHORT nItemId, void* pNewData )
1486 {
1487     USHORT nPos = GetItemPos( nItemId );
1488     if ( nPos != HEADERBAR_ITEM_NOTFOUND )
1489     {
1490         mpItemList->GetObject( nPos )->mpUserData = pNewData;
1491         ImplUpdate( nPos );
1492     }
1493 }
1494
1495 // -----------------------------------------------------------------------
1496
1497 void* HeaderBar::GetItemData( USHORT nItemId ) const
1498 {
1499     USHORT nPos = GetItemPos( nItemId );
1500     if ( nPos != HEADERBAR_ITEM_NOTFOUND )
1501         return mpItemList->GetObject( nPos )->mpUserData;
1502     else
1503         return NULL;
1504 }
1505
1506 // -----------------------------------------------------------------------
1507
1508 void HeaderBar::SetItemImage( USHORT nItemId, const Image& rImage )
1509 {
1510     USHORT nPos = GetItemPos( nItemId );
1511     if ( nPos != HEADERBAR_ITEM_NOTFOUND )
1512     {
1513         mpItemList->GetObject( nPos )->maImage = rImage;
1514         ImplUpdate( nPos );
1515     }
1516 }
1517
1518 // -----------------------------------------------------------------------
1519
1520 Image HeaderBar::GetItemImage( USHORT nItemId ) const
1521 {
1522     USHORT nPos = GetItemPos( nItemId );
1523     if ( nPos != HEADERBAR_ITEM_NOTFOUND )
1524         return mpItemList->GetObject( nPos )->maImage;
1525     else
1526         return Image();
1527 }
1528
1529 // -----------------------------------------------------------------------
1530
1531 void HeaderBar::SetItemText( USHORT nItemId, const XubString& rText )
1532 {
1533     USHORT nPos = GetItemPos( nItemId );
1534     if ( nPos != HEADERBAR_ITEM_NOTFOUND )
1535     {
1536         mpItemList->GetObject( nPos )->maText = rText;
1537         ImplUpdate( nPos );
1538     }
1539 }
1540
1541 // -----------------------------------------------------------------------
1542
1543 XubString HeaderBar::GetItemText( USHORT nItemId ) const
1544 {
1545     USHORT nPos = GetItemPos( nItemId );
1546     if ( nPos != HEADERBAR_ITEM_NOTFOUND )
1547         return mpItemList->GetObject( nPos )->maText;
1548     else
1549         return String();
1550 }
1551
1552 // -----------------------------------------------------------------------
1553
1554 void HeaderBar::SetHelpText( USHORT nItemId, const XubString& rText )
1555 {
1556     USHORT nPos = GetItemPos( nItemId );
1557     if ( nPos != HEADERBAR_ITEM_NOTFOUND )
1558         mpItemList->GetObject( nPos )->maHelpText = rText;
1559 }
1560
1561 // -----------------------------------------------------------------------
1562
1563 XubString HeaderBar::GetHelpText( USHORT nItemId ) const
1564 {
1565     USHORT nPos = GetItemPos( nItemId );
1566     if ( nPos != HEADERBAR_ITEM_NOTFOUND )
1567     {
1568         ImplHeadItem* pItem = mpItemList->GetObject( nPos );
1569         if ( !pItem->maHelpText.Len() && pItem->mnHelpId )
1570         {
1571             Help* pHelp = Application::GetHelp();
1572             if ( pHelp )
1573                 pItem->maHelpText = pHelp->GetHelpText( pItem->mnHelpId, this );
1574         }
1575
1576         return pItem->maHelpText;
1577     }
1578     else
1579         return XubString();
1580 }
1581
1582 // -----------------------------------------------------------------------
1583
1584 void HeaderBar::SetHelpId( USHORT nItemId, ULONG nHelpId )
1585 {
1586     USHORT nPos = GetItemPos( nItemId );
1587     if ( nPos != HEADERBAR_ITEM_NOTFOUND )
1588         mpItemList->GetObject( nPos )->mnHelpId = nHelpId;
1589 }
1590
1591 // -----------------------------------------------------------------------
1592
1593 ULONG HeaderBar::GetHelpId( USHORT nItemId ) const
1594 {
1595     USHORT nPos = GetItemPos( nItemId );
1596     if ( nPos != HEADERBAR_ITEM_NOTFOUND )
1597         return mpItemList->GetObject( nPos )->mnHelpId;
1598     else
1599         return 0;
1600 }
1601
1602 // -----------------------------------------------------------------------
1603
1604 Size HeaderBar::CalcWindowSizePixel() const
1605 {
1606     long nMaxImageSize = 0;
1607     Size aSize( 0, GetTextHeight() );
1608
1609     ImplHeadItem* pItem = mpItemList->First();
1610     while ( pItem )
1611     {
1612         // Image-Groessen beruecksichtigen
1613         long nImageHeight = pItem->maImage.GetSizePixel().Height();
1614         if ( !(pItem->mnBits & (HIB_LEFTIMAGE | HIB_RIGHTIMAGE)) && pItem->maText.Len() )
1615             nImageHeight += aSize.Height();
1616         if ( nImageHeight > nMaxImageSize )
1617             nMaxImageSize = nImageHeight;
1618
1619         // Breite aufaddieren
1620         aSize.Width() += pItem->mnSize;
1621
1622         pItem = mpItemList->Next();
1623     }
1624
1625     if ( nMaxImageSize > aSize.Height() )
1626         aSize.Height() = nMaxImageSize;
1627
1628     // Border aufaddieren
1629     if ( mbButtonStyle )
1630         aSize.Height() += 4;
1631     else
1632         aSize.Height() += 2;
1633     aSize.Height() += mnBorderOff1+mnBorderOff2;
1634
1635     return aSize;
1636 }
1637
1638 ::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessible > HeaderBar::CreateAccessible()
1639 {
1640     if ( !mxAccessible.is() )
1641     {
1642         if ( maCreateAccessibleHdl.IsSet() )
1643             maCreateAccessibleHdl.Call( this );
1644
1645         if ( !mxAccessible.is() )
1646             mxAccessible = Window::CreateAccessible();
1647     }
1648
1649     return mxAccessible;
1650 }
1651
1652 void HeaderBar::SetAccessible( ::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessible > _xAccessible )
1653 {
1654     mxAccessible = _xAccessible;
1655 }
1656