isa/mutter
1
0
Fork 0
mirror of https://github.com/brl/mutter.git synced 2024-11-22 16:10:41 -05:00
Code Issues Packages Projects Releases Wiki Activity
ed0051d0b4
mutter/clutter/clutter-bin-layout.c

887 lines
25 KiB
C
Raw Normal View History

[layout] Document BinLayout
2009-09-14 07:04:42 -04: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:
*
docs: Move to markdown We're removing docbook tags in favour of the markdown syntax.
2014-03-17 19:07:58 -04:00
* - the preferred size is the maximum preferred size
[layout, docs] Clean up BinLayout documentation Documentation and code style fixes for BinLayout.
2009-09-17 06:38:43 -04:00
* between all the children of the container using the
docs: Move to markdown We're removing docbook tags in favour of the markdown syntax.
2014-03-17 19:07:58 -04:00
* layout;
* - each child is allocated in "layers", on on top
* of the other;
* - for each layer there are horizontal and vertical
* alignment policies.
[layout, docs] Clean up BinLayout documentation Documentation and code style fixes for BinLayout.
2009-09-17 06:38:43 -04:00
*
docs: Move to markdown We're removing docbook tags in favour of the markdown syntax.
2014-03-17 19:07:58 -04:00
* The [bin-layout example](https://git.gnome.org/browse/clutter/tree/examples/bin-layout.c?h=clutter-1.18)
* shows how to pack actors inside a #ClutterBinLayout.
[layout] Document BinLayout
2009-09-14 07:04:42 -04: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 08:51:23 -04: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 09:12:37 -04: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 13:48:02 -05: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 12:27:34 -04: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 13:48:02 -05: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 11:34:36 -04: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 08:51:23 -04: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 16:51:49 -04: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 08:51:23 -04: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 12:37:11 -04: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 08:51:23 -04: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 16:51:49 -04: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))
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 12:37:11 -04: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 16:51:49 -04: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 08:51:23 -04: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 10:51:13 -04: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 08:51:23 -04: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 16:51:49 -04: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 12:37:11 -04: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 16:51:49 -04:00
ClutterBinAlignment x_align;
ClutterBinAlignment y_align;
};
enum
{
PROP_LAYER_0,
PROP_LAYER_X_ALIGN,
Move more classes to install_properties()
2010-10-15 10:24:27 -04: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 16:51:49 -04: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 08:51:23 -04: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 05:20:32 -04: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 08:51:23 -04:00
};
Move more classes to install_properties()
2010-10-15 10:24:27 -04: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 05:20:32 -04:00
Fix missing/redundant declarations
2012-03-07 07:34:06 -05: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 16:51:49 -04:00
G_DEFINE_TYPE (ClutterBinLayer,
clutter_bin_layer,
Use the new macros for adding private data
2013-07-03 09:14:01 -04: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 16:51:49 -04:00
Use the new macros for adding private data
2013-07-03 09:14:01 -04:00
G_DEFINE_TYPE_WITH_PRIVATE (ClutterBinLayout,
clutter_bin_layout,
CLUTTER_TYPE_LAYOUT_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 08:51:23 -04: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 16:51:49 -04: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 12:37:11 -04: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 16:51:49 -04: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 12:37:11 -04: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 16:51:49 -04: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 06:35:46 -05: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 16:51:49 -04: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 12:37:11 -04: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 16:51:49 -04: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 12:37:11 -04: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 16:51:49 -04: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 06:35:46 -05: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 16:51:49 -04: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 10:24:27 -04: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 06:35:46 -05: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 16:51:49 -04: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 08:51:23 -04: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 07:03:38 -04: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 08:51:23 -04: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 07:03:38 -04: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 06:35:46 -05: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 08:51:23 -04: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 07:03:38 -04: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 08:51:23 -04: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 07:03:38 -04: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 06:35:46 -05: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 08:51:23 -04: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 05:29:01 -05:00
ClutterActor *actor = CLUTTER_ACTOR (container);
Use ClutterActorIter inside layout managers Whenever it is possible, or convenient.
2012-01-30 05:55:30 -05: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 05:29:01 -05: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 08:51:23 -04: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 05:55:30 -05: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 08:51:23 -04:00
{
gfloat minimum, natural;
Stop using macros for accessing actor state Use the newly added functions instead.
2015-04-23 12:39:30 -04:00
if (!clutter_actor_is_visible (child))
Don't allocate size for invisible BinLayout children
2012-06-05 04:55:17 -04:00
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 08:51:23 -04: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 05:29:01 -05:00
ClutterActor *actor = CLUTTER_ACTOR (container);
Use ClutterActorIter inside layout managers Whenever it is possible, or convenient.
2012-01-30 05:55:30 -05: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 05:29:01 -05: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 08:51:23 -04: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 05:55:30 -05: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 08:51:23 -04:00
{
gfloat minimum, natural;
Stop using macros for accessing actor state Use the newly added functions instead.
2015-04-23 12:39:30 -04:00
if (!clutter_actor_is_visible (child))
Don't allocate size for invisible BinLayout children
2012-06-05 04:55:17 -04:00
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 08:51:23 -04: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
bin-layout: Fix text direction checks When using the new ActorAlign flags we must get the real alignment for the horizontal axis, as clutter_actor_allocate() will compute the effective alignment by itself; if we use the effective alignment then ClutterActor.allocate() will swap it, and undo our work. When using the old BinAlignment flags we should reverse the alignment depending on whether the text direction of the child is RTL or LTR. See bug: https://bugzilla.gnome.org/show_bug.cgi?id=684214
2012-09-19 06:40:33 -04:00
get_bin_alignment_factor (ClutterBinAlignment alignment,
ClutterTextDirection text_dir)
[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 08:51:23 -04:00
{
switch (alignment)
{
case CLUTTER_BIN_ALIGNMENT_CENTER:
return 0.5;
case CLUTTER_BIN_ALIGNMENT_START:
bin-layout: Fix text direction checks When using the new ActorAlign flags we must get the real alignment for the horizontal axis, as clutter_actor_allocate() will compute the effective alignment by itself; if we use the effective alignment then ClutterActor.allocate() will swap it, and undo our work. When using the old BinAlignment flags we should reverse the alignment depending on whether the text direction of the child is RTL or LTR. See bug: https://bugzilla.gnome.org/show_bug.cgi?id=684214
2012-09-19 06:40:33 -04:00
return text_dir == CLUTTER_TEXT_DIRECTION_LTR ? 0.0 : 1.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 08:51:23 -04:00
case CLUTTER_BIN_ALIGNMENT_END:
bin-layout: Fix text direction checks When using the new ActorAlign flags we must get the real alignment for the horizontal axis, as clutter_actor_allocate() will compute the effective alignment by itself; if we use the effective alignment then ClutterActor.allocate() will swap it, and undo our work. When using the old BinAlignment flags we should reverse the alignment depending on whether the text direction of the child is RTL or LTR. See bug: https://bugzilla.gnome.org/show_bug.cgi?id=684214
2012-09-19 06:40:33 -04:00
return text_dir == CLUTTER_TEXT_DIRECTION_LTR ? 1.0 : 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 08:51:23 -04:00
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 11:34:36 -04: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 08:51:23 -04: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 13:38:17 -04: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 08:51:23 -04: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 05:29:01 -05:00
ClutterActor *actor, *child;
Use ClutterActorIter inside layout managers Whenever it is possible, or convenient.
2012-01-30 05:55:30 -05: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 08:51:23 -04: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 13:38:17 -04: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 08:51:23 -04: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 05:29:01 -05:00
actor = CLUTTER_ACTOR (container);
Use ClutterActorIter inside layout managers Whenever it is possible, or convenient.
2012-01-30 05:55:30 -05: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 08:51:23 -04: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 12:37:11 -04: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 16:51:49 -04: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 08:51:23 -04:00
ClutterActorBox child_alloc = { 0, };
bin-layout: Migrate to allocate_align_fill() Now that we have the code in ClutterActor itself.
2010-08-10 12:43:26 -04: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 12:11:10 -04: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 08:51:23 -04:00
Stop using macros for accessing actor state Use the newly added functions instead.
2015-04-23 12:39:30 -04:00
if (!clutter_actor_is_visible (child))
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 05:29:43 -04:00
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 16:51:49 -04: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 12:11:10 -04: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 10:44:08 -04: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 12:11:10 -04: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 10:44:08 -04: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 08:51:23 -04: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 13:38:17 -04: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 08:51:23 -04: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 12:11:10 -04: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 10:44:08 -04: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 12:11:10 -04: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 10:44:08 -04: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 08:51:23 -04: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 13:38:17 -04: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 12:43:26 -04:00
bin-layout: Fix offsets Just as BoxLayout, BinLayout uses an odd interpretation of the box passed into allocate(): to define a child area of (w x h) starting at (x, y), callers need to pass a box of (x, 2 * x + w, y, 2 * y + h). This behavior is just confusing, change it to use the full box for child allocations. https://bugzilla.gnome.org/show_bug.cgi?id=703809
2013-07-05 19:38:28 -04:00
child_alloc.x2 = allocation_x + available_w;
child_alloc.y2 = allocation_y + 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 08:51:23 -04:00
actor: Coalesce needs_[xy]_expand() into one method Use the orientation enumeration instead of a per-axis method.
2012-04-20 07:45:54 -04: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 11:34:36 -04:00
{
ClutterActorAlign align;
bin-layout: Fix text direction checks When using the new ActorAlign flags we must get the real alignment for the horizontal axis, as clutter_actor_allocate() will compute the effective alignment by itself; if we use the effective alignment then ClutterActor.allocate() will swap it, and undo our work. When using the old BinAlignment flags we should reverse the alignment depending on whether the text direction of the child is RTL or LTR. See bug: https://bugzilla.gnome.org/show_bug.cgi?id=684214
2012-09-19 06:40:33 -04:00
align = clutter_actor_get_x_align (child);
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 11:34:36 -04:00
x_fill = align == CLUTTER_ACTOR_ALIGN_FILL;
x_align = get_actor_align_factor (align);
}
else
{
bin-layout: Fix text direction checks When using the new ActorAlign flags we must get the real alignment for the horizontal axis, as clutter_actor_allocate() will compute the effective alignment by itself; if we use the effective alignment then ClutterActor.allocate() will swap it, and undo our work. When using the old BinAlignment flags we should reverse the alignment depending on whether the text direction of the child is RTL or LTR. See bug: https://bugzilla.gnome.org/show_bug.cgi?id=684214
2012-09-19 06:40:33 -04:00
ClutterTextDirection text_dir;
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 11:34:36 -04:00
x_fill = (layer->x_align == CLUTTER_BIN_ALIGNMENT_FILL);
bin-layout: Ensure that fixed position get a 0.0 alignment If the actor has a fixed position set, but it's not using the BinLayout alignment enumeration to set its alignment, then we force the alignment factor to 0.0; this is consistent with what happens with an explicit alignment of CLUTTER_BIN_ALIGNMENT_FIXED. https://bugzilla.gnome.org/show_bug.cgi?id=682265
2012-08-20 09:47:53 -04:00
bin-layout: Fix text direction checks When using the new ActorAlign flags we must get the real alignment for the horizontal axis, as clutter_actor_allocate() will compute the effective alignment by itself; if we use the effective alignment then ClutterActor.allocate() will swap it, and undo our work. When using the old BinAlignment flags we should reverse the alignment depending on whether the text direction of the child is RTL or LTR. See bug: https://bugzilla.gnome.org/show_bug.cgi?id=684214
2012-09-19 06:40:33 -04:00
text_dir = clutter_actor_get_text_direction (child);
bin-layout: Ensure that fixed position get a 0.0 alignment If the actor has a fixed position set, but it's not using the BinLayout alignment enumeration to set its alignment, then we force the alignment factor to 0.0; this is consistent with what happens with an explicit alignment of CLUTTER_BIN_ALIGNMENT_FIXED. https://bugzilla.gnome.org/show_bug.cgi?id=682265
2012-08-20 09:47:53 -04:00
if (!is_fixed_position_set)
bin-layout: Fix text direction checks When using the new ActorAlign flags we must get the real alignment for the horizontal axis, as clutter_actor_allocate() will compute the effective alignment by itself; if we use the effective alignment then ClutterActor.allocate() will swap it, and undo our work. When using the old BinAlignment flags we should reverse the alignment depending on whether the text direction of the child is RTL or LTR. See bug: https://bugzilla.gnome.org/show_bug.cgi?id=684214
2012-09-19 06:40:33 -04:00
x_align = get_bin_alignment_factor (layer->x_align, text_dir);
bin-layout: Ensure that fixed position get a 0.0 alignment If the actor has a fixed position set, but it's not using the BinLayout alignment enumeration to set its alignment, then we force the alignment factor to 0.0; this is consistent with what happens with an explicit alignment of CLUTTER_BIN_ALIGNMENT_FIXED. https://bugzilla.gnome.org/show_bug.cgi?id=682265
2012-08-20 09:47:53 -04:00
else
x_align = 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 11:34:36 -04:00
}
actor: Coalesce needs_[xy]_expand() into one method Use the orientation enumeration instead of a per-axis method.
2012-04-20 07:45:54 -04: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 11:34:36 -04: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);
bin-layout: Ensure that fixed position get a 0.0 alignment If the actor has a fixed position set, but it's not using the BinLayout alignment enumeration to set its alignment, then we force the alignment factor to 0.0; this is consistent with what happens with an explicit alignment of CLUTTER_BIN_ALIGNMENT_FIXED. https://bugzilla.gnome.org/show_bug.cgi?id=682265
2012-08-20 09:47:53 -04:00
if (!is_fixed_position_set)
bin-layout: Fix text direction checks When using the new ActorAlign flags we must get the real alignment for the horizontal axis, as clutter_actor_allocate() will compute the effective alignment by itself; if we use the effective alignment then ClutterActor.allocate() will swap it, and undo our work. When using the old BinAlignment flags we should reverse the alignment depending on whether the text direction of the child is RTL or LTR. See bug: https://bugzilla.gnome.org/show_bug.cgi?id=684214
2012-09-19 06:40:33 -04:00
y_align = get_bin_alignment_factor (layer->y_align,
CLUTTER_TEXT_DIRECTION_LTR);
bin-layout: Ensure that fixed position get a 0.0 alignment If the actor has a fixed position set, but it's not using the BinLayout alignment enumeration to set its alignment, then we force the alignment factor to 0.0; this is consistent with what happens with an explicit alignment of CLUTTER_BIN_ALIGNMENT_FIXED. https://bugzilla.gnome.org/show_bug.cgi?id=682265
2012-08-20 09:47:53 -04:00
else
y_align = 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 11:34:36 -04: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 08:51:23 -04:00
bin-layout: Migrate to allocate_align_fill() Now that we have the code in ClutterActor itself.
2010-08-10 12:43:26 -04: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 08:51:23 -04:00
}
}
bin-layout: Add get_child_meta_type() override Return the GType of ClutterBinLayer.
2009-11-05 07:23:22 -05: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 12:37:11 -04: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 16:51:49 -04: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 12:37:11 -04: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 16:51:49 -04: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 12:37:11 -04: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 16:51:49 -04: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 10:51:13 -04: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 16:34:36 -04: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 10:51:13 -04: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 16:34:36 -04: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 10:51:13 -04: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 08:51:23 -04: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 06:38:43 -04: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 08:51:23 -04:00
switch (prop_id)
{
case PROP_X_ALIGN:
[layout, docs] Clean up BinLayout documentation Documentation and code style fixes for BinLayout.
2009-09-17 06:38:43 -04: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 08:51:23 -04:00
break;
case PROP_Y_ALIGN:
[layout, docs] Clean up BinLayout documentation Documentation and code style fixes for BinLayout.
2009-09-17 06:38:43 -04: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 08:51:23 -04: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);
[layout] Document BinLayout
2009-09-14 07:04:42 -04:00
/**
* ClutterBinLayout:x-align:
*
[layout, docs] Clean up BinLayout documentation Documentation and code style fixes for BinLayout.
2009-09-17 06:38:43 -04:00
* The default horizontal alignment policy for actors managed
* by the #ClutterBinLayout
[layout] Document BinLayout
2009-09-14 07:04:42 -04:00
*
* Since: 1.2
bin-layout: Deprecate BinLayout alignments We should use the ClutterActor's API for this.
2012-03-29 12:27:34 -04:00
*
* Deprecated: 1.12: Use the #ClutterActor:x-expand and the
* #ClutterActor:x-align properties on #ClutterActor instead.
[layout] Document BinLayout
2009-09-14 07:04:42 -04:00
*/
Move more classes to install_properties()
2010-10-15 10:24:27 -04: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 08:51:23 -04:00
[layout] Document BinLayout
2009-09-14 07:04:42 -04:00
/**
* ClutterBinLayout:y-align:
*
[layout, docs] Clean up BinLayout documentation Documentation and code style fixes for BinLayout.
2009-09-17 06:38:43 -04:00
* The default vertical alignment policy for actors managed
* by the #ClutterBinLayout
[layout] Document BinLayout
2009-09-14 07:04:42 -04:00
*
* Since: 1.2
bin-layout: Deprecate BinLayout alignments We should use the ClutterActor's API for this.
2012-03-29 12:27:34 -04:00
*
* Deprecated: 1.12: Use the #ClutterActor:y-expand and the
* #ClutterActor:y-align properties on #ClutterActor instead.
[layout] Document BinLayout
2009-09-14 07:04:42 -04:00
*/
Move more classes to install_properties()
2010-10-15 10:24:27 -04: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 05:55:30 -05: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 08:51:23 -04:00
}
static void
clutter_bin_layout_init (ClutterBinLayout *self)
{
Use the new macros for adding private data
2013-07-03 09:14:01 -04:00
self->priv = clutter_bin_layout_get_instance_private (self);
[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 08:51:23 -04:00
self->priv->x_align = CLUTTER_BIN_ALIGNMENT_CENTER;
self->priv->y_align = CLUTTER_BIN_ALIGNMENT_CENTER;
}
[layout] Document BinLayout
2009-09-14 07:04:42 -04: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 16:51:49 -04:00
* @x_align: the default alignment policy to be used on the
[layout] Document BinLayout
2009-09-14 07:04:42 -04: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 16:51:49 -04:00
* @y_align: the default alignment policy to be used on the
[layout] Document BinLayout
2009-09-14 07:04:42 -04: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 08:51:23 -04: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 07:04:42 -04: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 10:51:13 -04: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 16:51:49 -04: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 07:04:42 -04: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 16:51:49 -04: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 10:51:13 -04: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 07:04:42 -04:00
*
* Since: 1.2
bin-layout: Deprecate BinLayout alignments We should use the ClutterActor's API for this.
2012-03-29 12:27:34 -04:00
*
* Deprecated: 1.12: Use the #ClutterActor:x-align and
* #ClutterActor:y-align properties of #ClutterActor instead.
[layout] Document BinLayout
2009-09-14 07:04:42 -04: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 08:51:23 -04: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 16:51:49 -04: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 08:51:23 -04: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 10:51:13 -04: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 16:51:49 -04: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 12:37:11 -04: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 16:51:49 -04: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 08:51:23 -04: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 06:38:43 -04: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 08:51:23 -04: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 10:51:13 -04:00
priv = self->priv;
[layout, docs] Clean up BinLayout documentation Documentation and code style fixes for BinLayout.
2009-09-17 06:38:43 -04: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 10:51:13 -04:00
{
[layout, docs] Clean up BinLayout documentation Documentation and code style fixes for BinLayout.
2009-09-17 06:38:43 -04: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 10:51:13 -04: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 16:51:49 -04: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 10:51:13 -04: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 06:38:43 -04:00
g_assert (CLUTTER_IS_BIN_LAYER (meta));
[layout] Document BinLayout
2009-09-14 07:04:42 -04:00
[layout, docs] Clean up BinLayout documentation Documentation and code style fixes for BinLayout.
2009-09-17 06:38:43 -04: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 08:51:23 -04:00
}
[layout] Document BinLayout
2009-09-14 07:04:42 -04: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 10:51:13 -04:00
* @child: (allow-none): a child of @container
[layout] Document BinLayout
2009-09-14 07:04:42 -04: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 10:51:13 -04: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 07:04:42 -04:00
*
* Since: 1.2
bin-layout: Deprecate BinLayout alignments We should use the ClutterActor's API for this.
2012-03-29 12:27:34 -04:00
*
* Deprecated: 1.12: Use the #ClutterActor:x-align and the
* #ClutterActor:y-align properties of #ClutterActor instead.
[layout] Document BinLayout
2009-09-14 07:04:42 -04: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 08:51:23 -04: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 16:51:49 -04: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 08:51:23 -04: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 10:51:13 -04: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 16:51:49 -04: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 12:37:11 -04: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 16:51:49 -04: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 08:51:23 -04: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 10:51:13 -04:00
priv = self->priv;
[layout, docs] Clean up BinLayout documentation Documentation and code style fixes for BinLayout.
2009-09-17 06:38:43 -04: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 10:51:13 -04:00
{
[layout, docs] Clean up BinLayout documentation Documentation and code style fixes for BinLayout.
2009-09-17 06:38:43 -04: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 10:51:13 -04:00
[layout, docs] Clean up BinLayout documentation Documentation and code style fixes for BinLayout.
2009-09-17 06:38:43 -04: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 10:51:13 -04: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 16:51:49 -04: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 10:51:13 -04: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 06:38:43 -04: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 16:51:49 -04: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 08:51:23 -04: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 16:51:49 -04: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 08:51:23 -04: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 16:51:49 -04: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 08:51:23 -04: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 10:51:13 -04: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 06:38:43 -04: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 10:51:13 -04:00
*
* Since: 1.2
bin-layout: Deprecate BinLayout alignments We should use the ClutterActor's API for this.
2012-03-29 12:27:34 -04: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 10:51:13 -04: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 06:38:43 -04: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 10:51:13 -04: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 06:38:43 -04: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 10:51:13 -04:00
}
Reference in New Issue Copy Permalink