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  long nDX, 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  mbScreenComp = true;
162 
165 
166  if ( pOutDev->GetOutDevType() == OUTDEV_PRINTER )
167  mbScreenComp = false;
168  else if ( pOutDev->IsVirtual() )
169  mbScreenComp = static_cast<const VirtualDevice*>(pOutDev)->mbScreenComp;
170 
171  mbDevOutput = true;
174  mnDPIX = pOutDev->mnDPIX;
175  mnDPIY = pOutDev->mnDPIY;
177  maFont = pOutDev->maFont;
178 
179  if( maTextColor != pOutDev->maTextColor )
180  {
181  maTextColor = pOutDev->maTextColor;
182  mbInitTextColor = true;
183  }
184 
185  // virtual devices have white background by default
187 
188  // #i59283# don't erase user-provided surface
189  if( !pData && bErase)
190  Erase();
191 
192  // register VirDev in the list
193  mpNext = pSVData->maGDIData.mpFirstVirDev;
194  mpPrev = nullptr;
195  if ( mpNext )
196  mpNext->mpPrev = this;
197  pSVData->maGDIData.mpFirstVirDev = this;
198 }
199 
201  DeviceFormat eAlphaFormat, OutDevType eOutDevType)
202  : OutputDevice(eOutDevType)
203  , meFormat(eFormat)
204  , meAlphaFormat(eAlphaFormat)
205 {
206  SAL_INFO( "vcl.virdev", "VirtualDevice::VirtualDevice( " << static_cast<int>(eFormat)
207  << ", " << static_cast<int>(eAlphaFormat)
208  << ", " << static_cast<int>(eOutDevType) << " )" );
209 
210  ImplInitVirDev(pCompDev ? pCompDev : Application::GetDefaultDevice(), 0, 0);
211 }
212 
214  DeviceFormat eFormat)
216  , meFormat(eFormat)
217  , meAlphaFormat(DeviceFormat::NONE)
218 {
219  SAL_INFO( "vcl.virdev", "VirtualDevice::VirtualDevice( " << static_cast<int>(eFormat) << " )" );
220 
221  ImplInitVirDev(Application::GetDefaultDevice(), rSize.Width(), rSize.Height(), &rData);
222 }
223 
225 {
226  SAL_INFO( "vcl.virdev", "VirtualDevice::~VirtualDevice()" );
227  disposeOnce();
228 }
229 
231 {
232  SAL_INFO( "vcl.virdev", "VirtualDevice::dispose()" );
233 
234  ImplSVData* pSVData = ImplGetSVData();
235 
236  ReleaseGraphics();
237 
238  mpVirDev.reset();
239 
240  // remove this VirtualDevice from the double-linked global list
241  if( mpPrev )
242  mpPrev->mpNext = mpNext;
243  else
244  pSVData->maGDIData.mpFirstVirDev = mpNext;
245 
246  if( mpNext )
247  mpNext->mpPrev = mpPrev;
248 
250 }
251 
252 bool VirtualDevice::InnerImplSetOutputSizePixel( const Size& rNewSize, bool bErase,
253  sal_uInt8 *const pBuffer)
254 {
255  SAL_INFO( "vcl.virdev",
256  "VirtualDevice::InnerImplSetOutputSizePixel( " << rNewSize.Width() << ", "
257  << rNewSize.Height() << ", " << int(bErase) << " )" );
258 
259  if ( !mpVirDev )
260  return false;
261  else if ( rNewSize == GetOutputSizePixel() )
262  {
263  if ( bErase )
264  Erase();
265  SAL_INFO( "vcl.virdev", "Trying to re-use a VirtualDevice but this time using a pre-allocated buffer");
266  return true;
267  }
268 
269  bool bRet;
270  long nNewWidth = rNewSize.Width(), nNewHeight = rNewSize.Height();
271 
272  if ( nNewWidth < 1 )
273  nNewWidth = 1;
274 
275  if ( nNewHeight < 1 )
276  nNewHeight = 1;
277 
278  if ( bErase )
279  {
280  if ( pBuffer )
281  bRet = mpVirDev->SetSizeUsingBuffer( nNewWidth, nNewHeight, pBuffer );
282  else
283  bRet = mpVirDev->SetSize( nNewWidth, nNewHeight );
284 
285  if ( bRet )
286  {
287  mnOutWidth = rNewSize.Width();
288  mnOutHeight = rNewSize.Height();
289  Erase();
290  }
291  }
292  else
293  {
294  std::unique_ptr<SalVirtualDevice> pNewVirDev;
295  ImplSVData* pSVData = ImplGetSVData();
296 
297  // we need a graphics
298  if ( !mpGraphics && !AcquireGraphics() )
299  return false;
300 
301  pNewVirDev = pSVData->mpDefInst->CreateVirtualDevice(mpGraphics, nNewWidth, nNewHeight, meFormat);
302  if ( pNewVirDev )
303  {
304  SalGraphics* pGraphics = pNewVirDev->AcquireGraphics();
305  if ( pGraphics )
306  {
307  long nWidth;
308  long nHeight;
309  if ( mnOutWidth < nNewWidth )
310  nWidth = mnOutWidth;
311  else
312  nWidth = nNewWidth;
313  if ( mnOutHeight < nNewHeight )
314  nHeight = mnOutHeight;
315  else
316  nHeight = nNewHeight;
317  SalTwoRect aPosAry(0, 0, nWidth, nHeight, 0, 0, nWidth, nHeight);
318  pGraphics->CopyBits( aPosAry, mpGraphics, this, this );
319  pNewVirDev->ReleaseGraphics( pGraphics );
320  ReleaseGraphics();
321  mpVirDev = std::move(pNewVirDev);
322  mnOutWidth = rNewSize.Width();
323  mnOutHeight = rNewSize.Height();
324  bRet = true;
325  }
326  else
327  {
328  bRet = false;
329  }
330  }
331  else
332  bRet = false;
333  }
334 
335  return bRet;
336 }
337 
338 // #i32109#: Fill opaque areas correctly (without relying on
339 // fill/linecolor state)
341 {
342  // Set line and fill color to black (->opaque),
343  // fill rect with that (linecolor, too, because of
344  // those pesky missing pixel problems)
348  DrawRect( rRect );
349  Pop();
350 }
351 
352 bool VirtualDevice::ImplSetOutputSizePixel( const Size& rNewSize, bool bErase,
353  sal_uInt8 *const pBuffer)
354 {
355  if( InnerImplSetOutputSizePixel(rNewSize, bErase, pBuffer) )
356  {
358  {
359  // #110958# Setup alpha bitmap
360  if(mpAlphaVDev && mpAlphaVDev->GetOutputSizePixel() != rNewSize)
361  {
363  }
364 
365  if( !mpAlphaVDev )
366  {
368  mpAlphaVDev->InnerImplSetOutputSizePixel(rNewSize, bErase, nullptr);
369  }
370 
371  // TODO: copy full outdev state to new one, here. Also needed in outdev2.cxx:DrawOutDev
372  if( GetLineColor() != COL_TRANSPARENT )
374 
375  if( GetFillColor() != COL_TRANSPARENT )
377 
379  }
380 
381  return true;
382  }
383 
384  return false;
385 }
386 
387 void VirtualDevice::EnableRTL( bool bEnable )
388 {
389  // virdevs default to not mirroring, they will only be set to mirroring
390  // under rare circumstances in the UI, eg the valueset control
391  // because each virdev has its own SalGraphics we can safely switch the SalGraphics here
392  // ...hopefully
393  if( AcquireGraphics() )
395 
396  OutputDevice::EnableRTL(bEnable);
397 }
398 
399 bool VirtualDevice::SetOutputSizePixel( const Size& rNewSize, bool bErase )
400 {
401  return ImplSetOutputSizePixel(rNewSize, bErase, nullptr);
402 }
403 
405  const Size& rNewSize, const Fraction& rScale, const Point& rNewOffset,
406  sal_uInt8 *const pBuffer)
407 {
408  if (pBuffer) {
409  MapMode mm = GetMapMode();
410  mm.SetOrigin( rNewOffset );
411  mm.SetScaleX( rScale );
412  mm.SetScaleY( rScale );
413  SetMapMode( mm );
414  }
415  return ImplSetOutputSizePixel(rNewSize, true, pBuffer);
416 }
417 
419 {
420  sal_Int32 nDPIX = 600, nDPIY = 600;
421  switch( i_eRefDevMode )
422  {
423  case RefDevMode::NONE:
424  default:
425  SAL_WARN( "vcl.virdev", "VDev::SetRefDev illegal argument!" );
426  break;
427  case RefDevMode::Dpi600:
428  nDPIX = nDPIY = 600;
429  break;
430  case RefDevMode::MSO1:
431  nDPIX = nDPIY = 6*1440;
432  break;
433  case RefDevMode::PDF1:
434  nDPIX = nDPIY = 720;
435  break;
436  }
437  ImplSetReferenceDevice( i_eRefDevMode, nDPIX, nDPIY );
438 }
439 
440 void VirtualDevice::SetReferenceDevice( sal_Int32 i_nDPIX, sal_Int32 i_nDPIY )
441 {
442  ImplSetReferenceDevice( RefDevMode::Custom, i_nDPIX, i_nDPIY );
443 }
444 
446 {
447  return true;
448 }
449 
450 void VirtualDevice::ImplSetReferenceDevice( RefDevMode i_eRefDevMode, sal_Int32 i_nDPIX, sal_Int32 i_nDPIY )
451 {
452  mnDPIX = i_nDPIX;
453  mnDPIY = i_nDPIY;
454  mnDPIScalePercentage = 100;
455 
456  EnableOutput( false ); // prevent output on reference device
457  mbScreenComp = false;
458 
459  // invalidate currently selected fonts
460  mbInitFont = true;
461  mbNewFont = true;
462 
463  // avoid adjusting font lists when already in refdev mode
464  RefDevMode nOldRefDevMode = meRefDevMode;
465  meRefDevMode = i_eRefDevMode;
466  if( nOldRefDevMode != RefDevMode::NONE )
467  return;
468 
469  // the reference device should have only scalable fonts
470  // => clean up the original font lists before getting new ones
471  mpFontInstance.clear();
472  mpDeviceFontList.reset();
473  mpDeviceFontSizeList.reset();
474 
475  // preserve global font lists
476  ImplSVData* pSVData = ImplGetSVData();
477  mxFontCollection.reset();
478  mxFontCache.reset();
479 
480  // get font list with scalable fonts only
482  mxFontCollection = pSVData->maGDIData.mxScreenFontList->Clone();
483 
484  // prepare to use new font lists
485  mxFontCache.reset(new ImplFontCache);
486 }
487 
488 sal_uInt16 VirtualDevice::GetBitCount() const
489 {
490  return mnBitCount;
491 }
492 
494 {
495  return true;
496 }
497 
499 {
500  mbForceZeroExtleadBug = true;
501 }
502 
504 {
505 #ifdef UNX
506  // backwards compatible line metrics after fixing #i60945#
507  if ( mbForceZeroExtleadBug )
508  return 0;
509 #endif
510 
511  return mpFontInstance->mxFontMetric->GetExternalLeading();
512 }
513 
514 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
void EnableOutput(bool bEnable=true)
long Width() const
OutDevType GetOutDevType() const
Definition: outdev.hxx:522
sal_Int32 mnDPIScalePercentage
For HiDPI displays, we want to draw elements for a percentage larger.
Definition: outdev.hxx:349
void Compat_ZeroExtleadBug()
Definition: virdev.cxx:498
const DeviceFormat meFormat
Definition: virdev.hxx:53
VclPtr< OutputDevice > mpNextGraphics
Next output device in list.
Definition: outdev.hxx:318
virtual long GetFontExtLeading() const override
Definition: virdev.cxx:503
virtual bool UsePolyPolygonForComplexGradient() override
Definition: virdev.cxx:493
void SetReferenceDevice(RefDevMode)
Definition: virdev.cxx:418
constexpr::Color COL_BLACK(0x00, 0x00, 0x00)
virtual ~VirtualDevice() override
Definition: virdev.cxx:224
void SetAntialiasing(AntialiasingFlags nMode)
virtual bool IsVirtual() const
Definition: outdev.cxx:183
Color maTextColor
Definition: outdev.hxx:365
VclPtr< VirtualDevice > mpNext
Definition: virdev.hxx:50
long Height() const
void disposeAndClear()
Definition: vclptr.hxx:200
VclPtr< OutputDevice > mpLastVirGraphics
Definition: svdata.hxx:175
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:322
const MapMode & GetMapMode() const
Definition: outdev.hxx:1674
SAL_DLLPRIVATE void ImplInitVirDev(const OutputDevice *pOutDev, long nDX, long nDY, const SystemGraphicsData *pData=nullptr)
Definition: virdev.cxx:111
sal_Int32 mnDPIY
Definition: outdev.hxx:348
std::unique_ptr< ImplDeviceFontSizeList > mpDeviceFontSizeList
Definition: outdev.hxx:324
sal_Int32 mnDPIX
Definition: outdev.hxx:347
const DeviceFormat meAlphaFormat
Definition: virdev.hxx:54
void SetMapMode()
Definition: map.cxx:655
ImplSVGDIData maGDIData
Definition: svdata.hxx:348
virtual void dispose() override
Definition: virdev.cxx:230
static OutputDevice * GetDefaultDevice()
Get the default "device" (in this case the default window).
Definition: svapp.cxx:1054
constexpr::Color COL_TRANSPARENT(0xFF, 0xFF, 0xFF, 0xFF)
void SetBackground()
VirtualDevice(const VirtualDevice &)=delete
AntialiasingFlags mnAntialiasing
Definition: outdev.hxx:373
bool mbScreenComp
Definition: virdev.hxx:52
VclPtr< VirtualDevice > mpFirstVirDev
Definition: svdata.hxx:178
virtual void EnableRTL(bool bEnable=true)
Definition: outdev.cxx:596
void DrawRect(const tools::Rectangle &rRect)
Definition: rect.cxx:32
SalGraphics * mpGraphics
Graphics context to draw on.
Definition: outdev.hxx:316
ImplSVData * ImplGetSVData()
Definition: svdata.cxx:67
NONE
void SetLineColor()
void SetScaleX(const Fraction &rScaleX)
Definition: mapmod.cxx:108
virtual std::unique_ptr< SalVirtualDevice > CreateVirtualDevice(SalGraphics *pGraphics, long &rDX, long &rDY, DeviceFormat eFormat, const SystemGraphicsData *pData=nullptr)=0
OutDevType
Definition: outdev.hxx:278
virtual void dispose() override
Definition: outdev.cxx:141
SAL_DLLPRIVATE bool ImplSetOutputSizePixel(const Size &rNewSize, bool bErase, sal_uInt8 *pBuffer)
Definition: virdev.cxx:352
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:323
virtual void EnableRTL(bool bEnable=true) override
Definition: virdev.cxx:387
bool SetOutputSizePixel(const Size &rNewSize, bool bErase=true)
Definition: virdev.cxx:399
void SetOrigin(const Point &rOrigin)
Definition: mapmod.cxx:102
bool mbInitLineColor
Definition: outdev.hxx:384
void SetFillColor()
bool mbNewFont
Definition: outdev.hxx:390
Some things multiple-inherit from VclAbstractDialog and OutputDevice, so we need to use virtual inher...
Definition: outdev.hxx:304
const Color & GetLineColor() const
Definition: outdev.hxx:618
SAL_DLLPRIVATE void ImplFillOpaqueRectangle(const tools::Rectangle &rRect)
Used for alpha VDev, to set areas to opaque.
Definition: virdev.cxx:340
std::unique_ptr< SalVirtualDevice > mpVirDev
Definition: virdev.hxx:48
void SetScaleY(const Fraction &rScaleY)
Definition: mapmod.cxx:115
vcl::Font maFont
Definition: outdev.hxx:364
RasterOp meRasterOp
Definition: outdev.hxx:368
virtual sal_uInt16 GetBitCount() const override
Definition: virdev.cxx:488
Size GetOutputSizePixel() const
Definition: outdev.hxx:441
sal_uInt16 mnBitCount
Definition: virdev.hxx:51
bool mbInitTextColor
Definition: outdev.hxx:387
bool mbForceZeroExtleadBug
Definition: virdev.hxx:56
virtual sal_uInt16 GetBitCount() const
Definition: outdev.cxx:305
SAL_DLLPRIVATE bool InnerImplSetOutputSizePixel(const Size &rNewSize, bool bErase, sal_uInt8 *pBuffer)
Definition: virdev.cxx:252
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:317
DeviceFormat
Definition: salgtype.hxx:28
VclPtr< VirtualDevice > mpPrev
Definition: virdev.hxx:49
VclPtr< VirtualDevice > mpAlphaVDev
Definition: outdev.hxx:331
void Erase()
Definition: wallpaper.cxx:103
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:388
#define SAL_INFO(area, stream)
VclPtr< OutputDevice > mpFirstVirGraphics
Definition: svdata.hxx:174
static VclPtr< reference_type > Create(Arg &&...arg)
A construction helper for VclPtr.
Definition: vclptr.hxx:127
std::shared_ptr< ImplFontCache > mxScreenFontCache
Definition: svdata.hxx:183
bool IsVirtual() const override
Definition: virdev.cxx:445
void setAntiAliasB2DDraw(bool bNew)
Definition: salgdi.hxx:84
bool mbInitFont
Definition: outdev.hxx:386
constexpr::Color COL_WHITE(0xFF, 0xFF, 0xFF)
rtl::Reference< LogicalFontInstance > mpFontInstance
Definition: outdev.hxx:320
bool mbInitFillColor
Definition: outdev.hxx:385
SAL_DLLPRIVATE void ImplSetReferenceDevice(RefDevMode, sal_Int32 i_nDPIX, sal_Int32 i_nDPIY)
Definition: virdev.cxx:450
long mnOutWidth
Definition: outdev.hxx:345
bool mbDevOutput
Definition: outdev.hxx:380
bool SetOutputSizePixelScaleOffsetAndBuffer(const Size &rNewSize, const Fraction &rScale, const Point &rNewOffset, sal_uInt8 *pBuffer)
Definition: virdev.cxx:404
void SetLayout(SalLayoutFlags aLayout)
Definition: salgdi.hxx:201
std::shared_ptr< ImplFontCache > mxFontCache
Definition: outdev.hxx:321
#define SAL_WARN(area, stream)
#define DBG_TESTSOLARMUTEX()
long mnOutHeight
Definition: outdev.hxx:346
vcl::Window * ImplGetDefaultWindow()
Returns either the application window, or the default GL context window.
Definition: svdata.cxx:202
void Push(PushFlags nFlags=PushFlags::ALL)
Definition: outdevstate.cxx:60
virtual void ImplReleaseFonts()
std::shared_ptr< PhysicalFontCollection > mxScreenFontList
Definition: svdata.hxx:182
SalInstance * mpDefInst
Definition: svdata.hxx:336
const Color & GetFillColor() const
Definition: outdev.hxx:623
typedef void(CALLTYPE *GetFuncDataPtr)(sal_uInt16 &nNo