LCOV - code coverage report
Current view: top level - libreoffice/oox/source/vml - vmlshapecontext.cxx (source / functions) Hit Total Coverage
Test: libreoffice_filtered.info Lines: 219 260 84.2 %
Date: 2012-12-17 Functions: 31 31 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       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 "oox/vml/vmlshapecontext.hxx"
      21             : 
      22             : #include "oox/core/xmlfilterbase.hxx"
      23             : #include "oox/vml/vmldrawing.hxx"
      24             : #include "oox/vml/vmlshape.hxx"
      25             : #include "oox/vml/vmlshapecontainer.hxx"
      26             : #include "oox/vml/vmltextboxcontext.hxx"
      27             : 
      28             : namespace oox {
      29             : namespace vml {
      30             : 
      31             : // ============================================================================
      32             : 
      33             : using namespace ::com::sun::star;
      34             : 
      35             : using ::oox::core::ContextHandler2;
      36             : using ::oox::core::ContextHandler2Helper;
      37             : using ::oox::core::ContextHandlerRef;
      38             : using ::rtl::OUString;
      39             : 
      40             : // ============================================================================
      41             : 
      42             : namespace {
      43             : 
      44             : /** Returns the boolean value from the specified VML attribute (if present).
      45             :  */
      46         274 : OptValue< bool > lclDecodeBool( const AttributeList& rAttribs, sal_Int32 nToken )
      47             : {
      48         274 :     OptValue< OUString > oValue = rAttribs.getString( nToken );
      49         274 :     if( oValue.has() ) return OptValue< bool >( ConversionHelper::decodeBool( oValue.get() ) );
      50         222 :     return OptValue< bool >();
      51             : }
      52             : 
      53             : /** Returns the percentage value from the specified VML attribute (if present).
      54             :     The value will be normalized (1.0 is returned for 100%).
      55             :  */
      56          46 : OptValue< double > lclDecodePercent( const AttributeList& rAttribs, sal_Int32 nToken, double fDefValue )
      57             : {
      58          46 :     OptValue< OUString > oValue = rAttribs.getString( nToken );
      59          46 :     if( oValue.has() ) return OptValue< double >( ConversionHelper::decodePercent( oValue.get(), fDefValue ) );
      60          46 :     return OptValue< double >();
      61             : }
      62             : 
      63             : /** Returns the integer value pair from the specified VML attribute (if present).
      64             :  */
      65         156 : OptValue< Int32Pair > lclDecodeInt32Pair( const AttributeList& rAttribs, sal_Int32 nToken )
      66             : {
      67         156 :     OptValue< OUString > oValue = rAttribs.getString( nToken );
      68         156 :     OptValue< Int32Pair > oRetValue;
      69         156 :     if( oValue.has() )
      70             :     {
      71          34 :         OUString aValue1, aValue2;
      72          34 :         ConversionHelper::separatePair( aValue1, aValue2, oValue.get(), ',' );
      73          34 :         oRetValue = Int32Pair( aValue1.toInt32(), aValue2.toInt32() );
      74             :     }
      75         156 :     return oRetValue;
      76             : }
      77             : 
      78             : /** Returns the percentage pair from the specified VML attribute (if present).
      79             :  */
      80          12 : OptValue< DoublePair > lclDecodePercentPair( const AttributeList& rAttribs, sal_Int32 nToken )
      81             : {
      82          12 :     OptValue< OUString > oValue = rAttribs.getString( nToken );
      83          12 :     OptValue< DoublePair > oRetValue;
      84          12 :     if( oValue.has() )
      85             :     {
      86           0 :         OUString aValue1, aValue2;
      87           0 :         ConversionHelper::separatePair( aValue1, aValue2, oValue.get(), ',' );
      88             :         oRetValue = DoublePair(
      89           0 :             ConversionHelper::decodePercent( aValue1, 0.0 ),
      90           0 :             ConversionHelper::decodePercent( aValue2, 0.0 ) );
      91             :     }
      92          12 :     return oRetValue;
      93             : }
      94             : 
      95             : /** Returns the boolean value from the passed string of an attribute in the x:
      96             :     namespace (VML for spreadsheets). Supported values: f, t, False, True.
      97             :     @param bDefaultForEmpty  Default value for the empty string.
      98             :  */
      99           2 : bool lclDecodeVmlxBool( const OUString& rValue, bool bDefaultForEmpty )
     100             : {
     101           2 :     if( rValue.isEmpty() ) return bDefaultForEmpty;
     102           0 :     sal_Int32 nToken = AttributeConversion::decodeToken( rValue );
     103             :     // anything else than 't' or 'True' is considered to be false, as specified
     104           0 :     return (nToken == XML_t) || (nToken == XML_True);
     105             : }
     106             : 
     107             : } // namespace
     108             : 
     109             : // ============================================================================
     110             : 
     111           2 : ShapeLayoutContext::ShapeLayoutContext( ContextHandler2Helper& rParent, Drawing& rDrawing ) :
     112             :     ContextHandler2( rParent ),
     113           2 :     mrDrawing( rDrawing )
     114             : {
     115           2 : }
     116             : 
     117             : 
     118           2 : ContextHandlerRef ShapeLayoutContext::onCreateContext( sal_Int32 nElement, const AttributeList& rAttribs )
     119             : {
     120           2 :     switch( nElement )
     121             :     {
     122             :         case O_TOKEN( idmap ):
     123             :         {
     124           2 :             OUString aBlockIds = rAttribs.getString( XML_data, OUString() );
     125           2 :             sal_Int32 nIndex = 0;
     126           6 :             while( nIndex >= 0 )
     127             :             {
     128           2 :                 OUString aToken = aBlockIds.getToken( 0, ' ', nIndex ).trim();
     129           2 :                 if( !aToken.isEmpty() )
     130           2 :                     mrDrawing.registerBlockId( aToken.toInt32() );
     131           4 :             }
     132             :         }
     133           2 :         break;
     134             :     }
     135           2 :     return 0;
     136             : }
     137             : 
     138             : // ============================================================================
     139             : 
     140           4 : ClientDataContext::ClientDataContext( ContextHandler2Helper& rParent,
     141             :         ClientData& rClientData, const AttributeList& rAttribs ) :
     142             :     ContextHandler2( rParent ),
     143           4 :     mrClientData( rClientData )
     144             : {
     145           4 :     mrClientData.mnObjType = rAttribs.getToken( XML_ObjectType, XML_TOKEN_INVALID );
     146           4 : }
     147             : 
     148          26 : ContextHandlerRef ClientDataContext::onCreateContext( sal_Int32 /*nElement*/, const AttributeList& /*rAttribs*/ )
     149             : {
     150          26 :     if( isRootElement() )
     151             :     {
     152          26 :         maElementText = OUString();
     153          26 :         return this;
     154             :     }
     155           0 :     return 0;
     156             : }
     157             : 
     158          34 : void ClientDataContext::onCharacters( const OUString& rChars )
     159             : {
     160             :     /*  Empty but existing elements have special meaning, e.g. 'true'. Collect
     161             :         existing text and convert it in onEndElement(). */
     162          34 :     maElementText = rChars;
     163          34 : }
     164             : 
     165          30 : void ClientDataContext::onEndElement()
     166             : {
     167          30 :     switch( getCurrentElement() )
     168             :     {
     169           4 :         case VMLX_TOKEN( Anchor ):      mrClientData.maAnchor = maElementText;                                          break;
     170           0 :         case VMLX_TOKEN( FmlaMacro ):   mrClientData.maFmlaMacro = maElementText;                                       break;
     171           0 :         case VMLX_TOKEN( FmlaPict ):    mrClientData.maFmlaPict = maElementText;                                        break;
     172           0 :         case VMLX_TOKEN( FmlaLink ):    mrClientData.maFmlaLink = maElementText;                                        break;
     173           0 :         case VMLX_TOKEN( FmlaRange ):   mrClientData.maFmlaRange = maElementText;                                       break;
     174           0 :         case VMLX_TOKEN( FmlaGroup ):   mrClientData.maFmlaGroup = maElementText;                                       break;
     175           0 :         case VMLX_TOKEN( TextHAlign ):  mrClientData.mnTextHAlign = AttributeConversion::decodeToken( maElementText );  break;
     176           2 :         case VMLX_TOKEN( TextVAlign ):  mrClientData.mnTextVAlign = AttributeConversion::decodeToken( maElementText );  break;
     177           2 :         case VMLX_TOKEN( Column ):      mrClientData.mnCol = maElementText.toInt32();                                   break;
     178           2 :         case VMLX_TOKEN( Row ):         mrClientData.mnRow = maElementText.toInt32();                                   break;
     179           2 :         case VMLX_TOKEN( Checked ):     mrClientData.mnChecked = maElementText.toInt32();                               break;
     180           0 :         case VMLX_TOKEN( DropStyle ):   mrClientData.mnDropStyle = AttributeConversion::decodeToken( maElementText );   break;
     181           0 :         case VMLX_TOKEN( DropLines ):   mrClientData.mnDropLines = maElementText.toInt32();                             break;
     182           0 :         case VMLX_TOKEN( Val ):         mrClientData.mnVal = maElementText.toInt32();                                   break;
     183           0 :         case VMLX_TOKEN( Min ):         mrClientData.mnMin = maElementText.toInt32();                                   break;
     184           0 :         case VMLX_TOKEN( Max ):         mrClientData.mnMax = maElementText.toInt32();                                   break;
     185           0 :         case VMLX_TOKEN( Inc ):         mrClientData.mnInc = maElementText.toInt32();                                   break;
     186           0 :         case VMLX_TOKEN( Page ):        mrClientData.mnPage = maElementText.toInt32();                                  break;
     187           0 :         case VMLX_TOKEN( SelType ):     mrClientData.mnSelType = AttributeConversion::decodeToken( maElementText );     break;
     188           0 :         case VMLX_TOKEN( VTEdit ):      mrClientData.mnVTEdit = maElementText.toInt32();                                break;
     189           0 :         case VMLX_TOKEN( PrintObject ): mrClientData.mbPrintObject = lclDecodeVmlxBool( maElementText, true );          break;
     190           0 :         case VMLX_TOKEN( Visible ):     mrClientData.mbVisible = lclDecodeVmlxBool( maElementText, true );              break;
     191           0 :         case VMLX_TOKEN( DDE ):         mrClientData.mbDde = lclDecodeVmlxBool( maElementText, true );                  break;
     192           2 :         case VMLX_TOKEN( NoThreeD ):    mrClientData.mbNo3D = lclDecodeVmlxBool( maElementText, true );                 break;
     193           0 :         case VMLX_TOKEN( NoThreeD2 ):   mrClientData.mbNo3D2 = lclDecodeVmlxBool( maElementText, true );                break;
     194           0 :         case VMLX_TOKEN( MultiLine ):   mrClientData.mbMultiLine = lclDecodeVmlxBool( maElementText, true );            break;
     195           0 :         case VMLX_TOKEN( VScroll ):     mrClientData.mbVScroll = lclDecodeVmlxBool( maElementText, true );              break;
     196           0 :         case VMLX_TOKEN( SecretEdit ):  mrClientData.mbSecretEdit = lclDecodeVmlxBool( maElementText, true );           break;
     197             :     }
     198          30 : }
     199             : 
     200             : // ============================================================================
     201             : 
     202          78 : ShapeContextBase::ShapeContextBase( ContextHandler2Helper& rParent ) :
     203          78 :     ContextHandler2( rParent )
     204             : {
     205          78 : }
     206             : 
     207          82 : /*static*/ ContextHandlerRef ShapeContextBase::createShapeContext( ContextHandler2Helper& rParent,
     208             :         ShapeContainer& rShapes, sal_Int32 nElement, const AttributeList& rAttribs )
     209             : {
     210          82 :     switch( nElement )
     211             :     {
     212             :         case O_TOKEN( shapelayout ):
     213           2 :             return new ShapeLayoutContext( rParent, rShapes.getDrawing() );
     214             : 
     215             :         case VML_TOKEN( shapetype ):
     216          24 :             return new ShapeTypeContext( rParent, rShapes.createShapeType(), rAttribs );
     217             :         case VML_TOKEN( group ):
     218           4 :             return new GroupShapeContext( rParent, rShapes.createShape< GroupShape >(), rAttribs );
     219             :         case VML_TOKEN( shape ):
     220          30 :             if (rAttribs.hasAttribute(XML_path))
     221           2 :                 return new ShapeContext( rParent, rShapes.createShape< BezierShape >(), rAttribs );
     222             :             else
     223          28 :                 return new ShapeContext( rParent, rShapes.createShape< ComplexShape >(), rAttribs );
     224             :         case VML_TOKEN( rect ):
     225          14 :             return new RectangleShapeContext( rParent, rAttribs, rShapes.createShape< RectangleShape >() );
     226             :         case VML_TOKEN( roundrect ):
     227           2 :             return new ShapeContext( rParent, rShapes.createShape< RectangleShape >(), rAttribs );
     228             :         case VML_TOKEN( oval ):
     229           2 :             return new ShapeContext( rParent, rShapes.createShape< EllipseShape >(), rAttribs );
     230             :         case VML_TOKEN( polyline ):
     231           0 :             return new ShapeContext( rParent, rShapes.createShape< PolyLineShape >(), rAttribs );
     232             :         case VML_TOKEN( line ):
     233           2 :             return new ShapeContext( rParent, rShapes.createShape< LineShape >(), rAttribs );
     234             :         case VML_TOKEN( curve ):
     235           0 :             return new ShapeContext( rParent, rShapes.createShape< BezierShape >(), rAttribs );
     236             : 
     237             :         // TODO:
     238             :         case VML_TOKEN( arc ):
     239             :         case VML_TOKEN( diagram ):
     240             :         case VML_TOKEN( image ):
     241           0 :             return new ShapeContext( rParent, rShapes.createShape< ComplexShape >(), rAttribs );
     242             :     }
     243           2 :     return 0;
     244             : }
     245             : 
     246             : // ============================================================================
     247             : 
     248          78 : ShapeTypeContext::ShapeTypeContext( ContextHandler2Helper& rParent, ShapeType& rShapeType, const AttributeList& rAttribs ) :
     249             :     ShapeContextBase( rParent ),
     250          78 :     mrTypeModel( rShapeType.getTypeModel() )
     251             : {
     252             :     // shape identifier and shape name
     253          78 :     bool bHasOspid = rAttribs.hasAttribute( O_TOKEN( spid ) );
     254          78 :     mrTypeModel.maShapeId = rAttribs.getXString( bHasOspid ? O_TOKEN( spid ) : XML_id, OUString() );
     255             :     OSL_ENSURE( !mrTypeModel.maShapeId.isEmpty(), "ShapeTypeContext::ShapeTypeContext - missing shape identifier" );
     256             :     // if the o:spid attribute exists, the id attribute contains the user-defined shape name
     257          78 :     if( bHasOspid )
     258           8 :         mrTypeModel.maShapeName = rAttribs.getXString( XML_id, OUString() );
     259             :     // builtin shape type identifier
     260          78 :     mrTypeModel.moShapeType = rAttribs.getInteger( O_TOKEN( spt ) );
     261             : 
     262             :     // coordinate system position/size, CSS style
     263          78 :     mrTypeModel.moCoordPos = lclDecodeInt32Pair( rAttribs, XML_coordorigin );
     264          78 :     mrTypeModel.moCoordSize = lclDecodeInt32Pair( rAttribs, XML_coordsize );
     265          78 :     setStyle( rAttribs.getString( XML_style, OUString() ) );
     266          78 :     if( lclDecodeBool( rAttribs, O_TOKEN( hr )).get( false ))
     267             :     {   // MSO's handling of o:hr width is nowhere near what the spec says:
     268             :         // - o:hrpct is not in % but in 0.1%
     269             :         // - if o:hrpct is not given, 100% width is assumed
     270             :         // - given width is used only if explicit o:hrpct="0" is given
     271           0 :         OUString hrpct = rAttribs.getString( O_TOKEN( hrpct ), "1000" );
     272           0 :         if( hrpct != "0" )
     273           0 :             mrTypeModel.maWidth = OUString::valueOf( hrpct.toInt32() / 10 ) + "%";
     274             :     }
     275             : 
     276             :     // stroke settings (may be overridden by v:stroke element later)
     277          78 :     mrTypeModel.maStrokeModel.moStroked = lclDecodeBool( rAttribs, XML_stroked );
     278          78 :     mrTypeModel.maStrokeModel.moColor = rAttribs.getString( XML_strokecolor );
     279          78 :     mrTypeModel.maStrokeModel.moWeight = rAttribs.getString( XML_strokeweight );
     280             : 
     281             :     // fill settings (may be overridden by v:fill element later)
     282          78 :     mrTypeModel.maFillModel.moFilled = lclDecodeBool( rAttribs, XML_filled );
     283          78 :     mrTypeModel.maFillModel.moColor = rAttribs.getString( XML_fillcolor );
     284             : 
     285             :     // For roundrect we may have a arcsize attribute to read
     286          78 :     mrTypeModel.maArcsize = rAttribs.getString( XML_arcsize,rtl::OUString( ) );
     287          78 : }
     288             : 
     289         110 : ContextHandlerRef ShapeTypeContext::onCreateContext( sal_Int32 nElement, const AttributeList& rAttribs )
     290             : {
     291         110 :     if( isRootElement() ) switch( nElement )
     292             :     {
     293             :         case VML_TOKEN( stroke ):
     294          28 :             mrTypeModel.maStrokeModel.moStroked.assignIfUsed( lclDecodeBool( rAttribs, XML_on ) );
     295          28 :             mrTypeModel.maStrokeModel.maStartArrow.moArrowType = rAttribs.getToken( XML_startarrow );
     296          28 :             mrTypeModel.maStrokeModel.maStartArrow.moArrowWidth = rAttribs.getToken( XML_startarrowwidth );
     297          28 :             mrTypeModel.maStrokeModel.maStartArrow.moArrowLength = rAttribs.getToken( XML_startarrowlength );
     298          28 :             mrTypeModel.maStrokeModel.maEndArrow.moArrowType = rAttribs.getToken( XML_endarrow );
     299          28 :             mrTypeModel.maStrokeModel.maEndArrow.moArrowWidth = rAttribs.getToken( XML_endarrowwidth );
     300          28 :             mrTypeModel.maStrokeModel.maEndArrow.moArrowLength = rAttribs.getToken( XML_endarrowlength );
     301          28 :             mrTypeModel.maStrokeModel.moColor.assignIfUsed( rAttribs.getString( XML_color ) );
     302          28 :             mrTypeModel.maStrokeModel.moOpacity = lclDecodePercent( rAttribs, XML_opacity, 1.0 );
     303          28 :             mrTypeModel.maStrokeModel.moWeight.assignIfUsed( rAttribs.getString( XML_weight ) );
     304          28 :             mrTypeModel.maStrokeModel.moDashStyle = rAttribs.getString( XML_dashstyle );
     305          28 :             mrTypeModel.maStrokeModel.moLineStyle = rAttribs.getToken( XML_linestyle );
     306          28 :             mrTypeModel.maStrokeModel.moEndCap = rAttribs.getToken( XML_endcap );
     307          28 :             mrTypeModel.maStrokeModel.moJoinStyle = rAttribs.getToken( XML_joinstyle );
     308          28 :         break;
     309             :         case VML_TOKEN( fill ):
     310           6 :             mrTypeModel.maFillModel.moFilled.assignIfUsed( lclDecodeBool( rAttribs, XML_on ) );
     311           6 :             mrTypeModel.maFillModel.moColor.assignIfUsed( rAttribs.getString( XML_color ) );
     312           6 :             mrTypeModel.maFillModel.moOpacity = lclDecodePercent( rAttribs, XML_opacity, 1.0 );
     313           6 :             mrTypeModel.maFillModel.moColor2 = rAttribs.getString( XML_color2 );
     314           6 :             mrTypeModel.maFillModel.moOpacity2 = lclDecodePercent( rAttribs, XML_opacity2, 1.0 );
     315           6 :             mrTypeModel.maFillModel.moType = rAttribs.getToken( XML_type );
     316           6 :             mrTypeModel.maFillModel.moAngle = rAttribs.getInteger( XML_angle );
     317           6 :             mrTypeModel.maFillModel.moFocus = lclDecodePercent( rAttribs, XML_focus, 0.0 );
     318           6 :             mrTypeModel.maFillModel.moFocusPos = lclDecodePercentPair( rAttribs, XML_focusposition );
     319           6 :             mrTypeModel.maFillModel.moFocusSize = lclDecodePercentPair( rAttribs, XML_focussize );
     320           6 :             mrTypeModel.maFillModel.moBitmapPath = decodeFragmentPath( rAttribs, O_TOKEN( relid ) );
     321           6 :             mrTypeModel.maFillModel.moRotate = lclDecodeBool( rAttribs, XML_rotate );
     322           6 :         break;
     323             :         case VML_TOKEN( imagedata ):
     324             :         {
     325             :             // shapes in docx use r:id for the relationship id
     326             :             // in xlsx it they use o:relid
     327          12 :             bool bHasORelId = rAttribs.hasAttribute( O_TOKEN( relid ) );
     328          12 :             mrTypeModel.moGraphicPath = decodeFragmentPath( rAttribs, bHasORelId ? O_TOKEN( relid ) : R_TOKEN( id ) );
     329          12 :             mrTypeModel.moGraphicTitle = rAttribs.getString( O_TOKEN( title ) );
     330             :         }
     331          12 :         break;
     332             :         case NMSP_vmlWord | XML_wrap:
     333          20 :             mrTypeModel.moWrapAnchorX = rAttribs.getString(XML_anchorx);
     334          20 :             mrTypeModel.moWrapAnchorY = rAttribs.getString(XML_anchory);
     335          20 :         break;
     336             :     }
     337         110 :     return 0;
     338             : }
     339             : 
     340          18 : OptValue< OUString > ShapeTypeContext::decodeFragmentPath( const AttributeList& rAttribs, sal_Int32 nToken ) const
     341             : {
     342          18 :     OptValue< OUString > oFragmentPath;
     343          18 :     OptValue< OUString > oRelId = rAttribs.getString( nToken );
     344          18 :     if( oRelId.has() )
     345          12 :         oFragmentPath = getFragmentPathFromRelId( oRelId.get() );
     346          18 :     return oFragmentPath;
     347             : }
     348             : 
     349          78 : void ShapeTypeContext::setStyle( const OUString& rStyle )
     350             : {
     351          78 :     sal_Int32 nIndex = 0;
     352         646 :     while( nIndex >= 0 )
     353             :     {
     354         490 :         OUString aName, aValue;
     355         490 :         if( ConversionHelper::separatePair( aName, aValue, rStyle.getToken( 0, ';', nIndex ), ':' ) )
     356             :         {
     357         466 :                  if( aName == "position" )      mrTypeModel.maPosition = aValue;
     358         420 :             else if( aName == "left" )           mrTypeModel.maLeft = aValue;
     359         408 :             else if( aName == "top" )            mrTypeModel.maTop = aValue;
     360         400 :             else if( aName == "width" )          mrTypeModel.maWidth = aValue;
     361         348 :             else if( aName == "height" )         mrTypeModel.maHeight = aValue;
     362         296 :             else if( aName == "margin-left" )    mrTypeModel.maMarginLeft = aValue;
     363         262 :             else if( aName == "margin-top" )     mrTypeModel.maMarginTop = aValue;
     364         228 :             else if( aName == "mso-position-vertical-relative" )  mrTypeModel.maPositionVerticalRelative = aValue;
     365         206 :             else if( aName == "mso-position-horizontal-relative" )  mrTypeModel.maPositionHorizontalRelative = aValue;
     366         184 :             else if( aName == "mso-position-horizontal" ) mrTypeModel.maPositionHorizontal = aValue;
     367         166 :             else if( aName == "mso-position-vertical" ) mrTypeModel.maPositionVertical = aValue;
     368         150 :             else if( aName == "mso-width-percent" ) mrTypeModel.maWidthPercent = aValue;
     369         118 :             else if( aName == "mso-width-relative" ) mrTypeModel.maWidthRelative = aValue;
     370         108 :             else if( aName == "mso-height-percent" ) mrTypeModel.maHeightPercent = aValue;
     371          88 :             else if( aName == "mso-height-relative" ) mrTypeModel.maHeightRelative = aValue;
     372          76 :             else if( aName == "mso-fit-shape-to-text" )           mrTypeModel.mbAutoHeight = sal_True;
     373          76 :             else if( aName == "rotation" )       mrTypeModel.maRotation = aValue;
     374          74 :             else if( aName == "flip" )       mrTypeModel.maFlip = aValue;
     375          72 :             else if( aName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "visibility" ) ) )
     376           8 :                 mrTypeModel.mbVisible = !aValue.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM("hidden") );
     377          64 :             else if( aName == "mso-wrap-style" ) mrTypeModel.maWrapStyle = aValue;
     378             :         }
     379         490 :     }
     380          78 : }
     381             : 
     382             : // ============================================================================
     383             : 
     384          54 : ShapeContext::ShapeContext( ContextHandler2Helper& rParent, ShapeBase& rShape, const AttributeList& rAttribs ) :
     385             :     ShapeTypeContext( rParent, rShape, rAttribs ),
     386             :     mrShape( rShape ),
     387          54 :     mrShapeModel( rShape.getShapeModel() )
     388             : {
     389             :     // collect shape specific attributes
     390          54 :     mrShapeModel.maType = rAttribs.getXString( XML_type, OUString() );
     391             :     // polyline path
     392          54 :     setPoints( rAttribs.getString( XML_points, OUString() ) );
     393             :     // line start and end positions
     394          54 :     setFrom(rAttribs.getString(XML_from, OUString()));
     395          54 :     setTo(rAttribs.getString(XML_to, OUString()));
     396          54 :     setControl1(rAttribs.getString(XML_control1, OUString()));
     397          54 :     setControl2(rAttribs.getString(XML_control2, OUString()));
     398          54 :     setVmlPath(rAttribs.getString(XML_path, OUString()));
     399          54 : }
     400             : 
     401          86 : ContextHandlerRef ShapeContext::onCreateContext( sal_Int32 nElement, const AttributeList& rAttribs )
     402             : {
     403             :     // Excel specific shape client data
     404          86 :     if( isRootElement() ) switch( nElement )
     405             :     {
     406             :         case VML_TOKEN( textbox ):
     407             :             // Custom shape in Writer with a textbox are transformed into a frame
     408          26 :             dynamic_cast<SimpleShape&>( mrShape ).setService(
     409          52 :                     "com.sun.star.text.TextFrame");
     410          26 :             return new TextBoxContext( *this, mrShapeModel.createTextBox(), rAttribs,
     411          52 :                 mrShape.getDrawing().getFilter().getGraphicHelper());
     412             :         case VMLX_TOKEN( ClientData ):
     413           4 :             return new ClientDataContext( *this, mrShapeModel.createClientData(), rAttribs );
     414             :         case VMLPPT_TOKEN( textdata ):
     415             :             // Force RectangleShape, this is ugly :(
     416             :             // and is there because of the lines above which change it to TextFrame
     417           0 :             dynamic_cast< SimpleShape& >( mrShape ).setService(
     418           0 :                     "com.sun.star.drawing.RectangleShape");
     419           0 :             mrShapeModel.maLegacyDiagramPath = getFragmentPathFromRelId(rAttribs.getString(XML_id, OUString()));
     420           0 :             break;
     421             :     }
     422             :     // handle remaining stuff in base class
     423          56 :     return ShapeTypeContext::onCreateContext( nElement, rAttribs );
     424             : }
     425             : 
     426          54 : void ShapeContext::setPoints( const OUString& rPoints )
     427             : {
     428          54 :     mrShapeModel.maPoints.clear();
     429          54 :     sal_Int32 nIndex = 0;
     430             : 
     431         162 :     while( nIndex >= 0 )
     432             :     {
     433          54 :         sal_Int32 nX = rPoints.getToken( 0, ',', nIndex ).toInt32();
     434          54 :         sal_Int32 nY = rPoints.getToken( 0, ',', nIndex ).toInt32();
     435          54 :         mrShapeModel.maPoints.push_back( awt::Point( nX, nY ) );
     436             :     }
     437          54 : }
     438             : 
     439          54 : void ShapeContext::setFrom( const OUString& rPoints )
     440             : {
     441          54 :     if (!rPoints.isEmpty())
     442           2 :         mrShapeModel.maFrom = rPoints;
     443          54 : }
     444             : 
     445          54 : void ShapeContext::setTo( const OUString& rPoints )
     446             : {
     447          54 :     if (!rPoints.isEmpty())
     448           2 :         mrShapeModel.maTo = rPoints;
     449          54 : }
     450             : 
     451          54 : void ShapeContext::setControl1( const OUString& rPoints )
     452             : {
     453          54 :     if (!rPoints.isEmpty())
     454           0 :         mrShapeModel.maControl1 = rPoints;
     455          54 : }
     456             : 
     457          54 : void ShapeContext::setControl2( const OUString& rPoints )
     458             : {
     459          54 :     if (!rPoints.isEmpty())
     460           0 :         mrShapeModel.maControl2 = rPoints;
     461          54 : }
     462          54 : void ShapeContext::setVmlPath( const OUString& rPath )
     463             : {
     464          54 :     if (!rPath.isEmpty())
     465           2 :         mrShapeModel.maVmlPath = rPath;
     466          54 : }
     467             : 
     468             : 
     469             : // ============================================================================
     470             : 
     471           4 : GroupShapeContext::GroupShapeContext( ContextHandler2Helper& rParent, GroupShape& rShape, const AttributeList& rAttribs ) :
     472             :     ShapeContext( rParent, rShape, rAttribs ),
     473           4 :     mrShapes( rShape.getChildren() )
     474             : {
     475           4 : }
     476             : 
     477          10 : ContextHandlerRef GroupShapeContext::onCreateContext( sal_Int32 nElement, const AttributeList& rAttribs )
     478             : {
     479             :     // try to create a context of an embedded shape
     480          10 :     ContextHandlerRef xContext = createShapeContext( *this, mrShapes, nElement, rAttribs );
     481             :     // handle remaining stuff of this shape in base class
     482          10 :     return xContext.get() ? xContext : ShapeContext::onCreateContext( nElement, rAttribs );
     483             : }
     484             : 
     485             : // ============================================================================
     486             : 
     487          14 : RectangleShapeContext::RectangleShapeContext( ContextHandler2Helper& rParent, const AttributeList& rAttribs, RectangleShape& rShape ) :
     488          14 :     ShapeContext( rParent, rShape, rAttribs )
     489             : {
     490          14 : }
     491             : 
     492          18 : ContextHandlerRef RectangleShapeContext::onCreateContext( sal_Int32 nElement, const AttributeList& rAttribs )
     493             : {
     494             :     // The parent class's context is fine
     495          18 :     return ShapeContext::onCreateContext( nElement, rAttribs );
     496             : }
     497             : // ============================================================================
     498             : 
     499             : } // namespace vml
     500         174 : } // namespace oox
     501             : 
     502             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10