]> Pileus Git - ~andy/gtk/blobdiff - gtk/gtkbin.c
container: Split out a function
[~andy/gtk] / gtk / gtkbin.c
index 95d814e6e51dd946f0086a0cfc8ed12d49f3e3b9..e39ef02f3d8d316e7123d4dff82ee62c4d368cb0 100644 (file)
@@ -12,9 +12,7 @@
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the
- * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- * Boston, MA 02111-1307, USA.
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
  */
 
 /*
 #include "gtkintl.h"
 
 
+struct _GtkBinPrivate
+{
+  GtkWidget *child;
+};
+
 static void gtk_bin_add         (GtkContainer   *container,
                                 GtkWidget      *widget);
 static void gtk_bin_remove      (GtkContainer   *container,
@@ -54,49 +57,56 @@ static void gtk_bin_forall      (GtkContainer   *container,
 static GType gtk_bin_child_type (GtkContainer   *container);
 
 
-static void               gtk_bin_size_request_init     (GtkSizeRequestIface *iface);
-static GtkSizeRequestMode gtk_bin_get_request_mode      (GtkSizeRequest      *widget);
-static void               gtk_bin_get_width_for_height  (GtkSizeRequest      *widget,
-                                                        gint                 height,
-                                                        gint                *minimum_width,
-                                                        gint                *natural_width);
-static void               gtk_bin_get_height_for_width  (GtkSizeRequest      *widget,
-                                                        gint                 width,
-                                                        gint                *minimum_height,
-                                                        gint                *natural_height);
+static void               gtk_bin_get_preferred_width_for_height  (GtkWidget           *widget,
+                                                                   gint                 height,
+                                                                   gint                *minimum_width,
+                                                                   gint                *natural_width);
+static void               gtk_bin_get_preferred_height_for_width  (GtkWidget           *widget,
+                                                                   gint                 width,
+                                                                   gint                *minimum_height,
+                                                                   gint                *natural_height);
 
-static GtkSizeRequestIface *parent_size_request_iface;
-
-G_DEFINE_ABSTRACT_TYPE_WITH_CODE (GtkBin, gtk_bin, GTK_TYPE_CONTAINER,
-                                 G_IMPLEMENT_INTERFACE (GTK_TYPE_SIZE_REQUEST,
-                                                        gtk_bin_size_request_init))
+G_DEFINE_ABSTRACT_TYPE (GtkBin, gtk_bin, GTK_TYPE_CONTAINER)
 
 static void
 gtk_bin_class_init (GtkBinClass *class)
 {
-  GtkContainerClass *container_class;
+  GtkWidgetClass *widget_class = (GtkWidgetClass*) class;
+  GtkContainerClass *container_class = (GtkContainerClass*) class;
 
-  container_class = (GtkContainerClass*) class;
+  widget_class->get_preferred_width_for_height = gtk_bin_get_preferred_width_for_height;
+  widget_class->get_preferred_height_for_width = gtk_bin_get_preferred_height_for_width;
 
   container_class->add = gtk_bin_add;
   container_class->remove = gtk_bin_remove;
   container_class->forall = gtk_bin_forall;
   container_class->child_type = gtk_bin_child_type;
+
+  g_type_class_add_private (class, sizeof (GtkBinPrivate));
 }
 
 static void
 gtk_bin_init (GtkBin *bin)
 {
+  GtkBinPrivate *priv;
+
+  bin->priv = G_TYPE_INSTANCE_GET_PRIVATE (bin,
+                                           GTK_TYPE_BIN,
+                                           GtkBinPrivate);
+  priv = bin->priv;
+
   gtk_widget_set_has_window (GTK_WIDGET (bin), FALSE);
 
-  bin->child = NULL;
+  priv->child = NULL;
 }
 
 
 static GType
 gtk_bin_child_type (GtkContainer *container)
 {
-  if (!GTK_BIN (container)->child)
+  GtkBinPrivate *priv = GTK_BIN (container)->priv;
+
+  if (!priv->child)
     return GTK_TYPE_WIDGET;
   else
     return G_TYPE_NONE;
@@ -107,8 +117,9 @@ gtk_bin_add (GtkContainer *container,
             GtkWidget    *child)
 {
   GtkBin *bin = GTK_BIN (container);
+  GtkBinPrivate *priv = bin->priv;
 
-  if (bin->child != NULL)
+  if (priv->child != NULL)
     {
       g_warning ("Attempting to add a widget with type %s to a %s, "
                  "but as a GtkBin subclass a %s can only contain one widget at a time; "
@@ -116,12 +127,12 @@ gtk_bin_add (GtkContainer *container,
                  g_type_name (G_OBJECT_TYPE (child)),
                  g_type_name (G_OBJECT_TYPE (bin)),
                  g_type_name (G_OBJECT_TYPE (bin)),
-                 g_type_name (G_OBJECT_TYPE (bin->child)));
+                 g_type_name (G_OBJECT_TYPE (priv->child)));
       return;
     }
 
   gtk_widget_set_parent (child, GTK_WIDGET (bin));
-  bin->child = child;
+  priv->child = child;
 }
 
 static void
@@ -129,14 +140,15 @@ gtk_bin_remove (GtkContainer *container,
                GtkWidget    *child)
 {
   GtkBin *bin = GTK_BIN (container);
+  GtkBinPrivate *priv = bin->priv;
   gboolean widget_was_visible;
 
-  g_return_if_fail (bin->child == child);
+  g_return_if_fail (priv->child == child);
 
   widget_was_visible = gtk_widget_get_visible (child);
   
   gtk_widget_unparent (child);
-  bin->child = NULL;
+  priv->child = NULL;
   
   /* queue resize regardless of gtk_widget_get_visible (container),
    * since that's what is needed by toplevels, which derive from GtkBin.
@@ -152,9 +164,10 @@ gtk_bin_forall (GtkContainer *container,
                gpointer      callback_data)
 {
   GtkBin *bin = GTK_BIN (container);
+  GtkBinPrivate *priv = bin->priv;
 
-  if (bin->child)
-    (* callback) (bin->child, callback_data);
+  if (priv->child)
+    (* callback) (priv->child, callback_data);
 }
 
 
@@ -167,61 +180,53 @@ gtk_bin_forall (GtkContainer *container,
  * deduce a common code path for the get_width_for_height()/get_height_for_width()
  * cases by using the delta of the base size requsts.
  */
-static void 
-gtk_bin_size_request_init (GtkSizeRequestIface *iface)
-{
-  parent_size_request_iface = g_type_interface_peek_parent (iface);
-
-  iface->get_request_mode      = gtk_bin_get_request_mode;
-  iface->get_width_for_height  = gtk_bin_get_width_for_height;
-  iface->get_height_for_width  = gtk_bin_get_height_for_width;
-}
-
-static GtkSizeRequestMode
-gtk_bin_get_request_mode (GtkSizeRequest      *widget)
-{
-  GtkBin *bin = GTK_BIN (widget);
-
-  if (bin->child)
-    return gtk_size_request_get_request_mode (GTK_SIZE_REQUEST (bin->child));
-
-  return GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH;
-}
-
 static void
-get_child_padding_delta (GtkBin         *bin,
-                        gint           *delta_h,
-                        gint           *delta_v)
+get_child_padding_delta (GtkBin *bin,
+                        gint   *delta_h,
+                        gint   *delta_v)
 {
-  gint hmin, vmin, child_hmin, child_vmin;
+  GtkBinPrivate *priv = bin->priv;
+  gint hmin, vmin, hnat, vnat, child_hmin, child_vmin;
+
+  /* we can't use gtk_widget_get_preferred_width() wrapper 
+   * because we want our "original" request, not any external
+   * adjustments from set_size_request() or whatever.  we have
+   * to ask for natural also because NULL isn't allowed for the
+   * direct vfuncs
+   */
+  GTK_WIDGET_GET_CLASS (bin)->get_preferred_width (GTK_WIDGET (bin), &hmin, &hnat);
+  GTK_WIDGET_GET_CLASS (bin)->adjust_size_request (GTK_WIDGET (bin), 
+                                                  GTK_ORIENTATION_HORIZONTAL, &hmin, &hnat);
 
-  gtk_size_request_get_width (GTK_SIZE_REQUEST (bin), &hmin, NULL);
-  gtk_size_request_get_height (GTK_SIZE_REQUEST (bin), &vmin, NULL);
+  GTK_WIDGET_GET_CLASS (bin)->get_preferred_height (GTK_WIDGET (bin), &vmin, &vnat);
+  GTK_WIDGET_GET_CLASS (bin)->adjust_size_request (GTK_WIDGET (bin), 
+                                                  GTK_ORIENTATION_VERTICAL, &vmin, &vnat);
 
-  gtk_size_request_get_width (GTK_SIZE_REQUEST (bin->child), &child_hmin, NULL);
-  gtk_size_request_get_height (GTK_SIZE_REQUEST (bin->child), &child_vmin, NULL);
+  gtk_widget_get_preferred_width (priv->child, &child_hmin, NULL);
+  gtk_widget_get_preferred_height (priv->child, &child_vmin, NULL);
 
   *delta_h = hmin - child_hmin;
   *delta_v = vmin - child_vmin;
 }
 
 static void 
-gtk_bin_get_width_for_height (GtkSizeRequest      *widget,
-                             gint                 height,
-                             gint                *minimum_width,
-                             gint                *natural_width)
+gtk_bin_get_preferred_width_for_height (GtkWidget *widget,
+                                        gint       height,
+                                        gint      *minimum_width,
+                                        gint      *natural_width)
 {
   GtkBin *bin = GTK_BIN (widget);
+  GtkBinPrivate *priv = bin->priv;
   gint    hdelta, vdelta, child_min, child_nat;
 
-  if (bin->child)
+  if (priv->child)
     {
       get_child_padding_delta (bin, &hdelta, &vdelta);
-      
-      gtk_size_request_get_width_for_height (GTK_SIZE_REQUEST (bin->child),
-                                               height - vdelta,
-                                               &child_min, &child_nat);
-      
+
+      gtk_widget_get_preferred_width_for_height (priv->child,
+                                                 height - vdelta,
+                                                 &child_min, &child_nat);
+
       if (minimum_width)
        *minimum_width = child_min + hdelta;
       
@@ -229,26 +234,27 @@ gtk_bin_get_width_for_height (GtkSizeRequest      *widget,
        *natural_width = child_nat + hdelta;
     }
   else
-    GTK_SIZE_REQUEST_GET_IFACE (widget)->get_width (widget, minimum_width, natural_width);
+    GTK_WIDGET_GET_CLASS (widget)->get_preferred_width (widget, minimum_width, natural_width);
 }
 
 static void
-gtk_bin_get_height_for_width  (GtkSizeRequest      *widget,
-                              gint                 width,
-                              gint                *minimum_height,
-                              gint                *natural_height)
+gtk_bin_get_preferred_height_for_width  (GtkWidget *widget,
+                                         gint       width,
+                                         gint      *minimum_height,
+                                         gint      *natural_height)
 {
   GtkBin *bin = GTK_BIN (widget);
+  GtkBinPrivate *priv = bin->priv;
   gint    hdelta, vdelta, child_min, child_nat;
 
-  if (bin->child)
+  if (priv->child)
     {
       get_child_padding_delta (bin, &hdelta, &vdelta);
-      
-      gtk_size_request_get_height_for_width (GTK_SIZE_REQUEST (bin->child),
-                                               width - hdelta,
-                                               &child_min, &child_nat);
-      
+
+      gtk_widget_get_preferred_height_for_width (priv->child,
+                                                 width - hdelta,
+                                                 &child_min, &child_nat);
+
       if (minimum_height)
        *minimum_height = child_min + vdelta;
       
@@ -256,7 +262,7 @@ gtk_bin_get_height_for_width  (GtkSizeRequest      *widget,
        *natural_height = child_nat + vdelta;
     }
   else
-    GTK_SIZE_REQUEST_GET_IFACE (widget)->get_height (widget, minimum_height, natural_height);
+    GTK_WIDGET_GET_CLASS (widget)->get_preferred_height (widget, minimum_height, natural_height);
 }
 
 
@@ -275,7 +281,7 @@ gtk_bin_get_child (GtkBin *bin)
 {
   g_return_val_if_fail (GTK_IS_BIN (bin), NULL);
 
-  return bin->child;
+  return bin->priv->child;
 }
 
 void