xref: /aoo41x/main/sc/source/filter/rtf/eeimpars.cxx (revision b3f79822)

/**************************************************************
 *
 * 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_sc.hxx"



//------------------------------------------------------------------------

#include "scitems.hxx"
#include <editeng/eeitem.hxx>


#include <editeng/adjitem.hxx>
#include <editeng/editobj.hxx>
#include <editeng/editview.hxx>
#include <editeng/escpitem.hxx>
#include <editeng/langitem.hxx>
#include <svx/svdograf.hxx>
#include <svx/svdpage.hxx>
#include <editeng/scripttypeitem.hxx>
#include <svtools/htmlcfg.hxx>
#include <sfx2/sfxhtml.hxx>
#include <svtools/parhtml.hxx>
#include <svl/zforlist.hxx>
#include <vcl/virdev.hxx>
#include <vcl/svapp.hxx>
#include <unotools/syslocale.hxx>
#include <unotools/charclass.hxx>

#include "eeimport.hxx"
#include "global.hxx"
#include "document.hxx"
#include "editutil.hxx"
#include "stlsheet.hxx"
#include "docpool.hxx"
#include "attrib.hxx"
#include "patattr.hxx"
#include "cell.hxx"
#include "eeparser.hxx"
#include "drwlayer.hxx"
#include "rangenam.hxx"
#include "progress.hxx"

#include "globstr.hrc"

// in fuins1.cxx
extern void ScLimitSizeOnDrawPage( Size& rSize, Point& rPos, const Size& rPage );

//------------------------------------------------------------------------

ScEEImport::ScEEImport( ScDocument* pDocP, const ScRange& rRange ) :
    maRange( rRange ),
    mpDoc( pDocP ),
    mpParser( NULL ),
    mpRowHeights( new Table )
{
    const ScPatternAttr* pPattern = mpDoc->GetPattern(
        maRange.aStart.Col(), maRange.aStart.Row(), maRange.aStart.Tab() );
    mpEngine = new ScTabEditEngine( *pPattern, mpDoc->GetEditPool() );
    mpEngine->SetUpdateMode( sal_False );
    mpEngine->EnableUndo( sal_False );
}


ScEEImport::~ScEEImport()
{
	// Reihenfolge wichtig, sonst knallt's irgendwann irgendwo in irgendeinem Dtor!
	// Ist gewaehrleistet, da ScEEImport Basisklasse ist
    delete mpEngine;        // nach Parser!
    delete mpRowHeights;
}


sal_uLong ScEEImport::Read( SvStream& rStream, const String& rBaseURL )
{
    sal_uLong nErr = mpParser->Read( rStream, rBaseURL );

	SCCOL nEndCol;
	SCROW nEndRow;
    mpParser->GetDimensions( nEndCol, nEndRow );
	if ( nEndCol != 0 )
	{
        nEndCol += maRange.aStart.Col() - 1;
		if ( nEndCol > MAXCOL )
			nEndCol = MAXCOL;
	}
	else
        nEndCol = maRange.aStart.Col();
	if ( nEndRow != 0 )
	{
        nEndRow += maRange.aStart.Row() - 1;
		if ( nEndRow > MAXROW )
			nEndRow = MAXROW;
	}
	else
        nEndRow = maRange.aStart.Row();
    maRange.aEnd.Set( nEndCol, nEndRow, maRange.aStart.Tab() );

	return nErr;
}


void ScEEImport::WriteToDocument( sal_Bool bSizeColsRows, double nOutputFactor, SvNumberFormatter* pFormatter, bool bConvertDate )
{
    ScProgress* pProgress = new ScProgress( mpDoc->GetDocumentShell(),
        ScGlobal::GetRscString( STR_LOAD_DOC ), mpParser->Count() );
	sal_uLong nProgress = 0;

	SCCOL nStartCol, nEndCol;
        SCROW nStartRow, nEndRow;
        SCTAB nTab;
        SCROW nOverlapRowMax, nLastMergedRow;
        SCCOL nMergeColAdd;
    nStartCol = maRange.aStart.Col();
    nStartRow = maRange.aStart.Row();
    nTab = maRange.aStart.Tab();
    nEndCol = maRange.aEnd.Col();
    nEndRow = maRange.aEnd.Row();
	nOverlapRowMax = 0;
	nMergeColAdd = 0;
	nLastMergedRow = SCROW_MAX;
	sal_Bool bHasGraphics = sal_False;
	ScEEParseEntry* pE;
    if (!pFormatter)
        pFormatter = mpDoc->GetFormatTable();
    bool bNumbersEnglishUS = false;
    if (pFormatter->GetLanguage() == LANGUAGE_SYSTEM)
    {
        // Automatic language option selected.  Check for the global 'use US English' option.
        SvxHtmlOptions aOpt;
        bNumbersEnglishUS = aOpt.IsNumbersEnglishUS();
    }
    ScDocumentPool* pDocPool = mpDoc->GetPool();
    ScRangeName* pRangeNames = mpDoc->GetRangeName();
    for ( pE = mpParser->First(); pE; pE = mpParser->Next() )
	{
		SCROW nRow = nStartRow + pE->nRow;
		if ( nRow != nLastMergedRow )
			nMergeColAdd = 0;
		SCCOL nCol = nStartCol + pE->nCol + nMergeColAdd;
		// RowMerge feststellen, pures ColMerge und ColMerge der ersten
		// MergeRow bereits beim parsen
		if ( nRow <= nOverlapRowMax )
		{
            while ( nCol <= MAXCOL && mpDoc->HasAttrib( nCol, nRow, nTab,
				nCol, nRow, nTab, HASATTR_OVERLAPPED ) )
			{
				nCol++;
				nMergeColAdd++;
			}
			nLastMergedRow = nRow;
		}
		// fuer zweiten Durchlauf eintragen
		pE->nCol = nCol;
		pE->nRow = nRow;
		if ( ValidCol(nCol) && ValidRow(nRow) )
		{
            SfxItemSet aSet = mpEngine->GetAttribs( pE->aSel );
			// Default raus, wir setzen selber links/rechts je nachdem ob Text
			// oder Zahl; EditView.GetAttribs liefert immer kompletten Set
			// mit Defaults aufgefuellt
			const SfxPoolItem& rItem = aSet.Get( EE_PARA_JUST );
			if ( ((const SvxAdjustItem&)rItem).GetAdjust() == SVX_ADJUST_LEFT )
				aSet.ClearItem( EE_PARA_JUST );

			// Testen, ob einfacher String ohne gemischte Attribute
			sal_Bool bSimple = ( pE->aSel.nStartPara == pE->aSel.nEndPara );
            for (sal_uInt16 nId = EE_CHAR_START; nId <= EE_CHAR_END && bSimple; nId++)
			{
                const SfxPoolItem* pItem = 0;
				SfxItemState eState = aSet.GetItemState( nId, sal_True, &pItem );
				if (eState == SFX_ITEM_DONTCARE)
					bSimple = sal_False;
				else if (eState == SFX_ITEM_SET)
				{
					if ( nId == EE_CHAR_ESCAPEMENT )		// Hoch-/Tiefstellen immer ueber EE
					{
						if ( (SvxEscapement)((const SvxEscapementItem*)pItem)->GetEnumValue()
								!= SVX_ESCAPEMENT_OFF )
							bSimple = sal_False;
					}
				}
			}
			if ( bSimple )
			{	//	Feldbefehle enthalten?
				SfxItemState eFieldState = aSet.GetItemState( EE_FEATURE_FIELD, sal_False );
				if ( eFieldState == SFX_ITEM_DONTCARE || eFieldState == SFX_ITEM_SET )
					bSimple = sal_False;
			}

			// HTML
			String aValStr, aNumStr;
			double fVal;
            sal_uInt32 nNumForm = 0;
            LanguageType eNumLang = LANGUAGE_NONE;
			if ( pE->pNumStr )
			{	// SDNUM muss sein wenn SDVAL
				aNumStr = *pE->pNumStr;
				if ( pE->pValStr )
					aValStr = *pE->pValStr;
				fVal = SfxHTMLParser::GetTableDataOptionsValNum(
					nNumForm, eNumLang, aValStr, aNumStr, *pFormatter );
			}

			// Attribute setzen
			ScPatternAttr aAttr( pDocPool );
			aAttr.GetFromEditItemSet( &aSet );
			SfxItemSet& rSet = aAttr.GetItemSet();
			if ( aNumStr.Len() )
			{
				rSet.Put( SfxUInt32Item( ATTR_VALUE_FORMAT, nNumForm ) );
				rSet.Put( SvxLanguageItem( eNumLang, ATTR_LANGUAGE_FORMAT ) );
			}
			const SfxItemSet& rESet = pE->aItemSet;
			if ( rESet.Count() )
			{
				const SfxPoolItem* pItem;
				if ( rESet.GetItemState( ATTR_BACKGROUND, sal_False, &pItem) == SFX_ITEM_SET )
					rSet.Put( *pItem );
				if ( rESet.GetItemState( ATTR_BORDER, sal_False, &pItem) == SFX_ITEM_SET )
					rSet.Put( *pItem );
				if ( rESet.GetItemState( ATTR_SHADOW, sal_False, &pItem) == SFX_ITEM_SET )
					rSet.Put( *pItem );
				// HTML
				if ( rESet.GetItemState( ATTR_HOR_JUSTIFY, sal_False, &pItem) == SFX_ITEM_SET )
					rSet.Put( *pItem );
				if ( rESet.GetItemState( ATTR_VER_JUSTIFY, sal_False, &pItem) == SFX_ITEM_SET )
					rSet.Put( *pItem );
				if ( rESet.GetItemState( ATTR_LINEBREAK, sal_False, &pItem) == SFX_ITEM_SET )
					rSet.Put( *pItem );
				if ( rESet.GetItemState( ATTR_FONT_COLOR, sal_False, &pItem) == SFX_ITEM_SET )
					rSet.Put( *pItem );
				if ( rESet.GetItemState( ATTR_FONT_UNDERLINE, sal_False, &pItem) == SFX_ITEM_SET )
					rSet.Put( *pItem );
                // HTML LATIN/CJK/CTL script type dependent
                const SfxPoolItem* pFont;
				if ( rESet.GetItemState( ATTR_FONT, sal_False, &pFont) != SFX_ITEM_SET )
                    pFont = 0;
                const SfxPoolItem* pHeight;
				if ( rESet.GetItemState( ATTR_FONT_HEIGHT, sal_False, &pHeight) != SFX_ITEM_SET )
                    pHeight = 0;
                const SfxPoolItem* pWeight;
				if ( rESet.GetItemState( ATTR_FONT_WEIGHT, sal_False, &pWeight) != SFX_ITEM_SET )
                    pWeight = 0;
                const SfxPoolItem* pPosture;
				if ( rESet.GetItemState( ATTR_FONT_POSTURE, sal_False, &pPosture) != SFX_ITEM_SET )
                    pPosture = 0;
                if ( pFont || pHeight || pWeight || pPosture )
                {
                    String aStr( mpEngine->GetText( pE->aSel ) );
                    sal_uInt8 nScriptType = mpDoc->GetStringScriptType( aStr );
                    const sal_uInt8 nScripts[3] = { SCRIPTTYPE_LATIN,
                        SCRIPTTYPE_ASIAN, SCRIPTTYPE_COMPLEX };
                    for ( sal_uInt8 i=0; i<3; ++i )
                    {
                        if ( nScriptType & nScripts[i] )
                        {
                            if ( pFont )
                                rSet.Put( *pFont, ScGlobal::GetScriptedWhichID(
                                            nScripts[i], ATTR_FONT ));
                            if ( pHeight )
                                rSet.Put( *pHeight, ScGlobal::GetScriptedWhichID(
                                            nScripts[i], ATTR_FONT_HEIGHT ));
                            if ( pWeight )
                                rSet.Put( *pWeight, ScGlobal::GetScriptedWhichID(
                                            nScripts[i], ATTR_FONT_WEIGHT ));
                            if ( pPosture )
                                rSet.Put( *pPosture, ScGlobal::GetScriptedWhichID(
                                            nScripts[i], ATTR_FONT_POSTURE ));
                        }
                    }
                }
			}
			if ( pE->nColOverlap > 1 || pE->nRowOverlap > 1 )
			{	// merged cells, mit SfxItemSet Put schneller als mit
				// nachtraeglichem ScDocument DoMerge
				ScMergeAttr aMerge( pE->nColOverlap, pE->nRowOverlap );
				rSet.Put( aMerge );
                SCROW nRO = 0;
				if ( pE->nColOverlap > 1 )
                    mpDoc->ApplyFlagsTab( nCol+1, nRow,
						nCol + pE->nColOverlap - 1, nRow, nTab,
						SC_MF_HOR );
				if ( pE->nRowOverlap > 1 )
				{
					nRO = nRow + pE->nRowOverlap - 1;
                    mpDoc->ApplyFlagsTab( nCol, nRow+1,
						nCol, nRO , nTab,
						SC_MF_VER );
					if ( nRO > nOverlapRowMax )
						nOverlapRowMax = nRO;
				}
				if ( pE->nColOverlap > 1 && pE->nRowOverlap > 1 )
                    mpDoc->ApplyFlagsTab( nCol+1, nRow+1,
						nCol + pE->nColOverlap - 1, nRO, nTab,
						SC_MF_HOR | SC_MF_VER );
			}
			const ScStyleSheet* pStyleSheet =
                mpDoc->GetPattern( nCol, nRow, nTab )->GetStyleSheet();
			aAttr.SetStyleSheet( (ScStyleSheet*)pStyleSheet );
            mpDoc->SetPattern( nCol, nRow, nTab, aAttr, sal_True );

			// Daten eintragen
			if (bSimple)
			{
				if ( aValStr.Len() )
                    mpDoc->SetValue( nCol, nRow, nTab, fVal );
				else if ( !pE->aSel.HasRange() )
				{
					// maybe ALT text of IMG or similar
                    mpDoc->SetString( nCol, nRow, nTab, pE->aAltText, pFormatter );
					// wenn SelRange komplett leer kann nachfolgender Text im gleichen Absatz liegen!
				}
				else
				{
                    String aStr;
                    if( pE->bEntirePara )
                    {
                        aStr = mpEngine->GetText( pE->aSel.nStartPara );
                    }
                    else
                    {
                        aStr = mpEngine->GetText( pE->aSel );
                        aStr.EraseLeadingAndTrailingChars();
                    }

                    // TODO: RTF import should follow the language tag,
                    // currently this follows the HTML options for both, HTML
                    // and RTF.
                    bool bEnUsRecognized = false;
                    if (bNumbersEnglishUS)
                    {
                        pFormatter->ChangeIntl( LANGUAGE_ENGLISH_US);
                        sal_uInt32 nIndex = pFormatter->GetStandardIndex( LANGUAGE_ENGLISH_US);
                        double fEnVal = 0.0;
                        if (pFormatter->IsNumberFormat( aStr, nIndex, fEnVal))
                        {
                            bEnUsRecognized = true;
                            sal_uInt32 nNewIndex =
                                pFormatter->GetFormatForLanguageIfBuiltIn(
                                        nIndex, LANGUAGE_SYSTEM);
                            DBG_ASSERT( nNewIndex != nIndex, "ScEEImport::WriteToDocument: NumbersEnglishUS not a built-in format?");
                            pFormatter->GetInputLineString( fEnVal, nNewIndex, aStr);
                        }
                        pFormatter->ChangeIntl( LANGUAGE_SYSTEM);
                    }

					//	#105460#, #i4180# String cells can't contain tabs or linebreaks
					//	-> replace with spaces
					aStr.SearchAndReplaceAll( (sal_Unicode)'\t', (sal_Unicode)' ' );
					aStr.SearchAndReplaceAll( (sal_Unicode)'\n', (sal_Unicode)' ' );

                    if (bNumbersEnglishUS && !bEnUsRecognized)
                        mpDoc->PutCell( nCol, nRow, nTab, new ScStringCell( aStr));
                    else
                        mpDoc->SetString( nCol, nRow, nTab, aStr, pFormatter, bConvertDate );
				}
			}
			else
			{
                EditTextObject* pObject = mpEngine->CreateTextObject( pE->aSel );
                mpDoc->PutCell( nCol, nRow, nTab, new ScEditCell( pObject,
                    mpDoc, mpEngine->GetEditTextObjectPool() ) );
				delete pObject;
			}
			if ( pE->pImageList )
				bHasGraphics |= GraphicSize( nCol, nRow, nTab, pE );
			if ( pE->pName )
			{	// Anchor Name => RangeName
				sal_uInt16 nIndex;
				if ( !pRangeNames->SearchName( *pE->pName, nIndex ) )
				{
                    ScRangeData* pData = new ScRangeData( mpDoc, *pE->pName,
						ScAddress( nCol, nRow, nTab ) );
					pRangeNames->Insert( pData );
				}
			}
		}
		pProgress->SetStateOnPercent( ++nProgress );
	}
	if ( bSizeColsRows )
	{
		// Spaltenbreiten
        Table* pColWidths = mpParser->GetColWidths();
		if ( pColWidths->Count() )
		{
			nProgress = 0;
			pProgress->SetState( nProgress, nEndCol - nStartCol + 1 );
			for ( SCCOL nCol = nStartCol; nCol <= nEndCol; nCol++ )
			{
				sal_uInt16 nWidth = (sal_uInt16)(sal_uLong) pColWidths->Get( nCol );
				if ( nWidth )
                    mpDoc->SetColWidth( nCol, nTab, nWidth );
				pProgress->SetState( ++nProgress );
			}
		}
		DELETEZ( pProgress );	// SetOptimalHeight hat seinen eigenen ProgressBar
		// Zeilenhoehen anpassen, Basis 100% Zoom
		Fraction aZoom( 1, 1 );
		double nPPTX = ScGlobal::nScreenPPTX * (double) aZoom
			/ nOutputFactor;		// Faktor ist Drucker zu Bildschirm
		double nPPTY = ScGlobal::nScreenPPTY * (double) aZoom;
		VirtualDevice aVirtDev;
        mpDoc->SetOptimalHeight( 0, nEndRow, 0,
            static_cast< sal_uInt16 >( ScGlobal::nLastRowHeightExtra ), &aVirtDev,
			nPPTX, nPPTY, aZoom, aZoom, sal_False );
        if ( mpRowHeights->Count() )
		{
			for ( SCROW nRow = nStartRow; nRow <= nEndRow; nRow++ )
			{
                sal_uInt16 nHeight = (sal_uInt16)(sal_uLong) mpRowHeights->Get( nRow );
                if ( nHeight > mpDoc->GetRowHeight( nRow, nTab ) )
                    mpDoc->SetRowHeight( nRow, nTab, nHeight );
			}
		}
	}
	if ( bHasGraphics )
	{	// Grafiken einfuegen
        for ( pE = mpParser->First(); pE; pE = mpParser->Next() )
		{
			if ( pE->pImageList )
			{
				SCCOL nCol = pE->nCol;
				SCROW nRow = pE->nRow;
				if ( ValidCol(nCol) && ValidRow(nRow) )
					InsertGraphic( nCol, nRow, nTab, pE );
			}
		}
	}
	if ( pProgress )
		delete pProgress;
}


sal_Bool ScEEImport::GraphicSize( SCCOL nCol, SCROW nRow, SCTAB /*nTab*/,
		ScEEParseEntry* pE )
{
	ScHTMLImageList* pIL = pE->pImageList;
	if ( !pIL || !pIL->Count() )
		return sal_False;
	sal_Bool bHasGraphics = sal_False;
	OutputDevice* pDefaultDev = Application::GetDefaultDevice();
	long nWidth, nHeight;
	nWidth = nHeight = 0;
	sal_Char nDir = nHorizontal;
	for ( ScHTMLImage* pI = pIL->First(); pI; pI = pIL->Next() )
	{
		if ( pI->pGraphic )
			bHasGraphics = sal_True;
		Size aSizePix = pI->aSize;
		aSizePix.Width() += 2 * pI->aSpace.X();
		aSizePix.Height() += 2 * pI->aSpace.Y();
		Size aLogicSize = pDefaultDev->PixelToLogic( aSizePix, MapMode( MAP_TWIP ) );
		if ( nDir & nHorizontal )
			nWidth += aLogicSize.Width();
		else if ( nWidth < aLogicSize.Width() )
			nWidth = aLogicSize.Width();
		if ( nDir & nVertical )
			nHeight += aLogicSize.Height();
		else if ( nHeight < aLogicSize.Height() )
			nHeight = aLogicSize.Height();
		nDir = pI->nDir;
	}
	// Spaltenbreiten
    Table* pColWidths = mpParser->GetColWidths();
	long nThisWidth = (long) pColWidths->Get( nCol );
	long nColWidths = nThisWidth;
	SCCOL nColSpanCol = nCol + pE->nColOverlap;
	for ( SCCOL nC = nCol + 1; nC < nColSpanCol; nC++ )
	{
		nColWidths += (long) pColWidths->Get( nC );
	}
	if ( nWidth > nColWidths )
	{	// Differenz nur in der ersten Spalte eintragen
		if ( nThisWidth )
			pColWidths->Replace( nCol, (void*)(nWidth - nColWidths + nThisWidth) );
		else
			pColWidths->Insert( nCol, (void*)(nWidth - nColWidths) );
	}
	// Zeilenhoehen, Differenz auf alle betroffenen Zeilen verteilen
	SCROW nRowSpan = pE->nRowOverlap;
	nHeight /= nRowSpan;
	if ( nHeight == 0 )
		nHeight = 1;		// fuer eindeutigen Vergleich
	for ( SCROW nR = nRow; nR < nRow + nRowSpan; nR++ )
	{
        long nRowHeight = (long) mpRowHeights->Get( nR );
		if ( nHeight > nRowHeight )
		{
			if ( nRowHeight )
                mpRowHeights->Replace( nR, (void*)nHeight );
			else
                mpRowHeights->Insert( nR, (void*)nHeight );
		}
	}
	return bHasGraphics;
}


void ScEEImport::InsertGraphic( SCCOL nCol, SCROW nRow, SCTAB nTab,
		ScEEParseEntry* pE )
{
	ScHTMLImageList* pIL = pE->pImageList;
	if ( !pIL || !pIL->Count() )
		return ;
    ScDrawLayer* pModel = mpDoc->GetDrawLayer();
	if (!pModel)
	{
        mpDoc->InitDrawLayer();
        pModel = mpDoc->GetDrawLayer();
	}
	SdrPage* pPage = pModel->GetPage( static_cast<sal_uInt16>(nTab) );
	OutputDevice* pDefaultDev = Application::GetDefaultDevice();

	Point aCellInsertPos(
        (long)((double) mpDoc->GetColOffset( nCol, nTab ) * HMM_PER_TWIPS),
        (long)((double) mpDoc->GetRowOffset( nRow, nTab ) * HMM_PER_TWIPS) );

	Point aInsertPos( aCellInsertPos );
	Point aSpace;
	Size aLogicSize;
	sal_Char nDir = nHorizontal;
	for ( ScHTMLImage* pI = pIL->First(); pI; pI = pIL->Next() )
	{
		if ( nDir & nHorizontal )
		{	// horizontal
			aInsertPos.X() += aLogicSize.Width();
			aInsertPos.X() += aSpace.X();
			aInsertPos.Y() = aCellInsertPos.Y();
		}
		else
		{	// vertikal
			aInsertPos.X() = aCellInsertPos.X();
			aInsertPos.Y() += aLogicSize.Height();
			aInsertPos.Y() += aSpace.Y();
		}
		// Offset des Spacings drauf
		aSpace = pDefaultDev->PixelToLogic( pI->aSpace, MapMode( MAP_100TH_MM ) );
		aInsertPos += aSpace;

		Size aSizePix = pI->aSize;
		aLogicSize = pDefaultDev->PixelToLogic( aSizePix, MapMode( MAP_100TH_MM ) );
		//	Groesse begrenzen
		::ScLimitSizeOnDrawPage( aLogicSize, aInsertPos, pPage->GetSize() );

		if ( pI->pGraphic )
		{
			Rectangle aRect ( aInsertPos, aLogicSize );
			SdrGrafObj* pObj = new SdrGrafObj( *pI->pGraphic, aRect );
            // #118522# calling SetGraphicLink here doesn't work
			pObj->SetName( pI->aURL );

			pPage->InsertObject( pObj );

            // #118522# SetGraphicLink has to be used after inserting the object,
            // otherwise an empty graphic is swapped in and the contact stuff crashes.
            // See #i37444#.
			pObj->SetGraphicLink( pI->aURL, pI->aFilterName );

			pObj->SetLogicRect( aRect );		// erst nach InsertObject !!!
		}
		nDir = pI->nDir;
	}
}


