Icon Example with C++ binding

This example is as simple as possible. An icon object will be added to the window over a blank background, and set to be resizable together with the window. All the options set through the example will affect the behavior of this icon.

The first part consists of including the headers. In this case we are only working with the Elementary C++ binding and thus we need only to include him.

#include <Elementary.hh>

Attention
If necessary the C and/or the C++ headers should be include here as well.

Now we need to actually start the code and set the elm_policy, which defines for a given policy group/identifier a new policy's value, respectively. In this example the only policy we need to set a value for is ELM_POLICY_QUIT, possibles values for it are:

EAPI_MAIN int
elm_main (int argc, char *argv[])
{
elm_policy_set(ELM_POLICY_QUIT, ELM_POLICY_QUIT_LAST_WINDOW_HIDDEN);

As you can see, the policy we chose was to quit when the last win is hidden as opose to examples with the C bindings where we perpetually set it to quit when last win was closed. This changed was necessary because in C++ binding as the elm mainloop stop running all object are destroyed, references are unreferenced and events are stopped at ELM_MAIN().

See also
For more details consult elm_policy_set

Next step is creating an elementary window, in this example we use the C++ binding method with the elm_win_util_standard_add that is a elm_win_legacy function, better explained below. And then we set the autohide state for it.

elm_win_util_standard_add (const char *name, const char *tittle) Adds a window object with standard setup. Parameters:

This creates a window but also puts in a standard background with elm_bg_add(), as well as setting the window title to title. The window type created is of type ELM_WIN_BASIC, with the NULL as the parent widget. Returns the created object or NULL on failure.

The autohide works similarly to autodel, automatically handling "delete,request" signals when set to true, with the difference that it will hide the window, instead of destroying it.

It is specially designed to work together with ELM_POLICY_QUIT_LAST_WINDOW_HIDDEN which allows exiting Elementary's main loop when all the windows are hidden.

::elm::win win(elm_win_util_standard_add("icon", "Icon"));
win.autohide_set(true);

Note
autodel and autohide are not mutually exclusive. The window will be destructed if both autodel and autohide is set to EINA_TRUE or true.

Now we construct the elm icon and for this we use the C++ method below, setting it's parent. An icon object is used to display standard icon images ("delete", "edit", "arrows", etc.) or images coming from a custom file (PNG, JPG, EDJE, etc.), on icon contexts.

::elm::icon icon(efl::eo::parent = win);

The icon image requested can be in the Elementary theme in use, or in the freedesktop.org theme paths. It's possible to set the order of preference from where an image will be fetched and for that we'll use the function @ order_lookup_set(order_) that will be use by standard_set. Possibles values for order_ are:

icon.order_lookup_set(ELM_ICON_LOOKUP_THEME_FDO);

Now that we setted the order value we can set the standard "home" icon, chosen for this example.

icon.standard_set("home");

An interesting thing is that after setting this, it's possible to check where in the filesystem is the theme used by this icon, and the name of the group used, using file_get.

icon.file_get(&path, &group);
std::cout << "path = " << path << ", group = "<< group;

We can also get the name of the standard icon that we setted before.

efl::eina::optional<std::string> name;
name = icon.standard_get();
std::cout << ", name = " << *name << std::endl;

We can now go setting our options.

no_scale_set() is used just to set this value to true as we don't actually want to scale our icon, just resize it.

resizable_set() is used to allow the icon to be resized to a size smaller than the original one, but not to a size bigger than it.

smooth_set() will disable the smooth scaling, so the scale algorithm used to scale the icon to the new object size is going to be faster, but with a lower quality.

fill_outside_set() is used to ensure that the icon will fill the entire area available to it, even if keeping the aspect ratio. The icon will overflow its width or height (any of them that is necessary) to the object area, instead of resizing the icon down until it can fit entirely in this area.

This is the code for setting these options:

icon.no_scale_set(true);
icon.resizable_set(false, true);
icon.smooth_set(false);
icon.fill_outside_set(true);

However, if you try this example you may notice that this image is not being affected by all of these options. This happens because the used icon will be from elementary theme, and thus it has its own set of options like smooth scaling and fill_outside options. You can change the "home" icon to use some image (from your system) and see that then those options will be respected.

To better understand, the function size_hint_weight_set for C++ bindings originated from C bindings function evas_object_size_hint_weight_set, that is EFL Evas type function. With this function we set the hints for an object's weight. The parameters are:

This is not a size enforcement in any way, it's just a hint that should be used whenever appropriate.

This is a hint on how a container object should resize a given child within its area.

Containers may adhere to the simpler logic of just expanding the child object's dimensions to fit its own (see the EVAS_HINT_EXPAND helper weight macro in the EFL Evas Documentation) or the complete one of taking each child's weight hint as real weights to how much of its size to allocate for them in each axis. A container is supposed to, after normalizing the weights of its children (with weight hints), distribute the space it has to layout them by those factors – most weighted children get larger in this process than the least ones.

icon.size_hint_weight_set(EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);

Note
Default weight hint values are 0.0, for both axis.

Now we add the icon as a resize_object to win informing that when the size of the win changes so should the icon's size. And finally we make icon visible.

Now we set the size for the window, making it visible in the end:

Finally we just have to start the elm mainloop, starting to handle events and drawing operations.

The full code for this example can be found at icon_cxx_example_01.cc

This example will look like this:

icon_cxx_example_01.png