xmloff/source/style/xmlprmap.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: xmlprmap.cxx,v $
  10  * $Revision: 1.13.74.1 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_xmloff.hxx"
  33 #include <tools/debug.hxx>
  34 #include <xmloff/xmlprhdl.hxx>
  35 #include "xmlbahdl.hxx"
  36 #include <xmloff/xmlprmap.hxx>
  37 #include <xmloff/xmltypes.hxx>
  38 #include <com/sun/star/beans/XPropertySet.hpp>
  39 #include <com/sun/star/beans/XPropertyState.hpp>
  40 #include <com/sun/star/uno/Any.hxx>
  41 #include <xmloff/xmltoken.hxx>
  42
  43
  44 using namespace ::std;
  45 using ::rtl::OUString;
  46 using ::rtl::OUStringBuffer;
  47
  48 using namespace ::com::sun::star::uno;
  49 using namespace ::com::sun::star::beans;
  50 using ::xmloff::token::GetXMLToken;
  51
  52 XMLPropertySetMapperEntry_Impl::XMLPropertySetMapperEntry_Impl(
  53     const XMLPropertyMapEntry& rMapEntry,
  54     const UniReference< XMLPropertyHandlerFactory >& rFactory ) :
  55     sXMLAttributeName( GetXMLToken(rMapEntry.meXMLName) ),
  56     sAPIPropertyName( OUString(rMapEntry.msApiName, rMapEntry.nApiNameLength,
  57                                RTL_TEXTENCODING_ASCII_US ) ),
  58     nXMLNameSpace( rMapEntry.mnNameSpace ),
  59     nType( rMapEntry.mnType ),
  60     nContextId( rMapEntry.mnContextId ),
  61     nEarliestODFVersionForExport( rMapEntry.mnEarliestODFVersionForExport ),
  62     pHdl( rFactory->GetPropertyHandler( rMapEntry.mnType & MID_FLAG_MASK ) )
  63 {
  64 }
  65
  66 XMLPropertySetMapperEntry_Impl::XMLPropertySetMapperEntry_Impl(
  67         const XMLPropertySetMapperEntry_Impl& rEntry ) :
  68     sXMLAttributeName( rEntry.sXMLAttributeName),
  69     sAPIPropertyName( rEntry.sAPIPropertyName),
  70     nXMLNameSpace( rEntry.nXMLNameSpace),
  71     nType( rEntry.nType),
  72     nContextId( rEntry.nContextId),
  73     nEarliestODFVersionForExport( rEntry.nEarliestODFVersionForExport ),
  74     pHdl( rEntry.pHdl)
  75 {
  76     DBG_ASSERT( pHdl, "Unknown XML property type handler!" );
  77 }
  78
  79 ///////////////////////////////////////////////////////////////////////////
  80 //
  81 // Ctor
  82 //
  83 XMLPropertySetMapper::XMLPropertySetMapper(
  84         const XMLPropertyMapEntry* pEntries,
  85         const UniReference< XMLPropertyHandlerFactory >& rFactory )
  86 {
  87     aHdlFactories.push_back( rFactory );
  88     if( pEntries )
  89     {
  90         const XMLPropertyMapEntry* pIter = pEntries;
  91
  92         // count entries
  93         while( pIter->msApiName )
  94         {
  95             XMLPropertySetMapperEntry_Impl aEntry( *pIter, rFactory );
  96             aMapEntries.push_back( aEntry );
  97             pIter++;
  98         }
  99     }
 100 }
 101
 102 XMLPropertySetMapper::~XMLPropertySetMapper()
 103 {
 104 }
 105
 106 void XMLPropertySetMapper::AddMapperEntry(
 107     const UniReference < XMLPropertySetMapper >& rMapper )
 108 {
 109     for( vector < UniReference < XMLPropertyHandlerFactory > >::iterator
 110             aFIter = rMapper->aHdlFactories.begin();
 111          aFIter != rMapper->aHdlFactories.end();
 112          aFIter++ )
 113     {
 114         aHdlFactories.push_back( *aFIter );
 115     }
 116
 117     for( vector < XMLPropertySetMapperEntry_Impl >::iterator
 118             aEIter = rMapper->aMapEntries.begin();
 119          aEIter != rMapper->aMapEntries.end();
 120          aEIter++ )
 121     {
 122         aMapEntries.push_back( *aEIter );
 123     }
 124 }
 125
 126 ///////////////////////////////////////////////////////////////////////////
 127 //
 128 // Export a Property
 129 //
 130 sal_Bool XMLPropertySetMapper::exportXML(
 131         OUString& rStrExpValue,
 132         const XMLPropertyState& rProperty,
 133         const SvXMLUnitConverter& rUnitConverter ) const
 134 {
 135     sal_Bool bRet = sal_False;
 136
 137     const XMLPropertyHandler* pHdl = GetPropertyHandler( rProperty.mnIndex );
 138
 139     DBG_ASSERT( pHdl, "Unknown XML Type!" );
 140     if( pHdl )
 141         bRet = pHdl->exportXML( rStrExpValue, rProperty.maValue,
 142                                 rUnitConverter );
 143
 144     return bRet;
 145 }
 146
 147 ///////////////////////////////////////////////////////////////////////////
 148 //
 149 // Import a Property
 150 //
 151 sal_Bool XMLPropertySetMapper::importXML(
 152         const OUString& rStrImpValue,
 153         XMLPropertyState& rProperty,
 154         const SvXMLUnitConverter& rUnitConverter ) const
 155 {
 156     sal_Bool bRet = sal_False;
 157
 158     const XMLPropertyHandler* pHdl = GetPropertyHandler( rProperty.mnIndex );
 159
 160     if( pHdl )
 161         bRet = pHdl->importXML( rStrImpValue, rProperty.maValue,
 162                                 rUnitConverter );
 163
 164     return bRet;
 165 }
 166
 167 ///////////////////////////////////////////////////////////////////////////
 168 //
 169 // Search for the given name and the namespace in the list and return
 170 // the index of the entry
 171 // If there is no matching entry the method returns -1
 172 //
 173 sal_Int32 XMLPropertySetMapper::GetEntryIndex(
 174         sal_uInt16 nNamespace,
 175         const OUString& rStrName,
 176         sal_uInt32 nPropType,
 177         sal_Int32 nStartAt /* = -1 */ ) const
 178 {
 179     sal_Int32 nEntries = GetEntryCount();
 180     sal_Int32 nIndex= nStartAt == - 1? 0 : nStartAt+1;
 181
 182     if ( nEntries )
 183     {
 184         do
 185         {
 186             const XMLPropertySetMapperEntry_Impl& rEntry = aMapEntries[nIndex];
 187             if( (!nPropType || nPropType == rEntry.GetPropType()) &&
 188                 rEntry.nXMLNameSpace == nNamespace &&
 189                 rStrName == rEntry.sXMLAttributeName )
 190                 return nIndex;
 191             else
 192                 nIndex++;
 193
 194         } while( nIndex<nEntries );
 195     }
 196
 197     return -1;
 198 }
 199
 200
 201 /** searches for an entry that matches the given api name, namespace and local name or -1 if nothing found */
 202 sal_Int32 XMLPropertySetMapper::FindEntryIndex(
 203         const sal_Char* sApiName,
 204         sal_uInt16 nNameSpace,
 205         const OUString& sXMLName ) const
 206 {
 207     sal_Int32 nIndex = 0;
 208     sal_Int32 nEntries = GetEntryCount();
 209
 210     do
 211     {
 212         const XMLPropertySetMapperEntry_Impl& rEntry = aMapEntries[nIndex];
 213         if( rEntry.nXMLNameSpace == nNameSpace &&
 214             rEntry.sXMLAttributeName.equals( sXMLName ) &&
 215             0 == rEntry.sAPIPropertyName.compareToAscii( sApiName ) )
 216             return nIndex;
 217         else
 218             nIndex++;
 219
 220     } while( nIndex < nEntries );
 221
 222     return -1;
 223 }
 224
 225 sal_Int32 XMLPropertySetMapper::FindEntryIndex( const sal_Int16 nContextId ) const
 226 {
 227     sal_Int32 nIndex = 0;
 228     const sal_Int32 nEntries = GetEntryCount();
 229
 230     if ( nEntries )
 231     {
 232         do
 233         {
 234             const XMLPropertySetMapperEntry_Impl& rEntry = aMapEntries[nIndex];
 235             if( rEntry.nContextId == nContextId )
 236                 return nIndex;
 237             else
 238                 nIndex++;
 239
 240         } while( nIndex < nEntries );
 241     }
 242
 243     return -1;
 244 }
 245
 246 void XMLPropertySetMapper::RemoveEntry( sal_Int32 nIndex )
 247 {
 248     const sal_Int32 nEntries = GetEntryCount();
 249     if( nIndex>=nEntries || nIndex<0 )
 250         return;
 251     vector < XMLPropertySetMapperEntry_Impl >::iterator aEIter = aMapEntries.begin();
 252     for( sal_Int32 nN=0; nN<nIndex; nN++ )
 253         aEIter++;
 254     aMapEntries.erase( aEIter );
 255 }