1 /**************************************************************
2 *
3 * Licensed to the Apache Software Foundation (ASF) under one
4 * or more contributor license agreements. See the NOTICE file
5 * distributed with this work for additional information
6 * regarding copyright ownership. The ASF licenses this file
7 * to you under the Apache License, Version 2.0 (the
8 * "License"); you may not use this file except in compliance
9 * with the License. You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing,
14 * software distributed under the License is distributed on an
15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16 * KIND, either express or implied. See the License for the
17 * specific language governing permissions and limitations
18 * under the License.
19 *
20 *************************************************************/
21
22
23
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_sfx2.hxx"
26 #include <com/sun/star/ui/dialogs/XExecutableDialog.hpp>
27 #include <com/sun/star/ui/dialogs/XFilePicker.hpp>
28 #include <com/sun/star/ui/dialogs/XFilePickerControlAccess.hpp>
29 #include <com/sun/star/ui/dialogs/CommonFilePickerElementIds.hpp>
30 #include <com/sun/star/ui/dialogs/ExtendedFilePickerElementIds.hpp>
31 #include "com/sun/star/ui/dialogs/TemplateDescription.hpp"
32 #include <com/sun/star/view/XSelectionSupplier.hpp>
33 #include <com/sun/star/beans/XPropertyAccess.hpp>
34 #include <com/sun/star/beans/XPropertySet.hpp>
35 #include <com/sun/star/beans/XPropertyContainer.hpp>
36 #include <com/sun/star/beans/PropertyAttribute.hpp>
37 #include <com/sun/star/document/XExporter.hpp>
38 #include <com/sun/star/document/XDocumentInfoSupplier.hpp>
39 #include <com/sun/star/document/XDocumentInfo.hpp>
40 #include <com/sun/star/task/XInteractionHandler.hpp>
41 #include <com/sun/star/util/DateTime.hpp>
42 #include <com/sun/star/util/XURLTransformer.hpp>
43 #include <com/sun/star/frame/XStorable.hpp>
44 #include <com/sun/star/frame/XStorable2.hpp>
45 #include <com/sun/star/frame/XDispatchProvider.hpp>
46 #include <com/sun/star/frame/XDispatch.hpp>
47 #include <com/sun/star/frame/XTitle.hpp>
48 #include <com/sun/star/util/XModifyListener.hpp>
49 #include <com/sun/star/util/XModifiable.hpp>
50 #include <com/sun/star/util/XModifyBroadcaster.hpp>
51
52 #include <com/sun/star/util/XCloneable.hpp>
53 #include <com/sun/star/frame/XModuleManager.hpp>
54 #include <com/sun/star/io/IOException.hpp>
55
56 #include "guisaveas.hxx"
57
58 #include <unotools/pathoptions.hxx>
59 #include <unotools/pathoptions.hxx>
60 #include <svl/itemset.hxx>
61 #include <svl/eitem.hxx>
62 #include <svl/stritem.hxx>
63 #include <svl/intitem.hxx>
64 #include <unotools/useroptions.hxx>
65 #include <unotools/saveopt.hxx>
66 #include <tools/debug.hxx>
67 #include <tools/urlobj.hxx>
68 #include <comphelper/processfactory.hxx>
69 #include <comphelper/configurationhelper.hxx>
70 #include <comphelper/mimeconfighelper.hxx>
71 #include <vcl/msgbox.hxx>
72 #include <vcl/window.hxx>
73 #include <toolkit/awt/vclxwindow.hxx>
74
75 #include <sfx2/sfxsids.hrc>
76 #include <doc.hrc>
77 #include <sfx2/sfxresid.hxx>
78 #include <sfx2/docfilt.hxx>
79 #include <sfx2/filedlghelper.hxx>
80 #include <sfx2/app.hxx>
81 #include <sfx2/objsh.hxx>
82 #include <sfx2/dinfdlg.hxx>
83 #include <sfx2/request.hxx>
84 #include <sfxtypes.hxx>
85 #include "alienwarn.hxx"
86
87 #include "../appl/app.hrc"
88
89 #define DOCPROPSNUM 17
90
91 // flags that specify requested operation
92 #define EXPORT_REQUESTED 1
93 #define PDFEXPORT_REQUESTED 2
94 #define PDFDIRECTEXPORT_REQUESTED 4
95 #define WIDEEXPORT_REQUESTED 8
96 #define SAVE_REQUESTED 16
97 #define SAVEAS_REQUESTED 32
98
99 // possible statuses of save operation
100 #define STATUS_NO_ACTION 0
101 #define STATUS_SAVE 1
102 #define STATUS_SAVEAS 2
103 #define STATUS_SAVEAS_STANDARDNAME 3
104
105 const ::rtl::OUString aFilterNameString = ::rtl::OUString::createFromAscii( "FilterName" );
106 const ::rtl::OUString aFilterOptionsString = ::rtl::OUString::createFromAscii( "FilterOptions" );
107 const ::rtl::OUString aFilterDataString = ::rtl::OUString::createFromAscii( "FilterData" );
108 const ::rtl::OUString aFilterFlagsString = ::rtl::OUString::createFromAscii( "FilterFlags" );
109
110 using namespace ::com::sun::star;
111
112 namespace {
113 //-------------------------------------------------------------------------
getSlotIDFromMode(sal_Int8 nStoreMode)114 static sal_uInt16 getSlotIDFromMode( sal_Int8 nStoreMode )
115 {
116 // This is a temporary hardcoded solution must be removed when
117 // dialogs do not need parameters in SidSet representation any more
118
119 sal_uInt16 nResult = 0;
120 if ( nStoreMode == EXPORT_REQUESTED )
121 nResult = SID_EXPORTDOC;
122 else if ( nStoreMode == ( EXPORT_REQUESTED | PDFEXPORT_REQUESTED ) )
123 nResult = SID_EXPORTDOCASPDF;
124 else if ( nStoreMode == ( EXPORT_REQUESTED | PDFEXPORT_REQUESTED | PDFDIRECTEXPORT_REQUESTED ) )
125 nResult = SID_DIRECTEXPORTDOCASPDF;
126 else if ( nStoreMode == SAVEAS_REQUESTED || nStoreMode == ( EXPORT_REQUESTED | WIDEEXPORT_REQUESTED ) )
127 nResult = SID_SAVEASDOC;
128 else {
129 DBG_ASSERT( sal_False, "Unacceptable slot name is provided!\n" );
130 }
131
132 return nResult;
133 }
134
135 //-------------------------------------------------------------------------
getStoreModeFromSlotName(const::rtl::OUString & aSlotName)136 static sal_uInt8 getStoreModeFromSlotName( const ::rtl::OUString& aSlotName )
137 {
138 sal_uInt8 nResult = 0;
139 if ( aSlotName.equalsAscii( "ExportTo" ) )
140 nResult = EXPORT_REQUESTED;
141 else if ( aSlotName.equalsAscii( "ExportToPDF" ) )
142 nResult = EXPORT_REQUESTED | PDFEXPORT_REQUESTED;
143 else if ( aSlotName.equalsAscii( "ExportDirectToPDF" ) )
144 nResult = EXPORT_REQUESTED | PDFEXPORT_REQUESTED | PDFDIRECTEXPORT_REQUESTED;
145 else if ( aSlotName.equalsAscii( "Save" ) )
146 nResult = SAVE_REQUESTED;
147 else if ( aSlotName.equalsAscii( "SaveAs" ) )
148 nResult = SAVEAS_REQUESTED;
149 else
150 throw task::ErrorCodeIOException( ::rtl::OUString(),
151 uno::Reference< uno::XInterface >(),
152 ERRCODE_IO_INVALIDPARAMETER );
153
154 return nResult;
155 }
156
157 //-------------------------------------------------------------------------
getMustFlags(sal_Int8 nStoreMode)158 static sal_Int32 getMustFlags( sal_Int8 nStoreMode )
159 {
160 return ( SFX_FILTER_EXPORT
161 | ( ( ( nStoreMode & EXPORT_REQUESTED ) && !( nStoreMode & WIDEEXPORT_REQUESTED ) ) ? 0 : SFX_FILTER_IMPORT ) );
162 }
163
164 //-------------------------------------------------------------------------
getDontFlags(sal_Int8 nStoreMode)165 static sal_Int32 getDontFlags( sal_Int8 nStoreMode )
166 {
167 return ( SFX_FILTER_INTERNAL
168 | SFX_FILTER_NOTINFILEDLG
169 | ( ( ( nStoreMode & EXPORT_REQUESTED ) && !( nStoreMode & WIDEEXPORT_REQUESTED ) ) ? SFX_FILTER_IMPORT : 0 ) );
170 }
171
172 //=========================================================================
173 // class DocumentSettingsGuard
174 //=========================================================================
175
176 class DocumentSettingsGuard
177 {
178 uno::Reference< beans::XPropertySet > m_xDocumentSettings;
179 sal_Bool m_bPreserveReadOnly;
180 sal_Bool m_bReadOnlySupported;
181
182 sal_Bool m_bRestoreSettings;
183 public:
DocumentSettingsGuard(const uno::Reference<frame::XModel> & xModel,sal_Bool bReadOnly,sal_Bool bRestore)184 DocumentSettingsGuard( const uno::Reference< frame::XModel >& xModel, sal_Bool bReadOnly, sal_Bool bRestore )
185 : m_bPreserveReadOnly( sal_False )
186 , m_bReadOnlySupported( sal_False )
187 , m_bRestoreSettings( bRestore )
188 {
189 try
190 {
191 uno::Reference< lang::XMultiServiceFactory > xDocSettingsSupplier( xModel, uno::UNO_QUERY_THROW );
192 m_xDocumentSettings.set(
193 xDocSettingsSupplier->createInstance(
194 ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.document.Settings" ) ) ),
195 uno::UNO_QUERY_THROW );
196
197 ::rtl::OUString aLoadReadonlyString( RTL_CONSTASCII_USTRINGPARAM( "LoadReadonly" ) );
198
199 try
200 {
201 m_xDocumentSettings->getPropertyValue( aLoadReadonlyString ) >>= m_bPreserveReadOnly;
202 m_xDocumentSettings->setPropertyValue( aLoadReadonlyString, uno::makeAny( bReadOnly ) );
203 m_bReadOnlySupported = sal_True;
204 }
205 catch( uno::Exception& )
206 {}
207 }
208 catch( uno::Exception& )
209 {}
210
211 if ( ( bReadOnly && !m_bReadOnlySupported ) )
212 throw uno::RuntimeException(); // the user could provide the data, so it must be stored
213 }
214
~DocumentSettingsGuard()215 ~DocumentSettingsGuard()
216 {
217 if ( m_bRestoreSettings )
218 {
219 ::rtl::OUString aLoadReadonlyString( RTL_CONSTASCII_USTRINGPARAM( "LoadReadonly" ) );
220
221 try
222 {
223 if ( m_bReadOnlySupported )
224 m_xDocumentSettings->setPropertyValue( aLoadReadonlyString, uno::makeAny( m_bPreserveReadOnly ) );
225 }
226 catch( uno::Exception& )
227 {
228 OSL_ASSERT( "Unexpected exception!" );
229 }
230 }
231 }
232 };
233 } // anonymous namespace
234
235 //=========================================================================
236 // class ModelData_Impl
237 //=========================================================================
238 class ModelData_Impl
239 {
240 SfxStoringHelper* m_pOwner;
241 uno::Reference< frame::XModel > m_xModel;
242 uno::Reference< frame::XStorable > m_xStorable;
243 uno::Reference< frame::XStorable2 > m_xStorable2;
244 uno::Reference< util::XModifiable > m_xModifiable;
245
246 ::rtl::OUString m_aModuleName;
247 ::comphelper::SequenceAsHashMap* m_pDocumentPropsHM;
248 ::comphelper::SequenceAsHashMap* m_pModulePropsHM;
249
250 ::comphelper::SequenceAsHashMap m_aMediaDescrHM;
251
252 sal_Bool m_bRecommendReadOnly;
253
254 public:
255 ModelData_Impl( SfxStoringHelper& aOwner,
256 const uno::Reference< frame::XModel >& xModel,
257 const uno::Sequence< beans::PropertyValue >& aMediaDescr );
258
259 ~ModelData_Impl();
260
261 void FreeDocumentProps();
262
263 uno::Reference< frame::XModel > GetModel();
264 uno::Reference< frame::XStorable > GetStorable();
265 uno::Reference< frame::XStorable2 > GetStorable2();
266 uno::Reference< util::XModifiable > GetModifiable();
267
GetMediaDescr()268 ::comphelper::SequenceAsHashMap& GetMediaDescr() { return m_aMediaDescrHM; }
269
IsRecommendReadOnly()270 sal_Bool IsRecommendReadOnly() { return m_bRecommendReadOnly; }
271
272 const ::comphelper::SequenceAsHashMap& GetDocProps();
273
274 ::rtl::OUString GetModuleName();
275 const ::comphelper::SequenceAsHashMap& GetModuleProps();
276
277 void CheckInteractionHandler();
278
279
280 ::rtl::OUString GetDocServiceName();
281 uno::Sequence< beans::PropertyValue > GetDocServiceDefaultFilterCheckFlags( sal_Int32 nMust, sal_Int32 nDont );
282 uno::Sequence< beans::PropertyValue > GetDocServiceAnyFilter( sal_Int32 nMust, sal_Int32 nDont );
283 uno::Sequence< beans::PropertyValue > GetPreselectedFilter_Impl( sal_Int8 nStoreMode );
284 uno::Sequence< beans::PropertyValue > GetDocServiceDefaultFilter();
285
286 sal_Bool ExecuteFilterDialog_Impl( const ::rtl::OUString& aFilterName );
287
288 sal_Int8 CheckSaveAcceptable( sal_Int8 nCurStatus );
289 sal_Int8 CheckStateForSave();
290
291 sal_Int8 CheckFilter( const ::rtl::OUString& );
292
293 sal_Bool CheckFilterOptionsDialogExistence();
294
295 sal_Bool OutputFileDialog( sal_Int8 nStoreMode,
296 const ::comphelper::SequenceAsHashMap& aPreselectedFilterPropsHM,
297 sal_Bool bSetStandardName,
298 ::rtl::OUString& aSuggestedName,
299 sal_Bool bPreselectPassword,
300 const ::rtl::OUString& aSuggestedDir,
301 sal_Int16 nDialog,
302 const ::rtl::OUString& rStandardDir,
303 const ::com::sun::star::uno::Sequence< ::rtl::OUString >& rBlackList
304 );
305
306 sal_Bool ShowDocumentInfoDialog();
307
308 ::rtl::OUString GetReccomendedDir( const ::rtl::OUString& aSuggestedDir,
309 const sfx2::FileDialogHelper::Context& aCtxt );
310 ::rtl::OUString GetReccomendedName( const ::rtl::OUString& aSuggestedName,
311 const ::rtl::OUString& aTypeName );
312
313 };
314
315 //-------------------------------------------------------------------------
ModelData_Impl(SfxStoringHelper & aOwner,const uno::Reference<frame::XModel> & xModel,const uno::Sequence<beans::PropertyValue> & aMediaDescr)316 ModelData_Impl::ModelData_Impl( SfxStoringHelper& aOwner,
317 const uno::Reference< frame::XModel >& xModel,
318 const uno::Sequence< beans::PropertyValue >& aMediaDescr )
319 : m_pOwner( &aOwner )
320 , m_xModel( xModel )
321 , m_pDocumentPropsHM( NULL )
322 , m_pModulePropsHM( NULL )
323 , m_aMediaDescrHM( aMediaDescr )
324 , m_bRecommendReadOnly( sal_False )
325 {
326 CheckInteractionHandler();
327 }
328
329 //-------------------------------------------------------------------------
~ModelData_Impl()330 ModelData_Impl::~ModelData_Impl()
331 {
332 FreeDocumentProps();
333 if ( m_pDocumentPropsHM )
334 delete m_pDocumentPropsHM;
335
336 if ( m_pModulePropsHM )
337 delete m_pModulePropsHM;
338 }
339
340 //-------------------------------------------------------------------------
FreeDocumentProps()341 void ModelData_Impl::FreeDocumentProps()
342 {
343 if ( m_pDocumentPropsHM )
344 {
345 delete m_pDocumentPropsHM;
346 m_pDocumentPropsHM = NULL;
347 }
348 }
349
350 //-------------------------------------------------------------------------
GetModel()351 uno::Reference< frame::XModel > ModelData_Impl::GetModel()
352 {
353 if ( !m_xModel.is() )
354 throw uno::RuntimeException();
355
356 return m_xModel;
357 }
358
359 //-------------------------------------------------------------------------
GetStorable()360 uno::Reference< frame::XStorable > ModelData_Impl::GetStorable()
361 {
362 if ( !m_xStorable.is() )
363 {
364 m_xStorable = uno::Reference< frame::XStorable >( m_xModel, uno::UNO_QUERY );
365 if ( !m_xStorable.is() )
366 throw uno::RuntimeException();
367 }
368
369 return m_xStorable;
370 }
371
372 //-------------------------------------------------------------------------
GetStorable2()373 uno::Reference< frame::XStorable2 > ModelData_Impl::GetStorable2()
374 {
375 if ( !m_xStorable2.is() )
376 {
377 m_xStorable2 = uno::Reference< frame::XStorable2 >( m_xModel, uno::UNO_QUERY );
378 if ( !m_xStorable2.is() )
379 throw uno::RuntimeException();
380 }
381
382 return m_xStorable2;
383 }
384
385 //-------------------------------------------------------------------------
GetModifiable()386 uno::Reference< util::XModifiable > ModelData_Impl::GetModifiable()
387 {
388 if ( !m_xModifiable.is() )
389 {
390 m_xModifiable = uno::Reference< util::XModifiable >( m_xModel, uno::UNO_QUERY );
391 if ( !m_xModifiable.is() )
392 throw uno::RuntimeException();
393 }
394
395 return m_xModifiable;
396 }
397
398 //-------------------------------------------------------------------------
GetDocProps()399 const ::comphelper::SequenceAsHashMap& ModelData_Impl::GetDocProps()
400 {
401 if ( !m_pDocumentPropsHM )
402 m_pDocumentPropsHM = new ::comphelper::SequenceAsHashMap( GetModel()->getArgs() );
403
404 return *m_pDocumentPropsHM;
405 }
406
407 //-------------------------------------------------------------------------
GetModuleName()408 ::rtl::OUString ModelData_Impl::GetModuleName()
409 {
410 if ( !m_aModuleName.getLength() )
411 {
412 m_aModuleName = m_pOwner->GetModuleManager()->identify(
413 uno::Reference< uno::XInterface >( m_xModel, uno::UNO_QUERY ) );
414 if ( !m_aModuleName.getLength() )
415 throw uno::RuntimeException(); // TODO:
416 }
417 return m_aModuleName;
418 }
419
420 //-------------------------------------------------------------------------
GetModuleProps()421 const ::comphelper::SequenceAsHashMap& ModelData_Impl::GetModuleProps()
422 {
423 if ( !m_pModulePropsHM )
424 {
425 uno::Sequence< beans::PropertyValue > aModuleProps;
426 m_pOwner->GetNamedModuleManager()->getByName( GetModuleName() ) >>= aModuleProps;
427 if ( !aModuleProps.getLength() )
428 throw uno::RuntimeException(); // TODO;
429 m_pModulePropsHM = new ::comphelper::SequenceAsHashMap( aModuleProps );
430 }
431
432 return *m_pModulePropsHM;
433 }
434
435 //-------------------------------------------------------------------------
GetDocServiceName()436 ::rtl::OUString ModelData_Impl::GetDocServiceName()
437 {
438 return GetModuleProps().getUnpackedValueOrDefault(::rtl::OUString::createFromAscii( "ooSetupFactoryDocumentService" ), ::rtl::OUString());
439 }
440
441 //-------------------------------------------------------------------------
CheckInteractionHandler()442 void ModelData_Impl::CheckInteractionHandler()
443 {
444 ::comphelper::SequenceAsHashMap::const_iterator aInteractIter =
445 m_aMediaDescrHM.find( ::rtl::OUString::createFromAscii( "InteractionHandler" ) );
446
447 if ( aInteractIter == m_aMediaDescrHM.end() )
448 {
449 try {
450 m_aMediaDescrHM[ ::rtl::OUString::createFromAscii( "InteractionHandler" ) ]
451 <<= uno::Reference< task::XInteractionHandler >(
452 m_pOwner->GetServiceFactory()->createInstance(
453 DEFINE_CONST_UNICODE("com.sun.star.task.InteractionHandler") ),
454 uno::UNO_QUERY );
455 }
456 catch( uno::Exception& )
457 {
458 }
459 }
460 else
461 {
462 uno::Reference< task::XInteractionHandler > xInteract;
463 DBG_ASSERT( ( aInteractIter->second >>= xInteract ) && xInteract.is(), "Broken interaction handler is provided!\n" );
464 }
465 }
466
467 //-------------------------------------------------------------------------
GetDocServiceDefaultFilter()468 uno::Sequence< beans::PropertyValue > ModelData_Impl::GetDocServiceDefaultFilter()
469 {
470 uno::Sequence< beans::PropertyValue > aProps;
471
472 ::rtl::OUString aFilterName = GetModuleProps().getUnpackedValueOrDefault(
473 ::rtl::OUString::createFromAscii( "ooSetupFactoryDefaultFilter" ),
474 ::rtl::OUString() );
475
476 m_pOwner->GetFilterConfiguration()->getByName( aFilterName ) >>= aProps;
477
478 return aProps;
479 }
480
481 //-------------------------------------------------------------------------
GetDocServiceDefaultFilterCheckFlags(sal_Int32 nMust,sal_Int32 nDont)482 uno::Sequence< beans::PropertyValue > ModelData_Impl::GetDocServiceDefaultFilterCheckFlags( sal_Int32 nMust,
483 sal_Int32 nDont )
484 {
485 uno::Sequence< beans::PropertyValue > aFilterProps;
486 uno::Sequence< beans::PropertyValue > aProps = GetDocServiceDefaultFilter();
487 if ( aProps.getLength() )
488 {
489 ::comphelper::SequenceAsHashMap aFiltHM( aProps );
490 sal_Int32 nFlags = aFiltHM.getUnpackedValueOrDefault( ::rtl::OUString::createFromAscii( "Flags" ),
491 (sal_Int32)0 );
492 if ( ( ( nFlags & nMust ) == nMust ) && !( nFlags & nDont ) )
493 aFilterProps = aProps;
494 }
495
496 return aFilterProps;
497 }
498
499
500 //-------------------------------------------------------------------------
GetDocServiceAnyFilter(sal_Int32 nMust,sal_Int32 nDont)501 uno::Sequence< beans::PropertyValue > ModelData_Impl::GetDocServiceAnyFilter( sal_Int32 nMust, sal_Int32 nDont )
502 {
503 uno::Sequence< beans::NamedValue > aSearchRequest( 1 );
504 aSearchRequest[0].Name = ::rtl::OUString::createFromAscii( "DocumentService" );
505 aSearchRequest[0].Value <<= GetDocServiceName();
506
507 return ::comphelper::MimeConfigurationHelper::SearchForFilter( m_pOwner->GetFilterQuery(), aSearchRequest, nMust, nDont );
508 }
509
510 //-------------------------------------------------------------------------
GetPreselectedFilter_Impl(sal_Int8 nStoreMode)511 uno::Sequence< beans::PropertyValue > ModelData_Impl::GetPreselectedFilter_Impl( sal_Int8 nStoreMode )
512 {
513 uno::Sequence< beans::PropertyValue > aFilterProps;
514
515 sal_Int32 nMust = getMustFlags( nStoreMode );
516 sal_Int32 nDont = getDontFlags( nStoreMode );
517
518 if ( nStoreMode & PDFEXPORT_REQUESTED )
519 {
520 // Preselect PDF-Filter for EXPORT
521 uno::Sequence< beans::NamedValue > aSearchRequest( 2 );
522 aSearchRequest[0].Name = ::rtl::OUString::createFromAscii( "Type" );
523 aSearchRequest[0].Value <<= ::rtl::OUString::createFromAscii( "pdf_Portable_Document_Format" );
524 aSearchRequest[1].Name = ::rtl::OUString::createFromAscii( "DocumentService" );
525 aSearchRequest[1].Value <<= GetDocServiceName();
526
527 aFilterProps = ::comphelper::MimeConfigurationHelper::SearchForFilter( m_pOwner->GetFilterQuery(), aSearchRequest, nMust, nDont );
528 }
529 else
530 {
531 aFilterProps = GetDocServiceDefaultFilterCheckFlags( nMust, nDont );
532
533 if ( !aFilterProps.getLength() )
534 {
535 // the default filter was not faund, use just the first acceptable one
536 aFilterProps = GetDocServiceAnyFilter( nMust, nDont );
537 }
538 }
539
540 return aFilterProps;
541 }
542
543 //-------------------------------------------------------------------------
ExecuteFilterDialog_Impl(const::rtl::OUString & aFilterName)544 sal_Bool ModelData_Impl::ExecuteFilterDialog_Impl( const ::rtl::OUString& aFilterName )
545 {
546 sal_Bool bDialogUsed = sal_False;
547
548 try {
549 uno::Sequence < beans::PropertyValue > aProps;
550 uno::Any aAny = m_pOwner->GetFilterConfiguration()->getByName( aFilterName );
551 if ( aAny >>= aProps )
552 {
553 sal_Int32 nPropertyCount = aProps.getLength();
554 for( sal_Int32 nProperty=0; nProperty < nPropertyCount; ++nProperty )
555 if( aProps[nProperty].Name.equals( ::rtl::OUString::createFromAscii("UIComponent")) )
556 {
557 ::rtl::OUString aServiceName;
558 aProps[nProperty].Value >>= aServiceName;
559 if( aServiceName.getLength() )
560 {
561 uno::Reference< ui::dialogs::XExecutableDialog > xFilterDialog(
562 m_pOwner->GetServiceFactory()->createInstance( aServiceName ), uno::UNO_QUERY );
563 uno::Reference< beans::XPropertyAccess > xFilterProperties( xFilterDialog, uno::UNO_QUERY );
564
565 if( xFilterDialog.is() && xFilterProperties.is() )
566 {
567 bDialogUsed = sal_True;
568
569 uno::Reference< document::XExporter > xExporter( xFilterDialog, uno::UNO_QUERY );
570 if( xExporter.is() )
571 xExporter->setSourceDocument(
572 uno::Reference< lang::XComponent >( GetModel(), uno::UNO_QUERY ) );
573
574 uno::Sequence< beans::PropertyValue > aPropsForDialog;
575 GetMediaDescr() >> aPropsForDialog;
576 xFilterProperties->setPropertyValues( aPropsForDialog );
577
578 if( xFilterDialog->execute() )
579 {
580 uno::Sequence< beans::PropertyValue > aPropsFromDialog =
581 xFilterProperties->getPropertyValues();
582 for ( sal_Int32 nInd = 0; nInd < aPropsFromDialog.getLength(); nInd++ )
583 GetMediaDescr()[aPropsFromDialog[nInd].Name] = aPropsFromDialog[nInd].Value;
584 }
585 else
586 {
587 throw task::ErrorCodeIOException( ::rtl::OUString(),
588 uno::Reference< uno::XInterface >(),
589 ERRCODE_IO_ABORT );
590 }
591 }
592 }
593
594 break;
595 }
596 }
597 }
598 catch( container::NoSuchElementException& )
599 {
600 // the filter name is unknown
601 throw task::ErrorCodeIOException( ::rtl::OUString(),
602 uno::Reference< uno::XInterface >(),
603 ERRCODE_IO_INVALIDPARAMETER );
604 }
605 catch( task::ErrorCodeIOException& )
606 {
607 throw;
608 }
609 catch( uno::Exception& )
610 {
611 }
612
613 return bDialogUsed;
614 }
615
616 //-------------------------------------------------------------------------
CheckSaveAcceptable(sal_Int8 nCurStatus)617 sal_Int8 ModelData_Impl::CheckSaveAcceptable( sal_Int8 nCurStatus )
618 {
619 sal_Int8 nResult = nCurStatus;
620
621 if ( nResult != STATUS_NO_ACTION && GetStorable()->hasLocation() )
622 {
623 // check whether save is acceptable by the configuration
624 // it is done only for documents that have persistence already
625 uno::Reference< uno::XInterface > xCommonConfig = ::comphelper::ConfigurationHelper::openConfig(
626 m_pOwner->GetServiceFactory(),
627 ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "/org.openoffice.Office.Common" ) ),
628 ::comphelper::ConfigurationHelper::E_STANDARD );
629 if ( !xCommonConfig.is() )
630 throw uno::RuntimeException(); // should the saving proceed as usual instead?
631
632 try
633 {
634 sal_Bool bAlwaysSaveAs = sal_False;
635
636 // the saving is acceptable
637 // in case the configuration entry is not set or set to false
638 // or in case of version creation
639 ::rtl::OUString aVersionCommentString = ::rtl::OUString::createFromAscii( "VersionComment" );
640 if ( ( ::comphelper::ConfigurationHelper::readRelativeKey(
641 xCommonConfig,
642 ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Save/Document/" ) ),
643 ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "AlwaysSaveAs" ) ) ) >>= bAlwaysSaveAs )
644 && bAlwaysSaveAs
645 && GetMediaDescr().find( aVersionCommentString ) == GetMediaDescr().end() )
646 {
647 // notify the user that SaveAs is going to be done
648 String aString( SfxResId( STR_NEW_FILENAME_SAVE ) );
649 Window* pWin = SfxStoringHelper::GetModelWindow( m_xModel );
650 QueryBox aMessageBox( pWin, WB_OK_CANCEL | WB_DEF_OK, aString );
651 if ( aMessageBox.Execute() == RET_OK )
652 nResult = STATUS_SAVEAS;
653 else
654 nResult = STATUS_NO_ACTION;
655 }
656 }
657 catch( uno::Exception& )
658 {
659 // impossibility to get the configuration access means normal saving flow for now
660 }
661 }
662
663 return nResult;
664 }
665
666 //-------------------------------------------------------------------------
CheckStateForSave()667 sal_Int8 ModelData_Impl::CheckStateForSave()
668 {
669 // if the document is readonly or a new one a SaveAs operation must be used
670 if ( !GetStorable()->hasLocation() || GetStorable()->isReadonly() )
671 return STATUS_SAVEAS;
672
673 // check acceptable entries for media descriptor
674 sal_Bool bVersInfoNeedsStore = sal_False;
675 ::comphelper::SequenceAsHashMap aAcceptedArgs;
676
677 ::rtl::OUString aVersionCommentString = ::rtl::OUString::createFromAscii( "VersionComment" );
678 ::rtl::OUString aAuthorString = ::rtl::OUString::createFromAscii( "Author" );
679 ::rtl::OUString aInteractionHandlerString = ::rtl::OUString::createFromAscii( "InteractionHandler" );
680 ::rtl::OUString aStatusIndicatorString = ::rtl::OUString::createFromAscii( "StatusIndicator" );
681 ::rtl::OUString aFailOnWarningString = ::rtl::OUString::createFromAscii( "FailOnWarning" );
682
683 if ( GetMediaDescr().find( aVersionCommentString ) != GetMediaDescr().end() )
684 {
685 bVersInfoNeedsStore = sal_True;
686 aAcceptedArgs[ aVersionCommentString ] = GetMediaDescr()[ aVersionCommentString ];
687 }
688 if ( GetMediaDescr().find( aAuthorString ) != GetMediaDescr().end() )
689 aAcceptedArgs[ aAuthorString ] = GetMediaDescr()[ aAuthorString ];
690 if ( GetMediaDescr().find( aInteractionHandlerString ) != GetMediaDescr().end() )
691 aAcceptedArgs[ aInteractionHandlerString ] = GetMediaDescr()[ aInteractionHandlerString ];
692 if ( GetMediaDescr().find( aStatusIndicatorString ) != GetMediaDescr().end() )
693 aAcceptedArgs[ aStatusIndicatorString ] = GetMediaDescr()[ aStatusIndicatorString ];
694 if ( GetMediaDescr().find( aFailOnWarningString ) != GetMediaDescr().end() )
695 aAcceptedArgs[ aFailOnWarningString ] = GetMediaDescr()[ aFailOnWarningString ];
696
697 // remove unacceptable entry if there is any
698 DBG_ASSERT( GetMediaDescr().size() == aAcceptedArgs.size(),
699 "Unacceptable parameters are provided in Save request!\n" );
700 if ( GetMediaDescr().size() != aAcceptedArgs.size() )
701 GetMediaDescr() = aAcceptedArgs;
702
703 // the document must be modified
704 if ( !GetModifiable()->isModified() && !bVersInfoNeedsStore )
705 return STATUS_NO_ACTION;
706
707 // check that the old filter is acceptable
708 ::rtl::OUString aOldFilterName = GetDocProps().getUnpackedValueOrDefault(
709 aFilterNameString,
710 ::rtl::OUString() );
711 sal_Int8 nResult = CheckFilter( aOldFilterName );
712
713 return nResult;
714 }
715
CheckFilter(const::rtl::OUString & aFilterName)716 sal_Int8 ModelData_Impl::CheckFilter( const ::rtl::OUString& aFilterName )
717 {
718 ::comphelper::SequenceAsHashMap aFiltPropsHM;
719 sal_Int32 nFiltFlags = 0;
720 if ( aFilterName.getLength() )
721 {
722 // get properties of filter
723 uno::Sequence< beans::PropertyValue > aFilterProps;
724 if ( aFilterName.getLength() )
725 m_pOwner->GetFilterConfiguration()->getByName( aFilterName ) >>= aFilterProps;
726
727 aFiltPropsHM = ::comphelper::SequenceAsHashMap( aFilterProps );
728 nFiltFlags = aFiltPropsHM.getUnpackedValueOrDefault( ::rtl::OUString::createFromAscii( "Flags" ), (sal_Int32)0 );
729 }
730
731 // only a temporary solution until default filter retrieving feature is implemented
732 // then GetDocServiceDefaultFilter() must be used
733 ::comphelper::SequenceAsHashMap aDefFiltPropsHM = GetDocServiceDefaultFilterCheckFlags( 3, 0 );
734 sal_Int32 nDefFiltFlags = aDefFiltPropsHM.getUnpackedValueOrDefault( ::rtl::OUString::createFromAscii( "Flags" ), (sal_Int32)0 );
735
736 // if the old filter is not acceptable
737 // and there is no default filter or it is not acceptable for requested parameters then proceed with saveAs
738 if ( ( !aFiltPropsHM.size() || !( nFiltFlags & SFX_FILTER_EXPORT ) )
739 && ( !aDefFiltPropsHM.size() || !( nDefFiltFlags & SFX_FILTER_EXPORT ) || nDefFiltFlags & SFX_FILTER_INTERNAL ) )
740 return STATUS_SAVEAS;
741
742 // so at this point there is either an acceptable old filter or default one
743 if ( !aFiltPropsHM.size() || !( nFiltFlags & SFX_FILTER_EXPORT ) )
744 {
745 // so the default filter must be acceptable
746 return STATUS_SAVEAS_STANDARDNAME;
747 }
748 else if ( ( !( nFiltFlags & SFX_FILTER_OWN ) || ( nFiltFlags & SFX_FILTER_ALIEN ) )
749 && aDefFiltPropsHM.size()
750 && ( nDefFiltFlags & SFX_FILTER_EXPORT ) && !( nDefFiltFlags & SFX_FILTER_INTERNAL ))
751 {
752 // the default filter is acceptable and the old filter is alian one
753 // so ask to make a saveAs operation
754 ::rtl::OUString aUIName = aFiltPropsHM.getUnpackedValueOrDefault( ::rtl::OUString::createFromAscii( "UIName" ),
755 ::rtl::OUString() );
756 ::rtl::OUString aDefUIName = aDefFiltPropsHM.getUnpackedValueOrDefault( ::rtl::OUString::createFromAscii( "UIName" ),
757 ::rtl::OUString() );
758 ::rtl::OUString aPreusedFilterName = GetDocProps().getUnpackedValueOrDefault(
759 ::rtl::OUString::createFromAscii( "PreusedFilterName" ),
760 ::rtl::OUString() );
761 if ( !aPreusedFilterName.equals( aFilterName ) && !aUIName.equals( aDefUIName ) )
762 {
763 if ( !SfxStoringHelper::WarnUnacceptableFormat( GetModel(), aUIName, aDefUIName, sal_True ) )
764 return STATUS_SAVEAS_STANDARDNAME;
765 }
766 }
767
768 return STATUS_SAVE;
769 }
770
771 //-------------------------------------------------------------------------
CheckFilterOptionsDialogExistence()772 sal_Bool ModelData_Impl::CheckFilterOptionsDialogExistence()
773 {
774 uno::Sequence< beans::NamedValue > aSearchRequest( 1 );
775 aSearchRequest[0].Name = ::rtl::OUString::createFromAscii( "DocumentService" );
776 aSearchRequest[0].Value <<= GetDocServiceName();
777
778 uno::Reference< container::XEnumeration > xFilterEnum =
779 m_pOwner->GetFilterQuery()->createSubSetEnumerationByProperties( aSearchRequest );
780
781 while ( xFilterEnum->hasMoreElements() )
782 {
783 uno::Sequence< beans::PropertyValue > pProps;
784 if ( xFilterEnum->nextElement() >>= pProps )
785 {
786 ::comphelper::SequenceAsHashMap aPropsHM( pProps );
787 ::rtl::OUString aUIServName = aPropsHM.getUnpackedValueOrDefault(
788 ::rtl::OUString::createFromAscii( "UIComponent" ),
789 ::rtl::OUString() );
790 if ( aUIServName.getLength() )
791 return sal_True;
792 }
793 }
794
795 return sal_False;
796 }
797
798 //-------------------------------------------------------------------------
OutputFileDialog(sal_Int8 nStoreMode,const::comphelper::SequenceAsHashMap & aPreselectedFilterPropsHM,sal_Bool bSetStandardName,::rtl::OUString & aSuggestedName,sal_Bool bPreselectPassword,const::rtl::OUString & aSuggestedDir,sal_Int16 nDialog,const::rtl::OUString & rStandardDir,const::com::sun::star::uno::Sequence<::rtl::OUString> & rBlackList)799 sal_Bool ModelData_Impl::OutputFileDialog( sal_Int8 nStoreMode,
800 const ::comphelper::SequenceAsHashMap& aPreselectedFilterPropsHM,
801 sal_Bool bSetStandardName,
802 ::rtl::OUString& aSuggestedName,
803 sal_Bool bPreselectPassword,
804 const ::rtl::OUString& aSuggestedDir,
805 sal_Int16 nDialog,
806 const ::rtl::OUString& rStandardDir,
807 const ::com::sun::star::uno::Sequence< ::rtl::OUString >& rBlackList)
808 {
809 sal_Bool bUseFilterOptions = sal_False;
810
811 ::comphelper::SequenceAsHashMap::const_iterator aOverwriteIter =
812 GetMediaDescr().find( ::rtl::OUString::createFromAscii( "Overwrite" ) );
813
814 // the file name must be specified if overwrite option is set
815 if ( aOverwriteIter != GetMediaDescr().end() )
816 throw task::ErrorCodeIOException( ::rtl::OUString(),
817 uno::Reference< uno::XInterface >(),
818 ERRCODE_IO_INVALIDPARAMETER );
819
820 // no target file name is specified
821 // we need to show the file dialog
822
823 // check if we have a filter which allows for filter options, so we need a corresponding checkbox in the dialog
824 sal_Bool bAllowOptions = sal_False;
825
826 // in case of Export, filter options dialog is used if available
827 if( !( nStoreMode & EXPORT_REQUESTED ) || ( nStoreMode & WIDEEXPORT_REQUESTED ) )
828 bAllowOptions = CheckFilterOptionsDialogExistence();
829
830 // get the filename by dialog ...
831 // create the file dialog
832 sal_Int16 aDialogMode = bAllowOptions
833 ? (com::sun::star::ui::dialogs::TemplateDescription::
834 FILESAVE_AUTOEXTENSION_PASSWORD_FILTEROPTIONS)
835 : (com::sun::star::ui::dialogs::TemplateDescription::
836 FILESAVE_AUTOEXTENSION_PASSWORD);
837 sal_Int64 aDialogFlags = 0;
838
839 if( ( nStoreMode & EXPORT_REQUESTED ) && !( nStoreMode & WIDEEXPORT_REQUESTED ) )
840 {
841 if ( nStoreMode & PDFEXPORT_REQUESTED )
842 aDialogMode = com::sun::star::ui::dialogs::TemplateDescription::
843 FILESAVE_AUTOEXTENSION;
844 else
845 aDialogMode = com::sun::star::ui::dialogs::TemplateDescription::
846 FILESAVE_AUTOEXTENSION_SELECTION;
847 aDialogFlags = SFXWB_EXPORT;
848 }
849
850 sfx2::FileDialogHelper* pFileDlg = NULL;
851
852 ::rtl::OUString aDocServiceName = GetDocServiceName();
853 DBG_ASSERT( aDocServiceName.getLength(), "No document service for this module set!" );
854
855 sal_Int32 nMust = getMustFlags( nStoreMode );
856 sal_Int32 nDont = getDontFlags( nStoreMode );
857 sfx2::FileDialogHelper::Context eCtxt = sfx2::FileDialogHelper::UNKNOWN_CONTEXT;
858
859 if ( ( nStoreMode & EXPORT_REQUESTED ) && !( nStoreMode & WIDEEXPORT_REQUESTED ) )
860 {
861 if ( ( nStoreMode & PDFEXPORT_REQUESTED ) && aPreselectedFilterPropsHM.size() )
862 {
863 // this is a PDF export
864 // the filter options has been shown already
865 ::rtl::OUString aFilterUIName = aPreselectedFilterPropsHM.getUnpackedValueOrDefault(
866 ::rtl::OUString::createFromAscii( "UIName" ),
867 ::rtl::OUString() );
868
869 pFileDlg = new sfx2::FileDialogHelper( aDialogMode, aDialogFlags, aFilterUIName, ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "pdf" ) ), rStandardDir, rBlackList );
870 pFileDlg->SetCurrentFilter( aFilterUIName );
871 }
872 else
873 {
874 // This is the normal dialog
875 pFileDlg = new sfx2::FileDialogHelper( aDialogMode, aDialogFlags, aDocServiceName, nDialog, nMust, nDont, rStandardDir, rBlackList );
876 }
877
878 if( aDocServiceName.equalsAscii( "com.sun.star.drawing.DrawingDocument" ) )
879 eCtxt = sfx2::FileDialogHelper::SD_EXPORT;
880 if( aDocServiceName.equalsAscii( "com.sun.star.presentation.PresentationDocument" ) )
881 eCtxt = sfx2::FileDialogHelper::SI_EXPORT;
882 if( aDocServiceName.equalsAscii( "com.sun.star.text.TextDocument" ) )
883 eCtxt = sfx2::FileDialogHelper::SW_EXPORT;
884
885 if ( eCtxt != sfx2::FileDialogHelper::UNKNOWN_CONTEXT )
886 pFileDlg->SetContext( eCtxt );
887
888 pFileDlg->CreateMatcher( aDocServiceName );
889
890 uno::Reference< ui::dialogs::XFilePicker > xFilePicker = pFileDlg->GetFilePicker();
891 uno::Reference< ui::dialogs::XFilePickerControlAccess > xControlAccess =
892 uno::Reference< ui::dialogs::XFilePickerControlAccess >( xFilePicker, uno::UNO_QUERY );
893
894 if ( xControlAccess.is() )
895 {
896 ::rtl::OUString aCtrlText = String( SfxResId( STR_EXPORTBUTTON ) );
897 xControlAccess->setLabel( ui::dialogs::CommonFilePickerElementIds::PUSHBUTTON_OK, aCtrlText );
898
899 aCtrlText = ::rtl::OUString( String( SfxResId( STR_LABEL_FILEFORMAT ) ) );
900 xControlAccess->setLabel( ui::dialogs::CommonFilePickerElementIds::LISTBOX_FILTER_LABEL, aCtrlText );
901 }
902 }
903 else
904 {
905 // This is the normal dialog
906 pFileDlg = new sfx2::FileDialogHelper( aDialogMode, aDialogFlags, aDocServiceName, nDialog, nMust, nDont, rStandardDir, rBlackList );
907 pFileDlg->CreateMatcher( aDocServiceName );
908 }
909
910 ::rtl::OUString aAdjustToType;
911
912 if ( ( nStoreMode & EXPORT_REQUESTED ) && !( nStoreMode & WIDEEXPORT_REQUESTED ) )
913 {
914 // it is export, set the preselected filter
915 ::rtl::OUString aFilterUIName = aPreselectedFilterPropsHM.getUnpackedValueOrDefault(
916 ::rtl::OUString::createFromAscii( "UIName" ),
917 ::rtl::OUString() );
918 pFileDlg->SetCurrentFilter( aFilterUIName );
919 }
920 // it is no export, bSetStandardName == true means that user agreed to store document in the default (default default ;-)) format
921 else if ( bSetStandardName || GetStorable()->hasLocation() )
922 {
923 uno::Sequence< beans::PropertyValue > aOldFilterProps;
924 ::rtl::OUString aOldFilterName = GetDocProps().getUnpackedValueOrDefault(
925 aFilterNameString,
926 ::rtl::OUString() );
927
928 if ( aOldFilterName.getLength() )
929 m_pOwner->GetFilterConfiguration()->getByName( aOldFilterName ) >>= aOldFilterProps;
930
931 ::comphelper::SequenceAsHashMap aOldFiltPropsHM( aOldFilterProps );
932 sal_Int32 nOldFiltFlags = aOldFiltPropsHM.getUnpackedValueOrDefault( ::rtl::OUString::createFromAscii( "Flags" ), (sal_Int32)0 );
933
934 if ( bSetStandardName || ( nOldFiltFlags & nMust ) != nMust || nOldFiltFlags & nDont )
935 {
936 // the suggested type will be changed, the extension should be adjusted
937 aAdjustToType = aPreselectedFilterPropsHM.getUnpackedValueOrDefault(
938 ::rtl::OUString::createFromAscii( "Type" ),
939 ::rtl::OUString() );
940
941 ::rtl::OUString aFilterUIName = aPreselectedFilterPropsHM.getUnpackedValueOrDefault(
942 ::rtl::OUString::createFromAscii( "UIName" ),
943 ::rtl::OUString() );
944 pFileDlg->SetCurrentFilter( aFilterUIName );
945 }
946 else
947 {
948 pFileDlg->SetCurrentFilter( aOldFiltPropsHM.getUnpackedValueOrDefault(
949 ::rtl::OUString::createFromAscii( "UIName" ),
950 ::rtl::OUString() ) );
951 }
952 }
953
954 ::rtl::OUString aReccomendedDir = GetReccomendedDir( aSuggestedDir, eCtxt );
955 if ( aReccomendedDir.getLength() )
956 pFileDlg->SetDisplayDirectory( aReccomendedDir );
957 ::rtl::OUString aReccomendedName = GetReccomendedName( aSuggestedName, aAdjustToType );
958 if ( aReccomendedName.getLength() )
959 pFileDlg->SetFileName( aReccomendedName );
960
961 uno::Reference < view::XSelectionSupplier > xSel( GetModel()->getCurrentController(), uno::UNO_QUERY );
962 if ( xSel.is() && xSel->getSelection().hasValue() )
963 GetMediaDescr()[::rtl::OUString::createFromAscii( "SelectionOnly" )] <<= sal_True;
964
965 // This is a temporary hardcoded solution must be removed when
966 // dialogs do not need parameters in SidSet representation any more
967 sal_uInt16 nSlotID = getSlotIDFromMode( nStoreMode );
968 if ( !nSlotID )
969 throw lang::IllegalArgumentException(); // TODO:
970
971 // generate SidSet from MediaDescriptor and provide it into FileDialog
972 // than merge changed SidSet back
973 SfxAllItemSet aDialogParams( SFX_APP()->GetPool() );
974 SfxItemSet* pDialogParams = &aDialogParams;
975 TransformParameters( nSlotID,
976 GetMediaDescr().getAsConstPropertyValueList(),
977 aDialogParams,
978 NULL );
979
980 const SfxPoolItem* pItem = NULL;
981 if ( bPreselectPassword && aDialogParams.GetItemState( SID_ENCRYPTIONDATA, sal_True, &pItem ) != SFX_ITEM_SET )
982 {
983 // the file dialog preselects the password checkbox if the provided mediadescriptor has encryption data entry
984 // after dialog execution the password interaction flag will be either removed or not
985 aDialogParams.Put( SfxBoolItem( SID_PASSWORDINTERACTION, sal_True ) );
986 }
987
988 // aStringTypeFN is a pure output parameter, pDialogParams is an in/out parameter
989 String aStringTypeFN;
990 if ( pFileDlg->Execute( pDialogParams, aStringTypeFN ) != ERRCODE_NONE )
991 {
992 delete pFileDlg;
993 throw task::ErrorCodeIOException( ::rtl::OUString(), uno::Reference< uno::XInterface >(), ERRCODE_IO_ABORT );
994 }
995
996 ::rtl::OUString aFilterName = aStringTypeFN;
997
998 // the following two arguments can not be converted in MediaDescriptor,
999 // so they should be removed from the ItemSet after retrieving
1000 SFX_ITEMSET_ARG( pDialogParams, pRecommendReadOnly, SfxBoolItem, SID_RECOMMENDREADONLY, sal_False );
1001 m_bRecommendReadOnly = ( pRecommendReadOnly && pRecommendReadOnly->GetValue() );
1002 pDialogParams->ClearItem( SID_RECOMMENDREADONLY );
1003
1004 uno::Sequence< beans::PropertyValue > aPropsFromDialog;
1005 TransformItems( nSlotID, *pDialogParams, aPropsFromDialog, NULL );
1006 GetMediaDescr() << aPropsFromDialog;
1007
1008 // get the path from the dialog
1009 INetURLObject aURL( pFileDlg->GetPath() );
1010 // the path should be provided outside since it might be used for further calls to the dialog
1011 aSuggestedName = aURL.GetName( INetURLObject::DECODE_WITH_CHARSET );
1012
1013 // old filter options should be cleared in case different filter is used
1014
1015 ::rtl::OUString aFilterFromMediaDescr = GetMediaDescr().getUnpackedValueOrDefault(
1016 aFilterNameString,
1017 ::rtl::OUString() );
1018 ::rtl::OUString aOldFilterName = GetDocProps().getUnpackedValueOrDefault(
1019 aFilterNameString,
1020 ::rtl::OUString() );
1021 if ( aFilterName.equals( aFilterFromMediaDescr ) )
1022 {
1023 // preserv current settings if any
1024 // if there no current settings and the name is the same
1025 // as old filter name use old filter settings
1026
1027 if ( aFilterFromMediaDescr.equals( aOldFilterName ) )
1028 {
1029 ::comphelper::SequenceAsHashMap::const_iterator aIter =
1030 GetDocProps().find( aFilterOptionsString );
1031 if ( aIter != GetDocProps().end()
1032 && GetMediaDescr().find( aFilterOptionsString ) == GetMediaDescr().end() )
1033 GetMediaDescr()[aIter->first] = aIter->second;
1034
1035 aIter = GetDocProps().find( aFilterDataString );
1036 if ( aIter != GetDocProps().end()
1037 && GetMediaDescr().find( aFilterDataString ) == GetMediaDescr().end() )
1038 GetMediaDescr()[aIter->first] = aIter->second;
1039 }
1040 }
1041 else
1042 {
1043 GetMediaDescr().erase( aFilterDataString );
1044 GetMediaDescr().erase( aFilterOptionsString );
1045
1046 if ( aFilterName.equals( aOldFilterName ) )
1047 {
1048 // merge filter option of the document filter
1049
1050 ::comphelper::SequenceAsHashMap::const_iterator aIter =
1051 GetDocProps().find( aFilterOptionsString );
1052 if ( aIter != GetDocProps().end() )
1053 GetMediaDescr()[aIter->first] = aIter->second;
1054
1055 aIter = GetDocProps().find( aFilterDataString );
1056 if ( aIter != GetDocProps().end() )
1057 GetMediaDescr()[aIter->first] = aIter->second;
1058 }
1059 }
1060
1061 uno::Reference< ui::dialogs::XFilePickerControlAccess > xExtFileDlg( pFileDlg->GetFilePicker(), uno::UNO_QUERY );
1062 if ( xExtFileDlg.is() )
1063 {
1064 if ( SfxStoringHelper::CheckFilterOptionsAppearence( m_pOwner->GetFilterConfiguration(), aFilterName ) )
1065 bUseFilterOptions = sal_True;
1066
1067 if ( ( !( nStoreMode & EXPORT_REQUESTED ) || ( nStoreMode & WIDEEXPORT_REQUESTED ) ) && bUseFilterOptions )
1068 {
1069 try
1070 {
1071 // for exporters: always show dialog if format uses options
1072 // for save: show dialog if format uses options and no options given or if forced by user
1073 uno::Any aVal =
1074 xExtFileDlg->getValue( ui::dialogs::ExtendedFilePickerElementIds::CHECKBOX_FILTEROPTIONS, 0 );
1075
1076 aVal >>= bUseFilterOptions;
1077 if ( !bUseFilterOptions )
1078 bUseFilterOptions =
1079 ( GetMediaDescr().find( aFilterDataString ) == GetMediaDescr().end()
1080 && GetMediaDescr().find( aFilterOptionsString ) == GetMediaDescr().end() );
1081 }
1082 catch( lang::IllegalArgumentException& )
1083 {}
1084 }
1085 }
1086
1087 delete pFileDlg;
1088
1089 // merge in results of the dialog execution
1090 GetMediaDescr()[::rtl::OUString::createFromAscii( "URL" )] <<=
1091 ::rtl::OUString( aURL.GetMainURL( INetURLObject::NO_DECODE ));
1092 GetMediaDescr()[aFilterNameString] <<= aFilterName;
1093
1094 return bUseFilterOptions;
1095 }
1096
1097 //-------------------------------------------------------------------------
ShowDocumentInfoDialog()1098 sal_Bool ModelData_Impl::ShowDocumentInfoDialog()
1099 {
1100 sal_Bool bDialogUsed = sal_False;
1101
1102 try {
1103 uno::Reference< frame::XController > xController = GetModel()->getCurrentController();
1104 if ( xController.is() )
1105 {
1106 uno::Reference< frame::XDispatchProvider > xFrameDispatch( xController->getFrame(), uno::UNO_QUERY );
1107 if ( xFrameDispatch.is() )
1108 {
1109 util::URL aURL;
1110 aURL.Complete = ::rtl::OUString::createFromAscii( ".uno:SetDocumentProperties" );
1111
1112 uno::Reference< util::XURLTransformer > xTransformer(
1113 m_pOwner->GetServiceFactory()->createInstance(
1114 DEFINE_CONST_UNICODE("com.sun.star.util.URLTransformer") ),
1115 uno::UNO_QUERY );
1116 if ( xTransformer.is() && xTransformer->parseStrict( aURL ) )
1117 {
1118 uno::Reference< frame::XDispatch > xDispatch = xFrameDispatch->queryDispatch(
1119 aURL,
1120 ::rtl::OUString::createFromAscii( "_self" ),
1121 0 );
1122 if ( xDispatch.is() )
1123 {
1124 xDispatch->dispatch( aURL, uno::Sequence< beans::PropertyValue >() );
1125 bDialogUsed = sal_True;
1126 }
1127 }
1128 }
1129 }
1130 }
1131 catch ( uno::Exception& )
1132 {
1133 }
1134
1135 return bDialogUsed;
1136 }
1137
1138 //-------------------------------------------------------------------------
GetReccomendedDir(const::rtl::OUString & aSuggestedDir,const sfx2::FileDialogHelper::Context & aCtxt)1139 ::rtl::OUString ModelData_Impl::GetReccomendedDir( const ::rtl::OUString& aSuggestedDir, const sfx2::FileDialogHelper::Context& aCtxt )
1140 {
1141 ::rtl::OUString aReccomendedDir;
1142
1143 if ( ( aSuggestedDir.getLength() || GetStorable()->hasLocation() )
1144 && !GetMediaDescr().getUnpackedValueOrDefault( ::rtl::OUString::createFromAscii( "RepairPackage" ),
1145 sal_False ) )
1146 {
1147 INetURLObject aLocation;
1148 if ( aSuggestedDir.getLength() )
1149 aLocation = INetURLObject( aSuggestedDir );
1150 else
1151 {
1152 ::rtl::OUString aOldURL = GetStorable()->getLocation();
1153 if ( aOldURL.getLength() )
1154 {
1155 INetURLObject aTmp( aOldURL );
1156 if ( aTmp.removeSegment() )
1157 aLocation = aTmp;
1158 }
1159
1160 if ( aLocation.HasError() )
1161 aLocation = INetURLObject( SvtPathOptions().GetWorkPath() );
1162 }
1163
1164 aLocation.setFinalSlash();
1165 if ( !aLocation.HasError() )
1166 aReccomendedDir = aLocation.GetMainURL( INetURLObject::NO_DECODE );
1167 }
1168 else
1169 {
1170 // pb: set graphic path if context == SD_EXPORT or SI_EXPORT else work path
1171 ::rtl::OUString aConfigSuggestion( ( aCtxt != sfx2::FileDialogHelper::UNKNOWN_CONTEXT ) ? SvtPathOptions().GetGraphicPath() : SvtPathOptions().GetWorkPath() );
1172 aReccomendedDir = INetURLObject( aConfigSuggestion ).GetMainURL( INetURLObject::NO_DECODE );
1173 }
1174
1175 return aReccomendedDir;
1176 }
1177
1178 //-------------------------------------------------------------------------
GetReccomendedName(const::rtl::OUString & aSuggestedName,const::rtl::OUString & aTypeName)1179 ::rtl::OUString ModelData_Impl::GetReccomendedName( const ::rtl::OUString& aSuggestedName, const ::rtl::OUString& aTypeName )
1180 {
1181 // the last used name might be provided by aSuggestedName from the old selection, or from the MediaDescriptor
1182 ::rtl::OUString aReccomendedName;
1183
1184 if ( aSuggestedName.getLength() )
1185 aReccomendedName = aSuggestedName;
1186 else
1187 {
1188 aReccomendedName = INetURLObject( GetStorable()->getLocation() ).GetName( INetURLObject::DECODE_WITH_CHARSET );
1189 if ( !aReccomendedName.getLength() )
1190 {
1191 try {
1192 uno::Reference< frame::XTitle > xTitle( GetModel(), uno::UNO_QUERY_THROW );
1193 aReccomendedName = xTitle->getTitle();
1194 } catch( uno::Exception& ) {}
1195 }
1196
1197 if ( aReccomendedName.getLength() && aTypeName.getLength() )
1198 {
1199 // adjust the extension to the type
1200 uno::Reference< container::XNameAccess > xTypeDetection = uno::Reference< container::XNameAccess >(
1201 m_pOwner->GetServiceFactory()->createInstance( ::rtl::OUString::createFromAscii( "com.sun.star.document.TypeDetection" ) ),
1202 uno::UNO_QUERY );
1203 if ( xTypeDetection.is() )
1204 {
1205 INetURLObject aObj( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "file:///c:/" ) ) + aReccomendedName );
1206
1207 uno::Sequence< beans::PropertyValue > aTypeNameProps;
1208 if ( ( xTypeDetection->getByName( aTypeName ) >>= aTypeNameProps ) && aTypeNameProps.getLength() )
1209 {
1210 ::comphelper::SequenceAsHashMap aTypeNamePropsHM( aTypeNameProps );
1211 uno::Sequence< ::rtl::OUString > aExtensions = aTypeNamePropsHM.getUnpackedValueOrDefault(
1212 ::rtl::OUString::createFromAscii( "Extensions" ),
1213 ::uno::Sequence< ::rtl::OUString >() );
1214 if ( aExtensions.getLength() )
1215 aObj.SetExtension( aExtensions[0] );
1216 }
1217
1218 aReccomendedName = aObj.GetName( INetURLObject::DECODE_WITH_CHARSET );
1219 }
1220 }
1221 }
1222
1223 return aReccomendedName;
1224 }
1225
1226
1227 //=========================================================================
1228 // class SfxStoringHelper
1229 //=========================================================================
1230 //-------------------------------------------------------------------------
SfxStoringHelper(const uno::Reference<lang::XMultiServiceFactory> & xFactory)1231 SfxStoringHelper::SfxStoringHelper( const uno::Reference< lang::XMultiServiceFactory >& xFactory )
1232 : m_xFactory( xFactory )
1233 {
1234 }
1235
1236 //-------------------------------------------------------------------------
GetServiceFactory()1237 uno::Reference< lang::XMultiServiceFactory > SfxStoringHelper::GetServiceFactory()
1238 {
1239 if ( !m_xFactory.is() )
1240 {
1241 m_xFactory = ::comphelper::getProcessServiceFactory();
1242 if( !m_xFactory.is() )
1243 throw uno::RuntimeException(); // TODO:
1244 }
1245
1246 return m_xFactory;
1247 }
1248
1249 //-------------------------------------------------------------------------
GetFilterConfiguration()1250 uno::Reference< container::XNameAccess > SfxStoringHelper::GetFilterConfiguration()
1251 {
1252 if ( !m_xFilterCFG.is() )
1253 {
1254 m_xFilterCFG = uno::Reference< container::XNameAccess >(
1255 GetServiceFactory()->createInstance( ::rtl::OUString::createFromAscii( "com.sun.star.document.FilterFactory" ) ),
1256 uno::UNO_QUERY );
1257
1258 if ( !m_xFilterCFG.is() )
1259 throw uno::RuntimeException();
1260 }
1261
1262 return m_xFilterCFG;
1263 }
1264
1265 //-------------------------------------------------------------------------
GetFilterQuery()1266 uno::Reference< container::XContainerQuery > SfxStoringHelper::GetFilterQuery()
1267 {
1268 if ( !m_xFilterQuery.is() )
1269 {
1270 m_xFilterQuery = uno::Reference< container::XContainerQuery >( GetFilterConfiguration(), uno::UNO_QUERY );
1271 if ( !m_xFilterQuery.is() )
1272 throw uno::RuntimeException();
1273 }
1274
1275 return m_xFilterQuery;
1276 }
1277
1278 //-------------------------------------------------------------------------
GetModuleManager()1279 uno::Reference< ::com::sun::star::frame::XModuleManager > SfxStoringHelper::GetModuleManager()
1280 {
1281 if ( !m_xModuleManager.is() )
1282 {
1283 m_xModuleManager = uno::Reference< ::com::sun::star::frame::XModuleManager >(
1284 GetServiceFactory()->createInstance(
1285 ::rtl::OUString::createFromAscii( "com.sun.star.frame.ModuleManager" ) ),
1286 uno::UNO_QUERY );
1287
1288 if ( !m_xModuleManager.is() )
1289 throw uno::RuntimeException();
1290 }
1291
1292 return m_xModuleManager;
1293 }
1294
1295 //-------------------------------------------------------------------------
GetNamedModuleManager()1296 uno::Reference< container::XNameAccess > SfxStoringHelper::GetNamedModuleManager()
1297 {
1298 if ( !m_xNamedModManager.is() )
1299 {
1300 m_xNamedModManager = uno::Reference< container::XNameAccess >( GetModuleManager(), uno::UNO_QUERY );
1301 if ( !m_xNamedModManager.is() )
1302 throw uno::RuntimeException();
1303 }
1304
1305 return m_xNamedModManager;
1306 }
1307
1308 //-------------------------------------------------------------------------
GUIStoreModel(const uno::Reference<frame::XModel> & xModel,const::rtl::OUString & aSlotName,uno::Sequence<beans::PropertyValue> & aArgsSequence,sal_Bool bPreselectPassword,::rtl::OUString aSuggestedName,sal_uInt16 nDocumentSignatureState)1309 sal_Bool SfxStoringHelper::GUIStoreModel( const uno::Reference< frame::XModel >& xModel,
1310 const ::rtl::OUString& aSlotName,
1311 uno::Sequence< beans::PropertyValue >& aArgsSequence,
1312 sal_Bool bPreselectPassword,
1313 ::rtl::OUString aSuggestedName,
1314 sal_uInt16 nDocumentSignatureState )
1315 {
1316 ModelData_Impl aModelData( *this, xModel, aArgsSequence );
1317
1318 sal_Bool bDialogUsed = sal_False;
1319
1320 INetURLObject aURL;
1321
1322 sal_Bool bSetStandardName = sal_False; // can be set only for SaveAs
1323
1324 // parse the slot name
1325 sal_Int8 nStoreMode = getStoreModeFromSlotName( aSlotName );
1326 sal_Int8 nStatusSave = STATUS_NO_ACTION;
1327
1328 // handle the special cases
1329 if ( nStoreMode & SAVEAS_REQUESTED )
1330 {
1331 ::comphelper::SequenceAsHashMap::const_iterator aSaveToIter =
1332 aModelData.GetMediaDescr().find( ::rtl::OUString::createFromAscii( "SaveTo" ) );
1333 if ( aSaveToIter != aModelData.GetMediaDescr().end() )
1334 {
1335 sal_Bool bWideExport = sal_False;
1336 aSaveToIter->second >>= bWideExport;
1337 if ( bWideExport )
1338 nStoreMode = EXPORT_REQUESTED | WIDEEXPORT_REQUESTED;
1339 }
1340
1341 // if saving is not acceptable the warning must be shown even in case of SaveAs operation
1342 if ( ( nStoreMode & SAVEAS_REQUESTED ) && aModelData.CheckSaveAcceptable( STATUS_SAVEAS ) == STATUS_NO_ACTION )
1343 throw task::ErrorCodeIOException( ::rtl::OUString(), uno::Reference< uno::XInterface >(), ERRCODE_IO_ABORT );
1344 }
1345 else if ( nStoreMode & SAVE_REQUESTED )
1346 {
1347 // if saving is not acceptable by the configuration the warning must be shown
1348 nStatusSave = aModelData.CheckSaveAcceptable( STATUS_SAVE );
1349
1350 if ( nStatusSave == STATUS_NO_ACTION )
1351 throw task::ErrorCodeIOException( ::rtl::OUString(), uno::Reference< uno::XInterface >(), ERRCODE_IO_ABORT );
1352 else if ( nStatusSave == STATUS_SAVE )
1353 {
1354 // check whether it is possible to use save operation
1355 nStatusSave = aModelData.CheckStateForSave();
1356 }
1357
1358 if ( nStatusSave == STATUS_NO_ACTION )
1359 {
1360 throw task::ErrorCodeIOException( ::rtl::OUString(), uno::Reference< uno::XInterface >(), ERRCODE_IO_ABORT );
1361 }
1362 else if ( nStatusSave != STATUS_SAVE )
1363 {
1364 // this should be a usual SaveAs operation
1365 nStoreMode = SAVEAS_REQUESTED;
1366 if ( nStatusSave == STATUS_SAVEAS_STANDARDNAME )
1367 bSetStandardName = sal_True;
1368 }
1369 }
1370
1371 if ( !( nStoreMode & EXPORT_REQUESTED ) )
1372 {
1373 // if it is no export, warn user that the signature will be removed
1374 if ( SIGNATURESTATE_SIGNATURES_OK == nDocumentSignatureState
1375 || SIGNATURESTATE_SIGNATURES_INVALID == nDocumentSignatureState
1376 || SIGNATURESTATE_SIGNATURES_NOTVALIDATED == nDocumentSignatureState
1377 || SIGNATURESTATE_SIGNATURES_PARTIAL_OK == nDocumentSignatureState)
1378 {
1379 if ( QueryBox( NULL, SfxResId( RID_XMLSEC_QUERY_LOSINGSIGNATURE ) ).Execute() != RET_YES )
1380 {
1381 // the user has decided not to store the document
1382 throw task::ErrorCodeIOException( ::rtl::OUString(),
1383 uno::Reference< uno::XInterface >(),
1384 ERRCODE_IO_ABORT );
1385 }
1386 }
1387 }
1388
1389 if ( nStoreMode & SAVE_REQUESTED && nStatusSave == STATUS_SAVE )
1390 {
1391 // Document properties can contain streams that should be freed before storing
1392 aModelData.FreeDocumentProps();
1393
1394 if ( aModelData.GetStorable2().is() )
1395 {
1396 try
1397 {
1398 aModelData.GetStorable2()->storeSelf( aModelData.GetMediaDescr().getAsConstPropertyValueList() );
1399 }
1400 catch( lang::IllegalArgumentException& )
1401 {
1402 OSL_ENSURE( sal_False, "ModelData didn't handle illegal parameters, all the parameters are ignored!\n" );
1403 aModelData.GetStorable()->store();
1404 }
1405 }
1406 else
1407 {
1408 OSL_ENSURE( sal_False, "XStorable2 is not supported by the model!\n" );
1409 aModelData.GetStorable()->store();
1410 }
1411
1412 return sal_False;
1413 }
1414
1415 // preselect a filter for the storing process
1416 uno::Sequence< beans::PropertyValue > aFilterProps = aModelData.GetPreselectedFilter_Impl( nStoreMode );
1417
1418 DBG_ASSERT( aFilterProps.getLength(), "No filter for storing!\n" );
1419 if ( !aFilterProps.getLength() )
1420 throw task::ErrorCodeIOException( ::rtl::OUString(),
1421 uno::Reference< uno::XInterface >(),
1422 ERRCODE_IO_INVALIDPARAMETER );
1423
1424 ::comphelper::SequenceAsHashMap aFilterPropsHM( aFilterProps );
1425 ::rtl::OUString aFilterName = aFilterPropsHM.getUnpackedValueOrDefault(
1426 ::rtl::OUString::createFromAscii( "Name" ),
1427 ::rtl::OUString() );
1428
1429 ::rtl::OUString aFilterFromMediaDescr = aModelData.GetMediaDescr().getUnpackedValueOrDefault(
1430 aFilterNameString,
1431 ::rtl::OUString() );
1432 ::rtl::OUString aOldFilterName = aModelData.GetDocProps().getUnpackedValueOrDefault(
1433 aFilterNameString,
1434 ::rtl::OUString() );
1435
1436 sal_Bool bUseFilterOptions = sal_False;
1437 ::comphelper::SequenceAsHashMap::const_iterator aFileNameIter = aModelData.GetMediaDescr().find( ::rtl::OUString::createFromAscii( "URL" ) );
1438
1439 if ( ( nStoreMode & EXPORT_REQUESTED ) && ( nStoreMode & PDFEXPORT_REQUESTED ) && !( nStoreMode & PDFDIRECTEXPORT_REQUESTED ) )
1440 {
1441 // this is PDF export, the filter options dialog should be shown before the export
1442 aModelData.GetMediaDescr()[aFilterNameString] <<= aFilterName;
1443 if ( aModelData.GetMediaDescr().find( aFilterFlagsString ) == aModelData.GetMediaDescr().end()
1444 && aModelData.GetMediaDescr().find( aFilterOptionsString ) == aModelData.GetMediaDescr().end()
1445 && aModelData.GetMediaDescr().find( aFilterDataString ) == aModelData.GetMediaDescr().end() )
1446 {
1447 // execute filter options dialog since no options are set in the media descriptor
1448 if ( aModelData.ExecuteFilterDialog_Impl( aFilterName ) )
1449 bDialogUsed = sal_True;
1450 }
1451 }
1452
1453 if ( aFileNameIter == aModelData.GetMediaDescr().end() )
1454 {
1455 sal_Int16 nDialog = SFX2_IMPL_DIALOG_CONFIG;
1456 ::comphelper::SequenceAsHashMap::const_iterator aDlgIter =
1457 aModelData.GetMediaDescr().find( ::rtl::OUString::createFromAscii( "UseSystemDialog" ) );
1458 if ( aDlgIter != aModelData.GetMediaDescr().end() )
1459 {
1460 sal_Bool bUseSystemDialog = sal_True;
1461 if ( aDlgIter->second >>= bUseSystemDialog )
1462 {
1463 if ( bUseSystemDialog )
1464 nDialog = SFX2_IMPL_DIALOG_SYSTEM;
1465 else
1466 nDialog = SFX2_IMPL_DIALOG_OOO;
1467 }
1468 }
1469
1470 // The Dispatch supports parameter FolderName that overwrites SuggestedSaveAsDir
1471 ::rtl::OUString aSuggestedDir = aModelData.GetMediaDescr().getUnpackedValueOrDefault( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "FolderName" ) ), ::rtl::OUString() );
1472 if ( !aSuggestedDir.getLength() )
1473 {
1474 aSuggestedDir = aModelData.GetMediaDescr().getUnpackedValueOrDefault( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "SuggestedSaveAsDir" ) ), ::rtl::OUString() );
1475 if ( !aSuggestedDir.getLength() )
1476 aSuggestedDir = aModelData.GetDocProps().getUnpackedValueOrDefault( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "SuggestedSaveAsDir" ) ), ::rtl::OUString() );
1477 }
1478
1479 aSuggestedName = aModelData.GetMediaDescr().getUnpackedValueOrDefault( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "SuggestedSaveAsName" ) ), ::rtl::OUString() );
1480 if ( !aSuggestedName.getLength() )
1481 aSuggestedName = aModelData.GetDocProps().getUnpackedValueOrDefault( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "SuggestedSaveAsName" ) ), ::rtl::OUString() );
1482
1483 ::rtl::OUString sStandardDir;
1484 ::comphelper::SequenceAsHashMap::const_iterator aStdDirIter =
1485 aModelData.GetMediaDescr().find( ::rtl::OUString::createFromAscii( "StandardDir" ) );
1486 if ( aStdDirIter != aModelData.GetMediaDescr().end() )
1487 aStdDirIter->second >>= sStandardDir;
1488
1489 ::com::sun::star::uno::Sequence< ::rtl::OUString > aBlackList;
1490
1491 ::comphelper::SequenceAsHashMap::const_iterator aBlackListIter =
1492 aModelData.GetMediaDescr().find( ::rtl::OUString::createFromAscii( "BlackList" ) );
1493 if ( aBlackListIter != aModelData.GetMediaDescr().end() )
1494 aBlackListIter->second >>= aBlackList;
1495
1496 sal_Bool bExit = sal_False;
1497 while ( !bExit )
1498 {
1499 bUseFilterOptions = aModelData.OutputFileDialog( nStoreMode, aFilterProps, bSetStandardName, aSuggestedName, bPreselectPassword, aSuggestedDir, nDialog, sStandardDir, aBlackList );
1500
1501 // in case the dialog is opend a second time the folder should be the same as before, not what was handed over by parameters
1502 aSuggestedDir = ::rtl::OUString();
1503 if ( nStoreMode == SAVEAS_REQUESTED )
1504 {
1505 // in case of saving check filter for possible alien warning
1506 ::rtl::OUString aSelFilterName = aModelData.GetMediaDescr().getUnpackedValueOrDefault(
1507 aFilterNameString,
1508 ::rtl::OUString() );
1509 sal_Int8 nStatusFilterSave = aModelData.CheckFilter( aSelFilterName );
1510 if ( nStatusFilterSave == STATUS_SAVEAS_STANDARDNAME )
1511 {
1512 // switch to best filter
1513 bSetStandardName = sal_True;
1514 }
1515 else if ( nStatusFilterSave == STATUS_SAVE )
1516 {
1517 // user confirmed alien filter or "good" filter is used
1518 bExit = sal_True;
1519 }
1520 }
1521 else
1522 bExit = sal_True;
1523 }
1524
1525 bDialogUsed = sal_True;
1526 aFileNameIter = aModelData.GetMediaDescr().find( ::rtl::OUString::createFromAscii( "URL" ) );
1527 }
1528 else
1529 {
1530 // the target file name is provided so check if new filter options
1531 // are provided or old options can be used
1532 if ( aFilterFromMediaDescr.equals( aOldFilterName ) )
1533 {
1534 ::comphelper::SequenceAsHashMap::const_iterator aIter =
1535 aModelData.GetDocProps().find( aFilterOptionsString );
1536 if ( aIter != aModelData.GetDocProps().end()
1537 && aModelData.GetMediaDescr().find( aFilterOptionsString ) == aModelData.GetMediaDescr().end() )
1538 aModelData.GetMediaDescr()[aIter->first] = aIter->second;
1539
1540 aIter = aModelData.GetDocProps().find( aFilterDataString );
1541 if ( aIter != aModelData.GetDocProps().end()
1542 && aModelData.GetMediaDescr().find( aFilterDataString ) == aModelData.GetMediaDescr().end() )
1543 aModelData.GetMediaDescr()[aIter->first] = aIter->second;
1544 }
1545 }
1546
1547 if ( aFileNameIter != aModelData.GetMediaDescr().end() )
1548 {
1549 ::rtl::OUString aFileName;
1550 aFileNameIter->second >>= aFileName;
1551 aURL.SetURL( aFileName );
1552 DBG_ASSERT( aURL.GetProtocol() != INET_PROT_NOT_VALID, "Illegal URL!" );
1553
1554 ::comphelper::SequenceAsHashMap::const_iterator aIter =
1555 aModelData.GetMediaDescr().find( aFilterNameString );
1556
1557 if ( aIter != aModelData.GetMediaDescr().end() )
1558 aIter->second >>= aFilterName;
1559 else
1560 aModelData.GetMediaDescr()[aFilterNameString] <<= aFilterName;
1561
1562 DBG_ASSERT( aFilterName.getLength(), "Illegal filter!" );
1563 }
1564 else
1565 {
1566 DBG_ASSERT( sal_False, "This code must be unreachable!\n" );
1567 throw task::ErrorCodeIOException( ::rtl::OUString(),
1568 uno::Reference< uno::XInterface >(),
1569 ERRCODE_IO_INVALIDPARAMETER );
1570 }
1571
1572 ::comphelper::SequenceAsHashMap::const_iterator aIter =
1573 aModelData.GetMediaDescr().find( ::rtl::OUString::createFromAscii( "FilterFlags" ) );
1574 sal_Bool bFilterFlagsSet = ( aIter != aModelData.GetMediaDescr().end() );
1575
1576 if( !( nStoreMode & PDFEXPORT_REQUESTED ) && !bFilterFlagsSet
1577 && ( ( nStoreMode & EXPORT_REQUESTED ) || bUseFilterOptions ) )
1578 {
1579 // execute filter options dialog
1580 if ( aModelData.ExecuteFilterDialog_Impl( aFilterName ) )
1581 bDialogUsed = sal_True;
1582 }
1583
1584 // so the arguments will not change any more and can be stored to the main location
1585 aArgsSequence = aModelData.GetMediaDescr().getAsConstPropertyValueList();
1586
1587 // store the document and handle it's docinfo
1588 SvtSaveOptions aOptions;
1589
1590 DocumentSettingsGuard aSettingsGuard( aModelData.GetModel(), aModelData.IsRecommendReadOnly(), nStoreMode & EXPORT_REQUESTED );
1591
1592 OSL_ENSURE( aModelData.GetMediaDescr().find( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Password" ) ) ) == aModelData.GetMediaDescr().end(), "The Password property of MediaDescriptor should not be used here!" );
1593 if ( aOptions.IsDocInfoSave()
1594 && ( !aModelData.GetStorable()->hasLocation()
1595 || INetURLObject( aModelData.GetStorable()->getLocation() ) != aURL ) )
1596 {
1597 // this is defenitly not a Save operation
1598 // so the document info can be updated
1599
1600 // on export document info must be preserved
1601 uno::Reference<document::XDocumentInfoSupplier> xDIS(
1602 aModelData.GetModel(), uno::UNO_QUERY_THROW);
1603 uno::Reference<util::XCloneable> xCloneable(
1604 xDIS->getDocumentInfo(), uno::UNO_QUERY_THROW);
1605 uno::Reference<document::XDocumentInfo> xOldDocInfo(
1606 xCloneable->createClone(), uno::UNO_QUERY_THROW);
1607
1608 // use dispatch API to show document info dialog
1609 if ( aModelData.ShowDocumentInfoDialog() )
1610 bDialogUsed = sal_True;
1611 else
1612 {
1613 DBG_ERROR( "Can't execute document info dialog!\n" );
1614 }
1615
1616 try {
1617 // Document properties can contain streams that should be freed before storing
1618 aModelData.FreeDocumentProps();
1619 if ( ( nStoreMode & EXPORT_REQUESTED ) )
1620 aModelData.GetStorable()->storeToURL( aURL.GetMainURL( INetURLObject::NO_DECODE ), aArgsSequence );
1621 else
1622 aModelData.GetStorable()->storeAsURL( aURL.GetMainURL( INetURLObject::NO_DECODE ), aArgsSequence );
1623 }
1624 catch( uno::Exception& )
1625 {
1626 if ( ( nStoreMode & EXPORT_REQUESTED ) )
1627 SetDocInfoState( aModelData.GetModel(), xOldDocInfo, sal_True );
1628
1629 throw;
1630 }
1631
1632 if ( ( nStoreMode & EXPORT_REQUESTED ) )
1633 SetDocInfoState( aModelData.GetModel(), xOldDocInfo, sal_True );
1634 }
1635 else
1636 {
1637 // Document properties can contain streams that should be freed before storing
1638 aModelData.FreeDocumentProps();
1639
1640 // this is actually a save operation with different parameters
1641 // so storeTo or storeAs without DocInfo operations are used
1642 if ( ( nStoreMode & EXPORT_REQUESTED ) )
1643 aModelData.GetStorable()->storeToURL( aURL.GetMainURL( INetURLObject::NO_DECODE ), aArgsSequence );
1644 else
1645 aModelData.GetStorable()->storeAsURL( aURL.GetMainURL( INetURLObject::NO_DECODE ), aArgsSequence );
1646 }
1647
1648 return bDialogUsed;
1649 }
1650
1651 //-------------------------------------------------------------------------
1652 // static
CheckFilterOptionsAppearence(const uno::Reference<container::XNameAccess> & xFilterCFG,const::rtl::OUString & aFilterName)1653 sal_Bool SfxStoringHelper::CheckFilterOptionsAppearence(
1654 const uno::Reference< container::XNameAccess >& xFilterCFG,
1655 const ::rtl::OUString& aFilterName )
1656 {
1657 sal_Bool bUseFilterOptions = sal_False;
1658
1659 DBG_ASSERT( xFilterCFG.is(), "No filter configuration!\n" );
1660 if( xFilterCFG.is() )
1661 {
1662 try {
1663 uno::Sequence < beans::PropertyValue > aProps;
1664 uno::Any aAny = xFilterCFG->getByName( aFilterName );
1665 if ( aAny >>= aProps )
1666 {
1667 ::comphelper::SequenceAsHashMap aPropsHM( aProps );
1668 ::rtl::OUString aServiceName = aPropsHM.getUnpackedValueOrDefault(
1669 ::rtl::OUString::createFromAscii( "UIComponent" ),
1670 ::rtl::OUString() );
1671 if( aServiceName.getLength() )
1672 bUseFilterOptions = sal_True;
1673 }
1674 }
1675 catch( uno::Exception& )
1676 {
1677 }
1678 }
1679
1680 return bUseFilterOptions;
1681 }
1682
1683 //-------------------------------------------------------------------------
1684 // static
SetDocInfoState(const uno::Reference<frame::XModel> & xModel,const uno::Reference<document::XDocumentInfo> & i_xOldDocInfo,sal_Bool bNoModify)1685 void SfxStoringHelper::SetDocInfoState(
1686 const uno::Reference< frame::XModel >& xModel,
1687 const uno::Reference< document::XDocumentInfo >& i_xOldDocInfo,
1688 sal_Bool bNoModify )
1689 {
1690 uno::Reference< document::XDocumentInfoSupplier > xModelDocInfoSupplier( xModel, uno::UNO_QUERY );
1691 if ( !xModelDocInfoSupplier.is() )
1692 throw uno::RuntimeException(); // TODO:
1693
1694 uno::Reference< document::XDocumentInfo > xDocInfoToFill = xModelDocInfoSupplier->getDocumentInfo();
1695 uno::Reference< beans::XPropertySet > xPropSet( i_xOldDocInfo,
1696 uno::UNO_QUERY_THROW );
1697
1698 uno::Reference< util::XModifiable > xModifiable( xModel, uno::UNO_QUERY );
1699 if ( bNoModify && !xModifiable.is() )
1700 throw uno::RuntimeException();
1701
1702 sal_Bool bIsModified = bNoModify && xModifiable->isModified();
1703
1704 try
1705 {
1706 uno::Reference< beans::XPropertySet > xSet( xDocInfoToFill, uno::UNO_QUERY );
1707 uno::Reference< beans::XPropertyContainer > xContainer( xSet, uno::UNO_QUERY );
1708 uno::Reference< beans::XPropertySetInfo > xSetInfo = xSet->getPropertySetInfo();
1709 uno::Sequence< beans::Property > lProps = xSetInfo->getProperties();
1710 const beans::Property* pProps = lProps.getConstArray();
1711 sal_Int32 c = lProps.getLength();
1712 sal_Int32 i = 0;
1713 for (i=0; i<c; ++i)
1714 {
1715 uno::Any aValue = xPropSet->getPropertyValue( pProps[i].Name );
1716 if ( pProps[i].Attributes & ::com::sun::star::beans::PropertyAttribute::REMOVABLE )
1717 // QUESTION: DefaultValue?!
1718 xContainer->addProperty( pProps[i].Name, pProps[i].Attributes, aValue );
1719 try
1720 {
1721 // it is possible that the propertysets from XML and binary files differ; we shouldn't break then
1722 xSet->setPropertyValue( pProps[i].Name, aValue );
1723 }
1724 catch ( uno::Exception& ) {}
1725 }
1726
1727 sal_Int16 nCount = i_xOldDocInfo->getUserFieldCount();
1728 sal_Int16 nSupportedCount = xDocInfoToFill->getUserFieldCount();
1729 for ( sal_Int16 nInd = 0; nInd < nCount && nInd < nSupportedCount; nInd++ )
1730 {
1731 ::rtl::OUString aPropName = i_xOldDocInfo->getUserFieldName( nInd );
1732 xDocInfoToFill->setUserFieldName( nInd, aPropName );
1733 ::rtl::OUString aPropVal = i_xOldDocInfo->getUserFieldValue( nInd );
1734 xDocInfoToFill->setUserFieldValue( nInd, aPropVal );
1735 }
1736 }
1737 catch ( uno::Exception& ) {}
1738
1739 // set the modified flag back if required
1740 if ( bNoModify && bIsModified != xModifiable->isModified() )
1741 xModifiable->setModified( bIsModified );
1742 }
1743
1744 //-------------------------------------------------------------------------
1745 // static
WarnUnacceptableFormat(const uno::Reference<frame::XModel> & xModel,::rtl::OUString aOldUIName,::rtl::OUString,sal_Bool)1746 sal_Bool SfxStoringHelper::WarnUnacceptableFormat( const uno::Reference< frame::XModel >& xModel,
1747 ::rtl::OUString aOldUIName,
1748 ::rtl::OUString /*aDefUIName*/,
1749 sal_Bool /*bCanProceedFurther*/ )
1750 {
1751 if ( !SvtSaveOptions().IsWarnAlienFormat() )
1752 return sal_True;
1753
1754 Window* pWin = SfxStoringHelper::GetModelWindow( xModel );
1755 SfxAlienWarningDialog aDlg( pWin, aOldUIName );
1756
1757 return aDlg.Execute() == RET_OK;
1758 }
1759
1760 // static
ExecuteFilterDialog(SfxStoringHelper & _rStorageHelper,const::rtl::OUString & _sFilterName,const::com::sun::star::uno::Reference<::com::sun::star::frame::XModel> & _xModel,::com::sun::star::uno::Sequence<::com::sun::star::beans::PropertyValue> & _rArgsSequence)1761 void SfxStoringHelper::ExecuteFilterDialog( SfxStoringHelper& _rStorageHelper
1762 ,const ::rtl::OUString& _sFilterName
1763 ,const ::com::sun::star::uno::Reference< ::com::sun::star::frame::XModel >& _xModel
1764 ,/*OUT*/::com::sun::star::uno::Sequence< ::com::sun::star::beans::PropertyValue >& _rArgsSequence)
1765 {
1766 ModelData_Impl aModelData( _rStorageHelper, _xModel, _rArgsSequence );
1767 if ( aModelData.ExecuteFilterDialog_Impl( _sFilterName ) )
1768 _rArgsSequence = aModelData.GetMediaDescr().getAsConstPropertyValueList();
1769 }
1770
1771 // static
GetModelWindow(const uno::Reference<frame::XModel> & xModel)1772 Window* SfxStoringHelper::GetModelWindow( const uno::Reference< frame::XModel >& xModel )
1773 {
1774 Window* pWin = 0;
1775 try {
1776 if ( xModel.is() )
1777 {
1778 uno::Reference< frame::XController > xController = xModel->getCurrentController();
1779 if ( xController.is() )
1780 {
1781 uno::Reference< frame::XFrame > xFrame = xController->getFrame();
1782 if ( xFrame.is() )
1783 {
1784 uno::Reference< awt::XWindow > xWindow = xFrame->getContainerWindow();
1785 if ( xWindow.is() )
1786 {
1787 VCLXWindow* pVCLWindow = VCLXWindow::GetImplementation( xWindow );
1788 if ( pVCLWindow )
1789 pWin = pVCLWindow->GetWindow();
1790 }
1791 }
1792 }
1793 }
1794 }
1795 catch ( uno::Exception& )
1796 {
1797 }
1798
1799 return pWin;
1800 }
1801
1802