pivottablebuffer.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 "pivotcachebuffer.hxx"
#include "stylesbuffer.hxx"
 
namespace com::sun::star {
    namespace sheet { class XDataPilotDescriptor; }
    namespace sheet { class XDataPilotField; }
}
 
class ScDPObject;
 
namespace oox::xls {
 
class PivotTable;
 
struct PTFieldItemModel
{
    sal_Int32           mnCacheItem;        
    sal_Int32           mnType;             
    OUString       msCaption;          
    bool                mbShowDetails;      
    bool                mbHidden;           
 
    explicit            PTFieldItemModel();
 
    void                setBiffType( sal_uInt16 nType );
};
 
struct PTFieldModel
{
    sal_Int32           mnAxis;             
    sal_Int32           mnNumFmtId;         
    sal_Int32           mnAutoShowItems;    
    sal_Int32           mnAutoShowRankBy;   
    sal_Int32           mnSortType;         
    sal_Int32           mnSortRefField;     
    sal_Int32           mnSortRefItem;      
    bool                mbDataField;        
    bool                mbDefaultSubtotal;  
    bool                mbSumSubtotal;      
    bool                mbCountASubtotal;   
    bool                mbAverageSubtotal;  
    bool                mbMaxSubtotal;      
    bool                mbMinSubtotal;      
    bool                mbProductSubtotal;  
    bool                mbCountSubtotal;    
    bool                mbStdDevSubtotal;   
    bool                mbStdDevPSubtotal;  
    bool                mbVarSubtotal;      
    bool                mbVarPSubtotal;     
    bool                mbShowAll;          
    bool                mbOutline;          
    bool                mbSubtotalTop;      
    bool                mbCompact;          
    bool                mbInsertBlankRow;   
    bool                mbInsertPageBreak;  
    bool                mbAutoShow;         
    bool                mbTopAutoShow;      
    bool                mbMultiPageItems;   
 
    explicit            PTFieldModel();
 
    void                setBiffAxis( sal_uInt8 nAxisFlags );
};
 
struct PTPageFieldModel
{
    OUString     maName;             
    sal_Int32           mnField;            
    sal_Int32           mnItem;             
 
    explicit            PTPageFieldModel();
};
 
struct PTDataFieldModel
{
    OUString     maName;             
    sal_Int32           mnField;            
    sal_Int32           mnSubtotal;         
    sal_Int32           mnShowDataAs;       
    sal_Int32           mnBaseField;        
    sal_Int32           mnBaseItem;         
    sal_Int32           mnNumFmtId;         
 
    explicit            PTDataFieldModel();
 
    void                setBiffSubtotal( sal_Int32 nSubtotal );
    void                setBiffShowDataAs( sal_Int32 nShowDataAs );
};
 
class PivotTableField : public WorkbookHelper
{
public:
    explicit            PivotTableField( PivotTable& rPivotTable, sal_Int32 nFieldIndex );
 
    void                importPivotField( const AttributeList& rAttribs );
    void                importItem( const AttributeList& rAttribs );
    void                importReference( const AttributeList& rAttribs );
    void                importReferenceItem( const AttributeList& rAttribs );
 
    void                importPTField( SequenceInputStream& rStrm );
    void                importPTFItem( SequenceInputStream& rStrm );
    void                importPTReference( SequenceInputStream& rStrm );
    void                importPTReferenceItem( SequenceInputStream& rStrm );
 
    void                finalizeImport(
                            const css::uno::Reference< css::sheet::XDataPilotDescriptor >& rxDPDesc );
    void                finalizeDateGroupingImport(
                            const css::uno::Reference< css::sheet::XDataPilotField >& rxBaseDPField,
                            sal_Int32 nBaseFieldIdx );
    void                finalizeParentGroupingImport(
                            const css::uno::Reference< css::sheet::XDataPilotField >& rxBaseDPField,
                            const PivotCacheField& rBaseCacheField,
                            PivotCacheGroupItemVector& orItemNames );
    void                finalizeImportBasedOnCache(
                            const css::uno::Reference< css::sheet::XDataPilotDescriptor >& rxDPDesc);
 
    const OUString& getDPFieldName() const { return maDPFieldName; }
 
    void                convertRowField();
    void                convertColField();
    void                convertHiddenField();
    void                convertPageField( const PTPageFieldModel& rPageField );
    void                convertDataField( const PTDataFieldModel& rDataField );
 
private:
    css::uno::Reference< css::sheet::XDataPilotField >
                        convertRowColPageField( sal_Int32 nAxis );
 
private:
    typedef ::std::vector< PTFieldItemModel > ItemModelVector;
 
    PivotTable&         mrPivotTable;       
    ItemModelVector     maItems;            
    PTFieldModel        maModel;            
    OUString            maDPFieldName;      
    sal_Int32           mnFieldIndex;       
};
 
struct PTFilterModel
{
    OUString     maName;             
    OUString     maDescription;      
    OUString     maStrValue1;        
    OUString     maStrValue2;        
    double              mfValue;            
    sal_Int32           mnField;            
    sal_Int32           mnMemPropField;     
    sal_Int32           mnType;             
    sal_Int32           mnEvalOrder;        
    sal_Int32           mnId;               
    sal_Int32           mnMeasureField;     
    sal_Int32           mnMeasureHier;      
    bool                mbTopFilter;        
 
    explicit            PTFilterModel();
};
 
class PivotTableFilter : public WorkbookHelper
{
public:
    explicit            PivotTableFilter( const PivotTable& rPivotTable );
 
    void                importFilter( const AttributeList& rAttribs );
    void                importTop10( const AttributeList& rAttribs );
 
    void                importPTFilter( SequenceInputStream& rStrm );
    void                importTop10Filter( SequenceInputStream& rStrm );
 
    void                finalizeImport();
 
private:
    const PivotTable&   mrPivotTable;
    PTFilterModel       maModel;
};
 
struct PTDefinitionModel : public AutoFormatModel
{
    OUString     maName;
    OUString     maDataCaption;
    OUString     maGrandTotalCaption;
    OUString     maRowHeaderCaption;
    OUString     maColHeaderCaption;
    OUString     maErrorCaption;
    OUString     maMissingCaption;
    OUString     maPageStyle;
    OUString     maPivotTableStyle;
    OUString     maVacatedStyle;
    OUString     maTag;
    sal_Int32           mnCacheId;
    sal_Int32           mnDataPosition;
    sal_Int32           mnPageWrap;
    sal_Int32           mnIndent;
    sal_Int32           mnChartFormat;
    bool                mbDataOnRows;
    bool                mbShowError;
    bool                mbShowMissing;
    bool                mbShowItems;
    bool                mbDisableFieldList;
    bool                mbShowCalcMembers;
    bool                mbVisualTotals;
    bool                mbShowDrill;
    bool                mbPrintDrill;
    bool                mbEnableDrill;
    bool                mbPreserveFormatting;
    bool                mbUseAutoFormat;
    bool                mbPageOverThenDown;
    bool                mbSubtotalHiddenItems;
    bool                mbRowGrandTotals;
    bool                mbColGrandTotals;
    bool                mbFieldPrintTitles;
    bool                mbItemPrintTitles;
    bool                mbMergeItem;
    bool                mbShowEmptyRow;
    bool                mbShowEmptyCol;
    bool                mbShowHeaders;
    bool                mbFieldListSortAsc;
    bool                mbCustomListSort;
 
    explicit            PTDefinitionModel();
};
 
struct PTLocationModel
{
    ScRange             maRange;            
    sal_Int32           mnFirstHeaderRow;   
    sal_Int32           mnFirstDataRow;     
    sal_Int32           mnFirstDataCol;     
    sal_Int32           mnRowPageCount;     
    sal_Int32           mnColPageCount;     
 
    explicit            PTLocationModel();
};
 
class PivotTable : public WorkbookHelper
{
public:
    explicit            PivotTable( const WorkbookHelper& rHelper );
 
