| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_vcl.hxx" |
| |
| #include <vcl/gdimetafiletools.hxx> |
| #include <vcl/metaact.hxx> |
| #include <basegfx/polygon/b2dpolygonclipper.hxx> |
| #include <basegfx/matrix/b2dhommatrixtools.hxx> |
| #include <basegfx/polygon/b2dpolypolygontools.hxx> |
| #include <basegfx/polygon/b2dpolygontools.hxx> |
| #include <vcl/virdev.hxx> |
| #include <vcl/svapp.hxx> |
| #include <vcl/graphictools.hxx> |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| // helpers |
| |
| namespace |
| { |
| bool handleGeometricContent( |
| const basegfx::B2DPolyPolygon& rClip, |
| const basegfx::B2DPolyPolygon& rSource, |
| GDIMetaFile& rTarget, |
| bool bStroke) |
| { |
| if(rSource.count() && rClip.count()) |
| { |
| const basegfx::B2DPolyPolygon aResult( |
| basegfx::tools::clipPolyPolygonOnPolyPolygon( |
| rSource, |
| rClip, |
| true, // inside |
| bStroke)); |
| |
| if(aResult.count()) |
| { |
| if(aResult == rSource) |
| { |
| // not clipped, but inside. Add original |
| return false; |
| } |
| else |
| { |
| // add clipped geometry |
| if(bStroke) |
| { |
| for(sal_uInt32 a(0); a < aResult.count(); a++) |
| { |
| rTarget.AddAction( |
| new MetaPolyLineAction( |
| Polygon(aResult.getB2DPolygon(a)))); |
| } |
| } |
| else |
| { |
| rTarget.AddAction( |
| new MetaPolyPolygonAction( |
| PolyPolygon(aResult))); |
| } |
| } |
| } |
| } |
| |
| return true; |
| } |
| |
| bool handleGradientContent( |
| const basegfx::B2DPolyPolygon& rClip, |
| const basegfx::B2DPolyPolygon& rSource, |
| const Gradient& rGradient, |
| GDIMetaFile& rTarget) |
| { |
| if(rSource.count() && rClip.count()) |
| { |
| const basegfx::B2DPolyPolygon aResult( |
| basegfx::tools::clipPolyPolygonOnPolyPolygon( |
| rSource, |
| rClip, |
| true, // inside |
| false)); // stroke |
| |
| if(aResult.count()) |
| { |
| if(aResult == rSource) |
| { |
| // not clipped, but inside. Add original |
| return false; |
| } |
| else |
| { |
| // add clipped geometry |
| rTarget.AddAction( |
| new MetaGradientExAction( |
| PolyPolygon(aResult), |
| rGradient)); |
| } |
| } |
| } |
| |
| return true; |
| } |
| |
| bool handleBitmapContent( |
| const basegfx::B2DPolyPolygon& rClip, |
| const Point& rPoint, |
| const Size& rSize, |
| const BitmapEx& rBitmapEx, |
| GDIMetaFile& rTarget) |
| { |
| if(!rSize.Width() || !rSize.Height() || rBitmapEx.IsEmpty()) |
| { |
| // bitmap or size is empty |
| return true; |
| } |
| |
| const basegfx::B2DRange aLogicBitmapRange( |
| rPoint.X(), rPoint.Y(), |
| rPoint.X() + rSize.Width(), rPoint.Y() + rSize.Height()); |
| const basegfx::B2DPolyPolygon aClipOfBitmap( |
| basegfx::tools::clipPolyPolygonOnRange( |
| rClip, |
| aLogicBitmapRange, |
| true, |
| false)); // stroke |
| |
| if(!aClipOfBitmap.count()) |
| { |
| // outside clip region |
| return true; |
| } |
| |
| // inside or overlapping. Use area to find out if it is completely |
| // covering (inside) or overlapping |
| const double fClipArea(basegfx::tools::getArea(aClipOfBitmap)); |
| const double fBitmapArea( |
| aLogicBitmapRange.getWidth() * aLogicBitmapRange.getWidth() + |
| aLogicBitmapRange.getHeight() * aLogicBitmapRange.getHeight()); |
| const double fFactor(fClipArea / fBitmapArea); |
| |
| if(basegfx::fTools::more(fFactor, 1.0 - 0.001)) |
| { |
| // completely covering (with 0.1% tolerance) |
| return false; |
| } |
| |
| // needs clipping (with 0.1% tolerance). Prepare VirtualDevice |
| // in pixel mode for alpha channel painting (black is transparent, |
| // white to paint 100% opacity) |
| const Size aSizePixel(rBitmapEx.GetSizePixel()); |
| VirtualDevice aVDev; |
| |
| aVDev.SetOutputSizePixel(aSizePixel); |
| aVDev.EnableMapMode(false); |
| aVDev.SetFillColor(COL_WHITE); |
| aVDev.SetLineColor(); |
| |
| if(rBitmapEx.IsTransparent()) |
| { |
| // use given alpha channel |
| aVDev.DrawBitmap(Point(0, 0), rBitmapEx.GetAlpha().GetBitmap()); |
| } |
| else |
| { |
| // reset alpha channel |
| aVDev.SetBackground(Wallpaper(Color(COL_BLACK))); |
| aVDev.Erase(); |
| } |
| |
| // transform polygon from clipping to pixel coordinates |
| basegfx::B2DPolyPolygon aPixelPoly(aClipOfBitmap); |
| basegfx::B2DHomMatrix aTransform; |
| |
| aTransform.translate(-aLogicBitmapRange.getMinX(), -aLogicBitmapRange.getMinY()); |
| aTransform.scale( |
| static_cast< double >(aSizePixel.Width()) / aLogicBitmapRange.getWidth(), |
| static_cast< double >(aSizePixel.Height()) / aLogicBitmapRange.getHeight()); |
| aPixelPoly.transform(aTransform); |
| |
| // to fill the non-covered parts, use the Xor fill rule of |
| // PolyPolygon painting. Start with a all-covering polygon and |
| // add the clip polygon one |
| basegfx::B2DPolyPolygon aInvertPixelPoly; |
| |
| aInvertPixelPoly.append( |
| basegfx::tools::createPolygonFromRect( |
| basegfx::B2DRange( |
| 0.0, 0.0, |
| aSizePixel.Width(), aSizePixel.Height()))); |
| aInvertPixelPoly.append(aPixelPoly); |
| |
| // paint as alpha |
| aVDev.DrawPolyPolygon(aInvertPixelPoly); |
| |
| // get created alpha mask and set defaults |
| AlphaMask aAlpha( |
| aVDev.GetBitmap( |
| Point(0, 0), |
| aSizePixel)); |
| |
| aAlpha.SetPrefSize(rBitmapEx.GetPrefSize()); |
| aAlpha.SetPrefMapMode(rBitmapEx.GetPrefMapMode()); |
| |
| // add new action replacing the old one |
| rTarget.AddAction( |
| new MetaBmpExScaleAction( |
| Point( |
| basegfx::fround(aLogicBitmapRange.getMinX()), |
| basegfx::fround(aLogicBitmapRange.getMinY())), |
| Size( |
| basegfx::fround(aLogicBitmapRange.getWidth()), |
| basegfx::fround(aLogicBitmapRange.getHeight())), |
| BitmapEx(rBitmapEx.GetBitmap(), aAlpha))); |
| |
| return true; |
| } |
| |
| void addSvtGraphicStroke(const SvtGraphicStroke& rStroke, GDIMetaFile& rTarget) |
| { |
| // write SvtGraphicFill |
| SvMemoryStream aMemStm; |
| aMemStm << rStroke; |
| rTarget.AddAction( |
| new MetaCommentAction( |
| "XPATHSTROKE_SEQ_BEGIN", |
| 0, |
| static_cast< const sal_uInt8* >(aMemStm.GetData()), |
| aMemStm.Seek(STREAM_SEEK_TO_END))); |
| } |
| |
| void addSvtGraphicFill(const SvtGraphicFill &rFilling, GDIMetaFile& rTarget) |
| { |
| // write SvtGraphicFill |
| SvMemoryStream aMemStm; |
| aMemStm << rFilling; |
| rTarget.AddAction( |
| new MetaCommentAction( |
| "XPATHFILL_SEQ_BEGIN", |
| 0, |
| static_cast< const sal_uInt8* >(aMemStm.GetData()), |
| aMemStm.Seek(STREAM_SEEK_TO_END))); |
| } |
| } // end of anonymous namespace |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| // #121267# Tooling to internally clip geometry against internal clip regions |
| |
| void clipMetafileContentAgainstOwnRegions(GDIMetaFile& rSource) |
| { |
| const sal_uLong nObjCount(rSource.GetActionCount()); |
| |
| if(!nObjCount) |
| { |
| return; |
| } |
| |
| // prepare target data container and push/pop stack data |
| GDIMetaFile aTarget; |
| bool bChanged(false); |
| std::vector< basegfx::B2DPolyPolygon > aClips; |
| std::vector< sal_uInt16 > aPushFlags; |
| std::vector< MapMode > aMapModes; |
| |
| // start with empty region |
| aClips.push_back(basegfx::B2DPolyPolygon()); |
| |
| // start with default MapMode (MAP_PIXEL) |
| aMapModes.push_back(MapMode()); |
| |
| for(sal_uLong i(0); i < nObjCount; ++i) |
| { |
| const MetaAction* pAction(rSource.GetAction(i)); |
| const sal_uInt16 nType(pAction->GetType()); |
| bool bDone(false); |
| |
| // basic operation takes care of clipregion actions (four) and push/pop of these |
| // to steer the currently set clip region. There *is* an active |
| // clip region when (aClips.size() && aClips.back().count()), see |
| // below |
| switch(nType) |
| { |
| case META_CLIPREGION_ACTION : |
| { |
| const MetaClipRegionAction* pA = static_cast< const MetaClipRegionAction* >(pAction); |
| |
| if(pA->IsClipping()) |
| { |
| const Region& rRegion = pA->GetRegion(); |
| const basegfx::B2DPolyPolygon aNewClip(rRegion.GetAsB2DPolyPolygon()); |
| |
| aClips.back() = aNewClip; |
| } |
| else |
| { |
| aClips.back() = basegfx::B2DPolyPolygon(); |
| } |
| |
| break; |
| } |
| |
| case META_ISECTRECTCLIPREGION_ACTION : |
| { |
| const MetaISectRectClipRegionAction* pA = static_cast< const MetaISectRectClipRegionAction* >(pAction); |
| const Rectangle& rRect = pA->GetRect(); |
| |
| if(!rRect.IsEmpty() && aClips.size() && aClips.back().count()) |
| { |
| const basegfx::B2DRange aClipRange( |
| rRect.Left(), rRect.Top(), |
| rRect.Right(), rRect.Bottom()); |
| |
| aClips.back() = basegfx::tools::clipPolyPolygonOnRange( |
| aClips.back(), |
| aClipRange, |
| true, // inside |
| false); // stroke |
| } |
| break; |
| } |
| |
| case META_ISECTREGIONCLIPREGION_ACTION : |
| { |
| const MetaISectRegionClipRegionAction* pA = static_cast< const MetaISectRegionClipRegionAction* >(pAction); |
| const Region& rRegion = pA->GetRegion(); |
| |
| if(!rRegion.IsEmpty() && aClips.size() && aClips.back().count()) |
| { |
| const basegfx::B2DPolyPolygon aNewClip(rRegion.GetAsB2DPolyPolygon()); |
| |
| aClips.back() = basegfx::tools::clipPolyPolygonOnPolyPolygon( |
| aClips.back(), |
| aNewClip, |
| true, // inside |
| false); // stroke |
| } |
| break; |
| } |
| |
| case META_MOVECLIPREGION_ACTION : |
| { |
| const MetaMoveClipRegionAction* pA = static_cast< const MetaMoveClipRegionAction* >(pAction); |
| const long aHorMove(pA->GetHorzMove()); |
| const long aVerMove(pA->GetVertMove()); |
| |
| if((aHorMove || aVerMove) && aClips.size() && aClips.back().count()) |
| { |
| aClips.back().transform( |
| basegfx::tools::createTranslateB2DHomMatrix( |
| aHorMove, |
| aVerMove)); |
| } |
| break; |
| } |
| |
| case META_PUSH_ACTION : |
| { |
| const MetaPushAction* pA = static_cast< const MetaPushAction* >(pAction); |
| const sal_uInt16 nFlags(pA->GetFlags()); |
| |
| aPushFlags.push_back(nFlags); |
| |
| if(nFlags & PUSH_CLIPREGION) |
| { |
| aClips.push_back(aClips.back()); |
| } |
| |
| if(nFlags & PUSH_MAPMODE) |
| { |
| aMapModes.push_back(aMapModes.back()); |
| } |
| break; |
| } |
| |
| case META_POP_ACTION : |
| { |
| |
| if(aPushFlags.size()) |
| { |
| const sal_uInt16 nFlags(aPushFlags.back()); |
| aPushFlags.pop_back(); |
| |
| if(nFlags & PUSH_CLIPREGION) |
| { |
| if(aClips.size() > 1) |
| { |
| aClips.pop_back(); |
| } |
| else |
| { |
| OSL_ENSURE(false, "Wrong POP() in ClipRegions (!)"); |
| } |
| } |
| |
| if(nFlags & PUSH_MAPMODE) |
| { |
| if(aMapModes.size() > 1) |
| { |
| aMapModes.pop_back(); |
| } |
| else |
| { |
| OSL_ENSURE(false, "Wrong POP() in MapModes (!)"); |
| } |
| } |
| } |
| else |
| { |
| OSL_ENSURE(false, "Invalid pop() without push() (!)"); |
| } |
| |
| break; |
| } |
| |
| case META_MAPMODE_ACTION : |
| { |
| const MetaMapModeAction* pA = static_cast< const MetaMapModeAction* >(pAction); |
| |
| aMapModes.back() = pA->GetMapMode(); |
| break; |
| } |
| |
| default: |
| { |
| break; |
| } |
| } |
| |
| // this area contains all actions which could potentially be clipped. Since |
| // this tooling is only a fallback (see comments in header), only the needed |
| // actions will be implemented. Extend using the pattern for the already |
| // implemented actions. |
| if(aClips.size() && aClips.back().count()) |
| { |
| switch(nType) |
| { |
| // |
| // pixel actions, just check on inside |
| // |
| case META_PIXEL_ACTION : |
| { |
| const MetaPixelAction* pA = static_cast< const MetaPixelAction* >(pAction); |
| const Point& rPoint = pA->GetPoint(); |
| |
| if(!basegfx::tools::isInside( |
| aClips.back(), |
| basegfx::B2DPoint(rPoint.X(), rPoint.Y()))) |
| { |
| // when not inside, do not add original |
| bDone = true; |
| } |
| break; |
| } |
| |
| case META_POINT_ACTION : |
| { |
| const MetaPointAction* pA = static_cast< const MetaPointAction* >(pAction); |
| const Point& rPoint = pA->GetPoint(); |
| |
| if(!basegfx::tools::isInside( |
| aClips.back(), |
| basegfx::B2DPoint(rPoint.X(), rPoint.Y()))) |
| { |
| // when not inside, do not add original |
| bDone = true; |
| } |
| break; |
| } |
| |
| // |
| // geometry actions |
| // |
| case META_LINE_ACTION : |
| { |
| const MetaLineAction* pA = static_cast< const MetaLineAction* >(pAction); |
| const Point& rStart(pA->GetStartPoint()); |
| const Point& rEnd(pA->GetEndPoint()); |
| basegfx::B2DPolygon aLine; |
| |
| aLine.append(basegfx::B2DPoint(rStart.X(), rStart.Y())); |
| aLine.append(basegfx::B2DPoint(rEnd.X(), rEnd.Y())); |
| |
| bDone = handleGeometricContent( |
| aClips.back(), |
| basegfx::B2DPolyPolygon(aLine), |
| aTarget, |
| true); // stroke |
| break; |
| } |
| |
| case META_RECT_ACTION : |
| { |
| const MetaRectAction* pA = static_cast< const MetaRectAction* >(pAction); |
| const Rectangle& rRect = pA->GetRect(); |
| |
| if(rRect.IsEmpty()) |
| { |
| bDone = true; |
| } |
| else |
| { |
| |
| bDone = handleGeometricContent( |
| aClips.back(), |
| basegfx::B2DPolyPolygon( |
| basegfx::tools::createPolygonFromRect( |
| basegfx::B2DRange( |
| rRect.Left(), rRect.Top(), |
| rRect.Right(), rRect.Bottom()))), |
| aTarget, |
| false); // stroke |
| } |
| break; |
| } |
| |
| case META_ROUNDRECT_ACTION : |
| { |
| const MetaRoundRectAction* pA = static_cast< const MetaRoundRectAction* >(pAction); |
| const Rectangle& rRect = pA->GetRect(); |
| |
| if(rRect.IsEmpty()) |
| { |
| bDone = true; |
| } |
| else |
| { |
| const sal_uInt32 nHor(pA->GetHorzRound()); |
| const sal_uInt32 nVer(pA->GetVertRound()); |
| const basegfx::B2DRange aRange(rRect.Left(), rRect.Top(), rRect.Right(), rRect.Bottom()); |
| basegfx::B2DPolygon aOutline; |
| |
| if(nHor || nVer) |
| { |
| double fRadiusX((nHor * 2.0) / (aRange.getWidth() > 0.0 ? aRange.getWidth() : 1.0)); |
| double fRadiusY((nVer * 2.0) / (aRange.getHeight() > 0.0 ? aRange.getHeight() : 1.0)); |
| fRadiusX = std::max(0.0, std::min(1.0, fRadiusX)); |
| fRadiusY = std::max(0.0, std::min(1.0, fRadiusY)); |
| |
| aOutline = basegfx::tools::createPolygonFromRect(aRange, fRadiusX, fRadiusY); |
| } |
| else |
| { |
| aOutline = basegfx::tools::createPolygonFromRect(aRange); |
| } |
| |
| bDone = handleGeometricContent( |
| aClips.back(), |
| basegfx::B2DPolyPolygon(aOutline), |
| aTarget, |
| false); // stroke |
| } |
| break; |
| } |
| |
| case META_ELLIPSE_ACTION : |
| { |
| const MetaEllipseAction* pA = static_cast< const MetaEllipseAction* >(pAction); |
| const Rectangle& rRect = pA->GetRect(); |
| |
| if(rRect.IsEmpty()) |
| { |
| bDone = true; |
| } |
| else |
| { |
| const basegfx::B2DRange aRange(rRect.Left(), rRect.Top(), rRect.Right(), rRect.Bottom()); |
| |
| bDone = handleGeometricContent( |
| aClips.back(), |
| basegfx::B2DPolyPolygon( |
| basegfx::tools::createPolygonFromEllipse( |
| aRange.getCenter(), |
| aRange.getWidth() * 0.5, |
| aRange.getHeight() * 0.5)), |
| aTarget, |
| false); // stroke |
| } |
| break; |
| } |
| |
| case META_ARC_ACTION : |
| { |
| const MetaArcAction* pA = static_cast< const MetaArcAction* >(pAction); |
| const Rectangle& rRect = pA->GetRect(); |
| |
| if(rRect.IsEmpty()) |
| { |
| bDone = true; |
| } |
| else |
| { |
| const Polygon aToolsPoly( |
| rRect, |
| pA->GetStartPoint(), |
| pA->GetEndPoint(), |
| POLY_ARC); |
| |
| bDone = handleGeometricContent( |
| aClips.back(), |
| basegfx::B2DPolyPolygon(aToolsPoly.getB2DPolygon()), |
| aTarget, |
| true); // stroke |
| } |
| break; |
| } |
| |
| case META_PIE_ACTION : |
| { |
| const MetaPieAction* pA = static_cast< const MetaPieAction* >(pAction); |
| const Rectangle& rRect = pA->GetRect(); |
| |
| if(rRect.IsEmpty()) |
| { |
| bDone = true; |
| } |
| else |
| { |
| const Polygon aToolsPoly( |
| rRect, |
| pA->GetStartPoint(), |
| pA->GetEndPoint(), |
| POLY_PIE); |
| |
| bDone = handleGeometricContent( |
| aClips.back(), |
| basegfx::B2DPolyPolygon(aToolsPoly.getB2DPolygon()), |
| aTarget, |
| false); // stroke |
| } |
| break; |
| } |
| |
| case META_CHORD_ACTION : |
| { |
| const MetaChordAction* pA = static_cast< const MetaChordAction* >(pAction); |
| const Rectangle& rRect = pA->GetRect(); |
| |
| if(rRect.IsEmpty()) |
| { |
| bDone = true; |
| } |
| else |
| { |
| const Polygon aToolsPoly( |
| rRect, |
| pA->GetStartPoint(), |
| pA->GetEndPoint(), |
| POLY_CHORD); |
| |
| bDone = handleGeometricContent( |
| aClips.back(), |
| basegfx::B2DPolyPolygon(aToolsPoly.getB2DPolygon()), |
| aTarget, |
| false); // stroke |
| } |
| break; |
| } |
| |
| case META_POLYLINE_ACTION : |
| { |
| const MetaPolyLineAction* pA = static_cast< const MetaPolyLineAction* >(pAction); |
| |
| bDone = handleGeometricContent( |
| aClips.back(), |
| basegfx::B2DPolyPolygon(pA->GetPolygon().getB2DPolygon()), |
| aTarget, |
| true); // stroke |
| break; |
| } |
| |
| case META_POLYGON_ACTION : |
| { |
| const MetaPolygonAction* pA = static_cast< const MetaPolygonAction* >(pAction); |
| |
| bDone = handleGeometricContent( |
| aClips.back(), |
| basegfx::B2DPolyPolygon(pA->GetPolygon().getB2DPolygon()), |
| aTarget, |
| false); // stroke |
| break; |
| } |
| |
| case META_POLYPOLYGON_ACTION : |
| { |
| const MetaPolyPolygonAction* pA = static_cast< const MetaPolyPolygonAction* >(pAction); |
| const PolyPolygon& rPoly = pA->GetPolyPolygon(); |
| |
| bDone = handleGeometricContent( |
| aClips.back(), |
| rPoly.getB2DPolyPolygon(), |
| aTarget, |
| false); // stroke |
| break; |
| } |
| |
| // |
| // bitmap actions, create BitmapEx with alpha channel derived |
| // from clipping |
| // |
| case META_BMPEX_ACTION : |
| { |
| const MetaBmpExAction* pA = static_cast< const MetaBmpExAction* >(pAction); |
| const BitmapEx& rBitmapEx = pA->GetBitmapEx(); |
| |
| // the logical size depends on the PrefSize of the given bitmap in |
| // combination with the current MapMode |
| Size aLogicalSize(rBitmapEx.GetPrefSize()); |
| |
| if(MAP_PIXEL == rBitmapEx.GetPrefMapMode().GetMapUnit()) |
| { |
| aLogicalSize = Application::GetDefaultDevice()->PixelToLogic(aLogicalSize, aMapModes.back().GetMapUnit()); |
| } |
| else |
| { |
| aLogicalSize = OutputDevice::LogicToLogic(aLogicalSize, rBitmapEx.GetPrefMapMode(), aMapModes.back().GetMapUnit()); |
| } |
| |
| bDone = handleBitmapContent( |
| aClips.back(), |
| pA->GetPoint(), |
| aLogicalSize, |
| rBitmapEx, |
| aTarget); |
| break; |
| } |
| |
| case META_BMP_ACTION : |
| { |
| const MetaBmpAction* pA = static_cast< const MetaBmpAction* >(pAction); |
| const Bitmap& rBitmap = pA->GetBitmap(); |
| |
| // the logical size depends on the PrefSize of the given bitmap in |
| // combination with the current MapMode |
| Size aLogicalSize(rBitmap.GetPrefSize()); |
| |
| if(MAP_PIXEL == rBitmap.GetPrefMapMode().GetMapUnit()) |
| { |
| aLogicalSize = Application::GetDefaultDevice()->PixelToLogic(aLogicalSize, aMapModes.back().GetMapUnit()); |
| } |
| else |
| { |
| aLogicalSize = OutputDevice::LogicToLogic(aLogicalSize, rBitmap.GetPrefMapMode(), aMapModes.back().GetMapUnit()); |
| } |
| |
| bDone = handleBitmapContent( |
| aClips.back(), |
| pA->GetPoint(), |
| aLogicalSize, |
| BitmapEx(rBitmap), |
| aTarget); |
| break; |
| } |
| |
| case META_BMPEXSCALE_ACTION : |
| { |
| const MetaBmpExScaleAction* pA = static_cast< const MetaBmpExScaleAction* >(pAction); |
| |
| bDone = handleBitmapContent( |
| aClips.back(), |
| pA->GetPoint(), |
| pA->GetSize(), |
| pA->GetBitmapEx(), |
| aTarget); |
| break; |
| } |
| |
| case META_BMPSCALE_ACTION : |
| { |
| const MetaBmpScaleAction* pA = static_cast< const MetaBmpScaleAction* >(pAction); |
| |
| bDone = handleBitmapContent( |
| aClips.back(), |
| pA->GetPoint(), |
| pA->GetSize(), |
| BitmapEx(pA->GetBitmap()), |
| aTarget); |
| break; |
| } |
| |
| case META_BMPEXSCALEPART_ACTION : |
| { |
| const MetaBmpExScalePartAction* pA = static_cast< const MetaBmpExScalePartAction* >(pAction); |
| const BitmapEx& rBitmapEx = pA->GetBitmapEx(); |
| |
| if(rBitmapEx.IsEmpty()) |
| { |
| // empty content |
| bDone = true; |
| } |
| else |
| { |
| BitmapEx aCroppedBitmapEx(rBitmapEx); |
| const Rectangle aCropRectangle(pA->GetSrcPoint(), pA->GetSrcSize()); |
| |
| if(aCropRectangle.IsEmpty()) |
| { |
| // empty content |
| bDone = true; |
| } |
| else |
| { |
| aCroppedBitmapEx.Crop(aCropRectangle); |
| bDone = handleBitmapContent( |
| aClips.back(), |
| pA->GetDestPoint(), |
| pA->GetDestSize(), |
| aCroppedBitmapEx, |
| aTarget); |
| } |
| } |
| break; |
| } |
| |
| case META_BMPSCALEPART_ACTION : |
| { |
| const MetaBmpScalePartAction* pA = static_cast< const MetaBmpScalePartAction* >(pAction); |
| const Bitmap& rBitmap = pA->GetBitmap(); |
| |
| if(rBitmap.IsEmpty()) |
| { |
| // empty content |
| bDone = true; |
| } |
| else |
| { |
| Bitmap aCroppedBitmap(rBitmap); |
| const Rectangle aCropRectangle(pA->GetSrcPoint(), pA->GetSrcSize()); |
| |
| if(aCropRectangle.IsEmpty()) |
| { |
| // empty content |
| bDone = true; |
| } |
| else |
| { |
| aCroppedBitmap.Crop(aCropRectangle); |
| bDone = handleBitmapContent( |
| aClips.back(), |
| pA->GetDestPoint(), |
| pA->GetDestSize(), |
| BitmapEx(aCroppedBitmap), |
| aTarget); |
| } |
| } |
| break; |
| } |
| |
| // |
| // need to handle all those 'hacks' which hide data in comments |
| // |
| case META_COMMENT_ACTION : |
| { |
| const MetaCommentAction* pA = static_cast< const MetaCommentAction* >(pAction); |
| const ByteString& rComment = pA->GetComment(); |
| |
| if(COMPARE_EQUAL == rComment.CompareIgnoreCaseToAscii("XGRAD_SEQ_BEGIN")) |
| { |
| // nothing to do; this just means that between here and XGRAD_SEQ_END |
| // exists a META_GRADIENTEX_ACTION mixed with Xor-tricked painiting |
| // commands. This comment is used to scan over these and filter for |
| // the gradient action. It is needed to support META_GRADIENTEX_ACTION |
| // in this processor to solve usages. |
| } |
| else if(COMPARE_EQUAL == rComment.CompareIgnoreCaseToAscii("XPATHFILL_SEQ_BEGIN")) |
| { |
| SvtGraphicFill aFilling; |
| PolyPolygon aPath; |
| |
| { // read SvtGraphicFill |
| SvMemoryStream aMemStm((void*)pA->GetData(), pA->GetDataSize(),STREAM_READ); |
| aMemStm >> aFilling; |
| } |
| |
| aFilling.getPath(aPath); |
| |
| if(aPath.Count()) |
| { |
| const basegfx::B2DPolyPolygon aSource(aPath.getB2DPolyPolygon()); |
| const basegfx::B2DPolyPolygon aResult( |
| basegfx::tools::clipPolyPolygonOnPolyPolygon( |
| aSource, |
| aClips.back(), |
| true, // inside |
| false)); // stroke |
| |
| if(aResult.count()) |
| { |
| if(aResult != aSource) |
| { |
| // add clipped geometry |
| aFilling.setPath(PolyPolygon(aResult)); |
| addSvtGraphicFill(aFilling, aTarget); |
| bDone = true; |
| } |
| } |
| else |
| { |
| // exchange with empty polygon |
| aFilling.setPath(PolyPolygon()); |
| addSvtGraphicFill(aFilling, aTarget); |
| bDone = true; |
| } |
| } |
| } |
| else if(COMPARE_EQUAL == rComment.CompareIgnoreCaseToAscii("XPATHSTROKE_SEQ_BEGIN")) |
| { |
| SvtGraphicStroke aStroke; |
| Polygon aPath; |
| |
| { // read SvtGraphicFill |
| SvMemoryStream aMemStm((void*)pA->GetData(), pA->GetDataSize(),STREAM_READ); |
| aMemStm >> aStroke; |
| } |
| |
| aStroke.getPath(aPath); |
| |
| if(aPath.GetSize()) |
| { |
| const basegfx::B2DPolygon aSource(aPath.getB2DPolygon()); |
| const basegfx::B2DPolyPolygon aResult( |
| basegfx::tools::clipPolygonOnPolyPolygon( |
| aSource, |
| aClips.back(), |
| true, // inside |
| true)); // stroke |
| |
| if(aResult.count()) |
| { |
| if(aResult.count() > 1 || aResult.getB2DPolygon(0) != aSource) |
| { |
| // add clipped geometry |
| for(sal_uInt32 a(0); a < aResult.count(); a++) |
| { |
| aStroke.setPath(Polygon(aResult.getB2DPolygon(a))); |
| addSvtGraphicStroke(aStroke, aTarget); |
| } |
| |
| bDone = true; |
| } |
| } |
| else |
| { |
| // exchange with empty polygon |
| aStroke.setPath(Polygon()); |
| addSvtGraphicStroke(aStroke, aTarget); |
| bDone = true; |
| } |
| |
| } |
| } |
| break; |
| } |
| |
| // |
| // need to handle gradient fills (hopefully only unroated ones) |
| // |
| |
| case META_GRADIENT_ACTION : |
| { |
| const MetaGradientAction* pA = static_cast< const MetaGradientAction* >(pAction); |
| const Rectangle& rRect = pA->GetRect(); |
| |
| if(rRect.IsEmpty()) |
| { |
| bDone = true; |
| } |
| else |
| { |
| bDone = handleGradientContent( |
| aClips.back(), |
| basegfx::B2DPolyPolygon( |
| basegfx::tools::createPolygonFromRect( |
| basegfx::B2DRange( |
| rRect.Left(), rRect.Top(), |
| rRect.Right(), rRect.Bottom()))), |
| pA->GetGradient(), |
| aTarget); |
| } |
| |
| |
| break; |
| } |
| |
| case META_GRADIENTEX_ACTION : |
| { |
| const MetaGradientExAction* pA = static_cast< const MetaGradientExAction* >(pAction); |
| const PolyPolygon& rPolyPoly = pA->GetPolyPolygon(); |
| |
| bDone = handleGradientContent( |
| aClips.back(), |
| rPolyPoly.getB2DPolyPolygon(), |
| pA->GetGradient(), |
| aTarget); |
| break; |
| } |
| |
| // not (yet) supported actions |
| // |
| // META_NULL_ACTION |
| // META_TEXT_ACTION |
| // META_TEXTARRAY_ACTION |
| // META_STRETCHTEXT_ACTION |
| // META_TEXTRECT_ACTION |
| // META_MASK_ACTION |
| // META_MASKSCALE_ACTION |
| // META_MASKSCALEPART_ACTION |
| // META_HATCH_ACTION |
| // META_WALLPAPER_ACTION |
| // META_FILLCOLOR_ACTION |
| // META_TEXTCOLOR_ACTION |
| // META_TEXTFILLCOLOR_ACTION |
| // META_TEXTALIGN_ACTION |
| // META_MAPMODE_ACTION |
| // META_FONT_ACTION |
| // META_TRANSPARENT_ACTION |
| // META_EPS_ACTION |
| // META_REFPOINT_ACTION |
| // META_TEXTLINECOLOR_ACTION |
| // META_TEXTLINE_ACTION |
| // META_FLOATTRANSPARENT_ACTION |
| // META_LAYOUTMODE_ACTION |
| // META_TEXTLANGUAGE_ACTION |
| // META_OVERLINECOLOR_ACTION |
| |
| // if an action is not handled at all, it will simply get copied to the |
| // target (see below). This is the default for all non-implemented actions |
| default: |
| { |
| break; |
| } |
| } |
| } |
| |
| if(bDone) |
| { |
| bChanged = true; |
| } |
| else |
| { |
| const_cast< MetaAction* >(pAction)->Duplicate(); |
| aTarget.AddAction(const_cast< MetaAction* >(pAction)); |
| } |
| } |
| |
| if(bChanged) |
| { |
| // when changed, copy back and do not forget to set MapMode |
| // and PrefSize |
| aTarget.SetPrefMapMode(rSource.GetPrefMapMode()); |
| aTarget.SetPrefSize(rSource.GetPrefSize()); |
| rSource = aTarget; |
| } |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| |
| bool VCL_DLLPUBLIC usesClipActions(const GDIMetaFile& rSource) |
| { |
| const sal_uLong nObjCount(rSource.GetActionCount()); |
| |
| for(sal_uLong i(0); i < nObjCount; ++i) |
| { |
| const MetaAction* pAction(rSource.GetAction(i)); |
| const sal_uInt16 nType(pAction->GetType()); |
| |
| switch(nType) |
| { |
| case META_CLIPREGION_ACTION : |
| case META_ISECTRECTCLIPREGION_ACTION : |
| case META_ISECTREGIONCLIPREGION_ACTION : |
| case META_MOVECLIPREGION_ACTION : |
| { |
| return true; |
| break; |
| } |
| |
| default: break; |
| } |
| } |
| |
| return false; |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| // eof |
