xmloff/source/style/xmlprmap.cxx

   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 <tools/debug.hxx>
  21 #include <xmloff/xmlprhdl.hxx>
  22 #include "xmlbahdl.hxx"
  23 #include <xmloff/xmlprmap.hxx>
  24 #include <xmloff/xmltypes.hxx>
  25 #include <com/sun/star/beans/XPropertySet.hpp>
  26 #include <com/sun/star/beans/XPropertyState.hpp>
  27 #include <com/sun/star/uno/Any.hxx>
  28 #include <xmloff/xmltoken.hxx>
  29
  30
  31 using namespace ::std;
  32
  33 using namespace ::com::sun::star::uno;
  34 using namespace ::com::sun::star::beans;
  35 using ::xmloff::token::GetXMLToken;
  36
  37 XMLPropertySetMapperEntry_Impl::XMLPropertySetMapperEntry_Impl(
  38     const XMLPropertyMapEntry& rMapEntry,
  39     const UniReference< XMLPropertyHandlerFactory >& rFactory ) :
  40     sXMLAttributeName( GetXMLToken(rMapEntry.meXMLName) ),
  41     sAPIPropertyName( OUString(rMapEntry.msApiName, rMapEntry.nApiNameLength,
  42                                RTL_TEXTENCODING_ASCII_US ) ),
  43     nType( rMapEntry.mnType ),
  44     nXMLNameSpace( rMapEntry.mnNameSpace ),
  45     nContextId( rMapEntry.mnContextId ),
  46     nEarliestODFVersionForExport( rMapEntry.mnEarliestODFVersionForExport ),
  47     bImportOnly( rMapEntry.mbImportOnly),
  48     pHdl( rFactory->GetPropertyHandler( rMapEntry.mnType & MID_FLAG_MASK ) )
  49 {
  50 }
  51
  52 XMLPropertySetMapperEntry_Impl::XMLPropertySetMapperEntry_Impl(
  53         const XMLPropertySetMapperEntry_Impl& rEntry ) :
  54     sXMLAttributeName( rEntry.sXMLAttributeName),
  55     sAPIPropertyName( rEntry.sAPIPropertyName),
  56     nType( rEntry.nType),
  57     nXMLNameSpace( rEntry.nXMLNameSpace),
  58     nContextId( rEntry.nContextId),
  59     nEarliestODFVersionForExport( rEntry.nEarliestODFVersionForExport ),
  60     bImportOnly( rEntry.bImportOnly),
  61     pHdl( rEntry.pHdl)
  62 {
  63     DBG_ASSERT( pHdl, "Unknown XML property type handler!" );
  64 }
  65
  66 ///////////////////////////////////////////////////////////////////////////
  67 //
  68 // Ctor
  69 //
  70 XMLPropertySetMapper::XMLPropertySetMapper(
  71         const XMLPropertyMapEntry* pEntries,
  72         const UniReference< XMLPropertyHandlerFactory >& rFactory,
  73         bool bForExport )
  74     :
  75         mbOnlyExportMappings( bForExport)
  76 {
  77     aHdlFactories.push_back( rFactory );
  78     if( pEntries )
  79     {
  80         const XMLPropertyMapEntry* pIter = pEntries;
  81
  82         if (mbOnlyExportMappings)
  83         {
  84             while( pIter->msApiName )
  85             {
  86                 if (!pIter->mbImportOnly)
  87                 {
  88                     XMLPropertySetMapperEntry_Impl aEntry( *pIter, rFactory );
  89                     aMapEntries.push_back( aEntry );
  90                 }
  91                 pIter++;
  92             }
  93         }
  94         else
  95         {
  96             while( pIter->msApiName )
  97             {
  98                 XMLPropertySetMapperEntry_Impl aEntry( *pIter, rFactory );
  99                 aMapEntries.push_back( aEntry );
 100                 pIter++;
 101             }
 102         }
 103     }
 104 }
 105
 106 XMLPropertySetMapper::~XMLPropertySetMapper()
 107 {
 108 }
 109
 110 void XMLPropertySetMapper::AddMapperEntry(
 111     const UniReference < XMLPropertySetMapper >& rMapper )
 112 {
 113     for( vector < UniReference < XMLPropertyHandlerFactory > >::iterator
 114             aFIter = rMapper->aHdlFactories.begin();
 115          aFIter != rMapper->aHdlFactories.end();
 116          ++aFIter )
 117     {
 118         aHdlFactories.push_back( *aFIter );
 119     }
 120
 121     for( vector < XMLPropertySetMapperEntry_Impl >::iterator
 122             aEIter = rMapper->aMapEntries.begin();
 123          aEIter != rMapper->aMapEntries.end();
 124          ++aEIter )
 125     {
 126         if (!mbOnlyExportMappings || !(*aEIter).bImportOnly)
 127             aMapEntries.push_back( *aEIter );
 128     }
 129 }
 130
 131 ///////////////////////////////////////////////////////////////////////////
 132 //
 133 // Export a Property
 134 //
 135 sal_Bool XMLPropertySetMapper::exportXML(
 136         OUString& rStrExpValue,
 137         const XMLPropertyState& rProperty,
 138         const SvXMLUnitConverter& rUnitConverter ) const
 139 {
 140     sal_Bool bRet = sal_False;
 141
 142     const XMLPropertyHandler* pHdl = GetPropertyHandler( rProperty.mnIndex );
 143
 144     DBG_ASSERT( pHdl, "Unknown XML Type!" );
 145     if( pHdl )
 146         bRet = pHdl->exportXML( rStrExpValue, rProperty.maValue,
 147                                 rUnitConverter );
 148
 149     return bRet;
 150 }
 151
 152 ///////////////////////////////////////////////////////////////////////////
 153 //
 154 // Import a Property
 155 //
 156 sal_Bool XMLPropertySetMapper::importXML(
 157         const OUString& rStrImpValue,
 158         XMLPropertyState& rProperty,
 159         const SvXMLUnitConverter& rUnitConverter ) const
 160 {
 161     sal_Bool bRet = sal_False;
 162
 163     const XMLPropertyHandler* pHdl = GetPropertyHandler( rProperty.mnIndex );
 164
 165     if( pHdl )
 166         bRet = pHdl->importXML( rStrImpValue, rProperty.maValue,
 167                                 rUnitConverter );
 168
 169     return bRet;
 170 }
 171
 172 ///////////////////////////////////////////////////////////////////////////
 173 //
 174 // Search for the given name and the namespace in the list and return
 175 // the index of the entry
 176 // If there is no matching entry the method returns -1
 177 //
 178 sal_Int32 XMLPropertySetMapper::GetEntryIndex(
 179         sal_uInt16 nNamespace,
 180         const OUString& rStrName,
 181         sal_uInt32 nPropType,
 182         sal_Int32 nStartAt /* = -1 */ ) const
 183 {
 184     sal_Int32 nEntries = GetEntryCount();
 185     sal_Int32 nIndex= nStartAt == - 1? 0 : nStartAt+1;
 186
 187     if ( nEntries )
 188     {
 189         do
 190         {
 191             const XMLPropertySetMapperEntry_Impl& rEntry = aMapEntries[nIndex];
 192             if( (!nPropType || nPropType == rEntry.GetPropType()) &&
 193                 rEntry.nXMLNameSpace == nNamespace &&
 194                 rStrName == rEntry.sXMLAttributeName )
 195                 return nIndex;
 196             else
 197                 nIndex++;
 198
 199         } while( nIndex<nEntries );
 200     }
 201
 202     return -1;
 203 }
 204
 205
 206 /** searches for an entry that matches the given api name, namespace and local name or -1 if nothing found */
 207 sal_Int32 XMLPropertySetMapper::FindEntryIndex(
 208         const sal_Char* sApiName,
 209         sal_uInt16 nNameSpace,
 210         const OUString& sXMLName ) const
 211 {
 212     sal_Int32 nIndex = 0;
 213     sal_Int32 nEntries = GetEntryCount();
 214
 215     do
 216     {
 217         const XMLPropertySetMapperEntry_Impl& rEntry = aMapEntries[nIndex];
 218         if( rEntry.nXMLNameSpace == nNameSpace &&
 219             rEntry.sXMLAttributeName.equals( sXMLName ) &&
 220             0 == rEntry.sAPIPropertyName.compareToAscii( sApiName ) )
 221             return nIndex;
 222         else
 223             nIndex++;
 224
 225     } while( nIndex < nEntries );
 226
 227     return -1;
 228 }
 229
 230 sal_Int32 XMLPropertySetMapper::FindEntryIndex( const sal_Int16 nContextId ) const
 231 {
 232     const sal_Int32 nEntries = GetEntryCount();
 233
 234     if ( nEntries )
 235     {
 236         sal_Int32 nIndex = 0;
 237         do
 238         {
 239             const XMLPropertySetMapperEntry_Impl& rEntry = aMapEntries[nIndex];
 240             if( rEntry.nContextId == nContextId )
 241                 return nIndex;
 242             else
 243                 nIndex++;
 244
 245         } while( nIndex < nEntries );
 246     }
 247
 248     return -1;
 249 }
 250
 251 void XMLPropertySetMapper::RemoveEntry( sal_Int32 nIndex )
 252 {
 253     const sal_Int32 nEntries = GetEntryCount();
 254     if( nIndex>=nEntries || nIndex<0 )
 255         return;
 256     vector < XMLPropertySetMapperEntry_Impl >::iterator aEIter = aMapEntries.begin();
 257     for( sal_Int32 nN=0; nN<nIndex; nN++ )
 258         ++aEIter;
 259     aMapEntries.erase( aEIter );
 260 }
 261
 262 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */