X-Git-Url: http://pileus.org/git/?a=blobdiff_plain;f=gdk%2Fgdkwindow.c;h=410eb165f6379277bbf40911f4993022b34c4d48;hb=bf7804db643f7832b72efbcd98bec1689fa4f047;hp=e3b5026c8321aedcc8c4330694ae8a63242364ac;hpb=c4545cc5d47364b66b7ecd7bb482210fb8c8655a;p=~andy%2Fgtk

diff --git a/gdk/gdkwindow.c b/gdk/gdkwindow.c
index e3b5026c8..410eb165f 100644
--- a/gdk/gdkwindow.c
+++ b/gdk/gdkwindow.c
@@ -170,8 +170,7 @@ enum {
 
 enum {
   PROP_0,
-  PROP_CURSOR,
-  PROP_FRAME_CLOCK
+  PROP_CURSOR
 };
 
 typedef enum {
@@ -240,9 +239,8 @@ static void gdk_window_invalidate_rect_full (GdkWindow          *window,
 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 };
 
@@ -394,23 +392,6 @@ gdk_window_class_init (GdkWindowClass *klass)
                                                         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
@@ -623,10 +604,6 @@ gdk_window_set_property (GObject      *object,
       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;
@@ -647,10 +624,6 @@ gdk_window_get_property (GObject    *object,
       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;
@@ -1496,6 +1469,12 @@ gdk_window_new (GdkWindow     *parent,
   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 */
@@ -1746,6 +1725,27 @@ gdk_window_reparent (GdkWindow *window,
 	}
     }
 
+  /* 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))
@@ -2065,6 +2065,12 @@ _gdk_window_destroy_hierarchy (GdkWindow *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)
@@ -3809,7 +3815,6 @@ gdk_cairo_create (GdkWindow *window)
 /* 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
@@ -3908,27 +3913,6 @@ gdk_window_remove_update_window (GdkWindow *window)
   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)
 {
@@ -3942,13 +3926,20 @@ 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
@@ -4261,19 +4252,6 @@ after_process_all_updates (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
@@ -4284,8 +4262,15 @@ gdk_window_process_all_updates (void)
  * 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;
@@ -4316,8 +4301,7 @@ gdk_window_process_all_updates_internal (gboolean default_clock_only)
       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);
@@ -4919,6 +4903,7 @@ gdk_window_freeze_toplevel_updates_libgtk_only (GdkWindow *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));
 }
 
 /**
@@ -4939,6 +4924,7 @@ gdk_window_thaw_toplevel_updates_libgtk_only (GdkWindow *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);
 }
@@ -10036,7 +10022,7 @@ _gdk_windowing_got_event (GdkDisplay *display,
 {
   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;
@@ -10079,7 +10065,7 @@ _gdk_windowing_got_event (GdkDisplay *display,
 
   event_window = event->any.window;
   if (!event_window)
-    return;
+    goto out;
 
 #ifdef DEBUG_WINDOW_PRINTING
   if (event->type == GDK_KEY_PRESS &&
@@ -10094,13 +10080,13 @@ _gdk_windowing_got_event (GdkDisplay *display,
     {
       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);
 
@@ -10193,7 +10179,6 @@ _gdk_windowing_got_event (GdkDisplay *display,
         _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))
@@ -10235,6 +10220,13 @@ _gdk_windowing_got_event (GdkDisplay *display,
       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);
 }
 
 /**
@@ -11207,44 +11199,28 @@ gdk_window_begin_move_drag (GdkWindow *window,
  * 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);
 }
 
 /**
@@ -11601,6 +11577,22 @@ gdk_property_delete (GdkWindow *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)
@@ -11614,62 +11606,62 @@ gdk_window_paint_on_clock (GdkFrameClock *clock,
   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.
-   */
 }
 
 /**
@@ -11677,36 +11669,20 @@ gdk_window_set_frame_clock (GdkWindow     *window,
  * @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;
 }