diff options
Diffstat (limited to 'sd/source/ui/app/sdmod1.cxx')
| -rwxr-xr-x | sd/source/ui/app/sdmod1.cxx | 1065 |
1 files changed, 1065 insertions, 0 deletions
diff --git a/sd/source/ui/app/sdmod1.cxx b/sd/source/ui/app/sdmod1.cxx new file mode 100755 index 000000000000..3c1abc0c7d22 --- /dev/null +++ b/sd/source/ui/app/sdmod1.cxx @@ -0,0 +1,1065 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org 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 version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_sd.hxx" + +#include <svl/lckbitem.hxx> +#include <sfx2/frame.hxx> +#include <sfx2/viewfrm.hxx> +#include <unotools/moduleoptions.hxx> +#include "framework/FrameworkHelper.hxx" + +#include <svx/dialogs.hrc> + +#include <editeng/langitem.hxx> +#include <editeng/editdata.hxx> +#include <vcl/msgbox.hxx> +#include <editeng/svxenum.hxx> +#include <sfx2/dispatch.hxx> +#include <sfx2/request.hxx> +#include <sfx2/printer.hxx> +#include <sfx2/docfile.hxx> +#include <editeng/paperinf.hxx> +#include <editeng/eeitem.hxx> +#include <unotools/useroptions.hxx> + +#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" +#include "ViewShell.hxx" +#include "sdattr.hxx" +#include "sdpage.hxx" +#include "DrawDocShell.hxx" +#include "drawdoc.hxx" +#include "assclass.hxx" +#include "sdenumdef.hxx" +#include "sdresid.hxx" +#include "OutlineViewShell.hxx" +#include "ViewShellBase.hxx" +#ifndef SD_FRAMW_VIEW_HXX +#include "FrameView.hxx" +#endif +#include "FactoryIds.hxx" +#include "sdabstdlg.hxx" +#include <memory> +#include <boost/shared_ptr.hpp> +#include <boost/scoped_array.hpp> +#include "slideshow.hxx" + +#include <com/sun/star/document/XDocumentPropertiesSupplier.hpp> +#include <com/sun/star/document/XDocumentProperties.hpp> + + +using ::sd::framework::FrameworkHelper; +using ::com::sun::star::uno::Reference; +using ::com::sun::star::frame::XFrame; + +namespace { + +class OutlineToImpressFinalizer +{ +public: + OutlineToImpressFinalizer ( + ::sd::ViewShellBase& rBase, + SdDrawDocument& rDocument, + SvLockBytes& rBytes); + virtual ~OutlineToImpressFinalizer (void) {}; + void operator() (bool bEventSeen); +private: + ::sd::ViewShellBase& mrBase; + SdDrawDocument& mrDocument; + ::boost::shared_ptr<SvMemoryStream> mpStream; +}; + + +} //end of anonymous namespace + + +/************************************************************************* +|* +|* 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_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( (UINT16)eUnit ); + rReq.Done(); + } + } + break; + default: + 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_OPENHYPERLINK: + 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( sd::SlideShow::IsRunning( pViewShell->GetViewShellBase() ) ) + { + // Prevent documents from opening while the slide + // show is running, except when this request comes + // from a shape interaction. + if (rReq.GetArgs() == NULL) + { + 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); + SfxViewFrame::LoadDocumentIntoFrame( *pDocSh, pFrmItem, ::sd::OUTLINE_FACTORY_ID ); + + ::sd::ViewShell* pViewSh = pDocSh->GetViewShell(); + + if (pViewSh) + { + // AutoLayouts muessen fertig sein + 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 + = dynamic_cast< ::sd::ViewShellBase*>(pViewFrame->GetViewShell()); + if (pBase != NULL) + { + ::boost::shared_ptr<FrameworkHelper> pHelper ( + FrameworkHelper::Instance(*pBase)); + pHelper->RequestView( + FrameworkHelper::msOutlineViewURL, + FrameworkHelper::msCenterPaneURL); + + pHelper->RunOnResourceActivation( + FrameworkHelper::CreateResourceId( + FrameworkHelper::msOutlineViewURL, + FrameworkHelper::msCenterPaneURL), + OutlineToImpressFinalizer(*pBase, *pDoc, *pBytes)); + } + } + } + } + } + + rRequest.IsDone(); +} + + + + +/************************************************************************* +|* +|* GetState +|* +\************************************************************************/ + +static bool bOnce = false; + +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( sd::SlideShow::IsRunning( pViewShell->GetViewShellBase() ) ) + { + 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); + } + + // der Status von SID_OPENHYPERLINK wird von der Basisklasse bestimmt + if (rItemSet.GetItemState(SID_OPENHYPERLINK) != SFX_ITEM_UNKNOWN) + { + const SfxPoolItem* pItem = SFX_APP()->GetSlotState(SID_OPENHYPERLINK, SFX_APP()->GetInterface()); + if (pItem) + rItemSet.Put(*pItem); + } + + if( SFX_ITEM_AVAILABLE == rItemSet.GetItemState( SID_AUTOSPELL_CHECK ) ) + { + ::sd::DrawDocShell* pDocSh = + PTR_CAST(::sd::DrawDocShell, SfxObjectShell::Current()); + if( pDocSh ) + { + SdDrawDocument* pDoc = pDocSh->GetDoc(); + rItemSet.Put( SfxBoolItem( SID_AUTOSPELL_CHECK, pDoc->GetOnlineSpell() ) ); + } + } + + 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 ) ); + } + + if ( !bOnce ) + { + ::sd::DrawDocShell* pDocShell = PTR_CAST(::sd::DrawDocShell, SfxObjectShell::Current()); + if( pDocShell ) // Impress or Draw ? + { + ::sd::ViewShell* pViewShell = pDocShell->GetViewShell(); + + if( pViewShell && (pDocShell->GetDocumentType() == DOCUMENT_TYPE_IMPRESS) ) + { + // add our event listener as soon as possible + Application::AddEventListener( LINK( this, SdModule, EventListenerHdl ) ); + bOnce = true; + } + } + } +} + +IMPL_LINK( SdModule, EventListenerHdl, VclSimpleEvent*, pEvent ) +{ + if( pEvent && (pEvent->GetId() == VCLEVENT_WINDOW_COMMAND) && static_cast<VclWindowEvent*>(pEvent)->GetData() ) + { + const CommandEvent& rEvent = *(const CommandEvent*)static_cast<VclWindowEvent*>(pEvent)->GetData(); + + if( rEvent.GetCommand() == COMMAND_MEDIA ) + { + switch( rEvent.GetMediaCommand() ) + { + case MEDIA_COMMAND_PLAY: + { + ::sd::DrawDocShell* pDocShell = PTR_CAST(::sd::DrawDocShell, SfxObjectShell::Current()); + if( pDocShell ) // Impress or Draw ? + { + ::sd::ViewShell* pViewShell = pDocShell->GetViewShell(); + + // #i97925# start the presentation if and only if an Impress document is focused + if( pViewShell && (pDocShell->GetDocumentType() == DOCUMENT_TYPE_IMPRESS) ) + pViewShell->GetViewFrame()->GetDispatcher()->Execute( SID_PRESENTATION ); + } + } + break; + + default: + break; + } + } + } + return 0; +} + + +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, const Reference< XFrame >& i_rFrame ) +{ + 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 ) + { + SfxViewFrame* pViewFrame = SfxViewFrame::LoadDocumentIntoFrame( *pDocShell, i_rFrame ); + OSL_ENSURE( pViewFrame, "SdModule::CreateFromTemplate: no view frame - was the document really loaded?" ); + pFrame = pViewFrame ? &pViewFrame->GetFrame() : NULL; + } + + return pFrame; + +} + +SfxFrame* SdModule::ExecuteNewDocument( SfxRequest& rReq ) +{ + SfxFrame* pFrame = 0; + if ( SvtModuleOptions().IsImpress() ) + { + Reference< XFrame > xTargetFrame; + SFX_REQUEST_ARG( rReq, pFrmItem, SfxUnoFrameItem, SID_FILLFRAME, FALSE); + if ( pFrmItem ) + xTargetFrame = 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, xTargetFrame ); + } + else + { + //create an empty document + pFrame = CreateEmptyDocument( DOCUMENT_TYPE_IMPRESS, xTargetFrame ); + bMakeLayoutVisible = true; + } + } + else + { + SdAbstractDialogFactory* pFact = SdAbstractDialogFactory::Create(); + std::auto_ptr< AbstractAssistentDlg > pPilotDlg( pFact ? pFact->CreateAssistentDlg( NULL, !bNewDocDirect ) : 0 ); + + // 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 ( xTargetFrame.is() ) + { + 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 = SfxFrame::OpenDocumentSynchron( aSet, xTargetFrame ); + 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 ) + { + pViewFrame = SfxViewFrame::LoadDocumentIntoFrame( *pShell, xTargetFrame ); + DBG_ASSERT( pViewFrame, "no ViewFrame!!" ); + pFrame = pViewFrame ? &pViewFrame->GetFrame() : NULL; + + 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); + ::boost::shared_ptr<sd::ViewShell> pViewSh = pBase->GetMainViewShell(); + SdOptions* pOptions = GetSdOptions(pDoc->GetDocumentType()); + + if (pOptions && pViewSh.get()) + { + // The AutoPilot-document shall be open without its own options + ::sd::FrameView* pFrameView = pViewSh->GetFrameView(); + pFrameView->Update(pOptions); + pViewSh->ReadFrameViewData(pFrameView); + } + + 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); + } + + // clear document info + using namespace ::com::sun::star; + uno::Reference<document::XDocumentPropertiesSupplier> xDPS( + pDocShell->GetModel(), uno::UNO_QUERY_THROW); + uno::Reference<document::XDocumentProperties> + xDocProps(xDPS->getDocumentProperties()); + DBG_ASSERT(xDocProps.is(), "no DocumentProperties"); + xDocProps->resetUserData( + SvtUserOptions().GetFullName() ); + xDocProps->setTemplateName(xDocProps->getTitle()); + xDocProps->setTemplateURL(pPilotDlg->GetDocPath()); + + pDoc->SetChanged(!bIsDocEmpty); + + pDocShell->SetUseUserData(TRUE); + + // #94652# clear UNDO stack after autopilot + pDocShell->ClearUndoBuffer(); + + bMakeLayoutVisible = true; + } + } + pOpt->SetStartWithTemplate(bStartWithTemplate); + } + } + } + + if (bMakeLayoutVisible && pViewFrame!=NULL) + { + // Make the layout menu visible in the tool pane. + ::sd::ViewShellBase* pBase = ::sd::ViewShellBase::GetViewShellBase(pViewFrame); + if (pBase != NULL) + { + FrameworkHelper::Instance(*pBase)->RequestTaskPanel( + FrameworkHelper::msLayoutTaskPanelURL); + } + } + } + + return pFrame; +} + +SfxFrame* SdModule::CreateEmptyDocument( DocumentType eDocType, const Reference< XFrame >& i_rFrame ) +{ + 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(); + } + + SfxViewFrame* pViewFrame = SfxViewFrame::LoadDocumentIntoFrame( *pNewDocSh, i_rFrame ); + OSL_ENSURE( pViewFrame, "SdModule::CreateEmptyDocument: no view frame - was the document really loaded?" ); + pFrame = pViewFrame ? &pViewFrame->GetFrame() : NULL; + } + + 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 = 0; + UINT32 nRight = 0; + UINT32 nLower = 0; + UINT32 nUpper = 0; + 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()); + Paper ePaper = SvxPaperInfo::GetSvxPaper( aSize, MAP_100TH_MM, TRUE); + + if (ePaper != 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); + } +} + + + + +//===== OutlineToImpressFinalize ============================================== + +namespace { + +OutlineToImpressFinalizer::OutlineToImpressFinalizer ( + ::sd::ViewShellBase& rBase, + SdDrawDocument& rDocument, + SvLockBytes& rBytes) + : mrBase(rBase), + mrDocument(rDocument), + mpStream() +{ + // The given stream has a lifetime shorter than this new + // OutlineToImpressFinalizer object. Therefore a local copy of the + // stream is created. + const SvStream* pStream (rBytes.GetStream()); + if (pStream != NULL) + { + // Create a memory stream and prepare to fill it with the content of + // the original stream. + mpStream.reset(new SvMemoryStream()); + static const sal_Size nBufferSize = 4096; + ::boost::scoped_array<sal_Int8> pBuffer (new sal_Int8[nBufferSize]); + + sal_Size nReadPosition (0); + bool bLoop (true); + while (bLoop) + { + // Read the next part of the original stream. + sal_Size nReadByteCount (0); + const ErrCode nErrorCode ( + rBytes.ReadAt( + nReadPosition, + reinterpret_cast<void*>(pBuffer.get()), + nBufferSize, + &nReadByteCount)); + + // Check the error code and stop copying the stream data when an + // error has occured. + switch (nErrorCode) + { + case ERRCODE_NONE: + if (nReadByteCount == 0) + bLoop = false; + break; + case ERRCODE_IO_PENDING: + break; + + default: + bLoop = false; + nReadByteCount = 0; + break; + } + + // Append the read bytes to the end of the memory stream. + if (nReadByteCount > 0) + { + mpStream->Write(reinterpret_cast<void*>(pBuffer.get()), nReadByteCount); + nReadPosition += nReadByteCount; + } + } + + // Rewind the memory stream so that in the operator() method its + // content is properly read. + mpStream->Seek(STREAM_SEEK_TO_BEGIN); + } +} + + + + +void OutlineToImpressFinalizer::operator() (bool) +{ + // Fetch the new outline view shell. + ::sd::OutlineViewShell* pOutlineShell + = dynamic_cast<sd::OutlineViewShell*>(FrameworkHelper::Instance(mrBase)->GetViewShell(FrameworkHelper::msCenterPaneURL).get()); + + if (pOutlineShell != NULL && mpStream.get() != NULL) + { + sd::OutlineView* pView = static_cast<sd::OutlineView*>(pOutlineShell->GetView()); + // mba: the stream can't contain any relative URLs, because we don't + // have any information about a BaseURL! + if ( pOutlineShell->Read(*mpStream, String(), EE_FORMAT_RTF) == 0 ) + { +/* + sd::OutlineViewPageChangesGuard aGuard( pView ); + + // Remove the first empty pages + USHORT nPageCount = mrDocument.GetPageCount(); + mrDocument.RemovePage( --nPageCount ); // notes page + mrDocument.RemovePage( --nPageCount ); // standard page +*/ + } + + // Call UpdatePreview once for every slide to resync the + // document with the outliner of the OutlineViewShell. + USHORT nPageCount (mrDocument.GetSdPageCount(PK_STANDARD)); + for (USHORT nIndex=0; nIndex<nPageCount; nIndex++) + { + SdPage* pPage = mrDocument.GetSdPage(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 = mrDocument.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. + ::sd::DrawDocShell* pDocShell = mrDocument.GetDocSh(); + if( pDocShell ) + pDocShell->ClearUndoBuffer(); +} + + +} // end of anonymous namespace |