writerfilter/inc/resourcemodel/TableManager.hxx

   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: TableManager.hxx,v $
  10  * $Revision: 1.3 $
  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 #ifndef INCLUDED_TABLE_MANAGER_HXX
  32 #define INCLUDED_TABLE_MANAGER_HXX
  33
  34 #ifndef INCLUDED_TABLE_DATA_HXX
  35 #include <resourcemodel/TableData.hxx>
  36 #endif
  37
  38 #ifndef INCLUDED_WW8_RESOURCE_MODEL_HXX
  39 #include <resourcemodel/WW8ResourceModel.hxx>
  40 #endif
  41
  42 #ifndef INCLUDED_SPRMIDS_HXX
  43 #include <doctok/sprmids.hxx>
  44 #endif
  45
  46 #include <boost/shared_ptr.hpp>
  47 #include <stack>
  48
  49 namespace writerfilter
  50 {
  51
  52 using namespace ::std;
  53
  54 template <typename T, typename PropertiesPointer>
  55 /**
  56    Class to handle events generated by TableManager::resolveCurrentTable
  57  */
  58 class WRITERFILTER_DLLPUBLIC TableDataHandler
  59 {
  60 public:
  61     typedef boost::shared_ptr<TableDataHandler> Pointer_t;
  62
  63     /**
  64        Handle start of table.
  65
  66        @param nRows   number of rows in the table
  67        @param nDepth  depth of the table in surrounding table hierarchy
  68        @param pProps  properties of the table
  69      */
  70     virtual void startTable(unsigned int nRows, unsigned int nDepth,
  71                             PropertiesPointer pProps) = 0;
  72
  73     /**
  74        Handle end of table.
  75      */
  76     virtual void endTable() = 0;
  77
  78     /**
  79        Handle start of row.
  80
  81        @param nCols    number of columns in the table
  82        @param pProps   properties of the row
  83      */
  84     virtual void startRow(unsigned int nCols,
  85                           PropertiesPointer pProps) = 0;
  86
  87     /**
  88        Handle end of row.
  89     */
  90     virtual void endRow() = 0;
  91
  92     /**
  93        Handle start of cell.
  94
  95        @param rT     start handle of the cell
  96        @param pProps properties of the cell
  97     */
  98     virtual void startCell(const T & rT, PropertiesPointer pProps) = 0;
  99
 100     /**
 101         Handle end of cell.
 102
 103         @param rT    end handle of cell
 104     */
 105     virtual void endCell(const T & rT) = 0;
 106 };
 107
 108 template <typename T, typename PropertiesPointer>
 109 /**
 110    The table manager.
 111
 112    This class gets forwarded events from the tokenizer. It gathers the
 113    table data and after ending the table generates events for the
 114    table structure. The events have to be handles by a TableDataHandler.
 115
 116  */
 117 class TableManager
 118 {
 119     typedef boost::shared_ptr<T> T_p;
 120
 121     /**
 122        true if at the end of a row
 123      */
 124     bool mbRowEnd;
 125
 126     /**
 127        true when in a cell
 128     */
 129     bool mbInCell;
 130
 131     /**
 132        true when at the end of a cell
 133     */
 134     bool mbCellEnd;
 135
 136     /**
 137        depth of the current cell
 138     */
 139     sal_uInt32 mnTableDepthNew;
 140
 141     /**
 142         depth of the previous cell
 143     */
 144     sal_uInt32 mnTableDepth;
 145
 146     /**
 147        properties at the current point in document
 148     */
 149     PropertiesPointer mpProps;
 150
 151     /**
 152        properties of the current cell
 153     */
 154     PropertiesPointer mpCellProps;
 155
 156     /**
 157         properties of the current row
 158     */
 159     PropertiesPointer mpRowProps;
 160
 161     /**
 162        properties of the current table
 163     */
 164     PropertiesPointer mpTableProps;
 165
 166     /**
 167        handle for the current position in document
 168     */
 169     T mCurHandle;
 170
 171     /**
 172        stack of table data
 173
 174        for each level of nested tables there is one frame in the stack
 175      */
 176     stack<typename TableData<T, PropertiesPointer>::Pointer_t > mTableDataStack;
 177
 178     typedef typename TableDataHandler<T, PropertiesPointer>::Pointer_t TableDataHandlerPointer_t;
 179
 180     /**
 181        handler for resolveCurrentTable
 182      */
 183     TableDataHandlerPointer_t mpTableDataHandler;
 184
 185     /**
 186        Set flag which indicates the current handle is in a cell.
 187      */
 188     void inCell();
 189
 190     /**
 191        Set flag which indicate the current handle is at the end of a cell.
 192     */
 193     void endCell();
 194
 195     /**
 196        Set the table depth of the current cell.
 197
 198        @param nDepth     the cell depth
 199      */
 200     void cellDepth(sal_uInt32 nDepth);
 201
 202     /**
 203        Set flag indication the current handle is at the end of a row.
 204     */
 205     void endRow();
 206
 207     /**
 208        Resolve the current table to the TableDataHandler.
 209      */
 210     void resolveCurrentTable();
 211
 212 protected:
 213
 214     /**
 215        Return current table depth.
 216      */
 217     sal_uInt32 getTableDepthNew() { return mnTableDepthNew; }
 218
 219     /**
 220        Action to be carried out at the end of the last paragraph of a
 221        cell.
 222      */
 223     virtual void endOfCellAction();
 224
 225     /**
 226        Action to be carried out at the end of the "table row"
 227        paragraph.
 228      */
 229     virtual void endOfRowAction();
 230     /** let the derived class clear their table related data
 231      */
 232     virtual void clearData();
 233
 234
 235 public:
 236     TableManager();
 237     virtual ~TableManager(){}
 238
 239     /**
 240        Set handler for resolveCurrentTable.
 241
 242        @param pTableDataHandler     the handler
 243      */
 244     void setHandler(TableDataHandlerPointer_t pTableDataHandler);
 245
 246     /**
 247        Set the current handle.
 248
 249        @param rHandle     the handle
 250      */
 251     virtual void handle(const T & rHandle);
 252
 253     /**
 254        Start a new table level.
 255
 256        A new context is pushed onto the table data stack,
 257      */
 258     virtual void startLevel();
 259
 260     /**
 261        End a table level.
 262
 263        The current table is resolved and the context is popped from
 264        the stack.
 265      */
 266     virtual void endLevel();
 267
 268     /**
 269        Handle the start of a paragraph group.
 270      */
 271     virtual void startParagraphGroup();
 272
 273     /**
 274        Handle the end of a paragraph group.
 275     */
 276     virtual void endParagraphGroup();
 277
 278     /**
 279        Handle an SPRM at curent handle.
 280
 281        @param rSprm   the SPRM
 282      */
 283     virtual bool sprm(Sprm & rSprm);
 284
 285     /**
 286        Handle properties at current handle.
 287
 288        @param pProps   the properites
 289      */
 290     virtual void props(PropertiesPointer pProps);
 291
 292     /**
 293        Handle occurance of character 0x7.
 294      */
 295     virtual void handle0x7();
 296
 297     /**
 298        Handle 8 bit text at current handle.
 299
 300        @param data    array of characters
 301        @param len     number of characters to handle
 302      */
 303     virtual void text(const sal_uInt8 * data, size_t len);
 304
 305     /**
 306        Handle 16 bit text at current handle.
 307
 308        @param data    array of characters
 309        @param len     number of characters to handle
 310      */
 311     virtual void utext(const sal_uInt8 * data, size_t len);
 312
 313     /**
 314        Handle properties of the current cell.
 315
 316        @param pProps   the properties
 317      */
 318     virtual void cellProps(PropertiesPointer pProps);
 319
 320     /**
 321        Handle properties of a certain cell in the current row.
 322
 323        @paran i        index of the cell in the current row
 324        @param pProps   the properties
 325      */
 326     virtual void cellPropsByCell(unsigned int i, PropertiesPointer pProps);
 327
 328     /**
 329        Handle properties of the current row.
 330
 331        @param pProps   the properties
 332      */
 333     virtual void insertRowProps(PropertiesPointer pProps);
 334
 335     /**
 336        Handle properties of the current table.
 337
 338        @param pProps   the properties
 339      */
 340     virtual void insertTableProps(PropertiesPointer pProps);
 341
 342     /**
 343        Return if table manager has detected paragraph to ignore.
 344
 345        If this function returns true the current paragraph contains
 346        only control information, e.g. end of row.
 347      */
 348     virtual bool isIgnore() const;
 349 };
 350
 351 template <typename T, typename PropertiesPointer>
 352 TableManager<T, PropertiesPointer>::TableManager()
 353 : mbRowEnd(false), mbInCell(false), mbCellEnd(false), mnTableDepthNew(0),
 354   mnTableDepth(0)
 355 {
 356 }
 357
 358 template <typename T, typename PropertiesPointer>
 359 void TableManager<T, PropertiesPointer>::cellDepth(sal_uInt32 nDepth)
 360 {
 361     mnTableDepthNew = nDepth;
 362 }
 363
 364 template <typename T, typename PropertiesPointer>
 365 void TableManager<T, PropertiesPointer>::inCell()
 366 {
 367     mbInCell = true;
 368
 369     if (mnTableDepthNew < 1)
 370         mnTableDepthNew = 1;
 371 }
 372
 373 template <typename T, typename PropertiesPointer>
 374 void TableManager<T, PropertiesPointer>::endCell()
 375 {
 376     mbCellEnd = true;
 377 }
 378
 379 template <typename T, typename PropertiesPointer>
 380 void TableManager<T, PropertiesPointer>::endRow()
 381 {
 382     mbRowEnd = true;
 383 }
 384
 385 template <typename T, typename PropertiesPointer>
 386 void TableManager<T, PropertiesPointer>::setHandler
 387 (typename TableDataHandler<T, PropertiesPointer>::Pointer_t pTableDataHandler)
 388 {
 389     mpTableDataHandler = pTableDataHandler;
 390 }
 391
 392 template <typename T, typename PropertiesPointer>
 393 void TableManager<T, PropertiesPointer>::handle(const T & rHandle)
 394 {
 395     mCurHandle = rHandle;
 396 }
 397
 398 template <typename T, typename PropertiesPointer>
 399 void TableManager<T, PropertiesPointer>::startLevel()
 400 {
 401     typename TableData<T, PropertiesPointer>::Pointer_t pTableData
 402         (new TableData<T, PropertiesPointer>(mTableDataStack.size()));
 403
 404     mTableDataStack.push(pTableData);
 405 }
 406
 407 template <typename T, typename PropertiesPointer>
 408 void TableManager<T, PropertiesPointer>::endLevel()
 409 {
 410     if (mpTableDataHandler.get() != NULL)
 411         resolveCurrentTable();
 412
 413     mTableDataStack.pop();
 414 }
 415
 416 template <typename T, typename PropertiesPointer>
 417 void TableManager<T, PropertiesPointer>::startParagraphGroup()
 418 {
 419     mbRowEnd = false;
 420     mbInCell = false;
 421     mbCellEnd = false;
 422     mnTableDepthNew = 0;
 423 }
 424
 425 template <typename T, typename PropertiesPointer>
 426 void TableManager<T, PropertiesPointer>::endParagraphGroup()
 427 {
 428     sal_Int32 nTableDepthDifference = mnTableDepthNew - mnTableDepth;
 429     while (nTableDepthDifference > 0)
 430     {
 431         startLevel();
 432
 433         --nTableDepthDifference;
 434     }
 435     while (nTableDepthDifference < 0)
 436     {
 437         endLevel();
 438
 439         ++nTableDepthDifference;
 440     }
 441
 442     mnTableDepth = mnTableDepthNew;
 443
 444     typename TableData<T, PropertiesPointer>::Pointer_t pTableData =
 445         mTableDataStack.top();
 446
 447     if (mbRowEnd)
 448     {
 449         endOfRowAction();
 450         pTableData->endRow(mpRowProps);
 451         mpRowProps.reset();
 452     }
 453
 454     else if (mbInCell)
 455     {
 456         if (! pTableData->isCellOpen())
 457             pTableData->addCell(mCurHandle, mpCellProps);
 458
 459         if (mbCellEnd)
 460         {
 461             endOfCellAction();
 462             pTableData->endCell(mCurHandle);
 463         }
 464     }
 465     mpCellProps.reset();
 466 }
 467
 468 template <typename T, typename PropertiesPointer>
 469 bool TableManager<T, PropertiesPointer>::sprm(Sprm & rSprm)
 470 {
 471     bool bRet = true;
 472     switch (rSprm.getId())
 473     {
 474     case NS_sprm::LN_PTableDepth:
 475         {
 476             Value::Pointer_t pValue = rSprm.getValue();
 477
 478             cellDepth(pValue->getInt());
 479         }
 480         break;
 481     case NS_sprm::LN_PFInTable:
 482         inCell();
 483         break;
 484     case NS_sprm::LN_PCell:
 485         endCell();
 486         break;
 487     case NS_sprm::LN_PFTtp:
 488     case NS_sprm::LN_PRow:
 489         endRow();
 490         break;
 491     default:
 492         bRet = false;
 493     }
 494     return bRet;
 495 }
 496 template <typename T, typename PropertiesPointer>
 497 void TableManager<T, PropertiesPointer>::props(PropertiesPointer pProps)
 498 {
 499     mpProps = pProps;
 500 }
 501
 502 template <typename T, typename PropertiesPointer>
 503 void TableManager<T, PropertiesPointer>::handle0x7()
 504 {
 505     if (mnTableDepthNew < 1)
 506         mnTableDepthNew = 1;
 507
 508     if (mbInCell)
 509         endCell();
 510     else
 511         endRow();
 512 }
 513
 514 template <typename T, typename PropertiesPointer>
 515 void TableManager<T, PropertiesPointer>::text(const sal_uInt8 * data, size_t len)
 516 {
 517     // optimization: cell/row end characters are the last characters in a run
 518     if (len > 0)
 519     {
 520         if (data[len - 1] == 0x7)
 521             handle0x7();
 522     }
 523 }
 524
 525 template <typename T, typename PropertiesPointer>
 526 void TableManager<T, PropertiesPointer>::utext(const sal_uInt8 * data, size_t len)
 527 {
 528     // optimization: cell/row end characters are the last characters in a run
 529
 530     if (len > 0)
 531     {
 532         sal_Unicode nChar = data[(len - 1) * 2] + (data[(len - 1) * 2 + 1] << 8);
 533         if (nChar == 0x7)
 534             handle0x7();
 535     }
 536 }
 537
 538 template <typename T, typename PropertiesPointer>
 539 void TableManager<T, PropertiesPointer>::cellProps(PropertiesPointer pProps)
 540 {
 541     if(mpCellProps.get())
 542         mpCellProps->insert( pProps );
 543     else
 544         mpCellProps = pProps;
 545 }
 546
 547 template <typename T, typename PropertiesPointer>
 548 void TableManager<T, PropertiesPointer>::cellPropsByCell
 549 (unsigned int i, PropertiesPointer pProps)
 550 {
 551     mTableDataStack.top()->insertCellProperties(i, pProps);
 552 }
 553
 554 template <typename T, typename PropertiesPointer>
 555 void TableManager<T, PropertiesPointer>::insertRowProps(PropertiesPointer pProps)
 556 {
 557     if( mpRowProps.get() )
 558         mpRowProps->insert( pProps );
 559     else
 560         mpRowProps = pProps;
 561 }
 562
 563 template <typename T, typename PropertiesPointer>
 564 void TableManager<T, PropertiesPointer>::insertTableProps(PropertiesPointer pProps)
 565 {
 566     if( mpTableProps.get() )
 567         mpTableProps->insert( pProps );
 568     else
 569         mpTableProps = pProps;
 570 }
 571
 572 template <typename T, typename PropertiesPointer>
 573 void TableManager<T, PropertiesPointer>::resolveCurrentTable()
 574 {
 575     if (mpTableDataHandler.get() != NULL)
 576     {
 577         typename TableData<T, PropertiesPointer>::Pointer_t
 578             pTableData = mTableDataStack.top();
 579
 580         unsigned int nRows = pTableData->getRowCount();
 581
 582         mpTableDataHandler->startTable(nRows, pTableData->getDepth(), mpTableProps);
 583
 584         for (unsigned int nRow = 0; nRow < nRows; ++nRow)
 585         {
 586             typename RowData<T, PropertiesPointer>::Pointer_t pRowData = pTableData->getRow(nRow);
 587
 588             unsigned int nCells = pRowData->getCellCount();
 589
 590             mpTableDataHandler->startRow(nCells, pRowData->getProperties());
 591
 592             for (unsigned int nCell = 0; nCell < nCells; ++nCell)
 593             {
 594                 mpTableDataHandler->startCell
 595                     (pRowData->getCellStart(nCell),
 596                      pRowData->getCellProperties(nCell));
 597
 598                 mpTableDataHandler->endCell(pRowData->getCellEnd(nCell));
 599             }
 600
 601             mpTableDataHandler->endRow();
 602         }
 603
 604         mpTableDataHandler->endTable();
 605     }
 606     mpTableProps.reset();
 607     clearData();
 608 }
 609
 610 template <typename T, typename PropertiesPointer>
 611 void TableManager<T, PropertiesPointer>::endOfCellAction()
 612 {
 613 }
 614
 615 template <typename T, typename PropertiesPointer>
 616 void TableManager<T, PropertiesPointer>::endOfRowAction()
 617 {
 618 }
 619
 620 template <typename T, typename PropertiesPointer>
 621 bool TableManager<T, PropertiesPointer>::isIgnore() const
 622 {
 623     return mbRowEnd;
 624 }
 625 template <typename T, typename PropertiesPointer>
 626 void  TableManager<T, PropertiesPointer>::clearData()
 627 {
 628 }
 629
 630 }
 631
 632 #endif // INCLUDED_TABLE_MANAGER_HXX