xref: /aoo41x/main/sw/source/filter/basflt/shellio.cxx (revision 6fddd742)

/**************************************************************
 *
 * 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 <tools/date.hxx>
#include <tools/time.hxx>
#include <svl/urihelper.hxx>
#include <svl/fstathelper.hxx>
#include <unotools/moduleoptions.hxx>
#include <sfx2/docfile.hxx>
#include <editeng/lrspitem.hxx>
#include <editeng/ulspitem.hxx>
#include <editeng/boxitem.hxx>
#include <editeng/paperinf.hxx>
#include <node.hxx>
#include <docary.hxx>
#include <fmtanchr.hxx>
#include <fmtfsize.hxx>
#include <fmtpdsc.hxx>
#include <swtypes.hxx>
#include <shellio.hxx>
#include <doc.hxx>
#include <IDocumentUndoRedo.hxx>
#include <pam.hxx>
#include <editsh.hxx>
#include <undobj.hxx>			// fuer Undo Insert-Dokument
#include <swundo.hxx>			// fuer Undo Insert-Dokument
#include <swtable.hxx>
#include <tblsel.hxx>
#include <pagedesc.hxx>
#include <poolfmt.hxx>
#include <fltini.hxx>
#include <docsh.hxx>
#include <redline.hxx>
#include <swerror.h>

#include <paratr.hxx>

// --> OD 2007-03-30 #i73788#
#include <pausethreadstarting.hxx>
// <--


using namespace ::com::sun::star;

//////////////////////////////////////////////////////////////////////////

sal_uLong SwReader::Read( const Reader& rOptions )
{
	// Variable uebertragen
	Reader* po = (Reader*) &rOptions;
	po->pStrm = pStrm;
	po->pStg  = pStg;
    po->xStg  = xStg;
	po->bInsertMode = 0 != pCrsr;

	// ist ein Medium angegeben, dann aus diesem die Streams besorgen
	if( 0 != (po->pMedium = pMedium ) &&
		!po->SetStrmStgPtr() )
	{
		po->SetReadUTF8( sal_False );
		po->SetBlockMode( sal_False );
		po->SetOrganizerMode( sal_False );
        po->SetIgnoreHTMLComments( sal_False );
		return ERR_SWG_FILE_FORMAT_ERROR;
	}

	sal_uLong nError = 0L;

	GetDoc();

	// am Sw3-Reader noch den pIo-Pointer "loeschen"
    /*
	if( po == ReadSw3 && pDoc->GetDocShell() &&
		((Sw3Reader*)po)->GetSw3Io() != pDoc->GetDocShell()->GetIoSystem() )
            ((Sw3Reader*)po)->SetSw3Io( pDoc->GetDocShell()->GetIoSystem() );*/

	// waehrend des einlesens kein OLE-Modified rufen
	Link aOLELink( pDoc->GetOle2Link() );
	pDoc->SetOle2Link( Link() );

    pDoc->SetInReading( true );
    pDoc->SetInXMLImport( 0 != dynamic_cast< XMLReader* >(po) );

	SwPaM *pPam;
	if( pCrsr )
		pPam = pCrsr;
	else
	{
		// Wenn der Reader nicht mit einem Shell konstruiert wurde,
		// selber einen Pam machen.
		SwNodeIndex nNode( pDoc->GetNodes().GetEndOfContent(), -1 );
		pPam = new SwPaM( nNode );
		// Bei Web-Dokumenten wird die Default-Vorlage schon im InitNew
		// gesetzt und braucht deshalb nicht nochmal gesetzt zu werden.
		// Das gilt natuerlich nicht, wenn der Filter nicht der HTML-Filter
		// ist oder im ConvertFrom zuvor ein SetTemplateName gerufen
		// wurde.
		if( !pDoc->get(IDocumentSettingAccess::HTML_MODE) || ReadHTML != po || !po->pTemplate  )
			po->SetTemplate( *pDoc );
	}

	// Pams sind ringfoermig verkettet. Aufhoeren, wenn man wieder beim
	// ersten ist.
	SwPaM *pEnd = pPam;
	SwUndoInsDoc* pUndo = 0;

	sal_Bool bReadPageDescs = sal_False;
    bool const bDocUndo = pDoc->GetIDocumentUndoRedo().DoesUndo();
	sal_Bool bSaveUndo = bDocUndo && pCrsr;
	if( bSaveUndo )
	{
		// das Einlesen von Seitenvorlagen ist nicht Undofaehig!
		if( 0 != ( bReadPageDescs = po->aOpt.IsPageDescs() ) )
		{
			bSaveUndo = sal_False;
            pDoc->GetIDocumentUndoRedo().DelAllUndoObj();
        }
        else
        {
            pDoc->GetIDocumentUndoRedo().ClearRedo();
            pDoc->GetIDocumentUndoRedo().StartUndo( UNDO_INSDOKUMENT, NULL );
        }
	}
    pDoc->GetIDocumentUndoRedo().DoUndo(false);

	SwNodeIndex aSplitIdx( pDoc->GetNodes() );

	RedlineMode_t eOld = pDoc->GetRedlineMode();
    RedlineMode_t ePostReadRedlineMode( nsRedlineMode_t::REDLINE_IGNORE );

	// Array von FlyFormaten
	SwSpzFrmFmts aFlyFrmArr;
	// only read templates? then ignore multi selection!
	sal_Bool bFmtsOnly = po->aOpt.IsFmtsOnly();

	while( sal_True )
	{
		if( bSaveUndo )
			pUndo = new SwUndoInsDoc( *pPam );

		pDoc->SetRedlineMode_intern( nsRedlineMode_t::REDLINE_IGNORE );

		SwPaM* pUndoPam = 0;
		if( bDocUndo || pCrsr )
		{
			// Pam auf den Node davor setzen damit er nicht mit verschoben wird
			const SwNodeIndex& rTmp = pPam->GetPoint()->nNode;
			pUndoPam = new SwPaM( rTmp, rTmp, 0, -1 );
		}

		// Speicher mal alle Fly's
		if( pCrsr )
			aFlyFrmArr.Insert( pDoc->GetSpzFrmFmts(), 0L );

		xub_StrLen nSttCntnt = pPam->GetPoint()->nContent.GetIndex();

		// damit fuer alle Reader die Ende-Position immer stimmt, hier
		// pflegen.
		SwCntntNode* pCNd = pPam->GetCntntNode();
		xub_StrLen nEndCntnt = pCNd ? pCNd->Len() - nSttCntnt : 0;
		SwNodeIndex aEndPos( pPam->GetPoint()->nNode, 1 );

		pDoc->SetRedlineMode_intern( eOld );

        nError = po->Read( *pDoc, GetBaseURL(), *pPam, aFileName );

        // an ODF document may contain redline mode in settings.xml; save it!
        ePostReadRedlineMode = pDoc->GetRedlineMode();

		pDoc->SetRedlineMode_intern( nsRedlineMode_t::REDLINE_IGNORE );

		if( !IsError( nError )) 	// dann setzen wir das Ende mal richtig
		{
			aEndPos--;
			pCNd = aEndPos.GetNode().GetCntntNode();
			if( !pCNd && 0 == ( pCNd = pDoc->GetNodes().GoPrevious( &aEndPos ) ))
				pCNd = pDoc->GetNodes().GoNext( &aEndPos );

			pPam->GetPoint()->nNode = aEndPos;
			xub_StrLen nLen = pCNd->Len();
			if( nLen < nEndCntnt )
				nEndCntnt = 0;
			else
				nEndCntnt = nLen - nEndCntnt;
			pPam->GetPoint()->nContent.Assign( pCNd, nEndCntnt );
		}

		if( pCrsr )
		{
			*pUndoPam->GetMark() = *pPam->GetPoint();
			pUndoPam->GetPoint()->nNode++;
			SwNode* pNd = pUndoPam->GetNode();
			if( pNd->IsCntntNode() )
				pUndoPam->GetPoint()->nContent.Assign(
									(SwCntntNode*)pNd, nSttCntnt );
			else
				pUndoPam->GetPoint()->nContent.Assign( 0, 0 );

			int bChkHeaderFooter = pNd->FindHeaderStartNode() ||
								   pNd->FindFooterStartNode();

			// Suche alle neuen Fly's und speicher sie als einzelne Undo
			// Objecte
			for( sal_uInt16 n = 0; n < pDoc->GetSpzFrmFmts()->Count(); ++n )
			{
				SwFrmFmt* pFrmFmt = (*pDoc->GetSpzFrmFmts())[ n ];
				const SwFmtAnchor& rAnchor = pFrmFmt->GetAnchor();
				if( USHRT_MAX == aFlyFrmArr.GetPos( pFrmFmt) )
				{
                    SwPosition const*const pFrameAnchor(
                            rAnchor.GetCntntAnchor());
                    if  (   (FLY_AT_PAGE == rAnchor.GetAnchorId())
                        ||  (   pFrameAnchor
                            &&  (   (   (FLY_AT_PARA == rAnchor.GetAnchorId())
                                    &&  (   (pUndoPam->GetPoint()->nNode ==
                                             pFrameAnchor->nNode)
                                        ||  (pUndoPam->GetMark()->nNode ==
                                             pFrameAnchor->nNode)
                                        )
                                    )
                                // #i97570# also check frames anchored AT char
                                ||  (   (FLY_AT_CHAR == rAnchor.GetAnchorId())
                                    &&  !IsDestroyFrameAnchoredAtChar(
                                              *pFrameAnchor,
                                              *pUndoPam->GetPoint(),
                                              *pUndoPam->GetMark())
                                    )
                                )
                            )
                        )
					{
						if( bChkHeaderFooter &&
                            (FLY_AT_PARA == rAnchor.GetAnchorId()) &&
							RES_DRAWFRMFMT == pFrmFmt->Which() )
						{
                            // DrawObjecte in Kopf-/Fusszeilen ist nicht
							// erlaubt!
							pFrmFmt->DelFrms();
							pDoc->DelFrmFmt( pFrmFmt );
							--n;
						}
						else
						{
							if( bSaveUndo )
							{
								pDoc->SetRedlineMode_intern( eOld );
                                // UGLY: temp. enable undo
                                pDoc->GetIDocumentUndoRedo().DoUndo(true);
                                pDoc->GetIDocumentUndoRedo().AppendUndo(
                                    new SwUndoInsLayFmt( pFrmFmt,0,0 ) );
                                pDoc->GetIDocumentUndoRedo().DoUndo(false);
								pDoc->SetRedlineMode_intern( nsRedlineMode_t::REDLINE_IGNORE );
							}
							if( pFrmFmt->GetDepends() )
							{
								// beim Insert legen Draw-Objecte einen Frame an
								// also weg damit.
								pFrmFmt->DelFrms();
							}

                            if (FLY_AT_PAGE == rAnchor.GetAnchorId())
                            {
								if( !rAnchor.GetCntntAnchor() )
                                {
									pFrmFmt->MakeFrms();
                                }
								else if( pCrsr )
                                {
									pDoc->SetContainsAtPageObjWithContentAnchor( true );
                                }
							}
							else
								pFrmFmt->MakeFrms();
						}
					}
				}
			}
			if( aFlyFrmArr.Count() )
				aFlyFrmArr.Remove( 0, aFlyFrmArr.Count() );

			pDoc->SetRedlineMode_intern( eOld );
			if( pDoc->IsRedlineOn() )
				pDoc->AppendRedline( new SwRedline( nsRedlineType_t::REDLINE_INSERT, *pUndoPam ), true);
			else
				pDoc->SplitRedline( *pUndoPam );
			pDoc->SetRedlineMode_intern( nsRedlineMode_t::REDLINE_IGNORE );
		}
		if( bSaveUndo )
		{
			pDoc->SetRedlineMode_intern( eOld );
			pUndo->SetInsertRange( *pUndoPam, sal_False );
            // UGLY: temp. enable undo
            pDoc->GetIDocumentUndoRedo().DoUndo(true);
            pDoc->GetIDocumentUndoRedo().AppendUndo( pUndo );
            pDoc->GetIDocumentUndoRedo().DoUndo(false);
			pDoc->SetRedlineMode_intern( nsRedlineMode_t::REDLINE_IGNORE );
		}

		delete pUndoPam;

		pPam = (SwPaM *) pPam->GetNext();
		if( pPam == pEnd )
			break;

		// only read templates? then ignore multi selection! Bug 68593
		if( bFmtsOnly )
			break;

		/*
		 * !!! man muss selbst den Status vom Stream zuruecksetzen. !!!
		 *	   Beim seekg wird der akt. Status, eof- und bad-Bit
		 *	   gesetzt, warum weiss keiner
		 */
		if( pStrm )
		{
			pStrm->Seek(0);
			pStrm->ResetError();
		}
	}

    pDoc->SetInReading( false );
    pDoc->SetInXMLImport( false );

    pDoc->InvalidateNumRules();
    pDoc->UpdateNumRule();
    pDoc->ChkCondColls();
	pDoc->SetAllUniqueFlyNames();
    pDoc->SetLoaded( true );

    pDoc->GetIDocumentUndoRedo().DoUndo(bDocUndo);
    if (!bReadPageDescs)
    {
		if( bSaveUndo )
		{
			pDoc->SetRedlineMode_intern( eOld );
            pDoc->GetIDocumentUndoRedo().EndUndo( UNDO_INSDOKUMENT, NULL );
			pDoc->SetRedlineMode_intern( nsRedlineMode_t::REDLINE_IGNORE );
		}
	}

	// Wenn der Pam nur fuers Lesen konstruiert wurde, jetzt zerstoeren.
	if( !pCrsr )
	{
		delete pPam;		  // ein neues aufgemacht.

        // --> FME 2005-02-25 #i42634# Moved common code of SwReader::Read() and
        // SwDocShell::UpdateLinks() to new SwDoc::UpdateLinks():
	// ATM still with Update
        pDoc->UpdateLinks( sal_True );
        // <--

        // not insert: set the redline mode read from settings.xml
        eOld = static_cast<RedlineMode_t>(
                ePostReadRedlineMode & ~nsRedlineMode_t::REDLINE_IGNORE);

		pDoc->SetFieldsDirty(false, NULL, 0);
	}

	pDoc->SetRedlineMode_intern( eOld );
	pDoc->SetOle2Link( aOLELink );

	if( pCrsr )					// das Doc ist jetzt modifiziert
		pDoc->SetModified();
    // --> OD 2005-02-11 #i38810# - If links have been updated, the document
    // have to be modified. During update of links the OLE link at the document
    // isn't set. Thus, the document's modified state has to be set again after
    // the OLE link is restored - see above <pDoc->SetOle2Link( aOLELink )>.
    if ( pDoc->LinksUpdated() )
    {
        pDoc->SetModified();
    }
    // <--

//  if( po == ReadSw3 )         // am Sw3-Reader noch den pIo-Pointer "loeschen"
//      ((Sw3Reader*)po)->SetSw3Io( 0 );

	po->SetReadUTF8( sal_False );
	po->SetBlockMode( sal_False );
	po->SetOrganizerMode( sal_False );
    po->SetIgnoreHTMLComments( sal_False );

	return nError;
}


/*
 * Konstruktoren, Destruktor
 */

// Initiales Einlesben

                                       /*
SwReader::SwReader(SvStorage& rStg, const String& rFileName, SwDoc *pDoc)
	: SwDocFac(pDoc), pStrm(0), pStg(&rStg), pMedium(0), pCrsr(0),
	aFileName(rFileName)
{
}

SwReader::SwReader(const uno::Reference < embed::XStorage >& rStg, const String& rFileName, SwDoc *pDoc)
    : SwDocFac(pDoc), pStrm(0), pMedium(0), pCrsr(0), xStg( rStg ), aFileName(rFileName)
{
}
                                         */
SwReader::SwReader(SfxMedium& rMedium, const String& rFileName, SwDoc *pDocument)
    : SwDocFac(pDocument), pStrm(0), pMedium(&rMedium), pCrsr(0),
	aFileName(rFileName)
{
    SetBaseURL( rMedium.GetBaseURL() );
}

// In ein existierendes Dokument einlesen

SwReader::SwReader(SvStream& rStrm, const String& rFileName, const String& rBaseURL, SwPaM& rPam)
    : SwDocFac(rPam.GetDoc()), pStrm(&rStrm), pMedium(0), pCrsr(&rPam),
	aFileName(rFileName)
{
    SetBaseURL( rBaseURL );
}
/*
SwReader::SwReader(SvStorage& rStg, const String& rFileName, SwPaM& rPam)
	: SwDocFac(rPam.GetDoc()), pStrm(0), pStg(&rStg), pMedium(0), pCrsr(&rPam),
	aFileName(rFileName)
{
}
*/
SwReader::SwReader(SfxMedium& rMedium, const String& rFileName, SwPaM& rPam)
    : SwDocFac(rPam.GetDoc()), pStrm(0), pMedium(&rMedium),
	pCrsr(&rPam), aFileName(rFileName)
{
    SetBaseURL( rMedium.GetBaseURL() );
}

SwReader::SwReader( const uno::Reference < embed::XStorage > &rStg, const String& rFilename, SwPaM &rPam )
	: SwDocFac(rPam.GetDoc()), pStrm(0), xStg( rStg ), pMedium(0), pCrsr(&rPam), aFileName(rFilename)
{
}

Reader::Reader()
    : pTemplate(0), pStrm(0), pMedium(0), bInsertMode(0),
	bTmplBrowseMode(0), bReadUTF8(0), bBlockMode(0), bOrganizerMode(0),
    bHasAskTemplateName(0), bIgnoreHTMLComments(0)
{
}

Reader::~Reader()
{
	delete pTemplate;
}

String Reader::GetTemplateName() const
{
	return aEmptyStr;
}

// Die Filter-Vorlage laden, setzen und wieder freigeben
SwDoc* Reader::GetTemplateDoc()
{
	if( !bHasAskTemplateName )
	{
		SetTemplateName( GetTemplateName() );
		bHasAskTemplateName = sal_True;
	}

	if( !aTemplateNm.Len() )
		ClearTemplate();
	else
	{
        INetURLObject aTDir( aTemplateNm );
        String aFileName = aTDir.GetMainURL( INetURLObject::NO_DECODE );
        DBG_ASSERT( !aTDir.HasError(), "No absolute path for template name!" );
		DateTime aCurrDateTime;
		sal_Bool bLoad = sal_False;

		// Wenn das Template schon mal geladen wurde, nur einmal pro
		// Minute nachschauen, ob es geaendert wurde.
		if( !pTemplate || aCurrDateTime >= aChkDateTime )
		{
			Date aTstDate;
			Time aTstTime;
			if( FStatHelper::GetModifiedDateTimeOfFile(
							aTDir.GetMainURL( INetURLObject::NO_DECODE ),
							&aTstDate, &aTstTime ) &&
				( !pTemplate || aDStamp != aTstDate || aTStamp != aTstTime ))
			{
				bLoad = sal_True;
				aDStamp = aTstDate;
				aTStamp = aTstTime;
			}

			// Erst in einer Minute wieder mal nachschauen, ob sich die
			// Vorlage geaendert hat.
			aChkDateTime = aCurrDateTime;
			aChkDateTime += Time( 0L, 1L );
		}

		if( bLoad )
		{
			ClearTemplate();
			ASSERT( !pTemplate, "Who holds the template doc?" );

				// #95605#: If the writer module is not installed,
				// we cannot create a SwDocShell. We could create a
				// SwWebDocShell however, because this exists always
				// for the help.
				SvtModuleOptions aModuleOptions;
				if( aModuleOptions.IsWriter() )
				{
					SwDocShell *pDocSh =
						new SwDocShell ( SFX_CREATE_MODE_INTERNAL );
                    SfxObjectShellLock xDocSh = pDocSh;
					if( pDocSh->DoInitNew( 0 ) )
					{
						pTemplate = pDocSh->GetDoc();
						pTemplate->SetOle2Link( Link() );
                        // always FALSE
                        pTemplate->GetIDocumentUndoRedo().DoUndo( false );
                        pTemplate->set(IDocumentSettingAccess::BROWSE_MODE, bTmplBrowseMode );
                        pTemplate->RemoveAllFmtLanguageDependencies();

						ReadXML->SetOrganizerMode( sal_True );
                        SfxMedium aMedium( aFileName, sal_False );
                        SwReader aRdr( aMedium, aEmptyStr, pTemplate );
						aRdr.Read( *ReadXML );
						ReadXML->SetOrganizerMode( sal_False );

						pTemplate->acquire();
					}
				}
		}

        ASSERT( !pTemplate || FStatHelper::IsDocument( aFileName ) ||
				aTemplateNm.EqualsAscii( "$$Dummy$$" ),
                "TemplatePtr but no template exist!" );
	}

	return pTemplate;
}

sal_Bool Reader::SetTemplate( SwDoc& rDoc )
{
	sal_Bool bRet = sal_False;

	GetTemplateDoc();
	if( pTemplate )
	{
		rDoc.RemoveAllFmtLanguageDependencies();
		rDoc.ReplaceStyles( *pTemplate );
		rDoc.SetFixFields(false, NULL);
		bRet = sal_True;
	}

	return bRet;
}

void Reader::ClearTemplate()
{
	if( pTemplate )
	{
		if( 0 == pTemplate->release() )
			delete pTemplate,
		pTemplate = 0;
	}
}

void Reader::SetTemplateName( const String& rDir )
{
	if( rDir.Len() && aTemplateNm != rDir )
	{
		ClearTemplate();
		aTemplateNm = rDir;
	}
}

void Reader::MakeHTMLDummyTemplateDoc()
{
	ClearTemplate();
	pTemplate = new SwDoc;
	pTemplate->acquire();
    pTemplate->set(IDocumentSettingAccess::BROWSE_MODE, bTmplBrowseMode );
    pTemplate->getPrinter( true );
    pTemplate->RemoveAllFmtLanguageDependencies();
	aChkDateTime = Date( 1, 1, 2300 );	// 2300. Jahrtausend sollte reichen
	aTemplateNm.AssignAscii( "$$Dummy$$" );
}

// alle die die Streams / Storages nicht geoeffnet brauchen,
// muessen die Methode ueberladen
int Reader::SetStrmStgPtr()
{
	ASSERT( pMedium, "Wo ist das Medium??" );

	if( pMedium->IsStorage() )
	{
		if( SW_STORAGE_READER & GetReaderType() )
		{
            xStg = pMedium->GetStorage();
			return sal_True;
		}
	}
    else
	{
		pStrm = pMedium->GetInStream();
        if ( pStrm && SotStorage::IsStorageFile(pStrm) && (SW_STORAGE_READER & GetReaderType()) )
        {
            pStg = new SotStorage( *pStrm );
            pStrm = NULL;
        }
        else if ( !(SW_STREAM_READER & GetReaderType()) )
        {
            pStrm = NULL;
            return sal_False;
        }

        return sal_True;
	}
	return sal_False;
}


int Reader::GetReaderType()
{
	return SW_STREAM_READER;
}


void Reader::SetFltName( const String& )
{
}


void Reader::SetNoOutlineNum( SwDoc& /*rDoc*/ )
{
	// JP 10.03.96: jetzt wieder keine Nummerierung in den Vorlagen
}


void Reader::ResetFrmFmtAttrs( SfxItemSet &rFrmSet )
{
    rFrmSet.Put( SvxLRSpaceItem(RES_LR_SPACE) );
    rFrmSet.Put( SvxULSpaceItem(RES_UL_SPACE) );
    rFrmSet.Put( SvxBoxItem(RES_BOX) );
}


void Reader::ResetFrmFmts( SwDoc& rDoc )
{
	for (sal_uInt16 i=0; i<3; ++i)
	{
		sal_uInt16 nPoolId;
		switch (i)
		{
			default:
				ASSERT(i == 0, "Impossible");
				//fallthrough
			case 0:
				nPoolId = RES_POOLFRM_FRAME;
				break;
			case 1:
				nPoolId = RES_POOLFRM_GRAPHIC;
				break;
			case 2:
				nPoolId = RES_POOLFRM_OLE;
				break;
		}

		SwFrmFmt *pFrmFmt = rDoc.GetFrmFmtFromPool( nPoolId );

        pFrmFmt->ResetFmtAttr( RES_LR_SPACE );
        pFrmFmt->ResetFmtAttr( RES_UL_SPACE );
        pFrmFmt->ResetFmtAttr( RES_BOX );
	}
}

	// read the sections of the document, which is equal to the medium.
	// returns the count of it
sal_uInt16 Reader::GetSectionList( SfxMedium&, SvStrings& ) const
{
	return 0;
}

// ------------------------------------------------
sal_Bool SwReader::HasGlossaries( const Reader& rOptions )
{
	// Variable uebertragen
	Reader* po = (Reader*) &rOptions;
	po->pStrm = pStrm;
	po->pStg  = pStg;
	po->bInsertMode = sal_False;

	// ist ein Medium angegeben, dann aus diesem die Streams besorgen
	sal_Bool bRet = sal_False;
	if( !( 0 != (po->pMedium = pMedium ) && !po->SetStrmStgPtr() ))
		bRet = po->HasGlossaries();
	return bRet;
}

sal_Bool SwReader::ReadGlossaries( const Reader& rOptions,
								SwTextBlocks& rBlocks, sal_Bool bSaveRelFiles )
{
	// Variable uebertragen
	Reader* po = (Reader*) &rOptions;
	po->pStrm = pStrm;
	po->pStg  = pStg;
	po->bInsertMode = sal_False;

	// ist ein Medium angegeben, dann aus diesem die Streams besorgen
	sal_Bool bRet = sal_False;
	if( !( 0 != (po->pMedium = pMedium ) && !po->SetStrmStgPtr() ))
		bRet = po->ReadGlossaries( rBlocks, bSaveRelFiles );
	return bRet;
}

sal_Bool Reader::HasGlossaries() const
{
	return sal_False;
}

sal_Bool Reader::ReadGlossaries( SwTextBlocks&, sal_Bool ) const
{
	return sal_False;
}

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

int StgReader::GetReaderType()
{
	return SW_STORAGE_READER;
}




/*
 * Writer
 */

/*
 * Konstruktoren, Destruktoren sind inline (inc/shellio.hxx).
 */

SwWriter::SwWriter(SvStream& rStrm, SwCrsrShell &rShell, sal_Bool bInWriteAll)
    : pStrm(&rStrm), pMedium(0), pOutPam(0), pShell(&rShell),
	rDoc(*rShell.GetDoc()), bWriteAll(bInWriteAll)
{
}

SwWriter::SwWriter(SvStream& rStrm,SwDoc &rDocument)
    : pStrm(&rStrm), pMedium(0), pOutPam(0), pShell(0), rDoc(rDocument),
	bWriteAll(true)
{
}

SwWriter::SwWriter(SvStream& rStrm, SwPaM& rPam, sal_Bool bInWriteAll)
    : pStrm(&rStrm), pMedium(0), pOutPam(&rPam), pShell(0),
	rDoc(*rPam.GetDoc()), bWriteAll(bInWriteAll)
{
}

SwWriter::SwWriter( const uno::Reference < embed::XStorage >& rStg, SwDoc &rDocument)
    : pStrm(0), xStg( rStg ), pMedium(0), pOutPam(0), pShell(0), rDoc(rDocument), bWriteAll(true)
{
}

SwWriter::SwWriter(SfxMedium& rMedium, SwCrsrShell &rShell, sal_Bool bInWriteAll)
    : pStrm(0), pMedium(&rMedium), pOutPam(0), pShell(&rShell),
	rDoc(*rShell.GetDoc()), bWriteAll(bInWriteAll)
{
}

SwWriter::SwWriter(SfxMedium& rMedium, SwDoc &rDocument)
    : pStrm(0), pMedium(&rMedium), pOutPam(0), pShell(0), rDoc(rDocument),
	bWriteAll(true)
{
}

sal_uLong SwWriter::Write( WriterRef& rxWriter, const String* pRealFileName )
{
    // --> OD 2007-03-30 #i73788#
    SwPauseThreadStarting aPauseThreadStarting;
    // <--

    sal_Bool bHasMark = sal_False;
	SwPaM * pPam;

	SwDoc *pDoc = 0;

	if ( pShell && !bWriteAll && pShell->IsTableMode() )
	{
		bWriteAll = sal_True;
		pDoc = new SwDoc;
		pDoc->acquire();

		// kopiere Teile aus einer Tabelle: lege eine Tabelle mit der Breite
		// von der Originalen an und kopiere die selectierten Boxen.
		// Die Groessen werden prozentual korrigiert.

		// lasse ueber das Layout die Boxen suchen
		SwSelBoxes aBoxes;
		GetTblSel( *pShell, aBoxes );
        SwTableNode* pTblNd = (SwTableNode*)aBoxes[0]->GetSttNd()->StartOfSectionNode();
		SwNodeIndex aIdx( pDoc->GetNodes().GetEndOfExtras(), 2 );
		SwCntntNode *pNd = aIdx.GetNode().GetCntntNode();
		ASSERT( pNd, "Node not found" );
		SwPosition aPos( aIdx, SwIndex( pNd ) );
		pTblNd->GetTable().MakeCopy( pDoc, aPos, aBoxes );
	}

	if( !bWriteAll && ( pShell || pOutPam ))
	{
		if( pShell )
			pPam = pShell->GetCrsr();
		else
			pPam = pOutPam;

		SwPaM *pEnd = pPam;

		// Erste Runde: Nachsehen, ob eine Selektion besteht.
		while(sal_True)
		{
			bHasMark = bHasMark || pPam->HasMark();
			pPam = (SwPaM *) pPam->GetNext();
			if(bHasMark || pPam == pEnd)
				break;
		}

		// Wenn keine Selektion besteht, eine ueber das ganze Dokument aufspannen.
		if(!bHasMark)
		{
			if( pShell )
			{
				pShell->Push();
				pShell->SttEndDoc(sal_True);
				pShell->SetMark();
				pShell->SttEndDoc(sal_False);
			}
			else
			{
				pPam = new SwPaM( *pPam );
				pPam->Move( fnMoveBackward, fnGoDoc );
				pPam->SetMark();
				pPam->Move( fnMoveForward, fnGoDoc );
			}
		}
		// pPam ist immer noch der akt. Cursor !!
	}
	else
	{
		// keine Shell oder alles schreiben -> eigenen Pam erzeugen
		SwDoc* pOutDoc = pDoc ? pDoc : &rDoc;
		pPam = new SwPaM( pOutDoc->GetNodes().GetEndOfContent() );
        if( pOutDoc->IsClipBoard() )
        {
            pPam->Move( fnMoveBackward, fnGoDoc );
            pPam->SetMark();
            pPam->Move( fnMoveForward, fnGoDoc );
        }
        else
        {
            pPam->SetMark();
            pPam->Move( fnMoveBackward, fnGoDoc );
        }
	}

	rxWriter->bWriteAll = bWriteAll;
	SwDoc* pOutDoc = pDoc ? pDoc : &rDoc;

	// falls der Standart PageDesc. immer noch auf initalen Werten steht
	// (wenn z.B. kein Drucker gesetzt wurde) dann setze jetzt auf DIN A4
    // --> OD 2004-11-17 #i37248# - Modifications are only allowed at a new document.
    // <pOutDoc> contains a new document, if <pDoc> is set - see above.
    if ( pDoc && !pOutDoc->getPrinter( false ) )
    // <--
	{
		const SwPageDesc& rPgDsc = const_cast<const SwDoc *>(pOutDoc)->GetPageDesc( 0 );
		//const SwPageDesc& rPgDsc = *pOutDoc->GetPageDescFromPool( RES_POOLPAGE_STANDARD );;
		const SwFmtFrmSize& rSz = rPgDsc.GetMaster().GetFrmSize();
		// Clipboard-Dokument wird immer ohne Drucker angelegt, so ist
		// der Std.PageDesc immer aug LONG_MAX !! Mappe dann auf DIN A4
		if( LONG_MAX == rSz.GetHeight() || LONG_MAX == rSz.GetWidth() )
		{
			SwPageDesc aNew( rPgDsc );
			SwFmtFrmSize aNewSz( rSz );
			Size a4(SvxPaperInfo::GetPaperSize( PAPER_A4 ));
			aNewSz.SetHeight( a4.Width() );
			aNewSz.SetWidth( a4.Height() );
			aNew.GetMaster().SetFmtAttr( aNewSz );
			pOutDoc->ChgPageDesc( 0, aNew );
		}
	}

    sal_Bool bLockedView(sal_False);
	SwEditShell* pESh = pOutDoc->GetEditShell();
	if( pESh )
    {
        bLockedView = pESh->IsViewLocked();
        pESh->LockView( sal_True );    //lock visible section
		pESh->StartAllAction();
    }

	sal_Bool bWasPurgeOle = pOutDoc->get(IDocumentSettingAccess::PURGE_OLE);
	pOutDoc->set(IDocumentSettingAccess::PURGE_OLE, false);

	sal_uLong nError = 0;
	if( pMedium )
		nError = rxWriter->Write( *pPam, *pMedium, pRealFileName );
	else if( pStg )
		nError = rxWriter->Write( *pPam, *pStg, pRealFileName );
	else if( pStrm )
		nError = rxWriter->Write( *pPam, *pStrm, pRealFileName );
    else if( xStg.is() )
        nError = rxWriter->Write( *pPam, xStg, pRealFileName );

	pOutDoc->set(IDocumentSettingAccess::PURGE_OLE, bWasPurgeOle );

	if( pESh )
    {
		pESh->EndAllAction();
        pESh->LockView( bLockedView );
    }

	// Falls nur zum Schreiben eine Selektion aufgespannt wurde, vor der
	// Rueckkehr den alten Crsr wieder herstellen.
	if( !bWriteAll && ( pShell || pOutPam ))
	{
		if(!bHasMark)
		{
			if( pShell )
				pShell->Pop( sal_False );
			else
				delete pPam;
		}
	}
	else
	{
		delete pPam;			// loesche den hier erzeugten Pam
		// Alles erfolgreich geschrieben? Sag' das dem Dokument!
        if ( !IsError( nError ) && !pDoc )
        {
			rDoc.ResetModified();
            // --> OD 2005-02-11 #i38810# - reset also flag, that indicates
            // updated links
            rDoc.SetLinksUpdated( sal_False );
            // <-
        }
	}

	if ( pDoc )
	{
        if ( !pDoc->release() )
			delete pDoc;
		bWriteAll = sal_False;
	}

	return nError;
}


/*  */

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


sal_Bool SetHTMLTemplate( SwDoc & rDoc )
{
	// Vorlagennamen von den Sfx-HTML-Filter besorgen!!!
	if( !ReadHTML->GetTemplateDoc() )
		ReadHTML->MakeHTMLDummyTemplateDoc();

	sal_Bool bRet = ReadHTML->SetTemplate( rDoc );

	SwNodes& rNds = rDoc.GetNodes();
	SwNodeIndex aIdx( rNds.GetEndOfExtras(), 1 );
	SwCntntNode* pCNd = rNds.GoNext( &aIdx );
	if( pCNd )
	{
		pCNd->SetAttr
            ( SwFmtPageDesc(rDoc.GetPageDescFromPool(RES_POOLPAGE_HTML, false) ) );
        pCNd->ChgFmtColl( rDoc.GetTxtCollFromPool( RES_POOLCOLL_TEXT, false ));
	}

	return bRet;
}