#include "gdkframeclockidle.h"
#include "gdk.h"
+#ifdef G_OS_WIN32
+#include <windows.h>
+#endif
+
#define FRAME_INTERVAL 16667 // microseconds
struct _GdkFrameClockIdlePrivate
guint flush_idle_id;
guint paint_idle_id;
guint freeze_count;
+ guint updating_count;
GdkFrameClockPhase requested;
GdkFrameClockPhase phase;
guint in_paint_idle : 1;
+#ifdef G_OS_WIN32
+ guint begin_period : 1;
+#endif
};
static gboolean gdk_frame_clock_flush_idle (void *data);
static gboolean gdk_frame_clock_paint_idle (void *data);
-static void gdk_frame_clock_idle_finalize (GObject *object);
-
G_DEFINE_TYPE (GdkFrameClockIdle, gdk_frame_clock_idle, GDK_TYPE_FRAME_CLOCK)
static gint64 sleep_serial;
static gint64 sleep_source_prepare_time;
static GSource *sleep_source;
-gboolean
+static gboolean
sleep_source_prepare (GSource *source,
gint *timeout)
{
return FALSE;
}
-gboolean
+static gboolean
sleep_source_check (GSource *source)
{
if (g_source_get_time (source) != sleep_source_prepare_time)
return FALSE;
}
-gboolean
+static gboolean
sleep_source_dispatch (GSource *source,
GSourceFunc callback,
gpointer user_data)
GdkFrameClockIdlePrivate);
priv = frame_clock_idle->priv;
- priv->timer = g_timer_new ();
priv->freeze_count = 0;
}
static void
-gdk_frame_clock_idle_finalize (GObject *object)
+gdk_frame_clock_idle_dispose (GObject *object)
{
GdkFrameClockIdlePrivate *priv = GDK_FRAME_CLOCK_IDLE (object)->priv;
- g_timer_destroy (priv->timer);
+ if (priv->flush_idle_id != 0)
+ {
+ g_source_remove (priv->flush_idle_id);
+ priv->flush_idle_id = 0;
+ }
+
+ if (priv->paint_idle_id != 0)
+ {
+ g_source_remove (priv->paint_idle_id);
+ priv->paint_idle_id = 0;
+ }
- G_OBJECT_CLASS (gdk_frame_clock_idle_parent_class)->finalize (object);
+#ifdef G_OS_WIN32
+ if (priv->begin_period)
+ {
+ timeEndPeriod(1);
+ priv->begin_period = FALSE;
+ }
+#endif
+
+ G_OBJECT_CLASS (gdk_frame_clock_idle_parent_class)->dispose (object);
}
static gint64
return priv->frame_time;
}
+#define RUN_FLUSH_IDLE(priv) \
+ ((priv)->freeze_count == 0 && \
+ ((priv)->requested & GDK_FRAME_CLOCK_PHASE_FLUSH_EVENTS) != 0)
+
+/* The reason why we track updating_count separately here and don't
+ * just add GDK_FRAME_CLOCK_PHASE_UPDATE into ->request on every frame
+ * is so that we can avoid doing one more frame when an animation
+ * is cancelled.
+ */
+#define RUN_PAINT_IDLE(priv) \
+ ((priv)->freeze_count == 0 && \
+ (((priv)->requested & ~GDK_FRAME_CLOCK_PHASE_FLUSH_EVENTS) != 0 || \
+ (priv)->updating_count > 0))
+
static void
maybe_start_idle (GdkFrameClockIdle *clock_idle)
{
GdkFrameClockIdlePrivate *priv = clock_idle->priv;
- if (priv->freeze_count == 0 && priv->requested != 0)
+ if (RUN_FLUSH_IDLE (priv) || RUN_PAINT_IDLE (priv))
{
guint min_interval = 0;
min_interval = (min_interval_us + 500) / 1000;
}
- if (priv->flush_idle_id == 0 &&
- (priv->requested & GDK_FRAME_CLOCK_PHASE_FLUSH_EVENTS) != 0)
+ if (priv->flush_idle_id == 0 && RUN_FLUSH_IDLE (priv))
{
priv->flush_idle_id = gdk_threads_add_timeout_full (GDK_PRIORITY_EVENTS + 1,
min_interval,
(GDestroyNotify) g_object_unref);
}
- if (priv->paint_idle_id == 0 &&
- !priv->in_paint_idle &&
- (priv->requested & ~GDK_FRAME_CLOCK_PHASE_FLUSH_EVENTS) != 0)
+ if (priv->paint_idle_id == 0 && RUN_PAINT_IDLE (priv))
{
priv->paint_idle_id = gdk_threads_add_timeout_full (GDK_PRIORITY_REDRAW,
min_interval,
}
}
+static void
+maybe_stop_idle (GdkFrameClockIdle *clock_idle)
+{
+ GdkFrameClockIdlePrivate *priv = clock_idle->priv;
+
+ if (priv->flush_idle_id != 0 && !RUN_FLUSH_IDLE (priv))
+ {
+ g_source_remove (priv->flush_idle_id);
+ priv->flush_idle_id = 0;
+ }
+
+ if (priv->paint_idle_id != 0 && !RUN_PAINT_IDLE (priv))
+ {
+ g_source_remove (priv->paint_idle_id);
+ priv->paint_idle_id = 0;
+ }
+}
+
static gint64
compute_min_next_frame_time (GdkFrameClockIdle *clock_idle,
gint64 last_frame_time)
g_signal_emit_by_name (G_OBJECT (clock), "flush-events");
- if ((priv->requested & ~GDK_FRAME_CLOCK_PHASE_FLUSH_EVENTS) != 0)
+ if ((priv->requested & ~GDK_FRAME_CLOCK_PHASE_FLUSH_EVENTS) != 0 ||
+ priv->updating_count > 0)
priv->phase = GDK_FRAME_CLOCK_PHASE_BEFORE_PAINT;
else
priv->phase = GDK_FRAME_CLOCK_PHASE_NONE;
priv->min_next_frame_time = 0;
skip_to_resume_events =
- (priv->requested & ~(GDK_FRAME_CLOCK_PHASE_FLUSH_EVENTS | GDK_FRAME_CLOCK_PHASE_RESUME_EVENTS)) == 0;
+ (priv->requested & ~(GDK_FRAME_CLOCK_PHASE_FLUSH_EVENTS | GDK_FRAME_CLOCK_PHASE_RESUME_EVENTS)) == 0 &&
+ priv->updating_count == 0;
if (priv->phase > GDK_FRAME_CLOCK_PHASE_BEFORE_PAINT)
{
case GDK_FRAME_CLOCK_PHASE_UPDATE:
if (priv->freeze_count == 0)
{
- if (priv->requested & GDK_FRAME_CLOCK_PHASE_UPDATE)
+ if ((priv->requested & GDK_FRAME_CLOCK_PHASE_UPDATE) != 0 ||
+ priv->updating_count > 0)
{
priv->requested &= ~GDK_FRAME_CLOCK_PHASE_UPDATE;
g_signal_emit_by_name (G_OBJECT (clock), "update");
}
static void
-gdk_frame_clock_idle_freeze (GdkFrameClock *clock)
+gdk_frame_clock_idle_begin_updating (GdkFrameClock *clock)
{
- GdkFrameClockIdlePrivate *priv = GDK_FRAME_CLOCK_IDLE (clock)->priv;
+ GdkFrameClockIdle *clock_idle = GDK_FRAME_CLOCK_IDLE (clock);
+ GdkFrameClockIdlePrivate *priv = clock_idle->priv;
- priv->freeze_count++;
+#ifdef G_OS_WIN32
+ /* We need a higher resolution timer while doing animations */
+ if (priv->updating_count == 0 && !priv->begin_period)
+ {
+ timeBeginPeriod(1);
+ priv->begin_period = TRUE;
+ }
+#endif
+
+ priv->updating_count++;
+ maybe_start_idle (clock_idle);
+}
+
+static void
+gdk_frame_clock_idle_end_updating (GdkFrameClock *clock)
+{
+ GdkFrameClockIdle *clock_idle = GDK_FRAME_CLOCK_IDLE (clock);
+ GdkFrameClockIdlePrivate *priv = clock_idle->priv;
+
+ g_return_if_fail (priv->updating_count > 0);
+
+ priv->updating_count--;
+ maybe_stop_idle (clock_idle);
- if (priv->freeze_count == 1)
+#ifdef G_OS_WIN32
+ if (priv->updating_count == 0 && priv->begin_period)
{
- if (priv->flush_idle_id)
- {
- g_source_remove (priv->flush_idle_id);
- priv->flush_idle_id = 0;
- }
- if (priv->paint_idle_id)
- {
- g_source_remove (priv->paint_idle_id);
- priv->paint_idle_id = 0;
- }
+ timeEndPeriod(1);
+ priv->begin_period = FALSE;
}
+#endif
+}
+
+static void
+gdk_frame_clock_idle_freeze (GdkFrameClock *clock)
+{
+ GdkFrameClockIdle *clock_idle = GDK_FRAME_CLOCK_IDLE (clock);
+ GdkFrameClockIdlePrivate *priv = clock_idle->priv;
+
+ priv->freeze_count++;
+ maybe_stop_idle (clock_idle);
}
static void
GObjectClass *gobject_class = (GObjectClass*) klass;
GdkFrameClockClass *frame_clock_class = (GdkFrameClockClass *)klass;
- gobject_class->finalize = gdk_frame_clock_idle_finalize;
+ gobject_class->dispose = gdk_frame_clock_idle_dispose;
frame_clock_class->get_frame_time = gdk_frame_clock_idle_get_frame_time;
frame_clock_class->request_phase = gdk_frame_clock_idle_request_phase;
+ frame_clock_class->begin_updating = gdk_frame_clock_idle_begin_updating;
+ frame_clock_class->end_updating = gdk_frame_clock_idle_end_updating;
frame_clock_class->freeze = gdk_frame_clock_idle_freeze;
frame_clock_class->thaw = gdk_frame_clock_idle_thaw;