Adding upstream version 4:7.4.7.upstream/4%7.4.7upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 148 insertions, 0 deletions

diff --git a/slideshow/source/inc/eventqueue.hxx b/slideshow/source/inc/eventqueue.hxx
new file mode 100644
index 000000000..fb0f1b853
--- /dev/null
+++ b/slideshow/source/inc/eventqueue.hxx
@@ -0,0 +1,148 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_SLIDESHOW_SOURCE_INC_EVENTQUEUE_HXX
+#define INCLUDED_SLIDESHOW_SOURCE_INC_EVENTQUEUE_HXX
+
+#include <canvas/elapsedtime.hxx>
+
+#include "event.hxx"
+
+#include <mutex>
+#include <queue>
+#include <vector>
+
+
+/* Definition of ActivitiesQueue class */
+
+namespace slideshow::internal
+    {
+        /** This class handles events in a presentation. Events are
+            time instants where e.g. effects start.
+         */
+        class EventQueue
+        {
+        public:
+            EventQueue(
+                std::shared_ptr< ::canvas::tools::ElapsedTime >
+                const & pPresTimer );
+
+            ~EventQueue();
+
+            EventQueue(const EventQueue&) = delete;
+            EventQueue& operator=(const EventQueue&) = delete;
+
+            /** Add the given event to the queue. The event is fired
+                at, or shortly after, its Event::getActivationTime instant.
+             */
+            bool addEvent( const EventSharedPtr& event );
+
+            /** Add the given event to the queue. The event is fired
+                at, or shortly after, its Event::getActivationTime instant.
+                The difference to addEvent() is that events added during
+                process() are postponed to next process().
+             */
+            bool addEventForNextRound( const EventSharedPtr& event );
+
+            /** Another way to control the order of asynchronous event
+                execution.  Use this method to schedule events that are to
+                be executed after all regular events that have no delay,
+                even when they schedule new regular events without delay.
+            */
+            bool addEventWhenQueueIsEmpty (const EventSharedPtr& rpEvent);
+
+            /** Process the event queue.
+
+                This method executes all events whose timeout has
+                expired when calling this method (i.e. all events
+                whose scheduled time is less or equal the current
+                time).
+
+                Check for the next available event's timeout via
+                nextTimeout(), or whether the queue is empty
+                altogether via isEmpty().
+             */
+            void process();
+
+            /** Query state of the queue
+
+                @return false, if queue is empty, true otherwise
+             */
+            bool isEmpty() const;
+
+            /** Query timeout for the topmost event in the queue.
+
+                @return Timeout in seconds, until the next event is
+                ready. The time returned here is relative to the pres
+                timer (i.e. the timer specified at the EventQueue
+                constructor). When the queue is empty (i.e. isEmpty()
+                returns true), the returned value is the highest
+                representable double value
+                (::std::numeric_limits<double>::max()). If the topmost
+                event in the queue is already pending, the timeout
+                returned here will actually be negative.
+            */
+            double nextTimeout() const;
+
+            /** Remove all pending events from the queue.
+             */
+            void clear();
+
+            /** Forces an empty queue, firing all events immediately
+                without minding any times.
+                @attention do only call from event loop, this calls process_()!
+             */
+            void forceEmpty();
+
+            /** Gets the queue's timer object.
+             */
+            std::shared_ptr< ::canvas::tools::ElapsedTime > const &
+            getTimer() const { return mpTimer; }
+
+        private:
+            mutable std::mutex      maMutex;
+
+            struct EventEntry
+            {
+                EventSharedPtr  pEvent;
+                double          nTime;
+
+                bool operator<( const EventEntry& ) const; // to leverage priority_queue's default compare
+
+                EventEntry( EventSharedPtr const& p, double t )
+                    : pEvent(p), nTime(t) {}
+            };
+
+            typedef ::std::priority_queue< EventEntry > ImplQueueType;
+            ImplQueueType                   maEvents;
+            typedef ::std::vector<EventEntry> EventEntryVector;
+            EventEntryVector                maNextEvents;
+            ImplQueueType                   maNextNextEvents;
+            void process_( bool bFireAllEvents );
+
+            // perform timing of events via relative time
+            // measurements. The world time starts, when the
+            // EventQueue object is created
+            std::shared_ptr< ::canvas::tools::ElapsedTime > mpTimer;
+        };
+
+}
+#endif // INCLUDED_SLIDESHOW_SOURCE_INC_EVENTQUEUE_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */