Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 : #include "sal/config.h"
21 :
22 : #include <cassert>
23 :
24 : #include <vcl/msgbox.hxx>
25 : #include <svl/eitem.hxx>
26 : #include <svl/stritem.hxx>
27 : #include <svl/intitem.hxx>
28 : #include <com/sun/star/frame/GlobalEventBroadcaster.hpp>
29 : #include <com/sun/star/frame/XStorable.hpp>
30 : #include <com/sun/star/frame/XModel.hpp>
31 : #include <com/sun/star/frame/XFrame.hpp>
32 : #include <com/sun/star/document/XFilter.hpp>
33 : #include <com/sun/star/document/XImporter.hpp>
34 : #include <com/sun/star/document/XExporter.hpp>
35 : #include <com/sun/star/document/FilterOptionsRequest.hpp>
36 : #include <com/sun/star/document/XInteractionFilterOptions.hpp>
37 : #include <com/sun/star/packages/zip/ZipIOException.hpp>
38 : #include <com/sun/star/task/XInteractionHandler.hpp>
39 : #include <com/sun/star/task/XInteractionAskLater.hpp>
40 : #include <com/sun/star/task/FutureDocumentVersionProductUpdateRequest.hpp>
41 : #include <com/sun/star/task/InteractionClassification.hpp>
42 : #include <com/sun/star/lang/XInitialization.hpp>
43 : #include <com/sun/star/lang/WrappedTargetRuntimeException.hpp>
44 : #include <com/sun/star/document/MacroExecMode.hpp>
45 : #include <com/sun/star/ui/dialogs/ExtendedFilePickerElementIds.hpp>
46 : #include <com/sun/star/ui/dialogs/XFilePickerControlAccess.hpp>
47 : #include <com/sun/star/ui/dialogs/XFilePicker.hpp>
48 : #include <com/sun/star/beans/XPropertySetInfo.hpp>
49 : #include <com/sun/star/lang/XMultiServiceFactory.hpp>
50 : #include <com/sun/star/beans/XPropertyAccess.hpp>
51 : #include <com/sun/star/beans/PropertyValue.hpp>
52 : #include <com/sun/star/beans/XPropertySet.hpp>
53 : #include <com/sun/star/container/XNameAccess.hpp>
54 : #include <com/sun/star/container/XSet.hpp>
55 : #include <com/sun/star/embed/ElementModes.hpp>
56 : #include <com/sun/star/embed/EmbedStates.hpp>
57 : #include <com/sun/star/embed/Aspects.hpp>
58 : #include <com/sun/star/embed/XTransactedObject.hpp>
59 : #include <com/sun/star/embed/XEmbedPersist.hpp>
60 : #include <com/sun/star/embed/XLinkageSupport.hpp>
61 : #include <com/sun/star/embed/EntryInitModes.hpp>
62 : #include <com/sun/star/embed/XOptimizedStorage.hpp>
63 : #include <com/sun/star/embed/XEncryptionProtectedStorage.hpp>
64 : #include <com/sun/star/io/XTruncate.hpp>
65 : #include <com/sun/star/util/XModifiable.hpp>
66 : #include <com/sun/star/security/DocumentDigitalSignatures.hpp>
67 : #include <com/sun/star/xml/crypto/CipherID.hpp>
68 : #include <com/sun/star/xml/crypto/DigestID.hpp>
69 :
70 : #include <com/sun/star/document/XDocumentProperties.hpp>
71 : #include <com/sun/star/document/XDocumentPropertiesSupplier.hpp>
72 : #include <comphelper/processfactory.hxx>
73 : #include <comphelper/configurationhelper.hxx>
74 : #include <comphelper/interaction.hxx>
75 : #include <svtools/sfxecode.hxx>
76 : #include <unotools/securityoptions.hxx>
77 : #include <cppuhelper/weak.hxx>
78 : #include <unotools/streamwrap.hxx>
79 :
80 : #include <unotools/saveopt.hxx>
81 : #include <unotools/useroptions.hxx>
82 : #include <unotools/pathoptions.hxx>
83 : #include <tools/urlobj.hxx>
84 : #include <tools/diagnose_ex.h>
85 : #include <unotools/localfilehelper.hxx>
86 : #include <unotools/ucbhelper.hxx>
87 : #include <unotools/tempfile.hxx>
88 : #include <unotools/docinfohelper.hxx>
89 : #include <ucbhelper/content.hxx>
90 : #include <sot/storinfo.hxx>
91 : #include <sot/exchange.hxx>
92 : #include <sot/formats.hxx>
93 : #include <comphelper/storagehelper.hxx>
94 : #include <comphelper/seqstream.hxx>
95 : #include <comphelper/documentconstants.hxx>
96 : #include <comphelper/string.hxx>
97 : #include <vcl/bitmapex.hxx>
98 : #include <svtools/embedhlp.hxx>
99 : #include <rtl/logfile.hxx>
100 : #include <basic/modsizeexceeded.hxx>
101 : #include <osl/file.hxx>
102 :
103 : #include <sfx2/signaturestate.hxx>
104 : #include <sfx2/app.hxx>
105 : #include <sfx2/objsh.hxx>
106 : #include <sfx2/childwin.hxx>
107 : #include <sfx2/request.hxx>
108 : #include "sfx2/sfxresid.hxx"
109 : #include <sfx2/docfile.hxx>
110 : #include "fltfnc.hxx"
111 : #include <sfx2/docfilt.hxx>
112 : #include <sfx2/docfac.hxx>
113 : #include "objshimp.hxx"
114 : #include "sfxtypes.hxx"
115 : #include "doc.hrc"
116 : #include <sfx2/sfxsids.hrc>
117 : #include <sfx2/module.hxx>
118 : #include <sfx2/dispatch.hxx>
119 : #include "openflag.hxx"
120 : #include "helper.hxx"
121 : #include <sfx2/event.hxx>
122 : #include "fltoptint.hxx"
123 : #include <sfx2/viewfrm.hxx>
124 : #include "graphhelp.hxx"
125 : #include "appbaslib.hxx"
126 : #include "appdata.hxx"
127 :
128 : #include "../appl/app.hrc"
129 :
130 : extern sal_uInt32 CheckPasswd_Impl( SfxObjectShell*, SfxItemPool&, SfxMedium* );
131 :
132 : using namespace ::com::sun::star;
133 : using namespace ::com::sun::star::container;
134 : using namespace ::com::sun::star::lang;
135 : using namespace ::com::sun::star::ui::dialogs;
136 : using namespace ::com::sun::star::uno;
137 : using namespace ::com::sun::star::beans;
138 : using namespace ::com::sun::star::ucb;
139 : using namespace ::com::sun::star::task;
140 : using namespace ::com::sun::star::document;
141 : using namespace ::rtl;
142 : using namespace ::cppu;
143 :
144 : //=========================================================================
145 1042 : void impl_addToModelCollection(const css::uno::Reference< css::frame::XModel >& xModel)
146 : {
147 1042 : if (!xModel.is())
148 1042 : return;
149 :
150 1042 : css::uno::Reference< css::uno::XComponentContext > xContext = ::comphelper::getProcessComponentContext();
151 : css::uno::Reference< css::frame::XGlobalEventBroadcaster > xModelCollection =
152 1042 : css::frame::GlobalEventBroadcaster::create(xContext);
153 : try
154 : {
155 1042 : xModelCollection->insert(css::uno::makeAny(xModel));
156 : }
157 0 : catch ( uno::Exception& )
158 : {
159 : OSL_FAIL( "The document seems to be in the collection already!\n" );
160 1042 : }
161 : }
162 :
163 : //=========================================================================
164 :
165 0 : sal_Bool SfxObjectShell::Save()
166 : {
167 0 : return SaveChildren();
168 : }
169 :
170 : //--------------------------------------------------------------------------
171 :
172 576 : sal_Bool SfxObjectShell::SaveAs( SfxMedium& rMedium )
173 : {
174 576 : return SaveAsChildren( rMedium );
175 : }
176 :
177 : //-------------------------------------------------------------------------
178 :
179 0 : sal_Bool SfxObjectShell::QuerySlotExecutable( sal_uInt16 /*nSlotId*/ )
180 : {
181 0 : return sal_True;
182 : }
183 :
184 : //-------------------------------------------------------------------------
185 :
186 503 : bool GetEncryptionData_Impl( const SfxItemSet* pSet, uno::Sequence< beans::NamedValue >& o_rEncryptionData )
187 : {
188 503 : bool bResult = false;
189 503 : if ( pSet )
190 : {
191 503 : SFX_ITEMSET_ARG( pSet, pEncryptionDataItem, SfxUnoAnyItem, SID_ENCRYPTIONDATA, sal_False);
192 503 : if ( pEncryptionDataItem )
193 : {
194 12 : pEncryptionDataItem->GetValue() >>= o_rEncryptionData;
195 12 : bResult = true;
196 : }
197 : else
198 : {
199 491 : SFX_ITEMSET_ARG( pSet, pPasswordItem, SfxStringItem, SID_PASSWORD, sal_False);
200 491 : if ( pPasswordItem )
201 : {
202 6 : ::rtl::OUString aPassword = pPasswordItem->GetValue();
203 6 : o_rEncryptionData = ::comphelper::OStorageHelper::CreatePackageEncryptionData( aPassword );
204 6 : bResult = true;
205 : }
206 : }
207 : }
208 :
209 503 : return bResult;
210 : }
211 :
212 : //-------------------------------------------------------------------------
213 0 : sal_Bool SfxObjectShell::PutURLContentsToVersionStream_Impl(
214 : ::rtl::OUString aURL,
215 : const uno::Reference< embed::XStorage >& xDocStorage,
216 : ::rtl::OUString aStreamName )
217 : {
218 0 : sal_Bool bResult = sal_False;
219 : try
220 : {
221 0 : uno::Reference< embed::XStorage > xVersion = xDocStorage->openStorageElement(
222 : ::rtl::OUString("Versions"),
223 0 : embed::ElementModes::READWRITE );
224 :
225 : DBG_ASSERT( xVersion.is(),
226 : "The method must throw an exception if the storage can not be opened!\n" );
227 0 : if ( !xVersion.is() )
228 0 : throw uno::RuntimeException();
229 :
230 0 : uno::Reference< io::XStream > xVerStream = xVersion->openStreamElement(
231 : aStreamName,
232 0 : embed::ElementModes::READWRITE );
233 : DBG_ASSERT( xVerStream.is(), "The method must throw an exception if the storage can not be opened!\n" );
234 0 : if ( !xVerStream.is() )
235 0 : throw uno::RuntimeException();
236 :
237 0 : uno::Reference< io::XOutputStream > xOutStream = xVerStream->getOutputStream();
238 0 : uno::Reference< io::XTruncate > xTrunc( xOutStream, uno::UNO_QUERY );
239 :
240 : DBG_ASSERT( xTrunc.is(), "The output stream must exist and implement XTruncate interface!\n" );
241 0 : if ( !xTrunc.is() )
242 0 : throw RuntimeException();
243 :
244 : uno::Reference< io::XInputStream > xTmpInStream =
245 : ::comphelper::OStorageHelper::GetInputStreamFromURL(
246 0 : aURL, comphelper::getProcessComponentContext() );
247 : assert( xTmpInStream.is() );
248 :
249 0 : xTrunc->truncate();
250 0 : ::comphelper::OStorageHelper::CopyInputToOutput( xTmpInStream, xOutStream );
251 0 : xOutStream->closeOutput();
252 :
253 0 : uno::Reference< embed::XTransactedObject > xTransact( xVersion, uno::UNO_QUERY );
254 : DBG_ASSERT( xTransact.is(), "The storage must implement XTransacted interface!\n" );
255 0 : if ( xTransact.is() )
256 0 : xTransact->commit();
257 :
258 0 : bResult = sal_True;
259 : }
260 0 : catch( uno::Exception& )
261 : {
262 : // TODO/LATER: handle the error depending on exception
263 0 : SetError( ERRCODE_IO_GENERAL, ::rtl::OUString( OSL_LOG_PREFIX ) );
264 : }
265 :
266 0 : return bResult;
267 : }
268 :
269 : //-------------------------------------------------------------------------
270 0 : ::rtl::OUString SfxObjectShell::CreateTempCopyOfStorage_Impl( const uno::Reference< embed::XStorage >& xStorage )
271 : {
272 0 : ::rtl::OUString aTempURL = ::utl::TempFile().GetURL();
273 :
274 : DBG_ASSERT( !aTempURL.isEmpty(), "Can't create a temporary file!\n" );
275 0 : if ( !aTempURL.isEmpty() )
276 : {
277 : try
278 : {
279 : uno::Reference< embed::XStorage > xTempStorage =
280 0 : ::comphelper::OStorageHelper::GetStorageFromURL( aTempURL, embed::ElementModes::READWRITE );
281 :
282 : // the password will be transfered from the xStorage to xTempStorage by storage implemetation
283 0 : xStorage->copyToStorage( xTempStorage );
284 :
285 : // the temporary storage was commited by the previous method and it will die by refcount
286 : }
287 0 : catch ( uno::Exception& )
288 : {
289 : OSL_FAIL( "Creation of a storage copy is failed!" );
290 0 : ::utl::UCBContentHelper::Kill( aTempURL );
291 :
292 0 : aTempURL = ::rtl::OUString();
293 :
294 : // TODO/LATER: may need error code setting based on exception
295 0 : SetError( ERRCODE_IO_GENERAL, ::rtl::OUString( OSL_LOG_PREFIX ) );
296 : }
297 : }
298 :
299 0 : return aTempURL;
300 : }
301 :
302 : //-------------------------------------------------------------------------
303 0 : SvGlobalName SfxObjectShell::GetClassName() const
304 : {
305 0 : return GetFactory().GetClassId();
306 : }
307 :
308 : //-------------------------------------------------------------------------
309 1861 : void SfxObjectShell::SetupStorage( const uno::Reference< embed::XStorage >& xStorage,
310 : sal_Int32 nVersion,
311 : sal_Bool bTemplate ) const
312 : {
313 1861 : uno::Reference< beans::XPropertySet > xProps( xStorage, uno::UNO_QUERY );
314 :
315 1861 : if ( xProps.is() )
316 : {
317 1861 : SvGlobalName aName;
318 1861 : String aFullTypeName, aShortTypeName, aAppName;
319 1861 : sal_uInt32 nClipFormat=0;
320 :
321 1861 : FillClass( &aName, &nClipFormat, &aAppName, &aFullTypeName, &aShortTypeName, nVersion, bTemplate );
322 1861 : if ( nClipFormat )
323 : {
324 : // basic doesn't have a ClipFormat
325 : // without MediaType the storage is not really usable, but currently the BasicIDE still
326 : // is an SfxObjectShell and so we can't take this as an error
327 1861 : datatransfer::DataFlavor aDataFlavor;
328 1861 : SotExchange::GetFormatDataFlavor( nClipFormat, aDataFlavor );
329 1861 : if ( !aDataFlavor.MimeType.isEmpty() )
330 : {
331 : try
332 : {
333 1861 : xProps->setPropertyValue( ::rtl::OUString("MediaType"), uno::makeAny( aDataFlavor.MimeType ) );
334 : }
335 0 : catch( uno::Exception& )
336 : {
337 0 : const_cast<SfxObjectShell*>( this )->SetError( ERRCODE_IO_GENERAL, ::rtl::OUString( OSL_LOG_PREFIX ) );
338 : }
339 :
340 1861 : SvtSaveOptions aSaveOpt;
341 1861 : SvtSaveOptions::ODFDefaultVersion nDefVersion = aSaveOpt.GetODFDefaultVersion();
342 :
343 1861 : uno::Sequence< beans::NamedValue > aEncryptionAlgs( 3 );
344 1861 : aEncryptionAlgs[0].Name = ::rtl::OUString( "StartKeyGenerationAlgorithm" );
345 1861 : aEncryptionAlgs[1].Name = ::rtl::OUString( "EncryptionAlgorithm" );
346 1861 : aEncryptionAlgs[2].Name = ::rtl::OUString( "ChecksumAlgorithm" );
347 : // the default values, that should be used for ODF1.1 and older formats
348 1861 : aEncryptionAlgs[0].Value <<= xml::crypto::DigestID::SHA1;
349 1861 : aEncryptionAlgs[1].Value <<= xml::crypto::CipherID::BLOWFISH_CFB_8;
350 1861 : aEncryptionAlgs[2].Value <<= xml::crypto::DigestID::SHA1_1K;
351 :
352 1861 : if ( nDefVersion >= SvtSaveOptions::ODFVER_012 )
353 : {
354 : try
355 : {
356 : // older versions can not have this property set, it exists only starting from ODF1.2
357 1861 : xProps->setPropertyValue( ::rtl::OUString("Version" ), uno::makeAny( ODFVER_012_TEXT ) );
358 : }
359 0 : catch( uno::Exception& )
360 : {
361 : }
362 :
363 1861 : if ( !aSaveOpt.IsUseSHA1InODF12() && nDefVersion != SvtSaveOptions::ODFVER_012_EXT_COMPAT )
364 : {
365 1861 : aEncryptionAlgs[0].Value <<= xml::crypto::DigestID::SHA256;
366 1861 : aEncryptionAlgs[2].Value <<= xml::crypto::DigestID::SHA256_1K;
367 : }
368 1861 : if ( !aSaveOpt.IsUseBlowfishInODF12() && nDefVersion != SvtSaveOptions::ODFVER_012_EXT_COMPAT )
369 1861 : aEncryptionAlgs[1].Value <<= xml::crypto::CipherID::AES_CBC_W3C_PADDING;
370 : }
371 :
372 : try
373 : {
374 : // set the encryption algorithms accordingly;
375 : // the setting does not trigger encryption,
376 : // it just provides the format for the case that contents should be encrypted
377 1861 : uno::Reference< embed::XEncryptionProtectedStorage > xEncr( xStorage, uno::UNO_QUERY_THROW );
378 725 : xEncr->setEncryptionAlgorithms( aEncryptionAlgs );
379 : }
380 1136 : catch( uno::Exception& )
381 : {
382 1136 : const_cast<SfxObjectShell*>( this )->SetError( ERRCODE_IO_GENERAL, ::rtl::OUString( OSL_LOG_PREFIX ) );
383 1861 : }
384 :
385 1861 : }
386 1861 : }
387 1861 : }
388 1861 : }
389 :
390 : //-------------------------------------------------------------------------
391 0 : void SfxObjectShell::PrepareSecondTryLoad_Impl()
392 : {
393 : // only for internal use
394 0 : pImp->m_xDocStorage = uno::Reference< embed::XStorage >();
395 0 : pImp->m_bIsInit = sal_False;
396 0 : ResetError();
397 0 : }
398 :
399 : //-------------------------------------------------------------------------
400 1046 : sal_Bool SfxObjectShell::GeneralInit_Impl( const uno::Reference< embed::XStorage >& xStorage,
401 : sal_Bool bTypeMustBeSetAlready )
402 : {
403 1046 : if ( pImp->m_bIsInit )
404 2 : return sal_False;
405 :
406 1044 : pImp->m_bIsInit = sal_True;
407 1044 : if ( xStorage.is() )
408 : {
409 : // no notification is required the storage is set the first time
410 105 : pImp->m_xDocStorage = xStorage;
411 :
412 : try {
413 105 : uno::Reference < beans::XPropertySet > xPropSet( xStorage, uno::UNO_QUERY_THROW );
414 105 : Any a = xPropSet->getPropertyValue( ::rtl::OUString("MediaType" ) );
415 105 : ::rtl::OUString aMediaType;
416 105 : if ( !(a>>=aMediaType) || aMediaType.isEmpty() )
417 : {
418 0 : if ( bTypeMustBeSetAlready )
419 : {
420 0 : SetError( ERRCODE_IO_BROKENPACKAGE, ::rtl::OUString( OSL_LOG_PREFIX ) );
421 0 : return sal_False;
422 : }
423 :
424 0 : SetupStorage( xStorage, SOFFICE_FILEFORMAT_CURRENT, sal_False );
425 105 : }
426 : }
427 0 : catch ( uno::Exception& )
428 : {
429 : OSL_FAIL( "Can't check storage's mediatype!\n" );
430 : }
431 : }
432 : else
433 939 : pImp->m_bCreateTempStor = sal_True;
434 :
435 1044 : return sal_True;
436 : }
437 :
438 : //-------------------------------------------------------------------------
439 941 : sal_Bool SfxObjectShell::InitNew( const uno::Reference< embed::XStorage >& xStorage )
440 : {
441 941 : return GeneralInit_Impl( xStorage, sal_False );
442 : }
443 :
444 : //-------------------------------------------------------------------------
445 105 : sal_Bool SfxObjectShell::Load( SfxMedium& rMedium )
446 : {
447 105 : return GeneralInit_Impl( rMedium.GetStorage(), sal_True );
448 : }
449 :
450 327 : sal_Bool SfxObjectShell::DoInitNew( SfxMedium* pMed )
451 : /* [Description]
452 :
453 : This from SvPersist inherited virtual method is called to initialize
454 : the SfxObjectShell instance from a storage (PStore! = 0) or (PStore == 0)
455 :
456 : Like with all Do...-methods there is a from a control, the actual
457 : implementation is done by the virtual method in which also the
458 : InitNew(SvStorate *) from the SfxObjectShell-Subclass is implemented.
459 :
460 : For pStore == 0 the SfxObjectShell-instance is connected to an empty
461 : SfxMedium, otherwise a SfxMedium, which refers to the SvStorage
462 : passed as a parameter.
463 :
464 : The object is only initialized correctly after InitNew() or Load().
465 :
466 : [Return value]
467 : sal_True The object has been initialized.
468 : sal_False The object could not be initialized
469 : */
470 :
471 : {
472 327 : ModifyBlocker_Impl aBlock( this );
473 327 : pMedium = pMed;
474 327 : if ( !pMedium )
475 : {
476 319 : bIsTmp = sal_True;
477 319 : pMedium = new SfxMedium;
478 : }
479 :
480 327 : pMedium->CanDisposeStorage_Impl( sal_True );
481 :
482 327 : if ( InitNew( pMed ? pMed->GetStorage() : uno::Reference < embed::XStorage >() ) )
483 : {
484 : // empty documents always get their macros from the user, so there is no reason to restrict access
485 325 : pImp->aMacroMode.allowMacroExecution();
486 325 : if ( SFX_CREATE_MODE_EMBEDDED == eCreateMode )
487 306 : SetTitle(SfxResId(STR_NONAME).toString());
488 :
489 325 : uno::Reference< frame::XModel > xModel ( GetModel(), uno::UNO_QUERY );
490 325 : if ( xModel.is() )
491 : {
492 325 : SfxItemSet *pSet = GetMedium()->GetItemSet();
493 325 : uno::Sequence< beans::PropertyValue > aArgs;
494 325 : TransformItems( SID_OPENDOC, *pSet, aArgs );
495 325 : sal_Int32 nLength = aArgs.getLength();
496 325 : aArgs.realloc( nLength + 1 );
497 325 : aArgs[nLength].Name = DEFINE_CONST_UNICODE("Title");
498 325 : aArgs[nLength].Value <<= ::rtl::OUString( GetTitle( SFX_TITLE_DETECT ) );
499 325 : xModel->attachResource( ::rtl::OUString(), aArgs );
500 325 : impl_addToModelCollection(xModel);
501 : }
502 :
503 325 : SetInitialized_Impl( true );
504 325 : return sal_True;
505 : }
506 :
507 2 : return sal_False;
508 : }
509 :
510 : //-------------------------------------------------------------------------
511 :
512 0 : sal_Bool SfxObjectShell::ImportFromGeneratedStream_Impl(
513 : const uno::Reference< io::XStream >& xStream,
514 : const uno::Sequence< beans::PropertyValue >& aMediaDescr )
515 : {
516 0 : if ( !xStream.is() )
517 0 : return sal_False;
518 :
519 0 : if ( pMedium && pMedium->HasStorage_Impl() )
520 0 : pMedium->CloseStorage();
521 :
522 0 : sal_Bool bResult = sal_False;
523 :
524 : try
525 : {
526 : uno::Reference< embed::XStorage > xStorage =
527 0 : ::comphelper::OStorageHelper::GetStorageFromStream( xStream, embed::ElementModes::READWRITE );
528 :
529 0 : if ( !xStorage.is() )
530 0 : throw uno::RuntimeException();
531 :
532 0 : if ( !pMedium )
533 0 : pMedium = new SfxMedium( xStorage, String() );
534 : else
535 0 : pMedium->SetStorage_Impl( xStorage );
536 :
537 0 : SfxAllItemSet aSet( SFX_APP()->GetPool() );
538 0 : TransformParameters( SID_OPENDOC, aMediaDescr, aSet );
539 0 : pMedium->GetItemSet()->Put( aSet );
540 0 : pMedium->CanDisposeStorage_Impl( sal_False );
541 :
542 : // allow the subfilter to reinit the model
543 0 : if ( pImp->m_bIsInit )
544 0 : pImp->m_bIsInit = sal_False;
545 :
546 0 : if ( LoadOwnFormat( *pMedium ) )
547 : {
548 0 : bHasName = sal_True;
549 0 : if ( !IsReadOnly() && IsLoadReadonly() )
550 0 : SetReadOnlyUI();
551 :
552 0 : bResult = sal_True;
553 : OSL_ENSURE( pImp->m_xDocStorage == xStorage, "Wrong storage is used!\n" );
554 : }
555 :
556 : // now the medium can be disconnected from the storage
557 : // the medium is not allowed to dispose the storage so CloseStorage() can be used
558 0 : pMedium->CloseStorage();
559 : }
560 0 : catch( uno::Exception& )
561 : {
562 : }
563 :
564 0 : return bResult;
565 : }
566 :
567 : //-------------------------------------------------------------------------
568 :
569 719 : sal_Bool SfxObjectShell::DoLoad( SfxMedium *pMed )
570 : {
571 719 : ModifyBlocker_Impl aBlock( this );
572 :
573 719 : pMedium = pMed;
574 719 : pMedium->CanDisposeStorage_Impl( sal_True );
575 :
576 719 : sal_Bool bOk = sal_False;
577 719 : const SfxFilter* pFilter = pMed->GetFilter();
578 719 : SfxItemSet* pSet = pMedium->GetItemSet();
579 719 : if( !pImp->nEventId )
580 : {
581 719 : SFX_ITEMSET_ARG(
582 : pSet, pTemplateItem, SfxBoolItem,
583 : SID_TEMPLATE, sal_False);
584 : SetActivateEvent_Impl(
585 2 : ( pTemplateItem && pTemplateItem->GetValue() )
586 721 : ? SFX_EVENT_CREATEDOC : SFX_EVENT_OPENDOC );
587 : }
588 :
589 :
590 719 : SFX_ITEMSET_ARG( pSet, pBaseItem, SfxStringItem,
591 : SID_BASEURL, sal_False);
592 719 : rtl::OUString aBaseURL;
593 719 : SFX_ITEMSET_ARG( pMedium->GetItemSet(), pSalvageItem, SfxStringItem, SID_DOC_SALVAGE, sal_False);
594 719 : if( pBaseItem )
595 0 : aBaseURL = pBaseItem->GetValue();
596 : else
597 : {
598 719 : if ( pSalvageItem )
599 : {
600 0 : rtl::OUString aName( pMed->GetPhysicalName() );
601 0 : ::utl::LocalFileHelper::ConvertPhysicalNameToURL( aName, aBaseURL );
602 : }
603 : else
604 719 : aBaseURL = pMed->GetBaseURL();
605 : }
606 719 : pMed->GetItemSet()->Put( SfxStringItem( SID_DOC_BASEURL, aBaseURL ) );
607 :
608 719 : pImp->nLoadedFlags = 0;
609 719 : pImp->bModelInitialized = sal_False;
610 :
611 : //TODO/LATER: make a clear strategy how to handle "UsesStorage" etc.
612 719 : sal_Bool bOwnStorageFormat = IsOwnStorageFormat_Impl( *pMedium );
613 719 : sal_Bool bHasStorage = IsPackageStorageFormat_Impl( *pMedium );
614 719 : if ( pMedium->GetFilter() )
615 : {
616 719 : sal_uInt32 nError = HandleFilter( pMedium, this );
617 719 : if ( nError != ERRCODE_NONE )
618 0 : SetError( nError, ::rtl::OUString( OSL_LOG_PREFIX ) );
619 :
620 719 : if (pMedium->GetFilter()->GetFilterFlags() & SFX_FILTER_STARTPRESENTATION)
621 0 : pSet->Put( SfxBoolItem( SID_DOC_STARTPRESENTATION, sal_True) );
622 : }
623 :
624 719 : EnableSetModified( sal_False );
625 :
626 719 : pMedium->LockOrigFileOnDemand( sal_True, sal_False );
627 719 : if ( GetError() == ERRCODE_NONE && bOwnStorageFormat && ( !pFilter || !( pFilter->GetFilterFlags() & SFX_FILTER_STARONEFILTER ) ) )
628 : {
629 105 : uno::Reference< embed::XStorage > xStorage;
630 105 : if ( pMedium->GetError() == ERRCODE_NONE )
631 105 : xStorage = pMedium->GetStorage();
632 :
633 105 : if( xStorage.is() && pMedium->GetLastStorageCreationState() == ERRCODE_NONE )
634 : {
635 : DBG_ASSERT( pFilter, "No filter for storage found!" );
636 :
637 : try
638 : {
639 105 : sal_Bool bWarnMediaTypeFallback = sal_False;
640 105 : SFX_ITEMSET_ARG( pMedium->GetItemSet(), pRepairPackageItem, SfxBoolItem, SID_REPAIRPACKAGE, sal_False);
641 :
642 : // treat the package as broken if the mediatype was retrieved as a fallback
643 105 : uno::Reference< beans::XPropertySet > xStorProps( xStorage, uno::UNO_QUERY_THROW );
644 105 : xStorProps->getPropertyValue( ::rtl::OUString( "MediaTypeFallbackUsed" ) )
645 105 : >>= bWarnMediaTypeFallback;
646 :
647 105 : if ( pRepairPackageItem && pRepairPackageItem->GetValue() )
648 : {
649 : // the macros in repaired documents should be disabled
650 0 : pMedium->GetItemSet()->Put( SfxUInt16Item( SID_MACROEXECMODE, document::MacroExecMode::NEVER_EXECUTE ) );
651 :
652 : // the mediatype was retrieved by using fallback solution but this is a repairing mode
653 : // so it is acceptable to open the document if there is no contents that required manifest.xml
654 0 : bWarnMediaTypeFallback = sal_False;
655 : }
656 :
657 105 : if ( bWarnMediaTypeFallback || !xStorage->getElementNames().getLength() )
658 0 : SetError( ERRCODE_IO_BROKENPACKAGE, ::rtl::OUString( OSL_LOG_PREFIX ) );
659 : }
660 0 : catch( uno::Exception& )
661 : {
662 : // TODO/LATER: may need error code setting based on exception
663 0 : SetError( ERRCODE_IO_GENERAL, ::rtl::OUString( OSL_LOG_PREFIX ) );
664 : }
665 :
666 : // Load
667 105 : if ( !GetError() )
668 : {
669 105 : pImp->nLoadedFlags = 0;
670 105 : pImp->bModelInitialized = sal_False;
671 105 : bOk = xStorage.is() && LoadOwnFormat( *pMed );
672 105 : if ( bOk )
673 : {
674 : // the document loaded from template has no name
675 103 : SFX_ITEMSET_ARG( pMedium->GetItemSet(), pTemplateItem, SfxBoolItem, SID_TEMPLATE, sal_False);
676 103 : if ( !pTemplateItem || !pTemplateItem->GetValue() )
677 101 : bHasName = sal_True;
678 : }
679 : else
680 2 : SetError( ERRCODE_ABORT, ::rtl::OUString( OSL_LOG_PREFIX ) );
681 : }
682 : }
683 : else
684 0 : SetError( pMed->GetLastStorageCreationState(), ::rtl::OUString( OSL_LOG_PREFIX ) );
685 : }
686 614 : else if ( GetError() == ERRCODE_NONE && InitNew(0) )
687 : {
688 : // Name vor ConvertFrom setzen, damit GetSbxObject() schon funktioniert
689 614 : bHasName = sal_True;
690 614 : SetName( SfxResId(STR_NONAME).toString() );
691 :
692 614 : if( !bHasStorage )
693 562 : pMedium->GetInStream();
694 : else
695 52 : pMedium->GetStorage();
696 :
697 614 : if ( GetError() == ERRCODE_NONE )
698 : {
699 614 : pImp->nLoadedFlags = 0;
700 614 : pImp->bModelInitialized = sal_False;
701 614 : if ( pMedium->GetFilter() && ( pMedium->GetFilter()->GetFilterFlags() & SFX_FILTER_STARONEFILTER ) )
702 : {
703 446 : uno::Reference < beans::XPropertySet > xSet( GetModel(), uno::UNO_QUERY );
704 446 : ::rtl::OUString sLockUpdates("LockUpdates");
705 446 : bool bSetProperty = true;
706 : try
707 : {
708 454 : xSet->setPropertyValue( sLockUpdates, makeAny( (sal_Bool) sal_True ) );
709 : }
710 16 : catch(const beans::UnknownPropertyException& )
711 : {
712 8 : bSetProperty = false;
713 : }
714 446 : bOk = ImportFrom( *pMedium, false );
715 446 : if(bSetProperty)
716 : {
717 : try
718 : {
719 438 : xSet->setPropertyValue( sLockUpdates, makeAny( (sal_Bool) sal_False ) );
720 : }
721 0 : catch(const beans::UnknownPropertyException& )
722 : {}
723 : }
724 446 : UpdateLinks();
725 446 : FinishedLoading( SFX_LOADED_ALL );
726 : }
727 : else
728 : {
729 168 : bOk = ConvertFrom(*pMedium);
730 168 : InitOwnModel_Impl();
731 : }
732 : }
733 : }
734 :
735 719 : if ( bOk )
736 : {
737 703 : if ( IsReadOnlyMedium() || IsLoadReadonly() )
738 196 : SetReadOnlyUI();
739 :
740 : try
741 : {
742 705 : ::ucbhelper::Content aContent( pMedium->GetName(), com::sun::star::uno::Reference < XCommandEnvironment >(), comphelper::getProcessComponentContext() );
743 701 : com::sun::star::uno::Reference < XPropertySetInfo > xProps = aContent.getProperties();
744 701 : if ( xProps.is() )
745 : {
746 701 : ::rtl::OUString aAuthor( "Author" );
747 701 : ::rtl::OUString aKeywords( "Keywords" );
748 701 : ::rtl::OUString aSubject( "Subject" );
749 701 : Any aAny;
750 701 : ::rtl::OUString aValue;
751 : uno::Reference<document::XDocumentPropertiesSupplier> xDPS(
752 701 : GetModel(), uno::UNO_QUERY_THROW);
753 : uno::Reference<document::XDocumentProperties> xDocProps
754 701 : = xDPS->getDocumentProperties();
755 701 : if ( xProps->hasPropertyByName( aAuthor ) )
756 : {
757 0 : aAny = aContent.getPropertyValue( aAuthor );
758 0 : if ( ( aAny >>= aValue ) )
759 0 : xDocProps->setAuthor(aValue);
760 : }
761 701 : if ( xProps->hasPropertyByName( aKeywords ) )
762 : {
763 0 : aAny = aContent.getPropertyValue( aKeywords );
764 0 : if ( ( aAny >>= aValue ) )
765 0 : xDocProps->setKeywords(
766 0 : ::comphelper::string::convertCommaSeparated(aValue));
767 : ;
768 : }
769 701 : if ( xProps->hasPropertyByName( aSubject ) )
770 : {
771 0 : aAny = aContent.getPropertyValue( aSubject );
772 0 : if ( ( aAny >>= aValue ) ) {
773 0 : xDocProps->setSubject(aValue);
774 : }
775 701 : }
776 701 : }
777 : }
778 2 : catch( Exception& )
779 : {
780 : }
781 :
782 : // If not loaded asynchronously call FinishedLoading
783 707 : if ( !( pImp->nLoadedFlags & SFX_LOADED_MAINDOCUMENT ) &&
784 4 : ( !pMedium->GetFilter() || pMedium->GetFilter()->UsesStorage() )
785 : )
786 2 : FinishedLoading( SFX_LOADED_MAINDOCUMENT );
787 :
788 703 : if( IsOwnStorageFormat_Impl(*pMed) && pMed->GetFilter() )
789 : {
790 : }
791 703 : Broadcast( SfxSimpleHint(SFX_HINT_NAMECHANGED) );
792 :
793 703 : if ( SFX_CREATE_MODE_EMBEDDED != eCreateMode )
794 : {
795 503 : SFX_ITEMSET_ARG( pMedium->GetItemSet(), pAsTempItem, SfxBoolItem, SID_TEMPLATE, sal_False);
796 503 : SFX_ITEMSET_ARG( pMedium->GetItemSet(), pPreviewItem, SfxBoolItem, SID_PREVIEW, sal_False);
797 503 : SFX_ITEMSET_ARG( pMedium->GetItemSet(), pHiddenItem, SfxBoolItem, SID_HIDDEN, sal_False);
798 2006 : if( bOk && !pMedium->GetOrigURL().isEmpty()
799 0 : && !( pAsTempItem && pAsTempItem->GetValue() )
800 0 : && !( pPreviewItem && pPreviewItem->GetValue() )
801 0 : && !( pHiddenItem && pHiddenItem->GetValue() ) )
802 : {
803 501 : AddToRecentlyUsedList();
804 : }
805 : }
806 :
807 : const SfxBoolItem* pDdeReconnectItem = static_cast<const SfxBoolItem*>(
808 703 : SfxRequest::GetItem(pMedium->GetItemSet(), SID_DDE_RECONNECT_ONLOAD, false, TYPE(SfxBoolItem)));
809 :
810 703 : bool bReconnectDde = true; // by default, we try to auto-connect DDE connections.
811 703 : if (pDdeReconnectItem)
812 0 : bReconnectDde = pDdeReconnectItem->GetValue();
813 :
814 703 : if (bReconnectDde)
815 703 : ReconnectDdeLinks(*this);
816 : }
817 :
818 719 : return bOk;
819 : }
820 :
821 0 : bool SfxObjectShell::DoLoadExternal(SfxMedium *pMed, const OUString& rProvider)
822 : {
823 0 : pMedium = pMed;
824 0 : return LoadExternal(*pMedium, rProvider);
825 : }
826 :
827 719 : sal_uInt32 SfxObjectShell::HandleFilter( SfxMedium* pMedium, SfxObjectShell* pDoc )
828 : {
829 719 : sal_uInt32 nError = ERRCODE_NONE;
830 719 : SfxItemSet* pSet = pMedium->GetItemSet();
831 719 : SFX_ITEMSET_ARG( pSet, pOptions, SfxStringItem, SID_FILE_FILTEROPTIONS, sal_False );
832 719 : SFX_ITEMSET_ARG( pSet, pData, SfxUnoAnyItem, SID_FILTER_DATA, sal_False );
833 719 : if ( !pData && !pOptions )
834 : {
835 713 : com::sun::star::uno::Reference< XMultiServiceFactory > xServiceManager = ::comphelper::getProcessServiceFactory();
836 713 : com::sun::star::uno::Reference< XNameAccess > xFilterCFG;
837 713 : if( xServiceManager.is() )
838 : {
839 : xFilterCFG = com::sun::star::uno::Reference< XNameAccess >(
840 713 : xServiceManager->createInstance( ::rtl::OUString("com.sun.star.document.FilterFactory") ),
841 713 : UNO_QUERY );
842 : }
843 :
844 713 : if( xFilterCFG.is() )
845 : {
846 657 : sal_Bool bAbort = sal_False;
847 : try {
848 657 : const SfxFilter* pFilter = pMedium->GetFilter();
849 657 : Sequence < PropertyValue > aProps;
850 657 : Any aAny = xFilterCFG->getByName( pFilter->GetName() );
851 657 : if ( aAny >>= aProps )
852 : {
853 657 : sal_Int32 nPropertyCount = aProps.getLength();
854 7093 : for( sal_Int32 nProperty=0; nProperty < nPropertyCount; ++nProperty )
855 7093 : if( aProps[nProperty].Name == "UIComponent" )
856 : {
857 657 : ::rtl::OUString aServiceName;
858 657 : aProps[nProperty].Value >>= aServiceName;
859 657 : if( !aServiceName.isEmpty() )
860 : {
861 8 : com::sun::star::uno::Reference< XInteractionHandler > rHandler = pMedium->GetInteractionHandler();
862 8 : if( rHandler.is() )
863 : {
864 : // we need some properties in the media descriptor, so we have to make sure that they are in
865 0 : Any aStreamAny;
866 0 : aStreamAny <<= pMedium->GetInputStream();
867 0 : if ( pSet->GetItemState( SID_INPUTSTREAM ) < SFX_ITEM_SET )
868 0 : pSet->Put( SfxUnoAnyItem( SID_INPUTSTREAM, aStreamAny ) );
869 0 : if ( pSet->GetItemState( SID_FILE_NAME ) < SFX_ITEM_SET )
870 0 : pSet->Put( SfxStringItem( SID_FILE_NAME, pMedium->GetName() ) );
871 0 : if ( pSet->GetItemState( SID_FILTER_NAME ) < SFX_ITEM_SET )
872 0 : pSet->Put( SfxStringItem( SID_FILTER_NAME, pFilter->GetName() ) );
873 :
874 0 : Sequence< PropertyValue > rProperties;
875 0 : TransformItems( SID_OPENDOC, *pSet, rProperties, NULL );
876 0 : RequestFilterOptions* pFORequest = new RequestFilterOptions( pDoc->GetModel(), rProperties );
877 :
878 0 : com::sun::star::uno::Reference< XInteractionRequest > rRequest( pFORequest );
879 0 : rHandler->handle( rRequest );
880 :
881 0 : if ( !pFORequest->isAbort() )
882 : {
883 0 : SfxAllItemSet aNewParams( pDoc->GetPool() );
884 : TransformParameters( SID_OPENDOC,
885 : pFORequest->getFilterOptions(),
886 : aNewParams,
887 0 : NULL );
888 :
889 0 : SFX_ITEMSET_ARG( &aNewParams,
890 : pFilterOptions,
891 : SfxStringItem,
892 : SID_FILE_FILTEROPTIONS,
893 : sal_False );
894 0 : if ( pFilterOptions )
895 0 : pSet->Put( *pFilterOptions );
896 :
897 0 : SFX_ITEMSET_ARG( &aNewParams,
898 : pFilterData,
899 : SfxUnoAnyItem,
900 : SID_FILTER_DATA,
901 : sal_False );
902 0 : if ( pFilterData )
903 0 : pSet->Put( *pFilterData );
904 : }
905 : else
906 0 : bAbort = sal_True;
907 8 : }
908 : }
909 :
910 657 : break;
911 : }
912 : }
913 :
914 657 : if( bAbort )
915 : {
916 : // filter options were not entered
917 0 : nError = ERRCODE_ABORT;
918 657 : }
919 : }
920 0 : catch( NoSuchElementException& )
921 : {
922 : // the filter name is unknown
923 0 : nError = ERRCODE_IO_INVALIDPARAMETER;
924 : }
925 0 : catch( Exception& )
926 : {
927 0 : nError = ERRCODE_ABORT;
928 : }
929 713 : }
930 : }
931 :
932 719 : return nError;
933 : }
934 :
935 : //-------------------------------------------------------------------------
936 :
937 2383 : sal_Bool SfxObjectShell::IsOwnStorageFormat_Impl(const SfxMedium &rMedium) const
938 : {
939 2383 : return !rMedium.GetFilter() || // Embedded
940 2377 : ( rMedium.GetFilter()->IsOwnFormat() &&
941 343 : rMedium.GetFilter()->UsesStorage() &&
942 5103 : rMedium.GetFilter()->GetVersion() >= SOFFICE_FILEFORMAT_60 );
943 : }
944 :
945 : //-------------------------------------------------------------------------
946 :
947 1941 : sal_Bool SfxObjectShell::IsPackageStorageFormat_Impl(const SfxMedium &rMedium) const
948 : {
949 1941 : return !rMedium.GetFilter() || // Embedded
950 1935 : ( rMedium.GetFilter()->UsesStorage() &&
951 3876 : rMedium.GetFilter()->GetVersion() >= SOFFICE_FILEFORMAT_60 );
952 : }
953 :
954 : //-------------------------------------------------------------------------
955 :
956 0 : sal_Bool SfxObjectShell::DoSave()
957 : // DoSave is only invoked for OLE. Save your own documents in the SFX through
958 : // DoSave_Impl order to allow for the creation of backups.
959 : // Save in your own format again.
960 : {
961 0 : sal_Bool bOk = sal_False ;
962 : {
963 0 : ModifyBlocker_Impl aBlock( this );
964 :
965 0 : pImp->bIsSaving = sal_True;
966 :
967 0 : uno::Sequence< beans::NamedValue > aEncryptionData;
968 0 : if ( IsPackageStorageFormat_Impl( *GetMedium() ) )
969 : {
970 0 : if ( GetEncryptionData_Impl( GetMedium()->GetItemSet(), aEncryptionData ) )
971 : {
972 : try
973 : {
974 : //TODO/MBA: GetOutputStorage?! Special mode, because it's "Save"?!
975 0 : ::comphelper::OStorageHelper::SetCommonStorageEncryptionData( GetMedium()->GetStorage(), aEncryptionData );
976 0 : bOk = sal_True;
977 : }
978 0 : catch( uno::Exception& )
979 : {
980 0 : SetError( ERRCODE_IO_GENERAL, ::rtl::OUString( OSL_LOG_PREFIX ) );
981 : }
982 :
983 : DBG_ASSERT( bOk, "The root storage must allow to set common password!\n" );
984 : }
985 : else
986 0 : bOk = sal_True;
987 : #ifndef DISABLE_SCRIPTING
988 0 : if ( HasBasic() )
989 : {
990 : try
991 : {
992 : // The basic and dialogs related contents are still not able to proceed with save operation ( saveTo only )
993 : // so since the document storage is locked a workaround has to be used
994 :
995 0 : uno::Reference< embed::XStorage > xTmpStorage = ::comphelper::OStorageHelper::GetTemporaryStorage();
996 : DBG_ASSERT( xTmpStorage.is(), "If a storage can not be created an exception must be thrown!\n" );
997 0 : if ( !xTmpStorage.is() )
998 0 : throw uno::RuntimeException();
999 :
1000 0 : ::rtl::OUString aBasicStorageName( "Basic" );
1001 0 : ::rtl::OUString aDialogsStorageName( "Dialogs" );
1002 0 : if ( GetMedium()->GetStorage()->hasByName( aBasicStorageName ) )
1003 0 : GetMedium()->GetStorage()->copyElementTo( aBasicStorageName, xTmpStorage, aBasicStorageName );
1004 0 : if ( GetMedium()->GetStorage()->hasByName( aDialogsStorageName ) )
1005 0 : GetMedium()->GetStorage()->copyElementTo( aDialogsStorageName, xTmpStorage, aDialogsStorageName );
1006 :
1007 0 : GetBasicManager();
1008 :
1009 : // disconnect from the current storage
1010 0 : pImp->pBasicManager->setStorage( xTmpStorage );
1011 :
1012 : // store to the current storage
1013 0 : pImp->pBasicManager->storeLibrariesToStorage( GetMedium()->GetStorage() );
1014 :
1015 : // connect to the current storage back
1016 0 : pImp->pBasicManager->setStorage( GetMedium()->GetStorage() );
1017 : }
1018 0 : catch( uno::Exception& )
1019 : {
1020 0 : SetError( ERRCODE_IO_GENERAL, ::rtl::OUString( OSL_LOG_PREFIX ) );
1021 0 : bOk = sal_False;
1022 : }
1023 : }
1024 : #endif
1025 : }
1026 :
1027 0 : if ( bOk )
1028 0 : bOk = Save();
1029 :
1030 0 : bOk = pMedium->Commit();
1031 : }
1032 :
1033 0 : return bOk;
1034 : }
1035 :
1036 248 : void Lock_Impl( SfxObjectShell* pDoc, sal_Bool bLock )
1037 : {
1038 248 : SfxViewFrame *pFrame= SfxViewFrame::GetFirst( pDoc );
1039 728 : while ( pFrame )
1040 : {
1041 232 : pFrame->GetDispatcher()->Lock( bLock );
1042 232 : pFrame->Enable( !bLock );
1043 232 : pFrame = SfxViewFrame::GetNext( *pFrame, pDoc );
1044 : }
1045 :
1046 248 : }
1047 :
1048 : //-------------------------------------------------------------------------
1049 :
1050 124 : sal_Bool SfxObjectShell::SaveTo_Impl
1051 : (
1052 : SfxMedium &rMedium, // Medium, in which it will be stored
1053 : const SfxItemSet* pSet
1054 : )
1055 :
1056 : /* [Description]
1057 :
1058 : Writes the current contents to the medium rMedium. If the target medium is
1059 : no storage, then saving to a temporary storage, or directly if the medium
1060 : is transacted, if we ourselves have opened it, and if we are a server
1061 : either the container a transacted storage provides or created a
1062 : temporary storage by one self.
1063 : */
1064 :
1065 : {
1066 124 : RTL_LOGFILE_PRODUCT_CONTEXT( aLog, "PERFORMANCE SfxObjectShell::SaveTo_Impl" );
1067 124 : if( RTL_LOGFILE_HASLOGFILE() )
1068 : {
1069 : rtl::OString aString(
1070 0 : rtl::OUStringToOString(rMedium.GetName(), RTL_TEXTENCODING_ASCII_US));
1071 0 : RTL_LOGFILE_PRODUCT_CONTEXT_TRACE1(aLog, "saving \"%s\"", aString.getStr());
1072 : }
1073 :
1074 124 : AddLog( ::rtl::OUString( OSL_LOG_PREFIX "Begin" ) );
1075 :
1076 124 : ModifyBlocker_Impl aMod(this);
1077 :
1078 124 : const SfxFilter *pFilter = rMedium.GetFilter();
1079 124 : if ( !pFilter )
1080 : {
1081 : // if no filter was set, use the default filter
1082 : // this should be changed in the feature, it should be an error!
1083 : OSL_FAIL("No filter set!");
1084 0 : pFilter = GetFactory().GetFilterContainer()->GetAnyFilter( SFX_FILTER_IMPORT | SFX_FILTER_EXPORT );
1085 0 : rMedium.SetFilter(pFilter);
1086 : }
1087 :
1088 124 : sal_Bool bStorageBasedSource = IsPackageStorageFormat_Impl( *pMedium );
1089 124 : sal_Bool bStorageBasedTarget = IsPackageStorageFormat_Impl( rMedium );
1090 124 : sal_Bool bOwnSource = IsOwnStorageFormat_Impl( *pMedium );
1091 124 : sal_Bool bOwnTarget = IsOwnStorageFormat_Impl( rMedium );
1092 :
1093 : // Examine target format to determine whether to query if any password
1094 : // protected libraries exceed the size we can handler
1095 124 : if ( bOwnTarget && !QuerySaveSizeExceededModules_Impl( rMedium.GetInteractionHandler() ) )
1096 : {
1097 0 : SetError( ERRCODE_IO_ABORT, ::rtl::OUString( OSL_LOG_PREFIX ) );
1098 0 : return sal_False;
1099 : }
1100 :
1101 124 : sal_Bool bNeedsDisconnectionOnFail = sal_False;
1102 :
1103 124 : sal_Bool bStoreToSameLocation = sal_False;
1104 :
1105 : // the detection whether the script is changed should be done before saving
1106 124 : sal_Bool bTryToPreserveScriptSignature = sal_False;
1107 : // no way to detect whether a filter is oasis format, have to wait for saving process
1108 124 : sal_Bool bNoPreserveForOasis = sal_False;
1109 124 : if ( bOwnSource && bOwnTarget
1110 : && ( pImp->nScriptingSignatureState == SIGNATURESTATE_SIGNATURES_OK
1111 : || pImp->nScriptingSignatureState == SIGNATURESTATE_SIGNATURES_NOTVALIDATED
1112 : || pImp->nScriptingSignatureState == SIGNATURESTATE_SIGNATURES_INVALID ) )
1113 : {
1114 0 : AddLog( ::rtl::OUString( OSL_LOG_PREFIX "MacroSignaturePreserving" ) );
1115 :
1116 : // the checking of the library modified state iterates over the libraries, should be done only when required
1117 : // currently the check is commented out since it is broken, we have to check the signature every time we save
1118 : // TODO/LATER: let isAnyContainerModified() work!
1119 0 : bTryToPreserveScriptSignature = sal_True; // !pImp->pBasicManager->isAnyContainerModified();
1120 0 : if ( bTryToPreserveScriptSignature )
1121 : {
1122 : // check that the storage format stays the same
1123 0 : SvtSaveOptions aSaveOpt;
1124 0 : SvtSaveOptions::ODFDefaultVersion nVersion = aSaveOpt.GetODFDefaultVersion();
1125 :
1126 0 : ::rtl::OUString aODFVersion;
1127 : try
1128 : {
1129 0 : uno::Reference < beans::XPropertySet > xPropSet( GetStorage(), uno::UNO_QUERY_THROW );
1130 0 : xPropSet->getPropertyValue( ::rtl::OUString( "Version" ) ) >>= aODFVersion;
1131 : }
1132 0 : catch( uno::Exception& )
1133 : {}
1134 :
1135 : // preserve only if the same filter has been used
1136 0 : bTryToPreserveScriptSignature = pMedium->GetFilter() && pFilter && pMedium->GetFilter()->GetFilterName() == pFilter->GetFilterName();
1137 :
1138 : bNoPreserveForOasis = (
1139 0 : (aODFVersion.equals( ODFVER_012_TEXT ) && nVersion == SvtSaveOptions::ODFVER_011) ||
1140 0 : (aODFVersion.isEmpty() && nVersion >= SvtSaveOptions::ODFVER_012)
1141 0 : );
1142 : }
1143 : }
1144 :
1145 124 : sal_Bool bCopyTo = sal_False;
1146 124 : SfxItemSet *pMedSet = rMedium.GetItemSet();
1147 124 : if( pMedSet )
1148 : {
1149 124 : SFX_ITEMSET_ARG( pMedSet, pSaveToItem, SfxBoolItem, SID_SAVETO, sal_False );
1150 124 : bCopyTo = GetCreateMode() == SFX_CREATE_MODE_EMBEDDED ||
1151 124 : (pSaveToItem && pSaveToItem->GetValue());
1152 : }
1153 :
1154 : // use UCB for case sensitive/insensitive file name comparison
1155 496 : if ( pMedium
1156 124 : && !pMedium->GetName().equalsIgnoreAsciiCaseAscii("private:stream")
1157 124 : && !rMedium.GetName().equalsIgnoreAsciiCaseAscii("private:stream")
1158 124 : && ::utl::UCBContentHelper::EqualURLs( pMedium->GetName(), rMedium.GetName() ) )
1159 : {
1160 0 : bStoreToSameLocation = sal_True;
1161 0 : AddLog( ::rtl::OUString( OSL_LOG_PREFIX "Save" ) );
1162 :
1163 0 : if ( pMedium->DocNeedsFileDateCheck() )
1164 0 : rMedium.CheckFileDate( pMedium->GetInitFileDate( sal_False ) );
1165 :
1166 0 : if ( bCopyTo && GetCreateMode() != SFX_CREATE_MODE_EMBEDDED )
1167 : {
1168 : // export to the same location is forbidden
1169 0 : SetError( ERRCODE_IO_CANTWRITE, ::rtl::OUString( OSL_LOG_PREFIX ) );
1170 : }
1171 : else
1172 : {
1173 : // before we overwrite the original file, we will make a backup if there is a demand for that
1174 : // if the backup is not created here it will be created internally and will be removed in case of successful saving
1175 0 : const sal_Bool bDoBackup = SvtSaveOptions().IsBackup();
1176 0 : if ( bDoBackup )
1177 : {
1178 0 : AddLog( ::rtl::OUString( OSL_LOG_PREFIX "DoBackup" ) );
1179 0 : rMedium.DoBackup_Impl();
1180 0 : if ( rMedium.GetError() )
1181 : {
1182 0 : SetError( rMedium.GetErrorCode(), ::rtl::OUString( OSL_LOG_PREFIX ) );
1183 0 : rMedium.ResetError();
1184 : }
1185 : }
1186 :
1187 0 : if ( bStorageBasedSource && bStorageBasedTarget )
1188 : {
1189 : // The active storage must be switched. The simple saving is not enough.
1190 : // The problem is that the target medium contains target MediaDescriptor.
1191 :
1192 : // In future the switch of the persistance could be done on stream level:
1193 : // a new wrapper service will be implemented that allows to exchange
1194 : // persistance on the fly. So the real persistance will be set
1195 : // to that stream only after successful commit of the storage.
1196 : // TODO/LATER:
1197 : // create wrapper stream based on the URL
1198 : // create a new storage based on this stream
1199 : // store to this new storage
1200 : // commit the new storage
1201 : // call saveCompleted based with this new storage ( get rid of old storage and "frees" URL )
1202 : // commit the wrapper stream ( the stream will connect the URL only on commit, after that it will hold it )
1203 : // if the last step is failed the stream should stay to be transacted and should be commited on any flush
1204 : // so we can forget the stream in any way and the next storage commit will flush it
1205 :
1206 0 : AddLog( ::rtl::OUString( OSL_LOG_PREFIX "Save: Own to Own" ) );
1207 :
1208 : bNeedsDisconnectionOnFail = DisconnectStorage_Impl(
1209 0 : *pMedium, rMedium );
1210 0 : if ( bNeedsDisconnectionOnFail
1211 0 : || ConnectTmpStorage_Impl( pMedium->GetStorage(), pMedium ) )
1212 : {
1213 0 : pMedium->CloseAndRelease();
1214 :
1215 : // TODO/LATER: for now the medium must be closed since it can already contain streams from old medium
1216 : // in future those streams should not be copied in case a valid target url is provided,
1217 : // if the url is not provided ( means the document is based on a stream ) this code is not
1218 : // reachable.
1219 0 : rMedium.CloseAndRelease();
1220 0 : rMedium.GetOutputStorage();
1221 : }
1222 : }
1223 0 : else if ( !bStorageBasedSource && !bStorageBasedTarget )
1224 : {
1225 : // the source and the target formats are alien
1226 : // just disconnect the stream from the source format
1227 : // so that the target medium can use it
1228 :
1229 0 : AddLog( ::rtl::OUString( OSL_LOG_PREFIX "Save: Alien to Alien" ) );
1230 :
1231 0 : pMedium->CloseAndRelease();
1232 0 : rMedium.CloseAndRelease();
1233 0 : rMedium.CreateTempFileNoCopy();
1234 0 : rMedium.GetOutStream();
1235 : }
1236 0 : else if ( !bStorageBasedSource && bStorageBasedTarget )
1237 : {
1238 : // the source format is an alien one but the target
1239 : // format is an own one so just disconnect the source
1240 : // medium
1241 :
1242 0 : AddLog( ::rtl::OUString( OSL_LOG_PREFIX "Save: Alien to Own" ) );
1243 :
1244 0 : pMedium->CloseAndRelease();
1245 0 : rMedium.CloseAndRelease();
1246 0 : rMedium.GetOutputStorage();
1247 : }
1248 : else // means if ( bStorageBasedSource && !bStorageBasedTarget )
1249 : {
1250 : // the source format is an own one but the target is
1251 : // an alien format, just connect the source to temporary
1252 : // storage
1253 :
1254 0 : AddLog( ::rtl::OUString( OSL_LOG_PREFIX "Save: Own to Alien" ) );
1255 :
1256 : bNeedsDisconnectionOnFail = DisconnectStorage_Impl(
1257 0 : *pMedium, rMedium );
1258 0 : if ( bNeedsDisconnectionOnFail
1259 0 : || ConnectTmpStorage_Impl( pMedium->GetStorage(), pMedium ) )
1260 : {
1261 0 : pMedium->CloseAndRelease();
1262 0 : rMedium.CloseAndRelease();
1263 0 : rMedium.CreateTempFileNoCopy();
1264 0 : rMedium.GetOutStream();
1265 : }
1266 : }
1267 : }
1268 : }
1269 : else
1270 : {
1271 : // This is SaveAs or export action, prepare the target medium
1272 : // the alien filters still might write directly to the file, that is of course a bug,
1273 : // but for now the framework has to be ready for it
1274 : // TODO/LATER: let the medium be prepared for alien formats as well
1275 :
1276 124 : AddLog( ::rtl::OUString( OSL_LOG_PREFIX "SaveAs/Export" ) );
1277 :
1278 124 : rMedium.CloseAndRelease();
1279 124 : if ( bStorageBasedTarget )
1280 : {
1281 10 : rMedium.GetOutputStorage();
1282 : }
1283 : }
1284 :
1285 : // TODO/LATER: error handling
1286 124 : if( rMedium.GetErrorCode() || pMedium->GetErrorCode() || GetErrorCode() )
1287 0 : return sal_False;
1288 :
1289 124 : AddLog( ::rtl::OUString( OSL_LOG_PREFIX "Locking" ) );
1290 :
1291 124 : rMedium.LockOrigFileOnDemand( sal_False, sal_False );
1292 :
1293 124 : if ( bStorageBasedTarget )
1294 : {
1295 10 : if ( rMedium.GetErrorCode() )
1296 0 : return sal_False;
1297 :
1298 : // If the filter is a "cross export" filter ( f.e. a filter for exporting an impress document from
1299 : // a draw document ), the ClassId of the destination storage is different from the ClassId of this
1300 : // document. It can be retrieved from the default filter for the desired target format
1301 10 : long nFormat = rMedium.GetFilter()->GetFormat();
1302 10 : SfxFilterMatcher& rMatcher = SFX_APP()->GetFilterMatcher();
1303 10 : const SfxFilter *pFilt = rMatcher.GetFilter4ClipBoardId( nFormat );
1304 10 : if ( pFilt )
1305 : {
1306 10 : if ( pFilt->GetServiceName() != rMedium.GetFilter()->GetServiceName() )
1307 : {
1308 6 : datatransfer::DataFlavor aDataFlavor;
1309 6 : SotExchange::GetFormatDataFlavor( nFormat, aDataFlavor );
1310 :
1311 : try
1312 : {
1313 6 : uno::Reference< beans::XPropertySet > xProps( rMedium.GetStorage(), uno::UNO_QUERY );
1314 : DBG_ASSERT( xProps.is(), "The storage implementation must implement XPropertySet!" );
1315 6 : if ( !xProps.is() )
1316 0 : throw uno::RuntimeException();
1317 :
1318 6 : xProps->setPropertyValue( ::rtl::OUString("MediaType"),
1319 6 : uno::makeAny( aDataFlavor.MimeType ) );
1320 : }
1321 0 : catch( uno::Exception& )
1322 : {
1323 6 : }
1324 : }
1325 : }
1326 : }
1327 :
1328 : // TODO/LATER: error handling
1329 124 : if( rMedium.GetErrorCode() || pMedium->GetErrorCode() || GetErrorCode() )
1330 0 : return sal_False;
1331 :
1332 124 : sal_Bool bOldStat = pImp->bForbidReload;
1333 124 : pImp->bForbidReload = sal_True;
1334 :
1335 : // lock user interface while saving the document
1336 124 : Lock_Impl( this, sal_True );
1337 :
1338 124 : sal_Bool bOk = sal_False;
1339 : // TODO/LATER: get rid of bOk
1340 :
1341 124 : if( bOwnTarget && !( pFilter->GetFilterFlags() & SFX_FILTER_STARONEFILTER ) )
1342 : {
1343 8 : AddLog( ::rtl::OUString( OSL_LOG_PREFIX "Storing in own format." ) );
1344 8 : uno::Reference< embed::XStorage > xMedStorage = rMedium.GetStorage();
1345 8 : if ( !xMedStorage.is() )
1346 : {
1347 : // no saving without storage, unlock UI and return
1348 0 : Lock_Impl( this, sal_False );
1349 0 : pImp->bForbidReload = bOldStat;
1350 0 : AddLog( ::rtl::OUString( OSL_LOG_PREFIX "Storing failed, still no error set." ) );
1351 0 : return sal_False;
1352 : }
1353 :
1354 : // transfer password from the parameters to the storage
1355 8 : uno::Sequence< beans::NamedValue > aEncryptionData;
1356 8 : sal_Bool bPasswdProvided = sal_False;
1357 8 : if ( GetEncryptionData_Impl( rMedium.GetItemSet(), aEncryptionData ) )
1358 : {
1359 2 : bPasswdProvided = sal_True;
1360 : try {
1361 2 : ::comphelper::OStorageHelper::SetCommonStorageEncryptionData( xMedStorage, aEncryptionData );
1362 2 : bOk = sal_True;
1363 : }
1364 0 : catch( uno::Exception& )
1365 : {
1366 : OSL_FAIL( "Setting of common encryption key failed!" );
1367 0 : SetError( ERRCODE_IO_GENERAL, ::rtl::OUString( OSL_LOG_PREFIX ) );
1368 : }
1369 : }
1370 : else
1371 6 : bOk = sal_True;
1372 :
1373 8 : pFilter = rMedium.GetFilter();
1374 :
1375 8 : const SfxStringItem *pVersionItem = ( !rMedium.IsInCheckIn( ) && pSet ) ? (const SfxStringItem*)
1376 8 : SfxRequest::GetItem( pSet, SID_DOCINFO_COMMENTS, sal_False, TYPE(SfxStringItem) ) : NULL;
1377 8 : ::rtl::OUString aTmpVersionURL;
1378 :
1379 8 : if ( bOk )
1380 : {
1381 8 : bOk = sal_False;
1382 : // currently the case that the storage is the same should be impossible
1383 8 : if ( xMedStorage == GetStorage() )
1384 : {
1385 : OSL_ENSURE( !pVersionItem, "This scenario is impossible currently!\n" );
1386 0 : AddLog( ::rtl::OUString( OSL_LOG_PREFIX "Should be impossible." ) );
1387 : // usual save procedure
1388 0 : bOk = Save();
1389 : }
1390 : else
1391 : {
1392 : // save to target
1393 8 : AddLog( ::rtl::OUString( OSL_LOG_PREFIX "Save as own format." ) );
1394 8 : bOk = SaveAsOwnFormat( rMedium );
1395 8 : if ( bOk && pVersionItem )
1396 : {
1397 0 : AddLog( ::rtl::OUString( OSL_LOG_PREFIX "pVersionItem != NULL" ) );
1398 0 : aTmpVersionURL = CreateTempCopyOfStorage_Impl( xMedStorage );
1399 0 : bOk = !aTmpVersionURL.isEmpty();
1400 : }
1401 : }
1402 : }
1403 :
1404 :
1405 8 : if ( bOk && GetCreateMode() != SFX_CREATE_MODE_EMBEDDED && !bPasswdProvided )
1406 : {
1407 : // store the thumbnail representation image
1408 : // the thumbnail is not stored in case of encrypted document
1409 6 : AddLog( ::rtl::OUString( OSL_LOG_PREFIX "Thumbnail creation." ) );
1410 6 : if ( !GenerateAndStoreThumbnail( bPasswdProvided,
1411 : sal_False,
1412 6 : pFilter->IsOwnTemplateFormat(),
1413 6 : xMedStorage ) )
1414 : {
1415 : // TODO: error handling
1416 : OSL_FAIL( "Couldn't store thumbnail representation!" );
1417 : }
1418 : }
1419 :
1420 8 : if ( bOk )
1421 : {
1422 8 : if ( pImp->bIsSaving || pImp->bPreserveVersions )
1423 : {
1424 8 : AddLog( ::rtl::OUString( OSL_LOG_PREFIX "Preserve versions." ) );
1425 : try
1426 : {
1427 8 : Sequence < util::RevisionTag > aVersions = rMedium.GetVersionList();
1428 8 : if ( aVersions.getLength() )
1429 : {
1430 : // copy the version streams
1431 0 : ::rtl::OUString aVersionsName( "Versions" );
1432 0 : uno::Reference< embed::XStorage > xNewVerStor = xMedStorage->openStorageElement(
1433 : aVersionsName,
1434 0 : embed::ElementModes::READWRITE );
1435 0 : uno::Reference< embed::XStorage > xOldVerStor = GetStorage()->openStorageElement(
1436 : aVersionsName,
1437 0 : embed::ElementModes::READ );
1438 0 : if ( !xNewVerStor.is() || !xOldVerStor.is() )
1439 0 : throw uno::RuntimeException();
1440 :
1441 0 : for ( sal_Int32 n=0; n<aVersions.getLength(); n++ )
1442 : {
1443 0 : if ( xOldVerStor->hasByName( aVersions[n].Identifier ) )
1444 0 : xOldVerStor->copyElementTo( aVersions[n].Identifier, xNewVerStor, aVersions[n].Identifier );
1445 : }
1446 :
1447 0 : uno::Reference< embed::XTransactedObject > xTransact( xNewVerStor, uno::UNO_QUERY );
1448 0 : if ( xTransact.is() )
1449 0 : xTransact->commit();
1450 8 : }
1451 : }
1452 0 : catch( uno::Exception& )
1453 : {
1454 0 : AddLog( ::rtl::OUString( OSL_LOG_PREFIX "Preserve versions has failed." ) );
1455 : OSL_FAIL( "Couldn't copy versions!\n" );
1456 0 : bOk = sal_False;
1457 : // TODO/LATER: a specific error could be set
1458 : }
1459 : }
1460 :
1461 8 : if ( bOk && pVersionItem && !rMedium.IsInCheckIn() )
1462 : {
1463 : // store a version also
1464 : const SfxStringItem *pAuthorItem = pSet ? (const SfxStringItem*)
1465 0 : SfxRequest::GetItem( pSet, SID_DOCINFO_AUTHOR, sal_False, TYPE(SfxStringItem) ) : NULL;
1466 :
1467 : // version comment
1468 0 : util::RevisionTag aInfo;
1469 0 : aInfo.Comment = pVersionItem->GetValue();
1470 :
1471 : // version author
1472 0 : if ( pAuthorItem )
1473 0 : aInfo.Author = pAuthorItem->GetValue();
1474 : else
1475 : // if not transferred as a parameter, get it from user settings
1476 0 : aInfo.Author = SvtUserOptions().GetFullName();
1477 :
1478 0 : DateTime aTime( DateTime::SYSTEM );
1479 0 : aInfo.TimeStamp.Day = aTime.GetDay();
1480 0 : aInfo.TimeStamp.Month = aTime.GetMonth();
1481 0 : aInfo.TimeStamp.Year = aTime.GetYear();
1482 0 : aInfo.TimeStamp.Hours = aTime.GetHour();
1483 0 : aInfo.TimeStamp.Minutes = aTime.GetMin();
1484 0 : aInfo.TimeStamp.Seconds = aTime.GetSec();
1485 :
1486 0 : if ( bOk )
1487 : {
1488 : // add new version information into the versionlist and save the versionlist
1489 : // the version list must have been transferred from the "old" medium before
1490 0 : rMedium.AddVersion_Impl( aInfo );
1491 0 : rMedium.SaveVersionList_Impl( sal_True );
1492 0 : bOk = PutURLContentsToVersionStream_Impl( aTmpVersionURL, xMedStorage, aInfo.Identifier );
1493 0 : }
1494 : }
1495 8 : else if ( bOk && ( pImp->bIsSaving || pImp->bPreserveVersions ) )
1496 : {
1497 8 : rMedium.SaveVersionList_Impl( sal_True );
1498 : }
1499 : }
1500 :
1501 8 : if ( !aTmpVersionURL.isEmpty() )
1502 0 : ::utl::UCBContentHelper::Kill( aTmpVersionURL );
1503 : }
1504 : else
1505 : {
1506 116 : AddLog( ::rtl::OUString( OSL_LOG_PREFIX "Storing in alien format." ) );
1507 : // it's a "SaveAs" in an alien format
1508 116 : if ( rMedium.GetFilter() && ( rMedium.GetFilter()->GetFilterFlags() & SFX_FILTER_STARONEFILTER ) )
1509 106 : bOk = ExportTo( rMedium );
1510 : else
1511 10 : bOk = ConvertTo( rMedium );
1512 :
1513 : // after saving the document, the temporary object storage must be updated
1514 : // if the old object storage was not a temporary one, it will be updated also, because it will be used
1515 : // as a source for copying the objects into the new temporary storage that will be created below
1516 : // updating means: all child objects must be stored into it
1517 : // ( same as on loading, where these objects are copied to the temporary storage )
1518 : // but don't commit these changes, because in the case when the old object storage is not a temporary one,
1519 : // all changes will be written into the original file !
1520 :
1521 116 : if( bOk && !bCopyTo )
1522 : // we also don't touch any graphical replacements here
1523 0 : bOk = SaveChildren( sal_True );
1524 : }
1525 :
1526 124 : if ( bOk )
1527 : {
1528 : // if ODF version of oasis format changes on saving the signature should not be preserved
1529 124 : if ( bOk && bTryToPreserveScriptSignature && bNoPreserveForOasis )
1530 0 : bTryToPreserveScriptSignature = ( SotStorage::GetVersion( rMedium.GetStorage() ) == SOFFICE_FILEFORMAT_60 );
1531 :
1532 124 : uno::Reference< security::XDocumentDigitalSignatures > xDDSigns;
1533 124 : if ( bOk && bTryToPreserveScriptSignature )
1534 : {
1535 0 : AddLog( ::rtl::OUString( OSL_LOG_PREFIX "Copying scripting signature." ) );
1536 :
1537 : // if the scripting code was not changed and it is signed the signature should be preserved
1538 : // unfortunately at this point we have only information whether the basic code has changed or not
1539 : // so the only way is to check the signature if the basic was not changed
1540 : try
1541 : {
1542 : // get the ODF version of the new medium
1543 0 : OUString aVersion;
1544 : try
1545 : {
1546 0 : uno::Reference < beans::XPropertySet > xPropSet( rMedium.GetStorage(), uno::UNO_QUERY_THROW );
1547 0 : xPropSet->getPropertyValue( ::rtl::OUString( "Version" ) ) >>= aVersion;
1548 : }
1549 0 : catch( uno::Exception& )
1550 : {
1551 : }
1552 :
1553 0 : xDDSigns = security::DocumentDigitalSignatures::createWithVersion(comphelper::getProcessComponentContext(), aVersion);
1554 :
1555 0 : ::rtl::OUString aScriptSignName = xDDSigns->getScriptingContentSignatureDefaultStreamName();
1556 :
1557 0 : if ( !aScriptSignName.isEmpty() )
1558 : {
1559 0 : pMedium->Close();
1560 :
1561 : // target medium is still not commited, it should not be closed
1562 : // commit the package storage and close it, but leave the streams open
1563 0 : rMedium.StorageCommit_Impl();
1564 0 : rMedium.CloseStorage();
1565 :
1566 0 : uno::Reference< embed::XStorage > xReadOrig = pMedium->GetZipStorageToSign_Impl();
1567 0 : if ( !xReadOrig.is() )
1568 0 : throw uno::RuntimeException();
1569 0 : uno::Reference< embed::XStorage > xMetaInf = xReadOrig->openStorageElement(
1570 : ::rtl::OUString( "META-INF" ),
1571 0 : embed::ElementModes::READ );
1572 :
1573 0 : uno::Reference< embed::XStorage > xTarget = rMedium.GetZipStorageToSign_Impl( sal_False );
1574 0 : if ( !xTarget.is() )
1575 0 : throw uno::RuntimeException();
1576 0 : uno::Reference< embed::XStorage > xTargetMetaInf = xTarget->openStorageElement(
1577 : ::rtl::OUString( "META-INF" ),
1578 0 : embed::ElementModes::READWRITE );
1579 :
1580 0 : if ( xMetaInf.is() && xTargetMetaInf.is() )
1581 : {
1582 0 : xMetaInf->copyElementTo( aScriptSignName, xTargetMetaInf, aScriptSignName );
1583 :
1584 0 : uno::Reference< embed::XTransactedObject > xTransact( xTargetMetaInf, uno::UNO_QUERY );
1585 0 : if ( xTransact.is() )
1586 0 : xTransact->commit();
1587 :
1588 0 : xTargetMetaInf->dispose();
1589 :
1590 : // now check the copied signature
1591 : uno::Sequence< security::DocumentSignatureInformation > aInfos =
1592 0 : xDDSigns->verifyScriptingContentSignatures( xTarget,
1593 0 : uno::Reference< io::XInputStream >() );
1594 0 : sal_uInt16 nState = ImplCheckSignaturesInformation( aInfos );
1595 0 : if ( nState == SIGNATURESTATE_SIGNATURES_OK || nState == SIGNATURESTATE_SIGNATURES_NOTVALIDATED
1596 : || nState == SIGNATURESTATE_SIGNATURES_PARTIAL_OK)
1597 : {
1598 0 : rMedium.SetCachedSignatureState_Impl( nState );
1599 :
1600 : // commit the ZipStorage from target medium
1601 0 : xTransact.set( xTarget, uno::UNO_QUERY );
1602 0 : if ( xTransact.is() )
1603 0 : xTransact->commit();
1604 : }
1605 : else
1606 : {
1607 : // it should not happen, the copies signature is invalid!
1608 : // throw the changes away
1609 : OSL_FAIL( "An invalid signature was copied!" );
1610 0 : }
1611 0 : }
1612 0 : }
1613 : }
1614 0 : catch( uno::Exception& )
1615 : {
1616 : }
1617 :
1618 0 : pMedium->Close();
1619 0 : rMedium.CloseZipStorage_Impl();
1620 : }
1621 :
1622 124 : AddLog( ::rtl::OUString( OSL_LOG_PREFIX "Medium commit." ) );
1623 :
1624 124 : rtl::OUString sName( rMedium.GetName( ) );
1625 124 : bOk = rMedium.Commit();
1626 124 : rtl::OUString sNewName( rMedium.GetName( ) );
1627 :
1628 124 : if ( sName != sNewName )
1629 0 : GetMedium( )->SwitchDocumentToFile( sNewName );
1630 :
1631 124 : if ( bOk )
1632 : {
1633 124 : AddLog( ::rtl::OUString( OSL_LOG_PREFIX "Storing is successful." ) );
1634 :
1635 : // if the target medium is an alien format and the "old" medium was an own format and the "old" medium
1636 : // has a name, the object storage must be exchanged, because now we need a new temporary storage
1637 : // as object storage
1638 124 : if ( !bCopyTo && bStorageBasedSource && !bStorageBasedTarget )
1639 : {
1640 0 : if ( bStoreToSameLocation )
1641 : {
1642 : // if the old medium already disconnected from document storage, the storage still must
1643 : // be switched if backup file is used
1644 0 : if ( bNeedsDisconnectionOnFail )
1645 0 : ConnectTmpStorage_Impl( pImp->m_xDocStorage, NULL );
1646 : }
1647 0 : else if (!pMedium->GetName().isEmpty()
1648 0 : || ( pMedium->HasStorage_Impl() && pMedium->WillDisposeStorageOnClose_Impl() ) )
1649 : {
1650 : OSL_ENSURE(!pMedium->GetName().isEmpty(), "Fallback is used, the medium without name should not dispose the storage!\n");
1651 : // copy storage of old medium to new temporary storage and take this over
1652 0 : if( !ConnectTmpStorage_Impl( pMedium->GetStorage(), pMedium ) )
1653 : {
1654 0 : AddLog( ::rtl::OUString( OSL_LOG_PREFIX "Process after storing has failed." ) );
1655 0 : bOk = sal_False;
1656 : }
1657 : }
1658 : }
1659 : }
1660 : else
1661 : {
1662 0 : AddLog( ::rtl::OUString( OSL_LOG_PREFIX "Storing has failed." ) );
1663 :
1664 : // in case the document storage was connected to backup temporarely it must be disconnected now
1665 0 : if ( bNeedsDisconnectionOnFail )
1666 0 : ConnectTmpStorage_Impl( pImp->m_xDocStorage, NULL );
1667 124 : }
1668 : }
1669 :
1670 : // unlock user interface
1671 124 : Lock_Impl( this, sal_False );
1672 124 : pImp->bForbidReload = bOldStat;
1673 :
1674 124 : if ( bOk )
1675 : {
1676 : try
1677 : {
1678 124 : ::ucbhelper::Content aContent( rMedium.GetName(), com::sun::star::uno::Reference < XCommandEnvironment >(), comphelper::getProcessComponentContext() );
1679 124 : com::sun::star::uno::Reference < XPropertySetInfo > xProps = aContent.getProperties();
1680 124 : if ( xProps.is() )
1681 : {
1682 124 : ::rtl::OUString aAuthor( "Author" );
1683 124 : ::rtl::OUString aKeywords( "Keywords" );
1684 124 : ::rtl::OUString aSubject( "Subject" );
1685 124 : Any aAny;
1686 :
1687 : uno::Reference<document::XDocumentPropertiesSupplier> xDPS(
1688 124 : GetModel(), uno::UNO_QUERY_THROW);
1689 : uno::Reference<document::XDocumentProperties> xDocProps
1690 124 : = xDPS->getDocumentProperties();
1691 :
1692 124 : if ( xProps->hasPropertyByName( aAuthor ) )
1693 : {
1694 0 : aAny <<= xDocProps->getAuthor();
1695 0 : aContent.setPropertyValue( aAuthor, aAny );
1696 : }
1697 124 : if ( xProps->hasPropertyByName( aKeywords ) )
1698 : {
1699 : aAny <<= ::comphelper::string::convertCommaSeparated(
1700 0 : xDocProps->getKeywords());
1701 0 : aContent.setPropertyValue( aKeywords, aAny );
1702 : }
1703 124 : if ( xProps->hasPropertyByName( aSubject ) )
1704 : {
1705 0 : aAny <<= xDocProps->getSubject();
1706 0 : aContent.setPropertyValue( aSubject, aAny );
1707 124 : }
1708 124 : }
1709 : }
1710 0 : catch( Exception& )
1711 : {
1712 : }
1713 : }
1714 :
1715 124 : return bOk;
1716 : }
1717 :
1718 : //------------------------------------------------------------------------
1719 0 : sal_Bool SfxObjectShell::DisconnectStorage_Impl( SfxMedium& rSrcMedium, SfxMedium& rTargetMedium )
1720 : {
1721 : RTL_LOGFILE_CONTEXT( aLog, "sfx2 (mv76033) SfxObjectShell::DisconnectStorage_Impl" );
1722 :
1723 : // this method disconnects the storage from source medium, and attaches it to the backup created by the target medium
1724 :
1725 0 : uno::Reference< embed::XStorage > xStorage = rSrcMedium.GetStorage();
1726 :
1727 0 : sal_Bool bResult = sal_False;
1728 0 : if ( xStorage == pImp->m_xDocStorage )
1729 : {
1730 : try
1731 : {
1732 0 : uno::Reference< embed::XOptimizedStorage > xOptStorage( xStorage, uno::UNO_QUERY_THROW );
1733 0 : ::rtl::OUString aBackupURL = rTargetMedium.GetBackup_Impl();
1734 0 : if ( aBackupURL.isEmpty() )
1735 : {
1736 : // the backup could not be created, try to disconnect the storage and close the source SfxMedium
1737 : // in this case the optimization is not possible, connect storage to a temporary file
1738 0 : rTargetMedium.ResetError();
1739 0 : xOptStorage->writeAndAttachToStream( uno::Reference< io::XStream >() );
1740 0 : rSrcMedium.CanDisposeStorage_Impl( sal_False );
1741 0 : rSrcMedium.Close();
1742 :
1743 : // now try to create the backup
1744 0 : rTargetMedium.GetBackup_Impl();
1745 : }
1746 : else
1747 : {
1748 : // the following call will only compare stream sizes
1749 : // TODO/LATER: this is a very risky part, since if the URL contents are different from the storage
1750 : // contents, the storag will be broken
1751 0 : xOptStorage->attachToURL( aBackupURL, sal_True );
1752 :
1753 : // the storage is successfuly attached to backup, thus it it owned by the document not by the medium
1754 0 : rSrcMedium.CanDisposeStorage_Impl( sal_False );
1755 0 : bResult = sal_True;
1756 0 : }
1757 : }
1758 0 : catch ( uno::Exception& )
1759 : {}
1760 : }
1761 :
1762 : OSL_ENSURE( bResult, "Storage disconnecting has failed - affects performance!" );
1763 :
1764 0 : return bResult;
1765 : }
1766 :
1767 : //------------------------------------------------------------------------
1768 :
1769 0 : sal_Bool SfxObjectShell::ConnectTmpStorage_Impl(
1770 : const uno::Reference< embed::XStorage >& xStorage,
1771 : SfxMedium* pMediumArg )
1772 :
1773 : /* [Description]
1774 :
1775 : If the application operates on a temporary storage, then it may not take
1776 : the temporary storage from the SaveCompleted. Therefore the new storage
1777 : is connected already here in this case and SaveCompleted then does nothing.
1778 : */
1779 :
1780 : {
1781 : RTL_LOGFILE_CONTEXT( aLog, "sfx2 (mv76033) SfxObjectShell::ConnectTmpStorage_Impl" );
1782 :
1783 0 : sal_Bool bResult = sal_False;
1784 :
1785 0 : if ( xStorage.is() )
1786 : {
1787 : try
1788 : {
1789 : // the empty argument means that the storage will create temporary stream itself
1790 0 : uno::Reference< embed::XOptimizedStorage > xOptStorage( xStorage, uno::UNO_QUERY_THROW );
1791 0 : xOptStorage->writeAndAttachToStream( uno::Reference< io::XStream >() );
1792 :
1793 : // the storage is successfuly disconnected from the original sources, thus the medium must not dispose it
1794 0 : if ( pMediumArg )
1795 0 : pMediumArg->CanDisposeStorage_Impl( sal_False );
1796 :
1797 0 : bResult = sal_True;
1798 : }
1799 0 : catch( uno::Exception& )
1800 : {
1801 : }
1802 :
1803 : // if switching of the storage does not work for any reason ( nonroot storage for example ) use the old method
1804 0 : if ( !bResult ) try
1805 : {
1806 0 : uno::Reference< embed::XStorage > xTmpStorage = ::comphelper::OStorageHelper::GetTemporaryStorage();
1807 :
1808 : DBG_ASSERT( xTmpStorage.is(), "If a storage can not be created an exception must be thrown!\n" );
1809 0 : if ( !xTmpStorage.is() )
1810 0 : throw uno::RuntimeException();
1811 :
1812 : // TODO/LATER: may be it should be done in SwitchPersistence also
1813 : // TODO/LATER: find faster way to copy storage; perhaps sharing with backup?!
1814 0 : xStorage->copyToStorage( xTmpStorage );
1815 0 : bResult = SaveCompleted( xTmpStorage );
1816 :
1817 0 : if ( bResult )
1818 : {
1819 0 : pImp->pBasicManager->setStorage( xTmpStorage );
1820 :
1821 : // Get rid of this workaround after issue i113914 is fixed
1822 : try
1823 : {
1824 0 : uno::Reference< script::XStorageBasedLibraryContainer > xBasicLibraries( pImp->xBasicLibraries, uno::UNO_QUERY_THROW );
1825 0 : xBasicLibraries->setRootStorage( xTmpStorage );
1826 : }
1827 0 : catch( uno::Exception& )
1828 : {}
1829 : try
1830 : {
1831 0 : uno::Reference< script::XStorageBasedLibraryContainer > xDialogLibraries( pImp->xDialogLibraries, uno::UNO_QUERY_THROW );
1832 0 : xDialogLibraries->setRootStorage( xTmpStorage );
1833 : }
1834 0 : catch( uno::Exception& )
1835 : {}
1836 0 : }
1837 : }
1838 0 : catch( uno::Exception& )
1839 : {}
1840 :
1841 0 : if ( !bResult )
1842 : {
1843 : // TODO/LATER: may need error code setting based on exception
1844 0 : SetError( ERRCODE_IO_GENERAL, ::rtl::OUString( OSL_LOG_PREFIX ) );
1845 : }
1846 : }
1847 :
1848 0 : return bResult;
1849 : }
1850 :
1851 : //-------------------------------------------------------------------------
1852 :
1853 568 : sal_Bool SfxObjectShell::DoSaveObjectAs( SfxMedium& rMedium, sal_Bool bCommit )
1854 : {
1855 568 : sal_Bool bOk = sal_False;
1856 : {
1857 568 : ModifyBlocker_Impl aBlock( this );
1858 :
1859 568 : uno::Reference < embed::XStorage > xNewStor = rMedium.GetStorage();
1860 568 : if ( !xNewStor.is() )
1861 0 : return sal_False;
1862 :
1863 568 : uno::Reference < beans::XPropertySet > xPropSet( xNewStor, uno::UNO_QUERY );
1864 568 : if ( xPropSet.is() )
1865 : {
1866 568 : Any a = xPropSet->getPropertyValue( ::rtl::OUString("MediaType" ) );
1867 568 : ::rtl::OUString aMediaType;
1868 568 : if ( !(a>>=aMediaType) || aMediaType.isEmpty() )
1869 : {
1870 : OSL_FAIL( "The mediatype must be set already!\n" );
1871 0 : SetupStorage( xNewStor, SOFFICE_FILEFORMAT_CURRENT, sal_False );
1872 : }
1873 :
1874 568 : pImp->bIsSaving = sal_False;
1875 568 : bOk = SaveAsOwnFormat( rMedium );
1876 :
1877 568 : if ( bCommit )
1878 : {
1879 : try {
1880 568 : uno::Reference< embed::XTransactedObject > xTransact( xNewStor, uno::UNO_QUERY_THROW );
1881 568 : xTransact->commit();
1882 : }
1883 0 : catch( uno::Exception& )
1884 : {
1885 : OSL_FAIL( "The strotage was not commited on DoSaveAs!\n" );
1886 : }
1887 568 : }
1888 568 : }
1889 : }
1890 :
1891 568 : return bOk;
1892 : }
1893 :
1894 : //-------------------------------------------------------------------------
1895 : // TODO/LATER: may be the call must be removed completelly
1896 8 : sal_Bool SfxObjectShell::DoSaveAs( SfxMedium& rMedium )
1897 : {
1898 : // here only root storages are included, which are stored via temp file
1899 8 : rMedium.CreateTempFileNoCopy();
1900 8 : SetError(rMedium.GetErrorCode(), ::rtl::OUString( OSL_LOG_PREFIX ) );
1901 8 : if ( GetError() )
1902 0 : return sal_False;
1903 :
1904 : // copy version list from "old" medium to target medium, so it can be used on saving
1905 8 : if ( pImp->bPreserveVersions )
1906 8 : rMedium.TransferVersionList_Impl( *pMedium );
1907 :
1908 8 : sal_Bool bRet = SaveTo_Impl( rMedium, NULL );
1909 8 : if ( !bRet )
1910 0 : SetError(rMedium.GetErrorCode(), ::rtl::OUString( OSL_LOG_PREFIX ) );
1911 8 : return bRet;
1912 : }
1913 :
1914 : //-------------------------------------------------------------------------
1915 :
1916 1256 : sal_Bool SfxObjectShell::DoSaveCompleted( SfxMedium* pNewMed )
1917 : {
1918 : RTL_LOGFILE_CONTEXT( aLog, "sfx2 (mv76033) SfxObjectShell::DoSaveCompleted" );
1919 :
1920 1256 : sal_Bool bOk = sal_True;
1921 1256 : sal_Bool bMedChanged = pNewMed && pNewMed!=pMedium;
1922 :
1923 : DBG_ASSERT( !pNewMed || pNewMed->GetError() == ERRCODE_NONE, "DoSaveCompleted: Medium has error!" );
1924 :
1925 : // delete Medium (and Storage!) after all notifications
1926 1256 : SfxMedium* pOld = pMedium;
1927 1256 : if ( bMedChanged )
1928 : {
1929 572 : pMedium = pNewMed;
1930 572 : pMedium->CanDisposeStorage_Impl( sal_True );
1931 : }
1932 :
1933 1256 : const SfxFilter *pFilter = pMedium ? pMedium->GetFilter() : 0;
1934 1256 : if ( pNewMed )
1935 : {
1936 572 : if( bMedChanged )
1937 : {
1938 572 : if (!pNewMed->GetName().isEmpty())
1939 2 : bHasName = sal_True;
1940 572 : Broadcast( SfxSimpleHint(SFX_HINT_NAMECHANGED) );
1941 1144 : getDocProperties()->setGenerator(
1942 572 : ::utl::DocInfoHelper::GetGeneratorString() );
1943 : }
1944 :
1945 572 : uno::Reference< embed::XStorage > xStorage;
1946 572 : if ( !pFilter || IsPackageStorageFormat_Impl( *pMedium ) )
1947 : {
1948 570 : uno::Reference < embed::XStorage > xOld = GetStorage();
1949 :
1950 : // when the package based medium is broken and has no storage or if the storage
1951 : // is the same as the document storage the current document storage should be preserved
1952 570 : xStorage = pMedium->GetStorage();
1953 570 : bOk = SaveCompleted( xStorage );
1954 2276 : if ( bOk && xStorage.is() && xOld != xStorage
1955 1706 : && (!pOld || !pOld->HasStorage_Impl() || xOld != pOld->GetStorage() ) )
1956 : {
1957 : // old own storage was not controlled by old Medium -> dispose it
1958 : try {
1959 286 : xOld->dispose();
1960 0 : } catch( uno::Exception& )
1961 : {
1962 : // the storage is disposed already
1963 : // can happen during reload scenario when the medium has
1964 : // disposed it during the closing
1965 : // will be fixed in one of the next milestones
1966 : }
1967 570 : }
1968 : }
1969 : else
1970 : {
1971 2 : if( pMedium->GetOpenMode() & STREAM_WRITE )
1972 2 : pMedium->GetInStream();
1973 2 : xStorage = GetStorage();
1974 : }
1975 :
1976 : // TODO/LATER: may be this code will be replaced, but not sure
1977 : // Set storage in document library containers
1978 572 : pImp->pBasicManager->setStorage( xStorage );
1979 :
1980 : // Get rid of this workaround after issue i113914 is fixed
1981 : try
1982 : {
1983 572 : uno::Reference< script::XStorageBasedLibraryContainer > xBasicLibraries( pImp->xBasicLibraries, uno::UNO_QUERY_THROW );
1984 570 : xBasicLibraries->setRootStorage( xStorage );
1985 : }
1986 2 : catch( uno::Exception& )
1987 : {}
1988 : try
1989 : {
1990 572 : uno::Reference< script::XStorageBasedLibraryContainer > xDialogLibraries( pImp->xDialogLibraries, uno::UNO_QUERY_THROW );
1991 568 : xDialogLibraries->setRootStorage( xStorage );
1992 : }
1993 4 : catch( uno::Exception& )
1994 572 : {}
1995 : }
1996 : else
1997 : {
1998 684 : if( pMedium )
1999 : {
2000 684 : if( pFilter && !IsPackageStorageFormat_Impl( *pMedium ) && (pMedium->GetOpenMode() & STREAM_WRITE ))
2001 : {
2002 100 : pMedium->ReOpen();
2003 100 : bOk = SaveCompletedChildren( sal_False );
2004 : }
2005 : else
2006 584 : bOk = SaveCompleted( NULL );
2007 : }
2008 : // either Save or ConvertTo
2009 : else
2010 0 : bOk = SaveCompleted( NULL );
2011 : }
2012 :
2013 1256 : if ( bOk && pNewMed )
2014 : {
2015 572 : if( bMedChanged )
2016 : {
2017 572 : delete pOld;
2018 :
2019 572 : uno::Reference< frame::XModel > xModel = GetModel();
2020 572 : if ( xModel.is() )
2021 : {
2022 572 : ::rtl::OUString aURL = pNewMed->GetOrigURL();
2023 572 : uno::Sequence< beans::PropertyValue > aMediaDescr;
2024 572 : TransformItems( SID_OPENDOC, *pNewMed->GetItemSet(), aMediaDescr );
2025 : try
2026 : {
2027 572 : xModel->attachResource( aURL, aMediaDescr );
2028 : }
2029 0 : catch( uno::Exception& )
2030 572 : {}
2031 : }
2032 :
2033 : // before the title regenerated the document must loose the signatures
2034 572 : pImp->nDocumentSignatureState = SIGNATURESTATE_NOSIGNATURES;
2035 572 : pImp->nScriptingSignatureState = pNewMed->GetCachedSignatureState_Impl();
2036 : OSL_ENSURE( pImp->nScriptingSignatureState != SIGNATURESTATE_SIGNATURES_BROKEN, "The signature must not be broken at this place" );
2037 572 : pImp->bSignatureErrorIsShown = sal_False;
2038 :
2039 : // TODO/LATER: in future the medium must control own signature state, not the document
2040 572 : pNewMed->SetCachedSignatureState_Impl( SIGNATURESTATE_NOSIGNATURES ); // set the default value back
2041 :
2042 : // Set new title
2043 572 : if (!pNewMed->GetName().isEmpty() && SFX_CREATE_MODE_EMBEDDED != eCreateMode)
2044 0 : InvalidateName();
2045 572 : SetModified(sal_False); // reset only by set medium
2046 572 : Broadcast( SfxSimpleHint(SFX_HINT_MODECHANGED) );
2047 :
2048 : // this is the end of the saving process, it is possible that
2049 : // the file was changed
2050 : // between medium commit and this step (attributes change and so on)
2051 : // so get the file date again
2052 572 : if ( pNewMed->DocNeedsFileDateCheck() )
2053 2 : pNewMed->GetInitFileDate( sal_True );
2054 : }
2055 : }
2056 :
2057 1256 : pMedium->ClearBackup_Impl();
2058 1256 : pMedium->LockOrigFileOnDemand( sal_True, sal_False );
2059 :
2060 1256 : AddToRecentlyUsedList();
2061 :
2062 1256 : return bOk;
2063 : }
2064 :
2065 1757 : void SfxObjectShell::AddToRecentlyUsedList()
2066 : {
2067 1757 : INetURLObject aUrl( pMedium->GetOrigURL() );
2068 :
2069 1757 : if ( aUrl.GetProtocol() == INET_PROT_FILE )
2070 : {
2071 619 : const SfxFilter* pOrgFilter = pMedium->GetOrigFilter();
2072 : Application::AddToRecentDocumentList( aUrl.GetURLNoPass( INetURLObject::NO_DECODE ),
2073 619 : (pOrgFilter) ? pOrgFilter->GetMimeType() : ::rtl::OUString() );
2074 1757 : }
2075 1757 : }
2076 :
2077 : //-------------------------------------------------------------------------
2078 :
2079 0 : sal_Bool SfxObjectShell::ConvertFrom
2080 : (
2081 : SfxMedium& /*rMedium*/ /* <SfxMedium>, which describes the source file
2082 : (for example file name, <SfxFilter>,
2083 : Open-Modi and so on) */
2084 : )
2085 :
2086 : /* [Description]
2087 :
2088 : This method is called for loading of documents over all filters which are
2089 : not SFX_FILTER_OWN or for which no clipboard format has been registered
2090 : (thus no storage format that is used). In other words, whith this method
2091 : it is imported.
2092 :
2093 : Files which are to be opened here should be opened through 'rMedium'
2094 : to guarantee the right open modes. Especially if the format is retained
2095 : (only possible with SFX_FILTER_SIMULATE or SFX_FILTER_ONW) file which must
2096 : be opened STREAM_SHARE_DENYWRITE.
2097 :
2098 : [Return value]
2099 :
2100 : sal_Bool sal_True
2101 : The document could be loaded.
2102 :
2103 : sal_False
2104 : The document could not be loaded, an error code
2105 : received through <SvMedium::GetError()const>
2106 :
2107 : [Example]
2108 :
2109 : sal_Bool DocSh::ConvertFrom( SfxMedium &rMedium )
2110 : {
2111 : SvStreamRef xStream = rMedium.GetInStream();
2112 : if( xStream.is() )
2113 : {
2114 : xStream->SetBufferSize(4096);
2115 : *xStream >> ...;
2116 :
2117 : // Do not call 'rMedium.CloseInStream()'! Keep File locked!
2118 : return SVSTREAM_OK == rMedium.GetError();
2119 : }
2120 :
2121 : return sal_False;
2122 : }
2123 :
2124 : [Cross-references]
2125 :
2126 : <SfxObjectShell::ConvertTo(SfxMedium&)>
2127 : <SFX_FILTER_REGISTRATION>
2128 : */
2129 : {
2130 0 : return sal_False;
2131 : }
2132 :
2133 446 : sal_Bool SfxObjectShell::ImportFrom( SfxMedium& rMedium, bool bInsert )
2134 : {
2135 446 : ::rtl::OUString aFilterName( rMedium.GetFilter()->GetFilterName() );
2136 :
2137 446 : uno::Reference< lang::XMultiServiceFactory > xMan = ::comphelper::getProcessServiceFactory();
2138 : uno::Reference < lang::XMultiServiceFactory > xFilterFact (
2139 446 : xMan->createInstance( DEFINE_CONST_UNICODE( "com.sun.star.document.FilterFactory" ) ), uno::UNO_QUERY );
2140 :
2141 446 : uno::Sequence < beans::PropertyValue > aProps;
2142 446 : uno::Reference < container::XNameAccess > xFilters ( xFilterFact, uno::UNO_QUERY );
2143 446 : if ( xFilters->hasByName( aFilterName ) )
2144 : {
2145 446 : xFilters->getByName( aFilterName ) >>= aProps;
2146 446 : rMedium.GetItemSet()->Put( SfxStringItem( SID_FILTER_NAME, aFilterName ) );
2147 : }
2148 :
2149 446 : ::rtl::OUString aFilterImplName;
2150 446 : sal_Int32 nFilterProps = aProps.getLength();
2151 2646 : for ( sal_Int32 nFilterProp = 0; nFilterProp<nFilterProps; nFilterProp++ )
2152 : {
2153 2646 : const beans::PropertyValue& rFilterProp = aProps[nFilterProp];
2154 2646 : if ( rFilterProp.Name.compareToAscii("FilterService") == COMPARE_EQUAL )
2155 : {
2156 446 : rFilterProp.Value >>= aFilterImplName;
2157 446 : break;
2158 : }
2159 : }
2160 :
2161 446 : uno::Reference< document::XFilter > xLoader;
2162 446 : if ( !aFilterImplName.isEmpty() )
2163 : {
2164 : try{
2165 : xLoader = uno::Reference< document::XFilter >
2166 446 : ( xFilterFact->createInstanceWithArguments( aFilterName, uno::Sequence < uno::Any >() ), uno::UNO_QUERY );
2167 0 : }catch(const uno::Exception&)
2168 0 : { xLoader.clear(); }
2169 : }
2170 446 : if ( xLoader.is() )
2171 : {
2172 : // it happens that xLoader does not support xImporter!
2173 : try{
2174 446 : uno::Reference< lang::XComponent > xComp( GetModel(), uno::UNO_QUERY_THROW );
2175 446 : uno::Reference< document::XImporter > xImporter( xLoader, uno::UNO_QUERY_THROW );
2176 446 : xImporter->setTargetDocument( xComp );
2177 :
2178 446 : uno::Sequence < beans::PropertyValue > lDescriptor;
2179 446 : rMedium.GetItemSet()->Put( SfxStringItem( SID_FILE_NAME, rMedium.GetName() ) );
2180 446 : TransformItems( SID_OPENDOC, *rMedium.GetItemSet(), lDescriptor );
2181 :
2182 446 : com::sun::star::uno::Sequence < com::sun::star::beans::PropertyValue > aArgs ( lDescriptor.getLength() );
2183 446 : com::sun::star::beans::PropertyValue * pNewValue = aArgs.getArray();
2184 446 : const com::sun::star::beans::PropertyValue * pOldValue = lDescriptor.getConstArray();
2185 446 : const OUString sInputStream ( "InputStream" );
2186 :
2187 446 : sal_Bool bHasInputStream = sal_False;
2188 446 : sal_Bool bHasBaseURL = sal_False;
2189 : sal_Int32 i;
2190 446 : sal_Int32 nEnd = lDescriptor.getLength();
2191 :
2192 5142 : for ( i = 0; i < nEnd; i++ )
2193 : {
2194 4696 : pNewValue[i] = pOldValue[i];
2195 4696 : if ( pOldValue [i].Name == sInputStream )
2196 416 : bHasInputStream = sal_True;
2197 4280 : else if ( pOldValue[i].Name == "DocumentBaseURL" )
2198 446 : bHasBaseURL = sal_True;
2199 : }
2200 :
2201 446 : if ( !bHasInputStream )
2202 : {
2203 30 : aArgs.realloc ( ++nEnd );
2204 30 : aArgs[nEnd-1].Name = sInputStream;
2205 30 : aArgs[nEnd-1].Value <<= com::sun::star::uno::Reference < com::sun::star::io::XInputStream > ( new utl::OSeekableInputStreamWrapper ( *rMedium.GetInStream() ) );
2206 : }
2207 :
2208 446 : if ( !bHasBaseURL )
2209 : {
2210 0 : aArgs.realloc ( ++nEnd );
2211 0 : aArgs[nEnd-1].Name = ::rtl::OUString( "DocumentBaseURL" );
2212 0 : aArgs[nEnd-1].Value <<= rMedium.GetBaseURL();
2213 : }
2214 :
2215 446 : if ( bInsert ) {
2216 0 : aArgs.realloc( ++nEnd );
2217 0 : aArgs[nEnd-1].Name = ::rtl::OUString( "InsertMode" );
2218 0 : aArgs[nEnd-1].Value <<= (sal_Bool) sal_True;
2219 : }
2220 :
2221 446 : return xLoader->filter( aArgs );
2222 : }
2223 0 : catch (const packages::zip::ZipIOException&)
2224 : {
2225 0 : SetError( ERRCODE_IO_BROKENPACKAGE, "Badness in the underlying package format." );
2226 : }
2227 0 : catch (const lang::WrappedTargetRuntimeException& rWrapped)
2228 : {
2229 0 : io::WrongFormatException e;
2230 0 : if (rWrapped.TargetException >>= e)
2231 : {
2232 : SetError(*new StringErrorInfo(ERRCODE_SFX_FORMAT_ROWCOL,
2233 0 : e.Message, ERRCODE_BUTTON_OK | ERRCODE_MSG_ERROR ), "");
2234 0 : }
2235 : }
2236 0 : catch(...)
2237 : {}
2238 : }
2239 :
2240 0 : return sal_False;
2241 : }
2242 :
2243 106 : sal_Bool SfxObjectShell::ExportTo( SfxMedium& rMedium )
2244 : {
2245 106 : ::rtl::OUString aFilterName( rMedium.GetFilter()->GetFilterName() );
2246 106 : uno::Reference< document::XExporter > xExporter;
2247 :
2248 : {
2249 106 : uno::Reference< lang::XMultiServiceFactory > xMan = ::comphelper::getProcessServiceFactory();
2250 : uno::Reference < lang::XMultiServiceFactory > xFilterFact (
2251 106 : xMan->createInstance( DEFINE_CONST_UNICODE( "com.sun.star.document.FilterFactory" ) ), uno::UNO_QUERY );
2252 :
2253 106 : uno::Sequence < beans::PropertyValue > aProps;
2254 106 : uno::Reference < container::XNameAccess > xFilters ( xFilterFact, uno::UNO_QUERY );
2255 106 : if ( xFilters->hasByName( aFilterName ) )
2256 106 : xFilters->getByName( aFilterName ) >>= aProps;
2257 :
2258 106 : ::rtl::OUString aFilterImplName;
2259 106 : sal_Int32 nFilterProps = aProps.getLength();
2260 634 : for ( sal_Int32 nFilterProp = 0; nFilterProp<nFilterProps; nFilterProp++ )
2261 : {
2262 634 : const beans::PropertyValue& rFilterProp = aProps[nFilterProp];
2263 634 : if ( rFilterProp.Name.compareToAscii("FilterService") == COMPARE_EQUAL )
2264 : {
2265 106 : rFilterProp.Value >>= aFilterImplName;
2266 106 : break;
2267 : }
2268 : }
2269 :
2270 106 : if ( !aFilterImplName.isEmpty() )
2271 : {
2272 : try{
2273 : xExporter = uno::Reference< document::XExporter >
2274 106 : ( xFilterFact->createInstanceWithArguments( aFilterName, uno::Sequence < uno::Any >() ), uno::UNO_QUERY );
2275 0 : }catch(const uno::Exception&)
2276 0 : { xExporter.clear(); }
2277 106 : }
2278 : }
2279 :
2280 106 : if ( xExporter.is() )
2281 : {
2282 : try{
2283 106 : uno::Reference< lang::XComponent > xComp( GetModel(), uno::UNO_QUERY_THROW );
2284 106 : uno::Reference< document::XFilter > xFilter( xExporter, uno::UNO_QUERY_THROW );
2285 106 : xExporter->setSourceDocument( xComp );
2286 :
2287 106 : com::sun::star::uno::Sequence < com::sun::star::beans::PropertyValue > aOldArgs;
2288 106 : SfxItemSet* pItems = rMedium.GetItemSet();
2289 106 : TransformItems( SID_SAVEASDOC, *pItems, aOldArgs );
2290 :
2291 106 : const com::sun::star::beans::PropertyValue * pOldValue = aOldArgs.getConstArray();
2292 106 : com::sun::star::uno::Sequence < com::sun::star::beans::PropertyValue > aArgs ( aOldArgs.getLength() );
2293 106 : com::sun::star::beans::PropertyValue * pNewValue = aArgs.getArray();
2294 :
2295 : // put in the REAL file name, and copy all PropertyValues
2296 106 : const OUString sOutputStream ( "OutputStream" );
2297 106 : const OUString sStream ( "StreamForOutput" );
2298 106 : sal_Bool bHasOutputStream = sal_False;
2299 106 : sal_Bool bHasStream = sal_False;
2300 106 : sal_Bool bHasBaseURL = sal_False;
2301 : sal_Int32 i;
2302 106 : sal_Int32 nEnd = aOldArgs.getLength();
2303 :
2304 942 : for ( i = 0; i < nEnd; i++ )
2305 : {
2306 836 : pNewValue[i] = pOldValue[i];
2307 836 : if ( pOldValue[i].Name == "FileName" )
2308 0 : pNewValue[i].Value <<= OUString ( rMedium.GetName() );
2309 836 : else if ( pOldValue[i].Name == sOutputStream )
2310 0 : bHasOutputStream = sal_True;
2311 836 : else if ( pOldValue[i].Name == sStream )
2312 0 : bHasStream = sal_True;
2313 836 : else if ( pOldValue[i].Name == "DocumentBaseURL" )
2314 0 : bHasBaseURL = sal_True;
2315 : }
2316 :
2317 106 : if ( !bHasOutputStream )
2318 : {
2319 106 : aArgs.realloc ( ++nEnd );
2320 106 : aArgs[nEnd-1].Name = sOutputStream;
2321 106 : aArgs[nEnd-1].Value <<= com::sun::star::uno::Reference < com::sun::star::io::XOutputStream > ( new utl::OOutputStreamWrapper ( *rMedium.GetOutStream() ) );
2322 : }
2323 :
2324 : // add stream as well, for OOX export and maybe others
2325 106 : if ( !bHasStream )
2326 : {
2327 106 : aArgs.realloc ( ++nEnd );
2328 106 : aArgs[nEnd-1].Name = sStream;
2329 106 : aArgs[nEnd-1].Value <<= com::sun::star::uno::Reference < com::sun::star::io::XStream > ( new utl::OStreamWrapper ( *rMedium.GetOutStream() ) );
2330 : }
2331 :
2332 106 : if ( !bHasBaseURL )
2333 : {
2334 106 : aArgs.realloc ( ++nEnd );
2335 106 : aArgs[nEnd-1].Name = ::rtl::OUString( "DocumentBaseURL" );
2336 106 : aArgs[nEnd-1].Value <<= rMedium.GetBaseURL( sal_True );
2337 : }
2338 :
2339 106 : return xFilter->filter( aArgs );
2340 0 : }catch(const uno::Exception&)
2341 : {}
2342 : }
2343 :
2344 0 : return sal_False;
2345 : }
2346 :
2347 : //-------------------------------------------------------------------------
2348 :
2349 0 : sal_Bool SfxObjectShell::ConvertTo
2350 : (
2351 : SfxMedium& /*rMedium*/ /* <SfxMedium>, which describes the target file
2352 : (for example file name, <SfxFilter>,
2353 : Open-Modi and so on) */
2354 : )
2355 :
2356 : /* [Description]
2357 :
2358 : This method is called for saving of documents over all filters which are
2359 : not SFX_FILTER_OWN or for which no clipboard format has been registered
2360 : (thus no storage format that is used). In other words, with this method
2361 : it is exported.
2362 :
2363 : Files which are to be opened here should be opened through 'rMedium'
2364 : to guarantee the right open modes. Especially if the format is retained
2365 : (only possible with SFX_FILTER_SIMULATE or SFX_FILTER_ONW) file which must
2366 : be opened STREAM_SHARE_DENYWRITE.
2367 :
2368 : [Return value]
2369 :
2370 : sal_Bool sal_True
2371 : The document could be saved.
2372 :
2373 : sal_False
2374 : The document could not be saved, an error code is
2375 : received by <SvMedium::GetError()const>
2376 :
2377 :
2378 : [Example]
2379 :
2380 : sal_Bool DocSh::ConvertTo( SfxMedium &rMedium )
2381 : {
2382 : SvStreamRef xStream = rMedium.GetOutStream();
2383 : if ( xStream.is() )
2384 : {
2385 : xStream->SetBufferSize(4096);
2386 : *xStream << ...;
2387 :
2388 : rMedium.CloseOutStream(); // opens the InStream automatically
2389 : return SVSTREAM_OK == rMedium.GetError();
2390 : }
2391 : return sal_False ;
2392 : }
2393 :
2394 : [Cross-references]
2395 :
2396 : <SfxObjectShell::ConvertFrom(SfxMedium&)>
2397 : <SFX_FILTER_REGISTRATION>
2398 : */
2399 :
2400 : {
2401 0 : return sal_False;
2402 : }
2403 :
2404 : //-------------------------------------------------------------------------
2405 :
2406 0 : sal_Bool SfxObjectShell::DoSave_Impl( const SfxItemSet* pArgs )
2407 : {
2408 0 : SfxMedium* pRetrMedium = GetMedium();
2409 0 : const SfxFilter* pFilter = pRetrMedium->GetFilter();
2410 :
2411 : // copy the original itemset, but remove the "version" item, because pMediumTmp
2412 : // is a new medium "from scratch", so no version should be stored into it
2413 0 : SfxItemSet* pSet = new SfxAllItemSet(*pRetrMedium->GetItemSet());
2414 0 : pSet->ClearItem( SID_VERSION );
2415 0 : pSet->ClearItem( SID_DOC_BASEURL );
2416 :
2417 : // copy the version comment and major items for the checkin only
2418 0 : if ( pRetrMedium->IsInCheckIn( ) )
2419 : {
2420 0 : const SfxPoolItem* pMajor = pArgs->GetItem( SID_DOCINFO_MAJOR );
2421 0 : if ( pMajor )
2422 0 : pSet->Put( *pMajor );
2423 :
2424 0 : const SfxPoolItem* pComments = pArgs->GetItem( SID_DOCINFO_COMMENTS );
2425 0 : if ( pComments )
2426 0 : pSet->Put( *pComments );
2427 : }
2428 :
2429 : // create a medium as a copy; this medium is only for writingm, because it
2430 : // uses the same name as the original one writing is done through a copy,
2431 : // that will be transferred to the target (of course after calling HandsOff)
2432 0 : SfxMedium* pMediumTmp = new SfxMedium( pRetrMedium->GetName(), pRetrMedium->GetOpenMode(), pFilter, pSet );
2433 0 : pMediumTmp->SetInCheckIn( pRetrMedium->IsInCheckIn( ) );
2434 0 : pMediumTmp->SetLongName( pRetrMedium->GetLongName() );
2435 0 : if ( pMediumTmp->GetErrorCode() != ERRCODE_NONE )
2436 : {
2437 0 : SetError( pMediumTmp->GetError(), ::rtl::OUString( OSL_LOG_PREFIX ) );
2438 0 : delete pMediumTmp;
2439 0 : return sal_False;
2440 : }
2441 :
2442 : // copy version list from "old" medium to target medium, so it can be used on saving
2443 0 : pMediumTmp->TransferVersionList_Impl( *pRetrMedium );
2444 :
2445 : // an interaction handler here can aquire only in case of GUI Saving
2446 : // and should be removed after the saving is done
2447 0 : com::sun::star::uno::Reference< XInteractionHandler > xInteract;
2448 0 : SFX_ITEMSET_ARG( pArgs, pxInteractionItem, SfxUnoAnyItem, SID_INTERACTIONHANDLER, sal_False );
2449 0 : if ( pxInteractionItem && ( pxInteractionItem->GetValue() >>= xInteract ) && xInteract.is() )
2450 0 : pMediumTmp->GetItemSet()->Put( SfxUnoAnyItem( SID_INTERACTIONHANDLER, makeAny( xInteract ) ) );
2451 :
2452 0 : sal_Bool bSaved = sal_False;
2453 0 : if( !GetError() && SaveTo_Impl( *pMediumTmp, pArgs ) )
2454 : {
2455 0 : bSaved = sal_True;
2456 :
2457 0 : if( pMediumTmp->GetItemSet() )
2458 : {
2459 0 : pMediumTmp->GetItemSet()->ClearItem( SID_INTERACTIONHANDLER );
2460 0 : pMediumTmp->GetItemSet()->ClearItem( SID_PROGRESS_STATUSBAR_CONTROL );
2461 : }
2462 :
2463 0 : SetError(pMediumTmp->GetErrorCode(), ::rtl::OUString( OSL_LOG_PREFIX ) );
2464 :
2465 0 : sal_Bool bOpen( sal_False );
2466 0 : bOpen = DoSaveCompleted( pMediumTmp );
2467 :
2468 : DBG_ASSERT(bOpen,"Error handling for DoSaveCompleted not implemented");
2469 : (void)bOpen;
2470 : }
2471 : else
2472 : {
2473 : // transfer error code from medium to objectshell
2474 0 : SetError( pMediumTmp->GetError(), ::rtl::OUString( OSL_LOG_PREFIX ) );
2475 :
2476 : // reconnect to object storage
2477 0 : DoSaveCompleted( 0 );
2478 :
2479 0 : if( pRetrMedium->GetItemSet() )
2480 : {
2481 0 : pRetrMedium->GetItemSet()->ClearItem( SID_INTERACTIONHANDLER );
2482 0 : pRetrMedium->GetItemSet()->ClearItem( SID_PROGRESS_STATUSBAR_CONTROL );
2483 : }
2484 :
2485 0 : delete pMediumTmp;
2486 : }
2487 :
2488 0 : SetModified( !bSaved );
2489 0 : return bSaved;
2490 : }
2491 :
2492 : //-------------------------------------------------------------------------
2493 :
2494 0 : sal_Bool SfxObjectShell::Save_Impl( const SfxItemSet* pSet )
2495 : {
2496 0 : if ( IsReadOnly() )
2497 : {
2498 0 : SetError( ERRCODE_SFX_DOCUMENTREADONLY, ::rtl::OUString( OSL_LOG_PREFIX ) );
2499 0 : return sal_False;
2500 : }
2501 :
2502 : DBG_CHKTHIS(SfxObjectShell, 0);
2503 :
2504 0 : pImp->bIsSaving = sal_True;
2505 0 : sal_Bool bSaved = sal_False;
2506 0 : SFX_ITEMSET_ARG( GetMedium()->GetItemSet(), pSalvageItem, SfxStringItem, SID_DOC_SALVAGE, sal_False);
2507 0 : if ( pSalvageItem )
2508 : {
2509 0 : SFX_ITEMSET_ARG( GetMedium()->GetItemSet(), pFilterItem, SfxStringItem, SID_FILTER_NAME, sal_False);
2510 0 : String aFilterName;
2511 0 : const SfxFilter *pFilter = NULL;
2512 0 : if ( pFilterItem )
2513 0 : pFilter = SfxFilterMatcher( rtl::OUString::createFromAscii( GetFactory().GetShortName()) ).GetFilter4FilterName( aFilterName );
2514 :
2515 : SfxMedium *pMed = new SfxMedium(
2516 0 : pSalvageItem->GetValue(), STREAM_READWRITE | STREAM_SHARE_DENYWRITE | STREAM_TRUNC, pFilter );
2517 :
2518 0 : SFX_ITEMSET_ARG( GetMedium()->GetItemSet(), pPasswordItem, SfxStringItem, SID_PASSWORD, sal_False );
2519 0 : if ( pPasswordItem )
2520 0 : pMed->GetItemSet()->Put( *pPasswordItem );
2521 :
2522 0 : bSaved = DoSaveAs( *pMed );
2523 0 : if ( bSaved )
2524 0 : bSaved = DoSaveCompleted( pMed );
2525 : else
2526 0 : delete pMed;
2527 : }
2528 : else
2529 0 : bSaved = DoSave_Impl( pSet );
2530 0 : return bSaved;
2531 : }
2532 :
2533 : //-------------------------------------------------------------------------
2534 :
2535 116 : sal_Bool SfxObjectShell::CommonSaveAs_Impl
2536 : (
2537 : const INetURLObject& aURL,
2538 : const String& aFilterName,
2539 : SfxItemSet* aParams
2540 : )
2541 : {
2542 116 : if( aURL.HasError() )
2543 : {
2544 0 : SetError( ERRCODE_IO_INVALIDPARAMETER, ::rtl::OUString( OSL_LOG_PREFIX ) );
2545 0 : return sal_False;
2546 : }
2547 :
2548 116 : if ( aURL != INetURLObject( ::rtl::OUString( "private:stream" ) ) )
2549 : {
2550 : // Is there already a Document with this name?
2551 116 : SfxObjectShell* pDoc = 0;
2552 2322 : for ( SfxObjectShell* pTmp = SfxObjectShell::GetFirst();
2553 : pTmp && !pDoc;
2554 : pTmp = SfxObjectShell::GetNext(*pTmp) )
2555 : {
2556 2206 : if( ( pTmp != this ) && pTmp->GetMedium() )
2557 : {
2558 2090 : INetURLObject aCompare( pTmp->GetMedium()->GetName() );
2559 2090 : if ( aCompare == aURL )
2560 0 : pDoc = pTmp;
2561 : }
2562 : }
2563 116 : if ( pDoc )
2564 : {
2565 : // Then error message: "already opened"
2566 0 : SetError(ERRCODE_SFX_ALREADYOPEN, ::rtl::OUString( OSL_LOG_PREFIX ));
2567 0 : return sal_False;
2568 : }
2569 : }
2570 :
2571 : DBG_ASSERT( aURL.GetProtocol() != INET_PROT_NOT_VALID, "Illegal URL!" );
2572 : DBG_ASSERT( aParams->Count() != 0, "Incorrect Parameter");
2573 :
2574 116 : SFX_ITEMSET_ARG( aParams, pSaveToItem, SfxBoolItem, SID_SAVETO, sal_False );
2575 116 : sal_Bool bSaveTo = pSaveToItem ? pSaveToItem->GetValue() : sal_False;
2576 :
2577 116 : const SfxFilter* pFilter = GetFactory().GetFilterContainer()->GetFilter4FilterName( aFilterName );
2578 232 : if ( !pFilter
2579 116 : || !pFilter->CanExport()
2580 0 : || (!bSaveTo && !pFilter->CanImport()) )
2581 : {
2582 0 : SetError( ERRCODE_IO_INVALIDPARAMETER, ::rtl::OUString( OSL_LOG_PREFIX ) );
2583 0 : return sal_False;
2584 : }
2585 :
2586 116 : SFX_ITEMSET_ARG( aParams, pCopyStreamItem, SfxBoolItem, SID_COPY_STREAM_IF_POSSIBLE, sal_False );
2587 116 : if ( bSaveTo && pCopyStreamItem && pCopyStreamItem->GetValue() && !IsModified() )
2588 : {
2589 0 : if ( pMedium->TryDirectTransfer( aURL.GetMainURL( INetURLObject::NO_DECODE ), *aParams ) )
2590 0 : return sal_True;
2591 : }
2592 116 : aParams->ClearItem( SID_COPY_STREAM_IF_POSSIBLE );
2593 :
2594 116 : pImp->bPasswd = aParams && SFX_ITEM_SET == aParams->GetItemState(SID_PASSWORD);
2595 :
2596 116 : SfxMedium *pActMed = GetMedium();
2597 116 : const INetURLObject aActName(pActMed->GetName());
2598 :
2599 116 : sal_Bool bWasReadonly = IsReadOnly();
2600 :
2601 116 : if ( aURL == aActName && aURL != INetURLObject( OUString("private:stream") )
2602 0 : && IsReadOnly() )
2603 : {
2604 0 : SetError(ERRCODE_SFX_DOCUMENTREADONLY, ::rtl::OUString( OSL_LOG_PREFIX ));
2605 0 : return sal_False;
2606 : }
2607 :
2608 116 : if( SFX_ITEM_SET != aParams->GetItemState(SID_UNPACK) && SvtSaveOptions().IsSaveUnpacked() )
2609 0 : aParams->Put( SfxBoolItem( SID_UNPACK, sal_False ) );
2610 :
2611 116 : ::rtl::OUString aTempFileURL;
2612 116 : if ( IsDocShared() )
2613 0 : aTempFileURL = pMedium->GetURLObject().GetMainURL( INetURLObject::NO_DECODE );
2614 :
2615 116 : if ( PreDoSaveAs_Impl(aURL.GetMainURL( INetURLObject::NO_DECODE ),aFilterName,aParams))
2616 : {
2617 : // Update Data on media
2618 116 : SfxItemSet *pSet = GetMedium()->GetItemSet();
2619 116 : pSet->ClearItem( SID_INTERACTIONHANDLER );
2620 116 : pSet->ClearItem( SID_PROGRESS_STATUSBAR_CONTROL );
2621 116 : pSet->ClearItem( SID_STANDARD_DIR );
2622 116 : pSet->ClearItem( SID_PATH );
2623 :
2624 116 : if ( !bSaveTo )
2625 : {
2626 0 : pSet->ClearItem( SID_REFERER );
2627 0 : pSet->ClearItem( SID_POSTDATA );
2628 0 : pSet->ClearItem( SID_TEMPLATE );
2629 0 : pSet->ClearItem( SID_DOC_READONLY );
2630 0 : pSet->ClearItem( SID_CONTENTTYPE );
2631 0 : pSet->ClearItem( SID_CHARSET );
2632 0 : pSet->ClearItem( SID_FILTER_NAME );
2633 0 : pSet->ClearItem( SID_OPTIONS );
2634 0 : pSet->ClearItem( SID_VERSION );
2635 0 : pSet->ClearItem( SID_EDITDOC );
2636 0 : pSet->ClearItem( SID_OVERWRITE );
2637 0 : pSet->ClearItem( SID_DEFAULTFILEPATH );
2638 0 : pSet->ClearItem( SID_DEFAULTFILENAME );
2639 :
2640 0 : SFX_ITEMSET_GET( (*aParams), pFilterItem, SfxStringItem, SID_FILTER_NAME, sal_False );
2641 0 : if ( pFilterItem )
2642 0 : pSet->Put( *pFilterItem );
2643 :
2644 0 : SFX_ITEMSET_GET( (*aParams), pOptionsItem, SfxStringItem, SID_OPTIONS, sal_False );
2645 0 : if ( pOptionsItem )
2646 0 : pSet->Put( *pOptionsItem );
2647 :
2648 0 : SFX_ITEMSET_GET( (*aParams), pFilterOptItem, SfxStringItem, SID_FILE_FILTEROPTIONS, sal_False );
2649 0 : if ( pFilterOptItem )
2650 0 : pSet->Put( *pFilterOptItem );
2651 :
2652 0 : if ( IsDocShared() && !aTempFileURL.isEmpty() )
2653 : {
2654 : // this is a shared document that has to be disconnected from the old location
2655 0 : FreeSharedFile( aTempFileURL );
2656 :
2657 0 : if ( pFilter->IsOwnFormat()
2658 0 : && pFilter->UsesStorage()
2659 0 : && pFilter->GetVersion() >= SOFFICE_FILEFORMAT_60 )
2660 : {
2661 : // the target format is the own format
2662 : // the target document must be shared
2663 0 : SwitchToShared( sal_True, sal_False );
2664 : }
2665 : }
2666 : }
2667 :
2668 116 : if ( bWasReadonly && !bSaveTo )
2669 0 : Broadcast( SfxSimpleHint(SFX_HINT_MODECHANGED) );
2670 :
2671 116 : return sal_True;
2672 : }
2673 : else
2674 0 : return sal_False;
2675 : }
2676 :
2677 : //-------------------------------------------------------------------------
2678 :
2679 116 : sal_Bool SfxObjectShell::PreDoSaveAs_Impl
2680 : (
2681 : const String& rFileName,
2682 : const String& aFilterName,
2683 : SfxItemSet* pParams
2684 : )
2685 : {
2686 : // copy all items stored in the itemset of the current medium
2687 116 : SfxAllItemSet* pMergedParams = new SfxAllItemSet( *pMedium->GetItemSet() );
2688 :
2689 : // in "SaveAs" title and password will be cleared ( maybe the new itemset contains new values, otherwise they will be empty )
2690 116 : pMergedParams->ClearItem( SID_ENCRYPTIONDATA );
2691 116 : pMergedParams->ClearItem( SID_PASSWORD );
2692 116 : pMergedParams->ClearItem( SID_DOCINFO_TITLE );
2693 :
2694 116 : pMergedParams->ClearItem( SID_INPUTSTREAM );
2695 116 : pMergedParams->ClearItem( SID_STREAM );
2696 116 : pMergedParams->ClearItem( SID_CONTENT );
2697 116 : pMergedParams->ClearItem( SID_DOC_READONLY );
2698 116 : pMergedParams->ClearItem( SID_DOC_BASEURL );
2699 :
2700 116 : pMergedParams->ClearItem( SID_REPAIRPACKAGE );
2701 :
2702 : // "SaveAs" will never store any version information - it's a complete new file !
2703 116 : pMergedParams->ClearItem( SID_VERSION );
2704 :
2705 : // merge the new parameters into the copy
2706 : // all values present in both itemsets will be overwritten by the new parameters
2707 116 : if( pParams )
2708 116 : pMergedParams->Put( *pParams );
2709 :
2710 : #ifdef DBG_UTIL
2711 : if ( pMergedParams->GetItemState( SID_DOC_SALVAGE) >= SFX_ITEM_SET )
2712 : OSL_FAIL("Salvage item present in Itemset, check the parameters!");
2713 : #endif
2714 :
2715 : // should be unneccessary - too hot to handle!
2716 116 : pMergedParams->ClearItem( SID_DOC_SALVAGE );
2717 :
2718 : // take over the new merged itemset
2719 116 : pParams = pMergedParams;
2720 :
2721 : // create a medium for the target URL
2722 116 : SfxMedium *pNewFile = new SfxMedium( rFileName, STREAM_READWRITE | STREAM_SHARE_DENYWRITE | STREAM_TRUNC, 0, pParams );
2723 :
2724 : // set filter; if no filter is given, take the default filter of the factory
2725 116 : if ( aFilterName.Len() )
2726 116 : pNewFile->SetFilter( GetFactory().GetFilterContainer()->GetFilter4FilterName( aFilterName ) );
2727 : else
2728 0 : pNewFile->SetFilter( GetFactory().GetFilterContainer()->GetAnyFilter( SFX_FILTER_IMPORT | SFX_FILTER_EXPORT ) );
2729 :
2730 116 : if ( pNewFile->GetErrorCode() != ERRCODE_NONE )
2731 : {
2732 : // creating temporary file failed ( f.e. floppy disk not inserted! )
2733 0 : SetError( pNewFile->GetError(), ::rtl::OUString( OSL_LOG_PREFIX ) );
2734 0 : delete pNewFile;
2735 0 : return sal_False;
2736 : }
2737 :
2738 : // check if a "SaveTo" is wanted, no "SaveAs"
2739 116 : SFX_ITEMSET_ARG( pParams, pSaveToItem, SfxBoolItem, SID_SAVETO, sal_False );
2740 116 : sal_Bool bCopyTo = GetCreateMode() == SFX_CREATE_MODE_EMBEDDED || (pSaveToItem && pSaveToItem->GetValue());
2741 :
2742 : // distinguish between "Save" and "SaveAs"
2743 116 : pImp->bIsSaving = sal_False;
2744 :
2745 : // copy version list from "old" medium to target medium, so it can be used on saving
2746 116 : if ( pImp->bPreserveVersions )
2747 116 : pNewFile->TransferVersionList_Impl( *pMedium );
2748 :
2749 : // Save the document ( first as temporary file, then transfer to the target URL by committing the medium )
2750 116 : sal_Bool bOk = sal_False;
2751 116 : if ( !pNewFile->GetErrorCode() && SaveTo_Impl( *pNewFile, NULL ) )
2752 : {
2753 116 : bOk = sal_True;
2754 :
2755 : // transfer a possible error from the medium to the document
2756 116 : SetError( pNewFile->GetErrorCode(), ::rtl::OUString( OSL_LOG_PREFIX ) );
2757 :
2758 : // notify the document that saving was done successfully
2759 116 : if ( !bCopyTo )
2760 : {
2761 0 : bOk = DoSaveCompleted( pNewFile );
2762 : }
2763 : else
2764 116 : bOk = DoSaveCompleted(0);
2765 :
2766 116 : if( bOk )
2767 : {
2768 116 : if( !bCopyTo )
2769 0 : SetModified( sal_False );
2770 : }
2771 : else
2772 : {
2773 : // TODO/LATER: the code below must be dead since the storage commit makes all the stuff
2774 : // and the DoSaveCompleted call should not be able to fail in general
2775 :
2776 : DBG_ASSERT( !bCopyTo, "Error while reconnecting to medium, can't be handled!");
2777 0 : SetError( pNewFile->GetErrorCode(), ::rtl::OUString( OSL_LOG_PREFIX ) );
2778 :
2779 0 : if ( !bCopyTo )
2780 : {
2781 : // reconnect to the old medium
2782 0 : sal_Bool bRet( sal_False );
2783 0 : bRet = DoSaveCompleted( pMedium );
2784 : DBG_ASSERT( bRet, "Error in DoSaveCompleted, can't be handled!");
2785 : (void)bRet;
2786 : }
2787 :
2788 : // TODO/LATER: disconnect the new file from the storage for the case when pure saving is done
2789 : // if storing has corrupted the file, probably it must be restored either here or
2790 : // by the storage
2791 0 : DELETEZ( pNewFile );
2792 : }
2793 : }
2794 : else
2795 : {
2796 0 : SetError( pNewFile->GetErrorCode(), ::rtl::OUString( OSL_LOG_PREFIX ) );
2797 :
2798 : // reconnect to the old storage
2799 0 : DoSaveCompleted( 0 );
2800 :
2801 0 : DELETEZ( pNewFile );
2802 : }
2803 :
2804 116 : if ( bCopyTo )
2805 116 : DELETEZ( pNewFile );
2806 0 : else if( !bOk )
2807 0 : SetModified( sal_True );
2808 :
2809 116 : return bOk;
2810 : }
2811 :
2812 : //------------------------------------------------------------------------
2813 :
2814 0 : sal_Bool SfxObjectShell::LoadFrom( SfxMedium& /*rMedium*/ )
2815 : {
2816 : OSL_FAIL( "Base implementation, must not be called in general!" );
2817 0 : return sal_True;
2818 : }
2819 :
2820 : //-------------------------------------------------------------------------
2821 0 : sal_Bool SfxObjectShell::IsInformationLost()
2822 : {
2823 0 : Sequence< PropertyValue > aProps = GetModel()->getArgs();
2824 0 : ::rtl::OUString aFilterName;
2825 0 : ::rtl::OUString aPreusedFilterName;
2826 0 : for ( sal_Int32 nInd = 0; nInd < aProps.getLength(); nInd++ )
2827 : {
2828 0 : if ( aProps[nInd].Name == "FilterName" )
2829 0 : aProps[nInd].Value >>= aFilterName;
2830 0 : else if ( aProps[nInd].Name == "PreusedFilterName" )
2831 0 : aProps[nInd].Value >>= aPreusedFilterName;
2832 : }
2833 :
2834 : // if current filter can lead to information loss and it was used
2835 : // for the latest store then the user should be asked to store in own format
2836 0 : if ( !aFilterName.isEmpty() && aFilterName.equals( aPreusedFilterName ) )
2837 : {
2838 0 : const SfxFilter *pFilt = GetMedium()->GetFilter();
2839 : DBG_ASSERT( pFilt && aFilterName.equals( pFilt->GetName() ), "MediaDescriptor contains wrong filter!\n" );
2840 0 : return ( pFilt && pFilt->IsAlienFormat() );
2841 : }
2842 :
2843 0 : return sal_False;
2844 : }
2845 :
2846 : //-------------------------------------------------------------------------
2847 0 : sal_Bool SfxObjectShell::CanReload_Impl()
2848 :
2849 : /* [Description]
2850 :
2851 : Internal method for determining whether a reload of the document
2852 : (as RevertToSaved or last known version) is possible.
2853 : */
2854 :
2855 : {
2856 0 : return pMedium && HasName() && !IsInModalMode() && !pImp->bForbidReload;
2857 : }
2858 :
2859 : //-------------------------------------------------------------------------
2860 :
2861 0 : sal_uInt16 SfxObjectShell::GetHiddenInformationState( sal_uInt16 nStates )
2862 : {
2863 0 : sal_uInt16 nState = 0;
2864 0 : if ( nStates & HIDDENINFORMATION_DOCUMENTVERSIONS )
2865 : {
2866 0 : if ( GetMedium()->GetVersionList().getLength() )
2867 0 : nState |= HIDDENINFORMATION_DOCUMENTVERSIONS;
2868 : }
2869 :
2870 0 : return nState;
2871 : }
2872 :
2873 0 : sal_Int16 SfxObjectShell::QueryHiddenInformation( HiddenWarningFact eFact, Window* pParent )
2874 : {
2875 0 : sal_Int16 nRet = RET_YES;
2876 0 : sal_uInt16 nResId = 0;
2877 0 : SvtSecurityOptions::EOption eOption = static_cast< SvtSecurityOptions::EOption >( -1 );
2878 :
2879 0 : switch ( eFact )
2880 : {
2881 : case WhenSaving :
2882 : {
2883 0 : nResId = STR_HIDDENINFO_CONTINUE_SAVING;
2884 0 : eOption = SvtSecurityOptions::E_DOCWARN_SAVEORSEND;
2885 0 : break;
2886 : }
2887 : case WhenPrinting :
2888 : {
2889 0 : nResId = STR_HIDDENINFO_CONTINUE_PRINTING;
2890 0 : eOption = SvtSecurityOptions::E_DOCWARN_PRINT;
2891 0 : break;
2892 : }
2893 : case WhenSigning :
2894 : {
2895 0 : nResId = STR_HIDDENINFO_CONTINUE_SIGNING;
2896 0 : eOption = SvtSecurityOptions::E_DOCWARN_SIGNING;
2897 0 : break;
2898 : }
2899 : case WhenCreatingPDF :
2900 : {
2901 0 : nResId = STR_HIDDENINFO_CONTINUE_CREATEPDF;
2902 0 : eOption = SvtSecurityOptions::E_DOCWARN_CREATEPDF;
2903 0 : break;
2904 : }
2905 : default:
2906 : {
2907 : SAL_WARN( "sfx2.doc", "SfxObjectShell::DetectHiddenInformation(): what fact?" );
2908 : }
2909 : }
2910 :
2911 0 : if ( eOption != -1 && SvtSecurityOptions().IsOptionSet( eOption ) )
2912 : {
2913 0 : String sMessage( SfxResId(STR_HIDDENINFO_CONTAINS).toString() );
2914 0 : sal_uInt16 nWantedStates = HIDDENINFORMATION_RECORDEDCHANGES | HIDDENINFORMATION_NOTES;
2915 0 : if ( eFact != WhenPrinting )
2916 0 : nWantedStates |= HIDDENINFORMATION_DOCUMENTVERSIONS;
2917 0 : sal_uInt16 nStates = GetHiddenInformationState( nWantedStates );
2918 0 : bool bWarning = false;
2919 :
2920 0 : if ( ( nStates & HIDDENINFORMATION_RECORDEDCHANGES ) == HIDDENINFORMATION_RECORDEDCHANGES )
2921 : {
2922 0 : sMessage += SfxResId(STR_HIDDENINFO_RECORDCHANGES).toString();
2923 0 : sMessage += '\n';
2924 0 : bWarning = true;
2925 : }
2926 0 : if ( ( nStates & HIDDENINFORMATION_NOTES ) == HIDDENINFORMATION_NOTES )
2927 : {
2928 0 : sMessage += SfxResId(STR_HIDDENINFO_NOTES).toString();
2929 0 : sMessage += '\n';
2930 0 : bWarning = true;
2931 : }
2932 0 : if ( ( nStates & HIDDENINFORMATION_DOCUMENTVERSIONS ) == HIDDENINFORMATION_DOCUMENTVERSIONS )
2933 : {
2934 0 : sMessage += SfxResId(STR_HIDDENINFO_DOCVERSIONS).toString();
2935 0 : sMessage += '\n';
2936 0 : bWarning = true;
2937 : }
2938 :
2939 0 : if ( bWarning )
2940 : {
2941 0 : sMessage += '\n';
2942 0 : sMessage += SfxResId(nResId).toString();
2943 0 : WarningBox aWBox( pParent, WB_YES_NO | WB_DEF_NO, sMessage );
2944 0 : nRet = aWBox.Execute();
2945 0 : }
2946 : }
2947 :
2948 0 : return nRet;
2949 : }
2950 :
2951 0 : sal_Bool SfxObjectShell::HasSecurityOptOpenReadOnly() const
2952 : {
2953 0 : return sal_True;
2954 : }
2955 :
2956 0 : sal_Bool SfxObjectShell::IsSecurityOptOpenReadOnly() const
2957 : {
2958 0 : return IsLoadReadonly();
2959 : }
2960 :
2961 0 : void SfxObjectShell::SetSecurityOptOpenReadOnly( sal_Bool _b )
2962 : {
2963 0 : SetLoadReadonly( _b );
2964 0 : }
2965 :
2966 105 : sal_Bool SfxObjectShell::LoadOwnFormat( SfxMedium& rMedium )
2967 : {
2968 105 : RTL_LOGFILE_PRODUCT_CONTEXT( aLog, "PERFORMANCE SfxObjectShell::LoadOwnFormat" );
2969 105 : if( RTL_LOGFILE_HASLOGFILE() )
2970 : {
2971 : rtl::OString aString(
2972 0 : rtl::OUStringToOString(rMedium.GetName(), RTL_TEXTENCODING_ASCII_US));
2973 0 : RTL_LOGFILE_PRODUCT_CONTEXT_TRACE1(aLog, "loading \"%s\"", aString.getStr());
2974 : }
2975 :
2976 105 : uno::Reference< embed::XStorage > xStorage = rMedium.GetStorage();
2977 105 : if ( xStorage.is() )
2978 : {
2979 : // Password
2980 105 : SFX_ITEMSET_ARG( rMedium.GetItemSet(), pPasswdItem, SfxStringItem, SID_PASSWORD, sal_False );
2981 105 : if ( pPasswdItem || ERRCODE_IO_ABORT != CheckPasswd_Impl( this, SFX_APP()->GetPool(), pMedium ) )
2982 : {
2983 105 : uno::Sequence< beans::NamedValue > aEncryptionData;
2984 105 : if ( GetEncryptionData_Impl(pMedium->GetItemSet(), aEncryptionData) )
2985 : {
2986 : try
2987 : {
2988 : // the following code must throw an exception in case of failure
2989 6 : ::comphelper::OStorageHelper::SetCommonStorageEncryptionData( xStorage, aEncryptionData );
2990 : }
2991 0 : catch( uno::Exception& )
2992 : {
2993 : // TODO/LATER: handle the error code
2994 : }
2995 : }
2996 :
2997 : // load document
2998 105 : return Load( rMedium );
2999 : }
3000 0 : return sal_False;
3001 : }
3002 : else
3003 0 : return sal_False;
3004 : }
3005 :
3006 576 : sal_Bool SfxObjectShell::SaveAsOwnFormat( SfxMedium& rMedium )
3007 : {
3008 576 : uno::Reference< embed::XStorage > xStorage = rMedium.GetStorage();
3009 576 : if( xStorage.is() )
3010 : {
3011 576 : sal_Int32 nVersion = rMedium.GetFilter()->GetVersion();
3012 :
3013 : // OASIS templates have own mediatypes ( SO7 also actually, but it is to late to use them here )
3014 576 : sal_Bool bTemplate = ( rMedium.GetFilter()->IsOwnTemplateFormat() && nVersion > SOFFICE_FILEFORMAT_60 );
3015 :
3016 576 : SetupStorage( xStorage, nVersion, bTemplate );
3017 : #ifndef DISABLE_SCRIPTING
3018 576 : if ( HasBasic() )
3019 : {
3020 : // Initialize Basic
3021 572 : GetBasicManager();
3022 :
3023 : // Save dialog/script container
3024 572 : pImp->pBasicManager->storeLibrariesToStorage( xStorage );
3025 : }
3026 : #endif
3027 576 : return SaveAs( rMedium );
3028 : }
3029 0 : else return sal_False;
3030 : }
3031 :
3032 11479 : uno::Reference< embed::XStorage > SfxObjectShell::GetStorage()
3033 : {
3034 11479 : if ( !pImp->m_xDocStorage.is() )
3035 : {
3036 : OSL_ENSURE( pImp->m_bCreateTempStor, "The storage must exist already!\n" );
3037 : try {
3038 : // no notification is required the storage is set the first time
3039 2229 : pImp->m_xDocStorage = ::comphelper::OStorageHelper::GetTemporaryStorage();
3040 : OSL_ENSURE( pImp->m_xDocStorage.is(), "The method must either return storage or throw an exception!" );
3041 :
3042 717 : SetupStorage( pImp->m_xDocStorage, SOFFICE_FILEFORMAT_CURRENT, sal_False );
3043 717 : pImp->m_bCreateTempStor = sal_False;
3044 717 : SFX_APP()->NotifyEvent( SfxEventHint( SFX_EVENT_STORAGECHANGED, GlobalEventConfig::GetEventName(STR_EVENT_STORAGECHANGED), this ) );
3045 : }
3046 1512 : catch( uno::Exception& )
3047 : {
3048 : // TODO/LATER: error handling?
3049 : DBG_UNHANDLED_EXCEPTION();
3050 : }
3051 : }
3052 :
3053 : OSL_ENSURE( pImp->m_xDocStorage.is(), "The document storage must be created!" );
3054 11479 : return pImp->m_xDocStorage;
3055 : }
3056 :
3057 :
3058 0 : sal_Bool SfxObjectShell::SaveChildren( sal_Bool bObjectsOnly )
3059 : {
3060 : RTL_LOGFILE_CONTEXT( aLog, "sfx2 (mv76033) SfxObjectShell::SaveChildren" );
3061 :
3062 0 : sal_Bool bResult = sal_True;
3063 0 : if ( pImp->mpObjectContainer )
3064 : {
3065 0 : sal_Bool bOasis = ( SotStorage::GetVersion( GetStorage() ) > SOFFICE_FILEFORMAT_60 );
3066 0 : GetEmbeddedObjectContainer().StoreChildren(bOasis,bObjectsOnly);
3067 : }
3068 :
3069 0 : return bResult;
3070 : }
3071 :
3072 576 : sal_Bool SfxObjectShell::SaveAsChildren( SfxMedium& rMedium )
3073 : {
3074 : RTL_LOGFILE_CONTEXT( aLog, "sfx2 (mv76033) SfxObjectShell::SaveAsChildren" );
3075 :
3076 576 : sal_Bool bResult = sal_True;
3077 :
3078 576 : uno::Reference < embed::XStorage > xStorage = rMedium.GetStorage();
3079 576 : if ( !xStorage.is() )
3080 0 : return sal_False;
3081 :
3082 576 : if ( xStorage == GetStorage() )
3083 0 : return SaveChildren();
3084 :
3085 576 : sal_Bool bOasis = sal_True;
3086 576 : if ( pImp->mpObjectContainer )
3087 : {
3088 288 : bOasis = ( SotStorage::GetVersion( xStorage ) > SOFFICE_FILEFORMAT_60 );
3089 288 : GetEmbeddedObjectContainer().StoreAsChildren(bOasis,SFX_CREATE_MODE_EMBEDDED == eCreateMode,xStorage);
3090 : }
3091 :
3092 576 : if ( bResult )
3093 576 : bResult = CopyStoragesOfUnknownMediaType( GetStorage(), xStorage );
3094 :
3095 576 : return bResult;
3096 : }
3097 :
3098 684 : sal_Bool SfxObjectShell::SaveCompletedChildren( sal_Bool bSuccess )
3099 : {
3100 : RTL_LOGFILE_CONTEXT( aLog, "sfx2 (mv76033) SfxObjectShell::SaveCompletedChildren" );
3101 :
3102 684 : sal_Bool bResult = sal_True;
3103 :
3104 684 : if ( pImp->mpObjectContainer )
3105 : {
3106 400 : uno::Sequence < ::rtl::OUString > aNames = GetEmbeddedObjectContainer().GetObjectNames();
3107 686 : for ( sal_Int32 n=0; n<aNames.getLength(); n++ )
3108 : {
3109 286 : uno::Reference < embed::XEmbeddedObject > xObj = GetEmbeddedObjectContainer().GetEmbeddedObject( aNames[n] );
3110 : OSL_ENSURE( xObj.is(), "An empty entry in the embedded objects list!\n" );
3111 286 : if ( xObj.is() )
3112 : {
3113 286 : uno::Reference< embed::XEmbedPersist > xPersist( xObj, uno::UNO_QUERY );
3114 286 : if ( xPersist.is() )
3115 : {
3116 : try
3117 : {
3118 286 : xPersist->saveCompleted( bSuccess );
3119 : }
3120 0 : catch( uno::Exception& )
3121 : {
3122 : // TODO/LATER: error handling
3123 0 : bResult = sal_False;
3124 : break;
3125 : }
3126 286 : }
3127 : }
3128 686 : }
3129 : }
3130 :
3131 684 : return bResult;
3132 : }
3133 :
3134 1138 : sal_Bool SfxObjectShell::SwitchChildrenPersistance( const uno::Reference< embed::XStorage >& xStorage,
3135 : sal_Bool bForceNonModified )
3136 : {
3137 : RTL_LOGFILE_CONTEXT( aLog, "sfx2 (mv76033) SfxObjectShell::SwitchChildrenPersistence" );
3138 :
3139 1138 : if ( !xStorage.is() )
3140 : {
3141 : // TODO/LATER: error handling
3142 0 : return sal_False;
3143 : }
3144 :
3145 1138 : sal_Bool bResult = sal_True;
3146 :
3147 1138 : if ( pImp->mpObjectContainer )
3148 570 : pImp->mpObjectContainer->SetPersistentEntries(xStorage,bForceNonModified);
3149 :
3150 1138 : return bResult;
3151 : }
3152 :
3153 : // Never call this method directly, always use the DoSaveCompleted call
3154 1154 : sal_Bool SfxObjectShell::SaveCompleted( const uno::Reference< embed::XStorage >& xStorage )
3155 : {
3156 : RTL_LOGFILE_CONTEXT( aLog, "sfx2 (mv76033) SfxObjectShell::SaveCompleted" );
3157 :
3158 1154 : sal_Bool bResult = sal_False;
3159 1154 : sal_Bool bSendNotification = sal_False;
3160 1154 : uno::Reference< embed::XStorage > xOldStorageHolder;
3161 :
3162 : #ifdef DBG_UTIL
3163 : // check for wrong creation of object container
3164 : sal_Bool bHasContainer = ( pImp->mpObjectContainer != 0 );
3165 : #endif
3166 :
3167 1154 : if ( !xStorage.is() || xStorage == GetStorage() )
3168 : {
3169 : // no persistence change
3170 584 : bResult = SaveCompletedChildren( sal_False );
3171 : }
3172 : else
3173 : {
3174 570 : if ( pImp->mpObjectContainer )
3175 286 : GetEmbeddedObjectContainer().SwitchPersistence( xStorage );
3176 :
3177 570 : bResult = SwitchChildrenPersistance( xStorage, sal_True );
3178 : }
3179 :
3180 1154 : if ( bResult )
3181 : {
3182 1154 : if ( xStorage.is() && pImp->m_xDocStorage != xStorage )
3183 : {
3184 : // make sure that until the storage is assigned the object
3185 : // container is not created by accident!
3186 : DBG_ASSERT( bHasContainer == (pImp->mpObjectContainer != 0), "Wrong storage in object container!" );
3187 570 : xOldStorageHolder = pImp->m_xDocStorage;
3188 570 : pImp->m_xDocStorage = xStorage;
3189 570 : bSendNotification = sal_True;
3190 :
3191 570 : if ( IsEnableSetModified() )
3192 570 : SetModified( sal_False );
3193 : }
3194 : }
3195 : else
3196 : {
3197 0 : if ( pImp->mpObjectContainer )
3198 0 : GetEmbeddedObjectContainer().SwitchPersistence( pImp->m_xDocStorage );
3199 :
3200 : // let already successfully connected objects be switched back
3201 0 : SwitchChildrenPersistance( pImp->m_xDocStorage, sal_True );
3202 : }
3203 :
3204 1154 : if ( bSendNotification )
3205 : {
3206 570 : SFX_APP()->NotifyEvent( SfxEventHint( SFX_EVENT_STORAGECHANGED, GlobalEventConfig::GetEventName(STR_EVENT_STORAGECHANGED), this ) );
3207 : }
3208 :
3209 1154 : return bResult;
3210 : }
3211 :
3212 : #if OSL_DEBUG_LEVEL > 0
3213 : sal_Bool StoragesOfUnknownMediaTypeAreCopied_Impl( const uno::Reference< embed::XStorage >& xSource,
3214 : const uno::Reference< embed::XStorage >& xTarget )
3215 : {
3216 : OSL_ENSURE( xSource.is() && xTarget.is(), "Source and/or target storages are not available!\n" );
3217 : if ( !xSource.is() || !xTarget.is() || xSource == xTarget )
3218 : return sal_True;
3219 :
3220 : try
3221 : {
3222 : uno::Sequence< ::rtl::OUString > aSubElements = xSource->getElementNames();
3223 : for ( sal_Int32 nInd = 0; nInd < aSubElements.getLength(); nInd++ )
3224 : {
3225 : if ( xSource->isStorageElement( aSubElements[nInd] ) )
3226 : {
3227 : ::rtl::OUString aMediaType;
3228 : ::rtl::OUString aMediaTypePropName( "MediaType" );
3229 : sal_Bool bGotMediaType = sal_False;
3230 :
3231 : try
3232 : {
3233 : uno::Reference< embed::XOptimizedStorage > xOptStorage( xSource, uno::UNO_QUERY_THROW );
3234 : bGotMediaType =
3235 : ( xOptStorage->getElementPropertyValue( aSubElements[nInd], aMediaTypePropName ) >>= aMediaType );
3236 : }
3237 : catch( uno::Exception& )
3238 : {}
3239 :
3240 : if ( !bGotMediaType )
3241 : {
3242 : uno::Reference< embed::XStorage > xSubStorage;
3243 : try {
3244 : xSubStorage = xSource->openStorageElement( aSubElements[nInd], embed::ElementModes::READ );
3245 : } catch( uno::Exception& )
3246 : {}
3247 :
3248 : if ( !xSubStorage.is() )
3249 : {
3250 : xSubStorage = ::comphelper::OStorageHelper::GetTemporaryStorage();
3251 : xSource->copyStorageElementLastCommitTo( aSubElements[nInd], xSubStorage );
3252 : }
3253 :
3254 : uno::Reference< beans::XPropertySet > xProps( xSubStorage, uno::UNO_QUERY_THROW );
3255 : bGotMediaType = ( xProps->getPropertyValue( aMediaTypePropName ) >>= aMediaType );
3256 : }
3257 :
3258 : // TODO/LATER: there should be a way to detect whether an object with such a MediaType can exist
3259 : // probably it should be placed in the MimeType-ClassID table or in standalone table
3260 : if ( !aMediaType.isEmpty()
3261 : && aMediaType.compareToAscii( "application/vnd.sun.star.oleobject" ) != COMPARE_EQUAL )
3262 : {
3263 : ::com::sun::star::datatransfer::DataFlavor aDataFlavor;
3264 : aDataFlavor.MimeType = aMediaType;
3265 : sal_uInt32 nFormat = SotExchange::GetFormat( aDataFlavor );
3266 :
3267 : switch ( nFormat )
3268 : {
3269 : case SOT_FORMATSTR_ID_STARWRITER_60 :
3270 : case SOT_FORMATSTR_ID_STARWRITERWEB_60 :
3271 : case SOT_FORMATSTR_ID_STARWRITERGLOB_60 :
3272 : case SOT_FORMATSTR_ID_STARDRAW_60 :
3273 : case SOT_FORMATSTR_ID_STARIMPRESS_60 :
3274 : case SOT_FORMATSTR_ID_STARCALC_60 :
3275 : case SOT_FORMATSTR_ID_STARCHART_60 :
3276 : case SOT_FORMATSTR_ID_STARMATH_60 :
3277 : case SOT_FORMATSTR_ID_STARWRITER_8:
3278 : case SOT_FORMATSTR_ID_STARWRITERWEB_8:
3279 : case SOT_FORMATSTR_ID_STARWRITERGLOB_8:
3280 : case SOT_FORMATSTR_ID_STARDRAW_8:
3281 : case SOT_FORMATSTR_ID_STARIMPRESS_8:
3282 : case SOT_FORMATSTR_ID_STARCALC_8:
3283 : case SOT_FORMATSTR_ID_STARCHART_8:
3284 : case SOT_FORMATSTR_ID_STARMATH_8:
3285 : break;
3286 :
3287 : default:
3288 : {
3289 : if ( !xTarget->hasByName( aSubElements[nInd] ) )
3290 : return sal_False;
3291 : }
3292 : }
3293 : }
3294 : }
3295 : }
3296 : }
3297 : catch( uno::Exception& )
3298 : {
3299 : OSL_FAIL( "Cant check storage consistency!\n" );
3300 : }
3301 :
3302 : return sal_True;
3303 : }
3304 : #endif
3305 :
3306 568 : sal_Bool SfxObjectShell::SwitchPersistance( const uno::Reference< embed::XStorage >& xStorage )
3307 : {
3308 : RTL_LOGFILE_CONTEXT( aLog, "sfx2 (mv76033) SfxObjectShell::SwitchPersistance" );
3309 :
3310 568 : sal_Bool bResult = sal_False;
3311 : #ifdef DBG_UTIL
3312 : // check for wrong creation of object container
3313 : sal_Bool bHasContainer = ( pImp->mpObjectContainer != 0 );
3314 : #endif
3315 568 : if ( xStorage.is() )
3316 : {
3317 568 : if ( pImp->mpObjectContainer )
3318 284 : GetEmbeddedObjectContainer().SwitchPersistence( xStorage );
3319 568 : bResult = SwitchChildrenPersistance( xStorage );
3320 :
3321 : // TODO/LATER: substorages that have unknown mimetypes probably should be copied to the target storage here
3322 : OSL_ENSURE( StoragesOfUnknownMediaTypeAreCopied_Impl( pImp->m_xDocStorage, xStorage ),
3323 : "Some of substorages with unknown mimetypes is lost!" );
3324 : }
3325 :
3326 568 : if ( bResult )
3327 : {
3328 : // make sure that until the storage is assigned the object container is not created by accident!
3329 : DBG_ASSERT( bHasContainer == (pImp->mpObjectContainer != 0), "Wrong storage in object container!" );
3330 568 : if ( pImp->m_xDocStorage != xStorage )
3331 568 : DoSaveCompleted( new SfxMedium( xStorage, GetMedium()->GetBaseURL() ) );
3332 :
3333 568 : if ( IsEnableSetModified() )
3334 568 : SetModified( sal_True ); // ???
3335 : }
3336 :
3337 568 : return bResult;
3338 : }
3339 :
3340 576 : sal_Bool SfxObjectShell::CopyStoragesOfUnknownMediaType( const uno::Reference< embed::XStorage >& xSource,
3341 : const uno::Reference< embed::XStorage >& xTarget )
3342 : {
3343 : RTL_LOGFILE_CONTEXT( aLog, "sfx2 (mv76033) SfxObjectShell::CopyStoragesOfUnknownMediaType" );
3344 :
3345 : // This method does not commit the target storage and should not do it
3346 576 : sal_Bool bResult = sal_True;
3347 :
3348 : try
3349 : {
3350 576 : uno::Sequence< ::rtl::OUString > aSubElements = xSource->getElementNames();
3351 3446 : for ( sal_Int32 nInd = 0; nInd < aSubElements.getLength(); nInd++ )
3352 : {
3353 2870 : if ( aSubElements[nInd] == "Configurations" )
3354 : {
3355 : // The workaround for compatibility with SO7, "Configurations" substorage must be preserved
3356 0 : if ( xSource->isStorageElement( aSubElements[nInd] ) )
3357 : {
3358 : OSL_ENSURE( !xTarget->hasByName( aSubElements[nInd] ),
3359 : "The target storage is an output storage, the element should not exist in the target!\n" );
3360 :
3361 0 : xSource->copyElementTo( aSubElements[nInd], xTarget, aSubElements[nInd] );
3362 : }
3363 : }
3364 2870 : else if ( xSource->isStorageElement( aSubElements[nInd] ) )
3365 : {
3366 2280 : ::rtl::OUString aMediaType;
3367 2280 : ::rtl::OUString aMediaTypePropName( "MediaType" );
3368 2280 : sal_Bool bGotMediaType = sal_False;
3369 :
3370 : try
3371 : {
3372 2280 : uno::Reference< embed::XOptimizedStorage > xOptStorage( xSource, uno::UNO_QUERY_THROW );
3373 : bGotMediaType =
3374 2280 : ( xOptStorage->getElementPropertyValue( aSubElements[nInd], aMediaTypePropName ) >>= aMediaType );
3375 : }
3376 0 : catch( uno::Exception& )
3377 : {}
3378 :
3379 2280 : if ( !bGotMediaType )
3380 : {
3381 0 : uno::Reference< embed::XStorage > xSubStorage;
3382 : try {
3383 0 : xSubStorage = xSource->openStorageElement( aSubElements[nInd], embed::ElementModes::READ );
3384 0 : } catch( uno::Exception& )
3385 : {}
3386 :
3387 0 : if ( !xSubStorage.is() )
3388 : {
3389 : // TODO/LATER: as optimization in future a substorage of target storage could be used
3390 : // instead of the temporary storage; this substorage should be removed later
3391 : // if the MimeType is wrong
3392 0 : xSubStorage = ::comphelper::OStorageHelper::GetTemporaryStorage();
3393 0 : xSource->copyStorageElementLastCommitTo( aSubElements[nInd], xSubStorage );
3394 : }
3395 :
3396 0 : uno::Reference< beans::XPropertySet > xProps( xSubStorage, uno::UNO_QUERY_THROW );
3397 0 : bGotMediaType = ( xProps->getPropertyValue( aMediaTypePropName ) >>= aMediaType );
3398 : }
3399 :
3400 : // TODO/LATER: there should be a way to detect whether an object with such a MediaType can exist
3401 : // probably it should be placed in the MimeType-ClassID table or in standalone table
3402 2284 : if ( !aMediaType.isEmpty()
3403 4 : && aMediaType.compareToAscii( "application/vnd.sun.star.oleobject" ) != COMPARE_EQUAL )
3404 : {
3405 4 : ::com::sun::star::datatransfer::DataFlavor aDataFlavor;
3406 4 : aDataFlavor.MimeType = aMediaType;
3407 4 : sal_uInt32 nFormat = SotExchange::GetFormat( aDataFlavor );
3408 :
3409 4 : switch ( nFormat )
3410 : {
3411 : case SOT_FORMATSTR_ID_STARWRITER_60 :
3412 : case SOT_FORMATSTR_ID_STARWRITERWEB_60 :
3413 : case SOT_FORMATSTR_ID_STARWRITERGLOB_60 :
3414 : case SOT_FORMATSTR_ID_STARDRAW_60 :
3415 : case SOT_FORMATSTR_ID_STARIMPRESS_60 :
3416 : case SOT_FORMATSTR_ID_STARCALC_60 :
3417 : case SOT_FORMATSTR_ID_STARCHART_60 :
3418 : case SOT_FORMATSTR_ID_STARMATH_60 :
3419 : case SOT_FORMATSTR_ID_STARWRITER_8:
3420 : case SOT_FORMATSTR_ID_STARWRITERWEB_8:
3421 : case SOT_FORMATSTR_ID_STARWRITERGLOB_8:
3422 : case SOT_FORMATSTR_ID_STARDRAW_8:
3423 : case SOT_FORMATSTR_ID_STARIMPRESS_8:
3424 : case SOT_FORMATSTR_ID_STARCALC_8:
3425 : case SOT_FORMATSTR_ID_STARCHART_8:
3426 : case SOT_FORMATSTR_ID_STARMATH_8:
3427 0 : break;
3428 :
3429 : default:
3430 : {
3431 : OSL_ENSURE( aSubElements[nInd] == "Configurations2" || !xTarget->hasByName( aSubElements[nInd] ),
3432 : "The target storage is an output storage, the element should not exist in the target!\n" );
3433 :
3434 4 : if ( !xTarget->hasByName( aSubElements[nInd] ) )
3435 : {
3436 4 : xSource->copyElementTo( aSubElements[nInd], xTarget, aSubElements[nInd] );
3437 : }
3438 : }
3439 4 : }
3440 2280 : }
3441 : }
3442 576 : }
3443 : }
3444 0 : catch( uno::Exception& )
3445 : {
3446 0 : bResult = sal_False;
3447 : // TODO/LATER: a specific error could be provided
3448 : }
3449 :
3450 576 : return bResult;
3451 : }
3452 :
3453 6 : sal_Bool SfxObjectShell::GenerateAndStoreThumbnail( sal_Bool bEncrypted,
3454 : sal_Bool bSigned,
3455 : sal_Bool bIsTemplate,
3456 : const uno::Reference< embed::XStorage >& xStor )
3457 : {
3458 : RTL_LOGFILE_CONTEXT( aLog, "sfx2 (mv76033) SfxObjectShell::GenerateAndStoreThumbnail" );
3459 :
3460 6 : sal_Bool bResult = sal_False;
3461 :
3462 : try {
3463 : uno::Reference< embed::XStorage > xThumbnailStor =
3464 6 : xStor->openStorageElement( ::rtl::OUString("Thumbnails"),
3465 6 : embed::ElementModes::READWRITE );
3466 6 : if ( xThumbnailStor.is() )
3467 : {
3468 6 : uno::Reference< io::XStream > xStream = xThumbnailStor->openStreamElement(
3469 : ::rtl::OUString("thumbnail.png"),
3470 6 : embed::ElementModes::READWRITE );
3471 :
3472 6 : if ( xStream.is() && WriteThumbnail( bEncrypted, bSigned, bIsTemplate, xStream ) )
3473 : {
3474 6 : uno::Reference< embed::XTransactedObject > xTransact( xThumbnailStor, uno::UNO_QUERY_THROW );
3475 6 : xTransact->commit();
3476 6 : bResult = sal_True;
3477 6 : }
3478 6 : }
3479 : }
3480 0 : catch( uno::Exception& )
3481 : {
3482 : }
3483 :
3484 6 : return bResult;
3485 : }
3486 :
3487 6 : sal_Bool SfxObjectShell::WriteThumbnail( sal_Bool bEncrypted,
3488 : sal_Bool bSigned,
3489 : sal_Bool bIsTemplate,
3490 : const uno::Reference< io::XStream >& xStream )
3491 : {
3492 6 : sal_Bool bResult = sal_False;
3493 :
3494 6 : if ( xStream.is() )
3495 : {
3496 : try {
3497 6 : uno::Reference< io::XTruncate > xTruncate( xStream->getOutputStream(), uno::UNO_QUERY_THROW );
3498 6 : xTruncate->truncate();
3499 :
3500 6 : uno::Reference < beans::XPropertySet > xSet( xStream, uno::UNO_QUERY );
3501 6 : if ( xSet.is() )
3502 6 : xSet->setPropertyValue( ::rtl::OUString("MediaType"),
3503 6 : uno::makeAny( ::rtl::OUString("image/png") ) );
3504 6 : if ( bEncrypted )
3505 : {
3506 : sal_uInt16 nResID = GraphicHelper::getThumbnailReplacementIDByFactoryName_Impl(
3507 0 : ::rtl::OUString::createFromAscii( GetFactory().GetShortName() ),
3508 0 : bIsTemplate );
3509 0 : if ( nResID )
3510 : {
3511 0 : if ( !bSigned )
3512 : {
3513 0 : bResult = GraphicHelper::getThumbnailReplacement_Impl( nResID, xStream );
3514 : }
3515 : else
3516 : {
3517 : // retrieve the bitmap and write a signature bitmap over it
3518 0 : SfxResId aResId( nResID );
3519 0 : BitmapEx aThumbBitmap( aResId );
3520 0 : bResult = GraphicHelper::getSignedThumbnailFormatFromBitmap_Impl( aThumbBitmap, xStream );
3521 : }
3522 : }
3523 : }
3524 : else
3525 : {
3526 : ::boost::shared_ptr<GDIMetaFile> pMetaFile =
3527 6 : GetPreviewMetaFile( sal_False );
3528 6 : if ( pMetaFile )
3529 : {
3530 : bResult = GraphicHelper::getThumbnailFormatFromGDI_Impl(
3531 6 : pMetaFile.get(), bSigned, xStream );
3532 6 : }
3533 6 : }
3534 : }
3535 0 : catch( uno::Exception& )
3536 : {}
3537 : }
3538 :
3539 6 : return bResult;
3540 : }
3541 :
3542 8 : void SfxObjectShell::UpdateLinks()
3543 : {
3544 8 : }
3545 :
3546 0 : bool SfxObjectShell::LoadExternal(SfxMedium&, const OUString&)
3547 : {
3548 : // Not implemented. It's an error if the code path ever comes here.
3549 0 : return false;
3550 : }
3551 :
3552 0 : void SfxObjectShell::CheckConfigOptions()
3553 : {
3554 : // not handled. Each app's shell needs to overwrite this method to add handler.
3555 0 : SetConfigOptionsChecked(true);
3556 0 : }
3557 :
3558 26 : sal_Bool SfxObjectShell::IsConfigOptionsChecked() const
3559 : {
3560 26 : return pImp->m_bConfigOptionsChecked;
3561 : }
3562 :
3563 26 : void SfxObjectShell::SetConfigOptionsChecked( sal_Bool bChecked )
3564 : {
3565 26 : pImp->m_bConfigOptionsChecked = bChecked;
3566 26 : }
3567 :
3568 8 : sal_Bool SfxObjectShell::QuerySaveSizeExceededModules_Impl( const uno::Reference< task::XInteractionHandler >& xHandler )
3569 : {
3570 : #ifdef DISABLE_SCRIPTING
3571 : (void) xHandler;
3572 : #else
3573 8 : if ( !HasBasic() )
3574 4 : return sal_True;
3575 :
3576 4 : if ( !pImp->pBasicManager->isValid() )
3577 0 : GetBasicManager();
3578 4 : uno::Sequence< rtl::OUString > sModules;
3579 4 : if ( xHandler.is() )
3580 : {
3581 4 : if( pImp->pBasicManager->LegacyPsswdBinaryLimitExceeded( sModules ) )
3582 : {
3583 0 : ModuleSizeExceeded* pReq = new ModuleSizeExceeded( sModules );
3584 0 : uno::Reference< task::XInteractionRequest > xReq( pReq );
3585 0 : xHandler->handle( xReq );
3586 0 : return pReq->isApprove();
3587 : }
3588 : }
3589 : #endif
3590 : // No interaction handler, default is to continue to save
3591 4 : return sal_True;
3592 : }
3593 : // -----------------------------------------------------------------------------
3594 0 : uno::Reference< task::XInteractionHandler > SfxObjectShell::getInteractionHandler() const
3595 : {
3596 0 : uno::Reference< task::XInteractionHandler > xRet;
3597 0 : if ( GetMedium() )
3598 0 : xRet = GetMedium()->GetInteractionHandler();
3599 0 : return xRet;
3600 : }
3601 :
3602 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
