Support GtkOrientable for GtkButtonBox

Edit: Update for coding style

1 files changed, 349 insertions, 0 deletions

diff --git a/gtk/gtkbbox.c b/gtk/gtkbbox.c
index 609e45dc33..b2a0acf922 100644
--- a/gtk/gtkbbox.c
+++ b/gtk/gtkbbox.c
@@ -26,6 +26,7 @@
 
 #include "config.h"
 #include "gtkbbox.h"
+#include "gtkorientable.h"
 #include "gtkprivate.h"
 #include "gtkintl.h"
 #include "gtkalias.h"
@@ -48,6 +49,10 @@ static void gtk_button_box_get_property       (GObject           *object,
 					       guint              prop_id,
 					       GValue            *value,
 					       GParamSpec        *pspec);
+static void gtk_button_box_size_request  (GtkWidget      *widget,
+                                          GtkRequisition *requisition);
+static void gtk_button_box_size_allocate (GtkWidget      *widget,
+                                          GtkAllocation  *allocation);
 static void gtk_button_box_set_child_property (GtkContainer      *container,
 					       GtkWidget         *child,
 					       guint              property_id,
@@ -80,6 +85,9 @@ gtk_button_box_class_init (GtkButtonBoxClass *class)
   gobject_class->set_property = gtk_button_box_set_property;
   gobject_class->get_property = gtk_button_box_get_property;
 
+  widget_class->size_request = gtk_button_box_size_request;
+  widget_class->size_allocate = gtk_button_box_size_allocate;
+
   container_class->set_child_property = gtk_button_box_set_child_property;
   container_class->get_child_property = gtk_button_box_get_child_property;
   
@@ -471,5 +479,346 @@ _gtk_button_box_child_requisition (GtkWidget *widget,
     *height = needed_height;
 }
 
+/* this is a kludge function to support the deprecated
+ * gtk_[vh]button_box_set_layout_default() just in case anyone is still
+ * using it (why?)
+ */
+static GtkButtonBoxStyle
+gtk_button_box_kludge_get_layout_default (GtkButtonBox *widget)
+{
+  GtkOrientation orientation;
+
+  orientation = gtk_orientable_get_orientation (GTK_ORIENTABLE (widget));
+
+  if (orientation == GTK_ORIENTATION_HORIZONTAL)
+    return gtk_hbutton_box_get_layout_default ();
+  else
+    return gtk_vbutton_box_get_layout_default ();
+}
+
+static void
+gtk_button_box_size_request (GtkWidget      *widget,
+                             GtkRequisition *requisition)
+{
+  GtkBox *box;
+  GtkButtonBox *bbox;
+  gint nvis_children;
+  gint child_width;
+  gint child_height;
+  gint spacing;
+  GtkButtonBoxStyle layout;
+  GtkOrientation orientation;
+
+  box = GTK_BOX (widget);
+  bbox = GTK_BUTTON_BOX (widget);
+
+  orientation = gtk_orientable_get_orientation (GTK_ORIENTABLE (widget));
+  spacing = box->spacing;
+  layout = bbox->layout_style != GTK_BUTTONBOX_DEFAULT_STYLE
+	  ? bbox->layout_style : gtk_button_box_kludge_get_layout_default (GTK_BUTTON_BOX (widget));
+
+  _gtk_button_box_child_requisition (widget,
+                                     &nvis_children,
+				     NULL,
+                                     &child_width,
+                                     &child_height);
+
+  if (nvis_children == 0)
+    {
+      requisition->width = 0;
+      requisition->height = 0;
+    }
+  else
+    {
+      switch (layout)
+        {
+          case GTK_BUTTONBOX_SPREAD:
+            if (orientation == GTK_ORIENTATION_HORIZONTAL)
+              requisition->width =
+                      nvis_children*child_width + ((nvis_children+1)*spacing);
+            else
+              requisition->height =
+                      nvis_children*child_height + ((nvis_children+1)*spacing);
+
+            break;
+          case GTK_BUTTONBOX_EDGE:
+          case GTK_BUTTONBOX_START:
+          case GTK_BUTTONBOX_END:
+          case GTK_BUTTONBOX_CENTER:
+            if (orientation == GTK_ORIENTATION_HORIZONTAL)
+              requisition->width =
+                      nvis_children*child_width + ((nvis_children-1)*spacing);
+            else
+              requisition->height =
+                      nvis_children*child_height + ((nvis_children-1)*spacing);
+
+            break;
+          default:
+            g_assert_not_reached ();
+            break;
+        }
+
+        if (orientation == GTK_ORIENTATION_HORIZONTAL)
+        {
+          requisition->height = child_height;
+        }
+        else
+        {
+          requisition->width = child_width;
+        }
+    }
+
+  requisition->width += GTK_CONTAINER (box)->border_width * 2;
+  requisition->height += GTK_CONTAINER (box)->border_width * 2;
+}
+
+static void
+gtk_button_box_size_allocate (GtkWidget     *widget,
+                              GtkAllocation *allocation)
+{
+  GtkBox *base_box;
+  GtkButtonBox *box;
+  GtkBoxChild *child;
+  GList *children;
+  GtkAllocation child_allocation;
+  gint nvis_children;
+  gint n_secondaries;
+  gint child_width;
+  gint child_height;
+  gint x = 0;
+  gint y = 0;
+  gint secondary_x = 0;
+  gint secondary_y = 0;
+  gint width;
+  gint height;
+  gint childspace;
+  gint childspacing = 0;
+  GtkButtonBoxStyle layout;
+  gint spacing;
+  GtkOrientation orientation;
+
+  orientation = gtk_orientable_get_orientation (GTK_ORIENTABLE (widget));
+  base_box = GTK_BOX (widget);
+  box = GTK_BUTTON_BOX (widget);
+  spacing = base_box->spacing;
+  layout = box->layout_style != GTK_BUTTONBOX_DEFAULT_STYLE
+	  ? box->layout_style : gtk_button_box_kludge_get_layout_default (GTK_BUTTON_BOX (widget));
+  _gtk_button_box_child_requisition (widget,
+                                     &nvis_children,
+                                     &n_secondaries,
+                                     &child_width,
+                                     &child_height);
+  widget->allocation = *allocation;
+
+  if (orientation == GTK_ORIENTATION_HORIZONTAL)
+    width = allocation->width - GTK_CONTAINER (box)->border_width*2;
+  else
+    height = allocation->height - GTK_CONTAINER (box)->border_width*2;
+
+  switch (layout)
+    {
+      case GTK_BUTTONBOX_SPREAD:
+
+        if (orientation == GTK_ORIENTATION_HORIZONTAL)
+          {
+            childspacing = (width - (nvis_children * child_width))
+                    / (nvis_children + 1);
+            x = allocation->x + GTK_CONTAINER (box)->border_width
+                    + childspacing;
+            secondary_x = x + ((nvis_children - n_secondaries)
+                            * (child_width + childspacing));
+          }
+        else
+          {
+            childspacing = (height - (nvis_children * child_height))
+                    / (nvis_children + 1);
+            y = allocation->y + GTK_CONTAINER (box)->border_width
+                    + childspacing;
+            secondary_y = y + ((nvis_children - n_secondaries)
+                            * (child_height + childspacing));
+          }
+
+        break;
+
+      case GTK_BUTTONBOX_EDGE:
+
+        if (orientation == GTK_ORIENTATION_HORIZONTAL)
+          {
+            if (nvis_children >= 2)
+            {
+              childspacing = (width - (nvis_children * child_width))
+                      / (nvis_children - 1);
+              x = allocation->x + GTK_CONTAINER (box)->border_width;
+              secondary_x = x + ((nvis_children - n_secondaries)
+                              * (child_width + childspacing));
+            }
+          else
+            {
+              /* one or zero children, just center */
+              childspacing = width;
+              x = secondary_x = allocation->x
+                      + (allocation->width - child_width) / 2;
+            }
+          }
+        else
+          {
+            if (nvis_children >= 2)
+              {
+                childspacing = (height - (nvis_children*child_height))
+                        / (nvis_children-1);
+                y = allocation->y + GTK_CONTAINER (box)->border_width;
+                secondary_y = y + ((nvis_children - n_secondaries)
+                                * (child_height + childspacing));
+              }
+            else
+              {
+                /* one or zero children, just center */
+                childspacing = height;
+                y = secondary_y = allocation->y
+                        + (allocation->height - child_height) / 2;
+              }
+          }
+
+        break;
+
+      case GTK_BUTTONBOX_START:
+
+        if (orientation == GTK_ORIENTATION_HORIZONTAL)
+          {
+            childspacing = spacing;
+            x = allocation->x + GTK_CONTAINER (box)->border_width;
+            secondary_x = allocation->x + allocation->width
+              - child_width * n_secondaries
+              - spacing * (n_secondaries - 1)
+              - GTK_CONTAINER (box)->border_width;
+          }
+        else
+          {
+            childspacing = spacing;
+            y = allocation->y + GTK_CONTAINER (box)->border_width;
+            secondary_y = allocation->y + allocation->height
+              - child_height * n_secondaries
+              - spacing * (n_secondaries - 1)
+              - GTK_CONTAINER (box)->border_width;
+          }
+
+        break;
+
+      case GTK_BUTTONBOX_END:
+
+        if (orientation == GTK_ORIENTATION_HORIZONTAL)
+          {
+            childspacing = spacing;
+            x = allocation->x + allocation->width
+              - child_width * (nvis_children - n_secondaries)
+              - spacing * (nvis_children - n_secondaries - 1)
+              - GTK_CONTAINER (box)->border_width;
+            secondary_x = allocation->x + GTK_CONTAINER (box)->border_width;
+          }
+        else
+          {
+            childspacing = spacing;
+            y = allocation->y + allocation->height
+              - child_height * (nvis_children - n_secondaries)
+              - spacing * (nvis_children - n_secondaries - 1)
+              - GTK_CONTAINER (box)->border_width;
+            secondary_y = allocation->y + GTK_CONTAINER (box)->border_width;
+          }
+
+        break;
+
+      case GTK_BUTTONBOX_CENTER:
+
+        if (orientation == GTK_ORIENTATION_HORIZONTAL)
+          {
+            childspacing = spacing;
+            x = allocation->x +
+              (allocation->width
+               - (child_width * (nvis_children - n_secondaries)
+               + spacing * (nvis_children - n_secondaries - 1)))/2
+              + (n_secondaries * child_width + n_secondaries * spacing)/2;
+            secondary_x = allocation->x + GTK_CONTAINER (box)->border_width;
+          }
+        else
+          {
+            childspacing = spacing;
+            y = allocation->y +
+              (allocation->height
+               - (child_height * (nvis_children - n_secondaries)
+                  + spacing * (nvis_children - n_secondaries - 1)))/2
+              + (n_secondaries * child_height + n_secondaries * spacing)/2;
+            secondary_y = allocation->y + GTK_CONTAINER (box)->border_width;
+          }
+
+        break;
+
+      default:
+        g_assert_not_reached();
+        break;
+    }
+
+    if (orientation == GTK_ORIENTATION_HORIZONTAL)
+      {
+        y = allocation->y + (allocation->height - child_height) / 2;
+        childspace = child_width + childspacing;
+      }
+    else
+      {
+        x = allocation->x + (allocation->width - child_width) / 2;
+        childspace = child_height + childspacing;
+      }
+
+  children = GTK_BOX (box)->children;
+
+  while (children)
+    {
+      child = children->data;
+      children = children->next;
+
+      if (GTK_WIDGET_VISIBLE (child->widget))
+        {
+          child_allocation.width = child_width;
+          child_allocation.height = child_height;
+
+          if (orientation == GTK_ORIENTATION_HORIZONTAL)
+            {
+              child_allocation.y = y;
+
+              if (child->is_secondary)
+                {
+                  child_allocation.x = secondary_x;
+                  secondary_x += childspace;
+                }
+              else
+                {
+                  child_allocation.x = x;
+                  x += childspace;
+                }
+
+              if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL)
+                  child_allocation.x = (allocation->x + allocation->width)
+                          - (child_allocation.x + child_width - allocation->x);
+            }
+          else
+            {
+              child_allocation.x = x;
+
+              if (child->is_secondary)
+                {
+                  child_allocation.y = secondary_y;
+                  secondary_y += childspace;
+                }
+              else
+                {
+                  child_allocation.y = y;
+                  y += childspace;
+                }
+            }
+
+          gtk_widget_size_allocate (child->widget, &child_allocation);
+        }
+    }
+}
+
 #define __GTK_BUTTON_BOX_C__
 #include "gtkaliasdef.c"