excrecds.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 <rtl/string.hxx>
#include <rtl/ustring.hxx>
#include <tools/color.hxx>
 
#include "xerecord.hxx"
#include "xeroot.hxx"
#include "excdefs.hxx"
 
//------------------------------------------------------------------ Forwards -
 
class ScDBData;
struct ScQueryEntry;
 
//----------------------------------------------------------- class ExcRecord -
 
class ExcRecord : public XclExpRecord
{
public:
    virtual void            Save( XclExpStream& rStrm ) override;
    virtual void            SaveXml( XclExpXmlStream& rStrm ) override;
 
    virtual sal_uInt16          GetNum() const = 0;
    virtual std::size_t     GetLen() const = 0;
 
protected:
    virtual void            SaveCont( XclExpStream& rStrm );
 
private:
    virtual void            WriteBody( XclExpStream& rStrm ) override;
};
 
//--------------------------------------------------------- class ExcEmptyRec -
 
class ExcEmptyRec : public ExcRecord
{
private:
protected:
public:
    virtual void            Save( XclExpStream& rStrm ) override;
    virtual sal_uInt16          GetNum() const override;
    virtual std::size_t     GetLen() const override;
};
 
//--------------------------------------------------------- class ExcDummyRec -
 
class ExcDummyRec : public ExcRecord
{
protected:
public:
    virtual void            Save( XclExpStream& rStrm ) override;
    virtual sal_uInt16          GetNum() const override;
    virtual const sal_uInt8*        GetData() const = 0;    // byte data must contain header and body
};
 
//------------------------------------------------------- class ExcBoolRecord -
// stores bool as 16bit val ( 0x0000 | 0x0001 )
 
class ExcBoolRecord : public ExcRecord
{
private:
    virtual void            SaveCont( XclExpStream& rStrm ) override;
 
protected:
    bool                    bVal;
 
    ExcBoolRecord() : bVal( false ) {}
 
public:
    virtual std::size_t     GetLen() const override;
};
 
//--------------------------------------------------------- class ExcBof_Base -
 
class ExcBof_Base : public ExcRecord
{
private:
protected:
    sal_uInt16                  nDocType;
    sal_uInt16                  nVers;
    sal_uInt16                  nRupBuild;
    sal_uInt16                  nRupYear;
public:
                            ExcBof_Base();
};
 
//-------------------------------------------------------------- class ExcBof -
// Header Record for WORKSHEETS
 
class ExcBof : public ExcBof_Base
{
private:
    virtual void            SaveCont( XclExpStream& rStrm ) override;
public:
                            ExcBof();
 
    virtual sal_uInt16          GetNum() const override;
    virtual std::size_t     GetLen() const override;
};
 
//------------------------------------------------------------- class ExcBofW -
// Header Record for WORKBOOKS
 
class ExcBofW : public ExcBof_Base
{
private:
    virtual void            SaveCont( XclExpStream& rStrm ) override;
public:
                            ExcBofW();
 
    virtual sal_uInt16          GetNum() const override;
    virtual std::size_t     GetLen() const override;
};
 
//-------------------------------------------------------------- class ExcEof -
 
class ExcEof : public ExcRecord
{
private:
public:
    virtual sal_uInt16          GetNum() const override;
    virtual std::size_t     GetLen() const override;
};
 
//--------------------------------------------------------- class ExcDummy_00 -
// INTERFACEHDR to FNGROUPCOUNT (see excrecds.cxx)
 
class ExcDummy_00 : public ExcDummyRec
{
private:
    static const sal_uInt8      pMyData[];
    static const std::size_t   nMyLen;
public:
    virtual std::size_t        GetLen() const override;
    virtual const sal_uInt8*        GetData() const override;
};
 
// EXC_ID_WINDOWPROTECTION
class XclExpWindowProtection : public   XclExpBoolRecord
{
    public:
        XclExpWindowProtection(bool bValue);
 
    virtual void            SaveXml( XclExpXmlStream& rStrm ) override;
};
 
// EXC_ID_PROTECT  Document Protection
class XclExpProtection : public XclExpBoolRecord
{
    public:
        XclExpProtection(bool bValue);
};
 
class XclExpSheetProtection : public XclExpProtection
{
    SCTAB                   mnTab;
    public:
        XclExpSheetProtection(bool bValue, SCTAB nTab);
    virtual void            SaveXml( XclExpXmlStream& rStrm ) override;
};
 
class XclExpPassHash : public XclExpRecord
{
public:
    XclExpPassHash(const css::uno::Sequence<sal_Int8>& aHash);
    virtual ~XclExpPassHash() override;
 
private:
    virtual void    WriteBody(XclExpStream& rStrm) override;
 
private:
    sal_uInt16  mnHash;
};
 
//-------------------------------------------------------- class ExcDummy_04x -
// PASSWORD to BOOKBOOL (see excrecds.cxx), no 1904
 
class ExcDummy_040 : public ExcDummyRec
{
private:
    static const sal_uInt8      pMyData[];
    static const std::size_t   nMyLen;
public:
    virtual std::size_t        GetLen() const override;
    virtual const sal_uInt8*        GetData() const override;
};
 
class ExcDummy_041 : public ExcDummyRec
{
private:
    static const sal_uInt8     pMyData[];
    static const std::size_t   nMyLen;
public:
    virtual std::size_t        GetLen() const override;
    virtual const sal_uInt8*   GetData() const override;
};
 
//------------------------------------------------------------- class Exc1904 -
 
class Exc1904 : public ExcBoolRecord
{
public:
                            Exc1904( const ScDocument& rDoc );
    virtual sal_uInt16      GetNum() const override;
 
    virtual void            SaveXml( XclExpXmlStream& rStrm ) override;
private:
    bool                    bDateCompatibility;
};
 
//------------------------------------------------------ class ExcBundlesheet -
 
class ExcBundlesheetBase : public ExcRecord
{
protected:
    sal_uInt64              m_nStrPos;
    sal_uInt64              m_nOwnPos;    // Position after # and Len
    sal_uInt16              nGrbit;
    SCTAB                   nTab;
 
                            ExcBundlesheetBase();
 
public:
                            ExcBundlesheetBase( const RootData& rRootData, SCTAB nTab );
 
    void                    SetStreamPos(sal_uInt64 const nStrPos) { m_nStrPos = nStrPos; }
    void                    UpdateStreamPos( XclExpStream& rStrm );
 
    virtual sal_uInt16          GetNum() const override;
};
 
class ExcBundlesheet : public ExcBundlesheetBase
{
private:
    OString            aName;
 
    virtual void            SaveCont( XclExpStream& rStrm ) override;
 
public:
                            ExcBundlesheet( const RootData& rRootData, SCTAB nTab );
    virtual std::size_t     GetLen() const override;
};
 
//--------------------------------------------------------- class ExcDummy_02 -
// sheet dummies: CALCMODE to SETUP
 
class ExcDummy_02a : public ExcDummyRec
{
private:
    static const sal_uInt8      pMyData[];
    static const std::size_t   nMyLen;
public:
    virtual std::size_t        GetLen() const override;
    virtual const sal_uInt8*        GetData() const override;
};
 
class XclExpCountry : public XclExpRecord
{
public:
    explicit                    XclExpCountry( const XclExpRoot& rRoot );
 
private:
    sal_uInt16                  mnUICountry;        
    sal_uInt16                  mnDocCountry;       
 
    virtual void                WriteBody( XclExpStream& rStrm ) override;
};
 
// XclExpWsbool ===============================================================
 
class XclExpWsbool : public XclExpUInt16Record
{
public:
    explicit XclExpWsbool( bool bFitToPages );
};
 
class XclExpXmlSheetPr : public XclExpRecordBase
{
public:
    explicit XclExpXmlSheetPr(
        bool bFitToPages, SCTAB nScTab, const Color& rTabColor, XclExpFilterManager* pManager );
 
    virtual void SaveXml( XclExpXmlStream& rStrm ) override;
 
private:
    SCTAB mnScTab;
    XclExpFilterManager* mpManager;
    bool mbFitToPage;
    Color maTabColor;
};
 
class XclExpFiltermode : public XclExpEmptyRecord
{
public:
    explicit            XclExpFiltermode();
};
 
class XclExpAutofilterinfo : public XclExpUInt16Record
{
public:
    explicit            XclExpAutofilterinfo( const ScAddress& rStartPos, SCCOL nScCol );
 
    const ScAddress& GetStartPos() const { return maStartPos; }
    SCCOL        GetColCount() const { return static_cast< SCCOL >( GetValue() ); }
 
private:
    ScAddress           maStartPos;
};
 
