framework/source/helper/statusindicatorfactory.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 <algorithm>
  21 #include <utility>
  22 #include <helper/statusindicatorfactory.hxx>
  23 #include <helper/statusindicator.hxx>
  24 #include <helper/vclstatusindicator.hxx>
  25 #include <properties.h>
  26
  27 #include <com/sun/star/awt/XWindow2.hpp>
  28 #include <com/sun/star/beans/XPropertySet.hpp>
  29 #include <com/sun/star/frame/XLayoutManager2.hpp>
  30
  31 #include <toolkit/helper/vclunohelper.hxx>
  32
  33 #include <comphelper/sequenceashashmap.hxx>
  34 #include <unotools/mediadescriptor.hxx>
  35 #include <vcl/svapp.hxx>
  36 #include <mutex>
  37 #include <rtl/ref.hxx>
  38
  39 #include <officecfg/Office/Common.hxx>
  40
  41 namespace framework{
  42
  43 sal_Int32 StatusIndicatorFactory::m_nInReschedule = 0;  ///< static counter for rescheduling
  44
  45 constexpr OUString PROGRESS_RESOURCE = u"private:resource/progressbar/progressbar"_ustr;
  46
  47 StatusIndicatorFactory::StatusIndicatorFactory(css::uno::Reference< css::uno::XComponentContext >  xContext)
  48     : m_xContext          (std::move(xContext ))
  49     , m_bAllowReschedule  (false)
  50     , m_bAllowParentShow  (false)
  51     , m_bDisableReschedule(false)
  52 {
  53 }
  54
  55 StatusIndicatorFactory::~StatusIndicatorFactory()
  56 {
  57     impl_stopWakeUpThread();
  58 }
  59
  60 void SAL_CALL StatusIndicatorFactory::initialize(const css::uno::Sequence< css::uno::Any >& lArguments)
  61 {
  62     if (lArguments.hasElements()) {
  63         std::scoped_lock g(m_mutex);
  64
  65         css::uno::Reference< css::frame::XFrame > xTmpFrame;
  66         css::uno::Reference< css::awt::XWindow > xTmpWindow;
  67         bool b1 = lArguments[0] >>= xTmpFrame;
  68         bool b2 = lArguments[0] >>= xTmpWindow;
  69         if (lArguments.getLength() == 3 && b1) {
  70            // it's the first service constructor "createWithFrame"
  71             m_xFrame = xTmpFrame;
  72             lArguments[1] >>= m_bDisableReschedule;
  73             lArguments[2] >>= m_bAllowParentShow;
  74         } else if (lArguments.getLength() == 3 && b2) {
  75            // it's the second service constructor "createWithWindow"
  76             m_xPluggWindow = xTmpWindow;
  77             lArguments[1] >>= m_bDisableReschedule;
  78             lArguments[2] >>= m_bAllowParentShow;
  79         } else {
  80            // it's an old-style initialisation using properties
  81             ::comphelper::SequenceAsHashMap lArgs(lArguments);
  82
  83             m_xFrame             = lArgs.getUnpackedValueOrDefault(u"Frame"_ustr            , css::uno::Reference< css::frame::XFrame >());
  84             m_xPluggWindow       = lArgs.getUnpackedValueOrDefault(u"Window"_ustr           , css::uno::Reference< css::awt::XWindow >() );
  85             m_bAllowParentShow   = lArgs.getUnpackedValueOrDefault(u"AllowParentShow"_ustr  , false );
  86             m_bDisableReschedule = lArgs.getUnpackedValueOrDefault(u"DisableReschedule"_ustr, false );
  87        }
  88     }
  89
  90 #ifdef EMSCRIPTEN
  91     m_bDisableReschedule = true;
  92 #endif
  93     impl_createProgress();
  94 }
  95
  96 css::uno::Reference< css::task::XStatusIndicator > SAL_CALL StatusIndicatorFactory::createStatusIndicator()
  97 {
  98     return new StatusIndicator(this);
  99 }
 100
 101 void SAL_CALL StatusIndicatorFactory::update()
 102 {
 103     std::scoped_lock g(m_mutex);
 104     m_bAllowReschedule = true;
 105 }
 106
 107 void StatusIndicatorFactory::start(const css::uno::Reference< css::task::XStatusIndicator >& xChild,
 108                                    const OUString&                                    sText ,
 109                                          sal_Int32                                           nRange)
 110 {
 111     css::uno::Reference< css::task::XStatusIndicator > xProgress;
 112     // SAFE -> ----------------------------------
 113     {
 114         std::scoped_lock aWriteLock(m_mutex);
 115
 116         // create new info structure for this child or move it to the front of our stack
 117         IndicatorStack::iterator pItem = ::std::find(m_aStack.begin(), m_aStack.end(), xChild);
 118         if (pItem != m_aStack.end())
 119             m_aStack.erase(pItem);
 120         IndicatorInfo aInfo(xChild, sText);
 121         m_aStack.push_back (aInfo                );
 122
 123         m_xActiveChild = xChild;
 124         xProgress = m_xProgress;
 125     }
 126     // <- SAFE ----------------------------------
 127
 128     implts_makeParentVisibleIfAllowed();
 129
 130     if (xProgress.is())
 131         xProgress->start(sText, nRange);
 132
 133     impl_startWakeUpThread();
 134     impl_reschedule(true);
 135 }
 136
 137 void StatusIndicatorFactory::reset(const css::uno::Reference< css::task::XStatusIndicator >& xChild)
 138 {
 139     css::uno::Reference< css::task::XStatusIndicator > xActive;
 140     css::uno::Reference< css::task::XStatusIndicator > xProgress;
 141     // SAFE -> ----------------------------------
 142     {
 143         std::scoped_lock aReadLock(m_mutex);
 144
 145         // reset the internal info structure related to this child
 146         IndicatorStack::iterator pItem = ::std::find(m_aStack.begin(), m_aStack.end(), xChild);
 147         if (pItem != m_aStack.end())
 148         {
 149             pItem->m_nValue = 0;
 150             pItem->m_sText.clear();
 151         }
 152
 153         xActive   = m_xActiveChild;
 154         xProgress = m_xProgress;
 155     }
 156     // <- SAFE ----------------------------------
 157
 158     // not the top most child => don't change UI
 159     // But don't forget Reschedule!
 160     if (
 161         (xChild == xActive) &&
 162         (xProgress.is()   )
 163        )
 164         xProgress->reset();
 165
 166     impl_reschedule(true);
 167 }
 168
 169 void StatusIndicatorFactory::end(const css::uno::Reference< css::task::XStatusIndicator >& xChild)
 170 {
 171     css::uno::Reference< css::task::XStatusIndicator > xActive;
 172     css::uno::Reference< css::task::XStatusIndicator > xProgress;
 173     OUString sText;
 174     sal_Int32 nValue = 0;
 175     // SAFE -> ----------------------------------
 176     {
 177         std::scoped_lock aWriteLock(m_mutex);
 178
 179         // remove this child from our stack
 180         IndicatorStack::iterator pItem = ::std::find(m_aStack.begin(), m_aStack.end(), xChild);
 181         if (pItem != m_aStack.end())
 182             m_aStack.erase(pItem);
 183
 184         // activate next child ... or finish the progress if there is no further one.
 185         m_xActiveChild.clear();
 186         IndicatorStack::reverse_iterator pNext  = m_aStack.rbegin();
 187         if (pNext != m_aStack.rend())
 188         {
 189             m_xActiveChild = pNext->m_xIndicator;
 190             sText          = pNext->m_sText;
 191             nValue         = pNext->m_nValue;
 192         }
 193
 194         xActive   = m_xActiveChild;
 195         xProgress = m_xProgress;
 196     }
 197     // <- SAFE ----------------------------------
 198
 199     if (xActive.is())
 200     {
 201         // There is at least one further child indicator.
 202         // Actualize our progress, so it shows these values from now.
 203         if (xProgress.is())
 204         {
 205             xProgress->setText (sText );
 206             xProgress->setValue(nValue);
 207         }
 208     }
 209     else
 210     {
 211         // Our stack is empty. No further child exists.
 212         // Se we must "end" our progress really
 213         if (xProgress.is())
 214             xProgress->end();
 215         // Now hide the progress bar again.
 216         impl_hideProgress();
 217
 218         impl_stopWakeUpThread();
 219     }
 220
 221     impl_reschedule(true);
 222 }
 223
 224 void StatusIndicatorFactory::setText(const css::uno::Reference< css::task::XStatusIndicator >& xChild,
 225                                      const OUString&                                    sText )
 226 {
 227     css::uno::Reference< css::task::XStatusIndicator > xActive;
 228     css::uno::Reference< css::task::XStatusIndicator > xProgress;
 229     // SAFE -> ----------------------------------
 230     {
 231         std::scoped_lock aWriteLock(m_mutex);
 232
 233         IndicatorStack::iterator pItem = ::std::find(m_aStack.begin(), m_aStack.end(), xChild);
 234         if (pItem != m_aStack.end())
 235             pItem->m_sText = sText;
 236
 237         xActive   = m_xActiveChild;
 238         xProgress = m_xProgress;
 239     }
 240     // SAFE -> ----------------------------------
 241
 242     // paint only the top most indicator
 243     // but don't forget to Reschedule!
 244     if (
 245         (xChild == xActive) &&
 246         (xProgress.is()   )
 247        )
 248     {
 249         xProgress->setText(sText);
 250     }
 251
 252     impl_reschedule(true);
 253 }
 254
 255 void StatusIndicatorFactory::setValue( const css::uno::Reference< css::task::XStatusIndicator >& xChild ,
 256                                              sal_Int32                                           nValue )
 257 {
 258     sal_Int32 nOldValue = 0;
 259     css::uno::Reference< css::task::XStatusIndicator > xActive;
 260     css::uno::Reference< css::task::XStatusIndicator > xProgress;
 261     // SAFE -> ----------------------------------
 262     {
 263         std::scoped_lock aWriteLock(m_mutex);
 264
 265         IndicatorStack::iterator pItem = ::std::find(m_aStack.begin(), m_aStack.end(), xChild);
 266         if (pItem != m_aStack.end())
 267         {
 268             nOldValue       = pItem->m_nValue;
 269             pItem->m_nValue = nValue;
 270         }
 271
 272         xActive    = m_xActiveChild;
 273         xProgress  = m_xProgress;
 274     }
 275     // SAFE -> ----------------------------------
 276
 277     if (
 278         (xChild    == xActive) &&
 279         (nOldValue != nValue ) &&
 280         (xProgress.is()      )
 281        )
 282     {
 283         xProgress->setValue(nValue);
 284     }
 285
 286     impl_reschedule(false);
 287 }
 288
 289 bool StatusIndicatorFactory::joinThreads()
 290 {
 291     WakeUpThread::joinThread();
 292     return true;
 293 }
 294
 295 void StatusIndicatorFactory::startThreads()
 296 {
 297     WakeUpThread::startThread();
 298 }
 299
 300 void StatusIndicatorFactory::implts_makeParentVisibleIfAllowed()
 301 {
 302     css::uno::Reference< css::frame::XFrame > xFrame;
 303     css::uno::Reference< css::awt::XWindow >  xPluggWindow;
 304     css::uno::Reference< css::uno::XComponentContext > xContext;
 305     // SAFE -> ----------------------------------
 306     {
 307         std::scoped_lock aReadLock(m_mutex);
 308
 309         if (!m_bAllowParentShow)
 310             return;
 311
 312         xFrame = m_xFrame;
 313         xPluggWindow = m_xPluggWindow;
 314         xContext = m_xContext;
 315     }
 316     // <- SAFE ----------------------------------
 317
 318     css::uno::Reference< css::awt::XWindow > xParentWindow;
 319     if (xFrame.is())
 320         xParentWindow = xFrame->getContainerWindow();
 321     else
 322         xParentWindow = std::move(xPluggWindow);
 323
 324     // don't disturb user in case he put the loading document into the background!
 325     // Suppress any setVisible() or toFront() call in case the initial show was
 326     // already made.
 327     css::uno::Reference< css::awt::XWindow2 > xVisibleCheck(xParentWindow, css::uno::UNO_QUERY);
 328     bool bIsVisible = false;
 329     if (xVisibleCheck.is())
 330         bIsVisible = xVisibleCheck->isVisible();
 331
 332     if (bIsVisible)
 333     {
 334         impl_showProgress();
 335         return;
 336     }
 337
 338     // Check if the layout manager has been set to invisible state. It this case we are also
 339     // not allowed to set the frame visible!
 340     css::uno::Reference< css::beans::XPropertySet > xPropSet(xFrame, css::uno::UNO_QUERY);
 341     if (xPropSet.is())
 342     {
 343         css::uno::Reference< css::frame::XLayoutManager2 > xLayoutManager;
 344         xPropSet->getPropertyValue(FRAME_PROPNAME_ASCII_LAYOUTMANAGER) >>= xLayoutManager;
 345         if (xLayoutManager.is())
 346         {
 347             if ( !xLayoutManager->isVisible() )
 348                 return;
 349         }
 350     }
 351
 352     // Ok the window should be made visible... because it is not currently visible.
 353     // BUT..!
 354     // We need a Hack for our applications: They get her progress from the frame directly
 355     // on saving documents. Because there is no progress set on the MediaDescriptor.
 356     // But that's wrong. In case the document was opened hidden, they should not use any progress .-(
 357     // They only possible workaround: don't show the parent window here, if the document was opened hidden.
 358     bool bHiddenDoc = false;
 359     if (xFrame.is())
 360     {
 361         css::uno::Reference< css::frame::XController > xController;
 362         css::uno::Reference< css::frame::XModel >      xModel;
 363         xController = xFrame->getController();
 364         if (xController.is())
 365             xModel = xController->getModel();
 366         if (xModel.is())
 367         {
 368             utl::MediaDescriptor lDocArgs(xModel->getArgs());
 369             bHiddenDoc = lDocArgs.getUnpackedValueOrDefault(
 370                 utl::MediaDescriptor::PROP_HIDDEN,
 371                 false);
 372         }
 373     }
 374
 375     if (bHiddenDoc)
 376         return;
 377
 378     // OK: The document was not opened in hidden mode ...
 379     // and the window isn't already visible.
 380     // Show it and bring it to front.
 381     // But before we have to be sure, that our internal used helper progress
 382     // is visible too.
 383     impl_showProgress();
 384
 385     SolarMutexGuard aSolarGuard;
 386     VclPtr<vcl::Window> pWindow = VCLUnoHelper::GetWindow(xParentWindow);
 387     if ( pWindow )
 388     {
 389         bool bForceFrontAndFocus(officecfg::Office::Common::View::NewDocumentHandling::ForceFocusAndToFront::get());
 390         pWindow->Show(true, bForceFrontAndFocus ? ShowFlags::ForegroundTask : ShowFlags::NONE );
 391     }
 392
 393 }
 394
 395 void StatusIndicatorFactory::impl_createProgress()
 396 {
 397     css::uno::Reference< css::frame::XFrame > xFrame;
 398     css::uno::Reference< css::awt::XWindow > xWindow;
 399     // SAFE -> ----------------------------------
 400     {
 401         std::scoped_lock aReadLock(m_mutex);
 402
 403         xFrame = m_xFrame;
 404         xWindow = m_xPluggWindow;
 405     }
 406     // <- SAFE ----------------------------------
 407
 408     css::uno::Reference< css::task::XStatusIndicator > xProgress;
 409
 410     if (xWindow.is())
 411     {
 412         // use vcl based progress implementation in plugged mode
 413         xProgress = new VCLStatusIndicator(xWindow);
 414     }
 415     else if (xFrame.is())
 416     {
 417         // use frame layouted progress implementation
 418         css::uno::Reference< css::beans::XPropertySet > xPropSet(xFrame, css::uno::UNO_QUERY);
 419         if (xPropSet.is())
 420         {
 421             css::uno::Reference< css::frame::XLayoutManager2 > xLayoutManager;
 422             xPropSet->getPropertyValue(FRAME_PROPNAME_ASCII_LAYOUTMANAGER) >>= xLayoutManager;
 423             if (xLayoutManager.is())
 424             {
 425                 xLayoutManager->lock();
 426                 OUString sPROGRESS_RESOURCE(PROGRESS_RESOURCE);
 427                 xLayoutManager->createElement( sPROGRESS_RESOURCE );
 428                 xLayoutManager->hideElement( sPROGRESS_RESOURCE );
 429
 430                 css::uno::Reference< css::ui::XUIElement > xProgressBar = xLayoutManager->getElement(sPROGRESS_RESOURCE);
 431                 if (xProgressBar.is())
 432                     xProgress.set(xProgressBar->getRealInterface(), css::uno::UNO_QUERY);
 433                 xLayoutManager->unlock();
 434             }
 435         }
 436     }
 437
 438     std::scoped_lock g(m_mutex);
 439     m_xProgress = std::move(xProgress);
 440 }
 441
 442 void StatusIndicatorFactory::impl_showProgress()
 443 {
 444     css::uno::Reference< css::frame::XFrame > xFrame;
 445     // SAFE -> ----------------------------------
 446     {
 447         std::scoped_lock aReadLock(m_mutex);
 448
 449         xFrame = m_xFrame;
 450     }
 451     // <- SAFE ----------------------------------
 452
 453     css::uno::Reference< css::task::XStatusIndicator > xProgress;
 454
 455     if (!xFrame.is())
 456         return;
 457
 458     // use frame layouted progress implementation
 459     css::uno::Reference< css::beans::XPropertySet > xPropSet(xFrame, css::uno::UNO_QUERY);
 460     if (xPropSet.is())
 461     {
 462         css::uno::Reference< css::frame::XLayoutManager2 > xLayoutManager;
 463         xPropSet->getPropertyValue(FRAME_PROPNAME_ASCII_LAYOUTMANAGER) >>= xLayoutManager;
 464         if (xLayoutManager.is())
 465         {
 466             // Be sure that we have always a progress. It can be that our frame
 467             // was recycled and therefore the progress was destroyed!
 468             // CreateElement does nothing if there is already a valid progress.
 469             OUString sPROGRESS_RESOURCE(PROGRESS_RESOURCE);
 470             xLayoutManager->createElement( sPROGRESS_RESOURCE );
 471             xLayoutManager->showElement( sPROGRESS_RESOURCE );
 472
 473             css::uno::Reference< css::ui::XUIElement > xProgressBar = xLayoutManager->getElement(sPROGRESS_RESOURCE);
 474             if (xProgressBar.is())
 475                 xProgress.set(xProgressBar->getRealInterface(), css::uno::UNO_QUERY);
 476         }
 477     }
 478
 479     std::scoped_lock g(m_mutex);
 480     m_xProgress = std::move(xProgress);
 481 }
 482
 483 void StatusIndicatorFactory::impl_hideProgress()
 484 {
 485     css::uno::Reference< css::frame::XFrame > xFrame;
 486     // SAFE -> ----------------------------------
 487     {
 488         std::scoped_lock aReadLock(m_mutex);
 489
 490         xFrame = m_xFrame;
 491     }
 492     // <- SAFE ----------------------------------
 493
 494     if (xFrame.is())
 495     {
 496         // use frame layouted progress implementation
 497         css::uno::Reference< css::beans::XPropertySet > xPropSet(xFrame, css::uno::UNO_QUERY);
 498         if (xPropSet.is())
 499         {
 500             css::uno::Reference< css::frame::XLayoutManager2 > xLayoutManager;
 501             xPropSet->getPropertyValue(FRAME_PROPNAME_ASCII_LAYOUTMANAGER) >>= xLayoutManager;
 502             if (xLayoutManager.is())
 503                 xLayoutManager->hideElement( PROGRESS_RESOURCE );
 504         }
 505     }
 506 }
 507
 508 void StatusIndicatorFactory::impl_reschedule(bool bForce)
 509 {
 510     // SAFE ->
 511     {
 512         std::scoped_lock aReadLock(m_mutex);
 513         if (m_bDisableReschedule)
 514             return;
 515     }
 516     // <- SAFE
 517
 518     bool bReschedule = bForce;
 519     if (!bReschedule)
 520     {
 521         std::scoped_lock g(m_mutex);
 522         bReschedule        = m_bAllowReschedule;
 523         m_bAllowReschedule = false;
 524     }
 525
 526     if (!bReschedule)
 527         return;
 528
 529     static std::mutex rescheduleLock;
 530     // SAFE ->
 531     std::unique_lock aRescheduleGuard(rescheduleLock);
 532
 533     if (m_nInReschedule != 0)
 534         return;
 535
 536     // coverity[missing_lock: FALSE] - coverity fails to see the aRescheduleGuard ctor as taking a lock
 537     ++m_nInReschedule;
 538     aRescheduleGuard.unlock();
 539     // <- SAFE
 540
 541     {
 542         SolarMutexGuard g;
 543         Application::Reschedule(true);
 544     }
 545
 546     // SAFE ->
 547     aRescheduleGuard.lock();
 548     --m_nInReschedule;
 549 }
 550
 551 void StatusIndicatorFactory::impl_startWakeUpThread()
 552 {
 553     std::scoped_lock g(m_mutex);
 554
 555     if (m_bDisableReschedule)
 556         return;
 557
 558     if (!m_pWakeUp)
 559         m_pWakeUp.reset(new WakeUpThread(this));
 560 }
 561
 562 void StatusIndicatorFactory::impl_stopWakeUpThread()
 563 {
 564     std::unique_ptr<WakeUpThread> wakeUp;
 565     {
 566         std::scoped_lock g(m_mutex);
 567         std::swap(wakeUp, m_pWakeUp);
 568     }
 569     if (wakeUp)
 570         wakeUp->stop();
 571 }
 572
 573 } // namespace framework
 574
 575 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
 576 com_sun_star_comp_framework_StatusIndicatorFactory_get_implementation(
 577     css::uno::XComponentContext *context,
 578     css::uno::Sequence<css::uno::Any> const &)
 579 {
 580     return cppu::acquire(new framework::StatusIndicatorFactory(context));
 581 }
 582
 583 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */