framework/source/jobs/helponstartup.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
  21 //_______________________________________________
  22 // include own header
  23 #include <jobs/helponstartup.hxx>
  24 #include <threadhelp/resetableguard.hxx>
  25 #include <loadenv/targethelper.hxx>
  26 #include <services.h>
  27
  28 //_______________________________________________
  29 // include others
  30 #include <comphelper/configurationhelper.hxx>
  31 #include <comphelper/sequenceashashmap.hxx>
  32 #include <unotools/configmgr.hxx>
  33 #include <vcl/svapp.hxx>
  34 #include <vcl/help.hxx>
  35 #include <rtl/ustrbuf.hxx>
  36
  37 //_______________________________________________
  38 // include interfaces
  39 #include <com/sun/star/frame/FrameSearchFlag.hpp>
  40 #include <com/sun/star/frame/ModuleManager.hpp>
  41 #include <com/sun/star/frame/XFramesSupplier.hpp>
  42 #include <com/sun/star/frame/Desktop.hpp>
  43
  44
  45 namespace framework{
  46
  47
  48 // path to module config
  49 static OUString CFG_PACKAGE_MODULES     ("/org.openoffice.Setup/Office/Factories");
  50 static OUString CFG_PACKAGE_SETUP       ("/org.openoffice.Setup");
  51 static OUString CFG_PACKAGE_COMMON      ("/org.openoffice.Office.Common");
  52 static OUString CFG_PATH_L10N           ("L10N");
  53 static OUString CFG_PATH_HELP           ("Help");
  54 static OUString CFG_KEY_LOCALE          ("ooLocale");
  55 static OUString CFG_KEY_HELPSYSTEM      ("System");
  56
  57 // props of job environment
  58 static OUString PROP_ENVIRONMENT        ("Environment");
  59 static OUString PROP_JOBCONFIG          ("JobConfig");
  60 static OUString PROP_ENVTYPE            ("EnvType");
  61 static OUString PROP_MODEL              ("Model");
  62
  63 // props of module config
  64 static OUString PROP_HELP_BASEURL       ("ooSetupFactoryHelpBaseURL");
  65 static OUString PROP_AUTOMATIC_HELP     ("ooSetupFactoryHelpOnOpen");
  66
  67 // special value of job environment
  68 static OUString ENVTYPE_DOCUMENTEVENT   ("DOCUMENTEVENT");
  69
  70 //-----------------------------------------------
  71
  72 DEFINE_XSERVICEINFO_MULTISERVICE_2(HelpOnStartup                   ,
  73                                       ::cppu::OWeakObject             ,
  74                                       SERVICENAME_JOB                 ,
  75                                       IMPLEMENTATIONNAME_HELPONSTARTUP)
  76
  77 DEFINE_INIT_SERVICE(HelpOnStartup,
  78                     {
  79                         /*  Attention
  80                             I think we don't need any mutex or lock here ... because we are called by our own static method impl_createInstance()
  81                             to create a new instance of this class by our own supported service factory.
  82                             see macro DEFINE_XSERVICEINFO_MULTISERVICE and "impl_initService()" for further information!
  83                         */
  84                         // create some needed uno services and cache it
  85                         m_xModuleManager = css::frame::ModuleManager::create( m_xContext );
  86
  87                         m_xDesktop = css::frame::Desktop::create(m_xContext);
  88
  89                         m_xConfig = css::uno::Reference< css::container::XNameAccess >(
  90                             ::comphelper::ConfigurationHelper::openConfig(
  91                                 m_xContext,
  92                                 CFG_PACKAGE_MODULES,
  93                                 ::comphelper::ConfigurationHelper::E_READONLY),
  94                             css::uno::UNO_QUERY_THROW);
  95
  96                         // ask for office locale
  97                         ::comphelper::ConfigurationHelper::readDirectKey(
  98                             m_xContext,
  99                             CFG_PACKAGE_SETUP,
 100                             CFG_PATH_L10N,
 101                             CFG_KEY_LOCALE,
 102                             ::comphelper::ConfigurationHelper::E_READONLY) >>= m_sLocale;
 103
 104                         // detect system
 105                         ::comphelper::ConfigurationHelper::readDirectKey(
 106                             m_xContext,
 107                             CFG_PACKAGE_COMMON,
 108                             CFG_PATH_HELP,
 109                             CFG_KEY_HELPSYSTEM,
 110                             ::comphelper::ConfigurationHelper::E_READONLY) >>= m_sSystem;
 111
 112                         // Start listening for disposing events of these services,
 113                         // so we can react e.g. for an office shutdown
 114                         css::uno::Reference< css::lang::XComponent > xComponent;
 115                         xComponent = css::uno::Reference< css::lang::XComponent >(m_xModuleManager, css::uno::UNO_QUERY);
 116                         if (xComponent.is())
 117                             xComponent->addEventListener(static_cast< css::lang::XEventListener* >(this));
 118                         xComponent = css::uno::Reference< css::lang::XComponent >(m_xDesktop, css::uno::UNO_QUERY);
 119                         if (xComponent.is())
 120                             xComponent->addEventListener(static_cast< css::lang::XEventListener* >(this));
 121                         xComponent = css::uno::Reference< css::lang::XComponent >(m_xConfig, css::uno::UNO_QUERY);
 122                         if (xComponent.is())
 123                             xComponent->addEventListener(static_cast< css::lang::XEventListener* >(this));
 124                     }
 125                    )
 126
 127 //-----------------------------------------------
 128 HelpOnStartup::HelpOnStartup(const css::uno::Reference< css::uno::XComponentContext >& xContext)
 129     : ThreadHelpBase(     )
 130     , m_xContext    (xContext)
 131 {
 132 }
 133
 134 //-----------------------------------------------
 135 HelpOnStartup::~HelpOnStartup()
 136 {
 137 }
 138
 139 //-----------------------------------------------
 140 // css.task.XJob
 141 css::uno::Any SAL_CALL HelpOnStartup::execute(const css::uno::Sequence< css::beans::NamedValue >& lArguments)
 142     throw(css::lang::IllegalArgumentException,
 143           css::uno::Exception                ,
 144           css::uno::RuntimeException         )
 145 {
 146     // Analyze the given arguments; try to locate a model there and
 147     // classify it's used application module.
 148     OUString sModule = its_getModuleIdFromEnv(lArguments);
 149
 150     // Attention: We are bound to events for openeing any document inside the office.
 151     // That includes e.g. the help module itself. But we have to do nothing then!
 152     if (sModule.isEmpty())
 153         return css::uno::Any();
 154
 155     // check current state of the help module
 156     // a) help isnt open                       => show default page for the detected module
 157     // b) help shows any other default page(!) => show default page for the detected module
 158     // c) help shows any other content         => do nothing (user travelled to any other content and leaved the set of default pages)
 159     OUString sCurrentHelpURL                = its_getCurrentHelpURL();
 160     sal_Bool        bCurrentHelpURLIsAnyDefaultURL = its_isHelpUrlADefaultOne(sCurrentHelpURL);
 161     sal_Bool        bShowIt                        = sal_False;
 162
 163     // a)
 164     if (sCurrentHelpURL.isEmpty())
 165         bShowIt = sal_True;
 166     // b)
 167     else if (bCurrentHelpURLIsAnyDefaultURL)
 168         bShowIt = sal_True;
 169
 170     if (bShowIt)
 171     {
 172         // retrieve the help URL for the detected application module
 173         OUString sModuleDependendHelpURL = its_checkIfHelpEnabledAndGetURL(sModule);
 174         if (!sModuleDependendHelpURL.isEmpty())
 175         {
 176             // Show this help page.
 177             // Note: The help window brings itself to front ...
 178             Help* pHelp = Application::GetHelp();
 179             if (pHelp)
 180                 pHelp->Start(sModuleDependendHelpURL, 0);
 181         }
 182     }
 183
 184     return css::uno::Any();
 185 }
 186
 187 //-----------------------------------------------
 188 void SAL_CALL HelpOnStartup::disposing(const css::lang::EventObject& aEvent)
 189     throw(css::uno::RuntimeException)
 190 {
 191     // SAFE ->
 192     ResetableGuard aLock(m_aLock);
 193
 194     if (aEvent.Source == m_xModuleManager)
 195         m_xModuleManager.clear();
 196     else if (aEvent.Source == m_xDesktop)
 197         m_xDesktop.clear();
 198     else if (aEvent.Source == m_xConfig)
 199         m_xConfig.clear();
 200
 201     aLock.unlock();
 202     // <- SAFE
 203 }
 204
 205 //-----------------------------------------------
 206 OUString HelpOnStartup::its_getModuleIdFromEnv(const css::uno::Sequence< css::beans::NamedValue >& lArguments)
 207 {
 208     ::comphelper::SequenceAsHashMap lArgs        (lArguments);
 209     ::comphelper::SequenceAsHashMap lEnvironment = lArgs.getUnpackedValueOrDefault(PROP_ENVIRONMENT, css::uno::Sequence< css::beans::NamedValue >());
 210     ::comphelper::SequenceAsHashMap lJobConfig   = lArgs.getUnpackedValueOrDefault(PROP_JOBCONFIG  , css::uno::Sequence< css::beans::NamedValue >());
 211
 212     // check for right environment.
 213     // If its not a DocumentEvent, which triggered this job,
 214     // we cant work correctly! => return immediately and do nothing
 215     OUString sEnvType = lEnvironment.getUnpackedValueOrDefault(PROP_ENVTYPE, OUString());
 216     if (!sEnvType.equals(ENVTYPE_DOCUMENTEVENT))
 217         return OUString();
 218
 219     css::uno::Reference< css::frame::XModel > xDoc = lEnvironment.getUnpackedValueOrDefault(PROP_MODEL, css::uno::Reference< css::frame::XModel >());
 220     if (!xDoc.is())
 221         return OUString();
 222
 223     // be sure that we work on top level documents only, which are registered
 224     // on the desktop instance. Ignore e.g. life previews, which are top frames too ...
 225     // but not registered at this global desktop instance.
 226     css::uno::Reference< css::frame::XDesktop >    xDesktopCheck;
 227     css::uno::Reference< css::frame::XFrame >      xFrame       ;
 228     css::uno::Reference< css::frame::XController > xController  = xDoc->getCurrentController();
 229     if (xController.is())
 230         xFrame = xController->getFrame();
 231     if (xFrame.is() && xFrame->isTop())
 232         xDesktopCheck = css::uno::Reference< css::frame::XDesktop >(xFrame->getCreator(), css::uno::UNO_QUERY);
 233     if (!xDesktopCheck.is())
 234         return OUString();
 235
 236     // OK - now we are sure this document is a top level document.
 237     // Classify it.
 238     // SAFE ->
 239     ResetableGuard aLock(m_aLock);
 240     css::uno::Reference< css::frame::XModuleManager2 > xModuleManager = m_xModuleManager;
 241     aLock.unlock();
 242     // <- SAFE
 243
 244     OUString sModuleId;
 245     try
 246     {
 247         sModuleId = xModuleManager->identify(xDoc);
 248     }
 249     catch(const css::uno::RuntimeException&)
 250         { throw; }
 251     catch(const css::uno::Exception&)
 252         { sModuleId = OUString(); }
 253
 254     return sModuleId;
 255 }
 256
 257 //-----------------------------------------------
 258 OUString HelpOnStartup::its_getCurrentHelpURL()
 259 {
 260     // SAFE ->
 261     ResetableGuard aLock(m_aLock);
 262     css::uno::Reference< css::frame::XDesktop2 > xDesktop = m_xDesktop;
 263     aLock.unlock();
 264     // <- SAFE
 265
 266     if (!xDesktop.is())
 267         return OUString();
 268
 269     css::uno::Reference< css::frame::XFrame > xHelp = xDesktop->findFrame(SPECIALTARGET_HELPTASK, css::frame::FrameSearchFlag::CHILDREN);
 270     if (!xHelp.is())
 271         return OUString();
 272
 273     OUString sCurrentHelpURL;
 274     try
 275     {
 276         css::uno::Reference< css::frame::XFramesSupplier >  xHelpRoot  (xHelp                 , css::uno::UNO_QUERY_THROW);
 277         css::uno::Reference< css::container::XIndexAccess > xHelpChildren(xHelpRoot->getFrames(), css::uno::UNO_QUERY_THROW);
 278
 279         css::uno::Reference< css::frame::XFrame >      xHelpChild  ;
 280         css::uno::Reference< css::frame::XController > xHelpView   ;
 281         css::uno::Reference< css::frame::XModel >      xHelpContent;
 282
 283         xHelpChildren->getByIndex(0) >>= xHelpChild;
 284         if (xHelpChild.is())
 285             xHelpView = xHelpChild->getController();
 286         if (xHelpView.is())
 287             xHelpContent = xHelpView->getModel();
 288         if (xHelpContent.is())
 289             sCurrentHelpURL = xHelpContent->getURL();
 290     }
 291     catch(const css::uno::RuntimeException&)
 292         { throw; }
 293     catch(const css::uno::Exception&)
 294         { sCurrentHelpURL = OUString(); }
 295
 296     return sCurrentHelpURL;
 297 }
 298
 299 //-----------------------------------------------
 300 ::sal_Bool HelpOnStartup::its_isHelpUrlADefaultOne(const OUString& sHelpURL)
 301 {
 302     if (sHelpURL.isEmpty())
 303         return sal_False;
 304
 305     // SAFE ->
 306     ResetableGuard aLock(m_aLock);
 307     css::uno::Reference< css::container::XNameAccess >     xConfig = m_xConfig;
 308     OUString                                        sLocale = m_sLocale;
 309     OUString                                        sSystem = m_sSystem;
 310     aLock.unlock();
 311     // <- SAFE
 312
 313     if (!xConfig.is())
 314         return sal_False;
 315
 316     // check given help url against all default ones
 317     const css::uno::Sequence< OUString > lModules = xConfig->getElementNames();
 318     const OUString*                      pModules = lModules.getConstArray();
 319           ::sal_Int32                           c        = lModules.getLength();
 320           ::sal_Int32                           i        = 0;
 321
 322     for (i=0; i<c; ++i)
 323     {
 324         try
 325         {
 326             css::uno::Reference< css::container::XNameAccess > xModuleConfig;
 327             xConfig->getByName(pModules[i]) >>= xModuleConfig;
 328             if (!xModuleConfig.is())
 329                 continue;
 330
 331             OUString sHelpBaseURL;
 332             xModuleConfig->getByName(PROP_HELP_BASEURL) >>= sHelpBaseURL;
 333             OUString sHelpURLForModule = HelpOnStartup::ist_createHelpURL(sHelpBaseURL, sLocale, sSystem);
 334             if (sHelpURL.equals(sHelpURLForModule))
 335                 return sal_True;
 336         }
 337         catch(const css::uno::RuntimeException&)
 338             { throw; }
 339         catch(const css::uno::Exception&)
 340             {}
 341     }
 342
 343     return sal_False;
 344 }
 345
 346 //-----------------------------------------------
 347 OUString HelpOnStartup::its_checkIfHelpEnabledAndGetURL(const OUString& sModule)
 348 {
 349     // SAFE ->
 350     ResetableGuard aLock(m_aLock);
 351     css::uno::Reference< css::container::XNameAccess > xConfig = m_xConfig;
 352     OUString                                    sLocale = m_sLocale;
 353     OUString                                    sSystem = m_sSystem;
 354     aLock.unlock();
 355     // <- SAFE
 356
 357     OUString sHelpURL;
 358
 359     try
 360     {
 361         css::uno::Reference< css::container::XNameAccess > xModuleConfig;
 362         if (xConfig.is())
 363             xConfig->getByName(sModule) >>= xModuleConfig;
 364
 365         sal_Bool bHelpEnabled = sal_False;
 366         if (xModuleConfig.is())
 367             xModuleConfig->getByName(PROP_AUTOMATIC_HELP) >>= bHelpEnabled;
 368
 369         if (bHelpEnabled)
 370         {
 371             OUString sHelpBaseURL;
 372             xModuleConfig->getByName(PROP_HELP_BASEURL) >>= sHelpBaseURL;
 373             sHelpURL = HelpOnStartup::ist_createHelpURL(sHelpBaseURL, sLocale, sSystem);
 374         }
 375     }
 376     catch(const css::uno::RuntimeException&)
 377         { throw; }
 378     catch(const css::uno::Exception&)
 379         { sHelpURL = OUString(); }
 380
 381     return sHelpURL;
 382 }
 383
 384 //-----------------------------------------------
 385 OUString HelpOnStartup::ist_createHelpURL(const OUString& sBaseURL,
 386                                                  const OUString& sLocale ,
 387                                                  const OUString& sSystem )
 388 {
 389     OUStringBuffer sHelpURL(256);
 390     sHelpURL.append     (sBaseURL    );
 391     sHelpURL.appendAscii("?Language=");
 392     sHelpURL.append     (sLocale     );
 393     sHelpURL.appendAscii("&System="  );
 394     sHelpURL.append     (sSystem     );
 395
 396     return sHelpURL.makeStringAndClear();
 397 }
 398
 399 } // namespace framework
 400
 401 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */