xref: /aoo41x/main/sw/source/filter/xml/xmltexti.cxx (revision efeef26f)

/**************************************************************
 *
 * 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 <comphelper/storagehelper.hxx>
#include <comphelper/processfactory.hxx>
#include <com/sun/star/embed/EmbedStates.hpp>
#include <com/sun/star/embed/XEmbedObjectCreator.hpp>
#include <com/sun/star/embed/XLinkCreator.hpp>
#include <com/sun/star/embed/XEmbeddedObject.hpp>
#include <com/sun/star/embed/XVisualObject.hpp>
#include <com/sun/star/embed/Aspects.hpp>
#include <com/sun/star/task/XInteractionHandler.hpp>
#include <rtl/ustrbuf.hxx>
#include <sot/clsids.hxx>
#include <com/sun/star/lang/XUnoTunnel.hpp>
#include <xmloff/prstylei.hxx>
#include <xmloff/maptype.hxx>
#include <xmloff/xmlprmap.hxx>
#include <xmloff/txtprmap.hxx>
#include <xmloff/i18nmap.hxx>
#include "unocrsr.hxx"
#include "TextCursorHelper.hxx"
#include "unoframe.hxx"
#include "doc.hxx"
#include "unocoll.hxx"
#include <fmtfsize.hxx>
#include <fmtanchr.hxx>
#include <fmtcntnt.hxx>
#include "xmlimp.hxx"
#include "xmltbli.hxx"
#include "xmltexti.hxx"
#include "XMLRedlineImportHelper.hxx"
#include <xmloff/XMLFilterServiceNames.h>
#include <SwAppletImpl.hxx>
#include <ndole.hxx>
#include <docsh.hxx>
#include <sfx2/docfile.hxx>
#include <switerator.hxx>

// for locking SolarMutex: svapp + mutex
#include <vcl/svapp.hxx>
#include <vos/mutex.hxx>

#include <toolkit/helper/vclunohelper.hxx>
#include <svtools/embedhlp.hxx>
#include <svl/urihelper.hxx>


using ::rtl::OUString;
using ::rtl::OUStringBuffer;
using namespace ::com::sun::star;
using namespace ::com::sun::star::uno;
using namespace ::com::sun::star::lang;
using namespace ::com::sun::star::text;
using namespace ::com::sun::star::frame;
using namespace ::com::sun::star::beans;
using namespace xml::sax;


struct XMLServiceMapEntry_Impl
{
	const sal_Char *sFilterService;
	sal_Int32	   nFilterServiceLen;

	sal_uInt32	n1;
	sal_uInt16	n2, n3;
	sal_uInt8	n4, n5, n6, n7, n8, n9, n10, n11;
};

#define SERVICE_MAP_ENTRY( app, s ) \
	{ XML_IMPORT_FILTER_##app, sizeof(XML_IMPORT_FILTER_##app)-1, \
      SO3_##s##_CLASSID	}

const XMLServiceMapEntry_Impl aServiceMap[] =
{
	SERVICE_MAP_ENTRY( WRITER, SW ),
	SERVICE_MAP_ENTRY( CALC, SC ),
	SERVICE_MAP_ENTRY( DRAW, SDRAW ),
	SERVICE_MAP_ENTRY( IMPRESS, SIMPRESS ),
	SERVICE_MAP_ENTRY( CHART, SCH ),
	SERVICE_MAP_ENTRY( MATH, SM ),
	{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
};
static void lcl_putHeightAndWidth ( SfxItemSet &rItemSet,
		sal_Int32 nHeight, sal_Int32 nWidth,
		long *pTwipHeight=0, long *pTwipWidth=0 )
{
	if( nWidth > 0 && nHeight > 0 )
	{
		nWidth = MM100_TO_TWIP( nWidth );
		if( nWidth < MINFLY )
			nWidth = MINFLY;
		nHeight = MM100_TO_TWIP( nHeight );
		if( nHeight < MINFLY )
			nHeight = MINFLY;
		rItemSet.Put( SwFmtFrmSize( ATT_FIX_SIZE, nWidth, nHeight ) );
	}

    SwFmtAnchor aAnchor( FLY_AT_CHAR );
	rItemSet.Put( aAnchor );

	if( pTwipWidth )
		*pTwipWidth = nWidth;
	if( pTwipHeight )
		*pTwipHeight = nHeight;
}

static void lcl_setObjectVisualArea( const uno::Reference< embed::XEmbeddedObject >& xObj,
									sal_Int64 nAspect,
									const Size& aVisSize,
									const MapUnit& aUnit )
{
	if( xObj.is() && nAspect != embed::Aspects::MSOLE_ICON )
	{
		// convert the visual area to the objects units
		MapUnit aObjUnit = VCLUnoHelper::UnoEmbed2VCLMapUnit( xObj->getMapUnit( nAspect ) );
		Size aObjVisSize = OutputDevice::LogicToLogic( aVisSize, aUnit, aObjUnit );
		awt::Size aSz;
		aSz.Width = aObjVisSize.Width();
		aSz.Height = aObjVisSize.Height();

		try
		{
			xObj->setVisualAreaSize( nAspect, aSz );
		}
		catch( uno::Exception& )
		{
			OSL_ASSERT( "Couldn't set visual area of the object!\n" );
		}
	}
}

SwXMLTextImportHelper::SwXMLTextImportHelper(
		const uno::Reference < XModel>& rModel,
        SvXMLImport& rImport,
        const uno::Reference<XPropertySet> & rInfoSet,
		sal_Bool bInsertM, sal_Bool bStylesOnlyM, sal_Bool _bProgress,
		sal_Bool bBlockM, sal_Bool bOrganizerM,
		sal_Bool /*bPreserveRedlineMode*/ ) :
	XMLTextImportHelper( rModel, rImport, bInsertM, bStylesOnlyM, _bProgress,
                         bBlockM, bOrganizerM ),
	pRedlineHelper( NULL )
{
	uno::Reference<XPropertySet> xDocPropSet( rModel, UNO_QUERY );
	pRedlineHelper = new XMLRedlineImportHelper(
		bInsertM || bBlockM, xDocPropSet, rInfoSet );
}

SwXMLTextImportHelper::~SwXMLTextImportHelper()
{
    // #90463# the redline helper destructor sets properties on the document
    //         and may through an exception while doing so... catch this
    try
    {
        delete pRedlineHelper;
    }
    catch ( const RuntimeException& )
    {
        // ignore
    }
}

SvXMLImportContext *SwXMLTextImportHelper::CreateTableChildContext(
				SvXMLImport& rImport,
				sal_uInt16 nPrefix, const OUString& rLocalName,
				const uno::Reference< XAttributeList > & xAttrList )
{
	return new SwXMLTableContext(
				(SwXMLImport&)rImport, nPrefix, rLocalName, xAttrList );
}

sal_Bool SwXMLTextImportHelper::IsInHeaderFooter() const
{
	uno::Reference<XUnoTunnel> xCrsrTunnel(
			((SwXMLTextImportHelper *)this)->GetCursor(), UNO_QUERY );
	ASSERT( xCrsrTunnel.is(), "missing XUnoTunnel for Cursor" );
	OTextCursorHelper *pTxtCrsr = reinterpret_cast< OTextCursorHelper * >(
				sal::static_int_cast< sal_IntPtr >( xCrsrTunnel->getSomething( OTextCursorHelper::getUnoTunnelId() )));
	ASSERT( pTxtCrsr, "SwXTextCursor missing" );
	SwDoc *pDoc = pTxtCrsr->GetDoc();

	return pDoc && pDoc->IsInHeaderFooter( pTxtCrsr->GetPaM()->GetPoint()->nNode );
}

SwOLENode *lcl_GetOLENode( const SwFrmFmt *pFrmFmt )
{
	SwOLENode *pOLENd = 0;
	if( pFrmFmt )
	{
		const SwFmtCntnt& rCntnt = pFrmFmt->GetCntnt();
		const SwNodeIndex *pNdIdx = rCntnt.GetCntntIdx();
		pOLENd = pNdIdx->GetNodes()[pNdIdx->GetIndex() + 1]->GetOLENode();
	}
	ASSERT( pOLENd, "Where is the OLE node" );
	return pOLENd;
}

uno::Reference< XPropertySet > SwXMLTextImportHelper::createAndInsertOLEObject(
        SvXMLImport& rImport,
		const OUString& rHRef,
		const OUString& rStyleName,
		const OUString& rTblName,
		sal_Int32 nWidth, sal_Int32 nHeight )
{
    // this method will modify the document directly -> lock SolarMutex
	vos::OGuard aGuard(Application::GetSolarMutex());

	uno::Reference < XPropertySet > xPropSet;

	sal_Int32 nPos = rHRef.indexOf( ':' );
	if( -1 == nPos )
		return xPropSet;

	OUString aObjName( rHRef.copy( nPos+1) );

	if( !aObjName.getLength() )
		return xPropSet;

	uno::Reference<XUnoTunnel> xCrsrTunnel( GetCursor(), UNO_QUERY );
	ASSERT( xCrsrTunnel.is(), "missing XUnoTunnel for Cursor" );
	OTextCursorHelper *pTxtCrsr = reinterpret_cast< OTextCursorHelper * >(
				sal::static_int_cast< sal_IntPtr >( xCrsrTunnel->getSomething( OTextCursorHelper::getUnoTunnelId() )));
	ASSERT( pTxtCrsr, "SwXTextCursor missing" );
	SwDoc *pDoc = SwImport::GetDocFromXMLImport( rImport );

	SfxItemSet aItemSet( pDoc->GetAttrPool(), RES_FRMATR_BEGIN,
						 RES_FRMATR_END );
	Size aTwipSize( 0, 0 );
	Rectangle aVisArea( 0, 0, nWidth, nHeight );
    lcl_putHeightAndWidth( aItemSet, nHeight, nWidth,
						   &aTwipSize.Height(), &aTwipSize.Width() );

	SwFrmFmt *pFrmFmt = 0;
	SwOLENode *pOLENd = 0;
	if( rHRef.copy( 0, nPos ).equalsAsciiL( RTL_CONSTASCII_STRINGPARAM("vnd.sun.star.ServiceName") ) )
	{
		sal_Bool bInsert = sal_False;
		SvGlobalName aClassName;
		const XMLServiceMapEntry_Impl *pEntry = aServiceMap;
		while( pEntry->sFilterService )
		{
			if( aObjName.equalsAsciiL( pEntry->sFilterService,
									 pEntry->nFilterServiceLen ) )
			{
				aClassName = SvGlobalName( pEntry->n1, pEntry->n2,
										   pEntry->n3, pEntry->n4,
										   pEntry->n5, pEntry->n6,
										   pEntry->n7, pEntry->n8,
										   pEntry->n9, pEntry->n10,
										   pEntry->n11  );
				bInsert = sal_True;
				break;
			}
			pEntry++;
		}

		if( bInsert )
		{
            uno::Reference < embed::XStorage > xStorage = comphelper::OStorageHelper::GetTemporaryStorage();
            try
            {
                // create object with desired ClassId
                sal_Int64 nAspect = embed::Aspects::MSOLE_CONTENT;
                ::rtl::OUString aName = ::rtl::OUString::createFromAscii( "DummyName" );
                uno::Sequence < sal_Int8 > aClass( aClassName.GetByteSequence() );
                uno::Reference < embed::XEmbedObjectCreator > xFactory( ::comphelper::getProcessServiceFactory()->createInstance(
                        ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.embed.EmbeddedObjectCreator")) ), uno::UNO_QUERY );
                uno::Reference < embed::XEmbeddedObject > xObj =
                    uno::Reference < embed::XEmbeddedObject >( xFactory->createInstanceInitNew(
                    aClass, ::rtl::OUString(), xStorage, aName,
                    uno::Sequence < beans::PropertyValue >() ), uno::UNO_QUERY );
                if ( xObj.is() )
                {
                    //TODO/LATER: is it enough to only set the VisAreaSize?
					lcl_setObjectVisualArea( xObj, nAspect, aTwipSize, MAP_TWIP );
                }

                pFrmFmt = pDoc->Insert( *pTxtCrsr->GetPaM(),
										::svt::EmbeddedObjectRef( xObj, embed::Aspects::MSOLE_CONTENT ),
										&aItemSet,
										NULL,
										NULL );
                pOLENd = lcl_GetOLENode( pFrmFmt );
                if( pOLENd )
                    aObjName = pOLENd->GetOLEObj().GetCurrentPersistName();
            }
            catch ( uno::Exception& )
            {
            }
		}
	}
	else
	{
		// check whether an object with this name already exists in the document
		String aName;
		SwIterator<SwCntntNode,SwFmtColl> aIter( *pDoc->GetDfltGrfFmtColl() );
		for( SwCntntNode* pNd = aIter.First(); pNd; pNd = aIter.Next() )
		{
			SwOLENode* pExistingOLENd = pNd->GetOLENode();
			if( pExistingOLENd )
			{
            	::rtl::OUString aExistingName = pExistingOLENd->GetOLEObj().GetCurrentPersistName();
				if ( aExistingName.equals( aObjName ) )
				{
					OSL_ENSURE( sal_False, "The document contains duplicate object references, means it is partially broken, please let developers know how this document was generated!\n" );

					::rtl::OUString aTmpName = pDoc->GetPersist()->GetEmbeddedObjectContainer().CreateUniqueObjectName();
					try
					{
						pDoc->GetPersist()->GetStorage()->copyElementTo( aObjName,
																		 pDoc->GetPersist()->GetStorage(),
																		 aTmpName );
						aName = aTmpName;
					}
					catch ( uno::Exception& )
					{
						OSL_ENSURE( sal_False, "Couldn't create a copy of the object!\n" );
					}

					break;
				}
			}
    	}

		if ( !aName.Len() )
			aName = aObjName;

		// the correct aspect will be set later
		// TODO/LATER: Actually it should be set here
        if( pTxtCrsr )
        {
            pFrmFmt = pDoc->InsertOLE( *pTxtCrsr->GetPaM(), aName, embed::Aspects::MSOLE_CONTENT, &aItemSet, NULL, NULL );
            pOLENd = lcl_GetOLENode( pFrmFmt );
        }
		aObjName = aName;
	}

	if( !pFrmFmt )
		return xPropSet;

	if( IsInsertMode() )
	{
		if( !pOLENd )
			pOLENd = lcl_GetOLENode( pFrmFmt );
		if( pOLENd )
			pOLENd->SetOLESizeInvalid( sal_True );
	}

	SwXFrame *pXFrame = SwXFrames::GetObject( *pFrmFmt, FLYCNTTYPE_OLE );
	xPropSet = pXFrame;
	if( pDoc->GetDrawModel() )
		SwXFrame::GetOrCreateSdrObject(
				static_cast<SwFlyFrmFmt*>( pXFrame->GetFrmFmt() ) ); // req for z-order
	if( rTblName.getLength() )
	{
		const SwFmtCntnt& rCntnt = pFrmFmt->GetCntnt();
		const SwNodeIndex *pNdIdx = rCntnt.GetCntntIdx();
		SwOLENode *pOLENode = pNdIdx->GetNodes()[pNdIdx->GetIndex() + 1]->GetOLENode();
		ASSERT( pOLENode, "Where is the OLE node" );

		OUStringBuffer aBuffer( rTblName.getLength() );
		sal_Bool bQuoted = sal_False;
		sal_Bool bEscape = sal_False;
		sal_Bool bError = sal_False;
		for( sal_Int32 i=0; i < rTblName.getLength(); i++ )
		{
			sal_Bool bEndOfNameFound = sal_False;
			sal_Unicode c = rTblName[i];
			switch( c )
			{
			case '\'':
				if( bEscape )
				{
					aBuffer.append( c );
					bEscape = sal_False;
				}
				else if( bQuoted )
				{
					bEndOfNameFound = sal_True;
				}
				else if( 0 == i )
				{
					bQuoted = sal_True;
				}
				else
				{
					bError = sal_True;
				}
				break;
			case '\\':
				if( bEscape )
				{
					aBuffer.append( c );
					bEscape = sal_False;
				}
				else
				{
					bEscape = sal_True;
				}
				break;
			case ' ':
			case '.':
				if( !bQuoted )
				{
					bEndOfNameFound = sal_True;
				}
				else
				{
					aBuffer.append( c );
					bEscape = sal_False;
				}
				break;
			default:
				{
					aBuffer.append( c );
					bEscape = sal_False;
				}
				break;
			}
			if( bError || bEndOfNameFound )
				break;
		}
		if( !bError )
		{
			OUString sTblName( aBuffer.makeStringAndClear() );
			pOLENode->SetChartTblName( GetRenameMap().Get( XML_TEXT_RENAME_TYPE_TABLE, sTblName ) );
		}
	}

	sal_Int64 nDrawAspect = 0;
	const XMLPropStyleContext *pStyle = 0;
	sal_Bool bHasSizeProps = sal_False;
	if( rStyleName.getLength() )
	{
		pStyle = FindAutoFrameStyle( rStyleName );
		if( pStyle )
		{
			UniReference < SvXMLImportPropertyMapper > xImpPrMap =
				pStyle->GetStyles()
					  ->GetImportPropertyMapper(pStyle->GetFamily());
			ASSERT( xImpPrMap.is(), "Where is the import prop mapper?" );
			if( xImpPrMap.is() )
			{
				UniReference<XMLPropertySetMapper> rPropMapper =
				xImpPrMap->getPropertySetMapper();

				sal_Int32 nCount = pStyle->GetProperties().size();
				for( sal_Int32 i=0; i < nCount; i++ )
				{
					const XMLPropertyState& rProp = pStyle->GetProperties()[i];
					sal_Int32 nIdx = rProp.mnIndex;
					if( -1 == nIdx )
						continue;

					switch( rPropMapper->GetEntryContextId(nIdx) )
					{
					case CTF_OLE_VIS_AREA_LEFT:
						{
							sal_Int32 nVal = 0;
							rProp.maValue >>= nVal;
							aVisArea.setX( nVal );
						}
						break;
					case CTF_OLE_VIS_AREA_TOP:
						{
							sal_Int32 nVal = 0;
							rProp.maValue >>= nVal;
							aVisArea.setY( nVal );
						}
						break;
					case CTF_OLE_VIS_AREA_WIDTH:
						{
							sal_Int32 nVal = 0;
							rProp.maValue >>= nVal;
							aVisArea.setWidth( nVal );
							bHasSizeProps = sal_True;
						}
						break;
					case CTF_OLE_VIS_AREA_HEIGHT:
						{
							sal_Int32 nVal = 0;
							rProp.maValue >>= nVal;
							aVisArea.setHeight( nVal );
							bHasSizeProps = sal_True;
						}
						break;
					case CTF_OLE_DRAW_ASPECT:
						{
							rProp.maValue >>= nDrawAspect;

							if ( !nDrawAspect )
								nDrawAspect = embed::Aspects::MSOLE_CONTENT;

							if ( pOLENd )
								pOLENd->GetOLEObj().GetObject().SetViewAspect( nDrawAspect );
						}
						break;
					}
				}
			}
		}
	}

	if ( bHasSizeProps )
	{
    	uno::Reference < embed::XEmbeddedObject > xObj =
					pDoc->GetPersist()->GetEmbeddedObjectContainer().GetEmbeddedObject( aObjName );
    	if( xObj.is() )
			lcl_setObjectVisualArea( xObj, ( nDrawAspect ? nDrawAspect : embed::Aspects::MSOLE_CONTENT ),
								 	aVisArea.GetSize(), MAP_100TH_MM );
	}

	return xPropSet;
}

uno::Reference< XPropertySet > SwXMLTextImportHelper::createAndInsertOOoLink(
        SvXMLImport& rImport,
		const OUString& rHRef,
		const OUString& /*rStyleName*/,
		const OUString& /*rTblName*/,
		sal_Int32 nWidth, sal_Int32 nHeight )
{
    // this method will modify the document directly -> lock SolarMutex
	vos::OGuard aGuard(Application::GetSolarMutex());

	uno::Reference < XPropertySet > xPropSet;

	uno::Reference<XUnoTunnel> xCrsrTunnel( GetCursor(), UNO_QUERY );
	ASSERT( xCrsrTunnel.is(), "missing XUnoTunnel for Cursor" );
	OTextCursorHelper *pTxtCrsr = reinterpret_cast< OTextCursorHelper * >(
				sal::static_int_cast< sal_IntPtr >( xCrsrTunnel->getSomething( OTextCursorHelper::getUnoTunnelId() )));
	ASSERT( pTxtCrsr, "SwXTextCursor missing" );
	SwDoc *pDoc = SwImport::GetDocFromXMLImport( rImport );

	SfxItemSet aItemSet( pDoc->GetAttrPool(), RES_FRMATR_BEGIN,
						 RES_FRMATR_END );
	Size aTwipSize( 0, 0 );
	Rectangle aVisArea( 0, 0, nWidth, nHeight );
    lcl_putHeightAndWidth( aItemSet, nHeight, nWidth,
						   &aTwipSize.Height(), &aTwipSize.Width() );

    // We'll need a (valid) URL. If we don't have do not insert the link and return early.
	// Copy URL into URL oject on the way.
   	INetURLObject aURLObj;
    bool bValidURL = rHRef.getLength() != 0 &&
                     aURLObj.SetURL( URIHelper::SmartRel2Abs(
                                INetURLObject( GetXMLImport().GetBaseURL() ), rHRef ) );
    if( !bValidURL )
		return xPropSet;

    uno::Reference < embed::XStorage > xStorage = comphelper::OStorageHelper::GetTemporaryStorage();
    try
    {
        // create object with desired ClassId
        ::rtl::OUString aName = ::rtl::OUString::createFromAscii( "DummyName" );
        uno::Reference < embed::XLinkCreator > xFactory( ::comphelper::getProcessServiceFactory()->createInstance(
                ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.embed.OOoEmbeddedObjectFactory")) ),
				uno::UNO_QUERY_THROW );

		uno::Sequence< beans::PropertyValue > aMediaDescriptor( 1 );
		aMediaDescriptor[0].Name = ::rtl::OUString::createFromAscii( "URL" );
		aMediaDescriptor[0].Value <<= ::rtl::OUString( aURLObj.GetMainURL( INetURLObject::NO_DECODE ) );
		if ( pDoc && pDoc->GetDocShell() && pDoc->GetDocShell()->GetMedium() )
		{
			uno::Reference< task::XInteractionHandler > xInteraction =
										pDoc->GetDocShell()->GetMedium()->GetInteractionHandler();
			if ( xInteraction.is() )
			{
				aMediaDescriptor.realloc( 2 );
				aMediaDescriptor[1].Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "InteractionHandler" ) );
				aMediaDescriptor[1].Value <<= xInteraction;
			}
		}

        uno::Reference < embed::XEmbeddedObject > xObj(
			xFactory->createInstanceLink(
				xStorage, aName, aMediaDescriptor, uno::Sequence< beans::PropertyValue >() ),
			uno::UNO_QUERY_THROW );

        {
            SwFrmFmt *pFrmFmt = pDoc->Insert( *pTxtCrsr->GetPaM(),
											::svt::EmbeddedObjectRef( xObj, embed::Aspects::MSOLE_CONTENT ),
                                            &aItemSet,
											NULL,
											NULL );

            // TODO/LATER: in future may need a way to set replacement image url to the link ( may be even to the object ), needs oasis cws???

            SwXFrame *pXFrame = SwXFrames::GetObject( *pFrmFmt, FLYCNTTYPE_OLE );
            xPropSet = pXFrame;
            if( pDoc->GetDrawModel() )
                SwXFrame::GetOrCreateSdrObject(
                        static_cast<SwFlyFrmFmt*>( pXFrame->GetFrmFmt() ) ); // req for z-order
        }
    }
    catch ( uno::Exception& )
    {
    }

	// TODO/LATER: should the rStyleName and rTblName be handled as for usual embedded object?

	return xPropSet;
}

uno::Reference< XPropertySet > SwXMLTextImportHelper::createAndInsertApplet(
		const OUString &rName,
		const OUString &rCode,
		sal_Bool bMayScript,
		const OUString& rHRef,
		sal_Int32 nWidth, sal_Int32 nHeight )
{
    // this method will modify the document directly -> lock SolarMutex
	vos::OGuard aGuard(Application::GetSolarMutex());

	uno::Reference < XPropertySet > xPropSet;
	uno::Reference<XUnoTunnel> xCrsrTunnel( GetCursor(), UNO_QUERY );
	ASSERT( xCrsrTunnel.is(), "missing XUnoTunnel for Cursor" );
	OTextCursorHelper *pTxtCrsr = reinterpret_cast< OTextCursorHelper * >(
				sal::static_int_cast< sal_IntPtr >( xCrsrTunnel->getSomething( OTextCursorHelper::getUnoTunnelId() )));
	ASSERT( pTxtCrsr, "SwXTextCursor missing" );
	SwDoc *pDoc = pTxtCrsr->GetDoc();

	SfxItemSet aItemSet( pDoc->GetAttrPool(), RES_FRMATR_BEGIN,
						 RES_FRMATR_END );
    lcl_putHeightAndWidth( aItemSet, nHeight, nWidth);

	SwApplet_Impl aAppletImpl ( aItemSet );

    String sCodeBase;
    if( rHRef.getLength() )
        sCodeBase = GetXMLImport().GetAbsoluteReference( rHRef );

    aAppletImpl.CreateApplet ( rCode, rName, bMayScript, sCodeBase, GetXMLImport().GetDocumentBase() );

	// set the size of the applet
	lcl_setObjectVisualArea( aAppletImpl.GetApplet(),
							embed::Aspects::MSOLE_CONTENT,
							Size( nWidth, nHeight ),
							MAP_100TH_MM );

	SwFrmFmt *pFrmFmt = pDoc->Insert( *pTxtCrsr->GetPaM(),
									   ::svt::EmbeddedObjectRef( aAppletImpl.GetApplet(), embed::Aspects::MSOLE_CONTENT ),
									   &aAppletImpl.GetItemSet(),
									   NULL,
									   NULL);
	SwXFrame *pXFrame = SwXFrames::GetObject( *pFrmFmt, FLYCNTTYPE_OLE );
	xPropSet = pXFrame;
	if( pDoc->GetDrawModel() )
		SwXFrame::GetOrCreateSdrObject(
				static_cast<SwFlyFrmFmt*>( pXFrame->GetFrmFmt() ) ); // req for z-order

	return xPropSet;
}

uno::Reference< XPropertySet > SwXMLTextImportHelper::createAndInsertPlugin(
		const OUString &rMimeType,
		const OUString& rHRef,
		sal_Int32 nWidth, sal_Int32 nHeight )
{
	uno::Reference < XPropertySet > xPropSet;
	uno::Reference<XUnoTunnel> xCrsrTunnel( GetCursor(), UNO_QUERY );
	ASSERT( xCrsrTunnel.is(), "missing XUnoTunnel for Cursor" );
	OTextCursorHelper *pTxtCrsr = reinterpret_cast< OTextCursorHelper * >(
			sal::static_int_cast< sal_IntPtr >( xCrsrTunnel->getSomething( OTextCursorHelper::getUnoTunnelId() )));
	ASSERT( pTxtCrsr, "SwXTextCursor missing" );
	SwDoc *pDoc = pTxtCrsr->GetDoc();

	SfxItemSet aItemSet( pDoc->GetAttrPool(), RES_FRMATR_BEGIN,
						 RES_FRMATR_END );
    lcl_putHeightAndWidth( aItemSet, nHeight, nWidth);

    // We'll need a (valid) URL, or we need a MIME type. If we don't have
    // either, do not insert plugin and return early. Copy URL into URL oject
    // on the way.
   	INetURLObject aURLObj;

    bool bValidURL = rHRef.getLength() != 0 &&
                     aURLObj.SetURL( URIHelper::SmartRel2Abs( INetURLObject( GetXMLImport().GetBaseURL() ), rHRef ) );
    bool bValidMimeType = rMimeType.getLength() != 0;
	if( !bValidURL && !bValidMimeType )
		return xPropSet;

    uno::Reference < embed::XStorage > xStorage = comphelper::OStorageHelper::GetTemporaryStorage();
    try
    {
        // create object with desired ClassId
        ::rtl::OUString aName = ::rtl::OUString::createFromAscii( "DummyName" );
        uno::Sequence < sal_Int8 > aClass( SvGlobalName( SO3_PLUGIN_CLASSID ).GetByteSequence() );
        uno::Reference < embed::XEmbedObjectCreator > xFactory( ::comphelper::getProcessServiceFactory()->createInstance(
                ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.embed.EmbeddedObjectCreator")) ), uno::UNO_QUERY );
        uno::Reference < embed::XEmbeddedObject > xObj =
            uno::Reference < embed::XEmbeddedObject >( xFactory->createInstanceInitNew(
            aClass, ::rtl::OUString(), xStorage, aName,
            uno::Sequence < beans::PropertyValue >() ), uno::UNO_QUERY );

		// set size to the object
		lcl_setObjectVisualArea( xObj,
								embed::Aspects::MSOLE_CONTENT,
								Size( nWidth, nHeight ),
								MAP_100TH_MM );

        if ( svt::EmbeddedObjectRef::TryRunningState( xObj ) )
        {
            uno::Reference < beans::XPropertySet > xSet( xObj->getComponent(), uno::UNO_QUERY );
            if ( xSet.is() )
            {
                if( bValidURL )
                    xSet->setPropertyValue( ::rtl::OUString::createFromAscii("PluginURL"),
                        makeAny( ::rtl::OUString( aURLObj.GetMainURL( INetURLObject::NO_DECODE ) ) ) );
                if( bValidMimeType )
                    xSet->setPropertyValue( ::rtl::OUString::createFromAscii("PluginMimeType"),
                        makeAny( ::rtl::OUString( rMimeType ) ) );
            }

            SwFrmFmt *pFrmFmt = pDoc->Insert( *pTxtCrsr->GetPaM(),
                                            ::svt::EmbeddedObjectRef( xObj, embed::Aspects::MSOLE_CONTENT ),
                                            &aItemSet,
											NULL,
											NULL);
            SwXFrame *pXFrame = SwXFrames::GetObject( *pFrmFmt, FLYCNTTYPE_OLE );
            xPropSet = pXFrame;
            if( pDoc->GetDrawModel() )
                SwXFrame::GetOrCreateSdrObject(
                        static_cast<SwFlyFrmFmt*>( pXFrame->GetFrmFmt() ) ); // req for z-order
        }
    }
    catch ( uno::Exception& )
    {
    }

	return xPropSet;
}
uno::Reference< XPropertySet > SwXMLTextImportHelper::createAndInsertFloatingFrame(
		const OUString& rName,
		const OUString& rHRef,
		const OUString& rStyleName,
		sal_Int32 nWidth, sal_Int32 nHeight )
{
    // this method will modify the document directly -> lock SolarMutex
	vos::OGuard aGuard(Application::GetSolarMutex());

	uno::Reference < XPropertySet > xPropSet;
	uno::Reference<XUnoTunnel> xCrsrTunnel( GetCursor(), UNO_QUERY );
	ASSERT( xCrsrTunnel.is(), "missing XUnoTunnel for Cursor" );
	OTextCursorHelper *pTxtCrsr = reinterpret_cast< OTextCursorHelper * >(
				sal::static_int_cast< sal_IntPtr >( xCrsrTunnel->getSomething( OTextCursorHelper::getUnoTunnelId() )));
	ASSERT( pTxtCrsr, "SwXTextCursor missing" );
	SwDoc *pDoc = pTxtCrsr->GetDoc();

	SfxItemSet aItemSet( pDoc->GetAttrPool(), RES_FRMATR_BEGIN,
						 RES_FRMATR_END );
    lcl_putHeightAndWidth( aItemSet, nHeight, nWidth);

	ScrollingMode eScrollMode = ScrollingAuto;
	sal_Bool bHasBorder = sal_False;
	sal_Bool bIsBorderSet = sal_False;
	Size aMargin( SIZE_NOT_SET, SIZE_NOT_SET );
	const XMLPropStyleContext *pStyle = 0;
	if( rStyleName.getLength() )
	{
		pStyle = FindAutoFrameStyle( rStyleName );
		if( pStyle )
		{
			UniReference < SvXMLImportPropertyMapper > xImpPrMap =
				pStyle->GetStyles()
					  ->GetImportPropertyMapper(pStyle->GetFamily());
			ASSERT( xImpPrMap.is(), "Where is the import prop mapper?" );
			if( xImpPrMap.is() )
			{
				UniReference<XMLPropertySetMapper> rPropMapper =
				xImpPrMap->getPropertySetMapper();

				sal_Int32 nCount = pStyle->GetProperties().size();
				for( sal_Int32 i=0; i < nCount; i++ )
				{
					const XMLPropertyState& rProp = pStyle->GetProperties()[i];
					sal_Int32 nIdx = rProp.mnIndex;
					if( -1 == nIdx )
						continue;

					switch( rPropMapper->GetEntryContextId(nIdx) )
					{
					case CTF_FRAME_DISPLAY_SCROLLBAR:
						{
							sal_Bool bYes = *(sal_Bool *)rProp.maValue.getValue();
							eScrollMode = bYes ? ScrollingYes : ScrollingNo;
						}
						break;
					case CTF_FRAME_DISPLAY_BORDER:
						{
							bHasBorder = *(sal_Bool *)rProp.maValue.getValue();
							bIsBorderSet = sal_True;
						}
						break;
					case CTF_FRAME_MARGIN_HORI:
						{
							sal_Int32 nVal = SIZE_NOT_SET;
							rProp.maValue >>= nVal;
							aMargin.Width() = nVal;
						}
						break;
					case CTF_FRAME_MARGIN_VERT:
						{
							sal_Int32 nVal = SIZE_NOT_SET;
							rProp.maValue >>= nVal;
							aMargin.Height() = nVal;
						}
						break;
					}
				}
			}
		}
	}

    uno::Reference < embed::XStorage > xStorage = comphelper::OStorageHelper::GetTemporaryStorage();
    try
    {
        // create object with desired ClassId
        ::rtl::OUString aName = ::rtl::OUString::createFromAscii( "DummyName" );
        uno::Sequence < sal_Int8 > aClass( SvGlobalName( SO3_IFRAME_CLASSID ).GetByteSequence() );
        uno::Reference < embed::XEmbedObjectCreator > xFactory( ::comphelper::getProcessServiceFactory()->createInstance(
                ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.embed.EmbeddedObjectCreator")) ), uno::UNO_QUERY );
        uno::Reference < embed::XEmbeddedObject > xObj =
            uno::Reference < embed::XEmbeddedObject >( xFactory->createInstanceInitNew(
            aClass, ::rtl::OUString(), xStorage, aName,
            uno::Sequence < beans::PropertyValue >() ), uno::UNO_QUERY );

		// set size to the object
		lcl_setObjectVisualArea( xObj,
								embed::Aspects::MSOLE_CONTENT,
								Size( nWidth, nHeight ),
								MAP_100TH_MM );

        if ( svt::EmbeddedObjectRef::TryRunningState( xObj ) )
        {
            uno::Reference < beans::XPropertySet > xSet( xObj->getComponent(), uno::UNO_QUERY );
            if ( xSet.is() )
            {
                xSet->setPropertyValue( ::rtl::OUString::createFromAscii("FrameURL"),
                    makeAny( ::rtl::OUString( URIHelper::SmartRel2Abs(
                            INetURLObject( GetXMLImport().GetBaseURL() ), rHRef ) ) ) );

                xSet->setPropertyValue( ::rtl::OUString::createFromAscii("FrameName"),
                    makeAny( ::rtl::OUString( rName ) ) );

                if ( eScrollMode == ScrollingAuto )
                    xSet->setPropertyValue( ::rtl::OUString::createFromAscii("FrameIsAutoScroll"),
                        makeAny( sal_True ) );
                else
                    xSet->setPropertyValue( ::rtl::OUString::createFromAscii("FrameIsScrollingMode"),
                        makeAny( (sal_Bool) (eScrollMode == ScrollingYes) ) );

                if ( bIsBorderSet )
                    xSet->setPropertyValue( ::rtl::OUString::createFromAscii("FrameIsBorder"),
                        makeAny( bHasBorder ) );
                else
                    xSet->setPropertyValue( ::rtl::OUString::createFromAscii("FrameIsAutoBorder"),
                        makeAny( sal_True ) );

                xSet->setPropertyValue( ::rtl::OUString::createFromAscii("FrameMarginWidth"),
                    makeAny( sal_Int32( aMargin.Width() ) ) );

                xSet->setPropertyValue( ::rtl::OUString::createFromAscii("FrameMarginHeight"),
                    makeAny( sal_Int32( aMargin.Height() ) ) );
            }

            SwFrmFmt *pFrmFmt = pDoc->Insert( *pTxtCrsr->GetPaM(),
                                            ::svt::EmbeddedObjectRef( xObj, embed::Aspects::MSOLE_CONTENT ),
                                            &aItemSet,
											NULL,
											NULL);
            SwXFrame *pXFrame = SwXFrames::GetObject( *pFrmFmt, FLYCNTTYPE_OLE );
            xPropSet = pXFrame;
            if( pDoc->GetDrawModel() )
                SwXFrame::GetOrCreateSdrObject(
                        static_cast<SwFlyFrmFmt*>( pXFrame->GetFrmFmt() ) ); // req for z-order
        }
    }
    catch ( uno::Exception& )
    {
    }

	return xPropSet;
}

void SwXMLTextImportHelper::endAppletOrPlugin(
        const uno::Reference < XPropertySet > &rPropSet,
        ::std::map < const ::rtl::OUString, ::rtl::OUString, ::comphelper::UStringLess > &rParamMap)
{
    // this method will modify the document directly -> lock SolarMutex
	vos::OGuard aGuard(Application::GetSolarMutex());

    uno::Reference<XUnoTunnel> xCrsrTunnel( rPropSet, UNO_QUERY );
	ASSERT( xCrsrTunnel.is(), "missing XUnoTunnel for embedded" );
	SwXFrame *pFrame = reinterpret_cast< SwXFrame * >(
				sal::static_int_cast< sal_IntPtr >( xCrsrTunnel->getSomething( SwXFrame::getUnoTunnelId() )));
	ASSERT( pFrame, "SwXFrame missing" );
	SwFrmFmt *pFrmFmt = pFrame->GetFrmFmt();
	const SwFmtCntnt& rCntnt = pFrmFmt->GetCntnt();
	const SwNodeIndex *pNdIdx = rCntnt.GetCntntIdx();
	SwOLENode *pOLENd = pNdIdx->GetNodes()[pNdIdx->GetIndex() + 1]->GetNoTxtNode()->GetOLENode();
    SwOLEObj& rOLEObj = pOLENd->GetOLEObj();

    uno::Reference < embed::XEmbeddedObject > xEmbObj( rOLEObj.GetOleRef() );
    if ( svt::EmbeddedObjectRef::TryRunningState( xEmbObj ) )
    {
        uno::Reference < beans::XPropertySet > xSet( xEmbObj->getComponent(), uno::UNO_QUERY );
        if ( xSet.is() )
        {
            const sal_Int32 nCount = rParamMap.size();
            uno::Sequence< beans::PropertyValue > aCommandSequence( nCount );

            ::std::map < const ::rtl::OUString, ::rtl::OUString, ::comphelper::UStringLess > ::iterator aIter = rParamMap.begin();
            ::std::map < const ::rtl::OUString, ::rtl::OUString, ::comphelper::UStringLess > ::iterator aEnd = rParamMap.end();
            sal_Int32 nIndex=0;
            while (aIter != aEnd )
            {
                aCommandSequence[nIndex].Name = (*aIter).first;
                aCommandSequence[nIndex].Handle = -1;
                aCommandSequence[nIndex].Value = makeAny( OUString((*aIter).second) );
                aCommandSequence[nIndex].State = beans::PropertyState_DIRECT_VALUE;
                aIter++, nIndex++;
            }

            // unfortunately the names of the properties are depending on the object
            ::rtl::OUString aParaName = ::rtl::OUString::createFromAscii("AppletCommands");
            try
            {
                xSet->setPropertyValue( aParaName, makeAny( aCommandSequence ) );
            }
            catch ( uno::Exception& )
            {
                aParaName = ::rtl::OUString::createFromAscii("PluginCommands");
                try
                {
                    xSet->setPropertyValue( aParaName, makeAny( aCommandSequence ) );
                }
                catch ( uno::Exception& )
                {
                }
            }
        }
    }
}

XMLTextImportHelper* SwXMLImport::CreateTextImport()
{
	return new SwXMLTextImportHelper( GetModel(), *this, getImportInfo(),
									  IsInsertMode(),
									  IsStylesOnlyMode(), bShowProgress,
									  IsBlockMode(), IsOrganizerMode(),
									  bPreserveRedlineMode );
}


// redlining helper methods
// (override to provide the real implementation)

void SwXMLTextImportHelper::RedlineAdd(
	const OUString& rType,
	const OUString& rId,
	const OUString& rAuthor,
	const OUString& rComment,
	const util::DateTime& rDateTime,
    sal_Bool bMergeLastPara)
{
	// create redline helper on demand
	DBG_ASSERT(NULL != pRedlineHelper, "helper should have been created in constructor");
	if (NULL != pRedlineHelper)
		pRedlineHelper->Add(rType, rId, rAuthor, rComment, rDateTime,
                            bMergeLastPara);
}

uno::Reference<XTextCursor> SwXMLTextImportHelper::RedlineCreateText(
	uno::Reference<XTextCursor> & rOldCursor,
	const OUString& rId)
{
	uno::Reference<XTextCursor> xRet;

	if (NULL != pRedlineHelper)
	{
		xRet = pRedlineHelper->CreateRedlineTextSection(rOldCursor, rId);
	}

	return xRet;
}

void SwXMLTextImportHelper::RedlineSetCursor(
	const OUString& rId,
	sal_Bool bStart,
	sal_Bool bIsOutsideOfParagraph)
{
	if (NULL != pRedlineHelper) {
        uno::Reference<XTextRange> xTextRange( GetCursor()->getStart() );
		pRedlineHelper->SetCursor(rId, bStart, xTextRange,
								  bIsOutsideOfParagraph);
    }
	// else: ignore redline (wasn't added before, else we'd have a helper)
}

void SwXMLTextImportHelper::RedlineAdjustStartNodeCursor(
	sal_Bool bStart)
{
	OUString rId = GetOpenRedlineId();
	if ((NULL != pRedlineHelper) && (rId.getLength() > 0))
	{
        uno::Reference<XTextRange> xTextRange( GetCursor()->getStart() );
		pRedlineHelper->AdjustStartNodeCursor(rId, bStart, xTextRange );
		ResetOpenRedlineId();
	}
	// else: ignore redline (wasn't added before, or no open redline ID
}

void SwXMLTextImportHelper::SetShowChanges( sal_Bool bShowChanges )
{
	if ( NULL != pRedlineHelper )
		pRedlineHelper->SetShowChanges( bShowChanges );
}

void SwXMLTextImportHelper::SetRecordChanges( sal_Bool bRecordChanges )
{
	if ( NULL != pRedlineHelper )
		pRedlineHelper->SetRecordChanges( bRecordChanges );
}

void SwXMLTextImportHelper::SetChangesProtectionKey(
	const Sequence<sal_Int8> & rKey )
{
	if ( NULL != pRedlineHelper )
		pRedlineHelper->SetProtectionKey( rKey );
}