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