LibreOffice Module sc (master)  1
tbzoomsliderctrl.cxx
Go to the documentation of this file.
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 #include <tbzoomsliderctrl.hxx>
21 #include <vcl/event.hxx>
22 #include <vcl/image.hxx>
23 #include <vcl/toolbox.hxx>
24 #include <vcl/virdev.hxx>
25 #include <vcl/gradient.hxx>
26 #include <vcl/settings.hxx>
27 #include <svx/zoomslideritem.hxx>
28 #include <iterator>
29 #include <set>
30 #include <bitmaps.hlst>
31 
32 #include <com/sun/star/frame/XFrame.hpp>
33 #include <com/sun/star/frame/XDispatchProvider.hpp>
34 
35 // class ScZoomSliderControl ---------------------------------------
36 
38 
40  sal_uInt16 nSlotId,
41  sal_uInt16 nId,
42  ToolBox& rTbx )
43  :SfxToolBoxControl( nSlotId, nId, rTbx )
44 {
45  rTbx.Invalidate();
46 }
47 
49 {
50 
51 }
52 
53 void ScZoomSliderControl::StateChanged( sal_uInt16 /*nSID*/, SfxItemState eState,
54  const SfxPoolItem* pState )
55 {
56  sal_uInt16 nId = GetId();
57  ToolBox& rTbx = GetToolBox();
58  ScZoomSliderWnd* pBox = static_cast<ScZoomSliderWnd*>(rTbx.GetItemWindow( nId ));
59  OSL_ENSURE( pBox ,"Control not found!" );
60 
61  if ( SfxItemState::DEFAULT != eState || pState->IsVoidItem() )
62  {
63  SvxZoomSliderItem aZoomSliderItem( 100 );
64  pBox->Disable();
65  pBox->UpdateFromItem( &aZoomSliderItem );
66  }
67  else
68  {
69  pBox->Enable();
70  OSL_ENSURE( dynamic_cast<const SvxZoomSliderItem*>( pState) != nullptr, "invalid item type" );
71  const SvxZoomSliderItem* pZoomSliderItem = dynamic_cast< const SvxZoomSliderItem* >( pState );
72 
73  OSL_ENSURE( pZoomSliderItem, "Sc::ScZoomSliderControl::StateChanged(), wrong item type!" );
74  if( pZoomSliderItem )
75  pBox->UpdateFromItem( pZoomSliderItem );
76  }
77 }
78 
80 {
81  // #i98000# Don't try to get a value via SfxViewFrame::Current here.
82  // The view's value is always notified via StateChanged later.
83  VclPtrInstance<ScZoomSliderWnd> xSlider( pParent,
84  css::uno::Reference< css::frame::XDispatchProvider >( m_xFrame->getController(),
85  css::uno::UNO_QUERY ), 100 );
86  return xSlider;
87 }
88 
90 {
91  sal_uInt16 mnCurrentZoom;
92  sal_uInt16 mnMinZoom;
93  sal_uInt16 mnMaxZoom;
94  std::vector< long > maSnappingPointOffsets;
95  std::vector< sal_uInt16 > maSnappingPointZooms;
101 
102  explicit ScZoomSliderWnd_Impl( sal_uInt16 nCurrentZoom, vcl::Window* parentWindow ) :
103  mnCurrentZoom( nCurrentZoom ),
104  mnMinZoom( 10 ),
105  mnMaxZoom( 400 ),
106  maSnappingPointOffsets(),
107  maSnappingPointZooms(),
108  maSliderButton(),
109  maIncreaseButton(),
110  maDecreaseButton(),
111  mbOmitPaint( false ),
112  mxParentWindow(parentWindow)
113  {
114  }
115 };
116 
117 constexpr sal_uInt16 gnSliderCenter(100);
118 
119 const long nButtonWidth = 10;
120 const long nButtonHeight = 10;
121 const long nIncDecWidth = 11;
122 const long nIncDecHeight = 11;
123 const long nSliderHeight = 2;
124 const long nSliderWidth = 4;
125 const long nSnappingHeight = 4;
126 const long nSliderXOffset = 20;
127 const long nSnappingEpsilon = 5; // snapping epsilon in pixels
128 const long nSnappingPointsMinDist = nSnappingEpsilon; // minimum distance of two adjacent snapping points
129 
130 sal_uInt16 ScZoomSlider::Offset2Zoom( long nOffset ) const
131 {
132  Size aSliderWindowSize = GetOutputSizePixel();
133  const long nControlWidth = aSliderWindowSize.Width();
134  sal_uInt16 nRet = 0;
135 
136  if( nOffset < nSliderXOffset )
137  return mpImpl->mnMinZoom;
138  if( nOffset > nControlWidth - nSliderXOffset )
139  return mpImpl->mnMaxZoom;
140 
141  // check for snapping points:
142  auto aSnappingPointIter = std::find_if(mpImpl->maSnappingPointOffsets.begin(), mpImpl->maSnappingPointOffsets.end(),
143  [nOffset](const long nCurrent) { return std::abs(nCurrent - nOffset) < nSnappingEpsilon; });
144  if (aSnappingPointIter != mpImpl->maSnappingPointOffsets.end())
145  {
146  nOffset = *aSnappingPointIter;
147  auto nCount = static_cast<sal_uInt16>(std::distance(mpImpl->maSnappingPointOffsets.begin(), aSnappingPointIter));
148  nRet = mpImpl->maSnappingPointZooms[ nCount ];
149  }
150 
151  if( 0 == nRet )
152  {
153  if( nOffset < nControlWidth / 2 )
154  {
155  // first half of slider
156  const long nFirstHalfRange = gnSliderCenter - mpImpl->mnMinZoom;
157  const long nHalfSliderWidth = nControlWidth/2 - nSliderXOffset;
158  const long nZoomPerSliderPixel = (1000 * nFirstHalfRange) / nHalfSliderWidth;
159  const long nOffsetToSliderLeft = nOffset - nSliderXOffset;
160  nRet = mpImpl->mnMinZoom + sal_uInt16( nOffsetToSliderLeft * nZoomPerSliderPixel / 1000 );
161  }
162  else
163  {
164  // second half of slider
165  const long nSecondHalfRange = mpImpl->mnMaxZoom - gnSliderCenter;
166  const long nHalfSliderWidth = nControlWidth/2 - nSliderXOffset;
167  const long nZoomPerSliderPixel = 1000 * nSecondHalfRange / nHalfSliderWidth;
168  const long nOffsetToSliderCenter = nOffset - nControlWidth/2;
169  nRet = gnSliderCenter + sal_uInt16( nOffsetToSliderCenter * nZoomPerSliderPixel / 1000 );
170  }
171  }
172 
173  if( nRet < mpImpl->mnMinZoom )
174  return mpImpl->mnMinZoom;
175 
176  else if( nRet > mpImpl->mnMaxZoom )
177  return mpImpl->mnMaxZoom;
178 
179  return nRet;
180 }
181 
182 long ScZoomSlider::Zoom2Offset( sal_uInt16 nCurrentZoom ) const
183 {
184  Size aSliderWindowSize = GetOutputSizePixel();
185  const long nControlWidth = aSliderWindowSize.Width();
186  long nRect = nSliderXOffset;
187 
188  const long nHalfSliderWidth = nControlWidth/2 - nSliderXOffset;
189  if( nCurrentZoom <= gnSliderCenter )
190  {
191  nCurrentZoom = nCurrentZoom - mpImpl->mnMinZoom;
192  const long nFirstHalfRange = gnSliderCenter - mpImpl->mnMinZoom;
193  const long nSliderPixelPerZoomPercent = 1000 * nHalfSliderWidth / nFirstHalfRange;
194  const long nOffset = (nSliderPixelPerZoomPercent * nCurrentZoom) / 1000;
195  nRect += nOffset;
196  }
197  else
198  {
199  nCurrentZoom = nCurrentZoom - gnSliderCenter;
200  const long nSecondHalfRange = mpImpl->mnMaxZoom - gnSliderCenter;
201  const long nSliderPixelPerZoomPercent = 1000 * nHalfSliderWidth / nSecondHalfRange;
202  const long nOffset = (nSliderPixelPerZoomPercent * nCurrentZoom) / 1000;
203  nRect += nHalfSliderWidth + nOffset;
204  }
205  return nRect;
206 }
207 
209  const css::uno::Reference< css::frame::XDispatchProvider >& rDispatchProvider,
210  sal_uInt16 nCurrentZoom ):
211  InterimItemWindow(pParent, "modules/scalc/ui/zoombox.ui", "ZoomBox"),
212  mxWidget(new ScZoomSlider(rDispatchProvider, nCurrentZoom, pParent)),
213  mxWeld(new weld::CustomWeld(*m_xBuilder, "zoom", *mxWidget))
214 {
215  Size aLogicalSize( 115, 40 );
216  Size aSliderSize = LogicToPixel(aLogicalSize, MapMode(MapUnit::Map10thMM));
217  Size aPreferredSize(aSliderSize.Width() * nSliderWidth-1, aSliderSize.Height() + nSliderHeight);
218  mxWidget->GetDrawingArea()->set_size_request(aPreferredSize.Width(), aPreferredSize.Height());
219  mxWidget->SetOutputSizePixel(aPreferredSize);
220  SetSizePixel(aPreferredSize);
221 }
222 
224 {
225  disposeOnce();
226 }
227 
229 {
230  mxWeld.reset();
231  mxWidget.reset();
233 }
234 
235 ScZoomSlider::ScZoomSlider(const css::uno::Reference< css::frame::XDispatchProvider>& rDispatchProvider,
236  sal_uInt16 nCurrentZoom, vcl::Window* parentWindow)
237  : mpImpl(new ScZoomSliderWnd_Impl(nCurrentZoom, parentWindow))
238  , m_xDispatchProvider(rDispatchProvider)
239 {
240  mpImpl->maSliderButton = Image(StockImage::Yes, RID_SVXBMP_SLIDERBUTTON);
241  mpImpl->maIncreaseButton = Image(StockImage::Yes, RID_SVXBMP_SLIDERINCREASE);
242  mpImpl->maDecreaseButton = Image(StockImage::Yes, RID_SVXBMP_SLIDERDECREASE);
243 }
244 
246 {
247  Size aSliderWindowSize = GetOutputSizePixel();
248 
249  const Point aPoint = rMEvt.GetPosPixel();
250 
251  const long nButtonLeftOffset = ( nSliderXOffset - nIncDecWidth )/2;
252  const long nButtonRightOffset = ( nSliderXOffset + nIncDecWidth )/2;
253 
254  const long nOldZoom = mpImpl->mnCurrentZoom;
255 
256  // click to - button
257  if ( aPoint.X() >= nButtonLeftOffset && aPoint.X() <= nButtonRightOffset )
258  {
259  mpImpl->mnCurrentZoom = mpImpl->mnCurrentZoom - 5;
260  }
261  // click to + button
262  else if ( aPoint.X() >= aSliderWindowSize.Width() - nSliderXOffset + nButtonLeftOffset &&
263  aPoint.X() <= aSliderWindowSize.Width() - nSliderXOffset + nButtonRightOffset )
264  {
265  mpImpl->mnCurrentZoom = mpImpl->mnCurrentZoom + 5;
266  }
267  else if( aPoint.X() >= nSliderXOffset && aPoint.X() <= aSliderWindowSize.Width() - nSliderXOffset )
268  {
269  mpImpl->mnCurrentZoom = Offset2Zoom( aPoint.X() );
270  }
271 
272  if( mpImpl->mnCurrentZoom < mpImpl->mnMinZoom )
273  mpImpl->mnCurrentZoom = mpImpl->mnMinZoom;
274  else if( mpImpl->mnCurrentZoom > mpImpl->mnMaxZoom )
275  mpImpl->mnCurrentZoom = mpImpl->mnMaxZoom;
276 
277  if( nOldZoom == mpImpl->mnCurrentZoom )
278  return true;
279 
280  // need to invalidate parent since we rely on the toolbox drawing it's fancy gradient background
281  mpImpl->mxParentWindow->Invalidate();
282  mpImpl->mbOmitPaint = true;
283 
284  SvxZoomSliderItem aZoomSliderItem( mpImpl->mnCurrentZoom );
285 
286  css::uno::Any a;
287  aZoomSliderItem.QueryValue( a );
288 
289  css::uno::Sequence< css::beans::PropertyValue > aArgs( 1 );
290  aArgs[0].Name = "ScalingFactor";
291  aArgs[0].Value = a;
292 
293  SfxToolBoxControl::Dispatch( m_xDispatchProvider, ".uno:ScalingFactor", aArgs );
294 
295  mpImpl->mbOmitPaint = false;
296 
297  return true;
298 }
299 
301 {
302  Size aSliderWindowSize = GetOutputSizePixel();
303  const long nControlWidth = aSliderWindowSize.Width();
304  const short nButtons = rMEvt.GetButtons();
305 
306  // check mouse move with button pressed
307  if ( 1 == nButtons )
308  {
309  const Point aPoint = rMEvt.GetPosPixel();
310 
311  if ( aPoint.X() >= nSliderXOffset && aPoint.X() <= nControlWidth - nSliderXOffset )
312  {
313  mpImpl->mnCurrentZoom = Offset2Zoom( aPoint.X() );
314 
315  // need to invalidate parent since we rely on the toolbox drawing it's fancy gradient background
316  mpImpl->mxParentWindow->Invalidate();
317 
318  mpImpl->mbOmitPaint = true; // optimization: paint before executing command,
319 
320  // commit state change
321  SvxZoomSliderItem aZoomSliderItem( mpImpl->mnCurrentZoom );
322 
323  css::uno::Any a;
324  aZoomSliderItem.QueryValue( a );
325 
326  css::uno::Sequence< css::beans::PropertyValue > aArgs( 1 );
327  aArgs[0].Name = "ScalingFactor";
328  aArgs[0].Value = a;
329 
330  SfxToolBoxControl::Dispatch( m_xDispatchProvider, ".uno:ScalingFactor", aArgs );
331 
332  mpImpl->mbOmitPaint = false;
333  }
334  }
335 
336  return false;
337 }
338 
340 {
341  mxWidget->UpdateFromItem(pZoomSliderItem);
342 }
343 
345 {
346  if( pZoomSliderItem )
347  {
348  mpImpl->mnCurrentZoom = pZoomSliderItem->GetValue();
349  mpImpl->mnMinZoom = pZoomSliderItem->GetMinZoom();
350  mpImpl->mnMaxZoom = pZoomSliderItem->GetMaxZoom();
351 
352  OSL_ENSURE( mpImpl->mnMinZoom <= mpImpl->mnCurrentZoom &&
353  mpImpl->mnMinZoom < gnSliderCenter &&
354  mpImpl->mnMaxZoom >= mpImpl->mnCurrentZoom &&
355  mpImpl->mnMaxZoom > gnSliderCenter,
356  "Looks like the zoom slider item is corrupted" );
357  const css::uno::Sequence < sal_Int32 >& rSnappingPoints = pZoomSliderItem->GetSnappingPoints();
358  mpImpl->maSnappingPointOffsets.clear();
359  mpImpl->maSnappingPointZooms.clear();
360 
361  // get all snapping points:
362  std::set< sal_uInt16 > aTmpSnappingPoints;
363  std::transform(rSnappingPoints.begin(), rSnappingPoints.end(), std::inserter(aTmpSnappingPoints, aTmpSnappingPoints.end()),
364  [](const sal_Int32 nSnappingPoint) -> sal_uInt16 { return static_cast<sal_uInt16>(nSnappingPoint); });
365 
366  // remove snapping points that are too close to each other:
367  long nLastOffset = 0;
368 
369  for ( const sal_uInt16 nCurrent : aTmpSnappingPoints )
370  {
371  const long nCurrentOffset = Zoom2Offset( nCurrent );
372 
373  if ( nCurrentOffset - nLastOffset >= nSnappingPointsMinDist )
374  {
375  mpImpl->maSnappingPointOffsets.push_back( nCurrentOffset );
376  mpImpl->maSnappingPointZooms.push_back( nCurrent );
377  nLastOffset = nCurrentOffset;
378  }
379  }
380  }
381 
382  if ( !mpImpl->mbOmitPaint )
383  // need to invalidate parent since we rely on the toolbox drawing it's fancy gradient background
384  mpImpl->mxParentWindow->Invalidate();
385 }
386 
387 void ScZoomSlider::Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle& /*rRect*/)
388 {
389  DoPaint(rRenderContext);
390 }
391 
393 {
394  if (mpImpl->mbOmitPaint)
395  return;
396 
397  Size aSliderWindowSize(GetOutputSizePixel());
398  tools::Rectangle aRect(Point(0, 0), aSliderWindowSize);
399 
400  ScopedVclPtrInstance< VirtualDevice > pVDev(rRenderContext);
401  pVDev->SetBackground(Wallpaper(COL_TRANSPARENT));
402  pVDev->SetOutputSizePixel(aSliderWindowSize);
403 
404  tools::Rectangle aSlider = aRect;
405 
406  aSlider.AdjustTop((aSliderWindowSize.Height() - nSliderHeight) / 2 - 1 );
407  aSlider.SetBottom( aSlider.Top() + nSliderHeight );
408  aSlider.AdjustLeft(nSliderXOffset );
409  aSlider.AdjustRight( -nSliderXOffset );
410 
411  tools::Rectangle aFirstLine(aSlider);
412  aFirstLine.SetBottom( aFirstLine.Top() );
413 
414  tools::Rectangle aSecondLine(aSlider);
415  aSecondLine.SetTop( aSecondLine.Bottom() );
416 
417  tools::Rectangle aLeft(aSlider);
418  aLeft.SetRight( aLeft.Left() );
419 
420  tools::Rectangle aRight(aSlider);
421  aRight.SetLeft( aRight.Right() );
422 
423  // draw slider
424  pVDev->SetLineColor(COL_WHITE);
425  pVDev->DrawRect(aSecondLine);
426  pVDev->DrawRect(aRight);
427 
428  pVDev->SetLineColor(COL_GRAY);
429  pVDev->DrawRect(aFirstLine);
430  pVDev->DrawRect(aLeft);
431 
432  // draw snapping points:
433  for (const auto& rSnappingPointOffset : mpImpl->maSnappingPointOffsets)
434  {
435  pVDev->SetLineColor(COL_GRAY);
436  tools::Rectangle aSnapping(aRect);
437  aSnapping.SetBottom( aSlider.Top() );
438  aSnapping.SetTop( aSnapping.Bottom() - nSnappingHeight );
439  aSnapping.AdjustLeft(rSnappingPointOffset );
440  aSnapping.SetRight( aSnapping.Left() );
441  pVDev->DrawRect(aSnapping);
442 
445  pVDev->DrawRect(aSnapping);
446  }
447 
448  // draw slider button
449  Point aImagePoint = aRect.TopLeft();
450  aImagePoint.AdjustX(Zoom2Offset(mpImpl->mnCurrentZoom) );
451  aImagePoint.AdjustX( -(nButtonWidth / 2) );
452  aImagePoint.AdjustY( (aSliderWindowSize.Height() - nButtonHeight) / 2 );
453  pVDev->DrawImage(aImagePoint, mpImpl->maSliderButton);
454 
455  // draw decrease button
456  aImagePoint = aRect.TopLeft();
457  aImagePoint.AdjustX((nSliderXOffset - nIncDecWidth) / 2 );
458  aImagePoint.AdjustY((aSliderWindowSize.Height() - nIncDecHeight) / 2 );
459  pVDev->DrawImage(aImagePoint, mpImpl->maDecreaseButton);
460 
461  // draw increase button
462  aImagePoint.setX( aRect.TopLeft().X() + aSliderWindowSize.Width() - nIncDecWidth - (nSliderXOffset - nIncDecWidth) / 2 );
463  pVDev->DrawImage(aImagePoint, mpImpl->maIncreaseButton);
464 
465  rRenderContext.DrawOutDev(Point(0, 0), aSliderWindowSize, Point(0, 0), aSliderWindowSize, *pVDev);
466 }
467 
468 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
Point TopLeft() const
long Width() const
std::unique_ptr< weld::CustomWeld > mxWeld
void DoPaint(vcl::RenderContext &rRenderContext)
ToolBox & GetToolBox() const
long Height() const
virtual void Paint(vcl::RenderContext &rRenderContext, const tools::Rectangle &rRect) override
long AdjustLeft(long nHorzMoveDelta)
constexpr sal_uInt16 gnSliderCenter(100)
virtual ~ScZoomSliderWnd() override
css::uno::Reference< css::lang::XComponent > m_xFrame
const long nSliderHeight
virtual void SetSizePixel(const Size &rNewSize)
const long nSliderWidth
sal_Int16 nId
virtual bool MouseButtonDown(const MouseEvent &rMEvt) override
constexpr::Color COL_GRAY(0x80, 0x80, 0x80)
sal_uInt16 GetMaxZoom() const
const long nButtonHeight
ScZoomSliderWnd_Impl(sal_uInt16 nCurrentZoom, vcl::Window *parentWindow)
css::uno::Reference< css::frame::XDispatchProvider > m_xDispatchProvider
Size const & GetOutputSizePixel() const
long AdjustBottom(long nVertMoveDelta)
const long nIncDecHeight
sal_uInt16 Offset2Zoom(long nOffset) const
constexpr::Color COL_TRANSPARENT(0xFF, 0xFF, 0xFF, 0xFF)
long Right() const
void Enable(bool bEnable=true, bool bChild=true)
sal_uInt16 GetButtons() const
int nCount
virtual VclPtr< InterimItemWindow > CreateItemWindow(vcl::Window *pParent) override
long Top() const
virtual bool MouseMove(const MouseEvent &rMEvt) override
const long nSnappingHeight
virtual void StateChanged(sal_uInt16 nSID, SfxItemState eState, const SfxPoolItem *pState) override
virtual bool IsVoidItem() const
std::vector< sal_uInt16 > maSnappingPointZooms
const long nSliderXOffset
ScZoomSliderWnd(vcl::Window *pParent, const css::uno::Reference< css::frame::XDispatchProvider > &rDispatchProvider, sal_uInt16 nCurrentZoom)
virtual bool QueryValue(css::uno::Any &rVal, sal_uInt8 nMemberId=0) const override
void SetTop(long v)
uno_Any a
std::unique_ptr< ScZoomSlider > mxWidget
std::unique_ptr< ScZoomSliderWnd_Impl > mpImpl
virtual void Invalidate(InvalidateFlags nFlags=InvalidateFlags::NONE)
void SetRight(long v)
long Bottom() const
vcl::Window * GetItemWindow(sal_uInt16 nItemId) const
virtual void dispose() override
ScZoomSlider(const css::uno::Reference< css::frame::XDispatchProvider > &rDispatchProvider, sal_uInt16 nCurrentZoom, vcl::Window *)
SFX_IMPL_TOOLBOX_CONTROL(ScZoomSliderControl, SvxZoomSliderItem)
ScZoomSliderControl(sal_uInt16 nSlotId, sal_uInt16 nId, ToolBox &rTbx)
void Disable(bool bChild=true)
Point LogicToPixel(const Point &rLogicPt) const
virtual ~ScZoomSliderControl() override
SfxItemState
long AdjustRight(long nHorzMoveDelta)
const long nSnappingEpsilon
void UpdateFromItem(const SvxZoomSliderItem *pZoomSliderItem)
virtual void dispose() override
unsigned short GetId() const
std::vector< long > maSnappingPointOffsets
void SetBottom(long v)
long AdjustTop(long nVertMoveDelta)
const Point & GetPosPixel() const
constexpr::Color COL_WHITE(0xFF, 0xFF, 0xFF)
long Left() const
void UpdateFromItem(const SvxZoomSliderItem *pZoomSliderItem)
void SetLeft(long v)
sal_uInt16 GetMinZoom() const
const long nIncDecWidth
const long nSnappingPointsMinDist
const long nButtonWidth
const css::uno::Sequence< sal_Int32 > & GetSnappingPoints() const
long Zoom2Offset(sal_uInt16 nZoom) const
void Dispatch(const OUString &aCommand, css::uno::Sequence< css::beans::PropertyValue > const &aArgs)
SAL_DLLPRIVATE void DrawOutDev(const Point &, const Size &, const Point &, const Size &, const Printer &)=delete