ScEEParser::ScEEParser( EditEngine* pEditP ) :
		pEdit( pEditP ),
		pPool( EditEngine::CreatePool() ),
		pDocPool( new ScDocumentPool ),
		pList( new ScEEParseList ),
		pColWidths( new Table ),
		nLastToken(0),
		nColCnt(0),
		nRowCnt(0),
		nColMax(0),
		nRowMax(0)
{
	// pPool wird spaeter bei RTFIMP_START dem SvxRTFParser untergejubelt
	pPool->SetSecondaryPool( pDocPool );
	pPool->FreezeIdRanges();
	NewActEntry( NULL );
}


ScEEParser::~ScEEParser()
{
	delete pActEntry;
	delete pColWidths;
	for ( ScEEParseEntry* pE = pList->First(); pE; pE = pList->Next() )
		delete pE;
	delete pList;

	// Pool erst loeschen nachdem die Listen geloescht wurden
	pPool->SetSecondaryPool( NULL );
	SfxItemPool::Free(pDocPool);
	SfxItemPool::Free(pPool);
}


void ScEEParser::NewActEntry( ScEEParseEntry* pE )
{	// neuer freifliegender pActEntry
	pActEntry = new ScEEParseEntry( pPool );
	pActEntry->aSel.nStartPara = (pE ? pE->aSel.nEndPara + 1 : 0);
	pActEntry->aSel.nStartPos = 0;
}