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 <sal/log.hxx>
  22 #include <comphelper/string.hxx>
  23 #include <vcl/event.hxx>
  24 #include <vcl/decoview.hxx>
  25 #include <vcl/glyphitemcache.hxx>
  26 #include <vcl/svapp.hxx>
  27 #include <vcl/help.hxx>
  28 #include <vcl/vcllayout.hxx>
  29 #include <vcl/status.hxx>
  30 #include <vcl/virdev.hxx>
  31 #include <vcl/settings.hxx>
  32 #include <config_features.h>
  33 #include <svdata.hxx>
  34 #include <window.h>
  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 #define STATUSBAR_MIN_HEIGHT    16 // icons height, tdf#153344
  45
  46 class StatusBar::ImplData
  47 {
  48 public:
  49     ImplData();
  50
  51     VclPtr<VirtualDevice> mpVirDev;
  52 };
  53
  54 StatusBar::ImplData::ImplData()
  55 {
  56     mpVirDev = nullptr;
  57 }
  58
  59 struct ImplStatusItem
  60 {
  61     sal_uInt16                          mnId;
  62     StatusBarItemBits                   mnBits;
  63     tools::Long                                mnWidth;
  64     tools::Long                                mnOffset;
  65     tools::Long                                mnExtraWidth;
  66     tools::Long                                mnX;
  67     OUString                            maText;
  68     OUString                            maHelpText;
  69     OUString                            maQuickHelpText;
  70     OUString                            maHelpId;
  71     void*                               mpUserData;
  72     bool                                mbVisible;
  73     OUString                            maAccessibleName;
  74     OUString                            maCommand;
  75     std::optional<SalLayoutGlyphs>      mLayoutGlyphsCache;
  76     SalLayoutGlyphs*                    GetTextGlyphs(const OutputDevice* pOutputDevice);
  77 };
  78
  79 SalLayoutGlyphs* ImplStatusItem::GetTextGlyphs(const OutputDevice* outputDevice)
  80 {
  81     if(!mLayoutGlyphsCache.has_value())
  82     {
  83         std::unique_ptr<SalLayout> pSalLayout = outputDevice->ImplLayout(
  84             maText, 0, -1, Point(0, 0), 0, {}, {}, SalLayoutFlags::GlyphItemsOnly);
  85         mLayoutGlyphsCache = pSalLayout ? pSalLayout->GetGlyphs() : SalLayoutGlyphs();
  86     }
  87     return mLayoutGlyphsCache->IsValid() ? &mLayoutGlyphsCache.value() : nullptr;
  88 }
  89
  90 static tools::Long ImplCalcProgressWidth( sal_uInt16 nMax, tools::Long nSize )
  91 {
  92     return ((nMax*(nSize+(nSize/2)))-(nSize/2)+(STATUSBAR_PRGS_OFFSET*2));
  93 }
  94
  95 static Point ImplGetItemTextPos( const Size& rRectSize, const Size& rTextSize,
  96                                  StatusBarItemBits nStyle )
  97 {
  98     tools::Long nX;
  99     tools::Long nY;
 100     tools::Long delta = (rTextSize.Height()/4) + 1;
 101     if( delta + rTextSize.Width() > rRectSize.Width() )
 102         delta = 0;
 103
 104     if ( nStyle & StatusBarItemBits::Left )
 105         nX = delta;
 106     else if ( nStyle & StatusBarItemBits::Right )
 107         nX = rRectSize.Width()-rTextSize.Width()-delta;
 108     else // StatusBarItemBits::Center
 109         nX = (rRectSize.Width()-rTextSize.Width())/2;
 110     nY = (rRectSize.Height()-rTextSize.Height())/2 + 1;
 111     return Point( nX, nY );
 112 }
 113
 114 bool StatusBar::ImplIsItemUpdate() const
 115 {
 116     return !mbProgressMode && IsReallyVisible() && IsUpdateMode();
 117 }
 118
 119 void StatusBar::ImplInit( vcl::Window* pParent, WinBits nStyle )
 120 {
 121     mpImplData.reset(new ImplData);
 122
 123     // default: RightAlign
 124     if ( !(nStyle & (WB_LEFT | WB_RIGHT)) )
 125         nStyle |= WB_RIGHT;
 126
 127     Window::ImplInit( pParent, nStyle & ~WB_BORDER, nullptr );
 128
 129     // remember WinBits
 130     mpImplData->mpVirDev = VclPtr<VirtualDevice>::Create( *GetOutDev() );
 131     mnCurItemId     = 0;
 132     mbFormat        = true;
 133     mbProgressMode  = false;
 134     mbInUserDraw    = false;
 135     mbAdjustHiDPI   = false;
 136     mnItemsWidth    = STATUSBAR_OFFSET_X;
 137     mnDX            = 0;
 138     mnDY            = 0;
 139     mnCalcHeight    = 0;
 140     mnTextY         = STATUSBAR_OFFSET_TEXTY;
 141
 142     ImplInitSettings();
 143
 144     SetOutputSizePixel( CalcWindowSizePixel() );
 145 }
 146
 147 StatusBar::StatusBar( vcl::Window* pParent, WinBits nStyle ) :
 148     Window( WindowType::STATUSBAR ),
 149     mnLastProgressPaint_ms(osl_getGlobalTimer())
 150 {
 151     ImplInit( pParent, nStyle );
 152 }
 153
 154 StatusBar::~StatusBar()
 155 {
 156     disposeOnce();
 157 }
 158
 159 void StatusBar::dispose()
 160 {
 161     // delete all items
 162     mvItemList.clear();
 163
 164     // delete VirtualDevice
 165     mpImplData->mpVirDev.disposeAndClear();
 166     mpImplData.reset();
 167     Window::dispose();
 168 }
 169
 170 void StatusBar::AdjustItemWidthsForHiDPI()
 171 {
 172     mbAdjustHiDPI = true;
 173 }
 174
 175 void StatusBar::ApplySettings(vcl::RenderContext& rRenderContext)
 176 {
 177     rRenderContext.SetLineColor();
 178
 179     const StyleSettings& rStyleSettings = rRenderContext.GetSettings().GetStyleSettings();
 180     ApplyControlFont(rRenderContext, rStyleSettings.GetToolFont());
 181
 182     Color aColor;
 183     if (IsControlForeground())
 184         aColor = GetControlForeground();
 185     else if (GetStyle() & WB_3DLOOK)
 186         aColor = rStyleSettings.GetButtonTextColor();
 187     else
 188         aColor = rStyleSettings.GetWindowTextColor();
 189     rRenderContext.SetTextColor(aColor);
 190
 191     rRenderContext.SetTextFillColor();
 192
 193     if (IsControlBackground())
 194         aColor = GetControlBackground();
 195     else if (GetStyle() & WB_3DLOOK)
 196         aColor = rStyleSettings.GetFaceColor();
 197     else
 198         aColor = rStyleSettings.GetWindowColor();
 199     rRenderContext.SetBackground(aColor);
 200
 201     // NWF background
 202     if (!IsControlBackground() &&
 203           rRenderContext.IsNativeControlSupported(ControlType::WindowBackground, ControlPart::BackgroundWindow))
 204     {
 205         ImplGetWindowImpl()->mnNativeBackground = ControlPart::BackgroundWindow;
 206         EnableChildTransparentMode();
 207     }
 208 }
 209
 210 void StatusBar::ImplInitSettings()
 211 {
 212     ApplySettings(*GetOutDev());
 213
 214     mpImplData->mpVirDev->SetFont(GetFont());
 215     mpImplData->mpVirDev->SetTextColor(GetTextColor());
 216     mpImplData->mpVirDev->SetTextAlign(GetTextAlign());
 217     mpImplData->mpVirDev->SetTextFillColor();
 218     mpImplData->mpVirDev->SetBackground(GetBackground());
 219 }
 220
 221 void StatusBar::ImplFormat()
 222 {
 223     tools::Long            nExtraWidth;
 224     tools::Long            nExtraWidth2;
 225     tools::Long            nX;
 226     sal_uInt16      nAutoSizeItems;
 227     bool            bChanged;
 228
 229     do {
 230         // sum up widths
 231         nAutoSizeItems = 0;
 232         mnItemsWidth = STATUSBAR_OFFSET_X;
 233         bChanged = false;
 234         tools::Long nOffset = 0;
 235         for ( const auto & pItem : mvItemList ) {
 236             if ( pItem->mbVisible )
 237             {
 238                 if ( pItem->mnBits & StatusBarItemBits::AutoSize ) {
 239                     nAutoSizeItems++;
 240                 }
 241
 242                 mnItemsWidth += pItem->mnWidth + nOffset;
 243                 nOffset = pItem->mnOffset;
 244             }
 245         }
 246
 247         if ( mnDX > 0 && mnDX < mnItemsWidth )
 248         {
 249             // Total width of items is more than available width
 250             // Try to hide secondary elements, if any
 251             for ( auto & pItem : mvItemList )
 252             {
 253                 if ( pItem->mbVisible && !(pItem->mnBits & StatusBarItemBits::Mandatory) )
 254                 {
 255                     pItem->mbVisible = false;
 256                     bChanged = true;
 257                     break;
 258                 }
 259             }
 260         }
 261         else if ( mnDX > mnItemsWidth )
 262         {
 263             // Width of statusbar is sufficient.
 264             // Try to restore hidden items, if any
 265             for ( auto & pItem : mvItemList )
 266             {
 267                 if ( !pItem->mbVisible &&
 268                     !(pItem->mnBits & StatusBarItemBits::Mandatory) &&
 269                     pItem->mnWidth + nOffset + mnItemsWidth < mnDX )
 270                 {
 271                     pItem->mbVisible = true;
 272                     bChanged = true;
 273                     break;
 274                 }
 275             }
 276         }
 277     } while ( bChanged );
 278
 279     if ( GetStyle() & WB_RIGHT )
 280     {
 281         // AutoSize isn't computed for right-alignment,
 282         // because we show the text that is declared by SetText on the left side
 283         nX              = mnDX - mnItemsWidth;
 284         nExtraWidth     = 0;
 285         nExtraWidth2    = 0;
 286     }
 287     else
 288     {
 289         mnItemsWidth += STATUSBAR_OFFSET_X;
 290
 291         // calling AutoSize is potentially necessary for left-aligned text,
 292         if ( nAutoSizeItems && (mnDX > (mnItemsWidth - STATUSBAR_OFFSET)) )
 293         {
 294             nExtraWidth  = (mnDX - mnItemsWidth - 1) / nAutoSizeItems;
 295             nExtraWidth2 = (mnDX - mnItemsWidth - 1) % nAutoSizeItems;
 296         }
 297         else
 298         {
 299             nExtraWidth  = 0;
 300             nExtraWidth2 = 0;
 301         }
 302         nX = STATUSBAR_OFFSET_X;
 303
 304         if( GetOutDev()->HasMirroredGraphics() && IsRTLEnabled() )
 305             nX += ImplGetSVData()->maNWFData.mnStatusBarLowerRightOffset;
 306     }
 307
 308     for (auto & pItem : mvItemList) {
 309         if ( pItem->mbVisible ) {
 310             if ( pItem->mnBits & StatusBarItemBits::AutoSize ) {
 311                 pItem->mnExtraWidth = nExtraWidth;
 312                 if ( nExtraWidth2 ) {
 313                     pItem->mnExtraWidth++;
 314                     nExtraWidth2--;
 315                 }
 316             } else {
 317                 pItem->mnExtraWidth = 0;
 318             }
 319
 320             pItem->mnX = nX;
 321             nX += pItem->mnWidth + pItem->mnExtraWidth + pItem->mnOffset;
 322         }
 323     }
 324
 325     mbFormat = false;
 326 }
 327
 328 tools::Rectangle StatusBar::ImplGetItemRectPos( sal_uInt16 nPos ) const
 329 {
 330     tools::Rectangle       aRect;
 331     ImplStatusItem* pItem = ( nPos < mvItemList.size() ) ? mvItemList[ nPos ].get() : nullptr;
 332     if ( pItem && pItem->mbVisible )
 333     {
 334         aRect.SetLeft( pItem->mnX );
 335         aRect.SetRight( aRect.Left() + pItem->mnWidth + pItem->mnExtraWidth );
 336         aRect.SetTop( STATUSBAR_OFFSET_Y );
 337         aRect.SetBottom( mnCalcHeight - STATUSBAR_OFFSET_Y );
 338     }
 339
 340     return aRect;
 341 }
 342
 343 sal_uInt16 StatusBar::ImplGetFirstVisiblePos() const
 344 {
 345     for( size_t nPos = 0; nPos < mvItemList.size(); nPos++ )
 346     {
 347         ImplStatusItem* pItem = mvItemList[ nPos ].get();
 348         if ( pItem->mbVisible )
 349             return sal_uInt16(nPos);
 350     }
 351
 352     return SAL_MAX_UINT16;
 353 }
 354
 355 void StatusBar::ImplDrawText(vcl::RenderContext& rRenderContext)
 356 {
 357     // prevent item box from being overwritten
 358     tools::Rectangle aTextRect;
 359     aTextRect.SetLeft( STATUSBAR_OFFSET_X + 1 );
 360     aTextRect.SetTop( mnTextY );
 361     if (GetStyle() & WB_RIGHT)
 362         aTextRect.SetRight( mnDX - mnItemsWidth - 1 );
 363     else
 364         aTextRect.SetRight( mnDX - 1 );
 365     if (aTextRect.Right() > aTextRect.Left())
 366     {
 367         // compute position
 368         OUString aStr = GetText();
 369         sal_Int32 nPos = aStr.indexOf('\n');
 370         if (nPos != -1)
 371             aStr = aStr.copy(0, nPos);
 372
 373         aTextRect.SetBottom( aTextRect.Top()+GetTextHeight()+1 );
 374
 375         rRenderContext.DrawText(aTextRect, aStr, DrawTextFlags::Left | DrawTextFlags::Top | DrawTextFlags::Clip | DrawTextFlags::EndEllipsis);
 376     }
 377 }
 378
 379 void StatusBar::ImplDrawItem(vcl::RenderContext& rRenderContext, bool bOffScreen, sal_uInt16 nPos)
 380 {
 381     tools::Rectangle aRect = ImplGetItemRectPos(nPos);
 382
 383     if (aRect.IsEmpty())
 384         return;
 385
 386     // compute output region
 387     ImplStatusItem* pItem = mvItemList[nPos].get();
 388     tools::Long nW = 1;
 389     tools::Rectangle aTextRect(aRect.Left() + nW, aRect.Top() + nW,
 390                         aRect.Right() - nW, aRect.Bottom() - nW);
 391
 392     Size aTextRectSize(aTextRect.GetSize());
 393
 394     if (bOffScreen)
 395     {
 396         mpImplData->mpVirDev->SetOutputSizePixel(aTextRectSize);
 397     }
 398     else
 399     {
 400         vcl::Region aRegion(aTextRect);
 401         rRenderContext.SetClipRegion(aRegion);
 402     }
 403
 404     // if the framework code is drawing status, let it do all the work
 405     if (!(pItem->mnBits & StatusBarItemBits::UserDraw))
 406     {
 407         SalLayoutGlyphs* pGlyphs = pItem->GetTextGlyphs(&rRenderContext);
 408         Size aTextSize(rRenderContext.GetTextWidth(pItem->maText,0,-1,nullptr,pGlyphs),
 409                        rRenderContext.GetTextHeight());
 410         Point aTextPos = ImplGetItemTextPos(aTextRectSize, aTextSize, pItem->mnBits);
 411
 412         if (bOffScreen)
 413         {
 414             mpImplData->mpVirDev->DrawText(
 415                         aTextPos,
 416                         pItem->maText,
 417                         0, -1, nullptr, nullptr,
 418                         pGlyphs );
 419         }
 420         else
 421         {
 422             aTextPos.AdjustX(aTextRect.Left() );
 423             aTextPos.AdjustY(aTextRect.Top() );
 424             rRenderContext.DrawText(
 425                         aTextPos,
 426                         pItem->maText,
 427                         0, -1, nullptr, nullptr,
 428                         pGlyphs );
 429         }
 430     }
 431
 432     // call DrawItem if necessary
 433     if (pItem->mnBits & StatusBarItemBits::UserDraw)
 434     {
 435         if (bOffScreen)
 436         {
 437             mbInUserDraw = true;
 438             mpImplData->mpVirDev->EnableRTL( IsRTLEnabled() );
 439             UserDrawEvent aODEvt(mpImplData->mpVirDev, tools::Rectangle(Point(), aTextRectSize), pItem->mnId);
 440             UserDraw(aODEvt);
 441             mpImplData->mpVirDev->EnableRTL(false);
 442             mbInUserDraw = false;
 443         }
 444         else
 445         {
 446             UserDrawEvent aODEvt(&rRenderContext, aTextRect, pItem->mnId);
 447             UserDraw(aODEvt);
 448         }
 449     }
 450
 451     if (bOffScreen)
 452         rRenderContext.DrawOutDev(aTextRect.TopLeft(), aTextRectSize, Point(), aTextRectSize, *mpImplData->mpVirDev);
 453     else
 454         rRenderContext.SetClipRegion();
 455
 456     if (nPos != ImplGetFirstVisiblePos())
 457     {
 458         // draw separator
 459         Point aFrom(aRect.TopLeft());
 460         aFrom.AdjustX( -4 );
 461         aFrom.AdjustY( 1 );
 462         Point aTo(aRect.BottomLeft());
 463         aTo.AdjustX( -4 );
 464         aTo.AdjustY( -1 );
 465
 466         DecorationView aDecoView(&rRenderContext);
 467         aDecoView.DrawSeparator(aFrom, aTo);
 468     }
 469
 470     if (!rRenderContext.ImplIsRecordLayout())
 471         CallEventListeners(VclEventId::StatusbarDrawItem, reinterpret_cast<void*>(pItem->mnId));
 472 }
 473
 474 void DrawProgress(vcl::Window* pWindow, vcl::RenderContext& rRenderContext, const Point& rPos,
 475                   tools::Long nOffset, tools::Long nPrgsWidth, tools::Long nPrgsHeight,
 476                   sal_uInt16 nPercent1, sal_uInt16 nPercent2, sal_uInt16 nPercentCount,
 477                   const tools::Rectangle& rFramePosSize)
 478 {
 479     if (rRenderContext.IsNativeControlSupported(ControlType::Progress, ControlPart::Entire))
 480     {
 481         bool bNeedErase = ImplGetSVData()->maNWFData.mbProgressNeedsErase;
 482
 483         tools::Long nFullWidth = (nPrgsWidth + nOffset) * (10000 / nPercentCount);
 484         tools::Long nPerc = std::min<sal_uInt16>(nPercent2, 10000);
 485         ImplControlValue aValue(nFullWidth * nPerc / 10000);
 486         tools::Rectangle aDrawRect(rPos, Size(nFullWidth, nPrgsHeight));
 487         tools::Rectangle aControlRegion(aDrawRect);
 488
 489         if(bNeedErase)
 490         {
 491             vcl::Window* pEraseWindow = pWindow;
 492             while (pEraseWindow->IsPaintTransparent() && !pEraseWindow->ImplGetWindowImpl()->mbFrame)
 493             {
 494                 pEraseWindow = pEraseWindow->ImplGetWindowImpl()->mpParent;
 495             }
 496
 497             if (pEraseWindow == pWindow)
 498             {
 499                 // restore background of pWindow
 500                 rRenderContext.Erase(rFramePosSize);
 501             }
 502             else
 503             {
 504                 // restore transparent background
 505                 Point aTL(pWindow->OutputToAbsoluteScreenPixel(rFramePosSize.TopLeft()));
 506                 aTL = pEraseWindow->AbsoluteScreenToOutputPixel(aTL);
 507                 tools::Rectangle aRect(aTL, rFramePosSize.GetSize());
 508                 pEraseWindow->Invalidate(aRect, InvalidateFlags::NoChildren     |
 509                                                 InvalidateFlags::NoClipChildren |
 510                                                 InvalidateFlags::Transparent);
 511                 pEraseWindow->PaintImmediately();
 512             }
 513             rRenderContext.Push(vcl::PushFlags::CLIPREGION);
 514             rRenderContext.IntersectClipRegion(rFramePosSize);
 515         }
 516
 517         bool bNativeOK = rRenderContext.DrawNativeControl(ControlType::Progress, ControlPart::Entire, aControlRegion,
 518                                                           ControlState::ENABLED, aValue, OUString());
 519         if (bNeedErase)
 520             rRenderContext.Pop();
 521         if (bNativeOK)
 522             return;
 523     }
 524
 525     // precompute values
 526     sal_uInt16 nPerc1 = nPercent1 / nPercentCount;
 527     sal_uInt16 nPerc2 = nPercent2 / nPercentCount;
 528
 529     if (nPerc1 > nPerc2)
 530     {
 531         // support progress that can also decrease
 532
 533         // compute rectangle
 534         tools::Long nDX = nPrgsWidth + nOffset;
 535         tools::Long nLeft = rPos.X() + ((nPerc1 - 1) * nDX);
 536         tools::Rectangle aRect(nLeft, rPos.Y(), nLeft + nPrgsWidth, rPos.Y() + nPrgsHeight);
 537
 538         do
 539         {
 540             rRenderContext.Erase(aRect);
 541             aRect.AdjustLeft( -nDX );
 542             aRect.AdjustRight( -nDX );
 543             nPerc1--;
 544         }
 545         while (nPerc1 > nPerc2);
 546     }
 547     else if (nPerc1 < nPerc2)
 548     {
 549         // draw Percent rectangle
 550         // if Percent2 greater than 100%, adapt values
 551         if (nPercent2 > 10000)
 552         {
 553             nPerc2 = 10000 / nPercentCount;
 554             if (nPerc1 >= nPerc2)
 555                 nPerc1 = nPerc2 - 1;
 556         }
 557
 558         // compute rectangle
 559         tools::Long nDX = nPrgsWidth + nOffset;
 560         tools::Long nLeft = rPos.X() + (nPerc1 * nDX);
 561         tools::Rectangle aRect(nLeft, rPos.Y(), nLeft + nPrgsWidth, rPos.Y() + nPrgsHeight);
 562
 563         do
 564         {
 565             rRenderContext.DrawRect(aRect);
 566             aRect.AdjustLeft(nDX );
 567             aRect.AdjustRight(nDX );
 568             nPerc1++;
 569         }
 570         while (nPerc1 < nPerc2);
 571
 572         // if greater than 100%, set rectangle to blink
 573         if (nPercent2 > 10000)
 574         {
 575             // define on/off status
 576             if (((nPercent2 / nPercentCount) & 0x01) == (nPercentCount & 0x01))
 577             {
 578                 aRect.AdjustLeft( -nDX );
 579                 aRect.AdjustRight( -nDX );
 580                 rRenderContext.Erase(aRect);
 581             }
 582         }
 583     }
 584 }
 585
 586 void StatusBar::ImplDrawProgress(vcl::RenderContext& rRenderContext, sal_uInt16 nPercent2)
 587 {
 588     bool bNative = rRenderContext.IsNativeControlSupported(ControlType::Progress, ControlPart::Entire);
 589     // bPaint: draw text also, else only update progress
 590     rRenderContext.DrawText(maPrgsTxtPos, maPrgsTxt);
 591     if (!bNative)
 592     {
 593         DecorationView aDecoView(&rRenderContext);
 594         aDecoView.DrawFrame(maPrgsFrameRect, DrawFrameStyle::In);
 595     }
 596
 597     Point aPos(maPrgsFrameRect.Left() + STATUSBAR_PRGS_OFFSET,
 598                maPrgsFrameRect.Top()  + STATUSBAR_PRGS_OFFSET);
 599     tools::Long nPrgsHeight = mnPrgsSize;
 600     if (bNative)
 601     {
 602         aPos = maPrgsFrameRect.TopLeft();
 603         nPrgsHeight = maPrgsFrameRect.GetHeight();
 604     }
 605     DrawProgress(this, rRenderContext, aPos, mnPrgsSize / 2, mnPrgsSize, nPrgsHeight,
 606                  0, nPercent2 * 100, mnPercentCount, maPrgsFrameRect);
 607 }
 608
 609 void StatusBar::ImplCalcProgressRect()
 610 {
 611     // calculate text size
 612     Size aPrgsTxtSize( GetTextWidth( maPrgsTxt ), GetTextHeight() );
 613     maPrgsTxtPos.setX( STATUSBAR_OFFSET_X+1 );
 614
 615     // calculate progress frame
 616     maPrgsFrameRect.SetLeft( maPrgsTxtPos.X()+aPrgsTxtSize.Width()+STATUSBAR_OFFSET );
 617     maPrgsFrameRect.SetTop( STATUSBAR_OFFSET_Y );
 618     maPrgsFrameRect.SetBottom( mnCalcHeight - STATUSBAR_OFFSET_Y );
 619
 620     // calculate size of progress rects
 621     mnPrgsSize = maPrgsFrameRect.Bottom()-maPrgsFrameRect.Top()-(STATUSBAR_PRGS_OFFSET*2);
 622     sal_uInt16 nMaxPercent = STATUSBAR_PRGS_COUNT;
 623
 624     tools::Long nMaxWidth = mnDX-STATUSBAR_OFFSET-1;
 625
 626     // make smaller if there are too many rects
 627     while ( maPrgsFrameRect.Left()+ImplCalcProgressWidth( nMaxPercent, mnPrgsSize ) > nMaxWidth )
 628     {
 629         nMaxPercent--;
 630         if ( nMaxPercent <= STATUSBAR_PRGS_MIN )
 631             break;
 632     }
 633     maPrgsFrameRect.SetRight( maPrgsFrameRect.Left() + ImplCalcProgressWidth( nMaxPercent, mnPrgsSize ) );
 634
 635     // save the divisor for later
 636     mnPercentCount = 10000 / nMaxPercent;
 637     bool bNativeOK = false;
 638     if( IsNativeControlSupported( ControlType::Progress, ControlPart::Entire ) )
 639     {
 640         ImplControlValue aValue;
 641         tools::Rectangle aControlRegion( tools::Rectangle( Point(), maPrgsFrameRect.GetSize() ) );
 642         tools::Rectangle aNativeControlRegion, aNativeContentRegion;
 643         if( (bNativeOK = GetNativeControlRegion( ControlType::Progress, ControlPart::Entire, aControlRegion,
 644                                                  ControlState::ENABLED, aValue,
 645                                                  aNativeControlRegion, aNativeContentRegion ) ) )
 646         {
 647             tools::Long nProgressHeight = aNativeControlRegion.GetHeight();
 648             if( nProgressHeight > maPrgsFrameRect.GetHeight() )
 649             {
 650                 tools::Long nDelta = nProgressHeight - maPrgsFrameRect.GetHeight();
 651                 maPrgsFrameRect.AdjustTop( -(nDelta - nDelta/2) );
 652                 maPrgsFrameRect.AdjustBottom(nDelta/2 );
 653             }
 654             maPrgsTxtPos.setY( maPrgsFrameRect.Top() + (nProgressHeight - GetTextHeight())/2 );
 655         }
 656     }
 657     if( ! bNativeOK )
 658         maPrgsTxtPos.setY( mnTextY );
 659 }
 660
 661 void StatusBar::MouseButtonDown( const MouseEvent& rMEvt )
 662 {
 663     // trigger toolbox only for left mouse button
 664     if ( !rMEvt.IsLeft() )
 665         return;
 666
 667     Point  aMousePos = rMEvt.GetPosPixel();
 668
 669     // search for clicked item
 670     for ( size_t i = 0; i < mvItemList.size(); ++i )
 671     {
 672         ImplStatusItem* pItem = mvItemList[ i ].get();
 673         // check item for being clicked
 674         if ( ImplGetItemRectPos( sal_uInt16(i) ).Contains( aMousePos ) )
 675         {
 676             mnCurItemId = pItem->mnId;
 677             if ( rMEvt.GetClicks() == 2 )
 678                 DoubleClick();
 679             else
 680                 Click();
 681             mnCurItemId = 0;
 682
 683             // Item found
 684             return;
 685         }
 686     }
 687
 688     // if there's no item, trigger Click or DoubleClick
 689     if ( rMEvt.GetClicks() == 2 )
 690         DoubleClick();
 691     else
 692         Click();
 693 }
 694
 695 void StatusBar::Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect)
 696 {
 697     if (mbFormat)
 698         ImplFormat();
 699
 700     sal_uInt16 nItemCount = sal_uInt16( mvItemList.size() );
 701
 702     if (mbProgressMode)
 703     {
 704         rRenderContext.Push(vcl::PushFlags::FILLCOLOR | vcl::PushFlags::LINECOLOR);
 705
 706         const StyleSettings& rStyleSettings = rRenderContext.GetSettings().GetStyleSettings();
 707         Color aProgressColor = rStyleSettings.GetHighlightColor();
 708         if (aProgressColor == rStyleSettings.GetFaceColor())
 709             aProgressColor = rStyleSettings.GetDarkShadowColor();
 710         rRenderContext.SetLineColor();
 711         rRenderContext.SetFillColor(aProgressColor);
 712
 713         ImplDrawProgress(rRenderContext, mnPercent);
 714
 715         rRenderContext.Pop();
 716     }
 717     else
 718     {
 719         // draw text
 720         if (GetStyle() & WB_RIGHT)
 721             ImplDrawText(rRenderContext);
 722
 723         // draw items
 724
 725         // Do offscreen only when we are not recording layout...
 726         bool bOffscreen = !rRenderContext.ImplIsRecordLayout();
 727
 728         if (!bOffscreen)
 729             rRenderContext.Erase(rRect);
 730
 731         for (sal_uInt16 i = 0; i < nItemCount; i++)
 732             ImplDrawItem(rRenderContext, bOffscreen, i);
 733     }
 734
 735     // draw line at the top of the status bar (to visually distinguish it from
 736     // shell / docking area)
 737     const StyleSettings& rStyleSettings = rRenderContext.GetSettings().GetStyleSettings();
 738     rRenderContext.SetLineColor(rStyleSettings.GetShadowColor());
 739     rRenderContext.DrawLine(Point(0, 0), Point(mnDX-1, 0));
 740 }
 741
 742 void StatusBar::Resize()
 743 {
 744     // save width and height
 745     Size aSize = GetOutputSizePixel();
 746     mnDX = aSize.Width() - ImplGetSVData()->maNWFData.mnStatusBarLowerRightOffset;
 747     mnDY = aSize.Height();
 748     mnCalcHeight = mnDY;
 749
 750     mnTextY = (mnCalcHeight-GetTextHeight())/2;
 751
 752     // provoke re-formatting
 753     mbFormat = true;
 754
 755     if ( mbProgressMode )
 756         ImplCalcProgressRect();
 757
 758     Invalidate();
 759 }
 760
 761 void StatusBar::RequestHelp( const HelpEvent& rHEvt )
 762 {
 763     // no keyboard help in status bar
 764     if( rHEvt.KeyboardActivated() )
 765         return;
 766
 767     sal_uInt16 nItemId = GetItemId( ScreenToOutputPixel( rHEvt.GetMousePosPixel() ) );
 768
 769     if ( nItemId )
 770     {
 771         tools::Rectangle aItemRect = GetItemRect( nItemId );
 772         Point aPt = OutputToScreenPixel( aItemRect.TopLeft() );
 773         aItemRect.SetLeft( aPt.X() );
 774         aItemRect.SetTop( aPt.Y() );
 775         aPt = OutputToScreenPixel( aItemRect.BottomRight() );
 776         aItemRect.SetRight( aPt.X() );
 777         aItemRect.SetBottom( aPt.Y() );
 778
 779         if ( rHEvt.GetMode() & HelpEventMode::BALLOON )
 780         {
 781             OUString aStr = GetHelpText( nItemId );
 782             Help::ShowBalloon( this, aItemRect.Center(), aItemRect, aStr );
 783             return;
 784         }
 785         else if ( rHEvt.GetMode() & HelpEventMode::QUICK )
 786         {
 787             OUString aStr(GetQuickHelpText(nItemId));
 788             // show quickhelp if available
 789             if (!aStr.isEmpty())
 790             {
 791                 Help::ShowQuickHelp( this, aItemRect, aStr );
 792                 return;
 793             }
 794             aStr = GetItemText( nItemId );
 795             // show a quick help if item text doesn't fit
 796             if ( GetTextWidth( aStr ) > aItemRect.GetWidth() )
 797             {
 798                 Help::ShowQuickHelp( this, aItemRect, aStr );
 799                 return;
 800             }
 801         }
 802     }
 803
 804     Window::RequestHelp( rHEvt );
 805 }
 806
 807 void StatusBar::StateChanged( StateChangedType nType )
 808 {
 809     Window::StateChanged( nType );
 810
 811     if ( nType == StateChangedType::InitShow )
 812         ImplFormat();
 813     else if ( nType == StateChangedType::UpdateMode )
 814         Invalidate();
 815     else if ( (nType == StateChangedType::Zoom) ||
 816               (nType == StateChangedType::ControlFont) )
 817     {
 818         mbFormat = true;
 819         ImplInitSettings();
 820         Invalidate();
 821     }
 822     else if ( nType == StateChangedType::ControlForeground )
 823     {
 824         ImplInitSettings();
 825         Invalidate();
 826     }
 827     else if ( nType == StateChangedType::ControlBackground )
 828     {
 829         ImplInitSettings();
 830         Invalidate();
 831     }
 832
 833     //invalidate layout cache
 834     for (auto & pItem : mvItemList)
 835     {
 836         pItem->mLayoutGlyphsCache.reset();
 837     }
 838
 839 }
 840
 841 void StatusBar::DataChanged( const DataChangedEvent& rDCEvt )
 842 {
 843     Window::DataChanged( rDCEvt );
 844
 845     if (  !((rDCEvt.GetType() == DataChangedEventType::DISPLAY         )
 846        || (rDCEvt.GetType() == DataChangedEventType::FONTS           )
 847        || (rDCEvt.GetType() == DataChangedEventType::FONTSUBSTITUTION)
 848        || (  (rDCEvt.GetType() == DataChangedEventType::SETTINGS)
 849           && (rDCEvt.GetFlags() & AllSettingsFlags::STYLE )
 850           ))
 851        )
 852         return;
 853
 854     mbFormat = true;
 855     ImplInitSettings();
 856     tools::Long nFudge = GetTextHeight() / 4;
 857     for (auto & pItem : mvItemList)
 858     {
 859         tools::Long nWidth = GetTextWidth( pItem->maText ) + nFudge;
 860         if( nWidth > pItem->mnWidth + STATUSBAR_OFFSET )
 861             pItem->mnWidth = nWidth + STATUSBAR_OFFSET;
 862
 863         pItem->mLayoutGlyphsCache.reset();
 864     }
 865     Size aSize = GetSizePixel();
 866     // do not disturb current width, since
 867     // CalcWindowSizePixel calculates a minimum width
 868     aSize.setHeight( CalcWindowSizePixel().Height() );
 869     SetSizePixel( aSize );
 870     Invalidate();
 871 }
 872
 873 void StatusBar::Click()
 874 {
 875     maClickHdl.Call( this );
 876 }
 877
 878 void StatusBar::DoubleClick()
 879 {
 880     maDoubleClickHdl.Call( this );
 881 }
 882
 883 void StatusBar::UserDraw( const UserDrawEvent& )
 884 {
 885 }
 886
 887 void StatusBar::InsertItem( sal_uInt16 nItemId, sal_uLong nWidth,
 888                             StatusBarItemBits nBits,
 889                             tools::Long nOffset, sal_uInt16 nPos )
 890 {
 891     SAL_WARN_IF( !nItemId, "vcl", "StatusBar::InsertItem(): ItemId == 0" );
 892     SAL_WARN_IF( GetItemPos( nItemId ) != STATUSBAR_ITEM_NOTFOUND, "vcl",
 893                 "StatusBar::InsertItem(): ItemId already exists" );
 894
 895     // default: IN and CENTER
 896     if ( !(nBits & (StatusBarItemBits::In | StatusBarItemBits::Out | StatusBarItemBits::Flat)) )
 897         nBits |= StatusBarItemBits::In;
 898     if ( !(nBits & (StatusBarItemBits::Left | StatusBarItemBits::Right | StatusBarItemBits::Center)) )
 899         nBits |= StatusBarItemBits::Center;
 900
 901     // create item
 902     if (mbAdjustHiDPI)
 903     {
 904         nWidth *= GetDPIScaleFactor();
 905     }
 906     tools::Long nFudge = GetTextHeight()/4;
 907     std::unique_ptr<ImplStatusItem> pItem(new ImplStatusItem);
 908     pItem->mnId             = nItemId;
 909     pItem->mnBits           = nBits;
 910     pItem->mnWidth          = static_cast<tools::Long>(nWidth)+nFudge+STATUSBAR_OFFSET;
 911     pItem->mnOffset         = nOffset;
 912     pItem->mpUserData       = nullptr;
 913     pItem->mbVisible        = true;
 914
 915     // add item to list
 916     if ( nPos < mvItemList.size() ) {
 917         mvItemList.insert( mvItemList.begin() + nPos, std::move(pItem) );
 918     } else {
 919         mvItemList.push_back( std::move(pItem) );
 920     }
 921
 922     mbFormat = true;
 923     if ( ImplIsItemUpdate() )
 924         Invalidate();
 925
 926     CallEventListeners( VclEventId::StatusbarItemAdded, reinterpret_cast<void*>(nItemId) );
 927 }
 928
 929 void StatusBar::RemoveItem( sal_uInt16 nItemId )
 930 {
 931     sal_uInt16 nPos = GetItemPos( nItemId );
 932     if ( nPos != STATUSBAR_ITEM_NOTFOUND )
 933     {
 934         mvItemList.erase( mvItemList.begin() + nPos );
 935
 936         mbFormat = true;
 937         if ( ImplIsItemUpdate() )
 938             Invalidate();
 939
 940         CallEventListeners( VclEventId::StatusbarItemRemoved, reinterpret_cast<void*>(nItemId) );
 941     }
 942 }
 943
 944 void StatusBar::ShowItem( sal_uInt16 nItemId )
 945 {
 946     sal_uInt16 nPos = GetItemPos( nItemId );
 947
 948     if ( nPos == STATUSBAR_ITEM_NOTFOUND )
 949         return;
 950
 951     ImplStatusItem* pItem = mvItemList[ nPos ].get();
 952     if ( !pItem->mbVisible )
 953     {
 954         pItem->mbVisible = true;
 955
 956         mbFormat = true;
 957         if ( ImplIsItemUpdate() )
 958             Invalidate();
 959
 960         CallEventListeners( VclEventId::StatusbarShowItem, reinterpret_cast<void*>(nItemId) );
 961     }
 962 }
 963
 964 void StatusBar::HideItem( sal_uInt16 nItemId )
 965 {
 966     sal_uInt16 nPos = GetItemPos( nItemId );
 967
 968     if ( nPos == STATUSBAR_ITEM_NOTFOUND )
 969         return;
 970
 971     ImplStatusItem* pItem = mvItemList[ nPos ].get();
 972     if ( pItem->mbVisible )
 973     {
 974         pItem->mbVisible = false;
 975
 976         mbFormat = true;
 977         if ( ImplIsItemUpdate() )
 978             Invalidate();
 979
 980         CallEventListeners( VclEventId::StatusbarHideItem, reinterpret_cast<void*>(nItemId) );
 981     }
 982 }
 983
 984 bool StatusBar::IsItemVisible( sal_uInt16 nItemId ) const
 985 {
 986     sal_uInt16 nPos = GetItemPos( nItemId );
 987
 988     if ( nPos != STATUSBAR_ITEM_NOTFOUND )
 989         return mvItemList[ nPos ]->mbVisible;
 990     else
 991         return false;
 992 }
 993
 994 void StatusBar::Clear()
 995 {
 996     // delete all items
 997     mvItemList.clear();
 998
 999     mbFormat = true;
1000     if ( ImplIsItemUpdate() )
1001         Invalidate();
1002
1003     CallEventListeners( VclEventId::StatusbarAllItemsRemoved );
1004 }
1005
1006 sal_uInt16 StatusBar::GetItemCount() const
1007 {
1008     return static_cast<sal_uInt16>(mvItemList.size());
1009 }
1010
1011 sal_uInt16 StatusBar::GetItemId( sal_uInt16 nPos ) const
1012 {
1013     if ( nPos < mvItemList.size() )
1014         return mvItemList[ nPos ]->mnId;
1015     return 0;
1016 }
1017
1018 sal_uInt16 StatusBar::GetItemPos( sal_uInt16 nItemId ) const
1019 {
1020     for ( size_t i = 0, n = mvItemList.size(); i < n; ++i ) {
1021         if ( mvItemList[ i ]->mnId == nItemId ) {
1022             return sal_uInt16( i );
1023         }
1024     }
1025
1026     return STATUSBAR_ITEM_NOTFOUND;
1027 }
1028
1029 sal_uInt16 StatusBar::GetItemId( const Point& rPos ) const
1030 {
1031     if ( !mbFormat )
1032     {
1033         sal_uInt16 nItemCount = GetItemCount();
1034         sal_uInt16 nPos;
1035         for ( nPos = 0; nPos < nItemCount; nPos++ )
1036         {
1037             // get rectangle
1038             tools::Rectangle aRect = ImplGetItemRectPos( nPos );
1039             if ( aRect.Contains( rPos ) )
1040                 return mvItemList[ nPos ]->mnId;
1041         }
1042     }
1043
1044     return 0;
1045 }
1046
1047 tools::Rectangle StatusBar::GetItemRect( sal_uInt16 nItemId ) const
1048 {
1049     tools::Rectangle aRect;
1050
1051     if ( !mbFormat )
1052     {
1053         sal_uInt16 nPos = GetItemPos( nItemId );
1054         if ( nPos != STATUSBAR_ITEM_NOTFOUND )
1055         {
1056             // get rectangle and subtract frame
1057             aRect = ImplGetItemRectPos( nPos );
1058             tools::Long nW = 1;
1059             aRect.AdjustTop(nW-1 );
1060             aRect.AdjustBottom( -(nW-1) );
1061             aRect.AdjustLeft(nW );
1062             aRect.AdjustRight( -nW );
1063             return aRect;
1064         }
1065     }
1066
1067     return aRect;
1068 }
1069
1070 Point StatusBar::GetItemTextPos( sal_uInt16 nItemId ) const
1071 {
1072     if ( !mbFormat )
1073     {
1074         sal_uInt16 nPos = GetItemPos( nItemId );
1075         if ( nPos != STATUSBAR_ITEM_NOTFOUND )
1076         {
1077             // get rectangle
1078             ImplStatusItem* pItem = mvItemList[ nPos ].get();
1079             tools::Rectangle aRect = ImplGetItemRectPos( nPos );
1080             tools::Long nW = 1;
1081             tools::Rectangle           aTextRect( aRect.Left()+nW, aRect.Top()+nW,
1082                                            aRect.Right()-nW, aRect.Bottom()-nW );
1083             Point aPos = ImplGetItemTextPos( aTextRect.GetSize(),
1084                                              Size( GetTextWidth( pItem->maText ), GetTextHeight() ),
1085                                              pItem->mnBits );
1086             if ( !mbInUserDraw )
1087             {
1088                 aPos.AdjustX(aTextRect.Left() );
1089                 aPos.AdjustY(aTextRect.Top() );
1090             }
1091             return aPos;
1092         }
1093     }
1094
1095     return Point();
1096 }
1097
1098 sal_uLong StatusBar::GetItemWidth( sal_uInt16 nItemId ) const
1099 {
1100     sal_uInt16 nPos = GetItemPos( nItemId );
1101
1102     if ( nPos != STATUSBAR_ITEM_NOTFOUND )
1103         return mvItemList[ nPos ]->mnWidth;
1104
1105     return 0;
1106 }
1107
1108 StatusBarItemBits StatusBar::GetItemBits( sal_uInt16 nItemId ) const
1109 {
1110     sal_uInt16 nPos = GetItemPos( nItemId );
1111
1112     if ( nPos != STATUSBAR_ITEM_NOTFOUND )
1113         return mvItemList[ nPos ]->mnBits;
1114
1115     return StatusBarItemBits::NONE;
1116 }
1117
1118 tools::Long StatusBar::GetItemOffset( sal_uInt16 nItemId ) const
1119 {
1120     sal_uInt16 nPos = GetItemPos( nItemId );
1121
1122     if ( nPos != STATUSBAR_ITEM_NOTFOUND )
1123         return mvItemList[ nPos ]->mnOffset;
1124
1125     return 0;
1126 }
1127
1128 void StatusBar::PaintSelfAndChildrenImmediately()
1129 {
1130     WindowImpl* pWindowImpl = ImplGetWindowImpl();
1131     const bool bOrigOverlapWin = pWindowImpl->mbOverlapWin;
1132     // Temporarily set mbOverlapWin so that any parent windows of StatusBar
1133     // that happen to have accumulated Invalidates are not taken as the root
1134     // paint candidate from which to paint the paint hierarchy. So we limit the
1135     // paint here to this statusbar and its children, disabling the
1136     // optimization to bundle pending paints together and suppressing any
1137     // unexpected side effects of entering parent window paint handlers if this
1138     // call is not from the primordial thread.
1139     pWindowImpl->mbOverlapWin = true;
1140     PaintImmediately();
1141     pWindowImpl->mbOverlapWin = bOrigOverlapWin;
1142 }
1143
1144 void StatusBar::SetItemText( sal_uInt16 nItemId, const OUString& rText, int nCharsWidth )
1145 {
1146     sal_uInt16 nPos = GetItemPos( nItemId );
1147
1148     if ( nPos == STATUSBAR_ITEM_NOTFOUND )
1149         return;
1150
1151     ImplStatusItem* pItem = mvItemList[ nPos ].get();
1152
1153     if ( pItem->maText == rText )
1154         return;
1155
1156     pItem->maText = rText;
1157
1158     // adjust item width - see also DataChanged()
1159     tools::Long nFudge = GetTextHeight()/4;
1160
1161     tools::Long nWidth;
1162     if (nCharsWidth != -1)
1163     {
1164         nWidth = GetTextWidth("0",0,-1,nullptr,
1165                     SalLayoutGlyphsCache::self()->GetLayoutGlyphs(GetOutDev(),"0"));
1166         nWidth = nWidth * nCharsWidth + nFudge;
1167     }
1168     else
1169     {
1170         pItem->mLayoutGlyphsCache.reset();
1171         nWidth = GetTextWidth( pItem->maText,0,-1,nullptr, pItem->GetTextGlyphs(GetOutDev())) + nFudge;
1172     }
1173
1174     if( (nWidth > pItem->mnWidth + STATUSBAR_OFFSET) ||
1175         ((nWidth < pItem->mnWidth) && (mnDX - STATUSBAR_OFFSET) < mnItemsWidth  ))
1176     {
1177         pItem->mnWidth = nWidth + STATUSBAR_OFFSET;
1178         ImplFormat();
1179         Invalidate();
1180     }
1181
1182     // re-draw item if StatusBar is visible and UpdateMode active
1183     if ( pItem->mbVisible && !mbFormat && ImplIsItemUpdate() )
1184     {
1185         tools::Rectangle aRect = ImplGetItemRectPos(nPos);
1186         Invalidate(aRect);
1187         PaintSelfAndChildrenImmediately();
1188     }
1189 }
1190
1191 const OUString& StatusBar::GetItemText( sal_uInt16 nItemId ) const
1192 {
1193     sal_uInt16 nPos = GetItemPos( nItemId );
1194
1195     assert( nPos != STATUSBAR_ITEM_NOTFOUND );
1196
1197     return mvItemList[ nPos ]->maText;
1198 }
1199
1200 void StatusBar::SetItemCommand( sal_uInt16 nItemId, const OUString& rCommand )
1201 {
1202     sal_uInt16 nPos = GetItemPos( nItemId );
1203
1204     if ( nPos != STATUSBAR_ITEM_NOTFOUND )
1205     {
1206         ImplStatusItem* pItem = mvItemList[ nPos ].get();
1207
1208         if ( pItem->maCommand != rCommand )
1209             pItem->maCommand = rCommand;
1210     }
1211 }
1212
1213 OUString StatusBar::GetItemCommand( sal_uInt16 nItemId )
1214 {
1215     sal_uInt16 nPos = GetItemPos( nItemId );
1216
1217     if ( nPos != STATUSBAR_ITEM_NOTFOUND )
1218         return mvItemList[ nPos ]->maCommand;
1219
1220     return OUString();
1221 }
1222
1223 void StatusBar::SetItemData( sal_uInt16 nItemId, void* pNewData )
1224 {
1225     sal_uInt16 nPos = GetItemPos( nItemId );
1226
1227     if ( nPos == STATUSBAR_ITEM_NOTFOUND )
1228         return;
1229
1230     ImplStatusItem* pItem = mvItemList[ nPos ].get();
1231     // invalidate cache
1232     pItem->mLayoutGlyphsCache.reset();
1233     pItem->mpUserData = pNewData;
1234
1235     // call Draw-Item if it's a User-Item
1236     if ( (pItem->mnBits & StatusBarItemBits::UserDraw) && pItem->mbVisible &&
1237          !mbFormat && ImplIsItemUpdate() )
1238     {
1239         tools::Rectangle aRect = ImplGetItemRectPos(nPos);
1240         Invalidate(aRect, InvalidateFlags::NoErase);
1241         PaintSelfAndChildrenImmediately();
1242     }
1243 }
1244
1245 void* StatusBar::GetItemData( sal_uInt16 nItemId ) const
1246 {
1247     sal_uInt16 nPos = GetItemPos( nItemId );
1248
1249     if ( nPos != STATUSBAR_ITEM_NOTFOUND )
1250         return mvItemList[ nPos ]->mpUserData;
1251
1252     return nullptr;
1253 }
1254
1255 void StatusBar::RedrawItem(sal_uInt16 nItemId)
1256 {
1257     if ( mbFormat )
1258         return;
1259
1260     sal_uInt16 nPos = GetItemPos(nItemId);
1261     if ( nPos == STATUSBAR_ITEM_NOTFOUND )
1262         return;
1263
1264     ImplStatusItem* pItem = mvItemList[ nPos ].get();
1265     if ((pItem->mnBits & StatusBarItemBits::UserDraw) &&
1266         pItem->mbVisible && ImplIsItemUpdate())
1267     {
1268         tools::Rectangle aRect = ImplGetItemRectPos(nPos);
1269         Invalidate(aRect);
1270         PaintSelfAndChildrenImmediately();
1271     }
1272 }
1273
1274 void StatusBar::SetHelpText( sal_uInt16 nItemId, const OUString& rText )
1275 {
1276     sal_uInt16 nPos = GetItemPos( nItemId );
1277
1278     if ( nPos != STATUSBAR_ITEM_NOTFOUND )
1279         mvItemList[ nPos ]->maHelpText = rText;
1280 }
1281
1282 const OUString& StatusBar::GetHelpText( sal_uInt16 nItemId ) const
1283 {
1284     sal_uInt16 nPos = GetItemPos( nItemId );
1285
1286     assert ( nPos != STATUSBAR_ITEM_NOTFOUND );
1287
1288     ImplStatusItem* pItem = mvItemList[ nPos ].get();
1289     if ( pItem->maHelpText.isEmpty() && ( !pItem->maHelpId.isEmpty() || !pItem->maCommand.isEmpty() ))
1290     {
1291         Help* pHelp = Application::GetHelp();
1292         if ( pHelp )
1293         {
1294             if ( !pItem->maCommand.isEmpty() )
1295                 pItem->maHelpText = pHelp->GetHelpText( pItem->maCommand, this );
1296             if ( pItem->maHelpText.isEmpty() && !pItem->maHelpId.isEmpty() )
1297                 pItem->maHelpText = pHelp->GetHelpText( pItem->maHelpId, this );
1298         }
1299     }
1300
1301     return pItem->maHelpText;
1302 }
1303
1304 void StatusBar::SetQuickHelpText( sal_uInt16 nItemId, const OUString& rText )
1305 {
1306     sal_uInt16 nPos = GetItemPos( nItemId );
1307
1308     if ( nPos != STATUSBAR_ITEM_NOTFOUND )
1309         mvItemList[ nPos ]->maQuickHelpText = rText;
1310 }
1311
1312 const OUString& StatusBar::GetQuickHelpText( sal_uInt16 nItemId ) const
1313 {
1314     sal_uInt16 nPos = GetItemPos( nItemId );
1315
1316     assert ( nPos != STATUSBAR_ITEM_NOTFOUND );
1317
1318     ImplStatusItem* pItem = mvItemList[ nPos ].get();
1319     return pItem->maQuickHelpText;
1320 }
1321
1322 void StatusBar::SetHelpId( sal_uInt16 nItemId, const OUString& rHelpId )
1323 {
1324     sal_uInt16 nPos = GetItemPos( nItemId );
1325
1326     if ( nPos != STATUSBAR_ITEM_NOTFOUND )
1327         mvItemList[ nPos ]->maHelpId = rHelpId;
1328 }
1329
1330 void StatusBar::StartProgressMode( const OUString& rText )
1331 {
1332     SAL_WARN_IF( mbProgressMode, "vcl", "StatusBar::StartProgressMode(): progress mode is active" );
1333
1334     mbProgressMode  = true;
1335     mnPercent       = 0;
1336     maPrgsTxt       = rText;
1337
1338     // compute size
1339     ImplCalcProgressRect();
1340
1341     // trigger Paint, which draws text and frame
1342     if ( IsReallyVisible() )
1343     {
1344         Invalidate();
1345         PaintSelfAndChildrenImmediately();
1346     }
1347 }
1348
1349 void StatusBar::SetProgressValue( sal_uInt16 nNewPercent )
1350 {
1351     SAL_WARN_IF( !mbProgressMode, "vcl", "StatusBar::SetProgressValue(): no progress mode" );
1352     SAL_WARN_IF( nNewPercent > 100, "vcl", "StatusBar::SetProgressValue(): nPercent > 100" );
1353
1354     bool bInvalidate = mbProgressMode && IsReallyVisible() && (!mnPercent || (mnPercent != nNewPercent));
1355
1356     mnPercent = nNewPercent;
1357
1358     if (bInvalidate)
1359     {
1360         // Rate limit how often we paint, otherwise in some loading scenarios we can spend significant
1361         // time just painting progress bars.
1362         sal_uInt32 nTime_ms = osl_getGlobalTimer();
1363         if ((nTime_ms - mnLastProgressPaint_ms) > 100)
1364         {
1365             Invalidate(maPrgsFrameRect);
1366             PaintSelfAndChildrenImmediately();
1367             mnLastProgressPaint_ms = nTime_ms;
1368         }
1369     }
1370 }
1371
1372 void StatusBar::EndProgressMode()
1373 {
1374     SAL_WARN_IF( !mbProgressMode, "vcl", "StatusBar::EndProgressMode(): no progress mode" );
1375
1376     mbProgressMode = false;
1377     maPrgsTxt.clear();
1378
1379     if ( IsReallyVisible() )
1380     {
1381         Invalidate();
1382         PaintSelfAndChildrenImmediately();
1383     }
1384 }
1385
1386 void StatusBar::SetText(const OUString& rText)
1387 {
1388     if ((GetStyle() & WB_RIGHT) && !mbProgressMode && IsReallyVisible() && IsUpdateMode())
1389     {
1390         if (mbFormat)
1391         {
1392             Invalidate();
1393             Window::SetText(rText);
1394         }
1395         else
1396         {
1397             Invalidate();
1398             Window::SetText(rText);
1399             PaintSelfAndChildrenImmediately();
1400         }
1401     }
1402     else if (mbProgressMode)
1403     {
1404         maPrgsTxt = rText;
1405         if (IsReallyVisible())
1406         {
1407             Invalidate();
1408             PaintSelfAndChildrenImmediately();
1409         }
1410     }
1411     else
1412     {
1413         Window::SetText(rText);
1414     }
1415 }
1416
1417 Size StatusBar::CalcWindowSizePixel() const
1418 {
1419     size_t  i = 0;
1420     size_t  nCount = mvItemList.size();
1421     tools::Long    nOffset = 0;
1422     tools::Long    nCalcWidth = STATUSBAR_OFFSET_X*2;
1423     tools::Long    nCalcHeight;
1424
1425     while ( i < nCount )
1426     {
1427         ImplStatusItem* pItem = mvItemList[ i ].get();
1428         nCalcWidth += pItem->mnWidth + nOffset;
1429         nOffset = pItem->mnOffset;
1430         i++;
1431     }
1432
1433     tools::Long nMinHeight = std::max( static_cast<int>(GetTextHeight()), STATUSBAR_MIN_HEIGHT);
1434     const tools::Long nBarTextOffset = STATUSBAR_OFFSET_TEXTY*2;
1435     tools::Long nProgressHeight = nMinHeight + nBarTextOffset;
1436
1437     if( IsNativeControlSupported( ControlType::Progress, ControlPart::Entire ) )
1438     {
1439         ImplControlValue aValue;
1440         tools::Rectangle aControlRegion( Point(), Size( nCalcWidth, nMinHeight ) );
1441         tools::Rectangle aNativeControlRegion, aNativeContentRegion;
1442         if( GetNativeControlRegion( ControlType::Progress, ControlPart::Entire,
1443                     aControlRegion, ControlState::ENABLED, aValue,
1444                     aNativeControlRegion, aNativeContentRegion ) )
1445         {
1446             nProgressHeight = aNativeControlRegion.GetHeight();
1447         }
1448     }
1449
1450     nCalcHeight = nMinHeight+nBarTextOffset;
1451     if( nCalcHeight < nProgressHeight+2 )
1452         nCalcHeight = nProgressHeight+2;
1453
1454     return Size( nCalcWidth, nCalcHeight );
1455 }
1456
1457 void StatusBar::SetAccessibleName( sal_uInt16 nItemId, const OUString& rName )
1458 {
1459     sal_uInt16 nPos = GetItemPos( nItemId );
1460
1461     if ( nPos != STATUSBAR_ITEM_NOTFOUND )
1462     {
1463         ImplStatusItem* pItem = mvItemList[ nPos ].get();
1464
1465         if ( pItem->maAccessibleName != rName )
1466         {
1467             pItem->maAccessibleName = rName;
1468             CallEventListeners( VclEventId::StatusbarNameChanged, reinterpret_cast<void*>(pItem->mnId) );
1469         }
1470     }
1471 }
1472
1473 const OUString& StatusBar::GetAccessibleName( sal_uInt16 nItemId ) const
1474 {
1475     sal_uInt16 nPos = GetItemPos( nItemId );
1476
1477     assert ( nPos != STATUSBAR_ITEM_NOTFOUND );
1478
1479     return mvItemList[ nPos ]->maAccessibleName;
1480 }
1481
1482 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */