TableManager.hxx

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
 * This file is part of the LibreOffice project.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * This file incorporates work covered by the following license notice:
 *
 *   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 .
 */
 
#pragma once
 
#include <memory>
#include <stack>
 
#include "PropertyMap.hxx"
#include "TableData.hxx"
 
#include <dmapper/resourcemodel.hxx>
 
namespace writerfilter::dmapper
{
 
class DomainMapperTableHandler;
 
class TableManager : public virtual SvRefBase
{
    class TableManagerState final
    {
        TablePropertyMapPtr mpCellProps;
 
        TablePropertyMapPtr mpRowProps;
 
        TablePropertyMapPtr mpTableExceptionProps;
 
        std::stack<TablePropertyMapPtr> mTableProps;
 
        bool mbRowEnd;
 
        bool mbInCell;
 
        bool mbCellEnd;
 
    public:
        TableManagerState()
        : mbRowEnd(false), mbInCell(false), mbCellEnd(false)
        {
        }
 
        void startLevel()
        {
            TablePropertyMapPtr pProps;
            mTableProps.push(pProps);
        }
 
        void endLevel()
        {
            mTableProps.pop();
        }
 
        void resetCellSpecifics()
        {
            mbRowEnd = false;
            mbInCell = false;
            mbCellEnd = false;
        }
 
        void resetCellProps()
        {
            // copy tblPrEx table exception properties, if they exist
            if (getTableExceptionProps().is())
            {
                mpCellProps = new TablePropertyMap;
                mpCellProps->InsertProps(getTableExceptionProps().get());
            }
            else
                mpCellProps.clear();
        }
 
        void setCellProps(TablePropertyMapPtr pProps)
        {
            mpCellProps = pProps;
        }
 
        const TablePropertyMapPtr& getCellProps() const
        {
            return mpCellProps;
        }
 
        void resetRowProps()
        {
            // reset also table exception and
            // its copy set by the previous resetCellProps()
            mpTableExceptionProps.clear();
            resetCellProps();
            mpRowProps.clear();
        }
 
        void setRowProps(TablePropertyMapPtr pProps)
        {
            mpRowProps = pProps;
        }
 
        const TablePropertyMapPtr& getRowProps() const
        {
            return mpRowProps;
        }
 
        void setTableExceptionProps(TablePropertyMapPtr pProps)
        {
            mpTableExceptionProps = pProps;
            // set table exception properties of the first cell
            resetCellProps();
        }
 
        const TablePropertyMapPtr& getTableExceptionProps() const
        {
            return mpTableExceptionProps;
        }
 
        void resetTableProps()
        {
            if (mTableProps.size() > 0)
                mTableProps.top().clear();
        }
 
        void setTableProps(TablePropertyMapPtr pProps)
        {
            if (mTableProps.size() > 0)
                mTableProps.top() = pProps;
        }
 
        TablePropertyMapPtr getTableProps()
        {
            TablePropertyMapPtr 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;
        }
    };
 
    css::uno::Reference<css::text::XTextRange> mCurHandle;
 
    TableManagerState mState;
 
protected:
    TablePropertyMapPtr const & getCellProps() const
    {
        return mState.getCellProps();
    }
 
public:
    TablePropertyMapPtr const & getRowProps() const
    {
        return mState.getRowProps();
    }
 
    TablePropertyMapPtr const & getTableExceptionProps() const
    {
        return mState.getTableExceptionProps();
    }
 
protected:
    void setInCell(bool bInCell)
    {
        mState.setInCell(bInCell);
    }
 
    bool isInCell() const
    {
        return mState.isInCell();
    }
 
    void setCellEnd(bool bCellEnd)
    {
        mState.setCellEnd(bCellEnd);
    }
 
    void setRowEnd(bool bRowEnd)
    {
        mState.setRowEnd(bRowEnd);
    }
 
    bool isRowEnd() const
    {
        return mState.isRowEnd();
    }
 
