/*

 * Clutter.

 *

 * An OpenGL based 'interactive canvas' library.

 *

 * Copyright (C) 2010 Red Hat, Inc.

 * Copyright (C) 2012 Bastian Winkler <buz@netbuz.org>

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library. If not, see <http://www.gnu.org/licenses/>.

 *

 * Author:

 *   Bastian Winkler <buz@netbuz.org>

 *

 * Based on GtkGrid widget by:

 *   Matthias Clasen

 */

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include <string.h>

#include <math.h>

#include "clutter-grid-layout.h"

#include "clutter-actor-private.h"

#include "clutter-container.h"

#include "clutter-debug.h"

#include "clutter-enum-types.h"

#include "clutter-layout-meta.h"

#include "clutter-private.h"

/**

 * SECTION:clutter-grid-layout

 * @Short_description: A layout manager for a grid of actors

 * @Title: ClutterGridLayout

 * @See_also: #ClutterTableLayout, #ClutterBoxLayout

 *

 * #ClutterGridLayout is a layout manager which arranges its child widgets in

 * rows and columns. It is a very similar to #ClutterTableLayout and

 * #ClutterBoxLayout, but it consistently uses #ClutterActor's

 * alignment and expansion flags instead of custom child properties.

 *

 * Children are added using clutter_grid_layout_attach(). They can span

 * multiple rows or columns. It is also possible to add a child next to an

 * existing child, using clutter_grid_layout_attach_next_to(). The behaviour of

 * #ClutterGridLayout when several children occupy the same grid cell is undefined.

 *

 * #ClutterGridLayout can be used like a #ClutterBoxLayout by just using

 * clutter_actor_add_child(), which will place children next to each other in

 * the direction determined by the #ClutterGridLayout:orientation property.

 */

#define CLUTTER_TYPE_GRID_CHILD          (clutter_grid_child_get_type ())

#define CLUTTER_GRID_CHILD(obj)          (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_GRID_CHILD, ClutterGridChild))

#define CLUTTER_IS_GRID_CHILD(obj)       (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_GRID_CHILD))

typedef struct _ClutterGridChild        ClutterGridChild;

typedef struct _ClutterLayoutMetaClass  ClutterGridChildClass;

typedef struct _ClutterGridAttach       ClutterGridAttach;

typedef struct _ClutterGridLine         ClutterGridLine;

typedef struct _ClutterGridLines        ClutterGridLines;

typedef struct _ClutterGridLineData     ClutterGridLineData;

typedef struct _ClutterGridRequest      ClutterGridRequest;

struct _ClutterGridAttach

{

  gint pos;

  gint span;

};

struct _ClutterGridChild

{

  ClutterLayoutMeta parent_instance;

  ClutterGridAttach attach[2];

};

#define CHILD_LEFT(child)    ((child)->attach[CLUTTER_ORIENTATION_HORIZONTAL].pos)

#define CHILD_WIDTH(child)   ((child)->attach[CLUTTER_ORIENTATION_HORIZONTAL].span)

#define CHILD_TOP(child)     ((child)->attach[CLUTTER_ORIENTATION_VERTICAL].pos)

#define CHILD_HEIGHT(child)  ((child)->attach[CLUTTER_ORIENTATION_VERTICAL].span)

/* A ClutterGridLineData struct contains row/column specific parts

 * of the grid.

 */

struct _ClutterGridLineData

{

  gfloat spacing;

  guint homogeneous : 1;

};

struct _ClutterGridLayoutPrivate

{

  ClutterContainer *container;

  ClutterOrientation orientation;

  ClutterGridLineData linedata[2];

};

#define ROWS(priv)    (&(priv)->linedata[CLUTTER_ORIENTATION_HORIZONTAL])

#define COLUMNS(priv) (&(priv)->linedata[CLUTTER_ORIENTATION_VERTICAL])

/* A ClutterGridLine struct represents a single row or column

 * during size requests

 */

struct _ClutterGridLine

{

  gfloat minimum;

  gfloat natural;

  gfloat position;

  gfloat allocation;

  guint need_expand : 1;

  guint expand      : 1;

  guint empty       : 1;

};

struct _ClutterGridLines

{

  ClutterGridLine *lines;

  gint min, max;

};

struct _ClutterGridRequest

{

  ClutterGridLayout *grid;

  ClutterGridLines lines[2];

};

enum

{

  PROP_0,

  PROP_ORIENTATION,

  PROP_ROW_SPACING,

  PROP_COLUMN_SPACING,

  PROP_ROW_HOMOGENEOUS,

  PROP_COLUMN_HOMOGENEOUS,

  PROP_LAST

};

static GParamSpec *obj_props[PROP_LAST];

enum

{

  PROP_CHILD_0,

  PROP_CHILD_LEFT_ATTACH,

  PROP_CHILD_TOP_ATTACH,

  PROP_CHILD_WIDTH,

  PROP_CHILD_HEIGHT,

  PROP_CHILD_LAST

};

static GParamSpec *child_props[PROP_CHILD_LAST];

GType clutter_grid_child_get_type (void);

G_DEFINE_TYPE (ClutterGridChild, clutter_grid_child,

               CLUTTER_TYPE_LAYOUT_META)

G_DEFINE_TYPE_WITH_PRIVATE (ClutterGridLayout,

                            clutter_grid_layout,

                            CLUTTER_TYPE_LAYOUT_MANAGER)

#define GET_GRID_CHILD(grid, child) \

  (CLUTTER_GRID_CHILD(clutter_layout_manager_get_child_meta \

   (CLUTTER_LAYOUT_MANAGER((grid)),\

    CLUTTER_GRID_LAYOUT((grid))->priv->container,(child))))

static void

grid_attach (ClutterGridLayout *self,

             ClutterActor      *actor,

             gint               left,

             gint               top,

             gint               width,

             gint               height)

{

  ClutterGridChild *grid_child;

  grid_child = GET_GRID_CHILD (self, actor);

  CHILD_LEFT (grid_child) = left;

  CHILD_TOP (grid_child) = top;

  CHILD_WIDTH (grid_child) = width;

  CHILD_HEIGHT (grid_child) = height;

}

/* Find the position 'touching' existing

 * children. @orientation and @max determine

 * from which direction to approach (horizontal

 * + max = right, vertical + !max = top, etc).

 * @op_pos, @op_span determine the rows/columns

 * in which the touching has to happen.

 */

static gint

find_attach_position (ClutterGridLayout  *self,

                      ClutterOrientation  orientation,

                      gint                op_pos,

                      gint                op_span,

                      gboolean            max)

{

  ClutterGridLayoutPrivate *priv = self->priv;

  ClutterGridChild *grid_child;

  ClutterGridAttach *attach;

  ClutterGridAttach *opposite;

  ClutterActorIter iter;

  ClutterActor *child;

  gint pos;

  gboolean hit;

  if (max)

    pos = -G_MAXINT;

  else

    pos = G_MAXINT;

  hit = FALSE;

  if (!priv->container)

    return -1;

  clutter_actor_iter_init (&iter, CLUTTER_ACTOR (priv->container));

  while (clutter_actor_iter_next (&iter, &child))

    {

      grid_child = GET_GRID_CHILD (self, child);

      attach = &grid_child->attach[orientation];

      opposite = &grid_child->attach[1 - orientation];

      /* check if the ranges overlap */

      if (opposite->pos <= op_pos + op_span && op_pos <= opposite->pos + opposite->span)

        {

          hit = TRUE;

          if (max)

            pos = MAX (pos, attach->pos + attach->span);

          else

            pos = MIN (pos, attach->pos);

        }

     }

  if (!hit)

    pos = 0;

  return pos;

}

static void

grid_attach_next_to (ClutterGridLayout   *layout,

                     ClutterActor        *child,

                     ClutterActor        *sibling,

                     ClutterGridPosition  side,

                     gint                 width,

                     gint                 height)

{

  ClutterGridChild *grid_sibling;

  gint left, top;

  if (sibling)

    {

      grid_sibling = GET_GRID_CHILD (layout, sibling);

      switch (side)

        {

        case CLUTTER_GRID_POSITION_LEFT:

          left = CHILD_LEFT (grid_sibling) - width;

          top = CHILD_TOP (grid_sibling);

          break;

        case CLUTTER_GRID_POSITION_RIGHT:

          left = CHILD_LEFT (grid_sibling) + CHILD_WIDTH (grid_sibling);

          top = CHILD_TOP (grid_sibling);

          break;

        case CLUTTER_GRID_POSITION_TOP:

          left = CHILD_LEFT (grid_sibling);

          top = CHILD_TOP (grid_sibling) - height;

          break;

        case CLUTTER_GRID_POSITION_BOTTOM:

          left = CHILD_LEFT (grid_sibling);

          top = CHILD_TOP (grid_sibling) + CHILD_HEIGHT (grid_sibling);

          break;

        default:

          g_assert_not_reached ();

        }

    }

  else

    {

      switch (side)

        {

        case CLUTTER_GRID_POSITION_LEFT:

          left = find_attach_position (layout, CLUTTER_ORIENTATION_HORIZONTAL,

                                       0, height, FALSE);

          left -= width;

          top = 0;

          break;

        case CLUTTER_GRID_POSITION_RIGHT:

          left = find_attach_position (layout, CLUTTER_ORIENTATION_HORIZONTAL,

                                       0, height, TRUE);

          top = 0;

          break;

        case CLUTTER_GRID_POSITION_TOP:

          left = 0;

          top = find_attach_position (layout, CLUTTER_ORIENTATION_VERTICAL,

                                      0, width, FALSE);

          top -= height;

          break;

        case CLUTTER_GRID_POSITION_BOTTOM:

          left = 0;

          top = find_attach_position (layout, CLUTTER_ORIENTATION_VERTICAL,

                                      0, width, TRUE);

          break;

        default:

          g_assert_not_reached ();

        }

    }

  grid_attach (layout, child, left, top, width, height);

}

static void

clutter_grid_request_update_child_attach (ClutterGridRequest *request,

                                          ClutterActor       *actor)

{

  ClutterGridLayoutPrivate *priv = request->grid->priv;

  ClutterGridChild *grid_child;

  grid_child = GET_GRID_CHILD (request->grid, actor);

  if (CHILD_LEFT (grid_child) == -1 || CHILD_TOP (grid_child) == -1)

    {

      ClutterGridPosition side;

      ClutterActor *sibling;

      if (priv->orientation == CLUTTER_ORIENTATION_HORIZONTAL)

        {

          ClutterTextDirection td;

          gboolean rtl;

          ClutterActor *container = CLUTTER_ACTOR (priv->container);

          td = clutter_actor_get_text_direction (container);

          rtl = (td == CLUTTER_TEXT_DIRECTION_RTL) ? TRUE : FALSE;

          side = rtl ? CLUTTER_GRID_POSITION_LEFT : CLUTTER_GRID_POSITION_RIGHT;

        }

      else

        {

          /* XXX: maybe we should also add a :pack-start property to modify

           * this */

          side = CLUTTER_GRID_POSITION_BOTTOM;

        }

      sibling = clutter_actor_get_previous_sibling (actor);

      if (sibling)

        clutter_grid_layout_insert_next_to (request->grid, sibling, side);

      grid_attach_next_to (request->grid, actor, sibling, side,

                           CHILD_WIDTH (grid_child),

                           CHILD_HEIGHT (grid_child));

    }

}

static void

clutter_grid_request_update_attach (ClutterGridRequest *request)

{

  ClutterGridLayoutPrivate *priv = request->grid->priv;

  ClutterActorIter iter;

  ClutterActor *child;

  clutter_actor_iter_init (&iter, CLUTTER_ACTOR (priv->container));

  while (clutter_actor_iter_next (&iter, &child))

    clutter_grid_request_update_child_attach (request, child);

}

/* Calculates the min and max numbers for both orientations.

 */

static void

clutter_grid_request_count_lines (ClutterGridRequest *request)

{

  ClutterGridLayoutPrivate *priv = request->grid->priv;

  ClutterGridChild *grid_child;

  ClutterGridAttach *attach;

  ClutterActorIter iter;

  ClutterActor *child;

  gint min[2];

  gint max[2];

  min[0] = min[1] = G_MAXINT;

  max[0] = max[1] = G_MININT;

  clutter_actor_iter_init (&iter, CLUTTER_ACTOR (priv->container));

  while (clutter_actor_iter_next (&iter, &child))

    {

      grid_child = GET_GRID_CHILD (request->grid, child);

      attach = grid_child->attach;

      min[0] = MIN (min[0], attach[0].pos);

      max[0] = MAX (max[0], attach[0].pos + attach[0].span);

      min[1] = MIN (min[1], attach[1].pos);

      max[1] = MAX (max[1], attach[1].pos + attach[1].span);

    }

  request->lines[0].min = min[0];

  request->lines[0].max = max[0];

  request->lines[1].min = min[1];

  request->lines[1].max = max[1];

}

/* Sets line sizes to 0 and marks lines as expand

 * if they have a non-spanning expanding child.

 */

static void

clutter_grid_request_init (ClutterGridRequest *request,

                           ClutterOrientation  orientation)

{

  ClutterGridLayoutPrivate *priv = request->grid->priv;

  ClutterGridChild *grid_child;

  ClutterGridAttach *attach;

  ClutterGridLines *lines;

  ClutterActorIter iter;

  ClutterActor *child;

  gint i;

  lines = &request->lines[orientation];

  for (i = 0; i < lines->max - lines->min; i++)

    {

      lines->lines[i].minimum = 0;

      lines->lines[i].natural = 0;

      lines->lines[i].expand = FALSE;

    }

  clutter_actor_iter_init (&iter, CLUTTER_ACTOR (priv->container));

  while (clutter_actor_iter_next (&iter, &child))

    {

      grid_child = GET_GRID_CHILD (request->grid, child);

      attach = &grid_child->attach[orientation];

      if (attach->span == 1 && clutter_actor_needs_expand (child, orientation))

        lines->lines[attach->pos - lines->min].expand = TRUE;

    }

}

/* Sums allocations for lines spanned by child and their spacing.

 */

static gfloat

compute_allocation_for_child (ClutterGridRequest *request,

                              ClutterActor       *child,

                              ClutterOrientation  orientation)

{

  ClutterGridLayoutPrivate *priv = request->grid->priv;

  ClutterGridChild *grid_child;

  ClutterGridLineData *linedata;

  ClutterGridLines *lines;

  ClutterGridLine *line;

  ClutterGridAttach *attach;

  gfloat size;

  gint i;

  grid_child = GET_GRID_CHILD (request->grid, child);

  linedata = &priv->linedata[orientation];

  lines = &request->lines[orientation];

  attach = &grid_child->attach[orientation];

  size = (attach->span - 1) * linedata->spacing;

  for (i = 0; i < attach->span; i++)

    {

      line = &lines->lines[attach->pos - lines->min + i];

      size += line->allocation;

    }

  return size;

}

static void

compute_request_for_child (ClutterGridRequest *request,

                           ClutterActor       *child,

                           ClutterOrientation  orientation,

                           gboolean            contextual,

                           gfloat             *minimum,

                           gfloat             *natural)

{

  if (contextual)

    {

      gfloat size;

      size = compute_allocation_for_child (request, child, 1 - orientation);

      if (orientation == CLUTTER_ORIENTATION_HORIZONTAL)

        clutter_actor_get_preferred_width (child, size, minimum, natural);

      else

        clutter_actor_get_preferred_height (child, size, minimum, natural);

    }

  else

    {

      if (orientation == CLUTTER_ORIENTATION_HORIZONTAL)

        clutter_actor_get_preferred_width (child, -1, minimum, natural);

      else

        clutter_actor_get_preferred_height (child, -1, minimum, natural);

    }

}

/* Sets requisition to max. of non-spanning children.

 * If contextual is TRUE, requires allocations of

 * lines in the opposite orientation to be set.

 */

static void

clutter_grid_request_non_spanning (ClutterGridRequest *request,

                                   ClutterOrientation  orientation,

                                   gboolean            contextual)

{

  ClutterGridLayoutPrivate *priv = request->grid->priv;

  ClutterGridChild *grid_child;

  ClutterGridAttach *attach;

  ClutterGridLines *lines;

  ClutterGridLine *line;

  ClutterActorIter iter;

  ClutterActor *child;

  gfloat minimum;

  gfloat natural;

  lines = &request->lines[orientation];

  clutter_actor_iter_init (&iter, CLUTTER_ACTOR (priv->container));

  while (clutter_actor_iter_next (&iter, &child))

    {

      if (!clutter_actor_is_visible (child))

        continue;

      grid_child = GET_GRID_CHILD (request->grid, child);

      attach = &grid_child->attach[orientation];

      if (attach->span != 1)

        continue;

      compute_request_for_child (request, child, orientation, contextual, &minimum, &natural);

      line = &lines->lines[attach->pos - lines->min];

      line->minimum = MAX (line->minimum, minimum);

      line->natural = MAX (line->natural, natural);

    }

}

/* Enforce homogeneous sizes.

 */

static void

clutter_grid_request_homogeneous (ClutterGridRequest *request,

                                  ClutterOrientation  orientation)

{

  ClutterGridLayoutPrivate *priv = request->grid->priv;

  ClutterGridLineData *linedata;

  ClutterGridLines *lines;

  gfloat minimum, natural;

  gint i;

  linedata = &priv->linedata[orientation];

  lines = &request->lines[orientation];

  if (!linedata->homogeneous)

    return;

  minimum = 0.0f;

  natural = 0.0f;

  for (i = 0; i < lines->max - lines->min; i++)

    {

      minimum = MAX (minimum, lines->lines[i].minimum);

      natural = MAX (natural, lines->lines[i].natural);

    }

  for (i = 0; i < lines->max - lines->min; i++)

    {

      lines->lines[i].minimum = minimum;

      lines->lines[i].natural = natural;

    }

}

/* Deals with spanning children.

 * Requires expand fields of lines to be set for

 * non-spanning children.

 */

static void

clutter_grid_request_spanning (ClutterGridRequest *request,

                               ClutterOrientation  orientation,

                               gboolean            contextual)

{

  ClutterGridLayoutPrivate *priv = request->grid->priv;

  ClutterGridChild *grid_child;

  ClutterActor *child;

  ClutterActorIter iter;

  ClutterGridAttach *attach;

  ClutterGridLineData *linedata;

  ClutterGridLines *lines;

  ClutterGridLine *line;

  gfloat minimum;

  gfloat natural;

  gint span_minimum;

  gint span_natural;

  gint span_expand;

  gboolean force_expand;

  gint extra;

  gint expand;

  gint line_extra;

  gint i;

  linedata = &priv->linedata[orientation];

  lines = &request->lines[orientation];

  clutter_actor_iter_init (&iter, CLUTTER_ACTOR (priv->container));

  while (clutter_actor_iter_next (&iter, &child))

    {

      if (!clutter_actor_is_visible (child))

        continue;

      grid_child = GET_GRID_CHILD (request->grid, child);

      attach = &grid_child->attach[orientation];

      if (attach->span == 1)

        continue;

      compute_request_for_child (request, child, orientation, contextual,

                                 &minimum, &natural);

      span_minimum = (attach->span - 1) * linedata->spacing;

      span_natural = (attach->span - 1) * linedata->spacing;

      span_expand = 0;

      force_expand = FALSE;

      for (i = 0; i < attach->span; i++)

        {

          line = &lines->lines[attach->pos - lines->min + i];

          span_minimum += line->minimum;

          span_natural += line->natural;

          if (line->expand)

            span_expand += 1;

        }

      if (span_expand == 0)

        {

          span_expand = attach->span;

          force_expand = TRUE;

        }

      /* If we need to request more space for this child to fill

       * its requisition, then divide up the needed space amongst the

       * lines it spans, favoring expandable lines if any.

       *

       * When doing homogeneous allocation though, try to keep the

       * line allocations even, since we're going to force them to

       * be the same anyway, and we don't want to introduce unnecessary

       * extra space.

       */

      if (span_minimum < minimum)

        {

          if (linedata->homogeneous)

            {

              gint total, m;

              total = minimum - (attach->span - 1) * linedata->spacing;

              m = total / attach->span + (total % attach->span ? 1 : 0);

              for (i = 0; i < attach->span; i++)

                {

                  line = &lines->lines[attach->pos - lines->min + i];

                  line->minimum = MAX(line->minimum, m);

                }

            }

          else

            {

              extra = minimum - span_minimum;

              expand = span_expand;

              for (i = 0; i < attach->span; i++)

                {

                  line = &lines->lines[attach->pos - lines->min + i];

                  if (force_expand || line->expand)

                    {

                      line_extra = extra / expand;

                      line->minimum += line_extra;

                      extra -= line_extra;

                      expand -= 1;

                    }

                }

            }

        }

      if (span_natural < natural)

        {

          if (linedata->homogeneous)

            {

              gint total, n;

              total = natural - (attach->span - 1) * linedata->spacing;

              n = total / attach->span + (total % attach->span ? 1 : 0);

              for (i = 0; i < attach->span; i++)

                {

                  line = &lines->lines[attach->pos - lines->min + i];

                  line->natural = MAX(line->natural, n);

                }

            }

          else

            {

              extra = natural - span_natural;

              expand = span_expand;

              for (i = 0; i < attach->span; i++)

                {

                  line = &lines->lines[attach->pos - lines->min + i];

                  if (force_expand || line->expand)

                    {

                      line_extra = extra / expand;

                      line->natural += line_extra;

                      extra -= line_extra;

                      expand -= 1;

                    }

                }

            }

        }

    }

}

/* Marks empty and expanding lines and counts them.

 */

static void

clutter_grid_request_compute_expand (ClutterGridRequest *request,

                                     ClutterOrientation  orientation,

                                     gint               *nonempty_lines,

                                     gint               *expand_lines)

{

  ClutterGridLayoutPrivate *priv = request->grid->priv;

  ClutterGridChild *grid_child;

  ClutterGridAttach *attach;

  ClutterActorIter iter;

  ClutterActor *child;

  gint i;

  ClutterGridLines *lines;

  ClutterGridLine *line;

  gboolean has_expand;

  gint expand;

  gint empty;

  lines = &request->lines[orientation];

  for (i = 0; i < lines->max - lines->min; i++)

    {

      lines->lines[i].need_expand = FALSE;

      lines->lines[i].expand = FALSE;

      lines->lines[i].empty = TRUE;

    }

  clutter_actor_iter_init (&iter, CLUTTER_ACTOR (priv->container));

  while (clutter_actor_iter_next (&iter, &child))

    {

      if (!clutter_actor_is_visible (child))

        continue;

      grid_child = GET_GRID_CHILD (request->grid, child);

      attach = &grid_child->attach[orientation];

      if (attach->span != 1)

        continue;

      line = &lines->lines[attach->pos - lines->min];

      line->empty = FALSE;

      if (clutter_actor_needs_expand (child, orientation))

        line->expand = TRUE;

    }

  clutter_actor_iter_init (&iter, CLUTTER_ACTOR (priv->container));

  while (clutter_actor_iter_next (&iter, &child))

    {

      if (!clutter_actor_is_visible (child))

        continue;

      grid_child = GET_GRID_CHILD (request->grid, child);

      attach = &grid_child->attach[orientation];

      if (attach->span == 1)

        continue;

      has_expand = FALSE;

      for (i = 0; i < attach->span; i++)

        {

          line = &lines->lines[attach->pos - lines->min + i];

          line->empty = FALSE;

          if (line->expand)

            has_expand = TRUE;

        }

      if (!has_expand && clutter_actor_needs_expand (child, orientation))

        {

          for (i = 0; i < attach->span; i++)

            {

              line = &lines->lines[attach->pos - lines->min + i];

              line->need_expand = TRUE;

            }

        }

    }

  empty = 0;

  expand = 0;

  for (i = 0; i < lines->max - lines->min; i++)

    {

      line = &lines->lines[i];

      if (line->need_expand)

        line->expand = TRUE;

      if (line->empty)

        empty += 1;

      if (line->expand)

        expand += 1;

    }

  if (nonempty_lines)

    *nonempty_lines = lines->max - lines->min - empty;

  if (expand_lines)

    *expand_lines = expand;

}

/* Sums the minimum and natural fields of lines and their spacing.

 */

static void

clutter_grid_request_sum (ClutterGridRequest *request,

                          ClutterOrientation  orientation,

                          gfloat             *minimum,

                          gfloat             *natural)

{

  ClutterGridLayoutPrivate *priv = request->grid->priv;

  ClutterGridLineData *linedata;

  ClutterGridLines *lines;

  gint i;

  gfloat min, nat;

  gint nonempty;

  clutter_grid_request_compute_expand (request, orientation, &nonempty, NULL);

  linedata = &priv->linedata[orientation];

  lines = &request->lines[orientation];

  min = 0;

  nat = 0;

  if (nonempty > 0)

    {

      min = (nonempty - 1) * linedata->spacing;

      nat = (nonempty - 1) * linedata->spacing;

    }

  for (i = 0; i < lines->max - lines->min; i++)

    {

      min += lines->lines[i].minimum;

      nat += lines->lines[i].natural;

    }

  if (minimum)

    *minimum = min;

  if (natural)

    *natural = nat;

}

/* Computes minimum and natural fields of lines.

 * When contextual is TRUE, requires allocation of

 * lines in the opposite orientation to be set.

 */