condformatbuffer.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 "worksheethelper.hxx"
#include <tools/color.hxx>
#include <colorscale.hxx>
#include <conditio.hxx>
#include <rangelst.hxx>
 
#include <memory>
#include <vector>
 
class ScColorScaleFormat;
class ScDataBarFormat;
struct ScDataBarFormatData;
class ScIconSetFormat;
struct ScIconSetFormatData;
 
namespace oox { class AttributeList; }
 
namespace oox::xls {
 
class CondFormat;
 
struct CondFormatRuleModel
{
    typedef ::std::vector< ApiTokenSequence > ApiTokenSequenceVector;
 
    ApiTokenSequenceVector maFormulas;      
    OUString     maText;             
    sal_Int32           mnPriority;         
    sal_Int32           mnType;             
    sal_Int32           mnOperator;         
    sal_Int32           mnTimePeriod;       
    sal_Int32           mnRank;             
    sal_Int32           mnStdDev;           
    sal_Int32           mnDxfId;            
    bool                mbStopIfTrue;       
    bool                mbBottom;           
    bool                mbPercent;          
    bool                mbAboveAverage;     
    bool                mbEqualAverage;     
 
    explicit            CondFormatRuleModel();
 
    void                setBiffOperator( sal_Int32 nOperator );
 
    void                setBiff12TextType( sal_Int32 nOperator );
};
 
struct ColorScaleRuleModelEntry
{
    ::Color maColor;
    double mnVal;
 
    bool mbMin;
    bool mbMax;
    bool mbPercent;
    bool mbPercentile;
    bool mbNum;
    OUString maFormula;
 
    ColorScaleRuleModelEntry():
        maColor(),
        mnVal(0),
        mbMin(false),
        mbMax(false),
        mbPercent(false),
        mbPercentile(false),
        mbNum(false) {}
};
 
class ColorScaleRule final : public WorksheetHelper
{
public:
    ColorScaleRule( const CondFormat& rFormat );
 
    void importCfvo( const AttributeList& rAttribs );
    void importColor( const AttributeList& rAttribs );
 
    void AddEntries( ScColorScaleFormat* pFormat, ScDocument* pDoc, const ScAddress& rAddr );
 
private:
    std::vector< ColorScaleRuleModelEntry > maColorScaleRuleEntries;
 
    sal_uInt32 mnCfvo;
    sal_uInt32 mnCol;
};
 
class DataBarRule final : public WorksheetHelper
{
public:
    DataBarRule( const CondFormat& rFormat );
    void importCfvo( const AttributeList& rAttribs );
    void importColor( const AttributeList& rAttribs );
    void importAttribs( const AttributeList& rAttribs );
 
    void SetData( ScDataBarFormat* pFormat, ScDocument* pDoc, const ScAddress& rAddr );
 
    ScDataBarFormatData* getDataBarFormatData() { return mxFormat.get(); }
 
private:
    std::unique_ptr<ScDataBarFormatData> mxFormat;
 
    std::unique_ptr<ColorScaleRuleModelEntry> mpUpperLimit;
    std::unique_ptr<ColorScaleRuleModelEntry> mpLowerLimit;
};
 
class IconSetRule final : public WorksheetHelper
{
public:
    IconSetRule( const WorksheetHelper& rParent );
    void importCfvo( const AttributeList& rAttribs );
    void importAttribs( const AttributeList& rAttribs );
    void importFormula(const OUString& rFormula);
    void importIcon(const AttributeList& rAttribs);
 
    void SetData( ScIconSetFormat* pFormat, ScDocument* pDoc, const ScAddress& rAddr );
 
private:
    std::vector< ColorScaleRuleModelEntry > maEntries;
    std::unique_ptr<ScIconSetFormatData> mxFormatData;
    OUString maIconSetType;
    bool mbCustom;
};
 
class CondFormatRule final : public WorksheetHelper
{
friend class CondFormatBuffer;
public:
    explicit            CondFormatRule( const CondFormat& rCondFormat, ScConditionalFormat* pFormat );
 
    void                importCfRule( const AttributeList& rAttribs );
    void                appendFormula( const OUString& rFormula );
 
    void                importCfRule( SequenceInputStream& rStrm );
 
    void                setFormatEntry(sal_Int32 nPriority, ScFormatEntry* pEntry);
 
    void                finalizeImport();
 
    sal_Int32    getPriority() const { return maModel.mnPriority; }
 
    ColorScaleRule*     getColorScale();
    DataBarRule*        getDataBar();
    IconSetRule*            getIconSet();
 
private:
    const CondFormat&   mrCondFormat;
    CondFormatRuleModel maModel;
    ScConditionalFormat* mpFormat;
    ScFormatEntry*       mpFormatEntry;
    std::unique_ptr<ColorScaleRule> mpColor;
    std::unique_ptr<DataBarRule> mpDataBar;
    std::unique_ptr<IconSetRule> mpIconSet;
};
 
typedef std::shared_ptr< CondFormatRule > CondFormatRuleRef;
 
struct CondFormatModel
{
    ScRangeList         maRanges;           
    bool                mbPivot;            
 
    explicit            CondFormatModel();
};
 
class CondFormatBuffer;
 
class CondFormat final : public WorksheetHelper
{
friend class CondFormatBuffer;
public:
    explicit            CondFormat( const WorksheetHelper& rHelper );
    ~CondFormat();
 
    void                importConditionalFormatting( const AttributeList& rAttribs );
    CondFormatRuleRef   importCfRule( const AttributeList& rAttribs );
 
    void                importCondFormatting( SequenceInputStream& rStrm );
    void                importCfRule( SequenceInputStream& rStrm );
 
    void                finalizeImport();
 
    const ScRangeList& getRanges() const { return maModel.maRanges; }
 
    void                setReadyForFinalize() { mbReadyForFinalize = true; }
    void                insertRule( CondFormatRuleRef const & xRule );
private:
    CondFormatRuleRef   createRule();
 
private:
    typedef RefMap< sal_Int32, CondFormatRule > CondFormatRuleMap;
 
    CondFormatModel     maModel;            
    CondFormatRuleMap   maRules;            
    ScConditionalFormat* mpFormat;
    bool                mbReadyForFinalize;
};
 
struct ExCfRuleModel
{
    ExCfRuleModel() : mnAxisColor( ColorTransparency, UNSIGNED_RGB_TRANSPARENT ), mnNegativeColor( ColorTransparency, UNSIGNED_RGB_TRANSPARENT ), mbGradient( false ), mbIsLower( true ) {}
    // AxisColor
    ::Color mnAxisColor;
    ::Color mnPositiveColor;
    // NegativeFillColor
    ::Color mnNegativeColor;
    OUString maAxisPosition; // DataBar
    OUString maColorScaleType; // Cfvo
    OUString msScaleTypeValue; // Cfvo
    bool mbGradient; // DataBar
    bool mbIsLower; // Cfvo
};
 
class ExtCfDataBarRule : public WorksheetHelper
{
    enum RuleType
    {
        DATABAR,
        POSITIVEFILLCOLOR,
        NEGATIVEFILLCOLOR,
        AXISCOLOR,
        CFVO,
        UNKNOWN,
    };
    ExCfRuleModel maModel;
    RuleType mnRuleType;
    ScDataBarFormatData* mpTarget;
public:
 
    ExtCfDataBarRule(ScDataBarFormatData* pTarget, const WorksheetHelper& rParent);
    void finalizeImport();
    void importDataBar(  const AttributeList& rAttribs );
    void importPositiveFillColor(  const AttributeList& rAttribs );
    void importNegativeFillColor(  const AttributeList& rAttribs );
    void importAxisColor(  const AttributeList& rAttribs );
    void importCfvo(  const AttributeList& rAttribs );
    ExCfRuleModel& getModel() { return maModel; }
    const ScDataBarFormatData* GetDataBarData() { return mpTarget; }
};
 
class ExtCfCondFormat
{
public:
    ExtCfCondFormat(ScRangeList aRange, std::vector< std::unique_ptr<ScFormatEntry> >& rEntries,
                    const std::vector<sal_Int32>* pPriorities = nullptr);
    ~ExtCfCondFormat();
 
    const ScRangeList& getRange() const;
    const std::vector< std::unique_ptr<ScFormatEntry> >& getEntries() const;
    const std::vector<sal_Int32>& getPriorities() const { return maPriorities; }
 
private:
    std::vector< std::unique_ptr<ScFormatEntry> > maEntries;
    std::vector<sal_Int32> maPriorities;
    ScRangeList maRange;
};
 
typedef std::shared_ptr< CondFormat > CondFormatRef;
typedef std::shared_ptr< ExtCfDataBarRule > ExtCfDataBarRuleRef;
 
class CondFormatBuffer final : public WorksheetHelper
{
public:
    explicit            CondFormatBuffer( const WorksheetHelper& rHelper );
 
    CondFormatRef       importConditionalFormatting( const AttributeList& rAttribs );
    CondFormatRef       importCondFormatting( SequenceInputStream& rStrm );
    ExtCfDataBarRuleRef createExtCfDataBarRule(ScDataBarFormatData* pTarget);
    std::vector< std::unique_ptr<ExtCfCondFormat> >& importExtCondFormat();
    std::vector<std::unique_ptr<ScFormatEntry> >& importExtFormatEntries();
 
    static sal_Int32    convertToApiOperator( sal_Int32 nToken );
    static ScConditionMode convertToInternalOperator( sal_Int32 nToken );
    void                finalizeImport();
    bool                insertRule(CondFormatRef const & xCondFmt, CondFormatRuleRef const & xRule);
 
private:
    CondFormatRef       createCondFormat();
    void                updateImport(const ScDataBarFormatData* pTarget);
 
private:
    typedef RefVector< CondFormat > CondFormatVec;
    typedef RefVector< ExtCfDataBarRule > ExtCfDataBarRuleVec;
    CondFormatVec       maCondFormats;      
    ExtCfDataBarRuleVec        maCfRules;          
    std::vector< std::unique_ptr<ExtCfCondFormat> > maExtCondFormats;
    std::vector<std::unique_ptr<ScFormatEntry> > maExtFormatEntries;
    sal_Int32 mnNonPrioritizedRuleNextPriority = 1048576;
};
 
} // namespace oox::xls
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */