xmloff/source/style/cdouthdl.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: cdouthdl.cxx,v $
  10  * $Revision: 1.12 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_xmloff.hxx"
  33 #include <cdouthdl.hxx>
  34 #include <xmloff/xmltoken.hxx>
  35 #include <xmloff/xmluconv.hxx>
  36 #include <rtl/ustrbuf.hxx>
  37
  38 #ifndef _COM_SUN_STAR_AWT_FONTSTRIKEOUT_HPP
  39 #include <com/sun/star/awt/FontStrikeout.hpp>
  40 #endif
  41 #include <com/sun/star/uno/Any.hxx>
  42
  43 #ifndef _XMLOFF_XMLEMENT_HXX
  44 #include <xmloff/xmlelement.hxx>
  45 #endif
  46
  47 using ::rtl::OUString;
  48 using ::rtl::OUStringBuffer;
  49
  50 using namespace ::com::sun::star;
  51 using namespace ::com::sun::star::awt;
  52 using namespace ::xmloff::token;
  53
  54 SvXMLEnumMapEntry pXML_CrossedoutType_Enum[] =
  55 {
  56     { XML_NONE,                                 FontStrikeout::NONE },
  57     { XML_SINGLE,       FontStrikeout::SINGLE },
  58     { XML_DOUBLE,                               FontStrikeout::DOUBLE },
  59     { XML_SINGLE,    FontStrikeout::BOLD },
  60     { XML_SINGLE,    FontStrikeout::SLASH },
  61     { XML_SINGLE,    FontStrikeout::X },
  62     { XML_TOKEN_INVALID,                                0 }
  63 };
  64
  65 SvXMLEnumMapEntry pXML_CrossedoutStyle_Enum[] =
  66 {
  67     { XML_NONE,                                                 FontStrikeout::NONE },
  68     { XML_SOLID,                                                FontStrikeout::SINGLE },
  69     { XML_SOLID,                                                FontStrikeout::DOUBLE },
  70     { XML_SOLID,                                        FontStrikeout::BOLD },
  71     { XML_SOLID,                                        FontStrikeout::SLASH },
  72     { XML_SOLID,                                        FontStrikeout::X },
  73     { XML_DOTTED,                       FontStrikeout::SINGLE },
  74     { XML_DASH,                         FontStrikeout::SINGLE },
  75     { XML_LONG_DASH,                    FontStrikeout::SINGLE },
  76     { XML_DOT_DASH,                     FontStrikeout::SINGLE },
  77     { XML_DOT_DOT_DASH,         FontStrikeout::SINGLE },
  78     { XML_WAVE,                         FontStrikeout::SINGLE },
  79     { XML_TOKEN_INVALID,                                0 }
  80 };
  81
  82 SvXMLEnumMapEntry pXML_CrossedoutWidth_Enum[] =
  83 {
  84     { XML_AUTO,                                 FontStrikeout::NONE },
  85     { XML_AUTO,                                 FontStrikeout::SINGLE },
  86     { XML_AUTO,                                 FontStrikeout::DOUBLE },
  87     { XML_BOLD,     FontStrikeout::BOLD },
  88     { XML_AUTO,                         FontStrikeout::SLASH },
  89     { XML_AUTO,                         FontStrikeout::X },
  90     { XML_THIN,                         FontStrikeout::NONE },
  91     { XML_MEDIUM,                       FontStrikeout::NONE },
  92     { XML_THICK,                        FontStrikeout::NONE },
  93     { XML_TOKEN_INVALID,                                0 }
  94 };
  95
  96 ///////////////////////////////////////////////////////////////////////////////
  97 //
  98 // class XMLCrossedOutTypePropHdl
  99 //
 100
 101 XMLCrossedOutTypePropHdl::~XMLCrossedOutTypePropHdl()
 102 {
 103     // nothing to do
 104 }
 105
 106 sal_Bool XMLCrossedOutTypePropHdl::importXML( const OUString& rStrImpValue, uno::Any& rValue, const SvXMLUnitConverter& ) const
 107 {
 108     sal_uInt16 eNewStrikeout;
 109     sal_Bool bRet = SvXMLUnitConverter::convertEnum(
 110         eNewStrikeout, rStrImpValue, pXML_CrossedoutType_Enum );
 111     if( bRet )
 112     {
 113         // multi property: style and width might be set already.
 114         // If the old value is NONE, the new is used unchanged.
 115         sal_Int16 eStrikeout = sal_Int16();
 116         if( (rValue >>= eStrikeout) && FontStrikeout::NONE!=eStrikeout )
 117         {
 118             switch( eNewStrikeout )
 119             {
 120             case FontStrikeout::NONE:
 121             case FontStrikeout::SINGLE:
 122                 // keep existing line style
 123                 eNewStrikeout = eStrikeout;
 124                 break;
 125             case FontStrikeout::DOUBLE:
 126                 // A double line style has priority over a solid or a bold
 127                 // line style,
 128                 // but not about any other line style
 129                 switch( eStrikeout )
 130                 {
 131                 case FontStrikeout::SINGLE:
 132                 case FontStrikeout::BOLD:
 133                     break;
 134                 default:
 135                     // If a double line style is not supported for the existing
 136                     // value, keep the new one
 137                     eNewStrikeout = eStrikeout;
 138                     break;
 139                 }
 140                 break;
 141             default:
 142                 OSL_ENSURE( bRet, "unexpected line type value" );
 143                 break;
 144             }
 145             if( eNewStrikeout != eStrikeout )
 146                 rValue <<= (sal_Int16)eNewStrikeout;
 147         }
 148         else
 149         {
 150             rValue <<= (sal_Int16)eNewStrikeout;
 151         }
 152     }
 153
 154     return bRet;
 155 }
 156
 157 sal_Bool XMLCrossedOutTypePropHdl::exportXML( OUString& rStrExpValue, const uno::Any& rValue, const SvXMLUnitConverter& ) const
 158 {
 159     sal_Bool bRet = sal_False;
 160     sal_Int16 nValue = sal_Int16();
 161     OUStringBuffer aOut;
 162
 163     if( (rValue >>= nValue) && FontStrikeout::DOUBLE==nValue )
 164     {
 165         bRet = SvXMLUnitConverter::convertEnum(
 166             aOut, (sal_uInt16)nValue, pXML_CrossedoutType_Enum );
 167         if( bRet )
 168             rStrExpValue = aOut.makeStringAndClear();
 169     }
 170
 171     return bRet;
 172 }
 173
 174 ///////////////////////////////////////////////////////////////////////////////
 175 //
 176 // class XMLCrossedOutStylePropHdl
 177 //
 178
 179 XMLCrossedOutStylePropHdl::~XMLCrossedOutStylePropHdl()
 180 {
 181     // nothing to do
 182 }
 183
 184 sal_Bool XMLCrossedOutStylePropHdl::importXML( const OUString& rStrImpValue, uno::Any& rValue, const SvXMLUnitConverter& ) const
 185 {
 186     sal_uInt16 eNewStrikeout;
 187     sal_Bool bRet = SvXMLUnitConverter::convertEnum(
 188         eNewStrikeout, rStrImpValue, pXML_CrossedoutStyle_Enum );
 189     if( bRet )
 190     {
 191         // multi property: style and width might be set already.
 192         // If the old value is NONE, the new is used unchanged.
 193         sal_Int16 eStrikeout = sal_Int16();
 194         if( (rValue >>= eStrikeout) && FontStrikeout::NONE!=eStrikeout )
 195         {
 196             // one NONE a SINGLE are possible new values. For both, the
 197             // existing value is kept.
 198         }
 199         else
 200         {
 201             rValue <<= (sal_Int16)eNewStrikeout;
 202         }
 203     }
 204
 205     return bRet;
 206 }
 207
 208 sal_Bool XMLCrossedOutStylePropHdl::exportXML( OUString& rStrExpValue, const uno::Any& rValue, const SvXMLUnitConverter& ) const
 209 {
 210     sal_Bool bRet = sal_False;
 211     sal_Int16 nValue = sal_Int16();
 212     OUStringBuffer aOut;
 213
 214     if( rValue >>= nValue )
 215     {
 216         bRet = SvXMLUnitConverter::convertEnum(
 217             aOut, (sal_uInt16)nValue, pXML_CrossedoutStyle_Enum );
 218         if( bRet )
 219             rStrExpValue = aOut.makeStringAndClear();
 220     }
 221
 222     return bRet;
 223 }
 224
 225 ///////////////////////////////////////////////////////////////////////////////
 226 //
 227 // class XMLCrossedOutWidthPropHdl
 228 //
 229
 230 XMLCrossedOutWidthPropHdl::~XMLCrossedOutWidthPropHdl()
 231 {
 232     // nothing to do
 233 }
 234
 235 sal_Bool XMLCrossedOutWidthPropHdl::importXML( const OUString& rStrImpValue, uno::Any& rValue, const SvXMLUnitConverter& ) const
 236 {
 237     sal_uInt16 eNewStrikeout;
 238     sal_Bool bRet = SvXMLUnitConverter::convertEnum(
 239         eNewStrikeout, rStrImpValue, pXML_CrossedoutWidth_Enum );
 240     if( bRet )
 241     {
 242         // multi property: style and width might be set already.
 243         // If the old value is NONE, the new is used unchanged.
 244         sal_Int16 eStrikeout = sal_Int16();
 245         if( (rValue >>= eStrikeout) && FontStrikeout::NONE!=eStrikeout )
 246         {
 247             switch( eNewStrikeout )
 248             {
 249             case FontStrikeout::NONE:
 250                 // keep existing line style
 251                 eNewStrikeout = eStrikeout;
 252                 break;
 253             case FontStrikeout::BOLD:
 254                 switch( eStrikeout )
 255                 {
 256                 case FontStrikeout::SINGLE:
 257                     break;
 258                 default:
 259                     // If a double line style is not supported for the existing
 260                     // value, keep the new one
 261                     eNewStrikeout = eStrikeout;
 262                     break;
 263                 }
 264             default:
 265                 OSL_ENSURE( bRet, "unexpected line type value" );
 266                 break;
 267             }
 268             if( eNewStrikeout != eStrikeout )
 269                 rValue <<= (sal_Int16)eNewStrikeout;
 270         }
 271         else
 272         {
 273             rValue <<= (sal_Int16)eNewStrikeout;
 274         }
 275     }
 276
 277     return bRet;
 278 }
 279
 280 sal_Bool XMLCrossedOutWidthPropHdl::exportXML( OUString& rStrExpValue, const uno::Any& rValue, const SvXMLUnitConverter& ) const
 281 {
 282     sal_Bool bRet = sal_False;
 283     sal_Int16 nValue = sal_Int16();
 284     OUStringBuffer aOut;
 285
 286     if( (rValue >>= nValue) && (FontStrikeout::BOLD == nValue) )
 287     {
 288         bRet = SvXMLUnitConverter::convertEnum(
 289             aOut, (sal_uInt16)nValue, pXML_CrossedoutWidth_Enum );
 290         if( bRet )
 291             rStrExpValue = aOut.makeStringAndClear();
 292     }
 293
 294     return bRet;
 295 }
 296
 297 ///////////////////////////////////////////////////////////////////////////////
 298 //
 299 // class XMLCrossedOutTextPropHdl
 300 //
 301
 302 XMLCrossedOutTextPropHdl::~XMLCrossedOutTextPropHdl()
 303 {
 304     // nothing to do
 305 }
 306
 307 sal_Bool XMLCrossedOutTextPropHdl::importXML( const OUString& rStrImpValue, uno::Any& rValue, const SvXMLUnitConverter& ) const
 308 {
 309     sal_Bool bRet = sal_False;
 310
 311     if( rStrImpValue.getLength() )
 312     {
 313         sal_Int16 eStrikeout = ('/' == rStrImpValue[0]
 314                                         ? FontStrikeout::SLASH
 315                                         : FontStrikeout::X);
 316         rValue <<= (sal_Int16)eStrikeout;
 317         bRet = sal_True;
 318     }
 319
 320     return bRet;
 321 }
 322
 323 sal_Bool XMLCrossedOutTextPropHdl::exportXML( OUString& rStrExpValue, const uno::Any& rValue, const SvXMLUnitConverter& ) const
 324 {
 325     sal_Bool bRet = sal_False;
 326     sal_Int16 nValue = sal_Int16();
 327
 328     if( (rValue >>= nValue) &&
 329         (FontStrikeout::SLASH == nValue || FontStrikeout::X == nValue) )
 330     {
 331         rStrExpValue = OUString::valueOf(
 332             static_cast< sal_Unicode>( FontStrikeout::SLASH == nValue ? '/'
 333                                                                       : 'X' ) );
 334         bRet = sal_True;
 335     }
 336
 337     return bRet;
 338 }
 339