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); 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 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 Rechtschreibprüfung 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 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 müssen 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 347 void SdModule::GetState(SfxItemSet& rItemSet) 348 { 349 // Autopilot während der Präsentation 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 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 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 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 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 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 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) zurück 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 use 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_SCREEN_4_BY_3: 844 { 845 aNewSize = Size(28000, 21000); 846 nLeft =0; 847 nRight=0; 848 nUpper=0; 849 nLower=0; 850 } 851 break; 852 853 case OUTPUT_SCREEN_16_BY_9: 854 { 855 aNewSize = Size(28000, 15750); 856 nLeft =0; 857 nRight=0; 858 nUpper=0; 859 nLower=0; 860 } 861 break; 862 863 case OUTPUT_SCREEN_16_BY_10: 864 { 865 aNewSize = Size(28000, 17500); 866 nLeft =0; 867 nRight=0; 868 nUpper=0; 869 nLower=0; 870 } 871 break; 872 } 873 874 sal_Bool bScaleAll = sal_True; 875 sal_uInt16 nPageCnt = pDoc->GetMasterSdPageCount(PK_STANDARD); 876 sal_uInt16 i; 877 SdPage* pPage; 878 879 // master pages first 880 for (i = 0; i < nPageCnt; i++) 881 { 882 pPage = pDoc->GetMasterSdPage(i, PK_STANDARD); 883 884 if (pPage) 885 { 886 if(eMedium != OUTPUT_ORIGINAL) 887 { 888 Rectangle aBorderRect(nLeft, nUpper, nRight, nLower); 889 pPage->ScaleObjects(aNewSize, aBorderRect, bScaleAll); 890 pPage->SetSize(aNewSize); 891 pPage->SetBorder(nLeft, nUpper, nRight, nLower); 892 } 893 SdPage* pNotesPage = pDoc->GetMasterSdPage(i, PK_NOTES); 894 DBG_ASSERT( pNotesPage, "Wrong page ordering!" ); 895 if( pNotesPage ) pNotesPage->CreateTitleAndLayout(); 896 pPage->CreateTitleAndLayout(); 897 } 898 } 899 900 nPageCnt = pDoc->GetSdPageCount(PK_STANDARD); 901 902 // then slides 903 for (i = 0; i < nPageCnt; i++) 904 { 905 pPage = pDoc->GetSdPage(i, PK_STANDARD); 906 907 if (pPage) 908 { 909 if(eMedium != OUTPUT_ORIGINAL) 910 { 911 Rectangle aBorderRect(nLeft, nUpper, nRight, nLower); 912 pPage->ScaleObjects(aNewSize, aBorderRect, bScaleAll); 913 pPage->SetSize(aNewSize); 914 pPage->SetBorder(nLeft, nUpper, nRight, nLower); 915 } 916 SdPage* pNotesPage = pDoc->GetSdPage(i, PK_NOTES); 917 DBG_ASSERT( pNotesPage, "Wrong page ordering!" ); 918 if( pNotesPage ) pNotesPage->SetAutoLayout( pNotesPage->GetAutoLayout() ); 919 pPage->SetAutoLayout( pPage->GetAutoLayout() ); 920 } 921 } 922 923 SdPage* pHandoutPage = pDoc->GetSdPage(0, PK_HANDOUT); 924 pHandoutPage->CreateTitleAndLayout(sal_True); 925 926 if( (eMedium != OUTPUT_ORIGINAL) && pViewFrame && pViewFrame->GetDispatcher()) 927 { 928 pViewFrame->GetDispatcher()->Execute(SID_SIZE_PAGE, SFX_CALLMODE_SYNCHRON | SFX_CALLMODE_RECORD); 929 } 930 } 931 932 933 934 935 //===== OutlineToImpressFinalize ============================================== 936 937 namespace { 938 939 OutlineToImpressFinalizer::OutlineToImpressFinalizer ( 940 ::sd::ViewShellBase& rBase, 941 SdDrawDocument& rDocument, 942 SvLockBytes& rBytes) 943 : mrBase(rBase), 944 mrDocument(rDocument), 945 mpStream() 946 { 947 // The given stream has a lifetime shorter than this new 948 // OutlineToImpressFinalizer object. Therefore a local copy of the 949 // stream is created. 950 const SvStream* pStream (rBytes.GetStream()); 951 if (pStream != NULL) 952 { 953 // Create a memory stream and prepare to fill it with the content of 954 // the original stream. 955 mpStream.reset(new SvMemoryStream()); 956 static const sal_Size nBufferSize = 4096; 957 ::boost::scoped_array<sal_Int8> pBuffer (new sal_Int8[nBufferSize]); 958 959 sal_Size nReadPosition (0); 960 bool bLoop (true); 961 while (bLoop) 962 { 963 // Read the next part of the original stream. 964 sal_Size nReadByteCount (0); 965 const ErrCode nErrorCode ( 966 rBytes.ReadAt( 967 nReadPosition, 968 reinterpret_cast<void*>(pBuffer.get()), 969 nBufferSize, 970 &nReadByteCount)); 971 972 // Check the error code and stop copying the stream data when an 973 // error has occurred. 974 switch (nErrorCode) 975 { 976 case ERRCODE_NONE: 977 if (nReadByteCount == 0) 978 bLoop = false; 979 break; 980 case ERRCODE_IO_PENDING: 981 break; 982 983 default: 984 bLoop = false; 985 nReadByteCount = 0; 986 break; 987 } 988 989 // Append the read bytes to the end of the memory stream. 990 if (nReadByteCount > 0) 991 { 992 mpStream->Write(reinterpret_cast<void*>(pBuffer.get()), nReadByteCount); 993 nReadPosition += nReadByteCount; 994 } 995 } 996 997 // Rewind the memory stream so that in the operator() method its 998 // content is properly read. 999 mpStream->Seek(STREAM_SEEK_TO_BEGIN); 1000 } 1001 } 1002 1003 1004 1005 1006 void OutlineToImpressFinalizer::operator() (bool) 1007 { 1008 // Fetch the new outline view shell. 1009 ::sd::OutlineViewShell* pOutlineShell 1010 = dynamic_cast<sd::OutlineViewShell*>(FrameworkHelper::Instance(mrBase)->GetViewShell(FrameworkHelper::msCenterPaneURL).get()); 1011 1012 if (pOutlineShell != NULL && mpStream.get() != NULL) 1013 { 1014 sd::OutlineView* pView = static_cast<sd::OutlineView*>(pOutlineShell->GetView()); 1015 // mba: the stream can't contain any relative URLs, because we don't 1016 // have any information about a BaseURL! 1017 if ( pOutlineShell->Read(*mpStream, String(), EE_FORMAT_RTF) == 0 ) 1018 { 1019 /* 1020 sd::OutlineViewPageChangesGuard aGuard( pView ); 1021 1022 // Remove the first empty pages 1023 sal_uInt16 nPageCount = mrDocument.GetPageCount(); 1024 mrDocument.RemovePage( --nPageCount ); // notes page 1025 mrDocument.RemovePage( --nPageCount ); // standard page 1026 */ 1027 } 1028 1029 // Call UpdatePreview once for every slide to resync the 1030 // document with the outliner of the OutlineViewShell. 1031 sal_uInt16 nPageCount (mrDocument.GetSdPageCount(PK_STANDARD)); 1032 for (sal_uInt16 nIndex=0; nIndex<nPageCount; nIndex++) 1033 { 1034 SdPage* pPage = mrDocument.GetSdPage(nIndex, PK_STANDARD); 1035 // Make the page the actual page so that the 1036 // following UpdatePreview() call accesses the 1037 // correct paragraphs. 1038 pView->SetActualPage(pPage); 1039 pOutlineShell->UpdatePreview(pPage, true); 1040 } 1041 // Select the first slide. 1042 SdPage* pPage = mrDocument.GetSdPage(0, PK_STANDARD); 1043 pView->SetActualPage(pPage); 1044 pOutlineShell->UpdatePreview(pPage, true); 1045 } 1046 1047 1048 // #97231# Undo-Stack needs to be cleared, else the user may remove the 1049 // only drawpage and this is a state we cannot handle ATM. 1050 ::sd::DrawDocShell* pDocShell = mrDocument.GetDocSh(); 1051 if( pDocShell ) 1052 pDocShell->ClearUndoBuffer(); 1053 } 1054 1055 1056 } // end of anonymous namespace 1057 1058 /* vim: set noet sw=4 ts=4: */ 1059