core/graphic/ndgrf.cxx

/**************************************************************
 *
 * 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
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 *************************************************************/


// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_sw.hxx"
#include <hintids.hxx>
#include <vcl/salbtype.hxx>             // FRound
#include <tools/urlobj.hxx>
#include <svl/undo.hxx>
#ifndef SVTOOLS_FSTATHELPER_HXX
#include <svl/fstathelper.hxx>
#endif
#include <svtools/imap.hxx>
#include <svtools/filter.hxx>
#include <sot/storage.hxx>
#include <sfx2/linkmgr.hxx>
#include <editeng/boxitem.hxx>
#include <sot/formats.hxx>
#include <fmtfsize.hxx>
#include <fmturl.hxx>
#include <frmfmt.hxx>
#include <doc.hxx>
#include <frmatr.hxx>
#include <grfatr.hxx>
#include <swtypes.hxx>
#include <ndgrf.hxx>
#include <fmtcol.hxx>
#include <hints.hxx>
#include <swbaslnk.hxx>
#include <pagefrm.hxx>
#include <editsh.hxx>
#include <pam.hxx>

#include <unotools/ucbstreamhelper.hxx>
#include <com/sun/star/embed/ElementModes.hpp>
#include <com/sun/star/embed/XTransactedObject.hpp>
#include <tools/link.hxx>
#include <vcl/svapp.hxx>
#include <com/sun/star/io/XSeekable.hpp>
// --> OD 2007-03-28 #i73788#
#include <retrieveinputstreamconsumer.hxx>
// <--

using namespace com::sun::star;

// --------------------
// SwGrfNode
// --------------------
SwGrfNode::SwGrfNode(
        const SwNodeIndex & rWhere,
        const String& rGrfName, const String& rFltName,
        const Graphic* pGraphic,
        SwGrfFmtColl *pGrfColl,
        SwAttrSet* pAutoAttr ) :
    SwNoTxtNode( rWhere, ND_GRFNODE, pGrfColl, pAutoAttr ),
    aGrfObj(),
    mpReplacementGraphic(0),
    // --> OD 2007-01-23 #i73788#
    mbLinkedInputStreamReady( false ),
    mbIsStreamReadOnly( sal_False )
    // <--
{
	aGrfObj.SetSwapStreamHdl( LINK( this, SwGrfNode, SwapGraphic ) );
	bInSwapIn = bChgTwipSize = bChgTwipSizeFromPixel = bLoadLowResGrf =
		bFrameInPaint = bScaleImageMap = sal_False;

    bGrafikArrived = sal_True;
    ReRead(rGrfName,rFltName, pGraphic, 0, sal_False);
}

SwGrfNode::SwGrfNode( const SwNodeIndex & rWhere,
				  		const GraphicObject& rGrfObj,
                      SwGrfFmtColl *pGrfColl, SwAttrSet* pAutoAttr ) :
    SwNoTxtNode( rWhere, ND_GRFNODE, pGrfColl, pAutoAttr ),
	aGrfObj(rGrfObj),
    mpReplacementGraphic(0),
    // --> OD 2007-01-23 #i73788#
    mbLinkedInputStreamReady( false ),
    mbIsStreamReadOnly( sal_False )
    // <--
{
	aGrfObj = rGrfObj;
	aGrfObj.SetSwapStreamHdl( LINK( this, SwGrfNode, SwapGraphic ) );
	if( rGrfObj.HasUserData() && rGrfObj.IsSwappedOut() )
		aGrfObj.SetSwapState();
	bInSwapIn = bChgTwipSize = bChgTwipSizeFromPixel= bLoadLowResGrf =
		bFrameInPaint = bScaleImageMap = sal_False;
	bGrafikArrived = sal_True;
}

// Konstruktor fuer den SW/G-Reader. Dieser ctor wird verwendet,
// wenn eine gelinkte Grafik gelesen wird. Sie liest diese NICHT ein.


SwGrfNode::SwGrfNode( const SwNodeIndex & rWhere,
                      const String& rGrfName, const String& rFltName,
                      SwGrfFmtColl *pGrfColl,
                      SwAttrSet* pAutoAttr ) :
    SwNoTxtNode( rWhere, ND_GRFNODE, pGrfColl, pAutoAttr ),
    aGrfObj(),
    mpReplacementGraphic(0),
    // --> OD 2007-01-23 #i73788#
    mbLinkedInputStreamReady( false ),
    mbIsStreamReadOnly( sal_False )
    // <--
{
	aGrfObj.SetSwapStreamHdl( LINK( this, SwGrfNode, SwapGraphic ) );

	Graphic aGrf; aGrf.SetDefaultType();
	aGrfObj.SetGraphic( aGrf, rGrfName );

	bInSwapIn = bChgTwipSize = bChgTwipSizeFromPixel = bLoadLowResGrf =
		bFrameInPaint = bScaleImageMap = sal_False;
	bGrafikArrived = sal_True;

	InsertLink( rGrfName, rFltName );
	if( IsLinkedFile() )
	{
		INetURLObject aUrl( rGrfName );
		if( INET_PROT_FILE == aUrl.GetProtocol() &&
			FStatHelper::IsDocument( aUrl.GetMainURL( INetURLObject::NO_DECODE ) ))
		{
			// File vorhanden, Verbindung herstellen ohne ein Update
			((SwBaseLink*)&refLink)->Connect();
		}
	}
}

sal_Bool SwGrfNode::ReRead(
    const String& rGrfName, const String& rFltName,
    const Graphic* pGraphic, const GraphicObject* pGrfObj,
    sal_Bool bNewGrf )
{
	sal_Bool bReadGrf = sal_False, bSetTwipSize = sal_True;
    delete mpReplacementGraphic;
    mpReplacementGraphic = 0;

	ASSERT( pGraphic || pGrfObj || rGrfName.Len(),
			"GraphicNode without a name, Graphic or GraphicObject" );

	// ReadRead mit Namen
	if( refLink.Is() )
	{
		ASSERT( !bInSwapIn, "ReRead: stehe noch im SwapIn" );

		if( rGrfName.Len() )
		{
			// Besonderheit: steht im FltNamen DDE, handelt es sich um eine
			//					DDE-gelinkte Grafik
			String sCmd( rGrfName );
			if( rFltName.Len() )
			{
				sal_uInt16 nNewType;
				if( rFltName.EqualsAscii( "DDE" ))
					nNewType = OBJECT_CLIENT_DDE;
				else
				{
                    sfx2::MakeLnkName( sCmd, 0, rGrfName, aEmptyStr, &rFltName );
					nNewType = OBJECT_CLIENT_GRF;
				}

				if( nNewType != refLink->GetObjType() )
				{
					refLink->Disconnect();
					((SwBaseLink*)&refLink)->SetObjType( nNewType );
				}
			}

			refLink->SetLinkSourceName( sCmd );
		}
		else		// kein Name mehr, Link aufheben
		{
			GetDoc()->GetLinkManager().Remove( refLink );
			refLink.Clear();
		}

		if( pGraphic )
		{
			aGrfObj.SetGraphic( *pGraphic, rGrfName );
			bReadGrf = sal_True;
		}
		else if( pGrfObj )
		{
			aGrfObj = *pGrfObj;
			if( pGrfObj->HasUserData() && pGrfObj->IsSwappedOut() )
				aGrfObj.SetSwapState();
			aGrfObj.SetLink( rGrfName );
			bReadGrf = sal_True;
		}
		else
		{
			// MIB 25.02.97: Daten der alten Grafik zuruecksetzen, damit
			// die korrekte Ersatz-Darstellung erscheint, wenn die
			// der neue Link nicht geladen werden konnte.
			Graphic aGrf; aGrf.SetDefaultType();
			aGrfObj.SetGraphic( aGrf, rGrfName );

			if( refLink.Is() )
			{
				if( getLayoutFrm( GetDoc()->GetCurrentLayout() ) )
				{
					SwMsgPoolItem aMsgHint( RES_GRF_REREAD_AND_INCACHE );
					ModifyNotification( &aMsgHint, &aMsgHint );
				}
                // --> OD 2006-11-03 #i59688#
                // do not load linked graphic, if it isn't a new linked graphic.
//                else {
                else if ( bNewGrf )
                // <--
                {
					//TODO refLink->setInputStream(getInputStream());
                    ((SwBaseLink*)&refLink)->SwapIn();
                }
			}
			bSetTwipSize = sal_False;
		}
	}
	else if( pGraphic && !rGrfName.Len() )
	{
		// MIB 27.02.2001: Old stream must be deleted before the new one is set.
		if( HasStreamName() )
			DelStreamName();

		aGrfObj.SetGraphic( *pGraphic );
		bReadGrf = sal_True;
	}
	else if( pGrfObj && !rGrfName.Len() )
	{
		// MIB 27.02.2001: Old stream must be deleted before the new one is set.
		if( HasStreamName() )
			DelStreamName();

		aGrfObj = *pGrfObj;
		if( pGrfObj->HasUserData() && pGrfObj->IsSwappedOut() )
			aGrfObj.SetSwapState();
		bReadGrf = sal_True;
	}
		// Import einer Grafik:
		// Ist die Grafik bereits geladen?
	else if( !bNewGrf && GRAPHIC_NONE != aGrfObj.GetType() )
		return sal_True;

	else
	{
		if( HasStreamName() )
			DelStreamName();

		// einen neuen Grafik-Link anlegen
		InsertLink( rGrfName, rFltName );

		if( GetNodes().IsDocNodes() )
		{
			if( pGraphic )
			{
				aGrfObj.SetGraphic( *pGraphic, rGrfName );
				bReadGrf = sal_True;
				// Verbindung herstellen ohne ein Update; Grafik haben wir!
				((SwBaseLink*)&refLink)->Connect();
			}
			else if( pGrfObj )
			{
				aGrfObj = *pGrfObj;
				aGrfObj.SetLink( rGrfName );
				bReadGrf = sal_True;
				// Verbindung herstellen ohne ein Update; Grafik haben wir!
				((SwBaseLink*)&refLink)->Connect();
			}
			else
			{
				// MIB 25.02.97: Daten der alten Grafik zuruecksetzen, damit
				// die korrekte Ersatz-Darstellung erscheint, wenn die
				// der neue Kink nicht geladen werden konnte.
				Graphic aGrf; aGrf.SetDefaultType();
				aGrfObj.SetGraphic( aGrf, rGrfName );
                // --> OD 2006-11-03 #i59688#
                // do not load linked graphic, if it isn't a new linked graphic.
//                //TODO refLink->setInputStream(getInputStream());
//                ((SwBaseLink*)&refLink)->SwapIn();
                if ( bNewGrf )
                {
                    ((SwBaseLink*)&refLink)->SwapIn();
                }
                // <--
			}
		}
	}

	// Bug 39281: Size nicht sofort loeschen - Events auf ImageMaps
	//			  sollten nicht beim Austauschen nicht ins "leere greifen"
	if( bSetTwipSize )
		SetTwipSize( ::GetGraphicSizeTwip( aGrfObj.GetGraphic(), 0 ) );

	// erzeuge noch einen Update auf die Frames
	if( bReadGrf && bNewGrf )
	{
		SwMsgPoolItem aMsgHint( RES_UPDATE_ATTR );
		ModifyNotification( &aMsgHint, &aMsgHint );
	}

	return bReadGrf;
}


SwGrfNode::~SwGrfNode()
{
    delete mpReplacementGraphic;
    mpReplacementGraphic = 0;

    // --> OD 2007-03-30 #i73788#
    mpThreadConsumer.reset();
    // <--

	SwDoc* pDoc = GetDoc();
	if( refLink.Is() )
	{
		ASSERT( !bInSwapIn, "DTOR: stehe noch im SwapIn" );
		pDoc->GetLinkManager().Remove( refLink );
		refLink->Disconnect();
	}
	else
	{
        // --> OD 2005-01-19 #i40014# - A graphic node, which are in linked
        // section, whose link is another section is the document, doesn't
        // have to remove the stream from the storage.
        // Because it's hard to detect this case here and it would only fix
        // one problem with shared graphic files - there are also problems,
        // a certain graphic file is referenced by two independent graphic nodes,
        // brush item or drawing objects, the stream isn't no longer removed here.
        // To do this stuff correct, a reference counting on shared streams
        // inside one document have to be implemented.
//        if( !pDoc->IsInDtor() && HasStreamName() )
//          DelStreamName();
        // <--
	}
	//#39289# Die Frames muessen hier bereits geloescht weil der DTor der
	//Frms die Grafik noch fuer StopAnimation braucht.
	if( GetDepends() )
		DelFrms();
}


const GraphicObject* SwGrfNode::GetReplacementGrfObj() const
{
    if(!mpReplacementGraphic)
    {
        const SvgDataPtr& rSvgDataPtr = GetGrfObj().GetGraphic().getSvgData();

        if(rSvgDataPtr.get())
        {
            const_cast< SwGrfNode* >(this)->mpReplacementGraphic = new GraphicObject(rSvgDataPtr->getReplacement());
        }
    }

    return mpReplacementGraphic;
}

SwCntntNode *SwGrfNode::SplitCntntNode( const SwPosition & )
{
	return this;
}


SwGrfNode * SwNodes::MakeGrfNode( const SwNodeIndex & rWhere,
								const String& rGrfName,
								const String& rFltName,
								const Graphic* pGraphic,
								SwGrfFmtColl* pGrfColl,
								SwAttrSet* pAutoAttr,
								sal_Bool bDelayed )
{
	ASSERT( pGrfColl, "MakeGrfNode: Formatpointer ist 0." );
	SwGrfNode *pNode;
	// Delayed erzeugen nur aus dem SW/G-Reader
	if( bDelayed )
		pNode = new SwGrfNode( rWhere, rGrfName,
								rFltName, pGrfColl, pAutoAttr );
	else
		pNode = new SwGrfNode( rWhere, rGrfName,
								rFltName, pGraphic, pGrfColl, pAutoAttr );
	return pNode;
}

SwGrfNode * SwNodes::MakeGrfNode( const SwNodeIndex & rWhere,
								const GraphicObject& rGrfObj,
								SwGrfFmtColl* pGrfColl,
								SwAttrSet* pAutoAttr )
{
	ASSERT( pGrfColl, "MakeGrfNode: Formatpointer ist 0." );
	return new SwGrfNode( rWhere, rGrfObj, pGrfColl, pAutoAttr );
}


Size SwGrfNode::GetTwipSize() const
{
	return nGrfSize;
}


sal_Bool SwGrfNode::ImportGraphic( SvStream& rStrm )
{
	Graphic aGraphic;
    const String aURL(aGrfObj.GetUserData());

    if(!GraphicFilter::GetGraphicFilter()->ImportGraphic(aGraphic, aURL, rStrm))
	{
        delete mpReplacementGraphic;
        mpReplacementGraphic = 0;

        aGrfObj.SetGraphic( aGraphic );
		aGrfObj.SetUserData( aURL );
		return sal_True;
	}

	return sal_False;
}

// Returnwert:
// -1 : ReRead erfolgreich
//  0 : nicht geladen
//  1 : Einlesen erfolgreich

short SwGrfNode::SwapIn( sal_Bool bWaitForData )
{
	if( bInSwapIn )					// nicht rekuriv!!
		return !aGrfObj.IsSwappedOut();

	short nRet = 0;
	bInSwapIn = sal_True;
    SwBaseLink* pLink = (SwBaseLink*)(::sfx2::SvBaseLink*) refLink;

	if( pLink )
	{
		if( GRAPHIC_NONE == aGrfObj.GetType() ||
			GRAPHIC_DEFAULT == aGrfObj.GetType() )
		{
			// noch nicht geladener Link
            //TODO pLink->setInputStream(getInputStream());
			if( pLink->SwapIn( bWaitForData ) )
				nRet = -1;
			else if( GRAPHIC_DEFAULT == aGrfObj.GetType() )
			{
				// keine default Bitmap mehr, also neu Painten!
                delete mpReplacementGraphic;
                mpReplacementGraphic = 0;

				aGrfObj.SetGraphic( Graphic() );
				SwMsgPoolItem aMsgHint( RES_GRAPHIC_PIECE_ARRIVED );
				ModifyNotification( &aMsgHint, &aMsgHint );
			}
		}
		else if( aGrfObj.IsSwappedOut() ) {
			// nachzuladender Link
            //TODO pLink->setInputStream(getInputStream());
            nRet = pLink->SwapIn( bWaitForData ) ? 1 : 0;
        }
		else
			nRet = 1;
	}
	else if( aGrfObj.IsSwappedOut() )
	{
		// Die Grafik ist im Storage oder im TempFile drin
		if( !HasStreamName() )
			nRet = (short)aGrfObj.SwapIn();
		else
		{

            // --> OD 2005-05-04 #i48434# - usage of new method <_GetStreamForEmbedGrf(..)>
            try
            {
                // --> OD, MAV 2005-08-17 #i53025# - needed correction of new
                // method <_GetStreamForEmbedGrf(..)>
//                bool bGraphic(false);
//                SvStream* pStrm = _GetStreamForEmbedGrf( bGraphic );
                String aStrmName, aPicStgName;
                _GetStreamStorageNames( aStrmName, aPicStgName );
                uno::Reference < embed::XStorage > refPics = _GetDocSubstorageOrRoot( aPicStgName );
                SvStream* pStrm = _GetStreamForEmbedGrf( refPics, aStrmName );
                if ( pStrm )
                {
                    if ( ImportGraphic( *pStrm ) )
                        nRet = 1;
                    delete pStrm;
                }
                // <--
            }
            catch ( uno::Exception& )
            {
                // --> OD 2005-04-25 #i48434#
                ASSERT( false, "<SwGrfNode::SwapIn(..)> - unhandled exception!" );
                // <--
            }
            // <--
		}

		if( 1 == nRet )
		{
			SwMsgPoolItem aMsg( RES_GRAPHIC_SWAPIN );
            ModifyNotification( &aMsg, &aMsg );
		}
	}
	else
		nRet = 1;
	DBG_ASSERTWARNING( nRet, "Grafik kann nicht eingeswapt werden" );

	if( nRet )
	{
		if( !nGrfSize.Width() && !nGrfSize.Height() )
			SetTwipSize( ::GetGraphicSizeTwip( aGrfObj.GetGraphic(), 0 ) );
	}
	bInSwapIn = sal_False;
	return nRet;
}


short SwGrfNode::SwapOut()
{
	if( aGrfObj.GetType() != GRAPHIC_DEFAULT &&
		aGrfObj.GetType() != GRAPHIC_NONE &&
		!aGrfObj.IsSwappedOut() && !bInSwapIn )
	{
		if( !refLink.Is() )
		{
			// Das Swapping brauchen wir nur fuer Embedded Pictures
			// Die Grafik wird in eine TempFile geschrieben, wenn
			// sie frisch eingefuegt war, d.h. wenn es noch keinen
			// Streamnamen im Storage gibt.
			if( !HasStreamName() )
				if( !aGrfObj.SwapOut() )
					return 0;
		}
		// Geschriebene Grafiken oder Links werden jetzt weggeschmissen
		return (short) aGrfObj.SwapOut( NULL );
	}
	return 1;
}


sal_Bool SwGrfNode::GetFileFilterNms( String* pFileNm, String* pFilterNm ) const
{
	sal_Bool bRet = sal_False;
	if( refLink.Is() && refLink->GetLinkManager() )
	{
		sal_uInt16 nType = refLink->GetObjType();
		if( OBJECT_CLIENT_GRF == nType )
			bRet = refLink->GetLinkManager()->GetDisplayNames(
					refLink, 0, pFileNm, 0, pFilterNm );
		else if( OBJECT_CLIENT_DDE == nType && pFileNm && pFilterNm )
		{
			String sApp, sTopic, sItem;
			if( refLink->GetLinkManager()->GetDisplayNames(
					refLink, &sApp, &sTopic, &sItem ) )
			{
                ( *pFileNm = sApp ) += sfx2::cTokenSeperator;
                ( *pFileNm += sTopic ) += sfx2::cTokenSeperator;
				*pFileNm += sItem;
				pFilterNm->AssignAscii( RTL_CONSTASCII_STRINGPARAM( "DDE" ));
				bRet = sal_True;
			}
		}
	}
	return bRet;
}


// Eine Grafik Undo-faehig machen. Falls sie sich bereits in
// einem Storage befindet, muss sie geladen werden.

sal_Bool SwGrfNode::SavePersistentData()
{
	if( refLink.Is() )
	{
		ASSERT( !bInSwapIn, "SavePersistentData: stehe noch im SwapIn" );
		GetDoc()->GetLinkManager().Remove( refLink );
		return sal_True;
	}

	// Erst mal reinswappen, falls sie im Storage ist
	if( HasStreamName() && !SwapIn() )
		return sal_False;

    // --> OD 2005-04-19 #i44367#
    // Do not delete graphic file in storage, because the graphic file could
    // be referenced by other graphic nodes.
    // Because it's hard to detect this case here and it would only fix
    // one problem with shared graphic files - there are also problems,
    // a certain graphic file is referenced by two independent graphic nodes,
    // brush item or drawing objects, the stream isn't no longer removed here.
    // To do this stuff correct, a reference counting on shared streams
    // inside one document have to be implemented.
    // Important note: see also fix for #i40014#
//    if( HasStreamName() )
//        DelStreamName();
    // <--

	// Und in TempFile rausswappen
	return (sal_Bool) SwapOut();
}


sal_Bool SwGrfNode::RestorePersistentData()
{
	if( refLink.Is() )
	{
        IDocumentLinksAdministration* pIDLA = getIDocumentLinksAdministration();
        refLink->SetVisible( pIDLA->IsVisibleLinks() );
        pIDLA->GetLinkManager().InsertDDELink( refLink );
        if( getIDocumentLayoutAccess()->GetCurrentLayout() )	//swmod 080218
			refLink->Update();
	}
	return sal_True;
}


void SwGrfNode::InsertLink( const String& rGrfName, const String& rFltName )
{
    refLink = new SwBaseLink( sfx2::LINKUPDATE_ONCALL, FORMAT_GDIMETAFILE, this );

    IDocumentLinksAdministration* pIDLA = getIDocumentLinksAdministration();
	if( GetNodes().IsDocNodes() )
	{
        refLink->SetVisible( pIDLA->IsVisibleLinks() );
		if( rFltName.EqualsAscii( "DDE" ))
		{
			sal_uInt16 nTmp = 0;
			String sApp, sTopic, sItem;
            sApp = rGrfName.GetToken( 0, sfx2::cTokenSeperator, nTmp );
            sTopic = rGrfName.GetToken( 0, sfx2::cTokenSeperator, nTmp );
			sItem = rGrfName.Copy( nTmp );
            pIDLA->GetLinkManager().InsertDDELink( refLink,
											sApp, sTopic, sItem );
		}
		else
		{
			sal_Bool bSync = rFltName.EqualsAscii( "SYNCHRON" );
			refLink->SetSynchron( bSync );
            refLink->SetContentType( SOT_FORMATSTR_ID_SVXB );

            pIDLA->GetLinkManager().InsertFileLink( *refLink,
											OBJECT_CLIENT_GRF, rGrfName,
								(!bSync && rFltName.Len() ? &rFltName : 0) );
		}
	}
	aGrfObj.SetLink( rGrfName );
}


void SwGrfNode::ReleaseLink()
{
	if( refLink.Is() )
	{
		// erst die Grafik reinswappen!
//		if( aGraphic.IsSwapOut() || !refLink->IsSynchron() )
		{
			bInSwapIn = sal_True;
            SwBaseLink* pLink = (SwBaseLink*)(::sfx2::SvBaseLink*) refLink;
            //TODO pLink->setInputStream(getInputStream());
			pLink->SwapIn( sal_True, sal_True );
			bInSwapIn = sal_False;
		}
        getIDocumentLinksAdministration()->GetLinkManager().Remove( refLink );
		refLink.Clear();
		aGrfObj.SetLink();
	}
}


void SwGrfNode::SetTwipSize( const Size& rSz )
{
	nGrfSize = rSz;
	if( IsScaleImageMap() && nGrfSize.Width() && nGrfSize.Height() )
	{
		// Image-Map an Grafik-Groesse anpassen
		ScaleImageMap();

		// Image-Map nicht noch einmal skalieren
		SetScaleImageMap( sal_False );
	}
}

void SwGrfNode::ScaleImageMap()
{
	if( !nGrfSize.Width() || !nGrfSize.Height() )
		return;

	// dann die Image-Map skalieren
	SwFrmFmt* pFmt = GetFlyFmt();

	if( !pFmt )
		return;

	SwFmtURL aURL( pFmt->GetURL() );
	if ( !aURL.GetMap() )
		return;

	sal_Bool bScale = sal_False;
	Fraction aScaleX( 1, 1 );
	Fraction aScaleY( 1, 1 );

	const SwFmtFrmSize& rFrmSize = pFmt->GetFrmSize();
	const SvxBoxItem& rBox = pFmt->GetBox();

	if( !rFrmSize.GetWidthPercent() )
	{
		SwTwips nWidth = rFrmSize.GetWidth();

		nWidth -= rBox.CalcLineSpace(BOX_LINE_LEFT) +
				  rBox.CalcLineSpace(BOX_LINE_RIGHT);

		ASSERT( nWidth>0, "Gibt es 0 twip breite Grafiken!?" );

		if( nGrfSize.Width() != nWidth )
		{
			aScaleX = Fraction( nGrfSize.Width(), nWidth );
			bScale = sal_True;
		}
	}
	if( !rFrmSize.GetHeightPercent() )
	{
		SwTwips nHeight = rFrmSize.GetHeight();

		nHeight -= rBox.CalcLineSpace(BOX_LINE_TOP) +
				   rBox.CalcLineSpace(BOX_LINE_BOTTOM);

		ASSERT( nHeight>0, "Gibt es 0 twip hohe Grafiken!?" );

		if( nGrfSize.Height() != nHeight )
		{
			aScaleY = Fraction( nGrfSize.Height(), nHeight );
			bScale = sal_True;
		}
	}

	if( bScale )
	{
		aURL.GetMap()->Scale( aScaleX, aScaleY );
        pFmt->SetFmtAttr( aURL );
	}
}


void SwGrfNode::DelStreamName()
{
	if( HasStreamName() )
	{
		// Dann die Grafik im Storage loeschen
        uno::Reference < embed::XStorage > xDocStg = GetDoc()->GetDocStorage();
        if( xDocStg.is() )
		{
            try
            {
                String aPicStgName, aStrmName;
                _GetStreamStorageNames( aStrmName, aPicStgName );
                uno::Reference < embed::XStorage > refPics = xDocStg;
                if ( aPicStgName.Len() )
                    refPics = xDocStg->openStorageElement( aPicStgName, embed::ElementModes::READWRITE );
                refPics->removeElement( aStrmName );
                uno::Reference < embed::XTransactedObject > xTrans( refPics, uno::UNO_QUERY );
                if ( xTrans.is() )
                    xTrans->commit();
            }
            catch ( uno::Exception& )
            {
                // --> OD 2005-04-25 #i48434#
                ASSERT( false, "<SwGrfNode::DelStreamName()> - unhandled exception!" );
                // <--
            }
		}

		aGrfObj.SetUserData();
	}
}

/** helper method to get a substorage of the document storage for readonly access.

    OD, MAV 2005-08-17 #i53025#
    A substorage with the specified name will be opened readonly. If the provided
    name is empty the root storage will be returned.
*/
uno::Reference< embed::XStorage > SwGrfNode::_GetDocSubstorageOrRoot( const String& aStgName ) const
{
    uno::Reference < embed::XStorage > refStor =
        const_cast<SwGrfNode*>(this)->GetDoc()->GetDocStorage();
    ASSERT( refStor.is(), "Kein Storage am Doc" );

    if ( aStgName.Len() )
    {
        if( refStor.is() )
            return refStor->openStorageElement( aStgName, embed::ElementModes::READ );
    }

    return refStor;
}

/** helper method to determine stream for the embedded graphic.

    OD 2005-05-04 #i48434#
    Important note: caller of this method has to handle the thrown exceptions
    OD, MAV 2005-08-17 #i53025#
    Storage, which should contain the stream of the embedded graphic, is
    provided via parameter. Otherwise the returned stream will be closed
    after the the method returns, because its parent stream is closed and deleted.
    Proposed name of embedded graphic stream is also provided by parameter.

    @author OD
*/
SvStream* SwGrfNode::_GetStreamForEmbedGrf(
            const uno::Reference< embed::XStorage >& _refPics,
            String& _aStrmName ) const
{
    SvStream* pStrm( 0L );

    if( _refPics.is() && _aStrmName.Len() )
    {
        // If stream doesn't exist in the storage, try access the graphic file by
        // re-generating its name.
        // A save action can have changed the filename of the embedded graphic,
        // because a changed unique ID of the graphic is calculated.
        // --> OD 2006-01-30 #b6364738#
        // recursive calls of <GetUniqueID()> have to be avoided.
        // Thus, use local static boolean to assure this.
        static bool bInRegenerateStrmName( false );
        if ( !bInRegenerateStrmName &&
             ( !_refPics->hasByName( _aStrmName ) ||
               !_refPics->isStreamElement( _aStrmName ) ) )
        {
            bInRegenerateStrmName = true;
            xub_StrLen nExtPos = _aStrmName.Search( '.' );
            String aExtStr = _aStrmName.Copy( nExtPos );
			Graphic aGraphic( GetGrfObj().GetGraphic() );
			if ( aGraphic.GetType() != GRAPHIC_NONE )
			{
				_aStrmName = String( GetGrfObj().GetUniqueID(), RTL_TEXTENCODING_ASCII_US );
				_aStrmName += aExtStr;
			}
            bInRegenerateStrmName = false;
        }
        // <--

        // assure that graphic file exist in the storage.
        if ( _refPics->hasByName( _aStrmName ) &&
             _refPics->isStreamElement( _aStrmName ) )
        {
            uno::Reference < io::XStream > refStrm = _refPics->openStreamElement( _aStrmName, embed::ElementModes::READ );
            pStrm = utl::UcbStreamHelper::CreateStream( refStrm );
        }
        else
        {
            ASSERT( false, "<SwGrfNode::_GetStreamForEmbedGrf(..)> - embedded graphic file not found!" );
        }
    }

    return pStrm;
}


// --> OD 2005-08-17 #i53025# - stream couldn't be in a 3.1 - 5.2 storage any more.
// Thus, removing corresponding code.
void SwGrfNode::_GetStreamStorageNames( String& rStrmName,
                                        String& rStorName ) const
{
	rStorName.Erase();
	rStrmName.Erase();

	String aUserData( aGrfObj.GetUserData() );
	if( !aUserData.Len() )
        return;

	String aProt( RTL_CONSTASCII_STRINGPARAM( "vnd.sun.star.Package:" ) );
	if( 0 == aUserData.CompareTo( aProt, aProt.Len() ) )
	{
		// 6.0 (XML) Package
		xub_StrLen nPos = aUserData.Search( '/' );
		if( STRING_NOTFOUND == nPos )
		{
			rStrmName = aUserData.Copy( aProt.Len() );
		}
		else
		{
			xub_StrLen nPathStart = aProt.Len();
			if( 0 == aUserData.CompareToAscii( "./", 2 ) )
				nPathStart += 2;
			rStorName = aUserData.Copy( nPathStart, nPos-nPathStart );
			rStrmName = aUserData.Copy( nPos+1 );
		}
	}
    else
    {
        ASSERT( false,
                "<SwGrfNode::_GetStreamStorageNames(..)> - unknown graphic URL type. Code for handling 3.1 - 5.2 storages has been deleted by issue i53025." );
    }
	ASSERT( STRING_NOTFOUND == rStrmName.Search( '/' ),
			"invalid graphic stream name" );
}
// <--

SwCntntNode* SwGrfNode::MakeCopy( SwDoc* pDoc, const SwNodeIndex& rIdx ) const
{
	// kopiere die Formate in das andere Dokument:
	SwGrfFmtColl* pColl = pDoc->CopyGrfColl( *GetGrfColl() );

	Graphic aTmpGrf;
    SwBaseLink* pLink = (SwBaseLink*)(::sfx2::SvBaseLink*) refLink;
	if( !pLink && HasStreamName() )
	{
        // --> OD 2005-05-04 #i48434# - usage of new method <_GetStreamForEmbedGrf(..)>
        try
        {
            // --> OD, MAV 2005-08-17 #i53025# - needed correction of new
            // method <_GetStreamForEmbedGrf(..)>
//            bool bGraphic(false);
//            SvStream* pStrm = _GetStreamForEmbedGrf( bGraphic );
            String aStrmName, aPicStgName;
            _GetStreamStorageNames( aStrmName, aPicStgName );
            uno::Reference < embed::XStorage > refPics = _GetDocSubstorageOrRoot( aPicStgName );
            SvStream* pStrm = _GetStreamForEmbedGrf( refPics, aStrmName );
            if ( pStrm )
            {
                const String aURL(aGrfObj.GetUserData());
                GraphicFilter::GetGraphicFilter()->ImportGraphic(aTmpGrf, aURL, *pStrm);
                delete pStrm;
            }
            // <--
        }
        catch ( uno::Exception& )
        {
            // --> OD 2005-04-25 #i48434#
            ASSERT( false, "<SwGrfNode::MakeCopy(..)> - unhandled exception!" );
            // <--
        }
        // <--
	}
	else
	{
		if( aGrfObj.IsSwappedOut() )
            const_cast<SwGrfNode*>(this)->SwapIn();
		aTmpGrf = aGrfObj.GetGraphic();
	}

    const sfx2::LinkManager& rMgr = getIDocumentLinksAdministration()->GetLinkManager();
	String sFile, sFilter;
	if( IsLinkedFile() )
		rMgr.GetDisplayNames( refLink, 0, &sFile, 0, &sFilter );
	else if( IsLinkedDDE() )
	{
		String sTmp1, sTmp2;
		rMgr.GetDisplayNames( refLink, &sTmp1, &sTmp2, &sFilter );
        sfx2::MakeLnkName( sFile, &sTmp1, sTmp2, sFilter );
		sFilter.AssignAscii( RTL_CONSTASCII_STRINGPARAM( "DDE" ));
	}

	SwGrfNode* pGrfNd = pDoc->GetNodes().MakeGrfNode( rIdx, sFile, sFilter,
													&aTmpGrf, pColl,
											(SwAttrSet*)GetpSwAttrSet() );
    pGrfNd->SetTitle( GetTitle() );
    pGrfNd->SetDescription( GetDescription() );
    pGrfNd->SetContour( HasContour(), HasAutomaticContour() );
	return pGrfNd;
}

IMPL_LINK( SwGrfNode, SwapGraphic, GraphicObject*, pGrfObj )
{
	SvStream* pRet;

	// #101174#: Keep graphic while in swap in. That's at least important
	// when breaking links, because in this situation a reschedule call and
	// a DataChanged call lead to a paint of the graphic.
	if( pGrfObj->IsInSwapOut() && (IsSelected() || bInSwapIn) )
		pRet = GRFMGR_AUTOSWAPSTREAM_NONE;
	else if( refLink.Is() )
	{
		if( pGrfObj->IsInSwapIn() )
		{
			// then make it by your self
			if( !bInSwapIn )
			{
				sal_Bool bIsModifyLocked = IsModifyLocked();
				LockModify();
				SwapIn( sal_False );
				if( !bIsModifyLocked )
					UnlockModify();
			}
			pRet = GRFMGR_AUTOSWAPSTREAM_NONE;
		}
		else
			pRet = GRFMGR_AUTOSWAPSTREAM_LINK;
	}
	else
	{
		pRet = GRFMGR_AUTOSWAPSTREAM_TEMP;

		if( HasStreamName() )
		{
            // --> OD 2005-05-04 #i48434# - usage of new method <_GetStreamForEmbedGrf(..)>
            try
            {
                // --> OD, MAV 2005-08-17 #i53025# - needed correction of new
                // method <_GetStreamForEmbedGrf(..)>
//                bool bGraphic(false);
//                SvStream* pStrm = _GetStreamForEmbedGrf( bGraphic );
                String aStrmName, aPicStgName;
                _GetStreamStorageNames( aStrmName, aPicStgName );
                uno::Reference < embed::XStorage > refPics = _GetDocSubstorageOrRoot( aPicStgName );
                SvStream* pStrm = _GetStreamForEmbedGrf( refPics, aStrmName );
                if ( pStrm )
                {
                    if( pGrfObj->IsInSwapOut() )
                    {
                        pRet = GRFMGR_AUTOSWAPSTREAM_LINK;
                    }
                    else
                    {
                        ImportGraphic( *pStrm );
                        pRet = GRFMGR_AUTOSWAPSTREAM_LOADED;
                    }
                    delete pStrm;
                }
                // <--
            }
            catch ( uno::Exception& )
            {
                // --> OD 2005-04-25 #i48434#
                ASSERT( false, "<SwapGraphic> - unhandled exception!" );
                // <--
            }
            // <--
		}
	}

	return (long)pRet;
}


// alle QuickDraw-Bitmaps eines speziellen Docs loeschen
void DelAllGrfCacheEntries( SwDoc* pDoc )
{
	if( pDoc )
	{
		// alle Graphic-Links mit dem Namen aus dem Cache loeschen
		const sfx2::LinkManager& rLnkMgr = pDoc->GetLinkManager();
        const ::sfx2::SvBaseLinks& rLnks = rLnkMgr.GetLinks();
		SwGrfNode* pGrfNd;
		String sFileNm;
		for( sal_uInt16 n = rLnks.Count(); n; )
		{
            ::sfx2::SvBaseLink* pLnk = &(*rLnks[ --n ]);
			if( pLnk && OBJECT_CLIENT_GRF == pLnk->GetObjType() &&
				rLnkMgr.GetDisplayNames( pLnk, 0, &sFileNm ) &&
				pLnk->ISA( SwBaseLink ) && 0 != ( pGrfNd =
				((SwBaseLink*)pLnk)->GetCntntNode()->GetGrfNode()) )
			{
				pGrfNd->GetGrfObj().ReleaseFromCache();
			}
		}
	}
}

// returns the with our graphic attributes filled Graphic-Attr-Structure
GraphicAttr& SwGrfNode::GetGraphicAttr( GraphicAttr& rGA,
										const SwFrm* pFrm ) const
{
	const SwAttrSet& rSet = GetSwAttrSet();

	rGA.SetDrawMode( (GraphicDrawMode)rSet.GetDrawModeGrf().GetValue() );

	const SwMirrorGrf & rMirror = rSet.GetMirrorGrf();
	sal_uLong nMirror = BMP_MIRROR_NONE;
	if( rMirror.IsGrfToggle() && pFrm && !pFrm->FindPageFrm()->OnRightPage() )
	{
		switch( rMirror.GetValue() )
		{
        case RES_MIRROR_GRAPH_DONT:     nMirror = BMP_MIRROR_HORZ; break;
        case RES_MIRROR_GRAPH_VERT:     nMirror = BMP_MIRROR_NONE; break;
        case RES_MIRROR_GRAPH_HOR:  nMirror = BMP_MIRROR_HORZ|BMP_MIRROR_VERT;
									break;
		default: 					nMirror = BMP_MIRROR_VERT; break;
		}
	}
	else
		switch( rMirror.GetValue() )
		{
        case RES_MIRROR_GRAPH_BOTH:     nMirror = BMP_MIRROR_HORZ|BMP_MIRROR_VERT;
									break;
        case RES_MIRROR_GRAPH_VERT: nMirror = BMP_MIRROR_HORZ; break;
        case RES_MIRROR_GRAPH_HOR:  nMirror = BMP_MIRROR_VERT; break;
		}

	rGA.SetMirrorFlags( nMirror );

	const SwCropGrf& rCrop = rSet.GetCropGrf();
	rGA.SetCrop( TWIP_TO_MM100( rCrop.GetLeft() ),
				 TWIP_TO_MM100( rCrop.GetTop() ),
				 TWIP_TO_MM100( rCrop.GetRight() ),
				 TWIP_TO_MM100( rCrop.GetBottom() ));

	const SwRotationGrf& rRotation = rSet.GetRotationGrf();
	rGA.SetRotation( rRotation.GetValue() );

	rGA.SetLuminance( rSet.GetLuminanceGrf().GetValue() );
	rGA.SetContrast( rSet.GetContrastGrf().GetValue() );
	rGA.SetChannelR( rSet.GetChannelRGrf().GetValue() );
	rGA.SetChannelG( rSet.GetChannelGGrf().GetValue() );
	rGA.SetChannelB( rSet.GetChannelBGrf().GetValue() );
	rGA.SetGamma( rSet.GetGammaGrf().GetValue() );
	rGA.SetInvert( rSet.GetInvertGrf().GetValue() );

	const sal_uInt16 nTrans = rSet.GetTransparencyGrf().GetValue();
	rGA.SetTransparency( (sal_uInt8) FRound(
								Min( nTrans, (sal_uInt16) 100 )  * 2.55 ) );

	return rGA;
}

sal_Bool SwGrfNode::IsTransparent() const
{
	sal_Bool bRet = aGrfObj.IsTransparent();
	if( !bRet )	// ask the attribut
		bRet = 0 != GetSwAttrSet().GetTransparencyGrf().GetValue();

	return bRet;
}


sal_Bool SwGrfNode::IsSelected() const
{
	sal_Bool bRet = sal_False;
	const SwEditShell* pESh = GetDoc()->GetEditShell();
	if( pESh )
	{
		const SwNode* pN = this;
		const ViewShell* pV = pESh;
		do {
			if( pV->ISA( SwEditShell ) && pN == &((SwCrsrShell*)pV)
								->GetCrsr()->GetPoint()->nNode.GetNode() )
			{
				bRet = sal_True;
				break;
			}
		}
		while( pESh != ( pV = (ViewShell*)pV->GetNext() ));
	}
	return bRet;
}

// --> OD 2006-12-22 #i73788#
boost::weak_ptr< SwAsyncRetrieveInputStreamThreadConsumer > SwGrfNode::GetThreadConsumer()
{
    return mpThreadConsumer;
}

void SwGrfNode::TriggerAsyncRetrieveInputStream()
{
    if ( !IsLinkedFile() )
    {
        ASSERT( false,
                "<SwGrfNode::TriggerAsyncLoad()> - Method is misused. Method call is only valid for graphic nodes, which refer a linked graphic file" );
        return;
    }

    if ( mpThreadConsumer.get() == 0 )
    {
        mpThreadConsumer.reset( new SwAsyncRetrieveInputStreamThreadConsumer( *this ) );

        String sGrfNm;
        refLink->GetLinkManager()->GetDisplayNames( refLink, 0, &sGrfNm, 0, 0 );

        mpThreadConsumer->CreateThread( sGrfNm );
    }
}

bool SwGrfNode::IsLinkedInputStreamReady() const
{
    return mbLinkedInputStreamReady;
}

void SwGrfNode::ApplyInputStream(
    com::sun::star::uno::Reference<com::sun::star::io::XInputStream> xInputStream,
    const sal_Bool bIsStreamReadOnly )
{
    if ( IsLinkedFile() )
    {
        if ( xInputStream.is() )
        {
            mxInputStream = xInputStream;
            mbIsStreamReadOnly = bIsStreamReadOnly;
            mbLinkedInputStreamReady = true;
            SwMsgPoolItem aMsgHint( RES_LINKED_GRAPHIC_STREAM_ARRIVED );
            ModifyNotification( &aMsgHint, &aMsgHint );
        }
    }
}

void SwGrfNode::UpdateLinkWithInputStream()
{
    // --> OD #i85105#
    // do not work on link, if a <SwapIn> has been triggered.
    if ( !bInSwapIn && IsLinkedFile() )
    // <--
    {
        GetLink()->setStreamToLoadFrom( mxInputStream, mbIsStreamReadOnly );
        GetLink()->Update();
        SwMsgPoolItem aMsgHint( RES_GRAPHIC_ARRIVED );
        ModifyNotification( &aMsgHint, &aMsgHint );

        // --> OD 2008-06-18 #i88291#
        mxInputStream.clear();
        GetLink()->clearStreamToLoadFrom();
        // <--
        mbLinkedInputStreamReady = false;
        mpThreadConsumer.reset();
    }
}
// <--

// --> OD 2008-07-21 #i90395#
bool SwGrfNode::IsAsyncRetrieveInputStreamPossible() const
{
    bool bRet = false;

    if ( IsLinkedFile() )
    {
        String sGrfNm;
        refLink->GetLinkManager()->GetDisplayNames( refLink, 0, &sGrfNm, 0, 0 );
        String sProtocol( RTL_CONSTASCII_STRINGPARAM( "vnd.sun.star.pkg:" ) );
        if ( sGrfNm.CompareTo( sProtocol, sProtocol.Len() ) != 0 )
        {
            bRet = true;
        }
    }

    return bRet;
}
// <--