xihelper.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 <editeng/editdata.hxx>
#include <types.hxx>
#include "xladdress.hxx"
#include "xiroot.hxx"
#include "xltools.hxx"
#include <memory>
#include <vector>
 
class ScRangeList;
 
namespace svl {
 
class SharedStringPool;
 
}
 
// Excel->Calc cell address/range conversion ==================================
 
class XclImpAddressConverter : public XclAddressConverterBase
{
public:
    explicit            XclImpAddressConverter( const XclImpRoot& rRoot );
 
    // cell address -----------------------------------------------------------
 
    bool                CheckAddress( const XclAddress& rXclPos, bool bWarn );
 
    bool                ConvertAddress( ScAddress& rScPos,
                            const XclAddress& rXclPos, SCTAB nScTab, bool bWarn );
 
    ScAddress           CreateValidAddress( const XclAddress& rXclPos,
                            SCTAB nScTab, bool bWarn );
 
    // cell range -------------------------------------------------------------
 
    bool                ConvertRange( ScRange& rScRange, const XclRange& rXclRange,
                            SCTAB nScTab1, SCTAB nScTab2, bool bWarn );
 
    // cell range list --------------------------------------------------------
 
    void                ConvertRangeList( ScRangeList& rScRanges,
                            const XclRangeList& rXclRanges, SCTAB nScTab, bool bWarn );
};
 
// String->EditEngine conversion ==============================================
 
class EditTextObject;
 
class XclImpStringHelper
{
public:
    XclImpStringHelper(const XclImpStringHelper&) = delete;
    const XclImpStringHelper& operator=(const XclImpStringHelper&) = delete;
    XclImpStringHelper() = delete;
    static std::unique_ptr<EditTextObject> CreateTextObject(
                            const XclImpRoot& rRoot,
                            const XclImpString& rString );
 
    static void SetToDocument(
        ScDocumentImport& rDoc, const ScAddress& rPos, const XclImpRoot& rRoot,
        const XclImpString& rString, sal_uInt16 nXFIndex );
};
 
// Header/footer conversion ===================================================
 
class EditEngine;
class SfxItemSet;
class SvxFieldItem;
struct XclFontData;
 
class XclImpHFConverter : protected XclImpRoot
{
public:
    XclImpHFConverter(const XclImpHFConverter&) = delete;
    const XclImpHFConverter& operator=(const XclImpHFConverter&) = delete;
 
    explicit            XclImpHFConverter( const XclImpRoot& rRoot );
                        virtual ~XclImpHFConverter() override;
 
    void                ParseString( const OUString& rHFString );
 
    void                FillToItemSet( SfxItemSet& rItemSet, sal_uInt16 nWhichId ) const;
    sal_Int32           GetTotalHeight() const;
 
private:    // types
    typedef ::std::unique_ptr< XclFontData > XclFontDataPtr;
 
    enum XclImpHFPortion { EXC_HF_LEFT, EXC_HF_CENTER, EXC_HF_RIGHT, EXC_HF_PORTION_COUNT };
 
    struct XclImpHFPortionInfo
    {
        typedef std::shared_ptr< EditTextObject > EditTextObjectRef;
        EditTextObjectRef   mxObj;          
        ESelection          maSel;          
        sal_Int32           mnHeight;       
        sal_uInt16          mnMaxLineHt;    
        explicit            XclImpHFPortionInfo();
    };
 
private:
    XclImpHFPortionInfo& GetCurrInfo() { return maInfos[ meCurrObj ]; }
    XclImpHFPortionInfo::EditTextObjectRef& GetCurrObj() { return GetCurrInfo().mxObj; }
    ESelection&  GetCurrSel() { return GetCurrInfo().maSel; }
 
    sal_uInt16          GetMaxLineHeight( XclImpHFPortion ePortion ) const;
 
    void                UpdateMaxLineHeight( XclImpHFPortion ePortion );
    void                UpdateCurrMaxLineHeight();
 
    void                SetAttribs();
    void                ResetFontData();
 
    void                InsertText();
    void                InsertField( const SvxFieldItem& rFieldItem );
    void                InsertLineBreak();
 
    void                CreateCurrObject();
    void                SetNewPortion( XclImpHFPortion eNew );
 
private:
    EditEngine&         mrEE;               
    std::vector< XclImpHFPortionInfo >
                        maInfos;         
    OUStringBuffer      maCurrText;         
    XclFontDataPtr      mxFontData;         
    XclImpHFPortion     meCurrObj;          
};
 
// URL conversion =============================================================
 
class XclImpUrlHelper
{
public:
    XclImpUrlHelper(const XclImpUrlHelper&) = delete;
    const XclImpUrlHelper& operator=(const XclImpUrlHelper&) = delete;
    XclImpUrlHelper() = delete;
 
    static void         DecodeUrl(
                            OUString& rUrl,
                            OUString& rTabName,
                            bool& rbSameWb,
                            const XclImpRoot& rRoot,
                            const OUString& rEncodedUrl );
 
    static void         DecodeUrl(
                            OUString& rUrl,
                            bool& rbSameWb,
                            const XclImpRoot& rRoot,
                            const OUString& rEncodedUrl );
 
    static bool         DecodeLink( OUString& rApplic, OUString& rTopic, std::u16string_view aEncUrl );
};
 
// Cached values ==============================================================
 
class ScTokenArray;
 
class XclImpCachedValue
{
public:
    XclImpCachedValue(const XclImpCachedValue&) = delete;
    const XclImpCachedValue& operator=(const XclImpCachedValue&) = delete;
    explicit            XclImpCachedValue( XclImpStream& rStrm );
    virtual             ~XclImpCachedValue();
 
    sal_uInt8    GetType() const     { return mnType; }
    const OUString& GetString() const { return maStr;}
    double       GetValue() const    { return mfValue; }
    bool         GetBool() const     { return (mnType == EXC_CACHEDVAL_BOOL) && (mnBoolErr != 0); }
    sal_uInt8    GetXclError() const { return (mnType == EXC_CACHEDVAL_ERROR) ? mnBoolErr : EXC_ERR_NA; }
    FormulaError        GetScError() const;
 
private:
    typedef ::std::unique_ptr< const ScTokenArray >   ScTokenArrayPtr;
 
    OUString            maStr;      
    double              mfValue;    
    ScTokenArrayPtr     mxTokArr;   
    sal_uInt8           mnBoolErr;  
    sal_uInt8           mnType;     
};
 
class XclImpCachedMatrix
{
public:
    explicit            XclImpCachedMatrix( XclImpStream& rStrm );
                        ~XclImpCachedMatrix();
 
    ScMatrixRef CreateScMatrix( svl::SharedStringPool& rPool ) const;
 
private:
    typedef std::vector< std::unique_ptr<XclImpCachedValue> > XclImpValueList;
 
    XclImpValueList     maValueList;    
    SCSIZE              mnScCols;       
    SCSIZE              mnScRows;       
};
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */