1 From e6ec96617a5e97e45109c1df26f1011488a320b2 Mon Sep 17 00:00:00 2001
   2 From: Kristian Rietveld <kris@gtk.org>
   3 Date: Tue, 8 Jul 2008 19:52:51 +0300
   4 Subject: [PATCH] Removed fixed-height-mode; lifted requirement to fully validate the rbtree.
   5 
   6 * fixed-height-mode property and getter/setter are still there, but
   7   non-functional.
   8 * The validate_rows_timers() is gone, as is validate_rows_handler().
   9 * gtk_tree_view_size_request() now estimates the column widths and
  10   height of the tree from 500 rows.
  11 * validate_visible_area() now validates three times as much rows
  12   (3 "pages") so that arrow up/down and page up/down function properly.
  13 * (Superfluous) call to _clamp_node_visible() has been removed, since it
  14   breaks scrolling in some cases.
  15 * The row_* signal handlers still need updating; fixed height mode support
  16   has been removed.
  17 * scroll_to_cell() now also direct on not-fully validated trees and
  18   when a size request/allocation is pending.  The old "delayed" scrolling
  19   method is still used if the widget is not visible at time of call or
  20   when the destination has not yet been validated.
  21 ---
  22  gtk/gtktreeprivate.h |    7 +-
  23  gtk/gtktreeview.c    |  371 +++++++++++++------------------------------------
  24  2 files changed, 100 insertions(+), 278 deletions(-)
  25 
  26 diff --git a/gtk/gtktreeprivate.h b/gtk/gtktreeprivate.h
  27 index 51bb951..e3b754e 100644
  28 --- a/gtk/gtktreeprivate.h
  29 +++ b/gtk/gtktreeprivate.h
  30 @@ -100,6 +100,7 @@ struct _GtkTreeViewPrivate
  31    GList *children;
  32    gint width;
  33    gint height;
  34 +  gint average_row_height;
  35    gint expander_size;
  36  
  37    GtkAdjustment *hadjustment;
  38 @@ -192,9 +193,6 @@ struct _GtkTreeViewPrivate
  39    GtkRBNode *rubber_band_end_node;
  40    GtkRBTree *rubber_band_end_tree;
  41  
  42 -  /* fixed height */
  43 -  gint fixed_height;
  44 -
  45    /* Scroll-to functionality when unrealized */
  46    GtkTreeRowReference *scroll_to_path;
  47    GtkTreeViewColumn *scroll_to_column;
  48 @@ -202,9 +200,6 @@ struct _GtkTreeViewPrivate
  49    gfloat scroll_to_col_align;
  50    guint scroll_to_use_align : 1;
  51  
  52 -  guint fixed_height_mode : 1;
  53 -  guint fixed_height_check : 1;
  54 -
  55    guint reorderable : 1;
  56    guint header_has_focus : 1;
  57    guint drag_column_window_state : 3;
  58 diff --git a/gtk/gtktreeview.c b/gtk/gtktreeview.c
  59 index 554df04..81a0a65 100644
  60 --- a/gtk/gtktreeview.c
  61 +++ b/gtk/gtktreeview.c
  62 @@ -120,7 +120,7 @@ enum {
  63    PROP_RULES_HINT,
  64    PROP_ENABLE_SEARCH,
  65    PROP_SEARCH_COLUMN,
  66 -  PROP_FIXED_HEIGHT_MODE,
  67 +  PROP_FIXED_HEIGHT_MODE, /* DEPRECATED */
  68    PROP_HOVER_SELECTION,
  69    PROP_HOVER_EXPAND,
  70    PROP_SHOW_EXPANDERS,
  71 @@ -278,10 +278,12 @@ static gboolean validate_row             (GtkTreeView *tree_view,
  72  					  GtkTreeIter *iter,
  73  					  GtkTreePath *path);
  74  static void     validate_visible_area    (GtkTreeView *tree_view);
  75 -static gboolean validate_rows_handler    (GtkTreeView *tree_view);
  76 -static gboolean do_validate_rows         (GtkTreeView *tree_view,
  77 -					  gboolean     size_request);
  78  static gboolean validate_rows            (GtkTreeView *tree_view);
  79 +static gboolean do_validate_rows         (GtkTreeView *tree_view,
  80 +					  gboolean     size_request,
  81 +                                          int         *count,
  82 +                                          int         *height);
  83 +
  84  static gboolean presize_handler_callback (gpointer     data);
  85  static void     install_presize_handler  (GtkTreeView *tree_view);
  86  static void     install_scroll_sync_handler (GtkTreeView *tree_view);
  87 @@ -362,9 +364,6 @@ static void     gtk_tree_view_real_set_cursor                (GtkTreeView
  88  							      gboolean            clear_and_select,
  89  							      gboolean            clamp_node);
  90  static gboolean gtk_tree_view_has_special_cell               (GtkTreeView        *tree_view);
  91 -static void     column_sizing_notify                         (GObject            *object,
  92 -                                                              GParamSpec         *pspec,
  93 -                                                              gpointer            data);
  94  static gboolean expand_collapse_timeout                      (gpointer            data);
  95  static void     add_expand_collapse_timeout                  (GtkTreeView        *tree_view,
  96                                                                GtkRBTree          *tree,
  97 @@ -652,7 +651,7 @@ gtk_tree_view_class_init (GtkTreeViewClass *class)
  98       * Please see gtk_tree_view_set_fixed_height_mode() for more 
  99       * information on this option.
 100       *
 101 -     * Since: 2.4
 102 +     * Since: 2.4 (DEPRECATED)
 103       **/
 104      g_object_class_install_property (o_class,
 105                                       PROP_FIXED_HEIGHT_MODE,
 106 @@ -1342,9 +1341,6 @@ gtk_tree_view_init (GtkTreeView *tree_view)
 107    tree_view->priv->reorderable = FALSE;
 108    tree_view->priv->presize_handler_timer = 0;
 109    tree_view->priv->scroll_sync_timer = 0;
 110 -  tree_view->priv->fixed_height = -1;
 111 -  tree_view->priv->fixed_height_mode = FALSE;
 112 -  tree_view->priv->fixed_height_check = 0;
 113    gtk_tree_view_set_adjustments (tree_view, NULL, NULL);
 114    tree_view->priv->selection = _gtk_tree_selection_new_with_tree_view (tree_view);
 115    tree_view->priv->enable_search = TRUE;
 116 @@ -1355,6 +1351,7 @@ gtk_tree_view_init (GtkTreeView *tree_view)
 117    tree_view->priv->typeselect_flush_timeout = 0;
 118    tree_view->priv->init_hadjust_value = TRUE;    
 119    tree_view->priv->width = 0;
 120 +  tree_view->priv->average_row_height = -1;
 121            
 122    tree_view->priv->hover_selection = FALSE;
 123    tree_view->priv->hover_expand = FALSE;
 124 @@ -1416,9 +1413,6 @@ gtk_tree_view_set_property (GObject         *object,
 125      case PROP_SEARCH_COLUMN:
 126        gtk_tree_view_set_search_column (tree_view, g_value_get_int (value));
 127        break;
 128 -    case PROP_FIXED_HEIGHT_MODE:
 129 -      gtk_tree_view_set_fixed_height_mode (tree_view, g_value_get_boolean (value));
 130 -      break;
 131      case PROP_HOVER_SELECTION:
 132        tree_view->priv->hover_selection = g_value_get_boolean (value);
 133        break;
 134 @@ -1491,9 +1485,6 @@ gtk_tree_view_get_property (GObject    *object,
 135      case PROP_SEARCH_COLUMN:
 136        g_value_set_int (value, tree_view->priv->search_column);
 137        break;
 138 -    case PROP_FIXED_HEIGHT_MODE:
 139 -      g_value_set_boolean (value, tree_view->priv->fixed_height_mode);
 140 -      break;
 141      case PROP_HOVER_SELECTION:
 142        g_value_set_boolean (value, tree_view->priv->hover_selection);
 143        break;
 144 @@ -1879,12 +1870,6 @@ gtk_tree_view_unrealize (GtkWidget *widget)
 145        priv->presize_handler_timer = 0;
 146      }
 147  
 148 -  if (priv->validate_rows_timer != 0)
 149 -    {
 150 -      g_source_remove (priv->validate_rows_timer);
 151 -      priv->validate_rows_timer = 0;
 152 -    }
 153 -
 154    if (priv->scroll_sync_timer != 0)
 155      {
 156        g_source_remove (priv->scroll_sync_timer);
 157 @@ -2031,11 +2016,26 @@ gtk_tree_view_size_request (GtkWidget      *widget,
 158    GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
 159    GList *tmp_list;
 160  
 161 -  /* we validate GTK_TREE_VIEW_NUM_ROWS_PER_IDLE rows initially just to make
 162 -   * sure we have some size. In practice, with a lot of static lists, this
 163 -   * should get a good width.
 164 -   */
 165 -  do_validate_rows (tree_view, FALSE);
 166 +  if (tree_view->priv->average_row_height == -1)
 167 +    {
 168 +      int count = 0;
 169 +      int height = 0;
 170 +
 171 +      /* we validate GTK_TREE_VIEW_NUM_ROWS_PER_IDLE rows initially just to make
 172 +       * sure we have some size. In practice, with a lot of static lists, this
 173 +       * should get a good width.
 174 +       */
 175 +      do_validate_rows (tree_view, FALSE, &count, &height);
 176 +
 177 +      if (count > 0)
 178 +        {
 179 +          tree_view->priv->average_row_height = height / count;
 180 +
 181 +          _gtk_rbtree_set_fixed_height (tree_view->priv->tree,
 182 +                                        tree_view->priv->average_row_height, FALSE);
 183 +        }
 184 +    }
 185 +  
 186    gtk_tree_view_size_request_columns (tree_view);
 187    gtk_tree_view_update_size (GTK_TREE_VIEW (widget));
 188  
 189 @@ -2315,28 +2315,28 @@ gtk_tree_view_size_allocate (GtkWidget     *widget,
 190    tree_view->priv->hadjustment->upper = MAX (tree_view->priv->hadjustment->page_size, tree_view->priv->width);
 191  
 192    if (gtk_widget_get_direction(widget) == GTK_TEXT_DIR_RTL)   
 193 -     {
 194 +    {
 195        if (allocation->width < tree_view->priv->width)
 196 -         {
 197 -         if (tree_view->priv->init_hadjust_value)
 198 -           {
 199 -           tree_view->priv->hadjustment->value = MAX (tree_view->priv->width - allocation->width, 0);
 200 -           tree_view->priv->init_hadjust_value = FALSE;
 201 -           }
 202 -         else if(allocation->width != old_width)
 203 -           tree_view->priv->hadjustment->value = CLAMP(tree_view->priv->hadjustment->value - allocation->width + old_width, 0, tree_view->priv->width - allocation->width);
 204 -         else
 205 -           tree_view->priv->hadjustment->value = CLAMP(tree_view->priv->width - (tree_view->priv->prev_width - tree_view->priv->hadjustment->value), 0, tree_view->priv->width - allocation->width);
 206 -         }
 207 +        {
 208 +          if (tree_view->priv->init_hadjust_value)
 209 +            {
 210 +              tree_view->priv->hadjustment->value = MAX (tree_view->priv->width - allocation->width, 0);
 211 +              tree_view->priv->init_hadjust_value = FALSE;
 212 +            }
 213 +          else if (allocation->width != old_width)
 214 +            tree_view->priv->hadjustment->value = CLAMP(tree_view->priv->hadjustment->value - allocation->width + old_width, 0, tree_view->priv->width - allocation->width);
 215 +          else
 216 +            tree_view->priv->hadjustment->value = CLAMP(tree_view->priv->width - (tree_view->priv->prev_width - tree_view->priv->hadjustment->value), 0, tree_view->priv->width - allocation->width);
 217 +        }
 218        else
 219 -         {
 220 -         tree_view->priv->hadjustment->value = 0;
 221 -         tree_view->priv->init_hadjust_value = TRUE;
 222 -         }
 223 -     }
 224 +        {
 225 +          tree_view->priv->hadjustment->value = 0;
 226 +          tree_view->priv->init_hadjust_value = TRUE;
 227 +        }
 228 +    }
 229    else
 230 -     if (tree_view->priv->hadjustment->value + allocation->width > tree_view->priv->width)
 231 -        tree_view->priv->hadjustment->value = MAX (tree_view->priv->width - allocation->width, 0);
 232 +    if (tree_view->priv->hadjustment->value + allocation->width > tree_view->priv->width)
 233 +      tree_view->priv->hadjustment->value = MAX (tree_view->priv->width - allocation->width, 0);
 234  
 235    gtk_adjustment_changed (tree_view->priv->hadjustment);
 236  
 237 @@ -5846,6 +5846,13 @@ validate_visible_area (GtkTreeView *tree_view)
 238    if (total_height == 0)
 239      return;
 240  
 241 +  /* We validate the pages below and above this one too, so the scrolls done by
 242 +   * the arrow keys and page up/down can be done properly.
 243 +   *
 244 +   * FIXME: probably does not work properly yet with scroll_to_path == !NULL
 245 +   */
 246 +  total_height *= 3;
 247 +
 248    /* First, we check to see if we need to scroll anywhere
 249     */
 250    if (tree_view->priv->scroll_to_path)
 251 @@ -5975,8 +5982,12 @@ validate_visible_area (GtkTreeView *tree_view)
 252  	  if (validate_row (tree_view, tree, node, &iter, path))
 253  	    size_changed = TRUE;
 254  	}
 255 -      area_above = 0;
 256 -      area_below = total_height - gtk_tree_view_get_height_of_node (tree_view, node);
 257 +
 258 +      /* total_height is the height of three pages; we validate the pages above
 259 +       * and below this one too.
 260 +       */
 261 +      area_above = total_height / 2;
 262 +      area_below = (total_height / 2) - gtk_tree_view_get_height_of_node (tree_view, node);
 263      }
 264  
 265    above_path = gtk_tree_path_copy (path);
 266 @@ -6182,37 +6193,6 @@ validate_visible_area (GtkTreeView *tree_view)
 267      gtk_widget_queue_draw (GTK_WIDGET (tree_view));
 268  }
 269  
 270 -static void
 271 -initialize_fixed_height_mode (GtkTreeView *tree_view)
 272 -{
 273 -  if (!tree_view->priv->tree)
 274 -    return;
 275 -
 276 -  if (tree_view->priv->fixed_height < 0)
 277 -    {
 278 -      GtkTreeIter iter;
 279 -      GtkTreePath *path;
 280 -
 281 -      GtkRBTree *tree = NULL;
 282 -      GtkRBNode *node = NULL;
 283 -
 284 -      tree = tree_view->priv->tree;
 285 -      node = tree->root;
 286 -
 287 -      path = _gtk_tree_view_find_path (tree_view, tree, node);
 288 -      gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
 289 -
 290 -      validate_row (tree_view, tree, node, &iter, path);
 291 -
 292 -      gtk_tree_path_free (path);
 293 -
 294 -      tree_view->priv->fixed_height = gtk_tree_view_get_height_of_node (tree_view, node);
 295 -    }
 296 -
 297 -   _gtk_rbtree_set_fixed_height (tree_view->priv->tree,
 298 -                                 tree_view->priv->fixed_height, TRUE);
 299 -}
 300 -
 301  /* Our strategy for finding nodes to validate is a little convoluted.  We find
 302   * the left-most uninvalidated node.  We then try walking right, validating
 303   * nodes.  Once we find a valid node, we repeat the previous process of finding
 304 @@ -6220,7 +6200,10 @@ initialize_fixed_height_mode (GtkTreeView *tree_view)
 305   */
 306  
 307  static gboolean
 308 -do_validate_rows (GtkTreeView *tree_view, gboolean queue_resize)
 309 +do_validate_rows (GtkTreeView *tree_view,
 310 +                  gboolean     queue_resize,
 311 +                  int         *count,
 312 +                  int         *height)
 313  {
 314    GtkRBTree *tree = NULL;
 315    GtkRBNode *node = NULL;
 316 @@ -6230,22 +6213,11 @@ do_validate_rows (GtkTreeView *tree_view, gboolean queue_resize)
 317    GtkTreeIter iter;
 318    gint i = 0;
 319  
 320 -  gint prev_height = -1;
 321 -  gboolean fixed_height = TRUE;
 322 -
 323    g_assert (tree_view);
 324  
 325    if (tree_view->priv->tree == NULL)
 326        return FALSE;
 327  
 328 -  if (tree_view->priv->fixed_height_mode)
 329 -    {
 330 -      if (tree_view->priv->fixed_height < 0)
 331 -        initialize_fixed_height_mode (tree_view);
 332 -
 333 -      return FALSE;
 334 -    }
 335 -
 336    do
 337      {
 338        if (! GTK_RBNODE_FLAG_SET (tree_view->priv->tree->root, GTK_RBNODE_DESCENDANTS_INVALID))
 339 @@ -6310,28 +6282,16 @@ do_validate_rows (GtkTreeView *tree_view, gboolean queue_resize)
 340        validated_area = validate_row (tree_view, tree, node, &iter, path) ||
 341                         validated_area;
 342  
 343 -      if (!tree_view->priv->fixed_height_check)
 344 -        {
 345 -	  gint height;
 346 +      if (height)
 347 +        *height += GTK_RBNODE_GET_HEIGHT (node);
 348  
 349 -	  height = gtk_tree_view_get_height_of_node (tree_view, node);
 350 -	  if (prev_height < 0)
 351 -	    prev_height = height;
 352 -	  else if (prev_height != height)
 353 -	    fixed_height = FALSE;
 354 -	}
 355 +      if (count)
 356 +        (*count)++;
 357  
 358        i++;
 359      }
 360    while (i < GTK_TREE_VIEW_NUM_ROWS_PER_IDLE);
 361  
 362 -  if (!tree_view->priv->fixed_height_check)
 363 -   {
 364 -     if (fixed_height)
 365 -       _gtk_rbtree_set_fixed_height (tree_view->priv->tree, prev_height, FALSE);
 366 -
 367 -     tree_view->priv->fixed_height_check = 1;
 368 -   }
 369    
 370   done:
 371    if (validated_area)
 372 @@ -6361,29 +6321,8 @@ validate_rows (GtkTreeView *tree_view)
 373  {
 374    gboolean retval;
 375    
 376 -  retval = do_validate_rows (tree_view, TRUE);
 377 +  retval = do_validate_rows (tree_view, TRUE, NULL, NULL);
 378    
 379 -  if (! retval && tree_view->priv->validate_rows_timer)
 380 -    {
 381 -      g_source_remove (tree_view->priv->validate_rows_timer);
 382 -      tree_view->priv->validate_rows_timer = 0;
 383 -    }
 384 -
 385 -  return retval;
 386 -}
 387 -
 388 -static gboolean
 389 -validate_rows_handler (GtkTreeView *tree_view)
 390 -{
 391 -  gboolean retval;
 392 -
 393 -  retval = do_validate_rows (tree_view, TRUE);
 394 -  if (! retval && tree_view->priv->validate_rows_timer)
 395 -    {
 396 -      g_source_remove (tree_view->priv->validate_rows_timer);
 397 -      tree_view->priv->validate_rows_timer = 0;
 398 -    }
 399 -
 400    return retval;
 401  }
 402  
 403 @@ -6398,19 +6337,6 @@ do_presize_handler (GtkTreeView *tree_view)
 404      }
 405    validate_visible_area (tree_view);
 406    tree_view->priv->presize_handler_timer = 0;
 407 -
 408 -  if (tree_view->priv->fixed_height_mode)
 409 -    {
 410 -      GtkRequisition requisition;
 411 -
 412 -      gtk_widget_size_request (GTK_WIDGET (tree_view), &requisition);
 413 -
 414 -      tree_view->priv->hadjustment->upper = MAX (tree_view->priv->hadjustment->upper, (gfloat)requisition.width);
 415 -      tree_view->priv->vadjustment->upper = MAX (tree_view->priv->vadjustment->upper, (gfloat)requisition.height);
 416 -      gtk_adjustment_changed (tree_view->priv->hadjustment);
 417 -      gtk_adjustment_changed (tree_view->priv->vadjustment);
 418 -      gtk_widget_queue_resize (GTK_WIDGET (tree_view));
 419 -    }
 420  		   
 421    return FALSE;
 422  }
 423 @@ -6434,11 +6360,6 @@ install_presize_handler (GtkTreeView *tree_view)
 424        tree_view->priv->presize_handler_timer =
 425  	gdk_threads_add_idle_full (GTK_PRIORITY_RESIZE - 2, presize_handler_callback, tree_view, NULL);
 426      }
 427 -  if (! tree_view->priv->validate_rows_timer)
 428 -    {
 429 -      tree_view->priv->validate_rows_timer =
 430 -	gdk_threads_add_idle_full (GTK_TREE_VIEW_PRIORITY_VALIDATE, (GSourceFunc) validate_rows_handler, tree_view, NULL);
 431 -    }
 432  }
 433  
 434  static gboolean
 435 @@ -7684,18 +7605,6 @@ gtk_tree_view_has_special_cell (GtkTreeView *tree_view)
 436    return FALSE;
 437  }
 438  
 439 -static void
 440 -column_sizing_notify (GObject    *object,
 441 -                      GParamSpec *pspec,
 442 -                      gpointer    data)
 443 -{
 444 -  GtkTreeViewColumn *c = GTK_TREE_VIEW_COLUMN (object);
 445 -
 446 -  if (gtk_tree_view_column_get_sizing (c) != GTK_TREE_VIEW_COLUMN_FIXED)
 447 -    /* disable fixed height mode */
 448 -    g_object_set (data, "fixed-height-mode", FALSE, NULL);
 449 -}
 450 -
 451  /**
 452   * gtk_tree_view_set_fixed_height_mode:
 453   * @tree_view: a #GtkTreeView 
 454 @@ -7707,50 +7616,12 @@ column_sizing_notify (GObject    *object,
 455   * Only enable this option if all rows are the same height and all
 456   * columns are of type %GTK_TREE_VIEW_COLUMN_FIXED.
 457   *
 458 - * Since: 2.6 
 459 + * Since: 2.6 (DEPRECATED)
 460   **/
 461  void
 462  gtk_tree_view_set_fixed_height_mode (GtkTreeView *tree_view,
 463                                       gboolean     enable)
 464  {
 465 -  GList *l;
 466 -  
 467 -  enable = enable != FALSE;
 468 -
 469 -  if (enable == tree_view->priv->fixed_height_mode)
 470 -    return;
 471 -
 472 -  if (!enable)
 473 -    {
 474 -      tree_view->priv->fixed_height_mode = 0;
 475 -      tree_view->priv->fixed_height = -1;
 476 -
 477 -      /* force a revalidation */
 478 -      install_presize_handler (tree_view);
 479 -    }
 480 -  else 
 481 -    {
 482 -      /* make sure all columns are of type FIXED */
 483 -      for (l = tree_view->priv->columns; l; l = l->next)
 484 -	{
 485 -	  GtkTreeViewColumn *c = l->data;
 486 -	  
 487 -	  g_return_if_fail (gtk_tree_view_column_get_sizing (c) == GTK_TREE_VIEW_COLUMN_FIXED);
 488 -	}
 489 -      
 490 -      /* yes, we really have to do this is in a separate loop */
 491 -      for (l = tree_view->priv->columns; l; l = l->next)
 492 -	g_signal_connect (l->data, "notify::sizing",
 493 -			  G_CALLBACK (column_sizing_notify), tree_view);
 494 -      
 495 -      tree_view->priv->fixed_height_mode = 1;
 496 -      tree_view->priv->fixed_height = -1;
 497 -      
 498 -      if (tree_view->priv->tree)
 499 -	initialize_fixed_height_mode (tree_view);
 500 -    }
 501 -
 502 -  g_object_notify (G_OBJECT (tree_view), "fixed-height-mode");
 503  }
 504  
 505  /**
 506 @@ -7761,12 +7632,12 @@ gtk_tree_view_set_fixed_height_mode (GtkTreeView *tree_view,
 507   * 
 508   * Return value: %TRUE if @tree_view is in fixed height mode
 509   * 
 510 - * Since: 2.6
 511 + * Since: 2.6 (DEPRECATED).
 512   **/
 513  gboolean
 514  gtk_tree_view_get_fixed_height_mode (GtkTreeView *tree_view)
 515  {
 516 -  return tree_view->priv->fixed_height_mode;
 517 +  return FALSE;
 518  }
 519  
 520  /* Returns TRUE if the focus is within the headers, after the focus operation is
 521 @@ -8058,7 +7929,7 @@ gtk_tree_view_style_set (GtkWidget *widget,
 522        _gtk_tree_view_column_cell_set_dirty (column, TRUE);
 523      }
 524  
 525 -  tree_view->priv->fixed_height = -1;
 526 +  tree_view->priv->average_row_height = -1;
 527    _gtk_rbtree_mark_invalid (tree_view->priv->tree);
 528  
 529    gtk_widget_queue_resize (widget);
 530 @@ -8318,34 +8189,27 @@ gtk_tree_view_row_changed (GtkTreeModel *model,
 531    if (tree == NULL)
 532      goto done;
 533  
 534 -  if (tree_view->priv->fixed_height_mode
 535 -      && tree_view->priv->fixed_height >= 0)
 536 -    {
 537 -      _gtk_rbtree_node_set_height (tree, node, tree_view->priv->fixed_height);
 538 -      if (GTK_WIDGET_REALIZED (tree_view))
 539 -	gtk_tree_view_node_queue_redraw (tree_view, tree, node);
 540 -    }
 541 -  else
 542 +  _gtk_rbtree_node_mark_invalid (tree, node);
 543 +  for (list = tree_view->priv->columns; list; list = list->next)
 544      {
 545 -      _gtk_rbtree_node_mark_invalid (tree, node);
 546 -      for (list = tree_view->priv->columns; list; list = list->next)
 547 -        {
 548 -          GtkTreeViewColumn *column;
 549 +      GtkTreeViewColumn *column;
 550  
 551 -          column = list->data;
 552 -          if (! column->visible)
 553 -            continue;
 554 +      column = list->data;
 555 +      if (! column->visible)
 556 +        continue;
 557  
 558 -          if (column->column_type == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
 559 -            {
 560 -              _gtk_tree_view_column_cell_set_dirty (column, TRUE);
 561 -            }
 562 +      if (column->column_type == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
 563 +        {
 564 +          _gtk_tree_view_column_cell_set_dirty (column, TRUE);
 565          }
 566      }
 567  
 568   done:
 569 +#if 0
 570 +  /* FIXME: need area validation if this node is visible. */
 571    if (GTK_WIDGET_REALIZED (tree_view) && !tree_view->priv->fixed_height_mode)
 572      install_presize_handler (tree_view);
 573 +#endif
 574    if (free_path)
 575      gtk_tree_path_free (path);
 576  }
 577 @@ -8368,11 +8232,7 @@ gtk_tree_view_row_inserted (GtkTreeModel *model,
 578  
 579    g_return_if_fail (path != NULL || iter != NULL);
 580  
 581 -  if (tree_view->priv->fixed_height_mode
 582 -      && tree_view->priv->fixed_height >= 0)
 583 -    height = tree_view->priv->fixed_height;
 584 -  else
 585 -    height = 0;
 586 +  height = 0;
 587  
 588    if (path == NULL)
 589      {
 590 @@ -8449,18 +8309,12 @@ gtk_tree_view_row_inserted (GtkTreeModel *model,
 591      }
 592  
 593   done:
 594 -  if (height > 0)
 595 -    {
 596 -      if (tree)
 597 -        _gtk_rbtree_node_mark_valid (tree, tmpnode);
 598 -
 599 -      if (node_visible && node_is_visible (tree_view, tree, tmpnode))
 600 -	gtk_widget_queue_resize (GTK_WIDGET (tree_view));
 601 -      else
 602 -	gtk_widget_queue_resize_no_redraw (GTK_WIDGET (tree_view));
 603 -    }
 604 +  /* FIXME: need to validate the node if it will be visible directly. */
 605 +  if (node_visible && node_is_visible (tree_view, tree, tmpnode))
 606 +    gtk_widget_queue_resize (GTK_WIDGET (tree_view));
 607    else
 608 -    install_presize_handler (tree_view);
 609 +    gtk_widget_queue_resize_no_redraw (GTK_WIDGET (tree_view));
 610 +
 611    if (free_path)
 612      gtk_tree_path_free (path);
 613  }
 614 @@ -8815,15 +8669,6 @@ gtk_tree_view_build_tree (GtkTreeView *tree_view,
 615        gtk_tree_model_ref_node (tree_view->priv->model, iter);
 616        temp = _gtk_rbtree_insert_after (tree, temp, 0, FALSE);
 617  
 618 -      if (tree_view->priv->fixed_height > 0)
 619 -        {
 620 -          if (GTK_RBNODE_FLAG_SET (temp, GTK_RBNODE_INVALID))
 621 -	    {
 622 -              _gtk_rbtree_node_set_height (tree, temp, tree_view->priv->fixed_height);
 623 -	      _gtk_rbtree_node_mark_valid (tree, temp);
 624 -	    }
 625 -        }
 626 -
 627        if (is_list)
 628          continue;
 629  
 630 @@ -9834,7 +9679,6 @@ gtk_tree_view_move_cursor_page_up_down (GtkTreeView *tree_view,
 631  
 632    y -= window_y;
 633    gtk_tree_view_scroll_to_point (tree_view, -1, y);
 634 -  gtk_tree_view_clamp_node_visible (tree_view, cursor_tree, cursor_node);
 635    _gtk_tree_view_queue_draw_node (tree_view, cursor_tree, cursor_node, NULL);
 636  
 637    if (!gtk_tree_path_compare (old_cursor_path, cursor_path))
 638 @@ -10745,8 +10589,7 @@ gtk_tree_view_set_model (GtkTreeView  *tree_view,
 639        g_object_unref (tree_view->priv->model);
 640  
 641        tree_view->priv->search_column = -1;
 642 -      tree_view->priv->fixed_height_check = 0;
 643 -      tree_view->priv->fixed_height = -1;
 644 +      tree_view->priv->average_row_height = -1;
 645        tree_view->priv->dy = tree_view->priv->top_row_dy = 0;
 646      }
 647  
 648 @@ -11178,10 +11021,6 @@ gtk_tree_view_remove_column (GtkTreeView       *tree_view,
 649        tree_view->priv->edited_column = NULL;
 650      }
 651  
 652 -  g_signal_handlers_disconnect_by_func (column,
 653 -                                        G_CALLBACK (column_sizing_notify),
 654 -                                        tree_view);
 655 -
 656    _gtk_tree_view_column_unset_tree_view (column);
 657  
 658    tree_view->priv->columns = g_list_remove (tree_view->priv->columns, column);
 659 @@ -11236,10 +11075,6 @@ gtk_tree_view_insert_column (GtkTreeView       *tree_view,
 660    g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (column), -1);
 661    g_return_val_if_fail (column->tree_view == NULL, -1);
 662  
 663 -  if (tree_view->priv->fixed_height_mode)
 664 -    g_return_val_if_fail (gtk_tree_view_column_get_sizing (column)
 665 -                          == GTK_TREE_VIEW_COLUMN_FIXED, -1);
 666 -
 667    g_object_ref_sink (column);
 668  
 669    if (tree_view->priv->n_columns == 0 &&
 670 @@ -11249,9 +11084,6 @@ gtk_tree_view_insert_column (GtkTreeView       *tree_view,
 671        gdk_window_show (tree_view->priv->header_window);
 672      }
 673  
 674 -  g_signal_connect (column, "notify::sizing",
 675 -                    G_CALLBACK (column_sizing_notify), tree_view);
 676 -
 677    tree_view->priv->columns = g_list_insert (tree_view->priv->columns,
 678  					    column, position);
 679    tree_view->priv->n_columns++;
 680 @@ -11309,8 +11141,6 @@ gtk_tree_view_insert_column_with_attributes (GtkTreeView     *tree_view,
 681    g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
 682  
 683    column = gtk_tree_view_column_new ();
 684 -  if (tree_view->priv->fixed_height_mode)
 685 -    gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED);
 686  
 687    gtk_tree_view_column_set_title (column, title);
 688    gtk_tree_view_column_pack_start (column, cell, TRUE);
 689 @@ -11366,8 +11196,6 @@ gtk_tree_view_insert_column_with_data_func  (GtkTreeView               *tree_vie
 690    g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
 691  
 692    column = gtk_tree_view_column_new ();
 693 -  if (tree_view->priv->fixed_height_mode)
 694 -    gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED);
 695  
 696    gtk_tree_view_column_set_title (column, title);
 697    gtk_tree_view_column_pack_start (column, cell, TRUE);
 698 @@ -11639,6 +11467,9 @@ gtk_tree_view_scroll_to_cell (GtkTreeView       *tree_view,
 699                                gfloat             row_align,
 700                                gfloat             col_align)
 701  {
 702 +  GtkRBTree *tree;
 703 +  GtkRBNode *node;
 704 +
 705    g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
 706    g_return_if_fail (tree_view->priv->model != NULL);
 707    g_return_if_fail (tree_view->priv->tree != NULL);
 708 @@ -11646,22 +11477,18 @@ gtk_tree_view_scroll_to_cell (GtkTreeView       *tree_view,
 709    g_return_if_fail (col_align >= 0.0 && col_align <= 1.0);
 710    g_return_if_fail (path != NULL || column != NULL);
 711  
 712 -#if 0
 713 -  g_print ("gtk_tree_view_scroll_to_cell:\npath: %s\ncolumn: %s\nuse_align: %d\nrow_align: %f\ncol_align: %f\n",
 714 -	   gtk_tree_path_to_string (path), column?"non-null":"null", use_align, row_align, col_align);
 715 -#endif
 716    row_align = CLAMP (row_align, 0.0, 1.0);
 717    col_align = CLAMP (col_align, 0.0, 1.0);
 718  
 719 +  _gtk_tree_view_find_node (tree_view, path, &tree, &node);
 720  
 721    /* Note: Despite the benefits that come from having one code path for the
 722     * scrolling code, we short-circuit validate_visible_area's immplementation as
 723     * it is much slower than just going to the point.
 724     */
 725 -  if (! GTK_WIDGET_VISIBLE (tree_view) ||
 726 -      ! GTK_WIDGET_REALIZED (tree_view) ||
 727 -      GTK_WIDGET_ALLOC_NEEDED (tree_view) || 
 728 -      GTK_RBNODE_FLAG_SET (tree_view->priv->tree->root, GTK_RBNODE_DESCENDANTS_INVALID))
 729 +  if (! GTK_WIDGET_VISIBLE (tree_view)
 730 +      || ! GTK_WIDGET_REALIZED (tree_view)
 731 +      || GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID))
 732      {
 733        if (tree_view->priv->scroll_to_path)
 734  	gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
 735 -- 
 736 1.6.4