1 /************************************************************** 2 * 3 * Licensed to the Apache Software Foundation (ASF) under one 4 * or more contributor license agreements. See the NOTICE file 5 * distributed with this work for additional information 6 * regarding copyright ownership. The ASF licenses this file 7 * to you under the Apache License, Version 2.0 (the 8 * "License"); you may not use this file except in compliance 9 * with the License. You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, 14 * software distributed under the License is distributed on an 15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 16 * KIND, either express or implied. See the License for the 17 * specific language governing permissions and limitations 18 * under the License. 19 * 20 *************************************************************/ 21 22 23 24 // MARKER(update_precomp.py): autogen include statement, do not remove 25 #include "precompiled_svx.hxx" 26 27 #include "svdfmtf.hxx" 28 #include <editeng/editdata.hxx> 29 #include <math.h> 30 #include <svx/xpoly.hxx> 31 #include <vcl/svapp.hxx> 32 #include <editeng/eeitem.hxx> 33 #include <editeng/fhgtitem.hxx> 34 #include <editeng/wghtitem.hxx> 35 #include <editeng/postitem.hxx> 36 #include <editeng/udlnitem.hxx> 37 #include <editeng/crsditem.hxx> 38 #include <editeng/shdditem.hxx> 39 #include <svx/xlnclit.hxx> 40 #include <svx/xlncapit.hxx> 41 #include <svx/xlnwtit.hxx> 42 #include <svx/xflclit.hxx> 43 #include <svx/xgrad.hxx> 44 #include <svx/xflgrit.hxx> 45 #include <editeng/fontitem.hxx> 46 #include <editeng/akrnitem.hxx> 47 #include <editeng/wrlmitem.hxx> 48 #include <editeng/cntritem.hxx> 49 #include <editeng/colritem.hxx> 50 #include <vcl/metric.hxx> 51 #include <editeng/charscaleitem.hxx> 52 #include <svx/xflhtit.hxx> 53 #include <svx/svdattr.hxx> 54 #include <svx/svdmodel.hxx> 55 #include <svx/svdpage.hxx> 56 #include <svx/svdobj.hxx> 57 #include "svx/svditext.hxx" 58 #include <svx/svdotext.hxx> 59 #include <svx/svdorect.hxx> 60 #include <svx/svdocirc.hxx> 61 #include <svx/svdograf.hxx> 62 #include <svx/svdopath.hxx> 63 #include <svx/svdetc.hxx> 64 #include <svl/itemset.hxx> 65 #include <basegfx/polygon/b2dpolygon.hxx> 66 #include <vcl/salbtype.hxx> // FRound 67 #include <basegfx/matrix/b2dhommatrix.hxx> 68 #include <basegfx/matrix/b2dhommatrixtools.hxx> 69 #include <svx/xlinjoit.hxx> 70 #include <svx/xlndsit.hxx> 71 #include <basegfx/polygon/b2dpolygonclipper.hxx> 72 #include <svx/xbtmpit.hxx> 73 #include <svx/xfltrit.hxx> 74 #include <vcl/bmpacc.hxx> 75 #include <svx/xflbmtit.hxx> 76 #include <svx/xflbstit.hxx> 77 #include <svx/svdpntv.hxx> 78 #include <basegfx/polygon/b2dpolypolygontools.hxx> 79 #include <svx/svditer.hxx> 80 #include <svx/svdogrp.hxx> 81 82 //////////////////////////////////////////////////////////////////////////////////////////////////// 83 84 ImpSdrGDIMetaFileImport::ImpSdrGDIMetaFileImport( 85 SdrModel& rModel, 86 SdrLayerID nLay, 87 const Rectangle& rRect) 88 : maTmpList(), 89 maVD(), 90 maScaleRect(rRect), 91 mnMapScalingOfs(0), 92 mpLineAttr(0), 93 mpFillAttr(0), 94 mpTextAttr(0), 95 mpModel(&rModel), 96 mnLayer(nLay), 97 maOldLineColor(), 98 mnLineWidth(0), 99 maLineJoin(basegfx::B2DLINEJOIN_NONE), 100 maLineCap(com::sun::star::drawing::LineCap_BUTT), 101 maDash(XDASH_RECT, 0, 0, 0, 0, 0), 102 mbMov(false), 103 mbSize(false), 104 maOfs(0, 0), 105 mfScaleX(1.0), 106 mfScaleY(1.0), 107 maScaleX(1.0), 108 maScaleY(1.0), 109 mbFntDirty(true), 110 mbLastObjWasPolyWithoutLine(false), 111 mbNoLine(false), 112 mbNoFill(false), 113 mbLastObjWasLine(false), 114 maClip() 115 { 116 maVD.EnableOutput(false); 117 maVD.SetLineColor(); 118 maVD.SetFillColor(); 119 maOldLineColor.SetRed( maVD.GetLineColor().GetRed() + 1 ); 120 mpLineAttr = new SfxItemSet(rModel.GetItemPool(), XATTR_LINE_FIRST, XATTR_LINE_LAST, 0, 0); 121 mpFillAttr = new SfxItemSet(rModel.GetItemPool(), XATTR_FILL_FIRST, XATTR_FILL_LAST, 0, 0); 122 mpTextAttr = new SfxItemSet(rModel.GetItemPool(), EE_ITEMS_START, EE_ITEMS_END, 0, 0); 123 checkClip(); 124 } 125 126 ImpSdrGDIMetaFileImport::~ImpSdrGDIMetaFileImport() 127 { 128 delete mpLineAttr; 129 delete mpFillAttr; 130 delete mpTextAttr; 131 } 132 133 void ImpSdrGDIMetaFileImport::DoLoopActions(GDIMetaFile& rMtf, SvdProgressInfo* pProgrInfo, sal_uInt32* pActionsToReport) 134 { 135 const sal_uLong nCount(rMtf.GetActionCount()); 136 137 for(sal_uLong a(0); a < nCount; a++) 138 { 139 MetaAction* pAct = rMtf.GetAction(a); 140 141 if(!pAct) 142 { 143 OSL_ENSURE(false, "OOps, no action at valid position (!)"); 144 pAct = rMtf.GetAction(0); 145 } 146 147 switch (pAct->GetType()) 148 { 149 case META_PIXEL_ACTION : DoAction((MetaPixelAction &)*pAct); break; 150 case META_POINT_ACTION : DoAction((MetaPointAction &)*pAct); break; 151 case META_LINE_ACTION : DoAction((MetaLineAction &)*pAct); break; 152 case META_RECT_ACTION : DoAction((MetaRectAction &)*pAct); break; 153 case META_ROUNDRECT_ACTION : DoAction((MetaRoundRectAction &)*pAct); break; 154 case META_ELLIPSE_ACTION : DoAction((MetaEllipseAction &)*pAct); break; 155 case META_ARC_ACTION : DoAction((MetaArcAction &)*pAct); break; 156 case META_PIE_ACTION : DoAction((MetaPieAction &)*pAct); break; 157 case META_CHORD_ACTION : DoAction((MetaChordAction &)*pAct); break; 158 case META_POLYLINE_ACTION : DoAction((MetaPolyLineAction &)*pAct); break; 159 case META_POLYGON_ACTION : DoAction((MetaPolygonAction &)*pAct); break; 160 case META_POLYPOLYGON_ACTION : DoAction((MetaPolyPolygonAction &)*pAct); break; 161 case META_TEXT_ACTION : DoAction((MetaTextAction &)*pAct); break; 162 case META_TEXTARRAY_ACTION : DoAction((MetaTextArrayAction &)*pAct); break; 163 case META_STRETCHTEXT_ACTION : DoAction((MetaStretchTextAction &)*pAct); break; 164 case META_BMP_ACTION : DoAction((MetaBmpAction &)*pAct); break; 165 case META_BMPSCALE_ACTION : DoAction((MetaBmpScaleAction &)*pAct); break; 166 case META_BMPEX_ACTION : DoAction((MetaBmpExAction &)*pAct); break; 167 case META_BMPEXSCALE_ACTION : DoAction((MetaBmpExScaleAction &)*pAct); break; 168 case META_LINECOLOR_ACTION : DoAction((MetaLineColorAction &)*pAct); break; 169 case META_FILLCOLOR_ACTION : DoAction((MetaFillColorAction &)*pAct); break; 170 case META_TEXTCOLOR_ACTION : DoAction((MetaTextColorAction &)*pAct); break; 171 case META_TEXTFILLCOLOR_ACTION : DoAction((MetaTextFillColorAction &)*pAct); break; 172 case META_FONT_ACTION : DoAction((MetaFontAction &)*pAct); break; 173 case META_TEXTALIGN_ACTION : DoAction((MetaTextAlignAction &)*pAct); break; 174 case META_MAPMODE_ACTION : DoAction((MetaMapModeAction &)*pAct); break; 175 case META_CLIPREGION_ACTION : DoAction((MetaClipRegionAction &)*pAct); break; 176 case META_MOVECLIPREGION_ACTION : DoAction((MetaMoveClipRegionAction &)*pAct); break; 177 case META_ISECTRECTCLIPREGION_ACTION: DoAction((MetaISectRectClipRegionAction&)*pAct); break; 178 case META_ISECTREGIONCLIPREGION_ACTION: DoAction((MetaISectRegionClipRegionAction&)*pAct); break; 179 case META_RASTEROP_ACTION : DoAction((MetaRasterOpAction &)*pAct); break; 180 case META_PUSH_ACTION : DoAction((MetaPushAction &)*pAct); break; 181 case META_POP_ACTION : DoAction((MetaPopAction &)*pAct); break; 182 case META_HATCH_ACTION : DoAction((MetaHatchAction &)*pAct); break; 183 case META_COMMENT_ACTION : DoAction((MetaCommentAction &)*pAct, &rMtf); break; 184 185 // missing actions added 186 case META_TEXTRECT_ACTION : DoAction((MetaTextRectAction&)*pAct); break; 187 case META_BMPSCALEPART_ACTION : DoAction((MetaBmpScalePartAction&)*pAct); break; 188 case META_BMPEXSCALEPART_ACTION : DoAction((MetaBmpExScalePartAction&)*pAct); break; 189 case META_MASK_ACTION : DoAction((MetaMaskAction&)*pAct); break; 190 case META_MASKSCALE_ACTION : DoAction((MetaMaskScaleAction&)*pAct); break; 191 case META_MASKSCALEPART_ACTION : DoAction((MetaMaskScalePartAction&)*pAct); break; 192 case META_GRADIENT_ACTION : DoAction((MetaGradientAction&)*pAct); break; 193 case META_WALLPAPER_ACTION : DoAction((MetaWallpaperAction&)*pAct); break; 194 case META_TRANSPARENT_ACTION : DoAction((MetaTransparentAction&)*pAct); break; 195 case META_EPS_ACTION : DoAction((MetaEPSAction&)*pAct); break; 196 case META_REFPOINT_ACTION : DoAction((MetaRefPointAction&)*pAct); break; 197 case META_TEXTLINECOLOR_ACTION : DoAction((MetaTextLineColorAction&)*pAct); break; 198 case META_TEXTLINE_ACTION : DoAction((MetaTextLineAction&)*pAct); break; 199 case META_FLOATTRANSPARENT_ACTION : DoAction((MetaFloatTransparentAction&)*pAct); break; 200 case META_GRADIENTEX_ACTION : DoAction((MetaGradientExAction&)*pAct); break; 201 case META_LAYOUTMODE_ACTION : DoAction((MetaLayoutModeAction&)*pAct); break; 202 case META_TEXTLANGUAGE_ACTION : DoAction((MetaTextLanguageAction&)*pAct); break; 203 case META_OVERLINECOLOR_ACTION : DoAction((MetaOverlineColorAction&)*pAct); break; 204 } 205 206 if(pProgrInfo && pActionsToReport) 207 { 208 (*pActionsToReport)++; 209 210 if(*pActionsToReport >= 16) // Alle 16 Action updaten 211 { 212 if(!pProgrInfo->ReportActions(*pActionsToReport)) 213 break; 214 215 *pActionsToReport = 0; 216 } 217 } 218 } 219 } 220 221 sal_uInt32 ImpSdrGDIMetaFileImport::DoImport( 222 const GDIMetaFile& rMtf, 223 SdrObjList& rOL, 224 sal_uInt32 nInsPos, 225 SvdProgressInfo* pProgrInfo) 226 { 227 // setup some global scale parameter 228 // mfScaleX, mfScaleY, maScaleX, maScaleY, mbMov, mbSize 229 mfScaleX = mfScaleY = 1.0; 230 const Size aMtfSize(rMtf.GetPrefSize()); 231 232 if(aMtfSize.Width() & aMtfSize.Height() && (!maScaleRect.IsEmpty())) 233 { 234 maOfs = maScaleRect.TopLeft(); 235 236 if(aMtfSize.Width() != (maScaleRect.GetWidth() - 1)) 237 { 238 mfScaleX = (double)( maScaleRect.GetWidth() - 1 ) / (double)aMtfSize.Width(); 239 } 240 241 if(aMtfSize.Height() != (maScaleRect.GetHeight() - 1)) 242 { 243 mfScaleY = (double)( maScaleRect.GetHeight() - 1 ) / (double)aMtfSize.Height(); 244 } 245 } 246 247 mbMov = maOfs.X()!=0 || maOfs.Y()!=0; 248 mbSize = false; 249 maScaleX = Fraction( 1, 1 ); 250 maScaleY = Fraction( 1, 1 ); 251 252 if(aMtfSize.Width() != (maScaleRect.GetWidth() - 1)) 253 { 254 maScaleX = Fraction(maScaleRect.GetWidth() - 1, aMtfSize.Width()); 255 mbSize = true; 256 } 257 258 if(aMtfSize.Height() != (maScaleRect.GetHeight() - 1)) 259 { 260 maScaleY = Fraction(maScaleRect.GetHeight() - 1, aMtfSize.Height()); 261 mbSize = true; 262 } 263 264 if(pProgrInfo) 265 { 266 pProgrInfo->SetActionCount(rMtf.GetActionCount()); 267 } 268 269 sal_uInt32 nActionsToReport(0); 270 271 // execute 272 DoLoopActions(const_cast< GDIMetaFile& >(rMtf), pProgrInfo, &nActionsToReport); 273 274 if(pProgrInfo) 275 { 276 pProgrInfo->ReportActions(nActionsToReport); 277 nActionsToReport = 0; 278 } 279 280 // MapMode-Scaling vornehmen 281 MapScaling(); 282 283 // Beim berechnen der Fortschrittsanzeige wird GetActionCount()*3 benutzt. 284 // Da in maTmpList allerdings weniger eintraege als GetActionCount() 285 // existieren koennen, muessen hier die zuviel vermuteten Actionen wieder 286 // hinzugefuegt werden. 287 nActionsToReport = (rMtf.GetActionCount() - maTmpList.size()) * 2; 288 289 // Alle noch nicht gemeldeten Rescales melden 290 if(pProgrInfo) 291 { 292 pProgrInfo->ReportRescales(nActionsToReport); 293 pProgrInfo->SetInsertCount(maTmpList.size()); 294 } 295 296 nActionsToReport = 0; 297 298 // alle in maTmpList zwischengespeicherten Objekte nun in rOL ab der Position nInsPos einfuegen 299 if(nInsPos > rOL.GetObjCount()) 300 { 301 nInsPos = rOL.GetObjCount(); 302 } 303 304 SdrInsertReason aReason(SDRREASON_VIEWCALL); 305 306 for(sal_uInt32 i(0); i < maTmpList.size(); i++) 307 { 308 SdrObject* pObj = maTmpList[i]; 309 rOL.NbcInsertObject(pObj, nInsPos, &aReason); 310 nInsPos++; 311 312 if(pProgrInfo) 313 { 314 nActionsToReport++; 315 316 if(nActionsToReport >= 32) // Alle 32 Action updaten 317 { 318 pProgrInfo->ReportInserts(nActionsToReport); 319 nActionsToReport = 0; 320 } 321 } 322 } 323 324 // ein letztesmal alle verbliebennen Inserts reporten 325 if(pProgrInfo) 326 { 327 pProgrInfo->ReportInserts(nActionsToReport); 328 } 329 330 return maTmpList.size(); 331 } 332 333 void ImpSdrGDIMetaFileImport::SetAttributes(SdrObject* pObj, bool bForceTextAttr) 334 { 335 mbNoLine = false; 336 mbNoFill = false; 337 bool bLine(!bForceTextAttr); 338 bool bFill(!pObj || (pObj->IsClosedObj() && !bForceTextAttr)); 339 bool bText(bForceTextAttr || (pObj && pObj->GetOutlinerParaObject())); 340 341 if(bLine) 342 { 343 if(mnLineWidth) 344 { 345 mpLineAttr->Put(XLineWidthItem(mnLineWidth)); 346 } 347 else 348 { 349 mpLineAttr->Put(XLineWidthItem(0)); 350 } 351 352 maOldLineColor = maVD.GetLineColor(); 353 354 if(maVD.IsLineColor()) 355 { 356 mpLineAttr->Put(XLineStyleItem(XLINE_SOLID)); 357 mpLineAttr->Put(XLineColorItem(String(), maVD.GetLineColor())); 358 } 359 else 360 { 361 mpLineAttr->Put(XLineStyleItem(XLINE_NONE)); 362 } 363 364 switch(maLineJoin) 365 { 366 default : // basegfx::B2DLINEJOIN_NONE 367 mpLineAttr->Put(XLineJointItem(com::sun::star::drawing::LineJoint_NONE)); 368 break; 369 case basegfx::B2DLINEJOIN_MIDDLE: 370 mpLineAttr->Put(XLineJointItem(com::sun::star::drawing::LineJoint_MIDDLE)); 371 break; 372 case basegfx::B2DLINEJOIN_BEVEL: 373 mpLineAttr->Put(XLineJointItem(com::sun::star::drawing::LineJoint_BEVEL)); 374 break; 375 case basegfx::B2DLINEJOIN_MITER: 376 mpLineAttr->Put(XLineJointItem(com::sun::star::drawing::LineJoint_MITER)); 377 break; 378 case basegfx::B2DLINEJOIN_ROUND: 379 mpLineAttr->Put(XLineJointItem(com::sun::star::drawing::LineJoint_ROUND)); 380 break; 381 } 382 383 // Add LineCap support 384 mpLineAttr->Put(XLineCapItem(maLineCap)); 385 386 if(((maDash.GetDots() && maDash.GetDotLen()) || (maDash.GetDashes() && maDash.GetDashLen())) && maDash.GetDistance()) 387 { 388 mpLineAttr->Put(XLineDashItem(String(), maDash)); 389 } 390 else 391 { 392 mpLineAttr->Put(XLineDashItem(String(), XDash(XDASH_RECT))); 393 } 394 } 395 else 396 { 397 mbNoLine = true; 398 } 399 400 if(bFill) 401 { 402 if(maVD.IsFillColor()) 403 { 404 mpFillAttr->Put(XFillStyleItem(XFILL_SOLID)); 405 mpFillAttr->Put(XFillColorItem(String(), maVD.GetFillColor())); 406 } 407 else 408 { 409 mpFillAttr->Put(XFillStyleItem(XFILL_NONE)); 410 } 411 } 412 else 413 { 414 mbNoFill = true; 415 } 416 417 if(bText && mbFntDirty) 418 { 419 Font aFnt(maVD.GetFont()); 420 const sal_uInt32 nHeight(FRound(aFnt.GetSize().Height() * mfScaleY)); 421 422 mpTextAttr->Put( SvxFontItem( aFnt.GetFamily(), aFnt.GetName(), aFnt.GetStyleName(), aFnt.GetPitch(), aFnt.GetCharSet(), EE_CHAR_FONTINFO ) ); 423 mpTextAttr->Put( SvxFontItem( aFnt.GetFamily(), aFnt.GetName(), aFnt.GetStyleName(), aFnt.GetPitch(), aFnt.GetCharSet(), EE_CHAR_FONTINFO_CJK ) ); 424 mpTextAttr->Put( SvxFontItem( aFnt.GetFamily(), aFnt.GetName(), aFnt.GetStyleName(), aFnt.GetPitch(), aFnt.GetCharSet(), EE_CHAR_FONTINFO_CTL ) ); 425 mpTextAttr->Put(SvxPostureItem(aFnt.GetItalic(), EE_CHAR_ITALIC)); 426 mpTextAttr->Put(SvxWeightItem(aFnt.GetWeight(), EE_CHAR_WEIGHT)); 427 mpTextAttr->Put( SvxFontHeightItem( nHeight, 100, EE_CHAR_FONTHEIGHT ) ); 428 mpTextAttr->Put( SvxFontHeightItem( nHeight, 100, EE_CHAR_FONTHEIGHT_CJK ) ); 429 mpTextAttr->Put( SvxFontHeightItem( nHeight, 100, EE_CHAR_FONTHEIGHT_CTL ) ); 430 mpTextAttr->Put(SvxCharScaleWidthItem(100, EE_CHAR_FONTWIDTH)); 431 mpTextAttr->Put(SvxUnderlineItem(aFnt.GetUnderline(), EE_CHAR_UNDERLINE)); 432 mpTextAttr->Put(SvxOverlineItem(aFnt.GetOverline(), EE_CHAR_OVERLINE)); 433 mpTextAttr->Put(SvxCrossedOutItem(aFnt.GetStrikeout(), EE_CHAR_STRIKEOUT)); 434 mpTextAttr->Put(SvxShadowedItem(aFnt.IsShadow(), EE_CHAR_SHADOW)); 435 436 // #i118485# Setting this item leads to problems (written #i118498# for this) 437 // mpTextAttr->Put(SvxAutoKernItem(aFnt.IsKerning(), EE_CHAR_KERNING)); 438 439 mpTextAttr->Put(SvxWordLineModeItem(aFnt.IsWordLineMode(), EE_CHAR_WLM)); 440 mpTextAttr->Put(SvxContourItem(aFnt.IsOutline(), EE_CHAR_OUTLINE)); 441 mpTextAttr->Put(SvxColorItem(maVD.GetTextColor(), EE_CHAR_COLOR)); 442 //... svxfont textitem svditext 443 mbFntDirty = false; 444 } 445 446 if(pObj) 447 { 448 pObj->SetLayer(mnLayer); 449 450 if(bLine) 451 { 452 pObj->SetMergedItemSet(*mpLineAttr); 453 } 454 455 if(bFill) 456 { 457 pObj->SetMergedItemSet(*mpFillAttr); 458 } 459 460 if(bText) 461 { 462 pObj->SetMergedItemSet(*mpTextAttr); 463 pObj->SetMergedItem(SdrTextHorzAdjustItem(SDRTEXTHORZADJUST_LEFT)); 464 } 465 } 466 } 467 468 void ImpSdrGDIMetaFileImport::InsertObj(SdrObject* pObj, bool bScale) 469 { 470 if(bScale && !maScaleRect.IsEmpty()) 471 { 472 if(mbSize) 473 { 474 pObj->NbcResize(Point(), maScaleX, maScaleY); 475 } 476 477 if(mbMov) 478 { 479 pObj->NbcMove(Size(maOfs.X(), maOfs.Y())); 480 } 481 } 482 483 if(isClip()) 484 { 485 const basegfx::B2DPolyPolygon aPoly(pObj->TakeXorPoly()); 486 const basegfx::B2DRange aOldRange(aPoly.getB2DRange()); 487 const SdrLayerID aOldLayer(pObj->GetLayer()); 488 const SfxItemSet aOldItemSet(pObj->GetMergedItemSet()); 489 const SdrGrafObj* pSdrGrafObj = dynamic_cast< SdrGrafObj* >(pObj); 490 const SdrTextObj* pSdrTextObj = dynamic_cast< SdrTextObj* >(pObj); 491 492 if(pSdrTextObj && pSdrTextObj->HasText()) 493 { 494 // all text objects are created from ImportText and have no line or fill attributes, so 495 // it is okay to concentrate on the text itself 496 while(true) 497 { 498 const basegfx::B2DPolyPolygon aTextContour(pSdrTextObj->TakeContour()); 499 const basegfx::B2DRange aTextRange(aTextContour.getB2DRange()); 500 const basegfx::B2DRange aClipRange(maClip.getB2DRange()); 501 502 // no overlap -> completely outside 503 if(!aClipRange.overlaps(aTextRange)) 504 { 505 SdrObject::Free(pObj); 506 break; 507 } 508 509 // when the clip is a rectangle fast check for inside is possible 510 if(basegfx::tools::isRectangle(maClip) && aClipRange.isInside(aTextRange)) 511 { 512 // completely inside ClipRect 513 break; 514 } 515 516 // here text needs to be clipped; to do so, convert to SdrObjects with polygons 517 // and add these recursively. Delete original object, do not add in this run 518 SdrObject* pConverted = pSdrTextObj->ConvertToPolyObj(true, true); 519 SdrObject::Free(pObj); 520 521 if(pConverted) 522 { 523 // recursively add created conversion; per definition this shall not 524 // contain further SdrTextObjs. Visit only non-group objects 525 SdrObjListIter aIter(*pConverted, IM_DEEPNOGROUPS); 526 527 // work with clones; the created conversion may contain group objects 528 // and when working with the original objects the loop itself could 529 // break and the cleanup later would be pretty complicated (only delete group 530 // objects, are these empty, ...?) 531 while(aIter.IsMore()) 532 { 533 SdrObject* pCandidate = aIter.Next(); 534 OSL_ENSURE(pCandidate && 0 == dynamic_cast< SdrObjGroup* >(pCandidate), "SdrObjListIter with IM_DEEPNOGROUPS error (!)"); 535 SdrObject* pNewClone = pCandidate->Clone(); 536 537 if(pNewClone) 538 { 539 InsertObj(pNewClone, false); 540 } 541 else 542 { 543 OSL_ENSURE(false, "SdrObject::Clone() failed (!)"); 544 } 545 } 546 547 // cleanup temporary conversion objects 548 SdrObject::Free(pConverted); 549 } 550 551 break; 552 } 553 } 554 else 555 { 556 BitmapEx aBitmapEx; 557 558 if(pSdrGrafObj) 559 { 560 aBitmapEx = pSdrGrafObj->GetGraphic().GetBitmapEx(); 561 } 562 563 SdrObject::Free(pObj); 564 565 if(!aOldRange.isEmpty()) 566 { 567 // clip against ClipRegion 568 const basegfx::B2DPolyPolygon aNewPoly( 569 basegfx::tools::clipPolyPolygonOnPolyPolygon( 570 aPoly, 571 maClip, 572 true, 573 aPoly.isClosed() ? false : true)); 574 const basegfx::B2DRange aNewRange(aNewPoly.getB2DRange()); 575 576 if(!aNewRange.isEmpty()) 577 { 578 pObj = new SdrPathObj( 579 aNewPoly.isClosed() ? OBJ_POLY : OBJ_PLIN, 580 aNewPoly); 581 582 pObj->SetLayer(aOldLayer); 583 pObj->SetMergedItemSet(aOldItemSet); 584 585 if(!!aBitmapEx) 586 { 587 // aNewRange is inside of aOldRange and defines which part of aBitmapEx is used 588 const double fScaleX(aBitmapEx.GetSizePixel().Width() / (aOldRange.getWidth() ? aOldRange.getWidth() : 1.0)); 589 const double fScaleY(aBitmapEx.GetSizePixel().Height() / (aOldRange.getHeight() ? aOldRange.getHeight() : 1.0)); 590 basegfx::B2DRange aPixel(aNewRange); 591 basegfx::B2DHomMatrix aTrans; 592 593 aTrans.translate(-aOldRange.getMinX(), -aOldRange.getMinY()); 594 aTrans.scale(fScaleX, fScaleY); 595 aPixel.transform(aTrans); 596 597 const Size aOrigSizePixel(aBitmapEx.GetSizePixel()); 598 const Point aClipTopLeft( 599 basegfx::fround(floor(std::max(0.0, aPixel.getMinX()))), 600 basegfx::fround(floor(std::max(0.0, aPixel.getMinY())))); 601 const Size aClipSize( 602 basegfx::fround(ceil(std::min((double)aOrigSizePixel.Width(), aPixel.getWidth()))), 603 basegfx::fround(ceil(std::min((double)aOrigSizePixel.Height(), aPixel.getHeight())))); 604 const BitmapEx aClippedBitmap( 605 aBitmapEx, 606 aClipTopLeft, 607 aClipSize); 608 609 pObj->SetMergedItem(XFillStyleItem(XFILL_BITMAP)); 610 pObj->SetMergedItem(XFillBitmapItem(String(), Graphic(aClippedBitmap))); 611 pObj->SetMergedItem(XFillBmpTileItem(false)); 612 pObj->SetMergedItem(XFillBmpStretchItem(true)); 613 } 614 } 615 } 616 } 617 } 618 619 if(pObj) 620 { 621 // #i111954# check object for visibility 622 // used are SdrPathObj, SdrRectObj, SdrCircObj, SdrGrafObj 623 bool bVisible(false); 624 625 if(pObj->HasLineStyle()) 626 { 627 bVisible = true; 628 } 629 630 if(!bVisible && pObj->HasFillStyle()) 631 { 632 bVisible = true; 633 } 634 635 if(!bVisible) 636 { 637 SdrTextObj* pTextObj = dynamic_cast< SdrTextObj* >(pObj); 638 639 if(pTextObj && pTextObj->HasText()) 640 { 641 bVisible = true; 642 } 643 } 644 645 if(!bVisible) 646 { 647 SdrGrafObj* pGrafObj = dynamic_cast< SdrGrafObj* >(pObj); 648 649 if(pGrafObj) 650 { 651 // this may be refined to check if the graphic really is visible. It 652 // is here to ensure that graphic objects without fill, line and text 653 // get created 654 bVisible = true; 655 } 656 } 657 658 if(!bVisible) 659 { 660 SdrObject::Free(pObj); 661 } 662 else 663 { 664 maTmpList.push_back(pObj); 665 666 if(dynamic_cast< SdrPathObj* >(pObj)) 667 { 668 const bool bClosed(pObj->IsClosedObj()); 669 670 mbLastObjWasPolyWithoutLine = mbNoLine && bClosed; 671 mbLastObjWasLine = !bClosed; 672 } 673 else 674 { 675 mbLastObjWasPolyWithoutLine = false; 676 mbLastObjWasLine = false; 677 } 678 } 679 } 680 } 681 682 /**************************************************************************************************/ 683 684 void ImpSdrGDIMetaFileImport::DoAction(MetaPixelAction& /*rAct*/) 685 { 686 } 687 688 void ImpSdrGDIMetaFileImport::DoAction(MetaPointAction& /*rAct*/) 689 { 690 } 691 692 void ImpSdrGDIMetaFileImport::DoAction(MetaLineAction& rAct) 693 { 694 // #i73407# reformulation to use new B2DPolygon classes 695 const basegfx::B2DPoint aStart(rAct.GetStartPoint().X(), rAct.GetStartPoint().Y()); 696 const basegfx::B2DPoint aEnd(rAct.GetEndPoint().X(), rAct.GetEndPoint().Y()); 697 698 if(!aStart.equal(aEnd)) 699 { 700 basegfx::B2DPolygon aLine; 701 const basegfx::B2DHomMatrix aTransform(basegfx::tools::createScaleTranslateB2DHomMatrix(mfScaleX, mfScaleY, maOfs.X(), maOfs.Y())); 702 703 aLine.append(aStart); 704 aLine.append(aEnd); 705 aLine.transform(aTransform); 706 707 const LineInfo& rLineInfo = rAct.GetLineInfo(); 708 const sal_Int32 nNewLineWidth(rLineInfo.GetWidth()); 709 bool bCreateLineObject(true); 710 711 if(mbLastObjWasLine && (nNewLineWidth == mnLineWidth) && CheckLastLineMerge(aLine)) 712 { 713 bCreateLineObject = false; 714 } 715 716 if(bCreateLineObject) 717 { 718 SdrPathObj* pPath = new SdrPathObj(OBJ_LINE, basegfx::B2DPolyPolygon(aLine)); 719 mnLineWidth = nNewLineWidth; 720 maLineJoin = rLineInfo.GetLineJoin(); 721 maLineCap = rLineInfo.GetLineCap(); 722 maDash = XDash(XDASH_RECT, 723 rLineInfo.GetDotCount(), rLineInfo.GetDotLen(), 724 rLineInfo.GetDashCount(), rLineInfo.GetDashLen(), 725 rLineInfo.GetDistance()); 726 SetAttributes(pPath); 727 mnLineWidth = 0; 728 maLineJoin = basegfx::B2DLINEJOIN_NONE; 729 maDash = XDash(); 730 InsertObj(pPath, false); 731 } 732 } 733 } 734 735 void ImpSdrGDIMetaFileImport::DoAction(MetaRectAction& rAct) 736 { 737 SdrRectObj* pRect=new SdrRectObj(rAct.GetRect()); 738 SetAttributes(pRect); 739 InsertObj(pRect); 740 } 741 742 void ImpSdrGDIMetaFileImport::DoAction(MetaRoundRectAction& rAct) 743 { 744 SdrRectObj* pRect=new SdrRectObj(rAct.GetRect()); 745 SetAttributes(pRect); 746 long nRad=(rAct.GetHorzRound()+rAct.GetVertRound())/2; 747 if (nRad!=0) { 748 SfxItemSet aSet(*mpLineAttr->GetPool(), SDRATTR_ECKENRADIUS, SDRATTR_ECKENRADIUS, 0, 0); 749 aSet.Put(SdrEckenradiusItem(nRad)); 750 pRect->SetMergedItemSet(aSet); 751 } 752 InsertObj(pRect); 753 } 754 755 /**************************************************************************************************/ 756 757 void ImpSdrGDIMetaFileImport::DoAction(MetaEllipseAction& rAct) 758 { 759 SdrCircObj* pCirc=new SdrCircObj(OBJ_CIRC,rAct.GetRect()); 760 SetAttributes(pCirc); 761 InsertObj(pCirc); 762 } 763 764 void ImpSdrGDIMetaFileImport::DoAction(MetaArcAction& rAct) 765 { 766 Point aCenter(rAct.GetRect().Center()); 767 long nStart=GetAngle(rAct.GetStartPoint()-aCenter); 768 long nEnd=GetAngle(rAct.GetEndPoint()-aCenter); 769 SdrCircObj* pCirc=new SdrCircObj(OBJ_CARC,rAct.GetRect(),nStart,nEnd); 770 SetAttributes(pCirc); 771 InsertObj(pCirc); 772 } 773 774 void ImpSdrGDIMetaFileImport::DoAction(MetaPieAction& rAct) 775 { 776 Point aCenter(rAct.GetRect().Center()); 777 long nStart=GetAngle(rAct.GetStartPoint()-aCenter); 778 long nEnd=GetAngle(rAct.GetEndPoint()-aCenter); 779 SdrCircObj* pCirc=new SdrCircObj(OBJ_SECT,rAct.GetRect(),nStart,nEnd); 780 SetAttributes(pCirc); 781 InsertObj(pCirc); 782 } 783 784 void ImpSdrGDIMetaFileImport::DoAction(MetaChordAction& rAct) 785 { 786 Point aCenter(rAct.GetRect().Center()); 787 long nStart=GetAngle(rAct.GetStartPoint()-aCenter); 788 long nEnd=GetAngle(rAct.GetEndPoint()-aCenter); 789 SdrCircObj* pCirc=new SdrCircObj(OBJ_CCUT,rAct.GetRect(),nStart,nEnd); 790 SetAttributes(pCirc); 791 InsertObj(pCirc); 792 } 793 794 /**************************************************************************************************/ 795 796 bool ImpSdrGDIMetaFileImport::CheckLastLineMerge(const basegfx::B2DPolygon& rSrcPoly) 797 { 798 // #i102706# Do not merge closed polygons 799 if(rSrcPoly.isClosed()) 800 { 801 return false; 802 } 803 804 // #i73407# reformulation to use new B2DPolygon classes 805 if(mbLastObjWasLine && (maOldLineColor == maVD.GetLineColor()) && rSrcPoly.count()) 806 { 807 SdrObject* pTmpObj = maTmpList.size() ? maTmpList[maTmpList.size() - 1] : 0; 808 SdrPathObj* pLastPoly = dynamic_cast< SdrPathObj* >(pTmpObj); 809 810 if(pLastPoly) 811 { 812 if(1L == pLastPoly->GetPathPoly().count()) 813 { 814 bool bOk(false); 815 basegfx::B2DPolygon aDstPoly(pLastPoly->GetPathPoly().getB2DPolygon(0L)); 816 817 // #i102706# Do not merge closed polygons 818 if(aDstPoly.isClosed()) 819 { 820 return false; 821 } 822 823 if(aDstPoly.count()) 824 { 825 const sal_uInt32 nMaxDstPnt(aDstPoly.count() - 1L); 826 const sal_uInt32 nMaxSrcPnt(rSrcPoly.count() - 1L); 827 828 if(aDstPoly.getB2DPoint(nMaxDstPnt) == rSrcPoly.getB2DPoint(0L)) 829 { 830 aDstPoly.append(rSrcPoly, 1L, rSrcPoly.count() - 1L); 831 bOk = true; 832 } 833 else if(aDstPoly.getB2DPoint(0L) == rSrcPoly.getB2DPoint(nMaxSrcPnt)) 834 { 835 basegfx::B2DPolygon aNew(rSrcPoly); 836 aNew.append(aDstPoly, 1L, aDstPoly.count() - 1L); 837 aDstPoly = aNew; 838 bOk = true; 839 } 840 else if(aDstPoly.getB2DPoint(0L) == rSrcPoly.getB2DPoint(0L)) 841 { 842 aDstPoly.flip(); 843 aDstPoly.append(rSrcPoly, 1L, rSrcPoly.count() - 1L); 844 bOk = true; 845 } 846 else if(aDstPoly.getB2DPoint(nMaxDstPnt) == rSrcPoly.getB2DPoint(nMaxSrcPnt)) 847 { 848 basegfx::B2DPolygon aNew(rSrcPoly); 849 aNew.flip(); 850 aDstPoly.append(aNew, 1L, aNew.count() - 1L); 851 bOk = true; 852 } 853 } 854 855 if(bOk) 856 { 857 pLastPoly->NbcSetPathPoly(basegfx::B2DPolyPolygon(aDstPoly)); 858 } 859 860 return bOk; 861 } 862 } 863 } 864 865 return false; 866 } 867 868 bool ImpSdrGDIMetaFileImport::CheckLastPolyLineAndFillMerge(const basegfx::B2DPolyPolygon & rPolyPolygon) 869 { 870 // #i73407# reformulation to use new B2DPolygon classes 871 if(mbLastObjWasPolyWithoutLine) 872 { 873 SdrObject* pTmpObj = maTmpList.size() ? maTmpList[maTmpList.size() - 1] : 0; 874 SdrPathObj* pLastPoly = dynamic_cast< SdrPathObj* >(pTmpObj); 875 876 if(pLastPoly) 877 { 878 if(pLastPoly->GetPathPoly() == rPolyPolygon) 879 { 880 SetAttributes(NULL); 881 882 if(!mbNoLine && mbNoFill) 883 { 884 pLastPoly->SetMergedItemSet(*mpLineAttr); 885 886 return true; 887 } 888 } 889 } 890 } 891 892 return false; 893 } 894 895 void ImpSdrGDIMetaFileImport::checkClip() 896 { 897 if(maVD.IsClipRegion()) 898 { 899 maClip = maVD.GetClipRegion().GetAsB2DPolyPolygon(); 900 901 if(isClip()) 902 { 903 const basegfx::B2DHomMatrix aTransform( 904 basegfx::tools::createScaleTranslateB2DHomMatrix( 905 mfScaleX, 906 mfScaleY, 907 maOfs.X(), 908 maOfs.Y())); 909 910 maClip.transform(aTransform); 911 } 912 } 913 } 914 915 bool ImpSdrGDIMetaFileImport::isClip() const 916 { 917 return !maClip.getB2DRange().isEmpty(); 918 } 919 920 void ImpSdrGDIMetaFileImport::DoAction( MetaPolyLineAction& rAct ) 921 { 922 // #i73407# reformulation to use new B2DPolygon classes 923 basegfx::B2DPolygon aSource(rAct.GetPolygon().getB2DPolygon()); 924 925 if(aSource.count()) 926 { 927 const basegfx::B2DHomMatrix aTransform(basegfx::tools::createScaleTranslateB2DHomMatrix(mfScaleX, mfScaleY, maOfs.X(), maOfs.Y())); 928 aSource.transform(aTransform); 929 } 930 931 const LineInfo& rLineInfo = rAct.GetLineInfo(); 932 const sal_Int32 nNewLineWidth(rLineInfo.GetWidth()); 933 bool bCreateLineObject(true); 934 935 if(mbLastObjWasLine && (nNewLineWidth == mnLineWidth) && CheckLastLineMerge(aSource)) 936 { 937 bCreateLineObject = false; 938 } 939 else if(mbLastObjWasPolyWithoutLine && CheckLastPolyLineAndFillMerge(basegfx::B2DPolyPolygon(aSource))) 940 { 941 bCreateLineObject = false; 942 } 943 944 if(bCreateLineObject) 945 { 946 SdrPathObj* pPath = new SdrPathObj( 947 aSource.isClosed() ? OBJ_POLY : OBJ_PLIN, 948 basegfx::B2DPolyPolygon(aSource)); 949 mnLineWidth = nNewLineWidth; 950 maLineJoin = rLineInfo.GetLineJoin(); 951 maLineCap = rLineInfo.GetLineCap(); 952 maDash = XDash(XDASH_RECT, 953 rLineInfo.GetDotCount(), rLineInfo.GetDotLen(), 954 rLineInfo.GetDashCount(), rLineInfo.GetDashLen(), 955 rLineInfo.GetDistance()); 956 SetAttributes(pPath); 957 mnLineWidth = 0; 958 maLineJoin = basegfx::B2DLINEJOIN_NONE; 959 maDash = XDash(); 960 InsertObj(pPath, false); 961 } 962 } 963 964 void ImpSdrGDIMetaFileImport::DoAction( MetaPolygonAction& rAct ) 965 { 966 // #i73407# reformulation to use new B2DPolygon classes 967 basegfx::B2DPolygon aSource(rAct.GetPolygon().getB2DPolygon()); 968 969 if(aSource.count()) 970 { 971 const basegfx::B2DHomMatrix aTransform(basegfx::tools::createScaleTranslateB2DHomMatrix(mfScaleX, mfScaleY, maOfs.X(), maOfs.Y())); 972 aSource.transform(aTransform); 973 974 if(!mbLastObjWasPolyWithoutLine || !CheckLastPolyLineAndFillMerge(basegfx::B2DPolyPolygon(aSource))) 975 { 976 // #i73407# make sure polygon is closed, it's a filled primitive 977 aSource.setClosed(true); 978 SdrPathObj* pPath = new SdrPathObj(OBJ_POLY, basegfx::B2DPolyPolygon(aSource)); 979 SetAttributes(pPath); 980 InsertObj(pPath, false); 981 } 982 } 983 } 984 985 void ImpSdrGDIMetaFileImport::DoAction(MetaPolyPolygonAction& rAct) 986 { 987 // #i73407# reformulation to use new B2DPolygon classes 988 basegfx::B2DPolyPolygon aSource(rAct.GetPolyPolygon().getB2DPolyPolygon()); 989 990 if(aSource.count()) 991 { 992 const basegfx::B2DHomMatrix aTransform(basegfx::tools::createScaleTranslateB2DHomMatrix(mfScaleX, mfScaleY, maOfs.X(), maOfs.Y())); 993 aSource.transform(aTransform); 994 995 if(!mbLastObjWasPolyWithoutLine || !CheckLastPolyLineAndFillMerge(aSource)) 996 { 997 // #i73407# make sure polygon is closed, it's a filled primitive 998 aSource.setClosed(true); 999 SdrPathObj* pPath = new SdrPathObj(OBJ_POLY, aSource); 1000 SetAttributes(pPath); 1001 InsertObj(pPath, false); 1002 } 1003 } 1004 } 1005 1006 /**************************************************************************************************/ 1007 1008 void ImpSdrGDIMetaFileImport::ImportText( const Point& rPos, const XubString& rStr, const MetaAction& rAct ) 1009 { 1010 // calc text box size, add 5% to make it fit safely 1011 1012 FontMetric aFontMetric( maVD.GetFontMetric() ); 1013 Font aFnt( maVD.GetFont() ); 1014 FontAlign eAlg( aFnt.GetAlign() ); 1015 1016 sal_Int32 nTextWidth = (sal_Int32)( maVD.GetTextWidth( rStr ) * mfScaleX ); 1017 sal_Int32 nTextHeight = (sal_Int32)( maVD.GetTextHeight() * mfScaleY ); 1018 //sal_Int32 nDxWidth = 0; 1019 //sal_Int32 nLen = rStr.Len(); 1020 1021 Point aPos( FRound(rPos.X() * mfScaleX + maOfs.X()), FRound(rPos.Y() * mfScaleY + maOfs.Y()) ); 1022 Size aSize( nTextWidth, nTextHeight ); 1023 1024 if ( eAlg == ALIGN_BASELINE ) 1025 aPos.Y() -= FRound(aFontMetric.GetAscent() * mfScaleY); 1026 else if ( eAlg == ALIGN_BOTTOM ) 1027 aPos.Y() -= nTextHeight; 1028 1029 Rectangle aTextRect( aPos, aSize ); 1030 SdrRectObj* pText =new SdrRectObj( OBJ_TEXT, aTextRect ); 1031 1032 pText->SetMergedItem ( SdrTextUpperDistItem (0)); 1033 pText->SetMergedItem ( SdrTextLowerDistItem (0)); 1034 pText->SetMergedItem ( SdrTextRightDistItem (0)); 1035 pText->SetMergedItem ( SdrTextLeftDistItem (0)); 1036 1037 if ( aFnt.GetWidth() || ( rAct.GetType() == META_STRETCHTEXT_ACTION ) ) 1038 { 1039 pText->ClearMergedItem( SDRATTR_TEXT_AUTOGROWWIDTH ); 1040 pText->SetMergedItem( SdrTextAutoGrowHeightItem( false ) ); 1041 // don't let the margins eat the space needed for the text 1042 pText->SetMergedItem( SdrTextFitToSizeTypeItem( SDRTEXTFIT_ALLLINES ) ); 1043 } 1044 else 1045 { 1046 pText->SetMergedItem( SdrTextAutoGrowWidthItem( true ) ); 1047 } 1048 1049 pText->SetModel(mpModel); 1050 pText->SetLayer(mnLayer); 1051 pText->NbcSetText( rStr ); 1052 SetAttributes( pText, true ); 1053 pText->SetSnapRect( aTextRect ); 1054 1055 if (!aFnt.IsTransparent()) 1056 { 1057 SfxItemSet aAttr(*mpFillAttr->GetPool(), XATTR_FILL_FIRST, XATTR_FILL_LAST, 0, 0); 1058 aAttr.Put(XFillStyleItem(XFILL_SOLID)); 1059 aAttr.Put(XFillColorItem(String(), aFnt.GetFillColor())); 1060 pText->SetMergedItemSet(aAttr); 1061 } 1062 sal_uInt32 nWink = aFnt.GetOrientation(); 1063 if ( nWink ) 1064 { 1065 nWink*=10; 1066 double a=nWink*nPi180; 1067 double nSin=sin(a); 1068 double nCos=cos(a); 1069 pText->NbcRotate(aPos,nWink,nSin,nCos); 1070 } 1071 InsertObj( pText, false ); 1072 } 1073 1074 void ImpSdrGDIMetaFileImport::DoAction(MetaTextAction& rAct) 1075 { 1076 XubString aStr(rAct.GetText()); 1077 aStr.Erase(0,rAct.GetIndex()); 1078 aStr.Erase(rAct.GetLen()); 1079 ImportText( rAct.GetPoint(), aStr, rAct ); 1080 } 1081 1082 void ImpSdrGDIMetaFileImport::DoAction(MetaTextArrayAction& rAct) 1083 { 1084 XubString aStr(rAct.GetText()); 1085 aStr.Erase(0,rAct.GetIndex()); 1086 aStr.Erase(rAct.GetLen()); 1087 ImportText( rAct.GetPoint(), aStr, rAct ); 1088 } 1089 1090 void ImpSdrGDIMetaFileImport::DoAction(MetaStretchTextAction& rAct) 1091 { 1092 XubString aStr(rAct.GetText()); 1093 aStr.Erase(0,rAct.GetIndex()); 1094 aStr.Erase(rAct.GetLen()); 1095 ImportText( rAct.GetPoint(), aStr, rAct ); 1096 } 1097 1098 void ImpSdrGDIMetaFileImport::DoAction(MetaBmpAction& rAct) 1099 { 1100 Rectangle aRect(rAct.GetPoint(),rAct.GetBitmap().GetSizePixel()); 1101 aRect.Right()++; aRect.Bottom()++; 1102 SdrGrafObj* pGraf=new SdrGrafObj(Graphic(rAct.GetBitmap()),aRect); 1103 1104 // This action is not creating line and fill, set directly, do not use SetAttributes(..) 1105 pGraf->SetMergedItem(XLineStyleItem(XLINE_NONE)); 1106 pGraf->SetMergedItem(XFillStyleItem(XFILL_NONE)); 1107 InsertObj(pGraf); 1108 } 1109 1110 void ImpSdrGDIMetaFileImport::DoAction(MetaBmpScaleAction& rAct) 1111 { 1112 Rectangle aRect(rAct.GetPoint(),rAct.GetSize()); 1113 aRect.Right()++; aRect.Bottom()++; 1114 SdrGrafObj* pGraf=new SdrGrafObj(Graphic(rAct.GetBitmap()),aRect); 1115 1116 // This action is not creating line and fill, set directly, do not use SetAttributes(..) 1117 pGraf->SetMergedItem(XLineStyleItem(XLINE_NONE)); 1118 pGraf->SetMergedItem(XFillStyleItem(XFILL_NONE)); 1119 InsertObj(pGraf); 1120 } 1121 1122 void ImpSdrGDIMetaFileImport::DoAction(MetaBmpExAction& rAct) 1123 { 1124 Rectangle aRect(rAct.GetPoint(),rAct.GetBitmapEx().GetSizePixel()); 1125 aRect.Right()++; aRect.Bottom()++; 1126 SdrGrafObj* pGraf=new SdrGrafObj( rAct.GetBitmapEx(), aRect ); 1127 1128 // This action is not creating line and fill, set directly, do not use SetAttributes(..) 1129 pGraf->SetMergedItem(XLineStyleItem(XLINE_NONE)); 1130 pGraf->SetMergedItem(XFillStyleItem(XFILL_NONE)); 1131 InsertObj(pGraf); 1132 } 1133 1134 void ImpSdrGDIMetaFileImport::DoAction(MetaBmpExScaleAction& rAct) 1135 { 1136 Rectangle aRect(rAct.GetPoint(),rAct.GetSize()); 1137 aRect.Right()++; aRect.Bottom()++; 1138 SdrGrafObj* pGraf=new SdrGrafObj( rAct.GetBitmapEx(), aRect ); 1139 1140 // This action is not creating line and fill, set directly, do not use SetAttributes(..) 1141 pGraf->SetMergedItem(XLineStyleItem(XLINE_NONE)); 1142 pGraf->SetMergedItem(XFillStyleItem(XFILL_NONE)); 1143 InsertObj(pGraf); 1144 } 1145 1146 //////////////////////////////////////////////////////////////////////////////////////////////////// 1147 1148 void ImpSdrGDIMetaFileImport::DoAction( MetaHatchAction& rAct ) 1149 { 1150 // #i73407# reformulation to use new B2DPolygon classes 1151 basegfx::B2DPolyPolygon aSource(rAct.GetPolyPolygon().getB2DPolyPolygon()); 1152 1153 if(aSource.count()) 1154 { 1155 const basegfx::B2DHomMatrix aTransform(basegfx::tools::createScaleTranslateB2DHomMatrix(mfScaleX, mfScaleY, maOfs.X(), maOfs.Y())); 1156 aSource.transform(aTransform); 1157 1158 if(!mbLastObjWasPolyWithoutLine || !CheckLastPolyLineAndFillMerge(aSource)) 1159 { 1160 const Hatch& rHatch = rAct.GetHatch(); 1161 SdrPathObj* pPath = new SdrPathObj(OBJ_POLY, aSource); 1162 SfxItemSet aHatchAttr(mpModel->GetItemPool(), XATTR_FILLSTYLE, XATTR_FILLSTYLE, XATTR_FILLHATCH, XATTR_FILLHATCH, 0, 0); 1163 XHatchStyle eStyle; 1164 1165 switch(rHatch.GetStyle()) 1166 { 1167 case(HATCH_TRIPLE) : 1168 { 1169 eStyle = XHATCH_TRIPLE; 1170 break; 1171 } 1172 1173 case(HATCH_DOUBLE) : 1174 { 1175 eStyle = XHATCH_DOUBLE; 1176 break; 1177 } 1178 1179 default: 1180 { 1181 eStyle = XHATCH_SINGLE; 1182 break; 1183 } 1184 } 1185 1186 SetAttributes(pPath); 1187 aHatchAttr.Put(XFillStyleItem(XFILL_HATCH)); 1188 aHatchAttr.Put(XFillHatchItem(&mpModel->GetItemPool(), XHatch(rHatch.GetColor(), eStyle, rHatch.GetDistance(), rHatch.GetAngle()))); 1189 pPath->SetMergedItemSet(aHatchAttr); 1190 1191 InsertObj(pPath, false); 1192 } 1193 } 1194 } 1195 1196 //////////////////////////////////////////////////////////////////////////////////////////////////// 1197 1198 void ImpSdrGDIMetaFileImport::DoAction(MetaLineColorAction& rAct) 1199 { 1200 rAct.Execute(&maVD); 1201 } 1202 1203 void ImpSdrGDIMetaFileImport::DoAction(MetaMapModeAction& rAct) 1204 { 1205 MapScaling(); 1206 rAct.Execute(&maVD); 1207 mbLastObjWasPolyWithoutLine = false; 1208 mbLastObjWasLine = false; 1209 } 1210 1211 void ImpSdrGDIMetaFileImport::MapScaling() 1212 { 1213 const sal_uInt32 nAnz(maTmpList.size()); 1214 sal_uInt32 i(0); 1215 const MapMode& rMap = maVD.GetMapMode(); 1216 Point aMapOrg( rMap.GetOrigin() ); 1217 bool bMov2(aMapOrg.X() != 0 || aMapOrg.Y() != 0); 1218 1219 if(bMov2) 1220 { 1221 for(i = mnMapScalingOfs; i < nAnz; i++) 1222 { 1223 SdrObject* pObj = maTmpList[i]; 1224 1225 pObj->NbcMove(Size(aMapOrg.X(), aMapOrg.Y())); 1226 } 1227 } 1228 1229 mnMapScalingOfs = nAnz; 1230 } 1231 1232 //////////////////////////////////////////////////////////////////////////////////////////////////// 1233 1234 void ImpSdrGDIMetaFileImport::DoAction( MetaCommentAction& rAct, GDIMetaFile* pMtf ) 1235 { 1236 ByteString aSkipComment; 1237 1238 if( rAct.GetComment().CompareIgnoreCaseToAscii( "XGRAD_SEQ_BEGIN" ) == COMPARE_EQUAL ) 1239 { 1240 MetaGradientExAction* pAct = (MetaGradientExAction*) pMtf->NextAction(); 1241 1242 if( pAct && pAct->GetType() == META_GRADIENTEX_ACTION ) 1243 { 1244 // #i73407# reformulation to use new B2DPolygon classes 1245 basegfx::B2DPolyPolygon aSource(pAct->GetPolyPolygon().getB2DPolyPolygon()); 1246 1247 if(aSource.count()) 1248 { 1249 if(!mbLastObjWasPolyWithoutLine || !CheckLastPolyLineAndFillMerge(aSource)) 1250 { 1251 const Gradient& rGrad = pAct->GetGradient(); 1252 SdrPathObj* pPath = new SdrPathObj(OBJ_POLY, aSource); 1253 SfxItemSet aGradAttr(mpModel->GetItemPool(), XATTR_FILLSTYLE, XATTR_FILLSTYLE, XATTR_FILLGRADIENT, XATTR_FILLGRADIENT, 0, 0); 1254 XGradient aXGradient; 1255 1256 aXGradient.SetGradientStyle((XGradientStyle)rGrad.GetStyle()); 1257 aXGradient.SetStartColor(rGrad.GetStartColor()); 1258 aXGradient.SetEndColor(rGrad.GetEndColor()); 1259 aXGradient.SetAngle((sal_uInt16)rGrad.GetAngle()); 1260 aXGradient.SetBorder(rGrad.GetBorder()); 1261 aXGradient.SetXOffset(rGrad.GetOfsX()); 1262 aXGradient.SetYOffset(rGrad.GetOfsY()); 1263 aXGradient.SetStartIntens(rGrad.GetStartIntensity()); 1264 aXGradient.SetEndIntens(rGrad.GetEndIntensity()); 1265 aXGradient.SetSteps(rGrad.GetSteps()); 1266 1267 // no need to use SetAttributes(..) here since line and fill style 1268 // need to be set individually 1269 // SetAttributes(pPath); 1270 1271 // switch line off; when there was one there will be a 1272 // META_POLYLINE_ACTION following creating another object 1273 aGradAttr.Put(XLineStyleItem(XLINE_NONE)); 1274 1275 // add detected gradient fillstyle 1276 aGradAttr.Put(XFillStyleItem(XFILL_GRADIENT)); 1277 aGradAttr.Put(XFillGradientItem(&mpModel->GetItemPool(), aXGradient)); 1278 1279 pPath->SetMergedItemSet(aGradAttr); 1280 1281 InsertObj(pPath); 1282 } 1283 } 1284 1285 aSkipComment = "XGRAD_SEQ_END"; 1286 } 1287 } 1288 1289 if(aSkipComment.Len()) 1290 { 1291 MetaAction* pSkipAct = pMtf->NextAction(); 1292 1293 while( pSkipAct 1294 && ((pSkipAct->GetType() != META_COMMENT_ACTION ) 1295 || (((MetaCommentAction*)pSkipAct)->GetComment().CompareIgnoreCaseToAscii(aSkipComment.GetBuffer()) != COMPARE_EQUAL))) 1296 { 1297 pSkipAct = pMtf->NextAction(); 1298 } 1299 } 1300 } 1301 1302 //////////////////////////////////////////////////////////////////////////////////////////////////// 1303 1304 void ImpSdrGDIMetaFileImport::DoAction(MetaTextRectAction& rAct) 1305 { 1306 GDIMetaFile aTemp; 1307 1308 maVD.AddTextRectActions(rAct.GetRect(), rAct.GetText(), rAct.GetStyle(), aTemp); 1309 DoLoopActions(aTemp, 0, 0); 1310 } 1311 1312 void ImpSdrGDIMetaFileImport::DoAction(MetaBmpScalePartAction& rAct) 1313 { 1314 Rectangle aRect(rAct.GetDestPoint(), rAct.GetDestSize()); 1315 Bitmap aBitmap(rAct.GetBitmap()); 1316 1317 aRect.Right()++; 1318 aRect.Bottom()++; 1319 aBitmap.Crop(Rectangle(rAct.GetSrcPoint(), rAct.GetSrcSize())); 1320 SdrGrafObj* pGraf = new SdrGrafObj(aBitmap, aRect); 1321 1322 // This action is not creating line and fill, set directly, do not use SetAttributes(..) 1323 pGraf->SetMergedItem(XLineStyleItem(XLINE_NONE)); 1324 pGraf->SetMergedItem(XFillStyleItem(XFILL_NONE)); 1325 InsertObj(pGraf); 1326 } 1327 1328 void ImpSdrGDIMetaFileImport::DoAction(MetaBmpExScalePartAction& rAct) 1329 { 1330 Rectangle aRect(rAct.GetDestPoint(),rAct.GetDestSize()); 1331 BitmapEx aBitmapEx(rAct.GetBitmapEx()); 1332 1333 aRect.Right()++; 1334 aRect.Bottom()++; 1335 aBitmapEx.Crop(Rectangle(rAct.GetSrcPoint(), rAct.GetSrcSize())); 1336 SdrGrafObj* pGraf = new SdrGrafObj(aBitmapEx, aRect); 1337 1338 // This action is not creating line and fill, set directly, do not use SetAttributes(..) 1339 pGraf->SetMergedItem(XLineStyleItem(XLINE_NONE)); 1340 pGraf->SetMergedItem(XFillStyleItem(XFILL_NONE)); 1341 InsertObj(pGraf); 1342 } 1343 1344 void ImpSdrGDIMetaFileImport::DoAction(MetaMaskAction& rAct) 1345 { 1346 Rectangle aRect(rAct.GetPoint(), rAct.GetBitmap().GetSizePixel()); 1347 BitmapEx aBitmapEx(rAct.GetBitmap(), rAct.GetColor()); 1348 1349 aRect.Right()++; aRect.Bottom()++; 1350 SdrGrafObj* pGraf = new SdrGrafObj(aBitmapEx, aRect); 1351 1352 // This action is not creating line and fill, set directly, do not use SetAttributes(..) 1353 pGraf->SetMergedItem(XLineStyleItem(XLINE_NONE)); 1354 pGraf->SetMergedItem(XFillStyleItem(XFILL_NONE)); 1355 InsertObj(pGraf); 1356 } 1357 1358 void ImpSdrGDIMetaFileImport::DoAction(MetaMaskScaleAction& rAct) 1359 { 1360 Rectangle aRect(rAct.GetPoint(), rAct.GetSize()); 1361 BitmapEx aBitmapEx(rAct.GetBitmap(), rAct.GetColor()); 1362 1363 aRect.Right()++; aRect.Bottom()++; 1364 SdrGrafObj* pGraf = new SdrGrafObj(aBitmapEx, aRect); 1365 1366 // This action is not creating line and fill, set directly, do not use SetAttributes(..) 1367 pGraf->SetMergedItem(XLineStyleItem(XLINE_NONE)); 1368 pGraf->SetMergedItem(XFillStyleItem(XFILL_NONE)); 1369 InsertObj(pGraf); 1370 } 1371 1372 void ImpSdrGDIMetaFileImport::DoAction(MetaMaskScalePartAction& rAct) 1373 { 1374 Rectangle aRect(rAct.GetDestPoint(), rAct.GetDestSize()); 1375 BitmapEx aBitmapEx(rAct.GetBitmap(), rAct.GetColor()); 1376 1377 aRect.Right()++; aRect.Bottom()++; 1378 aBitmapEx.Crop(Rectangle(rAct.GetSrcPoint(), rAct.GetSrcSize())); 1379 SdrGrafObj* pGraf = new SdrGrafObj(aBitmapEx, aRect); 1380 1381 // This action is not creating line and fill, set directly, do not use SetAttributes(..) 1382 pGraf->SetMergedItem(XLineStyleItem(XLINE_NONE)); 1383 pGraf->SetMergedItem(XFillStyleItem(XFILL_NONE)); 1384 InsertObj(pGraf); 1385 } 1386 1387 XGradientStyle getXGradientStyleFromGradientStyle(const GradientStyle& rGradientStyle) 1388 { 1389 XGradientStyle aXGradientStyle(XGRAD_LINEAR); 1390 1391 switch(rGradientStyle) 1392 { 1393 case GRADIENT_LINEAR: aXGradientStyle = XGRAD_LINEAR; break; 1394 case GRADIENT_AXIAL: aXGradientStyle = XGRAD_AXIAL; break; 1395 case GRADIENT_RADIAL: aXGradientStyle = XGRAD_RADIAL; break; 1396 case GRADIENT_ELLIPTICAL: aXGradientStyle = XGRAD_ELLIPTICAL; break; 1397 case GRADIENT_SQUARE: aXGradientStyle = XGRAD_SQUARE; break; 1398 case GRADIENT_RECT: aXGradientStyle = XGRAD_RECT; break; 1399 1400 // Needed due to GRADIENT_FORCE_EQUAL_SIZE; this again is needed 1401 // to force the enum defines in VCL to a defined size for the compilers, 1402 // so despite it is never used it cannot be removed (would break the 1403 // API implementation probably). 1404 default: break; 1405 } 1406 1407 return aXGradientStyle; 1408 } 1409 1410 void ImpSdrGDIMetaFileImport::DoAction(MetaGradientAction& rAct) 1411 { 1412 basegfx::B2DRange aRange(rAct.GetRect().Left(), rAct.GetRect().Top(), rAct.GetRect().Right(), rAct.GetRect().Bottom()); 1413 1414 if(!aRange.isEmpty()) 1415 { 1416 const basegfx::B2DHomMatrix aTransform(basegfx::tools::createScaleTranslateB2DHomMatrix(mfScaleX, mfScaleY, maOfs.X(), maOfs.Y())); 1417 aRange.transform(aTransform); 1418 const Gradient& rGradient = rAct.GetGradient(); 1419 SdrRectObj* pRect = new SdrRectObj( 1420 Rectangle( 1421 floor(aRange.getMinX()), 1422 floor(aRange.getMinY()), 1423 ceil(aRange.getMaxX()), 1424 ceil(aRange.getMaxY()))); 1425 SfxItemSet aGradientAttr(mpModel->GetItemPool(), XATTR_FILLSTYLE, XATTR_FILLSTYLE, XATTR_FILLGRADIENT, XATTR_FILLGRADIENT, 0, 0); 1426 const XGradientStyle aXGradientStyle(getXGradientStyleFromGradientStyle(rGradient.GetStyle())); 1427 const XFillGradientItem aXFillGradientItem( 1428 &mpModel->GetItemPool(), 1429 XGradient( 1430 rGradient.GetStartColor(), 1431 rGradient.GetEndColor(), 1432 aXGradientStyle, 1433 rGradient.GetAngle(), 1434 rGradient.GetOfsX(), 1435 rGradient.GetOfsY(), 1436 rGradient.GetBorder(), 1437 rGradient.GetStartIntensity(), 1438 rGradient.GetEndIntensity(), 1439 rGradient.GetSteps())); 1440 1441 SetAttributes(pRect); 1442 aGradientAttr.Put(XFillStyleItem(XFILL_HATCH)); 1443 aGradientAttr.Put(aXFillGradientItem); 1444 pRect->SetMergedItemSet(aGradientAttr); 1445 1446 InsertObj(pRect, false); 1447 } 1448 } 1449 1450 void ImpSdrGDIMetaFileImport::DoAction(MetaWallpaperAction& /*rAct*/) 1451 { 1452 OSL_ENSURE(false, "Tried to construct SdrObject from MetaWallpaperAction: not supported (!)"); 1453 } 1454 1455 void ImpSdrGDIMetaFileImport::DoAction(MetaTransparentAction& rAct) 1456 { 1457 basegfx::B2DPolyPolygon aSource(rAct.GetPolyPolygon().getB2DPolyPolygon()); 1458 1459 if(aSource.count()) 1460 { 1461 const basegfx::B2DHomMatrix aTransform(basegfx::tools::createScaleTranslateB2DHomMatrix(mfScaleX, mfScaleY, maOfs.X(), maOfs.Y())); 1462 aSource.transform(aTransform); 1463 aSource.setClosed(true); 1464 1465 SdrPathObj* pPath = new SdrPathObj(OBJ_POLY, aSource); 1466 SetAttributes(pPath); 1467 pPath->SetMergedItem(XFillTransparenceItem(rAct.GetTransparence())); 1468 InsertObj(pPath, false); 1469 } 1470 } 1471 1472 void ImpSdrGDIMetaFileImport::DoAction(MetaEPSAction& /*rAct*/) 1473 { 1474 OSL_ENSURE(false, "Tried to construct SdrObject from MetaEPSAction: not supported (!)"); 1475 } 1476 1477 void ImpSdrGDIMetaFileImport::DoAction(MetaTextLineAction& /*rAct*/) 1478 { 1479 OSL_ENSURE(false, "Tried to construct SdrObject from MetaTextLineAction: not supported (!)"); 1480 } 1481 1482 void ImpSdrGDIMetaFileImport::DoAction(MetaGradientExAction& rAct) 1483 { 1484 basegfx::B2DPolyPolygon aSource(rAct.GetPolyPolygon().getB2DPolyPolygon()); 1485 1486 if(aSource.count()) 1487 { 1488 const basegfx::B2DHomMatrix aTransform(basegfx::tools::createScaleTranslateB2DHomMatrix(mfScaleX, mfScaleY, maOfs.X(), maOfs.Y())); 1489 aSource.transform(aTransform); 1490 1491 if(!mbLastObjWasPolyWithoutLine || !CheckLastPolyLineAndFillMerge(aSource)) 1492 { 1493 const Gradient& rGradient = rAct.GetGradient(); 1494 SdrPathObj* pPath = new SdrPathObj(OBJ_POLY, aSource); 1495 SfxItemSet aGradientAttr(mpModel->GetItemPool(), XATTR_FILLSTYLE, XATTR_FILLSTYLE, XATTR_FILLGRADIENT, XATTR_FILLGRADIENT, 0, 0); 1496 const XGradientStyle aXGradientStyle(getXGradientStyleFromGradientStyle(rGradient.GetStyle())); 1497 const XFillGradientItem aXFillGradientItem( 1498 &mpModel->GetItemPool(), 1499 XGradient( 1500 rGradient.GetStartColor(), 1501 rGradient.GetEndColor(), 1502 aXGradientStyle, 1503 rGradient.GetAngle(), 1504 rGradient.GetOfsX(), 1505 rGradient.GetOfsY(), 1506 rGradient.GetBorder(), 1507 rGradient.GetStartIntensity(), 1508 rGradient.GetEndIntensity(), 1509 rGradient.GetSteps())); 1510 1511 SetAttributes(pPath); 1512 aGradientAttr.Put(XFillStyleItem(XFILL_HATCH)); 1513 aGradientAttr.Put(aXFillGradientItem); 1514 pPath->SetMergedItemSet(aGradientAttr); 1515 1516 InsertObj(pPath, false); 1517 } 1518 } 1519 } 1520 1521 void ImpSdrGDIMetaFileImport::DoAction(MetaFloatTransparentAction& rAct) 1522 { 1523 const GDIMetaFile& rMtf = rAct.GetGDIMetaFile(); 1524 1525 if(rMtf.GetActionCount()) 1526 { 1527 const Rectangle aRect(rAct.GetPoint(),rAct.GetSize()); 1528 1529 Rectangle aHairline; 1530 const Rectangle aBoundRect(rMtf.GetBoundRect(*Application::GetDefaultDevice(), &aHairline)); 1531 1532 // convert metafile sub-content to BitmapEx 1533 BitmapEx aBitmapEx( 1534 convertMetafileToBitmapEx( 1535 rMtf, 1536 basegfx::B2DRange( 1537 aRect.Left(), aRect.Top(), 1538 aRect.Right(), aRect.Bottom()), 1539 125000)); 1540 1541 // handle colors 1542 const Gradient& rGradient = rAct.GetGradient(); 1543 basegfx::BColor aStart(rGradient.GetStartColor().getBColor()); 1544 basegfx::BColor aEnd(rGradient.GetEndColor().getBColor()); 1545 1546 if(100 != rGradient.GetStartIntensity()) 1547 { 1548 aStart *= (double)rGradient.GetStartIntensity() / 100.0; 1549 } 1550 1551 if(100 != rGradient.GetEndIntensity()) 1552 { 1553 aEnd *= (double)rGradient.GetEndIntensity() / 100.0; 1554 } 1555 1556 const bool bEqualColors(aStart == aEnd); 1557 const bool bNoSteps(1 == rGradient.GetSteps()); 1558 bool bCreateObject(true); 1559 bool bHasNewMask(false); 1560 AlphaMask aNewMask; 1561 double fTransparence(0.0); 1562 bool bFixedTransparence(false); 1563 1564 if(bEqualColors || bNoSteps) 1565 { 1566 // single transparence 1567 const basegfx::BColor aMedium(basegfx::average(aStart, aEnd)); 1568 fTransparence = aMedium.luminance(); 1569 1570 if(basegfx::fTools::lessOrEqual(fTransparence, 0.0)) 1571 { 1572 // no transparence needed, all done 1573 } 1574 else if(basegfx::fTools::moreOrEqual(fTransparence, 1.0)) 1575 { 1576 // all transparent, no object 1577 bCreateObject = false; 1578 } 1579 else 1580 { 1581 // 0.0 < transparence < 1.0, apply fixed transparence 1582 bFixedTransparence = true; 1583 } 1584 } 1585 else 1586 { 1587 // gradient transparence 1588 VirtualDevice aVDev; 1589 1590 aVDev.SetOutputSizePixel(aBitmapEx.GetBitmap().GetSizePixel()); 1591 aVDev.DrawGradient(Rectangle(Point(0, 0), aVDev.GetOutputSizePixel()), rGradient); 1592 1593 aNewMask = AlphaMask(aVDev.GetBitmap(Point(0, 0), aVDev.GetOutputSizePixel())); 1594 bHasNewMask = true; 1595 } 1596 1597 if(bCreateObject) 1598 { 1599 if(bHasNewMask || bFixedTransparence) 1600 { 1601 if(!aBitmapEx.IsAlpha() && !aBitmapEx.IsTransparent()) 1602 { 1603 // no transparence yet, apply new one 1604 if(bFixedTransparence) 1605 { 1606 sal_uInt8 aAlpha(basegfx::fround(fTransparence * 255.0)); 1607 1608 aNewMask = AlphaMask(aBitmapEx.GetBitmap().GetSizePixel(), &aAlpha); 1609 } 1610 1611 aBitmapEx = BitmapEx(aBitmapEx.GetBitmap(), aNewMask); 1612 } 1613 else 1614 { 1615 // mix existing and new alpha mask 1616 AlphaMask aOldMask; 1617 1618 if(aBitmapEx.IsAlpha()) 1619 { 1620 aOldMask = aBitmapEx.GetAlpha(); 1621 } 1622 else if(TRANSPARENT_BITMAP == aBitmapEx.GetTransparentType()) 1623 { 1624 aOldMask = aBitmapEx.GetMask(); 1625 } 1626 else if(TRANSPARENT_COLOR == aBitmapEx.GetTransparentType()) 1627 { 1628 aOldMask = aBitmapEx.GetBitmap().CreateMask(aBitmapEx.GetTransparentColor()); 1629 } 1630 1631 BitmapWriteAccess* pOld = aOldMask.AcquireWriteAccess(); 1632 1633 if(pOld) 1634 { 1635 const double fFactor(1.0 / 255.0); 1636 1637 if(bFixedTransparence) 1638 { 1639 const double fOpNew(1.0 - fTransparence); 1640 1641 for(sal_uInt32 y(0); y < static_cast< sal_uInt32 >(pOld->Height()); y++) 1642 { 1643 for(sal_uInt32 x(0); x < static_cast< sal_uInt32 >(pOld->Width()); x++) 1644 { 1645 const double fOpOld(1.0 - (pOld->GetPixel(y, x).GetIndex() * fFactor)); 1646 const sal_uInt8 aCol(basegfx::fround((1.0 - (fOpOld * fOpNew)) * 255.0)); 1647 1648 pOld->SetPixel(y, x, BitmapColor(aCol)); 1649 } 1650 } 1651 } 1652 else 1653 { 1654 BitmapReadAccess* pNew = aNewMask.AcquireReadAccess(); 1655 1656 if(pNew) 1657 { 1658 if(pOld->Width() == pNew->Width() && pOld->Height() == pNew->Height()) 1659 { 1660 for(sal_uInt32 y(0); y < static_cast< sal_uInt32 >(pOld->Height()); y++) 1661 { 1662 for(sal_uInt32 x(0); x < static_cast< sal_uInt32 >(pOld->Width()); x++) 1663 { 1664 const double fOpOld(1.0 - (pOld->GetPixel(y, x).GetIndex() * fFactor)); 1665 const double fOpNew(1.0 - (pNew->GetPixel(y, x).GetIndex() * fFactor)); 1666 const sal_uInt8 aCol(basegfx::fround((1.0 - (fOpOld * fOpNew)) * 255.0)); 1667 1668 pOld->SetPixel(y, x, BitmapColor(aCol)); 1669 } 1670 } 1671 } 1672 else 1673 { 1674 OSL_ENSURE(false, "Alpha masks have different sizes (!)"); 1675 } 1676 1677 aNewMask.ReleaseAccess(pNew); 1678 } 1679 else 1680 { 1681 OSL_ENSURE(false, "Got no access to new alpha mask (!)"); 1682 } 1683 } 1684 1685 aOldMask.ReleaseAccess(pOld); 1686 } 1687 else 1688 { 1689 OSL_ENSURE(false, "Got no access to old alpha mask (!)"); 1690 } 1691 1692 // apply combined bitmap as mask 1693 aBitmapEx = BitmapEx(aBitmapEx.GetBitmap(), aOldMask); 1694 } 1695 } 1696 1697 // create and add object 1698 SdrGrafObj* pGraf = new SdrGrafObj(aBitmapEx, aRect); 1699 1700 // for MetaFloatTransparentAction, do not use SetAttributes(...) 1701 // since these metafile content is not used to draw line/fill 1702 // dependent of these setting at the device content 1703 pGraf->SetMergedItem(XLineStyleItem(XLINE_NONE)); 1704 pGraf->SetMergedItem(XFillStyleItem(XFILL_NONE)); 1705 InsertObj(pGraf); 1706 } 1707 } 1708 } 1709 1710 //////////////////////////////////////////////////////////////////////////////////////////////////// 1711 // eof 1712