AdgModel

AdgDependencyFunc ()

void                (*AdgDependencyFunc)                (AdgModel *model,
                                                         AdgEntity *entity,
                                                         gpointer user_data);

Callback used by adg_model_foreach_dependency().

AdgNamedPairFunc ()

void                (*AdgNamedPairFunc)                 (AdgModel *model,
                                                         const gchar *name,
                                                         AdgPair *pair,
                                                         gpointer user_data);

Callback used by adg_model_foreach_named_pair().

AdgModel

typedef struct _AdgModel AdgModel;

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

adg_model_add_dependency ()

void                adg_model_add_dependency            (AdgModel *model,
                                                         AdgEntity *entity);

Emits a "add-dependency" signal on model passing entity as argument. This will add a reference to entity owned by model.

adg_model_remove_dependency ()

void                adg_model_remove_dependency         (AdgModel *model,
                                                         AdgEntity *entity);

Emits a "remove-dependency" signal on model passing entity as argument. entity must be inside model.

Note that model will own a reference to entity and it may be the last reference held: this means removing an entity from the model can destroy it.

adg_model_get_dependencies ()

const GSList *      adg_model_get_dependencies          (AdgModel *model);

Gets the list of entities dependending on model. This list is owned by model and must not be modified or freed.

adg_model_foreach_dependency ()

void                adg_model_foreach_dependency        (AdgModel *model,
                                                         AdgDependencyFunc callback,
                                                         gpointer user_data);

Invokes callback on each entity linked to model.

adg_model_set_named_pair ()

void                adg_model_set_named_pair            (AdgModel *model,
                                                         const gchar *name,
                                                         const AdgPair *pair);

Emits a "set-named-pair" signal on model passing name and pair as arguments.

adg_model_set_named_pair_explicit ()

void                adg_model_set_named_pair_explicit   (AdgModel *model,
                                                         const gchar *name,
                                                         gdouble x,
                                                         gdouble y);

Convenient wrapper on adg_model_set_named_pair() that accepts explicit coordinates.

adg_model_get_named_pair ()

const AdgPair *     adg_model_get_named_pair            (AdgModel *model,
                                                         const gchar *name);

Gets the name named pair associated to model. The returned pair is owned by model and must not be modified or freed.

adg_model_foreach_named_pair ()

void                adg_model_foreach_named_pair        (AdgModel *model,
                                                         AdgNamedPairFunc callback,
                                                         gpointer user_data);

Invokes callback for each named pair set on model. This can be used, for example, to retrieve all the named pairs of a model or to duplicate a transformed version of every named pair.

adg_model_clear ()

void                adg_model_clear                     (AdgModel *model);

Emits the "clear" signal on model.

adg_model_reset ()

void                adg_model_reset                     (AdgModel *model);

Emits the "reset" signal on model.

adg_model_changed ()

void                adg_model_changed                   (AdgModel *model);

Emits the "changed" signal on model.

The "dependency" property

  "dependency"               AdgEntity*            : Write

Can be used to add a new dependency from this model (this entity will be invalidated on model changed).

The "add-dependency" signal

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

Adds entity to model. After that entity will depend on model, that is "changed" on model will invalidate entity.

The "changed" signal

void                user_function                      (AdgModel *model,
                                                        gpointer  user_data)      : Run Last / No Recursion

Notificates that the model has changed. By default, all the dependent entities are invalidated.

The "clear" signal

void                user_function                      (AdgModel *model,
                                                        gpointer  user_data)      : Run Last / No Recursion

Removes any information from model cached by the implementation code. Useful to force a recomputation of the cache when something in the model has changed.

The "remove-dependency" signal

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

Removes the entity from model, that is entity will not depend on model anymore.

The "reset" signal

void                user_function                      (AdgModel *model,
                                                        gpointer  user_data)      : Run Last / No Recursion

Resets the state of model by destroying any named pair associated to it. This step also involves the emission of the AdgModel:clear signal.

This signal is intended to be used while redefining the model. A typical usage would be on these terms:

adg_model_reset(model);
// Definition of model. This also requires the redefinition of
// the named pairs because the old ones have been destroyed.
...
adg_model_changed(model);

The "set-named-pair" signal

void                user_function                      (AdgModel *model,
                                                        gchar    *name,
                                                        gpointer  pair,
                                                        gpointer  user_data)      : Run First

Adds, updates or deletes a named pair, accordling to the given parameters.

If pair is NULL, the name named pair is searched and deleted. If it is not found, a warning is raised.

Otherwise, the name named pair is searched: if it is found, its data are updated with pair. If it is not found, a new named pair is created using name and pair.