In this example, we demonstrate the use of Evas box objects. We cover changing boxes' layouts (with a custom layout, besides the ones provided by Evas), box padding and alignment influence on the layouts, insertion and removal of box items.
The interesting part of the code starts, naturally, when we add a box object to the canvas. Just after it, we place five rectangles, with random colors, inside of it. Those rectangles get a minimum size hint of 50 pixels on each axis, which will be respected by most of the box's possible layouts:
for (i = 1; i <= 5; i++)
{
o, rand() % 256, rand() % 256, rand() % 256, 255);
{
fprintf(stderr, "Error appending child object on the box!\n");
goto error;
}
}
Just like in other Evas examples, we have a white background on the canvas and a red border around the container object of interest, the box, to mark its boundaries. Resizing of the canvas will keep the box's proportion with regard to the whole canvas', so that you can experiment with different sizes of the box to accommodate its children:
static void
_canvas_resize_cb(Ecore_Evas *ee)
{
int w, h;
}
Again, one interacts with this program by means of key commands:
static const char *commands = \
"commands are:\n"
"\ta - change the box's alignment values\n"
"\tp - change the box's padding values\n"
"\t1 - change the box's layout to horizontal\n"
"\t2 - change the box's layout to vertical\n"
"\t3 - change the box's layout to horizontal homogeneous\n"
"\t4 - change the box's layout to vertical homogeneous\n"
"\t5 - change the box's layout to horizontal maximum size homogeneous\n"
"\t6 - change the box's layout to vertical maximum size homogeneous\n"
"\t7 - change the box's layout to horizontal flow\n"
"\t8 - change the box's layout to vertical flow\n"
"\t9 - change the box's layout to stack\n"
"\t0 - change the box's layout to a custom-made one\n"
"\tCtrl + NUMBER - insert a new child object at that position in the box\n"
"\tShift + NUMBER - remove the child object at that position in the box\n"
"\th - print help\n";
Let's start with the numeric ones, each of which will impose a different layout on the box object.
The initial layout the box starts at is the one triggered by the key '1'
– the horizontal layout. Thus, the initial appearance of this program, demonstrating this layout, is something like:
The vertical layout ('2'
key) is very similar, but just disposing the items vertically:
Note the influence of the (default) 0.5
box alignment property, which will let the children line in the middle of the box's area. Also, because the space required by them extrapolates the box's height (we resized it to be smaller), they'll be drawn out if its bounds.
Next, comes the horizontal homogeneous layout ('3'
key). See how it reserves an equal amount of space for each child to take:
Its vertical equivalent can be triggered by the '4'
key. The next different layout of interest is the horizontal maximum size homogeneous ('5'
key). It will reserve cells to children sized equally to the dimensions of the child with bigger size (or minimum size hints). For this example, all cells would be just the size of our rectangles' minimum size hints and, to prove that, insert a new (smaller) rectangle at position 3, say, with Ctrl
and 3
keys together:
The code for the commands inserting and deleting box items is:
{
int pos;
if (!obj) goto list_free;
list_free:
return;
}
{
int pos;
o_ = _new_rectangle_add(d.evas);
return;
}
_new_rectangle_add(
Evas *e)
{
return o;
}
In that code, we exemplify evas_object_box_children_get(), to fetch a child element at an exact position. After the element removal from the box (leaving it unparented again), we delete it and free that list. The code inserting a new rectangle, there, is straightforward.
Try the '6'
key for the vertical equivalent of the last shown layout. Then, comes the flow layout, triggered by the '7'
key. We make our box small to demonstrate the effect on the items layouting:
The next two numerical commands are for the vertical equivalent of the last and the stack one, respectively. Try them out to get their looks.
The last numerical key, '0'
, shows the effect of a custom layout on the box. We wrote one that would split the width and height of the box equally and, then, place the items in the cells in the diagonal:
if (strcmp(ev->
key,
"0") == 0)
{
printf("Applying '%s' layout on the box\n",
"CUSTOM");
return;
}
static void
{
int x, y, w, h;
int xx, yy, ww, hh;
int count;
ww = w / (count ? : 1);
hh = h / (count ? : 1);
if (ww < 1) ww = 1;
if (hh < 1) hh = 1;
xx = x;
yy = y;
{
xx += ww;
yy += hh;
}
}
Finally, the 'a'
and 'p'
commands will change the box's alignment and padding property values, respectively. For each of the layouts above, see the effects they make by setting different values on those properties.
The full code for this example follows. For an exercise on the effect of children box elements' size hints on a box layout, try the Evas alignment, minimum size, maximum size, padding and weight hints example.
#ifdef HAVE_CONFIG_H
#include "config.h"
#else
#define PACKAGE_EXAMPLES_DIR "."
#endif
#include <Ecore.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "evas-common.h"
#define WIDTH (640)
#define HEIGHT (480)
static const char *border_img_path = PACKAGE_EXAMPLES_DIR EVAS_IMAGE_FOLDER "/red.png";
static const char *commands = \
"commands are:\n"
"\ta - change the box's alignment values\n"
"\tp - change the box's padding values\n"
"\t1 - change the box's layout to horizontal\n"
"\t2 - change the box's layout to vertical\n"
"\t3 - change the box's layout to horizontal homogeneous\n"
"\t4 - change the box's layout to vertical homogeneous\n"
"\t5 - change the box's layout to horizontal maximum size homogeneous\n"
"\t6 - change the box's layout to vertical maximum size homogeneous\n"
"\t7 - change the box's layout to horizontal flow\n"
"\t8 - change the box's layout to vertical flow\n"
"\t9 - change the box's layout to stack\n"
"\t0 - change the box's layout to a custom-made one\n"
"\tCtrl + NUMBER - insert a new child object at that position in the box\n"
"\tShift + NUMBER - remove the child object at that position in the box\n"
"\th - print help\n";
struct example_data
{
Ecore_Evas *ee;
};
static struct example_data d;
static void
{
int x, y, w, h;
int xx, yy, ww, hh;
int count;
ww = w / (count ? : 1);
hh = h / (count ? : 1);
if (ww < 1) ww = 1;
if (hh < 1) hh = 1;
xx = x;
yy = y;
{
xx += ww;
yy += hh;
}
}
_new_rectangle_add(
Evas *e)
{
return o;
}
static void
void *einfo)
{
if (strcmp(ev->
key,
"h") == 0)
{
printf("%s", commands);
return;
}
{
int pos;
if (!obj) goto list_free;
list_free:
return;
}
{
int pos;
o_ = _new_rectangle_add(d.evas);
return;
}
if (strcmp(ev->
key,
"a") == 0)
{
double h, v;
h = v = 1.0;
h = v = -1.0;
h = v = 0.0;
h = v = 0.5;
printf("Applying new alignment values (%.1f, %.1f) on the box\n",
h, v);
return;
}
if (strcmp(ev->
key,
"p") == 0)
{
int h, v;
if (h == 0)
h = v = 50;
else
h = v = 0;
printf("Applying new padding values (%d, %d) on the box\n",
h, v);
return;
}
if (strcmp(ev->
key,
"1") == 0)
{
printf("Applying '%s' layout on the box\n",
"horizontal");
return;
}
if (strcmp(ev->
key,
"2") == 0)
{
printf("Applying '%s' layout on the box\n",
"vertical");
return;
}
if (strcmp(ev->
key,
"3") == 0)
{
NULL);
printf("Applying '%s' layout on the box\n",
"horizontal homogeneous");
return;
}
if (strcmp(ev->
key,
"4") == 0)
{
printf("Applying '%s' layout on the box\n",
"vertical homogeneous");
return;
}
if (strcmp(ev->
key,
"5") == 0)
{
NULL, NULL);
printf("Applying '%s' layout on the box\n",
"horizontal maximum size homogeneous");
return;
}
if (strcmp(ev->
key,
"6") == 0)
{
NULL, NULL);
printf("Applying '%s' layout on the box\n",
"vertical maximum size homogeneous");
return;
}
if (strcmp(ev->
key,
"7") == 0)
{
printf("Applying '%s' layout on the box\n",
"horizontal flow");
return;
}
if (strcmp(ev->
key,
"8") == 0)
{
printf("Applying '%s' layout on the box\n",
"vertical flow");
return;
}
if (strcmp(ev->
key,
"9") == 0)
{
printf("Applying '%s' layout on the box\n",
"stack");
return;
}
if (strcmp(ev->
key,
"0") == 0)
{
printf("Applying '%s' layout on the box\n",
"CUSTOM");
return;
}
}
static void
{
}
static void
_canvas_resize_cb(Ecore_Evas *ee)
{
int w, h;
}
int
main(void)
{
int i;
srand(time(NULL));
return EXIT_FAILURE;
if (!d.ee)
goto panic;
for (i = 1; i <= 5; i++)
{
o, rand() % 256, rand() % 256, rand() % 256, 255);
{
fprintf(stderr, "Error appending child object on the box!\n");
goto error;
}
}
printf("%s", commands);
_canvas_resize_cb(d.ee);
return 0;
error:
return -1;
panic:
fprintf(stderr, "error: Requires at least one Evas engine built and linked"
" to ecore-evas for this example to run properly.\n");
return -2;
}
EAPI Ecore_Evas * ecore_evas_new(const char *engine_name, int x, int y, int w, int h, const char *extra_options)
Creates a new Ecore_Evas based on engine name and common parameters.
Definition: ecore_evas.c:1065
Evas_Object * evas_object_image_filled_add(Evas *eo_e)
Creates a new image object that automatically scales its bound image to the object's area,...
Definition: evas_image_legacy.c:35
EAPI int ecore_evas_shutdown(void)
Shuts down the Ecore_Evas system.
Definition: ecore_evas.c:674
void evas_object_image_border_set(Evas_Object *obj, int l, int r, int t, int b)
Dimensions of this image's border, a region that does not scale with the center area.
Definition: evas_image_legacy.c:117
Eina_List * evas_object_box_children_get(const Evas_Object *o)
Get the list of children objects in a given box object.
Definition: evas_object_box.c:1924
EAPI void ecore_evas_geometry_get(const Ecore_Evas *ee, int *x, int *y, int *w, int *h)
Gets the geometry of an Ecore_Evas.
Definition: ecore_evas.c:1388
void evas_object_box_padding_set(Evas_Box *obj, int horizontal, int vertical)
Set the (space) padding between cells set for a given box object.
Definition: evas_box_eo.legacy.c:15
void evas_object_box_layout_homogeneous_max_size_horizontal(Evas_Box *obj, Evas_Object_Box_Data *priv, void *data)
Layout function which sets the box o to a maximum size, homogeneous horizontal box.
Definition: evas_box_eo.legacy.c:45
void evas_object_box_layout_flow_vertical(Evas_Box *obj, Evas_Object_Box_Data *priv, void *data)
Layout function which sets the box o to a flow vertical box.
Definition: evas_box_eo.legacy.c:51
void evas_object_box_align_get(const Evas_Box *obj, double *horizontal, double *vertical)
Get the alignment of the whole bounding box of contents, for a given box object.
Definition: evas_box_eo.legacy.c:9
EAPI void ecore_evas_callback_resize_set(Ecore_Evas *ee, Ecore_Evas_Event_Cb func)
Sets a callback for Ecore_Evas resize events.
Definition: ecore_evas.c:1166
void ecore_main_loop_quit(void)
Quits the main loop once all the events currently on the queue have been processed.
Definition: ecore_main.c:1308
void evas_object_size_hint_min_set(Evas_Object *obj, Evas_Coord w, Evas_Coord h)
Sets the hints for an object's minimum size.
Definition: evas_object_main.c:2611
Key press event.
Definition: Evas_Legacy.h:313
#define EINA_LIST_FOREACH(list, l, _data)
Definition for the macro to iterate over a list.
Definition: eina_list.h:1415
#define EINA_UNUSED
Definition: eina_types.h:339
void evas_object_box_layout_vertical(Evas_Box *obj, Evas_Object_Box_Data *priv, void *data)
Layout function which sets the box o to a (basic) vertical box.
Definition: evas_box_eo.legacy.c:39
EAPI int ecore_evas_init(void)
Inits the Ecore_Evas system.
Definition: ecore_evas.c:606
void evas_object_box_layout_homogeneous_horizontal(Evas_Box *obj, Evas_Object_Box_Data *priv, void *data)
Layout function which sets the box o to a homogeneous horizontal box.
Definition: evas_box_eo.legacy.c:123
EAPI void * eina_list_nth(const Eina_List *list, unsigned int n)
Gets the nth member's data pointer in a list, or NULL on error.
Definition: eina_list.c:994
void evas_object_box_align_set(Evas_Box *obj, double horizontal, double vertical)
Set the alignment of the whole bounding box of contents, for a given box object.
Definition: evas_box_eo.legacy.c:3
Eina_Bool evas_object_box_remove_at(Evas_Box *obj, unsigned int pos)
Remove an object, bound to a given position in a box object, unparenting it again.
Definition: evas_box_eo.legacy.c:105
Efl_Canvas_Object Evas_Object
Definition: Evas_Common.h:185
void evas_object_image_border_center_fill_set(Evas_Object *obj, Evas_Border_Fill_Mode fill)
Specifies how the center part of the object (not the borders) should be drawn when EFL is rendering i...
Definition: evas_image_legacy.c:145
EAPI void ecore_evas_callback_delete_request_set(Ecore_Evas *ee, Ecore_Evas_Event_Cb func)
Sets a callback for Ecore_Evas delete request events.
Definition: ecore_evas.c:1202
void evas_object_resize(Evas_Object *obj, Evas_Coord w, Evas_Coord h)
Changes the size of the given Evas object.
Definition: evas_object_main.c:1236
EAPI Evas * ecore_evas_get(const Ecore_Evas *ee)
Gets an Ecore_Evas's Evas.
Definition: ecore_evas.c:1326
const Evas_Modifier * evas_key_modifier_get(const Evas *eo_e)
Returns a handle to the list of modifier keys registered in the canvas e.
Definition: evas_key.c:35
void evas_object_geometry_get(const Evas_Object *eo_obj, Evas_Coord *x, Evas_Coord *y, Evas_Coord *w, Evas_Coord *h)
Retrieves the position and (rectangular) size of the given Evas object.
Definition: evas_object_main.c:1335
void evas_object_event_callback_add(Evas_Object *eo_obj, Evas_Callback_Type type, Evas_Object_Event_Cb func, const void *data)
Add (register) a callback function to a given Evas object event.
Definition: evas_callbacks.c:478
@ EVAS_CALLBACK_KEY_DOWN
Key Press Event.
Definition: Evas_Common.h:430
Evas_Object_Box_Option * evas_object_box_insert_at(Evas_Box *obj, Efl_Canvas_Object *child, unsigned int pos)
Insert a new child object at a given position, in a given box object o.
Definition: evas_box_eo.legacy.c:135
const char * key
The logical key : (eg shift+1 == exclamation)
Definition: Evas_Legacy.h:320
void ecore_main_loop_begin(void)
Runs the application main loop.
Definition: ecore_main.c:1298
void evas_object_box_layout_stack(Evas_Box *obj, Evas_Object_Box_Data *priv, void *data)
Layout function which sets the box o to a stacking box.
Definition: evas_box_eo.legacy.c:147
void evas_object_focus_set(Efl_Canvas_Object *obj, Eina_Bool focus)
Indicates that this object is the keyboard event receiver on its canvas.
Definition: efl_canvas_object_eo.legacy.c:39
void evas_object_show(Evas_Object *eo_obj)
Makes the given Evas object visible.
Definition: evas_object_main.c:1814
void evas_object_box_layout_homogeneous_max_size_vertical(Evas_Box *obj, Evas_Object_Box_Data *priv, void *data)
Layout function which sets the box o to a maximum size, homogeneous vertical box.
Definition: evas_box_eo.legacy.c:129
Eo Evas
Definition: Evas_Common.h:163
void evas_object_box_layout_set(Evas_Box *obj, Evas_Object_Box_Layout cb, const void *data, Eina_Free_Cb free_data)
Set a new layouting function to a given box object.
Definition: evas_box_eo.legacy.c:27
#define EINA_TRUE
Definition: eina_types.h:539
void evas_object_box_layout_homogeneous_vertical(Evas_Box *obj, Evas_Object_Box_Data *priv, void *data)
Layout function which sets the box o to a homogeneous vertical box.
Definition: evas_box_eo.legacy.c:153
EAPI Eina_List * eina_list_free(Eina_List *list)
Frees an entire list and all the nodes, ignoring the data contained.
Definition: eina_list.c:823
Evas_Object * obj
Pointer to the box child object, itself.
Definition: Evas_Common.h:2873
unsigned char Eina_Bool
Definition: eina_types.h:527
Definition: Evas_Common.h:2848
void evas_object_image_file_set(Evas_Object *obj, const char *file, const char *key)
Set the source file from where an image object must fetch the real image data (it may be an Eet file,...
Definition: evas_image_legacy.c:194
void evas_object_del(Evas_Object *obj)
Marks the given Evas object for deletion (when Evas will free its memory).
Definition: evas_object_main.c:928
Evas_Object * evas_object_rectangle_add(Evas *e)
Adds a rectangle to the given evas.
Definition: evas_object_rectangle.c:78
void evas_object_box_padding_get(const Evas_Box *obj, int *horizontal, int *vertical)
Get the (space) padding between cells set for a given box object.
Definition: evas_box_eo.legacy.c:21
Evas_Object_Box_Option * evas_object_box_append(Evas_Box *obj, Efl_Canvas_Object *child)
Append a new child object to the given box object o.
Definition: evas_box_eo.legacy.c:81
Definition: eina_list.h:317
Definition: Evas_Common.h:2871
void evas_object_move(Evas_Object *obj, Evas_Coord x, Evas_Coord y)
Move the given Evas object to the given location inside its canvas' viewport.
Definition: evas_object_main.c:1171
Eina_Bool evas_key_modifier_is_set(const Evas_Modifier *m, const char *keyname)
Checks the state of a given modifier of the default seat, at the time of the call.
Definition: evas_key.c:76
void evas_object_box_layout_horizontal(Evas_Box *obj, Evas_Object_Box_Data *priv, void *data)
Layout function which sets the box o to a (basic) horizontal box.
Definition: evas_box_eo.legacy.c:33
Evas_Object * evas_object_box_add(Evas *evas)
Add a new box object on the provided canvas.
Definition: evas_object_box.c:481
@ EVAS_BORDER_FILL_NONE
Image's center region is not to be rendered.
Definition: Evas_Legacy.h:5721
EAPI void ecore_evas_show(Ecore_Evas *ee)
Shows an Ecore_Evas' window.
Definition: ecore_evas.c:1506
void evas_object_box_layout_flow_horizontal(Evas_Box *obj, Evas_Object_Box_Data *priv, void *data)
Layout function which sets the box o to a flow horizontal box.
Definition: evas_box_eo.legacy.c:159
void evas_object_color_set(Evas_Object *obj, int r, int g, int b, int a)
Sets the general/main color of the given Evas object to the given one.
Definition: evas_object_main.c:2024
static unsigned int eina_list_count(const Eina_List *list)
Gets the count of the number of items in a list.