    TablePropertyMapPtr getTableProps()
    {
        return mState.getTableProps();
    }
 
    const css::uno::Reference<css::text::XTextRange>& getHandle() const
    {
        return mCurHandle;
    }
 
    void setHandle(const css::uno::Reference<css::text::XTextRange>& rHandle)
    {
        mCurHandle = rHandle;
    }
 
private:
    typedef tools::SvRef< css::uno::Reference<css::text::XTextRange> > T_p;
 
    sal_uInt32 mnTableDepthNew;
 
    sal_uInt32 mnTableDepth;
 
    std::stack<TableData::Pointer_t> mTableDataStack;
    RowData::Pointer_t mpUnfinishedRow;
    bool mbKeepUnfinishedRow;
    bool m_bTableStartsAtCellStart;
 
    bool m_bCellLastParaAfterAutospacing;
 
    tools::SvRef<DomainMapperTableHandler> mpTableDataHandler;
 
    void inCell();
 
    void endCell();
 
    void cellDepth(sal_uInt32 nDepth);
 
    void endRow();
 
    void resolveCurrentTable();
 
    void openCell(const css::uno::Reference<css::text::XTextRange>& rHandle, const TablePropertyMapPtr& pProps);
 
    void closeCell(const css::uno::Reference<css::text::XTextRange>& rHandle);
 
    void ensureOpenCell(const TablePropertyMapPtr& pProps);
 
protected:
    sal_Int32 getTableDepthDifference() const { return mnTableDepthNew - mnTableDepth; }
 
    sal_uInt32 getTableDepth() const { return mnTableDepthNew; }
 
    virtual void endOfCellAction();
 
    virtual void endOfRowAction();
    virtual void clearData();
 
    void setKeepUnfinishedRow(bool bKeep)
    {
        mbKeepUnfinishedRow = bKeep;
    }
 
 
public:
    TableManager();
    ~TableManager();
 
    void setHandler(const tools::SvRef<DomainMapperTableHandler>& pTableDataHandler);
 
    void handle(const css::uno::Reference<css::text::XTextRange>& rHandle);
 
    virtual void startLevel();
 
    virtual void endLevel();
 
    void endTable()
    {
        setRowEnd(false);
    }
 
    bool isInTable();
 
    void startParagraphGroup();
 
    void endParagraphGroup();
 
    virtual bool sprm(Sprm & rSprm);
 
    void handle0x7();
 
    void text(const sal_uInt8 * data, size_t len);
 
    void utext(const sal_uInt8 * data, size_t len);
 
    virtual void cellProps(const TablePropertyMapPtr& pProps);
 
    virtual void insertRowProps(const TablePropertyMapPtr& pProps);
 
    virtual void tableExceptionProps(const TablePropertyMapPtr& pProps);
 
    virtual void insertTableProps(const TablePropertyMapPtr& pProps);
 
    bool isIgnore() const;
 
    sal_uInt32 getGridBefore(sal_uInt32 nRow);
    sal_uInt32 getCurrentGridBefore();
    void setCurrentGridBefore( sal_uInt32 nSkipGrids );
    sal_uInt32 getGridAfter(sal_uInt32 nRow);
    void setCurrentGridAfter( sal_uInt32 nSkipGrids );
    std::vector<sal_uInt32> getCurrentGridSpans();
    void setCurrentGridSpan( sal_uInt32 nGridSpan, bool bFirstCell = false );
    sal_uInt32 findColumn( const sal_uInt32 nRow, const sal_uInt32 nCell );
    sal_uInt32 findColumnCell( const sal_uInt32 nRow, const sal_uInt32 nCol );
 
    void setTableStartsAtCellStart(bool bTableStartsAtCellStart);
    void setCellLastParaAfterAutospacing(bool bIsAfterAutospacing);
    bool isCellLastParaAfterAutospacing() const {return m_bCellLastParaAfterAutospacing;}
};
 
}
 
 
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */