/************************************************************** * * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, * software distributed under the License is distributed on an * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY * KIND, either express or implied. See the License for the * specific language governing permissions and limitations * under the License. * *************************************************************/ // MARKER(update_precomp.py): autogen include statement, do not remove #include "precompiled_sfx2.hxx" #include <svl/stritem.hxx> #include <svl/eitem.hxx> #include <svl/whiter.hxx> #include <vcl/msgbox.hxx> #include <vcl/toolbox.hxx> #include <svl/intitem.hxx> #include <svtools/sfxecode.hxx> #include <svtools/ehdl.hxx> #include <com/sun/star/frame/XLayoutManager.hpp> #include <com/sun/star/frame/XModuleManager.hpp> #include <com/sun/star/beans/XPropertySet.hpp> #include <com/sun/star/embed/EmbedStates.hpp> #include <com/sun/star/embed/EmbedMisc.hpp> #include <com/sun/star/system/SystemShellExecute.hpp> #include <com/sun/star/system/SystemShellExecuteFlags.hpp> #include <com/sun/star/container/XContainerQuery.hpp> #include <com/sun/star/frame/XStorable.hpp> #include <com/sun/star/datatransfer/clipboard/XClipboard.hpp> #include <cppuhelper/implbase1.hxx> #include <osl/file.hxx> #include <vos/mutex.hxx> #include <tools/urlobj.hxx> #include <unotools/tempfile.hxx> #include <unotools/pathoptions.hxx> #include <svtools/miscopt.hxx> #include <svtools/soerr.hxx> #include <unotools/internaloptions.hxx> #include <unotools/javaoptions.hxx> #include <basic/basmgr.hxx> #include <basic/sbuno.hxx> #include <framework/actiontriggerhelper.hxx> #include <comphelper/processfactory.hxx> #include <comphelper/sequenceashashmap.hxx> #include <toolkit/unohlp.hxx> #include <sfx2/app.hxx> #include "view.hrc" #include <sfx2/viewsh.hxx> #include "viewimp.hxx" #include "sfx2/sfxresid.hxx" #include <sfx2/request.hxx> #include <sfx2/templdlg.hxx> #include <sfx2/printer.hxx> #include <sfx2/docfile.hxx> #include <sfx2/dispatch.hxx> #include "arrdecl.hxx" #include <sfx2/docfac.hxx> #include "view.hrc" #include "sfxlocal.hrc" #include <sfx2/sfxbasecontroller.hxx> #include "sfx2/mailmodelapi.hxx" #include <sfx2/viewfrm.hxx> #include <sfx2/event.hxx> #include <sfx2/fcontnr.hxx> #include <sfx2/ipclient.hxx> #include "workwin.hxx" #include <sfx2/objface.hxx> #include <sfx2/docfilt.hxx> // #110897# #ifndef _UNOTOOLS_PROCESSFACTORY_HXX #include <comphelper/processfactory.hxx> #endif using namespace ::com::sun::star; using namespace ::com::sun::star::uno; using namespace ::com::sun::star::frame; using namespace ::com::sun::star::beans; using namespace ::com::sun::star::util; using namespace ::com::sun::star::system; using namespace ::cppu; namespace css = ::com::sun::star; //========================================================================= DBG_NAME(SfxViewShell) #define SfxViewShell #include "sfxslots.hxx" //========================================================================= class SfxClipboardChangeListener : public ::cppu::WeakImplHelper1< datatransfer::clipboard::XClipboardListener > { public: SfxClipboardChangeListener( SfxViewShell* pView, const uno::Reference< datatransfer::clipboard::XClipboardNotifier >& xClpbrdNtfr ); virtual ~SfxClipboardChangeListener(); // XEventListener virtual void SAL_CALL disposing( const lang::EventObject& rEventObject ) throw ( uno::RuntimeException ); // XClipboardListener virtual void SAL_CALL changedContents( const datatransfer::clipboard::ClipboardEvent& rEventObject ) throw ( uno::RuntimeException ); void DisconnectViewShell() { m_pViewShell = NULL; } void ChangedContents(); enum AsyncExecuteCmd { ASYNCEXECUTE_CMD_DISPOSING, ASYNCEXECUTE_CMD_CHANGEDCONTENTS }; struct AsyncExecuteInfo { AsyncExecuteInfo( AsyncExecuteCmd eCmd, uno::Reference< datatransfer::clipboard::XClipboardListener > xThis, SfxClipboardChangeListener* pListener ) : m_eCmd( eCmd ), m_xThis( xThis ), m_pListener( pListener ) {} AsyncExecuteCmd m_eCmd; uno::Reference< datatransfer::clipboard::XClipboardListener > m_xThis; SfxClipboardChangeListener* m_pListener; }; private: SfxViewShell* m_pViewShell; uno::Reference< datatransfer::clipboard::XClipboardNotifier > m_xClpbrdNtfr; uno::Reference< lang::XComponent > m_xCtrl; DECL_STATIC_LINK( SfxClipboardChangeListener, AsyncExecuteHdl_Impl, AsyncExecuteInfo* ); }; SfxClipboardChangeListener::SfxClipboardChangeListener( SfxViewShell* pView, const uno::Reference< datatransfer::clipboard::XClipboardNotifier >& xClpbrdNtfr ) : m_pViewShell( 0 ), m_xClpbrdNtfr( xClpbrdNtfr ) { m_xCtrl = uno::Reference < lang::XComponent >( pView->GetController(), uno::UNO_QUERY ); if ( m_xCtrl.is() ) { m_xCtrl->addEventListener( uno::Reference < lang::XEventListener > ( static_cast < lang::XEventListener* >( this ) ) ); m_pViewShell = pView; } if ( m_xClpbrdNtfr.is() ) { m_xClpbrdNtfr->addClipboardListener( uno::Reference< datatransfer::clipboard::XClipboardListener >( static_cast< datatransfer::clipboard::XClipboardListener* >( this ))); } } SfxClipboardChangeListener::~SfxClipboardChangeListener() { } void SfxClipboardChangeListener::ChangedContents() { const ::vos::OGuard aGuard( Application::GetSolarMutex() ); if( m_pViewShell ) { SfxBindings& rBind = m_pViewShell->GetViewFrame()->GetBindings(); rBind.Invalidate( SID_PASTE ); rBind.Invalidate( SID_PASTE_SPECIAL ); rBind.Invalidate( SID_CLIPBOARD_FORMAT_ITEMS ); } } IMPL_STATIC_LINK_NOINSTANCE( SfxClipboardChangeListener, AsyncExecuteHdl_Impl, AsyncExecuteInfo*, pAsyncExecuteInfo ) { if ( pAsyncExecuteInfo ) { uno::Reference< datatransfer::clipboard::XClipboardListener > xThis( pAsyncExecuteInfo->m_xThis ); if ( pAsyncExecuteInfo->m_pListener ) { if ( pAsyncExecuteInfo->m_eCmd == ASYNCEXECUTE_CMD_DISPOSING ) pAsyncExecuteInfo->m_pListener->DisconnectViewShell(); else if ( pAsyncExecuteInfo->m_eCmd == ASYNCEXECUTE_CMD_CHANGEDCONTENTS ) pAsyncExecuteInfo->m_pListener->ChangedContents(); } } delete pAsyncExecuteInfo; return 0; } void SAL_CALL SfxClipboardChangeListener::disposing( const lang::EventObject& /*rEventObject*/ ) throw ( uno::RuntimeException ) { // Either clipboard or ViewShell is going to be destroyed -> no interest in listening anymore uno::Reference< lang::XComponent > xCtrl( m_xCtrl ); uno::Reference< datatransfer::clipboard::XClipboardNotifier > xNotify( m_xClpbrdNtfr ); uno::Reference< datatransfer::clipboard::XClipboardListener > xThis( static_cast< datatransfer::clipboard::XClipboardListener* >( this )); if ( xCtrl.is() ) xCtrl->removeEventListener( uno::Reference < lang::XEventListener > ( static_cast < lang::XEventListener* >( this ))); if ( xNotify.is() ) xNotify->removeClipboardListener( xThis ); // Make asynchronous call to avoid locking SolarMutex which is the // root for many deadlocks, especially in conjunction with the "Windows" // based single thread apartment clipboard code! AsyncExecuteInfo* pInfo = new AsyncExecuteInfo( ASYNCEXECUTE_CMD_DISPOSING, xThis, this ); Application::PostUserEvent( STATIC_LINK( 0, SfxClipboardChangeListener, AsyncExecuteHdl_Impl ), pInfo ); } void SAL_CALL SfxClipboardChangeListener::changedContents( const datatransfer::clipboard::ClipboardEvent& ) throw ( RuntimeException ) { // Make asynchronous call to avoid locking SolarMutex which is the // root for many deadlocks, especially in conjunction with the "Windows" // based single thread apartment clipboard code! uno::Reference< datatransfer::clipboard::XClipboardListener > xThis( static_cast< datatransfer::clipboard::XClipboardListener* >( this )); AsyncExecuteInfo* pInfo = new AsyncExecuteInfo( ASYNCEXECUTE_CMD_CHANGEDCONTENTS, xThis, this ); Application::PostUserEvent( STATIC_LINK( 0, SfxClipboardChangeListener, AsyncExecuteHdl_Impl ), pInfo ); } //========================================================================= static ::rtl::OUString RetrieveLabelFromCommand( const ::rtl::OUString& rCommandURL, const css::uno::Reference< css::frame::XFrame >& rFrame ) { static css::uno::WeakReference< frame::XModuleManager > s_xModuleManager; static css::uno::WeakReference< container::XNameAccess > s_xNameAccess; ::rtl::OUString aLabel; css::uno::Reference< css::frame::XModuleManager > xModuleManager( s_xModuleManager ); css::uno::Reference< css::container::XNameAccess > xNameAccess( s_xNameAccess ); css::uno::Reference< css::lang::XMultiServiceFactory > xSMGR( ::comphelper::getProcessServiceFactory(), css::uno::UNO_QUERY_THROW); try { if ( !xModuleManager.is() ) { xModuleManager = css::uno::Reference< css::frame::XModuleManager >( xSMGR->createInstance( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.frame.ModuleManager" ))), css::uno::UNO_QUERY_THROW ); s_xModuleManager = xModuleManager; } ::rtl::OUString aModuleIdentifier = xModuleManager->identify( rFrame ); if ( !xNameAccess.is() ) { xNameAccess = css::uno::Reference< css::container::XNameAccess >( xSMGR->createInstance( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.frame.UICommandDescription" ))), css::uno::UNO_QUERY_THROW ); s_xNameAccess = xNameAccess; } css::uno::Any a = xNameAccess->getByName( aModuleIdentifier ); css::uno::Reference< css::container::XNameAccess > xUICommands; a >>= xUICommands; rtl::OUString aStr; css::uno::Sequence< css::beans::PropertyValue > aPropSeq; a = xUICommands->getByName( rCommandURL ); if ( a >>= aPropSeq ) { for ( sal_Int32 i = 0; i < aPropSeq.getLength(); i++ ) { if ( aPropSeq[i].Name.equalsAscii( "Label" )) { aPropSeq[i].Value >>= aStr; break; } } aLabel = aStr; } } catch ( css::uno::Exception& ) { } return aLabel; } //========================================================================= SfxViewShell_Impl::SfxViewShell_Impl(sal_uInt16 const nFlags) : aInterceptorContainer( aMutex ) , m_bControllerSet(false) , m_nPrinterLocks(0) , m_bCanPrint(SFX_VIEW_CAN_PRINT == (nFlags & SFX_VIEW_CAN_PRINT)) , m_bHasPrintOptions( SFX_VIEW_HAS_PRINTOPTIONS == (nFlags & SFX_VIEW_HAS_PRINTOPTIONS)) , m_bPlugInsActive(true) , m_bIsShowView(SFX_VIEW_NO_SHOW != (nFlags & SFX_VIEW_NO_SHOW)) , m_bGotOwnership(false) , m_bGotFrameOwnership(false) , m_eScroll(SCROLLING_DEFAULT) , m_nFamily(0xFFFF) // undefined, default set by TemplateDialog , m_pController(0) , m_pAccExec(0) {} //========================================================================= SFX_IMPL_INTERFACE(SfxViewShell,SfxShell,SfxResId(0)) { SFX_CHILDWINDOW_REGISTRATION( SID_MAIL_CHILDWIN ); } TYPEINIT2(SfxViewShell,SfxShell,SfxListener); //-------------------------------------------------------------------- /** search for a filter name dependent on type and module */ static ::rtl::OUString impl_retrieveFilterNameFromTypeAndModule( const css::uno::Reference< css::container::XContainerQuery >& rContainerQuery, const ::rtl::OUString& rType, const ::rtl::OUString& rModuleIdentifier, const sal_Int32 nFlags ) { // Retrieve filter from type css::uno::Sequence< css::beans::NamedValue > aQuery( 2 ); aQuery[0].Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Type" )); aQuery[0].Value = css::uno::makeAny( rType ); aQuery[1].Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "DocumentService" )); aQuery[1].Value = css::uno::makeAny( rModuleIdentifier ); css::uno::Reference< css::container::XEnumeration > xEnumeration = rContainerQuery->createSubSetEnumerationByProperties( aQuery ); ::rtl::OUString aFoundFilterName; while ( xEnumeration->hasMoreElements() ) { ::comphelper::SequenceAsHashMap aFilterPropsHM( xEnumeration->nextElement() ); ::rtl::OUString aFilterName = aFilterPropsHM.getUnpackedValueOrDefault( ::rtl::OUString::createFromAscii( "Name" ), ::rtl::OUString() ); sal_Int32 nFilterFlags = aFilterPropsHM.getUnpackedValueOrDefault( ::rtl::OUString::createFromAscii( "Flags" ), sal_Int32( 0 ) ); if ( nFilterFlags & nFlags ) { aFoundFilterName = aFilterName; break; } } return aFoundFilterName; } //-------------------------------------------------------------------- /** search for an internal typename, which map to the current app module and map also to a "family" of file formats as e.g. PDF/MS Doc/OOo Doc. */ enum ETypeFamily { E_MS_DOC, E_OOO_DOC }; ::rtl::OUString impl_searchFormatTypeForApp(const css::uno::Reference< css::frame::XFrame >& xFrame , ETypeFamily eTypeFamily) { static ::rtl::OUString SERVICENAME_MODULEMANAGER = ::rtl::OUString::createFromAscii("com.sun.star.frame.ModuleManager"); try { css::uno::Reference< css::lang::XMultiServiceFactory > xSMGR (::comphelper::getProcessServiceFactory() , css::uno::UNO_QUERY_THROW); css::uno::Reference< css::frame::XModuleManager > xModuleManager(xSMGR->createInstance(SERVICENAME_MODULEMANAGER), css::uno::UNO_QUERY_THROW); ::rtl::OUString sModule = xModuleManager->identify(xFrame); ::rtl::OUString sType ; switch(eTypeFamily) { case E_MS_DOC: { if (sModule.equalsAscii( "com.sun.star.text.TextDocument" )) sType = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "writer_MS_Word_97" )); else if (sModule.equalsAscii( "com.sun.star.sheet.SpreadsheetDocument" )) sType = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "calc_MS_Excel_97" )); else if (sModule.equalsAscii( "com.sun.star.drawing.DrawingDocument" )) sType = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "impress_MS_PowerPoint_97" )); else if (sModule.equalsAscii( "com.sun.star.presentation.PresentationDocument" )) sType = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "impress_MS_PowerPoint_97" )); } break; case E_OOO_DOC: { if (sModule.equalsAscii( "com.sun.star.text.TextDocument" )) sType = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "writer8" )); else if (sModule.equalsAscii( "com.sun.star.sheet.SpreadsheetDocument" )) sType = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "calc8" )); else if (sModule.equalsAscii( "com.sun.star.drawing.DrawingDocument" )) sType = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "draw8" )); else if (sModule.equalsAscii( "com.sun.star.presentation.PresentationDocument" )) sType = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "impress8" )); } break; } return sType; } catch(const css::uno::RuntimeException& exRun) { throw exRun; } catch(const css::uno::Exception&) {} return ::rtl::OUString(); } //-------------------------------------------------------------------- void SfxViewShell::ExecMisc_Impl( SfxRequest &rReq ) { const sal_uInt16 nId = rReq.GetSlot(); switch( nId ) { case SID_STYLE_FAMILY : { SFX_REQUEST_ARG(rReq, pItem, SfxUInt16Item, nId, sal_False); if (pItem) { pImp->m_nFamily = pItem->GetValue(); } break; } case SID_STYLE_CATALOG: { SfxTemplateCatalog aCatalog( SFX_APP()->GetTopWindow(), &GetViewFrame()->GetBindings()); aCatalog.Execute(); rReq.Ignore(); break; } case SID_ACTIVATE_STYLE_APPLY: { com::sun::star::uno::Reference< com::sun::star::frame::XFrame > xFrame( GetViewFrame()->GetFrame().GetFrameInterface(), com::sun::star::uno::UNO_QUERY); Reference< com::sun::star::beans::XPropertySet > xPropSet( xFrame, UNO_QUERY ); Reference< ::com::sun::star::frame::XLayoutManager > xLayoutManager; if ( xPropSet.is() ) { try { Any aValue = xPropSet->getPropertyValue( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "LayoutManager" ))); aValue >>= xLayoutManager; if ( xLayoutManager.is() ) { rtl::OUString aTextResString( RTL_CONSTASCII_USTRINGPARAM( "private:resource/toolbar/textobjectbar" )); uno::Reference< ui::XUIElement > xElement = xLayoutManager->getElement( aTextResString ); if(!xElement.is()) { rtl::OUString aFrameResString( RTL_CONSTASCII_USTRINGPARAM( "private:resource/toolbar/frameobjectbar" )); xElement = xLayoutManager->getElement( aFrameResString ); } if(!xElement.is()) { rtl::OUString aOleResString( RTL_CONSTASCII_USTRINGPARAM( "private:resource/toolbar/oleobjectbar" )); xElement = xLayoutManager->getElement( aOleResString ); } if(xElement.is()) { uno::Reference< awt::XWindow > xWin( xElement->getRealInterface(), uno::UNO_QUERY_THROW ); Window* pWin = VCLUnoHelper::GetWindow( xWin ); ToolBox* pTextToolbox = dynamic_cast< ToolBox* >( pWin ); if( pTextToolbox ) { sal_uInt16 nItemCount = pTextToolbox->GetItemCount(); for( sal_uInt16 nItem = 0; nItem < nItemCount; ++nItem ) { sal_uInt16 nItemId = pTextToolbox->GetItemId( nItem ); const XubString& rCommand = pTextToolbox->GetItemCommand( nItemId ); if( rCommand.EqualsAscii( ".uno:StyleApply" ) ) { Window* pItemWin = pTextToolbox->GetItemWindow( nItemId ); if( pItemWin ) pItemWin->GrabFocus(); break; } } } } } } catch ( Exception& ) { } } rReq.Done(); } break; // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - case SID_MAIL_SENDDOCASMS: case SID_MAIL_SENDDOCASOOO: case SID_MAIL_SENDDOCASPDF: case SID_MAIL_SENDDOC: case SID_MAIL_SENDDOCASFORMAT: { SfxObjectShell* pDoc = GetObjectShell(); if ( pDoc && pDoc->QueryHiddenInformation( WhenSaving, &GetViewFrame()->GetWindow() ) != RET_YES ) break; if ( SvtInternalOptions().MailUIEnabled() ) { GetViewFrame()->SetChildWindow( SID_MAIL_CHILDWIN, sal_True ); } else { SfxMailModel aModel; rtl::OUString aDocType; SFX_REQUEST_ARG(rReq, pMailSubject, SfxStringItem, SID_MAIL_SUBJECT, sal_False ); if ( pMailSubject ) aModel.SetSubject( pMailSubject->GetValue() ); SFX_REQUEST_ARG(rReq, pMailRecipient, SfxStringItem, SID_MAIL_RECIPIENT, sal_False ); if ( pMailRecipient ) { String aRecipient( pMailRecipient->GetValue() ); String aMailToStr( String::CreateFromAscii( "mailto:" )); if ( aRecipient.Search( aMailToStr ) == 0 ) aRecipient = aRecipient.Erase( 0, aMailToStr.Len() ); aModel.AddAddress( aRecipient, SfxMailModel::ROLE_TO ); } SFX_REQUEST_ARG(rReq, pMailDocType, SfxStringItem, SID_TYPE_NAME, sal_False ); if ( pMailDocType ) aDocType = pMailDocType->GetValue(); uno::Reference < frame::XFrame > xFrame( pFrame->GetFrame().GetFrameInterface() ); SfxMailModel::SendMailResult eResult = SfxMailModel::SEND_MAIL_ERROR; if ( nId == SID_MAIL_SENDDOC ) eResult = aModel.SaveAndSend( xFrame, rtl::OUString() ); else if ( nId == SID_MAIL_SENDDOCASPDF ) eResult = aModel.SaveAndSend( xFrame, rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "pdf_Portable_Document_Format" ))); else if ( nId == SID_MAIL_SENDDOCASMS ) { aDocType = impl_searchFormatTypeForApp(xFrame, E_MS_DOC); if (aDocType.getLength() > 0) eResult = aModel.SaveAndSend( xFrame, aDocType ); } else if ( nId == SID_MAIL_SENDDOCASOOO ) { aDocType = impl_searchFormatTypeForApp(xFrame, E_OOO_DOC); if (aDocType.getLength() > 0) eResult = aModel.SaveAndSend( xFrame, aDocType ); } if ( eResult == SfxMailModel::SEND_MAIL_ERROR ) { InfoBox aBox( SFX_APP()->GetTopWindow(), SfxResId( MSG_ERROR_SEND_MAIL )); aBox.Execute(); rReq.Ignore(); } else rReq.Done(); } break; } // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - case SID_WEBHTML: { static const char HTML_DOCUMENT_TYPE[] = "writer_web_HTML"; static const char HTML_GRAPHIC_TYPE[] = "graphic_HTML"; const sal_Int32 FILTERFLAG_EXPORT = 0x00000002; css::uno::Reference< lang::XMultiServiceFactory > xSMGR(::comphelper::getProcessServiceFactory(), css::uno::UNO_QUERY_THROW); css::uno::Reference < css::frame::XFrame > xFrame( pFrame->GetFrame().GetFrameInterface() ); css::uno::Reference< css::frame::XModel > xModel; const rtl::OUString aModuleManager( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.frame.ModuleManager" )); css::uno::Reference< css::frame::XModuleManager > xModuleManager( xSMGR->createInstance( aModuleManager ), css::uno::UNO_QUERY_THROW ); if ( !xModuleManager.is() ) { rReq.Done(sal_False); return; } rtl::OUString aModule; try { aModule = xModuleManager->identify( xFrame ); } catch ( css::uno::RuntimeException& ) { throw; } catch ( css::uno::Exception& ) { } if ( xFrame.is() ) { css::uno::Reference< css::frame::XController > xController = xFrame->getController(); if ( xController.is() ) xModel = xController->getModel(); } // We need at least a valid module name and model reference css::uno::Reference< css::frame::XStorable > xStorable( xModel, css::uno::UNO_QUERY ); if ( xModel.is() && xStorable.is() ) { rtl::OUString aFilterName; rtl::OUString aTypeName( RTL_CONSTASCII_USTRINGPARAM( HTML_DOCUMENT_TYPE )); rtl::OUString aFileName; rtl::OUString aExtension( RTL_CONSTASCII_USTRINGPARAM( "htm" )); rtl::OUString aLocation = xStorable->getLocation(); INetURLObject aFileObj( aLocation ); bool bPrivateProtocol = ( aFileObj.GetProtocol() == INET_PROT_PRIV_SOFFICE ); bool bHasLocation = ( aLocation.getLength() > 0 ) && !bPrivateProtocol; css::uno::Reference< css::container::XContainerQuery > xContainerQuery( xSMGR->createInstance( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.document.FilterFactory" ))), css::uno::UNO_QUERY_THROW ); // Retrieve filter from type sal_Int32 nFilterFlags = FILTERFLAG_EXPORT; aFilterName = impl_retrieveFilterNameFromTypeAndModule( xContainerQuery, aTypeName, aModule, nFilterFlags ); if ( aFilterName.getLength() == 0 ) { // Draw/Impress uses a different type. 2nd chance try to use alternative type name aFilterName = impl_retrieveFilterNameFromTypeAndModule( xContainerQuery, ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( HTML_GRAPHIC_TYPE )), aModule, nFilterFlags ); } // No filter found => error // No type and no location => error if (( aFilterName.getLength() == 0 ) || ( aTypeName.getLength() == 0 )) { rReq.Done(sal_False); return; } // Use provided save file name. If empty determine file name if ( !bHasLocation ) { // Create a default file name with the correct extension const rtl::OUString aPreviewFileName( RTL_CONSTASCII_USTRINGPARAM( "webpreview" )); aFileName = aPreviewFileName; } else { // Determine file name from model INetURLObject aFObj( xStorable->getLocation() ); aFileName = aFObj.getName( INetURLObject::LAST_SEGMENT, true, INetURLObject::NO_DECODE ); } OSL_ASSERT( aFilterName.getLength() > 0 ); OSL_ASSERT( aFileName.getLength() > 0 ); // Creates a temporary directory to store our predefined file into it. ::utl::TempFile aTempDir( NULL, sal_True ); INetURLObject aFilePathObj( aTempDir.GetURL() ); aFilePathObj.insertName( aFileName ); aFilePathObj.setExtension( aExtension ); rtl::OUString aFileURL = aFilePathObj.GetMainURL( INetURLObject::NO_DECODE ); css::uno::Sequence< css::beans::PropertyValue > aArgs( 1 ); aArgs[0].Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "FilterName" )); aArgs[0].Value = css::uno::makeAny( aFilterName ); // Store document in the html format try { xStorable->storeToURL( aFileURL, aArgs ); } catch ( com::sun::star::io::IOException& ) { rReq.Done(sal_False); return; } ::com::sun::star::uno::Reference< XSystemShellExecute > xSystemShellExecute( com::sun::star::system::SystemShellExecute::create( ::comphelper::getProcessComponentContext() ) ); sal_Bool bRet( sal_True ); if ( xSystemShellExecute.is() ) { try { xSystemShellExecute->execute( aFileURL, ::rtl::OUString(), SystemShellExecuteFlags::DEFAULTS ); } catch ( uno::Exception& ) { vos::OGuard aGuard( Application::GetSolarMutex() ); Window *pParent = SFX_APP()->GetTopWindow(); ErrorBox( pParent, SfxResId( MSG_ERROR_NO_WEBBROWSER_FOUND )).Execute(); bRet = sal_False; } } rReq.Done(bRet); break; } else { rReq.Done(sal_False); return; } } // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - case SID_PLUGINS_ACTIVE: { SFX_REQUEST_ARG(rReq, pShowItem, SfxBoolItem, nId, sal_False); bool const bActive = (pShowItem) ? pShowItem->GetValue() : !pImp->m_bPlugInsActive; // ggf. recorden if ( !rReq.IsAPI() ) rReq.AppendItem( SfxBoolItem( nId, bActive ) ); // Jetzt schon DONE aufrufen, da die Argumente evtl. einen Pool // benutzen, der demn"achst weg ist rReq.Done(sal_True); // ausfuehren if (!pShowItem || (bActive != pImp->m_bPlugInsActive)) { SfxFrame* pTopFrame = &GetFrame()->GetTopFrame(); if ( pTopFrame != &GetFrame()->GetFrame() ) { // FramesetDocument SfxViewShell *pShell = pTopFrame->GetCurrentViewFrame()->GetViewShell(); if ( pShell->GetInterface()->GetSlot( nId ) ) pShell->ExecuteSlot( rReq ); break; } SfxFrameIterator aIter( *pTopFrame ); while ( pTopFrame ) { if ( pTopFrame->GetCurrentViewFrame() ) { SfxViewShell *pView = pTopFrame->GetCurrentViewFrame()->GetViewShell(); if ( pView ) { pView->pImp->m_bPlugInsActive = bActive; Rectangle aVisArea = GetObjectShell()->GetVisArea(); VisAreaChanged(aVisArea); // the plugins might need change in their state SfxInPlaceClientList *pClients = pView->GetIPClientList_Impl(sal_False); if ( pClients ) { for (sal_uInt16 n=0; n < pClients->Count(); n++) { SfxInPlaceClient* pIPClient = pClients->GetObject(n); if ( pIPClient ) pView->CheckIPClient_Impl( pIPClient, aVisArea ); } } } } if ( !pTopFrame->GetParentFrame() ) pTopFrame = aIter.FirstFrame(); else pTopFrame = aIter.NextFrame( *pTopFrame ); } } break; } } } //-------------------------------------------------------------------- void SfxViewShell::GetState_Impl( SfxItemSet &rSet ) { DBG_CHKTHIS(SfxViewShell, 0); SfxWhichIter aIter( rSet ); for ( sal_uInt16 nSID = aIter.FirstWhich(); nSID; nSID = aIter.NextWhich() ) { switch ( nSID ) { case SID_STYLE_CATALOG: { if ( !GetViewFrame()->KnowsChildWindow( SID_STYLE_DESIGNER ) ) rSet.DisableItem( nSID ); break; } // Printer-Funktionen case SID_PRINTDOC: case SID_PRINTDOCDIRECT: case SID_SETUPPRINTER: case SID_PRINTER_NAME: { bool bEnabled = pImp->m_bCanPrint && !pImp->m_nPrinterLocks; bEnabled = bEnabled && !Application::GetSettings().GetMiscSettings().GetDisablePrinting(); if ( bEnabled ) { SfxPrinter *pPrinter = GetPrinter(sal_False); if ( SID_PRINTDOCDIRECT == nSID ) { rtl::OUString aPrinterName; if ( pPrinter != NULL ) aPrinterName = pPrinter->GetName(); else aPrinterName = Printer::GetDefaultPrinterName(); if ( aPrinterName.getLength() > 0 ) { uno::Reference < frame::XFrame > xFrame( pFrame->GetFrame().GetFrameInterface() ); ::rtl::OUStringBuffer aBuffer( 60 ); aBuffer.append( RetrieveLabelFromCommand( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:PrintDefault" )), xFrame )); aBuffer.appendAscii( " (" ); aBuffer.append( aPrinterName ); aBuffer.appendAscii( ")" ); rSet.Put( SfxStringItem( SID_PRINTDOCDIRECT, aBuffer.makeStringAndClear() ) ); } } bEnabled = !pPrinter || !pPrinter->IsPrinting(); } if ( !bEnabled ) { // will now be handled by requeing the request /* rSet.DisableItem( SID_PRINTDOC ); rSet.DisableItem( SID_PRINTDOCDIRECT ); rSet.DisableItem( SID_SETUPPRINTER ); */ } break; } // Mail-Funktionen case SID_MAIL_SENDDOCASPDF: case SID_MAIL_SENDDOC: case SID_MAIL_SENDDOCASFORMAT: { sal_Bool bEnable = !GetViewFrame()->HasChildWindow( SID_MAIL_CHILDWIN ); if ( !bEnable ) rSet.DisableItem( nSID ); break; } // PlugIns running case SID_PLUGINS_ACTIVE: { rSet.Put( SfxBoolItem( SID_PLUGINS_ACTIVE, !pImp->m_bPlugInsActive) ); break; } /* // SelectionText case SID_SELECTION_TEXT: { rSet.Put( SfxStringItem( SID_SELECTION_TEXT, GetSelectionText() ) ); break; } // SelectionTextExt case SID_SELECTION_TEXT_EXT: { rSet.Put( SfxStringItem( SID_SELECTION_TEXT_EXT, GetSelectionText(sal_True) ) ); break; } */ case SID_STYLE_FAMILY : { rSet.Put( SfxUInt16Item( SID_STYLE_FAMILY, pImp->m_nFamily ) ); break; } } } } //-------------------------------------------------------------------- void SfxViewShell::SetZoomFactor( const Fraction &rZoomX, const Fraction &rZoomY ) { DBG_ASSERT( GetWindow(), "no window" ); MapMode aMap( GetWindow()->GetMapMode() ); aMap.SetScaleX( rZoomX ); aMap.SetScaleY( rZoomY ); GetWindow()->SetMapMode( aMap ); } //-------------------------------------------------------------------- ErrCode SfxViewShell::DoVerb(long /*nVerb*/) /* [Beschreibung] Virtuelle Methode, um am selektierten Objekt ein Verb auszuf"uhren. Da dieses Objekt nur den abgeleiteten Klassen bekannt ist, muss DoVerb dort "uberschrieben werden. */ { return ERRCODE_SO_NOVERBS; } //-------------------------------------------------------------------- void SfxViewShell::OutplaceActivated( sal_Bool bActive, SfxInPlaceClient* /*pClient*/ ) { if ( !bActive ) GetFrame()->GetFrame().Appear(); } //-------------------------------------------------------------------- void SfxViewShell::InplaceActivating( SfxInPlaceClient* /*pClient*/ ) { // TODO/LATER: painting of the bitmap can be stopped, it is required if CLIPCHILDREN problem #i25788# is not solved, // but may be the bug will not affect the real office vcl windows, then it is not required } //-------------------------------------------------------------------- void SfxViewShell::InplaceDeactivated( SfxInPlaceClient* /*pClient*/ ) { // TODO/LATER: paint the replacement image in normal way if the painting was stopped } //-------------------------------------------------------------------- void SfxViewShell::UIActivating( SfxInPlaceClient* /*pClient*/ ) { uno::Reference < frame::XFrame > xOwnFrame( pFrame->GetFrame().GetFrameInterface() ); uno::Reference < frame::XFramesSupplier > xParentFrame( xOwnFrame->getCreator(), uno::UNO_QUERY ); if ( xParentFrame.is() ) xParentFrame->setActiveFrame( xOwnFrame ); pFrame->GetBindings().HidePopups(sal_True); pFrame->GetDispatcher()->Update_Impl( sal_True ); } //-------------------------------------------------------------------- void SfxViewShell::UIDeactivated( SfxInPlaceClient* /*pClient*/ ) { if ( !pFrame->GetFrame().IsClosing_Impl() || SfxViewFrame::Current() != pFrame ) pFrame->GetDispatcher()->Update_Impl( sal_True ); pFrame->GetBindings().HidePopups(sal_False); // uno::Reference < frame::XFrame > xOwnFrame( pFrame->GetFrame().GetFrameInterface() ); // uno::Reference < frame::XFramesSupplier > xParentFrame( xOwnFrame->getCreator(), uno::UNO_QUERY ); // if ( xParentFrame.is() ) // xParentFrame->setActiveFrame( uno::Reference < frame::XFrame >() ); // Make sure that slot servers are initialized or updated after // an OLE object is deactivated. pFrame->GetBindings().InvalidateAll(sal_True); } //-------------------------------------------------------------------- SfxInPlaceClient* SfxViewShell::FindIPClient ( const uno::Reference < embed::XEmbeddedObject >& xObj, Window* pObjParentWin ) const { SfxInPlaceClientList *pClients = GetIPClientList_Impl(sal_False); if ( !pClients ) return 0; if( !pObjParentWin ) pObjParentWin = GetWindow(); for (sal_uInt16 n=0; n < pClients->Count(); n++) { SfxInPlaceClient *pIPClient = (SfxInPlaceClient*) pClients->GetObject(n); if ( pIPClient->GetObject() == xObj && pIPClient->GetEditWin() == pObjParentWin ) return pIPClient; } return 0; } //-------------------------------------------------------------------- SfxInPlaceClient* SfxViewShell::GetIPClient() const { return GetUIActiveClient(); } //-------------------------------------------------------------------- SfxInPlaceClient* SfxViewShell::GetUIActiveIPClient_Impl() const { // this method is needed as long as SFX still manages the border space for ChildWindows (see SfxFrame::Resize) SfxInPlaceClientList *pClients = GetIPClientList_Impl(sal_False); if ( !pClients ) return 0; for (sal_uInt16 n=0; n < pClients->Count(); n++) { SfxInPlaceClient* pIPClient = pClients->GetObject(n); if ( pIPClient->IsUIActive() ) return pIPClient; } return NULL; } SfxInPlaceClient* SfxViewShell::GetUIActiveClient() const { SfxInPlaceClientList *pClients = GetIPClientList_Impl(sal_False); if ( !pClients ) return 0; for (sal_uInt16 n=0; n < pClients->Count(); n++) { SfxInPlaceClient* pIPClient = pClients->GetObject(n); if ( pIPClient->IsObjectUIActive() ) return pIPClient; } return NULL; } //-------------------------------------------------------------------- void SfxViewShell::Activate( sal_Bool bMDI ) { DBG_CHKTHIS(SfxViewShell, 0); if ( bMDI ) { SfxObjectShell *pSh = GetViewFrame()->GetObjectShell(); if ( pSh->GetModel().is() ) pSh->GetModel()->setCurrentController( GetViewFrame()->GetFrame().GetController() ); SetCurrentDocument(); } } //-------------------------------------------------------------------- void SfxViewShell::Deactivate(sal_Bool /*bMDI*/) { DBG_CHKTHIS(SfxViewShell, 0); } //-------------------------------------------------------------------- void SfxViewShell::AdjustPosSizePixel ( const Point& /*rToolOffset*/,// linke obere Ecke der Tools im Frame-Window const Size& /*rSize*/ // gesamte zur Verf"ugung stehende Gr"o\se ) { DBG_CHKTHIS(SfxViewShell, 0); } //-------------------------------------------------------------------- void SfxViewShell::Move() /* [Beschreibung] Diese virtuelle Methode wird gerufen, wenn das Fenster, in dem die SfxViewShell dargestellt wird eine StarView-Move() Nachricht erh"alt. Die Basisimplementierung braucht nicht gerufen zu werden. [Anmerkung] Diese Methode kann dazu verwendet werden, eine Selektion abzubrechen, um durch das Moven des Fensters erzeugte Maus-Bewegungen anzufangen. Zur Zeit funktioniert die Benachrichtigung nicht In-Place. */ { } //-------------------------------------------------------------------- void SfxViewShell::OuterResizePixel ( const Point& /*rToolOffset*/,// linke obere Ecke der Tools im Frame-Window const Size& /*rSize*/ // gesamte zur Verf"ugung stehende Gr"o\se ) /* [Beschreibung] Diese Methode muss ueberladen werden, um auf "Anderungen der Groesse der View zu reagieren. Dabei definieren wir die View als das Edit-Window zuz"uglich der um das Edit-Window angeordnenten Tools (z.B. Lineale). Das Edit-Window darf weder in Gr"o\se noch Position ver"andert werden. Die Vis-Area der SfxObjectShell, dessen Skalierung und Position d"urfen hier ver"andert werden. Der Hauptanwendungsfall ist dabei, das Ver"andern der Gr"o\se der Vis-Area. "Andert sich durch die neue Berechnung der Border, so mu\s dieser mit <SfxViewShell::SetBorderPixel(const SvBorder&)> gesetzt werden. Erst nach Aufruf von 'SetBorderPixel' ist das Positionieren von Tools erlaubt. [Beispiel] void AppViewSh::OuterViewResizePixel( const Point &rOfs, const Size &rSz ) { // Tool-Positionen und Gr"o\sen von au\sen berechnen, NICHT setzen! // (wegen folgender Border-Berechnung) Point aHLinPos...; Size aHLinSz...; ... // Border f"ur Tools passend zu rSize berechnen und setzen SvBorder aBorder... SetBorderPixel( aBorder ); // ab jetzt sind Positionierungen erlaubt // Tools anordnen pHLin->SetPosSizePixel( aHLinPos, aHLinSz ); ... } [Querverweise] <SfxViewShell::InnerResizePixel(const Point&,const Size& rSize)> */ { DBG_CHKTHIS(SfxViewShell, 0); SetBorderPixel( SvBorder() ); } //-------------------------------------------------------------------- void SfxViewShell::InnerResizePixel ( const Point& /*rToolOffset*/,// linke obere Ecke der Tools im Frame-Window const Size& /*rSize*/ // dem Edit-Win zur Verf"ugung stehende Gr"o\se ) /* [Beschreibung] Diese Methode muss ueberladen werden, um auf "Anderungen der Groesse des Edit-Windows zu reagieren. Das Edit-Window darf weder in Gr"o\se noch Position ver"andert werden. Weder die Vis-Area der SfxObjectShell noch dessen Skalierung oder Position d"urfen ver"andert werden. "Andert sich durch die neue Berechnung der Border, so mu\s dieser mit <SfxViewShell::SetBorderPixel(const SvBorder&)> gesetzt werden. Erst nach Aufruf von 'SetBorderPixel' ist das Positionieren von Tools erlaubt. [Beispiel] void AppViewSh::InnerViewResizePixel( const Point &rOfs, const Size &rSz ) { // Tool-Positionen und Gr"o\sen von innen berechnen, NICHT setzen! // (wegen folgender Border-Berechnung) Point aHLinPos...; Size aHLinSz...; ... // Border f"ur Tools passend zu rSz berechnen und setzen SvBorder aBorder... SetBorderPixel( aBorder ); // ab jetzt sind Positionierungen erlaubt // Tools anordnen pHLin->SetPosSizePixel( aHLinPos, aHLinSz ); ... } [Querverweise] <SfxViewShell::OuterResizePixel(const Point&,const Size& rSize)> */ { DBG_CHKTHIS(SfxViewShell, 0); SetBorderPixel( SvBorder() ); } //-------------------------------------------------------------------- void SfxViewShell::InvalidateBorder() { DBG_CHKTHIS(SfxViewShell, 0); DBG_ASSERT( GetViewFrame(), "SfxViewShell without SfxViewFrame" ); GetViewFrame()->InvalidateBorderImpl( this ); if (pImp->m_pController.is()) { pImp->m_pController->BorderWidthsChanged_Impl(); } } //-------------------------------------------------------------------- void SfxViewShell::SetBorderPixel( const SvBorder &rBorder ) { DBG_CHKTHIS(SfxViewShell, 0); DBG_ASSERT( GetViewFrame(), "SfxViewShell without SfxViewFrame" ); //if ( rBorder != GetBorderPixel()) { GetViewFrame()->SetBorderPixelImpl( this, rBorder ); // notify related controller that border size is changed if (pImp->m_pController.is()) { pImp->m_pController->BorderWidthsChanged_Impl(); } } } //-------------------------------------------------------------------- const SvBorder& SfxViewShell::GetBorderPixel() const { DBG_CHKTHIS(SfxViewShell, 0); DBG_ASSERT( GetViewFrame(), "SfxViewShell without SfxViewFrame" ); return GetViewFrame()->GetBorderPixelImpl( this ); } //-------------------------------------------------------------------- void SfxViewShell::SetWindow ( Window* pViewPort // Pointer auf das Datenfenster bzw. 0 im Destruktor ) /* [Beschreibung] Mit dieser Methode wird der SfxViewShell das Datenfenster mitgeteilt. Dieses wird f"ur den In-Place-Container und f"ur das korrekte Wiederherstellen des Focus ben"otigt. Selbst In-Place-aktiv ist das Umsetzen des ViewPort-Windows verboten. */ { if( pWindow == pViewPort ) return; // ggf. vorhandene IP-Clients disconnecten DisconnectAllClients(); //TODO: should we have a "ReconnectAllClients" method? DiscardClients_Impl(); // View-Port austauschen sal_Bool bHadFocus = pWindow ? pWindow->HasChildPathFocus( sal_True ) : sal_False; pWindow = pViewPort; if( pWindow ) { // Disable automatic GUI mirroring (right-to-left) for document windows pWindow->EnableRTL( sal_False ); } if ( bHadFocus && pWindow ) pWindow->GrabFocus(); //TODO/CLEANUP //brauchen wir die Methode doch noch?! //SFX_APP()->GrabFocus( pWindow ); } //-------------------------------------------------------------------- Size SfxViewShell::GetOptimalSizePixel() const { DBG_ERROR( "Useless call!" ); return Size(); } //------------------------------------------------------------------------ SfxViewShell::SfxViewShell ( SfxViewFrame* pViewFrame, /* <SfxViewFrame>, in dem diese View dargestellt wird */ sal_uInt16 nFlags /* siehe <SfxViewShell-Flags> */ ) : SfxShell(this) , pImp( new SfxViewShell_Impl(nFlags) ) ,pIPClientList( 0 ) ,pFrame(pViewFrame) ,pSubShell(0) ,pWindow(0) ,bNoNewWindow( 0 != (nFlags & SFX_VIEW_NO_NEWWINDOW) ) { DBG_CTOR(SfxViewShell, 0); //pImp->pPrinterCommandQueue = new SfxAsyncPrintExec_Impl( this ); if ( pViewFrame->GetParentViewFrame() ) { pImp->m_bPlugInsActive = pViewFrame->GetParentViewFrame() ->GetViewShell()->pImp->m_bPlugInsActive; } SetMargin( pViewFrame->GetMargin_Impl() ); SetPool( &pViewFrame->GetObjectShell()->GetPool() ); StartListening(*pViewFrame->GetObjectShell()); // in Liste eintragen const SfxViewShell *pThis = this; // wegen der kranken Array-Syntax SfxViewShellArr_Impl &rViewArr = SFX_APP()->GetViewShells_Impl(); rViewArr.Insert(pThis, rViewArr.Count() ); } //-------------------------------------------------------------------- SfxViewShell::~SfxViewShell() { DBG_DTOR(SfxViewShell, 0); // aus Liste austragen const SfxViewShell *pThis = this; SfxViewShellArr_Impl &rViewArr = SFX_APP()->GetViewShells_Impl(); rViewArr.Remove( rViewArr.GetPos(pThis) ); if ( pImp->xClipboardListener.is() ) { pImp->xClipboardListener->DisconnectViewShell(); pImp->xClipboardListener = NULL; } if (pImp->m_pController.is()) { pImp->m_pController->ReleaseShell_Impl(); pImp->m_pController.clear(); } //DELETEZ( pImp->pPrinterCommandQueue ); DELETEZ( pImp ); DELETEZ( pIPClientList ); } //-------------------------------------------------------------------- sal_uInt16 SfxViewShell::PrepareClose ( sal_Bool bUI, // sal_True: Dialoge etc. erlaubt, sal_False: silent-mode sal_Bool /*bForBrowsing*/ ) { SfxPrinter *pPrinter = GetPrinter(); if ( pPrinter && pPrinter->IsPrinting() ) { if ( bUI ) { InfoBox aInfoBox( &GetViewFrame()->GetWindow(), SfxResId( MSG_CANT_CLOSE ) ); aInfoBox.Execute(); } return sal_False; } if( GetViewFrame()->IsInModalMode() ) return sal_False; if( bUI && GetViewFrame()->GetDispatcher()->IsLocked() ) return sal_False; return sal_True; } //-------------------------------------------------------------------- SfxViewShell* SfxViewShell::Current() { SfxViewFrame *pCurrent = SfxViewFrame::Current(); return pCurrent ? pCurrent->GetViewShell() : NULL; } //-------------------------------------------------------------------- SfxViewShell* SfxViewShell::Get( const Reference< XController>& i_rController ) { if ( !i_rController.is() ) return NULL; for ( SfxViewShell* pViewShell = SfxViewShell::GetFirst( NULL, sal_False ); pViewShell; pViewShell = SfxViewShell::GetNext( *pViewShell, NULL, sal_False ) ) { if ( pViewShell->GetController() == i_rController ) return pViewShell; } return NULL; } //-------------------------------------------------------------------- SdrView* SfxViewShell::GetDrawView() const /* [Beschreibung] Diese virtuelle Methode mu\s von den Subklassen "uberladen werden, wenn der Property-Editor zur Verf"ugung stehen soll. Die Default-Implementierung liefert immer 0. */ { return 0; } //-------------------------------------------------------------------- String SfxViewShell::GetSelectionText ( sal_Bool /*bCompleteWords*/ /* sal_False (default) Nur der tats"achlich selektierte Text wird zur"uckgegeben. TRUE Der selektierte Text wird soweit erweitert, da\s nur ganze W"orter zur"uckgegeben werden. Als Worttrenner gelten White-Spaces und die Satzzeichen ".,;" sowie einfache und doppelte Anf"uhrungszeichen. */ ) /* [Beschreibung] Diese Methode kann von Anwendungsprogrammierer "uberladen werden, um einen Text zur"uckzuliefern, der in der aktuellen Selektion steht. Dieser wird z.B. beim Versenden (email) verwendet. Mit "CompleteWords == TRUE" ger"ufen, reicht z.B. auch der Cursor, der in einer URL steht, um die gesamte URL zu liefern. */ { return String(); } //-------------------------------------------------------------------- sal_Bool SfxViewShell::HasSelection( sal_Bool ) const /* [Beschreibung] Mit dieser virtuellen Methode kann z.B. ein Dialog abfragen, ob in der aktuellen View etwas selektiert ist. Wenn der Parameter <sal_Bool> sal_True ist, wird abgefragt, ob Text selektiert ist. */ { return sal_False; } //-------------------------------------------------------------------- void SfxViewShell::SetSubShell( SfxShell *pShell ) /* [Beschreibung] Mit dieser Methode kann eine Selektions- oder Cursor-Shell angemeldet werden, die automatisch unmittelbar nach der SfxViewShell auf den SfxDispatcher gepusht wird, und automatisch umittelbar vor ihr gepoppt wird. Ist die SfxViewShell-Instanz bereits gepusht, dann wird pShell sofort ebenfalls gepusht. Wird mit SetSubShell eine andere SfxShell Instanz angemeldet, als vorher angemeldet war, wird die zuvor angemeldete ggf. automatisch gepoppt. Mit pShell==0 kann daher die aktuelle Sub-Shell abgemeldet werden. */ { // ist diese ViewShell "uberhaupt aktiv? SfxDispatcher *pDisp = pFrame->GetDispatcher(); if ( pDisp->IsActive(*this) ) { // Dispatcher updaten if ( pSubShell ) pDisp->Pop(*pSubShell); if ( pShell ) pDisp->Push(*pShell); pDisp->Flush(); } pSubShell = pShell; } void SfxViewShell::AddSubShell( SfxShell& rShell ) { pImp->aArr.Insert( &rShell, pImp->aArr.Count() ); SfxDispatcher *pDisp = pFrame->GetDispatcher(); if ( pDisp->IsActive(*this) ) { pDisp->Push(rShell); pDisp->Flush(); } } void SfxViewShell::RemoveSubShell( SfxShell* pShell ) { SfxDispatcher *pDisp = pFrame->GetDispatcher(); if ( !pShell ) { sal_uInt16 nCount = pImp->aArr.Count(); if ( pDisp->IsActive(*this) ) { for ( sal_uInt16 n=nCount; n>0; n-- ) pDisp->Pop( *pImp->aArr[n-1] ); pDisp->Flush(); } pImp->aArr.Remove(0, nCount); } else { sal_uInt16 nPos = pImp->aArr.GetPos( pShell ); if ( nPos != 0xFFFF ) { pImp->aArr.Remove( nPos ); if ( pDisp->IsActive(*this) ) { pDisp->RemoveShell_Impl( *pShell ); pDisp->Flush(); } } } } SfxShell* SfxViewShell::GetSubShell( sal_uInt16 nNo ) { sal_uInt16 nCount = pImp->aArr.Count(); if ( nNo<nCount ) return pImp->aArr[nCount-nNo-1]; return NULL; } void SfxViewShell::PushSubShells_Impl( sal_Bool bPush ) { sal_uInt16 nCount = pImp->aArr.Count(); SfxDispatcher *pDisp = pFrame->GetDispatcher(); if ( bPush ) { for ( sal_uInt16 n=0; n<nCount; n++ ) pDisp->Push( *pImp->aArr[n] ); } else if ( nCount ) { SfxShell& rPopUntil = *pImp->aArr[0]; if ( pDisp->GetShellLevel( rPopUntil ) != USHRT_MAX ) pDisp->Pop( rPopUntil, SFX_SHELL_POP_UNTIL ); } pDisp->Flush(); } //-------------------------------------------------------------------- void SfxViewShell::WriteUserData( String&, sal_Bool ) { } //-------------------------------------------------------------------- void SfxViewShell::ReadUserData(const String&, sal_Bool ) { } void SfxViewShell::ReadUserDataSequence ( const ::com::sun::star::uno::Sequence < ::com::sun::star::beans::PropertyValue >&, sal_Bool ) { } void SfxViewShell::WriteUserDataSequence ( ::com::sun::star::uno::Sequence < ::com::sun::star::beans::PropertyValue >&, sal_Bool ) { } //-------------------------------------------------------------------- // returns the first shell of spec. type viewing the specified doc. SfxViewShell* SfxViewShell::GetFirst ( const TypeId* pType, sal_Bool bOnlyVisible ) { // search for a SfxViewShell of the specified type SfxViewShellArr_Impl &rShells = SFX_APP()->GetViewShells_Impl(); SfxViewFrameArr_Impl &rFrames = SFX_APP()->GetViewFrames_Impl(); for ( sal_uInt16 nPos = 0; nPos < rShells.Count(); ++nPos ) { SfxViewShell *pShell = rShells.GetObject(nPos); if ( pShell ) { // sometimes dangling SfxViewShells exist that point to a dead SfxViewFrame // these ViewShells shouldn't be accessible anymore // a destroyed ViewFrame is not in the ViewFrame array anymore, so checking this array helps for ( sal_uInt16 n=0; n<rFrames.Count(); ++n ) { SfxViewFrame *pFrame = rFrames.GetObject(n); if ( pFrame == pShell->GetViewFrame() ) { // only ViewShells with a valid ViewFrame will be returned if ( ( !bOnlyVisible || pFrame->IsVisible() ) && ( !pType || pShell->IsA(*pType) ) ) return pShell; break; } } } } return 0; } //-------------------------------------------------------------------- // returns the next shell of spec. type viewing the specified doc. SfxViewShell* SfxViewShell::GetNext ( const SfxViewShell& rPrev, const TypeId* pType, sal_Bool bOnlyVisible ) { SfxViewShellArr_Impl &rShells = SFX_APP()->GetViewShells_Impl(); SfxViewFrameArr_Impl &rFrames = SFX_APP()->GetViewFrames_Impl(); sal_uInt16 nPos; for ( nPos = 0; nPos < rShells.Count(); ++nPos ) if ( rShells.GetObject(nPos) == &rPrev ) break; for ( ++nPos; nPos < rShells.Count(); ++nPos ) { SfxViewShell *pShell = rShells.GetObject(nPos); if ( pShell ) { // sometimes dangling SfxViewShells exist that point to a dead SfxViewFrame // these ViewShells shouldn't be accessible anymore // a destroyed ViewFrame is not in the ViewFrame array anymore, so checking this array helps for ( sal_uInt16 n=0; n<rFrames.Count(); ++n ) { SfxViewFrame *pFrame = rFrames.GetObject(n); if ( pFrame == pShell->GetViewFrame() ) { // only ViewShells with a valid ViewFrame will be returned if ( ( !bOnlyVisible || pFrame->IsVisible() ) && ( !pType || pShell->IsA(*pType) ) ) return pShell; break; } } } } return 0; } //-------------------------------------------------------------------- void SfxViewShell::Notify( SfxBroadcaster& rBC, const SfxHint& rHint ) { if ( rHint.IsA(TYPE(SfxEventHint)) ) { switch ( ((SfxEventHint&)rHint).GetEventId() ) { case SFX_EVENT_LOADFINISHED: { if ( GetController().is() ) { // avoid access to dangling ViewShells SfxViewFrameArr_Impl &rFrames = SFX_APP()->GetViewFrames_Impl(); for ( sal_uInt16 n=0; n<rFrames.Count(); ++n ) { SfxViewFrame *frame = rFrames.GetObject(n); if ( frame == GetViewFrame() && &rBC == GetObjectShell() ) { SfxItemSet* pSet = GetObjectShell()->GetMedium()->GetItemSet(); SFX_ITEMSET_ARG( pSet, pItem, SfxUnoAnyItem, SID_VIEW_DATA, sal_False ); if ( pItem ) { pImp->m_pController->restoreViewData( pItem->GetValue() ); pSet->ClearItem( SID_VIEW_DATA ); } break; } } } break; } } } } //-------------------------------------------------------------------- sal_Bool SfxViewShell::ExecKey_Impl(const KeyEvent& aKey) { if (!pImp->m_pAccExec.get()) { pImp->m_pAccExec.reset( ::svt::AcceleratorExecute::createAcceleratorHelper() ); pImp->m_pAccExec->init(::comphelper::getProcessServiceFactory(), pFrame->GetFrame().GetFrameInterface()); } return pImp->m_pAccExec->execute(aKey.GetKeyCode()); } //-------------------------------------------------------------------- FASTBOOL SfxViewShell::KeyInput( const KeyEvent &rKeyEvent ) /* [Beschreibung] Diese Methode f"uhrt das KeyEvent 'rKeyEvent' "uber die an dieser SfxViewShell direkt oder indirekt (z.B. via Applikation) konfigurierten Tasten (Accelerator) aus. [R"uckgabewert] FASTBOOL sal_True die Taste ist konfiguriert, der betreffende Handler wurde gerufen FALSE die Taste ist nicht konfiguriert, es konnte also kein Handler gerufen werden [Querverweise] <SfxApplication::KeyInput(const KeyEvent&)> */ { return ExecKey_Impl(rKeyEvent); } bool SfxViewShell::GlobalKeyInput_Impl( const KeyEvent &rKeyEvent ) { return ExecKey_Impl(rKeyEvent); } //-------------------------------------------------------------------- void SfxViewShell::ShowCursor( FASTBOOL /*bOn*/ ) /* [Beschreibung] Diese Methode mu\s von Subklassen "uberladen werden, damit vom SFx aus der Cursor ein- und ausgeschaltet werden kann. Dies geschieht z.B. bei laufendem <SfxProgress>. */ { } //-------------------------------------------------------------------- void SfxViewShell::GotFocus() const /* [Beschreibung] Diese Methode mu\s vom Applikationsentwickler gerufen werden, wenn das Edit-Window den Focus erhalten hat. Der SFx hat so z.B. die M"oglichkeit, den Accelerator einzuschalten. [Anmerkung] <StarView> liefert leider keine M"oglichkeit, solche Events 'von der Seite' einzuh"angen. */ { } //-------------------------------------------------------------------- void SfxViewShell::ResetAllClients_Impl( SfxInPlaceClient *pIP ) { SfxInPlaceClientList *pClients = GetIPClientList_Impl(sal_False); if ( !pClients ) return; for ( sal_uInt16 n=0; n < pClients->Count(); n++ ) { SfxInPlaceClient* pIPClient = pClients->GetObject(n); if( pIPClient != pIP ) pIPClient->ResetObject(); } } //-------------------------------------------------------------------- void SfxViewShell::DisconnectAllClients() { SfxInPlaceClientList *pClients = GetIPClientList_Impl(sal_False); if ( !pClients ) return; for ( sal_uInt16 n=0; n<pClients->Count(); ) // clients will remove themselves from the list delete pClients->GetObject(n); } //-------------------------------------------------------------------- void SfxViewShell::QueryObjAreaPixel( Rectangle& ) const { } //-------------------------------------------------------------------- void SfxViewShell::AdjustVisArea(const Rectangle& rRect) { DBG_ASSERT (pFrame, "Kein Frame?"); GetObjectShell()->SetVisArea( rRect ); } //-------------------------------------------------------------------- void SfxViewShell::VisAreaChanged(const Rectangle& /*rVisArea*/) { SfxInPlaceClientList *pClients = GetIPClientList_Impl(sal_False); if ( !pClients ) return; for (sal_uInt16 n=0; n < pClients->Count(); n++) { SfxInPlaceClient* pIPClient = pClients->GetObject(n); if ( pIPClient->IsObjectInPlaceActive() ) // client is active, notify client that the VisArea might have changed pIPClient->VisAreaChanged(); } } //-------------------------------------------------------------------- void SfxViewShell::CheckIPClient_Impl( SfxInPlaceClient *pIPClient, const Rectangle& rVisArea ) { if ( GetObjectShell()->IsInClose() ) return; sal_Bool bAlwaysActive = ( ( pIPClient->GetObjectMiscStatus() & embed::EmbedMisc::EMBED_ACTIVATEIMMEDIATELY ) != 0 ); sal_Bool bActiveWhenVisible = ( ( pIPClient->GetObjectMiscStatus() & embed::EmbedMisc::MS_EMBED_ACTIVATEWHENVISIBLE ) != 0 ); // this method is called when either a client is created or the "Edit/Plugins" checkbox is checked if ( !pIPClient->IsObjectInPlaceActive() && pImp->m_bPlugInsActive ) { // object in client is currently not active // check if the object wants to be activated always or when it becomes at least partially visible // TODO/LATER: maybe we should use the scaled area instead of the ObjArea?! if ( bAlwaysActive || (bActiveWhenVisible && rVisArea.IsOver(pIPClient->GetObjArea())) ) { try { pIPClient->GetObject()->changeState( embed::EmbedStates::INPLACE_ACTIVE ); } catch ( uno::Exception& ) { } } } else if (!pImp->m_bPlugInsActive) { // object in client is currently active and "Edit/Plugins" checkbox is selected // check if the object wants to be activated always or when it becomes at least partially visible // in this case selecting of the "Edit/Plugin" checkbox should let such objects deactivate if ( bAlwaysActive || bActiveWhenVisible ) pIPClient->GetObject()->changeState( embed::EmbedStates::RUNNING ); } } //-------------------------------------------------------------------- sal_Bool SfxViewShell::PlugInsActive() const { return pImp->m_bPlugInsActive; } //-------------------------------------------------------------------- void SfxViewShell::DiscardClients_Impl() /* [Beschreibung] Diese Methode dient dazu, vor dem Schlie\sen eines Dokuments das Speichern der Objekte zu verhindern, wenn der Benutzer Schlie\en ohne Speichern gew"ahlt hatte. */ { SfxInPlaceClientList *pClients = GetIPClientList_Impl(sal_False); if ( !pClients ) return; for (sal_uInt16 n=0; n < pClients->Count(); ) delete pClients->GetObject(n); } //-------------------------------------------------------------------- SfxScrollingMode SfxViewShell::GetScrollingMode() const { return pImp->m_eScroll; } //-------------------------------------------------------------------- void SfxViewShell::SetScrollingMode( SfxScrollingMode eMode ) { pImp->m_eScroll = eMode; } //-------------------------------------------------------------------- SfxObjectShell* SfxViewShell::GetObjectShell() { return pFrame ? pFrame->GetObjectShell() : NULL; } //-------------------------------------------------------------------- Reference< XModel > SfxViewShell::GetCurrentDocument() const { Reference< XModel > xDocument; const SfxObjectShell* pDocShell( const_cast< SfxViewShell* >( this )->GetObjectShell() ); OSL_ENSURE( pDocShell, "SfxViewFrame::GetCurrentDocument: no DocShell!?" ); if ( pDocShell ) xDocument = pDocShell->GetModel(); return xDocument; } //-------------------------------------------------------------------- void SfxViewShell::SetCurrentDocument() const { uno::Reference< frame::XModel > xDocument( GetCurrentDocument() ); if ( xDocument.is() ) SfxObjectShell::SetCurrentComponent( xDocument ); } //-------------------------------------------------------------------- const Size& SfxViewShell::GetMargin() const { return pImp->aMargin; } //-------------------------------------------------------------------- void SfxViewShell::SetMargin( const Size& rSize ) { // Der default-Margin wurde "geeicht" mit www.apple.com !! Size aMargin = rSize; if ( aMargin.Width() == -1 ) aMargin.Width() = DEFAULT_MARGIN_WIDTH; if ( aMargin.Height() == -1 ) aMargin.Height() = DEFAULT_MARGIN_HEIGHT; if ( aMargin != pImp->aMargin ) { pImp->aMargin = aMargin; MarginChanged(); } } //-------------------------------------------------------------------- void SfxViewShell::MarginChanged() { } //-------------------------------------------------------------------- sal_Bool SfxViewShell::IsShowView_Impl() const { return pImp->m_bIsShowView; } //-------------------------------------------------------------------- SfxFrame* SfxViewShell::GetSmartSelf( SfxFrame* pSelf, SfxMedium& /*rMedium*/ ) { return pSelf; } //------------------------------------------------------------------------ void SfxViewShell::JumpToMark( const String& rMark ) { SfxStringItem aMarkItem( SID_JUMPTOMARK, rMark ); GetViewFrame()->GetDispatcher()->Execute( SID_JUMPTOMARK, SFX_CALLMODE_SYNCHRON|SFX_CALLMODE_RECORD, &aMarkItem, 0L ); } //------------------------------------------------------------------------ SfxInPlaceClientList* SfxViewShell::GetIPClientList_Impl( sal_Bool bCreate ) const { if ( !pIPClientList && bCreate ) ( (SfxViewShell*) this )->pIPClientList = new SfxInPlaceClientList; return pIPClientList; } void SfxViewShell::SetController( SfxBaseController* pController ) { pImp->m_pController = pController; pImp->m_bControllerSet = true; // there should be no old listener, but if there is one, it should be disconnected if ( pImp->xClipboardListener.is() ) pImp->xClipboardListener->DisconnectViewShell(); pImp->xClipboardListener = new SfxClipboardChangeListener( this, GetClipboardNotifier() ); } Reference < XController > SfxViewShell::GetController() { return pImp->m_pController.get(); } SfxBaseController* SfxViewShell::GetBaseController_Impl() const { return pImp->m_pController.get(); } void SfxViewShell::AddContextMenuInterceptor_Impl( const REFERENCE< XCONTEXTMENUINTERCEPTOR >& xInterceptor ) { pImp->aInterceptorContainer.addInterface( xInterceptor ); } void SfxViewShell::RemoveContextMenuInterceptor_Impl( const REFERENCE< XCONTEXTMENUINTERCEPTOR >& xInterceptor ) { pImp->aInterceptorContainer.removeInterface( xInterceptor ); } ::cppu::OInterfaceContainerHelper& SfxViewShell::GetContextMenuInterceptors() const { return pImp->aInterceptorContainer; } void Change( Menu* pMenu, SfxViewShell* pView ) { SfxDispatcher *pDisp = pView->GetViewFrame()->GetDispatcher(); sal_uInt16 nCount = pMenu->GetItemCount(); for ( sal_uInt16 nPos=0; nPos<nCount; ++nPos ) { sal_uInt16 nId = pMenu->GetItemId(nPos); String aCmd = pMenu->GetItemCommand(nId); PopupMenu* pPopup = pMenu->GetPopupMenu(nId); if ( pPopup ) { Change( pPopup, pView ); } else if ( nId < 5000 ) { if ( aCmd.CompareToAscii(".uno:", 5) == 0 ) { for (sal_uInt16 nIdx=0;;) { SfxShell *pShell=pDisp->GetShell(nIdx++); if (pShell == NULL) break; const SfxInterface *pIFace = pShell->GetInterface(); const SfxSlot* pSlot = pIFace->GetSlot( aCmd ); if ( pSlot ) { pMenu->InsertItem( pSlot->GetSlotId(), pMenu->GetItemText( nId ), pMenu->GetItemBits( nId ), nPos ); pMenu->SetItemCommand( pSlot->GetSlotId(), aCmd ); pMenu->RemoveItem( nPos+1 ); break; } } } } } } sal_Bool SfxViewShell::TryContextMenuInterception( Menu& rIn, const ::rtl::OUString& rMenuIdentifier, Menu*& rpOut, ui::ContextMenuExecuteEvent aEvent ) { rpOut = NULL; sal_Bool bModified = sal_False; // create container from menu // #110897# // aEvent.ActionTriggerContainer = ::framework::ActionTriggerHelper::CreateActionTriggerContainerFromMenu( &rIn ); aEvent.ActionTriggerContainer = ::framework::ActionTriggerHelper::CreateActionTriggerContainerFromMenu( ::comphelper::getProcessServiceFactory(), &rIn, &rMenuIdentifier ); // get selection from controller aEvent.Selection = uno::Reference < view::XSelectionSupplier > ( GetController(), uno::UNO_QUERY ); // call interceptors ::cppu::OInterfaceIteratorHelper aIt( pImp->aInterceptorContainer ); while( aIt.hasMoreElements() ) { try { ui::ContextMenuInterceptorAction eAction = ((ui::XContextMenuInterceptor*)aIt.next())->notifyContextMenuExecute( aEvent ); switch ( eAction ) { case ui::ContextMenuInterceptorAction_CANCELLED : // interceptor does not want execution return sal_False; case ui::ContextMenuInterceptorAction_EXECUTE_MODIFIED : // interceptor wants his modified menu to be executed bModified = sal_True; break; case ui::ContextMenuInterceptorAction_CONTINUE_MODIFIED : // interceptor has modified menu, but allows for calling other interceptors bModified = sal_True; continue; case ui::ContextMenuInterceptorAction_IGNORED : // interceptor is indifferent continue; default: DBG_ERROR("Wrong return value of ContextMenuInterceptor!"); continue; } } catch( uno::RuntimeException& ) { aIt.remove(); } break; } if ( bModified ) { // container was modified, create a new window out of it rpOut = new PopupMenu; ::framework::ActionTriggerHelper::CreateMenuFromActionTriggerContainer( rpOut, aEvent.ActionTriggerContainer ); Change( rpOut, this ); } return sal_True; } void SfxViewShell::TakeOwnerShip_Impl() { // currently there is only one reason to take OwnerShip: a hidden frame is printed // so the ViewShell will check this on EndPrint (->prnmon.cxx) pImp->m_bGotOwnership = true; } void SfxViewShell::TakeFrameOwnerShip_Impl() { // currently there is only one reason to take OwnerShip: a hidden frame is printed // so the ViewShell will check this on EndPrint (->prnmon.cxx) pImp->m_bGotFrameOwnership = true; } void SfxViewShell::CheckOwnerShip_Impl() { sal_Bool bSuccess = sal_False; if (pImp->m_bGotOwnership) { uno::Reference < util::XCloseable > xModel( GetObjectShell()->GetModel(), uno::UNO_QUERY ); if ( xModel.is() ) { try { // this call will destroy this object in case of success! xModel->close( sal_True ); bSuccess = sal_True; } catch ( util::CloseVetoException& ) { } } } if (!bSuccess && pImp->m_bGotFrameOwnership) { // document couldn't be closed or it shouldn't, now try at least to close the frame uno::Reference < util::XCloseable > xFrame( GetViewFrame()->GetFrame().GetFrameInterface(), com::sun::star::uno::UNO_QUERY ); if ( xFrame.is() ) { try { xFrame->close( sal_True ); } catch ( util::CloseVetoException& ) { } } } } long SfxViewShell::HandleNotifyEvent_Impl( NotifyEvent& rEvent ) { if (pImp->m_pController.is()) return pImp->m_pController->HandleEvent_Impl( rEvent ); return 0; } sal_Bool SfxViewShell::HasKeyListeners_Impl() { return (pImp->m_pController.is()) ? pImp->m_pController->HasKeyListeners_Impl() : sal_False; } sal_Bool SfxViewShell::HasMouseClickListeners_Impl() { return (pImp->m_pController.is()) ? pImp->m_pController->HasMouseClickListeners_Impl() : sal_False; } void SfxViewShell::SetAdditionalPrintOptions( const com::sun::star::uno::Sequence < com::sun::star::beans::PropertyValue >& rOpts ) { pImp->aPrintOpts = rOpts; // GetObjectShell()->Broadcast( SfxPrintingHint( -3, NULL, NULL, rOpts ) ); } sal_Bool SfxViewShell::Escape() { return GetViewFrame()->GetBindings().Execute( SID_TERMINATE_INPLACEACTIVATION ); } Reference< view::XRenderable > SfxViewShell::GetRenderable() { Reference< view::XRenderable >xRender; SfxObjectShell* pObj = GetObjectShell(); if( pObj ) { Reference< frame::XModel > xModel( pObj->GetModel() ); if( xModel.is() ) xRender = Reference< view::XRenderable >( xModel, UNO_QUERY ); } return xRender; } uno::Reference< datatransfer::clipboard::XClipboardNotifier > SfxViewShell::GetClipboardNotifier() { uno::Reference< datatransfer::clipboard::XClipboardNotifier > xClipboardNotifier; if ( GetViewFrame() ) xClipboardNotifier = uno::Reference< datatransfer::clipboard::XClipboardNotifier >( GetViewFrame()->GetWindow().GetClipboard(), uno::UNO_QUERY ); return xClipboardNotifier; } void SfxViewShell::AddRemoveClipboardListener( const uno::Reference < datatransfer::clipboard::XClipboardListener >& rClp, sal_Bool bAdd ) { try { if ( GetViewFrame() ) { uno::Reference< datatransfer::clipboard::XClipboard > xClipboard( GetViewFrame()->GetWindow().GetClipboard() ); if( xClipboard.is() ) { uno::Reference< datatransfer::clipboard::XClipboardNotifier > xClpbrdNtfr( xClipboard, uno::UNO_QUERY ); if( xClpbrdNtfr.is() ) { if( bAdd ) xClpbrdNtfr->addClipboardListener( rClp ); else xClpbrdNtfr->removeClipboardListener( rClp ); } } } } catch( const uno::Exception& ) { } }