GNOME.org
 

[gnome-panel/gtk3] Move widgets to get_preferred_width/height() API instead of size_request()

commit beec7ccc7f7448f2a30da3be9a3bb86a5d59eab0
Author: Milan Bouchet-Valat <nalimilan club fr>
Date:   Wed Dec 29 19:38:39 2010 +0100

    Move widgets to get_preferred_width/height() API instead of size_request()
    
    This is how current GTK+3 handles size requisitions. Most of the time,
    it simply means splitting the function between height and width. When
    possible, we ask children for minimal and natural sizes, but when it's
    too complex, we just set minimal_size = natural_size.
    
    This raises GTK+ 3 requirement to 2.91.7.
    
    https://bugzilla.gnome.org/show_bug.cgi?id=627455

 applets/clock/clock-face.c          |   86 ++++++++++++++++++++++++-----------
 applets/clock/clock-map.c           |   36 ++++++++++-----
 applets/notification_area/na-tray.c |   23 +++++++--
 configure.ac                        |    2 +-
 gnome-panel/button-widget.c         |   34 ++++++++------
 gnome-panel/panel-applet-frame.c    |   64 ++++++++++++++++++++------
 gnome-panel/panel-frame.c           |   69 +++++++++++++++++++++-------
 gnome-panel/panel-separator.c       |   39 +++++++++++-----
 gnome-panel/panel-toplevel.c        |   30 +++++++++++-
 gnome-panel/panel-widget.c          |   80 ++++++++++++++++++++++----------
 10 files changed, 332 insertions(+), 131 deletions(-)
---
diff --git a/applets/clock/clock-face.c b/applets/clock/clock-face.c
index fb3a246..a3d10d0 100644
--- a/applets/clock/clock-face.c
+++ b/applets/clock/clock-face.c
@@ -24,12 +24,17 @@ static GHashTable *pixbuf_cache = NULL;
 
 G_DEFINE_TYPE (ClockFace, clock_face, GTK_TYPE_WIDGET)
 
-static void clock_face_finalize (GObject *);
-static gboolean clock_face_draw (GtkWidget *clock, cairo_t *cr);
-static void clock_face_size_request (GtkWidget *clock,
-				     GtkRequisition *requisition);
-static void clock_face_size_allocate (GtkWidget     *clock,
-				      GtkAllocation *allocation);
+static void     clock_face_finalize             (GObject *);
+static gboolean clock_face_draw                 (GtkWidget     *clock,
+                                                 cairo_t       *cr);
+static void     clock_face_get_preferred_width  (GtkWidget     *this,
+                                                 gint          *minimal_width,
+                                                 gint          *natural_width);
+static void     clock_face_get_preferred_height (GtkWidget     *this,
+                                                 gint          *minimal_height,
+                                                 gint          *natural_height);
+static void     clock_face_size_allocate        (GtkWidget     *clock,
+				                 GtkAllocation *allocation);
 
 static void update_time_and_face (ClockFace *this,
                                   gboolean   force_face_loading);
@@ -67,7 +72,8 @@ clock_face_class_init (ClockFaceClass *class)
 
         /* GtkWidget signals */
         widget_class->draw = clock_face_draw;
-        widget_class->size_request = clock_face_size_request;
+        widget_class->get_preferred_width  = clock_face_get_preferred_width;
+        widget_class->get_preferred_height = clock_face_get_preferred_height;
         widget_class->size_allocate = clock_face_size_allocate;
 
         /* GObject signals */
@@ -181,40 +187,68 @@ clock_face_redraw_canvas (ClockFace *this)
 }
 
 static void
-clock_face_size_request (GtkWidget *this,
-			 GtkRequisition *requisition)
+clock_face_get_preferred_width (GtkWidget *this,
+                                gint      *minimal_width,
+                                gint      *natural_width)
 {
         ClockFacePrivate *priv = CLOCK_FACE (this)->priv;
 
         if (priv->size_widget != NULL) {
-                GtkRequisition req;
+               int child_minimal_height;
+               int child_natural_height;
 
                 /* Tie our size to the height of the size_widget */
-                gtk_widget_size_request (GTK_WIDGET (priv->size_widget), &req);
+                gtk_widget_get_preferred_height (GTK_WIDGET (priv->size_widget),
+                                                 &child_minimal_height,
+                                                 &child_natural_height);
 
                 /* Pad out our height by a little bit - this improves
                    the balance */
-                requisition->width = req.height + req.height / 8;
-                requisition->height = req.height + req.height / 8;
+                *minimal_width = child_minimal_height + child_minimal_height / 8;
+                *natural_width = child_natural_height + child_natural_height / 8;
         } else if (priv->face_pixbuf != NULL) {
-                int w, h;
-
                 /* Use the size of the current pixbuf */
-                w = gdk_pixbuf_get_width (GDK_PIXBUF (priv->face_pixbuf));
-                h = gdk_pixbuf_get_height (GDK_PIXBUF (priv->face_pixbuf));
+                *minimal_width = *natural_width = gdk_pixbuf_get_width (GDK_PIXBUF (priv->face_pixbuf));
+        } else {
+                /* we don't know anything, so use known dimensions for the svg
+                 * files */
+                if (priv->size == CLOCK_FACE_LARGE)
+                        *minimal_width = *natural_width = 50;
+                else
+                        *minimal_width = *natural_width = 36;
+        }
+}
+
+static void
+clock_face_get_preferred_height (GtkWidget *this,
+                                 gint      *minimal_height,
+                                 gint      *natural_height)
+{
+        ClockFacePrivate *priv = CLOCK_FACE (this)->priv;
+
+        if (priv->size_widget != NULL) {
+               int child_minimal_height;
+               int child_natural_height;
+
+                /* Tie our size to the height of the size_widget */
+                gtk_widget_get_preferred_height (GTK_WIDGET (priv->size_widget),
+                                                 &child_minimal_height,
+                                                 &child_natural_height);
 
-                requisition->width = w;
-                requisition->height = h;
+                /* Pad out our height by a little bit - this improves
+                   the balance */
+                *minimal_height = child_minimal_height + child_minimal_height / 8;
+                *natural_height = child_natural_height + child_natural_height / 8;
+        } else if (priv->face_pixbuf != NULL) {
+                /* Use the size of the current pixbuf */
+                *minimal_height = *natural_height = gdk_pixbuf_get_height (GDK_PIXBUF (priv->face_pixbuf));
         } else {
                 /* we don't know anything, so use known dimensions for the svg
                  * files */
-                if (priv->size == CLOCK_FACE_LARGE) {
-                        requisition->width = 50;
-                        requisition->height = 50;
-                } else {
-                        requisition->width = 36;
-                        requisition->height = 36;
-                }
+                if (priv->size == CLOCK_FACE_LARGE)
+                        *minimal_height = *natural_height = 50;
+                else
+                        *minimal_height = *natural_height = 36;
         }
 }
 
diff --git a/applets/clock/clock-map.c b/applets/clock/clock-map.c
index 1d8c5a1..4ab91d8 100644
--- a/applets/clock/clock-map.c
+++ b/applets/clock/clock-map.c
@@ -55,13 +55,17 @@ typedef struct {
         GdkPixbuf *shadow_map_pixbuf;
 } ClockMapPrivate;
 
-static void clock_map_finalize (GObject *);
-static void clock_map_size_request (GtkWidget *this,
-                                        GtkRequisition *requisition);
-static void clock_map_size_allocate (GtkWidget *this,
-					 GtkAllocation *allocation);
-static gboolean clock_map_draw (GtkWidget *this,
-                                cairo_t *cr);
+static void     clock_map_finalize             (GObject *);
+static void     clock_map_get_preferred_width  (GtkWidget     *this,
+                                                gint          *minimal_width,
+                                                gint          *natural_width);
+static void     clock_map_get_preferred_height (GtkWidget     *this,
+                                                gint          *minimal_height,
+                                                gint          *natural_height);
+static void     clock_map_size_allocate        (GtkWidget     *this,
+                                                GtkAllocation *allocation);
+static gboolean clock_map_draw                 (GtkWidget     *this,
+                                                cairo_t       *cr);
 
 static void clock_map_place_locations (ClockMap *this);
 static void clock_map_render_shadow (ClockMap *this);
@@ -88,7 +92,8 @@ clock_map_class_init (ClockMapClass *this_class)
         g_obj_class->finalize = clock_map_finalize;
 
         /* GtkWidget signals */
-        widget_class->size_request = clock_map_size_request;
+        widget_class->get_preferred_width  = clock_map_get_preferred_width;
+        widget_class->get_preferred_height = clock_map_get_preferred_height;
         widget_class->size_allocate = clock_map_size_allocate;
 	widget_class->draw = clock_map_draw;
 
@@ -248,10 +253,19 @@ clock_map_draw (GtkWidget *this, cairo_t *cr)
 }
 
 static void
-clock_map_size_request (GtkWidget *this, GtkRequisition *requisition)
+clock_map_get_preferred_width (GtkWidget *this,
+                               gint      *minimal_width,
+                               gint      *natural_width)
 {
-        requisition->width = 250;
-        requisition->height = 125;
+        *minimal_width = *natural_width = 250;
+}
+
+static void
+clock_map_get_preferred_height (GtkWidget *this,
+                                gint      *minimal_height,
+                                gint      *natural_height)
+{
+        *minimal_height = *natural_height = 125;
 }
 
 static void
diff --git a/applets/notification_area/na-tray.c b/applets/notification_area/na-tray.c
index 1299f9f..945807d 100644
--- a/applets/notification_area/na-tray.c
+++ b/applets/notification_area/na-tray.c
@@ -728,10 +728,23 @@ na_tray_set_property (GObject      *object,
 }
 
 static void
-na_tray_size_request (GtkWidget        *widget,
-                      GtkRequisition   *requisition)
+na_tray_get_preferred_width (GtkWidget *widget,
+                             gint      *minimal_width,
+                             gint      *natural_width)
 {
-  gtk_widget_size_request (gtk_bin_get_child (GTK_BIN (widget)), requisition);
+  gtk_widget_get_preferred_width (gtk_bin_get_child (GTK_BIN (widget)),
+                                  minimal_width,
+                                  natural_width);
+}
+
+static void
+na_tray_get_preferred_height (GtkWidget *widget,
+                              gint      *minimal_height,
+                              gint      *natural_height)
+{
+  gtk_widget_get_preferred_height (gtk_bin_get_child (GTK_BIN (widget)),
+                                   minimal_height,
+                                   natural_height);
 }
 
 static void
@@ -750,8 +763,8 @@ na_tray_class_init (NaTrayClass *klass)
   gobject_class->constructor = na_tray_constructor;
   gobject_class->set_property = na_tray_set_property;
   gobject_class->dispose = na_tray_dispose;
-
-  widget_class->size_request = na_tray_size_request;
+  widget_class->get_preferred_width = na_tray_get_preferred_width;
+  widget_class->get_preferred_height = na_tray_get_preferred_height;
   widget_class->size_allocate = na_tray_size_allocate;
 
   g_object_class_install_property
diff --git a/configure.ac b/configure.ac
index 9907056..64c3ae4 100644
--- a/configure.ac
+++ b/configure.ac
@@ -65,7 +65,7 @@ GDK_PIXBUF_REQUIRED=2.7.1
 PANGO_REQUIRED=1.15.4
 GLIB_REQUIRED=2.25.12
 GTK2_REQUIRED=2.20.0
-GTK_REQUIRED=2.91.2
+GTK_REQUIRED=2.91.7
 LIBWNCK_REQUIRED=2.91.0
 GCONF_REQUIRED=2.6.1
 LIBGNOME_MENU_REQUIRED=2.27.92
diff --git a/gnome-panel/button-widget.c b/gnome-panel/button-widget.c
index 0bd1300..97be133 100644
--- a/gnome-panel/button-widget.c
+++ b/gnome-panel/button-widget.c
@@ -421,17 +421,22 @@ button_widget_draw (GtkWidget *widget,
 }
 
 static void
-button_widget_size_request (GtkWidget      *widget,
-			    GtkRequisition *requisition)
+button_widget_get_preferred_width(GtkWidget *widget, gint *minimal_width, gint *natural_width)
 {
 	ButtonWidget *button_widget = BUTTON_WIDGET (widget);
 
-	if (button_widget->priv->pixbuf) {
-		requisition->width  = gdk_pixbuf_get_width  (button_widget->priv->pixbuf);
-		requisition->height = gdk_pixbuf_get_height (button_widget->priv->pixbuf);
-	}
+	*minimal_width = *natural_width = gdk_pixbuf_get_width  (button_widget->priv->pixbuf);
+}
+
+static void
+button_widget_get_preferred_height(GtkWidget *widget, gint *minimal_height, gint *natural_height)
+{
+	ButtonWidget *button_widget = BUTTON_WIDGET (widget);
+
+	*minimal_height = *natural_height = gdk_pixbuf_get_height (button_widget->priv->pixbuf);
 }
 
+
 static void
 button_widget_size_allocate (GtkWidget     *widget,
 			     GtkAllocation *allocation)
@@ -557,14 +562,15 @@ button_widget_class_init (ButtonWidgetClass *klass)
 
 	g_type_class_add_private (klass, sizeof (ButtonWidgetPrivate));
 	  
-	widget_class->realize            = button_widget_realize;
-	widget_class->unrealize          = button_widget_unrealize;
-	widget_class->size_allocate      = button_widget_size_allocate;
-	widget_class->size_request       = button_widget_size_request;
-	widget_class->button_press_event = button_widget_button_press;
-	widget_class->enter_notify_event = button_widget_enter_notify;
-	widget_class->leave_notify_event = button_widget_leave_notify;
-	widget_class->draw               = button_widget_draw;
+	widget_class->realize              = button_widget_realize;
+	widget_class->unrealize            = button_widget_unrealize;
+	widget_class->size_allocate        = button_widget_size_allocate;
+	widget_class->get_preferred_width  = button_widget_get_preferred_width;
+	widget_class->get_preferred_height = button_widget_get_preferred_height;
+	widget_class->button_press_event   = button_widget_button_press;
+	widget_class->enter_notify_event   = button_widget_enter_notify;
+	widget_class->leave_notify_event   = button_widget_leave_notify;
+	widget_class->draw                 = button_widget_draw;
 
 	button_class->activate = button_widget_activate;
 
diff --git a/gnome-panel/panel-applet-frame.c b/gnome-panel/panel-applet-frame.c
index 3f3b774..511332f 100644
--- a/gnome-panel/panel-applet-frame.c
+++ b/gnome-panel/panel-applet-frame.c
@@ -154,43 +154,76 @@ panel_applet_frame_update_background_size (PanelAppletFrame *frame,
 }
 
 static void
-panel_applet_frame_size_request (GtkWidget      *widget,
-				 GtkRequisition *requisition)
+panel_applet_frame_get_preferred_width(GtkWidget *widget, gint *minimal_width, gint *natural_width)
 {
 	PanelAppletFrame *frame;
 	GtkBin           *bin;
 	GtkWidget        *child;
-	GtkRequisition    child_requisition;
 	guint             border_width;
 
 	frame = PANEL_APPLET_FRAME (widget);
 	bin = GTK_BIN (widget);
 
 	if (!frame->priv->has_handle) {
-		GTK_WIDGET_CLASS (panel_applet_frame_parent_class)->size_request (widget, requisition);
+		GTK_WIDGET_CLASS (panel_applet_frame_parent_class)->get_preferred_width (widget, minimal_width, natural_width);
 		return;
 	}
 
 	child = gtk_bin_get_child (bin);
-	if (child && gtk_widget_get_visible (child)) {
-		gtk_widget_size_request (child, &child_requisition);
-
-		requisition->width  = child_requisition.width;
-		requisition->height = child_requisition.height;
-	}
+	if (child && gtk_widget_get_visible (child))
+		gtk_widget_get_preferred_width (child, minimal_width, natural_width);
 
 	border_width = gtk_container_get_border_width (GTK_CONTAINER (widget));
-	requisition->width += border_width;
-	requisition->height += border_width;
+	*minimal_width += border_width;
+	*natural_width += border_width;
 
 	switch (frame->priv->orientation) {
 	case PANEL_ORIENTATION_TOP:
 	case PANEL_ORIENTATION_BOTTOM:
-		requisition->width += HANDLE_SIZE;
+		*minimal_width += HANDLE_SIZE;
+		*natural_width += HANDLE_SIZE;
 		break;
 	case PANEL_ORIENTATION_LEFT:
 	case PANEL_ORIENTATION_RIGHT:
-		requisition->height += HANDLE_SIZE;
+		break;
+	default:
+		g_assert_not_reached ();
+		break;
+	}
+}
+
+static void
+panel_applet_frame_get_preferred_height(GtkWidget *widget, gint *minimal_height, gint *natural_height)
+{
+	PanelAppletFrame *frame;
+	GtkBin           *bin;
+	GtkWidget        *child;
+	guint             border_width;
+
+	frame = PANEL_APPLET_FRAME (widget);
+	bin = GTK_BIN (widget);
+
+	if (!frame->priv->has_handle) {
+		GTK_WIDGET_CLASS (panel_applet_frame_parent_class)->get_preferred_height (widget, minimal_height, natural_height);
+		return;
+	}
+
+	child = gtk_bin_get_child (bin);
+	if (child && gtk_widget_get_visible (child))
+		gtk_widget_get_preferred_height (child, minimal_height, natural_height);
+
+	border_width = gtk_container_get_border_width (GTK_CONTAINER (widget));
+	*minimal_height += border_width;
+	*natural_height += border_width;
+
+	switch (frame->priv->orientation) {
+	case PANEL_ORIENTATION_LEFT:
+	case PANEL_ORIENTATION_RIGHT:
+		*minimal_height += HANDLE_SIZE;
+		*natural_height += HANDLE_SIZE;
+		break;
+	case PANEL_ORIENTATION_TOP:
+	case PANEL_ORIENTATION_BOTTOM:
 		break;
 	default:
 		g_assert_not_reached ();
@@ -393,7 +426,8 @@ panel_applet_frame_class_init (PanelAppletFrameClass *klass)
 	gobject_class->finalize = panel_applet_frame_finalize;
 
 	widget_class->draw                 = panel_applet_frame_draw;
-	widget_class->size_request         = panel_applet_frame_size_request;
+	widget_class->get_preferred_width  = panel_applet_frame_get_preferred_width;
+	widget_class->get_preferred_height = panel_applet_frame_get_preferred_height;
 	widget_class->size_allocate        = panel_applet_frame_size_allocate;
 	widget_class->button_press_event   = panel_applet_frame_button_changed;
 	widget_class->button_release_event = panel_applet_frame_button_changed;
diff --git a/gnome-panel/panel-frame.c b/gnome-panel/panel-frame.c
index 91f8077..00182a4 100644
--- a/gnome-panel/panel-frame.c
+++ b/gnome-panel/panel-frame.c
@@ -36,8 +36,7 @@ enum {
 };
 
 static void
-panel_frame_size_request (GtkWidget      *widget,
-			  GtkRequisition *requisition)
+panel_frame_get_preferred_width(GtkWidget *widget, gint *minimal_width, gint *natural_width)
 {
 	PanelFrame *frame = (PanelFrame *) widget;
 	GtkBin     *bin   = (GtkBin *) widget;
@@ -48,24 +47,57 @@ panel_frame_size_request (GtkWidget      *widget,
 	style = gtk_widget_get_style (widget);
 	border_width = gtk_container_get_border_width (GTK_CONTAINER (widget));
 
-	requisition->width = 1;
-	requisition->height = 1;
+	*minimal_width = 1;
+	*natural_width = 1;
 
 	child = gtk_bin_get_child (bin);
 	if (child && gtk_widget_get_visible (child))
-		gtk_widget_size_request (child, requisition);
+		gtk_widget_get_preferred_width (child, minimal_width, natural_width);
 
-	requisition->width  += border_width;
-	requisition->height += border_width;
+	*minimal_width += border_width;
+	*natural_width += border_width;
 
-	if (frame->edges & PANEL_EDGE_TOP)
-		requisition->height += style->xthickness;
-	if (frame->edges & PANEL_EDGE_BOTTOM)
-		requisition->height += style->xthickness;
-	if (frame->edges & PANEL_EDGE_LEFT)
-		requisition->width += style->ythickness;
-	if (frame->edges & PANEL_EDGE_RIGHT)
-		requisition->width += style->ythickness;
+	if (frame->edges & PANEL_EDGE_LEFT) {
+		*minimal_width += style->ythickness;
+		*natural_width += style->ythickness;
+	}
+	if (frame->edges & PANEL_EDGE_RIGHT) {
+		*minimal_width += style->ythickness;
+		*natural_width += style->ythickness;
+	}
+}
+
+static void
+panel_frame_get_preferred_height(GtkWidget *widget, gint *minimal_height, gint *natural_height)
+{
+	PanelFrame *frame = (PanelFrame *) widget;
+	GtkBin     *bin   = (GtkBin *) widget;
+	GtkStyle   *style;
+	GtkWidget  *child;
+	int         border_width;
+
+	style = gtk_widget_get_style (widget);
+	border_width = gtk_container_get_border_width (GTK_CONTAINER (widget));
+
+	*minimal_height = 1;
+	*natural_height = 1;
+
+	child = gtk_bin_get_child (bin);
+	if (child && gtk_widget_get_visible (child))
+		gtk_widget_get_preferred_height (child, minimal_height, natural_height);
+
+	*minimal_height += border_width;
+	*natural_height += border_width;
+
+
+	if (frame->edges & PANEL_EDGE_TOP) {
+		*minimal_height += style->xthickness;
+		*natural_height += style->xthickness;
+	}
+	if (frame->edges & PANEL_EDGE_BOTTOM) {
+		*minimal_height += style->xthickness;
+		*natural_height += style->xthickness;
+	}
 }
 
 static void
@@ -289,9 +321,10 @@ panel_frame_class_init (PanelFrameClass *klass)
 	gobject_class->set_property = panel_frame_set_property;
         gobject_class->get_property = panel_frame_get_property;
 
-	widget_class->size_request  = panel_frame_size_request;
-	widget_class->size_allocate = panel_frame_size_allocate;
-	widget_class->draw          = panel_frame_real_draw;
+	widget_class->get_preferred_width  = panel_frame_get_preferred_width;
+	widget_class->get_preferred_height = panel_frame_get_preferred_height;
+	widget_class->size_allocate        = panel_frame_size_allocate;
+	widget_class->draw                 = panel_frame_real_draw;
 
 	g_object_class_install_property (
 		gobject_class,
diff --git a/gnome-panel/panel-separator.c b/gnome-panel/panel-separator.c
index 275c519..584cdca 100644
--- a/gnome-panel/panel-separator.c
+++ b/gnome-panel/panel-separator.c
@@ -78,8 +78,7 @@ panel_separator_draw (GtkWidget *widget,
 }
 
 static void
-panel_separator_size_request (GtkWidget      *widget,
-			      GtkRequisition *requisition)
+panel_separator_get_preferred_width(GtkWidget *widget, gint *minimal_width, gint *natural_width)
 {
 	PanelSeparator *separator;
 	int             size;
@@ -88,13 +87,26 @@ panel_separator_size_request (GtkWidget      *widget,
 
 	size = panel_toplevel_get_size (separator->priv->panel->toplevel);
 
-	if (separator->priv->orientation == GTK_ORIENTATION_VERTICAL) {
-		requisition->width = size;
-		requisition->height = SEPARATOR_SIZE;
-	} else {
-		requisition->width = SEPARATOR_SIZE;
-		requisition->height = size;
-	}
+	if (separator->priv->orientation == GTK_ORIENTATION_VERTICAL)
+		*minimal_width = *natural_width = size;
+	else
+		*minimal_width = *natural_width = SEPARATOR_SIZE;
+}
+
+static void
+panel_separator_get_preferred_height(GtkWidget *widget, gint *minimal_height, gint *natural_height)
+{
+	PanelSeparator *separator;
+	int             size;
+
+	separator = PANEL_SEPARATOR (widget);
+
+	size = panel_toplevel_get_size (separator->priv->panel->toplevel);
+
+	if (separator->priv->orientation == GTK_ORIENTATION_VERTICAL)
+		*minimal_height = *natural_height = SEPARATOR_SIZE;
+	else
+		*minimal_height = *natural_height = size;
 }
 
 static void
@@ -149,10 +161,11 @@ panel_separator_class_init (PanelSeparatorClass *klass)
 {
 	GtkWidgetClass *widget_class  = GTK_WIDGET_CLASS (klass);
 
-	widget_class->draw          = panel_separator_draw;
-	widget_class->size_request  = panel_separator_size_request;
-	widget_class->size_allocate = panel_separator_size_allocate;
-	widget_class->parent_set    = panel_separator_parent_set;
+	widget_class->draw                 = panel_separator_draw;
+	widget_class->get_preferred_width  = panel_separator_get_preferred_width;
+	widget_class->get_preferred_height = panel_separator_get_preferred_height;
+	widget_class->size_allocate        = panel_separator_size_allocate;
+	widget_class->parent_set           = panel_separator_parent_set;
 
 	g_type_class_add_private (klass, sizeof (PanelSeparatorPrivate));
 }
diff --git a/gnome-panel/panel-toplevel.c b/gnome-panel/panel-toplevel.c
index 6452ce7..1a135c9 100644
--- a/gnome-panel/panel-toplevel.c
+++ b/gnome-panel/panel-toplevel.c
@@ -3062,6 +3062,7 @@ panel_toplevel_size_request (GtkWidget      *widget,
 	GdkRectangle   old_geometry;
 	int            position_changed = FALSE;
 	int            size_changed = FALSE;
+	int            dummy; /* to pass a valid pointer */
 
 	toplevel = PANEL_TOPLEVEL (widget);
 	bin = GTK_BIN (widget);
@@ -3071,8 +3072,10 @@ panel_toplevel_size_request (GtkWidget      *widget,
 	panel_toplevel_update_monitor (toplevel);
 
 	child = gtk_bin_get_child (bin);
-	if (child && gtk_widget_get_visible (child))
-		gtk_widget_size_request (child, requisition);
+	if (child && gtk_widget_get_visible (child)) {
+		gtk_widget_get_preferred_width (child, &dummy, &requisition->width);
+		gtk_widget_get_preferred_height (child, &dummy, &requisition->height);
+	}
 
 	old_geometry = toplevel->priv->geometry;
 
@@ -3096,6 +3099,26 @@ panel_toplevel_size_request (GtkWidget      *widget,
 }
 
 static void
+panel_toplevel_get_preferred_width(GtkWidget *widget, gint *minimal_width, gint *natural_width)
+{
+	GtkRequisition requisition;
+
+	panel_toplevel_size_request (widget, &requisition);
+
+	*minimal_width = *natural_width = requisition.width;
+}
+
+static void
+panel_toplevel_get_preferred_height(GtkWidget *widget, gint *minimal_height, gint *natural_height)
+{
+	GtkRequisition requisition;
+
+	panel_toplevel_size_request (widget, &requisition);
+
+	*minimal_height = *natural_height = requisition.height;
+}
+
+static void
 panel_toplevel_size_allocate (GtkWidget     *widget,
 			      GtkAllocation *allocation)
 {
@@ -4098,7 +4121,8 @@ panel_toplevel_class_init (PanelToplevelClass *klass)
 
 	widget_class->realize              = panel_toplevel_realize;
 	widget_class->unrealize            = panel_toplevel_unrealize;
-	widget_class->size_request         = panel_toplevel_size_request;
+	widget_class->get_preferred_width  = panel_toplevel_get_preferred_width;
+	widget_class->get_preferred_height = panel_toplevel_get_preferred_height;
 	widget_class->size_allocate        = panel_toplevel_size_allocate;
 	widget_class->draw                 = panel_toplevel_draw;
 	widget_class->button_press_event   = panel_toplevel_button_press_event;
diff --git a/gnome-panel/panel-widget.c b/gnome-panel/panel-widget.c
index 16cac99..697a50b 100644
--- a/gnome-panel/panel-widget.c
+++ b/gnome-panel/panel-widget.c
@@ -59,22 +59,26 @@ static guint panel_widget_signals [LAST_SIGNAL] = {0};
 static gboolean panel_applet_in_drag = FALSE;
 static GtkWidget *saved_focus_widget = NULL;
 
-static void panel_widget_size_request   (GtkWidget        *widget,
-					 GtkRequisition   *requisition);
-static void panel_widget_size_allocate  (GtkWidget        *widget,
-					 GtkAllocation    *allocation);
-static void panel_widget_cadd           (GtkContainer     *container,
-					 GtkWidget        *widget);
-static void panel_widget_cremove        (GtkContainer     *container,
-					 GtkWidget        *widget);
-static void panel_widget_dispose        (GObject          *obj);
-static void panel_widget_finalize       (GObject          *obj);
-static void panel_widget_realize        (GtkWidget        *widget);
-static void panel_widget_unrealize      (GtkWidget        *panel);
-static void panel_widget_state_changed  (GtkWidget        *widget,
-					 GtkStateType      previous_state);
-static void panel_widget_style_set      (GtkWidget        *widget,
-					 GtkStyle         *previous_style);
+static void panel_widget_get_preferred_width  (GtkWidget        *widget,
+					       gint             *minimal_width,
+					       gint             *natural_width);
+static void panel_widget_get_preferred_height (GtkWidget        *widget,
+					       gint             *minimal_height,
+					       gint             *natural_height);
+static void panel_widget_size_allocate        (GtkWidget        *widget,
+					       GtkAllocation    *allocation);
+static void panel_widget_cadd                 (GtkContainer     *container,
+					       GtkWidget        *widget);
+static void panel_widget_cremove              (GtkContainer     *container,
+					       GtkWidget        *widget);
+static void panel_widget_dispose              (GObject          *obj);
+static void panel_widget_finalize             (GObject          *obj);
+static void panel_widget_realize              (GtkWidget        *widget);
+static void panel_widget_unrealize            (GtkWidget        *panel);
+static void panel_widget_state_changed        (GtkWidget        *widget,
+					       GtkStateType      previous_state);
+static void panel_widget_style_set            (GtkWidget        *widget,
+					       GtkStyle         *previous_style);
 
 static void panel_widget_background_changed (PanelBackground *background,
 					     PanelWidget     *panel);
@@ -409,7 +413,8 @@ panel_widget_class_init (PanelWidgetClass *class)
 	object_class->dispose = panel_widget_dispose;
 	object_class->finalize = panel_widget_finalize;
 	
-	widget_class->size_request = panel_widget_size_request;
+	widget_class->get_preferred_width = panel_widget_get_preferred_width;
+	widget_class->get_preferred_height = panel_widget_get_preferred_height;
 	widget_class->size_allocate = panel_widget_size_allocate;
 	widget_class->realize = panel_widget_realize;
 	widget_class->unrealize = panel_widget_unrealize;
@@ -1212,29 +1217,34 @@ panel_widget_size_request(GtkWidget *widget, GtkRequisition *requisition)
 
 	for(list = panel->applet_list; list!=NULL; list = g_list_next(list)) {
 		AppletData *ad = list->data;
-		GtkRequisition chreq;
-		gtk_widget_size_request(ad->applet,&chreq);
+		gint min_width, preferred_width;
+		gint min_height, preferred_height;
+
+		gtk_widget_get_preferred_width (ad->applet, &min_width, &preferred_width);
+		gtk_widget_get_preferred_width (ad->applet, &min_height, &preferred_height);
+
+		/* FIXME: do something with minimum sizes */
 
 		if (panel->orient == GTK_ORIENTATION_HORIZONTAL) {
-			if (requisition->height < chreq.height && !ad->size_constrained)
-				requisition->height = chreq.height;
+			if (requisition->height < preferred_height && !ad->size_constrained)
+				requisition->height = preferred_height;
 
 			if (panel->packed && ad->expand_major && ad->size_hints)
 				ad_with_hints = g_list_prepend (ad_with_hints,
 								ad);
 
 			else if (panel->packed)
-				requisition->width += chreq.width;
+				requisition->width += preferred_width;
 		} else {
-			if (requisition->width < chreq.width && !ad->size_constrained)
-				requisition->width = chreq.width;
+			if (requisition->width < preferred_width && !ad->size_constrained)
+				requisition->width = preferred_width;
 
 			if (panel->packed && ad->expand_major && ad->size_hints)
 				ad_with_hints = g_list_prepend (ad_with_hints,
 								ad);
 
 			else if (panel->packed)
-				requisition->height += chreq.height;
+				requisition->height += preferred_height;
 		}
 	}
 
@@ -1294,6 +1304,26 @@ panel_widget_size_request(GtkWidget *widget, GtkRequisition *requisition)
 }
 
 static void
+panel_widget_get_preferred_width(GtkWidget *widget, gint *minimal_width, gint *natural_width)
+{
+	GtkRequisition requisition;
+
+        panel_widget_size_request (widget, &requisition);
+
+	*minimal_width = *natural_width = requisition.width;
+}
+
+static void
+panel_widget_get_preferred_height(GtkWidget *widget, gint *minimal_height, gint *natural_height)
+{
+	GtkRequisition requisition;
+
+        panel_widget_size_request (widget, &requisition);
+
+	*minimal_height = *natural_height = requisition.height;
+}
+
+static void
 queue_resize_on_all_applets(PanelWidget *panel)
 {
 	GList *li;
[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]