/**************************************************************
*
* 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 <shutdownicon.hxx>
#include <app.hrc>
#include <sfx2/app.hxx>
#include <vos/mutex.hxx>
#include <svtools/imagemgr.hxx>
#include <svtools/miscopt.hxx>
// #include <cmdlineargs.hxx>
#include <com/sun/star/task/XInteractionHandler.hpp>
#include <com/sun/star/frame/XDispatchResultListener.hpp>
#include <com/sun/star/frame/XNotifyingDispatch.hpp>
#include <com/sun/star/frame/XFramesSupplier.hpp>
#include <com/sun/star/frame/XComponentLoader.hpp>
#include <com/sun/star/frame/XFrame.hpp>
#include <com/sun/star/util/XURLTransformer.hpp>
#include <com/sun/star/frame/XFramesSupplier.hpp>
#include <com/sun/star/ui/dialogs/XFilePickerControlAccess.hpp>
#include <com/sun/star/ui/dialogs/XFilterManager.hpp>
#include <com/sun/star/ui/dialogs/ExtendedFilePickerElementIds.hpp>
#include <com/sun/star/ui/dialogs/CommonFilePickerElementIds.hpp>
#include <com/sun/star/ui/dialogs/ControlActions.hpp>
#include <com/sun/star/document/MacroExecMode.hpp>
#include <com/sun/star/document/UpdateDocMode.hpp>
#include <sfx2/filedlghelper.hxx>
#include <sfx2/fcontnr.hxx>
#ifndef _UNOTOOLS_PROCESSFACTORY_HXX
#include <comphelper/processfactory.hxx>
#endif
#include <cppuhelper/compbase1.hxx>
#include <sfx2/dispatch.hxx>
#include <comphelper/extract.hxx>
#include <tools/urlobj.hxx>
#include <osl/security.hxx>
#include <osl/file.hxx>
#include <rtl/bootstrap.hxx>
#include <rtl/ustrbuf.hxx>
#include <tools/link.hxx>
#ifdef UNX // need symlink
#include <unistd.h>
#include <errno.h>
#endif
#include <vcl/timer.hxx>
#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<PropertyValue> 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 <tools/rcid.h>
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<bool>(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;
}