enum {
PROP_0,
- PROP_CURSOR,
- PROP_FRAME_CLOCK
+ PROP_CURSOR
};
typedef enum {
static void _gdk_window_propagate_has_alpha_background (GdkWindow *window);
static cairo_surface_t *gdk_window_ref_impl_surface (GdkWindow *window);
-static void gdk_window_process_all_updates_internal (gboolean default_clock_only);
-
-static void gdk_ensure_default_frame_clock (void);
+static void gdk_window_set_frame_clock (GdkWindow *window,
+ GdkFrameClock *clock);
static guint signals[LAST_SIGNAL] = { 0 };
GDK_TYPE_CURSOR,
G_PARAM_READWRITE));
- /**
- * GdkWindow:paint-clock:
- *
- * The frame clock for a #GdkWindow, see #GdkFrameClock
- *
- * The frame clock remains the same for the lifetime of the window.
- *
- * Since: 3.0
- */
- g_object_class_install_property (object_class,
- PROP_FRAME_CLOCK,
- g_param_spec_object ("paint-clock",
- P_("Frame clock"),
- P_("Frame clock"),
- GDK_TYPE_FRAME_CLOCK,
- G_PARAM_READWRITE));
-
/**
* GdkWindow::pick-embedded-child:
* @window: the window on which the signal is emitted
gdk_window_set_cursor (window, g_value_get_object (value));
break;
- case PROP_FRAME_CLOCK:
- gdk_window_set_frame_clock (window, g_value_get_object (value));
- break;
-
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
g_value_set_object (value, gdk_window_get_cursor (window));
break;
- case PROP_FRAME_CLOCK:
- g_value_set_object (value, gdk_window_get_frame_clock (window));
- break;
-
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
if (window->parent)
window->parent->children = g_list_prepend (window->parent->children, window);
+ if (window->parent->window_type == GDK_WINDOW_ROOT)
+ {
+ GdkFrameClock *frame_clock = g_object_new (GDK_TYPE_FRAME_CLOCK_IDLE, NULL);
+ gdk_window_set_frame_clock (window, frame_clock);
+ }
+
native = FALSE;
if (window->parent->window_type == GDK_WINDOW_ROOT)
native = TRUE; /* Always use native windows for toplevels */
}
}
+ /* If we changed the window type, we might have to set or
+ * unset the frame clock on the window
+ */
+ if (GDK_WINDOW_TYPE (new_parent) == GDK_WINDOW_ROOT &&
+ GDK_WINDOW_TYPE (window) != GDK_WINDOW_FOREIGN)
+ {
+ if (window->frame_clock == NULL)
+ {
+ GdkFrameClock *frame_clock = g_object_new (GDK_TYPE_FRAME_CLOCK_IDLE, NULL);
+ gdk_window_set_frame_clock (window, frame_clock);
+ }
+ }
+ else
+ {
+ if (window->frame_clock != NULL)
+ {
+ g_object_run_dispose (G_OBJECT (window->frame_clock));
+ gdk_window_set_frame_clock (window, NULL);
+ }
+ }
+
/* We might have changed window type for a native windows, so we
need to change the event mask too. */
if (gdk_window_has_impl (window))
}
}
+ if (window->frame_clock)
+ {
+ g_object_run_dispose (G_OBJECT (window->frame_clock));
+ gdk_window_set_frame_clock (window, NULL);
+ }
+
gdk_window_free_paint_stack (window);
if (window->background)
/* Code for dirty-region queueing
*/
static GSList *update_windows = NULL;
-static GdkFrameClock *_gdk_default_frame_clock = NULL;
static gboolean debug_updates = FALSE;
static inline gboolean
update_windows = g_slist_remove (update_windows, window);
}
-static void
-gdk_window_paint_default_clock_updates (gpointer data)
-{
- gdk_window_process_all_updates_internal (TRUE);
-}
-
-static void
-gdk_ensure_default_frame_clock (void)
-{
- if (_gdk_default_frame_clock == NULL)
- {
- _gdk_default_frame_clock = g_object_new (GDK_TYPE_FRAME_CLOCK_IDLE,
- NULL);
-
- g_signal_connect (G_OBJECT (_gdk_default_frame_clock),
- "paint",
- G_CALLBACK (gdk_window_paint_default_clock_updates),
- NULL);
- }
-}
-
static gboolean
gdk_window_is_toplevel_frozen (GdkWindow *window)
{
static void
gdk_window_schedule_update (GdkWindow *window)
{
+ GdkFrameClock *frame_clock;
+
if (window &&
(window->update_freeze_count ||
gdk_window_is_toplevel_frozen (window)))
return;
- gdk_frame_clock_request_phase (gdk_window_get_frame_clock (window),
- GDK_FRAME_CLOCK_PHASE_PAINT);
+ /* If there's no frame clock (a foreign window), then the invalid
+ * region will just stick around unless gdk_window_process_updates()
+ * is called. */
+ frame_clock = gdk_window_get_frame_clock (window);
+ if (frame_clock)
+ gdk_frame_clock_request_phase (gdk_window_get_frame_clock (window),
+ GDK_FRAME_CLOCK_PHASE_PAINT);
}
void
g_slist_free (displays);
}
-/**
- * gdk_window_process_all_updates:
- *
- * Calls gdk_window_process_updates() for all windows (see #GdkWindow)
- * in the application.
- *
- **/
-void
-gdk_window_process_all_updates (void)
-{
- gdk_window_process_all_updates_internal (FALSE);
-}
-
/* Currently it is not possible to override
* gdk_window_process_all_updates in the same manner as
* gdk_window_process_updates and gdk_window_invalidate_maybe_recurse
* displays and call the mehod.
*/
-static void
-gdk_window_process_all_updates_internal (gboolean default_clock_only)
+/**
+ * gdk_window_process_all_updates:
+ *
+ * Calls gdk_window_process_updates() for all windows (see #GdkWindow)
+ * in the application.
+ *
+ **/
+void
+gdk_window_process_all_updates (void)
{
GSList *old_update_windows = update_windows;
GSList *tmp_list = update_windows;
if (!GDK_WINDOW_DESTROYED (window))
{
if (window->update_freeze_count ||
- gdk_window_is_toplevel_frozen (window) ||
- (default_clock_only && window->frame_clock != NULL))
+ gdk_window_is_toplevel_frozen (window))
gdk_window_add_update_window (window);
else
gdk_window_process_updates_internal (window);
g_return_if_fail (window->window_type != GDK_WINDOW_CHILD);
window->update_and_descendants_freeze_count++;
+ _gdk_frame_clock_freeze (gdk_window_get_frame_clock (window));
}
/**
g_return_if_fail (window->update_and_descendants_freeze_count > 0);
window->update_and_descendants_freeze_count--;
+ _gdk_frame_clock_thaw (gdk_window_get_frame_clock (window));
gdk_window_schedule_update (window);
}
{
GdkWindow *event_window;
gdouble x, y;
- gboolean unlink_event;
+ gboolean unlink_event = FALSE;
GdkDeviceGrabInfo *button_release_grab;
GdkPointerWindowInfo *pointer_info = NULL;
GdkDevice *device, *source_device;
event_window = event->any.window;
if (!event_window)
- return;
+ goto out;
#ifdef DEBUG_WINDOW_PRINTING
if (event->type == GDK_KEY_PRESS &&
{
event_window->native_visibility = event->visibility.state;
gdk_window_update_visibility_recursively (event_window, event_window);
- return;
+ goto out;
}
if (!(is_button_type (event->type) ||
is_motion_type (event->type)) ||
event_window->window_type == GDK_WINDOW_ROOT)
- return;
+ goto out;
is_toplevel = gdk_window_is_toplevel (event_window);
_gdk_display_enable_motion_hints (display, device);
}
- unlink_event = FALSE;
if (is_motion_type (event->type))
unlink_event = proxy_pointer_event (display, event, serial);
else if (is_button_type (event->type))
g_list_free_1 (event_link);
gdk_event_free (event);
}
+
+ /* This does two things - first it sees if there are motions at the
+ * end of the queue that can be compressed. Second, if there is just
+ * a single motion that won't be dispatched because it is a compression
+ * candidate it queues up flushing the event queue.
+ */
+ _gdk_event_queue_handle_motion_compression (display);
}
/**
* gdk_window_enable_synchronized_configure:
* @window: a toplevel #GdkWindow
*
- * Indicates that the application will cooperate with the window
- * system in synchronizing the window repaint with the window
- * manager during resizing operations. After an application calls
- * this function, it must call gdk_window_configure_finished() every
- * time it has finished all processing associated with a set of
- * Configure events. Toplevel GTK+ windows automatically use this
- * protocol.
- *
- * On X, calling this function makes @window participate in the
- * _NET_WM_SYNC_REQUEST window manager protocol.
+ * Does nothing, present only for compatiblity.
*
* Since: 2.6
+ * Deprecated: 3.8: this function is no longer needed
**/
void
gdk_window_enable_synchronized_configure (GdkWindow *window)
{
- GDK_WINDOW_IMPL_GET_CLASS (window->impl)->enable_synchronized_configure (window);
}
/**
* gdk_window_configure_finished:
* @window: a toplevel #GdkWindow
- *
- * Signal to the window system that the application has finished
- * handling Configure events it has received. Window Managers can
- * use this to better synchronize the frame repaint with the
- * application. GTK+ applications will automatically call this
- * function when appropriate.
*
- * This function can only be called if gdk_window_enable_synchronized_configure()
- * was called previously.
+ * Does nothing, present only for compatiblity.
*
* Since: 2.6
+ * Deprecated: 3.8: this function is no longer needed
**/
void
gdk_window_configure_finished (GdkWindow *window)
{
- GDK_WINDOW_IMPL_GET_CLASS (window->impl)->configure_finished (window);
}
/**
GDK_WINDOW_IMPL_GET_CLASS (window->impl)->delete_property (window, property);
}
+static void
+gdk_window_flush_events (GdkFrameClock *clock,
+ void *data)
+{
+ GdkWindow *window;
+ GdkDisplay *display;
+
+ window = GDK_WINDOW (data);
+
+ display = gdk_window_get_display (window);
+ _gdk_display_flush_events (display);
+ _gdk_display_pause_events (display);
+
+ gdk_frame_clock_request_phase (clock, GDK_FRAME_CLOCK_PHASE_RESUME_EVENTS);
+}
+
static void
gdk_window_paint_on_clock (GdkFrameClock *clock,
void *data)
gdk_window_process_updates_with_mode (window, PROCESS_UPDATES_WITH_SAME_CLOCK_CHILDREN);
}
-/**
- * gdk_window_set_frame_clock:
- * @window: window to set frame clock on
- * @clock: the clock
- *
- * Sets the frame clock for the window. The frame clock for a window
- * cannot be changed while the window is mapped. Set the frame
- * clock to #NULL to use the default frame clock. (By default the
- * frame clock comes from the window's parent or is a global default
- * frame clock.)
- *
- * Since: 3.0
- */
-void
+static void
+gdk_window_resume_events (GdkFrameClock *clock,
+ void *data)
+{
+ GdkWindow *window;
+ GdkDisplay *display;
+
+ window = GDK_WINDOW (data);
+
+ display = gdk_window_get_display (window);
+ _gdk_display_unpause_events (display);
+}
+
+static void
gdk_window_set_frame_clock (GdkWindow *window,
GdkFrameClock *clock)
{
g_return_if_fail (GDK_IS_WINDOW (window));
g_return_if_fail (clock == NULL || GDK_IS_FRAME_CLOCK (clock));
- g_return_if_fail (!GDK_WINDOW_IS_MAPPED (window));
+ g_return_if_fail (clock == NULL || gdk_window_is_toplevel (window));
if (clock == window->frame_clock)
return;
- /* If we are using our parent's clock, then the parent will repaint
- * us when that clock fires. If we are using the default clock, then
- * it does a gdk_window_process_all_updates() which will repaint us
- * when the clock fires. If we are using our own clock, then we have
- * to connect to "paint" on it ourselves and paint ourselves and
- * any child windows.
- */
-
if (clock)
{
g_object_ref (clock);
+ g_signal_connect (G_OBJECT (clock),
+ "flush-events",
+ G_CALLBACK (gdk_window_flush_events),
+ window);
g_signal_connect (G_OBJECT (clock),
"paint",
G_CALLBACK (gdk_window_paint_on_clock),
window);
+ g_signal_connect (G_OBJECT (clock),
+ "resume-events",
+ G_CALLBACK (gdk_window_resume_events),
+ window);
}
if (window->frame_clock)
{
+ g_signal_handlers_disconnect_by_func (G_OBJECT (window->frame_clock),
+ G_CALLBACK (gdk_window_flush_events),
+ window);
g_signal_handlers_disconnect_by_func (G_OBJECT (window->frame_clock),
G_CALLBACK (gdk_window_paint_on_clock),
window);
+ g_signal_handlers_disconnect_by_func (G_OBJECT (window->frame_clock),
+ G_CALLBACK (gdk_window_resume_events),
+ window);
g_object_unref (window->frame_clock);
}
window->frame_clock = clock;
- g_object_notify (G_OBJECT (window), "paint-clock");
-
- /* We probably should recurse child windows and emit notify on their
- * paint-clock properties also, and we should emit notify when a
- * window is first parented.
- */
}
/**
* @window: window to get frame clock for
*
* Gets the frame clock for the window. The frame clock for a window
- * never changes while the window is mapped. It may be changed at
- * other times.
+ * never changes unless the window is reparented to a new toplevel
+ * window.
*
- * Since: 3.0
+ * Since: 3.8
* Return value: (transfer none): the frame clock
*/
GdkFrameClock*
gdk_window_get_frame_clock (GdkWindow *window)
{
+ GdkWindow *toplevel;
+
g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
- if (window->frame_clock != NULL)
- {
- /* Frame clock set explicitly on this window */
- return window->frame_clock;
- }
- else
- {
- GdkWindow *parent;
+ toplevel = gdk_window_get_toplevel (window);
- /* parent's frame clock or default */
- parent = gdk_window_get_effective_parent (window);
- if (parent != NULL)
- {
- return gdk_window_get_frame_clock (parent);
- }
- else
- {
- gdk_ensure_default_frame_clock ();
- return _gdk_default_frame_clock;
- }
- }
+ return toplevel->frame_clock;
}
projects / ~andy / gtk / blobdiff