AdgEntity

AdgDress

typedef gint                     AdgDress;

An index representing a virtual AdgStyle.

AdgEntityCallback ()

void                (*AdgEntityCallback)                (AdgEntity *entity,
                                                         gpointer user_data);

Callback used when inspecting or browsing entities. For example, it is passed to adg_model_foreach_dependency() to perform an operation on all the entities depending on an AdgModel.

AdgEntity

typedef struct _AdgEntity AdgEntity;

All fields are private and should not be used directly. Use its public methods instead.

adg_switch_extents ()

void                adg_switch_extents                  (gboolean state);

Strokes (if state is TRUE) a rectangle around every entity to show their extents. Useful for debugging purposes.

adg_entity_get_canvas ()

AdgCanvas *         adg_entity_get_canvas               (AdgEntity *entity);

Walks on the entity hierarchy and gets the first parent of entity that is of AdgCanvas derived type.

adg_entity_set_parent ()

void                adg_entity_set_parent               (AdgEntity *entity,
                                                         AdgEntity *parent);

Sets a new parent on entity.

adg_entity_get_parent ()

AdgEntity *         adg_entity_get_parent               (AdgEntity *entity);

Gets the parent of entity.

adg_entity_set_global_map ()

void                adg_entity_set_global_map           (AdgEntity *entity,
                                                         const AdgMatrix *map);

Sets the new global transformation of entity to map: the old map is discarded. If map is NULL, the global map is left unchanged.

adg_entity_transform_global_map ()

void                adg_entity_transform_global_map     (AdgEntity *entity,
                                                         const AdgMatrix *transformation,
                                                         AdgTransformMode mode);

Convenient function to change the global map of entity by applying tranformation using the mode operator. This is logically equivalent to the following:

AdgMatrix map;
adg_matrix_copy(&map, adg_entity_get_global_map(entity));
adg_matrix_transform(&map, transformation, mode);
adg_entity_set_global_map(entity, &map);

adg_entity_get_global_map ()

const AdgMatrix *   adg_entity_get_global_map           (AdgEntity *entity);

Gets the transformation to be used to compute the global matrix of entity.

adg_entity_get_global_matrix ()

const AdgMatrix *   adg_entity_get_global_matrix        (AdgEntity *entity);

Gets the current global matrix of entity. The returned value is owned by entity and should not be changed or freed.

The global matrix is computed in the arrange() phase by combining all the global maps of the entity hierarchy using the ADG_MIX_ANCESTORS method.

adg_entity_set_local_map ()

void                adg_entity_set_local_map            (AdgEntity *entity,
                                                         const AdgMatrix *map);

Sets the new local transformation of entity to map: the old map is discarded. If map is NULL, the local map is left unchanged.

adg_entity_transform_local_map ()

void                adg_entity_transform_local_map      (AdgEntity *entity,
                                                         const AdgMatrix *transformation,
                                                         AdgTransformMode mode);

Convenient function to change the local map of entity by applying tranformation using the mode operator. This is logically equivalent to the following:

AdgMatrix map;
adg_matrix_copy(&map, adg_entity_get_local_map(entity));
adg_matrix_transform(&map, transformation, mode);
adg_entity_set_local_map(entity, &map);

adg_entity_get_local_map ()

const AdgMatrix *   adg_entity_get_local_map            (AdgEntity *entity);

Gets the transformation to be used to compute the local matrix of entity and store it in map.

adg_entity_get_local_matrix ()

const AdgMatrix *   adg_entity_get_local_matrix         (AdgEntity *entity);

Gets the current local matrix of entity. The returned value is owned by entity and should not be changed or freed.

The local matrix is computed in the arrange() phase by combining all the local maps of the entity hierarchy using the method specified by the "local-method" property.

adg_entity_set_local_method ()

void                adg_entity_set_local_method         (AdgEntity *entity,
                                                         AdgMixMethod local_method);

Sets a new local mix method on entity. The "local-method" property defines how the local matrix must be computed: check out the AdgMixMethod documentation to know what are the availables methods and how they affect the local matrix computation.

Setting a different local method emits an "local-changed" signal on entity.

adg_entity_get_local_method ()

AdgMixMethod        adg_entity_get_local_method         (AdgEntity *entity);

Gets the local mix method of entity. Check out the adg_entity_set_local_method() documentation to know what the local method is used for.

adg_entity_set_extents ()

void                adg_entity_set_extents              (AdgEntity *entity,
                                                         const CpmlExtents *extents);

Sets a new bounding box for entity. extents can be NULL, in which case the extents are unset.

adg_entity_get_extents ()

const CpmlExtents * adg_entity_get_extents              (AdgEntity *entity);

Gets the bounding box of entity. The returned struct is owned by entity and should not modified or freed.

This struct specifies the surface portion (in global space of entity) occupied by the entity without taking into account rendering properties such as line thickness or caps.

The "arrange" signal should be emitted before this call (either explicitely trought adg_entity_arrange() or implicitely with adg_entity_render()) in order to get an up to date boundary box.

adg_entity_set_style ()

void                adg_entity_set_style                (AdgEntity *entity,
                                                         AdgDress dress,
                                                         AdgStyle *style);

Overrides the style of dress for entity and its children. If style is NULL, any previous override is removed.

The new style must still be compatible with dress: check out the adg_dress_style_is_compatible() documentation to know what a compatible style means.

adg_entity_get_style ()

AdgStyle *          adg_entity_get_style                (AdgEntity *entity,
                                                         AdgDress dress);

Gets the overriden dress style from entity. This is a kind of accessor function: to get the style to be used for rendering purpose, use adg_entity_style() instead.

adg_entity_style ()

AdgStyle *          adg_entity_style                    (AdgEntity *entity,
                                                         AdgDress dress);

Gets the style to be used for entity. dress specifies which "family" of style to get.

The following sequence of checks is performed to get the proper style, stopping at the first succesfull result:

adg_entity_apply_dress ()

void                adg_entity_apply_dress              (AdgEntity *entity,
                                                         AdgDress dress,
                                                         cairo_t *cr);

Convenient function to apply a dress style (as returned by adg_entity_style()) to the cr cairo context.

adg_entity_global_changed ()

void                adg_entity_global_changed           (AdgEntity *entity);

Emits the "global-changed" signal on entity and on all of its children, if any.

adg_entity_local_changed ()

void                adg_entity_local_changed            (AdgEntity *entity);

Emits the "local-changed" signal on entity and on all of its children, if any.

adg_entity_invalidate ()

void                adg_entity_invalidate               (AdgEntity *entity);

Emits the "invalidate" signal on entity and on all of its children, if any, clearing the eventual cache stored by the "arrange" signal and setting the entity state similary to the just initialized entity.

adg_entity_arrange ()

void                adg_entity_arrange                  (AdgEntity *entity);

Emits the "arrange" signal on entity and all its children, if any. This function is rarely needed as the arrange call is usually implicitely called by the "render" signal or iby a call to adg_entity_get_extents().

adg_entity_render ()

void                adg_entity_render                   (AdgEntity *entity,
                                                         cairo_t *cr);

Emits the "render" signal on entity and on all of its children, if any, causing the rendering to the cr cairo context.

The "global-map" property

  "global-map"               AdgMatrix*            : Read / Write

The transformation to be combined with the parent ones to get the global matrix.

The "local-map" property

  "local-map"                AdgMatrix*            : Read / Write

The local transformation that could be used to compute the local matrix in the way specified by the #AdgEntity:local-method property.

The "local-method" property

  "local-method"             AdgMixMethod          : Read / Write

Define how the local maps of the entity and its ancestors should be combined to get the local matrix.

Default value: ADG_MIX_ANCESTORS

The "parent" property

  "parent"                   AdgEntity*            : Read / Write

The parent entity of this entity or NULL if this is a top-level entity.

The "arrange" signal

void                user_function                      (AdgEntity *entity,
                                                        gpointer   user_data)      : Run Last

Arranges the layout of entity, updating the cache if necessary, and computes the extents of entity.

The "global-changed" signal

void                user_function                      (AdgEntity *entity,
                                                        gpointer   user_data)      : Run First

Emitted when the global map of entity or any of its parent has changed. The default handler will compute the new global matrix, updating the internal cache.

The "invalidate" signal

void                user_function                      (AdgEntity *entity,
                                                        gpointer   user_data)      : Run Last

Invalidates the whole entity, that is resets all the cache (if present) built during the "arrange" signal. The resulting state is a clean entity, similar to what you have just before the first rendering.

The "local-changed" signal

void                user_function                      (AdgEntity *entity,
                                                        gpointer   user_data)      : Run First

Emitted when the local map of entity or any of its parent has changed. The default handler will compute the new local matrix, updating the internal cache.

The "parent-set" signal

void                user_function                      (AdgEntity *entity,
                                                        AdgEntity *old_parent,
                                                        gpointer   user_data)       : Run First

Emitted after the parent entity has changed. The new parent can be inspected using adg_entity_get_parent().

It is allowed for both old and new parent to be NULL.

The "render" signal

void                user_function                      (AdgEntity *entity,
                                                        gpointer   cr,
                                                        gpointer   user_data)      : Run Last

Causes the rendering of entity on cr. A render signal will automatically emit "arrange" just before the real rendering on the cairo context.