global.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 "address.hxx"
#include "typedstrdata.hxx"
#include <i18nlangtag/lang.h>
#include <svx/svdtypes.hxx>
#include <tools/ref.hxx>
#include <sal/types.h>
#include <com/sun/star/i18n/CollatorOptions.hpp>
#include "scdllapi.h"
#include <rtl/ustring.hxx>
#include <tools/long.hxx>
#include <o3tl/unit_conversion.hxx>
 
#include <atomic>
// HACK: <atomic> includes <stdbool.h>, which in some Clang versions does '#define bool bool',
// which confuses clang plugins.
#undef bool
 
#include <memory>
#include <optional>
#include <string_view>
 
namespace com::sun::star::uno { template <typename > class Reference; }
 
class SfxItemSet;
class SfxViewShell;
struct ScCalcConfig;
enum class SvtScriptType : sal_uInt8;
enum class FormulaError : sal_uInt16;
enum class SvNumFormatType : sal_Int16;
 
#define SC_COLLATOR_IGNORES css::i18n::CollatorOptions::CollatorOptions_IGNORE_CASE
 
//  Calc has lots of names...
//  Clipboard names are in so3/soapp.hxx now
//  STRING_SCAPP was "scalc3", "scalc4", now just "scalc"
 
inline constexpr OUStringLiteral STRING_SCAPP = u"scalc";
 
inline constexpr OUStringLiteral STRING_STANDARD = u"Standard";
 
// Have the dreaded programmatic filter name defined in one place.
inline constexpr OUStringLiteral SC_TEXT_CSV_FILTER_NAME = u"Text - txt - csv (StarCalc)";
 
// characters
 
const sal_Unicode CHAR_NBSP     = 0x00A0;
const sal_Unicode CHAR_SHY      = 0x00AD;
const sal_Unicode CHAR_ZWSP     = 0x200B;
const sal_Unicode CHAR_LRM      = 0x200E;
const sal_Unicode CHAR_RLM      = 0x200F;
const sal_Unicode CHAR_NBHY     = 0x2011;
const sal_Unicode CHAR_WJ       = 0x2060;
const sal_Unicode CHAR_NNBSP    = 0x202F; //NARROW NO-BREAK SPACE
 
#define MINDOUBLE   1.7e-307
#define MAXDOUBLE   1.7e307
 
const sal_uInt16 MINZOOM = 20;
const sal_uInt16 MAXZOOM = 400;
 
const SCSIZE MAXSUBTOTAL        = 3;
 
// ~105.88 twip, i.e. about 2 times narrower than o3tl::Length::ch, which is 210 twip
constexpr auto TWIPS_PER_CHAR = o3tl::toTwips(1 / 13.6, o3tl::Length::in);
 
constexpr sal_Int32 STD_COL_WIDTH = o3tl::convert(64, o3tl::Length::pt, o3tl::Length::twip);
constexpr sal_Int32 STD_EXTRA_WIDTH = o3tl::convert(2, o3tl::Length::mm, o3tl::Length::twip);
 
constexpr sal_Int32 MAX_EXTRA_WIDTH = o3tl::convert(42, o3tl::Length::cm, o3tl::Length::twip);
constexpr sal_Int32 MAX_EXTRA_HEIGHT = o3tl::convert(42, o3tl::Length::cm, o3tl::Length::twip);
constexpr sal_Int32 MAX_COL_WIDTH = o3tl::convert(1, o3tl::Length::m, o3tl::Length::twip);
constexpr sal_Int32 MAX_ROW_HEIGHT = o3tl::convert(1, o3tl::Length::m, o3tl::Length::twip);
 
                                    /* standard row height: text + margin - STD_ROWHEIGHT_DIFF */
#define STD_ROWHEIGHT_DIFF  23
 
namespace sc
{
    constexpr ::tools::Long TwipsToEvenHMM( ::tools::Long nTwips ) { return o3tl::convert(nTwips, 127, 144) * 2; }
}
 
                                    // standard size as OLE server (cells)
#define OLE_STD_CELLS_X     4
#define OLE_STD_CELLS_Y     5
 
 
                                    // repaint flags (for messages)
enum class PaintPartFlags {
    NONE          = 0x00,
    Grid          = 0x01,
    Top           = 0x02,
    Left          = 0x04,
    Extras        = 0x08,
    Marks         = 0x10,
    Objects       = 0x20,
    Size          = 0x40,
    All           = Grid | Top | Left | Extras | Objects | Size,
};
namespace o3tl {
    template<> struct typed_flags<PaintPartFlags> : is_typed_flags<PaintPartFlags, 0x07f> {};
}
 
                                    // flags for columns / rows
enum class CRFlags : sal_uInt8 {
    // Filtered always together with Hidden
    // Filtered and ManualSize only valid for rows
    NONE        = 0x00,
    Hidden      = 0x01,
    ManualBreak = 0x02,
    Filtered    = 0x04,
    ManualSize  = 0x08,
    All         = Hidden | ManualBreak | Filtered | ManualSize
};
namespace o3tl {
    template<> struct typed_flags<CRFlags> : is_typed_flags<CRFlags, 0x0f> {};
}
 
enum class ScBreakType {
    NONE   = 0x00,
    Page   = 0x01,
    Manual = 0x02
};
namespace o3tl {
    template<> struct typed_flags<ScBreakType> : is_typed_flags<ScBreakType, 0x03> {};
}
 
enum class InsertDeleteFlags : sal_uInt16
{
    NONE             = 0x0000,
    VALUE            = 0x0001,   
    DATETIME         = 0x0002,   
    STRING           = 0x0004,   
    NOTE             = 0x0008,   
    FORMULA          = 0x0010,   
    HARDATTR         = 0x0020,   
    STYLES           = 0x0040,   
    OBJECTS          = 0x0080,   
    EDITATTR         = 0x0100,   
    OUTLINE          = 0x0800,   
    SPARKLINES       = 0x4000,   
    NOCAPTIONS       = 0x0200,   
    ADDNOTES         = 0x0400,   
    SPECIAL_BOOLEAN  = 0x1000,
    FORGETCAPTIONS   = 0x2000,   
    ATTRIB           = HARDATTR | STYLES,
    CONTENTS         = VALUE | DATETIME | STRING | NOTE | FORMULA | OUTLINE | SPARKLINES,
    // tdf#116127 - add EDITATTR to ALL flags in order to check for valid function inputs
    ALL              = CONTENTS | ATTRIB | OBJECTS | SPARKLINES | EDITATTR,
    AUTOFILL         = ALL & ~(NOTE | OBJECTS)
};
namespace o3tl
{
    template<> struct typed_flags<InsertDeleteFlags> : is_typed_flags<InsertDeleteFlags, 0x7fff> {};
}
// This doesn't work at the moment, perhaps when we have constexpr we can modify InsertDeleteFlags to make it work.
//static_assert((InsertDeleteFlags::ATTRIB & InsertDeleteFlags::CONTENTS) == InsertDeleteFlags::NONE, "these must match");
 
 
enum class ScPasteFunc {
    NONE, ADD, SUB, MUL, DIV
};
                                        // bits for HasAttr
enum class HasAttrFlags {
    NONE            = 0x0000,
    Lines           = 0x0001,
    Merged          = 0x0002,
    Overlapped      = 0x0004,
    Protected       = 0x0008,
    Shadow          = 0x0010,
    NeedHeight      = 0x0020,
    ShadowRight     = 0x0040,
    ShadowDown      = 0x0080,
    AutoFilter      = 0x0100,
    Conditional     = 0x0200,
    Rotate          = 0x0400,
    NotOverlapped   = 0x0800,
    RightOrCenter   = 0x1000,   // right or centered logical alignment
};
namespace o3tl {
    template<> struct typed_flags<HasAttrFlags> : is_typed_flags<HasAttrFlags, 0x1fff> {};
}
 
 
// Layer id's for drawing.
// These are both id's and positions.
constexpr SdrLayerID SC_LAYER_FRONT   (0);
constexpr SdrLayerID SC_LAYER_BACK    (1);
constexpr SdrLayerID SC_LAYER_INTERN  (2);
constexpr SdrLayerID SC_LAYER_CONTROLS(3);
constexpr SdrLayerID SC_LAYER_HIDDEN  (4);
 
//  link tables
enum class ScLinkMode {
    NONE, NORMAL, VALUE
};
                                        //  input
enum class ScEnterMode {
    NORMAL, BLOCK, MATRIX
};
 
                                        //  step = 10pt, max. indention = 100 steps
#define SC_INDENT_STEP      200
 
enum class ScScenarioFlags{             //  scenario flags
    NONE       = 0,
    CopyAll    = 1,
    ShowFrame  = 2,
    PrintFrame = 4,
    TwoWay     = 8,
    Attrib     = 16,
    Value      = 32,
    Protected  = 64
};
namespace o3tl {
    template<> struct typed_flags<ScScenarioFlags> : is_typed_flags<ScScenarioFlags, 127> {};
}
 
enum class SubtotalFlags {
    NONE              = 0x00,
    IgnoreNestedStAg  = 0x08,
    IgnoreErrVal      = 0x04,
    IgnoreHidden      = 0x02,
    IgnoreFiltered    = 0x01
};
namespace o3tl {
    template<> struct typed_flags<SubtotalFlags> : is_typed_flags<SubtotalFlags, 0x0f> {};
}
 
enum class ScCloneFlags{
    Default          = 0x0000,
 
    StartListening   = 0x0001,
 
    NoMakeAbsExternal = 0x0002,
 
    NamesToLocal   = 0x0004
};
namespace o3tl
{
    template<> struct typed_flags<ScCloneFlags> : is_typed_flags<ScCloneFlags, 0x0007> {};
}
 
enum CellType
    {
        CELLTYPE_NONE,
        CELLTYPE_VALUE,
        CELLTYPE_STRING,
        CELLTYPE_FORMULA,
        CELLTYPE_EDIT,
    };
 
enum class DelCellCmd
    {
        CellsUp,
        CellsLeft,
        Rows,
        Cols,
        NONE
    };
 
enum InsCellCmd
    {
        INS_CELLSDOWN,
        INS_CELLSRIGHT,
        INS_INSROWS_BEFORE,
        INS_INSCOLS_BEFORE,
        INS_NONE,
        INS_INSROWS_AFTER,
        INS_INSCOLS_AFTER
    };
 
enum UpdateRefMode
    {
        URM_INSDEL,
        URM_COPY,
        URM_MOVE,
        URM_REORDER
    };
 
enum FillDir
    {
        FILL_TO_BOTTOM,
        FILL_TO_RIGHT,
        FILL_TO_TOP,
        FILL_TO_LEFT
    };
 
enum FillCmd
    {
        FILL_SIMPLE,
        FILL_LINEAR,
        FILL_GROWTH,
        FILL_DATE,
        FILL_AUTO
    };
 
enum ScMoveDirection
{
    SC_MOVE_RIGHT,
    SC_MOVE_LEFT,
    SC_MOVE_UP,
    SC_MOVE_DOWN
};
 
enum FillDateCmd
    {
        FILL_DAY,
        FILL_WEEKDAY,
        FILL_MONTH,
        FILL_END_OF_MONTH,
        FILL_YEAR
    };
 
enum ScDirection
    {
        DIR_BOTTOM,
        DIR_RIGHT,
        DIR_TOP,
        DIR_LEFT
    };
 
enum ScSizeMode
    {
        SC_SIZE_DIRECT,             // set size or hide if value is 0
        SC_SIZE_OPTIMAL,            // set optimal size for everything
        SC_SIZE_SHOW,               // show with original size
        SC_SIZE_VISOPT,             // set optimal size only if visible
        SC_SIZE_ORIGINAL            // only set size, don't change visible flag
    };
 
enum ScInputMode
    {
        SC_INPUT_NONE,
        SC_INPUT_TYPE,              // input, while not in inplace mode
        SC_INPUT_TABLE,             // text cursor in the table
        SC_INPUT_TOP                // text cursor in the input line
    };
 
enum ScVObjMode                     // output modes of objects on a page
{
    VOBJ_MODE_SHOW,
    VOBJ_MODE_HIDE
};
 
enum ScAnchorType                   // anchor of a character object
{
    SCA_CELL,                       // anchor to cell, move with cell
    SCA_CELL_RESIZE,                // anchor to cell, move and resize with cell
    SCA_PAGE,                       // anchor to page, independent of any cells
    SCA_DONTKNOW                    // for multi selection
};
 
enum ScGetDBMode
{
    SC_DB_MAKE,         
    SC_DB_AUTOFILTER,   
    SC_DB_IMPORT,       
    SC_DB_OLD           
};
 
enum class ScGetDBSelection
{
    Keep,
 
    ShrinkToUsedData,
 
    RowDown,
 
    ForceMark
};
 
enum ScLkUpdMode    // modes for updating links
{
    LM_ALWAYS,
    LM_NEVER,
    LM_ON_DEMAND,
    LM_UNKNOWN
};
 
// enum with values equal to old DBObject enum from sdb
enum ScDBObject
{
    ScDbTable,
    ScDbQuery
};
 
namespace sc {
 
enum class ColRowEditAction
{
    Unknown,
    InsertColumnsBefore,
    InsertColumnsAfter,
    InsertRowsBefore,
    InsertRowsAfter,
    DeleteColumns,
    DeleteRows
};
 
}
 
struct ScImportParam
{
    SCCOL           nCol1;
    SCROW           nRow1;
    SCCOL           nCol2;
    SCROW           nRow2;
    bool            bImport;
    OUString aDBName;                    // alias of data base
    OUString aStatement;
    bool            bNative;
    bool            bSql;                       // statement or name?
    sal_uInt8       nType;                      // enum DBObject
 
    ScImportParam();
    ScImportParam( const ScImportParam& r );
    ~ScImportParam();
 
    ScImportParam&  operator=   ( const ScImportParam& r );
    bool            operator==  ( const ScImportParam& r ) const;
};
 
// Formula data replacement character for a pair of parentheses at end of
// function name, to force sorting parentheses before all other characters.
// Collation may treat parentheses differently.
constexpr sal_Unicode cParenthesesReplacement = 0x0001;
struct InputHandlerFunctionNames
{
    ScTypedCaseStrSet       maFunctionData;
    ScTypedCaseStrSet       maFunctionDataPara;
    std::set<sal_Unicode>   maFunctionChar;
};
 
class ScDocShell;
class SvxSearchItem;
class ScAutoFormat;
class LegacyFuncCollection;
class ScUnoAddInCollection;
class ScUserList;
class SvxBrushItem;
class ScFunctionList;
class ScFunctionMgr;
class SfxItemPool;
class EditTextObject;
class SfxObjectShell;
class SvNumberFormatter;
class ScUnitConverter;
class CharClass;
class LocaleDataWrapper;
class SvtSysLocale;
class CalendarWrapper;
class CollatorWrapper;
class IntlWrapper;
class ScFieldEditEngine;
 
namespace com::sun::star {
    namespace lang {
        struct Locale;
    }
    namespace i18n {
        class XOrdinalSuffix;
    }
}
namespace utl {
    class TransliterationWrapper;
}
 
namespace sc {
    class SharedStringPoolPurge;
}
 
class ScGlobal
{
    static std::unique_ptr<SvxSearchItem> xSearchItem;
    static std::unique_ptr<ScAutoFormat> xAutoFormat;
    static std::atomic<LegacyFuncCollection*> pLegacyFuncCollection;
    static std::atomic<ScUnoAddInCollection*> pAddInCollection;
    static std::unique_ptr<ScUserList> xUserList;
    static OUString         aStrClipDocName;
    static std::unique_ptr<SvxBrushItem> xEmptyBrushItem;
    static std::unique_ptr<SvxBrushItem> xButtonBrushItem;
 
    static std::unique_ptr<ScFunctionList> xStarCalcFunctionList;
    static std::unique_ptr<ScFunctionMgr> xStarCalcFunctionMgr;
 
    static std::atomic<ScUnitConverter*> pUnitConverter;
 
    static std::unique_ptr<SvNumberFormatter> xEnglishFormatter;          // for UNO / XML export
 
    static css::uno::Reference< css::i18n::XOrdinalSuffix> xOrdinalSuffix;
    static std::optional<CalendarWrapper>    oCalendar;
    static std::atomic<CollatorWrapper*>     pCaseCollator;
    static std::atomic<CollatorWrapper*>     pCollator;
    static std::atomic<::utl::TransliterationWrapper*> pTransliteration;
    static std::atomic<::utl::TransliterationWrapper*> pCaseTransliteration;
    static std::atomic<css::lang::Locale*>   pLocale;
 
    static std::unique_ptr<ScFieldEditEngine> xFieldEditEngine;
 
    static std::atomic<sc::SharedStringPoolPurge*> pSharedStringPoolPurge;
 
    static InputHandlerFunctionNames maInputHandlerFunctionNames;
 
    static void                 InitPPT();
 
public:
    static std::optional<SvtSysLocale> oSysLocale;
    SC_DLLPUBLIC static const LocaleDataWrapper& getLocaleData();
    SC_DLLPUBLIC static const CharClass& getCharClass();
 
    static CalendarWrapper&     GetCalendar();
    SC_DLLPUBLIC static CollatorWrapper& GetCollator();
    static CollatorWrapper&     GetCaseCollator();
    static CollatorWrapper&     GetCollator(bool bCaseSensitive);
    static css::lang::Locale&   GetLocale();
 
    SC_DLLPUBLIC static ::utl::TransliterationWrapper& GetTransliteration();
    static ::utl::TransliterationWrapper& GetCaseTransliteration();
    static ::utl::TransliterationWrapper& GetTransliteration(bool bCaseSensitive);
 
    SC_DLLPUBLIC static LanguageType            eLnge;
    static constexpr sal_Unicode cListDelimiter = ',';
 
    static const OUString&      GetClipDocName();
    static void                 SetClipDocName( const OUString& rNew );
    SC_DLLPUBLIC static const SvxSearchItem&    GetSearchItem();
    SC_DLLPUBLIC static void                    SetSearchItem( const SvxSearchItem& rNew );
    SC_DLLPUBLIC static ScAutoFormat*       GetAutoFormat();
    SC_DLLPUBLIC static ScAutoFormat*       GetOrCreateAutoFormat();
    static void                 ClearAutoFormat(); //BugId 54209
    static LegacyFuncCollection*      GetLegacyFuncCollection();
    SC_DLLPUBLIC static ScUnoAddInCollection* GetAddInCollection();
    SC_DLLPUBLIC static ScUserList*         GetUserList();
    static void                 SetUserList( const ScUserList* pNewList );
    static void OpenURL(const OUString& rURL, const OUString& rTarget, bool bIgnoreSettings = false);
    static bool                 ShouldOpenURL();
    SC_DLLPUBLIC static OUString            GetAbsDocName( const OUString& rFileName,
                                                const SfxObjectShell* pShell );
    SC_DLLPUBLIC static OUString            GetDocTabName( std::u16string_view rFileName,
                                                std::u16string_view rTabName );
    SC_DLLPUBLIC static sal_uInt32 GetStandardFormat( SvNumberFormatter&, sal_uInt32 nFormat, SvNumFormatType nType );
 
    SC_DLLPUBLIC static sal_uInt16 GetStandardRowHeight();
    SC_DLLPUBLIC static double              nScreenPPTX;
    SC_DLLPUBLIC static double              nScreenPPTY;
 
    static tools::SvRef<ScDocShell>   xDrawClipDocShellRef;
 
    static sal_uInt16           nDefFontHeight;
    SC_DLLPUBLIC static sal_uInt16           nStdRowHeight;
 
    SC_DLLPUBLIC static ::tools::Long                nLastRowHeightExtra;
    static ::tools::Long             nLastColWidthExtra;
 
    SC_DLLPUBLIC static void Init();                     // during start up
    static void             InitAddIns();
    SC_DLLPUBLIC static void Clear();                    // at the end of the program
 
    static void             InitTextHeight(const SfxItemPool* pPool);
    static SvxBrushItem*    GetEmptyBrushItem() { return xEmptyBrushItem.get(); }
    static SvxBrushItem*    GetButtonBrushItem();
 
    static bool             HasStarCalcFunctionList();
    static ScFunctionList*  GetStarCalcFunctionList();
    static ScFunctionMgr*   GetStarCalcFunctionMgr();
    static void             ResetFunctionList();
    static const InputHandlerFunctionNames& GetInputHandlerFunctionNames();
 
    static OUString         GetErrorString(FormulaError nErrNumber);
    static OUString         GetLongErrorString(FormulaError nErrNumber);
    static bool             EETextObjEqual( const EditTextObject* pObj1,
                                            const EditTextObject* pObj2 );
    static bool             CheckWidthInvalidate( bool& bNumFormatChanged,
                                                  const SfxItemSet& rNewAttrs,
                                                  const SfxItemSet& rOldAttrs );
    static bool             HasAttrChanged( const SfxItemSet& rNewAttrs,
                                            const SfxItemSet& rOldAttrs,
                                            const sal_uInt16      nWhich );
 
    static ScUnitConverter* GetUnitConverter();
 
    static const sal_Unicode* UnicodeStrChr( const sal_Unicode* pStr, sal_Unicode c );
 
    static sal_Unicode ToUpperAlpha( sal_Unicode c )
        { return ( c >= 'a' && c <= 'z' ) ? ( c-'a'+'A' ) : c; }
 
    SC_DLLPUBLIC static OUString addToken(
                                std::u16string_view rTokenList, std::u16string_view rToken,
                                sal_Unicode cSep, sal_Int32 nSepCount = 1,
                                bool bForceSep = false );
 
    SC_DLLPUBLIC static bool             IsQuoted( std::u16string_view rString, sal_Unicode cQuote );
 
    SC_DLLPUBLIC static void             AddQuotes( OUString& rString, sal_Unicode cQuote, bool bEscapeEmbedded = true );
 
    SC_DLLPUBLIC static void             EraseQuotes( OUString& rString, sal_Unicode cQuote, bool bUnescapeEmbedded = true );
 
    SC_DLLPUBLIC static sal_Int32   FindUnquoted( const OUString& rString, sal_Unicode cChar, sal_Int32 nStart = 0 );
 
    SC_DLLPUBLIC static const sal_Unicode* FindUnquoted( const sal_Unicode* pString, sal_Unicode cChar );
 
    static  rtl_TextEncoding GetCharsetValue( std::u16string_view rCharSet );
    static  OUString        GetCharsetString( rtl_TextEncoding eVal );
 
    static  SvNumberFormatter*  GetEnglishFormatter();
 
    static bool IsSystemRTL();                      // depending on system language
    static LanguageType GetEditDefaultLanguage();   // for EditEngine::SetDefaultLanguage
    SC_DLLPUBLIC static SvtScriptType GetDefaultScriptType();             // for all WEAK characters
    SC_DLLPUBLIC static sal_uInt16 GetScriptedWhichID( SvtScriptType nScriptType, sal_uInt16 nWhich );
 
    SC_DLLPUBLIC static void             AddLanguage( SfxItemSet& rSet, const SvNumberFormatter& rFormatter );
 
    static OUString         GetOrdinalSuffix( sal_Int32 nNumber);
 
    static ScFieldEditEngine&   GetStaticFieldEditEngine();
 
    static sc::SharedStringPoolPurge& GetSharedStringPoolPurge();
 
    SC_DLLPUBLIC static OUString    ReplaceOrAppend( const OUString& rString,
                                                     std::u16string_view rPlaceholder,
                                                     const OUString& rReplacement );
 
 
    static double ConvertStringToValue( const OUString& rStr, const ScCalcConfig& rConfig,
            FormulaError & rError, FormulaError nStringNoValueError,
            SvNumberFormatter* pFormatter, SvNumFormatType & rCurFmtType );
 
    SC_DLLPUBLIC static bool bThreadedGroupCalcInProgress;
};
 
// maybe move to dbdata.hxx (?):
 
enum ScQueryOp
    {
        SC_EQUAL,
        SC_LESS,
        SC_GREATER,
        SC_LESS_EQUAL,
        SC_GREATER_EQUAL,
        SC_NOT_EQUAL,
        SC_TOPVAL,
        SC_BOTVAL,
        SC_TOPPERC,
        SC_BOTPERC,
        SC_CONTAINS,
        SC_DOES_NOT_CONTAIN,
        SC_BEGINS_WITH,
        SC_DOES_NOT_BEGIN_WITH,
        SC_ENDS_WITH,
        SC_DOES_NOT_END_WITH
    };
 
enum ScQueryConnect
    {
        SC_AND,
        SC_OR
    };
 
enum ScSubTotalFunc
    {
        SUBTOTAL_FUNC_NONE  = 0,
        SUBTOTAL_FUNC_AVE   = 1,
        SUBTOTAL_FUNC_CNT   = 2,
        SUBTOTAL_FUNC_CNT2  = 3,
        SUBTOTAL_FUNC_MAX   = 4,
        SUBTOTAL_FUNC_MIN   = 5,
        SUBTOTAL_FUNC_PROD  = 6,
        SUBTOTAL_FUNC_STD   = 7,
        SUBTOTAL_FUNC_STDP  = 8,
        SUBTOTAL_FUNC_SUM   = 9,
        SUBTOTAL_FUNC_VAR   = 10,
        SUBTOTAL_FUNC_VARP  = 11,
        SUBTOTAL_FUNC_MED   = 12,
        SUBTOTAL_FUNC_SELECTION_COUNT = 13
    };
 
enum ScAggregateFunc
    {
        AGGREGATE_FUNC_AVE     = 1,
        AGGREGATE_FUNC_CNT     = 2,
        AGGREGATE_FUNC_CNT2    = 3,
        AGGREGATE_FUNC_MAX     = 4,
        AGGREGATE_FUNC_MIN     = 5,
        AGGREGATE_FUNC_PROD    = 6,
        AGGREGATE_FUNC_STD     = 7,
        AGGREGATE_FUNC_STDP    = 8,
        AGGREGATE_FUNC_SUM     = 9,
        AGGREGATE_FUNC_VAR     = 10,
        AGGREGATE_FUNC_VARP    = 11,
        AGGREGATE_FUNC_MEDIAN  = 12,
        AGGREGATE_FUNC_MODSNGL = 13,
        AGGREGATE_FUNC_LARGE   = 14,
        AGGREGATE_FUNC_SMALL   = 15,
        AGGREGATE_FUNC_PERCINC = 16,
        AGGREGATE_FUNC_QRTINC  = 17,
        AGGREGATE_FUNC_PERCEXC = 18,
        AGGREGATE_FUNC_QRTEXC  = 19
    };
 
class ScArea;
 
struct ScConsolidateParam
{
    SCCOL           nCol;                   // cursor position /
    SCROW           nRow;                   // or start of destination area respectively
    SCTAB           nTab;
    ScSubTotalFunc  eFunction;
    sal_uInt16      nDataAreaCount;         // number of data areas
    std::unique_ptr<ScArea[]> pDataAreas; // array of pointers into data areas
    bool            bByCol;
    bool            bByRow;
    bool            bReferenceData;         // reference source data
 
    ScConsolidateParam();
    ScConsolidateParam( const ScConsolidateParam& r );
    ~ScConsolidateParam();
 
    ScConsolidateParam& operator=       ( const ScConsolidateParam& r );
    bool                operator==      ( const ScConsolidateParam& r ) const;
    void                Clear           (); // = ClearDataAreas()+Members
    void                ClearDataAreas  ();
    void                SetAreas        ( std::unique_ptr<ScArea[]> pAreas, sal_uInt16 nCount );
};
 
extern SfxViewShell* pScActiveViewShell;
extern sal_uInt16 nScClickMouseModifier;
extern sal_uInt16 nScFillModeMouseModifier;
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */