Line data Source code
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 <editeng/editdata.hxx>
22 : #include <math.h>
23 : #include <svx/xpoly.hxx>
24 : #include <vcl/svapp.hxx>
25 : #include <editeng/eeitem.hxx>
26 : #include <editeng/fhgtitem.hxx>
27 : #include <editeng/wghtitem.hxx>
28 : #include <editeng/postitem.hxx>
29 : #include <editeng/udlnitem.hxx>
30 : #include <editeng/crsditem.hxx>
31 : #include <editeng/shdditem.hxx>
32 : #include <svx/xlnclit.hxx>
33 : #include <svx/xlncapit.hxx>
34 : #include <svx/xlnwtit.hxx>
35 : #include <svx/xflclit.hxx>
36 : #include <svx/xgrad.hxx>
37 : #include <svx/xflgrit.hxx>
38 : #include <editeng/fontitem.hxx>
39 : #include <editeng/akrnitem.hxx>
40 : #include <editeng/wrlmitem.hxx>
41 : #include <editeng/cntritem.hxx>
42 : #include <editeng/colritem.hxx>
43 : #include <vcl/metric.hxx>
44 : #include <editeng/charscaleitem.hxx>
45 : #include <svx/xflhtit.hxx>
46 : #include <svx/svdattr.hxx>
47 : #include <svx/svdmodel.hxx>
48 : #include <svx/svdpage.hxx>
49 : #include <svx/svdobj.hxx>
50 : #include "svx/svditext.hxx"
51 : #include <svx/svdotext.hxx>
52 : #include <svx/svdorect.hxx>
53 : #include <svx/svdocirc.hxx>
54 : #include <svx/svdograf.hxx>
55 : #include <svx/svdopath.hxx>
56 : #include <svx/svdetc.hxx>
57 : #include <svl/itemset.hxx>
58 : #include <basegfx/polygon/b2dpolygon.hxx>
59 : #include <tools/helpers.hxx>
60 : #include <basegfx/matrix/b2dhommatrix.hxx>
61 : #include <basegfx/matrix/b2dhommatrixtools.hxx>
62 : #include <svx/xlinjoit.hxx>
63 : #include <svx/xlndsit.hxx>
64 :
65 : ////////////////////////////////////////////////////////////////////////////////////////////////////
66 :
67 0 : ImpSdrGDIMetaFileImport::ImpSdrGDIMetaFileImport(SdrModel& rModel):
68 : nMapScalingOfs(0),
69 : pLineAttr(NULL),pFillAttr(NULL),pTextAttr(NULL),
70 : pPage(NULL),pModel(NULL),nLayer(0),
71 : nLineWidth(0),
72 : maLineJoin(basegfx::B2DLINEJOIN_NONE),
73 : maLineCap(com::sun::star::drawing::LineCap_BUTT),
74 : maDash(XDASH_RECT, 0, 0, 0, 0, 0),
75 : fScaleX(0.0),fScaleY(0.0),
76 : bFntDirty(sal_True),
77 0 : bLastObjWasPolyWithoutLine(sal_False),bNoLine(sal_False),bNoFill(sal_False),bLastObjWasLine(sal_False)
78 : {
79 0 : aVD.EnableOutput(sal_False);
80 :
81 : // #i111954# init to no fill and no line initially
82 0 : aVD.SetLineColor();
83 0 : aVD.SetFillColor();
84 :
85 0 : aOldLineColor.SetRed( aVD.GetLineColor().GetRed() + 1 ); // invalidate old line color
86 0 : pLineAttr=new SfxItemSet(rModel.GetItemPool(),XATTR_LINE_FIRST,XATTR_LINE_LAST);
87 0 : pFillAttr=new SfxItemSet(rModel.GetItemPool(),XATTR_FILL_FIRST,XATTR_FILL_LAST);
88 0 : pTextAttr=new SfxItemSet(rModel.GetItemPool(),EE_ITEMS_START,EE_ITEMS_END);
89 0 : pModel=&rModel;
90 0 : }
91 :
92 0 : ImpSdrGDIMetaFileImport::~ImpSdrGDIMetaFileImport()
93 : {
94 0 : delete pLineAttr;
95 0 : delete pFillAttr;
96 0 : delete pTextAttr;
97 0 : }
98 :
99 0 : sal_uIntPtr ImpSdrGDIMetaFileImport::DoImport(const GDIMetaFile& rMtf,
100 : SdrObjList& rOL,
101 : sal_uIntPtr nInsPos,
102 : SvdProgressInfo *pProgrInfo)
103 : {
104 0 : pPage = rOL.GetPage();
105 0 : GDIMetaFile* pTmpMtf=NULL;
106 0 : GDIMetaFile* pMtf = (GDIMetaFile*) &rMtf;
107 0 : size_t nActionAnz = pMtf->GetActionSize();
108 0 : sal_Bool bError = sal_False;
109 :
110 :
111 : // setup some global scale parameters
112 : // fScaleX, fScaleY, aScaleX, aScaleY, bMov, bSize
113 0 : fScaleX = fScaleY = 1.0;
114 0 : Size aMtfSize( pMtf->GetPrefSize() );
115 0 : if ( aMtfSize.Width() & aMtfSize.Height() && ( aScaleRect.IsEmpty() == sal_False ) )
116 : {
117 0 : aOfs = aScaleRect.TopLeft();
118 0 : if ( aMtfSize.Width() != ( aScaleRect.GetWidth() - 1 ) )
119 0 : fScaleX = (double)( aScaleRect.GetWidth() - 1 ) / (double)aMtfSize.Width();
120 0 : if ( aMtfSize.Height() != ( aScaleRect.GetHeight() - 1 ) )
121 0 : fScaleY = (double)( aScaleRect.GetHeight() - 1 ) / (double)aMtfSize.Height();
122 : }
123 :
124 0 : bMov = aOfs.X()!=0 || aOfs.Y()!=0;
125 0 : bSize = sal_False;
126 :
127 0 : aScaleX = Fraction( 1, 1 );
128 0 : aScaleY = Fraction( 1, 1 );
129 0 : if ( aMtfSize.Width() != ( aScaleRect.GetWidth() - 1 ) )
130 : {
131 0 : aScaleX = Fraction( aScaleRect.GetWidth() - 1, aMtfSize.Width() );
132 0 : bSize = sal_True;
133 : }
134 0 : if ( aMtfSize.Height() != ( aScaleRect.GetHeight() - 1 ) )
135 : {
136 0 : aScaleY = Fraction( aScaleRect.GetHeight() - 1, aMtfSize.Height() );
137 0 : bSize = sal_True;
138 : }
139 :
140 0 : if(65000 < nActionAnz)
141 : {
142 0 : nActionAnz = 65000;
143 0 : bError = sal_True;
144 : }
145 :
146 0 : if(pProgrInfo)
147 0 : pProgrInfo->SetActionCount(nActionAnz);
148 :
149 0 : size_t nActionsToReport = 0;
150 :
151 0 : for( MetaAction* pAct = pMtf->FirstAction(); pAct; pAct = pMtf->NextAction() )
152 : {
153 0 : switch (pAct->GetType())
154 : {
155 0 : case META_PIXEL_ACTION : DoAction((MetaPixelAction &)*pAct); break;
156 0 : case META_POINT_ACTION : DoAction((MetaPointAction &)*pAct); break;
157 0 : case META_LINE_ACTION : DoAction((MetaLineAction &)*pAct); break;
158 0 : case META_RECT_ACTION : DoAction((MetaRectAction &)*pAct); break;
159 0 : case META_ROUNDRECT_ACTION : DoAction((MetaRoundRectAction &)*pAct); break;
160 0 : case META_ELLIPSE_ACTION : DoAction((MetaEllipseAction &)*pAct); break;
161 0 : case META_ARC_ACTION : DoAction((MetaArcAction &)*pAct); break;
162 0 : case META_PIE_ACTION : DoAction((MetaPieAction &)*pAct); break;
163 0 : case META_CHORD_ACTION : DoAction((MetaChordAction &)*pAct); break;
164 0 : case META_POLYLINE_ACTION : DoAction((MetaPolyLineAction &)*pAct); break;
165 0 : case META_POLYGON_ACTION : DoAction((MetaPolygonAction &)*pAct); break;
166 0 : case META_POLYPOLYGON_ACTION : DoAction((MetaPolyPolygonAction &)*pAct); break;
167 0 : case META_TEXT_ACTION : DoAction((MetaTextAction &)*pAct); break;
168 0 : case META_TEXTARRAY_ACTION : DoAction((MetaTextArrayAction &)*pAct); break;
169 0 : case META_STRETCHTEXT_ACTION : DoAction((MetaStretchTextAction &)*pAct); break;
170 0 : case META_BMP_ACTION : DoAction((MetaBmpAction &)*pAct); break;
171 0 : case META_BMPSCALE_ACTION : DoAction((MetaBmpScaleAction &)*pAct); break;
172 0 : case META_BMPEX_ACTION : DoAction((MetaBmpExAction &)*pAct); break;
173 0 : case META_BMPEXSCALE_ACTION : DoAction((MetaBmpExScaleAction &)*pAct); break;
174 0 : case META_LINECOLOR_ACTION : DoAction((MetaLineColorAction &)*pAct); break;
175 0 : case META_FILLCOLOR_ACTION : DoAction((MetaFillColorAction &)*pAct); break;
176 0 : case META_TEXTCOLOR_ACTION : DoAction((MetaTextColorAction &)*pAct); break;
177 0 : case META_TEXTFILLCOLOR_ACTION : DoAction((MetaTextFillColorAction &)*pAct); break;
178 0 : case META_FONT_ACTION : DoAction((MetaFontAction &)*pAct); break;
179 0 : case META_TEXTALIGN_ACTION : DoAction((MetaTextAlignAction &)*pAct); break;
180 0 : case META_MAPMODE_ACTION : DoAction((MetaMapModeAction &)*pAct); break;
181 0 : case META_CLIPREGION_ACTION : DoAction((MetaClipRegionAction &)*pAct); break;
182 0 : case META_MOVECLIPREGION_ACTION : DoAction((MetaMoveClipRegionAction &)*pAct); break;
183 0 : case META_ISECTRECTCLIPREGION_ACTION: DoAction((MetaISectRectClipRegionAction&)*pAct); break;
184 0 : case META_ISECTREGIONCLIPREGION_ACTION: DoAction((MetaISectRegionClipRegionAction&)*pAct); break;
185 0 : case META_RASTEROP_ACTION : DoAction((MetaRasterOpAction &)*pAct); break;
186 0 : case META_PUSH_ACTION : DoAction((MetaPushAction &)*pAct); break;
187 0 : case META_POP_ACTION : DoAction((MetaPopAction &)*pAct); break;
188 0 : case META_HATCH_ACTION : DoAction((MetaHatchAction &)*pAct); break;
189 0 : case META_COMMENT_ACTION : DoAction((MetaCommentAction &)*pAct, pMtf); break;
190 : }
191 :
192 0 : if(pProgrInfo != NULL)
193 : {
194 0 : nActionsToReport++;
195 0 : if(nActionsToReport >= 16) // update all 16 actions
196 : {
197 0 : if(!pProgrInfo->ReportActions(nActionsToReport))
198 0 : break;
199 0 : nActionsToReport = 0;
200 : }
201 : }
202 : }
203 :
204 0 : if(pProgrInfo != NULL)
205 : {
206 0 : pProgrInfo->ReportActions(nActionsToReport);
207 0 : nActionsToReport = 0;
208 : }
209 :
210 : // MapMode scaling
211 0 : MapScaling();
212 : // scale objects to predetermined rectangle
213 0 : size_t nAnz=aTmpList.size();
214 :
215 : // To calculate the progress meter, we use GetActionSize()*3.
216 : // However, aTmpList has a lower entry count limit than GetActionSize(),
217 : // so the actions that were assumed were too much have to be re-added.
218 0 : nActionsToReport = (pMtf->GetActionSize() - nAnz)*2;
219 :
220 :
221 : // announce all currently unannounced rescales
222 0 : if(pProgrInfo)
223 : {
224 0 : pProgrInfo->ReportRescales(nActionsToReport);
225 0 : pProgrInfo->SetInsertCount(nAnz);
226 : }
227 0 : nActionsToReport = 0;
228 :
229 : // insert all objects cached in aTmpList now into rOL from nInsPos
230 0 : if (nInsPos>rOL.GetObjCount()) nInsPos=rOL.GetObjCount();
231 0 : SdrInsertReason aReason(SDRREASON_VIEWCALL);
232 0 : for (size_t i=0; i<nAnz; i++)
233 : {
234 0 : SdrObject* pObj=aTmpList[i];
235 0 : rOL.NbcInsertObject(pObj,nInsPos,&aReason);
236 0 : nInsPos++;
237 :
238 0 : if(pProgrInfo != NULL)
239 : {
240 0 : nActionsToReport++;
241 0 : if(nActionsToReport >= 32) // update all 32 actions
242 : {
243 0 : pProgrInfo->ReportInserts(nActionsToReport);
244 0 : nActionsToReport = 0;
245 : }
246 : }
247 : }
248 0 : if (pTmpMtf!=NULL) delete pTmpMtf;
249 :
250 : // report all remaining inserts for the last time
251 0 : if(pProgrInfo != NULL)
252 : {
253 0 : pProgrInfo->ReportInserts(nActionsToReport);
254 0 : if(bError)
255 0 : pProgrInfo->ReportError();
256 : }
257 :
258 0 : return aTmpList.size();
259 : }
260 :
261 0 : void ImpSdrGDIMetaFileImport::SetAttributes(SdrObject* pObj, bool bForceTextAttr)
262 : {
263 0 : bNoLine = sal_False; bNoFill = sal_False;
264 0 : bool bLine = !bForceTextAttr;
265 0 : bool bFill = (pObj==NULL) || (pObj->IsClosedObj() && !bForceTextAttr);
266 0 : bool bText = bForceTextAttr || (pObj!=NULL && pObj->GetOutlinerParaObject()!=NULL);
267 :
268 0 : if ( bLine )
269 : {
270 0 : if ( nLineWidth )
271 0 : pLineAttr->Put( XLineWidthItem( nLineWidth ) );
272 : else
273 0 : pLineAttr->Put( XLineWidthItem( 0 ) );
274 :
275 0 : aOldLineColor = aVD.GetLineColor();
276 0 : if( aVD.IsLineColor() )
277 : {
278 0 : pLineAttr->Put(XLineStyleItem(XLINE_SOLID));
279 0 : pLineAttr->Put(XLineColorItem(String(), aVD.GetLineColor()));
280 : }
281 : else
282 0 : pLineAttr->Put(XLineStyleItem(XLINE_NONE));
283 :
284 0 : switch(maLineJoin)
285 : {
286 : default : // basegfx::B2DLINEJOIN_NONE
287 0 : pLineAttr->Put(XLineJointItem(XLINEJOINT_NONE));
288 0 : break;
289 : case basegfx::B2DLINEJOIN_MIDDLE:
290 0 : pLineAttr->Put(XLineJointItem(XLINEJOINT_MIDDLE));
291 0 : break;
292 : case basegfx::B2DLINEJOIN_BEVEL:
293 0 : pLineAttr->Put(XLineJointItem(XLINEJOINT_BEVEL));
294 0 : break;
295 : case basegfx::B2DLINEJOIN_MITER:
296 0 : pLineAttr->Put(XLineJointItem(XLINEJOINT_MITER));
297 0 : break;
298 : case basegfx::B2DLINEJOIN_ROUND:
299 0 : pLineAttr->Put(XLineJointItem(XLINEJOINT_ROUND));
300 0 : break;
301 : }
302 :
303 : // Add LineCap support
304 0 : pLineAttr->Put(XLineCapItem(maLineCap));
305 :
306 0 : if(((maDash.GetDots() && maDash.GetDotLen()) || (maDash.GetDashes() && maDash.GetDashLen())) && maDash.GetDistance())
307 : {
308 0 : pLineAttr->Put(XLineDashItem(String(), maDash));
309 : }
310 : else
311 : {
312 0 : pLineAttr->Put(XLineDashItem(String(), XDash(XDASH_RECT)));
313 : }
314 : }
315 : else
316 0 : bNoLine = sal_True;
317 :
318 0 : if ( bFill )
319 : {
320 0 : if( aVD.IsFillColor() )
321 : {
322 0 : pFillAttr->Put(XFillStyleItem(XFILL_SOLID));
323 0 : pFillAttr->Put(XFillColorItem(String(), aVD.GetFillColor()));
324 : }
325 : else
326 0 : pFillAttr->Put(XFillStyleItem(XFILL_NONE));
327 : }
328 : else
329 0 : bNoFill = sal_True;
330 :
331 0 : if ( bText && bFntDirty )
332 : {
333 0 : Font aFnt(aVD.GetFont());
334 0 : pTextAttr->Put( SvxFontItem( aFnt.GetFamily(), aFnt.GetName(), aFnt.GetStyleName(),
335 0 : aFnt.GetPitch(), aFnt.GetCharSet(), EE_CHAR_FONTINFO ) );
336 0 : pTextAttr->Put( SvxFontItem( aFnt.GetFamily(), aFnt.GetName(), aFnt.GetStyleName(),
337 0 : aFnt.GetPitch(), aFnt.GetCharSet(), EE_CHAR_FONTINFO_CJK ) );
338 0 : pTextAttr->Put( SvxFontItem( aFnt.GetFamily(), aFnt.GetName(), aFnt.GetStyleName(),
339 0 : aFnt.GetPitch(), aFnt.GetCharSet(), EE_CHAR_FONTINFO_CTL ) );
340 0 : pTextAttr->Put(SvxPostureItem(aFnt.GetItalic(), EE_CHAR_ITALIC));
341 0 : pTextAttr->Put(SvxWeightItem(aFnt.GetWeight(), EE_CHAR_WEIGHT));
342 0 : sal_uInt32 nHeight = FRound(aFnt.GetSize().Height() * fScaleY);
343 0 : pTextAttr->Put( SvxFontHeightItem( nHeight, 100, EE_CHAR_FONTHEIGHT ) );
344 0 : pTextAttr->Put( SvxFontHeightItem( nHeight, 100, EE_CHAR_FONTHEIGHT_CJK ) );
345 0 : pTextAttr->Put( SvxFontHeightItem( nHeight, 100, EE_CHAR_FONTHEIGHT_CTL ) );
346 0 : pTextAttr->Put(SvxCharScaleWidthItem(100, EE_CHAR_FONTWIDTH));
347 0 : pTextAttr->Put(SvxUnderlineItem(aFnt.GetUnderline(), EE_CHAR_UNDERLINE));
348 0 : pTextAttr->Put(SvxOverlineItem(aFnt.GetOverline(), EE_CHAR_OVERLINE));
349 0 : pTextAttr->Put(SvxCrossedOutItem(aFnt.GetStrikeout(), EE_CHAR_STRIKEOUT));
350 0 : pTextAttr->Put(SvxShadowedItem(aFnt.IsShadow(), EE_CHAR_SHADOW));
351 :
352 : // #i118485# Setting this item leads to problems (written #i118498# for this)
353 : // pTextAttr->Put(SvxAutoKernItem(aFnt.IsKerning(), EE_CHAR_KERNING));
354 :
355 0 : pTextAttr->Put(SvxWordLineModeItem(aFnt.IsWordLineMode(), EE_CHAR_WLM));
356 0 : pTextAttr->Put(SvxContourItem(aFnt.IsOutline(), EE_CHAR_OUTLINE));
357 0 : pTextAttr->Put(SvxColorItem(aVD.GetTextColor(), EE_CHAR_COLOR));
358 : //... svxfont textitem svditext
359 0 : bFntDirty=sal_False;
360 : }
361 0 : if (pObj!=NULL)
362 : {
363 0 : pObj->SetLayer(nLayer);
364 0 : if (bLine) pObj->SetMergedItemSet(*pLineAttr);
365 0 : if (bFill) pObj->SetMergedItemSet(*pFillAttr);
366 0 : if (bText)
367 : {
368 0 : pObj->SetMergedItemSet(*pTextAttr);
369 0 : pObj->SetMergedItem( SdrTextHorzAdjustItem( SDRTEXTHORZADJUST_LEFT ) );
370 : }
371 : }
372 0 : }
373 :
374 0 : void ImpSdrGDIMetaFileImport::InsertObj( SdrObject* pObj, sal_Bool bScale )
375 : {
376 0 : if ( bScale && !aScaleRect.IsEmpty() )
377 : {
378 0 : if ( bSize )
379 0 : pObj->NbcResize( Point(), aScaleX, aScaleY );
380 0 : if ( bMov )
381 0 : pObj->NbcMove( Size( aOfs.X(), aOfs.Y() ) );
382 : }
383 :
384 : // #i111954# check object for visibility
385 : // used are SdrPathObj, SdrRectObj, SdrCircObj, SdrGrafObj
386 0 : bool bVisible(false);
387 :
388 0 : if(pObj->HasLineStyle())
389 : {
390 0 : bVisible = true;
391 : }
392 :
393 0 : if(!bVisible && pObj->HasFillStyle())
394 : {
395 0 : bVisible = true;
396 : }
397 :
398 0 : if(!bVisible)
399 : {
400 0 : SdrTextObj* pTextObj = dynamic_cast< SdrTextObj* >(pObj);
401 :
402 0 : if(pTextObj && pTextObj->HasText())
403 : {
404 0 : bVisible = true;
405 : }
406 : }
407 :
408 0 : if(!bVisible)
409 : {
410 0 : SdrGrafObj* pGrafObj = dynamic_cast< SdrGrafObj* >(pObj);
411 :
412 0 : if(pGrafObj)
413 : {
414 : // this may be refined to check if the graphic really is visible. It
415 : // is here to ensure that graphic objects without fill, line and text
416 : // get created
417 0 : bVisible = true;
418 : }
419 : }
420 :
421 0 : if(!bVisible)
422 : {
423 0 : SdrObject::Free(pObj);
424 : }
425 : else
426 : {
427 0 : aTmpList.push_back( pObj );
428 0 : if ( HAS_BASE( SdrPathObj, pObj ) )
429 : {
430 0 : bool bClosed=pObj->IsClosedObj();
431 0 : bLastObjWasPolyWithoutLine=bNoLine && bClosed;
432 0 : bLastObjWasLine=!bClosed;
433 : }
434 : else
435 : {
436 0 : bLastObjWasPolyWithoutLine = sal_False;
437 0 : bLastObjWasLine = sal_False;
438 : }
439 : }
440 0 : }
441 :
442 : /**************************************************************************************************/
443 0 : void ImpSdrGDIMetaFileImport::DoAction(MetaPixelAction& /*rAct*/) const
444 : {
445 0 : }
446 :
447 0 : void ImpSdrGDIMetaFileImport::DoAction(MetaPointAction& /*rAct*/) const
448 : {
449 0 : }
450 :
451 0 : void ImpSdrGDIMetaFileImport::DoAction(MetaLineAction& rAct)
452 : {
453 : // #i73407# reformulation to use new B2DPolygon classes
454 0 : const basegfx::B2DPoint aStart(rAct.GetStartPoint().X(), rAct.GetStartPoint().Y());
455 0 : const basegfx::B2DPoint aEnd(rAct.GetEndPoint().X(), rAct.GetEndPoint().Y());
456 :
457 0 : if(!aStart.equal(aEnd))
458 : {
459 0 : basegfx::B2DPolygon aLine;
460 0 : const basegfx::B2DHomMatrix aTransform(basegfx::tools::createScaleTranslateB2DHomMatrix(fScaleX, fScaleY, aOfs.X(), aOfs.Y()));
461 :
462 0 : aLine.append(aStart);
463 0 : aLine.append(aEnd);
464 0 : aLine.transform(aTransform);
465 :
466 0 : const LineInfo& rLineInfo = rAct.GetLineInfo();
467 0 : const sal_Int32 nNewLineWidth(rLineInfo.GetWidth());
468 0 : bool bCreateLineObject(true);
469 :
470 0 : if(bLastObjWasLine && (nNewLineWidth == nLineWidth) && CheckLastLineMerge(aLine))
471 : {
472 0 : bCreateLineObject = false;
473 : }
474 :
475 0 : if(bCreateLineObject)
476 : {
477 0 : SdrPathObj* pPath = new SdrPathObj(OBJ_LINE, basegfx::B2DPolyPolygon(aLine));
478 0 : nLineWidth = nNewLineWidth;
479 0 : maLineJoin = rLineInfo.GetLineJoin();
480 0 : maLineCap = rLineInfo.GetLineCap();
481 : maDash = XDash(XDASH_RECT,
482 0 : rLineInfo.GetDotCount(), rLineInfo.GetDotLen(),
483 0 : rLineInfo.GetDashCount(), rLineInfo.GetDashLen(),
484 0 : rLineInfo.GetDistance());
485 0 : SetAttributes(pPath);
486 0 : nLineWidth = 0;
487 0 : maLineJoin = basegfx::B2DLINEJOIN_NONE;
488 0 : maDash = XDash();
489 0 : InsertObj(pPath, false);
490 0 : }
491 0 : }
492 0 : }
493 :
494 0 : void ImpSdrGDIMetaFileImport::DoAction(MetaRectAction& rAct)
495 : {
496 0 : SdrRectObj* pRect=new SdrRectObj(rAct.GetRect());
497 0 : SetAttributes(pRect);
498 0 : InsertObj(pRect);
499 0 : }
500 :
501 0 : void ImpSdrGDIMetaFileImport::DoAction(MetaRoundRectAction& rAct)
502 : {
503 0 : SdrRectObj* pRect=new SdrRectObj(rAct.GetRect());
504 0 : SetAttributes(pRect);
505 0 : long nRad=(rAct.GetHorzRound()+rAct.GetVertRound())/2;
506 0 : if (nRad!=0) {
507 0 : SfxItemSet aSet(*pLineAttr->GetPool(),SDRATTR_ECKENRADIUS,SDRATTR_ECKENRADIUS);
508 0 : aSet.Put(SdrEckenradiusItem(nRad));
509 0 : pRect->SetMergedItemSet(aSet);
510 : }
511 0 : InsertObj(pRect);
512 0 : }
513 :
514 : /**************************************************************************************************/
515 :
516 0 : void ImpSdrGDIMetaFileImport::DoAction(MetaEllipseAction& rAct)
517 : {
518 0 : SdrCircObj* pCirc=new SdrCircObj(OBJ_CIRC,rAct.GetRect());
519 0 : SetAttributes(pCirc);
520 0 : InsertObj(pCirc);
521 0 : }
522 :
523 0 : void ImpSdrGDIMetaFileImport::DoAction(MetaArcAction& rAct)
524 : {
525 0 : Point aCenter(rAct.GetRect().Center());
526 0 : long nStart=GetAngle(rAct.GetStartPoint()-aCenter);
527 0 : long nEnd=GetAngle(rAct.GetEndPoint()-aCenter);
528 0 : SdrCircObj* pCirc=new SdrCircObj(OBJ_CARC,rAct.GetRect(),nStart,nEnd);
529 0 : SetAttributes(pCirc);
530 0 : InsertObj(pCirc);
531 0 : }
532 :
533 0 : void ImpSdrGDIMetaFileImport::DoAction(MetaPieAction& rAct)
534 : {
535 0 : Point aCenter(rAct.GetRect().Center());
536 0 : long nStart=GetAngle(rAct.GetStartPoint()-aCenter);
537 0 : long nEnd=GetAngle(rAct.GetEndPoint()-aCenter);
538 0 : SdrCircObj* pCirc=new SdrCircObj(OBJ_SECT,rAct.GetRect(),nStart,nEnd);
539 0 : SetAttributes(pCirc);
540 0 : InsertObj(pCirc);
541 0 : }
542 :
543 0 : void ImpSdrGDIMetaFileImport::DoAction(MetaChordAction& rAct)
544 : {
545 0 : Point aCenter(rAct.GetRect().Center());
546 0 : long nStart=GetAngle(rAct.GetStartPoint()-aCenter);
547 0 : long nEnd=GetAngle(rAct.GetEndPoint()-aCenter);
548 0 : SdrCircObj* pCirc=new SdrCircObj(OBJ_CCUT,rAct.GetRect(),nStart,nEnd);
549 0 : SetAttributes(pCirc);
550 0 : InsertObj(pCirc);
551 0 : }
552 :
553 : /**************************************************************************************************/
554 :
555 0 : bool ImpSdrGDIMetaFileImport::CheckLastLineMerge(const basegfx::B2DPolygon& rSrcPoly)
556 : {
557 : // #i102706# Do not merge closed polygons
558 0 : if(rSrcPoly.isClosed())
559 : {
560 0 : return false;
561 : }
562 :
563 : // #i73407# reformulation to use new B2DPolygon classes
564 0 : if(bLastObjWasLine && (aOldLineColor == aVD.GetLineColor()) && rSrcPoly.count() && !aTmpList.empty())
565 : {
566 0 : SdrObject* pTmpObj = aTmpList.back();
567 0 : SdrPathObj* pLastPoly = PTR_CAST(SdrPathObj, pTmpObj);
568 :
569 0 : if(pLastPoly)
570 : {
571 0 : if(1L == pLastPoly->GetPathPoly().count())
572 : {
573 0 : bool bOk(false);
574 0 : basegfx::B2DPolygon aDstPoly(pLastPoly->GetPathPoly().getB2DPolygon(0L));
575 :
576 : // #i102706# Do not merge closed polygons
577 0 : if(aDstPoly.isClosed())
578 : {
579 0 : return false;
580 : }
581 :
582 0 : if(aDstPoly.count())
583 : {
584 0 : const sal_uInt32 nMaxDstPnt(aDstPoly.count() - 1L);
585 0 : const sal_uInt32 nMaxSrcPnt(rSrcPoly.count() - 1L);
586 :
587 0 : if(aDstPoly.getB2DPoint(nMaxDstPnt) == rSrcPoly.getB2DPoint(0L))
588 : {
589 0 : aDstPoly.append(rSrcPoly, 1L, rSrcPoly.count() - 1L);
590 0 : bOk = true;
591 : }
592 0 : else if(aDstPoly.getB2DPoint(0L) == rSrcPoly.getB2DPoint(nMaxSrcPnt))
593 : {
594 0 : basegfx::B2DPolygon aNew(rSrcPoly);
595 0 : aNew.append(aDstPoly, 1L, aDstPoly.count() - 1L);
596 0 : aDstPoly = aNew;
597 0 : bOk = true;
598 : }
599 0 : else if(aDstPoly.getB2DPoint(0L) == rSrcPoly.getB2DPoint(0L))
600 : {
601 0 : aDstPoly.flip();
602 0 : aDstPoly.append(rSrcPoly, 1L, rSrcPoly.count() - 1L);
603 0 : bOk = true;
604 : }
605 0 : else if(aDstPoly.getB2DPoint(nMaxDstPnt) == rSrcPoly.getB2DPoint(nMaxSrcPnt))
606 : {
607 0 : basegfx::B2DPolygon aNew(rSrcPoly);
608 0 : aNew.flip();
609 0 : aDstPoly.append(aNew, 1L, aNew.count() - 1L);
610 0 : bOk = true;
611 : }
612 : }
613 :
614 0 : if(bOk)
615 : {
616 0 : pLastPoly->NbcSetPathPoly(basegfx::B2DPolyPolygon(aDstPoly));
617 : }
618 :
619 0 : return bOk;
620 : }
621 : }
622 : }
623 :
624 0 : return false;
625 : }
626 :
627 0 : bool ImpSdrGDIMetaFileImport::CheckLastPolyLineAndFillMerge(const basegfx::B2DPolyPolygon & rPolyPolygon)
628 : {
629 : // #i73407# reformulation to use new B2DPolygon classes
630 0 : if(bLastObjWasPolyWithoutLine && !aTmpList.empty())
631 : {
632 0 : SdrObject* pTmpObj = aTmpList.back();
633 0 : SdrPathObj* pLastPoly = PTR_CAST(SdrPathObj, pTmpObj);
634 :
635 0 : if(pLastPoly)
636 : {
637 0 : if(pLastPoly->GetPathPoly() == rPolyPolygon)
638 : {
639 0 : SetAttributes(NULL);
640 :
641 0 : if(!bNoLine && bNoFill)
642 : {
643 0 : pLastPoly->SetMergedItemSet(*pLineAttr);
644 :
645 0 : return true;
646 : }
647 : }
648 : }
649 : }
650 :
651 0 : return false;
652 : }
653 :
654 :
655 0 : void ImpSdrGDIMetaFileImport::DoAction( MetaPolyLineAction& rAct )
656 : {
657 : // #i73407# reformulation to use new B2DPolygon classes
658 0 : basegfx::B2DPolygon aSource(rAct.GetPolygon().getB2DPolygon());
659 :
660 0 : if(aSource.count())
661 : {
662 0 : const basegfx::B2DHomMatrix aTransform(basegfx::tools::createScaleTranslateB2DHomMatrix(fScaleX, fScaleY, aOfs.X(), aOfs.Y()));
663 0 : aSource.transform(aTransform);
664 : }
665 :
666 0 : const LineInfo& rLineInfo = rAct.GetLineInfo();
667 0 : const sal_Int32 nNewLineWidth(rLineInfo.GetWidth());
668 0 : bool bCreateLineObject(true);
669 :
670 0 : if(bLastObjWasLine && (nNewLineWidth == nLineWidth) && CheckLastLineMerge(aSource))
671 : {
672 0 : bCreateLineObject = false;
673 : }
674 0 : else if(bLastObjWasPolyWithoutLine && CheckLastPolyLineAndFillMerge(basegfx::B2DPolyPolygon(aSource)))
675 : {
676 0 : bCreateLineObject = false;
677 : }
678 :
679 0 : if(bCreateLineObject)
680 : {
681 : SdrPathObj* pPath = new SdrPathObj(
682 0 : aSource.isClosed() ? OBJ_POLY : OBJ_PLIN,
683 0 : basegfx::B2DPolyPolygon(aSource));
684 0 : nLineWidth = nNewLineWidth;
685 0 : maLineJoin = rLineInfo.GetLineJoin();
686 0 : maLineCap = rLineInfo.GetLineCap();
687 : maDash = XDash(XDASH_RECT,
688 0 : rLineInfo.GetDotCount(), rLineInfo.GetDotLen(),
689 0 : rLineInfo.GetDashCount(), rLineInfo.GetDashLen(),
690 0 : rLineInfo.GetDistance());
691 0 : SetAttributes(pPath);
692 0 : nLineWidth = 0;
693 0 : maLineJoin = basegfx::B2DLINEJOIN_NONE;
694 0 : maDash = XDash();
695 0 : InsertObj(pPath, false);
696 0 : }
697 0 : }
698 :
699 0 : void ImpSdrGDIMetaFileImport::DoAction( MetaPolygonAction& rAct )
700 : {
701 : // #i73407# reformulation to use new B2DPolygon classes
702 0 : basegfx::B2DPolygon aSource(rAct.GetPolygon().getB2DPolygon());
703 :
704 0 : if(aSource.count())
705 : {
706 0 : const basegfx::B2DHomMatrix aTransform(basegfx::tools::createScaleTranslateB2DHomMatrix(fScaleX, fScaleY, aOfs.X(), aOfs.Y()));
707 0 : aSource.transform(aTransform);
708 :
709 0 : if(!bLastObjWasPolyWithoutLine || !CheckLastPolyLineAndFillMerge(basegfx::B2DPolyPolygon(aSource)))
710 : {
711 : // #i73407# make sure polygon is closed, it's a filled primitive
712 0 : aSource.setClosed(true);
713 :
714 0 : SdrPathObj* pPath = new SdrPathObj(OBJ_POLY, basegfx::B2DPolyPolygon(aSource));
715 0 : SetAttributes(pPath);
716 0 : InsertObj(pPath, false);
717 0 : }
718 0 : }
719 0 : }
720 :
721 0 : void ImpSdrGDIMetaFileImport::DoAction(MetaPolyPolygonAction& rAct)
722 : {
723 : // #i73407# reformulation to use new B2DPolygon classes
724 0 : basegfx::B2DPolyPolygon aSource(rAct.GetPolyPolygon().getB2DPolyPolygon());
725 :
726 0 : if(aSource.count())
727 : {
728 0 : const basegfx::B2DHomMatrix aTransform(basegfx::tools::createScaleTranslateB2DHomMatrix(fScaleX, fScaleY, aOfs.X(), aOfs.Y()));
729 0 : aSource.transform(aTransform);
730 :
731 0 : if(!bLastObjWasPolyWithoutLine || !CheckLastPolyLineAndFillMerge(aSource))
732 : {
733 : // #i73407# make sure polygon is closed, it's a filled primitive
734 0 : aSource.setClosed(true);
735 :
736 0 : SdrPathObj* pPath = new SdrPathObj(OBJ_POLY, aSource);
737 0 : SetAttributes(pPath);
738 0 : InsertObj(pPath, false);
739 0 : }
740 0 : }
741 0 : }
742 :
743 : /**************************************************************************************************/
744 :
745 0 : void ImpSdrGDIMetaFileImport::ImportText( const Point& rPos, const XubString& rStr, const MetaAction& rAct )
746 : {
747 : // calc text box size, add 5% to make it fit safely
748 :
749 0 : FontMetric aFontMetric( aVD.GetFontMetric() );
750 0 : Font aFnt( aVD.GetFont() );
751 0 : FontAlign eAlg( aFnt.GetAlign() );
752 :
753 0 : sal_Int32 nTextWidth = (sal_Int32)( aVD.GetTextWidth( rStr ) * fScaleX );
754 0 : sal_Int32 nTextHeight = (sal_Int32)( aVD.GetTextHeight() * fScaleY );
755 :
756 0 : Point aPos( FRound(rPos.X() * fScaleX + aOfs.X()), FRound(rPos.Y() * fScaleY + aOfs.Y()) );
757 0 : Size aSize( nTextWidth, nTextHeight );
758 :
759 0 : if ( eAlg == ALIGN_BASELINE )
760 0 : aPos.Y() -= FRound(aFontMetric.GetAscent() * fScaleY);
761 0 : else if ( eAlg == ALIGN_BOTTOM )
762 0 : aPos.Y() -= nTextHeight;
763 :
764 0 : Rectangle aTextRect( aPos, aSize );
765 0 : SdrRectObj* pText =new SdrRectObj( OBJ_TEXT, aTextRect );
766 :
767 0 : if ( aFnt.GetWidth() || ( rAct.GetType() == META_STRETCHTEXT_ACTION ) )
768 : {
769 0 : pText->ClearMergedItem( SDRATTR_TEXT_AUTOGROWWIDTH );
770 0 : pText->SetMergedItem( SdrTextAutoGrowHeightItem( sal_False ) );
771 : // don't let the margins eat the space needed for the text
772 0 : pText->SetMergedItem ( SdrTextUpperDistItem (0));
773 0 : pText->SetMergedItem ( SdrTextLowerDistItem (0));
774 0 : pText->SetMergedItem ( SdrTextRightDistItem (0));
775 0 : pText->SetMergedItem ( SdrTextLeftDistItem (0));
776 0 : pText->SetMergedItem( SdrTextFitToSizeTypeItem( SDRTEXTFIT_ALLLINES ) );
777 : }
778 : else
779 0 : pText->SetMergedItem( SdrTextAutoGrowWidthItem( sal_True ) );
780 :
781 0 : pText->SetModel( pModel );
782 0 : pText->SetLayer( nLayer );
783 0 : pText->NbcSetText( rStr );
784 0 : SetAttributes( pText, sal_True );
785 0 : pText->SetSnapRect( aTextRect );
786 :
787 0 : if (!aFnt.IsTransparent())
788 : {
789 0 : SfxItemSet aAttr(*pFillAttr->GetPool(),XATTR_FILL_FIRST,XATTR_FILL_LAST);
790 0 : aAttr.Put(XFillStyleItem(XFILL_SOLID));
791 0 : aAttr.Put(XFillColorItem(String(), aFnt.GetFillColor()));
792 0 : pText->SetMergedItemSet(aAttr);
793 : }
794 0 : sal_uInt32 nWink = aFnt.GetOrientation();
795 0 : if ( nWink )
796 : {
797 0 : nWink*=10;
798 0 : double a=nWink*nPi180;
799 0 : double nSin=sin(a);
800 0 : double nCos=cos(a);
801 0 : pText->NbcRotate(aPos,nWink,nSin,nCos);
802 : }
803 0 : InsertObj( pText, sal_False );
804 0 : }
805 :
806 0 : void ImpSdrGDIMetaFileImport::DoAction(MetaTextAction& rAct)
807 : {
808 0 : XubString aStr(rAct.GetText());
809 0 : aStr.Erase(0,rAct.GetIndex());
810 0 : aStr.Erase(rAct.GetLen());
811 0 : ImportText( rAct.GetPoint(), aStr, rAct );
812 0 : }
813 :
814 0 : void ImpSdrGDIMetaFileImport::DoAction(MetaTextArrayAction& rAct)
815 : {
816 0 : XubString aStr(rAct.GetText());
817 0 : aStr.Erase(0,rAct.GetIndex());
818 0 : aStr.Erase(rAct.GetLen());
819 0 : ImportText( rAct.GetPoint(), aStr, rAct );
820 0 : }
821 :
822 0 : void ImpSdrGDIMetaFileImport::DoAction(MetaStretchTextAction& rAct)
823 : {
824 0 : XubString aStr(rAct.GetText());
825 0 : aStr.Erase(0,rAct.GetIndex());
826 0 : aStr.Erase(rAct.GetLen());
827 0 : ImportText( rAct.GetPoint(), aStr, rAct );
828 0 : }
829 :
830 0 : void ImpSdrGDIMetaFileImport::DoAction(MetaBmpAction& rAct)
831 : {
832 0 : Rectangle aRect(rAct.GetPoint(),rAct.GetBitmap().GetSizePixel());
833 0 : aRect.Right()++; aRect.Bottom()++;
834 0 : SdrGrafObj* pGraf=new SdrGrafObj(Graphic(rAct.GetBitmap()),aRect);
835 0 : InsertObj(pGraf);
836 0 : }
837 :
838 0 : void ImpSdrGDIMetaFileImport::DoAction(MetaBmpScaleAction& rAct)
839 : {
840 0 : Rectangle aRect(rAct.GetPoint(),rAct.GetSize());
841 0 : aRect.Right()++; aRect.Bottom()++;
842 0 : SdrGrafObj* pGraf=new SdrGrafObj(Graphic(rAct.GetBitmap()),aRect);
843 0 : InsertObj(pGraf);
844 0 : }
845 :
846 0 : void ImpSdrGDIMetaFileImport::DoAction(MetaBmpExAction& rAct)
847 : {
848 0 : Rectangle aRect(rAct.GetPoint(),rAct.GetBitmapEx().GetSizePixel());
849 0 : aRect.Right()++; aRect.Bottom()++;
850 0 : SdrGrafObj* pGraf=new SdrGrafObj( rAct.GetBitmapEx(), aRect );
851 0 : InsertObj(pGraf);
852 0 : }
853 :
854 0 : void ImpSdrGDIMetaFileImport::DoAction(MetaBmpExScaleAction& rAct)
855 : {
856 0 : Rectangle aRect(rAct.GetPoint(),rAct.GetSize());
857 0 : aRect.Right()++; aRect.Bottom()++;
858 0 : SdrGrafObj* pGraf=new SdrGrafObj( rAct.GetBitmapEx(), aRect );
859 0 : InsertObj(pGraf);
860 0 : }
861 :
862 : ////////////////////////////////////////////////////////////////////////////////////////////////////
863 :
864 0 : void ImpSdrGDIMetaFileImport::DoAction( MetaHatchAction& rAct )
865 : {
866 : // #i73407# reformulation to use new B2DPolygon classes
867 0 : basegfx::B2DPolyPolygon aSource(rAct.GetPolyPolygon().getB2DPolyPolygon());
868 :
869 0 : if(aSource.count())
870 : {
871 0 : const basegfx::B2DHomMatrix aTransform(basegfx::tools::createScaleTranslateB2DHomMatrix(fScaleX, fScaleY, aOfs.X(), aOfs.Y()));
872 0 : aSource.transform(aTransform);
873 :
874 0 : if(!bLastObjWasPolyWithoutLine || !CheckLastPolyLineAndFillMerge(aSource))
875 : {
876 0 : const Hatch& rHatch = rAct.GetHatch();
877 0 : SdrPathObj* pPath = new SdrPathObj(OBJ_POLY, aSource);
878 0 : SfxItemSet aHatchAttr(pModel->GetItemPool(),
879 : XATTR_FILLSTYLE, XATTR_FILLSTYLE,
880 0 : XATTR_FILLHATCH, XATTR_FILLHATCH, 0, 0 );
881 : XHatchStyle eStyle;
882 :
883 0 : switch(rHatch.GetStyle())
884 : {
885 : case(HATCH_TRIPLE) :
886 : {
887 0 : eStyle = XHATCH_TRIPLE;
888 0 : break;
889 : }
890 :
891 : case(HATCH_DOUBLE) :
892 : {
893 0 : eStyle = XHATCH_DOUBLE;
894 0 : break;
895 : }
896 :
897 : default:
898 : {
899 0 : eStyle = XHATCH_SINGLE;
900 0 : break;
901 : }
902 : }
903 :
904 0 : SetAttributes(pPath);
905 0 : aHatchAttr.Put(XFillStyleItem(XFILL_HATCH));
906 0 : aHatchAttr.Put(XFillHatchItem(&pModel->GetItemPool(), XHatch(rHatch.GetColor(), eStyle, rHatch.GetDistance(), rHatch.GetAngle())));
907 0 : pPath->SetMergedItemSet(aHatchAttr);
908 :
909 0 : InsertObj(pPath, false);
910 0 : }
911 0 : }
912 0 : }
913 :
914 : ////////////////////////////////////////////////////////////////////////////////////////////////////
915 :
916 0 : void ImpSdrGDIMetaFileImport::DoAction(MetaLineColorAction& rAct)
917 : {
918 0 : rAct.Execute(&aVD);
919 0 : }
920 :
921 0 : void ImpSdrGDIMetaFileImport::DoAction(MetaMapModeAction& rAct)
922 : {
923 0 : MapScaling();
924 0 : rAct.Execute(&aVD);
925 0 : bLastObjWasPolyWithoutLine=sal_False;
926 0 : bLastObjWasLine=sal_False;
927 0 : }
928 :
929 0 : void ImpSdrGDIMetaFileImport::MapScaling()
930 : {
931 0 : size_t nAnz = aTmpList.size();
932 0 : const MapMode& rMap = aVD.GetMapMode();
933 0 : Point aMapOrg( rMap.GetOrigin() );
934 0 : sal_Bool bMov2 = aMapOrg.X() != 0 || aMapOrg.Y() != 0;
935 0 : if ( bMov2 )
936 : {
937 0 : for (size_t i = nMapScalingOfs; i < nAnz; i++ )
938 : {
939 0 : SdrObject* pObj = aTmpList[i];
940 0 : if ( bMov2 )
941 0 : pObj->NbcMove( Size( aMapOrg.X(), aMapOrg.Y() ) );
942 : }
943 : }
944 0 : nMapScalingOfs = nAnz;
945 0 : }
946 :
947 : ////////////////////////////////////////////////////////////////////////////////////////////////////
948 :
949 0 : void ImpSdrGDIMetaFileImport::DoAction( MetaCommentAction& rAct, GDIMetaFile* pMtf )
950 : {
951 0 : bool aSkipComment = false;
952 :
953 0 : if (rAct.GetComment().equalsIgnoreAsciiCaseL(RTL_CONSTASCII_STRINGPARAM("XGRAD_SEQ_BEGIN")))
954 : {
955 0 : MetaGradientExAction* pAct = (MetaGradientExAction*) pMtf->NextAction();
956 :
957 0 : if( pAct && pAct->GetType() == META_GRADIENTEX_ACTION )
958 : {
959 : // #i73407# reformulation to use new B2DPolygon classes
960 0 : basegfx::B2DPolyPolygon aSource(pAct->GetPolyPolygon().getB2DPolyPolygon());
961 :
962 0 : if(aSource.count())
963 : {
964 0 : if(!bLastObjWasPolyWithoutLine || !CheckLastPolyLineAndFillMerge(aSource))
965 : {
966 0 : const Gradient& rGrad = pAct->GetGradient();
967 0 : SdrPathObj* pPath = new SdrPathObj(OBJ_POLY, aSource);
968 0 : SfxItemSet aGradAttr(pModel->GetItemPool(),
969 : XATTR_FILLSTYLE, XATTR_FILLSTYLE,
970 0 : XATTR_FILLGRADIENT, XATTR_FILLGRADIENT, 0, 0 );
971 0 : XGradient aXGradient;
972 :
973 0 : aXGradient.SetGradientStyle((XGradientStyle)rGrad.GetStyle());
974 0 : aXGradient.SetStartColor(rGrad.GetStartColor());
975 0 : aXGradient.SetEndColor(rGrad.GetEndColor());
976 0 : aXGradient.SetAngle((sal_uInt16)rGrad.GetAngle());
977 0 : aXGradient.SetBorder(rGrad.GetBorder());
978 0 : aXGradient.SetXOffset(rGrad.GetOfsX());
979 0 : aXGradient.SetYOffset(rGrad.GetOfsY());
980 0 : aXGradient.SetStartIntens(rGrad.GetStartIntensity());
981 0 : aXGradient.SetEndIntens(rGrad.GetEndIntensity());
982 0 : aXGradient.SetSteps(rGrad.GetSteps());
983 :
984 0 : if(aVD.IsLineColor())
985 : {
986 : // switch line off; if there was one, there will be a
987 : // META_POLYLINE_ACTION following creating another object
988 0 : const Color aLineColor(aVD.GetLineColor());
989 0 : aVD.SetLineColor();
990 0 : SetAttributes(pPath);
991 0 : aVD.SetLineColor(aLineColor);
992 : }
993 : else
994 : {
995 0 : SetAttributes(pPath);
996 : }
997 :
998 0 : aGradAttr.Put(XFillStyleItem(XFILL_GRADIENT));
999 0 : aGradAttr.Put(XFillGradientItem(aXGradient));
1000 0 : pPath->SetMergedItemSet(aGradAttr);
1001 :
1002 0 : InsertObj(pPath);
1003 : }
1004 : }
1005 :
1006 0 : aSkipComment = true;
1007 : }
1008 : }
1009 :
1010 0 : if(aSkipComment)
1011 : {
1012 0 : MetaAction* pSkipAct = pMtf->NextAction();
1013 :
1014 0 : while( pSkipAct
1015 0 : && ((pSkipAct->GetType() != META_COMMENT_ACTION )
1016 0 : || !(((MetaCommentAction*)pSkipAct)->GetComment().equalsIgnoreAsciiCase("XGRAD_SEQ_END"))))
1017 : {
1018 0 : pSkipAct = pMtf->NextAction();
1019 : }
1020 : }
1021 0 : }
1022 :
1023 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
