writerfilter/inc/resourcemodel/TableManager.hxx

   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 #ifndef INCLUDED_WRITERFILTER_INC_RESOURCEMODEL_TABLEMANAGER_HXX
  21 #define INCLUDED_WRITERFILTER_INC_RESOURCEMODEL_TABLEMANAGER_HXX
  22
  23 #include <resourcemodel/TableData.hxx>
  24
  25 #include <resourcemodel/WW8ResourceModel.hxx>
  26
  27 #include <ooxml/resourceids.hxx>
  28
  29 #include <boost/shared_ptr.hpp>
  30 #include <stack>
  31 #include "util.hxx"
  32 #include "TagLogger.hxx"
  33
  34 #if OSL_DEBUG_LEVEL > 0
  35 #   include <rtl/strbuf.hxx>
  36 #endif
  37
  38 namespace writerfilter
  39 {
  40
  41 /**
  42    Class to handle events generated by TableManager::resolveCurrentTable
  43  */
  44 template <typename T, typename PropertiesPointer>
  45 class TableDataHandler
  46 {
  47 public:
  48     typedef boost::shared_ptr<TableDataHandler> Pointer_t;
  49
  50     /**
  51        Handle start of table.
  52
  53        @param nRows   number of rows in the table
  54        @param nDepth  depth of the table in surrounding table hierarchy
  55        @param pProps  properties of the table
  56      */
  57     virtual void startTable(unsigned int nRows, unsigned int nDepth,
  58                             PropertiesPointer pProps) = 0;
  59
  60     /**
  61        Handle end of table.
  62      */
  63     virtual void endTable(unsigned int nestedTableLevel) = 0;
  64
  65     /**
  66        Handle start of row.
  67
  68        @param nCols    number of columns in the table
  69        @param pProps   properties of the row
  70      */
  71     virtual void startRow(unsigned int nCols,
  72                           PropertiesPointer pProps) = 0;
  73
  74     /**
  75        Handle end of row.
  76     */
  77     virtual void endRow() = 0;
  78
  79     /**
  80        Handle start of cell.
  81
  82        @param rT     start handle of the cell
  83        @param pProps properties of the cell
  84     */
  85     virtual void startCell(const T & rT, PropertiesPointer pProps) = 0;
  86
  87     /**
  88         Handle end of cell.
  89
  90         @param rT    end handle of cell
  91     */
  92     virtual void endCell(const T & rT) = 0;
  93
  94 protected:
  95     ~TableDataHandler() {}
  96 };
  97
  98 template <typename T, typename PropertiesPointer>
  99 /**
 100    The table manager.
 101
 102    This class gets forwarded events from the tokenizer. It gathers the
 103    table data and after ending the table generates events for the
 104    table structure. The events have to be handles by a TableDataHandler.
 105
 106  */
 107 class TableManager
 108 {
 109 #ifdef DEBUG_TABLE
 110     TagLogger::Pointer_t mpTableLogger;
 111 #endif
 112
 113     class TableManagerState
 114     {
 115         /**
 116          properties at the current point in document
 117          */
 118         PropertiesPointer mpProps;
 119
 120         /**
 121          properties of the current cell
 122          */
 123         PropertiesPointer mpCellProps;
 124
 125         /**
 126          properties of the current row
 127          */
 128         PropertiesPointer mpRowProps;
 129
 130         /**
 131          properties of the current table
 132          */
 133         std::stack<PropertiesPointer> mTableProps;
 134
 135         /**
 136          true if at the end of a row
 137          */
 138         bool mbRowEnd;
 139
 140         /**
 141          true when in a cell
 142          */
 143         bool mbInCell;
 144
 145         /**
 146          true when at the end of a cell
 147          */
 148         bool mbCellEnd;
 149
 150     public:
 151         /**
 152          Constructor
 153          */
 154         TableManagerState()
 155         : mbRowEnd(false), mbInCell(false), mbCellEnd(false)
 156         {
 157         }
 158
 159         virtual ~TableManagerState()
 160         {
 161         }
 162
 163         void startLevel()
 164         {
 165             PropertiesPointer pProps;
 166             mTableProps.push(pProps);
 167         }
 168
 169         void endLevel()
 170         {
 171             mTableProps.pop();
 172         }
 173
 174         /**
 175          Reset to initial state at beginning of row.
 176          */
 177         void resetCellSpecifics()
 178         {
 179             mbRowEnd = false;
 180             mbInCell = false;
 181             mbCellEnd = false;
 182         }
 183
 184         void resetProps()
 185         {
 186             mpProps.reset();
 187         }
 188
 189         void setProps(PropertiesPointer pProps)
 190         {
 191             mpProps = pProps;
 192         }
 193
 194         PropertiesPointer getProps()
 195         {
 196             return mpProps;
 197         }
 198
 199         void resetCellProps()
 200         {
 201             mpCellProps.reset();
 202         }
 203
 204         void setCellProps(PropertiesPointer pProps)
 205         {
 206             mpCellProps = pProps;
 207         }
 208
 209         PropertiesPointer getCellProps()
 210         {
 211             return mpCellProps;
 212         }
 213
 214         void resetRowProps()
 215         {
 216             mpRowProps.reset();
 217         }
 218
 219         void setRowProps(PropertiesPointer pProps)
 220         {
 221             mpRowProps = pProps;
 222         }
 223
 224         PropertiesPointer getRowProps()
 225         {
 226             return mpRowProps;
 227         }
 228
 229         void resetTableProps()
 230         {
 231             if (mTableProps.size() > 0)
 232                 mTableProps.top().reset();
 233         }
 234
 235         void setTableProps(PropertiesPointer pProps)
 236         {
 237             if (mTableProps.size() > 0)
 238                 mTableProps.top() = pProps;
 239         }
 240
 241         PropertiesPointer getTableProps()
 242         {
 243             PropertiesPointer pResult;
 244
 245             if (mTableProps.size() > 0)
 246                 pResult = mTableProps.top();
 247
 248             return pResult;
 249         }
 250
 251         void setInCell(bool bInCell)
 252         {
 253             mbInCell = bInCell;
 254         }
 255
 256         bool isInCell() const
 257         {
 258             return mbInCell;
 259         }
 260
 261         void setCellEnd(bool bCellEnd)
 262         {
 263             mbCellEnd = bCellEnd;
 264         }
 265
 266         bool isCellEnd() const
 267         {
 268             return mbCellEnd;
 269         }
 270
 271         void setRowEnd(bool bRowEnd)
 272         {
 273             mbRowEnd = bRowEnd;
 274         }
 275
 276         bool isRowEnd() const
 277         {
 278             return mbRowEnd;
 279         }
 280     };
 281
 282     /**
 283      handle for the current position in document
 284      */
 285     T mCurHandle;
 286
 287     TableManagerState mState;
 288
 289 protected:
 290     PropertiesPointer getProps()
 291     {
 292         return mState.getProps();
 293     }
 294
 295     void setProps(PropertiesPointer pProps)
 296     {
 297         mState.setProps(pProps);
 298     }
 299
 300     void resetProps()
 301     {
 302         mState.resetProps();
 303     }
 304
 305     PropertiesPointer getCellProps()
 306     {
 307         return mState.getCellProps();
 308     }
 309
 310     void setCellProps(PropertiesPointer pProps)
 311     {
 312         mState.setCellProps(pProps);
 313     }
 314
 315     void resetCellProps()
 316     {
 317         mState.resetCellProps();
 318     }
 319
 320     PropertiesPointer getRowProps()
 321     {
 322         return mState.getRowProps();
 323     }
 324
 325     void setRowProps(PropertiesPointer pProps)
 326     {
 327         mState.setRowProps(pProps);
 328     }
 329
 330     void resetRowProps()
 331     {
 332         mState.resetRowProps();
 333     }
 334
 335     void setInCell(bool bInCell)
 336     {
 337         mState.setInCell(bInCell);
 338     }
 339
 340     bool isInCell() const
 341     {
 342         return mState.isInCell();
 343     }
 344
 345     void setCellEnd(bool bCellEnd)
 346     {
 347         mState.setCellEnd(bCellEnd);
 348     }
 349
 350     bool isCellEnd() const
 351     {
 352         return mState.isCellEnd();
 353     }
 354
 355     void setRowEnd(bool bRowEnd)
 356     {
 357         mState.setRowEnd(bRowEnd);
 358     }
 359
 360     bool isRowEnd() const
 361     {
 362         return mState.isRowEnd();
 363     }
 364
 365     PropertiesPointer getTableProps()
 366     {
 367         return mState.getTableProps();
 368     }
 369
 370     void setTableProps(PropertiesPointer pProps)
 371     {
 372         mState.setTableProps(pProps);
 373     }
 374
 375     void resetTableProps()
 376     {
 377         mState.resetTableProps();
 378     }
 379
 380     T getHandle()
 381     {
 382         return mCurHandle;
 383     }
 384
 385     void setHandle(const T & rHandle)
 386     {
 387         mCurHandle = rHandle;
 388     }
 389
 390 private:
 391     typedef boost::shared_ptr<T> T_p;
 392
 393     /**
 394        depth of the current cell
 395     */
 396     sal_uInt32 mnTableDepthNew;
 397
 398     /**
 399         depth of the previous cell
 400     */
 401     sal_uInt32 mnTableDepth;
 402
 403     /**
 404        stack of table data
 405
 406        for each level of nested tables there is one frame in the stack
 407      */
 408     std::stack<typename TableData<T, PropertiesPointer>::Pointer_t > mTableDataStack;
 409     typename RowData<T, PropertiesPointer>::Pointer_t mpUnfinishedRow;
 410     bool mbKeepUnfinishedRow;
 411
 412     typedef typename TableDataHandler<T, PropertiesPointer>::Pointer_t TableDataHandlerPointer_t;
 413
 414     /**
 415        handler for resolveCurrentTable
 416      */
 417     TableDataHandlerPointer_t mpTableDataHandler;
 418
 419     /**
 420        Set flag which indicates the current handle is in a cell.
 421      */
 422     void inCell();
 423
 424     /**
 425        Set flag which indicate the current handle is at the end of a cell.
 426     */
 427     void endCell();
 428
 429     /**
 430        Set the table depth of the current cell.
 431
 432        @param nDepth     the cell depth
 433      */
 434     void cellDepth(sal_uInt32 nDepth);
 435
 436     /**
 437        Set flag indication the current handle is at the end of a row.
 438     */
 439     void endRow();
 440
 441     /**
 442        Resolve the current table to the TableDataHandler.
 443      */
 444     void resolveCurrentTable();
 445
 446     /**
 447      Open a cell at current level.
 448      */
 449
 450     void openCell(const T & handle, PropertiesPointer pProps);
 451
 452     /**
 453      Close a cell at current level.
 454      */
 455     void closeCell(const T & handle);
 456
 457     /**
 458      Ensure a cell is open at the current level.
 459     */
 460     void ensureOpenCell(PropertiesPointer pProps);
 461
 462 protected:
 463
 464     /**
 465        Return current table depth.
 466      */
 467     sal_uInt32 getTableDepthNew() { return mnTableDepthNew; }
 468
 469     /**
 470        Return the current table difference, i.e. 1 if we are in the first cell of a new table, etc.
 471      */
 472     sal_uInt32 getTableDepthDifference() { return mnTableDepthNew - mnTableDepth; }
 473
 474     /**
 475        Action to be carried out at the end of the last paragraph of a
 476        cell.
 477      */
 478     virtual void endOfCellAction();
 479
 480     /**
 481        Action to be carried out at the end of the "table row"
 482        paragraph.
 483      */
 484     virtual void endOfRowAction();
 485     /** let the derived class clear their table related data
 486      */
 487     virtual void clearData();
 488
 489     /** Should we keep the unfinished row in endLevel to initialize the table
 490         data in the following startLevel.
 491       */
 492     void setKeepUnfinishedRow(bool bKeep)
 493     {
 494         mbKeepUnfinishedRow = bKeep;
 495     }
 496
 497
 498 public:
 499     TableManager();
 500     virtual ~TableManager(){}
 501
 502     /**
 503        Set handler for resolveCurrentTable.
 504
 505        @param pTableDataHandler     the handler
 506      */
 507     void setHandler(TableDataHandlerPointer_t pTableDataHandler);
 508
 509     /**
 510        Set the current handle.
 511
 512        @param rHandle     the handle
 513      */
 514     virtual void handle(const T & rHandle);
 515
 516     /**
 517        Start a new table level.
 518
 519        A new context is pushed onto the table data stack,
 520      */
 521     virtual void startLevel();
 522
 523     /**
 524        End a table level.
 525
 526        The current table is resolved and the context is popped from
 527        the stack.
 528      */
 529     virtual void endLevel();
 530
 531     /**
 532      * Signal that the next paragraph definitely won't be part of any table.
 533      */
 534     void endTable()
 535     {
 536         setRowEnd(false);
 537     }
 538
 539     /**
 540        Tells whether a table has been started or not
 541       */
 542     bool isInTable();
 543
 544     /**
 545        Handle the start of a paragraph group.
 546      */
 547     virtual void startParagraphGroup();
 548
 549     /**
 550        Handle the end of a paragraph group.
 551     */
 552     virtual void endParagraphGroup();
 553
 554     /**
 555        Handle an SPRM at curent handle.
 556
 557        @param rSprm   the SPRM
 558      */
 559     virtual bool sprm(Sprm & rSprm);
 560
 561     /**
 562        Handle properties at current handle.
 563
 564        @param pProps   the properites
 565      */
 566     virtual void props(PropertiesPointer pProps);
 567
 568     /**
 569        Handle occurrence of character 0x7.
 570      */
 571     virtual void handle0x7();
 572
 573     /**
 574        Handle 8 bit text at current handle.
 575
 576        @param data    array of characters
 577        @param len     number of characters to handle
 578      */
 579     virtual void text(const sal_uInt8 * data, size_t len);
 580
 581     /**
 582        Handle 16 bit text at current handle.
 583
 584        @param data    array of characters
 585        @param len     number of characters to handle
 586      */
 587     virtual void utext(const sal_uInt8 * data, size_t len);
 588
 589     /**
 590        Handle properties of the current cell.
 591
 592        @param pProps   the properties
 593      */
 594     virtual void cellProps(PropertiesPointer pProps);
 595
 596     /**
 597        Handle properties of a certain cell in the current row.
 598
 599        @paran i        index of the cell in the current row
 600        @param pProps   the properties
 601      */
 602     virtual void cellPropsByCell(unsigned int i, PropertiesPointer pProps);
 603
 604     /**
 605        Handle properties of the current row.
 606
 607        @param pProps   the properties
 608      */
 609     virtual void insertRowProps(PropertiesPointer pProps);
 610
 611     /**
 612        Handle properties of the current table.
 613
 614        @param pProps   the properties
 615      */
 616     virtual void insertTableProps(PropertiesPointer pProps);
 617
 618     /**
 619        Return if table manager has detected paragraph to ignore.
 620
 621        If this function returns true the current paragraph contains
 622        only control information, e.g. end of row.
 623      */
 624     virtual bool isIgnore() const;
 625
 626
 627 #ifdef DEBUG_TABLE
 628     void setTagLogger(TagLogger::Pointer_t _tagLogger)
 629     {
 630         mpTableLogger = _tagLogger;
 631     }
 632 #endif
 633 };
 634
 635 template <typename T, typename PropertiesPointer>
 636 TableManager<T, PropertiesPointer>::TableManager()
 637 : mnTableDepthNew(0), mnTableDepth(0), mbKeepUnfinishedRow( false )
 638 {
 639     setRowEnd(false);
 640     setInCell(false);
 641     setCellEnd(false);
 642 }
 643
 644 template <typename T, typename PropertiesPointer>
 645 void TableManager<T, PropertiesPointer>::cellDepth(sal_uInt32 nDepth)
 646 {
 647 #ifdef DEBUG_TABLE
 648     if (mpTableLogger != NULL)
 649     {
 650         mpTableLogger->startElement("tablemanager.cellDepth");
 651         mpTableLogger->attribute("depth", nDepth);
 652         mpTableLogger->endElement();
 653     }
 654 #endif
 655
 656     mnTableDepthNew = nDepth;
 657 }
 658
 659 template <typename T, typename PropertiesPointer>
 660 void TableManager<T, PropertiesPointer>::inCell()
 661 {
 662 #ifdef DEBUG_TABLE
 663     if (mpTableLogger != NULL)
 664         mpTableLogger->element("tablemanager.inCell");
 665 #endif
 666     setInCell(true);
 667
 668     if (mnTableDepthNew < 1)
 669         mnTableDepthNew = 1;
 670 }
 671
 672 template <typename T, typename PropertiesPointer>
 673 void TableManager<T, PropertiesPointer>::endCell()
 674 {
 675 #ifdef DEBUG_TABLE
 676     if (mpTableLogger != NULL)
 677         mpTableLogger->element("tablemanager.endCell");
 678 #endif
 679
 680     setCellEnd(true);
 681 }
 682
 683 template <typename T, typename PropertiesPointer>
 684 void TableManager<T, PropertiesPointer>::endRow()
 685 {
 686 #ifdef DEBUG_TABLE
 687     if (mpTableLogger != NULL)
 688         mpTableLogger->element("tablemanager.endRow");
 689 #endif
 690
 691     setRowEnd(true);
 692 }
 693
 694 template <typename T, typename PropertiesPointer>
 695 void TableManager<T, PropertiesPointer>::setHandler
 696 (typename TableDataHandler<T, PropertiesPointer>::Pointer_t pTableDataHandler)
 697 {
 698     mpTableDataHandler = pTableDataHandler;
 699 }
 700
 701 template <typename T, typename PropertiesPointer>
 702 void TableManager<T, PropertiesPointer>::handle(const T & rHandle)
 703 {
 704 #ifdef DEBUG_TABLE
 705     if (mpTableLogger)
 706     {
 707         mpTableLogger->startElement("tablemanager.handle");
 708         mpTableLogger->chars(toString(rHandle));
 709         mpTableLogger->endElement();
 710     }
 711 #endif
 712
 713     setHandle(rHandle);
 714 }
 715
 716 template <typename T, typename PropertiesPointer>
 717 bool TableManager<T, PropertiesPointer>::isInTable()
 718 {
 719     bool bInTable = false;
 720     if ( !mTableDataStack.empty() )
 721         bInTable = mTableDataStack.top()->getDepth() > 0;
 722     return bInTable;
 723 }
 724
 725 template <typename T, typename PropertiesPointer>
 726 void TableManager<T, PropertiesPointer>::startLevel()
 727 {
 728 #ifdef DEBUG_TABLE
 729     if (mpTableLogger != NULL)
 730     {
 731         typename TableData<T, PropertiesPointer>::Pointer_t pTableData;
 732
 733         if (mTableDataStack.size() > 0)
 734             pTableData = mTableDataStack.top();
 735
 736         mpTableLogger->startElement("tablemanager.startLevel");
 737         mpTableLogger->attribute("level", mTableDataStack.size());
 738
 739         if (pTableData.get() != NULL)
 740             mpTableLogger->attribute("openCell",
 741                                      pTableData->isCellOpen() ? "yes" : "no");
 742
 743         mpTableLogger->endElement();
 744     }
 745 #endif
 746
 747     typename TableData<T, PropertiesPointer>::Pointer_t pTableData
 748         (new TableData<T, PropertiesPointer>(mTableDataStack.size()));
 749
 750     // If we have an unfinished row stored here, then push it to the new TableData
 751     if ( mpUnfinishedRow )
 752     {
 753         for (unsigned int i = 0; i < mpUnfinishedRow->getCellCount(); ++i)
 754         {
 755             pTableData->addCell( mpUnfinishedRow->getCellStart(i),
 756                                  mpUnfinishedRow->getCellProperties(i) );
 757             pTableData->endCell( mpUnfinishedRow->getCellEnd(i) );
 758         }
 759         mpUnfinishedRow.reset();
 760     }
 761
 762     mTableDataStack.push(pTableData);
 763     mState.startLevel();
 764 }
 765
 766 template <typename T, typename PropertiesPointer>
 767 void TableManager<T, PropertiesPointer>::endLevel()
 768 {
 769     if (mpTableDataHandler.get() != NULL)
 770         resolveCurrentTable();
 771
 772     // Store the unfinished row as it will be used for the next table
 773     if ( mbKeepUnfinishedRow )
 774         mpUnfinishedRow = mTableDataStack.top()->getCurrentRow();
 775     mState.endLevel();
 776     mTableDataStack.pop();
 777
 778 #ifdef DEBUG_TABLE
 779     if (mpTableLogger != NULL)
 780     {
 781         typename TableData<T, PropertiesPointer>::Pointer_t pTableData;
 782
 783         if (mTableDataStack.size() > 0)
 784             pTableData = mTableDataStack.top();
 785
 786         mpTableLogger->startElement("tablemanager.endLevel");
 787         mpTableLogger->attribute("level", mTableDataStack.size());
 788
 789         if (pTableData.get() != NULL)
 790             mpTableLogger->attribute("openCell",
 791                                      pTableData->isCellOpen() ? "yes" : "no");
 792
 793         mpTableLogger->endElement();
 794     }
 795 #endif
 796 }
 797
 798 template <typename T, typename PropertiesPointer>
 799 void TableManager<T, PropertiesPointer>::startParagraphGroup()
 800 {
 801     mState.resetCellSpecifics();
 802     mnTableDepthNew = 0;
 803 }
 804
 805 template <typename T, typename PropertiesPointer>
 806 void TableManager<T, PropertiesPointer>::endParagraphGroup()
 807 {
 808     sal_Int32 nTableDepthDifference = mnTableDepthNew - mnTableDepth;
 809
 810     PropertiesPointer pEmptyProps;
 811
 812     while (nTableDepthDifference > 0)
 813     {
 814         ensureOpenCell(pEmptyProps);
 815         startLevel();
 816
 817         --nTableDepthDifference;
 818     }
 819     while (nTableDepthDifference < 0)
 820     {
 821         endLevel();
 822
 823         ++nTableDepthDifference;
 824     }
 825
 826     mnTableDepth = mnTableDepthNew;
 827
 828     if (mnTableDepth > 0)
 829     {
 830         typename TableData<T, PropertiesPointer>::Pointer_t pTableData =
 831         mTableDataStack.top();
 832
 833         if (isRowEnd())
 834         {
 835             endOfRowAction();
 836             mTableDataStack.top()->endRow(getRowProps());
 837             resetRowProps();
 838         }
 839
 840         else if (isInCell())
 841         {
 842             ensureOpenCell(getCellProps());
 843
 844             if (isCellEnd())
 845             {
 846                 endOfCellAction();
 847                 closeCell(getHandle());
 848             }
 849         }
 850         resetCellProps();
 851     }
 852 }
 853
 854 template <typename T, typename PropertiesPointer>
 855 bool TableManager<T, PropertiesPointer>::sprm(Sprm & rSprm)
 856 {
 857     bool bRet = true;
 858     switch (rSprm.getId())
 859     {
 860     case NS_ooxml::LN_tblDepth:
 861         {
 862             Value::Pointer_t pValue = rSprm.getValue();
 863
 864             cellDepth(pValue->getInt());
 865         }
 866         break;
 867     case NS_ooxml::LN_inTbl:
 868         inCell();
 869         break;
 870     case NS_ooxml::LN_tblCell:
 871         endCell();
 872         break;
 873     case NS_ooxml::LN_tblRow:
 874         endRow();
 875         break;
 876     default:
 877         bRet = false;
 878     }
 879     return bRet;
 880 }
 881 template <typename T, typename PropertiesPointer>
 882 void TableManager<T, PropertiesPointer>::props(PropertiesPointer pProps)
 883 {
 884     setProps(pProps);
 885 }
 886
 887 template <typename T, typename PropertiesPointer>
 888 void TableManager<T, PropertiesPointer>::handle0x7()
 889 {
 890 #ifdef DEBUG_TABLE
 891     if (mpTableLogger != NULL)
 892         mpTableLogger->startElement("tablemanager.handle0x7");
 893 #endif
 894
 895     if (mnTableDepthNew < 1)
 896         mnTableDepthNew = 1;
 897
 898     if (isInCell())
 899         endCell();
 900     else
 901         endRow();
 902
 903 #ifdef DEBUG_TABLE
 904     if (mpTableLogger != NULL)
 905         mpTableLogger->endElement();
 906 #endif
 907 }
 908
 909 template <typename T, typename PropertiesPointer>
 910 void TableManager<T, PropertiesPointer>::text(const sal_uInt8 * data, size_t len)
 911 {
 912     // optimization: cell/row end characters are the last characters in a run
 913     if (len > 0)
 914     {
 915         if (data[len - 1] == 0x7)
 916             handle0x7();
 917     }
 918 }
 919
 920 template <typename T, typename PropertiesPointer>
 921 void TableManager<T, PropertiesPointer>::utext(const sal_uInt8 * data, size_t len)
 922 {
 923     // optimization: cell/row end characters are the last characters in a run
 924
 925     if (len > 0)
 926     {
 927         sal_Unicode nChar = data[(len - 1) * 2] + (data[(len - 1) * 2 + 1] << 8);
 928         if (nChar == 0x7)
 929             handle0x7();
 930     }
 931 }
 932
 933 template <typename T, typename PropertiesPointer>
 934 void TableManager<T, PropertiesPointer>::cellProps(PropertiesPointer pProps)
 935 {
 936 #ifdef DEBUG_TABLE
 937     if (mpTableLogger != NULL)
 938         mpTableLogger->startElement("tablemanager.cellProps");
 939 #endif
 940
 941     if(getCellProps().get())
 942         getCellProps()->InsertProps(pProps);
 943     else
 944         setCellProps(pProps);
 945
 946 #ifdef DEBUG_TABLE
 947     if (mpTableLogger != NULL)
 948         mpTableLogger->endElement();
 949 #endif
 950 }
 951
 952 template <typename T, typename PropertiesPointer>
 953 void TableManager<T, PropertiesPointer>::cellPropsByCell
 954 (unsigned int i, PropertiesPointer pProps)
 955 {
 956 #ifdef DEBUG_TABLE
 957     if (mpTableLogger != NULL)
 958         mpTableLogger->startElement("tablemanager.cellPropsByCell");
 959 #endif
 960
 961     mTableDataStack.top()->insertCellProperties(i, pProps);
 962
 963 #ifdef DEBUG_TABLE
 964     if (mpTableLogger != NULL)
 965         mpTableLogger->endElement();
 966 #endif
 967 }
 968
 969 template <typename T, typename PropertiesPointer>
 970 void TableManager<T, PropertiesPointer>::insertRowProps(PropertiesPointer pProps)
 971 {
 972 #ifdef DEBUG_TABLE
 973     if (mpTableLogger != NULL)
 974         mpTableLogger->startElement("tablemanager.insertRowProps");
 975 #endif
 976
 977     if( getRowProps().get() )
 978         getRowProps()->InsertProps(pProps);
 979     else
 980         setRowProps(pProps);
 981
 982 #ifdef DEBUG_TABLE
 983     if (mpTableLogger != NULL)
 984         mpTableLogger->endElement();
 985 #endif
 986 }
 987
 988 template <typename T, typename PropertiesPointer>
 989 void TableManager<T, PropertiesPointer>::insertTableProps(PropertiesPointer pProps)
 990 {
 991 #ifdef DEBUG_TABLE
 992     if (mpTableLogger != NULL)
 993         mpTableLogger->startElement("tablemanager.insertTableProps");
 994 #endif
 995
 996     if( getTableProps().get() && getTableProps() != pProps)
 997         getTableProps()->InsertProps(pProps);
 998     else
 999         setTableProps(pProps);
1000
1001 #ifdef DEBUG_TABLE
1002     if (mpTableLogger != NULL)
1003         mpTableLogger->endElement();
1004 #endif
1005 }
1006
1007 template <typename T, typename PropertiesPointer>
1008 void TableManager<T, PropertiesPointer>::resolveCurrentTable()
1009 {
1010 #ifdef DEBUG_TABLE
1011     if (mpTableLogger != NULL)
1012         mpTableLogger->startElement("tablemanager.resolveCurrentTable");
1013 #endif
1014
1015     if (mpTableDataHandler.get() != NULL)
1016     {
1017         try
1018         {
1019             typename TableData<T, PropertiesPointer>::Pointer_t
1020                 pTableData = mTableDataStack.top();
1021
1022             unsigned int nRows = pTableData->getRowCount();
1023
1024             mpTableDataHandler->startTable(nRows, pTableData->getDepth(), getTableProps());
1025
1026             for (unsigned int nRow = 0; nRow < nRows; ++nRow)
1027             {
1028                 typename RowData<T, PropertiesPointer>::Pointer_t pRowData = pTableData->getRow(nRow);
1029
1030                 unsigned int nCells = pRowData->getCellCount();
1031
1032                 mpTableDataHandler->startRow(nCells, pRowData->getProperties());
1033
1034                 for (unsigned int nCell = 0; nCell < nCells; ++nCell)
1035                 {
1036                     mpTableDataHandler->startCell
1037                         (pRowData->getCellStart(nCell),
1038                         pRowData->getCellProperties(nCell));
1039
1040                     mpTableDataHandler->endCell(pRowData->getCellEnd(nCell));
1041                 }
1042
1043                 mpTableDataHandler->endRow();
1044             }
1045
1046             mpTableDataHandler->endTable(mTableDataStack.size() - 1);
1047         }
1048         catch (css::uno::Exception const& e)
1049         {
1050             (void) e;
1051 #if OSL_DEBUG_LEVEL > 0
1052             SAL_WARN("writerfilter", "resolving of current table failed with: " << e.Message);
1053 #endif
1054         }
1055     }
1056     resetTableProps();
1057     clearData();
1058
1059 #ifdef DEBUG_TABLE
1060     if (mpTableLogger != NULL)
1061         mpTableLogger->endElement();
1062 #endif
1063 }
1064
1065 template <typename T, typename PropertiesPointer>
1066 void TableManager<T, PropertiesPointer>::endOfCellAction()
1067 {
1068 }
1069
1070 template <typename T, typename PropertiesPointer>
1071 void TableManager<T, PropertiesPointer>::endOfRowAction()
1072 {
1073 }
1074
1075 template <typename T, typename PropertiesPointer>
1076 bool TableManager<T, PropertiesPointer>::isIgnore() const
1077 {
1078     return isRowEnd();
1079 }
1080
1081 template <typename T, typename PropertiesPointer>
1082 void  TableManager<T, PropertiesPointer>::clearData()
1083 {
1084 }
1085
1086 template <typename T, typename PropertiesPointer>
1087 void  TableManager<T, PropertiesPointer>::openCell
1088 (const T & rHandle, PropertiesPointer pProps)
1089 {
1090 #ifdef DEBUG_TABLE
1091     mpTableLogger->startElement("tablemanager.openCell");
1092     mpTableLogger->chars(toString(rHandle));
1093     mpTableLogger->endElement();
1094 #endif
1095
1096     if (mTableDataStack.size() > 0)
1097     {
1098         typename TableData<T, PropertiesPointer>::Pointer_t
1099         pTableData = mTableDataStack.top();
1100
1101         pTableData->addCell(rHandle, pProps);
1102     }
1103 }
1104
1105 template <typename T, typename PropertiesPointer>
1106 void  TableManager<T, PropertiesPointer>::closeCell
1107 (const T & rHandle)
1108 {
1109 #ifdef DEBUG_TABLE
1110     mpTableLogger->startElement("tablemanager.closeCell");
1111     mpTableLogger->chars(toString(rHandle));
1112     mpTableLogger->endElement();
1113 #endif
1114
1115     if (mTableDataStack.size() > 0)
1116     {
1117         typename TableData<T, PropertiesPointer>::Pointer_t
1118         pTableData = mTableDataStack.top();
1119
1120         pTableData->endCell(rHandle);
1121     }
1122 }
1123
1124 template <typename T, typename PropertiesPointer>
1125 void  TableManager<T, PropertiesPointer>::ensureOpenCell(PropertiesPointer pProps)
1126 {
1127 #ifdef DEBUG_TABLE
1128     mpTableLogger->startElement("tablemanager.ensureOpenCell");
1129 #endif
1130
1131     if (mTableDataStack.size() > 0)
1132     {
1133         typename TableData<T, PropertiesPointer>::Pointer_t
1134         pTableData = mTableDataStack.top();
1135
1136         if (pTableData.get() != NULL)
1137         {
1138             if (!pTableData->isCellOpen())
1139                 openCell(getHandle(), pProps);
1140             else
1141                 pTableData->insertCellProperties(pProps);
1142         }
1143     }
1144 #ifdef DEBUG_TABLE
1145     mpTableLogger->endElement();
1146 #endif
1147 }
1148
1149 }
1150
1151 #endif // INCLUDED_WRITERFILTER_INC_RESOURCEMODEL_TABLEMANAGER_HXX
1152
1153 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */