1 /**************************************************************
2 *
3 * Licensed to the Apache Software Foundation (ASF) under one
4 * or more contributor license agreements. See the NOTICE file
5 * distributed with this work for additional information
6 * regarding copyright ownership. The ASF licenses this file
7 * to you under the Apache License, Version 2.0 (the
8 * "License"); you may not use this file except in compliance
9 * with the License. You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing,
14 * software distributed under the License is distributed on an
15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16 * KIND, either express or implied. See the License for the
17 * specific language governing permissions and limitations
18 * under the License.
19 *
20 *************************************************************/
21
22
23 #include "precompiled_reportdesign.hxx"
24
25 #include "xmlExportDocumentHandler.hxx"
26 #include <com/sun/star/sdb/CommandType.hpp>
27 #include <com/sun/star/chart2/data/XDatabaseDataProvider.hpp>
28 #include <com/sun/star/chart/XComplexDescriptionAccess.hpp>
29 #include <com/sun/star/reflection/XProxyFactory.hpp>
30 #include <com/sun/star/sdb/CommandType.hpp>
31 #include <comphelper/sequence.hxx>
32 #include <comphelper/sequenceashashmap.hxx>
33 #include <comphelper/documentconstants.hxx>
34 #include <xmloff/attrlist.hxx>
35 #include <xmloff/xmltoken.hxx>
36 #include <xmloff/xmlement.hxx>
37 #include <xmloff/xmluconv.hxx>
38 #include <unotools/saveopt.hxx>
39 #include <rtl/ustrbuf.hxx>
40 #include <connectivity/dbtools.hxx>
41 #include <rtl/ustrbuf.hxx>
42
43 namespace rptxml
44 {
45 using namespace ::com::sun::star;
46 using namespace ::xmloff::token;
47
lcl_exportPrettyPrinting(const uno::Reference<xml::sax::XDocumentHandler> & _xDelegatee)48 void lcl_exportPrettyPrinting(const uno::Reference< xml::sax::XDocumentHandler >& _xDelegatee)
49 {
50 SvtSaveOptions aSaveOpt;
51 if ( aSaveOpt.IsPrettyPrinting() )
52 {
53 static const ::rtl::OUString s_sWhitespaces(RTL_CONSTASCII_USTRINGPARAM(" "));
54 _xDelegatee->ignorableWhitespace(s_sWhitespaces);
55 }
56 }
57
lcl_createAttribute(const xmloff::token::XMLTokenEnum & _eNamespace,const xmloff::token::XMLTokenEnum & _eAttribute)58 ::rtl::OUString lcl_createAttribute(const xmloff::token::XMLTokenEnum& _eNamespace,const xmloff::token::XMLTokenEnum& _eAttribute)
59 {
60 ::rtl::OUStringBuffer sQName;
61 // ...if it's in our map, make the prefix
62 sQName.append ( xmloff::token::GetXMLToken(_eNamespace) );
63 sQName.append ( sal_Unicode(':') );
64 sQName.append ( xmloff::token::GetXMLToken(_eAttribute) );
65 return sQName.makeStringAndClear();
66 }
67
lcl_correctCellAddress(const::rtl::OUString & _sName,const uno::Reference<xml::sax::XAttributeList> & xAttribs)68 void lcl_correctCellAddress(const ::rtl::OUString & _sName, const uno::Reference< xml::sax::XAttributeList > & xAttribs)
69 {
70 SvXMLAttributeList* pList = SvXMLAttributeList::getImplementation(xAttribs);
71 ::rtl::OUString sCellAddress = pList->getValueByName(_sName);
72 const sal_Int32 nPos = sCellAddress.lastIndexOf('$');
73 if ( nPos != -1 )
74 {
75 sCellAddress = sCellAddress.copy(0,nPos);
76 sCellAddress += ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("$65535"));
77 pList->RemoveAttribute(_sName);
78 pList->AddAttribute(_sName,sCellAddress);
79 }
80 }
81
ExportDocumentHandler(uno::Reference<uno::XComponentContext> const & context)82 ExportDocumentHandler::ExportDocumentHandler(uno::Reference< uno::XComponentContext > const & context) :
83 m_xContext(context)
84 ,m_nCurrentCellIndex(0)
85 ,m_nColumnCount(0)
86 ,m_bTableRowsStarted(false)
87 ,m_bFirstRowExported(false)
88 ,m_bExportChar(false)
89 ,m_bCountColumnHeader(false)
90 {
91 }
92 // -----------------------------------------------------------------------------
~ExportDocumentHandler()93 ExportDocumentHandler::~ExportDocumentHandler()
94 {
95 if ( m_xProxy.is() )
96 {
97 m_xProxy->setDelegator( NULL );
98 m_xProxy.clear();
99 }
100 }
101 IMPLEMENT_GET_IMPLEMENTATION_ID(ExportDocumentHandler)
IMPLEMENT_FORWARD_REFCOUNT(ExportDocumentHandler,ExportDocumentHandler_BASE)102 IMPLEMENT_FORWARD_REFCOUNT( ExportDocumentHandler, ExportDocumentHandler_BASE )
103 //------------------------------------------------------------------------
104 ::rtl::OUString SAL_CALL ExportDocumentHandler::getImplementationName( ) throw(uno::RuntimeException)
105 {
106 return getImplementationName_Static();
107 }
108
109 //------------------------------------------------------------------------
supportsService(const::rtl::OUString & ServiceName)110 sal_Bool SAL_CALL ExportDocumentHandler::supportsService( const ::rtl::OUString& ServiceName ) throw(uno::RuntimeException)
111 {
112 return ::comphelper::existsValue(ServiceName,getSupportedServiceNames_static());
113 }
114
115 //------------------------------------------------------------------------
getSupportedServiceNames()116 uno::Sequence< ::rtl::OUString > SAL_CALL ExportDocumentHandler::getSupportedServiceNames( ) throw(uno::RuntimeException)
117 {
118 uno::Sequence< ::rtl::OUString > aSupported;
119 if ( m_xServiceInfo.is() )
120 aSupported = m_xServiceInfo->getSupportedServiceNames();
121 return ::comphelper::concatSequences(getSupportedServiceNames_static(),aSupported);
122 }
123
124 //------------------------------------------------------------------------
getImplementationName_Static()125 ::rtl::OUString ExportDocumentHandler::getImplementationName_Static( ) throw(uno::RuntimeException)
126 {
127 return ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.comp.report.ExportDocumentHandler"));
128 }
129
130 //------------------------------------------------------------------------
getSupportedServiceNames_static()131 uno::Sequence< ::rtl::OUString > ExportDocumentHandler::getSupportedServiceNames_static( ) throw(uno::RuntimeException)
132 {
133 uno::Sequence< ::rtl::OUString > aSupported(1);
134 aSupported[0] = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.report.ExportDocumentHandler"));
135 return aSupported;
136 }
137
138 //------------------------------------------------------------------------
create(const uno::Reference<uno::XComponentContext> & _rxContext)139 uno::Reference< uno::XInterface > SAL_CALL ExportDocumentHandler::create( const uno::Reference< uno::XComponentContext >& _rxContext )
140 {
141 return *(new ExportDocumentHandler( _rxContext ));
142 }
143 // xml::sax::XDocumentHandler:
startDocument()144 void SAL_CALL ExportDocumentHandler::startDocument() throw (uno::RuntimeException, xml::sax::SAXException)
145 {
146 m_xDelegatee->startDocument();
147 }
148
endDocument()149 void SAL_CALL ExportDocumentHandler::endDocument() throw (uno::RuntimeException, xml::sax::SAXException)
150 {
151 m_xDelegatee->endDocument();
152 }
153
startElement(const::rtl::OUString & _sName,const uno::Reference<xml::sax::XAttributeList> & xAttribs)154 void SAL_CALL ExportDocumentHandler::startElement(const ::rtl::OUString & _sName, const uno::Reference< xml::sax::XAttributeList > & xAttribs) throw (uno::RuntimeException, xml::sax::SAXException)
155 {
156 bool bExport = true;
157 if ( _sName.equalsAscii("office:chart") )
158 {
159 SvXMLAttributeList* pList = new SvXMLAttributeList();
160 uno::Reference< xml::sax::XAttributeList > xNewAttribs = pList;
161 ::rtl::OUStringBuffer sValue;
162 static SvXMLEnumMapEntry aXML_CommnadTypeEnumMap[] =
163 {
164 { XML_TABLE, sdb::CommandType::TABLE },
165 { XML_QUERY, sdb::CommandType::QUERY },
166 // { XML_COMMAND, CommandType::COMMAND }, // default
167 { XML_TOKEN_INVALID, 0 }
168 };
169 if ( SvXMLUnitConverter::convertEnum( sValue, static_cast<sal_uInt16>(m_xDatabaseDataProvider->getCommandType()),aXML_CommnadTypeEnumMap ) )
170 {
171 pList->AddAttribute(lcl_createAttribute(XML_NP_RPT,XML_COMMAND_TYPE),sValue.makeStringAndClear());
172 }
173 const ::rtl::OUString sComamnd = m_xDatabaseDataProvider->getCommand();
174 if ( sComamnd.getLength() )
175 pList->AddAttribute(lcl_createAttribute(XML_NP_RPT,XML_COMMAND),sComamnd);
176
177 const ::rtl::OUString sFilter( m_xDatabaseDataProvider->getFilter() );
178 if ( sFilter.getLength() )
179 pList->AddAttribute(lcl_createAttribute(XML_NP_RPT,XML_FILTER),sFilter);
180
181 const sal_Bool bEscapeProcessing( m_xDatabaseDataProvider->getEscapeProcessing() );
182 if ( !bEscapeProcessing )
183 pList->AddAttribute(lcl_createAttribute(XML_NP_RPT,XML_ESCAPE_PROCESSING),::xmloff::token::GetXMLToken( XML_FALSE ));
184
185 pList->AddAttribute(lcl_createAttribute(XML_NP_OFFICE,XML_MIMETYPE),MIMETYPE_OASIS_OPENDOCUMENT_CHART);
186
187 m_xDelegatee->startElement(lcl_createAttribute(XML_NP_OFFICE,XML_REPORT),xNewAttribs);
188
189 const ::rtl::OUString sTableCalc = lcl_createAttribute(XML_NP_TABLE,XML_CALCULATION_SETTINGS);
190 m_xDelegatee->startElement(sTableCalc,NULL);
191 pList = new SvXMLAttributeList();
192 uno::Reference< xml::sax::XAttributeList > xNullAttr = pList;
193 pList->AddAttribute(lcl_createAttribute(XML_NP_TABLE,XML_DATE_VALUE),::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("1900-01-01")));
194
195 const ::rtl::OUString sNullDate = lcl_createAttribute(XML_NP_TABLE,XML_NULL_DATE);
196 m_xDelegatee->startElement(sNullDate,xNullAttr);
197 m_xDelegatee->endElement(sNullDate);
198 m_xDelegatee->endElement(sTableCalc);
199 bExport = false;
200 }
201 else if ( _sName.equalsAscii("table:table") )
202 {
203 m_xDelegatee->startElement(lcl_createAttribute(XML_NP_RPT,XML_DETAIL),NULL);
204 lcl_exportPrettyPrinting(m_xDelegatee);
205 }
206 else if ( _sName.equalsAscii("table:table-header-rows") )
207 {
208 m_bCountColumnHeader = true;
209 }
210 else if ( m_bCountColumnHeader && _sName.equalsAscii("table:table-cell") )
211 {
212 ++m_nColumnCount;
213 }
214 else if ( _sName.equalsAscii("table:table-rows") )
215 {
216 m_xDelegatee->startElement(_sName,xAttribs);
217 exportTableRows();
218 bExport = false;
219 m_bTableRowsStarted = true;
220 m_bFirstRowExported = true;
221 }
222 else if ( m_bTableRowsStarted && m_bFirstRowExported && (_sName.equalsAscii("table:table-row") || _sName.equalsAscii("table:table-cell")) )
223 bExport = false;
224 else if ( _sName.equalsAscii("chart:plot-area"))
225 {
226 SvXMLAttributeList* pList = SvXMLAttributeList::getImplementation(xAttribs);
227 pList->RemoveAttribute(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("table:cell-range-address")));
228 }
229 else if ( _sName.equalsAscii("chart:categories"))
230 {
231 static ::rtl::OUString s_sCellAddress(lcl_createAttribute(XML_NP_TABLE,XML_CELL_RANGE_ADDRESS));
232 lcl_correctCellAddress(s_sCellAddress,xAttribs);
233 }
234 else if ( _sName.equalsAscii("chart:series"))
235 {
236 static ::rtl::OUString s_sCellAddress(lcl_createAttribute(XML_NP_CHART,XML_VALUES_CELL_RANGE_ADDRESS));
237 lcl_correctCellAddress(s_sCellAddress,xAttribs);
238 }
239 else if ( m_bTableRowsStarted && !m_bFirstRowExported && _sName.equalsAscii("table:table-cell") )
240 {
241 SvXMLAttributeList* pList = SvXMLAttributeList::getImplementation(xAttribs);
242 static ::rtl::OUString s_sValue(lcl_createAttribute(XML_NP_OFFICE,XML_VALUE));
243 pList->RemoveAttribute(s_sValue);
244 }
245 else if ( m_bTableRowsStarted && _sName.equalsAscii("text:p") )
246 {
247 bExport = false;
248 }
249 if ( bExport )
250 m_xDelegatee->startElement(_sName,xAttribs);
251 }
252 // -----------------------------------------------------------------------------
endElement(const::rtl::OUString & _sName)253 void SAL_CALL ExportDocumentHandler::endElement(const ::rtl::OUString & _sName) throw (uno::RuntimeException, xml::sax::SAXException)
254 {
255 bool bExport = true;
256 ::rtl::OUString sNewName = _sName;
257 if ( _sName.equalsAscii("office:chart") )
258 {
259 sNewName = lcl_createAttribute(XML_NP_OFFICE,XML_REPORT);
260 }
261 else if ( _sName.equalsAscii("table:table") )
262 {
263 m_xDelegatee->endElement(_sName);
264 lcl_exportPrettyPrinting(m_xDelegatee);
265 sNewName = lcl_createAttribute(XML_NP_RPT,XML_DETAIL);
266 }
267 else if ( _sName.equalsAscii("table:table-header-rows") )
268 {
269 m_bCountColumnHeader = false;
270 }
271 else if ( _sName.equalsAscii("table:table-rows") )
272 m_bTableRowsStarted = false;
273 else if ( m_bTableRowsStarted && m_bFirstRowExported && (_sName.equalsAscii("table:table-row") || _sName.equalsAscii("table:table-cell")) )
274 bExport = false;
275 else if ( m_bTableRowsStarted && _sName.equalsAscii("table:table-row") )
276 m_bFirstRowExported = true;
277 else if ( m_bTableRowsStarted && _sName.equalsAscii("text:p") )
278 {
279 bExport = !m_bFirstRowExported;
280 }
281
282 if ( bExport )
283 m_xDelegatee->endElement(sNewName);
284 }
285
characters(const::rtl::OUString & aChars)286 void SAL_CALL ExportDocumentHandler::characters(const ::rtl::OUString & aChars) throw (uno::RuntimeException, xml::sax::SAXException)
287 {
288 if ( !(m_bTableRowsStarted || m_bFirstRowExported) )
289 {
290 m_xDelegatee->characters(aChars);
291 }
292 else if ( m_bExportChar )
293 {
294 static const ::rtl::OUString s_sZero(RTL_CONSTASCII_USTRINGPARAM("0"));
295 m_xDelegatee->characters(s_sZero);
296 }
297 }
298
ignorableWhitespace(const::rtl::OUString & aWhitespaces)299 void SAL_CALL ExportDocumentHandler::ignorableWhitespace(const ::rtl::OUString & aWhitespaces) throw (uno::RuntimeException, xml::sax::SAXException)
300 {
301 m_xDelegatee->ignorableWhitespace(aWhitespaces);
302 }
303
processingInstruction(const::rtl::OUString & aTarget,const::rtl::OUString & aData)304 void SAL_CALL ExportDocumentHandler::processingInstruction(const ::rtl::OUString & aTarget, const ::rtl::OUString & aData) throw (uno::RuntimeException, xml::sax::SAXException)
305 {
306 m_xDelegatee->processingInstruction(aTarget,aData);
307 }
308
setDocumentLocator(const uno::Reference<xml::sax::XLocator> & xLocator)309 void SAL_CALL ExportDocumentHandler::setDocumentLocator(const uno::Reference< xml::sax::XLocator > & xLocator) throw (uno::RuntimeException, xml::sax::SAXException)
310 {
311 m_xDelegatee->setDocumentLocator(xLocator);
312 }
initialize(const uno::Sequence<uno::Any> & _aArguments)313 void SAL_CALL ExportDocumentHandler::initialize( const uno::Sequence< uno::Any >& _aArguments ) throw (uno::Exception, uno::RuntimeException)
314 {
315 ::osl::MutexGuard aGuard(m_aMutex);
316 comphelper::SequenceAsHashMap aArgs(_aArguments);
317 m_xDelegatee = aArgs.getUnpackedValueOrDefault(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("DocumentHandler")),m_xDelegatee);
318 m_xModel = aArgs.getUnpackedValueOrDefault(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Model")),m_xModel);
319
320 OSL_ENSURE(m_xDelegatee.is(),"No document handler avialable!");
321 if ( !m_xDelegatee.is() || !m_xModel.is() )
322 throw uno::Exception();
323
324 m_xDatabaseDataProvider.set(m_xModel->getDataProvider(),uno::UNO_QUERY);
325 if ( !m_xDatabaseDataProvider.is() || !m_xDatabaseDataProvider->getActiveConnection().is() )
326 throw uno::Exception();
327
328 uno::Reference< reflection::XProxyFactory > xProxyFactory( m_xContext->getServiceManager()->createInstanceWithContext(
329 ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.reflection.ProxyFactory")),m_xContext),
330 uno::UNO_QUERY);
331 m_xProxy = xProxyFactory->createProxy(m_xDelegatee.get());
332 ::comphelper::query_aggregation(m_xProxy,m_xDelegatee);
333 m_xTypeProvider.set(m_xDelegatee,uno::UNO_QUERY);
334 m_xServiceInfo.set(m_xDelegatee,uno::UNO_QUERY);
335
336 // set ourself as delegator
337 m_xProxy->setDelegator( *this );
338 const ::rtl::OUString sCommand = m_xDatabaseDataProvider->getCommand();
339 if ( sCommand.getLength() )
340 m_aColumns = ::dbtools::getFieldNamesByCommandDescriptor(m_xDatabaseDataProvider->getActiveConnection()
341 ,m_xDatabaseDataProvider->getCommandType()
342 ,sCommand);
343
344 uno::Reference< chart::XComplexDescriptionAccess > xDataProvider(m_xDatabaseDataProvider,uno::UNO_QUERY);
345 if ( xDataProvider.is() )
346 {
347 m_aColumns.realloc(1);
348 uno::Sequence< ::rtl::OUString > aColumnNames = xDataProvider->getColumnDescriptions();
349 for(sal_Int32 i = 0 ; i < aColumnNames.getLength();++i)
350 {
351 if ( aColumnNames[i].getLength() )
352 {
353 sal_Int32 nCount = m_aColumns.getLength();
354 m_aColumns.realloc(nCount+1);
355 m_aColumns[nCount] = aColumnNames[i];
356 }
357 }
358 }
359 }
360 // --------------------------------------------------------------------------------
queryInterface(const uno::Type & _rType)361 uno::Any SAL_CALL ExportDocumentHandler::queryInterface( const uno::Type& _rType ) throw (uno::RuntimeException)
362 {
363 uno::Any aReturn = ExportDocumentHandler_BASE::queryInterface(_rType);
364 return aReturn.hasValue() ? aReturn : (m_xProxy.is() ? m_xProxy->queryAggregation(_rType) : aReturn);
365 }
366 // --------------------------------------------------------------------------------
getTypes()367 uno::Sequence< uno::Type > SAL_CALL ExportDocumentHandler::getTypes( ) throw (uno::RuntimeException)
368 {
369 if ( m_xTypeProvider.is() )
370 return ::comphelper::concatSequences(
371 ExportDocumentHandler_BASE::getTypes(),
372 m_xTypeProvider->getTypes()
373 );
374 return ExportDocumentHandler_BASE::getTypes();
375 }
376 // -----------------------------------------------------------------------------
exportTableRows()377 void ExportDocumentHandler::exportTableRows()
378 {
379 const ::rtl::OUString sRow( lcl_createAttribute(XML_NP_TABLE, XML_TABLE_ROW) );
380 m_xDelegatee->startElement(sRow,NULL);
381
382 const ::rtl::OUString sValueType( lcl_createAttribute(XML_NP_OFFICE, XML_VALUE_TYPE) );
383
384 const static ::rtl::OUString s_sFieldPrefix(RTL_CONSTASCII_USTRINGPARAM("field:["));
385 const static ::rtl::OUString s_sFieldPostfix(RTL_CONSTASCII_USTRINGPARAM("]"));
386 const ::rtl::OUString sCell( lcl_createAttribute(XML_NP_TABLE, XML_TABLE_CELL) );
387 const ::rtl::OUString sP( lcl_createAttribute(XML_NP_TEXT, XML_P) );
388 const ::rtl::OUString sFtext(lcl_createAttribute(XML_NP_RPT,XML_FORMATTED_TEXT) );
389 const ::rtl::OUString sRElement(lcl_createAttribute(XML_NP_RPT,XML_REPORT_ELEMENT) );
390 const ::rtl::OUString sRComponent( lcl_createAttribute(XML_NP_RPT,XML_REPORT_COMPONENT) ) ;
391 const ::rtl::OUString sFormulaAttrib( lcl_createAttribute(XML_NP_RPT,XML_FORMULA) );
392 const static ::rtl::OUString s_sString(RTL_CONSTASCII_USTRINGPARAM("string"));
393 const static ::rtl::OUString s_sFloat(RTL_CONSTASCII_USTRINGPARAM("float"));
394
395 SvXMLAttributeList* pCellAtt = new SvXMLAttributeList();
396 uno::Reference< xml::sax::XAttributeList > xCellAtt = pCellAtt;
397 pCellAtt->AddAttribute(sValueType,s_sString);
398
399 bool bRemoveString = true;
400 ::rtl::OUString sFormula;
401 const sal_Int32 nCount = m_aColumns.getLength();
402 if ( m_nColumnCount > nCount )
403 {
404 const sal_Int32 nEmptyCellCount = m_nColumnCount - nCount;
405 for(sal_Int32 i = 0; i < nEmptyCellCount ; ++i)
406 {
407 m_xDelegatee->startElement(sCell,xCellAtt);
408 if ( bRemoveString )
409 {
410 bRemoveString = false;
411 pCellAtt->RemoveAttribute(sValueType);
412 pCellAtt->AddAttribute(sValueType,s_sFloat);
413 } // if ( i == 0 )
414 m_xDelegatee->startElement(sP,NULL);
415 m_xDelegatee->endElement(sP);
416 m_xDelegatee->endElement(sCell);
417 }
418 }
419 for(sal_Int32 i = 0; i < nCount ; ++i)
420 {
421 sFormula = s_sFieldPrefix;
422 sFormula += m_aColumns[i];
423 sFormula += s_sFieldPostfix;
424 SvXMLAttributeList* pList = new SvXMLAttributeList();
425 uno::Reference< xml::sax::XAttributeList > xAttribs = pList;
426 pList->AddAttribute(sFormulaAttrib,sFormula);
427
428 m_xDelegatee->startElement(sCell,xCellAtt);
429 if ( bRemoveString )
430 {
431 bRemoveString = false;
432 pCellAtt->RemoveAttribute(sValueType);
433 pCellAtt->AddAttribute(sValueType,s_sFloat);
434 }
435 m_xDelegatee->startElement(sP,NULL);
436 m_xDelegatee->startElement(sFtext,xAttribs);
437 m_xDelegatee->startElement(sRElement,NULL);
438 m_xDelegatee->startElement(sRComponent,NULL);
439
440 m_xDelegatee->endElement(sRComponent);
441 m_xDelegatee->endElement(sRElement);
442 m_xDelegatee->endElement(sFtext);
443 m_xDelegatee->endElement(sP);
444 m_xDelegatee->endElement(sCell);
445 } // for(sal_Int32 i = 0; i < nCount ; ++i)
446
447 m_xDelegatee->endElement(sRow);
448 }
449 // -----------------------------------------------------------------------------
450 } // namespace rptxml
451 // -----------------------------------------------------------------------------
452