Merge lp:~bellini666/gtk/fix_1427352 into lp:~ubuntu-desktop/gtk/ubuntugtk3trusty

[Thiago Bellini]

Fix for LP:#1427352

Upstream bug: https://bugzilla.gnome.org/show_bug.cgi?id=731054

[Thiago Bellini (bellini666)]

I tested this locally and it solves the issue and is working great!

But if anyone wants to test, it is building atm on this ppa: https://launchpad.net/~hackedbellini/+archive/ubuntu/misc

=== modified file 'debian/changelog'
--- debian/changelog	2015-01-15 15:01:30 +0000
+++ debian/changelog	2015-03-02 19:52:16 +0000
@@ -1,3 +1,12 @@
+gtk+3.0 (3.10.8-0ubuntu1.5) trusty; urgency=low
+
+  * debian/patches/revert-better-resize-of-expandable-columns.patch
+    debian/patches/revert-use-minumum-natural-size-semantics.patch
+    - Port of an upstream bug:
+      https://bugzilla.gnome.org/show_bug.cgi?id=731054 (LP: #1427352)
+
+ -- Thiago Bellini Ribeiro <[e-mail]>  Mon, 02 Mar 2015 16:26:25 -0300
+
 gtk+3.0 (3.10.8-0ubuntu1.4) trusty-security; urgency=medium
 
   * debian/patches/no_popup_menu_in_gtk_window.patch
 
=== added file 'debian/patches/revert-better-resize-of-expandable-columns.patch'
--- debian/patches/revert-better-resize-of-expandable-columns.patch	1970-01-01 00:00:00 +0000
+++ debian/patches/revert-better-resize-of-expandable-columns.patch	2015-03-02 19:52:16 +0000
@@ -0,0 +1,123 @@
+From 73ff6a8e0ff307b8d14986c64918022364ff10e7 Mon Sep 17 00:00:00 2001
+From: Matthias Clasen <[e-mail]>
+Date: Sun, 1 Jun 2014 10:15:41 -0400
+Subject: Revert "Better resize of expandable columns"
+
+This reverts commit 0050d469b592ec571a5940f1ab1d842a76905e17.
+
+Conflicts:
+	gtk/gtktreeview.c
+
+--- a/gtk/gtktreeview.c
++++ b/gtk/gtktreeview.c
+@@ -2544,71 +2544,6 @@ gtk_tree_view_get_preferred_height (GtkW
+     *natural = height;
+ }
+ 
+-static void
+-gtk_tree_view_modify_column_width (GtkTreeView       *tree_view,
+-				   GtkTreeViewColumn *column,
+-				   gint               width)
+-{
+-  gboolean is_expand;
+-  gint n_expand_others;
+-  gint minimum, natural, natural_others;
+-  gint expand;
+-
+-  is_expand = gtk_tree_view_column_get_expand (column);
+-  n_expand_others = tree_view->priv->n_expand_columns - (is_expand ? 1 : 0);
+-
+-  _gtk_tree_view_column_request_width (column, &minimum, &natural);
+-  natural_others = tree_view->priv->natural_width - natural;
+-
+-  if (natural_others + width < tree_view->priv->width)
+-    {
+-      /* There is extra space that needs to be taken up by letting some other
+-       * column(s) expand: by default, the last column. */
+-      if (!n_expand_others)
+-	{
+-	  GList *last = g_list_last (tree_view->priv->columns);
+-	  while (!gtk_tree_view_column_get_visible (last->data))
+-	    last = last->prev;
+-
+-	  if (column == last->data)
+-	    return;
+-
+-	  gtk_tree_view_column_set_expand (last->data, TRUE);
+-	  n_expand_others++;
+-	}
+-
+-      /* Now try to make this column expandable also.  Solving the following
+-       * equations reveals what the natural width should be to achieve the
+-       * desired width after expanding:
+-       *
+-       *   1. natural + expand = desired_width
+-       *   2. natural + natural_others + expand * (n_expand_others + 1) = total_width
+-       *
+-       * Solution:
+-       *   expand = (total_width - natural_others - desired_width) / n_expand_others
+-       *
+-       * It is possible for the solved natural width to be less than the
+-       * minimum; in that case, we cannot let the column expand.
+-       */
+-      expand = (tree_view->priv->width - natural_others - width) / n_expand_others;
+-
+-      if (minimum + expand > width)
+-	{
+-	  if (is_expand)
+-	    gtk_tree_view_column_set_expand (column, FALSE);
+-	}
+-      else
+-	{
+-	  if (!is_expand)
+-	    gtk_tree_view_column_set_expand (column, TRUE);
+-
+-	  width -= expand;
+-	}
+-    }
+-
+-  gtk_tree_view_column_set_fixed_width (column, width);
+-}
+-
+ static int
+ gtk_tree_view_calculate_width_before_expander (GtkTreeView *tree_view)
+ {
+@@ -3386,6 +3321,9 @@ gtk_tree_view_button_press (GtkWidget
+ 					     drag_data);
+ 
+ 	  column_width = gtk_tree_view_column_get_width (column);
++	  gtk_tree_view_column_set_fixed_width (column, column_width);
++	  gtk_tree_view_column_set_expand (column, FALSE);
++
+ 	  gdk_window_get_device_position (tree_view->priv->bin_window,
+ 					  gdk_event_get_device ((GdkEvent *) event),
+ 					  &x, NULL, NULL);
+@@ -4137,14 +4075,14 @@ gtk_tree_view_motion_resize_column (GtkW
+   gdk_window_get_device_position (tree_view->priv->bin_window,
+ 				  gdk_event_get_device ((GdkEvent *) event),
+ 				  &x, NULL, NULL);
+-
++ 
+   if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL)
+     new_width = MAX (tree_view->priv->x_drag - x, 0);
+   else
+     new_width = MAX (x - tree_view->priv->x_drag, 0);
+-
+-  if (new_width != gtk_tree_view_column_get_width (column))
+-    gtk_tree_view_modify_column_width (tree_view, column, new_width);
++  
++  if (new_width != gtk_tree_view_column_get_fixed_width (column))
++    gtk_tree_view_column_set_fixed_width (column, new_width);
+ 
+   return FALSE;
+ }
+@@ -5869,7 +5807,8 @@ gtk_tree_view_key_press (GtkWidget   *wi
+ 	      column_width = column_width + 2;
+             }
+ 
+-	  gtk_tree_view_modify_column_width (tree_view, column, column_width);
++	  gtk_tree_view_column_set_fixed_width (column, column_width);
++	  gtk_tree_view_column_set_expand (column, FALSE);
+           return TRUE;
+         }
+ 
 
=== added file 'debian/patches/revert-use-minumum-natural-size-semantics.patch'
--- debian/patches/revert-use-minumum-natural-size-semantics.patch	1970-01-01 00:00:00 +0000
+++ debian/patches/revert-use-minumum-natural-size-semantics.patch	2015-03-02 19:52:16 +0000
@@ -0,0 +1,364 @@
+From a3cd0ee7d8a610feff39984254306cec4a6c9c73 Mon Sep 17 00:00:00 2001
+From: Matthias Clasen <[e-mail]>
+Date: Sun, 1 Jun 2014 10:16:01 -0400
+Subject: Revert "Use minimum/natural size semantics"
+
+This reverts commit 6d53c2339f79baa0b295ecc614f41f9daab2e132.
+
+https://bugzilla.gnome.org/show_bug.cgi?id=731054 showed some
+major regressions caused by this commit.
+
+--- a/gtk/gtktreeprivate.h
++++ b/gtk/gtktreeprivate.h
+@@ -100,9 +100,7 @@ void _gtk_tree_view_column_unrealize_but
+  
+ void _gtk_tree_view_column_set_tree_view    (GtkTreeViewColumn *column,
+ 					     GtkTreeView       *tree_view);
+-void _gtk_tree_view_column_request_width    (GtkTreeViewColumn *tree_column,
+-					     gint              *minimum,
+-					     gint              *natural);
++gint _gtk_tree_view_column_request_width    (GtkTreeViewColumn *tree_column);
+ void _gtk_tree_view_column_allocate         (GtkTreeViewColumn *tree_column,
+ 					     int                x_offset,
+ 					     int                width);
+--- a/gtk/gtktreeview.c
++++ b/gtk/gtktreeview.c
+@@ -386,10 +386,10 @@ struct _GtkTreeViewPrivate
+   gint drag_pos;
+   gint x_drag;
+ 
+-  /* Column width allocation */
+-  gint minimum_width;
+-  gint natural_width;
+-  gint n_expand_columns;
++  /* Non-interactive Header Resizing, expand flag support */
++  gint last_extra_space;
++  gint last_extra_space_per_column;
++  gint last_number_of_expand_columns;
+ 
+   /* ATK Hack */
+   GtkTreeDestroyCountFunc destroy_count_func;
+@@ -494,6 +494,8 @@ struct _GtkTreeViewPrivate
+ 
+   guint in_scroll : 1;
+ 
++  guint post_validation_flag : 1;
++
+   /* Whether our key press handler is to avoid sending an unhandled binding to the search entry */
+   guint search_entry_avoid_unhandled_binding : 1;
+ 
+@@ -1749,9 +1751,6 @@ gtk_tree_view_init (GtkTreeView *tree_vi
+   tree_view->priv->header_height = 1;
+   tree_view->priv->x_drag = 0;
+   tree_view->priv->drag_pos = -1;
+-  tree_view->priv->minimum_width = 0;
+-  tree_view->priv->natural_width = 0;
+-  tree_view->priv->n_expand_columns = 0;
+   tree_view->priv->header_has_focus = FALSE;
+   tree_view->priv->pressed_button = -1;
+   tree_view->priv->press_start_x = -1;
+@@ -1785,6 +1784,8 @@ gtk_tree_view_init (GtkTreeView *tree_vi
+ 
+   tree_view->priv->tooltip_column = -1;
+ 
++  tree_view->priv->post_validation_flag = FALSE;
++
+   tree_view->priv->last_button_x = -1;
+   tree_view->priv->last_button_y = -1;
+ 
+@@ -2502,16 +2503,12 @@ gtk_tree_view_get_preferred_width (GtkWi
+   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
+   GList *list;
+   GtkTreeViewColumn *column;
+-  gint column_minimum, column_natural;
++  gint width = 0;
+ 
+   /* we validate some rows initially just to make sure we have some size.
+    * In practice, with a lot of static lists, this should get a good width.
+    */
+   do_validate_rows (tree_view, FALSE);
+-  
+-  tree_view->priv->minimum_width = 0;
+-  tree_view->priv->natural_width = 0;
+-  tree_view->priv->n_expand_columns = 0;
+ 
+   /* keep this in sync with size_allocate below */
+   for (list = tree_view->priv->columns; list; list = list->next)
+@@ -2520,18 +2517,13 @@ gtk_tree_view_get_preferred_width (GtkWi
+       if (!gtk_tree_view_column_get_visible (column) || column == tree_view->priv->drag_column)
+ 	continue;
+ 
+-      _gtk_tree_view_column_request_width (column, &column_minimum, &column_natural);
+-      tree_view->priv->minimum_width += column_minimum;
+-      tree_view->priv->natural_width += column_natural;
+-
+-      if (gtk_tree_view_column_get_expand (column))
+-	tree_view->priv->n_expand_columns++;
++      width += _gtk_tree_view_column_request_width (column);
+     }
+ 
+   if (minimum != NULL)
+-    *minimum = tree_view->priv->minimum_width;
++    *minimum = width;
+   if (natural != NULL)
+-    *natural = tree_view->priv->natural_width;
++    *natural = width;
+ }
+ 
+ static void
+@@ -2646,9 +2638,12 @@ gtk_tree_view_size_allocate_columns (Gtk
+   GList *list, *first_column, *last_column;
+   GtkTreeViewColumn *column;
+   GtkAllocation widget_allocation;
+-  gint minimum_width, natural_width, n_expand_columns, width;
+-  gint column_minimum, column_natural, column_width;
++  gint width = 0;
++  gint extra, extra_per_column, extra_for_last;
++  gint full_requested_width = 0;
++  gint number_of_expand_columns = 0;
+   gboolean rtl;
++  gboolean update_expand;
+   
+   tree_view = GTK_TREE_VIEW (widget);
+ 
+@@ -2668,65 +2663,111 @@ gtk_tree_view_size_allocate_columns (Gtk
+ 
+   rtl = (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL);
+ 
+-  gtk_widget_get_allocation (widget, &widget_allocation);
++  /* find out how many extra space and expandable columns we have */
++  for (list = tree_view->priv->columns; list != last_column->next; list = list->next)
++    {
++      column = (GtkTreeViewColumn *)list->data;
+ 
+-  minimum_width = tree_view->priv->minimum_width;
+-  natural_width = tree_view->priv->natural_width;
+-  n_expand_columns = tree_view->priv->n_expand_columns;
++      if (!gtk_tree_view_column_get_visible (column) || column == tree_view->priv->drag_column)
++	continue;
+ 
+-  width = MAX (widget_allocation.width, minimum_width);
++      full_requested_width += _gtk_tree_view_column_request_width (column);
+ 
+-  /* We change the width here.  The user might have been resizing columns,
+-   * which changes the total width of the tree view.  This is of
+-   * importance for getting the horizontal scroll bar right.
++      if (gtk_tree_view_column_get_expand (column))
++	number_of_expand_columns++;
++    }
++
++  /* Only update the expand value if the width of the widget has changed,
++   * or the number of expand columns has changed, or if there are no expand
++   * columns, or if we didn't have an size-allocation yet after the
++   * last validated node.
+    */
+-  if (tree_view->priv->width != width)
++  update_expand = (width_changed && *width_changed == TRUE)
++      || number_of_expand_columns != tree_view->priv->last_number_of_expand_columns
++      || number_of_expand_columns == 0
++      || tree_view->priv->post_validation_flag == TRUE;
++
++  tree_view->priv->post_validation_flag = FALSE;
++
++  gtk_widget_get_allocation (widget, &widget_allocation);
++  if (!update_expand)
+     {
+-      tree_view->priv->width = width;
+-      if (width_changed)
+-        *width_changed = TRUE;
++      extra = tree_view->priv->last_extra_space;
++      extra_for_last = MAX (widget_allocation.width - full_requested_width - extra, 0);
+     }
++  else
++    {
++      extra = MAX (widget_allocation.width - full_requested_width, 0);
++      extra_for_last = 0;
++
++      tree_view->priv->last_extra_space = extra;
++    }
++
++  if (number_of_expand_columns > 0)
++    extra_per_column = extra/number_of_expand_columns;
++  else
++    extra_per_column = 0;
+ 
+-  /* iterate through columns in reverse order */
+-  for (list = (rtl ? first_column : last_column); 
+-       list != (rtl ? last_column->next : first_column->prev);
+-       list = (rtl ? list->next : list->prev)) 
++  if (update_expand)
+     {
++      tree_view->priv->last_extra_space_per_column = extra_per_column;
++      tree_view->priv->last_number_of_expand_columns = number_of_expand_columns;
++    }
++
++  for (list = (rtl ? last_column : first_column); 
++       list != (rtl ? first_column->prev : last_column->next);
++       list = (rtl ? list->prev : list->next)) 
++    {
++      gint column_width;
++
+       column = list->data;
+ 
+       if (!gtk_tree_view_column_get_visible (column) || column == tree_view->priv->drag_column)
+ 	continue;
+ 
+-      _gtk_tree_view_column_request_width (column, &column_minimum, &column_natural);
+-      
+-      column_width = column_natural;
++      column_width = _gtk_tree_view_column_request_width (column);
+ 
+-      if (width > natural_width)
+-        {
+-	  /* We need to expand some columns.  If there are none marked to
+-	   * expand, give all the extra space to the last column. */
+-	  if (n_expand_columns == 0)
++      if (gtk_tree_view_column_get_expand (column))
++	{
++	  if (number_of_expand_columns == 1)
+ 	    {
+-	      column_width = column_natural + (width - natural_width);
++	      /* We add the remander to the last column as
++	       * */
++	      column_width += extra;
+ 	    }
+-	  else if (gtk_tree_view_column_get_expand (column))
++	  else
+ 	    {
+-	      column_width = column_natural + (width - natural_width) / n_expand_columns;
+-	      n_expand_columns--;
++	      column_width += extra_per_column;
++	      extra -= extra_per_column;
++	      number_of_expand_columns --;
+ 	    }
+-        }
+-      else if (width < natural_width)
++	}
++      else if (number_of_expand_columns == 0 &&
++	       list == last_column)
+ 	{
+-	  /* We need to shrink some columns.  Starting with later columns,
+-	   * shrink each one down to its minimum width as necessary. */
+-	  column_width = MAX (column_natural + (width - natural_width), column_minimum);
++	  column_width += extra;
+ 	}
+-	
+-      _gtk_tree_view_column_allocate (column, width - column_width, column_width);
+-      
+-      minimum_width -= column_minimum;
+-      natural_width -= column_natural;
+-      width -= column_width;
++
++      /* In addition to expand, the last column can get even more
++       * extra space so all available space is filled up.
++       */
++      if (extra_for_last > 0 && list == last_column)
++	column_width += extra_for_last;
++
++      _gtk_tree_view_column_allocate (column, width, column_width);
++
++      width += column_width;
++    }
++
++  /* We change the width here.  The user might have been resizing columns,
++   * which changes the total width of the tree view.  This is of
++   * importance for getting the horizontal scroll bar right.
++   */
++  if (tree_view->priv->width != width)
++    {
++      tree_view->priv->width = width;
++      if (width_changed)
++        *width_changed = TRUE;
+     }
+ }
+ 
+@@ -6241,6 +6282,7 @@ validate_row (GtkTreeView *tree_view,
+       _gtk_rbtree_node_set_height (tree, node, height);
+     }
+   _gtk_rbtree_node_mark_valid (tree, node);
++  tree_view->priv->post_validation_flag = TRUE;
+ 
+   return retval;
+ }
+--- a/gtk/gtktreeviewcolumn.c
++++ b/gtk/gtktreeviewcolumn.c
+@@ -2087,48 +2087,48 @@ gtk_tree_view_column_get_x_offset (GtkTr
+   return tree_column->priv->x_offset;
+ }
+ 
+-void
+-_gtk_tree_view_column_request_width (GtkTreeViewColumn *tree_column,
+-                                     gint              *minimum,
+-                                     gint              *natural)
++gint
++_gtk_tree_view_column_request_width (GtkTreeViewColumn *tree_column)
+ {
+-  GtkTreeViewColumnPrivate *priv = tree_column->priv;
+-  gint minimum_width = 1, natural_width = 1;
+-  gint button_minimum, button_natural;
++  GtkTreeViewColumnPrivate *priv;
++  gint real_requested_width;
++
++  priv = tree_column->priv;
+ 
+-  if (priv->column_type != GTK_TREE_VIEW_COLUMN_FIXED)
++  if (priv->fixed_width != -1)
+     {
+-      gtk_cell_area_context_get_preferred_width (priv->cell_area_context, &minimum_width, &natural_width);
+-      minimum_width += priv->padding;
+-      natural_width += priv->padding;
+-
+-      if (gtk_tree_view_get_headers_visible (GTK_TREE_VIEW (priv->tree_view)))
+-        {
+-          gtk_widget_get_preferred_width (priv->button, &button_minimum, &button_natural);
+-          minimum_width = MAX (minimum_width, button_minimum);
+-          natural_width = MAX (natural_width, button_natural);
+-        }
++      real_requested_width = priv->fixed_width;
+     }
++  else if (gtk_tree_view_get_headers_visible (GTK_TREE_VIEW (priv->tree_view)))
++    {
++      gint button_request;
++      gint requested_width;
+ 
+-  if (priv->fixed_width != -1)
+-    natural_width = MAX (priv->fixed_width, minimum_width);
++      gtk_cell_area_context_get_preferred_width (priv->cell_area_context, &requested_width, NULL);
++      requested_width += priv->padding;
+ 
+-  if (priv->min_width != -1)
++      gtk_widget_get_preferred_width (priv->button, &button_request, NULL);
++      real_requested_width = MAX (requested_width, button_request);
++    }
++  else
+     {
+-      minimum_width = MAX (minimum_width, priv->min_width);
+-      natural_width = MAX (natural_width, priv->min_width);
++      gint requested_width;
++
++      gtk_cell_area_context_get_preferred_width (priv->cell_area_context, &requested_width, NULL);
++      requested_width += priv->padding;
++
++      real_requested_width = requested_width;
++      if (real_requested_width < 0)
++        real_requested_width = 0;
+     }
+ 
++  if (priv->min_width != -1)
++    real_requested_width = MAX (real_requested_width, priv->min_width);
++
+   if (priv->max_width != -1)
+-    {
+-      minimum_width = MIN (minimum_width, priv->max_width);
+-      natural_width = MIN (natural_width, priv->max_width);
+-    }
++    real_requested_width = MIN (real_requested_width, priv->max_width);
+ 
+-  if (minimum != NULL)
+-    *minimum = minimum_width;
+-  if (natural != NULL)
+-    *natural = natural_width;
++  return real_requested_width;
+ }
+ 
+ void
 
=== modified file 'debian/patches/series'
--- debian/patches/series	2015-01-15 15:01:30 +0000
+++ debian/patches/series	2015-03-02 19:52:16 +0000
@@ -24,3 +24,5 @@
 use-secrets-service-for-cups-auth_info.patch
 printing-initialize-auth_info.patch
 no_popup_menu_in_gtk_window.patch
+revert-use-minumum-natural-size-semantics.patch
+revert-better-resize-of-expandable-columns.patch