class ExcFilterCondition
{
private:
    sal_uInt8               nType;
    sal_uInt8               nOper;
    std::unique_ptr<XclExpString>
                            pText;
 
protected:
public:
                            ExcFilterCondition();
                            ~ExcFilterCondition();
 
    bool             IsEmpty() const     { return (nType == EXC_AFTYPE_NOTUSED); }
    std::size_t             GetTextBytes() const;
 
    void                    SetCondition( sal_uInt8 nTp, sal_uInt8 nOp, const OUString* pT );
 
    void                    Save( XclExpStream& rStrm );
    void                    SaveXml( XclExpXmlStream& rStrm );
    void                    SaveText( XclExpStream& rStrm );
};
 
class XclExpAutofilter : public XclExpRecord, protected XclExpRoot
{
private:
    enum FilterType
    {
        FilterCondition,
        MultiValue,
        BlankValue,
        ColorValue
    };
    FilterType              meType;
    sal_uInt16              nCol;
    sal_uInt16              nFlags;
    bool                    bHasBlankValue;
    ExcFilterCondition      aCond[ 2 ];
    std::vector<std::pair<OUString, bool>> maMultiValues; // first->values, second->bDateFormat
    std::vector<std::pair<::Color, bool>> maColorValues; // first->Color, second->bIsBackgroundColor (vs. TextColor)
 
    bool                    AddCondition( ScQueryConnect eConn, sal_uInt8 nType,
                                sal_uInt8 nOp, const OUString* pText, bool bSimple = false );
 
    virtual void            WriteBody( XclExpStream& rStrm ) override;
 
public:
                            XclExpAutofilter( const XclExpRoot& rRoot, sal_uInt16 nC );
 
    sal_uInt16       GetCol() const          { return nCol; }
    bool             HasTop10() const        { return ::get_flag( nFlags, EXC_AFFLAG_TOP10 ); }
 
    bool                    HasCondition() const;
    bool                    AddEntry( const ScQueryEntry& rEntry );
    void                    AddMultiValueEntry( const ScQueryEntry& rEntry );
    void AddColorEntry( const ScQueryEntry& rEntry );
 
    virtual void            SaveXml( XclExpXmlStream& rStrm ) override;
};
 
class ExcAutoFilterRecs : public XclExpRecordBase, protected XclExpRoot
{
public:
    explicit            ExcAutoFilterRecs( const XclExpRoot& rRoot, SCTAB nTab, const ScDBData* pDefinedData );
    virtual             ~ExcAutoFilterRecs() override;
 
    void                AddObjRecs();
 
    virtual void        Save( XclExpStream& rStrm ) override;
    virtual void        SaveXml( XclExpXmlStream& rStrm ) override;
 
    bool                HasFilterMode() const;
 
private:
    XclExpAutofilter*   GetByCol( SCCOL nCol ); // always 0-based
    bool                IsFiltered( SCCOL nCol );
 
private:
    typedef XclExpRecordList< XclExpAutofilter >    XclExpAutofilterList;
    typedef XclExpAutofilterList::RecordRefType     XclExpAutofilterRef;
 
    XclExpAutofilterList maFilterList;
    rtl::Reference<XclExpFiltermode> m_pFilterMode;
    rtl::Reference<XclExpAutofilterinfo> m_pFilterInfo;
    ScRange                 maRef;
    bool mbAutoFilter;
 
    ScRange maSortRef; // sort area without headers
    std::vector< std::tuple<ScRange, OUString, bool> > maSortCustomList; // sorted column with list of sorted items
};
 
class XclExpFilterManager : protected XclExpRoot
{
public:
    explicit            XclExpFilterManager( const XclExpRoot& rRoot );
 
    void                InitTabFilter( SCTAB nScTab );
 
    XclExpRecordRef     CreateRecord( SCTAB nScTab );
 
    bool                HasFilterMode( SCTAB nScTab );
 
private:
    using               XclExpRoot::CreateRecord;
 
    typedef rtl::Reference< ExcAutoFilterRecs >  XclExpTabFilterRef;
    typedef ::std::map< SCTAB, XclExpTabFilterRef > XclExpTabFilterMap;
 
    XclExpTabFilterMap  maFilterMap;
};
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */