LCOV - code coverage report
Current view: top level - xmloff/source/style - undlihdl.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 115 0.0 %
Date: 2014-04-14 Functions: 0 12 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 <undlihdl.hxx>
      21             : #include <xmloff/xmltoken.hxx>
      22             : #include <xmloff/xmluconv.hxx>
      23             : #include <rtl/ustrbuf.hxx>
      24             : 
      25             : #include <com/sun/star/uno/Any.hxx>
      26             : #include <com/sun/star/awt/FontUnderline.hpp>
      27             : 
      28             : using namespace ::com::sun::star;
      29             : using namespace ::com::sun::star::awt;
      30             : using namespace ::xmloff::token;
      31             : 
      32             : SvXMLEnumMapEntry const pXML_UnderlineType_Enum[] =
      33             : {
      34             :     { XML_NONE,                         awt::FontUnderline::NONE },
      35             :     { XML_SINGLE,               awt::FontUnderline::SINGLE },
      36             :     { XML_DOUBLE,                       awt::FontUnderline::DOUBLE },
      37             :     { XML_SINGLE,               awt::FontUnderline::DOTTED },
      38             :     { XML_SINGLE,               awt::FontUnderline::DASH },
      39             :     { XML_SINGLE,               awt::FontUnderline::LONGDASH },
      40             :     { XML_SINGLE,               awt::FontUnderline::DASHDOT },
      41             :     { XML_SINGLE,               awt::FontUnderline::DASHDOTDOT },
      42             :     { XML_SINGLE,               awt::FontUnderline::WAVE },
      43             :     { XML_SINGLE,               awt::FontUnderline::BOLD },
      44             :     { XML_SINGLE,               awt::FontUnderline::BOLDDOTTED },
      45             :     { XML_SINGLE,               awt::FontUnderline::BOLDDASH },
      46             :     { XML_SINGLE,               awt::FontUnderline::BOLDLONGDASH },
      47             :     { XML_SINGLE,               awt::FontUnderline::BOLDDASHDOT },
      48             :     { XML_SINGLE,           awt::FontUnderline::BOLDDASHDOTDOT },
      49             :     { XML_SINGLE,               awt::FontUnderline::BOLDWAVE },
      50             :     { XML_DOUBLE,                       awt::FontUnderline::DOUBLEWAVE },
      51             :     { XML_SINGLE,               awt::FontUnderline::SMALLWAVE },
      52             :     { XML_TOKEN_INVALID,                0 }
      53             : };
      54             : 
      55             : SvXMLEnumMapEntry const pXML_UnderlineStyle_Enum[] =
      56             : {
      57             :     { XML_NONE,                         awt::FontUnderline::NONE },
      58             :     { XML_SOLID,                        awt::FontUnderline::SINGLE },
      59             :     { XML_SOLID,                        awt::FontUnderline::DOUBLE },
      60             :     { XML_DOTTED,               awt::FontUnderline::DOTTED },
      61             :     { XML_DASH,             awt::FontUnderline::DASH },
      62             :     { XML_LONG_DASH,            awt::FontUnderline::LONGDASH },
      63             :     { XML_DOT_DASH,         awt::FontUnderline::DASHDOT },
      64             :     { XML_DOT_DOT_DASH,     awt::FontUnderline::DASHDOTDOT },
      65             :     { XML_WAVE,             awt::FontUnderline::WAVE },
      66             :     { XML_SOLID,                        awt::FontUnderline::BOLD },
      67             :     { XML_DOTTED,               awt::FontUnderline::BOLDDOTTED },
      68             :     { XML_DASH,             awt::FontUnderline::BOLDDASH },
      69             :     { XML_LONG_DASH,            awt::FontUnderline::BOLDLONGDASH },
      70             :     { XML_DOT_DASH,         awt::FontUnderline::BOLDDASHDOT },
      71             :     { XML_DOT_DOT_DASH,         awt::FontUnderline::BOLDDASHDOTDOT },
      72             :     { XML_WAVE,             awt::FontUnderline::BOLDWAVE },
      73             :     { XML_WAVE,                 awt::FontUnderline::DOUBLEWAVE },
      74             :     { XML_SMALL_WAVE,           awt::FontUnderline::SMALLWAVE },
      75             :     { XML_TOKEN_INVALID,                0 }
      76             : };
      77             : 
      78             : SvXMLEnumMapEntry const pXML_UnderlineWidth_Enum[] =
      79             : {
      80             :     { XML_AUTO,                         awt::FontUnderline::NONE },
      81             :     { XML_AUTO,                         awt::FontUnderline::SINGLE },
      82             :     { XML_AUTO,                         awt::FontUnderline::DOUBLE },
      83             :     { XML_AUTO,                         awt::FontUnderline::DOTTED },
      84             :     { XML_AUTO,                         awt::FontUnderline::DASH },
      85             :     { XML_AUTO,                         awt::FontUnderline::LONGDASH },
      86             :     { XML_AUTO,                         awt::FontUnderline::DASHDOT },
      87             :     { XML_AUTO,                         awt::FontUnderline::DASHDOTDOT },
      88             :     { XML_AUTO,                         awt::FontUnderline::WAVE },
      89             :     { XML_BOLD,             awt::FontUnderline::BOLD },
      90             :     { XML_BOLD,             awt::FontUnderline::BOLDDOTTED },
      91             :     { XML_BOLD,             awt::FontUnderline::BOLDDASH },
      92             :     { XML_BOLD,             awt::FontUnderline::BOLDLONGDASH },
      93             :     { XML_BOLD,             awt::FontUnderline::BOLDDASHDOT },
      94             :     { XML_BOLD,                 awt::FontUnderline::BOLDDASHDOTDOT },
      95             :     { XML_BOLD,             awt::FontUnderline::BOLDWAVE },
      96             :     { XML_AUTO,                         awt::FontUnderline::DOUBLEWAVE },
      97             :     { XML_THIN,                         awt::FontUnderline::NONE },
      98             :     { XML_MEDIUM,                       awt::FontUnderline::NONE },
      99             :     { XML_THICK,                        awt::FontUnderline::BOLD},
     100             :     { XML_TOKEN_INVALID,                0 }
     101             : };
     102             : 
     103             : 
     104             : // class XMLUnderlineTypePropHdl
     105             : 
     106             : 
     107           0 : XMLUnderlineTypePropHdl::~XMLUnderlineTypePropHdl()
     108             : {
     109             :     // nothing to do
     110           0 : }
     111             : 
     112           0 : bool XMLUnderlineTypePropHdl::importXML( const OUString& rStrImpValue, uno::Any& rValue, const SvXMLUnitConverter& ) const
     113             : {
     114             :     sal_uInt16 eNewUnderline;
     115             :     bool bRet = SvXMLUnitConverter::convertEnum(
     116           0 :         eNewUnderline, rStrImpValue, pXML_UnderlineType_Enum );
     117           0 :     if( bRet )
     118             :     {
     119             :         // multi property: style and width might be set already.
     120             :         // If the old value is NONE, the new is used unchanged.
     121           0 :         sal_Int16 eUnderline = sal_Int16();
     122           0 :         if( (rValue >>= eUnderline) && awt::FontUnderline::NONE!=eUnderline )
     123             :         {
     124           0 :             switch( eNewUnderline )
     125             :             {
     126             :             case awt::FontUnderline::NONE:
     127             :             case awt::FontUnderline::SINGLE:
     128             :                 // keep existing line style
     129           0 :                 eNewUnderline = eUnderline;
     130           0 :                 break;
     131             :             case awt::FontUnderline::DOUBLE:
     132             :                 // A double line style has priority over a bold line style,
     133             :                 // but not over the line style itself.
     134           0 :                 switch( eUnderline )
     135             :                 {
     136             :                 case awt::FontUnderline::SINGLE:
     137             :                 case awt::FontUnderline::BOLD:
     138           0 :                     break;
     139             :                 case awt::FontUnderline::WAVE:
     140             :                 case awt::FontUnderline::BOLDWAVE:
     141           0 :                     eNewUnderline = awt::FontUnderline::DOUBLEWAVE;
     142           0 :                     break;
     143             :                 default:
     144             :                     // If a double line style is not supported for the existing
     145             :                     // value, keep the new one
     146           0 :                     eNewUnderline = eUnderline;
     147           0 :                     break;
     148             :                 }
     149           0 :                 break;
     150             :             default:
     151             :                 OSL_ENSURE( bRet, "unexpected line type value" );
     152           0 :                 break;
     153             :             }
     154           0 :             if( eNewUnderline != eUnderline )
     155           0 :                 rValue <<= (sal_Int16)eNewUnderline;
     156             :         }
     157             :         else
     158             :         {
     159           0 :             rValue <<= (sal_Int16)eNewUnderline;
     160             :         }
     161             :     }
     162             : 
     163           0 :     return bRet;
     164             : }
     165             : 
     166           0 : bool XMLUnderlineTypePropHdl::exportXML( OUString& rStrExpValue, const uno::Any& rValue, const SvXMLUnitConverter& ) const
     167             : {
     168           0 :     bool bRet = false;
     169           0 :     sal_Int16 nValue = sal_Int16();
     170           0 :     OUStringBuffer aOut;
     171             : 
     172           0 :     if( (rValue >>= nValue) &&
     173           0 :         (awt::FontUnderline::DOUBLE == nValue ||
     174           0 :          awt::FontUnderline::DOUBLEWAVE == nValue) )
     175             :     {
     176             :         bRet = SvXMLUnitConverter::convertEnum(
     177           0 :             aOut, (sal_uInt16)nValue, pXML_UnderlineType_Enum );
     178           0 :         if( bRet )
     179           0 :             rStrExpValue = aOut.makeStringAndClear();
     180             :     }
     181             : 
     182           0 :     return bRet;
     183             : }
     184             : 
     185             : 
     186             : // class XMLUnderlineStylePropHdl
     187             : 
     188             : 
     189           0 : XMLUnderlineStylePropHdl::~XMLUnderlineStylePropHdl()
     190             : {
     191             :     // nothing to do
     192           0 : }
     193             : 
     194           0 : bool XMLUnderlineStylePropHdl::importXML( const OUString& rStrImpValue, uno::Any& rValue, const SvXMLUnitConverter& ) const
     195             : {
     196             :     sal_uInt16 eNewUnderline;
     197             :     bool bRet = SvXMLUnitConverter::convertEnum(
     198           0 :         eNewUnderline, rStrImpValue, pXML_UnderlineStyle_Enum );
     199           0 :     if( bRet )
     200             :     {
     201             :         // multi property: style and width might be set already.
     202             :         // If the old value is NONE, the new is used unchanged.
     203           0 :         sal_Int16 eUnderline = sal_Int16();
     204           0 :         if( (rValue >>= eUnderline) && awt::FontUnderline::NONE!=eUnderline )
     205             :         {
     206           0 :             switch( eNewUnderline )
     207             :             {
     208             :             case awt::FontUnderline::NONE:
     209             :             case awt::FontUnderline::SINGLE:
     210             :                 // keep double or bold line style
     211           0 :                 eNewUnderline = eUnderline;
     212             :                 //fall-through
     213             :             case awt::FontUnderline::DOTTED:
     214             :                 // The line style has priority over a double type.
     215           0 :                 if( awt::FontUnderline::BOLD == eUnderline )
     216           0 :                     eNewUnderline = awt::FontUnderline::BOLDDOTTED;
     217           0 :                 break;
     218             :             case awt::FontUnderline::DASH:
     219           0 :                 if( awt::FontUnderline::BOLD == eUnderline )
     220           0 :                     eNewUnderline = awt::FontUnderline::BOLDDASH;
     221           0 :                 break;
     222             :             case awt::FontUnderline::LONGDASH:
     223           0 :                 if( awt::FontUnderline::BOLD == eUnderline )
     224           0 :                     eNewUnderline = awt::FontUnderline::BOLDLONGDASH;
     225           0 :                 break;
     226             :             case awt::FontUnderline::DASHDOT:
     227           0 :                 if( awt::FontUnderline::BOLD == eUnderline )
     228           0 :                     eNewUnderline = awt::FontUnderline::BOLDDASHDOT;
     229           0 :                 break;
     230             :             case awt::FontUnderline::DASHDOTDOT:
     231           0 :                 if( awt::FontUnderline::BOLD == eUnderline )
     232           0 :                     eNewUnderline = awt::FontUnderline::BOLDDASHDOTDOT;
     233           0 :                 break;
     234             :             case awt::FontUnderline::WAVE:
     235           0 :                 if( awt::FontUnderline::BOLD == eUnderline )
     236           0 :                     eNewUnderline = awt::FontUnderline::BOLDWAVE;
     237           0 :                 break;
     238             :             case awt::FontUnderline::SMALLWAVE:
     239             :                 // SMALLWAVE is not used
     240             :             default:
     241             :                 OSL_ENSURE( bRet, "unexpected line style value" );
     242           0 :                 break;
     243             :             }
     244           0 :             if( eNewUnderline != eUnderline )
     245           0 :                 rValue <<= (sal_Int16)eNewUnderline;
     246             :         }
     247             :         else
     248             :         {
     249           0 :             rValue <<= (sal_Int16)eNewUnderline;
     250             :         }
     251             :     }
     252             : 
     253           0 :     return bRet;
     254             : }
     255             : 
     256           0 : bool XMLUnderlineStylePropHdl::exportXML( OUString& rStrExpValue, const uno::Any& rValue, const SvXMLUnitConverter& ) const
     257             : {
     258           0 :     bool bRet = false;
     259           0 :     sal_Int16 nValue = sal_Int16();
     260           0 :     OUStringBuffer aOut;
     261             : 
     262           0 :     if( rValue >>= nValue )
     263             :     {
     264             :         bRet = SvXMLUnitConverter::convertEnum(
     265           0 :             aOut, (sal_uInt16)nValue, pXML_UnderlineStyle_Enum );
     266           0 :         if( bRet )
     267           0 :             rStrExpValue = aOut.makeStringAndClear();
     268             :     }
     269             : 
     270           0 :     return bRet;
     271             : }
     272             : 
     273             : 
     274             : // class XMLUnderlineWidthPropHdl
     275             : 
     276             : 
     277           0 : XMLUnderlineWidthPropHdl::~XMLUnderlineWidthPropHdl()
     278             : {
     279             :     // nothing to do
     280           0 : }
     281             : 
     282           0 : bool XMLUnderlineWidthPropHdl::importXML( const OUString& rStrImpValue, uno::Any& rValue, const SvXMLUnitConverter& ) const
     283             : {
     284             :     sal_uInt16 eNewUnderline;
     285             :     bool bRet = SvXMLUnitConverter::convertEnum(
     286           0 :         eNewUnderline, rStrImpValue, pXML_UnderlineWidth_Enum );
     287           0 :     if( bRet )
     288             :     {
     289             :         // multi property: style and width might be set already.
     290             :         // If the old value is NONE, the new is used unchanged.
     291           0 :         sal_Int16 eUnderline = sal_Int16();
     292           0 :         if( (rValue >>= eUnderline) && awt::FontUnderline::NONE!=eUnderline )
     293             :         {
     294           0 :             switch( eNewUnderline )
     295             :             {
     296             :             case awt::FontUnderline::NONE:
     297             :                 // keep existing line style
     298           0 :                 eNewUnderline = eUnderline;
     299           0 :                 break;
     300             :             case awt::FontUnderline::BOLD:
     301             :                 // A double line style has priority over a bold line style,
     302             :                 // but not over the line style itself.
     303           0 :                 switch( eUnderline )
     304             :                 {
     305             :                 case awt::FontUnderline::SINGLE:
     306           0 :                     break;
     307             :                 case awt::FontUnderline::DOTTED:
     308           0 :                     eNewUnderline = awt::FontUnderline::BOLDDOTTED;
     309           0 :                     break;
     310             :                 case awt::FontUnderline::DASH:
     311           0 :                     eNewUnderline = awt::FontUnderline::BOLDDASH;
     312           0 :                     break;
     313             :                 case awt::FontUnderline::LONGDASH:
     314           0 :                     eNewUnderline = awt::FontUnderline::BOLDLONGDASH;
     315           0 :                     break;
     316             :                 case awt::FontUnderline::DASHDOT:
     317           0 :                     eNewUnderline = awt::FontUnderline::BOLDDASHDOT;
     318           0 :                     break;
     319             :                 case awt::FontUnderline::DASHDOTDOT:
     320           0 :                     eNewUnderline = awt::FontUnderline::BOLDDASHDOTDOT;
     321           0 :                     break;
     322             :                 case awt::FontUnderline::WAVE:
     323           0 :                     eNewUnderline = awt::FontUnderline::BOLDWAVE;
     324           0 :                     break;
     325             :                 default:
     326             :                     // a doube line style overwrites a bold one
     327           0 :                     eNewUnderline = eUnderline;
     328           0 :                     break;
     329             :                 }
     330           0 :                 break;
     331             :             default:
     332             :                 OSL_ENSURE( bRet, "unexpected line width value" );
     333           0 :                 break;
     334             :             }
     335           0 :             if( eNewUnderline != eUnderline )
     336           0 :                 rValue <<= (sal_Int16)eNewUnderline;
     337             :         }
     338             :         else
     339             :         {
     340           0 :             rValue <<= (sal_Int16)eNewUnderline;
     341             :         }
     342             :     }
     343             : 
     344           0 :     return bRet;
     345             : }
     346             : 
     347           0 : bool XMLUnderlineWidthPropHdl::exportXML( OUString& rStrExpValue, const uno::Any& rValue, const SvXMLUnitConverter& ) const
     348             : {
     349           0 :     bool bRet = false;
     350           0 :     sal_Int16 nValue = sal_Int16();
     351           0 :     OUStringBuffer aOut;
     352             : 
     353           0 :     if( (rValue >>= nValue) && (awt::FontUnderline::NONE != nValue) )
     354             :     {
     355             :         bRet = SvXMLUnitConverter::convertEnum(
     356           0 :             aOut, (sal_uInt16)nValue, pXML_UnderlineWidth_Enum );
     357           0 :         if( bRet )
     358           0 :             rStrExpValue = aOut.makeStringAndClear();
     359             :     }
     360             : 
     361           0 :     return bRet;
     362             : }
     363             : 
     364             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10