File indexing completed on 2024-05-19 05:31:44

 /*
     SPDX-FileCopyrightText: 2018 Vlad Zahorodnii <vlad.zahorodnii@kde.org>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #pragma once
 
 #include "kwin_export.h"
 
 #include <QEasingCurve>
 #include <QSharedDataPointer>
 
 #include <chrono>
 
 namespace KWin
 {
 
 /**
  * The TimeLine class is a helper for controlling animations.
  */
 class KWIN_EXPORT TimeLine
 {
 public:
     /**
      * Direction of the timeline.
      *
      * When the direction of the timeline is Forward, the progress
      * value will go from 0.0 to 1.0.
      *
      * When the direction of the timeline is Backward, the progress
      * value will go from 1.0 to 0.0.
      */
     enum Direction {
         Forward,
         Backward
     };
 
     /**
      * Constructs a new instance of TimeLine.
      *
      * @param duration Duration of the timeline, in milliseconds
      * @param direction Direction of the timeline
      * @since 5.14
      */
     explicit TimeLine(std::chrono::milliseconds duration = std::chrono::milliseconds(1000),
                       Direction direction = Forward);
     TimeLine(const TimeLine &other);
     ~TimeLine();
 
     /**
      * Returns the current value of the timeline.
      *
      * @since 5.14
      */
     qreal value() const;
 
     /**
      * Advances the timeline to the specified @a timestamp.
      */
     void advance(std::chrono::milliseconds timestamp);
 
     /**
      * Returns the number of elapsed milliseconds.
      *
      * @see setElapsed
      * @since 5.14
      */
     std::chrono::milliseconds elapsed() const;
 
     /**
      * Sets the number of elapsed milliseconds.
      *
      * This method overwrites previous value of elapsed milliseconds.
      * If the new value of elapsed milliseconds is greater or equal
      * to duration of the timeline, the timeline will be finished, i.e.
      * proceeding TimeLine::done method calls will return @c true.
      * Please don't use it. Instead, use TimeLine::update.
      *
      * @note The new number of elapsed milliseconds should be a non-negative
      * number, i.e. it should be greater or equal to 0.
      *
      * @param elapsed The new number of elapsed milliseconds
      * @see elapsed
      * @since 5.14
      */
     void setElapsed(std::chrono::milliseconds elapsed);
 
     /**
      * Returns the duration of the timeline.
      *
      * @returns Duration of the timeline, in milliseconds
      * @see setDuration
      * @since 5.14
      */
     std::chrono::milliseconds duration() const;
 
     /**
      * Sets the duration of the timeline.
      *
      * In addition to setting new value of duration, the timeline will
      * try to retarget the number of elapsed milliseconds to match
      * as close as possible old progress value. If the new duration
      * is much smaller than old duration, there is a big chance that
      * the timeline will be finished after setting new duration.
      *
      * @note The new duration should be a positive number, i.e. it
      * should be greater or equal to 1.
      *
      * @param duration The new duration of the timeline, in milliseconds
      * @see duration
      * @since 5.14
      */
     void setDuration(std::chrono::milliseconds duration);
 
     /**
      * Returns the direction of the timeline.
      *
      * @returns Direction of the timeline(TimeLine::Forward or TimeLine::Backward)
      * @see setDirection
      * @see toggleDirection
      * @since 5.14
      */
     Direction direction() const;
 
     /**
      * Sets the direction of the timeline.
      *
      * @param direction The new direction of the timeline
      * @see direction
      * @see toggleDirection
      * @since 5.14
      */
     void setDirection(Direction direction);
 
     /**
      * Toggles the direction of the timeline.
      *
      * If the direction of the timeline was TimeLine::Forward, it becomes
      * TimeLine::Backward, and vice verca.
      *
      * @see direction
      * @see setDirection
      * @since 5.14
      */
     void toggleDirection();
 
     /**
      * Returns the easing curve of the timeline.
      *
      * @see setEasingCurve
      * @since 5.14
      */
     QEasingCurve easingCurve() const;
 
     /**
      * Sets new easing curve.
      *
      * @param easingCurve An easing curve to be set
      * @see easingCurve
      * @since 5.14
      */
     void setEasingCurve(const QEasingCurve &easingCurve);
 
     /**
      * Sets new easing curve by providing its type.
      *
      * @param type Type of the easing curve(e.g. QEasingCurve::InCubic, etc)
      * @see easingCurve
      * @since 5.14
      */
     void setEasingCurve(QEasingCurve::Type type);
 
     /**
      * Returns whether the timeline is currently in progress.
      *
      * @see done
      * @since 5.14
      */
     bool running() const;
 
     /**
      * Returns whether the timeline is finished.
      *
      * @see reset
      * @since 5.14
      */
     bool done() const;
 
     /**
      * Resets the timeline to initial state.
      *
      * @since 5.14
      */
     void reset();
 
     enum class RedirectMode {
         Strict,
         Relaxed
     };
 
     /**
      * Returns the redirect mode for the source position.
      *
      * The redirect mode controls behavior of the timeline when its direction is
      * changed at the source position, e.g. what should we do when the timeline
      * initially goes forward and we change its direction to go backward.
      *
      * In the strict mode, the timeline will stop.
      *
      * In the relaxed mode, the timeline will go in the new direction. For example,
      * if the timeline goes forward(from 0 to 1), then with the new direction it
      * will go backward(from 1 to 0).
      *
      * The default is RedirectMode::Relaxed.
      *
      * @see targetRedirectMode
      * @since 5.15
      */
     RedirectMode sourceRedirectMode() const;
 
     /**
      * Sets the redirect mode for the source position.
      *
      * @param mode The new mode.
      * @since 5.15
      */
     void setSourceRedirectMode(RedirectMode mode);
 
     /**
      * Returns the redirect mode for the target position.
      *
      * The redirect mode controls behavior of the timeline when its direction is
      * changed at the target position.
      *
      * In the strict mode, subsequent update calls won't have any effect on the
      * current value of the timeline.
      *
      * In the relaxed mode, the timeline will go in the new direction.
      *
      * The default is RedirectMode::Strict.
      *
      * @see sourceRedirectMode
      * @since 5.15
      */
     RedirectMode targetRedirectMode() const;
 
     /**
      * Sets the redirect mode for the target position.
      *
      * @param mode The new mode.
      * @since 5.15
      */
     void setTargetRedirectMode(RedirectMode mode);
 
     TimeLine &operator=(const TimeLine &other);
 
     /**
      * @returns a value between 0 and 1 defining the progress of the timeline
      *
      * @since 5.23
      */
     qreal progress() const;
 
 private:
     class Data;
     QSharedDataPointer<Data> d;
 };
 
 } // namespace KWin