LCOV - code coverage report
Current view: top level - libreoffice/xmloff/source/style - xmlbahdl.cxx (source / functions) Hit Total Coverage
Test: libreoffice_filtered.info Lines: 280 417 67.1 %
Date: 2012-12-27 Functions: 75 94 79.8 %
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             : 
      21             : #include <xmlbahdl.hxx>
      22             : 
      23             : #include <tools/debug.hxx>
      24             : #include <sax/tools/converter.hxx>
      25             : #include <xmloff/xmluconv.hxx>
      26             : #include <com/sun/star/uno/Any.hxx>
      27             : #include <xmloff/xmltoken.hxx>
      28             : 
      29             : using ::rtl::OUString;
      30             : using ::rtl::OUStringBuffer;
      31             : 
      32             : using namespace ::com::sun::star::uno;
      33             : using namespace ::xmloff::token;
      34             : 
      35        1703 : static void lcl_xmloff_setAny( Any& rValue, sal_Int32 nValue, sal_Int8 nBytes )
      36             : {
      37        1703 :     switch( nBytes )
      38             :     {
      39             :     case 1:
      40           6 :         if( nValue < SCHAR_MIN )
      41           0 :             nValue = SCHAR_MIN;
      42           6 :         else if( nValue > SCHAR_MAX )
      43           0 :             nValue = SCHAR_MAX;
      44           6 :         rValue <<= (sal_Int8)nValue;
      45           6 :         break;
      46             :     case 2:
      47         318 :         if( nValue < SHRT_MIN )
      48           0 :             nValue = SHRT_MIN;
      49         318 :         else if( nValue > SHRT_MAX )
      50           0 :             nValue = SHRT_MAX;
      51         318 :         rValue <<= (sal_Int16)nValue;
      52         318 :         break;
      53             :     case 4:
      54        1379 :         rValue <<= nValue;
      55        1379 :         break;
      56             :     }
      57        1703 : }
      58             : 
      59         140 : static sal_Bool lcl_xmloff_getAny( const Any& rValue, sal_Int32& nValue,
      60             :                             sal_Int8 nBytes )
      61             : {
      62         140 :     sal_Bool bRet = sal_False;
      63             : 
      64         140 :     switch( nBytes )
      65             :     {
      66             :     case 1:
      67             :         {
      68           2 :             sal_Int8 nValue8 = 0;
      69           2 :             bRet = rValue >>= nValue8;
      70           2 :             nValue = nValue8;
      71             :         }
      72           2 :         break;
      73             :     case 2:
      74             :         {
      75          12 :             sal_Int16 nValue16 = 0;
      76          12 :             bRet = rValue >>= nValue16;
      77          12 :             nValue = nValue16;
      78             :         }
      79          12 :         break;
      80             :     case 4:
      81         126 :         bRet = rValue >>= nValue;
      82         126 :         break;
      83             :     }
      84             : 
      85         140 :     return bRet;
      86             : }
      87             : 
      88             : ///////////////////////////////////////////////////////////////////////////////
      89             : //
      90             : // class XMLNumberPropHdl
      91             : //
      92             : 
      93        2898 : XMLNumberPropHdl::~XMLNumberPropHdl()
      94             : {
      95             :     // nothing to do
      96        2898 : }
      97             : 
      98          58 : sal_Bool XMLNumberPropHdl::importXML( const OUString& rStrImpValue, Any& rValue, const SvXMLUnitConverter& ) const
      99             : {
     100          58 :     sal_Int32 nValue = 0;
     101          58 :     bool bRet = ::sax::Converter::convertNumber( nValue, rStrImpValue );
     102          58 :     lcl_xmloff_setAny( rValue, nValue, nBytes );
     103             : 
     104          58 :     return bRet;
     105             : }
     106             : 
     107          12 : sal_Bool XMLNumberPropHdl::exportXML( OUString& rStrExpValue, const Any& rValue, const SvXMLUnitConverter& ) const
     108             : {
     109          12 :     sal_Bool bRet = sal_False;
     110             :     sal_Int32 nValue;
     111          12 :       OUStringBuffer aOut;
     112             : 
     113          12 :     if( lcl_xmloff_getAny( rValue, nValue, nBytes ) )
     114             :     {
     115          10 :         ::sax::Converter::convertNumber( aOut, nValue );
     116          10 :         rStrExpValue = aOut.makeStringAndClear();
     117             : 
     118          10 :         bRet = sal_True;
     119             :     }
     120             : 
     121          12 :     return bRet;
     122             : }
     123             : 
     124             : ///////////////////////////////////////////////////////////////////////////////
     125             : // class XMLNumberNonePropHdl
     126             : //
     127             : 
     128         352 : XMLNumberNonePropHdl::XMLNumberNonePropHdl( sal_Int8 nB ) :
     129         352 :     sZeroStr( GetXMLToken(XML_NO_LIMIT) ),
     130         704 :     nBytes( nB )
     131             : {
     132         352 : }
     133             : 
     134          43 : XMLNumberNonePropHdl::XMLNumberNonePropHdl( enum XMLTokenEnum eZeroString, sal_Int8 nB ) :
     135          43 :     sZeroStr( GetXMLToken( eZeroString ) ),
     136          86 :     nBytes( nB )
     137             : {
     138          43 : }
     139             : 
     140         790 : XMLNumberNonePropHdl::~XMLNumberNonePropHdl()
     141             : {
     142             :     // nothing to do
     143         790 : }
     144             : 
     145          18 : sal_Bool XMLNumberNonePropHdl::importXML( const OUString& rStrImpValue, Any& rValue, const SvXMLUnitConverter& ) const
     146             : {
     147          18 :     sal_Bool bRet = sal_False;
     148             : 
     149          18 :     sal_Int32 nValue = 0;
     150          18 :     if( rStrImpValue == sZeroStr )
     151             :     {
     152          18 :         bRet = sal_True;
     153             :     }
     154             :     else
     155             :     {
     156           0 :         bRet = ::sax::Converter::convertNumber( nValue, rStrImpValue );
     157             :     }
     158          18 :     lcl_xmloff_setAny( rValue, nValue, nBytes );
     159             : 
     160          18 :     return bRet;
     161             : }
     162             : 
     163           2 : sal_Bool XMLNumberNonePropHdl::exportXML( OUString& rStrExpValue, const Any& rValue, const SvXMLUnitConverter& ) const
     164             : {
     165           2 :     sal_Bool bRet = sal_False;
     166             :     sal_Int32 nValue;
     167             : 
     168           2 :     if( lcl_xmloff_getAny( rValue, nValue, nBytes ) )
     169             :     {
     170           2 :           OUStringBuffer aOut;
     171             : 
     172           2 :         if( nValue == 0 )
     173             :         {
     174           2 :             aOut.append( sZeroStr );
     175             :         }
     176             :         else
     177             :         {
     178           0 :             ::sax::Converter::convertNumber( aOut, nValue );
     179             :         }
     180             : 
     181           2 :         rStrExpValue = aOut.makeStringAndClear();
     182             : 
     183           2 :         bRet = sal_True;
     184             :     }
     185             : 
     186           2 :     return bRet;
     187             : }
     188             : 
     189             : ///////////////////////////////////////////////////////////////////////////////
     190             : //
     191             : // class XMLMeasurePropHdl
     192             : //
     193             : 
     194        2336 : XMLMeasurePropHdl::~XMLMeasurePropHdl()
     195             : {
     196             :     // nothing to do
     197        2336 : }
     198             : 
     199        1312 : sal_Bool XMLMeasurePropHdl::importXML( const OUString& rStrImpValue, Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const
     200             : {
     201        1312 :     sal_Bool bRet = sal_False;
     202             : 
     203        1312 :     sal_Int32 nValue = 0;
     204        1312 :     bRet = rUnitConverter.convertMeasureToCore( nValue, rStrImpValue );
     205        1312 :     lcl_xmloff_setAny( rValue, nValue, nBytes );
     206             : 
     207        1312 :     return bRet;
     208             : }
     209             : 
     210         120 : sal_Bool XMLMeasurePropHdl::exportXML( OUString& rStrExpValue, const Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const
     211             : {
     212         120 :     sal_Bool bRet = sal_False;
     213             :     sal_Int32 nValue;
     214         120 :       OUStringBuffer aOut;
     215             : 
     216         120 :     if( lcl_xmloff_getAny( rValue, nValue, nBytes ) )
     217             :     {
     218         120 :         rUnitConverter.convertMeasureToXML( aOut, nValue );
     219         120 :         rStrExpValue = aOut.makeStringAndClear();
     220             : 
     221         120 :         bRet = sal_True;
     222             :     }
     223             : 
     224         120 :     return bRet;
     225             : }
     226             : 
     227             : ///////////////////////////////////////////////////////////////////////////////
     228             : //
     229             : // class XMLBoolFalsePropHdl
     230             : //
     231             : 
     232           0 : XMLBoolFalsePropHdl::~XMLBoolFalsePropHdl()
     233             : {
     234             :     // nothing to do
     235           0 : }
     236             : 
     237           0 : sal_Bool XMLBoolFalsePropHdl::importXML( const OUString&, Any&, const SvXMLUnitConverter& ) const
     238             : {
     239           0 :     return sal_False;
     240             : }
     241             : 
     242           0 : sal_Bool XMLBoolFalsePropHdl::exportXML( OUString& rStrExpValue, const Any& /*rValue*/, const SvXMLUnitConverter& rCnv) const
     243             : {
     244           0 :     return XMLBoolPropHdl::exportXML( rStrExpValue, makeAny( sal_False ), rCnv );
     245             : }
     246             : 
     247             : ///////////////////////////////////////////////////////////////////////////////
     248             : //
     249             : // class XMLBoolPropHdl
     250             : //
     251             : 
     252        2242 : XMLBoolPropHdl::~XMLBoolPropHdl()
     253             : {
     254             :     // nothing to do
     255        2242 : }
     256             : 
     257         354 : sal_Bool XMLBoolPropHdl::importXML( const OUString& rStrImpValue, Any& rValue, const SvXMLUnitConverter& ) const
     258             : {
     259         354 :     bool bValue(false);
     260         354 :     bool const bRet = ::sax::Converter::convertBool( bValue, rStrImpValue );
     261         354 :     rValue <<= sal_Bool(bValue);
     262             : 
     263         354 :     return bRet;
     264             : }
     265             : 
     266          34 : sal_Bool XMLBoolPropHdl::exportXML( OUString& rStrExpValue, const Any& rValue, const SvXMLUnitConverter& ) const
     267             : {
     268          34 :     sal_Bool bRet = sal_False;
     269          34 :       OUStringBuffer aOut;
     270          34 :     sal_Bool bValue = sal_Bool();
     271             : 
     272          34 :     if (rValue >>= bValue)
     273             :     {
     274          34 :         ::sax::Converter::convertBool( aOut, bValue );
     275          34 :         rStrExpValue = aOut.makeStringAndClear();
     276             : 
     277          34 :         bRet = sal_True;
     278             :     }
     279             : 
     280          34 :     return bRet;
     281             : }
     282             : 
     283             : ///////////////////////////////////////////////////////////////////////////////
     284             : //
     285             : // class XMLNBoolPropHdl
     286             : //
     287             : 
     288           8 : XMLNBoolPropHdl::~XMLNBoolPropHdl()
     289             : {
     290             :     // nothing to do
     291           8 : }
     292             : 
     293           0 : sal_Bool XMLNBoolPropHdl::importXML( const OUString& rStrImpValue, Any& rValue, const SvXMLUnitConverter& ) const
     294             : {
     295           0 :     bool bValue(false);
     296           0 :     bool const bRet = ::sax::Converter::convertBool( bValue, rStrImpValue );
     297           0 :     rValue <<= sal_Bool(!bValue);
     298             : 
     299           0 :     return bRet;
     300             : }
     301             : 
     302           0 : sal_Bool XMLNBoolPropHdl::exportXML( OUString& rStrExpValue, const Any& rValue, const SvXMLUnitConverter& ) const
     303             : {
     304           0 :     sal_Bool bRet = sal_False;
     305           0 :       OUStringBuffer aOut;
     306           0 :     sal_Bool bValue = sal_Bool();
     307             : 
     308           0 :     if (rValue >>= bValue)
     309             :     {
     310           0 :         ::sax::Converter::convertBool( aOut, !bValue );
     311           0 :         rStrExpValue = aOut.makeStringAndClear();
     312             : 
     313           0 :         bRet = sal_True;
     314             :     }
     315             : 
     316           0 :     return bRet;
     317             : }
     318             : 
     319             : ///////////////////////////////////////////////////////////////////////////////
     320             : //
     321             : // class XMLPercentPropHdl
     322             : //
     323             : 
     324        2950 : XMLPercentPropHdl::~XMLPercentPropHdl()
     325             : {
     326             :     // nothing to do
     327        2950 : }
     328             : 
     329         272 : sal_Bool XMLPercentPropHdl::importXML( const OUString& rStrImpValue, Any& rValue, const SvXMLUnitConverter& ) const
     330             : {
     331         272 :     sal_Int32 nValue = 0;
     332         272 :     bool const bRet = ::sax::Converter::convertPercent( nValue, rStrImpValue );
     333         272 :     lcl_xmloff_setAny( rValue, nValue, nBytes );
     334             : 
     335         272 :     return bRet;
     336             : }
     337             : 
     338           0 : sal_Bool XMLPercentPropHdl::exportXML( OUString& rStrExpValue, const Any& rValue, const SvXMLUnitConverter& ) const
     339             : {
     340           0 :     sal_Bool bRet = sal_False;
     341             :     sal_Int32 nValue;
     342           0 :       OUStringBuffer aOut;
     343             : 
     344           0 :     if( lcl_xmloff_getAny( rValue, nValue, nBytes ) )
     345             :     {
     346           0 :         ::sax::Converter::convertPercent( aOut, nValue );
     347           0 :         rStrExpValue = aOut.makeStringAndClear();
     348             : 
     349           0 :         bRet = sal_True;
     350             :     }
     351             : 
     352           0 :     return bRet;
     353             : }
     354             : 
     355             : ///////////////////////////////////////////////////////////////////////////////
     356             : //
     357             : // class XMLDoublePercentPropHdl
     358             : //
     359             : 
     360           2 : sal_Bool XMLDoublePercentPropHdl::importXML( const OUString& rStrImpValue, Any& rValue, const SvXMLUnitConverter& ) const
     361             : {
     362           2 :     sal_Bool bRet = sal_False;
     363             : 
     364           2 :     double fValue = 1.0;
     365             : 
     366           2 :     if( rStrImpValue.indexOf( (sal_Unicode)'%' ) == -1 )
     367             :     {
     368           0 :         fValue = rStrImpValue.toDouble();
     369             :     }
     370             :     else
     371             :     {
     372           2 :         sal_Int32 nValue = 0;
     373           2 :         bRet = ::sax::Converter::convertPercent( nValue, rStrImpValue );
     374           2 :         fValue = ((double)nValue) / 100.0;
     375             :     }
     376           2 :     rValue <<= fValue;
     377             : 
     378           2 :     return bRet;
     379             : }
     380             : 
     381           0 : sal_Bool XMLDoublePercentPropHdl::exportXML( OUString& rStrExpValue, const Any& rValue, const SvXMLUnitConverter& ) const
     382             : {
     383           0 :     sal_Bool bRet = sal_False;
     384           0 :     double fValue = 0;
     385             : 
     386           0 :     if( rValue >>= fValue )
     387             :     {
     388           0 :         fValue *= 100.0;
     389           0 :         if( fValue > 0 ) fValue += 0.5; else    fValue -= 0.5;
     390             : 
     391           0 :         sal_Int32 nValue = (sal_Int32)fValue;
     392             : 
     393           0 :         OUStringBuffer aOut;
     394           0 :         ::sax::Converter::convertPercent( aOut, nValue );
     395           0 :         rStrExpValue = aOut.makeStringAndClear();
     396             : 
     397           0 :         bRet = sal_True;
     398             :     }
     399             : 
     400           0 :     return bRet;
     401             : }
     402             : 
     403             : 
     404             : ///////////////////////////////////////////////////////////////////////////////
     405             : //
     406             : // class XMLNegPercentPropHdl
     407             : //
     408             : 
     409         774 : XMLNegPercentPropHdl::~XMLNegPercentPropHdl()
     410             : {
     411             :     // nothing to do
     412         774 : }
     413             : 
     414           7 : sal_Bool XMLNegPercentPropHdl::importXML( const OUString& rStrImpValue, Any& rValue, const SvXMLUnitConverter& ) const
     415             : {
     416           7 :     sal_Int32 nValue = 0;
     417           7 :     bool const bRet = ::sax::Converter::convertPercent( nValue, rStrImpValue );
     418           7 :     lcl_xmloff_setAny( rValue, 100-nValue, nBytes );
     419             : 
     420           7 :     return bRet;
     421             : }
     422             : 
     423           0 : sal_Bool XMLNegPercentPropHdl::exportXML( OUString& rStrExpValue, const Any& rValue, const SvXMLUnitConverter& ) const
     424             : {
     425           0 :     sal_Bool bRet = sal_False;
     426             :     sal_Int32 nValue;
     427           0 :       OUStringBuffer aOut;
     428             : 
     429           0 :     if( lcl_xmloff_getAny( rValue, nValue, nBytes ) )
     430             :     {
     431           0 :         ::sax::Converter::convertPercent( aOut, 100-nValue );
     432           0 :         rStrExpValue = aOut.makeStringAndClear();
     433             : 
     434           0 :         bRet = sal_True;
     435             :     }
     436             : 
     437           0 :     return bRet;
     438             : }
     439             : 
     440             : 
     441             : ///////////////////////////////////////////////////////////////////////////////
     442             : //
     443             : // class XMLMeasurePxPropHdl
     444             : //
     445             : 
     446         556 : XMLMeasurePxPropHdl::~XMLMeasurePxPropHdl()
     447             : {
     448             :     // nothing to do
     449         556 : }
     450             : 
     451           0 : sal_Bool XMLMeasurePxPropHdl::importXML( const OUString& rStrImpValue, Any& rValue, const SvXMLUnitConverter& ) const
     452             : {
     453           0 :     sal_Bool bRet = sal_False;
     454             : 
     455           0 :     sal_Int32 nValue = 0;
     456           0 :     bRet = ::sax::Converter::convertMeasurePx( nValue, rStrImpValue );
     457           0 :     lcl_xmloff_setAny( rValue, nValue, nBytes );
     458             : 
     459           0 :     return bRet;
     460             : }
     461             : 
     462           0 : sal_Bool XMLMeasurePxPropHdl::exportXML( OUString& rStrExpValue, const Any& rValue, const SvXMLUnitConverter& ) const
     463             : {
     464           0 :     sal_Bool bRet = sal_False;
     465             :     sal_Int32 nValue;
     466           0 :       OUStringBuffer aOut;
     467             : 
     468           0 :     if( lcl_xmloff_getAny( rValue, nValue, nBytes ) )
     469             :     {
     470           0 :         ::sax::Converter::convertMeasurePx( aOut, nValue );
     471           0 :         rStrExpValue = aOut.makeStringAndClear();
     472             : 
     473           0 :         bRet = sal_True;
     474             :     }
     475             : 
     476           0 :     return bRet;
     477             : }
     478             : 
     479             : ///////////////////////////////////////////////////////////////////////////////
     480             : //
     481             : // class XMLColorPropHdl
     482             : //
     483             : 
     484        1274 : XMLColorPropHdl::~XMLColorPropHdl()
     485             : {
     486             :     // Nothing to do
     487        1274 : }
     488             : 
     489          77 : sal_Bool XMLColorPropHdl::importXML( const OUString& rStrImpValue, Any& rValue, const SvXMLUnitConverter& ) const
     490             : {
     491          77 :     sal_Bool bRet = sal_False;
     492             : 
     493          77 :     const OUString astrHSL( "hsl"  );
     494          77 :     if( rStrImpValue.matchIgnoreAsciiCase( astrHSL ) )
     495             :     {
     496           0 :         sal_Int32 nOpen = rStrImpValue.indexOf( '(' );
     497           0 :         sal_Int32 nClose = rStrImpValue.lastIndexOf( ')' );
     498             : 
     499           0 :         if( (nOpen != -1) && (nClose > nOpen) )
     500             :         {
     501           0 :             const OUString aTmp( rStrImpValue.copy( nOpen+1, nClose - nOpen-1) );
     502             : 
     503           0 :             sal_Int32 nIndex = 0;
     504             : 
     505           0 :             Sequence< double > aHSL(3);
     506           0 :             aHSL[0] = aTmp.getToken( 0, ',', nIndex ).toDouble();
     507           0 :             aHSL[1] = aTmp.getToken( 0, ',', nIndex ).toDouble() / 100.0;
     508           0 :             aHSL[2] = aTmp.getToken( 0, ',', nIndex ).toDouble() / 100.0;
     509           0 :             rValue <<= aHSL;
     510           0 :             bRet = true;
     511             :         }
     512             :     }
     513             :     else
     514             :     {
     515          77 :         sal_Int32 nColor(0);
     516          77 :         bRet = ::sax::Converter::convertColor( nColor, rStrImpValue );
     517          77 :         rValue <<= nColor;
     518             :     }
     519             : 
     520          77 :     return bRet;
     521             : }
     522             : 
     523           6 : sal_Bool XMLColorPropHdl::exportXML( OUString& rStrExpValue, const Any& rValue, const SvXMLUnitConverter& ) const
     524             : {
     525           6 :     sal_Bool bRet = sal_False;
     526           6 :     sal_Int32 nColor = 0;
     527             : 
     528           6 :     OUStringBuffer aOut;
     529           6 :     if( rValue >>= nColor )
     530             :     {
     531           6 :         ::sax::Converter::convertColor( aOut, nColor );
     532           6 :         rStrExpValue = aOut.makeStringAndClear();
     533             : 
     534           6 :         bRet = sal_True;
     535             :     }
     536             :     else
     537             :     {
     538           0 :         Sequence< double > aHSL;
     539           0 :         if( (rValue >>= aHSL) && (aHSL.getLength() == 3) )
     540             :         {
     541           0 :             aOut.append( OUString("hsl(") );
     542           0 :             aOut.append( aHSL[0] );
     543           0 :             aOut.append( OUString(",") );
     544           0 :             aOut.append( aHSL[1] * 100.0 );
     545           0 :             aOut.append( OUString("%,") );
     546           0 :             aOut.append( aHSL[2] * 100.0 );
     547           0 :             aOut.append( OUString("%)") );
     548           0 :             rStrExpValue = aOut.makeStringAndClear();
     549             : 
     550           0 :             bRet = sal_True;
     551           0 :         }
     552             :     }
     553             : 
     554           6 :     return bRet;
     555             : }
     556             : 
     557             : ///////////////////////////////////////////////////////////////////////////////
     558             : //
     559             : // class XMLHexPropHdl
     560             : //
     561             : 
     562         962 : XMLHexPropHdl::~XMLHexPropHdl()
     563             : {
     564             :     // Nothing to do
     565         962 : }
     566             : 
     567           8 : sal_Bool XMLHexPropHdl::importXML( const OUString& rStrImpValue, Any& rValue, const SvXMLUnitConverter& ) const
     568             : {
     569           8 :     sal_Bool bRet = sal_False;
     570             :     sal_uInt32 nRsid;
     571             : 
     572           8 :     bRet = SvXMLUnitConverter::convertHex( nRsid, rStrImpValue );
     573           8 :     rValue <<= nRsid;
     574             : 
     575           8 :     return bRet;
     576             : }
     577             : 
     578           0 : sal_Bool XMLHexPropHdl::exportXML( OUString& rStrExpValue, const Any& rValue, const SvXMLUnitConverter& ) const
     579             : {
     580           0 :     sal_Bool bRet = sal_False;
     581           0 :     sal_uInt32 nRsid = 0;
     582             : 
     583           0 :     OUStringBuffer aOut;
     584           0 :     if( rValue >>= nRsid )
     585             :     {
     586           0 :         SvXMLUnitConverter::convertHex( aOut, nRsid );
     587           0 :         rStrExpValue = aOut.makeStringAndClear();
     588             : 
     589           0 :         bRet = sal_True;
     590             :     }
     591             :     else
     592             :     {
     593           0 :         bRet = sal_False;
     594             :     }
     595             : 
     596           0 :     return bRet;
     597             : }
     598             : 
     599             : ///////////////////////////////////////////////////////////////////////////////
     600             : //
     601             : // class XMLStringPropHdl
     602             : //
     603             : 
     604        2562 : XMLStringPropHdl::~XMLStringPropHdl()
     605             : {
     606             :     // Nothing to do
     607        2562 : }
     608             : 
     609          18 : sal_Bool XMLStringPropHdl::importXML( const OUString& rStrImpValue, Any& rValue, const SvXMLUnitConverter& ) const
     610             : {
     611          18 :     sal_Bool bRet = sal_False;
     612             : 
     613          18 :     rValue <<= rStrImpValue;
     614          18 :     bRet = sal_True;
     615             : 
     616          18 :     return bRet;
     617             : }
     618             : 
     619          32 : sal_Bool XMLStringPropHdl::exportXML( OUString& rStrExpValue, const Any& rValue, const SvXMLUnitConverter& ) const
     620             : {
     621          32 :     sal_Bool bRet = sal_False;
     622             : 
     623          32 :     if( rValue >>= rStrExpValue )
     624          32 :         bRet = sal_True;
     625             : 
     626          32 :     return bRet;
     627             : }
     628             : 
     629             : ///////////////////////////////////////////////////////////////////////////////
     630             : //
     631             : // class XMLStyleNamePropHdl
     632             : //
     633             : 
     634        1008 : XMLStyleNamePropHdl::~XMLStyleNamePropHdl()
     635             : {
     636             :     // Nothing to do
     637        1008 : }
     638             : 
     639           0 : sal_Bool XMLStyleNamePropHdl::exportXML( OUString& rStrExpValue, const Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const
     640             : {
     641           0 :     sal_Bool bRet = sal_False;
     642             : 
     643           0 :     if( rValue >>= rStrExpValue )
     644             :     {
     645           0 :         rStrExpValue = rUnitConverter.encodeStyleName( rStrExpValue );
     646           0 :         bRet = sal_True;
     647             :     }
     648             : 
     649           0 :     return bRet;
     650             : }
     651             : 
     652             : 
     653             : ///////////////////////////////////////////////////////////////////////////////
     654             : //
     655             : // class XMLDoublePropHdl
     656             : //
     657             : 
     658           0 : XMLDoublePropHdl::~XMLDoublePropHdl()
     659             : {
     660             :     // Nothing to do
     661           0 : }
     662             : 
     663           0 : sal_Bool XMLDoublePropHdl::importXML( const OUString& rStrImpValue, Any& rValue, const SvXMLUnitConverter& ) const
     664             : {
     665           0 :     double fDblValue(0.0);
     666           0 :     bool const bRet = ::sax::Converter::convertDouble(fDblValue, rStrImpValue);
     667           0 :     rValue <<= fDblValue;
     668           0 :     return bRet;
     669             : }
     670             : 
     671           0 : sal_Bool XMLDoublePropHdl::exportXML( OUString& rStrExpValue, const Any& rValue, const SvXMLUnitConverter& ) const
     672             : {
     673           0 :     sal_Bool bRet = sal_False;
     674             : 
     675           0 :     double fValue = 0;
     676             : 
     677           0 :     if( rValue >>= fValue )
     678             :     {
     679           0 :         OUStringBuffer aOut;
     680           0 :         ::sax::Converter::convertDouble( aOut, fValue );
     681           0 :         rStrExpValue = aOut.makeStringAndClear();
     682           0 :         bRet = sal_True;
     683             :     }
     684             : 
     685           0 :     return bRet;
     686             : }
     687             : 
     688             : ///////////////////////////////////////////////////////////////////////////////
     689             : //
     690             : // class XMLColorTransparentPropHdl
     691             : //
     692             : 
     693        1882 : XMLColorTransparentPropHdl::XMLColorTransparentPropHdl(
     694             :     enum XMLTokenEnum eTransparent ) :
     695             :     sTransparent( GetXMLToken(
     696        1882 :         eTransparent != XML_TOKEN_INVALID ? eTransparent : XML_TRANSPARENT ) )
     697             : {
     698             :     // Nothing to do
     699        1882 : }
     700             : 
     701        3764 : XMLColorTransparentPropHdl::~XMLColorTransparentPropHdl()
     702             : {
     703             :     // Nothing to do
     704        3764 : }
     705             : 
     706          86 : sal_Bool XMLColorTransparentPropHdl::importXML( const OUString& rStrImpValue, Any& rValue, const SvXMLUnitConverter& ) const
     707             : {
     708          86 :     sal_Bool bRet = sal_False;
     709             : 
     710          86 :     if( rStrImpValue != sTransparent )
     711             :     {
     712          52 :         sal_Int32 nColor(0);
     713          52 :         bRet = ::sax::Converter::convertColor( nColor, rStrImpValue );
     714          52 :         rValue <<= nColor;
     715             :     }
     716             : 
     717          86 :     return bRet;
     718             : }
     719             : 
     720           6 : sal_Bool XMLColorTransparentPropHdl::exportXML( OUString& rStrExpValue, const Any& rValue, const SvXMLUnitConverter& ) const
     721             : {
     722           6 :     sal_Bool bRet = sal_False;
     723           6 :     sal_Int32 nColor = 0;
     724             : 
     725           6 :     if( rStrExpValue == sTransparent )
     726           0 :         bRet = sal_False;
     727           6 :     else if( rValue >>= nColor )
     728             :     {
     729           6 :         OUStringBuffer aOut;
     730           6 :         ::sax::Converter::convertColor( aOut, nColor );
     731           6 :         rStrExpValue = aOut.makeStringAndClear();
     732             : 
     733           6 :         bRet = sal_True;
     734             :     }
     735             : 
     736           6 :     return bRet;
     737             : }
     738             : 
     739             : 
     740             : ///////////////////////////////////////////////////////////////////////////////
     741             : //
     742             : // class XMLIsTransparentPropHdl
     743             : //
     744             : 
     745        1878 : XMLIsTransparentPropHdl::XMLIsTransparentPropHdl(
     746             :     enum XMLTokenEnum eTransparent, sal_Bool bTransPropVal ) :
     747             :     sTransparent( GetXMLToken(
     748        1878 :         eTransparent != XML_TOKEN_INVALID ? eTransparent : XML_TRANSPARENT ) ),
     749        3756 :     bTransPropValue( bTransPropVal )
     750             : {
     751        1878 : }
     752             : 
     753        3756 : XMLIsTransparentPropHdl::~XMLIsTransparentPropHdl()
     754             : {
     755             :     // Nothing to do
     756        3756 : }
     757             : 
     758          86 : sal_Bool XMLIsTransparentPropHdl::importXML( const OUString& rStrImpValue, Any& rValue, const SvXMLUnitConverter& ) const
     759             : {
     760          86 :     sal_Bool bValue = ( (rStrImpValue == sTransparent) == bTransPropValue);
     761          86 :     rValue.setValue( &bValue, ::getBooleanCppuType() );
     762             : 
     763          86 :     return sal_True;
     764             : }
     765             : 
     766           6 : sal_Bool XMLIsTransparentPropHdl::exportXML( OUString& rStrExpValue, const Any& rValue, const SvXMLUnitConverter& ) const
     767             : {
     768           6 :     sal_Bool bRet = sal_False;
     769             : 
     770             :     // MIB: This looks a bit strange, because bTransPropValue == bValue should
     771             :     // do the same, but this only applies if 'true' is represented by the same
     772             :     // 8 bit value in bValue and bTransPropValue. Who will ensure this?
     773           6 :     sal_Bool bValue = *(sal_Bool *)rValue.getValue();
     774           6 :     sal_Bool bIsTrans = bTransPropValue ? bValue : !bValue;
     775             : 
     776           6 :     if( bIsTrans )
     777             :     {
     778           2 :         rStrExpValue = sTransparent;
     779           2 :         bRet = sal_True;
     780             :     }
     781             : 
     782           6 :     return bRet;
     783             : }
     784             : 
     785             : ///////////////////////////////////////////////////////////////////////////////
     786             : //
     787             : // class XMLColorAutoPropHdl
     788             : //
     789             : 
     790         577 : XMLColorAutoPropHdl::XMLColorAutoPropHdl()
     791             : {
     792             :     // Nothing to do
     793         577 : }
     794             : 
     795        1154 : XMLColorAutoPropHdl::~XMLColorAutoPropHdl()
     796             : {
     797             :     // Nothing to do
     798        1154 : }
     799             : 
     800          26 : sal_Bool XMLColorAutoPropHdl::importXML( const OUString& rStrImpValue, Any& rValue, const SvXMLUnitConverter& ) const
     801             : {
     802          26 :     sal_Bool bRet = sal_False;
     803             : 
     804             :     // This is a multi property: the value might be set to AUTO_COLOR
     805             :     // already by the XMLIsAutoColorPropHdl!
     806          26 :     sal_Int32 nColor = 0;
     807          26 :     if( !(rValue >>= nColor) || -1 != nColor )
     808             :     {
     809          26 :         bRet = ::sax::Converter::convertColor( nColor, rStrImpValue );
     810          26 :         if( bRet )
     811          26 :             rValue <<= nColor;
     812             :     }
     813             : 
     814          26 :     return bRet;
     815             : }
     816             : 
     817           7 : sal_Bool XMLColorAutoPropHdl::exportXML( OUString& rStrExpValue, const Any& rValue, const SvXMLUnitConverter& ) const
     818             : {
     819           7 :     sal_Bool bRet = sal_False;
     820             : 
     821           7 :     sal_Int32 nColor = 0;
     822           7 :     if( (rValue >>= nColor) && -1 != nColor )
     823             :     {
     824           0 :         OUStringBuffer aOut;
     825           0 :         ::sax::Converter::convertColor( aOut, nColor );
     826           0 :         rStrExpValue = aOut.makeStringAndClear();
     827             : 
     828           0 :         bRet = sal_True;
     829             :     }
     830             : 
     831           7 :     return bRet;
     832             : }
     833             : 
     834             : ///////////////////////////////////////////////////////////////////////////////
     835             : //
     836             : // class XMLIsAutoColorPropHdl
     837             : //
     838             : 
     839         481 : XMLIsAutoColorPropHdl::XMLIsAutoColorPropHdl()
     840             : {
     841         481 : }
     842             : 
     843         962 : XMLIsAutoColorPropHdl::~XMLIsAutoColorPropHdl()
     844             : {
     845             :     // Nothing to do
     846         962 : }
     847             : 
     848          45 : sal_Bool XMLIsAutoColorPropHdl::importXML( const OUString& rStrImpValue, Any& rValue, const SvXMLUnitConverter& ) const
     849             : {
     850             :     // An auto color overrides any other color set!
     851             :     bool bValue;
     852          45 :     bool const bRet = ::sax::Converter::convertBool( bValue, rStrImpValue );
     853          45 :     if( bRet && bValue )
     854          45 :         rValue <<= (sal_Int32)-1;
     855             : 
     856          45 :     return sal_True;
     857             : }
     858             : 
     859           5 : sal_Bool XMLIsAutoColorPropHdl::exportXML( OUString& rStrExpValue, const Any& rValue, const SvXMLUnitConverter& ) const
     860             : {
     861           5 :     sal_Bool bRet = sal_False;
     862           5 :     sal_Int32 nColor = 0;
     863             : 
     864           5 :     if( (rValue >>= nColor) && -1 == nColor )
     865             :     {
     866           5 :         OUStringBuffer aOut;
     867           5 :         ::sax::Converter::convertBool( aOut, true );
     868           5 :         rStrExpValue = aOut.makeStringAndClear();
     869             : 
     870           5 :         bRet = sal_True;
     871             :     }
     872             : 
     873           5 :     return bRet;
     874             : }
     875             : 
     876             : ///////////////////////////////////////////////////////////////////////////////
     877             : //
     878             : // class XMLCompareOnlyPropHdl
     879             : //
     880             : 
     881        1792 : XMLCompareOnlyPropHdl::~XMLCompareOnlyPropHdl()
     882             : {
     883             :     // Nothing to do
     884        1792 : }
     885             : 
     886           0 : sal_Bool XMLCompareOnlyPropHdl::importXML( const OUString&, Any&, const SvXMLUnitConverter& ) const
     887             : {
     888             :     DBG_ASSERT( !this, "importXML called for compare-only-property" );
     889           0 :     return sal_False;
     890             : }
     891             : 
     892           0 : sal_Bool XMLCompareOnlyPropHdl::exportXML( OUString&, const Any&, const SvXMLUnitConverter& ) const
     893             : {
     894             :     DBG_ASSERT( !this, "exportXML called for compare-only-property" );
     895           0 :     return sal_False;
     896             : }
     897             : 
     898             : ///////////////////////////////////////////////////////////////////////////////
     899             : // class XMLNumberWithoutZeroPropHdl
     900             : //
     901             : 
     902         704 : XMLNumberWithoutZeroPropHdl::XMLNumberWithoutZeroPropHdl( sal_Int8 nB ) :
     903         704 :     nBytes( nB )
     904             : {
     905         704 : }
     906             : 
     907        1056 : XMLNumberWithoutZeroPropHdl::~XMLNumberWithoutZeroPropHdl()
     908             : {
     909        1056 : }
     910             : 
     911          36 : sal_Bool XMLNumberWithoutZeroPropHdl::importXML(
     912             :     const OUString& rStrImpValue,
     913             :     Any& rValue,
     914             :     const SvXMLUnitConverter& ) const
     915             : {
     916          36 :     sal_Int32 nValue = 0;
     917          36 :     bool const bRet = ::sax::Converter::convertNumber( nValue, rStrImpValue );
     918          36 :     if( bRet )
     919          36 :         lcl_xmloff_setAny( rValue, nValue, nBytes );
     920          36 :     return bRet;
     921             : }
     922             : 
     923           4 : sal_Bool XMLNumberWithoutZeroPropHdl::exportXML( OUString& rStrExpValue, const Any& rValue, const SvXMLUnitConverter& ) const
     924             : {
     925             : 
     926           4 :     sal_Int32 nValue = 0;
     927           4 :     sal_Bool bRet = lcl_xmloff_getAny( rValue, nValue, nBytes );
     928           4 :     bRet &= nValue != 0;
     929             : 
     930           4 :     if( bRet )
     931             :     {
     932           4 :           OUStringBuffer aBuffer;
     933           4 :         ::sax::Converter::convertNumber( aBuffer, nValue );
     934           4 :         rStrExpValue = aBuffer.makeStringAndClear();
     935             :     }
     936             : 
     937           4 :     return bRet;
     938             : }
     939             : 
     940             : ///////////////////////////////////////////////////////////////////////////////
     941             : // class XMLNumberWithAutoInsteadZeroPropHdl
     942             : //
     943             : 
     944         704 : XMLNumberWithAutoInsteadZeroPropHdl::~XMLNumberWithAutoInsteadZeroPropHdl()
     945             : {
     946         704 : }
     947             : 
     948          16 : sal_Bool XMLNumberWithAutoInsteadZeroPropHdl::importXML(
     949             :     const OUString& rStrImpValue,
     950             :     Any& rValue,
     951             :     const SvXMLUnitConverter& ) const
     952             : {
     953          16 :     sal_Int32 nValue = 0;
     954          16 :     bool bRet = ::sax::Converter::convertNumber( nValue, rStrImpValue );
     955          16 :     if( bRet )
     956           0 :         lcl_xmloff_setAny( rValue, nValue, 2 );
     957          16 :     else if( rStrImpValue == GetXMLToken( XML_AUTO ) )
     958             :     {
     959          16 :         rValue <<= (sal_Int16)nValue;
     960          16 :         bRet = sal_True;
     961             :     }
     962          16 :     return bRet;
     963             : }
     964             : 
     965           2 : sal_Bool XMLNumberWithAutoInsteadZeroPropHdl::exportXML( OUString& rStrExpValue, const Any& rValue, const SvXMLUnitConverter& ) const
     966             : {
     967             : 
     968           2 :     sal_Int32 nValue = 0;
     969           2 :     lcl_xmloff_getAny( rValue, nValue, 2 );
     970             : 
     971           2 :     if( 0 == nValue )
     972           2 :         rStrExpValue = GetXMLToken( XML_AUTO );
     973             :     else
     974             :     {
     975           0 :         OUStringBuffer aBuffer;
     976           0 :         ::sax::Converter::convertNumber( aBuffer, nValue );
     977           0 :         rStrExpValue = aBuffer.makeStringAndClear();
     978             :     }
     979             : 
     980           2 :     return sal_True;
     981             : }
     982             : 
     983             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10