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  tools::Long nStart=GetAngle(rAct.GetStartPoint()-aCenter);
746  tools::Long 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  tools::Long nStart=GetAngle(rAct.GetStartPoint()-aCenter);
759  tools::Long 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  tools::Long nStart=GetAngle(rAct.GetStartPoint()-aCenter);
774  tools::Long 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  sal_Int32 nAngle = aFnt.GetOrientation().get();
1057  if ( nAngle )
1058  {
1059  nAngle*=10;
1060  double a = nAngle * F_PI18000;
1061  double nSin=sin(a);
1062  double nCos=cos(a);
1063  pText->NbcRotate(aPos,nAngle,nSin,nCos);
1064  }
1065  InsertObj( pText, false );
1066 }
1067 
1068 void ImpSdrGDIMetaFileImport::DoAction(MetaTextAction const & rAct)
1069 {
1070  OUString aStr(rAct.GetText());
1071  aStr = aStr.copy(rAct.GetIndex(), rAct.GetLen());
1072  ImportText( rAct.GetPoint(), aStr, rAct );
1073 }
1074 
1075 void ImpSdrGDIMetaFileImport::DoAction(MetaTextArrayAction const & rAct)
1076 {
1077  OUString aStr(rAct.GetText());
1078  aStr = aStr.copy(rAct.GetIndex(), rAct.GetLen());
1079  ImportText( rAct.GetPoint(), aStr, rAct );
1080 }
1081 
1082 void ImpSdrGDIMetaFileImport::DoAction(MetaStretchTextAction const & rAct)
1083 {
1084  OUString aStr(rAct.GetText());
1085  aStr = aStr.copy(rAct.GetIndex(), rAct.GetLen());
1086  ImportText( rAct.GetPoint(), aStr, rAct );
1087 }
1088 
1089 void ImpSdrGDIMetaFileImport::DoAction(MetaBmpAction const & rAct)
1090 {
1091  tools::Rectangle aRect(rAct.GetPoint(),rAct.GetBitmap().GetSizePixel());
1092  aRect.AdjustRight( 1 ); aRect.AdjustBottom( 1 );
1093  SdrGrafObj* pGraf = new SdrGrafObj(
1094  *mpModel,
1095  Graphic(BitmapEx(rAct.GetBitmap())),
1096  aRect);
1097 
1098  // This action is not creating line and fill, set directly, do not use SetAttributes(..)
1099  pGraf->SetMergedItem(XLineStyleItem(drawing::LineStyle_NONE));
1100  pGraf->SetMergedItem(XFillStyleItem(drawing::FillStyle_NONE));
1101  InsertObj(pGraf);
1102 }
1103 
1104 void ImpSdrGDIMetaFileImport::DoAction(MetaBmpScaleAction const & rAct)
1105 {
1106  tools::Rectangle aRect(rAct.GetPoint(),rAct.GetSize());
1107  aRect.AdjustRight( 1 ); aRect.AdjustBottom( 1 );
1108  SdrGrafObj* pGraf = new SdrGrafObj(
1109  *mpModel,
1110  Graphic(BitmapEx(rAct.GetBitmap())),
1111  aRect);
1112 
1113  // This action is not creating line and fill, set directly, do not use SetAttributes(..)
1114  pGraf->SetMergedItem(XLineStyleItem(drawing::LineStyle_NONE));
1115  pGraf->SetMergedItem(XFillStyleItem(drawing::FillStyle_NONE));
1116  InsertObj(pGraf);
1117 }
1118 
1119 void ImpSdrGDIMetaFileImport::DoAction(MetaBmpExAction const & rAct)
1120 {
1121  tools::Rectangle aRect(rAct.GetPoint(),rAct.GetBitmapEx().GetSizePixel());
1122  aRect.AdjustRight( 1 ); aRect.AdjustBottom( 1 );
1123  SdrGrafObj* pGraf = new SdrGrafObj(
1124  *mpModel,
1125  rAct.GetBitmapEx(),
1126  aRect);
1127 
1128  // This action is not creating line and fill, set directly, do not use SetAttributes(..)
1129  pGraf->SetMergedItem(XLineStyleItem(drawing::LineStyle_NONE));
1130  pGraf->SetMergedItem(XFillStyleItem(drawing::FillStyle_NONE));
1131  InsertObj(pGraf);
1132 }
1133 
1134 void ImpSdrGDIMetaFileImport::DoAction(MetaBmpExScaleAction const & rAct)
1135 {
1136  tools::Rectangle aRect(rAct.GetPoint(),rAct.GetSize());
1137  aRect.AdjustRight( 1 ); aRect.AdjustBottom( 1 );
1138  SdrGrafObj* pGraf = new SdrGrafObj(
1139  *mpModel,
1140  rAct.GetBitmapEx(),
1141  aRect);
1142 
1143  // This action is not creating line and fill, set directly, do not use SetAttributes(..)
1144  pGraf->SetMergedItem(XLineStyleItem(drawing::LineStyle_NONE));
1145  pGraf->SetMergedItem(XFillStyleItem(drawing::FillStyle_NONE));
1146  InsertObj(pGraf);
1147 }
1148 
1149 
1150 void ImpSdrGDIMetaFileImport::DoAction( MetaHatchAction const & rAct )
1151 {
1152  // #i73407# reformulation to use new B2DPolygon classes
1153  basegfx::B2DPolyPolygon aSource(rAct.GetPolyPolygon().getB2DPolyPolygon());
1154 
1155  if(!aSource.count())
1156  return;
1157 
1158  const basegfx::B2DHomMatrix aTransform(basegfx::utils::createScaleTranslateB2DHomMatrix(mfScaleX, mfScaleY, maOfs.X(), maOfs.Y()));
1159  aSource.transform(aTransform);
1160 
1161  if(mbLastObjWasPolyWithoutLine && CheckLastPolyLineAndFillMerge(aSource))
1162  return;
1163 
1164  const Hatch& rHatch = rAct.GetHatch();
1165  SdrPathObj* pPath = new SdrPathObj(
1166  *mpModel,
1167  OBJ_POLY,
1168  aSource);
1169  // #i125211# Use the ranges from the SdrObject to create a new empty SfxItemSet
1170  SfxItemSet aHatchAttr(mpModel->GetItemPool(), pPath->GetMergedItemSet().GetRanges());
1171  css::drawing::HatchStyle eStyle;
1172 
1173  switch(rHatch.GetStyle())
1174  {
1175  case HatchStyle::Triple :
1176  {
1177  eStyle = css::drawing::HatchStyle_TRIPLE;
1178  break;
1179  }
1180 
1181  case HatchStyle::Double :
1182  {
1183  eStyle = css::drawing::HatchStyle_DOUBLE;
1184  break;
1185  }
1186 
1187  default:
1188  {
1189  eStyle = css::drawing::HatchStyle_SINGLE;
1190  break;
1191  }
1192  }
1193 
1194  SetAttributes(pPath);
1195  aHatchAttr.Put(XFillStyleItem(drawing::FillStyle_HATCH));
1196  aHatchAttr.Put(XFillHatchItem(XHatch(rHatch.GetColor(), eStyle, rHatch.GetDistance(), rHatch.GetAngle())));
1197  pPath->SetMergedItemSet(aHatchAttr);
1198 
1199  InsertObj(pPath, false);
1200 }
1201 
1202 
1203 void ImpSdrGDIMetaFileImport::DoAction(MetaLineColorAction& rAct)
1204 {
1205  rAct.Execute(mpVD);
1206 }
1207 
1208 void ImpSdrGDIMetaFileImport::DoAction(MetaMapModeAction& rAct)
1209 {
1210  MapScaling();
1211  rAct.Execute(mpVD);
1212  mbLastObjWasPolyWithoutLine = false;
1213  mbLastObjWasLine = false;
1214 }
1215 
1216 void ImpSdrGDIMetaFileImport::MapScaling()
1217 {
1218  const size_t nCount(maTmpList.size());
1219  const MapMode& rMap = mpVD->GetMapMode();
1220  Point aMapOrg( rMap.GetOrigin() );
1221  bool bMov2(aMapOrg.X() != 0 || aMapOrg.Y() != 0);
1222 
1223  if(bMov2)
1224  {
1225  for(size_t i = mnMapScalingOfs; i < nCount; i++)
1226  {
1227  SdrObject* pObj = maTmpList[i];
1228 
1229  pObj->NbcMove(Size(aMapOrg.X(), aMapOrg.Y()));
1230  }
1231  }
1232 
1233  mnMapScalingOfs = nCount;
1234 }
1235 
1236 
1237 void ImpSdrGDIMetaFileImport::DoAction( MetaCommentAction const & rAct, GDIMetaFile const & rMtf, sal_uLong& a) // GDIMetaFile* pMtf )
1238 {
1239  bool aSkipComment = false;
1240 
1241  if (a < rMtf.GetActionSize() && rAct.GetComment().equalsIgnoreAsciiCase("XGRAD_SEQ_BEGIN"))
1242  {
1243  // #i125211# Check if next action is a MetaGradientExAction
1244  MetaGradientExAction* pAct = dynamic_cast< MetaGradientExAction* >(rMtf.GetAction(a + 1));
1245 
1246  if( pAct && pAct->GetType() == MetaActionType::GRADIENTEX )
1247  {
1248  // #i73407# reformulation to use new B2DPolygon classes
1249  basegfx::B2DPolyPolygon aSource(pAct->GetPolyPolygon().getB2DPolyPolygon());
1250 
1251  if(aSource.count())
1252  {
1253  if(!mbLastObjWasPolyWithoutLine || !CheckLastPolyLineAndFillMerge(aSource))
1254  {
1255  const Gradient& rGrad = pAct->GetGradient();
1256  SdrPathObj* pPath = new SdrPathObj(
1257  *mpModel,
1258  OBJ_POLY,
1259  aSource);
1260  // #i125211# Use the ranges from the SdrObject to create a new empty SfxItemSet
1261  SfxItemSet aGradAttr(mpModel->GetItemPool(), pPath->GetMergedItemSet().GetRanges());
1262  XGradient aXGradient;
1263 
1264  aXGradient.SetGradientStyle(static_cast<css::awt::GradientStyle>(rGrad.GetStyle()));
1265  aXGradient.SetStartColor(rGrad.GetStartColor());
1266  aXGradient.SetEndColor(rGrad.GetEndColor());
1267  aXGradient.SetAngle(rGrad.GetAngle());
1268  aXGradient.SetBorder(rGrad.GetBorder());
1269  aXGradient.SetXOffset(rGrad.GetOfsX());
1270  aXGradient.SetYOffset(rGrad.GetOfsY());
1271  aXGradient.SetStartIntens(rGrad.GetStartIntensity());
1272  aXGradient.SetEndIntens(rGrad.GetEndIntensity());
1273  aXGradient.SetSteps(rGrad.GetSteps());
1274 
1275  // no need to use SetAttributes(..) here since line and fill style
1276  // need to be set individually
1277  // SetAttributes(pPath);
1278 
1279  // switch line off; if there was one there will be a
1280  // MetaActionType::POLYLINE following creating another object
1281  aGradAttr.Put(XLineStyleItem(drawing::LineStyle_NONE));
1282 
1283  // add detected gradient fillstyle
1284  aGradAttr.Put(XFillStyleItem(drawing::FillStyle_GRADIENT));
1285  aGradAttr.Put(XFillGradientItem(aXGradient));
1286 
1287  pPath->SetMergedItemSet(aGradAttr);
1288 
1289  InsertObj(pPath);
1290  }
1291  }
1292 
1293  aSkipComment = true;
1294  }
1295  }
1296 
1297  if(aSkipComment)
1298  {
1299  // #i125211# forward until closing MetaCommentAction
1300  MetaAction* pSkipAct = rMtf.GetAction(++a);
1301 
1302  while( pSkipAct
1303  && ((pSkipAct->GetType() != MetaActionType::COMMENT )
1304  || !(static_cast<MetaCommentAction*>(pSkipAct)->GetComment().equalsIgnoreAsciiCase("XGRAD_SEQ_END"))))
1305  {
1306  pSkipAct = rMtf.GetAction(++a);
1307  }
1308  }
1309 }
1310 
1311 void ImpSdrGDIMetaFileImport::DoAction(MetaTextRectAction const & rAct)
1312 {
1313  GDIMetaFile aTemp;
1314 
1315  mpVD->AddTextRectActions(rAct.GetRect(), rAct.GetText(), rAct.GetStyle(), aTemp);
1316  DoLoopActions(aTemp, nullptr, nullptr);
1317 }
1318 
1319 void ImpSdrGDIMetaFileImport::DoAction(MetaBmpScalePartAction const & rAct)
1320 {
1321  tools::Rectangle aRect(rAct.GetDestPoint(), rAct.GetDestSize());
1322  BitmapEx aBitmapEx(rAct.GetBitmap());
1323 
1324  aRect.AdjustRight( 1 );
1325  aRect.AdjustBottom( 1 );
1326  aBitmapEx.Crop(tools::Rectangle(rAct.GetSrcPoint(), rAct.GetSrcSize()));
1327  SdrGrafObj* pGraf = new SdrGrafObj(
1328  *mpModel,
1329  aBitmapEx,
1330  aRect);
1331 
1332  // This action is not creating line and fill, set directly, do not use SetAttributes(..)
1333  pGraf->SetMergedItem(XLineStyleItem(drawing::LineStyle_NONE));
1334  pGraf->SetMergedItem(XFillStyleItem(drawing::FillStyle_NONE));
1335  InsertObj(pGraf);
1336 }
1337 
1338 void ImpSdrGDIMetaFileImport::DoAction(MetaBmpExScalePartAction const & rAct)
1339 {
1340  tools::Rectangle aRect(rAct.GetDestPoint(),rAct.GetDestSize());
1341  BitmapEx aBitmapEx(rAct.GetBitmapEx());
1342 
1343  aRect.AdjustRight( 1 );
1344  aRect.AdjustBottom( 1 );
1345  aBitmapEx.Crop(tools::Rectangle(rAct.GetSrcPoint(), rAct.GetSrcSize()));
1346  SdrGrafObj* pGraf = new SdrGrafObj(
1347  *mpModel,
1348  aBitmapEx,
1349  aRect);
1350 
1351  // This action is not creating line and fill, set directly, do not use SetAttributes(..)
1352  pGraf->SetMergedItem(XLineStyleItem(drawing::LineStyle_NONE));
1353  pGraf->SetMergedItem(XFillStyleItem(drawing::FillStyle_NONE));
1354  InsertObj(pGraf);
1355 }
1356 
1357 void ImpSdrGDIMetaFileImport::DoAction(MetaMaskAction const & rAct)
1358 {
1359  tools::Rectangle aRect(rAct.GetPoint(), rAct.GetBitmap().GetSizePixel());
1360  BitmapEx aBitmapEx(rAct.GetBitmap(), rAct.GetColor());
1361 
1362  aRect.AdjustRight( 1 ); aRect.AdjustBottom( 1 );
1363  SdrGrafObj* pGraf = new SdrGrafObj(
1364  *mpModel,
1365  aBitmapEx,
1366  aRect);
1367 
1368  // This action is not creating line and fill, set directly, do not use SetAttributes(..)
1369  pGraf->SetMergedItem(XLineStyleItem(drawing::LineStyle_NONE));
1370  pGraf->SetMergedItem(XFillStyleItem(drawing::FillStyle_NONE));
1371  InsertObj(pGraf);
1372 }
1373 
1374 void ImpSdrGDIMetaFileImport::DoAction(MetaMaskScaleAction const & rAct)
1375 {
1376  tools::Rectangle aRect(rAct.GetPoint(), rAct.GetSize());
1377  BitmapEx aBitmapEx(rAct.GetBitmap(), rAct.GetColor());
1378 
1379  aRect.AdjustRight( 1 ); aRect.AdjustBottom( 1 );
1380  SdrGrafObj* pGraf = new SdrGrafObj(
1381  *mpModel,
1382  aBitmapEx,
1383  aRect);
1384 
1385  // This action is not creating line and fill, set directly, do not use SetAttributes(..)
1386  pGraf->SetMergedItem(XLineStyleItem(drawing::LineStyle_NONE));
1387  pGraf->SetMergedItem(XFillStyleItem(drawing::FillStyle_NONE));
1388  InsertObj(pGraf);
1389 }
1390 
1391 void ImpSdrGDIMetaFileImport::DoAction(MetaMaskScalePartAction const & rAct)
1392 {
1393  tools::Rectangle aRect(rAct.GetDestPoint(), rAct.GetDestSize());
1394  BitmapEx aBitmapEx(rAct.GetBitmap(), rAct.GetColor());
1395 
1396  aRect.AdjustRight( 1 ); aRect.AdjustBottom( 1 );
1397  aBitmapEx.Crop(tools::Rectangle(rAct.GetSrcPoint(), rAct.GetSrcSize()));
1398  SdrGrafObj* pGraf = new SdrGrafObj(
1399  *mpModel,
1400  aBitmapEx,
1401  aRect);
1402 
1403  // This action is not creating line and fill, set directly, do not use SetAttributes(..)
1404  pGraf->SetMergedItem(XLineStyleItem(drawing::LineStyle_NONE));
1405  pGraf->SetMergedItem(XFillStyleItem(drawing::FillStyle_NONE));
1406  InsertObj(pGraf);
1407 }
1408 
1409 namespace
1410 {
1411  css::awt::GradientStyle getXGradientStyleFromGradientStyle(const GradientStyle& rGradientStyle)
1412  {
1413  css::awt::GradientStyle aXGradientStyle(css::awt::GradientStyle_LINEAR);
1414 
1415  switch(rGradientStyle)
1416  {
1417  case GradientStyle::Linear: aXGradientStyle = css::awt::GradientStyle_LINEAR; break;
1418  case GradientStyle::Axial: aXGradientStyle = css::awt::GradientStyle_AXIAL; break;
1419  case GradientStyle::Radial: aXGradientStyle = css::awt::GradientStyle_RADIAL; break;
1420  case GradientStyle::Elliptical: aXGradientStyle = css::awt::GradientStyle_ELLIPTICAL; break;
1421  case GradientStyle::Square: aXGradientStyle = css::awt::GradientStyle_SQUARE; break;
1422  case GradientStyle::Rect: aXGradientStyle = css::awt::GradientStyle_RECT; break;
1423 
1424  // Needed due to GradientStyle::FORCE_EQUAL_SIZE; this again is needed
1425  // to force the enum defines in VCL to a defined size for the compilers,
1426  // so despite it is never used it cannot be removed (would break the
1427  // API implementation probably).
1428  case GradientStyle::FORCE_EQUAL_SIZE: break;
1429  default:
1430  break;
1431  }
1432 
1433  return aXGradientStyle;
1434  }
1435 }
1436 
1437 void ImpSdrGDIMetaFileImport::DoAction(MetaGradientAction const & rAct)
1438 {
1439  basegfx::B2DRange aRange = vcl::unotools::b2DRectangleFromRectangle(rAct.GetRect());
1440 
1441  if(aRange.isEmpty())
1442  return;
1443 
1444  const basegfx::B2DHomMatrix aTransform(basegfx::utils::createScaleTranslateB2DHomMatrix(mfScaleX, mfScaleY, maOfs.X(), maOfs.Y()));
1445  aRange.transform(aTransform);
1446  const Gradient& rGradient = rAct.GetGradient();
1447  SdrRectObj* pRect = new SdrRectObj(
1448  *mpModel,
1449  tools::Rectangle(
1450  floor(aRange.getMinX()),
1451  floor(aRange.getMinY()),
1452  ceil(aRange.getMaxX()),
1453  ceil(aRange.getMaxY())));
1454  // #i125211# Use the ranges from the SdrObject to create a new empty SfxItemSet
1455  SfxItemSet aGradientAttr(mpModel->GetItemPool(), pRect->GetMergedItemSet().GetRanges());
1456  const css::awt::GradientStyle aXGradientStyle(getXGradientStyleFromGradientStyle(rGradient.GetStyle()));
1457  const XFillGradientItem aXFillGradientItem(
1458  XGradient(
1459  rGradient.GetStartColor(),
1460  rGradient.GetEndColor(),
1461  aXGradientStyle,
1462  rGradient.GetAngle(),
1463  rGradient.GetOfsX(),
1464  rGradient.GetOfsY(),
1465  rGradient.GetBorder(),
1466  rGradient.GetStartIntensity(),
1467  rGradient.GetEndIntensity(),
1468  rGradient.GetSteps()));
1469 
1470  SetAttributes(pRect);
1471  aGradientAttr.Put(XFillStyleItem(drawing::FillStyle_GRADIENT)); // #i125211#
1472  aGradientAttr.Put(aXFillGradientItem);
1473  pRect->SetMergedItemSet(aGradientAttr);
1474 
1475  InsertObj(pRect, false);
1476 }
1477 
1478 void ImpSdrGDIMetaFileImport::DoAction(MetaTransparentAction const & rAct)
1479 {
1480  basegfx::B2DPolyPolygon aSource(rAct.GetPolyPolygon().getB2DPolyPolygon());
1481 
1482  if(!aSource.count())
1483  return;
1484 
1485  const basegfx::B2DHomMatrix aTransform(basegfx::utils::createScaleTranslateB2DHomMatrix(mfScaleX, mfScaleY, maOfs.X(), maOfs.Y()));
1486  aSource.transform(aTransform);
1487  aSource.setClosed(true);
1488 
1489  SdrPathObj* pPath = new SdrPathObj(
1490  *mpModel,
1491  OBJ_POLY,
1492  aSource);
1493  SetAttributes(pPath);
1494  pPath->SetMergedItem(XFillTransparenceItem(rAct.GetTransparence()));
1495  InsertObj(pPath, false);
1496 }
1497 
1498 void ImpSdrGDIMetaFileImport::DoAction(MetaGradientExAction const & rAct)
1499 {
1500  basegfx::B2DPolyPolygon aSource(rAct.GetPolyPolygon().getB2DPolyPolygon());
1501 
1502  if(!aSource.count())
1503  return;
1504 
1505  const basegfx::B2DHomMatrix aTransform(basegfx::utils::createScaleTranslateB2DHomMatrix(mfScaleX, mfScaleY, maOfs.X(), maOfs.Y()));
1506  aSource.transform(aTransform);
1507 
1508  if(mbLastObjWasPolyWithoutLine && CheckLastPolyLineAndFillMerge(aSource))
1509  return;
1510 
1511  const Gradient& rGradient = rAct.GetGradient();
1512  SdrPathObj* pPath = new SdrPathObj(
1513  *mpModel,
1514  OBJ_POLY,
1515  aSource);
1516  // #i125211# Use the ranges from the SdrObject to create a new empty SfxItemSet
1517  SfxItemSet aGradientAttr(mpModel->GetItemPool(), pPath->GetMergedItemSet().GetRanges());
1518  const css::awt::GradientStyle aXGradientStyle(getXGradientStyleFromGradientStyle(rGradient.GetStyle()));
1519  const XFillGradientItem aXFillGradientItem(
1520  XGradient(
1521  rGradient.GetStartColor(),
1522  rGradient.GetEndColor(),
1523  aXGradientStyle,
1524  rGradient.GetAngle(),
1525  rGradient.GetOfsX(),
1526  rGradient.GetOfsY(),
1527  rGradient.GetBorder(),
1528  rGradient.GetStartIntensity(),
1529  rGradient.GetEndIntensity(),
1530  rGradient.GetSteps()));
1531 
1532  SetAttributes(pPath);
1533  aGradientAttr.Put(XFillStyleItem(drawing::FillStyle_GRADIENT)); // #i125211#
1534  aGradientAttr.Put(aXFillGradientItem);
1535  pPath->SetMergedItemSet(aGradientAttr);
1536 
1537  InsertObj(pPath, false);
1538 }
1539 
1540 void ImpSdrGDIMetaFileImport::DoAction(MetaFloatTransparentAction const & rAct)
1541 {
1542  const GDIMetaFile& rMtf = rAct.GetGDIMetaFile();
1543 
1544  if(!rMtf.GetActionSize())
1545  return;
1546 
1547  const tools::Rectangle aRect(rAct.GetPoint(),rAct.GetSize());
1548 
1549  // convert metafile sub-content to BitmapEx
1550  BitmapEx aBitmapEx(
1551  convertMetafileToBitmapEx(
1552  rMtf,
1553  vcl::unotools::b2DRectangleFromRectangle(aRect),
1554  125000));
1555 
1556  // handle colors
1557  const Gradient& rGradient = rAct.GetGradient();
1558  basegfx::BColor aStart(rGradient.GetStartColor().getBColor());
1559  basegfx::BColor aEnd(rGradient.GetEndColor().getBColor());
1560 
1561  if(100 != rGradient.GetStartIntensity())
1562  {
1563  aStart *= static_cast<double>(rGradient.GetStartIntensity()) / 100.0;
1564  }
1565 
1566  if(100 != rGradient.GetEndIntensity())
1567  {
1568  aEnd *= static_cast<double>(rGradient.GetEndIntensity()) / 100.0;
1569  }
1570 
1571  const bool bEqualColors(aStart == aEnd);
1572  const bool bNoSteps(1 == rGradient.GetSteps());
1573  bool bCreateObject(true);
1574  bool bHasNewMask(false);
1575  AlphaMask aNewMask;
1576  double fTransparence(0.0);
1577  bool bFixedTransparence(false);
1578 
1579  if(bEqualColors || bNoSteps)
1580  {
1581  // single transparence
1582  const basegfx::BColor aMedium(basegfx::average(aStart, aEnd));
1583  fTransparence = aMedium.luminance();
1584 
1585  if(basegfx::fTools::lessOrEqual(fTransparence, 0.0))
1586  {
1587  // no transparence needed, all done
1588  }
1589  else if(basegfx::fTools::moreOrEqual(fTransparence, 1.0))
1590  {
1591  // all transparent, no object
1592  bCreateObject = false;
1593  }
1594  else
1595  {
1596  // 0.0 < transparence < 1.0, apply fixed transparence
1597  bFixedTransparence = true;
1598  }
1599  }
1600  else
1601  {
1602  // gradient transparence
1603  ScopedVclPtrInstance< VirtualDevice > pVDev;
1604 
1605  pVDev->SetOutputSizePixel(aBitmapEx.GetBitmap().GetSizePixel());
1606  pVDev->DrawGradient(tools::Rectangle(Point(0, 0), pVDev->GetOutputSizePixel()), rGradient);
1607 
1608  aNewMask = AlphaMask(pVDev->GetBitmap(Point(0, 0), pVDev->GetOutputSizePixel()));
1609  bHasNewMask = true;
1610  }
1611 
1612  if(!bCreateObject)
1613  return;
1614 
1615  if(bHasNewMask || bFixedTransparence)
1616  {
1617  if(!aBitmapEx.IsAlpha() && !aBitmapEx.IsTransparent())
1618  {
1619  // no transparence yet, apply new one
1620  if(bFixedTransparence)
1621  {
1622  sal_uInt8 aAlpha(basegfx::fround(fTransparence * 255.0));
1623 
1624  aNewMask = AlphaMask(aBitmapEx.GetBitmap().GetSizePixel(), &aAlpha);
1625  }
1626 
1627  aBitmapEx = BitmapEx(aBitmapEx.GetBitmap(), aNewMask);
1628  }
1629  else
1630  {
1631  vcl::bitmap::DrawAlphaBitmapAndAlphaGradient(aBitmapEx, bFixedTransparence, fTransparence, aNewMask);
1632  }
1633  }
1634 
1635  // create and add object
1636  SdrGrafObj* pGraf = new SdrGrafObj(
1637  *mpModel,
1638  aBitmapEx,
1639  aRect);
1640 
1641  // for MetaFloatTransparentAction, do not use SetAttributes(...)
1642  // since these metafile content is not used to draw line/fill
1643  // dependent of these setting at the device content
1644  pGraf->SetMergedItem(XLineStyleItem(drawing::LineStyle_NONE));
1645  pGraf->SetMergedItem(XFillStyleItem(drawing::FillStyle_NONE));
1646  InsertObj(pGraf);
1647 }
1648 
1649 /* 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:1067
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:736
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:1380
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:2955
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:396
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:413
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
basegfx::B2DPolyPolygon::getB2DPolygon
B2DPolygon const & getB2DPolygon(sal_uInt32 nIndex) const
SdrObject::ClearMergedItem
void ClearMergedItem(const sal_uInt16 nWhich=0)
Definition: svdobj.cxx:1905
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:1915
basegfx::utils::createScaleTranslateB2DHomMatrix
B2DHomMatrix createScaleTranslateB2DHomMatrix(double fScaleX, double fScaleY, double fTranslateX, double fTranslateY)
XDash::GetDots
sal_uInt16 GetDots() const
Definition: xdash.hxx:55
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:599
LineInfo::GetWidth
sal_Int32 GetWidth() const
GradientStyle
GradientStyle
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
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:1900
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:1064
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:577
SdrObject::HasLineStyle
bool HasLineStyle() const
Definition: svdobj.cxx:2960
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:2511
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:1374
GDIMetaFile::GetAction
MetaAction * GetAction(size_t nAction) const
SdrObject::GetMergedItemSet
const SfxItemSet & GetMergedItemSet() const
Definition: svdobj.cxx:1890
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:190
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:974
F_PI18000
#define F_PI18000
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:139
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:1623
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:313
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
GetAngle
tools::Long 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:386
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:1749
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
SdrRectObj::NbcRotate
virtual void NbcRotate(const Point &rRef, tools::Long nAngle, double sn, double cs) override
Definition: svdorect.cxx:473
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 Tue Nov 24 2020 03:21:33 for LibreOffice Module svx (master) by   doxygen 1.8.10