slideshow/source/engine/activitiesqueue.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 #include <tools/diagnose_ex.h>
  22 #include <osl/diagnose.h>
  23 #include <sal/log.hxx>
  24
  25 #include <slideshowexceptions.hxx>
  26 #include <activity.hxx>
  27 #include <activitiesqueue.hxx>
  28
  29 #include <algorithm>
  30 #include <memory>
  31
  32
  33 using namespace ::com::sun::star;
  34
  35 namespace slideshow
  36 {
  37     namespace internal
  38     {
  39         ActivitiesQueue::ActivitiesQueue(
  40           const std::shared_ptr< ::canvas::tools::ElapsedTime >& pPresTimer ) :
  41             mpTimer( pPresTimer ),
  42             maCurrentActivitiesWaiting(),
  43             maCurrentActivitiesReinsert(),
  44             maDequeuedActivities()
  45         {
  46         }
  47
  48         ActivitiesQueue::~ActivitiesQueue()
  49         {
  50             // dispose all queue entries
  51             try
  52             {
  53                 for( const auto& pActivity : maCurrentActivitiesWaiting )
  54                     pActivity->dispose();
  55                 for( const auto& pActivity : maCurrentActivitiesReinsert )
  56                     pActivity->dispose();
  57             }
  58             catch (const uno::Exception&)
  59             {
  60                 TOOLS_WARN_EXCEPTION("slideshow", "");
  61             }
  62         }
  63
  64         bool ActivitiesQueue::addActivity( const ActivitySharedPtr& pActivity )
  65         {
  66             OSL_ENSURE( pActivity, "ActivitiesQueue::addActivity: activity ptr NULL" );
  67
  68             if( !pActivity )
  69                 return false;
  70
  71             // add entry to waiting list
  72             maCurrentActivitiesWaiting.push_back( pActivity );
  73
  74             return true;
  75         }
  76
  77         void ActivitiesQueue::process()
  78         {
  79             SAL_INFO("slideshow.verbose", "ActivitiesQueue: outer loop heartbeat" );
  80
  81             // accumulate time lag for all activities, and lag time
  82             // base if necessary:
  83             double fLag = 0.0;
  84             for ( const auto& rxActivity : maCurrentActivitiesWaiting )
  85                 fLag = std::max<double>( fLag, rxActivity->calcTimeLag() );
  86             if (fLag > 0.0)
  87             {
  88                 mpTimer->adjustTimer( -fLag );
  89             }
  90
  91             // process list of activities
  92             while( !maCurrentActivitiesWaiting.empty() )
  93             {
  94                 // process topmost activity
  95                 ActivitySharedPtr pActivity( maCurrentActivitiesWaiting.front() );
  96                 maCurrentActivitiesWaiting.pop_front();
  97
  98                 bool bReinsert( false );
  99
 100                 try
 101                 {
 102                     // fire up activity
 103                     bReinsert = pActivity->perform();
 104                 }
 105                 catch( uno::RuntimeException& )
 106                 {
 107                     throw;
 108                 }
 109                 catch( uno::Exception& )
 110                 {
 111                     // catch anything here, we don't want
 112                     // to leave this scope under _any_
 113                     // circumstance. Although, do _not_
 114                     // reinsert an activity that threw
 115                     // once.
 116
 117                     // NOTE: we explicitly don't catch(...) here,
 118                     // since this will also capture segmentation
 119                     // violations and the like. In such a case, we
 120                     // still better let our clients now...
 121                     TOOLS_WARN_EXCEPTION( "slideshow", "" );
 122                 }
 123                 catch( SlideShowException& )
 124                 {
 125                     // catch anything here, we don't want
 126                     // to leave this scope under _any_
 127                     // circumstance. Although, do _not_
 128                     // reinsert an activity that threw
 129                     // once.
 130
 131                     // NOTE: we explicitly don't catch(...) here,
 132                     // since this will also capture segmentation
 133                     // violations and the like. In such a case, we
 134                     // still better let our clients now...
 135                     SAL_WARN("slideshow", "::presentation::internal::ActivitiesQueue: Activity threw a SlideShowException, removing from ring" );
 136                 }
 137
 138                 if( bReinsert )
 139                     maCurrentActivitiesReinsert.push_back( pActivity );
 140                 else
 141                     maDequeuedActivities.push_back( pActivity );
 142
 143                 SAL_INFO("slideshow.verbose", "ActivitiesQueue: inner loop heartbeat" );
 144             }
 145
 146             if( !maCurrentActivitiesReinsert.empty() )
 147             {
 148                 // reinsert all processed, but not finished
 149                 // activities back to waiting queue. With swap(),
 150                 // we kill two birds with one stone: we reuse the
 151                 // list nodes, and we clear the
 152                 // maCurrentActivitiesReinsert list
 153                 maCurrentActivitiesWaiting.swap( maCurrentActivitiesReinsert );
 154             }
 155         }
 156
 157         void ActivitiesQueue::processDequeued()
 158         {
 159             // notify all dequeued activities from last round
 160             for( const auto& pActivity : maDequeuedActivities )
 161                 pActivity->dequeued();
 162             maDequeuedActivities.clear();
 163         }
 164
 165         bool ActivitiesQueue::isEmpty() const
 166         {
 167             return maCurrentActivitiesWaiting.empty() && maCurrentActivitiesReinsert.empty();
 168         }
 169
 170         void ActivitiesQueue::clear()
 171         {
 172             // dequeue all entries:
 173             for( const auto& pActivity : maCurrentActivitiesWaiting )
 174                 pActivity->dequeued();
 175             ActivityQueue().swap( maCurrentActivitiesWaiting );
 176
 177             for( const auto& pActivity : maCurrentActivitiesReinsert )
 178                 pActivity->dequeued();
 179             ActivityQueue().swap( maCurrentActivitiesReinsert );
 180         }
 181     }
 182 }
 183
 184 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */