| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| #ifndef INCLUDED_TABLE_MANAGER_HXX |
| #define INCLUDED_TABLE_MANAGER_HXX |
| |
| #include <resourcemodel/TableData.hxx> |
| #include <resourcemodel/WW8ResourceModel.hxx> |
| #include <doctok/sprmids.hxx> |
| |
| #include <boost/shared_ptr.hpp> |
| #include <stack> |
| #include "util.hxx" |
| #include "TagLogger.hxx" |
| |
| namespace writerfilter |
| { |
| |
| using namespace ::std; |
| |
| template <typename T, typename PropertiesPointer> |
| /** |
| Class to handle events generated by TableManager::resolveCurrentTable |
| */ |
| class WRITERFILTER_DLLPUBLIC TableDataHandler |
| { |
| public: |
| typedef boost::shared_ptr<TableDataHandler> Pointer_t; |
| |
| /** |
| Handle start of table. |
| |
| @param nRows number of rows in the table |
| @param nDepth depth of the table in surrounding table hierarchy |
| @param pProps properties of the table |
| */ |
| virtual void startTable( |
| unsigned int nRows, |
| unsigned int nDepth, |
| PropertiesPointer pProps ) = 0; |
| |
| /** |
| Handle end of table. |
| */ |
| virtual void endTable( |
| const unsigned int nDepth ) = 0; |
| |
| /** |
| Handle start of row. |
| |
| @param nCols number of columns in the table |
| @param pProps properties of the row |
| */ |
| virtual void startRow( |
| unsigned int nCols, |
| PropertiesPointer pProps ) = 0; |
| |
| /** |
| Handle end of row. |
| */ |
| virtual void endRow() = 0; |
| |
| /** |
| Handle start of cell. |
| |
| @param rT start handle of the cell |
| @param pProps properties of the cell |
| */ |
| virtual void startCell( |
| const T & rT, |
| PropertiesPointer pProps ) = 0; |
| |
| /** |
| Handle end of cell. |
| |
| @param rT end handle of cell |
| */ |
| virtual void endCell( |
| const T & rT ) = 0; |
| }; |
| |
| template <typename T, typename PropertiesPointer> |
| /** |
| The table manager. |
| |
| This class gets forwarded events from the tokenizer. It gathers the |
| table data and after ending the table generates events for the |
| table structure. The events have to be handles by a TableDataHandler. |
| |
| */ |
| class TableManager |
| { |
| #ifdef DEBUG_TABLE |
| TagLogger::Pointer_t mpTableLogger; |
| #endif |
| |
| class TableManagerState |
| { |
| /** |
| properties at the current point in document |
| */ |
| PropertiesPointer mpProps; |
| |
| /** |
| properties of the current cell |
| */ |
| PropertiesPointer mpCellProps; |
| |
| /** |
| properties of the current row |
| */ |
| PropertiesPointer mpRowProps; |
| |
| /** |
| properties of the current table |
| */ |
| stack<PropertiesPointer> mTableProps; |
| |
| /** |
| true if at the end of a row |
| */ |
| bool mbRowEnd; |
| |
| /** |
| true when in a cell |
| */ |
| bool mbInCell; |
| |
| /** |
| true when at the end of a cell |
| */ |
| bool mbCellEnd; |
| |
| public: |
| /** |
| Constructor |
| */ |
| TableManagerState() |
| : mbRowEnd(false), mbInCell(false), mbCellEnd(false) |
| { |
| } |
| |
| virtual ~TableManagerState() |
| { |
| } |
| |
| void startLevel() |
| { |
| PropertiesPointer pProps; |
| mTableProps.push(pProps); |
| } |
| |
| void endLevel() |
| { |
| mTableProps.pop(); |
| } |
| |
| /** |
| Reset to initial state at beginning of row. |
| */ |
| void resetCellSpecifics() |
| { |
| mbRowEnd = false; |
| mbInCell = false; |
| mbCellEnd = false; |
| } |
| |
| void resetProps() |
| { |
| mpProps.reset(); |
| } |
| |
| void setProps(PropertiesPointer pProps) |
| { |
| mpProps = pProps; |
| } |
| |
| PropertiesPointer getProps() |
| { |
| return mpProps; |
| } |
| |
| void resetCellProps() |
| { |
| mpCellProps.reset(); |
| } |
| |
| void setCellProps(PropertiesPointer pProps) |
| { |
| mpCellProps = pProps; |
| } |
| |
| PropertiesPointer getCellProps() |
| { |
| return mpCellProps; |
| } |
| |
| void resetRowProps() |
| { |
| mpRowProps.reset(); |
| } |
| |
| void setRowProps(PropertiesPointer pProps) |
| { |
| mpRowProps = pProps; |
| } |
| |
| PropertiesPointer getRowProps() |
| { |
| return mpRowProps; |
| } |
| |
| void resetTableProps() |
| { |
| if (mTableProps.size() > 0) |
| mTableProps.top().reset(); |
| } |
| |
| void setTableProps(PropertiesPointer pProps) |
| { |
| if (mTableProps.size() > 0) |
| mTableProps.top() = pProps; |
| } |
| |
| PropertiesPointer getTableProps() |
| { |
| PropertiesPointer pResult; |
| |
| if (mTableProps.size() > 0) |
| pResult = mTableProps.top(); |
| |
| return pResult; |
| } |
| |
| void setInCell(bool bInCell) |
| { |
| mbInCell = bInCell; |
| } |
| |
| bool isInCell() const |
| { |
| return mbInCell; |
| } |
| |
| void setCellEnd(bool bCellEnd) |
| { |
| mbCellEnd = bCellEnd; |
| } |
| |
| bool isCellEnd() const |
| { |
| return mbCellEnd; |
| } |
| |
| void setRowEnd(bool bRowEnd) |
| { |
| mbRowEnd = bRowEnd; |
| } |
| |
| bool isRowEnd() const |
| { |
| return mbRowEnd; |
| } |
| }; |
| |
| /** |
| handle for the current position in document |
| */ |
| T mCurHandle; |
| |
| TableManagerState mState; |
| |
| protected: |
| PropertiesPointer getProps() |
| { |
| return mState.getProps(); |
| } |
| |
| void setProps( |
| PropertiesPointer pProps ) |
| { |
| mState.setProps( pProps ); |
| } |
| |
| void resetProps() |
| { |
| mState.resetProps(); |
| } |
| |
| PropertiesPointer getCellProps() |
| { |
| return mState.getCellProps(); |
| } |
| |
| void setCellProps( |
| PropertiesPointer pProps ) |
| { |
| mState.setCellProps( pProps ); |
| } |
| |
| void resetCellProps() |
| { |
| mState.resetCellProps(); |
| } |
| |
| PropertiesPointer getRowProps() |
| { |
| return mState.getRowProps(); |
| } |
| |
| void setRowProps( |
| PropertiesPointer pProps ) |
| { |
| mState.setRowProps( pProps ); |
| } |
| |
| void resetRowProps() |
| { |
| mState.resetRowProps(); |
| } |
| |
| void setInCell( |
| bool bInCell ) |
| { |
| mState.setInCell( bInCell ); |
| } |
| |
| bool isInCell() const |
| { |
| return mState.isInCell(); |
| } |
| |
| void setCellEnd( |
| bool bCellEnd ) |
| { |
| mState.setCellEnd( bCellEnd ); |
| } |
| |
| bool isCellEnd() const |
| { |
| return mState.isCellEnd(); |
| } |
| |
| void setRowEnd( |
| bool bRowEnd ) |
| { |
| mState.setRowEnd( bRowEnd ); |
| } |
| |
| bool isRowEnd() const |
| { |
| return mState.isRowEnd(); |
| } |
| |
| PropertiesPointer getTableProps() |
| { |
| return mState.getTableProps(); |
| } |
| |
| void setTableProps( |
| PropertiesPointer pProps ) |
| { |
| mState.setTableProps( pProps ); |
| } |
| |
| void resetTableProps() |
| { |
| mState.resetTableProps(); |
| } |
| |
| T getHandle() |
| { |
| return mCurHandle; |
| } |
| |
| void setHandle( |
| const T & rHandle ) |
| { |
| mCurHandle = rHandle; |
| } |
| |
| private: |
| typedef boost::shared_ptr<T> T_p; |
| |
| /** |
| depth of the current cell |
| */ |
| sal_uInt32 mnTableDepthNew; |
| |
| /** |
| depth of the previous cell |
| */ |
| sal_uInt32 mnTableDepth; |
| |
| /** |
| stack of table data |
| |
| for each level of nested tables there is one frame in the stack |
| */ |
| stack<typename TableData<T, PropertiesPointer>::Pointer_t > mTableDataStack; |
| |
| typedef typename TableDataHandler<T, PropertiesPointer>::Pointer_t TableDataHandlerPointer_t; |
| |
| /** |
| handler for resolveCurrentTable |
| */ |
| TableDataHandlerPointer_t mpTableDataHandler; |
| |
| /** |
| Set flag which indicates the current handle is in a cell. |
| */ |
| void inCell(); |
| |
| /** |
| Set flag which indicate the current handle is at the end of a cell. |
| */ |
| void endCell(); |
| |
| /** |
| Set the table depth of the current cell. |
| |
| @param nDepth the cell depth |
| */ |
| void cellDepth(sal_uInt32 nDepth); |
| |
| /** |
| Set flag indication the current handle is at the end of a row. |
| */ |
| void endRow(); |
| |
| /** |
| Resolve the current table to the TableDataHandler. |
| */ |
| void resolveCurrentTable(); |
| |
| /** |
| Open a cell at current level. |
| */ |
| |
| void openCell(const T & handle, PropertiesPointer pProps); |
| |
| /** |
| Close a cell at current level. |
| */ |
| void closeCell(const T & handle); |
| |
| /** |
| Ensure a cell is open at the current level. |
| */ |
| void ensureOpenCell(PropertiesPointer pProps); |
| |
| protected: |
| |
| /** |
| Return current table depth. |
| */ |
| sal_uInt32 getTableDepthNew() { return mnTableDepthNew; } |
| |
| /** |
| Action to be carried out at the end of the last paragraph of a |
| cell. |
| */ |
| virtual void endOfCellAction(); |
| |
| /** |
| Action to be carried out at the end of the "table row" |
| paragraph. |
| */ |
| virtual void endOfRowAction(); |
| |
| |
| public: |
| TableManager(); |
| virtual ~TableManager(){} |
| |
| /** |
| Set handler for resolveCurrentTable. |
| |
| @param pTableDataHandler the handler |
| */ |
| void setHandler(TableDataHandlerPointer_t pTableDataHandler); |
| |
| /** |
| Set the current handle. |
| |
| @param rHandle the handle |
| */ |
| virtual void handle(const T & rHandle); |
| |
| /** |
| Start a new table level. |
| |
| A new context is pushed onto the table data stack, |
| */ |
| virtual void startLevel(); |
| |
| /** |
| End a table level. |
| |
| The current table is resolved and the context is popped from |
| the stack. |
| */ |
| virtual void endLevel(); |
| |
| /** |
| Handle the start of a paragraph group. |
| */ |
| virtual void startParagraphGroup(); |
| |
| /** |
| Handle the end of a paragraph group. |
| */ |
| virtual void endParagraphGroup(); |
| |
| /** |
| Handle an SPRM at curent handle. |
| |
| @param rSprm the SPRM |
| */ |
| virtual bool sprm(Sprm & rSprm); |
| |
| /** |
| Handle properties at current handle. |
| |
| @param pProps the properites |
| */ |
| virtual void props(PropertiesPointer pProps); |
| |
| /** |
| Handle occurance of character 0x7. |
| */ |
| virtual void handle0x7(); |
| |
| /** |
| Handle 8 bit text at current handle. |
| |
| @param data array of characters |
| @param len number of characters to handle |
| */ |
| virtual void text(const sal_uInt8 * data, size_t len); |
| |
| /** |
| Handle 16 bit text at current handle. |
| |
| @param data array of characters |
| @param len number of characters to handle |
| */ |
| virtual void utext(const sal_uInt8 * data, size_t len); |
| |
| /** |
| Handle properties of the current cell. |
| |
| @param pProps the properties |
| */ |
| virtual void cellProps(PropertiesPointer pProps); |
| |
| /** |
| Handle properties of a certain cell in the current row. |
| |
| @paran i index of the cell in the current row |
| @param pProps the properties |
| */ |
| virtual void cellPropsByCell(unsigned int i, PropertiesPointer pProps); |
| |
| /** |
| Handle properties of the current row. |
| |
| @param pProps the properties |
| */ |
| virtual void insertRowProps(PropertiesPointer pProps); |
| |
| /** |
| Handle properties of the current table. |
| |
| @param pProps the properties |
| */ |
| virtual void insertTableProps(PropertiesPointer pProps); |
| |
| /** |
| Return if table manager has detected paragraph to ignore. |
| |
| If this function returns true the current paragraph contains |
| only control information, e.g. end of row. |
| */ |
| virtual bool isIgnore() const; |
| |
| |
| #ifdef DEBUG_TABLE |
| void setTagLogger(TagLogger::Pointer_t _tagLogger) |
| { |
| mpTableLogger = _tagLogger; |
| } |
| #endif |
| }; |
| |
| template <typename T, typename PropertiesPointer> |
| TableManager<T, PropertiesPointer>::TableManager() |
| : mnTableDepthNew(0), mnTableDepth(0) |
| { |
| setRowEnd(false); |
| setInCell(false); |
| setCellEnd(false); |
| } |
| |
| template <typename T, typename PropertiesPointer> |
| void TableManager<T, PropertiesPointer>::cellDepth(sal_uInt32 nDepth) |
| { |
| #ifdef DEBUG_TABLE |
| if (mpTableLogger.get() != NULL) |
| { |
| mpTableLogger->startElement("tablemanager.cellDepth"); |
| mpTableLogger->attribute("depth", nDepth); |
| mpTableLogger->endElement("tablemanager.cellDepth"); |
| } |
| #endif |
| |
| mnTableDepthNew = nDepth; |
| } |
| |
| template <typename T, typename PropertiesPointer> |
| void TableManager<T, PropertiesPointer>::inCell() |
| { |
| #ifdef DEBUG_TABLE |
| if (mpTableLogger.get() != NULL) |
| mpTableLogger->element("tablemanager.inCell"); |
| #endif |
| setInCell(true); |
| |
| if (mnTableDepthNew < 1) |
| mnTableDepthNew = 1; |
| } |
| |
| template <typename T, typename PropertiesPointer> |
| void TableManager<T, PropertiesPointer>::endCell() |
| { |
| #ifdef DEBUG_TABLE |
| if (mpTableLogger.get() != NULL) |
| mpTableLogger->element("tablemanager.endCell"); |
| #endif |
| |
| setCellEnd(true); |
| } |
| |
| template <typename T, typename PropertiesPointer> |
| void TableManager<T, PropertiesPointer>::endRow() |
| { |
| #ifdef DEBUG_TABLE |
| if (mpTableLogger.get() != NULL) |
| mpTableLogger->element("tablemanager.endRow"); |
| #endif |
| |
| setRowEnd(true); |
| } |
| |
| template <typename T, typename PropertiesPointer> |
| void TableManager<T, PropertiesPointer>::setHandler |
| (typename TableDataHandler<T, PropertiesPointer>::Pointer_t pTableDataHandler) |
| { |
| mpTableDataHandler = pTableDataHandler; |
| } |
| |
| template <typename T, typename PropertiesPointer> |
| void TableManager<T, PropertiesPointer>::handle(const T & rHandle) |
| { |
| #ifdef DEBUG_TABLE |
| if (mpTableLogger.get()) |
| { |
| mpTableLogger->startElement("tablemanager.handle"); |
| mpTableLogger->chars(toString(rHandle)); |
| mpTableLogger->endElement("tablemanager.handle"); |
| } |
| #endif |
| |
| setHandle(rHandle); |
| } |
| |
| template <typename T, typename PropertiesPointer> |
| void TableManager<T, PropertiesPointer>::startLevel() |
| { |
| #ifdef DEBUG_TABLE |
| if (mpTableLogger.get() != NULL) |
| { |
| typename TableData<T, PropertiesPointer>::Pointer_t pTableData; |
| |
| if (mTableDataStack.size() > 0) |
| pTableData = mTableDataStack.top(); |
| |
| mpTableLogger->startElement("tablemanager.startLevel"); |
| mpTableLogger->attribute("level", mTableDataStack.size()); |
| |
| if (pTableData.get() != NULL) |
| mpTableLogger->attribute("openCell", |
| pTableData->isCellOpen() ? "yes" : "no"); |
| |
| mpTableLogger->endElement("tablemanager.startLevel"); |
| } |
| #endif |
| |
| typename TableData<T, PropertiesPointer>::Pointer_t pTableData |
| (new TableData<T, PropertiesPointer>(mTableDataStack.size())); |
| |
| mTableDataStack.push(pTableData); |
| mState.startLevel(); |
| } |
| |
| template <typename T, typename PropertiesPointer> |
| void TableManager<T, PropertiesPointer>::endLevel() |
| { |
| if (mpTableDataHandler.get() != NULL) |
| resolveCurrentTable(); |
| |
| mState.endLevel(); |
| mTableDataStack.pop(); |
| |
| #ifdef DEBUG_TABLE |
| if (mpTableLogger.get() != NULL) |
| { |
| typename TableData<T, PropertiesPointer>::Pointer_t pTableData; |
| |
| if (mTableDataStack.size() > 0) |
| pTableData = mTableDataStack.top(); |
| |
| mpTableLogger->startElement("tablemanager.endLevel"); |
| mpTableLogger->attribute("level", mTableDataStack.size()); |
| |
| if (pTableData.get() != NULL) |
| mpTableLogger->attribute("openCell", |
| pTableData->isCellOpen() ? "yes" : "no"); |
| |
| mpTableLogger->endElement("tablemanager.endLevel"); |
| } |
| #endif |
| } |
| |
| template <typename T, typename PropertiesPointer> |
| void TableManager<T, PropertiesPointer>::startParagraphGroup() |
| { |
| mState.resetCellSpecifics(); |
| mnTableDepthNew = 0; |
| } |
| |
| template <typename T, typename PropertiesPointer> |
| void TableManager<T, PropertiesPointer>::endParagraphGroup() |
| { |
| sal_Int32 nTableDepthDifference = mnTableDepthNew - mnTableDepth; |
| |
| PropertiesPointer pEmptyProps; |
| |
| while (nTableDepthDifference > 0) |
| { |
| ensureOpenCell(pEmptyProps); |
| startLevel(); |
| |
| --nTableDepthDifference; |
| } |
| while (nTableDepthDifference < 0) |
| { |
| endLevel(); |
| |
| ++nTableDepthDifference; |
| } |
| |
| mnTableDepth = mnTableDepthNew; |
| |
| if ( mnTableDepth > 0 ) |
| { |
| typename TableData< T, PropertiesPointer >::Pointer_t pTableData = mTableDataStack.top(); |
| |
| if ( isRowEnd() ) |
| { |
| endOfRowAction(); |
| pTableData->endRow( getRowProps() ); |
| resetRowProps(); |
| } |
| |
| else if ( isInCell() ) |
| { |
| ensureOpenCell( getCellProps() ); |
| |
| if ( isCellEnd() ) |
| { |
| endOfCellAction(); |
| closeCell( getHandle() ); |
| } |
| } |
| resetCellProps(); |
| } |
| } |
| |
| template <typename T, typename PropertiesPointer> |
| bool TableManager<T, PropertiesPointer>::sprm(Sprm & rSprm) |
| { |
| bool bRet = true; |
| switch (rSprm.getId()) |
| { |
| case NS_sprm::LN_PTableDepth: |
| { |
| Value::Pointer_t pValue = rSprm.getValue(); |
| |
| cellDepth(pValue->getInt()); |
| } |
| break; |
| case NS_sprm::LN_PFInTable: |
| inCell(); |
| break; |
| case NS_sprm::LN_PCell: |
| endCell(); |
| break; |
| case NS_sprm::LN_PFTtp: |
| case NS_sprm::LN_PRow: |
| endRow(); |
| break; |
| default: |
| bRet = false; |
| } |
| return bRet; |
| } |
| template <typename T, typename PropertiesPointer> |
| void TableManager<T, PropertiesPointer>::props(PropertiesPointer pProps) |
| { |
| setProps(pProps); |
| } |
| |
| template <typename T, typename PropertiesPointer> |
| void TableManager<T, PropertiesPointer>::handle0x7() |
| { |
| #ifdef DEBUG_TABLE |
| if (mpTableLogger.get() != NULL) |
| mpTableLogger->startElement("tablemanager.handle0x7"); |
| #endif |
| |
| if (mnTableDepthNew < 1) |
| mnTableDepthNew = 1; |
| |
| if (isInCell()) |
| endCell(); |
| else |
| endRow(); |
| |
| #ifdef DEBUG_TABLE |
| if (mpTableLogger.get() != NULL) |
| mpTableLogger->endElement("tablemanager.handle0x7"); |
| #endif |
| } |
| |
| template <typename T, typename PropertiesPointer> |
| void TableManager<T, PropertiesPointer>::text(const sal_uInt8 * data, size_t len) |
| { |
| // optimization: cell/row end characters are the last characters in a run |
| if (len > 0) |
| { |
| if (data[len - 1] == 0x7) |
| handle0x7(); |
| } |
| } |
| |
| template <typename T, typename PropertiesPointer> |
| void TableManager<T, PropertiesPointer>::utext(const sal_uInt8 * data, size_t len) |
| { |
| // optimization: cell/row end characters are the last characters in a run |
| |
| if (len > 0) |
| { |
| sal_Unicode nChar = data[(len - 1) * 2] + (data[(len - 1) * 2 + 1] << 8); |
| if (nChar == 0x7) |
| handle0x7(); |
| } |
| } |
| |
| template <typename T, typename PropertiesPointer> |
| void TableManager<T, PropertiesPointer>::cellProps(PropertiesPointer pProps) |
| { |
| #ifdef DEBUG_TABLE |
| if (mpTableLogger.get() != NULL) |
| mpTableLogger->startElement("tablemanager.cellProps"); |
| #endif |
| |
| if(getCellProps().get()) |
| getCellProps()->insert( pProps ); |
| else |
| setCellProps(pProps); |
| |
| #ifdef DEBUG_TABLE |
| if (mpTableLogger.get() != NULL) |
| mpTableLogger->endElement("tablemanager.cellProps"); |
| #endif |
| } |
| |
| template <typename T, typename PropertiesPointer> |
| void TableManager<T, PropertiesPointer>::cellPropsByCell |
| (unsigned int i, PropertiesPointer pProps) |
| { |
| #ifdef DEBUG_TABLE |
| if (mpTableLogger.get() != NULL) |
| mpTableLogger->startElement("tablemanager.cellPropsByCell"); |
| #endif |
| |
| mTableDataStack.top()->insertCellProperties(i, pProps); |
| |
| #ifdef DEBUG_TABLE |
| if (mpTableLogger.get() != NULL) |
| mpTableLogger->endElement("tablemanager.cellPropsByCell"); |
| #endif |
| } |
| |
| template <typename T, typename PropertiesPointer> |
| void TableManager<T, PropertiesPointer>::insertRowProps(PropertiesPointer pProps) |
| { |
| #ifdef DEBUG_TABLE |
| if (mpTableLogger.get() != NULL) |
| mpTableLogger->startElement("tablemanager.insertRowProps"); |
| #endif |
| |
| if( getRowProps().get() ) |
| getRowProps()->insert( pProps ); |
| else |
| setRowProps(pProps); |
| |
| #ifdef DEBUG_TABLE |
| if (mpTableLogger.get() != NULL) |
| mpTableLogger->endElement("tablemanager.insertRowProps"); |
| #endif |
| } |
| |
| template <typename T, typename PropertiesPointer> |
| void TableManager<T, PropertiesPointer>::insertTableProps(PropertiesPointer pProps) |
| { |
| #ifdef DEBUG_TABLE |
| if (mpTableLogger.get() != NULL) |
| mpTableLogger->startElement("tablemanager.insertTableProps"); |
| #endif |
| |
| if( getTableProps().get() ) |
| getTableProps()->insert( pProps ); |
| else |
| setTableProps(pProps); |
| |
| #ifdef DEBUG_TABLE |
| if (mpTableLogger.get() != NULL) |
| mpTableLogger->endElement("tablemanager.insertTableProps"); |
| #endif |
| } |
| |
| template <typename T, typename PropertiesPointer> |
| void TableManager<T, PropertiesPointer>::resolveCurrentTable() |
| { |
| #ifdef DEBUG_TABLE |
| if (mpTableLogger.get() != NULL) |
| mpTableLogger->startElement("tablemanager.resolveCurrentTable"); |
| #endif |
| |
| if (mpTableDataHandler.get() != NULL) |
| { |
| typename TableData<T, PropertiesPointer>::Pointer_t |
| pTableData = mTableDataStack.top(); |
| |
| const unsigned int nRows = pTableData->getRowCount(); |
| |
| mpTableDataHandler->startTable(nRows, pTableData->getDepth(), getTableProps()); |
| |
| for (unsigned int nRow = 0; nRow < nRows; ++nRow) |
| { |
| typename RowData<T, PropertiesPointer>::Pointer_t pRowData = pTableData->getRow(nRow); |
| |
| unsigned int nCells = pRowData->getCellCount(); |
| |
| mpTableDataHandler->startRow(nCells, pRowData->getProperties()); |
| |
| for (unsigned int nCell = 0; nCell < nCells; ++nCell) |
| { |
| mpTableDataHandler->startCell |
| (pRowData->getCellStart(nCell), |
| pRowData->getCellProperties(nCell)); |
| |
| mpTableDataHandler->endCell(pRowData->getCellEnd(nCell)); |
| } |
| |
| mpTableDataHandler->endRow(); |
| } |
| |
| mpTableDataHandler->endTable( pTableData->getDepth() ); |
| } |
| resetTableProps(); |
| |
| #ifdef DEBUG_TABLE |
| if (mpTableLogger.get() != NULL) |
| mpTableLogger->endElement("tablemanager.resolveCurrentTable"); |
| #endif |
| } |
| |
| template <typename T, typename PropertiesPointer> |
| void TableManager<T, PropertiesPointer>::endOfCellAction() |
| { |
| } |
| |
| template <typename T, typename PropertiesPointer> |
| void TableManager<T, PropertiesPointer>::endOfRowAction() |
| { |
| } |
| |
| template <typename T, typename PropertiesPointer> |
| bool TableManager<T, PropertiesPointer>::isIgnore() const |
| { |
| return isRowEnd(); |
| } |
| |
| template <typename T, typename PropertiesPointer> |
| void TableManager<T, PropertiesPointer>::openCell |
| (const T & rHandle, PropertiesPointer pProps) |
| { |
| #ifdef DEBUG_TABLE |
| mpTableLogger->startElement("tablemanager.openCell"); |
| mpTableLogger->chars(toString(rHandle)); |
| mpTableLogger->endElement("tablemanager.openCell"); |
| #endif |
| |
| if (mTableDataStack.size() > 0) |
| { |
| typename TableData<T, PropertiesPointer>::Pointer_t |
| pTableData = mTableDataStack.top(); |
| |
| pTableData->addCell(rHandle, pProps); |
| } |
| } |
| |
| template <typename T, typename PropertiesPointer> |
| void TableManager<T, PropertiesPointer>::closeCell |
| (const T & rHandle) |
| { |
| #ifdef DEBUG_TABLE |
| mpTableLogger->startElement("tablemanager.closeCell"); |
| mpTableLogger->chars(toString(rHandle)); |
| mpTableLogger->endElement("tablemanager.closeCell"); |
| #endif |
| |
| if (mTableDataStack.size() > 0) |
| { |
| typename TableData<T, PropertiesPointer>::Pointer_t |
| pTableData = mTableDataStack.top(); |
| |
| pTableData->endCell(rHandle); |
| } |
| } |
| |
| template <typename T, typename PropertiesPointer> |
| void TableManager<T, PropertiesPointer>::ensureOpenCell(PropertiesPointer pProps) |
| { |
| #ifdef DEBUG_TABLE |
| mpTableLogger->startElement("tablemanager.ensureOpenCell"); |
| #endif |
| |
| if (mTableDataStack.size() > 0) |
| { |
| typename TableData<T, PropertiesPointer>::Pointer_t |
| pTableData = mTableDataStack.top(); |
| |
| if (pTableData.get() != NULL) |
| { |
| if (!pTableData->isCellOpen()) |
| openCell(getHandle(), pProps); |
| else |
| pTableData->insertCellProperties(pProps); |
| } |
| } |
| #ifdef DEBUG_TABLE |
| mpTableLogger->endElement("tablemanager.ensureOpenCell"); |
| #endif |
| } |
| |
| } |
| |
| #endif // INCLUDED_TABLE_MANAGER_HXX |
