![]() |
![]() |
![]() |
adg-1 reference manual |
![]() |
---|---|---|---|---|
Top | Description | Object Hierarchy |
AdgTableCellAdgTableCell — A single cell of an AdgTable |
AdgTableCell; constCpmlExtents * adg_table_cell_arrange (AdgTableCell *table_cell
,const
);CpmlExtents *layoutvoid adg_table_cell_dispose (AdgTableCell *table_cell
); AdgTableCell * adg_table_cell_dup (const AdgTableCell *table_cell
);void adg_table_cell_free (AdgTableCell *table_cell
); constCpmlExtents * adg_table_cell_get_extents (AdgTableCell *table_cell
); AdgTableRow * adg_table_cell_get_row (AdgTableCell *table_cell
); AdgTable * adg_table_cell_get_table (AdgTableCell *table_cell
);gdouble adg_table_cell_get_width (AdgTableCell *table_cell
);gboolean adg_table_cell_has_frame (AdgTableCell *table_cell
); AdgTableCell * adg_table_cell_new (AdgTableRow *table_row
); AdgTableCell * adg_table_cell_new_before (AdgTableCell *before_cell
); AdgTableCell * adg_table_cell_new_full (AdgTableRow *table_row
,,
gdouble widthconst
,gchar *nameconst
,gchar *title); AdgTableCell * adg_table_cell_new_with_width (
gboolean has_frameAdgTableRow *table_row
,);
gdouble widthvoid adg_table_cell_set_text_title (AdgTableCell *table_cell
,const
);gchar *titlevoid adg_table_cell_set_text_value (AdgTableCell *table_cell
,const
);gchar *valuevoid adg_table_cell_set_title (AdgTableCell *table_cell
,AdgEntity *title
);void adg_table_cell_set_value (AdgTableCell *table_cell
,AdgEntity *value
);void adg_table_cell_set_value_pos (AdgTableCell *table_cell
,const AdgPair *from_factor
,const AdgPair *to_factor
);void adg_table_cell_set_value_pos_explicit (AdgTableCell *table_cell
,,
gdouble from_x,
gdouble from_y,
gdouble to_x);
gdouble to_yvoid adg_table_cell_set_width (AdgTableCell *table_cell
,); const AdgPair * adg_table_cell_size_request (
gdouble widthAdgTableCell *table_cell
,const
);CpmlExtents *row_extentsvoid adg_table_cell_switch_frame (AdgTableCell *table_cell
,); AdgEntity * adg_table_cell_title (
gboolean has_frameAdgTableCell *table_cell
); AdgEntity * adg_table_cell_value (AdgTableCell *table_cell
);
The AdgTableCell is a boxed type, the basic component of an AdgTable entity. It must be added to an AdgTableRow that, in cascade, will be added to an AdgTable entity.
Any cell can be filled with a title and a value: the font to be used will be picked up from the AdgTableStyle got by resolving the "table-dress" property.
The default title is placed at the upper left corner of the cell
while the value is centered up to the bottom edge of the cell.
Anyway the text positioning can be customized by using the
adg_table_cell_set_value_pos()
method.
Some convenient functions to easily create title and value entities
with plain text are provided: adg_table_cell_new_full()
,
adg_table_cell_set_text_title()
and adg_table_cell_set_text_value()
.
When using these methods keep in mind the underlying AdgToyText
entities will be displaced accordingly to the
"cell-padding" value, not used when setting the
entities throught other APIs.
typedef struct _AdgTableCell AdgTableCell;
An opaque structure referring to the cell of an AdgTableRow. Any row can have an unlimited number of cells.
Since 1.0
constCpmlExtents * adg_table_cell_arrange (AdgTableCell *table_cell
,const
);CpmlExtents *layout
Rearranges the underlying AdgTableCell owned by table_cell
using
the new extents provided in layout
. If the x or y size component
of layout
is negative, the value holded by the internal extents
struct is not overriden.
table_cell->extents must be up to date if layout->size.x
or
layout->size.y
is negative in order to have a valid size.
|
an AdgTableCell |
|
the new extents to use |
Returns : |
the extents of table_cell or NULL |
Since 1.0
void adg_table_cell_dispose (AdgTableCell *table_cell
);
Disposes table_cell
.
|
a valid AdgTableCell struct |
Since 1.0
AdgTableCell * adg_table_cell_dup (const AdgTableCell *table_cell
);
Duplicates table_cell
. The returned duplicate should be freed
with adg_table_cell_free()
when no longer needed.
|
an AdgTableCell structure |
Returns : |
a duplicate of table_cell . [transfer full] |
Since 1.0
void adg_table_cell_free (AdgTableCell *table_cell
);
Releases all the memory allocated by table_cell
, itself included.
|
an AdgTableCell structure |
Since 1.0
constCpmlExtents * adg_table_cell_get_extents (AdgTableCell *table_cell
);
Gets the extents of table_cell
. This function is useful only after the
arrange()
|
a valid AdgTableCell |
Returns : |
the extents of table_cell or NULL |
Since 1.0
AdgTableRow * adg_table_cell_get_row (AdgTableCell *table_cell
);
Gets the row container of table_cell
. The returned AdgTableRow
is owned by table_cell
and must not be modified or freed.
|
a valid AdgTableCell |
Returns : |
the container row. [transfer none] |
Since 1.0
AdgTable * adg_table_cell_get_table (AdgTableCell *table_cell
);
A convenient function that gets the table that contains
table_cell
. The returned AdgTable is owned by table_cell
and must not be modified or freed.
|
a valid AdgTableCell |
Returns : |
the container table. [transfer none] |
Since 1.0
gdouble adg_table_cell_get_width (AdgTableCell *table_cell
);
Gets the width of table_cell
.
|
a valid AdgTableCell |
Returns : |
the requested width or 0 |
Since 1.0
gboolean adg_table_cell_has_frame (AdgTableCell *table_cell
);
Gets the frame flag of table_cell
.
|
a valid AdgTableCell |
Returns : |
the frame flag. |
Since 1.0
AdgTableCell * adg_table_cell_new (AdgTableRow *table_row
);
Creates a new empty cell without a frame and appends it at the
end of the cells yet present in table_row
. You can add content
to the cell by using adg_table_cell_set_title()
and
adg_table_cell_set_value()
or enable the frame with
adg_table_cell_switch_frame()
.
|
a valid AdgTableRow |
Returns : |
the newly created cell or NULL |
Since 1.0
AdgTableCell * adg_table_cell_new_before (AdgTableCell *before_cell
);
Creates a new cell and inserts it rigthly before the table_cell
cell.
|
a valid AdgTableCell |
Returns : |
the newly created cell or NULL |
Since 1.0
AdgTableCell * adg_table_cell_new_full (AdgTableRow *table_row
,,
gdouble widthconst
,gchar *nameconst
,gchar *title);
gboolean has_frame
A convenient function to add a cell and specifies some common used properties at once.
If name
is NULL
adg_table_set_cell()
for further details on what a named
cell is supposed to be..
title
can be NULL
|
a valid AdgTableRow |
|
the cell width |
|
the name to bound to this cell. [allow-none] |
|
the title text. [allow-none] |
|
whether to draw or not the frame |
Returns : |
the newly created cell or NULL |
Since 1.0
AdgTableCell * adg_table_cell_new_with_width (AdgTableRow *table_row
,);
gdouble width
A convenient wrapper to adg_table_cell_new()
that allows to
specify the width
of table_row
all at once.
|
a valid AdgTableRow |
|
the cell width |
Returns : |
the newly created cell or NULL |
Since 1.0
void adg_table_cell_set_text_title (AdgTableCell *table_cell
,const
);gchar *title
Convenient function to set a the title of a cell using an AdgToyText
entity with the font dress picked from "table-dress" with
a call to adg_table_style_get_title_dress()
.
|
a valid AdgTableCell |
|
a text string |
Since 1.0
void adg_table_cell_set_text_value (AdgTableCell *table_cell
,const
);gchar *value
Convenient function to set a the value of a cell using an AdgToyText
entity with a value font dress picked from "table-dress" with
a call to adg_table_style_get_value_dress()
.
|
a valid AdgTableCell |
|
a text string |
Since 1.0
void adg_table_cell_set_title (AdgTableCell *table_cell
,AdgEntity *title
);
Sets title
as the new title entity of table_cell
. The top left
corner of the bounding box of title
will be cohincident to
the top left corner of the cell extents, taking into accounts
eventual padding spaces specified by the table style.
The old internal entity is unrefenrenced while the title
(if
not NULL
g_object_ref_sink()
title
can be NULL
|
a valid AdgTableCell |
|
the new title entity |
Since 1.0
void adg_table_cell_set_value (AdgTableCell *table_cell
,AdgEntity *value
);
Sets value
as the new value entity of table_cell
. The bottom middle
point of the bounding box of value
will be cohincident to the
bottom middle point of the cell extents, taking into accounts
eventual padding spaces specified by the table style.
The old internal entity is unrefenrenced while the value
(if
not NULL
g_object_ref_sink()
value
can be NULL
|
a valid AdgTableCell |
|
the new value entity |
Since 1.0
void adg_table_cell_set_value_pos (AdgTableCell *table_cell
,const AdgPair *from_factor
,const AdgPair *to_factor
);
Sets a new custom position for the value entity of table_cell
. The
from_factor
specifies the source point (as a fraction of the
value extents) while the to_factor
is the destination point
(specified as a fraction of the cell extents) the source point
must be moved to.
|
a valid AdgTableCell |
|
the alignment factor on the value entity |
|
the alignment factor on the cell |
Since 1.0
void adg_table_cell_set_value_pos_explicit (AdgTableCell *table_cell
,,
gdouble from_x,
gdouble from_y,
gdouble to_x);
gdouble to_y
A convenient wrapper around adg_table_cell_set_value_pos()
that uses explicit factors instead of AdgPair.
|
a valid AdgTableCell |
|
the x alignment factor on the entity |
|
the y alignment factor on the entity |
|
the x alignment factor on the cell |
|
the y alignment factor on the cell |
Since 1.0
void adg_table_cell_set_width (AdgTableCell *table_cell
,);
gdouble width
Sets a new width on table_cell
. The extents on the whole table
will be invalidated, so will be recomputed in the next
arrange()
A positive width
value specifies the width of this cell in global
space: if the width of its content (that is, either the title or the
value entity) will be greater than width
, it will be rendered
outside the cell boundary box, luckely overwriting the adiacent
cells.
Using 0
width
means the width of the cell will be automatically
adjusted to the maximum width of its content.
Negative width values are not allowed: this condition will raise a warning without any further processing.
|
a valid AdgTableCell |
|
the new width |
Since 1.0
const AdgPair * adg_table_cell_size_request (AdgTableCell *table_cell
,const
);CpmlExtents *row_extents
Computes the minimum space needed to properly render table_cell
and updates the size component of the internal table_cell
and should not be modified or freed.
|
a valid AdgTableCell |
|
the extents of the container AdgTableRow |
Returns : |
the minimum size required. [transfer none] |
Since 1.0
void adg_table_cell_switch_frame (AdgTableCell *table_cell
,);
gboolean has_frame
Sets the frame flag of table_cell
: if has_frame
is TRUE
table_cell
will be rendered using the
|
a valid AdgTableCell |
|
whether to draw or not the frame |
Since 1.0
AdgEntity * adg_table_cell_title (AdgTableCell *table_cell
);
Gets the current title of table_cell
. The returned string is owned
by table_cell
and must not be modified or freed.
|
a valid AdgTableCell |
Returns : |
the title entity or NULL |
Since 1.0
AdgEntity * adg_table_cell_value (AdgTableCell *table_cell
);
Gets the current value of table_cell
. The returned string is owned
by table_cell
and must not be modified or freed.
|
a valid AdgTableCell |
Returns : |
the value entity or NULL |
Since 1.0