path: root/meta/packages/gtk+/gtk+-2.6.4-1.osso7/gtknotebook.c.diff

--- gtk+-2.6.4/gtk/gtknotebook.c	2004-09-27 06:43:55.000000000 +0300
+++ gtk+-2.6.4/gtk/gtknotebook.c	2005-04-06 16:19:37.033908352 +0300
@@ -40,10 +40,10 @@
 
 #define TAB_OVERLAP    2
 #define TAB_CURVATURE  1
-#define ARROW_SIZE     12
+#define ARROW_WIDTH    20
+#define ARROW_HEIGHT   27
 #define ARROW_SPACING  0
-#define NOTEBOOK_INIT_SCROLL_DELAY (200)
-#define NOTEBOOK_SCROLL_DELAY      (100)
+#define LABEL_PADDING  0
 
 
 enum {
@@ -57,7 +57,9 @@
 
 enum {
   STEP_PREV,
-  STEP_NEXT
+  STEP_NEXT,
+  STEP_PREV_CYCLE,
+  STEP_NEXT_CYCLE
 };
 
 typedef enum
@@ -216,7 +218,7 @@
 					      GList            *list,
 					      gboolean		destroying);
 static void gtk_notebook_update_labels       (GtkNotebook      *notebook);
-static gint gtk_notebook_timer               (GtkNotebook      *notebook);
+static gint gtk_notebook_timer               (GtkNotebook      *notebook        );
 static gint gtk_notebook_page_compare        (gconstpointer     a,
 					      gconstpointer     b);
 static GList* gtk_notebook_find_child        (GtkNotebook      *notebook,
@@ -458,7 +460,7 @@
 				   g_param_spec_boolean ("scrollable",
  							 P_("Scrollable"),
  							 P_("If TRUE, scroll arrows are added if there are too many tabs to fit"),
- 							 FALSE,
+ 							 TRUE,
  							 G_PARAM_READWRITE));
   g_object_class_install_property (gobject_class,
 				   PROP_ENABLE_POPUP,
@@ -584,6 +586,75 @@
 								 
                                                                    G_PARAM_READABLE));
 
+  /* Hildon: for adding paddings to the inner borders of the visible page */
+  gtk_widget_class_install_style_property (widget_class,
+                                           g_param_spec_int ("inner_left_border",
+                                                             _("Inner left border of the visible page"),
+                                                             _("Width of inner left border of the visible page"),
+                                                             0,
+                                                             G_MAXINT,
+                                                             0,
+                                                             G_PARAM_READABLE));
+  gtk_widget_class_install_style_property (widget_class,
+                                           g_param_spec_int ("inner_right_border",
+                                                             _("Inner right border of the visible page"),
+                                                             _("Width of inner right border of the visible page"),
+                                                             0,
+                                                             G_MAXINT,
+                                                             0,
+                                                             G_PARAM_READABLE));
+
+  /* Hildon: previously hardcoded constants ARROW_WIDTH, ARROW_HEIGHT,
+     ARROW_SPACING, TAB_OVERLAP and TAB_CURVATURE are now style properties */
+  gtk_widget_class_install_style_property (widget_class,
+                                           g_param_spec_int ("arrow-width",
+                                                             _("Arrow width"),
+                                                             _("Scroll arrow width"),
+                                                             0,
+                                                             G_MAXINT,
+                                                             ARROW_WIDTH,
+                                                             G_PARAM_READABLE));
+  gtk_widget_class_install_style_property (widget_class,
+                                           g_param_spec_int ("arrow-height",
+                                                             _("Arrow height"),
+                                                             _("Scroll arrow height"),
+                                                             0,
+                                                             G_MAXINT,
+                                                             ARROW_HEIGHT,
+                                                             G_PARAM_READABLE));
+  gtk_widget_class_install_style_property (widget_class,
+                                           g_param_spec_int ("arrow-spacing",
+                                                             _("Arrow spacing"),
+                                                             _("Scroll arrow spacing"),
+                                                             0,
+                                                             G_MAXINT,
+                                                             ARROW_SPACING,
+                                                             G_PARAM_READABLE));
+  gtk_widget_class_install_style_property (widget_class,
+                                           g_param_spec_int ("tab-overlap",
+                                                             _("Tab overlap"),
+                                                             _("Tab overlap"),
+                                                             0,
+                                                             G_MAXINT,
+                                                             TAB_OVERLAP,
+                                                             G_PARAM_READABLE));
+  gtk_widget_class_install_style_property (widget_class,
+                                           g_param_spec_int ("tab-curvature",
+                                                             _("Tab curvature"),
+                                                             _("Tab curvature"),
+                                                             0,
+                                                             G_MAXINT,
+                                                             TAB_CURVATURE,
+                                                             G_PARAM_READABLE));
+  gtk_widget_class_install_style_property (widget_class,
+                                           g_param_spec_int ("label-padding",
+                                                             _("Label padding"),
+                                                             _("Label padding"),
+                                                             0,
+                                                             G_MAXINT,
+                                                             LABEL_PADDING,
+                                                             G_PARAM_READABLE));
+
   notebook_signals[SWITCH_PAGE] =
     g_signal_new ("switch_page",
 		  G_TYPE_FROM_CLASS (gobject_class),
@@ -705,11 +776,10 @@
   notebook->show_tabs = TRUE;
   notebook->show_border = TRUE;
   notebook->tab_pos = GTK_POS_TOP;
-  notebook->scrollable = FALSE;
+  notebook->scrollable = TRUE;
   notebook->in_child = 0;
   notebook->click_child = 0;
   notebook->button = 0;
-  notebook->need_timer = 0;
   notebook->child_has_focus = FALSE;
   notebook->have_visible_child = FALSE;
   notebook->focus_out = FALSE;
@@ -1189,9 +1259,18 @@
   GtkRequisition child_requisition;
   gboolean switch_page = FALSE;
   gint vis_pages;
-  gint focus_width;
+  gint focus_width, label_padding;
+  gint arrow_width, arrow_height, arrow_spacing, tab_overlap, tab_curvature;
 
-  gtk_widget_style_get (widget, "focus-line-width", &focus_width, NULL);
+  gtk_widget_style_get (widget,
+                        "focus-line-width", &focus_width,
+                        "arrow-width", &arrow_width,
+                        "arrow-height", &arrow_height,
+                        "arrow-spacing", &arrow_spacing,
+                        "tab-overlap", &tab_overlap,
+                        "tab-curvature", &tab_curvature,
+                        "label-padding", &label_padding,
+                        NULL);
   
   widget->requisition.width = 0;
   widget->requisition.height = 0;
@@ -1229,6 +1308,22 @@
     {
       widget->requisition.width += widget->style->xthickness * 2;
       widget->requisition.height += widget->style->ythickness * 2;
+   
+      /* Hildon kludge: inner border paddings */
+      if (notebook->children && notebook->show_border)
+        {
+          gint inner_left_border, inner_right_border;
+
+          gtk_widget_style_get (widget,
+                                "inner_left_border",
+                                &inner_left_border,
+                                "inner_right_border",
+                                &inner_right_border,
+                                NULL);
+
+          widget->requisition.width += inner_left_border + inner_right_border;
+        }
+
 
       if (notebook->show_tabs)
 	{
@@ -1249,6 +1344,7 @@
 
 		  gtk_widget_size_request (page->tab_label,
 					   &child_requisition);
+                  child_requisition.width += 2 * label_padding;
 
 		  page->requisition.width = 
 		    child_requisition.width +
@@ -1292,10 +1388,10 @@
 
 		  if (notebook->scrollable && vis_pages > 1 && 
 		      widget->requisition.width < tab_width)
-		    tab_height = MAX (tab_height, ARROW_SIZE);
+		    tab_height = MAX (tab_height, arrow_height);
 
-		  padding = 2 * (TAB_CURVATURE + focus_width +
-				 notebook->tab_hborder) - TAB_OVERLAP;
+		  padding = 2 * (tab_curvature + focus_width +
+				 notebook->tab_hborder) - tab_overlap;
 		  tab_max += padding;
 		  while (children)
 		    {
@@ -1316,15 +1412,15 @@
 
 		  if (notebook->scrollable && vis_pages > 1 &&
 		      widget->requisition.width < tab_width)
-		    tab_width = tab_max + 2 * (ARROW_SIZE + ARROW_SPACING);
+		    tab_width = tab_max + 2 * (arrow_width + arrow_spacing);
 
                   if (notebook->homogeneous && !notebook->scrollable)
                     widget->requisition.width = MAX (widget->requisition.width,
                                                      vis_pages * tab_max +
-                                                     TAB_OVERLAP);
+                                                     tab_overlap);
                   else
                     widget->requisition.width = MAX (widget->requisition.width,
-                                                     tab_width + TAB_OVERLAP);
+                                                     tab_width + tab_overlap);
 
 		  widget->requisition.height += tab_height;
 		  break;
@@ -1335,10 +1431,10 @@
 
 		  if (notebook->scrollable && vis_pages > 1 && 
 		      widget->requisition.height < tab_height)
-		    tab_width = MAX (tab_width, ARROW_SPACING + 2 * ARROW_SIZE);
+		    tab_width = MAX (tab_width, arrow_spacing + 2 * arrow_width);
 
-		  padding = 2 * (TAB_CURVATURE + focus_width +
-				 notebook->tab_vborder) - TAB_OVERLAP;
+		  padding = 2 * (tab_curvature + focus_width +
+				 notebook->tab_vborder) - tab_overlap;
 		  tab_max += padding;
 
 		  while (children)
@@ -1361,24 +1457,24 @@
 
 		  if (notebook->scrollable && vis_pages > 1 && 
 		      widget->requisition.height < tab_height)
-		    tab_height = tab_max + ARROW_SIZE + ARROW_SPACING;
+		    tab_height = tab_max + arrow_height + arrow_spacing;
 
 		  widget->requisition.width += tab_width;
 
                   if (notebook->homogeneous && !notebook->scrollable)
                     widget->requisition.height =
 		      MAX (widget->requisition.height,
-			   vis_pages * tab_max + TAB_OVERLAP);
+			   vis_pages * tab_max + tab_overlap);
                   else
                     widget->requisition.height =
 		      MAX (widget->requisition.height,
-			   tab_height + TAB_OVERLAP);
+			   tab_height + tab_overlap);
 
 		  if (!notebook->homogeneous || notebook->scrollable)
 		    vis_pages = 1;
 		  widget->requisition.height = MAX (widget->requisition.height,
 						    vis_pages * tab_max +
-						    TAB_OVERLAP);
+						    tab_overlap);
 		  break;
 		}
 	    }
