LCOV - code coverage report
Current view: top level - xmloff/source/style - MarkerStyle.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 71 0.0 %
Date: 2014-04-14 Functions: 0 6 0.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 <xmloff/MarkerStyle.hxx>
      21             : #include "xexptran.hxx"
      22             : #include <xmloff/attrlist.hxx>
      23             : #include <xmloff/nmspmap.hxx>
      24             : #include <xmloff/xmluconv.hxx>
      25             : #include <xmloff/xmlnmspe.hxx>
      26             : #include <xmloff/xmltoken.hxx>
      27             : #include <xmloff/xmlexp.hxx>
      28             : #include <xmloff/xmlimp.hxx>
      29             : #include <rtl/ustrbuf.hxx>
      30             : #include <rtl/ustring.hxx>
      31             : #include <com/sun/star/drawing/PolyPolygonBezierCoords.hpp>
      32             : #include <basegfx/polygon/b2dpolypolygon.hxx>
      33             : #include <basegfx/polygon/b2dpolypolygontools.hxx>
      34             : #include <basegfx/matrix/b2dhommatrixtools.hxx>
      35             : 
      36             : using namespace ::com::sun::star;
      37             : 
      38             : using namespace ::xmloff::token;
      39             : 
      40             : // Import
      41             : 
      42           0 : XMLMarkerStyleImport::XMLMarkerStyleImport( SvXMLImport& rImp )
      43           0 :     : rImport( rImp )
      44             : {
      45           0 : }
      46             : 
      47           0 : XMLMarkerStyleImport::~XMLMarkerStyleImport()
      48             : {
      49           0 : }
      50             : 
      51           0 : bool XMLMarkerStyleImport::importXML(
      52             :     const uno::Reference< xml::sax::XAttributeList >& xAttrList,
      53             :     uno::Any& rValue,
      54             :     OUString& rStrName )
      55             : {
      56           0 :     bool bHasViewBox    = false;
      57           0 :     bool bHasPathData   = false;
      58           0 :     OUString aDisplayName;
      59             : 
      60           0 :     SdXMLImExViewBox* pViewBox = NULL;
      61             : 
      62           0 :     SvXMLNamespaceMap& rNamespaceMap = rImport.GetNamespaceMap();
      63           0 :     SvXMLUnitConverter& rUnitConverter = rImport.GetMM100UnitConverter();
      64             : 
      65           0 :     OUString strPathData;
      66             : 
      67           0 :     sal_Int16 nAttrCount = xAttrList.is() ? xAttrList->getLength() : 0;
      68           0 :     for( sal_Int16 i = 0; i < nAttrCount; i++ )
      69             :     {
      70           0 :         OUString aStrFullAttrName = xAttrList->getNameByIndex( i );
      71           0 :         OUString aStrAttrName;
      72           0 :         rNamespaceMap.GetKeyByAttrName( aStrFullAttrName, &aStrAttrName );
      73           0 :         OUString aStrValue = xAttrList->getValueByIndex( i );
      74             : 
      75           0 :         if( IsXMLToken( aStrAttrName, XML_NAME ) )
      76             :         {
      77           0 :             rStrName = aStrValue;
      78             :         }
      79           0 :         else if( IsXMLToken( aStrAttrName, XML_DISPLAY_NAME ) )
      80             :         {
      81           0 :             aDisplayName = aStrValue;
      82             :         }
      83           0 :         else if( IsXMLToken( aStrAttrName, XML_VIEWBOX ) )
      84             :         {
      85           0 :             pViewBox = new SdXMLImExViewBox( aStrValue, rUnitConverter );
      86           0 :             bHasViewBox = true;
      87             : 
      88             :         }
      89           0 :         else if( IsXMLToken( aStrAttrName, XML_D ) )
      90             :         {
      91           0 :             strPathData = aStrValue;
      92           0 :             bHasPathData = true;
      93             :         }
      94           0 :     }
      95             : 
      96           0 :     if( bHasViewBox && bHasPathData )
      97             :     {
      98           0 :         basegfx::B2DPolyPolygon aPolyPolygon;
      99             : 
     100           0 :         if(basegfx::tools::importFromSvgD(aPolyPolygon, strPathData, rImport.needFixPositionAfterZ(), 0))
     101             :         {
     102           0 :             if(aPolyPolygon.count())
     103             :             {
     104             :                 // ViewBox probably not used, but stay with former processing inside of
     105             :                 // SdXMLImExSvgDElement
     106             :                 const basegfx::B2DRange aSourceRange(
     107             :                     pViewBox->GetX(), pViewBox->GetY(),
     108           0 :                     pViewBox->GetX() + pViewBox->GetWidth(), pViewBox->GetY() + pViewBox->GetHeight());
     109             :                 const basegfx::B2DRange aTargetRange(
     110             :                     0.0, 0.0,
     111           0 :                     pViewBox->GetWidth(), pViewBox->GetHeight());
     112             : 
     113           0 :                 if(!aSourceRange.equal(aTargetRange))
     114             :                 {
     115             :                     aPolyPolygon.transform(
     116             :                         basegfx::tools::createSourceRangeTargetRangeTransform(
     117             :                             aSourceRange,
     118           0 :                             aTargetRange));
     119             :                 }
     120             : 
     121             :                 // always use PolyPolygonBezierCoords here
     122           0 :                 drawing::PolyPolygonBezierCoords aSourcePolyPolygon;
     123             : 
     124             :                 basegfx::tools::B2DPolyPolygonToUnoPolyPolygonBezierCoords(
     125             :                     aPolyPolygon,
     126           0 :                     aSourcePolyPolygon);
     127           0 :                 rValue <<= aSourcePolyPolygon;
     128             :             }
     129             :         }
     130             : 
     131           0 :         if( !aDisplayName.isEmpty() )
     132             :         {
     133             :             rImport.AddStyleDisplayName( XML_STYLE_FAMILY_SD_MARKER_ID, rStrName,
     134           0 :                                         aDisplayName );
     135           0 :             rStrName = aDisplayName;
     136           0 :         }
     137             :     }
     138             : 
     139           0 :     if( pViewBox )
     140           0 :         delete pViewBox;
     141             : 
     142           0 :     return bHasViewBox && bHasPathData;
     143             : }
     144             : 
     145             : // Export
     146             : 
     147           0 : XMLMarkerStyleExport::XMLMarkerStyleExport( SvXMLExport& rExp )
     148           0 :     : rExport( rExp )
     149             : {
     150           0 : }
     151             : 
     152           0 : XMLMarkerStyleExport::~XMLMarkerStyleExport()
     153             : {
     154           0 : }
     155             : 
     156           0 : void XMLMarkerStyleExport::exportXML(
     157             :     const OUString& rStrName,
     158             :     const uno::Any& rValue )
     159             : {
     160           0 :     if(!rStrName.isEmpty())
     161             :     {
     162           0 :         drawing::PolyPolygonBezierCoords aBezier;
     163             : 
     164           0 :         if(rValue >>= aBezier)
     165             :         {
     166             :             // Name
     167           0 :             bool bEncoded(false);
     168           0 :             OUString aStrName( rStrName );
     169             : 
     170           0 :             rExport.AddAttribute(XML_NAMESPACE_DRAW, XML_NAME, rExport.EncodeStyleName( aStrName, &bEncoded ) );
     171             : 
     172           0 :             if( bEncoded )
     173             :             {
     174           0 :                 rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_DISPLAY_NAME, aStrName );
     175             :             }
     176             : 
     177             :             const basegfx::B2DPolyPolygon aPolyPolygon(
     178             :                 basegfx::tools::UnoPolyPolygonBezierCoordsToB2DPolyPolygon(
     179           0 :                     aBezier));
     180           0 :             const basegfx::B2DRange aPolyPolygonRange(aPolyPolygon.getB2DRange());
     181             : 
     182             : 
     183             :             // Viewbox (viewBox="0 0 1500 1000")
     184             : 
     185             :             SdXMLImExViewBox aViewBox(
     186             :                 aPolyPolygonRange.getMinX(),
     187             :                 aPolyPolygonRange.getMinY(),
     188             :                 aPolyPolygonRange.getWidth(),
     189           0 :                 aPolyPolygonRange.getHeight());
     190           0 :             rExport.AddAttribute( XML_NAMESPACE_SVG, XML_VIEWBOX, aViewBox.GetExportString() );
     191             : 
     192             :             // Pathdata
     193             :             const OUString aPolygonString(
     194             :                 basegfx::tools::exportToSvgD(
     195             :                     aPolyPolygon,
     196             :                     true,           // bUseRelativeCoordinates
     197             :                     false,          // bDetectQuadraticBeziers: not used in old, but maybe activated now
     198           0 :                     true));         // bHandleRelativeNextPointCompatible
     199             : 
     200             :             // write point array
     201           0 :             rExport.AddAttribute(XML_NAMESPACE_SVG, XML_D, aPolygonString);
     202             : 
     203             :             // Do Write
     204           0 :             SvXMLElementExport rElem( rExport, XML_NAMESPACE_DRAW, XML_MARKER, true, false );
     205           0 :         }
     206             :     }
     207           0 : }
     208             : 
     209             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10