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 :
21 : #include <com/sun/star/style/XStyleFamiliesSupplier.hpp>
22 : #include <com/sun/star/table/XTableRows.hpp>
23 : #include <com/sun/star/table/XMergeableCell.hpp>
24 : #include <com/sun/star/table/XMergeableCellRange.hpp>
25 : #include <com/sun/star/table/XTable.hpp>
26 : #include <com/sun/star/text/XText.hpp>
27 : #include <com/sun/star/container/XNameContainer.hpp>
28 : #include <com/sun/star/lang/XSingleServiceFactory.hpp>
29 :
30 : #include "xmloff/table/XMLTableImport.hxx"
31 : #include "xmloff/xmltkmap.hxx"
32 : #include "xmloff/maptype.hxx"
33 : #include "xmloff/xmlprmap.hxx"
34 : #include "xmloff/txtimp.hxx"
35 : #include "xmloff/xmlimp.hxx"
36 : #include "xmloff/nmspmap.hxx"
37 : #include "xmloff/xmlstyle.hxx"
38 : #include "xmloff/prstylei.hxx"
39 :
40 : #include "xmloff/xmlnmspe.hxx"
41 : #include "table.hxx"
42 :
43 : #include <boost/shared_ptr.hpp>
44 :
45 : // --------------------------------------------------------------------
46 :
47 : using ::rtl::OUString;
48 : using namespace ::xmloff::token;
49 : using namespace ::com::sun::star::beans;
50 : using namespace ::com::sun::star::uno;
51 : using namespace ::com::sun::star::table;
52 : using namespace ::com::sun::star::xml::sax;
53 : using namespace ::com::sun::star::text;
54 : using namespace ::com::sun::star::style;
55 : using namespace ::com::sun::star::lang;
56 : using namespace ::com::sun::star::container;
57 :
58 : // --------------------------------------------------------------------
59 :
60 16 : struct ColumnInfo
61 : {
62 : OUString msStyleName;
63 : sal_Bool mbVisibility;
64 : OUString msDefaultCellStyleName;
65 : };
66 :
67 : // --------------------------------------------------------------------
68 :
69 20 : class XMLProxyContext : public SvXMLImportContext
70 : {
71 : public:
72 : XMLProxyContext( SvXMLImport& rImport, const SvXMLImportContextRef& xParent, sal_uInt16 nPrfx, const OUString& rLName );
73 :
74 : virtual SvXMLImportContext *CreateChildContext( sal_uInt16 nPrefix, const OUString& rLocalName, const Reference< XAttributeList >& xAttrList );
75 :
76 : private:
77 : SvXMLImportContextRef mxParent;
78 : };
79 :
80 : // --------------------------------------------------------------------
81 :
82 : struct MergeInfo
83 : {
84 : sal_Int32 mnStartColumn;
85 : sal_Int32 mnStartRow;
86 : sal_Int32 mnEndColumn;
87 : sal_Int32 mnEndRow;
88 :
89 0 : MergeInfo( sal_Int32 nStartColumn, sal_Int32 nStartRow, sal_Int32 nColumnSpan, sal_Int32 nRowSpan )
90 0 : : mnStartColumn( nStartColumn ), mnStartRow( nStartRow ), mnEndColumn( nStartColumn + nColumnSpan - 1 ), mnEndRow( nStartRow + nRowSpan - 1 ) {};
91 : };
92 :
93 : typedef std::vector< boost::shared_ptr< MergeInfo > > MergeInfoVector;
94 :
95 : // --------------------------------------------------------------------
96 :
97 : class XMLTableImportContext : public SvXMLImportContext
98 : {
99 : public:
100 : XMLTableImportContext( const rtl::Reference< XMLTableImport >& xThis, sal_uInt16 nPrfx, const OUString& rLName, Reference< XColumnRowRange >& xColumnRowRange );
101 : virtual ~XMLTableImportContext();
102 :
103 : virtual SvXMLImportContext *CreateChildContext( sal_uInt16 nPrefix, const OUString& rLocalName, const Reference< XAttributeList >& xAttrList );
104 :
105 : virtual void StartElement( const Reference< XAttributeList >& xAttrList );
106 :
107 : virtual void EndElement();
108 :
109 : void InitColumns();
110 :
111 : SvXMLImportContext * ImportColumn( sal_uInt16 nPrefix, const OUString& rLocalName, const Reference< XAttributeList >& xAttrList );
112 : SvXMLImportContext * ImportRow( sal_uInt16 nPrefix, const OUString& rLocalName, const Reference< XAttributeList >& xAttrList );
113 : SvXMLImportContext * ImportCell( sal_uInt16 nPrefix, const OUString& rLocalName, const Reference< XAttributeList >& xAttrList );
114 :
115 : OUString GetDefaultCellStyleName() const;
116 :
117 : rtl::Reference< XMLTableImport > mxTableImporter;
118 : ::com::sun::star::uno::Reference< ::com::sun::star::table::XTable > mxTable;
119 : Reference< XTableColumns > mxColumns;
120 : Reference< XTableRows > mxRows;
121 :
122 : std::vector< boost::shared_ptr< ColumnInfo > > maColumnInfos;
123 : sal_Int32 mnCurrentRow;
124 : sal_Int32 mnCurrentColumn;
125 :
126 : // default cell style name for the current row
127 : OUString msDefaultCellStyleName;
128 :
129 : MergeInfoVector maMergeInfos;
130 : };
131 :
132 : // --------------------------------------------------------------------
133 :
134 : class XMLCellImportContext : public SvXMLImportContext
135 : {
136 : public:
137 : XMLCellImportContext( SvXMLImport& rImport,
138 : const Reference< XMergeableCell >& xCell,
139 : const OUString& sDefaultCellStyleName,
140 : sal_uInt16 nPrfx, const OUString& rLName,
141 : const ::com::sun::star::uno::Reference< ::com::sun::star::xml::sax::XAttributeList >& xAttrList );
142 :
143 : virtual ~XMLCellImportContext();
144 :
145 : virtual SvXMLImportContext *CreateChildContext( sal_uInt16 nPrefix, const OUString& rLocalName, const Reference< XAttributeList >& xAttrList );
146 :
147 : virtual void EndElement();
148 :
149 16 : sal_Int32 getColumnSpan() const { return mnColSpan; }
150 16 : sal_Int32 getRowSpan() const { return mnRowSpan; }
151 16 : sal_Int32 getRepeated() const { return mnRepeated; }
152 :
153 : Reference< XMergeableCell > mxCell;
154 : Reference< XTextCursor > mxCursor;
155 : Reference< XTextCursor > mxOldCursor;
156 : bool mbListContextPushed;
157 :
158 : sal_Int32 mnColSpan, mnRowSpan, mnRepeated;
159 : };
160 :
161 : // --------------------------------------------------------------------
162 :
163 2 : class XMLTableTemplateContext : public SvXMLStyleContext
164 : {
165 : public:
166 : XMLTableTemplateContext( SvXMLImport& rImport, sal_uInt16 nPrfx, const OUString& rLName, const Reference< XAttributeList >& xAttrList );
167 :
168 : virtual SvXMLImportContext *CreateChildContext( sal_uInt16 nPrefix, const OUString& rLocalName, const Reference< XAttributeList >& xAttrList );
169 :
170 : virtual void StartElement( const Reference< XAttributeList >& xAttrList );
171 :
172 : virtual void EndElement();
173 :
174 : private:
175 : XMLTableTemplate maTableTemplate;
176 : OUString msTemplateStyleName;
177 : };
178 :
179 : // --------------------------------------------------------------------
180 : // class XMLProxyContext
181 : // --------------------------------------------------------------------
182 :
183 10 : XMLProxyContext::XMLProxyContext( SvXMLImport& rImport, const SvXMLImportContextRef& xParent, sal_uInt16 nPrfx, const OUString& rLName )
184 : : SvXMLImportContext( rImport, nPrfx, rLName )
185 10 : , mxParent( xParent )
186 : {
187 10 : }
188 :
189 : // --------------------------------------------------------------------
190 :
191 16 : SvXMLImportContext * XMLProxyContext::CreateChildContext( sal_uInt16 nPrefix, const OUString& rLocalName, const Reference< XAttributeList >& xAttrList )
192 : {
193 16 : if( mxParent.Is() )
194 16 : return mxParent->CreateChildContext( nPrefix, rLocalName, xAttrList );
195 : else
196 0 : return SvXMLImportContext::CreateChildContext( nPrefix, rLocalName, xAttrList );
197 : }
198 :
199 : // --------------------------------------------------------------------
200 : // class XMLTableImport
201 : // --------------------------------------------------------------------
202 :
203 3 : XMLTableImport::XMLTableImport( SvXMLImport& rImport, const rtl::Reference< XMLPropertySetMapper >& xCellPropertySetMapper, const rtl::Reference< XMLPropertyHandlerFactory >& xFactoryRef )
204 3 : : mrImport( rImport )
205 : {
206 3 : mxCellImportPropertySetMapper = new SvXMLImportPropertyMapper( xCellPropertySetMapper.get(), rImport );
207 3 : mxCellImportPropertySetMapper->ChainImportMapper(XMLTextImportHelper::CreateParaExtPropMapper(rImport));
208 :
209 :
210 3 : UniReference < XMLPropertySetMapper > xRowMapper( new XMLPropertySetMapper( getRowPropertiesMap(), xFactoryRef.get() ) );
211 3 : mxRowImportPropertySetMapper = new SvXMLImportPropertyMapper( xRowMapper, rImport );
212 :
213 3 : UniReference < XMLPropertySetMapper > xColMapper( new XMLPropertySetMapper( getColumnPropertiesMap(), xFactoryRef.get() ) );
214 3 : mxColumnImportPropertySetMapper = new SvXMLImportPropertyMapper( xColMapper, rImport );
215 3 : }
216 :
217 : // --------------------------------------------------------------------
218 :
219 6 : XMLTableImport::~XMLTableImport()
220 : {
221 6 : }
222 :
223 : // --------------------------------------------------------------------
224 :
225 2 : SvXMLImportContext* XMLTableImport::CreateTableContext( sal_uInt16 nPrfx, const OUString& rLName, Reference< XColumnRowRange >& xColumnRowRange )
226 : {
227 2 : rtl::Reference< XMLTableImport > xThis( this );
228 2 : return new XMLTableImportContext( xThis, nPrfx, rLName, xColumnRowRange );
229 : }
230 :
231 : // --------------------------------------------------------------------
232 :
233 1 : SvXMLStyleContext* XMLTableImport::CreateTableTemplateContext( sal_uInt16 nPrfx, const OUString& rLName, const Reference< XAttributeList >& xAttrList )
234 : {
235 1 : return new XMLTableTemplateContext( mrImport, nPrfx, rLName, xAttrList );
236 : }
237 :
238 : // --------------------------------------------------------------------
239 :
240 1 : void XMLTableImport::addTableTemplate( const rtl::OUString& rsStyleName, XMLTableTemplate& xTableTemplate )
241 : {
242 1 : boost::shared_ptr< XMLTableTemplate > xPtr( new XMLTableTemplate );
243 1 : xPtr->swap( xTableTemplate );
244 1 : maTableTemplates[rsStyleName] = xPtr;
245 1 : }
246 :
247 : // --------------------------------------------------------------------
248 :
249 2 : void XMLTableImport::finishStyles()
250 : {
251 2 : if( !maTableTemplates.empty() ) try
252 : {
253 1 : Reference< XStyleFamiliesSupplier > xFamiliesSupp( mrImport.GetModel(), UNO_QUERY_THROW );
254 1 : Reference< XNameAccess > xFamilies( xFamiliesSupp->getStyleFamilies() );
255 1 : const OUString sFamilyName( RTL_CONSTASCII_USTRINGPARAM("table" ) );
256 1 : const OUString sCellFamilyName( RTL_CONSTASCII_USTRINGPARAM("cell") );
257 :
258 1 : Reference< XNameContainer > xTableFamily( xFamilies->getByName( sFamilyName ), UNO_QUERY_THROW );
259 1 : Reference< XNameAccess > xCellFamily( xFamilies->getByName( sCellFamilyName ), UNO_QUERY_THROW );
260 :
261 1 : Reference< XSingleServiceFactory > xFactory( xTableFamily, UNO_QUERY_THROW );
262 :
263 2 : for( XMLTableTemplateMap::iterator aTemplateIter( maTableTemplates.begin() ); aTemplateIter != maTableTemplates.end(); ++aTemplateIter ) try
264 : {
265 1 : const OUString sTemplateName( (*aTemplateIter).first );
266 1 : Reference< XNameReplace > xTemplate( xFactory->createInstance(), UNO_QUERY_THROW );
267 :
268 1 : boost::shared_ptr< XMLTableTemplate > xT( (*aTemplateIter).second );
269 :
270 8 : for( XMLTableTemplate::iterator aStyleIter( xT->begin() ); aStyleIter != xT->end(); ++aStyleIter ) try
271 : {
272 7 : const OUString sPropName( (*aStyleIter).first );
273 7 : const OUString sStyleName( (*aStyleIter).second );
274 7 : xTemplate->replaceByName( sPropName, xCellFamily->getByName( sStyleName ) );
275 : }
276 0 : catch( Exception& )
277 : {
278 : OSL_FAIL("xmloff::XMLTableImport::finishStyles(), exception caught!");
279 : }
280 :
281 1 : if( xTemplate.is() )
282 : {
283 1 : if( xTableFamily->hasByName( sTemplateName ) )
284 1 : xTableFamily->replaceByName( sTemplateName, Any( xTemplate ) );
285 : else
286 0 : xTableFamily->insertByName( sTemplateName, Any( xTemplate ) );
287 1 : }
288 :
289 : }
290 0 : catch( Exception& )
291 : {
292 : OSL_FAIL("xmloff::XMLTableImport::finishStyles(), exception caught!");
293 1 : }
294 : }
295 0 : catch( Exception& )
296 : {
297 : OSL_FAIL("xmloff::XMLTableImport::finishStyles(), exception caught!");
298 : }
299 2 : }
300 :
301 : // --------------------------------------------------------------------
302 : // class XMLTableImport
303 : // --------------------------------------------------------------------
304 :
305 :
306 2 : XMLTableImportContext::XMLTableImportContext( const rtl::Reference< XMLTableImport >& xImporter, sal_uInt16 nPrfx, const OUString& rLName, Reference< XColumnRowRange >& xColumnRowRange )
307 2 : : SvXMLImportContext( xImporter->mrImport, nPrfx, rLName )
308 : , mxTableImporter( xImporter )
309 : , mxTable( xColumnRowRange, UNO_QUERY )
310 2 : , mxColumns( xColumnRowRange->getColumns() )
311 2 : , mxRows( xColumnRowRange->getRows() )
312 : , mnCurrentRow( -1 )
313 8 : , mnCurrentColumn( -1 )
314 : {
315 2 : }
316 :
317 : // --------------------------------------------------------------------
318 :
319 4 : XMLTableImportContext::~XMLTableImportContext()
320 : {
321 4 : }
322 :
323 : // --------------------------------------------------------------------
324 :
325 8 : SvXMLImportContext * XMLTableImportContext::ImportColumn( sal_uInt16 nPrefix, const OUString& rLocalName, const Reference< XAttributeList >& xAttrList )
326 : {
327 8 : if( mxColumns.is() && (mnCurrentRow == -1) ) try
328 : {
329 8 : boost::shared_ptr< ColumnInfo > xInfo ( new ColumnInfo );
330 :
331 8 : sal_Int32 nRepeated = 1;
332 :
333 : // read attributes for the table-column
334 8 : sal_Int16 nAttrCount = xAttrList.is() ? xAttrList->getLength() : 0;
335 16 : for(sal_Int16 i=0; i < nAttrCount; i++)
336 : {
337 8 : const OUString sAttrName( xAttrList->getNameByIndex( i ) );
338 8 : const OUString sValue( xAttrList->getValueByIndex( i ) );
339 8 : OUString aLocalName;
340 :
341 8 : sal_uInt16 nPrefix2 = GetImport().GetNamespaceMap().GetKeyByAttrName( sAttrName, &aLocalName );
342 8 : if( XML_NAMESPACE_TABLE == nPrefix2 )
343 : {
344 8 : if( IsXMLToken( aLocalName, XML_NUMBER_COLUMNS_REPEATED ) )
345 : {
346 0 : nRepeated = sValue.toInt32();
347 : }
348 8 : else if( IsXMLToken( aLocalName, XML_STYLE_NAME ) )
349 : {
350 8 : xInfo->msStyleName = sValue;
351 : }
352 0 : else if( IsXMLToken( aLocalName, XML_DEFAULT_CELL_STYLE_NAME ) )
353 : {
354 0 : xInfo->msDefaultCellStyleName = sValue;
355 : }
356 0 : else if( IsXMLToken( aLocalName, XML_VISIBILITY ) )
357 : {
358 0 : xInfo->mbVisibility = IsXMLToken( sValue, XML_VISIBLE );
359 : }
360 : }
361 0 : else if ( (XML_NAMESPACE_XML == nPrefix2) &&
362 0 : IsXMLToken(aLocalName, XML_ID) )
363 : {
364 : (void) sValue;
365 : //FIXME: TODO
366 : }
367 8 : }
368 :
369 8 : if( nRepeated <= 1 )
370 : {
371 8 : maColumnInfos.push_back( xInfo );
372 : }
373 : else
374 : {
375 0 : maColumnInfos.insert( maColumnInfos.end(), nRepeated, xInfo );
376 8 : }
377 : }
378 0 : catch( Exception& )
379 : {
380 : OSL_FAIL("xmloff::XMLTableImportContext::ImportTableColumn(), exception caught!");
381 : }
382 :
383 8 : return SvXMLImportContext::CreateChildContext( nPrefix, rLocalName, xAttrList);
384 : }
385 :
386 : // --------------------------------------------------------------------
387 :
388 2 : void XMLTableImportContext::InitColumns()
389 : {
390 2 : if( mxColumns.is() ) try
391 : {
392 2 : const sal_Int32 nCount1 = mxColumns->getCount();
393 2 : const sal_Int32 nCount2 = sal::static_int_cast< sal_Int32 >( maColumnInfos.size() );
394 2 : if( nCount1 < nCount2 )
395 1 : mxColumns->insertByIndex( nCount1, nCount2 - nCount1 );
396 :
397 2 : SvXMLStylesContext * pAutoStyles = GetImport().GetShapeImport()->GetAutoStylesContext();
398 :
399 10 : for( sal_Int32 nCol = 0; nCol < nCount2; nCol++ )
400 : {
401 8 : boost::shared_ptr< ColumnInfo > xInfo( maColumnInfos[nCol] );
402 :
403 8 : if( pAutoStyles && !xInfo->msStyleName.isEmpty() )
404 : {
405 : const XMLPropStyleContext* pStyle =
406 : dynamic_cast< const XMLPropStyleContext* >(
407 8 : pAutoStyles->FindStyleChildContext(XML_STYLE_FAMILY_TABLE_COLUMN, xInfo->msStyleName) );
408 :
409 8 : if( pStyle )
410 : {
411 8 : Reference< XPropertySet > xColProps( mxColumns->getByIndex(nCol), UNO_QUERY_THROW );
412 8 : const_cast< XMLPropStyleContext* >( pStyle )->FillPropertySet( xColProps );
413 : }
414 : }
415 :
416 8 : }
417 : }
418 0 : catch( Exception& )
419 : {
420 : OSL_FAIL("xmloff::XMLTableImportContext::ImportTableColumn(), exception caught!");
421 : }
422 2 : }
423 :
424 : // --------------------------------------------------------------------
425 :
426 10 : SvXMLImportContext * XMLTableImportContext::ImportRow( sal_uInt16 nPrefix, const OUString& rLocalName, const Reference< XAttributeList >& xAttrList )
427 : {
428 10 : if( mxRows.is() )
429 : {
430 10 : mnCurrentRow++;
431 10 : if( mnCurrentRow == 0 )
432 2 : InitColumns(); // first init columns
433 :
434 10 : mnCurrentColumn = -1;
435 :
436 10 : const sal_Int32 nRowCount = mxRows->getCount();
437 10 : if( ( nRowCount - 1) < mnCurrentRow )
438 : {
439 8 : const sal_Int32 nCount = mnCurrentRow - nRowCount + 1;
440 8 : mxRows->insertByIndex( nRowCount, nCount );
441 : }
442 :
443 10 : Reference< XPropertySet > xRowSet( mxRows->getByIndex(mnCurrentRow), UNO_QUERY );
444 :
445 10 : OUString sStyleName;
446 :
447 : // read attributes for the table-row
448 10 : sal_Int16 nAttrCount = xAttrList.is() ? xAttrList->getLength() : 0;
449 21 : for(sal_Int16 i=0; i < nAttrCount; i++)
450 : {
451 11 : const OUString sAttrName( xAttrList->getNameByIndex( i ) );
452 11 : const OUString sValue( xAttrList->getValueByIndex( i ) );
453 11 : OUString aLocalName;
454 :
455 11 : sal_uInt16 nPrefix2 = GetImport().GetNamespaceMap().GetKeyByAttrName( sAttrName, &aLocalName );
456 11 : if( nPrefix2 == XML_NAMESPACE_TABLE )
457 : {
458 11 : if( IsXMLToken( aLocalName, XML_STYLE_NAME ) )
459 : {
460 10 : sStyleName = sValue;
461 : }
462 1 : else if( IsXMLToken( aLocalName, XML_DEFAULT_CELL_STYLE_NAME ) )
463 : {
464 1 : msDefaultCellStyleName = sValue;
465 : }
466 : }
467 0 : else if ( (XML_NAMESPACE_XML == nPrefix2) &&
468 0 : IsXMLToken(aLocalName, XML_ID) )
469 : {
470 : (void) sValue;
471 : //FIXME: TODO
472 : }
473 11 : }
474 :
475 10 : if( !sStyleName.isEmpty() )
476 : {
477 10 : SvXMLStylesContext * pAutoStyles = GetImport().GetShapeImport()->GetAutoStylesContext();
478 10 : if( pAutoStyles )
479 : {
480 : const XMLPropStyleContext* pStyle =
481 : dynamic_cast< const XMLPropStyleContext* >(
482 10 : pAutoStyles->FindStyleChildContext(XML_STYLE_FAMILY_TABLE_ROW, sStyleName) );
483 :
484 10 : if( pStyle )
485 : {
486 10 : const_cast< XMLPropStyleContext* >( pStyle )->FillPropertySet( xRowSet );
487 : }
488 : }
489 10 : }
490 : }
491 :
492 10 : SvXMLImportContextRef xThis( this );
493 10 : return new XMLProxyContext( GetImport(), xThis, nPrefix, rLocalName );
494 : }
495 :
496 : // --------------------------------------------------------------------
497 :
498 16 : SvXMLImportContext * XMLTableImportContext::ImportCell( sal_uInt16 nPrefix, const OUString& rLocalName, const Reference< XAttributeList >& xAttrList )
499 : {
500 16 : mnCurrentColumn++;
501 16 : if( mxColumns.is() ) try
502 : {
503 16 : if( mxColumns->getCount() <= mnCurrentColumn )
504 0 : mxColumns->insertByIndex( mxColumns->getCount(), mnCurrentColumn - mxColumns->getCount() + 1 );
505 :
506 16 : Reference< XMergeableCell > xCell( mxTable->getCellByPosition( mnCurrentColumn, mnCurrentRow ), UNO_QUERY_THROW );
507 16 : XMLCellImportContext* pCellContext = new XMLCellImportContext( GetImport(), xCell, GetDefaultCellStyleName(), nPrefix, rLocalName, xAttrList );
508 :
509 16 : const sal_Int32 nColumnSpan = pCellContext->getColumnSpan();
510 16 : const sal_Int32 nRowSpan = pCellContext->getRowSpan();
511 16 : if( (nColumnSpan > 1) || (nRowSpan > 1) )
512 0 : maMergeInfos.push_back( boost::shared_ptr< MergeInfo >( new MergeInfo( mnCurrentColumn, mnCurrentRow, nColumnSpan, nRowSpan ) ) );
513 :
514 16 : const sal_Int32 nRepeated = pCellContext->getRepeated();
515 16 : if( nRepeated > 1 )
516 : {
517 : OSL_FAIL("xmloff::XMLTableImportContext::ImportCell(), import of repeated Cells not implemented (TODO)");
518 0 : mnCurrentColumn += nRepeated - 1;
519 : }
520 :
521 16 : return pCellContext;
522 : }
523 0 : catch( Exception& )
524 : {
525 : OSL_FAIL("xmloff::XMLTableImportContext::ImportCell(), exception caught!");
526 : }
527 :
528 0 : return SvXMLImportContext::CreateChildContext( nPrefix, rLocalName, xAttrList);
529 : }
530 :
531 : // --------------------------------------------------------------------
532 :
533 34 : SvXMLImportContext *XMLTableImportContext::CreateChildContext( sal_uInt16 nPrefix, const OUString& rLocalName, const Reference< XAttributeList >& xAttrList )
534 : {
535 34 : if( nPrefix == XML_NAMESPACE_TABLE )
536 : {
537 34 : if( IsXMLToken( rLocalName, XML_TABLE_COLUMN ) )
538 8 : return ImportColumn( nPrefix, rLocalName, xAttrList );
539 26 : else if( IsXMLToken( rLocalName, XML_TABLE_ROW ) )
540 10 : return ImportRow( nPrefix, rLocalName, xAttrList );
541 16 : else if( IsXMLToken( rLocalName, XML_TABLE_CELL ) || IsXMLToken( rLocalName, XML_COVERED_TABLE_CELL ) )
542 16 : return ImportCell( nPrefix, rLocalName, xAttrList );
543 0 : else if( IsXMLToken( rLocalName, XML_TABLE_COLUMNS ) || IsXMLToken( rLocalName, XML_TABLE_ROWS ) )
544 : {
545 0 : SvXMLImportContextRef xThis( this );
546 0 : return new XMLProxyContext( GetImport(), xThis, nPrefix, rLocalName );
547 : }
548 : }
549 :
550 0 : return SvXMLImportContext::CreateChildContext( nPrefix, rLocalName, xAttrList);
551 : }
552 :
553 : // --------------------------------------------------------------------
554 :
555 2 : void XMLTableImportContext::StartElement( const Reference< XAttributeList >& /*xAttrList*/ )
556 : {
557 2 : }
558 :
559 : // --------------------------------------------------------------------
560 :
561 2 : void XMLTableImportContext::EndElement()
562 : {
563 2 : if( !maMergeInfos.empty() )
564 : {
565 0 : MergeInfoVector::iterator aIter( maMergeInfos.begin() );
566 0 : while( aIter != maMergeInfos.end() )
567 : {
568 0 : boost::shared_ptr< MergeInfo > xInfo( (*aIter++) );
569 :
570 0 : if( xInfo.get() ) try
571 : {
572 0 : Reference< XCellRange > xRange( mxTable->getCellRangeByPosition( xInfo->mnStartColumn, xInfo->mnStartRow, xInfo->mnEndColumn, xInfo->mnEndRow ) );
573 0 : Reference< XMergeableCellRange > xCursor( mxTable->createCursorByRange( xRange ), UNO_QUERY_THROW );
574 0 : xCursor->merge();
575 : }
576 0 : catch( Exception& )
577 : {
578 : OSL_FAIL("XMLTableImportContext::EndElement(), exception caught while merging cells!");
579 : }
580 0 : }
581 : }
582 2 : }
583 :
584 : // --------------------------------------------------------------------
585 :
586 16 : OUString XMLTableImportContext::GetDefaultCellStyleName() const
587 : {
588 16 : OUString sStyleName( msDefaultCellStyleName );
589 :
590 : // if there is still no style name, try default style name from column
591 16 : if( (sStyleName.isEmpty()) && (mnCurrentColumn < sal::static_int_cast<sal_Int32>(maColumnInfos.size())) )
592 9 : sStyleName = maColumnInfos[mnCurrentColumn]->msDefaultCellStyleName;
593 :
594 16 : return sStyleName;
595 : }
596 :
597 : // --------------------------------------------------------------------
598 : // XMLCellImportContext
599 : // --------------------------------------------------------------------
600 :
601 16 : XMLCellImportContext::XMLCellImportContext( SvXMLImport& rImport, const Reference< XMergeableCell >& xCell, const OUString& sDefaultCellStyleName, sal_uInt16 nPrfx, const OUString& rLName, const ::com::sun::star::uno::Reference< ::com::sun::star::xml::sax::XAttributeList >& xAttrList )
602 : : SvXMLImportContext( rImport, nPrfx, rLName )
603 : , mxCell( xCell )
604 : , mbListContextPushed( false )
605 : , mnColSpan( 1 )
606 : , mnRowSpan( 1 )
607 16 : , mnRepeated( 1 )
608 : {
609 16 : OUString sStyleName;
610 :
611 : // read attributes for the table-cell
612 16 : sal_Int16 nAttrCount = xAttrList.is() ? xAttrList->getLength() : 0;
613 25 : for(sal_Int16 i=0; i < nAttrCount; i++)
614 : {
615 9 : const OUString sAttrName( xAttrList->getNameByIndex( i ) );
616 9 : const OUString sValue( xAttrList->getValueByIndex( i ) );
617 9 : OUString aLocalName;
618 :
619 9 : sal_uInt16 nPrefix2 = GetImport().GetNamespaceMap().GetKeyByAttrName( sAttrName, &aLocalName );
620 9 : if( XML_NAMESPACE_TABLE == nPrefix2 )
621 : {
622 9 : if( IsXMLToken( aLocalName, XML_NUMBER_COLUMNS_REPEATED ) )
623 : {
624 0 : mnRepeated = sValue.toInt32();
625 : }
626 9 : else if( IsXMLToken( aLocalName, XML_NUMBER_COLUMNS_SPANNED ) )
627 : {
628 0 : mnColSpan = sValue.toInt32();
629 : }
630 9 : else if( IsXMLToken( aLocalName, XML_NUMBER_ROWS_SPANNED ) )
631 : {
632 0 : mnRowSpan = sValue.toInt32();
633 : }
634 9 : else if( IsXMLToken( aLocalName, XML_STYLE_NAME ) )
635 : {
636 9 : sStyleName = sValue;
637 : }
638 : }
639 0 : else if ( (XML_NAMESPACE_XML == nPrefix2) &&
640 0 : IsXMLToken(aLocalName, XML_ID) )
641 : {
642 : (void) sValue;
643 : //FIXME: TODO
644 : }
645 : //FIXME: RDFa (table:table-cell)
646 9 : }
647 :
648 : // if there is no style name at the cell, try default style name from row
649 16 : if( sStyleName.isEmpty() )
650 7 : sStyleName = sDefaultCellStyleName;
651 :
652 16 : if( !sStyleName.isEmpty() )
653 : {
654 16 : SvXMLStylesContext * pAutoStyles = GetImport().GetShapeImport()->GetAutoStylesContext();
655 16 : if( pAutoStyles )
656 : {
657 : const XMLPropStyleContext* pStyle =
658 : dynamic_cast< const XMLPropStyleContext* >(
659 16 : pAutoStyles->FindStyleChildContext(XML_STYLE_FAMILY_TABLE_CELL, sStyleName) );
660 :
661 16 : if( pStyle )
662 : {
663 16 : Reference< XPropertySet > xCellSet( mxCell, UNO_QUERY );
664 16 : if( xCellSet.is() )
665 16 : const_cast< XMLPropStyleContext* >( pStyle )->FillPropertySet( xCellSet );
666 : }
667 : }
668 16 : }
669 16 : }
670 :
671 : // --------------------------------------------------------------------
672 :
673 32 : XMLCellImportContext::~XMLCellImportContext()
674 : {
675 32 : }
676 :
677 : // --------------------------------------------------------------------
678 :
679 0 : SvXMLImportContext * XMLCellImportContext::CreateChildContext( sal_uInt16 nPrefix, const OUString& rLocalName, const Reference< XAttributeList >& xAttrList )
680 : {
681 : // create text cursor on demand
682 0 : if( !mxCursor.is() )
683 : {
684 0 : Reference< XText > xText( mxCell, UNO_QUERY );
685 0 : if( xText.is() )
686 : {
687 0 : UniReference < XMLTextImportHelper > xTxtImport( GetImport().GetTextImport() );
688 0 : mxOldCursor = xTxtImport->GetCursor();
689 0 : mxCursor = xText->createTextCursor();
690 0 : if( mxCursor.is() )
691 0 : xTxtImport->SetCursor( mxCursor );
692 :
693 : // remember old list item and block (#91964#) and reset them
694 : // for the text frame
695 0 : xTxtImport->PushListContext();
696 0 : mbListContextPushed = true;
697 0 : }
698 : }
699 :
700 0 : SvXMLImportContext * pContext = 0;
701 :
702 : // if we have a text cursor, lets try to import some text
703 0 : if( mxCursor.is() )
704 : {
705 0 : pContext = GetImport().GetTextImport()->CreateTextChildContext( GetImport(), nPrefix, rLocalName, xAttrList );
706 : }
707 :
708 0 : if( pContext )
709 0 : return pContext;
710 : else
711 0 : return SvXMLImportContext::CreateChildContext( nPrefix, rLocalName, xAttrList);
712 : }
713 :
714 : // --------------------------------------------------------------------
715 :
716 : // --------------------------------------------------------------------
717 :
718 16 : void XMLCellImportContext::EndElement()
719 : {
720 16 : if(mxCursor.is())
721 : {
722 : // delete addition newline
723 0 : const OUString aEmpty;
724 0 : mxCursor->gotoEnd( sal_False );
725 0 : mxCursor->goLeft( 1, sal_True );
726 0 : mxCursor->setString( aEmpty );
727 :
728 : // reset cursor
729 0 : GetImport().GetTextImport()->ResetCursor();
730 : }
731 :
732 16 : if(mxOldCursor.is())
733 0 : GetImport().GetTextImport()->SetCursor( mxOldCursor );
734 :
735 : // reinstall old list item (if necessary) #91964#
736 16 : if (mbListContextPushed) {
737 0 : GetImport().GetTextImport()->PopListContext();
738 : }
739 16 : }
740 :
741 : // --------------------------------------------------------------------
742 : // class XMLTableTemplateContext
743 : // --------------------------------------------------------------------
744 :
745 1 : XMLTableTemplateContext::XMLTableTemplateContext( SvXMLImport& rImport, sal_uInt16 nPrfx, const OUString& rLName, const Reference< XAttributeList >& xAttrList )
746 1 : : SvXMLStyleContext( rImport, nPrfx, rLName, xAttrList, XML_STYLE_FAMILY_TABLE_TEMPLATE_ID, sal_False )
747 : {
748 1 : }
749 :
750 : // --------------------------------------------------------------------
751 :
752 1 : void XMLTableTemplateContext::StartElement( const Reference< XAttributeList >& xAttrList )
753 : {
754 1 : sal_Int16 nAttrCount = xAttrList.is() ? xAttrList->getLength() : 0;
755 1 : for(sal_Int16 i=0; i < nAttrCount; i++)
756 : {
757 1 : OUString sAttrName;
758 1 : sal_uInt16 nAttrPrefix = GetImport().GetNamespaceMap().GetKeyByAttrName( xAttrList->getNameByIndex( i ), &sAttrName );
759 1 : if( (nAttrPrefix == XML_NAMESPACE_TEXT ) && IsXMLToken( sAttrName, XML_STYLE_NAME ) )
760 : {
761 1 : msTemplateStyleName = xAttrList->getValueByIndex( i );
762 : break;
763 : }
764 1 : }
765 1 : }
766 :
767 : // --------------------------------------------------------------------
768 :
769 1 : void XMLTableTemplateContext::EndElement()
770 : {
771 1 : rtl::Reference< XMLTableImport > xTableImport( GetImport().GetShapeImport()->GetShapeTableImport() );
772 1 : if( xTableImport.is() )
773 1 : xTableImport->addTableTemplate( msTemplateStyleName, maTableTemplate );
774 1 : }
775 :
776 : // --------------------------------------------------------------------
777 :
778 7 : SvXMLImportContext * XMLTableTemplateContext::CreateChildContext( sal_uInt16 nPrefix, const OUString& rLocalName, const Reference< XAttributeList >& xAttrList )
779 : {
780 7 : if( nPrefix == XML_NAMESPACE_TABLE )
781 : {
782 7 : const TableStyleElement* pElements = getTableStyleMap();
783 40 : while( (pElements->meElement != XML_TOKEN_END) && !IsXMLToken( rLocalName, pElements->meElement ) )
784 26 : pElements++;
785 :
786 7 : if( pElements->meElement != XML_TOKEN_END )
787 : {
788 7 : sal_Int16 nAttrCount = xAttrList.is() ? xAttrList->getLength() : 0;
789 7 : for(sal_Int16 i=0; i < nAttrCount; i++)
790 : {
791 7 : OUString sAttrName;
792 7 : sal_uInt16 nAttrPrefix = GetImport().GetNamespaceMap().GetKeyByAttrName( xAttrList->getNameByIndex( i ), &sAttrName );
793 14 : if( (nAttrPrefix == XML_NAMESPACE_TEXT || nAttrPrefix == XML_NAMESPACE_TABLE) &&
794 7 : IsXMLToken( sAttrName, XML_STYLE_NAME ) )
795 : {
796 7 : maTableTemplate[pElements->msStyleName] = xAttrList->getValueByIndex( i );
797 : break;
798 : }
799 7 : }
800 : }
801 : }
802 :
803 7 : return SvXMLImportContext::CreateChildContext( nPrefix, rLocalName, xAttrList );
804 : }
805 :
806 : // --------------------------------------------------------------------
807 :
808 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
