externallinkbuffer.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 <ostream>

#include <com/sun/star/sheet/ExternalLinkInfo.hpp>
#include <oox/helper/containerhelper.hxx>
#include "defnamesbuffer.hxx"
#include "formulabase.hxx"

namespace com::sun::star {
    namespace sheet { struct DDEItemInfo; }
    namespace sheet { class XDDELink; }
    namespace sheet { class XExternalDocLink; }
    namespace sheet { class XExternalSheetCache; }
}

namespace oox::core {
    class Relations;
}

namespace oox::xls {

struct ExternalNameModel
{
    bool                mbNotify;           
    bool                mbPreferPic;        
    bool                mbStdDocName;       
    bool                mbOleObj;           
    bool                mbIconified;        

    explicit            ExternalNameModel();
};

class ExternalLink;

class ExternalName : public DefinedNameBase
{
public:
    explicit            ExternalName( const ExternalLink& rParentLink );

    template< typename Type >
    void         appendResultValue( const Type& rValue )
                            { if( maCurrIt != maResults.end() ) (*maCurrIt++) <<= rValue; }

    void                importDefinedName( const AttributeList& rAttribs );
    void                importDdeItem( const AttributeList& rAttribs );
    void                importValues( const AttributeList& rAttribs );
    void                importOleItem( const AttributeList& rAttribs );

    void                importExternalName( SequenceInputStream& rStrm );
    void                importExternalNameFlags( SequenceInputStream& rStrm );
    void                importDdeItemValues( SequenceInputStream& rStrm );
    void                importDdeItemBool( SequenceInputStream& rStrm );
    void                importDdeItemDouble( SequenceInputStream& rStrm );
    void                importDdeItemError( SequenceInputStream& rStrm );
    void                importDdeItemString( SequenceInputStream& rStrm );

    bool                getDdeItemInfo(
                            css::sheet::DDEItemInfo& orItemInfo ) const;

    bool                getDdeLinkData(
                            OUString& orDdeServer,
                            OUString& orDdeTopic,
                            OUString& orDdeItem );

private:
    void                setResultSize( sal_Int32 nColumns, sal_Int32 nRows );

private:
    typedef Matrix< css::uno::Any > ResultMatrix;

    const ExternalLink& mrParentLink;       
    ExternalNameModel   maExtNameModel;     
    ResultMatrix        maResults;          
    ResultMatrix::iterator maCurrIt;        
    css::uno::Reference< css::sheet::XDDELink >
                        mxDdeLink;          
    bool                mbDdeLinkCreated;   
};

typedef std::shared_ptr< ExternalName > ExternalNameRef;

class LinkSheetRange
{
public:
    explicit     LinkSheetRange() { setDeleted(); }

    void                setDeleted();
    void                setSameSheet();
    void                setRange( sal_Int32 nFirst, sal_Int32 nLast );
    void                setExternalRange( sal_Int32 nDocLink, sal_Int32 nFirst, sal_Int32 nLast );

    bool         isDeleted() const { return mnFirst < 0; }
    bool         isExternal() const { return !isDeleted() && (meType == LINKSHEETRANGE_EXTERNAL); }
    bool         isSameSheet() const { return meType == LINKSHEETRANGE_SAMESHEET; }
    bool         is3dRange() const { return (0 <= mnFirst) && (mnFirst < mnLast); }

    sal_Int32    getDocLinkIndex() const { return mnDocLink; }
    sal_Int32    getFirstSheet() const { return mnFirst; }
    sal_Int32    getLastSheet() const { return mnLast; }

private:
    enum LinkSheetRangeType
    {
        LINKSHEETRANGE_INTERNAL,    
        LINKSHEETRANGE_EXTERNAL,    
        LINKSHEETRANGE_SAMESHEET    
    };

    LinkSheetRangeType  meType;         
    sal_Int32           mnDocLink;      
    sal_Int32           mnFirst;        
    sal_Int32           mnLast;         
};

enum class ExternalLinkType
{
    Self,          
    Same,          
    External,      
    // let's ignore xlStartup and xlAlternateStartup for now
    PathMissing,   
    Library,       
    DDE,           
    OLE,           
    Unknown        
};

template< typename charT, typename traits >
inline std::basic_ostream<charT, traits> & operator <<(
    std::basic_ostream<charT, traits> & stream, const ExternalLinkType& type )
{
    switch (type)
    {
    case ExternalLinkType::Self: return stream << "self";
    case ExternalLinkType::Same: return stream << "same";
    case ExternalLinkType::External: return stream << "external";
    case ExternalLinkType::PathMissing: return stream << "pathmissing";
    case ExternalLinkType::Library: return stream << "library";
    case ExternalLinkType::DDE: return stream << "dde";
    case ExternalLinkType::OLE: return stream << "ole";
    case ExternalLinkType::Unknown: return stream << "unknown";
    default: return stream << static_cast<int>(type);
    }
}

class ExternalLink : public WorkbookHelper
{
public:
    explicit            ExternalLink( const WorkbookHelper& rHelper );

    void                importExternalReference( const AttributeList& rAttribs );
    void                importExternalBook( const ::oox::core::Relations& rRelations, const AttributeList& rAttribs );
    void                importSheetName( const AttributeList& rAttribs );
    void                importDefinedName( const AttributeList& rAttribs );
    void                importDdeLink( const AttributeList& rAttribs );
    ExternalNameRef     importDdeItem( const AttributeList& rAttribs );
    void                importOleLink( const ::oox::core::Relations& rRelations, const AttributeList& rAttribs );
    ExternalNameRef     importOleItem( const AttributeList& rAttribs );

    void                importExternalBook( const ::oox::core::Relations& rRelations, SequenceInputStream& rStrm );
    void                importExtSheetNames( SequenceInputStream& rStrm );
    ExternalNameRef     importExternalName( SequenceInputStream& rStrm );
    void                importExternalRef( SequenceInputStream& rStrm );
    void                importExternalSelf( SequenceInputStream& rStrm );
    void                importExternalSame( SequenceInputStream& rStrm );
    void                importExternalAddin( SequenceInputStream& rStrm );

    void         setSelfLinkType() { meLinkType = ExternalLinkType::Self; }

    ExternalLinkType getLinkType() const { return meLinkType; }

    const OUString& getRelId() const { return maRelId; }
    const OUString& getClassName() const { return maClassName; }
    const OUString& getTargetUrl() const { return maTargetUrl; }
    css::sheet::ExternalLinkInfo getLinkInfo() const;

    FunctionLibraryType getFuncLibraryType() const;

    sal_Int32           getDocumentLinkIndex() const;
    sal_Int32           getSheetCacheIndex( sal_Int32 nTabId ) const;
    css::uno::Reference< css::sheet::XExternalSheetCache >
                        getSheetCache( sal_Int32 nTabId ) const;

    void                getSheetRange( LinkSheetRange& orSheetRange, sal_Int32 nTabId1, sal_Int32 nTabId2 ) const;

    ExternalNameRef     getNameByIndex( sal_Int32 nIndex ) const;

private:
    void                setExternalTargetUrl( const OUString& rTargetUrl, const OUString& rTargetType );
    void                setDdeOleTargetUrl( const OUString& rClassName, const OUString& rTargetUrl, ExternalLinkType eLinkType );
    void                parseExternalReference( const ::oox::core::Relations& rRelations, const OUString& rRelId );

    void                insertExternalSheet( const OUString& rSheetName );

    ExternalNameRef     createExternalName();

private:
    ExternalLinkType    meLinkType;         
    FunctionLibraryType meFuncLibType;      
    OUString            maRelId;            
    OUString            maClassName;        
    OUString            maTargetUrl;        
    css::uno::Reference< css::sheet::XExternalDocLink >
                        mxDocLink;          
    std::vector< sal_Int32 > maSheetCaches; 
    RefVector< ExternalName >  maExtNames;         
};

typedef std::shared_ptr< ExternalLink > ExternalLinkRef;

struct RefSheetsModel
{
    sal_Int32           mnExtRefId;         
    sal_Int32           mnTabId1;           
    sal_Int32           mnTabId2;           

    explicit            RefSheetsModel();

    void                readBiff12Data( SequenceInputStream& rStrm );
};

class ExternalLinkBuffer : public WorkbookHelper
{
public:
    explicit            ExternalLinkBuffer( const WorkbookHelper& rHelper );

    ExternalLinkRef     importExternalReference( const AttributeList& rAttribs );

    ExternalLinkRef     importExternalRef( SequenceInputStream& rStrm );
    void                importExternalSelf( SequenceInputStream& rStrm );
    void                importExternalSame( SequenceInputStream& rStrm );
    void                importExternalAddin( SequenceInputStream& rStrm );
    void                importExternalSheets( SequenceInputStream& rStrm );

    css::uno::Sequence< css::sheet::ExternalLinkInfo >
                        getLinkInfos() const;

    ExternalLinkRef     getExternalLink( sal_Int32 nRefId, bool bUseRefSheets = true ) const;

    LinkSheetRange      getSheetRange( sal_Int32 nRefId ) const;

private:
    ExternalLinkRef     createExternalLink();

    const RefSheetsModel* getRefSheets( sal_Int32 nRefId ) const;

private:
    typedef RefVector< ExternalLink >       ExternalLinkVec;
    typedef ::std::vector< RefSheetsModel > RefSheetsModelVec;

    ExternalLinkRef     mxSelfRef;          
    ExternalLinkVec     maLinks;            
    ExternalLinkVec     maExtLinks;         
    RefSheetsModelVec   maRefSheets;        
    bool                mbUseRefSheets;     
};

} // namespace oox::xls

/* vim:set shiftwidth=4 softtabstop=4 expandtab: */