LCOV - code coverage report
Current view: top level - xmloff/source/text - XMLTextColumnsContext.cxx (source / functions) Hit Total Coverage
Test: commit 10e77ab3ff6f4314137acd6e2702a6e5c1ce1fae Lines: 109 181 60.2 %
Date: 2014-11-03 Functions: 9 32 28.1 %
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 <com/sun/star/text/XTextColumns.hpp>
      21             : #include <com/sun/star/text/TextColumn.hpp>
      22             : #include <com/sun/star/lang/XMultiServiceFactory.hpp>
      23             : #include <com/sun/star/style/VerticalAlignment.hpp>
      24             : #include <com/sun/star/beans/XPropertySet.hpp>
      25             : #include <sax/tools/converter.hxx>
      26             : #include <xmloff/xmltkmap.hxx>
      27             : #include <xmloff/xmluconv.hxx>
      28             : #include <xmloff/nmspmap.hxx>
      29             : #include <xmloff/xmlnmspe.hxx>
      30             : #include <xmloff/xmlimp.hxx>
      31             : #include <xmloff/xmltoken.hxx>
      32             : #include "XMLTextColumnsContext.hxx"
      33             : 
      34             : using namespace ::com::sun::star;
      35             : using namespace ::com::sun::star::uno;
      36             : using namespace ::com::sun::star::lang;
      37             : using namespace ::com::sun::star::text;
      38             : using namespace ::com::sun::star::style;
      39             : using namespace ::com::sun::star::beans;
      40             : using namespace ::xmloff::token;
      41             : 
      42             : enum SvXMLTokenMapAttrs
      43             : {
      44             :     XML_TOK_COLUMN_WIDTH,
      45             :     XML_TOK_COLUMN_MARGIN_LEFT,
      46             :     XML_TOK_COLUMN_MARGIN_RIGHT,
      47             :     XML_TOK_COLUMN_END=XML_TOK_UNKNOWN
      48             : };
      49             : 
      50             : enum SvXMLSepTokenMapAttrs
      51             : {
      52             :     XML_TOK_COLUMN_SEP_WIDTH,
      53             :     XML_TOK_COLUMN_SEP_HEIGHT,
      54             :     XML_TOK_COLUMN_SEP_COLOR,
      55             :     XML_TOK_COLUMN_SEP_ALIGN,
      56             :     XML_TOK_COLUMN_SEP_STYLE,
      57             :     XML_TOK_COLUMN_SEP_END=XML_TOK_UNKNOWN
      58             : };
      59             : 
      60             : static const SvXMLTokenMapEntry aColAttrTokenMap[] =
      61             : {
      62             :     { XML_NAMESPACE_STYLE,  XML_REL_WIDTH,      XML_TOK_COLUMN_WIDTH },
      63             :     { XML_NAMESPACE_FO,     XML_START_INDENT,   XML_TOK_COLUMN_MARGIN_LEFT },
      64             :     { XML_NAMESPACE_FO,     XML_END_INDENT,     XML_TOK_COLUMN_MARGIN_RIGHT },
      65             :     XML_TOKEN_MAP_END
      66             : };
      67             : 
      68             : static const SvXMLTokenMapEntry aColSepAttrTokenMap[] =
      69             : {
      70             :     { XML_NAMESPACE_STYLE,  XML_WIDTH,          XML_TOK_COLUMN_SEP_WIDTH },
      71             :     { XML_NAMESPACE_STYLE,  XML_COLOR,          XML_TOK_COLUMN_SEP_COLOR },
      72             :     { XML_NAMESPACE_STYLE,  XML_HEIGHT,         XML_TOK_COLUMN_SEP_HEIGHT },
      73             :     { XML_NAMESPACE_STYLE,  XML_VERTICAL_ALIGN, XML_TOK_COLUMN_SEP_ALIGN },
      74             :     { XML_NAMESPACE_STYLE,  XML_STYLE,          XML_TOK_COLUMN_SEP_STYLE },
      75             :     XML_TOKEN_MAP_END
      76             : };
      77             : 
      78             : static SvXMLEnumMapEntry const pXML_Sep_Style_Enum[] =
      79             : {
      80             :     { XML_NONE,          0 },
      81             :     { XML_SOLID,         1 },
      82             :     { XML_DOTTED,        2 },
      83             :     { XML_DASHED,        3 },
      84             :     { XML_TOKEN_INVALID, 0 }
      85             : };
      86             : 
      87             : static SvXMLEnumMapEntry const pXML_Sep_Align_Enum[] =
      88             : {
      89             :     { XML_TOP,          VerticalAlignment_TOP   },
      90             :     { XML_MIDDLE,       VerticalAlignment_MIDDLE },
      91             :     { XML_BOTTOM,       VerticalAlignment_BOTTOM },
      92             :     { XML_TOKEN_INVALID, 0 }
      93             : };
      94             : 
      95             : class XMLTextColumnContext_Impl: public SvXMLImportContext
      96             : {
      97             :     text::TextColumn aColumn;
      98             : 
      99             : public:
     100             :     TYPEINFO_OVERRIDE();
     101             : 
     102             :     XMLTextColumnContext_Impl( SvXMLImport& rImport, sal_uInt16 nPrfx,
     103             :                                const OUString& rLName,
     104             :                                const uno::Reference<
     105             :                                        xml::sax::XAttributeList > & xAttrList,
     106             :                                const SvXMLTokenMap& rTokenMap );
     107             : 
     108             :     virtual ~XMLTextColumnContext_Impl();
     109             : 
     110          76 :     text::TextColumn& getTextColumn() { return aColumn; }
     111             : };
     112             : 
     113           0 : TYPEINIT1( XMLTextColumnContext_Impl, SvXMLImportContext );
     114             : 
     115          76 : XMLTextColumnContext_Impl::XMLTextColumnContext_Impl(
     116             :                                SvXMLImport& rImport, sal_uInt16 nPrfx,
     117             :                                const OUString& rLName,
     118             :                                const uno::Reference<
     119             :                                        xml::sax::XAttributeList > & xAttrList,
     120             :                                const SvXMLTokenMap& rTokenMap ) :
     121          76 :     SvXMLImportContext( rImport, nPrfx, rLName )
     122             : {
     123          76 :     aColumn.Width = 0;
     124          76 :     aColumn.LeftMargin = 0;
     125          76 :     aColumn.RightMargin = 0;
     126             : 
     127          76 :     sal_Int16 nAttrCount = xAttrList.is() ? xAttrList->getLength() : 0;
     128         304 :     for( sal_Int16 i=0; i < nAttrCount; i++ )
     129             :     {
     130         228 :         const OUString& rAttrName = xAttrList->getNameByIndex( i );
     131         456 :         OUString aLocalName;
     132             :         sal_uInt16 nPrefix =
     133         228 :             GetImport().GetNamespaceMap().GetKeyByAttrName( rAttrName,
     134         228 :                                                             &aLocalName );
     135         456 :         const OUString& rValue = xAttrList->getValueByIndex( i );
     136             : 
     137             :         sal_Int32 nVal;
     138         228 :         switch( rTokenMap.Get( nPrefix, aLocalName ) )
     139             :         {
     140             :         case XML_TOK_COLUMN_WIDTH:
     141             :             {
     142          76 :                 sal_Int32 nPos = rValue.indexOf( (sal_Unicode)'*' );
     143          76 :                 if( nPos != -1 && nPos+1 == rValue.getLength() )
     144             :                 {
     145          76 :                     OUString sTmp( rValue.copy( 0, nPos ) );
     146          76 :                     if (::sax::Converter::convertNumber(
     147             :                                 nVal, sTmp, 0, USHRT_MAX))
     148          76 :                     aColumn.Width = nVal;
     149             :                 }
     150             :             }
     151          76 :             break;
     152             :         case XML_TOK_COLUMN_MARGIN_LEFT:
     153          76 :             if( GetImport().GetMM100UnitConverter().
     154             :                                 convertMeasureToCore( nVal, rValue ) )
     155          76 :                 aColumn.LeftMargin = nVal;
     156          76 :             break;
     157             :         case XML_TOK_COLUMN_MARGIN_RIGHT:
     158             : 
     159          76 :             if( GetImport().GetMM100UnitConverter().
     160             :                                 convertMeasureToCore( nVal, rValue ) )
     161          76 :                 aColumn.RightMargin = nVal;
     162          76 :             break;
     163             :         default:
     164           0 :             break;
     165             :         }
     166         228 :     }
     167          76 : }
     168             : 
     169         152 : XMLTextColumnContext_Impl::~XMLTextColumnContext_Impl()
     170             : {
     171         152 : }
     172             : 
     173             : class XMLTextColumnSepContext_Impl: public SvXMLImportContext
     174             : {
     175             :     sal_Int32 nWidth;
     176             :     sal_Int32 nColor;
     177             :     sal_Int8 nHeight;
     178             :     sal_Int8 nStyle;
     179             :     VerticalAlignment eVertAlign;
     180             : 
     181             : public:
     182             :     TYPEINFO_OVERRIDE();
     183             : 
     184             :     XMLTextColumnSepContext_Impl( SvXMLImport& rImport, sal_uInt16 nPrfx,
     185             :                                const OUString& rLName,
     186             :                                const uno::Reference<
     187             :                                        xml::sax::XAttributeList > & xAttrList,
     188             :                                const SvXMLTokenMap& rTokenMap );
     189             : 
     190             :     virtual ~XMLTextColumnSepContext_Impl();
     191             : 
     192           0 :     sal_Int32 GetWidth() const { return nWidth; }
     193           0 :     sal_Int32 GetColor() const { return  nColor; }
     194           0 :     sal_Int8 GetHeight() const { return nHeight; }
     195           0 :     sal_Int8 GetStyle() const { return nStyle; }
     196           0 :     VerticalAlignment GetVertAlign() const { return eVertAlign; }
     197             : };
     198             : 
     199           0 : TYPEINIT1( XMLTextColumnSepContext_Impl, SvXMLImportContext );
     200             : 
     201           0 : XMLTextColumnSepContext_Impl::XMLTextColumnSepContext_Impl(
     202             :                                SvXMLImport& rImport, sal_uInt16 nPrfx,
     203             :                                const OUString& rLName,
     204             :                                const uno::Reference<
     205             :                                        xml::sax::XAttributeList > & xAttrList,
     206             :                                const SvXMLTokenMap& rTokenMap ) :
     207             :     SvXMLImportContext( rImport, nPrfx, rLName ),
     208             :     nWidth( 2 ),
     209             :     nColor( 0 ),
     210             :     nHeight( 100 ),
     211             :     nStyle( 1 ),
     212           0 :     eVertAlign( VerticalAlignment_TOP )
     213             : {
     214           0 :     sal_Int16 nAttrCount = xAttrList.is() ? xAttrList->getLength() : 0;
     215           0 :     for( sal_Int16 i=0; i < nAttrCount; i++ )
     216             :     {
     217           0 :         const OUString& rAttrName = xAttrList->getNameByIndex( i );
     218           0 :         OUString aLocalName;
     219             :         sal_uInt16 nPrefix =
     220           0 :             GetImport().GetNamespaceMap().GetKeyByAttrName( rAttrName,
     221           0 :                                                             &aLocalName );
     222           0 :         const OUString& rValue = xAttrList->getValueByIndex( i );
     223             : 
     224             :         sal_Int32 nVal;
     225           0 :         switch( rTokenMap.Get( nPrefix, aLocalName ) )
     226             :         {
     227             :         case XML_TOK_COLUMN_SEP_WIDTH:
     228           0 :             if( GetImport().GetMM100UnitConverter().
     229             :                                 convertMeasureToCore( nVal, rValue ) )
     230           0 :                 nWidth = nVal;
     231           0 :             break;
     232             :         case XML_TOK_COLUMN_SEP_HEIGHT:
     233           0 :             if (::sax::Converter::convertPercent( nVal, rValue ) &&
     234           0 :                  nVal >=1 && nVal <= 100 )
     235           0 :                 nHeight = (sal_Int8)nVal;
     236           0 :             break;
     237             :         case XML_TOK_COLUMN_SEP_COLOR:
     238             :             {
     239           0 :                 ::sax::Converter::convertColor( nColor, rValue );
     240             :             }
     241           0 :             break;
     242             :         case XML_TOK_COLUMN_SEP_ALIGN:
     243             :             {
     244             :                 sal_uInt16 nAlign;
     245           0 :                 if( SvXMLUnitConverter::convertEnum( nAlign, rValue,
     246             :                                                        pXML_Sep_Align_Enum ) )
     247           0 :                     eVertAlign = (VerticalAlignment)nAlign;
     248             :             }
     249           0 :             break;
     250             :         case XML_TOK_COLUMN_SEP_STYLE:
     251             :             {
     252             :                 sal_uInt16 nStyleVal;
     253           0 :                 if( SvXMLUnitConverter::convertEnum( nStyleVal, rValue,
     254             :                                                        pXML_Sep_Style_Enum ) )
     255           0 :                     nStyle = (sal_Int8)nStyleVal;
     256             :             }
     257           0 :             break;
     258             :         }
     259           0 :     }
     260           0 : }
     261             : 
     262           0 : XMLTextColumnSepContext_Impl::~XMLTextColumnSepContext_Impl()
     263             : {
     264           0 : }
     265             : 
     266           0 : TYPEINIT1( XMLTextColumnsContext, XMLElementPropertyContext );
     267             : 
     268          82 : XMLTextColumnsContext::XMLTextColumnsContext(
     269             :                                 SvXMLImport& rImport, sal_uInt16 nPrfx,
     270             :                                 const OUString& rLName,
     271             :                                 const Reference< xml::sax::XAttributeList >&
     272             :                                     xAttrList,
     273             :                                 const XMLPropertyState& rProp,
     274             :                                  ::std::vector< XMLPropertyState > &rProps )
     275             : :   XMLElementPropertyContext( rImport, nPrfx, rLName, rProp, rProps )
     276             : ,   sSeparatorLineIsOn("SeparatorLineIsOn")
     277             : ,   sSeparatorLineWidth("SeparatorLineWidth")
     278             : ,   sSeparatorLineColor("SeparatorLineColor")
     279             : ,   sSeparatorLineRelativeHeight("SeparatorLineRelativeHeight")
     280             : ,   sSeparatorLineVerticalAlignment("SeparatorLineVerticalAlignment")
     281             : ,   sAutomaticDistance("AutomaticDistance")
     282             : ,   sSeparatorLineStyle("SeparatorLineStyle")
     283             : ,   pColumns( 0 )
     284             : ,   pColumnSep( 0 )
     285          82 : ,   pColumnAttrTokenMap( new SvXMLTokenMap(aColAttrTokenMap) )
     286          82 : ,   pColumnSepAttrTokenMap( new SvXMLTokenMap(aColSepAttrTokenMap) )
     287             : ,   nCount( 0 )
     288             : ,   bAutomatic( false )
     289         246 : ,   nAutomaticDistance( 0 )
     290             : {
     291          82 :     sal_Int16 nAttrCount = xAttrList.is() ? xAttrList->getLength() : 0;
     292             :     sal_Int32 nVal;
     293         228 :     for( sal_Int16 i=0; i < nAttrCount; i++ )
     294             :     {
     295         146 :         const OUString& rAttrName = xAttrList->getNameByIndex( i );
     296         292 :         OUString aLocalName;
     297             :         sal_uInt16 nPrefix =
     298         146 :             GetImport().GetNamespaceMap().GetKeyByAttrName( rAttrName,
     299         146 :                                                             &aLocalName );
     300         292 :         const OUString& rValue = xAttrList->getValueByIndex( i );
     301         146 :         if( XML_NAMESPACE_FO == nPrefix )
     302             :         {
     303         228 :             if( IsXMLToken( aLocalName, XML_COLUMN_COUNT ) &&
     304          82 :                 ::sax::Converter::convertNumber( nVal, rValue, 0, SHRT_MAX ))
     305             :             {
     306          82 :                 nCount = (sal_Int16)nVal;
     307             :             }
     308          64 :             else if( IsXMLToken( aLocalName, XML_COLUMN_GAP ) )
     309             :             {
     310          64 :                 bAutomatic = GetImport().GetMM100UnitConverter().
     311         128 :                     convertMeasureToCore( nAutomaticDistance, rValue );
     312             :             }
     313             :         }
     314         146 :     }
     315          82 : }
     316             : 
     317         246 : XMLTextColumnsContext::~XMLTextColumnsContext()
     318             : {
     319          82 :     if( pColumns )
     320             :     {
     321         324 :         for (XMLTextColumnsArray_Impl::iterator it = pColumns->begin();
     322         216 :                 it != pColumns->end(); ++it)
     323             :         {
     324          76 :            (*it)->ReleaseRef();
     325             :         }
     326             :     }
     327          82 :     if( pColumnSep )
     328           0 :         pColumnSep->ReleaseRef();
     329             : 
     330          82 :     delete pColumns;
     331          82 :     delete pColumnAttrTokenMap;
     332          82 :     delete pColumnSepAttrTokenMap;
     333         164 : }
     334             : 
     335          76 : SvXMLImportContext *XMLTextColumnsContext::CreateChildContext(
     336             :     sal_uInt16 nPrefix,
     337             :     const OUString& rLocalName,
     338             :     const uno::Reference< xml::sax::XAttributeList > & xAttrList )
     339             : {
     340          76 :     SvXMLImportContext *pContext = 0;
     341             : 
     342         152 :     if( XML_NAMESPACE_STYLE == nPrefix &&
     343          76 :         IsXMLToken( rLocalName, XML_COLUMN ) )
     344             :     {
     345             :         XMLTextColumnContext_Impl *pColumn =
     346          76 :             new XMLTextColumnContext_Impl( GetImport(), nPrefix, rLocalName,
     347          76 :                                            xAttrList, *pColumnAttrTokenMap );
     348             : 
     349             :         // add new tabstop to array of tabstops
     350          76 :         if( !pColumns )
     351          32 :             pColumns = new XMLTextColumnsArray_Impl;
     352             : 
     353          76 :         pColumns->push_back( pColumn );
     354          76 :         pColumn->AddFirstRef();
     355             : 
     356          76 :         pContext = pColumn;
     357             :     }
     358           0 :     else if( XML_NAMESPACE_STYLE == nPrefix &&
     359           0 :              IsXMLToken( rLocalName, XML_COLUMN_SEP ) )
     360             :     {
     361             :         pColumnSep =
     362           0 :             new XMLTextColumnSepContext_Impl( GetImport(), nPrefix, rLocalName,
     363           0 :                                            xAttrList, *pColumnSepAttrTokenMap );
     364           0 :         pColumnSep->AddFirstRef();
     365             : 
     366           0 :         pContext = pColumnSep;
     367             :     }
     368             :     else
     369             :     {
     370           0 :         pContext = new SvXMLImportContext( GetImport(), nPrefix, rLocalName );
     371             :     }
     372             : 
     373          76 :     return pContext;
     374             : }
     375             : 
     376          82 : void XMLTextColumnsContext::EndElement( )
     377             : {
     378          82 :     Reference<XMultiServiceFactory> xFactory(GetImport().GetModel(),UNO_QUERY);
     379          82 :     if( !xFactory.is() )
     380           0 :         return;
     381             : 
     382         164 :     Reference<XInterface> xIfc = xFactory->createInstance("com.sun.star.text.TextColumns");
     383          82 :     if( !xIfc.is() )
     384           0 :         return;
     385             : 
     386         164 :     Reference< XTextColumns > xColumns( xIfc, UNO_QUERY );
     387          82 :     if ( 0 == nCount )
     388             :     {
     389             :         // zero columns = no columns -> 1 column
     390           0 :         xColumns->setColumnCount( 1 );
     391             :     }
     392         100 :     else if( !bAutomatic && pColumns &&
     393          18 :              pColumns->size() == (sal_uInt16)nCount )
     394             :     {
     395             :         // if we have column descriptions, one per column, and we don't use
     396             :         // automatic width, then set the column widths
     397             : 
     398          18 :         sal_Int32 nRelWidth = 0;
     399          18 :         sal_uInt16 nColumnsWithWidth = 0;
     400             :         sal_Int16 i;
     401             : 
     402          56 :         for( i = 0; i < nCount; i++ )
     403             :         {
     404             :             const TextColumn& rColumn =
     405          38 :                 (*pColumns)[(sal_uInt16)i]->getTextColumn();
     406          38 :             if( rColumn.Width > 0 )
     407             :             {
     408          38 :                 nRelWidth += rColumn.Width;
     409          38 :                 nColumnsWithWidth++;
     410             :             }
     411             :         }
     412          18 :         if( nColumnsWithWidth < nCount )
     413             :         {
     414             :             sal_Int32 nColWidth = 0==nRelWidth
     415           0 :                                         ? USHRT_MAX / nCount
     416           0 :                                         : nRelWidth / nColumnsWithWidth;
     417             : 
     418           0 :             for( i=0; i < nCount; i++ )
     419             :             {
     420             :                 TextColumn& rColumn =
     421           0 :                     (*pColumns)[(sal_uInt16)i]->getTextColumn();
     422           0 :                 if( rColumn.Width == 0 )
     423             :                 {
     424           0 :                     rColumn.Width = nColWidth;
     425           0 :                     nRelWidth += rColumn.Width;
     426           0 :                     if( 0 == --nColumnsWithWidth )
     427           0 :                         break;
     428             :                 }
     429             :             }
     430             :         }
     431             : 
     432          18 :         Sequence< TextColumn > aColumns( (sal_Int32)nCount );
     433          18 :         TextColumn *pTextColumns = aColumns.getArray();
     434          56 :         for( i=0; i < nCount; i++ )
     435          38 :             *pTextColumns++ = (*pColumns)[(sal_uInt16)i]->getTextColumn();
     436             : 
     437          18 :         xColumns->setColumns( aColumns );
     438             :     }
     439             :     else
     440             :     {
     441             :         // only set column count (and let the columns be distributed
     442             :         // automatically)
     443             : 
     444          64 :         xColumns->setColumnCount( nCount );
     445             :     }
     446             : 
     447         164 :     Reference < XPropertySet > xPropSet( xColumns, UNO_QUERY );
     448          82 :     if( xPropSet.is() )
     449             :     {
     450          82 :         Any aAny;
     451          82 :         sal_Bool bOn = pColumnSep != 0;
     452             : 
     453          82 :         aAny.setValue( &bOn, ::getBooleanCppuType() );
     454          82 :         xPropSet->setPropertyValue( sSeparatorLineIsOn, aAny );
     455             : 
     456          82 :         if( pColumnSep )
     457             :         {
     458           0 :             if( pColumnSep->GetWidth() )
     459             :             {
     460           0 :                 aAny <<= pColumnSep->GetWidth();
     461           0 :                 xPropSet->setPropertyValue( sSeparatorLineWidth, aAny );
     462             :             }
     463           0 :             if( pColumnSep->GetHeight() )
     464             :             {
     465           0 :                 aAny <<= pColumnSep->GetHeight();
     466           0 :                 xPropSet->setPropertyValue( sSeparatorLineRelativeHeight,
     467           0 :                                             aAny );
     468             :             }
     469           0 :             if ( pColumnSep->GetStyle() )
     470             :             {
     471           0 :                 aAny <<= pColumnSep->GetStyle();
     472           0 :                 xPropSet->setPropertyValue( sSeparatorLineStyle, aAny );
     473             :             }
     474             : 
     475           0 :             aAny <<= pColumnSep->GetColor();
     476           0 :             xPropSet->setPropertyValue( sSeparatorLineColor, aAny );
     477             : 
     478           0 :             aAny <<= pColumnSep->GetVertAlign();
     479           0 :             xPropSet->setPropertyValue( sSeparatorLineVerticalAlignment, aAny );
     480             :         }
     481             : 
     482             :         // handle 'automatic columns': column distance
     483          82 :         if( bAutomatic )
     484             :         {
     485          64 :             aAny <<= nAutomaticDistance;
     486          64 :             xPropSet->setPropertyValue( sAutomaticDistance, aAny );
     487          82 :         }
     488             :     }
     489             : 
     490          82 :     aProp.maValue <<= xColumns;
     491             : 
     492          82 :     SetInsert( true );
     493         164 :     XMLElementPropertyContext::EndElement();
     494             : 
     495             : }
     496             : 
     497             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10