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