vcl/source/window/status.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20
  21 #include <tools/debug.hxx>
  22 #include <tools/rc.h>
  23
  24 #include <vcl/event.hxx>
  25 #include <vcl/decoview.hxx>
  26 #include <vcl/svapp.hxx>
  27 #include <vcl/help.hxx>
  28 #include <vcl/status.hxx>
  29 #include <vcl/virdev.hxx>
  30
  31 #include <svdata.hxx>
  32 #include <window.h>
  33
  34 // =======================================================================
  35
  36 #define STATUSBAR_OFFSET_X      STATUSBAR_OFFSET
  37 #define STATUSBAR_OFFSET_Y      2
  38 #define STATUSBAR_OFFSET_TEXTY  3
  39
  40 #define STATUSBAR_PRGS_OFFSET   3
  41 #define STATUSBAR_PRGS_COUNT    100
  42 #define STATUSBAR_PRGS_MIN      5
  43
  44 // -----------------------------------------------------------------------
  45
  46 class StatusBar::ImplData
  47 {
  48 public:
  49     ImplData();
  50     ~ImplData();
  51
  52     VirtualDevice*      mpVirDev;
  53     long                mnItemBorderWidth;
  54     bool                mbDrawItemFrames:1;
  55 };
  56
  57 StatusBar::ImplData::ImplData()
  58 {
  59     mpVirDev = NULL;
  60     mbDrawItemFrames = false;
  61     mnItemBorderWidth = 0;
  62 }
  63
  64 StatusBar::ImplData::~ImplData()
  65 {
  66 }
  67
  68 struct ImplStatusItem
  69 {
  70     sal_uInt16              mnId;
  71     StatusBarItemBits   mnBits;
  72     long                mnWidth;
  73     long                mnOffset;
  74     long                mnExtraWidth;
  75     long                mnX;
  76     OUString            maText;
  77     OUString            maHelpText;
  78     OUString            maQuickHelpText;
  79     OString             maHelpId;
  80     void*               mpUserData;
  81     sal_Bool            mbVisible;
  82     OUString            maAccessibleName;
  83     OUString            maCommand;
  84 };
  85
  86 // =======================================================================
  87
  88 inline long ImplCalcProgessWidth( sal_uInt16 nMax, long nSize )
  89 {
  90     return ((nMax*(nSize+(nSize/2)))-(nSize/2)+(STATUSBAR_PRGS_OFFSET*2));
  91 }
  92
  93 // -----------------------------------------------------------------------
  94
  95 static Point ImplGetItemTextPos( const Size& rRectSize, const Size& rTextSize,
  96                                  sal_uInt16 nStyle )
  97 {
  98     long nX;
  99     long nY;
 100     long delta = (rTextSize.Height()/4) + 1;
 101     if( delta + rTextSize.Width() > rRectSize.Width() )
 102         delta = 0;
 103
 104     if ( nStyle & SIB_LEFT )
 105         nX = delta;
 106     else if ( nStyle & SIB_RIGHT )
 107         nX = rRectSize.Width()-rTextSize.Width()-delta;
 108     else // SIB_CENTER
 109         nX = (rRectSize.Width()-rTextSize.Width())/2;
 110     nY = (rRectSize.Height()-rTextSize.Height())/2 + 1;
 111     return Point( nX, nY );
 112 }
 113
 114 // -----------------------------------------------------------------------
 115
 116 sal_Bool StatusBar::ImplIsItemUpdate()
 117 {
 118     if ( !mbProgressMode && mbVisibleItems && IsReallyVisible() && IsUpdateMode() )
 119         return sal_True;
 120     else
 121         return sal_False;
 122 }
 123
 124 // -----------------------------------------------------------------------
 125
 126 void StatusBar::ImplInit( Window* pParent, WinBits nStyle )
 127 {
 128     mpImplData = new ImplData;
 129
 130     // Default ist RightAlign
 131     if ( !(nStyle & (WB_LEFT | WB_RIGHT)) )
 132         nStyle |= WB_RIGHT;
 133
 134     Window::ImplInit( pParent, nStyle & ~WB_BORDER, NULL );
 135
 136     // WinBits merken
 137     mpItemList      = new ImplStatusItemList;
 138     mpImplData->mpVirDev        = new VirtualDevice( *this );
 139     mnCurItemId     = 0;
 140     mbFormat        = sal_True;
 141     mbVisibleItems  = sal_True;
 142     mbProgressMode  = sal_False;
 143     mbInUserDraw    = sal_False;
 144     mnItemsWidth    = STATUSBAR_OFFSET_X;
 145     mnDX            = 0;
 146     mnDY            = 0;
 147     mnCalcHeight    = 0;
 148     mnItemY         = STATUSBAR_OFFSET_Y;
 149     mnTextY         = STATUSBAR_OFFSET_TEXTY;
 150
 151     ImplInitSettings( sal_True, sal_True, sal_True );
 152     SetLineColor();
 153
 154     SetOutputSizePixel( CalcWindowSizePixel() );
 155 }
 156
 157 // -----------------------------------------------------------------------
 158
 159 StatusBar::StatusBar( Window* pParent, WinBits nStyle ) :
 160     Window( WINDOW_STATUSBAR )
 161 {
 162     ImplInit( pParent, nStyle );
 163 }
 164
 165 // -----------------------------------------------------------------------
 166
 167 StatusBar::~StatusBar()
 168 {
 169     // Alle Items loeschen
 170     for ( size_t i = 0, n = mpItemList->size(); i < n; ++i ) {
 171         delete (*mpItemList)[ i ];
 172     }
 173     delete mpItemList;
 174
 175     // VirtualDevice loeschen
 176     delete mpImplData->mpVirDev;
 177     delete mpImplData;
 178 }
 179
 180 // -----------------------------------------------------------------------
 181
 182 void StatusBar::ImplInitSettings( sal_Bool bFont,
 183                                   sal_Bool bForeground, sal_Bool bBackground )
 184 {
 185     const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
 186
 187     if ( bFont )
 188     {
 189         Font aFont = rStyleSettings.GetToolFont();
 190         if ( IsControlFont() )
 191             aFont.Merge( GetControlFont() );
 192         SetZoomedPointFont( aFont );
 193     }
 194
 195     if ( bForeground || bFont )
 196     {
 197         Color aColor;
 198         if ( IsControlForeground() )
 199             aColor = GetControlForeground();
 200         else if ( GetStyle() & WB_3DLOOK )
 201             aColor = rStyleSettings.GetButtonTextColor();
 202         else
 203             aColor = rStyleSettings.GetWindowTextColor();
 204         SetTextColor( aColor );
 205         SetTextFillColor();
 206
 207         mpImplData->mpVirDev->SetFont( GetFont() );
 208         mpImplData->mpVirDev->SetTextColor( GetTextColor() );
 209         mpImplData->mpVirDev->SetTextAlign( GetTextAlign() );
 210         mpImplData->mpVirDev->SetTextFillColor();
 211     }
 212
 213     if ( bBackground )
 214     {
 215         Color aColor;
 216         if ( IsControlBackground() )
 217             aColor = GetControlBackground();
 218         else if ( GetStyle() & WB_3DLOOK )
 219             aColor = rStyleSettings.GetFaceColor();
 220         else
 221             aColor = rStyleSettings.GetWindowColor();
 222         SetBackground( aColor );
 223         mpImplData->mpVirDev->SetBackground( GetBackground() );
 224
 225         // NWF background
 226         if( ! IsControlBackground() &&
 227               IsNativeControlSupported( CTRL_WINDOW_BACKGROUND, PART_BACKGROUND_WINDOW ) )
 228         {
 229             ImplGetWindowImpl()->mnNativeBackground = PART_BACKGROUND_WINDOW;
 230             EnableChildTransparentMode( sal_True );
 231         }
 232     }
 233 }
 234
 235 // -----------------------------------------------------------------------
 236
 237 void StatusBar::ImplFormat()
 238 {
 239     ImplStatusItem* pItem;
 240     long            nExtraWidth;
 241     long            nExtraWidth2;
 242     long            nX;
 243     sal_uInt16          nAutoSizeItems = 0;
 244
 245     // Breiten zusammenrechnen
 246     mnItemsWidth = STATUSBAR_OFFSET_X;
 247     long nOffset = 0;
 248     for ( size_t i = 0, n = mpItemList->size(); i < n; ++i ) {
 249         pItem = (*mpItemList)[ i ];
 250         if ( pItem->mbVisible )
 251         {
 252             if ( pItem->mnBits & SIB_AUTOSIZE ) {
 253                 nAutoSizeItems++;
 254             }
 255
 256             mnItemsWidth += pItem->mnWidth + nOffset;
 257             nOffset = pItem->mnOffset;
 258         }
 259     }
 260
 261     if ( GetStyle() & WB_RIGHT )
 262     {
 263         // Bei rechtsbuendiger Ausrichtung wird kein AutoSize ausgewertet,
 264         // da wir links den Text anzeigen, der mit SetText gesetzt wird
 265         nX              = mnDX - mnItemsWidth;
 266         nExtraWidth     = 0;
 267         nExtraWidth2    = 0;
 268     }
 269     else
 270     {
 271         mnItemsWidth += STATUSBAR_OFFSET_X;
 272
 273         // Bei linksbuendiger Ausrichtung muessen wir gegebenenfalls noch
 274         // AutoSize auswerten
 275         if ( nAutoSizeItems && (mnDX > (mnItemsWidth - STATUSBAR_OFFSET)) )
 276         {
 277             nExtraWidth  = (mnDX - mnItemsWidth - 1) / nAutoSizeItems;
 278             nExtraWidth2 = (mnDX - mnItemsWidth - 1) % nAutoSizeItems;
 279         }
 280         else
 281         {
 282             nExtraWidth  = 0;
 283             nExtraWidth2 = 0;
 284         }
 285         nX = STATUSBAR_OFFSET_X;
 286         if( ImplHasMirroredGraphics() && IsRTLEnabled() )
 287             nX += ImplGetSVData()->maNWFData.mnStatusBarLowerRightOffset;
 288     }
 289
 290     for ( size_t i = 0, n = mpItemList->size(); i < n; ++i ) {
 291         pItem = (*mpItemList)[ i ];
 292         if ( pItem->mbVisible ) {
 293             if ( pItem->mnBits & SIB_AUTOSIZE ) {
 294                 pItem->mnExtraWidth = nExtraWidth;
 295                 if ( nExtraWidth2 ) {
 296                     pItem->mnExtraWidth++;
 297                     nExtraWidth2--;
 298                 }
 299             } else {
 300                 pItem->mnExtraWidth = 0;
 301             }
 302
 303             pItem->mnX = nX;
 304             nX += pItem->mnWidth + pItem->mnExtraWidth + pItem->mnOffset;
 305         }
 306     }
 307
 308     mbFormat = sal_False;
 309 }
 310
 311 // -----------------------------------------------------------------------
 312
 313 Rectangle StatusBar::ImplGetItemRectPos( sal_uInt16 nPos ) const
 314 {
 315     Rectangle       aRect;
 316     ImplStatusItem* pItem;
 317     pItem = ( nPos < mpItemList->size() ) ? (*mpItemList)[ nPos ] : NULL;
 318     if ( pItem )
 319     {
 320         if ( pItem->mbVisible )
 321         {
 322             aRect.Left()   = pItem->mnX;
 323             aRect.Right()  = aRect.Left() + pItem->mnWidth + pItem->mnExtraWidth;
 324             aRect.Top()    = mnItemY;
 325             aRect.Bottom() = mnCalcHeight - STATUSBAR_OFFSET_Y;
 326         }
 327     }
 328
 329     return aRect;
 330 }
 331
 332 // -----------------------------------------------------------------------
 333
 334 sal_uInt16 StatusBar::ImplGetFirstVisiblePos() const
 335 {
 336     ImplStatusItem* pItem;
 337
 338     for( size_t nPos = 0; nPos < mpItemList->size(); nPos++ )
 339     {
 340         pItem = (*mpItemList)[ nPos ];
 341         if ( pItem )
 342         {
 343             if ( pItem->mbVisible )
 344                 return sal_uInt16(nPos);
 345         }
 346     }
 347
 348     return ~0;
 349 }
 350
 351 // -----------------------------------------------------------------------
 352
 353 void StatusBar::ImplDrawText( sal_Bool bOffScreen, long nOldTextWidth )
 354 {
 355     // Das ueberschreiben der Item-Box verhindern
 356     Rectangle aTextRect;
 357     aTextRect.Left() = STATUSBAR_OFFSET_X+1;
 358     aTextRect.Top()  = mnTextY;
 359     if ( mbVisibleItems && (GetStyle() & WB_RIGHT) )
 360         aTextRect.Right() = mnDX - mnItemsWidth - 1;
 361     else
 362         aTextRect.Right() = mnDX - 1;
 363     if ( aTextRect.Right() > aTextRect.Left() )
 364     {
 365         // Position ermitteln
 366         OUString aStr = GetText();
 367         sal_Int32 nPos = aStr.indexOf('\n');
 368         if (nPos != -1)
 369             aStr = aStr.copy(0, nPos);
 370
 371         aTextRect.Bottom() = aTextRect.Top()+GetTextHeight()+1;
 372
 373         if ( bOffScreen )
 374         {
 375             long nMaxWidth = std::max( nOldTextWidth, GetTextWidth( aStr ) );
 376             Size aVirDevSize( nMaxWidth, aTextRect.GetHeight() );
 377             mpImplData->mpVirDev->SetOutputSizePixel( aVirDevSize );
 378             Rectangle aTempRect = aTextRect;
 379             aTempRect.SetPos( Point( 0, 0 ) );
 380             mpImplData->mpVirDev->DrawText( aTempRect, aStr, TEXT_DRAW_LEFT | TEXT_DRAW_TOP | TEXT_DRAW_CLIP | TEXT_DRAW_ENDELLIPSIS );
 381             DrawOutDev( aTextRect.TopLeft(), aVirDevSize, Point(), aVirDevSize, *mpImplData->mpVirDev );
 382         }
 383         else
 384             DrawText( aTextRect, aStr, TEXT_DRAW_LEFT | TEXT_DRAW_TOP | TEXT_DRAW_CLIP | TEXT_DRAW_ENDELLIPSIS );
 385     }
 386 }
 387
 388 // -----------------------------------------------------------------------
 389
 390 void StatusBar::ImplDrawItem( sal_Bool bOffScreen, sal_uInt16 nPos, sal_Bool bDrawText, sal_Bool bDrawFrame )
 391 {
 392     Rectangle aRect = ImplGetItemRectPos( nPos );
 393
 394     if ( aRect.IsEmpty() )
 395         return;
 396
 397     // Ausgabebereich berechnen
 398     ImplStatusItem*     pItem = (*mpItemList)[ nPos ];
 399     long nW = mpImplData->mnItemBorderWidth + 1;
 400     Rectangle           aTextRect( aRect.Left()+nW, aRect.Top()+nW,
 401                                    aRect.Right()-nW, aRect.Bottom()-nW );
 402     Size                aTextRectSize( aTextRect.GetSize() );
 403
 404     if ( bOffScreen )
 405         mpImplData->mpVirDev->SetOutputSizePixel( aTextRectSize );
 406     else
 407     {
 408         Region aRegion( aTextRect );
 409         SetClipRegion( aRegion );
 410     }
 411
 412     // Text ausgeben
 413     if ( bDrawText )
 414     {
 415         Size    aTextSize( GetTextWidth( pItem->maText ), GetTextHeight() );
 416         Point   aTextPos = ImplGetItemTextPos( aTextRectSize, aTextSize, pItem->mnBits );
 417         if ( bOffScreen )
 418             mpImplData->mpVirDev->DrawText( aTextPos, pItem->maText );
 419         else
 420         {
 421             aTextPos.X() += aTextRect.Left();
 422             aTextPos.Y() += aTextRect.Top();
 423             DrawText( aTextPos, pItem->maText );
 424         }
 425     }
 426
 427     // Gegebenenfalls auch DrawItem aufrufen
 428     if ( pItem->mnBits & SIB_USERDRAW )
 429     {
 430         if ( bOffScreen )
 431         {
 432             mbInUserDraw = sal_True;
 433             mpImplData->mpVirDev->EnableRTL( IsRTLEnabled() );
 434             UserDrawEvent aODEvt( mpImplData->mpVirDev, Rectangle( Point(), aTextRectSize ), pItem->mnId );
 435             UserDraw( aODEvt );
 436             mpImplData->mpVirDev->EnableRTL( sal_False );
 437             mbInUserDraw = sal_False;
 438         }
 439         else
 440         {
 441             UserDrawEvent aODEvt( this, aTextRect, pItem->mnId );
 442             UserDraw( aODEvt );
 443         }
 444     }
 445
 446     if ( bOffScreen )
 447         DrawOutDev( aTextRect.TopLeft(), aTextRectSize, Point(), aTextRectSize, *mpImplData->mpVirDev );
 448     else
 449         SetClipRegion();
 450
 451     // Frame ausgeben
 452     if ( bDrawFrame )
 453     {
 454         if( mpImplData->mbDrawItemFrames )
 455         {
 456             if( !(pItem->mnBits & SIB_FLAT) )
 457             {
 458                 sal_uInt16 nStyle;
 459
 460                 if ( pItem->mnBits & SIB_IN )
 461                     nStyle = FRAME_DRAW_IN;
 462                 else
 463                     nStyle = FRAME_DRAW_OUT;
 464
 465                 DecorationView aDecoView( this );
 466                 aDecoView.DrawFrame( aRect, nStyle );
 467             }
 468         }
 469         else if( nPos != ImplGetFirstVisiblePos() )
 470         {
 471             // draw separator
 472             Point aFrom( aRect.TopLeft() );
 473             aFrom.X()-=4;
 474             aFrom.Y()++;
 475             Point aTo( aRect.BottomLeft() );
 476             aTo.X()-=4;
 477             aTo.Y()--;
 478
 479             DecorationView aDecoView( this );
 480             aDecoView.DrawSeparator( aFrom, aTo );
 481         }
 482     }
 483
 484     if ( !ImplIsRecordLayout() )
 485         ImplCallEventListeners( VCLEVENT_STATUSBAR_DRAWITEM, (void*) sal_IntPtr(pItem->mnId) );
 486 }
 487
 488 // -----------------------------------------------------------------------
 489
 490 void DrawProgress( Window* pWindow, const Point& rPos,
 491                    long nOffset, long nPrgsWidth, long nPrgsHeight,
 492                    sal_uInt16 nPercent1, sal_uInt16 nPercent2, sal_uInt16 nPercentCount,
 493                    const Rectangle& rFramePosSize
 494                    )
 495 {
 496     if( pWindow->IsNativeControlSupported( CTRL_PROGRESS, PART_ENTIRE_CONTROL ) )
 497     {
 498         bool bNeedErase = ImplGetSVData()->maNWFData.mbProgressNeedsErase;
 499
 500         long nFullWidth = (nPrgsWidth + nOffset) * (10000 / nPercentCount);
 501         long nPerc = (nPercent2 > 10000) ? 10000 : nPercent2;
 502         ImplControlValue aValue( nFullWidth * (long)nPerc / 10000 );
 503         Rectangle aDrawRect( rPos, Size( nFullWidth, nPrgsHeight ) );
 504         Rectangle aControlRegion( aDrawRect );
 505         if( bNeedErase )
 506         {
 507             Window* pEraseWindow = pWindow;
 508             while( pEraseWindow->IsPaintTransparent()                         &&
 509                    ! pEraseWindow->ImplGetWindowImpl()->mbFrame )
 510             {
 511                 pEraseWindow = pEraseWindow->ImplGetWindowImpl()->mpParent;
 512             }
 513             if( pEraseWindow == pWindow )
 514                 // restore background of pWindow
 515                 pEraseWindow->Erase( rFramePosSize );
 516             else
 517             {
 518                 // restore transparent background
 519                 Point aTL( pWindow->OutputToAbsoluteScreenPixel( rFramePosSize.TopLeft() ) );
 520                 aTL = pEraseWindow->AbsoluteScreenToOutputPixel( aTL );
 521                 Rectangle aRect( aTL, rFramePosSize.GetSize() );
 522                 pEraseWindow->Invalidate( aRect, INVALIDATE_NOCHILDREN     |
 523                                                  INVALIDATE_NOCLIPCHILDREN |
 524                                                  INVALIDATE_TRANSPARENT );
 525                 pEraseWindow->Update();
 526             }
 527             pWindow->Push( PUSH_CLIPREGION );
 528             pWindow->IntersectClipRegion( rFramePosSize );
 529         }
 530         sal_Bool bNativeOK = pWindow->DrawNativeControl( CTRL_PROGRESS, PART_ENTIRE_CONTROL, aControlRegion,
 531                                                      CTRL_STATE_ENABLED, aValue, OUString() );
 532         if( bNeedErase )
 533             pWindow->Pop();
 534         if( bNativeOK )
 535         {
 536             pWindow->Flush();
 537             return;
 538         }
 539     }
 540
 541     // Werte vorberechnen
 542     sal_uInt16 nPerc1 = nPercent1 / nPercentCount;
 543     sal_uInt16 nPerc2 = nPercent2 / nPercentCount;
 544
 545     if ( nPerc1 > nPerc2 )
 546     {
 547         // Support progress that can also decrease
 548
 549         // Rechteck berechnen
 550         long        nDX = nPrgsWidth + nOffset;
 551         long        nLeft = rPos.X()+((nPerc1-1)*nDX);
 552         Rectangle   aRect( nLeft, rPos.Y(), nLeft+nPrgsWidth, rPos.Y()+nPrgsHeight );
 553
 554         do
 555         {
 556             pWindow->Erase( aRect );
 557             aRect.Left()  -= nDX;
 558             aRect.Right() -= nDX;
 559             nPerc1--;
 560         }
 561         while ( nPerc1 > nPerc2 );
 562
 563         pWindow->Flush();
 564     }
 565     else if ( nPerc1 < nPerc2 )
 566     {
 567         // Percent-Rechtecke malen
 568         // Wenn Percent2 ueber 100%, Werte anpassen
 569         if ( nPercent2 > 10000 )
 570         {
 571             nPerc2 = 10000 / nPercentCount;
 572             if ( nPerc1 >= nPerc2 )
 573                 nPerc1 = nPerc2-1;
 574         }
 575
 576         // Rechteck berechnen
 577         long        nDX = nPrgsWidth + nOffset;
 578         long        nLeft = rPos.X()+(nPerc1*nDX);
 579         Rectangle   aRect( nLeft, rPos.Y(), nLeft+nPrgsWidth, rPos.Y()+nPrgsHeight );
 580
 581         do
 582         {
 583             pWindow->DrawRect( aRect );
 584             aRect.Left()  += nDX;
 585             aRect.Right() += nDX;
 586             nPerc1++;
 587         }
 588         while ( nPerc1 < nPerc2 );
 589
 590         // Bei mehr als 100%, lassen wir das Rechteck blinken
 591         if ( nPercent2 > 10000 )
 592         {
 593             // an/aus-Status festlegen
 594             if ( ((nPercent2 / nPercentCount) & 0x01) == (nPercentCount & 0x01) )
 595             {
 596                 aRect.Left()  -= nDX;
 597                 aRect.Right() -= nDX;
 598                 pWindow->Erase( aRect );
 599             }
 600         }
 601
 602         pWindow->Flush();
 603     }
 604 }
 605
 606 // -----------------------------------------------------------------------
 607
 608 void StatusBar::ImplDrawProgress( sal_Bool bPaint,
 609                                   sal_uInt16 nPercent1, sal_uInt16 nPercent2 )
 610 {
 611     bool bNative = IsNativeControlSupported( CTRL_PROGRESS, PART_ENTIRE_CONTROL );
 612     // bPaint: draw text also, else only update progress
 613     if ( bPaint )
 614     {
 615         DrawText( maPrgsTxtPos, maPrgsTxt );
 616         if( ! bNative )
 617         {
 618             DecorationView aDecoView( this );
 619             aDecoView.DrawFrame( maPrgsFrameRect, FRAME_DRAW_IN );
 620         }
 621     }
 622
 623     Point aPos( maPrgsFrameRect.Left()+STATUSBAR_PRGS_OFFSET,
 624                 maPrgsFrameRect.Top()+STATUSBAR_PRGS_OFFSET );
 625     long nPrgsHeight = mnPrgsSize;
 626     if( bNative )
 627     {
 628         aPos = maPrgsFrameRect.TopLeft();
 629         nPrgsHeight = maPrgsFrameRect.GetHeight();
 630     }
 631     DrawProgress( this, aPos, mnPrgsSize/2, mnPrgsSize, nPrgsHeight,
 632                   nPercent1*100, nPercent2*100, mnPercentCount, maPrgsFrameRect );
 633 }
 634
 635 // -----------------------------------------------------------------------
 636
 637 void StatusBar::ImplCalcProgressRect()
 638 {
 639     // calculate text size
 640     Size aPrgsTxtSize( GetTextWidth( maPrgsTxt ), GetTextHeight() );
 641     maPrgsTxtPos.X()    = STATUSBAR_OFFSET_X+1;
 642
 643     // calculate progress frame
 644     maPrgsFrameRect.Left()      = maPrgsTxtPos.X()+aPrgsTxtSize.Width()+STATUSBAR_OFFSET;
 645     maPrgsFrameRect.Top()       = mnItemY;
 646     maPrgsFrameRect.Bottom()    = mnCalcHeight - STATUSBAR_OFFSET_Y;
 647
 648     // calculate size of progress rects
 649     mnPrgsSize = maPrgsFrameRect.Bottom()-maPrgsFrameRect.Top()-(STATUSBAR_PRGS_OFFSET*2);
 650     sal_uInt16 nMaxPercent = STATUSBAR_PRGS_COUNT;
 651
 652     long nMaxWidth = mnDX-STATUSBAR_OFFSET-1;
 653
 654     // make smaller if there are too many rects
 655     while ( maPrgsFrameRect.Left()+ImplCalcProgessWidth( nMaxPercent, mnPrgsSize ) > nMaxWidth )
 656     {
 657         nMaxPercent--;
 658         if ( nMaxPercent <= STATUSBAR_PRGS_MIN )
 659             break;
 660     }
 661     maPrgsFrameRect.Right() = maPrgsFrameRect.Left() + ImplCalcProgessWidth( nMaxPercent, mnPrgsSize );
 662
 663     // save the divisor for later
 664     mnPercentCount = 10000 / nMaxPercent;
 665     sal_Bool bNativeOK = sal_False;
 666     if( IsNativeControlSupported( CTRL_PROGRESS, PART_ENTIRE_CONTROL ) )
 667     {
 668         ImplControlValue aValue;
 669         Rectangle aControlRegion( Rectangle( (const Point&)Point(), maPrgsFrameRect.GetSize() ) );
 670         Rectangle aNativeControlRegion, aNativeContentRegion;
 671         if( (bNativeOK = GetNativeControlRegion( CTRL_PROGRESS, PART_ENTIRE_CONTROL, aControlRegion,
 672                                                  CTRL_STATE_ENABLED, aValue, OUString(),
 673                                                  aNativeControlRegion, aNativeContentRegion ) ) != sal_False )
 674         {
 675             long nProgressHeight = aNativeControlRegion.GetHeight();
 676             if( nProgressHeight > maPrgsFrameRect.GetHeight() )
 677             {
 678                 long nDelta = nProgressHeight - maPrgsFrameRect.GetHeight();
 679                 maPrgsFrameRect.Top() -= (nDelta - nDelta/2);
 680                 maPrgsFrameRect.Bottom() += nDelta/2;
 681             }
 682             maPrgsTxtPos.Y() = maPrgsFrameRect.Top() + (nProgressHeight - GetTextHeight())/2;
 683         }
 684     }
 685     if( ! bNativeOK )
 686         maPrgsTxtPos.Y()    = mnTextY;
 687 }
 688
 689 // -----------------------------------------------------------------------
 690
 691 void StatusBar::MouseButtonDown( const MouseEvent& rMEvt )
 692 {
 693     // Nur bei linker Maustaste ToolBox ausloesen
 694     if ( rMEvt.IsLeft() )
 695     {
 696         if ( mbVisibleItems )
 697         {
 698             Point  aMousePos = rMEvt.GetPosPixel();
 699
 700             // Item suchen, das geklickt wurde
 701             for ( size_t i = 0; i < mpItemList->size(); ++i )
 702             {
 703                 ImplStatusItem* pItem = (*mpItemList)[ i ];
 704                 // Ist es dieses Item
 705                 if ( ImplGetItemRectPos( sal_uInt16(i) ).IsInside( aMousePos ) )
 706                 {
 707                     mnCurItemId = pItem->mnId;
 708                     if ( rMEvt.GetClicks() == 2 )
 709                         DoubleClick();
 710                     else
 711                         Click();
 712                     mnCurItemId = 0;
 713
 714                     // Item wurde gefunden
 715                     return;
 716                 }
 717             }
 718         }
 719
 720         // Kein Item, dann nur Click oder DoubleClick
 721         if ( rMEvt.GetClicks() == 2 )
 722             DoubleClick();
 723         else
 724             Click();
 725     }
 726 }
 727
 728 // -----------------------------------------------------------------------
 729
 730 void StatusBar::Paint( const Rectangle& )
 731 {
 732     if ( mbFormat )
 733         ImplFormat();
 734
 735     sal_uInt16 nItemCount = sal_uInt16( mpItemList->size() );
 736
 737     if ( mbProgressMode )
 738         ImplDrawProgress( sal_True, 0, mnPercent );
 739     else
 740     {
 741         // Text zeichen
 742         if ( !mbVisibleItems || (GetStyle() & WB_RIGHT) )
 743             ImplDrawText( sal_False, 0 );
 744
 745         // Items zeichnen
 746         if ( mbVisibleItems )
 747         {
 748             // Items zeichnen
 749             for ( sal_uInt16 i = 0; i < nItemCount; i++ )
 750                 ImplDrawItem( sal_False, i, sal_True, sal_True );
 751         }
 752     }
 753
 754     // draw line at the top of the status bar (to visually distinguish it from
 755     // shell / docking area)
 756     const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
 757     SetLineColor( rStyleSettings.GetShadowColor() );
 758     DrawLine( Point( 0, 0 ), Point( mnDX-1, 0 ) );
 759 }
 760
 761 // -----------------------------------------------------------------------
 762
 763 void StatusBar::Move()
 764 {
 765     Window::Move();
 766 }
 767
 768 // -----------------------------------------------------------------------
 769
 770 void StatusBar::Resize()
 771 {
 772     // Breite und Hoehe abfragen und merken
 773     Size aSize = GetOutputSizePixel();
 774     mnDX = aSize.Width() - ImplGetSVData()->maNWFData.mnStatusBarLowerRightOffset;
 775     mnDY = aSize.Height();
 776     mnCalcHeight = mnDY;
 777
 778     mnItemY = STATUSBAR_OFFSET_Y;
 779     mnTextY = (mnCalcHeight-GetTextHeight())/2;
 780
 781     // Formatierung neu ausloesen
 782     mbFormat = sal_True;
 783
 784     if ( mbProgressMode )
 785         ImplCalcProgressRect();
 786
 787     Invalidate();
 788 }
 789
 790 // -----------------------------------------------------------------------
 791
 792 void StatusBar::RequestHelp( const HelpEvent& rHEvt )
 793 {
 794     // no keyboard help in status bar
 795     if( rHEvt.KeyboardActivated() )
 796         return;
 797
 798     sal_uInt16 nItemId = GetItemId( ScreenToOutputPixel( rHEvt.GetMousePosPixel() ) );
 799
 800     if ( nItemId )
 801     {
 802         Rectangle aItemRect = GetItemRect( nItemId );
 803         Point aPt = OutputToScreenPixel( aItemRect.TopLeft() );
 804         aItemRect.Left()   = aPt.X();
 805         aItemRect.Top()    = aPt.Y();
 806         aPt = OutputToScreenPixel( aItemRect.BottomRight() );
 807         aItemRect.Right()  = aPt.X();
 808         aItemRect.Bottom() = aPt.Y();
 809
 810         if ( rHEvt.GetMode() & HELPMODE_BALLOON )
 811         {
 812             OUString aStr = GetHelpText( nItemId );
 813             Help::ShowBalloon( this, aItemRect.Center(), aItemRect, aStr );
 814             return;
 815         }
 816         else if ( rHEvt.GetMode() & HELPMODE_QUICK )
 817         {
 818             OUString aStr(GetQuickHelpText(nItemId));
 819             // Show quickhelp if available
 820             if (!aStr.isEmpty())
 821             {
 822                 Help::ShowQuickHelp( this, aItemRect, aStr );
 823                 return;
 824             }
 825             aStr = GetItemText( nItemId );
 826             // show a quick help if item text doesn't fit
 827             if ( GetTextWidth( aStr ) > aItemRect.GetWidth() )
 828             {
 829                 Help::ShowQuickHelp( this, aItemRect, aStr );
 830                 return;
 831             }
 832         }
 833         else if ( rHEvt.GetMode() & HELPMODE_EXTENDED )
 834         {
 835             OUString aCommand = GetItemCommand( nItemId );
 836             OString aHelpId( GetHelpId( nItemId ) );
 837
 838             if ( !aCommand.isEmpty() || !aHelpId.isEmpty() )
 839             {
 840                 // Wenn eine Hilfe existiert, dann ausloesen
 841                 Help* pHelp = Application::GetHelp();
 842                 if ( pHelp )
 843                 {
 844                     if ( !aCommand.isEmpty() )
 845                         pHelp->Start( aCommand, this );
 846                     else if ( !aHelpId.isEmpty() )
 847                         pHelp->Start( OStringToOUString( aHelpId, RTL_TEXTENCODING_UTF8 ), this );
 848                 }
 849                 return;
 850             }
 851         }
 852     }
 853
 854     Window::RequestHelp( rHEvt );
 855 }
 856
 857 // -----------------------------------------------------------------------
 858
 859 void StatusBar::StateChanged( StateChangedType nType )
 860 {
 861     Window::StateChanged( nType );
 862
 863     if ( nType == STATE_CHANGE_INITSHOW )
 864         ImplFormat();
 865     else if ( nType == STATE_CHANGE_UPDATEMODE )
 866         Invalidate();
 867     else if ( (nType == STATE_CHANGE_ZOOM) ||
 868               (nType == STATE_CHANGE_CONTROLFONT) )
 869     {
 870         mbFormat = sal_True;
 871         ImplInitSettings( sal_True, sal_False, sal_False );
 872         Invalidate();
 873     }
 874     else if ( nType == STATE_CHANGE_CONTROLFOREGROUND )
 875     {
 876         ImplInitSettings( sal_False, sal_True, sal_False );
 877         Invalidate();
 878     }
 879     else if ( nType == STATE_CHANGE_CONTROLBACKGROUND )
 880     {
 881         ImplInitSettings( sal_False, sal_False, sal_True );
 882         Invalidate();
 883     }
 884 }
 885
 886 // -----------------------------------------------------------------------
 887
 888 void StatusBar::DataChanged( const DataChangedEvent& rDCEvt )
 889 {
 890     Window::DataChanged( rDCEvt );
 891
 892     if (  (rDCEvt.GetType() == DATACHANGED_DISPLAY         )
 893        || (rDCEvt.GetType() == DATACHANGED_FONTS           )
 894        || (rDCEvt.GetType() == DATACHANGED_FONTSUBSTITUTION)
 895        || (  (rDCEvt.GetType() == DATACHANGED_SETTINGS)
 896           && (rDCEvt.GetFlags() & SETTINGS_STYLE )
 897           )
 898        )
 899     {
 900         mbFormat = sal_True;
 901         ImplInitSettings( sal_True, sal_True, sal_True );
 902         long nFudge = GetTextHeight() / 4;
 903         for ( size_t i = 0, n = mpItemList->size(); i < n; ++i )
 904         {
 905             ImplStatusItem* pItem = (*mpItemList)[ i ];
 906             long nWidth = GetTextWidth( pItem->maText ) + nFudge;
 907             if( nWidth > pItem->mnWidth + STATUSBAR_OFFSET )
 908                 pItem->mnWidth = nWidth + STATUSBAR_OFFSET;
 909         }
 910         Size aSize = GetSizePixel();
 911         // do not disturb current width, since
 912         // CalcWindowSizePixel calculates a minimum width
 913         aSize.Height() = CalcWindowSizePixel().Height();
 914         SetSizePixel( aSize );
 915         Invalidate();
 916     }
 917 }
 918
 919 // -----------------------------------------------------------------------
 920
 921 void StatusBar::Click()
 922 {
 923     ImplCallEventListeners( VCLEVENT_STATUSBAR_CLICK );
 924     maClickHdl.Call( this );
 925 }
 926
 927 // -----------------------------------------------------------------------
 928
 929 void StatusBar::DoubleClick()
 930 {
 931     ImplCallEventListeners( VCLEVENT_STATUSBAR_DOUBLECLICK );
 932     maDoubleClickHdl.Call( this );
 933 }
 934
 935 // -----------------------------------------------------------------------
 936
 937 void StatusBar::UserDraw( const UserDrawEvent& )
 938 {
 939 }
 940
 941 // -----------------------------------------------------------------------
 942
 943 void StatusBar::InsertItem( sal_uInt16 nItemId, sal_uLong nWidth,
 944                             StatusBarItemBits nBits,
 945                             long nOffset, sal_uInt16 nPos )
 946 {
 947     DBG_ASSERT( nItemId, "StatusBar::InsertItem(): ItemId == 0" );
 948     DBG_ASSERT( GetItemPos( nItemId ) == STATUSBAR_ITEM_NOTFOUND,
 949                 "StatusBar::InsertItem(): ItemId already exists" );
 950
 951     // IN und CENTER sind Default
 952     if ( !(nBits & (SIB_IN | SIB_OUT | SIB_FLAT)) )
 953         nBits |= SIB_IN;
 954     if ( !(nBits & (SIB_LEFT | SIB_RIGHT | SIB_CENTER)) )
 955         nBits |= SIB_CENTER;
 956
 957     // Item anlegen
 958     long nFudge = GetTextHeight()/4;
 959     ImplStatusItem* pItem   = new ImplStatusItem;
 960     pItem->mnId             = nItemId;
 961     pItem->mnBits           = nBits;
 962     pItem->mnWidth          = (long)nWidth+nFudge+STATUSBAR_OFFSET;
 963     pItem->mnOffset         = nOffset;
 964     pItem->mpUserData       = 0;
 965     pItem->mbVisible        = sal_True;
 966
 967     // Item in die Liste einfuegen
 968     if ( nPos < mpItemList->size() ) {
 969         mpItemList->insert( mpItemList->begin() + nPos, pItem );
 970     } else {
 971         mpItemList->push_back( pItem );
 972     }
 973
 974     mbFormat = sal_True;
 975     if ( ImplIsItemUpdate() )
 976         Invalidate();
 977
 978     ImplCallEventListeners( VCLEVENT_STATUSBAR_ITEMADDED, (void*) sal_IntPtr(nItemId) );
 979 }
 980
 981 // -----------------------------------------------------------------------
 982
 983 void StatusBar::RemoveItem( sal_uInt16 nItemId )
 984 {
 985     sal_uInt16 nPos = GetItemPos( nItemId );
 986     if ( nPos != STATUSBAR_ITEM_NOTFOUND )
 987     {
 988         delete (*mpItemList)[ nPos ];
 989         mpItemList->erase( mpItemList->begin() + nPos );
 990
 991         mbFormat = sal_True;
 992         if ( ImplIsItemUpdate() )
 993             Invalidate();
 994
 995         ImplCallEventListeners( VCLEVENT_STATUSBAR_ITEMREMOVED, (void*) sal_IntPtr(nItemId) );
 996     }
 997 }
 998
 999 // -----------------------------------------------------------------------
