[evas] Examples on box object.

SVN revision: 62102

legacy/evas/doc/examples.dox

@@ -24,6 +24,8 @@
  * @ref Example_Evas_Stacking
  *
  * @ref Example_Evas_Smart_Objects
+ *
+ * @ref Example_Evas_Box Evas box
  */
 
 /**
@@ -349,10 +351,152 @@
 /**
  * @page Example_Evas_Size_Hints Evas alignment, minimum size, maximum size, padding and weight hints example
  *
+ * In this code, we place a (vertical) box with two rectangles as
+ * child elements. It has a command line interface with which to act
+ * on those rectangles' <b>size hints</b>:
+ * @dontinclude evas-hints.c
+ * @skip static const char commands
+ * @until ;
+ *
+ * That should be self explanatory. Change those values (possibly
+ * resizing the box, which will resize together with the example's
+ * window) to get how size hints are honored by a container object,
+ * which in this case is the Evas box.
+ *
+ * More on this smart object can be found on @ref Example_Evas_Box.
+ * The full code for this example follows.
+ *
  * @include evas-hints.c
  * @example evas-hints.c
  */
 
+/**
+ * @page Example_Evas_Box Evas box example
+ *
+ * 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:
+ * @dontinclude evas-box.c
+ * @skip evas_object_box_add
+ * @until }
+ * @until }
+ *
+ * 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 accomodate its
+ * children:
+ * @dontinclude evas-box.c
+ * @skip adjust canvas' contents on resizes
+ * @until }
+ *
+ * Again, one interacts with this program by means of key commands:
+ * @dontinclude evas-box.c
+ * @skip static const char *commands
+ * @until ;
+ *
+ * Let's start with the @b 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 @c '1' -- the horizontal layout. Thus, the initial appearence
+ * of this program, demonstrating this layout, is something like:
+ * @image html evas-box-example-00.png
+ * @image rtf evas-box-example-00.png
+ * @image latex evas-box-example-00.eps
+ *
+ * The vertical layout (@c '2' key) is very similar, but just
+ * disposing the items vertically:
+ * @image html evas-box-example-01.png
+ * @image rtf evas-box-example-01.png
+ * @image latex evas-box-example-01.eps
+ *
+ * Note the influence of the (default) @c 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 @b homogeneous layout (@c '3' key). See
+ * how it reserves an equal amount of space for each child to take:
+ * @image html evas-box-example-02.png
+ * @image rtf evas-box-example-02.png
+ * @image latex evas-box-example-02.eps
+ *
+ * Its vertical equivalent can be triggered by the @c '4' key. The
+ * next different layout of interest is the horizontal maximum size
+ * homogeneous (@c '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 @c Ctrl and @c 3 keys
+ * together:
+ * @image html evas-box-example-03.png
+ * @image rtf evas-box-example-03.png
+ * @image latex evas-box-example-03.eps
+ *
+ * The code for the commands inserting and deleting box items is:
+ * @dontinclude evas-box.c
+ * @skip mods, "Shift"
+ * @until }
+ * @until }
+ * @dontinclude evas-box.c
+ * @skip new rectangle to be put in the box
+ * @until }
+ * 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 @c '6' key for the vertical equivalent of the last shown
+ * layout. Then, comes the @b flow layout, triggered by the @c '7'
+ * key. We make our box small to demonstrate the effect on the items
+ * layouting:
+ * @image html evas-box-example-04.png
+ * @image rtf evas-box-example-04.png
+ * @image latex evas-box-example-04.eps
+ *
+ * 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, @c '0', shows the effect of a @b 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:
+ * @dontinclude evas-box.c
+ * @skip keyname, "0"
+ * @until }
+ * @dontinclude evas-box.c
+ * @skip custom 'diagonal' layout
+ * @until }
+ * @until }
+ * @image html evas-box-example-05.png
+ * @image rtf evas-box-example-05.png
+ * @image latex evas-box-example-05.eps
+ *
+ * Finally, the @c 'a' and @c '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 <b>the
+ * effect of children box elements' size hints on a box layout</b>,
+ * try the @ref Example_Evas_Size_Hints.
+ *
+ * @include evas-box.c
+ * @example evas-box.c
+ */
+
 /**
  * @page Example_Evas_Stacking Evas object stacking functions (and some event handling)
  * @dontinclude evas-stacking.c
@@ -367,7 +511,8 @@
  * @skip d.rects[2] = evas_object_rectangle_add(d.canvas);
  * @until evas_object_show(d.rects[0]);
  * @dontinclude evas-stacking.c
- * Like in other Evas examples, one interacts with it be means of key commands:
+ * Like in other Evas examples, one interacts with it by means of key
+ * commands:
  * @skip static const char *commands
  * @until ;
  * At any given point, like seem above, you'll be operating one rectangle only.

legacy/evas/src/examples/Makefile.am

@@ -77,6 +77,10 @@ pkglib_PROGRAMS += evas_smart_object
 evas_smart_object_SOURCES = evas-smart-object.c
 evas_smart_object_LDADD = $(top_builddir)/src/lib/libevas.la @ECORE_EVAS_LIBS@
 
+pkglib_PROGRAMS += evas_box
+evas_box_SOURCES = evas-box.c
+evas_box_LDADD = $(top_builddir)/src/lib/libevas.la @ECORE_EVAS_LIBS@
+
 #the ones using ecore_evas and edje follow
 AM_CPPFLAGS += @EDJE_CFLAGS@
 
@@ -121,7 +125,8 @@ files_DATA += \
 	$(srcdir)/evas-stacking.c \
 	$(srcdir)/evas-map-utils.c \
 	$(srcdir)/evas-text.c \
-	$(srcdir)/evas-smart-object.c
+	$(srcdir)/evas-smart-object.c \
+	$(srcdir)/evas-box.c
 endif
 
 EXTRA_DIST = $(EDCS) \
@@ -137,6 +142,7 @@ EXTRA_DIST = $(EDCS) \
 	$(srcdir)/evas-map-utils.c \
 	$(srcdir)/evas-text.c \
 	$(srcdir)/evas-smart-object.c \
+	$(srcdir)/box.c \
 	$(srcdir)/enlightenment.png \
 	$(srcdir)/red.png \
 	$(srcdir)/im1.png \

legacy/evas/src/examples/evas-box.c

@@ -0,0 +1,382 @@
+/**
+ * Simple Evas example illustrating a custom Evas box object
+ *
+ * You'll need at least one engine built for it (excluding the buffer
+ * one). See stdout/stderr for output.
+ *
+ * @verbatim
+ * gcc -o evas-box evas-box.c `pkg-config --libs --cflags evas ecore ecore-evas`
+ * @endverbatim
+ */
+
+#ifdef HAVE_CONFIG_H
+
+#include "config.h"
+#else
+#define PACKAGE_EXAMPLES_DIR "."
+#define __UNUSED__
+#endif
+
+#include <Ecore.h>
+#include <Ecore_Evas.h>
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#define WIDTH  (640)
+#define HEIGHT (480)
+
+static const char *border_img_path = PACKAGE_EXAMPLES_DIR "/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 exemple_data
+{
+   Ecore_Evas  *ee;
+   Evas        *evas;
+   Evas_Object *bg, *box, *border;
+};
+
+static struct exemple_data d;
+
+static void /* custom 'diagonal' layout */
+_custom_layout(Evas_Object          *o,
+               Evas_Object_Box_Data *p,
+               void                 *data __UNUSED__)
+{
+   int x, y, w, h;
+   int xx, yy, ww, hh;
+   int count;
+   Eina_List *l;
+   Evas_Object_Box_Option *opt;
+
+   evas_object_geometry_get(o, &x, &y, &w, &h);
+   count = eina_list_count(p->children);
+   ww = w / (count ? : 1);
+   hh = h / (count ? : 1);
+   if (ww < 1) ww = 1;
+   if (hh < 1) hh = 1;
+
+   xx = x;
+   yy = y;
+   EINA_LIST_FOREACH(p->children, l, opt)
+     {
+        evas_object_move(opt->obj, xx, yy);
+        xx += ww;
+        yy += hh;
+     }
+}
+
+static Evas_Object * /* new rectangle to be put in the box */
+_new_rectangle_add(Evas *e)
+{
+   Evas_Object *o;
+
+   o = evas_object_rectangle_add(e);
+   evas_object_resize(o, 10, 10);
+   evas_object_color_set(o, 0, 255, 0, 255);
+   evas_object_show(o);
+
+   return o;
+}
+
+/* use the following commands to interact with this example - 'h' is
+ * the key for help */
+static void
+_on_keydown(void        *data __UNUSED__,
+            Evas        *evas __UNUSED__,
+            Evas_Object *o __UNUSED__,
+            void        *einfo)
+{
+   Evas_Event_Key_Down *ev = einfo;
+   const Evas_Modifier *mods = evas_key_modifier_get(evas);
+
+   if (strcmp(ev->keyname, "h") == 0) /* print help */
+     {
+        fprintf(stdout, commands);
+        return;
+     }
+
+   if (evas_key_modifier_is_set(mods, "Shift"))
+     {
+        int pos;
+        Eina_Bool ret;
+        Evas_Object *obj;
+        Eina_List *children;
+
+        pos = atoi(ev->keyname);
+        children = evas_object_box_children_get(d.box);
+
+        obj = eina_list_nth(children, pos);
+        if (!obj) goto list_free;
+
+        ret = evas_object_box_remove_at(d.box, pos);
+        if (ret) evas_object_del(obj);
+
+list_free:
+        eina_list_free(children);
+        return;
+     }
+
+   if (evas_key_modifier_is_set(mods, "Control"))
+     {
+        Evas_Object *o;
+        int pos;
+        pos = atoi(ev->keyname);
+        o = _new_rectangle_add(d.evas);
+        if (!evas_object_box_insert_at(d.box, o, pos))
+          evas_object_box_append(d.box, o);
+        return;
+     }
+
+   if (strcmp(ev->keyname, "a") == 0)
+     {
+        double h, v;
+
+        evas_object_box_align_get(d.box, &h, &v);
+
+        if (h == 0.5)
+          h = v = 1.0;
+        else if (h == 1.0)
+          h = v = -1.0;
+        else if (h == -1.0)
+          h = v = 0.0;
+        else if (h == 0.0)
+          h = v = 0.5;
+
+        evas_object_box_align_set(d.box, h, v);
+
+        fprintf(stdout, "Applying new alignment values (%.1f, %.1f)"
+                        " on the box\n", h, v);
+        return;
+     }
+
+   if (strcmp(ev->keyname, "p") == 0)
+     {
+        int h, v;
+
+        evas_object_box_padding_get(d.box, &h, &v);
+
+        if (h == 0)
+          h = v = 50;
+        else
+          h = v = 0;
+
+        evas_object_box_padding_set(d.box, h, v);
+
+        fprintf(stdout, "Applying new padding values (%d, %d)"
+                        " on the box\n", h, v);
+        return;
+     }
+
+   if (strcmp(ev->keyname, "1") == 0)
+     {
+        evas_object_box_layout_set(
+          d.box, evas_object_box_layout_horizontal, NULL, NULL);
+
+        fprintf(stdout, "Applying '%s' layout on the box\n", "horizontal");
+        return;
+     }
+
+   if (strcmp(ev->keyname, "2") == 0)
+     {
+        evas_object_box_layout_set(
+          d.box, evas_object_box_layout_vertical, NULL, NULL);
+
+        fprintf(stdout, "Applying '%s' layout on the box\n", "vertical");
+        return;
+     }
+
+   if (strcmp(ev->keyname, "3") == 0)
+     {
+        evas_object_box_layout_set(
+          d.box, evas_object_box_layout_homogeneous_horizontal, NULL,
+          NULL);
+
+        fprintf(stdout, "Applying '%s' layout on the box\n",
+                "horizontal homogeneous");
+        return;
+     }
+
+   if (strcmp(ev->keyname, "4") == 0)
+     {
+        evas_object_box_layout_set(
+          d.box, evas_object_box_layout_homogeneous_vertical, NULL, NULL);
+
+        fprintf(stdout, "Applying '%s' layout on the box\n",
+                "vertical homogeneous");
+        return;
+     }
+
+   if (strcmp(ev->keyname, "5") == 0)
+     {
+        evas_object_box_layout_set(
+          d.box, evas_object_box_layout_homogeneous_max_size_horizontal,
+          NULL, NULL);
+
+        fprintf(stdout, "Applying '%s' layout on the box\n",
+                "horizontal maximum size homogeneous");
+        return;
+     }
+
+   if (strcmp(ev->keyname, "6") == 0)
+     {
+        evas_object_box_layout_set(
+          d.box, evas_object_box_layout_homogeneous_max_size_vertical,
+          NULL, NULL);
+
+        fprintf(stdout, "Applying '%s' layout on the box\n",
+                "vertical maximum size homogeneous");
+        return;
+     }
+
+   if (strcmp(ev->keyname, "7") == 0)
+     {
+        evas_object_box_layout_set(
+          d.box, evas_object_box_layout_flow_horizontal, NULL, NULL);
+
+        fprintf(stdout, "Applying '%s' layout on the box\n", "horizontal flow");
+        return;
+     }
+
+   if (strcmp(ev->keyname, "8") == 0)
+     {
+        evas_object_box_layout_set(
+          d.box, evas_object_box_layout_flow_vertical, NULL, NULL);
+
+        fprintf(stdout, "Applying '%s' layout on the box\n", "vertical flow");
+        return;
+     }
+
+   if (strcmp(ev->keyname, "9") == 0)
+     {
+        evas_object_box_layout_set(
+          d.box, evas_object_box_layout_stack, NULL, NULL);
+
+        fprintf(stdout, "Applying '%s' layout on the box\n", "stack");
+        return;
+     }
+
+   if (strcmp(ev->keyname, "0") == 0)
+     {
+        evas_object_box_layout_set(d.box, _custom_layout, NULL, NULL);
+
+        fprintf(stdout, "Applying '%s' layout on the box\n", "CUSTOM");
+        return;
+     }
+}
+
+static void
+_on_delete(Ecore_Evas *ee __UNUSED__)
+{
+   ecore_main_loop_quit();
+}
+
+static void /* adjust canvas' contents on resizes */
+_canvas_resize_cb(Ecore_Evas *ee)
+{
+   int w, h;
+
+   ecore_evas_geometry_get(ee, NULL, NULL, &w, &h);
+
+   evas_object_resize(d.bg, w, h);
+
+   evas_object_move(d.box, (w / 4), (h / 4));
+   evas_object_resize(d.box, (w / 2), (h / 2));
+
+   evas_object_move(d.border, (w / 4) - 2, (h / 4) - 2);
+   evas_object_resize(d.border, (w / 2) + 4, (h / 2) + 4);
+}
+
+int
+main(void)
+{
+   Evas_Object *last, *o;
+   int i;
+
+   srand(time(NULL));
+
+   if (!ecore_evas_init())
+     return EXIT_FAILURE;
+
+   /* this will give you a window with an Evas canvas under the first
+    * engine available */
+   d.ee = ecore_evas_new(NULL, 0, 0, WIDTH, HEIGHT, NULL);
+   if (!d.ee)
+     goto panic;
+
+   ecore_evas_callback_delete_request_set(d.ee, _on_delete);
+   ecore_evas_callback_resize_set(d.ee, _canvas_resize_cb);
+   ecore_evas_show(d.ee);
+
+   d.evas = ecore_evas_get(d.ee);
+
+   d.bg = evas_object_rectangle_add(d.evas);
+   evas_object_color_set(d.bg, 255, 255, 255, 255); /* white bg */
+   evas_object_show(d.bg);
+
+   evas_object_focus_set(d.bg, EINA_TRUE);
+   evas_object_event_callback_add(
+     d.bg, EVAS_CALLBACK_KEY_DOWN, _on_keydown, NULL);
+
+   d.box = evas_object_box_add(d.evas);
+   evas_object_show(d.box);
+
+   for (i = 1; i <= 5; i++)
+     {
+        o = last = evas_object_rectangle_add(d.evas);
+        evas_object_size_hint_min_set(o, 50, 50);
+        evas_object_color_set(
+          o, rand() % 256, rand() % 256, rand() % 256, 255);
+        evas_object_show(o);
+
+        if (!evas_object_box_append(d.box, o))
+          {
+             fprintf(stderr, "Error appending child object on the box!\n");
+             goto error;
+          }
+     }
+
+   /* this is a border around the box, container of the rectangles we
+    * are going to experiment with. this way you can see how the
+    * container relates to the children */
+   d.border = evas_object_image_filled_add(d.evas);
+   evas_object_image_file_set(d.border, border_img_path, NULL);
+   evas_object_image_border_set(d.border, 2, 2, 2, 2);
+   evas_object_image_border_center_fill_set(d.border, EVAS_BORDER_FILL_NONE);
+   evas_object_show(d.border);
+
+   fprintf(stdout, commands);
+
+   _canvas_resize_cb(d.ee);
+   ecore_main_loop_begin();
+   ecore_evas_shutdown();
+   return 0;
+
+error:
+   ecore_evas_shutdown();
+   return -1;
+
+panic:
+   fprintf(stderr, "You got to have at least one evas engine built and linked"
+                   " up to ecore-evas for this example to run properly.\n");
+   return -2;
+}
+

legacy/evas/src/examples/evas-hints.c

@@ -10,7 +10,7 @@
  * output.
  *
  * @verbatim
- * gcc -o evas-events evas-events.c `pkg-config --libs --cflags ecore-evas edje`
+ * gcc -o evas-events evas-events.c `pkg-config --libs --cflags ecore-evas`
  * @endverbatim
  */
 
@@ -28,6 +28,21 @@
 #define WIDTH  320
 #define HEIGHT 480
 
+static const char commands[] = \
+  "commands are:\n"
+  "\tShift + a - change alignment hints on top rectangle\n"
+  "\tShift + m - change min. size hint on top rectangle\n"
+  "\tShift + n - change max. size hint on top rectangle\n"
+  "\tShift + p - change padding hints on top rectangle\n"
+  "\tShift + w - change weight hints on top rectangle\n\n"
+  "\tControl + a - change alignment hints on bottom rectangle\n"
+  "\tControl + m - change min. size hint on bottom rectangle\n"
+  "\tControl + n - change max. size hint on bottom rectangle\n"
+  "\tControl + p - change padding hints on bottom rectangle\n"
+  "\tControl + w - change weight hints on bottom rectangle\n\n"
+  "\ts - print current hints information\n"
+  "\th - print help\n";
+
 static const char *border_img_path = PACKAGE_EXAMPLES_DIR "/red.png";
 
 struct coord_tuple
@@ -48,10 +63,10 @@ struct padding_tuple
 struct rect_data
 {
    struct coord_tuple   *min_ptr;
-   struct coord_tuple    min[3];
+   struct coord_tuple    min[4];
 
    struct coord_tuple   *max_ptr;
-   struct coord_tuple    max[3];
+   struct coord_tuple    max[4];
 
    struct weight_tuple  *align_ptr;
    struct weight_tuple   align[3];
@@ -82,6 +97,12 @@ _canvas_resize_cb(Ecore_Evas *ee)
 
    ecore_evas_geometry_get(ee, NULL, NULL, &w, &h);
    evas_object_resize(d.bg, w, h);
+
+   evas_object_move(d.box, (w / 4), (h / 4));
+   evas_object_resize(d.box, (w / 2), (h / 2));
+
+   evas_object_move(d.border, (w / 4) - 3, (h / 4) - 3);
+   evas_object_resize(d.border, (w / 2) + 6, (h / 2) + 6);
 }
 
 static void
@@ -136,20 +157,7 @@ _on_keydown(void        *data __UNUSED__,
      }
    else if (strcmp(ev->keyname, "h") == 0) /* print help */
      {
-        fprintf(stdout,
-                "commands are:\n"
-                "\tShift + a - change alignment hints on top rectangle\n"
-                "\tShift + m - change min. size hint on top rectangle\n"
-                "\tShift + n - change max. size hint on top rectangle\n"
-                "\tShift + p - change padding hints on top rectangle\n"
-                "\tShift + w - change weight hints on top rectangle\n\n"
-                "\tControl + a - change alignment hints on bottom rectangle\n"
-                "\tControl + m - change min. size hint on bottom rectangle\n"
-                "\tControl + n - change max. size hint on bottom rectangle\n"
-                "\tControl + p - change padding hints on bottom rectangle\n"
-                "\tControl + w - change weight hints on bottom rectangle\n\n"
-                "\ts - print current hints information\n"
-                "\th - print help\n");
+        fprintf(stdout, commands);
         return;
      }
    else if (strcmp(ev->keyname, "s") == 0) /* get aspect status of the
@@ -174,10 +182,10 @@ _on_keydown(void        *data __UNUSED__,
         if ((unsigned)
             (((void *)(r_data->align_ptr)) - ((void *)(r_data->align))) >=
             sizeof(r_data->align))
-            r_data->align_ptr = r_data->align;
+          r_data->align_ptr = r_data->align;
 
         evas_object_size_hint_align_set(
-            rect, r_data->align_ptr->x, r_data->align_ptr->y);
+          rect, r_data->align_ptr->x, r_data->align_ptr->y);
 
         fprintf(stdout, "Changing align hints for %s rect. to (%f, %f)\n",
                 name, r_data->align_ptr->x, r_data->align_ptr->y);
@@ -191,10 +199,10 @@ _on_keydown(void        *data __UNUSED__,
         if ((unsigned)
             (((void *)(r_data->min_ptr)) - ((void *)(r_data->min))) >=
             sizeof(r_data->min))
-            r_data->min_ptr = r_data->min;
+          r_data->min_ptr = r_data->min;
 
         evas_object_size_hint_min_set(
-            rect, r_data->min_ptr->w, r_data->min_ptr->h);
+          rect, r_data->min_ptr->w, r_data->min_ptr->h);
 
         fprintf(stdout, "Changing min. size hints for %s rect. to (%d, %d)\n",
                 name, r_data->min_ptr->w, r_data->min_ptr->h);
@@ -208,10 +216,10 @@ _on_keydown(void        *data __UNUSED__,
         if ((unsigned)
             (((void *)(r_data->max_ptr)) - ((void *)(r_data->max))) >=
             sizeof(r_data->max))
-            r_data->max_ptr = r_data->max;
+          r_data->max_ptr = r_data->max;
 
         evas_object_size_hint_max_set(
-            rect, r_data->max_ptr->w, r_data->max_ptr->h);
+          rect, r_data->max_ptr->w, r_data->max_ptr->h);
 
         fprintf(stdout, "Changing max. size hints for %s rect. to (%d, %d)\n",
                 name, r_data->max_ptr->w, r_data->max_ptr->h);
@@ -225,14 +233,14 @@ _on_keydown(void        *data __UNUSED__,
         if ((unsigned)
             (((void *)(r_data->padding_ptr)) - ((void *)(r_data->padding))) >=
             sizeof(r_data->padding))
-            r_data->padding_ptr = r_data->padding;
+          r_data->padding_ptr = r_data->padding;
 
         evas_object_size_hint_padding_set(
-            rect, r_data->padding_ptr->l, r_data->padding_ptr->r,
-            r_data->padding_ptr->t, r_data->padding_ptr->b);
+          rect, r_data->padding_ptr->l, r_data->padding_ptr->r,
+          r_data->padding_ptr->t, r_data->padding_ptr->b);
 
         fprintf(stdout, "Changing padding size hints for %s rect."
-                " to (%d, %d, %d, %d)\n",
+                        " to (%d, %d, %d, %d)\n",
                 name, r_data->padding_ptr->l, r_data->padding_ptr->r,
                 r_data->padding_ptr->t, r_data->padding_ptr->b);
         return;
@@ -248,10 +256,10 @@ _on_keydown(void        *data __UNUSED__,
         if ((unsigned)
             (((void *)(r_data->weight_ptr)) - ((void *)(r_data->weight))) >=
             sizeof(r_data->weight))
-            r_data->weight_ptr = r_data->weight;
+          r_data->weight_ptr = r_data->weight;
 
         evas_object_size_hint_weight_set(
-            rect, r_data->weight_ptr->x, r_data->weight_ptr->y);
+          rect, r_data->weight_ptr->x, r_data->weight_ptr->y);
 
         fprintf(stdout, "Changing weight hints for %s rect. to (%f, %f)\n",
                 name, r_data->weight_ptr->x, r_data->weight_ptr->y);
@@ -274,24 +282,26 @@ main(void)
    /* init values one is going to cycle through while running this
     * example */
    struct rect_data init_data = \
-   {.min = {{30, 30}, {100, 70}, {200, 200}},
-    .max = {{100, 100}, {100, 70}, {300, 300}},
-    .align = {{0.0, 0.0}, {0.5, 0.5}, {1.0, 0.5}},
-    .weight = {{0.0, 0.0}, {3, 6}, {10, 100}},
-    .padding = {{0, 0, 0, 0}, {3, 6, 9, 12}, {10, 20, 0, 30}}};
+   {
+      .min = {{0, 0}, {30, 30}, {100, 70}, {200, 200}},
+      .max = {{0, 0}, {100, 100}, {100, 70}, {300, 300}},
+      .align = {{0.0, 0.0}, {0.5, 0.5}, {1.0, 0.5}},
+      .weight = {{0.0, 0.0}, {3, 6}, {10, 100}},
+      .padding = {{0, 0, 0, 0}, {3, 6, 9, 12}, {10, 20, 0, 30}}
+   };
 
    d.t_data = init_data;
 
-   d.t_data.min_ptr = d.t_data.min;
-   d.t_data.max_ptr = d.t_data.max;
+   d.t_data.min_ptr = d.t_data.min + 1;
+   d.t_data.max_ptr = d.t_data.max + 1;
    d.t_data.align_ptr = d.t_data.align;
    d.t_data.weight_ptr = d.t_data.weight;
    d.t_data.padding_ptr = d.t_data.padding;
 
    d.b_data = init_data;
 
-   d.b_data.min_ptr = d.b_data.min;
-   d.b_data.max_ptr = d.b_data.max;
+   d.b_data.min_ptr = d.b_data.min + 1;
+   d.b_data.max_ptr = d.b_data.max + 1;
    d.b_data.align_ptr = d.b_data.align;
    d.b_data.weight_ptr = d.b_data.weight;
    d.b_data.padding_ptr = d.b_data.padding;
@@ -319,12 +329,10 @@ main(void)
    evas_object_event_callback_add(
      d.bg, EVAS_CALLBACK_KEY_DOWN, _on_keydown, NULL);
 
-   /* Evas box with horizontal layout */
+   /* Evas box with vertical layout */
    d.box = evas_object_box_add(d.canvas);
    evas_object_box_layout_set(
      d.box, evas_object_box_layout_vertical, NULL, NULL);
-   evas_object_move(d.box, (WIDTH / 4), (HEIGHT / 4));
-   evas_object_resize(d.box, (WIDTH / 2), (HEIGHT / 2));
    evas_object_show(d.box);
 
    /* this is a border around the box, container of the rectangles we
@@ -334,31 +342,33 @@ main(void)
    evas_object_image_file_set(d.border, border_img_path, NULL);
    evas_object_image_border_set(d.border, 3, 3, 3, 3);
    evas_object_image_border_center_fill_set(d.border, EVAS_BORDER_FILL_NONE);
-   evas_object_move(d.border, (WIDTH / 4) - 3, (HEIGHT / 4) - 3);
-   evas_object_resize(d.border, (WIDTH / 2) + 6, (HEIGHT / 2) + 6);
    evas_object_show(d.border);
 
    d.t_rect = evas_object_rectangle_add(d.canvas);
    evas_object_color_set(d.t_rect, 0, 0, 255, 255);
 
-   evas_object_size_hint_min_set(d.t_rect, 100, 100);
+   evas_object_size_hint_min_set(
+          d.t_rect, d.t_data.min_ptr->w, d.t_data.min_ptr->h);
    evas_object_show(d.t_rect);
    evas_object_box_append(d.box, d.t_rect);
 
    d.b_rect = evas_object_rectangle_add(d.canvas);
    evas_object_color_set(d.b_rect, 0, 255, 0, 255);
 
-   evas_object_size_hint_min_set(d.b_rect, 100, 100);
+   evas_object_size_hint_min_set(
+          d.b_rect, d.b_data.min_ptr->w, d.b_data.min_ptr->h);
    evas_object_show(d.b_rect);
    evas_object_box_append(d.box, d.b_rect);
 
-   ecore_main_loop_begin();
+   _canvas_resize_cb(d.ee);
 
+   fprintf(stdout, commands);
+   ecore_main_loop_begin();
    ecore_evas_shutdown();
    return 0;
 
 error:
-   fprintf(stderr, "you got to have at least one evas engine built and linked"
+   fprintf(stderr, "You got to have at least one evas engine built and linked"
                    " up to ecore-evas for this example to run properly.\n");
    return -1;
 }

legacy/evas/src/lib/Evas.h

@@ -9536,6 +9536,10 @@ EAPI const Evas_Smart_Class *evas_object_smart_clipped_class_get     (void) EINA
  * in Evas</b>, all of them using children size hints to define their
  * size and alignment inside their cell space.
  *
+ * Examples on this smart object's usage:
+ * - @ref Example_Evas_Box
+ * - @ref Example_Evas_Size_Hints
+ *
  * @see @ref Evas_Object_Group_Size_Hints
  *
  * @ingroup Evas_Smart_Object_Group