:right-sidebar: True

FrameClock
===================================================================

.. currentmodule:: gi.repository.Gdk





.. class:: FrameClock(**properties: ~typing.Any)
   :no-contents-entry:


Superclasses: :class:`~gi.repository.GObject.Object`





:Constructors:

::

    FrameClock(**properties)





Methods
-------

.. rst-class:: interim-class

.. class:: FrameClock
   :no-index:


   .. method:: begin_updating() -> None

      Starts updates for an animation.

      Until a matching call to :obj:`~gi.repository.Gdk.FrameClock.end_updating` is made,
      the frame clock will continually request a new frame with the
      :const:`~gi.repository.Gdk.FrameClockPhase.UPDATE` phase. This function may be called multiple
      times and frames will be requested until :func:`~gi.repository.Gdk.FrameClock.end_updating`
      is called the same number of times.










   .. method:: end_updating() -> None

      Stops updates for an animation.

      See the documentation for :obj:`~gi.repository.Gdk.FrameClock.begin_updating`.










   .. method:: get_current_timings() -> ~gi.repository.Gdk.FrameTimings | None

      Gets the frame timings for the current frame.










   .. method:: get_fps() -> float

      Calculates the current frames-per-second, based on the
      frame timings of ``frame_clock``.










   .. method:: get_frame_counter() -> int

      ``GdkFrameClock`` maintains a 64-bit counter that increments for
      each frame drawn.










   .. method:: get_frame_time() -> int

      Gets the time that should currently be used for animations.

      Inside the processing of a frame, it’s the time used to compute the
      animation position of everything in a frame. Outside of a frame, it's
      the time of the conceptual “previous frame,” which may be either
      the actual previous frame time, or if that’s too old, an updated
      time.










   .. method:: get_history_start() -> int

      Returns the frame counter for the oldest frame available in history.

      ``GdkFrameClock`` internally keeps a history of ``GdkFrameTimings``
      objects for recent frames that can be retrieved with
      :obj:`~gi.repository.Gdk.FrameClock.get_timings`. The set of stored frames
      is the set from the counter values given by
      :obj:`~gi.repository.Gdk.FrameClock.get_history_start` and
      :obj:`~gi.repository.Gdk.FrameClock.get_frame_counter`, inclusive.










   .. method:: get_refresh_info(base_time: int) -> tuple[int, int]

      Predicts a presentation time, based on history.

      Using the frame history stored in the frame clock, finds the last
      known presentation time and refresh interval, and assuming that
      presentation times are separated by the refresh interval,
      predicts a presentation time that is a multiple of the refresh
      interval after the last presentation time, and later than ``base_time``.







      :param base_time: base time for determining a presentaton time





   .. method:: get_timings(frame_counter: int) -> ~gi.repository.Gdk.FrameTimings | None

      Retrieves a ``GdkFrameTimings`` object holding timing information
      for the current frame or a recent frame.

      The ``GdkFrameTimings`` object may not yet be complete: see
      :obj:`~gi.repository.Gdk.FrameTimings.get_complete` and
      :obj:`~gi.repository.Gdk.FrameClock.get_history_start`.







      :param frame_counter: the frame counter value identifying the frame to
         be received





   .. method:: request_phase(phase: ~gi.repository.Gdk.FrameClockPhase) -> None

      Asks the frame clock to run a particular phase.

      The signal corresponding the requested phase will be emitted the next
      time the frame clock processes. Multiple calls to
      :func:`~gi.repository.Gdk.FrameClock.request_phase` will be combined together
      and only one frame processed. If you are displaying animated
      content and want to continually request the
      :const:`~gi.repository.Gdk.FrameClockPhase.UPDATE` phase for a period of time,
      you should use :obj:`~gi.repository.Gdk.FrameClock.begin_updating` instead,
      since this allows GTK to adjust system parameters to get maximally
      smooth animations.







      :param phase: the phase that is requested











Signals
-------

.. rst-class:: interim-class

.. class:: FrameClock.signals
   :no-index:
   

   .. method:: after_paint() -> None

      This signal ends processing of the frame.

      Applications should generally not handle this signal.










   .. method:: before_paint() -> None

      Begins processing of the frame.

      Applications should generally not handle this signal.










   .. method:: flush_events() -> None

      Used to flush pending motion events that are being batched up and
      compressed together.

      Applications should not handle this signal.










   .. method:: layout() -> None

      Emitted as the second step of toolkit and application processing
      of the frame.

      Any work to update sizes and positions of application elements
      should be performed. GTK normally handles this internally.










   .. method:: paint() -> None

      Emitted as the third step of toolkit and application processing
      of the frame.

      The frame is repainted. GDK normally handles this internally and
      emits :obj:`~gi.repository.Gdk.Surface.signals.render` signals which are turned into
      `GtkWidget::snapshot <../gtk4/signal.Widget.snapshot.html>`_ signals
      by GTK.










   .. method:: resume_events() -> None

      Emitted after processing of the frame is finished.

      This signal is handled internally by GTK to resume normal
      event processing. Applications should not handle this signal.










   .. method:: update() -> None

      Emitted as the first step of toolkit and application processing
      of the frame.

      Animations should be updated using :obj:`~gi.repository.Gdk.FrameClock.get_frame_time`.
      Applications can connect directly to this signal, or use
      `gtk_widget_add_tick_callback() <../gtk4/method.Widget.add_tick_callback.html>`_
      as a more convenient interface.