1000
1001 void StatusBar::ShowItem( sal_uInt16 nItemId )
1002 {
1003     sal_uInt16 nPos = GetItemPos( nItemId );
1004
1005     if ( nPos != STATUSBAR_ITEM_NOTFOUND )
1006     {
1007         ImplStatusItem* pItem = (*mpItemList)[ nPos ];
1008         if ( !pItem->mbVisible )
1009         {
1010             pItem->mbVisible = sal_True;
1011
1012             mbFormat = sal_True;
1013             if ( ImplIsItemUpdate() )
1014                 Invalidate();
1015
1016             ImplCallEventListeners( VCLEVENT_STATUSBAR_SHOWITEM, (void*) sal_IntPtr(nItemId) );
1017         }
1018     }
1019 }
1020
1021 // -----------------------------------------------------------------------
1022
1023 void StatusBar::HideItem( sal_uInt16 nItemId )
1024 {
1025     sal_uInt16 nPos = GetItemPos( nItemId );
1026
1027     if ( nPos != STATUSBAR_ITEM_NOTFOUND )
1028     {
1029         ImplStatusItem* pItem = (*mpItemList)[ nPos ];
1030         if ( pItem->mbVisible )
1031         {
1032             pItem->mbVisible = sal_False;
1033
1034             mbFormat = sal_True;
1035             if ( ImplIsItemUpdate() )
1036                 Invalidate();
1037
1038             ImplCallEventListeners( VCLEVENT_STATUSBAR_HIDEITEM, (void*) sal_IntPtr(nItemId) );
1039         }
1040     }
1041 }
1042
1043 // -----------------------------------------------------------------------
1044
1045 sal_Bool StatusBar::IsItemVisible( sal_uInt16 nItemId ) const
1046 {
1047     sal_uInt16 nPos = GetItemPos( nItemId );
1048
1049     if ( nPos != STATUSBAR_ITEM_NOTFOUND )
1050         return (*mpItemList)[ nPos ]->mbVisible;
1051     else
1052         return sal_False;
1053 }
1054
1055 void StatusBar::Clear()
1056 {
1057     // Alle Item loeschen
1058     for ( size_t i = 0, n = mpItemList->size(); i < n; ++i ) {
1059         delete (*mpItemList)[ i ];
1060     }
1061     mpItemList->clear();
1062
1063     mbFormat = sal_True;
1064     if ( ImplIsItemUpdate() )
1065         Invalidate();
1066
1067     ImplCallEventListeners( VCLEVENT_STATUSBAR_ALLITEMSREMOVED );
1068 }
1069
1070 // -----------------------------------------------------------------------
1071
1072 sal_uInt16 StatusBar::GetItemCount() const
1073 {
1074     return (sal_uInt16)mpItemList->size();
1075 }
1076
1077 // -----------------------------------------------------------------------
1078
1079 sal_uInt16 StatusBar::GetItemId( sal_uInt16 nPos ) const
1080 {
1081     if ( nPos < mpItemList->size() )
1082         return (*mpItemList)[ nPos ]->mnId;
1083     return 0;
1084 }
1085
1086 // -----------------------------------------------------------------------
1087
1088 sal_uInt16 StatusBar::GetItemPos( sal_uInt16 nItemId ) const
1089 {
1090     for ( size_t i = 0, n = mpItemList->size(); i < n; ++i ) {
1091         if ( (*mpItemList)[ i ]->mnId == nItemId ) {
1092             return sal_uInt16( i );
1093         }
1094     }
1095
1096     return STATUSBAR_ITEM_NOTFOUND;
1097 }
1098
1099 // -----------------------------------------------------------------------
1100
1101 sal_uInt16 StatusBar::GetItemId( const Point& rPos ) const
1102 {
1103     if ( AreItemsVisible() && !mbFormat )
1104     {
1105         sal_uInt16 nItemCount = GetItemCount();
1106         sal_uInt16 nPos;
1107         for ( nPos = 0; nPos < nItemCount; nPos++ )
1108         {
1109             // Rechteck holen
1110             Rectangle aRect = ImplGetItemRectPos( nPos );
1111             if ( aRect.IsInside( rPos ) )
1112                 return (*mpItemList)[ nPos ]->mnId;
1113         }
1114     }
1115
1116     return 0;
1117 }
1118
1119 // -----------------------------------------------------------------------
1120
1121 Rectangle StatusBar::GetItemRect( sal_uInt16 nItemId ) const
1122 {
1123     Rectangle aRect;
1124
1125     if ( AreItemsVisible() && !mbFormat )
1126     {
1127         sal_uInt16 nPos = GetItemPos( nItemId );
1128         if ( nPos != STATUSBAR_ITEM_NOTFOUND )
1129         {
1130             // Rechteck holen und Rahmen abziehen
1131             aRect = ImplGetItemRectPos( nPos );
1132             long nW = mpImplData->mnItemBorderWidth+1;
1133             aRect.Top() += nW-1;
1134             aRect.Bottom() -= nW-1;
1135             aRect.Left() += nW;
1136             aRect.Right() -= nW;
1137             return aRect;
1138         }
1139     }
1140
1141     return aRect;
1142 }
1143
1144 // -----------------------------------------------------------------------
1145
1146 Point StatusBar::GetItemTextPos( sal_uInt16 nItemId ) const
1147 {
1148     if ( !mbFormat )
1149     {
1150         sal_uInt16 nPos = GetItemPos( nItemId );
1151         if ( nPos != STATUSBAR_ITEM_NOTFOUND )
1152         {
1153             // Rechteck holen
1154             ImplStatusItem* pItem = (*mpItemList)[ nPos ];
1155             Rectangle aRect = ImplGetItemRectPos( nPos );
1156             long nW = mpImplData->mnItemBorderWidth + 1;
1157             Rectangle           aTextRect( aRect.Left()+nW, aRect.Top()+nW,
1158                                            aRect.Right()-nW, aRect.Bottom()-nW );
1159             Point aPos = ImplGetItemTextPos( aTextRect.GetSize(),
1160                                              Size( GetTextWidth( pItem->maText ), GetTextHeight() ),
1161                                              pItem->mnBits );
1162             if ( !mbInUserDraw )
1163             {
1164                 aPos.X() += aTextRect.Left();
1165                 aPos.Y() += aTextRect.Top();
1166             }
1167             return aPos;
1168         }
1169     }
1170
1171     return Point();
1172 }
1173
1174 // -----------------------------------------------------------------------
1175
1176 sal_uLong StatusBar::GetItemWidth( sal_uInt16 nItemId ) const
1177 {
1178     sal_uInt16 nPos = GetItemPos( nItemId );
1179
1180     if ( nPos != STATUSBAR_ITEM_NOTFOUND )
1181         return (*mpItemList)[ nPos ]->mnWidth;
1182
1183     return 0;
1184 }
1185
1186 // -----------------------------------------------------------------------
1187
1188 StatusBarItemBits StatusBar::GetItemBits( sal_uInt16 nItemId ) const
1189 {
1190     sal_uInt16 nPos = GetItemPos( nItemId );
1191
1192     if ( nPos != STATUSBAR_ITEM_NOTFOUND )
1193         return (*mpItemList)[ nPos ]->mnBits;
1194
1195     return 0;
1196 }
1197
1198 // -----------------------------------------------------------------------
1199
1200 long StatusBar::GetItemOffset( sal_uInt16 nItemId ) const
1201 {
1202     sal_uInt16 nPos = GetItemPos( nItemId );
1203
1204     if ( nPos != STATUSBAR_ITEM_NOTFOUND )
1205         return (*mpItemList)[ nPos ]->mnOffset;
1206
1207     return 0;
1208 }
1209
1210 // -----------------------------------------------------------------------
1211
1212 void StatusBar::SetItemText( sal_uInt16 nItemId, const OUString& rText )
1213 {
1214     sal_uInt16 nPos = GetItemPos( nItemId );
1215
1216     if ( nPos != STATUSBAR_ITEM_NOTFOUND )
1217     {
1218         ImplStatusItem* pItem = (*mpItemList)[ nPos ];
1219
1220         if ( pItem->maText != rText )
1221         {
1222             pItem->maText = rText;
1223
1224             // adjust item width - see also DataChanged()
1225             long nFudge = GetTextHeight()/4;
1226             long nWidth = GetTextWidth( pItem->maText ) + nFudge;
1227             if( (nWidth > pItem->mnWidth + STATUSBAR_OFFSET) ||
1228                 ((nWidth < pItem->mnWidth) && (mnDX - STATUSBAR_OFFSET) < mnItemsWidth  ))
1229             {
1230                 pItem->mnWidth = nWidth + STATUSBAR_OFFSET;
1231                 ImplFormat();
1232                 Invalidate();
1233             }
1234
1235             // Item neu Zeichen, wenn StatusBar sichtbar und
1236             // UpdateMode gesetzt ist
1237             if ( pItem->mbVisible && !mbFormat && ImplIsItemUpdate() )
1238             {
1239                 Update();
1240                 ImplDrawItem( sal_True, nPos, sal_True, sal_False );
1241                 Flush();
1242             }
1243         }
1244     }
1245 }
1246
1247 // -----------------------------------------------------------------------
1248
1249 const OUString& StatusBar::GetItemText( sal_uInt16 nItemId ) const
1250 {
1251     sal_uInt16 nPos = GetItemPos( nItemId );
1252
1253     assert( nPos != STATUSBAR_ITEM_NOTFOUND );
1254
1255     return (*mpItemList)[ nPos ]->maText;
1256 }
1257
1258 // -----------------------------------------------------------------------
1259
1260 void StatusBar::SetItemCommand( sal_uInt16 nItemId, const OUString& rCommand )
1261 {
1262     sal_uInt16 nPos = GetItemPos( nItemId );
1263
1264     if ( nPos != STATUSBAR_ITEM_NOTFOUND )
1265     {
1266         ImplStatusItem* pItem = (*mpItemList)[ nPos ];
1267
1268         if ( pItem->maCommand != rCommand )
1269             pItem->maCommand = rCommand;
1270     }
1271 }
1272
1273 // -----------------------------------------------------------------------
1274
1275 const OUString StatusBar::GetItemCommand( sal_uInt16 nItemId )
1276 {
1277     sal_uInt16 nPos = GetItemPos( nItemId );
1278
1279     if ( nPos != STATUSBAR_ITEM_NOTFOUND )
1280         return (*mpItemList)[ nPos ]->maCommand;
1281
1282     return OUString();
1283 }
1284
1285 // -----------------------------------------------------------------------
1286
1287 void StatusBar::SetItemData( sal_uInt16 nItemId, void* pNewData )
1288 {
1289     sal_uInt16 nPos = GetItemPos( nItemId );
1290
1291     if ( nPos != STATUSBAR_ITEM_NOTFOUND )
1292     {
1293         ImplStatusItem* pItem = (*mpItemList)[ nPos ];
1294         pItem->mpUserData = pNewData;
1295
1296         // Wenn es ein User-Item ist, DrawItem-Aufrufen
1297         if ( (pItem->mnBits & SIB_USERDRAW) && pItem->mbVisible &&
1298              !mbFormat && ImplIsItemUpdate() )
1299         {
1300             Update();
1301             ImplDrawItem( sal_True, nPos, sal_False, sal_False );
1302             Flush();
1303         }
1304     }
1305 }
1306
1307 void* StatusBar::GetItemData( sal_uInt16 nItemId ) const
1308 {
1309     sal_uInt16 nPos = GetItemPos( nItemId );
1310
1311     if ( nPos != STATUSBAR_ITEM_NOTFOUND )
1312         return (*mpItemList)[ nPos ]->mpUserData;
1313
1314     return NULL;
1315 }
1316
1317 void StatusBar::RedrawItem( sal_uInt16 nItemId )
1318 {
1319     if ( mbFormat )
1320         return;
1321
1322     sal_uInt16 nPos = GetItemPos( nItemId );
1323     if ( nPos == STATUSBAR_ITEM_NOTFOUND )
1324         return;
1325
1326     ImplStatusItem* pItem = (*mpItemList)[ nPos ];
1327     if ( pItem && (pItem->mnBits & SIB_USERDRAW) &&
1328          pItem->mbVisible && ImplIsItemUpdate() )
1329     {
1330         Update();
1331         ImplDrawItem( sal_True, nPos, sal_False, sal_False );
1332         Flush();
1333     }
1334 }
1335
1336 // -----------------------------------------------------------------------
1337
1338 void StatusBar::SetHelpText( sal_uInt16 nItemId, const OUString& rText )
1339 {
1340     sal_uInt16 nPos = GetItemPos( nItemId );
1341
1342     if ( nPos != STATUSBAR_ITEM_NOTFOUND )
1343         (*mpItemList)[ nPos ]->maHelpText = rText;
1344 }
1345
1346 // -----------------------------------------------------------------------
1347
1348 const OUString& StatusBar::GetHelpText( sal_uInt16 nItemId ) const
1349 {
1350     sal_uInt16 nPos = GetItemPos( nItemId );
1351
1352     assert ( nPos != STATUSBAR_ITEM_NOTFOUND );
1353
1354     ImplStatusItem* pItem = (*mpItemList)[ nPos ];
1355     if ( pItem->maHelpText.isEmpty() && ( !pItem->maHelpId.isEmpty() || !pItem->maCommand.isEmpty() ))
1356     {
1357         Help* pHelp = Application::GetHelp();
1358         if ( pHelp )
1359         {
1360             if ( !pItem->maCommand.isEmpty() )
1361                 pItem->maHelpText = pHelp->GetHelpText( pItem->maCommand, this );
1362             if ( pItem->maHelpText.isEmpty() && !pItem->maHelpId.isEmpty() )
1363                 pItem->maHelpText = pHelp->GetHelpText( OStringToOUString( pItem->maHelpId, RTL_TEXTENCODING_UTF8 ), this );
1364         }
1365     }
1366
1367     return pItem->maHelpText;
1368 }
1369
1370 // -----------------------------------------------------------------------
1371
1372 void StatusBar::SetQuickHelpText( sal_uInt16 nItemId, const OUString& rText )
1373 {
1374     sal_uInt16 nPos = GetItemPos( nItemId );
1375
1376     if ( nPos != STATUSBAR_ITEM_NOTFOUND )
1377         (*mpItemList)[ nPos ]->maQuickHelpText = rText;
1378 }
1379
1380 // -----------------------------------------------------------------------
1381
1382 const OUString& StatusBar::GetQuickHelpText( sal_uInt16 nItemId ) const
1383 {
1384     sal_uInt16 nPos = GetItemPos( nItemId );
1385
1386     assert ( nPos != STATUSBAR_ITEM_NOTFOUND );
1387
1388     ImplStatusItem* pItem = (*mpItemList)[ nPos ];
1389     return pItem->maQuickHelpText;
1390 }
1391
1392 // -----------------------------------------------------------------------
1393
1394 void StatusBar::SetHelpId( sal_uInt16 nItemId, const OString& rHelpId )
1395 {
1396     sal_uInt16 nPos = GetItemPos( nItemId );
1397
1398     if ( nPos != STATUSBAR_ITEM_NOTFOUND )
1399         (*mpItemList)[ nPos ]->maHelpId = rHelpId;
1400 }
1401
1402 // -----------------------------------------------------------------------
1403
1404 OString StatusBar::GetHelpId( sal_uInt16 nItemId ) const
1405 {
1406     sal_uInt16 nPos = GetItemPos( nItemId );
1407
1408     OString aRet;
1409     if ( nPos != STATUSBAR_ITEM_NOTFOUND )
1410     {
1411         ImplStatusItem* pItem = (*mpItemList)[ nPos ];
1412         if ( !pItem->maHelpId.isEmpty() )
1413             aRet = pItem->maHelpId;
1414         else
1415             aRet = OUStringToOString( pItem->maCommand, RTL_TEXTENCODING_UTF8 );
1416     }
1417
1418     return aRet;
1419 }
1420
1421 void StatusBar::StartProgressMode( const OUString& rText )
1422 {
1423     DBG_ASSERT( !mbProgressMode, "StatusBar::StartProgressMode(): progress mode is active" );
1424
1425     mbProgressMode  = sal_True;
1426     mnPercent       = 0;
1427     maPrgsTxt       = rText;
1428
1429     // Groessen berechnen
1430     ImplCalcProgressRect();
1431
1432     // Paint ausloesen (dort wird der Text und der Frame gemalt)
1433     const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
1434     Color aPrgsColor = rStyleSettings.GetHighlightColor();
1435     if ( aPrgsColor == rStyleSettings.GetFaceColor() )
1436         aPrgsColor = rStyleSettings.GetDarkShadowColor();
1437     SetLineColor();
1438     SetFillColor( aPrgsColor );
1439     if ( IsReallyVisible() )
1440     {
1441         Invalidate();
1442         Update();
1443         Flush();
1444     }
1445 }
1446
1447 // -----------------------------------------------------------------------
1448
1449 void StatusBar::SetProgressValue( sal_uInt16 nNewPercent )
1450 {
1451     DBG_ASSERT( mbProgressMode, "StatusBar::SetProgressValue(): no progrss mode" );
1452     DBG_ASSERTWARNING( nNewPercent <= 100, "StatusBar::SetProgressValue(): nPercent > 100" );
1453
1454     if ( mbProgressMode
1455     &&   IsReallyVisible()
1456     &&   (!mnPercent || (mnPercent != nNewPercent)) )
1457     {
1458         Update();
1459         SetLineColor();
1460         ImplDrawProgress( sal_False, mnPercent, nNewPercent );
1461         Flush();
1462     }
1463     mnPercent = nNewPercent;
1464 }
1465
1466 // -----------------------------------------------------------------------
1467
1468 void StatusBar::EndProgressMode()
1469 {
1470     DBG_ASSERT( mbProgressMode, "StatusBar::EndProgressMode(): no progress mode" );
1471
1472     mbProgressMode = sal_False;
1473     maPrgsTxt = "";
1474
1475     // Paint neu ausloesen um StatusBar wieder herzustellen
1476     SetFillColor( GetSettings().GetStyleSettings().GetFaceColor() );
1477     if ( IsReallyVisible() )
1478     {
1479         Invalidate();
1480         Update();
1481         Flush();
1482     }
1483 }
1484
1485 // -----------------------------------------------------------------------
1486
1487 void StatusBar::SetText( const OUString& rText )
1488 {
1489     if ( (!mbVisibleItems || (GetStyle() & WB_RIGHT)) && !mbProgressMode &&
1490          IsReallyVisible() && IsUpdateMode() )
1491     {
1492         if ( mbFormat  )
1493         {
1494             Invalidate();
1495             Window::SetText( rText );
1496         }
1497         else
1498         {
1499             Update();
1500             long nOldTextWidth = GetTextWidth( GetText() );
1501             Window::SetText( rText );
1502             ImplDrawText( sal_True, nOldTextWidth );
1503             Flush();
1504         }
1505     }
1506     else if ( mbProgressMode )
1507     {
1508         maPrgsTxt = rText;
1509         if ( IsReallyVisible() )
1510         {
1511             Invalidate();
1512             Update();
1513             Flush();
1514         }
1515     }
1516     else
1517         Window::SetText( rText );
1518 }
1519
1520 // -----------------------------------------------------------------------
1521
1522 Size StatusBar::CalcWindowSizePixel() const
1523 {
1524     size_t  i = 0;
1525     size_t  nCount = mpItemList->size();
1526     long    nOffset = 0;
1527     long    nCalcWidth = (STATUSBAR_OFFSET_X*2);
1528     long    nCalcHeight;
1529
1530     while ( i < nCount )
1531     {
1532         ImplStatusItem* pItem = (*mpItemList)[ i ];
1533         nCalcWidth += pItem->mnWidth + nOffset;
1534         nOffset = pItem->mnOffset;
1535         i++;
1536     }
1537
1538     long nMinHeight = GetTextHeight();
1539     const long nBarTextOffset = STATUSBAR_OFFSET_TEXTY*2;
1540     long nProgressHeight = nMinHeight + nBarTextOffset;
1541
1542     if( IsNativeControlSupported( CTRL_PROGRESS, PART_ENTIRE_CONTROL ) )
1543     {
1544         ImplControlValue aValue;
1545         Rectangle aControlRegion( (const Point&)Point(), Size( nCalcWidth, nMinHeight ) );
1546         Rectangle aNativeControlRegion, aNativeContentRegion;
1547         if( GetNativeControlRegion( CTRL_PROGRESS, PART_ENTIRE_CONTROL,
1548                     aControlRegion, CTRL_STATE_ENABLED, aValue, OUString(),
1549                     aNativeControlRegion, aNativeContentRegion ) )
1550         {
1551             nProgressHeight = aNativeControlRegion.GetHeight();
1552         }
1553     }
1554
1555     if( mpImplData->mbDrawItemFrames &&
1556         IsNativeControlSupported( CTRL_FRAME, PART_BORDER ) )
1557     {
1558         ImplControlValue aControlValue( FRAME_DRAW_NODRAW );
1559         Rectangle aBound, aContent;
1560         Rectangle aNatRgn( Point( 0, 0 ), Size( 150, 50 ) );
1561         if( GetNativeControlRegion(CTRL_FRAME, PART_BORDER,
1562                     aNatRgn, 0, aControlValue, OUString(), aBound, aContent) )
1563         {
1564             mpImplData->mnItemBorderWidth =
1565                 ( aBound.GetHeight() - aContent.GetHeight() ) / 2;
1566         }
1567     }
1568
1569     nCalcHeight = nMinHeight+nBarTextOffset + 2*mpImplData->mnItemBorderWidth;
1570     if( nCalcHeight < nProgressHeight+2 )
1571         nCalcHeight = nProgressHeight+2;
1572
1573     return Size( nCalcWidth, nCalcHeight );
1574 }
1575
1576
1577 // -----------------------------------------------------------------------
1578
1579 void StatusBar::SetAccessibleName( sal_uInt16 nItemId, const OUString& rName )
1580 {
1581     sal_uInt16 nPos = GetItemPos( nItemId );
1582
1583     if ( nPos != STATUSBAR_ITEM_NOTFOUND )
1584     {
1585         ImplStatusItem* pItem = (*mpItemList)[ nPos ];
1586
1587         if ( pItem->maAccessibleName != rName )
1588         {
1589             pItem->maAccessibleName = rName;
1590             ImplCallEventListeners( VCLEVENT_STATUSBAR_NAMECHANGED, (void*) sal_IntPtr(pItem->mnId) );
1591         }
1592     }
1593 }
1594
1595 // -----------------------------------------------------------------------
1596
1597 const OUString& StatusBar::GetAccessibleName( sal_uInt16 nItemId ) const
1598 {
1599     sal_uInt16 nPos = GetItemPos( nItemId );
1600
1601     assert ( nPos != STATUSBAR_ITEM_NOTFOUND );
1602
1603     return (*mpItemList)[ nPos ]->maAccessibleName;
1604 }
1605
1606 // -----------------------------------------------------------------------
1607
1608 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */