recreated tag libreoffice-3.3.1.1 which had these commits:

commit 1163151cf51a15a68700eda522ba7a789e378361 (tag: refs/tags/libreoffice-3.3.1.1)
Author: Petr Mladek <pmladek@suse.cz>
Date:   Tue Feb 8 18:07:43 2011 +0100

    Version 3.3.1.1, tag libreoffice-3.3.1.1 (3.3.1-rc1)

commit 3d8f2d6ee7f86ec048ffca70a7dd59efb64ab90c
Author: Jan Holesovsky <kendy@suse.cz>
Date:   Mon Feb 7 21:23:24 2011 +0100

    Branch libreoffice-3-3-1

    This is 'libreoffice-3-3-1' - the stable branch for the 3.3.1 release.
    Only very safe changes, reviewed by three people are allowed.

    If you want to commit more complicated fix for the next 3.3.x release,
    please use the 'libreoffice-3-3' branch.

    If you want to build something cool, unstable, and risky, use master.

commit 4d86423be75125185f7e220877839c68934bfedc
Author: Joseph Powers <jpowers27@cox.net>
Date:   Mon Feb 7 16:32:57 2011 +0000

    cherry picked from 0679158ebb6c84863e6e0e2fe877ea06eba4a2d4

    Move XServiceInfo.hpp from DEBUG to main.

    Now that XServiceInfo is always used, it would be nice to always include
    if defination. This fixes a compile error on mac.

    PS: Also some trailing white space. The changed code all appears at the
    top of the patch.

    Signed-off-by: Noel Power <noel.power@novell.com>

 writerfilter/source/dmapper/DomainMapper_Impl.cxx |  144 ++++++++++----------
 1 files changed, 72 insertions(+), 72 deletions(-)

commit 8efa2697b2a2737ee5951358878a17203073ac49
Author: Noel Power <noel.power@novell.com>
Date:   Mon Feb 7 12:01:46 2011 +0000

    fix for bnc#655763

    cherry picked from ae5d018c49d3ab61416cde7fb09c37bcce7d9566
    reviewed in bug https://bugzilla.novell.com/show_bug.cgi?id=655763#c6

    Signed-off-by: Cedric Bosdonnat <cbosdonnat@novell.com>

 writerfilter/source/dmapper/DomainMapper_Impl.cxx |    7 ++++---
 1 files changed, 4 insertions(+), 3 deletions(-)

commit 780535edc21bc230a859d672b7408f10e2691a38
Author: Petr Mladek <pmladek@suse.cz>
Date:   Wed Feb 2 17:09:03 2011 +0100

    RTF export crasher (bnc#656503)

    Signed off by Cedric

 filter/source/msfilter/escherex.cxx |    6 ++++++
 1 files changed, 6 insertions(+), 0 deletions(-)

commit ecda6f3b42d84e88d35d4d6bd4ea5cc32b9b8c89
Author: Takeshi Kurosawa <taken.spc@gmail.com>
Date:   Thu Jan 27 14:31:57 2011 +0900

    Use product name for EPS Creator header
    (cherry picked from commit 2d07f1d678dc868687a9ae8c326b766e7def21c2)

    Signed-off-by: Thorsten Behrens <tbehrens@novell.com>

 filter/source/graphicfilter/eps/eps.cxx     |   16 +++++++++++++++-
 filter/source/graphicfilter/eps/makefile.mk |    2 +-
 2 files changed, 16 insertions(+), 2 deletions(-)

commit dd73734f0440787d84ddbe5737e7f996803dacf2
Author: Takeshi Kurosawa <taken.spc@gmail.com>
Date:   Thu Jan 27 13:45:16 2011 +0900

    Parse 'color' property (fdo#33551)

    Parse 'color' property and store the value as currentColor.
    (cherry picked from commit d4bac116d0c35d8811a048fdd991363a32df14ca)

    Signed-off-by: Thorsten Behrens <tbehrens@novell.com>

 filter/source/svg/svgreader.cxx |    8 ++++++++
 1 files changed, 8 insertions(+), 0 deletions(-)

commit 9a7fcfcf49e393c02e8d115dfa4a40811582375f
Author: Fridrich Štrba <fridrich.strba@bluewin.ch>
Date:   Sun Jan 30 10:22:38 2011 +0100

    Use double instead of float
    (cherry picked from commit c90c5d503543a960a05b43752a5dff9ccf4bcd30)

    Signed-off-by: Caolán McNamara <caolanm@redhat.com>

 writerperfect/source/filter/DocumentCollector.cxx |    2 +-
 writerperfect/source/filter/DocumentCollector.hxx |    2 +-
 writerperfect/source/filter/FilterInternal.hxx    |    6 +++---
 writerperfect/source/filter/ListStyle.cxx         |   12 ++++++------
 writerperfect/source/filter/SectionStyle.cxx      |    2 +-
 writerperfect/source/filter/TextRunStyle.cxx      |    6 +++---
 writerperfect/source/filter/WriterProperties.hxx  |    4 ++--
 7 files changed, 17 insertions(+), 17 deletions(-)

commit 9fd267985820db81454cce1b4a76752769b471b7
Author: Thomas Klausner <wiz@NetBSD.org>
Date:   Sat Nov 6 00:30:42 2010 +0100

    Use PYTHON as passed through by set_soenv.in.

 filter/source/config/fragments/makefile.mk |    2 +-
 1 files changed, 1 insertions(+), 1 deletions(-)

commit 82102abd307f911c400735eb6f9b43fa69d221d8
Author: Noel Power <noel.power@novell.com>
Date:   Tue Jan 18 12:58:17 2011 +0000

    fdo#33237 remove debug line

 writerfilter/source/dmapper/DomainMapper_Impl.cxx |    1 -
 1 files changed, 0 insertions(+), 1 deletions(-)

commit 9c976ba4f8e1fd2bcd40412873e22728ed83d5bd
Author: Noel Power <noel.power@novell.com>
Date:   Tue Jan 18 12:43:50 2011 +0000

    fdo#33237# fix ole object import for writer (docx)

 writerfilter/source/dmapper/DomainMapper_Impl.cxx |   41 +++++++++++++++++++++
 1 files changed, 41 insertions(+), 0 deletions(-)

commit 8383f008c60c0615005f4bb22ae9ddaeca4540cf
Author: Fridrich Štrba <fridrich.strba@bluewin.ch>
Date:   Tue Jan 18 11:12:52 2011 +0100

    Fix a typo SolarMuexGuard -> SolarMutexGuard

    signoff: Jan Holesovsky <kendy@suse.cz>
    signoff: Thorsten Behrens <thb@documentfoundation.org>
    signoff: Tor Lillqvist <tlillqvist@novell.com>
    signoff: Petr Mladek <pmladek@suse.cz>

 binfilter/bf_so3/source/ole/socli.cxx |    2 +-
 1 files changed, 1 insertions(+), 1 deletions(-)

commit 247a91f1df71614fc8d9b2264d10f0952055c611
Author: Petr Mladek <pmladek@suse.cz>
Date:   Tue Jan 11 23:05:56 2011 +0100

    Please, ignore the previous message; it was for the libreoffice-3-3-0 branch

    This is 'libreoffice-3-3' - the stable branch for the 3.3.x releases.
    Only safe changes, reviewed by anoter person are allowed.

    If you want to build something cool, unstable, and risky, use master.

commit 9628deac573830fdfbce2c402f8574379ac71a35
Author: Petr Mladek <pmladek@suse.cz>
Date:   Tue Jan 11 22:39:07 2011 +0100

    Branch libreoffice-3-3-0

    This is 'libreoffice-3-3-0' - the stable branch for the 3.3.0 release.
    Only very safe changes, reviewed by three people are allowed.

    If you want to commit more complicated fix for the next 3.3.x release,
    please use the 'libreoffice-3-3' branch.

    If you want to build something cool, unstable, and risky, use master.

1 files changed, 1751 insertions, 0 deletions

diff --git a/binfilter/bf_sfx2/source/doc/sfx2_objstor.cxx b/binfilter/bf_sfx2/source/doc/sfx2_objstor.cxx
new file mode 100644
index 000000000000..dfba43054cbb
--- /dev/null
+++ b/binfilter/bf_sfx2/source/doc/sfx2_objstor.cxx
@@ -0,0 +1,1751 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*************************************************************************
+ *
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * 
+ * Copyright 2000, 2010 Oracle and/or its affiliates.
+ *
+ * OpenOffice.org - a multi-platform office productivity suite
+ *
+ * This file is part of OpenOffice.org.
+ *
+ * OpenOffice.org is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3
+ * only, as published by the Free Software Foundation.
+ *
+ * OpenOffice.org is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License version 3 for more details
+ * (a copy is included in the LICENSE file that accompanied this code).
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * version 3 along with OpenOffice.org.  If not, see
+ * <http://www.openoffice.org/license.html>
+ * for a copy of the LGPLv3 License.
+ *
+ ************************************************************************/
+
+#include <bf_svtools/eitem.hxx>
+#include <bf_svtools/stritem.hxx>
+#include <bf_so3/svstor.hxx>
+#include <tools/zcodec.hxx>
+#include <com/sun/star/frame/XStorable.hpp>
+#include <com/sun/star/frame/XModel.hpp>
+#include <com/sun/star/frame/XFrame.hpp>
+
+#include <com/sun/star/document/XFilter.hpp>
+#include <com/sun/star/document/XImporter.hpp>
+#include <com/sun/star/document/XExporter.hpp>
+#include <com/sun/star/document/FilterOptionsRequest.hpp>
+#include <com/sun/star/document/XInteractionFilterOptions.hpp>
+#include <com/sun/star/task/XInteractionHandler.hpp>
+
+#include <com/sun/star/lang/XInitialization.hpp>
+
+#include <com/sun/star/document/MacroExecMode.hpp>
+#include <com/sun/star/beans/XPropertySetInfo.hpp>
+
+#include <com/sun/star/lang/XMultiServiceFactory.hpp>
+
+#include <com/sun/star/beans/XPropertyAccess.hpp>
+
+#include <com/sun/star/beans/PropertyValue.hpp>
+
+#include <com/sun/star/container/XNameAccess.hpp>
+
+#include <comphelper/processfactory.hxx>
+
+#ifdef _MSC_VER
+#pragma hdrstop
+#endif
+#include <bf_svtools/itemset.hxx>
+
+#include <bf_svtools/sfxecode.hxx>
+
+#include <cppuhelper/weak.hxx>
+#include <comphelper/processfactory.hxx>
+
+#include <comphelper/classids.hxx>
+#include <tools/cachestr.hxx>
+#include <bf_svtools/addxmltostorageoptions.hxx>
+#include <unotools/streamwrap.hxx>
+
+#include <bf_svtools/saveopt.hxx>
+#include <bf_svtools/useroptions.hxx>
+#include <bf_svtools/pathoptions.hxx>
+#include <tools/urlobj.hxx>
+#include <unotools/localfilehelper.hxx>
+#include <unotools/ucbhelper.hxx>
+#include <unotools/tempfile.hxx>
+#include <ucbhelper/content.hxx>
+#include <sot/storinfo.hxx>
+
+#include "objsh.hxx"
+#include "request.hxx"
+#include "docfile.hxx"
+#include "fltfnc.hxx"
+#include "docfilt.hxx"
+#include "docinf.hxx"
+#include "docfac.hxx"
+#include "cfgmgr.hxx"
+#include "objshimp.hxx"
+#include "sfxtypes.hxx"
+#include "appdata.hxx"
+#include "sfxsids.hrc"
+#include "interno.hxx"
+#include "module.hxx"
+#include "app.hxx"
+#include "openflag.hxx"
+#include "helper.hxx"
+#include "dlgcont.hxx"
+#include "appuno.hxx"
+
+#include "bf_basic/basmgr.hxx"
+
+#include "scriptcont.hxx"
+#include "event.hxx"
+#include "fltoptint.hxx"
+
+#include <legacysmgr/legacy_binfilters_smgr.hxx>	//STRIP002
+#include "bf_so3/staticbaseurl.hxx"
+namespace binfilter {
+
+#define S2BS(s) ByteString( s, RTL_TEXTENCODING_MS_1252 )
+
+
+extern sal_uInt32 CheckPasswd_Impl( SfxObjectShell*, SfxItemPool&, SfxMedium* );
+
+
+using namespace ::com::sun::star::container;
+using namespace ::com::sun::star::lang;
+//using namespace ::com::sun::star::ui::dialogs;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::beans;
+using namespace ::com::sun::star::ucb;
+using namespace ::com::sun::star::task;
+using namespace ::com::sun::star::document;
+using namespace ::rtl;
+using namespace ::cppu;
+
+//=========================================================================
+
+/*N*/ sal_Bool ShallSetBaseURL_Impl( SfxMedium &rMed )
+/*N*/ {
+/*N*/     SvtSaveOptions aOpt;
+/*N*/ 	sal_Bool bIsRemote = rMed.IsRemote();
+/*N*/     return  aOpt.IsSaveRelINet() && bIsRemote || aOpt.IsSaveRelFSys() && !bIsRemote;
+/*N*/ }
+
+//=========================================================================
+
+/*N*/ sal_Bool SfxObjectShell::Save()
+/*N*/ {
+/*N*/     if( SOFFICE_FILEFORMAT_60 <= GetStorage()->GetVersion() )
+/*N*/         return sal_True;
+/*N*/     else
+/*N*/         return SaveInfoAndConfig_Impl( GetMedium()->GetStorage() );
+/*N*/ }
+
+//--------------------------------------------------------------------------
+
+/*N*/ sal_Bool SfxObjectShell::SaveAs( SvStorage* pNewStg )
+/*N*/ {
+/*N*/     if( SOFFICE_FILEFORMAT_60 <= pNewStg->GetVersion() )
+/*N*/         return sal_True;
+/*N*/     else
+/*N*/         return SaveInfoAndConfig_Impl( pNewStg );
+/*N*/ }
+
+//-------------------------------------------------------------------------
+
+/*N*/ sal_Bool GetPasswd_Impl( const SfxItemSet* pSet, String& rPasswd )
+/*N*/ {
+/*N*/ 	const SfxPoolItem* pItem = NULL;
+/*N*/ 	if ( pSet && SFX_ITEM_SET == pSet->GetItemState( SID_PASSWORD, sal_True, &pItem ) )
+/*N*/ 	{
+/*?*/ 		DBG_ASSERT( pItem->IsA( TYPE(SfxStringItem) ), "wrong item type" );
+/*?*/ 		rPasswd = ( (const SfxStringItem*)pItem )->GetValue();
+/*?*/ 		return sal_True;
+/*N*/ 	}
+/*N*/ 	return sal_False;
+/*N*/ }
+
+//-------------------------------------------------------------------------
+
+/*N*/ sal_Bool SfxObjectShell::DoInitNew( SvStorage * pStor )
+
+/*  [Beschreibung]
+
+    Diese von SvPersist geerbte virtuelle Methode wird gerufen, um
+    die SfxObjectShell-Instanz aus einem Storage (pStor != 0) bzw.
+    (pStor == 0) ganz neu zu initialisieren.
+
+    Wie alle Do...-Methoden liegt hier eine Steuerung vor, die eigentliche
+    Implementierung erfolgt, indem die ebenfalls virtuellen Methode
+    InitNew(SvStorate*) von der SfxObjectShell-Subclass implementiert wird.
+
+    F"ur pStor == 0 wird ein die SfxObjectShell-Instanz mit einem leeren
+    SfxMedium verbunden, sonst mit einem SfxMedium, welches auf den
+    als Parameter "ubergeben SvStorage verweist.
+
+    Erst nach InitNew() oder Load() ist das Objekt korrekt initialisiert.
+
+    [R"uckgabewert]
+    sal_True            Das Objekt wurde initialisiert.
+    sal_False           Das Objekt konnte nicht initialisiert werden
+*/
+
+/*N*/ {
+/*N*/ 	ModifyBlocker_Impl aBlock( this );
+/*N*/ 	if ( pStor )
+/*N*/ 		pMedium = new SfxMedium( pStor );
+/*N*/ 	else
+/*N*/ 	{
+/*N*/ 		bIsTmp = sal_True;
+/*N*/ 		pMedium = new SfxMedium;
+/*N*/ 	}
+/*N*/
+/*N*/ 	if ( InitNew( pStor ) )
+/*N*/ 	{
+/*N*/ 		// empty documents always get their macros from the user, so there is no reason to restrict access
+/*N*/ 		pImp->nMacroMode = MacroExecMode::ALWAYS_EXECUTE_NO_WARN;
+/*N*/
+/*N*/ 		::com::sun::star::uno::Reference< ::com::sun::star::frame::XModel >  xModel ( GetModel(), ::com::sun::star::uno::UNO_QUERY );
+/*N*/ 		if ( xModel.is() )
+/*N*/ 		{
+/*N*/ 			SfxItemSet *pSet = GetMedium()->GetItemSet();
+/*N*/             pSet->Put( SfxStringItem( SID_FILTER_NAME, GetFactory().GetFilter(0)->GetFilterName() ) );
+/*N*/ 			::com::sun::star::uno::Sequence< ::com::sun::star::beans::PropertyValue > aArgs;
+/*N*/ 			TransformItems( SID_OPENDOC, *pSet, aArgs );
+/*N*/             sal_Int32 nLength = aArgs.getLength();
+/*N*/             aArgs.realloc( nLength + 1 );
+/*N*/             aArgs[nLength].Name = DEFINE_CONST_UNICODE("Title");
+/*N*/             aArgs[nLength].Value <<= ::rtl::OUString( GetTitle( SFX_TITLE_DETECT ) );
+/*N*/             xModel->attachResource( ::rtl::OUString(), aArgs );
+/*N*/ 		}
+/*N*/
+/*N*/         SetActivateEvent_Impl( SFX_EVENT_CREATEDOC );
+/*N*/ 		return sal_True;
+/*N*/ 	}
+/*N*/ 	return sal_False;
+/*N*/ }
+
+//-------------------------------------------------------------------------
+
+void SfxObjectShell::DoHandsOffNoMediumClose()
+/*N*/ {
+/*N*/     const SfxFilter *pFilter = pMedium->GetFilter();
+/*N*/     if( !pFilter || pFilter->IsOwnFormat() || ( pFilter->GetFilterFlags() & SFX_FILTER_PACKED ) )
+/*N*/ 		HandsOff();
+/*N*/
+/*N*/ 	// Force document library containers to release storage
+/*N*/ 	SotStorageRef xDummyStorage;
+/*N*/ 	SfxDialogLibraryContainer* pDialogCont = pImp->pDialogLibContainer;
+/*N*/ 	if( pDialogCont )
+/*N*/ 		pDialogCont->setStorage( xDummyStorage );
+/*N*/
+/*N*/ 	SfxScriptLibraryContainer* pBasicCont = pImp->pBasicLibContainer;
+/*N*/ 	if( pBasicCont )
+/*N*/ 		pBasicCont->setStorage( xDummyStorage );
+/*N*/ }
+
+//-------------------------------------------------------------------------
+
+/*N*/ void SfxObjectShell::DoHandsOff()
+
+/*  [Beschreibung]
+
+    Diese von SvPersist geerbte virtuelle Methode wird gerufen, um
+    das Objekt aufzufordern, den ihm zugeteilten SvStorage freizugeben,
+    insbesondere Substorages und Streams zu schlie"sen.
+
+    Als Do...-Methode liegt hier nur die Steuerung. Der Implementierer
+    von Subclasses kann die ebenfalls virtuelle Methode HandsOff()
+    implementieren, um seine Substorages und Streams zu schlie"sen.
+
+    Nach dem Aufruf dieser Methode, ist dem Objekt kein SfxMedium mehr
+    zugeordnet, bis SaveCompleted() durchlaufen ist.
+*/
+
+/*N*/ {
+/*N*/ 	DoHandsOffNoMediumClose();
+/*N*/ 	pMedium->Close();
+/*N*/ //  DELETEZ( pMedium );
+/*N*/ }
+
+//-------------------------------------------------------------------------
+
+/*?*/ sal_Bool SfxObjectShell::DoLoad(
+/*?*/ 	const String& rFileName, StreamMode nStreamMode, StorageMode nStorageMode)
+/*?*/ {DBG_BF_ASSERT(0, "STRIP"); //STRIP001
+/*?*/ 	return sal_False;
+/*?*/ }
+
+
+//-------------------------------------------------------------------------
+
+/*N*/ sal_Bool SfxObjectShell::DoLoad( SvStorage * pStor )
+
+/*  [Beschreibung]
+
+    Diese von SvPersist geerbte virtuelle Methode steuert das Laden
+    des Objektes aus einem Storage. Dabei wird der SvStorage zun"achst
+    in einem SfxMedium verpackt und SfxObjectShell::DoLoad(SfxMedium*)
+    mit diesem gerufen.
+
+    [R"uckgabewert]
+    sal_True                Das Objekt wurde initialisiert.
+    sal_False               Das Objekt konnte nicht initialisiert werden
+*/
+
+/*N*/ {
+/*N*/ 	pMedium = new SfxMedium( pStor );
+/*N*/ 	if ( DoLoad(pMedium) )
+/*N*/ 	{
+/*N*/ 		if ( SFX_CREATE_MODE_EMBEDDED == eCreateMode )
+/*N*/ 		{
+/*N*/ 			ModifyBlocker_Impl aBlock( this );
+/*N*/ 			// bei Embedded Objekten setzt sonst keiner den Namen
+/*N*/ //            DBG_ASSERT( pStor->GetName().Len(),
+/*N*/ //                        "StorageName hat Laenge Null" );
+/*N*/ 			SetTitle( pStor->GetName() );
+/*N*/ 		}
+/*N*/ 		return sal_True;
+/*N*/ 	}
+/*N*/
+/*N*/ 	return sal_False;
+/*N*/ }
+
+//-------------------------------------------------------------------------
+
+/*N*/ sal_Bool SfxObjectShell::DoLoad( SfxMedium *pMed )
+
+/*  [Beschreibung]
+
+    Diese Methode steuert das Laden des Objektes aus dem von dem
+    "ubergebenen SfxMedium beschriebenen Medium. Hinterher ist das Objekt
+    mit diesem SfxMedium verbunden.
+
+    Handelt es sich bei dem SfxMedium um einen Storage im eigenen Format,
+    wird die virtuelle Methode SvPersit::Load(SvStorage*) gerufen, welche
+    die Implementierer von Subclasses "uberladen m"ussen, um das Objekt
+    aus einem eigenen Storage zu laden (=> Swapping m"oeglich).
+
+    Handelt es sich bei dem SfxMedium um einen Storage in einem fremden
+    Format, oder um ein Flat-File, dann wird die virtuelle Methode
+    <SfxObjectShell::ConvertFrom(SfxMedium*)> gerufen, welche die
+    Implementierer von Subclasses "uberladen m"ussen, um das Objekt
+    aus dem SfxMedium zu konvertieren. W"ahrend der Bearbeitung ist
+    das Objekt dann mit einem tempor"aren SvStorage verbunden.
+
+    Erst nach InitNew() oder Load() ist das Objekt korrekt
+    initialisiert.
+
+    [R"uckgabewert]
+    sal_True                Das Objekt wurde geladen.
+    sal_False           Das Objekt konnte nicht geladen werden
+*/
+
+/*N*/ {
+/*N*/ 	SfxApplication *pSfxApp = SFX_APP();
+/*N*/ 	ModifyBlocker_Impl aBlock( this );
+/*N*/
+/*N*/ 	pMedium = pMed;
+/*N*/ 	sal_Bool bOk = sal_False;
+/*N*/ 	const SfxFilter* pFilter = pMed->GetFilter();
+/*N*/ 	SfxItemSet* pSet = pMedium->GetItemSet();
+/*N*/ 	if( !pImp->nEventId )
+/*N*/ 	{
+/*N*/ 		SFX_ITEMSET_ARG(
+/*N*/ 			pSet, pTemplateItem, SfxBoolItem,
+/*N*/ 			SID_TEMPLATE, sal_False);
+/*N*/         SetActivateEvent_Impl(
+/*N*/ 			( pTemplateItem && pTemplateItem->GetValue() )
+/*N*/             ? SFX_EVENT_CREATEDOC : SFX_EVENT_OPENDOC );
+/*N*/ 	}
+/*N*/
+/*N*/
+/*N*/ 	SFX_ITEMSET_ARG( pSet, pBaseItem, SfxStringItem,
+/*N*/ 					 SID_BASEURL, sal_False);
+/*N*/ 	String aBaseURL;
+/*N*/ 	SFX_ITEMSET_ARG( pMedium->GetItemSet(), pSalvageItem, SfxStringItem, SID_DOC_SALVAGE, sal_False);
+/*N*/ 	if( pBaseItem )
+/*N*/ 		aBaseURL = pBaseItem->GetValue();
+/*N*/ 	else
+/*N*/ 	{
+/*N*/ 		if( GetCreateMode() == SFX_CREATE_MODE_EMBEDDED )
+/*N*/ 		{
+/*N*/ 			aBaseURL = ::binfilter::StaticBaseUrl::GetBaseURL();
+/*N*/ 			SetBaseURL( aBaseURL );
+/*N*/ 		}
+/*N*/ 		else if ( pSalvageItem )
+/*N*/ 		{
+/*N*/             String aName( pMed->GetPhysicalName() );
+/*N*/             ::utl::LocalFileHelper::ConvertPhysicalNameToURL( aName, aBaseURL );
+/*N*/ 		}
+/*N*/ 		else
+/*N*/ 			aBaseURL = pMed->GetBaseURL();
+/*N*/ 	}
+/*N*/
+/*N*/ 	SfxApplication* pApp = SFX_APP();
+/*N*/ 	pImp->nLoadedFlags = 0;
+/*N*/     sal_Bool bHasStorage = !pFilter || ( pFilter->IsOwnFormat() && pFilter->UsesStorage() );
+/*N*/ 	if ( !bHasStorage && pFilter && ( pFilter->GetFilterFlags() & SFX_FILTER_PACKED ) )
+/*N*/ 	{
+/*N*/ 		bHasStorage = pMed->TryStorage();
+/*N*/ 		if ( bHasStorage )
+/*N*/ 		{
+/*N*/             String aName( pMed->GetPhysicalName() );
+/*N*/             ::utl::LocalFileHelper::ConvertPhysicalNameToURL( aName, aBaseURL );
+/*N*/ 		}
+/*N*/ 	}
+/*N*/
+/*N*/ 	if ( pMedium->GetFilter() )
+/*N*/ 	{
+/*N*/ 		sal_uInt32 nError = HandleFilter( pMedium, this );
+/*N*/ 		if ( nError != ERRCODE_NONE )
+/*N*/ 			SetError( nError );
+/*N*/ 	}
+/*N*/
+/*N*/     if ( GetError() == ERRCODE_NONE && pMed->IsStorage() ) // STRIP003 && bHasStorage && ( !pFilter || !( pFilter->GetFilterFlags() & SFX_FILTER_STARONEFILTER ) ) )
+/*N*/ 	{
+/*N*/ 		SvStorageRef xStor( pMed->GetStorage() );
+/*N*/ 		if( pMed->GetLastStorageCreationState() == ERRCODE_NONE )
+/*N*/ 		{
+/*N*/         	DBG_ASSERT( pFilter, "No filter for storage found!" );
+/*N*/         	if( xStor.Is() && !xStor->GetError() && pMed->GetFilter() && pMed->GetFilter()->GetVersion() < SOFFICE_FILEFORMAT_60 )
+/*N*/ 			{
+/*N*/             	// Undoobjekte aufraeumen, muss vor dem eigentlichen Laden erfolgen
+/*N*/ 				SvEmbeddedObjectRef xThis = this;
+/*N*/ 				SvPersistRef xPer;
+/*N*/ 				if ( xThis.Is() )
+/*N*/ 					xPer = new SvEmbeddedObject;
+/*N*/ 				else
+/*?*/ 					xPer = new SvPersist;
+/*N*/
+/*N*/ 				xPer->DoOwnerLoad(xStor);
+/*N*/ 				xPer->CleanUp();
+/*N*/ 				xPer->DoSave();
+/*N*/ 				xPer->DoSaveCompleted( 0 );
+/*N*/ 			}
+/*N*/
+/*N*/         	if ( xStor.Is() )
+/*N*/         	{
+/*N*/             	SvStorageInfoList aList;
+/*N*/             	xStor->FillInfoList( &aList );
+/*N*/             	if ( !aList.Count() && !xStor->IsOLEStorage() )
+/*?*/                 	SetError( ERRCODE_IO_BROKENPACKAGE );
+/*N*/             	else
+/*N*/             	{
+/*N*/                 	BOOL bHasMacros = FALSE;
+/*N*/                 	if ( xStor->IsOLEStorage() )
+/*N*/                     	bHasMacros = BasicManager::HasBasicWithModules(
+                                *xStor,
+                                ::binfilter::StaticBaseUrl::GetBaseURL(
+                                    INetURLObject::NO_DECODE) );
+/*N*/                 	else
+/*?*/                     	bHasMacros = xStor->IsStorage( String::CreateFromAscii("Basic") );
+/*N*/
+/*N*/                 	if ( bHasMacros )
+/*N*/                     	AdjustMacroMode( String() );
+/*N*/ 					else
+/*N*/ 					{
+/*N*/ 						// if macros will be added by the user later, the security check is obsolete
+/*N*/ 						pImp->nMacroMode = MacroExecMode::ALWAYS_EXECUTE_NO_WARN;
+/*N*/ 					}
+/*N*/             	}
+/*N*/         	}
+/*N*/
+/*N*/         	// Load
+/*N*/         	if ( !GetError() )
+/*N*/         	{
+/*N*/             	const String aOldURL( ::binfilter::StaticBaseUrl::GetBaseURL() );
+/*N*/             	if( aBaseURL.Len() ) ::binfilter::StaticBaseUrl::SetBaseURL( aBaseURL );
+/*N*/             	pImp->nLoadedFlags = 0;
+/*N*/             	bOk = xStor.Is() && LoadOwnFormat( *pMed );
+/*N*/             	::binfilter::StaticBaseUrl::SetBaseURL( aOldURL );
+/*N*/             	if ( bOk )
+/*N*/             	{
+/*N*/                 	GetDocInfo().Load(xStor);
+/*N*/                 	bHasName = sal_True;
+/*N*/             	}
+/*N*/             	else
+/*?*/                 	SetError( ERRCODE_ABORT );
+/*N*/         	}
+/*N*/ 		}
+/*N*/      else
+/*?*/ 			SetError( pMed->GetLastStorageCreationState() );
+/*N*/    }
+         else if ( GetError() == ERRCODE_NONE && InitNew(0) )
+/*?*/    {
+/*?*/        // Name vor ConvertFrom setzen, damit GetSbxObject() schon funktioniert
+/*?*/        bHasName = sal_True;
+/*?*/
+/*?*/        // Importieren
+/*?*/        const String aOldURL( ::binfilter::StaticBaseUrl::GetBaseURL() );
+/*?*/        if( aBaseURL.Len() ) ::binfilter::StaticBaseUrl::SetBaseURL( aBaseURL );
+/*?*/         if( !pMedium->GetFilter()->UsesStorage() )
+/*?*/            pMedium->GetInStream();
+/*?*/         else
+/*?*/             pMedium->GetStorage();
+/*?*/
+/*?*/        pImp->nLoadedFlags = 0;
+/*?*/        bOk = ConvertFrom(*pMedium);
+/*?*/
+/*?*/        ::binfilter::StaticBaseUrl::SetBaseURL( aOldURL );
+/*?*/
+/*?*/         if( bOk && pMedium->GetOpenMode() & STREAM_WRITE )
+/*?*/        //Medium offen halten um andere Zugriffe zu verhindern
+/*?*/        {
+/*?*/            if(pMedium->GetFilter() && pMedium->GetFilter()->UsesStorage())
+/*?*/            {
+/*?*/                pMedium->GetStorage();
+/*?*/                if( pMedium->GetLastStorageCreationState() != ERRCODE_NONE )
+/*?*/                    pMedium->SetError( pMedium->GetLastStorageCreationState() );
+/*?*/            }
+/*?*/            else
+/*?*/                pMedium->GetInStream();
+/*?*/            if(pMedium->GetError())
+/*?*/                bOk = sal_False;
+/*?*/        }
+/*?*/    }
+/*N*/
+/*N*/  if ( bOk )
+/*N*/  {
+/*N*/         try
+/*?*/ /*N*/         {
+/*?*/             ::ucbhelper::Content aContent( pMedium->GetName(), ::com::sun::star::uno::Reference < XCommandEnvironment >() );
+/*?*/             ::com::sun::star::uno::Reference < XPropertySetInfo > xProps = aContent.getProperties();
+/*?*/             if ( xProps.is() )
+/*?*/             {
+/*?*/                 ::rtl::OUString aAuthor( RTL_CONSTASCII_USTRINGPARAM("Author") );
+/*?*/                 ::rtl::OUString aKeywords( RTL_CONSTASCII_USTRINGPARAM("Keywords") );
+/*?*/                 ::rtl::OUString aSubject( RTL_CONSTASCII_USTRINGPARAM("Subject") );
+/*?*/                 Any aAny;
+/*?*/                 ::rtl::OUString aValue;
+/*?*/                 SfxDocumentInfo& rInfo = GetDocInfo();
+/*?*/                 if ( xProps->hasPropertyByName( aAuthor ) )
+/*?*/                 {
+/*?*/                     aAny = aContent.getPropertyValue( aAuthor );
+/*?*/                     if ( ( aAny >>= aValue ) )
+/*?*/                         rInfo.SetCreated( SfxStamp( String( aValue ) ) );
+/*?*/                 }
+/*?*/                 if ( xProps->hasPropertyByName( aKeywords ) )
+/*?*/                 {
+/*?*/                     aAny = aContent.getPropertyValue( aKeywords );
+/*?*/                     if ( ( aAny >>= aValue ) )
+/*?*/                         rInfo.SetKeywords( aValue );
+/*?*/                 }
+/*?*/                 if ( xProps->hasPropertyByName( aSubject ) )
+/*?*/                 {
+/*?*/                     aAny = aContent.getPropertyValue( aSubject );
+/*?*/                     if ( ( aAny >>= aValue ) )
+/*?*/                         rInfo.SetTheme( aValue );
+/*?*/                 }
+/*?*/             }
+/*?*/         }
+/*N*/         catch( Exception& )
+/*N*/         {
+/*N*/         }
+/*N*/
+/*N*/         ::rtl::OUString aTitle = GetTitle( SFX_TITLE_DETECT );
+/*N*/
+/*N*/ 		// Falls nicht asynchron geladen wird selbst FinishedLoading aufrufen
+/*N*/ 		if ( !( pImp->nLoadedFlags & SFX_LOADED_MAINDOCUMENT ) &&
+/*N*/             ( !pMedium->GetFilter() ||
+/*N*/                pMedium->GetFilter()->UsesStorage() ||
+/*N*/                !( pMedium->GetFilter()->GetFilterFlags() & SFX_FILTER_ASYNC ) ) )
+/*N*/ 			FinishedLoading( SFX_LOADED_MAINDOCUMENT );
+/*N*/
+/*N*/ 		if ( pSalvageItem )
+/*N*/ 		{
+/*?*/             pImp->aTempName = pMedium->GetPhysicalName();
+/*?*/ 			pMedium->GetItemSet()->ClearItem( SID_DOC_SALVAGE );
+/*?*/ 			pMedium->GetItemSet()->ClearItem( SID_FILE_NAME );
+/*N*/ 		}
+/*N*/ 		else
+/*N*/ 		{
+/*N*/ 			pMedium->GetItemSet()->ClearItem( SID_PROGRESS_STATUSBAR_CONTROL );
+/*N*/ 			pMedium->GetItemSet()->ClearItem( SID_DOCUMENT );
+/*N*/ 		}
+/*N*/
+/*N*/ 		pMedium->GetItemSet()->ClearItem( SID_REFERER );
+/*N*/ 		::com::sun::star::uno::Reference< ::com::sun::star::frame::XModel >  xModel ( GetModel(), ::com::sun::star::uno::UNO_QUERY );
+/*N*/ 		if ( xModel.is() )
+/*N*/ 		{
+/*N*/ 			::rtl::OUString aURL = GetMedium()->GetOrigURL();
+/*N*/ 			SfxItemSet *pSet = GetMedium()->GetItemSet();
+/*N*/             if ( !GetMedium()->IsReadOnly() )
+/*N*/                 pSet->ClearItem( SID_INPUTSTREAM );
+/*N*/ 			::com::sun::star::uno::Sequence< ::com::sun::star::beans::PropertyValue > aArgs;
+/*N*/ 			TransformItems( SID_OPENDOC, *pSet, aArgs );
+/*N*/ 			xModel->attachResource( aURL, aArgs );
+/*N*/ 		}
+/*N*/
+/*N*/         if( IsOwnStorageFormat_Impl(*pMed) && pMed->GetFilter() )
+/*N*/ 		{
+/*N*/ //???? dv			DirEntry aDirEntry( pMed->GetPhysicalName() );
+/*N*/ //???? dv			SetFileName( aDirEntry.GetFull() );
+/*N*/ 		}
+/*N*/ 		Broadcast( SfxSimpleHint(SFX_HINT_NAMECHANGED) );
+/*N*/ 	}
+/*N*/
+/*N*/ 	if ( SFX_CREATE_MODE_EMBEDDED != eCreateMode )
+/*N*/ 	{
+/*N*/ 		GetpApp()->HideStatusText();
+/*N*/ 	}
+/*N*/
+/*N*/ 	return bOk;
+/*N*/ }
+
+/*N*/ sal_uInt32 SfxObjectShell::HandleFilter( SfxMedium* pMedium, SfxObjectShell* pDoc )
+/*N*/ {
+/*N*/ 	sal_uInt32 nError = ERRCODE_NONE;
+/*N*/ 	SfxItemSet* pSet = pMedium->GetItemSet();
+/*N*/ 	SFX_ITEMSET_ARG( pSet, pOptions, SfxStringItem, SID_FILE_FILTEROPTIONS, sal_False );
+/*N*/ 	SFX_ITEMSET_ARG( pSet, pData, SfxUsrAnyItem, SID_FILTER_DATA, sal_False );
+/*N*/ 	if ( !pData && !pOptions )
+/*N*/ 	{
+/*N*/     	::com::sun::star::uno::Reference< XMultiServiceFactory > xServiceManager = ::legacy_binfilters::getLegacyProcessServiceFactory();
+/*N*/ 		::com::sun::star::uno::Reference< XNameAccess > xFilterCFG;
+/*N*/ 		if( xServiceManager.is() )
+/*N*/ 		{
+/*N*/ 			xFilterCFG = ::com::sun::star::uno::Reference< XNameAccess >(
+/*N*/ 				xServiceManager->createInstance( ::rtl::OUString::createFromAscii( "com.sun.star.document.FilterFactory" ) ),
+/*N*/ 				UNO_QUERY );
+/*N*/ 		}
+/*N*/
+/*N*/ 		if( xFilterCFG.is() )
+/*N*/     	{
+/*N*/         	BOOL bAbort = FALSE;
+/*N*/         	try {
+/*N*/ 				const SfxFilter* pFilter = pMedium->GetFilter();
+/*N*/             	Sequence < PropertyValue > aProps;
+/*N*/             	Any aAny = xFilterCFG->getByName( pFilter->GetName() );
+/*N*/             	if ( aAny >>= aProps )
+/*N*/             	{
+/*N*/                 	::rtl::OUString aServiceName;
+/*N*/                 	sal_Int32 nPropertyCount = aProps.getLength();
+/*N*/                 	for( sal_Int32 nProperty=0; nProperty < nPropertyCount; ++nProperty )
+/*N*/                     	if( aProps[nProperty].Name.equals( ::rtl::OUString::createFromAscii("UIComponent")) )
+/*N*/                     	{
+/*N*/                         	::rtl::OUString aServiceName;
+/*N*/                         	aProps[nProperty].Value >>= aServiceName;
+/*N*/                         	if( aServiceName.getLength() )
+/*?*/                         	{
+/*?*/ 								::com::sun::star::uno::Reference< XInteractionHandler > rHandler = pMedium->GetInteractionHandler();
+/*?*/ 								if( rHandler.is() )
+/*?*/ 								{
+/*?*/ 									// we need some properties in the media descriptor, so we have to make sure that they are in
+/*?*/ 									Any aAny;
+/*?*/ 									aAny <<= pMedium->GetInputStream();
+/*?*/ 									if ( pSet->GetItemState( SID_INPUTSTREAM ) < SFX_ITEM_SET )
+/*?*/ 									pSet->Put( SfxUsrAnyItem( SID_INPUTSTREAM, aAny ) );
+/*?*/ 									if ( pSet->GetItemState( SID_FILE_NAME ) < SFX_ITEM_SET )
+/*?*/ 										pSet->Put( SfxStringItem( SID_FILE_NAME, pMedium->GetName() ) );
+/*?*/ 									if ( pSet->GetItemState( SID_FILTER_NAME ) < SFX_ITEM_SET )
+/*?*/ 										pSet->Put( SfxStringItem( SID_FILTER_NAME, pFilter->GetName() ) );
+/*?*/
+/*?*/ 									Sequence< PropertyValue > rProperties;
+/*?*/                                 	TransformItems( SID_OPENDOC, *pSet, rProperties );
+/*?*/ 									RequestFilterOptions* pFORequest = new RequestFilterOptions( pDoc->GetModel(), rProperties );
+/*?*/
+/*?*/ 									::com::sun::star::uno::Reference< XInteractionRequest > rRequest( pFORequest );
+/*?*/ 									rHandler->handle( rRequest );
+/*?*/
+/*?*/ 									if ( !pFORequest->isAbort() )
+/*?*/ 									{
+/*?*/                                    		SfxAllItemSet aNewParams( pDoc->GetPool() );
+/*?*/                                    		TransformParameters( SID_OPENDOC,
+/*?*/ 														 	pFORequest->getFilterOptions(),
+/*?*/                                                          	aNewParams );
+/*?*/
+/*?*/                                    		SFX_ITEMSET_ARG( &aNewParams,
+/*?*/ 													 	pOptions,
+/*?*/ 													 	SfxStringItem,
+/*?*/ 													 	SID_FILE_FILTEROPTIONS,
+/*?*/ 													 	sal_False );
+/*?*/                                    		if ( pOptions )
+/*?*/                                        		pSet->Put( *pOptions );
+/*?*/
+/*?*/                                    		SFX_ITEMSET_ARG( &aNewParams,
+/*?*/ 													 	pData,
+/*?*/ 													 	SfxUsrAnyItem,
+/*?*/ 													 	SID_FILTER_DATA,
+/*?*/ 													 	sal_False );
+/*?*/                                    		if ( pData )
+/*?*/                                        		pSet->Put( *pData );
+/*?*/ 									}
+/*?*/                                 	else
+/*?*/                                     	bAbort = TRUE;
+/*?*/ 								}
+/*?*/                         	}
+/*N*/
+/*N*/                         	break;
+/*N*/                     	}
+/*N*/             	}
+/*N*/
+/*N*/             	if( bAbort )
+/*N*/ 				{
+/*N*/ 					// filter options were not entered
+/*N*/ 					nError = ERRCODE_ABORT;
+/*N*/ 				}
+/*N*/         	}
+/*N*/         	catch( NoSuchElementException& )
+/*N*/         	{
+/*N*/             	// the filter name is unknown
+/*N*/             	nError = ERRCODE_IO_INVALIDPARAMETER;
+/*N*/         	}
+/*N*/         	catch( Exception& )
+/*N*/         	{
+/*N*/ 				nError = ERRCODE_ABORT;
+/*N*/         	}
+/*N*/     	}
+/*N*/ 	}
+/*N*/
+/*N*/ 	return nError;
+/*N*/ }
+
+//-------------------------------------------------------------------------
+
+/*N*/ sal_Bool SfxObjectShell::IsOwnStorageFormat_Impl(const SfxMedium &rMedium) const
+/*N*/ {
+/*N*/ 	return !rMedium.GetFilter() || // Embedded
+/*N*/ 		   ( rMedium.GetFilter()->IsOwnFormat() &&
+/*N*/ 			 rMedium.GetFilter()->UsesStorage() );
+/*N*/ }
+
+//-------------------------------------------------------------------------
+
+/*N*/ sal_Bool SfxObjectShell::DoSave()
+// DoSave wird nur noch ueber OLE aufgerufen. Sichern eigener Dokumente im SFX
+// laeuft uber DoSave_Impl, um das Anlegen von Backups zu ermoeglichen.
+// Save in eigenes Format jetzt auch wieder Hierueber
+/*N*/ {
+/*N*/ 	sal_Bool bOk = sal_False ;
+/*N*/ 	{
+/*N*/ 		ModifyBlocker_Impl aBlock( this );
+/*N*/ 		SfxForceLinkTimer_Impl aFLT( this );
+/*N*/ 		pImp->bIsSaving = sal_True;
+/*N*/ 		String aPasswd;
+/*N*/ 		if ( IsOwnStorageFormat_Impl( *GetMedium() ) &&
+/*N*/ 			 GetPasswd_Impl( GetMedium()->GetItemSet(), aPasswd ) )
+/*N*/ 			GetMedium()->GetStorage()->SetKey( S2BS( aPasswd ) );	//!!! (pb) needs new implementation
+/*N*/ 		GetStorage()->SetVersion( GetMedium()->GetFilter()->GetVersion() );
+/*N*/ 		bOk = Save();
+/*N*/ 	}
+
+//#88046
+//    if ( bOk )
+//        SetModified( sal_False );
+/*N*/ 	return bOk;
+/*N*/ }
+
+/*N*/ void Lock_Impl( SfxObjectShell* pDoc, BOOL bLock )
+/*N*/ {
+/*N*/ }
+
+//-------------------------------------------------------------------------
+
+/*N*/ sal_Bool SfxObjectShell::SaveTo_Impl
+/*N*/ (
+/*N*/ 	 SfxMedium &rMedium, // Medium, in das gespeichert werden soll
+/*N*/      const SfxItemSet* pSet,
+/*N*/      BOOL bPrepareForDirectAccess
+/*N*/ )
+
+/*  [Beschreibung]
+
+    Schreibt den aktuellen Inhalt in das Medium rMedium.
+    Ist das Zielmedium kein Storage, so wird ueber ein temporaeres
+    Medium gespeichert, sonst direkt, da das Medium transacted
+    geschaltet ist, wenn wir es selbst geoeffnet haben und falls wir
+    Server sind entweder der Container einen transacted Storage zur
+    Verfuegung stellt oder selbst einen temporaeren Storage erzeugt hat.
+*/
+
+/*N*/ {
+/*N*/ 	SfxForceLinkTimer_Impl aFLT( this );
+/*N*/     EnableSetModified( FALSE );
+/*N*/
+/*N*/ 	const SfxFilter *pFilter = rMedium.GetFilter();
+/*N*/ 	if ( !pFilter )
+/*N*/ 	{
+/*N*/         // if no filter was set, use the default filter
+/*N*/         // this should be changed in the feature, it should be an error!
+/*?*/ 		pFilter = GetFactory().GetFilter(0);
+/*?*/ 		rMedium.SetFilter(pFilter);
+/*N*/ 	}
+/*N*/
+/*N*/     if( pFilter->UsesStorage() )
+/*N*/         // create an output storage in the correct format
+/*N*/         rMedium.GetOutputStorage( SOFFICE_FILEFORMAT_60 <= pFilter->GetVersion() );
+/*N*/ 	else
+/*?*/ 		rMedium.GetOutStream();
+/*N*/
+/*N*/ 	if( rMedium.GetErrorCode() )
+/*N*/ 		return sal_False;
+/*N*/
+/*N*/ 	sal_Bool bOldStat = pImp->bForbidReload;
+/*N*/ 	pImp->bForbidReload = sal_True;
+/*N*/
+/*N*/     // lock user interface while saving the document
+/*N*/     Lock_Impl( this, sal_True );
+/*N*/
+/*N*/ 	sal_Bool bOk = sal_False;
+/*N*/	if( sal_True ) // STRIP003 IsOwnStorageFormat_Impl(rMedium) && !(pFilter->GetFilterFlags() & SFX_FILTER_STARONEFILTER))
+/*N*/ 	{
+/*N*/ 		SvStorageRef aMedRef = rMedium.GetStorage();
+/*N*/ 		if ( !aMedRef.Is() )
+/*N*/         {
+/*?*/             // no saving without storage, unlock UI and return
+/*?*/             Lock_Impl( this, sal_False );
+/*?*/ 			return sal_False;
+/*N*/         }
+/*N*/
+/*N*/         // transfer password from the parameters to the storage
+/*N*/         String aPasswd;
+/*N*/ 		if ( GetPasswd_Impl( rMedium.GetItemSet(), aPasswd ) )
+/*N*/ 			aMedRef->SetKey( S2BS( aPasswd ) ); //!!! (pb) needs new implementation
+/*N*/
+/*N*/ 		const SfxFilter* pFilter = rMedium.GetFilter();
+/*N*/ 		if(  ((SvStorage *)aMedRef) == ((SvStorage *)GetStorage() ) )
+/*N*/ 		{
+/*N*/             // target storage and object storage are identical, should never happen here
+/*?*/             DBG_ERROR( "Saving storage without copy!");
+/*?*/ 			aMedRef->SetVersion( pFilter->GetVersion() );
+/*?*/ 			bOk = Save();
+/*N*/ 		}
+/*N*/ 		else
+/*N*/             // save to target
+/*N*/ 			bOk = SaveAsOwnFormat( rMedium );
+/*N*/
+/*N*/         // look for a "version" parameter
+/*N*/ 		const SfxStringItem *pVersionItem = pSet ? (const SfxStringItem*)
+/*N*/             SfxRequest::GetItem( pSet, SID_DOCINFO_COMMENTS, sal_False, TYPE(SfxStringItem) ) : NULL;
+/*N*/
+/*N*/ 		if ( pVersionItem )
+/*N*/ 		{DBG_BF_ASSERT(0, "STRIP"); //STRIP001
+/*N*/ 		}
+/*N*/ 		else if ( pImp->bIsSaving )
+/*N*/ 		{DBG_BF_ASSERT(0, "STRIP"); //STRIP001
+/*N*/ 		}
+/*N*/ 	}
+//STRIP003/*N*/ 	else
+//STRIP003/*N*/ 	{
+//STRIP003/*?*/         // it's a "SaveAs" in an alien format
+//STRIP003/*?*/ 		if ( rMedium.GetFilter() && ( rMedium.GetFilter()->GetFilterFlags() & SFX_FILTER_STARONEFILTER ) )
+//STRIP003/*?*/             bOk = ExportTo( rMedium );
+//STRIP003/*?*/ 		else
+//STRIP003/*?*/             bOk = ConvertTo( rMedium );
+//STRIP003/*?*/
+//STRIP003/*?*/         // after saving the document, the temporary object storage must be updated
+//STRIP003/*?*/         // if the old object storage was not a temporary one, it will be updated also, because it will be used
+//STRIP003/*?*/         // as a source for copying the objects into the new temporary storage that will be created below
+//STRIP003/*?*/         // updating means: all child objects must be stored into it
+//STRIP003/*?*/         // ( same as on loading, where these objects are copied to the temporary storage )
+//STRIP003/*?*/         // but don't commit these changes, because in the case when the old object storage is not a temporary one,
+//STRIP003/*?*/         // all changes will be written into the original file !
+//STRIP003/*?*/         if( bOk )
+//STRIP003/*?*/             bOk = SaveChilds() && SaveCompletedChilds( NULL );
+//STRIP003/*N*/ 	}
+
+    // SetModified must be enabled when SaveCompleted is called, otherwise the modified flag of child objects will not be cleared
+/*N*/     EnableSetModified( sal_True );
+/*N*/
+/*N*/     sal_Bool bCopyTo = sal_False;
+/*N*/     SfxItemSet *pMedSet = rMedium.GetItemSet();
+/*N*/     if( pMedSet )
+/*N*/     {
+/*N*/         SFX_ITEMSET_ARG( pMedSet, pSaveToItem, SfxBoolItem, SID_SAVETO, sal_False );
+/*N*/         bCopyTo =   GetCreateMode() == SFX_CREATE_MODE_EMBEDDED ||
+/*N*/                     pSaveToItem && pSaveToItem->GetValue();
+/*N*/     }
+/*N*/
+/*N*/     if( bOk )
+/*N*/ 	{
+/*N*/         // remember new object storage, if it is a temporary one, because we will need it for a "SaveCompleted" later
+/*N*/         SvStorageRef xNewTempRef;
+/*N*/         if ( bOk && bPrepareForDirectAccess )
+/*N*/         {
+/*N*/             // if the target medium is an alien format and the "old" medium was an own format, the object storage
+/*N*/             // must be exchanged, because now we need a new temporary storage as object storage
+/*N*/             BOOL bNeedsStorage = !bCopyTo && IsOwnStorageFormat_Impl(*pMedium) && !IsOwnStorageFormat_Impl(rMedium);
+/*N*/             if ( bNeedsStorage )
+/*N*/             {
+/*?*/                 if( !pMedium->GetName().Len() )
+/*?*/                     // if the old object storage was a temporary one too, we can continue with it
+/*?*/                     xNewTempRef = GetStorage();
+/*?*/                 else
+/*?*/                 {
+/*?*/                     // copy storage of old medium to new temporary storage and take this over
+/*?*/                     if( ConnectTmpStorage_Impl( pMedium->GetStorage() ) )
+/*?*/                         xNewTempRef = GetStorage();
+/*?*/                     else
+/*?*/                         bOk = sal_False;
+/*?*/                 }
+/*N*/             }
+/*N*/
+/*N*/             // When the new medium ( rMedium ) has the same name as the current one,
+/*N*/             // we need to call DoHandsOff() so Commit() can overwrite the old version
+/*N*/             if ( bOk && pMedium && ( rMedium.GetName().EqualsIgnoreCaseAscii( pMedium->GetName() ) )
+/*N*/ 			  && rMedium.GetName().CompareIgnoreCaseToAscii( "private:stream", 14 ) != COMPARE_EQUAL )
+/*?*/                 DoHandsOff();
+/*N*/         }
+/*N*/
+/*N*/         if ( bOk && pMedium && ( rMedium.GetName() == pMedium->GetName() ) )
+/*N*/         {
+/*N*/             // before we overwrite the original file, we will make a backup if there is a demand for that
+/*N*/             const sal_Bool bDoBackup = SvtSaveOptions().IsBackup();
+/*N*/             if ( bDoBackup )
+/*N*/ 			{{DBG_BF_ASSERT(0, "STRIP");}//STRIP001
+/*N*/ 			}
+/*N*/         }
+/*N*/
+/*N*/         if ( bOk )
+/*N*/         {
+/*N*/             // transfer data to its destinated location
+/*N*/             EnableSetModified( sal_False );
+/*N*/             RegisterTransfer( rMedium );
+/*N*/             bOk = rMedium.Commit();
+/*N*/             EnableSetModified( sal_True );
+/*N*/
+/*N*/ 			if ( bOk )
+/*N*/ 			{
+/*N*/             	// watch: if the document was successfully saved into an own format, no "SaveCompleted" was called,
+/*N*/             	// this must be done by the caller ( because they want to do different calls )
+/*N*/ 				if( xNewTempRef.Is() && xNewTempRef != GetStorage() )
+/*N*/                 	// if the new object storage is a temporary one, because the target format is an alien format
+/*?*/                 	SaveCompleted( xNewTempRef );
+/*N*/ 			}
+/*N*/ 			else
+/*N*/ 			{
+/*?*/ 				// if the storing process fails on medium commit step it means that
+/*?*/ 				// the new medium should contain successfully written temporary representation
+/*?*/ 				// of the document, so the docshell can just switch to new medium.
+/*?*/ 				// it is reasonable in case an open document suddenly became unavailable.
+/*?*/
+/*?*/ 				OUString aOrigName = pMedium ? OUString(pMedium->GetName()) : OUString();
+/*?*/ 				if ( aOrigName.getLength() && aOrigName.compareToAscii( "private:", 8 ) != COMPARE_EQUAL
+/*?*/ 				  	&& !::utl::UCBContentHelper::Exists( aOrigName ) )
+/*?*/ 				{DBG_BF_ASSERT(0, "STRIP");//STRIP001
+/*?*/ 				}
+/*N*/ 			}
+/*N*/         }
+/*N*/ 	}
+/*N*/
+/*N*/     // unlock user interface
+/*N*/     Lock_Impl( this, sal_False );
+/*N*/     pImp->bForbidReload = bOldStat;
+/*N*/
+/*N*/     if ( bOk )
+/*N*/     {
+/*N*/         DBG_ASSERT( pFilter, "No filter after successful save?!" );
+/*N*/         if( pFilter )
+/*N*/             if( !bCopyTo && pFilter->IsAlienFormat() )
+/*N*/                 // set flag, that the user will be warned for possible data loss on closing this document
+/*N*/                 pImp->bDidDangerousSave=sal_True;
+/*N*/             else
+/*?*/                 pImp->bDidDangerousSave=sal_False;
+/*N*/
+/*N*/
+/*N*/         try
+/*N*/         {
+/*?*/             ::ucbhelper::Content aContent( rMedium.GetName(), ::com::sun::star::uno::Reference < XCommandEnvironment >() );
+/*?*/             ::com::sun::star::uno::Reference < XPropertySetInfo > xProps = aContent.getProperties();
+/*?*/             if ( xProps.is() )
+/*?*/             {
+/*?*/                 ::rtl::OUString aAuthor( RTL_CONSTASCII_USTRINGPARAM("Author") );
+/*?*/                 ::rtl::OUString aKeywords( RTL_CONSTASCII_USTRINGPARAM("Keywords") );
+/*?*/                 ::rtl::OUString aSubject( RTL_CONSTASCII_USTRINGPARAM("Subject") );
+/*?*/                 Any aAny;
+/*?*/                 if ( xProps->hasPropertyByName( aAuthor ) )
+/*?*/                 {
+/*?*/                     aAny <<= ::rtl::OUString( GetDocInfo().GetCreated().GetName() );
+/*?*/                     aContent.setPropertyValue( aAuthor, aAny );
+/*?*/                 }
+/*?*/                 if ( xProps->hasPropertyByName( aKeywords ) )
+/*?*/                 {
+/*?*/                     aAny <<= ::rtl::OUString( GetDocInfo().GetKeywords() );
+/*?*/                     aContent.setPropertyValue( aKeywords, aAny );
+/*?*/                 }
+/*?*/                 if ( xProps->hasPropertyByName( aSubject ) )
+/*?*/                 {
+/*?*/                     aAny <<= ::rtl::OUString( GetDocInfo().GetTheme() );
+/*?*/                     aContent.setPropertyValue( aSubject, aAny );
+/*?*/                 }
+/*?*/             }
+/*N*/         }
+/*N*/         catch( Exception& )
+/*N*/         {
+/*N*/         }
+/*N*/     }
+/*N*/
+/*N*/ 	return bOk;
+/*N*/ }
+
+//------------------------------------------------------------------------
+
+/*?*/ sal_Bool SfxObjectShell::ConnectTmpStorage_Impl( SvStorage* pStg)
+
+/*   [Beschreibung]
+
+     Arbeitet die Applikation auf einem temporaeren Storage,
+     so darf der temporaere Storage nicht aus dem SaveCompleted
+     genommen werden. Daher wird in diesem Fall schon hier an
+     den neuen Storage connected. SaveCompleted tut dann nichts.
+
+     */
+
+/*?*/ {
+/*?*/ 	// wenn es kein temp. Storage ist, einen anlegen
+/*?*/     SvStorageRef aTmpMed = new SvStorage( (pStg->GetVersion() >= SOFFICE_FILEFORMAT_60), String() );
+/*?*/
+/*?*/ 	// nach HandsOff muss der alte Storage wieder eingesetzt werden
+/*?*/ 	if ( !pStg->CopyTo(aTmpMed) )
+/*?*/ 	{
+/*?*/ 		SetError(aTmpMed->GetErrorCode());
+/*?*/ 		aTmpMed.Clear();
+/*?*/ 		return sal_False;
+/*?*/ 	}
+/*?*/
+/*?*/ 	SetError(GetMedium()->GetErrorCode());
+/*?*/ 	SaveCompleted(aTmpMed); // neuer temp. Storage; gibt alten frei
+/*?*/ 	return sal_True;
+/*?*/ }
+
+
+//-------------------------------------------------------------------------
+
+/*N*/ sal_Bool SfxObjectShell::DoSaveAs( SvStorage * pNewStor )
+/*N*/ {
+/*N*/ // DoSaveAs wird nur noch ueber OLE aufgerufen
+/*N*/ 	sal_Bool bOk;
+/*N*/ 	{
+/*N*/ 		SfxForceLinkTimer_Impl aFLT( this );
+/*N*/ 		ModifyBlocker_Impl aBlock( this );
+/*N*/ 		//Abwehr gegen feindlich gesinnte Applikationen.
+/*N*/ 		if ( !pNewStor->GetFormat() )
+/*N*/ 			SetupStorage( pNewStor );
+/*N*/
+/*N*/ 		pImp->bIsSaving = sal_False;
+/*N*/ 		SfxMedium* pNewMed = new SfxMedium( pNewStor );
+/*N*/ 		const String aOldURL( ::binfilter::StaticBaseUrl::GetBaseURL() );
+/*N*/
+/*N*/ 		bOk = SaveAsOwnFormat( *pNewMed );
+/*N*/ 		::binfilter::StaticBaseUrl::SetBaseURL( aOldURL );
+/*N*/ 		delete pNewMed;
+/*N*/ 	}
+/*N*/ 	return bOk;
+/*N*/ }
+
+//-------------------------------------------------------------------------
+
+/*N*/ sal_Bool SfxObjectShell::DoSaveCompleted( SfxMedium * pNewMed )
+/*N*/ {
+    sal_Bool bOk = sal_True;
+    sal_Bool bMedChanged = pNewMed && pNewMed!=pMedium;
+/*	sal_Bool bCreatedTempStor = pNewMed && pMedium &&
+        IsOwnStorageFormat_Impl(*pMedium) &&
+        !IsOwnStorageFormat_Impl(*pNewMed) &&
+        pMedium->GetName().Len();
+*/
+/*N*/     DBG_ASSERT( !pNewMed || pNewMed->GetError() == ERRCODE_NONE, "DoSaveCompleted: Medium has error!" );
+/*N*/ 	if ( bMedChanged )
+/*N*/ 	{
+/*N*/ 		delete pMedium;
+/*N*/ 		pMedium = pNewMed;
+/*N*/ 		//MI? DELETEZ(pImp->pDocInfo);
+/*N*/ 	}
+/*N*/
+/*N*/ 	const SfxFilter *pFilter = pMedium ? pMedium->GetFilter() : 0;
+/*N*/ 	if ( pNewMed )
+/*N*/ 	{
+/*N*/ 		if( bMedChanged )
+/*N*/ 		{
+/*N*/ 			if( pNewMed->GetName().Len() )
+/*N*/ 				bHasName = sal_True;
+/*N*/ 			String aBase = GetBaseURL();
+/*N*/ 			if( Current() == this && aBase.Len() )
+/*N*/ 				::binfilter::StaticBaseUrl::SetBaseURL( aBase );
+/*N*/ 			Broadcast( SfxSimpleHint(SFX_HINT_NAMECHANGED) );
+/*N*/ 		}
+/*N*/
+/*N*/ 		SvStorage *pStorage=NULL;
+/*N*/ 		if ( !pFilter||sal_True  ) //STRIP007 if ( !pFilter || pFilter->IsOwnFormat() )
+/*N*/ 		{
+/*N*/ 			pStorage = pMedium->GetStorage();
+/*N*/ 			bOk = SaveCompleted( pStorage );
+/*N*/ 		}
+/*N*/ 		else
+/*N*/ 		{
+/*?*/ 			pStorage = GetStorage();
+/*?*/ 			if( pFilter->UsesStorage() )
+/*?*/ 				pMedium->GetStorage();
+/*?*/ 			else if( pMedium->GetOpenMode() & STREAM_WRITE )
+/*?*/ 				pMedium->GetInStream();
+/*N*/ 		}
+/*N*/
+/*N*/ 		// Set storage in document library containers
+/*N*/ 		SfxDialogLibraryContainer* pDialogCont = pImp->pDialogLibContainer;
+/*N*/ 		if( pDialogCont )
+/*N*/ 			pDialogCont->setStorage( pStorage );
+/*N*/
+/*N*/ 		SfxScriptLibraryContainer* pBasicCont = pImp->pBasicLibContainer;
+/*N*/ 		if( pBasicCont )
+/*N*/ 			pBasicCont->setStorage( pStorage );
+/*N*/ 	}
+/*N*/ 	else
+/*N*/ 	{
+/*N*/ 		if( pMedium )
+/*N*/ 		{
+/*N*/ 			const SfxFilter* pFilter = pMedium->GetFilter();
+/*N*/ 			if( pFilter && !pFilter->IsOwnFormat() &&
+/*N*/ 				(pMedium->GetOpenMode() & STREAM_WRITE ))
+/*N*/ 				 pMedium->ReOpen();
+/*N*/ 			else
+/*N*/ 				SaveCompleted( 0 );
+/*N*/ 		}
+/*N*/ 		// entweder Save oder ConvertTo
+/*N*/ 		else
+/*?*/ 			bOk = SaveCompleted( NULL );
+/*N*/ 	}
+/*N*/
+/*N*/ 	if ( bOk && pNewMed )
+/*N*/ 	{
+/*N*/ 		if( bMedChanged )
+/*N*/ 		{
+/*N*/ 			// Titel neu setzen
+/*N*/ 			if ( pNewMed->GetName().Len() &&
+/*N*/ 				 SFX_CREATE_MODE_EMBEDDED != eCreateMode )
+/*N*/ 				InvalidateName();
+/*N*/ 			SetModified(sal_False); // nur bei gesetztem Medium zur"ucksetzen
+/*N*/             Broadcast( SfxSimpleHint(SFX_HINT_MODECHANGED) );
+/*N*/ 		}
+/*N*/ 	}
+/*N*/
+/*N*/ 	return bOk;
+/*N*/ }
+
+//-------------------------------------------------------------------------
+
+/*N*/ sal_Bool SfxObjectShell::DoSaveCompleted( SvStorage * pNewStor )
+/*N*/ {
+/*N*/ 	return DoSaveCompleted(pNewStor? new SfxMedium( pNewStor ): 0);
+/*N*/ }
+
+//-------------------------------------------------------------------------
+
+/*?*/ sal_Bool SfxObjectShell::ConvertFrom
+/*?*/ (
+/*?*/ 	SfxMedium&  rMedium     /*  <SfxMedium>, welches die Quell-Datei beschreibt
+                                (z.B. Dateiname, <SfxFilter>, Open-Modi etc.) */
+/*?*/ )
+
+/*  [Beschreibung]
+
+    Diese Methode wird zum Laden von Dokumenten "uber alle Filter gerufen,
+    die nicht SFX_FILTER_OWN sind oder f"ur die kein Clipboard-Format
+    registriert wurde (also kein Storage-Format benutzen). Mit anderen Worten:
+    mit dieser Methode wird importiert.
+
+    Das hier zu "offende File sollte "uber 'rMedium' ge"offnet werden,
+    um die richtigen Open-Modi zu gew"ahrleisten. Insbesondere wenn das
+    Format beibehalten wird (nur m"oglich bei SFX_FILTER_SIMULATE oder
+    SFX_FILTER_ONW) mu\s die Datei STREAM_SHARE_DENYWRITE ge"offnet werden.
+
+
+    [R"uckgabewert]
+
+    sal_Bool                sal_True
+                        Das Dokument konnte geladen werden.
+
+                        sal_False
+                        Das Dokument konnte nicht geladen werden, ein
+                        Fehlercode ist mit <SvMedium::GetError()const> zu
+                        erhalten.
+
+
+    [Beispiel]
+
+    sal_Bool DocSh::ConvertFrom( SfxMedium &rMedium )
+    {
+        SvStreamRef xStream = rMedium.GetInStream();
+        if( xStream.is() )
+        {
+            xStream->SetBufferSize(4096);
+            *xStream >> ...;
+
+            // NICHT 'rMedium.CloseInStream()' rufen! File gelockt halten!
+            return SVSTREAM_OK == rMedium.GetError();
+        }
+
+        return sal_False;
+    }
+
+
+    [Querverweise]
+
+    <SfxObjectShell::ConvertTo(SfxMedium&)>
+    <SFX_FILTER_REGISTRATION>
+*/
+/*?*/ {
+/*?*/ 	return sal_False;
+/*?*/ }
+
+//-------------------------------------------------------------------------
+
+/*?*/ sal_Bool SfxObjectShell::ConvertTo
+/*?*/ (
+/*?*/ 	SfxMedium&  rMedium     /*  <SfxMedium>, welches die Ziel-Datei beschreibt
+                                (z.B. Dateiname, <SfxFilter>, Open-Modi etc.) */
+/*?*/ )
+
+/*  [Beschreibung]
+
+    Diese Methode wird zum Speichern von Dokumenten "uber alle Filter gerufen,
+    die nicht SFX_FILTER_OWN sind oder f"ur die kein Clipboard-Format
+    registriert wurde (also kein Storage-Format benutzen). Mit anderen Worten:
+    mit dieser Methode wird exportiert.
+
+    Das hier zu "offende File sollte "uber 'rMedium' ge"offnet werden,
+    um die richtigen Open-Modi zu gew"ahrleisten. Insbesondere wenn das
+    Format beibehalten wird (nur m"oglich bei SFX_FILTER_SIMULATE oder
+    SFX_FILTER_ONW) mu\s die Datei auch nach dem Speichern im Modus
+    STREAM_SHARE_DENYWRITE ge"offnet bleiben.
+
+
+    [R"uckgabewert]
+
+    sal_Bool                sal_True
+                        Das Dokument konnte gespeichert werden.
+
+                        sal_False
+                        Das Dokument konnte nicht gespeichert werden, ein
+                        Fehlercode ist mit <SvMedium::GetError()const> zu
+                        erhalten.
+
+
+    [Beispiel]
+
+    sal_Bool DocSh::ConvertTo( SfxMedium &rMedium )
+    {
+        SvStreamRef xStream = rMedium.GetOutStream();
+        if ( xStream.is() )
+        {
+            xStream->SetBufferSize(4096);
+            *xStream << ...;
+
+            rMedium.CloseOutStream(); // "offnet automatisch wieder den InStream
+            return SVSTREAM_OK == rMedium.GetError();
+        }
+        return sal_False ;
+    }
+
+
+    [Querverweise]
+
+    <SfxObjectShell::ConvertFrom(SfxMedium&)>
+    <SFX_FILTER_REGISTRATION>
+*/
+
+/*?*/ {
+/*?*/ 	return sal_False;
+/*?*/ }
+
+//-------------------------------------------------------------------------
+
+
+/*?*/ sal_Bool SfxObjectShell::DoSave_Impl( const SfxItemSet* pArgs )
+/*?*/ {DBG_BF_ASSERT(0, "STRIP"); return sal_False; //STRIP001
+/*?*/ }
+
+//-------------------------------------------------------------------------
+
+/*?*/ sal_Bool SfxObjectShell::Save_Impl( const SfxItemSet* pSet )
+/*?*/ {DBG_BF_ASSERT(0, "STRIP"); return sal_False;//STRIP001
+/*?*/ }
+
+//-------------------------------------------------------------------------
+
+/*N*/ sal_Bool SfxObjectShell::CommonSaveAs_Impl
+/*N*/ (
+/*N*/ 	const INetURLObject&   aURL,
+/*N*/ 	const String&   aFilterName,
+/*N*/ 	SfxItemSet*     aParams
+/*N*/ )
+/*N*/ {
+/*N*/ 	SFX_APP()->NotifyEvent(SfxEventHint(SFX_EVENT_SAVEASDOC,this));
+/*N*/ 	BOOL bWasReadonly = IsReadOnly();
+/*N*/
+/*N*/ 	if( aURL.HasError() )
+/*N*/ 	{
+/*N*/ 		SetError( ERRCODE_IO_INVALIDPARAMETER );
+/*N*/ 		return sal_False;
+/*N*/ 	}
+/*N*/
+/*N*/     DBG_ASSERT( aURL.GetProtocol() != INET_PROT_NOT_VALID, "Illegal URL!" );
+/*N*/     DBG_ASSERT( aParams->Count() != 0, "fehlerhafte Parameter");
+/*N*/
+/*N*/     SFX_ITEMSET_ARG( aParams, pSaveToItem, SfxBoolItem, SID_SAVETO, sal_False );
+/*N*/     sal_Bool bSaveTo = pSaveToItem ? pSaveToItem->GetValue() : sal_False;
+/*N*/
+/*N*/     const SfxFilter* pFilter = GetFactory().GetFilterContainer()->GetFilter( aFilterName );
+/*N*/     if ( !pFilter
+/*N*/ 		|| !pFilter->CanExport()
+/*N*/ 		|| !bSaveTo && !pFilter->CanImport() )
+/*N*/     {
+/*N*/         SetError( ERRCODE_IO_INVALIDPARAMETER );
+/*N*/         return sal_False;
+/*N*/     }
+/*N*/
+/*N*/ 	pImp->bPasswd = aParams && SFX_ITEM_SET == aParams->GetItemState(SID_PASSWORD);
+/*N*/
+/*N*/ 	SfxMedium *pActMed = GetMedium();
+/*N*/ 	const INetURLObject aActName(pActMed->GetName());
+/*N*/
+/*N*/ 	if ( aURL == aActName
+/*N*/ 		&& aURL != INetURLObject( OUString::createFromAscii( "private:stream" ) ) )
+/*N*/ 	{
+/*?*/ 		if ( IsReadOnly() )
+/*?*/ 		{
+/*?*/ 			SetError(ERRCODE_SFX_DOCUMENTREADONLY);
+/*?*/ 			return sal_False;
+/*?*/ 		}
+/*?*/ 		// gleicher Filter? -> Save()
+/*?*/ 		const SfxFilter *pFilter = pActMed->GetFilter();
+/*?*/         if ( pFilter && pFilter->GetFilterName() == aFilterName )
+/*?*/ 		{
+/*?*/ 			pImp->bIsSaving=sal_False;
+/*?*/ 			if ( aParams )
+/*?*/ 			{
+/*?*/ 				SfxItemSet* pSet = pMedium->GetItemSet();
+/*?*/ 				pSet->ClearItem( SID_PASSWORD );
+/*?*/ 				pSet->Put( *aParams );
+/*?*/ 			}
+/*?*/ 			return DoSave_Impl();
+/*?*/ 		}
+/*N*/ 	}
+
+/*N*/     if( SFX_ITEM_SET != aParams->GetItemState(SID_UNPACK) && SvtSaveOptions().IsSaveUnpacked() )
+/*N*/         aParams->Put( SfxBoolItem( SID_UNPACK, sal_False ) );
+/*N*/
+/*N*/ 	if ( PreDoSaveAs_Impl(aURL.GetMainURL( INetURLObject::NO_DECODE ),aFilterName,aParams))
+/*N*/ 	{
+/*N*/ 		pImp->bWaitingForPicklist = sal_True;
+/*N*/ 		if (!pImp->bSetStandardName)
+/*N*/ 			pImp->bDidWarnFormat=sal_False;
+/*N*/
+/*N*/ 		// Daten am Medium updaten
+/*N*/ 		SfxItemSet *pSet = GetMedium()->GetItemSet();
+/*N*/ 		pSet->ClearItem( SID_INTERACTIONHANDLER );
+/*N*/
+/*N*/ 		if ( !bSaveTo )
+/*N*/ 		{
+/*N*/ 			pSet->ClearItem( SID_REFERER );
+/*N*/ 			pSet->ClearItem( SID_POSTDATA );
+/*N*/ 			pSet->ClearItem( SID_TEMPLATE );
+/*N*/ 			pSet->ClearItem( SID_DOC_READONLY );
+/*N*/ 			pSet->ClearItem( SID_CONTENTTYPE );
+/*N*/ 			pSet->ClearItem( SID_CHARSET );
+/*N*/ 			pSet->ClearItem( SID_FILTER_NAME );
+/*N*/ 			pSet->ClearItem( SID_OPTIONS );
+/*N*/ 			//pSet->ClearItem( SID_FILE_FILTEROPTIONS );
+/*N*/ 			pSet->ClearItem( SID_VERSION );
+/*N*/ 			//pSet->ClearItem( SID_USE_FILTEROPTIONS );
+/*N*/ 			pSet->ClearItem( SID_EDITDOC );
+/*N*/
+/*N*/ 			SFX_ITEMSET_GET( (*aParams), pFilterItem, SfxStringItem, SID_FILTER_NAME, sal_False );
+/*N*/ 			if ( pFilterItem )
+/*N*/ 				pSet->Put( *pFilterItem );
+/*N*/
+/*N*/ 			SFX_ITEMSET_GET( (*aParams), pOptionsItem, SfxStringItem, SID_OPTIONS, sal_False );
+/*N*/ 			if ( pOptionsItem )
+/*N*/ 				pSet->Put( *pOptionsItem );
+/*N*/
+/*N*/ 			SFX_ITEMSET_GET( (*aParams), pFilterOptItem, SfxStringItem, SID_FILE_FILTEROPTIONS, sal_False );
+/*N*/ 			if ( pFilterOptItem )
+/*N*/ 				pSet->Put( *pFilterOptItem );
+/*N*/ 		}
+/*N*/
+/*N*/ 		SFX_APP()->NotifyEvent(SfxEventHint(SFX_EVENT_SAVEASDOCDONE,this));
+/*N*/
+/*N*/ 		if ( bWasReadonly && !bSaveTo )
+/*N*/ 			Broadcast( SfxSimpleHint(SFX_HINT_MODECHANGED) );
+/*N*/
+/*N*/ 		return sal_True;
+/*N*/ 	}
+/*N*/ 	else
+/*N*/ 		return sal_False;
+/*N*/ }
+
+//-------------------------------------------------------------------------
+
+/*N*/ sal_Bool SfxObjectShell::PreDoSaveAs_Impl
+/*N*/ (
+/*N*/ 	const String&   rFileName,
+/*N*/ 	const String&   aFilterName,
+/*N*/ 	SfxItemSet*     pParams
+/*N*/ )
+/*N*/ {
+/*N*/     // copy all items stored in the itemset of the current medium
+/*N*/     SfxAllItemSet* pMergedParams = new SfxAllItemSet( *pMedium->GetItemSet() );
+/*N*/
+/*N*/     // in "SaveAs" title and password will be cleared ( maybe the new itemset contains new values, otherwise they will be empty )
+/*N*/ 	pMergedParams->ClearItem( SID_PASSWORD );
+/*N*/ 	pMergedParams->ClearItem( SID_DOCINFO_TITLE );
+/*N*/
+/*N*/ 	pMergedParams->ClearItem( SID_INPUTSTREAM );
+/*N*/ 	pMergedParams->ClearItem( SID_CONTENT );
+/*N*/
+/*N*/ 	pMergedParams->ClearItem( SID_REPAIRPACKAGE );
+/*N*/
+/*N*/     // "SaveAs" will never store any version information - it's a complete new file !
+/*N*/     pMergedParams->ClearItem( SID_VERSION );
+/*N*/
+/*N*/     // merge the new parameters into the copy
+/*N*/     // all values present in both itemsets will be overwritten by the new parameters
+/*N*/     if( pParams )
+/*N*/ 		pMergedParams->Put( *pParams );
+/*N*/     //DELETEZ( pParams );
+/*N*/
+/*N*/ #ifdef DBG_UTIL
+/*N*/     if ( pMergedParams->GetItemState( SID_DOC_SALVAGE) >= SFX_ITEM_SET )
+/*N*/         DBG_ERROR("Salvage item present in Itemset, check the parameters!");
+/*N*/ #endif
+/*N*/
+/*N*/     // should be unneccessary - too hot to handle!
+/*N*/ 	pMergedParams->ClearItem( SID_DOC_SALVAGE );
+/*N*/
+/*N*/     // take over the new merged itemset
+/*N*/ 	pParams = pMergedParams;
+/*N*/
+/*N*/     // create a medium for the target URL
+/*N*/     SfxMedium *pNewFile = new SfxMedium( rFileName, STREAM_READWRITE | STREAM_SHARE_DENYWRITE, sal_False, 0, pParams );
+/*N*/
+/*N*/     // set filter; if no filter is given, take the default filter of the factory
+/*N*/     if ( aFilterName.Len() )
+/*N*/         pNewFile->SetFilter( GetFactory(), aFilterName );
+/*N*/ 	else
+/*N*/         pNewFile->SetFilter( GetFactory().GetFilterContainer()->GetFilter(0) );
+/*N*/
+/*N*/     // saving is alway done using a temporary file
+/*N*/     pNewFile->CreateTempFileNoCopy();
+/*N*/     if ( pNewFile->GetErrorCode() != ERRCODE_NONE )
+/*N*/     {
+/*N*/         // creating temporary file failed ( f.e. floppy disk not inserted! )
+/*N*/         SetError( pNewFile->GetError() );
+/*N*/         delete pNewFile;
+/*N*/         return sal_False;
+/*N*/     }
+/*N*/
+/*N*/     // check if a "SaveTo" is wanted, no "SaveAs"
+/*N*/     SFX_ITEMSET_ARG( pParams, pSaveToItem, SfxBoolItem, SID_SAVETO, sal_False );
+/*N*/     sal_Bool bCopyTo = GetCreateMode() == SFX_CREATE_MODE_EMBEDDED || pSaveToItem && pSaveToItem->GetValue();
+/*N*/
+/*N*/     // some base URL stuff ( awful, but not avoidable ... )
+/*N*/     const String aOldURL( ::binfilter::StaticBaseUrl::GetBaseURL() );
+/*N*/ 	if( GetCreateMode() != SFX_CREATE_MODE_EMBEDDED )
+/*N*/ 		if ( ShallSetBaseURL_Impl(*pNewFile) )
+/*N*/ 			::binfilter::StaticBaseUrl::SetBaseURL( pNewFile->GetBaseURL() );
+/*N*/ 		else
+/*N*/ 			::binfilter::StaticBaseUrl::SetBaseURL( String() );
+/*N*/
+/*N*/     // distinguish between "Save" and "SaveAs"
+/*N*/     pImp-> bIsSaving = sal_False;
+/*N*/
+/*N*/ 	sal_Bool bToOwnFormat = sal_True;//STRIP007 IsOwnStorageFormat_Impl(*pNewFile);
+/*N*/ 	if ( bToOwnFormat )
+/*N*/ 	{
+/*N*/         // If the filter is a "cross export" filter ( f.e. a filter for exporting an impress document from
+/*N*/         // a draw document ), the ClassId of the destination storage is different from the ClassId of this
+/*N*/         // document. It can be retrieved from the default filter for the desired target format
+/*N*/         long nFormat = pNewFile->GetFilter()->GetFormat();
+/*N*/ 		SfxFilterMatcher& rMatcher = SFX_APP()->GetFilterMatcher();
+/*N*/ 		const SfxFilter *pFilt = rMatcher.GetFilter4ClipBoardId( nFormat );
+/*N*/ 		if ( pFilt )
+/*N*/ 		{
+/*N*/             if ( pFilt->GetFilterContainer() != pNewFile->GetFilter()->GetFilterContainer() )
+/*N*/                 pNewFile->GetStorage()->SetClass( SvFactory::GetServerName( nFormat ), nFormat, pFilt->GetTypeName() );
+/*N*/ 		}
+/*N*/ 	}
+/*N*/
+/*N*/ 	if ( GetMedium()->GetFilter() && ( GetMedium()->GetFilter()->GetFilterFlags() & SFX_FILTER_PACKED ) )
+/*N*/ 	{DBG_BF_ASSERT(0, "STRIP"); //STRIP001
+/*N*/ 	}
+/*N*/
+/*N*/     // Save the document ( first as temporary file, then transfer to the target URL by committing the medium )
+/*N*/     sal_Bool bOk = sal_False;
+/*N*/     if ( !pNewFile->GetErrorCode() && SaveTo_Impl( *pNewFile, NULL, sal_True ) )
+/*N*/ 	{
+/*N*/ 		bOk = sal_True;
+/*N*/
+/*N*/         // restore old BaseURL
+/*N*/ 		::binfilter::StaticBaseUrl::SetBaseURL( aOldURL );
+/*N*/
+/*N*/         // transfer a possible error from the medium to the document
+/*N*/         SetError( pNewFile->GetErrorCode() );
+/*N*/
+/*N*/         // notify the document that saving was done successfully
+/*N*/         if ( bCopyTo )
+/*N*/ 		{
+/*N*/         	if ( IsHandsOff() )
+/*N*/ 				bOk = DoSaveCompleted( pMedium );
+/*N*/ 		}
+/*N*/ 		else
+/*N*/ 		{
+/*N*/ 			// Muss !!!
+/*N*/ 			if ( bToOwnFormat )
+/*N*/ 				SetFileName( pNewFile->GetPhysicalName() );
+/*N*/
+/*N*/ 			bOk = DoSaveCompleted( pNewFile );
+/*N*/ 		}
+/*N*/
+/*N*/ 		if( bOk )
+/*N*/ 		{
+/*N*/             if( !bCopyTo )
+/*N*/                 SetModified( sal_False );
+/*N*/ 		}
+/*N*/ 		else
+/*N*/ 		{
+/*N*/             DBG_ASSERT( !bCopyTo, "Error while reconnecting to medium, can't be handled!");
+/*N*/ 			SetError( pNewFile->GetErrorCode() );
+/*N*/
+/*N*/             if ( !bCopyTo )
+/*N*/             {
+/*N*/                 // reconnect to the old medium
+/*?*/                 BOOL bRet = DoSaveCompleted( pMedium );
+/*?*/                 DBG_ASSERT( bRet, "Error in DoSaveCompleted, can't be handled!");
+/*N*/             }
+/*N*/
+/*N*/ 			DELETEZ( pNewFile );
+/*N*/ 		}
+/*N*/
+/*N*/ 		String aPasswd;
+/*N*/ 		if ( IsOwnStorageFormat_Impl( *GetMedium() ) && GetPasswd_Impl( GetMedium()->GetItemSet(), aPasswd ) )
+/*?*/ 			GetMedium()->GetStorage()->SetKey( S2BS( aPasswd ) );	//!!! (pb) needs new implementation
+/*N*/ 	}
+/*N*/ 	else
+/*N*/ 	{
+/*?*/ 		::binfilter::StaticBaseUrl::SetBaseURL( aOldURL );
+/*?*/         SetError( pNewFile->GetErrorCode() );
+/*?*/
+/*?*/         // reconnect to the old storage
+/*?*/         if ( IsHandsOff() )
+/*?*/             DoSaveCompleted( pMedium );
+/*?*/         else
+/*?*/             DoSaveCompleted( (SvStorage*)0 );
+/*?*/
+/*?*/         DELETEZ( pNewFile );
+/*N*/ 	}
+/*N*/
+/*N*/     if( !bOk )
+/*?*/         SetModified( sal_True );
+/*N*/
+/*N*/ 	if ( bCopyTo )
+/*N*/         DELETEZ( pNewFile );
+/*N*/
+/*N*/ 	return bOk;
+/*N*/ }
+
+//------------------------------------------------------------------------
+
+/*?*/ sal_Bool SfxObjectShell::LoadFrom( SvStorage *pStor )
+/*?*/ {
+/*?*/ 	GetConfigManager();
+/*?*/ 	GetDocInfo().Load(pStor);
+/*?*/ 	return sal_True;
+/*?*/ }
+
+//-------------------------------------------------------------------------
+
+/*N*/ sal_Bool SfxObjectShell::IsInformationLost()
+/*N*/ {
+/*N*/ 	const SfxFilter *pFilt = GetMedium()->GetFilter();
+/*N*/     if ( pFilt == GetFactory().GetFilterContainer()->GetFilter(0) )
+/*N*/         return sal_False;
+/*N*/     return pFilt && pFilt->IsAlienFormat() && pImp->bDidDangerousSave && !(pFilt->GetFilterFlags() & SFX_FILTER_SILENTEXPORT);
+/*N*/ }
+
+/*N*/ sal_Bool SfxObjectShell::LoadOwnFormat( SfxMedium& rMedium )
+/*N*/ {
+/*N*/ 	SvStorageRef xStor = rMedium.GetStorage();
+/*N*/ 	if ( xStor.Is() )
+/*N*/ 	{
+/*N*/ 		if ( rMedium.GetFileVersion() )
+/*N*/ 			xStor->SetVersion( rMedium.GetFileVersion() );
+/*N*/
+/*N*/ 		// Password
+/*N*/         SFX_ITEMSET_ARG( rMedium.GetItemSet(), pPasswdItem, SfxStringItem, SID_PASSWORD, sal_False );
+/*N*/         if ( pPasswdItem || ERRCODE_IO_ABORT != CheckPasswd_Impl( this, SFX_APP()->GetPool(), pMedium ) )
+/*N*/ 		{
+/*N*/ 			String aPasswd;
+/*N*/ 			if ( GetPasswd_Impl(pMedium->GetItemSet(), aPasswd) )
+/*N*/ 				xStor->SetKey( S2BS( aPasswd ) ); //!!! (pb) needs new implementation
+/*N*/
+/*N*/ 			// load document
+                sal_Bool bRet = Load( xStor );
+                if ( bRet )
+                    GetConfigManager( TRUE );
+                return bRet;
+/*N*/ 		}
+/*N*/ 		return sal_False;
+/*N*/ 	}
+/*N*/ 	else
+/*N*/ 		return sal_False;
+/*N*/ }
+
+/*N*/ sal_Bool SfxObjectShell::SaveAsOwnFormat( SfxMedium& rMedium )
+/*N*/ {
+/*N*/ 	SvStorageRef xStor = rMedium.GetStorage();
+/*N*/ 	if( xStor.Is() )
+/*N*/ 	{
+/*N*/ 		ULONG nVersion = rMedium.GetFilter()->GetVersion();
+/*N*/ 		xStor->SetVersion( nVersion );
+/*N*/
+/*N*/ 		// Initialize Basic
+/*N*/ 		GetBasicManager();
+/*N*/
+/*N*/ 		// Save dialog container
+/*N*/ 		if( nVersion >= 6200 )
+/*N*/ 		{
+/*N*/ 			SfxDialogLibraryContainer* pDialogCont = pImp->pDialogLibContainer;
+/*N*/ 			if( pDialogCont )
+/*N*/ 				pDialogCont->storeLibrariesToStorage( (SotStorage*)(SvStorage*)xStor );
+/*N*/
+/*N*/ 			SfxScriptLibraryContainer* pBasicCont = pImp->pBasicLibContainer;
+/*N*/ 			if( pBasicCont )
+/*N*/ 				pBasicCont->storeLibrariesToStorage( (SotStorage*)(SvStorage*)xStor );
+/*N*/
+/*N*/ 			// Konfiguration schreiben
+/*N*/ 			if ( GetConfigManager() )
+/*N*/ 			{
+/* //!MBA
+                if ( rDocInfo.HasTemplateConfig() )
+                {
+                    const String aTemplFileName( rDocInfo.GetTemplateFileName() );
+                    if ( aTemplFileName.Len() )
+                    {
+                        INetURLObject aURL( aTemplFileName );
+                        DBG_ASSERT( aURL.GetProtocol() != INET_PROT_NOT_VALID, "Illegal URL !" );
+
+                        SvStorageRef aStor = new SvStorage( aURL.GetMainURL( INetURLObject::NO_DECODE ) );
+                        if ( SVSTREAM_OK == aStor->GetError() )
+                        {
+                            GetConfigManager()->StoreConfiguration(aStor);
+                            if (aRef->IsStream(SfxConfigManager::GetStreamName()))
+                                aRef->Remove(SfxConfigManager::GetStreamName());
+                        }
+                    }
+                }
+                else
+ */
+/*N*/ 				{
+//! MBA                    GetConfigManager()->SetModified( sal_True );
+/*N*/ 					SotStorageRef xCfgStor = pImp->pCfgMgr->GetConfigurationStorage( xStor );
+/*N*/                     if ( pImp->pCfgMgr->StoreConfiguration( xCfgStor ) )
+/*N*/ 						xCfgStor->Commit();
+/*N*/ 				}
+/*N*/ 			}
+/*N*/
+/*N*/ 		}
+/*N*/
+/*N*/ 		const SfxFilter* pFilter = rMedium.GetFilter();
+/*N*/ 		return SaveAs( xStor );
+/*N*/ 	}
+/*N*/ 	else return sal_False;
+/*N*/ }
+
+
+/*N*/ void SfxObjectShell::AddXMLAsZipToTheStorage( SvStorage& rRoot )
+/*N*/ {
+/*N*/ 	static struct _ObjExpType {
+/*N*/ 		sal_Bool (SvtAddXMLToStorageOptions:: *fnIsAdd)() const;
+/*N*/ 		const sal_Char* pModuleNm;
+/*N*/ 		// GlobalNameId
+/*N*/ 		UINT32 n1;
+/*N*/ 		USHORT n2, n3;
+/*N*/ 		BYTE b8, b9, b10, b11, b12, b13, b14, b15;
+/*N*/ 	} aArr[] = {
+/*N*/ 		{ &SvtAddXMLToStorageOptions::IsWriter_Add_XML_to_Storage,
+/*N*/ 			"Writer", BF_SO3_SW_CLASSID_50 },
+/*N*/ 		{ &SvtAddXMLToStorageOptions::IsCalc_Add_XML_to_Storage,
+/*N*/ 			"Calc", BF_SO3_SC_CLASSID_50 },
+/*N*/ 		{ &SvtAddXMLToStorageOptions::IsImpress_Add_XML_to_Storage,
+/*N*/ 			"Impress", BF_SO3_SIMPRESS_CLASSID_50 },
+/*N*/ 		{ &SvtAddXMLToStorageOptions::IsDraw_Add_XML_to_Storage,
+/*N*/ 			"Draw", BF_SO3_SDRAW_CLASSID_50 },
+/*N*/ 		{ 0 }
+/*N*/ 	};
+/*N*/
+/*N*/ 	for( const _ObjExpType* pArr = aArr; pArr->fnIsAdd; ++pArr )
+/*N*/ 	{
+/*N*/ 		SvGlobalName aGlbNm( pArr->n1, pArr->n2, pArr->n3,
+/*N*/ 							pArr->b8, pArr->b9, pArr->b10, pArr->b11,
+/*N*/ 							pArr->b12, pArr->b13, pArr->b14, pArr->b15 );
+/*N*/ 		if( *GetSvFactory() == aGlbNm )
+/*N*/ 		{
+/*?*/ 			// 1. check if the option is set and unequal 0 or is not set
+/*?*/ 			SvtAddXMLToStorageOptions aOpt;
+/*?*/ 			if( (aOpt.*pArr->fnIsAdd)() )
+/*?*/ 			{
+/*?*/ 				// the flag is set
+/*?*/ 				String sStr;
+/*?*/ 				sStr.AssignAscii( "StarOffice XML (" );
+/*?*/ 				sStr.AppendAscii( pArr->pModuleNm );
+/*?*/ 				sStr += ')';
+/*?*/ 				// 2. exist the XML filter? "StarOffice XML (<Application>)"?
+/*?*/ 				const SfxFilter* pFilter = GetFactory().GetFilterContainer()->
+/*?*/ 												GetFilter4FilterName( sStr );
+/*?*/ 				if( pFilter )
+/*?*/ 				{
+/*?*/ 					::utl::TempFile aTempFile;
+/*?*/ 					SfxMedium		aTmpMed( aTempFile.GetURL(), STREAM_READ | STREAM_WRITE, sal_True );
+/*?*/
+/*?*/ 					aTmpMed.SetFilter( pFilter );
+/*?*/
+/*?*/ 					if( ConvertTo( aTmpMed ) )
+/*?*/ 					{
+/*?*/                         SvStorage* pXMLStor = aTmpMed.GetStorage();
+/*?*/
+/*?*/ 						if( pXMLStor )
+/*?*/ 						{
+/*?*/ 							const String	aContent( String::CreateFromAscii( "Content" ) );
+/*?*/ 							const String	aContentXML( String::CreateFromAscii( "Content.xml" ) );
+/*?*/ 							const String	aXMLFormatName( String::CreateFromAscii( "XMLFormat2" ) );
+/*?*/ 							String			aContentName;
+/*?*/
+/*?*/ 							if( pXMLStor->IsContained( aContentXML ) )
+/*?*/ 								aContentName = aContentXML;
+/*?*/ 							else if( pXMLStor->IsContained( aContent ) )
+/*?*/ 								aContentName = aContent;
+/*?*/
+/*?*/ 							if( aContentName.Len() )
+/*?*/ 							{
+/*?*/ 								SvStorageStreamRef	xOStm( rRoot.OpenStream( aXMLFormatName, STREAM_WRITE | STREAM_TRUNC ) );
+/*?*/ 								SvStorageStreamRef	xIStm( pXMLStor->OpenStream( aContentName, STREAM_READ | STREAM_NOCREATE ) );
+/*?*/
+/*?*/ 								if( xOStm.Is() && xIStm.Is() )
+/*?*/ 								{
+/*?*/ 									ZCodec aCodec;
+/*?*/
+/*?*/ 									xIStm->Seek( 0 );
+/*?*/ 									aCodec.BeginCompression( ZCODEC_BEST_COMPRESSION );
+/*?*/ 									aCodec.Compress( *xIStm, *xOStm );
+/*?*/ 									aCodec.EndCompression();
+/*?*/ 									xOStm->Commit();
+/*?*/ 								}
+/*?*/ 							}
+/*?*/ 						}
+/*?*/ 					}
+/*?*/ 				}
+/*?*/ 			}
+/*?*/ 			// that's all
+/*?*/ 			break;
+/*N*/ 		}
+/*N*/ 	}
+/*N*/ }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */