svx/source/table/tablertfimporter.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20
  21 #include <memory>
  22 #include <vector>
  23
  24 #include <com/sun/star/table/XTable.hpp>
  25 #include <com/sun/star/table/XMergeableCellRange.hpp>
  26
  27 #include <tools/stream.hxx>
  28 #include <svtools/rtftoken.h>
  29
  30 #include <editeng/eeitem.hxx>
  31 #include <svx/svdetc.hxx>
  32 #include <editeng/fhgtitem.hxx>
  33 #include <editeng/outlobj.hxx>
  34
  35 #include <cell.hxx>
  36 #include <celltypes.hxx>
  37 #include <svx/svdotable.hxx>
  38 #include <svx/svdoutl.hxx>
  39 #include <editeng/editeng.hxx>
  40 #include <editeng/editdata.hxx>
  41 #include <svx/svdmodel.hxx>
  42 #include <editeng/svxrtf.hxx>
  43 #include <sal/log.hxx>
  44
  45 using namespace ::com::sun::star::uno;
  46 using namespace ::com::sun::star::table;
  47 using namespace ::com::sun::star::container;
  48 using namespace ::com::sun::star::beans;
  49
  50 namespace sdr { namespace table {
  51
  52 struct RTFCellDefault
  53 {
  54     SfxItemSet          maItemSet;
  55     sal_Int32           mnRowSpan;
  56     sal_Int32           mnColSpan;   // MergeCell if >1, merged cells if 0
  57     sal_Int32           mnCellX;
  58
  59     explicit RTFCellDefault( SfxItemPool* pPool ) : maItemSet( *pPool ), mnRowSpan(1), mnColSpan(1), mnCellX(0) {}
  60 };
  61
  62 typedef std::vector< std::shared_ptr< RTFCellDefault > > RTFCellDefaultVector;
  63
  64 struct RTFCellInfo
  65 {
  66     SfxItemSet const    maItemSet;
  67     sal_Int32           mnStartPara;
  68     sal_Int32           mnParaCount;
  69     sal_Int32           mnCellX;
  70     sal_Int32           mnRowSpan;
  71     std::shared_ptr< RTFCellInfo > mxVMergeCell;
  72
  73     explicit RTFCellInfo( SfxItemPool& rPool ) : maItemSet(  rPool ), mnStartPara(0), mnParaCount(0), mnCellX(0), mnRowSpan(1) {}
  74 };
  75
  76 typedef std::shared_ptr< RTFCellInfo > RTFCellInfoPtr;
  77 typedef std::vector< RTFCellInfoPtr > RTFColumnVector;
  78
  79 typedef std::shared_ptr< RTFColumnVector > RTFColumnVectorPtr;
  80
  81 class SdrTableRTFParser
  82 {
  83 public:
  84     explicit SdrTableRTFParser( SdrTableObj& rTableObj );
  85
  86     void Read( SvStream& rStream );
  87
  88     void ProcToken( RtfImportInfo* pInfo );
  89
  90     void NextRow();
  91     void NextColumn();
  92     void NewCellRow();
  93
  94     void InsertCell( RtfImportInfo const * pInfo );
  95     void InsertColumnEdge( sal_Int32 nEdge );
  96
  97     void FillTable();
  98
  99     DECL_LINK( RTFImportHdl, RtfImportInfo&, void );
 100
 101 private:
 102     SdrTableObj&    mrTableObj;
 103     std::unique_ptr<SdrOutliner> mpOutliner;
 104     SfxItemPool&    mrItemPool;
 105
 106     RTFCellDefaultVector maDefaultList;
 107     RTFCellDefaultVector::iterator maDefaultIterator;
 108
 109     int             mnLastToken;
 110     bool            mbNewDef;
 111
 112     sal_Int32       mnStartPara;
 113
 114     sal_Int32       mnRowCnt;
 115     sal_Int32       mnLastEdge;
 116     sal_Int32       mnVMergeIdx;
 117
 118     std::vector< sal_Int32 > maColumnEdges;
 119     std::vector< sal_Int32 >::iterator maLastEdge;
 120     std::vector< RTFColumnVectorPtr > maRows;
 121
 122     std::unique_ptr<RTFCellDefault> mpInsDefault;
 123     RTFCellDefault* mpActDefault;
 124     RTFCellDefault* mpDefMerge;
 125
 126     Reference< XTable > mxTable;
 127
 128     RTFColumnVectorPtr mxLastRow;
 129     // Copy assignment is forbidden and not implemented.
 130     SdrTableRTFParser (const SdrTableRTFParser &) = delete;
 131     SdrTableRTFParser & operator= (const SdrTableRTFParser &) = delete;
 132 };
 133
 134 SdrTableRTFParser::SdrTableRTFParser( SdrTableObj& rTableObj )
 135 : mrTableObj( rTableObj )
 136 , mpOutliner( SdrMakeOutliner( OutlinerMode::TextObject, rTableObj.getSdrModelFromSdrObject() ) )
 137 , mrItemPool( rTableObj.getSdrModelFromSdrObject().GetItemPool() )
 138 , mnLastToken( 0 )
 139 , mbNewDef( false )
 140 , mnStartPara( 0 )
 141 , mnRowCnt( 0 )
 142 , mnLastEdge( 0 )
 143 , mnVMergeIdx ( 0 )
 144 , mpActDefault( nullptr )
 145 , mpDefMerge( nullptr )
 146 , mxTable( rTableObj.getTable() )
 147 {
 148     mpOutliner->SetUpdateMode(true);
 149     mpOutliner->SetStyleSheet( 0, mrTableObj.GetStyleSheet() );
 150     mpInsDefault.reset( new RTFCellDefault( &mrItemPool ) );
 151 }
 152
 153 void SdrTableRTFParser::Read( SvStream& rStream )
 154 {
 155     EditEngine& rEdit = const_cast< EditEngine& >( mpOutliner->GetEditEngine() );
 156
 157     Link<RtfImportInfo&,void> aOldLink( rEdit.GetRtfImportHdl() );
 158     rEdit.SetRtfImportHdl( LINK( this, SdrTableRTFParser, RTFImportHdl ) );
 159     mpOutliner->Read( rStream, OUString(), EETextFormat::Rtf );
 160     rEdit.SetRtfImportHdl( aOldLink );
 161
 162     FillTable();
 163 }
 164
 165 IMPL_LINK( SdrTableRTFParser, RTFImportHdl, RtfImportInfo&, rInfo, void )
 166 {
 167     switch ( rInfo.eState )
 168     {
 169         case RtfImportState::NextToken:
 170             ProcToken( &rInfo );
 171             break;
 172         case RtfImportState::UnknownAttr:
 173             ProcToken( &rInfo );
 174             break;
 175         case RtfImportState::Start:
 176         {
 177             SvxRTFParser* pParser = static_cast<SvxRTFParser*>(rInfo.pParser);
 178             pParser->SetAttrPool( &mrItemPool );
 179             RTFPardAttrMapIds& rMap = pParser->GetPardMap();
 180             rMap.nBox = SDRATTR_TABLE_BORDER;
 181         }
 182             break;
 183         case RtfImportState::End:
 184             if ( rInfo.aSelection.nEndPos )
 185             {
 186                 mpActDefault = nullptr;
 187                 rInfo.nToken = RTF_PAR;
 188                 rInfo.aSelection.nEndPara++;
 189                 ProcToken( &rInfo );
 190             }
 191             break;
 192         case RtfImportState::SetAttr:
 193         case RtfImportState::InsertText:
 194         case RtfImportState::InsertPara:
 195             break;
 196         default:
 197             SAL_WARN( "svx.table","unknown ImportInfo.eState");
 198     }
 199 }
 200
 201 void SdrTableRTFParser::NextRow()
 202 {
 203     mxLastRow = maRows.back();
 204     mnVMergeIdx = 0;
 205     ++mnRowCnt;
 206 }
 207
 208 void SdrTableRTFParser::InsertCell( RtfImportInfo const * pInfo )
 209 {
 210
 211     RTFCellInfoPtr xCellInfo( new RTFCellInfo(mrItemPool) );
 212
 213     xCellInfo->mnStartPara = mnStartPara;
 214     xCellInfo->mnParaCount = pInfo->aSelection.nEndPara - 1 - mnStartPara;
 215     xCellInfo->mnCellX = mpActDefault->mnCellX;
 216     xCellInfo->mnRowSpan = mpActDefault->mnRowSpan;
 217
 218
 219     if ( mxLastRow != nullptr )
 220     {
 221         sal_Int32 nSize = mxLastRow->size();
 222         while( mnVMergeIdx < nSize &&
 223              (*mxLastRow)[mnVMergeIdx]->mnCellX < xCellInfo->mnCellX )
 224             ++mnVMergeIdx;
 225
 226         if ( xCellInfo->mnRowSpan == 0 && mnVMergeIdx < nSize )
 227         {
 228             RTFCellInfoPtr xLastCell( (*mxLastRow)[mnVMergeIdx] );
 229             if (xLastCell->mnRowSpan)
 230                 xCellInfo->mxVMergeCell = xLastCell;
 231             else
 232                 xCellInfo->mxVMergeCell = xLastCell->mxVMergeCell;
 233         }
 234     }
 235
 236     if( !maRows.empty() )
 237     {
 238         RTFColumnVectorPtr xColumn( maRows.back() );
 239         if ( xCellInfo->mxVMergeCell )
 240         {
 241             if ( xColumn->empty() ||
 242                     xColumn->back()->mxVMergeCell != xCellInfo->mxVMergeCell )
 243                 xCellInfo->mxVMergeCell->mnRowSpan++;
 244         }
 245
 246         xColumn->push_back( xCellInfo );
 247     }
 248
 249     mnStartPara = pInfo->aSelection.nEndPara - 1;
 250 }
 251
 252 void SdrTableRTFParser::InsertColumnEdge( sal_Int32 nEdge )
 253 {
 254     auto aNextEdge = std::lower_bound( maLastEdge, maColumnEdges.end(), nEdge );
 255
 256     if ( aNextEdge == maColumnEdges.end() || nEdge != *aNextEdge )
 257     {
 258         maLastEdge = maColumnEdges.insert( aNextEdge , nEdge );
 259         mnLastEdge = nEdge;
 260     }
 261 }
 262
 263 void SdrTableRTFParser::FillTable()
 264 {
 265     try
 266     {
 267         sal_Int32 nColCount = mxTable->getColumnCount();
 268         Reference< XTableColumns > xCols( mxTable->getColumns(), UNO_SET_THROW );
 269         sal_Int32 nColMax = maColumnEdges.size();
 270         if( nColCount < nColMax )
 271         {
 272             xCols->insertByIndex( nColCount, nColMax - nColCount );
 273             nColCount = mxTable->getColumnCount();
 274         }
 275
 276         const OUString sWidth("Width");
 277         sal_Int32 nCol, nLastEdge = 0;
 278         for( nCol = 0; nCol < nColCount; nCol++ )
 279         {
 280             Reference< XPropertySet > xSet( xCols->getByIndex( nCol ), UNO_QUERY_THROW );
 281             sal_Int32 nWidth = maColumnEdges[nCol] - nLastEdge;
 282
 283             xSet->setPropertyValue( sWidth, Any( nWidth ) );
 284             nLastEdge += nWidth;
 285         }
 286
 287         const sal_Int32 nRowCount = mxTable->getRowCount();
 288         if( nRowCount < mnRowCnt )
 289         {
 290             Reference< XTableRows > xRows( mxTable->getRows(), UNO_SET_THROW );
 291             xRows->insertByIndex( nRowCount, mnRowCnt - nRowCount );
 292         }
 293
 294         for( sal_Int32 nRow = 0; nRow < static_cast<sal_Int32>(maRows.size()); nRow++ )
 295         {
 296             RTFColumnVectorPtr xColumn( maRows[nRow] );
 297             nCol = 0;
 298             auto aEdge = maColumnEdges.begin();
 299             for( sal_Int32 nIdx = 0; nCol < nColMax && nIdx < static_cast<sal_Int32>(xColumn->size()); nIdx++ )
 300             {
 301                 RTFCellInfoPtr xCellInfo( (*xColumn)[nIdx] );
 302
 303                 CellRef xCell( dynamic_cast< Cell* >( mxTable->getCellByPosition( nCol, nRow ).get() ) );
 304                 if( xCell.is() && xCellInfo.get() )
 305                 {
 306                     const SfxPoolItem *pPoolItem = nullptr;
 307                     if( xCellInfo->maItemSet.GetItemState(SDRATTR_TABLE_BORDER,false,&pPoolItem)==SfxItemState::SET)
 308                         xCell->SetMergedItem( *pPoolItem );
 309
 310                     std::unique_ptr<OutlinerParaObject> pTextObject(mpOutliner->CreateParaObject( xCellInfo->mnStartPara, xCellInfo->mnParaCount ));
 311                     if( pTextObject )
 312                     {
 313                         SdrOutliner& rOutliner=mrTableObj.ImpGetDrawOutliner();
 314                         rOutliner.SetUpdateMode(true);
 315                         rOutliner.SetText( *pTextObject );
 316                         mrTableObj.NbcSetOutlinerParaObjectForText( rOutliner.CreateParaObject(), xCell.get() );
 317                     }
 318
 319                     sal_Int32 nLastRow = nRow;
 320                     if ( xCellInfo->mnRowSpan )
 321                         nLastRow += xCellInfo->mnRowSpan - 1;
 322
 323                     aEdge = std::lower_bound( aEdge, maColumnEdges.end(), xCellInfo->mnCellX );
 324                     sal_Int32 nLastCol = nCol;
 325                     if ( aEdge != maColumnEdges.end() )
 326                     {
 327                         nLastCol = std::distance( maColumnEdges.begin(), aEdge);
 328                         ++aEdge;
 329                     }
 330
 331                     if ( nLastCol > nCol || nLastRow > nRow )
 332                     {
 333                          Reference< XMergeableCellRange > xRange( mxTable->createCursorByRange( mxTable->getCellRangeByPosition( nCol, nRow, nLastCol, nLastRow ) ), UNO_QUERY_THROW );
 334                          if( xRange->isMergeable() )
 335                              xRange->merge();
 336                     }
 337                     nCol = nLastCol + 1;
 338                 }
 339             }
 340         }
 341
 342         tools::Rectangle aRect( mrTableObj.GetSnapRect() );
 343         aRect.SetRight( aRect.Left() + nLastEdge );
 344         mrTableObj.NbcSetSnapRect( aRect );
 345
 346     }
 347     catch( Exception& )
 348     {
 349         OSL_FAIL("sdr::table::SdrTableRTFParser::InsertCell(), exception caught!" );
 350     }
 351 }
 352
 353 void SdrTableRTFParser::NewCellRow()
 354 {
 355     if( mbNewDef )
 356     {
 357         mbNewDef = false;
 358
 359         maRows.push_back( std::make_shared<std::vector<std::shared_ptr<RTFCellInfo>>>( ) );
 360     }
 361     mpDefMerge = nullptr;
 362     maDefaultIterator = maDefaultList.begin();
 363
 364     NextColumn();
 365
 366     DBG_ASSERT( mpActDefault, "NewCellRow: pActDefault==0" );
 367 }
 368
 369 void SdrTableRTFParser::NextColumn()
 370 {
 371     if( maDefaultIterator != maDefaultList.end() )
 372         mpActDefault = (*maDefaultIterator++).get();
 373     else
 374         mpActDefault = nullptr;
 375 }
 376
 377 static long TwipsToHundMM( long nIn )
 378 {
 379     long nRet = OutputDevice::LogicToLogic( nIn, MapUnit::MapTwip, MapUnit::Map100thMM );
 380     return nRet;
 381 }
 382
 383 void SdrTableRTFParser::ProcToken( RtfImportInfo* pInfo )
 384 {
 385     switch ( pInfo->nToken )
 386     {
 387         case RTF_TROWD:         // denotes table row default, before RTF_CELLX
 388         {
 389             maDefaultList.clear();
 390             mpDefMerge = nullptr;
 391             mnLastToken = pInfo->nToken;
 392             maLastEdge = maColumnEdges.begin();
 393             mnLastEdge = 0;
 394         }
 395         break;
 396         case RTF_CLMGF:         // The first cell of cells to be merged
 397         {
 398             mpDefMerge = mpInsDefault.get();
 399             mnLastToken = pInfo->nToken;
 400         }
 401         break;
 402         case RTF_CLMRG:         // A cell to be merged with the preceding cell
 403         {
 404             if ( !mpDefMerge )
 405                 mpDefMerge = maDefaultList.back().get();
 406             DBG_ASSERT( mpDefMerge, "RTF_CLMRG: pDefMerge==0" );
 407             if( mpDefMerge )
 408                 mpDefMerge->mnColSpan++;
 409             mpInsDefault->mnColSpan = 0;
 410             mnLastToken = pInfo->nToken;
 411         }
 412         break;
 413         case RTF_CLVMGF:
 414         {
 415             mnLastToken = pInfo->nToken;
 416         }
 417         break;
 418         case RTF_CLVMRG:
 419         {
 420             mpInsDefault->mnRowSpan = 0;
 421             mnLastToken = pInfo->nToken;
 422         }
 423         break;
 424         case RTF_CELLX:         // closes cell default
 425         {
 426             mbNewDef = true;
 427             std::shared_ptr<RTFCellDefault> pDefault( mpInsDefault.release() );
 428             maDefaultList.push_back( pDefault );
 429
 430
 431             const sal_Int32 nSize = TwipsToHundMM( pInfo->nTokenValue );
 432             if ( nSize > mnLastEdge )
 433                 InsertColumnEdge( nSize );
 434
 435             pDefault->mnCellX = nSize;
 436             // Record cellx in the first merged cell.
 437             if ( mpDefMerge && pDefault->mnColSpan == 0 )
 438                 mpDefMerge->mnCellX = nSize;
 439
 440             mpInsDefault.reset( new RTFCellDefault( &mrItemPool ) );
 441
 442             mnLastToken = pInfo->nToken;
 443         }
 444         break;
 445         case RTF_INTBL:         // before the first RTF_CELL
 446         {
 447             if ( mnLastToken != RTF_INTBL && mnLastToken != RTF_CELL && mnLastToken != RTF_PAR )
 448             {
 449                 NewCellRow();
 450                 mnLastToken = pInfo->nToken;
 451             }
 452         }
 453         break;
 454         case RTF_CELL:          // denotes the end of a cell.
 455         {
 456             DBG_ASSERT( mpActDefault, "RTF_CELL: pActDefault==0" );
 457             if ( mbNewDef || !mpActDefault )
 458                 NewCellRow();
 459             if ( !mpActDefault )
 460                 mpActDefault = mpInsDefault.get();
 461             if ( mpActDefault->mnColSpan > 0 )
 462             {
 463                 InsertCell(pInfo);
 464             }
 465             NextColumn();
 466             mnLastToken = pInfo->nToken;
 467         }
 468         break;
 469         case RTF_ROW:           // means the end of a row
 470         {
 471             NextRow();
 472             mnLastToken = pInfo->nToken;
 473         }
 474         break;
 475         case RTF_PAR:           // Paragraph
 476             mnLastToken = pInfo->nToken;
 477             break;
 478         default:
 479         {   // do not set nLastToken
 480             switch ( pInfo->nToken & ~(0xff | RTF_TABLEDEF) )
 481             {
 482                 case RTF_SHADINGDEF:
 483 //                  ((SvxRTFParser*)pInfo->pParser)->ReadBackgroundAttr(pInfo->nToken, mpInsDefault->maItemSet, sal_True );
 484                 break;
 485                 case RTF_BRDRDEF:
 486                     static_cast<SvxRTFParser*>(pInfo->pParser)->ReadBorderAttr(pInfo->nToken, mpInsDefault->maItemSet, true );
 487                 break;
 488             }
 489         }
 490     }
 491 }
 492
 493 void SdrTableObj::ImportAsRTF( SvStream& rStream, SdrTableObj& rObj )
 494 {
 495     SdrTableRTFParser aParser( rObj );
 496     aParser.Read( rStream );
 497 }
 498
 499 } }
 500
 501 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */