ndgrf.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 .
 */
 
#ifndef INCLUDED_SW_INC_NDGRF_HXX
#define INCLUDED_SW_INC_NDGRF_HXX
 
#include <sfx2/lnkbase.hxx>
#include <vcl/GraphicObject.hxx>
#include "ndnotxt.hxx"
#include <memory>
 
class SwAsyncRetrieveInputStreamThreadConsumer;
 
class SwGrfFormatColl;
class SwDoc;
 
// SwGrfNode
class SW_DLLPUBLIC SwGrfNode final: public SwNoTextNode
{
    friend class SwNodes;
 
    GraphicObject maGrfObj;
    std::unique_ptr<GraphicObject> mpReplacementGraphic;
    tools::SvRef<sfx2::SvBaseLink> mxLink;       
    Size mnGrfSize;
    bool mbInSwapIn              :1; // to avoid recursion in SwGrfNode::SwapIn
    bool mbInBaseLinkSwapIn      :1; // to avoid recursion in SwBaseLink::SwapIn
 
    bool mbChangeTwipSize           :1;
    bool mbFrameInPaint          :1; 
    bool mbScaleImageMap         :1; 
 
    std::shared_ptr< SwAsyncRetrieveInputStreamThreadConsumer > mpThreadConsumer;
    bool mbLinkedInputStreamReady;
    css::uno::Reference<css::io::XInputStream> mxInputStream;
    bool mbIsStreamReadOnly;
 
    SwGrfNode( SwNode& rWhere,
               const OUString& rGrfName, const OUString& rFltName,
               const Graphic* pGraphic,
               SwGrfFormatColl* pGrfColl,
               SwAttrSet const * pAutoAttr );
    SwGrfNode( SwNode& rWhere,
               std::u16string_view rGrfName, const OUString& rFltName,
               SwGrfFormatColl* pGrfColl,
               SwAttrSet const * pAutoAttr );
    SwGrfNode( SwNode& rWhere,
               const GraphicObject& rGrfObj,
               SwGrfFormatColl* pGrfColl,
               SwAttrSet const * pAutoAttr );
 
    void InsertLink( std::u16string_view rGrfName, const OUString& rFltName );
 
    void onGraphicChanged();
 
public:
    virtual ~SwGrfNode() override;
    const Graphic&          GetGrf(bool bWait = false) const;
    const GraphicObject&    GetGrfObj(bool bWait = false) const;
    const GraphicObject* GetReplacementGrfObj() const;
 
    void SetGraphic(const Graphic& rGraphic);
    void TriggerGraphicArrived();
 
    void StartGraphicAnimation(OutputDevice* pOut, const Point& rPt, const Size& rSz, tools::Long nRendererId, OutputDevice* pFirstFrameOutDev)
    { maGrfObj.StartAnimation(*pOut, rPt, rSz, nRendererId, pFirstFrameOutDev); }
    void StopGraphicAnimation(const OutputDevice* pOut, tools::Long nRendererId) { maGrfObj.StopAnimation(pOut, nRendererId); }
 
    virtual Size GetTwipSize() const override;
    void SetTwipSize( const Size& rSz );
 
    bool IsTransparent() const;
 
    bool IsAnimated() const              { return maGrfObj.IsAnimated(); }
 
    bool IsChgTwipSize() const           { return mbChangeTwipSize; }
    void SetChgTwipSize( bool b)
    {
        mbChangeTwipSize = b;
    }
 
    bool IsFrameInPaint() const          { return mbFrameInPaint; }
    void SetFrameInPaint( bool b )       { mbFrameInPaint = b; }
 
    bool IsScaleImageMap() const         { return mbScaleImageMap; }
    void SetScaleImageMap( bool b )      { mbScaleImageMap = b; }
 
    virtual SwContentNode* MakeCopy(SwDoc&, SwNode&, bool bNewFrames) const override;
 
    bool ReRead( const OUString& rGrfName, const OUString& rFltName,
                 const Graphic* pGraphic = nullptr,
                 bool bModify = true );
private:
    bool SwapIn( bool bWaitForData = false );
 
public:
    bool HasEmbeddedStreamName() const { return maGrfObj.HasUserData(); }
 
    virtual bool SavePersistentData() override;
    virtual bool RestorePersistentData() override;
 
    bool IsGrfLink() const                  { return mxLink.is(); }
    bool IsLinkedFile() const;
    bool IsLinkedDDE() const;
    const tools::SvRef<sfx2::SvBaseLink>& GetLink() const    { return mxLink; }
    bool GetFileFilterNms( OUString* pFileNm, OUString* pFilterNm ) const;
    void ReleaseLink();
 
    void ScaleImageMap();
 
    GraphicAttr& GetGraphicAttr( GraphicAttr&, const SwFrame* pFrame ) const;
 
    std::weak_ptr< SwAsyncRetrieveInputStreamThreadConsumer > GetThreadConsumer() const { return mpThreadConsumer;}
    bool IsLinkedInputStreamReady() const { return mbLinkedInputStreamReady;}
    void TriggerAsyncRetrieveInputStream();
    void ApplyInputStream(
        const css::uno::Reference<css::io::XInputStream>& xInputStream,
        const bool bIsStreamReadOnly );
    void UpdateLinkWithInputStream();
    bool IsAsyncRetrieveInputStreamPossible() const;
};
 
// Inline methods from Node.hxx - it is only now that we know TextNode!!
inline       SwGrfNode   *SwNode::GetGrfNode()
{
     return SwNodeType::Grf == m_nNodeType ? static_cast<SwGrfNode*>(this) : nullptr;
}
 
inline const SwGrfNode   *SwNode::GetGrfNode() const
{
     return SwNodeType::Grf == m_nNodeType ? static_cast<const SwGrfNode*>(this) : nullptr;
}
 
inline bool SwGrfNode::IsLinkedFile() const
{
    return mxLink.is() && sfx2::SvBaseLinkObjectType::ClientGraphic == mxLink->GetObjType();
}
 
inline bool SwGrfNode::IsLinkedDDE() const
{
    return mxLink.is() && sfx2::SvBaseLinkObjectType::ClientDde == mxLink->GetObjType();
}
 
#endif
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */