/************************************************************** * * 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 #include #include #include #include #include // #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifndef _UNOTOOLS_PROCESSFACTORY_HXX #include #endif #include #include #include #include #include #include #include #include #include #ifdef UNX // need symlink #include #include #endif #include #include "sfx2/sfxresid.hxx" using namespace ::com::sun::star::uno; using namespace ::com::sun::star::frame; using namespace ::com::sun::star::container; using namespace ::com::sun::star::io; using namespace ::com::sun::star::lang; using namespace ::com::sun::star::beans; using namespace ::com::sun::star::util; using namespace ::com::sun::star::ui::dialogs; using namespace ::vos; #ifdef WNT using ::rtl::OUString; #else using namespace ::rtl; #endif using namespace ::sfx2; #ifdef ENABLE_QUICKSTART_APPLET # if !defined(WIN32) && !defined(QUARTZ) extern "C" { static void SAL_CALL thisModule() {} } # endif #endif #if defined(UNX) && defined(ENABLE_SYSTRAY_GTK) #define PLUGIN_NAME libqstart_gtk.so #endif class SfxNotificationListener_Impl : public cppu::WeakImplHelper1< XDispatchResultListener > { public: virtual void SAL_CALL dispatchFinished( const DispatchResultEvent& aEvent ) throw( RuntimeException ); virtual void SAL_CALL disposing( const EventObject& aEvent ) throw( RuntimeException ); }; void SAL_CALL SfxNotificationListener_Impl::dispatchFinished( const DispatchResultEvent& ) throw( RuntimeException ) { ShutdownIcon::LeaveModalMode(); } void SAL_CALL SfxNotificationListener_Impl::disposing( const EventObject& ) throw( RuntimeException ) { } SFX_IMPL_XSERVICEINFO( ShutdownIcon, "com.sun.star.office.Quickstart", "com.sun.star.comp.desktop.QuickstartWrapper" ) \ SFX_IMPL_ONEINSTANCEFACTORY( ShutdownIcon ); bool ShutdownIcon::bModalMode = false; ShutdownIcon* ShutdownIcon::pShutdownIcon = NULL; // To remove conditionals extern "C" { static void disabled_initSystray() { } static void disabled_deInitSystray() { } } #define DOSTRING( x ) #x #define STRING( x ) DOSTRING( x ) bool ShutdownIcon::LoadModule( osl::Module **pModule, oslGenericFunction *pInit, oslGenericFunction *pDeInit ) { if ( pModule ) { OSL_ASSERT ( pInit && pDeInit ); *pInit = *pDeInit = NULL; *pModule = NULL; } #ifdef ENABLE_QUICKSTART_APPLET # ifdef WIN32 if ( pModule ) { *pInit = win32_init_sys_tray; *pDeInit = win32_shutdown_sys_tray; } return true; # elif defined QUARTZ *pInit = aqua_init_systray; *pDeInit = aqua_shutdown_systray; return true; # else // UNX osl::Module *pPlugin; pPlugin = new osl::Module(); oslGenericFunction pTmpInit = NULL; oslGenericFunction pTmpDeInit = NULL; if ( pPlugin->loadRelative( &thisModule, OUString( RTL_CONSTASCII_USTRINGPARAM( STRING( PLUGIN_NAME ) ) ) ) ) { pTmpInit = pPlugin->getFunctionSymbol( OUString( RTL_CONSTASCII_USTRINGPARAM( "plugin_init_sys_tray" ) ) ); pTmpDeInit = pPlugin->getFunctionSymbol( OUString( RTL_CONSTASCII_USTRINGPARAM( "plugin_shutdown_sys_tray" ) ) ); } if ( !pTmpInit || !pTmpDeInit ) { delete pPlugin; pPlugin = NULL; } if ( pModule ) { *pModule = pPlugin; *pInit = pTmpInit; *pDeInit = pTmpDeInit; } else { bool bRet = pPlugin != NULL; delete pPlugin; return bRet; } # endif // UNX #endif // ENABLE_QUICKSTART_APPLET if ( pModule ) { if ( !*pInit ) *pInit = disabled_initSystray; if ( !*pDeInit ) *pDeInit = disabled_deInitSystray; } return true; } struct AsyncDesktopTerminationData { Reference< XDesktop > mxDesktop; AsyncDesktopTerminationData( const Reference< XDesktop > &xDesktop ) : mxDesktop( xDesktop ) {} }; class IdleUnloader : Timer { ::osl::Module *m_pModule; public: IdleUnloader (::osl::Module **pModule) : m_pModule (*pModule) { *pModule = NULL; Start(); } virtual void Timeout() { delete m_pModule; delete this; } }; void ShutdownIcon::initSystray() { if (m_bInitialized) return; m_bInitialized = true; (void) LoadModule( &m_pPlugin, &m_pInitSystray, &m_pDeInitSystray ); m_bVeto = true; m_pInitSystray(); } void ShutdownIcon::deInitSystray() { if (!m_bInitialized) return; if (m_pDeInitSystray) m_pDeInitSystray(); m_bVeto = false; m_pInitSystray = 0; m_pDeInitSystray = 0; new IdleUnloader (&m_pPlugin); delete m_pFileDlg; m_pFileDlg = NULL; m_bInitialized = false; } ShutdownIcon::ShutdownIcon( Reference< XMultiServiceFactory > aSMgr ) : ShutdownIconServiceBase( m_aMutex ), m_bVeto ( false ), m_bListenForTermination ( false ), m_bSystemDialogs( false ), m_pResMgr( NULL ), m_pFileDlg( NULL ), m_xServiceManager( aSMgr ), m_pInitSystray( 0 ), m_pDeInitSystray( 0 ), m_pPlugin( 0 ), m_bInitialized( false ) { m_bSystemDialogs = SvtMiscOptions().UseSystemFileDialog(); } ShutdownIcon::~ShutdownIcon() { deInitSystray(); new IdleUnloader (&m_pPlugin); } // --------------------------------------------------------------------------- void ShutdownIcon::OpenURL( const ::rtl::OUString& aURL, const ::rtl::OUString& rTarget, const Sequence< PropertyValue >& aArgs ) { if ( getInstance() && getInstance()->m_xDesktop.is() ) { Reference < XDispatchProvider > xDispatchProvider( getInstance()->m_xDesktop, UNO_QUERY ); if ( xDispatchProvider.is() ) { com::sun::star::util::URL aDispatchURL; aDispatchURL.Complete = aURL; Reference < com::sun::star::util::XURLTransformer > xURLTransformer( ::comphelper::getProcessServiceFactory()->createInstance( OUString::createFromAscii("com.sun.star.util.URLTransformer") ), com::sun::star::uno::UNO_QUERY ); if ( xURLTransformer.is() ) { try { Reference< com::sun::star::frame::XDispatch > xDispatch; xURLTransformer->parseStrict( aDispatchURL ); xDispatch = xDispatchProvider->queryDispatch( aDispatchURL, rTarget, 0 ); if ( xDispatch.is() ) xDispatch->dispatch( aDispatchURL, aArgs ); } catch ( com::sun::star::uno::RuntimeException& ) { throw; } catch ( com::sun::star::uno::Exception& ) { } } } } } // --------------------------------------------------------------------------- void ShutdownIcon::FileOpen() { if ( getInstance() && getInstance()->m_xDesktop.is() ) { ::vos::OGuard aGuard( Application::GetSolarMutex() ); EnterModalMode(); getInstance()->StartFileDialog(); } } // --------------------------------------------------------------------------- void ShutdownIcon::FromTemplate() { if ( getInstance() && getInstance()->m_xDesktop.is() ) { Reference < ::com::sun::star::frame::XFramesSupplier > xDesktop ( getInstance()->m_xDesktop, UNO_QUERY); Reference < ::com::sun::star::frame::XFrame > xFrame( xDesktop->getActiveFrame() ); if ( !xFrame.is() ) xFrame = Reference < ::com::sun::star::frame::XFrame >( xDesktop, UNO_QUERY ); URL aTargetURL; aTargetURL.Complete = OUString( RTL_CONSTASCII_USTRINGPARAM( "slot:5500" ) ); Reference < XURLTransformer > xTrans( ::comphelper::getProcessServiceFactory()->createInstance( rtl::OUString::createFromAscii("com.sun.star.util.URLTransformer" )), UNO_QUERY ); xTrans->parseStrict( aTargetURL ); Reference < ::com::sun::star::frame::XDispatchProvider > xProv( xFrame, UNO_QUERY ); Reference < ::com::sun::star::frame::XDispatch > xDisp; if ( xProv.is() ) { if ( aTargetURL.Protocol.compareToAscii("slot:") == COMPARE_EQUAL ) xDisp = xProv->queryDispatch( aTargetURL, ::rtl::OUString(), 0 ); else xDisp = xProv->queryDispatch( aTargetURL, ::rtl::OUString::createFromAscii("_blank"), 0 ); } if ( xDisp.is() ) { Sequence aArgs(1); PropertyValue* pArg = aArgs.getArray(); pArg[0].Name = rtl::OUString::createFromAscii("Referer"); pArg[0].Value <<= ::rtl::OUString::createFromAscii("private:user"); Reference< ::com::sun::star::frame::XNotifyingDispatch > xNotifyer( xDisp, UNO_QUERY ); if ( xNotifyer.is() ) { EnterModalMode(); xNotifyer->dispatchWithNotification( aTargetURL, aArgs, new SfxNotificationListener_Impl() ); } else xDisp->dispatch( aTargetURL, aArgs ); } } } // --------------------------------------------------------------------------- #include OUString ShutdownIcon::GetResString( int id ) { ::vos::OGuard aGuard( Application::GetSolarMutex() ); if( ! m_pResMgr ) m_pResMgr = SfxResId::GetResMgr(); ResId aResId( id, *m_pResMgr ); aResId.SetRT( RSC_STRING ); if( !m_pResMgr || !m_pResMgr->IsAvailable( aResId ) ) return OUString(); UniString aRes( ResId(id, *m_pResMgr) ); return OUString( aRes ); } // --------------------------------------------------------------------------- OUString ShutdownIcon::GetUrlDescription( const OUString& aUrl ) { ::vos::OGuard aGuard( Application::GetSolarMutex() ); return OUString( SvFileInformationManager::GetDescription( INetURLObject( aUrl ) ) ); } // --------------------------------------------------------------------------- void ShutdownIcon::StartFileDialog() { ::vos::OGuard aGuard( Application::GetSolarMutex() ); bool bDirty = ( m_bSystemDialogs != static_cast(SvtMiscOptions().UseSystemFileDialog()) ); if ( m_pFileDlg && bDirty ) { // Destroy instance as changing the system file dialog setting // forces us to create a new FileDialogHelper instance! delete m_pFileDlg; m_pFileDlg = NULL; } if ( !m_pFileDlg ) m_pFileDlg = new FileDialogHelper( WB_OPEN | SFXWB_MULTISELECTION, String() ); m_pFileDlg->StartExecuteModal( STATIC_LINK( this, ShutdownIcon, DialogClosedHdl_Impl ) ); } // --------------------------------------------------------------------------- IMPL_STATIC_LINK( ShutdownIcon, DialogClosedHdl_Impl, FileDialogHelper*, EMPTYARG ) { DBG_ASSERT( pThis->m_pFileDlg, "ShutdownIcon, DialogClosedHdl_Impl(): no file dialog" ); // use ctor for filling up filters automatically! #89169# if ( ERRCODE_NONE == pThis->m_pFileDlg->GetError() ) { Reference< XFilePicker > xPicker = pThis->m_pFileDlg->GetFilePicker(); try { if ( xPicker.is() ) { Reference < XFilePickerControlAccess > xPickerControls ( xPicker, UNO_QUERY ); Reference < XFilterManager > xFilterManager ( xPicker, UNO_QUERY ); Sequence< OUString > sFiles = xPicker->getFiles(); int nFiles = sFiles.getLength(); int nArgs=3; Sequence< PropertyValue > aArgs(3); Reference < com::sun::star::task::XInteractionHandler > xInteraction( ::comphelper::getProcessServiceFactory()->createInstance( OUString::createFromAscii("com.sun.star.task.InteractionHandler") ), com::sun::star::uno::UNO_QUERY ); aArgs[0].Name = OUString::createFromAscii( "InteractionHandler" ); aArgs[0].Value <<= xInteraction; sal_Int16 nMacroExecMode = ::com::sun::star::document::MacroExecMode::USE_CONFIG; aArgs[1].Name = OUString::createFromAscii( "MacroExecutionMode" ); aArgs[1].Value <<= nMacroExecMode; sal_Int16 nUpdateDoc = ::com::sun::star::document::UpdateDocMode::ACCORDING_TO_CONFIG; aArgs[2].Name = OUString::createFromAscii( "UpdateDocMode" ); aArgs[2].Value <<= nUpdateDoc; // pb: #102643# use the filedlghelper to get the current filter name, // because it removes the extensions before you get the filter name. OUString aFilterName( pThis->m_pFileDlg->GetCurrentFilter() ); if ( xPickerControls.is() ) { // Set readonly flag sal_Bool bReadOnly = sal_False; xPickerControls->getValue( ExtendedFilePickerElementIds::CHECKBOX_READONLY, 0 ) >>= bReadOnly; // #95239#: Only set property if readonly is set to TRUE if ( bReadOnly ) { aArgs.realloc( ++nArgs ); aArgs[nArgs-1].Name = OUString::createFromAscii( "ReadOnly" ); aArgs[nArgs-1].Value <<= bReadOnly; } // Get version string sal_Int32 iVersion = -1; xPickerControls->getValue( ExtendedFilePickerElementIds::LISTBOX_VERSION, ControlActions::GET_SELECTED_ITEM_INDEX ) >>= iVersion; if ( iVersion >= 0 ) { sal_Int16 uVersion = (sal_Int16)iVersion; aArgs.realloc( ++nArgs ); aArgs[nArgs-1].Name = OUString::createFromAscii( "Version" ); aArgs[nArgs-1].Value <<= uVersion; } // Retrieve the current filter if ( !aFilterName.getLength() ) xPickerControls->getValue( CommonFilePickerElementIds::LISTBOX_FILTER, ControlActions::GET_SELECTED_ITEM ) >>= aFilterName; } // Convert UI filter name to internal filter name if ( aFilterName.getLength() ) { const SfxFilter* pFilter = SFX_APP()->GetFilterMatcher().GetFilter4UIName( aFilterName, 0, SFX_FILTER_NOTINFILEDLG ); if ( pFilter ) { aFilterName = pFilter->GetFilterName(); if ( aFilterName.getLength() ) { aArgs.realloc( ++nArgs ); aArgs[nArgs-1].Name = OUString::createFromAscii( "FilterName" ); aArgs[nArgs-1].Value <<= aFilterName; } } } if ( 1 == nFiles ) OpenURL( sFiles[0], OUString( RTL_CONSTASCII_USTRINGPARAM( "_default" ) ), aArgs ); else { OUString aBaseDirURL = sFiles[0]; if ( aBaseDirURL.getLength() > 0 && aBaseDirURL[aBaseDirURL.getLength()-1] != '/' ) aBaseDirURL += OUString::createFromAscii("/"); int iFiles; for ( iFiles = 1; iFiles < nFiles; iFiles++ ) { OUString aURL = aBaseDirURL; aURL += sFiles[iFiles]; OpenURL( aURL, OUString( RTL_CONSTASCII_USTRINGPARAM( "_default" ) ), aArgs ); } } } } catch ( ... ) { } } #ifdef WNT // #103346 Destroy dialog to prevent problems with custom controls // This fix is dependent on the dialog settings. Destroying the dialog here will // crash the non-native dialog implementation! Therefore make this dependent on // the settings. if ( SvtMiscOptions().UseSystemFileDialog() ) { delete pThis->m_pFileDlg; pThis->m_pFileDlg = NULL; } #endif LeaveModalMode(); return 0; } // --------------------------------------------------------------------------- void ShutdownIcon::addTerminateListener() { ShutdownIcon* pInst = getInstance(); if ( ! pInst) return; if (pInst->m_bListenForTermination) return; Reference< XDesktop > xDesktop = pInst->m_xDesktop; if ( ! xDesktop.is()) return; xDesktop->addTerminateListener( pInst ); pInst->m_bListenForTermination = true; } // --------------------------------------------------------------------------- void ShutdownIcon::terminateDesktop() { ShutdownIcon* pInst = getInstance(); if ( ! pInst) return; Reference< XDesktop > xDesktop = pInst->m_xDesktop; if ( ! xDesktop.is()) return; // always remove ourselves as listener pInst->m_bListenForTermination = true; xDesktop->removeTerminateListener( pInst ); // terminate desktop only if no tasks exist Reference< XFramesSupplier > xSupplier( xDesktop, UNO_QUERY ); if ( xSupplier.is() ) { Reference< XIndexAccess > xTasks ( xSupplier->getFrames(), UNO_QUERY ); if( xTasks.is() && xTasks->getCount() < 1 ) { AsyncDesktopTerminationData * pData = new AsyncDesktopTerminationData( xDesktop ); if ( !Application::PostUserEvent( STATIC_LINK( 0, ShutdownIcon, AsyncDesktopTermination ), pData ) ) delete pData; } } // remove the instance pointer ShutdownIcon::pShutdownIcon = 0; } IMPL_STATIC_LINK_NOINSTANCE( ShutdownIcon, AsyncDesktopTermination, AsyncDesktopTerminationData*, pData ) { if ( pData && pData->mxDesktop.is() ) pData->mxDesktop->terminate(); delete pData; return 0; } // --------------------------------------------------------------------------- ShutdownIcon* ShutdownIcon::getInstance() { OSL_ASSERT( pShutdownIcon ); return pShutdownIcon; } // --------------------------------------------------------------------------- ShutdownIcon* ShutdownIcon::createInstance() { if (pShutdownIcon) return pShutdownIcon; ShutdownIcon *pIcon = NULL; try { Reference< XMultiServiceFactory > xSMgr( comphelper::getProcessServiceFactory() ); pIcon = new ShutdownIcon( xSMgr ); pIcon->init (); pShutdownIcon = pIcon; } catch (...) { delete pIcon; } return pShutdownIcon; } void ShutdownIcon::init() throw( ::com::sun::star::uno::Exception ) { // access resource system and sfx only protected by solarmutex vos::OGuard aSolarGuard( Application::GetSolarMutex() ); ResMgr *pResMgr = SfxResId::GetResMgr(); ::osl::ResettableMutexGuard aGuard( m_aMutex ); m_pResMgr = pResMgr; aGuard.clear(); Reference < XDesktop > xDesktop( m_xServiceManager->createInstance( DEFINE_CONST_UNICODE( "com.sun.star.frame.Desktop" )), UNO_QUERY ); aGuard.reset(); m_xDesktop = xDesktop; } // --------------------------------------------------------------------------- void SAL_CALL ShutdownIcon::disposing() { m_xServiceManager = Reference< XMultiServiceFactory >(); m_xDesktop = Reference< XDesktop >(); } // --------------------------------------------------------------------------- // XEventListener void SAL_CALL ShutdownIcon::disposing( const ::com::sun::star::lang::EventObject& ) throw(::com::sun::star::uno::RuntimeException) { } // --------------------------------------------------------------------------- // XTerminateListener void SAL_CALL ShutdownIcon::queryTermination( const ::com::sun::star::lang::EventObject& ) throw(::com::sun::star::frame::TerminationVetoException, ::com::sun::star::uno::RuntimeException) { ::osl::ClearableMutexGuard aGuard( m_aMutex ); if ( m_bVeto ) throw ::com::sun::star::frame::TerminationVetoException(); } // --------------------------------------------------------------------------- void SAL_CALL ShutdownIcon::notifyTermination( const ::com::sun::star::lang::EventObject& ) throw(::com::sun::star::uno::RuntimeException) { } // --------------------------------------------------------------------------- void SAL_CALL ShutdownIcon::initialize( const ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Any>& aArguments ) throw( ::com::sun::star::uno::Exception ) { ::osl::ResettableMutexGuard aGuard( m_aMutex ); // third argument only sets veto, everything else will be ignored! if (aArguments.getLength() > 2) { sal_Bool bVeto = sal_True; bVeto = ::cppu::any2bool(aArguments[2]); m_bVeto = bVeto; return; } if ( aArguments.getLength() > 0 ) { if ( !ShutdownIcon::pShutdownIcon ) { try { sal_Bool bQuickstart = sal_False; bQuickstart = ::cppu::any2bool( aArguments[0] ); if( !bQuickstart && !GetAutostart() ) return; aGuard.clear(); init (); aGuard.reset(); if ( !m_xDesktop.is() ) return; /* Create a sub-classed instance - foo */ ShutdownIcon::pShutdownIcon = this; initSystray(); #ifdef OS2 // above win32 starts the quickstart thread, but we have // quickstart running only when -quickstart is specified // on command line (next boot). // so if -quickstart was not specified, we cannot issue // quickstart veto on shutdown. if (bQuickstart) { // disable shutdown ShutdownIcon::getInstance()->SetVeto( true ); ShutdownIcon::getInstance()->addTerminateListener(); } #endif } catch(const ::com::sun::star::lang::IllegalArgumentException&) { } } } if ( aArguments.getLength() > 1 ) { sal_Bool bAutostart = sal_False; bAutostart = ::cppu::any2bool( aArguments[1] ); if (bAutostart && !GetAutostart()) SetAutostart( sal_True ); if (!bAutostart && GetAutostart()) SetAutostart( sal_False ); } } // ------------------------------- void ShutdownIcon::EnterModalMode() { bModalMode = sal_True; } // ------------------------------- void ShutdownIcon::LeaveModalMode() { bModalMode = sal_False; } #ifdef WNT // defined in shutdowniconw32.cxx #elif defined(OS2) // defined in shutdowniconOs2.cxx #elif defined QUARTZ // defined in shutdowniconaqua.cxx #else bool ShutdownIcon::IsQuickstarterInstalled() { #ifndef ENABLE_QUICKSTART_APPLET return false; #else // !ENABLE_QUICKSTART_APPLET #ifdef UNX return LoadModule( NULL, NULL, NULL); #endif // UNX #endif // !ENABLE_QUICKSTART_APPLET } #endif // !WNT // --------------------------------------------------------------------------- #if defined (ENABLE_QUICKSTART_APPLET) && defined (UNX) static OUString getDotAutostart( bool bCreate = false ) { OUString aShortcut; const char *pConfigHome; if( (pConfigHome = getenv("XDG_CONFIG_HOME") ) ) aShortcut = OStringToOUString( OString( pConfigHome ), RTL_TEXTENCODING_UTF8 ); else { OUString aHomeURL; osl::Security().getHomeDir( aHomeURL ); ::osl::File::getSystemPathFromFileURL( aHomeURL, aShortcut ); aShortcut += OUString( RTL_CONSTASCII_USTRINGPARAM( "/.config" ) ); } aShortcut += OUString( RTL_CONSTASCII_USTRINGPARAM( "/autostart" ) ); if (bCreate) { OUString aShortcutUrl; osl::File::getFileURLFromSystemPath( aShortcut, aShortcutUrl ); osl::Directory::createPath( aShortcutUrl ); } return aShortcut; } #endif rtl::OUString ShutdownIcon::getShortcutName() { #ifndef ENABLE_QUICKSTART_APPLET return OUString(); #else OUString aShortcutName( RTL_CONSTASCII_USTRINGPARAM( "StarOffice 6.0" ) ); ResMgr* pMgr = SfxResId::GetResMgr(); if( pMgr ) { ::vos::OGuard aGuard( Application::GetSolarMutex() ); UniString aRes( SfxResId( STR_QUICKSTART_LNKNAME ) ); aShortcutName = OUString( aRes ); } #ifdef WNT aShortcutName += OUString( RTL_CONSTASCII_USTRINGPARAM( ".lnk" ) ); OUString aShortcut(GetAutostartFolderNameW32()); aShortcut += OUString( RTL_CONSTASCII_USTRINGPARAM( "\\" ) ); aShortcut += aShortcutName; #else // UNX OUStringBuffer aStrBuff( getDotAutostart() ); aStrBuff.appendAscii( RTL_CONSTASCII_STRINGPARAM( "/" ) ); if ( sal_Int32 len = aShortcutName.getLength() ) aStrBuff.append( aShortcutName.getStr(), len ); else aStrBuff.appendAscii( RTL_CONSTASCII_STRINGPARAM( "qstart" ) ); aStrBuff.appendAscii( RTL_CONSTASCII_STRINGPARAM( ".desktop" ) ); OUString aShortcut( aStrBuff.makeStringAndClear() ); #endif // UNX return aShortcut; #endif // ENABLE_QUICKSTART_APPLET } bool ShutdownIcon::GetAutostart( ) { #if defined(OS2) return GetAutostartOs2( ); #elif defined QUARTZ return true; #else bool bRet = false; #ifdef ENABLE_QUICKSTART_APPLET OUString aShortcut( getShortcutName() ); OUString aShortcutUrl; osl::File::getFileURLFromSystemPath( aShortcut, aShortcutUrl ); osl::File f( aShortcutUrl ); osl::File::RC error = f.open( OpenFlag_Read ); if( error == osl::File::E_None ) { f.close(); bRet = true; } #endif // ENABLE_QUICKSTART_APPLET return bRet; #endif } void ShutdownIcon::SetAutostart( bool bActivate ) { #ifdef ENABLE_QUICKSTART_APPLET OUString aShortcut( getShortcutName() ); if( bActivate && IsQuickstarterInstalled() ) { #ifdef WNT EnableAutostartW32( aShortcut ); #else // UNX getDotAutostart( true ); OUString aPath( RTL_CONSTASCII_USTRINGPARAM("${OOO_BASE_DIR}/share/xdg/qstart.desktop" ) ); Bootstrap::expandMacros( aPath ); OUString aDesktopFile; ::osl::File::getSystemPathFromFileURL( aPath, aDesktopFile ); OString aDesktopFileUnx = OUStringToOString( aDesktopFile, osl_getThreadTextEncoding() ); OString aShortcutUnx = OUStringToOString( aShortcut, osl_getThreadTextEncoding() ); if ((0 != symlink( aDesktopFileUnx.getStr(), aShortcutUnx.getStr())) && (errno == EEXIST)) { unlink( aShortcutUnx.getStr()); symlink( aDesktopFileUnx.getStr(), aShortcutUnx.getStr()); } ShutdownIcon *pIcon = ShutdownIcon::createInstance(); if( pIcon ) pIcon->initSystray(); #endif // UNX } else { OUString aShortcutUrl; ::osl::File::getFileURLFromSystemPath( aShortcut, aShortcutUrl ); ::osl::File::remove( aShortcutUrl ); #ifdef UNX if (pShutdownIcon) { ShutdownIcon *pIcon = getInstance(); pIcon->deInitSystray(); } #endif } #elif defined OS2 SetAutostartOs2( bActivate ); #else (void)bActivate; // unused variable #endif // ENABLE_QUICKSTART_APPLET } static const ::sal_Int32 PROPHANDLE_TERMINATEVETOSTATE = 0; // XFastPropertySet void SAL_CALL ShutdownIcon::setFastPropertyValue( ::sal_Int32 nHandle, const ::com::sun::star::uno::Any& aValue ) throw (::com::sun::star::beans::UnknownPropertyException, ::com::sun::star::beans::PropertyVetoException, ::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::lang::WrappedTargetException, ::com::sun::star::uno::RuntimeException) { switch(nHandle) { case PROPHANDLE_TERMINATEVETOSTATE : { // use new value in case it's a valid information only ::sal_Bool bState( sal_False ); if (! (aValue >>= bState)) return; m_bVeto = bState; if (m_bVeto && ! m_bListenForTermination) addTerminateListener(); } break; default : throw ::com::sun::star::beans::UnknownPropertyException(); } } // XFastPropertySet ::com::sun::star::uno::Any SAL_CALL ShutdownIcon::getFastPropertyValue( ::sal_Int32 nHandle ) throw (::com::sun::star::beans::UnknownPropertyException, ::com::sun::star::lang::WrappedTargetException, ::com::sun::star::uno::RuntimeException) { ::com::sun::star::uno::Any aValue; switch(nHandle) { case PROPHANDLE_TERMINATEVETOSTATE : { bool bState = (m_bListenForTermination && m_bVeto); aValue <<= bState; } break; default : throw ::com::sun::star::beans::UnknownPropertyException(); } return aValue; }