888 lines
36 KiB
C++
888 lines
36 KiB
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 "oox/vml/vmlformatting.hxx"
|
|
|
|
#include <com/sun/star/beans/PropertyValue.hpp>
|
|
#include <com/sun/star/beans/XPropertySet.hpp>
|
|
#include <com/sun/star/drawing/EnhancedCustomShapeTextPathMode.hpp>
|
|
#include <com/sun/star/table/ShadowFormat.hpp>
|
|
#include <com/sun/star/text/XTextRange.hpp>
|
|
#include <rtl/strbuf.hxx>
|
|
#include <osl/diagnose.h>
|
|
#include "oox/drawingml/color.hxx"
|
|
#include "oox/drawingml/drawingmltypes.hxx"
|
|
#include "oox/drawingml/fillproperties.hxx"
|
|
#include "oox/drawingml/lineproperties.hxx"
|
|
#include "oox/drawingml/shapepropertymap.hxx"
|
|
#include "oox/helper/attributelist.hxx"
|
|
#include "oox/helper/graphichelper.hxx"
|
|
|
|
namespace oox {
|
|
namespace vml {
|
|
|
|
using namespace ::com::sun::star;
|
|
using namespace ::com::sun::star::geometry;
|
|
|
|
using ::oox::drawingml::Color;
|
|
using ::oox::drawingml::FillProperties;
|
|
using ::oox::drawingml::LineArrowProperties;
|
|
using ::oox::drawingml::LineProperties;
|
|
using ::oox::drawingml::ShapePropertyMap;
|
|
using ::com::sun::star::awt::Point;
|
|
using ::com::sun::star::drawing::PolygonFlags;
|
|
using ::com::sun::star::drawing::PolygonFlags_NORMAL;
|
|
using ::com::sun::star::drawing::PolygonFlags_CONTROL;
|
|
|
|
namespace {
|
|
|
|
bool lclExtractDouble( double& orfValue, sal_Int32& ornEndPos, const OUString& rValue )
|
|
{
|
|
// extract the double value and find start position of unit characters
|
|
rtl_math_ConversionStatus eConvStatus = rtl_math_ConversionStatus_Ok;
|
|
orfValue = ::rtl::math::stringToDouble( rValue, '.', '\0', &eConvStatus, &ornEndPos );
|
|
return eConvStatus == rtl_math_ConversionStatus_Ok;
|
|
}
|
|
|
|
} // namespace
|
|
|
|
bool ConversionHelper::separatePair( OUString& orValue1, OUString& orValue2,
|
|
const OUString& rValue, sal_Unicode cSep )
|
|
{
|
|
sal_Int32 nSepPos = rValue.indexOf( cSep );
|
|
if( nSepPos >= 0 )
|
|
{
|
|
orValue1 = rValue.copy( 0, nSepPos ).trim();
|
|
orValue2 = rValue.copy( nSepPos + 1 ).trim();
|
|
}
|
|
else
|
|
{
|
|
orValue1 = rValue.trim();
|
|
}
|
|
return !orValue1.isEmpty() && !orValue2.isEmpty();
|
|
}
|
|
|
|
bool ConversionHelper::decodeBool( const OUString& rValue )
|
|
{
|
|
sal_Int32 nToken = AttributeConversion::decodeToken( rValue );
|
|
// anything else than 't' or 'true' is considered to be false, as specified
|
|
return (nToken == XML_t) || (nToken == XML_true);
|
|
}
|
|
|
|
double ConversionHelper::decodePercent( const OUString& rValue, double fDefValue )
|
|
{
|
|
if( rValue.isEmpty() )
|
|
return fDefValue;
|
|
|
|
double fValue = 0.0;
|
|
sal_Int32 nEndPos = 0;
|
|
if( !lclExtractDouble( fValue, nEndPos, rValue ) )
|
|
return fDefValue;
|
|
|
|
if( nEndPos == rValue.getLength() )
|
|
return fValue;
|
|
|
|
if( (nEndPos + 1 == rValue.getLength()) && (rValue[ nEndPos ] == '%') )
|
|
return fValue / 100.0;
|
|
|
|
if( (nEndPos + 1 == rValue.getLength()) && (rValue[ nEndPos ] == 'f') )
|
|
return fValue / 65536.0;
|
|
|
|
OSL_FAIL( "ConversionHelper::decodePercent - unknown measure unit" );
|
|
return fDefValue;
|
|
}
|
|
|
|
sal_Int64 ConversionHelper::decodeMeasureToEmu( const GraphicHelper& rGraphicHelper,
|
|
const OUString& rValue, sal_Int32 nRefValue, bool bPixelX, bool bDefaultAsPixel )
|
|
{
|
|
// default for missing values is 0
|
|
if( rValue.isEmpty() )
|
|
return 0;
|
|
|
|
// TODO: according to spec, value may contain "auto"
|
|
if ( rValue == "auto" )
|
|
{
|
|
OSL_FAIL( "ConversionHelper::decodeMeasureToEmu - special value 'auto' must be handled by caller" );
|
|
return nRefValue;
|
|
}
|
|
|
|
// extract the double value and find start position of unit characters
|
|
double fValue = 0.0;
|
|
sal_Int32 nEndPos = 0;
|
|
if( !lclExtractDouble( fValue, nEndPos, rValue ) || (fValue == 0.0) )
|
|
return 0;
|
|
|
|
// process trailing unit, convert to EMU
|
|
OUString aUnit;
|
|
if( (0 < nEndPos) && (nEndPos < rValue.getLength()) )
|
|
aUnit = rValue.copy( nEndPos );
|
|
else if( bDefaultAsPixel )
|
|
aUnit = "px";
|
|
// else default is EMU
|
|
|
|
if( aUnit.getLength() == 2 )
|
|
{
|
|
sal_Unicode cChar1 = aUnit[ 0 ];
|
|
sal_Unicode cChar2 = aUnit[ 1 ];
|
|
if( (cChar1 == 'i') && (cChar2 == 'n') ) // 1 inch = 914,400 EMU
|
|
fValue *= 914400.0;
|
|
else if( (cChar1 == 'c') && (cChar2 == 'm') ) // 1 cm = 360,000 EMU
|
|
fValue *= 360000.0;
|
|
else if( (cChar1 == 'm') && (cChar2 == 'm') ) // 1 mm = 36,000 EMU
|
|
fValue *= 36000.0;
|
|
else if( (cChar1 == 'p') && (cChar2 == 't') ) // 1 point = 1/72 inch = 12,700 EMU
|
|
fValue *= 12700.0;
|
|
else if( (cChar1 == 'p') && (cChar2 == 'c') ) // 1 pica = 1/6 inch = 152,400 EMU
|
|
fValue *= 152400.0;
|
|
else if( (cChar1 == 'p') && (cChar2 == 'x') ) // 1 pixel, dependent on output device
|
|
fValue = static_cast< double >( ::oox::drawingml::convertHmmToEmu(
|
|
bPixelX ?
|
|
rGraphicHelper.convertScreenPixelXToHmm( fValue ) :
|
|
rGraphicHelper.convertScreenPixelYToHmm( fValue ) ) );
|
|
}
|
|
else if( (aUnit.getLength() == 1) && (aUnit[ 0 ] == '%') )
|
|
{
|
|
fValue *= nRefValue / 100.0;
|
|
}
|
|
else if( bDefaultAsPixel || !aUnit.isEmpty() ) // default as EMU and no unit -> do nothing
|
|
{
|
|
OSL_FAIL( "ConversionHelper::decodeMeasureToEmu - unknown measure unit" );
|
|
fValue = nRefValue;
|
|
}
|
|
return static_cast< sal_Int64 >( fValue + 0.5 );
|
|
}
|
|
|
|
sal_Int32 ConversionHelper::decodeMeasureToHmm( const GraphicHelper& rGraphicHelper,
|
|
const OUString& rValue, sal_Int32 nRefValue, bool bPixelX, bool bDefaultAsPixel )
|
|
{
|
|
return ::oox::drawingml::convertEmuToHmm( decodeMeasureToEmu( rGraphicHelper, rValue, nRefValue, bPixelX, bDefaultAsPixel ) );
|
|
}
|
|
|
|
Color ConversionHelper::decodeColor( const GraphicHelper& rGraphicHelper,
|
|
const OptValue< OUString >& roVmlColor, const OptValue< double >& roVmlOpacity,
|
|
sal_Int32 nDefaultRgb, sal_Int32 nPrimaryRgb )
|
|
{
|
|
Color aDmlColor;
|
|
|
|
// convert opacity
|
|
const sal_Int32 DML_FULL_OPAQUE = ::oox::drawingml::MAX_PERCENT;
|
|
double fOpacity = roVmlOpacity.get( 1.0 );
|
|
sal_Int32 nOpacity = getLimitedValue< sal_Int32, double >( fOpacity * DML_FULL_OPAQUE, 0, DML_FULL_OPAQUE );
|
|
if( nOpacity < DML_FULL_OPAQUE )
|
|
aDmlColor.addTransformation( XML_alpha, nOpacity );
|
|
|
|
// color attribute not present - set passed default color
|
|
if( !roVmlColor.has() )
|
|
{
|
|
aDmlColor.setSrgbClr( nDefaultRgb );
|
|
return aDmlColor;
|
|
}
|
|
|
|
// separate leading color name or RGB value from following palette index
|
|
OUString aColorName, aColorIndex;
|
|
separatePair( aColorName, aColorIndex, roVmlColor.get(), ' ' );
|
|
|
|
// RGB colors in the format '#RRGGBB'
|
|
if( (aColorName.getLength() == 7) && (aColorName[ 0 ] == '#') )
|
|
{
|
|
aDmlColor.setSrgbClr( aColorName.copy( 1 ).toUInt32( 16 ) );
|
|
return aDmlColor;
|
|
}
|
|
|
|
// RGB colors in the format '#RGB'
|
|
if( (aColorName.getLength() == 4) && (aColorName[ 0 ] == '#') )
|
|
{
|
|
sal_Int32 nR = aColorName.copy( 1, 1 ).toUInt32( 16 ) * 0x11;
|
|
sal_Int32 nG = aColorName.copy( 2, 1 ).toUInt32( 16 ) * 0x11;
|
|
sal_Int32 nB = aColorName.copy( 3, 1 ).toUInt32( 16 ) * 0x11;
|
|
aDmlColor.setSrgbClr( (nR << 16) | (nG << 8) | nB );
|
|
return aDmlColor;
|
|
}
|
|
|
|
/* Predefined color names or system color names (resolve to RGB to detect
|
|
valid color name). */
|
|
sal_Int32 nColorToken = AttributeConversion::decodeToken( aColorName );
|
|
sal_Int32 nRgbValue = Color::getVmlPresetColor( nColorToken, API_RGB_TRANSPARENT );
|
|
if( nRgbValue == API_RGB_TRANSPARENT )
|
|
nRgbValue = rGraphicHelper.getSystemColor( nColorToken );
|
|
if( nRgbValue != API_RGB_TRANSPARENT )
|
|
{
|
|
aDmlColor.setSrgbClr( nRgbValue );
|
|
return aDmlColor;
|
|
}
|
|
|
|
// try palette colors enclosed in brackets
|
|
if( (aColorIndex.getLength() >= 3) && (aColorIndex[ 0 ] == '[') && (aColorIndex[ aColorIndex.getLength() - 1 ] == ']') )
|
|
{
|
|
aDmlColor.setPaletteClr( aColorIndex.copy( 1, aColorIndex.getLength() - 2 ).toInt32() );
|
|
return aDmlColor;
|
|
}
|
|
|
|
// try fill gradient modificator 'fill <modifier>(<amount>)'
|
|
if( (nPrimaryRgb != API_RGB_TRANSPARENT) && (nColorToken == XML_fill) )
|
|
{
|
|
sal_Int32 nOpenParen = aColorIndex.indexOf( '(' );
|
|
sal_Int32 nCloseParen = aColorIndex.indexOf( ')' );
|
|
if( (2 <= nOpenParen) && (nOpenParen + 1 < nCloseParen) && (nCloseParen + 1 == aColorIndex.getLength()) )
|
|
{
|
|
sal_Int32 nModToken = XML_TOKEN_INVALID;
|
|
switch( AttributeConversion::decodeToken( aColorIndex.copy( 0, nOpenParen ) ) )
|
|
{
|
|
case XML_darken: nModToken = XML_shade;break;
|
|
case XML_lighten: nModToken = XML_tint;
|
|
}
|
|
sal_Int32 nValue = aColorIndex.copy( nOpenParen + 1, nCloseParen - nOpenParen - 1 ).toInt32();
|
|
if( (nModToken != XML_TOKEN_INVALID) && (0 <= nValue) && (nValue < 255) )
|
|
{
|
|
/* Simulate this modifier color by a color with related transformation.
|
|
The modifier amount has to be converted from the range [0;255] to
|
|
percentage [0;100000] used by DrawingML. */
|
|
aDmlColor.setSrgbClr( nPrimaryRgb );
|
|
aDmlColor.addTransformation( nModToken, static_cast< sal_Int32 >( nValue * ::oox::drawingml::MAX_PERCENT / 255 ) );
|
|
return aDmlColor;
|
|
}
|
|
}
|
|
}
|
|
|
|
OSL_FAIL( OStringBuffer( "lclGetColor - invalid VML color name '" ).
|
|
append( OUStringToOString( roVmlColor.get(), RTL_TEXTENCODING_ASCII_US ) ).append( '\'' ).getStr() );
|
|
aDmlColor.setSrgbClr( nDefaultRgb );
|
|
return aDmlColor;
|
|
}
|
|
|
|
void ConversionHelper::decodeVmlPath( ::std::vector< ::std::vector< Point > >& rPointLists, ::std::vector< ::std::vector< PolygonFlags > >& rFlagLists, const OUString& rPath )
|
|
{
|
|
::std::vector< sal_Int32 > aCoordList;
|
|
Point aCurrentPoint;
|
|
sal_Int32 nTokenStart = 0;
|
|
sal_Int32 nTokenLen = 0;
|
|
sal_Int32 nParamCount = 0;
|
|
bool bCommand = false;
|
|
enum VML_State { START, MOVE_REL, MOVE_ABS, BEZIER_REL, BEZIER_ABS,
|
|
LINE_REL, LINE_ABS, CLOSE, END, UNSUPPORTED };
|
|
VML_State state = START;
|
|
|
|
rPointLists.push_back( ::std::vector< Point>() );
|
|
rFlagLists.push_back( ::std::vector< PolygonFlags >() );
|
|
|
|
for ( sal_Int32 i = 0; i < rPath.getLength(); i++ )
|
|
{
|
|
// Keep track of current integer token
|
|
if ( ( rPath[ i ] >= '0' && rPath[ i ] <= '9' ) || rPath[ i ] == '-' )
|
|
nTokenLen++;
|
|
else if ( rPath[ i ] != ' ' )
|
|
{
|
|
// Store coordinate from current token
|
|
if ( state != START && state != UNSUPPORTED )
|
|
{
|
|
if ( nTokenLen > 0 )
|
|
aCoordList.push_back( rPath.copy( nTokenStart, nTokenLen ).toInt32() );
|
|
else
|
|
aCoordList.push_back( 0 );
|
|
nTokenLen = 0;
|
|
}
|
|
|
|
if (rPath[ i ] == ',' )
|
|
{
|
|
nParamCount--;
|
|
}
|
|
|
|
// Upon finding the next command code, deal with stored
|
|
// coordinates for previous command and reset parameters counter if needed.
|
|
// See http://www.w3.org/TR/NOTE-VML#_Toc416858382 for params count reference
|
|
if ( rPath[ i ] != ',' || nParamCount == 0 )
|
|
{
|
|
switch ( state )
|
|
{
|
|
case MOVE_REL: // 2* params -> param count reset
|
|
if ( rPointLists.size() > 0 && rPointLists.back().size() > 0 )
|
|
{
|
|
rPointLists.push_back( ::std::vector< Point >() );
|
|
rFlagLists.push_back( ::std::vector< PolygonFlags >() );
|
|
}
|
|
rPointLists.back().push_back( Point( aCoordList[ 0 ], aCoordList[ 1 ] ) );
|
|
rFlagLists.back().push_back( PolygonFlags_NORMAL );
|
|
aCurrentPoint = rPointLists.back().back();
|
|
nParamCount = 2;
|
|
break;
|
|
|
|
case MOVE_ABS: // 2 params -> no param count reset
|
|
if ( rPointLists.size() > 0 && rPointLists.back().size() > 0 )
|
|
{
|
|
rPointLists.push_back( ::std::vector< Point >() );
|
|
rFlagLists.push_back( ::std::vector< PolygonFlags >() );
|
|
}
|
|
rPointLists.back().push_back( Point( (aCoordList[ 0 ]), (aCoordList.size() > 1 ? aCoordList[ 1 ] : 0) ) );
|
|
rFlagLists.back().push_back( PolygonFlags_NORMAL );
|
|
aCurrentPoint = rPointLists.back().back();
|
|
break;
|
|
|
|
case BEZIER_REL: // 6* params -> param count reset
|
|
rPointLists.back().push_back( Point( aCurrentPoint.X + aCoordList[ 0 ],
|
|
aCurrentPoint.Y + aCoordList[ 1 ] ) );
|
|
rPointLists.back().push_back( Point( aCurrentPoint.X + aCoordList[ 2 ],
|
|
aCurrentPoint.Y + aCoordList[ 3 ] ) );
|
|
rPointLists.back().push_back( Point( aCurrentPoint.X + aCoordList[ 4 ],
|
|
aCurrentPoint.Y + aCoordList[ 5 ] ) );
|
|
rFlagLists.back().push_back( PolygonFlags_CONTROL );
|
|
rFlagLists.back().push_back( PolygonFlags_CONTROL );
|
|
rFlagLists.back().push_back( PolygonFlags_NORMAL );
|
|
aCurrentPoint = rPointLists.back().back();
|
|
nParamCount = 6;
|
|
break;
|
|
|
|
case BEZIER_ABS: // 6* params -> param count reset
|
|
rPointLists.back().push_back( Point( aCoordList[ 0 ], aCoordList[ 1 ] ) );
|
|
rPointLists.back().push_back( Point( aCoordList[ 2 ], aCoordList[ 3 ] ) );
|
|
rPointLists.back().push_back( Point( aCoordList[ 4 ], aCoordList[ 5 ] ) );
|
|
rFlagLists.back().push_back( PolygonFlags_CONTROL );
|
|
rFlagLists.back().push_back( PolygonFlags_CONTROL );
|
|
rFlagLists.back().push_back( PolygonFlags_NORMAL );
|
|
aCurrentPoint = rPointLists.back().back();
|
|
nParamCount = 6;
|
|
break;
|
|
|
|
case LINE_REL: // 2* params -> param count reset
|
|
rPointLists.back().push_back( Point( aCurrentPoint.X + aCoordList[ 0 ],
|
|
aCurrentPoint.Y + aCoordList[ 1 ] ) );
|
|
rFlagLists.back().push_back( PolygonFlags_NORMAL );
|
|
aCurrentPoint = rPointLists.back().back();
|
|
nParamCount = 2;
|
|
break;
|
|
|
|
case LINE_ABS: // 2* params -> param count reset
|
|
rPointLists.back().push_back( Point( aCoordList[ 0 ], (aCoordList.size() > 1 ? aCoordList[ 1 ] : 0) ) );
|
|
rFlagLists.back().push_back( PolygonFlags_NORMAL );
|
|
aCurrentPoint = rPointLists.back().back();
|
|
nParamCount = 2;
|
|
break;
|
|
|
|
case CLOSE: // 0 param
|
|
SAL_WARN_IF(rPointLists.back().empty() || rFlagLists.back().empty(), "oox", "empty pointlists at close");
|
|
if (!rPointLists.back().empty() && !rFlagLists.back().empty())
|
|
{
|
|
rPointLists.back().push_back( rPointLists.back()[ 0 ] );
|
|
rFlagLists.back().push_back( rFlagLists.back()[ 0 ] );
|
|
aCurrentPoint = rPointLists.back().back();
|
|
}
|
|
break;
|
|
|
|
case END: // 0 param
|
|
rPointLists.push_back( ::std::vector< Point >() );
|
|
rFlagLists.push_back( ::std::vector< PolygonFlags >() );
|
|
break;
|
|
|
|
case START:
|
|
case UNSUPPORTED:
|
|
break;
|
|
}
|
|
|
|
aCoordList.clear();
|
|
}
|
|
|
|
// Allow two-char commands to peek ahead to the next character
|
|
char nextChar = '\0';
|
|
if (i+1 < rPath.getLength())
|
|
nextChar = rPath[i+1];
|
|
|
|
// Move to relevant state upon finding a command
|
|
bCommand = true;
|
|
switch ( rPath[ i ] )
|
|
{
|
|
// Single-character commands
|
|
case 't': // rmoveto
|
|
state = MOVE_REL; nParamCount = 2; break;
|
|
case 'm': // moveto
|
|
state = MOVE_ABS; nParamCount = 2; break;
|
|
case 'v': // rcurveto
|
|
state = BEZIER_REL; nParamCount = 6; break;
|
|
case 'c': // curveto
|
|
state = BEZIER_ABS; nParamCount = 6; break;
|
|
case 'r': // rlineto
|
|
state = LINE_REL; nParamCount = 2; break;
|
|
case 'l': // lineto
|
|
state = LINE_ABS; nParamCount = 2; break;
|
|
case 'x': // close
|
|
state = CLOSE; break;
|
|
case 'e': // end
|
|
state = END; break;
|
|
|
|
// Two-character commands
|
|
case 'n':
|
|
{
|
|
switch ( nextChar )
|
|
{
|
|
case 'f': // nf - nofill
|
|
case 's': // ns - nostroke
|
|
state = UNSUPPORTED; i++; break;
|
|
}
|
|
break;
|
|
}
|
|
case 'a': // Elliptical curves
|
|
{
|
|
switch ( nextChar )
|
|
{
|
|
case 'e': // ae - angleellipseto
|
|
case 'l': // al - angleellipse
|
|
state = UNSUPPORTED; i++; break;
|
|
case 't': // at - arcto
|
|
case 'r': // ar - arc
|
|
state = UNSUPPORTED; i++; break;
|
|
}
|
|
break;
|
|
}
|
|
case 'w': // Clockwise elliptical arcs
|
|
{
|
|
switch ( nextChar )
|
|
{
|
|
case 'a': // wa - clockwisearcto
|
|
case 'r': // wr - clockwisearc
|
|
state = UNSUPPORTED; i++; break;
|
|
}
|
|
break;
|
|
}
|
|
case 'q':
|
|
{
|
|
switch ( nextChar )
|
|
{
|
|
case 'x': // qx - ellipticalquadrantx
|
|
case 'y': // qy - ellipticalquadranty
|
|
state = UNSUPPORTED; i++; break;
|
|
case 'b': // qb - quadraticbezier
|
|
state = UNSUPPORTED; i++; break;
|
|
}
|
|
break;
|
|
}
|
|
case 'h': // behaviour extensions
|
|
{
|
|
switch ( nextChar )
|
|
{
|
|
case 'a': // ha - AutoLine
|
|
case 'b': // hb - AutoCurve
|
|
case 'c': // hc - CornerLine
|
|
case 'd': // hd - CornerCurve
|
|
case 'e': // he - SmoothLine
|
|
case 'f': // hf - SmoothCurve
|
|
case 'g': // hg - SymmetricLine
|
|
case 'h': // hh - SymmetricCurve
|
|
case 'i': // hi - Freeform
|
|
state = UNSUPPORTED; i++; break;
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
bCommand = false;
|
|
break;
|
|
}
|
|
|
|
if (bCommand) nTokenLen = 0;
|
|
nTokenStart = i+1;
|
|
}
|
|
}
|
|
}
|
|
|
|
namespace {
|
|
|
|
sal_Int64 lclGetEmu( const GraphicHelper& rGraphicHelper, const OptValue< OUString >& roValue, sal_Int64 nDefValue )
|
|
{
|
|
return roValue.has() ? ConversionHelper::decodeMeasureToEmu( rGraphicHelper, roValue.get(), 0, false, false ) : nDefValue;
|
|
}
|
|
|
|
void lclGetDmlLineDash( OptValue< sal_Int32 >& oroPresetDash, LineProperties::DashStopVector& orCustomDash, const OptValue< OUString >& roDashStyle )
|
|
{
|
|
if( roDashStyle.has() )
|
|
{
|
|
const OUString& rDashStyle = roDashStyle.get();
|
|
switch( AttributeConversion::decodeToken( rDashStyle ) )
|
|
{
|
|
case XML_solid: oroPresetDash = XML_solid; return;
|
|
case XML_shortdot: oroPresetDash = XML_sysDot; return;
|
|
case XML_shortdash: oroPresetDash = XML_sysDash; return;
|
|
case XML_shortdashdot: oroPresetDash = XML_sysDashDot; return;
|
|
case XML_shortdashdotdot: oroPresetDash = XML_sysDashDotDot; return;
|
|
case XML_dot: oroPresetDash = XML_dot; return;
|
|
case XML_dash: oroPresetDash = XML_dash; return;
|
|
case XML_dashdot: oroPresetDash = XML_dashDot; return;
|
|
case XML_longdash: oroPresetDash = XML_lgDash; return;
|
|
case XML_longdashdot: oroPresetDash = XML_lgDashDot; return;
|
|
case XML_longdashdotdot: oroPresetDash = XML_lgDashDotDot; return;
|
|
|
|
// try to convert user-defined dash style
|
|
default:
|
|
{
|
|
::std::vector< sal_Int32 > aValues;
|
|
sal_Int32 nIndex = 0;
|
|
while( nIndex >= 0 )
|
|
aValues.push_back( rDashStyle.getToken( 0, ' ', nIndex ).toInt32() );
|
|
size_t nPairs = aValues.size() / 2; // ignore last value if size is odd
|
|
for( size_t nPairIdx = 0; nPairIdx < nPairs; ++nPairIdx )
|
|
orCustomDash.push_back( LineProperties::DashStop( aValues[ 2 * nPairIdx ], aValues[ 2 * nPairIdx + 1 ] ) );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
sal_Int32 lclGetDmlArrowType( const OptValue< sal_Int32 >& roArrowType )
|
|
{
|
|
if( roArrowType.has() ) switch( roArrowType.get() )
|
|
{
|
|
case XML_none: return XML_none;
|
|
case XML_block: return XML_triangle;
|
|
case XML_classic: return XML_stealth;
|
|
case XML_diamond: return XML_diamond;
|
|
case XML_oval: return XML_oval;
|
|
case XML_open: return XML_arrow;
|
|
}
|
|
return XML_none;
|
|
}
|
|
|
|
sal_Int32 lclGetDmlArrowWidth( const OptValue< sal_Int32 >& roArrowWidth )
|
|
{
|
|
if( roArrowWidth.has() ) switch( roArrowWidth.get() )
|
|
{
|
|
case XML_narrow: return XML_sm;
|
|
case XML_medium: return XML_med;
|
|
case XML_wide: return XML_lg;
|
|
}
|
|
return XML_med;
|
|
}
|
|
|
|
sal_Int32 lclGetDmlArrowLength( const OptValue< sal_Int32 >& roArrowLength )
|
|
{
|
|
if( roArrowLength.has() ) switch( roArrowLength.get() )
|
|
{
|
|
case XML_short: return XML_sm;
|
|
case XML_medium: return XML_med;
|
|
case XML_long: return XML_lg;
|
|
}
|
|
return XML_med;
|
|
}
|
|
|
|
void lclConvertArrow( LineArrowProperties& orArrowProp, const StrokeArrowModel& rStrokeArrow )
|
|
{
|
|
orArrowProp.moArrowType = lclGetDmlArrowType( rStrokeArrow.moArrowType );
|
|
orArrowProp.moArrowWidth = lclGetDmlArrowWidth( rStrokeArrow.moArrowWidth );
|
|
orArrowProp.moArrowLength = lclGetDmlArrowLength( rStrokeArrow.moArrowLength );
|
|
}
|
|
|
|
sal_Int32 lclGetDmlLineCompound( const OptValue< sal_Int32 >& roLineStyle )
|
|
{
|
|
if( roLineStyle.has() ) switch( roLineStyle.get() )
|
|
{
|
|
case XML_single: return XML_sng;
|
|
case XML_thinThin: return XML_dbl;
|
|
case XML_thinThick: return XML_thinThick;
|
|
case XML_thickThin: return XML_thickThin;
|
|
case XML_thickBetweenThin: return XML_tri;
|
|
}
|
|
return XML_sng;
|
|
}
|
|
|
|
sal_Int32 lclGetDmlLineCap( const OptValue< sal_Int32 >& roEndCap )
|
|
{
|
|
if( roEndCap.has() ) switch( roEndCap.get() )
|
|
{
|
|
case XML_flat: return XML_flat;
|
|
case XML_square: return XML_sq;
|
|
case XML_round: return XML_rnd;
|
|
}
|
|
return XML_flat; // different defaults in VML (flat) and DrawingML (square)
|
|
}
|
|
|
|
sal_Int32 lclGetDmlLineJoint( const OptValue< sal_Int32 >& roJoinStyle )
|
|
{
|
|
if( roJoinStyle.has() ) switch( roJoinStyle.get() )
|
|
{
|
|
case XML_round: return XML_round;
|
|
case XML_bevel: return XML_bevel;
|
|
case XML_miter: return XML_miter;
|
|
}
|
|
return XML_round;
|
|
}
|
|
|
|
} // namespace
|
|
|
|
void StrokeArrowModel::assignUsed( const StrokeArrowModel& rSource )
|
|
{
|
|
moArrowType.assignIfUsed( rSource.moArrowType );
|
|
moArrowWidth.assignIfUsed( rSource.moArrowWidth );
|
|
moArrowLength.assignIfUsed( rSource.moArrowLength );
|
|
}
|
|
|
|
void StrokeModel::assignUsed( const StrokeModel& rSource )
|
|
{
|
|
moStroked.assignIfUsed( rSource.moStroked );
|
|
maStartArrow.assignUsed( rSource.maStartArrow );
|
|
maEndArrow.assignUsed( rSource.maEndArrow );
|
|
moColor.assignIfUsed( rSource.moColor );
|
|
moOpacity.assignIfUsed( rSource.moOpacity );
|
|
moWeight.assignIfUsed( rSource.moWeight );
|
|
moDashStyle.assignIfUsed( rSource.moDashStyle );
|
|
moLineStyle.assignIfUsed( rSource.moLineStyle );
|
|
moEndCap.assignIfUsed( rSource.moEndCap );
|
|
moJoinStyle.assignIfUsed( rSource.moJoinStyle );
|
|
}
|
|
|
|
void StrokeModel::pushToPropMap( ShapePropertyMap& rPropMap, const GraphicHelper& rGraphicHelper ) const
|
|
{
|
|
/* Convert VML line formatting to DrawingML line formatting and let the
|
|
DrawingML code do the hard work. */
|
|
LineProperties aLineProps;
|
|
|
|
if( moStroked.get( true ) )
|
|
{
|
|
aLineProps.maLineFill.moFillType = XML_solidFill;
|
|
lclConvertArrow( aLineProps.maStartArrow, maStartArrow );
|
|
lclConvertArrow( aLineProps.maEndArrow, maEndArrow );
|
|
aLineProps.maLineFill.maFillColor = ConversionHelper::decodeColor( rGraphicHelper, moColor, moOpacity, API_RGB_BLACK );
|
|
aLineProps.moLineWidth = getLimitedValue< sal_Int32, sal_Int64 >( lclGetEmu( rGraphicHelper, moWeight, 1 ), 0, SAL_MAX_INT32 );
|
|
lclGetDmlLineDash( aLineProps.moPresetDash, aLineProps.maCustomDash, moDashStyle );
|
|
aLineProps.moLineCompound = lclGetDmlLineCompound( moLineStyle );
|
|
aLineProps.moLineCap = lclGetDmlLineCap( moEndCap );
|
|
aLineProps.moLineJoint = lclGetDmlLineJoint( moJoinStyle );
|
|
}
|
|
else
|
|
{
|
|
aLineProps.maLineFill.moFillType = XML_noFill;
|
|
}
|
|
|
|
aLineProps.pushToPropMap( rPropMap, rGraphicHelper );
|
|
}
|
|
|
|
void FillModel::assignUsed( const FillModel& rSource )
|
|
{
|
|
moFilled.assignIfUsed( rSource.moFilled );
|
|
moColor.assignIfUsed( rSource.moColor );
|
|
moOpacity.assignIfUsed( rSource.moOpacity );
|
|
moColor2.assignIfUsed( rSource.moColor2 );
|
|
moOpacity2.assignIfUsed( rSource.moOpacity2 );
|
|
moType.assignIfUsed( rSource.moType );
|
|
moAngle.assignIfUsed( rSource.moAngle );
|
|
moFocus.assignIfUsed( rSource.moFocus );
|
|
moFocusPos.assignIfUsed( rSource.moFocusPos );
|
|
moFocusSize.assignIfUsed( rSource.moFocusSize );
|
|
moBitmapPath.assignIfUsed( rSource.moBitmapPath );
|
|
moRotate.assignIfUsed( rSource.moRotate );
|
|
}
|
|
|
|
void FillModel::pushToPropMap( ShapePropertyMap& rPropMap, const GraphicHelper& rGraphicHelper ) const
|
|
{
|
|
/* Convert VML fill formatting to DrawingML fill formatting and let the
|
|
DrawingML code do the hard work. */
|
|
FillProperties aFillProps;
|
|
|
|
if( moFilled.get( true ) )
|
|
{
|
|
sal_Int32 nFillType = moType.get( XML_solid );
|
|
switch( nFillType )
|
|
{
|
|
case XML_gradient:
|
|
case XML_gradientRadial:
|
|
{
|
|
aFillProps.moFillType = XML_gradFill;
|
|
aFillProps.maGradientProps.moRotateWithShape = moRotate.get( false );
|
|
double fFocus = moFocus.get( 0.0 );
|
|
|
|
// prepare colors
|
|
Color aColor1 = ConversionHelper::decodeColor( rGraphicHelper, moColor, moOpacity, API_RGB_WHITE );
|
|
Color aColor2 = ConversionHelper::decodeColor( rGraphicHelper, moColor2, moOpacity2, API_RGB_WHITE, aColor1.getColor( rGraphicHelper ) );
|
|
|
|
// type XML_gradient is linear or axial gradient
|
|
if( nFillType == XML_gradient )
|
|
{
|
|
// normalize angle to range [0;360) degrees
|
|
sal_Int32 nVmlAngle = getIntervalValue< sal_Int32, sal_Int32 >( moAngle.get( 0 ), 0, 360 );
|
|
|
|
// focus of -50% or 50% is axial gradient
|
|
if( ((-0.75 <= fFocus) && (fFocus <= -0.25)) || ((0.25 <= fFocus) && (fFocus <= 0.75)) )
|
|
{
|
|
/* According to spec, focus of 50% is outer-to-inner,
|
|
and -50% is inner-to-outer (color to color2).
|
|
BUT: For angles >= 180 deg., the behaviour is
|
|
reversed... that's not spec'ed of course. So,
|
|
[0;180) deg. and 50%, or [180;360) deg. and -50% is
|
|
outer-to-inner in fact. */
|
|
bool bOuterToInner = (fFocus > 0.0) == (nVmlAngle < 180);
|
|
// simulate axial gradient by 3-step DrawingML gradient
|
|
const Color& rOuterColor = bOuterToInner ? aColor1 : aColor2;
|
|
const Color& rInnerColor = bOuterToInner ? aColor2 : aColor1;
|
|
aFillProps.maGradientProps.maGradientStops[ 0.0 ] = aFillProps.maGradientProps.maGradientStops[ 1.0 ] = rOuterColor;
|
|
aFillProps.maGradientProps.maGradientStops[ 0.5 ] = rInnerColor;
|
|
}
|
|
else // focus of -100%, 0%, and 100% is linear gradient
|
|
{
|
|
/* According to spec, focus of -100% or 100% swaps the
|
|
start and stop colors, effectively reversing the
|
|
gradient. BUT: For angles >= 180 deg., the
|
|
behaviour is reversed. This means that in this case
|
|
a focus of 0% swaps the gradient. */
|
|
if( fFocus < -0.5 || fFocus > 0.5 )
|
|
(nVmlAngle += 180) %= 360;
|
|
// set the start and stop colors
|
|
aFillProps.maGradientProps.maGradientStops[ 0.0 ] = aColor1;
|
|
aFillProps.maGradientProps.maGradientStops[ 1.0 ] = aColor2;
|
|
}
|
|
|
|
// VML counts counterclockwise from bottom, DrawingML clockwise from left
|
|
sal_Int32 nDmlAngle = (630 - nVmlAngle) % 360;
|
|
aFillProps.maGradientProps.moShadeAngle = nDmlAngle * ::oox::drawingml::PER_DEGREE;
|
|
}
|
|
else // XML_gradientRadial is rectangular gradient
|
|
{
|
|
aFillProps.maGradientProps.moGradientPath = XML_rect;
|
|
// convert VML focus position and size to DrawingML fill-to-rect
|
|
DoublePair aFocusPos = moFocusPos.get( DoublePair( 0.0, 0.0 ) );
|
|
DoublePair aFocusSize = moFocusSize.get( DoublePair( 0.0, 0.0 ) );
|
|
double fLeft = getLimitedValue< double, double >( aFocusPos.first, 0.0, 1.0 );
|
|
double fTop = getLimitedValue< double, double >( aFocusPos.second, 0.0, 1.0 );
|
|
double fRight = getLimitedValue< double, double >( fLeft + aFocusSize.first, fLeft, 1.0 );
|
|
double fBottom = getLimitedValue< double, double >( fTop + aFocusSize.second, fTop, 1.0 );
|
|
aFillProps.maGradientProps.moFillToRect = IntegerRectangle2D(
|
|
static_cast< sal_Int32 >( fLeft * ::oox::drawingml::MAX_PERCENT ),
|
|
static_cast< sal_Int32 >( fTop * ::oox::drawingml::MAX_PERCENT ),
|
|
static_cast< sal_Int32 >( (1.0 - fRight) * ::oox::drawingml::MAX_PERCENT ),
|
|
static_cast< sal_Int32 >( (1.0 - fBottom) * ::oox::drawingml::MAX_PERCENT ) );
|
|
|
|
// set the start and stop colors (focus of 0% means outer-to-inner)
|
|
bool bOuterToInner = (-0.5 <= fFocus) && (fFocus <= 0.5);
|
|
aFillProps.maGradientProps.maGradientStops[ 0.0 ] = bOuterToInner ? aColor2 : aColor1;
|
|
aFillProps.maGradientProps.maGradientStops[ 1.0 ] = bOuterToInner ? aColor1 : aColor2;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case XML_pattern:
|
|
case XML_tile:
|
|
case XML_frame:
|
|
{
|
|
if( moBitmapPath.has() && !moBitmapPath.get().isEmpty() )
|
|
{
|
|
aFillProps.maBlipProps.mxGraphic = rGraphicHelper.importEmbeddedGraphic( moBitmapPath.get() );
|
|
if( aFillProps.maBlipProps.mxGraphic.is() )
|
|
{
|
|
aFillProps.moFillType = XML_blipFill;
|
|
aFillProps.maBlipProps.moBitmapMode = (nFillType == XML_frame) ? XML_stretch : XML_tile;
|
|
break; // do not break if bitmap is missing, but run to XML_solid instead
|
|
}
|
|
}
|
|
}
|
|
// run-through to XML_solid in case of missing bitmap path intended!
|
|
|
|
case XML_solid:
|
|
default:
|
|
{
|
|
aFillProps.moFillType = XML_solidFill;
|
|
// fill color (default is white)
|
|
aFillProps.maFillColor = ConversionHelper::decodeColor( rGraphicHelper, moColor, moOpacity, API_RGB_WHITE );
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
aFillProps.moFillType = XML_noFill;
|
|
}
|
|
|
|
aFillProps.pushToPropMap( rPropMap, rGraphicHelper );
|
|
}
|
|
|
|
ShadowModel::ShadowModel()
|
|
: mbHasShadow(false)
|
|
{
|
|
}
|
|
|
|
void ShadowModel::pushToPropMap(ShapePropertyMap& rPropMap, const GraphicHelper& rGraphicHelper) const
|
|
{
|
|
if (!mbHasShadow || (moShadowOn.has() && !moShadowOn.get()))
|
|
return;
|
|
|
|
drawingml::Color aColor = ConversionHelper::decodeColor(rGraphicHelper, moColor, moOpacity, API_RGB_GRAY);
|
|
// nOffset* is in mm100, default value is 35 twips, see DffPropertyReader::ApplyAttributes() in msfilter.
|
|
sal_Int32 nOffsetX = 62, nOffsetY = 62;
|
|
if (moOffset.has())
|
|
{
|
|
OUString aOffsetX, aOffsetY;
|
|
ConversionHelper::separatePair(aOffsetX, aOffsetY, moOffset.get(), ',');
|
|
if (!aOffsetX.isEmpty())
|
|
nOffsetX = ConversionHelper::decodeMeasureToHmm(rGraphicHelper, aOffsetX, 0, false, false );
|
|
if (!aOffsetY.isEmpty())
|
|
nOffsetY = ConversionHelper::decodeMeasureToHmm(rGraphicHelper, aOffsetY, 0, false, false );
|
|
}
|
|
|
|
table::ShadowFormat aFormat;
|
|
aFormat.Color = aColor.getColor(rGraphicHelper);
|
|
aFormat.Location = table::ShadowLocation_BOTTOM_RIGHT;
|
|
// The width of the shadow is the average of the x and y values, see SwWW8ImplReader::MatchSdrItemsIntoFlySet().
|
|
aFormat.ShadowWidth = ((nOffsetX + nOffsetY) / 2);
|
|
rPropMap.setProperty(PROP_ShadowFormat, uno::makeAny(aFormat));
|
|
}
|
|
|
|
TextpathModel::TextpathModel()
|
|
{
|
|
}
|
|
|
|
beans::PropertyValue lcl_createTextpathProps()
|
|
{
|
|
uno::Sequence<beans::PropertyValue> aTextpathPropSeq(4);
|
|
aTextpathPropSeq[0].Name = "TextPath";
|
|
aTextpathPropSeq[0].Value <<= true;
|
|
aTextpathPropSeq[1].Name = "TextPathMode";
|
|
aTextpathPropSeq[1].Value <<= drawing::EnhancedCustomShapeTextPathMode_SHAPE;
|
|
aTextpathPropSeq[2].Name = "ScaleX";
|
|
aTextpathPropSeq[2].Value <<= false;
|
|
aTextpathPropSeq[3].Name = "SameLetterHeights";
|
|
aTextpathPropSeq[3].Value <<= false;
|
|
|
|
beans::PropertyValue aRet;
|
|
aRet.Name = "TextPath";
|
|
aRet.Value <<= aTextpathPropSeq;
|
|
return aRet;
|
|
}
|
|
|
|
void TextpathModel::pushToPropMap(ShapePropertyMap& rPropMap, const uno::Reference<drawing::XShape>& xShape) const
|
|
{
|
|
if (moString.has())
|
|
{
|
|
uno::Reference<text::XTextRange> xTextRange(xShape, uno::UNO_QUERY);
|
|
xTextRange->setString(moString.get());
|
|
|
|
uno::Reference<beans::XPropertySet> xPropertySet(xShape, uno::UNO_QUERY);
|
|
uno::Sequence<beans::PropertyValue> aGeomPropSeq = xPropertySet->getPropertyValue("CustomShapeGeometry").get< uno::Sequence<beans::PropertyValue> >();
|
|
bool bFound = false;
|
|
for (int i = 0; i < aGeomPropSeq.getLength(); ++i)
|
|
{
|
|
beans::PropertyValue& rProp = aGeomPropSeq[i];
|
|
if (rProp.Name == "TextPath")
|
|
{
|
|
bFound = true;
|
|
rProp = lcl_createTextpathProps();
|
|
}
|
|
}
|
|
if (!bFound)
|
|
{
|
|
sal_Int32 nSize = aGeomPropSeq.getLength();
|
|
aGeomPropSeq.realloc(nSize+1);
|
|
aGeomPropSeq[nSize] = lcl_createTextpathProps();
|
|
}
|
|
rPropMap.setAnyProperty(PROP_CustomShapeGeometry, uno::makeAny(aGeomPropSeq));
|
|
}
|
|
}
|
|
|
|
} // namespace vml
|
|
} // namespace oox
|
|
|
|
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|