/************************************************************************* * * OpenOffice.org - a multi-platform office productivity suite * * $RCSfile: sdmod1.cxx,v $ * * $Revision: 1.41 $ * * last change: $Author: obo $ $Date: 2006-09-16 18:31:41 $ * * The Contents of this file are made available subject to * the terms of GNU Lesser General Public License Version 2.1. * * * GNU Lesser General Public License Version 2.1 * ============================================= * Copyright 2005 by Sun Microsystems, Inc. * 901 San Antonio Road, Palo Alto, CA 94303, USA * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License version 2.1, as published by the Free Software Foundation. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * MA 02111-1307 USA * ************************************************************************/ // MARKER(update_precomp.py): autogen include statement, do not remove #include "precompiled_sd.hxx" #include #ifndef _SFXFRAME_HXX //autogen #include #endif #ifndef _SFXVIEWFRM_HXX //autogen #include #endif #ifndef INCLUDED_SVTOOLS_MODULEOPTIONS_HXX #include #endif #include #define ITEMID_LANGUAGE SID_ATTR_LANGUAGE #include #include #ifndef _SV_MSGBOX_HXX //autogen #include #endif #ifndef _SVX_SVXENUM_HXX //autogen #include #endif #ifndef _SFXDISPATCH_HXX //autogen #include #endif #ifndef _SFXREQUEST_HXX //autogen #include #endif #ifndef _SFX_PRINTER_HXX //autogen #include #endif #ifndef _SFXDOCFILE_HXX //autogen #include #endif #ifndef _SVX_PAPERINF_HXX //autogen #include #endif #ifndef _EEITEM_HXX #include #endif #ifndef INCLUDED_SVTOOLS_USEROPTIONS_HXX #include #endif #include "app.hrc" #include "glob.hrc" #include "strings.hrc" #include "res_bmp.hrc" #define _SD_DLL // fuer SD_MOD() #include "sdmod.hxx" #include "sddll.hxx" #include "pres.hxx" #include "optsitem.hxx" #ifndef SD_VIEW_SHELL_HXX #include "ViewShell.hxx" #endif #include "sdattr.hxx" #include "sdpage.hxx" #ifndef SD_DRAW_DOC_SHELL_HXX #include "DrawDocShell.hxx" #endif #include "drawdoc.hxx" #include "assclass.hxx" //CHINA001 #include "dlgass.hxx" #include "sdenumdef.hxx" //CHINA001 #include "sdresid.hxx" #ifndef SD_OUTLINE_VIEW_SHELL_HXX #include "OutlineViewShell.hxx" #endif #include "PaneManager.hxx" #ifndef SD_VIEW_SHELL_BASE_HXX #include "ViewShellBase.hxx" #endif #include "TaskPaneViewShell.hxx" #ifndef SD_FRAMW_VIEW_HXX #include "FrameView.hxx" #endif #ifndef SD_FACTORY_IDS_HXX #include "FactoryIds.hxx" #endif #include "sdabstdlg.hxx" //CHINA001 #include "dlgass.hrc" //CHINA001 #include /************************************************************************* |* |* Execute |* \************************************************************************/ void SdModule::Execute(SfxRequest& rReq) { const SfxItemSet* pSet = rReq.GetArgs(); ULONG nSlotId = rReq.GetSlot(); switch ( nSlotId ) { case SID_NEWDOC: { SFX_APP()->ExecuteSlot(rReq, SFX_APP()->GetInterface()); } break; case SID_AUTOSPELL_CHECK: { // automatische Rechtschreibpruefung const SfxPoolItem* pItem; if( pSet && SFX_ITEM_SET == pSet->GetItemState( SID_AUTOSPELL_CHECK, FALSE, &pItem ) ) { BOOL bOnlineSpelling = ( (const SfxBoolItem*) pItem )->GetValue(); // am Dokument sichern: ::sd::DrawDocShell* pDocSh = PTR_CAST(::sd::DrawDocShell, SfxObjectShell::Current()); if( pDocSh ) { SdDrawDocument* pDoc = pDocSh->GetDoc(); pDoc->SetOnlineSpell( bOnlineSpelling ); } } } break; case SID_AUTOSPELL_MARKOFF: { const SfxPoolItem* pItem; if( pSet && SFX_ITEM_SET == pSet->GetItemState( SID_AUTOSPELL_MARKOFF, FALSE, &pItem ) ) { BOOL bHideSpell = ( (const SfxBoolItem*) pItem )->GetValue(); // am Dokument sichern: ::sd::DrawDocShell* pDocSh = PTR_CAST(::sd::DrawDocShell, SfxObjectShell::Current()); if( pDocSh ) { SdDrawDocument* pDoc = pDocSh->GetDoc(); pDoc->SetHideSpell( bHideSpell ); } } } break; case SID_ATTR_METRIC: { const SfxPoolItem* pItem; if ( pSet && SFX_ITEM_SET == pSet->GetItemState( SID_ATTR_METRIC, TRUE, &pItem ) ) { FieldUnit eUnit = (FieldUnit)((const SfxUInt16Item*)pItem)->GetValue(); switch( eUnit ) { case FUNIT_MM: // nur die Einheiten, die auch im Dialog stehen case FUNIT_CM: case FUNIT_INCH: case FUNIT_PICA: case FUNIT_POINT: { ::sd::DrawDocShell* pDocSh = PTR_CAST(::sd::DrawDocShell, SfxObjectShell::Current() ); if(pDocSh) { DocumentType eDocType = pDocSh->GetDoc()->GetDocumentType(); PutItem( *pItem ); SdOptions* pOptions = GetSdOptions( eDocType ); if(pOptions) pOptions->SetMetric( eUnit ); rReq.Done(); } } break; } } } break; case SID_ATTR_LANGUAGE: case SID_ATTR_CHAR_CJK_LANGUAGE: case SID_ATTR_CHAR_CTL_LANGUAGE: { const SfxPoolItem* pItem; if( pSet && SFX_ITEM_SET == pSet->GetItemState(SID_ATTR_LANGUAGE, FALSE, &pItem ) || SFX_ITEM_SET == pSet->GetItemState(SID_ATTR_CHAR_CJK_LANGUAGE, FALSE, &pItem ) || SFX_ITEM_SET == pSet->GetItemState(SID_ATTR_CHAR_CTL_LANGUAGE, FALSE, &pItem ) ) { // am Dokument sichern: ::sd::DrawDocShell* pDocSh = PTR_CAST(::sd::DrawDocShell, SfxObjectShell::Current()); if ( pDocSh ) { LanguageType eLanguage = ( (SvxLanguageItem*)pItem )->GetValue(); SdDrawDocument* pDoc = pDocSh->GetDoc(); if( nSlotId == SID_ATTR_CHAR_CJK_LANGUAGE ) pDoc->SetLanguage( eLanguage, EE_CHAR_LANGUAGE_CJK ); else if( nSlotId == SID_ATTR_CHAR_CTL_LANGUAGE ) pDoc->SetLanguage( eLanguage, EE_CHAR_LANGUAGE_CTL ); else pDoc->SetLanguage( eLanguage, EE_CHAR_LANGUAGE ); if( pDoc->GetOnlineSpell() ) { pDoc->StopOnlineSpelling(); pDoc->StartOnlineSpelling(); } } } } break; case SID_SD_AUTOPILOT: case SID_NEWSD: { SfxFrame* pFrame = ExecuteNewDocument( rReq ); // #94442# if a frame was created, set it as return value if(pFrame) rReq.SetReturnValue(SfxFrameItem(0, pFrame)); } break; case SID_OPENDOC: { BOOL bIntercept = FALSE; ::sd::DrawDocShell* pDocShell = PTR_CAST(::sd::DrawDocShell, SfxObjectShell::Current()); if (pDocShell) { ::sd::ViewShell* pViewShell = pDocShell->GetViewShell(); if (pViewShell) { if (pViewShell->GetSlideShow()) { const SfxItemSet* pSet = rReq.GetArgs(); if (pSet == NULL) { // e.g. open button during a presentation. bIntercept = TRUE; } } } } if (!bIntercept) { SFX_APP()->ExecuteSlot(rReq, SFX_APP()->GetInterface()); } else { ErrorBox(NULL, WB_OK, String(SdResId(STR_CANT_PERFORM_IN_LIVEMODE))).Execute(); SFX_REQUEST_ARG( rReq, pLinkItem, SfxLinkItem, SID_DONELINK, FALSE ); if( pLinkItem ) pLinkItem->GetValue().Call( 0 ); } } break; case SID_OUTLINE_TO_IMPRESS: OutlineToImpress (rReq); break; default: break; } } void SdModule::OutlineToImpress (SfxRequest& rRequest) { const SfxItemSet* pSet = rRequest.GetArgs(); if (pSet) { SvLockBytes* pBytes = ((SfxLockBytesItem&) pSet->Get(SID_OUTLINE_TO_IMPRESS)).GetValue(); if (pBytes) { SfxObjectShellLock xDocShell; ::sd::DrawDocShell* pDocSh; xDocShell = pDocSh = new ::sd::DrawDocShell( SFX_CREATE_MODE_STANDARD, FALSE); if(pDocSh) { pDocSh->DoInitNew(NULL); SdDrawDocument* pDoc = pDocSh->GetDoc(); if(pDoc) { pDoc->CreateFirstPages(); pDoc->StopWorkStartupDelay(); } SFX_REQUEST_ARG( rRequest, pFrmItem, SfxFrameItem, SID_DOCFRAME, FALSE); if ( pFrmItem ) { SfxFrame* pFrame = pFrmItem->GetFrame(); pFrame->InsertDocument( pDocSh ); } else SfxViewFrame::CreateViewFrame(*pDocSh, ::sd::OUTLINE_FACTORY_ID); ::sd::ViewShell* pViewSh = pDocSh->GetViewShell(); if (pViewSh) { // AutoLayouts muessen fertig sein SdDrawDocument* pDoc = pDocSh->GetDoc(); pDoc->StopWorkStartupDelay(); SfxViewFrame* pViewFrame = pViewSh->GetViewFrame(); // When the view frame has not been just created // we have to switch synchronously to the outline // view. (Otherwise the request will be ignored // anyway.) ::sd::ViewShellBase* pBase = static_cast< ::sd::ViewShellBase*>( pViewFrame->GetViewShell()); pBase->GetPaneManager().RequestMainViewShellChange ( ::sd::ViewShell::ST_OUTLINE, ::sd::PaneManager::CM_SYNCHRONOUS); // Fetch the new outline view shell. ::sd::OutlineViewShell* pOutlineShell = PTR_CAST(::sd::OutlineViewShell, pBase->GetMainViewShell()); if (pOutlineShell != NULL) { sd::OutlineView* pView = static_cast(pOutlineShell->GetView()); SvStream* pStream = (SvStream*) pBytes->GetStream(); // mba: the stream can't contain any relative URLs, because we don't have any information about a BaseURL! if ( pOutlineShell->Read(*pStream, String(), EE_FORMAT_RTF) == 0 ) { sd::OutlineViewPageChangesGuard aGuard( pView ); // Remove the first empty pages USHORT nPageCount = pDoc->GetPageCount(); pDoc->RemovePage( --nPageCount ); // notes page pDoc->RemovePage( --nPageCount ); // standard page } // Call UpdatePreview once for every slide to resync the // document with the outliner of the OutlineViewShell. USHORT nPageCount (pDoc->GetSdPageCount(PK_STANDARD)); for (USHORT nIndex=0; nIndexGetSdPage(nIndex, PK_STANDARD); // Make the page the actual page so that the // following UpdatePreview() call accesses the // correct paragraphs. pView->SetActualPage(pPage); pOutlineShell->UpdatePreview(pPage, true); } // Select the first slide. SdPage* pPage = pDoc->GetSdPage(0, PK_STANDARD); pView->SetActualPage(pPage); pOutlineShell->UpdatePreview(pPage, true); } } // #97231# Undo-Stack needs to be cleared, else the user may remove the // only drawpage and this is a state we cannot handle ATM. SfxUndoManager* pUndoManager = pDocSh->GetUndoManager(); DBG_ASSERT(pUndoManager, "No UNDO MANAGER ?!?"); if(pUndoManager->GetUndoActionCount()) pUndoManager->Clear(); } } } rRequest.IsDone(); } /************************************************************************* |* |* GetState |* \************************************************************************/ void SdModule::GetState(SfxItemSet& rItemSet) { // Autopilot waehrend der Praesentation disablen if (rItemSet.GetItemState(SID_SD_AUTOPILOT) != SFX_ITEM_UNKNOWN) { if (!SvtModuleOptions().IsImpress()) { rItemSet.DisableItem(SID_SD_AUTOPILOT); } else { ::sd::DrawDocShell* pDocShell = PTR_CAST(::sd::DrawDocShell, SfxObjectShell::Current()); if (pDocShell) { ::sd::ViewShell* pViewShell = pDocShell->GetViewShell(); if (pViewShell) { if (pViewShell->GetSlideShow()) { rItemSet.DisableItem(SID_SD_AUTOPILOT); } } } } } if( SFX_ITEM_AVAILABLE == rItemSet.GetItemState( SID_ATTR_METRIC ) ) { ::sd::DrawDocShell* pDocSh = PTR_CAST(::sd::DrawDocShell, SfxObjectShell::Current() ); if(pDocSh) { DocumentType eDocType = pDocSh->GetDoc()->GetDocumentType(); SdOptions* pOptions = GetSdOptions(eDocType); rItemSet.Put( SfxUInt16Item( SID_ATTR_METRIC, pOptions->GetMetric() ) ); } } // der Status von SID_OPENDOC wird von der Basisklasse bestimmt if (rItemSet.GetItemState(SID_OPENDOC) != SFX_ITEM_UNKNOWN) { const SfxPoolItem* pItem = SFX_APP()->GetSlotState(SID_OPENDOC, SFX_APP()->GetInterface()); if (pItem) rItemSet.Put(*pItem); } if( SFX_ITEM_AVAILABLE == rItemSet.GetItemState( SID_AUTOSPELL_CHECK ) || SFX_ITEM_AVAILABLE == rItemSet.GetItemState( SID_AUTOSPELL_MARKOFF ) ) { ::sd::DrawDocShell* pDocSh = PTR_CAST(::sd::DrawDocShell, SfxObjectShell::Current()); if( pDocSh ) { SdDrawDocument* pDoc = pDocSh->GetDoc(); rItemSet.Put( SfxBoolItem( SID_AUTOSPELL_CHECK, pDoc->GetOnlineSpell() ) ); rItemSet.Put( SfxBoolItem( SID_AUTOSPELL_MARKOFF, pDoc->GetHideSpell() ) ); } } if( SFX_ITEM_AVAILABLE == rItemSet.GetItemState( SID_ATTR_LANGUAGE ) ) { ::sd::DrawDocShell* pDocSh = PTR_CAST(::sd::DrawDocShell, SfxObjectShell::Current()); if( pDocSh ) rItemSet.Put( SvxLanguageItem( pDocSh->GetDoc()->GetLanguage( EE_CHAR_LANGUAGE ), SID_ATTR_LANGUAGE ) ); } if( SFX_ITEM_AVAILABLE == rItemSet.GetItemState( SID_ATTR_CHAR_CJK_LANGUAGE ) ) { ::sd::DrawDocShell* pDocSh = PTR_CAST(::sd::DrawDocShell, SfxObjectShell::Current()); if( pDocSh ) rItemSet.Put( SvxLanguageItem( pDocSh->GetDoc()->GetLanguage( EE_CHAR_LANGUAGE_CJK ), SID_ATTR_CHAR_CJK_LANGUAGE ) ); } if( SFX_ITEM_AVAILABLE == rItemSet.GetItemState( SID_ATTR_CHAR_CTL_LANGUAGE ) ) { ::sd::DrawDocShell* pDocSh = PTR_CAST(::sd::DrawDocShell, SfxObjectShell::Current()); if( pDocSh ) rItemSet.Put( SvxLanguageItem( pDocSh->GetDoc()->GetLanguage( EE_CHAR_LANGUAGE_CTL ), SID_ATTR_CHAR_CTL_LANGUAGE ) ); } } void SdModule::AddSummaryPage (SfxViewFrame* pViewFrame, SdDrawDocument* pDocument) { if( !pViewFrame || !pViewFrame->GetDispatcher() || !pDocument ) return; pViewFrame->GetDispatcher()->Execute(SID_SUMMARY_PAGE, SFX_CALLMODE_SYNCHRON | SFX_CALLMODE_RECORD); OSL_ASSERT (pDocument!=NULL); sal_Int32 nPageCount = pDocument->GetSdPageCount (PK_STANDARD); // We need at least two pages: the summary page and one to use as // template to take the transition parameters from. if (nPageCount >= 2) { // Get a page from which to retrieve the transition parameters. SdPage* pTemplatePage = pDocument->GetSdPage (0, PK_STANDARD); OSL_ASSERT (pTemplatePage!=NULL); // The summary page, if it exists, is the last page. SdPage* pSummaryPage = pDocument->GetSdPage ( (USHORT)nPageCount-1, PK_STANDARD); OSL_ASSERT (pSummaryPage!=NULL); // Take the change mode of the template page as indication of the // document's kiosk mode. pSummaryPage->setTransitionDuration(pTemplatePage->getTransitionDuration()); pSummaryPage->SetPresChange(pTemplatePage->GetPresChange()); pSummaryPage->SetTime(pTemplatePage->GetTime()); pSummaryPage->SetSound(pTemplatePage->IsSoundOn()); pSummaryPage->SetSoundFile(pTemplatePage->GetSoundFile()); pSummaryPage->setTransitionType(pTemplatePage->getTransitionType()); pSummaryPage->setTransitionSubtype(pTemplatePage->getTransitionSubtype()); pSummaryPage->setTransitionDirection(pTemplatePage->getTransitionDirection()); pSummaryPage->setTransitionFadeColor(pTemplatePage->getTransitionFadeColor()); pSummaryPage->setTransitionDuration(pTemplatePage->getTransitionDuration()); } } SfxFrame* SdModule::CreateFromTemplate( const String& rTemplatePath, SfxFrame* pTargetFrame ) { SfxFrame* pFrame = 0; SfxObjectShellLock xDocShell; SfxItemSet* pSet = new SfxAllItemSet( SFX_APP()->GetPool() ); pSet->Put( SfxBoolItem( SID_TEMPLATE, TRUE ) ); ULONG lErr = SFX_APP()->LoadTemplate( xDocShell, rTemplatePath, TRUE, pSet ); SfxObjectShell* pDocShell = xDocShell; if( lErr ) { ErrorHandler::HandleError(lErr); } else if( pDocShell ) { if ( pTargetFrame ) { pFrame = pTargetFrame; pFrame->InsertDocument( pDocShell ); } else { SfxViewFrame* pViewFrame = SfxViewFrame::CreateViewFrame( *pDocShell ); if( pViewFrame ) pFrame = pViewFrame->GetFrame(); } } return pFrame; } SfxFrame* SdModule::ExecuteNewDocument( SfxRequest& rReq ) { SfxFrame* pFrame = 0; if ( SvtModuleOptions().IsImpress() ) { SfxFrame* pTargetFrame = 0; SFX_REQUEST_ARG( rReq, pFrmItem, SfxFrameItem, SID_DOCFRAME, FALSE); if ( pFrmItem ) pTargetFrame = pFrmItem->GetFrame(); bool bMakeLayoutVisible = false; SfxViewFrame* pViewFrame = NULL; SdOptions* pOpt = GetSdOptions(DOCUMENT_TYPE_IMPRESS); bool bStartWithTemplate = pOpt->IsStartWithTemplate(); bool bNewDocDirect = rReq.GetSlot() == SID_NEWSD; if( bNewDocDirect && !bStartWithTemplate ) { //we start without wizard //check wether we should load a template document const ::rtl::OUString aServiceName( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.presentation.PresentationDocument" ) ); String aStandardTemplate( SfxObjectFactory::GetStandardTemplate( aServiceName ) ); if( aStandardTemplate.Len() > 0 ) { //load a template document pFrame = CreateFromTemplate( aStandardTemplate, pTargetFrame ); } else { //create an empty document pFrame = CreateEmptyDocument( DOCUMENT_TYPE_IMPRESS, pTargetFrame ); bMakeLayoutVisible = true; } } else { String aFileToOpen; SdAbstractDialogFactory* pFact = SdAbstractDialogFactory::Create(); std::auto_ptr< AbstractAssistentDlg > pPilotDlg; if( pFact ) { pPilotDlg.reset( pFact->CreateAssistentDlg(ResId( DLG_ASS ), NULL, !bNewDocDirect ) ); } DBG_ASSERT(pPilotDlg.get(), "Dialogdiet fail!"); // Open the Pilot if( pPilotDlg.get() && pPilotDlg->Execute()==RET_OK ) { const String aDocPath( pPilotDlg->GetDocPath()); const sal_Bool bIsDocEmpty = pPilotDlg->IsDocEmpty(); // So that you can open the document without AutoLayout-Dialog pOpt->SetStartWithTemplate(FALSE); if(bNewDocDirect && !pPilotDlg->GetStartWithFlag()) bStartWithTemplate = FALSE; if( pPilotDlg->GetStartType() == ST_OPEN ) { String aFileToOpen = aDocPath; DBG_ASSERT( aFileToOpen.Len()!=0, "The autopilot should have asked for a file itself already!" ); if(aFileToOpen.Len() != 0) { const String aPasswrd( pPilotDlg->GetPassword() ); SfxStringItem aFile( SID_FILE_NAME, aFileToOpen ); SfxStringItem aReferer( SID_REFERER, UniString() ); SfxStringItem aPassword( SID_PASSWORD, aPasswrd ); if ( pTargetFrame ) { SfxAllItemSet aSet( *rReq.GetArgs()->GetPool() ); aSet.Put( aFile ); aSet.Put( aReferer ); // Put the password into the request // only if it is not empty. if (aPasswrd.Len() > 0) aSet.Put( aPassword ); const SfxPoolItem* pRet = pTargetFrame->LoadDocumentSynchron( aSet ); const SfxViewFrameItem* pFrameItem = PTR_CAST( SfxViewFrameItem, pRet ); if ( pFrameItem && pFrameItem->GetFrame() ) pFrame = pFrameItem->GetFrame()->GetFrame(); } else { SfxRequest aRequest (SID_OPENDOC, SFX_CALLMODE_SYNCHRON, SFX_APP()->GetPool()); aRequest.AppendItem (aFile); aRequest.AppendItem (aReferer); // Put the password into the request // only if it is not empty. if (aPasswrd.Len() > 0) aRequest.AppendItem (aPassword); aRequest.AppendItem (SfxStringItem ( SID_TARGETNAME, String (RTL_CONSTASCII_USTRINGPARAM ("_default")))); try { const SfxPoolItem* pRet = SFX_APP()->ExecuteSlot (aRequest); const SfxViewFrameItem* pFrameItem = PTR_CAST( SfxViewFrameItem, pRet ); if ( pFrameItem ) pFrame = pFrameItem->GetFrame()->GetFrame(); } catch (::com::sun::star::uno::Exception e) { DBG_ASSERT (FALSE, "caught IllegalArgumentException while loading document from Impress autopilot"); } } } pOpt->SetStartWithTemplate(bStartWithTemplate); if(bNewDocDirect && !bStartWithTemplate) { std::auto_ptr< SfxItemSet > pRet( CreateItemSet( SID_SD_EDITOPTIONS ) ); if(pRet.get()) ApplyItemSet( SID_SD_EDITOPTIONS, *pRet.get() ); } } else { SfxObjectShellLock xShell( pPilotDlg->GetDocument() ); SfxObjectShell* pShell = xShell; if( pShell ) { if ( pTargetFrame ) { pFrame = pTargetFrame; pFrame->InsertDocument( pShell ); pViewFrame = pFrame->GetCurrentViewFrame(); } else { pViewFrame = SfxViewFrame::CreateViewFrame( *pShell ); if( pViewFrame ) pFrame = pViewFrame->GetFrame(); } DBG_ASSERT( pViewFrame, "no ViewFrame!!" ); if(bNewDocDirect && !bStartWithTemplate) { std::auto_ptr< SfxItemSet > pRet( CreateItemSet( SID_SD_EDITOPTIONS ) ); if(pRet.get()) ApplyItemSet( SID_SD_EDITOPTIONS, *pRet.get() ); } if( pShell && pViewFrame ) { ::sd::DrawDocShell* pDocShell = PTR_CAST(::sd::DrawDocShell,pShell); SdDrawDocument* pDoc = pDocShell->GetDoc(); ::sd::ViewShellBase* pBase = ::sd::ViewShellBase::GetViewShellBase ( pViewFrame); OSL_ASSERT (pBase!=NULL); ::sd::ViewShell* pViewSh = pBase->GetMainViewShell (); SdOptions* pOptions = GetSdOptions(pDoc->GetDocumentType()); if (pOptions && pViewSh) { // The AutoPilot-document shall be open without its own options ::sd::FrameView* pFrameView = pViewSh->GetFrameView(); pFrameView->Update(pOptions); pViewSh->ReadFrameViewData(pFrameView); } const sal_Int32 eMedium = pPilotDlg->GetOutputMedium(); ChangeMedium( pDocShell, pViewFrame, pPilotDlg->GetOutputMedium() ); if(pPilotDlg->IsSummary()) AddSummaryPage(pViewFrame, pDoc); // empty document if((aDocPath.Len() == 0) && pViewFrame && pViewFrame->GetDispatcher()) { SfxBoolItem aIsChangedItem(SID_MODIFYPAGE, !bIsDocEmpty); SfxUInt32Item eAutoLayout( ID_VAL_WHATLAYOUT, (UINT32) AUTOLAYOUT_TITLE ); pViewFrame->GetDispatcher()->Execute(SID_MODIFYPAGE, SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD, &aIsChangedItem, &eAutoLayout, 0L); } pDoc->SetChanged(!bIsDocEmpty); // clear document info SfxDocumentInfo& rInfo = pDocShell->GetDocInfo(); SfxStamp aCreated; SvtUserOptions aOptions; aCreated.SetName( aOptions.GetFullName() ); rInfo.SetCreated( aCreated ); SfxStamp aInvalid( TIMESTAMP_INVALID_DATETIME ); rInfo.SetChanged( aInvalid ); rInfo.SetPrinted( aInvalid ); rInfo.SetTime( 0L ); rInfo.SetDocumentNumber( 1 ); rInfo.SetUseUserData( TRUE ); // #94652# clear UNDO stack after autopilot SfxUndoManager* pUndoManager = pDocShell->GetUndoManager(); DBG_ASSERT(pUndoManager, "No UNDO MANAGER ?!?"); if(pUndoManager && pUndoManager->GetUndoActionCount()) pUndoManager->Clear(); bMakeLayoutVisible = true; } } pOpt->SetStartWithTemplate(bStartWithTemplate); } } } if( bMakeLayoutVisible ) { SfxDispatcher* pDispatcher = 0; if( !pViewFrame && pFrame ) pViewFrame = pFrame->GetCurrentViewFrame(); if( pViewFrame ) pDispatcher = pViewFrame->GetDispatcher(); if( pDispatcher ) { // Make the layout menu visible in the tool pane. SfxBoolItem aMakeToolPaneVisible (ID_VAL_ISVISIBLE, TRUE); SfxUInt32Item aPanelId (ID_VAL_PANEL_INDEX, ::sd::toolpanel::TaskPaneViewShell::PID_LAYOUT); pDispatcher->Execute( SID_TASK_PANE, SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD, &aMakeToolPaneVisible, &aPanelId, NULL); } } } return pFrame; } SfxFrame* SdModule::CreateEmptyDocument( DocumentType eDocType, SfxFrame* pTargetFrame ) { SfxFrame* pFrame = 0; SfxObjectShellLock xDocShell; ::sd::DrawDocShell* pNewDocSh; xDocShell = pNewDocSh = new ::sd::DrawDocShell(SFX_CREATE_MODE_STANDARD,FALSE,eDocType); if(pNewDocSh) { pNewDocSh->DoInitNew(NULL); SdDrawDocument* pDoc = pNewDocSh->GetDoc(); if(pDoc) { pDoc->CreateFirstPages(); pDoc->StopWorkStartupDelay(); } if ( pTargetFrame ) { pFrame = pTargetFrame; pFrame->InsertDocument( pNewDocSh ); } else { SfxViewFrame* pViewFrame = SfxViewFrame::CreateViewFrame( *pNewDocSh ); if( pViewFrame ) pFrame = pViewFrame->GetFrame(); } } return pFrame; } void SdModule::ChangeMedium( ::sd::DrawDocShell* pDocShell, SfxViewFrame* pViewFrame, const sal_Int32 eMedium ) { if( !pDocShell ) return; SdDrawDocument* pDoc = pDocShell->GetDoc(); if( !pDoc ) return; // settings for the Outputmedium Size aNewSize; UINT32 nLeft; UINT32 nRight; UINT32 nLower; UINT32 nUpper; switch(eMedium) { case OUTPUT_PAGE: case OUTPUT_OVERHEAD: { SfxPrinter* pPrinter = pDocShell->GetPrinter(TRUE); if( pPrinter && pPrinter->IsValid()) { // Der Printer gibt leider kein exaktes // Format (z.B. A4) zurueck Size aSize(pPrinter->GetPaperSize()); SvxPaper ePaper = SvxPaperInfo::GetSvxPaper( aSize, MAP_100TH_MM, TRUE); if (ePaper != SVX_PAPER_USER) { // Korrekte Size holen aSize = SvxPaperInfo::GetPaperSize(ePaper, MAP_100TH_MM); } if (aSize.Height() > aSize.Width()) { // Stets Querformat aNewSize.Width() = aSize.Height(); aNewSize.Height() = aSize.Width(); } else { aNewSize = aSize; } } else { aNewSize=Size(29700, 21000); } if (eMedium == OUTPUT_PAGE) { nLeft =1000; nRight=1000; nUpper=1000; nLower=1000; } else { nLeft =0; nRight=0; nUpper=0; nLower=0; } } break; case OUTPUT_SLIDE: { aNewSize = Size(27000, 18000); nLeft =0; nRight=0; nUpper=0; nLower=0; } break; case OUTPUT_PRESENTATION: { aNewSize = Size(28000, 21000); nLeft =0; nRight=0; nUpper=0; nLower=0; } break; } BOOL bScaleAll = TRUE; USHORT nPageCnt = pDoc->GetMasterSdPageCount(PK_STANDARD); USHORT i; SdPage* pPage; // master pages first for (i = 0; i < nPageCnt; i++) { pPage = pDoc->GetMasterSdPage(i, PK_STANDARD); if (pPage) { if(eMedium != OUTPUT_ORIGINAL) { Rectangle aBorderRect(nLeft, nUpper, nRight, nLower); pPage->ScaleObjects(aNewSize, aBorderRect, bScaleAll); pPage->SetSize(aNewSize); pPage->SetBorder(nLeft, nUpper, nRight, nLower); } SdPage* pNotesPage = pDoc->GetMasterSdPage(i, PK_NOTES); DBG_ASSERT( pNotesPage, "Wrong page ordering!" ); if( pNotesPage ) pNotesPage->CreateTitleAndLayout(); pPage->CreateTitleAndLayout(); } } nPageCnt = pDoc->GetSdPageCount(PK_STANDARD); // then slides for (i = 0; i < nPageCnt; i++) { pPage = pDoc->GetSdPage(i, PK_STANDARD); if (pPage) { if(eMedium != OUTPUT_ORIGINAL) { Rectangle aBorderRect(nLeft, nUpper, nRight, nLower); pPage->ScaleObjects(aNewSize, aBorderRect, bScaleAll); pPage->SetSize(aNewSize); pPage->SetBorder(nLeft, nUpper, nRight, nLower); } SdPage* pNotesPage = pDoc->GetSdPage(i, PK_NOTES); DBG_ASSERT( pNotesPage, "Wrong page ordering!" ); if( pNotesPage ) pNotesPage->SetAutoLayout( pNotesPage->GetAutoLayout() ); pPage->SetAutoLayout( pPage->GetAutoLayout() ); } } SdPage* pHandoutPage = pDoc->GetSdPage(0, PK_HANDOUT); pHandoutPage->CreateTitleAndLayout(TRUE); if( (eMedium != OUTPUT_ORIGINAL) && pViewFrame && pViewFrame->GetDispatcher()) { pViewFrame->GetDispatcher()->Execute(SID_SIZE_PAGE, SFX_CALLMODE_SYNCHRON | SFX_CALLMODE_RECORD); } }