xmloff/source/style/fonthdl.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: fonthdl.cxx,v $
  10  * $Revision: 1.15 $
  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
  34 #ifndef _XMLOFF_PROPERTYHANDLER_FONTTYPES_HXX
  35 #include <fonthdl.hxx>
  36 #endif
  37 #include <xmloff/xmltoken.hxx>
  38 #include <xmloff/xmluconv.hxx>
  39 #include <rtl/ustrbuf.hxx>
  40 #include <com/sun/star/uno/Any.hxx>
  41 #include <vcl/vclenum.hxx>
  42
  43 #ifndef _XMLOFF_XMLEMENT_HXX
  44 #include <xmloff/xmlelement.hxx>
  45 #endif
  46 #include <tools/string.hxx>
  47
  48 using ::rtl::OUString;
  49 using ::rtl::OUStringBuffer;
  50
  51 using namespace ::com::sun::star;
  52 using namespace ::xmloff::token;
  53
  54 const SvXMLEnumMapEntry* lcl_getFontFamilyGenericMapping()
  55 {
  56     static SvXMLEnumMapEntry __READONLY_DATA aFontFamilyGenericMapping[] =
  57     {
  58         { XML_DECORATIVE,           FAMILY_DECORATIVE },
  59
  60         { XML_MODERN,               FAMILY_MODERN       },
  61         { XML_ROMAN,            FAMILY_ROMAN    },
  62         { XML_SCRIPT,               FAMILY_SCRIPT       },
  63         { XML_SWISS,            FAMILY_SWISS    },
  64         { XML_SYSTEM,                   FAMILY_SYSTEM   },
  65         { XML_TOKEN_INVALID,    0                               }
  66     };
  67     return aFontFamilyGenericMapping;
  68 }
  69
  70 static SvXMLEnumMapEntry __READONLY_DATA aFontPitchMapping[] =
  71 {
  72     { XML_FIXED,                    PITCH_FIXED         },
  73     { XML_VARIABLE,             PITCH_VARIABLE  },
  74     { XML_TOKEN_INVALID,    0                           }
  75 };
  76 ///////////////////////////////////////////////////////////////////////////////
  77 //
  78 // class XMLFontFamilyNamePropHdl
  79 //
  80
  81 XMLFontFamilyNamePropHdl::~XMLFontFamilyNamePropHdl()
  82 {
  83     // Nothing to do
  84 }
  85
  86 sal_Bool XMLFontFamilyNamePropHdl::importXML( const OUString& rStrImpValue, uno::Any& rValue, const SvXMLUnitConverter& ) const
  87 {
  88     sal_Bool bRet = sal_False;
  89     String sValue;
  90     sal_Int32 nPos = 0;
  91
  92     do
  93     {
  94         sal_Int32 nFirst = nPos;
  95         nPos = SvXMLUnitConverter::indexOfComma( rStrImpValue, nPos );
  96         sal_Int32 nLast = (-1 == nPos ? rStrImpValue.getLength() : nPos);
  97         if( nLast > 0 )
  98             nLast--;
  99
 100         // skip trailing blanks
 101         while( sal_Unicode(' ') == rStrImpValue[nLast] && nLast > nFirst )
 102             nLast--;
 103
 104         // skip leading blanks
 105         while( sal_Unicode(' ') == rStrImpValue[nFirst] && nFirst <= nLast )
 106             nFirst++;
 107
 108         // remove quotes
 109         sal_Unicode c = rStrImpValue[nFirst];
 110         if( nFirst < nLast && (sal_Unicode('\'') == c || sal_Unicode('\"') == c) && rStrImpValue[nLast] == c )
 111         {
 112             nFirst++;
 113             nLast--;
 114         }
 115
 116         if( nFirst <= nLast )
 117         {
 118             if( sValue.Len() != 0 )
 119                 sValue += sal_Unicode(';');
 120
 121             OUString sTemp = rStrImpValue.copy( nFirst, nLast-nFirst+1 );
 122             sValue += sTemp.getStr();
 123         }
 124
 125         if( -1 != nPos )
 126             nPos++;
 127     }
 128     while( -1 != nPos );
 129
 130     if( sValue.Len() )
 131     {
 132         rValue <<= OUString(sValue.GetBuffer());
 133         bRet = sal_True;
 134     }
 135
 136     return bRet;
 137 }
 138
 139 sal_Bool XMLFontFamilyNamePropHdl::exportXML( OUString& rStrExpValue, const uno::Any& rValue, const SvXMLUnitConverter& ) const
 140 {
 141     sal_Bool bRet = sal_False;
 142     OUString aStrFamilyName;
 143
 144     if( rValue >>= aStrFamilyName )
 145     {
 146         OUStringBuffer sValue( aStrFamilyName.getLength() + 2L );
 147         sal_Int32 nPos = 0L;
 148         do
 149         {
 150             sal_Int32 nFirst = nPos;
 151             nPos = aStrFamilyName.indexOf( sal_Unicode(';'), nPos );
 152             sal_Int32 nLast = (-1L == nPos ? aStrFamilyName.getLength() : nPos);
 153
 154             // Set position to the character behind the ';', so we won't
 155             // forget this.
 156             if( -1L != nPos )
 157                 nPos++;
 158
 159             // If the property value was empty, we stop now.
 160             // If there is a ';' at the first position, the empty name
 161             // at the start will be removed.
 162             if( 0L == nLast )
 163                 continue;
 164
 165             // nFirst and nLast now denote the first and last character of
 166             // one font name.
 167             nLast--;
 168
 169             // skip trailing blanks
 170             while( sal_Unicode(' ') == aStrFamilyName[nLast] && nLast > nFirst )
 171                 nLast--;
 172
 173             // skip leading blanks
 174             while( sal_Unicode(' ') == aStrFamilyName[nFirst] && nFirst <= nLast )
 175                 nFirst++;
 176
 177             if( nFirst <= nLast )
 178             {
 179                 if( sValue.getLength() != 0L )
 180                 {
 181                     sValue.append( sal_Unicode( ',' ) );
 182                     sValue.append( sal_Unicode( ' ' ));
 183                 }
 184                 sal_Int32 nLen = nLast-nFirst+1L;
 185                 OUString sFamily( aStrFamilyName.copy( nFirst, nLen ) );
 186                 sal_Bool bQuote = sal_False;
 187                 for( sal_Int32 i=0; i < nLen; i++ )
 188                 {
 189                     sal_Unicode c = sFamily[i];
 190                     if( sal_Unicode(' ') == c || sal_Unicode(',') == c )
 191                     {
 192                         bQuote = sal_True;
 193                         break;
 194                     }
 195                 }
 196                 if( bQuote )
 197                     sValue.append( sal_Unicode('\'') );
 198                 sValue.append( sFamily );
 199                 if( bQuote )
 200                     sValue.append( sal_Unicode('\'') );
 201             }
 202         }
 203         while( -1L != nPos );
 204
 205         rStrExpValue = sValue.makeStringAndClear();
 206
 207         bRet = sal_True;
 208     }
 209
 210     return bRet;
 211 }
 212
 213 ///////////////////////////////////////////////////////////////////////////////
 214 //
 215 // class XMLFontFamilyPropHdl
 216 //
 217
 218 XMLFontFamilyPropHdl::~XMLFontFamilyPropHdl()
 219 {
 220     // Nothing to do
 221 }
 222
 223 sal_Bool XMLFontFamilyPropHdl::importXML( const OUString& rStrImpValue, uno::Any& rValue, const SvXMLUnitConverter& ) const
 224 {
 225     sal_uInt16 eNewFamily;
 226     sal_Bool bRet = SvXMLUnitConverter::convertEnum( eNewFamily, rStrImpValue, lcl_getFontFamilyGenericMapping() );
 227     if( bRet )
 228         rValue <<= (sal_Int16)eNewFamily;
 229
 230     return bRet;
 231 }
 232
 233 sal_Bool XMLFontFamilyPropHdl::exportXML( OUString& rStrExpValue, const uno::Any& rValue, const SvXMLUnitConverter& ) const
 234 {
 235     sal_Bool bRet = sal_False;
 236     OUStringBuffer aOut;
 237
 238     sal_Int16 nFamily = sal_Int16();
 239     if( rValue >>= nFamily )
 240     {
 241         FontFamily eFamily = (FontFamily)nFamily;
 242         if( eFamily != FAMILY_DONTKNOW )
 243             bRet = SvXMLUnitConverter::convertEnum( aOut, eFamily, lcl_getFontFamilyGenericMapping() );
 244     }
 245
 246     rStrExpValue = aOut.makeStringAndClear();
 247
 248     return bRet;
 249 }
 250
 251 ///////////////////////////////////////////////////////////////////////////////
 252 //
 253 // class XMLFontEncodingPropHdl
 254 //
 255
 256 XMLFontEncodingPropHdl::~XMLFontEncodingPropHdl()
 257 {
 258     // Nothing to do
 259 }
 260
 261 sal_Bool XMLFontEncodingPropHdl::importXML( const OUString& rStrImpValue, uno::Any& rValue, const SvXMLUnitConverter& ) const
 262 {
 263     sal_Bool bRet = sal_True;
 264
 265     if( IsXMLToken( rStrImpValue, XML_X_SYMBOL ) )
 266         rValue <<= (sal_Int16) RTL_TEXTENCODING_SYMBOL;
 267
 268     return bRet;
 269 }
 270
 271 sal_Bool XMLFontEncodingPropHdl::exportXML( OUString& rStrExpValue, const uno::Any& rValue, const SvXMLUnitConverter& ) const
 272 {
 273     sal_Bool bRet = sal_False;
 274     OUStringBuffer aOut;
 275     sal_Int16 nSet = sal_Int16();
 276
 277     if( rValue >>= nSet )
 278     {
 279         if( (rtl_TextEncoding)nSet == RTL_TEXTENCODING_SYMBOL )
 280         {
 281             aOut.append( GetXMLToken(XML_X_SYMBOL) );
 282             rStrExpValue = aOut.makeStringAndClear();
 283             bRet = sal_True;
 284         }
 285     }
 286
 287     return bRet;
 288 }
 289
 290 ///////////////////////////////////////////////////////////////////////////////
 291 //
 292 // class XMLFontPitchPropHdl
 293 //
 294
 295 XMLFontPitchPropHdl::~XMLFontPitchPropHdl()
 296 {
 297     // Nothing to do
 298 }
 299
 300 sal_Bool XMLFontPitchPropHdl::importXML( const OUString& rStrImpValue, uno::Any& rValue, const SvXMLUnitConverter& ) const
 301 {
 302     USHORT eNewPitch;
 303     sal_Bool bRet = SvXMLUnitConverter::convertEnum( eNewPitch, rStrImpValue, aFontPitchMapping );
 304     if( bRet )
 305         rValue <<= (sal_Int16)eNewPitch;
 306
 307     return bRet;
 308 }
 309
 310 sal_Bool XMLFontPitchPropHdl::exportXML( OUString& rStrExpValue, const uno::Any& rValue, const SvXMLUnitConverter& ) const
 311 {
 312     sal_Bool bRet = sal_False;
 313     sal_Int16 nPitch = sal_Int16();
 314     OUStringBuffer aOut;
 315
 316     FontPitch ePitch = PITCH_DONTKNOW;
 317     if( rValue >>= nPitch )
 318         ePitch =  (FontPitch)nPitch;
 319
 320     if( PITCH_DONTKNOW != ePitch )
 321     {
 322         bRet = SvXMLUnitConverter::convertEnum( aOut, ePitch, aFontPitchMapping, XML_FIXED );
 323         rStrExpValue = aOut.makeStringAndClear();
 324     }
 325
 326     return bRet;
 327 }