summaryrefslogtreecommitdiffstats
path: root/oox/source/drawingml/fillproperties.cxx
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--oox/source/drawingml/fillproperties.cxx1257
1 files changed, 1257 insertions, 0 deletions
diff --git a/oox/source/drawingml/fillproperties.cxx b/oox/source/drawingml/fillproperties.cxx
new file mode 100644
index 000000000..9ae39b8cf
--- /dev/null
+++ b/oox/source/drawingml/fillproperties.cxx
@@ -0,0 +1,1257 @@
+/* -*- 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 <drawingml/fillproperties.hxx>
+
+#include <iterator>
+
+#include <comphelper/propertyvalue.hxx>
+#include <drawingml/graphicproperties.hxx>
+#include <vcl/graph.hxx>
+#include <vcl/BitmapFilter.hxx>
+#include <vcl/BitmapMonochromeFilter.hxx>
+
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <com/sun/star/awt/Gradient.hpp>
+#include <com/sun/star/text/GraphicCrop.hpp>
+#include <com/sun/star/awt/Size.hpp>
+#include <com/sun/star/drawing/BitmapMode.hpp>
+#include <com/sun/star/drawing/ColorMode.hpp>
+#include <com/sun/star/drawing/FillStyle.hpp>
+#include <com/sun/star/drawing/RectanglePoint.hpp>
+#include <com/sun/star/graphic/XGraphicTransformer.hpp>
+#include <oox/helper/graphichelper.hxx>
+#include <oox/drawingml/drawingmltypes.hxx>
+#include <oox/drawingml/shapepropertymap.hxx>
+#include <drawingml/hatchmap.hxx>
+#include <oox/token/namespaces.hxx>
+#include <oox/token/properties.hxx>
+#include <oox/token/tokens.hxx>
+#include <osl/diagnose.h>
+#include <sal/log.hxx>
+
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::drawing;
+using namespace ::com::sun::star::graphic;
+
+using ::com::sun::star::uno::Reference;
+using ::com::sun::star::uno::Exception;
+using ::com::sun::star::uno::UNO_QUERY_THROW;
+using ::com::sun::star::geometry::IntegerRectangle2D;
+
+namespace oox::drawingml {
+
+namespace {
+
+Reference< XGraphic > lclCheckAndApplyDuotoneTransform(const BlipFillProperties& aBlipProps, uno::Reference<graphic::XGraphic> const & xGraphic,
+ const GraphicHelper& rGraphicHelper, const ::Color nPhClr)
+{
+ if (aBlipProps.maDuotoneColors[0].isUsed() && aBlipProps.maDuotoneColors[1].isUsed())
+ {
+ ::Color nColor1 = aBlipProps.maDuotoneColors[0].getColor( rGraphicHelper, nPhClr );
+ ::Color nColor2 = aBlipProps.maDuotoneColors[1].getColor( rGraphicHelper, nPhClr );
+
+ uno::Reference<graphic::XGraphicTransformer> xTransformer(aBlipProps.mxFillGraphic, uno::UNO_QUERY);
+ if (xTransformer.is())
+ return xTransformer->applyDuotone(xGraphic, sal_Int32(nColor1), sal_Int32(nColor2));
+ }
+ return xGraphic;
+}
+
+Reference< XGraphic > lclRotateGraphic(uno::Reference<graphic::XGraphic> const & xGraphic, Degree10 nRotation)
+{
+ ::Graphic aGraphic(xGraphic);
+ ::Graphic aReturnGraphic;
+
+ assert (aGraphic.GetType() == GraphicType::Bitmap);
+
+ BitmapEx aBitmapEx(aGraphic.GetBitmapEx());
+ const ::Color& aColor = ::Color(0x00);
+ aBitmapEx.Rotate(nRotation, aColor);
+ aReturnGraphic = ::Graphic(aBitmapEx);
+ aReturnGraphic.setOriginURL(aGraphic.getOriginURL());
+
+ return aReturnGraphic.GetXGraphic();
+}
+
+using Quotients = std::tuple<double, double, double, double>;
+Quotients getQuotients(geometry::IntegerRectangle2D aRelRect, double hDiv, double vDiv)
+{
+ return { aRelRect.X1 / hDiv, aRelRect.Y1 / vDiv, aRelRect.X2 / hDiv, aRelRect.Y2 / vDiv };
+}
+
+// ECMA-376 Part 1 20.1.8.55 srcRect (Source Rectangle)
+std::optional<Quotients> CropQuotientsFromSrcRect(geometry::IntegerRectangle2D aSrcRect)
+{
+ aSrcRect.X1 = std::max(aSrcRect.X1, sal_Int32(0));
+ aSrcRect.X2 = std::max(aSrcRect.X2, sal_Int32(0));
+ aSrcRect.Y1 = std::max(aSrcRect.Y1, sal_Int32(0));
+ aSrcRect.Y2 = std::max(aSrcRect.Y2, sal_Int32(0));
+ if (aSrcRect.X1 + aSrcRect.X2 >= 100'000 || aSrcRect.Y1 + aSrcRect.Y2 >= 100'000)
+ return {}; // Cropped everything
+ return getQuotients(aSrcRect, 100'000.0, 100'000.0);
+}
+
+// ECMA-376 Part 1 20.1.8.30 fillRect (Fill Rectangle)
+std::optional<Quotients> CropQuotientsFromFillRect(geometry::IntegerRectangle2D aFillRect)
+{
+ aFillRect.X1 = std::min(aFillRect.X1, sal_Int32(0));
+ aFillRect.X2 = std::min(aFillRect.X2, sal_Int32(0));
+ aFillRect.Y1 = std::min(aFillRect.Y1, sal_Int32(0));
+ aFillRect.Y2 = std::min(aFillRect.Y2, sal_Int32(0));
+ // Negative divisor and negative relative offset give positive value wanted in lclCropGraphic
+ return getQuotients(aFillRect, -100'000.0 + aFillRect.X1 + aFillRect.X2,
+ -100'000.0 + aFillRect.Y1 + aFillRect.Y2);
+}
+
+// Crops a piece of the bitmap. lclCropGraphic doesn't handle growing.
+Reference<XGraphic> lclCropGraphic(uno::Reference<graphic::XGraphic> const& xGraphic,
+ std::optional<Quotients> quotients)
+{
+ ::Graphic aGraphic(xGraphic);
+ assert (aGraphic.GetType() == GraphicType::Bitmap);
+
+ BitmapEx aBitmapEx;
+ if (quotients)
+ {
+ aBitmapEx = aGraphic.GetBitmapEx();
+
+ const Size bmpSize = aBitmapEx.GetSizePixel();
+ const auto& [qx1, qy1, qx2, qy2] = *quotients;
+ const tools::Long l = std::round(bmpSize.Width() * qx1);
+ const tools::Long t = std::round(bmpSize.Height() * qy1);
+ const tools::Long r = std::round(bmpSize.Width() * qx2);
+ const tools::Long b = std::round(bmpSize.Height() * qy2);
+
+ aBitmapEx.Crop({ l, t, bmpSize.Width() - r - 1, bmpSize.Height() - b - 1 });
+ }
+
+ ::Graphic aReturnGraphic(aBitmapEx);
+ aReturnGraphic.setOriginURL(aGraphic.getOriginURL());
+
+ return aReturnGraphic.GetXGraphic();
+}
+
+Reference< XGraphic > lclMirrorGraphic(uno::Reference<graphic::XGraphic> const & xGraphic, bool bFlipH, bool bFlipV)
+{
+ ::Graphic aGraphic(xGraphic);
+ ::Graphic aReturnGraphic;
+
+ assert (aGraphic.GetType() == GraphicType::Bitmap);
+
+ BitmapEx aBitmapEx(aGraphic.GetBitmapEx());
+ BmpMirrorFlags nMirrorFlags = BmpMirrorFlags::NONE;
+
+ if(bFlipH)
+ nMirrorFlags |= BmpMirrorFlags::Horizontal;
+ if(bFlipV)
+ nMirrorFlags |= BmpMirrorFlags::Vertical;
+
+ aBitmapEx.Mirror(nMirrorFlags);
+
+ aReturnGraphic = ::Graphic(aBitmapEx);
+ aReturnGraphic.setOriginURL(aGraphic.getOriginURL());
+
+ return aReturnGraphic.GetXGraphic();
+}
+
+Reference< XGraphic > lclGreysScaleGraphic(uno::Reference<graphic::XGraphic> const & xGraphic)
+{
+ ::Graphic aGraphic(xGraphic);
+ ::Graphic aReturnGraphic;
+
+ assert (aGraphic.GetType() == GraphicType::Bitmap);
+
+ BitmapEx aBitmapEx(aGraphic.GetBitmapEx());
+ aBitmapEx.Convert(BmpConversion::N8BitGreys);
+
+ aReturnGraphic = ::Graphic(aBitmapEx);
+ aReturnGraphic.setOriginURL(aGraphic.getOriginURL());
+
+ return aReturnGraphic.GetXGraphic();
+}
+
+/// Applies the graphic Black&White (Monochrome) effect with the imported threshold
+Reference<XGraphic> lclApplyBlackWhiteEffect(const BlipFillProperties& aBlipProps,
+ const uno::Reference<graphic::XGraphic>& xGraphic)
+{
+ const auto& oBiLevelThreshold = aBlipProps.moBiLevelThreshold;
+ if (oBiLevelThreshold.has())
+ {
+ sal_uInt8 nThreshold
+ = static_cast<sal_uInt8>(oBiLevelThreshold.get() * 255 / MAX_PERCENT);
+
+ ::Graphic aGraphic(xGraphic);
+ ::Graphic aReturnGraphic;
+
+ BitmapEx aBitmapEx(aGraphic.GetBitmapEx());
+ AlphaMask aMask(aBitmapEx.GetAlpha());
+
+ BitmapEx aTmpBmpEx(aBitmapEx.GetBitmap());
+ BitmapFilter::Filter(aTmpBmpEx, BitmapMonochromeFilter{ nThreshold });
+
+ aReturnGraphic = ::Graphic(BitmapEx(aTmpBmpEx.GetBitmap(), aMask));
+ aReturnGraphic.setOriginURL(aGraphic.getOriginURL());
+ return aReturnGraphic.GetXGraphic();
+ }
+ return xGraphic;
+}
+
+Reference< XGraphic > lclCheckAndApplyChangeColorTransform(const BlipFillProperties &aBlipProps, uno::Reference<graphic::XGraphic> const & xGraphic,
+ const GraphicHelper& rGraphicHelper, const ::Color nPhClr)
+{
+ if( aBlipProps.maColorChangeFrom.isUsed() && aBlipProps.maColorChangeTo.isUsed() )
+ {
+ ::Color nFromColor = aBlipProps.maColorChangeFrom.getColor( rGraphicHelper, nPhClr );
+ ::Color nToColor = aBlipProps.maColorChangeTo.getColor( rGraphicHelper, nPhClr );
+ if ( (nFromColor != nToColor) || aBlipProps.maColorChangeTo.hasTransparency() )
+ {
+ sal_Int16 nToTransparence = aBlipProps.maColorChangeTo.getTransparency();
+ sal_Int8 nToAlpha = static_cast< sal_Int8 >( (100 - nToTransparence) * 2.55 );
+
+ sal_uInt8 nTolerance = 9;
+ Graphic aGraphic{ xGraphic };
+ if( aGraphic.IsGfxLink() )
+ {
+ // tdf#149670: Try to guess tolerance depending on image format
+ switch (aGraphic.GetGfxLink().GetType())
+ {
+ case GfxLinkType::NativeJpg:
+ nTolerance = 15;
+ break;
+ case GfxLinkType::NativePng:
+ case GfxLinkType::NativeTif:
+ nTolerance = 1;
+ break;
+ case GfxLinkType::NativeBmp:
+ nTolerance = 0;
+ break;
+ default:
+ break;
+ }
+ }
+
+ uno::Reference<graphic::XGraphicTransformer> xTransformer(aBlipProps.mxFillGraphic, uno::UNO_QUERY);
+ if (xTransformer.is())
+ return xTransformer->colorChange(xGraphic, sal_Int32(nFromColor), nTolerance, sal_Int32(nToColor), nToAlpha);
+ }
+ }
+ return xGraphic;
+}
+
+uno::Reference<graphic::XGraphic> applyBrightnessContrast(uno::Reference<graphic::XGraphic> const & xGraphic, sal_Int32 brightness, sal_Int32 contrast)
+{
+ uno::Reference<graphic::XGraphicTransformer> xTransformer(xGraphic, uno::UNO_QUERY);
+ if (xTransformer.is())
+ return xTransformer->applyBrightnessContrast(xGraphic, brightness, contrast, true);
+ return xGraphic;
+}
+
+BitmapMode lclGetBitmapMode( sal_Int32 nToken )
+{
+ OSL_ASSERT((nToken & sal_Int32(0xFFFF0000))==0);
+ switch( nToken )
+ {
+ case XML_tile: return BitmapMode_REPEAT;
+ case XML_stretch: return BitmapMode_STRETCH;
+ }
+
+ // tdf#128596 Default value is XML_tile for MSO.
+ return BitmapMode_REPEAT;
+}
+
+RectanglePoint lclGetRectanglePoint( sal_Int32 nToken )
+{
+ OSL_ASSERT((nToken & sal_Int32(0xFFFF0000))==0);
+ switch( nToken )
+ {
+ case XML_tl: return RectanglePoint_LEFT_TOP;
+ case XML_t: return RectanglePoint_MIDDLE_TOP;
+ case XML_tr: return RectanglePoint_RIGHT_TOP;
+ case XML_l: return RectanglePoint_LEFT_MIDDLE;
+ case XML_ctr: return RectanglePoint_MIDDLE_MIDDLE;
+ case XML_r: return RectanglePoint_RIGHT_MIDDLE;
+ case XML_bl: return RectanglePoint_LEFT_BOTTOM;
+ case XML_b: return RectanglePoint_MIDDLE_BOTTOM;
+ case XML_br: return RectanglePoint_RIGHT_BOTTOM;
+ }
+ return RectanglePoint_LEFT_TOP;
+}
+
+awt::Size lclGetOriginalSize( const GraphicHelper& rGraphicHelper, const Reference< XGraphic >& rxGraphic )
+{
+ awt::Size aSizeHmm( 0, 0 );
+ try
+ {
+ Reference< beans::XPropertySet > xGraphicPropertySet( rxGraphic, UNO_QUERY_THROW );
+ if( xGraphicPropertySet->getPropertyValue( "Size100thMM" ) >>= aSizeHmm )
+ {
+ if( !aSizeHmm.Width && !aSizeHmm.Height )
+ { // MAPMODE_PIXEL USED :-(
+ awt::Size aSourceSizePixel( 0, 0 );
+ if( xGraphicPropertySet->getPropertyValue( "SizePixel" ) >>= aSourceSizePixel )
+ aSizeHmm = rGraphicHelper.convertScreenPixelToHmm( aSourceSizePixel );
+ }
+ }
+ }
+ catch( Exception& )
+ {
+ }
+ return aSizeHmm;
+}
+
+/**
+ * Looks for a last gradient transition and possibly sets a gradient border
+ * based on that.
+ */
+void extractGradientBorderFromStops(const GradientFillProperties& rGradientProps,
+ const GraphicHelper& rGraphicHelper, ::Color nPhClr,
+ awt::Gradient& rGradient)
+{
+ if (rGradientProps.maGradientStops.size() <= 1)
+ return;
+
+ auto it = rGradientProps.maGradientStops.rbegin();
+ double fLastPos = it->first;
+ Color aLastColor = it->second;
+ ++it;
+ double fLastButOnePos = it->first;
+ Color aLastButOneColor = it->second;
+ if (!aLastColor.equals(aLastButOneColor, rGraphicHelper, nPhClr))
+ return;
+
+ // Last transition has the same color, we can map that to a border.
+ rGradient.Border = rtl::math::round((fLastPos - fLastButOnePos) * 100);
+}
+
+} // namespace
+
+void GradientFillProperties::assignUsed( const GradientFillProperties& rSourceProps )
+{
+ if( !rSourceProps.maGradientStops.empty() )
+ maGradientStops = rSourceProps.maGradientStops;
+ moFillToRect.assignIfUsed( rSourceProps.moFillToRect );
+ moTileRect.assignIfUsed( rSourceProps.moTileRect );
+ moGradientPath.assignIfUsed( rSourceProps.moGradientPath );
+ moShadeAngle.assignIfUsed( rSourceProps.moShadeAngle );
+ moShadeFlip.assignIfUsed( rSourceProps.moShadeFlip );
+ moShadeScaled.assignIfUsed( rSourceProps.moShadeScaled );
+ moRotateWithShape.assignIfUsed( rSourceProps.moRotateWithShape );
+}
+
+void PatternFillProperties::assignUsed( const PatternFillProperties& rSourceProps )
+{
+ maPattFgColor.assignIfUsed( rSourceProps.maPattFgColor );
+ maPattBgColor.assignIfUsed( rSourceProps.maPattBgColor );
+ moPattPreset.assignIfUsed( rSourceProps.moPattPreset );
+}
+
+void BlipFillProperties::assignUsed( const BlipFillProperties& rSourceProps )
+{
+ if(rSourceProps.mxFillGraphic.is())
+ mxFillGraphic = rSourceProps.mxFillGraphic;
+ moBitmapMode.assignIfUsed( rSourceProps.moBitmapMode );
+ moFillRect.assignIfUsed( rSourceProps.moFillRect );
+ moTileOffsetX.assignIfUsed( rSourceProps.moTileOffsetX );
+ moTileOffsetY.assignIfUsed( rSourceProps.moTileOffsetY );
+ moTileScaleX.assignIfUsed( rSourceProps.moTileScaleX );
+ moTileScaleY.assignIfUsed( rSourceProps.moTileScaleY );
+ moTileAlign.assignIfUsed( rSourceProps.moTileAlign );
+ moTileFlip.assignIfUsed( rSourceProps.moTileFlip );
+ moRotateWithShape.assignIfUsed( rSourceProps.moRotateWithShape );
+ moColorEffect.assignIfUsed( rSourceProps.moColorEffect );
+ moBrightness.assignIfUsed( rSourceProps.moBrightness );
+ moContrast.assignIfUsed( rSourceProps.moContrast );
+ moBiLevelThreshold.assignIfUsed( rSourceProps.moBiLevelThreshold );
+ maColorChangeFrom.assignIfUsed( rSourceProps.maColorChangeFrom );
+ maColorChangeTo.assignIfUsed( rSourceProps.maColorChangeTo );
+ maDuotoneColors[0].assignIfUsed( rSourceProps.maDuotoneColors[0] );
+ maDuotoneColors[1].assignIfUsed( rSourceProps.maDuotoneColors[1] );
+ maEffect.assignUsed( rSourceProps.maEffect );
+ moAlphaModFix.assignIfUsed(rSourceProps.moAlphaModFix);
+}
+
+void FillProperties::assignUsed( const FillProperties& rSourceProps )
+{
+ moFillType.assignIfUsed( rSourceProps.moFillType );
+ maFillColor.assignIfUsed( rSourceProps.maFillColor );
+ moUseBgFill.assignIfUsed( rSourceProps.moUseBgFill );
+ maGradientProps.assignUsed( rSourceProps.maGradientProps );
+ maPatternProps.assignUsed( rSourceProps.maPatternProps );
+ maBlipProps.assignUsed( rSourceProps.maBlipProps );
+}
+
+Color FillProperties::getBestSolidColor() const
+{
+ Color aSolidColor;
+ if( moFillType.has() ) switch( moFillType.get() )
+ {
+ case XML_solidFill:
+ aSolidColor = maFillColor;
+ break;
+ case XML_gradFill:
+ if( !maGradientProps.maGradientStops.empty() )
+ {
+ GradientFillProperties::GradientStopMap::const_iterator aGradientStop =
+ maGradientProps.maGradientStops.begin();
+ if (maGradientProps.maGradientStops.size() > 2)
+ ++aGradientStop;
+ aSolidColor = aGradientStop->second;
+ }
+ break;
+ case XML_pattFill:
+ aSolidColor = maPatternProps.maPattBgColor.isUsed() ? maPatternProps.maPattBgColor : maPatternProps.maPattFgColor;
+ break;
+ }
+ return aSolidColor;
+}
+
+void FillProperties::pushToPropMap( ShapePropertyMap& rPropMap,
+ const GraphicHelper& rGraphicHelper, sal_Int32 nShapeRotation, ::Color nPhClr, sal_Int16 nPhClrTheme,
+ bool bFlipH, bool bFlipV, bool bIsCustomShape) const
+{
+ if( !moFillType.has() )
+ return;
+
+ FillStyle eFillStyle = FillStyle_NONE;
+ OSL_ASSERT((moFillType.get() & sal_Int32(0xFFFF0000))==0);
+ switch( moFillType.get() )
+ {
+ case XML_noFill:
+ {
+ eFillStyle = FillStyle_NONE;
+ rPropMap.setProperty(ShapeProperty::FillUseSlideBackground, moUseBgFill.get(false));
+ }
+ break;
+
+ case XML_solidFill:
+ if( maFillColor.isUsed() )
+ {
+ ::Color aFillColor = maFillColor.getColor(rGraphicHelper, nPhClr);
+ rPropMap.setProperty(ShapeProperty::FillColor, aFillColor);
+ if( maFillColor.hasTransparency() )
+ rPropMap.setProperty( ShapeProperty::FillTransparency, maFillColor.getTransparency() );
+
+ if (aFillColor == nPhClr)
+ {
+ rPropMap.setProperty(PROP_FillColorTheme, nPhClrTheme);
+ }
+ else if (maFillColor.getTintOrShade() == 0)
+ {
+ rPropMap.setProperty(PROP_FillColorTheme, maFillColor.getSchemeColorIndex());
+ rPropMap.setProperty(PROP_FillColorLumMod, maFillColor.getLumMod());
+ rPropMap.setProperty(PROP_FillColorLumOff, maFillColor.getLumOff());
+ }
+
+ eFillStyle = FillStyle_SOLID;
+ }
+ break;
+
+ case XML_gradFill:
+ // do not create gradient struct if property is not supported...
+ if( rPropMap.supportsProperty( ShapeProperty::FillGradient ) )
+ {
+ sal_Int32 nEndTrans = 0;
+ sal_Int32 nStartTrans = 0;
+ awt::Gradient aGradient;
+ aGradient.Angle = 900;
+ aGradient.StartIntensity = 100;
+ aGradient.EndIntensity = 100;
+
+ // Old code, values in aGradient overwritten in many cases by newer code below
+ if( maGradientProps.maGradientStops.size() > 1 )
+ {
+ aGradient.StartColor = sal_Int32(maGradientProps.maGradientStops.begin()->second.getColor( rGraphicHelper, nPhClr ));
+ aGradient.EndColor = sal_Int32(maGradientProps.maGradientStops.rbegin()->second.getColor( rGraphicHelper, nPhClr ));
+ if( maGradientProps.maGradientStops.rbegin()->second.hasTransparency() )
+ nEndTrans = maGradientProps.maGradientStops.rbegin()->second.getTransparency()*255/100;
+ if( maGradientProps.maGradientStops.begin()->second.hasTransparency() )
+ nStartTrans = maGradientProps.maGradientStops.begin()->second.getTransparency()*255/100;
+ }
+
+ // "rotate with shape" set to false -> do not rotate
+ if ( !maGradientProps.moRotateWithShape.get( true ) )
+ nShapeRotation = 0;
+
+ if( maGradientProps.moGradientPath.has() )
+ {
+ IntegerRectangle2D aFillToRect = maGradientProps.moFillToRect.get( IntegerRectangle2D( 0, 0, MAX_PERCENT, MAX_PERCENT ) );
+ sal_Int32 nCenterX = (MAX_PERCENT + aFillToRect.X1 - aFillToRect.X2) / 2;
+ aGradient.XOffset = getLimitedValue<sal_Int16, sal_Int32>(
+ nCenterX / PER_PERCENT, 0, 100);
+ sal_Int32 nCenterY = (MAX_PERCENT + aFillToRect.Y1 - aFillToRect.Y2) / 2;
+ aGradient.YOffset = getLimitedValue<sal_Int16, sal_Int32>(
+ nCenterY / PER_PERCENT, 0, 100);
+
+ if( maGradientProps.moGradientPath.get() == XML_circle )
+ {
+ // Style should be radial at least when the horizontal center is at 50%.
+ // Otherwise import as a linear gradient, because it is the most similar to the MSO radial style.
+ aGradient.Style = awt::GradientStyle_LINEAR;
+ if( aGradient.XOffset == 100 && aGradient.YOffset == 100 )
+ aGradient.Angle = 450;
+ else if( aGradient.XOffset == 0 && aGradient.YOffset == 100 )
+ aGradient.Angle = 3150;
+ else if( aGradient.XOffset == 100 && aGradient.YOffset == 0 )
+ aGradient.Angle = 1350;
+ else if( aGradient.XOffset == 0 && aGradient.YOffset == 0 )
+ aGradient.Angle = 2250;
+ else
+ aGradient.Style = awt::GradientStyle_RADIAL;
+ }
+ else
+ {
+ aGradient.Style = awt::GradientStyle_RECT;
+ }
+
+ ::std::swap( aGradient.StartColor, aGradient.EndColor );
+ ::std::swap( nStartTrans, nEndTrans );
+
+ extractGradientBorderFromStops(maGradientProps, rGraphicHelper, nPhClr,
+ aGradient);
+ }
+ else if (!maGradientProps.maGradientStops.empty())
+ {
+ // A copy of the gradient stops for local modification
+ GradientFillProperties::GradientStopMap aGradientStops(maGradientProps.maGradientStops);
+
+ // Add a fake gradient stop at 0% and 100% if necessary, so that the gradient always starts
+ // at 0% and ends at 100%, to make following logic clearer (?).
+ auto a0 = aGradientStops.find( 0.0 );
+ if( a0 == aGradientStops.end() )
+ {
+ // temp variable required
+ Color aFirstColor(aGradientStops.begin()->second);
+ aGradientStops.emplace( 0.0, aFirstColor );
+ }
+
+ auto a1 = aGradientStops.find( 1.0 );
+ if( a1 == aGradientStops.end() )
+ {
+ // ditto
+ Color aLastColor(aGradientStops.rbegin()->second);
+ aGradientStops.emplace( 1.0, aLastColor );
+ }
+
+ // Check if the gradient is symmetric, which we will emulate with an "axial" gradient.
+ bool bSymmetric(true);
+ {
+ GradientFillProperties::GradientStopMap::const_iterator aItA( aGradientStops.begin() );
+ GradientFillProperties::GradientStopMap::const_iterator aItZ(std::prev(aGradientStops.end()));
+ assert(aItZ != aGradientStops.end());
+ while( bSymmetric && aItA->first < aItZ->first )
+ {
+ if (!aItA->second.equals(aItZ->second, rGraphicHelper, nPhClr))
+ bSymmetric = false;
+ else
+ {
+ ++aItA;
+ aItZ = std::prev(aItZ);
+ }
+ }
+ // Don't be fooled if the middlemost stop isn't at 0.5.
+ if( bSymmetric && aItA == aItZ && aItA->first != 0.5 )
+ bSymmetric = false;
+
+ // If symmetric, do the rest of the logic for just a half.
+ if( bSymmetric )
+ {
+ // aItZ already points to the colour for the middle, but insert a fake stop at the
+ // exact middle if necessary.
+ if( aItA->first != aItZ->first )
+ {
+ Color aMiddleColor = aItZ->second;
+ auto a05 = aGradientStops.find( 0.5 );
+
+ if( a05 != aGradientStops.end() )
+ a05->second = aMiddleColor;
+ else
+ aGradientStops.emplace( 0.5, aMiddleColor );
+ }
+ // Drop the rest of the stops
+ while( aGradientStops.rbegin()->first > 0.5 )
+ aGradientStops.erase( aGradientStops.rbegin()->first );
+ }
+ }
+
+ SAL_INFO("oox.drawingml.gradient", "symmetric: " << (bSymmetric ? "YES" : "NO") <<
+ ", number of stops: " << aGradientStops.size());
+ size_t nIndex = 0;
+ for (auto const& gradientStop : aGradientStops)
+ SAL_INFO("oox.drawingml.gradient", " " << nIndex++ << ": " <<
+ gradientStop.first << ": " <<
+ std::hex << sal_Int32(gradientStop.second.getColor( rGraphicHelper, nPhClr )) << std::dec <<
+ "@" << (100 - gradientStop.second.getTransparency()) << "%");
+
+ // Now estimate the simple LO style gradient (only two stops, at n% and 100%, where n ==
+ // the "border") that best emulates the gradient between begin() and prior(end()).
+
+ // First look for the largest segment in the gradient.
+ GradientFillProperties::GradientStopMap::iterator aIt(aGradientStops.begin());
+ double nWidestWidth = -1;
+ GradientFillProperties::GradientStopMap::iterator aWidestSegmentStart;
+ ++aIt;
+ while( aIt != aGradientStops.end() )
+ {
+ if (aIt->first - std::prev(aIt)->first > nWidestWidth)
+ {
+ nWidestWidth = aIt->first - std::prev(aIt)->first;
+ aWidestSegmentStart = std::prev(aIt);
+ }
+ ++aIt;
+ }
+ assert( nWidestWidth > 0 );
+
+ double nBorder = 0;
+ bool bSwap(false);
+
+ // Do we have just two segments, and either one is of uniform colour, or three or more
+ // segments, and the widest one is the first or last one, and is it of uniform colour? If
+ // so, deduce the border from it, and drop that segment.
+ if( aGradientStops.size() == 3 &&
+ aGradientStops.begin()->second.getColor(rGraphicHelper, nPhClr) == std::next(aGradientStops.begin())->second.getColor(rGraphicHelper, nPhClr) &&
+ aGradientStops.begin()->second.getTransparency() == std::next(aGradientStops.begin())->second.getTransparency())
+ {
+ // Two segments, first is uniformly coloured
+ SAL_INFO("oox.drawingml.gradient", "two segments, first is uniformly coloured");
+ nBorder = std::next(aGradientStops.begin())->first - aGradientStops.begin()->first;
+ aGradientStops.erase(aGradientStops.begin());
+ aWidestSegmentStart = aGradientStops.begin();
+ }
+ else if( !bSymmetric &&
+ aGradientStops.size() == 3 &&
+ std::next(aGradientStops.begin())->second.getColor(rGraphicHelper, nPhClr) == std::prev(aGradientStops.end())->second.getColor(rGraphicHelper, nPhClr) &&
+ std::next(aGradientStops.begin())->second.getTransparency() == std::prev(aGradientStops.end())->second.getTransparency())
+ {
+ // Two segments, second is uniformly coloured
+ SAL_INFO("oox.drawingml.gradient", "two segments, second is uniformly coloured");
+ auto aNext = std::next(aGradientStops.begin());
+ auto aPrev = std::prev(aGradientStops.end());
+ assert(aPrev != aGradientStops.end());
+ nBorder = aPrev->first - aNext->first;
+ aGradientStops.erase(aNext);
+ aWidestSegmentStart = aGradientStops.begin();
+ bSwap = true;
+ nShapeRotation = 180*60000 - nShapeRotation;
+ }
+ else if( !bSymmetric &&
+ aGradientStops.size() >= 4 &&
+ aWidestSegmentStart->second.getColor( rGraphicHelper, nPhClr ) == std::next(aWidestSegmentStart)->second.getColor(rGraphicHelper, nPhClr) &&
+ aWidestSegmentStart->second.getTransparency() == std::next(aWidestSegmentStart)->second.getTransparency() &&
+ ( aWidestSegmentStart == aGradientStops.begin() ||
+ std::next(aWidestSegmentStart) == std::prev(aGradientStops.end())))
+ {
+ // Not symmetric, three or more segments, the widest is first or last and is uniformly coloured
+ SAL_INFO("oox.drawingml.gradient", "first or last segment is widest and is uniformly coloured");
+ nBorder = std::next(aWidestSegmentStart)->first - aWidestSegmentStart->first;
+
+ // If it's the last segment that is uniformly coloured, rotate the gradient 180
+ // degrees and swap start and end colours
+ if (std::next(aWidestSegmentStart) == std::prev(aGradientStops.end()))
+ {
+ bSwap = true;
+ nShapeRotation = 180*60000 - nShapeRotation;
+ }
+
+ aGradientStops.erase( aWidestSegmentStart++ );
+
+ // Look for which is widest now
+ aIt = std::next(aGradientStops.begin());
+ nWidestWidth = -1;
+ while( aIt != aGradientStops.end() )
+ {
+ if (aIt->first - std::prev(aIt)->first > nWidestWidth)
+ {
+ nWidestWidth = aIt->first - std::prev(aIt)->first;
+ aWidestSegmentStart = std::prev(aIt);
+ }
+ ++aIt;
+ }
+ }
+ SAL_INFO("oox.drawingml.gradient", "widest segment start: " << aWidestSegmentStart->first << ", border: " << nBorder);
+ assert( (!bSymmetric && !bSwap) || !(bSymmetric && bSwap) );
+
+ // Now we have a potential border and a largest segment. Use those.
+
+ aGradient.Style = bSymmetric ? awt::GradientStyle_AXIAL : awt::GradientStyle_LINEAR;
+ sal_Int32 nShadeAngle = maGradientProps.moShadeAngle.get( 0 );
+ // Adjust for flips
+ if ( bFlipH )
+ nShadeAngle = 180*60000 - nShadeAngle;
+ if ( bFlipV )
+ nShadeAngle = -nShadeAngle;
+ sal_Int32 nDmlAngle = nShadeAngle + nShapeRotation;
+ // convert DrawingML angle (in 1/60000 degrees) to API angle (in 1/10 degrees)
+ aGradient.Angle = static_cast< sal_Int16 >( (8100 - (nDmlAngle / (PER_DEGREE / 10))) % 3600 );
+ Color aStartColor, aEndColor;
+
+ // Make a note where the widest segment stops, because we will try to grow it next.
+ auto aWidestSegmentEnd = std::next(aWidestSegmentStart);
+
+ // Try to grow the widest segment backwards: if a previous segment has the same
+ // color, just different transparency, include it.
+ while (aWidestSegmentStart != aGradientStops.begin())
+ {
+ auto it = std::prev(aWidestSegmentStart);
+ if (it->second.getColor(rGraphicHelper, nPhClr)
+ != aWidestSegmentStart->second.getColor(rGraphicHelper, nPhClr))
+ {
+ break;
+ }
+
+ aWidestSegmentStart = it;
+ }
+
+ // Try to grow the widest segment forward: if a next segment has the same
+ // color, just different transparency, include it.
+ while (aWidestSegmentEnd != std::prev(aGradientStops.end()))
+ {
+ auto it = std::next(aWidestSegmentEnd);
+ if (it->second.getColor(rGraphicHelper, nPhClr)
+ != aWidestSegmentEnd->second.getColor(rGraphicHelper, nPhClr))
+ {
+ break;
+ }
+
+ aWidestSegmentEnd = it;
+ }
+
+ assert(aWidestSegmentEnd != aGradientStops.end());
+
+ if( bSymmetric )
+ {
+ aStartColor = aWidestSegmentEnd->second;
+ aEndColor = aWidestSegmentStart->second;
+ nBorder *= 2;
+ }
+ else if( bSwap )
+ {
+ aStartColor = aWidestSegmentEnd->second;
+ aEndColor = aWidestSegmentStart->second;
+ }
+ else
+ {
+ aStartColor = aWidestSegmentStart->second;
+ aEndColor = aWidestSegmentEnd->second;
+ }
+
+ SAL_INFO("oox.drawingml.gradient", "start color: " << std::hex << sal_Int32(aStartColor.getColor( rGraphicHelper, nPhClr )) << std::dec <<
+ "@" << (100-aStartColor.getTransparency()) << "%"
+ ", end color: " << std::hex << sal_Int32(aEndColor.getColor( rGraphicHelper, nPhClr )) << std::dec <<
+ "@" << (100-aEndColor.getTransparency()) << "%");
+
+ aGradient.StartColor = sal_Int32(aStartColor.getColor( rGraphicHelper, nPhClr ));
+ aGradient.EndColor = sal_Int32(aEndColor.getColor( rGraphicHelper, nPhClr ));
+
+ nStartTrans = aStartColor.hasTransparency() ? aStartColor.getTransparency()*255/100 : 0;
+ nEndTrans = aEndColor.hasTransparency() ? aEndColor.getTransparency()*255/100 : 0;
+
+ aGradient.Border = rtl::math::round(100*nBorder);
+ }
+
+ // push gradient or named gradient to property map
+ if( rPropMap.setProperty( ShapeProperty::FillGradient, aGradient ) )
+ eFillStyle = FillStyle_GRADIENT;
+
+ // push gradient transparency to property map
+ if( nStartTrans != 0 || nEndTrans != 0 )
+ {
+ awt::Gradient aGrad(aGradient);
+ uno::Any aVal;
+ aGrad.EndColor = static_cast<sal_Int32>( nEndTrans | nEndTrans << 8 | nEndTrans << 16 );
+ aGrad.StartColor = static_cast<sal_Int32>( nStartTrans | nStartTrans << 8 | nStartTrans << 16 );
+ aVal <<= aGrad;
+ rPropMap.setProperty( ShapeProperty::GradientTransparency, aGrad );
+ }
+
+ }
+ break;
+
+ case XML_blipFill:
+ // do not start complex graphic transformation if property is not supported...
+ if (maBlipProps.mxFillGraphic.is() && rPropMap.supportsProperty(ShapeProperty::FillBitmap))
+ {
+ uno::Reference<graphic::XGraphic> xGraphic = lclCheckAndApplyDuotoneTransform(maBlipProps, maBlipProps.mxFillGraphic, rGraphicHelper, nPhClr);
+ // TODO: "rotate with shape" is not possible with our current core
+
+ if (xGraphic.is())
+ {
+ if (maBlipProps.moColorEffect.get(XML_TOKEN_INVALID) == XML_grayscl)
+ xGraphic = lclGreysScaleGraphic(xGraphic);
+
+ if (rPropMap.supportsProperty(ShapeProperty::FillBitmapName) &&
+ rPropMap.setProperty(ShapeProperty::FillBitmapName, xGraphic))
+ {
+ eFillStyle = FillStyle_BITMAP;
+ }
+ else if (rPropMap.setProperty(ShapeProperty::FillBitmap, xGraphic))
+ {
+ eFillStyle = FillStyle_BITMAP;
+ }
+ }
+
+ // set other bitmap properties, if bitmap has been inserted into the map
+ if( eFillStyle == FillStyle_BITMAP )
+ {
+ // bitmap mode (single, repeat, stretch)
+ BitmapMode eBitmapMode = lclGetBitmapMode( maBlipProps.moBitmapMode.get( XML_TOKEN_INVALID ) );
+ rPropMap.setProperty( ShapeProperty::FillBitmapMode, eBitmapMode );
+
+ // additional settings for repeated bitmap
+ if( eBitmapMode == BitmapMode_REPEAT )
+ {
+ // anchor position inside bitmap
+ RectanglePoint eRectPoint = lclGetRectanglePoint( maBlipProps.moTileAlign.get( XML_tl ) );
+ rPropMap.setProperty( ShapeProperty::FillBitmapRectanglePoint, eRectPoint );
+
+ awt::Size aOriginalSize = lclGetOriginalSize(rGraphicHelper, maBlipProps.mxFillGraphic);
+ if( (aOriginalSize.Width > 0) && (aOriginalSize.Height > 0) )
+ {
+ // size of one bitmap tile (given as 1/1000 percent of bitmap size), convert to 1/100 mm
+ double fScaleX = maBlipProps.moTileScaleX.get( MAX_PERCENT ) / static_cast< double >( MAX_PERCENT );
+ sal_Int32 nFillBmpSizeX = getLimitedValue< sal_Int32, double >( aOriginalSize.Width * fScaleX, 1, SAL_MAX_INT32 );
+ rPropMap.setProperty( ShapeProperty::FillBitmapSizeX, nFillBmpSizeX );
+ double fScaleY = maBlipProps.moTileScaleY.get( MAX_PERCENT ) / static_cast< double >( MAX_PERCENT );
+ sal_Int32 nFillBmpSizeY = getLimitedValue< sal_Int32, double >( aOriginalSize.Height * fScaleY, 1, SAL_MAX_INT32 );
+ rPropMap.setProperty( ShapeProperty::FillBitmapSizeY, nFillBmpSizeY );
+
+ // offset of the first bitmap tile (given as EMUs), convert to percent
+ sal_Int16 nTileOffsetX = getDoubleIntervalValue< sal_Int16 >( std::round( maBlipProps.moTileOffsetX.get( 0 ) / 3.6 / aOriginalSize.Width ), 0, 100 );
+ rPropMap.setProperty( ShapeProperty::FillBitmapOffsetX, nTileOffsetX );
+ sal_Int16 nTileOffsetY = getDoubleIntervalValue< sal_Int16 >( std::round( maBlipProps.moTileOffsetY.get( 0 ) / 3.6 / aOriginalSize.Height ), 0, 100 );
+ rPropMap.setProperty( ShapeProperty::FillBitmapOffsetY, nTileOffsetY );
+ }
+ }
+ else if ( eBitmapMode == BitmapMode_STRETCH && maBlipProps.moFillRect.has() )
+ {
+ geometry::IntegerRectangle2D aFillRect( maBlipProps.moFillRect.get() );
+ awt::Size aOriginalSize( rGraphicHelper.getOriginalSize( xGraphic ) );
+ if ( aOriginalSize.Width && aOriginalSize.Height )
+ {
+ text::GraphicCrop aGraphCrop( 0, 0, 0, 0 );
+ if ( aFillRect.X1 )
+ aGraphCrop.Left = static_cast< sal_Int32 >( ( static_cast< double >( aOriginalSize.Width ) * aFillRect.X1 ) / 100000 );
+ if ( aFillRect.Y1 )
+ aGraphCrop.Top = static_cast< sal_Int32 >( ( static_cast< double >( aOriginalSize.Height ) * aFillRect.Y1 ) / 100000 );
+ if ( aFillRect.X2 )
+ aGraphCrop.Right = static_cast< sal_Int32 >( ( static_cast< double >( aOriginalSize.Width ) * aFillRect.X2 ) / 100000 );
+ if ( aFillRect.Y2 )
+ aGraphCrop.Bottom = static_cast< sal_Int32 >( ( static_cast< double >( aOriginalSize.Height ) * aFillRect.Y2 ) / 100000 );
+
+ bool bHasCropValues = aGraphCrop.Left != 0 || aGraphCrop.Right !=0 || aGraphCrop.Top != 0 || aGraphCrop.Bottom != 0;
+ // Negative GraphicCrop values means "crop" here.
+ bool bNeedCrop = aGraphCrop.Left <= 0 && aGraphCrop.Right <= 0 && aGraphCrop.Top <= 0 && aGraphCrop.Bottom <= 0;
+
+ if(bIsCustomShape && bHasCropValues && bNeedCrop)
+ {
+ // Physically crop the image
+ // In this case, don't set the PROP_GraphicCrop because that
+ // would lead to applying the crop twice after roundtrip
+ xGraphic = lclCropGraphic(xGraphic, CropQuotientsFromFillRect(aFillRect));
+ if (rPropMap.supportsProperty(ShapeProperty::FillBitmapName))
+ rPropMap.setProperty(ShapeProperty::FillBitmapName, xGraphic);
+ else
+ rPropMap.setProperty(ShapeProperty::FillBitmap, xGraphic);
+ }
+ else
+ rPropMap.setProperty(PROP_GraphicCrop, aGraphCrop);
+ }
+ }
+ }
+
+ if (maBlipProps.moAlphaModFix.has())
+ rPropMap.setProperty(ShapeProperty::FillTransparency, static_cast<sal_Int16>(100 - (maBlipProps.moAlphaModFix.get() / PER_PERCENT)));
+ }
+ break;
+
+ case XML_pattFill:
+ {
+ if( rPropMap.supportsProperty( ShapeProperty::FillHatch ) )
+ {
+ Color aColor( maPatternProps.maPattFgColor );
+ if( aColor.isUsed() && maPatternProps.moPattPreset.has() )
+ {
+ eFillStyle = FillStyle_HATCH;
+ rPropMap.setProperty( ShapeProperty::FillHatch, createHatch( maPatternProps.moPattPreset.get(), aColor.getColor( rGraphicHelper, nPhClr ) ) );
+ if( aColor.hasTransparency() )
+ rPropMap.setProperty( ShapeProperty::FillTransparency, aColor.getTransparency() );
+
+ // Set background color for hatch
+ if(maPatternProps.maPattBgColor.isUsed())
+ {
+ aColor = maPatternProps.maPattBgColor;
+ rPropMap.setProperty( ShapeProperty::FillBackground, aColor.getTransparency() != 100 );
+ rPropMap.setProperty( ShapeProperty::FillColor, aColor.getColor( rGraphicHelper, nPhClr ) );
+ }
+ }
+ else if ( maPatternProps.maPattBgColor.isUsed() )
+ {
+ aColor = maPatternProps.maPattBgColor;
+ rPropMap.setProperty( ShapeProperty::FillColor, aColor.getColor( rGraphicHelper, nPhClr ) );
+ if( aColor.hasTransparency() )
+ rPropMap.setProperty( ShapeProperty::FillTransparency, aColor.getTransparency() );
+ eFillStyle = FillStyle_SOLID;
+ }
+ }
+ }
+ break;
+
+ case XML_grpFill:
+ // todo
+ eFillStyle = FillStyle_NONE;
+ break;
+ }
+
+ // set final fill style property
+ rPropMap.setProperty( ShapeProperty::FillStyle, eFillStyle );
+}
+
+void GraphicProperties::pushToPropMap( PropertyMap& rPropMap, const GraphicHelper& rGraphicHelper, bool bFlipH, bool bFlipV) const
+{
+ sal_Int16 nBrightness = getLimitedValue< sal_Int16, sal_Int32 >( maBlipProps.moBrightness.get( 0 ) / PER_PERCENT, -100, 100 );
+ sal_Int16 nContrast = getLimitedValue< sal_Int16, sal_Int32 >( maBlipProps.moContrast.get( 0 ) / PER_PERCENT, -100, 100 );
+ ColorMode eColorMode = ColorMode_STANDARD;
+
+ switch( maBlipProps.moColorEffect.get( XML_TOKEN_INVALID ) )
+ {
+ case XML_biLevel: eColorMode = ColorMode_MONO; break;
+ case XML_grayscl: eColorMode = ColorMode_GREYS; break;
+ }
+
+ if (maBlipProps.mxFillGraphic.is())
+ {
+ // created transformed graphic
+ uno::Reference<graphic::XGraphic> xGraphic = lclCheckAndApplyChangeColorTransform(maBlipProps, maBlipProps.mxFillGraphic, rGraphicHelper, API_RGB_TRANSPARENT);
+ xGraphic = lclCheckAndApplyDuotoneTransform(maBlipProps, xGraphic, rGraphicHelper, API_RGB_TRANSPARENT);
+
+ if( eColorMode == ColorMode_MONO )
+ {
+ // ColorMode_MONO is the same with MSO's biLevel with 50000 (50%) threshold,
+ // when threshold isn't 50000 bake the effect instead.
+ if( maBlipProps.moBiLevelThreshold.get() != 50000 )
+ {
+ xGraphic = lclApplyBlackWhiteEffect(maBlipProps, xGraphic);
+ eColorMode = ColorMode_STANDARD;
+ }
+ }
+
+ if (eColorMode == ColorMode_STANDARD && nBrightness == 70 && nContrast == -70)
+ {
+ // map MSO 'washout' to our Watermark colormode
+ eColorMode = ColorMode_WATERMARK;
+ nBrightness = 0;
+ nContrast = 0;
+ }
+ else if( nBrightness != 0 && nContrast != 0 )
+ {
+ // MSO uses a different algorithm for contrast+brightness, LO applies contrast before brightness,
+ // while MSO apparently applies half of brightness before contrast and half after. So if only
+ // contrast or brightness need to be altered, the result is the same, but if both are involved,
+ // there's no way to map that, so just force a conversion of the image.
+ xGraphic = applyBrightnessContrast( xGraphic, nBrightness, nContrast );
+ nBrightness = 0;
+ nContrast = 0;
+ }
+
+ // cropping
+ if ( maBlipProps.moClipRect.has() )
+ {
+ geometry::IntegerRectangle2D oClipRect( maBlipProps.moClipRect.get() );
+ awt::Size aOriginalSize( rGraphicHelper.getOriginalSize( xGraphic ) );
+ if ( aOriginalSize.Width && aOriginalSize.Height )
+ {
+ text::GraphicCrop aGraphCrop( 0, 0, 0, 0 );
+ if ( oClipRect.X1 )
+ aGraphCrop.Left = rtl::math::round( ( static_cast< double >( aOriginalSize.Width ) * oClipRect.X1 ) / 100000 );
+ if ( oClipRect.Y1 )
+ aGraphCrop.Top = rtl::math::round( ( static_cast< double >( aOriginalSize.Height ) * oClipRect.Y1 ) / 100000 );
+ if ( oClipRect.X2 )
+ aGraphCrop.Right = rtl::math::round( ( static_cast< double >( aOriginalSize.Width ) * oClipRect.X2 ) / 100000 );
+ if ( oClipRect.Y2 )
+ aGraphCrop.Bottom = rtl::math::round( ( static_cast< double >( aOriginalSize.Height ) * oClipRect.Y2 ) / 100000 );
+ rPropMap.setProperty(PROP_GraphicCrop, aGraphCrop);
+
+ bool bHasCropValues = aGraphCrop.Left != 0 || aGraphCrop.Right !=0 || aGraphCrop.Top != 0 || aGraphCrop.Bottom != 0;
+ // Positive GraphicCrop values means "crop" here.
+ bool bNeedCrop = aGraphCrop.Left >= 0 && aGraphCrop.Right >= 0 && aGraphCrop.Top >= 0 && aGraphCrop.Bottom >= 0;
+
+ if(mbIsCustomShape && bHasCropValues && bNeedCrop)
+ {
+ xGraphic = lclCropGraphic(xGraphic, CropQuotientsFromSrcRect(oClipRect));
+ }
+ }
+ }
+
+ if(mbIsCustomShape)
+ {
+ // it is a cropped graphic.
+ rPropMap.setProperty(PROP_FillStyle, FillStyle_BITMAP);
+ rPropMap.setProperty(PROP_FillBitmapMode, BitmapMode_STRETCH);
+
+ // It is a bitmap filled and rotated graphic.
+ // When custom shape is rotated, bitmap have to be rotated too.
+ if(rPropMap.hasProperty(PROP_RotateAngle))
+ {
+ tools::Long nAngle = rPropMap.getProperty(PROP_RotateAngle).get<tools::Long>();
+ xGraphic = lclRotateGraphic(xGraphic, Degree10(nAngle/10) );
+ }
+
+ // We have not core feature that flips graphic in the shape.
+ // Here we are applying flip property to bitmap directly.
+ if(bFlipH || bFlipV)
+ xGraphic = lclMirrorGraphic(xGraphic, bFlipH, bFlipV );
+
+ if(eColorMode == ColorMode_GREYS)
+ xGraphic = lclGreysScaleGraphic( xGraphic );
+
+ rPropMap.setProperty(PROP_FillBitmap, xGraphic);
+ }
+ else
+ rPropMap.setProperty(PROP_Graphic, xGraphic);
+
+
+ if ( maBlipProps.moAlphaModFix.has() )
+ {
+ rPropMap.setProperty(PROP_Transparency, static_cast<sal_Int16>(100 - (maBlipProps.moAlphaModFix.get() / PER_PERCENT)));
+ }
+ }
+ rPropMap.setProperty(PROP_GraphicColorMode, eColorMode);
+
+ // brightness and contrast
+ if( nBrightness != 0 )
+ rPropMap.setProperty(PROP_AdjustLuminance, nBrightness);
+ if( nContrast != 0 )
+ rPropMap.setProperty(PROP_AdjustContrast, nContrast);
+
+ // Media content
+ if (!m_sMediaPackageURL.isEmpty())
+ {
+ rPropMap.setProperty(PROP_MediaURL, m_sMediaPackageURL);
+ if (m_xMediaStream.is())
+ rPropMap.setProperty(PROP_PrivateStream, m_xMediaStream);
+ }
+}
+
+bool ArtisticEffectProperties::isEmpty() const
+{
+ return msName.isEmpty();
+}
+
+css::beans::PropertyValue ArtisticEffectProperties::getEffect()
+{
+ css::beans::PropertyValue aRet;
+ if( msName.isEmpty() )
+ return aRet;
+
+ css::uno::Sequence< css::beans::PropertyValue > aSeq( maAttribs.size() + 1 );
+ auto pSeq = aSeq.getArray();
+ sal_uInt32 i = 0;
+ for (auto const& attrib : maAttribs)
+ {
+ pSeq[i].Name = attrib.first;
+ pSeq[i].Value = attrib.second;
+ i++;
+ }
+
+ if( mrOleObjectInfo.maEmbeddedData.hasElements() )
+ {
+ css::uno::Sequence< css::beans::PropertyValue > aGraphicSeq{
+ comphelper::makePropertyValue("Id", mrOleObjectInfo.maProgId),
+ comphelper::makePropertyValue("Data", mrOleObjectInfo.maEmbeddedData)
+ };
+
+ pSeq[i].Name = "OriginalGraphic";
+ pSeq[i].Value <<= aGraphicSeq;
+ }
+
+ aRet.Name = msName;
+ aRet.Value <<= aSeq;
+
+ return aRet;
+}
+
+void ArtisticEffectProperties::assignUsed( const ArtisticEffectProperties& rSourceProps )
+{
+ if( !rSourceProps.isEmpty() )
+ {
+ msName = rSourceProps.msName;
+ maAttribs = rSourceProps.maAttribs;
+ }
+}
+
+OUString ArtisticEffectProperties::getEffectString( sal_Int32 nToken )
+{
+ switch( nToken )
+ {
+ // effects
+ case OOX_TOKEN( a14, artisticBlur ): return "artisticBlur";
+ case OOX_TOKEN( a14, artisticCement ): return "artisticCement";
+ case OOX_TOKEN( a14, artisticChalkSketch ): return "artisticChalkSketch";
+ case OOX_TOKEN( a14, artisticCrisscrossEtching ): return "artisticCrisscrossEtching";
+ case OOX_TOKEN( a14, artisticCutout ): return "artisticCutout";
+ case OOX_TOKEN( a14, artisticFilmGrain ): return "artisticFilmGrain";
+ case OOX_TOKEN( a14, artisticGlass ): return "artisticGlass";
+ case OOX_TOKEN( a14, artisticGlowDiffused ): return "artisticGlowDiffused";
+ case OOX_TOKEN( a14, artisticGlowEdges ): return "artisticGlowEdges";
+ case OOX_TOKEN( a14, artisticLightScreen ): return "artisticLightScreen";
+ case OOX_TOKEN( a14, artisticLineDrawing ): return "artisticLineDrawing";
+ case OOX_TOKEN( a14, artisticMarker ): return "artisticMarker";
+ case OOX_TOKEN( a14, artisticMosiaicBubbles ): return "artisticMosiaicBubbles";
+ case OOX_TOKEN( a14, artisticPaintStrokes ): return "artisticPaintStrokes";
+ case OOX_TOKEN( a14, artisticPaintBrush ): return "artisticPaintBrush";
+ case OOX_TOKEN( a14, artisticPastelsSmooth ): return "artisticPastelsSmooth";
+ case OOX_TOKEN( a14, artisticPencilGrayscale ): return "artisticPencilGrayscale";
+ case OOX_TOKEN( a14, artisticPencilSketch ): return "artisticPencilSketch";
+ case OOX_TOKEN( a14, artisticPhotocopy ): return "artisticPhotocopy";
+ case OOX_TOKEN( a14, artisticPlasticWrap ): return "artisticPlasticWrap";
+ case OOX_TOKEN( a14, artisticTexturizer ): return "artisticTexturizer";
+ case OOX_TOKEN( a14, artisticWatercolorSponge ): return "artisticWatercolorSponge";
+ case OOX_TOKEN( a14, brightnessContrast ): return "brightnessContrast";
+ case OOX_TOKEN( a14, colorTemperature ): return "colorTemperature";
+ case OOX_TOKEN( a14, saturation ): return "saturation";
+ case OOX_TOKEN( a14, sharpenSoften ): return "sharpenSoften";
+
+ // attributes
+ case XML_visible: return "visible";
+ case XML_trans: return "trans";
+ case XML_crackSpacing: return "crackSpacing";
+ case XML_pressure: return "pressure";
+ case XML_numberOfShades: return "numberOfShades";
+ case XML_grainSize: return "grainSize";
+ case XML_intensity: return "intensity";
+ case XML_smoothness: return "smoothness";
+ case XML_gridSize: return "gridSize";
+ case XML_pencilSize: return "pencilSize";
+ case XML_size: return "size";
+ case XML_brushSize: return "brushSize";
+ case XML_scaling: return "scaling";
+ case XML_detail: return "detail";
+ case XML_bright: return "bright";
+ case XML_contrast: return "contrast";
+ case XML_colorTemp: return "colorTemp";
+ case XML_sat: return "sat";
+ case XML_amount: return "amount";
+ }
+ SAL_WARN( "oox.drawingml", "ArtisticEffectProperties::getEffectString: unexpected token " << nToken );
+ return OUString();
+}
+
+sal_Int32 ArtisticEffectProperties::getEffectToken( const OUString& sName )
+{
+ // effects
+ if( sName == "artisticBlur" )
+ return XML_artisticBlur;
+ else if( sName == "artisticCement" )
+ return XML_artisticCement;
+ else if( sName == "artisticChalkSketch" )
+ return XML_artisticChalkSketch;
+ else if( sName == "artisticCrisscrossEtching" )
+ return XML_artisticCrisscrossEtching;
+ else if( sName == "artisticCutout" )
+ return XML_artisticCutout;
+ else if( sName == "artisticFilmGrain" )
+ return XML_artisticFilmGrain;
+ else if( sName == "artisticGlass" )
+ return XML_artisticGlass;
+ else if( sName == "artisticGlowDiffused" )
+ return XML_artisticGlowDiffused;
+ else if( sName == "artisticGlowEdges" )
+ return XML_artisticGlowEdges;
+ else if( sName == "artisticLightScreen" )
+ return XML_artisticLightScreen;
+ else if( sName == "artisticLineDrawing" )
+ return XML_artisticLineDrawing;
+ else if( sName == "artisticMarker" )
+ return XML_artisticMarker;
+ else if( sName == "artisticMosiaicBubbles" )
+ return XML_artisticMosiaicBubbles;
+ else if( sName == "artisticPaintStrokes" )
+ return XML_artisticPaintStrokes;
+ else if( sName == "artisticPaintBrush" )
+ return XML_artisticPaintBrush;
+ else if( sName == "artisticPastelsSmooth" )
+ return XML_artisticPastelsSmooth;
+ else if( sName == "artisticPencilGrayscale" )
+ return XML_artisticPencilGrayscale;
+ else if( sName == "artisticPencilSketch" )
+ return XML_artisticPencilSketch;
+ else if( sName == "artisticPhotocopy" )
+ return XML_artisticPhotocopy;
+ else if( sName == "artisticPlasticWrap" )
+ return XML_artisticPlasticWrap;
+ else if( sName == "artisticTexturizer" )
+ return XML_artisticTexturizer;
+ else if( sName == "artisticWatercolorSponge" )
+ return XML_artisticWatercolorSponge;
+ else if( sName == "brightnessContrast" )
+ return XML_brightnessContrast;
+ else if( sName == "colorTemperature" )
+ return XML_colorTemperature;
+ else if( sName == "saturation" )
+ return XML_saturation;
+ else if( sName == "sharpenSoften" )
+ return XML_sharpenSoften;
+
+ // attributes
+ else if( sName == "visible" )
+ return XML_visible;
+ else if( sName == "trans" )
+ return XML_trans;
+ else if( sName == "crackSpacing" )
+ return XML_crackSpacing;
+ else if( sName == "pressure" )
+ return XML_pressure;
+ else if( sName == "numberOfShades" )
+ return XML_numberOfShades;
+ else if( sName == "grainSize" )
+ return XML_grainSize;
+ else if( sName == "intensity" )
+ return XML_intensity;
+ else if( sName == "smoothness" )
+ return XML_smoothness;
+ else if( sName == "gridSize" )
+ return XML_gridSize;
+ else if( sName == "pencilSize" )
+ return XML_pencilSize;
+ else if( sName == "size" )
+ return XML_size;
+ else if( sName == "brushSize" )
+ return XML_brushSize;
+ else if( sName == "scaling" )
+ return XML_scaling;
+ else if( sName == "detail" )
+ return XML_detail;
+ else if( sName == "bright" )
+ return XML_bright;
+ else if( sName == "contrast" )
+ return XML_contrast;
+ else if( sName == "colorTemp" )
+ return XML_colorTemp;
+ else if( sName == "sat" )
+ return XML_sat;
+ else if( sName == "amount" )
+ return XML_amount;
+
+ SAL_WARN( "oox.drawingml", "ArtisticEffectProperties::getEffectToken - unexpected token name: " << sName );
+ return XML_none;
+}
+
+} // namespace oox
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */