mirror of
https://github.com/brl/mutter.git
synced 2025-02-25 01:04:10 +00:00
clutter: Remove all the since annotations
Since they are all refer to the days clutter used to be a separate library Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/2441>
This commit is contained in:
parent
7b7e1c6fbd
commit
a73ae93d59
@ -29,8 +29,6 @@
|
||||
*
|
||||
* #CallyActor implements the required ATK interfaces of [class@Clutter.Actor]
|
||||
* exposing the common elements on each actor (position, extents, etc).
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
|
||||
/*
|
||||
@ -195,8 +193,6 @@ G_DEFINE_TYPE_WITH_CODE (CallyActor,
|
||||
* Creates a new #CallyActor for the given @actor
|
||||
*
|
||||
* Return value: the newly created #AtkObject
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
AtkObject *
|
||||
cally_actor_new (ClutterActor *actor)
|
||||
@ -1036,8 +1032,6 @@ _cally_actor_get_action_info (CallyActor *cally_actor,
|
||||
* Adds a new action to be accessed with the #AtkAction interface.
|
||||
*
|
||||
* Return value: added action id, or -1 if failure
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
guint
|
||||
cally_actor_add_action (CallyActor *cally_actor,
|
||||
@ -1067,8 +1061,6 @@ cally_actor_add_action (CallyActor *cally_actor,
|
||||
* Adds a new action to be accessed with the #AtkAction interface.
|
||||
*
|
||||
* Return value: added action id, or -1 if failure
|
||||
*
|
||||
* Since: 1.6
|
||||
*/
|
||||
guint
|
||||
cally_actor_add_action_full (CallyActor *cally_actor,
|
||||
@ -1108,8 +1100,6 @@ cally_actor_add_action_full (CallyActor *cally_actor,
|
||||
* Removes a action, using the @action_id returned by [method@Actor.add_action]
|
||||
*
|
||||
* Return value: %TRUE if the operation was successful, %FALSE otherwise
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
gboolean
|
||||
cally_actor_remove_action (CallyActor *cally_actor,
|
||||
@ -1142,8 +1132,6 @@ cally_actor_remove_action (CallyActor *cally_actor,
|
||||
* with [method@Actor.add_action]
|
||||
*
|
||||
* Return value: %TRUE if the operation was successful, %FALSE otherwise
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
gboolean
|
||||
cally_actor_remove_action_by_name (CallyActor *cally_actor,
|
||||
|
@ -51,8 +51,6 @@ typedef struct _CallyActorPrivate CallyActorPrivate;
|
||||
*
|
||||
* Action function, to be used on #AtkAction implementations as a individual
|
||||
* action
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
typedef void (* CallyActionFunc) (CallyActor *cally_actor);
|
||||
|
||||
@ -66,8 +64,6 @@ typedef void (* CallyActionFunc) (CallyActor *cally_actor);
|
||||
*
|
||||
* Unlike #CallyActionFunc, this function uses the @user_data
|
||||
* argument passed to [method@Actor.add_action_full].
|
||||
*
|
||||
* Since: 1.6
|
||||
*/
|
||||
typedef void (* CallyActionCallback) (CallyActor *cally_actor,
|
||||
gpointer user_data);
|
||||
@ -90,8 +86,6 @@ struct _CallyActor
|
||||
*
|
||||
* The <structname>CallyActorClass</structname> structure contains
|
||||
* only private data
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
struct _CallyActorClass
|
||||
{
|
||||
|
@ -29,8 +29,6 @@
|
||||
*
|
||||
* In particular it sets a proper role for the clone, as just a image,
|
||||
* as it is the sanest and simplest approach.
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
|
||||
/* Design rationale for CallyClone:
|
||||
@ -104,8 +102,6 @@ cally_clone_init (CallyClone *clone)
|
||||
* [class@Clutter.Clone].
|
||||
*
|
||||
* Return value: the newly created #AtkObject
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
AtkObject*
|
||||
cally_clone_new (ClutterActor *actor)
|
||||
|
@ -54,8 +54,6 @@ struct _CallyClone
|
||||
*
|
||||
* The <structname>CallyCloneClass</structname> structure contains only
|
||||
* private data
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
struct _CallyCloneClass
|
||||
{
|
||||
|
@ -42,8 +42,6 @@
|
||||
* It assumes that the accessibility object provides a
|
||||
* @opt_create_accessible method in order to create the accessibility
|
||||
* object. It returns a @type GType object.
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
#define CALLY_ACCESSIBLE_FACTORY(type, type_as_function, opt_create_accessible) \
|
||||
\
|
||||
@ -106,8 +104,6 @@ type_as_function ## _factory_get_type (void) \
|
||||
*
|
||||
* Sets the #AtkObjectFactory to be used in order to instantiate
|
||||
* accessibility objects for the actor which GType is @widget_type.
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
#define CALLY_ACTOR_SET_FACTORY(widget_type, type_as_function) \
|
||||
atk_registry_set_factory_type (atk_get_default_registry (), \
|
||||
|
@ -33,8 +33,6 @@
|
||||
* children of this object are the different [class@Clutter.Stage] managed (so
|
||||
* the [class@GObject.Object] used in the atk_object_initialize() is the
|
||||
* [class@Clutter.StageManager]).
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
|
||||
#include "clutter-build-config.h"
|
||||
@ -115,8 +113,6 @@ cally_root_init (CallyRoot *root)
|
||||
* Creates a new #CallyRoot object.
|
||||
*
|
||||
* Return value: the newly created #AtkObject
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
AtkObject*
|
||||
cally_root_new (void)
|
||||
|
@ -54,8 +54,6 @@ struct _CallyRoot
|
||||
*
|
||||
* The <structname>CallyRootClass</structname> structure contains only
|
||||
* private data
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
struct _CallyRootClass
|
||||
{
|
||||
|
@ -32,8 +32,6 @@
|
||||
* related signals), although the real purpose of [class@Clutter.Stage] is
|
||||
* being a canvas. Anyway, this is required for applications using
|
||||
* just clutter, or directly [class@Clutter.Stage]
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
#include "clutter-build-config.h"
|
||||
|
||||
@ -97,8 +95,6 @@ cally_stage_init (CallyStage *cally_stage)
|
||||
* [class@Clutter.Stage].
|
||||
*
|
||||
* Return value: the newly created #AtkObject
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
AtkObject*
|
||||
cally_stage_new (ClutterActor *actor)
|
||||
|
@ -54,8 +54,6 @@ struct _CallyStage
|
||||
*
|
||||
* The <structname>CallyStageClass</structname> structure contains only
|
||||
* private data
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
struct _CallyStageClass
|
||||
{
|
||||
|
@ -35,8 +35,6 @@
|
||||
*
|
||||
* #CallyText implements the required ATK interfaces of
|
||||
* [class@Clutter.Text], #AtkText and #AtkEditableText
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
|
||||
#include "clutter-build-config.h"
|
||||
@ -260,8 +258,6 @@ cally_text_finalize (GObject *obj)
|
||||
* [class@Clutter.Text].
|
||||
*
|
||||
* Return value: the newly created #AtkObject
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
AtkObject*
|
||||
cally_text_new (ClutterActor *actor)
|
||||
|
@ -54,8 +54,6 @@ struct _CallyText
|
||||
*
|
||||
* The <structname>CallyTextClass</structname> structure contains only
|
||||
* private data
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
struct _CallyTextClass
|
||||
{
|
||||
|
@ -35,8 +35,6 @@
|
||||
* For instance, it defines atk_get_root(), the method that returns
|
||||
* the root object in the hierarchy. Without it, you don't have
|
||||
* available any accessible object.
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
|
||||
#include "clutter-build-config.h"
|
||||
|
@ -54,8 +54,6 @@ struct _CallyUtil
|
||||
*
|
||||
* The <structname>CallyUtilClass</structname> structure contains only
|
||||
* private data
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
struct _CallyUtilClass
|
||||
{
|
||||
|
@ -61,8 +61,6 @@ CALLY_ACCESSIBLE_FACTORY (CALLY_TYPE_CLONE, cally_clone, cally_clone_new)
|
||||
*
|
||||
* Return value: %TRUE if accessibility support has been correctly
|
||||
* initialized.
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
gboolean
|
||||
cally_accessibility_init (void)
|
||||
@ -88,8 +86,6 @@ cally_accessibility_init (void)
|
||||
*
|
||||
* Return value: %TRUE if accessibility support has been correctly
|
||||
* initialized.
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
gboolean cally_get_cally_initialized (void)
|
||||
{
|
||||
|
@ -36,8 +36,6 @@
|
||||
* provide behavioral changes when dealing with user input - for instance
|
||||
* drag and drop capabilities, or scrolling, or panning - by using the
|
||||
* various event-related signals provided by [class@Actor] itself.
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
|
||||
#include "clutter-build-config.h"
|
||||
|
@ -43,8 +43,6 @@ G_DECLARE_DERIVABLE_TYPE (ClutterAction, clutter_action,
|
||||
* ClutterActionClass:
|
||||
*
|
||||
* The ClutterActionClass structure contains only private data
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
struct _ClutterActionClass
|
||||
{
|
||||
|
@ -27,8 +27,6 @@
|
||||
*
|
||||
* Return value: (transfer full): the newly allocated #ClutterActorBox.
|
||||
* Use [method@ActorBox.free] to free the resources
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
ClutterActorBox *
|
||||
clutter_actor_box_new (gfloat x_1,
|
||||
@ -48,8 +46,6 @@ clutter_actor_box_new (gfloat x_1,
|
||||
*
|
||||
* Return value: (transfer full): the newly allocated #ClutterActorBox.
|
||||
* Use [method@ActorBox.free] to free its resources
|
||||
*
|
||||
* Since: 1.12
|
||||
*/
|
||||
ClutterActorBox *
|
||||
clutter_actor_box_alloc (void)
|
||||
@ -68,8 +64,6 @@ clutter_actor_box_alloc (void)
|
||||
* Initializes @box with the given coordinates.
|
||||
*
|
||||
* Return value: (transfer none): the initialized #ClutterActorBox
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
ClutterActorBox *
|
||||
clutter_actor_box_init (ClutterActorBox *box,
|
||||
@ -97,8 +91,6 @@ clutter_actor_box_init (ClutterActorBox *box,
|
||||
* @height: height of the box
|
||||
*
|
||||
* Initializes @box with the given origin and size.
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
void
|
||||
clutter_actor_box_init_rect (ClutterActorBox *box,
|
||||
@ -123,8 +115,6 @@ clutter_actor_box_init_rect (ClutterActorBox *box,
|
||||
*
|
||||
* Return value: a newly allocated copy of #ClutterActorBox. Use
|
||||
* [method@ActorBox.free] to free the allocated resources
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
ClutterActorBox *
|
||||
clutter_actor_box_copy (const ClutterActorBox *box)
|
||||
@ -141,8 +131,6 @@ clutter_actor_box_copy (const ClutterActorBox *box)
|
||||
*
|
||||
* Frees a #ClutterActorBox allocated using [ctor@ActorBox.new]
|
||||
* or [method@ActorBox.copy].
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
void
|
||||
clutter_actor_box_free (ClutterActorBox *box)
|
||||
@ -159,8 +147,6 @@ clutter_actor_box_free (ClutterActorBox *box)
|
||||
* Checks @box_a and @box_b for equality
|
||||
*
|
||||
* Return value: %TRUE if the passed #ClutterActorBox are equal
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
gboolean
|
||||
clutter_actor_box_equal (const ClutterActorBox *box_a,
|
||||
@ -182,8 +168,6 @@ clutter_actor_box_equal (const ClutterActorBox *box_a,
|
||||
* Retrieves the X coordinate of the origin of @box
|
||||
*
|
||||
* Return value: the X coordinate of the origin
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
gfloat
|
||||
clutter_actor_box_get_x (const ClutterActorBox *box)
|
||||
@ -200,8 +184,6 @@ clutter_actor_box_get_x (const ClutterActorBox *box)
|
||||
* Retrieves the Y coordinate of the origin of @box
|
||||
*
|
||||
* Return value: the Y coordinate of the origin
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
gfloat
|
||||
clutter_actor_box_get_y (const ClutterActorBox *box)
|
||||
@ -218,8 +200,6 @@ clutter_actor_box_get_y (const ClutterActorBox *box)
|
||||
* Retrieves the width of the @box
|
||||
*
|
||||
* Return value: the width of the box
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
gfloat
|
||||
clutter_actor_box_get_width (const ClutterActorBox *box)
|
||||
@ -236,8 +216,6 @@ clutter_actor_box_get_width (const ClutterActorBox *box)
|
||||
* Retrieves the height of the @box
|
||||
*
|
||||
* Return value: the height of the box
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
gfloat
|
||||
clutter_actor_box_get_height (const ClutterActorBox *box)
|
||||
@ -254,8 +232,6 @@ clutter_actor_box_get_height (const ClutterActorBox *box)
|
||||
* @y: (out) (allow-none): return location for the Y coordinate, or %NULL
|
||||
*
|
||||
* Retrieves the origin of @box
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
void
|
||||
clutter_actor_box_get_origin (const ClutterActorBox *box,
|
||||
@ -278,8 +254,6 @@ clutter_actor_box_get_origin (const ClutterActorBox *box,
|
||||
* @height: (out) (allow-none): return location for the height, or %NULL
|
||||
*
|
||||
* Retrieves the size of @box
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
void
|
||||
clutter_actor_box_get_size (const ClutterActorBox *box,
|
||||
@ -302,8 +276,6 @@ clutter_actor_box_get_size (const ClutterActorBox *box,
|
||||
* Retrieves the area of @box
|
||||
*
|
||||
* Return value: the area of a #ClutterActorBox, in pixels
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
gfloat
|
||||
clutter_actor_box_get_area (const ClutterActorBox *box)
|
||||
@ -323,8 +295,6 @@ clutter_actor_box_get_area (const ClutterActorBox *box)
|
||||
* within @box
|
||||
*
|
||||
* Return value: %TRUE if the point is contained by the #ClutterActorBox
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
gboolean
|
||||
clutter_actor_box_contains (const ClutterActorBox *box,
|
||||
@ -344,8 +314,6 @@ clutter_actor_box_contains (const ClutterActorBox *box,
|
||||
*
|
||||
* Calculates the bounding box represented by the four vertices; for details
|
||||
* of the vertex array see [method@Actor.get_abs_allocation_vertices].
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
void
|
||||
clutter_actor_box_from_vertices (ClutterActorBox *box,
|
||||
@ -414,8 +382,6 @@ clutter_actor_box_from_vertices (ClutterActorBox *box,
|
||||
*
|
||||
* Interpolates between @initial and @final `ClutterActorBox`es
|
||||
* using @progress
|
||||
*
|
||||
* Since: 1.2
|
||||
*/
|
||||
void
|
||||
clutter_actor_box_interpolate (const ClutterActorBox *initial,
|
||||
@ -438,8 +404,6 @@ clutter_actor_box_interpolate (const ClutterActorBox *initial,
|
||||
* @box: (inout): the #ClutterActorBox to clamp
|
||||
*
|
||||
* Clamps the components of @box to the nearest integer
|
||||
*
|
||||
* Since: 1.2
|
||||
*/
|
||||
void
|
||||
clutter_actor_box_clamp_to_pixel (ClutterActorBox *box)
|
||||
@ -460,8 +424,6 @@ clutter_actor_box_clamp_to_pixel (ClutterActorBox *box)
|
||||
* of @a and @b
|
||||
*
|
||||
* Unions the two boxes @a and @b and stores the result in @result.
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
void
|
||||
clutter_actor_box_union (const ClutterActorBox *a,
|
||||
@ -504,8 +466,6 @@ clutter_actor_box_progress (const GValue *a,
|
||||
* @y: the Y coordinate of the new origin
|
||||
*
|
||||
* Changes the origin of @box, maintaining the size of the #ClutterActorBox.
|
||||
*
|
||||
* Since: 1.6
|
||||
*/
|
||||
void
|
||||
clutter_actor_box_set_origin (ClutterActorBox *box,
|
||||
@ -529,8 +489,6 @@ clutter_actor_box_set_origin (ClutterActorBox *box,
|
||||
* @height: the new height
|
||||
*
|
||||
* Sets the size of @box, maintaining the origin of the #ClutterActorBox.
|
||||
*
|
||||
* Since: 1.6
|
||||
*/
|
||||
void
|
||||
clutter_actor_box_set_size (ClutterActorBox *box,
|
||||
@ -600,8 +558,6 @@ _clutter_actor_box_enlarge_for_effects (ClutterActorBox *box)
|
||||
* @scale: scale factor for resizing this box
|
||||
*
|
||||
* Rescale the @box by provided @scale factor.
|
||||
*
|
||||
* Since: 1.6
|
||||
*/
|
||||
void
|
||||
clutter_actor_box_scale (ClutterActorBox *box,
|
||||
|
@ -36,8 +36,6 @@
|
||||
* Every sub-class of #ClutterActorMeta should check if the
|
||||
* [property@ActorMeta:enabled] property is set to %TRUE before applying
|
||||
* any kind of modification.
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
|
||||
#include "clutter-build-config.h"
|
||||
@ -206,8 +204,6 @@ clutter_actor_meta_class_init (ClutterActorMetaClass *klass)
|
||||
* ClutterActorMeta:actor:
|
||||
*
|
||||
* The #ClutterActor attached to the #ClutterActorMeta instance
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
obj_props[PROP_ACTOR] =
|
||||
g_param_spec_object ("actor",
|
||||
@ -221,8 +217,6 @@ clutter_actor_meta_class_init (ClutterActorMetaClass *klass)
|
||||
* ClutterActorMeta:name:
|
||||
*
|
||||
* The unique name to access the #ClutterActorMeta
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
obj_props[PROP_NAME] =
|
||||
g_param_spec_string ("name",
|
||||
@ -235,8 +229,6 @@ clutter_actor_meta_class_init (ClutterActorMetaClass *klass)
|
||||
* ClutterActorMeta:enabled:
|
||||
*
|
||||
* Whether or not the #ClutterActorMeta is enabled
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
obj_props[PROP_ENABLED] =
|
||||
g_param_spec_boolean ("enabled",
|
||||
@ -271,8 +263,6 @@ clutter_actor_meta_init (ClutterActorMeta *self)
|
||||
* Sets the name of @meta
|
||||
*
|
||||
* The name can be used to identify the #ClutterActorMeta instance
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
void
|
||||
clutter_actor_meta_set_name (ClutterActorMeta *meta,
|
||||
@ -303,8 +293,6 @@ clutter_actor_meta_set_name (ClutterActorMeta *meta,
|
||||
* instance, or %NULL if none was set. The returned string is owned
|
||||
* by the #ClutterActorMeta instance and it should not be modified
|
||||
* or freed
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
const gchar *
|
||||
clutter_actor_meta_get_name (ClutterActorMeta *meta)
|
||||
@ -324,8 +312,6 @@ clutter_actor_meta_get_name (ClutterActorMeta *meta)
|
||||
* @is_enabled: whether @meta is enabled
|
||||
*
|
||||
* Sets whether @meta should be enabled or not
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
void
|
||||
clutter_actor_meta_set_enabled (ClutterActorMeta *meta,
|
||||
@ -351,8 +337,6 @@ clutter_actor_meta_set_enabled (ClutterActorMeta *meta,
|
||||
* Retrieves whether @meta is enabled
|
||||
*
|
||||
* Return value: %TRUE if the #ClutterActorMeta instance is enabled
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
gboolean
|
||||
clutter_actor_meta_get_enabled (ClutterActorMeta *meta)
|
||||
@ -373,8 +357,6 @@ clutter_actor_meta_get_enabled (ClutterActorMeta *meta)
|
||||
*
|
||||
* Sets or unsets a back pointer to the #ClutterActor that owns
|
||||
* the @meta
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
void
|
||||
_clutter_actor_meta_set_actor (ClutterActorMeta *meta,
|
||||
@ -393,8 +375,6 @@ _clutter_actor_meta_set_actor (ClutterActorMeta *meta,
|
||||
* Retrieves a pointer to the [class@Actor] that owns @meta
|
||||
*
|
||||
* Return value: (transfer none): a pointer to a #ClutterActor or %NULL
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
ClutterActor *
|
||||
clutter_actor_meta_get_actor (ClutterActorMeta *meta)
|
||||
|
@ -48,8 +48,6 @@ typedef struct _ClutterActorMetaPrivate ClutterActorMetaPrivate;
|
||||
*
|
||||
* The #ClutterActorMetaClass structure contains
|
||||
* only private data
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
struct _ClutterActorMetaClass
|
||||
{
|
||||
|
File diff suppressed because it is too large
Load Diff
@ -306,8 +306,6 @@ struct _ClutterActorClass
|
||||
*
|
||||
* The contents of the #ClutterActorIter structure
|
||||
* are private and should only be accessed using the provided API.
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
struct _ClutterActorIter
|
||||
{
|
||||
@ -902,9 +900,7 @@ void clutter_actor_uninhibit_culling
|
||||
* of interest, using g_object_bind_property(). This way, when the @item
|
||||
* in the #GListModel changes, the #ClutterActor changes as well.
|
||||
*
|
||||
* Returns: (transfer full): The newly created child #ClutterActor
|
||||
*
|
||||
* Since: 1.24
|
||||
* Returns: (transfer full): The newly created child #ClutterActor4
|
||||
*/
|
||||
typedef ClutterActor * (* ClutterActorCreateChildFunc) (gpointer item,
|
||||
gpointer user_data);
|
||||
|
@ -30,8 +30,6 @@
|
||||
* #ClutterAlignConstraint is a [class@Constraint] that aligns the position
|
||||
* of the [class@Actor] to which it is applied to the size of another
|
||||
* [class@Actor] using an alignment factor
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
|
||||
#include "clutter-build-config.h"
|
||||
@ -289,8 +287,6 @@ clutter_align_constraint_class_init (ClutterAlignConstraintClass *klass)
|
||||
*
|
||||
* The #ClutterActor must not be a child or a grandchild of the actor
|
||||
* using the constraint.
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
obj_props[PROP_SOURCE] =
|
||||
g_param_spec_object ("source",
|
||||
@ -303,8 +299,6 @@ clutter_align_constraint_class_init (ClutterAlignConstraintClass *klass)
|
||||
* ClutterAlignConstraint:align-axis:
|
||||
*
|
||||
* The axis to be used to compute the alignment
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
obj_props[PROP_ALIGN_AXIS] =
|
||||
g_param_spec_enum ("align-axis",
|
||||
@ -347,8 +341,6 @@ clutter_align_constraint_class_init (ClutterAlignConstraintClass *klass)
|
||||
* with an align-axis value of %CLUTTER_ALIGN_X_AXIS, 0.0 means left and
|
||||
* 1.0 means right; with a value of %CLUTTER_ALIGN_Y_AXIS, 0.0 means top
|
||||
* and 1.0 means bottom.
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
obj_props[PROP_FACTOR] =
|
||||
g_param_spec_float ("factor",
|
||||
@ -387,8 +379,6 @@ clutter_align_constraint_init (ClutterAlignConstraint *self)
|
||||
* alignment @factor
|
||||
*
|
||||
* Return value: the newly created #ClutterAlignConstraint
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
ClutterConstraint *
|
||||
clutter_align_constraint_new (ClutterActor *source,
|
||||
@ -410,8 +400,6 @@ clutter_align_constraint_new (ClutterActor *source,
|
||||
* @source: (allow-none): a #ClutterActor, or %NULL to unset the source
|
||||
*
|
||||
* Sets the source of the alignment constraint
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
void
|
||||
clutter_align_constraint_set_source (ClutterAlignConstraint *align,
|
||||
@ -478,8 +466,6 @@ clutter_align_constraint_set_source (ClutterAlignConstraint *align,
|
||||
*
|
||||
* Return value: (transfer none): the #ClutterActor used as the source
|
||||
* of the alignment
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
ClutterActor *
|
||||
clutter_align_constraint_get_source (ClutterAlignConstraint *align)
|
||||
@ -495,8 +481,6 @@ clutter_align_constraint_get_source (ClutterAlignConstraint *align)
|
||||
* @axis: the axis to which the alignment refers to
|
||||
*
|
||||
* Sets the axis to which the alignment refers to
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
void
|
||||
clutter_align_constraint_set_align_axis (ClutterAlignConstraint *align,
|
||||
@ -522,8 +506,6 @@ clutter_align_constraint_set_align_axis (ClutterAlignConstraint *align,
|
||||
* Retrieves the value set using clutter_align_constraint_set_align_axis()
|
||||
*
|
||||
* Return value: the alignment axis
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
ClutterAlignAxis
|
||||
clutter_align_constraint_get_align_axis (ClutterAlignConstraint *align)
|
||||
@ -604,8 +586,6 @@ clutter_align_constraint_get_pivot_point (ClutterAlignConstraint *align,
|
||||
* meaning bottom, when #ClutterAlignConstraint:align-axis is set to
|
||||
* %CLUTTER_ALIGN_Y_AXIS). A value of 0.5 aligns in the middle in either
|
||||
* cases
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
void
|
||||
clutter_align_constraint_set_factor (ClutterAlignConstraint *align,
|
||||
@ -628,8 +608,6 @@ clutter_align_constraint_set_factor (ClutterAlignConstraint *align,
|
||||
* Retrieves the factor set using clutter_align_constraint_set_factor()
|
||||
*
|
||||
* Return value: the alignment factor
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
gfloat
|
||||
clutter_align_constraint_get_factor (ClutterAlignConstraint *align)
|
||||
|
@ -34,8 +34,6 @@
|
||||
* [vfunc@Animatable.interpolate_value] virtual function of the
|
||||
* interface to compute the animation state between two values of an interval
|
||||
* depending on a progress factor, expressed as a floating point value.
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
|
||||
#include "clutter-build-config.h"
|
||||
@ -61,8 +59,6 @@ clutter_animatable_default_init (ClutterAnimatableInterface *iface)
|
||||
*
|
||||
* Return value: (transfer none): The #GParamSpec for the given property
|
||||
* or %NULL
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
GParamSpec *
|
||||
clutter_animatable_find_property (ClutterAnimatable *animatable,
|
||||
@ -90,8 +86,6 @@ clutter_animatable_find_property (ClutterAnimatable *animatable,
|
||||
* @value: a #GValue initialized to the type of the property to retrieve
|
||||
*
|
||||
* Retrieves the current state of @property_name and sets @value with it
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
void
|
||||
clutter_animatable_get_initial_state (ClutterAnimatable *animatable,
|
||||
@ -119,8 +113,6 @@ clutter_animatable_get_initial_state (ClutterAnimatable *animatable,
|
||||
* @value: the value of the animatable property to set
|
||||
*
|
||||
* Sets the current state of @property_name to @value
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
void
|
||||
clutter_animatable_set_final_state (ClutterAnimatable *animatable,
|
||||
@ -163,8 +155,6 @@ clutter_animatable_set_final_state (ClutterAnimatable *animatable,
|
||||
*
|
||||
* Return value: %TRUE if the interpolation was successful,
|
||||
* and %FALSE otherwise
|
||||
*
|
||||
* Since: 1.8
|
||||
*/
|
||||
gboolean
|
||||
clutter_animatable_interpolate_value (ClutterAnimatable *animatable,
|
||||
|
@ -51,8 +51,6 @@ G_DECLARE_INTERFACE (ClutterAnimatable, clutter_animatable,
|
||||
* @interpolate_value: virtual function for interpolating the progress
|
||||
* of a property
|
||||
* @get_actor: virtual function for getting associated actor
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
struct _ClutterAnimatableInterface
|
||||
{
|
||||
|
@ -35,8 +35,6 @@
|
||||
* #ClutterBackend is the base class abstracting the various implementation;
|
||||
* it provides a basic API to query the backend for generic information
|
||||
* and settings.
|
||||
*
|
||||
* Since: 0.4
|
||||
*/
|
||||
|
||||
#include "clutter-build-config.h"
|
||||
@ -379,8 +377,6 @@ clutter_backend_class_init (ClutterBackendClass *klass)
|
||||
*
|
||||
* The signal is emitted each time the font
|
||||
* resolutions has been changed through #ClutterSettings.
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
backend_signals[RESOLUTION_CHANGED] =
|
||||
g_signal_new (I_("resolution-changed"),
|
||||
@ -396,8 +392,6 @@ clutter_backend_class_init (ClutterBackendClass *klass)
|
||||
*
|
||||
* The signal is emitted each time the font options
|
||||
* have been changed through #ClutterSettings.
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
backend_signals[FONT_CHANGED] =
|
||||
g_signal_new (I_("font-changed"),
|
||||
@ -413,8 +407,6 @@ clutter_backend_class_init (ClutterBackendClass *klass)
|
||||
*
|
||||
* The signal is emitted each time the #ClutterSettings
|
||||
* properties have been changed.
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
backend_signals[SETTINGS_CHANGED] =
|
||||
g_signal_new (I_("settings-changed"),
|
||||
@ -519,8 +511,6 @@ _clutter_backend_get_units_per_em (ClutterBackend *backend,
|
||||
* Return value: (transfer none): the default backend. You should
|
||||
* not ref or unref the returned object. Applications should rarely
|
||||
* need to use this.
|
||||
*
|
||||
* Since: 0.4
|
||||
*/
|
||||
ClutterBackend *
|
||||
clutter_get_default_backend (void)
|
||||
@ -549,8 +539,6 @@ clutter_get_default_backend (void)
|
||||
*
|
||||
* Return value: the current resolution, or -1 if no resolution
|
||||
* has been set.
|
||||
*
|
||||
* Since: 0.4
|
||||
*/
|
||||
gdouble
|
||||
clutter_backend_get_resolution (ClutterBackend *backend)
|
||||
@ -583,8 +571,6 @@ clutter_backend_get_resolution (ClutterBackend *backend)
|
||||
*
|
||||
* This function is intended for actors creating a Pango layout
|
||||
* using the PangoCairo API.
|
||||
*
|
||||
* Since: 0.8
|
||||
*/
|
||||
void
|
||||
clutter_backend_set_font_options (ClutterBackend *backend,
|
||||
@ -615,8 +601,6 @@ clutter_backend_set_font_options (ClutterBackend *backend,
|
||||
* Return value: (transfer none): the font options of the #ClutterBackend.
|
||||
* The returned #cairo_font_options_t is owned by the backend and should
|
||||
* not be modified or freed
|
||||
*
|
||||
* Since: 0.8
|
||||
*/
|
||||
const cairo_font_options_t *
|
||||
clutter_backend_get_font_options (ClutterBackend *backend)
|
||||
@ -669,8 +653,6 @@ _clutter_backend_translate_event (ClutterBackend *backend,
|
||||
* explicitly create a CoglContext.
|
||||
*
|
||||
* Return value: (transfer none): The #CoglContext associated with @backend.
|
||||
*
|
||||
* Since: 1.8
|
||||
* Stability: unstable
|
||||
*/
|
||||
CoglContext *
|
||||
|
@ -51,8 +51,6 @@
|
||||
* Return value: (transfer full): a newly allocated #ClutterMargin. Use
|
||||
* clutter_margin_free() to free the resources associated with it when
|
||||
* done.
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
ClutterMargin *
|
||||
clutter_margin_new (void)
|
||||
@ -68,8 +66,6 @@ clutter_margin_new (void)
|
||||
* the newly created structure.
|
||||
*
|
||||
* Return value: (transfer full): a copy of the #ClutterMargin.
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
ClutterMargin *
|
||||
clutter_margin_copy (const ClutterMargin *margin_)
|
||||
@ -86,8 +82,6 @@ clutter_margin_copy (const ClutterMargin *margin_)
|
||||
*
|
||||
* Frees the resources allocated by clutter_margin_new() and
|
||||
* clutter_margin_copy().
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
void
|
||||
clutter_margin_free (ClutterMargin *margin_)
|
||||
|
@ -40,8 +40,6 @@
|
||||
*
|
||||
* 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.
|
||||
*
|
||||
* Since: 1.2
|
||||
*/
|
||||
|
||||
#include "clutter-build-config.h"
|
||||
@ -620,8 +618,6 @@ clutter_bin_layout_class_init (ClutterBinLayoutClass *klass)
|
||||
* The default horizontal alignment policy for actors managed
|
||||
* by the #ClutterBinLayout
|
||||
*
|
||||
* Since: 1.2
|
||||
*
|
||||
* Deprecated: 1.12: Use the #ClutterActor:x-expand and the
|
||||
* #ClutterActor:x-align properties on #ClutterActor instead.
|
||||
*/
|
||||
@ -640,8 +636,6 @@ clutter_bin_layout_class_init (ClutterBinLayoutClass *klass)
|
||||
* The default vertical alignment policy for actors managed
|
||||
* by the #ClutterBinLayout
|
||||
*
|
||||
* Since: 1.2
|
||||
*
|
||||
* Deprecated: 1.12: Use the #ClutterActor:y-expand and the
|
||||
* #ClutterActor:y-align properties on #ClutterActor instead.
|
||||
*/
|
||||
@ -685,8 +679,6 @@ clutter_bin_layout_init (ClutterBinLayout *self)
|
||||
* Creates a new #ClutterBinLayout layout manager
|
||||
*
|
||||
* Return value: the newly created layout manager
|
||||
*
|
||||
* Since: 1.2
|
||||
*/
|
||||
ClutterLayoutManager *
|
||||
clutter_bin_layout_new (ClutterBinAlignment x_align,
|
||||
|
@ -57,8 +57,6 @@ struct _ClutterBinLayout
|
||||
*
|
||||
* The #ClutterBinLayoutClass structure contains only private
|
||||
* data and should be accessed using the provided API
|
||||
*
|
||||
* Since: 1.2
|
||||
*/
|
||||
struct _ClutterBinLayoutClass
|
||||
{
|
||||
|
@ -79,8 +79,6 @@
|
||||
* "opacity", 255,
|
||||
* NULL);
|
||||
* ```
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
|
||||
#include "clutter-build-config.h"
|
||||
@ -392,8 +390,6 @@ clutter_bind_constraint_class_init (ClutterBindConstraintClass *klass)
|
||||
*
|
||||
* The #ClutterActor must not be contained inside the actor associated
|
||||
* to the constraint.
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
obj_props[PROP_SOURCE] =
|
||||
g_param_spec_object ("source",
|
||||
@ -406,8 +402,6 @@ clutter_bind_constraint_class_init (ClutterBindConstraintClass *klass)
|
||||
* ClutterBindConstraint:coordinate:
|
||||
*
|
||||
* The coordinate to be bound
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
obj_props[PROP_COORDINATE] =
|
||||
g_param_spec_enum ("coordinate",
|
||||
@ -421,8 +415,6 @@ clutter_bind_constraint_class_init (ClutterBindConstraintClass *klass)
|
||||
* ClutterBindConstraint:offset:
|
||||
*
|
||||
* The offset, in pixels, to be applied to the binding
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
obj_props[PROP_OFFSET] =
|
||||
g_param_spec_float ("offset",
|
||||
@ -457,8 +449,6 @@ clutter_bind_constraint_init (ClutterBindConstraint *self)
|
||||
* the given @coordinate of the position of @source
|
||||
*
|
||||
* Return value: the newly created #ClutterBindConstraint
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
ClutterConstraint *
|
||||
clutter_bind_constraint_new (ClutterActor *source,
|
||||
@ -480,8 +470,6 @@ clutter_bind_constraint_new (ClutterActor *source,
|
||||
* @source: (allow-none): a #ClutterActor, or %NULL to unset the source
|
||||
*
|
||||
* Sets the source #ClutterActor for the constraint
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
void
|
||||
clutter_bind_constraint_set_source (ClutterBindConstraint *constraint,
|
||||
@ -547,8 +535,6 @@ clutter_bind_constraint_set_source (ClutterBindConstraint *constraint,
|
||||
* Retrieves the #ClutterActor set using clutter_bind_constraint_set_source()
|
||||
*
|
||||
* Return value: (transfer none): a pointer to the source actor
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
ClutterActor *
|
||||
clutter_bind_constraint_get_source (ClutterBindConstraint *constraint)
|
||||
@ -564,8 +550,6 @@ clutter_bind_constraint_get_source (ClutterBindConstraint *constraint)
|
||||
* @coordinate: the coordinate to bind
|
||||
*
|
||||
* Sets the coordinate to bind in the constraint
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
void
|
||||
clutter_bind_constraint_set_coordinate (ClutterBindConstraint *constraint,
|
||||
@ -591,8 +575,6 @@ clutter_bind_constraint_set_coordinate (ClutterBindConstraint *constraint,
|
||||
* Retrieves the bound coordinate of the constraint
|
||||
*
|
||||
* Return value: the bound coordinate
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
ClutterBindCoordinate
|
||||
clutter_bind_constraint_get_coordinate (ClutterBindConstraint *constraint)
|
||||
@ -609,8 +591,6 @@ clutter_bind_constraint_get_coordinate (ClutterBindConstraint *constraint)
|
||||
* @offset: the offset to apply, in pixels
|
||||
*
|
||||
* Sets the offset to be applied to the constraint
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
void
|
||||
clutter_bind_constraint_set_offset (ClutterBindConstraint *constraint,
|
||||
@ -636,8 +616,6 @@ clutter_bind_constraint_set_offset (ClutterBindConstraint *constraint,
|
||||
* Retrieves the offset set using clutter_bind_constraint_set_offset()
|
||||
*
|
||||
* Return value: the offset, in pixels
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
gfloat
|
||||
clutter_bind_constraint_get_offset (ClutterBindConstraint *bind)
|
||||
|
@ -91,8 +91,6 @@
|
||||
* no action for the given key binding was found, if the action was
|
||||
* blocked (using [method@BindingPool.block_action]) or if the
|
||||
* key binding handler returned %FALSE.
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
|
||||
#include "clutter-build-config.h"
|
||||
@ -308,8 +306,6 @@ clutter_binding_pool_class_init (ClutterBindingPoolClass *klass)
|
||||
* ClutterBindingPool:name:
|
||||
*
|
||||
* The unique name of the #ClutterBindingPool.
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
obj_props[PROP_NAME] =
|
||||
g_param_spec_string ("name",
|
||||
@ -346,8 +342,6 @@ clutter_binding_pool_init (ClutterBindingPool *pool)
|
||||
*
|
||||
* Return value: the newly created binding pool with the given
|
||||
* name. Use g_object_unref() when done.
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
ClutterBindingPool *
|
||||
clutter_binding_pool_new (const gchar *name)
|
||||
@ -390,8 +384,6 @@ clutter_binding_pool_new (const gchar *name)
|
||||
* Return value: (transfer none): the binding pool for the given class.
|
||||
* The returned #ClutterBindingPool is owned by Clutter and should not
|
||||
* be freed directly
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
ClutterBindingPool *
|
||||
clutter_binding_pool_get_for_class (gpointer klass)
|
||||
@ -422,8 +414,6 @@ clutter_binding_pool_get_for_class (gpointer klass)
|
||||
* Finds the #ClutterBindingPool with @name.
|
||||
*
|
||||
* Return value: (transfer none): a pointer to the #ClutterBindingPool, or %NULL
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
ClutterBindingPool *
|
||||
clutter_binding_pool_find (const gchar *name)
|
||||
@ -466,8 +456,6 @@ clutter_binding_pool_find (const gchar *name)
|
||||
*
|
||||
* Actions can be blocked with clutter_binding_pool_block_action()
|
||||
* and then unblocked using clutter_binding_pool_unblock_action().
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
void
|
||||
clutter_binding_pool_install_action (ClutterBindingPool *pool,
|
||||
@ -536,8 +524,6 @@ clutter_binding_pool_install_action (ClutterBindingPool *pool,
|
||||
*
|
||||
* Actions can be blocked with clutter_binding_pool_block_action()
|
||||
* and then unblocked using clutter_binding_pool_unblock_action().
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
void
|
||||
clutter_binding_pool_install_closure (ClutterBindingPool *pool,
|
||||
@ -599,8 +585,6 @@ clutter_binding_pool_install_closure (ClutterBindingPool *pool,
|
||||
*
|
||||
* Actions can be blocked with clutter_binding_pool_block_action()
|
||||
* and then unblocked using clutter_binding_pool_unblock_action().
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
void
|
||||
clutter_binding_pool_override_action (ClutterBindingPool *pool,
|
||||
@ -663,8 +647,6 @@ clutter_binding_pool_override_action (ClutterBindingPool *pool,
|
||||
*
|
||||
* Actions can be blocked with clutter_binding_pool_block_action()
|
||||
* and then unblocked using clutter_binding_pool_unblock_action().
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
void
|
||||
clutter_binding_pool_override_closure (ClutterBindingPool *pool,
|
||||
@ -718,8 +700,6 @@ clutter_binding_pool_override_closure (ClutterBindingPool *pool,
|
||||
* Return value: the name of the action, if found, or %NULL. The
|
||||
* returned string is owned by the binding pool and should never
|
||||
* be modified or freed
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
const gchar *
|
||||
clutter_binding_pool_find_action (ClutterBindingPool *pool,
|
||||
@ -746,8 +726,6 @@ clutter_binding_pool_find_action (ClutterBindingPool *pool,
|
||||
*
|
||||
* Removes the action matching the given @key_val, @modifiers pair,
|
||||
* if any exists.
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
void
|
||||
clutter_binding_pool_remove_action (ClutterBindingPool *pool,
|
||||
@ -850,8 +828,6 @@ clutter_binding_entry_invoke (ClutterBindingEntry *entry,
|
||||
* will not be invoked, and this function will return %FALSE.
|
||||
*
|
||||
* Return value: %TRUE if an action was found and was activated
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
gboolean
|
||||
clutter_binding_pool_activate (ClutterBindingPool *pool,
|
||||
@ -883,8 +859,6 @@ clutter_binding_pool_activate (ClutterBindingPool *pool,
|
||||
* @action_name: an action name
|
||||
*
|
||||
* Blocks all the actions with name @action_name inside @pool.
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
void
|
||||
clutter_binding_pool_block_action (ClutterBindingPool *pool,
|
||||
@ -914,8 +888,6 @@ clutter_binding_pool_block_action (ClutterBindingPool *pool,
|
||||
* Unblocking an action does not cause the callback bound to it to
|
||||
* be invoked in case clutter_binding_pool_activate() was called on
|
||||
* an action previously blocked with clutter_binding_pool_block_action().
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
void
|
||||
clutter_binding_pool_unblock_action (ClutterBindingPool *pool,
|
||||
|
@ -54,8 +54,6 @@ typedef struct _ClutterBindingPoolClass ClutterBindingPoolClass;
|
||||
*
|
||||
* Return value: the function should return %TRUE if the key
|
||||
* binding has been handled, and return %FALSE otherwise
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
typedef gboolean (* ClutterBindingActionFunc) (GObject *gobject,
|
||||
const gchar *action_name,
|
||||
|
@ -29,8 +29,6 @@
|
||||
*
|
||||
* #ClutterBlurEffect is a sub-class of #ClutterEffect that allows blurring a
|
||||
* actor and its contents.
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
|
||||
#define CLUTTER_BLUR_EFFECT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), CLUTTER_TYPE_BLUR_EFFECT, ClutterBlurEffectClass))
|
||||
@ -209,8 +207,6 @@ clutter_blur_effect_init (ClutterBlurEffect *self)
|
||||
* clutter_actor_add_effect()
|
||||
*
|
||||
* Return value: the newly created #ClutterBlurEffect or %NULL
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
ClutterEffect *
|
||||
clutter_blur_effect_new (void)
|
||||
|
@ -44,8 +44,6 @@
|
||||
*
|
||||
* It is possible to control the spacing between children of a
|
||||
* #ClutterBoxLayout by using clutter_box_layout_set_spacing().
|
||||
*
|
||||
* Since: 1.2
|
||||
*/
|
||||
|
||||
#include "clutter-build-config.h"
|
||||
@ -940,8 +938,6 @@ clutter_box_layout_class_init (ClutterBoxLayoutClass *klass)
|
||||
*
|
||||
* The orientation of the #ClutterBoxLayout, either horizontal
|
||||
* or vertical
|
||||
*
|
||||
* Since: 1.12
|
||||
*/
|
||||
obj_props[PROP_ORIENTATION] =
|
||||
g_param_spec_enum ("orientation",
|
||||
@ -957,8 +953,6 @@ clutter_box_layout_class_init (ClutterBoxLayoutClass *klass)
|
||||
*
|
||||
* Whether the #ClutterBoxLayout should arrange its children
|
||||
* homogeneously, i.e. all children get the same size
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
obj_props[PROP_HOMOGENEOUS] =
|
||||
g_param_spec_boolean ("homogeneous",
|
||||
@ -984,8 +978,6 @@ clutter_box_layout_class_init (ClutterBoxLayoutClass *klass)
|
||||
* ClutterBoxLayout:spacing:
|
||||
*
|
||||
* The spacing between children of the #ClutterBoxLayout, in pixels
|
||||
*
|
||||
* Since: 1.2
|
||||
*/
|
||||
obj_props[PROP_SPACING] =
|
||||
g_param_spec_uint ("spacing",
|
||||
@ -1018,8 +1010,6 @@ clutter_box_layout_init (ClutterBoxLayout *self)
|
||||
* Creates a new #ClutterBoxLayout layout manager
|
||||
*
|
||||
* Return value: the newly created #ClutterBoxLayout
|
||||
*
|
||||
* Since: 1.2
|
||||
*/
|
||||
ClutterLayoutManager *
|
||||
clutter_box_layout_new (void)
|
||||
@ -1033,8 +1023,6 @@ clutter_box_layout_new (void)
|
||||
* @spacing: the spacing between children of the layout, in pixels
|
||||
*
|
||||
* Sets the spacing between children of @layout
|
||||
*
|
||||
* Since: 1.2
|
||||
*/
|
||||
void
|
||||
clutter_box_layout_set_spacing (ClutterBoxLayout *layout,
|
||||
@ -1067,8 +1055,6 @@ clutter_box_layout_set_spacing (ClutterBoxLayout *layout,
|
||||
* Retrieves the spacing set using clutter_box_layout_set_spacing()
|
||||
*
|
||||
* Return value: the spacing between children of the #ClutterBoxLayout
|
||||
*
|
||||
* Since: 1.2
|
||||
*/
|
||||
guint
|
||||
clutter_box_layout_get_spacing (ClutterBoxLayout *layout)
|
||||
@ -1084,8 +1070,6 @@ clutter_box_layout_get_spacing (ClutterBoxLayout *layout)
|
||||
* @orientation: the orientation of the #ClutterBoxLayout
|
||||
*
|
||||
* Sets the orientation of the #ClutterBoxLayout layout manager.
|
||||
*
|
||||
* Since: 1.12
|
||||
*/
|
||||
void
|
||||
clutter_box_layout_set_orientation (ClutterBoxLayout *layout,
|
||||
@ -1117,8 +1101,6 @@ clutter_box_layout_set_orientation (ClutterBoxLayout *layout,
|
||||
* Retrieves the orientation of the @layout.
|
||||
*
|
||||
* Return value: the orientation of the layout
|
||||
*
|
||||
* Since: 1.12
|
||||
*/
|
||||
ClutterOrientation
|
||||
clutter_box_layout_get_orientation (ClutterBoxLayout *layout)
|
||||
@ -1136,8 +1118,6 @@ clutter_box_layout_get_orientation (ClutterBoxLayout *layout)
|
||||
*
|
||||
* Sets whether the size of @layout children should be
|
||||
* homogeneous
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
void
|
||||
clutter_box_layout_set_homogeneous (ClutterBoxLayout *layout,
|
||||
@ -1171,8 +1151,6 @@ clutter_box_layout_set_homogeneous (ClutterBoxLayout *layout,
|
||||
*
|
||||
* Return value: %TRUE if the #ClutterBoxLayout is arranging its children
|
||||
* homogeneously, and %FALSE otherwise
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
gboolean
|
||||
clutter_box_layout_get_homogeneous (ClutterBoxLayout *layout)
|
||||
|
@ -60,8 +60,6 @@ struct _ClutterBoxLayout
|
||||
*
|
||||
* The #ClutterBoxLayoutClass structure contains only private
|
||||
* data and should be accessed using the provided API
|
||||
*
|
||||
* Since: 1.2
|
||||
*/
|
||||
struct _ClutterBoxLayoutClass
|
||||
{
|
||||
|
@ -29,8 +29,6 @@
|
||||
*
|
||||
* #ClutterBrightnessContrastEffect is a sub-class of #ClutterEffect that
|
||||
* changes the overall brightness of a #ClutterActor.
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
|
||||
#define CLUTTER_BRIGHTNESS_CONTRAST_EFFECT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), CLUTTER_TYPE_BRIGHTNESS_CONTRAST_EFFECT, ClutterBrightnessContrastEffectClass))
|
||||
@ -268,8 +266,6 @@ clutter_brightness_contrast_effect_class_init (ClutterBrightnessContrastEffectCl
|
||||
* to indicate no change; values smaller than 127 indicate a decrease
|
||||
* in brightness, and values larger than 127 indicate an increase in
|
||||
* brightness.
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
obj_props[PROP_BRIGHTNESS] =
|
||||
clutter_param_spec_color ("brightness",
|
||||
@ -288,8 +284,6 @@ clutter_brightness_contrast_effect_class_init (ClutterBrightnessContrastEffectCl
|
||||
* to indicate no change; values smaller than 127 indicate a decrease
|
||||
* in contrast, and values larger than 127 indicate an increase in
|
||||
* contrast.
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
obj_props[PROP_CONTRAST] =
|
||||
clutter_param_spec_color ("contrast",
|
||||
@ -420,8 +414,6 @@ clutter_brightness_contrast_effect_init (ClutterBrightnessContrastEffect *self)
|
||||
* Return value: (transfer full): the newly created
|
||||
* #ClutterBrightnessContrastEffect or %NULL. Use g_object_unref() when
|
||||
* done.
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
ClutterEffect *
|
||||
clutter_brightness_contrast_effect_new (void)
|
||||
@ -439,8 +431,6 @@ clutter_brightness_contrast_effect_new (void)
|
||||
* The range for each component is [-1.0, 1.0] where 0.0 designates no change,
|
||||
* values below 0.0 mean a decrease in brightness, and values above indicate
|
||||
* an increase.
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
void
|
||||
clutter_brightness_contrast_effect_set_brightness_full (ClutterBrightnessContrastEffect *effect,
|
||||
@ -477,8 +467,6 @@ clutter_brightness_contrast_effect_set_brightness_full (ClutterBrightnessContras
|
||||
* change in brightness
|
||||
*
|
||||
* Retrieves the change in brightness used by @effect.
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
void
|
||||
clutter_brightness_contrast_effect_get_brightness (ClutterBrightnessContrastEffect *effect,
|
||||
@ -506,8 +494,6 @@ clutter_brightness_contrast_effect_get_brightness (ClutterBrightnessContrastEffe
|
||||
* The range of @brightness is [-1.0, 1.0], where 0.0 designates no change;
|
||||
* a value below 0.0 indicates a decrease in brightness; and a value
|
||||
* above 0.0 indicates an increase of brightness.
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
void
|
||||
clutter_brightness_contrast_effect_set_brightness (ClutterBrightnessContrastEffect *effect,
|
||||
@ -529,8 +515,6 @@ clutter_brightness_contrast_effect_set_brightness (ClutterBrightnessContrastEffe
|
||||
* The range for each component is [-1.0, 1.0] where 0.0 designates no change,
|
||||
* values below 0.0 mean a decrease in contrast, and values above indicate
|
||||
* an increase.
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
void
|
||||
clutter_brightness_contrast_effect_set_contrast_full (ClutterBrightnessContrastEffect *effect,
|
||||
@ -567,8 +551,6 @@ clutter_brightness_contrast_effect_set_contrast_full (ClutterBrightnessContrastE
|
||||
* change in contrast
|
||||
*
|
||||
* Retrieves the contrast value used by @effect.
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
void
|
||||
clutter_brightness_contrast_effect_get_contrast (ClutterBrightnessContrastEffect *effect,
|
||||
@ -596,8 +578,6 @@ clutter_brightness_contrast_effect_get_contrast (ClutterBrightnessContrastEffect
|
||||
* The range for @contrast is [-1.0, 1.0], where 0.0 designates no change;
|
||||
* a value below 0.0 indicates a decrease in contrast; and a value above
|
||||
* 0.0 indicates an increase.
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
void
|
||||
clutter_brightness_contrast_effect_set_contrast (ClutterBrightnessContrastEffect *effect,
|
||||
|
@ -47,8 +47,6 @@
|
||||
* color->blue / 255.0,
|
||||
* color->alpha / 255.0);
|
||||
* ```
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
void
|
||||
clutter_cairo_set_source_color (cairo_t *cr,
|
||||
@ -75,8 +73,6 @@ clutter_cairo_set_source_color (cairo_t *cr,
|
||||
* @cr: a Cairo context
|
||||
*
|
||||
* Utility function to clear a Cairo context.
|
||||
*
|
||||
* Since: 1.12
|
||||
*/
|
||||
void
|
||||
clutter_cairo_clear (cairo_t *cr)
|
||||
|
@ -36,8 +36,6 @@ G_BEGIN_DECLS
|
||||
* The #CoglPixelFormat to be used when uploading image data from
|
||||
* and to a Cairo image surface using %CAIRO_FORMAT_ARGB32 and
|
||||
* %CAIRO_FORMAT_RGB24 as #cairo_format_t.
|
||||
*
|
||||
* Since: 1.8
|
||||
*/
|
||||
|
||||
/* Cairo stores the data in native byte order as ARGB but Cogl's pixel
|
||||
|
@ -36,9 +36,7 @@
|
||||
* signal when invalidated using clutter_content_invalidate().
|
||||
*
|
||||
* See [canvas.c](https://git.gnome.org/browse/clutter/tree/examples/canvas.c?h=clutter-1.18)
|
||||
* for an example of how to use #ClutterCanvas.
|
||||
*
|
||||
* Since: 1.10.
|
||||
* for an example of how to use #ClutterCanvas..
|
||||
*/
|
||||
|
||||
#include "clutter-build-config.h"
|
||||
@ -234,8 +232,6 @@ clutter_canvas_class_init (ClutterCanvasClass *klass)
|
||||
* ClutterCanvas:width:
|
||||
*
|
||||
* The width of the canvas.
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
obj_props[PROP_WIDTH] =
|
||||
g_param_spec_int ("width",
|
||||
@ -250,8 +246,6 @@ clutter_canvas_class_init (ClutterCanvasClass *klass)
|
||||
* ClutterCanvas:height:
|
||||
*
|
||||
* The height of the canvas.
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
obj_props[PROP_HEIGHT] =
|
||||
g_param_spec_int ("height",
|
||||
@ -292,8 +286,6 @@ clutter_canvas_class_init (ClutterCanvasClass *klass)
|
||||
*
|
||||
* Return value: %TRUE if the signal emission should stop, and
|
||||
* %FALSE otherwise
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
canvas_signals[DRAW] =
|
||||
g_signal_new (I_("draw"),
|
||||
@ -510,8 +502,6 @@ clutter_content_iface_init (ClutterContentInterface *iface)
|
||||
*
|
||||
* Return value: (transfer full): The newly allocated instance of
|
||||
* #ClutterCanvas. Use g_object_unref() when done.
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
ClutterContent *
|
||||
clutter_canvas_new (void)
|
||||
@ -581,8 +571,6 @@ clutter_canvas_invalidate_internal (ClutterCanvas *canvas,
|
||||
*
|
||||
* Return value: this function returns %TRUE if the size change
|
||||
* caused a content invalidation, and %FALSE otherwise
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
gboolean
|
||||
clutter_canvas_set_size (ClutterCanvas *canvas,
|
||||
|
@ -58,8 +58,6 @@ struct _ClutterCanvas
|
||||
*
|
||||
* The #ClutterCanvasClass structure contains
|
||||
* private data.
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
struct _ClutterCanvasClass
|
||||
{
|
||||
|
@ -62,8 +62,6 @@
|
||||
* instantiation by overriding the #ClutterContainerIface virtual functions
|
||||
* #ClutterContainerIface.create_child_meta(), #ClutterContainerIface.destroy_child_meta(),
|
||||
* and #ClutterContainerIface.get_child_meta().
|
||||
*
|
||||
* Since: 0.8
|
||||
*/
|
||||
|
||||
#include "clutter-build-config.h"
|
||||
@ -147,8 +145,6 @@ clutter_child_meta_class_init (ClutterChildMetaClass *klass)
|
||||
* ClutterChildMeta:container:
|
||||
*
|
||||
* The #ClutterContainer that created this #ClutterChildMeta.
|
||||
*
|
||||
* Since: 0.8
|
||||
*/
|
||||
obj_props[PROP_CONTAINER] =
|
||||
g_param_spec_object ("container",
|
||||
@ -162,8 +158,6 @@ clutter_child_meta_class_init (ClutterChildMetaClass *klass)
|
||||
* ClutterChildMeta:actor:
|
||||
*
|
||||
* The #ClutterActor being wrapped by this #ClutterChildMeta
|
||||
*
|
||||
* Since: 0.8
|
||||
*/
|
||||
obj_props[PROP_ACTOR] =
|
||||
g_param_spec_object ("actor",
|
||||
@ -190,8 +184,6 @@ clutter_child_meta_init (ClutterChildMeta *self)
|
||||
* Retrieves the container using @data
|
||||
*
|
||||
* Return value: (transfer none): a #ClutterContainer
|
||||
*
|
||||
* Since: 0.8
|
||||
*/
|
||||
ClutterContainer *
|
||||
clutter_child_meta_get_container (ClutterChildMeta *data)
|
||||
@ -208,8 +200,6 @@ clutter_child_meta_get_container (ClutterChildMeta *data)
|
||||
* Retrieves the actor wrapped by @data
|
||||
*
|
||||
* Return value: (transfer none): a #ClutterActor
|
||||
*
|
||||
* Since: 0.8
|
||||
*/
|
||||
ClutterActor *
|
||||
clutter_child_meta_get_actor (ClutterChildMeta *data)
|
||||
|
@ -60,8 +60,6 @@ struct _ClutterChildMeta
|
||||
* ClutterChildMetaClass:
|
||||
*
|
||||
* The #ClutterChildMetaClass contains only private data
|
||||
*
|
||||
* Since: 0.8
|
||||
*/
|
||||
struct _ClutterChildMetaClass
|
||||
{
|
||||
|
@ -85,8 +85,6 @@
|
||||
* }
|
||||
* }
|
||||
* ```
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
|
||||
#include "clutter-build-config.h"
|
||||
@ -544,8 +542,6 @@ clutter_click_action_class_init (ClutterClickActionClass *klass)
|
||||
* ClutterClickAction:pressed:
|
||||
*
|
||||
* Whether the clickable actor should be in "pressed" state
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
obj_props[PROP_PRESSED] =
|
||||
g_param_spec_boolean ("pressed",
|
||||
@ -558,8 +554,6 @@ clutter_click_action_class_init (ClutterClickActionClass *klass)
|
||||
* ClutterClickAction:held:
|
||||
*
|
||||
* Whether the clickable actor has the pointer grabbed
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
obj_props[PROP_HELD] =
|
||||
g_param_spec_boolean ("held",
|
||||
@ -576,8 +570,6 @@ clutter_click_action_class_init (ClutterClickActionClass *klass)
|
||||
*
|
||||
* A value of -1 will make the #ClutterClickAction use the value of
|
||||
* the [property@Settings:long-press-duration] property.
|
||||
*
|
||||
* Since: 1.8
|
||||
*/
|
||||
obj_props[PROP_LONG_PRESS_DURATION] =
|
||||
g_param_spec_int ("long-press-duration",
|
||||
@ -595,8 +587,6 @@ clutter_click_action_class_init (ClutterClickActionClass *klass)
|
||||
*
|
||||
* A value of -1 will make the #ClutterClickAction use the value of
|
||||
* the [property@Settings:dnd-drag-threshold] property.
|
||||
*
|
||||
* Since: 1.8
|
||||
*/
|
||||
obj_props[PROP_LONG_PRESS_THRESHOLD] =
|
||||
g_param_spec_int ("long-press-threshold",
|
||||
@ -618,8 +608,6 @@ clutter_click_action_class_init (ClutterClickActionClass *klass)
|
||||
* The signal is emitted when the [class@Actor] to which
|
||||
* a #ClutterClickAction has been applied should respond to a
|
||||
* pointer button press and release events
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
click_signals[CLICKED] =
|
||||
g_signal_new (I_("clicked"),
|
||||
@ -654,8 +642,6 @@ clutter_click_action_class_init (ClutterClickActionClass *klass)
|
||||
*
|
||||
* Return value: Only the %CLUTTER_LONG_PRESS_QUERY state uses the
|
||||
* returned value of the handler; other states will ignore it
|
||||
*
|
||||
* Since: 1.8
|
||||
*/
|
||||
click_signals[LONG_PRESS] =
|
||||
g_signal_new (I_("long-press"),
|
||||
@ -685,8 +671,6 @@ clutter_click_action_init (ClutterClickAction *self)
|
||||
* Creates a new #ClutterClickAction instance
|
||||
*
|
||||
* Return value: the newly created #ClutterClickAction
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
ClutterAction *
|
||||
clutter_click_action_new (void)
|
||||
@ -706,8 +690,6 @@ clutter_click_action_new (void)
|
||||
*
|
||||
* This function is useful to break a grab, for instance after a certain
|
||||
* amount of time has passed.
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
void
|
||||
clutter_click_action_release (ClutterClickAction *action)
|
||||
@ -733,8 +715,6 @@ clutter_click_action_release (ClutterClickAction *action)
|
||||
* Retrieves the button that was pressed.
|
||||
*
|
||||
* Return value: the button value
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
guint
|
||||
clutter_click_action_get_button (ClutterClickAction *action)
|
||||
@ -755,8 +735,6 @@ clutter_click_action_get_button (ClutterClickAction *action)
|
||||
* Retrieves the modifier state of the click action.
|
||||
*
|
||||
* Return value: the modifier state parameter, or 0
|
||||
*
|
||||
* Since: 1.6
|
||||
*/
|
||||
ClutterModifierType
|
||||
clutter_click_action_get_state (ClutterClickAction *action)
|
||||
@ -777,8 +755,6 @@ clutter_click_action_get_state (ClutterClickAction *action)
|
||||
* @press_y: (out): return location for the Y coordinate, or %NULL
|
||||
*
|
||||
* Retrieves the screen coordinates of the button press.
|
||||
*
|
||||
* Since: 1.8
|
||||
*/
|
||||
void
|
||||
clutter_click_action_get_coords (ClutterClickAction *action,
|
||||
|
@ -52,8 +52,6 @@ typedef struct _ClutterClickActionPrivate ClutterClickActionPrivate;
|
||||
*
|
||||
* The #ClutterClickActionClass structure
|
||||
* contains only private data
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
struct _ClutterClickActionClass
|
||||
{
|
||||
|
@ -34,8 +34,6 @@
|
||||
* Unlike clutter_texture_new_from_actor(), #ClutterClone does not require
|
||||
* the presence of support for FBOs in the underlying GL or GLES
|
||||
* implementation.
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
|
||||
#include "clutter-build-config.h"
|
||||
@ -355,8 +353,6 @@ clutter_clone_class_init (ClutterCloneClass *klass)
|
||||
* ClutterClone:source:
|
||||
*
|
||||
* This property specifies the source actor being cloned.
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
obj_props[PROP_SOURCE] =
|
||||
g_param_spec_object ("source",
|
||||
@ -385,8 +381,6 @@ clutter_clone_init (ClutterClone *self)
|
||||
* Creates a new #ClutterActor which clones @source/
|
||||
*
|
||||
* Return value: the newly created #ClutterClone
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
ClutterActor *
|
||||
clutter_clone_new (ClutterActor *source)
|
||||
@ -437,8 +431,6 @@ clutter_clone_set_source_internal (ClutterClone *self,
|
||||
* @source: (allow-none): a #ClutterActor, or %NULL
|
||||
*
|
||||
* Sets @source as the source actor to be cloned by @self.
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
void
|
||||
clutter_clone_set_source (ClutterClone *self,
|
||||
@ -458,8 +450,6 @@ clutter_clone_set_source (ClutterClone *self,
|
||||
* Retrieves the source #ClutterActor being cloned by @self.
|
||||
*
|
||||
* Return value: (transfer none): the actor source for the clone
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
ClutterActor *
|
||||
clutter_clone_get_source (ClutterClone *self)
|
||||
|
@ -55,8 +55,6 @@ struct _ClutterClone
|
||||
* ClutterCloneClass:
|
||||
*
|
||||
* The #ClutterCloneClass structure contains only private data
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
struct _ClutterCloneClass
|
||||
{
|
||||
|
@ -98,8 +98,6 @@ static const ClutterColor static_colors[] = {
|
||||
*
|
||||
* Return value: a pointer to a static color; the returned pointer
|
||||
* is owned by Clutter and it should never be modified or freed
|
||||
*
|
||||
* Since: 1.6
|
||||
*/
|
||||
const ClutterColor *
|
||||
clutter_color_get_static (ClutterStaticColor color)
|
||||
@ -637,8 +635,6 @@ parse_hsla (ClutterColor *color,
|
||||
* be fully opaque.
|
||||
*
|
||||
* Return value: %TRUE if parsing succeeded, and %FALSE otherwise
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
gboolean
|
||||
clutter_color_from_string (ClutterColor *color,
|
||||
@ -771,8 +767,6 @@ clutter_color_from_string (ClutterColor *color,
|
||||
* respectively.
|
||||
*
|
||||
* Return value: (transfer full): a newly-allocated text string
|
||||
*
|
||||
* Since: 0.2
|
||||
*/
|
||||
gchar *
|
||||
clutter_color_to_string (const ClutterColor *color)
|
||||
@ -797,8 +791,6 @@ clutter_color_to_string (const ClutterColor *color)
|
||||
* parameter, when using `ClutterColor`s as keys in a #GHashTable.
|
||||
*
|
||||
* Return value: %TRUE if the two colors are the same.
|
||||
*
|
||||
* Since: 0.2
|
||||
*/
|
||||
gboolean
|
||||
clutter_color_equal (gconstpointer v1,
|
||||
@ -831,8 +823,6 @@ clutter_color_equal (gconstpointer v1,
|
||||
* parameter, when using `ClutterColor`s as keys in a #GHashTable.
|
||||
*
|
||||
* Return value: a hash value corresponding to the color
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
guint
|
||||
clutter_color_hash (gconstpointer v)
|
||||
@ -849,8 +839,6 @@ clutter_color_hash (gconstpointer v)
|
||||
*
|
||||
* Interpolates between @initial and @final `ClutterColor`s
|
||||
* using @progress
|
||||
*
|
||||
* Since: 1.6
|
||||
*/
|
||||
void
|
||||
clutter_color_interpolate (const ClutterColor *initial,
|
||||
@ -892,8 +880,6 @@ clutter_color_progress (const GValue *a,
|
||||
* freed using clutter_color_free().
|
||||
*
|
||||
* Return value: (transfer full): an allocated copy of @color.
|
||||
*
|
||||
* Since: 0.2
|
||||
*/
|
||||
ClutterColor *
|
||||
clutter_color_copy (const ClutterColor *color)
|
||||
@ -909,8 +895,6 @@ clutter_color_copy (const ClutterColor *color)
|
||||
* @color: a #ClutterColor
|
||||
*
|
||||
* Frees a color structure created with clutter_color_copy().
|
||||
*
|
||||
* Since: 0.2
|
||||
*/
|
||||
void
|
||||
clutter_color_free (ClutterColor *color)
|
||||
@ -936,8 +920,6 @@ clutter_color_free (ClutterColor *color)
|
||||
*
|
||||
* Return value: (transfer full): the newly allocated color.
|
||||
* Use clutter_color_free() when done
|
||||
*
|
||||
* Since: 0.8
|
||||
*/
|
||||
ClutterColor *
|
||||
clutter_color_new (guint8 red,
|
||||
@ -959,8 +941,6 @@ clutter_color_new (guint8 red,
|
||||
*
|
||||
* Return value: (transfer full): the newly allocated #ClutterColor; use
|
||||
* clutter_color_free() to free its resources
|
||||
*
|
||||
* Since: 1.12
|
||||
*/
|
||||
ClutterColor *
|
||||
clutter_color_alloc (void)
|
||||
@ -979,8 +959,6 @@ clutter_color_alloc (void)
|
||||
* Initializes @color with the given values.
|
||||
*
|
||||
* Return value: (transfer none): the initialized #ClutterColor
|
||||
*
|
||||
* Since: 1.12
|
||||
*/
|
||||
ClutterColor *
|
||||
clutter_color_init (ClutterColor *color,
|
||||
@ -1046,8 +1024,6 @@ G_DEFINE_BOXED_TYPE_WITH_CODE (ClutterColor, clutter_color,
|
||||
* @color: the color to set
|
||||
*
|
||||
* Sets @value to @color.
|
||||
*
|
||||
* Since: 0.8
|
||||
*/
|
||||
void
|
||||
clutter_value_set_color (GValue *value,
|
||||
@ -1065,8 +1041,6 @@ clutter_value_set_color (GValue *value,
|
||||
* Gets the #ClutterColor contained in @value.
|
||||
*
|
||||
* Return value: (transfer none): the color inside the passed #GValue
|
||||
*
|
||||
* Since: 0.8
|
||||
*/
|
||||
const ClutterColor *
|
||||
clutter_value_get_color (const GValue *value)
|
||||
@ -1160,8 +1134,6 @@ clutter_param_color_get_type (void)
|
||||
* Creates a #GParamSpec for properties using #ClutterColor.
|
||||
*
|
||||
* Return value: the newly created #GParamSpec
|
||||
*
|
||||
* Since: 0.8
|
||||
*/
|
||||
GParamSpec *
|
||||
clutter_param_spec_color (const gchar *name,
|
||||
|
@ -68,8 +68,6 @@ struct _ClutterColor
|
||||
* @a: value for the alpha channel, between 0 and 255
|
||||
*
|
||||
* A macro that initializes a #ClutterColor, to be used when declaring it.
|
||||
*
|
||||
* Since: 1.12
|
||||
*/
|
||||
#define CLUTTER_COLOR_INIT(r,g,b,a) { (r), (g), (b), (a) }
|
||||
|
||||
@ -157,8 +155,6 @@ void clutter_color_interpolate (const ClutterColor *initial,
|
||||
* @x: a #GValue
|
||||
*
|
||||
* Evaluates to %TRUE if @x holds a `ClutterColor`.
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
#define CLUTTER_VALUE_HOLDS_COLOR(x) (G_VALUE_HOLDS ((x), CLUTTER_TYPE_COLOR))
|
||||
|
||||
@ -170,8 +166,6 @@ typedef struct _ClutterParamSpecColor ClutterParamSpecColor;
|
||||
*
|
||||
* A #GParamSpec subclass for defining properties holding
|
||||
* a #ClutterColor.
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
struct _ClutterParamSpecColor
|
||||
{
|
||||
|
@ -29,8 +29,6 @@
|
||||
*
|
||||
* #ClutterColorizeEffect is a sub-class of #ClutterEffect that
|
||||
* colorizes an actor with the given tint.
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
|
||||
#define CLUTTER_COLORIZE_EFFECT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), CLUTTER_TYPE_COLORIZE_EFFECT, ClutterColorizeEffectClass))
|
||||
@ -182,8 +180,6 @@ clutter_colorize_effect_class_init (ClutterColorizeEffectClass *klass)
|
||||
* ClutterColorizeEffect:tint:
|
||||
*
|
||||
* The tint to apply to the actor
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
obj_props[PROP_TINT] =
|
||||
clutter_param_spec_color ("tint",
|
||||
@ -254,8 +250,6 @@ clutter_colorize_effect_init (ClutterColorizeEffect *self)
|
||||
* clutter_actor_add_effect()
|
||||
*
|
||||
* Return value: the newly created #ClutterColorizeEffect or %NULL
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
ClutterEffect *
|
||||
clutter_colorize_effect_new (const ClutterColor *tint)
|
||||
@ -271,8 +265,6 @@ clutter_colorize_effect_new (const ClutterColor *tint)
|
||||
* @tint: the color to be used
|
||||
*
|
||||
* Sets the tint to be used when colorizing
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
void
|
||||
clutter_colorize_effect_set_tint (ClutterColorizeEffect *effect,
|
||||
@ -295,8 +287,6 @@ clutter_colorize_effect_set_tint (ClutterColorizeEffect *effect,
|
||||
* @tint: (out caller-allocates): return location for the color used
|
||||
*
|
||||
* Retrieves the tint used by @effect
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
void
|
||||
clutter_colorize_effect_get_tint (ClutterColorizeEffect *effect,
|
||||
|
@ -123,8 +123,6 @@
|
||||
* call clutter_actor_queue_relayout() on the actor to which it is attached
|
||||
* to whenever any parameter is changed. The actor to which it is attached
|
||||
* can be recovered at any point using clutter_actor_meta_get_actor().
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
|
||||
#include "clutter-build-config.h"
|
||||
|
@ -58,8 +58,6 @@ struct _ClutterConstraint
|
||||
*
|
||||
* The #ClutterConstraintClass structure contains
|
||||
* only private data
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
struct _ClutterConstraintClass
|
||||
{
|
||||
|
@ -71,8 +71,6 @@
|
||||
* it provides some common API for notifying when a child actor is added
|
||||
* or removed, as well as the infrastructure for accessing child properties
|
||||
* through [class@ChildMeta].
|
||||
*
|
||||
* Since: 0.4
|
||||
*/
|
||||
|
||||
enum
|
||||
@ -130,8 +128,6 @@ clutter_container_default_init (ClutterContainerInterface *iface)
|
||||
*
|
||||
* The signal is emitted each time an actor
|
||||
* has been added to @container.
|
||||
*
|
||||
* Since: 0.4
|
||||
*/
|
||||
container_signals[ACTOR_ADDED] =
|
||||
g_signal_new (I_("actor-added"),
|
||||
@ -148,8 +144,6 @@ clutter_container_default_init (ClutterContainerInterface *iface)
|
||||
*
|
||||
* The signal is emitted each time an actor
|
||||
* is removed from @container.
|
||||
*
|
||||
* Since: 0.4
|
||||
*/
|
||||
container_signals[ACTOR_REMOVED] =
|
||||
g_signal_new (I_("actor-removed"),
|
||||
@ -169,8 +163,6 @@ clutter_container_default_init (ClutterContainerInterface *iface)
|
||||
* The signal is emitted each time a property is
|
||||
* being set through the clutter_container_child_set() and
|
||||
* clutter_container_child_set_property() calls.
|
||||
*
|
||||
* Since: 0.8
|
||||
*/
|
||||
container_signals[CHILD_NOTIFY] =
|
||||
g_signal_new (I_("child-notify"),
|
||||
@ -306,8 +298,6 @@ container_remove_valist (ClutterContainer *container,
|
||||
* deprecated virtual function. The default implementation will
|
||||
* call clutter_actor_add_child().
|
||||
*
|
||||
* Since: 0.4
|
||||
*
|
||||
* Deprecated: 1.10: Use clutter_actor_add_child() instead.
|
||||
*/
|
||||
void
|
||||
@ -339,8 +329,6 @@ clutter_container_add (ClutterContainer *container,
|
||||
* deprecated virtual function. The default implementation will
|
||||
* call clutter_actor_add_child().
|
||||
*
|
||||
* Since: 0.4
|
||||
*
|
||||
* Deprecated: 1.10: Use clutter_actor_add_child() instead.
|
||||
*/
|
||||
void
|
||||
@ -369,8 +357,6 @@ clutter_container_add_actor (ClutterContainer *container,
|
||||
* deprecated virtual function. The default implementation will call
|
||||
* clutter_actor_remove_child().
|
||||
*
|
||||
* Since: 0.4
|
||||
*
|
||||
* Deprecated: 1.10: Use clutter_actor_remove_child() instead.
|
||||
*/
|
||||
void
|
||||
@ -402,8 +388,6 @@ clutter_container_remove (ClutterContainer *container,
|
||||
* deprecated virtual function. The default implementation will call
|
||||
* clutter_actor_remove_child().
|
||||
*
|
||||
* Since: 0.4
|
||||
*
|
||||
* Deprecated: 1.10: Use clutter_actor_remove_child() instead.
|
||||
*/
|
||||
void
|
||||
@ -426,8 +410,6 @@ clutter_container_remove_actor (ClutterContainer *container,
|
||||
*
|
||||
* Return value: (transfer none): The child actor with the requested name,
|
||||
* or %NULL if no actor with that name was found.
|
||||
*
|
||||
* Since: 0.6
|
||||
*/
|
||||
ClutterActor *
|
||||
clutter_container_find_child_by_name (ClutterContainer *container,
|
||||
@ -538,8 +520,6 @@ destroy_child_meta (ClutterContainer *container,
|
||||
* Return value: (transfer none): the #ClutterChildMeta for the @actor child
|
||||
* of @container or %NULL if the specifiec actor does not exist or the
|
||||
* container is not configured to provide `ClutterChildMeta`s
|
||||
*
|
||||
* Since: 0.8
|
||||
*/
|
||||
ClutterChildMeta *
|
||||
clutter_container_get_child_meta (ClutterContainer *container,
|
||||
@ -570,8 +550,6 @@ clutter_container_get_child_meta (ClutterContainer *container,
|
||||
* #ClutterContainer::add() virtual function implementation.
|
||||
*
|
||||
* Applications should not call this function.
|
||||
*
|
||||
* Since: 1.2
|
||||
*/
|
||||
void
|
||||
clutter_container_create_child_meta (ClutterContainer *container,
|
||||
@ -606,8 +584,6 @@ clutter_container_create_child_meta (ClutterContainer *container,
|
||||
* #ClutterContainer::add() virtual function implementation.
|
||||
*
|
||||
* Applications should not call this function.
|
||||
*
|
||||
* Since: 1.2
|
||||
*/
|
||||
void
|
||||
clutter_container_destroy_child_meta (ClutterContainer *container,
|
||||
@ -636,8 +612,6 @@ clutter_container_destroy_child_meta (ClutterContainer *container,
|
||||
*
|
||||
* Return value: (transfer none): The #GParamSpec for the property or %NULL
|
||||
* if no such property exist.
|
||||
*
|
||||
* Since: 0.8
|
||||
*/
|
||||
GParamSpec *
|
||||
clutter_container_class_find_child_property (GObjectClass *klass,
|
||||
@ -675,8 +649,6 @@ clutter_container_class_find_child_property (GObjectClass *klass,
|
||||
*
|
||||
* Return value: (array length=n_properties) (transfer full): an array
|
||||
* of `GParamSpec`s which should be freed after use.
|
||||
*
|
||||
* Since: 0.8
|
||||
*/
|
||||
GParamSpec **
|
||||
clutter_container_class_list_child_properties (GObjectClass *klass,
|
||||
@ -737,8 +709,6 @@ container_set_child_property (ClutterContainer *container,
|
||||
* @value: the value.
|
||||
*
|
||||
* Sets a container-specific property on a child of @container.
|
||||
*
|
||||
* Since: 0.8
|
||||
*/
|
||||
void
|
||||
clutter_container_child_set_property (ClutterContainer *container,
|
||||
@ -785,8 +755,6 @@ clutter_container_child_set_property (ClutterContainer *container,
|
||||
* pairs terminated with NULL.
|
||||
*
|
||||
* Sets container specific properties on the child of a container.
|
||||
*
|
||||
* Since: 0.8
|
||||
*/
|
||||
void
|
||||
clutter_container_child_set (ClutterContainer *container,
|
||||
@ -880,8 +848,6 @@ container_get_child_property (ClutterContainer *container,
|
||||
* Note that clutter_container_child_set_property() is really intended for
|
||||
* language bindings, clutter_container_child_set() is much more convenient
|
||||
* for C programming.
|
||||
*
|
||||
* Since: 0.8
|
||||
*/
|
||||
void
|
||||
clutter_container_child_get_property (ClutterContainer *container,
|
||||
@ -933,8 +899,6 @@ clutter_container_child_get_property (ClutterContainer *container,
|
||||
* In general, a copy is made of the property contents and the caller is
|
||||
* responsible for freeing the memory in the appropriate manner for the type, for
|
||||
* instance by calling g_free() or g_object_unref().
|
||||
*
|
||||
* Since: 0.8
|
||||
*/
|
||||
void
|
||||
clutter_container_child_get (ClutterContainer *container,
|
||||
@ -1005,8 +969,6 @@ clutter_container_child_get (ClutterContainer *container,
|
||||
* Calls the #ClutterContainerIface.child_notify() virtual function
|
||||
* of #ClutterContainer. The default implementation will emit the
|
||||
* #ClutterContainer::child-notify signal.
|
||||
*
|
||||
* Since: 1.6
|
||||
*/
|
||||
void
|
||||
clutter_container_child_notify (ClutterContainer *container,
|
||||
|
@ -67,8 +67,6 @@ typedef struct _ClutterContainerIface ClutterContainerIface;
|
||||
* Base interface for container actors. The @add and @remove
|
||||
* virtual functions must be provided by any implementation; the other
|
||||
* virtual functions are optional.
|
||||
*
|
||||
* Since: 0.4
|
||||
*/
|
||||
struct _ClutterContainerIface
|
||||
{
|
||||
|
@ -31,9 +31,7 @@
|
||||
* painting the content of a [class@Actor].
|
||||
*
|
||||
* Multiple actors can use the same #ClutterContent instance, in order
|
||||
* to share the resources associated with painting the same content.
|
||||
*
|
||||
* Since: 1.10.
|
||||
* to share the resources associated with painting the same content..
|
||||
*/
|
||||
|
||||
#include "clutter-build-config.h"
|
||||
@ -122,8 +120,6 @@ clutter_content_default_init (ClutterContentInterface *iface)
|
||||
*
|
||||
* This signal is emitted each time a #ClutterContent implementation is
|
||||
* assigned to a #ClutterActor.
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
content_signals[ATTACHED] =
|
||||
g_signal_new (I_("attached"),
|
||||
@ -141,8 +137,6 @@ clutter_content_default_init (ClutterContentInterface *iface)
|
||||
*
|
||||
* This signal is emitted each time a #ClutterContent implementation is
|
||||
* removed from a #ClutterActor.
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
content_signals[DETACHED] =
|
||||
g_signal_new (I_("detached"),
|
||||
@ -163,8 +157,6 @@ clutter_content_default_init (ClutterContentInterface *iface)
|
||||
* This function should be called by #ClutterContent implementations when
|
||||
* they change the way a the content should be painted regardless of the
|
||||
* actor state.
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
void
|
||||
clutter_content_invalidate (ClutterContent *content)
|
||||
@ -333,8 +325,6 @@ _clutter_content_paint_content (ClutterContent *content,
|
||||
*
|
||||
* Return value: %TRUE if the content has a preferred size, and %FALSE
|
||||
* otherwise
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
gboolean
|
||||
clutter_content_get_preferred_size (ClutterContent *content,
|
||||
|
@ -53,8 +53,6 @@ G_DECLARE_INTERFACE (ClutterContent, clutter_content, CLUTTER, CONTENT, GObject)
|
||||
*
|
||||
* The #ClutterContentInterface structure contains only
|
||||
* private data.
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
struct _ClutterContentInterface
|
||||
{
|
||||
|
@ -46,8 +46,6 @@
|
||||
* Each passed vertex is an in-out parameter that initially contains the
|
||||
* position of the vertex and should be modified according to a specific
|
||||
* deformation algorithm.
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
|
||||
#include "clutter-build-config.h"
|
||||
@ -595,8 +593,6 @@ clutter_deform_effect_class_init (ClutterDeformEffectClass *klass)
|
||||
*
|
||||
* The number of horizontal tiles. The bigger the number, the
|
||||
* smaller the tiles
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
obj_props[PROP_X_TILES] =
|
||||
g_param_spec_uint ("x-tiles",
|
||||
@ -611,8 +607,6 @@ clutter_deform_effect_class_init (ClutterDeformEffectClass *klass)
|
||||
*
|
||||
* The number of vertical tiles. The bigger the number, the
|
||||
* smaller the tiles
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
obj_props[PROP_Y_TILES] =
|
||||
g_param_spec_uint ("y-tiles",
|
||||
@ -629,8 +623,6 @@ clutter_deform_effect_class_init (ClutterDeformEffectClass *klass)
|
||||
* to which this effect has been applied
|
||||
*
|
||||
* By default, no material will be used
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
obj_props[PROP_BACK_MATERIAL] =
|
||||
g_param_spec_boxed ("back-material",
|
||||
@ -671,8 +663,6 @@ clutter_deform_effect_init (ClutterDeformEffect *self)
|
||||
*
|
||||
* The #ClutterDeformEffect will take a reference on the material's
|
||||
* handle
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
void
|
||||
clutter_deform_effect_set_back_material (ClutterDeformEffect *effect,
|
||||
@ -704,8 +694,6 @@ clutter_deform_effect_set_back_material (ClutterDeformEffect *effect,
|
||||
* Return value: (transfer none): a handle for the material, or %NULL.
|
||||
* The returned material is owned by the #ClutterDeformEffect and it
|
||||
* should not be freed directly
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
CoglHandle
|
||||
clutter_deform_effect_get_back_material (ClutterDeformEffect *effect)
|
||||
@ -726,8 +714,6 @@ clutter_deform_effect_get_back_material (ClutterDeformEffect *effect)
|
||||
*
|
||||
* More tiles allow a finer grained deformation at the expenses
|
||||
* of computation
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
void
|
||||
clutter_deform_effect_set_n_tiles (ClutterDeformEffect *effect,
|
||||
@ -781,8 +767,6 @@ clutter_deform_effect_set_n_tiles (ClutterDeformEffect *effect,
|
||||
*
|
||||
* Retrieves the number of horizontal and vertical tiles used to sub-divide
|
||||
* the actor's geometry during the effect
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
void
|
||||
clutter_deform_effect_get_n_tiles (ClutterDeformEffect *effect,
|
||||
@ -804,8 +788,6 @@ clutter_deform_effect_get_n_tiles (ClutterDeformEffect *effect,
|
||||
*
|
||||
* Invalidates the `effect`'s vertices and, if it is associated
|
||||
* to an actor, it will queue a redraw
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
void
|
||||
clutter_deform_effect_invalidate (ClutterDeformEffect *effect)
|
||||
|
@ -60,8 +60,6 @@ struct _ClutterDeformEffect
|
||||
*
|
||||
* The #ClutterDeformEffectClass structure contains
|
||||
* only private data
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
struct _ClutterDeformEffectClass
|
||||
{
|
||||
|
@ -31,8 +31,6 @@
|
||||
* desaturates the color of an actor and its contents. The strength
|
||||
* of the desaturation effect is controllable and animatable through
|
||||
* the #ClutterDesaturateEffect:factor property.
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
|
||||
#define CLUTTER_DESATURATE_EFFECT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), CLUTTER_TYPE_DESATURATE_EFFECT, ClutterDesaturateEffectClass))
|
||||
@ -199,8 +197,6 @@ clutter_desaturate_effect_class_init (ClutterDesaturateEffectClass *klass)
|
||||
*
|
||||
* The desaturation factor, between 0.0 (no desaturation) and 1.0 (full
|
||||
* desaturation).
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
obj_props[PROP_FACTOR] =
|
||||
g_param_spec_double ("factor",
|
||||
@ -257,8 +253,6 @@ clutter_desaturate_effect_init (ClutterDesaturateEffect *self)
|
||||
* clutter_actor_add_effect()
|
||||
*
|
||||
* Return value: the newly created #ClutterDesaturateEffect or %NULL
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
ClutterEffect *
|
||||
clutter_desaturate_effect_new (gdouble factor)
|
||||
@ -277,8 +271,6 @@ clutter_desaturate_effect_new (gdouble factor)
|
||||
*
|
||||
* Sets the desaturation factor for @effect, with 0.0 being "do not desaturate"
|
||||
* and 1.0 being "fully desaturate"
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
void
|
||||
clutter_desaturate_effect_set_factor (ClutterDesaturateEffect *effect,
|
||||
@ -305,8 +297,6 @@ clutter_desaturate_effect_set_factor (ClutterDesaturateEffect *effect,
|
||||
* Retrieves the desaturation factor of @effect
|
||||
*
|
||||
* Return value: the desaturation factor
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
gdouble
|
||||
clutter_desaturate_effect_get_factor (ClutterDesaturateEffect *effect)
|
||||
|
@ -157,8 +157,6 @@
|
||||
* klass->paint = my_effect_paint;
|
||||
* }
|
||||
* ```
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
|
||||
#include "clutter-build-config.h"
|
||||
@ -378,8 +376,6 @@ _clutter_effect_has_custom_paint_volume (ClutterEffect *effect)
|
||||
* one then that will override this call. In that case this effect
|
||||
* will instead be called with the %CLUTTER_EFFECT_PAINT_ACTOR_DIRTY
|
||||
* flag set.
|
||||
*
|
||||
* Since: 1.8
|
||||
*/
|
||||
void
|
||||
clutter_effect_queue_repaint (ClutterEffect *effect)
|
||||
|
@ -59,8 +59,6 @@ struct _ClutterEffect
|
||||
* @pick: virtual function
|
||||
*
|
||||
* The #ClutterEffectClass structure contains only private data
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
struct _ClutterEffectClass
|
||||
{
|
||||
|
@ -49,8 +49,6 @@ G_BEGIN_DECLS
|
||||
* an actor is scaled keeping the position of the specified portion
|
||||
* at the same coordinates.
|
||||
*
|
||||
* Since: 0.2
|
||||
*
|
||||
* Deprecated: 1.22: Use the normalized #ClutterActor pivot point instead
|
||||
*/
|
||||
typedef enum /*< prefix=CLUTTER_GRAVITY >*/
|
||||
@ -74,8 +72,6 @@ typedef enum /*< prefix=CLUTTER_GRAVITY >*/
|
||||
* @CLUTTER_Z_AXIS: Rotate around the Z axis
|
||||
*
|
||||
* Axis of a rotation.
|
||||
*
|
||||
* Since: 0.4
|
||||
*/
|
||||
typedef enum /*< prefix=CLUTTER >*/
|
||||
{
|
||||
@ -91,8 +87,6 @@ typedef enum /*< prefix=CLUTTER >*/
|
||||
*
|
||||
* Direction of a rotation.
|
||||
*
|
||||
* Since: 0.4
|
||||
*
|
||||
* Deprecated: 1.22
|
||||
*/
|
||||
typedef enum /*< prefix=CLUTTER_ROTATE >*/
|
||||
@ -109,8 +103,6 @@ typedef enum /*< prefix=CLUTTER_ROTATE >*/
|
||||
* #ClutterContent, if it has any (available since 1.22)
|
||||
*
|
||||
* Specifies the type of requests for a #ClutterActor.
|
||||
*
|
||||
* Since: 0.8
|
||||
*/
|
||||
typedef enum /*< prefix=CLUTTER_REQUEST >*/
|
||||
{
|
||||
@ -204,8 +196,6 @@ typedef enum /*< prefix=CLUTTER_REQUEST >*/
|
||||
* Every global alpha function registered using clutter_alpha_register_func()
|
||||
* or clutter_alpha_register_closure() will have a logical id greater than
|
||||
* %CLUTTER_ANIMATION_LAST.
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
typedef enum
|
||||
{
|
||||
@ -288,8 +278,6 @@ typedef enum
|
||||
* @CLUTTER_TEXT_DIRECTION_RTL: Use right-to-left text direction
|
||||
*
|
||||
* The text direction to be used by [class@Actor]s
|
||||
*
|
||||
* Since: 1.2
|
||||
*/
|
||||
typedef enum
|
||||
{
|
||||
@ -304,8 +292,6 @@ typedef enum
|
||||
* @CLUTTER_FRAGMENT_SHADER: a fragment shader
|
||||
*
|
||||
* The type of GLSL shader program
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
typedef enum
|
||||
{
|
||||
@ -340,8 +326,6 @@ typedef enum
|
||||
* reserved values such as %CLUTTER_MODIFIER_RESERVED_13_MASK. Your code
|
||||
* should preserve and ignore them. You can use %CLUTTER_MODIFIER_MASK to
|
||||
* remove all reserved values.
|
||||
*
|
||||
* Since: 0.4
|
||||
*/
|
||||
typedef enum
|
||||
{
|
||||
@ -509,8 +493,6 @@ typedef enum /*< prefix=CLUTTER_ACTOR >*/
|
||||
* on stage.
|
||||
*
|
||||
* Possible flags to pass to clutter_actor_set_offscreen_redirect().
|
||||
*
|
||||
* Since: 1.8
|
||||
*/
|
||||
typedef enum /*< prefix=CLUTTER_OFFSCREEN_REDIRECT >*/
|
||||
{
|
||||
@ -527,8 +509,6 @@ typedef enum /*< prefix=CLUTTER_OFFSCREEN_REDIRECT >*/
|
||||
*
|
||||
* Specifies the axis on which #ClutterAlignConstraint should maintain
|
||||
* the alignment.
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
typedef enum /*< prefix=CLUTTER_ALIGN >*/
|
||||
{
|
||||
@ -544,8 +524,6 @@ typedef enum /*< prefix=CLUTTER_ALIGN >*/
|
||||
*
|
||||
* The mode of interpolation between key frames
|
||||
*
|
||||
* Since: 1.2
|
||||
*
|
||||
* Deprecated: 1.22
|
||||
*/
|
||||
typedef enum
|
||||
@ -569,8 +547,6 @@ typedef enum
|
||||
*
|
||||
* The alignment policies available on each axis for #ClutterBinLayout
|
||||
*
|
||||
* Since: 1.2
|
||||
*
|
||||
* Deprecated: 1.12: Use #ClutterActorAlign and the #ClutterActor
|
||||
* API instead
|
||||
*/
|
||||
@ -597,8 +573,6 @@ typedef enum
|
||||
* %CLUTTER_BIND_SIZE (added in Clutter 1.10)
|
||||
*
|
||||
* Specifies which property should be used in a binding
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
typedef enum /*< prefix=CLUTTER_BIND >*/
|
||||
{
|
||||
@ -637,8 +611,6 @@ typedef enum /*< prefix=CLUTTER_EFFECT_PAINT >*/
|
||||
* the right, depending on the used axis
|
||||
*
|
||||
* The alignment policies available on each axis of the #ClutterBoxLayout
|
||||
*
|
||||
* Since: 1.2
|
||||
*/
|
||||
typedef enum
|
||||
{
|
||||
@ -655,8 +627,6 @@ typedef enum
|
||||
* @CLUTTER_LONG_PRESS_CANCEL: The long press was cancelled
|
||||
*
|
||||
* The states for the #ClutterClickAction::long-press signal.
|
||||
*
|
||||
* Since: 1.8
|
||||
*/
|
||||
typedef enum /*< prefix=CLUTTER_LONG_PRESS >*/
|
||||
{
|
||||
@ -714,8 +684,6 @@ typedef enum /*< prefix=CLUTTER_LONG_PRESS >*/
|
||||
* @CLUTTER_COLOR_TRANSPARENT: Transparent color (00000000)
|
||||
*
|
||||
* Named colors, for accessing global colors defined by Clutter
|
||||
*
|
||||
* Since: 1.6
|
||||
*/
|
||||
typedef enum /*< prefix=CLUTTER_COLOR >*/
|
||||
{
|
||||
@ -779,8 +747,6 @@ typedef enum /*< prefix=CLUTTER_COLOR >*/
|
||||
*
|
||||
* The axis of the constraint that should be applied on the
|
||||
* dragging action
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
typedef enum /*< prefix=CLUTTER_DRAG >*/
|
||||
{
|
||||
@ -797,8 +763,6 @@ typedef enum /*< prefix=CLUTTER_DRAG >*/
|
||||
* @CLUTTER_EVENT_FLAG_REPEATED: Auto-repeated event
|
||||
*
|
||||
* Flags for the #ClutterEvent
|
||||
*
|
||||
* Since: 0.6
|
||||
*/
|
||||
typedef enum /*< flags prefix=CLUTTER_EVENT >*/
|
||||
{
|
||||
@ -846,8 +810,6 @@ typedef enum /*< flags prefix=CLUTTER_EVENT >*/
|
||||
* added in 1.10
|
||||
*
|
||||
* Types of events.
|
||||
*
|
||||
* Since: 0.4
|
||||
*/
|
||||
typedef enum /*< prefix=CLUTTER >*/
|
||||
{
|
||||
@ -894,8 +856,6 @@ typedef enum /*< prefix=CLUTTER >*/
|
||||
*
|
||||
* The %CLUTTER_SCROLL_SMOOTH value implies that the #ClutterScrollEvent
|
||||
* has precise scrolling delta information.
|
||||
*
|
||||
* Since: 0.4
|
||||
*/
|
||||
typedef enum /*< prefix=CLUTTER_SCROLL >*/
|
||||
{
|
||||
@ -915,8 +875,6 @@ typedef enum /*< prefix=CLUTTER_SCROLL >*/
|
||||
*
|
||||
* The direction of the arrangement of the children inside
|
||||
* a #ClutterFlowLayout
|
||||
*
|
||||
* Since: 1.2
|
||||
*/
|
||||
typedef enum /*< prefix=CLUTTER_FLOW >*/
|
||||
{
|
||||
@ -966,8 +924,6 @@ typedef enum /*< prefix=CLUTTER_INPUT_CAPABILITY >*/
|
||||
*
|
||||
* The #ClutterInputDeviceType enumeration can be extended at later
|
||||
* date; not every platform supports every input device type.
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
typedef enum
|
||||
{
|
||||
@ -995,8 +951,6 @@ typedef enum
|
||||
* to a logical device
|
||||
*
|
||||
* The mode for input devices available.
|
||||
*
|
||||
* Since: 1.6
|
||||
*/
|
||||
typedef enum
|
||||
{
|
||||
@ -1021,8 +975,6 @@ typedef enum
|
||||
* useful when iterating over the enumeration values (Since 1.12)
|
||||
*
|
||||
* The type of axes Clutter recognizes on a #ClutterInputDevice
|
||||
*
|
||||
* Since: 1.6
|
||||
*/
|
||||
typedef enum
|
||||
{
|
||||
@ -1063,8 +1015,6 @@ typedef enum
|
||||
* @CLUTTER_SNAP_EDGE_LEFT: the left edge
|
||||
*
|
||||
* The edge to snap
|
||||
*
|
||||
* Since: 1.6
|
||||
*/
|
||||
typedef enum
|
||||
{
|
||||
@ -1081,8 +1031,6 @@ typedef enum
|
||||
* @CLUTTER_PICK_ALL: Paint all actors
|
||||
*
|
||||
* Controls the paint cycle of the scene graph when in pick mode
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
typedef enum
|
||||
{
|
||||
@ -1099,8 +1047,6 @@ typedef enum
|
||||
* @CLUTTER_SWIPE_DIRECTION_RIGHT: Rightwards swipe gesture
|
||||
*
|
||||
* The main direction of the swipe gesture
|
||||
*
|
||||
* Since: 1.8
|
||||
*/
|
||||
typedef enum /*< prefix=CLUTTER_SWIPE_DIRECTION >*/
|
||||
{
|
||||
@ -1120,8 +1066,6 @@ typedef enum /*< prefix=CLUTTER_SWIPE_DIRECTION >*/
|
||||
*
|
||||
* The axis of the constraint that should be applied on the
|
||||
* panning action
|
||||
*
|
||||
* Since: 1.12
|
||||
*/
|
||||
typedef enum /*< prefix=CLUTTER_PAN >*/
|
||||
{
|
||||
@ -1142,8 +1086,6 @@ typedef enum /*< prefix=CLUTTER_PAN >*/
|
||||
*
|
||||
* Flags for clutter_texture_set_from_rgb_data().
|
||||
*
|
||||
* Since: 0.4
|
||||
*
|
||||
* Deprecated: 1.22: The #ClutterTexture class was the only user of
|
||||
* this API
|
||||
*/
|
||||
@ -1166,8 +1108,6 @@ typedef enum /*< prefix=CLUTTER_TEXTURE >*/
|
||||
*
|
||||
* Enumaration controlling the texture quality.
|
||||
*
|
||||
* Since: 0.8
|
||||
*
|
||||
* Deprecated: 1.22: The #ClutterTexture class was the only user of
|
||||
* this API; use #ClutterImage and clutter_actor_set_content_scaling_filters()
|
||||
* instead.
|
||||
@ -1185,8 +1125,6 @@ typedef enum /*< prefix=CLUTTER_TEXTURE_QUALITY >*/
|
||||
* @CLUTTER_TIMELINE_BACKWARD: backward direction for a timeline
|
||||
*
|
||||
* The direction of a #ClutterTimeline
|
||||
*
|
||||
* Since: 0.6
|
||||
*/
|
||||
typedef enum
|
||||
{
|
||||
@ -1205,8 +1143,6 @@ typedef enum
|
||||
* The type of unit in which a value is expressed
|
||||
*
|
||||
* This enumeration might be expanded at later date
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
typedef enum /*< prefix=CLUTTER_UNIT >*/
|
||||
{
|
||||
@ -1236,8 +1172,6 @@ typedef enum /*< prefix=CLUTTER_UNIT >*/
|
||||
* coordinates relative to the last node.
|
||||
*
|
||||
* Types of nodes in a #ClutterPath.
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
typedef enum
|
||||
{
|
||||
@ -1268,8 +1202,6 @@ typedef enum
|
||||
* Alignment only matters if the allocated space given to an actor is
|
||||
* bigger than its natural size; for example, when the #ClutterActor:x-expand
|
||||
* or the #ClutterActor:y-expand properties of #ClutterActor are set to %TRUE.
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
typedef enum
|
||||
{
|
||||
@ -1287,8 +1219,6 @@ typedef enum
|
||||
* painting the stages
|
||||
*
|
||||
* Flags to pass to clutter_threads_add_repaint_func_full().
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
typedef enum
|
||||
{
|
||||
@ -1312,8 +1242,6 @@ typedef enum
|
||||
* allocation, while maintaining the aspect ratio
|
||||
*
|
||||
* Controls the alignment of the #ClutterContent inside a #ClutterActor.
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
typedef enum
|
||||
{
|
||||
@ -1343,8 +1271,6 @@ typedef enum
|
||||
*
|
||||
* The scaling filters to be used with the [property@Actor:minification-filter]
|
||||
* and [property@Actor:magnification-filter] properties.
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
typedef enum
|
||||
{
|
||||
@ -1359,8 +1285,6 @@ typedef enum
|
||||
* @CLUTTER_ORIENTATION_VERTICAL: A vertical orientation
|
||||
*
|
||||
* Represents the orientation of actors or layout managers.
|
||||
*
|
||||
* Since: 1.12
|
||||
*/
|
||||
typedef enum
|
||||
{
|
||||
@ -1376,8 +1300,6 @@ typedef enum
|
||||
* @CLUTTER_SCROLL_BOTH: Scroll in both directions
|
||||
*
|
||||
* Scroll modes.
|
||||
*
|
||||
* Since: 1.12
|
||||
*/
|
||||
typedef enum /*< prefix=CLUTTER_SCROLL >*/
|
||||
{
|
||||
@ -1397,8 +1319,6 @@ typedef enum /*< prefix=CLUTTER_SCROLL >*/
|
||||
* @CLUTTER_GRID_POSITION_BOTTOM: bottom position
|
||||
*
|
||||
* Grid position modes.
|
||||
*
|
||||
* Since: 1.12
|
||||
*/
|
||||
typedef enum
|
||||
{
|
||||
@ -1416,8 +1336,6 @@ typedef enum
|
||||
* @CLUTTER_REPEAT_BOTH: Repeat the content on both axis
|
||||
*
|
||||
* Content repeat modes.
|
||||
*
|
||||
* Since: 1.12
|
||||
*/
|
||||
typedef enum
|
||||
{
|
||||
@ -1454,8 +1372,6 @@ typedef enum
|
||||
* Change the value transition of a step function.
|
||||
*
|
||||
* See clutter_timeline_set_step_progress().
|
||||
*
|
||||
* Since: 1.12
|
||||
*/
|
||||
typedef enum
|
||||
{
|
||||
@ -1477,8 +1393,6 @@ typedef enum
|
||||
*
|
||||
* Enum passed to the [method@GestureAction.set_threshold_trigger_edge]
|
||||
* function.
|
||||
*
|
||||
* Since: 1.18
|
||||
*/
|
||||
typedef enum
|
||||
{
|
||||
@ -1515,9 +1429,7 @@ typedef enum
|
||||
* to undo any visible/permanent changes that were done throughout the
|
||||
* progress of the gesture.
|
||||
*
|
||||
* See also #ClutterTouchpadPinchEvent and #ClutterTouchpadPinchEvent.
|
||||
*
|
||||
* Since: 1.24
|
||||
* See also #ClutterTouchpadPinchEvent and #ClutterTouchpadPinchEvent.4
|
||||
*/
|
||||
typedef enum
|
||||
{
|
||||
@ -1539,9 +1451,7 @@ typedef enum
|
||||
* The scroll source determines the source of the scroll event.
|
||||
*
|
||||
* Keep in mind that the source device #ClutterInputDeviceType is not enough
|
||||
* to infer the scroll source.
|
||||
*
|
||||
* Since: 1.26
|
||||
* to infer the scroll source.6
|
||||
*/
|
||||
typedef enum
|
||||
{
|
||||
@ -1559,9 +1469,7 @@ typedef enum
|
||||
*
|
||||
* Flags used to notify the axes that were stopped in a #ClutterScrollEvent.
|
||||
*
|
||||
* These can be used to trigger post-scroll effects like kinetic scrolling.
|
||||
*
|
||||
* Since: 1.26
|
||||
* These can be used to trigger post-scroll effects like kinetic scrolling.6
|
||||
*/
|
||||
typedef enum
|
||||
{
|
||||
@ -1581,9 +1489,7 @@ typedef enum
|
||||
* @CLUTTER_INPUT_DEVICE_TOOL_MOUSE: The tool is a mouse
|
||||
* @CLUTTER_INPUT_DEVICE_TOOL_LENS: The tool is a lens
|
||||
*
|
||||
* Defines the type of tool that a #ClutterInputDeviceTool represents.
|
||||
*
|
||||
* Since: 1.28
|
||||
* Defines the type of tool that a #ClutterInputDeviceTool represents.8
|
||||
*/
|
||||
typedef enum
|
||||
{
|
||||
|
@ -91,8 +91,6 @@ G_DEFINE_BOXED_TYPE (ClutterEventSequence, clutter_event_sequence,
|
||||
* Retrieves the pointer to platform-specific data inside an event
|
||||
*
|
||||
* Return value: a pointer to platform-specific data
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
gpointer
|
||||
_clutter_event_get_platform_data (const ClutterEvent *event)
|
||||
@ -106,8 +104,6 @@ _clutter_event_get_platform_data (const ClutterEvent *event)
|
||||
* @data: a pointer to platform-specific data
|
||||
*
|
||||
* Sets the pointer to platform-specific data inside an event
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
void
|
||||
_clutter_event_set_platform_data (ClutterEvent *event,
|
||||
@ -146,8 +142,6 @@ clutter_event_type (const ClutterEvent *event)
|
||||
* Retrieves the time of the event.
|
||||
*
|
||||
* Return value: the time of the event, or %CLUTTER_CURRENT_TIME
|
||||
*
|
||||
* Since: 0.4
|
||||
*/
|
||||
guint32
|
||||
clutter_event_get_time (const ClutterEvent *event)
|
||||
@ -163,8 +157,6 @@ clutter_event_get_time (const ClutterEvent *event)
|
||||
* @time_: the time of the event
|
||||
*
|
||||
* Sets the time of the event.
|
||||
*
|
||||
* Since: 1.8
|
||||
*/
|
||||
void
|
||||
clutter_event_set_time (ClutterEvent *event,
|
||||
@ -184,8 +176,6 @@ clutter_event_set_time (ClutterEvent *event,
|
||||
* the effective state.
|
||||
*
|
||||
* Return value: the modifier state parameter, or 0
|
||||
*
|
||||
* Since: 0.4
|
||||
*/
|
||||
ClutterModifierType
|
||||
clutter_event_get_state (const ClutterEvent *event)
|
||||
@ -227,8 +217,6 @@ clutter_event_get_state (const ClutterEvent *event)
|
||||
* @state: the modifier state to set
|
||||
*
|
||||
* Sets the modifier state of the event.
|
||||
*
|
||||
* Since: 1.8
|
||||
*/
|
||||
void
|
||||
clutter_event_set_state (ClutterEvent *event,
|
||||
@ -298,8 +286,6 @@ _clutter_event_set_state_full (ClutterEvent *event,
|
||||
* Retrieves the decomposition of the keyboard state into button, base,
|
||||
* latched, locked and effective. This can be used to transmit to other
|
||||
* applications, for example when implementing a wayland compositor.
|
||||
*
|
||||
* Since: 1.16
|
||||
*/
|
||||
void
|
||||
clutter_event_get_state_full (const ClutterEvent *event,
|
||||
@ -332,8 +318,6 @@ clutter_event_get_state_full (const ClutterEvent *event,
|
||||
* @y: (out): return location for the Y coordinate, or %NULL
|
||||
*
|
||||
* Retrieves the coordinates of @event and puts them into @x and @y.
|
||||
*
|
||||
* Since: 0.4
|
||||
*/
|
||||
void
|
||||
clutter_event_get_coords (const ClutterEvent *event,
|
||||
@ -359,8 +343,6 @@ clutter_event_get_coords (const ClutterEvent *event,
|
||||
* @position: a #graphene_point_t
|
||||
*
|
||||
* Retrieves the event coordinates as a #graphene_point_t.
|
||||
*
|
||||
* Since: 1.12
|
||||
*/
|
||||
void
|
||||
clutter_event_get_position (const ClutterEvent *event,
|
||||
@ -439,8 +421,6 @@ clutter_event_get_position (const ClutterEvent *event,
|
||||
* @y: the Y coordinate of the event
|
||||
*
|
||||
* Sets the coordinates of the @event.
|
||||
*
|
||||
* Since: 1.8
|
||||
*/
|
||||
void
|
||||
clutter_event_set_coords (ClutterEvent *event,
|
||||
@ -523,8 +503,6 @@ clutter_event_set_coords (ClutterEvent *event,
|
||||
* NULL if the event has no source.
|
||||
*
|
||||
* Return value: (transfer none): a #ClutterActor
|
||||
*
|
||||
* Since: 0.6
|
||||
*/
|
||||
ClutterActor *
|
||||
clutter_event_get_source (const ClutterEvent *event)
|
||||
@ -541,8 +519,6 @@ clutter_event_get_source (const ClutterEvent *event)
|
||||
* @actor: (allow-none): a #ClutterActor, or %NULL
|
||||
*
|
||||
* Sets the source #ClutterActor of @event.
|
||||
*
|
||||
* Since: 1.8
|
||||
*/
|
||||
void
|
||||
clutter_event_set_source (ClutterEvent *event,
|
||||
@ -558,8 +534,6 @@ clutter_event_set_source (ClutterEvent *event,
|
||||
* %NULL if the event has no stage.
|
||||
*
|
||||
* Return value: (transfer none): a #ClutterStage
|
||||
*
|
||||
* Since: 0.8
|
||||
*/
|
||||
ClutterStage *
|
||||
clutter_event_get_stage (const ClutterEvent *event)
|
||||
@ -575,8 +549,6 @@ clutter_event_get_stage (const ClutterEvent *event)
|
||||
* @stage: (allow-none): a #ClutterStage, or %NULL
|
||||
*
|
||||
* Sets the source #ClutterStage of the event.
|
||||
*
|
||||
* Since: 1.8
|
||||
*/
|
||||
void
|
||||
clutter_event_set_stage (ClutterEvent *event,
|
||||
@ -598,8 +570,6 @@ clutter_event_set_stage (ClutterEvent *event,
|
||||
* Retrieves the #ClutterEventFlags of @event
|
||||
*
|
||||
* Return value: the event flags
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
ClutterEventFlags
|
||||
clutter_event_get_flags (const ClutterEvent *event)
|
||||
@ -615,8 +585,6 @@ clutter_event_get_flags (const ClutterEvent *event)
|
||||
* @flags: a binary OR of #ClutterEventFlags values
|
||||
*
|
||||
* Sets the #ClutterEventFlags of @event
|
||||
*
|
||||
* Since: 1.8
|
||||
*/
|
||||
void
|
||||
clutter_event_set_flags (ClutterEvent *event,
|
||||
@ -639,8 +607,6 @@ clutter_event_set_flags (ClutterEvent *event,
|
||||
* Retrieves the related actor of a crossing event.
|
||||
*
|
||||
* Return value: (transfer none): the related #ClutterActor, or %NULL
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
ClutterActor *
|
||||
clutter_event_get_related (const ClutterEvent *event)
|
||||
@ -658,8 +624,6 @@ clutter_event_get_related (const ClutterEvent *event)
|
||||
* @actor: (allow-none): a #ClutterActor or %NULL
|
||||
*
|
||||
* Sets the related actor of a crossing event
|
||||
*
|
||||
* Since: 1.8
|
||||
*/
|
||||
void
|
||||
clutter_event_set_related (ClutterEvent *event,
|
||||
@ -683,8 +647,6 @@ clutter_event_set_related (ClutterEvent *event,
|
||||
* @dy: delta on the vertical axis
|
||||
*
|
||||
* Sets the precise scrolling information of @event.
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
void
|
||||
clutter_event_set_scroll_delta (ClutterEvent *event,
|
||||
@ -710,8 +672,6 @@ clutter_event_set_scroll_delta (ClutterEvent *event,
|
||||
*
|
||||
* The @event has to have a #ClutterScrollEvent.direction value
|
||||
* of %CLUTTER_SCROLL_SMOOTH.
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
void
|
||||
clutter_event_get_scroll_delta (const ClutterEvent *event,
|
||||
@ -741,8 +701,6 @@ clutter_event_get_scroll_delta (const ClutterEvent *event,
|
||||
* Retrieves the direction of the scrolling of @event
|
||||
*
|
||||
* Return value: the scrolling direction
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
ClutterScrollDirection
|
||||
clutter_event_get_scroll_direction (const ClutterEvent *event)
|
||||
@ -759,8 +717,6 @@ clutter_event_get_scroll_direction (const ClutterEvent *event)
|
||||
* @direction: the scrolling direction
|
||||
*
|
||||
* Sets the direction of the scrolling of @event
|
||||
*
|
||||
* Since: 1.8
|
||||
*/
|
||||
void
|
||||
clutter_event_set_scroll_direction (ClutterEvent *event,
|
||||
@ -780,8 +736,6 @@ clutter_event_set_scroll_direction (ClutterEvent *event,
|
||||
* Retrieves the button number of @event
|
||||
*
|
||||
* Return value: the button number
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
guint32
|
||||
clutter_event_get_button (const ClutterEvent *event)
|
||||
@ -806,8 +760,6 @@ clutter_event_get_button (const ClutterEvent *event)
|
||||
* @button: the button number
|
||||
*
|
||||
* Sets the button number of @event
|
||||
*
|
||||
* Since: 1.8
|
||||
*/
|
||||
void
|
||||
clutter_event_set_button (ClutterEvent *event,
|
||||
@ -830,8 +782,6 @@ clutter_event_set_button (ClutterEvent *event,
|
||||
* Retrieves the key symbol of @event
|
||||
*
|
||||
* Return value: the key symbol representing the key
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
guint
|
||||
clutter_event_get_key_symbol (const ClutterEvent *event)
|
||||
@ -850,8 +800,6 @@ clutter_event_get_key_symbol (const ClutterEvent *event)
|
||||
* @key_sym: the key symbol representing the key
|
||||
*
|
||||
* Sets the key symbol of @event.
|
||||
*
|
||||
* Since: 1.8
|
||||
*/
|
||||
void
|
||||
clutter_event_set_key_symbol (ClutterEvent *event,
|
||||
@ -872,8 +820,6 @@ clutter_event_set_key_symbol (ClutterEvent *event,
|
||||
* Retrieves the keycode of the key that caused @event
|
||||
*
|
||||
* Return value: The keycode representing the key
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
guint16
|
||||
clutter_event_get_key_code (const ClutterEvent *event)
|
||||
@ -892,8 +838,6 @@ clutter_event_get_key_code (const ClutterEvent *event)
|
||||
* @key_code: the keycode representing the key
|
||||
*
|
||||
* Sets the keycode of the @event.
|
||||
*
|
||||
* Since: 1.8
|
||||
*/
|
||||
void
|
||||
clutter_event_set_key_code (ClutterEvent *event,
|
||||
@ -935,8 +879,6 @@ clutter_event_get_key_unicode (const ClutterEvent *event)
|
||||
* @key_unicode: the Unicode value representing the key
|
||||
*
|
||||
* Sets the Unicode value of @event.
|
||||
*
|
||||
* Since: 1.8
|
||||
*/
|
||||
void
|
||||
clutter_event_set_key_unicode (ClutterEvent *event,
|
||||
@ -958,8 +900,6 @@ clutter_event_set_key_unicode (ClutterEvent *event,
|
||||
* Retrieves the #ClutterEventSequence of @event.
|
||||
*
|
||||
* Return value: (transfer none): the event sequence, or %NULL
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
ClutterEventSequence *
|
||||
clutter_event_get_event_sequence (const ClutterEvent *event)
|
||||
@ -986,8 +926,6 @@ clutter_event_get_event_sequence (const ClutterEvent *event)
|
||||
*
|
||||
* Return value: the #ClutterInputDeviceType for the device, if
|
||||
* any is set
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
ClutterInputDeviceType
|
||||
clutter_event_get_device_type (const ClutterEvent *event)
|
||||
@ -1009,8 +947,6 @@ clutter_event_get_device_type (const ClutterEvent *event)
|
||||
* @device: (allow-none): a #ClutterInputDevice, or %NULL
|
||||
*
|
||||
* Sets the device for @event.
|
||||
*
|
||||
* Since: 1.6
|
||||
*/
|
||||
void
|
||||
clutter_event_set_device (ClutterEvent *event,
|
||||
@ -1107,8 +1043,6 @@ clutter_event_set_device (ClutterEvent *event,
|
||||
* Return value: (transfer none): the #ClutterInputDevice or %NULL. The
|
||||
* returned device is owned by the #ClutterEvent and it should not
|
||||
* be unreferenced
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
ClutterInputDevice *
|
||||
clutter_event_get_device (const ClutterEvent *event)
|
||||
@ -1198,9 +1132,7 @@ clutter_event_get_device (const ClutterEvent *event)
|
||||
* @event: a #ClutterEvent
|
||||
* @tool: (nullable): a #ClutterInputDeviceTool
|
||||
*
|
||||
* Sets the tool in use for this event
|
||||
*
|
||||
* Since: 1.28
|
||||
* Sets the tool in use for this event8
|
||||
**/
|
||||
void
|
||||
clutter_event_set_device_tool (ClutterEvent *event,
|
||||
@ -1219,9 +1151,7 @@ clutter_event_set_device_tool (ClutterEvent *event,
|
||||
*
|
||||
* Returns the device tool that originated this event
|
||||
*
|
||||
* Returns: (transfer none): The tool of this event
|
||||
*
|
||||
* Since: 1.28
|
||||
* Returns: (transfer none): The tool of this event8
|
||||
**/
|
||||
ClutterInputDeviceTool *
|
||||
clutter_event_get_device_tool (const ClutterEvent *event)
|
||||
@ -1404,8 +1334,6 @@ clutter_event_free (ClutterEvent *event)
|
||||
* this.
|
||||
*
|
||||
* Return value: A #ClutterEvent or NULL if queue empty
|
||||
*
|
||||
* Since: 0.4
|
||||
*/
|
||||
ClutterEvent *
|
||||
clutter_event_get (void)
|
||||
@ -1447,8 +1375,6 @@ _clutter_event_push (const ClutterEvent *event,
|
||||
* event signals will be emitted for this source and capture/bubbling for
|
||||
* its ancestors. If the source is not set it will be generated by picking
|
||||
* or use the actor that currently has keyboard focus
|
||||
*
|
||||
* Since: 0.6
|
||||
*/
|
||||
void
|
||||
clutter_event_put (const ClutterEvent *event)
|
||||
@ -1462,8 +1388,6 @@ clutter_event_put (const ClutterEvent *event)
|
||||
* Checks if events are pending in the event queue.
|
||||
*
|
||||
* Return value: TRUE if there are pending events, FALSE otherwise.
|
||||
*
|
||||
* Since: 0.4
|
||||
*/
|
||||
gboolean
|
||||
clutter_events_pending (void)
|
||||
@ -1482,8 +1406,6 @@ clutter_events_pending (void)
|
||||
* event or if the event has a timestamp.
|
||||
*
|
||||
* Return value: the event timestamp, or %CLUTTER_CURRENT_TIME
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
guint32
|
||||
clutter_get_current_event_time (void)
|
||||
@ -1508,8 +1430,6 @@ clutter_get_current_event_time (void)
|
||||
* event.
|
||||
*
|
||||
* Return value: (transfer none): The current ClutterEvent, or %NULL if none
|
||||
*
|
||||
* Since: 1.2
|
||||
*/
|
||||
const ClutterEvent *
|
||||
clutter_get_current_event (void)
|
||||
@ -1534,8 +1454,6 @@ clutter_get_current_event (void)
|
||||
*
|
||||
* Return value: (transfer none): a pointer to a #ClutterInputDevice
|
||||
* or %NULL
|
||||
*
|
||||
* Since: 1.6
|
||||
*/
|
||||
ClutterInputDevice *
|
||||
clutter_event_get_source_device (const ClutterEvent *event)
|
||||
@ -1558,8 +1476,6 @@ clutter_event_get_source_device (const ClutterEvent *event)
|
||||
* Sets the source #ClutterInputDevice for @event.
|
||||
*
|
||||
* The #ClutterEvent must have been created using clutter_event_new().
|
||||
*
|
||||
* Since: 1.8
|
||||
*/
|
||||
void
|
||||
clutter_event_set_source_device (ClutterEvent *event,
|
||||
@ -1582,8 +1498,6 @@ clutter_event_set_source_device (ClutterEvent *event,
|
||||
* Retrieves the array of axes values attached to the event.
|
||||
*
|
||||
* Return value: (transfer none): an array of axis values
|
||||
*
|
||||
* Since: 1.6
|
||||
*/
|
||||
gdouble *
|
||||
clutter_event_get_axes (const ClutterEvent *event,
|
||||
@ -1652,8 +1566,6 @@ clutter_event_get_axes (const ClutterEvent *event,
|
||||
* Retrieves the distance between two events, a @source and a @target.
|
||||
*
|
||||
* Return value: the distance between two #ClutterEvent
|
||||
*
|
||||
* Since: 1.12
|
||||
*/
|
||||
float
|
||||
clutter_event_get_distance (const ClutterEvent *source,
|
||||
@ -1678,8 +1590,6 @@ clutter_event_get_distance (const ClutterEvent *source,
|
||||
* the positive Y axis.
|
||||
*
|
||||
* Return value: the angle between two #ClutterEvent
|
||||
*
|
||||
* Since: 1.12
|
||||
*/
|
||||
double
|
||||
clutter_event_get_angle (const ClutterEvent *source,
|
||||
@ -1716,8 +1626,6 @@ clutter_event_get_angle (const ClutterEvent *source,
|
||||
* Checks whether @event has the Shift modifier mask set.
|
||||
*
|
||||
* Return value: %TRUE if the event has the Shift modifier mask set
|
||||
*
|
||||
* Since: 1.12
|
||||
*/
|
||||
gboolean
|
||||
clutter_event_has_shift_modifier (const ClutterEvent *event)
|
||||
@ -1732,8 +1640,6 @@ clutter_event_has_shift_modifier (const ClutterEvent *event)
|
||||
* Checks whether @event has the Control modifier mask set.
|
||||
*
|
||||
* Return value: %TRUE if the event has the Control modifier mask set
|
||||
*
|
||||
* Since: 1.12
|
||||
*/
|
||||
gboolean
|
||||
clutter_event_has_control_modifier (const ClutterEvent *event)
|
||||
@ -1750,8 +1656,6 @@ clutter_event_has_control_modifier (const ClutterEvent *event)
|
||||
* synthesized by the windowing system itself (as opposed by Clutter).
|
||||
*
|
||||
* Return value: %TRUE if the event is pointer emulated
|
||||
*
|
||||
* Since: 1.12
|
||||
*/
|
||||
gboolean
|
||||
clutter_event_is_pointer_emulated (const ClutterEvent *event)
|
||||
@ -1800,8 +1704,6 @@ _clutter_event_process_filters (ClutterEvent *event,
|
||||
*
|
||||
* Return value: an identifier for the event filter, to be used
|
||||
* with clutter_event_remove_filter().
|
||||
*
|
||||
* Since: 1.18
|
||||
*/
|
||||
guint
|
||||
clutter_event_add_filter (ClutterStage *stage,
|
||||
@ -1832,8 +1734,6 @@ clutter_event_add_filter (ClutterStage *stage,
|
||||
*
|
||||
* Removes an event filter that was previously added with
|
||||
* clutter_event_add_filter().
|
||||
*
|
||||
* Since: 1.18
|
||||
*/
|
||||
void
|
||||
clutter_event_remove_filter (guint id)
|
||||
@ -1865,9 +1765,7 @@ clutter_event_remove_filter (guint id)
|
||||
*
|
||||
* Returns the number of fingers that is triggering the touchpad gesture.
|
||||
*
|
||||
* Returns: the number of fingers in the gesture.
|
||||
*
|
||||
* Since: 1.24
|
||||
* Returns: the number of fingers in the gesture.4
|
||||
**/
|
||||
guint
|
||||
clutter_event_get_touchpad_gesture_finger_count (const ClutterEvent *event)
|
||||
@ -1893,9 +1791,7 @@ clutter_event_get_touchpad_gesture_finger_count (const ClutterEvent *event)
|
||||
*
|
||||
* Returns the angle delta reported by this specific event.
|
||||
*
|
||||
* Returns: The angle delta relative to the previous event.
|
||||
*
|
||||
* Since: 1.24
|
||||
* Returns: The angle delta relative to the previous event.4
|
||||
**/
|
||||
gdouble
|
||||
clutter_event_get_gesture_pinch_angle_delta (const ClutterEvent *event)
|
||||
@ -1915,9 +1811,7 @@ clutter_event_get_gesture_pinch_angle_delta (const ClutterEvent *event)
|
||||
* %CLUTTER_TOUCHPAD_GESTURE_PHASE_BEGIN is received.
|
||||
* is received.
|
||||
*
|
||||
* Returns: the current pinch gesture scale
|
||||
*
|
||||
* Since: 1.24
|
||||
* Returns: the current pinch gesture scale4
|
||||
**/
|
||||
gdouble
|
||||
clutter_event_get_gesture_pinch_scale (const ClutterEvent *event)
|
||||
@ -1964,9 +1858,7 @@ clutter_event_get_gesture_phase (const ClutterEvent *event)
|
||||
* position in the Y axis, or %NULL
|
||||
*
|
||||
* Returns the gesture motion deltas relative to the current pointer
|
||||
* position.
|
||||
*
|
||||
* Since: 1.24
|
||||
* position.4
|
||||
**/
|
||||
void
|
||||
clutter_event_get_gesture_motion_delta (const ClutterEvent *event,
|
||||
@ -2051,9 +1943,7 @@ clutter_event_get_gesture_motion_delta_unaccelerated (const ClutterEvent *event,
|
||||
*
|
||||
* Returns the #ClutterScrollSource that applies to an scroll event.
|
||||
*
|
||||
* Returns: The source of scroll events
|
||||
*
|
||||
* Since: 1.26
|
||||
* Returns: The source of scroll events6
|
||||
**/
|
||||
ClutterScrollSource
|
||||
clutter_event_get_scroll_source (const ClutterEvent *event)
|
||||
@ -2073,9 +1963,7 @@ clutter_event_get_scroll_source (const ClutterEvent *event)
|
||||
* can be used to determine whether post-scroll effects like kinetic
|
||||
* scrolling should be applied.
|
||||
*
|
||||
* Returns: The scroll finish flags
|
||||
*
|
||||
* Since: 1.26
|
||||
* Returns: The scroll finish flags6
|
||||
**/
|
||||
ClutterScrollFinishFlags
|
||||
clutter_event_get_scroll_finish_flags (const ClutterEvent *event)
|
||||
|
@ -40,8 +40,6 @@ G_BEGIN_DECLS
|
||||
* CLUTTER_PRIORITY_EVENTS:
|
||||
*
|
||||
* Priority for event handling.
|
||||
*
|
||||
* Since: 0.4
|
||||
*/
|
||||
#define CLUTTER_PRIORITY_EVENTS (G_PRIORITY_DEFAULT)
|
||||
|
||||
@ -49,8 +47,6 @@ G_BEGIN_DECLS
|
||||
* CLUTTER_CURRENT_TIME:
|
||||
*
|
||||
* Default value for "now".
|
||||
*
|
||||
* Since: 0.4
|
||||
*/
|
||||
#define CLUTTER_CURRENT_TIME (0L)
|
||||
|
||||
@ -59,8 +55,6 @@ G_BEGIN_DECLS
|
||||
*
|
||||
* Continues the propagation of an event; this macro should be
|
||||
* used in event-related signals.
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
#define CLUTTER_EVENT_PROPAGATE (FALSE)
|
||||
|
||||
@ -69,8 +63,6 @@ G_BEGIN_DECLS
|
||||
*
|
||||
* Stops the propagation of an event; this macro should be used
|
||||
* in event-related signals.
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
#define CLUTTER_EVENT_STOP (TRUE)
|
||||
|
||||
@ -81,8 +73,6 @@ G_BEGIN_DECLS
|
||||
*
|
||||
* This is typically the left mouse button in a right-handed
|
||||
* mouse configuration.
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
#define CLUTTER_BUTTON_PRIMARY (1)
|
||||
|
||||
@ -90,8 +80,6 @@ G_BEGIN_DECLS
|
||||
* CLUTTER_BUTTON_MIDDLE:
|
||||
*
|
||||
* The middle button of a pointer device.
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
#define CLUTTER_BUTTON_MIDDLE (2)
|
||||
|
||||
@ -102,8 +90,6 @@ G_BEGIN_DECLS
|
||||
*
|
||||
* This is typically the right mouse button in a right-handed
|
||||
* mouse configuration.
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
#define CLUTTER_BUTTON_SECONDARY (3)
|
||||
|
||||
@ -132,8 +118,6 @@ typedef struct _ClutterIMEvent ClutterIMEvent;
|
||||
* @source: event source actor
|
||||
*
|
||||
* Common members for a #ClutterEvent
|
||||
*
|
||||
* Since: 0.2
|
||||
*/
|
||||
struct _ClutterAnyEvent
|
||||
{
|
||||
@ -158,8 +142,6 @@ struct _ClutterAnyEvent
|
||||
* device the event originated from, use clutter_event_get_source_device()
|
||||
*
|
||||
* Key event
|
||||
*
|
||||
* Since: 0.2
|
||||
*/
|
||||
struct _ClutterKeyEvent
|
||||
{
|
||||
@ -196,8 +178,6 @@ struct _ClutterKeyEvent
|
||||
* The event coordinates are relative to the stage that received the
|
||||
* event, and can be transformed into actor-relative coordinates by
|
||||
* using clutter_actor_transform_stage_point().
|
||||
*
|
||||
* Since: 0.2
|
||||
*/
|
||||
struct _ClutterButtonEvent
|
||||
{
|
||||
@ -225,9 +205,7 @@ struct _ClutterButtonEvent
|
||||
* @device: the device that originated the event. If you want the physical
|
||||
* device the event originated from, use clutter_event_get_source_device()
|
||||
*
|
||||
* Event for tool proximity in tablet devices
|
||||
*
|
||||
* Since: 1.28
|
||||
* Event for tool proximity in tablet devices8
|
||||
*/
|
||||
struct _ClutterProximityEvent
|
||||
{
|
||||
@ -252,8 +230,6 @@ struct _ClutterProximityEvent
|
||||
* device the event originated from, use clutter_event_get_source_device()
|
||||
*
|
||||
* Event for the movement of the pointer across different actors
|
||||
*
|
||||
* Since: 0.2
|
||||
*/
|
||||
struct _ClutterCrossingEvent
|
||||
{
|
||||
@ -284,8 +260,6 @@ struct _ClutterCrossingEvent
|
||||
* device the event originated from, use clutter_event_get_source_device()
|
||||
*
|
||||
* Event for the pointer motion
|
||||
*
|
||||
* Since: 0.2
|
||||
*/
|
||||
struct _ClutterMotionEvent
|
||||
{
|
||||
@ -325,8 +299,6 @@ struct _ClutterMotionEvent
|
||||
* @finish_flags: the axes that were stopped in this event. This field is available since 1.26
|
||||
*
|
||||
* Scroll wheel (or similar device) event
|
||||
*
|
||||
* Since: 0.2
|
||||
*/
|
||||
struct _ClutterScrollEvent
|
||||
{
|
||||
@ -374,8 +346,6 @@ struct _ClutterScrollEvent
|
||||
*
|
||||
* With multi-touch capable devices there can be multiple event sequence
|
||||
* running at the same time.
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
struct _ClutterTouchEvent
|
||||
{
|
||||
@ -419,9 +389,7 @@ struct _ClutterTouchEvent
|
||||
* Each event with phase %CLUTTER_TOUCHPAD_GESTURE_PHASE_BEGIN
|
||||
* will report a @scale of 1.0, all later phases in the gesture
|
||||
* report the current scale relative to the initial 1.0 value
|
||||
* (eg. 0.5 being half the size, 2.0 twice as big).
|
||||
*
|
||||
* Since: 1.24
|
||||
* (eg. 0.5 being half the size, 2.0 twice as big).4
|
||||
*/
|
||||
struct _ClutterTouchpadPinchEvent
|
||||
{
|
||||
@ -462,9 +430,7 @@ struct _ClutterTouchpadPinchEvent
|
||||
*
|
||||
* Used for touchpad swipe gesture events.
|
||||
*
|
||||
* The current state of the gesture will be determined by the @phase field.
|
||||
*
|
||||
* Since: 1.24
|
||||
* The current state of the gesture will be determined by the @phase field.4
|
||||
*/
|
||||
struct _ClutterTouchpadSwipeEvent
|
||||
{
|
||||
@ -593,8 +559,6 @@ struct _ClutterIMEvent
|
||||
*
|
||||
* The events usually come from the windowing backend, but can also
|
||||
* be synthesized by Clutter itself or by the application code.
|
||||
*
|
||||
* Since: 0.2
|
||||
*/
|
||||
union _ClutterEvent
|
||||
{
|
||||
@ -632,8 +596,6 @@ union _ClutterEvent
|
||||
* has been handled or %CLUTTER_EVENT_PROPAGATE otherwise.
|
||||
* Returning %CLUTTER_EVENT_STOP skips any further filter
|
||||
* functions and prevents the signal emission for the event.
|
||||
*
|
||||
* Since: 1.18
|
||||
*/
|
||||
typedef gboolean (* ClutterEventFilterFunc) (const ClutterEvent *event,
|
||||
ClutterActor *event_actor,
|
||||
|
138
clutter/clutter/clutter-feature.c
Normal file
138
clutter/clutter/clutter-feature.c
Normal file
@ -0,0 +1,138 @@
|
||||
/*
|
||||
* Clutter.
|
||||
*
|
||||
* An OpenGL based 'interactive canvas' library.
|
||||
*
|
||||
* Authored By Matthew Allum <mallum@openedhand.com>
|
||||
*
|
||||
* Copyright (C) 2006 OpenedHand
|
||||
*
|
||||
* 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/>.
|
||||
*
|
||||
*
|
||||
*/
|
||||
|
||||
/**
|
||||
* SECTION:clutter-feature
|
||||
* @short_description: Run-time detection of Clutter features
|
||||
*
|
||||
* Parts of Clutter depend on the underlying platform, including the
|
||||
* capabilities of the backend used and the OpenGL features exposed through the
|
||||
* Clutter and COGL API.
|
||||
*
|
||||
* It is possible to ask whether Clutter has support for specific features at
|
||||
* run-time.
|
||||
*/
|
||||
|
||||
#include "clutter-build-config.h"
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <sys/types.h>
|
||||
|
||||
#include "clutter-backend-private.h"
|
||||
#include "clutter-feature.h"
|
||||
#include "clutter-main.h"
|
||||
#include "clutter-private.h"
|
||||
#include "clutter-debug.h"
|
||||
|
||||
#include "cogl/cogl.h"
|
||||
|
||||
typedef struct ClutterFeatures
|
||||
{
|
||||
ClutterFeatureFlags flags;
|
||||
guint features_set : 1;
|
||||
} ClutterFeatures;
|
||||
|
||||
static ClutterFeatures* __features = NULL;
|
||||
|
||||
static ClutterFeatureFlags
|
||||
clutter_features_from_cogl (void)
|
||||
{
|
||||
ClutterFeatureFlags clutter_flags = 0;
|
||||
|
||||
clutter_flags |= CLUTTER_FEATURE_SHADERS_GLSL;
|
||||
|
||||
return clutter_flags;
|
||||
}
|
||||
|
||||
gboolean
|
||||
clutter_feature_init (ClutterMainContext *context,
|
||||
GError **error)
|
||||
{
|
||||
CLUTTER_NOTE (MISC, "checking features");
|
||||
|
||||
if (!__features)
|
||||
{
|
||||
CLUTTER_NOTE (MISC, "allocating features data");
|
||||
__features = g_new0 (ClutterFeatures, 1);
|
||||
__features->features_set = FALSE; /* don't rely on zero-ing */
|
||||
}
|
||||
|
||||
if (__features->features_set)
|
||||
return TRUE;
|
||||
|
||||
/* makes sure we have a GL context; if we have, this is a no-op */
|
||||
if (!_clutter_backend_create_context (context->backend, error))
|
||||
return FALSE;
|
||||
|
||||
__features->flags = clutter_features_from_cogl ();
|
||||
|
||||
__features->features_set = TRUE;
|
||||
|
||||
CLUTTER_NOTE (MISC, "features checked");
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
/**
|
||||
* clutter_feature_available:
|
||||
* @feature: a #ClutterFeatureFlags
|
||||
*
|
||||
* Checks whether @feature is available. @feature can be a logical
|
||||
* OR of #ClutterFeatureFlags.
|
||||
*
|
||||
* Return value: %TRUE if a feature is available
|
||||
*/
|
||||
gboolean
|
||||
clutter_feature_available (ClutterFeatureFlags feature)
|
||||
{
|
||||
if (G_UNLIKELY (!__features))
|
||||
{
|
||||
g_critical ("Unable to check features. Have you initialized Clutter?");
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
return (__features->flags & feature);
|
||||
}
|
||||
|
||||
/**
|
||||
* clutter_feature_get_all:
|
||||
*
|
||||
* Returns all the supported features.
|
||||
*
|
||||
* Return value: a logical OR of all the supported features.
|
||||
*/
|
||||
ClutterFeatureFlags
|
||||
clutter_feature_get_all (void)
|
||||
{
|
||||
if (G_UNLIKELY (!__features))
|
||||
{
|
||||
g_critical ("Unable to check features. Have you initialized Clutter?");
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
return __features->flags;
|
||||
}
|
||||
|
@ -31,8 +31,6 @@
|
||||
*
|
||||
* #ClutterFixedLayout is a layout manager implementing the same
|
||||
* layout policies as #ClutterGroup.
|
||||
*
|
||||
* Since: 1.2
|
||||
*/
|
||||
|
||||
#include "clutter-build-config.h"
|
||||
@ -178,8 +176,6 @@ clutter_fixed_layout_init (ClutterFixedLayout *self)
|
||||
* Creates a new #ClutterFixedLayout
|
||||
*
|
||||
* Return value: the newly created #ClutterFixedLayout
|
||||
*
|
||||
* Since: 1.2
|
||||
*/
|
||||
ClutterLayoutManager *
|
||||
clutter_fixed_layout_new (void)
|
||||
|
@ -54,8 +54,6 @@ struct _ClutterFixedLayout
|
||||
*
|
||||
* The #ClutterFixedLayoutClass structure contains only private data
|
||||
* and it should be accessed using the provided API
|
||||
*
|
||||
* Since: 1.2
|
||||
*/
|
||||
struct _ClutterFixedLayoutClass
|
||||
{
|
||||
|
@ -49,8 +49,6 @@
|
||||
*
|
||||
* The [flow-layout example](https://git.gnome.org/browse/clutter/tree/examples/flow-layout.c?h=clutter-1.18)
|
||||
* shows how to use the #ClutterFlowLayout.
|
||||
*
|
||||
* Since: 1.2
|
||||
*/
|
||||
|
||||
#include "clutter-build-config.h"
|
||||
@ -917,8 +915,6 @@ clutter_flow_layout_class_init (ClutterFlowLayoutClass *klass)
|
||||
* of the layout will be laid out following the orientation.
|
||||
*
|
||||
* This property also controls the overflowing directions
|
||||
*
|
||||
* Since: 1.2
|
||||
*/
|
||||
flow_properties[PROP_ORIENTATION] =
|
||||
g_param_spec_enum ("orientation",
|
||||
@ -933,8 +929,6 @@ clutter_flow_layout_class_init (ClutterFlowLayoutClass *klass)
|
||||
*
|
||||
* Whether each child inside the #ClutterFlowLayout should receive
|
||||
* the same allocation
|
||||
*
|
||||
* Since: 1.2
|
||||
*/
|
||||
flow_properties[PROP_HOMOGENEOUS] =
|
||||
g_param_spec_boolean ("homogeneous",
|
||||
@ -949,8 +943,6 @@ clutter_flow_layout_class_init (ClutterFlowLayoutClass *klass)
|
||||
* The spacing between columns, in pixels; the value of this
|
||||
* property is honoured by horizontal non-overflowing layouts
|
||||
* and by vertical overflowing layouts
|
||||
*
|
||||
* Since: 1.2
|
||||
*/
|
||||
flow_properties[PROP_COLUMN_SPACING] =
|
||||
g_param_spec_float ("column-spacing",
|
||||
@ -966,8 +958,6 @@ clutter_flow_layout_class_init (ClutterFlowLayoutClass *klass)
|
||||
* The spacing between rows, in pixels; the value of this
|
||||
* property is honoured by vertical non-overflowing layouts and
|
||||
* by horizontal overflowing layouts
|
||||
*
|
||||
* Since: 1.2
|
||||
*/
|
||||
flow_properties[PROP_ROW_SPACING] =
|
||||
g_param_spec_float ("row-spacing",
|
||||
@ -981,8 +971,6 @@ clutter_flow_layout_class_init (ClutterFlowLayoutClass *klass)
|
||||
* ClutterFlowLayout:min-column-width:
|
||||
*
|
||||
* Minimum width for each column in the layout, in pixels
|
||||
*
|
||||
* Since: 1.2
|
||||
*/
|
||||
flow_properties[PROP_MIN_COLUMN_WIDTH] =
|
||||
g_param_spec_float ("min-column-width",
|
||||
@ -997,8 +985,6 @@ clutter_flow_layout_class_init (ClutterFlowLayoutClass *klass)
|
||||
*
|
||||
* Maximum width for each column in the layout, in pixels. If
|
||||
* set to -1 the width will be the maximum child width
|
||||
*
|
||||
* Since: 1.2
|
||||
*/
|
||||
flow_properties[PROP_MAX_COLUMN_WIDTH] =
|
||||
g_param_spec_float ("max-column-width",
|
||||
@ -1012,8 +998,6 @@ clutter_flow_layout_class_init (ClutterFlowLayoutClass *klass)
|
||||
* ClutterFlowLayout:min-row-height:
|
||||
*
|
||||
* Minimum height for each row in the layout, in pixels
|
||||
*
|
||||
* Since: 1.2
|
||||
*/
|
||||
flow_properties[PROP_MIN_ROW_HEGHT] =
|
||||
g_param_spec_float ("min-row-height",
|
||||
@ -1028,8 +1012,6 @@ clutter_flow_layout_class_init (ClutterFlowLayoutClass *klass)
|
||||
*
|
||||
* Maximum height for each row in the layout, in pixels. If
|
||||
* set to -1 the width will be the maximum child height
|
||||
*
|
||||
* Since: 1.2
|
||||
*/
|
||||
flow_properties[PROP_MAX_ROW_HEIGHT] =
|
||||
g_param_spec_float ("max-row-height",
|
||||
@ -1044,8 +1026,6 @@ clutter_flow_layout_class_init (ClutterFlowLayoutClass *klass)
|
||||
*
|
||||
* Whether the #ClutterFlowLayout should arrange its children
|
||||
* on a grid
|
||||
*
|
||||
* Since: 1.16
|
||||
*/
|
||||
flow_properties[PROP_SNAP_TO_GRID] =
|
||||
g_param_spec_boolean ("snap-to-grid",
|
||||
@ -1089,8 +1069,6 @@ clutter_flow_layout_init (ClutterFlowLayout *self)
|
||||
* Creates a new #ClutterFlowLayout with the given @orientation
|
||||
*
|
||||
* Return value: the newly created #ClutterFlowLayout
|
||||
*
|
||||
* Since: 1.2
|
||||
*/
|
||||
ClutterLayoutManager *
|
||||
clutter_flow_layout_new (ClutterFlowOrientation orientation)
|
||||
@ -1110,8 +1088,6 @@ clutter_flow_layout_new (ClutterFlowOrientation orientation)
|
||||
* The orientation controls the direction used to allocate
|
||||
* the children: either horizontally or vertically. The
|
||||
* orientation also controls the direction of the overflowing
|
||||
*
|
||||
* Since: 1.2
|
||||
*/
|
||||
void
|
||||
clutter_flow_layout_set_orientation (ClutterFlowLayout *layout,
|
||||
@ -1158,8 +1134,6 @@ clutter_flow_layout_set_orientation (ClutterFlowLayout *layout,
|
||||
* Retrieves the orientation of the @layout
|
||||
*
|
||||
* Return value: the orientation of the #ClutterFlowLayout
|
||||
*
|
||||
* Since: 1.2
|
||||
*/
|
||||
ClutterFlowOrientation
|
||||
clutter_flow_layout_get_orientation (ClutterFlowLayout *layout)
|
||||
@ -1177,8 +1151,6 @@ clutter_flow_layout_get_orientation (ClutterFlowLayout *layout)
|
||||
*
|
||||
* Sets whether the @layout should allocate the same space for
|
||||
* each child
|
||||
*
|
||||
* Since: 1.2
|
||||
*/
|
||||
void
|
||||
clutter_flow_layout_set_homogeneous (ClutterFlowLayout *layout,
|
||||
@ -1211,8 +1183,6 @@ clutter_flow_layout_set_homogeneous (ClutterFlowLayout *layout,
|
||||
* Retrieves whether the @layout is homogeneous
|
||||
*
|
||||
* Return value: %TRUE if the #ClutterFlowLayout is homogeneous
|
||||
*
|
||||
* Since: 1.2
|
||||
*/
|
||||
gboolean
|
||||
clutter_flow_layout_get_homogeneous (ClutterFlowLayout *layout)
|
||||
@ -1228,8 +1198,6 @@ clutter_flow_layout_get_homogeneous (ClutterFlowLayout *layout)
|
||||
* @spacing: the space between columns
|
||||
*
|
||||
* Sets the space between columns, in pixels
|
||||
*
|
||||
* Since: 1.2
|
||||
*/
|
||||
void
|
||||
clutter_flow_layout_set_column_spacing (ClutterFlowLayout *layout,
|
||||
@ -1263,8 +1231,6 @@ clutter_flow_layout_set_column_spacing (ClutterFlowLayout *layout,
|
||||
*
|
||||
* Return value: the spacing between columns of the #ClutterFlowLayout,
|
||||
* in pixels
|
||||
*
|
||||
* Since: 1.2
|
||||
*/
|
||||
gfloat
|
||||
clutter_flow_layout_get_column_spacing (ClutterFlowLayout *layout)
|
||||
@ -1280,8 +1246,6 @@ clutter_flow_layout_get_column_spacing (ClutterFlowLayout *layout)
|
||||
* @spacing: the space between rows
|
||||
*
|
||||
* Sets the spacing between rows, in pixels
|
||||
*
|
||||
* Since: 1.2
|
||||
*/
|
||||
void
|
||||
clutter_flow_layout_set_row_spacing (ClutterFlowLayout *layout,
|
||||
@ -1315,8 +1279,6 @@ clutter_flow_layout_set_row_spacing (ClutterFlowLayout *layout,
|
||||
*
|
||||
* Return value: the spacing between rows of the #ClutterFlowLayout,
|
||||
* in pixels
|
||||
*
|
||||
* Since: 1.2
|
||||
*/
|
||||
gfloat
|
||||
clutter_flow_layout_get_row_spacing (ClutterFlowLayout *layout)
|
||||
@ -1333,8 +1295,6 @@ clutter_flow_layout_get_row_spacing (ClutterFlowLayout *layout)
|
||||
* @max_width: maximum width of a column
|
||||
*
|
||||
* Sets the minimum and maximum widths that a column can have
|
||||
*
|
||||
* Since: 1.2
|
||||
*/
|
||||
void
|
||||
clutter_flow_layout_set_column_width (ClutterFlowLayout *layout,
|
||||
@ -1389,8 +1349,6 @@ clutter_flow_layout_set_column_width (ClutterFlowLayout *layout,
|
||||
* @max_width: (out): return location for the maximum column width, or %NULL
|
||||
*
|
||||
* Retrieves the minimum and maximum column widths
|
||||
*
|
||||
* Since: 1.2
|
||||
*/
|
||||
void
|
||||
clutter_flow_layout_get_column_width (ClutterFlowLayout *layout,
|
||||
@ -1413,8 +1371,6 @@ clutter_flow_layout_get_column_width (ClutterFlowLayout *layout,
|
||||
* @max_height: the maximum height of a row
|
||||
*
|
||||
* Sets the minimum and maximum heights that a row can have
|
||||
*
|
||||
* Since: 1.2
|
||||
*/
|
||||
void
|
||||
clutter_flow_layout_set_row_height (ClutterFlowLayout *layout,
|
||||
@ -1469,8 +1425,6 @@ clutter_flow_layout_set_row_height (ClutterFlowLayout *layout,
|
||||
* @max_height: (out): return location for the maximum row height, or %NULL
|
||||
*
|
||||
* Retrieves the minimum and maximum row heights
|
||||
*
|
||||
* Since: 1.2
|
||||
*/
|
||||
void
|
||||
clutter_flow_layout_get_row_height (ClutterFlowLayout *layout,
|
||||
@ -1492,8 +1446,6 @@ clutter_flow_layout_get_row_height (ClutterFlowLayout *layout,
|
||||
* @snap_to_grid: %TRUE if @layout should place its children on a grid
|
||||
*
|
||||
* Whether the @layout should place its children on a grid.
|
||||
*
|
||||
* Since: 1.16
|
||||
*/
|
||||
void
|
||||
clutter_flow_layout_set_snap_to_grid (ClutterFlowLayout *layout,
|
||||
@ -1523,8 +1475,6 @@ clutter_flow_layout_set_snap_to_grid (ClutterFlowLayout *layout,
|
||||
* Retrieves the value of #ClutterFlowLayout:snap-to-grid property
|
||||
*
|
||||
* Return value: %TRUE if the @layout is placing its children on a grid
|
||||
*
|
||||
* Since: 1.16
|
||||
*/
|
||||
gboolean
|
||||
clutter_flow_layout_get_snap_to_grid (ClutterFlowLayout *layout)
|
||||
|
@ -57,8 +57,6 @@ struct _ClutterFlowLayout
|
||||
*
|
||||
* The #ClutterFlowLayoutClass structure contains only private data
|
||||
* and should be accessed using the provided API
|
||||
*
|
||||
* Since: 1.2
|
||||
*/
|
||||
struct _ClutterFlowLayoutClass
|
||||
{
|
||||
|
@ -79,8 +79,6 @@
|
||||
* gesture, in which case the "end" state will be reached, or until the
|
||||
* gesture is cancelled, in which case the "cancel" gesture will be used
|
||||
* instead.
|
||||
*
|
||||
* Since: 1.8
|
||||
*/
|
||||
|
||||
#include "clutter-build-config.h"
|
||||
@ -651,8 +649,6 @@ clutter_gesture_action_class_init (ClutterGestureActionClass *klass)
|
||||
* ClutterGestureAction:n-touch-points:
|
||||
*
|
||||
* Number of touch points to trigger a gesture action.
|
||||
*
|
||||
* Since: 1.16
|
||||
*/
|
||||
gesture_props[PROP_N_TOUCH_POINTS] =
|
||||
g_param_spec_int ("n-touch-points",
|
||||
@ -667,8 +663,6 @@ clutter_gesture_action_class_init (ClutterGestureActionClass *klass)
|
||||
* The trigger edge to be used by the action to either emit the
|
||||
* [signal@GestureAction::gesture-begin] signal or to emit the
|
||||
* [signal@GestureAction::gesture-cancel] signal.
|
||||
*
|
||||
* Since: 1.18
|
||||
*/
|
||||
gesture_props[PROP_THRESHOLD_TRIGGER_EDGE] =
|
||||
g_param_spec_enum ("threshold-trigger-edge",
|
||||
@ -687,8 +681,6 @@ clutter_gesture_action_class_init (ClutterGestureActionClass *klass)
|
||||
* the [signal@GestureAction::gesture-cancel] signal.
|
||||
*
|
||||
* A negative value will be interpreted as the default drag threshold.
|
||||
*
|
||||
* Since: 1.18
|
||||
*/
|
||||
gesture_props[PROP_THRESHOLD_TRIGGER_DISTANCE_X] =
|
||||
g_param_spec_float ("threshold-trigger-distance-x",
|
||||
@ -706,8 +698,6 @@ clutter_gesture_action_class_init (ClutterGestureActionClass *klass)
|
||||
* the [signal@GestureAction::gesture-cancel] signal.
|
||||
*
|
||||
* A negative value will be interpreted as the default drag threshold.
|
||||
*
|
||||
* Since: 1.18
|
||||
*/
|
||||
gesture_props[PROP_THRESHOLD_TRIGGER_DISTANCE_Y] =
|
||||
g_param_spec_float ("threshold-trigger-distance-y",
|
||||
@ -731,8 +721,6 @@ clutter_gesture_action_class_init (ClutterGestureActionClass *klass)
|
||||
*
|
||||
* Return value: %TRUE if the gesture should start, and %FALSE if
|
||||
* the gesture should be ignored.
|
||||
*
|
||||
* Since: 1.8
|
||||
*/
|
||||
gesture_signals[GESTURE_BEGIN] =
|
||||
g_signal_new (I_("gesture-begin"),
|
||||
@ -754,8 +742,6 @@ clutter_gesture_action_class_init (ClutterGestureActionClass *klass)
|
||||
*
|
||||
* Return value: %TRUE if the gesture should continue, and %FALSE if
|
||||
* the gesture should be cancelled.
|
||||
*
|
||||
* Since: 1.8
|
||||
*/
|
||||
gesture_signals[GESTURE_PROGRESS] =
|
||||
g_signal_new (I_("gesture-progress"),
|
||||
@ -777,8 +763,6 @@ clutter_gesture_action_class_init (ClutterGestureActionClass *klass)
|
||||
*
|
||||
* This signal is emitted if and only if the [signal@GestureAction::gesture-begin]
|
||||
* signal has been emitted first.
|
||||
*
|
||||
* Since: 1.8
|
||||
*/
|
||||
gesture_signals[GESTURE_END] =
|
||||
g_signal_new (I_("gesture-end"),
|
||||
@ -799,8 +783,6 @@ clutter_gesture_action_class_init (ClutterGestureActionClass *klass)
|
||||
*
|
||||
* This signal is emitted if and only if the [signal@GestureAction::gesture-begin]
|
||||
* signal has been emitted first.
|
||||
*
|
||||
* Since: 1.8
|
||||
*/
|
||||
gesture_signals[GESTURE_CANCEL] =
|
||||
g_signal_new (I_("gesture-cancel"),
|
||||
@ -831,8 +813,6 @@ clutter_gesture_action_init (ClutterGestureAction *self)
|
||||
* Creates a new #ClutterGestureAction instance.
|
||||
*
|
||||
* Return value: the newly created #ClutterGestureAction
|
||||
*
|
||||
* Since: 1.8
|
||||
*/
|
||||
ClutterAction *
|
||||
clutter_gesture_action_new (void)
|
||||
@ -852,8 +832,6 @@ clutter_gesture_action_new (void)
|
||||
*
|
||||
* Retrieves the coordinates, in stage space, of the press event
|
||||
* that started the dragging for a specific touch point.
|
||||
*
|
||||
* Since: 1.8
|
||||
*/
|
||||
void
|
||||
clutter_gesture_action_get_press_coords (ClutterGestureAction *action,
|
||||
@ -892,8 +870,6 @@ clutter_gesture_action_get_press_coords (ClutterGestureAction *action,
|
||||
*
|
||||
* Retrieves the coordinates, in stage space, of the latest motion
|
||||
* event during the dragging.
|
||||
*
|
||||
* Since: 1.8
|
||||
*/
|
||||
void
|
||||
clutter_gesture_action_get_motion_coords (ClutterGestureAction *action,
|
||||
@ -934,8 +910,6 @@ clutter_gesture_action_get_motion_coords (ClutterGestureAction *action,
|
||||
* during the dragging.
|
||||
*
|
||||
* Return value: the distance since last motion event
|
||||
*
|
||||
* Since: 1.12
|
||||
*/
|
||||
gfloat
|
||||
clutter_gesture_action_get_motion_delta (ClutterGestureAction *action,
|
||||
@ -980,8 +954,6 @@ clutter_gesture_action_get_motion_delta (ClutterGestureAction *action,
|
||||
*
|
||||
* Retrieves the coordinates, in stage space, where the touch point was
|
||||
* last released.
|
||||
*
|
||||
* Since: 1.8
|
||||
*/
|
||||
void
|
||||
clutter_gesture_action_get_release_coords (ClutterGestureAction *action,
|
||||
@ -1020,8 +992,6 @@ clutter_gesture_action_get_release_coords (ClutterGestureAction *action,
|
||||
*
|
||||
* Retrieves the velocity, in stage pixels per millisecond, of the
|
||||
* latest motion event during the dragging.
|
||||
*
|
||||
* Since: 1.12
|
||||
*/
|
||||
gfloat
|
||||
clutter_gesture_action_get_velocity (ClutterGestureAction *action,
|
||||
@ -1063,8 +1033,6 @@ clutter_gesture_action_get_velocity (ClutterGestureAction *action,
|
||||
* Retrieves the number of requested points to trigger the gesture.
|
||||
*
|
||||
* Return value: the number of points to trigger the gesture.
|
||||
*
|
||||
* Since: 1.12
|
||||
*/
|
||||
gint
|
||||
clutter_gesture_action_get_n_touch_points (ClutterGestureAction *action)
|
||||
@ -1084,8 +1052,6 @@ clutter_gesture_action_get_n_touch_points (ClutterGestureAction *action)
|
||||
* @nb_points: a number of points
|
||||
*
|
||||
* Sets the number of points needed to trigger the gesture.
|
||||
*
|
||||
* Since: 1.12
|
||||
*/
|
||||
void
|
||||
clutter_gesture_action_set_n_touch_points (ClutterGestureAction *action,
|
||||
@ -1144,8 +1110,6 @@ clutter_gesture_action_set_n_touch_points (ClutterGestureAction *action,
|
||||
* Retrieves the number of points currently active.
|
||||
*
|
||||
* Return value: the number of points currently active.
|
||||
*
|
||||
* Since: 1.12
|
||||
*/
|
||||
guint
|
||||
clutter_gesture_action_get_n_current_points (ClutterGestureAction *action)
|
||||
@ -1167,8 +1131,6 @@ clutter_gesture_action_get_n_current_points (ClutterGestureAction *action)
|
||||
* Retrieves the #ClutterEventSequence of a touch point.
|
||||
*
|
||||
* Return value: (transfer none): the #ClutterEventSequence of a touch point.
|
||||
*
|
||||
* Since: 1.12
|
||||
*/
|
||||
ClutterEventSequence *
|
||||
clutter_gesture_action_get_sequence (ClutterGestureAction *action,
|
||||
@ -1194,8 +1156,6 @@ clutter_gesture_action_get_sequence (ClutterGestureAction *action,
|
||||
* Retrieves the #ClutterInputDevice of a touch point.
|
||||
*
|
||||
* Return value: (transfer none): the #ClutterInputDevice of a touch point.
|
||||
*
|
||||
* Since: 1.12
|
||||
*/
|
||||
ClutterInputDevice *
|
||||
clutter_gesture_action_get_device (ClutterGestureAction *action,
|
||||
@ -1221,8 +1181,6 @@ clutter_gesture_action_get_device (ClutterGestureAction *action,
|
||||
* [method@Event.copy] if you need to store the reference somewhere.
|
||||
*
|
||||
* Return value: (transfer none): the last #ClutterEvent for a touch point.
|
||||
*
|
||||
* Since: 1.14
|
||||
*/
|
||||
const ClutterEvent *
|
||||
clutter_gesture_action_get_last_event (ClutterGestureAction *action,
|
||||
@ -1247,8 +1205,6 @@ clutter_gesture_action_get_last_event (ClutterGestureAction *action,
|
||||
* @action: a #ClutterGestureAction
|
||||
*
|
||||
* Cancel a #ClutterGestureAction before it begins
|
||||
*
|
||||
* Since: 1.12
|
||||
*/
|
||||
void
|
||||
clutter_gesture_action_cancel (ClutterGestureAction *action)
|
||||
@ -1267,8 +1223,6 @@ clutter_gesture_action_cancel (ClutterGestureAction *action)
|
||||
*
|
||||
* This function should only be called by sub-classes of
|
||||
* #ClutterGestureAction during their construction phase.
|
||||
*
|
||||
* Since: 1.18
|
||||
*/
|
||||
void
|
||||
clutter_gesture_action_set_threshold_trigger_edge (ClutterGestureAction *action,
|
||||
@ -1295,9 +1249,7 @@ clutter_gesture_action_set_threshold_trigger_edge (ClutterGestureAction *ac
|
||||
* Retrieves the edge trigger of the gesture @action, as set using
|
||||
* [method@GestureAction.set_threshold_trigger_edge].
|
||||
*
|
||||
* Return value: the edge trigger
|
||||
*
|
||||
* Since: 1.20
|
||||
* Return value: the edge trigger0
|
||||
*/
|
||||
ClutterGestureTriggerEdge
|
||||
clutter_gesture_action_get_threshold_trigger_edge (ClutterGestureAction *action)
|
||||
@ -1321,8 +1273,6 @@ clutter_gesture_action_get_threshold_trigger_edge (ClutterGestureAction *action)
|
||||
*
|
||||
* Return value: the edge trigger
|
||||
*
|
||||
* Since: 1.18
|
||||
*
|
||||
* Deprecated: 1.20: Use [method@GestureAction.get_threshold_trigger_edge] instead.
|
||||
*/
|
||||
ClutterGestureTriggerEdge
|
||||
@ -1341,8 +1291,6 @@ clutter_gesture_action_get_threshold_trigger_egde (ClutterGestureAction *action)
|
||||
*
|
||||
* This function should only be called by sub-classes of
|
||||
* #ClutterGestureAction during their construction phase.
|
||||
*
|
||||
* Since: 1.18
|
||||
*/
|
||||
void
|
||||
clutter_gesture_action_set_threshold_trigger_distance (ClutterGestureAction *action,
|
||||
@ -1376,8 +1324,6 @@ clutter_gesture_action_set_threshold_trigger_distance (ClutterGestureAction
|
||||
*
|
||||
* Retrieves the threshold trigger distance of the gesture @action,
|
||||
* as set using [method@GestureAction.set_threshold_trigger_distance].
|
||||
*
|
||||
* Since: 1.18
|
||||
*/
|
||||
void
|
||||
clutter_gesture_action_get_threshold_trigger_distance (ClutterGestureAction *action,
|
||||
|
@ -53,8 +53,6 @@ typedef struct _ClutterGestureActionPrivate ClutterGestureActionPrivate;
|
||||
*
|
||||
* The #ClutterGestureClass structure contains only
|
||||
* private data.
|
||||
*
|
||||
* Since: 1.8
|
||||
*/
|
||||
struct _ClutterGestureActionClass
|
||||
{
|
||||
|
@ -1556,8 +1556,6 @@ clutter_grid_layout_class_init (ClutterGridLayoutClass *klass)
|
||||
* ClutterGridLayout:orientation:
|
||||
*
|
||||
* The orientation of the layout, either horizontal or vertical
|
||||
*
|
||||
* Since: 1.12
|
||||
*/
|
||||
obj_props[PROP_ORIENTATION] =
|
||||
g_param_spec_enum ("orientation",
|
||||
@ -1571,8 +1569,6 @@ clutter_grid_layout_class_init (ClutterGridLayoutClass *klass)
|
||||
* ClutterGridLayout:row-spacing:
|
||||
*
|
||||
* The amount of space in pixels between two consecutive rows
|
||||
*
|
||||
* Since: 1.12
|
||||
*/
|
||||
obj_props[PROP_ROW_SPACING] =
|
||||
g_param_spec_uint ("row-spacing",
|
||||
@ -1585,8 +1581,6 @@ clutter_grid_layout_class_init (ClutterGridLayoutClass *klass)
|
||||
* ClutterGridLayout:column-spacing:
|
||||
*
|
||||
* The amount of space in pixels between two consecutive columns
|
||||
*
|
||||
* Since: 1.12
|
||||
*/
|
||||
obj_props[PROP_COLUMN_SPACING] =
|
||||
g_param_spec_uint ("column-spacing",
|
||||
@ -1600,8 +1594,6 @@ clutter_grid_layout_class_init (ClutterGridLayoutClass *klass)
|
||||
* ClutterGridLayout:row-homogeneous:
|
||||
*
|
||||
* Whether all rows of the layout should have the same height
|
||||
*
|
||||
* Since: 1.12
|
||||
*/
|
||||
obj_props[PROP_ROW_HOMOGENEOUS] =
|
||||
g_param_spec_boolean ("row-homogeneous",
|
||||
@ -1614,8 +1606,6 @@ clutter_grid_layout_class_init (ClutterGridLayoutClass *klass)
|
||||
* ClutterGridLayout:column-homogeneous:
|
||||
*
|
||||
* Whether all columns of the layout should have the same width
|
||||
*
|
||||
* Since: 1.12
|
||||
*/
|
||||
obj_props[PROP_COLUMN_HOMOGENEOUS] =
|
||||
g_param_spec_boolean ("column-homogeneous",
|
||||
@ -1668,8 +1658,6 @@ clutter_grid_layout_new (void)
|
||||
* The position of @child is determined by @left and @top. The
|
||||
* number of 'cells' that @child will occupy is determined by
|
||||
* @width and @height.
|
||||
*
|
||||
* Since: 1.12
|
||||
*/
|
||||
void
|
||||
clutter_grid_layout_attach (ClutterGridLayout *layout,
|
||||
@ -1711,8 +1699,6 @@ clutter_grid_layout_attach (ClutterGridLayout *layout,
|
||||
*
|
||||
* Attaching widgets labeled [1], [2], [3] with @sibling == %NULL and
|
||||
* @side == %CLUTTER_GRID_POSITION_LEFT yields a layout of [3][2][1].
|
||||
*
|
||||
* Since: 1.12
|
||||
*/
|
||||
void
|
||||
clutter_grid_layout_attach_next_to (ClutterGridLayout *layout,
|
||||
@ -1751,8 +1737,6 @@ clutter_grid_layout_attach_next_to (ClutterGridLayout *layout,
|
||||
* children to the #ClutterActor using it as a layout manager via
|
||||
* clutter_actor_add_child(); changing this value will not have
|
||||
* any effect on children that are already part of the layout.
|
||||
*
|
||||
* Since: 1.12
|
||||
*/
|
||||
void
|
||||
clutter_grid_layout_set_orientation (ClutterGridLayout *layout,
|
||||
@ -1783,8 +1767,6 @@ clutter_grid_layout_set_orientation (ClutterGridLayout *layout,
|
||||
* cell whose upper left corner is at @left, @top.
|
||||
*
|
||||
* Returns: (transfer none): the child at the given position, or %NULL
|
||||
*
|
||||
* Since: 1.12
|
||||
*/
|
||||
ClutterActor *
|
||||
clutter_grid_layout_get_child_at (ClutterGridLayout *layout,
|
||||
@ -1828,8 +1810,6 @@ clutter_grid_layout_get_child_at (ClutterGridLayout *layout,
|
||||
* Children which are attached at or below this position
|
||||
* are moved one row down. Children which span across this
|
||||
* position are grown to span the new row.
|
||||
*
|
||||
* Since: 1.12
|
||||
*/
|
||||
void
|
||||
clutter_grid_layout_insert_row (ClutterGridLayout *layout,
|
||||
@ -1882,8 +1862,6 @@ clutter_grid_layout_insert_row (ClutterGridLayout *layout,
|
||||
* Children which are attached at or to the right of this position
|
||||
* are moved one column to the right. Children which span across this
|
||||
* position are grown to span the new column.
|
||||
*
|
||||
* Since: 1.12
|
||||
*/
|
||||
void
|
||||
clutter_grid_layout_insert_column (ClutterGridLayout *layout,
|
||||
@ -1940,8 +1918,6 @@ clutter_grid_layout_insert_column (ClutterGridLayout *layout,
|
||||
* %CLUTTER_GRID_POSITION_BOTTOM, a row is inserted. If @side is
|
||||
* %CLUTTER_GRID_POSITION_LEFT of %CLUTTER_GRID_POSITION_RIGHT,
|
||||
* a column is inserted.
|
||||
*
|
||||
* Since: 1.12
|
||||
*/
|
||||
void
|
||||
clutter_grid_layout_insert_next_to (ClutterGridLayout *layout,
|
||||
@ -1987,8 +1963,6 @@ clutter_grid_layout_insert_next_to (ClutterGridLayout *layout,
|
||||
* Retrieves the orientation of the @layout.
|
||||
*
|
||||
* Return value: the orientation of the layout
|
||||
*
|
||||
* Since: 1.12
|
||||
*/
|
||||
ClutterOrientation
|
||||
clutter_grid_layout_get_orientation (ClutterGridLayout *layout)
|
||||
@ -2005,8 +1979,6 @@ clutter_grid_layout_get_orientation (ClutterGridLayout *layout)
|
||||
* @spacing: the spacing between rows of the layout, in pixels
|
||||
*
|
||||
* Sets the spacing between rows of @layout
|
||||
*
|
||||
* Since: 1.12
|
||||
*/
|
||||
void
|
||||
clutter_grid_layout_set_row_spacing (ClutterGridLayout *layout,
|
||||
@ -2035,8 +2007,6 @@ clutter_grid_layout_set_row_spacing (ClutterGridLayout *layout,
|
||||
* Retrieves the spacing set using clutter_grid_layout_set_row_spacing()
|
||||
*
|
||||
* Return value: the spacing between rows of @layout
|
||||
*
|
||||
* Since: 1.12
|
||||
*/
|
||||
guint
|
||||
clutter_grid_layout_get_row_spacing (ClutterGridLayout *layout)
|
||||
@ -2056,8 +2026,6 @@ clutter_grid_layout_get_row_spacing (ClutterGridLayout *layout)
|
||||
* @spacing: the spacing between columns of the layout, in pixels
|
||||
*
|
||||
* Sets the spacing between columns of @layout
|
||||
*
|
||||
* Since: 1.12
|
||||
*/
|
||||
void
|
||||
clutter_grid_layout_set_column_spacing (ClutterGridLayout *layout,
|
||||
@ -2086,8 +2054,6 @@ clutter_grid_layout_set_column_spacing (ClutterGridLayout *layout,
|
||||
* Retrieves the spacing set using clutter_grid_layout_set_column_spacing()
|
||||
*
|
||||
* Return value: the spacing between coluns of @layout
|
||||
*
|
||||
* Since: 1.12
|
||||
*/
|
||||
guint
|
||||
clutter_grid_layout_get_column_spacing (ClutterGridLayout *layout)
|
||||
@ -2107,8 +2073,6 @@ clutter_grid_layout_get_column_spacing (ClutterGridLayout *layout)
|
||||
* @homogeneous: %TRUE to make columns homogeneous
|
||||
*
|
||||
* Sets whether all columns of @layout will have the same width.
|
||||
*
|
||||
* Since: 1.12
|
||||
*/
|
||||
void
|
||||
clutter_grid_layout_set_column_homogeneous (ClutterGridLayout *layout,
|
||||
@ -2156,8 +2120,6 @@ clutter_grid_layout_get_column_homogeneous (ClutterGridLayout *layout)
|
||||
* @homogeneous: %TRUE to make rows homogeneous
|
||||
*
|
||||
* Sets whether all rows of @layout will have the same height.
|
||||
*
|
||||
* Since: 1.12
|
||||
*/
|
||||
void
|
||||
clutter_grid_layout_set_row_homogeneous (ClutterGridLayout *layout,
|
||||
@ -2186,8 +2148,6 @@ clutter_grid_layout_set_row_homogeneous (ClutterGridLayout *layout,
|
||||
* Returns whether all rows of @layout have the same height.
|
||||
*
|
||||
* Returns: whether all rows of @layout have the same height.
|
||||
*
|
||||
* Since: 1.12
|
||||
*/
|
||||
gboolean
|
||||
clutter_grid_layout_get_row_homogeneous (ClutterGridLayout *layout)
|
||||
|
@ -61,8 +61,6 @@ struct _ClutterGridLayout
|
||||
*
|
||||
* The #ClutterGridLayoutClass structure contains only private
|
||||
* data and should be accessed using the provided API
|
||||
*
|
||||
* Since: 1.12
|
||||
*/
|
||||
struct _ClutterGridLayoutClass
|
||||
{
|
||||
|
@ -31,9 +31,7 @@
|
||||
* image data inside a [class@Actor].
|
||||
*
|
||||
* See [image.c](https://git.gnome.org/browse/clutter/tree/examples/image-content.c?h=clutter-1.18)
|
||||
* for an example of how to use #ClutterImage.
|
||||
*
|
||||
* Since: 1.10.
|
||||
* for an example of how to use #ClutterImage..
|
||||
*/
|
||||
|
||||
#include "clutter-build-config.h"
|
||||
@ -186,8 +184,6 @@ clutter_content_iface_init (ClutterContentInterface *iface)
|
||||
*
|
||||
* Return value: (transfer full): the newly created #ClutterImage instance.
|
||||
* Use g_object_unref() when done.
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
ClutterContent *
|
||||
clutter_image_new (void)
|
||||
@ -238,8 +234,6 @@ clutter_image_new (void)
|
||||
*
|
||||
* Return value: %TRUE if the image data was successfully loaded,
|
||||
* and %FALSE otherwise.
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
gboolean
|
||||
clutter_image_set_data (ClutterImage *image,
|
||||
@ -298,8 +292,6 @@ clutter_image_set_data (ClutterImage *image,
|
||||
*
|
||||
* Return value: %TRUE if the image data was successfully loaded,
|
||||
* and %FALSE otherwise.
|
||||
*
|
||||
* Since: 1.12
|
||||
*/
|
||||
gboolean
|
||||
clutter_image_set_bytes (ClutterImage *image,
|
||||
@ -362,8 +354,6 @@ clutter_image_set_bytes (ClutterImage *image,
|
||||
*
|
||||
* Return value: %TRUE if the image data was successfully loaded,
|
||||
* and %FALSE otherwise.
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
gboolean
|
||||
clutter_image_set_area (ClutterImage *image,
|
||||
@ -430,8 +420,6 @@ clutter_image_set_area (ClutterImage *image,
|
||||
* in order to update the actors using @image as their content.
|
||||
*
|
||||
* Return value: (transfer none): a pointer to the Cogl texture, or %NULL
|
||||
*
|
||||
* Since: 1.10
|
||||
* Stability: unstable
|
||||
*/
|
||||
CoglTexture *
|
||||
|
@ -44,8 +44,6 @@ G_DECLARE_DERIVABLE_TYPE (ClutterImage, clutter_image, CLUTTER, IMAGE, GObject)
|
||||
*
|
||||
* The #ClutterImageClass structure contains
|
||||
* private data.
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
struct _ClutterImageClass
|
||||
{
|
||||
|
@ -160,9 +160,7 @@ clutter_input_device_tool_init (ClutterInputDeviceTool *tool)
|
||||
* Gets the serial of this tool, this value can be used to identify a
|
||||
* physical tool (eg. a tablet pen) across program executions.
|
||||
*
|
||||
* Returns: The serial ID for this tool
|
||||
*
|
||||
* Since: 1.28
|
||||
* Returns: The serial ID for this tool8
|
||||
**/
|
||||
guint64
|
||||
clutter_input_device_tool_get_serial (ClutterInputDeviceTool *tool)
|
||||
@ -183,9 +181,7 @@ clutter_input_device_tool_get_serial (ClutterInputDeviceTool *tool)
|
||||
*
|
||||
* Gets the tool type of this tool.
|
||||
*
|
||||
* Returns: The tool type of this tool
|
||||
*
|
||||
* Since: 1.28
|
||||
* Returns: The tool type of this tool8
|
||||
**/
|
||||
ClutterInputDeviceToolType
|
||||
clutter_input_device_tool_get_tool_type (ClutterInputDeviceTool *tool)
|
||||
|
@ -327,8 +327,6 @@ clutter_input_device_class_init (ClutterInputDeviceClass *klass)
|
||||
* ClutterInputDevice:name:
|
||||
*
|
||||
* The name of the device
|
||||
*
|
||||
* Since: 1.2
|
||||
*/
|
||||
obj_props[PROP_NAME] =
|
||||
g_param_spec_string ("name",
|
||||
@ -342,8 +340,6 @@ clutter_input_device_class_init (ClutterInputDeviceClass *klass)
|
||||
* ClutterInputDevice:device-type:
|
||||
*
|
||||
* The type of the device
|
||||
*
|
||||
* Since: 1.2
|
||||
*/
|
||||
obj_props[PROP_DEVICE_TYPE] =
|
||||
g_param_spec_enum ("device-type",
|
||||
@ -383,8 +379,6 @@ clutter_input_device_class_init (ClutterInputDeviceClass *klass)
|
||||
* ClutterInputDevice:mode:
|
||||
*
|
||||
* The mode of the device.
|
||||
*
|
||||
* Since: 1.6
|
||||
*/
|
||||
obj_props[PROP_DEVICE_MODE] =
|
||||
g_param_spec_enum ("device-mode",
|
||||
@ -398,8 +392,6 @@ clutter_input_device_class_init (ClutterInputDeviceClass *klass)
|
||||
* ClutterInputDevice:has-cursor:
|
||||
*
|
||||
* Whether the device has an on screen cursor following its movement.
|
||||
*
|
||||
* Since: 1.6
|
||||
*/
|
||||
obj_props[PROP_HAS_CURSOR] =
|
||||
g_param_spec_boolean ("has-cursor",
|
||||
@ -412,8 +404,6 @@ clutter_input_device_class_init (ClutterInputDeviceClass *klass)
|
||||
* ClutterInputDevice:backend:
|
||||
*
|
||||
* The #ClutterBackend that created the device.
|
||||
*
|
||||
* Since: 1.6
|
||||
*/
|
||||
obj_props[PROP_BACKEND] =
|
||||
g_param_spec_object ("backend",
|
||||
@ -425,9 +415,7 @@ clutter_input_device_class_init (ClutterInputDeviceClass *klass)
|
||||
/**
|
||||
* ClutterInputDevice:vendor-id:
|
||||
*
|
||||
* Vendor ID of this device.
|
||||
*
|
||||
* Since: 1.22
|
||||
* Vendor ID of this device.2
|
||||
*/
|
||||
obj_props[PROP_VENDOR_ID] =
|
||||
g_param_spec_string ("vendor-id",
|
||||
@ -439,9 +427,7 @@ clutter_input_device_class_init (ClutterInputDeviceClass *klass)
|
||||
/**
|
||||
* ClutterInputDevice:product-id:
|
||||
*
|
||||
* Product ID of this device.
|
||||
*
|
||||
* Since: 1.22
|
||||
* Product ID of this device.2
|
||||
*/
|
||||
obj_props[PROP_PRODUCT_ID] =
|
||||
g_param_spec_string ("product-id",
|
||||
@ -508,8 +494,6 @@ clutter_input_device_init (ClutterInputDevice *self)
|
||||
* Retrieves the type of @device
|
||||
*
|
||||
* Return value: the type of the device
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
ClutterInputDeviceType
|
||||
clutter_input_device_get_device_type (ClutterInputDevice *device)
|
||||
@ -551,8 +535,6 @@ clutter_input_device_get_capabilities (ClutterInputDevice *device)
|
||||
* Return value: the name of the device, or %NULL. The returned string
|
||||
* is owned by the #ClutterInputDevice and should never be modified
|
||||
* or freed
|
||||
*
|
||||
* Since: 1.2
|
||||
*/
|
||||
const gchar *
|
||||
clutter_input_device_get_device_name (ClutterInputDevice *device)
|
||||
@ -573,8 +555,6 @@ clutter_input_device_get_device_name (ClutterInputDevice *device)
|
||||
* device motion.
|
||||
*
|
||||
* Return value: %TRUE if the device has a cursor
|
||||
*
|
||||
* Since: 1.6
|
||||
*/
|
||||
gboolean
|
||||
clutter_input_device_get_has_cursor (ClutterInputDevice *device)
|
||||
@ -594,8 +574,6 @@ clutter_input_device_get_has_cursor (ClutterInputDevice *device)
|
||||
* Retrieves the #ClutterInputMode of @device.
|
||||
*
|
||||
* Return value: the device mode
|
||||
*
|
||||
* Since: 1.6
|
||||
*/
|
||||
ClutterInputMode
|
||||
clutter_input_device_get_device_mode (ClutterInputDevice *device)
|
||||
@ -615,9 +593,7 @@ clutter_input_device_get_device_mode (ClutterInputDevice *device)
|
||||
*
|
||||
* Gets the vendor ID of this device.
|
||||
*
|
||||
* Returns: the vendor ID
|
||||
*
|
||||
* Since: 1.22
|
||||
* Returns: the vendor ID2
|
||||
*/
|
||||
const gchar *
|
||||
clutter_input_device_get_vendor_id (ClutterInputDevice *device)
|
||||
@ -637,9 +613,7 @@ clutter_input_device_get_vendor_id (ClutterInputDevice *device)
|
||||
*
|
||||
* Gets the product ID of this device.
|
||||
*
|
||||
* Returns: the product ID
|
||||
*
|
||||
* Since: 1.22
|
||||
* Returns: the product ID2
|
||||
*/
|
||||
const gchar *
|
||||
clutter_input_device_get_product_id (ClutterInputDevice *device)
|
||||
|
@ -40,8 +40,6 @@
|
||||
*
|
||||
* #ClutterInterval can be subclassed to override the validation
|
||||
* and value computation.
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
|
||||
#include "clutter-build-config.h"
|
||||
@ -525,8 +523,6 @@ clutter_interval_class_init (ClutterIntervalClass *klass)
|
||||
* ClutterInterval:value-type:
|
||||
*
|
||||
* The type of the values in the interval.
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
obj_props[PROP_VALUE_TYPE] =
|
||||
g_param_spec_gtype ("value-type",
|
||||
@ -541,8 +537,6 @@ clutter_interval_class_init (ClutterIntervalClass *klass)
|
||||
* ClutterInterval:initial:
|
||||
*
|
||||
* The initial value of the interval.
|
||||
*
|
||||
* Since: 1.12
|
||||
*/
|
||||
obj_props[PROP_INITIAL] =
|
||||
g_param_spec_boxed ("initial",
|
||||
@ -556,8 +550,6 @@ clutter_interval_class_init (ClutterIntervalClass *klass)
|
||||
* ClutterInterval:final:
|
||||
*
|
||||
* The final value of the interval.
|
||||
*
|
||||
* Since: 1.12
|
||||
*/
|
||||
obj_props[PROP_FINAL] =
|
||||
g_param_spec_boxed ("final",
|
||||
@ -752,8 +744,6 @@ clutter_interval_get_interval_valist (ClutterInterval *interval,
|
||||
* ```
|
||||
*
|
||||
* Return value: the newly created #ClutterInterval
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
ClutterInterval *
|
||||
clutter_interval_new (GType gtype,
|
||||
@ -791,8 +781,6 @@ out:
|
||||
* This function is useful for language bindings.
|
||||
*
|
||||
* Return value: the newly created #ClutterInterval
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
ClutterInterval *
|
||||
clutter_interval_new_with_values (GType gtype,
|
||||
@ -817,8 +805,6 @@ clutter_interval_new_with_values (GType gtype,
|
||||
* Creates a copy of @interval.
|
||||
*
|
||||
* Return value: (transfer full): the newly created #ClutterInterval
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
ClutterInterval *
|
||||
clutter_interval_clone (ClutterInterval *interval)
|
||||
@ -849,8 +835,6 @@ clutter_interval_clone (ClutterInterval *interval)
|
||||
* Retrieves the #GType of the values inside @interval.
|
||||
*
|
||||
* Return value: the type of the value, or G_TYPE_INVALID
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
GType
|
||||
clutter_interval_get_value_type (ClutterInterval *interval)
|
||||
@ -867,8 +851,6 @@ clutter_interval_get_value_type (ClutterInterval *interval)
|
||||
*
|
||||
* Sets the initial value of @interval to @value. The value is copied
|
||||
* inside the #ClutterInterval.
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
void
|
||||
clutter_interval_set_initial_value (ClutterInterval *interval,
|
||||
@ -891,8 +873,6 @@ clutter_interval_set_initial_value (ClutterInterval *interval,
|
||||
*
|
||||
* Language bindings should use clutter_interval_set_initial_value()
|
||||
* instead.
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
void
|
||||
clutter_interval_set_initial (ClutterInterval *interval,
|
||||
@ -917,8 +897,6 @@ clutter_interval_set_initial (ClutterInterval *interval,
|
||||
*
|
||||
* The passed #GValue must be initialized to the value held by
|
||||
* the #ClutterInterval.
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
void
|
||||
clutter_interval_get_initial_value (ClutterInterval *interval,
|
||||
@ -939,8 +917,6 @@ clutter_interval_get_initial_value (ClutterInterval *interval,
|
||||
* Return value: (transfer none): the initial value of the interval.
|
||||
* The value is owned by the #ClutterInterval and it should not be
|
||||
* modified or freed
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
GValue *
|
||||
clutter_interval_peek_initial_value (ClutterInterval *interval)
|
||||
@ -957,8 +933,6 @@ clutter_interval_peek_initial_value (ClutterInterval *interval)
|
||||
*
|
||||
* Sets the final value of @interval to @value. The value is
|
||||
* copied inside the #ClutterInterval.
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
void
|
||||
clutter_interval_set_final_value (ClutterInterval *interval,
|
||||
@ -980,8 +954,6 @@ clutter_interval_set_final_value (ClutterInterval *interval,
|
||||
*
|
||||
* The passed #GValue must be initialized to the value held by
|
||||
* the #ClutterInterval.
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
void
|
||||
clutter_interval_get_final_value (ClutterInterval *interval,
|
||||
@ -1003,8 +975,6 @@ clutter_interval_get_final_value (ClutterInterval *interval,
|
||||
* This function is meant as a convenience for the C API.
|
||||
*
|
||||
* Language bindings should use clutter_interval_set_final_value() instead.
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
void
|
||||
clutter_interval_set_final (ClutterInterval *interval,
|
||||
@ -1028,8 +998,6 @@ clutter_interval_set_final (ClutterInterval *interval,
|
||||
* Return value: (transfer none): the final value of the interval.
|
||||
* The value is owned by the #ClutterInterval and it should not be
|
||||
* modified or freed
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
GValue *
|
||||
clutter_interval_peek_final_value (ClutterInterval *interval)
|
||||
@ -1056,8 +1024,6 @@ clutter_interval_peek_final_value (ClutterInterval *interval)
|
||||
*
|
||||
* This function is meant for the convenience of the C API; bindings
|
||||
* should reimplement this function using the #GValue-based API.
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
void
|
||||
clutter_interval_set_interval (ClutterInterval *interval,
|
||||
@ -1096,8 +1062,6 @@ out:
|
||||
*
|
||||
* This function is meant for the convenience of the C API; bindings
|
||||
* should reimplement this function using the #GValue-based API.
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
void
|
||||
clutter_interval_get_interval (ClutterInterval *interval,
|
||||
@ -1122,8 +1086,6 @@ clutter_interval_get_interval (ClutterInterval *interval,
|
||||
* a #GParamSpec.
|
||||
*
|
||||
* Return value: %TRUE if the #ClutterInterval is valid, %FALSE otherwise
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
gboolean
|
||||
clutter_interval_validate (ClutterInterval *interval,
|
||||
@ -1145,8 +1107,6 @@ clutter_interval_validate (ClutterInterval *interval,
|
||||
* progress @factor and copies it into @value.
|
||||
*
|
||||
* Return value: %TRUE if the operation was successful
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
gboolean
|
||||
clutter_interval_compute_value (ClutterInterval *interval,
|
||||
@ -1178,8 +1138,6 @@ clutter_interval_compute_value (ClutterInterval *interval,
|
||||
*
|
||||
* Return value: (transfer none): a pointer to the computed value,
|
||||
* or %NULL if the computation was not successful
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
const GValue *
|
||||
clutter_interval_compute (ClutterInterval *interval,
|
||||
@ -1213,8 +1171,6 @@ clutter_interval_compute (ClutterInterval *interval,
|
||||
*
|
||||
* Return value: %TRUE if the #ClutterInterval has an initial and
|
||||
* final values, and %FALSE otherwise
|
||||
*
|
||||
* Since: 1.12
|
||||
*/
|
||||
gboolean
|
||||
clutter_interval_is_valid (ClutterInterval *interval)
|
||||
|
@ -59,8 +59,6 @@ struct _ClutterInterval
|
||||
* inside an interval using an adimensional factor between 0 and 1
|
||||
*
|
||||
* The #ClutterIntervalClass contains only private data.
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
struct _ClutterIntervalClass
|
||||
{
|
||||
|
@ -57,9 +57,7 @@
|
||||
*
|
||||
* The #ClutterKeyframeTransition will add an implicit key frame between the last
|
||||
* and the 1.0 value, to interpolate to the final value of the transition's
|
||||
* interval.
|
||||
*
|
||||
* Since: 1.12.
|
||||
* interval..
|
||||
*/
|
||||
|
||||
#include "clutter-build-config.h"
|
||||
@ -396,8 +394,6 @@ clutter_keyframe_transition_init (ClutterKeyframeTransition *self)
|
||||
* Return value: (transfer full): the newly allocated
|
||||
* #ClutterKeyframeTransition instance. Use g_object_unref() when
|
||||
* done to free its resources.
|
||||
*
|
||||
* Since: 1.12
|
||||
*/
|
||||
ClutterTransition *
|
||||
clutter_keyframe_transition_new (const char *property_name)
|
||||
@ -419,8 +415,6 @@ clutter_keyframe_transition_new (const char *property_name)
|
||||
* If @transition does not hold any key frame, @n_key_frames key frames
|
||||
* will be created; if @transition already has key frames, @key_frames must
|
||||
* have at least as many elements as the number of key frames.
|
||||
*
|
||||
* Since: 1.12
|
||||
*/
|
||||
void
|
||||
clutter_keyframe_transition_set_key_frames (ClutterKeyframeTransition *transition,
|
||||
@ -461,8 +455,6 @@ clutter_keyframe_transition_set_key_frames (ClutterKeyframeTransition *transitio
|
||||
* If @transition does not hold any key frame, @n_values key frames will
|
||||
* be created; if @transition already has key frames, @values must have
|
||||
* at least as many elements as the number of key frames.
|
||||
*
|
||||
* Since: 1.12
|
||||
*/
|
||||
void
|
||||
clutter_keyframe_transition_set_values (ClutterKeyframeTransition *transition,
|
||||
@ -508,8 +500,6 @@ clutter_keyframe_transition_set_values (ClutterKeyframeTransition *transition,
|
||||
* If @transition does not hold any key frame, @n_modes key frames will
|
||||
* be created; if @transition already has key frames, @modes must have
|
||||
* at least as many elements as the number of key frames.
|
||||
*
|
||||
* Since: 1.12
|
||||
*/
|
||||
void
|
||||
clutter_keyframe_transition_set_modes (ClutterKeyframeTransition *transition,
|
||||
@ -553,8 +543,6 @@ clutter_keyframe_transition_set_modes (ClutterKeyframeTransition *transition,
|
||||
* language bindings should use clutter_keyframe_transition_set_key_frames(),
|
||||
* clutter_keyframe_transition_set_modes(), and
|
||||
* clutter_keyframe_transition_set_values() instead.
|
||||
*
|
||||
* Since: 1.12
|
||||
*/
|
||||
void
|
||||
clutter_keyframe_transition_set (ClutterKeyframeTransition *transition,
|
||||
@ -611,8 +599,6 @@ clutter_keyframe_transition_set (ClutterKeyframeTransition *transition,
|
||||
* @transition: a #ClutterKeyframeTransition
|
||||
*
|
||||
* Removes all key frames from @transition.
|
||||
*
|
||||
* Since: 1.12
|
||||
*/
|
||||
void
|
||||
clutter_keyframe_transition_clear (ClutterKeyframeTransition *transition)
|
||||
@ -633,8 +619,6 @@ clutter_keyframe_transition_clear (ClutterKeyframeTransition *transition)
|
||||
* Retrieves the number of key frames inside @transition.
|
||||
*
|
||||
* Return value: the number of key frames
|
||||
*
|
||||
* Since: 1.12
|
||||
*/
|
||||
guint
|
||||
clutter_keyframe_transition_get_n_key_frames (ClutterKeyframeTransition *transition)
|
||||
@ -659,8 +643,6 @@ clutter_keyframe_transition_get_n_key_frames (ClutterKeyframeTransition *transit
|
||||
*
|
||||
* The @transition must already have a key frame at @index_, and @index_
|
||||
* must be smaller than the number of key frames inside @transition.
|
||||
*
|
||||
* Since: 1.12
|
||||
*/
|
||||
void
|
||||
clutter_keyframe_transition_set_key_frame (ClutterKeyframeTransition *transition,
|
||||
@ -697,8 +679,6 @@ clutter_keyframe_transition_set_key_frame (ClutterKeyframeTransition *transition
|
||||
*
|
||||
* The @transition must already have key frames set, and @index_ must be
|
||||
* smaller than the number of key frames.
|
||||
*
|
||||
* Since: 1.12
|
||||
*/
|
||||
void
|
||||
clutter_keyframe_transition_get_key_frame (ClutterKeyframeTransition *transition,
|
||||
|
@ -56,8 +56,6 @@ struct _ClutterKeyframeTransition
|
||||
*
|
||||
* The `ClutterKeyframeTransitionClass` structure contains only
|
||||
* private data.
|
||||
*
|
||||
* Since: 1.12
|
||||
*/
|
||||
struct _ClutterKeyframeTransitionClass
|
||||
{
|
||||
|
@ -1643,8 +1643,6 @@ static const int clutter_unicode_to_keysym_tab_size =
|
||||
*
|
||||
* Return value: the corresponding Clutter key symbol, if one exists.
|
||||
* or, if there is no corresponding symbol, wc | 0x01000000
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
guint
|
||||
clutter_unicode_to_keysym (guint32 wc)
|
||||
|
@ -125,8 +125,6 @@
|
||||
* ]
|
||||
* }
|
||||
* ```
|
||||
*
|
||||
* Since: 1.2
|
||||
*/
|
||||
|
||||
#include "clutter-build-config.h"
|
||||
@ -340,8 +338,6 @@ clutter_layout_manager_class_init (ClutterLayoutManagerClass *klass)
|
||||
* can be controlled or changed using parameters should emit the
|
||||
* ::layout-changed signal whenever one of the parameters changes,
|
||||
* by using clutter_layout_manager_layout_changed().
|
||||
*
|
||||
* Since: 1.2
|
||||
*/
|
||||
manager_signals[LAYOUT_CHANGED] =
|
||||
g_signal_new (I_("layout-changed"),
|
||||
@ -372,8 +368,6 @@ clutter_layout_manager_init (ClutterLayoutManager *manager)
|
||||
* to @manager.
|
||||
*
|
||||
* See also clutter_actor_get_preferred_width()
|
||||
*
|
||||
* Since: 1.2
|
||||
*/
|
||||
void
|
||||
clutter_layout_manager_get_preferred_width (ClutterLayoutManager *manager,
|
||||
@ -407,8 +401,6 @@ clutter_layout_manager_get_preferred_width (ClutterLayoutManager *manager,
|
||||
* to @manager.
|
||||
*
|
||||
* See also clutter_actor_get_preferred_height()
|
||||
*
|
||||
* Since: 1.2
|
||||
*/
|
||||
void
|
||||
clutter_layout_manager_get_preferred_height (ClutterLayoutManager *manager,
|
||||
@ -438,8 +430,6 @@ clutter_layout_manager_get_preferred_height (ClutterLayoutManager *manager,
|
||||
* Allocates the children of @container given an area
|
||||
*
|
||||
* See also clutter_actor_allocate()
|
||||
*
|
||||
* Since: 1.2
|
||||
*/
|
||||
void
|
||||
clutter_layout_manager_allocate (ClutterLayoutManager *manager,
|
||||
@ -464,8 +454,6 @@ clutter_layout_manager_allocate (ClutterLayoutManager *manager,
|
||||
*
|
||||
* This function should only be called by implementations of the
|
||||
* #ClutterLayoutManager class
|
||||
*
|
||||
* Since: 1.2
|
||||
*/
|
||||
void
|
||||
clutter_layout_manager_layout_changed (ClutterLayoutManager *manager)
|
||||
@ -494,8 +482,6 @@ clutter_layout_manager_layout_changed (ClutterLayoutManager *manager)
|
||||
*
|
||||
* The layout manager should not increase the reference
|
||||
* count of the @container
|
||||
*
|
||||
* Since: 1.2
|
||||
*/
|
||||
void
|
||||
clutter_layout_manager_set_container (ClutterLayoutManager *manager,
|
||||
@ -586,8 +572,6 @@ get_child_meta (ClutterLayoutManager *manager,
|
||||
* #ClutterLayoutManager does not have layout properties. The returned
|
||||
* layout meta instance is owned by the #ClutterLayoutManager and it
|
||||
* should not be unreferenced
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
ClutterLayoutMeta *
|
||||
clutter_layout_manager_get_child_meta (ClutterLayoutManager *manager,
|
||||
@ -660,8 +644,6 @@ layout_get_property_internal (ClutterLayoutManager *manager,
|
||||
*
|
||||
* Languages bindings should use clutter_layout_manager_child_set_property()
|
||||
* instead
|
||||
*
|
||||
* Since: 1.2
|
||||
*/
|
||||
void
|
||||
clutter_layout_manager_child_set (ClutterLayoutManager *manager,
|
||||
@ -746,8 +728,6 @@ clutter_layout_manager_child_set (ClutterLayoutManager *manager,
|
||||
*
|
||||
* Sets a property on the #ClutterLayoutMeta created by @manager and
|
||||
* attached to a child of @container
|
||||
*
|
||||
* Since: 1.2
|
||||
*/
|
||||
void
|
||||
clutter_layout_manager_child_set_property (ClutterLayoutManager *manager,
|
||||
@ -800,8 +780,6 @@ clutter_layout_manager_child_set_property (ClutterLayoutManager *manager,
|
||||
* Retrieves the values for a list of properties out of the
|
||||
* #ClutterLayoutMeta created by @manager and attached to the
|
||||
* child of a @container
|
||||
*
|
||||
* Since: 1.2
|
||||
*/
|
||||
void
|
||||
clutter_layout_manager_child_get (ClutterLayoutManager *manager,
|
||||
@ -892,8 +870,6 @@ clutter_layout_manager_child_get (ClutterLayoutManager *manager,
|
||||
* The #GValue must already be initialized to the type of the property
|
||||
* and has to be unset with g_value_unset() after extracting the real
|
||||
* value out of it
|
||||
*
|
||||
* Since: 1.2
|
||||
*/
|
||||
void
|
||||
clutter_layout_manager_child_get_property (ClutterLayoutManager *manager,
|
||||
@ -947,8 +923,6 @@ clutter_layout_manager_child_get_property (ClutterLayoutManager *manager,
|
||||
* or %NULL if no property with that name exists. The returned
|
||||
* #GParamSpec is owned by the layout manager and should not be
|
||||
* modified or freed
|
||||
*
|
||||
* Since: 1.2
|
||||
*/
|
||||
GParamSpec *
|
||||
clutter_layout_manager_find_child_property (ClutterLayoutManager *manager,
|
||||
@ -985,8 +959,6 @@ clutter_layout_manager_find_child_property (ClutterLayoutManager *manager,
|
||||
* Return value: (transfer full) (array length=n_pspecs): the newly-allocated,
|
||||
* %NULL-terminated array of `GParamSpec`s. Use g_free() to free the
|
||||
* resources allocated for the array
|
||||
*
|
||||
* Since: 1.2
|
||||
*/
|
||||
GParamSpec **
|
||||
clutter_layout_manager_list_child_properties (ClutterLayoutManager *manager,
|
||||
|
@ -86,8 +86,6 @@ struct _ClutterLayoutManager
|
||||
*
|
||||
* The #ClutterLayoutManagerClass structure contains only private
|
||||
* data and should be accessed using the provided API
|
||||
*
|
||||
* Since: 1.2
|
||||
*/
|
||||
struct _ClutterLayoutManagerClass
|
||||
{
|
||||
|
@ -32,8 +32,6 @@
|
||||
*
|
||||
* A #ClutterLayoutMeta wraps a [class@Actor] inside a [iface@Container]
|
||||
* using a [class@LayoutManager].
|
||||
*
|
||||
* Since: 1.2
|
||||
*/
|
||||
|
||||
#include "clutter-build-config.h"
|
||||
@ -110,8 +108,6 @@ clutter_layout_meta_class_init (ClutterLayoutMetaClass *klass)
|
||||
* ClutterLayoutMeta:manager:
|
||||
*
|
||||
* The [class@LayoutManager] that created this #ClutterLayoutMeta.
|
||||
*
|
||||
* Since: 1.2
|
||||
*/
|
||||
pspec = g_param_spec_object ("manager",
|
||||
P_("Manager"),
|
||||
@ -135,8 +131,6 @@ clutter_layout_meta_init (ClutterLayoutMeta *self)
|
||||
* Retrieves the actor wrapped by @data
|
||||
*
|
||||
* Return value: (transfer none): a #ClutterLayoutManager
|
||||
*
|
||||
* Since: 1.2
|
||||
*/
|
||||
ClutterLayoutManager *
|
||||
clutter_layout_meta_get_manager (ClutterLayoutMeta *data)
|
||||
|
@ -65,8 +65,6 @@ struct _ClutterLayoutMeta
|
||||
*
|
||||
* The #ClutterLayoutMetaClass contains only private data and
|
||||
* should never be accessed directly
|
||||
*
|
||||
* Since: 1.2
|
||||
*/
|
||||
struct _ClutterLayoutMetaClass
|
||||
{
|
||||
|
@ -31,8 +31,6 @@
|
||||
*
|
||||
* GL Windowing system used
|
||||
*
|
||||
* Since: 0.4
|
||||
*
|
||||
* Deprecated: 1.10: The macro evaluates to "deprecated" as Clutter can be
|
||||
* compiled with multiple windowing system backends. Use the various
|
||||
* CLUTTER_WINDOWING_* macros to detect the windowing system that Clutter
|
||||
@ -47,8 +45,6 @@
|
||||
* Cogl (internal GL abstraction utility library) backend. Can be "gl" or
|
||||
* "gles" currently
|
||||
*
|
||||
* Since: 0.4
|
||||
*
|
||||
* Deprecated: 1.10: The macro evaluates to "deprecated" as Cogl can be
|
||||
* compiled against multiple GL implementations.
|
||||
*/
|
||||
@ -59,8 +55,6 @@
|
||||
*
|
||||
* The default GObject type for the Clutter stage.
|
||||
*
|
||||
* Since: 0.8
|
||||
*
|
||||
* Deprecated: 1.10: The macro evaluates to "deprecated" as Clutter can
|
||||
* be compiled against multiple windowing systems. You can use the
|
||||
* CLUTTER_WINDOWING_* macros for compile-time checks, and the type
|
||||
|
@ -151,8 +151,6 @@ _clutter_context_get_show_fps (void)
|
||||
* implementation available
|
||||
*
|
||||
* Return value: %TRUE if Clutter has accessibility support enabled
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
gboolean
|
||||
clutter_get_accessibility_enabled (void)
|
||||
@ -167,8 +165,6 @@ clutter_get_accessibility_enabled (void)
|
||||
* as setting the environment variable
|
||||
* CLUTTER_DISABLE_ACCESSIBILITY. For the same reason, this method
|
||||
* should be called before clutter_init().
|
||||
*
|
||||
* Since: 1.14
|
||||
*/
|
||||
void
|
||||
clutter_disable_accessibility (void)
|
||||
@ -354,8 +350,6 @@ _clutter_threads_dispatch_free (gpointer data)
|
||||
* ```
|
||||
*
|
||||
* Return value: the ID (greater than 0) of the event source.
|
||||
*
|
||||
* Since: 0.4
|
||||
*/
|
||||
guint
|
||||
clutter_threads_add_idle_full (gint priority,
|
||||
@ -386,8 +380,6 @@ clutter_threads_add_idle_full (gint priority,
|
||||
* default priority.
|
||||
*
|
||||
* Return value: the ID (greater than 0) of the event source.
|
||||
*
|
||||
* Since: 0.4
|
||||
*/
|
||||
guint
|
||||
clutter_threads_add_idle (GSourceFunc func,
|
||||
@ -424,8 +416,6 @@ clutter_threads_add_idle (GSourceFunc func,
|
||||
* See also clutter_threads_add_idle_full().
|
||||
*
|
||||
* Return value: the ID (greater than 0) of the event source.
|
||||
*
|
||||
* Since: 0.4
|
||||
*/
|
||||
guint
|
||||
clutter_threads_add_timeout_full (gint priority,
|
||||
@ -458,8 +448,6 @@ clutter_threads_add_timeout_full (gint priority,
|
||||
* Simple wrapper around clutter_threads_add_timeout_full().
|
||||
*
|
||||
* Return value: the ID (greater than 0) of the event source.
|
||||
*
|
||||
* Since: 0.4
|
||||
*/
|
||||
guint
|
||||
clutter_threads_add_timeout (guint interval,
|
||||
@ -755,8 +743,6 @@ remove_device_for_event (ClutterStage *stage,
|
||||
*
|
||||
* This function is only useful when embedding Clutter inside another
|
||||
* toolkit, and it should never be called by applications.
|
||||
*
|
||||
* Since: 0.4
|
||||
*/
|
||||
void
|
||||
clutter_do_event (ClutterEvent *event)
|
||||
@ -996,8 +982,6 @@ _clutter_process_event (ClutterEvent *event)
|
||||
*
|
||||
* Return value: (transfer none): the #PangoFontMap instance. The returned
|
||||
* value is owned by Clutter and it should never be unreferenced.
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
PangoFontMap *
|
||||
clutter_get_font_map (void)
|
||||
@ -1019,8 +1003,6 @@ typedef struct _ClutterRepaintFunction
|
||||
* @handle_id: an unsigned integer greater than zero
|
||||
*
|
||||
* Removes the repaint function with @handle_id as its id
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
void
|
||||
clutter_threads_remove_repaint_func (guint handle_id)
|
||||
@ -1091,8 +1073,6 @@ clutter_threads_remove_repaint_func (guint handle_id)
|
||||
* Return value: the ID (greater than 0) of the repaint function. You
|
||||
* can use the returned integer to remove the repaint function by
|
||||
* calling clutter_threads_remove_repaint_func().
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
guint
|
||||
clutter_threads_add_repaint_func (GSourceFunc func,
|
||||
@ -1138,8 +1118,6 @@ clutter_threads_add_repaint_func (GSourceFunc func,
|
||||
* Return value: the ID (greater than 0) of the repaint function. You
|
||||
* can use the returned integer to remove the repaint function by
|
||||
* calling clutter_threads_remove_repaint_func().
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
guint
|
||||
clutter_threads_add_repaint_func_full (ClutterRepaintFlags flags,
|
||||
@ -1242,8 +1220,6 @@ _clutter_run_repaint_functions (ClutterRepaintFlags flags)
|
||||
* [method@Actor.set_text_direction].
|
||||
*
|
||||
* Return value: the default text direction
|
||||
*
|
||||
* Since: 1.2
|
||||
*/
|
||||
ClutterTextDirection
|
||||
clutter_get_default_text_direction (void)
|
||||
|
@ -85,8 +85,6 @@ typedef enum
|
||||
* GTK+ and Clutter it's more likely that the Clutter part will be
|
||||
* continually animating (and thus able to starve GTK+) than
|
||||
* vice-versa.
|
||||
*
|
||||
* Since: 0.8
|
||||
*/
|
||||
#define CLUTTER_PRIORITY_REDRAW (G_PRIORITY_HIGH_IDLE + 50)
|
||||
|
||||
|
@ -83,8 +83,6 @@
|
||||
*
|
||||
* In both cases, the "Pipeline" node is created with the return value
|
||||
* of [vfunc@OffscreenEffect.create_pipeline].
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
|
||||
#include "clutter-build-config.h"
|
||||
@ -629,8 +627,6 @@ clutter_offscreen_effect_init (ClutterOffscreenEffect *self)
|
||||
* Return value: (transfer none): a #CoglHandle or %NULL. The
|
||||
* returned texture is owned by Clutter and it should not be
|
||||
* modified or freed
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
CoglHandle
|
||||
clutter_offscreen_effect_get_texture (ClutterOffscreenEffect *effect)
|
||||
@ -654,8 +650,6 @@ clutter_offscreen_effect_get_texture (ClutterOffscreenEffect *effect)
|
||||
* Return value: (transfer none)(nullable): a #CoglPipeline. The
|
||||
* pipeline is owned by Clutter and it should not be modified
|
||||
* or freed
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
CoglPipeline *
|
||||
clutter_offscreen_effect_get_pipeline (ClutterOffscreenEffect *effect)
|
||||
@ -673,8 +667,6 @@ clutter_offscreen_effect_get_pipeline (ClutterOffscreenEffect *effect)
|
||||
* @paint_context: a #ClutterPaintContext
|
||||
*
|
||||
* Calls the [vfunc@OffscreenEffect.paint_target] virtual function of the @effect
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
void
|
||||
clutter_offscreen_effect_paint_target (ClutterOffscreenEffect *effect,
|
||||
@ -699,8 +691,6 @@ clutter_offscreen_effect_paint_target (ClutterOffscreenEffect *effect,
|
||||
* Return value: (transfer full): a handle to a Cogl texture, or
|
||||
* %NULL. The returned handle has its reference
|
||||
* count increased.
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
CoglHandle
|
||||
clutter_offscreen_effect_create_texture (ClutterOffscreenEffect *effect,
|
||||
@ -730,8 +720,6 @@ clutter_offscreen_effect_create_texture (ClutterOffscreenEffect *effect,
|
||||
*
|
||||
* Return value: %TRUE if the offscreen buffer has a valid size,
|
||||
* and %FALSE otherwise
|
||||
*
|
||||
* Since: 1.8
|
||||
*/
|
||||
gboolean
|
||||
clutter_offscreen_effect_get_target_size (ClutterOffscreenEffect *effect,
|
||||
|
@ -59,8 +59,6 @@ struct _ClutterOffscreenEffect
|
||||
* @paint_target: virtual function
|
||||
*
|
||||
* The #ClutterOffscreenEffectClass structure contains only private data
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
struct _ClutterOffscreenEffectClass
|
||||
{
|
||||
|
@ -31,8 +31,6 @@
|
||||
* A page turning effect
|
||||
*
|
||||
* A simple page turning effect
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
|
||||
#include "clutter-build-config.h"
|
||||
@ -216,8 +214,6 @@ clutter_page_turn_effect_class_init (ClutterPageTurnEffectClass *klass)
|
||||
*
|
||||
* The period of the page turn, between 0.0 (no curling) and
|
||||
* 1.0 (fully curled)
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
pspec = g_param_spec_double ("period",
|
||||
"Period",
|
||||
@ -232,8 +228,6 @@ clutter_page_turn_effect_class_init (ClutterPageTurnEffectClass *klass)
|
||||
* ClutterPageTurnEffect:angle:
|
||||
*
|
||||
* The angle of the page rotation, in degrees, between 0.0 and 360.0
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
pspec = g_param_spec_double ("angle",
|
||||
"Angle",
|
||||
@ -248,8 +242,6 @@ clutter_page_turn_effect_class_init (ClutterPageTurnEffectClass *klass)
|
||||
* ClutterPageTurnEffect:radius:
|
||||
*
|
||||
* The radius of the page curl, in pixels
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
pspec = g_param_spec_float ("radius",
|
||||
"Radius",
|
||||
@ -280,8 +272,6 @@ clutter_page_turn_effect_init (ClutterPageTurnEffect *self)
|
||||
* Creates a new #ClutterPageTurnEffect instance with the given parameters
|
||||
*
|
||||
* Return value: the newly created #ClutterPageTurnEffect
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
ClutterEffect *
|
||||
clutter_page_turn_effect_new (gdouble period,
|
||||
@ -305,8 +295,6 @@ clutter_page_turn_effect_new (gdouble period,
|
||||
*
|
||||
* Sets the period of the page curling, between 0.0 (no curling)
|
||||
* and 1.0 (fully curled)
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
void
|
||||
clutter_page_turn_effect_set_period (ClutterPageTurnEffect *effect,
|
||||
@ -329,8 +317,6 @@ clutter_page_turn_effect_set_period (ClutterPageTurnEffect *effect,
|
||||
* Retrieves the value set using [method@PageTurnEffect.get_period]
|
||||
*
|
||||
* Return value: the period of the page curling
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
gdouble
|
||||
clutter_page_turn_effect_get_period (ClutterPageTurnEffect *effect)
|
||||
@ -346,8 +332,6 @@ clutter_page_turn_effect_get_period (ClutterPageTurnEffect *effect)
|
||||
* @angle: the angle of the page curl, in degrees
|
||||
*
|
||||
* Sets the angle of the page curling, in degrees
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
void
|
||||
clutter_page_turn_effect_set_angle (ClutterPageTurnEffect *effect,
|
||||
@ -370,8 +354,6 @@ clutter_page_turn_effect_set_angle (ClutterPageTurnEffect *effect,
|
||||
* Retrieves the value set using [method@PageTurnEffect.get_angle]
|
||||
*
|
||||
* Return value: the angle of the page curling
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
gdouble
|
||||
clutter_page_turn_effect_get_angle (ClutterPageTurnEffect *effect)
|
||||
@ -387,8 +369,6 @@ clutter_page_turn_effect_get_angle (ClutterPageTurnEffect *effect)
|
||||
* @radius: the radius of the page curling, in pixels
|
||||
*
|
||||
* Sets the radius of the page curling
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
void
|
||||
clutter_page_turn_effect_set_radius (ClutterPageTurnEffect *effect,
|
||||
@ -410,8 +390,6 @@ clutter_page_turn_effect_set_radius (ClutterPageTurnEffect *effect,
|
||||
* Retrieves the value set using [method@PageTurnEffect.set_radius]
|
||||
*
|
||||
* Return value: the radius of the page curling
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
gfloat
|
||||
clutter_page_turn_effect_get_radius (ClutterPageTurnEffect *effect)
|
||||
|
@ -39,16 +39,12 @@
|
||||
*
|
||||
* Each #ClutterActor can submit multiple `ClutterPaintNode`s to
|
||||
* the render graph.
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
|
||||
/**
|
||||
* ClutterPaintNodeClass:
|
||||
*
|
||||
* The `ClutterPaintNodeClass` structure contains only private data.
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
|
||||
#include "clutter-build-config.h"
|
||||
@ -288,8 +284,6 @@ clutter_paint_node_get_type (void)
|
||||
*
|
||||
* The @node will intern @name using g_intern_string(). If you have access to a
|
||||
* static string, use clutter_paint_node_set_static_name() instead.
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
void
|
||||
clutter_paint_node_set_name (ClutterPaintNode *node,
|
||||
@ -322,8 +316,6 @@ clutter_paint_node_set_static_name (ClutterPaintNode *node,
|
||||
* Acquires a reference on @node.
|
||||
*
|
||||
* Return value: (transfer full): the #ClutterPaintNode
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
ClutterPaintNode *
|
||||
clutter_paint_node_ref (ClutterPaintNode *node)
|
||||
@ -340,8 +332,6 @@ clutter_paint_node_ref (ClutterPaintNode *node)
|
||||
* @node: a #ClutterPaintNode
|
||||
*
|
||||
* Releases a reference on @node.
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
void
|
||||
clutter_paint_node_unref (ClutterPaintNode *node)
|
||||
@ -364,8 +354,6 @@ clutter_paint_node_unref (ClutterPaintNode *node)
|
||||
* Adds @child to the list of children of @node.
|
||||
*
|
||||
* This function will acquire a reference on @child.
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
void
|
||||
clutter_paint_node_add_child (ClutterPaintNode *node,
|
||||
@ -406,8 +394,6 @@ clutter_paint_node_add_child (ClutterPaintNode *node,
|
||||
*
|
||||
* This function will release the reference on @child acquired by
|
||||
* using clutter_paint_node_add_child().
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
void
|
||||
clutter_paint_node_remove_child (ClutterPaintNode *node,
|
||||
@ -455,8 +441,6 @@ clutter_paint_node_remove_child (ClutterPaintNode *node,
|
||||
*
|
||||
* This function will release the reference on @old_child acquired
|
||||
* by @node, and will acquire a new reference on @new_child.
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
void
|
||||
clutter_paint_node_replace_child (ClutterPaintNode *node,
|
||||
@ -505,8 +489,6 @@ clutter_paint_node_replace_child (ClutterPaintNode *node,
|
||||
*
|
||||
* This function releases the reference acquired by @node on its
|
||||
* children.
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
void
|
||||
clutter_paint_node_remove_all (ClutterPaintNode *node)
|
||||
@ -534,8 +516,6 @@ clutter_paint_node_remove_all (ClutterPaintNode *node)
|
||||
*
|
||||
* Return value: (transfer none): a pointer to the first child of
|
||||
* the #ClutterPaintNode.
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
ClutterPaintNode *
|
||||
clutter_paint_node_get_first_child (ClutterPaintNode *node)
|
||||
@ -553,8 +533,6 @@ clutter_paint_node_get_first_child (ClutterPaintNode *node)
|
||||
*
|
||||
* Return value: (transfer none): a pointer to the previous sibling
|
||||
* of the #ClutterPaintNode.
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
ClutterPaintNode *
|
||||
clutter_paint_node_get_previous_sibling (ClutterPaintNode *node)
|
||||
@ -572,8 +550,6 @@ clutter_paint_node_get_previous_sibling (ClutterPaintNode *node)
|
||||
*
|
||||
* Return value: (transfer none): a pointer to the next sibling
|
||||
* of a #ClutterPaintNode
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
ClutterPaintNode *
|
||||
clutter_paint_node_get_next_sibling (ClutterPaintNode *node)
|
||||
@ -591,8 +567,6 @@ clutter_paint_node_get_next_sibling (ClutterPaintNode *node)
|
||||
*
|
||||
* Return value: (transfer none): a pointer to the last child
|
||||
* of a #ClutterPaintNode
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
ClutterPaintNode *
|
||||
clutter_paint_node_get_last_child (ClutterPaintNode *node)
|
||||
@ -610,8 +584,6 @@ clutter_paint_node_get_last_child (ClutterPaintNode *node)
|
||||
*
|
||||
* Return value: (transfer none): a pointer to the parent of
|
||||
* a #ClutterPaintNode
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
ClutterPaintNode *
|
||||
clutter_paint_node_get_parent (ClutterPaintNode *node)
|
||||
@ -628,8 +600,6 @@ clutter_paint_node_get_parent (ClutterPaintNode *node)
|
||||
* Retrieves the number of children of @node.
|
||||
*
|
||||
* Return value: the number of children of a #ClutterPaintNode
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
guint
|
||||
clutter_paint_node_get_n_children (ClutterPaintNode *node)
|
||||
@ -649,8 +619,6 @@ clutter_paint_node_get_n_children (ClutterPaintNode *node)
|
||||
* This function increased the reference count of @node; if you do not wish
|
||||
* to increase the reference count, use clutter_value_take_paint_node()
|
||||
* instead. The reference count will be released by g_value_unset().
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
void
|
||||
clutter_value_set_paint_node (GValue *value,
|
||||
@ -685,8 +653,6 @@ clutter_value_set_paint_node (GValue *value,
|
||||
* Unlike clutter_value_set_paint_node(), this function will not take a
|
||||
* reference on the passed @node: instead, it will take ownership of the
|
||||
* current reference count.
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
void
|
||||
clutter_value_take_paint_node (GValue *value,
|
||||
@ -721,8 +687,6 @@ clutter_value_take_paint_node (GValue *value,
|
||||
*
|
||||
* Return value: (transfer none) (type Clutter.PaintNode): a pointer to
|
||||
* a #ClutterPaintNode, or %NULL
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
gpointer
|
||||
clutter_value_get_paint_node (const GValue *value)
|
||||
@ -743,8 +707,6 @@ clutter_value_get_paint_node (const GValue *value)
|
||||
* Return value: (transfer full) (type Clutter.PaintNode): a pointer
|
||||
* to the #ClutterPaintNode, with its reference count increased,
|
||||
* or %NULL
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
gpointer
|
||||
clutter_value_dup_paint_node (const GValue *value)
|
||||
@ -879,8 +841,6 @@ clutter_paint_node_maybe_init_operations (ClutterPaintNode *node)
|
||||
*
|
||||
* Adds a rectangle region to the @node, as described by the
|
||||
* passed @rect.
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
void
|
||||
clutter_paint_node_add_rectangle (ClutterPaintNode *node,
|
||||
@ -907,8 +867,6 @@ clutter_paint_node_add_rectangle (ClutterPaintNode *node,
|
||||
* @y_2: the bottom Y coordinate of the texture
|
||||
*
|
||||
* Adds a rectangle region to the @node, with texture coordinates.
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
void
|
||||
clutter_paint_node_add_texture_rectangle (ClutterPaintNode *node,
|
||||
@ -1033,8 +991,6 @@ clutter_paint_node_add_texture_rectangles (ClutterPaintNode *node,
|
||||
*
|
||||
* This function acquires a reference on @primitive, so it is safe
|
||||
* to call cogl_object_unref() when it returns.
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
void
|
||||
clutter_paint_node_add_primitive (ClutterPaintNode *node,
|
||||
|
@ -102,8 +102,6 @@ void clutter_paint_node_add_primitive (Clutter
|
||||
*
|
||||
* Evaluates to %TRUE if the @value has been initialized to hold
|
||||
* a #ClutterPaintNode.
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
#define CLUTTER_VALUE_HOLDS_PAINT_NODE(value) (G_VALUE_HOLDS (value, CLUTTER_TYPE_PAINT_NODE))
|
||||
|
||||
|
@ -176,8 +176,6 @@ clutter_root_node_new (CoglFramebuffer *framebuffer,
|
||||
|
||||
/*
|
||||
* ClutterTransformNode:
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
|
||||
struct _ClutterTransformNode
|
||||
@ -358,8 +356,6 @@ _clutter_dummy_node_new (ClutterActor *actor,
|
||||
|
||||
/**
|
||||
* ClutterPipelineNode:
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
|
||||
struct _ClutterPipelineNode
|
||||
@ -374,8 +370,6 @@ struct _ClutterPipelineNode
|
||||
*
|
||||
* The `ClutterPipelineNodeClass` structure is an opaque
|
||||
* type whose members cannot be directly accessed.
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
struct _ClutterPipelineNodeClass
|
||||
{
|
||||
@ -564,8 +558,6 @@ clutter_pipeline_node_init (ClutterPipelineNode *self)
|
||||
*
|
||||
* Return value: (transfer full): the newly created #ClutterPaintNode.
|
||||
* Use clutter_paint_node_unref() when done.
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
ClutterPaintNode *
|
||||
clutter_pipeline_node_new (CoglPipeline *pipeline)
|
||||
@ -584,8 +576,6 @@ clutter_pipeline_node_new (CoglPipeline *pipeline)
|
||||
|
||||
/**
|
||||
* ClutterColorNode:
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
|
||||
struct _ClutterColorNode
|
||||
@ -598,8 +588,6 @@ struct _ClutterColorNode
|
||||
*
|
||||
* The `ClutterColorNodeClass` structure is an
|
||||
* opaque type whose members cannot be directly accessed.
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
struct _ClutterColorNodeClass
|
||||
{
|
||||
@ -632,8 +620,6 @@ clutter_color_node_init (ClutterColorNode *cnode)
|
||||
*
|
||||
* Return value: (transfer full): the newly created #ClutterPaintNode. Use
|
||||
* clutter_paint_node_unref() when done
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
ClutterPaintNode *
|
||||
clutter_color_node_new (const ClutterColor *color)
|
||||
@ -662,8 +648,6 @@ clutter_color_node_new (const ClutterColor *color)
|
||||
/**
|
||||
* ClutterTextureNode:
|
||||
*
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
|
||||
struct _ClutterTextureNode
|
||||
@ -676,8 +660,6 @@ struct _ClutterTextureNode
|
||||
*
|
||||
* The `ClutterTextureNodeClass` structure is an
|
||||
* opaque type whose members cannot be directly accessed.
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
struct _ClutterTextureNodeClass
|
||||
{
|
||||
@ -736,8 +718,6 @@ clutter_scaling_filter_to_cogl_pipeline_filter (ClutterScalingFilter filter)
|
||||
*
|
||||
* Return value: (transfer full): the newly created #ClutterPaintNode.
|
||||
* Use clutter_paint_node_unref() when done
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
ClutterPaintNode *
|
||||
clutter_texture_node_new (CoglTexture *texture,
|
||||
@ -779,8 +759,6 @@ clutter_texture_node_new (CoglTexture *texture,
|
||||
|
||||
/**
|
||||
* ClutterTextNode:
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
struct _ClutterTextNode
|
||||
{
|
||||
@ -795,8 +773,6 @@ struct _ClutterTextNode
|
||||
*
|
||||
* The `ClutterTextNodeClass` structure is an opaque
|
||||
* type whose contents cannot be directly accessed.
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
struct _ClutterTextNodeClass
|
||||
{
|
||||
@ -961,8 +937,6 @@ clutter_text_node_init (ClutterTextNode *self)
|
||||
*
|
||||
* Return value: (transfer full): the newly created #ClutterPaintNode.
|
||||
* Use clutter_paint_node_unref() when done
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
ClutterPaintNode *
|
||||
clutter_text_node_new (PangoLayout *layout,
|
||||
@ -991,8 +965,6 @@ clutter_text_node_new (PangoLayout *layout,
|
||||
|
||||
/**
|
||||
* ClutterClipNode:
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
struct _ClutterClipNode
|
||||
{
|
||||
@ -1004,8 +976,6 @@ struct _ClutterClipNode
|
||||
*
|
||||
* The `ClutterClipNodeClass` structure is an opaque
|
||||
* type whose members cannot be directly accessed.
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
struct _ClutterClipNodeClass
|
||||
{
|
||||
@ -1111,8 +1081,6 @@ clutter_clip_node_init (ClutterClipNode *self)
|
||||
*
|
||||
* Return value: (transfer full): the newly created #ClutterPaintNode.
|
||||
* Use clutter_paint_node_unref() when done.
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
ClutterPaintNode *
|
||||
clutter_clip_node_new (void)
|
||||
@ -1546,8 +1514,6 @@ clutter_layer_node_init (ClutterLayerNode *self)
|
||||
*
|
||||
* Return value: (transfer full): the newly created #ClutterLayerNode.
|
||||
* Use clutter_paint_node_unref() when done.
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
ClutterPaintNode *
|
||||
clutter_layer_node_new (const graphene_matrix_t *projection,
|
||||
|
@ -49,8 +49,6 @@ G_DEFINE_BOXED_TYPE (ClutterPaintVolume, clutter_paint_volume,
|
||||
*
|
||||
* Return value: the newly allocated #ClutterPaintVolume. Use
|
||||
* clutter_paint_volume_free() to free the resources it uses
|
||||
*
|
||||
* Since: 1.6
|
||||
*/
|
||||
ClutterPaintVolume *
|
||||
_clutter_paint_volume_new (ClutterActor *actor)
|
||||
@ -123,8 +121,6 @@ _clutter_paint_volume_copy_static (const ClutterPaintVolume *src_pv,
|
||||
* Copies @pv into a new #ClutterPaintVolume
|
||||
*
|
||||
* Return value: a newly allocated copy of a #ClutterPaintVolume
|
||||
*
|
||||
* Since: 1.6
|
||||
*/
|
||||
ClutterPaintVolume *
|
||||
clutter_paint_volume_copy (const ClutterPaintVolume *pv)
|
||||
@ -153,8 +149,6 @@ _clutter_paint_volume_set_from_volume (ClutterPaintVolume *pv,
|
||||
* @pv: a #ClutterPaintVolume
|
||||
*
|
||||
* Frees the resources allocated by @pv
|
||||
*
|
||||
* Since: 1.6
|
||||
*/
|
||||
void
|
||||
clutter_paint_volume_free (ClutterPaintVolume *pv)
|
||||
@ -178,8 +172,6 @@ clutter_paint_volume_free (ClutterPaintVolume *pv)
|
||||
* corner of an actor's paint volume, in actor coordinates.
|
||||
*
|
||||
* The default is origin is assumed at: (0, 0, 0)
|
||||
*
|
||||
* Since: 1.6
|
||||
*/
|
||||
void
|
||||
clutter_paint_volume_set_origin (ClutterPaintVolume *pv,
|
||||
@ -213,8 +205,6 @@ clutter_paint_volume_set_origin (ClutterPaintVolume *pv,
|
||||
* @vertex: (out): the return location for a #graphene_point3d_t
|
||||
*
|
||||
* Retrieves the origin of the #ClutterPaintVolume.
|
||||
*
|
||||
* Since: 1.6
|
||||
*/
|
||||
void
|
||||
clutter_paint_volume_get_origin (const ClutterPaintVolume *pv,
|
||||
@ -244,8 +234,6 @@ _clutter_paint_volume_update_is_empty (ClutterPaintVolume *pv)
|
||||
*
|
||||
* Sets the width of the paint volume. The width is measured along
|
||||
* the x axis in the actor coordinates that @pv is associated with.
|
||||
*
|
||||
* Since: 1.6
|
||||
*/
|
||||
void
|
||||
clutter_paint_volume_set_width (ClutterPaintVolume *pv,
|
||||
@ -306,8 +294,6 @@ clutter_paint_volume_set_width (ClutterPaintVolume *pv,
|
||||
* fitting paint volumes for efficiency.
|
||||
|
||||
* Return value: the width, in units of @pv's local coordinate system.
|
||||
*
|
||||
* Since: 1.6
|
||||
*/
|
||||
gfloat
|
||||
clutter_paint_volume_get_width (const ClutterPaintVolume *pv)
|
||||
@ -337,8 +323,6 @@ clutter_paint_volume_get_width (const ClutterPaintVolume *pv)
|
||||
*
|
||||
* Sets the height of the paint volume. The height is measured along
|
||||
* the y axis in the actor coordinates that @pv is associated with.
|
||||
*
|
||||
* Since: 1.6
|
||||
*/
|
||||
void
|
||||
clutter_paint_volume_set_height (ClutterPaintVolume *pv,
|
||||
@ -398,8 +382,6 @@ clutter_paint_volume_set_height (ClutterPaintVolume *pv,
|
||||
* volumes for efficiency.
|
||||
*
|
||||
* Return value: the height, in units of @pv's local coordinate system.
|
||||
*
|
||||
* Since: 1.6
|
||||
*/
|
||||
gfloat
|
||||
clutter_paint_volume_get_height (const ClutterPaintVolume *pv)
|
||||
@ -429,8 +411,6 @@ clutter_paint_volume_get_height (const ClutterPaintVolume *pv)
|
||||
*
|
||||
* Sets the depth of the paint volume. The depth is measured along
|
||||
* the z axis in the actor coordinates that @pv is associated with.
|
||||
*
|
||||
* Since: 1.6
|
||||
*/
|
||||
void
|
||||
clutter_paint_volume_set_depth (ClutterPaintVolume *pv,
|
||||
@ -491,8 +471,6 @@ clutter_paint_volume_set_depth (ClutterPaintVolume *pv,
|
||||
* volumes for efficiency.
|
||||
*
|
||||
* Return value: the depth, in units of @pv's local coordinate system.
|
||||
*
|
||||
* Since: 1.6
|
||||
*/
|
||||
gfloat
|
||||
clutter_paint_volume_get_depth (const ClutterPaintVolume *pv)
|
||||
@ -525,8 +503,6 @@ clutter_paint_volume_get_depth (const ClutterPaintVolume *pv)
|
||||
*
|
||||
* There are no guarantees about how precisely the two volumes
|
||||
* will be unioned.
|
||||
*
|
||||
* Since: 1.6
|
||||
*/
|
||||
void
|
||||
clutter_paint_volume_union (ClutterPaintVolume *pv,
|
||||
@ -609,8 +585,6 @@ done:
|
||||
*
|
||||
* This function is similar to [method@PaintVolume.union], but it is
|
||||
* specific for 2D regions.
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
void
|
||||
clutter_paint_volume_union_box (ClutterPaintVolume *pv,
|
||||
@ -707,8 +681,6 @@ _clutter_paint_volume_complete (ClutterPaintVolume *pv)
|
||||
* integer pixel values; if you need them to be rounded to the
|
||||
* nearest integer pixel values, you can use the
|
||||
* clutter_actor_box_clamp_to_pixel() function.
|
||||
*
|
||||
* Since: 1.6
|
||||
*/
|
||||
void
|
||||
_clutter_paint_volume_get_bounding_box (ClutterPaintVolume *pv,
|
||||
@ -1001,8 +973,6 @@ _clutter_actor_set_default_paint_volume (ClutterActor *self,
|
||||
*
|
||||
* Return value: %TRUE if the paint volume was successfully set, and %FALSE
|
||||
* otherwise
|
||||
*
|
||||
* Since: 1.6
|
||||
*/
|
||||
gboolean
|
||||
clutter_paint_volume_set_from_allocation (ClutterPaintVolume *pv,
|
||||
|
@ -49,8 +49,6 @@
|
||||
*
|
||||
* will automatically result in the actor children to be moved
|
||||
* when dragging.
|
||||
*
|
||||
* Since: 1.12
|
||||
*/
|
||||
|
||||
#include "clutter-build-config.h"
|
||||
@ -476,8 +474,6 @@ clutter_pan_action_class_init (ClutterPanActionClass *klass)
|
||||
* ClutterPanAction:pan-axis:
|
||||
*
|
||||
* Constraints the panning action to the specified axis
|
||||
*
|
||||
* Since: 1.12
|
||||
*/
|
||||
pan_props[PROP_PAN_AXIS] =
|
||||
g_param_spec_enum ("pan-axis",
|
||||
@ -491,8 +487,6 @@ clutter_pan_action_class_init (ClutterPanActionClass *klass)
|
||||
* ClutterPanAction:interpolate:
|
||||
*
|
||||
* Whether interpolated events emission is enabled.
|
||||
*
|
||||
* Since: 1.12
|
||||
*/
|
||||
pan_props[PROP_INTERPOLATE] =
|
||||
g_param_spec_boolean ("interpolate",
|
||||
@ -508,8 +502,6 @@ clutter_pan_action_class_init (ClutterPanActionClass *klass)
|
||||
*
|
||||
* #ClutterPanAction will emit interpolated ::pan events with decreasing
|
||||
* scroll deltas, using the rate specified by this property.
|
||||
*
|
||||
* Since: 1.12
|
||||
*/
|
||||
pan_props[PROP_DECELERATION] =
|
||||
g_param_spec_double ("deceleration",
|
||||
@ -526,8 +518,6 @@ clutter_pan_action_class_init (ClutterPanActionClass *klass)
|
||||
* The kinetic momentum measured at the time of releasing the pointer will
|
||||
* be multiplied by the factor specified by this property before being used
|
||||
* to generate interpolated ::pan events.
|
||||
*
|
||||
* Since: 1.12
|
||||
*/
|
||||
pan_props[PROP_ACCELERATION_FACTOR] =
|
||||
g_param_spec_double ("acceleration-factor",
|
||||
@ -558,8 +548,6 @@ clutter_pan_action_class_init (ClutterPanActionClass *klass)
|
||||
*
|
||||
* Return value: %TRUE if the pan should continue, and %FALSE if
|
||||
* the pan should be cancelled.
|
||||
*
|
||||
* Since: 1.12
|
||||
*/
|
||||
pan_signals[PAN] =
|
||||
g_signal_new (I_("pan"),
|
||||
@ -578,8 +566,6 @@ clutter_pan_action_class_init (ClutterPanActionClass *klass)
|
||||
*
|
||||
* The signal is emitted at the end of the interpolation
|
||||
* phase of the pan action, only when :interpolate is set to %TRUE.
|
||||
*
|
||||
* Since: 1.12
|
||||
*/
|
||||
pan_signals[PAN_STOPPED] =
|
||||
g_signal_new (I_("pan-stopped"),
|
||||
@ -606,8 +592,6 @@ clutter_pan_action_init (ClutterPanAction *self)
|
||||
* Creates a new #ClutterPanAction instance
|
||||
*
|
||||
* Return value: the newly created #ClutterPanAction
|
||||
*
|
||||
* Since: 1.12
|
||||
*/
|
||||
ClutterAction *
|
||||
clutter_pan_action_new (void)
|
||||
@ -621,8 +605,6 @@ clutter_pan_action_new (void)
|
||||
* @axis: the axis to constraint the panning to
|
||||
*
|
||||
* Restricts the panning action to a specific axis
|
||||
*
|
||||
* Since: 1.12
|
||||
*/
|
||||
void
|
||||
clutter_pan_action_set_pan_axis (ClutterPanAction *self,
|
||||
@ -651,8 +633,6 @@ clutter_pan_action_set_pan_axis (ClutterPanAction *self,
|
||||
* Retrieves the axis constraint set by [method@PanAction.set_pan_axis]
|
||||
*
|
||||
* Return value: the axis constraint
|
||||
*
|
||||
* Since: 1.12
|
||||
*/
|
||||
ClutterPanAxis
|
||||
clutter_pan_action_get_pan_axis (ClutterPanAction *self)
|
||||
@ -670,8 +650,6 @@ clutter_pan_action_get_pan_axis (ClutterPanAction *self)
|
||||
*
|
||||
* Sets whether the action should emit interpolated ::pan events
|
||||
* after the drag has ended, to emulate the gesture kinetic inertia.
|
||||
*
|
||||
* Since: 1.12
|
||||
*/
|
||||
void
|
||||
clutter_pan_action_set_interpolate (ClutterPanAction *self,
|
||||
@ -702,8 +680,6 @@ clutter_pan_action_set_interpolate (ClutterPanAction *self,
|
||||
* kinetic inertia.
|
||||
*
|
||||
* Return value: %TRUE if interpolated events emission is active.
|
||||
*
|
||||
* Since: 1.12
|
||||
*/
|
||||
gboolean
|
||||
clutter_pan_action_get_interpolate (ClutterPanAction *self)
|
||||
@ -722,8 +698,6 @@ clutter_pan_action_get_interpolate (ClutterPanAction *self)
|
||||
* Sets the deceleration rate of the interpolated ::pan events generated
|
||||
* after a pan gesture. This is approximately the value that the momentum
|
||||
* at the time of releasing the pointer is divided by every 60th of a second.
|
||||
*
|
||||
* Since: 1.12
|
||||
*/
|
||||
void
|
||||
clutter_pan_action_set_deceleration (ClutterPanAction *self,
|
||||
@ -744,8 +718,6 @@ clutter_pan_action_set_deceleration (ClutterPanAction *self,
|
||||
* Retrieves the deceleration rate of interpolated ::pan events.
|
||||
*
|
||||
* Return value: The deceleration rate of the interpolated events.
|
||||
*
|
||||
* Since: 1.12
|
||||
*/
|
||||
gdouble
|
||||
clutter_pan_action_get_deceleration (ClutterPanAction *self)
|
||||
@ -761,8 +733,6 @@ clutter_pan_action_get_deceleration (ClutterPanAction *self)
|
||||
*
|
||||
* Factor applied to the momentum velocity at the time of releasing the
|
||||
* pointer when generating interpolated ::pan events.
|
||||
*
|
||||
* Since: 1.12
|
||||
*/
|
||||
void
|
||||
clutter_pan_action_set_acceleration_factor (ClutterPanAction *self,
|
||||
@ -782,8 +752,6 @@ clutter_pan_action_set_acceleration_factor (ClutterPanAction *self,
|
||||
* Retrieves the initial acceleration factor for interpolated ::pan events.
|
||||
*
|
||||
* Return value: The initial acceleration factor for interpolated events.
|
||||
*
|
||||
* Since: 1.12
|
||||
*/
|
||||
gdouble
|
||||
clutter_pan_action_get_acceleration_factor (ClutterPanAction *self)
|
||||
@ -802,8 +770,6 @@ clutter_pan_action_get_acceleration_factor (ClutterPanAction *self)
|
||||
*
|
||||
* Retrieves the coordinates, in stage space, of the latest interpolated
|
||||
* event, analogous to [method@GestureAction.get_motion_coords].
|
||||
*
|
||||
* Since: 1.12
|
||||
*/
|
||||
void
|
||||
clutter_pan_action_get_interpolated_coords (ClutterPanAction *self,
|
||||
@ -835,8 +801,6 @@ clutter_pan_action_get_interpolated_coords (ClutterPanAction *self,
|
||||
* event, analogous to [method@GestureAction.get_motion_delta].
|
||||
*
|
||||
* Return value: the distance since the latest interpolated event
|
||||
*
|
||||
* Since: 1.12
|
||||
*/
|
||||
gfloat
|
||||
clutter_pan_action_get_interpolated_delta (ClutterPanAction *self,
|
||||
@ -870,9 +834,7 @@ clutter_pan_action_get_interpolated_delta (ClutterPanAction *self,
|
||||
* of the #ClutterPanAction, and respecting the constraint specified by the
|
||||
* [property@PanAction:pan-axis] property.
|
||||
*
|
||||
* Return value: the distance since last motion event
|
||||
*
|
||||
* Since: 1.24
|
||||
* Return value: the distance since last motion event4
|
||||
*/
|
||||
gfloat
|
||||
clutter_pan_action_get_constrained_motion_delta (ClutterPanAction *self,
|
||||
@ -937,8 +899,6 @@ clutter_pan_action_get_constrained_motion_delta (ClutterPanAction *self,
|
||||
* will be equivalent to those returned by
|
||||
* [method@PanAction.get_interpolated_delta]. This is a convenience
|
||||
* method designed to be used in replacement "pan" signal handlers.
|
||||
*
|
||||
* Since: 1.14
|
||||
*/
|
||||
gfloat
|
||||
clutter_pan_action_get_motion_delta (ClutterPanAction *self,
|
||||
@ -989,8 +949,6 @@ clutter_pan_action_get_motion_delta (ClutterPanAction *self,
|
||||
* will be equivalent to those returned by
|
||||
* [method@PanAction.get_interpolated_coords]. This is a convenience
|
||||
* method designed to be used in replacement "pan" signal handlers.
|
||||
*
|
||||
* Since: 1.14
|
||||
*/
|
||||
void
|
||||
clutter_pan_action_get_motion_coords (ClutterPanAction *self,
|
||||
|
@ -67,8 +67,6 @@ struct _ClutterPanAction
|
||||
*
|
||||
* The #ClutterPanActionClass structure contains
|
||||
* only private data.
|
||||
*
|
||||
* Since: 1.12
|
||||
*/
|
||||
struct _ClutterPanActionClass
|
||||
{
|
||||
|
@ -31,9 +31,7 @@
|
||||
* of the [class@Actor] to which it has been applied using a [class@Path].
|
||||
*
|
||||
* By setting the [property@PathConstraint:offset] property it is possible to
|
||||
* control how far along the path the [class@Actor] should be.
|
||||
*
|
||||
* Since: 1.6.
|
||||
* control how far along the path the [class@Actor] should be..
|
||||
*/
|
||||
|
||||
#include "clutter-build-config.h"
|
||||
@ -202,8 +200,6 @@ clutter_path_constraint_class_init (ClutterPathConstraintClass *klass)
|
||||
* ClutterPathConstraint:path:
|
||||
*
|
||||
* The #ClutterPath used to constrain the position of an actor.
|
||||
*
|
||||
* Since: 1.6
|
||||
*/
|
||||
path_properties[PROP_PATH] =
|
||||
g_param_spec_object ("path",
|
||||
@ -216,8 +212,6 @@ clutter_path_constraint_class_init (ClutterPathConstraintClass *klass)
|
||||
* ClutterPathConstraint:offset:
|
||||
*
|
||||
* The offset along the #ClutterPathConstraint:path, between -1.0 and 2.0.
|
||||
*
|
||||
* Since: 1.6
|
||||
*/
|
||||
path_properties[PROP_OFFSET] =
|
||||
g_param_spec_float ("offset",
|
||||
@ -247,8 +241,6 @@ clutter_path_constraint_class_init (ClutterPathConstraintClass *klass)
|
||||
* The signal is emitted each time a
|
||||
* #ClutterPathConstraint:offset value results in the actor
|
||||
* passing a #ClutterPathNode
|
||||
*
|
||||
* Since: 1.6
|
||||
*/
|
||||
path_signals[NODE_REACHED] =
|
||||
g_signal_new (I_("node-reached"),
|
||||
@ -277,8 +269,6 @@ clutter_path_constraint_init (ClutterPathConstraint *self)
|
||||
* Creates a new #ClutterPathConstraint with the given @path and @offset
|
||||
*
|
||||
* Return value: the newly created #ClutterPathConstraint
|
||||
*
|
||||
* Since: 1.6
|
||||
*/
|
||||
ClutterConstraint *
|
||||
clutter_path_constraint_new (ClutterPath *path,
|
||||
@ -301,8 +291,6 @@ clutter_path_constraint_new (ClutterPath *path,
|
||||
*
|
||||
* The @constraint will take ownership of the #ClutterPath passed to this
|
||||
* function.
|
||||
*
|
||||
* Since: 1.6
|
||||
*/
|
||||
void
|
||||
clutter_path_constraint_set_path (ClutterPathConstraint *constraint,
|
||||
@ -338,8 +326,6 @@ clutter_path_constraint_set_path (ClutterPathConstraint *constraint,
|
||||
* Return value: (transfer none): the #ClutterPath used by the
|
||||
* #ClutterPathConstraint, or %NULL. The returned #ClutterPath is owned
|
||||
* by the constraint and it should not be unreferenced
|
||||
*
|
||||
* Since: 1.6
|
||||
*/
|
||||
ClutterPath *
|
||||
clutter_path_constraint_get_path (ClutterPathConstraint *constraint)
|
||||
@ -355,8 +341,6 @@ clutter_path_constraint_get_path (ClutterPathConstraint *constraint)
|
||||
* @offset: the offset along the path
|
||||
*
|
||||
* Sets the offset along the #ClutterPath used by @constraint.
|
||||
*
|
||||
* Since: 1.6
|
||||
*/
|
||||
void
|
||||
clutter_path_constraint_set_offset (ClutterPathConstraint *constraint,
|
||||
@ -382,8 +366,6 @@ clutter_path_constraint_set_offset (ClutterPathConstraint *constraint,
|
||||
* Retrieves the offset along the [class@Path] used by @constraint.
|
||||
*
|
||||
* Return value: the offset
|
||||
*
|
||||
* Since: 1.6
|
||||
*/
|
||||
gfloat
|
||||
clutter_path_constraint_get_offset (ClutterPathConstraint *constraint)
|
||||
|
@ -56,8 +56,6 @@
|
||||
* [method@Path.add_line_to]. Alternatively the path can be described
|
||||
* in a string using a subset of the SVG path syntax. See
|
||||
* [method@Path.add_string] for details.
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
|
||||
#include "clutter-build-config.h"
|
||||
@ -244,8 +242,6 @@ clutter_path_finalize (GObject *object)
|
||||
* Creates a new #ClutterPath instance with no nodes.
|
||||
*
|
||||
* Return value: the newly created #ClutterPath
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
ClutterPath *
|
||||
clutter_path_new (void)
|
||||
@ -264,8 +260,6 @@ clutter_path_new (void)
|
||||
* the string.
|
||||
*
|
||||
* Return value: the newly created #ClutterPath
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
ClutterPath *
|
||||
clutter_path_new_with_description (const gchar *desc)
|
||||
@ -280,8 +274,6 @@ clutter_path_new_with_description (const gchar *desc)
|
||||
* @path: a #ClutterPath
|
||||
*
|
||||
* Removes all nodes from the path.
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
void
|
||||
clutter_path_clear (ClutterPath *path)
|
||||
@ -351,8 +343,6 @@ clutter_path_add_node_helper (ClutterPath *path,
|
||||
* Adds a %CLUTTER_PATH_MOVE_TO type node to the path. This is usually
|
||||
* used as the first node in a path. It can also be used in the middle
|
||||
* of the path to cause the actor to jump to the new coordinate.
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
void
|
||||
clutter_path_add_move_to (ClutterPath *path,
|
||||
@ -372,8 +362,6 @@ clutter_path_add_move_to (ClutterPath *path,
|
||||
*
|
||||
* Same as [method@Path.add_move_to] except the coordinates are
|
||||
* relative to the previous node.
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
void
|
||||
clutter_path_add_rel_move_to (ClutterPath *path,
|
||||
@ -393,8 +381,6 @@ clutter_path_add_rel_move_to (ClutterPath *path,
|
||||
*
|
||||
* Adds a %CLUTTER_PATH_LINE_TO type node to the path. This causes the
|
||||
* actor to move to the new coordinates in a straight line.
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
void
|
||||
clutter_path_add_line_to (ClutterPath *path,
|
||||
@ -414,8 +400,6 @@ clutter_path_add_line_to (ClutterPath *path,
|
||||
*
|
||||
* Same as [method@Path.add_line_to] except the coordinates are
|
||||
* relative to the previous node.
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
void
|
||||
clutter_path_add_rel_line_to (ClutterPath *path,
|
||||
@ -440,8 +424,6 @@ clutter_path_add_rel_line_to (ClutterPath *path,
|
||||
* Adds a %CLUTTER_PATH_CURVE_TO type node to the path. This causes
|
||||
* the actor to follow a bezier from the last node to (@x_3, @y_3) using
|
||||
* (@x_1, @y_1) and (@x_2,@y_2) as control points.
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
void
|
||||
clutter_path_add_curve_to (ClutterPath *path,
|
||||
@ -472,8 +454,6 @@ clutter_path_add_curve_to (ClutterPath *path,
|
||||
*
|
||||
* Same as [method@Path.add_curve_to] except the coordinates are
|
||||
* relative to the previous node.
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
void
|
||||
clutter_path_add_rel_curve_to (ClutterPath *path,
|
||||
@ -499,8 +479,6 @@ clutter_path_add_rel_curve_to (ClutterPath *path,
|
||||
* Adds a %CLUTTER_PATH_CLOSE type node to the path. This creates a
|
||||
* straight line from the last node to the last %CLUTTER_PATH_MOVE_TO
|
||||
* type node.
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
void
|
||||
clutter_path_add_close (ClutterPath *path)
|
||||
@ -707,8 +685,6 @@ clutter_path_add_nodes (ClutterPath *path,
|
||||
*
|
||||
* Return value: %TRUE is the path description was valid or %FALSE
|
||||
* otherwise.
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
gboolean
|
||||
clutter_path_add_string (ClutterPath *path,
|
||||
@ -735,8 +711,6 @@ clutter_path_add_string (ClutterPath *path,
|
||||
* @node: a #ClutterPathNode
|
||||
*
|
||||
* Adds @node to the end of the path.
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
void
|
||||
clutter_path_add_node (ClutterPath *path,
|
||||
@ -760,8 +734,6 @@ clutter_path_add_node (ClutterPath *path,
|
||||
* @cpath: a Cairo path
|
||||
*
|
||||
* Add the nodes of the Cairo path to the end of @path.
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
void
|
||||
clutter_path_add_cairo_path (ClutterPath *path,
|
||||
@ -856,8 +828,6 @@ clutter_path_add_node_to_cairo_path (const ClutterPathNode *node,
|
||||
* @cr: a Cairo context
|
||||
*
|
||||
* Add the nodes of the ClutterPath to the path in the Cairo context.
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
void
|
||||
clutter_path_to_cairo_path (ClutterPath *path,
|
||||
@ -876,8 +846,6 @@ clutter_path_to_cairo_path (ClutterPath *path,
|
||||
* Retrieves the number of nodes in the path.
|
||||
*
|
||||
* Return value: the number of nodes.
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
guint
|
||||
clutter_path_get_n_nodes (ClutterPath *path)
|
||||
@ -898,8 +866,6 @@ clutter_path_get_n_nodes (ClutterPath *path)
|
||||
* @node: (out): a location to store a copy of the node
|
||||
*
|
||||
* Retrieves the node of the path indexed by @index.
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
void
|
||||
clutter_path_get_node (ClutterPath *path,
|
||||
@ -933,8 +899,6 @@ clutter_path_get_node (ClutterPath *path,
|
||||
*
|
||||
* Return value: (transfer container) (element-type Clutter.PathNode): a
|
||||
* list of nodes in the path.
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
GSList *
|
||||
clutter_path_get_nodes (ClutterPath *path)
|
||||
@ -955,8 +919,6 @@ clutter_path_get_nodes (ClutterPath *path)
|
||||
* @user_data: user data to pass to the function
|
||||
*
|
||||
* Calls a function for each node of the path.
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
void
|
||||
clutter_path_foreach (ClutterPath *path,
|
||||
@ -980,8 +942,6 @@ clutter_path_foreach (ClutterPath *path,
|
||||
*
|
||||
* Inserts @node into the path before the node at the given offset. If
|
||||
* @index_ is negative it will append the node to the end of the path.
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
void
|
||||
clutter_path_insert_node (ClutterPath *path,
|
||||
@ -1016,8 +976,6 @@ clutter_path_insert_node (ClutterPath *path,
|
||||
* @index_: index of the node to remove
|
||||
*
|
||||
* Removes the node at the given offset from the path.
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
void
|
||||
clutter_path_remove_node (ClutterPath *path,
|
||||
@ -1058,8 +1016,6 @@ clutter_path_remove_node (ClutterPath *path,
|
||||
* @node: the replacement node
|
||||
*
|
||||
* Replaces the node at offset @index_ with @node.
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
void
|
||||
clutter_path_replace_node (ClutterPath *path,
|
||||
@ -1095,8 +1051,6 @@ clutter_path_replace_node (ClutterPath *path,
|
||||
* unaltered.
|
||||
*
|
||||
* Return value: %TRUE is the path was valid, %FALSE otherwise.
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
gboolean
|
||||
clutter_path_set_description (ClutterPath *path,
|
||||
@ -1126,8 +1080,6 @@ clutter_path_set_description (ClutterPath *path,
|
||||
* format as used by [method@Path.add_string].
|
||||
*
|
||||
* Return value: a string description of the path. Free with g_free().
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
gchar *
|
||||
clutter_path_get_description (ClutterPath *path)
|
||||
@ -1339,8 +1291,6 @@ clutter_path_ensure_node_data (ClutterPath *path)
|
||||
* interpolated position is then stored in @position.
|
||||
*
|
||||
* Return value: index of the node used to calculate the position.
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
guint
|
||||
clutter_path_get_position (ClutterPath *path,
|
||||
@ -1431,8 +1381,6 @@ clutter_path_get_position (ClutterPath *path,
|
||||
* Retrieves an approximation of the total length of the path.
|
||||
*
|
||||
* Return value: the length of the path.
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
guint
|
||||
clutter_path_get_length (ClutterPath *path)
|
||||
@ -1466,8 +1414,6 @@ clutter_path_node_full_free (ClutterPathNodeFull *node)
|
||||
* Makes an allocated copy of a node.
|
||||
*
|
||||
* Return value: the copied node.
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
ClutterPathNode *
|
||||
clutter_path_node_copy (const ClutterPathNode *node)
|
||||
@ -1480,8 +1426,6 @@ clutter_path_node_copy (const ClutterPathNode *node)
|
||||
* @node: a #ClutterPathNode
|
||||
*
|
||||
* Frees the memory of an allocated node.
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
void
|
||||
clutter_path_node_free (ClutterPathNode *node)
|
||||
@ -1499,8 +1443,6 @@ clutter_path_node_free (ClutterPathNode *node)
|
||||
* same coordinates.
|
||||
*
|
||||
* Return value: %TRUE if the nodes are the same.
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
gboolean
|
||||
clutter_path_node_equal (const ClutterPathNode *node_a,
|
||||
@ -1542,8 +1484,6 @@ G_DEFINE_BOXED_TYPE (ClutterKnot, clutter_knot,
|
||||
* Makes an allocated copy of a knot.
|
||||
*
|
||||
* Return value: the copied knot.
|
||||
*
|
||||
* Since: 0.2
|
||||
*/
|
||||
ClutterKnot *
|
||||
clutter_knot_copy (const ClutterKnot *knot)
|
||||
@ -1559,8 +1499,6 @@ clutter_knot_copy (const ClutterKnot *knot)
|
||||
* @knot: a #ClutterKnot
|
||||
*
|
||||
* Frees the memory of an allocated knot.
|
||||
*
|
||||
* Since: 0.2
|
||||
*/
|
||||
void
|
||||
clutter_knot_free (ClutterKnot *knot)
|
||||
@ -1577,8 +1515,6 @@ clutter_knot_free (ClutterKnot *knot)
|
||||
* Compares to knot and checks if the point to the same location.
|
||||
*
|
||||
* Return value: %TRUE if the knots point to the same location.
|
||||
*
|
||||
* Since: 0.2
|
||||
*/
|
||||
gboolean
|
||||
clutter_knot_equal (const ClutterKnot *knot_a,
|
||||
|
@ -51,8 +51,6 @@ typedef struct _ClutterPathPrivate ClutterPathPrivate;
|
||||
*
|
||||
* This function is passed to [method@Path.foreach] and will be
|
||||
* called for each node contained in the path.
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
typedef void (* ClutterPathCallback) (const ClutterPathNode *node,
|
||||
gpointer data);
|
||||
@ -69,8 +67,6 @@ struct _ClutterPath
|
||||
* ClutterPathClass:
|
||||
*
|
||||
* The #ClutterPathClass struct contains only private data.
|
||||
*
|
||||
* Since: 1.0
|
||||
*/
|
||||
struct _ClutterPathClass
|
||||
{
|
||||
|
@ -26,8 +26,6 @@
|
||||
*
|
||||
* #ClutterPropertyTransition is a specialized [class@Transition] that
|
||||
* can be used to tween a property of a [iface@Animatable] instance.
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
|
||||
#include "clutter-build-config.h"
|
||||
@ -259,8 +257,6 @@ clutter_property_transition_class_init (ClutterPropertyTransitionClass *klass)
|
||||
* ClutterPropertyTransition:property-name:
|
||||
*
|
||||
* The name of the property of a [iface@Animatable] to animate.
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
obj_props[PROP_PROPERTY_NAME] =
|
||||
g_param_spec_string ("property-name",
|
||||
@ -306,8 +302,6 @@ clutter_property_transition_new_for_actor (ClutterActor *actor,
|
||||
*
|
||||
* Return value: (transfer full): the newly created #ClutterPropertyTransition.
|
||||
* Use g_object_unref() when done
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
ClutterTransition *
|
||||
clutter_property_transition_new (const char *property_name)
|
||||
@ -323,8 +317,6 @@ clutter_property_transition_new (const char *property_name)
|
||||
* @property_name: (allow-none): a property name
|
||||
*
|
||||
* Sets the [property@PropertyTransition:property-name] property of @transition.
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
void
|
||||
clutter_property_transition_set_property_name (ClutterPropertyTransition *transition,
|
||||
@ -366,8 +358,6 @@ clutter_property_transition_set_property_name (ClutterPropertyTransition *transi
|
||||
* Return value: the name of the property being animated, or %NULL if
|
||||
* none is set. The returned string is owned by the @transition and
|
||||
* it should not be freed.
|
||||
*
|
||||
* Since: 1.10
|
||||
*/
|
||||
const char *
|
||||
clutter_property_transition_get_property_name (ClutterPropertyTransition *transition)
|
||||
|
Some files were not shown because too many files have changed in this diff Show More
Loading…
x
Reference in New Issue
Block a user