    void                importPivotTableDefinition( const AttributeList& rAttribs );
    void                importLocation( const AttributeList& rAttribs, sal_Int16 nSheet );
    void                importRowField( const AttributeList& rAttribs );
    void                importColField( const AttributeList& rAttribs );
    void                importPageField( const AttributeList& rAttribs );
    void                importDataField( const AttributeList& rAttribs );
    void putToInteropGrabBag(const OUString& sName, const AttributeList& rAttribs);
 
    void                importPTDefinition( SequenceInputStream& rStrm );
    void                importPTLocation( SequenceInputStream& rStrm, sal_Int16 nSheet );
    void                importPTRowFields( SequenceInputStream& rStrm );
    void                importPTColFields( SequenceInputStream& rStrm );
    void                importPTPageField( SequenceInputStream& rStrm );
    void                importPTDataField( SequenceInputStream& rStrm );
 
    PivotTableField&    createTableField();
    PivotTableFilter&   createTableFilter();
    void                finalizeImport();
    void                finalizeFieldsImport();
    void                finalizeDateGroupingImport(
                            const css::uno::Reference< css::sheet::XDataPilotField >& rxBaseDPField,
                            sal_Int32 nBaseFieldIdx );
    void                finalizeParentGroupingImport(
                            const css::uno::Reference< css::sheet::XDataPilotField >& rxBaseDPField,
                            const PivotCacheField& rBaseCacheField,
                            PivotCacheGroupItemVector& orItemNames );
 
    css::uno::Reference< css::sheet::XDataPilotField >
                        getDataPilotField( const OUString& rFieldName ) const;
    css::uno::Reference< css::sheet::XDataPilotField >
                        getDataPilotField( sal_Int32 nFieldIdx ) const;
    css::uno::Reference< css::sheet::XDataPilotField >
                        getDataLayoutField() const;
 
    PivotCacheField* getCacheField( sal_Int32 nFieldIdx );
    const PivotCacheField* getCacheField( sal_Int32 nFieldIdx ) const;
    const PivotCacheField* getCacheFieldOfDataField( sal_Int32 nDataItemIdx ) const;
    sal_Int32           getCacheDatabaseIndex( sal_Int32 nFieldIdx ) const;
 
    ScDPObject* getDPObject() { return mpDPObject; }
 
private:
    typedef RefVector< PivotTableField >        PivotTableFieldVector;
    typedef RefVector< PivotTableFilter >       PivotTableFilterVector;
    typedef ::std::vector< sal_Int32 >          IndexVector;
    typedef ::std::vector< PTPageFieldModel >   PageFieldVector;
    typedef ::std::vector< PTDataFieldModel >   DataFieldVector;
 
private:
    PivotTableField*    getTableField( sal_Int32 nFieldIdx );
 
    static void         importField( IndexVector& orFields, const AttributeList& rAttribs );
    static void         importFields( IndexVector& orFields, SequenceInputStream& rStrm );
 
private:
    ScDPObject*           mpDPObject;
    PivotTableFieldVector maFields;         
    PivotTableField       maDataField;        
    IndexVector           maRowFields;        
    IndexVector           maColFields;        
    PageFieldVector       maPageFields;       
    DataFieldVector       maDataFields;       
    PivotTableFilterVector maFilters;       
    PTDefinitionModel     maDefModel;         
    PTLocationModel       maLocationModel;    
    PivotCache*           mpPivotCache;       
    css::uno::Reference< css::sheet::XDataPilotDescriptor >
                          mxDPDescriptor;     
    std::map<OUString, css::uno::Any> maInteropGrabBag;
 
};
 
class PivotTableBuffer : public WorkbookHelper
{
public:
    explicit            PivotTableBuffer( const WorkbookHelper& rHelper );
 
    PivotTable&         createPivotTable();
 
    void                finalizeImport();
 
private:
    typedef RefVector< PivotTable > PivotTableVector;
    PivotTableVector    maTables;
};
 
} // namespace oox::xls
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */