| Quellcodebibliothek Statistik Leitseite products/Sources/formale Sprachen/C/LibreOffice/drawinglayer/source/tools/ (Office von Apache Version 25.8.3.2©) Datei vom 5.10.2025 mit Größe 130 kB |
|
Quelle wmfemfhelper.cxxSprache: C |
|||||||||||||||
|
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ /* * This file is part of the LibreOffice project. * * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. * * This file incorporates work covered by the following license notice: * * 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 . */ #include <wmfemfhelper.hxx> #include <drawinglayer/primitive2d/pointarrayprimitive2d.hxx> #include <vcl/lineinfo.hxx> #include <vcl/metaact.hxx> #include <drawinglayer/primitive2d/transformprimitive2d.hxx> #include <basegfx/matrix/b2dhommatrixtools.hxx> #include <basegfx/utils/gradienttools.hxx> #include <drawinglayer/primitive2d/unifiedtransparenceprimitive2d.hxx> #include <drawinglayer/primitive2d/PolygonStrokePrimitive2D.hxx> #include <drawinglayer/primitive2d/PolygonHairlinePrimitive2D.hxx> #include <drawinglayer/primitive2d/PolyPolygonColorPrimitive2D.hxx> #include <drawinglayer/primitive2d/PolyPolygonGradientPrimitive2D.hxx> #include <basegfx/polygon/b2dpolygontools.hxx> #include <drawinglayer/primitive2d/discretebitmapprimitive2d.hxx> #include <drawinglayer/primitive2d/bitmapprimitive2d.hxx> #include <vcl/BitmapPalette.hxx> #include <drawinglayer/primitive2d/fillgradientprimitive2d.hxx> #include <drawinglayer/primitive2d/transparenceprimitive2d.hxx> #include <drawinglayer/primitive2d/fillhatchprimitive2d.hxx> #include <drawinglayer/primitive2d/maskprimitive2d.hxx> #include <basegfx/polygon/b2dpolygonclipper.hxx> #include <drawinglayer/primitive2d/invertprimitive2d.hxx> #include <drawinglayer/primitive2d/modifiedcolorprimitive2d.hxx> #include <primitive2d/wallpaperprimitive2d.hxx> #include <drawinglayer/primitive2d/textlayoutdevice.hxx> #include <drawinglayer/primitive2d/textdecoratedprimitive2d.hxx> #include <primitive2d/textlineprimitive2d.hxx> #include <primitive2d/textstrikeoutprimitive2d.hxx> #include <drawinglayer/primitive2d/epsprimitive2d.hxx> #include <sal/log.hxx> #include <tools/fract.hxx> #include <tools/stream.hxx> #include <tools/UnitConversion.hxx> #include <vcl/canvastools.hxx> #include <vcl/gradient.hxx> #include <vcl/hatch.hxx> #include <vcl/outdev.hxx> #include <i18nlangtag/languagetag.hxx> #include <emfplushelper.hxx> #include <numeric> #include <toolkit/helper/vclunohelper.hxx> namespace drawinglayer::primitive2d { namespace { /** NonOverlappingFillGradientPrimitive2D class This is a special version of the FillGradientPrimitive2D which decomposes to a non-overlapping geometry version of the gradient. This needs to be used to support the old XOR paint-'trick'. It does not need an own identifier since a renderer who wants to interpret it itself may do so. It just overrides the decomposition of the C++ implementation class to do an alternative decomposition. */ class NonOverlappingFillGradientPrimitive2D : public FillGradientPrimitive2D { protected: /// local decomposition. virtual Primitive2DReference create2DDecomposition( const geometry::ViewInformation2D& rViewInformation) const override; public: /// constructor NonOverlappingFillGradientPrimitive2D( const basegfx::B2DRange& rObjectRange, const attribute::FillGradientAttribute& rFillGradient) : FillGradientPrimitive2D(rObjectRange, rFillGradient) { } }; } Primitive2DReference NonOverlappingFillGradientPrimitive2D::create2DDecomposition const geometry::ViewInformation2D& /*rViewInformation*/) const { if (!getFillGradient().isDefault()) { return createFill(false); } return nullptr; } } // end of namespace namespace wmfemfhelper { /** helper class for graphic context This class allows to hold a complete representation of classic VCL OutputDevice state. This data is needed for correct interpretation of the MetaFile action flow. */ PropertyHolder::PropertyHolder() : maMapUnit(MapUnit::Map100thMM), maTextColor(sal_uInt32(COL_BLACK)), maRasterOp(RasterOp::OverPaint), mnLayoutMode(vcl::text::ComplexTextLayoutFlags::Default), maLanguageType(0), mnPushFlags(vcl::PushFlags::NONE), mbLineColor(false), mbFillColor(false), mbTextColor(true), mbTextFillColor(false), mbTextLineColor(false), mbOverlineColor(false), mbClipPolyPolygonActive(false) { } } namespace wmfemfhelper { /** stack for properties This class builds a stack based on the PropertyHolder class. It encapsulates the pointer/new/delete usage to make it safe and implements the push/pop as needed by a VCL Metafile interpreter. The critical part here are the flag values VCL OutputDevice uses here; not all stuff is pushed and thus needs to be copied at pop. */ PropertyHolders::PropertyHolders() { maPropertyHolders.push_back(new PropertyHolder()); } void PropertyHolders::PushDefault() { PropertyHolder* pNew = new PropertyHolder(); maPropertyHolders.push_back(pNew); } void PropertyHolders::Push(vcl::PushFlags nPushFlags) { if (bool(nPushFlags)) { OSL_ENSURE(maPropertyHolders.size(), "PropertyHolders: PUSH with no property holders (! if (!maPropertyHolders.empty()) { PropertyHolder* pNew = new PropertyHolder(*maPropertyHolders.back()); pNew->setPushFlags(nPushFlags); maPropertyHolders.push_back(pNew); } } } void PropertyHolders::Pop() { OSL_ENSURE(maPropertyHolders.size(), "PropertyHolders: POP with no property holders (!) const sal_uInt32 nSize(maPropertyHolders.size()); if (!nSize) return; const PropertyHolder* pTip = maPropertyHolders.back(); const vcl::PushFlags nPushFlags(pTip->getPushFlags()); if (nPushFlags != vcl::PushFlags::NONE) { if (nSize > 1) { // copy back content for all non-set flags PropertyHolder* pLast = maPropertyHolders[nSize - 2]; if (vcl::PushFlags::ALL != nPushFlags) { if (!(nPushFlags & vcl::PushFlags::LINECOLOR)) { pLast->setLineColor(pTip->getLineColor()); pLast->setLineColorActive(pTip->getLineColorActive()); } if (!(nPushFlags & vcl::PushFlags::FILLCOLOR)) { pLast->setFillColor(pTip->getFillColor()); pLast->setFillColorActive(pTip->getFillColorActive()); } if (!(nPushFlags & vcl::PushFlags::FONT)) { pLast->setFont(pTip->getFont()); } if (!(nPushFlags & vcl::PushFlags::TEXTCOLOR)) { pLast->setTextColor(pTip->getTextColor()); pLast->setTextColorActive(pTip->getTextColorActive()); } if (!(nPushFlags & vcl::PushFlags::MAPMODE)) { pLast->setTransformation(pTip->getTransformation()); pLast->setMapUnit(pTip->getMapUnit()); } if (!(nPushFlags & vcl::PushFlags::CLIPREGION)) { pLast->setClipPolyPolygon(pTip->getClipPolyPolygon()); pLast->setClipPolyPolygonActive(pTip->getClipPolyPolygonActive()); } if (!(nPushFlags & vcl::PushFlags::RASTEROP)) { pLast->setRasterOp(pTip->getRasterOp()); } if (!(nPushFlags & vcl::PushFlags::TEXTFILLCOLOR)) { pLast->setTextFillColor(pTip->getTextFillColor()); pLast->setTextFillColorActive(pTip->getTextFillColorActive()); } if (!(nPushFlags & vcl::PushFlags::TEXTALIGN)) { if (pLast->getFont().GetAlignment() != pTip->getFont().GetAlignment()) { vcl::Font aFont(pLast->getFont()); aFont.SetAlignment(pTip->getFont().GetAlignment()); pLast->setFont(aFont); } } if (!(nPushFlags & vcl::PushFlags::REFPOINT)) { // not supported } if (!(nPushFlags & vcl::PushFlags::TEXTLINECOLOR)) { pLast->setTextLineColor(pTip->getTextLineColor()); pLast->setTextLineColorActive(pTip->getTextLineColorActive()); } if (!(nPushFlags & vcl::PushFlags::TEXTLAYOUTMODE)) { pLast->setLayoutMode(pTip->getLayoutMode()); } if (!(nPushFlags & vcl::PushFlags::TEXTLANGUAGE)) { pLast->setLanguageType(pTip->getLanguageType()); } if (!(nPushFlags & vcl::PushFlags::OVERLINECOLOR)) { pLast->setOverlineColor(pTip->getOverlineColor()); pLast->setOverlineColorActive(pTip->getOverlineColorActive()); } } } } // execute the pop delete maPropertyHolders.back(); maPropertyHolders.pop_back(); } PropertyHolder& PropertyHolders::Current() { static PropertyHolder aDummy; OSL_ENSURE(maPropertyHolders.size(), "PropertyHolders: CURRENT with no property holder return maPropertyHolders.empty() ? aDummy : *maPropertyHolders.back(); } PropertyHolders::~PropertyHolders() { while (!maPropertyHolders.empty()) { delete maPropertyHolders.back(); maPropertyHolders.pop_back(); } } } namespace { /** helper to convert a vcl::Region to a B2DPolyPolygon when it does not yet contain one. In the future this may be expanded to merge the polygons created from rectangles or use a special algo to directly turn the spans of regions to a single, already merged PolyPolygon. */ basegfx::B2DPolyPolygon getB2DPolyPolygonFromRegion(const vcl::Region& rRegion) { basegfx::B2DPolyPolygon aRetval; if (!rRegion.IsEmpty()) { aRetval = rRegion.GetAsB2DPolyPolygon(); } return aRetval; } } namespace wmfemfhelper { /** Helper class to buffer and hold a Primitive target vector. It encapsulates the new/delete functionality and allows to work on pointers of the implementation classes. All data will be converted to uno sequences of uno references when accessing the data. */ TargetHolder::TargetHolder() { } TargetHolder::~TargetHolder() { } sal_uInt32 TargetHolder::size() const { return aTargets.size(); } void TargetHolder::append(drawinglayer::primitive2d::BasePrimitive2D* pCandidate) { if (pCandidate) { aTargets.push_back(pCandidate); } } drawinglayer::primitive2d::Primitive2DContainer TargetHolder::getPrimitive2DSeque { drawinglayer::primitive2d::Primitive2DContainer xRetval = std::move(aTargets); if (!xRetval.empty() && rPropertyHolder.getClipPolyPolygonActive()) { const basegfx::B2DPolyPolygon& rClipPolyPolygon = rPropertyHolder.getClipPolyPol if (rClipPolyPolygon.count()) { xRetval = drawinglayer::primitive2d::Primitive2DContainer{ new drawinglayer::primitive2d::MaskPrimitive2D( rClipPolyPolygon, std::move(xRetval)) }; } } return xRetval; } } namespace wmfemfhelper { /** Helper class which builds a stack on the TargetHolder class */ TargetHolders::TargetHolders() { maTargetHolders.push_back(new TargetHolder()); } sal_uInt32 TargetHolders::size() const { return maTargetHolders.size(); } void TargetHolders::Push() { maTargetHolders.push_back(new TargetHolder()); } void TargetHolders::Pop() { OSL_ENSURE(maTargetHolders.size(), "TargetHolders: POP with no property holders (!)"); if (!maTargetHolders.empty()) { delete maTargetHolders.back(); maTargetHolders.pop_back(); } } TargetHolder& TargetHolders::Current() { static TargetHolder aDummy; OSL_ENSURE(maTargetHolders.size(), "TargetHolders: CURRENT with no property holders (!) return maTargetHolders.empty() ? aDummy : *maTargetHolders.back(); } TargetHolders::~TargetHolders() { while (!maTargetHolders.empty()) { delete maTargetHolders.back(); maTargetHolders.pop_back(); } } } namespace { /** helper to convert a MapMode to a transformation */ basegfx::B2DHomMatrix getTransformFromMapMode(const MapMode& rMapMode) { basegfx::B2DHomMatrix aMapping; const Fraction aNoScale(1, 1); const Point& rOrigin(rMapMode.GetOrigin()); if(0 != rOrigin.X() || 0 != rOrigin.Y()) { aMapping.translate(rOrigin.X(), rOrigin.Y()); } if(rMapMode.GetScaleX() != aNoScale || rMapMode.GetScaleY() != aNoScale) { aMapping.scale( double(rMapMode.GetScaleX()), double(rMapMode.GetScaleY())); } return aMapping; } } namespace wmfemfhelper { /** helper to create a PointArrayPrimitive2D based on current context */ static void createPointArrayPrimitive( std::vector< basegfx::B2DPoint >&& rPositions, TargetHolder& rTarget, PropertyHolder const & rProperties, const basegfx::BColor& rBColor) { if(rPositions.empty()) return; if(rProperties.getTransformation().isIdentity()) { rTarget.append( new drawinglayer::primitive2d::PointArrayPrimitive2D( std::move(rPositions), rBColor)); } else { for(basegfx::B2DPoint & aPosition : rPositions) { aPosition = rProperties.getTransformation() * aPosition; } rTarget.append( new drawinglayer::primitive2d::PointArrayPrimitive2D( std::move(rPositions), rBColor)); } } /** helper to create a PolygonHairlinePrimitive2D based on current context */ static void createHairlinePrimitive( const basegfx::B2DPolygon& rLinePolygon, TargetHolder& rTarget, PropertyHolder const & rProperties) { if(rLinePolygon.count()) { basegfx::B2DPolygon aLinePolygon(rLinePolygon); aLinePolygon.transform(rProperties.getTransformation()); rTarget.append( new drawinglayer::primitive2d::PolygonHairlinePrimitive2D( std::move(aLinePolygon), rProperties.getLineColor())); } } /** helper to create a PolyPolygonColorPrimitive2D based on current context */ static void createFillPrimitive( const basegfx::B2DPolyPolygon& rFillPolyPolygon, TargetHolder& rTarget, PropertyHolder const & rProperties) { if(rFillPolyPolygon.count()) { basegfx::B2DPolyPolygon aFillPolyPolygon(rFillPolyPolygon); aFillPolyPolygon.transform(rProperties.getTransformation()); rTarget.append( new drawinglayer::primitive2d::PolyPolygonColorPrimitive2D( std::move(aFillPolyPolygon), rProperties.getFillColor())); } } /** helper to create a PolygonStrokePrimitive2D based on current context */ static void createLinePrimitive( const basegfx::B2DPolygon& rLinePolygon, const LineInfo& rLineInfo, TargetHolder& rTarget, PropertyHolder const & rProperties) { if(!rLinePolygon.count()) return; const bool bDashDotUsed(LineStyle::Dash == rLineInfo.GetStyle()); const bool bWidthUsed(rLineInfo.GetWidth() > 1); if(bDashDotUsed || bWidthUsed) { basegfx::B2DPolygon aLinePolygon(rLinePolygon); aLinePolygon.transform(rProperties.getTransformation()); drawinglayer::attribute::LineAttribute aLineAttribute( rProperties.getLineColor(), bWidthUsed ? rLineInfo.GetWidth() : 0.0, rLineInfo.GetLineJoin(), rLineInfo.GetLineCap()); if(bDashDotUsed) { std::vector< double > fDotDashArray = rLineInfo.GetDotDashArray(); const double fAccumulated(std::accumulate(fDotDashArray.begin(), fDotDashArray.end( drawinglayer::attribute::StrokeAttribute aStrokeAttribute( std::move(fDotDashArray), fAccumulated); rTarget.append( new drawinglayer::primitive2d::PolygonStrokePrimitive2D( std::move(aLinePolygon), std::move(aLineAttribute), std::move(aStrokeAttribute))); } else { rTarget.append( new drawinglayer::primitive2d::PolygonStrokePrimitive2D( std::move(aLinePolygon), aLineAttribute)); } } else { createHairlinePrimitive(rLinePolygon, rTarget, rProperties); } } /** helper to create needed line and fill primitives based on current context */ static void createHairlineAndFillPrimitive( const basegfx::B2DPolygon& rPolygon, TargetHolder& rTarget, PropertyHolder const & rProperties) { if(rProperties.getFillColorActive()) { createFillPrimitive(basegfx::B2DPolyPolygon(rPolygon), rTarget, rProperties); } if(rProperties.getLineColorActive()) { createHairlinePrimitive(rPolygon, rTarget, rProperties); } } /** helper to create needed line and fill primitives based on current context */ static void createHairlineAndFillPrimitive( const basegfx::B2DPolyPolygon& rPolyPolygon, TargetHolder& rTarget, PropertyHolder const & rProperties) { if(rProperties.getFillColorActive()) { createFillPrimitive(rPolyPolygon, rTarget, rProperties); } if(rProperties.getLineColorActive()) { for(sal_uInt32 a(0); a < rPolyPolygon.count(); a++) { createHairlinePrimitive(rPolyPolygon.getB2DPolygon(a), rTarget, rProperties); } } } /** helper to create DiscreteBitmapPrimitive2D based on current context. The DiscreteBitmapPrimitive2D is especially created for this usage since no other usage defines a bitmap visualisation based on top-left position and size in pixels. At the end it will create a view-dependent transformed embedding of a BitmapPrimitive2D. */ static void createBitmapExPrimitive( const BitmapEx& rBitmapEx, const Point& rPoint, TargetHolder& rTarget, PropertyHolder const & rProperties) { if(!rBitmapEx.IsEmpty()) { basegfx::B2DPoint aPoint(rPoint.X(), rPoint.Y()); aPoint = rProperties.getTransformation() * aPoint; rTarget.append( new drawinglayer::primitive2d::DiscreteBitmapPrimitive2D( rBitmapEx, aPoint)); } } /** helper to create BitmapPrimitive2D based on current context */ static void createBitmapExPrimitive( const BitmapEx& rBitmapEx, const Point& rPoint, const Size& rSize, TargetHolder& rTarget, PropertyHolder const & rProperties) { if(rBitmapEx.IsEmpty()) return; basegfx::B2DHomMatrix aObjectTransform; aObjectTransform.set(0, 0, rSize.Width()); aObjectTransform.set(1, 1, rSize.Height()); aObjectTransform.set(0, 2, rPoint.X()); aObjectTransform.set(1, 2, rPoint.Y()); aObjectTransform = rProperties.getTransformation() * aObjectTransform; rTarget.append( new drawinglayer::primitive2d::BitmapPrimitive2D( rBitmapEx, aObjectTransform)); } /** helper to create a regular BotmapEx from a MaskAction (definitions which use a bitmap without transparence but define one of the colors as transparent) */ static BitmapEx createMaskBmpEx(const Bitmap& rBitmap, const Color& rMaskColor) { const Color aWhite(COL_WHITE); BitmapPalette aBiLevelPalette { aWhite, rMaskColor }; AlphaMask aMask(rBitmap.CreateAlphaMask(aWhite)); Bitmap aSolid(rBitmap.GetSizePixel(), vcl::PixelFormat::N8_BPP, &aBiLevelPalette); aSolid.Erase(rMaskColor); return BitmapEx(aSolid, aMask); } /** helper to convert from a VCL Gradient definition to the corresponding data for primitive representation */ static drawinglayer::attribute::FillGradientAttribute createFillGradientAttribute( { const Color aStartColor(rGradient.GetStartColor()); const sal_uInt16 nStartIntens(rGradient.GetStartIntensity()); basegfx::BColor aStart(aStartColor.getBColor()); if(nStartIntens != 100) { const basegfx::BColor aBlack; aStart = interpolate(aBlack, aStart, static_cast<double>(nStartIntens) * 0.01); } const Color aEndColor(rGradient.GetEndColor()); const sal_uInt16 nEndIntens(rGradient.GetEndIntensity()); basegfx::BColor aEnd(aEndColor.getBColor()); if(nEndIntens != 100) { const basegfx::BColor aBlack; aEnd = interpolate(aBlack, aEnd, static_cast<double>(nEndIntens) * 0.01); } return drawinglayer::attribute::FillGradientAttribute( rGradient.GetStyle(), static_cast<double>(rGradient.GetBorder()) * 0.01, static_cast<double>(rGradient.GetOfsX()) * 0.01, static_cast<double>(rGradient.GetOfsY()) * 0.01, toRadians(rGradient.GetAngle()), basegfx::BColorStops(aStart, aEnd), rGradient.GetSteps()); } /** helper to convert from a VCL Hatch definition to the corresponding data for primitive representation */ static drawinglayer::attribute::FillHatchAttribute createFillHatchAttribute(const H { drawinglayer::attribute::HatchStyle aHatchStyle(drawinglayer::attribute::HatchSty switch(rHatch.GetStyle()) { default : // case HatchStyle::Single : { aHatchStyle = drawinglayer::attribute::HatchStyle::Single; break; } case HatchStyle::Double : { aHatchStyle = drawinglayer::attribute::HatchStyle::Double; break; } case HatchStyle::Triple : { aHatchStyle = drawinglayer::attribute::HatchStyle::Triple; break; } } return drawinglayer::attribute::FillHatchAttribute( aHatchStyle, static_cast<double>(rHatch.GetDistance()), toRadians(rHatch.GetAngle()), rHatch.GetColor().getBColor(), 3, // same default as VCL, a minimum of three discrete units (pixels) offset false); } /** helper to take needed action on ClipRegion change. This method needs to be called on any vcl::Region change, e.g. at the obvious actions doing this, but also at pop-calls which change the vcl::Region of the current context. It takes care of creating the current embedded context, set the new vcl::Region at the context and possibly prepare a new target for including new geometry into the current region */ void HandleNewClipRegion( const basegfx::B2DPolyPolygon& rClipPolyPolygon, TargetHolders& rTargetHolders, PropertyHolders& rPropertyHolders) { const bool bNewActive(rClipPolyPolygon.count()); // #i108636# The handling of new ClipPolyPolygons was not done as good as possible // in the first version of this interpreter; e.g. when a ClipPolyPolygon was set // initially and then using a lot of push/pop actions, the pop always leads // to setting a 'new' ClipPolyPolygon which indeed is the return to the ClipPolyPolygon // of the properties next on the stack. // This ClipPolyPolygon is identical to the current one, so there is no need to // create a MaskPrimitive2D containing the up-to-now created primitives, but // this was done before. While this does not lead to wrong primitive // representations of the metafile data, it creates unnecessarily expensive // representations. Just detecting when no really 'new' ClipPolyPolygon gets set // solves the problem. if(!rPropertyHolders.Current().getClipPolyPolygonActive() && !bNewActive) { // no active ClipPolyPolygon exchanged by no new one, done return; } if(rPropertyHolders.Current().getClipPolyPolygonActive() && bNewActive) { // active ClipPolyPolygon and new active ClipPolyPolygon if(rPropertyHolders.Current().getClipPolyPolygon() == rClipPolyPolygon) { // new is the same as old, done return; } } // Here the old and the new are definitively different, maybe // old one and/or new one is not active. // Handle deletion of old ClipPolyPolygon. The process evtl. created primitives which // belong to this active ClipPolyPolygon. These need to be embedded to a // MaskPrimitive2D accordingly. if(rPropertyHolders.Current().getClipPolyPolygonActive() && rTargetHolders.size() > 1) { drawinglayer::primitive2d::Primitive2DContainer aSubContent; if(rPropertyHolders.Current().getClipPolyPolygon().count() && rTargetHolders.Current().size()) { aSubContent = rTargetHolders.Current().getPrimitive2DSequence( rPropertyHolders.Current()); } rTargetHolders.Pop(); if(!aSubContent.empty()) { rTargetHolders.Current().append( new drawinglayer::primitive2d::GroupPrimitive2D( std::move(aSubContent))); } } // apply new settings to current properties by setting // the new region now rPropertyHolders.Current().setClipPolyPolygonActive(bNewActive); if(bNewActive) { rPropertyHolders.Current().setClipPolyPolygon(rClipPolyPolygon); // prepare new content holder for new active region rTargetHolders.Push(); } } /** helper to handle the change of RasterOp. It takes care of encapsulating all current geometry to the current RasterOp (if changed) and needs to be called on any RasterOp change. It will also start a new geometry target to embrace to the new RasterOp if a changing RasterOp is used. Currently, RasterOp::Xor and RasterOp::Invert are supported us InvertPrimitive2D, and RasterOp::N0 by using a ModifiedColorPrimitive2D to force to black p */ static void HandleNewRasterOp( RasterOp aRasterOp, TargetHolders& rTargetHolders, PropertyHolders& rPropertyHolders) { // check if currently active if(rPropertyHolders.Current().isRasterOpActive() && rTargetHolders.size() > 1) { drawinglayer::primitive2d::Primitive2DContainer aSubContent; if(rTargetHolders.Current().size()) { aSubContent = rTargetHolders.Current().getPrimitive2DSequence(rPropertyHolders.Cur } rTargetHolders.Pop(); if(!aSubContent.empty()) { if(rPropertyHolders.Current().isRasterOpForceBlack()) { // force content to black rTargetHolders.Current().append( new drawinglayer::primitive2d::ModifiedColorPrimitive2D( std::move(aSubContent), std::make_shared<basegfx::BColorModifier_replace>( basegfx::BColor(0.0, 0.0, 0.0)))); } else // if(rPropertyHolders.Current().isRasterOpInvert()) { // invert content rTargetHolders.Current().append( new drawinglayer::primitive2d::InvertPrimitive2D( std::move(aSubContent))); } } } // apply new settings rPropertyHolders.Current().setRasterOp(aRasterOp); // check if now active if(rPropertyHolders.Current().isRasterOpActive()) { // prepare new content holder for new invert rTargetHolders.Push(); } } /** helper to create needed data to emulate the VCL Wallpaper Metafile action. It is a quite mighty action. This helper is for simple color filled background. */ static rtl::Reference<drawinglayer::primitive2d::BasePrimitive2D> CreateColorWallpap const basegfx::B2DRange& rRange, const basegfx::BColor& rColor, PropertyHolder const & rPropertyHolder) { basegfx::B2DPolygon aOutline(basegfx::utils::createPolygonFromRect(rRange)); aOutline.transform(rPropertyHolder.getTransformation()); return new drawinglayer::primitive2d::PolyPolygonColorPrimitive2D( basegfx::B2DPolyPolygon(aOutline), rColor); } /** helper to create needed data to emulate the VCL Wallpaper Metafile action. It is a quite mighty action. This helper is for gradient filled background. */ static rtl::Reference<drawinglayer::primitive2d::BasePrimitive2D> CreateGradientWall const basegfx::B2DRange& rRange, const Gradient& rGradient, PropertyHolder const & rPropertyHolder) { drawinglayer::attribute::FillGradientAttribute aAttribute(createFillGradientAttri basegfx::BColor aSingleColor; if (aAttribute.getColorStops().isSingleColor(aSingleColor)) { // not really a gradient. Create filled rectangle return CreateColorWallpaper(rRange, aSingleColor, rPropertyHolder); } else { // really a gradient rtl::Reference<drawinglayer::primitive2d::BasePrimitive2D> pRetval( new drawinglayer::primitive2d::FillGradientPrimitive2D( rRange, std::move(aAttribute))); if(!rPropertyHolder.getTransformation().isIdentity()) { const drawinglayer::primitive2d::Primitive2DReference xPrim(pRetval); drawinglayer::primitive2d::Primitive2DContainer xSeq { xPrim }; pRetval = new drawinglayer::primitive2d::TransformPrimitive2D( rPropertyHolder.getTransformation(), std::move(xSeq)); } return pRetval; } } /** helper to create needed data to emulate the VCL Wallpaper Metafile action. It is a quite mighty action. This helper decides if color and/or gradient background is needed for the wanted bitmap fill and then creates the needed WallpaperBitmapPrimitive2D. This primitive was created for this purpose and takes over all needed logic of orientations and tiling. */ static void CreateAndAppendBitmapWallpaper( basegfx::B2DRange aWallpaperRange, const Wallpaper& rWallpaper, TargetHolder& rTarget, PropertyHolder const & rProperty) { const BitmapEx& aBitmapEx(rWallpaper.GetBitmap()); const WallpaperStyle eWallpaperStyle(rWallpaper.GetStyle()); // if bitmap visualisation is transparent, maybe background // needs to be filled. Create background if(aBitmapEx.IsAlpha() || (WallpaperStyle::Tile != eWallpaperStyle && WallpaperStyle::Scale != eWallpaperStyle)) { if(rWallpaper.IsGradient()) { rTarget.append( CreateGradientWallpaper( aWallpaperRange, rWallpaper.GetGradient(), rProperty)); } else if(!rWallpaper.GetColor().IsTransparent()) { rTarget.append( CreateColorWallpaper( aWallpaperRange, rWallpaper.GetColor().getBColor(), rProperty)); } } // use wallpaper rect if set if(rWallpaper.IsRect() && !rWallpaper.GetRect().IsEmpty()) { aWallpaperRange = vcl::unotools::b2DRectangleFromRectangle(rWallpaper.GetRect()); } rtl::Reference<drawinglayer::primitive2d::BasePrimitive2D> pBitmapWallpaperFill = new drawinglayer::primitive2d::WallpaperBitmapPrimitive2D( aWallpaperRange, aBitmapEx, eWallpaperStyle); if(rProperty.getTransformation().isIdentity()) { // add directly rTarget.append(pBitmapWallpaperFill); } else { // when a transformation is set, embed to it rTarget.append( new drawinglayer::primitive2d::TransformPrimitive2D( rProperty.getTransformation(), drawinglayer::primitive2d::Primitive2DContainer { pBitmapWallpaperFill })); } } /** helper to decide UnderlineAbove for text primitives */ static bool isUnderlineAbove(const vcl::Font& rFont) { if(!rFont.IsVertical()) { return false; } // the underline is right for Japanese only return (LANGUAGE_JAPANESE == rFont.GetLanguage()) || (LANGUAGE_JAPANESE == rFont.GetCJK } static void createFontAttributeTransformAndAlignment( drawinglayer::attribute::FontAttribute& rFontAttribute, basegfx::B2DHomMatrix& rTextTransform, basegfx::B2DVector& rAlignmentOffset, PropertyHolder const & rProperty) { const vcl::Font& rFont = rProperty.getFont(); basegfx::B2DVector aFontScaling; rFontAttribute = drawinglayer::primitive2d::getFontAttributeFromVclFont( aFontScaling, rFont, bool(rProperty.getLayoutMode() & vcl::text::ComplexTextLayoutFlags::BiDiRtl), bool(rProperty.getLayoutMode() & vcl::text::ComplexTextLayoutFlags::BiDiStrong // add FontScaling rTextTransform.scale(aFontScaling.getX(), aFontScaling.getY()); // take text align into account if(ALIGN_BASELINE != rFont.GetAlignment()) { drawinglayer::primitive2d::TextLayouterDevice aTextLayouterDevice; aTextLayouterDevice.setFont(rFont); if(ALIGN_TOP == rFont.GetAlignment()) { rAlignmentOffset.setY(aTextLayouterDevice.getFontAscent()); } else // ALIGN_BOTTOM { rAlignmentOffset.setY(-aTextLayouterDevice.getFontDescent()); } rTextTransform.translate(rAlignmentOffset.getX(), rAlignmentOffset.getY()); } // add FontRotation (if used) if(rFont.GetOrientation()) { rTextTransform.rotate(-toRadians(rFont.GetOrientation())); } } /** helper which takes complete care for creating the needed text primitives. It takes care of decorated stuff and all the geometry adaptations needed */ static void processMetaTextAction( const Point& rTextStartPosition, const OUString& rText, sal_uInt16 nTextStart, sal_uInt16 nTextLength, std::vector< double >&& rDXArray, std::vector< sal_Bool >&& rKashidaArray, TargetHolder& rTarget, PropertyHolder const & rProperty) { rtl::Reference<drawinglayer::primitive2d::BasePrimitive2D> pResult; const vcl::Font& rFont = rProperty.getFont(); basegfx::B2DVector aAlignmentOffset(0.0, 0.0); if(nTextLength) { drawinglayer::attribute::FontAttribute aFontAttribute; basegfx::B2DHomMatrix aTextTransform; // fill parameters derived from current font createFontAttributeTransformAndAlignment( aFontAttribute, aTextTransform, aAlignmentOffset, rProperty); // add TextStartPosition aTextTransform.translate(rTextStartPosition.X(), rTextStartPosition.Y()); // prepare FontColor and Locale const basegfx::BColor aFontColor(rProperty.getTextColor()); const Color aFillColor(rFont.GetFillColor()); css::lang::Locale aLocale(LanguageTag(rProperty.getLanguageType()).getLocale()); const bool bWordLineMode(rFont.IsWordLineMode()); const bool bDecoratedIsNeeded( LINESTYLE_NONE != rFont.GetOverline() || LINESTYLE_NONE != rFont.GetUnderline() || STRIKEOUT_NONE != rFont.GetStrikeout() || FontEmphasisMark::NONE != (rFont.GetEmphasisMark() & FontEmphasisMark::Style) || FontRelief::NONE != rFont.GetRelief() || rFont.IsShadow() || bWordLineMode); if(bDecoratedIsNeeded) { // prepare overline, underline and strikeout data const drawinglayer::primitive2d::TextLine eFontOverline(drawinglayer::primitive2d: const drawinglayer::primitive2d::TextLine eFontLineStyle(drawinglayer::primitive2d const drawinglayer::primitive2d::TextStrikeout eTextStrikeout(drawinglayer::primit // check UndelineAbove const bool bUnderlineAbove(drawinglayer::primitive2d::TEXT_LINE_NONE != eFontLineSty // prepare emphasis mark data drawinglayer::primitive2d::TextEmphasisMark eTextEmphasisMark(drawinglayer::primi switch(rFont.GetEmphasisMark() & FontEmphasisMark::Style) { case FontEmphasisMark::Dot : eTextEmphasisMark = drawinglayer::primitive2d::TEXT_FONT case FontEmphasisMark::Circle : eTextEmphasisMark = drawinglayer::primitive2d::TEXT_F case FontEmphasisMark::Disc : eTextEmphasisMark = drawinglayer::primitive2d::TEXT_FON case FontEmphasisMark::Accent : eTextEmphasisMark = drawinglayer::primitive2d::TEXT_F default: break; } const bool bEmphasisMarkAbove(rFont.GetEmphasisMark() & FontEmphasisMark::PosAbo const bool bEmphasisMarkBelow(rFont.GetEmphasisMark() & FontEmphasisMark::PosBel // prepare font relief data drawinglayer::primitive2d::TextRelief eTextRelief(drawinglayer::primitive2d::TEXT switch(rFont.GetRelief()) { case FontRelief::Embossed : eTextRelief = drawinglayer::primitive2d::TEXT_RELIEF_EMBO case FontRelief::Engraved : eTextRelief = drawinglayer::primitive2d::TEXT_RELIEF_ENGR default : break; // RELIEF_NONE, FontRelief_FORCE_EQUAL_SIZE } // prepare shadow/outline data const bool bShadow(rFont.IsShadow()); // TextDecoratedPortionPrimitive2D is needed, create one pResult = new drawinglayer::primitive2d::TextDecoratedPortionPrimitive2D( // attributes for TextSimplePortionPrimitive2D aTextTransform, rText, nTextStart, nTextLength, std::vector(rDXArray), std::move(rKashidaArray), aFontAttribute, aLocale, aFontColor, aFillColor, rFont.GetFixKerning(), // attributes for TextDecoratedPortionPrimitive2D rProperty.getOverlineColorActive() ? rProperty.getOverlineColor() : aFontColor, rProperty.getTextLineColorActive() ? rProperty.getTextLineColor() : aFontColor, eFontOverline, eFontLineStyle, bUnderlineAbove, eTextStrikeout, bWordLineMode, eTextEmphasisMark, bEmphasisMarkAbove, bEmphasisMarkBelow, eTextRelief, bShadow); } else { // TextSimplePortionPrimitive2D is enough pResult = new drawinglayer::primitive2d::TextSimplePortionPrimitive2D( aTextTransform, rText, nTextStart, nTextLength, std::vector(rDXArray), std::move(rKashidaArray), std::move(aFontAttribute), std::move(aLocale), aFontColor, COL_TRANSPARENT, rFont.GetFixKerning()); } } if(pResult && rProperty.getTextFillColorActive()) { // text background is requested, add and encapsulate both to new primitive drawinglayer::primitive2d::TextLayouterDevice aTextLayouterDevice; aTextLayouterDevice.setFont(rFont); // get text width double fTextWidth(0.0); if (rDXArray.empty()) { fTextWidth = aTextLayouterDevice.getTextWidth(rText, nTextStart, nTextLength); } else { fTextWidth = rDXArray.back(); } if (fTextWidth > 0.0 && !basegfx::fTools::equalZero(fTextWidth)) { // build text range const basegfx::B2DRange aTextRange( 0.0, -aTextLayouterDevice.getFontAscent(), fTextWidth, aTextLayouterDevice.getFontDescent()); // create Transform basegfx::B2DHomMatrix aTextTransform; aTextTransform.translate(aAlignmentOffset.getX(), aAlignmentOffset.getY()); if(rFont.GetOrientation()) { aTextTransform.rotate(-toRadians(rFont.GetOrientation())); } aTextTransform.translate(rTextStartPosition.X(), rTextStartPosition.Y()); // prepare Primitive2DSequence, put text in foreground drawinglayer::primitive2d::Primitive2DContainer aSequence(2); aSequence[1] = pResult; // prepare filled polygon basegfx::B2DPolygon aOutline(basegfx::utils::createPolygonFromRect(aTextRange)); aOutline.transform(aTextTransform); aSequence[0] = drawinglayer::primitive2d::Primitive2DReference( new drawinglayer::primitive2d::PolyPolygonColorPrimitive2D( basegfx::B2DPolyPolygon(aOutline), rProperty.getTextFillColor())); // set as group at pResult pResult = new drawinglayer::primitive2d::GroupPrimitive2D(std::move(aSequence)); } } if(!pResult) return; // add created text primitive to target if(rProperty.getTransformation().isIdentity()) { rTarget.append(pResult); } else { // when a transformation is set, embed to it rTarget.append( new drawinglayer::primitive2d::TransformPrimitive2D( rProperty.getTransformation(), drawinglayer::primitive2d::Primitive2DContainer { pResult })); } } /** helper which takes complete care for creating the needed textLine primitives */ static void processMetaTextLineAction( const MetaTextLineAction& rAction, TargetHolder& rTarget, PropertyHolder const & rProperty) { const double fLineWidth(fabs(static_cast<double>(rAction.GetWidth()))); if(fLineWidth <= 0.0) return; const drawinglayer::primitive2d::TextLine aOverlineMode(drawinglayer::primitive2d: const drawinglayer::primitive2d::TextLine aUnderlineMode(drawinglayer::primitive2d const drawinglayer::primitive2d::TextStrikeout aTextStrikeout(drawinglayer::primit const bool bOverlineUsed(drawinglayer::primitive2d::TEXT_LINE_NONE != aOverlineMode) const bool bUnderlineUsed(drawinglayer::primitive2d::TEXT_LINE_NONE != aUnderlineMod const bool bStrikeoutUsed(drawinglayer::primitive2d::TEXT_STRIKEOUT_NONE != aTextStr if(!(bUnderlineUsed || bStrikeoutUsed || bOverlineUsed)) return; drawinglayer::primitive2d::Primitive2DContainer aTargets; basegfx::B2DVector aAlignmentOffset(0.0, 0.0); drawinglayer::attribute::FontAttribute aFontAttribute; basegfx::B2DHomMatrix aTextTransform; // fill parameters derived from current font createFontAttributeTransformAndAlignment( aFontAttribute, aTextTransform, aAlignmentOffset, rProperty); // add TextStartPosition aTextTransform.translate(rAction.GetStartPoint().X(), rAction.GetStartPoint().Y() // prepare TextLayouter (used in most cases) drawinglayer::primitive2d::TextLayouterDevice aTextLayouter; aTextLayouter.setFont(rProperty.getFont()); if(bOverlineUsed) { // create primitive geometry for overline aTargets.push_back( new drawinglayer::primitive2d::TextLinePrimitive2D( aTextTransform, fLineWidth, aTextLayouter.getOverlineOffset(), aTextLayouter.getOverlineHeight(), aOverlineMode, rProperty.getOverlineColor())); } if(bUnderlineUsed) { // create primitive geometry for underline aTargets.push_back( new drawinglayer::primitive2d::TextLinePrimitive2D( aTextTransform, fLineWidth, aTextLayouter.getUnderlineOffset(), aTextLayouter.getUnderlineHeight(), aUnderlineMode, rProperty.getTextLineColor())); } if(bStrikeoutUsed) { // create primitive geometry for strikeout if(drawinglayer::primitive2d::TEXT_STRIKEOUT_SLASH == aTextStrikeout || drawinglayer::primitive2d::TEXT_STRIKEOUT_X == aTextStrikeout) { // strikeout with character const sal_Unicode aStrikeoutChar( drawinglayer::primitive2d::TEXT_STRIKEOUT_SLASH == aTextStrikeout ? '/' : 'X'); css::lang::Locale aLocale(LanguageTag( rProperty.getLanguageType()).getLocale()); aTargets.push_back( new drawinglayer::primitive2d::TextCharacterStrikeoutPrimitive2D( aTextTransform, fLineWidth, rProperty.getTextColor(), aStrikeoutChar, std::move(aFontAttribute), std::move(aLocale))); } else { // strikeout with geometry aTargets.push_back( new drawinglayer::primitive2d::TextGeometryStrikeoutPrimitive2D( aTextTransform, fLineWidth, rProperty.getTextColor(), aTextLayouter.getUnderlineHeight(), aTextLayouter.getStrikeoutOffset(), aTextStrikeout)); } } if(aTargets.empty()) return; // add created text primitive to target if(rProperty.getTransformation().isIdentity()) { rTarget.append(std::move(aTargets)); } else { // when a transformation is set, embed to it rTarget.append( new drawinglayer::primitive2d::TransformPrimitive2D( rProperty.getTransformation(), std::move(aTargets))); } } /** This is the main interpreter method. It is designed to handle the given Metafile completely inside the given context and target. It may use and modify the context and target. This design allows to call itself recursively which adapted contexts and targets as e.g. needed for the MetaActionType::FLOATTRANSPARENT where the content is expres as a metafile as sub-content. This interpreter is as free of VCL functionality as possible. It uses VCL data classes (else reading the data would not be possible), but e.g. does NOT use a local OutputDevice as most other MetaFile interpreters/exporters do to hold and work with the current context. This is necessary to be able to get away from the strong internal VCL-binding. It tries to combine e.g. pixel and/or point actions and to stitch together single line primitiv where possible (which is not trivial with the possible line geometry definitions). It tries to handle clipping no longer as Regions and spans of Rectangles, but as PolyPolygon ClipRegions with (where possible) high precision by using the best possible data quality from the Region. The vcl::Region is unavoidable as data container, but nowadays allows the tra of Polygon-based clip regions. Where this is not used, a Polygon is constructed from the vcl::Region ranges. All primitive clipping uses the MaskPrimitive2D with Polygon-based cli I have marked the single MetaActions with: SIMPLE, DONE: Simple, e.g nothing to do or value setting in the context CHECKED, WORKS WELL: Thoroughly tested with extra written test code which created a replacement Metafile just to test this action in various combinations NEEDS IMPLEMENTATION: Not implemented and asserted, but also no usage found, neither in own Metafile creations, nor in EMF/WMF imports (checked with a whole bunch of critical EMF/WMF bugdocs) For more comments, see the single action implementations. */ static void implInterpretMetafile( const GDIMetaFile& rMetaFile, TargetHolders& rTargetHolders, PropertyHolders& rPropertyHolders, const drawinglayer::geometry::ViewInformation2D& rViewInformation) { const size_t nCount(rMetaFile.GetActionSize()); std::unique_ptr<emfplushelper::EmfPlusHelper> aEMFPlus; for(size_t nAction(0); nAction < nCount; nAction++) { MetaAction* pAction = rMetaFile.GetAction(nAction); switch(pAction->GetType()) { case MetaActionType::NONE : { /** SIMPLE, DONE */ break; } case MetaActionType::PIXEL : { /** CHECKED, WORKS WELL */ std::vector< basegfx::B2DPoint > aPositions; Color aLastColor(COL_BLACK); while(MetaActionType::PIXEL == pAction->GetType() && nAction < nCount) { const MetaPixelAction* pA = static_cast<const MetaPixelAction*>(pAction); if(pA->GetColor() != aLastColor) { if(!aPositions.empty()) { createPointArrayPrimitive(std::move(aPositions), rTargetHolders.Current(), rProper aPositions.clear(); } aLastColor = pA->GetColor(); } const Point& rPoint = pA->GetPoint(); aPositions.emplace_back(rPoint.X(), rPoint.Y()); nAction++; if(nAction < nCount) pAction = rMetaFile.GetAction(nAction); } nAction--; if(!aPositions.empty()) { createPointArrayPrimitive(std::move(aPositions), rTargetHolders.Current(), rProper } break; } case MetaActionType::POINT : { /** CHECKED, WORKS WELL */ if(rPropertyHolders.Current().getLineColorActive()) { std::vector< basegfx::B2DPoint > aPositions; while(MetaActionType::POINT == pAction->GetType() && nAction < nCount) { const MetaPointAction* pA = static_cast<const MetaPointAction*>(pAction); const Point& rPoint = pA->GetPoint(); aPositions.emplace_back(rPoint.X(), rPoint.Y()); nAction++; if(nAction < nCount) pAction = rMetaFile.GetAction(nAction); } nAction--; if(!aPositions.empty()) { createPointArrayPrimitive(std::move(aPositions), rTargetHolders.Current(), rProper } } break; } case MetaActionType::LINE : { /** CHECKED, WORKS WELL */ if(rPropertyHolders.Current().getLineColorActive()) { basegfx::B2DPolygon aLinePolygon; LineInfo aLineInfo; while(MetaActionType::LINE == pAction->GetType() && nAction < nCount) { const MetaLineAction* pA = static_cast<const MetaLineAction*>(pAction); const Point& rStartPoint = pA->GetStartPoint(); const Point& rEndPoint = pA->GetEndPoint(); const basegfx::B2DPoint aStart(rStartPoint.X(), rStartPoint.Y()); const basegfx::B2DPoint aEnd(rEndPoint.X(), rEndPoint.Y()); if(aLinePolygon.count()) { if(pA->GetLineInfo() == aLineInfo && aStart == aLinePolygon.getB2DPoint(aLinePolygon.count() - 1)) { aLinePolygon.append(aEnd); } else { createLinePrimitive(aLinePolygon, aLineInfo, rTargetHolders.Current(), rPropertyHol aLinePolygon.clear(); aLineInfo = pA->GetLineInfo(); aLinePolygon.append(aStart); aLinePolygon.append(aEnd); } } else { aLineInfo = pA->GetLineInfo(); aLinePolygon.append(aStart); aLinePolygon.append(aEnd); } nAction++; if (nAction < nCount) pAction = rMetaFile.GetAction(nAction); } nAction--; if (aLinePolygon.count()) createLinePrimitive(aLinePolygon, aLineInfo, rTargetHolders.Current(), rPropertyHol } break; } case MetaActionType::RECT : { /** CHECKED, WORKS WELL */ if(rPropertyHolders.Current().getLineOrFillActive()) { const MetaRectAction* pA = static_cast<const MetaRectAction*>(pAction); const tools::Rectangle& rRectangle = pA->GetRect(); if(!rRectangle.IsEmpty()) { const basegfx::B2DRange aRange = vcl::unotools::b2DRectangleFromRectangle(rRectangle if(!aRange.isEmpty()) { const basegfx::B2DPolygon aOutline(basegfx::utils::createPolygonFromRect(aRange)); createHairlineAndFillPrimitive(aOutline, rTargetHolders.Current(), rPropertyHolder } } } break; } case MetaActionType::ROUNDRECT : { /** CHECKED, WORKS WELL */ /** The original OutputDevice::DrawRect paints nothing when nHor or nVer is zero; but just because the tools::Polygon operator creating the rounding does produce nonsense. I assume this an error and create an unrounded rectangle in that case (implicit in createPolygonFromRect) */ if(rPropertyHolders.Current().getLineOrFillActive()) { const MetaRoundRectAction* pA = static_cast<const MetaRoundRectAction*>(pAction); const tools::Rectangle& rRectangle = pA->GetRect(); if(!rRectangle.IsEmpty()) { const basegfx::B2DRange aRange = vcl::unotools::b2DRectangleFromRectangle(rRectangle if(!aRange.isEmpty()) { const sal_uInt32 nHor(pA->GetHorzRound()); const sal_uInt32 nVer(pA->GetVertRound()); 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::clamp(fRadiusX, 0.0, 1.0); fRadiusY = std::clamp(fRadiusY, 0.0, 1.0); aOutline = basegfx::utils::createPolygonFromRect(aRange, fRadiusX, fRadiusY); } else { aOutline = basegfx::utils::createPolygonFromRect(aRange); } createHairlineAndFillPrimitive(aOutline, rTargetHolders.Current(), rPropertyHolder } } } break; } case MetaActionType::ELLIPSE : { /** CHECKED, WORKS WELL */ if(rPropertyHolders.Current().getLineOrFillActive()) { const MetaEllipseAction* pA = static_cast<const MetaEllipseAction*>(pAction); const tools::Rectangle& rRectangle = pA->GetRect(); if(!rRectangle.IsEmpty()) { const basegfx::B2DRange aRange = vcl::unotools::b2DRectangleFromRectangle(rRectangle if(!aRange.isEmpty()) { const basegfx::B2DPolygon aOutline(basegfx::utils::createPolygonFromEllipse( aRange.getCenter(), aRange.getWidth() * 0.5, aRange.getHeight() * 0.5)); createHairlineAndFillPrimitive(aOutline, rTargetHolders.Current(), rPropertyHolder } } } break; } case MetaActionType::ARC : { /** CHECKED, WORKS WELL */ if(rPropertyHolders.Current().getLineColorActive()) { const MetaArcAction* pA = static_cast<const MetaArcAction*>(pAction); const tools::Polygon aToolsPoly(pA->GetRect(), pA->GetStartPoint(), pA->GetEndPoint(), P const basegfx::B2DPolygon aOutline(aToolsPoly.getB2DPolygon()); createHairlinePrimitive(aOutline, rTargetHolders.Current(), rPropertyHolders.Curre } break; } case MetaActionType::PIE : { /** CHECKED, WORKS WELL */ if(rPropertyHolders.Current().getLineOrFillActive()) { const MetaPieAction* pA = static_cast<const MetaPieAction*>(pAction); const tools::Polygon aToolsPoly(pA->GetRect(), pA->GetStartPoint(), pA->GetEndPoint(), P const basegfx::B2DPolygon aOutline(aToolsPoly.getB2DPolygon()); createHairlineAndFillPrimitive(aOutline, rTargetHolders.Current(), rPropertyHolder } break; } case MetaActionType::CHORD : { /** CHECKED, WORKS WELL */ if(rPropertyHolders.Current().getLineOrFillActive()) { const MetaChordAction* pA = static_cast<const MetaChordAction*>(pAction); const tools::Polygon aToolsPoly(pA->GetRect(), pA->GetStartPoint(), pA->GetEndPoint(), P const basegfx::B2DPolygon aOutline(aToolsPoly.getB2DPolygon()); createHairlineAndFillPrimitive(aOutline, rTargetHolders.Current(), rPropertyHolder } break; } case MetaActionType::POLYLINE : { /** CHECKED, WORKS WELL */ if(rPropertyHolders.Current().getLineColorActive()) { const MetaPolyLineAction* pA = static_cast<const MetaPolyLineAction*>(pAction); createLinePrimitive(pA->GetPolygon().getB2DPolygon(), pA->GetLineInfo(), rTargetHold } break; } case MetaActionType::POLYGON : { /** CHECKED, WORKS WELL */ if(rPropertyHolders.Current().getLineOrFillActive()) { const MetaPolygonAction* pA = static_cast<const MetaPolygonAction*>(pAction); basegfx::B2DPolygon aOutline(pA->GetPolygon().getB2DPolygon()); // the metafile play interprets the polygons from MetaPolygonAction // always as closed and always paints an edge from last to first point, // so force to closed here to emulate that if(aOutline.count() > 1 && !aOutline.isClosed()) { aOutline.setClosed(true); } createHairlineAndFillPrimitive(aOutline, rTargetHolders.Current(), rPropertyHolder } break; } case MetaActionType::POLYPOLYGON : { /** CHECKED, WORKS WELL */ if(rPropertyHolders.Current().getLineOrFillActive()) { const MetaPolyPolygonAction* pA = static_cast<const MetaPolyPolygonAction*>(pAction); basegfx::B2DPolyPolygon aPolyPolygonOutline(pA->GetPolyPolygon().getB2DPolyPolygon // the metafile play interprets the single polygons from MetaPolyPolygonAction // always as closed and always paints an edge from last to first point, // so force to closed here to emulate that for(sal_uInt32 b(0); b < aPolyPolygonOutline.count(); b++) { basegfx::B2DPolygon aPolygonOutline(aPolyPolygonOutline.getB2DPolygon(b)); if(aPolygonOutline.count() > 1 && !aPolygonOutline.isClosed()) { aPolygonOutline.setClosed(true); aPolyPolygonOutline.setB2DPolygon(b, aPolygonOutline); } } createHairlineAndFillPrimitive(aPolyPolygonOutline, rTargetHolders.Current(), rPro } break; } case MetaActionType::TEXT : { /** CHECKED, WORKS WELL */ const MetaTextAction* pA = static_cast<const MetaTextAction*>(pAction); sal_uInt32 nTextLength(pA->GetLen()); const sal_uInt32 nTextIndex(pA->GetIndex()); const sal_uInt32 nStringLength(pA->GetText().getLength()); if(nTextLength + nTextIndex > nStringLength) { nTextLength = nStringLength - nTextIndex; } if(nTextLength && rPropertyHolders.Current().getTextColorActive()) { std::vector< double > aDXArray{}; processMetaTextAction( pA->GetPoint(), pA->GetText(), nTextIndex, nTextLength, std::move(aDXArray), {}, rTargetHolders.Current(), rPropertyHolders.Current()); } break; } case MetaActionType::TEXTARRAY : { /** CHECKED, WORKS WELL */ const MetaTextArrayAction* pA = static_cast<const MetaTextArrayAction*>(pAction); sal_uInt32 nTextLength(pA->GetLen()); const sal_uInt32 nTextIndex(pA->GetIndex()); const sal_uInt32 nStringLength(pA->GetText().getLength()); if(nTextLength + nTextIndex > nStringLength) { nTextLength = nTextIndex > nStringLength ? 0 : nStringLength - nTextIndex; } if(nTextLength && rPropertyHolders.Current().getTextColorActive()) { // prepare DXArray (if used) std::vector< double > aDXArray; const KernArray& rDXArray = pA->GetDXArray(); std::vector< sal_Bool > aKashidaArray = pA->GetKashidaArray(); if(!rDXArray.empty()) { aDXArray.reserve(nTextLength); for(sal_uInt32 a(0); a < nTextLength; a++) { aDXArray.push_back(static_cast<double>(rDXArray[a])); } } processMetaTextAction( pA->GetPoint(), pA->GetText(), nTextIndex, nTextLength, std::move(aDXArray), std::move(aKashidaArray), rTargetHolders.Current(), rPropertyHolders.Current()); } break; } case MetaActionType::STRETCHTEXT : { // #i108440# StarMath uses MetaStretchTextAction, thus support is needed. // It looks as if it pretty never really uses a width different from // the default text-layout width, but it's not possible to be sure. // Implemented getting the DXArray and checking for scale at all. If // scale is more than 3.5% different, scale the DXArray before usage. // New status: /** CHECKED, WORKS WELL */ const MetaStretchTextAction* pA = static_cast<const MetaStretchTextAction*>(pAction); sal_uInt32 nTextLength(pA->GetLen()); const sal_uInt32 nTextIndex(pA->GetIndex()); const sal_uInt32 nStringLength(pA->GetText().getLength()); if(nTextLength + nTextIndex > nStringLength) { nTextLength = nStringLength - nTextIndex; } if(nTextLength && rPropertyHolders.Current().getTextColorActive()) { drawinglayer::primitive2d::TextLayouterDevice aTextLayouterDevice; aTextLayouterDevice.setFont(rPropertyHolders.Current().getFont()); std::vector< double > aTextArray( aTextLayouterDevice.getTextArray( pA->GetText(), nTextIndex, nTextLength)); if(!aTextArray.empty()) { const double fTextLength(aTextArray.back()); if(0.0 != fTextLength && pA->GetWidth()) { const double fRelative(pA->GetWidth() / fTextLength); if(fabs(fRelative - 1.0) >= 0.035) { // when derivation is more than 3,5% from default text size, // scale the DXArray for(double & a : aTextArray) { a *= fRelative; } } } } processMetaTextAction( pA->GetPoint(), pA->GetText(), nTextIndex, nTextLength, std::move(aTextArray), {}, rTargetHolders.Current(), rPropertyHolders.Current()); } break; } case MetaActionType::TEXTRECT : { /** CHECKED, WORKS WELL */ // OSL_FAIL("MetaActionType::TEXTRECT requested (!)"); const MetaTextRectAction* pA = static_cast<const MetaTextRectAction*>(pAction); const tools::Rectangle& rRectangle = pA->GetRect(); const sal_uInt32 nStringLength(pA->GetText().getLength()); if(!rRectangle.IsEmpty() && 0 != nStringLength) { // The problem with this action is that it describes unlayouted text // and the layout capabilities are in EditEngine/Outliner in SVX. The // same problem is true for VCL which internally has implementations // to layout text in this case. There exists even a call // OutputDevice::AddTextRectActions(...) to create the needed actions // as 'sub-content' of a Metafile. Unfortunately i do not have an // OutputDevice here since this interpreter tries to work without // VCL AFAP. // Since AddTextRectActions is the only way as long as we do not have // a simple text layouter available, i will try to add it to the // TextLayouterDevice isolation. drawinglayer::primitive2d::TextLayouterDevice aTextLayouterDevice; aTextLayouterDevice.setFont(rPropertyHolders.Current().getFont()); GDIMetaFile aGDIMetaFile; aTextLayouterDevice.addTextRectActions( rRectangle, pA->GetText(), pA->GetStyle(), aGDIMetaFile); if(aGDIMetaFile.GetActionSize()) { // create sub-content drawinglayer::primitive2d::Primitive2DContainer xSubContent; { rTargetHolders.Push(); // for sub-Mteafile contents, do start with new, default render state // #i124686# ...but copy font, this is already set accordingly vcl::Font aTargetFont = rPropertyHolders.Current().getFont(); rPropertyHolders.PushDefault(); rPropertyHolders.Current().setFont(aTargetFont); implInterpretMetafile(aGDIMetaFile, rTargetHolders, rPropertyHolders, rViewInformat xSubContent = rTargetHolders.Current().getPrimitive2DSequence(rPropertyHolders.Cur rPropertyHolders.Pop(); rTargetHolders.Pop(); } if(!xSubContent.empty()) { // add with transformation rTargetHolders.Current().append( new drawinglayer::primitive2d::TransformPrimitive2D( rPropertyHolders.Current().getTransformation(), std::move(xSubContent))); } } } break; } case MetaActionType::BMP : { /** CHECKED, WORKS WELL */ const MetaBmpAction* pA = static_cast<const MetaBmpAction*>(pAction); const BitmapEx aBitmapEx(pA->GetBitmap()); createBitmapExPrimitive(aBitmapEx, pA->GetPoint(), rTargetHolders.Current(), rProper break; } case MetaActionType::BMPSCALE : { /** CHECKED, WORKS WELL */ const MetaBmpScaleAction* pA = static_cast<const MetaBmpScaleAction*>(pAction); const BitmapEx aBitmapEx(pA->GetBitmap()); createBitmapExPrimitive(aBitmapEx, pA->GetPoint(), pA->GetSize(), rTargetHolders.Curr break; } case MetaActionType::BMPSCALEPART : { /** CHECKED, WORKS WELL */ const MetaBmpScalePartAction* pA = static_cast<const MetaBmpScalePartAction*>(pAction); const Bitmap& rBitmap = pA->GetBitmap(); if(!rBitmap.IsEmpty()) { Bitmap aCroppedBitmap(rBitmap); const tools::Rectangle aCropRectangle(pA->GetSrcPoint(), pA->GetSrcSize()); if(!aCropRectangle.IsEmpty()) { aCroppedBitmap.Crop(aCropRectangle); } const BitmapEx aCroppedBitmapEx(aCroppedBitmap); createBitmapExPrimitive(aCroppedBitmapEx, pA->GetDestPoint(), pA->GetDestSize(), rTar } break; } case MetaActionType::BMPEX : { /** CHECKED, WORKS WELL: Simply same as MetaActionType::BMP */ const MetaBmpExAction* pA = static_cast<const MetaBmpExAction*>(pAction); const BitmapEx& rBitmapEx = pA->GetBitmapEx(); createBitmapExPrimitive(rBitmapEx, pA->GetPoint(), rTargetHolders.Current(), rProper break; } case MetaActionType::BMPEXSCALE : { /** CHECKED, WORKS WELL: Simply same as MetaActionType::BMPSCALE */ const MetaBmpExScaleAction* pA = static_cast<const MetaBmpExScaleAction*>(pAction); const BitmapEx& rBitmapEx = pA->GetBitmapEx(); createBitmapExPrimitive(rBitmapEx, pA->GetPoint(), pA->GetSize(), rTargetHolders.Curr break; } case MetaActionType::BMPEXSCALEPART : { /** CHECKED, WORKS WELL: Simply same as MetaActionType::BMPSCALEPART */ const MetaBmpExScalePartAction* pA = static_cast<const MetaBmpExScalePartAction*>(pActi const BitmapEx& rBitmapEx = pA->GetBitmapEx(); if(!rBitmapEx.IsEmpty()) { BitmapEx aCroppedBitmapEx(rBitmapEx); const tools::Rectangle aCropRectangle(pA->GetSrcPoint(), pA->GetSrcSize()); if(!aCropRectangle.IsEmpty()) { aCroppedBitmapEx.Crop(aCropRectangle); } createBitmapExPrimitive(aCroppedBitmapEx, pA->GetDestPoint(), pA->GetDestSize(), rTar } break; } case MetaActionType::MASK : { /** CHECKED, WORKS WELL: Simply same as MetaActionType::BMP */ /** Huh, no it isn't!? */ const MetaMaskAction* pA = static_cast<const MetaMaskAction*>(pAction); const BitmapEx aBitmapEx(createMaskBmpEx(pA->GetBitmap(), pA->GetColor())); createBitmapExPrimitive(aBitmapEx, pA->GetPoint(), rTargetHolders.Current(), rProper break; } case MetaActionType::MASKSCALE : { /** CHECKED, WORKS WELL: Simply same as MetaActionType::BMPSCALE */ const MetaMaskScaleAction* pA = static_cast<const MetaMaskScaleAction*>(pAction); const BitmapEx aBitmapEx(createMaskBmpEx(pA->GetBitmap(), pA->GetColor())); createBitmapExPrimitive(aBitmapEx, pA->GetPoint(), pA->GetSize(), rTargetHolders.Curr break; } case MetaActionType::MASKSCALEPART : { /** CHECKED, WORKS WELL: Simply same as MetaActionType::BMPSCALEPART */ const MetaMaskScalePartAction* pA = static_cast<const MetaMaskScalePartAction*>(pAction const Bitmap& rBitmap = pA->GetBitmap(); if(!rBitmap.IsEmpty()) { Bitmap aCroppedBitmap(rBitmap); const tools::Rectangle aCropRectangle(pA->GetSrcPoint(), pA->GetSrcSize()); if(!aCropRectangle.IsEmpty()) { aCroppedBitmap.Crop(aCropRectangle); } const BitmapEx aCroppedBitmapEx(createMaskBmpEx(aCroppedBitmap, pA->GetColor())); createBitmapExPrimitive(aCroppedBitmapEx, pA->GetDestPoint(), pA->GetDestSize(), rTar } break; } case MetaActionType::GRADIENT : { /** CHECKED, WORKS WELL */ const MetaGradientAction* pA = static_cast<const MetaGradientAction*>(pAction); const tools::Rectangle& rRectangle = pA->GetRect(); if(!rRectangle.IsEmpty()) { basegfx::B2DRange aRange = vcl::unotools::b2DRectangleFromRectangle(rRectangle); if(!aRange.isEmpty()) { const Gradient& rGradient = pA->GetGradient(); drawinglayer::attribute::FillGradientAttribute aAttribute(createFillGradientAttri basegfx::B2DPolyPolygon aOutline(basegfx::utils::createPolygonFromRect(aRange)); basegfx::BColor aSingleColor; if (aAttribute.getColorStops().isSingleColor(aSingleColor)) { // not really a gradient. Create filled rectangle createFillPrimitive( aOutline, rTargetHolders.Current(), rPropertyHolders.Current()); } else { // really a gradient aRange.transform(rPropertyHolders.Current().getTransformation()); drawinglayer::primitive2d::Primitive2DContainer xGradient(1); if(rPropertyHolders.Current().isRasterOpInvert()) { // use a special version of FillGradientPrimitive2D which creates // non-overlapping geometry on decomposition to make the old XOR // paint 'trick' work. xGradient[0] = drawinglayer::primitive2d::Primitive2DReference( new drawinglayer::primitive2d::NonOverlappingFillGradientPrimitive2D( aRange, aAttribute)); } else { xGradient[0] = drawinglayer::primitive2d::Primitive2DReference( new drawinglayer::primitive2d::FillGradientPrimitive2D( aRange, std::move(aAttribute))); } // #i112300# clip against polygon representing the rectangle from // the action. This is implicitly done using a temp Clipping in VCL // when a MetaGradientAction is executed aOutline.transform(rPropertyHolders.Current().getTransformation()); rTargetHolders.Current().append( new drawinglayer::primitive2d::MaskPrimitive2D( std::move(aOutline), std::move(xGradient))); } } } break; } case MetaActionType::HATCH : { /** CHECKED, WORKS WELL */ const MetaHatchAction* pA = static_cast<const MetaHatchAction*>(pAction); basegfx::B2DPolyPolygon aOutline(pA->GetPolyPolygon().getB2DPolyPolygon()); if(aOutline.count()) { const Hatch& rHatch = pA->GetHatch(); drawinglayer::attribute::FillHatchAttribute aAttribute(createFillHatchAttribute(r aOutline.transform(rPropertyHolders.Current().getTransformation()); const basegfx::B2DRange aObjectRange(aOutline.getB2DRange()); const drawinglayer::primitive2d::Primitive2DReference aFillHatch( new drawinglayer::primitive2d::FillHatchPrimitive2D( aObjectRange, basegfx::BColor(), std::move(aAttribute))); rTargetHolders.Current().append( new drawinglayer::primitive2d::MaskPrimitive2D( std::move(aOutline), drawinglayer::primitive2d::Primitive2DContainer { aFillHatch })); } break; } case MetaActionType::WALLPAPER : { /** CHECKED, WORKS WELL */ const MetaWallpaperAction* pA = static_cast<const MetaWallpaperAction*>(pAction); tools::Rectangle aWallpaperRectangle(pA->GetRect()); if(!aWallpaperRectangle.IsEmpty()) { const Wallpaper& rWallpaper = pA->GetWallpaper(); const WallpaperStyle eWallpaperStyle(rWallpaper.GetStyle()); basegfx::B2DRange aWallpaperRange = vcl::unotools::b2DRectangleFromRectangle(aWallp if(WallpaperStyle::NONE != eWallpaperStyle) { if(rWallpaper.IsBitmap()) { // create bitmap background. Caution: This // also will create gradient/color background(s) // when the bitmap is transparent or not tiled CreateAndAppendBitmapWallpaper( aWallpaperRange, rWallpaper, rTargetHolders.Current(), rPropertyHolders.Current()); } else if(rWallpaper.IsGradient()) { // create gradient background rTargetHolders.Current().append( CreateGradientWallpaper( aWallpaperRange, rWallpaper.GetGradient(), rPropertyHolders.Current())); } else if(!rWallpaper.GetColor().IsTransparent()) { // create color background rTargetHolders.Current().append( CreateColorWallpaper( aWallpaperRange, rWallpaper.GetColor().getBColor(), rPropertyHolders.Current())); } } } break; } case MetaActionType::CLIPREGION : { /** CHECKED, WORKS WELL */ const MetaClipRegionAction* pA = static_cast<const MetaClipRegionAction*>(pAction); if(pA->IsClipping()) { // new clipping. Get tools::PolyPolygon and transform with current transformation basegfx::B2DPolyPolygon aNewClipPolyPolygon(getB2DPolyPolygonFromRegion(pA->GetReg aNewClipPolyPolygon.transform(rPropertyHolders.Current().getTransformation()); HandleNewClipRegion(aNewClipPolyPolygon, rTargetHolders, rPropertyHolders); } else { // end clipping const basegfx::B2DPolyPolygon aEmptyPolyPolygon; HandleNewClipRegion(aEmptyPolyPolygon, rTargetHolders, rPropertyHolders); } break; } case MetaActionType::ISECTRECTCLIPREGION : { /** CHECKED, WORKS WELL */ const MetaISectRectClipRegionAction* pA = static_cast<const MetaISectRectClipRegionAct const tools::Rectangle& rRectangle = pA->GetRect(); if(rRectangle.IsEmpty()) { // intersect with empty rectangle will always give empty // ClipPolyPolygon; start new clipping with empty PolyPolygon const basegfx::B2DPolyPolygon aEmptyPolyPolygon; HandleNewClipRegion(aEmptyPolyPolygon, rTargetHolders, rPropertyHolders); } else { // create transformed ClipRange basegfx::B2DRange aClipRange = vcl::unotools::b2DRectangleFromRectangle(rRectangle) aClipRange.transform(rPropertyHolders.Current().getTransformation()); if(rPropertyHolders.Current().getClipPolyPolygonActive()) { if(0 == rPropertyHolders.Current().getClipPolyPolygon().count()) { // nothing to do, empty active clipPolyPolygon will stay // empty when intersecting } else { // AND existing region and new ClipRange const basegfx::B2DPolyPolygon aOriginalPolyPolygon( rPropertyHolders.Current().getClipPolyPolygon()); basegfx::B2DPolyPolygon aClippedPolyPolygon; if(aOriginalPolyPolygon.count()) { aClippedPolyPolygon = basegfx::utils::clipPolyPolygonOnRange( aOriginalPolyPolygon, aClipRange, true, false); } if(aClippedPolyPolygon != aOriginalPolyPolygon) { // start new clipping with intersected region HandleNewClipRegion( aClippedPolyPolygon, rTargetHolders, rPropertyHolders); } } } else { // start new clipping with ClipRange const basegfx::B2DPolyPolygon aNewClipPolyPolygon( basegfx::utils::createPolygonFromRect(aClipRange)); HandleNewClipRegion(aNewClipPolyPolygon, rTargetHolders, rPropertyHolders); } } break; } case MetaActionType::ISECTREGIONCLIPREGION : { /** CHECKED, WORKS WELL */ const MetaISectRegionClipRegionAction* pA = static_cast<const MetaISectRegionClipRegio const vcl::Region& rNewRegion = pA->GetRegion(); if(rNewRegion.IsEmpty()) { // intersect with empty region will always give empty // region; start new clipping with empty PolyPolygon const basegfx::B2DPolyPolygon aEmptyPolyPolygon; HandleNewClipRegion(aEmptyPolyPolygon, rTargetHolders, rPropertyHolders); } else { // get new ClipPolyPolygon, transform it with current transformation basegfx::B2DPolyPolygon aNewClipPolyPolygon(getB2DPolyPolygonFromRegion(rNewRegio aNewClipPolyPolygon.transform(rPropertyHolders.Current().getTransformation()); if(rPropertyHolders.Current().getClipPolyPolygonActive()) { if(0 == rPropertyHolders.Current().getClipPolyPolygon().count()) { // nothing to do, empty active clipPolyPolygon will stay empty // when intersecting with any region } else { // AND existing and new region const basegfx::B2DPolyPolygon aOriginalPolyPolygon( rPropertyHolders.Current().getClipPolyPolygon()); basegfx::B2DPolyPolygon aClippedPolyPolygon; if(aOriginalPolyPolygon.count()) { aClippedPolyPolygon = basegfx::utils::clipPolyPolygonOnPolyPolygon( aOriginalPolyPolygon, aNewClipPolyPolygon, true, false); } if(aClippedPolyPolygon != aOriginalPolyPolygon) { // start new clipping with intersected ClipPolyPolygon HandleNewClipRegion(aClippedPolyPolygon, rTargetHolders, rPropertyHolders); } } } else { // start new clipping with new ClipPolyPolygon HandleNewClipRegion(aNewClipPolyPolygon, rTargetHolders, rPropertyHolders); } } break; } case MetaActionType::MOVECLIPREGION : { /** CHECKED, WORKS WELL */ const MetaMoveClipRegionAction* pA = static_cast<const MetaMoveClipRegionAction*>(pActi if(rPropertyHolders.Current().getClipPolyPolygonActive()) { if(0 == rPropertyHolders.Current().getClipPolyPolygon().count()) { // nothing to do } else { const sal_Int32 nHor(pA->GetHorzMove()); const sal_Int32 nVer(pA->GetVertMove()); if(0 != nHor || 0 != nVer) { // prepare translation, add current transformation basegfx::B2DVector aVector(pA->GetHorzMove(), pA->GetVertMove()); aVector *= rPropertyHolders.Current().getTransformation(); // transform existing region basegfx::B2DPolyPolygon aClipPolyPolygon( rPropertyHolders.Current().getClipPolyPolygon()); aClipPolyPolygon.translate(aVector); HandleNewClipRegion(aClipPolyPolygon, rTargetHolders, rPropertyHolders); } } } break; } case MetaActionType::LINECOLOR : { /** CHECKED, WORKS WELL */ const MetaLineColorAction* pA = static_cast<const MetaLineColorAction*>(pAction); // tdf#89901 do as OutDev does: COL_TRANSPARENT deactivates line draw const bool bActive(pA->IsSetting() && COL_TRANSPARENT != pA->GetColor()); rPropertyHolders.Current().setLineColorActive(bActive); if(bActive) rPropertyHolders.Current().setLineColor(pA->GetColor().getBColor()); break; } case MetaActionType::FILLCOLOR : { /** CHECKED, WORKS WELL */ const MetaFillColorAction* pA = static_cast<const MetaFillColorAction*>(pAction); // tdf#89901 do as OutDev does: COL_TRANSPARENT deactivates polygon fill const bool bActive(pA->IsSetting() && COL_TRANSPARENT != pA->GetColor()); rPropertyHolders.Current().setFillColorActive(bActive); if(bActive) rPropertyHolders.Current().setFillColor(pA->GetColor().getBColor()); break; } case MetaActionType::TEXTCOLOR : { /** SIMPLE, DONE */ const MetaTextColorAction* pA = static_cast<const MetaTextColorAction*>(pAction); const bool bActivate(COL_TRANSPARENT != pA->GetColor()); rPropertyHolders.Current().setTextColorActive(bActivate); rPropertyHolders.Current().setTextColor(pA->GetColor().getBColor()); break; } case MetaActionType::TEXTFILLCOLOR : { /** SIMPLE, DONE */ const MetaTextFillColorAction* pA = static_cast<const MetaTextFillColorAction*>(pAction const bool bWithColorArgument(pA->IsSetting()); if(bWithColorArgument) { // emulate OutputDevice::SetTextFillColor(...) WITH argument const Color& rFontFillColor = pA->GetColor(); rPropertyHolders.Current().setTextFillColor(rFontFillColor.getBColor()); rPropertyHolders.Current().setTextFillColorActive(COL_TRANSPARENT != rFontFillColo } else { // emulate SetFillColor() <- NO argument (!) rPropertyHolders.Current().setTextFillColorActive(false); } break; } case MetaActionType::TEXTALIGN : { /** SIMPLE, DONE */ const MetaTextAlignAction* pA = static_cast<const MetaTextAlignAction*>(pAction); const TextAlign aNewTextAlign = pA->GetTextAlign(); // TextAlign is applied to the current font (as in // OutputDevice::SetTextAlign which would be used when // playing the Metafile) if(rPropertyHolders.Current().getFont().GetAlignment() != aNewTextAlign) { vcl::Font aNewFont(rPropertyHolders.Current().getFont()); aNewFont.SetAlignment(aNewTextAlign); rPropertyHolders.Current().setFont(aNewFont); } break; } case MetaActionType::MAPMODE : { /** CHECKED, WORKS WELL */ // the most necessary MapMode to be interpreted is MapUnit::MapRelative, // but also the others may occur. Even not yet supported ones // may need to be added here later const MetaMapModeAction* pA = static_cast<const MetaMapModeAction*>(pAction); const MapMode& rMapMode = pA->GetMapMode(); basegfx::B2DHomMatrix aMapping; if(MapUnit::MapRelative == rMapMode.GetMapUnit()) { aMapping = getTransformFromMapMode(rMapMode); } else { const auto eFrom = MapToO3tlLength(rPropertyHolders.Current().getMapUnit()), eTo = MapToO3tlLength(rMapMode.GetMapUnit()); if (eFrom != o3tl::Length::invalid && eTo != o3tl::Length::invalid) { const double fConvert(o3tl::convert(1.0, eFrom, eTo)); aMapping.scale(fConvert, fConvert); } else OSL_FAIL("implInterpretMetafile: MetaActionType::MAPMODE with unsupported MapUnit (!) aMapping = getTransformFromMapMode(rMapMode) * aMapping; rPropertyHolders.Current().setMapUnit(rMapMode.GetMapUnit()); } if(!aMapping.isIdentity()) { aMapping = aMapping * rPropertyHolders.Current().getTransformation(); rPropertyHolders.Current().setTransformation(aMapping); } break; } case MetaActionType::FONT : { /** SIMPLE, DONE */ const MetaFontAction* pA = static_cast<const MetaFontAction*>(pAction); rPropertyHolders.Current().setFont(pA->GetFont()); Size aFontSize(pA->GetFont().GetFontSize()); if(0 == aFontSize.Height()) { // this should not happen but i got Metafiles where this was the // case. A height needs to be guessed (similar to OutputDevice::ImplNewFont()) vcl::Font aCorrectedFont(pA->GetFont()); // guess 16 pixel (as in VCL) aFontSize = Size(0, 16); // convert to target MapUnit if not pixels aFontSize = OutputDevice::LogicToLogic( aFontSize, MapMode(MapUnit::MapPixel), MapMode(rPropertyHolders.Current().getMapUn aCorrectedFont.SetFontSize(aFontSize); rPropertyHolders.Current().setFont(aCorrectedFont); } // older Metafiles have no MetaActionType::TEXTCOLOR which defines // the FontColor now, so use the Font's color when not transparent const Color& rFontColor = pA->GetFont().GetColor(); const bool bActivate(COL_TRANSPARENT != rFontColor); if(bActivate) { rPropertyHolders.Current().setTextColor(rFontColor.getBColor()); } // caution: do NOT deactivate here on transparent, see // OutputDevice::SetFont(..) for more info // rPropertyHolders.Current().setTextColorActive(bActivate); // for fill color emulate a MetaTextFillColorAction with !transparent as bool, // see OutputDevice::SetFont(..) the if(mpMetaFile) case if(bActivate) { const Color& rFontFillColor = pA->GetFont().GetFillColor(); rPropertyHolders.Current().setTextFillColor(rFontFillColor.getBColor()); rPropertyHolders.Current().setTextFillColorActive(COL_TRANSPARENT != rFontFillColo } else { rPropertyHolders.Current().setTextFillColorActive(false); } break; } case MetaActionType::PUSH : { /** CHECKED, WORKS WELL */ const MetaPushAction* pA = static_cast<const MetaPushAction*>(pAction); rPropertyHolders.Push(pA->GetFlags()); break; } case MetaActionType::POP : { /** CHECKED, WORKS WELL */ const bool bRegionMayChange(rPropertyHolders.Current().getPushFlags() & vcl::Pus const bool bRasterOpMayChange(rPropertyHolders.Current().getPushFlags() & vcl::P if(bRegionMayChange && rPropertyHolders.Current().getClipPolyPolygonActive()) { // end evtl. clipping const basegfx::B2DPolyPolygon aEmptyPolyPolygon; HandleNewClipRegion(aEmptyPolyPolygon, rTargetHolders, rPropertyHolders); } if(bRasterOpMayChange && rPropertyHolders.Current().isRasterOpActive()) { // end evtl. RasterOp HandleNewRasterOp(RasterOp::OverPaint, rTargetHolders, rPropertyHolders); } rPropertyHolders.Pop(); if(bRasterOpMayChange && rPropertyHolders.Current().isRasterOpActive()) { // start evtl. RasterOp HandleNewRasterOp(rPropertyHolders.Current().getRasterOp(), rTargetHolders, rPrope } if(bRegionMayChange && rPropertyHolders.Current().getClipPolyPolygonActive()) { // start evtl. clipping HandleNewClipRegion( rPropertyHolders.Current().getClipPolyPolygon(), rTargetHolders, rPropertyHolders) } break; } case MetaActionType::RASTEROP : { /** CHECKED, WORKS WELL */ const MetaRasterOpAction* pA = static_cast<const MetaRasterOpAction*>(pAction); const RasterOp aRasterOp = pA->GetRasterOp(); HandleNewRasterOp(aRasterOp, rTargetHolders, rPropertyHolders); break; } case MetaActionType::Transparent : { /** CHECKED, WORKS WELL */ const MetaTransparentAction* pA = static_cast<const MetaTransparentAction*>(pAction); const basegfx::B2DPolyPolygon aOutline(pA->GetPolyPolygon().getB2DPolyPolygon()); if(aOutline.count()) { const sal_uInt16 nTransparence(pA->GetTransparence()); if(0 == nTransparence) { // not transparent createHairlineAndFillPrimitive(aOutline, rTargetHolders.Current(), rPropertyHolder } else if(nTransparence >= 100) { // fully or more than transparent } else { // transparent. Create new target rTargetHolders.Push(); // create primitives there and get them createHairlineAndFillPrimitive(aOutline, rTargetHolders.Current(), rPropertyHolder drawinglayer::primitive2d::Primitive2DContainer aSubContent( rTargetHolders.Current().getPrimitive2DSequence(rPropertyHolders.Current())); // back to old target rTargetHolders.Pop(); if(!aSubContent.empty()) { rTargetHolders.Current().append( new drawinglayer::primitive2d::UnifiedTransparencePrimitive2D( std::move(aSubContent), nTransparence * 0.01)); } } } break; } case MetaActionType::EPS : { /** CHECKED, WORKS WELL */ // To support this action, I have added a EpsPrimitive2D which will // by default decompose to the Metafile replacement data. To support // this EPS on screen, the renderer visualizing this has to support // that primitive and visualize the Eps file (e.g. printing) const MetaEPSAction* pA = static_cast<const MetaEPSAction*>(pAction); const tools::Rectangle aRectangle(pA->GetPoint(), pA->GetSize()); if(!aRectangle.IsEmpty()) { // create object transform basegfx::B2DHomMatrix aObjectTransform; aObjectTransform.set(0, 0, aRectangle.GetWidth()); aObjectTransform.set(1, 1, aRectangle.GetHeight()); aObjectTransform.set(0, 2, aRectangle.Left()); aObjectTransform.set(1, 2, aRectangle.Top()); // add current transformation aObjectTransform = rPropertyHolders.Current().getTransformation() * aObjectTransform // embed using EpsPrimitive rTargetHolders.Current().append( new drawinglayer::primitive2d::EpsPrimitive2D( aObjectTransform, pA->GetLink(), pA->GetSubstitute())); } break; } case MetaActionType::REFPOINT : { /** SIMPLE, DONE */ // only used for hatch and line pattern offsets, pretty much no longer // supported today // const MetaRefPointAction* pA = (const MetaRefPointAction*)pAction; break; } case MetaActionType::TEXTLINECOLOR : { /** SIMPLE, DONE */ const MetaTextLineColorAction* pA = static_cast<const MetaTextLineColorAction*>(pAction const bool bActive(pA->IsSetting()); rPropertyHolders.Current().setTextLineColorActive(bActive); if(bActive) rPropertyHolders.Current().setTextLineColor(pA->GetColor().getBColor()); break; } case MetaActionType::TEXTLINE : { /** CHECKED, WORKS WELL */ // actually creates overline, underline and strikeouts, so // these should be isolated from TextDecoratedPortionPrimitive2D // to own primitives. Done, available now. // // This Metaaction seems not to be used (was not used in any // checked files). It's used in combination with the current // Font. const MetaTextLineAction* pA = static_cast<const MetaTextLineAction*>(pAction); processMetaTextLineAction( *pA, rTargetHolders.Current(), rPropertyHolders.Current()); break; } case MetaActionType::FLOATTRANSPARENT : { /** CHECKED, WORKS WELL */ const MetaFloatTransparentAction* pA = static_cast<const MetaFloatTransparentAction*>(p const basegfx::B2DRange aTargetRange( pA->GetPoint().X(), pA->GetPoint().Y(), pA->GetPoint().X() + pA->GetSize().Width(), pA->GetPoint().Y() + pA->GetSize().Height()); if(!aTargetRange.isEmpty()) { const GDIMetaFile& rContent = pA->GetGDIMetaFile(); if(rContent.GetActionSize()) { // create the sub-content with no embedding specific to the // sub-metafile, this seems not to be used. drawinglayer::primitive2d::Primitive2DContainer xSubContent; { rTargetHolders.Push(); // #i# for sub-Mteafile contents, do start with new, default render state rPropertyHolders.PushDefault(); implInterpretMetafile(rContent, rTargetHolders, rPropertyHolders, rViewInformation) xSubContent = rTargetHolders.Current().getPrimitive2DSequence(rPropertyHolders.Cur rPropertyHolders.Pop(); rTargetHolders.Pop(); } if(!xSubContent.empty()) { // prepare sub-content transform basegfx::B2DHomMatrix aSubTransform; // create SourceRange const basegfx::B2DRange aSourceRange( rContent.GetPrefMapMode().GetOrigin().X(), rContent.GetPrefMapMode().GetOrigin().Y(), rContent.GetPrefMapMode().GetOrigin().X() + rContent.GetPrefSize().Width(), rContent.GetPrefMapMode().GetOrigin().Y() + rContent.GetPrefSize().Height()); // apply mapping if aTargetRange and aSourceRange are not equal if(!aSourceRange.equal(aTargetRange)) { aSubTransform.translate(-aSourceRange.getMinX(), -aSourceRange.getMinY()); aSubTransform.scale( aTargetRange.getWidth() / (basegfx::fTools::equalZero(aSourceRange.getWidth()) ? 1.0 aTargetRange.getHeight() / (basegfx::fTools::equalZero(aSourceRange.getHeight()) ? 1 aSubTransform.translate(aTargetRange.getMinX(), aTargetRange.getMinY()); } // apply general current transformation aSubTransform = rPropertyHolders.Current().getTransformation() * aSubTransform; // evtl. embed sub-content to its transformation if(!aSubTransform.isIdentity()) { const drawinglayer::primitive2d::Primitive2DReference aEmbeddedTransform( new drawinglayer::primitive2d::TransformPrimitive2D( aSubTransform, std::move(xSubContent))); xSubContent = drawinglayer::primitive2d::Primitive2DContainer { aEmbeddedTransform }; } // check if gradient is a real gradient const Gradient& rGradient = pA->GetGradient(); drawinglayer::attribute::FillGradientAttribute aAttribute(createFillGradientAttri basegfx::BColor aSingleColor; if (aAttribute.getColorStops().isSingleColor(aSingleColor)) { // not really a gradient; create UnifiedTransparencePrimitive2D rTargetHolders.Current().append( new drawinglayer::primitive2d::UnifiedTransparencePrimitive2D( std::move(xSubContent), aSingleColor.luminance())); } else { // really a gradient. Create gradient sub-content (with correct scaling) basegfx::B2DRange aRange(aTargetRange); aRange.transform(rPropertyHolders.Current().getTransformation()); // prepare gradient for transparent content const drawinglayer::primitive2d::Primitive2DReference xTransparence( new drawinglayer::primitive2d::FillGradientPrimitive2D( aRange, std::move(aAttribute))); // create transparence primitive rTargetHolders.Current().append( new drawinglayer::primitive2d::TransparencePrimitive2D( std::move(xSubContent), drawinglayer::primitive2d::Primitive2DContainer { xTransparence })); } } } } break; } case MetaActionType::GRADIENTEX : { /** SIMPLE, DONE */ // This is only a data holder which is interpreted inside comment actions, // see MetaActionType::COMMENT for more info // const MetaGradientExAction* pA = (const MetaGradientExAction*)pAction; break; } case MetaActionType::LAYOUTMODE : { /** SIMPLE, DONE */ const MetaLayoutModeAction* pA = static_cast<const MetaLayoutModeAction*>(pAction); rPropertyHolders.Current().setLayoutMode(pA->GetLayoutMode()); break; } case MetaActionType::TEXTLANGUAGE : { /** SIMPLE, DONE */ const MetaTextLanguageAction* pA = static_cast<const MetaTextLanguageAction*>(pAction); rPropertyHolders.Current().setLanguageType(pA->GetTextLanguage()); break; } case MetaActionType::OVERLINECOLOR : { /** SIMPLE, DONE */ const MetaOverlineColorAction* pA = static_cast<const MetaOverlineColorAction*>(pAction const bool bActive(pA->IsSetting()); rPropertyHolders.Current().setOverlineColorActive(bActive); if(bActive) rPropertyHolders.Current().setOverlineColor(pA->GetColor().getBColor()); break; } case MetaActionType::COMMENT : { /** CHECKED, WORKS WELL */ // I already implemented // XPATHFILL_SEQ_BEGIN, XPATHFILL_SEQ_END // XPATHSTROKE_SEQ_BEGIN, XPATHSTROKE_SEQ_END, // but opted to remove these again; it works well without them // and makes the code less dependent from those Metafile Add-Ons const MetaCommentAction* pA = static_cast<const MetaCommentAction*>(pAction); if (pA->GetComment().equalsIgnoreAsciiCase("XGRAD_SEQ_BEGIN")) { // XGRAD_SEQ_BEGIN, XGRAD_SEQ_END should be supported since the // pure recorded paint of the gradients uses the XOR paint functionality // ('trick'). This is (and will be) problematic with AntiAliasing, so it's // better to use this info const MetaGradientExAction* pMetaGradientExAction = nullptr; bool bDone(false); size_t b(nAction + 1); for(; !bDone && b < nCount; b++) { pAction = rMetaFile.GetAction(b); if(MetaActionType::GRADIENTEX == pAction->GetType()) { pMetaGradientExAction = static_cast<const MetaGradientExAction*>(pAction); } else if(MetaActionType::COMMENT == pAction->GetType()) { if (static_cast<const MetaCommentAction*>(pAction)->GetComment().equalsIgnoreAsciiCas { bDone = true; } } } if(bDone && pMetaGradientExAction) { // consume actions and skip forward nAction = b - 1; // get geometry data basegfx::B2DPolyPolygon aPolyPolygon(pMetaGradientExAction->GetPolyPolygon().getB2 if(aPolyPolygon.count()) { // transform geometry aPolyPolygon.transform(rPropertyHolders.Current().getTransformation()); // get and check if gradient is a real gradient const Gradient& rGradient = pMetaGradientExAction->GetGradient(); drawinglayer::attribute::FillGradientAttribute aAttribute(createFillGradientAttri basegfx::BColor aSingleColor; if (aAttribute.getColorStops().isSingleColor(aSingleColor)) { // not really a gradient rTargetHolders.Current().append( new drawinglayer::primitive2d::PolyPolygonColorPrimitive2D( std::move(aPolyPolygon), aSingleColor)); } else { // really a gradient rTargetHolders.Current().append( new drawinglayer::primitive2d::PolyPolygonGradientPrimitive2D( aPolyPolygon, std::move(aAttribute))); } } } } else if (pA->GetComment().equalsIgnoreAsciiCase("EMF_PLUS_HEADER_INFO")) { if (aEMFPlus) { // error: should not yet exist SAL_INFO("drawinglayer.emf", "Error: multiple EMF_PLUS_HEADER_INFO"); } else { SAL_INFO("drawinglayer.emf", "EMF+ passed to canvas mtf renderer - header info, size: " << pA->G SvMemoryStream aMemoryStream(const_cast<sal_uInt8 *>(pA->GetData()), pA->GetDataSize(), aEMFPlus.reset( new emfplushelper::EmfPlusHelper( aMemoryStream, rTargetHolders, rPropertyHolders)); } } else if (pA->GetComment().equalsIgnoreAsciiCase("EMF_PLUS")) { if (!aEMFPlus) { // error: should exist SAL_INFO("drawinglayer.emf", "Error: EMF_PLUS before EMF_PLUS_HEADER_INFO"); } else { static int count = -1, limit = 0x7fffffff; if (count == -1) { count = 0; if (char *env = getenv("EMF_PLUS_LIMIT")) { limit = atoi(env); SAL_INFO("drawinglayer.emf", "EMF+ records limit: " << limit); } } SAL_INFO("drawinglayer.emf", "EMF+ passed to canvas mtf renderer, size: " << pA->GetDataSize( if (count < limit) { SvMemoryStream aMemoryStream(const_cast<sal_uInt8 *>(pA->GetData()), pA->GetDataSize(), aEMFPlus->processEmfPlusData( aMemoryStream, rViewInformation); } count++; } } break; } default: { OSL_FAIL("Unknown MetaFile Action (!)"); break; } } } } } namespace wmfemfhelper { drawinglayer::primitive2d::Primitive2DContainer interpretMetafile( const GDIMetaFile& rMetaFile, const drawinglayer::geometry::ViewInformation2D& rViewInformation) { // prepare target and properties; each will have one default entry drawinglayer::primitive2d::Primitive2DContainer xRetval; TargetHolders aTargetHolders; PropertyHolders aPropertyHolders; // set target MapUnit at Properties aPropertyHolders.Current().setMapUnit(rMetaFile.GetPrefMapMode().GetMapUnit()); // interpret the Metafile implInterpretMetafile(rMetaFile, aTargetHolders, aPropertyHolders, rViewInformation // get the content. There should be only one target, as in the start condition, // but iterating will be the right thing to do when some push/pop is not closed while (aTargetHolders.size() > 1) { xRetval.append( aTargetHolders.Current().getPrimitive2DSequence(aPropertyHolders.Current())); aTargetHolders.Pop(); } xRetval.append( aTargetHolders.Current().getPrimitive2DSequence(aPropertyHolders.Current())); return xRetval; } } // end of namespace wmfemfhelper /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
¤ Dauer der Verarbeitung: 0.48 Sekunden (vorverarbeitet am 2026-05-08) ¤*© Formatika GbR, Deutschland |
|
||||||||||||||
2026-05-26