xmloff/source/style/DashStyle.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 <com/sun/star/drawing/DashStyle.hpp>
  21 #include <com/sun/star/drawing/LineDash.hpp>
  22
  23 #include <sax/tools/converter.hxx>
  24
  25 #include <xmloff/DashStyle.hxx>
  26 #include <xmloff/xmluconv.hxx>
  27 #include <xmloff/xmlnamespace.hxx>
  28 #include <xmloff/xmltoken.hxx>
  29 #include <xmloff/xmlexp.hxx>
  30 #include <xmloff/xmlimp.hxx>
  31 #include <xmloff/xmlement.hxx>
  32 #include <rtl/ustrbuf.hxx>
  33 #include <rtl/ustring.hxx>
  34 #include <sal/log.hxx>
  35
  36 using namespace ::com::sun::star;
  37 using namespace ::xmloff::token;
  38
  39 SvXMLEnumMapEntry<drawing::DashStyle> const pXML_DashStyle_Enum[] =
  40 {
  41     { XML_RECT,         drawing::DashStyle_RECT },
  42     { XML_ROUND,        drawing::DashStyle_ROUND },
  43     { XML_RECT,         drawing::DashStyle_RECTRELATIVE },
  44     { XML_ROUND,        drawing::DashStyle_ROUNDRELATIVE },
  45     { XML_TOKEN_INVALID, drawing::DashStyle(0) }
  46 };
  47
  48 // Import
  49
  50 XMLDashStyleImport::XMLDashStyleImport( SvXMLImport& rImp )
  51     : m_rImport(rImp)
  52 {
  53 }
  54
  55 void XMLDashStyleImport::importXML(
  56     const uno::Reference< xml::sax::XFastAttributeList >& xAttrList,
  57     uno::Any& rValue,
  58     OUString& rStrName )
  59 {
  60     drawing::LineDash aLineDash;
  61     aLineDash.Style = drawing::DashStyle_RECT;
  62     aLineDash.Dots = 0;
  63     aLineDash.DotLen = 0;
  64     aLineDash.Dashes = 0;
  65     aLineDash.DashLen = 0;
  66     aLineDash.Distance = 20;
  67     OUString aDisplayName;
  68
  69     bool bIsRel = false;
  70
  71     SvXMLUnitConverter& rUnitConverter = m_rImport.GetMM100UnitConverter();
  72
  73     for (auto &aIter : sax_fastparser::castToFastAttributeList( xAttrList ))
  74     {
  75         switch( aIter.getToken() )
  76         {
  77         case XML_ELEMENT(DRAW, XML_NAME):
  78         case XML_ELEMENT(DRAW_OOO, XML_NAME):
  79             {
  80                 rStrName = aIter.toString();
  81             }
  82             break;
  83         case XML_ELEMENT(DRAW, XML_DISPLAY_NAME):
  84         case XML_ELEMENT(DRAW_OOO, XML_DISPLAY_NAME):
  85             {
  86                 aDisplayName = aIter.toString();
  87             }
  88             break;
  89         case XML_ELEMENT(DRAW, XML_STYLE):
  90         case XML_ELEMENT(DRAW_OOO, XML_STYLE):
  91             {
  92                 SvXMLUnitConverter::convertEnum( aLineDash.Style, aIter.toView(), pXML_DashStyle_Enum );
  93             }
  94             break;
  95         case XML_ELEMENT(DRAW, XML_DOTS1):
  96         case XML_ELEMENT(DRAW_OOO, XML_DOTS1):
  97             aLineDash.Dots = static_cast<sal_Int16>(aIter.toInt32());
  98             break;
  99
 100         case XML_ELEMENT(DRAW, XML_DOTS1_LENGTH):
 101         case XML_ELEMENT(DRAW_OOO, XML_DOTS1_LENGTH):
 102             {
 103                 if( aIter.toView().find( '%' ) != std::string_view::npos ) // it's a percentage
 104                 {
 105                     bIsRel = true;
 106                     ::sax::Converter::convertPercent(aLineDash.DotLen, aIter.toView());
 107                 }
 108                 else
 109                 {
 110                     rUnitConverter.convertMeasureToCore( aLineDash.DotLen,
 111                             aIter.toView() );
 112                 }
 113             }
 114             break;
 115
 116         case XML_ELEMENT(DRAW, XML_DOTS2):
 117         case XML_ELEMENT(DRAW_OOO, XML_DOTS2):
 118             aLineDash.Dashes = static_cast<sal_Int16>(aIter.toInt32());
 119             break;
 120
 121         case XML_ELEMENT(DRAW, XML_DOTS2_LENGTH):
 122         case XML_ELEMENT(DRAW_OOO, XML_DOTS2_LENGTH):
 123             {
 124                 if( aIter.toView().find( '%' ) != std::string_view::npos ) // it's a percentage
 125                 {
 126                     bIsRel = true;
 127                     ::sax::Converter::convertPercent(aLineDash.DashLen, aIter.toView());
 128                 }
 129                 else
 130                 {
 131                     rUnitConverter.convertMeasureToCore( aLineDash.DashLen,
 132                             aIter.toView() );
 133                 }
 134             }
 135             break;
 136
 137         case XML_ELEMENT(DRAW, XML_DISTANCE):
 138         case XML_ELEMENT(DRAW_OOO, XML_DISTANCE):
 139             {
 140                 if( aIter.toView().find( '%' ) != std::string_view::npos ) // it's a percentage
 141                 {
 142                     bIsRel = true;
 143                     ::sax::Converter::convertPercent(aLineDash.Distance, aIter.toView());
 144                 }
 145                 else
 146                 {
 147                     rUnitConverter.convertMeasureToCore( aLineDash.Distance,
 148                             aIter.toView() );
 149                 }
 150             }
 151             break;
 152         default:
 153             XMLOFF_WARN_UNKNOWN("xmloff.style", aIter);
 154         }
 155     }
 156
 157     if( bIsRel )
 158         aLineDash.Style = aLineDash.Style == drawing::DashStyle_RECT ? drawing::DashStyle_RECTRELATIVE : drawing::DashStyle_ROUNDRELATIVE;
 159
 160     rValue <<= aLineDash;
 161
 162     if( !aDisplayName.isEmpty() )
 163     {
 164         m_rImport.AddStyleDisplayName( XmlStyleFamily::SD_STROKE_DASH_ID,
 165                                      rStrName, aDisplayName );
 166         rStrName = aDisplayName;
 167     }
 168 }
 169
 170 // Export
 171
 172 XMLDashStyleExport::XMLDashStyleExport( SvXMLExport& rExp )
 173     : m_rExport(rExp)
 174 {
 175 }
 176
 177 void XMLDashStyleExport::exportXML(
 178     const OUString& rStrName,
 179     const uno::Any& rValue )
 180 {
 181     SvXMLUnitConverter & rUnitConverter = m_rExport.GetMM100UnitConverter();
 182
 183     drawing::LineDash aLineDash;
 184
 185     if( rStrName.isEmpty() )
 186         return;
 187
 188     if( !(rValue >>= aLineDash) )
 189         return;
 190
 191     bool bIsRel = aLineDash.Style == drawing::DashStyle_RECTRELATIVE || aLineDash.Style == drawing::DashStyle_ROUNDRELATIVE;
 192
 193     OUString aStrValue;
 194     OUStringBuffer aOut;
 195
 196     // Name
 197     bool bEncoded = false;
 198     m_rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_NAME,
 199                           m_rExport.EncodeStyleName( rStrName,
 200                                                    &bEncoded ) );
 201     if( bEncoded )
 202         m_rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_DISPLAY_NAME,
 203                               rStrName );
 204
 205     // Style
 206     SvXMLUnitConverter::convertEnum( aOut, aLineDash.Style, pXML_DashStyle_Enum );
 207     aStrValue = aOut.makeStringAndClear();
 208     m_rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_STYLE, aStrValue );
 209
 210     // dots
 211     if( aLineDash.Dots )
 212     {
 213         m_rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_DOTS1, OUString::number( aLineDash.Dots ) );
 214
 215         if( aLineDash.DotLen )
 216         {
 217             // dashes length
 218             if( bIsRel )
 219             {
 220                 ::sax::Converter::convertPercent(aOut, aLineDash.DotLen);
 221             }
 222             else
 223             {
 224                 rUnitConverter.convertMeasureToXML( aOut,
 225                         aLineDash.DotLen );
 226             }
 227             aStrValue = aOut.makeStringAndClear();
 228             m_rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_DOTS1_LENGTH, aStrValue );
 229         }
 230     }
 231
 232     // dashes
 233     if( aLineDash.Dashes )
 234     {
 235         m_rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_DOTS2, OUString::number( aLineDash.Dashes ) );
 236
 237         if( aLineDash.DashLen )
 238         {
 239             // dashes length
 240             if( bIsRel )
 241             {
 242                 ::sax::Converter::convertPercent(aOut, aLineDash.DashLen);
 243             }
 244             else
 245             {
 246                 rUnitConverter.convertMeasureToXML( aOut,
 247                         aLineDash.DashLen );
 248             }
 249             aStrValue = aOut.makeStringAndClear();
 250             m_rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_DOTS2_LENGTH, aStrValue );
 251         }
 252     }
 253
 254     // distance
 255     if( bIsRel )
 256     {
 257         ::sax::Converter::convertPercent( aOut, aLineDash.Distance );
 258     }
 259     else
 260     {
 261         rUnitConverter.convertMeasureToXML( aOut,
 262                 aLineDash.Distance );
 263     }
 264     aStrValue = aOut.makeStringAndClear();
 265     m_rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_DISTANCE, aStrValue );
 266
 267     // do Write
 268     SvXMLElementExport rElem( m_rExport,
 269                               XML_NAMESPACE_DRAW, XML_STROKE_DASH,
 270                               true, false );
 271 }
 272
 273 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */