| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_vcl.hxx" |
| |
| #include <tools/list.hxx> |
| #include <tools/debug.hxx> |
| #include <tools/rc.h> |
| |
| #include <vcl/event.hxx> |
| #include <vcl/decoview.hxx> |
| #include <vcl/svapp.hxx> |
| #include <vcl/help.hxx> |
| #include <vcl/status.hxx> |
| #include <vcl/virdev.hxx> |
| |
| #include <svdata.hxx> |
| #include <window.h> |
| |
| // ======================================================================= |
| |
| #define STATUSBAR_OFFSET_X STATUSBAR_OFFSET |
| #define STATUSBAR_OFFSET_Y 2 |
| #define STATUSBAR_OFFSET_TEXTY 3 |
| |
| #define STATUSBAR_PRGS_OFFSET 3 |
| #define STATUSBAR_PRGS_COUNT 100 |
| #define STATUSBAR_PRGS_MIN 5 |
| |
| // ----------------------------------------------------------------------- |
| |
| class StatusBar::ImplData |
| { |
| public: |
| ImplData(); |
| ~ImplData(); |
| |
| VirtualDevice* mpVirDev; |
| long mnItemBorderWidth; |
| bool mbTopBorder:1; |
| bool mbDrawItemFrames:1; |
| }; |
| |
| StatusBar::ImplData::ImplData() |
| { |
| mpVirDev = NULL; |
| mbTopBorder = false; |
| mbDrawItemFrames = false; |
| mnItemBorderWidth = 0; |
| } |
| |
| StatusBar::ImplData::~ImplData() |
| { |
| } |
| |
| struct ImplStatusItem |
| { |
| sal_uInt16 mnId; |
| StatusBarItemBits mnBits; |
| long mnWidth; |
| long mnOffset; |
| long mnExtraWidth; |
| long mnX; |
| XubString maText; |
| XubString maHelpText; |
| XubString maQuickHelpText; |
| rtl::OString maHelpId; |
| void* mpUserData; |
| sal_Bool mbVisible; |
| XubString maAccessibleName; |
| XubString maCommand; |
| }; |
| |
| DECLARE_LIST( ImplStatusItemList, ImplStatusItem* ) |
| |
| // ======================================================================= |
| |
| inline long ImplCalcProgessWidth( sal_uInt16 nMax, long nSize ) |
| { |
| return ((nMax*(nSize+(nSize/2)))-(nSize/2)+(STATUSBAR_PRGS_OFFSET*2)); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| static Point ImplGetItemTextPos( const Size& rRectSize, const Size& rTextSize, |
| sal_uInt16 nStyle ) |
| { |
| long nX; |
| long nY; |
| long delta = (rTextSize.Height()/4) + 1; |
| if( delta + rTextSize.Width() > rRectSize.Width() ) |
| delta = 0; |
| |
| if ( nStyle & SIB_LEFT ) |
| nX = delta; |
| else if ( nStyle & SIB_RIGHT ) |
| nX = rRectSize.Width()-rTextSize.Width()-delta; |
| else // SIB_CENTER |
| nX = (rRectSize.Width()-rTextSize.Width())/2; |
| nY = (rRectSize.Height()-rTextSize.Height())/2 + 1; |
| return Point( nX, nY ); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| sal_Bool StatusBar::ImplIsItemUpdate() |
| { |
| if ( !mbProgressMode && mbVisibleItems && IsReallyVisible() && IsUpdateMode() ) |
| return sal_True; |
| else |
| return sal_False; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void StatusBar::ImplInit( Window* pParent, WinBits nStyle ) |
| { |
| mpImplData = new ImplData; |
| |
| // Default ist RightAlign |
| if ( !(nStyle & (WB_LEFT | WB_RIGHT)) ) |
| nStyle |= WB_RIGHT; |
| |
| Window::ImplInit( pParent, nStyle & ~WB_BORDER, NULL ); |
| |
| // WinBits merken |
| mpItemList = new ImplStatusItemList; |
| mpImplData->mpVirDev = new VirtualDevice( *this ); |
| mnCurItemId = 0; |
| mbFormat = sal_True; |
| mbVisibleItems = sal_True; |
| mbProgressMode = sal_False; |
| mbInUserDraw = sal_False; |
| mbBottomBorder = sal_False; |
| mnItemsWidth = STATUSBAR_OFFSET_X; |
| mnDX = 0; |
| mnDY = 0; |
| mnCalcHeight = 0; |
| mnItemY = STATUSBAR_OFFSET_Y; |
| mnTextY = STATUSBAR_OFFSET_TEXTY; |
| |
| ImplInitSettings( sal_True, sal_True, sal_True ); |
| SetLineColor(); |
| |
| SetOutputSizePixel( CalcWindowSizePixel() ); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| StatusBar::StatusBar( Window* pParent, WinBits nStyle ) : |
| Window( WINDOW_STATUSBAR ) |
| { |
| ImplInit( pParent, nStyle ); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| StatusBar::StatusBar( Window* pParent, const ResId& rResId ) : |
| Window( WINDOW_STATUSBAR ) |
| { |
| rResId.SetRT( RSC_STATUSBAR ); |
| WinBits nStyle = ImplInitRes( rResId ); |
| ImplInit( pParent, nStyle ); |
| ImplLoadRes( rResId ); |
| |
| if ( !(nStyle & WB_HIDE) ) |
| Show(); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| StatusBar::~StatusBar() |
| { |
| // Alle Items loeschen |
| ImplStatusItem* pItem = mpItemList->First(); |
| while ( pItem ) |
| { |
| delete pItem; |
| pItem = mpItemList->Next(); |
| } |
| |
| delete mpItemList; |
| |
| // VirtualDevice loeschen |
| delete mpImplData->mpVirDev; |
| |
| delete mpImplData; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void StatusBar::ImplInitSettings( sal_Bool bFont, |
| sal_Bool bForeground, sal_Bool bBackground ) |
| { |
| const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings(); |
| |
| if ( bFont ) |
| { |
| Font aFont = rStyleSettings.GetToolFont(); |
| if ( IsControlFont() ) |
| aFont.Merge( GetControlFont() ); |
| SetZoomedPointFont( aFont ); |
| } |
| |
| if ( bForeground || bFont ) |
| { |
| Color aColor; |
| if ( IsControlForeground() ) |
| aColor = GetControlForeground(); |
| else if ( GetStyle() & WB_3DLOOK ) |
| aColor = rStyleSettings.GetButtonTextColor(); |
| else |
| aColor = rStyleSettings.GetWindowTextColor(); |
| SetTextColor( aColor ); |
| SetTextFillColor(); |
| |
| mpImplData->mpVirDev->SetFont( GetFont() ); |
| mpImplData->mpVirDev->SetTextColor( GetTextColor() ); |
| mpImplData->mpVirDev->SetTextAlign( GetTextAlign() ); |
| mpImplData->mpVirDev->SetTextFillColor(); |
| } |
| |
| if ( bBackground ) |
| { |
| Color aColor; |
| if ( IsControlBackground() ) |
| aColor = GetControlBackground(); |
| else if ( GetStyle() & WB_3DLOOK ) |
| aColor = rStyleSettings.GetFaceColor(); |
| else |
| aColor = rStyleSettings.GetWindowColor(); |
| SetBackground( aColor ); |
| mpImplData->mpVirDev->SetBackground( GetBackground() ); |
| |
| // NWF background |
| if( ! IsControlBackground() && |
| IsNativeControlSupported( CTRL_WINDOW_BACKGROUND, PART_BACKGROUND_WINDOW ) ) |
| { |
| ImplGetWindowImpl()->mnNativeBackground = PART_BACKGROUND_WINDOW; |
| EnableChildTransparentMode( sal_True ); |
| } |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void StatusBar::ImplFormat() |
| { |
| ImplStatusItem* pItem; |
| long nExtraWidth; |
| long nExtraWidth2; |
| long nX; |
| sal_uInt16 nAutoSizeItems = 0; |
| |
| // Breiten zusammenrechnen |
| mnItemsWidth = STATUSBAR_OFFSET_X; |
| long nOffset = 0; |
| pItem = mpItemList->First(); |
| while ( pItem ) |
| { |
| if ( pItem->mbVisible ) |
| { |
| if ( pItem->mnBits & SIB_AUTOSIZE ) |
| nAutoSizeItems++; |
| |
| mnItemsWidth += pItem->mnWidth + nOffset; |
| nOffset = pItem->mnOffset; |
| } |
| |
| pItem = mpItemList->Next(); |
| } |
| |
| if ( GetStyle() & WB_RIGHT ) |
| { |
| // Bei rechtsbuendiger Ausrichtung wird kein AutoSize ausgewertet, |
| // da wir links den Text anzeigen, der mit SetText gesetzt wird |
| nX = mnDX - mnItemsWidth; |
| nExtraWidth = 0; |
| nExtraWidth2 = 0; |
| } |
| else |
| { |
| mnItemsWidth += STATUSBAR_OFFSET_X; |
| |
| // Bei linksbuendiger Ausrichtung muessen wir gegebenenfalls noch |
| // AutoSize auswerten |
| if ( nAutoSizeItems && (mnDX > (mnItemsWidth - STATUSBAR_OFFSET)) ) |
| { |
| nExtraWidth = (mnDX - mnItemsWidth - 1) / nAutoSizeItems; |
| nExtraWidth2 = (mnDX - mnItemsWidth - 1) % nAutoSizeItems; |
| } |
| else |
| { |
| nExtraWidth = 0; |
| nExtraWidth2 = 0; |
| } |
| nX = STATUSBAR_OFFSET_X; |
| if( ImplHasMirroredGraphics() && IsRTLEnabled() ) |
| nX += ImplGetSVData()->maNWFData.mnStatusBarLowerRightOffset; |
| } |
| |
| pItem = mpItemList->First(); |
| while ( pItem ) |
| { |
| if ( pItem->mbVisible ) |
| { |
| if ( pItem->mnBits & SIB_AUTOSIZE ) |
| { |
| pItem->mnExtraWidth = nExtraWidth; |
| if ( nExtraWidth2 ) |
| { |
| pItem->mnExtraWidth++; |
| nExtraWidth2--; |
| } |
| } |
| else |
| pItem->mnExtraWidth = 0; |
| |
| pItem->mnX = nX; |
| nX += pItem->mnWidth + pItem->mnExtraWidth + pItem->mnOffset; |
| } |
| |
| pItem = mpItemList->Next(); |
| } |
| |
| mbFormat = sal_False; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| Rectangle StatusBar::ImplGetItemRectPos( sal_uInt16 nPos ) const |
| { |
| Rectangle aRect; |
| ImplStatusItem* pItem; |
| pItem = mpItemList->GetObject( nPos ); |
| if ( pItem ) |
| { |
| if ( pItem->mbVisible ) |
| { |
| aRect.Left() = pItem->mnX; |
| aRect.Right() = aRect.Left() + pItem->mnWidth + pItem->mnExtraWidth; |
| aRect.Top() = mnItemY; |
| aRect.Bottom() = mnCalcHeight - STATUSBAR_OFFSET_Y; |
| if( IsTopBorder() ) |
| aRect.Bottom()+=2; |
| } |
| } |
| |
| return aRect; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| sal_uInt16 StatusBar::ImplGetFirstVisiblePos() const |
| { |
| ImplStatusItem* pItem; |
| |
| for( sal_uInt16 nPos = 0; nPos < mpItemList->Count(); nPos++ ) |
| { |
| pItem = mpItemList->GetObject( nPos ); |
| if ( pItem ) |
| { |
| if ( pItem->mbVisible ) |
| return nPos; |
| } |
| } |
| |
| return ~0; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void StatusBar::ImplDrawText( sal_Bool bOffScreen, long nOldTextWidth ) |
| { |
| // Das ueberschreiben der Item-Box verhindern |
| Rectangle aTextRect; |
| aTextRect.Left() = STATUSBAR_OFFSET_X+1; |
| aTextRect.Top() = mnTextY; |
| if ( mbVisibleItems && (GetStyle() & WB_RIGHT) ) |
| aTextRect.Right() = mnDX - mnItemsWidth - 1; |
| else |
| aTextRect.Right() = mnDX - 1; |
| if ( aTextRect.Right() > aTextRect.Left() ) |
| { |
| // Position ermitteln |
| XubString aStr = GetText(); |
| sal_uInt16 nPos = aStr.Search( _LF ); |
| if ( nPos != STRING_NOTFOUND ) |
| aStr.Erase( nPos ); |
| |
| aTextRect.Bottom() = aTextRect.Top()+GetTextHeight()+1; |
| |
| if ( bOffScreen ) |
| { |
| long nMaxWidth = Max( nOldTextWidth, GetTextWidth( aStr ) ); |
| Size aVirDevSize( nMaxWidth, aTextRect.GetHeight() ); |
| mpImplData->mpVirDev->SetOutputSizePixel( aVirDevSize ); |
| Rectangle aTempRect = aTextRect; |
| aTempRect.SetPos( Point( 0, 0 ) ); |
| mpImplData->mpVirDev->DrawText( aTempRect, aStr, TEXT_DRAW_LEFT | TEXT_DRAW_TOP | TEXT_DRAW_CLIP | TEXT_DRAW_ENDELLIPSIS ); |
| DrawOutDev( aTextRect.TopLeft(), aVirDevSize, Point(), aVirDevSize, *mpImplData->mpVirDev ); |
| } |
| else |
| DrawText( aTextRect, aStr, TEXT_DRAW_LEFT | TEXT_DRAW_TOP | TEXT_DRAW_CLIP | TEXT_DRAW_ENDELLIPSIS ); |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void StatusBar::ImplDrawItem( sal_Bool bOffScreen, sal_uInt16 nPos, sal_Bool bDrawText, sal_Bool bDrawFrame ) |
| { |
| Rectangle aRect = ImplGetItemRectPos( nPos ); |
| |
| if ( aRect.IsEmpty() ) |
| return; |
| |
| // Ausgabebereich berechnen |
| ImplStatusItem* pItem = mpItemList->GetObject( nPos ); |
| long nW = mpImplData->mnItemBorderWidth + 1; |
| Rectangle aTextRect( aRect.Left()+nW, aRect.Top()+nW, |
| aRect.Right()-nW, aRect.Bottom()-nW ); |
| Size aTextRectSize( aTextRect.GetSize() ); |
| |
| if ( bOffScreen ) |
| mpImplData->mpVirDev->SetOutputSizePixel( aTextRectSize ); |
| else |
| { |
| Region aRegion( aTextRect ); |
| SetClipRegion( aRegion ); |
| } |
| |
| // Text ausgeben |
| if ( bDrawText ) |
| { |
| Size aTextSize( GetTextWidth( pItem->maText ), GetTextHeight() ); |
| Point aTextPos = ImplGetItemTextPos( aTextRectSize, aTextSize, pItem->mnBits ); |
| if ( bOffScreen ) |
| mpImplData->mpVirDev->DrawText( aTextPos, pItem->maText ); |
| else |
| { |
| aTextPos.X() += aTextRect.Left(); |
| aTextPos.Y() += aTextRect.Top(); |
| DrawText( aTextPos, pItem->maText ); |
| } |
| } |
| |
| // Gegebenenfalls auch DrawItem aufrufen |
| if ( pItem->mnBits & SIB_USERDRAW ) |
| { |
| if ( bOffScreen ) |
| { |
| mbInUserDraw = sal_True; |
| mpImplData->mpVirDev->EnableRTL( IsRTLEnabled() ); |
| UserDrawEvent aODEvt( mpImplData->mpVirDev, Rectangle( Point(), aTextRectSize ), pItem->mnId ); |
| UserDraw( aODEvt ); |
| mpImplData->mpVirDev->EnableRTL( sal_False ); |
| mbInUserDraw = sal_False; |
| } |
| else |
| { |
| UserDrawEvent aODEvt( this, aTextRect, pItem->mnId ); |
| UserDraw( aODEvt ); |
| } |
| } |
| |
| if ( bOffScreen ) |
| DrawOutDev( aTextRect.TopLeft(), aTextRectSize, Point(), aTextRectSize, *mpImplData->mpVirDev ); |
| else |
| SetClipRegion(); |
| |
| // Frame ausgeben |
| if ( bDrawFrame ) |
| { |
| if( mpImplData->mbDrawItemFrames ) |
| { |
| if( !(pItem->mnBits & SIB_FLAT) ) |
| { |
| sal_uInt16 nStyle; |
| |
| if ( pItem->mnBits & SIB_IN ) |
| nStyle = FRAME_DRAW_IN; |
| else |
| nStyle = FRAME_DRAW_OUT; |
| |
| DecorationView aDecoView( this ); |
| aDecoView.DrawFrame( aRect, nStyle ); |
| } |
| } |
| else if( nPos != ImplGetFirstVisiblePos() ) |
| { |
| // draw separator |
| Point aFrom( aRect.TopLeft() ); |
| aFrom.X()--; |
| aFrom.Y()++; |
| Point aTo( aRect.BottomLeft() ); |
| aTo.X()--; |
| aTo.Y()--; |
| |
| DecorationView aDecoView( this ); |
| aDecoView.DrawSeparator( aFrom, aTo ); |
| } |
| } |
| |
| if ( !ImplIsRecordLayout() ) |
| ImplCallEventListeners( VCLEVENT_STATUSBAR_DRAWITEM, (void*) sal_IntPtr(pItem->mnId) ); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void DrawProgress( Window* pWindow, const Point& rPos, |
| long nOffset, long nPrgsWidth, long nPrgsHeight, |
| sal_uInt16 nPercent1, sal_uInt16 nPercent2, sal_uInt16 nPercentCount, |
| const Rectangle& rFramePosSize |
| ) |
| { |
| if( pWindow->IsNativeControlSupported( CTRL_PROGRESS, PART_ENTIRE_CONTROL ) ) |
| { |
| bool bNeedErase = ImplGetSVData()->maNWFData.mbProgressNeedsErase; |
| |
| long nFullWidth = (nPrgsWidth + nOffset) * (10000 / nPercentCount); |
| long nPerc = (nPercent2 > 10000) ? 10000 : nPercent2; |
| ImplControlValue aValue( nFullWidth * (long)nPerc / 10000 ); |
| Rectangle aDrawRect( rPos, Size( nFullWidth, nPrgsHeight ) ); |
| Rectangle aControlRegion( aDrawRect ); |
| if( bNeedErase ) |
| { |
| Window* pEraseWindow = pWindow; |
| while( pEraseWindow->IsPaintTransparent() && |
| ! pEraseWindow->ImplGetWindowImpl()->mbFrame ) |
| { |
| pEraseWindow = pEraseWindow->ImplGetWindowImpl()->mpParent; |
| } |
| if( pEraseWindow == pWindow ) |
| // restore background of pWindow |
| pEraseWindow->Erase( rFramePosSize ); |
| else |
| { |
| // restore transparent background |
| Point aTL( pWindow->OutputToAbsoluteScreenPixel( rFramePosSize.TopLeft() ) ); |
| aTL = pEraseWindow->AbsoluteScreenToOutputPixel( aTL ); |
| Rectangle aRect( aTL, rFramePosSize.GetSize() ); |
| pEraseWindow->Invalidate( aRect, INVALIDATE_NOCHILDREN | |
| INVALIDATE_NOCLIPCHILDREN | |
| INVALIDATE_TRANSPARENT ); |
| pEraseWindow->Update(); |
| } |
| pWindow->Push( PUSH_CLIPREGION ); |
| pWindow->IntersectClipRegion( rFramePosSize ); |
| } |
| sal_Bool bNativeOK = pWindow->DrawNativeControl( CTRL_PROGRESS, PART_ENTIRE_CONTROL, aControlRegion, |
| CTRL_STATE_ENABLED, aValue, rtl::OUString() ); |
| if( bNeedErase ) |
| pWindow->Pop(); |
| if( bNativeOK ) |
| { |
| pWindow->Flush(); |
| return; |
| } |
| } |
| |
| // Werte vorberechnen |
| sal_uInt16 nPerc1 = nPercent1 / nPercentCount; |
| sal_uInt16 nPerc2 = nPercent2 / nPercentCount; |
| |
| if ( nPerc1 > nPerc2 ) |
| { |
| // Support progress that can also decrease |
| |
| // Rechteck berechnen |
| long nDX = nPrgsWidth + nOffset; |
| long nLeft = rPos.X()+((nPerc1-1)*nDX); |
| Rectangle aRect( nLeft, rPos.Y(), nLeft+nPrgsWidth, rPos.Y()+nPrgsHeight ); |
| |
| do |
| { |
| pWindow->Erase( aRect ); |
| aRect.Left() -= nDX; |
| aRect.Right() -= nDX; |
| nPerc1--; |
| } |
| while ( nPerc1 > nPerc2 ); |
| |
| pWindow->Flush(); |
| } |
| else if ( nPerc1 < nPerc2 ) |
| { |
| // Percent-Rechtecke malen |
| // Wenn Percent2 ueber 100%, Werte anpassen |
| if ( nPercent2 > 10000 ) |
| { |
| nPerc2 = 10000 / nPercentCount; |
| if ( nPerc1 >= nPerc2 ) |
| nPerc1 = nPerc2-1; |
| } |
| |
| // Rechteck berechnen |
| long nDX = nPrgsWidth + nOffset; |
| long nLeft = rPos.X()+(nPerc1*nDX); |
| Rectangle aRect( nLeft, rPos.Y(), nLeft+nPrgsWidth, rPos.Y()+nPrgsHeight ); |
| |
| do |
| { |
| pWindow->DrawRect( aRect ); |
| aRect.Left() += nDX; |
| aRect.Right() += nDX; |
| nPerc1++; |
| } |
| while ( nPerc1 < nPerc2 ); |
| |
| // Bei mehr als 100%, lassen wir das Rechteck blinken |
| if ( nPercent2 > 10000 ) |
| { |
| // an/aus-Status festlegen |
| if ( ((nPercent2 / nPercentCount) & 0x01) == (nPercentCount & 0x01) ) |
| { |
| aRect.Left() -= nDX; |
| aRect.Right() -= nDX; |
| pWindow->Erase( aRect ); |
| } |
| } |
| |
| pWindow->Flush(); |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void StatusBar::ImplDrawProgress( sal_Bool bPaint, |
| sal_uInt16 nPercent1, sal_uInt16 nPercent2 ) |
| { |
| bool bNative = IsNativeControlSupported( CTRL_PROGRESS, PART_ENTIRE_CONTROL ); |
| // bPaint: draw text also, else only update progress |
| if ( bPaint ) |
| { |
| DrawText( maPrgsTxtPos, maPrgsTxt ); |
| if( ! bNative ) |
| { |
| DecorationView aDecoView( this ); |
| aDecoView.DrawFrame( maPrgsFrameRect, FRAME_DRAW_IN ); |
| } |
| } |
| |
| Point aPos( maPrgsFrameRect.Left()+STATUSBAR_PRGS_OFFSET, |
| maPrgsFrameRect.Top()+STATUSBAR_PRGS_OFFSET ); |
| long nPrgsHeight = mnPrgsSize; |
| if( bNative ) |
| { |
| aPos = maPrgsFrameRect.TopLeft(); |
| nPrgsHeight = maPrgsFrameRect.GetHeight(); |
| } |
| DrawProgress( this, aPos, mnPrgsSize/2, mnPrgsSize, nPrgsHeight, |
| nPercent1*100, nPercent2*100, mnPercentCount, maPrgsFrameRect ); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void StatusBar::ImplCalcProgressRect() |
| { |
| // calculate text size |
| Size aPrgsTxtSize( GetTextWidth( maPrgsTxt ), GetTextHeight() ); |
| maPrgsTxtPos.X() = STATUSBAR_OFFSET_X+1; |
| |
| // calculate progress frame |
| maPrgsFrameRect.Left() = maPrgsTxtPos.X()+aPrgsTxtSize.Width()+STATUSBAR_OFFSET; |
| maPrgsFrameRect.Top() = mnItemY; |
| maPrgsFrameRect.Bottom() = mnCalcHeight - STATUSBAR_OFFSET_Y; |
| if( IsTopBorder() ) |
| maPrgsFrameRect.Bottom()+=2; |
| |
| // calculate size of progress rects |
| mnPrgsSize = maPrgsFrameRect.Bottom()-maPrgsFrameRect.Top()-(STATUSBAR_PRGS_OFFSET*2); |
| sal_uInt16 nMaxPercent = STATUSBAR_PRGS_COUNT; |
| |
| long nMaxWidth = mnDX-STATUSBAR_OFFSET-1; |
| |
| // make smaller if there are too many rects |
| while ( maPrgsFrameRect.Left()+ImplCalcProgessWidth( nMaxPercent, mnPrgsSize ) > nMaxWidth ) |
| { |
| nMaxPercent--; |
| if ( nMaxPercent <= STATUSBAR_PRGS_MIN ) |
| break; |
| } |
| maPrgsFrameRect.Right() = maPrgsFrameRect.Left() + ImplCalcProgessWidth( nMaxPercent, mnPrgsSize ); |
| |
| // save the divisor for later |
| mnPercentCount = 10000 / nMaxPercent; |
| sal_Bool bNativeOK = sal_False; |
| if( IsNativeControlSupported( CTRL_PROGRESS, PART_ENTIRE_CONTROL ) ) |
| { |
| ImplControlValue aValue; |
| Rectangle aControlRegion( Rectangle( (const Point&)Point(), maPrgsFrameRect.GetSize() ) ); |
| Rectangle aNativeControlRegion, aNativeContentRegion; |
| if( (bNativeOK = GetNativeControlRegion( CTRL_PROGRESS, PART_ENTIRE_CONTROL, aControlRegion, |
| CTRL_STATE_ENABLED, aValue, rtl::OUString(), |
| aNativeControlRegion, aNativeContentRegion ) ) != sal_False ) |
| { |
| long nProgressHeight = aNativeControlRegion.GetHeight(); |
| if( nProgressHeight > maPrgsFrameRect.GetHeight() ) |
| { |
| long nDelta = nProgressHeight - maPrgsFrameRect.GetHeight(); |
| maPrgsFrameRect.Top() -= (nDelta - nDelta/2); |
| maPrgsFrameRect.Bottom() += nDelta/2; |
| } |
| maPrgsTxtPos.Y() = maPrgsFrameRect.Top() + (nProgressHeight - GetTextHeight())/2; |
| } |
| } |
| if( ! bNativeOK ) |
| maPrgsTxtPos.Y() = mnTextY; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void StatusBar::MouseButtonDown( const MouseEvent& rMEvt ) |
| { |
| // Nur bei linker Maustaste ToolBox ausloesen |
| if ( rMEvt.IsLeft() ) |
| { |
| if ( mbVisibleItems ) |
| { |
| Point aMousePos = rMEvt.GetPosPixel(); |
| sal_uInt16 i = 0; |
| |
| // Item suchen, das geklickt wurde |
| ImplStatusItem* pItem = mpItemList->First(); |
| while ( pItem ) |
| { |
| // Ist es dieses Item |
| if ( ImplGetItemRectPos( i ).IsInside( aMousePos ) ) |
| { |
| mnCurItemId = pItem->mnId; |
| if ( rMEvt.GetClicks() == 2 ) |
| DoubleClick(); |
| else |
| Click(); |
| mnCurItemId = 0; |
| |
| // Item wurde gefunden |
| return; |
| } |
| |
| i++; |
| pItem = mpItemList->Next(); |
| } |
| } |
| |
| // Kein Item, dann nur Click oder DoubleClick |
| if ( rMEvt.GetClicks() == 2 ) |
| DoubleClick(); |
| else |
| Click(); |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void StatusBar::Paint( const Rectangle& ) |
| { |
| if ( mbFormat ) |
| ImplFormat(); |
| |
| sal_uInt16 nItemCount = (sal_uInt16)mpItemList->Count(); |
| |
| if ( mbProgressMode ) |
| ImplDrawProgress( sal_True, 0, mnPercent ); |
| else |
| { |
| // Text zeichen |
| if ( !mbVisibleItems || (GetStyle() & WB_RIGHT) ) |
| ImplDrawText( sal_False, 0 ); |
| |
| // Items zeichnen |
| if ( mbVisibleItems ) |
| { |
| // Items zeichnen |
| for ( sal_uInt16 i = 0; i < nItemCount; i++ ) |
| ImplDrawItem( sal_False, i, sal_True, sal_True ); |
| } |
| } |
| |
| // draw borders |
| if( IsTopBorder() ) |
| { |
| const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings(); |
| SetLineColor( rStyleSettings.GetShadowColor() ); |
| DrawLine( Point( 0, 0 ), Point( mnDX-1, 0 ) ); |
| SetLineColor( rStyleSettings.GetLightColor() ); |
| DrawLine( Point( 0, 1 ), Point( mnDX-1, 1 ) ); |
| } |
| |
| if ( IsBottomBorder() ) |
| { |
| const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings(); |
| SetLineColor( rStyleSettings.GetShadowColor() ); |
| DrawLine( Point( 0, mnDY-2 ), Point( mnDX-1, mnDY-2 ) ); |
| SetLineColor( rStyleSettings.GetLightColor() ); |
| DrawLine( Point( 0, mnDY-1 ), Point( mnDX-1, mnDY-1 ) ); |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void StatusBar::Move() |
| { |
| Window::Move(); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void StatusBar::Resize() |
| { |
| // Breite und Hoehe abfragen und merken |
| Size aSize = GetOutputSizePixel(); |
| mnDX = aSize.Width() - ImplGetSVData()->maNWFData.mnStatusBarLowerRightOffset; |
| mnDY = aSize.Height(); |
| mnCalcHeight = mnDY; |
| // subtract border |
| if( IsTopBorder() ) |
| mnCalcHeight -= 2; |
| if ( IsBottomBorder() ) |
| mnCalcHeight -= 2; |
| |
| mnItemY = STATUSBAR_OFFSET_Y; |
| if( IsTopBorder() ) |
| mnItemY += 2; |
| mnTextY = (mnCalcHeight-GetTextHeight())/2; |
| if( IsTopBorder() ) |
| mnTextY += 2; |
| |
| // Formatierung neu ausloesen |
| mbFormat = sal_True; |
| |
| if ( mbProgressMode ) |
| ImplCalcProgressRect(); |
| |
| Invalidate(); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void StatusBar::RequestHelp( const HelpEvent& rHEvt ) |
| { |
| // no keyboard help in status bar |
| if( rHEvt.KeyboardActivated() ) |
| return; |
| |
| sal_uInt16 nItemId = GetItemId( ScreenToOutputPixel( rHEvt.GetMousePosPixel() ) ); |
| |
| if ( nItemId ) |
| { |
| Rectangle aItemRect = GetItemRect( nItemId ); |
| Point aPt = OutputToScreenPixel( aItemRect.TopLeft() ); |
| aItemRect.Left() = aPt.X(); |
| aItemRect.Top() = aPt.Y(); |
| aPt = OutputToScreenPixel( aItemRect.BottomRight() ); |
| aItemRect.Right() = aPt.X(); |
| aItemRect.Bottom() = aPt.Y(); |
| |
| if ( rHEvt.GetMode() & HELPMODE_BALLOON ) |
| { |
| XubString aStr = GetHelpText( nItemId ); |
| Help::ShowBalloon( this, aItemRect.Center(), aItemRect, aStr ); |
| return; |
| } |
| else if ( rHEvt.GetMode() & HELPMODE_QUICK ) |
| { |
| XubString aStr = GetQuickHelpText( nItemId ); |
| // Show quickhelp if available |
| if( aStr.Len() ) |
| { |
| Help::ShowQuickHelp( this, aItemRect, aStr ); |
| return; |
| } |
| aStr = GetItemText( nItemId ); |
| // show a quick help if item text doesn't fit |
| if ( GetTextWidth( aStr ) > aItemRect.GetWidth() ) |
| { |
| Help::ShowQuickHelp( this, aItemRect, aStr ); |
| return; |
| } |
| } |
| else if ( rHEvt.GetMode() & HELPMODE_EXTENDED ) |
| { |
| String aCommand = GetItemCommand( nItemId ); |
| rtl::OString aHelpId( GetHelpId( nItemId ) ); |
| |
| if ( aCommand.Len() || aHelpId.getLength() ) |
| { |
| // Wenn eine Hilfe existiert, dann ausloesen |
| Help* pHelp = Application::GetHelp(); |
| if ( pHelp ) |
| { |
| if ( aCommand.Len() ) |
| pHelp->Start( aCommand, this ); |
| else if ( aHelpId.getLength() ) |
| pHelp->Start( rtl::OStringToOUString( aHelpId, RTL_TEXTENCODING_UTF8 ), this ); |
| } |
| return; |
| } |
| } |
| } |
| |
| Window::RequestHelp( rHEvt ); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void StatusBar::StateChanged( StateChangedType nType ) |
| { |
| Window::StateChanged( nType ); |
| |
| if ( nType == STATE_CHANGE_INITSHOW ) |
| ImplFormat(); |
| else if ( nType == STATE_CHANGE_UPDATEMODE ) |
| Invalidate(); |
| else if ( (nType == STATE_CHANGE_ZOOM) || |
| (nType == STATE_CHANGE_CONTROLFONT) ) |
| { |
| mbFormat = sal_True; |
| ImplInitSettings( sal_True, sal_False, sal_False ); |
| Invalidate(); |
| } |
| else if ( nType == STATE_CHANGE_CONTROLFOREGROUND ) |
| { |
| ImplInitSettings( sal_False, sal_True, sal_False ); |
| Invalidate(); |
| } |
| else if ( nType == STATE_CHANGE_CONTROLBACKGROUND ) |
| { |
| ImplInitSettings( sal_False, sal_False, sal_True ); |
| Invalidate(); |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void StatusBar::DataChanged( const DataChangedEvent& rDCEvt ) |
| { |
| Window::DataChanged( rDCEvt ); |
| |
| if ( (rDCEvt.GetType() == DATACHANGED_DISPLAY) || |
| (rDCEvt.GetType() == DATACHANGED_FONTS) || |
| (rDCEvt.GetType() == DATACHANGED_FONTSUBSTITUTION) || |
| ((rDCEvt.GetType() == DATACHANGED_SETTINGS) && |
| (rDCEvt.GetFlags() & SETTINGS_STYLE)) ) |
| { |
| mbFormat = sal_True; |
| ImplInitSettings( sal_True, sal_True, sal_True ); |
| ImplStatusItem* pItem = mpItemList->First(); |
| long nFudge = GetTextHeight() / 4; |
| while ( pItem ) |
| { |
| long nWidth = GetTextWidth( pItem->maText ) + nFudge; |
| if( nWidth > pItem->mnWidth + STATUSBAR_OFFSET ) |
| pItem->mnWidth = nWidth + STATUSBAR_OFFSET; |
| pItem = mpItemList->Next(); |
| } |
| Size aSize = GetSizePixel(); |
| // do not disturb current width, since |
| // CalcWindowSizePixel calculates a minimum width |
| aSize.Height() = CalcWindowSizePixel().Height(); |
| SetSizePixel( aSize ); |
| Invalidate(); |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void StatusBar::Click() |
| { |
| ImplCallEventListeners( VCLEVENT_STATUSBAR_CLICK ); |
| maClickHdl.Call( this ); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void StatusBar::DoubleClick() |
| { |
| ImplCallEventListeners( VCLEVENT_STATUSBAR_DOUBLECLICK ); |
| maDoubleClickHdl.Call( this ); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void StatusBar::UserDraw( const UserDrawEvent& ) |
| { |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void StatusBar::InsertItem( sal_uInt16 nItemId, sal_uLong nWidth, |
| StatusBarItemBits nBits, |
| long nOffset, sal_uInt16 nPos ) |
| { |
| DBG_ASSERT( nItemId, "StatusBar::InsertItem(): ItemId == 0" ); |
| DBG_ASSERT( GetItemPos( nItemId ) == STATUSBAR_ITEM_NOTFOUND, |
| "StatusBar::InsertItem(): ItemId already exists" ); |
| |
| // IN und CENTER sind Default |
| if ( !(nBits & (SIB_IN | SIB_OUT | SIB_FLAT)) ) |
| nBits |= SIB_IN; |
| if ( !(nBits & (SIB_LEFT | SIB_RIGHT | SIB_CENTER)) ) |
| nBits |= SIB_CENTER; |
| |
| // Item anlegen |
| long nFudge = GetTextHeight()/4; |
| ImplStatusItem* pItem = new ImplStatusItem; |
| pItem->mnId = nItemId; |
| pItem->mnBits = nBits; |
| pItem->mnWidth = (long)nWidth+nFudge+STATUSBAR_OFFSET; |
| pItem->mnOffset = nOffset; |
| pItem->mpUserData = 0; |
| pItem->mbVisible = sal_True; |
| |
| // Item in die Liste einfuegen |
| mpItemList->Insert( pItem, nPos ); |
| |
| mbFormat = sal_True; |
| if ( ImplIsItemUpdate() ) |
| Invalidate(); |
| |
| ImplCallEventListeners( VCLEVENT_STATUSBAR_ITEMADDED, (void*) sal_IntPtr(nItemId) ); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void StatusBar::RemoveItem( sal_uInt16 nItemId ) |
| { |
| sal_uInt16 nPos = GetItemPos( nItemId ); |
| if ( nPos != STATUSBAR_ITEM_NOTFOUND ) |
| { |
| ImplStatusItem* pItem = mpItemList->Remove( nPos ); |
| delete pItem; |
| |
| mbFormat = sal_True; |
| if ( ImplIsItemUpdate() ) |
| Invalidate(); |
| |
| ImplCallEventListeners( VCLEVENT_STATUSBAR_ITEMREMOVED, (void*) sal_IntPtr(nItemId) ); |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void StatusBar::ShowItem( sal_uInt16 nItemId ) |
| { |
| sal_uInt16 nPos = GetItemPos( nItemId ); |
| |
| if ( nPos != STATUSBAR_ITEM_NOTFOUND ) |
| { |
| ImplStatusItem* pItem = mpItemList->GetObject( nPos ); |
| if ( !pItem->mbVisible ) |
| { |
| pItem->mbVisible = sal_True; |
| |
| mbFormat = sal_True; |
| if ( ImplIsItemUpdate() ) |
| Invalidate(); |
| |
| ImplCallEventListeners( VCLEVENT_STATUSBAR_SHOWITEM, (void*) sal_IntPtr(nItemId) ); |
| } |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void StatusBar::HideItem( sal_uInt16 nItemId ) |
| { |
| sal_uInt16 nPos = GetItemPos( nItemId ); |
| |
| if ( nPos != STATUSBAR_ITEM_NOTFOUND ) |
| { |
| ImplStatusItem* pItem = mpItemList->GetObject( nPos ); |
| if ( pItem->mbVisible ) |
| { |
| pItem->mbVisible = sal_False; |
| |
| mbFormat = sal_True; |
| if ( ImplIsItemUpdate() ) |
| Invalidate(); |
| |
| ImplCallEventListeners( VCLEVENT_STATUSBAR_HIDEITEM, (void*) sal_IntPtr(nItemId) ); |
| } |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| sal_Bool StatusBar::IsItemVisible( sal_uInt16 nItemId ) const |
| { |
| sal_uInt16 nPos = GetItemPos( nItemId ); |
| |
| if ( nPos != STATUSBAR_ITEM_NOTFOUND ) |
| return mpItemList->GetObject( nPos )->mbVisible; |
| else |
| return sal_False; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void StatusBar::ShowItems() |
| { |
| if ( !mbVisibleItems ) |
| { |
| mbVisibleItems = sal_True; |
| if ( !mbProgressMode ) |
| Invalidate(); |
| |
| ImplCallEventListeners( VCLEVENT_STATUSBAR_SHOWALLITEMS ); |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void StatusBar::HideItems() |
| { |
| if ( mbVisibleItems ) |
| { |
| mbVisibleItems = sal_False; |
| if ( !mbProgressMode ) |
| Invalidate(); |
| |
| ImplCallEventListeners( VCLEVENT_STATUSBAR_HIDEALLITEMS ); |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void StatusBar::CopyItems( const StatusBar& rStatusBar ) |
| { |
| // Alle Items entfernen |
| ImplStatusItem* pItem = mpItemList->First(); |
| while ( pItem ) |
| { |
| delete pItem; |
| pItem = mpItemList->Next(); |
| } |
| |
| // Items aus der Liste loeschen |
| mpItemList->Clear(); |
| |
| // Items kopieren |
| sal_uLong i = 0; |
| pItem = rStatusBar.mpItemList->GetObject( i ); |
| while ( pItem ) |
| { |
| mpItemList->Insert( new ImplStatusItem( *pItem ), LIST_APPEND ); |
| i++; |
| pItem = rStatusBar.mpItemList->GetObject( i ); |
| } |
| |
| mbFormat = sal_True; |
| if ( ImplIsItemUpdate() ) |
| Invalidate(); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void StatusBar::Clear() |
| { |
| // Alle Item loeschen |
| ImplStatusItem* pItem = mpItemList->First(); |
| while ( pItem ) |
| { |
| delete pItem; |
| pItem = mpItemList->Next(); |
| } |
| |
| // Items aus der Liste loeschen |
| mpItemList->Clear(); |
| |
| mbFormat = sal_True; |
| if ( ImplIsItemUpdate() ) |
| Invalidate(); |
| |
| ImplCallEventListeners( VCLEVENT_STATUSBAR_ALLITEMSREMOVED ); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| sal_uInt16 StatusBar::GetItemCount() const |
| { |
| return (sal_uInt16)mpItemList->Count(); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| sal_uInt16 StatusBar::GetItemId( sal_uInt16 nPos ) const |
| { |
| ImplStatusItem* pItem = mpItemList->GetObject( nPos ); |
| if ( pItem ) |
| return pItem->mnId; |
| else |
| return 0; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| sal_uInt16 StatusBar::GetItemPos( sal_uInt16 nItemId ) const |
| { |
| ImplStatusItem* pItem = mpItemList->First(); |
| while ( pItem ) |
| { |
| if ( pItem->mnId == nItemId ) |
| return (sal_uInt16)mpItemList->GetCurPos(); |
| |
| pItem = mpItemList->Next(); |
| } |
| |
| return STATUSBAR_ITEM_NOTFOUND; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| sal_uInt16 StatusBar::GetItemId( const Point& rPos ) const |
| { |
| if ( AreItemsVisible() && !mbFormat ) |
| { |
| sal_uInt16 nItemCount = GetItemCount(); |
| sal_uInt16 nPos; |
| for ( nPos = 0; nPos < nItemCount; nPos++ ) |
| { |
| // Rechteck holen |
| Rectangle aRect = ImplGetItemRectPos( nPos ); |
| if ( aRect.IsInside( rPos ) ) |
| return mpItemList->GetObject( nPos )->mnId; |
| } |
| } |
| |
| return 0; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| Rectangle StatusBar::GetItemRect( sal_uInt16 nItemId ) const |
| { |
| Rectangle aRect; |
| |
| if ( AreItemsVisible() && !mbFormat ) |
| { |
| sal_uInt16 nPos = GetItemPos( nItemId ); |
| if ( nPos != STATUSBAR_ITEM_NOTFOUND ) |
| { |
| // Rechteck holen und Rahmen abziehen |
| aRect = ImplGetItemRectPos( nPos ); |
| long nW = mpImplData->mnItemBorderWidth+1; |
| aRect.Top() += nW-1; |
| aRect.Bottom() -= nW-1; |
| aRect.Left() += nW; |
| aRect.Right() -= nW; |
| return aRect; |
| } |
| } |
| |
| return aRect; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| Point StatusBar::GetItemTextPos( sal_uInt16 nItemId ) const |
| { |
| if ( !mbFormat ) |
| { |
| sal_uInt16 nPos = GetItemPos( nItemId ); |
| if ( nPos != STATUSBAR_ITEM_NOTFOUND ) |
| { |
| // Rechteck holen |
| ImplStatusItem* pItem = mpItemList->GetObject( nPos ); |
| Rectangle aRect = ImplGetItemRectPos( nPos ); |
| long nW = mpImplData->mnItemBorderWidth + 1; |
| Rectangle aTextRect( aRect.Left()+nW, aRect.Top()+nW, |
| aRect.Right()-nW, aRect.Bottom()-nW ); |
| Point aPos = ImplGetItemTextPos( aTextRect.GetSize(), |
| Size( GetTextWidth( pItem->maText ), GetTextHeight() ), |
| pItem->mnBits ); |
| if ( !mbInUserDraw ) |
| { |
| aPos.X() += aTextRect.Left(); |
| aPos.Y() += aTextRect.Top(); |
| } |
| return aPos; |
| } |
| } |
| |
| return Point(); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| sal_uLong StatusBar::GetItemWidth( sal_uInt16 nItemId ) const |
| { |
| sal_uInt16 nPos = GetItemPos( nItemId ); |
| |
| if ( nPos != STATUSBAR_ITEM_NOTFOUND ) |
| return mpItemList->GetObject( nPos )->mnWidth; |
| else |
| return 0; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| StatusBarItemBits StatusBar::GetItemBits( sal_uInt16 nItemId ) const |
| { |
| sal_uInt16 nPos = GetItemPos( nItemId ); |
| |
| if ( nPos != STATUSBAR_ITEM_NOTFOUND ) |
| return mpItemList->GetObject( nPos )->mnBits; |
| else |
| return 0; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| long StatusBar::GetItemOffset( sal_uInt16 nItemId ) const |
| { |
| sal_uInt16 nPos = GetItemPos( nItemId ); |
| |
| if ( nPos != STATUSBAR_ITEM_NOTFOUND ) |
| return mpItemList->GetObject( nPos )->mnOffset; |
| else |
| return 0; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void StatusBar::SetItemText( sal_uInt16 nItemId, const XubString& rText ) |
| { |
| sal_uInt16 nPos = GetItemPos( nItemId ); |
| |
| if ( nPos != STATUSBAR_ITEM_NOTFOUND ) |
| { |
| ImplStatusItem* pItem = mpItemList->GetObject( nPos ); |
| |
| if ( pItem->maText != rText ) |
| { |
| pItem->maText = rText; |
| |
| // adjust item width - see also DataChanged() |
| long nFudge = GetTextHeight()/4; |
| long nWidth = GetTextWidth( pItem->maText ) + nFudge; |
| if( (nWidth > pItem->mnWidth + STATUSBAR_OFFSET) || |
| ((nWidth < pItem->mnWidth) && (mnDX - STATUSBAR_OFFSET) < mnItemsWidth )) |
| { |
| pItem->mnWidth = nWidth + STATUSBAR_OFFSET; |
| ImplFormat(); |
| Invalidate(); |
| } |
| |
| // Item neu Zeichen, wenn StatusBar sichtbar und |
| // UpdateMode gesetzt ist |
| if ( pItem->mbVisible && !mbFormat && ImplIsItemUpdate() ) |
| { |
| Update(); |
| ImplDrawItem( sal_True, nPos, sal_True, sal_False ); |
| Flush(); |
| } |
| } |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| const XubString& StatusBar::GetItemText( sal_uInt16 nItemId ) const |
| { |
| sal_uInt16 nPos = GetItemPos( nItemId ); |
| |
| if ( nPos != STATUSBAR_ITEM_NOTFOUND ) |
| return mpItemList->GetObject( nPos )->maText; |
| else |
| return ImplGetSVEmptyStr(); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void StatusBar::SetItemCommand( sal_uInt16 nItemId, const XubString& rCommand ) |
| { |
| sal_uInt16 nPos = GetItemPos( nItemId ); |
| |
| if ( nPos != STATUSBAR_ITEM_NOTFOUND ) |
| { |
| ImplStatusItem* pItem = mpItemList->GetObject( nPos ); |
| |
| if ( pItem->maCommand != rCommand ) |
| pItem->maCommand = rCommand; |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| const XubString& StatusBar::GetItemCommand( sal_uInt16 nItemId ) |
| { |
| sal_uInt16 nPos = GetItemPos( nItemId ); |
| |
| if ( nPos != STATUSBAR_ITEM_NOTFOUND ) |
| return mpItemList->GetObject( nPos )->maCommand; |
| else |
| return ImplGetSVEmptyStr(); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void StatusBar::SetItemData( sal_uInt16 nItemId, void* pNewData ) |
| { |
| sal_uInt16 nPos = GetItemPos( nItemId ); |
| |
| if ( nPos != STATUSBAR_ITEM_NOTFOUND ) |
| { |
| ImplStatusItem* pItem = mpItemList->GetObject( nPos ); |
| pItem->mpUserData = pNewData; |
| |
| // Wenn es ein User-Item ist, DrawItem-Aufrufen |
| if ( (pItem->mnBits & SIB_USERDRAW) && pItem->mbVisible && |
| !mbFormat && ImplIsItemUpdate() ) |
| { |
| Update(); |
| ImplDrawItem( sal_True, nPos, sal_False, sal_False ); |
| Flush(); |
| } |
| } |
| } |
| |
| void StatusBar::RedrawItem( sal_uInt16 nItemId ) |
| { |
| if ( mbFormat ) |
| return; |
| |
| sal_uInt16 nPos = GetItemPos( nItemId ); |
| if ( nPos == STATUSBAR_ITEM_NOTFOUND ) |
| return; |
| |
| ImplStatusItem* pItem = mpItemList->GetObject( nPos ); |
| if ( pItem && (pItem->mnBits & SIB_USERDRAW) && |
| pItem->mbVisible && ImplIsItemUpdate() ) |
| { |
| Update(); |
| ImplDrawItem( sal_True, nPos, sal_False, sal_False ); |
| Flush(); |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void* StatusBar::GetItemData( sal_uInt16 nItemId ) const |
| { |
| sal_uInt16 nPos = GetItemPos( nItemId ); |
| |
| if ( nPos != STATUSBAR_ITEM_NOTFOUND ) |
| return mpItemList->GetObject( nPos )->mpUserData; |
| else |
| return NULL; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void StatusBar::SetHelpText( sal_uInt16 nItemId, const XubString& rText ) |
| { |
| sal_uInt16 nPos = GetItemPos( nItemId ); |
| |
| if ( nPos != STATUSBAR_ITEM_NOTFOUND ) |
| mpItemList->GetObject( nPos )->maHelpText = rText; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| const XubString& StatusBar::GetHelpText( sal_uInt16 nItemId ) const |
| { |
| sal_uInt16 nPos = GetItemPos( nItemId ); |
| |
| if ( nPos != STATUSBAR_ITEM_NOTFOUND ) |
| { |
| ImplStatusItem* pItem = mpItemList->GetObject( nPos ); |
| if ( !pItem->maHelpText.Len() && ( pItem->maHelpId.getLength() || pItem->maCommand.Len() )) |
| { |
| Help* pHelp = Application::GetHelp(); |
| if ( pHelp ) |
| { |
| if ( pItem->maCommand.Len() ) |
| pItem->maHelpText = pHelp->GetHelpText( pItem->maCommand, this ); |
| if ( !pItem->maHelpText.Len() && pItem->maHelpId.getLength() ) |
| pItem->maHelpText = pHelp->GetHelpText( rtl::OStringToOUString( pItem->maHelpId, RTL_TEXTENCODING_UTF8 ), this ); |
| } |
| } |
| |
| return pItem->maHelpText; |
| } |
| else |
| return ImplGetSVEmptyStr(); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void StatusBar::SetQuickHelpText( sal_uInt16 nItemId, const XubString& rText ) |
| { |
| sal_uInt16 nPos = GetItemPos( nItemId ); |
| |
| if ( nPos != STATUSBAR_ITEM_NOTFOUND ) |
| mpItemList->GetObject( nPos )->maQuickHelpText = rText; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| const XubString& StatusBar::GetQuickHelpText( sal_uInt16 nItemId ) const |
| { |
| sal_uInt16 nPos = GetItemPos( nItemId ); |
| |
| if ( nPos != STATUSBAR_ITEM_NOTFOUND ) |
| { |
| ImplStatusItem* pItem = mpItemList->GetObject( nPos ); |
| return pItem->maQuickHelpText; |
| } |
| else |
| return ImplGetSVEmptyStr(); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void StatusBar::SetHelpId( sal_uInt16 nItemId, const rtl::OString& rHelpId ) |
| { |
| sal_uInt16 nPos = GetItemPos( nItemId ); |
| |
| if ( nPos != STATUSBAR_ITEM_NOTFOUND ) |
| mpItemList->GetObject( nPos )->maHelpId = rHelpId; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| rtl::OString StatusBar::GetHelpId( sal_uInt16 nItemId ) const |
| { |
| sal_uInt16 nPos = GetItemPos( nItemId ); |
| |
| rtl::OString aRet; |
| if ( nPos != STATUSBAR_ITEM_NOTFOUND ) |
| { |
| ImplStatusItem* pItem = mpItemList->GetObject( nPos ); |
| if ( pItem->maHelpId.getLength() ) |
| aRet = pItem->maHelpId; |
| else |
| aRet = ::rtl::OUStringToOString( pItem->maCommand, RTL_TEXTENCODING_UTF8 ); |
| } |
| |
| return aRet; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void StatusBar::ImplCalcBorder( ) |
| { |
| mnCalcHeight = mnDY; |
| // subtract border |
| if( IsTopBorder() ) |
| { |
| mnCalcHeight -= 2; |
| mnTextY += 2; |
| mnItemY += 2; |
| } |
| if ( IsBottomBorder() ) |
| mnCalcHeight -= 2; |
| mbFormat = sal_True; |
| Invalidate(); |
| } |
| |
| void StatusBar::SetBottomBorder( sal_Bool bBottomBorder ) |
| { |
| if ( mbBottomBorder != bBottomBorder ) |
| { |
| mbBottomBorder = bBottomBorder; |
| ImplCalcBorder(); |
| } |
| } |
| |
| void StatusBar::SetTopBorder( sal_Bool bTopBorder ) |
| { |
| if ( mpImplData->mbTopBorder != static_cast<bool>(bTopBorder) ) |
| { |
| mpImplData->mbTopBorder = static_cast<bool>(bTopBorder); |
| ImplCalcBorder(); |
| } |
| } |
| |
| sal_Bool StatusBar::IsTopBorder() const |
| { |
| return mpImplData->mbTopBorder; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void StatusBar::StartProgressMode( const XubString& rText ) |
| { |
| DBG_ASSERT( !mbProgressMode, "StatusBar::StartProgressMode(): progress mode is active" ); |
| |
| mbProgressMode = sal_True; |
| mnPercent = 0; |
| maPrgsTxt = rText; |
| |
| // Groessen berechnen |
| ImplCalcProgressRect(); |
| |
| // Paint ausloesen (dort wird der Text und der Frame gemalt) |
| const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings(); |
| Color aPrgsColor = rStyleSettings.GetHighlightColor(); |
| if ( aPrgsColor == rStyleSettings.GetFaceColor() ) |
| aPrgsColor = rStyleSettings.GetDarkShadowColor(); |
| SetLineColor(); |
| SetFillColor( aPrgsColor ); |
| if ( IsReallyVisible() ) |
| { |
| Invalidate(); |
| Update(); |
| Flush(); |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void StatusBar::SetProgressValue( sal_uInt16 nNewPercent ) |
| { |
| DBG_ASSERT( mbProgressMode, "StatusBar::SetProgressValue(): no progrss mode" ); |
| DBG_ASSERTWARNING( nNewPercent <= 100, "StatusBar::SetProgressValue(): nPercent > 100" ); |
| |
| if ( mbProgressMode |
| && IsReallyVisible() |
| && (!mnPercent || (mnPercent != nNewPercent)) ) |
| { |
| Update(); |
| SetLineColor(); |
| ImplDrawProgress( sal_False, mnPercent, nNewPercent ); |
| Flush(); |
| } |
| mnPercent = nNewPercent; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void StatusBar::EndProgressMode() |
| { |
| DBG_ASSERT( mbProgressMode, "StatusBar::EndProgressMode(): no progress mode" ); |
| |
| mbProgressMode = sal_False; |
| maPrgsTxt.Erase(); |
| |
| // Paint neu ausloesen um StatusBar wieder herzustellen |
| SetFillColor( GetSettings().GetStyleSettings().GetFaceColor() ); |
| if ( IsReallyVisible() ) |
| { |
| Invalidate(); |
| Update(); |
| Flush(); |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void StatusBar::ResetProgressMode() |
| { |
| if ( mbProgressMode ) |
| { |
| mnPercent = 0; |
| maPrgsTxt.Erase(); |
| if ( IsReallyVisible() ) |
| { |
| Invalidate(); |
| Update(); |
| Flush(); |
| } |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void StatusBar::SetText( const XubString& rText ) |
| { |
| if ( (!mbVisibleItems || (GetStyle() & WB_RIGHT)) && !mbProgressMode && |
| IsReallyVisible() && IsUpdateMode() ) |
| { |
| if ( mbFormat ) |
| { |
| Invalidate(); |
| Window::SetText( rText ); |
| } |
| else |
| { |
| Update(); |
| long nOldTextWidth = GetTextWidth( GetText() ); |
| Window::SetText( rText ); |
| ImplDrawText( sal_True, nOldTextWidth ); |
| Flush(); |
| } |
| } |
| else if ( mbProgressMode ) |
| { |
| maPrgsTxt = rText; |
| if ( IsReallyVisible() ) |
| { |
| Invalidate(); |
| Update(); |
| Flush(); |
| } |
| } |
| else |
| Window::SetText( rText ); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| Size StatusBar::CalcWindowSizePixel() const |
| { |
| sal_uLong i = 0; |
| sal_uLong nCount = mpItemList->Count(); |
| long nOffset = 0; |
| long nCalcWidth = (STATUSBAR_OFFSET_X*2); |
| long nCalcHeight; |
| |
| while ( i < nCount ) |
| { |
| ImplStatusItem* pItem = mpItemList->GetObject( i ); |
| nCalcWidth += pItem->mnWidth + nOffset; |
| nOffset = pItem->mnOffset; |
| i++; |
| } |
| |
| long nMinHeight = GetTextHeight(); |
| const long nBarTextOffset = STATUSBAR_OFFSET_TEXTY*2; |
| long nProgressHeight = nMinHeight + nBarTextOffset; |
| // FIXME: IsNativeControlSupported and GetNativeControlRegion should be const ? |
| StatusBar* pThis = const_cast<StatusBar*>( this ); |
| if( pThis->IsNativeControlSupported( CTRL_PROGRESS, PART_ENTIRE_CONTROL ) ) |
| { |
| ImplControlValue aValue; |
| Rectangle aControlRegion( (const Point&)Point(), Size( nCalcWidth, nMinHeight ) ); |
| Rectangle aNativeControlRegion, aNativeContentRegion; |
| if( pThis->GetNativeControlRegion( CTRL_PROGRESS, PART_ENTIRE_CONTROL, aControlRegion, |
| CTRL_STATE_ENABLED, aValue, rtl::OUString(), |
| aNativeControlRegion, aNativeContentRegion ) ) |
| { |
| nProgressHeight = aNativeControlRegion.GetHeight(); |
| } |
| } |
| |
| if( mpImplData->mbDrawItemFrames && |
| pThis->IsNativeControlSupported( CTRL_FRAME, PART_BORDER ) ) |
| { |
| ImplControlValue aControlValue( FRAME_DRAW_NODRAW ); |
| Rectangle aBound, aContent; |
| Rectangle aNatRgn( Point( 0, 0 ), Size( 150, 50 ) ); |
| if( pThis->GetNativeControlRegion(CTRL_FRAME, PART_BORDER, |
| aNatRgn, 0, aControlValue, rtl::OUString(), aBound, aContent) ) |
| { |
| mpImplData->mnItemBorderWidth = |
| ( aBound.GetHeight() - aContent.GetHeight() ) / 2; |
| } |
| } |
| |
| nCalcHeight = nMinHeight+nBarTextOffset + 2*mpImplData->mnItemBorderWidth; |
| if( nCalcHeight < nProgressHeight+2 ) |
| nCalcHeight = nProgressHeight+2; |
| |
| // add border |
| if( IsTopBorder() ) |
| nCalcHeight += 2; |
| if ( IsBottomBorder() ) |
| nCalcHeight += 2; |
| |
| return Size( nCalcWidth, nCalcHeight ); |
| } |
| |
| |
| // ----------------------------------------------------------------------- |
| |
| void StatusBar::SetAccessibleName( sal_uInt16 nItemId, const XubString& rName ) |
| { |
| sal_uInt16 nPos = GetItemPos( nItemId ); |
| |
| if ( nPos != STATUSBAR_ITEM_NOTFOUND ) |
| { |
| ImplStatusItem* pItem = mpItemList->GetObject( nPos ); |
| |
| if ( pItem->maAccessibleName != rName ) |
| { |
| pItem->maAccessibleName = rName; |
| ImplCallEventListeners( VCLEVENT_STATUSBAR_NAMECHANGED, (void*) sal_IntPtr(pItem->mnId) ); |
| } |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| const XubString& StatusBar::GetAccessibleName( sal_uInt16 nItemId ) const |
| { |
| sal_uInt16 nPos = GetItemPos( nItemId ); |
| |
| if ( nPos != STATUSBAR_ITEM_NOTFOUND ) |
| return mpItemList->GetObject( nPos )->maAccessibleName; |
| else |
| return ImplGetSVEmptyStr(); |
| } |
| |
| // ----------------------------------------------------------------------- |