sfx2/source/appl/shutdownicon.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <shutdownicon.hxx>
  21 #include <app.hrc>
  22 #include <sfx2/app.hxx>
  23 #include <osl/mutex.hxx>
  24 #include <svtools/imagemgr.hxx>
  25 #include <svtools/miscopt.hxx>
  26 #include <com/sun/star/task/InteractionHandler.hpp>
  27 #include <com/sun/star/frame/Desktop.hpp>
  28 #include <com/sun/star/frame/XDispatchResultListener.hpp>
  29 #include <com/sun/star/frame/XNotifyingDispatch.hpp>
  30 #include <com/sun/star/frame/XFramesSupplier.hpp>
  31 #include <com/sun/star/frame/XComponentLoader.hpp>
  32 #include <com/sun/star/frame/XFrame.hpp>
  33 #include <com/sun/star/util/URLTransformer.hpp>
  34 #include <com/sun/star/util/XURLTransformer.hpp>
  35 #include <com/sun/star/ui/dialogs/XFilePickerControlAccess.hpp>
  36 #include <com/sun/star/ui/dialogs/XFilterManager.hpp>
  37 #include <com/sun/star/ui/dialogs/TemplateDescription.hpp>
  38 #include <com/sun/star/ui/dialogs/ExtendedFilePickerElementIds.hpp>
  39 #include <com/sun/star/ui/dialogs/CommonFilePickerElementIds.hpp>
  40 #include <com/sun/star/ui/dialogs/ControlActions.hpp>
  41 #include <com/sun/star/document/MacroExecMode.hpp>
  42 #include <com/sun/star/document/UpdateDocMode.hpp>
  43 #include <sfx2/filedlghelper.hxx>
  44 #include <sfx2/fcontnr.hxx>
  45 #include <comphelper/processfactory.hxx>
  46 #include <cppuhelper/compbase1.hxx>
  47 #include <sfx2/dispatch.hxx>
  48 #include <comphelper/extract.hxx>
  49 #include <tools/urlobj.hxx>
  50 #include <osl/security.hxx>
  51 #include <osl/file.hxx>
  52 #include <rtl/bootstrap.hxx>
  53 #include <rtl/ustrbuf.hxx>
  54 #ifdef UNX // need symlink
  55 #include <unistd.h>
  56 #include <errno.h>
  57 #endif
  58 #include <vcl/timer.hxx>
  59
  60 #include "sfx2/sfxresid.hxx"
  61
  62 using namespace ::com::sun::star;
  63 using namespace ::com::sun::star::uno;
  64 using namespace ::com::sun::star::frame;
  65 using namespace ::com::sun::star::container;
  66 using namespace ::com::sun::star::io;
  67 using namespace ::com::sun::star::lang;
  68 using namespace ::com::sun::star::beans;
  69 using namespace ::com::sun::star::util;
  70 using namespace ::com::sun::star::ui::dialogs;
  71 #ifdef WNT
  72 #else
  73 using namespace ::rtl;
  74 #endif
  75 using namespace ::sfx2;
  76
  77 #ifdef ENABLE_QUICKSTART_APPLET
  78 # if !defined(WIN32) && !defined(MACOSX)
  79 extern "C" { static void SAL_CALL thisModule() {} }
  80 # endif
  81 #endif
  82
  83 #if defined(UNX) && defined(ENABLE_SYSTRAY_GTK) && !defined(PLUGIN_NAME)
  84 #define PLUGIN_NAME "libqstart_gtklo.so"
  85 #endif
  86
  87 class SfxNotificationListener_Impl : public cppu::WeakImplHelper1< XDispatchResultListener >
  88 {
  89 public:
  90     virtual void SAL_CALL dispatchFinished( const DispatchResultEvent& aEvent ) throw( RuntimeException );
  91     virtual void SAL_CALL disposing( const EventObject& aEvent ) throw( RuntimeException );
  92 };
  93
  94 void SAL_CALL SfxNotificationListener_Impl::dispatchFinished( const DispatchResultEvent& ) throw( RuntimeException )
  95 {
  96     ShutdownIcon::LeaveModalMode();
  97 }
  98
  99 void SAL_CALL SfxNotificationListener_Impl::disposing( const EventObject& ) throw( RuntimeException )
 100 {
 101 }
 102
 103 SFX_IMPL_XSERVICEINFO_CTX( ShutdownIcon, "com.sun.star.office.Quickstart", "com.sun.star.comp.desktop.QuickstartWrapper" )  \
 104 SFX_IMPL_ONEINSTANCEFACTORY( ShutdownIcon );
 105
 106 bool ShutdownIcon::bModalMode = false;
 107 ShutdownIcon* ShutdownIcon::pShutdownIcon = NULL;
 108
 109 #if !defined( ENABLE_QUICKSTART_APPLET ) || defined( UNX )
 110 // To remove conditionals
 111 extern "C" {
 112     static void disabled_initSystray() { }
 113     static void disabled_deInitSystray() { }
 114 }
 115 #endif
 116
 117 bool ShutdownIcon::LoadModule( osl::Module **pModule,
 118                                oslGenericFunction *pInit,
 119                                oslGenericFunction *pDeInit )
 120 {
 121     if ( pModule )
 122     {
 123         OSL_ASSERT ( pInit && pDeInit );
 124         *pInit = *pDeInit = NULL;
 125         *pModule = NULL;
 126     }
 127
 128 #ifdef ENABLE_QUICKSTART_APPLET
 129 #  ifdef WIN32
 130     if ( pModule )
 131     {
 132         *pInit = win32_init_sys_tray;
 133         *pDeInit = win32_shutdown_sys_tray;
 134     }
 135     return true;
 136 #  elif defined MACOSX
 137     *pInit = aqua_init_systray;
 138     *pDeInit = aqua_shutdown_systray;
 139     return true;
 140 #  else // UNX
 141     osl::Module *pPlugin;
 142     pPlugin = new osl::Module();
 143
 144     oslGenericFunction pTmpInit = NULL;
 145     oslGenericFunction pTmpDeInit = NULL;
 146
 147 #define DOSTRING( x )                       #x
 148 #define STRING( x )                         DOSTRING( x )
 149
 150     if ( pPlugin->loadRelative( &thisModule, OUString (STRING( PLUGIN_NAME  ) ) ) )
 151     {
 152         pTmpInit = pPlugin->getFunctionSymbol(
 153             OUString( "plugin_init_sys_tray"  ) );
 154         pTmpDeInit = pPlugin->getFunctionSymbol(
 155             OUString( "plugin_shutdown_sys_tray"  ) );
 156     }
 157     if ( !pTmpInit || !pTmpDeInit )
 158     {
 159         delete pPlugin;
 160         pPlugin = NULL;
 161     }
 162     if ( pModule )
 163     {
 164         *pModule = pPlugin;
 165         *pInit = pTmpInit;
 166         *pDeInit = pTmpDeInit;
 167     }
 168     else
 169     {
 170         bool bRet = pPlugin != NULL;
 171         delete pPlugin;
 172         return bRet;
 173     }
 174 #  endif // UNX
 175 #endif // ENABLE_QUICKSTART_APPLET
 176
 177 #if !defined( ENABLE_QUICKSTART_APPLET ) || defined( UNX )
 178     // Avoid unreachable code. In the ENABLE_QUICKSTART_APPLET && !UNX
 179     // case, we have already returned.
 180     if ( pModule )
 181     {
 182         if ( !*pInit )
 183             *pInit = disabled_initSystray;
 184         if ( !*pDeInit )
 185             *pDeInit = disabled_deInitSystray;
 186     }
 187
 188     return true;
 189 #endif // !ENABLE_QUICKSTART_APPLET || UNX
 190 }
 191
 192 // These two timeouts are necessary to avoid there being
 193 // plugin frames still on the stack, after unloading that
 194 // code, causing a crash during disabling / termination.
 195 class IdleUnloader : Timer
 196 {
 197     ::osl::Module *m_pModule;
 198 public:
 199     IdleUnloader (::osl::Module **pModule) :
 200         m_pModule (*pModule)
 201     {
 202         *pModule = NULL;
 203         Start();
 204     }
 205     virtual void Timeout()
 206     {
 207         delete m_pModule;
 208         delete this;
 209     }
 210 };
 211
 212 class IdleTerminate : Timer
 213 {
 214     Reference< XDesktop2 > m_xDesktop;
 215 public:
 216     IdleTerminate (Reference< XDesktop2 > xDesktop)
 217     {
 218         m_xDesktop = xDesktop;
 219         Start();
 220     }
 221     virtual void Timeout()
 222     {
 223         m_xDesktop->terminate();
 224         delete this;
 225     }
 226 };
 227
 228 void ShutdownIcon::initSystray()
 229 {
 230     if (m_bInitialized)
 231         return;
 232     m_bInitialized = true;
 233
 234     (void) LoadModule( &m_pPlugin, &m_pInitSystray, &m_pDeInitSystray );
 235     m_bVeto = true;
 236     m_pInitSystray();
 237 }
 238
 239 void ShutdownIcon::deInitSystray()
 240 {
 241     if (!m_bInitialized)
 242         return;
 243
 244     if (m_pDeInitSystray)
 245         m_pDeInitSystray();
 246
 247     m_bVeto = false;
 248     m_pInitSystray = 0;
 249     m_pDeInitSystray = 0;
 250     new IdleUnloader (&m_pPlugin);
 251
 252     delete m_pFileDlg;
 253     m_pFileDlg = NULL;
 254     m_bInitialized = false;
 255 }
 256
 257
 258 ShutdownIcon::ShutdownIcon( const Reference< XComponentContext > & rxContext ) :
 259     ShutdownIconServiceBase( m_aMutex ),
 260     m_bVeto ( false ),
 261     m_bListenForTermination ( false ),
 262     m_bSystemDialogs( false ),
 263     m_pResMgr( NULL ),
 264     m_pFileDlg( NULL ),
 265     m_xContext( rxContext ),
 266     m_pInitSystray( 0 ),
 267     m_pDeInitSystray( 0 ),
 268     m_pPlugin( 0 ),
 269     m_bInitialized( false )
 270 {
 271     m_bSystemDialogs = SvtMiscOptions().UseSystemFileDialog();
 272 }
 273
 274 ShutdownIcon::~ShutdownIcon()
 275 {
 276     deInitSystray();
 277     new IdleUnloader (&m_pPlugin);
 278 }
 279
 280 // ---------------------------------------------------------------------------
 281
 282 void ShutdownIcon::OpenURL( const OUString& aURL, const OUString& rTarget, const Sequence< PropertyValue >& aArgs )
 283 {
 284     if ( getInstance() && getInstance()->m_xDesktop.is() )
 285     {
 286         Reference < XDispatchProvider > xDispatchProvider( getInstance()->m_xDesktop, UNO_QUERY );
 287         if ( xDispatchProvider.is() )
 288         {
 289             com::sun::star::util::URL aDispatchURL;
 290             aDispatchURL.Complete = aURL;
 291
 292             Reference< util::XURLTransformer > xURLTransformer( util::URLTransformer::create( ::comphelper::getProcessComponentContext() ) );
 293             try
 294             {
 295                 Reference< com::sun::star::frame::XDispatch > xDispatch;
 296
 297                 xURLTransformer->parseStrict( aDispatchURL );
 298                 xDispatch = xDispatchProvider->queryDispatch( aDispatchURL, rTarget, 0 );
 299                 if ( xDispatch.is() )
 300                     xDispatch->dispatch( aDispatchURL, aArgs );
 301             }
 302             catch ( com::sun::star::uno::RuntimeException& )
 303             {
 304                 throw;
 305             }
 306             catch ( com::sun::star::uno::Exception& )
 307             {
 308             }
 309         }
 310     }
 311 }
 312
 313 // ---------------------------------------------------------------------------
 314
 315 void ShutdownIcon::FileOpen()
 316 {
 317     if ( getInstance() && getInstance()->m_xDesktop.is() )
 318     {
 319         ::SolarMutexGuard aGuard;
 320         EnterModalMode();
 321         getInstance()->StartFileDialog();
 322     }
 323 }
 324
 325 // ---------------------------------------------------------------------------
 326
 327 void ShutdownIcon::FromTemplate()
 328 {
 329     if ( getInstance() && getInstance()->m_xDesktop.is() )
 330     {
 331         Reference < ::com::sun::star::frame::XFramesSupplier > xDesktop ( getInstance()->m_xDesktop, UNO_QUERY);
 332         Reference < ::com::sun::star::frame::XFrame > xFrame( xDesktop->getActiveFrame() );
 333         if ( !xFrame.is() )
 334             xFrame = Reference < ::com::sun::star::frame::XFrame >( xDesktop, UNO_QUERY );
 335
 336         URL aTargetURL;
 337         aTargetURL.Complete = OUString( "slot:5500"  );
 338         Reference< util::XURLTransformer > xTrans( util::URLTransformer::create( ::comphelper::getProcessComponentContext() ) );
 339         xTrans->parseStrict( aTargetURL );
 340
 341         Reference < ::com::sun::star::frame::XDispatchProvider > xProv( xFrame, UNO_QUERY );
 342         Reference < ::com::sun::star::frame::XDispatch > xDisp;
 343         if ( xProv.is() )
 344         {
 345             if ( aTargetURL.Protocol.compareToAscii("slot:") == COMPARE_EQUAL )
 346                 xDisp = xProv->queryDispatch( aTargetURL, OUString(), 0 );
 347             else
 348                 xDisp = xProv->queryDispatch( aTargetURL, OUString("_blank"), 0 );
 349         }
 350         if ( xDisp.is() )
 351         {
 352             Sequence<PropertyValue> aArgs(1);
 353             PropertyValue* pArg = aArgs.getArray();
 354             pArg[0].Name = OUString("Referer");
 355             pArg[0].Value <<= OUString("private:user");
 356             Reference< ::com::sun::star::frame::XNotifyingDispatch > xNotifyer( xDisp, UNO_QUERY );
 357             if ( xNotifyer.is() )
 358             {
 359                 EnterModalMode();
 360                 xNotifyer->dispatchWithNotification( aTargetURL, aArgs, new SfxNotificationListener_Impl() );
 361             }
 362             else
 363                 xDisp->dispatch( aTargetURL, aArgs );
 364         }
 365     }
 366 }
 367
 368 // ---------------------------------------------------------------------------
 369 #include <tools/rcid.h>
 370 OUString ShutdownIcon::GetResString( int id )
 371 {
 372     ::SolarMutexGuard aGuard;
 373
 374     if( ! m_pResMgr )
 375         m_pResMgr = SfxResId::GetResMgr();
 376     ResId aResId( id, *m_pResMgr );
 377     aResId.SetRT( RSC_STRING );
 378     if( !m_pResMgr || !m_pResMgr->IsAvailable( aResId ) )
 379         return OUString();
 380
 381     return ResId(id, *m_pResMgr).toString();
 382 }
 383
 384 // ---------------------------------------------------------------------------
 385
 386 OUString ShutdownIcon::GetUrlDescription( const OUString& aUrl )
 387 {
 388     ::SolarMutexGuard aGuard;
 389
 390     return OUString( SvFileInformationManager::GetDescription( INetURLObject( aUrl ) ) );
 391 }
 392
 393 // ---------------------------------------------------------------------------
 394
 395 void ShutdownIcon::StartFileDialog()
 396 {
 397     ::SolarMutexGuard aGuard;
 398
 399     bool bDirty = ( m_bSystemDialogs != static_cast<bool>(SvtMiscOptions().UseSystemFileDialog()) );
 400
 401     if ( m_pFileDlg && bDirty )
 402     {
 403         // Destroy instance as changing the system file dialog setting
 404         // forces us to create a new FileDialogHelper instance!
 405         delete m_pFileDlg;
 406         m_pFileDlg = NULL;
 407     }
 408
 409     if ( !m_pFileDlg )
 410         m_pFileDlg = new FileDialogHelper(
 411                 ui::dialogs::TemplateDescription::FILEOPEN_READONLY_VERSION,
 412                 SFXWB_MULTISELECTION, String() );
 413     m_pFileDlg->StartExecuteModal( STATIC_LINK( this, ShutdownIcon, DialogClosedHdl_Impl ) );
 414 }
 415
 416 // ---------------------------------------------------------------------------
 417
 418 IMPL_STATIC_LINK( ShutdownIcon, DialogClosedHdl_Impl, FileDialogHelper*, EMPTYARG )
 419 {
 420     DBG_ASSERT( pThis->m_pFileDlg, "ShutdownIcon, DialogClosedHdl_Impl(): no file dialog" );
 421
 422     // use constructor for filling up filters automatically!
 423     if ( ERRCODE_NONE == pThis->m_pFileDlg->GetError() )
 424     {
 425         Reference< XFilePicker >    xPicker = pThis->m_pFileDlg->GetFilePicker();
 426
 427         try
 428         {
 429
 430             if ( xPicker.is() )
 431             {
 432
 433                 Reference < XFilePickerControlAccess > xPickerControls ( xPicker, UNO_QUERY );
 434                 Reference < XFilterManager > xFilterManager ( xPicker, UNO_QUERY );
 435
 436                 Sequence< OUString >        sFiles = xPicker->getFiles();
 437                 int                         nFiles = sFiles.getLength();
 438
 439                 int                         nArgs=3;
 440                 Sequence< PropertyValue >   aArgs(3);
 441
 442                 Reference < com::sun::star::task::XInteractionHandler2 > xInteraction(
 443                     task::InteractionHandler::createWithParent(::comphelper::getProcessComponentContext(), 0) );
 444
 445                 aArgs[0].Name = OUString("InteractionHandler");
 446                 aArgs[0].Value <<= xInteraction;
 447
 448                 sal_Int16 nMacroExecMode = ::com::sun::star::document::MacroExecMode::USE_CONFIG;
 449                 aArgs[1].Name = OUString("MacroExecutionMode");
 450                 aArgs[1].Value <<= nMacroExecMode;
 451
 452                 sal_Int16 nUpdateDoc = ::com::sun::star::document::UpdateDocMode::ACCORDING_TO_CONFIG;
 453                 aArgs[2].Name = OUString("UpdateDocMode");
 454                 aArgs[2].Value <<= nUpdateDoc;
 455
 456                 // use the filedlghelper to get the current filter name,
 457                 // because it removes the extensions before you get the filter name.
 458                 OUString aFilterName( pThis->m_pFileDlg->GetCurrentFilter() );
 459
 460                 if ( xPickerControls.is() )
 461                 {
 462
 463                     // Set readonly flag
 464
 465                     sal_Bool    bReadOnly = sal_False;
 466
 467
 468                     xPickerControls->getValue( ExtendedFilePickerElementIds::CHECKBOX_READONLY, 0 ) >>= bReadOnly;
 469
 470                     // Only set porperty if readonly is set to TRUE
 471
 472                     if ( bReadOnly )
 473                     {
 474                         aArgs.realloc( ++nArgs );
 475                         aArgs[nArgs-1].Name  = OUString("ReadOnly");
 476                         aArgs[nArgs-1].Value <<= bReadOnly;
 477                     }
 478
 479                     // Get version string
 480
 481                     sal_Int32   iVersion = -1;
 482
 483                     xPickerControls->getValue( ExtendedFilePickerElementIds::LISTBOX_VERSION, ControlActions::GET_SELECTED_ITEM_INDEX ) >>= iVersion;
 484
 485                     if ( iVersion >= 0 )
 486                     {
 487                         sal_Int16   uVersion = (sal_Int16)iVersion;
 488
 489                         aArgs.realloc( ++nArgs );
 490                         aArgs[nArgs-1].Name  = OUString("Version");
 491                         aArgs[nArgs-1].Value <<= uVersion;
 492                     }
 493
 494                     // Retrieve the current filter
 495
 496                     if ( aFilterName.isEmpty() )
 497                         xPickerControls->getValue( CommonFilePickerElementIds::LISTBOX_FILTER, ControlActions::GET_SELECTED_ITEM ) >>= aFilterName;
 498
 499                 }
 500
 501
 502                 // Convert UI filter name to internal filter name
 503
 504                 if ( !aFilterName.isEmpty() )
 505                 {
 506                     const SfxFilter* pFilter = SFX_APP()->GetFilterMatcher().GetFilter4UIName( aFilterName, 0, SFX_FILTER_NOTINFILEDLG );
 507
 508                     if ( pFilter )
 509                     {
 510                         aFilterName = pFilter->GetFilterName();
 511
 512                         if ( !aFilterName.isEmpty() )
 513                         {
 514                             aArgs.realloc( ++nArgs );
 515                             aArgs[nArgs-1].Name  = OUString("FilterName");
 516                             aArgs[nArgs-1].Value <<= aFilterName;
 517                         }
 518                     }
 519                 }
 520
 521                 if ( 1 == nFiles )
 522                     OpenURL( sFiles[0], OUString( "_default"  ), aArgs );
 523                 else
 524                 {
 525                     OUString    aBaseDirURL = sFiles[0];
 526                     if ( !aBaseDirURL.isEmpty() && aBaseDirURL[aBaseDirURL.getLength()-1] != '/' )
 527                         aBaseDirURL += "/";
 528
 529                     int iFiles;
 530                     for ( iFiles = 1; iFiles < nFiles; iFiles++ )
 531                     {
 532                         OUString    aURL = aBaseDirURL;
 533                         aURL += sFiles[iFiles];
 534                         OpenURL( aURL, OUString( "_default"  ), aArgs );
 535                     }
 536                 }
 537             }
 538         }
 539         catch ( ... )
 540         {
 541         }
 542     }
 543
 544 #ifdef WNT
 545     // Destroy dialog to prevent problems with custom controls
 546     // This fix is dependent on the dialog settings. Destroying the dialog here will
 547     // crash the non-native dialog implementation! Therefore make this dependent on
 548     // the settings.
 549     if ( SvtMiscOptions().UseSystemFileDialog() )
 550     {
 551         delete pThis->m_pFileDlg;
 552         pThis->m_pFileDlg = NULL;
 553     }
 554 #endif
 555
 556     LeaveModalMode();
 557     return 0;
 558 }
 559
 560 // ---------------------------------------------------------------------------
 561
 562 void ShutdownIcon::addTerminateListener()
 563 {
 564     ShutdownIcon* pInst = getInstance();
 565     if ( ! pInst)
 566         return;
 567
 568     if (pInst->m_bListenForTermination)
 569         return;
 570
 571     Reference< XDesktop2 > xDesktop = pInst->m_xDesktop;
 572     if ( ! xDesktop.is())
 573         return;
 574
 575     xDesktop->addTerminateListener( pInst );
 576     pInst->m_bListenForTermination = true;
 577 }
 578
 579 // ---------------------------------------------------------------------------
 580
 581 void ShutdownIcon::terminateDesktop()
 582 {
 583     ShutdownIcon* pInst = getInstance();
 584     if ( ! pInst)
 585         return;
 586
 587     Reference< XDesktop2 > xDesktop = pInst->m_xDesktop;
 588     if ( ! xDesktop.is())
 589         return;
 590
 591     // always remove ourselves as listener
 592     pInst->m_bListenForTermination = true;
 593     xDesktop->removeTerminateListener( pInst );
 594
 595     // terminate desktop only if no tasks exist
 596     Reference< XIndexAccess > xTasks ( xDesktop->getFrames(), UNO_QUERY );
 597     if( xTasks.is() && xTasks->getCount() < 1 )
 598         new IdleTerminate( xDesktop );
 599
 600     // remove the instance pointer
 601     ShutdownIcon::pShutdownIcon = 0;
 602 }
 603
 604 // ---------------------------------------------------------------------------
 605
 606 ShutdownIcon* ShutdownIcon::getInstance()
 607 {
 608     OSL_ASSERT( pShutdownIcon );
 609     return pShutdownIcon;
 610 }
 611
 612 // ---------------------------------------------------------------------------
 613
 614 ShutdownIcon* ShutdownIcon::createInstance()
 615 {
 616     if (pShutdownIcon)
 617         return pShutdownIcon;
 618
 619     ShutdownIcon *pIcon = NULL;
 620     try {
 621         pIcon = new ShutdownIcon( comphelper::getProcessComponentContext() );
 622         pIcon->init ();
 623         pShutdownIcon = pIcon;
 624     } catch (...) {
 625         delete pIcon;
 626     }
 627
 628     return pShutdownIcon;
 629 }
 630
 631 void ShutdownIcon::init() throw( ::com::sun::star::uno::Exception )
 632 {
 633     // access resource system and sfx only protected by solarmutex
 634     ::SolarMutexGuard aSolarGuard;
 635     ResMgr *pResMgr = SfxResId::GetResMgr();
 636
 637     ::osl::ResettableMutexGuard aGuard( m_aMutex );
 638     m_pResMgr = pResMgr;
 639     aGuard.clear();
 640     Reference < XDesktop2 > xDesktop = Desktop::create( m_xContext );
 641     aGuard.reset();
 642     m_xDesktop = xDesktop;
 643 }
 644
 645 // ---------------------------------------------------------------------------
 646
 647 void SAL_CALL ShutdownIcon::disposing()
 648 {
 649     m_xContext.clear();
 650     m_xDesktop.clear();
 651 }
 652
 653 // ---------------------------------------------------------------------------
 654
 655 // XEventListener
 656 void SAL_CALL ShutdownIcon::disposing( const ::com::sun::star::lang::EventObject& )
 657     throw(::com::sun::star::uno::RuntimeException)
 658 {
 659 }
 660
 661 // ---------------------------------------------------------------------------
 662
 663 // XTerminateListener
 664 void SAL_CALL ShutdownIcon::queryTermination( const ::com::sun::star::lang::EventObject& )
 665 throw(::com::sun::star::frame::TerminationVetoException, ::com::sun::star::uno::RuntimeException)
 666 {
 667     SAL_INFO("sfx2.appl", "ShutdownIcon::queryTermination: veto is " << m_bVeto);
 668     ::osl::ClearableMutexGuard  aGuard( m_aMutex );
 669
 670     if ( m_bVeto )
 671         throw ::com::sun::star::frame::TerminationVetoException();
 672 }
 673
 674
 675 // ---------------------------------------------------------------------------
 676
 677 void SAL_CALL ShutdownIcon::notifyTermination( const ::com::sun::star::lang::EventObject& )
 678 throw(::com::sun::star::uno::RuntimeException)
 679 {
 680 }
 681
 682
 683 // ---------------------------------------------------------------------------
 684
 685 void SAL_CALL ShutdownIcon::initialize( const ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Any>& aArguments )
 686     throw( ::com::sun::star::uno::Exception )
 687 {
 688     ::osl::ResettableMutexGuard aGuard( m_aMutex );
 689
 690     // third argument only sets veto, everything else will be ignored!
 691     if (aArguments.getLength() > 2)
 692     {
 693         sal_Bool bVeto = sal_True;
 694         bVeto = ::cppu::any2bool(aArguments[2]);
 695         m_bVeto = bVeto;
 696         return;
 697     }
 698
 699     if ( aArguments.getLength() > 0 )
 700     {
 701         if ( !ShutdownIcon::pShutdownIcon )
 702         {
 703             try
 704             {
 705                 sal_Bool bQuickstart = sal_False;
 706                 bQuickstart = ::cppu::any2bool( aArguments[0] );
 707                 if( !bQuickstart && !GetAutostart() )
 708                     return;
 709                 aGuard.clear();
 710                 init ();
 711                 aGuard.reset();
 712                 if ( !m_xDesktop.is() )
 713                     return;
 714
 715                 /* Create a sub-classed instance - foo */
 716                 ShutdownIcon::pShutdownIcon = this;
 717                 initSystray();
 718             }
 719             catch(const ::com::sun::star::lang::IllegalArgumentException&)
 720             {
 721             }
 722         }
 723     }
 724     if ( aArguments.getLength() > 1 )
 725     {
 726             sal_Bool bAutostart = sal_False;
 727             bAutostart = ::cppu::any2bool( aArguments[1] );
 728             if (bAutostart && !GetAutostart())
 729                 SetAutostart( sal_True );
 730             if (!bAutostart && GetAutostart())
 731                 SetAutostart( sal_False );
 732     }
 733
 734 }
 735
 736 // -------------------------------
 737
 738 void ShutdownIcon::EnterModalMode()
 739 {
 740     bModalMode = sal_True;
 741 }
 742
 743 // -------------------------------
 744
 745 void ShutdownIcon::LeaveModalMode()
 746 {
 747     bModalMode = sal_False;
 748 }
 749
 750 #ifdef WNT
 751 // defined in shutdowniconw32.cxx
 752 #elif defined MACOSX
 753 // defined in shutdowniconaqua.cxx
 754 #else
 755 bool ShutdownIcon::IsQuickstarterInstalled()
 756 {
 757 #ifndef ENABLE_QUICKSTART_APPLET
 758     return false;
 759 #else // !ENABLE_QUICKSTART_APPLET
 760 #ifdef UNX
 761     return LoadModule( NULL, NULL, NULL);
 762 #endif // UNX
 763 #endif // !ENABLE_QUICKSTART_APPLET
 764 }
 765 #endif // !WNT
 766
 767 // ---------------------------------------------------------------------------
 768
 769 #if defined (ENABLE_QUICKSTART_APPLET) && defined (UNX)
 770 /**
 771 * Return the XDG autostart directory.
 772 * http://standards.freedesktop.org/autostart-spec/autostart-spec-latest.html
 773 * Available in Unix and with Quickstart enabled.
 774 * @param bCreate Create the directory if it does not exist yet.
 775 * @return OUString containing the autostart directory path.
 776 */
 777 static OUString getAutostartDir( bool bCreate = false )
 778 {
 779     OUString aShortcut;
 780     const char *pConfigHome;
 781     if( (pConfigHome = getenv("XDG_CONFIG_HOME") ) )
 782         aShortcut = OStringToOUString( OString( pConfigHome ),
 783                                        RTL_TEXTENCODING_UTF8 );
 784     else
 785     {
 786         OUString aHomeURL;
 787         osl::Security().getHomeDir( aHomeURL );
 788         ::osl::File::getSystemPathFromFileURL( aHomeURL, aShortcut );
 789         aShortcut += "/.config";
 790     }
 791     aShortcut += "/autostart";
 792     if (bCreate)
 793     {
 794         OUString aShortcutUrl;
 795         osl::File::getFileURLFromSystemPath( aShortcut, aShortcutUrl );
 796         osl::Directory::createPath( aShortcutUrl );
 797     }
 798     return aShortcut;
 799 }
 800 #endif
 801
 802 OUString ShutdownIcon::getShortcutName()
 803 {
 804 #ifndef ENABLE_QUICKSTART_APPLET
 805     return OUString();
 806 #else
 807
 808     OUString aShortcutName( "StarOffice 6.0"  );
 809     ResMgr* pMgr = SfxResId::GetResMgr();
 810     if( pMgr )
 811     {
 812         ::SolarMutexGuard aGuard;
 813         aShortcutName = SFX2_RESSTR(STR_QUICKSTART_LNKNAME);
 814     }
 815 #ifdef WNT
 816     aShortcutName += ".lnk";
 817
 818     OUString aShortcut(GetAutostartFolderNameW32());
 819     aShortcut += "\\";
 820     aShortcut += aShortcutName;
 821 #else // UNX
 822     OUString aShortcut = getAutostartDir();
 823     aShortcut += "/qstart.desktop";
 824 #endif // UNX
 825     return aShortcut;
 826 #endif // ENABLE_QUICKSTART_APPLET
 827 }
 828
 829 bool ShutdownIcon::GetAutostart( )
 830 {
 831 #if defined MACOSX
 832     return true;
 833 #else
 834     bool bRet = false;
 835 #ifdef ENABLE_QUICKSTART_APPLET
 836     OUString aShortcut( getShortcutName() );
 837     OUString aShortcutUrl;
 838     osl::File::getFileURLFromSystemPath( aShortcut, aShortcutUrl );
 839     osl::File f( aShortcutUrl );
 840     osl::File::RC error = f.open( osl_File_OpenFlag_Read );
 841     if( error == osl::File::E_None )
 842     {
 843         f.close();
 844         bRet = true;
 845     }
 846 #endif // ENABLE_QUICKSTART_APPLET
 847     return bRet;
 848 #endif
 849 }
 850
 851 void ShutdownIcon::SetAutostart( bool bActivate )
 852 {
 853 #ifdef ENABLE_QUICKSTART_APPLET
 854     OUString aShortcut( getShortcutName() );
 855
 856     if( bActivate && IsQuickstarterInstalled() )
 857     {
 858 #ifdef WNT
 859         EnableAutostartW32( aShortcut );
 860 #else // UNX
 861         getAutostartDir( true );
 862
 863         OUString aPath( "${BRAND_BASE_DIR}/share/xdg/qstart.desktop"  );
 864         Bootstrap::expandMacros( aPath );
 865
 866         OUString aDesktopFile;
 867         ::osl::File::getSystemPathFromFileURL( aPath, aDesktopFile );
 868
 869         OString aDesktopFileUnx = OUStringToOString( aDesktopFile,
 870                                                      osl_getThreadTextEncoding() );
 871         OString aShortcutUnx = OUStringToOString( aShortcut,
 872                                                   osl_getThreadTextEncoding() );
 873         if ((0 != symlink(aDesktopFileUnx.getStr(), aShortcutUnx.getStr())) && (errno == EEXIST))
 874         {
 875             unlink(aShortcutUnx.getStr());
 876             int ret = symlink(aDesktopFileUnx.getStr(), aShortcutUnx.getStr());
 877             (void)ret; //deliberately ignore return value, it's non-critical if it fails
 878         }
 879
 880         ShutdownIcon *pIcon = ShutdownIcon::createInstance();
 881         if( pIcon )
 882             pIcon->initSystray();
 883 #endif // UNX
 884     }
 885     else
 886     {
 887         OUString aShortcutUrl;
 888         ::osl::File::getFileURLFromSystemPath( aShortcut, aShortcutUrl );
 889         ::osl::File::remove( aShortcutUrl );
 890 #ifdef UNX
 891         if (pShutdownIcon)
 892         {
 893             ShutdownIcon *pIcon = getInstance();
 894             pIcon->deInitSystray();
 895         }
 896 #endif
 897     }
 898 #else
 899     (void)bActivate; // unused variable
 900 #endif // ENABLE_QUICKSTART_APPLET
 901 }
 902
 903 static const ::sal_Int32 PROPHANDLE_TERMINATEVETOSTATE = 0;
 904
 905 // XFastPropertySet
 906 void SAL_CALL ShutdownIcon::setFastPropertyValue(       ::sal_Int32                  nHandle,
 907                                                   const ::com::sun::star::uno::Any& aValue )
 908     throw (::com::sun::star::beans::UnknownPropertyException,
 909             ::com::sun::star::beans::PropertyVetoException,
 910             ::com::sun::star::lang::IllegalArgumentException,
 911             ::com::sun::star::lang::WrappedTargetException,
 912             ::com::sun::star::uno::RuntimeException)
 913 {
 914     switch(nHandle)
 915     {
 916         case PROPHANDLE_TERMINATEVETOSTATE :
 917              {
 918                 // use new value in case it's a valid information only
 919                 ::sal_Bool bState( sal_False );
 920                 if (! (aValue >>= bState))
 921                     return;
 922
 923                 m_bVeto = bState;
 924                 if (m_bVeto && ! m_bListenForTermination)
 925                     addTerminateListener();
 926              }
 927              break;
 928
 929         default :
 930             throw ::com::sun::star::beans::UnknownPropertyException();
 931     }
 932 }
 933
 934 // XFastPropertySet
 935 ::com::sun::star::uno::Any SAL_CALL ShutdownIcon::getFastPropertyValue( ::sal_Int32 nHandle )
 936     throw (::com::sun::star::beans::UnknownPropertyException,
 937             ::com::sun::star::lang::WrappedTargetException,
 938             ::com::sun::star::uno::RuntimeException)
 939 {
 940     ::com::sun::star::uno::Any aValue;
 941     switch(nHandle)
 942     {
 943         case PROPHANDLE_TERMINATEVETOSTATE :
 944              {
 945                 bool bState   = (m_bListenForTermination && m_bVeto);
 946                      aValue <<= bState;
 947              }
 948              break;
 949
 950         default :
 951             throw ::com::sun::star::beans::UnknownPropertyException();
 952     }
 953
 954     return aValue;
 955 }
 956
 957 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */