app/gtkvwrapbox.c

   1 /* GTK - The GIMP Toolkit
   2  * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
   3  *
   4  * GtkVWrapBox: Vertical wrapping box widget
   5  * Copyright (C) 1999 Tim Janik
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Library General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Library General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Library General Public
  18  * License along with this library; if not, write to the
  19  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  20  * Boston, MA 02111-1307, USA.
  21  */
  22 #include <config.h>
  23
  24 #include "gtkvwrapbox.h"
  25 #include <math.h>
  26
  27
  28 /* --- prototypes --- */
  29 static void    gtk_vwrap_box_class_init    (GtkVWrapBoxClass   *klass);
  30 static void    gtk_vwrap_box_init          (GtkVWrapBox        *vwbox);
  31 static void    gtk_vwrap_box_size_request  (GtkWidget          *widget,
  32                                             GtkRequisition     *requisition);
  33 static void    gtk_vwrap_box_size_allocate (GtkWidget          *widget,
  34                                             GtkAllocation      *allocation);
  35 static GSList* reverse_list_col_children   (GtkWrapBox         *wbox,
  36                                             GtkWrapBoxChild   **child_p,
  37                                             GtkAllocation      *area,
  38                                             guint              *max_width,
  39                                             gboolean           *can_hexpand);
  40
  41
  42 /* --- variables --- */
  43 static gpointer parent_class = NULL;
  44
  45
  46 /* --- functions --- */
  47 GtkType
  48 gtk_vwrap_box_get_type (void)
  49 {
  50   static GtkType vwrap_box_type = 0;
  51
  52   if (!vwrap_box_type)
  53     {
  54       static const GtkTypeInfo vwrap_box_info =
  55       {
  56         "GtkVWrapBox",
  57         sizeof (GtkVWrapBox),
  58         sizeof (GtkVWrapBoxClass),
  59         (GtkClassInitFunc) gtk_vwrap_box_class_init,
  60         (GtkObjectInitFunc) gtk_vwrap_box_init,
  61         /* reserved_1 */ NULL,
  62         /* reserved_2 */ NULL,
  63         (GtkClassInitFunc) NULL,
  64       };
  65
  66       vwrap_box_type = gtk_type_unique (GTK_TYPE_WRAP_BOX, &vwrap_box_info);
  67     }
  68
  69   return vwrap_box_type;
  70 }
  71
  72 static void
  73 gtk_vwrap_box_class_init (GtkVWrapBoxClass *class)
  74 {
  75   GtkObjectClass *object_class;
  76   GtkWidgetClass *widget_class;
  77   GtkContainerClass *container_class;
  78   GtkWrapBoxClass *wrap_box_class;
  79
  80   object_class = GTK_OBJECT_CLASS (class);
  81   widget_class = GTK_WIDGET_CLASS (class);
  82   container_class = GTK_CONTAINER_CLASS (class);
  83   wrap_box_class = GTK_WRAP_BOX_CLASS (class);
  84
  85   parent_class = gtk_type_class (GTK_TYPE_WRAP_BOX);
  86
  87   widget_class->size_request = gtk_vwrap_box_size_request;
  88   widget_class->size_allocate = gtk_vwrap_box_size_allocate;
  89
  90   wrap_box_class->rlist_line_children = reverse_list_col_children;
  91 }
  92
  93 static void
  94 gtk_vwrap_box_init (GtkVWrapBox *vwbox)
  95 {
  96   vwbox->max_child_height = 0;
  97   vwbox->max_child_width = 0;
  98 }
  99
 100 GtkWidget*
 101 gtk_vwrap_box_new (gboolean homogeneous)
 102 {
 103   GtkVWrapBox *vwbox;
 104
 105   vwbox = GTK_VWRAP_BOX (gtk_widget_new (GTK_TYPE_VWRAP_BOX, NULL));
 106
 107   GTK_WRAP_BOX (vwbox)->homogeneous = homogeneous ? TRUE : FALSE;
 108
 109   return GTK_WIDGET (vwbox);
 110 }
 111
 112 static inline void
 113 get_child_requisition (GtkWrapBox     *wbox,
 114                        GtkWidget      *child,
 115                        GtkRequisition *child_requisition)
 116 {
 117   if (wbox->homogeneous)
 118     {
 119       GtkVWrapBox *vwbox = GTK_VWRAP_BOX (wbox);
 120
 121       child_requisition->height = vwbox->max_child_height;
 122       child_requisition->width = vwbox->max_child_width;
 123     }
 124   else
 125     gtk_widget_get_child_requisition (child, child_requisition);
 126 }
 127
 128 #if THIS_IS_PROBABLY_DEAD_CODE
 129 static void
 130 _gtk_vwrap_box_size_request (GtkWidget      *widget,
 131                              GtkRequisition *requisition)
 132 {
 133   GtkVWrapBox *this = GTK_VWRAP_BOX (widget);
 134   GtkWrapBox *wbox = GTK_WRAP_BOX (widget);
 135   GtkWrapBoxChild *child;
 136   guint area = 0;
 137
 138   g_return_if_fail (requisition != NULL);
 139
 140   /*<h2v-off>*/
 141   requisition->width = 0;
 142   requisition->height = 0;
 143   this->max_child_width = 0;
 144   this->max_child_height = 0;
 145
 146   for (child = wbox->children; child; child = child->next)
 147     if (GTK_WIDGET_VISIBLE (child->widget))
 148       {
 149         GtkRequisition child_requisition;
 150
 151         gtk_widget_size_request (child->widget, &child_requisition);
 152
 153         area += child_requisition.width * child_requisition.height;
 154         this->max_child_width = MAX (this->max_child_width, child_requisition.width);
 155         this->max_child_height = MAX (this->max_child_height, child_requisition.height);
 156       }
 157   if (wbox->homogeneous)
 158     area = this->max_child_width * this->max_child_height * wbox->n_children;
 159
 160   if (area)
 161     {
 162       requisition->width = sqrt (area * wbox->aspect_ratio);
 163       requisition->height = area / requisition->width;
 164     }
 165   else
 166     {
 167       requisition->width = 0;
 168       requisition->height = 0;
 169     }
 170
 171   requisition->width += GTK_CONTAINER (wbox)->border_width * 2;
 172   requisition->height += GTK_CONTAINER (wbox)->border_width * 2;
 173   /*<h2v-on>*/
 174 }
 175 #endif
 176
 177 static gfloat
 178 get_layout_size (GtkVWrapBox *this,
 179                  guint        max_height,
 180                  guint       *height_inc)
 181 {
 182   GtkWrapBox *wbox = GTK_WRAP_BOX (this);
 183   GtkWrapBoxChild *child;
 184   guint n_cols, left_over = 0, total_width = 0;
 185   gboolean last_col_filled = TRUE;
 186
 187   *height_inc = this->max_child_height + 1;
 188
 189   n_cols = 0;
 190   for (child = wbox->children; child; child = child->next)
 191     {
 192       GtkWrapBoxChild *col_child;
 193       GtkRequisition child_requisition;
 194       guint col_height, col_width, n = 1;
 195
 196       if (!GTK_WIDGET_VISIBLE (child->widget))
 197         continue;
 198
 199       get_child_requisition (wbox, child->widget, &child_requisition);
 200       if (!last_col_filled)
 201         *height_inc = MIN (*height_inc, child_requisition.height - left_over);
 202       col_height = child_requisition.height;
 203       col_width = child_requisition.width;
 204       for (col_child = child->next; col_child && n < wbox->child_limit; col_child = col_child->next)
 205         {
 206           if (GTK_WIDGET_VISIBLE (col_child->widget))
 207             {
 208               get_child_requisition (wbox, col_child->widget, &child_requisition);
 209               if (col_height + wbox->vspacing + child_requisition.height > max_height)
 210                 break;
 211               col_height += wbox->vspacing + child_requisition.height;
 212               col_width = MAX (col_width, child_requisition.width);
 213               n++;
 214             }
 215           child = col_child;
 216         }
 217       last_col_filled = n >= wbox->child_limit;
 218       left_over = last_col_filled ? 0 : max_height - (col_height + wbox->vspacing);
 219       total_width += (n_cols ? wbox->hspacing : 0) + col_width;
 220       n_cols++;
 221     }
 222
 223   if (*height_inc > this->max_child_height)
 224     *height_inc = 0;
 225
 226   return MAX (total_width, 1);
 227 }
 228
 229 static void
 230 gtk_vwrap_box_size_request (GtkWidget      *widget,
 231                             GtkRequisition *requisition)
 232 {
 233   GtkVWrapBox *this = GTK_VWRAP_BOX (widget);
 234   GtkWrapBox *wbox = GTK_WRAP_BOX (widget);
 235   GtkWrapBoxChild *child;
 236   gfloat ratio_dist, layout_height = 0;
 237   guint col_inc = 0;
 238
 239   g_return_if_fail (requisition != NULL);
 240
 241   requisition->height = 0;
 242   requisition->width = 0;
 243   this->max_child_height = 0;
 244   this->max_child_width = 0;
 245
 246   /* size_request all children */
 247   for (child = wbox->children; child; child = child->next)
 248     if (GTK_WIDGET_VISIBLE (child->widget))
 249       {
 250         GtkRequisition child_requisition;
 251
 252         gtk_widget_size_request (child->widget, &child_requisition);
 253
 254         this->max_child_height = MAX (this->max_child_height, child_requisition.height);
 255         this->max_child_width = MAX (this->max_child_width, child_requisition.width);
 256       }
 257
 258   /* figure all possible layouts */
 259   ratio_dist = 32768;
 260   layout_height = this->max_child_height;
 261   do
 262     {
 263       gfloat layout_width;
 264       gfloat ratio, dist;
 265
 266       layout_height += col_inc;
 267       layout_width = get_layout_size (this, layout_height, &col_inc);
 268       ratio = layout_width / layout_height;             /*<h2v-skip>*/
 269       dist = MAX (ratio, wbox->aspect_ratio) - MIN (ratio, wbox->aspect_ratio);
 270       if (dist < ratio_dist)
 271         {
 272           ratio_dist = dist;
 273           requisition->height = layout_height;
 274           requisition->width = layout_width;
 275         }
 276
 277       /* g_print ("ratio for height %d width %d = %f\n",
 278          (gint) layout_height,
 279          (gint) layout_width,
 280          ratio);
 281       */
 282     }
 283   while (col_inc);
 284
 285   requisition->width += GTK_CONTAINER (wbox)->border_width * 2; /*<h2v-skip>*/
 286   requisition->height += GTK_CONTAINER (wbox)->border_width * 2; /*<h2v-skip>*/
 287   /* g_print ("choosen: height %d, width %d\n",
 288      requisition->height,
 289      requisition->width);
 290   */
 291 }
 292
 293 static GSList*
 294 reverse_list_col_children (GtkWrapBox       *wbox,
 295                            GtkWrapBoxChild **child_p,
 296                            GtkAllocation    *area,
 297                            guint            *max_child_size,
 298                            gboolean         *expand_line)
 299 {
 300   GSList *slist = NULL;
 301   guint height = 0, col_height = area->height;
 302   GtkWrapBoxChild *child = *child_p;
 303
 304   *max_child_size = 0;
 305   *expand_line = FALSE;
 306
 307   while (child && !GTK_WIDGET_VISIBLE (child->widget))
 308     {
 309       *child_p = child->next;
 310       child = *child_p;
 311     }
 312
 313   if (child)
 314     {
 315       GtkRequisition child_requisition;
 316       guint n = 1;
 317
 318       get_child_requisition (wbox, child->widget, &child_requisition);
 319       height += child_requisition.height;
 320       *max_child_size = MAX (*max_child_size, child_requisition.width);
 321       *expand_line |= child->hexpand;
 322       slist = g_slist_prepend (slist, child);
 323       *child_p = child->next;
 324       child = *child_p;
 325
 326       while (child && n < wbox->child_limit)
 327         {
 328           if (GTK_WIDGET_VISIBLE (child->widget))
 329             {
 330               get_child_requisition (wbox, child->widget, &child_requisition);
 331               if (height + wbox->vspacing + child_requisition.height > col_height ||
 332                   child->forced_break)
 333                 break;
 334               height += wbox->vspacing + child_requisition.height;
 335               *max_child_size = MAX (*max_child_size, child_requisition.width);
 336               *expand_line |= child->hexpand;
 337               slist = g_slist_prepend (slist, child);
 338               n++;
 339             }
 340           *child_p = child->next;
 341           child = *child_p;
 342         }
 343     }
 344
 345   return slist;
 346 }
 347
 348 static void
 349 layout_col (GtkWrapBox    *wbox,
 350             GtkAllocation *area,
 351             GSList        *children,
 352             guint          children_per_line,
 353             gboolean       hexpand)
 354 {
 355   GSList *slist;
 356   guint n_children = 0, n_expand_children = 0, have_expand_children = 0, total_height = 0;
 357   gfloat y, height, extra;
 358   GtkAllocation child_allocation;
 359
 360   for (slist = children; slist; slist = slist->next)
 361     {
 362       GtkWrapBoxChild *child = slist->data;
 363       GtkRequisition child_requisition;
 364
 365       n_children++;
 366       if (child->vexpand)
 367         n_expand_children++;
 368
 369       get_child_requisition (wbox, child->widget, &child_requisition);
 370       total_height += child_requisition.height;
 371     }
 372
 373   height = MAX (1, area->height - (n_children - 1) * wbox->vspacing);
 374   if (height > total_height)
 375     extra = height - total_height;
 376   else
 377     extra = 0;
 378   have_expand_children = n_expand_children && extra;
 379
 380   y = area->y;
 381   if (wbox->homogeneous)
 382     {
 383       height = MAX (1, area->height - (children_per_line - 1) * wbox->vspacing);
 384       height /= ((gdouble) children_per_line);
 385       extra = 0;
 386     }
 387   else if (have_expand_children && wbox->justify != GTK_JUSTIFY_FILL)
 388     {
 389       height = extra;
 390       extra /= ((gdouble) n_expand_children);
 391     }
 392   else
 393     {
 394       if (wbox->justify == GTK_JUSTIFY_FILL)
 395         {
 396           height = extra;
 397           have_expand_children = TRUE;
 398           n_expand_children = n_children;
 399           extra /= ((gdouble) n_expand_children);
 400         }
 401       else if (wbox->justify == GTK_JUSTIFY_CENTER)
 402         {
 403           y += extra / 2;
 404           height = 0;
 405           extra = 0;
 406         }
 407       else if (wbox->justify == GTK_JUSTIFY_LEFT)
 408         {
 409           height = 0;
 410           extra = 0;
 411         }
 412       else if (wbox->justify == GTK_JUSTIFY_RIGHT)
 413         {
 414           y += extra;
 415           height = 0;
 416           extra = 0;
 417         }
 418     }
 419
 420   n_children = 0;
 421   for (slist = children; slist; slist = slist->next)
 422     {
 423       GtkWrapBoxChild *child = slist->data;
 424
 425       child_allocation.y = y;
 426       child_allocation.x = area->x;
 427       if (wbox->homogeneous)
 428         {
 429           child_allocation.width = area->width;
 430           child_allocation.height = height;
 431           y += child_allocation.height + wbox->vspacing;
 432         }
 433       else
 434         {
 435           GtkRequisition child_requisition;
 436
 437           get_child_requisition (wbox, child->widget, &child_requisition);
 438
 439           if (child_requisition.width >= area->width)
 440             child_allocation.width = area->width;
 441           else
 442             {
 443               child_allocation.width = child_requisition.width;
 444               if (wbox->line_justify == GTK_JUSTIFY_FILL || child->hfill)
 445                 child_allocation.width = area->width;
 446               else if (child->hexpand || wbox->line_justify == GTK_JUSTIFY_CENTER)
 447                 child_allocation.x += (area->width - child_requisition.width) / 2;
 448               else if (wbox->line_justify == GTK_JUSTIFY_BOTTOM)
 449                 child_allocation.x += area->width - child_requisition.width;
 450             }
 451
 452           if (have_expand_children)
 453             {
 454               child_allocation.height = child_requisition.height;
 455               if (child->vexpand || wbox->justify == GTK_JUSTIFY_FILL)
 456                 {
 457                   guint space;
 458
 459                   n_expand_children--;
 460                   space = extra * n_expand_children;
 461                   space = height - space;
 462                   height -= space;
 463                   if (child->vfill)
 464                     child_allocation.height += space;
 465                   else
 466                     {
 467                       child_allocation.y += space / 2;
 468                       y += space;
 469                     }
 470                 }
 471             }
 472           else
 473             {
 474               /* g_print ("child_allocation.y %d += %d * %f ",
 475                        child_allocation.y, n_children, extra); */
 476               child_allocation.y += n_children * extra;
 477               /* g_print ("= %d\n",
 478                        child_allocation.y); */
 479               child_allocation.height = MIN (child_requisition.height,
 480                                             area->height - child_allocation.y + area->y);
 481             }
 482         }
 483
 484       y += child_allocation.height + wbox->vspacing;
 485       gtk_widget_size_allocate (child->widget, &child_allocation);
 486       n_children++;
 487     }
 488 }
 489
 490 typedef struct _Line Line;
 491 struct _Line
 492 {
 493   GSList  *children;
 494   guint16  min_size;
 495   guint    expand : 1;
 496   Line     *next;
 497 };
 498
 499 static void
 500 layout_cols (GtkWrapBox    *wbox,
 501              GtkAllocation *area)
 502 {
 503   GtkWrapBoxChild *next_child;
 504   guint min_width;
 505   gboolean hexpand;
 506   GSList *slist;
 507   Line *line_list = NULL;
 508   guint total_width = 0, n_expand_lines = 0, n_lines = 0;
 509   gfloat shrink_width;
 510   guint children_per_line;
 511
 512   next_child = wbox->children;
 513   slist = GTK_WRAP_BOX_GET_CLASS (wbox)->rlist_line_children (wbox,
 514                                                               &next_child,
 515                                                               area,
 516                                                               &min_width,
 517                                                               &hexpand);
 518   slist = g_slist_reverse (slist);
 519
 520   children_per_line = g_slist_length (slist);
 521   while (slist)
 522     {
 523       Line *line = g_new (Line, 1);
 524
 525       line->children = slist;
 526       line->min_size = min_width;
 527       total_width += min_width;
 528       line->expand = hexpand;
 529       if (hexpand)
 530         n_expand_lines++;
 531       line->next = line_list;
 532       line_list = line;
 533       n_lines++;
 534
 535       slist = GTK_WRAP_BOX_GET_CLASS (wbox)->rlist_line_children (wbox,
 536                                                                   &next_child,
 537                                                                   area,
 538                                                                   &min_width,
 539                                                                   &hexpand);
 540       slist = g_slist_reverse (slist);
 541     }
 542
 543   if (total_width > area->width)
 544     shrink_width = total_width - area->width;
 545   else
 546     shrink_width = 0;
 547
 548   if (1) /* reverse lines and shrink */
 549     {
 550       Line *prev = NULL, *last = NULL;
 551       gfloat n_shrink_lines = n_lines;
 552
 553       while (line_list)
 554         {
 555           Line *tmp = line_list->next;
 556
 557           if (shrink_width)
 558             {
 559               Line *line = line_list;
 560               guint shrink_fract = shrink_width / n_shrink_lines + 0.5;
 561
 562               if (line->min_size > shrink_fract)
 563                 {
 564                   shrink_width -= shrink_fract;
 565                   line->min_size -= shrink_fract;
 566                 }
 567               else
 568                 {
 569                   shrink_width -= line->min_size - 1;
 570                   line->min_size = 1;
 571                 }
 572             }
 573           n_shrink_lines--;
 574
 575           last = line_list;
 576           line_list->next = prev;
 577           prev = line_list;
 578           line_list = tmp;
 579         }
 580       line_list = last;
 581     }
 582
 583   if (n_lines)
 584     {
 585       Line *line;
 586       gfloat x, width, extra = 0;
 587
 588       width = area->width;
 589       width = MAX (n_lines, width - (n_lines - 1) * wbox->hspacing);
 590
 591       if (wbox->homogeneous)
 592         width /= ((gdouble) n_lines);
 593       else if (n_expand_lines)
 594         {
 595           width = MAX (0, width - total_width);
 596           extra = width / ((gdouble) n_expand_lines);
 597         }
 598       else
 599         width = 0;
 600
 601       x = area->x;
 602       line = line_list;
 603       while (line)
 604         {
 605           GtkAllocation col_allocation;
 606           Line *next_line = line->next;
 607
 608           col_allocation.y = area->y;
 609           col_allocation.height = area->height;
 610           if (wbox->homogeneous)
 611             col_allocation.width = width;
 612           else
 613             {
 614               col_allocation.width = line->min_size;
 615
 616               if (line->expand)
 617                 col_allocation.width += extra;
 618             }
 619
 620           col_allocation.x = x;
 621
 622           x += col_allocation.width + wbox->hspacing;
 623           layout_col (wbox,
 624                       &col_allocation,
 625                       line->children,
 626                       children_per_line,
 627                       line->expand);
 628
 629           g_slist_free (line->children);
 630           g_free (line);
 631           line = next_line;
 632         }
 633     }
 634 }
 635
 636 static void
 637 gtk_vwrap_box_size_allocate (GtkWidget     *widget,
 638                              GtkAllocation *allocation)
 639 {
 640   GtkWrapBox *wbox = GTK_WRAP_BOX (widget);
 641   GtkAllocation area;
 642   guint border = GTK_CONTAINER (wbox)->border_width; /*<h2v-skip>*/
 643
 644   widget->allocation = *allocation;
 645   area.y = allocation->y + border;
 646   area.x = allocation->x + border;
 647   area.height = MAX (1, (gint) allocation->height - border * 2);
 648   area.width = MAX (1, (gint) allocation->width - border * 2);
 649
 650   /*<h2v-off>*/
 651   /* g_print ("got: width %d, height %d\n",
 652      allocation->width,
 653      allocation->height);
 654   */
 655   /*<h2v-on>*/
 656
 657   layout_cols (wbox, &area);
 658 }