@@ -1499,7 +1595,26 @@
 	    }
 	}
 
+      /* Hildon kludge: inner border paddings */
+      if (notebook->show_border)
+        {
+          gint inner_left_border, inner_right_border;
+
+          gtk_widget_style_get (widget,
+                                "inner_left_border",
+                                &inner_left_border,
+                                "inner_right_border",
+                                &inner_right_border,
+                                NULL);
+
+          child_allocation.x += inner_left_border;
+          child_allocation.width -= inner_left_border + inner_right_border;
+          if (child_allocation.width < 0)
+            child_allocation.width = 0;
+        }
+
       children = notebook->children;
+
       while (children)
 	{
 	  page = children->data;
@@ -1580,11 +1695,18 @@
   GdkRectangle event_window_pos;
   gboolean before = ARROW_IS_BEFORE (arrow);
   gboolean left = ARROW_IS_LEFT (arrow);
+  gint arrow_width, arrow_height, arrow_spacing;
+
+  gtk_widget_style_get (GTK_WIDGET(notebook),
+                        "arrow-width", &arrow_width,
+                        "arrow-height", &arrow_height,
+                        "arrow-spacing", &arrow_spacing,
+                        NULL);
 
   if (gtk_notebook_get_event_window_position (notebook, &event_window_pos))
     {
-      rectangle->width = ARROW_SIZE;
-      rectangle->height = ARROW_SIZE;
+      rectangle->width = arrow_width;
+      rectangle->height = arrow_height;
 
       switch (notebook->tab_pos)
 	{
@@ -1602,6 +1724,8 @@
 	    rectangle->y += event_window_pos.height - rectangle->height;
 	  break;
 	case GTK_POS_TOP:
+          arrow_spacing = - arrow_spacing;
+          /* Fall through */
 	case GTK_POS_BOTTOM:
 	  if (before)
 	    {
@@ -1617,7 +1741,11 @@
 	      else
 		rectangle->x = event_window_pos.x + event_window_pos.width - 2 * rectangle->width;
 	    }
-	  rectangle->y = event_window_pos.y + (event_window_pos.height - rectangle->height) / 2;
+	  rectangle->y = event_window_pos.y;
+          if (arrow_spacing > 0)
+            rectangle->y += arrow_spacing;
+          else
+            rectangle->y += (event_window_pos.height - rectangle->height) / 2;
 	  break;
 	}
     }
@@ -1696,6 +1824,10 @@
   gboolean is_rtl = gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL;
   gboolean left = (ARROW_IS_LEFT (arrow) && !is_rtl) || 
                   (!ARROW_IS_LEFT (arrow) && is_rtl);
+  GtkSettings *settings = gtk_settings_get_default ();
+  guint timeout;
+
+  g_object_get (settings, "gtk-initial-timeout", &timeout, NULL);
 
   if (!GTK_WIDGET_HAS_FOCUS (widget))
     gtk_widget_grab_focus (widget);
@@ -1706,14 +1838,14 @@
   if (event->button == 1)
     {
       gtk_notebook_do_arrow (notebook, arrow);
-      
+
       if (!notebook->timer)
-	{
-	  notebook->timer = g_timeout_add (NOTEBOOK_INIT_SCROLL_DELAY, 
-					   (GSourceFunc) gtk_notebook_timer, 
-					   (gpointer) notebook);
-	  notebook->need_timer = TRUE;
-	}
+        {
+          notebook->timer = g_timeout_add (timeout,
+                                           (GSourceFunc) gtk_notebook_timer,
+                                           (gpointer) notebook);
+          notebook->need_timer = TRUE;
+        }
     }
   else if (event->button == 2)
     gtk_notebook_page_select (notebook, TRUE);
@@ -1862,7 +1994,7 @@
 static void 
 stop_scrolling (GtkNotebook *notebook)
 {
-  if (notebook->timer)
+   if (notebook->timer)
     {
       g_source_remove (notebook->timer);
       notebook->timer = 0;
@@ -2343,9 +2475,9 @@
 	   */
 	  return focus_child_in (notebook, GTK_DIR_TAB_FORWARD);
 	case GTK_DIR_LEFT:
-	  return focus_tabs_move (notebook, direction, STEP_PREV);
+	  return focus_tabs_move (notebook, direction, STEP_PREV_CYCLE);
 	case GTK_DIR_RIGHT:
-	  return focus_tabs_move (notebook, direction, STEP_NEXT);
+	  return focus_tabs_move (notebook, direction, STEP_NEXT_CYCLE);
 	}
     }
   else /* Focus was not on widget */
@@ -2481,7 +2613,6 @@
  * gtk_notebook_redraw_tabs
  * gtk_notebook_real_remove
  * gtk_notebook_update_labels
- * gtk_notebook_timer
  * gtk_notebook_page_compare
  * gtk_notebook_real_page_position
  * gtk_notebook_search_page
@@ -2574,22 +2705,27 @@
 gtk_notebook_timer (GtkNotebook *notebook)
 {
   gboolean retval = FALSE;
+  guint timeout;
+  GtkSettings *settings;
 
   GDK_THREADS_ENTER ();
 
+  settings = gtk_settings_get_default ();
+  g_object_get (settings, "gtk-update-timeout", &timeout, NULL);
+
   if (notebook->timer)
     {
       gtk_notebook_do_arrow (notebook, notebook->click_child);
 
-      if (notebook->need_timer) 
-	{
-	  notebook->need_timer = FALSE;
-	  notebook->timer = g_timeout_add (NOTEBOOK_SCROLL_DELAY,
-					   (GSourceFunc) gtk_notebook_timer, 
-					   (gpointer) notebook);
-	}
+      if (notebook->need_timer)
+        {
+          notebook->need_timer = FALSE;
+          notebook->timer = g_timeout_add (timeout,
+                                           (GSourceFunc) gtk_notebook_timer,
+                                           (gpointer) notebook);
+        }
       else
-	retval = TRUE;
+        retval = TRUE;
     }
 
   GDK_THREADS_LEAVE ();
@@ -2781,10 +2917,12 @@
   switch (direction)
     {
     case STEP_PREV:
+    case STEP_PREV_CYCLE:
       flag = GTK_PACK_END;
       break;
 
     case STEP_NEXT:
+    case STEP_NEXT_CYCLE:
       flag = GTK_PACK_START;
       break;
     }
@@ -2827,6 +2965,37 @@
       old_list = list;
       list = list->prev;
     }
+
+  /* Hildon hack: keyboard navigation should cycle around */
+  if (direction == STEP_PREV_CYCLE)
+    {
+      /* find and return the last (visible) page */
+      list = g_list_last (notebook->children);
+      if (!find_visible)
+        return list;
+      while (list)
+        {
+          page = list->data;
+          if (GTK_WIDGET_VISIBLE (page->child))
+            return list;
+          list = list->prev;
+        }
+    }
+  if (direction == STEP_NEXT_CYCLE)
+    {
+      /* find and return the first (visible) page */
+      list = g_list_first (notebook->children);
+      if (!find_visible)
+        return list;
+      while (list)
+        {
+          page = list->data;
+          if (GTK_WIDGET_VISIBLE (page->child))
+            return list;
+          list = list->next;
+        }
+    }
+
   return NULL;
 }
 
@@ -2850,6 +3019,7 @@
   gint gap_x = 0, gap_width = 0, step = STEP_PREV;
   gboolean is_rtl;
   gint tab_pos;
+  gboolean paint_box_gap = FALSE;
    
   g_return_if_fail (GTK_IS_NOTEBOOK (widget));
   g_return_if_fail (area != NULL);
@@ -2933,15 +3103,37 @@
 	  step = STEP_PREV;
 	  break;
 	}
-      gtk_paint_box_gap (widget->style, widget->window,
-			 GTK_STATE_NORMAL, GTK_SHADOW_OUT,
-			 area, widget, "notebook",
-			 x, y, width, height,
-			 tab_pos, gap_x, gap_width);
+
+      /* hildon hack to postpone painting until it
+         is known if scroll arrows will be drawn */
+      paint_box_gap = TRUE;
     }
 
+  /* first, figure out if arrows should be drawn */
   showarrow = FALSE;
   children = gtk_notebook_search_page (notebook, NULL, step, TRUE);
+  while (children && !showarrow)
+    {
+      page = children->data;
+      children = gtk_notebook_search_page (notebook, children,
+					   step, TRUE);
+      if (!GTK_WIDGET_MAPPED (page->tab_label))
+	showarrow = TRUE;
+    }
+
+  /* then draw content area frame */
+  if (paint_box_gap)
+    gtk_paint_box_gap (widget->style, widget->window,
+                       GTK_STATE_NORMAL, GTK_SHADOW_OUT,
+                       area, widget,
+                       (showarrow && notebook->scrollable)
+                       ? "notebook_show_arrow"
+                       : "notebook",
+                       x, y, width, height,
+                       tab_pos, gap_x, gap_width);
+  
+  /* and finally draw tabs */
+  children = gtk_notebook_search_page (notebook, NULL, step, TRUE);
   while (children)
     {
       page = children->data;
@@ -3069,10 +3261,15 @@
   GdkRectangle arrow_rect;
   GtkArrowType arrow;
   gboolean is_rtl, left;
+  gint arrow_width, arrow_height;
 
   gtk_notebook_get_arrow_rect (notebook, &arrow_rect, nbarrow);
 
   widget = GTK_WIDGET (notebook);
+  gtk_widget_style_get (widget,
+                        "arrow-width", &arrow_width,
+                        "arrow-height", &arrow_height,
+                        NULL);
 
   is_rtl = gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL;
   left = (ARROW_IS_LEFT (nbarrow) && !is_rtl) ||
@@ -3112,7 +3309,7 @@
       gtk_paint_arrow (widget->style, widget->window, state_type, 
 		       shadow_type, NULL, widget, "notebook",
 		       arrow, TRUE, arrow_rect.x, arrow_rect.y, 
-		       ARROW_SIZE, ARROW_SIZE);
+		       arrow_width, arrow_height);
     }
 }
 
@@ -3143,13 +3340,25 @@
   gboolean is_rtl = (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL &&
 		     (tab_pos == GTK_POS_TOP || tab_pos == GTK_POS_BOTTOM));
   gint memo_x;
+  gboolean truncate = FALSE;
+  gint arrow_width, arrow_height, arrow_spacing, tab_overlap;
+  gint total_width, ideal_tab_width, n_expanding_tabs;
 
   if (!notebook->show_tabs || !notebook->children || !notebook->cur_page)
     return;
 
+  gtk_widget_style_get (widget,
+                        "arrow-width", &arrow_width,
+                        "arrow-height", &arrow_height,
+                        "arrow-spacing", &arrow_spacing,
+                        "tab-overlap", &tab_overlap,
+                        NULL);
+
   child_allocation.x = widget->allocation.x + container->border_width;
   child_allocation.y = widget->allocation.y + container->border_width;
 
+  total_width = allocation->width - 2 * container->border_width - tab_overlap;
+
   switch (tab_pos)
     {
     case GTK_POS_BOTTOM:
@@ -3198,27 +3407,26 @@
 	      if (GTK_WIDGET_VISIBLE (page->child))
 		tab_space += page->requisition.width;
 	    }
-	  if (tab_space >
-	      allocation->width - 2 * container->border_width - TAB_OVERLAP) 
+	  if (tab_space > total_width) 
 	    {
 	      showarrow = TRUE;
 	      page = focus_tab->data; 
 
-	      tab_space = allocation->width - TAB_OVERLAP -
+	      tab_space = allocation->width - tab_overlap -
 		page->requisition.width - 2 * container->border_width;
 	      if (notebook->has_after_previous)
-		tab_space -= ARROW_SPACING + ARROW_SIZE;
+		tab_space -= arrow_spacing + arrow_width;
 	      if (notebook->has_after_next)
-		tab_space -= ARROW_SPACING + ARROW_SIZE;
+		tab_space -= arrow_spacing + arrow_width;
 	      if (notebook->has_before_previous)
 		{
-		  tab_space -= ARROW_SPACING + ARROW_SIZE;
-		  child_allocation.x += ARROW_SPACING + ARROW_SIZE;
+		  tab_space -= arrow_spacing + arrow_width;
+		  child_allocation.x += arrow_spacing + arrow_width;
 		}
 	      if (notebook->has_before_next)
 		{
-		  tab_space -= ARROW_SPACING + ARROW_SIZE;
-		  child_allocation.x += ARROW_SPACING + ARROW_SIZE;
+		  tab_space -= arrow_spacing + arrow_width;
+		  child_allocation.x += arrow_spacing + arrow_width;
 		}
 	    }
 	  break;
@@ -3233,19 +3441,19 @@
 		tab_space += page->requisition.height;
 	    }
 	  if (tab_space >
-	      (allocation->height - 2 * container->border_width - TAB_OVERLAP))
+	      (allocation->height - 2 * container->border_width - tab_overlap))
 	    {
 	      showarrow = TRUE;
 	      page = focus_tab->data; 
 	      tab_space = allocation->height
-		- TAB_OVERLAP - 2 * container->border_width
+		- tab_overlap - 2 * container->border_width
 		- page->requisition.height;
 	      if (notebook->has_after_previous || notebook->has_after_next)
-		tab_space -= ARROW_SPACING + ARROW_SIZE;
+		tab_space -= arrow_spacing + arrow_height;
 	      if (notebook->has_before_previous || notebook->has_before_next)
 		{
-		  tab_space -= ARROW_SPACING + ARROW_SIZE;
-		  child_allocation.y += ARROW_SPACING + ARROW_SIZE;
+		  tab_space -= arrow_spacing + arrow_height;
+		  child_allocation.y += arrow_spacing + arrow_height;
 		}
 	    }
 	  break;
@@ -3257,6 +3465,10 @@
 	      notebook->first_tab = focus_tab;
 	      last_child = gtk_notebook_search_page (notebook, focus_tab,
 						     STEP_NEXT, TRUE);
+
+              /* Hildon: there is only one visible tab label
+                 and it doesn't fit unless it is truncated */
+              truncate = TRUE;
 	    }
 	  else
 	    {
@@ -3413,7 +3625,7 @@
 	    }
 	  tab_space -= allocation->height;
 	}
-      tab_space += 2 * container->border_width + TAB_OVERLAP;
+      tab_space += 2 * container->border_width + tab_overlap;
       tab_space *= -1;
       notebook->first_tab = gtk_notebook_search_page (notebook, NULL,
 						      STEP_NEXT, TRUE);
@@ -3432,12 +3644,29 @@
       if (showarrow) 
 	{
 	  if (notebook->has_after_previous)
-	    child_allocation.x -= ARROW_SPACING + ARROW_SIZE;
+	    child_allocation.x -= arrow_spacing + arrow_width;
 	  if (notebook->has_after_next)
-	    child_allocation.x -= ARROW_SPACING + ARROW_SIZE;
+	    child_allocation.x -= arrow_spacing + arrow_width;
 	}
      }
 
+  ideal_tab_width = (total_width / n);
+  n_expanding_tabs = 0;
+
+  while (children)
+    {
+      if (children == last_child)
+        break;
+
+      page = children->data;
+      children = gtk_notebook_search_page (notebook, children, STEP_NEXT,TRUE);
+
+      if (page->requisition.width <= ideal_tab_width)
+        n_expanding_tabs++;
+    }
+
+  children = notebook->first_tab;
+
   while (children)
     {
       if (children == last_child)
@@ -3452,9 +3681,11 @@
       children = gtk_notebook_search_page (notebook, children, STEP_NEXT,TRUE);
       
       delta = 0;
-      if (n && (showarrow || page->expand || notebook->homogeneous))
+
+      if (n && (showarrow || page->expand || notebook->homogeneous) &&
+          (page->requisition.width <= ideal_tab_width))
 	{
-	  new_fill = (tab_space * i++) / n;
+	  new_fill = (tab_space * i++) / n_expanding_tabs;
 	  delta = new_fill - old_fill;
 	  old_fill = new_fill;
 	}
@@ -3463,15 +3694,18 @@
 	{
 	case GTK_POS_TOP:
 	case GTK_POS_BOTTOM:
+          if (truncate)
+            delta *= -1;
+
 	  child_allocation.width = (page->requisition.width +
-				    TAB_OVERLAP + delta);
+				    tab_overlap + delta);
           if (is_rtl)
 	      child_allocation.x -= child_allocation.width;
 	  break;
 	case GTK_POS_LEFT:
 	case GTK_POS_RIGHT:
 	  child_allocation.height = (page->requisition.height +
-				     TAB_OVERLAP + delta);
+				     tab_overlap + delta);
 	  break;
 	}
 
@@ -3482,13 +3716,13 @@
 	case GTK_POS_TOP:
 	case GTK_POS_BOTTOM:
           if (!is_rtl)
-	     child_allocation.x += child_allocation.width - TAB_OVERLAP;
+	     child_allocation.x += child_allocation.width - tab_overlap;
           else
-             child_allocation.x += TAB_OVERLAP;
+             child_allocation.x += tab_overlap;
 	  break;
 	case GTK_POS_LEFT:
 	case GTK_POS_RIGHT:
-	  child_allocation.y += child_allocation.height - TAB_OVERLAP;
+	  child_allocation.y += child_allocation.height - tab_overlap;
 	  break;
 	}
 
@@ -3538,14 +3772,14 @@
 	    case GTK_POS_TOP:
 	    case GTK_POS_BOTTOM:
 	      child_allocation.width = (page->requisition.width +
-					TAB_OVERLAP + delta);
+					tab_overlap + delta);
               if (!is_rtl)
 	         child_allocation.x -= child_allocation.width;
 	      break;
 	    case GTK_POS_LEFT:
 	    case GTK_POS_RIGHT:
 	      child_allocation.height = (page->requisition.height +
-					 TAB_OVERLAP + delta);
+					 tab_overlap + delta);
 	      child_allocation.y -= child_allocation.height;
 	      break;
 	    }
@@ -3557,13 +3791,13 @@
 	    case GTK_POS_TOP:
 	    case GTK_POS_BOTTOM:
               if (!is_rtl)
-	         child_allocation.x += TAB_OVERLAP;
+	         child_allocation.x += tab_overlap;
               else
-                 child_allocation.x += child_allocation.width - TAB_OVERLAP;
+                 child_allocation.x += child_allocation.width - tab_overlap;
 	      break;
 	    case GTK_POS_LEFT:
 	    case GTK_POS_RIGHT:
-	      child_allocation.y += TAB_OVERLAP;
+	      child_allocation.y += tab_overlap;
 	      break;
 	    }
 
@@ -3589,8 +3823,12 @@
   gint padding;
   gint focus_width;
   gint tab_pos = get_effective_tab_pos (notebook);
+  gint tab_curvature;
 
-  gtk_widget_style_get (widget, "focus-line-width", &focus_width, NULL);
+  gtk_widget_style_get (widget,
+                        "focus-line-width", &focus_width,
+                        "tab-curvature", &tab_curvature,
+                        NULL);
   
   xthickness = widget->style->xthickness;
   ythickness = widget->style->ythickness;
@@ -3621,7 +3859,7 @@
     {
     case GTK_POS_TOP:
     case GTK_POS_BOTTOM:
-      padding = TAB_CURVATURE + focus_width + notebook->tab_hborder;
+      padding = tab_curvature + focus_width + notebook->tab_hborder;
       if (page->fill)
 	{
 	  child_allocation.x = (xthickness + focus_width +
@@ -3646,7 +3884,7 @@
       break;
     case GTK_POS_LEFT:
     case GTK_POS_RIGHT:
-      padding = TAB_CURVATURE + focus_width + notebook->tab_vborder;
+      padding = tab_curvature + focus_width + notebook->tab_vborder;
       if (page->fill)
 	{
 	  child_allocation.y = ythickness + padding;
@@ -4340,7 +4578,7 @@
     }
   page->tab_label = tab_label;
   page->menu_label = menu_label;
-  page->expand = FALSE;
+  page->expand = TRUE;
   page->fill = TRUE;
   page->pack = GTK_PACK_START; 
 
@@ -5046,6 +5284,7 @@
     {
       page->default_tab = FALSE;
       page->tab_label = tab_label;
+
       gtk_widget_set_parent (page->tab_label, GTK_WIDGET (notebook));
     }
   else