sungmg/mutter-performance-source
1
0
Fork 0
Code Activity
mutter-performance-source/clutter/clutter-flow-layout.c

1538 lines
44 KiB
C
Raw Normal View History

[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
/*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Copyright (C) 2009 Intel Corporation.
*
* 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:
* Emmanuele Bassi <ebassi@linux.intel.com>
*/
/**
* SECTION:clutter-flow-layout
* @short_description: A reflowing layout manager
*
* #ClutterFlowLayout is a layout manager which implements the following
* policy:
*
docs: Move to markdown We're removing docbook tags in favour of the markdown syntax.
2014-03-17 23:07:58 +00:00
* - the preferred natural size depends on the value
layout, docs: Add long description for FlowLayout Add the full description of the layout policy
2009-10-15 13:11:36 +00:00
* of the #ClutterFlowLayout:orientation property; the layout will try
* to maintain all its children on a single row or
docs: Move to markdown We're removing docbook tags in favour of the markdown syntax.
2014-03-17 23:07:58 +00:00
* column;
* - if either the width or the height allocated are
layout, docs: Add long description for FlowLayout Add the full description of the layout policy
2009-10-15 13:11:36 +00:00
* smaller than the preferred ones, the layout will wrap; in this case,
* the preferred height or width, respectively, will take into account
docs: Move to markdown We're removing docbook tags in favour of the markdown syntax.
2014-03-17 23:07:58 +00:00
* the amount of columns and rows;
* - each line (either column or row) in reflowing will
layout, docs: Add long description for FlowLayout Add the full description of the layout policy
2009-10-15 13:11:36 +00:00
* have the size of the biggest cell on that line; if the
* #ClutterFlowLayout:homogeneous property is set to %FALSE the actor
* will be allocated within that area, and if set to %TRUE instead the
docs: Move to markdown We're removing docbook tags in favour of the markdown syntax.
2014-03-17 23:07:58 +00:00
* actor will be given exactly that area;
* - the size of the columns or rows can be controlled
layout, docs: Add long description for FlowLayout Add the full description of the layout policy
2009-10-15 13:11:36 +00:00
* for both minimum and maximum; the spacing can also be controlled
docs: Move to markdown We're removing docbook tags in favour of the markdown syntax.
2014-03-17 23:07:58 +00:00
* in both columns and rows.
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
*
docs: Move to markdown We're removing docbook tags in favour of the markdown syntax.
2014-03-17 23:07:58 +00:00
* The [flow-layout example](https://git.gnome.org/browse/clutter/tree/examples/flow-layout.c?h=clutter-1.18)
* shows how to use the #ClutterFlowLayout.
Move FlowLayout test into examples There's nothing really test-worthy in the ClutterFlowLayout interactive test; it can be lifted pretty much as is, and placed into the examples.
2012-05-02 11:14:45 +00:00
*
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
* #ClutterFlowLayout is available since Clutter 1.2
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <math.h>
Deprecate Container add() and remove() methods This will make things interesting. We have better replacements in ClutterActor, that do The Right Thing™ instead of deferring control and requiring reimplementation in every single container actor.
2011-12-19 18:48:02 +00:00
#define CLUTTER_DISABLE_DEPRECATION_WARNINGS
#include "deprecated/clutter-container.h"
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
#include "clutter-actor.h"
#include "clutter-animatable.h"
#include "clutter-child-meta.h"
#include "clutter-debug.h"
#include "clutter-enum-types.h"
#include "clutter-flow-layout.h"
#include "clutter-layout-meta.h"
#include "clutter-private.h"
struct _ClutterFlowLayoutPrivate
{
ClutterContainer *container;
ClutterFlowOrientation orientation;
gfloat col_spacing;
gfloat row_spacing;
gfloat min_col_width;
gfloat max_col_width;
gfloat col_width;
gfloat min_row_height;
gfloat max_row_height;
gfloat row_height;
layout: Report the correct size of FlowLayout FlowLayout should compute the correct height for the assigned width when in horizontal flow, and the correct width for the assigned height when in vertical flow. This means pre-computing the number of lines inside the get_preferred_width() and get_preferred_height(). We can then cache the computed column width and row height, cache them inside the layout and then use them when allocating the children.
2009-10-08 14:45:29 +00:00
/* per-line size */
GArray *line_min;
GArray *line_natural;
flow-layout: Blow the cached preferred size if needed If the FlowLayout layout manager wasn't allocated the same size it requested then it should blow its caches and recompute the layout with the given allocation size.
2010-09-17 11:43:23 +00:00
gfloat req_width;
gfloat req_height;
layout: Report the correct size of FlowLayout FlowLayout should compute the correct height for the assigned width when in horizontal flow, and the correct width for the assigned height when in vertical flow. This means pre-computing the number of lines inside the get_preferred_width() and get_preferred_height(). We can then cache the computed column width and row height, cache them inside the layout and then use them when allocating the children.
2009-10-08 14:45:29 +00:00
guint line_count;
[layout] Add :homogeneous to FlowLayout
2009-10-06 15:17:16 +00:00
guint is_homogeneous : 1;
flow-layout: Add :snap-to-grid property Add a :snap-to-grid property to FlowLayout to prevent the layout from assigning it's children a position based on the size of the largest child. https://bugzilla.gnome.org/show_bug.cgi?id=648873
2013-05-03 15:53:44 +00:00
guint snap_to_grid : 1;
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
};
enum
{
PROP_0,
PROP_ORIENTATION,
[layout] Add :homogeneous to FlowLayout
2009-10-06 15:17:16 +00:00
PROP_HOMOGENEOUS,
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
PROP_COLUMN_SPACING,
PROP_ROW_SPACING,
PROP_MIN_COLUMN_WIDTH,
PROP_MAX_COLUMN_WIDTH,
PROP_MIN_ROW_HEGHT,
Move more classes to install_properties()
2010-10-15 14:24:27 +00:00
PROP_MAX_ROW_HEIGHT,
flow-layout: Add :snap-to-grid property Add a :snap-to-grid property to FlowLayout to prevent the layout from assigning it's children a position based on the size of the largest child. https://bugzilla.gnome.org/show_bug.cgi?id=648873
2013-05-03 15:53:44 +00:00
PROP_SNAP_TO_GRID,
Move more classes to install_properties()
2010-10-15 14:24:27 +00:00
N_PROPERTIES
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
};
Move more classes to install_properties()
2010-10-15 14:24:27 +00:00
static GParamSpec *flow_properties[N_PROPERTIES] = { NULL, };
Use the new macros for adding private data
2013-07-03 13:14:01 +00:00
G_DEFINE_TYPE_WITH_PRIVATE (ClutterFlowLayout,
clutter_flow_layout,
CLUTTER_TYPE_LAYOUT_MANAGER)
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
layout: Report the correct size of FlowLayout FlowLayout should compute the correct height for the assigned width when in horizontal flow, and the correct width for the assigned height when in vertical flow. This means pre-computing the number of lines inside the get_preferred_width() and get_preferred_height(). We can then cache the computed column width and row height, cache them inside the layout and then use them when allocating the children.
2009-10-08 14:45:29 +00:00
static gint
get_columns (ClutterFlowLayout *self,
gfloat for_width)
{
ClutterFlowLayoutPrivate *priv = self->priv;
gint n_columns;
if (for_width < 0)
return 1;
if (priv->col_width == 0)
return 1;
n_columns = (gint) (for_width + priv->col_spacing)
/ (priv->col_width + priv->col_spacing);
if (n_columns == 0)
return 1;
return n_columns;
}
static gint
get_rows (ClutterFlowLayout *self,
gfloat for_height)
{
ClutterFlowLayoutPrivate *priv = self->priv;
gint n_rows;
if (for_height < 0)
return 1;
if (priv->row_height == 0)
return 1;
n_rows = (gint) (for_height + priv->row_spacing)
/ (priv->row_height + priv->row_spacing);
if (n_rows == 0)
return 1;
return n_rows;
}
static gint
compute_lines (ClutterFlowLayout *self,
gfloat avail_width,
gfloat avail_height)
{
ClutterFlowLayoutPrivate *priv = self->priv;
if (priv->orientation == CLUTTER_FLOW_HORIZONTAL)
return get_columns (self, avail_width);
else
return get_rows (self, avail_height);
}
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
static void
clutter_flow_layout_get_preferred_width (ClutterLayoutManager *manager,
ClutterContainer *container,
gfloat for_height,
gfloat *min_width_p,
gfloat *nat_width_p)
{
ClutterFlowLayoutPrivate *priv = CLUTTER_FLOW_LAYOUT (manager)->priv;
layout: Report the correct size of FlowLayout FlowLayout should compute the correct height for the assigned width when in horizontal flow, and the correct width for the assigned height when in vertical flow. This means pre-computing the number of lines inside the get_preferred_width() and get_preferred_height(). We can then cache the computed column width and row height, cache them inside the layout and then use them when allocating the children.
2009-10-08 14:45:29 +00:00
gint n_rows, line_item_count, line_count;
gfloat total_min_width, total_natural_width;
gfloat line_min_width, line_natural_width;
gfloat max_min_width, max_natural_width;
Port remaining layout managers to the new child iteration API TableLayout and FlowLayout now use the ClutterActor API for iterating over the children of an actor.
2011-12-18 11:26:29 +00:00
ClutterActor *actor, *child;
Use ClutterActorIter inside layout managers Whenever it is possible, or convenient.
2012-01-30 10:55:30 +00:00
ClutterActorIter iter;
layout: Report the correct size of FlowLayout FlowLayout should compute the correct height for the assigned width when in horizontal flow, and the correct width for the assigned height when in vertical flow. This means pre-computing the number of lines inside the get_preferred_width() and get_preferred_height(). We can then cache the computed column width and row height, cache them inside the layout and then use them when allocating the children.
2009-10-08 14:45:29 +00:00
gfloat item_y;
n_rows = get_rows (CLUTTER_FLOW_LAYOUT (manager), for_height);
total_min_width = 0;
total_natural_width = 0;
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
layout: Report the correct size of FlowLayout FlowLayout should compute the correct height for the assigned width when in horizontal flow, and the correct width for the assigned height when in vertical flow. This means pre-computing the number of lines inside the get_preferred_width() and get_preferred_height(). We can then cache the computed column width and row height, cache them inside the layout and then use them when allocating the children.
2009-10-08 14:45:29 +00:00
line_min_width = 0;
line_natural_width = 0;
line_item_count = 0;
line_count = 0;
item_y = 0;
Port remaining layout managers to the new child iteration API TableLayout and FlowLayout now use the ClutterActor API for iterating over the children of an actor.
2011-12-18 11:26:29 +00:00
actor = CLUTTER_ACTOR (container);
layout: Report the correct size of FlowLayout FlowLayout should compute the correct height for the assigned width when in horizontal flow, and the correct width for the assigned height when in vertical flow. This means pre-computing the number of lines inside the get_preferred_width() and get_preferred_height(). We can then cache the computed column width and row height, cache them inside the layout and then use them when allocating the children.
2009-10-08 14:45:29 +00:00
/* clear the line width arrays */
flow-layout: Provide a preferred size The FlowLayout fails to provide a preferred size in case no sizing is specified on one axis. It should, instead, have the preferred size of the sum of its children, depending on the orientation property. http://bugzilla.openedhand.com/show_bug.cgi?id=2013
2010-03-02 15:08:01 +00:00
if (priv->line_min != NULL)
g_array_free (priv->line_min, TRUE);
layout: Report the correct size of FlowLayout FlowLayout should compute the correct height for the assigned width when in horizontal flow, and the correct width for the assigned height when in vertical flow. This means pre-computing the number of lines inside the get_preferred_width() and get_preferred_height(). We can then cache the computed column width and row height, cache them inside the layout and then use them when allocating the children.
2009-10-08 14:45:29 +00:00
flow-layout: Provide a preferred size The FlowLayout fails to provide a preferred size in case no sizing is specified on one axis. It should, instead, have the preferred size of the sum of its children, depending on the orientation property. http://bugzilla.openedhand.com/show_bug.cgi?id=2013
2010-03-02 15:08:01 +00:00
if (priv->line_natural != NULL)
g_array_free (priv->line_natural, TRUE);
layout: Report the correct size of FlowLayout FlowLayout should compute the correct height for the assigned width when in horizontal flow, and the correct width for the assigned height when in vertical flow. This means pre-computing the number of lines inside the get_preferred_width() and get_preferred_height(). We can then cache the computed column width and row height, cache them inside the layout and then use them when allocating the children.
2009-10-08 14:45:29 +00:00
flow-layout: Provide a preferred size The FlowLayout fails to provide a preferred size in case no sizing is specified on one axis. It should, instead, have the preferred size of the sum of its children, depending on the orientation property. http://bugzilla.openedhand.com/show_bug.cgi?id=2013
2010-03-02 15:08:01 +00:00
priv->line_min = g_array_sized_new (FALSE, FALSE,
sizeof (gfloat),
16);
priv->line_natural = g_array_sized_new (FALSE, FALSE,
layout: Report the correct size of FlowLayout FlowLayout should compute the correct height for the assigned width when in horizontal flow, and the correct width for the assigned height when in vertical flow. This means pre-computing the number of lines inside the get_preferred_width() and get_preferred_height(). We can then cache the computed column width and row height, cache them inside the layout and then use them when allocating the children.
2009-10-08 14:45:29 +00:00
sizeof (gfloat),
16);
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
Port remaining layout managers to the new child iteration API TableLayout and FlowLayout now use the ClutterActor API for iterating over the children of an actor.
2011-12-18 11:26:29 +00:00
if (clutter_actor_get_n_children (actor) != 0)
flow-layout: Include the first line when calculating number of lines This ensures that the preferred height / width height takes into consideration the correct amount of padding
2009-12-01 17:44:42 +00:00
line_count = 1;
Fix some compiler warnings GCC complains that some variable might be used uninitialized.
2010-02-09 16:57:14 +00:00
max_min_width = max_natural_width = 0;
Use ClutterActorIter inside layout managers Whenever it is possible, or convenient.
2012-01-30 10:55:30 +00:00
clutter_actor_iter_init (&iter, actor);
while (clutter_actor_iter_next (&iter, &child))
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
{
gfloat child_min, child_natural;
layout: Report the correct size of FlowLayout FlowLayout should compute the correct height for the assigned width when in horizontal flow, and the correct width for the assigned height when in vertical flow. This means pre-computing the number of lines inside the get_preferred_width() and get_preferred_height(). We can then cache the computed column width and row height, cache them inside the layout and then use them when allocating the children.
2009-10-08 14:45:29 +00:00
gfloat new_y, item_height;
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
Stop using macros for accessing actor state Use the newly added functions instead.
2015-04-23 16:39:30 +00:00
if (!clutter_actor_is_visible (child))
[layout] Skip invisible children in FlowLayout Skip hidden actors when computing the preferred size and when allocating.
2009-10-07 10:39:18 +00:00
continue;
layout: Report the correct size of FlowLayout FlowLayout should compute the correct height for the assigned width when in horizontal flow, and the correct width for the assigned height when in vertical flow. This means pre-computing the number of lines inside the get_preferred_width() and get_preferred_height(). We can then cache the computed column width and row height, cache them inside the layout and then use them when allocating the children.
2009-10-08 14:45:29 +00:00
if (priv->orientation == CLUTTER_FLOW_VERTICAL && for_height > 0)
{
flow-layout: Add :snap-to-grid property Add a :snap-to-grid property to FlowLayout to prevent the layout from assigning it's children a position based on the size of the largest child. https://bugzilla.gnome.org/show_bug.cgi?id=648873
2013-05-03 15:53:44 +00:00
clutter_actor_get_preferred_height (child, -1,
&child_min,
&child_natural);
if ((priv->snap_to_grid && line_item_count == n_rows) ||
(!priv->snap_to_grid && item_y + child_natural > for_height))
layout: Report the correct size of FlowLayout FlowLayout should compute the correct height for the assigned width when in horizontal flow, and the correct width for the assigned height when in vertical flow. This means pre-computing the number of lines inside the get_preferred_width() and get_preferred_height(). We can then cache the computed column width and row height, cache them inside the layout and then use them when allocating the children.
2009-10-08 14:45:29 +00:00
{
total_min_width += line_min_width;
total_natural_width += line_natural_width;
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
layout: Report the correct size of FlowLayout FlowLayout should compute the correct height for the assigned width when in horizontal flow, and the correct width for the assigned height when in vertical flow. This means pre-computing the number of lines inside the get_preferred_width() and get_preferred_height(). We can then cache the computed column width and row height, cache them inside the layout and then use them when allocating the children.
2009-10-08 14:45:29 +00:00
g_array_append_val (priv->line_min,
line_min_width);
g_array_append_val (priv->line_natural,
line_natural_width);
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
layout: Report the correct size of FlowLayout FlowLayout should compute the correct height for the assigned width when in horizontal flow, and the correct width for the assigned height when in vertical flow. This means pre-computing the number of lines inside the get_preferred_width() and get_preferred_height(). We can then cache the computed column width and row height, cache them inside the layout and then use them when allocating the children.
2009-10-08 14:45:29 +00:00
line_min_width = line_natural_width = 0;
line_item_count = 0;
line_count += 1;
item_y = 0;
}
flow-layout: Add :snap-to-grid property Add a :snap-to-grid property to FlowLayout to prevent the layout from assigning it's children a position based on the size of the largest child. https://bugzilla.gnome.org/show_bug.cgi?id=648873
2013-05-03 15:53:44 +00:00
if (priv->snap_to_grid)
{
new_y = ((line_item_count + 1) * (for_height + priv->row_spacing))
/ n_rows;
item_height = new_y - item_y - priv->row_spacing;
}
else
{
new_y = item_y + child_natural + priv->row_spacing;
item_height = child_natural;
}
layout: Report the correct size of FlowLayout FlowLayout should compute the correct height for the assigned width when in horizontal flow, and the correct width for the assigned height when in vertical flow. This means pre-computing the number of lines inside the get_preferred_width() and get_preferred_height(). We can then cache the computed column width and row height, cache them inside the layout and then use them when allocating the children.
2009-10-08 14:45:29 +00:00
clutter_actor_get_preferred_width (child, item_height,
&child_min,
&child_natural);
line_min_width = MAX (line_min_width, child_min);
line_natural_width = MAX (line_natural_width, child_natural);
item_y = new_y;
line_item_count += 1;
max_min_width = MAX (max_min_width, line_min_width);
max_natural_width = MAX (max_natural_width, line_natural_width);
}
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
else
layout: Report the correct size of FlowLayout FlowLayout should compute the correct height for the assigned width when in horizontal flow, and the correct width for the assigned height when in vertical flow. This means pre-computing the number of lines inside the get_preferred_width() and get_preferred_height(). We can then cache the computed column width and row height, cache them inside the layout and then use them when allocating the children.
2009-10-08 14:45:29 +00:00
{
clutter_actor_get_preferred_width (child, for_height,
&child_min,
&child_natural);
max_min_width = MAX (max_min_width, child_min);
max_natural_width = MAX (max_natural_width, child_natural);
flow-layout: Provide a preferred size The FlowLayout fails to provide a preferred size in case no sizing is specified on one axis. It should, instead, have the preferred size of the sum of its children, depending on the orientation property. http://bugzilla.openedhand.com/show_bug.cgi?id=2013
2010-03-02 15:08:01 +00:00
total_min_width += max_min_width;
total_natural_width += max_natural_width;
layout: Report the correct size of FlowLayout FlowLayout should compute the correct height for the assigned width when in horizontal flow, and the correct width for the assigned height when in vertical flow. This means pre-computing the number of lines inside the get_preferred_width() and get_preferred_height(). We can then cache the computed column width and row height, cache them inside the layout and then use them when allocating the children.
2009-10-08 14:45:29 +00:00
line_count += 1;
}
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
}
layout: Report the correct size of FlowLayout FlowLayout should compute the correct height for the assigned width when in horizontal flow, and the correct width for the assigned height when in vertical flow. This means pre-computing the number of lines inside the get_preferred_width() and get_preferred_height(). We can then cache the computed column width and row height, cache them inside the layout and then use them when allocating the children.
2009-10-08 14:45:29 +00:00
priv->col_width = max_natural_width;
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
if (priv->max_col_width > 0 && priv->col_width > priv->max_col_width)
layout: Report the correct size of FlowLayout FlowLayout should compute the correct height for the assigned width when in horizontal flow, and the correct width for the assigned height when in vertical flow. This means pre-computing the number of lines inside the get_preferred_width() and get_preferred_height(). We can then cache the computed column width and row height, cache them inside the layout and then use them when allocating the children.
2009-10-08 14:45:29 +00:00
priv->col_width = MAX (priv->max_col_width, max_min_width);
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
if (priv->col_width < priv->min_col_width)
priv->col_width = priv->min_col_width;
layout: Report the correct size of FlowLayout FlowLayout should compute the correct height for the assigned width when in horizontal flow, and the correct width for the assigned height when in vertical flow. This means pre-computing the number of lines inside the get_preferred_width() and get_preferred_height(). We can then cache the computed column width and row height, cache them inside the layout and then use them when allocating the children.
2009-10-08 14:45:29 +00:00
if (priv->orientation == CLUTTER_FLOW_VERTICAL && for_height > 0)
{
/* if we have a non-full row we need to add it */
if (line_item_count > 0)
{
total_min_width += line_min_width;
total_natural_width += line_natural_width;
g_array_append_val (priv->line_min,
line_min_width);
g_array_append_val (priv->line_natural,
line_natural_width);
}
priv->line_count = line_count;
flow-layout: Provide a preferred size The FlowLayout fails to provide a preferred size in case no sizing is specified on one axis. It should, instead, have the preferred size of the sum of its children, depending on the orientation property. http://bugzilla.openedhand.com/show_bug.cgi?id=2013
2010-03-02 15:08:01 +00:00
if (priv->line_count > 0)
{
gfloat total_spacing;
total_spacing = priv->col_spacing * (priv->line_count - 1);
total_min_width += total_spacing;
total_natural_width += total_spacing;
}
}
else
{
g_array_append_val (priv->line_min, line_min_width);
g_array_append_val (priv->line_natural, line_natural_width);
priv->line_count = line_count;
layout: Report the correct size of FlowLayout FlowLayout should compute the correct height for the assigned width when in horizontal flow, and the correct width for the assigned height when in vertical flow. This means pre-computing the number of lines inside the get_preferred_width() and get_preferred_height(). We can then cache the computed column width and row height, cache them inside the layout and then use them when allocating the children.
2009-10-08 14:45:29 +00:00
if (priv->line_count > 0)
{
gfloat total_spacing;
total_spacing = priv->col_spacing * (priv->line_count - 1);
total_min_width += total_spacing;
total_natural_width += total_spacing;
}
}
flow-layout: Provide a preferred size The FlowLayout fails to provide a preferred size in case no sizing is specified on one axis. It should, instead, have the preferred size of the sum of its children, depending on the orientation property. http://bugzilla.openedhand.com/show_bug.cgi?id=2013
2010-03-02 15:08:01 +00:00
CLUTTER_NOTE (LAYOUT,
"Flow[w]: %d lines (%d per line): w [ %.2f, %.2f ] for h %.2f",
n_rows, priv->line_count,
total_min_width,
total_natural_width,
for_height);
flow-layout: Blow the cached preferred size if needed If the FlowLayout layout manager wasn't allocated the same size it requested then it should blow its caches and recompute the layout with the given allocation size.
2010-09-17 11:43:23 +00:00
priv->req_height = for_height;
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
if (min_width_p)
flow-layout: Fix minimum size request The minimum preferred size of a Flow layout manager is the size of a column or a row, as the whole point of the layout policy enforced by the Flow layout manager is to reflow when needed.
2011-12-05 10:25:42 +00:00
*min_width_p = max_min_width;
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
if (nat_width_p)
layout: Report the correct size of FlowLayout FlowLayout should compute the correct height for the assigned width when in horizontal flow, and the correct width for the assigned height when in vertical flow. This means pre-computing the number of lines inside the get_preferred_width() and get_preferred_height(). We can then cache the computed column width and row height, cache them inside the layout and then use them when allocating the children.
2009-10-08 14:45:29 +00:00
*nat_width_p = total_natural_width;
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
}
static void
clutter_flow_layout_get_preferred_height (ClutterLayoutManager *manager,
ClutterContainer *container,
gfloat for_width,
gfloat *min_height_p,
gfloat *nat_height_p)
{
ClutterFlowLayoutPrivate *priv = CLUTTER_FLOW_LAYOUT (manager)->priv;
layout: Report the correct size of FlowLayout FlowLayout should compute the correct height for the assigned width when in horizontal flow, and the correct width for the assigned height when in vertical flow. This means pre-computing the number of lines inside the get_preferred_width() and get_preferred_height(). We can then cache the computed column width and row height, cache them inside the layout and then use them when allocating the children.
2009-10-08 14:45:29 +00:00
gint n_columns, line_item_count, line_count;
gfloat total_min_height, total_natural_height;
gfloat line_min_height, line_natural_height;
gfloat max_min_height, max_natural_height;
Port remaining layout managers to the new child iteration API TableLayout and FlowLayout now use the ClutterActor API for iterating over the children of an actor.
2011-12-18 11:26:29 +00:00
ClutterActor *actor, *child;
Use ClutterActorIter inside layout managers Whenever it is possible, or convenient.
2012-01-30 10:55:30 +00:00
ClutterActorIter iter;
layout: Report the correct size of FlowLayout FlowLayout should compute the correct height for the assigned width when in horizontal flow, and the correct width for the assigned height when in vertical flow. This means pre-computing the number of lines inside the get_preferred_width() and get_preferred_height(). We can then cache the computed column width and row height, cache them inside the layout and then use them when allocating the children.
2009-10-08 14:45:29 +00:00
gfloat item_x;
n_columns = get_columns (CLUTTER_FLOW_LAYOUT (manager), for_width);
total_min_height = 0;
total_natural_height = 0;
line_min_height = 0;
line_natural_height = 0;
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
layout: Report the correct size of FlowLayout FlowLayout should compute the correct height for the assigned width when in horizontal flow, and the correct width for the assigned height when in vertical flow. This means pre-computing the number of lines inside the get_preferred_width() and get_preferred_height(). We can then cache the computed column width and row height, cache them inside the layout and then use them when allocating the children.
2009-10-08 14:45:29 +00:00
line_item_count = 0;
line_count = 0;
item_x = 0;
Port remaining layout managers to the new child iteration API TableLayout and FlowLayout now use the ClutterActor API for iterating over the children of an actor.
2011-12-18 11:26:29 +00:00
actor = CLUTTER_ACTOR (container);
layout: Report the correct size of FlowLayout FlowLayout should compute the correct height for the assigned width when in horizontal flow, and the correct width for the assigned height when in vertical flow. This means pre-computing the number of lines inside the get_preferred_width() and get_preferred_height(). We can then cache the computed column width and row height, cache them inside the layout and then use them when allocating the children.
2009-10-08 14:45:29 +00:00
/* clear the line height arrays */
flow-layout: Provide a preferred size The FlowLayout fails to provide a preferred size in case no sizing is specified on one axis. It should, instead, have the preferred size of the sum of its children, depending on the orientation property. http://bugzilla.openedhand.com/show_bug.cgi?id=2013
2010-03-02 15:08:01 +00:00
if (priv->line_min != NULL)
g_array_free (priv->line_min, TRUE);
layout: Report the correct size of FlowLayout FlowLayout should compute the correct height for the assigned width when in horizontal flow, and the correct width for the assigned height when in vertical flow. This means pre-computing the number of lines inside the get_preferred_width() and get_preferred_height(). We can then cache the computed column width and row height, cache them inside the layout and then use them when allocating the children.
2009-10-08 14:45:29 +00:00
flow-layout: Provide a preferred size The FlowLayout fails to provide a preferred size in case no sizing is specified on one axis. It should, instead, have the preferred size of the sum of its children, depending on the orientation property. http://bugzilla.openedhand.com/show_bug.cgi?id=2013
2010-03-02 15:08:01 +00:00
if (priv->line_natural != NULL)
g_array_free (priv->line_natural, TRUE);
layout: Report the correct size of FlowLayout FlowLayout should compute the correct height for the assigned width when in horizontal flow, and the correct width for the assigned height when in vertical flow. This means pre-computing the number of lines inside the get_preferred_width() and get_preferred_height(). We can then cache the computed column width and row height, cache them inside the layout and then use them when allocating the children.
2009-10-08 14:45:29 +00:00
flow-layout: Provide a preferred size The FlowLayout fails to provide a preferred size in case no sizing is specified on one axis. It should, instead, have the preferred size of the sum of its children, depending on the orientation property. http://bugzilla.openedhand.com/show_bug.cgi?id=2013
2010-03-02 15:08:01 +00:00
priv->line_min = g_array_sized_new (FALSE, FALSE,
sizeof (gfloat),
16);
priv->line_natural = g_array_sized_new (FALSE, FALSE,
layout: Report the correct size of FlowLayout FlowLayout should compute the correct height for the assigned width when in horizontal flow, and the correct width for the assigned height when in vertical flow. This means pre-computing the number of lines inside the get_preferred_width() and get_preferred_height(). We can then cache the computed column width and row height, cache them inside the layout and then use them when allocating the children.
2009-10-08 14:45:29 +00:00
sizeof (gfloat),
16);
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
Port remaining layout managers to the new child iteration API TableLayout and FlowLayout now use the ClutterActor API for iterating over the children of an actor.
2011-12-18 11:26:29 +00:00
if (clutter_actor_get_n_children (actor) != 0)
flow-layout: Include the first line when calculating number of lines This ensures that the preferred height / width height takes into consideration the correct amount of padding
2009-12-01 17:44:42 +00:00
line_count = 1;
Fix some compiler warnings GCC complains that some variable might be used uninitialized.
2010-02-09 16:57:14 +00:00
max_min_height = max_natural_height = 0;
Use ClutterActorIter inside layout managers Whenever it is possible, or convenient.
2012-01-30 10:55:30 +00:00
clutter_actor_iter_init (&iter, actor);
while (clutter_actor_iter_next (&iter, &child))
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
{
gfloat child_min, child_natural;
layout: Report the correct size of FlowLayout FlowLayout should compute the correct height for the assigned width when in horizontal flow, and the correct width for the assigned height when in vertical flow. This means pre-computing the number of lines inside the get_preferred_width() and get_preferred_height(). We can then cache the computed column width and row height, cache them inside the layout and then use them when allocating the children.
2009-10-08 14:45:29 +00:00
gfloat new_x, item_width;
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
Stop using macros for accessing actor state Use the newly added functions instead.
2015-04-23 16:39:30 +00:00
if (!clutter_actor_is_visible (child))
[layout] Skip invisible children in FlowLayout Skip hidden actors when computing the preferred size and when allocating.
2009-10-07 10:39:18 +00:00
continue;
layout: Report the correct size of FlowLayout FlowLayout should compute the correct height for the assigned width when in horizontal flow, and the correct width for the assigned height when in vertical flow. This means pre-computing the number of lines inside the get_preferred_width() and get_preferred_height(). We can then cache the computed column width and row height, cache them inside the layout and then use them when allocating the children.
2009-10-08 14:45:29 +00:00
if (priv->orientation == CLUTTER_FLOW_HORIZONTAL && for_width > 0)
{
flow-layout: Add :snap-to-grid property Add a :snap-to-grid property to FlowLayout to prevent the layout from assigning it's children a position based on the size of the largest child. https://bugzilla.gnome.org/show_bug.cgi?id=648873
2013-05-03 15:53:44 +00:00
clutter_actor_get_preferred_width (child, -1,
&child_min,
&child_natural);
if ((priv->snap_to_grid && line_item_count == n_columns) ||
(!priv->snap_to_grid && item_x + child_natural > for_width))
layout: Report the correct size of FlowLayout FlowLayout should compute the correct height for the assigned width when in horizontal flow, and the correct width for the assigned height when in vertical flow. This means pre-computing the number of lines inside the get_preferred_width() and get_preferred_height(). We can then cache the computed column width and row height, cache them inside the layout and then use them when allocating the children.
2009-10-08 14:45:29 +00:00
{
total_min_height += line_min_height;
total_natural_height += line_natural_height;
g_array_append_val (priv->line_min,
line_min_height);
g_array_append_val (priv->line_natural,
line_natural_height);
line_min_height = line_natural_height = 0;
line_item_count = 0;
line_count += 1;
item_x = 0;
}
flow-layout: Add :snap-to-grid property Add a :snap-to-grid property to FlowLayout to prevent the layout from assigning it's children a position based on the size of the largest child. https://bugzilla.gnome.org/show_bug.cgi?id=648873
2013-05-03 15:53:44 +00:00
if (priv->snap_to_grid)
{
new_x = ((line_item_count + 1) * (for_width + priv->col_spacing))
/ n_columns;
item_width = new_x - item_x - priv->col_spacing;
}
else
{
new_x = item_x + child_natural + priv->col_spacing;
item_width = child_natural;
}
layout: Report the correct size of FlowLayout FlowLayout should compute the correct height for the assigned width when in horizontal flow, and the correct width for the assigned height when in vertical flow. This means pre-computing the number of lines inside the get_preferred_width() and get_preferred_height(). We can then cache the computed column width and row height, cache them inside the layout and then use them when allocating the children.
2009-10-08 14:45:29 +00:00
clutter_actor_get_preferred_height (child, item_width,
&child_min,
&child_natural);
line_min_height = MAX (line_min_height, child_min);
line_natural_height = MAX (line_natural_height, child_natural);
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
layout: Report the correct size of FlowLayout FlowLayout should compute the correct height for the assigned width when in horizontal flow, and the correct width for the assigned height when in vertical flow. This means pre-computing the number of lines inside the get_preferred_width() and get_preferred_height(). We can then cache the computed column width and row height, cache them inside the layout and then use them when allocating the children.
2009-10-08 14:45:29 +00:00
item_x = new_x;
line_item_count += 1;
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
layout: Report the correct size of FlowLayout FlowLayout should compute the correct height for the assigned width when in horizontal flow, and the correct width for the assigned height when in vertical flow. This means pre-computing the number of lines inside the get_preferred_width() and get_preferred_height(). We can then cache the computed column width and row height, cache them inside the layout and then use them when allocating the children.
2009-10-08 14:45:29 +00:00
max_min_height = MAX (max_min_height, line_min_height);
max_natural_height = MAX (max_natural_height, line_natural_height);
}
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
else
layout: Report the correct size of FlowLayout FlowLayout should compute the correct height for the assigned width when in horizontal flow, and the correct width for the assigned height when in vertical flow. This means pre-computing the number of lines inside the get_preferred_width() and get_preferred_height(). We can then cache the computed column width and row height, cache them inside the layout and then use them when allocating the children.
2009-10-08 14:45:29 +00:00
{
clutter_actor_get_preferred_height (child, for_width,
&child_min,
&child_natural);
max_min_height = MAX (max_min_height, child_min);
max_natural_height = MAX (max_natural_height, child_natural);
flow-layout: Provide a preferred size The FlowLayout fails to provide a preferred size in case no sizing is specified on one axis. It should, instead, have the preferred size of the sum of its children, depending on the orientation property. http://bugzilla.openedhand.com/show_bug.cgi?id=2013
2010-03-02 15:08:01 +00:00
total_min_height += max_min_height;
total_natural_height += max_natural_height;
layout: Report the correct size of FlowLayout FlowLayout should compute the correct height for the assigned width when in horizontal flow, and the correct width for the assigned height when in vertical flow. This means pre-computing the number of lines inside the get_preferred_width() and get_preferred_height(). We can then cache the computed column width and row height, cache them inside the layout and then use them when allocating the children.
2009-10-08 14:45:29 +00:00
line_count += 1;
}
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
}
layout: Report the correct size of FlowLayout FlowLayout should compute the correct height for the assigned width when in horizontal flow, and the correct width for the assigned height when in vertical flow. This means pre-computing the number of lines inside the get_preferred_width() and get_preferred_height(). We can then cache the computed column width and row height, cache them inside the layout and then use them when allocating the children.
2009-10-08 14:45:29 +00:00
priv->row_height = max_natural_height;
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
if (priv->max_row_height > 0 && priv->row_height > priv->max_row_height)
layout: Report the correct size of FlowLayout FlowLayout should compute the correct height for the assigned width when in horizontal flow, and the correct width for the assigned height when in vertical flow. This means pre-computing the number of lines inside the get_preferred_width() and get_preferred_height(). We can then cache the computed column width and row height, cache them inside the layout and then use them when allocating the children.
2009-10-08 14:45:29 +00:00
priv->row_height = MAX (priv->max_row_height, max_min_height);
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
if (priv->row_height < priv->min_row_height)
priv->row_height = priv->min_row_height;
layout: Report the correct size of FlowLayout FlowLayout should compute the correct height for the assigned width when in horizontal flow, and the correct width for the assigned height when in vertical flow. This means pre-computing the number of lines inside the get_preferred_width() and get_preferred_height(). We can then cache the computed column width and row height, cache them inside the layout and then use them when allocating the children.
2009-10-08 14:45:29 +00:00
if (priv->orientation == CLUTTER_FLOW_HORIZONTAL && for_width > 0)
{
/* if we have a non-full row we need to add it */
if (line_item_count > 0)
{
total_min_height += line_min_height;
total_natural_height += line_natural_height;
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
layout: Report the correct size of FlowLayout FlowLayout should compute the correct height for the assigned width when in horizontal flow, and the correct width for the assigned height when in vertical flow. This means pre-computing the number of lines inside the get_preferred_width() and get_preferred_height(). We can then cache the computed column width and row height, cache them inside the layout and then use them when allocating the children.
2009-10-08 14:45:29 +00:00
g_array_append_val (priv->line_min,
line_min_height);
g_array_append_val (priv->line_natural,
line_natural_height);
}
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
layout: Report the correct size of FlowLayout FlowLayout should compute the correct height for the assigned width when in horizontal flow, and the correct width for the assigned height when in vertical flow. This means pre-computing the number of lines inside the get_preferred_width() and get_preferred_height(). We can then cache the computed column width and row height, cache them inside the layout and then use them when allocating the children.
2009-10-08 14:45:29 +00:00
priv->line_count = line_count;
if (priv->line_count > 0)
{
gfloat total_spacing;
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
layout: Report the correct size of FlowLayout FlowLayout should compute the correct height for the assigned width when in horizontal flow, and the correct width for the assigned height when in vertical flow. This means pre-computing the number of lines inside the get_preferred_width() and get_preferred_height(). We can then cache the computed column width and row height, cache them inside the layout and then use them when allocating the children.
2009-10-08 14:45:29 +00:00
total_spacing = priv->row_spacing * (priv->line_count - 1);
total_min_height += total_spacing;
total_natural_height += total_spacing;
}
[layout] Snap children of FlowLayout to column/row Use the column and row size to align each child; with :homogeneous set to TRUE, or with children with the same size, the FlowLayout will behave like a reflowing grid.
2009-10-06 16:30:49 +00:00
}
flow-layout: Provide a preferred size The FlowLayout fails to provide a preferred size in case no sizing is specified on one axis. It should, instead, have the preferred size of the sum of its children, depending on the orientation property. http://bugzilla.openedhand.com/show_bug.cgi?id=2013
2010-03-02 15:08:01 +00:00
else
{
g_array_append_val (priv->line_min, line_min_height);
g_array_append_val (priv->line_natural, line_natural_height);
priv->line_count = line_count;
if (priv->line_count > 0)
{
gfloat total_spacing;
total_spacing = priv->col_spacing * priv->line_count;
total_min_height += total_spacing;
total_natural_height += total_spacing;
}
}
CLUTTER_NOTE (LAYOUT,
"Flow[h]: %d lines (%d per line): w [ %.2f, %.2f ] for h %.2f",
n_columns, priv->line_count,
total_min_height,
total_natural_height,
for_width);
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
flow-layout: Blow the cached preferred size if needed If the FlowLayout layout manager wasn't allocated the same size it requested then it should blow its caches and recompute the layout with the given allocation size.
2010-09-17 11:43:23 +00:00
priv->req_width = for_width;
layout: Report the correct size of FlowLayout FlowLayout should compute the correct height for the assigned width when in horizontal flow, and the correct width for the assigned height when in vertical flow. This means pre-computing the number of lines inside the get_preferred_width() and get_preferred_height(). We can then cache the computed column width and row height, cache them inside the layout and then use them when allocating the children.
2009-10-08 14:45:29 +00:00
if (min_height_p)
flow-layout: Fix minimum size request The minimum preferred size of a Flow layout manager is the size of a column or a row, as the whole point of the layout policy enforced by the Flow layout manager is to reflow when needed.
2011-12-05 10:25:42 +00:00
*min_height_p = max_min_height;
layout: Report the correct size of FlowLayout FlowLayout should compute the correct height for the assigned width when in horizontal flow, and the correct width for the assigned height when in vertical flow. This means pre-computing the number of lines inside the get_preferred_width() and get_preferred_height(). We can then cache the computed column width and row height, cache them inside the layout and then use them when allocating the children.
2009-10-08 14:45:29 +00:00
if (nat_height_p)
*nat_height_p = total_natural_height;
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
}
static void
clutter_flow_layout_allocate (ClutterLayoutManager *manager,
ClutterContainer *container,
const ClutterActorBox *allocation,
ClutterAllocationFlags flags)
{
ClutterFlowLayoutPrivate *priv = CLUTTER_FLOW_LAYOUT (manager)->priv;
Port remaining layout managers to the new child iteration API TableLayout and FlowLayout now use the ClutterActor API for iterating over the children of an actor.
2011-12-18 11:26:29 +00:00
ClutterActor *actor, *child;
Use ClutterActorIter inside layout managers Whenever it is possible, or convenient.
2012-01-30 10:55:30 +00:00
ClutterActorIter iter;
layout-managers: Take into account the allocations's origin If an actor using a LayoutManager has attributes like margin or padding then it'll have to shave them from the available allocation before passing it to the LayoutManager::allocate() implementation. Layout managers should, thus, not assume that the origin of the allocation is in (0, 0), but take into account that the passed ActorBox might have a different origin. https://bugzilla.gnome.org/show_bug.cgi?id=649631
2011-08-24 17:38:17 +00:00
gfloat x_off, y_off;
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
gfloat avail_width, avail_height;
gfloat item_x, item_y;
layout: Report the correct size of FlowLayout FlowLayout should compute the correct height for the assigned width when in horizontal flow, and the correct width for the assigned height when in vertical flow. This means pre-computing the number of lines inside the get_preferred_width() and get_preferred_height(). We can then cache the computed column width and row height, cache them inside the layout and then use them when allocating the children.
2009-10-08 14:45:29 +00:00
gint line_item_count;
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
gint items_per_line;
gint line_index;
Port remaining layout managers to the new child iteration API TableLayout and FlowLayout now use the ClutterActor API for iterating over the children of an actor.
2011-12-18 11:26:29 +00:00
actor = CLUTTER_ACTOR (container);
if (clutter_actor_get_n_children (actor) == 0)
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
return;
layout-managers: Take into account the allocations's origin If an actor using a LayoutManager has attributes like margin or padding then it'll have to shave them from the available allocation before passing it to the LayoutManager::allocate() implementation. Layout managers should, thus, not assume that the origin of the allocation is in (0, 0), but take into account that the passed ActorBox might have a different origin. https://bugzilla.gnome.org/show_bug.cgi?id=649631
2011-08-24 17:38:17 +00:00
clutter_actor_box_get_origin (allocation, &x_off, &y_off);
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
clutter_actor_box_get_size (allocation, &avail_width, &avail_height);
flow-layout: Blow the cached preferred size if needed If the FlowLayout layout manager wasn't allocated the same size it requested then it should blow its caches and recompute the layout with the given allocation size.
2010-09-17 11:43:23 +00:00
/* blow the cached preferred size and re-compute with the given
* available size in case the FlowLayout wasn't given the exact
* size it requested
*/
flow-layout: Check for all positive values When creating a FlowLayout container, setting a specific size on it, and adding a child to it, as per the attached testcase, it crashes. The line on the backtrace doesn't really make sense, but from looking over it, it appears that it's probably because priv->line_natural is NULL. The attached patch makes it so in this case, priv->line_natural is allocated. https://bugzilla.gnome.org/show_bug.cgi?id=676068 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2012-05-22 13:25:19 +00:00
if ((priv->req_width >= 0 && avail_width != priv->req_width) ||
(priv->req_height >= 0 && avail_height != priv->req_height))
flow-layout: Blow the cached preferred size if needed If the FlowLayout layout manager wasn't allocated the same size it requested then it should blow its caches and recompute the layout with the given allocation size.
2010-09-17 11:43:23 +00:00
{
clutter_flow_layout_get_preferred_width (manager, container,
avail_height,
NULL, NULL);
clutter_flow_layout_get_preferred_height (manager, container,
avail_width,
NULL, NULL);
}
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
items_per_line = compute_lines (CLUTTER_FLOW_LAYOUT (manager),
avail_width, avail_height);
layout-managers: Take into account the allocations's origin If an actor using a LayoutManager has attributes like margin or padding then it'll have to shave them from the available allocation before passing it to the LayoutManager::allocate() implementation. Layout managers should, thus, not assume that the origin of the allocation is in (0, 0), but take into account that the passed ActorBox might have a different origin. https://bugzilla.gnome.org/show_bug.cgi?id=649631
2011-08-24 17:38:17 +00:00
item_x = x_off;
item_y = y_off;
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
layout: Report the correct size of FlowLayout FlowLayout should compute the correct height for the assigned width when in horizontal flow, and the correct width for the assigned height when in vertical flow. This means pre-computing the number of lines inside the get_preferred_width() and get_preferred_height(). We can then cache the computed column width and row height, cache them inside the layout and then use them when allocating the children.
2009-10-08 14:45:29 +00:00
line_item_count = 0;
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
line_index = 0;
Use ClutterActorIter inside layout managers Whenever it is possible, or convenient.
2012-01-30 10:55:30 +00:00
clutter_actor_iter_init (&iter, actor);
while (clutter_actor_iter_next (&iter, &child))
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
{
ClutterActorBox child_alloc;
gfloat item_width, item_height;
layout: Report the correct size of FlowLayout FlowLayout should compute the correct height for the assigned width when in horizontal flow, and the correct width for the assigned height when in vertical flow. This means pre-computing the number of lines inside the get_preferred_width() and get_preferred_height(). We can then cache the computed column width and row height, cache them inside the layout and then use them when allocating the children.
2009-10-08 14:45:29 +00:00
gfloat new_x, new_y;
flow-layout: Add :snap-to-grid property Add a :snap-to-grid property to FlowLayout to prevent the layout from assigning it's children a position based on the size of the largest child. https://bugzilla.gnome.org/show_bug.cgi?id=648873
2013-05-03 15:53:44 +00:00
gfloat child_min, child_natural;
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
Stop using macros for accessing actor state Use the newly added functions instead.
2015-04-23 16:39:30 +00:00
if (!clutter_actor_is_visible (child))
[layout] Skip invisible children in FlowLayout Skip hidden actors when computing the preferred size and when allocating.
2009-10-07 10:39:18 +00:00
continue;
Fix some compiler warnings GCC complains that some variable might be used uninitialized.
2010-02-09 16:57:14 +00:00
new_x = new_y = 0;
flow-layout: Add :snap-to-grid property Add a :snap-to-grid property to FlowLayout to prevent the layout from assigning it's children a position based on the size of the largest child. https://bugzilla.gnome.org/show_bug.cgi?id=648873
2013-05-03 15:53:44 +00:00
if (!priv->snap_to_grid)
clutter_actor_get_preferred_size (child,
NULL, NULL,
&item_width,
&item_height);
layout: Report the correct size of FlowLayout FlowLayout should compute the correct height for the assigned width when in horizontal flow, and the correct width for the assigned height when in vertical flow. This means pre-computing the number of lines inside the get_preferred_width() and get_preferred_height(). We can then cache the computed column width and row height, cache them inside the layout and then use them when allocating the children.
2009-10-08 14:45:29 +00:00
if (priv->orientation == CLUTTER_FLOW_HORIZONTAL)
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
{
flow-layout: Add :snap-to-grid property Add a :snap-to-grid property to FlowLayout to prevent the layout from assigning it's children a position based on the size of the largest child. https://bugzilla.gnome.org/show_bug.cgi?id=648873
2013-05-03 15:53:44 +00:00
if ((priv->snap_to_grid &&
line_item_count == items_per_line && line_item_count > 0) ||
(!priv->snap_to_grid && item_x + item_width > avail_width))
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
{
layout: Report the correct size of FlowLayout FlowLayout should compute the correct height for the assigned width when in horizontal flow, and the correct width for the assigned height when in vertical flow. This means pre-computing the number of lines inside the get_preferred_width() and get_preferred_height(). We can then cache the computed column width and row height, cache them inside the layout and then use them when allocating the children.
2009-10-08 14:45:29 +00:00
item_y += g_array_index (priv->line_natural,
gfloat,
line_index);
flow-layout: Respect row-spacing/col-spacine in horizontal/vertical flows We need to add the row-spacing value when calculating the y position for lines of actors in horizontal flowing layouts. Similarly we need to add the col-spacing value when calculating the x posution for actors in vertical flowing layouts.
2009-12-01 17:11:08 +00:00
if (line_index >= 0)
item_y += priv->row_spacing;
layout: Report the correct size of FlowLayout FlowLayout should compute the correct height for the assigned width when in horizontal flow, and the correct width for the assigned height when in vertical flow. This means pre-computing the number of lines inside the get_preferred_width() and get_preferred_height(). We can then cache the computed column width and row height, cache them inside the layout and then use them when allocating the children.
2009-10-08 14:45:29 +00:00
line_item_count = 0;
line_index += 1;
layout-managers: Take into account the allocations's origin If an actor using a LayoutManager has attributes like margin or padding then it'll have to shave them from the available allocation before passing it to the LayoutManager::allocate() implementation. Layout managers should, thus, not assume that the origin of the allocation is in (0, 0), but take into account that the passed ActorBox might have a different origin. https://bugzilla.gnome.org/show_bug.cgi?id=649631
2011-08-24 17:38:17 +00:00
item_x = x_off;
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
}
layout: Report the correct size of FlowLayout FlowLayout should compute the correct height for the assigned width when in horizontal flow, and the correct width for the assigned height when in vertical flow. This means pre-computing the number of lines inside the get_preferred_width() and get_preferred_height(). We can then cache the computed column width and row height, cache them inside the layout and then use them when allocating the children.
2009-10-08 14:45:29 +00:00
flow-layout: Add :snap-to-grid property Add a :snap-to-grid property to FlowLayout to prevent the layout from assigning it's children a position based on the size of the largest child. https://bugzilla.gnome.org/show_bug.cgi?id=648873
2013-05-03 15:53:44 +00:00
if (priv->snap_to_grid)
{
new_x = x_off + ((line_item_count + 1) * (avail_width + priv->col_spacing))
/ items_per_line;
item_width = new_x - item_x - priv->col_spacing;
}
else
{
new_x = item_x + item_width + priv->col_spacing;
}
layout: Report the correct size of FlowLayout FlowLayout should compute the correct height for the assigned width when in horizontal flow, and the correct width for the assigned height when in vertical flow. This means pre-computing the number of lines inside the get_preferred_width() and get_preferred_height(). We can then cache the computed column width and row height, cache them inside the layout and then use them when allocating the children.
2009-10-08 14:45:29 +00:00
item_height = g_array_index (priv->line_natural,
gfloat,
line_index);
[layout] Add :homogeneous to FlowLayout
2009-10-06 15:17:16 +00:00
}
else
{
flow-layout: Add :snap-to-grid property Add a :snap-to-grid property to FlowLayout to prevent the layout from assigning it's children a position based on the size of the largest child. https://bugzilla.gnome.org/show_bug.cgi?id=648873
2013-05-03 15:53:44 +00:00
if ((priv->snap_to_grid &&
line_item_count == items_per_line && line_item_count > 0) ||
(!priv->snap_to_grid && item_y + item_height > avail_height))
layout: Report the correct size of FlowLayout FlowLayout should compute the correct height for the assigned width when in horizontal flow, and the correct width for the assigned height when in vertical flow. This means pre-computing the number of lines inside the get_preferred_width() and get_preferred_height(). We can then cache the computed column width and row height, cache them inside the layout and then use them when allocating the children.
2009-10-08 14:45:29 +00:00
{
item_x += g_array_index (priv->line_natural,
gfloat,
line_index);
[layout] Add :homogeneous to FlowLayout
2009-10-06 15:17:16 +00:00
flow-layout: Respect row-spacing/col-spacine in horizontal/vertical flows We need to add the row-spacing value when calculating the y position for lines of actors in horizontal flowing layouts. Similarly we need to add the col-spacing value when calculating the x posution for actors in vertical flowing layouts.
2009-12-01 17:11:08 +00:00
if (line_index >= 0)
item_x += priv->col_spacing;
layout: Report the correct size of FlowLayout FlowLayout should compute the correct height for the assigned width when in horizontal flow, and the correct width for the assigned height when in vertical flow. This means pre-computing the number of lines inside the get_preferred_width() and get_preferred_height(). We can then cache the computed column width and row height, cache them inside the layout and then use them when allocating the children.
2009-10-08 14:45:29 +00:00
line_item_count = 0;
line_index += 1;
layout-managers: Take into account the allocations's origin If an actor using a LayoutManager has attributes like margin or padding then it'll have to shave them from the available allocation before passing it to the LayoutManager::allocate() implementation. Layout managers should, thus, not assume that the origin of the allocation is in (0, 0), but take into account that the passed ActorBox might have a different origin. https://bugzilla.gnome.org/show_bug.cgi?id=649631
2011-08-24 17:38:17 +00:00
item_y = y_off;
layout: Report the correct size of FlowLayout FlowLayout should compute the correct height for the assigned width when in horizontal flow, and the correct width for the assigned height when in vertical flow. This means pre-computing the number of lines inside the get_preferred_width() and get_preferred_height(). We can then cache the computed column width and row height, cache them inside the layout and then use them when allocating the children.
2009-10-08 14:45:29 +00:00
}
flow-layout: Add :snap-to-grid property Add a :snap-to-grid property to FlowLayout to prevent the layout from assigning it's children a position based on the size of the largest child. https://bugzilla.gnome.org/show_bug.cgi?id=648873
2013-05-03 15:53:44 +00:00
if (priv->snap_to_grid)
{
new_y = y_off + ((line_item_count + 1) * (avail_height + priv->row_spacing))
/ items_per_line;
item_height = new_y - item_y - priv->row_spacing;
}
else
{
new_y = item_y + item_height + priv->row_spacing;
}
layout: Report the correct size of FlowLayout FlowLayout should compute the correct height for the assigned width when in horizontal flow, and the correct width for the assigned height when in vertical flow. This means pre-computing the number of lines inside the get_preferred_width() and get_preferred_height(). We can then cache the computed column width and row height, cache them inside the layout and then use them when allocating the children.
2009-10-08 14:45:29 +00:00
item_width = g_array_index (priv->line_natural,
gfloat,
line_index);
flow-layout: Add :snap-to-grid property Add a :snap-to-grid property to FlowLayout to prevent the layout from assigning it's children a position based on the size of the largest child. https://bugzilla.gnome.org/show_bug.cgi?id=648873
2013-05-03 15:53:44 +00:00
}
layout: Report the correct size of FlowLayout FlowLayout should compute the correct height for the assigned width when in horizontal flow, and the correct width for the assigned height when in vertical flow. This means pre-computing the number of lines inside the get_preferred_width() and get_preferred_height(). We can then cache the computed column width and row height, cache them inside the layout and then use them when allocating the children.
2009-10-08 14:45:29 +00:00
flow-layout: Add :snap-to-grid property Add a :snap-to-grid property to FlowLayout to prevent the layout from assigning it's children a position based on the size of the largest child. https://bugzilla.gnome.org/show_bug.cgi?id=648873
2013-05-03 15:53:44 +00:00
if (!priv->is_homogeneous &&
!clutter_actor_needs_expand (child,
CLUTTER_ORIENTATION_HORIZONTAL))
{
clutter_actor_get_preferred_width (child, item_height,
&child_min,
&child_natural);
item_width = MIN (item_width, child_natural);
}
layout: Report the correct size of FlowLayout FlowLayout should compute the correct height for the assigned width when in horizontal flow, and the correct width for the assigned height when in vertical flow. This means pre-computing the number of lines inside the get_preferred_width() and get_preferred_height(). We can then cache the computed column width and row height, cache them inside the layout and then use them when allocating the children.
2009-10-08 14:45:29 +00:00
flow-layout: Add :snap-to-grid property Add a :snap-to-grid property to FlowLayout to prevent the layout from assigning it's children a position based on the size of the largest child. https://bugzilla.gnome.org/show_bug.cgi?id=648873
2013-05-03 15:53:44 +00:00
if (!priv->is_homogeneous &&
!clutter_actor_needs_expand (child,
CLUTTER_ORIENTATION_VERTICAL))
{
clutter_actor_get_preferred_height (child, item_width,
&child_min,
&child_natural);
item_height = MIN (item_height, child_natural);
[layout] Add :homogeneous to FlowLayout
2009-10-06 15:17:16 +00:00
}
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
CLUTTER_NOTE (LAYOUT,
layout: Report the correct size of FlowLayout FlowLayout should compute the correct height for the assigned width when in horizontal flow, and the correct width for the assigned height when in vertical flow. This means pre-computing the number of lines inside the get_preferred_width() and get_preferred_height(). We can then cache the computed column width and row height, cache them inside the layout and then use them when allocating the children.
2009-10-08 14:45:29 +00:00
"flow[line:%d, item:%d/%d] ="
"{ %.2f, %.2f, %.2f, %.2f }",
line_index, line_item_count + 1, items_per_line,
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
item_x, item_y, item_width, item_height);
child_alloc.x1 = ceil (item_x);
child_alloc.y1 = ceil (item_y);
child_alloc.x2 = ceil (child_alloc.x1 + item_width);
child_alloc.y2 = ceil (child_alloc.y1 + item_height);
clutter_actor_allocate (child, &child_alloc, flags);
if (priv->orientation == CLUTTER_FLOW_HORIZONTAL)
layout: Report the correct size of FlowLayout FlowLayout should compute the correct height for the assigned width when in horizontal flow, and the correct width for the assigned height when in vertical flow. This means pre-computing the number of lines inside the get_preferred_width() and get_preferred_height(). We can then cache the computed column width and row height, cache them inside the layout and then use them when allocating the children.
2009-10-08 14:45:29 +00:00
item_x = new_x;
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
else
layout: Report the correct size of FlowLayout FlowLayout should compute the correct height for the assigned width when in horizontal flow, and the correct width for the assigned height when in vertical flow. This means pre-computing the number of lines inside the get_preferred_width() and get_preferred_height(). We can then cache the computed column width and row height, cache them inside the layout and then use them when allocating the children.
2009-10-08 14:45:29 +00:00
item_y = new_y;
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
layout: Report the correct size of FlowLayout FlowLayout should compute the correct height for the assigned width when in horizontal flow, and the correct width for the assigned height when in vertical flow. This means pre-computing the number of lines inside the get_preferred_width() and get_preferred_height(). We can then cache the computed column width and row height, cache them inside the layout and then use them when allocating the children.
2009-10-08 14:45:29 +00:00
line_item_count += 1;
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
}
}
static void
clutter_flow_layout_set_container (ClutterLayoutManager *manager,
ClutterContainer *container)
{
ClutterFlowLayoutPrivate *priv = CLUTTER_FLOW_LAYOUT (manager)->priv;
layout-manager: Implement set_container() Store a back pointer of the layout manager inside the container using the GObject instance data. This introduces a change in the implementation of ClutterLayoutManager, though it's still binary compatible.
2010-06-07 20:34:36 +00:00
ClutterLayoutManagerClass *parent_class;
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
priv->container = container;
layout: Change the request-mode along with the orientation When changing the orientation of a FlowLayout, the associated container should also change its request mode. A horizontally flowing layout has a height depending on the width, since it will reflow vertically; similarly, a vertically reflowing layout will have a width depending on the height.
2009-10-07 14:28:01 +00:00
if (priv->container != NULL)
{
ClutterRequestMode request_mode;
/* we need to change the :request-mode of the container
* to match the orientation
*/
request_mode = (priv->orientation == CLUTTER_FLOW_HORIZONTAL)
? CLUTTER_REQUEST_HEIGHT_FOR_WIDTH
: CLUTTER_REQUEST_WIDTH_FOR_HEIGHT;
clutter_actor_set_request_mode (CLUTTER_ACTOR (priv->container),
request_mode);
}
layout-manager: Implement set_container() Store a back pointer of the layout manager inside the container using the GObject instance data. This introduces a change in the implementation of ClutterLayoutManager, though it's still binary compatible.
2010-06-07 20:34:36 +00:00
parent_class = CLUTTER_LAYOUT_MANAGER_CLASS (clutter_flow_layout_parent_class);
parent_class->set_container (manager, container);
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
}
static void
clutter_flow_layout_set_property (GObject *gobject,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
ClutterFlowLayout *self = CLUTTER_FLOW_LAYOUT (gobject);
switch (prop_id)
{
case PROP_ORIENTATION:
clutter_flow_layout_set_orientation (self, g_value_get_enum (value));
break;
[layout] Add :homogeneous to FlowLayout
2009-10-06 15:17:16 +00:00
case PROP_HOMOGENEOUS:
clutter_flow_layout_set_homogeneous (self, g_value_get_boolean (value));
break;
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
case PROP_COLUMN_SPACING:
clutter_flow_layout_set_column_spacing (self, g_value_get_float (value));
break;
case PROP_ROW_SPACING:
clutter_flow_layout_set_row_spacing (self, g_value_get_float (value));
break;
case PROP_MIN_COLUMN_WIDTH:
clutter_flow_layout_set_column_width (self,
g_value_get_float (value),
self->priv->max_col_width);
break;
case PROP_MAX_COLUMN_WIDTH:
clutter_flow_layout_set_column_width (self,
self->priv->min_col_width,
g_value_get_float (value));
break;
case PROP_MIN_ROW_HEGHT:
clutter_flow_layout_set_row_height (self,
g_value_get_float (value),
self->priv->max_row_height);
break;
case PROP_MAX_ROW_HEIGHT:
clutter_flow_layout_set_row_height (self,
self->priv->min_row_height,
g_value_get_float (value));
break;
flow-layout: Add :snap-to-grid property Add a :snap-to-grid property to FlowLayout to prevent the layout from assigning it's children a position based on the size of the largest child. https://bugzilla.gnome.org/show_bug.cgi?id=648873
2013-05-03 15:53:44 +00:00
case PROP_SNAP_TO_GRID:
clutter_flow_layout_set_snap_to_grid (self,
g_value_get_boolean (value));
break;
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
break;
}
}
static void
clutter_flow_layout_get_property (GObject *gobject,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
ClutterFlowLayoutPrivate *priv = CLUTTER_FLOW_LAYOUT (gobject)->priv;
switch (prop_id)
{
case PROP_ORIENTATION:
g_value_set_enum (value, priv->orientation);
break;
[layout] Add :homogeneous to FlowLayout
2009-10-06 15:17:16 +00:00
case PROP_HOMOGENEOUS:
g_value_set_boolean (value, priv->is_homogeneous);
break;
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
case PROP_COLUMN_SPACING:
g_value_set_float (value, priv->col_spacing);
break;
case PROP_ROW_SPACING:
g_value_set_float (value, priv->row_spacing);
break;
case PROP_MIN_COLUMN_WIDTH:
g_value_set_float (value, priv->min_col_width);
break;
case PROP_MAX_COLUMN_WIDTH:
g_value_set_float (value, priv->max_col_width);
break;
case PROP_MIN_ROW_HEGHT:
g_value_set_float (value, priv->min_row_height);
break;
case PROP_MAX_ROW_HEIGHT:
g_value_set_float (value, priv->max_row_height);
break;
flow-layout: Add :snap-to-grid property Add a :snap-to-grid property to FlowLayout to prevent the layout from assigning it's children a position based on the size of the largest child. https://bugzilla.gnome.org/show_bug.cgi?id=648873
2013-05-03 15:53:44 +00:00
case PROP_SNAP_TO_GRID:
g_value_set_boolean (value, priv->snap_to_grid);
break;
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
break;
}
}
layout: Report the correct size of FlowLayout FlowLayout should compute the correct height for the assigned width when in horizontal flow, and the correct width for the assigned height when in vertical flow. This means pre-computing the number of lines inside the get_preferred_width() and get_preferred_height(). We can then cache the computed column width and row height, cache them inside the layout and then use them when allocating the children.
2009-10-08 14:45:29 +00:00
static void
clutter_flow_layout_finalize (GObject *gobject)
{
ClutterFlowLayoutPrivate *priv = CLUTTER_FLOW_LAYOUT (gobject)->priv;
if (priv->line_min != NULL)
g_array_free (priv->line_min, TRUE);
if (priv->line_natural != NULL)
g_array_free (priv->line_natural, TRUE);
G_OBJECT_CLASS (clutter_flow_layout_parent_class)->finalize (gobject);
}
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
static void
clutter_flow_layout_class_init (ClutterFlowLayoutClass *klass)
{
GObjectClass *gobject_class;
ClutterLayoutManagerClass *layout_class;
gobject_class = G_OBJECT_CLASS (klass);
layout_class = CLUTTER_LAYOUT_MANAGER_CLASS (klass);
layout_class->get_preferred_width =
clutter_flow_layout_get_preferred_width;
layout_class->get_preferred_height =
clutter_flow_layout_get_preferred_height;
layout_class->allocate = clutter_flow_layout_allocate;
layout_class->set_container = clutter_flow_layout_set_container;
/**
* ClutterFlowLayout:orientation:
*
* The orientation of the #ClutterFlowLayout. The children
* of the layout will be layed out following the orientation.
[layout] Remove FlowLayout:wrap The :wrap property is not implemented, and mostly useless: the FlowLayout is a reflowing grid. This means that if it receives less than the preferred width or height in the flow direction then it should always reflow.
2009-10-07 11:35:39 +00:00
*
* This property also controls the overflowing directions
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
*
* Since: 1.2
*/
Move more classes to install_properties()
2010-10-15 14:24:27 +00:00
flow_properties[PROP_ORIENTATION] =
g_param_spec_enum ("orientation",
P_("Orientation"),
P_("The orientation of the layout"),
CLUTTER_TYPE_FLOW_ORIENTATION,
CLUTTER_FLOW_HORIZONTAL,
CLUTTER_PARAM_READWRITE | G_PARAM_CONSTRUCT);
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
[layout] Add :homogeneous to FlowLayout
2009-10-06 15:17:16 +00:00
/**
* ClutterFlowLayout:homogeneous:
*
* Whether each child inside the #ClutterFlowLayout should receive
* the same allocation
*
* Since: 1.2
*/
Move more classes to install_properties()
2010-10-15 14:24:27 +00:00
flow_properties[PROP_HOMOGENEOUS] =
g_param_spec_boolean ("homogeneous",
P_("Homogeneous"),
P_("Whether each item should receive the same allocation"),
FALSE,
CLUTTER_PARAM_READWRITE);
[layout] Add :homogeneous to FlowLayout
2009-10-06 15:17:16 +00:00
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
/**
* ClutterFlowLayout:column-spacing:
*
* The spacing between columns, in pixels; the value of this
[layout] Remove FlowLayout:wrap The :wrap property is not implemented, and mostly useless: the FlowLayout is a reflowing grid. This means that if it receives less than the preferred width or height in the flow direction then it should always reflow.
2009-10-07 11:35:39 +00:00
* property is honoured by horizontal non-overflowing layouts
* and by vertical overflowing layouts
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
*
* Since: 1.2
*/
Move more classes to install_properties()
2010-10-15 14:24:27 +00:00
flow_properties[PROP_COLUMN_SPACING] =
g_param_spec_float ("column-spacing",
P_("Column Spacing"),
P_("The spacing between columns"),
0.0, G_MAXFLOAT,
0.0,
CLUTTER_PARAM_READWRITE);
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
/**
* ClutterFlowLayout:row-spacing:
*
* The spacing between rows, in pixels; the value of this
[layout] Remove FlowLayout:wrap The :wrap property is not implemented, and mostly useless: the FlowLayout is a reflowing grid. This means that if it receives less than the preferred width or height in the flow direction then it should always reflow.
2009-10-07 11:35:39 +00:00
* property is honoured by vertical non-overflowing layouts and
* by horizontal overflowing layouts
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
*
* Since: 1.2
*/
Move more classes to install_properties()
2010-10-15 14:24:27 +00:00
flow_properties[PROP_ROW_SPACING] =
g_param_spec_float ("row-spacing",
P_("Row Spacing"),
P_("The spacing between rows"),
0.0, G_MAXFLOAT,
0.0,
CLUTTER_PARAM_READWRITE);
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
/**
* ClutterFlowLayout:min-column-width:
*
* Minimum width for each column in the layout, in pixels
*
* Since: 1.2
*/
Move more classes to install_properties()
2010-10-15 14:24:27 +00:00
flow_properties[PROP_MIN_COLUMN_WIDTH] =
g_param_spec_float ("min-column-width",
P_("Minimum Column Width"),
P_("Minimum width for each column"),
0.0, G_MAXFLOAT,
0.0,
CLUTTER_PARAM_READWRITE);
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
/**
* ClutterFlowLayout:max-column-width:
*
* Maximum width for each column in the layout, in pixels. If
* set to -1 the width will be the maximum child width
*
* Since: 1.2
*/
Move more classes to install_properties()
2010-10-15 14:24:27 +00:00
flow_properties[PROP_MAX_COLUMN_WIDTH] =
g_param_spec_float ("max-column-width",
P_("Maximum Column Width"),
P_("Maximum width for each column"),
-1.0, G_MAXFLOAT,
-1.0,
CLUTTER_PARAM_READWRITE);
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
/**
* ClutterFlowLayout:min-row-height:
*
* Minimum height for each row in the layout, in pixels
*
* Since: 1.2
*/
Move more classes to install_properties()
2010-10-15 14:24:27 +00:00
flow_properties[PROP_MIN_ROW_HEGHT] =
g_param_spec_float ("min-row-height",
P_("Minimum Row Height"),
P_("Minimum height for each row"),
0.0, G_MAXFLOAT,
0.0,
CLUTTER_PARAM_READWRITE);
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
/**
* ClutterFlowLayout:max-row-height:
*
* Maximum height for each row in the layout, in pixels. If
* set to -1 the width will be the maximum child height
*
* Since: 1.2
*/
Move more classes to install_properties()
2010-10-15 14:24:27 +00:00
flow_properties[PROP_MAX_ROW_HEIGHT] =
g_param_spec_float ("max-row-height",
P_("Maximum Row Height"),
P_("Maximum height for each row"),
-1.0, G_MAXFLOAT,
-1.0,
CLUTTER_PARAM_READWRITE);
flow-layout: Add :snap-to-grid property Add a :snap-to-grid property to FlowLayout to prevent the layout from assigning it's children a position based on the size of the largest child. https://bugzilla.gnome.org/show_bug.cgi?id=648873
2013-05-03 15:53:44 +00:00
/**
* ClutterFlowLayout:snap-to-grid:
*
* Whether the #ClutterFlowLayout should arrange its children
* on a grid
*
* Since: 1.16
*/
flow_properties[PROP_SNAP_TO_GRID] =
g_param_spec_boolean ("snap-to-grid",
P_("Snap to grid"),
P_("Snap to grid"),
TRUE,
CLUTTER_PARAM_READWRITE);
Move more classes to install_properties()
2010-10-15 14:24:27 +00:00
gobject_class->finalize = clutter_flow_layout_finalize;
gobject_class->set_property = clutter_flow_layout_set_property;
gobject_class->get_property = clutter_flow_layout_get_property;
Remove private helper #define's Finish off the second half of 09a830d294. http://bugzilla.clutter-project.org/show_bug.cgi?id=2596
2011-03-03 11:35:46 +00:00
g_object_class_install_properties (gobject_class,
N_PROPERTIES,
flow_properties);
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
}
static void
clutter_flow_layout_init (ClutterFlowLayout *self)
{
ClutterFlowLayoutPrivate *priv;
Use the new macros for adding private data
2013-07-03 13:14:01 +00:00
self->priv = priv = clutter_flow_layout_get_instance_private (self);
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
priv->orientation = CLUTTER_FLOW_HORIZONTAL;
priv->col_spacing = 0;
priv->row_spacing = 0;
priv->min_col_width = priv->min_row_height = 0;
priv->max_col_width = priv->max_row_height = -1;
layout: Report the correct size of FlowLayout FlowLayout should compute the correct height for the assigned width when in horizontal flow, and the correct width for the assigned height when in vertical flow. This means pre-computing the number of lines inside the get_preferred_width() and get_preferred_height(). We can then cache the computed column width and row height, cache them inside the layout and then use them when allocating the children.
2009-10-08 14:45:29 +00:00
priv->line_min = NULL;
priv->line_natural = NULL;
flow-layout: Add :snap-to-grid property Add a :snap-to-grid property to FlowLayout to prevent the layout from assigning it's children a position based on the size of the largest child. https://bugzilla.gnome.org/show_bug.cgi?id=648873
2013-05-03 15:53:44 +00:00
priv->snap_to_grid = TRUE;
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
}
/**
* clutter_flow_layout_new:
* @orientation: the orientation of the flow layout
*
* Creates a new #ClutterFlowLayout with the given @orientation
*
* Return value: the newly created #ClutterFlowLayout
*
* Since: 1.2
*/
ClutterLayoutManager *
clutter_flow_layout_new (ClutterFlowOrientation orientation)
{
return g_object_new (CLUTTER_TYPE_FLOW_LAYOUT,
"orientation", orientation,
NULL);
}
[layout] Clean up and document FlowLayout
2009-10-07 10:08:51 +00:00
/**
* clutter_flow_layout_set_orientation:
* @layout: a #ClutterFlowLayout
* @orientation: the orientation of the layout
*
* Sets the orientation of the flow layout
*
* The orientation controls the direction used to allocate
* the children: either horizontally or vertically. The
[layout] Remove FlowLayout:wrap The :wrap property is not implemented, and mostly useless: the FlowLayout is a reflowing grid. This means that if it receives less than the preferred width or height in the flow direction then it should always reflow.
2009-10-07 11:35:39 +00:00
* orientation also controls the direction of the overflowing
[layout] Clean up and document FlowLayout
2009-10-07 10:08:51 +00:00
*
* Since: 1.2
*/
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
void
clutter_flow_layout_set_orientation (ClutterFlowLayout *layout,
ClutterFlowOrientation orientation)
{
ClutterFlowLayoutPrivate *priv;
g_return_if_fail (CLUTTER_IS_FLOW_LAYOUT (layout));
priv = layout->priv;
if (priv->orientation != orientation)
{
ClutterLayoutManager *manager;
priv->orientation = orientation;
layout: Change the request-mode along with the orientation When changing the orientation of a FlowLayout, the associated container should also change its request mode. A horizontally flowing layout has a height depending on the width, since it will reflow vertically; similarly, a vertically reflowing layout will have a width depending on the height.
2009-10-07 14:28:01 +00:00
if (priv->container != NULL)
{
ClutterRequestMode request_mode;
/* we need to change the :request-mode of the container
* to match the orientation
*/
request_mode = (priv->orientation == CLUTTER_FLOW_HORIZONTAL)
? CLUTTER_REQUEST_HEIGHT_FOR_WIDTH
: CLUTTER_REQUEST_WIDTH_FOR_HEIGHT;
clutter_actor_set_request_mode (CLUTTER_ACTOR (priv->container),
request_mode);
}
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
manager = CLUTTER_LAYOUT_MANAGER (layout);
clutter_layout_manager_layout_changed (manager);
Remove private helper #define's Finish off the second half of 09a830d294. http://bugzilla.clutter-project.org/show_bug.cgi?id=2596
2011-03-03 11:35:46 +00:00
g_object_notify_by_pspec (G_OBJECT (layout),
Move more classes to install_properties()
2010-10-15 14:24:27 +00:00
flow_properties[PROP_ORIENTATION]);
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
}
}
[layout] Clean up and document FlowLayout
2009-10-07 10:08:51 +00:00
/**
* clutter_flow_layout_get_orientation:
* @layout: a #ClutterFlowLayout
*
* Retrieves the orientation of the @layout
*
* Return value: the orientation of the #ClutterFlowLayout
*
* Since: 1.2
*/
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
ClutterFlowOrientation
clutter_flow_layout_get_orientation (ClutterFlowLayout *layout)
{
g_return_val_if_fail (CLUTTER_IS_FLOW_LAYOUT (layout),
CLUTTER_FLOW_HORIZONTAL);
return layout->priv->orientation;
}
[layout] Clean up and document FlowLayout
2009-10-07 10:08:51 +00:00
/**
* clutter_flow_layout_set_homogeneous:
* @layout: a #ClutterFlowLayout
* @homogeneous: whether the layout should be homogeneous or not
*
* Sets whether the @layout should allocate the same space for
* each child
*
* Since: 1.2
*/
[layout] Add :homogeneous to FlowLayout
2009-10-06 15:17:16 +00:00
void
clutter_flow_layout_set_homogeneous (ClutterFlowLayout *layout,
gboolean homogeneous)
{
ClutterFlowLayoutPrivate *priv;
g_return_if_fail (CLUTTER_IS_FLOW_LAYOUT (layout));
priv = layout->priv;
if (priv->is_homogeneous != homogeneous)
{
ClutterLayoutManager *manager;
priv->is_homogeneous = homogeneous;
manager = CLUTTER_LAYOUT_MANAGER (layout);
clutter_layout_manager_layout_changed (manager);
Remove private helper #define's Finish off the second half of 09a830d294. http://bugzilla.clutter-project.org/show_bug.cgi?id=2596
2011-03-03 11:35:46 +00:00
g_object_notify_by_pspec (G_OBJECT (layout),
Move more classes to install_properties()
2010-10-15 14:24:27 +00:00
flow_properties[PROP_HOMOGENEOUS]);
[layout] Add :homogeneous to FlowLayout
2009-10-06 15:17:16 +00:00
}
}
[layout] Clean up and document FlowLayout
2009-10-07 10:08:51 +00:00
/**
* clutter_flow_layout_get_homogeneous:
* @layout: a #ClutterFlowLayout
*
* Retrieves whether the @layout is homogeneous
*
* Return value: %TRUE if the #ClutterFlowLayout is homogeneous
*
* Since: 1.2
*/
[layout] Add :homogeneous to FlowLayout
2009-10-06 15:17:16 +00:00
gboolean
clutter_flow_layout_get_homogeneous (ClutterFlowLayout *layout)
{
g_return_val_if_fail (CLUTTER_IS_FLOW_LAYOUT (layout), FALSE);
return layout->priv->is_homogeneous;
}
[layout] Clean up and document FlowLayout
2009-10-07 10:08:51 +00:00
/**
* clutter_flow_layout_set_column_spacing:
* @layout: a #ClutterFlowLayout
* @spacing: the space between columns
*
* Sets the space between columns, in pixels
*
* Since: 1.2
*/
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
void
clutter_flow_layout_set_column_spacing (ClutterFlowLayout *layout,
gfloat spacing)
{
ClutterFlowLayoutPrivate *priv;
g_return_if_fail (CLUTTER_IS_FLOW_LAYOUT (layout));
priv = layout->priv;
if (priv->col_spacing != spacing)
{
ClutterLayoutManager *manager;
priv->col_spacing = spacing;
manager = CLUTTER_LAYOUT_MANAGER (layout);
clutter_layout_manager_layout_changed (manager);
Remove private helper #define's Finish off the second half of 09a830d294. http://bugzilla.clutter-project.org/show_bug.cgi?id=2596
2011-03-03 11:35:46 +00:00
g_object_notify_by_pspec (G_OBJECT (layout),
Move more classes to install_properties()
2010-10-15 14:24:27 +00:00
flow_properties[PROP_COLUMN_SPACING]);
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
}
}
[layout] Clean up and document FlowLayout
2009-10-07 10:08:51 +00:00
/**
* clutter_flow_layout_get_column_spacing:
* @layout: a #ClutterFlowLayout
*
* Retrieves the spacing between columns
*
* Return value: the spacing between columns of the #ClutterFlowLayout,
* in pixels
*
* Since: 1.2
*/
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
gfloat
clutter_flow_layout_get_column_spacing (ClutterFlowLayout *layout)
{
g_return_val_if_fail (CLUTTER_IS_FLOW_LAYOUT (layout), 0.0);
return layout->priv->col_spacing;
}
[layout] Clean up and document FlowLayout
2009-10-07 10:08:51 +00:00
/**
* clutter_flow_layout_set_row_spacing:
* @layout: a #ClutterFlowLayout
* @spacing: the space between rows
*
* Sets the spacing between rows, in pixels
*
* Since: 1.2
*/
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
void
clutter_flow_layout_set_row_spacing (ClutterFlowLayout *layout,
gfloat spacing)
{
ClutterFlowLayoutPrivate *priv;
g_return_if_fail (CLUTTER_IS_FLOW_LAYOUT (layout));
priv = layout->priv;
if (priv->row_spacing != spacing)
{
ClutterLayoutManager *manager;
priv->row_spacing = spacing;
manager = CLUTTER_LAYOUT_MANAGER (layout);
clutter_layout_manager_layout_changed (manager);
Remove private helper #define's Finish off the second half of 09a830d294. http://bugzilla.clutter-project.org/show_bug.cgi?id=2596
2011-03-03 11:35:46 +00:00
g_object_notify_by_pspec (G_OBJECT (layout),
Move more classes to install_properties()
2010-10-15 14:24:27 +00:00
flow_properties[PROP_ROW_SPACING]);
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
}
}
[layout] Clean up and document FlowLayout
2009-10-07 10:08:51 +00:00
/**
* clutter_flow_layout_get_row_spacing:
* @layout: a #ClutterFlowLayout
*
* Retrieves the spacing between rows
*
* Return value: the spacing between rows of the #ClutterFlowLayout,
* in pixels
*
* Since: 1.2
*/
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
gfloat
clutter_flow_layout_get_row_spacing (ClutterFlowLayout *layout)
{
g_return_val_if_fail (CLUTTER_IS_FLOW_LAYOUT (layout), 0.0);
return layout->priv->row_spacing;
}
[layout] Clean up and document FlowLayout
2009-10-07 10:08:51 +00:00
/**
* clutter_flow_layout_set_column_width:
* @layout: a #ClutterFlowLayout
* @min_width: minimum width of a column
* @max_width: maximum width of a column
*
* Sets the minimum and maximum widths that a column can have
*
* Since: 1.2
*/
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
void
clutter_flow_layout_set_column_width (ClutterFlowLayout *layout,
gfloat min_width,
gfloat max_width)
{
ClutterFlowLayoutPrivate *priv;
gboolean notify_min = FALSE, notify_max = FALSE;
g_return_if_fail (CLUTTER_IS_FLOW_LAYOUT (layout));
priv = layout->priv;
if (priv->min_col_width != min_width)
{
priv->min_col_width = min_width;
notify_min = TRUE;
}
if (priv->max_col_width != max_width)
{
priv->max_col_width = max_width;
notify_max = TRUE;
}
[layout] Clean up and document FlowLayout
2009-10-07 10:08:51 +00:00
g_object_freeze_notify (G_OBJECT (layout));
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
if (notify_min || notify_max)
{
ClutterLayoutManager *manager = CLUTTER_LAYOUT_MANAGER (layout);
clutter_layout_manager_layout_changed (manager);
}
if (notify_min)
Remove private helper #define's Finish off the second half of 09a830d294. http://bugzilla.clutter-project.org/show_bug.cgi?id=2596
2011-03-03 11:35:46 +00:00
g_object_notify_by_pspec (G_OBJECT (layout),
Move more classes to install_properties()
2010-10-15 14:24:27 +00:00
flow_properties[PROP_MIN_COLUMN_WIDTH]);
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
if (notify_max)
Remove private helper #define's Finish off the second half of 09a830d294. http://bugzilla.clutter-project.org/show_bug.cgi?id=2596
2011-03-03 11:35:46 +00:00
g_object_notify_by_pspec (G_OBJECT (layout),
Move more classes to install_properties()
2010-10-15 14:24:27 +00:00
flow_properties[PROP_MAX_COLUMN_WIDTH]);
[layout] Clean up and document FlowLayout
2009-10-07 10:08:51 +00:00
g_object_thaw_notify (G_OBJECT (layout));
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
}
[layout] Clean up and document FlowLayout
2009-10-07 10:08:51 +00:00
/**
* clutter_flow_layout_get_column_width:
* @layout: a #ClutterFlowLayout
* @min_width: (out): return location for the minimum column width, or %NULL
* @max_width: (out): return location for the maximum column width, or %NULL
*
* Retrieves the minimum and maximum column widths
*
* Since: 1.2
*/
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
void
clutter_flow_layout_get_column_width (ClutterFlowLayout *layout,
gfloat *min_width,
gfloat *max_width)
{
g_return_if_fail (CLUTTER_IS_FLOW_LAYOUT (layout));
if (min_width)
*min_width = layout->priv->min_col_width;
if (max_width)
*max_width = layout->priv->max_col_width;
}
[layout] Clean up and document FlowLayout
2009-10-07 10:08:51 +00:00
/**
* clutter_flow_layout_set_row_height:
* @layout: a #ClutterFlowLayout
* @min_height: the minimum height of a row
* @max_height: the maximum height of a row
*
* Sets the minimum and maximum heights that a row can have
*
* Since: 1.2
*/
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
void
clutter_flow_layout_set_row_height (ClutterFlowLayout *layout,
gfloat min_height,
gfloat max_height)
{
ClutterFlowLayoutPrivate *priv;
gboolean notify_min = FALSE, notify_max = FALSE;
g_return_if_fail (CLUTTER_IS_FLOW_LAYOUT (layout));
priv = layout->priv;
if (priv->min_row_height != min_height)
{
priv->min_row_height = min_height;
notify_min = TRUE;
}
if (priv->max_row_height != max_height)
{
priv->max_row_height = max_height;
notify_max = TRUE;
}
[layout] Clean up and document FlowLayout
2009-10-07 10:08:51 +00:00
g_object_freeze_notify (G_OBJECT (layout));
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
if (notify_min || notify_max)
{
ClutterLayoutManager *manager = CLUTTER_LAYOUT_MANAGER (layout);
clutter_layout_manager_layout_changed (manager);
}
if (notify_min)
Remove private helper #define's Finish off the second half of 09a830d294. http://bugzilla.clutter-project.org/show_bug.cgi?id=2596
2011-03-03 11:35:46 +00:00
g_object_notify_by_pspec (G_OBJECT (layout),
Move more classes to install_properties()
2010-10-15 14:24:27 +00:00
flow_properties[PROP_MIN_ROW_HEGHT]);
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
if (notify_max)
Remove private helper #define's Finish off the second half of 09a830d294. http://bugzilla.clutter-project.org/show_bug.cgi?id=2596
2011-03-03 11:35:46 +00:00
g_object_notify_by_pspec (G_OBJECT (layout),
Move more classes to install_properties()
2010-10-15 14:24:27 +00:00
flow_properties[PROP_MAX_ROW_HEIGHT]);
[layout] Clean up and document FlowLayout
2009-10-07 10:08:51 +00:00
g_object_thaw_notify (G_OBJECT (layout));
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
}
[layout] Clean up and document FlowLayout
2009-10-07 10:08:51 +00:00
/**
* clutter_flow_layout_get_row_height:
* @layout: a #ClutterFlowLayout
* @min_height: (out): return location for the minimum row height, or %NULL
* @max_height: (out): return location for the maximum row height, or %NULL
*
* Retrieves the minimum and maximum row heights
*
* Since: 1.2
*/
[layout] Initial implementation of FlowLayout FlowLayout is a layout manager that arranges its children in a reflowing line; the orientation controls the major axis for the layout: horizontal, for reflow on the Y axis, and vertical, for reflow on the X axis.
2009-09-18 16:28:02 +00:00
void
clutter_flow_layout_get_row_height (ClutterFlowLayout *layout,
gfloat *min_height,
gfloat *max_height)
{
g_return_if_fail (CLUTTER_IS_FLOW_LAYOUT (layout));
if (min_height)
*min_height = layout->priv->min_row_height;
if (max_height)
*max_height = layout->priv->max_row_height;
}
flow-layout: Add :snap-to-grid property Add a :snap-to-grid property to FlowLayout to prevent the layout from assigning it's children a position based on the size of the largest child. https://bugzilla.gnome.org/show_bug.cgi?id=648873
2013-05-03 15:53:44 +00:00
/**
* clutter_flow_layout_set_snap_to_grid:
* @layout: a #ClutterFlowLayout
* @snap_to_grid: %TRUE if @layout should place its children on a grid
*
* Whether the @layout should place its children on a grid.
*
* Since: 1.16
*/
void
clutter_flow_layout_set_snap_to_grid (ClutterFlowLayout *layout,
gboolean snap_to_grid)
{
ClutterFlowLayoutPrivate *priv;
g_return_if_fail (CLUTTER_IS_FLOW_LAYOUT (layout));
priv = layout->priv;
if (priv->snap_to_grid != snap_to_grid)
{
priv->snap_to_grid = snap_to_grid;
clutter_layout_manager_layout_changed (CLUTTER_LAYOUT_MANAGER (layout));
g_object_notify_by_pspec (G_OBJECT (layout),
flow_properties[PROP_SNAP_TO_GRID]);
}
}
/**
* clutter_flow_layout_get_snap_to_grid:
* @layout: a #ClutterFlowLayout
*
* Retrieves the value of #ClutterFlowLayout:snap-to-grid property
*
* Return value: %TRUE if the @layout is placing its children on a grid
*
* Since: 1.16
*/
gboolean
clutter_flow_layout_get_snap_to_grid (ClutterFlowLayout *layout)
{
g_return_val_if_fail (CLUTTER_IS_FLOW_LAYOUT (layout), FALSE);
return layout->priv->snap_to_grid;
}
Copy permalink