/**************************************************************
*
* 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.
*
*************************************************************/
#include "precompiled_sc.hxx"
#ifndef _SC_ZOOMSLIDERTBCONTRL_HXX
#include "tbzoomsliderctrl.hxx"
#endif
#ifndef _SV_IMAGE_HXX
#include <vcl/image.hxx>
#endif
#ifndef _SV_TOOLBOX_HXX
#include <vcl/toolbox.hxx>
#endif
#ifndef _SV_SVAPP_HXX
#include <vcl/svapp.hxx>
#endif
#ifndef _SV_GRADIENT_HXX
#include <vcl/gradient.hxx>
#endif
#include <svl/itemset.hxx>
#include <sfx2/viewfrm.hxx>
#include <sfx2/objsh.hxx>
#include <svx/zoomslideritem.hxx>
#include <svx/dialmgr.hxx>
#include <svx/dialogs.hrc>
#include <set>
#include "docsh.hxx"
#include "stlpool.hxx"
#include "scitems.hxx"
#include "printfun.hxx"
//========================================================================
// class ScZoomSliderControl ---------------------------------------
//========================================================================
// -----------------------------------------------------------------------
SFX_IMPL_TOOLBOX_CONTROL( ScZoomSliderControl, SvxZoomSliderItem );
// -----------------------------------------------------------------------
ScZoomSliderControl::ScZoomSliderControl(
sal_uInt16 nSlotId,
sal_uInt16 nId,
ToolBox& rTbx )
:SfxToolBoxControl( nSlotId, nId, rTbx )
{
rTbx.Invalidate();
}
// -----------------------------------------------------------------------
__EXPORT ScZoomSliderControl::~ScZoomSliderControl()
{
}
// -----------------------------------------------------------------------
void ScZoomSliderControl::StateChanged( sal_uInt16 /*nSID*/, SfxItemState eState,
const SfxPoolItem* pState )
{
sal_uInt16 nId = GetId();
ToolBox& rTbx = GetToolBox();
ScZoomSliderWnd* pBox = (ScZoomSliderWnd*)(rTbx.GetItemWindow( nId ));
DBG_ASSERT( pBox ,"Control not found!" );
if ( SFX_ITEM_AVAILABLE != eState || pState->ISA( SfxVoidItem ) )
{
SvxZoomSliderItem aZoomSliderItem( 100 );
pBox->Disable();
pBox->UpdateFromItem( &aZoomSliderItem );
}
else
{
pBox->Enable();
DBG_ASSERT( pState->ISA( SvxZoomSliderItem ), "invalid item type" );
const SvxZoomSliderItem* pZoomSliderItem = dynamic_cast< const SvxZoomSliderItem* >( pState );
DBG_ASSERT( pZoomSliderItem, "Sc::ScZoomSliderControl::StateChanged(), wrong item type!" );
if( pZoomSliderItem )
pBox->UpdateFromItem( pZoomSliderItem );
}
}
// -----------------------------------------------------------------------
Window* ScZoomSliderControl::CreateItemWindow( Window *pParent )
{
// #i98000# Don't try to get a value via SfxViewFrame::Current here.
// The view's value is always notified via StateChanged later.
ScZoomSliderWnd* pSlider = new ScZoomSliderWnd( pParent,
::com::sun::star::uno::Reference< ::com::sun::star::frame::XDispatchProvider >( m_xFrame->getController(),
::com::sun::star::uno::UNO_QUERY ), m_xFrame, 100 );
return pSlider;
}
// -----------------------------------------------------------------------
struct ScZoomSliderWnd::ScZoomSliderWnd_Impl
{
sal_uInt16 mnCurrentZoom;
sal_uInt16 mnMinZoom;
sal_uInt16 mnMaxZoom;
sal_uInt16 mnSliderCenter;
std::vector< long > maSnappingPointOffsets;
std::vector< sal_uInt16 > maSnappingPointZooms;
Image maSliderButton;
Image maIncreaseButton;
Image maDecreaseButton;
bool mbValuesSet;
bool mbOmitPaint;
ScZoomSliderWnd_Impl( sal_uInt16 nCurrentZoom ) :
mnCurrentZoom( nCurrentZoom ),
mnMinZoom( 10 ),
mnMaxZoom( 400 ),
mnSliderCenter( 100 ),
maSnappingPointOffsets(),
maSnappingPointZooms(),
maSliderButton(),
maIncreaseButton(),
maDecreaseButton(),
mbValuesSet( true ),
mbOmitPaint( false )
{
}
};
// -----------------------------------------------------------------------
const long nButtonWidth = 10;
const long nButtonHeight = 10;
const long nIncDecWidth = 11;
const long nIncDecHeight = 11;
const long nSliderHeight = 2; //
const long nSliderWidth = 4; //
const long nSnappingHeight = 4;
const long nSliderXOffset = 20;
const long nSnappingEpsilon = 5; // snapping epsilon in pixels
const long nSnappingPointsMinDist = nSnappingEpsilon; // minimum distance of two adjacent snapping points
// -----------------------------------------------------------------------
sal_uInt16 ScZoomSliderWnd::Offset2Zoom( long nOffset ) const
{
Size aSliderWindowSize = GetOutputSizePixel();
const long nControlWidth = aSliderWindowSize.Width();
sal_uInt16 nRet = 0;
if( nOffset < nSliderXOffset )
return mpImpl->mnMinZoom;
if( nOffset > nControlWidth - nSliderXOffset )
return mpImpl->mnMaxZoom;
// check for snapping points:
sal_uInt16 nCount = 0;
std::vector< long >::iterator aSnappingPointIter;
for ( aSnappingPointIter = mpImpl->maSnappingPointOffsets.begin();
aSnappingPointIter != mpImpl->maSnappingPointOffsets.end();
++aSnappingPointIter )
{
const long nCurrent = *aSnappingPointIter;
if ( Abs(nCurrent - nOffset) < nSnappingEpsilon )
{
nOffset = nCurrent;
nRet = mpImpl->maSnappingPointZooms[ nCount ];
break;
}
++nCount;
}
if( 0 == nRet )
{
if( nOffset < nControlWidth / 2 )
{
// first half of slider
const long nFirstHalfRange = mpImpl->mnSliderCenter - mpImpl->mnMinZoom;
const long nHalfSliderWidth = nControlWidth/2 - nSliderXOffset;
const long nZoomPerSliderPixel = (1000 * nFirstHalfRange) / nHalfSliderWidth;
const long nOffsetToSliderLeft = nOffset - nSliderXOffset;
nRet = mpImpl->mnMinZoom + sal_uInt16( nOffsetToSliderLeft * nZoomPerSliderPixel / 1000 );
}
else
{
// second half of slider
const long nSecondHalfRange = mpImpl->mnMaxZoom - mpImpl->mnSliderCenter;
const long nHalfSliderWidth = nControlWidth/2 - nSliderXOffset;
const long nZoomPerSliderPixel = 1000 * nSecondHalfRange / nHalfSliderWidth;
const long nOffsetToSliderCenter = nOffset - nControlWidth/2;
nRet = mpImpl->mnSliderCenter + sal_uInt16( nOffsetToSliderCenter * nZoomPerSliderPixel / 1000 );
}
}
if( nRet < mpImpl->mnMinZoom )
return mpImpl->mnMinZoom;
else if( nRet > mpImpl->mnMaxZoom )
return mpImpl->mnMaxZoom;
return nRet;
}
// -----------------------------------------------------------------------
long ScZoomSliderWnd::Zoom2Offset( sal_uInt16 nCurrentZoom ) const
{
Size aSliderWindowSize = GetOutputSizePixel();
const long nControlWidth = aSliderWindowSize.Width();
long nRect = nSliderXOffset;
const long nHalfSliderWidth = nControlWidth/2 - nSliderXOffset;
if( nCurrentZoom <= mpImpl->mnSliderCenter )
{
nCurrentZoom = nCurrentZoom - mpImpl->mnMinZoom;
const long nFirstHalfRange = mpImpl->mnSliderCenter - mpImpl->mnMinZoom;
const long nSliderPixelPerZoomPercent = 1000 * nHalfSliderWidth / nFirstHalfRange;
const long nOffset = (nSliderPixelPerZoomPercent * nCurrentZoom) / 1000;
nRect += nOffset;
}
else
{
nCurrentZoom = nCurrentZoom - mpImpl->mnSliderCenter;
const long nSecondHalfRange = mpImpl->mnMaxZoom - mpImpl->mnSliderCenter;
const long nSliderPixelPerZoomPercent = 1000 * nHalfSliderWidth / nSecondHalfRange;
const long nOffset = (nSliderPixelPerZoomPercent * nCurrentZoom) / 1000;
nRect += nHalfSliderWidth + nOffset;
}
return nRect;
}
// -----------------------------------------------------------------------
ScZoomSliderWnd::ScZoomSliderWnd( Window* pParent, const ::com::sun::star::uno::Reference< ::com::sun::star::frame::XDispatchProvider >& rDispatchProvider,
const ::com::sun::star::uno::Reference< ::com::sun::star::frame::XFrame >& _xFrame , sal_uInt16 nCurrentZoom ):
Window( pParent ),
mpImpl( new ScZoomSliderWnd_Impl( nCurrentZoom ) ),
aLogicalSize( 115, 40 ),
m_xDispatchProvider( rDispatchProvider ),
m_xFrame( _xFrame )
{
sal_Bool bIsHC = GetSettings().GetStyleSettings().GetHighContrastMode();
mpImpl->maSliderButton = Image( SVX_RES( bIsHC ? RID_SVXBMP_SLIDERBUTTON_HC : RID_SVXBMP_SLIDERBUTTON ) );
mpImpl->maIncreaseButton = Image( SVX_RES( bIsHC ? RID_SVXBMP_SLIDERINCREASE_HC : RID_SVXBMP_SLIDERINCREASE ) );
mpImpl->maDecreaseButton = Image( SVX_RES( bIsHC ? RID_SVXBMP_SLIDERDECREASE_HC : RID_SVXBMP_SLIDERDECREASE ) );
Size aSliderSize = LogicToPixel( Size( aLogicalSize), MapMode( MAP_10TH_MM ) );
SetSizePixel( Size( aSliderSize.Width() * nSliderWidth-1, aSliderSize.Height() + nSliderHeight ) );
}
// -----------------------------------------------------------------------
ScZoomSliderWnd::~ScZoomSliderWnd()
{
delete mpImpl;
}
// -----------------------------------------------------------------------
void ScZoomSliderWnd::MouseButtonDown( const MouseEvent& rMEvt )
{
if ( !mpImpl->mbValuesSet )
return ;
Size aSliderWindowSize = GetOutputSizePixel();
const Point aPoint = rMEvt.GetPosPixel();
const long nButtonLeftOffset = ( nSliderXOffset - nIncDecWidth )/2;
const long nButtonRightOffset = ( nSliderXOffset + nIncDecWidth )/2;
const long nOldZoom = mpImpl->mnCurrentZoom;
// click to - button
if ( aPoint.X() >= nButtonLeftOffset && aPoint.X() <= nButtonRightOffset )
{
mpImpl->mnCurrentZoom = mpImpl->mnCurrentZoom - 5;
}
// click to + button
else if ( aPoint.X() >= aSliderWindowSize.Width() - nSliderXOffset + nButtonLeftOffset &&
aPoint.X() <= aSliderWindowSize.Width() - nSliderXOffset + nButtonRightOffset )
{
mpImpl->mnCurrentZoom = mpImpl->mnCurrentZoom + 5;
}
else if( aPoint.X() >= nSliderXOffset && aPoint.X() <= aSliderWindowSize.Width() - nSliderXOffset )
{
mpImpl->mnCurrentZoom = Offset2Zoom( aPoint.X() );
}
if( mpImpl->mnCurrentZoom < mpImpl->mnMinZoom )
mpImpl->mnCurrentZoom = mpImpl->mnMinZoom;
else if( mpImpl->mnCurrentZoom > mpImpl->mnMaxZoom )
mpImpl->mnCurrentZoom = mpImpl->mnMaxZoom;
if( nOldZoom == mpImpl->mnCurrentZoom )
return ;
Rectangle aRect( Point( 0, 0 ), aSliderWindowSize );
Paint( aRect );
mpImpl->mbOmitPaint = true;
SvxZoomSliderItem aZoomSliderItem( mpImpl->mnCurrentZoom );
::com::sun::star::uno::Any a;
aZoomSliderItem.QueryValue( a );
::com::sun::star::uno::Sequence< ::com::sun::star::beans::PropertyValue > aArgs( 1 );
aArgs[0].Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "ScalingFactor" ));
aArgs[0].Value = a;
SfxToolBoxControl::Dispatch( m_xDispatchProvider, String::CreateFromAscii(".uno:ScalingFactor"), aArgs );
mpImpl->mbOmitPaint = false;
}
// -----------------------------------------------------------------------
void ScZoomSliderWnd::MouseMove( const MouseEvent& rMEvt )
{
if ( !mpImpl->mbValuesSet )
return ;
Size aSliderWindowSize = GetOutputSizePixel();
const long nControlWidth = aSliderWindowSize.Width();
const short nButtons = rMEvt.GetButtons();
// check mouse move with button pressed
if ( 1 == nButtons )
{
const Point aPoint = rMEvt.GetPosPixel();
if ( aPoint.X() >= nSliderXOffset && aPoint.X() <= nControlWidth - nSliderXOffset )
{
mpImpl->mnCurrentZoom = Offset2Zoom( aPoint.X() );
Rectangle aRect( Point( 0, 0 ), aSliderWindowSize );
Paint( aRect );
mpImpl->mbOmitPaint = true; // optimization: paint before executing command,
// commit state change
SvxZoomSliderItem aZoomSliderItem( mpImpl->mnCurrentZoom );
::com::sun::star::uno::Any a;
aZoomSliderItem.QueryValue( a );
::com::sun::star::uno::Sequence< ::com::sun::star::beans::PropertyValue > aArgs( 1 );
aArgs[0].Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "ScalingFactor" ));
aArgs[0].Value = a;
SfxToolBoxControl::Dispatch( m_xDispatchProvider, String::CreateFromAscii(".uno:ScalingFactor"), aArgs );
mpImpl->mbOmitPaint = false;
}
}
}
// -----------------------------------------------------------------------
void ScZoomSliderWnd::UpdateFromItem( const SvxZoomSliderItem* pZoomSliderItem )
{
if( pZoomSliderItem )
{
mpImpl->mnCurrentZoom = pZoomSliderItem->GetValue();
mpImpl->mnMinZoom = pZoomSliderItem->GetMinZoom();
mpImpl->mnMaxZoom = pZoomSliderItem->GetMaxZoom();
DBG_ASSERT( mpImpl->mnMinZoom <= mpImpl->mnCurrentZoom &&
mpImpl->mnMinZoom < mpImpl->mnSliderCenter &&
mpImpl->mnMaxZoom >= mpImpl->mnCurrentZoom &&
mpImpl->mnMaxZoom > mpImpl->mnSliderCenter,
"Looks like the zoom slider item is corrupted" );
const com::sun::star::uno::Sequence < sal_Int32 > rSnappingPoints = pZoomSliderItem->GetSnappingPoints();
mpImpl->maSnappingPointOffsets.clear();
mpImpl->maSnappingPointZooms.clear();
// get all snapping points:
std::set< sal_uInt16 > aTmpSnappingPoints;
for ( sal_uInt16 j = 0; j < rSnappingPoints.getLength(); ++j )
{
const sal_Int32 nSnappingPoint = rSnappingPoints[j];
aTmpSnappingPoints.insert( (sal_uInt16)nSnappingPoint );
}
// remove snapping points that are to close to each other:
std::set< sal_uInt16 >::iterator aSnappingPointIter;
long nLastOffset = 0;
for ( aSnappingPointIter = aTmpSnappingPoints.begin(); aSnappingPointIter != aTmpSnappingPoints.end(); ++aSnappingPointIter )
{
const sal_uInt16 nCurrent = *aSnappingPointIter;
const long nCurrentOffset = Zoom2Offset( nCurrent );
if ( nCurrentOffset - nLastOffset >= nSnappingPointsMinDist )
{
mpImpl->maSnappingPointOffsets.push_back( nCurrentOffset );
mpImpl->maSnappingPointZooms.push_back( nCurrent );
nLastOffset = nCurrentOffset;
}
}
}
Size aSliderWindowSize = GetOutputSizePixel();
Rectangle aRect( Point( 0, 0 ), aSliderWindowSize );
if ( !mpImpl->mbOmitPaint )
Paint(aRect);
}
// -----------------------------------------------------------------------
void ScZoomSliderWnd::Paint( const Rectangle& rRect )
{
DoPaint( rRect );
}
// -----------------------------------------------------------------------
void ScZoomSliderWnd::DoPaint( const Rectangle& /*rRect*/ )
{
if( mpImpl->mbOmitPaint )
return;
Size aSliderWindowSize = GetOutputSizePixel();
Rectangle aRect( Point( 0, 0 ), aSliderWindowSize );
VirtualDevice* pVDev = new VirtualDevice( *this );
pVDev->SetOutputSizePixel( aSliderWindowSize );
Rectangle aSlider = aRect;
aSlider.Top() += ( aSliderWindowSize.Height() - nSliderHeight )/2 - 1;
aSlider.Bottom() = aSlider.Top() + nSliderHeight;
aSlider.Left() += nSliderXOffset;
aSlider.Right() -= nSliderXOffset;
Rectangle aFirstLine( aSlider );
aFirstLine.Bottom() = aFirstLine.Top();
Rectangle aSecondLine( aSlider );
aSecondLine.Top() = aSecondLine.Bottom();
Rectangle aLeft( aSlider );
aLeft.Right() = aLeft.Left();
Rectangle aRight( aSlider );
aRight.Left() = aRight.Right();
// draw VirtualDevice's background color
Color aStartColor,aEndColor;
aStartColor = GetSettings().GetStyleSettings().GetFaceColor();
aEndColor = GetSettings().GetStyleSettings().GetFaceColor();
if( aEndColor.IsDark() )
aStartColor = aEndColor;
Gradient g;
g.SetAngle( 0 );
g.SetStyle( GRADIENT_LINEAR );
g.SetStartColor( aStartColor );
g.SetEndColor( aEndColor );
pVDev->DrawGradient( aRect, g );
// draw slider
pVDev->SetLineColor( Color ( COL_GRAY ) );
pVDev->DrawRect( aSecondLine );
pVDev->DrawRect( aRight );
pVDev->SetLineColor( Color ( COL_GRAY ) );
pVDev->DrawRect( aFirstLine );
pVDev->DrawRect( aLeft );
// draw snapping points:
std::vector< long >::iterator aSnappingPointIter;
for ( aSnappingPointIter = mpImpl->maSnappingPointOffsets.begin();
aSnappingPointIter != mpImpl->maSnappingPointOffsets.end();
++aSnappingPointIter )
{
pVDev->SetLineColor( Color( COL_GRAY ) );
Rectangle aSnapping( aRect );
aSnapping.Bottom() = aSlider.Top();
aSnapping.Top() = aSnapping.Bottom() - nSnappingHeight;
aSnapping.Left() += *aSnappingPointIter;
aSnapping.Right() = aSnapping.Left();
pVDev->DrawRect( aSnapping );
aSnapping.Top() += nSnappingHeight + nSliderHeight;
aSnapping.Bottom() += nSnappingHeight + nSliderHeight;
pVDev->DrawRect( aSnapping );
}
// draw slider button
Point aImagePoint = aRect.TopLeft();
aImagePoint.X() += Zoom2Offset( mpImpl->mnCurrentZoom );
aImagePoint.X() -= nButtonWidth/2;
aImagePoint.Y() += ( aSliderWindowSize.Height() - nButtonHeight)/2;
pVDev->DrawImage( aImagePoint, mpImpl->maSliderButton );
// draw decrease button
aImagePoint = aRect.TopLeft();
aImagePoint.X() += (nSliderXOffset - nIncDecWidth)/2;
aImagePoint.Y() += ( aSliderWindowSize.Height() - nIncDecHeight)/2;
pVDev->DrawImage( aImagePoint, mpImpl->maDecreaseButton );
// draw increase button
aImagePoint.X() = aRect.TopLeft().X() + aSliderWindowSize.Width() - nIncDecWidth - (nSliderXOffset - nIncDecWidth)/2;
pVDev->DrawImage( aImagePoint, mpImpl->maIncreaseButton );
DrawOutDev( Point(0, 0), aSliderWindowSize, Point(0, 0), aSliderWindowSize, *pVDev );
delete pVDev;
}
// -----------------------------------------------------------------------