? alignment3.patch
? gtk+.kdevprj
? gtk+.kdevses
? demos/gtk-demo/geninclude.pl
? gtk/gtkalignment.loT
Index: ChangeLog
===================================================================
RCS file: /cvs/gnome/gtk+/ChangeLog,v
retrieving revision 1.4000.2.152
diff -u -p -r1.4000.2.152 ChangeLog
--- ChangeLog	30 May 2003 01:32:41 -0000	1.4000.2.152
+++ ChangeLog	30 May 2003 06:22:54 -0000
@@ -1,3 +1,10 @@
+2003-05-29  Murray Cumming  <murrayc@usa.net>
+ 
+ 	* gtk/gtkalignment.[h|c]: Added 4-sided padding as properties with
+ 	gtk_alignment_get_padding() and gtk_aligment_set_padding(). This
+ 	uses the new private data system - see g_type_class_add_private() in
+ 	gtk_alignment_class_init() and the use of GTK_ALIGNMENT_GET_PRIVATE().
+
 Thu May 29 18:30:55 2003  Hidetoshi Tajima  <hidetoshi.tajima@sun.com>
 
 	* modules/input/imipa.c: 
Index: examples/menu/menu.c
===================================================================
RCS file: /cvs/gnome/gtk+/examples/menu/menu.c,v
retrieving revision 1.8
diff -u -p -r1.8 menu.c
--- examples/menu/menu.c	24 Aug 2002 11:53:20 -0000	1.8
+++ examples/menu/menu.c	30 May 2003 06:22:54 -0000
@@ -69,7 +69,7 @@ int main( int   argc,
 
     /* Now we specify that we want our newly created "menu" to be the menu
      * for the "root menu" */
-    gtk_menu_item_set_submenu (GTK_MENU_ITEM (root_menu), menu);
+    gtk_menu_item_set_submenu (GTK_MENU_ITEM (root_menu), h);
 
     /* A vbox to put a menu and a button in: */
     vbox = gtk_vbox_new (FALSE, 0);
Index: gtk/gtkalignment.c
===================================================================
RCS file: /cvs/gnome/gtk+/gtk/gtkalignment.c,v
retrieving revision 1.26
diff -u -p -r1.26 gtkalignment.c
--- gtk/gtkalignment.c	9 Oct 2002 22:25:17 -0000	1.26
+++ gtk/gtkalignment.c	30 May 2003 06:22:55 -0000
@@ -34,10 +34,22 @@ enum {
   PROP_YALIGN,
   PROP_XSCALE,
   PROP_YSCALE,
+
+  PROP_PADDING_TOP,
+  PROP_PADDING_BOTTOM,
+  PROP_PADDING_LEFT,
+  PROP_PADDING_RIGHT,
   
   PROP_LAST
 };
 
+struct _GtkAlignmentPrivate
+{
+  guint padding_top;
+  guint padding_bottom;
+  guint padding_left;
+  guint padding_right;
+};
 
 static void gtk_alignment_class_init    (GtkAlignmentClass *klass);
 static void gtk_alignment_init          (GtkAlignment      *alignment);
@@ -133,11 +145,57 @@ gtk_alignment_class_init (GtkAlignmentCl
                                                       1.0,
                                                       1.0,
                                                       G_PARAM_READABLE | G_PARAM_WRITABLE));
+
+
+  /* Padding properties: */
+  g_object_class_install_property (gobject_class,
+                                   PROP_PADDING_TOP,
+                                   g_param_spec_uint("top_padding",
+                                                      _("Top Padding"),
+                                                      _("The padding to insert at the top of the widget."),
+                                                      0,
+                                                      G_MAXINT,
+                                                      0,
+                                                      G_PARAM_READABLE | G_PARAM_WRITABLE));
+
+  g_object_class_install_property (gobject_class,
+                                   PROP_PADDING_BOTTOM,
+                                   g_param_spec_uint("bottom_padding",
+                                                      _("Bottom Padding"),
+                                                      _("The padding to insert at the bottom of the widget."),
+                                                      0,
+                                                      G_MAXINT,
+                                                      0,
+                                                      G_PARAM_READABLE | G_PARAM_WRITABLE));
+
+  g_object_class_install_property (gobject_class,
+                                   PROP_PADDING_LEFT,
+                                   g_param_spec_uint("left_padding",
+                                                      _("Left Padding"),
+                                                      _("The padding to insert at the left of the widget."),
+                                                      0,
+                                                      G_MAXINT,
+                                                      0,
+                                                      G_PARAM_READABLE | G_PARAM_WRITABLE));
+
+  g_object_class_install_property (gobject_class,
+                                   PROP_PADDING_RIGHT,
+                                   g_param_spec_uint("right_padding",
+                                                      _("Right Padding"),
+                                                      _("The padding to insert at the right of the widget."),
+                                                      0,
+                                                      G_MAXINT,
+                                                      0,
+                                                      G_PARAM_READABLE | G_PARAM_WRITABLE));
+
+  g_type_class_add_private (gobject_class, sizeof (GtkAlignmentPrivate));  
 }
 
 static void
 gtk_alignment_init (GtkAlignment *alignment)
 {
+  GtkAlignmentPrivate *priv;
+  
   GTK_WIDGET_SET_FLAGS (alignment, GTK_NO_WINDOW);
   gtk_widget_set_redraw_on_allocate (GTK_WIDGET (alignment), FALSE);
 
@@ -145,6 +203,13 @@ gtk_alignment_init (GtkAlignment *alignm
   alignment->yalign = 0.5;
   alignment->xscale = 1.0;
   alignment->yscale = 1.0;
+
+  /* Initialize padding with default values: */
+  priv = GTK_ALIGNMENT_GET_PRIVATE (alignment);
+  priv->padding_top = 0;
+  priv->padding_bottom = 0;
+  priv->padding_left = 0;
+  priv->padding_right = 0;
 }
 
 GtkWidget*
@@ -172,8 +237,10 @@ gtk_alignment_set_property (GObject     
 			    GParamSpec      *pspec)
 {
   GtkAlignment *alignment;
+  GtkAlignmentPrivate *priv;
   
   alignment = GTK_ALIGNMENT (object);
+  priv = GTK_ALIGNMENT_GET_PRIVATE (alignment);
   
   switch (prop_id)
     {
@@ -205,6 +272,37 @@ gtk_alignment_set_property (GObject     
 			 alignment->xscale,
 			 g_value_get_float (value));
       break;
+      
+    /* Padding: */
+    case PROP_PADDING_TOP:
+      gtk_alignment_set_padding (alignment,
+			 g_value_get_uint (value),
+			 priv->padding_bottom,
+			 priv->padding_left,
+			 priv->padding_right);
+      break;
+    case PROP_PADDING_BOTTOM:
+      gtk_alignment_set_padding (alignment,
+			 priv->padding_top,
+			 g_value_get_uint (value),
+			 priv->padding_left,
+			 priv->padding_right);
+      break;
+    case PROP_PADDING_LEFT:
+      gtk_alignment_set_padding (alignment,
+			 priv->padding_top,
+			 priv->padding_bottom,
+			 g_value_get_uint (value),
+			 priv->padding_right);
+      break;
+    case PROP_PADDING_RIGHT:
+      gtk_alignment_set_padding (alignment,
+			 priv->padding_top,
+			 priv->padding_bottom,
+			 priv->padding_left,
+			 g_value_get_uint (value));
+      break;
+    
     default:
       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
       break;
@@ -218,8 +316,10 @@ gtk_alignment_get_property (GObject     
 			    GParamSpec      *pspec)
 {
   GtkAlignment *alignment;
-  
+  GtkAlignmentPrivate *priv;
+
   alignment = GTK_ALIGNMENT (object);
+  priv = GTK_ALIGNMENT_GET_PRIVATE (alignment);
    
   switch (prop_id)
     {
@@ -235,6 +335,21 @@ gtk_alignment_get_property (GObject     
     case PROP_YSCALE:
       g_value_set_float(value, alignment->yscale);
       break;
+
+    /* Padding: */
+    case PROP_PADDING_TOP:
+      g_value_set_uint (value, priv->padding_top);
+      break;
+    case PROP_PADDING_BOTTOM:
+      g_value_set_uint (value, priv->padding_bottom);
+      break;
+    case PROP_PADDING_LEFT:
+      g_value_set_uint (value, priv->padding_left);
+      break;
+    case PROP_PADDING_RIGHT:
+      g_value_set_uint (value, priv->padding_right);
+      break;
+      
     default:
       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
       break;
@@ -296,9 +411,11 @@ gtk_alignment_size_request (GtkWidget   
 {
   GtkAlignment *alignment;
   GtkBin *bin;
+  GtkAlignmentPrivate *priv;
 
   alignment = GTK_ALIGNMENT (widget);
   bin = GTK_BIN (widget);
+  priv = GTK_ALIGNMENT_GET_PRIVATE (widget);
 
   requisition->width = GTK_CONTAINER (widget)->border_width * 2;
   requisition->height = GTK_CONTAINER (widget)->border_width * 2;
@@ -311,6 +428,10 @@ gtk_alignment_size_request (GtkWidget   
 
       requisition->width += child_requisition.width;
       requisition->height += child_requisition.height;
+
+      /* Request extra space for the padding: */
+      requisition->width += (priv->padding_left + priv->padding_right);
+      requisition->height += (priv->padding_top + priv->padding_bottom);
     }
 }
 
@@ -323,7 +444,13 @@ gtk_alignment_size_allocate (GtkWidget  
   GtkAllocation child_allocation;
   GtkRequisition child_requisition;
   gint width, height;
-  gint x, y;
+  gint border_width;
+  gint padding_horizontal, padding_vertical;
+  GtkAlignmentPrivate *priv;
+  
+
+  padding_horizontal = 0;
+  padding_vertical = 0;
 
   widget->allocation = *allocation;
   alignment = GTK_ALIGNMENT (widget);
@@ -332,12 +459,16 @@ gtk_alignment_size_allocate (GtkWidget  
   if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
     {
       gtk_widget_get_child_requisition (bin->child, &child_requisition);
-      
-      x = GTK_CONTAINER (alignment)->border_width;
-      y = GTK_CONTAINER (alignment)->border_width;
-      width = MAX (allocation->width - 2 * x, 0);
-      height = MAX (allocation->height - 2 * y, 0);
-      
+
+      border_width = GTK_CONTAINER (alignment)->border_width;
+
+      priv = GTK_ALIGNMENT_GET_PRIVATE (widget);
+      padding_horizontal = priv->padding_left + priv->padding_right;
+      padding_vertical = priv->padding_top + priv->padding_bottom;
+
+      width = allocation->width - padding_horizontal - 2 * border_width;
+      height = allocation->height - padding_vertical - 2 * border_width;
+    
       if (width > child_requisition.width)
 	child_allocation.width = (child_requisition.width *
 				  (1.0 - alignment->xscale) +
@@ -352,9 +483,100 @@ gtk_alignment_size_allocate (GtkWidget  
       else
 	child_allocation.height = height;
 
-      child_allocation.x = alignment->xalign * (width - child_allocation.width) + allocation->x + x;
-      child_allocation.y = alignment->yalign * (height - child_allocation.height) + allocation->y + y;
+      child_allocation.x = alignment->xalign * (width - child_allocation.width) + allocation->x + border_width + priv->padding_left;
+      child_allocation.y = alignment->yalign * (height - child_allocation.height) + allocation->y + border_width + priv->padding_top;
 
       gtk_widget_size_allocate (bin->child, &child_allocation);
     }
+}
+
+/**
+ * gtk_alignment_set_padding:
+ * @alignment a #GtkAlignment
+ * @padding_top: the padding at the top of the widget
+ * @padding_bottom: the padding at the bottom of the widget
+ * @padding_left: the padding at the left of the widget
+ * @padding_right: the padding at the right of the widget.
+ *
+ * Sets the padding on the different sides of the widget.
+ * The padding adds blank space to the sides of the widget. For instance,
+ * this can be used to indent the child widget towards the right by adding
+ * padding on the left.
+ */
+void
+gtk_alignment_set_padding (GtkAlignment    *alignment,
+			   guint            padding_top,
+			   guint            padding_bottom,
+			   guint            padding_left,
+			   guint            padding_right)
+{
+  GtkAlignmentPrivate *priv;
+  
+  g_return_if_fail (GTK_IS_ALIGNMENT (alignment));
+
+  priv = GTK_ALIGNMENT_GET_PRIVATE (alignment);
+
+  g_object_freeze_notify (G_OBJECT (alignment));
+
+  if (priv->padding_top != padding_top)
+    {
+      priv->padding_top = padding_top;
+      g_object_notify (G_OBJECT (alignment), "top_padding");
+    }
+  if (priv->padding_bottom != padding_bottom)
+    {
+      priv->padding_bottom = padding_bottom;
+      g_object_notify (G_OBJECT (alignment), "bottom_padding");
+    }
+  if (priv->padding_left != padding_left)
+    {
+      priv->padding_left = padding_left;
+      g_object_notify (G_OBJECT (alignment), "left_padding");
+    }
+  if (priv->padding_right != padding_right)
+    {
+      priv->padding_right = padding_right;
+      g_object_notify (G_OBJECT (alignment), "right_padding");
+    }
+
+  g_object_thaw_notify (G_OBJECT (alignment));
+  
+  /* Make sure that the widget and children are redrawn with the new setting: */
+  if (GTK_BIN (alignment)->child)
+    gtk_widget_queue_resize (GTK_BIN (alignment)->child);
+
+  gtk_widget_queue_draw (GTK_WIDGET (alignment));
+}
+
+/**
+ * gtk_alignment_get_padding:
+ * @alignment a #GtkAlignment
+ * @padding_top: location to store the padding for the top of the widget, or %NULL
+ * @padding_bottom: location to store the padding for the bottom of the widget, or %NULL
+ * @padding_left: location to store the padding for the left of the widget, or %NULL
+ * @padding_right: location to store the padding for the right of the widget, or %NULL
+ *
+ * Gets the padding on the different sides of the widget.
+ * See gtk_alignment_set_padding ().
+ */
+void
+gtk_alignment_get_padding (GtkAlignment    *alignment,
+			   guint           *padding_top,
+			   guint           *padding_bottom,
+			   guint           *padding_left,
+			   guint           *padding_right)
+{
+  GtkAlignmentPrivate *priv;
+ 
+  g_return_if_fail (GTK_IS_ALIGNMENT (alignment));
+
+  priv = GTK_ALIGNMENT_GET_PRIVATE (alignment);
+  if(padding_top)
+    *padding_top = priv->padding_top;
+  if(padding_bottom)
+    *padding_bottom = priv->padding_bottom;
+  if(padding_left)
+    *padding_left = priv->padding_left;
+  if(padding_right)
+    *padding_right = priv->padding_right;
 }
Index: gtk/gtkalignment.h
===================================================================
RCS file: /cvs/gnome/gtk+/gtk/gtkalignment.h,v
retrieving revision 1.10
diff -u -p -r1.10 gtkalignment.h
--- gtk/gtkalignment.h	9 Oct 2002 22:25:17 -0000	1.10
+++ gtk/gtkalignment.h	30 May 2003 06:22:55 -0000
@@ -43,10 +43,12 @@ extern "C" {
 #define GTK_IS_ALIGNMENT(obj)               (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_ALIGNMENT))
 #define GTK_IS_ALIGNMENT_CLASS(klass)       (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_ALIGNMENT))
 #define GTK_ALIGNMENT_GET_CLASS(obj)        (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_ALIGNMENT, GtkAlignmentClass))
+#define GTK_ALIGNMENT_GET_PRIVATE(o)  (G_TYPE_INSTANCE_GET_PRIVATE ((o), GTK_TYPE_ALIGNMENT, GtkAlignmentPrivate))
 
 
 typedef struct _GtkAlignment       GtkAlignment;
 typedef struct _GtkAlignmentClass  GtkAlignmentClass;
+typedef struct _GtkAlignmentPrivate GtkAlignmentPrivate;
 
 struct _GtkAlignment
 {
@@ -75,6 +77,17 @@ void       gtk_alignment_set        (Gtk
 				     gfloat             xscale,
 				     gfloat             yscale);
 
+void       gtk_alignment_set_padding (GtkAlignment      *alignment,
+				      guint              padding_top,
+				      guint              padding_bottom,
+				      guint              padding_left,
+				      guint              padding_right);
+
+void       gtk_alignment_get_padding (GtkAlignment      *alignment,
+				      guint             *padding_top,
+				      guint             *padding_bottom,
+				      guint             *padding_left,
+				      guint             *padding_right);
 
 #ifdef __cplusplus
 }
