oox/source/vml/vmlshapecontext.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <sal/config.h>
  21
  22 #include <string_view>
  23
  24 #include <oox/vml/vmlshapecontext.hxx>
  25
  26 #include <oox/core/xmlfilterbase.hxx>
  27 #include <oox/helper/attributelist.hxx>
  28 #include <oox/helper/helper.hxx>
  29 #include <oox/token/namespaces.hxx>
  30 #include <oox/token/tokens.hxx>
  31 #include <oox/vml/vmldrawing.hxx>
  32 #include <oox/vml/vmlshape.hxx>
  33 #include <oox/vml/vmlshapecontainer.hxx>
  34 #include <oox/vml/vmltextboxcontext.hxx>
  35
  36 #include <osl/diagnose.h>
  37 #include <filter/msfilter/escherex.hxx>
  38 #include <o3tl/string_view.hxx>
  39
  40 namespace oox::vml {
  41
  42 using namespace ::com::sun::star;
  43
  44 using ::oox::core::ContextHandler2;
  45 using ::oox::core::ContextHandler2Helper;
  46 using ::oox::core::ContextHandlerRef;
  47
  48 namespace {
  49
  50 /** Returns the boolean value from the specified VML attribute (if present).
  51  */
  52 std::optional< bool > lclDecodeBool( const AttributeList& rAttribs, sal_Int32 nToken )
  53 {
  54     std::optional< OUString > oValue = rAttribs.getString( nToken );
  55     if( oValue.has_value() ) return std::optional< bool >( ConversionHelper::decodeBool( oValue.value() ) );
  56     return std::optional< bool >();
  57 }
  58
  59 /** Returns the percentage value from the specified VML attribute (if present).
  60     The value will be normalized (1.0 is returned for 100%).
  61  */
  62 std::optional< double > lclDecodePercent( const AttributeList& rAttribs, sal_Int32 nToken, double fDefValue )
  63 {
  64     std::optional< OUString > oValue = rAttribs.getString( nToken );
  65     if( oValue.has_value() ) return std::optional< double >( ConversionHelper::decodePercent( oValue.value(), fDefValue ) );
  66     return std::optional< double >();
  67 }
  68
  69 /** #119750# Special method for opacity; it *should* be a percentage value, but there are cases
  70     where a value relative to 0xffff (65536) is used, ending with an 'f'
  71  */
  72 std::optional< double > lclDecodeOpacity( const AttributeList& rAttribs, sal_Int32 nToken, double fDefValue )
  73 {
  74     std::optional< OUString > oValue = rAttribs.getString( nToken );
  75     double fRetval(fDefValue);
  76
  77     if( oValue.has_value() )
  78     {
  79         const OUString& aString(oValue.value());
  80         const sal_Int32 nLength(aString.getLength());
  81
  82         if(nLength > 0)
  83         {
  84             if(aString.endsWith("f"))
  85             {
  86                 fRetval = std::clamp(aString.toDouble() / 65536.0, 0.0, 1.0);
  87             }
  88             else
  89             {
  90                 fRetval = ConversionHelper::decodePercent( aString, fDefValue );
  91             }
  92         }
  93     }
  94
  95     return std::optional< double >(fRetval);
  96 }
  97
  98 /** Returns the integer value pair from the specified VML attribute (if present).
  99  */
 100 std::optional< Int32Pair > lclDecodeInt32Pair( const AttributeList& rAttribs, sal_Int32 nToken )
 101 {
 102     std::optional< OUString > oValue = rAttribs.getString( nToken );
 103     std::optional< Int32Pair > oRetValue;
 104     if( oValue.has_value() )
 105     {
 106         std::u16string_view aValue1, aValue2;
 107         ConversionHelper::separatePair( aValue1, aValue2, oValue.value(), ',' );
 108         oRetValue = Int32Pair( o3tl::toInt32(aValue1), o3tl::toInt32(aValue2) );
 109     }
 110     return oRetValue;
 111 }
 112
 113 /** Returns the percentage pair from the specified VML attribute (if present).
 114  */
 115 std::optional< DoublePair > lclDecodePercentPair( const AttributeList& rAttribs, sal_Int32 nToken )
 116 {
 117     std::optional< OUString > oValue = rAttribs.getString( nToken );
 118     std::optional< DoublePair > oRetValue;
 119     if( oValue.has_value() )
 120     {
 121         std::u16string_view aValue1, aValue2;
 122         ConversionHelper::separatePair( aValue1, aValue2, oValue.value(), ',' );
 123         oRetValue = DoublePair(
 124             ConversionHelper::decodePercent( aValue1, 0.0 ),
 125             ConversionHelper::decodePercent( aValue2, 0.0 ) );
 126     }
 127     return oRetValue;
 128 }
 129
 130 /** Returns the boolean value from the passed string of an attribute in the x:
 131     namespace (VML for spreadsheets). Supported values: f, t, False, True.
 132     @param bDefaultForEmpty  Default value for the empty string.
 133  */
 134 bool lclDecodeVmlxBool( std::u16string_view rValue, bool bDefaultForEmpty )
 135 {
 136     if( rValue.empty() ) return bDefaultForEmpty;
 137     sal_Int32 nToken = AttributeConversion::decodeToken( rValue );
 138     // anything else than 't' or 'True' is considered to be false, as specified
 139     return (nToken == XML_t) || (nToken == XML_True);
 140 }
 141
 142 } // namespace
 143
 144 ShapeLayoutContext::ShapeLayoutContext( ContextHandler2Helper const & rParent, Drawing& rDrawing ) :
 145     ContextHandler2( rParent ),
 146     mrDrawing( rDrawing )
 147 {
 148 }
 149
 150 ContextHandlerRef ShapeLayoutContext::onCreateContext( sal_Int32 nElement, const AttributeList& rAttribs )
 151 {
 152     switch( nElement )
 153     {
 154         case O_TOKEN( idmap ):
 155         {
 156             OUString aBlockIds = rAttribs.getStringDefaulted( XML_data);
 157             sal_Int32 nIndex = 0;
 158             while( nIndex >= 0 )
 159             {
 160                 std::u16string_view aToken = o3tl::trim(o3tl::getToken(aBlockIds, 0, ' ', nIndex ));
 161                 if( !aToken.empty() )
 162                     mrDrawing.registerBlockId( o3tl::toInt32(aToken) );
 163             }
 164         }
 165         break;
 166     }
 167     return nullptr;
 168 }
 169
 170 ClientDataContext::ClientDataContext( ContextHandler2Helper const & rParent,
 171         ClientData& rClientData, const AttributeList& rAttribs ) :
 172     ContextHandler2( rParent ),
 173     mrClientData( rClientData )
 174 {
 175     mrClientData.mnObjType = rAttribs.getToken( XML_ObjectType, XML_TOKEN_INVALID );
 176 }
 177
 178 ContextHandlerRef ClientDataContext::onCreateContext( sal_Int32 /*nElement*/, const AttributeList& /*rAttribs*/ )
 179 {
 180     if( isRootElement() )
 181     {
 182         maElementText.clear();
 183         return this;
 184     }
 185     return nullptr;
 186 }
 187
 188 void ClientDataContext::onCharacters( const OUString& rChars )
 189 {
 190     /*  Empty but existing elements have special meaning, e.g. 'true'. Collect
 191         existing text and convert it in onEndElement(). */
 192     maElementText = rChars;
 193 }
 194
 195 void ClientDataContext::onEndElement()
 196 {
 197     switch( getCurrentElement() )
 198     {
 199         case VMLX_TOKEN( Anchor ):      mrClientData.maAnchor = maElementText;                                          break;
 200         case VMLX_TOKEN( FmlaMacro ):   mrClientData.maFmlaMacro = maElementText;                                       break;
 201         case VMLX_TOKEN( FmlaPict ):    mrClientData.maFmlaPict = maElementText;                                        break;
 202         case VMLX_TOKEN( FmlaLink ):    mrClientData.maFmlaLink = maElementText;                                        break;
 203         case VMLX_TOKEN( FmlaRange ):   mrClientData.maFmlaRange = maElementText;                                       break;
 204         case VMLX_TOKEN( FmlaGroup ):   mrClientData.maFmlaGroup = maElementText;                                       break;
 205         case VMLX_TOKEN( TextHAlign ):  mrClientData.mnTextHAlign = AttributeConversion::decodeToken( maElementText );  break;
 206         case VMLX_TOKEN( TextVAlign ):  mrClientData.mnTextVAlign = AttributeConversion::decodeToken( maElementText );  break;
 207         case VMLX_TOKEN( Column ):      mrClientData.mnCol = maElementText.toInt32();                                   break;
 208         case VMLX_TOKEN( Row ):         mrClientData.mnRow = maElementText.toInt32();                                   break;
 209         case VMLX_TOKEN( Checked ):     mrClientData.mnChecked = maElementText.toInt32();                               break;
 210         case VMLX_TOKEN( DropStyle ):   mrClientData.mnDropStyle = AttributeConversion::decodeToken( maElementText );   break;
 211         case VMLX_TOKEN( DropLines ):   mrClientData.mnDropLines = maElementText.toInt32();                             break;
 212         case VMLX_TOKEN( Val ):         mrClientData.mnVal = maElementText.toInt32();                                   break;
 213         case VMLX_TOKEN( Min ):         mrClientData.mnMin = maElementText.toInt32();                                   break;
 214         case VMLX_TOKEN( Max ):         mrClientData.mnMax = maElementText.toInt32();                                   break;
 215         case VMLX_TOKEN( Inc ):         mrClientData.mnInc = maElementText.toInt32();                                   break;
 216         case VMLX_TOKEN( Page ):        mrClientData.mnPage = maElementText.toInt32();                                  break;
 217         case VMLX_TOKEN( SelType ):     mrClientData.mnSelType = AttributeConversion::decodeToken( maElementText );     break;
 218         case VMLX_TOKEN( VTEdit ):      mrClientData.mnVTEdit = maElementText.toInt32();                                break;
 219         case VMLX_TOKEN( PrintObject ): mrClientData.mbPrintObject = lclDecodeVmlxBool( maElementText, true );          break;
 220         case VMLX_TOKEN( Visible ):     mrClientData.mbVisible = lclDecodeVmlxBool( maElementText, true );              break;
 221         case VMLX_TOKEN( DDE ):         mrClientData.mbDde = lclDecodeVmlxBool( maElementText, true );                  break;
 222         case VMLX_TOKEN( NoThreeD ):    mrClientData.mbNo3D = lclDecodeVmlxBool( maElementText, true );                 break;
 223         case VMLX_TOKEN( NoThreeD2 ):   mrClientData.mbNo3D2 = lclDecodeVmlxBool( maElementText, true );                break;
 224         case VMLX_TOKEN( MultiLine ):   mrClientData.mbMultiLine = lclDecodeVmlxBool( maElementText, true );            break;
 225         case VMLX_TOKEN( VScroll ):     mrClientData.mbVScroll = lclDecodeVmlxBool( maElementText, true );              break;
 226         case VMLX_TOKEN( SecretEdit ):  mrClientData.mbSecretEdit = lclDecodeVmlxBool( maElementText, true );           break;
 227     }
 228 }
 229
 230 ShapeContextBase::ShapeContextBase( ContextHandler2Helper const & rParent ) :
 231     ContextHandler2( rParent )
 232 {
 233 }
 234
 235 ContextHandlerRef ShapeContextBase::createShapeContext( ContextHandler2Helper const & rParent,
 236         ShapeContainer& rShapes, sal_Int32 nElement, const AttributeList& rAttribs )
 237 {
 238     switch( nElement )
 239     {
 240         case O_TOKEN( shapelayout ):
 241             return new ShapeLayoutContext( rParent, rShapes.getDrawing() );
 242
 243         case VML_TOKEN( shapetype ):
 244             return new ShapeTypeContext( rParent, rShapes.createShapeType(), rAttribs );
 245         case VML_TOKEN( group ):
 246             return new GroupShapeContext( rParent, rShapes.createShape< GroupShape >(), rAttribs );
 247         case VML_TOKEN( shape ):
 248             if (rAttribs.hasAttribute(XML_path) &&
 249                     // tdf#122563 skip in the case of empty path
 250                     !rAttribs.getStringDefaulted(XML_path).isEmpty())
 251                 return new ShapeContext( rParent, rShapes.createShape< BezierShape >(), rAttribs );
 252             else
 253                 return new ShapeContext( rParent, rShapes.createShape< ComplexShape >(), rAttribs );
 254         case VML_TOKEN(background):
 255         case VML_TOKEN( rect ):
 256             return new RectangleShapeContext( rParent, rAttribs, rShapes.createShape< RectangleShape >() );
 257         case VML_TOKEN( roundrect ):
 258             return new ShapeContext( rParent, rShapes.createShape< RectangleShape >(), rAttribs );
 259         case VML_TOKEN( oval ):
 260             return new ShapeContext( rParent, rShapes.createShape< EllipseShape >(), rAttribs );
 261         case VML_TOKEN( polyline ):
 262             return new ShapeContext( rParent, rShapes.createShape< PolyLineShape >(), rAttribs );
 263         case VML_TOKEN( line ):
 264             return new ShapeContext( rParent, rShapes.createShape< LineShape >(), rAttribs );
 265         case VML_TOKEN( curve ):
 266             return new ShapeContext( rParent, rShapes.createShape< BezierShape >(), rAttribs );
 267
 268         // TODO:
 269         case VML_TOKEN( arc ):
 270         case VML_TOKEN( diagram ):
 271         case VML_TOKEN( image ):
 272             return new ShapeContext( rParent, rShapes.createShape< ComplexShape >(), rAttribs );
 273
 274         case W_TOKEN(control):
 275             return new ControlShapeContext( rParent, rShapes, rAttribs );
 276     }
 277     return nullptr;
 278 }
 279
 280 ShapeTypeContext::ShapeTypeContext(ContextHandler2Helper const & rParent,
 281         std::shared_ptr<ShapeType> const& pShapeType,
 282         const AttributeList& rAttribs)
 283     : ShapeContextBase(rParent)
 284     , m_pShapeType(pShapeType) // tdf#112311 keep it alive
 285     , mrTypeModel( pShapeType->getTypeModel() )
 286 {
 287     // shape identifier and shape name
 288     bool bHasOspid = rAttribs.hasAttribute( O_TOKEN( spid ) );
 289     mrTypeModel.maShapeId = rAttribs.getXString( bHasOspid ? O_TOKEN( spid ) : XML_id, OUString() );
 290     mrTypeModel.maLegacyId = rAttribs.getStringDefaulted( XML_id);
 291     OSL_ENSURE( !mrTypeModel.maShapeId.isEmpty(), "ShapeTypeContext::ShapeTypeContext - missing shape identifier" );
 292     // builtin shape type identifier
 293     mrTypeModel.moShapeType = rAttribs.getInteger( O_TOKEN( spt ) );
 294     // if the o:spid attribute exists, the id attribute contains the user-defined shape name
 295     if( bHasOspid )
 296     {
 297         mrTypeModel.maShapeName = rAttribs.getXString( XML_id, OUString() );
 298         // get ShapeType and ShapeId from name for compatibility
 299         static constexpr OUString sShapeTypePrefix = u"shapetype_"_ustr;
 300         std::u16string_view tmp;
 301         if( mrTypeModel.maShapeName.startsWith( sShapeTypePrefix ) )
 302         {
 303             mrTypeModel.maShapeId = mrTypeModel.maShapeName;
 304             mrTypeModel.moShapeType = o3tl::toInt32(mrTypeModel.maShapeName.subView(sShapeTypePrefix.getLength()));
 305         }
 306         else if (mrTypeModel.maShapeName.startsWith("_x0000_t", &tmp))
 307         {
 308             mrTypeModel.maShapeId = mrTypeModel.maShapeName;
 309             mrTypeModel.moShapeType = o3tl::toInt32(tmp);
 310         }
 311     }
 312
 313     // coordinate system position/size, CSS style
 314     mrTypeModel.moCoordPos = lclDecodeInt32Pair( rAttribs, XML_coordorigin );
 315     mrTypeModel.moCoordSize = lclDecodeInt32Pair( rAttribs, XML_coordsize );
 316     setStyle( rAttribs.getStringDefaulted( XML_style) );
 317     if( lclDecodeBool( rAttribs, O_TOKEN( hr )).value_or( false ))
 318     {   // MSO's handling of o:hr width is nowhere near what the spec says:
 319         // - o:hrpct is not in % but in 0.1%
 320         // - if o:hrpct is not given, 100% width is assumed
 321         // - given width is used only if explicit o:hrpct="0" is given
 322         OUString hrpct = rAttribs.getString( O_TOKEN( hrpct ), u"1000"_ustr );
 323         if( hrpct != "0" )
 324             mrTypeModel.maWidthPercent = OUString::number( hrpct.toInt32() );
 325         mrTypeModel.maWrapDistanceLeft = "0";
 326         mrTypeModel.maWrapDistanceRight = "0";
 327         mrTypeModel.maPositionHorizontal = rAttribs.getString( O_TOKEN( hralign ), u"left"_ustr );
 328         mrTypeModel.moWrapType = "topAndBottom";
 329     }
 330
 331     // stroke settings (may be overridden by v:stroke element later)
 332     mrTypeModel.maStrokeModel.moStroked = lclDecodeBool( rAttribs, XML_stroked );
 333     mrTypeModel.maStrokeModel.moColor = rAttribs.getString( XML_strokecolor );
 334     mrTypeModel.maStrokeModel.moWeight = rAttribs.getString( XML_strokeweight );
 335
 336     // fill settings (may be overridden by v:fill element later)
 337     mrTypeModel.maFillModel.moFilled = lclDecodeBool( rAttribs, XML_filled );
 338     mrTypeModel.maFillModel.moColor = rAttribs.getString( XML_fillcolor );
 339
 340     // For roundrect we may have an arcsize attribute to read
 341     mrTypeModel.maArcsize = rAttribs.getStringDefaulted(XML_arcsize);
 342     // editas
 343     mrTypeModel.maEditAs = rAttribs.getStringDefaulted(XML_editas);
 344
 345     mrTypeModel.maAdjustments = rAttribs.getStringDefaulted(XML_adj);
 346 }
 347
 348 ContextHandlerRef ShapeTypeContext::onCreateContext( sal_Int32 nElement, const AttributeList& rAttribs )
 349 {
 350     if( isRootElement() ) switch( nElement )
 351     {
 352         case VML_TOKEN( stroke ):
 353             assignIfUsed( mrTypeModel.maStrokeModel.moStroked, lclDecodeBool( rAttribs, XML_on ) );
 354             mrTypeModel.maStrokeModel.maStartArrow.moArrowType = rAttribs.getToken( XML_startarrow );
 355             mrTypeModel.maStrokeModel.maStartArrow.moArrowWidth = rAttribs.getToken( XML_startarrowwidth );
 356             mrTypeModel.maStrokeModel.maStartArrow.moArrowLength = rAttribs.getToken( XML_startarrowlength );
 357             mrTypeModel.maStrokeModel.maEndArrow.moArrowType = rAttribs.getToken( XML_endarrow );
 358             mrTypeModel.maStrokeModel.maEndArrow.moArrowWidth = rAttribs.getToken( XML_endarrowwidth );
 359             mrTypeModel.maStrokeModel.maEndArrow.moArrowLength = rAttribs.getToken( XML_endarrowlength );
 360             assignIfUsed( mrTypeModel.maStrokeModel.moColor, rAttribs.getString( XML_color ) );
 361             mrTypeModel.maStrokeModel.moOpacity = lclDecodeOpacity( rAttribs, XML_opacity, 1.0 );
 362             assignIfUsed( mrTypeModel.maStrokeModel.moWeight, rAttribs.getString( XML_weight ) );
 363             mrTypeModel.maStrokeModel.moDashStyle = rAttribs.getString( XML_dashstyle );
 364             mrTypeModel.maStrokeModel.moLineStyle = rAttribs.getToken( XML_linestyle );
 365             mrTypeModel.maStrokeModel.moEndCap = rAttribs.getToken( XML_endcap );
 366             mrTypeModel.maStrokeModel.moJoinStyle = rAttribs.getToken( XML_joinstyle );
 367         break;
 368         case VML_TOKEN( fill ):
 369         {
 370             // in DOCX shapes use r:id for the relationship id
 371             // in XLSX they use o:relid
 372             bool bHasORelId = rAttribs.hasAttribute( O_TOKEN(relid) );
 373             assignIfUsed( mrTypeModel.maFillModel.moFilled, lclDecodeBool( rAttribs, XML_on ) );
 374             assignIfUsed( mrTypeModel.maFillModel.moColor, rAttribs.getString( XML_color ) );
 375             mrTypeModel.maFillModel.moOpacity = lclDecodeOpacity( rAttribs, XML_opacity, 1.0 );
 376             mrTypeModel.maFillModel.moColor2 = rAttribs.getString( XML_color2 );
 377             mrTypeModel.maFillModel.moOpacity2 = lclDecodeOpacity( rAttribs, XML_opacity2, 1.0 );
 378             mrTypeModel.maFillModel.moType = rAttribs.getToken( XML_type );
 379             mrTypeModel.maFillModel.moAngle = rAttribs.getInteger( XML_angle );
 380             mrTypeModel.maFillModel.moFocus = lclDecodePercent( rAttribs, XML_focus, 0.0 );
 381             mrTypeModel.maFillModel.moFocusPos = lclDecodePercentPair( rAttribs, XML_focusposition );
 382             mrTypeModel.maFillModel.moFocusSize = lclDecodePercentPair( rAttribs, XML_focussize );
 383             mrTypeModel.maFillModel.moBitmapPath = decodeFragmentPath( rAttribs, bHasORelId ? O_TOKEN(relid) : R_TOKEN(id) );
 384             mrTypeModel.maFillModel.moRotate = lclDecodeBool( rAttribs, XML_rotate );
 385             break;
 386         }
 387         case VML_TOKEN( imagedata ):
 388         {
 389             // shapes in docx use r:id for the relationship id
 390             // in xlsx it they use o:relid
 391             bool bHasORelId = rAttribs.hasAttribute( O_TOKEN( relid ) );
 392             mrTypeModel.moGraphicPath = decodeFragmentPath( rAttribs, bHasORelId ? O_TOKEN( relid ) : R_TOKEN( id ) );
 393             mrTypeModel.moGraphicTitle = rAttribs.getString( O_TOKEN( title ) );
 394
 395             // Get crop attributes.
 396             mrTypeModel.moCropBottom = rAttribs.getString(XML_cropbottom);
 397             mrTypeModel.moCropLeft = rAttribs.getString(XML_cropleft);
 398             mrTypeModel.moCropRight = rAttribs.getString(XML_cropright);
 399             mrTypeModel.moCropTop = rAttribs.getString(XML_croptop);
 400
 401             // Gain / contrast.
 402             std::optional<OUString> oGain = rAttribs.getString(XML_gain);
 403             sal_Int32 nGain = 0x10000;
 404             if (oGain.has_value() && oGain.value().endsWith("f"))
 405             {
 406                 nGain = oGain.value().toInt32();
 407             }
 408             if (nGain < 0x10000)
 409             {
 410                 nGain *= 101; // 100 + 1 to round
 411                 nGain /= 0x10000;
 412                 nGain -= 100;
 413             }
 414             mrTypeModel.mnGain = nGain;
 415
 416             // Blacklevel / brightness.
 417             std::optional<OUString> oBlacklevel = rAttribs.getString(XML_blacklevel);
 418             sal_Int16 nBlacklevel = 0;
 419             if (oBlacklevel.has_value() && oBlacklevel.value().endsWith("f"))
 420             {
 421                 nBlacklevel = oBlacklevel.value().toInt32();
 422             }
 423             if (nBlacklevel != 0)
 424             {
 425                 nBlacklevel /= 327;
 426             }
 427             mrTypeModel.mnBlacklevel = nBlacklevel;
 428         }
 429         break;
 430         case NMSP_vmlWord | XML_wrap:
 431             mrTypeModel.moWrapAnchorX = rAttribs.getString(XML_anchorx);
 432             mrTypeModel.moWrapAnchorY = rAttribs.getString(XML_anchory);
 433             mrTypeModel.moWrapType = rAttribs.getString(XML_type);
 434             mrTypeModel.moWrapSide = rAttribs.getString(XML_side);
 435         break;
 436         case VML_TOKEN( shadow ):
 437         {
 438             mrTypeModel.maShadowModel.mbHasShadow = true;
 439             mrTypeModel.maShadowModel.moShadowOn = lclDecodeBool(rAttribs, XML_on).value_or(false);
 440             assignIfUsed(mrTypeModel.maShadowModel.moColor, rAttribs.getString(XML_color));
 441             assignIfUsed(mrTypeModel.maShadowModel.moOffset, rAttribs.getString(XML_offset));
 442             mrTypeModel.maShadowModel.moOpacity = lclDecodePercent(rAttribs, XML_opacity, 1.0);
 443         }
 444         break;
 445         case VML_TOKEN( textpath ):
 446             assignIfUsed(mrTypeModel.maTextpathModel.moString, rAttribs.getString(XML_string));
 447             assignIfUsed(mrTypeModel.maTextpathModel.moStyle, rAttribs.getString(XML_style));
 448             assignIfUsed(mrTypeModel.maTextpathModel.moTrim, lclDecodeBool(rAttribs, XML_trim));
 449         break;
 450     }
 451     return nullptr;
 452 }
 453
 454 std::optional< OUString > ShapeTypeContext::decodeFragmentPath( const AttributeList& rAttribs, sal_Int32 nToken ) const
 455 {
 456     std::optional< OUString > oFragmentPath;
 457     std::optional< OUString > oRelId = rAttribs.getString( nToken );
 458     if( oRelId.has_value() )
 459         oFragmentPath = getFragmentPathFromRelId( oRelId.value() );
 460     return oFragmentPath;
 461 }
 462
 463 void ShapeTypeContext::setStyle( std::u16string_view rStyle )
 464 {
 465     sal_Int32 nIndex = 0;
 466     while( nIndex >= 0 )
 467     {
 468         std::u16string_view aName, aValue;
 469         if( ConversionHelper::separatePair( aName, aValue, o3tl::getToken(rStyle, 0, ';', nIndex ), ':' ) )
 470         {
 471             if( aName == u"position" )      mrTypeModel.maPosition = aValue;
 472             else if( aName == u"z-index" )        mrTypeModel.maZIndex = aValue;
 473             else if( aName == u"left" )           mrTypeModel.maLeft = aValue;
 474             else if( aName == u"top" )            mrTypeModel.maTop = aValue;
 475             else if( aName == u"width" )          mrTypeModel.maWidth = aValue;
 476             else if( aName == u"height" )         mrTypeModel.maHeight = aValue;
 477             else if( aName == u"margin-left" )    mrTypeModel.maMarginLeft = aValue;
 478             else if( aName == u"margin-top" )     mrTypeModel.maMarginTop = aValue;
 479             else if( aName == u"mso-position-vertical-relative" )  mrTypeModel.maPositionVerticalRelative = aValue;
 480             else if( aName == u"mso-position-horizontal-relative" )  mrTypeModel.maPositionHorizontalRelative = aValue;
 481             else if( aName == u"mso-position-horizontal" ) mrTypeModel.maPositionHorizontal = aValue;
 482             else if( aName == u"mso-position-vertical" ) mrTypeModel.maPositionVertical = aValue;
 483             else if( aName == u"mso-width-percent" ) mrTypeModel.maWidthPercent = aValue;
 484             else if( aName == u"mso-width-relative" ) mrTypeModel.maWidthRelative = aValue;
 485             else if( aName == u"mso-height-percent" ) mrTypeModel.maHeightPercent = aValue;
 486             else if( aName == u"mso-height-relative" ) mrTypeModel.maHeightRelative = aValue;
 487             else if( aName == u"mso-fit-shape-to-text" )           mrTypeModel.mbAutoHeight = true;
 488             else if( aName == u"rotation" )       mrTypeModel.maRotation = aValue;
 489             else if( aName == u"flip" )       mrTypeModel.maFlip = aValue;
 490             else if( aName == u"visibility" )
 491                 mrTypeModel.mbVisible = aValue != u"hidden";
 492             else if( aName == u"mso-wrap-style" ) mrTypeModel.maWrapStyle = aValue;
 493             else if ( aName == u"v-text-anchor" ) mrTypeModel.maVTextAnchor = aValue;
 494             else if ( aName == u"mso-wrap-distance-left" ) mrTypeModel.maWrapDistanceLeft = aValue;
 495             else if ( aName == u"mso-wrap-distance-right" ) mrTypeModel.maWrapDistanceRight = aValue;
 496             else if ( aName == u"mso-wrap-distance-top" ) mrTypeModel.maWrapDistanceTop = aValue;
 497             else if ( aName == u"mso-wrap-distance-bottom" ) mrTypeModel.maWrapDistanceBottom = aValue;
 498         }
 499     }
 500 }
 501
 502 ShapeContext::ShapeContext(ContextHandler2Helper const& rParent,
 503                            const std::shared_ptr<ShapeBase>& pShape, const AttributeList& rAttribs)
 504     : ShapeTypeContext(rParent, pShape, rAttribs)
 505     , mrShape(*pShape)
 506     , mrShapeModel(pShape->getShapeModel())
 507 {
 508     // collect shape specific attributes
 509     mrShapeModel.maType = rAttribs.getXString( XML_type, OUString() );
 510     // polyline path
 511     setPoints( rAttribs.getStringDefaulted( XML_points) );
 512     // line start and end positions
 513     setFrom(rAttribs.getStringDefaulted(XML_from));
 514     setTo(rAttribs.getStringDefaulted(XML_to));
 515     setControl1(rAttribs.getStringDefaulted(XML_control1));
 516     setControl2(rAttribs.getStringDefaulted(XML_control2));
 517     setVmlPath(rAttribs.getStringDefaulted(XML_path));
 518     setHyperlink(rAttribs.getStringDefaulted(XML_href));
 519 }
 520
 521 ContextHandlerRef ShapeContext::onCreateContext( sal_Int32 nElement, const AttributeList& rAttribs )
 522 {
 523     // Excel specific shape client data
 524     if( isRootElement() ) switch( nElement )
 525     {
 526         case VML_TOKEN( textbox ):
 527         {
 528             // Calculate the shape type: map both <rect> and <v:shape> with a textbox shape type to
 529             // a TextShape.
 530             sal_Int32 nShapeType = 0;
 531             if (ShapeContainer* pShapeContainer = mrShape.getContainer())
 532             {
 533                 OUString aType = mrShapeModel.maType;
 534                 if (!aType.isEmpty() && aType[0] == '#')
 535                 {
 536                     aType = aType.copy(1);
 537                 }
 538                 if (const ShapeType* pShapeType = pShapeContainer->getShapeTypeById(aType))
 539                 {
 540                     nShapeType = pShapeType->getTypeModel().moShapeType.value();
 541                 }
 542             }
 543             mrShapeModel.mbInGroup = (getParentElement() == VML_TOKEN(group));
 544
 545             // FIXME: the shape with textbox should be used for the next cases
 546             if (getCurrentElement() == VML_TOKEN(rect) || nShapeType == ESCHER_ShpInst_TextBox)
 547             {
 548                 if (mrShapeModel.mbInGroup)
 549                     // FIXME: without this a text will be added into the group-shape instead of its
 550                     // parent shape
 551                 {
 552                     if (mrShape.isTextBox())
 553                         dynamic_cast<SimpleShape&>(mrShape).setService(
 554                             u"com.sun.star.drawing.CustomShape"_ustr);
 555                     else
 556                         dynamic_cast<SimpleShape&>(mrShape).setService(
 557                             u"com.sun.star.drawing.TextShape"_ustr);
 558                 }
 559                 else
 560                     // FIXME: without this we does not handle some properties like shadow
 561                     dynamic_cast<SimpleShape&>(mrShape).setService(u"com.sun.star.text.TextFrame"_ustr);
 562             }
 563             return new TextBoxContext( *this, mrShapeModel.createTextBox(mrShape.getTypeModel()), rAttribs,
 564                 mrShape.getDrawing().getFilter().getGraphicHelper());
 565         }
 566         case VMLX_TOKEN( ClientData ):
 567             // tdf#41466 ActiveX control shapes with a textbox are transformed into a frame
 568             // (see unit test testActiveXOptionButtonGroup)
 569             dynamic_cast<SimpleShape&>(mrShape).setService(u"com.sun.star.text.TextFrame"_ustr);
 570             return new ClientDataContext( *this, mrShapeModel.createClientData(), rAttribs );
 571         case VMLPPT_TOKEN( textdata ):
 572             // Force RectangleShape, this is ugly :(
 573             // and is there because of the lines above which change it to TextFrame
 574             dynamic_cast< SimpleShape& >( mrShape ).setService(
 575                     u"com.sun.star.drawing.RectangleShape"_ustr);
 576             mrShapeModel.maLegacyDiagramPath = getFragmentPathFromRelId(rAttribs.getStringDefaulted(XML_id));
 577             break;
 578         case O_TOKEN( signatureline ):
 579             mrShapeModel.mbIsSignatureLine = true;
 580             mrShapeModel.maSignatureId = rAttribs.getStringDefaulted(XML_id);
 581             mrShapeModel.maSignatureLineSuggestedSignerName
 582                 = rAttribs.getStringDefaulted(O_TOKEN(suggestedsigner));
 583             mrShapeModel.maSignatureLineSuggestedSignerTitle
 584                 = rAttribs.getStringDefaulted(O_TOKEN(suggestedsigner2));
 585             mrShapeModel.maSignatureLineSuggestedSignerEmail
 586                 = rAttribs.getStringDefaulted(O_TOKEN(suggestedsigneremail));
 587             mrShapeModel.maSignatureLineSigningInstructions
 588                 = rAttribs.getStringDefaulted(O_TOKEN(signinginstructions));
 589             mrShapeModel.mbSignatureLineShowSignDate = ConversionHelper::decodeBool(
 590                 rAttribs.getString(XML_showsigndate, u"t"_ustr)); // default is true
 591             mrShapeModel.mbSignatureLineCanAddComment = ConversionHelper::decodeBool(
 592                 rAttribs.getString(XML_allowcomments, u"f"_ustr)); // default is false
 593             break;
 594         case O_TOKEN( lock ):
 595             // TODO
 596             break;
 597     }
 598     // handle remaining stuff in base class
 599     return ShapeTypeContext::onCreateContext( nElement, rAttribs );
 600 }
 601 void ShapeContext::setWriterShape()
 602 {
 603     mrShape.setTextBox(true);
 604 }
 605
 606 void ShapeContext::setPoints(std::u16string_view rPoints)
 607 {
 608     mrShapeModel.maPoints.clear();
 609     sal_Int32 nIndex = 0;
 610
 611     while (nIndex >= 0)
 612     {
 613         sal_Int32 nX = ConversionHelper::decodeMeasureToTwip(
 614             mrShape.getDrawing().getFilter().getGraphicHelper(), o3tl::getToken(rPoints, 0, ',', nIndex),
 615             0, true, true);
 616         sal_Int32 nY = ConversionHelper::decodeMeasureToTwip(
 617             mrShape.getDrawing().getFilter().getGraphicHelper(), o3tl::getToken(rPoints, 0, ',', nIndex),
 618             0, false, true);
 619         mrShapeModel.maPoints.emplace_back(nX, nY);
 620     }
 621     // VML polyline has no size in its style attribute. Word writes the size to attribute
 622     // coordsize with values in twip but without unit. For others we get size from points.
 623     if (!mrShape.getTypeModel().maWidth.isEmpty() || !mrShape.getTypeModel().maHeight.isEmpty())
 624         return;
 625
 626     if (mrShape.getTypeModel().moCoordSize.has_value())
 627     {
 628         double fWidth = mrShape.getTypeModel().moCoordSize.value().first;
 629         fWidth = o3tl::convert(fWidth, o3tl::Length::twip, o3tl::Length::pt);
 630         double fHeight = mrShape.getTypeModel().moCoordSize.value().second;
 631         fHeight = o3tl::convert(fHeight, o3tl::Length::twip, o3tl::Length::pt);
 632         mrShape.getTypeModel().maWidth = OUString::number(fWidth) + "pt";
 633         mrShape.getTypeModel().maHeight = OUString::number(fHeight) + "pt";
 634     }
 635     else if (mrShapeModel.maPoints.size())
 636     {
 637         double fMinX = mrShapeModel.maPoints[0].X;
 638         double fMaxX = mrShapeModel.maPoints[0].X;
 639         double fMinY = mrShapeModel.maPoints[0].Y;
 640         double fMaxY = mrShapeModel.maPoints[0].Y;
 641         for (const auto& rPoint : mrShapeModel.maPoints)
 642         {
 643             if (rPoint.X < fMinX)
 644                 fMinX = rPoint.X;
 645             else if (rPoint.X > fMaxX)
 646                 fMaxX = rPoint.X;
 647             if (rPoint.Y < fMinY)
 648                 fMinY = rPoint.Y;
 649             else if (rPoint.Y > fMaxY)
 650                 fMaxY = rPoint.Y;
 651         }
 652         mrShape.getTypeModel().maWidth
 653             = OUString::number(
 654                   o3tl::convert(fMaxX - fMinX, o3tl::Length::twip, o3tl::Length::pt))
 655               + "pt";
 656         mrShape.getTypeModel().maHeight
 657             = OUString::number(
 658                   o3tl::convert(fMaxY - fMinY, o3tl::Length::twip, o3tl::Length::pt))
 659               + "pt";
 660         // Set moCoordSize, otherwise default (1000,1000) is used.
 661         mrShape.getTypeModel().moCoordSize =
 662             Int32Pair(basegfx::fround(fMaxX - fMinX), basegfx::fround(fMaxY - fMinY));
 663     }
 664 }
 665
 666 void ShapeContext::setFrom( const OUString& rPoints )
 667 {
 668     if (!rPoints.isEmpty())
 669         mrShapeModel.maFrom = rPoints;
 670 }
 671
 672 void ShapeContext::setTo( const OUString& rPoints )
 673 {
 674     if (!rPoints.isEmpty())
 675         mrShapeModel.maTo = rPoints;
 676 }
 677
 678 void ShapeContext::setControl1( const OUString& rPoints )
 679 {
 680     if (!rPoints.isEmpty())
 681         mrShapeModel.maControl1 = rPoints;
 682 }
 683
 684 void ShapeContext::setControl2( const OUString& rPoints )
 685 {
 686     if (!rPoints.isEmpty())
 687         mrShapeModel.maControl2 = rPoints;
 688 }
 689 void ShapeContext::setVmlPath( const OUString& rPath )
 690 {
 691     if (!rPath.isEmpty())
 692         mrShapeModel.maVmlPath = rPath;
 693 }
 694
 695 void ShapeContext::setHyperlink( const OUString& rHyperlink )
 696 {
 697     if (!rHyperlink.isEmpty())
 698         mrShapeModel.maHyperlink = rHyperlink;
 699 }
 700
 701 GroupShapeContext::GroupShapeContext(ContextHandler2Helper const& rParent,
 702                                      const std::shared_ptr<GroupShape>& pShape,
 703                                      const AttributeList& rAttribs)
 704     : ShapeContext(rParent, pShape, rAttribs)
 705     , mrShapes(pShape->getChildren())
 706 {
 707 }
 708
 709 ContextHandlerRef GroupShapeContext::onCreateContext( sal_Int32 nElement, const AttributeList& rAttribs )
 710 {
 711     // try to create a context of an embedded shape
 712     ContextHandlerRef xContext = createShapeContext( *this, mrShapes, nElement, rAttribs );
 713     // handle remaining stuff of this shape in base class
 714     return xContext ? xContext : ShapeContext::onCreateContext( nElement, rAttribs );
 715 }
 716
 717 RectangleShapeContext::RectangleShapeContext(ContextHandler2Helper const& rParent,
 718                                              const AttributeList& rAttribs,
 719                                              const std::shared_ptr<RectangleShape>& pShape)
 720     : ShapeContext(rParent, pShape, rAttribs)
 721 {
 722 }
 723
 724 ContextHandlerRef RectangleShapeContext::onCreateContext( sal_Int32 nElement, const AttributeList& rAttribs )
 725 {
 726     // The parent class's context is fine
 727     return ShapeContext::onCreateContext( nElement, rAttribs );
 728 }
 729
 730 ControlShapeContext::ControlShapeContext( ::oox::core::ContextHandler2Helper const & rParent, ShapeContainer& rShapes, const AttributeList& rAttribs )
 731     : ShapeContextBase (rParent)
 732 {
 733     ::oox::vml::ControlInfo aInfo;
 734     aInfo.maShapeId = rAttribs.getXString( W_TOKEN( shapeid ), OUString() );
 735     aInfo.maFragmentPath = getFragmentPathFromRelId(rAttribs.getStringDefaulted( R_TOKEN(id)));
 736     aInfo.maName = rAttribs.getStringDefaulted( W_TOKEN( name ));
 737     aInfo.mbTextContentShape = true;
 738     rShapes.getDrawing().registerControl(aInfo);
 739 }
 740
 741 } // namespace oox
 742
 743 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */