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_sd.hxx"
26
27 #include <svl/lckbitem.hxx>
28 #include <sfx2/frame.hxx>
29 #include <sfx2/viewfrm.hxx>
30 #include <unotools/moduleoptions.hxx>
31 #include "framework/FrameworkHelper.hxx"
32
33 #include <svx/dialogs.hrc>
34
35 #include <editeng/langitem.hxx>
36 #include <editeng/editdata.hxx>
37 #include <vcl/msgbox.hxx>
38 #include <editeng/svxenum.hxx>
39 #include <sfx2/dispatch.hxx>
40 #include <sfx2/request.hxx>
41 #include <sfx2/printer.hxx>
42 #include <sfx2/docfile.hxx>
43 #include <editeng/paperinf.hxx>
44 #include <editeng/eeitem.hxx>
45 #include <unotools/useroptions.hxx>
46
47 #include "app.hrc"
48 #include "glob.hrc"
49 #include "strings.hrc"
50 #include "res_bmp.hrc"
51
52 #define _SD_DLL // for SD_MOD()
53 #include "sdmod.hxx"
54 #include "sddll.hxx"
55 #include "pres.hxx"
56 #include "optsitem.hxx"
57 #include "ViewShell.hxx"
58 #include "sdattr.hxx"
59 #include "sdpage.hxx"
60 #include "DrawDocShell.hxx"
61 #include "drawdoc.hxx"
62 #include "assclass.hxx"
63 #include "sdenumdef.hxx"
64 #include "sdresid.hxx"
65 #include "OutlineViewShell.hxx"
66 #include "ViewShellBase.hxx"
67 #ifndef SD_FRAMW_VIEW_HXX
68 #include "FrameView.hxx"
69 #endif
70 #include "FactoryIds.hxx"
71 #include "sdabstdlg.hxx"
72 #include <memory>
73 #include <boost/shared_ptr.hpp>
74 #include <boost/scoped_array.hpp>
75 #include "slideshow.hxx"
76
77 #include <com/sun/star/document/XDocumentPropertiesSupplier.hpp>
78 #include <com/sun/star/document/XDocumentProperties.hpp>
79
80
81 using ::sd::framework::FrameworkHelper;
82 using ::com::sun::star::uno::Reference;
83 using ::com::sun::star::frame::XFrame;
84
85 namespace {
86
87 class OutlineToImpressFinalizer
88 {
89 public:
90 OutlineToImpressFinalizer (
91 ::sd::ViewShellBase& rBase,
92 SdDrawDocument& rDocument,
93 SvLockBytes& rBytes);
~OutlineToImpressFinalizer(void)94 virtual ~OutlineToImpressFinalizer (void) {};
95 void operator() (bool bEventSeen);
96 private:
97 ::sd::ViewShellBase& mrBase;
98 SdDrawDocument& mrDocument;
99 ::boost::shared_ptr<SvMemoryStream> mpStream;
100 };
101
102
103 } // end of anonymous namespace
104
105
106 /*************************************************************************
107 |* Execute
108 \************************************************************************/
109
Execute(SfxRequest & rReq)110 void SdModule::Execute(SfxRequest& rReq)
111 {
112 const SfxItemSet* pSet = rReq.GetArgs();
113 sal_uLong nSlotId = rReq.GetSlot();
114
115 switch ( nSlotId )
116 {
117 case SID_NEWDOC:
118 {
119 SFX_APP()->ExecuteSlot(rReq, SFX_APP()->GetInterface());
120 }
121 break;
122
123 case SID_AUTOSPELL_CHECK:
124 {
125 // automatische Rechtschreibpruefung
126 const SfxPoolItem* pItem;
127 if( pSet && SFX_ITEM_SET == pSet->GetItemState(
128 SID_AUTOSPELL_CHECK, sal_False, &pItem ) )
129 {
130 sal_Bool bOnlineSpelling = ( (const SfxBoolItem*) pItem )->GetValue();
131 // am Dokument sichern:
132 ::sd::DrawDocShell* pDocSh = PTR_CAST(::sd::DrawDocShell, SfxObjectShell::Current());
133 if( pDocSh )
134 {
135 SdDrawDocument* pDoc = pDocSh->GetDoc();
136 pDoc->SetOnlineSpell( bOnlineSpelling );
137 }
138 }
139 }
140 break;
141
142 case SID_ATTR_METRIC:
143 {
144 const SfxPoolItem* pItem;
145 if ( pSet && SFX_ITEM_SET == pSet->GetItemState( SID_ATTR_METRIC, sal_True, &pItem ) )
146 {
147 FieldUnit eUnit = (FieldUnit)((const SfxUInt16Item*)pItem)->GetValue();
148 switch( eUnit )
149 {
150 case FUNIT_MM: // nur die Einheiten, die auch im Dialog stehen
151 case FUNIT_CM:
152 case FUNIT_INCH:
153 case FUNIT_PICA:
154 case FUNIT_POINT:
155 {
156 ::sd::DrawDocShell* pDocSh = PTR_CAST(::sd::DrawDocShell, SfxObjectShell::Current() );
157 if(pDocSh)
158 {
159 DocumentType eDocType = pDocSh->GetDoc()->GetDocumentType();
160
161 PutItem( *pItem );
162 SdOptions* pOptions = GetSdOptions( eDocType );
163 if(pOptions)
164 pOptions->SetMetric( (sal_uInt16)eUnit );
165 rReq.Done();
166 }
167 }
168 break;
169 default:
170 break;
171 }
172 }
173
174 }
175 break;
176
177 case SID_ATTR_LANGUAGE:
178 case SID_ATTR_CHAR_CJK_LANGUAGE:
179 case SID_ATTR_CHAR_CTL_LANGUAGE:
180 {
181 const SfxPoolItem* pItem;
182 if( pSet &&
183 (
184 SFX_ITEM_SET == pSet->GetItemState(SID_ATTR_LANGUAGE, sal_False, &pItem ) ||
185 SFX_ITEM_SET == pSet->GetItemState(SID_ATTR_CHAR_CJK_LANGUAGE, sal_False, &pItem ) ||
186 SFX_ITEM_SET == pSet->GetItemState(SID_ATTR_CHAR_CTL_LANGUAGE, sal_False, &pItem )
187 )
188 )
189 {
190 // am Dokument sichern:
191 ::sd::DrawDocShell* pDocSh = PTR_CAST(::sd::DrawDocShell, SfxObjectShell::Current());
192 if ( pDocSh )
193 {
194 LanguageType eLanguage = ( (SvxLanguageItem*)pItem )->GetValue();
195 SdDrawDocument* pDoc = pDocSh->GetDoc();
196
197 if( nSlotId == SID_ATTR_CHAR_CJK_LANGUAGE )
198 pDoc->SetLanguage( eLanguage, EE_CHAR_LANGUAGE_CJK );
199 else if( nSlotId == SID_ATTR_CHAR_CTL_LANGUAGE )
200 pDoc->SetLanguage( eLanguage, EE_CHAR_LANGUAGE_CTL );
201 else
202 pDoc->SetLanguage( eLanguage, EE_CHAR_LANGUAGE );
203
204 if( pDoc->GetOnlineSpell() )
205 {
206 pDoc->StopOnlineSpelling();
207 pDoc->StartOnlineSpelling();
208 }
209 }
210 }
211 }
212 break;
213
214 case SID_SD_AUTOPILOT:
215 case SID_NEWSD:
216 {
217 SfxFrame* pFrame = ExecuteNewDocument( rReq );
218 // #94442# if a frame was created, set it as return value
219 if(pFrame)
220 rReq.SetReturnValue(SfxFrameItem(0, pFrame));
221 }
222
223 break;
224
225 case SID_OPENHYPERLINK:
226 case SID_OPENDOC:
227 {
228 sal_Bool bIntercept = sal_False;
229 ::sd::DrawDocShell* pDocShell = PTR_CAST(::sd::DrawDocShell, SfxObjectShell::Current());
230 if (pDocShell)
231 {
232 ::sd::ViewShell* pViewShell = pDocShell->GetViewShell();
233 if (pViewShell)
234 {
235 if( sd::SlideShow::IsRunning( pViewShell->GetViewShellBase() ) )
236 {
237 // Prevent documents from opening while the slide
238 // show is running, except when this request comes
239 // from a shape interaction.
240 if (rReq.GetArgs() == NULL)
241 {
242 bIntercept = sal_True;
243 }
244 }
245 }
246 }
247
248 if (!bIntercept)
249 {
250 SFX_APP()->ExecuteSlot(rReq, SFX_APP()->GetInterface());
251 }
252 else
253 {
254 ErrorBox(NULL, WB_OK, String(SdResId(STR_CANT_PERFORM_IN_LIVEMODE))).Execute();
255
256 SFX_REQUEST_ARG( rReq, pLinkItem, SfxLinkItem, SID_DONELINK, sal_False );
257 if( pLinkItem )
258 pLinkItem->GetValue().Call( 0 );
259 }
260 }
261 break;
262
263 case SID_OUTLINE_TO_IMPRESS:
264 OutlineToImpress (rReq);
265 break;
266
267 default:
268 break;
269 }
270 }
271
272
273
274
OutlineToImpress(SfxRequest & rRequest)275 void SdModule::OutlineToImpress (SfxRequest& rRequest)
276 {
277 const SfxItemSet* pSet = rRequest.GetArgs();
278
279 if (pSet)
280 {
281 SvLockBytes* pBytes = ((SfxLockBytesItem&) pSet->Get(SID_OUTLINE_TO_IMPRESS)).GetValue();
282
283 if (pBytes)
284 {
285 SfxObjectShellLock xDocShell;
286 ::sd::DrawDocShell* pDocSh;
287 xDocShell = pDocSh = new ::sd::DrawDocShell(
288 SFX_CREATE_MODE_STANDARD, sal_False);
289 if(pDocSh)
290 {
291 pDocSh->DoInitNew(NULL);
292 SdDrawDocument* pDoc = pDocSh->GetDoc();
293 if(pDoc)
294 {
295 pDoc->CreateFirstPages();
296 pDoc->StopWorkStartupDelay();
297 }
298
299 SFX_REQUEST_ARG( rRequest, pFrmItem, SfxFrameItem, SID_DOCFRAME, sal_False);
300 SfxViewFrame::LoadDocumentIntoFrame( *pDocSh, pFrmItem, ::sd::OUTLINE_FACTORY_ID );
301
302 ::sd::ViewShell* pViewSh = pDocSh->GetViewShell();
303
304 if (pViewSh)
305 {
306 // AutoLayouts muessen fertig sein
307 pDoc->StopWorkStartupDelay();
308
309 SfxViewFrame* pViewFrame = pViewSh->GetViewFrame();
310
311 // When the view frame has not been just created we have
312 // to switch synchronously to the outline view.
313 // (Otherwise the request will be ignored anyway.)
314 ::sd::ViewShellBase* pBase
315 = dynamic_cast< ::sd::ViewShellBase*>(pViewFrame->GetViewShell());
316 if (pBase != NULL)
317 {
318 ::boost::shared_ptr<FrameworkHelper> pHelper (
319 FrameworkHelper::Instance(*pBase));
320 pHelper->RequestView(
321 FrameworkHelper::msOutlineViewURL,
322 FrameworkHelper::msCenterPaneURL);
323
324 pHelper->RunOnResourceActivation(
325 FrameworkHelper::CreateResourceId(
326 FrameworkHelper::msOutlineViewURL,
327 FrameworkHelper::msCenterPaneURL),
328 OutlineToImpressFinalizer(*pBase, *pDoc, *pBytes));
329 }
330 }
331 }
332 }
333 }
334
335 rRequest.IsDone();
336 }
337
338
339
340
341 /*************************************************************************
342 |* GetState
343 \************************************************************************/
344
345 static bool bOnce = false;
346
GetState(SfxItemSet & rItemSet)347 void SdModule::GetState(SfxItemSet& rItemSet)
348 {
349 // Autopilot waehrend der Praesentation disablen
350 if (rItemSet.GetItemState(SID_SD_AUTOPILOT) != SFX_ITEM_UNKNOWN)
351 {
352 if (!SvtModuleOptions().IsImpress())
353 {
354 rItemSet.DisableItem(SID_SD_AUTOPILOT);
355 }
356 else
357 {
358 ::sd::DrawDocShell* pDocShell = PTR_CAST(::sd::DrawDocShell, SfxObjectShell::Current());
359 if (pDocShell)
360 {
361 ::sd::ViewShell* pViewShell = pDocShell->GetViewShell();
362 if (pViewShell)
363 {
364 if( sd::SlideShow::IsRunning( pViewShell->GetViewShellBase() ) )
365 {
366 rItemSet.DisableItem(SID_SD_AUTOPILOT);
367 }
368 }
369 }
370 }
371 }
372
373 if( SFX_ITEM_AVAILABLE == rItemSet.GetItemState( SID_ATTR_METRIC ) )
374 {
375 ::sd::DrawDocShell* pDocSh = PTR_CAST(::sd::DrawDocShell, SfxObjectShell::Current() );
376 if(pDocSh)
377 {
378 DocumentType eDocType = pDocSh->GetDoc()->GetDocumentType();
379
380 SdOptions* pOptions = GetSdOptions(eDocType);
381 rItemSet.Put( SfxUInt16Item( SID_ATTR_METRIC, pOptions->GetMetric() ) );
382 }
383 }
384
385 // der Status von SID_OPENDOC wird von der Basisklasse bestimmt
386 if (rItemSet.GetItemState(SID_OPENDOC) != SFX_ITEM_UNKNOWN)
387 {
388 const SfxPoolItem* pItem = SFX_APP()->GetSlotState(SID_OPENDOC, SFX_APP()->GetInterface());
389 if (pItem)
390 rItemSet.Put(*pItem);
391 }
392
393 // der Status von SID_OPENHYPERLINK wird von der Basisklasse bestimmt
394 if (rItemSet.GetItemState(SID_OPENHYPERLINK) != SFX_ITEM_UNKNOWN)
395 {
396 const SfxPoolItem* pItem = SFX_APP()->GetSlotState(SID_OPENHYPERLINK, SFX_APP()->GetInterface());
397 if (pItem)
398 rItemSet.Put(*pItem);
399 }
400
401 if( SFX_ITEM_AVAILABLE == rItemSet.GetItemState( SID_AUTOSPELL_CHECK ) )
402 {
403 ::sd::DrawDocShell* pDocSh =
404 PTR_CAST(::sd::DrawDocShell, SfxObjectShell::Current());
405 if( pDocSh )
406 {
407 SdDrawDocument* pDoc = pDocSh->GetDoc();
408 rItemSet.Put( SfxBoolItem( SID_AUTOSPELL_CHECK, pDoc->GetOnlineSpell() ) );
409 }
410 }
411
412 if( SFX_ITEM_AVAILABLE == rItemSet.GetItemState( SID_ATTR_LANGUAGE ) )
413 {
414 ::sd::DrawDocShell* pDocSh = PTR_CAST(::sd::DrawDocShell, SfxObjectShell::Current());
415 if( pDocSh )
416 rItemSet.Put( SvxLanguageItem( pDocSh->GetDoc()->GetLanguage( EE_CHAR_LANGUAGE ), SID_ATTR_LANGUAGE ) );
417 }
418
419 if( SFX_ITEM_AVAILABLE == rItemSet.GetItemState( SID_ATTR_CHAR_CJK_LANGUAGE ) )
420 {
421 ::sd::DrawDocShell* pDocSh = PTR_CAST(::sd::DrawDocShell, SfxObjectShell::Current());
422 if( pDocSh )
423 rItemSet.Put( SvxLanguageItem( pDocSh->GetDoc()->GetLanguage( EE_CHAR_LANGUAGE_CJK ), SID_ATTR_CHAR_CJK_LANGUAGE ) );
424 }
425
426 if( SFX_ITEM_AVAILABLE == rItemSet.GetItemState( SID_ATTR_CHAR_CTL_LANGUAGE ) )
427 {
428 ::sd::DrawDocShell* pDocSh = PTR_CAST(::sd::DrawDocShell, SfxObjectShell::Current());
429 if( pDocSh )
430 rItemSet.Put( SvxLanguageItem( pDocSh->GetDoc()->GetLanguage( EE_CHAR_LANGUAGE_CTL ), SID_ATTR_CHAR_CTL_LANGUAGE ) );
431 }
432
433 if ( !bOnce )
434 {
435 ::sd::DrawDocShell* pDocShell = PTR_CAST(::sd::DrawDocShell, SfxObjectShell::Current());
436 if( pDocShell ) // Impress or Draw?
437 {
438 ::sd::ViewShell* pViewShell = pDocShell->GetViewShell();
439
440 if( pViewShell && (pDocShell->GetDocumentType() == DOCUMENT_TYPE_IMPRESS) )
441 {
442 // add our event listener as soon as possible
443 Application::AddEventListener( LINK( this, SdModule, EventListenerHdl ) );
444 bOnce = true;
445 }
446 }
447 }
448 }
449
IMPL_LINK(SdModule,EventListenerHdl,VclSimpleEvent *,pEvent)450 IMPL_LINK( SdModule, EventListenerHdl, VclSimpleEvent*, pEvent )
451 {
452 if( pEvent && (pEvent->GetId() == VCLEVENT_WINDOW_COMMAND) && static_cast<VclWindowEvent*>(pEvent)->GetData() )
453 {
454 const CommandEvent& rEvent = *(const CommandEvent*)static_cast<VclWindowEvent*>(pEvent)->GetData();
455
456 if( rEvent.GetCommand() == COMMAND_MEDIA )
457 {
458 switch( rEvent.GetMediaCommand() )
459 {
460 case MEDIA_COMMAND_PLAY:
461 {
462 ::sd::DrawDocShell* pDocShell = PTR_CAST(::sd::DrawDocShell, SfxObjectShell::Current());
463 if( pDocShell ) // Impress or Draw?
464 {
465 ::sd::ViewShell* pViewShell = pDocShell->GetViewShell();
466
467 // #i97925# start the presentation if and only if an Impress document is focused
468 if( pViewShell && (pDocShell->GetDocumentType() == DOCUMENT_TYPE_IMPRESS) )
469 pViewShell->GetViewFrame()->GetDispatcher()->Execute( SID_PRESENTATION );
470 }
471 }
472 break;
473
474 default:
475 break;
476 }
477 }
478 }
479 return 0;
480 }
481
482
AddSummaryPage(SfxViewFrame * pViewFrame,SdDrawDocument * pDocument)483 void SdModule::AddSummaryPage (SfxViewFrame* pViewFrame, SdDrawDocument* pDocument)
484 {
485 if( !pViewFrame || !pViewFrame->GetDispatcher() || !pDocument )
486 return;
487
488 pViewFrame->GetDispatcher()->Execute(SID_SUMMARY_PAGE,
489 SFX_CALLMODE_SYNCHRON | SFX_CALLMODE_RECORD);
490
491 OSL_ASSERT (pDocument!=NULL);
492
493 sal_Int32 nPageCount = pDocument->GetSdPageCount (PK_STANDARD);
494
495 // We need at least two pages: the summary page and one to use as
496 // template to take the transition parameters from.
497 if (nPageCount >= 2)
498 {
499 // Get a page from which to retrieve the transition parameters.
500 SdPage* pTemplatePage = pDocument->GetSdPage (0, PK_STANDARD);
501 OSL_ASSERT (pTemplatePage!=NULL);
502
503 // The summary page, if it exists, is the last page.
504 SdPage* pSummaryPage = pDocument->GetSdPage (
505 (sal_uInt16)nPageCount-1, PK_STANDARD);
506 OSL_ASSERT (pSummaryPage!=NULL);
507
508 // Take the change mode of the template page as indication of the
509 // document's kiosk mode.
510 pSummaryPage->setTransitionDuration(pTemplatePage->getTransitionDuration());
511 pSummaryPage->SetPresChange(pTemplatePage->GetPresChange());
512 pSummaryPage->SetTime(pTemplatePage->GetTime());
513 pSummaryPage->SetSound(pTemplatePage->IsSoundOn());
514 pSummaryPage->SetSoundFile(pTemplatePage->GetSoundFile());
515 pSummaryPage->setTransitionType(pTemplatePage->getTransitionType());
516 pSummaryPage->setTransitionSubtype(pTemplatePage->getTransitionSubtype());
517 pSummaryPage->setTransitionDirection(pTemplatePage->getTransitionDirection());
518 pSummaryPage->setTransitionFadeColor(pTemplatePage->getTransitionFadeColor());
519 pSummaryPage->setTransitionDuration(pTemplatePage->getTransitionDuration());
520 }
521 }
522
CreateFromTemplate(const String & rTemplatePath,const Reference<XFrame> & i_rFrame)523 SfxFrame* SdModule::CreateFromTemplate( const String& rTemplatePath, const Reference< XFrame >& i_rFrame )
524 {
525 SfxFrame* pFrame = 0;
526
527 SfxObjectShellLock xDocShell;
528
529 SfxItemSet* pSet = new SfxAllItemSet( SFX_APP()->GetPool() );
530 pSet->Put( SfxBoolItem( SID_TEMPLATE, sal_True ) );
531
532 sal_uLong lErr = SFX_APP()->LoadTemplate( xDocShell, rTemplatePath, sal_True, pSet );
533
534 SfxObjectShell* pDocShell = xDocShell;
535
536 if( lErr )
537 {
538 ErrorHandler::HandleError(lErr);
539 }
540 else if( pDocShell )
541 {
542 SfxViewFrame* pViewFrame = SfxViewFrame::LoadDocumentIntoFrame( *pDocShell, i_rFrame );
543 OSL_ENSURE( pViewFrame, "SdModule::CreateFromTemplate: no view frame - was the document really loaded?" );
544 pFrame = pViewFrame ? &pViewFrame->GetFrame() : NULL;
545 }
546
547 return pFrame;
548
549 }
550
ExecuteNewDocument(SfxRequest & rReq)551 SfxFrame* SdModule::ExecuteNewDocument( SfxRequest& rReq )
552 {
553 SfxFrame* pFrame = 0;
554 if ( SvtModuleOptions().IsImpress() )
555 {
556 Reference< XFrame > xTargetFrame;
557 SFX_REQUEST_ARG( rReq, pFrmItem, SfxUnoFrameItem, SID_FILLFRAME, sal_False);
558 if ( pFrmItem )
559 xTargetFrame = pFrmItem->GetFrame();
560
561 bool bMakeLayoutVisible = false;
562 SfxViewFrame* pViewFrame = NULL;
563
564 SdOptions* pOpt = GetSdOptions(DOCUMENT_TYPE_IMPRESS);
565 bool bStartWithTemplate = pOpt->IsStartWithTemplate();
566
567 bool bNewDocDirect = rReq.GetSlot() == SID_NEWSD;
568 if( bNewDocDirect && !bStartWithTemplate )
569 {
570 // we start without wizard
571
572 // check whether we should load a template document
573 const ::rtl::OUString aServiceName( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.presentation.PresentationDocument" ) );
574 String aStandardTemplate( SfxObjectFactory::GetStandardTemplate( aServiceName ) );
575
576 if( aStandardTemplate.Len() > 0 )
577 {
578 // load a template document
579 pFrame = CreateFromTemplate( aStandardTemplate, xTargetFrame );
580 }
581 else
582 {
583 // create an empty document
584 pFrame = CreateEmptyDocument( DOCUMENT_TYPE_IMPRESS, xTargetFrame );
585 bMakeLayoutVisible = true;
586 }
587 }
588 else
589 {
590 SdAbstractDialogFactory* pFact = SdAbstractDialogFactory::Create();
591 std::auto_ptr< AbstractAssistentDlg > pPilotDlg( pFact ? pFact->CreateAssistentDlg( NULL, !bNewDocDirect ) : 0 );
592
593 // Open the Pilot
594 if( pPilotDlg.get() && pPilotDlg->Execute()==RET_OK )
595 {
596 const String aDocPath( pPilotDlg->GetDocPath());
597 const sal_Bool bIsDocEmpty = pPilotDlg->IsDocEmpty();
598
599 // So that you can open the document without AutoLayout-Dialog
600 pOpt->SetStartWithTemplate(sal_False);
601 if(bNewDocDirect && !pPilotDlg->GetStartWithFlag())
602 bStartWithTemplate = sal_False;
603
604 if( pPilotDlg->GetStartType() == ST_OPEN )
605 {
606 String aFileToOpen = aDocPath;
607
608 DBG_ASSERT( aFileToOpen.Len()!=0, "The autopilot should have asked for a file itself already!" );
609 if(aFileToOpen.Len() != 0)
610 {
611 const String aPasswrd( pPilotDlg->GetPassword() );
612
613 SfxStringItem aFile( SID_FILE_NAME, aFileToOpen );
614 SfxStringItem aReferer( SID_REFERER, UniString() );
615 SfxStringItem aPassword( SID_PASSWORD, aPasswrd );
616
617 if ( xTargetFrame.is() )
618 {
619 SfxAllItemSet aSet( *rReq.GetArgs()->GetPool() );
620 aSet.Put( aFile );
621 aSet.Put( aReferer );
622 // Put the password into the request
623 // only if it is not empty.
624 if (aPasswrd.Len() > 0)
625 aSet.Put( aPassword );
626
627 const SfxPoolItem* pRet = SfxFrame::OpenDocumentSynchron( aSet, xTargetFrame );
628 const SfxViewFrameItem* pFrameItem = PTR_CAST( SfxViewFrameItem, pRet );
629 if ( pFrameItem && pFrameItem->GetFrame() )
630 pFrame = &pFrameItem->GetFrame()->GetFrame();
631 }
632 else
633 {
634 SfxRequest aRequest (SID_OPENDOC, SFX_CALLMODE_SYNCHRON, SFX_APP()->GetPool());
635 aRequest.AppendItem (aFile);
636 aRequest.AppendItem (aReferer);
637 // Put the password into the request
638 // only if it is not empty.
639 if (aPasswrd.Len() > 0)
640 aRequest.AppendItem (aPassword);
641 aRequest.AppendItem (SfxStringItem (
642 SID_TARGETNAME,
643 String (RTL_CONSTASCII_USTRINGPARAM ("_default"))));
644 try
645 {
646 const SfxPoolItem* pRet = SFX_APP()->ExecuteSlot (aRequest);
647 const SfxViewFrameItem* pFrameItem = PTR_CAST( SfxViewFrameItem, pRet );
648 if ( pFrameItem )
649 pFrame = &pFrameItem->GetFrame()->GetFrame();
650 }
651 catch (::com::sun::star::uno::Exception e)
652 {
653 DBG_ASSERT (sal_False, "caught IllegalArgumentException while loading document from Impress autopilot");
654 }
655 }
656 }
657
658 pOpt->SetStartWithTemplate(bStartWithTemplate);
659 if(bNewDocDirect && !bStartWithTemplate)
660 {
661 std::auto_ptr< SfxItemSet > pRet( CreateItemSet( SID_SD_EDITOPTIONS ) );
662 if(pRet.get())
663 ApplyItemSet( SID_SD_EDITOPTIONS, *pRet.get() );
664
665 }
666 }
667 else
668 {
669 SfxObjectShellLock xShell( pPilotDlg->GetDocument() );
670 SfxObjectShell* pShell = xShell;
671 if( pShell )
672 {
673 pViewFrame = SfxViewFrame::LoadDocumentIntoFrame( *pShell, xTargetFrame );
674 DBG_ASSERT( pViewFrame, "no ViewFrame!!" );
675 pFrame = pViewFrame ? &pViewFrame->GetFrame() : NULL;
676
677 if(bNewDocDirect && !bStartWithTemplate)
678 {
679 std::auto_ptr< SfxItemSet > pRet( CreateItemSet( SID_SD_EDITOPTIONS ) );
680 if(pRet.get())
681 ApplyItemSet( SID_SD_EDITOPTIONS, *pRet.get() );
682 }
683
684 if( pShell && pViewFrame )
685 {
686 ::sd::DrawDocShell* pDocShell =
687 PTR_CAST(::sd::DrawDocShell,pShell);
688 SdDrawDocument* pDoc = pDocShell->GetDoc();
689
690 ::sd::ViewShellBase* pBase =
691 ::sd::ViewShellBase::GetViewShellBase (
692 pViewFrame);
693 OSL_ASSERT (pBase!=NULL);
694 ::boost::shared_ptr<sd::ViewShell> pViewSh = pBase->GetMainViewShell();
695 SdOptions* pOptions = GetSdOptions(pDoc->GetDocumentType());
696
697 if (pOptions && pViewSh.get())
698 {
699 // The AutoPilot-document shall be open without its own options
700 ::sd::FrameView* pFrameView = pViewSh->GetFrameView();
701 pFrameView->Update(pOptions);
702 pViewSh->ReadFrameViewData(pFrameView);
703 }
704
705 ChangeMedium( pDocShell, pViewFrame, pPilotDlg->GetOutputMedium() );
706
707 if(pPilotDlg->IsSummary())
708 AddSummaryPage(pViewFrame, pDoc);
709
710 // empty document
711 if((aDocPath.Len() == 0) && pViewFrame && pViewFrame->GetDispatcher())
712 {
713 SfxBoolItem aIsChangedItem(SID_MODIFYPAGE, !bIsDocEmpty);
714 SfxUInt32Item eAutoLayout( ID_VAL_WHATLAYOUT, (sal_uInt32) AUTOLAYOUT_TITLE );
715 pViewFrame->GetDispatcher()->Execute(SID_MODIFYPAGE,
716 SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD, &aIsChangedItem, &eAutoLayout, 0L);
717 }
718
719 // clear document info
720 using namespace ::com::sun::star;
721 uno::Reference<document::XDocumentPropertiesSupplier> xDPS(
722 pDocShell->GetModel(), uno::UNO_QUERY_THROW);
723 uno::Reference<document::XDocumentProperties>
724 xDocProps(xDPS->getDocumentProperties());
725 DBG_ASSERT(xDocProps.is(), "no DocumentProperties");
726 xDocProps->resetUserData(
727 SvtUserOptions().GetFullName() );
728 xDocProps->setTemplateName(xDocProps->getTitle());
729 xDocProps->setTemplateURL(pPilotDlg->GetDocPath());
730
731 pDoc->SetChanged(!bIsDocEmpty);
732
733 pDocShell->SetUseUserData(sal_True);
734
735 // #94652# clear UNDO stack after autopilot
736 pDocShell->ClearUndoBuffer();
737
738 bMakeLayoutVisible = true;
739 }
740 }
741 pOpt->SetStartWithTemplate(bStartWithTemplate);
742 }
743 }
744 }
745 }
746
747 return pFrame;
748 }
749
CreateEmptyDocument(DocumentType eDocType,const Reference<XFrame> & i_rFrame)750 SfxFrame* SdModule::CreateEmptyDocument( DocumentType eDocType, const Reference< XFrame >& i_rFrame )
751 {
752 SfxFrame* pFrame = 0;
753
754 SfxObjectShellLock xDocShell;
755 ::sd::DrawDocShell* pNewDocSh;
756 xDocShell = pNewDocSh = new ::sd::DrawDocShell(SFX_CREATE_MODE_STANDARD,sal_False,eDocType);
757 if(pNewDocSh)
758 {
759 pNewDocSh->DoInitNew(NULL);
760 SdDrawDocument* pDoc = pNewDocSh->GetDoc();
761 if(pDoc)
762 {
763 pDoc->CreateFirstPages();
764 pDoc->StopWorkStartupDelay();
765 }
766
767 SfxViewFrame* pViewFrame = SfxViewFrame::LoadDocumentIntoFrame( *pNewDocSh, i_rFrame );
768 OSL_ENSURE( pViewFrame, "SdModule::CreateEmptyDocument: no view frame - was the document really loaded?" );
769 pFrame = pViewFrame ? &pViewFrame->GetFrame() : NULL;
770 }
771
772 return pFrame;
773 }
774
ChangeMedium(::sd::DrawDocShell * pDocShell,SfxViewFrame * pViewFrame,const sal_Int32 eMedium)775 void SdModule::ChangeMedium( ::sd::DrawDocShell* pDocShell, SfxViewFrame* pViewFrame, const sal_Int32 eMedium )
776 {
777 if( !pDocShell )
778 return;
779
780 SdDrawDocument* pDoc = pDocShell->GetDoc();
781 if( !pDoc )
782 return;
783
784 // settings for the Outputmedium
785 Size aNewSize;
786 sal_uInt32 nLeft = 0;
787 sal_uInt32 nRight = 0;
788 sal_uInt32 nLower = 0;
789 sal_uInt32 nUpper = 0;
790 switch(eMedium)
791 {
792 case OUTPUT_PAGE:
793 case OUTPUT_OVERHEAD:
794 {
795 SfxPrinter* pPrinter = pDocShell->GetPrinter(sal_True);
796
797 if( pPrinter && pPrinter->IsValid())
798 {
799 // Der Printer gibt leider kein exaktes
800 // Format (z.B. A4) zurueck
801 Size aSize(pPrinter->GetPaperSize());
802 Paper ePaper = SvxPaperInfo::GetSvxPaper( aSize, MAP_100TH_MM, sal_True);
803
804 if (ePaper != PAPER_USER)
805 {
806 // Get correct size
807 aSize = SvxPaperInfo::GetPaperSize(ePaper, MAP_100TH_MM);
808 }
809
810 if (aSize.Height() > aSize.Width())
811 {
812 // Always Landscape
813 aNewSize.Width() = aSize.Height();
814 aNewSize.Height() = aSize.Width();
815 }
816 else
817 {
818 aNewSize = aSize;
819 }
820 }
821 else
822 {
823 aNewSize=Size(29700, 21000);
824 }
825
826 if (eMedium == OUTPUT_PAGE)
827 {
828 nLeft =1000;
829 nRight=1000;
830 nUpper=1000;
831 nLower=1000;
832 }
833 else
834 {
835 nLeft =0;
836 nRight=0;
837 nUpper=0;
838 nLower=0;
839 }
840 }
841 break;
842
843 case OUTPUT_SLIDE:
844 {
845 aNewSize = Size(27000, 18000);
846 nLeft =0;
847 nRight=0;
848 nUpper=0;
849 nLower=0;
850 }
851 break;
852
853 case OUTPUT_PRESENTATION_4_BY_3:
854 {
855 aNewSize = Size(28000, 21000);
856 nLeft =0;
857 nRight=0;
858 nUpper=0;
859 nLower=0;
860 }
861 break;
862
863 case OUTPUT_PRESENTATION_16_BY_9: // not used yet
864 {
865 aNewSize = Size(28000, 15750);
866 nLeft =0;
867 nRight=0;
868 nUpper=0;
869 nLower=0;
870 }
871 break;
872
873 case OUTPUT_PRESENTATION_16_BY_10: // not used yet
874 {
875 aNewSize = Size(28000, 17500);
876 nLeft =0;
877 nRight=0;
878 nUpper=0;
879 nLower=0;
880 }
881 break;
882 }
883
884 sal_Bool bScaleAll = sal_True;
885 sal_uInt16 nPageCnt = pDoc->GetMasterSdPageCount(PK_STANDARD);
886 sal_uInt16 i;
887 SdPage* pPage;
888
889 // master pages first
890 for (i = 0; i < nPageCnt; i++)
891 {
892 pPage = pDoc->GetMasterSdPage(i, PK_STANDARD);
893
894 if (pPage)
895 {
896 if(eMedium != OUTPUT_ORIGINAL)
897 {
898 Rectangle aBorderRect(nLeft, nUpper, nRight, nLower);
899 pPage->ScaleObjects(aNewSize, aBorderRect, bScaleAll);
900 pPage->SetSize(aNewSize);
901 pPage->SetBorder(nLeft, nUpper, nRight, nLower);
902 }
903 SdPage* pNotesPage = pDoc->GetMasterSdPage(i, PK_NOTES);
904 DBG_ASSERT( pNotesPage, "Wrong page ordering!" );
905 if( pNotesPage ) pNotesPage->CreateTitleAndLayout();
906 pPage->CreateTitleAndLayout();
907 }
908 }
909
910 nPageCnt = pDoc->GetSdPageCount(PK_STANDARD);
911
912 // then slides
913 for (i = 0; i < nPageCnt; i++)
914 {
915 pPage = pDoc->GetSdPage(i, PK_STANDARD);
916
917 if (pPage)
918 {
919 if(eMedium != OUTPUT_ORIGINAL)
920 {
921 Rectangle aBorderRect(nLeft, nUpper, nRight, nLower);
922 pPage->ScaleObjects(aNewSize, aBorderRect, bScaleAll);
923 pPage->SetSize(aNewSize);
924 pPage->SetBorder(nLeft, nUpper, nRight, nLower);
925 }
926 SdPage* pNotesPage = pDoc->GetSdPage(i, PK_NOTES);
927 DBG_ASSERT( pNotesPage, "Wrong page ordering!" );
928 if( pNotesPage ) pNotesPage->SetAutoLayout( pNotesPage->GetAutoLayout() );
929 pPage->SetAutoLayout( pPage->GetAutoLayout() );
930 }
931 }
932
933 SdPage* pHandoutPage = pDoc->GetSdPage(0, PK_HANDOUT);
934 pHandoutPage->CreateTitleAndLayout(sal_True);
935
936 if( (eMedium != OUTPUT_ORIGINAL) && pViewFrame && pViewFrame->GetDispatcher())
937 {
938 pViewFrame->GetDispatcher()->Execute(SID_SIZE_PAGE, SFX_CALLMODE_SYNCHRON | SFX_CALLMODE_RECORD);
939 }
940 }
941
942
943
944
945 //===== OutlineToImpressFinalize ==============================================
946
947 namespace {
948
OutlineToImpressFinalizer(::sd::ViewShellBase & rBase,SdDrawDocument & rDocument,SvLockBytes & rBytes)949 OutlineToImpressFinalizer::OutlineToImpressFinalizer (
950 ::sd::ViewShellBase& rBase,
951 SdDrawDocument& rDocument,
952 SvLockBytes& rBytes)
953 : mrBase(rBase),
954 mrDocument(rDocument),
955 mpStream()
956 {
957 // The given stream has a lifetime shorter than this new
958 // OutlineToImpressFinalizer object. Therefore a local copy of the
959 // stream is created.
960 const SvStream* pStream (rBytes.GetStream());
961 if (pStream != NULL)
962 {
963 // Create a memory stream and prepare to fill it with the content of
964 // the original stream.
965 mpStream.reset(new SvMemoryStream());
966 static const sal_Size nBufferSize = 4096;
967 ::boost::scoped_array<sal_Int8> pBuffer (new sal_Int8[nBufferSize]);
968
969 sal_Size nReadPosition (0);
970 bool bLoop (true);
971 while (bLoop)
972 {
973 // Read the next part of the original stream.
974 sal_Size nReadByteCount (0);
975 const ErrCode nErrorCode (
976 rBytes.ReadAt(
977 nReadPosition,
978 reinterpret_cast<void*>(pBuffer.get()),
979 nBufferSize,
980 &nReadByteCount));
981
982 // Check the error code and stop copying the stream data when an
983 // error has occurred.
984 switch (nErrorCode)
985 {
986 case ERRCODE_NONE:
987 if (nReadByteCount == 0)
988 bLoop = false;
989 break;
990 case ERRCODE_IO_PENDING:
991 break;
992
993 default:
994 bLoop = false;
995 nReadByteCount = 0;
996 break;
997 }
998
999 // Append the read bytes to the end of the memory stream.
1000 if (nReadByteCount > 0)
1001 {
1002 mpStream->Write(reinterpret_cast<void*>(pBuffer.get()), nReadByteCount);
1003 nReadPosition += nReadByteCount;
1004 }
1005 }
1006
1007 // Rewind the memory stream so that in the operator() method its
1008 // content is properly read.
1009 mpStream->Seek(STREAM_SEEK_TO_BEGIN);
1010 }
1011 }
1012
1013
1014
1015
operator ()(bool)1016 void OutlineToImpressFinalizer::operator() (bool)
1017 {
1018 // Fetch the new outline view shell.
1019 ::sd::OutlineViewShell* pOutlineShell
1020 = dynamic_cast<sd::OutlineViewShell*>(FrameworkHelper::Instance(mrBase)->GetViewShell(FrameworkHelper::msCenterPaneURL).get());
1021
1022 if (pOutlineShell != NULL && mpStream.get() != NULL)
1023 {
1024 sd::OutlineView* pView = static_cast<sd::OutlineView*>(pOutlineShell->GetView());
1025 // mba: the stream can't contain any relative URLs, because we don't
1026 // have any information about a BaseURL!
1027 if ( pOutlineShell->Read(*mpStream, String(), EE_FORMAT_RTF) == 0 )
1028 {
1029 /*
1030 sd::OutlineViewPageChangesGuard aGuard( pView );
1031
1032 // Remove the first empty pages
1033 sal_uInt16 nPageCount = mrDocument.GetPageCount();
1034 mrDocument.RemovePage( --nPageCount ); // notes page
1035 mrDocument.RemovePage( --nPageCount ); // standard page
1036 */
1037 }
1038
1039 // Call UpdatePreview once for every slide to resync the
1040 // document with the outliner of the OutlineViewShell.
1041 sal_uInt16 nPageCount (mrDocument.GetSdPageCount(PK_STANDARD));
1042 for (sal_uInt16 nIndex=0; nIndex<nPageCount; nIndex++)
1043 {
1044 SdPage* pPage = mrDocument.GetSdPage(nIndex, PK_STANDARD);
1045 // Make the page the actual page so that the
1046 // following UpdatePreview() call accesses the
1047 // correct paragraphs.
1048 pView->SetActualPage(pPage);
1049 pOutlineShell->UpdatePreview(pPage, true);
1050 }
1051 // Select the first slide.
1052 SdPage* pPage = mrDocument.GetSdPage(0, PK_STANDARD);
1053 pView->SetActualPage(pPage);
1054 pOutlineShell->UpdatePreview(pPage, true);
1055 }
1056
1057
1058 // #97231# Undo-Stack needs to be cleared, else the user may remove the
1059 // only drawpage and this is a state we cannot handle ATM.
1060 ::sd::DrawDocShell* pDocShell = mrDocument.GetDocSh();
1061 if( pDocShell )
1062 pDocShell->ClearUndoBuffer();
1063 }
1064
1065
1066 } // end of anonymous namespace
1067
1068 /* vim: set noet sw=4 ts=4: */
1069