LibreOffice Module vcl (master)  1
rect.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 
20 #include <cassert>
21 
22 #include <sal/types.h>
23 
24 #include <tools/poly.hxx>
25 #include <tools/helpers.hxx>
26 #include <vcl/metaact.hxx>
27 #include <vcl/outdev.hxx>
28 #include <vcl/virdev.hxx>
29 
30 #include <salgdi.hxx>
31 
33 {
34  sal_uInt16 nPixel = static_cast<sal_uInt16>(PixelToLogic(Size(1, 1)).Width());
35 
36  aBorderRect.AdjustLeft(nPixel);
37  aBorderRect.AdjustTop(nPixel);
38 
40  DrawRect(aBorderRect);
41 
42  aBorderRect.AdjustLeft(-nPixel);
43  aBorderRect.AdjustTop(-nPixel);
44  aBorderRect.AdjustRight(-nPixel);
45  aBorderRect.AdjustBottom(-nPixel);
47 
48  DrawRect(aBorderRect);
49 }
50 
52 {
54 
55  if ( mpMetaFile )
56  mpMetaFile->AddAction( new MetaRectAction( rRect ) );
57 
59  return;
60 
61  tools::Rectangle aRect( ImplLogicToDevicePixel( rRect ) );
62 
63  if ( aRect.IsEmpty() )
64  return;
65 
66  aRect.Justify();
67 
68  if ( !mpGraphics && !AcquireGraphics() )
69  return;
70 
71  if ( mbInitClipRegion )
73 
74  if ( mbOutputClipped )
75  return;
76 
77  if ( mbInitLineColor )
78  InitLineColor();
79 
80  if ( mbInitFillColor )
81  InitFillColor();
82 
83  mpGraphics->DrawRect( aRect.Left(), aRect.Top(), aRect.GetWidth(), aRect.GetHeight(), this );
84 
85  if( mpAlphaVDev )
86  mpAlphaVDev->DrawRect( rRect );
87 }
88 
90  sal_uLong nHorzRound, sal_uLong nVertRound )
91 {
93 
94  if ( mpMetaFile )
95  mpMetaFile->AddAction( new MetaRoundRectAction( rRect, nHorzRound, nVertRound ) );
96 
98  return;
99 
100  const tools::Rectangle aRect( ImplLogicToDevicePixel( rRect ) );
101 
102  if ( aRect.IsEmpty() )
103  return;
104 
105  nHorzRound = ImplLogicWidthToDevicePixel( nHorzRound );
106  nVertRound = ImplLogicHeightToDevicePixel( nVertRound );
107 
108  // we need a graphics
109  if ( !mpGraphics && !AcquireGraphics() )
110  return;
111 
112  if ( mbInitClipRegion )
113  InitClipRegion();
114 
115  if ( mbOutputClipped )
116  return;
117 
118  if ( mbInitLineColor )
119  InitLineColor();
120 
121  if ( mbInitFillColor )
122  InitFillColor();
123 
124  if ( !nHorzRound && !nVertRound )
125  {
126  mpGraphics->DrawRect( aRect.Left(), aRect.Top(), aRect.GetWidth(), aRect.GetHeight(), this );
127  }
128  else
129  {
130  tools::Polygon aRoundRectPoly( aRect, nHorzRound, nVertRound );
131 
132  if ( aRoundRectPoly.GetSize() >= 2 )
133  {
134  SalPoint* pPtAry = reinterpret_cast<SalPoint*>(aRoundRectPoly.GetPointAry());
135 
136  if ( !mbFillColor )
137  mpGraphics->DrawPolyLine( aRoundRectPoly.GetSize(), pPtAry, this );
138  else
139  mpGraphics->DrawPolygon( aRoundRectPoly.GetSize(), pPtAry, this );
140  }
141  }
142 
143  if( mpAlphaVDev )
144  mpAlphaVDev->DrawRect( rRect, nHorzRound, nVertRound );
145 }
146 
148 {
150  if ( !IsDeviceOutputNecessary() )
151  return;
152 
153  tools::Rectangle aRect( ImplLogicToDevicePixel( rRect ) );
154 
155  if ( aRect.IsEmpty() )
156  return;
157  aRect.Justify();
158 
159  // we need a graphics
160  if ( !mpGraphics && !AcquireGraphics() )
161  return;
162 
163  if ( mbInitClipRegion )
164  InitClipRegion();
165 
166  if ( mbOutputClipped )
167  return;
168 
169  SalInvert nSalFlags = SalInvert::NONE;
170  if ( nFlags & InvertFlags::N50 )
171  nSalFlags |= SalInvert::N50;
172  if ( nFlags & InvertFlags::TrackFrame )
173  nSalFlags |= SalInvert::TrackFrame;
174  mpGraphics->Invert( aRect.Left(), aRect.Top(), aRect.GetWidth(), aRect.GetHeight(), nSalFlags, this );
175 }
176 
177 void OutputDevice::Invert( const tools::Polygon& rPoly, InvertFlags nFlags )
178 {
180  if ( !IsDeviceOutputNecessary() )
181  return;
182 
183  sal_uInt16 nPoints = rPoly.GetSize();
184 
185  if ( nPoints < 2 )
186  return;
187 
188  tools::Polygon aPoly( ImplLogicToDevicePixel( rPoly ) );
189 
190  // we need a graphics
191  if ( !mpGraphics && !AcquireGraphics() )
192  return;
193 
194  if ( mbInitClipRegion )
195  InitClipRegion();
196 
197  if ( mbOutputClipped )
198  return;
199 
200  SalInvert nSalFlags = SalInvert::NONE;
201  if ( nFlags & InvertFlags::N50 )
202  nSalFlags |= SalInvert::N50;
203  if ( nFlags & InvertFlags::TrackFrame )
204  nSalFlags |= SalInvert::TrackFrame;
205  const SalPoint* pPtAry = reinterpret_cast<const SalPoint*>(aPoly.GetConstPointAry());
206  mpGraphics->Invert( nPoints, pPtAry, nSalFlags, this );
207 }
208 
209 void OutputDevice::DrawCheckered(const Point& rPos, const Size& rSize, sal_uInt32 nLen, Color aStart, Color aEnd)
210 {
212 
213  const sal_uInt32 nMaxX(rPos.X() + rSize.Width());
214  const sal_uInt32 nMaxY(rPos.Y() + rSize.Height());
215 
217  SetLineColor();
218 
219  for(sal_uInt32 x(0), nX(rPos.X()); nX < nMaxX; x++, nX += nLen)
220  {
221  const sal_uInt32 nRight(std::min(nMaxX, nX + nLen));
222 
223  for(sal_uInt32 y(0), nY(rPos.Y()); nY < nMaxY; y++, nY += nLen)
224  {
225  const sal_uInt32 nBottom(std::min(nMaxY, nY + nLen));
226 
227  SetFillColor(((x & 0x0001) ^ (y & 0x0001)) ? aStart : aEnd);
228  DrawRect(tools::Rectangle(nX, nY, nRight, nBottom));
229  }
230  }
231 
232  Pop();
233 }
234 
235 void OutputDevice::DrawGrid( const tools::Rectangle& rRect, const Size& rDist, DrawGridFlags nFlags )
236 {
238 
239  tools::Rectangle aDstRect( PixelToLogic( Point() ), GetOutputSize() );
240  aDstRect.Intersection( rRect );
241 
242  if( aDstRect.IsEmpty() || ImplIsRecordLayout() )
243  return;
244 
245  if( !mpGraphics && !AcquireGraphics() )
246  return;
247 
248  if( mbInitClipRegion )
249  InitClipRegion();
250 
251  if( mbOutputClipped )
252  return;
253 
254  const tools::Long nDistX = std::max( rDist.Width(), 1L );
255  const tools::Long nDistY = std::max( rDist.Height(), 1L );
256  tools::Long nX = ( rRect.Left() >= aDstRect.Left() ) ? rRect.Left() : ( rRect.Left() + ( ( aDstRect.Left() - rRect.Left() ) / nDistX ) * nDistX );
257  tools::Long nY = ( rRect.Top() >= aDstRect.Top() ) ? rRect.Top() : ( rRect.Top() + ( ( aDstRect.Top() - rRect.Top() ) / nDistY ) * nDistY );
258  const tools::Long nRight = aDstRect.Right();
259  const tools::Long nBottom = aDstRect.Bottom();
260  const tools::Long nStartX = ImplLogicXToDevicePixel( nX );
261  const tools::Long nEndX = ImplLogicXToDevicePixel( nRight );
262  const tools::Long nStartY = ImplLogicYToDevicePixel( nY );
263  const tools::Long nEndY = ImplLogicYToDevicePixel( nBottom );
264  tools::Long nHorzCount = 0;
265  tools::Long nVertCount = 0;
266 
267  std::vector< sal_Int32 > aVertBuf;
268  std::vector< sal_Int32 > aHorzBuf;
269 
270  if( ( nFlags & DrawGridFlags::Dots ) || ( nFlags & DrawGridFlags::HorzLines ) )
271  {
272  aVertBuf.resize( aDstRect.GetHeight() / nDistY + 2 );
273  aVertBuf[ nVertCount++ ] = nStartY;
274  while( ( nY += nDistY ) <= nBottom )
275  {
276  aVertBuf[ nVertCount++ ] = ImplLogicYToDevicePixel( nY );
277  }
278  }
279 
280  if( ( nFlags & DrawGridFlags::Dots ) || ( nFlags & DrawGridFlags::VertLines ) )
281  {
282  aHorzBuf.resize( aDstRect.GetWidth() / nDistX + 2 );
283  aHorzBuf[ nHorzCount++ ] = nStartX;
284  while( ( nX += nDistX ) <= nRight )
285  {
286  aHorzBuf[ nHorzCount++ ] = ImplLogicXToDevicePixel( nX );
287  }
288  }
289 
290  if( mbInitLineColor )
291  InitLineColor();
292 
293  if( mbInitFillColor )
294  InitFillColor();
295 
296  const bool bOldMap = mbMap;
297  EnableMapMode( false );
298 
299  if( nFlags & DrawGridFlags::Dots )
300  {
301  for( tools::Long i = 0; i < nVertCount; i++ )
302  {
303  for( tools::Long j = 0, Y = aVertBuf[ i ]; j < nHorzCount; j++ )
304  {
305  mpGraphics->DrawPixel( aHorzBuf[ j ], Y, this );
306  }
307  }
308  }
309  else
310  {
311  if( nFlags & DrawGridFlags::HorzLines )
312  {
313  for( tools::Long i = 0; i < nVertCount; i++ )
314  {
315  nY = aVertBuf[ i ];
316  mpGraphics->DrawLine( nStartX, nY, nEndX, nY, this );
317  }
318  }
319 
320  if( nFlags & DrawGridFlags::VertLines )
321  {
322  for( tools::Long i = 0; i < nHorzCount; i++ )
323  {
324  nX = aHorzBuf[ i ];
325  mpGraphics->DrawLine( nX, nStartY, nX, nEndY, this );
326  }
327  }
328  }
329 
330  EnableMapMode( bOldMap );
331 
332  if( mpAlphaVDev )
333  mpAlphaVDev->DrawGrid( rRect, rDist, nFlags );
334 }
335 
336 BmpMirrorFlags AdjustTwoRect( SalTwoRect& rTwoRect, const Size& rSizePix )
337 {
339 
340  if ( rTwoRect.mnDestWidth < 0 )
341  {
342  rTwoRect.mnSrcX = rSizePix.Width() - rTwoRect.mnSrcX - rTwoRect.mnSrcWidth;
343  rTwoRect.mnDestWidth = -rTwoRect.mnDestWidth;
344  rTwoRect.mnDestX -= rTwoRect.mnDestWidth-1;
345  nMirrFlags |= BmpMirrorFlags::Horizontal;
346  }
347 
348  if ( rTwoRect.mnDestHeight < 0 )
349  {
350  rTwoRect.mnSrcY = rSizePix.Height() - rTwoRect.mnSrcY - rTwoRect.mnSrcHeight;
351  rTwoRect.mnDestHeight = -rTwoRect.mnDestHeight;
352  rTwoRect.mnDestY -= rTwoRect.mnDestHeight-1;
353  nMirrFlags |= BmpMirrorFlags::Vertical;
354  }
355 
356  if( ( rTwoRect.mnSrcX < 0 ) || ( rTwoRect.mnSrcX >= rSizePix.Width() ) ||
357  ( rTwoRect.mnSrcY < 0 ) || ( rTwoRect.mnSrcY >= rSizePix.Height() ) ||
358  ( ( rTwoRect.mnSrcX + rTwoRect.mnSrcWidth ) > rSizePix.Width() ) ||
359  ( ( rTwoRect.mnSrcY + rTwoRect.mnSrcHeight ) > rSizePix.Height() ) )
360  {
361  const tools::Rectangle aSourceRect( Point( rTwoRect.mnSrcX, rTwoRect.mnSrcY ),
362  Size( rTwoRect.mnSrcWidth, rTwoRect.mnSrcHeight ) );
363  tools::Rectangle aCropRect( aSourceRect );
364 
365  aCropRect.Intersection( tools::Rectangle( Point(), rSizePix ) );
366 
367  if( aCropRect.IsEmpty() )
368  {
369  rTwoRect.mnSrcWidth = rTwoRect.mnSrcHeight = rTwoRect.mnDestWidth = rTwoRect.mnDestHeight = 0;
370  }
371  else
372  {
373  const double fFactorX = ( rTwoRect.mnSrcWidth > 1 ) ? static_cast<double>( rTwoRect.mnDestWidth - 1 ) / ( rTwoRect.mnSrcWidth - 1 ) : 0.0;
374  const double fFactorY = ( rTwoRect.mnSrcHeight > 1 ) ? static_cast<double>( rTwoRect.mnDestHeight - 1 ) / ( rTwoRect.mnSrcHeight - 1 ) : 0.0;
375 
376  const tools::Long nDstX1 = rTwoRect.mnDestX + FRound( fFactorX * ( aCropRect.Left() - rTwoRect.mnSrcX ) );
377  const tools::Long nDstY1 = rTwoRect.mnDestY + FRound( fFactorY * ( aCropRect.Top() - rTwoRect.mnSrcY ) );
378  const tools::Long nDstX2 = rTwoRect.mnDestX + FRound( fFactorX * ( aCropRect.Right() - rTwoRect.mnSrcX ) );
379  const tools::Long nDstY2 = rTwoRect.mnDestY + FRound( fFactorY * ( aCropRect.Bottom() - rTwoRect.mnSrcY ) );
380 
381  rTwoRect.mnSrcX = aCropRect.Left();
382  rTwoRect.mnSrcY = aCropRect.Top();
383  rTwoRect.mnSrcWidth = aCropRect.GetWidth();
384  rTwoRect.mnSrcHeight = aCropRect.GetHeight();
385  rTwoRect.mnDestX = nDstX1;
386  rTwoRect.mnDestY = nDstY1;
387  rTwoRect.mnDestWidth = nDstX2 - nDstX1 + 1;
388  rTwoRect.mnDestHeight = nDstY2 - nDstY1 + 1;
389  }
390  }
391 
392  return nMirrFlags;
393 }
394 
395 void AdjustTwoRect( SalTwoRect& rTwoRect, const tools::Rectangle& rValidSrcRect )
396 {
397  if( !(( rTwoRect.mnSrcX < rValidSrcRect.Left() ) || ( rTwoRect.mnSrcX >= rValidSrcRect.Right() ) ||
398  ( rTwoRect.mnSrcY < rValidSrcRect.Top() ) || ( rTwoRect.mnSrcY >= rValidSrcRect.Bottom() ) ||
399  ( ( rTwoRect.mnSrcX + rTwoRect.mnSrcWidth ) > rValidSrcRect.Right() ) ||
400  ( ( rTwoRect.mnSrcY + rTwoRect.mnSrcHeight ) > rValidSrcRect.Bottom() )) )
401  return;
402 
403  const tools::Rectangle aSourceRect( Point( rTwoRect.mnSrcX, rTwoRect.mnSrcY ),
404  Size( rTwoRect.mnSrcWidth, rTwoRect.mnSrcHeight ) );
405  tools::Rectangle aCropRect( aSourceRect );
406 
407  aCropRect.Intersection( rValidSrcRect );
408 
409  if( aCropRect.IsEmpty() )
410  {
411  rTwoRect.mnSrcWidth = rTwoRect.mnSrcHeight = rTwoRect.mnDestWidth = rTwoRect.mnDestHeight = 0;
412  }
413  else
414  {
415  const double fFactorX = ( rTwoRect.mnSrcWidth > 1 ) ? static_cast<double>( rTwoRect.mnDestWidth - 1 ) / ( rTwoRect.mnSrcWidth - 1 ) : 0.0;
416  const double fFactorY = ( rTwoRect.mnSrcHeight > 1 ) ? static_cast<double>( rTwoRect.mnDestHeight - 1 ) / ( rTwoRect.mnSrcHeight - 1 ) : 0.0;
417 
418  const tools::Long nDstX1 = rTwoRect.mnDestX + FRound( fFactorX * ( aCropRect.Left() - rTwoRect.mnSrcX ) );
419  const tools::Long nDstY1 = rTwoRect.mnDestY + FRound( fFactorY * ( aCropRect.Top() - rTwoRect.mnSrcY ) );
420  const tools::Long nDstX2 = rTwoRect.mnDestX + FRound( fFactorX * ( aCropRect.Right() - rTwoRect.mnSrcX ) );
421  const tools::Long nDstY2 = rTwoRect.mnDestY + FRound( fFactorY * ( aCropRect.Bottom() - rTwoRect.mnSrcY ) );
422 
423  rTwoRect.mnSrcX = aCropRect.Left();
424  rTwoRect.mnSrcY = aCropRect.Top();
425  rTwoRect.mnSrcWidth = aCropRect.GetWidth();
426  rTwoRect.mnSrcHeight = aCropRect.GetHeight();
427  rTwoRect.mnDestX = nDstX1;
428  rTwoRect.mnDestY = nDstY1;
429  rTwoRect.mnDestWidth = nDstX2 - nDstX1 + 1;
430  rTwoRect.mnDestHeight = nDstY2 - nDstY1 + 1;
431  }
432 }
433 
434 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
SAL_DLLPRIVATE bool ImplIsRecordLayout() const
Definition: outdev.cxx:641
tools::Rectangle & Intersection(const tools::Rectangle &rRect)
tools::Long AdjustRight(tools::Long nHorzMoveDelta)
void DrawRect(tools::Long nX, tools::Long nY, tools::Long nWidth, tools::Long nHeight, const OutputDevice *pOutDev)
tools::Long mnDestX
Definition: salgtype.hxx:54
sal_uIntPtr sal_uLong
long Long
BmpMirrorFlags AdjustTwoRect(SalTwoRect &rTwoRect, const Size &rSizePix)
Definition: rect.cxx:336
bool mbOutputClipped
Definition: outdev.hxx:379
SAL_DLLPRIVATE bool is_double_buffered_window() const
tools::Long mnSrcHeight
Definition: salgtype.hxx:53
tools::Long GetWidth() const
tools::Long mnSrcWidth
Definition: salgtype.hxx:52
constexpr::Color COL_LIGHTGRAY(0xC0, 0xC0, 0xC0)
void EnableMapMode(bool bEnable=true)
Definition: map.cxx:646
virtual void DrawBorder(tools::Rectangle aBorderRect)
Definition: rect.cxx:32
bool mbMap
Definition: outdev.hxx:374
float x
tools::Long mnDestWidth
Definition: salgtype.hxx:56
bool IsEmpty() const
SAL_DLLPRIVATE void InitLineColor()
void Invert(const tools::Rectangle &rRect, InvertFlags nFlags=InvertFlags::NONE)
Definition: rect.cxx:147
tools::Long Left() const
SAL_DLLPRIVATE tools::Long ImplLogicXToDevicePixel(tools::Long nX) const
Convert a logical X coordinate to a device pixel's X coordinate.
Definition: map.cxx:410
const BorderLinePrimitive2D *pCandidateB assert(pCandidateA)
tools::Long Bottom() const
void Invert(tools::Long nX, tools::Long nY, tools::Long nWidth, tools::Long nHeight, SalInvert nFlags, const OutputDevice *pOutDev)
tools::Long AdjustBottom(tools::Long nVertMoveDelta)
void DrawRect(const tools::Rectangle &rRect)
Definition: rect.cxx:51
void DrawPolyLine(sal_uInt32 nPoints, SalPoint const *pPtAry, const OutputDevice *pOutDev)
float y
void DrawPolygon(sal_uInt32 nPoints, const SalPoint *pPtAry, const OutputDevice *pOutDev)
SalGraphics * mpGraphics
Graphics context to draw on.
Definition: outdev.hxx:314
tools::Long mnDestHeight
Definition: salgtype.hxx:57
void SetLineColor()
SAL_DLLPRIVATE void InitFillColor()
void DrawPixel(tools::Long nX, tools::Long nY, const OutputDevice *pOutDev)
#define nPixel
int i
Point * GetPointAry()
tools::Long FRound(double fVal)
const Point * GetConstPointAry() const
virtual bool AcquireGraphics() const =0
Acquire a graphics device that the output device uses to draw on.
Size GetOutputSize() const
Definition: outdev.hxx:450
bool mbInitLineColor
Definition: outdev.hxx:382
void SetFillColor()
tools::Long Width() const
const ::std::vector< Color > ImpSvNumberformatScan::StandardColor COL_GRAY
SAL_DLLPRIVATE tools::Long ImplLogicWidthToDevicePixel(tools::Long nWidth) const
Convert a logical width to a width in units of device pixels.
Definition: map.cxx:430
BmpMirrorFlags
Definition: bitmap.hxx:37
SalInvert
Definition: salgtype.hxx:84
bool mbLineColor
Definition: outdev.hxx:380
sal_uInt16 GetSize() const
tools::Long Top() const
DrawGridFlags
Definition: outdev.hxx:185
#define Y
tools::Long mnSrcX
Definition: salgtype.hxx:50
tools::Long mnSrcY
Definition: salgtype.hxx:51
tools::Long AdjustTop(tools::Long nVertMoveDelta)
Point PixelToLogic(const Point &rDevicePt) const
Definition: map.cxx:1186
bool mbFillColor
Definition: outdev.hxx:381
VclPtr< VirtualDevice > mpAlphaVDev
Definition: outdev.hxx:329
void AddAction(const rtl::Reference< MetaAction > &pAction)
Definition: gdimtf.cxx:566
bool mbInitClipRegion
Definition: outdev.hxx:386
void DrawGrid(const tools::Rectangle &rRect, const Size &rDist, DrawGridFlags nFlags)
Definition: rect.cxx:235
tools::Long Height() const
virtual void InitClipRegion()
InvertFlags
Definition: outdev.hxx:265
void DrawCheckered(const Point &rPos, const Size &rSize, sal_uInt32 nLen=8, Color aStart=COL_WHITE, Color aEnd=COL_BLACK)
Fill the given rectangle with checkered rectangles of size nLen x nLen using the colors aStart and aE...
Definition: rect.cxx:209
bool mbInitFillColor
Definition: outdev.hxx:383
void DrawLine(tools::Long nX1, tools::Long nY1, tools::Long nX2, tools::Long nY2, const OutputDevice *pOutDev)
SAL_DLLPRIVATE tools::Rectangle ImplLogicToDevicePixel(const tools::Rectangle &rLogicRect) const
Convert a logical rectangle to a rectangle in physical device pixel units.
Definition: map.cxx:504
tools::Long GetHeight() const
tools::Long AdjustLeft(tools::Long nHorzMoveDelta)
SAL_DLLPRIVATE tools::Long ImplLogicYToDevicePixel(tools::Long nY) const
Convert a logical Y coordinate to a device pixel's Y coordinate.
Definition: map.cxx:420
tools::Long mnDestY
Definition: salgtype.hxx:55
bool IsDeviceOutputNecessary() const
Definition: outdev.hxx:601
void Push(PushFlags nFlags=PushFlags::ALL)
Definition: outdevstate.cxx:60
SAL_DLLPRIVATE tools::Long ImplLogicHeightToDevicePixel(tools::Long nHeight) const
Convert a logical height to a height in units of device pixels.
Definition: map.cxx:440
tools::Long Right() const
GDIMetaFile * mpMetaFile
Definition: outdev.hxx:317