sheetdatabuffer.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 <vector>
#include <map>
#include <o3tl/sorted_vector.hxx>
 
#include "richstring.hxx"
#include "worksheethelper.hxx"
#include "addressconverter.hxx"
 
namespace com::sun::star {
    namespace util { struct DateTime; }
}
 
namespace oox::xls {
 
struct CellModel
{
    ScAddress           maCellAddr;         
    sal_Int32           mnCellType;         
    sal_Int32           mnXfId;             
    bool                mbShowPhonetic;     
 
    explicit            CellModel();
};
 
struct CellFormulaModel
{
    ScRange             maFormulaRef;       
    sal_Int32           mnFormulaType;      
    sal_Int32           mnSharedId;         
 
    explicit            CellFormulaModel();
 
    bool                isValidArrayRef( const ScAddress& rCellAddr );
    bool                isValidSharedRef( const ScAddress& rCellAddr );
};
 
struct DataTableModel
{
    OUString     maRef1;             
    OUString     maRef2;             
    bool                mb2dTable;          
    bool                mbRowTable;         
    bool                mbRef1Deleted;      
    bool                mbRef2Deleted;      
 
    explicit            DataTableModel();
};
 
class CellBlockBuffer : public WorksheetHelper
{
public:
    explicit            CellBlockBuffer( const WorksheetHelper& rHelper );
 
    void                setColSpans( sal_Int32 nRow, const ValueRangeSet& rColSpans );
 
private:
    typedef ::std::map< sal_Int32, ValueRangeVector >   ColSpanVectorMap;
 
    ColSpanVectorMap    maColSpans;             
    sal_Int32           mnCurrRow;              
};
 
class SheetDataBuffer : public WorksheetHelper
{
public:
    explicit            SheetDataBuffer( const WorksheetHelper& rHelper );
 
    void                setColSpans( sal_Int32 nRow, const ValueRangeSet& rColSpans );
 
    void                setBlankCell( const CellModel& rModel );
    void                setValueCell( const CellModel& rModel, double fValue );
    void                setStringCell( const CellModel& rModel, const OUString& rText );
    void                setStringCell( const CellModel& rModel, const RichStringRef& rxString );
    void                setStringCell( const CellModel& rModel, sal_Int32 nStringId );
    void                setDateTimeCell( const CellModel& rModel, const css::util::DateTime& rDateTime );
    void                setBooleanCell( const CellModel& rModel, bool bValue );
    void                setErrorCell( const CellModel& rModel, const OUString& rErrorCode );
    void                setErrorCell( const CellModel& rModel, sal_uInt8 nErrorCode );
    void                setFormulaCell( const CellModel& rModel, const ApiTokenSequence& rTokens );
    void                setDateCell( const CellModel& rModel, const OUString& rDateString );
 
    void                createSharedFormula(
            const ScAddress& rRange,
            const ApiTokenSequence& rTokens);
 
    void                createArrayFormula(
                            const ScRange& rRange,
                            const ApiTokenSequence& rTokens );
    void                createTableOperation(
                            const ScRange& rRange,
                            const DataTableModel& rModel );
 
    void                setRowFormat( sal_Int32 nRow, sal_Int32 nXfId, bool bCustomFormat );
    void                setMergedRange( const ScRange& rRange );
 
    void                setCellFormat( const CellModel& rModel );
 
    void                finalizeImport();
 
    void                setCellFormula(
                            const ScAddress& rCellAddr,
                            const ApiTokenSequence& rTokens );
private:
 
    ApiTokenSequence    resolveSharedFormula( const ScAddress& rMapKey ) const;
 
    void                finalizeArrayFormula(
                            const ScRange& rRange,
                            const ApiTokenSequence& rTokens ) const;
    void finalizeTableOperation(
        const ScRange& rRange, const DataTableModel& rModel );
 
    void                applyCellMerging( const ScRange& rRange );
    void                addColXfStyles();
    void                addColXfStyleProcessRowRanges();
private:
    typedef std::pair< ScRange, ApiTokenSequence > ArrayFormula;
    typedef ::std::vector< ArrayFormula > ArrayFormulaVector;
 
    typedef std::pair< ScRange, DataTableModel > TableOperation;
 
    struct XfIdRowRange
    {
        ValueRange          maRowRange;         
        sal_Int32           mnXfId;             
 
        explicit            XfIdRowRange();
        void                set( sal_Int32 nRow, sal_Int32 nXfId );
        bool                tryExpand( sal_Int32 nRow, sal_Int32 nXfId );
    };
 
    typedef ::std::pair< sal_Int32, sal_Int32 > XfIdNumFmtKey;
 
    struct RowRangeStyle
    {
        sal_Int32 mnStartRow;
        sal_Int32 mnEndRow;
        XfIdNumFmtKey mnNumFmt;
    };
    struct StyleRowRangeComp
    {
        bool operator() (const RowRangeStyle& lhs, const RowRangeStyle& rhs) const
        {
            // This end-vs-start comparison is needed by the lower_bound() use
            // in SheetDataBuffer::addColXfStyleProcessRowRanges() that searches
            // for partially overlapping ranges. In all other places the ranges
            // should be non-overlapping, in which case this is the same as the "normal"
            // comparison.
            return lhs.mnEndRow<rhs.mnStartRow;
        }
    };
    typedef ::o3tl::sorted_vector< RowRangeStyle, StyleRowRangeComp > RowStyles;
    typedef ::std::map< sal_Int32, RowStyles > ColStyles;
    typedef ::std::vector< RowRangeStyle > TmpRowStyles;
    typedef ::std::map< sal_Int32, TmpRowStyles > TmpColStyles;
    struct MergedRange
    {
        ScRange             maRange;            
        sal_Int32           mnHorAlign;         
 
        explicit            MergedRange( const ScRange& rRange );
        explicit            MergedRange( const ScAddress& rAddress, sal_Int32 nHorAlign );
        bool                tryExpand( const ScAddress& rAddress, sal_Int32 nHorAlign );
    };
    typedef ::std::vector< MergedRange > MergedRangeVector;
 
    ColStyles           maStylesPerColumn;      
    CellBlockBuffer     maCellBlocks;           
    ArrayFormulaVector  maArrayFormulas;        
    std::vector< TableOperation >
                        maTableOperations;      
    ::std::map< BinAddress, ApiTokenSequence >
                        maSharedFormulas;       
    ScAddress           maSharedFmlaAddr;       
    ScAddress           maSharedBaseAddr;       
    XfIdRowRange        maXfIdRowRange;         
    std::map< XfIdNumFmtKey, ScRangeList >
                        maXfIdRangeLists;       
    MergedRangeVector   maMergedRanges;         
    MergedRangeVector   maCenterFillRanges;     
    bool                mbPendingSharedFmla;    
    std::map< sal_Int32, std::vector< ValueRange > > maXfIdRowRangeList; 
};
 
} // namespace oox::xls
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */