Separator with C++ Binding

Separator is a very thin object used to separate other objects, wich can be vertical or horizontal.

This example shows how to create a window and separate in two parts, each one will be filled with a background color to show the division. The separator is used to visually mark the division between two parts.

The first part consists of including the headers. In this case we are only working with the Elementary and Evas C++ bindings.

#include <Elementary.hh>
#include <Evas.hh>

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:

elm_main (int argc, char *argv[])

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 at ELM_MAIN() because of this. ??

See also

Next step is creating an Elementary window, where win calls a constructor and sets the type of the win to ELM_WIN_BASIC (Elm_Win_Type), which is the indicated type for most of our examples. Here we also set the title that will appear at the top of our window and then the autohide state for it.

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.


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 let's create the background with the C++ binding method, passing our window as parent.

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

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.

bg.size_hint_weight_set(EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);

Default weight hint values are 0.0, for both axis.

Now we add the background as a resize-object to win informing that when the size of the win changes so should the background's size and setting it's visibility. You can change the background's color using color_set, if not, the default color will be used.

To put a box in the window we also need to set it's parent. By default, box object arranges their contents vertically from top to bottom. By calling this function with horizontal as true, the box will become horizontal, arranging contents from left to right.

The value that we set EFL Evas function size_hint_weight_set expands the box to cover all win's area and adding it as a resize_object to win informing that when the size of the win changes so should the box's size. In the end we make the box visible.

Now we create a retangle, like before, we just need to setting it's parent. After created, we set the color to show the difference between the next rectangle and define the minimun size of each side by using size_hint_min_set(minimum width, minimum height).

As in the background, the value we set EFL Evas function size_hint_weight_set expands the background to cover all area defined in size_hint_min_set. We also need to expand the rectangle to fill the area if the win's size change, if not, win can change it's size and the rectangle will only fill it's own previous area.

The function size_hint_align_set for C++ bindings originated from C bindings function evas_object_size_hint_align_set, that is EFL Evas type function. With this function we set the hints for an object's alignment. The parameters are:

These are hints on how to align an object inside the boundaries of a container/manager. Accepted values are in the 0.0 to 1.0 range, with the special value EVAS_HINT_FILL used to specify "justify" or "fill" by some users. In this case, maximum size hints should be enforced with higher priority, if they are set. Also, any padding hint set on objects should add up to the alignment space on the final scene composition.

For the horizontal component, 0.0 means to the left, 1.0 means to the right. Analogously, for the vertical component, 0.0 to the top, 1.0 means to the bottom.

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

Default alignment hint values are 0.5, for both axis.

Now we only need to set the visibility of the rectangle and add our retangle to box with the packing method of the subobj - rectangle in this case. There are four possible methods:

In this and most examples we use pack_end by choice and practicality. In this part of the code we also make rectangle visible.

Once we have our first rectangle in the box we create and add our separator. Using the same approach, we setting it's parent. Since our box is in horizontal mode it's a good idea to set the separator to be horizontal too. Finishing with the visibility and packing method.

After all this, we just need to create another rectangle, setting the color, size hints, make rect2 visible and packing in the box. Don't forget to set the win's visibility as true.

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 .

This example will look like: