Pileus Git - ~andy/gtk/blob - gtk/gtksizerequest.c

   1 /* gtksizerequest.c
   2  * Copyright (C) 2007-2010 Openismus GmbH
   3  *
   4  * Authors:
   5  *      Mathias Hasselmann <mathias@openismus.com>
   6  *      Tristan Van Berkom <tristan.van.berkom@gmail.com>
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Library General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Library General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Library General Public
  19  * License along with this library. If not, see <http://www.gnu.org/licenses/>.
  20  */
  21
  22 #include <config.h>
  23
  24 #include "gtksizerequest.h"
  25
  26 #include "gtkdebug.h"
  27 #include "gtkintl.h"
  28 #include "gtkprivate.h"
  29 #include "gtksizegroup-private.h"
  30 #include "gtksizerequestcacheprivate.h"
  31 #include "gtkwidgetprivate.h"
  32 #include "deprecated/gtkstyle.h"
  33
  34
  35 #ifndef G_DISABLE_CHECKS
  36 static GQuark recursion_check_quark = 0;
  37 #endif /* G_DISABLE_CHECKS */
  38
  39 static void
  40 push_recursion_check (GtkWidget       *widget,
  41                       GtkOrientation   orientation,
  42                       gint             for_size)
  43 {
  44 #ifndef G_DISABLE_CHECKS
  45   const char *previous_method;
  46   const char *method;
  47
  48   if (recursion_check_quark == 0)
  49     recursion_check_quark = g_quark_from_static_string ("gtk-size-request-in-progress");
  50
  51   previous_method = g_object_get_qdata (G_OBJECT (widget), recursion_check_quark);
  52
  53   if (orientation == GTK_ORIENTATION_HORIZONTAL)
  54     {
  55       method = for_size < 0 ? "get_width" : "get_width_for_height";
  56     }
  57   else
  58     {
  59       method = for_size < 0 ? "get_height" : "get_height_for_width";
  60     }
  61
  62   if (previous_method != NULL)
  63     {
  64       g_warning ("%s %p: widget tried to gtk_widget_%s inside "
  65                  " GtkWidget     ::%s implementation. "
  66                  "Should just invoke GTK_WIDGET_GET_CLASS(widget)->%s "
  67                  "directly rather than using gtk_widget_%s",
  68                  G_OBJECT_TYPE_NAME (widget), widget,
  69                  method, previous_method,
  70                  method, method);
  71     }
  72
  73   g_object_set_qdata (G_OBJECT (widget), recursion_check_quark, (char*) method);
  74 #endif /* G_DISABLE_CHECKS */
  75 }
  76
  77 static void
  78 pop_recursion_check (GtkWidget       *widget,
  79                      GtkOrientation   orientation)
  80 {
  81 #ifndef G_DISABLE_CHECKS
  82   g_object_set_qdata (G_OBJECT (widget), recursion_check_quark, NULL);
  83 #endif
  84 }
  85
  86 static const char *
  87 get_vfunc_name (GtkOrientation orientation,
  88                 gint           for_size)
  89 {
  90   if (orientation == GTK_ORIENTATION_HORIZONTAL)
  91     return for_size < 0 ? "get_preferred_width" : "get_preferred_width_for_height";
  92   else
  93     return for_size < 0 ? "get_preferred_height" : "get_preferred_height_for_width";
  94 }
  95
  96 static void
  97 gtk_widget_query_size_for_orientation (GtkWidget        *widget,
  98                                        GtkOrientation    orientation,
  99                                        gint              for_size,
 100                                        gint             *minimum_size,
 101                                        gint             *natural_size)
 102 {
 103   SizeRequestCache *cache;
 104   gint min_size = 0;
 105   gint nat_size = 0;
 106   gboolean found_in_cache;
 107
 108   if (gtk_widget_get_request_mode (widget) == GTK_SIZE_REQUEST_CONSTANT_SIZE)
 109     for_size = -1;
 110
 111   cache = _gtk_widget_peek_request_cache (widget);
 112   found_in_cache = _gtk_size_request_cache_lookup (cache,
 113                                                    orientation,
 114                                                    for_size,
 115                                                    &min_size,
 116                                                    &nat_size);
 117
 118   if (!found_in_cache)
 119     {
 120       gint adjusted_min, adjusted_natural, adjusted_for_size = for_size;
 121
 122       gtk_widget_ensure_style (widget);
 123
 124       if (orientation == GTK_ORIENTATION_HORIZONTAL)
 125         {
 126           if (for_size < 0)
 127             {
 128               push_recursion_check (widget, orientation, for_size);
 129               GTK_WIDGET_GET_CLASS (widget)->get_preferred_width (widget, &min_size, &nat_size);
 130               pop_recursion_check (widget, orientation);
 131             }
 132           else
 133             {
 134               gint ignored_position = 0;
 135               gint minimum_height;
 136               gint natural_height;
 137
 138               /* Pull the base natural height from the cache as it's needed to adjust
 139                * the proposed 'for_size' */
 140               gtk_widget_get_preferred_height (widget, &minimum_height, &natural_height);
 141
 142               /* convert for_size to unadjusted height (for_size is a proposed allocation) */
 143               GTK_WIDGET_GET_CLASS (widget)->adjust_size_allocation (widget,
 144                                                                      GTK_ORIENTATION_VERTICAL,
 145                                                                      &minimum_height,
 146                                                                      &natural_height,
 147                                                                      &ignored_position,
 148                                                                      &adjusted_for_size);
 149
 150               push_recursion_check (widget, orientation, for_size);
 151               GTK_WIDGET_GET_CLASS (widget)->get_preferred_width_for_height (widget,
 152                                                                              MAX (adjusted_for_size, minimum_height),
 153                                                                              &min_size, &nat_size);
 154               pop_recursion_check (widget, orientation);
 155             }
 156         }
 157       else
 158         {
 159           if (for_size < 0)
 160             {
 161               push_recursion_check (widget, orientation, for_size);
 162               GTK_WIDGET_GET_CLASS (widget)->get_preferred_height (widget, &min_size, &nat_size);
 163               pop_recursion_check (widget, orientation);
 164             }
 165           else
 166             {
 167               gint ignored_position = 0;
 168               gint minimum_width;
 169               gint natural_width;
 170
 171               /* Pull the base natural width from the cache as it's needed to adjust
 172                * the proposed 'for_size' */
 173               gtk_widget_get_preferred_width (widget, &minimum_width, &natural_width);
 174
 175               /* convert for_size to unadjusted width (for_size is a proposed allocation) */
 176               GTK_WIDGET_GET_CLASS (widget)->adjust_size_allocation (widget,
 177                                                                      GTK_ORIENTATION_HORIZONTAL,
 178                                                                      &minimum_width,
 179                                                                      &natural_width,
 180                                                                      &ignored_position,
 181                                                                      &adjusted_for_size);
 182
 183               push_recursion_check (widget, orientation, for_size);
 184               GTK_WIDGET_GET_CLASS (widget)->get_preferred_height_for_width (widget,
 185                                                                              MAX (adjusted_for_size, minimum_width),
 186                                                                              &min_size, &nat_size);
 187               pop_recursion_check (widget, orientation);
 188             }
 189         }
 190
 191       if (min_size > nat_size)
 192         {
 193           g_warning ("%s %p reported min size %d and natural size %d in %s(); natural size must be >= min size",
 194                      G_OBJECT_TYPE_NAME (widget), widget, min_size, nat_size, get_vfunc_name (orientation, for_size));
 195         }
 196
 197       adjusted_min     = min_size;
 198       adjusted_natural = nat_size;
 199       GTK_WIDGET_GET_CLASS (widget)->adjust_size_request (widget,
 200                                                           orientation,
 201                                                           &adjusted_min,
 202                                                           &adjusted_natural);
 203
 204       if (adjusted_min < min_size ||
 205           adjusted_natural < nat_size)
 206         {
 207           g_warning ("%s %p adjusted size %s min %d natural %d must not decrease below min %d natural %d",
 208                      G_OBJECT_TYPE_NAME (widget), widget,
 209                      orientation == GTK_ORIENTATION_VERTICAL ? "vertical" : "horizontal",
 210                      adjusted_min, adjusted_natural,
 211                      min_size, nat_size);
 212           /* don't use the adjustment */
 213         }
 214       else if (adjusted_min > adjusted_natural)
 215         {
 216           g_warning ("%s %p adjusted size %s min %d natural %d original min %d natural %d has min greater than natural",
 217                      G_OBJECT_TYPE_NAME (widget), widget,
 218                      orientation == GTK_ORIENTATION_VERTICAL ? "vertical" : "horizontal",
 219                      adjusted_min, adjusted_natural,
 220                      min_size, nat_size);
 221           /* don't use the adjustment */
 222         }
 223       else
 224         {
 225           /* adjustment looks good */
 226           min_size = adjusted_min;
 227           nat_size = adjusted_natural;
 228         }
 229
 230       _gtk_size_request_cache_commit (cache,
 231                                       orientation,
 232                                       for_size,
 233                                       min_size,
 234                                       nat_size);
 235     }
 236
 237   if (minimum_size)
 238     *minimum_size = min_size;
 239
 240   if (natural_size)
 241     *natural_size = nat_size;
 242
 243   g_assert (min_size <= nat_size);
 244
 245   GTK_NOTE (SIZE_REQUEST,
 246             g_print ("[%p] %s\t%s: %d is minimum %d and natural: %d (hit cache: %s)\n",
 247                      widget, G_OBJECT_TYPE_NAME (widget),
 248                      orientation == GTK_ORIENTATION_HORIZONTAL ?
 249                      "width for height" : "height for width" ,
 250                      for_size, min_size, nat_size,
 251                      found_in_cache ? "yes" : "no"));
 252 }
 253
 254 /* This is the main function that checks for a cached size and
 255  * possibly queries the widget class to compute the size if it's
 256  * not cached. If the for_size here is -1, then get_preferred_width()
 257  * or get_preferred_height() will be used.
 258  */
 259 void
 260 _gtk_widget_compute_size_for_orientation (GtkWidget        *widget,
 261                                           GtkOrientation    orientation,
 262                                           gint              for_size,
 263                                           gint             *minimum,
 264                                           gint             *natural)
 265 {
 266   GHashTable *widgets;
 267   GHashTableIter iter;
 268   gpointer key;
 269   gint    min_result = 0, nat_result = 0;
 270
 271   if (G_LIKELY (!_gtk_widget_get_sizegroups (widget)))
 272     {
 273       gtk_widget_query_size_for_orientation (widget, orientation, for_size, minimum, natural);
 274       return;
 275     }
 276
 277   widgets = _gtk_size_group_get_widget_peers (widget, orientation);
 278
 279   g_hash_table_foreach (widgets, (GHFunc) g_object_ref, NULL);
 280
 281   g_hash_table_iter_init (&iter, widgets);
 282   while (g_hash_table_iter_next (&iter, &key, NULL))
 283     {
 284       GtkWidget *tmp_widget = key;
 285       gint min_dimension, nat_dimension;
 286
 287       gtk_widget_query_size_for_orientation (tmp_widget, orientation, for_size, &min_dimension, &nat_dimension);
 288
 289       min_result = MAX (min_result, min_dimension);
 290       nat_result = MAX (nat_result, nat_dimension);
 291     }
 292
 293   g_hash_table_foreach (widgets, (GHFunc) g_object_unref, NULL);
 294
 295   g_hash_table_destroy (widgets);
 296
 297   if (minimum)
 298     *minimum = min_result;
 299
 300   if (natural)
 301     *natural = nat_result;
 302 }
 303
 304 /**
 305  * gtk_widget_get_request_mode:
 306  * @widget: a #GtkWidget instance
 307  *
 308  * Gets whether the widget prefers a height-for-width layout
 309  * or a width-for-height layout.
 310  *
 311  * <note><para>#GtkBin widgets generally propagate the preference of
 312  * their child, container widgets need to request something either in
 313  * context of their children or in context of their allocation
 314  * capabilities.</para></note>
 315  *
 316  * Returns: The #GtkSizeRequestMode preferred by @widget.
 317  *
 318  * Since: 3.0
 319  */
 320 GtkSizeRequestMode
 321 gtk_widget_get_request_mode (GtkWidget *widget)
 322 {
 323   SizeRequestCache *cache;
 324
 325   g_return_val_if_fail (GTK_IS_WIDGET (widget), GTK_SIZE_REQUEST_CONSTANT_SIZE);
 326
 327   cache = _gtk_widget_peek_request_cache (widget);
 328
 329   if (!cache->request_mode_valid)
 330     {
 331       cache->request_mode = GTK_WIDGET_GET_CLASS (widget)->get_request_mode (widget);
 332       cache->request_mode_valid = TRUE;
 333     }
 334
 335   return cache->request_mode;
 336 }
 337
 338 /**
 339  * gtk_widget_get_preferred_width:
 340  * @widget: a #GtkWidget instance
 341  * @minimum_width: (out) (allow-none): location to store the minimum width, or %NULL
 342  * @natural_width: (out) (allow-none): location to store the natural width, or %NULL
 343  *
 344  * Retrieves a widget's initial minimum and natural width.
 345  *
 346  * <note><para>This call is specific to height-for-width
 347  * requests.</para></note>
 348  *
 349  * The returned request will be modified by the
 350  * GtkWidgetClass::adjust_size_request virtual method and by any
 351  * #GtkSizeGroup<!-- -->s that have been applied. That is, the returned request
 352  * is the one that should be used for layout, not necessarily the one
 353  * returned by the widget itself.
 354  *
 355  * Since: 3.0
 356  */
 357 void
 358 gtk_widget_get_preferred_width (GtkWidget *widget,
 359                                 gint      *minimum_width,
 360                                 gint      *natural_width)
 361 {
 362   g_return_if_fail (GTK_IS_WIDGET (widget));
 363   g_return_if_fail (minimum_width != NULL || natural_width != NULL);
 364
 365   _gtk_widget_compute_size_for_orientation (widget,
 366                                             GTK_ORIENTATION_HORIZONTAL,
 367                                             -1,
 368                                             minimum_width,
 369                                             natural_width);
 370 }
 371
 372
 373 /**
 374  * gtk_widget_get_preferred_height:
 375  * @widget: a #GtkWidget instance
 376  * @minimum_height: (out) (allow-none): location to store the minimum height, or %NULL
 377  * @natural_height: (out) (allow-none): location to store the natural height, or %NULL
 378  *
 379  * Retrieves a widget's initial minimum and natural height.
 380  *
 381  * <note><para>This call is specific to width-for-height requests.</para></note>
 382  *
 383  * The returned request will be modified by the
 384  * GtkWidgetClass::adjust_size_request virtual method and by any
 385  * #GtkSizeGroup<!-- -->s that have been applied. That is, the returned request
 386  * is the one that should be used for layout, not necessarily the one
 387  * returned by the widget itself.
 388  *
 389  * Since: 3.0
 390  */
 391 void
 392 gtk_widget_get_preferred_height (GtkWidget *widget,
 393                                  gint      *minimum_height,
 394                                  gint      *natural_height)
 395 {
 396   g_return_if_fail (GTK_IS_WIDGET (widget));
 397   g_return_if_fail (minimum_height != NULL || natural_height != NULL);
 398
 399   _gtk_widget_compute_size_for_orientation (widget,
 400                                             GTK_ORIENTATION_VERTICAL,
 401                                             -1,
 402                                             minimum_height,
 403                                             natural_height);
 404 }
 405
 406
 407
 408 /**
 409  * gtk_widget_get_preferred_width_for_height:
 410  * @widget: a #GtkWidget instance
 411  * @height: the height which is available for allocation
 412  * @minimum_width: (out) (allow-none): location for storing the minimum width, or %NULL
 413  * @natural_width: (out) (allow-none): location for storing the natural width, or %NULL
 414  *
 415  * Retrieves a widget's minimum and natural width if it would be given
 416  * the specified @height.
 417  *
 418  * The returned request will be modified by the
 419  * GtkWidgetClass::adjust_size_request virtual method and by any
 420  * #GtkSizeGroup<!-- -->s that have been applied. That is, the returned request
 421  * is the one that should be used for layout, not necessarily the one
 422  * returned by the widget itself.
 423  *
 424  * Since: 3.0
 425  */
 426 void
 427 gtk_widget_get_preferred_width_for_height (GtkWidget *widget,
 428                                            gint       height,
 429                                            gint      *minimum_width,
 430                                            gint      *natural_width)
 431 {
 432   g_return_if_fail (GTK_IS_WIDGET (widget));
 433   g_return_if_fail (minimum_width != NULL || natural_width != NULL);
 434   g_return_if_fail (height >= 0);
 435
 436   _gtk_widget_compute_size_for_orientation (widget,
 437                                             GTK_ORIENTATION_HORIZONTAL,
 438                                             height,
 439                                             minimum_width,
 440                                             natural_width);
 441 }
 442
 443 /**
 444  * gtk_widget_get_preferred_height_for_width:
 445  * @widget: a #GtkWidget instance
 446  * @width: the width which is available for allocation
 447  * @minimum_height: (out) (allow-none): location for storing the minimum height, or %NULL
 448  * @natural_height: (out) (allow-none): location for storing the natural height, or %NULL
 449  *
 450  * Retrieves a widget's minimum and natural height if it would be given
 451  * the specified @width.
 452  *
 453  * The returned request will be modified by the
 454  * GtkWidgetClass::adjust_size_request virtual method and by any
 455  * #GtkSizeGroup<!-- -->s that have been applied. That is, the returned request
 456  * is the one that should be used for layout, not necessarily the one
 457  * returned by the widget itself.
 458  *
 459  * Since: 3.0
 460  */
 461 void
 462 gtk_widget_get_preferred_height_for_width (GtkWidget *widget,
 463                                            gint       width,
 464                                            gint      *minimum_height,
 465                                            gint      *natural_height)
 466 {
 467   g_return_if_fail (GTK_IS_WIDGET (widget));
 468   g_return_if_fail (minimum_height != NULL || natural_height != NULL);
 469   g_return_if_fail (width >= 0);
 470
 471   _gtk_widget_compute_size_for_orientation (widget,
 472                                             GTK_ORIENTATION_VERTICAL,
 473                                             width,
 474                                             minimum_height,
 475                                             natural_height);
 476 }
 477
 478 /**
 479  * gtk_widget_get_preferred_size:
 480  * @widget: a #GtkWidget instance
 481  * @minimum_size: (out) (allow-none): location for storing the minimum size, or %NULL
 482  * @natural_size: (out) (allow-none): location for storing the natural size, or %NULL
 483  *
 484  * Retrieves the minimum and natural size of a widget, taking
 485  * into account the widget's preference for height-for-width management.
 486  *
 487  * This is used to retrieve a suitable size by container widgets which do
 488  * not impose any restrictions on the child placement. It can be used
 489  * to deduce toplevel window and menu sizes as well as child widgets in
 490  * free-form containers such as GtkLayout.
 491  *
 492  * <note><para>Handle with care. Note that the natural height of a height-for-width
 493  * widget will generally be a smaller size than the minimum height, since the required
 494  * height for the natural width is generally smaller than the required height for
 495  * the minimum width.</para></note>
 496  *
 497  * Since: 3.0
 498  */
 499 void
 500 gtk_widget_get_preferred_size (GtkWidget      *widget,
 501                                GtkRequisition *minimum_size,
 502                                GtkRequisition *natural_size)
 503 {
 504   gint min_width, nat_width;
 505   gint min_height, nat_height;
 506
 507   g_return_if_fail (GTK_IS_WIDGET (widget));
 508
 509   if (gtk_widget_get_request_mode (widget) == GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH)
 510     {
 511       gtk_widget_get_preferred_width (widget, &min_width, &nat_width);
 512
 513       if (minimum_size)
 514         {
 515           minimum_size->width = min_width;
 516           gtk_widget_get_preferred_height_for_width (widget, min_width,
 517                                                      &minimum_size->height, NULL);
 518         }
 519
 520       if (natural_size)
 521         {
 522           natural_size->width = nat_width;
 523           gtk_widget_get_preferred_height_for_width (widget, nat_width,
 524                                                      NULL, &natural_size->height);
 525         }
 526     }
 527   else /* GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT or CONSTANT_SIZE */
 528     {
 529       gtk_widget_get_preferred_height (widget, &min_height, &nat_height);
 530
 531       if (minimum_size)
 532         {
 533           minimum_size->height = min_height;
 534           gtk_widget_get_preferred_width_for_height (widget, min_height,
 535                                                      &minimum_size->width, NULL);
 536         }
 537
 538       if (natural_size)
 539         {
 540           natural_size->height = nat_height;
 541           gtk_widget_get_preferred_width_for_height (widget, nat_height,
 542                                                      NULL, &natural_size->width);
 543         }
 544     }
 545 }
 546
 547
 548 static gint
 549 compare_gap (gconstpointer p1,
 550              gconstpointer p2,
 551              gpointer      data)
 552 {
 553   GtkRequestedSize *sizes = data;
 554   const guint *c1 = p1;
 555   const guint *c2 = p2;
 556
 557   const gint d1 = MAX (sizes[*c1].natural_size -
 558                        sizes[*c1].minimum_size,
 559                        0);
 560   const gint d2 = MAX (sizes[*c2].natural_size -
 561                        sizes[*c2].minimum_size,
 562                        0);
 563
 564   gint delta = (d2 - d1);
 565
 566   if (0 == delta)
 567     delta = (*c2 - *c1);
 568
 569   return delta;
 570 }
 571
 572 /**
 573  * gtk_distribute_natural_allocation:
 574  * @extra_space: Extra space to redistribute among children after subtracting
 575  *               minimum sizes and any child padding from the overall allocation
 576  * @n_requested_sizes: Number of requests to fit into the allocation
 577  * @sizes: An array of structs with a client pointer and a minimum/natural size
 578  *         in the orientation of the allocation.
 579  *
 580  * Distributes @extra_space to child @sizes by bringing smaller
 581  * children up to natural size first.
 582  *
 583  * The remaining space will be added to the @minimum_size member of the
 584  * GtkRequestedSize struct. If all sizes reach their natural size then
 585  * the remaining space is returned.
 586  *
 587  * Returns: The remainder of @extra_space after redistributing space
 588  * to @sizes.
 589  */
 590 gint
 591 gtk_distribute_natural_allocation (gint              extra_space,
 592                                    guint             n_requested_sizes,
 593                                    GtkRequestedSize *sizes)
 594 {
 595   guint *spreading;
 596   gint   i;
 597
 598   g_return_val_if_fail (extra_space >= 0, 0);
 599
 600   spreading = g_newa (guint, n_requested_sizes);
 601
 602   for (i = 0; i < n_requested_sizes; i++)
 603     spreading[i] = i;
 604
 605   /* Distribute the container's extra space c_gap. We want to assign
 606    * this space such that the sum of extra space assigned to children
 607    * (c^i_gap) is equal to c_cap. The case that there's not enough
 608    * space for all children to take their natural size needs some
 609    * attention. The goals we want to achieve are:
 610    *
 611    *   a) Maximize number of children taking their natural size.
 612    *   b) The allocated size of children should be a continuous
 613    *   function of c_gap.  That is, increasing the container size by
 614    *   one pixel should never make drastic changes in the distribution.
 615    *   c) If child i takes its natural size and child j doesn't,
 616    *   child j should have received at least as much gap as child i.
 617    *
 618    * The following code distributes the additional space by following
 619    * these rules.
 620    */
 621
 622   /* Sort descending by gap and position. */
 623   g_qsort_with_data (spreading,
 624                      n_requested_sizes, sizeof (guint),
 625                      compare_gap, sizes);
 626
 627   /* Distribute available space.
 628    * This master piece of a loop was conceived by Behdad Esfahbod.
 629    */
 630   for (i = n_requested_sizes - 1; extra_space > 0 && i >= 0; --i)
 631     {
 632       /* Divide remaining space by number of remaining children.
 633        * Sort order and reducing remaining space by assigned space
 634        * ensures that space is distributed equally.
 635        */
 636       gint glue = (extra_space + i) / (i + 1);
 637       gint gap = sizes[(spreading[i])].natural_size
 638         - sizes[(spreading[i])].minimum_size;
 639
 640       gint extra = MIN (glue, gap);
 641
 642       sizes[spreading[i]].minimum_size += extra;
 643
 644       extra_space -= extra;
 645     }
 646
 647   return extra_space;
 648 }