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, const OUString& rEncUrl );
};

// 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;

protected:
    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: */