LibreOffice Module vcl (master)  1
virdev.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 <salinst.hxx>
21 #include <salgdi.hxx>
22 #include <salvd.hxx>
23 #include <outdev.h>
25 #include <svdata.hxx>
26 #include <vcl/virdev.hxx>
27 #include <sal/log.hxx>
28 #include <tools/debug.hxx>
29 
30 using namespace ::com::sun::star::uno;
31 
33 {
35 
36  if ( mpGraphics )
37  return true;
38 
39  mbInitLineColor = true;
40  mbInitFillColor = true;
41  mbInitFont = true;
42  mbInitTextColor = true;
43  mbInitClipRegion = true;
44 
45  ImplSVData* pSVData = ImplGetSVData();
46 
47  if ( mpVirDev )
48  {
49  mpGraphics = mpVirDev->AcquireGraphics();
50  // if needed retry after releasing least recently used virtual device graphics
51  while ( !mpGraphics )
52  {
53  if ( !pSVData->maGDIData.mpLastVirGraphics )
54  break;
56  mpGraphics = mpVirDev->AcquireGraphics();
57  }
58  // update global LRU list of virtual device graphics
59  if ( mpGraphics )
60  {
62  pSVData->maGDIData.mpFirstVirGraphics = const_cast<VirtualDevice*>(this);
63  if ( mpNextGraphics )
64  mpNextGraphics->mpPrevGraphics = const_cast<VirtualDevice*>(this);
65  if ( !pSVData->maGDIData.mpLastVirGraphics )
66  pSVData->maGDIData.mpLastVirGraphics = const_cast<VirtualDevice*>(this);
67  }
68  }
69 
70  if ( mpGraphics )
71  {
74  }
75 
76  return mpGraphics != nullptr;
77 }
78 
79 void VirtualDevice::ReleaseGraphics( bool bRelease )
80 {
82 
83  if ( !mpGraphics )
84  return;
85 
86  // release the fonts of the physically released graphics device
87  if ( bRelease )
89 
90  ImplSVData* pSVData = ImplGetSVData();
91 
92  VirtualDevice* pVirDev = this;
93 
94  if ( bRelease )
95  pVirDev->mpVirDev->ReleaseGraphics( mpGraphics );
96  // remove from global LRU list of virtual device graphics
97  if ( mpPrevGraphics )
99  else
101  if ( mpNextGraphics )
103  else
105 
106  mpGraphics = nullptr;
107  mpPrevGraphics = nullptr;
108  mpNextGraphics = nullptr;
109 }
110 
112  tools::Long nDX, tools::Long nDY, const SystemGraphicsData *pData )
113 {
114  SAL_INFO( "vcl.virdev", "ImplInitVirDev(" << nDX << "," << nDY << ")" );
115 
117  mbForceZeroExtleadBug = false;
118 
119  bool bErase = nDX > 0 && nDY > 0;
120 
121  if ( nDX < 1 )
122  nDX = 1;
123 
124  if ( nDY < 1 )
125  nDY = 1;
126 
127  ImplSVData* pSVData = ImplGetSVData();
128 
129  if ( !pOutDev )
130  pOutDev = ImplGetDefaultWindow();
131  if( !pOutDev )
132  return;
133 
134  SalGraphics* pGraphics;
135  if ( !pOutDev->mpGraphics )
136  (void)pOutDev->AcquireGraphics();
137  pGraphics = pOutDev->mpGraphics;
138  if ( pGraphics )
139  mpVirDev = pSVData->mpDefInst->CreateVirtualDevice(pGraphics, nDX, nDY, meFormat, pData);
140  else
141  mpVirDev = nullptr;
142  if ( !mpVirDev )
143  {
144  // do not abort but throw an exception, may be the current thread terminates anyway (plugin-scenario)
145  throw css::uno::RuntimeException(
146  "Could not create system bitmap!",
147  css::uno::Reference< css::uno::XInterface >() );
148  }
149 
150  switch (meFormat)
151  {
153  mnBitCount = 1;
154  break;
155  default:
156  mnBitCount = pOutDev->GetBitCount();
157  break;
158  }
159  mnOutWidth = nDX;
160  mnOutHeight = nDY;
161 
164 
165  mbScreenComp = pOutDev->IsScreenComp();
166 
167  mbDevOutput = true;
170  mnDPIX = pOutDev->mnDPIX;
171  mnDPIY = pOutDev->mnDPIY;
173  maFont = pOutDev->maFont;
174 
175  if( maTextColor != pOutDev->maTextColor )
176  {
177  maTextColor = pOutDev->maTextColor;
178  mbInitTextColor = true;
179  }
180 
181  // virtual devices have white background by default
183 
184  // #i59283# don't erase user-provided surface
185  if( !pData && bErase)
186  Erase();
187 
188  // register VirDev in the list
189  mpNext = pSVData->maGDIData.mpFirstVirDev;
190  mpPrev = nullptr;
191  if ( mpNext )
192  mpNext->mpPrev = this;
193  pSVData->maGDIData.mpFirstVirDev = this;
194 }
195 
197  DeviceFormat eAlphaFormat, OutDevType eOutDevType)
198  : OutputDevice(eOutDevType)
199  , meFormat(eFormat)
200  , meAlphaFormat(eAlphaFormat)
201 {
202  SAL_INFO( "vcl.virdev", "VirtualDevice::VirtualDevice( " << static_cast<int>(eFormat)
203  << ", " << static_cast<int>(eAlphaFormat)
204  << ", " << static_cast<int>(eOutDevType) << " )" );
205 
206  ImplInitVirDev(pCompDev ? pCompDev : Application::GetDefaultDevice(), 0, 0);
207 }
208 
210  DeviceFormat eFormat)
212  , meFormat(eFormat)
213  , meAlphaFormat(DeviceFormat::NONE)
214 {
215  SAL_INFO( "vcl.virdev", "VirtualDevice::VirtualDevice( " << static_cast<int>(eFormat) << " )" );
216 
217  ImplInitVirDev(Application::GetDefaultDevice(), rSize.Width(), rSize.Height(), &rData);
218 }
219 
221 {
222  SAL_INFO( "vcl.virdev", "VirtualDevice::~VirtualDevice()" );
223  disposeOnce();
224 }
225 
227 {
228  SAL_INFO( "vcl.virdev", "VirtualDevice::dispose()" );
229 
230  ImplSVData* pSVData = ImplGetSVData();
231 
232  ReleaseGraphics();
233 
234  mpVirDev.reset();
235 
236  // remove this VirtualDevice from the double-linked global list
237  if( mpPrev )
238  mpPrev->mpNext = mpNext;
239  else
240  pSVData->maGDIData.mpFirstVirDev = mpNext;
241 
242  if( mpNext )
243  mpNext->mpPrev = mpPrev;
244 
246 }
247 
248 bool VirtualDevice::InnerImplSetOutputSizePixel( const Size& rNewSize, bool bErase,
249  sal_uInt8 *const pBuffer)
250 {
251  SAL_INFO( "vcl.virdev",
252  "VirtualDevice::InnerImplSetOutputSizePixel( " << rNewSize.Width() << ", "
253  << rNewSize.Height() << ", " << int(bErase) << " )" );
254 
255  if ( !mpVirDev )
256  return false;
257  else if ( rNewSize == GetOutputSizePixel() )
258  {
259  if ( bErase )
260  Erase();
261  SAL_INFO( "vcl.virdev", "Trying to re-use a VirtualDevice but this time using a pre-allocated buffer");
262  return true;
263  }
264 
265  bool bRet;
266  tools::Long nNewWidth = rNewSize.Width(), nNewHeight = rNewSize.Height();
267 
268  if ( nNewWidth < 1 )
269  nNewWidth = 1;
270 
271  if ( nNewHeight < 1 )
272  nNewHeight = 1;
273 
274  if ( bErase )
275  {
276  if ( pBuffer )
277  bRet = mpVirDev->SetSizeUsingBuffer( nNewWidth, nNewHeight, pBuffer );
278  else
279  bRet = mpVirDev->SetSize( nNewWidth, nNewHeight );
280 
281  if ( bRet )
282  {
283  mnOutWidth = rNewSize.Width();
284  mnOutHeight = rNewSize.Height();
285  Erase();
286  }
287  }
288  else
289  {
290  std::unique_ptr<SalVirtualDevice> pNewVirDev;
291  ImplSVData* pSVData = ImplGetSVData();
292 
293  // we need a graphics
294  if ( !mpGraphics && !AcquireGraphics() )
295  return false;
296 
297  pNewVirDev = pSVData->mpDefInst->CreateVirtualDevice(mpGraphics, nNewWidth, nNewHeight, meFormat);
298  if ( pNewVirDev )
299  {
300  SalGraphics* pGraphics = pNewVirDev->AcquireGraphics();
301  if ( pGraphics )
302  {
303  tools::Long nWidth;
304  tools::Long nHeight;
305  if ( mnOutWidth < nNewWidth )
306  nWidth = mnOutWidth;
307  else
308  nWidth = nNewWidth;
309  if ( mnOutHeight < nNewHeight )
310  nHeight = mnOutHeight;
311  else
312  nHeight = nNewHeight;
313  SalTwoRect aPosAry(0, 0, nWidth, nHeight, 0, 0, nWidth, nHeight);
314  pGraphics->CopyBits( aPosAry, mpGraphics, this, this );
315  pNewVirDev->ReleaseGraphics( pGraphics );
316  ReleaseGraphics();
317  mpVirDev = std::move(pNewVirDev);
318  mnOutWidth = rNewSize.Width();
319  mnOutHeight = rNewSize.Height();
320  bRet = true;
321  }
322  else
323  {
324  bRet = false;
325  }
326  }
327  else
328  bRet = false;
329  }
330 
331  return bRet;
332 }
333 
334 // #i32109#: Fill opaque areas correctly (without relying on
335 // fill/linecolor state)
337 {
338  // Set line and fill color to black (->opaque),
339  // fill rect with that (linecolor, too, because of
340  // those pesky missing pixel problems)
344  DrawRect( rRect );
345  Pop();
346 }
347 
348 bool VirtualDevice::ImplSetOutputSizePixel( const Size& rNewSize, bool bErase,
349  sal_uInt8 *const pBuffer)
350 {
351  if( InnerImplSetOutputSizePixel(rNewSize, bErase, pBuffer) )
352  {
354  {
355  // #110958# Setup alpha bitmap
356  if(mpAlphaVDev && mpAlphaVDev->GetOutputSizePixel() != rNewSize)
357  {
359  }
360 
361  if( !mpAlphaVDev )
362  {
364  mpAlphaVDev->InnerImplSetOutputSizePixel(rNewSize, bErase, nullptr);
365  }
366 
367  // TODO: copy full outdev state to new one, here. Also needed in outdev2.cxx:DrawOutDev
368  if( GetLineColor() != COL_TRANSPARENT )
370 
371  if( GetFillColor() != COL_TRANSPARENT )
373 
375  }
376 
377  return true;
378  }
379 
380  return false;
381 }
382 
383 void VirtualDevice::EnableRTL( bool bEnable )
384 {
385  // virdevs default to not mirroring, they will only be set to mirroring
386  // under rare circumstances in the UI, eg the valueset control
387  // because each virdev has its own SalGraphics we can safely switch the SalGraphics here
388  // ...hopefully
389  if( AcquireGraphics() )
391 
392  OutputDevice::EnableRTL(bEnable);
393 }
394 
395 bool VirtualDevice::SetOutputSizePixel( const Size& rNewSize, bool bErase )
396 {
397  return ImplSetOutputSizePixel(rNewSize, bErase, nullptr);
398 }
399 
401  const Size& rNewSize, const Fraction& rScale, const Point& rNewOffset,
402  sal_uInt8 *const pBuffer)
403 {
404  if (pBuffer) {
405  MapMode mm = GetMapMode();
406  mm.SetOrigin( rNewOffset );
407  mm.SetScaleX( rScale );
408  mm.SetScaleY( rScale );
409  SetMapMode( mm );
410  }
411  return ImplSetOutputSizePixel(rNewSize, true, pBuffer);
412 }
413 
415 {
416  sal_Int32 nDPIX = 600, nDPIY = 600;
417  switch( i_eRefDevMode )
418  {
419  case RefDevMode::NONE:
420  default:
421  SAL_WARN( "vcl.virdev", "VDev::SetRefDev illegal argument!" );
422  break;
423  case RefDevMode::Dpi600:
424  nDPIX = nDPIY = 600;
425  break;
426  case RefDevMode::MSO1:
427  nDPIX = nDPIY = 6*1440;
428  break;
429  case RefDevMode::PDF1:
430  nDPIX = nDPIY = 720;
431  break;
432  }
433  ImplSetReferenceDevice( i_eRefDevMode, nDPIX, nDPIY );
434 }
435 
436 void VirtualDevice::SetReferenceDevice( sal_Int32 i_nDPIX, sal_Int32 i_nDPIY )
437 {
438  ImplSetReferenceDevice( RefDevMode::Custom, i_nDPIX, i_nDPIY );
439 }
440 
442 {
443  return true;
444 }
445 
446 void VirtualDevice::ImplSetReferenceDevice( RefDevMode i_eRefDevMode, sal_Int32 i_nDPIX, sal_Int32 i_nDPIY )
447 {
448  mnDPIX = i_nDPIX;
449  mnDPIY = i_nDPIY;
450  mnDPIScalePercentage = 100;
451 
452  EnableOutput( false ); // prevent output on reference device
453  mbScreenComp = false;
454 
455  // invalidate currently selected fonts
456  mbInitFont = true;
457  mbNewFont = true;
458 
459  // avoid adjusting font lists when already in refdev mode
460  RefDevMode nOldRefDevMode = meRefDevMode;
461  meRefDevMode = i_eRefDevMode;
462  if( nOldRefDevMode != RefDevMode::NONE )
463  return;
464 
465  // the reference device should have only scalable fonts
466  // => clean up the original font lists before getting new ones
467  mpFontInstance.clear();
468  mpDeviceFontList.reset();
469  mpDeviceFontSizeList.reset();
470 
471  // preserve global font lists
472  ImplSVData* pSVData = ImplGetSVData();
473  mxFontCollection.reset();
474  mxFontCache.reset();
475 
476  // get font list with scalable fonts only
478  mxFontCollection = pSVData->maGDIData.mxScreenFontList->Clone();
479 
480  // prepare to use new font lists
481  mxFontCache = std::make_shared<ImplFontCache>();
482 }
483 
484 sal_uInt16 VirtualDevice::GetBitCount() const
485 {
486  return mnBitCount;
487 }
488 
490 {
491  return true;
492 }
493 
495 {
496  mbForceZeroExtleadBug = true;
497 }
498 
500 {
501 #ifdef UNX
502  // backwards compatible line metrics after fixing #i60945#
503  if ( mbForceZeroExtleadBug )
504  return 0;
505 #endif
506 
507  return mpFontInstance->mxFontMetric->GetExternalLeading();
508 }
509 
510 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
void EnableOutput(bool bEnable=true)
sal_Int32 mnDPIScalePercentage
For HiDPI displays, we want to draw elements for a percentage larger.
Definition: outdev.hxx:347
void Compat_ZeroExtleadBug()
Definition: virdev.cxx:494
const DeviceFormat meFormat
Definition: virdev.hxx:53
VclPtr< OutputDevice > mpNextGraphics
Next output device in list.
Definition: outdev.hxx:316
virtual bool UsePolyPolygonForComplexGradient() override
Definition: virdev.cxx:489
void SetReferenceDevice(RefDevMode)
Definition: virdev.cxx:414
virtual ~VirtualDevice() override
Definition: virdev.cxx:220
void SetAntialiasing(AntialiasingFlags nMode)
Color maTextColor
Definition: outdev.hxx:362
VclPtr< VirtualDevice > mpNext
Definition: virdev.hxx:50
long Long
void disposeAndClear()
Definition: vclptr.hxx:200
VclPtr< OutputDevice > mpLastVirGraphics
Definition: svdata.hxx:214
const wchar_t *typedef int(__stdcall *DllNativeUnregProc)(int
virtual bool AcquireGraphics() const override
Acquire a graphics device that the output device uses to draw on.
Definition: virdev.cxx:32
void CopyBits(const SalTwoRect &rPosAry, SalGraphics *pSrcGraphics, const OutputDevice *pOutDev, const OutputDevice *pSrcOutDev)
std::shared_ptr< PhysicalFontCollection > mxFontCollection
Definition: outdev.hxx:320
const MapMode & GetMapMode() const
Definition: outdev.hxx:1681
sal_Int32 mnDPIY
Definition: outdev.hxx:346
std::unique_ptr< ImplDeviceFontSizeList > mpDeviceFontSizeList
Definition: outdev.hxx:322
sal_Int32 mnDPIX
Definition: outdev.hxx:345
const DeviceFormat meAlphaFormat
Definition: virdev.hxx:54
void SetMapMode()
Definition: map.cxx:546
ImplSVGDIData maGDIData
Definition: svdata.hxx:390
NONE
virtual void dispose() override
Definition: virdev.cxx:226
static OutputDevice * GetDefaultDevice()
Get the default "device" (in this case the default window).
Definition: svapp.cxx:1047
constexpr::Color COL_TRANSPARENT(0xFF, 0xFF, 0xFF, 0xFF)
void SetBackground()
VirtualDevice(const VirtualDevice &)=delete
AntialiasingFlags mnAntialiasing
Definition: outdev.hxx:370
bool mbScreenComp
Definition: virdev.hxx:52
VclPtr< VirtualDevice > mpFirstVirDev
Definition: svdata.hxx:217
virtual void EnableRTL(bool bEnable=true)
Definition: outdev.cxx:575
virtual tools::Long GetFontExtLeading() const override
Definition: virdev.cxx:499
void DrawRect(const tools::Rectangle &rRect)
Definition: rect.cxx:51
SalGraphics * mpGraphics
Graphics context to draw on.
Definition: outdev.hxx:314
ImplSVData * ImplGetSVData()
Definition: svdata.cxx:76
void SetLineColor()
void SetScaleX(const Fraction &rScaleX)
Definition: mapmod.cxx:108
OutDevType
Definition: outdev.hxx:276
virtual void dispose() override
Definition: outdev.cxx:136
SAL_DLLPRIVATE bool ImplSetOutputSizePixel(const Size &rNewSize, bool bErase, sal_uInt8 *pBuffer)
Definition: virdev.cxx:348
SAL_DLLPRIVATE void ImplInitVirDev(const OutputDevice *pOutDev, tools::Long nDX, tools::Long nDY, const SystemGraphicsData *pData=nullptr)
Definition: virdev.cxx:111
virtual bool AcquireGraphics() const =0
Acquire a graphics device that the output device uses to draw on.
std::unique_ptr< ImplDeviceFontList > mpDeviceFontList
Definition: outdev.hxx:321
virtual void EnableRTL(bool bEnable=true) override
Definition: virdev.cxx:383
bool SetOutputSizePixel(const Size &rNewSize, bool bErase=true)
Definition: virdev.cxx:395
void SetOrigin(const Point &rOrigin)
Definition: mapmod.cxx:102
bool mbInitLineColor
Definition: outdev.hxx:381
void SetFillColor()
tools::Long mnOutHeight
Definition: outdev.hxx:344
bool mbNewFont
Definition: outdev.hxx:387
tools::Long Width() const
Some things multiple-inherit from VclAbstractDialog and OutputDevice, so we need to use virtual inher...
Definition: outdev.hxx:302
const Color & GetLineColor() const
Definition: outdev.hxx:629
SAL_DLLPRIVATE void ImplFillOpaqueRectangle(const tools::Rectangle &rRect)
Used for alpha VDev, to set areas to opaque.
Definition: virdev.cxx:336
std::unique_ptr< SalVirtualDevice > mpVirDev
Definition: virdev.hxx:48
void SetScaleY(const Fraction &rScaleY)
Definition: mapmod.cxx:115
vcl::Font maFont
Definition: outdev.hxx:361
RasterOp meRasterOp
Definition: outdev.hxx:365
virtual sal_uInt16 GetBitCount() const override
Definition: virdev.cxx:484
Size GetOutputSizePixel() const
Definition: outdev.hxx:440
sal_uInt16 mnBitCount
Definition: virdev.hxx:51
bool mbInitTextColor
Definition: outdev.hxx:384
bool mbForceZeroExtleadBug
Definition: virdev.hxx:56
virtual sal_uInt16 GetBitCount() const
Definition: outdev.cxx:300
SAL_DLLPRIVATE bool InnerImplSetOutputSizePixel(const Size &rNewSize, bool bErase, sal_uInt8 *pBuffer)
Definition: virdev.cxx:248
virtual void ReleaseGraphics(bool bRelease=true) override
Release the graphics device, and remove it from the graphics device list.
Definition: virdev.cxx:79
RefDevMode meRefDevMode
Definition: virdev.hxx:55
virtual void SetXORMode(bool bSet, bool bInvertOnly)=0
VclPtr< OutputDevice > mpPrevGraphics
Previous output device in list.
Definition: outdev.hxx:315
DeviceFormat
Definition: salgtype.hxx:28
void setAntiAlias(bool bNew)
Definition: salgdi.hxx:86
VclPtr< VirtualDevice > mpPrev
Definition: virdev.hxx:49
VclPtr< VirtualDevice > mpAlphaVDev
Definition: outdev.hxx:329
void Erase()
Definition: wallpaper.cxx:103
virtual std::unique_ptr< SalVirtualDevice > CreateVirtualDevice(SalGraphics *pGraphics, tools::Long &rDX, tools::Long &rDY, DeviceFormat eFormat, const SystemGraphicsData *pData=nullptr)=0
virtual void ReleaseGraphics(bool bRelease=true)=0
Release the graphics device, and remove it from the graphics device list.
unsigned char sal_uInt8
bool mbInitClipRegion
Definition: outdev.hxx:385
const ::std::vector< Color > ImpSvNumberformatScan::StandardColor COL_WHITE
#define SAL_INFO(area, stream)
VclPtr< OutputDevice > mpFirstVirGraphics
Definition: svdata.hxx:213
static VclPtr< reference_type > Create(Arg &&...arg)
A construction helper for VclPtr.
Definition: vclptr.hxx:127
std::shared_ptr< ImplFontCache > mxScreenFontCache
Definition: svdata.hxx:222
bool IsVirtual() const override
Definition: virdev.cxx:441
tools::Long Height() const
const ::std::vector< Color > ImpSvNumberformatScan::StandardColor COL_BLACK
bool mbInitFont
Definition: outdev.hxx:383
rtl::Reference< LogicalFontInstance > mpFontInstance
Definition: outdev.hxx:318
bool mbInitFillColor
Definition: outdev.hxx:382
tools::Long mnOutWidth
Definition: outdev.hxx:343
SAL_DLLPRIVATE void ImplSetReferenceDevice(RefDevMode, sal_Int32 i_nDPIX, sal_Int32 i_nDPIY)
Definition: virdev.cxx:446
bool mbDevOutput
Definition: outdev.hxx:377
bool SetOutputSizePixelScaleOffsetAndBuffer(const Size &rNewSize, const Fraction &rScale, const Point &rNewOffset, sal_uInt8 *pBuffer)
Definition: virdev.cxx:400
void SetLayout(SalLayoutFlags aLayout)
Definition: salgdi.hxx:203
std::shared_ptr< ImplFontCache > mxFontCache
Definition: outdev.hxx:319
#define SAL_WARN(area, stream)
#define DBG_TESTSOLARMUTEX()
vcl::Window * ImplGetDefaultWindow()
Returns either the application window, or the default GL context window.
Definition: svdata.cxx:211
void Push(PushFlags nFlags=PushFlags::ALL)
Definition: outdevstate.cxx:60
virtual void ImplReleaseFonts()
std::shared_ptr< PhysicalFontCollection > mxScreenFontList
Definition: svdata.hxx:221
SalInstance * mpDefInst
Definition: svdata.hxx:381
virtual bool IsScreenComp() const
Definition: outdev.hxx:436
const Color & GetFillColor() const
Definition: outdev.hxx:634
typedef void(CALLTYPE *GetFuncDataPtr)(sal_uInt16 &nNo