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