isa/mutter
1
0
Fork 0
mirror of https://github.com/brl/mutter.git synced 2024-12-25 04:22:05 +00:00
Code Issues Packages Projects Releases Wiki Activity
7a59b69f96
mutter/clutter/clutter-bin-layout.c

895 lines
25 KiB
C
Raw Normal View History

[layout] Document BinLayout
2009-09-14 11:04:42 +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-bin-layout
* @short_description: A simple layout manager
*
* #ClutterBinLayout is a layout manager which implements the following
* policy:
*
[layout, docs] Clean up BinLayout documentation Documentation and code style fixes for BinLayout.
2009-09-17 10:38:43 +00:00
* <itemizedlist>
* <listitem><simpara>the preferred size is the maximum preferred size
* between all the children of the container using the
* layout;</simpara></listitem>
* <listitem><simpara>each child is allocated in "layers", on on top
* of the other;</simpara></listitem>
* <listitem><simpara>for each layer there are horizontal and vertical
* alignment policies.</simpara></listitem>
* </itemizedlist>
*
docs: Add images for layout managers It's easier to show the layout manager policy with a simple screen shot coming from our interactive tests.
2009-10-23 16:32:18 +00:00
* <figure id="bin-layout">
* <title>Bin layout</title>
* <para>The image shows a #ClutterBinLayout with three layers:
* a background #ClutterCairoTexture, set to fill on both the X
* and Y axis; a #ClutterTexture, set to center on both the X and
* Y axis; and a #ClutterRectangle, set to %CLUTTER_BIN_ALIGNMENT_END
* on both the X and Y axis.</para>
* <graphic fileref="bin-layout.png" format="PNG"/>
* </figure>
*
[layout, docs] Clean up BinLayout documentation Documentation and code style fixes for BinLayout.
2009-09-17 10:38:43 +00:00
* <example id="example-clutter-bin-layout">
* <title>How to pack actors inside a BinLayout</title>
* <programlisting>
Move examples from tests/interactive to a new top-level The example code that is meant to be XIncluded into the API reference should not be part of the interactive test suite: it's code that it is meant to be used as a reference implementation - whereas the interactive test suite should be allowed to be lean and test behaviour even in nasty ways. In short: the test suite should not be the place where we show off idiomatic code for educational purposes.
2012-05-01 17:30:10 +00:00
* <xi:include xmlns:xi="http://www.w3.org/2001/XInclude" parse="text" href="../../../../examples/bin-layout.c">
docs: XInclude the bin layout example
2012-03-29 16:20:45 +00:00
* <xi:fallback>FIXME: MISSING XINCLUDE CONTENT</xi:fallback>
* </xi:include>
[layout, docs] Clean up BinLayout documentation Documentation and code style fixes for BinLayout.
2009-09-17 10:38:43 +00:00
* </programlisting>
* </example>
[layout] Document BinLayout
2009-09-14 11:04:42 +00:00
*
* #ClutterBinLayout is available since Clutter 1.2
*/
[layout] Add BinLayout A BinLayout is a simple layout manager that allocates a single cell, providing alignment on both the horizontal and vertical axis. If the container associated to the BinLayout has more than one child, the preferred size returned by the layout manager will be as big as the maximum of the children preferred sizes; the allocation will be applied to all children - but it will still depend on each child preferred size and the BinLayout horizontal and vertical alignment properties. The supported alignment properties are: * center: align the child by centering it * start: align the child at the top or left border of the layout * end: align the child at the bottom or right border of the layout * fill: expand the child to fill the size of the layout * fixed: let the child position itself
2009-09-11 12:51:23 +00:00
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
layout, bin: Use ceilf() instead of casting to int Casting a float to int to truncate it before assigning the value to a float again is wrong. We should use ceilf() instead which does what we want to achieve (rounding up the size to avoid sub-pixel positioning of children).
2009-10-15 13:12:37 +00:00
#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"
bin-layout: Deprecate BinLayout alignments We should use the ClutterActor's API for this.
2012-03-29 16:27:34 +00:00
#include "deprecated/clutter-bin-layout.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
bin-layout: Use the actor align/expand flags If an actor is set to expand, we use the actor's horizontal and vertical alignment values instead of the BinLayout's.
2012-03-29 15:34:36 +00:00
#include "clutter-actor-private.h"
[layout] Add BinLayout A BinLayout is a simple layout manager that allocates a single cell, providing alignment on both the horizontal and vertical axis. If the container associated to the BinLayout has more than one child, the preferred size returned by the layout manager will be as big as the maximum of the children preferred sizes; the allocation will be applied to all children - but it will still depend on each child preferred size and the BinLayout horizontal and vertical alignment properties. The supported alignment properties are: * center: align the child by centering it * start: align the child at the top or left border of the layout * end: align the child at the bottom or right border of the layout * fill: expand the child to fill the size of the layout * fixed: let the child position itself
2009-09-11 12:51:23 +00:00
#include "clutter-animatable.h"
[layout] Add layers to BinLayout Each actor managed by a BinLayout policy should reside inside its own "layer", with horizontal and vertical alignment. The :x-align and :y-align properties of the BinLayout are the default alignment policies, which are copied to each new "layer" when it is created. The set_alignment() and get_alignment() methods of BinLayout can be changed to operate on a specific "layer". The whole machinery uses the new ChildMeta support inside the LayoutManager base abstract class.
2009-09-14 20:51:49 +00:00
#include "clutter-child-meta.h"
[layout] Add BinLayout A BinLayout is a simple layout manager that allocates a single cell, providing alignment on both the horizontal and vertical axis. If the container associated to the BinLayout has more than one child, the preferred size returned by the layout manager will be as big as the maximum of the children preferred sizes; the allocation will be applied to all children - but it will still depend on each child preferred size and the BinLayout horizontal and vertical alignment properties. The supported alignment properties are: * center: align the child by centering it * start: align the child at the top or left border of the layout * end: align the child at the bottom or right border of the layout * fill: expand the child to fill the size of the layout * fixed: let the child position itself
2009-09-11 12:51:23 +00:00
#include "clutter-debug.h"
#include "clutter-enum-types.h"
[layout] Add LayoutMeta Instead of overloading ClutterChildMeta with both container and layout metadata and delegate to every LayoutManager implementation to keep a backpointer to the layout manager instance, we can simply subclass ChildMeta into LayoutMeta and presto! everything works out pretty well for everyone.
2009-09-15 16:37:11 +00:00
#include "clutter-layout-meta.h"
[layout] Add BinLayout A BinLayout is a simple layout manager that allocates a single cell, providing alignment on both the horizontal and vertical axis. If the container associated to the BinLayout has more than one child, the preferred size returned by the layout manager will be as big as the maximum of the children preferred sizes; the allocation will be applied to all children - but it will still depend on each child preferred size and the BinLayout horizontal and vertical alignment properties. The supported alignment properties are: * center: align the child by centering it * start: align the child at the top or left border of the layout * end: align the child at the bottom or right border of the layout * fill: expand the child to fill the size of the layout * fixed: let the child position itself
2009-09-11 12:51:23 +00:00
#include "clutter-private.h"
[layout] Add layers to BinLayout Each actor managed by a BinLayout policy should reside inside its own "layer", with horizontal and vertical alignment. The :x-align and :y-align properties of the BinLayout are the default alignment policies, which are copied to each new "layer" when it is created. The set_alignment() and get_alignment() methods of BinLayout can be changed to operate on a specific "layer". The whole machinery uses the new ChildMeta support inside the LayoutManager base abstract class.
2009-09-14 20:51:49 +00:00
#define CLUTTER_TYPE_BIN_LAYER (clutter_bin_layer_get_type ())
#define CLUTTER_BIN_LAYER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_BIN_LAYER, ClutterBinLayer))
#define CLUTTER_IS_BIN_LAYER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_BIN_LAYER))
[layout] Add BinLayout A BinLayout is a simple layout manager that allocates a single cell, providing alignment on both the horizontal and vertical axis. If the container associated to the BinLayout has more than one child, the preferred size returned by the layout manager will be as big as the maximum of the children preferred sizes; the allocation will be applied to all children - but it will still depend on each child preferred size and the BinLayout horizontal and vertical alignment properties. The supported alignment properties are: * center: align the child by centering it * start: align the child at the top or left border of the layout * end: align the child at the bottom or right border of the layout * fill: expand the child to fill the size of the layout * fixed: let the child position itself
2009-09-11 12:51:23 +00:00
#define CLUTTER_BIN_LAYOUT_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), CLUTTER_TYPE_BIN_LAYOUT, ClutterBinLayoutPrivate))
[layout] Add layers to BinLayout Each actor managed by a BinLayout policy should reside inside its own "layer", with horizontal and vertical alignment. The :x-align and :y-align properties of the BinLayout are the default alignment policies, which are copied to each new "layer" when it is created. The set_alignment() and get_alignment() methods of BinLayout can be changed to operate on a specific "layer". The whole machinery uses the new ChildMeta support inside the LayoutManager base abstract class.
2009-09-14 20:51:49 +00:00
typedef struct _ClutterBinLayer ClutterBinLayer;
[layout] Add LayoutMeta Instead of overloading ClutterChildMeta with both container and layout metadata and delegate to every LayoutManager implementation to keep a backpointer to the layout manager instance, we can simply subclass ChildMeta into LayoutMeta and presto! everything works out pretty well for everyone.
2009-09-15 16:37:11 +00:00
typedef struct _ClutterLayoutMetaClass ClutterBinLayerClass;
[layout] Add layers to BinLayout Each actor managed by a BinLayout policy should reside inside its own "layer", with horizontal and vertical alignment. The :x-align and :y-align properties of the BinLayout are the default alignment policies, which are copied to each new "layer" when it is created. The set_alignment() and get_alignment() methods of BinLayout can be changed to operate on a specific "layer". The whole machinery uses the new ChildMeta support inside the LayoutManager base abstract class.
2009-09-14 20:51:49 +00:00
[layout] Add BinLayout A BinLayout is a simple layout manager that allocates a single cell, providing alignment on both the horizontal and vertical axis. If the container associated to the BinLayout has more than one child, the preferred size returned by the layout manager will be as big as the maximum of the children preferred sizes; the allocation will be applied to all children - but it will still depend on each child preferred size and the BinLayout horizontal and vertical alignment properties. The supported alignment properties are: * center: align the child by centering it * start: align the child at the top or left border of the layout * end: align the child at the bottom or right border of the layout * fill: expand the child to fill the size of the layout * fixed: let the child position itself
2009-09-11 12:51:23 +00:00
struct _ClutterBinLayoutPrivate
{
ClutterBinAlignment x_align;
ClutterBinAlignment y_align;
[layout] Store and use the container inside BinLayout The BinLayout should store a pointer to the Container that it is using it as the layout manager. This allows us to fix the API and drop the additional Container arguments from set_alignment() and get_alignment(). This also allows us to add a ClutterBinLayout::add() method which adds an actor and sets the alignment policies without dealing with variadic arguments functions and GValue (de)marshalling.
2009-09-16 14:51:13 +00:00
ClutterContainer *container;
[layout] Add BinLayout A BinLayout is a simple layout manager that allocates a single cell, providing alignment on both the horizontal and vertical axis. If the container associated to the BinLayout has more than one child, the preferred size returned by the layout manager will be as big as the maximum of the children preferred sizes; the allocation will be applied to all children - but it will still depend on each child preferred size and the BinLayout horizontal and vertical alignment properties. The supported alignment properties are: * center: align the child by centering it * start: align the child at the top or left border of the layout * end: align the child at the bottom or right border of the layout * fill: expand the child to fill the size of the layout * fixed: let the child position itself
2009-09-11 12:51:23 +00:00
};
[layout] Add layers to BinLayout Each actor managed by a BinLayout policy should reside inside its own "layer", with horizontal and vertical alignment. The :x-align and :y-align properties of the BinLayout are the default alignment policies, which are copied to each new "layer" when it is created. The set_alignment() and get_alignment() methods of BinLayout can be changed to operate on a specific "layer". The whole machinery uses the new ChildMeta support inside the LayoutManager base abstract class.
2009-09-14 20:51:49 +00:00
struct _ClutterBinLayer
{
[layout] Add LayoutMeta Instead of overloading ClutterChildMeta with both container and layout metadata and delegate to every LayoutManager implementation to keep a backpointer to the layout manager instance, we can simply subclass ChildMeta into LayoutMeta and presto! everything works out pretty well for everyone.
2009-09-15 16:37:11 +00:00
ClutterLayoutMeta parent_instance;
[layout] Add layers to BinLayout Each actor managed by a BinLayout policy should reside inside its own "layer", with horizontal and vertical alignment. The :x-align and :y-align properties of the BinLayout are the default alignment policies, which are copied to each new "layer" when it is created. The set_alignment() and get_alignment() methods of BinLayout can be changed to operate on a specific "layer". The whole machinery uses the new ChildMeta support inside the LayoutManager base abstract class.
2009-09-14 20:51:49 +00:00
ClutterBinAlignment x_align;
ClutterBinAlignment y_align;
};
enum
{
PROP_LAYER_0,
PROP_LAYER_X_ALIGN,
Move more classes to install_properties()
2010-10-15 14:24:27 +00:00
PROP_LAYER_Y_ALIGN,
PROP_LAYER_LAST
[layout] Add layers to BinLayout Each actor managed by a BinLayout policy should reside inside its own "layer", with horizontal and vertical alignment. The :x-align and :y-align properties of the BinLayout are the default alignment policies, which are copied to each new "layer" when it is created. The set_alignment() and get_alignment() methods of BinLayout can be changed to operate on a specific "layer". The whole machinery uses the new ChildMeta support inside the LayoutManager base abstract class.
2009-09-14 20:51:49 +00:00
};
[layout] Add BinLayout A BinLayout is a simple layout manager that allocates a single cell, providing alignment on both the horizontal and vertical axis. If the container associated to the BinLayout has more than one child, the preferred size returned by the layout manager will be as big as the maximum of the children preferred sizes; the allocation will be applied to all children - but it will still depend on each child preferred size and the BinLayout horizontal and vertical alignment properties. The supported alignment properties are: * center: align the child by centering it * start: align the child at the top or left border of the layout * end: align the child at the bottom or right border of the layout * fill: expand the child to fill the size of the layout * fixed: let the child position itself
2009-09-11 12:51:23 +00:00
enum
{
PROP_0,
PROP_X_ALIGN,
Conditionally use g_object_notify_by_pspec This adds a wrapper macro to clutter-private that will use g_object_notify_by_pspec if it's compiled against a version of GLib that is sufficiently new. Otherwise it will notify by the property name as before by extracting the name from the pspec. The objects can then store a static array of GParamSpecs and notify using those as suggested in the documentation for g_object_notify_by_pspec. Note that the name of the variable used for storing the array of GParamSpecs is obj_props instead of properties as used in the documentation because some places in Clutter uses 'properties' as the name of a local variable. Mose of the classes in Clutter have been converted using the script in the bug report. Some classes have not been modified even though the script picked them up as described here: json-generator: We probably don't want to modify the internal copy of JSON behaviour-depth: rectangle: score: stage-manager: These aren't using the separate GParamSpec* variable style. blur-effect: win32/device-manager: Don't actually define any properties even though it has the enum. box-layout: flow-layout: Have some per-child properties that don't work automatically with the script. clutter-model: The script gets confused with ClutterModelIter stage: Script gets confused because PROP_USER_RESIZE doesn't match "user-resizable" test-layout: Don't really want to modify the tests http://bugzilla.clutter-project.org/show_bug.cgi?id=2150
2010-06-21 09:20:32 +00:00
PROP_Y_ALIGN,
PROP_LAST
[layout] Add BinLayout A BinLayout is a simple layout manager that allocates a single cell, providing alignment on both the horizontal and vertical axis. If the container associated to the BinLayout has more than one child, the preferred size returned by the layout manager will be as big as the maximum of the children preferred sizes; the allocation will be applied to all children - but it will still depend on each child preferred size and the BinLayout horizontal and vertical alignment properties. The supported alignment properties are: * center: align the child by centering it * start: align the child at the top or left border of the layout * end: align the child at the bottom or right border of the layout * fill: expand the child to fill the size of the layout * fixed: let the child position itself
2009-09-11 12:51:23 +00:00
};
Move more classes to install_properties()
2010-10-15 14:24:27 +00:00
static GParamSpec *layer_props[PROP_LAYER_LAST] = { NULL, };
static GParamSpec *bin_props[PROP_LAST] = { NULL, };
Conditionally use g_object_notify_by_pspec This adds a wrapper macro to clutter-private that will use g_object_notify_by_pspec if it's compiled against a version of GLib that is sufficiently new. Otherwise it will notify by the property name as before by extracting the name from the pspec. The objects can then store a static array of GParamSpecs and notify using those as suggested in the documentation for g_object_notify_by_pspec. Note that the name of the variable used for storing the array of GParamSpecs is obj_props instead of properties as used in the documentation because some places in Clutter uses 'properties' as the name of a local variable. Mose of the classes in Clutter have been converted using the script in the bug report. Some classes have not been modified even though the script picked them up as described here: json-generator: We probably don't want to modify the internal copy of JSON behaviour-depth: rectangle: score: stage-manager: These aren't using the separate GParamSpec* variable style. blur-effect: win32/device-manager: Don't actually define any properties even though it has the enum. box-layout: flow-layout: Have some per-child properties that don't work automatically with the script. clutter-model: The script gets confused with ClutterModelIter stage: Script gets confused because PROP_USER_RESIZE doesn't match "user-resizable" test-layout: Don't really want to modify the tests http://bugzilla.clutter-project.org/show_bug.cgi?id=2150
2010-06-21 09:20:32 +00:00
Fix missing/redundant declarations
2012-03-07 12:34:06 +00:00
GType clutter_bin_layer_get_type (void);
[layout] Add layers to BinLayout Each actor managed by a BinLayout policy should reside inside its own "layer", with horizontal and vertical alignment. The :x-align and :y-align properties of the BinLayout are the default alignment policies, which are copied to each new "layer" when it is created. The set_alignment() and get_alignment() methods of BinLayout can be changed to operate on a specific "layer". The whole machinery uses the new ChildMeta support inside the LayoutManager base abstract class.
2009-09-14 20:51:49 +00:00
G_DEFINE_TYPE (ClutterBinLayer,
clutter_bin_layer,
[layout] Add LayoutMeta Instead of overloading ClutterChildMeta with both container and layout metadata and delegate to every LayoutManager implementation to keep a backpointer to the layout manager instance, we can simply subclass ChildMeta into LayoutMeta and presto! everything works out pretty well for everyone.
2009-09-15 16:37:11 +00:00
CLUTTER_TYPE_LAYOUT_META);
[layout] Add layers to BinLayout Each actor managed by a BinLayout policy should reside inside its own "layer", with horizontal and vertical alignment. The :x-align and :y-align properties of the BinLayout are the default alignment policies, which are copied to each new "layer" when it is created. The set_alignment() and get_alignment() methods of BinLayout can be changed to operate on a specific "layer". The whole machinery uses the new ChildMeta support inside the LayoutManager base abstract class.
2009-09-14 20:51:49 +00:00
[layout] Add BinLayout A BinLayout is a simple layout manager that allocates a single cell, providing alignment on both the horizontal and vertical axis. If the container associated to the BinLayout has more than one child, the preferred size returned by the layout manager will be as big as the maximum of the children preferred sizes; the allocation will be applied to all children - but it will still depend on each child preferred size and the BinLayout horizontal and vertical alignment properties. The supported alignment properties are: * center: align the child by centering it * start: align the child at the top or left border of the layout * end: align the child at the bottom or right border of the layout * fill: expand the child to fill the size of the layout * fixed: let the child position itself
2009-09-11 12:51:23 +00:00
G_DEFINE_TYPE (ClutterBinLayout,
clutter_bin_layout,
CLUTTER_TYPE_LAYOUT_MANAGER);
[layout] Add layers to BinLayout Each actor managed by a BinLayout policy should reside inside its own "layer", with horizontal and vertical alignment. The :x-align and :y-align properties of the BinLayout are the default alignment policies, which are copied to each new "layer" when it is created. The set_alignment() and get_alignment() methods of BinLayout can be changed to operate on a specific "layer". The whole machinery uses the new ChildMeta support inside the LayoutManager base abstract class.
2009-09-14 20:51:49 +00:00
/*
* ClutterBinLayer
*/
static void
set_layer_x_align (ClutterBinLayer *self,
ClutterBinAlignment alignment)
{
ClutterLayoutManager *manager;
[layout] Add LayoutMeta Instead of overloading ClutterChildMeta with both container and layout metadata and delegate to every LayoutManager implementation to keep a backpointer to the layout manager instance, we can simply subclass ChildMeta into LayoutMeta and presto! everything works out pretty well for everyone.
2009-09-15 16:37:11 +00:00
ClutterLayoutMeta *meta;
[layout] Add layers to BinLayout Each actor managed by a BinLayout policy should reside inside its own "layer", with horizontal and vertical alignment. The :x-align and :y-align properties of the BinLayout are the default alignment policies, which are copied to each new "layer" when it is created. The set_alignment() and get_alignment() methods of BinLayout can be changed to operate on a specific "layer". The whole machinery uses the new ChildMeta support inside the LayoutManager base abstract class.
2009-09-14 20:51:49 +00:00
if (self->x_align == alignment)
return;
self->x_align = alignment;
[layout] Add LayoutMeta Instead of overloading ClutterChildMeta with both container and layout metadata and delegate to every LayoutManager implementation to keep a backpointer to the layout manager instance, we can simply subclass ChildMeta into LayoutMeta and presto! everything works out pretty well for everyone.
2009-09-15 16:37:11 +00:00
meta = CLUTTER_LAYOUT_META (self);
manager = clutter_layout_meta_get_manager (meta);
[layout] Add layers to BinLayout Each actor managed by a BinLayout policy should reside inside its own "layer", with horizontal and vertical alignment. The :x-align and :y-align properties of the BinLayout are the default alignment policies, which are copied to each new "layer" when it is created. The set_alignment() and get_alignment() methods of BinLayout can be changed to operate on a specific "layer". The whole machinery uses the new ChildMeta support inside the LayoutManager base abstract class.
2009-09-14 20:51:49 +00:00
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 (self), layer_props[PROP_LAYER_X_ALIGN]);
[layout] Add layers to BinLayout Each actor managed by a BinLayout policy should reside inside its own "layer", with horizontal and vertical alignment. The :x-align and :y-align properties of the BinLayout are the default alignment policies, which are copied to each new "layer" when it is created. The set_alignment() and get_alignment() methods of BinLayout can be changed to operate on a specific "layer". The whole machinery uses the new ChildMeta support inside the LayoutManager base abstract class.
2009-09-14 20:51:49 +00:00
}
static void
set_layer_y_align (ClutterBinLayer *self,
ClutterBinAlignment alignment)
{
ClutterLayoutManager *manager;
[layout] Add LayoutMeta Instead of overloading ClutterChildMeta with both container and layout metadata and delegate to every LayoutManager implementation to keep a backpointer to the layout manager instance, we can simply subclass ChildMeta into LayoutMeta and presto! everything works out pretty well for everyone.
2009-09-15 16:37:11 +00:00
ClutterLayoutMeta *meta;
[layout] Add layers to BinLayout Each actor managed by a BinLayout policy should reside inside its own "layer", with horizontal and vertical alignment. The :x-align and :y-align properties of the BinLayout are the default alignment policies, which are copied to each new "layer" when it is created. The set_alignment() and get_alignment() methods of BinLayout can be changed to operate on a specific "layer". The whole machinery uses the new ChildMeta support inside the LayoutManager base abstract class.
2009-09-14 20:51:49 +00:00
if (self->y_align == alignment)
return;
self->y_align = alignment;
[layout] Add LayoutMeta Instead of overloading ClutterChildMeta with both container and layout metadata and delegate to every LayoutManager implementation to keep a backpointer to the layout manager instance, we can simply subclass ChildMeta into LayoutMeta and presto! everything works out pretty well for everyone.
2009-09-15 16:37:11 +00:00
meta = CLUTTER_LAYOUT_META (self);
manager = clutter_layout_meta_get_manager (meta);
[layout] Add layers to BinLayout Each actor managed by a BinLayout policy should reside inside its own "layer", with horizontal and vertical alignment. The :x-align and :y-align properties of the BinLayout are the default alignment policies, which are copied to each new "layer" when it is created. The set_alignment() and get_alignment() methods of BinLayout can be changed to operate on a specific "layer". The whole machinery uses the new ChildMeta support inside the LayoutManager base abstract class.
2009-09-14 20:51:49 +00:00
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 (self), layer_props[PROP_LAYER_Y_ALIGN]);
[layout] Add layers to BinLayout Each actor managed by a BinLayout policy should reside inside its own "layer", with horizontal and vertical alignment. The :x-align and :y-align properties of the BinLayout are the default alignment policies, which are copied to each new "layer" when it is created. The set_alignment() and get_alignment() methods of BinLayout can be changed to operate on a specific "layer". The whole machinery uses the new ChildMeta support inside the LayoutManager base abstract class.
2009-09-14 20:51:49 +00:00
}
static void
clutter_bin_layer_set_property (GObject *gobject,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
ClutterBinLayer *layer = CLUTTER_BIN_LAYER (gobject);
switch (prop_id)
{
case PROP_LAYER_X_ALIGN:
set_layer_x_align (layer, g_value_get_enum (value));
break;
case PROP_LAYER_Y_ALIGN:
set_layer_y_align (layer, g_value_get_enum (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
break;
}
}
static void
clutter_bin_layer_get_property (GObject *gobject,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
ClutterBinLayer *layer = CLUTTER_BIN_LAYER (gobject);
switch (prop_id)
{
case PROP_LAYER_X_ALIGN:
g_value_set_enum (value, layer->x_align);
break;
case PROP_LAYER_Y_ALIGN:
g_value_set_enum (value, layer->y_align);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
break;
}
}
static void
clutter_bin_layer_class_init (ClutterBinLayerClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
gobject_class->set_property = clutter_bin_layer_set_property;
gobject_class->get_property = clutter_bin_layer_get_property;
Move more classes to install_properties()
2010-10-15 14:24:27 +00:00
layer_props[PROP_LAYER_X_ALIGN] =
g_param_spec_enum ("x-align",
P_("Horizontal Alignment"),
P_("Horizontal alignment for the actor "
"inside the layout manager"),
CLUTTER_TYPE_BIN_ALIGNMENT,
CLUTTER_BIN_ALIGNMENT_CENTER,
CLUTTER_PARAM_READWRITE);
layer_props[PROP_LAYER_Y_ALIGN] =
g_param_spec_enum ("y-align",
P_("Vertical Alignment"),
P_("Vertical alignment for the actor "
"inside the layout manager"),
CLUTTER_TYPE_BIN_ALIGNMENT,
CLUTTER_BIN_ALIGNMENT_CENTER,
CLUTTER_PARAM_READWRITE);
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,
PROP_LAYER_LAST,
layer_props);
[layout] Add layers to BinLayout Each actor managed by a BinLayout policy should reside inside its own "layer", with horizontal and vertical alignment. The :x-align and :y-align properties of the BinLayout are the default alignment policies, which are copied to each new "layer" when it is created. The set_alignment() and get_alignment() methods of BinLayout can be changed to operate on a specific "layer". The whole machinery uses the new ChildMeta support inside the LayoutManager base abstract class.
2009-09-14 20:51:49 +00:00
}
static void
clutter_bin_layer_init (ClutterBinLayer *layer)
{
layer->x_align = CLUTTER_BIN_ALIGNMENT_CENTER;
layer->y_align = CLUTTER_BIN_ALIGNMENT_CENTER;
}
/*
* ClutterBinLayout
*/
[layout] Add BinLayout A BinLayout is a simple layout manager that allocates a single cell, providing alignment on both the horizontal and vertical axis. If the container associated to the BinLayout has more than one child, the preferred size returned by the layout manager will be as big as the maximum of the children preferred sizes; the allocation will be applied to all children - but it will still depend on each child preferred size and the BinLayout horizontal and vertical alignment properties. The supported alignment properties are: * center: align the child by centering it * start: align the child at the top or left border of the layout * end: align the child at the bottom or right border of the layout * fill: expand the child to fill the size of the layout * fixed: let the child position itself
2009-09-11 12:51:23 +00:00
static void
set_x_align (ClutterBinLayout *self,
ClutterBinAlignment alignment)
{
ClutterBinLayoutPrivate *priv = self->priv;
if (priv->x_align != alignment)
{
[layout] Notify of alignment changes in BinLayout Emit the ::layout-changed when the BinLayout alignment policies change. This will result in a queue_relayout() on the containers using the BinLayout layout manager.
2009-09-14 11:03:38 +00:00
ClutterLayoutManager *manager;
[layout] Add BinLayout A BinLayout is a simple layout manager that allocates a single cell, providing alignment on both the horizontal and vertical axis. If the container associated to the BinLayout has more than one child, the preferred size returned by the layout manager will be as big as the maximum of the children preferred sizes; the allocation will be applied to all children - but it will still depend on each child preferred size and the BinLayout horizontal and vertical alignment properties. The supported alignment properties are: * center: align the child by centering it * start: align the child at the top or left border of the layout * end: align the child at the bottom or right border of the layout * fill: expand the child to fill the size of the layout * fixed: let the child position itself
2009-09-11 12:51:23 +00:00
priv->x_align = alignment;
[layout] Notify of alignment changes in BinLayout Emit the ::layout-changed when the BinLayout alignment policies change. This will result in a queue_relayout() on the containers using the BinLayout layout manager.
2009-09-14 11:03:38 +00:00
manager = CLUTTER_LAYOUT_MANAGER (self);
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 (self), bin_props[PROP_X_ALIGN]);
[layout] Add BinLayout A BinLayout is a simple layout manager that allocates a single cell, providing alignment on both the horizontal and vertical axis. If the container associated to the BinLayout has more than one child, the preferred size returned by the layout manager will be as big as the maximum of the children preferred sizes; the allocation will be applied to all children - but it will still depend on each child preferred size and the BinLayout horizontal and vertical alignment properties. The supported alignment properties are: * center: align the child by centering it * start: align the child at the top or left border of the layout * end: align the child at the bottom or right border of the layout * fill: expand the child to fill the size of the layout * fixed: let the child position itself
2009-09-11 12:51:23 +00:00
}
}
static void
set_y_align (ClutterBinLayout *self,
ClutterBinAlignment alignment)
{
ClutterBinLayoutPrivate *priv = self->priv;
if (priv->y_align != alignment)
{
[layout] Notify of alignment changes in BinLayout Emit the ::layout-changed when the BinLayout alignment policies change. This will result in a queue_relayout() on the containers using the BinLayout layout manager.
2009-09-14 11:03:38 +00:00
ClutterLayoutManager *manager;
[layout] Add BinLayout A BinLayout is a simple layout manager that allocates a single cell, providing alignment on both the horizontal and vertical axis. If the container associated to the BinLayout has more than one child, the preferred size returned by the layout manager will be as big as the maximum of the children preferred sizes; the allocation will be applied to all children - but it will still depend on each child preferred size and the BinLayout horizontal and vertical alignment properties. The supported alignment properties are: * center: align the child by centering it * start: align the child at the top or left border of the layout * end: align the child at the bottom or right border of the layout * fill: expand the child to fill the size of the layout * fixed: let the child position itself
2009-09-11 12:51:23 +00:00
priv->y_align = alignment;
[layout] Notify of alignment changes in BinLayout Emit the ::layout-changed when the BinLayout alignment policies change. This will result in a queue_relayout() on the containers using the BinLayout layout manager.
2009-09-14 11:03:38 +00:00
manager = CLUTTER_LAYOUT_MANAGER (self);
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 (self), bin_props[PROP_Y_ALIGN]);
[layout] Add BinLayout A BinLayout is a simple layout manager that allocates a single cell, providing alignment on both the horizontal and vertical axis. If the container associated to the BinLayout has more than one child, the preferred size returned by the layout manager will be as big as the maximum of the children preferred sizes; the allocation will be applied to all children - but it will still depend on each child preferred size and the BinLayout horizontal and vertical alignment properties. The supported alignment properties are: * center: align the child by centering it * start: align the child at the top or left border of the layout * end: align the child at the bottom or right border of the layout * fill: expand the child to fill the size of the layout * fixed: let the child position itself
2009-09-11 12:51:23 +00:00
}
}
static void
clutter_bin_layout_get_preferred_width (ClutterLayoutManager *manager,
ClutterContainer *container,
gfloat for_height,
gfloat *min_width_p,
gfloat *nat_width_p)
{
Begin porting layout managers to the new child iteration API Instead of getting the list of children to iterate over it, let's use the newly added child iteration API; this should save us a bunch of allocations, as well as indirections. Ported: ClutterBinLayout and ClutterBoxLayout.
2011-12-18 10:29:01 +00:00
ClutterActor *actor = CLUTTER_ACTOR (container);
Use ClutterActorIter inside layout managers Whenever it is possible, or convenient.
2012-01-30 10:55:30 +00:00
ClutterActorIter iter;
Begin porting layout managers to the new child iteration API Instead of getting the list of children to iterate over it, let's use the newly added child iteration API; this should save us a bunch of allocations, as well as indirections. Ported: ClutterBinLayout and ClutterBoxLayout.
2011-12-18 10:29:01 +00:00
ClutterActor *child;
[layout] Add BinLayout A BinLayout is a simple layout manager that allocates a single cell, providing alignment on both the horizontal and vertical axis. If the container associated to the BinLayout has more than one child, the preferred size returned by the layout manager will be as big as the maximum of the children preferred sizes; the allocation will be applied to all children - but it will still depend on each child preferred size and the BinLayout horizontal and vertical alignment properties. The supported alignment properties are: * center: align the child by centering it * start: align the child at the top or left border of the layout * end: align the child at the bottom or right border of the layout * fill: expand the child to fill the size of the layout * fixed: let the child position itself
2009-09-11 12:51:23 +00:00
gfloat min_width, nat_width;
min_width = nat_width = 0.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] Add BinLayout A BinLayout is a simple layout manager that allocates a single cell, providing alignment on both the horizontal and vertical axis. If the container associated to the BinLayout has more than one child, the preferred size returned by the layout manager will be as big as the maximum of the children preferred sizes; the allocation will be applied to all children - but it will still depend on each child preferred size and the BinLayout horizontal and vertical alignment properties. The supported alignment properties are: * center: align the child by centering it * start: align the child at the top or left border of the layout * end: align the child at the bottom or right border of the layout * fill: expand the child to fill the size of the layout * fixed: let the child position itself
2009-09-11 12:51:23 +00:00
{
gfloat minimum, natural;
Don't allocate size for invisible BinLayout children
2012-06-05 08:55:17 +00:00
if (!CLUTTER_ACTOR_IS_VISIBLE (child))
continue;
[layout] Add BinLayout A BinLayout is a simple layout manager that allocates a single cell, providing alignment on both the horizontal and vertical axis. If the container associated to the BinLayout has more than one child, the preferred size returned by the layout manager will be as big as the maximum of the children preferred sizes; the allocation will be applied to all children - but it will still depend on each child preferred size and the BinLayout horizontal and vertical alignment properties. The supported alignment properties are: * center: align the child by centering it * start: align the child at the top or left border of the layout * end: align the child at the bottom or right border of the layout * fill: expand the child to fill the size of the layout * fixed: let the child position itself
2009-09-11 12:51:23 +00:00
clutter_actor_get_preferred_width (child, for_height,
&minimum,
&natural);
min_width = MAX (min_width, minimum);
nat_width = MAX (nat_width, natural);
}
if (min_width_p)
*min_width_p = min_width;
if (nat_width_p)
*nat_width_p = nat_width;
}
static void
clutter_bin_layout_get_preferred_height (ClutterLayoutManager *manager,
ClutterContainer *container,
gfloat for_width,
gfloat *min_height_p,
gfloat *nat_height_p)
{
Begin porting layout managers to the new child iteration API Instead of getting the list of children to iterate over it, let's use the newly added child iteration API; this should save us a bunch of allocations, as well as indirections. Ported: ClutterBinLayout and ClutterBoxLayout.
2011-12-18 10:29:01 +00:00
ClutterActor *actor = CLUTTER_ACTOR (container);
Use ClutterActorIter inside layout managers Whenever it is possible, or convenient.
2012-01-30 10:55:30 +00:00
ClutterActorIter iter;
Begin porting layout managers to the new child iteration API Instead of getting the list of children to iterate over it, let's use the newly added child iteration API; this should save us a bunch of allocations, as well as indirections. Ported: ClutterBinLayout and ClutterBoxLayout.
2011-12-18 10:29:01 +00:00
ClutterActor *child;
[layout] Add BinLayout A BinLayout is a simple layout manager that allocates a single cell, providing alignment on both the horizontal and vertical axis. If the container associated to the BinLayout has more than one child, the preferred size returned by the layout manager will be as big as the maximum of the children preferred sizes; the allocation will be applied to all children - but it will still depend on each child preferred size and the BinLayout horizontal and vertical alignment properties. The supported alignment properties are: * center: align the child by centering it * start: align the child at the top or left border of the layout * end: align the child at the bottom or right border of the layout * fill: expand the child to fill the size of the layout * fixed: let the child position itself
2009-09-11 12:51:23 +00:00
gfloat min_height, nat_height;
min_height = nat_height = 0.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] Add BinLayout A BinLayout is a simple layout manager that allocates a single cell, providing alignment on both the horizontal and vertical axis. If the container associated to the BinLayout has more than one child, the preferred size returned by the layout manager will be as big as the maximum of the children preferred sizes; the allocation will be applied to all children - but it will still depend on each child preferred size and the BinLayout horizontal and vertical alignment properties. The supported alignment properties are: * center: align the child by centering it * start: align the child at the top or left border of the layout * end: align the child at the bottom or right border of the layout * fill: expand the child to fill the size of the layout * fixed: let the child position itself
2009-09-11 12:51:23 +00:00
{
gfloat minimum, natural;
Don't allocate size for invisible BinLayout children
2012-06-05 08:55:17 +00:00
if (!CLUTTER_ACTOR_IS_VISIBLE (child))
continue;
[layout] Add BinLayout A BinLayout is a simple layout manager that allocates a single cell, providing alignment on both the horizontal and vertical axis. If the container associated to the BinLayout has more than one child, the preferred size returned by the layout manager will be as big as the maximum of the children preferred sizes; the allocation will be applied to all children - but it will still depend on each child preferred size and the BinLayout horizontal and vertical alignment properties. The supported alignment properties are: * center: align the child by centering it * start: align the child at the top or left border of the layout * end: align the child at the bottom or right border of the layout * fill: expand the child to fill the size of the layout * fixed: let the child position itself
2009-09-11 12:51:23 +00:00
clutter_actor_get_preferred_height (child, for_width,
&minimum,
&natural);
min_height = MAX (min_height, minimum);
nat_height = MAX (nat_height, natural);
}
if (min_height_p)
*min_height_p = min_height;
if (nat_height_p)
*nat_height_p = nat_height;
}
static gdouble
get_bin_alignment_factor (ClutterBinAlignment alignment)
{
switch (alignment)
{
case CLUTTER_BIN_ALIGNMENT_CENTER:
return 0.5;
case CLUTTER_BIN_ALIGNMENT_START:
return 0.0;
case CLUTTER_BIN_ALIGNMENT_END:
return 1.0;
case CLUTTER_BIN_ALIGNMENT_FIXED:
case CLUTTER_BIN_ALIGNMENT_FILL:
return 0.0;
}
return 0.0;
}
bin-layout: Use the actor align/expand flags If an actor is set to expand, we use the actor's horizontal and vertical alignment values instead of the BinLayout's.
2012-03-29 15:34:36 +00:00
static gdouble
get_actor_align_factor (ClutterActorAlign alignment)
{
switch (alignment)
{
case CLUTTER_ACTOR_ALIGN_CENTER:
return 0.5;
case CLUTTER_ACTOR_ALIGN_START:
return 0.0;
case CLUTTER_ACTOR_ALIGN_END:
return 1.0;
case CLUTTER_ACTOR_ALIGN_FILL:
return 0.0;
}
return 0.0;
}
[layout] Add BinLayout A BinLayout is a simple layout manager that allocates a single cell, providing alignment on both the horizontal and vertical axis. If the container associated to the BinLayout has more than one child, the preferred size returned by the layout manager will be as big as the maximum of the children preferred sizes; the allocation will be applied to all children - but it will still depend on each child preferred size and the BinLayout horizontal and vertical alignment properties. The supported alignment properties are: * center: align the child by centering it * start: align the child at the top or left border of the layout * end: align the child at the bottom or right border of the layout * fill: expand the child to fill the size of the layout * fixed: let the child position itself
2009-09-11 12:51:23 +00:00
static void
clutter_bin_layout_allocate (ClutterLayoutManager *manager,
ClutterContainer *container,
const ClutterActorBox *allocation,
ClutterAllocationFlags flags)
{
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 allocation_x, allocation_y;
[layout] Add BinLayout A BinLayout is a simple layout manager that allocates a single cell, providing alignment on both the horizontal and vertical axis. If the container associated to the BinLayout has more than one child, the preferred size returned by the layout manager will be as big as the maximum of the children preferred sizes; the allocation will be applied to all children - but it will still depend on each child preferred size and the BinLayout horizontal and vertical alignment properties. The supported alignment properties are: * center: align the child by centering it * start: align the child at the top or left border of the layout * end: align the child at the bottom or right border of the layout * fill: expand the child to fill the size of the layout * fixed: let the child position itself
2009-09-11 12:51:23 +00:00
gfloat available_w, available_h;
Begin porting layout managers to the new child iteration API Instead of getting the list of children to iterate over it, let's use the newly added child iteration API; this should save us a bunch of allocations, as well as indirections. Ported: ClutterBinLayout and ClutterBoxLayout.
2011-12-18 10:29:01 +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] Add BinLayout A BinLayout is a simple layout manager that allocates a single cell, providing alignment on both the horizontal and vertical axis. If the container associated to the BinLayout has more than one child, the preferred size returned by the layout manager will be as big as the maximum of the children preferred sizes; the allocation will be applied to all children - but it will still depend on each child preferred size and the BinLayout horizontal and vertical alignment properties. The supported alignment properties are: * center: align the child by centering it * start: align the child at the top or left border of the layout * end: align the child at the bottom or right border of the layout * fill: expand the child to fill the size of the layout * fixed: let the child position itself
2009-09-11 12:51:23 +00:00
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, &allocation_x, &allocation_y);
clutter_actor_box_get_size (allocation, &available_w, &available_h);
[layout] Add BinLayout A BinLayout is a simple layout manager that allocates a single cell, providing alignment on both the horizontal and vertical axis. If the container associated to the BinLayout has more than one child, the preferred size returned by the layout manager will be as big as the maximum of the children preferred sizes; the allocation will be applied to all children - but it will still depend on each child preferred size and the BinLayout horizontal and vertical alignment properties. The supported alignment properties are: * center: align the child by centering it * start: align the child at the top or left border of the layout * end: align the child at the bottom or right border of the layout * fill: expand the child to fill the size of the layout * fixed: let the child position itself
2009-09-11 12:51:23 +00:00
Begin porting layout managers to the new child iteration API Instead of getting the list of children to iterate over it, let's use the newly added child iteration API; this should save us a bunch of allocations, as well as indirections. Ported: ClutterBinLayout and ClutterBoxLayout.
2011-12-18 10:29:01 +00:00
actor = CLUTTER_ACTOR (container);
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] Add BinLayout A BinLayout is a simple layout manager that allocates a single cell, providing alignment on both the horizontal and vertical axis. If the container associated to the BinLayout has more than one child, the preferred size returned by the layout manager will be as big as the maximum of the children preferred sizes; the allocation will be applied to all children - but it will still depend on each child preferred size and the BinLayout horizontal and vertical alignment properties. The supported alignment properties are: * center: align the child by centering it * start: align the child at the top or left border of the layout * end: align the child at the bottom or right border of the layout * fill: expand the child to fill the size of the layout * fixed: let the child position itself
2009-09-11 12:51:23 +00:00
{
[layout] Add LayoutMeta Instead of overloading ClutterChildMeta with both container and layout metadata and delegate to every LayoutManager implementation to keep a backpointer to the layout manager instance, we can simply subclass ChildMeta into LayoutMeta and presto! everything works out pretty well for everyone.
2009-09-15 16:37:11 +00:00
ClutterLayoutMeta *meta;
[layout] Add layers to BinLayout Each actor managed by a BinLayout policy should reside inside its own "layer", with horizontal and vertical alignment. The :x-align and :y-align properties of the BinLayout are the default alignment policies, which are copied to each new "layer" when it is created. The set_alignment() and get_alignment() methods of BinLayout can be changed to operate on a specific "layer". The whole machinery uses the new ChildMeta support inside the LayoutManager base abstract class.
2009-09-14 20:51:49 +00:00
ClutterBinLayer *layer;
[layout] Add BinLayout A BinLayout is a simple layout manager that allocates a single cell, providing alignment on both the horizontal and vertical axis. If the container associated to the BinLayout has more than one child, the preferred size returned by the layout manager will be as big as the maximum of the children preferred sizes; the allocation will be applied to all children - but it will still depend on each child preferred size and the BinLayout horizontal and vertical alignment properties. The supported alignment properties are: * center: align the child by centering it * start: align the child at the top or left border of the layout * end: align the child at the bottom or right border of the layout * fill: expand the child to fill the size of the layout * fixed: let the child position itself
2009-09-11 12:51:23 +00:00
ClutterActorBox child_alloc = { 0, };
bin-layout: Migrate to allocate_align_fill() Now that we have the code in ClutterActor itself.
2010-08-10 16:43:26 +00:00
gdouble x_align, y_align;
bin-layout: Use ClutterActor:fixed-position-set Instead of only relying on the (now) deprecated BinAlignment.FIXED enumeration value, we just ask the actor if a fixed position has been explicitly set, under the assumption that if a developer decided to call set_x(), set_y(), or set_position() on an actor inside a BinLayout then she wanted the fixed position to be honoured. This removes the last (proper) use of the BinAlignment enumeration.
2012-08-09 16:11:10 +00:00
gboolean x_fill, y_fill, is_fixed_position_set;
float fixed_x, fixed_y;
[layout] Add BinLayout A BinLayout is a simple layout manager that allocates a single cell, providing alignment on both the horizontal and vertical axis. If the container associated to the BinLayout has more than one child, the preferred size returned by the layout manager will be as big as the maximum of the children preferred sizes; the allocation will be applied to all children - but it will still depend on each child preferred size and the BinLayout horizontal and vertical alignment properties. The supported alignment properties are: * center: align the child by centering it * start: align the child at the top or left border of the layout * end: align the child at the bottom or right border of the layout * fill: expand the child to fill the size of the layout * fixed: let the child position itself
2009-09-11 12:51:23 +00:00
Don't allocate size to invisible BinLayout children This is similar to what other layouts do, and avoids problems with Gtk+ actor children which warn about being allocated not enough space.
2012-06-08 09:29:43 +00:00
if (!CLUTTER_ACTOR_IS_VISIBLE (child))
continue;
[layout] Add layers to BinLayout Each actor managed by a BinLayout policy should reside inside its own "layer", with horizontal and vertical alignment. The :x-align and :y-align properties of the BinLayout are the default alignment policies, which are copied to each new "layer" when it is created. The set_alignment() and get_alignment() methods of BinLayout can be changed to operate on a specific "layer". The whole machinery uses the new ChildMeta support inside the LayoutManager base abstract class.
2009-09-14 20:51:49 +00:00
meta = clutter_layout_manager_get_child_meta (manager,
container,
child);
layer = CLUTTER_BIN_LAYER (meta);
bin-layout: Use ClutterActor:fixed-position-set Instead of only relying on the (now) deprecated BinAlignment.FIXED enumeration value, we just ask the actor if a fixed position has been explicitly set, under the assumption that if a developer decided to call set_x(), set_y(), or set_position() on an actor inside a BinLayout then she wanted the fixed position to be honoured. This removes the last (proper) use of the BinAlignment enumeration.
2012-08-09 16:11:10 +00:00
fixed_x = fixed_y = 0.f;
g_object_get (child,
"fixed-position-set", &is_fixed_position_set,
"fixed-x", &fixed_x,
"fixed-y", &fixed_y,
NULL);
/* XXX:2.0 - remove the FIXED alignment, and just use the fixed position
* of the actor if one is set
*/
if (is_fixed_position_set ||
layer->x_align == CLUTTER_BIN_ALIGNMENT_FIXED)
BinLayout: Always use fixed_x/y for FIXED if set We want to use the actually set value for x/y, not the current allocation, as that might be a transition from an earlier allocation animation.
2012-06-07 14:44:08 +00:00
{
bin-layout: Use ClutterActor:fixed-position-set Instead of only relying on the (now) deprecated BinAlignment.FIXED enumeration value, we just ask the actor if a fixed position has been explicitly set, under the assumption that if a developer decided to call set_x(), set_y(), or set_position() on an actor inside a BinLayout then she wanted the fixed position to be honoured. This removes the last (proper) use of the BinAlignment enumeration.
2012-08-09 16:11:10 +00:00
if (is_fixed_position_set)
child_alloc.x1 = fixed_x;
else
child_alloc.x1 = clutter_actor_get_x (child);
BinLayout: Always use fixed_x/y for FIXED if set We want to use the actually set value for x/y, not the current allocation, as that might be a transition from an earlier allocation animation.
2012-06-07 14:44:08 +00:00
}
[layout] Add BinLayout A BinLayout is a simple layout manager that allocates a single cell, providing alignment on both the horizontal and vertical axis. If the container associated to the BinLayout has more than one child, the preferred size returned by the layout manager will be as big as the maximum of the children preferred sizes; the allocation will be applied to all children - but it will still depend on each child preferred size and the BinLayout horizontal and vertical alignment properties. The supported alignment properties are: * center: align the child by centering it * start: align the child at the top or left border of the layout * end: align the child at the bottom or right border of the layout * fill: expand the child to fill the size of the layout * fixed: let the child position itself
2009-09-11 12:51:23 +00:00
else
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
child_alloc.x1 = allocation_x;
[layout] Add BinLayout A BinLayout is a simple layout manager that allocates a single cell, providing alignment on both the horizontal and vertical axis. If the container associated to the BinLayout has more than one child, the preferred size returned by the layout manager will be as big as the maximum of the children preferred sizes; the allocation will be applied to all children - but it will still depend on each child preferred size and the BinLayout horizontal and vertical alignment properties. The supported alignment properties are: * center: align the child by centering it * start: align the child at the top or left border of the layout * end: align the child at the bottom or right border of the layout * fill: expand the child to fill the size of the layout * fixed: let the child position itself
2009-09-11 12:51:23 +00:00
bin-layout: Use ClutterActor:fixed-position-set Instead of only relying on the (now) deprecated BinAlignment.FIXED enumeration value, we just ask the actor if a fixed position has been explicitly set, under the assumption that if a developer decided to call set_x(), set_y(), or set_position() on an actor inside a BinLayout then she wanted the fixed position to be honoured. This removes the last (proper) use of the BinAlignment enumeration.
2012-08-09 16:11:10 +00:00
if (is_fixed_position_set ||
layer->y_align == CLUTTER_BIN_ALIGNMENT_FIXED)
BinLayout: Always use fixed_x/y for FIXED if set We want to use the actually set value for x/y, not the current allocation, as that might be a transition from an earlier allocation animation.
2012-06-07 14:44:08 +00:00
{
bin-layout: Use ClutterActor:fixed-position-set Instead of only relying on the (now) deprecated BinAlignment.FIXED enumeration value, we just ask the actor if a fixed position has been explicitly set, under the assumption that if a developer decided to call set_x(), set_y(), or set_position() on an actor inside a BinLayout then she wanted the fixed position to be honoured. This removes the last (proper) use of the BinAlignment enumeration.
2012-08-09 16:11:10 +00:00
if (is_fixed_position_set)
child_alloc.y1 = fixed_y;
else
BinLayout: Always use fixed_x/y for FIXED if set We want to use the actually set value for x/y, not the current allocation, as that might be a transition from an earlier allocation animation.
2012-06-07 14:44:08 +00:00
child_alloc.y1 = clutter_actor_get_y (child);
}
[layout] Add BinLayout A BinLayout is a simple layout manager that allocates a single cell, providing alignment on both the horizontal and vertical axis. If the container associated to the BinLayout has more than one child, the preferred size returned by the layout manager will be as big as the maximum of the children preferred sizes; the allocation will be applied to all children - but it will still depend on each child preferred size and the BinLayout horizontal and vertical alignment properties. The supported alignment properties are: * center: align the child by centering it * start: align the child at the top or left border of the layout * end: align the child at the bottom or right border of the layout * fill: expand the child to fill the size of the layout * fixed: let the child position itself
2009-09-11 12:51:23 +00:00
else
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
child_alloc.y1 = allocation_y;
bin-layout: Migrate to allocate_align_fill() Now that we have the code in ClutterActor itself.
2010-08-10 16:43:26 +00:00
child_alloc.x2 = available_w;
child_alloc.y2 = available_h;
[layout] Add BinLayout A BinLayout is a simple layout manager that allocates a single cell, providing alignment on both the horizontal and vertical axis. If the container associated to the BinLayout has more than one child, the preferred size returned by the layout manager will be as big as the maximum of the children preferred sizes; the allocation will be applied to all children - but it will still depend on each child preferred size and the BinLayout horizontal and vertical alignment properties. The supported alignment properties are: * center: align the child by centering it * start: align the child at the top or left border of the layout * end: align the child at the bottom or right border of the layout * fill: expand the child to fill the size of the layout * fixed: let the child position itself
2009-09-11 12:51:23 +00:00
actor: Coalesce needs_[xy]_expand() into one method Use the orientation enumeration instead of a per-axis method.
2012-04-20 11:45:54 +00:00
if (clutter_actor_needs_expand (child, CLUTTER_ORIENTATION_HORIZONTAL))
bin-layout: Use the actor align/expand flags If an actor is set to expand, we use the actor's horizontal and vertical alignment values instead of the BinLayout's.
2012-03-29 15:34:36 +00:00
{
ClutterActorAlign align;
align = _clutter_actor_get_effective_x_align (child);
x_fill = align == CLUTTER_ACTOR_ALIGN_FILL;
x_align = get_actor_align_factor (align);
}
else
{
x_fill = (layer->x_align == CLUTTER_BIN_ALIGNMENT_FILL);
x_align = get_bin_alignment_factor (layer->x_align);
}
actor: Coalesce needs_[xy]_expand() into one method Use the orientation enumeration instead of a per-axis method.
2012-04-20 11:45:54 +00:00
if (clutter_actor_needs_expand (child, CLUTTER_ORIENTATION_VERTICAL))
bin-layout: Use the actor align/expand flags If an actor is set to expand, we use the actor's horizontal and vertical alignment values instead of the BinLayout's.
2012-03-29 15:34:36 +00:00
{
ClutterActorAlign align;
align = clutter_actor_get_y_align (child);
y_fill = align == CLUTTER_ACTOR_ALIGN_FILL;
y_align = get_actor_align_factor (align);
}
else
{
y_fill = (layer->y_align == CLUTTER_BIN_ALIGNMENT_FILL);
y_align = get_bin_alignment_factor (layer->y_align);
}
[layout] Add BinLayout A BinLayout is a simple layout manager that allocates a single cell, providing alignment on both the horizontal and vertical axis. If the container associated to the BinLayout has more than one child, the preferred size returned by the layout manager will be as big as the maximum of the children preferred sizes; the allocation will be applied to all children - but it will still depend on each child preferred size and the BinLayout horizontal and vertical alignment properties. The supported alignment properties are: * center: align the child by centering it * start: align the child at the top or left border of the layout * end: align the child at the bottom or right border of the layout * fill: expand the child to fill the size of the layout * fixed: let the child position itself
2009-09-11 12:51:23 +00:00
bin-layout: Migrate to allocate_align_fill() Now that we have the code in ClutterActor itself.
2010-08-10 16:43:26 +00:00
clutter_actor_allocate_align_fill (child, &child_alloc,
x_align, y_align,
x_fill, y_fill,
flags);
[layout] Add BinLayout A BinLayout is a simple layout manager that allocates a single cell, providing alignment on both the horizontal and vertical axis. If the container associated to the BinLayout has more than one child, the preferred size returned by the layout manager will be as big as the maximum of the children preferred sizes; the allocation will be applied to all children - but it will still depend on each child preferred size and the BinLayout horizontal and vertical alignment properties. The supported alignment properties are: * center: align the child by centering it * start: align the child at the top or left border of the layout * end: align the child at the bottom or right border of the layout * fill: expand the child to fill the size of the layout * fixed: let the child position itself
2009-09-11 12:51:23 +00:00
}
}
bin-layout: Add get_child_meta_type() override Return the GType of ClutterBinLayer.
2009-11-05 12:23:22 +00:00
static GType
clutter_bin_layout_get_child_meta_type (ClutterLayoutManager *manager)
{
return CLUTTER_TYPE_BIN_LAYER;
}
[layout] Add LayoutMeta Instead of overloading ClutterChildMeta with both container and layout metadata and delegate to every LayoutManager implementation to keep a backpointer to the layout manager instance, we can simply subclass ChildMeta into LayoutMeta and presto! everything works out pretty well for everyone.
2009-09-15 16:37:11 +00:00
static ClutterLayoutMeta *
[layout] Add layers to BinLayout Each actor managed by a BinLayout policy should reside inside its own "layer", with horizontal and vertical alignment. The :x-align and :y-align properties of the BinLayout are the default alignment policies, which are copied to each new "layer" when it is created. The set_alignment() and get_alignment() methods of BinLayout can be changed to operate on a specific "layer". The whole machinery uses the new ChildMeta support inside the LayoutManager base abstract class.
2009-09-14 20:51:49 +00:00
clutter_bin_layout_create_child_meta (ClutterLayoutManager *manager,
ClutterContainer *container,
ClutterActor *actor)
{
ClutterBinLayoutPrivate *priv;
priv = CLUTTER_BIN_LAYOUT (manager)->priv;
[layout] Add LayoutMeta Instead of overloading ClutterChildMeta with both container and layout metadata and delegate to every LayoutManager implementation to keep a backpointer to the layout manager instance, we can simply subclass ChildMeta into LayoutMeta and presto! everything works out pretty well for everyone.
2009-09-15 16:37:11 +00:00
return g_object_new (CLUTTER_TYPE_BIN_LAYER,
[layout] Add layers to BinLayout Each actor managed by a BinLayout policy should reside inside its own "layer", with horizontal and vertical alignment. The :x-align and :y-align properties of the BinLayout are the default alignment policies, which are copied to each new "layer" when it is created. The set_alignment() and get_alignment() methods of BinLayout can be changed to operate on a specific "layer". The whole machinery uses the new ChildMeta support inside the LayoutManager base abstract class.
2009-09-14 20:51:49 +00:00
"container", container,
"actor", actor,
[layout] Add LayoutMeta Instead of overloading ClutterChildMeta with both container and layout metadata and delegate to every LayoutManager implementation to keep a backpointer to the layout manager instance, we can simply subclass ChildMeta into LayoutMeta and presto! everything works out pretty well for everyone.
2009-09-15 16:37:11 +00:00
"manager", manager,
[layout] Add layers to BinLayout Each actor managed by a BinLayout policy should reside inside its own "layer", with horizontal and vertical alignment. The :x-align and :y-align properties of the BinLayout are the default alignment policies, which are copied to each new "layer" when it is created. The set_alignment() and get_alignment() methods of BinLayout can be changed to operate on a specific "layer". The whole machinery uses the new ChildMeta support inside the LayoutManager base abstract class.
2009-09-14 20:51:49 +00:00
"x-align", priv->x_align,
"y_align", priv->y_align,
NULL);
}
[layout] Store and use the container inside BinLayout The BinLayout should store a pointer to the Container that it is using it as the layout manager. This allows us to fix the API and drop the additional Container arguments from set_alignment() and get_alignment(). This also allows us to add a ClutterBinLayout::add() method which adds an actor and sets the alignment policies without dealing with variadic arguments functions and GValue (de)marshalling.
2009-09-16 14:51:13 +00:00
static void
clutter_bin_layout_set_container (ClutterLayoutManager *manager,
ClutterContainer *container)
{
ClutterBinLayoutPrivate *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] Store and use the container inside BinLayout The BinLayout should store a pointer to the Container that it is using it as the layout manager. This allows us to fix the API and drop the additional Container arguments from set_alignment() and get_alignment(). This also allows us to add a ClutterBinLayout::add() method which adds an actor and sets the alignment policies without dealing with variadic arguments functions and GValue (de)marshalling.
2009-09-16 14:51:13 +00:00
priv = CLUTTER_BIN_LAYOUT (manager)->priv;
priv->container = container;
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_bin_layout_parent_class);
parent_class->set_container (manager, container);
[layout] Store and use the container inside BinLayout The BinLayout should store a pointer to the Container that it is using it as the layout manager. This allows us to fix the API and drop the additional Container arguments from set_alignment() and get_alignment(). This also allows us to add a ClutterBinLayout::add() method which adds an actor and sets the alignment policies without dealing with variadic arguments functions and GValue (de)marshalling.
2009-09-16 14:51:13 +00:00
}
[layout] Add BinLayout A BinLayout is a simple layout manager that allocates a single cell, providing alignment on both the horizontal and vertical axis. If the container associated to the BinLayout has more than one child, the preferred size returned by the layout manager will be as big as the maximum of the children preferred sizes; the allocation will be applied to all children - but it will still depend on each child preferred size and the BinLayout horizontal and vertical alignment properties. The supported alignment properties are: * center: align the child by centering it * start: align the child at the top or left border of the layout * end: align the child at the bottom or right border of the layout * fill: expand the child to fill the size of the layout * fixed: let the child position itself
2009-09-11 12:51:23 +00:00
static void
clutter_bin_layout_set_property (GObject *gobject,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
[layout, docs] Clean up BinLayout documentation Documentation and code style fixes for BinLayout.
2009-09-17 10:38:43 +00:00
ClutterBinLayout *layout = CLUTTER_BIN_LAYOUT (gobject);
[layout] Add BinLayout A BinLayout is a simple layout manager that allocates a single cell, providing alignment on both the horizontal and vertical axis. If the container associated to the BinLayout has more than one child, the preferred size returned by the layout manager will be as big as the maximum of the children preferred sizes; the allocation will be applied to all children - but it will still depend on each child preferred size and the BinLayout horizontal and vertical alignment properties. The supported alignment properties are: * center: align the child by centering it * start: align the child at the top or left border of the layout * end: align the child at the bottom or right border of the layout * fill: expand the child to fill the size of the layout * fixed: let the child position itself
2009-09-11 12:51:23 +00:00
switch (prop_id)
{
case PROP_X_ALIGN:
[layout, docs] Clean up BinLayout documentation Documentation and code style fixes for BinLayout.
2009-09-17 10:38:43 +00:00
set_x_align (layout, g_value_get_enum (value));
[layout] Add BinLayout A BinLayout is a simple layout manager that allocates a single cell, providing alignment on both the horizontal and vertical axis. If the container associated to the BinLayout has more than one child, the preferred size returned by the layout manager will be as big as the maximum of the children preferred sizes; the allocation will be applied to all children - but it will still depend on each child preferred size and the BinLayout horizontal and vertical alignment properties. The supported alignment properties are: * center: align the child by centering it * start: align the child at the top or left border of the layout * end: align the child at the bottom or right border of the layout * fill: expand the child to fill the size of the layout * fixed: let the child position itself
2009-09-11 12:51:23 +00:00
break;
case PROP_Y_ALIGN:
[layout, docs] Clean up BinLayout documentation Documentation and code style fixes for BinLayout.
2009-09-17 10:38:43 +00:00
set_y_align (layout, g_value_get_enum (value));
[layout] Add BinLayout A BinLayout is a simple layout manager that allocates a single cell, providing alignment on both the horizontal and vertical axis. If the container associated to the BinLayout has more than one child, the preferred size returned by the layout manager will be as big as the maximum of the children preferred sizes; the allocation will be applied to all children - but it will still depend on each child preferred size and the BinLayout horizontal and vertical alignment properties. The supported alignment properties are: * center: align the child by centering it * start: align the child at the top or left border of the layout * end: align the child at the bottom or right border of the layout * fill: expand the child to fill the size of the layout * fixed: let the child position itself
2009-09-11 12:51:23 +00:00
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
break;
}
}
static void
clutter_bin_layout_get_property (GObject *gobject,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
ClutterBinLayoutPrivate *priv;
priv = CLUTTER_BIN_LAYOUT (gobject)->priv;
switch (prop_id)
{
case PROP_X_ALIGN:
g_value_set_enum (value, priv->x_align);
break;
case PROP_Y_ALIGN:
g_value_set_enum (value, priv->y_align);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
break;
}
}
static void
clutter_bin_layout_class_init (ClutterBinLayoutClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
ClutterLayoutManagerClass *layout_class =
CLUTTER_LAYOUT_MANAGER_CLASS (klass);
g_type_class_add_private (klass, sizeof (ClutterBinLayoutPrivate));
[layout] Document BinLayout
2009-09-14 11:04:42 +00:00
/**
* ClutterBinLayout:x-align:
*
[layout, docs] Clean up BinLayout documentation Documentation and code style fixes for BinLayout.
2009-09-17 10:38:43 +00:00
* The default horizontal alignment policy for actors managed
* by the #ClutterBinLayout
[layout] Document BinLayout
2009-09-14 11:04:42 +00:00
*
* Since: 1.2
bin-layout: Deprecate BinLayout alignments We should use the ClutterActor's API for this.
2012-03-29 16:27:34 +00:00
*
* Deprecated: 1.12: Use the #ClutterActor:x-expand and the
* #ClutterActor:x-align properties on #ClutterActor instead.
[layout] Document BinLayout
2009-09-14 11:04:42 +00:00
*/
Move more classes to install_properties()
2010-10-15 14:24:27 +00:00
bin_props[PROP_X_ALIGN] =
g_param_spec_enum ("x-align",
P_("Horizontal Alignment"),
P_("Default horizontal alignment for the actors "
"inside the layout manager"),
CLUTTER_TYPE_BIN_ALIGNMENT,
CLUTTER_BIN_ALIGNMENT_CENTER,
CLUTTER_PARAM_READWRITE);
[layout] Add BinLayout A BinLayout is a simple layout manager that allocates a single cell, providing alignment on both the horizontal and vertical axis. If the container associated to the BinLayout has more than one child, the preferred size returned by the layout manager will be as big as the maximum of the children preferred sizes; the allocation will be applied to all children - but it will still depend on each child preferred size and the BinLayout horizontal and vertical alignment properties. The supported alignment properties are: * center: align the child by centering it * start: align the child at the top or left border of the layout * end: align the child at the bottom or right border of the layout * fill: expand the child to fill the size of the layout * fixed: let the child position itself
2009-09-11 12:51:23 +00:00
[layout] Document BinLayout
2009-09-14 11:04:42 +00:00
/**
* ClutterBinLayout:y-align:
*
[layout, docs] Clean up BinLayout documentation Documentation and code style fixes for BinLayout.
2009-09-17 10:38:43 +00:00
* The default vertical alignment policy for actors managed
* by the #ClutterBinLayout
[layout] Document BinLayout
2009-09-14 11:04:42 +00:00
*
* Since: 1.2
bin-layout: Deprecate BinLayout alignments We should use the ClutterActor's API for this.
2012-03-29 16:27:34 +00:00
*
* Deprecated: 1.12: Use the #ClutterActor:y-expand and the
* #ClutterActor:y-align properties on #ClutterActor instead.
[layout] Document BinLayout
2009-09-14 11:04:42 +00:00
*/
Move more classes to install_properties()
2010-10-15 14:24:27 +00:00
bin_props[PROP_Y_ALIGN] =
g_param_spec_enum ("y-align",
P_("Vertical Alignment"),
P_("Default vertical alignment for the actors "
"inside the layout manager"),
CLUTTER_TYPE_BIN_ALIGNMENT,
CLUTTER_BIN_ALIGNMENT_CENTER,
CLUTTER_PARAM_READWRITE);
gobject_class->set_property = clutter_bin_layout_set_property;
gobject_class->get_property = clutter_bin_layout_get_property;
Use ClutterActorIter inside layout managers Whenever it is possible, or convenient.
2012-01-30 10:55:30 +00:00
g_object_class_install_properties (gobject_class, PROP_LAST, bin_props);
layout_class->get_preferred_width = clutter_bin_layout_get_preferred_width;
layout_class->get_preferred_height = clutter_bin_layout_get_preferred_height;
layout_class->allocate = clutter_bin_layout_allocate;
layout_class->create_child_meta = clutter_bin_layout_create_child_meta;
layout_class->get_child_meta_type = clutter_bin_layout_get_child_meta_type;
layout_class->set_container = clutter_bin_layout_set_container;
[layout] Add BinLayout A BinLayout is a simple layout manager that allocates a single cell, providing alignment on both the horizontal and vertical axis. If the container associated to the BinLayout has more than one child, the preferred size returned by the layout manager will be as big as the maximum of the children preferred sizes; the allocation will be applied to all children - but it will still depend on each child preferred size and the BinLayout horizontal and vertical alignment properties. The supported alignment properties are: * center: align the child by centering it * start: align the child at the top or left border of the layout * end: align the child at the bottom or right border of the layout * fill: expand the child to fill the size of the layout * fixed: let the child position itself
2009-09-11 12:51:23 +00:00
}
static void
clutter_bin_layout_init (ClutterBinLayout *self)
{
self->priv = CLUTTER_BIN_LAYOUT_GET_PRIVATE (self);
self->priv->x_align = CLUTTER_BIN_ALIGNMENT_CENTER;
self->priv->y_align = CLUTTER_BIN_ALIGNMENT_CENTER;
}
[layout] Document BinLayout
2009-09-14 11:04:42 +00:00
/**
* clutter_bin_layout_new:
[layout] Add layers to BinLayout Each actor managed by a BinLayout policy should reside inside its own "layer", with horizontal and vertical alignment. The :x-align and :y-align properties of the BinLayout are the default alignment policies, which are copied to each new "layer" when it is created. The set_alignment() and get_alignment() methods of BinLayout can be changed to operate on a specific "layer". The whole machinery uses the new ChildMeta support inside the LayoutManager base abstract class.
2009-09-14 20:51:49 +00:00
* @x_align: the default alignment policy to be used on the
[layout] Document BinLayout
2009-09-14 11:04:42 +00:00
* horizontal axis
[layout] Add layers to BinLayout Each actor managed by a BinLayout policy should reside inside its own "layer", with horizontal and vertical alignment. The :x-align and :y-align properties of the BinLayout are the default alignment policies, which are copied to each new "layer" when it is created. The set_alignment() and get_alignment() methods of BinLayout can be changed to operate on a specific "layer". The whole machinery uses the new ChildMeta support inside the LayoutManager base abstract class.
2009-09-14 20:51:49 +00:00
* @y_align: the default alignment policy to be used on the
[layout] Document BinLayout
2009-09-14 11:04:42 +00:00
* vertical axis
*
* Creates a new #ClutterBinLayout layout manager
*
* Return value: the newly created layout manager
*
* Since: 1.2
*/
[layout] Add BinLayout A BinLayout is a simple layout manager that allocates a single cell, providing alignment on both the horizontal and vertical axis. If the container associated to the BinLayout has more than one child, the preferred size returned by the layout manager will be as big as the maximum of the children preferred sizes; the allocation will be applied to all children - but it will still depend on each child preferred size and the BinLayout horizontal and vertical alignment properties. The supported alignment properties are: * center: align the child by centering it * start: align the child at the top or left border of the layout * end: align the child at the bottom or right border of the layout * fill: expand the child to fill the size of the layout * fixed: let the child position itself
2009-09-11 12:51:23 +00:00
ClutterLayoutManager *
clutter_bin_layout_new (ClutterBinAlignment x_align,
ClutterBinAlignment y_align)
{
return g_object_new (CLUTTER_TYPE_BIN_LAYOUT,
"x-align", x_align,
"y-align", y_align,
NULL);
}
[layout] Document BinLayout
2009-09-14 11:04:42 +00:00
/**
* clutter_bin_layout_set_alignment:
* @self: a #ClutterBinLayout
[layout] Store and use the container inside BinLayout The BinLayout should store a pointer to the Container that it is using it as the layout manager. This allows us to fix the API and drop the additional Container arguments from set_alignment() and get_alignment(). This also allows us to add a ClutterBinLayout::add() method which adds an actor and sets the alignment policies without dealing with variadic arguments functions and GValue (de)marshalling.
2009-09-16 14:51:13 +00:00
* @child: (allow-none): a child of @container
[layout] Add layers to BinLayout Each actor managed by a BinLayout policy should reside inside its own "layer", with horizontal and vertical alignment. The :x-align and :y-align properties of the BinLayout are the default alignment policies, which are copied to each new "layer" when it is created. The set_alignment() and get_alignment() methods of BinLayout can be changed to operate on a specific "layer". The whole machinery uses the new ChildMeta support inside the LayoutManager base abstract class.
2009-09-14 20:51:49 +00:00
* @x_align: the horizontal alignment policy to be used for the @child
* inside @container
* @y_align: the vertical aligment policy to be used on the @child
* inside @container
[layout] Document BinLayout
2009-09-14 11:04:42 +00:00
*
[layout] Add layers to BinLayout Each actor managed by a BinLayout policy should reside inside its own "layer", with horizontal and vertical alignment. The :x-align and :y-align properties of the BinLayout are the default alignment policies, which are copied to each new "layer" when it is created. The set_alignment() and get_alignment() methods of BinLayout can be changed to operate on a specific "layer". The whole machinery uses the new ChildMeta support inside the LayoutManager base abstract class.
2009-09-14 20:51:49 +00:00
* Sets the horizontal and vertical alignment policies to be applied
[layout] Store and use the container inside BinLayout The BinLayout should store a pointer to the Container that it is using it as the layout manager. This allows us to fix the API and drop the additional Container arguments from set_alignment() and get_alignment(). This also allows us to add a ClutterBinLayout::add() method which adds an actor and sets the alignment policies without dealing with variadic arguments functions and GValue (de)marshalling.
2009-09-16 14:51:13 +00:00
* to a @child of @self
*
* If @child is %NULL then the @x_align and @y_align values will
* be set as the default alignment policies
[layout] Document BinLayout
2009-09-14 11:04:42 +00:00
*
* Since: 1.2
bin-layout: Deprecate BinLayout alignments We should use the ClutterActor's API for this.
2012-03-29 16:27:34 +00:00
*
* Deprecated: 1.12: Use the #ClutterActor:x-align and
* #ClutterActor:y-align properties of #ClutterActor instead.
[layout] Document BinLayout
2009-09-14 11:04:42 +00:00
*/
[layout] Add BinLayout A BinLayout is a simple layout manager that allocates a single cell, providing alignment on both the horizontal and vertical axis. If the container associated to the BinLayout has more than one child, the preferred size returned by the layout manager will be as big as the maximum of the children preferred sizes; the allocation will be applied to all children - but it will still depend on each child preferred size and the BinLayout horizontal and vertical alignment properties. The supported alignment properties are: * center: align the child by centering it * start: align the child at the top or left border of the layout * end: align the child at the bottom or right border of the layout * fill: expand the child to fill the size of the layout * fixed: let the child position itself
2009-09-11 12:51:23 +00:00
void
clutter_bin_layout_set_alignment (ClutterBinLayout *self,
[layout] Add layers to BinLayout Each actor managed by a BinLayout policy should reside inside its own "layer", with horizontal and vertical alignment. The :x-align and :y-align properties of the BinLayout are the default alignment policies, which are copied to each new "layer" when it is created. The set_alignment() and get_alignment() methods of BinLayout can be changed to operate on a specific "layer". The whole machinery uses the new ChildMeta support inside the LayoutManager base abstract class.
2009-09-14 20:51:49 +00:00
ClutterActor *child,
[layout] Add BinLayout A BinLayout is a simple layout manager that allocates a single cell, providing alignment on both the horizontal and vertical axis. If the container associated to the BinLayout has more than one child, the preferred size returned by the layout manager will be as big as the maximum of the children preferred sizes; the allocation will be applied to all children - but it will still depend on each child preferred size and the BinLayout horizontal and vertical alignment properties. The supported alignment properties are: * center: align the child by centering it * start: align the child at the top or left border of the layout * end: align the child at the bottom or right border of the layout * fill: expand the child to fill the size of the layout * fixed: let the child position itself
2009-09-11 12:51:23 +00:00
ClutterBinAlignment x_align,
ClutterBinAlignment y_align)
{
[layout] Store and use the container inside BinLayout The BinLayout should store a pointer to the Container that it is using it as the layout manager. This allows us to fix the API and drop the additional Container arguments from set_alignment() and get_alignment(). This also allows us to add a ClutterBinLayout::add() method which adds an actor and sets the alignment policies without dealing with variadic arguments functions and GValue (de)marshalling.
2009-09-16 14:51:13 +00:00
ClutterBinLayoutPrivate *priv;
[layout] Add layers to BinLayout Each actor managed by a BinLayout policy should reside inside its own "layer", with horizontal and vertical alignment. The :x-align and :y-align properties of the BinLayout are the default alignment policies, which are copied to each new "layer" when it is created. The set_alignment() and get_alignment() methods of BinLayout can be changed to operate on a specific "layer". The whole machinery uses the new ChildMeta support inside the LayoutManager base abstract class.
2009-09-14 20:51:49 +00:00
ClutterLayoutManager *manager;
[layout] Add LayoutMeta Instead of overloading ClutterChildMeta with both container and layout metadata and delegate to every LayoutManager implementation to keep a backpointer to the layout manager instance, we can simply subclass ChildMeta into LayoutMeta and presto! everything works out pretty well for everyone.
2009-09-15 16:37:11 +00:00
ClutterLayoutMeta *meta;
[layout] Add layers to BinLayout Each actor managed by a BinLayout policy should reside inside its own "layer", with horizontal and vertical alignment. The :x-align and :y-align properties of the BinLayout are the default alignment policies, which are copied to each new "layer" when it is created. The set_alignment() and get_alignment() methods of BinLayout can be changed to operate on a specific "layer". The whole machinery uses the new ChildMeta support inside the LayoutManager base abstract class.
2009-09-14 20:51:49 +00:00
[layout] Add BinLayout A BinLayout is a simple layout manager that allocates a single cell, providing alignment on both the horizontal and vertical axis. If the container associated to the BinLayout has more than one child, the preferred size returned by the layout manager will be as big as the maximum of the children preferred sizes; the allocation will be applied to all children - but it will still depend on each child preferred size and the BinLayout horizontal and vertical alignment properties. The supported alignment properties are: * center: align the child by centering it * start: align the child at the top or left border of the layout * end: align the child at the bottom or right border of the layout * fill: expand the child to fill the size of the layout * fixed: let the child position itself
2009-09-11 12:51:23 +00:00
g_return_if_fail (CLUTTER_IS_BIN_LAYOUT (self));
[layout, docs] Clean up BinLayout documentation Documentation and code style fixes for BinLayout.
2009-09-17 10:38:43 +00:00
g_return_if_fail (child == NULL || CLUTTER_IS_ACTOR (child));
[layout] Add BinLayout A BinLayout is a simple layout manager that allocates a single cell, providing alignment on both the horizontal and vertical axis. If the container associated to the BinLayout has more than one child, the preferred size returned by the layout manager will be as big as the maximum of the children preferred sizes; the allocation will be applied to all children - but it will still depend on each child preferred size and the BinLayout horizontal and vertical alignment properties. The supported alignment properties are: * center: align the child by centering it * start: align the child at the top or left border of the layout * end: align the child at the bottom or right border of the layout * fill: expand the child to fill the size of the layout * fixed: let the child position itself
2009-09-11 12:51:23 +00:00
[layout] Store and use the container inside BinLayout The BinLayout should store a pointer to the Container that it is using it as the layout manager. This allows us to fix the API and drop the additional Container arguments from set_alignment() and get_alignment(). This also allows us to add a ClutterBinLayout::add() method which adds an actor and sets the alignment policies without dealing with variadic arguments functions and GValue (de)marshalling.
2009-09-16 14:51:13 +00:00
priv = self->priv;
[layout, docs] Clean up BinLayout documentation Documentation and code style fixes for BinLayout.
2009-09-17 10:38:43 +00:00
if (priv->container == NULL)
[layout] Store and use the container inside BinLayout The BinLayout should store a pointer to the Container that it is using it as the layout manager. This allows us to fix the API and drop the additional Container arguments from set_alignment() and get_alignment(). This also allows us to add a ClutterBinLayout::add() method which adds an actor and sets the alignment policies without dealing with variadic arguments functions and GValue (de)marshalling.
2009-09-16 14:51:13 +00:00
{
[layout, docs] Clean up BinLayout documentation Documentation and code style fixes for BinLayout.
2009-09-17 10:38:43 +00:00
if (child == NULL)
{
set_x_align (self, x_align);
set_y_align (self, y_align);
}
else
g_warning ("The layout of type '%s' must be associated to "
"a ClutterContainer before setting the alignment "
"on its children",
G_OBJECT_TYPE_NAME (self));
[layout] Store and use the container inside BinLayout The BinLayout should store a pointer to the Container that it is using it as the layout manager. This allows us to fix the API and drop the additional Container arguments from set_alignment() and get_alignment(). This also allows us to add a ClutterBinLayout::add() method which adds an actor and sets the alignment policies without dealing with variadic arguments functions and GValue (de)marshalling.
2009-09-16 14:51:13 +00:00
return;
}
[layout] Add layers to BinLayout Each actor managed by a BinLayout policy should reside inside its own "layer", with horizontal and vertical alignment. The :x-align and :y-align properties of the BinLayout are the default alignment policies, which are copied to each new "layer" when it is created. The set_alignment() and get_alignment() methods of BinLayout can be changed to operate on a specific "layer". The whole machinery uses the new ChildMeta support inside the LayoutManager base abstract class.
2009-09-14 20:51:49 +00:00
manager = CLUTTER_LAYOUT_MANAGER (self);
[layout] Store and use the container inside BinLayout The BinLayout should store a pointer to the Container that it is using it as the layout manager. This allows us to fix the API and drop the additional Container arguments from set_alignment() and get_alignment(). This also allows us to add a ClutterBinLayout::add() method which adds an actor and sets the alignment policies without dealing with variadic arguments functions and GValue (de)marshalling.
2009-09-16 14:51:13 +00:00
meta = clutter_layout_manager_get_child_meta (manager,
priv->container,
child);
[layout, docs] Clean up BinLayout documentation Documentation and code style fixes for BinLayout.
2009-09-17 10:38:43 +00:00
g_assert (CLUTTER_IS_BIN_LAYER (meta));
[layout] Document BinLayout
2009-09-14 11:04:42 +00:00
[layout, docs] Clean up BinLayout documentation Documentation and code style fixes for BinLayout.
2009-09-17 10:38:43 +00:00
set_layer_x_align (CLUTTER_BIN_LAYER (meta), x_align);
set_layer_y_align (CLUTTER_BIN_LAYER (meta), y_align);
[layout] Add BinLayout A BinLayout is a simple layout manager that allocates a single cell, providing alignment on both the horizontal and vertical axis. If the container associated to the BinLayout has more than one child, the preferred size returned by the layout manager will be as big as the maximum of the children preferred sizes; the allocation will be applied to all children - but it will still depend on each child preferred size and the BinLayout horizontal and vertical alignment properties. The supported alignment properties are: * center: align the child by centering it * start: align the child at the top or left border of the layout * end: align the child at the bottom or right border of the layout * fill: expand the child to fill the size of the layout * fixed: let the child position itself
2009-09-11 12:51:23 +00:00
}
[layout] Document BinLayout
2009-09-14 11:04:42 +00:00
/**
* clutter_bin_layout_get_alignment:
* @self: a #ClutterBinLayout
[layout] Store and use the container inside BinLayout The BinLayout should store a pointer to the Container that it is using it as the layout manager. This allows us to fix the API and drop the additional Container arguments from set_alignment() and get_alignment(). This also allows us to add a ClutterBinLayout::add() method which adds an actor and sets the alignment policies without dealing with variadic arguments functions and GValue (de)marshalling.
2009-09-16 14:51:13 +00:00
* @child: (allow-none): a child of @container
[layout] Document BinLayout
2009-09-14 11:04:42 +00:00
* @x_align: (out) (allow-none): return location for the horizontal
* alignment policy
* @y_align: (out) (allow-none): return location for the vertical
* alignment policy
*
[layout] Store and use the container inside BinLayout The BinLayout should store a pointer to the Container that it is using it as the layout manager. This allows us to fix the API and drop the additional Container arguments from set_alignment() and get_alignment(). This also allows us to add a ClutterBinLayout::add() method which adds an actor and sets the alignment policies without dealing with variadic arguments functions and GValue (de)marshalling.
2009-09-16 14:51:13 +00:00
* Retrieves the horizontal and vertical alignment policies for
* a child of @self
*
* If @child is %NULL the default alignment policies will be returned
* instead
[layout] Document BinLayout
2009-09-14 11:04:42 +00:00
*
* Since: 1.2
bin-layout: Deprecate BinLayout alignments We should use the ClutterActor's API for this.
2012-03-29 16:27:34 +00:00
*
* Deprecated: 1.12: Use the #ClutterActor:x-align and the
* #ClutterActor:y-align properties of #ClutterActor instead.
[layout] Document BinLayout
2009-09-14 11:04:42 +00:00
*/
[layout] Add BinLayout A BinLayout is a simple layout manager that allocates a single cell, providing alignment on both the horizontal and vertical axis. If the container associated to the BinLayout has more than one child, the preferred size returned by the layout manager will be as big as the maximum of the children preferred sizes; the allocation will be applied to all children - but it will still depend on each child preferred size and the BinLayout horizontal and vertical alignment properties. The supported alignment properties are: * center: align the child by centering it * start: align the child at the top or left border of the layout * end: align the child at the bottom or right border of the layout * fill: expand the child to fill the size of the layout * fixed: let the child position itself
2009-09-11 12:51:23 +00:00
void
clutter_bin_layout_get_alignment (ClutterBinLayout *self,
[layout] Add layers to BinLayout Each actor managed by a BinLayout policy should reside inside its own "layer", with horizontal and vertical alignment. The :x-align and :y-align properties of the BinLayout are the default alignment policies, which are copied to each new "layer" when it is created. The set_alignment() and get_alignment() methods of BinLayout can be changed to operate on a specific "layer". The whole machinery uses the new ChildMeta support inside the LayoutManager base abstract class.
2009-09-14 20:51:49 +00:00
ClutterActor *child,
[layout] Add BinLayout A BinLayout is a simple layout manager that allocates a single cell, providing alignment on both the horizontal and vertical axis. If the container associated to the BinLayout has more than one child, the preferred size returned by the layout manager will be as big as the maximum of the children preferred sizes; the allocation will be applied to all children - but it will still depend on each child preferred size and the BinLayout horizontal and vertical alignment properties. The supported alignment properties are: * center: align the child by centering it * start: align the child at the top or left border of the layout * end: align the child at the bottom or right border of the layout * fill: expand the child to fill the size of the layout * fixed: let the child position itself
2009-09-11 12:51:23 +00:00
ClutterBinAlignment *x_align,
ClutterBinAlignment *y_align)
{
[layout] Store and use the container inside BinLayout The BinLayout should store a pointer to the Container that it is using it as the layout manager. This allows us to fix the API and drop the additional Container arguments from set_alignment() and get_alignment(). This also allows us to add a ClutterBinLayout::add() method which adds an actor and sets the alignment policies without dealing with variadic arguments functions and GValue (de)marshalling.
2009-09-16 14:51:13 +00:00
ClutterBinLayoutPrivate *priv;
[layout] Add layers to BinLayout Each actor managed by a BinLayout policy should reside inside its own "layer", with horizontal and vertical alignment. The :x-align and :y-align properties of the BinLayout are the default alignment policies, which are copied to each new "layer" when it is created. The set_alignment() and get_alignment() methods of BinLayout can be changed to operate on a specific "layer". The whole machinery uses the new ChildMeta support inside the LayoutManager base abstract class.
2009-09-14 20:51:49 +00:00
ClutterLayoutManager *manager;
[layout] Add LayoutMeta Instead of overloading ClutterChildMeta with both container and layout metadata and delegate to every LayoutManager implementation to keep a backpointer to the layout manager instance, we can simply subclass ChildMeta into LayoutMeta and presto! everything works out pretty well for everyone.
2009-09-15 16:37:11 +00:00
ClutterLayoutMeta *meta;
[layout] Add layers to BinLayout Each actor managed by a BinLayout policy should reside inside its own "layer", with horizontal and vertical alignment. The :x-align and :y-align properties of the BinLayout are the default alignment policies, which are copied to each new "layer" when it is created. The set_alignment() and get_alignment() methods of BinLayout can be changed to operate on a specific "layer". The whole machinery uses the new ChildMeta support inside the LayoutManager base abstract class.
2009-09-14 20:51:49 +00:00
ClutterBinLayer *layer;
[layout] Add BinLayout A BinLayout is a simple layout manager that allocates a single cell, providing alignment on both the horizontal and vertical axis. If the container associated to the BinLayout has more than one child, the preferred size returned by the layout manager will be as big as the maximum of the children preferred sizes; the allocation will be applied to all children - but it will still depend on each child preferred size and the BinLayout horizontal and vertical alignment properties. The supported alignment properties are: * center: align the child by centering it * start: align the child at the top or left border of the layout * end: align the child at the bottom or right border of the layout * fill: expand the child to fill the size of the layout * fixed: let the child position itself
2009-09-11 12:51:23 +00:00
g_return_if_fail (CLUTTER_IS_BIN_LAYOUT (self));
[layout] Store and use the container inside BinLayout The BinLayout should store a pointer to the Container that it is using it as the layout manager. This allows us to fix the API and drop the additional Container arguments from set_alignment() and get_alignment(). This also allows us to add a ClutterBinLayout::add() method which adds an actor and sets the alignment policies without dealing with variadic arguments functions and GValue (de)marshalling.
2009-09-16 14:51:13 +00:00
priv = self->priv;
[layout, docs] Clean up BinLayout documentation Documentation and code style fixes for BinLayout.
2009-09-17 10:38:43 +00:00
if (priv->container == NULL)
[layout] Store and use the container inside BinLayout The BinLayout should store a pointer to the Container that it is using it as the layout manager. This allows us to fix the API and drop the additional Container arguments from set_alignment() and get_alignment(). This also allows us to add a ClutterBinLayout::add() method which adds an actor and sets the alignment policies without dealing with variadic arguments functions and GValue (de)marshalling.
2009-09-16 14:51:13 +00:00
{
[layout, docs] Clean up BinLayout documentation Documentation and code style fixes for BinLayout.
2009-09-17 10:38:43 +00:00
if (child == NULL)
{
if (x_align)
*x_align = priv->x_align;
[layout] Store and use the container inside BinLayout The BinLayout should store a pointer to the Container that it is using it as the layout manager. This allows us to fix the API and drop the additional Container arguments from set_alignment() and get_alignment(). This also allows us to add a ClutterBinLayout::add() method which adds an actor and sets the alignment policies without dealing with variadic arguments functions and GValue (de)marshalling.
2009-09-16 14:51:13 +00:00
[layout, docs] Clean up BinLayout documentation Documentation and code style fixes for BinLayout.
2009-09-17 10:38:43 +00:00
if (y_align)
*y_align = priv->y_align;
}
else
g_warning ("The layout of type '%s' must be associated to "
"a ClutterContainer before getting the alignment "
"of its children",
G_OBJECT_TYPE_NAME (self));
[layout] Store and use the container inside BinLayout The BinLayout should store a pointer to the Container that it is using it as the layout manager. This allows us to fix the API and drop the additional Container arguments from set_alignment() and get_alignment(). This also allows us to add a ClutterBinLayout::add() method which adds an actor and sets the alignment policies without dealing with variadic arguments functions and GValue (de)marshalling.
2009-09-16 14:51:13 +00:00
return;
}
[layout] Add layers to BinLayout Each actor managed by a BinLayout policy should reside inside its own "layer", with horizontal and vertical alignment. The :x-align and :y-align properties of the BinLayout are the default alignment policies, which are copied to each new "layer" when it is created. The set_alignment() and get_alignment() methods of BinLayout can be changed to operate on a specific "layer". The whole machinery uses the new ChildMeta support inside the LayoutManager base abstract class.
2009-09-14 20:51:49 +00:00
manager = CLUTTER_LAYOUT_MANAGER (self);
[layout] Store and use the container inside BinLayout The BinLayout should store a pointer to the Container that it is using it as the layout manager. This allows us to fix the API and drop the additional Container arguments from set_alignment() and get_alignment(). This also allows us to add a ClutterBinLayout::add() method which adds an actor and sets the alignment policies without dealing with variadic arguments functions and GValue (de)marshalling.
2009-09-16 14:51:13 +00:00
meta = clutter_layout_manager_get_child_meta (manager,
priv->container,
child);
[layout, docs] Clean up BinLayout documentation Documentation and code style fixes for BinLayout.
2009-09-17 10:38:43 +00:00
g_assert (CLUTTER_IS_BIN_LAYER (meta));
[layout] Add layers to BinLayout Each actor managed by a BinLayout policy should reside inside its own "layer", with horizontal and vertical alignment. The :x-align and :y-align properties of the BinLayout are the default alignment policies, which are copied to each new "layer" when it is created. The set_alignment() and get_alignment() methods of BinLayout can be changed to operate on a specific "layer". The whole machinery uses the new ChildMeta support inside the LayoutManager base abstract class.
2009-09-14 20:51:49 +00:00
layer = CLUTTER_BIN_LAYER (meta);
[layout] Add BinLayout A BinLayout is a simple layout manager that allocates a single cell, providing alignment on both the horizontal and vertical axis. If the container associated to the BinLayout has more than one child, the preferred size returned by the layout manager will be as big as the maximum of the children preferred sizes; the allocation will be applied to all children - but it will still depend on each child preferred size and the BinLayout horizontal and vertical alignment properties. The supported alignment properties are: * center: align the child by centering it * start: align the child at the top or left border of the layout * end: align the child at the bottom or right border of the layout * fill: expand the child to fill the size of the layout * fixed: let the child position itself
2009-09-11 12:51:23 +00:00
if (x_align)
[layout] Add layers to BinLayout Each actor managed by a BinLayout policy should reside inside its own "layer", with horizontal and vertical alignment. The :x-align and :y-align properties of the BinLayout are the default alignment policies, which are copied to each new "layer" when it is created. The set_alignment() and get_alignment() methods of BinLayout can be changed to operate on a specific "layer". The whole machinery uses the new ChildMeta support inside the LayoutManager base abstract class.
2009-09-14 20:51:49 +00:00
*x_align = layer->x_align;
[layout] Add BinLayout A BinLayout is a simple layout manager that allocates a single cell, providing alignment on both the horizontal and vertical axis. If the container associated to the BinLayout has more than one child, the preferred size returned by the layout manager will be as big as the maximum of the children preferred sizes; the allocation will be applied to all children - but it will still depend on each child preferred size and the BinLayout horizontal and vertical alignment properties. The supported alignment properties are: * center: align the child by centering it * start: align the child at the top or left border of the layout * end: align the child at the bottom or right border of the layout * fill: expand the child to fill the size of the layout * fixed: let the child position itself
2009-09-11 12:51:23 +00:00
if (y_align)
[layout] Add layers to BinLayout Each actor managed by a BinLayout policy should reside inside its own "layer", with horizontal and vertical alignment. The :x-align and :y-align properties of the BinLayout are the default alignment policies, which are copied to each new "layer" when it is created. The set_alignment() and get_alignment() methods of BinLayout can be changed to operate on a specific "layer". The whole machinery uses the new ChildMeta support inside the LayoutManager base abstract class.
2009-09-14 20:51:49 +00:00
*y_align = layer->y_align;
[layout] Add BinLayout A BinLayout is a simple layout manager that allocates a single cell, providing alignment on both the horizontal and vertical axis. If the container associated to the BinLayout has more than one child, the preferred size returned by the layout manager will be as big as the maximum of the children preferred sizes; the allocation will be applied to all children - but it will still depend on each child preferred size and the BinLayout horizontal and vertical alignment properties. The supported alignment properties are: * center: align the child by centering it * start: align the child at the top or left border of the layout * end: align the child at the bottom or right border of the layout * fill: expand the child to fill the size of the layout * fixed: let the child position itself
2009-09-11 12:51:23 +00:00
}
[layout] Store and use the container inside BinLayout The BinLayout should store a pointer to the Container that it is using it as the layout manager. This allows us to fix the API and drop the additional Container arguments from set_alignment() and get_alignment(). This also allows us to add a ClutterBinLayout::add() method which adds an actor and sets the alignment policies without dealing with variadic arguments functions and GValue (de)marshalling.
2009-09-16 14:51:13 +00:00
/**
* clutter_bin_layout_add:
* @self: a #ClutterBinLayout
* @child: a #ClutterActor
* @x_align: horizontal alignment policy for @child
* @y_align: vertical alignment policy for @child
*
* Adds a #ClutterActor to the container using @self and
* sets the alignment policies for it
*
* This function is equivalent to clutter_container_add_actor()
[layout, docs] Clean up BinLayout documentation Documentation and code style fixes for BinLayout.
2009-09-17 10:38:43 +00:00
* and clutter_layout_manager_child_set_property() but it does not
* require a pointer to the #ClutterContainer associated to the
* #ClutterBinLayout
[layout] Store and use the container inside BinLayout The BinLayout should store a pointer to the Container that it is using it as the layout manager. This allows us to fix the API and drop the additional Container arguments from set_alignment() and get_alignment(). This also allows us to add a ClutterBinLayout::add() method which adds an actor and sets the alignment policies without dealing with variadic arguments functions and GValue (de)marshalling.
2009-09-16 14:51:13 +00:00
*
* Since: 1.2
bin-layout: Deprecate BinLayout alignments We should use the ClutterActor's API for this.
2012-03-29 16:27:34 +00:00
*
* Deprecated: 1.12: Use clutter_actor_add_child() instead.
[layout] Store and use the container inside BinLayout The BinLayout should store a pointer to the Container that it is using it as the layout manager. This allows us to fix the API and drop the additional Container arguments from set_alignment() and get_alignment(). This also allows us to add a ClutterBinLayout::add() method which adds an actor and sets the alignment policies without dealing with variadic arguments functions and GValue (de)marshalling.
2009-09-16 14:51:13 +00:00
*/
void
clutter_bin_layout_add (ClutterBinLayout *self,
ClutterActor *child,
ClutterBinAlignment x_align,
ClutterBinAlignment y_align)
{
ClutterBinLayoutPrivate *priv;
[layout, docs] Clean up BinLayout documentation Documentation and code style fixes for BinLayout.
2009-09-17 10:38:43 +00:00
ClutterLayoutManager *manager;
ClutterLayoutMeta *meta;
[layout] Store and use the container inside BinLayout The BinLayout should store a pointer to the Container that it is using it as the layout manager. This allows us to fix the API and drop the additional Container arguments from set_alignment() and get_alignment(). This also allows us to add a ClutterBinLayout::add() method which adds an actor and sets the alignment policies without dealing with variadic arguments functions and GValue (de)marshalling.
2009-09-16 14:51:13 +00:00
g_return_if_fail (CLUTTER_IS_BIN_LAYOUT (self));
g_return_if_fail (CLUTTER_IS_ACTOR (child));
priv = self->priv;
if (priv->container == NULL)
{
g_warning ("The layout of type '%s' must be associated to "
"a ClutterContainer before adding children",
G_OBJECT_TYPE_NAME (self));
return;
}
clutter_container_add_actor (priv->container, child);
manager = CLUTTER_LAYOUT_MANAGER (self);
meta = clutter_layout_manager_get_child_meta (manager,
priv->container,
child);
g_assert (CLUTTER_IS_BIN_LAYER (meta));
[layout, docs] Clean up BinLayout documentation Documentation and code style fixes for BinLayout.
2009-09-17 10:38:43 +00:00
set_layer_x_align (CLUTTER_BIN_LAYER (meta), x_align);
set_layer_y_align (CLUTTER_BIN_LAYER (meta), y_align);
[layout] Store and use the container inside BinLayout The BinLayout should store a pointer to the Container that it is using it as the layout manager. This allows us to fix the API and drop the additional Container arguments from set_alignment() and get_alignment(). This also allows us to add a ClutterBinLayout::add() method which adds an actor and sets the alignment policies without dealing with variadic arguments functions and GValue (de)marshalling.
2009-09-16 14:51:13 +00:00
}
Reference in New Issue Copy Permalink