?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Version 7.1.7.1, tag libreoffice-7.1.7.1
[LibreOffice.git] / sfx2 / source / doc / objserv.cxx
blob83327103c1f014be8e3815436af0fddc5c79bfc0
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 <config_features.h>
21
22 #include <com/sun/star/style/XStyleFamiliesSupplier.hpp>
23 #include <com/sun/star/ui/dialogs/ExtendedFilePickerElementIds.hpp>
24 #include <com/sun/star/util/CloseVetoException.hpp>
25 #include <com/sun/star/beans/XPropertySet.hpp>
26 #include <com/sun/star/beans/PropertyValue.hpp>
27 #include <com/sun/star/document/XCmisDocument.hpp>
28 #include <com/sun/star/drawing/LineStyle.hpp>
29 #include <com/sun/star/lang/XServiceInfo.hpp>
30 #include <com/sun/star/security/XCertificate.hpp>
31 #include <com/sun/star/task/ErrorCodeIOException.hpp>
32 #include <com/sun/star/task/InteractionHandler.hpp>
33 #include <com/sun/star/task/XStatusIndicator.hpp>
34 #include <com/sun/star/task/XStatusIndicatorFactory.hpp>
35 #include <comphelper/processfactory.hxx>
36 #include <comphelper/servicehelper.hxx>
37 #include <com/sun/star/security/CertificateValidity.hpp>
38 #include <com/sun/star/drawing/XDrawView.hpp>
39
40 #include <com/sun/star/security/DocumentSignatureInformation.hpp>
41 #include <com/sun/star/security/DocumentDigitalSignatures.hpp>
42 #include <tools/diagnose_ex.h>
43 #include <tools/urlobj.hxx>
44 #include <svl/whiter.hxx>
45 #include <svl/intitem.hxx>
46 #include <svl/eitem.hxx>
47 #include <svl/visitem.hxx>
48 #include <svtools/sfxecode.hxx>
49 #include <svtools/ehdl.hxx>
50 #include <sal/log.hxx>
51 #include <sfx2/app.hxx>
52
53 #include <comphelper/string.hxx>
54 #include <basic/sbxcore.hxx>
55 #include <basic/sberrors.hxx>
56 #include <unotools/moduleoptions.hxx>
57 #include <unotools/saveopt.hxx>
58 #include <svtools/DocumentToGraphicRenderer.hxx>
59 #include <vcl/gdimtf.hxx>
60 #include <vcl/svapp.hxx>
61 #include <vcl/weld.hxx>
62 #include <comphelper/documentconstants.hxx>
63 #include <comphelper/storagehelper.hxx>
64 #include <tools/link.hxx>
65
66 #include <asyncfunc.hxx>
67 #include <sfx2/signaturestate.hxx>
68 #include <sfx2/sfxresid.hxx>
69 #include <sfx2/request.hxx>
70 #include <sfx2/printer.hxx>
71 #include <sfx2/viewsh.hxx>
72 #include <sfx2/dinfdlg.hxx>
73 #include <sfx2/docfilt.hxx>
74 #include <sfx2/docfile.hxx>
75 #include <sfx2/dispatch.hxx>
76 #include <sfx2/objitem.hxx>
77 #include <sfx2/objsh.hxx>
78 #include <objshimp.hxx>
79 #include <sfx2/module.hxx>
80 #include <sfx2/viewfrm.hxx>
81 #include <versdlg.hxx>
82 #include <sfx2/strings.hrc>
83 #include <sfx2/docfac.hxx>
84 #include <sfx2/fcontnr.hxx>
85 #include <sfx2/msgpool.hxx>
86 #include <sfx2/objface.hxx>
87 #include <checkin.hxx>
88 #include <sfx2/infobar.hxx>
89 #include <sfx2/sfxuno.hxx>
90 #include <sfx2/sfxsids.hrc>
91 #include <SfxRedactionHelper.hxx>
92
93 #include <com/sun/star/util/XCloseable.hpp>
94 #include <com/sun/star/document/XDocumentProperties.hpp>
95
96 #include <com/sun/star/drawing/XDrawPagesSupplier.hpp>
97 #include <com/sun/star/frame/XDesktop2.hpp>
98 #include <com/sun/star/frame/Desktop.hpp>
99
100 #include <guisaveas.hxx>
101 #include <saveastemplatedlg.hxx>
102 #include <memory>
103 #include <cppuhelper/implbase.hxx>
104 #include <unotools/ucbstreamhelper.hxx>
105 #include <unotools/streamwrap.hxx>
106 #include <comphelper/sequenceashashmap.hxx>
107
108 #include <autoredactdialog.hxx>
109
110 using namespace ::com::sun::star;
111 using namespace ::com::sun::star::lang;
112 using namespace ::com::sun::star::uno;
113 using namespace ::com::sun::star::ui::dialogs;
114 using namespace ::com::sun::star::awt;
115 using namespace ::com::sun::star::container;
116 using namespace ::com::sun::star::beans;
117 using namespace ::com::sun::star::document;
118 using namespace ::com::sun::star::security;
119 using namespace ::com::sun::star::task;
120 using namespace ::com::sun::star::graphic;
121
122 #define ShellClass_SfxObjectShell
123 #include <sfxslots.hxx>
124
125 SFX_IMPL_SUPERCLASS_INTERFACE(SfxObjectShell, SfxShell)
126
127 void SfxObjectShell::InitInterface_Impl()
128 {
129 }
130
131 namespace {
132
133 class SfxClosePreventer_Impl : public ::cppu::WeakImplHelper< css::util::XCloseListener >
134 {
135 bool m_bGotOwnership;
136 bool m_bPreventClose;
137
138 public:
139 SfxClosePreventer_Impl();
140
141 bool HasOwnership() const { return m_bGotOwnership; }
142
143 void SetPreventClose( bool bPrevent ) { m_bPreventClose = bPrevent; }
144
145 virtual void SAL_CALL queryClosing( const lang::EventObject& aEvent, sal_Bool bDeliverOwnership ) override;
146
147 virtual void SAL_CALL notifyClosing( const lang::EventObject& aEvent ) override ;
148
149 virtual void SAL_CALL disposing( const lang::EventObject& aEvent ) override ;
150
151 } ;
152
153 }
154
155 SfxClosePreventer_Impl::SfxClosePreventer_Impl()
156 : m_bGotOwnership( false )
157 , m_bPreventClose( true )
158 {
159 }
160
161 void SAL_CALL SfxClosePreventer_Impl::queryClosing( const lang::EventObject&, sal_Bool bDeliverOwnership )
162 {
163 if ( m_bPreventClose )
164 {
165 if ( !m_bGotOwnership )
166 m_bGotOwnership = bDeliverOwnership;
167
168 throw util::CloseVetoException();
169 }
170 }
171
172 void SAL_CALL SfxClosePreventer_Impl::notifyClosing( const lang::EventObject& )
173 {}
174
175 void SAL_CALL SfxClosePreventer_Impl::disposing( const lang::EventObject& )
176 {}
177
178 namespace {
179
180 class SfxInstanceCloseGuard_Impl
181 {
182 rtl::Reference<SfxClosePreventer_Impl> m_xPreventer;
183 uno::Reference< util::XCloseable > m_xCloseable;
184
185 public:
186 SfxInstanceCloseGuard_Impl() {}
187
188 ~SfxInstanceCloseGuard_Impl();
189
190 bool Init_Impl( const uno::Reference< util::XCloseable >& xCloseable );
191 };
192
193 }
194
195 bool SfxInstanceCloseGuard_Impl::Init_Impl( const uno::Reference< util::XCloseable >& xCloseable )
196 {
197 bool bResult = false;
198
199 // do not allow reinit after the successful init
200 if ( xCloseable.is() && !m_xCloseable.is() )
201 {
202 try
203 {
204 m_xPreventer = new SfxClosePreventer_Impl();
205 xCloseable->addCloseListener( m_xPreventer.get() );
206 m_xCloseable = xCloseable;
207 bResult = true;
208 }
209 catch( uno::Exception& )
210 {
211 OSL_FAIL( "Could not register close listener!" );
212 }
213 }
214
215 return bResult;
216 }
217
218 SfxInstanceCloseGuard_Impl::~SfxInstanceCloseGuard_Impl()
219 {
220 if ( !m_xCloseable.is() || !m_xPreventer.is() )
221 return;
222
223 try
224 {
225 m_xCloseable->removeCloseListener( m_xPreventer.get() );
226 }
227 catch( uno::Exception& )
228 {
229 }
230
231 try
232 {
233 if ( m_xPreventer.is() )
234 {
235 m_xPreventer->SetPreventClose( false );
236
237 if ( m_xPreventer->HasOwnership() )
238 m_xCloseable->close( true ); // TODO: do it asynchronously
239 }
240 }
241 catch( uno::Exception& )
242 {
243 }
244 }
245
246
247 void SfxObjectShell::PrintExec_Impl(SfxRequest &rReq)
248 {
249 SfxViewFrame *pFrame = SfxViewFrame::GetFirst(this);
250 if ( pFrame )
251 {
252 rReq.SetSlot( SID_PRINTDOC );
253 pFrame->GetViewShell()->ExecuteSlot(rReq);
254 }
255 }
256
257
258 void SfxObjectShell::PrintState_Impl(SfxItemSet &rSet)
259 {
260 bool bPrinting = false;
261 SfxViewFrame* pFrame = SfxViewFrame::GetFirst( this );
262 if ( pFrame )
263 {
264 SfxPrinter *pPrinter = pFrame->GetViewShell()->GetPrinter();
265 bPrinting = pPrinter && pPrinter->IsPrinting();
266 }
267 rSet.Put( SfxBoolItem( SID_PRINTOUT, bPrinting ) );
268 }
269
270 bool SfxObjectShell::APISaveAs_Impl(const OUString& aFileName, SfxItemSet& rItemSet,
271 const css::uno::Sequence<css::beans::PropertyValue>& rArgs)
272 {
273 bool bOk = false;
274
275 if ( GetMedium() )
276 {
277 OUString aFilterName;
278 const SfxStringItem* pFilterNameItem = rItemSet.GetItem<SfxStringItem>(SID_FILTER_NAME, false);
279 if( pFilterNameItem )
280 {
281 aFilterName = pFilterNameItem->GetValue();
282 }
283 else
284 {
285 const SfxStringItem* pContentTypeItem = rItemSet.GetItem<SfxStringItem>(SID_CONTENTTYPE, false);
286 if ( pContentTypeItem )
287 {
288 std::shared_ptr<const SfxFilter> pFilter = SfxFilterMatcher( GetFactory().GetFactoryName() ).GetFilter4Mime( pContentTypeItem->GetValue(), SfxFilterFlags::EXPORT );
289 if ( pFilter )
290 aFilterName = pFilter->GetName();
291 }
292 }
293
294 // in case no filter defined use default one
295 if( aFilterName.isEmpty() )
296 {
297 std::shared_ptr<const SfxFilter> pFilt = SfxFilter::GetDefaultFilterFromFactory(GetFactory().GetFactoryName());
298
299 DBG_ASSERT( pFilt, "No default filter!\n" );
300 if( pFilt )
301 aFilterName = pFilt->GetFilterName();
302
303 rItemSet.Put(SfxStringItem(SID_FILTER_NAME, aFilterName));
304 }
305
306
307 {
308 SfxObjectShellRef xLock( this ); // ???
309
310 // use the title that is provided in the media descriptor
311 const SfxStringItem* pDocTitleItem = rItemSet.GetItem<SfxStringItem>(SID_DOCINFO_TITLE, false);
312 if ( pDocTitleItem )
313 getDocProperties()->setTitle( pDocTitleItem->GetValue() );
314
315 bOk = CommonSaveAs_Impl(INetURLObject(aFileName), aFilterName, rItemSet, rArgs);
316 }
317 }
318
319 return bOk;
320 }
321
322 void SfxObjectShell::CheckOut( )
323 {
324 try
325 {
326 uno::Reference< document::XCmisDocument > xCmisDoc( GetModel(), uno::UNO_QUERY_THROW );
327 xCmisDoc->checkOut( );
328
329 // Remove the info bar
330 SfxViewFrame* pViewFrame = GetFrame();
331 pViewFrame->RemoveInfoBar( "checkout" );
332 }
333 catch ( const uno::RuntimeException& e )
334 {
335 std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog(GetFrame()->GetWindow().GetFrameWeld(),
336 VclMessageType::Warning, VclButtonsType::Ok, e.Message));
337 xBox->run();
338 }
339 }
340
341 void SfxObjectShell::CancelCheckOut( )
342 {
343 try
344 {
345 uno::Reference< document::XCmisDocument > xCmisDoc( GetModel(), uno::UNO_QUERY_THROW );
346 xCmisDoc->cancelCheckOut( );
347
348 uno::Reference< util::XModifiable > xModifiable( GetModel( ), uno::UNO_QUERY );
349 if ( xModifiable.is( ) )
350 xModifiable->setModified( false );
351 }
352 catch ( const uno::RuntimeException& e )
353 {
354 std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog(GetFrame()->GetWindow().GetFrameWeld(),
355 VclMessageType::Warning, VclButtonsType::Ok, e.Message));
356 xBox->run();
357 }
358 }
359
360 void SfxObjectShell::CheckIn( )
361 {
362 try
363 {
364 uno::Reference< document::XCmisDocument > xCmisDoc( GetModel(), uno::UNO_QUERY_THROW );
365 // Pop up dialog to ask for comment and major
366 SfxCheckinDialog checkinDlg(GetFrame()->GetWindow().GetFrameWeld());
367 if (checkinDlg.run() == RET_OK)
368 {
369 xCmisDoc->checkIn(checkinDlg.IsMajor(), checkinDlg.GetComment());
370 uno::Reference< util::XModifiable > xModifiable( GetModel( ), uno::UNO_QUERY );
371 if ( xModifiable.is( ) )
372 xModifiable->setModified( false );
373 }
374 }
375 catch ( const uno::RuntimeException& e )
376 {
377 std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog(GetFrame()->GetWindow().GetFrameWeld(),
378 VclMessageType::Warning, VclButtonsType::Ok, e.Message));
379 xBox->run();
380 }
381 }
382
383 uno::Sequence< document::CmisVersion > SfxObjectShell::GetCmisVersions( ) const
384 {
385 try
386 {
387 uno::Reference< document::XCmisDocument > xCmisDoc( GetModel(), uno::UNO_QUERY_THROW );
388 return xCmisDoc->getAllVersions( );
389 }
390 catch ( const uno::RuntimeException& e )
391 {
392 std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog(GetFrame()->GetWindow().GetFrameWeld(),
393 VclMessageType::Warning, VclButtonsType::Ok, e.Message));
394 xBox->run();
395 }
396 return uno::Sequence< document::CmisVersion > ( );
397 }
398
399 bool SfxObjectShell::IsSignPDF() const
400 {
401 if (pMedium && !pMedium->IsOriginallyReadOnly())
402 {
403 const std::shared_ptr<const SfxFilter>& pFilter = pMedium->GetFilter();
404 if (pFilter && pFilter->GetName() == "draw_pdf_import")
405 return true;
406 }
407
408 return false;
409 }
410
411 uno::Reference<security::XCertificate> SfxObjectShell::GetSignPDFCertificate() const
412 {
413 uno::Reference<frame::XModel> xModel = GetBaseModel();
414 if (!xModel.is())
415 {
416 return uno::Reference<security::XCertificate>();
417 }
418
419 uno::Reference<drawing::XShapes> xShapes(xModel->getCurrentSelection(), uno::UNO_QUERY);
420 if (!xShapes.is() || xShapes->getCount() < 1)
421 {
422 return uno::Reference<security::XCertificate>();
423 }
424
425 uno::Reference<beans::XPropertySet> xShapeProps(xShapes->getByIndex(0), uno::UNO_QUERY);
426 if (!xShapeProps.is())
427 {
428 return uno::Reference<security::XCertificate>();
429 }
430
431 if (!xShapeProps->getPropertySetInfo()->hasPropertyByName("InteropGrabBag"))
432 {
433 return uno::Reference<security::XCertificate>();
434 }
435
436 comphelper::SequenceAsHashMap aMap(xShapeProps->getPropertyValue("InteropGrabBag"));
437 auto it = aMap.find("SignatureCertificate");
438 if (it == aMap.end())
439 {
440 return uno::Reference<security::XCertificate>();
441 }
442
443 return uno::Reference<security::XCertificate>(it->second, uno::UNO_QUERY);
444 }
445
446 void SfxObjectShell::ExecFile_Impl(SfxRequest &rReq)
447 {
448 weld::Window* pDialogParent = rReq.GetFrameWeld();
449 if (!pDialogParent)
450 {
451 SfxViewFrame* pFrame = GetFrame();
452 if (!pFrame)
453 pFrame = SfxViewFrame::GetFirst(this);
454 if (pFrame)
455 pDialogParent = pFrame->GetWindow().GetFrameWeld();
456 }
457
458 sal_uInt16 nId = rReq.GetSlot();
459
460 if( SID_SIGNATURE == nId || SID_MACRO_SIGNATURE == nId )
461 {
462 if ( QueryHiddenInformation( HiddenWarningFact::WhenSigning, nullptr ) == RET_YES )
463 {
464 if (SID_SIGNATURE == nId)
465 {
466 uno::Reference<security::XCertificate> xCertificate = GetSignPDFCertificate();
467 if (xCertificate.is())
468 {
469 SignDocumentContentUsingCertificate(xCertificate);
470
471 // Reload to show how the PDF actually looks like after signing. This also
472 // changes "finish signing" on the infobar back to "sign document" as a side
473 // effect.
474 SfxViewFrame* pFrame = GetFrame();
475 if (pFrame)
476 {
477 // Store current page before reload.
478 SfxAllItemSet aSet(SfxGetpApp()->GetPool());
479 uno::Reference<drawing::XDrawView> xController(
480 GetBaseModel()->getCurrentController(), uno::UNO_QUERY);
481 uno::Reference<beans::XPropertySet> xPage(xController->getCurrentPage(),
482 uno::UNO_QUERY);
483 sal_Int32 nPage{};
484 xPage->getPropertyValue("Number") >>= nPage;
485 if (nPage > 0)
486 {
487 // nPage is 1-based.
488 aSet.Put(SfxInt32Item(SID_PAGE_NUMBER, nPage - 1));
489 }
490 SfxRequest aReq(SID_RELOAD, SfxCallMode::SLOT, aSet);
491 pFrame->ExecReload_Impl(aReq);
492 }
493 }
494 else
495 {
496 SignDocumentContent(pDialogParent);
497 }
498 }
499 else
500 {
501 SignScriptingContent(pDialogParent);
502 }
503 }
504 return;
505 }
506
507 if ( !GetMedium() && nId != SID_CLOSEDOC )
508 {
509 rReq.Ignore();
510 return;
511 }
512
513 // this guard is created here to have it destruction at the end of the method
514 SfxInstanceCloseGuard_Impl aModelGuard;
515
516 bool bIsPDFExport = false;
517 bool bIsAutoRedact = false;
518 std::vector<std::pair<RedactionTarget*, OUString>> aRedactionTargets;
519 switch(nId)
520 {
521 case SID_VERSION:
522 {
523 SfxViewFrame* pFrame = GetFrame();
524 if ( !pFrame )
525 pFrame = SfxViewFrame::GetFirst( this );
526 if ( !pFrame )
527 return;
528
529 if ( !IsOwnStorageFormat( *GetMedium() ) )
530 return;
531
532 SfxVersionDialog aDlg(pDialogParent, pFrame, IsSaveVersionOnClose());
533 aDlg.run();
534 SetSaveVersionOnClose(aDlg.IsSaveVersionOnClose());
535 rReq.Done();
536 return;
537 }
538
539 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
540 case SID_DOCINFO:
541 {
542 const SfxDocumentInfoItem* pDocInfItem = rReq.GetArg<SfxDocumentInfoItem>(SID_DOCINFO);
543 if ( pDocInfItem )
544 {
545 // parameter, e.g. from replayed macro
546 pDocInfItem->UpdateDocumentInfo(getDocProperties(), true);
547 SetUseUserData( pDocInfItem->IsUseUserData() );
548 SetUseThumbnailSave( pDocInfItem->IsUseThumbnailSave() );
549 }
550 else
551 {
552 // no argument containing DocInfo; check optional arguments
553 bool bReadOnly = IsReadOnly();
554 const SfxBoolItem* pROItem = rReq.GetArg<SfxBoolItem>(SID_DOC_READONLY);
555 if ( pROItem )
556 // override readonly attribute of document
557 // e.g. if a readonly document is saved elsewhere and user asks for editing DocInfo before
558 bReadOnly = pROItem->GetValue();
559
560 // URL for dialog
561 const OUString aURL( HasName() ? GetMedium()->GetName() : GetFactory().GetFactoryURL() );
562
563 Reference< XCmisDocument > xCmisDoc( GetModel(), uno::UNO_QUERY );
564 uno::Sequence< document::CmisProperty> aCmisProperties = xCmisDoc->getCmisProperties();
565
566 SfxDocumentInfoItem aDocInfoItem( aURL, getDocProperties(), aCmisProperties,
567 IsUseUserData(), IsUseThumbnailSave() );
568 if ( !GetSlotState( SID_DOCTEMPLATE ) )
569 // templates not supported
570 aDocInfoItem.SetTemplate(false);
571
572 SfxItemSet aSet(GetPool(), svl::Items<SID_DOCINFO, SID_DOCINFO, SID_DOC_READONLY, SID_DOC_READONLY,
573 SID_EXPLORER_PROPS_START, SID_EXPLORER_PROPS_START, SID_BASEURL, SID_BASEURL>{} );
574 aSet.Put( aDocInfoItem );
575 aSet.Put( SfxBoolItem( SID_DOC_READONLY, bReadOnly ) );
576 aSet.Put( SfxStringItem( SID_EXPLORER_PROPS_START, GetTitle() ) );
577 aSet.Put( SfxStringItem( SID_BASEURL, GetMedium()->GetBaseURL() ) );
578
579 // creating dialog is done via virtual method; application will
580 // add its own statistics page
581 std::shared_ptr<SfxRequest> pReq = std::make_shared<SfxRequest>(rReq);
582 std::shared_ptr<SfxDocumentInfoDialog> xDlg(CreateDocumentInfoDialog(rReq.GetFrameWeld(), aSet));
583 SfxTabDialogController::runAsync(xDlg, [this, xDlg, xCmisDoc, pReq](sal_Int32 nResult)
584 {
585 if (RET_OK == nResult)
586 {
587 const SfxDocumentInfoItem* pDocInfoItem = SfxItemSet::GetItem<SfxDocumentInfoItem>(xDlg->GetOutputItemSet(), SID_DOCINFO, false);
588 if ( pDocInfoItem )
589 {
590 // user has done some changes to DocumentInfo
591 pDocInfoItem->UpdateDocumentInfo(getDocProperties());
592 const uno::Sequence< document::CmisProperty >& aNewCmisProperties =
593 pDocInfoItem->GetCmisProperties( );
594 if ( aNewCmisProperties.hasElements( ) )
595 xCmisDoc->updateCmisProperties( aNewCmisProperties );
596 SetUseUserData( pDocInfoItem->IsUseUserData() );
597 SetUseThumbnailSave( pDocInfoItem-> IsUseThumbnailSave() );
598 // add data from dialog for possible recording purpose
599 pReq->AppendItem( SfxDocumentInfoItem( GetTitle(),
600 getDocProperties(), aNewCmisProperties, IsUseUserData(), IsUseThumbnailSave() ) );
601 }
602
603 css::uno::Reference< css::uno::XInterface > xInterface;
604 const SfxUnoAnyItem* pUnoAny = pReq->GetArg<SfxUnoAnyItem>(FN_PARAM_2);
605 AsyncFunc* pAsyncFunc = pUnoAny && (pUnoAny->GetValue() >>= xInterface ) ?
606 comphelper::getUnoTunnelImplementation<AsyncFunc>(xInterface) : nullptr;
607 if (pAsyncFunc)
608 pAsyncFunc->Execute();
609
610 pReq->Done();
611 }
612 else
613 // nothing done; no recording
614 pReq->Ignore();
615 });
616
617 rReq.Ignore();
618 }
619
620 return;
621 }
622
623 case SID_AUTOREDACTDOC:
624 {
625 // Actual redaction takes place on a newly generated Draw document
626 if (!SvtModuleOptions().IsModuleInstalled(SvtModuleOptions::EModule::DRAW))
627 {
628 std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog(
629 pDialogParent, VclMessageType::Warning, VclButtonsType::Ok,
630 SfxResId(STR_REDACTION_NO_DRAW_WARNING)));
631
632 xBox->run();
633
634 return;
635 }
636
637 SfxAutoRedactDialog aDlg(pDialogParent);
638 sal_Int16 nResult = aDlg.run();
639
640 if (nResult != RET_OK || !aDlg.hasTargets() || !aDlg.isValidState())
641 {
642 //Do nothing
643 return;
644 }
645
646 // else continue with normal redaction
647 bIsAutoRedact = true;
648 aDlg.getTargets(aRedactionTargets);
649
650 [[fallthrough]];
651 }
652
653 case SID_REDACTDOC:
654 {
655 css::uno::Reference<css::frame::XModel> xModel = GetModel();
656 if(!xModel.is())
657 return;
658
659 uno::Reference< lang::XComponent > xSourceDoc( xModel );
660
661 // Actual redaction takes place on a newly generated Draw document
662 if (!SvtModuleOptions().IsModuleInstalled(SvtModuleOptions::EModule::DRAW))
663 {
664 std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog(
665 pDialogParent, VclMessageType::Warning, VclButtonsType::Ok,
666 SfxResId(STR_REDACTION_NO_DRAW_WARNING)));
667
668 xBox->run();
669
670 return;
671 }
672
673 DocumentToGraphicRenderer aRenderer(xSourceDoc, false);
674
675 // Get the page margins of the original doc
676 PageMargins aPageMargins = {-1, -1, -1, -1};
677 if (aRenderer.isWriter())
678 aPageMargins = SfxRedactionHelper::getPageMarginsForWriter(xModel);
679 else if (aRenderer.isCalc())
680 aPageMargins = SfxRedactionHelper::getPageMarginsForCalc(xModel);
681
682 sal_Int32 nPages = aRenderer.getPageCount();
683 std::vector< GDIMetaFile > aMetaFiles;
684 std::vector< ::Size > aPageSizes;
685
686 // Convert the pages of the document to gdimetafiles
687 SfxRedactionHelper::getPageMetaFilesFromDoc(aMetaFiles, aPageSizes, nPages, aRenderer);
688
689 // Create an empty Draw component.
690 uno::Reference<frame::XDesktop2> xDesktop = css::frame::Desktop::create(comphelper::getProcessComponentContext());
691 uno::Reference<lang::XComponent> xComponent = xDesktop->loadComponentFromURL("private:factory/sdraw", "_default", 0, {});
692
693 if (!xComponent.is())
694 {
695 SAL_WARN("sfx.doc", "SID_REDACTDOC: Failed to load new draw component. loadComponentFromURL returned an empty reference.");
696
697 return;
698 }
699
700 // Add the doc pages to the new draw document
701 SfxRedactionHelper::addPagesToDraw(xComponent, nPages, aMetaFiles, aPageSizes, aPageMargins, aRedactionTargets, bIsAutoRedact);
702
703 // Show the Redaction toolbar
704 SfxViewFrame* pViewFrame = SfxViewFrame::Current();
705 if (!pViewFrame)
706 return;
707 SfxRedactionHelper::showRedactionToolbar(pViewFrame);
708
709 return;
710 }
711
712 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
713 case SID_DIRECTEXPORTDOCASPDF:
714 {
715 uno::Reference< lang::XComponent > xComponent( GetCurrentComponent(), uno::UNO_QUERY );
716 if (!xComponent.is())
717 return;
718
719 uno::Reference< lang::XServiceInfo > xServiceInfo( xComponent, uno::UNO_QUERY);
720
721 // Redaction finalization takes place in Draw
722 if ( xServiceInfo.is() && xServiceInfo->supportsService("com.sun.star.drawing.DrawingDocument")
723 && SfxRedactionHelper::isRedactMode(rReq) )
724 {
725 OUString sRedactionStyle(SfxRedactionHelper::getStringParam(rReq, SID_REDACTION_STYLE));
726
727 // Access the draw pages
728 uno::Reference<drawing::XDrawPagesSupplier> xDrawPagesSupplier(xComponent, uno::UNO_QUERY);
729 uno::Reference<drawing::XDrawPages> xDrawPages = xDrawPagesSupplier->getDrawPages();
730
731 sal_Int32 nPageCount = xDrawPages->getCount();
732 for (sal_Int32 nPageNum = 0; nPageNum < nPageCount; ++nPageNum)
733 {
734 // Get the page
735 uno::Reference< drawing::XDrawPage > xPage( xDrawPages->getByIndex( nPageNum ), uno::UNO_QUERY );
736
737 if (!xPage.is())
738 continue;
739
740 // Go through all shapes
741 sal_Int32 nShapeCount = xPage->getCount();
742 for (sal_Int32 nShapeNum = 0; nShapeNum < nShapeCount; ++nShapeNum)
743 {
744 uno::Reference< drawing::XShape > xCurrShape(xPage->getByIndex(nShapeNum), uno::UNO_QUERY);
745 if (!xCurrShape.is())
746 continue;
747
748 uno::Reference< beans::XPropertySet > xPropSet(xCurrShape, uno::UNO_QUERY);
749 if (!xPropSet.is())
750 continue;
751
752 uno::Reference< beans::XPropertySetInfo> xInfo = xPropSet->getPropertySetInfo();
753 if (!xInfo.is())
754 continue;
755
756 OUString sShapeName;
757 if (xInfo->hasPropertyByName("Name"))
758 {
759 uno::Any aAnyShapeName = xPropSet->getPropertyValue("Name");
760 aAnyShapeName >>= sShapeName;
761 }
762 else
763 continue;
764
765 // Rectangle redaction
766 if (sShapeName == "RectangleRedactionShape"
767 && xInfo->hasPropertyByName("FillTransparence") && xInfo->hasPropertyByName("FillColor"))
768 {
769 xPropSet->setPropertyValue("FillTransparence", css::uno::makeAny(static_cast<sal_Int16>(0)));
770 if (sRedactionStyle == "White")
771 {
772 xPropSet->setPropertyValue("FillColor", css::uno::makeAny(COL_WHITE));
773 xPropSet->setPropertyValue("LineStyle", css::uno::makeAny(css::drawing::LineStyle::LineStyle_SOLID));
774 xPropSet->setPropertyValue("LineColor", css::uno::makeAny(COL_BLACK));
775 }
776 else
777 {
778 xPropSet->setPropertyValue("FillColor", css::uno::makeAny(COL_BLACK));
779 xPropSet->setPropertyValue("LineStyle", css::uno::makeAny(css::drawing::LineStyle::LineStyle_NONE));
780 }
781 }
782 // Freeform redaction
783 else if (sShapeName == "FreeformRedactionShape"
784 && xInfo->hasPropertyByName("LineTransparence") && xInfo->hasPropertyByName("LineColor"))
785 {
786 xPropSet->setPropertyValue("LineTransparence", css::uno::makeAny(static_cast<sal_Int16>(0)));
787
788 if (sRedactionStyle == "White")
789 {
790 xPropSet->setPropertyValue("LineColor", css::uno::makeAny(COL_WHITE));
791 }
792 else
793 {
794 xPropSet->setPropertyValue("LineColor", css::uno::makeAny(COL_BLACK));
795 }
796 }
797 }
798 }
799 }
800 }
801 [[fallthrough]];
802 case SID_EXPORTDOCASPDF:
803 bIsPDFExport = true;
804 [[fallthrough]];
805 case SID_EXPORTDOCASEPUB:
806 case SID_DIRECTEXPORTDOCASEPUB:
807 case SID_EXPORTDOC:
808 case SID_SAVEASDOC:
809 case SID_SAVEASREMOTE:
810 case SID_SAVEDOC:
811 {
812 // derived class may decide to abort this
813 if( !QuerySlotExecutable( nId ) )
814 {
815 rReq.SetReturnValue( SfxBoolItem( 0, false ) );
816 return;
817 }
818
819 //!! detailed analysis of an error code
820 SfxObjectShellRef xLock( this );
821
822 // the model can not be closed till the end of this method
823 // if somebody tries to close it during this time the model will be closed
824 // at the end of the method
825 aModelGuard.Init_Impl( uno::Reference< util::XCloseable >( GetModel(), uno::UNO_QUERY ) );
826
827 ErrCode nErrorCode = ERRCODE_NONE;
828
829 // by default versions should be preserved always except in case of an explicit
830 // SaveAs via GUI, so the flag must be set accordingly
831 pImpl->bPreserveVersions = (nId == SID_SAVEDOC);
832 try
833 {
834 SfxErrorContext aEc( ERRCTX_SFX_SAVEASDOC, GetTitle() ); // ???
835
836 if ( nId == SID_SAVEASDOC || nId == SID_SAVEASREMOTE )
837 {
838 // in case of plugin mode the SaveAs operation means SaveTo
839 const SfxBoolItem* pViewOnlyItem = SfxItemSet::GetItem<SfxBoolItem>(GetMedium()->GetItemSet(), SID_VIEWONLY, false);
840 if ( pViewOnlyItem && pViewOnlyItem->GetValue() )
841 rReq.AppendItem( SfxBoolItem( SID_SAVETO, true ) );
842 }
843
844 // TODO/LATER: do the following GUI related actions in standalone method
845
846 // Introduce a status indicator for GUI operation
847 const SfxUnoAnyItem* pStatusIndicatorItem = rReq.GetArg<SfxUnoAnyItem>(SID_PROGRESS_STATUSBAR_CONTROL);
848 if ( !pStatusIndicatorItem )
849 {
850 // get statusindicator
851 uno::Reference< task::XStatusIndicator > xStatusIndicator;
852 uno::Reference < frame::XController > xCtrl( GetModel()->getCurrentController() );
853 if ( xCtrl.is() )
854 {
855 uno::Reference< task::XStatusIndicatorFactory > xStatFactory( xCtrl->getFrame(), uno::UNO_QUERY );
856 if( xStatFactory.is() )
857 xStatusIndicator = xStatFactory->createStatusIndicator();
858 }
859
860 OSL_ENSURE( xStatusIndicator.is(), "Can not retrieve default status indicator!" );
861
862 if ( xStatusIndicator.is() )
863 {
864 SfxUnoAnyItem aStatIndItem( SID_PROGRESS_STATUSBAR_CONTROL, uno::makeAny( xStatusIndicator ) );
865
866 if ( nId == SID_SAVEDOC )
867 {
868 // in case of saving it is not possible to transport the parameters from here
869 // but it is not clear here whether the saving will be done or saveAs operation
870 GetMedium()->GetItemSet()->Put( aStatIndItem );
871 }
872
873 rReq.AppendItem( aStatIndItem );
874 }
875 }
876 else if ( nId == SID_SAVEDOC )
877 {
878 // in case of saving it is not possible to transport the parameters from here
879 // but it is not clear here whether the saving will be done or saveAs operation
880 GetMedium()->GetItemSet()->Put( *pStatusIndicatorItem );
881 }
882
883 // Introduce an interaction handler for GUI operation
884 const SfxUnoAnyItem* pInteractionHandlerItem = rReq.GetArg<SfxUnoAnyItem>(SID_INTERACTIONHANDLER);
885 if ( !pInteractionHandlerItem )
886 {
887 uno::Reference<css::awt::XWindow> xParentWindow;
888 uno::Reference<frame::XController> xCtrl(GetModel()->getCurrentController());
889 if (xCtrl.is())
890 xParentWindow = xCtrl->getFrame()->getContainerWindow();
891
892 uno::Reference< uno::XComponentContext > xContext = ::comphelper::getProcessComponentContext();
893
894 uno::Reference< task::XInteractionHandler2 > xInteract(
895 task::InteractionHandler::createWithParent(xContext, xParentWindow) );
896
897 SfxUnoAnyItem aInteractionItem( SID_INTERACTIONHANDLER, uno::makeAny( xInteract ) );
898 if ( nId == SID_SAVEDOC )
899 {
900 // in case of saving it is not possible to transport the parameters from here
901 // but it is not clear here whether the saving will be done or saveAs operation
902 GetMedium()->GetItemSet()->Put( aInteractionItem );
903 }
904
905 rReq.AppendItem( aInteractionItem );
906 }
907 else if ( nId == SID_SAVEDOC )
908 {
909 // in case of saving it is not possible to transport the parameters from here
910 // but it is not clear here whether the saving will be done or saveAs operation
911 GetMedium()->GetItemSet()->Put( *pInteractionHandlerItem );
912 }
913
914
915 const SfxStringItem* pOldPasswordItem = SfxItemSet::GetItem<SfxStringItem>(GetMedium()->GetItemSet(), SID_PASSWORD, false);
916 const SfxUnoAnyItem* pOldEncryptionDataItem = SfxItemSet::GetItem<SfxUnoAnyItem>(GetMedium()->GetItemSet(), SID_ENCRYPTIONDATA, false);
917 bool bPreselectPassword = (pOldPasswordItem && pOldEncryptionDataItem);
918
919 uno::Sequence< beans::PropertyValue > aDispatchArgs;
920 if ( rReq.GetArgs() )
921 TransformItems( nId,
922 *rReq.GetArgs(),
923 aDispatchArgs );
924
925 bool bForceSaveAs = nId == SID_SAVEDOC && IsReadOnlyMedium();
926 const SfxSlot* pSlot = GetModule()->GetSlotPool()->GetSlot( bForceSaveAs ? SID_SAVEASDOC : nId );
927 if ( !pSlot )
928 throw uno::Exception("no slot", nullptr);
929
930 SfxStoringHelper aHelper;
931
932 if ( QueryHiddenInformation( bIsPDFExport ? HiddenWarningFact::WhenCreatingPDF : HiddenWarningFact::WhenSaving, nullptr ) != RET_YES )
933 {
934 // the user has decided not to store the document
935 throw task::ErrorCodeIOException(
936 "SfxObjectShell::ExecFile_Impl: ERRCODE_IO_ABORT",
937 uno::Reference< uno::XInterface >(), sal_uInt32(ERRCODE_IO_ABORT));
938 }
939
940 aHelper.GUIStoreModel( GetModel(),
941 OUString::createFromAscii( pSlot->GetUnoName() ),
942 aDispatchArgs,
943 bPreselectPassword,
944 GetDocumentSignatureState() );
945
946
947 // merge aDispatchArgs to the request
948 SfxAllItemSet aResultParams( GetPool() );
949 TransformParameters( nId,
950 aDispatchArgs,
951 aResultParams );
952 rReq.SetArgs( aResultParams );
953
954 // the StoreAsURL/StoreToURL method have called this method with false
955 // so it has to be restored to true here since it is a call from GUI
956 GetMedium()->SetUpdatePickList( true );
957
958 // TODO: in future it must be done in following way
959 // if document is opened from GUI, it immediately appears in the picklist
960 // if the document is a new one then it appears in the picklist immediately
961 // after SaveAs operation triggered from GUI
962 }
963 catch( const task::ErrorCodeIOException& aErrorEx )
964 {
965 TOOLS_WARN_EXCEPTION( "sfx.doc", "Fatal IO error during save");
966 nErrorCode = ErrCode(aErrorEx.ErrCode);
967 }
968 catch( Exception& )
969 {
970 nErrorCode = ERRCODE_IO_GENERAL;
971 }
972
973 // by default versions should be preserved always except in case of an explicit
974 // SaveAs via GUI, so the flag must be reset to guarantee this
975 pImpl->bPreserveVersions = true;
976 ErrCode lErr=GetErrorCode();
977
978 if ( !lErr && nErrorCode )
979 lErr = nErrorCode;
980
981 if ( lErr && nErrorCode == ERRCODE_NONE )
982 {
983 const SfxBoolItem* pWarnItem = rReq.GetArg<SfxBoolItem>(SID_FAIL_ON_WARNING);
984 if ( pWarnItem && pWarnItem->GetValue() )
985 nErrorCode = lErr;
986 }
987
988 // may be nErrorCode should be shown in future
989 if ( lErr != ERRCODE_IO_ABORT )
990 {
991 SfxErrorContext aEc(ERRCTX_SFX_SAVEASDOC,GetTitle());
992 ErrorHandler::HandleError(lErr, pDialogParent);
993 }
994
995 if (nId == SID_DIRECTEXPORTDOCASPDF &&
996 SfxRedactionHelper::isRedactMode(rReq))
997 {
998 // Return the finalized redaction shapes back to normal (gray & transparent)
999 uno::Reference< lang::XComponent > xComponent( GetCurrentComponent(), uno::UNO_QUERY );
1000 if (!xComponent.is())
1001 return;
1002
1003 uno::Reference< lang::XServiceInfo > xServiceInfo( xComponent, uno::UNO_QUERY);
1004
1005 // Redaction finalization takes place in Draw
1006 if ( xServiceInfo.is() && xServiceInfo->supportsService("com.sun.star.drawing.DrawingDocument") )
1007 {
1008 // Access the draw pages
1009 uno::Reference<drawing::XDrawPagesSupplier> xDrawPagesSupplier(xComponent, uno::UNO_QUERY);
1010 uno::Reference<drawing::XDrawPages> xDrawPages = xDrawPagesSupplier->getDrawPages();
1011
1012 sal_Int32 nPageCount = xDrawPages->getCount();
1013 for (sal_Int32 nPageNum = 0; nPageNum < nPageCount; ++nPageNum)
1014 {
1015 // Get the page
1016 uno::Reference< drawing::XDrawPage > xPage( xDrawPages->getByIndex( nPageNum ), uno::UNO_QUERY );
1017
1018 if (!xPage.is())
1019 continue;
1020
1021 // Go through all shapes
1022 sal_Int32 nShapeCount = xPage->getCount();
1023 for (sal_Int32 nShapeNum = 0; nShapeNum < nShapeCount; ++nShapeNum)
1024 {
1025 uno::Reference< drawing::XShape > xCurrShape(xPage->getByIndex(nShapeNum), uno::UNO_QUERY);
1026 if (!xCurrShape.is())
1027 continue;
1028
1029 uno::Reference< beans::XPropertySet > xPropSet(xCurrShape, uno::UNO_QUERY);
1030 if (!xPropSet.is())
1031 continue;
1032
1033 uno::Reference< beans::XPropertySetInfo> xInfo = xPropSet->getPropertySetInfo();
1034 if (!xInfo.is())
1035 continue;
1036
1037 // Not a shape we converted?
1038 if (!xInfo->hasPropertyByName("Name"))
1039 continue;
1040
1041 OUString sShapeName;
1042 if (xInfo->hasPropertyByName("Name"))
1043 {
1044 uno::Any aAnyShapeName = xPropSet->getPropertyValue("Name");
1045 aAnyShapeName >>= sShapeName;
1046 }
1047 else
1048 continue;
1049
1050 // Rectangle redaction
1051 if (sShapeName == "RectangleRedactionShape"
1052 && xInfo->hasPropertyByName("FillTransparence") && xInfo->hasPropertyByName("FillColor"))
1053 {
1054 xPropSet->setPropertyValue("FillTransparence", css::uno::makeAny(static_cast<sal_Int16>(50)));
1055 xPropSet->setPropertyValue("FillColor", css::uno::makeAny(COL_GRAY7));
1056 xPropSet->setPropertyValue("LineStyle", css::uno::makeAny(css::drawing::LineStyle::LineStyle_NONE));
1057
1058 }
1059 // Freeform redaction
1060 else if (sShapeName == "FreeformRedactionShape")
1061 {
1062 xPropSet->setPropertyValue("LineTransparence", css::uno::makeAny(static_cast<sal_Int16>(50)));
1063 xPropSet->setPropertyValue("LineColor", css::uno::makeAny(COL_GRAY7));
1064 }
1065 }
1066 }
1067
1068
1069 }
1070 }
1071
1072 if ( nId == SID_EXPORTDOCASPDF )
1073 {
1074 // This function is used by the SendMail function that needs information if an export
1075 // file was written or not. This could be due to cancellation of the export
1076 // or due to an error. So IO abort must be handled like an error!
1077 nErrorCode = ( lErr != ERRCODE_IO_ABORT ) && ( nErrorCode == ERRCODE_NONE ) ? nErrorCode : lErr;
1078 }
1079
1080 if ( ( nId == SID_SAVEASDOC || nId == SID_SAVEASREMOTE ) && nErrorCode == ERRCODE_NONE )
1081 {
1082 const SfxBoolItem* saveTo = rReq.GetArg<SfxBoolItem>(SID_SAVETO);
1083 if (saveTo == nullptr || !saveTo->GetValue())
1084 {
1085 SfxViewFrame *pFrame = GetFrame();
1086 if (pFrame)
1087 pFrame->RemoveInfoBar("readonly");
1088 SetReadOnlyUI(false);
1089 }
1090 }
1091
1092 rReq.SetReturnValue( SfxBoolItem(0, nErrorCode == ERRCODE_NONE ) );
1093
1094 ResetError();
1095
1096 Invalidate();
1097 break;
1098 }
1099
1100 case SID_SAVEACOPY:
1101 {
1102 SfxAllItemSet aArgs( GetPool() );
1103 aArgs.Put( SfxBoolItem( SID_SAVEACOPYITEM, true ) );
1104 SfxRequest aSaveACopyReq( SID_EXPORTDOC, SfxCallMode::API, aArgs );
1105 ExecFile_Impl( aSaveACopyReq );
1106 if ( !aSaveACopyReq.IsDone() )
1107 {
1108 rReq.Ignore();
1109 return;
1110 }
1111 break;
1112 }
1113
1114 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
1115
1116 case SID_CLOSEDOC:
1117 {
1118 // Evaluate Parameter
1119 const SfxBoolItem* pSaveItem = rReq.GetArg<SfxBoolItem>(SID_CLOSEDOC_SAVE);
1120 const SfxStringItem* pNameItem = rReq.GetArg<SfxStringItem>(SID_CLOSEDOC_FILENAME);
1121 if ( pSaveItem )
1122 {
1123 if ( pSaveItem->GetValue() )
1124 {
1125 if ( !pNameItem )
1126 {
1127 #if HAVE_FEATURE_SCRIPTING
1128 SbxBase::SetError( ERRCODE_BASIC_WRONG_ARGS );
1129 #endif
1130 rReq.Ignore();
1131 return;
1132 }
1133 SfxAllItemSet aArgs( GetPool() );
1134 SfxStringItem aTmpItem( SID_FILE_NAME, pNameItem->GetValue() );
1135 aArgs.Put( aTmpItem, aTmpItem.Which() );
1136 SfxRequest aSaveAsReq( SID_SAVEASDOC, SfxCallMode::API, aArgs );
1137 ExecFile_Impl( aSaveAsReq );
1138 if ( !aSaveAsReq.IsDone() )
1139 {
1140 rReq.Ignore();
1141 return;
1142 }
1143 }
1144 else
1145 SetModified(false);
1146 }
1147
1148 // Cancelled by the user?
1149 if (!PrepareClose())
1150 {
1151 rReq.SetReturnValue( SfxBoolItem(0, false) );
1152 rReq.Done();
1153 return;
1154 }
1155
1156 SetModified( false );
1157 ErrCode lErr = GetErrorCode();
1158 ErrorHandler::HandleError(lErr, pDialogParent);
1159
1160 rReq.SetReturnValue( SfxBoolItem(0, true) );
1161 rReq.Done();
1162 rReq.ReleaseArgs(); // because the pool is destroyed in Close
1163 DoClose();
1164 return;
1165 }
1166
1167 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
1168 case SID_DOCTEMPLATE:
1169 {
1170 // save as document templates
1171 SfxSaveAsTemplateDialog aDlg(pDialogParent, GetModel());
1172 (void)aDlg.run();
1173 break;
1174 }
1175
1176 case SID_CHECKOUT:
1177 {
1178 CheckOut( );
1179 break;
1180 }
1181 case SID_CANCELCHECKOUT:
1182 {
1183 std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog(nullptr,
1184 VclMessageType::Question, VclButtonsType::YesNo, SfxResId(STR_QUERY_CANCELCHECKOUT)));
1185 if (xBox->run() == RET_YES)
1186 {
1187 CancelCheckOut( );
1188
1189 // Reload the document as we may still have local changes
1190 SfxViewFrame *pFrame = GetFrame();
1191 if ( pFrame )
1192 pFrame->GetDispatcher()->Execute(SID_RELOAD);
1193 }
1194 break;
1195 }
1196 case SID_CHECKIN:
1197 {
1198 CheckIn( );
1199 break;
1200 }
1201 }
1202
1203 // Prevent entry in the Pick-lists
1204 if ( rReq.IsAPI() )
1205 GetMedium()->SetUpdatePickList( false );
1206
1207 // Ignore()-branches have already returned
1208 rReq.Done();
1209 }
1210
1211
1212 void SfxObjectShell::GetState_Impl(SfxItemSet &rSet)
1213 {
1214 SfxWhichIter aIter( rSet );
1215
1216 for ( sal_uInt16 nWhich = aIter.FirstWhich(); nWhich; nWhich = aIter.NextWhich() )
1217 {
1218 switch ( nWhich )
1219 {
1220 case SID_DOCTEMPLATE :
1221 {
1222 if ( isExportLocked())
1223 rSet.DisableItem( nWhich );
1224 break;
1225 }
1226
1227 case SID_CHECKOUT:
1228 {
1229 bool bShow = false;
1230 Reference< XCmisDocument > xCmisDoc( GetModel(), uno::UNO_QUERY );
1231 const uno::Sequence< document::CmisProperty> aCmisProperties = xCmisDoc->getCmisProperties();
1232
1233 if ( xCmisDoc->isVersionable( ) && aCmisProperties.hasElements( ) )
1234 {
1235 // Loop over the CMIS Properties to find cmis:isVersionSeriesCheckedOut
1236 bool bIsGoogleFile = false;
1237 bool bCheckedOut = false;
1238 for ( const auto& rCmisProperty : aCmisProperties )
1239 {
1240 if ( rCmisProperty.Id == "cmis:isVersionSeriesCheckedOut" )
1241 {
1242 uno::Sequence< sal_Bool > bTmp;
1243 rCmisProperty.Value >>= bTmp;
1244 bCheckedOut = bTmp[0];
1245 }
1246 // using title to know if it's a Google Drive file
1247 // maybe there's a safer way.
1248 if ( rCmisProperty.Name == "title" )
1249 bIsGoogleFile = true;
1250 }
1251 bShow = !bCheckedOut && !bIsGoogleFile;
1252 }
1253
1254 if ( !bShow )
1255 {
1256 rSet.DisableItem( nWhich );
1257 rSet.Put( SfxVisibilityItem( nWhich, false ) );
1258 }
1259 }
1260 break;
1261
1262 case SID_CANCELCHECKOUT:
1263 case SID_CHECKIN:
1264 {
1265 bool bShow = false;
1266 Reference< XCmisDocument > xCmisDoc( GetModel(), uno::UNO_QUERY );
1267 uno::Sequence< document::CmisProperty> aCmisProperties = xCmisDoc->getCmisProperties( );
1268
1269 if ( xCmisDoc->isVersionable( ) && aCmisProperties.hasElements( ) )
1270 {
1271 // Loop over the CMIS Properties to find cmis:isVersionSeriesCheckedOut
1272 bool bCheckedOut = false;
1273 auto pProp = std::find_if(aCmisProperties.begin(), aCmisProperties.end(),
1274 [](const document::CmisProperty& rProp) { return rProp.Id == "cmis:isVersionSeriesCheckedOut"; });
1275 if (pProp != aCmisProperties.end())
1276 {
1277 uno::Sequence< sal_Bool > bTmp;
1278 pProp->Value >>= bTmp;
1279 bCheckedOut = bTmp[0];
1280 }
1281 bShow = bCheckedOut;
1282 }
1283
1284 if ( !bShow )
1285 {
1286 rSet.DisableItem( nWhich );
1287 rSet.Put( SfxVisibilityItem( nWhich, false ) );
1288 }
1289 }
1290 break;
1291
1292 case SID_VERSION:
1293 {
1294 SfxObjectShell *pDoc = this;
1295 SfxViewFrame* pFrame = GetFrame();
1296 if ( !pFrame )
1297 pFrame = SfxViewFrame::GetFirst( this );
1298
1299 if ( !pFrame || !pDoc->HasName() ||
1300 !IsOwnStorageFormat( *pDoc->GetMedium() ) )
1301 rSet.DisableItem( nWhich );
1302 break;
1303 }
1304 case SID_SAVEDOC:
1305 {
1306 if ( IsReadOnly() || isSaveLocked())
1307 {
1308 rSet.DisableItem(nWhich);
1309 break;
1310 }
1311 rSet.Put(SfxStringItem(nWhich, SfxResId(STR_SAVEDOC)));
1312 }
1313 break;
1314
1315 case SID_DOCINFO:
1316 break;
1317
1318 case SID_CLOSEDOC:
1319 {
1320 rSet.Put(SfxStringItem(nWhich, SfxResId(STR_CLOSEDOC)));
1321 break;
1322 }
1323
1324 case SID_SAVEASDOC:
1325 {
1326 if (!(pImpl->nLoadedFlags & SfxLoadedFlags::MAINDOCUMENT)
1327 || isExportLocked())
1328 {
1329 rSet.DisableItem( nWhich );
1330 break;
1331 }
1332 if ( /*!pCombinedFilters ||*/ !GetMedium() )
1333 rSet.DisableItem( nWhich );
1334 else
1335 rSet.Put( SfxStringItem( nWhich, SfxResId(STR_SAVEASDOC) ) );
1336 break;
1337 }
1338
1339 case SID_SAVEACOPY:
1340 {
1341 if (!(pImpl->nLoadedFlags & SfxLoadedFlags::MAINDOCUMENT) || isExportLocked())
1342 {
1343 rSet.DisableItem( nWhich );
1344 break;
1345 }
1346 if ( /*!pCombinedFilters ||*/ !GetMedium() )
1347 rSet.DisableItem( nWhich );
1348 else
1349 rSet.Put( SfxStringItem( nWhich, SfxResId(STR_SAVEACOPY) ) );
1350 break;
1351 }
1352
1353 case SID_EXPORTDOC:
1354 case SID_EXPORTDOCASPDF:
1355 case SID_DIRECTEXPORTDOCASPDF:
1356 case SID_EXPORTDOCASEPUB:
1357 case SID_DIRECTEXPORTDOCASEPUB:
1358 case SID_REDACTDOC:
1359 case SID_AUTOREDACTDOC:
1360 case SID_SAVEASREMOTE:
1361 {
1362 if (isExportLocked())
1363 rSet.DisableItem( nWhich );
1364 break;
1365 }
1366
1367 case SID_DOC_MODIFIED:
1368 {
1369 rSet.Put( SfxBoolItem( SID_DOC_MODIFIED, IsModified() ) );
1370 break;
1371 }
1372
1373 case SID_MODIFIED:
1374 {
1375 rSet.Put( SfxBoolItem( SID_MODIFIED, IsModified() ) );
1376 break;
1377 }
1378
1379 case SID_DOCINFO_TITLE:
1380 {
1381 rSet.Put( SfxStringItem(
1382 SID_DOCINFO_TITLE, getDocProperties()->getTitle() ) );
1383 break;
1384 }
1385 case SID_FILE_NAME:
1386 {
1387 if( GetMedium() && HasName() )
1388 rSet.Put( SfxStringItem(
1389 SID_FILE_NAME, GetMedium()->GetName() ) );
1390 break;
1391 }
1392 case SID_SIGNATURE:
1393 {
1394 SfxViewFrame *pFrame = SfxViewFrame::GetFirst(this);
1395 if ( pFrame )
1396 {
1397 SignatureState eState = GetDocumentSignatureState();
1398 InfobarType aInfobarType(InfobarType::INFO);
1399 OUString sMessage("");
1400
1401 switch (eState)
1402 {
1403 case SignatureState::BROKEN:
1404 sMessage = SfxResId(STR_SIGNATURE_BROKEN);
1405 aInfobarType = InfobarType::DANGER;
1406 break;
1407 case SignatureState::INVALID:
1408 sMessage = SfxResId(STR_SIGNATURE_INVALID);
1409 // Warning only, I've tried Danger and it looked too scary
1410 aInfobarType = InfobarType::WARNING;
1411 break;
1412 case SignatureState::NOTVALIDATED:
1413 sMessage = SfxResId(STR_SIGNATURE_NOTVALIDATED);
1414 aInfobarType = InfobarType::WARNING;
1415 break;
1416 case SignatureState::PARTIAL_OK:
1417 sMessage = SfxResId(STR_SIGNATURE_PARTIAL_OK);
1418 aInfobarType = InfobarType::WARNING;
1419 break;
1420 case SignatureState::OK:
1421 sMessage = SfxResId(STR_SIGNATURE_OK);
1422 aInfobarType = InfobarType::INFO;
1423 break;
1424 case SignatureState::NOTVALIDATED_PARTIAL_OK:
1425 sMessage = SfxResId(STR_SIGNATURE_NOTVALIDATED_PARTIAL_OK);
1426 aInfobarType = InfobarType::WARNING;
1427 break;
1428 //FIXME SignatureState::Unknown, own message?
1429 default:
1430 break;
1431 }
1432
1433 // new info bar
1434 if ( !pFrame->HasInfoBarWithID("signature") )
1435 {
1436 if ( !sMessage.isEmpty() )
1437 {
1438 auto pInfoBar = pFrame->AppendInfoBar("signature", "", sMessage, aInfobarType);
1439 if (pInfoBar == nullptr || pInfoBar->IsDisposed())
1440 return;
1441 weld::Button& rBtn = pInfoBar->addButton();
1442 rBtn.set_label(SfxResId(STR_SIGNATURE_SHOW));
1443 rBtn.connect_clicked(LINK(this, SfxObjectShell, SignDocumentHandler));
1444 }
1445 }
1446 else // info bar exists already
1447 {
1448 if ( eState == SignatureState::NOSIGNATURES )
1449 pFrame->RemoveInfoBar("signature");
1450 else
1451 pFrame->UpdateInfoBar("signature", "", sMessage, aInfobarType);
1452 }
1453 }
1454
1455 rSet.Put( SfxUInt16Item( SID_SIGNATURE, static_cast<sal_uInt16>(GetDocumentSignatureState()) ) );
1456 break;
1457 }
1458 case SID_MACRO_SIGNATURE:
1459 {
1460 // the slot makes sense only if there is a macro in the document
1461 if ( pImpl->documentStorageHasMacros() || pImpl->aMacroMode.hasMacroLibrary() )
1462 rSet.Put( SfxUInt16Item( SID_MACRO_SIGNATURE, static_cast<sal_uInt16>(GetScriptingSignatureState()) ) );
1463 else
1464 rSet.DisableItem( nWhich );
1465 break;
1466 }
1467 case SID_DOC_REPAIR:
1468 {
1469 SfxUndoManager* pIUndoMgr = GetUndoManager();
1470 if (pIUndoMgr)
1471 rSet.Put( SfxBoolItem(nWhich, pIUndoMgr->IsEmptyActions()) );
1472 else
1473 rSet.DisableItem( nWhich );
1474 break;
1475 }
1476 }
1477 }
1478 }
1479
1480 IMPL_LINK_NOARG(SfxObjectShell, SignDocumentHandler, weld::Button&, void)
1481 {
1482 GetDispatcher()->Execute(SID_SIGNATURE);
1483 }
1484
1485 void SfxObjectShell::ExecProps_Impl(SfxRequest &rReq)
1486 {
1487 switch ( rReq.GetSlot() )
1488 {
1489 case SID_MODIFIED:
1490 {
1491 SetModified( rReq.GetArgs()->Get(SID_MODIFIED).GetValue() );
1492 rReq.Done();
1493 break;
1494 }
1495
1496 case SID_DOCTITLE:
1497 SetTitle( rReq.GetArgs()->Get(SID_DOCTITLE).GetValue() );
1498 rReq.Done();
1499 break;
1500
1501 case SID_DOCINFO_AUTHOR :
1502 getDocProperties()->setAuthor( static_cast<const SfxStringItem&>(rReq.GetArgs()->Get(rReq.GetSlot())).GetValue() );
1503 break;
1504
1505 case SID_DOCINFO_COMMENTS :
1506 getDocProperties()->setDescription( static_cast<const SfxStringItem&>(rReq.GetArgs()->Get(rReq.GetSlot())).GetValue() );
1507 break;
1508
1509 case SID_DOCINFO_KEYWORDS :
1510 {
1511 const OUString aStr = static_cast<const SfxStringItem&>(rReq.GetArgs()->Get(rReq.GetSlot())).GetValue();
1512 getDocProperties()->setKeywords(
1513 ::comphelper::string::convertCommaSeparated(aStr) );
1514 break;
1515 }
1516 }
1517 }
1518
1519
1520 void SfxObjectShell::StateProps_Impl(SfxItemSet &rSet)
1521 {
1522 SfxWhichIter aIter(rSet);
1523 for ( sal_uInt16 nSID = aIter.FirstWhich(); nSID; nSID = aIter.NextWhich() )
1524 {
1525 switch ( nSID )
1526 {
1527 case SID_DOCINFO_AUTHOR :
1528 {
1529 rSet.Put( SfxStringItem( nSID,
1530 getDocProperties()->getAuthor() ) );
1531 break;
1532 }
1533
1534 case SID_DOCINFO_COMMENTS :
1535 {
1536 rSet.Put( SfxStringItem( nSID,
1537 getDocProperties()->getDescription()) );
1538 break;
1539 }
1540
1541 case SID_DOCINFO_KEYWORDS :
1542 {
1543 rSet.Put( SfxStringItem( nSID, ::comphelper::string::
1544 convertCommaSeparated(getDocProperties()->getKeywords())) );
1545 break;
1546 }
1547
1548 case SID_DOCPATH:
1549 {
1550 OSL_FAIL( "Not supported anymore!" );
1551 break;
1552 }
1553
1554 case SID_DOCFULLNAME:
1555 {
1556 rSet.Put( SfxStringItem( SID_DOCFULLNAME, GetTitle(SFX_TITLE_FULLNAME) ) );
1557 break;
1558 }
1559
1560 case SID_DOCTITLE:
1561 {
1562 rSet.Put( SfxStringItem( SID_DOCTITLE, GetTitle() ) );
1563 break;
1564 }
1565
1566 case SID_DOC_READONLY:
1567 {
1568 rSet.Put( SfxBoolItem( SID_DOC_READONLY, IsReadOnly() ) );
1569 break;
1570 }
1571
1572 case SID_DOC_SAVED:
1573 {
1574 rSet.Put( SfxBoolItem( SID_DOC_SAVED, !IsModified() ) );
1575 break;
1576 }
1577
1578 case SID_CLOSING:
1579 {
1580 rSet.Put( SfxBoolItem( SID_CLOSING, false ) );
1581 break;
1582 }
1583
1584 case SID_DOC_LOADING:
1585 rSet.Put( SfxBoolItem( nSID, ! ( pImpl->nLoadedFlags & SfxLoadedFlags::MAINDOCUMENT ) ) );
1586 break;
1587
1588 case SID_IMG_LOADING:
1589 rSet.Put( SfxBoolItem( nSID, ! ( pImpl->nLoadedFlags & SfxLoadedFlags::IMAGES ) ) );
1590 break;
1591 }
1592 }
1593 }
1594
1595
1596 void SfxObjectShell::ExecView_Impl(SfxRequest &rReq)
1597 {
1598 switch ( rReq.GetSlot() )
1599 {
1600 case SID_ACTIVATE:
1601 {
1602 SfxViewFrame *pFrame = SfxViewFrame::GetFirst( this );
1603 if ( pFrame )
1604 pFrame->GetFrame().Appear();
1605 rReq.SetReturnValue( SfxObjectItem( 0, pFrame ) );
1606 rReq.Done();
1607 break;
1608 }
1609 }
1610 }
1611
1612
1613 void SfxObjectShell::StateView_Impl(SfxItemSet& /*rSet*/)
1614 {
1615 }
1616
1617 /// Does this ZIP storage have a signature stream?
1618 static bool HasSignatureStream(const uno::Reference<embed::XStorage>& xStorage)
1619 {
1620 if (!xStorage.is())
1621 return false;
1622
1623 if (xStorage->hasByName("META-INF"))
1624 {
1625 // ODF case.
1626 try
1627 {
1628 uno::Reference<embed::XStorage> xMetaInf
1629 = xStorage->openStorageElement("META-INF", embed::ElementModes::READ);
1630 if (xMetaInf.is())
1631 {
1632 return xMetaInf->hasByName("documentsignatures.xml")
1633 || xMetaInf->hasByName("macrosignatures.xml")
1634 || xMetaInf->hasByName("packagesignatures.xml");
1635 }
1636 }
1637 catch (const css::io::IOException&)
1638 {
1639 TOOLS_WARN_EXCEPTION("sfx.doc", "HasSignatureStream: failed to open META-INF");
1640 }
1641 }
1642
1643 // OOXML case.
1644 return xStorage->hasByName("_xmlsignatures");
1645 }
1646
1647 uno::Sequence< security::DocumentSignatureInformation > SfxObjectShell::GetDocumentSignatureInformation( bool bScriptingContent, const uno::Reference< security::XDocumentDigitalSignatures >& xSigner )
1648 {
1649 uno::Sequence< security::DocumentSignatureInformation > aResult;
1650 uno::Reference< security::XDocumentDigitalSignatures > xLocSigner = xSigner;
1651
1652 bool bSupportsSigning = GetMedium() && GetMedium()->GetFilter() && GetMedium()->GetFilter()->GetSupportsSigning();
1653 if (GetMedium() && !GetMedium()->GetName().isEmpty() && ((IsOwnStorageFormat(*GetMedium()) && GetMedium()->GetStorage().is()) || bSupportsSigning))
1654 {
1655 try
1656 {
1657 if ( !xLocSigner.is() )
1658 {
1659 OUString aVersion;
1660 try
1661 {
1662 uno::Reference < beans::XPropertySet > xPropSet( GetStorage(), uno::UNO_QUERY_THROW );
1663 xPropSet->getPropertyValue("Version") >>= aVersion;
1664 }
1665 catch( uno::Exception& )
1666 {
1667 }
1668
1669 xLocSigner.set( security::DocumentDigitalSignatures::createWithVersion(comphelper::getProcessComponentContext(), aVersion) );
1670
1671 }
1672
1673 if ( bScriptingContent )
1674 aResult = xLocSigner->verifyScriptingContentSignatures( GetMedium()->GetZipStorageToSign_Impl(),
1675 uno::Reference< io::XInputStream >() );
1676 else
1677 {
1678 if (GetMedium()->GetStorage(false).is())
1679 {
1680 // Something ZIP-based.
1681 // Only call into xmlsecurity if we see a signature stream,
1682 // as libxmlsec init is expensive.
1683 if (HasSignatureStream(GetMedium()->GetZipStorageToSign_Impl()))
1684 aResult = xLocSigner->verifyDocumentContentSignatures( GetMedium()->GetZipStorageToSign_Impl(),
1685 uno::Reference< io::XInputStream >() );
1686 }
1687 else
1688 {
1689 // Not ZIP-based, e.g. PDF.
1690
1691 // Create temp file if needed.
1692 GetMedium()->CreateTempFile(/*bReplace=*/false);
1693
1694 std::unique_ptr<SvStream> pStream(utl::UcbStreamHelper::CreateStream(GetMedium()->GetName(), StreamMode::READ));
1695 uno::Reference<io::XStream> xStream(new utl::OStreamWrapper(*pStream));
1696 uno::Reference<io::XInputStream> xInputStream(xStream, uno::UNO_QUERY);
1697 aResult = xLocSigner->verifyDocumentContentSignatures(uno::Reference<embed::XStorage>(), xInputStream);
1698 }
1699 }
1700 }
1701 catch( css::uno::Exception& )
1702 {
1703 }
1704 }
1705
1706 return aResult;
1707 }
1708
1709 SignatureState SfxObjectShell::ImplGetSignatureState( bool bScriptingContent )
1710 {
1711 SignatureState* pState = bScriptingContent ? &pImpl->nScriptingSignatureState : &pImpl->nDocumentSignatureState;
1712
1713 if ( *pState == SignatureState::UNKNOWN )
1714 {
1715 *pState = SignatureState::NOSIGNATURES;
1716
1717 uno::Sequence< security::DocumentSignatureInformation > aInfos = GetDocumentSignatureInformation( bScriptingContent );
1718 *pState = DocumentSignatures::getSignatureState(aInfos);
1719 }
1720
1721 if ( *pState == SignatureState::OK || *pState == SignatureState::NOTVALIDATED
1722 || *pState == SignatureState::PARTIAL_OK)
1723 {
1724 if ( IsModified() )
1725 *pState = SignatureState::INVALID;
1726 }
1727
1728 return *pState;
1729 }
1730
1731 bool SfxObjectShell::PrepareForSigning(weld::Window* pDialogParent)
1732 {
1733 // check whether the document is signed
1734 ImplGetSignatureState(); // document signature
1735 if (GetMedium() && GetMedium()->GetFilter() && GetMedium()->GetFilter()->IsOwnFormat())
1736 ImplGetSignatureState( true ); // script signature
1737 bool bHasSign = ( pImpl->nScriptingSignatureState != SignatureState::NOSIGNATURES || pImpl->nDocumentSignatureState != SignatureState::NOSIGNATURES );
1738
1739 // the target ODF version on saving (only valid when signing ODF of course)
1740 SvtSaveOptions aSaveOpt;
1741 SvtSaveOptions::ODFSaneDefaultVersion nVersion = aSaveOpt.GetODFSaneDefaultVersion();
1742
1743 // the document is not new and is not modified
1744 OUString aODFVersion(comphelper::OStorageHelper::GetODFVersionFromStorage(GetStorage()));
1745
1746 if ( IsModified() || !GetMedium() || GetMedium()->GetName().isEmpty()
1747 || (GetMedium()->GetFilter()->IsOwnFormat() && aODFVersion.compareTo(ODFVER_012_TEXT) < 0 && !bHasSign))
1748 {
1749 // the document might need saving ( new, modified or in ODF1.1 format without signature )
1750
1751 if (nVersion >= SvtSaveOptions::ODFSVER_012)
1752 {
1753 OUString sQuestion(bHasSign ? SfxResId(STR_XMLSEC_QUERY_SAVESIGNEDBEFORESIGN) : SfxResId(RID_SVXSTR_XMLSEC_QUERY_SAVEBEFORESIGN));
1754 std::unique_ptr<weld::MessageDialog> xQuestion(Application::CreateMessageDialog(pDialogParent,
1755 VclMessageType::Question, VclButtonsType::YesNo, sQuestion));
1756
1757
1758 if (xQuestion->run() == RET_YES)
1759 {
1760 sal_uInt16 nId = SID_SAVEDOC;
1761 if ( !GetMedium() || GetMedium()->GetName().isEmpty() )
1762 nId = SID_SAVEASDOC;
1763 SfxRequest aSaveRequest( nId, SfxCallMode::SLOT, GetPool() );
1764 //ToDo: Review. We needed to call SetModified, otherwise the document would not be saved.
1765 SetModified();
1766 ExecFile_Impl( aSaveRequest );
1767
1768 // Check if it is stored a format which supports signing
1769 if (GetMedium() && GetMedium()->GetFilter() && !GetMedium()->GetName().isEmpty()
1770 && ((!GetMedium()->GetFilter()->IsOwnFormat()
1771 && !GetMedium()->GetFilter()->GetSupportsSigning())
1772 || (GetMedium()->GetFilter()->IsOwnFormat()
1773 && !GetMedium()->HasStorage_Impl())))
1774 {
1775 std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog(
1776 pDialogParent, VclMessageType::Info, VclButtonsType::Ok,
1777 SfxResId(STR_INFO_WRONGDOCFORMAT)));
1778
1779 xBox->run();
1780 return false;
1781 }
1782 }
1783 else
1784 {
1785 // When the document is modified then we must not show the
1786 // digital signatures dialog
1787 // If we have come here then the user denied to save.
1788 if (!bHasSign)
1789 return false;
1790 }
1791 }
1792 else
1793 {
1794 std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog(pDialogParent,
1795 VclMessageType::Warning, VclButtonsType::Ok, SfxResId(STR_XMLSEC_ODF12_EXPECTED)));
1796 xBox->run();
1797 return false;
1798 }
1799
1800 if ( IsModified() || !GetMedium() || GetMedium()->GetName().isEmpty() )
1801 return false;
1802 }
1803
1804 // the document is not modified currently, so it can not become modified after signing
1805 pImpl->m_bAllowModifiedBackAfterSigning = false;
1806 if ( IsEnableSetModified() )
1807 {
1808 EnableSetModified( false );
1809 pImpl->m_bAllowModifiedBackAfterSigning = true;
1810 }
1811
1812 // we have to store to the original document, the original medium should be closed for this time
1813 if ( ConnectTmpStorage_Impl( pMedium->GetStorage(), pMedium ) )
1814 {
1815 GetMedium()->CloseAndRelease();
1816 return true;
1817 }
1818 return false;
1819 }
1820
1821 void SfxObjectShell::RecheckSignature(bool bAlsoRecheckScriptingSignature)
1822 {
1823 if (bAlsoRecheckScriptingSignature)
1824 pImpl->nScriptingSignatureState = SignatureState::UNKNOWN; // Re-Check
1825
1826 pImpl->nDocumentSignatureState = SignatureState::UNKNOWN; // Re-Check
1827
1828 Invalidate(SID_SIGNATURE);
1829 Invalidate(SID_MACRO_SIGNATURE);
1830 Broadcast(SfxHint(SfxHintId::TitleChanged));
1831 }
1832
1833 void SfxObjectShell::AfterSigning(bool bSignSuccess, bool bSignScriptingContent)
1834 {
1835 pImpl->m_bSavingForSigning = true;
1836 DoSaveCompleted( GetMedium() );
1837 pImpl->m_bSavingForSigning = false;
1838
1839 if ( bSignSuccess )
1840 RecheckSignature(bSignScriptingContent);
1841
1842 if ( pImpl->m_bAllowModifiedBackAfterSigning )
1843 EnableSetModified();
1844 }
1845
1846 bool SfxObjectShell::CheckIsReadonly(bool bSignScriptingContent)
1847 {
1848 if (GetMedium()->IsOriginallyReadOnly())
1849 {
1850 // If the file is physically read-only, we just show the existing signatures
1851 try
1852 {
1853 OUString aODFVersion(
1854 comphelper::OStorageHelper::GetODFVersionFromStorage(GetStorage()));
1855 uno::Reference<security::XDocumentDigitalSignatures> xSigner(
1856 security::DocumentDigitalSignatures::createWithVersionAndValidSignature(
1857 comphelper::getProcessComponentContext(), aODFVersion, HasValidSignatures()));
1858 if (bSignScriptingContent)
1859 xSigner->showScriptingContentSignatures(GetMedium()->GetZipStorageToSign_Impl(),
1860 uno::Reference<io::XInputStream>());
1861 else
1862 {
1863 uno::Reference<embed::XStorage> xStorage = GetMedium()->GetZipStorageToSign_Impl();
1864 if (xStorage.is())
1865 xSigner->showDocumentContentSignatures(xStorage,
1866 uno::Reference<io::XInputStream>());
1867 else
1868 {
1869 std::unique_ptr<SvStream> pStream(
1870 utl::UcbStreamHelper::CreateStream(GetName(), StreamMode::READ));
1871 uno::Reference<io::XInputStream> xStream(new utl::OStreamWrapper(*pStream));
1872 xSigner->showDocumentContentSignatures(uno::Reference<embed::XStorage>(),
1873 xStream);
1874 }
1875 }
1876 }
1877 catch (const uno::Exception&)
1878 {
1879 SAL_WARN("sfx.doc", "Couldn't use signing functionality!");
1880 }
1881 return true;
1882 }
1883 return false;
1884 }
1885
1886 bool SfxObjectShell::HasValidSignatures() const
1887 {
1888 return pImpl->nDocumentSignatureState == SignatureState::OK
1889 || pImpl->nDocumentSignatureState == SignatureState::NOTVALIDATED
1890 || pImpl->nDocumentSignatureState == SignatureState::PARTIAL_OK;
1891 }
1892
1893 SignatureState SfxObjectShell::GetDocumentSignatureState()
1894 {
1895 return ImplGetSignatureState();
1896 }
1897
1898 void SfxObjectShell::SignDocumentContent(weld::Window* pDialogParent)
1899 {
1900 if (!PrepareForSigning(pDialogParent))
1901 return;
1902
1903 if (CheckIsReadonly(false))
1904 return;
1905
1906 bool bSignSuccess = GetMedium()->SignContents_Impl(pDialogParent, false, HasValidSignatures());
1907
1908 AfterSigning(bSignSuccess, false);
1909 }
1910
1911 bool SfxObjectShell::SignDocumentContentUsingCertificate(const Reference<XCertificate>& xCertificate)
1912 {
1913 // 1. PrepareForSigning
1914
1915 // check whether the document is signed
1916 ImplGetSignatureState(false); // document signature
1917 if (GetMedium() && GetMedium()->GetFilter() && GetMedium()->GetFilter()->IsOwnFormat())
1918 ImplGetSignatureState( true ); // script signature
1919 bool bHasSign = ( pImpl->nScriptingSignatureState != SignatureState::NOSIGNATURES || pImpl->nDocumentSignatureState != SignatureState::NOSIGNATURES );
1920
1921 // the target ODF version on saving (only valid when signing ODF of course)
1922 SvtSaveOptions aSaveOpt;
1923 SvtSaveOptions::ODFSaneDefaultVersion nVersion = aSaveOpt.GetODFSaneDefaultVersion();
1924
1925 // the document is not new and is not modified
1926 OUString aODFVersion(comphelper::OStorageHelper::GetODFVersionFromStorage(GetStorage()));
1927
1928 if (IsModified() || !GetMedium() || GetMedium()->GetName().isEmpty()
1929 || (GetMedium()->GetFilter()->IsOwnFormat() && aODFVersion.compareTo(ODFVER_012_TEXT) < 0 && !bHasSign))
1930 {
1931 if (nVersion >= SvtSaveOptions::ODFSVER_012)
1932 {
1933 sal_uInt16 nId = SID_SAVEDOC;
1934 if ( !GetMedium() || GetMedium()->GetName().isEmpty() )
1935 nId = SID_SAVEASDOC;
1936 SfxRequest aSaveRequest( nId, SfxCallMode::SLOT, GetPool() );
1937 //ToDo: Review. We needed to call SetModified, otherwise the document would not be saved.
1938 SetModified();
1939 ExecFile_Impl( aSaveRequest );
1940
1941 // Check if it is stored a format which supports signing
1942 if (GetMedium() && GetMedium()->GetFilter() && !GetMedium()->GetName().isEmpty()
1943 && ((!GetMedium()->GetFilter()->IsOwnFormat()
1944 && !GetMedium()->GetFilter()->GetSupportsSigning())
1945 || (GetMedium()->GetFilter()->IsOwnFormat()
1946 && !GetMedium()->HasStorage_Impl())))
1947 {
1948 return false;
1949 }
1950 }
1951 else
1952 {
1953 return false;
1954 }
1955
1956 if ( IsModified() || !GetMedium() || GetMedium()->GetName().isEmpty() )
1957 return false;
1958 }
1959
1960 // the document is not modified currently, so it can not become modified after signing
1961 pImpl->m_bAllowModifiedBackAfterSigning = false;
1962 if ( IsEnableSetModified() )
1963 {
1964 EnableSetModified( false );
1965 pImpl->m_bAllowModifiedBackAfterSigning = true;
1966 }
1967
1968 // we have to store to the original document, the original medium should be closed for this time
1969 bool bResult = ConnectTmpStorage_Impl( pMedium->GetStorage(), pMedium);
1970
1971 if (!bResult)
1972 return false;
1973
1974 GetMedium()->CloseAndRelease();
1975
1976 // 2. Check Read-Only
1977 if (GetMedium()->IsOriginallyReadOnly())
1978 return false;
1979
1980 // 3. Sign
1981 bool bSignSuccess = GetMedium()->SignDocumentContentUsingCertificate(
1982 GetBaseModel(), HasValidSignatures(), xCertificate);
1983
1984 // 4. AfterSigning
1985 AfterSigning(bSignSuccess, false);
1986
1987 return true;
1988 }
1989
1990 void SfxObjectShell::SignSignatureLine(weld::Window* pDialogParent,
1991 const OUString& aSignatureLineId,
1992 const Reference<XCertificate>& xCert,
1993 const Reference<XGraphic>& xValidGraphic,
1994 const Reference<XGraphic>& xInvalidGraphic,
1995 const OUString& aComment)
1996 {
1997 if (!PrepareForSigning(pDialogParent))
1998 return;
1999
2000 if (CheckIsReadonly(false))
2001 return;
2002
2003 bool bSignSuccess = GetMedium()->SignContents_Impl(pDialogParent,
2004 false, HasValidSignatures(), aSignatureLineId, xCert, xValidGraphic, xInvalidGraphic, aComment);
2005
2006 AfterSigning(bSignSuccess, false);
2007
2008 // Reload the document to get the updated graphic
2009 // FIXME: Update just the signature line graphic instead of reloading the document
2010 SfxViewFrame *pFrame = GetFrame();
2011 if (pFrame)
2012 pFrame->GetDispatcher()->Execute(SID_RELOAD);
2013 }
2014
2015 SignatureState SfxObjectShell::GetScriptingSignatureState()
2016 {
2017 return ImplGetSignatureState( true );
2018 }
2019
2020 void SfxObjectShell::SignScriptingContent(weld::Window* pDialogParent)
2021 {
2022 if (!PrepareForSigning(pDialogParent))
2023 return;
2024
2025 if (CheckIsReadonly(true))
2026 return;
2027
2028 bool bSignSuccess = GetMedium()->SignContents_Impl(pDialogParent, true, HasValidSignatures());
2029
2030 AfterSigning(bSignSuccess, true);
2031 }
2032
2033 namespace
2034 {
2035 class theSfxObjectShellUnoTunnelId : public rtl::Static< UnoTunnelIdInit, theSfxObjectShellUnoTunnelId > {};
2036 }
2037
2038 const uno::Sequence<sal_Int8>& SfxObjectShell::getUnoTunnelId()
2039 {
2040 return theSfxObjectShellUnoTunnelId::get().getSeq();
2041 }
2042
2043 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE