LCOV - code coverage report
Current view: top level - xmloff/source/forms - controlpropertyhdl.cxx (source / functions) Hit Total Coverage
Test: commit 10e77ab3ff6f4314137acd6e2702a6e5c1ce1fae Lines: 76 159 47.8 %
Date: 2014-11-03 Functions: 10 17 58.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             : #include <xmloff/controlpropertyhdl.hxx>
      21             : 
      22             : #include <com/sun/star/util/MeasureUnit.hpp>
      23             : #include <com/sun/star/awt/TextAlign.hpp>
      24             : #include <com/sun/star/awt/FontWidth.hpp>
      25             : #include <com/sun/star/awt/FontEmphasisMark.hpp>
      26             : 
      27             : #include <sax/tools/converter.hxx>
      28             : 
      29             : #include <xmloff/xmltypes.hxx>
      30             : #include <xmloff/NamedBoolPropertyHdl.hxx>
      31             : #include "formenums.hxx"
      32             : #include <xmloff/xmluconv.hxx>
      33             : #include <xmloff/xmltoken.hxx>
      34             : #include <rtl/ustrbuf.hxx>
      35             : #include <osl/diagnose.h>
      36             : #include "callbacks.hxx"
      37             : #include <xmloff/XMLConstantsPropertyHandler.hxx>
      38             : 
      39             : namespace xmloff
      40             : {
      41             : 
      42             :     using namespace ::com::sun::star;
      43             :     using namespace ::com::sun::star::uno;
      44             :     using namespace ::com::sun::star::awt;
      45             :     using namespace ::com::sun::star::beans;
      46             :     using namespace ::xmloff::token;
      47             : 
      48             :     //= OControlPropertyHandlerFactory
      49        1648 :     OControlPropertyHandlerFactory::OControlPropertyHandlerFactory()
      50             :         :m_pTextAlignHandler(NULL)
      51             :         ,m_pControlBorderStyleHandler(NULL)
      52             :         ,m_pControlBorderColorHandler(NULL)
      53             :         ,m_pRotationAngleHandler(NULL)
      54             :         ,m_pFontWidthHandler(NULL)
      55             :         ,m_pFontEmphasisHandler(NULL)
      56        1648 :         ,m_pFontReliefHandler(NULL)
      57             :     {
      58        1648 :     }
      59             : 
      60        4188 :     OControlPropertyHandlerFactory::~OControlPropertyHandlerFactory()
      61             :     {
      62        1648 :         delete m_pTextAlignHandler;
      63        1648 :         delete m_pControlBorderStyleHandler;
      64        1648 :         delete m_pControlBorderColorHandler;
      65        1648 :         delete m_pRotationAngleHandler;
      66        1648 :         delete m_pFontWidthHandler;
      67        1648 :         delete m_pFontEmphasisHandler;
      68        1648 :         delete m_pFontReliefHandler;
      69        2540 :     }
      70             : 
      71       15700 :     const XMLPropertyHandler* OControlPropertyHandlerFactory::GetPropertyHandler(sal_Int32 _nType) const
      72             :     {
      73       15700 :         const XMLPropertyHandler* pHandler = NULL;
      74             : 
      75       15700 :         switch (_nType)
      76             :         {
      77             :             case XML_TYPE_TEXT_ALIGN:
      78         524 :                 if (!m_pTextAlignHandler)
      79         524 :                     m_pTextAlignHandler = new XMLConstantsPropertyHandler(OEnumMapper::getEnumMap(OEnumMapper::epTextAlign), XML_TOKEN_INVALID );
      80         524 :                 pHandler = m_pTextAlignHandler;
      81         524 :                 break;
      82             : 
      83             :             case XML_TYPE_CONTROL_BORDER:
      84         136 :                 if (!m_pControlBorderStyleHandler)
      85         136 :                     m_pControlBorderStyleHandler = new OControlBorderHandler( OControlBorderHandler::STYLE );
      86         136 :                 pHandler = m_pControlBorderStyleHandler;
      87         136 :                 break;
      88             : 
      89             :             case XML_TYPE_CONTROL_BORDER_COLOR:
      90         136 :                 if ( !m_pControlBorderColorHandler )
      91         136 :                     m_pControlBorderColorHandler = new OControlBorderHandler( OControlBorderHandler::COLOR );
      92         136 :                 pHandler = m_pControlBorderColorHandler;
      93         136 :                 break;
      94             : 
      95             :             case XML_TYPE_ROTATION_ANGLE:
      96         524 :                 if (!m_pRotationAngleHandler)
      97         524 :                     m_pRotationAngleHandler = new ORotationAngleHandler;
      98         524 :                 pHandler = m_pRotationAngleHandler;
      99         524 :                 break;
     100             : 
     101             :             case XML_TYPE_FONT_WIDTH:
     102         524 :                 if (!m_pFontWidthHandler)
     103         524 :                     m_pFontWidthHandler = new OFontWidthHandler;
     104         524 :                 pHandler = m_pFontWidthHandler;
     105         524 :                 break;
     106             : 
     107             :             case XML_TYPE_CONTROL_TEXT_EMPHASIZE:
     108         524 :                 if (!m_pFontEmphasisHandler)
     109         524 :                     m_pFontEmphasisHandler = new XMLConstantsPropertyHandler( OEnumMapper::getEnumMap(OEnumMapper::epFontEmphasis), XML_NONE );
     110         524 :                 pHandler = m_pFontEmphasisHandler;
     111         524 :                 break;
     112             : 
     113             :             case XML_TYPE_TEXT_FONT_RELIEF:
     114         524 :                 if (!m_pFontReliefHandler)
     115         524 :                     m_pFontReliefHandler = new XMLConstantsPropertyHandler( OEnumMapper::getEnumMap(OEnumMapper::epFontRelief), XML_NONE );
     116         524 :                 pHandler = m_pFontReliefHandler;
     117         524 :                 break;
     118             :             case XML_TYPE_TEXT_LINE_MODE:
     119             :                 pHandler = new XMLNamedBoolPropertyHdl(
     120             :                                             ::xmloff::token::XML_SKIP_WHITE_SPACE,
     121         388 :                                             ::xmloff::token::XML_CONTINUOUS);
     122         388 :                 break;
     123             :         }
     124             : 
     125       15700 :         if (!pHandler)
     126       12420 :             pHandler = XMLPropertyHandlerFactory::GetPropertyHandler(_nType);
     127       15700 :         return pHandler;
     128             :     }
     129             : 
     130             :     //= OControlTextEmphasisHandler
     131        5724 :     OControlTextEmphasisHandler::OControlTextEmphasisHandler()
     132             :     {
     133        5724 :     }
     134             : 
     135           0 :     bool OControlTextEmphasisHandler::exportXML( OUString& _rStrExpValue, const Any& _rValue, const SvXMLUnitConverter& ) const
     136             :     {
     137           0 :         OUStringBuffer aReturn;
     138           0 :         bool bSuccess = false;
     139           0 :         sal_Int16 nFontEmphasis = sal_Int16();
     140           0 :         if (_rValue >>= nFontEmphasis)
     141             :         {
     142             :             // the type
     143           0 :             sal_Int16 nType = nFontEmphasis & ~(awt::FontEmphasisMark::ABOVE | awt::FontEmphasisMark::BELOW);
     144             :             // the position of the mark
     145           0 :             bool bBelow = 0 != (nFontEmphasis & awt::FontEmphasisMark::BELOW);
     146             : 
     147             :             // convert
     148           0 :             bSuccess = SvXMLUnitConverter::convertEnum(aReturn, nType, OEnumMapper::getEnumMap(OEnumMapper::epFontEmphasis), XML_NONE);
     149           0 :             if (bSuccess)
     150             :             {
     151           0 :                 aReturn.append( ' ' );
     152           0 :                 aReturn.append( GetXMLToken(bBelow ? XML_BELOW : XML_ABOVE) );
     153             : 
     154           0 :                 _rStrExpValue = aReturn.makeStringAndClear();
     155             :             }
     156             :         }
     157             : 
     158           0 :         return bSuccess;
     159             :     }
     160             : 
     161           0 :     bool OControlTextEmphasisHandler::importXML( const OUString& _rStrImpValue, Any& _rValue, const SvXMLUnitConverter& ) const
     162             :     {
     163           0 :         bool bSuccess = true;
     164           0 :         sal_uInt16 nEmphasis = awt::FontEmphasisMark::NONE;
     165             : 
     166           0 :         bool bBelow = false;
     167           0 :         bool bHasPos = false, bHasType = false;
     168             : 
     169           0 :         OUString sToken;
     170           0 :         SvXMLTokenEnumerator aTokenEnum(_rStrImpValue);
     171           0 :         while (aTokenEnum.getNextToken(sToken))
     172             :         {
     173           0 :             if (!bHasPos)
     174             :             {
     175           0 :                 if (IsXMLToken(sToken, XML_ABOVE))
     176             :                 {
     177           0 :                     bBelow = false;
     178           0 :                     bHasPos = true;
     179             :                 }
     180           0 :                 else if (IsXMLToken(sToken, XML_BELOW))
     181             :                 {
     182           0 :                     bBelow = true;
     183           0 :                     bHasPos = true;
     184             :                 }
     185             :             }
     186           0 :             if (!bHasType)
     187             :             {
     188           0 :                 if (SvXMLUnitConverter::convertEnum(nEmphasis, sToken, OEnumMapper::getEnumMap(OEnumMapper::epFontEmphasis)))
     189             :                 {
     190           0 :                     bHasType = true;
     191             :                 }
     192             :                 else
     193             :                 {
     194           0 :                     bSuccess = false;
     195           0 :                     break;
     196             :                 }
     197             :             }
     198             :         }
     199             : 
     200           0 :         if (bSuccess)
     201             :         {
     202           0 :             nEmphasis |= bBelow ? awt::FontEmphasisMark::BELOW : awt::FontEmphasisMark::ABOVE;
     203           0 :             _rValue <<= (sal_Int16)nEmphasis;
     204             :         }
     205             : 
     206           0 :         return bSuccess;
     207             :     }
     208             : 
     209             :     //= OControlBorderHandlerBase
     210       11720 :     OControlBorderHandler::OControlBorderHandler( const OControlBorderHandler::BorderFacet _eFacet )
     211       11720 :         :m_eFacet( _eFacet )
     212             :     {
     213       11720 :     }
     214             : 
     215         352 :     bool OControlBorderHandler::importXML( const OUString& _rStrImpValue, Any& _rValue, const SvXMLUnitConverter& ) const
     216             :     {
     217         352 :         OUString sToken;
     218         352 :         SvXMLTokenEnumerator aTokens(_rStrImpValue);
     219             : 
     220         352 :         sal_uInt16 nStyle = 1;
     221             : 
     222        1912 :         while   (   aTokens.getNextToken(sToken)    // have a new token
     223         780 :                 &&  (!sToken.isEmpty())       // really have a new token
     224             :                 )
     225             :         {
     226             :             // try interpreting the token as border style
     227         730 :             if ( m_eFacet == STYLE )
     228             :             {
     229             :                 // is it a valid enum value?
     230         302 :                 if ( SvXMLUnitConverter::convertEnum( nStyle, sToken, OEnumMapper::getEnumMap( OEnumMapper::epBorderWidth ) ) )
     231             :                 {
     232         176 :                     _rValue <<= nStyle;
     233         176 :                     return true;
     234             :                 }
     235             :             }
     236             : 
     237             :             // try interpreting it as color value
     238         554 :             if ( m_eFacet == COLOR )
     239             :             {
     240         428 :                 sal_Int32 nColor(0);
     241         428 :                 if (::sax::Converter::convertColor( nColor, sToken ))
     242             :                 {
     243         126 :                     _rValue <<= nColor;
     244         126 :                     return true;
     245             :                 }
     246             :             }
     247             :         }
     248             : 
     249          50 :         return false;
     250             :     }
     251             : 
     252           0 :     bool OControlBorderHandler::exportXML( OUString& _rStrExpValue, const Any& _rValue, const SvXMLUnitConverter& ) const
     253             :     {
     254           0 :         bool bSuccess = false;
     255             : 
     256           0 :         OUStringBuffer aOut;
     257           0 :         switch ( m_eFacet )
     258             :         {
     259             :         case STYLE:
     260             :         {
     261           0 :             sal_Int16 nBorder = 0;
     262           0 :             bSuccess =  (_rValue >>= nBorder)
     263           0 :                     &&  SvXMLUnitConverter::convertEnum( aOut, nBorder, OEnumMapper::getEnumMap( OEnumMapper::epBorderWidth ) );
     264             :         }
     265           0 :         break;
     266             :         case COLOR:
     267             :         {
     268           0 :             sal_Int32 nBorderColor = 0;
     269           0 :             if ( _rValue >>= nBorderColor )
     270             :             {
     271           0 :                 ::sax::Converter::convertColor(aOut, nBorderColor);
     272           0 :                 bSuccess = true;
     273             :             }
     274             :         }
     275           0 :         break;
     276             :         }   // switch ( m_eFacet )
     277             : 
     278           0 :         if ( !bSuccess )
     279           0 :             return false;
     280             : 
     281           0 :         if ( !_rStrExpValue.isEmpty() )
     282           0 :             _rStrExpValue += " ";
     283           0 :         _rStrExpValue += aOut.makeStringAndClear();
     284             : 
     285           0 :         return true;
     286             :     }
     287             : 
     288             :     //= OFontWidthHandler
     289         524 :     OFontWidthHandler::OFontWidthHandler()
     290             :     {
     291         524 :     }
     292             : 
     293           0 :     bool OFontWidthHandler::importXML( const OUString& _rStrImpValue, Any& _rValue, const SvXMLUnitConverter& ) const
     294             :     {
     295           0 :         sal_Int32 nWidth = 0;
     296             :         bool const bSuccess = ::sax::Converter::convertMeasure(
     297           0 :                 nWidth, _rStrImpValue, util::MeasureUnit::POINT);
     298           0 :         if (bSuccess)
     299           0 :             _rValue <<= (sal_Int16)nWidth;
     300             : 
     301           0 :         return bSuccess;
     302             :     }
     303             : 
     304           0 :     bool OFontWidthHandler::exportXML( OUString& _rStrExpValue, const Any& _rValue, const SvXMLUnitConverter& ) const
     305             :     {
     306           0 :         sal_Int16 nWidth = 0;
     307           0 :         OUStringBuffer aResult;
     308           0 :         if (_rValue >>= nWidth)
     309             :         {
     310             :             ::sax::Converter::convertMeasure(aResult, nWidth,
     311           0 :                     util::MeasureUnit::POINT, util::MeasureUnit::POINT);
     312             :         }
     313           0 :         _rStrExpValue = aResult.makeStringAndClear();
     314             : 
     315           0 :         return !_rStrExpValue.isEmpty();
     316             :     }
     317             : 
     318             :     //= ORotationAngleHandler
     319         524 :     ORotationAngleHandler::ORotationAngleHandler()
     320             :     {
     321         524 :     }
     322             : 
     323           0 :     bool ORotationAngleHandler::importXML( const OUString& _rStrImpValue, Any& _rValue, const SvXMLUnitConverter& ) const
     324             :     {
     325             :         double fValue;
     326             :         bool const bSucces =
     327           0 :             ::sax::Converter::convertDouble(fValue, _rStrImpValue);
     328           0 :         if (bSucces)
     329             :         {
     330           0 :             fValue *= 10;
     331           0 :             _rValue <<= (float)fValue;
     332             :         }
     333             : 
     334           0 :         return bSucces;
     335             :     }
     336             : 
     337           0 :     bool ORotationAngleHandler::exportXML( OUString& _rStrExpValue, const Any& _rValue, const SvXMLUnitConverter& ) const
     338             :     {
     339           0 :         float fAngle = 0;
     340           0 :         bool bSuccess = (_rValue >>= fAngle);
     341             : 
     342           0 :         if (bSuccess)
     343             :         {
     344           0 :             OUStringBuffer sValue;
     345           0 :             ::sax::Converter::convertDouble(sValue, ((double)fAngle) / 10);
     346           0 :             _rStrExpValue = sValue.makeStringAndClear();
     347             :         }
     348             : 
     349           0 :         return bSuccess;
     350             :     }
     351             : 
     352             :     //= ImageScaleModeHandler
     353        5724 :     ImageScaleModeHandler::ImageScaleModeHandler()
     354        5724 :         :XMLConstantsPropertyHandler( OEnumMapper::getEnumMap( OEnumMapper::epImageScaleMode ), XML_STRETCH )
     355             :     {
     356        5724 :     }
     357             : 
     358             : }   // namespace xmloff
     359             : 
     360             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10