LibreOffice Module svx (master)  1
svdfmtf.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 "svdfmtf.hxx"
21 #include <math.h>
22 #include <editeng/eeitem.hxx>
23 #include <editeng/fhgtitem.hxx>
24 #include <editeng/wghtitem.hxx>
25 #include <editeng/postitem.hxx>
26 #include <editeng/udlnitem.hxx>
27 #include <editeng/crossedoutitem.hxx>
28 #include <editeng/shdditem.hxx>
29 #include <svx/xlineit0.hxx>
30 #include <svx/xlnclit.hxx>
31 #include <svx/xlncapit.hxx>
32 #include <svx/xlnwtit.hxx>
33 #include <svx/xfillit0.hxx>
34 #include <svx/xflclit.hxx>
35 #include <svx/xgrad.hxx>
36 #include <svx/xflgrit.hxx>
37 #include <editeng/fontitem.hxx>
38 #include <editeng/wrlmitem.hxx>
39 #include <editeng/contouritem.hxx>
40 #include <editeng/colritem.hxx>
41 #include <vcl/canvastools.hxx>
42 #include <vcl/metric.hxx>
43 #include <editeng/charscaleitem.hxx>
44 #include <svx/xflhtit.hxx>
45 #include <svx/sdmetitm.hxx>
46 #include <svx/sdtagitm.hxx>
47 #include <svx/sdtaitm.hxx>
48 #include <svx/sdtditm.hxx>
49 #include <svx/sdtfsitm.hxx>
50 #include <svx/svdmodel.hxx>
51 #include <svx/svdpage.hxx>
52 #include <svx/svdobj.hxx>
53 #include <svx/svdotext.hxx>
54 #include <svx/svdorect.hxx>
55 #include <svx/svdocirc.hxx>
56 #include <svx/svdograf.hxx>
57 #include <svx/svdopath.hxx>
58 #include <svx/svdetc.hxx>
59 #include <svl/itemset.hxx>
60 #include <basegfx/polygon/b2dpolygon.hxx>
61 #include <tools/helpers.hxx>
62 #include <basegfx/matrix/b2dhommatrix.hxx>
63 #include <basegfx/matrix/b2dhommatrixtools.hxx>
64 #include <svx/xlinjoit.hxx>
65 #include <svx/xlndsit.hxx>
66 #include <basegfx/polygon/b2dpolygonclipper.hxx>
67 #include <svx/xbtmpit.hxx>
68 #include <svx/xfltrit.hxx>
69 #include <svx/xflbmtit.hxx>
70 #include <svx/xflbstit.hxx>
71 #include <svx/svdpntv.hxx>
72 #include <basegfx/polygon/b2dpolypolygontools.hxx>
73 #include <svx/svditer.hxx>
74 #include <svx/svdogrp.hxx>
75 #include <vcl/BitmapTools.hxx>
76 
77 using namespace com::sun::star;
78 
79 ImpSdrGDIMetaFileImport::ImpSdrGDIMetaFileImport(
80  SdrModel& rModel,
81  SdrLayerID nLay,
82  const tools::Rectangle& rRect)
83 : maTmpList(),
84  mpVD(VclPtr<VirtualDevice>::Create()),
85  maScaleRect(rRect),
86  mnMapScalingOfs(0),
87  mpModel(&rModel),
88  mnLayer(nLay),
89  maOldLineColor(),
90  mnLineWidth(0),
91  maLineJoin(basegfx::B2DLineJoin::NONE),
92  maLineCap(css::drawing::LineCap_BUTT),
93  maDash(css::drawing::DashStyle_RECT, 0, 0, 0, 0, 0),
94  mbMov(false),
95  mbSize(false),
96  maOfs(0, 0),
97  mfScaleX(1.0),
98  mfScaleY(1.0),
99  maScaleX(1.0),
100  maScaleY(1.0),
101  mbFntDirty(true),
102  mbLastObjWasPolyWithoutLine(false),
103  mbNoLine(false),
104  mbNoFill(false),
105  mbLastObjWasLine(false),
106  maClip()
107 {
108  mpVD->EnableOutput(false);
109  mpVD->SetLineColor();
110  mpVD->SetFillColor();
111  maOldLineColor.SetRed( mpVD->GetLineColor().GetRed() + 1 );
112  mpLineAttr = std::make_unique<SfxItemSet>(rModel.GetItemPool(), svl::Items<XATTR_LINE_FIRST, XATTR_LINE_LAST>{});
113  mpFillAttr = std::make_unique<SfxItemSet>(rModel.GetItemPool(), svl::Items<XATTR_FILL_FIRST, XATTR_FILL_LAST>{});
114  mpTextAttr = std::make_unique<SfxItemSet>(rModel.GetItemPool(), svl::Items<EE_ITEMS_START, EE_ITEMS_END>{});
115  checkClip();
116 }
117 
118 void ImpSdrGDIMetaFileImport::DoLoopActions(GDIMetaFile const & rMtf, SvdProgressInfo* pProgrInfo, sal_uInt32* pActionsToReport)
119 {
120  const sal_uLong nCount(rMtf.GetActionSize());
121 
122  for(sal_uLong a(0); a < nCount; a++)
123  {
124  MetaAction* pAct = rMtf.GetAction(a);
125 
126  if(!pAct)
127  {
128  OSL_ENSURE(false, "OOps, no action at valid position (!)");
129  pAct = rMtf.GetAction(0);
130  }
131 
132  switch (pAct->GetType())
133  {
134  case MetaActionType::PIXEL : break;
135  case MetaActionType::POINT : break;
136  case MetaActionType::LINE : DoAction(static_cast<MetaLineAction &>(*pAct)); break;
137  case MetaActionType::RECT : DoAction(static_cast<MetaRectAction &>(*pAct)); break;
138  case MetaActionType::ROUNDRECT : DoAction(static_cast<MetaRoundRectAction &>(*pAct)); break;
139  case MetaActionType::ELLIPSE : DoAction(static_cast<MetaEllipseAction &>(*pAct)); break;
140  case MetaActionType::ARC : DoAction(static_cast<MetaArcAction &>(*pAct)); break;
141  case MetaActionType::PIE : DoAction(static_cast<MetaPieAction &>(*pAct)); break;
142  case MetaActionType::CHORD : DoAction(static_cast<MetaChordAction &>(*pAct)); break;
143  case MetaActionType::POLYLINE : DoAction(static_cast<MetaPolyLineAction &>(*pAct)); break;
144  case MetaActionType::POLYGON : DoAction(static_cast<MetaPolygonAction &>(*pAct)); break;
145  case MetaActionType::POLYPOLYGON : DoAction(static_cast<MetaPolyPolygonAction &>(*pAct)); break;
146  case MetaActionType::TEXT : DoAction(static_cast<MetaTextAction &>(*pAct)); break;
147  case MetaActionType::TEXTARRAY : DoAction(static_cast<MetaTextArrayAction &>(*pAct)); break;
148  case MetaActionType::STRETCHTEXT : DoAction(static_cast<MetaStretchTextAction &>(*pAct)); break;
149  case MetaActionType::BMP : DoAction(static_cast<MetaBmpAction &>(*pAct)); break;
150  case MetaActionType::BMPSCALE : DoAction(static_cast<MetaBmpScaleAction &>(*pAct)); break;
151  case MetaActionType::BMPEX : DoAction(static_cast<MetaBmpExAction &>(*pAct)); break;
152  case MetaActionType::BMPEXSCALE : DoAction(static_cast<MetaBmpExScaleAction &>(*pAct)); break;
153  case MetaActionType::LINECOLOR : DoAction(static_cast<MetaLineColorAction &>(*pAct)); break;
154  case MetaActionType::FILLCOLOR : DoAction(static_cast<MetaFillColorAction &>(*pAct)); break;
155  case MetaActionType::TEXTCOLOR : DoAction(static_cast<MetaTextColorAction &>(*pAct)); break;
156  case MetaActionType::TEXTFILLCOLOR : DoAction(static_cast<MetaTextFillColorAction &>(*pAct)); break;
157  case MetaActionType::FONT : DoAction(static_cast<MetaFontAction &>(*pAct)); break;
158  case MetaActionType::TEXTALIGN : DoAction(static_cast<MetaTextAlignAction &>(*pAct)); break;
159  case MetaActionType::MAPMODE : DoAction(static_cast<MetaMapModeAction &>(*pAct)); break;
160  case MetaActionType::CLIPREGION : DoAction(static_cast<MetaClipRegionAction &>(*pAct)); break;
161  case MetaActionType::MOVECLIPREGION : DoAction(static_cast<MetaMoveClipRegionAction &>(*pAct)); break;
162  case MetaActionType::ISECTRECTCLIPREGION: DoAction(static_cast<MetaISectRectClipRegionAction&>(*pAct)); break;
163  case MetaActionType::ISECTREGIONCLIPREGION: DoAction(static_cast<MetaISectRegionClipRegionAction&>(*pAct)); break;
164  case MetaActionType::RASTEROP : DoAction(static_cast<MetaRasterOpAction &>(*pAct)); break;
165  case MetaActionType::PUSH : DoAction(static_cast<MetaPushAction &>(*pAct)); break;
166  case MetaActionType::POP : DoAction(static_cast<MetaPopAction &>(*pAct)); break;
167  case MetaActionType::HATCH : DoAction(static_cast<MetaHatchAction &>(*pAct)); break;
168 
169  // #i125211# MetaCommentAction may change index, thus hand it over
170  case MetaActionType::COMMENT : DoAction(static_cast<MetaCommentAction&>(*pAct), rMtf, a);
171  break;
172 
173  // missing actions added
174  case MetaActionType::TEXTRECT : DoAction(static_cast<MetaTextRectAction&>(*pAct)); break;
175  case MetaActionType::BMPSCALEPART : DoAction(static_cast<MetaBmpScalePartAction&>(*pAct)); break;
176  case MetaActionType::BMPEXSCALEPART : DoAction(static_cast<MetaBmpExScalePartAction&>(*pAct)); break;
177  case MetaActionType::MASK : DoAction(static_cast<MetaMaskAction&>(*pAct)); break;
178  case MetaActionType::MASKSCALE : DoAction(static_cast<MetaMaskScaleAction&>(*pAct)); break;
179  case MetaActionType::MASKSCALEPART : DoAction(static_cast<MetaMaskScalePartAction&>(*pAct)); break;
180  case MetaActionType::GRADIENT : DoAction(static_cast<MetaGradientAction&>(*pAct)); break;
181  case MetaActionType::WALLPAPER : OSL_ENSURE(false, "Tried to construct SdrObject from MetaWallpaperAction: not supported (!)"); break;
182  case MetaActionType::Transparent : DoAction(static_cast<MetaTransparentAction&>(*pAct)); break;
183  case MetaActionType::EPS : OSL_ENSURE(false, "Tried to construct SdrObject from MetaEPSAction: not supported (!)"); break;
184  case MetaActionType::REFPOINT : DoAction(static_cast<MetaRefPointAction&>(*pAct)); break;
185  case MetaActionType::TEXTLINECOLOR : DoAction(static_cast<MetaTextLineColorAction&>(*pAct)); break;
186  case MetaActionType::TEXTLINE : OSL_ENSURE(false, "Tried to construct SdrObject from MetaTextLineAction: not supported (!)"); break;
187  case MetaActionType::FLOATTRANSPARENT : DoAction(static_cast<MetaFloatTransparentAction&>(*pAct)); break;
188  case MetaActionType::GRADIENTEX : DoAction(static_cast<MetaGradientExAction&>(*pAct)); break;
189  case MetaActionType::LAYOUTMODE : DoAction(static_cast<MetaLayoutModeAction&>(*pAct)); break;
190  case MetaActionType::TEXTLANGUAGE : DoAction(static_cast<MetaTextLanguageAction&>(*pAct)); break;
191  case MetaActionType::OVERLINECOLOR : DoAction(static_cast<MetaOverlineColorAction&>(*pAct)); break;
192  default: break;
193  }
194 
195  if(pProgrInfo && pActionsToReport)
196  {
197  (*pActionsToReport)++;
198 
199  if(*pActionsToReport >= 16) // update all 16 actions
200  {
201  if(!pProgrInfo->ReportActions(*pActionsToReport))
202  break;
203 
204  *pActionsToReport = 0;
205  }
206  }
207  }
208 }
209 
210 size_t ImpSdrGDIMetaFileImport::DoImport(
211  const GDIMetaFile& rMtf,
212  SdrObjList& rOL,
213  size_t nInsPos,
214  SvdProgressInfo* pProgrInfo)
215 {
216  // setup some global scale parameter
217  // mfScaleX, mfScaleY, maScaleX, maScaleY, mbMov, mbSize
218  mfScaleX = mfScaleY = 1.0;
219  const Size aMtfSize(rMtf.GetPrefSize());
220 
221  if(aMtfSize.Width() & aMtfSize.Height() && (!maScaleRect.IsEmpty()))
222  {
223  maOfs = maScaleRect.TopLeft();
224 
225  if(aMtfSize.Width() != (maScaleRect.GetWidth() - 1))
226  {
227  mfScaleX = static_cast<double>( maScaleRect.GetWidth() - 1 ) / static_cast<double>(aMtfSize.Width());
228  }
229 
230  if(aMtfSize.Height() != (maScaleRect.GetHeight() - 1))
231  {
232  mfScaleY = static_cast<double>( maScaleRect.GetHeight() - 1 ) / static_cast<double>(aMtfSize.Height());
233  }
234  }
235 
236  mbMov = maOfs.X()!=0 || maOfs.Y()!=0;
237  mbSize = false;
238  maScaleX = Fraction( 1, 1 );
239  maScaleY = Fraction( 1, 1 );
240 
241  if(aMtfSize.Width() != (maScaleRect.GetWidth() - 1))
242  {
243  maScaleX = Fraction(maScaleRect.GetWidth() - 1, aMtfSize.Width());
244  mbSize = true;
245  }
246 
247  if(aMtfSize.Height() != (maScaleRect.GetHeight() - 1))
248  {
249  maScaleY = Fraction(maScaleRect.GetHeight() - 1, aMtfSize.Height());
250  mbSize = true;
251  }
252 
253  if(pProgrInfo)
254  {
255  pProgrInfo->SetActionCount(rMtf.GetActionSize());
256  }
257 
258  sal_uInt32 nActionsToReport(0);
259 
260  // execute
261  DoLoopActions(rMtf, pProgrInfo, &nActionsToReport);
262 
263  if(pProgrInfo)
264  {
265  pProgrInfo->ReportActions(nActionsToReport);
266  nActionsToReport = 0;
267  }
268 
269  // MapMode scaling
270  MapScaling();
271 
272  // To calculate the progress meter, we use GetActionSize()*3.
273  // However, maTmpList has a lower entry count limit than GetActionSize(),
274  // so the actions that were assumed were too much have to be re-added.
275  nActionsToReport = (rMtf.GetActionSize() - maTmpList.size()) * 2;
276 
277  // announce all currently unannounced rescales
278  if(pProgrInfo)
279  {
280  pProgrInfo->ReportRescales(nActionsToReport);
281  pProgrInfo->SetInsertCount(maTmpList.size());
282  }
283 
284  nActionsToReport = 0;
285 
286  // insert all objects cached in aTmpList now into rOL from nInsPos
287  nInsPos = std::min(nInsPos, rOL.GetObjCount());
288 
289  for(SdrObject* pObj : maTmpList)
290  {
291  rOL.NbcInsertObject(pObj, nInsPos);
292  nInsPos++;
293 
294  if(pProgrInfo)
295  {
296  nActionsToReport++;
297 
298  if(nActionsToReport >= 32) // update all 32 actions
299  {
300  pProgrInfo->ReportInserts(nActionsToReport);
301  nActionsToReport = 0;
302  }
303  }
304  }
305 
306  // report all remaining inserts for the last time
307  if(pProgrInfo)
308  {
309  pProgrInfo->ReportInserts(nActionsToReport);
310  }
311 
312  return maTmpList.size();
313 }
314 
315 void ImpSdrGDIMetaFileImport::SetAttributes(SdrObject* pObj, bool bForceTextAttr)
316 {
317  mbNoLine = false;
318  mbNoFill = false;
319  bool bLine(!bForceTextAttr);
320  bool bFill(!pObj || (pObj->IsClosedObj() && !bForceTextAttr));
321  bool bText(bForceTextAttr || (pObj && pObj->GetOutlinerParaObject()));
322 
323  if(bLine)
324  {
325  if(mnLineWidth)
326  {
327  mpLineAttr->Put(XLineWidthItem(mnLineWidth));
328  }
329  else
330  {
331  mpLineAttr->Put(XLineWidthItem(0));
332  }
333 
334  maOldLineColor = mpVD->GetLineColor();
335 
336  if(mpVD->IsLineColor())
337  {
338  mpLineAttr->Put(XLineStyleItem(drawing::LineStyle_SOLID));
339  mpLineAttr->Put(XLineColorItem(OUString(), mpVD->GetLineColor()));
340  }
341  else
342  {
343  mpLineAttr->Put(XLineStyleItem(drawing::LineStyle_NONE));
344  }
345 
346  switch(maLineJoin)
347  {
348  case basegfx::B2DLineJoin::NONE:
349  mpLineAttr->Put(XLineJointItem(css::drawing::LineJoint_NONE));
350  break;
351  case basegfx::B2DLineJoin::Bevel:
352  mpLineAttr->Put(XLineJointItem(css::drawing::LineJoint_BEVEL));
353  break;
354  case basegfx::B2DLineJoin::Miter:
355  mpLineAttr->Put(XLineJointItem(css::drawing::LineJoint_MITER));
356  break;
357  case basegfx::B2DLineJoin::Round:
358  mpLineAttr->Put(XLineJointItem(css::drawing::LineJoint_ROUND));
359  break;
360  }
361 
362  // Add LineCap support
363  mpLineAttr->Put(XLineCapItem(maLineCap));
364 
365  if(((maDash.GetDots() && maDash.GetDotLen()) || (maDash.GetDashes() && maDash.GetDashLen())) && maDash.GetDistance())
366  {
367  mpLineAttr->Put(XLineDashItem(OUString(), maDash));
368  }
369  else
370  {
371  mpLineAttr->Put(XLineDashItem(OUString(), XDash(css::drawing::DashStyle_RECT)));
372  }
373  }
374  else
375  {
376  mbNoLine = true;
377  }
378 
379  if(bFill)
380  {
381  if(mpVD->IsFillColor())
382  {
383  mpFillAttr->Put(XFillStyleItem(drawing::FillStyle_SOLID));
384  mpFillAttr->Put(XFillColorItem(OUString(), mpVD->GetFillColor()));
385  }
386  else
387  {
388  mpFillAttr->Put(XFillStyleItem(drawing::FillStyle_NONE));
389  }
390  }
391  else
392  {
393  mbNoFill = true;
394  }
395 
396  if(bText && mbFntDirty)
397  {
398  vcl::Font aFnt(mpVD->GetFont());
399  const sal_uInt32 nHeight(FRound(aFnt.GetFontSize().Height() * mfScaleY));
400 
401  mpTextAttr->Put( SvxFontItem( aFnt.GetFamilyType(), aFnt.GetFamilyName(), aFnt.GetStyleName(), aFnt.GetPitch(), aFnt.GetCharSet(), EE_CHAR_FONTINFO ) );
402  mpTextAttr->Put( SvxFontItem( aFnt.GetFamilyType(), aFnt.GetFamilyName(), aFnt.GetStyleName(), aFnt.GetPitch(), aFnt.GetCharSet(), EE_CHAR_FONTINFO_CJK ) );
403  mpTextAttr->Put( SvxFontItem( aFnt.GetFamilyType(), aFnt.GetFamilyName(), aFnt.GetStyleName(), aFnt.GetPitch(), aFnt.GetCharSet(), EE_CHAR_FONTINFO_CTL ) );
404  mpTextAttr->Put(SvxPostureItem(aFnt.GetItalic(), EE_CHAR_ITALIC));
405  mpTextAttr->Put(SvxWeightItem(aFnt.GetWeight(), EE_CHAR_WEIGHT));
406  mpTextAttr->Put( SvxFontHeightItem( nHeight, 100, EE_CHAR_FONTHEIGHT ) );
407  mpTextAttr->Put( SvxFontHeightItem( nHeight, 100, EE_CHAR_FONTHEIGHT_CJK ) );
408  mpTextAttr->Put( SvxFontHeightItem( nHeight, 100, EE_CHAR_FONTHEIGHT_CTL ) );
409  mpTextAttr->Put(SvxCharScaleWidthItem(100, EE_CHAR_FONTWIDTH));
410  mpTextAttr->Put(SvxUnderlineItem(aFnt.GetUnderline(), EE_CHAR_UNDERLINE));
411  mpTextAttr->Put(SvxOverlineItem(aFnt.GetOverline(), EE_CHAR_OVERLINE));
412  mpTextAttr->Put(SvxCrossedOutItem(aFnt.GetStrikeout(), EE_CHAR_STRIKEOUT));
413  mpTextAttr->Put(SvxShadowedItem(aFnt.IsShadow(), EE_CHAR_SHADOW));
414 
415  // #i118485# Setting this item leads to problems (written #i118498# for this)
416  // mpTextAttr->Put(SvxAutoKernItem(aFnt.IsKerning(), EE_CHAR_KERNING));
417 
418  mpTextAttr->Put(SvxWordLineModeItem(aFnt.IsWordLineMode(), EE_CHAR_WLM));
419  mpTextAttr->Put(SvxContourItem(aFnt.IsOutline(), EE_CHAR_OUTLINE));
420  mpTextAttr->Put(SvxColorItem(mpVD->GetTextColor(), EE_CHAR_COLOR));
421  //... svxfont textitem svditext
422  mbFntDirty = false;
423  }
424 
425  if(!pObj)
426  return;
427 
428  pObj->SetLayer(mnLayer);
429 
430  if(bLine)
431  {
432  pObj->SetMergedItemSet(*mpLineAttr);
433  }
434 
435  if(bFill)
436  {
437  pObj->SetMergedItemSet(*mpFillAttr);
438  }
439 
440  if(bText)
441  {
442  pObj->SetMergedItemSet(*mpTextAttr);
443  pObj->SetMergedItem(SdrTextHorzAdjustItem(SDRTEXTHORZADJUST_LEFT));
444  }
445 }
446 
447 void ImpSdrGDIMetaFileImport::InsertObj(SdrObject* pObj, bool bScale)
448 {
449  if(bScale && !maScaleRect.IsEmpty())
450  {
451  if(mbSize)
452  {
453  pObj->NbcResize(Point(), maScaleX, maScaleY);
454  }
455 
456  if(mbMov)
457  {
458  pObj->NbcMove(Size(maOfs.X(), maOfs.Y()));
459  }
460  }
461 
462  if(isClip())
463  {
464  const basegfx::B2DPolyPolygon aPoly(pObj->TakeXorPoly());
465  const basegfx::B2DRange aOldRange(aPoly.getB2DRange());
466  const SdrLayerID aOldLayer(pObj->GetLayer());
467  const SfxItemSet aOldItemSet(pObj->GetMergedItemSet());
468  const SdrGrafObj* pSdrGrafObj = dynamic_cast< SdrGrafObj* >(pObj);
469  const SdrTextObj* pSdrTextObj = dynamic_cast< SdrTextObj* >(pObj);
470 
471  if(pSdrTextObj && pSdrTextObj->HasText())
472  {
473  // all text objects are created from ImportText and have no line or fill attributes, so
474  // it is okay to concentrate on the text itself
475  while(true)
476  {
477  const basegfx::B2DPolyPolygon aTextContour(pSdrTextObj->TakeContour());
478  const basegfx::B2DRange aTextRange(aTextContour.getB2DRange());
479  const basegfx::B2DRange aClipRange(maClip.getB2DRange());
480 
481  // no overlap -> completely outside
482  if(!aClipRange.overlaps(aTextRange))
483  {
484  SdrObject::Free(pObj);
485  break;
486  }
487 
488  // when the clip is a rectangle fast check for inside is possible
489  if(basegfx::utils::isRectangle(maClip) && aClipRange.isInside(aTextRange))
490  {
491  // completely inside ClipRect
492  break;
493  }
494 
495  // here text needs to be clipped; to do so, convert to SdrObjects with polygons
496  // and add these recursively. Delete original object, do not add in this run
497  SdrObject* pConverted = pSdrTextObj->ConvertToPolyObj(true, true).release();
498  SdrObject::Free(pObj);
499 
500  if(pConverted)
501  {
502  // recursively add created conversion; per definition this shall not
503  // contain further SdrTextObjs. Visit only non-group objects
504  SdrObjListIter aIter(*pConverted, SdrIterMode::DeepNoGroups);
505 
506  // work with clones; the created conversion may contain group objects
507  // and when working with the original objects the loop itself could
508  // break and the cleanup later would be pretty complicated (only delete group
509  // objects, are these empty, ...?)
510  while(aIter.IsMore())
511  {
512  SdrObject* pCandidate = aIter.Next();
513  OSL_ENSURE(pCandidate && dynamic_cast< SdrObjGroup* >(pCandidate) == nullptr, "SdrObjListIter with SdrIterMode::DeepNoGroups error (!)");
514  SdrObject* pNewClone(pCandidate->CloneSdrObject(pCandidate->getSdrModelFromSdrObject()));
515 
516  if(pNewClone)
517  {
518  InsertObj(pNewClone, false);
519  }
520  else
521  {
522  OSL_ENSURE(false, "SdrObject::Clone() failed (!)");
523  }
524  }
525 
526  // cleanup temporary conversion objects
527  SdrObject::Free(pConverted);
528  }
529 
530  break;
531  }
532  }
533  else
534  {
535  BitmapEx aBitmapEx;
536 
537  if(pSdrGrafObj)
538  {
539  aBitmapEx = pSdrGrafObj->GetGraphic().GetBitmapEx();
540  }
541 
542  SdrObject::Free(pObj);
543 
544  if(!aOldRange.isEmpty())
545  {
546  // clip against ClipRegion
547  const basegfx::B2DPolyPolygon aNewPoly(
548  basegfx::utils::clipPolyPolygonOnPolyPolygon(
549  aPoly,
550  maClip,
551  true,
552  !aPoly.isClosed()));
553  const basegfx::B2DRange aNewRange(aNewPoly.getB2DRange());
554 
555  if(!aNewRange.isEmpty())
556  {
557  pObj = new SdrPathObj(
558  *mpModel,
559  aNewPoly.isClosed() ? OBJ_POLY : OBJ_PLIN,
560  aNewPoly);
561 
562  pObj->SetLayer(aOldLayer);
563  pObj->SetMergedItemSet(aOldItemSet);
564 
565  if(!!aBitmapEx)
566  {
567  // aNewRange is inside of aOldRange and defines which part of aBitmapEx is used
568  const double fScaleX(aBitmapEx.GetSizePixel().Width() / (aOldRange.getWidth() ? aOldRange.getWidth() : 1.0));
569  const double fScaleY(aBitmapEx.GetSizePixel().Height() / (aOldRange.getHeight() ? aOldRange.getHeight() : 1.0));
570  basegfx::B2DRange aPixel(aNewRange);
571  basegfx::B2DHomMatrix aTrans;
572 
573  aTrans.translate(-aOldRange.getMinX(), -aOldRange.getMinY());
574  aTrans.scale(fScaleX, fScaleY);
575  aPixel.transform(aTrans);
576 
577  const Size aOrigSizePixel(aBitmapEx.GetSizePixel());
578  const Point aClipTopLeft(
579  basegfx::fround(floor(std::max(0.0, aPixel.getMinX()))),
580  basegfx::fround(floor(std::max(0.0, aPixel.getMinY()))));
581  const Size aClipSize(
582  basegfx::fround(ceil(std::min(static_cast<double>(aOrigSizePixel.Width()), aPixel.getWidth()))),
583  basegfx::fround(ceil(std::min(static_cast<double>(aOrigSizePixel.Height()), aPixel.getHeight()))));
584  const BitmapEx aClippedBitmap(
585  aBitmapEx,
586  aClipTopLeft,
587  aClipSize);
588 
589  pObj->SetMergedItem(XFillStyleItem(drawing::FillStyle_BITMAP));
590  pObj->SetMergedItem(XFillBitmapItem(OUString(), Graphic(aClippedBitmap)));
591  pObj->SetMergedItem(XFillBmpTileItem(false));
592  pObj->SetMergedItem(XFillBmpStretchItem(true));
593  }
594  }
595  }
596  }
597  }
598 
599  if(!pObj)
600  return;
601 
602  // #i111954# check object for visibility
603  // used are SdrPathObj, SdrRectObj, SdrCircObj, SdrGrafObj
604  bool bVisible(false);
605 
606  if(pObj->HasLineStyle())
607  {
608  bVisible = true;
609  }
610 
611  if(!bVisible && pObj->HasFillStyle())
612  {
613  bVisible = true;
614  }
615 
616  if(!bVisible)
617  {
618  SdrTextObj* pTextObj = dynamic_cast< SdrTextObj* >(pObj);
619 
620  if(pTextObj && pTextObj->HasText())
621  {
622  bVisible = true;
623  }
624  }
625 
626  if(!bVisible)
627  {
628  SdrGrafObj* pGrafObj = dynamic_cast< SdrGrafObj* >(pObj);
629 
630  if(pGrafObj)
631  {
632  // this may be refined to check if the graphic really is visible. It
633  // is here to ensure that graphic objects without fill, line and text
634  // get created
635  bVisible = true;
636  }
637  }
638 
639  if(!bVisible)
640  {
641  SdrObject::Free(pObj);
642  }
643  else
644  {
645  maTmpList.push_back(pObj);
646 
647  if(dynamic_cast< SdrPathObj* >(pObj))
648  {
649  const bool bClosed(pObj->IsClosedObj());
650 
651  mbLastObjWasPolyWithoutLine = mbNoLine && bClosed;
652  mbLastObjWasLine = !bClosed;
653  }
654  else
655  {
656  mbLastObjWasPolyWithoutLine = false;
657  mbLastObjWasLine = false;
658  }
659  }
660 }
661 
662 void ImpSdrGDIMetaFileImport::DoAction(MetaLineAction const & rAct)
663 {
664  // #i73407# reformulation to use new B2DPolygon classes
665  const basegfx::B2DPoint aStart(rAct.GetStartPoint().X(), rAct.GetStartPoint().Y());
666  const basegfx::B2DPoint aEnd(rAct.GetEndPoint().X(), rAct.GetEndPoint().Y());
667 
668  if(aStart.equal(aEnd))
669  return;
670 
671  basegfx::B2DPolygon aLine;
672  const basegfx::B2DHomMatrix aTransform(basegfx::utils::createScaleTranslateB2DHomMatrix(mfScaleX, mfScaleY, maOfs.X(), maOfs.Y()));
673 
674  aLine.append(aStart);
675  aLine.append(aEnd);
676  aLine.transform(aTransform);
677 
678  const LineInfo& rLineInfo = rAct.GetLineInfo();
679  const sal_Int32 nNewLineWidth(rLineInfo.GetWidth());
680  bool bCreateLineObject(true);
681 
682  if(mbLastObjWasLine && (nNewLineWidth == mnLineWidth) && CheckLastLineMerge(aLine))
683  {
684  bCreateLineObject = false;
685  }
686 
687  if(!bCreateLineObject)
688  return;
689 
690  SdrPathObj* pPath = new SdrPathObj(
691  *mpModel,
692  OBJ_LINE,
693  basegfx::B2DPolyPolygon(aLine));
694  mnLineWidth = nNewLineWidth;
695  maLineJoin = rLineInfo.GetLineJoin();
696  maLineCap = rLineInfo.GetLineCap();
697  maDash = XDash(css::drawing::DashStyle_RECT,
698  rLineInfo.GetDotCount(), rLineInfo.GetDotLen(),
699  rLineInfo.GetDashCount(), rLineInfo.GetDashLen(),
700  rLineInfo.GetDistance());
701  SetAttributes(pPath);
702  mnLineWidth = 0;
703  maLineJoin = basegfx::B2DLineJoin::NONE;
704  maDash = XDash();
705  InsertObj(pPath, false);
706 }
707 
708 void ImpSdrGDIMetaFileImport::DoAction(MetaRectAction const & rAct)
709 {
710  SdrRectObj* pRect = new SdrRectObj(
711  *mpModel,
712  rAct.GetRect());
713  SetAttributes(pRect);
714  InsertObj(pRect);
715 }
716 
717 void ImpSdrGDIMetaFileImport::DoAction(MetaRoundRectAction const & rAct)
718 {
719  SdrRectObj* pRect = new SdrRectObj(
720  *mpModel,
721  rAct.GetRect());
722  SetAttributes(pRect);
723  tools::Long nRad=(rAct.GetHorzRound()+rAct.GetVertRound())/2;
724  if (nRad!=0) {
725  SfxItemSet aSet(*mpLineAttr->GetPool(), svl::Items<SDRATTR_ECKENRADIUS, SDRATTR_ECKENRADIUS>{});
726  aSet.Put(SdrMetricItem(SDRATTR_ECKENRADIUS, nRad));
727  pRect->SetMergedItemSet(aSet);
728  }
729  InsertObj(pRect);
730 }
731 
732 void ImpSdrGDIMetaFileImport::DoAction(MetaEllipseAction const & rAct)
733 {
734  SdrCircObj* pCirc=new SdrCircObj(
735  *mpModel,
736  SdrCircKind::Full,
737  rAct.GetRect());
738  SetAttributes(pCirc);
739  InsertObj(pCirc);
740 }
741 
742 void ImpSdrGDIMetaFileImport::DoAction(MetaArcAction const & rAct)
743 {
744  Point aCenter(rAct.GetRect().Center());
745  Degree100 nStart=GetAngle(rAct.GetStartPoint()-aCenter);
746  Degree100 nEnd=GetAngle(rAct.GetEndPoint()-aCenter);
747  SdrCircObj* pCirc = new SdrCircObj(
748  *mpModel,
749  SdrCircKind::Arc,
750  rAct.GetRect(),nStart,nEnd);
751  SetAttributes(pCirc);
752  InsertObj(pCirc);
753 }
754 
755 void ImpSdrGDIMetaFileImport::DoAction(MetaPieAction const & rAct)
756 {
757  Point aCenter(rAct.GetRect().Center());
758  Degree100 nStart=GetAngle(rAct.GetStartPoint()-aCenter);
759  Degree100 nEnd=GetAngle(rAct.GetEndPoint()-aCenter);
760  SdrCircObj* pCirc = new SdrCircObj(
761  *mpModel,
762  SdrCircKind::Section,
763  rAct.GetRect(),
764  nStart,
765  nEnd);
766  SetAttributes(pCirc);
767  InsertObj(pCirc);
768 }
769 
770 void ImpSdrGDIMetaFileImport::DoAction(MetaChordAction const & rAct)
771 {
772  Point aCenter(rAct.GetRect().Center());
773  Degree100 nStart=GetAngle(rAct.GetStartPoint()-aCenter);
774  Degree100 nEnd=GetAngle(rAct.GetEndPoint()-aCenter);
775  SdrCircObj* pCirc = new SdrCircObj(
776  *mpModel,
777  SdrCircKind::Cut,
778  rAct.GetRect(),
779  nStart,
780  nEnd);
781  SetAttributes(pCirc);
782  InsertObj(pCirc);
783 }
784 
785 bool ImpSdrGDIMetaFileImport::CheckLastLineMerge(const basegfx::B2DPolygon& rSrcPoly)
786 {
787  // #i102706# Do not merge closed polygons
788  if(rSrcPoly.isClosed())
789  {
790  return false;
791  }
792 
793  // #i73407# reformulation to use new B2DPolygon classes
794  if(mbLastObjWasLine && (maOldLineColor == mpVD->GetLineColor()) && rSrcPoly.count())
795  {
796  SdrObject* pTmpObj = !maTmpList.empty() ? maTmpList[maTmpList.size() - 1] : nullptr;
797  SdrPathObj* pLastPoly = dynamic_cast< SdrPathObj* >(pTmpObj);
798 
799  if(pLastPoly)
800  {
801  if(1 == pLastPoly->GetPathPoly().count())
802  {
803  bool bOk(false);
804  basegfx::B2DPolygon aDstPoly(pLastPoly->GetPathPoly().getB2DPolygon(0));
805 
806  // #i102706# Do not merge closed polygons
807  if(aDstPoly.isClosed())
808  {
809  return false;
810  }
811 
812  if(aDstPoly.count())
813  {
814  const sal_uInt32 nMaxDstPnt(aDstPoly.count() - 1);
815  const sal_uInt32 nMaxSrcPnt(rSrcPoly.count() - 1);
816 
817  if(aDstPoly.getB2DPoint(nMaxDstPnt) == rSrcPoly.getB2DPoint(0))
818  {
819  aDstPoly.append(rSrcPoly, 1, rSrcPoly.count() - 1);
820  bOk = true;
821  }
822  else if(aDstPoly.getB2DPoint(0) == rSrcPoly.getB2DPoint(nMaxSrcPnt))
823  {
824  basegfx::B2DPolygon aNew(rSrcPoly);
825  aNew.append(aDstPoly, 1, aDstPoly.count() - 1);
826  aDstPoly = aNew;
827  bOk = true;
828  }
829  else if(aDstPoly.getB2DPoint(0) == rSrcPoly.getB2DPoint(0))
830  {
831  aDstPoly.flip();
832  aDstPoly.append(rSrcPoly, 1, rSrcPoly.count() - 1);
833  bOk = true;
834  }
835  else if(aDstPoly.getB2DPoint(nMaxDstPnt) == rSrcPoly.getB2DPoint(nMaxSrcPnt))
836  {
837  basegfx::B2DPolygon aNew(rSrcPoly);
838  aNew.flip();
839  aDstPoly.append(aNew, 1, aNew.count() - 1);
840  bOk = true;
841  }
842  }
843 
844  if(bOk)
845  {
846  pLastPoly->NbcSetPathPoly(basegfx::B2DPolyPolygon(aDstPoly));
847  }
848 
849  return bOk;
850  }
851  }
852  }
853 
854  return false;
855 }
856 
857 bool ImpSdrGDIMetaFileImport::CheckLastPolyLineAndFillMerge(const basegfx::B2DPolyPolygon & rPolyPolygon)
858 {
859  // #i73407# reformulation to use new B2DPolygon classes
860  if(mbLastObjWasPolyWithoutLine)
861  {
862  SdrObject* pTmpObj = !maTmpList.empty() ? maTmpList[maTmpList.size() - 1] : nullptr;
863  SdrPathObj* pLastPoly = dynamic_cast< SdrPathObj* >(pTmpObj);
864 
865  if(pLastPoly)
866  {
867  if(pLastPoly->GetPathPoly() == rPolyPolygon)
868  {
869  SetAttributes(nullptr);
870 
871  if(!mbNoLine && mbNoFill)
872  {
873  pLastPoly->SetMergedItemSet(*mpLineAttr);
874 
875  return true;
876  }
877  }
878  }
879  }
880 
881  return false;
882 }
883 
884 void ImpSdrGDIMetaFileImport::checkClip()
885 {
886  if(!mpVD->IsClipRegion())
887  return;
888 
889  maClip = mpVD->GetClipRegion().GetAsB2DPolyPolygon();
890 
891  if(isClip())
892  {
893  const basegfx::B2DHomMatrix aTransform(
894  basegfx::utils::createScaleTranslateB2DHomMatrix(
895  mfScaleX,
896  mfScaleY,
897  maOfs.X(),
898  maOfs.Y()));
899 
900  maClip.transform(aTransform);
901  }
902 }
903 
904 bool ImpSdrGDIMetaFileImport::isClip() const
905 {
906  return !maClip.getB2DRange().isEmpty();
907 }
908 
909 void ImpSdrGDIMetaFileImport::DoAction( MetaPolyLineAction const & rAct )
910 {
911  // #i73407# reformulation to use new B2DPolygon classes
912  basegfx::B2DPolygon aSource(rAct.GetPolygon().getB2DPolygon());
913 
914  if(aSource.count())
915  {
916  const basegfx::B2DHomMatrix aTransform(basegfx::utils::createScaleTranslateB2DHomMatrix(mfScaleX, mfScaleY, maOfs.X(), maOfs.Y()));
917  aSource.transform(aTransform);
918  }
919 
920  const LineInfo& rLineInfo = rAct.GetLineInfo();
921  const sal_Int32 nNewLineWidth(rLineInfo.GetWidth());
922  bool bCreateLineObject(true);
923 
924  if(mbLastObjWasLine && (nNewLineWidth == mnLineWidth) && CheckLastLineMerge(aSource))
925  {
926  bCreateLineObject = false;
927  }
928  else if(mbLastObjWasPolyWithoutLine && CheckLastPolyLineAndFillMerge(basegfx::B2DPolyPolygon(aSource)))
929  {
930  bCreateLineObject = false;
931  }
932 
933  if(!bCreateLineObject)
934  return;
935 
936  SdrPathObj* pPath = new SdrPathObj(
937  *mpModel,
938  aSource.isClosed() ? OBJ_POLY : OBJ_PLIN,
939  basegfx::B2DPolyPolygon(aSource));
940  mnLineWidth = nNewLineWidth;
941  maLineJoin = rLineInfo.GetLineJoin();
942  maLineCap = rLineInfo.GetLineCap();
943  maDash = XDash(css::drawing::DashStyle_RECT,
944  rLineInfo.GetDotCount(), rLineInfo.GetDotLen(),
945  rLineInfo.GetDashCount(), rLineInfo.GetDashLen(),
946  rLineInfo.GetDistance());
947  SetAttributes(pPath);
948  mnLineWidth = 0;
949  maLineJoin = basegfx::B2DLineJoin::NONE;
950  maDash = XDash();
951  InsertObj(pPath, false);
952 }
953 
954 void ImpSdrGDIMetaFileImport::DoAction( MetaPolygonAction const & rAct )
955 {
956  // #i73407# reformulation to use new B2DPolygon classes
957  basegfx::B2DPolygon aSource(rAct.GetPolygon().getB2DPolygon());
958 
959  if(!aSource.count())
960  return;
961 
962  const basegfx::B2DHomMatrix aTransform(basegfx::utils::createScaleTranslateB2DHomMatrix(mfScaleX, mfScaleY, maOfs.X(), maOfs.Y()));
963  aSource.transform(aTransform);
964 
965  if(!mbLastObjWasPolyWithoutLine || !CheckLastPolyLineAndFillMerge(basegfx::B2DPolyPolygon(aSource)))
966  {
967  // #i73407# make sure polygon is closed, it's a filled primitive
968  aSource.setClosed(true);
969  SdrPathObj* pPath = new SdrPathObj(
970  *mpModel,
971  OBJ_POLY,
972  basegfx::B2DPolyPolygon(aSource));
973  SetAttributes(pPath);
974  InsertObj(pPath, false);
975  }
976 }
977 
978 void ImpSdrGDIMetaFileImport::DoAction(MetaPolyPolygonAction const & rAct)
979 {
980  // #i73407# reformulation to use new B2DPolygon classes
981  basegfx::B2DPolyPolygon aSource(rAct.GetPolyPolygon().getB2DPolyPolygon());
982 
983  if(!aSource.count())
984  return;
985 
986  const basegfx::B2DHomMatrix aTransform(basegfx::utils::createScaleTranslateB2DHomMatrix(mfScaleX, mfScaleY, maOfs.X(), maOfs.Y()));
987  aSource.transform(aTransform);
988 
989  if(!mbLastObjWasPolyWithoutLine || !CheckLastPolyLineAndFillMerge(aSource))
990  {
991  // #i73407# make sure polygon is closed, it's a filled primitive
992  aSource.setClosed(true);
993  SdrPathObj* pPath = new SdrPathObj(
994  *mpModel,
995  OBJ_POLY,
996  aSource);
997  SetAttributes(pPath);
998  InsertObj(pPath, false);
999  }
1000 }
1001 
1002 void ImpSdrGDIMetaFileImport::ImportText( const Point& rPos, const OUString& rStr, const MetaAction& rAct )
1003 {
1004  // calc text box size, add 5% to make it fit safely
1005 
1006  FontMetric aFontMetric( mpVD->GetFontMetric() );
1007  vcl::Font aFnt( mpVD->GetFont() );
1008  FontAlign eAlg( aFnt.GetAlignment() );
1009 
1010  sal_Int32 nTextWidth = static_cast<sal_Int32>( mpVD->GetTextWidth( rStr ) * mfScaleX );
1011  sal_Int32 nTextHeight = static_cast<sal_Int32>( mpVD->GetTextHeight() * mfScaleY );
1012 
1013  Point aPos( FRound(rPos.X() * mfScaleX + maOfs.X()), FRound(rPos.Y() * mfScaleY + maOfs.Y()) );
1014  Size aSize( nTextWidth, nTextHeight );
1015 
1016  if ( eAlg == ALIGN_BASELINE )
1017  aPos.AdjustY( -(FRound(aFontMetric.GetAscent() * mfScaleY)) );
1018  else if ( eAlg == ALIGN_BOTTOM )
1019  aPos.AdjustY( -nTextHeight );
1020 
1021  tools::Rectangle aTextRect( aPos, aSize );
1022  SdrRectObj* pText = new SdrRectObj(
1023  *mpModel,
1024  OBJ_TEXT,
1025  aTextRect);
1026 
1027  pText->SetMergedItem ( makeSdrTextUpperDistItem (0));
1028  pText->SetMergedItem ( makeSdrTextLowerDistItem (0));
1029  pText->SetMergedItem ( makeSdrTextRightDistItem (0));
1030  pText->SetMergedItem ( makeSdrTextLeftDistItem (0));
1031 
1032  if ( aFnt.GetAverageFontWidth() || ( rAct.GetType() == MetaActionType::STRETCHTEXT ) )
1033  {
1034  pText->ClearMergedItem( SDRATTR_TEXT_AUTOGROWWIDTH );
1035  pText->SetMergedItem( makeSdrTextAutoGrowHeightItem( false ) );
1036  // don't let the margins eat the space needed for the text
1037  pText->SetMergedItem( SdrTextFitToSizeTypeItem(drawing::TextFitToSizeType_ALLLINES) );
1038  }
1039  else
1040  {
1041  pText->SetMergedItem( makeSdrTextAutoGrowWidthItem( true ) );
1042  }
1043 
1044  pText->SetLayer(mnLayer);
1045  pText->NbcSetText( rStr );
1046  SetAttributes( pText, true );
1047  pText->SetSnapRect( aTextRect );
1048 
1049  if (!aFnt.IsTransparent())
1050  {
1051  SfxItemSet aAttr(*mpFillAttr->GetPool(), svl::Items<XATTR_FILL_FIRST, XATTR_FILL_LAST>{});
1052  aAttr.Put(XFillStyleItem(drawing::FillStyle_SOLID));
1053  aAttr.Put(XFillColorItem(OUString(), aFnt.GetFillColor()));
1054  pText->SetMergedItemSet(aAttr);
1055  }
1056  Degree100 nAngle = toDegree100(aFnt.GetOrientation());
1057  if ( nAngle )
1058  pText->SdrAttrObj::NbcRotate(aPos,nAngle);
1059  InsertObj( pText, false );
1060 }
1061 
1062 void ImpSdrGDIMetaFileImport::DoAction(MetaTextAction const & rAct)
1063 {
1064  OUString aStr(rAct.GetText());
1065  aStr = aStr.copy(rAct.GetIndex(), rAct.GetLen());
1066  ImportText( rAct.GetPoint(), aStr, rAct );
1067 }
1068 
1069 void ImpSdrGDIMetaFileImport::DoAction(MetaTextArrayAction const & rAct)
1070 {
1071  OUString aStr(rAct.GetText());
1072  aStr = aStr.copy(rAct.GetIndex(), rAct.GetLen());
1073  ImportText( rAct.GetPoint(), aStr, rAct );
1074 }
1075 
1076 void ImpSdrGDIMetaFileImport::DoAction(MetaStretchTextAction const & rAct)
1077 {
1078  OUString aStr(rAct.GetText());
1079  aStr = aStr.copy(rAct.GetIndex(), rAct.GetLen());
1080  ImportText( rAct.GetPoint(), aStr, rAct );
1081 }
1082 
1083 void ImpSdrGDIMetaFileImport::DoAction(MetaBmpAction const & rAct)
1084 {
1085  tools::Rectangle aRect(rAct.GetPoint(),rAct.GetBitmap().GetSizePixel());
1086  aRect.AdjustRight( 1 ); aRect.AdjustBottom( 1 );
1087  SdrGrafObj* pGraf = new SdrGrafObj(
1088  *mpModel,
1089  Graphic(BitmapEx(rAct.GetBitmap())),
1090  aRect);
1091 
1092  // This action is not creating line and fill, set directly, do not use SetAttributes(..)
1093  pGraf->SetMergedItem(XLineStyleItem(drawing::LineStyle_NONE));
1094  pGraf->SetMergedItem(XFillStyleItem(drawing::FillStyle_NONE));
1095  InsertObj(pGraf);
1096 }
1097 
1098 void ImpSdrGDIMetaFileImport::DoAction(MetaBmpScaleAction const & rAct)
1099 {
1100  tools::Rectangle aRect(rAct.GetPoint(),rAct.GetSize());
1101  aRect.AdjustRight( 1 ); aRect.AdjustBottom( 1 );
1102  SdrGrafObj* pGraf = new SdrGrafObj(
1103  *mpModel,
1104  Graphic(BitmapEx(rAct.GetBitmap())),
1105  aRect);
1106 
1107  // This action is not creating line and fill, set directly, do not use SetAttributes(..)
1108  pGraf->SetMergedItem(XLineStyleItem(drawing::LineStyle_NONE));
1109  pGraf->SetMergedItem(XFillStyleItem(drawing::FillStyle_NONE));
1110  InsertObj(pGraf);
1111 }
1112 
1113 void ImpSdrGDIMetaFileImport::DoAction(MetaBmpExAction const & rAct)
1114 {
1115  tools::Rectangle aRect(rAct.GetPoint(),rAct.GetBitmapEx().GetSizePixel());
1116  aRect.AdjustRight( 1 ); aRect.AdjustBottom( 1 );
1117  SdrGrafObj* pGraf = new SdrGrafObj(
1118  *mpModel,
1119  rAct.GetBitmapEx(),
1120  aRect);
1121 
1122  // This action is not creating line and fill, set directly, do not use SetAttributes(..)
1123  pGraf->SetMergedItem(XLineStyleItem(drawing::LineStyle_NONE));
1124  pGraf->SetMergedItem(XFillStyleItem(drawing::FillStyle_NONE));
1125  InsertObj(pGraf);
1126 }
1127 
1128 void ImpSdrGDIMetaFileImport::DoAction(MetaBmpExScaleAction const & rAct)
1129 {
1130  tools::Rectangle aRect(rAct.GetPoint(),rAct.GetSize());
1131  aRect.AdjustRight( 1 ); aRect.AdjustBottom( 1 );
1132  SdrGrafObj* pGraf = new SdrGrafObj(
1133  *mpModel,
1134  rAct.GetBitmapEx(),
1135  aRect);
1136 
1137  // This action is not creating line and fill, set directly, do not use SetAttributes(..)
1138  pGraf->SetMergedItem(XLineStyleItem(drawing::LineStyle_NONE));
1139  pGraf->SetMergedItem(XFillStyleItem(drawing::FillStyle_NONE));
1140  InsertObj(pGraf);
1141 }
1142 
1143 
1144 void ImpSdrGDIMetaFileImport::DoAction( MetaHatchAction const & rAct )
1145 {
1146  // #i73407# reformulation to use new B2DPolygon classes
1147  basegfx::B2DPolyPolygon aSource(rAct.GetPolyPolygon().getB2DPolyPolygon());
1148 
1149  if(!aSource.count())
1150  return;
1151 
1152  const basegfx::B2DHomMatrix aTransform(basegfx::utils::createScaleTranslateB2DHomMatrix(mfScaleX, mfScaleY, maOfs.X(), maOfs.Y()));
1153  aSource.transform(aTransform);
1154 
1155  if(mbLastObjWasPolyWithoutLine && CheckLastPolyLineAndFillMerge(aSource))
1156  return;
1157 
1158  const Hatch& rHatch = rAct.GetHatch();
1159  SdrPathObj* pPath = new SdrPathObj(
1160  *mpModel,
1161  OBJ_POLY,
1162  aSource);
1163  // #i125211# Use the ranges from the SdrObject to create a new empty SfxItemSet
1164  SfxItemSet aHatchAttr(mpModel->GetItemPool(), pPath->GetMergedItemSet().GetRanges());
1165  css::drawing::HatchStyle eStyle;
1166 
1167  switch(rHatch.GetStyle())
1168  {
1169  case HatchStyle::Triple :
1170  {
1171  eStyle = css::drawing::HatchStyle_TRIPLE;
1172  break;
1173  }
1174 
1175  case HatchStyle::Double :
1176  {
1177  eStyle = css::drawing::HatchStyle_DOUBLE;
1178  break;
1179  }
1180 
1181  default:
1182  {
1183  eStyle = css::drawing::HatchStyle_SINGLE;
1184  break;
1185  }
1186  }
1187 
1188  SetAttributes(pPath);
1189  aHatchAttr.Put(XFillStyleItem(drawing::FillStyle_HATCH));
1190  aHatchAttr.Put(XFillHatchItem(XHatch(rHatch.GetColor(), eStyle, rHatch.GetDistance(), rHatch.GetAngle())));
1191  pPath->SetMergedItemSet(aHatchAttr);
1192 
1193  InsertObj(pPath, false);
1194 }
1195 
1196 
1197 void ImpSdrGDIMetaFileImport::DoAction(MetaLineColorAction& rAct)
1198 {
1199  rAct.Execute(mpVD);
1200 }
1201 
1202 void ImpSdrGDIMetaFileImport::DoAction(MetaMapModeAction& rAct)
1203 {
1204  MapScaling();
1205  rAct.Execute(mpVD);
1206  mbLastObjWasPolyWithoutLine = false;
1207  mbLastObjWasLine = false;
1208 }
1209 
1210 void ImpSdrGDIMetaFileImport::MapScaling()
1211 {
1212  const size_t nCount(maTmpList.size());
1213  const MapMode& rMap = mpVD->GetMapMode();
1214  Point aMapOrg( rMap.GetOrigin() );
1215  bool bMov2(aMapOrg.X() != 0 || aMapOrg.Y() != 0);
1216 
1217  if(bMov2)
1218  {
1219  for(size_t i = mnMapScalingOfs; i < nCount; i++)
1220  {
1221  SdrObject* pObj = maTmpList[i];
1222 
1223  pObj->NbcMove(Size(aMapOrg.X(), aMapOrg.Y()));
1224  }
1225  }
1226 
1227  mnMapScalingOfs = nCount;
1228 }
1229 
1230 
1231 void ImpSdrGDIMetaFileImport::DoAction( MetaCommentAction const & rAct, GDIMetaFile const & rMtf, sal_uLong& a) // GDIMetaFile* pMtf )
1232 {
1233  bool aSkipComment = false;
1234 
1235  if (a < rMtf.GetActionSize() && rAct.GetComment().equalsIgnoreAsciiCase("XGRAD_SEQ_BEGIN"))
1236  {
1237  // #i125211# Check if next action is a MetaGradientExAction
1238  MetaGradientExAction* pAct = dynamic_cast< MetaGradientExAction* >(rMtf.GetAction(a + 1));
1239 
1240  if( pAct && pAct->GetType() == MetaActionType::GRADIENTEX )
1241  {
1242  // #i73407# reformulation to use new B2DPolygon classes
1243  basegfx::B2DPolyPolygon aSource(pAct->GetPolyPolygon().getB2DPolyPolygon());
1244 
1245  if(aSource.count())
1246  {
1247  if(!mbLastObjWasPolyWithoutLine || !CheckLastPolyLineAndFillMerge(aSource))
1248  {
1249  const Gradient& rGrad = pAct->GetGradient();
1250  SdrPathObj* pPath = new SdrPathObj(
1251  *mpModel,
1252  OBJ_POLY,
1253  aSource);
1254  // #i125211# Use the ranges from the SdrObject to create a new empty SfxItemSet
1255  SfxItemSet aGradAttr(mpModel->GetItemPool(), pPath->GetMergedItemSet().GetRanges());
1256  XGradient aXGradient;
1257 
1258  aXGradient.SetGradientStyle(static_cast<css::awt::GradientStyle>(rGrad.GetStyle()));
1259  aXGradient.SetStartColor(rGrad.GetStartColor());
1260  aXGradient.SetEndColor(rGrad.GetEndColor());
1261  aXGradient.SetAngle(rGrad.GetAngle());
1262  aXGradient.SetBorder(rGrad.GetBorder());
1263  aXGradient.SetXOffset(rGrad.GetOfsX());
1264  aXGradient.SetYOffset(rGrad.GetOfsY());
1265  aXGradient.SetStartIntens(rGrad.GetStartIntensity());
1266  aXGradient.SetEndIntens(rGrad.GetEndIntensity());
1267  aXGradient.SetSteps(rGrad.GetSteps());
1268 
1269  // no need to use SetAttributes(..) here since line and fill style
1270  // need to be set individually
1271  // SetAttributes(pPath);
1272 
1273  // switch line off; if there was one there will be a
1274  // MetaActionType::POLYLINE following creating another object
1275  aGradAttr.Put(XLineStyleItem(drawing::LineStyle_NONE));
1276 
1277  // add detected gradient fillstyle
1278  aGradAttr.Put(XFillStyleItem(drawing::FillStyle_GRADIENT));
1279  aGradAttr.Put(XFillGradientItem(aXGradient));
1280 
1281  pPath->SetMergedItemSet(aGradAttr);
1282 
1283  InsertObj(pPath);
1284  }
1285  }
1286 
1287  aSkipComment = true;
1288  }
1289  }
1290 
1291  if(aSkipComment)
1292  {
1293  // #i125211# forward until closing MetaCommentAction
1294  MetaAction* pSkipAct = rMtf.GetAction(++a);
1295 
1296  while( pSkipAct
1297  && ((pSkipAct->GetType() != MetaActionType::COMMENT )
1298  || !(static_cast<MetaCommentAction*>(pSkipAct)->GetComment().equalsIgnoreAsciiCase("XGRAD_SEQ_END"))))
1299  {
1300  pSkipAct = rMtf.GetAction(++a);
1301  }
1302  }
1303 }
1304 
1305 void ImpSdrGDIMetaFileImport::DoAction(MetaTextRectAction const & rAct)
1306 {
1307  GDIMetaFile aTemp;
1308 
1309  mpVD->AddTextRectActions(rAct.GetRect(), rAct.GetText(), rAct.GetStyle(), aTemp);
1310  DoLoopActions(aTemp, nullptr, nullptr);
1311 }
1312 
1313 void ImpSdrGDIMetaFileImport::DoAction(MetaBmpScalePartAction const & rAct)
1314 {
1315  tools::Rectangle aRect(rAct.GetDestPoint(), rAct.GetDestSize());
1316  BitmapEx aBitmapEx(rAct.GetBitmap());
1317 
1318  aRect.AdjustRight( 1 );
1319  aRect.AdjustBottom( 1 );
1320  aBitmapEx.Crop(tools::Rectangle(rAct.GetSrcPoint(), rAct.GetSrcSize()));
1321  SdrGrafObj* pGraf = new SdrGrafObj(
1322  *mpModel,
1323  aBitmapEx,
1324  aRect);
1325 
1326  // This action is not creating line and fill, set directly, do not use SetAttributes(..)
1327  pGraf->SetMergedItem(XLineStyleItem(drawing::LineStyle_NONE));
1328  pGraf->SetMergedItem(XFillStyleItem(drawing::FillStyle_NONE));
1329  InsertObj(pGraf);
1330 }
1331 
1332 void ImpSdrGDIMetaFileImport::DoAction(MetaBmpExScalePartAction const & rAct)
1333 {
1334  tools::Rectangle aRect(rAct.GetDestPoint(),rAct.GetDestSize());
1335  BitmapEx aBitmapEx(rAct.GetBitmapEx());
1336 
1337  aRect.AdjustRight( 1 );
1338  aRect.AdjustBottom( 1 );
1339  aBitmapEx.Crop(tools::Rectangle(rAct.GetSrcPoint(), rAct.GetSrcSize()));
1340  SdrGrafObj* pGraf = new SdrGrafObj(
1341  *mpModel,
1342  aBitmapEx,
1343  aRect);
1344 
1345  // This action is not creating line and fill, set directly, do not use SetAttributes(..)
1346  pGraf->SetMergedItem(XLineStyleItem(drawing::LineStyle_NONE));
1347  pGraf->SetMergedItem(XFillStyleItem(drawing::FillStyle_NONE));
1348  InsertObj(pGraf);
1349 }
1350 
1351 void ImpSdrGDIMetaFileImport::DoAction(MetaMaskAction const & rAct)
1352 {
1353  tools::Rectangle aRect(rAct.GetPoint(), rAct.GetBitmap().GetSizePixel());
1354  BitmapEx aBitmapEx(rAct.GetBitmap(), rAct.GetColor());
1355 
1356  aRect.AdjustRight( 1 ); aRect.AdjustBottom( 1 );
1357  SdrGrafObj* pGraf = new SdrGrafObj(
1358  *mpModel,
1359  aBitmapEx,
1360  aRect);
1361 
1362  // This action is not creating line and fill, set directly, do not use SetAttributes(..)
1363  pGraf->SetMergedItem(XLineStyleItem(drawing::LineStyle_NONE));
1364  pGraf->SetMergedItem(XFillStyleItem(drawing::FillStyle_NONE));
1365  InsertObj(pGraf);
1366 }
1367 
1368 void ImpSdrGDIMetaFileImport::DoAction(MetaMaskScaleAction const & rAct)
1369 {
1370  tools::Rectangle aRect(rAct.GetPoint(), rAct.GetSize());
1371  BitmapEx aBitmapEx(rAct.GetBitmap(), rAct.GetColor());
1372 
1373  aRect.AdjustRight( 1 ); aRect.AdjustBottom( 1 );
1374  SdrGrafObj* pGraf = new SdrGrafObj(
1375  *mpModel,
1376  aBitmapEx,
1377  aRect);
1378 
1379  // This action is not creating line and fill, set directly, do not use SetAttributes(..)
1380  pGraf->SetMergedItem(XLineStyleItem(drawing::LineStyle_NONE));
1381  pGraf->SetMergedItem(XFillStyleItem(drawing::FillStyle_NONE));
1382  InsertObj(pGraf);
1383 }
1384 
1385 void ImpSdrGDIMetaFileImport::DoAction(MetaMaskScalePartAction const & rAct)
1386 {
1387  tools::Rectangle aRect(rAct.GetDestPoint(), rAct.GetDestSize());
1388  BitmapEx aBitmapEx(rAct.GetBitmap(), rAct.GetColor());
1389 
1390  aRect.AdjustRight( 1 ); aRect.AdjustBottom( 1 );
1391  aBitmapEx.Crop(tools::Rectangle(rAct.GetSrcPoint(), rAct.GetSrcSize()));
1392  SdrGrafObj* pGraf = new SdrGrafObj(
1393  *mpModel,
1394  aBitmapEx,
1395  aRect);
1396 
1397  // This action is not creating line and fill, set directly, do not use SetAttributes(..)
1398  pGraf->SetMergedItem(XLineStyleItem(drawing::LineStyle_NONE));
1399  pGraf->SetMergedItem(XFillStyleItem(drawing::FillStyle_NONE));
1400  InsertObj(pGraf);
1401 }
1402 
1403 namespace
1404 {
1405  css::awt::GradientStyle getXGradientStyleFromGradientStyle(const GradientStyle& rGradientStyle)
1406  {
1407  css::awt::GradientStyle aXGradientStyle(css::awt::GradientStyle_LINEAR);
1408 
1409  switch(rGradientStyle)
1410  {
1411  case GradientStyle::Linear: aXGradientStyle = css::awt::GradientStyle_LINEAR; break;
1412  case GradientStyle::Axial: aXGradientStyle = css::awt::GradientStyle_AXIAL; break;
1413  case GradientStyle::Radial: aXGradientStyle = css::awt::GradientStyle_RADIAL; break;
1414  case GradientStyle::Elliptical: aXGradientStyle = css::awt::GradientStyle_ELLIPTICAL; break;
1415  case GradientStyle::Square: aXGradientStyle = css::awt::GradientStyle_SQUARE; break;
1416  case GradientStyle::Rect: aXGradientStyle = css::awt::GradientStyle_RECT; break;
1417 
1418  // Needed due to GradientStyle::FORCE_EQUAL_SIZE; this again is needed
1419  // to force the enum defines in VCL to a defined size for the compilers,
1420  // so despite it is never used it cannot be removed (would break the
1421  // API implementation probably).
1422  case GradientStyle::FORCE_EQUAL_SIZE: break;
1423  default:
1424  break;
1425  }
1426 
1427  return aXGradientStyle;
1428  }
1429 }
1430 
1431 void ImpSdrGDIMetaFileImport::DoAction(MetaGradientAction const & rAct)
1432 {
1433  basegfx::B2DRange aRange = vcl::unotools::b2DRectangleFromRectangle(rAct.GetRect());
1434 
1435  if(aRange.isEmpty())
1436  return;
1437 
1438  const basegfx::B2DHomMatrix aTransform(basegfx::utils::createScaleTranslateB2DHomMatrix(mfScaleX, mfScaleY, maOfs.X(), maOfs.Y()));
1439  aRange.transform(aTransform);
1440  const Gradient& rGradient = rAct.GetGradient();
1441  SdrRectObj* pRect = new SdrRectObj(
1442  *mpModel,
1443  tools::Rectangle(
1444  floor(aRange.getMinX()),
1445  floor(aRange.getMinY()),
1446  ceil(aRange.getMaxX()),
1447  ceil(aRange.getMaxY())));
1448  // #i125211# Use the ranges from the SdrObject to create a new empty SfxItemSet
1449  SfxItemSet aGradientAttr(mpModel->GetItemPool(), pRect->GetMergedItemSet().GetRanges());
1450  const css::awt::GradientStyle aXGradientStyle(getXGradientStyleFromGradientStyle(rGradient.GetStyle()));
1451  const XFillGradientItem aXFillGradientItem(
1452  XGradient(
1453  rGradient.GetStartColor(),
1454  rGradient.GetEndColor(),
1455  aXGradientStyle,
1456  rGradient.GetAngle(),
1457  rGradient.GetOfsX(),
1458  rGradient.GetOfsY(),
1459  rGradient.GetBorder(),
1460  rGradient.GetStartIntensity(),
1461  rGradient.GetEndIntensity(),
1462  rGradient.GetSteps()));
1463 
1464  SetAttributes(pRect);
1465  aGradientAttr.Put(XFillStyleItem(drawing::FillStyle_GRADIENT)); // #i125211#
1466  aGradientAttr.Put(aXFillGradientItem);
1467  pRect->SetMergedItemSet(aGradientAttr);
1468 
1469  InsertObj(pRect, false);
1470 }
1471 
1472 void ImpSdrGDIMetaFileImport::DoAction(MetaTransparentAction const & rAct)
1473 {
1474  basegfx::B2DPolyPolygon aSource(rAct.GetPolyPolygon().getB2DPolyPolygon());
1475 
1476  if(!aSource.count())
1477  return;
1478 
1479  const basegfx::B2DHomMatrix aTransform(basegfx::utils::createScaleTranslateB2DHomMatrix(mfScaleX, mfScaleY, maOfs.X(), maOfs.Y()));
1480  aSource.transform(aTransform);
1481  aSource.setClosed(true);
1482 
1483  SdrPathObj* pPath = new SdrPathObj(
1484  *mpModel,
1485  OBJ_POLY,
1486  aSource);
1487  SetAttributes(pPath);
1488  pPath->SetMergedItem(XFillTransparenceItem(rAct.GetTransparence()));
1489  InsertObj(pPath, false);
1490 }
1491 
1492 void ImpSdrGDIMetaFileImport::DoAction(MetaGradientExAction const & rAct)
1493 {
1494  basegfx::B2DPolyPolygon aSource(rAct.GetPolyPolygon().getB2DPolyPolygon());
1495 
1496  if(!aSource.count())
1497  return;
1498 
1499  const basegfx::B2DHomMatrix aTransform(basegfx::utils::createScaleTranslateB2DHomMatrix(mfScaleX, mfScaleY, maOfs.X(), maOfs.Y()));
1500  aSource.transform(aTransform);
1501 
1502  if(mbLastObjWasPolyWithoutLine && CheckLastPolyLineAndFillMerge(aSource))
1503  return;
1504 
1505  const Gradient& rGradient = rAct.GetGradient();
1506  SdrPathObj* pPath = new SdrPathObj(
1507  *mpModel,
1508  OBJ_POLY,
1509  aSource);
1510  // #i125211# Use the ranges from the SdrObject to create a new empty SfxItemSet
1511  SfxItemSet aGradientAttr(mpModel->GetItemPool(), pPath->GetMergedItemSet().GetRanges());
1512  const css::awt::GradientStyle aXGradientStyle(getXGradientStyleFromGradientStyle(rGradient.GetStyle()));
1513  const XFillGradientItem aXFillGradientItem(
1514  XGradient(
1515  rGradient.GetStartColor(),
1516  rGradient.GetEndColor(),
1517  aXGradientStyle,
1518  rGradient.GetAngle(),
1519  rGradient.GetOfsX(),
1520  rGradient.GetOfsY(),
1521  rGradient.GetBorder(),
1522  rGradient.GetStartIntensity(),
1523  rGradient.GetEndIntensity(),
1524  rGradient.GetSteps()));
1525 
1526  SetAttributes(pPath);
1527  aGradientAttr.Put(XFillStyleItem(drawing::FillStyle_GRADIENT)); // #i125211#
1528  aGradientAttr.Put(aXFillGradientItem);
1529  pPath->SetMergedItemSet(aGradientAttr);
1530 
1531  InsertObj(pPath, false);
1532 }
1533 
1534 void ImpSdrGDIMetaFileImport::DoAction(MetaFloatTransparentAction const & rAct)
1535 {
1536  const GDIMetaFile& rMtf = rAct.GetGDIMetaFile();
1537 
1538  if(!rMtf.GetActionSize())
1539  return;
1540 
1541  const tools::Rectangle aRect(rAct.GetPoint(),rAct.GetSize());
1542 
1543  // convert metafile sub-content to BitmapEx
1544  BitmapEx aBitmapEx(
1545  convertMetafileToBitmapEx(
1546  rMtf,
1547  vcl::unotools::b2DRectangleFromRectangle(aRect),
1548  125000));
1549 
1550  // handle colors
1551  const Gradient& rGradient = rAct.GetGradient();
1552  basegfx::BColor aStart(rGradient.GetStartColor().getBColor());
1553  basegfx::BColor aEnd(rGradient.GetEndColor().getBColor());
1554 
1555  if(100 != rGradient.GetStartIntensity())
1556  {
1557  aStart *= static_cast<double>(rGradient.GetStartIntensity()) / 100.0;
1558  }
1559 
1560  if(100 != rGradient.GetEndIntensity())
1561  {
1562  aEnd *= static_cast<double>(rGradient.GetEndIntensity()) / 100.0;
1563  }
1564 
1565  const bool bEqualColors(aStart == aEnd);
1566  const bool bNoSteps(1 == rGradient.GetSteps());
1567  bool bCreateObject(true);
1568  bool bHasNewMask(false);
1569  AlphaMask aNewMask;
1570  double fTransparence(0.0);
1571  bool bFixedTransparence(false);
1572 
1573  if(bEqualColors || bNoSteps)
1574  {
1575  // single transparence
1576  const basegfx::BColor aMedium(basegfx::average(aStart, aEnd));
1577  fTransparence = aMedium.luminance();
1578 
1579  if(basegfx::fTools::lessOrEqual(fTransparence, 0.0))
1580  {
1581  // no transparence needed, all done
1582  }
1583  else if(basegfx::fTools::moreOrEqual(fTransparence, 1.0))
1584  {
1585  // all transparent, no object
1586  bCreateObject = false;
1587  }
1588  else
1589  {
1590  // 0.0 < transparence < 1.0, apply fixed transparence
1591  bFixedTransparence = true;
1592  }
1593  }
1594  else
1595  {
1596  // gradient transparence
1597  ScopedVclPtrInstance< VirtualDevice > pVDev;
1598 
1599  pVDev->SetOutputSizePixel(aBitmapEx.GetBitmap().GetSizePixel());
1600  pVDev->DrawGradient(tools::Rectangle(Point(0, 0), pVDev->GetOutputSizePixel()), rGradient);
1601 
1602  aNewMask = AlphaMask(pVDev->GetBitmap(Point(0, 0), pVDev->GetOutputSizePixel()));
1603  bHasNewMask = true;
1604  }
1605 
1606  if(!bCreateObject)
1607  return;
1608 
1609  if(bHasNewMask || bFixedTransparence)
1610  {
1611  if(!aBitmapEx.IsAlpha() && !aBitmapEx.IsTransparent())
1612  {
1613  // no transparence yet, apply new one
1614  if(bFixedTransparence)
1615  {
1616  sal_uInt8 aAlpha(basegfx::fround(fTransparence * 255.0));
1617 
1618  aNewMask = AlphaMask(aBitmapEx.GetBitmap().GetSizePixel(), &aAlpha);
1619  }
1620 
1621  aBitmapEx = BitmapEx(aBitmapEx.GetBitmap(), aNewMask);
1622  }
1623  else
1624  {
1625  vcl::bitmap::DrawAlphaBitmapAndAlphaGradient(aBitmapEx, bFixedTransparence, fTransparence, aNewMask);
1626  }
1627  }
1628 
1629  // create and add object
1630  SdrGrafObj* pGraf = new SdrGrafObj(
1631  *mpModel,
1632  aBitmapEx,
1633  aRect);
1634 
1635  // for MetaFloatTransparentAction, do not use SetAttributes(...)
1636  // since these metafile content is not used to draw line/fill
1637  // dependent of these setting at the device content
1638  pGraf->SetMergedItem(XLineStyleItem(drawing::LineStyle_NONE));
1639  pGraf->SetMergedItem(XFillStyleItem(drawing::FillStyle_NONE));
1640  InsertObj(pGraf);
1641 }
1642 
1643 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
tools::Rectangle::TopLeft
Point TopLeft() const
basegfx::fTools::lessOrEqual
static bool lessOrEqual(const double &rfValA, const double &rfValB)
MetaFloatTransparentAction::GetGradient
const Gradient & GetGradient() const
SvdProgressInfo::ReportRescales
void ReportRescales(size_t nRescaleCount)
Definition: svdetc.cxx:473
basegfx::fTools::moreOrEqual
static bool moreOrEqual(const double &rfValA, const double &rfValB)
SdrObject::TakeXorPoly
virtual basegfx::B2DPolyPolygon TakeXorPoly() const
The Xor-Polygon is required by the View to drag the object.
Definition: svdobj.cxx:1102
MetaLineAction::GetLineInfo
const LineInfo & GetLineInfo() const
LineInfo::GetLineCap
css::drawing::LineCap GetLineCap() const
makeSdrTextUpperDistItem
SdrMetricItem makeSdrTextUpperDistItem(tools::Long mnHeight)
Definition: sdtditm.hxx:35
basegfx::BColor::luminance
double luminance() const
FontAlign
#define FontAlign
MetaTextRectAction::GetStyle
DrawTextFlags GetStyle() const
EE_CHAR_FONTINFO_CJK
constexpr TypedWhichId< SvxFontItem > EE_CHAR_FONTINFO_CJK(EE_CHAR_START+17)
MetaMaskScalePartAction::GetDestSize
const Size & GetDestSize() const
basegfx::B2DPolygon::append
void append(const basegfx::B2DPoint &rPoint, sal_uInt32 nCount)
MetaMaskScaleAction::GetBitmap
const Bitmap & GetBitmap() const
bVisible
bool bVisible
MetaTextAction::GetLen
sal_Int32 GetLen() const
Gradient::GetStyle
GradientStyle GetStyle() const
MetaBmpScaleAction::GetPoint
const Point & GetPoint() const
SdrObject::IsClosedObj
bool IsClosedObj() const
Definition: svdobj.hxx:739
tools::Rectangle::AdjustRight
tools::Long AdjustRight(tools::Long nHorzMoveDelta)
MetaFloatTransparentAction::GetGDIMetaFile
const GDIMetaFile & GetGDIMetaFile() const
vcl::bitmap::DrawAlphaBitmapAndAlphaGradient
void DrawAlphaBitmapAndAlphaGradient(BitmapEx &rBitmapEx, bool bFixedTransparence, float fTransparence, AlphaMask &rNewMask)
SdrObject::NbcResize
virtual void NbcResize(const Point &rRef, const Fraction &xFact, const Fraction &yFact)
Definition: svdobj.cxx:1415
SDRATTR_TEXT_AUTOGROWWIDTH
constexpr TypedWhichId< SdrOnOffItem > SDRATTR_TEXT_AUTOGROWWIDTH(SDRATTR_MISC_FIRST+12)
Gradient::GetOfsY
sal_uInt16 GetOfsY() const
ImpSdrGDIMetaFileImport::ImportText
void ImportText(const Point &rPos, const OUString &rStr, const MetaAction &rAct)
Definition: svdfmtf.cxx:1002
Create
void Create(SwFormatVertOrient &rItem, SvStream &rStrm, sal_uInt16 nVersionAbusedAsSize)
sal_uLong
sal_uIntPtr sal_uLong
tools::Long
long Long
ImpSdrGDIMetaFileImport::mpTextAttr
std::unique_ptr< SfxItemSet > mpTextAttr
Definition: svdfmtf.hxx:54
SdrObjList::NbcInsertObject
virtual void NbcInsertObject(SdrObject *pObj, size_t nPos=SAL_MAX_SIZE)
Definition: svdpage.cxx:292
SdrObject::HasFillStyle
bool HasFillStyle() const
Definition: svdobj.cxx:3016
OBJ_LINE
object group
Definition: svdobjkind.hxx:28
XDash::GetDistance
sal_uInt32 GetDistance() const
Definition: xdash.hxx:59
ImpSdrGDIMetaFileImport::DoLoopActions
void DoLoopActions(GDIMetaFile const &rMtf, SvdProgressInfo *pProgrInfo, sal_uInt32 *pActionsToReport)
Definition: svdfmtf.cxx:118
Gradient::GetBorder
sal_uInt16 GetBorder() const
SdrObjList::GetObjCount
size_t GetObjCount() const
Definition: svdpage.cxx:752
OBJ_POLY
circle cut
Definition: svdobjkind.hxx:34
MetaFloatTransparentAction::GetPoint
const Point & GetPoint() const
EE_CHAR_ITALIC
constexpr TypedWhichId< SvxPostureItem > EE_CHAR_ITALIC(EE_CHAR_START+7)
MetaBmpScaleAction::GetSize
const Size & GetSize() const
MetaTransparentAction::GetPolyPolygon
const tools::PolyPolygon & GetPolyPolygon() const
tools::Rectangle::GetWidth
tools::Long GetWidth() const
MetaLineAction::GetEndPoint
const Point & GetEndPoint() const
ImpSdrGDIMetaFileImport::SetAttributes
void SetAttributes(SdrObject *pObj, bool bForceTextAttr=false)
Definition: svdfmtf.cxx:315
ImpSdrGDIMetaFileImport::maLineJoin
basegfx::B2DLineJoin maLineJoin
Definition: svdfmtf.hxx:59
MetaStretchTextAction::GetText
const OUString & GetText() const
basegfx::average
B2DTuple average(const B2DTuple &rOld1, const B2DTuple &rOld2)
ImpSdrGDIMetaFileImport::DoAction
void DoAction(MetaLineAction const &rAct)
Definition: svdfmtf.cxx:662
Bitmap::GetSizePixel
Size GetSizePixel() const
makeSdrTextRightDistItem
SdrMetricItem makeSdrTextRightDistItem(tools::Long mnHeight)
Definition: sdtditm.hxx:30
makeSdrTextLowerDistItem
SdrMetricItem makeSdrTextLowerDistItem(tools::Long mnHeight)
Definition: sdtditm.hxx:40
SdrObject::Free
static void Free(SdrObject *&_rpObject)
Definition: svdobj.cxx:467
basegfx::B2DRange::getMaxX
double getMaxX() const
MetaMaskScaleAction::GetPoint
const Point & GetPoint() const
EE_CHAR_FONTHEIGHT
constexpr TypedWhichId< SvxFontHeightItem > EE_CHAR_FONTHEIGHT(EE_CHAR_START+2)
SdrTextObj::HasText
virtual bool HasText() const override
Definition: svdotxat.cxx:416
makeSdrTextAutoGrowHeightItem
SdrOnOffItem makeSdrTextAutoGrowHeightItem(bool bAuto)
Definition: sdtagitm.hxx:25
NONE
NONE
basegfx::utils::clipPolyPolygonOnPolyPolygon
B2DPolyPolygon clipPolyPolygonOnPolyPolygon(const B2DPolyPolygon &rCandidate, const B2DPolyPolygon &rClip, bool bInside, bool bStroke)
basegfx::B2DPolyPolygon::getB2DRange
B2DRange getB2DRange() const
SdrRectObj
Rectangle objects (rectangle, circle, ...)
Definition: svdorect.hxx:39
tools::Rectangle::IsEmpty
bool IsEmpty() const
SdrPaintView::mpModel
SdrModel * mpModel
Definition: svdpntv.hxx:126
toDegree100
Degree100 toDegree100(Degree10 x)
basegfx::B2DPolyPolygon::getB2DPolygon
B2DPolygon const & getB2DPolygon(sal_uInt32 nIndex) const
SdrObject::ClearMergedItem
void ClearMergedItem(const sal_uInt16 nWhich=0)
Definition: svdobj.cxx:1969
XDash
Definition: xdash.hxx:31
LineInfo::GetDotCount
sal_uInt16 GetDotCount() const
MetaBmpExScaleAction::GetPoint
const Point & GetPoint() const
SdrObjListIter::IsMore
bool IsMore() const
Definition: svditer.hxx:62
MetaTextAction::GetText
const OUString & GetText() const
MetaMaskAction::GetColor
const Color & GetColor() const
basegfx::B2DRange::transform
BASEGFX_DLLPUBLIC void transform(const B2DHomMatrix &rMatrix)
EE_CHAR_FONTINFO_CTL
constexpr TypedWhichId< SvxFontItem > EE_CHAR_FONTINFO_CTL(EE_CHAR_START+18)
MetaBmpAction::GetBitmap
const Bitmap & GetBitmap() const
nCount
int nCount
ImpSdrGDIMetaFileImport::maScaleRect
tools::Rectangle maScaleRect
Definition: svdfmtf.hxx:50
MetaGradientAction::GetGradient
const Gradient & GetGradient() const
SdrObject::SetMergedItemSet
void SetMergedItemSet(const SfxItemSet &rSet, bool bClearAllItems=false)
Definition: svdobj.cxx:1979
basegfx::utils::createScaleTranslateB2DHomMatrix
B2DHomMatrix createScaleTranslateB2DHomMatrix(double fScaleX, double fScaleY, double fTranslateX, double fTranslateY)
XDash::GetDots
sal_uInt16 GetDots() const
Definition: xdash.hxx:55
GradientStyle
GradientStyle
o3tl::strong_int< sal_uInt8, struct SdrLayerIDTag >
makeSdrTextAutoGrowWidthItem
SdrOnOffItem makeSdrTextAutoGrowWidthItem(bool bAuto)
Definition: sdtagitm.hxx:30
MetaBmpExScaleAction::GetSize
const Size & GetSize() const
basegfx::B2DRange::getMaxY
double getMaxY() const
Hatch::GetStyle
HatchStyle GetStyle() const
basegfx::fround
B2IRange fround(const B2DRange &rRange)
basegfx::B2DPolygon::isClosed
bool isClosed() const
EE_CHAR_OUTLINE
constexpr TypedWhichId< SvxContourItem > EE_CHAR_OUTLINE(EE_CHAR_START+8)
EE_CHAR_WEIGHT
constexpr TypedWhichId< SvxWeightItem > EE_CHAR_WEIGHT(EE_CHAR_START+4)
LineInfo::GetDashCount
sal_uInt16 GetDashCount() const
SvdProgressInfo::SetInsertCount
void SetInsertCount(size_t _nInsertCount)
Definition: svdetc.cxx:484
ImpSdrGDIMetaFileImport::InsertObj
void InsertObj(SdrObject *pObj, bool bScale=true)
Definition: svdfmtf.cxx:447
SvdProgressInfo::SetActionCount
void SetActionCount(size_t _nActionCount)
Definition: svdetc.cxx:479
MetaMaskScalePartAction::GetSrcSize
const Size & GetSrcSize() const
EE_CHAR_SHADOW
constexpr TypedWhichId< SvxShadowedItem > EE_CHAR_SHADOW(EE_CHAR_START+9)
basegfx::B2DRange::isEmpty
bool isEmpty() const
LineInfo::GetDistance
sal_Int32 GetDistance() const
SdrObject::SetLayer
virtual void SetLayer(SdrLayerID nLayer)
Definition: svdobj.cxx:670
LineInfo::GetWidth
sal_Int32 GetWidth() const
ALIGN_BASELINE
ALIGN_BASELINE
LineInfo::GetLineJoin
basegfx::B2DLineJoin GetLineJoin() const
MetaRectAction::GetRect
const tools::Rectangle & GetRect() const
GDIMetaFile::GetPrefSize
const Size & GetPrefSize() const
basegfx::B2DPolyPolygon::isClosed
bool isClosed() const
i
int i
a
uno_Any a
MetaTransparentAction::GetTransparence
sal_uInt16 GetTransparence() const
MetaMaskScaleAction::GetSize
const Size & GetSize() const
MetaTextAction::GetPoint
const Point & GetPoint() const
FRound
tools::Long FRound(double fVal)
EE_CHAR_FONTWIDTH
constexpr TypedWhichId< SvxCharScaleWidthItem > EE_CHAR_FONTWIDTH(EE_CHAR_START+3)
maClip
basegfx::B2DPolyPolygon maClip
GetAngle
Degree100 GetAngle(const Point &rPnt)
The Y axis points down! The function negates the Y axis, when calculating the angle, such that GetAngle(Point(0,-1))=90 deg.
Definition: svdtrans.cxx:387
MetaBmpExAction::GetBitmapEx
const BitmapEx & GetBitmapEx() const
MetaGradientAction::GetRect
const tools::Rectangle & GetRect() const
SdrPathObj::NbcSetPathPoly
void NbcSetPathPoly(const basegfx::B2DPolyPolygon &rPathPoly)
Definition: svdopath.cxx:2728
XGradient::SetGradientStyle
void SetGradientStyle(css::awt::GradientStyle eNewStyle)
Definition: xgrad.hxx:57
Hatch::GetColor
const Color & GetColor() const
Gradient::GetOfsX
sal_uInt16 GetOfsX() const
MetaFloatTransparentAction::GetSize
const Size & GetSize() const
ImpSdrGDIMetaFileImport::DoImport
size_t DoImport(const GDIMetaFile &rMtf, SdrObjList &rDestList, size_t nInsPos, SvdProgressInfo *pProgrInfo=nullptr)
Definition: svdfmtf.cxx:210
convertMetafileToBitmapEx
BitmapEx convertMetafileToBitmapEx(const GDIMetaFile &rMtf, const basegfx::B2DRange &rTargetRange, const sal_uInt32 nMaximumQuadraticPixels)
Helper to convert any GDIMetaFile to a good quality BitmapEx, using default parameters and graphic::X...
Definition: svdpntv.cxx:103
Size::Width
tools::Long Width() const
SvdProgressInfo
Helper class for the communication between the dialog In order to break open Metafiles (sd/source/ui/...
Definition: svdetc.hxx:111
Color::SetRed
void SetRed(sal_uInt8 nRed)
B2DLineJoin
B2DLineJoin
basegfx::B2DHomMatrix::scale
void scale(double fX, double fY)
SdrPaintView::SdrGrafObj
friend class SdrGrafObj
Definition: svdpntv.hxx:119
SdrObject::getSdrModelFromSdrObject
SdrModel & getSdrModelFromSdrObject() const
Definition: svdobj.cxx:273
basegfx::B2DPolyPolygon::transform
void transform(const basegfx::B2DHomMatrix &rMatrix)
OBJ_PLIN
polygon, PolyPolygon
Definition: svdobjkind.hxx:35
MetaTextRectAction::GetText
const OUString & GetText() const
Gradient::GetEndIntensity
sal_uInt16 GetEndIntensity() const
ALIGN_BOTTOM
ALIGN_BOTTOM
MetaStretchTextAction::GetLen
sal_Int32 GetLen() const
SdrObject::SetMergedItem
void SetMergedItem(const SfxPoolItem &rItem)
Definition: svdobj.cxx:1964
MetaBmpExAction::GetPoint
const Point & GetPoint() const
MetaMaskAction::GetBitmap
const Bitmap & GetBitmap() const
SdrGrafObj
This class represents an embedded or linked bitmap graphic object.
Definition: svdograf.hxx:77
ImpSdrGDIMetaFileImport::mpFillAttr
std::unique_ptr< SfxItemSet > mpFillAttr
Definition: svdfmtf.hxx:53
SdrObject
Abstract DrawObject.
Definition: svdobj.hxx:260
SvdProgressInfo::ReportActions
bool ReportActions(size_t nActionCount)
Definition: svdetc.cxx:455
SdrTextObj::TakeContour
virtual basegfx::B2DPolyPolygon TakeContour() const override
contour for TextToContour
Definition: svdotext.cxx:1067
MetaMaskScalePartAction::GetBitmap
const Bitmap & GetBitmap() const
MetaMaskAction::GetPoint
const Point & GetPoint() const
LineInfo::GetDashLen
sal_Int32 GetDashLen() const
MetaBmpScaleAction::GetBitmap
const Bitmap & GetBitmap() const
Gradient::GetSteps
sal_uInt16 GetSteps() const
makeSdrTextLeftDistItem
SdrMetricItem makeSdrTextLeftDistItem(tools::Long mnHeight)
Definition: sdtditm.hxx:25
basegfx::B2DPolygon::transform
void transform(const basegfx::B2DHomMatrix &rMatrix)
SdrObject::GetLayer
virtual SdrLayerID GetLayer() const
Definition: svdobj.cxx:648
SdrObject::HasLineStyle
bool HasLineStyle() const
Definition: svdobj.cxx:3021
vcl::unotools::b2DRectangleFromRectangle
basegfx::B2DRange b2DRectangleFromRectangle(const ::tools::Rectangle &rRect)
Gradient::GetStartColor
const Color & GetStartColor() const
MetaHatchAction::GetPolyPolygon
const tools::PolyPolygon & GetPolyPolygon() const
MetaStretchTextAction::GetPoint
const Point & GetPoint() const
mnLayer
const int mnLayer
MetaMaskScaleAction::GetColor
const Color & GetColor() const
ImpSdrGDIMetaFileImport::isClip
bool isClip() const
Definition: svdfmtf.cxx:904
MetaLineAction::GetStartPoint
const Point & GetStartPoint() const
SdrObjListIter::Next
SdrObject * Next()
Definition: svditer.hxx:63
EE_CHAR_STRIKEOUT
constexpr TypedWhichId< SvxCrossedOutItem > EE_CHAR_STRIKEOUT(EE_CHAR_START+6)
SdrObject::ConvertToPolyObj
SdrObjectUniquePtr ConvertToPolyObj(bool bBezier, bool bLineToArea) const
Definition: svdobj.cxx:2571
ImpSdrGDIMetaFileImport::maTmpList
::std::vector< SdrObject * > maTmpList
Definition: svdfmtf.hxx:48
basegfx::B2DRange::getMinY
double getMinY() const
Gradient::GetAngle
Degree10 GetAngle() const
MetaBmpExScaleAction::GetBitmapEx
const BitmapEx & GetBitmapEx() const
basegfx::B2DPolyPolygon::count
sal_uInt32 count() const
XDash::GetDotLen
sal_uInt32 GetDotLen() const
Definition: xdash.hxx:56
ImpSdrGDIMetaFileImport::mpLineAttr
std::unique_ptr< SfxItemSet > mpLineAttr
Definition: svdfmtf.hxx:52
ImpSdrGDIMetaFileImport::maClip
basegfx::B2DPolyPolygon maClip
Definition: svdfmtf.hxx:82
tools::PolyPolygon::getB2DPolyPolygon
::basegfx::B2DPolyPolygon getB2DPolyPolygon() const
EE_CHAR_FONTHEIGHT_CTL
constexpr TypedWhichId< SvxFontHeightItem > EE_CHAR_FONTHEIGHT_CTL(EE_CHAR_START+20)
MetaMaskScalePartAction::GetColor
const Color & GetColor() const
sal_uInt8
unsigned char sal_uInt8
LineInfo::GetDotLen
sal_Int32 GetDotLen() const
SdrObject::NbcMove
virtual void NbcMove(const Size &rSiz)
The methods Move, Resize, Rotate, Mirror, Shear, SetSnapRect and SetLogicRect call the corresponding ...
Definition: svdobj.cxx:1409
GDIMetaFile::GetAction
MetaAction * GetAction(size_t nAction) const
SdrObject::GetMergedItemSet
const SfxItemSet & GetMergedItemSet() const
Definition: svdobj.cxx:1954
EE_CHAR_COLOR
constexpr TypedWhichId< SvxColorItem > EE_CHAR_COLOR(EE_CHAR_START+0)
Gradient::GetEndColor
const Color & GetEndColor() const
MetaBmpAction::GetPoint
const Point & GetPoint() const
SdrTextObj::NbcSetText
void NbcSetText(const OUString &rStr)
Definition: svdotext.cxx:239
EE_CHAR_WLM
constexpr TypedWhichId< SvxWordLineModeItem > EE_CHAR_WLM(EE_CHAR_START+13)
MetaMaskScalePartAction::GetDestPoint
const Point & GetDestPoint() const
SdrObject::CloneSdrObject
virtual SdrObject * CloneSdrObject(SdrModel &rTargetModel) const
Definition: svdobj.cxx:1048
ImpSdrGDIMetaFileImport::CheckLastLineMerge
bool CheckLastLineMerge(const basegfx::B2DPolygon &rSrcPoly)
Definition: svdfmtf.cxx:785
EE_CHAR_OVERLINE
constexpr TypedWhichId< SvxOverlineItem > EE_CHAR_OVERLINE(EE_CHAR_START+29)
Size::Height
tools::Long Height() const
GDIMetaFile::GetActionSize
size_t GetActionSize() const
ImpSdrGDIMetaFileImport::mbLastObjWasPolyWithoutLine
bool mbLastObjWasPolyWithoutLine
Definition: svdfmtf.hxx:74
EE_CHAR_FONTINFO
constexpr TypedWhichId< SvxFontItem > EE_CHAR_FONTINFO(EE_CHAR_START+1)
MetaAction::GetType
MetaActionType GetType() const
basegfx::B2DHomMatrix::translate
void translate(double fX, double fY)
Hatch::GetDistance
tools::Long GetDistance() const
SdrPathObj::GetPathPoly
const basegfx::B2DPolyPolygon & GetPathPoly() const
Definition: svdopath.hxx:141
Color::getBColor
basegfx::BColor getBColor() const
SvdProgressInfo::ReportInserts
void ReportInserts(size_t nInsertCount)
Definition: svdetc.cxx:465
MetaHatchAction::GetHatch
const Hatch & GetHatch() const
MetaMaskScalePartAction::GetSrcPoint
const Point & GetSrcPoint() const
tools::Rectangle::GetHeight
tools::Long GetHeight() const
SdrObject::SetSnapRect
virtual void SetSnapRect(const tools::Rectangle &rRect)
Definition: svdobj.cxx:1667
SfxItemSet::GetRanges
const sal_uInt16 * GetRanges() const
EE_CHAR_UNDERLINE
constexpr TypedWhichId< SvxUnderlineItem > EE_CHAR_UNDERLINE(EE_CHAR_START+5)
EE_CHAR_FONTHEIGHT_CJK
constexpr TypedWhichId< SvxFontHeightItem > EE_CHAR_FONTHEIGHT_CJK(EE_CHAR_START+19)
SdrModel::GetItemPool
const SfxItemPool & GetItemPool() const
Definition: svdmodel.hxx:314
basegfx::B2DRange::getMinX
double getMinX() const
MetaCommentAction::GetComment
const OString & GetComment() const
MetaLineColorAction::Execute
virtual void Execute(OutputDevice *pOut) override
XDash::GetDashLen
sal_uInt32 GetDashLen() const
Definition: xdash.hxx:58
Hatch::GetAngle
Degree10 GetAngle() const
BitmapEx::GetSizePixel
const Size & GetSizePixel() const
SDRATTR_ECKENRADIUS
constexpr TypedWhichId< SdrMetricItem > SDRATTR_ECKENRADIUS(SDRATTR_MISC_FIRST+0)
OBJ_TEXT
periodic cubic Spline (ni)
Definition: svdobjkind.hxx:42
BitmapEx::Crop
bool Crop(const tools::Rectangle &rRectPixel)
Gradient::GetStartIntensity
sal_uInt16 GetStartIntensity() const
SdrObject::GetOutlinerParaObject
virtual OutlinerParaObject * GetOutlinerParaObject() const
Definition: svdobj.cxx:1813
MetaTextRectAction::GetRect
const tools::Rectangle & GetRect() const
aStr
aStr
ImpSdrGDIMetaFileImport::CheckLastPolyLineAndFillMerge
bool CheckLastPolyLineAndFillMerge(const basegfx::B2DPolyPolygon &rPolyPolygon)
Definition: svdfmtf.cxx:857
MetaStretchTextAction::GetIndex
sal_Int32 GetIndex() const
ImpSdrGDIMetaFileImport::ImpSdrGDIMetaFileImport
ImpSdrGDIMetaFileImport(const ImpSdrGDIMetaFileImport &)=delete
basegfx::utils::isRectangle
bool isRectangle(const B2DPolygon &rPoly)
MetaTextAction::GetIndex
sal_Int32 GetIndex() const
ImpSdrGDIMetaFileImport::maLineCap
css::drawing::LineCap maLineCap
Definition: svdfmtf.hxx:60
XDash::GetDashes
sal_uInt16 GetDashes() const
Definition: xdash.hxx:57
basegfx::B2DPolygon::count
sal_uInt32 count() const
basegfx::B2DPolygon::getB2DPoint
basegfx::B2DPoint const & getB2DPoint(sal_uInt32 nIndex) const
ImpSdrGDIMetaFileImport::mpVD
ScopedVclPtr< VirtualDevice > mpVD
Definition: svdfmtf.hxx:49
Generated on Sat Feb 27 2021 02:36:03 for LibreOffice Module svx (master) by   doxygen 1.8.10