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