efl

1
#ifdef HAVE_CONFIG_H
2
# include "elementary_config.h"
3
#endif
4
#include <Efl_Ui.h>
5
#include <Elementary.h>
6

7
#define TABLE_SIZE 10
8

9
static const char *images[] = { "plant_01.jpg", "rock_01.jpg",
10
                                "rock_02.jpg", "sky_01.jpg", "sky_04.jpg",
11
                                "wood_01.jpg", "fire.gif" };
12

13
static const int rnd[] = {
14
   3, 86, 81, 36, 38, 8, 65, 53, 93, 40, 71, 74, 90, 95, 88, 4, 96, 73, 14, 52,
15
   83, 77, 51, 13, 79, 15, 59, 99, 100, 31, 27, 24, 97, 34, 28, 58, 84, 92, 18,
16
   50, 22, 62, 12, 7, 17, 56, 2, 47, 75, 85, 42, 89, 80, 57, 44, 49, 5, 45, 54,
17
   68, 76, 70, 11, 69, 64, 30, 55, 29, 39, 60, 82, 63, 94, 43, 19, 26, 35, 21,
18
   67, 91, 46, 72, 33, 87, 10, 9, 41, 66, 37, 32, 78, 20, 23, 48, 6, 1, 25, 16,
19
   61, 98,
20
};
21

22
static const char *filter =
23
      "padding_set {0}"
24
      "fill { color = 'red' }"
25
      "blur { radius }"
26
      "print ('Evaluating filter: ' .. input.width .. 'x' .. input.height)"
27
      ;
28

29
static inline Eo *
30
_image_create(Eo *win, const char *path)
31
{
32
   return efl_add(EFL_UI_IMAGE_CLASS, win,
33
                  efl_file_set(efl_added, path),
34
                  efl_file_load(efl_added),
35
                  efl_gfx_hint_size_min_set(efl_added, EINA_SIZE2D(20, 20)));
36
}
37

38
static void
39
_anim_toggle(void *data, const Efl_Event *ev EINA_UNUSED)
40
{
41
   Eina_Iterator *it;
42
   Eo *win = data;
43
   Eo *table, *o;
44

45
   table = efl_key_wref_get(win, "table");
46
   it = efl_content_iterate(table);
47
   EINA_ITERATOR_FOREACH(it, o)
48
     {
49
        if (efl_isa(o, EFL_PLAYER_INTERFACE) && efl_playable_get(o))
50
          {
51
             if (!efl_player_playing_get(o))
52
               efl_player_playing_set(o, EINA_TRUE);
53
             efl_player_paused_set(o, !efl_player_paused_get(o));
54
          }
55
     }
56
   eina_iterator_free(it);
57
}
58

59
static void
60
_render_post(void *data, const Efl_Event *ev)
61
{
62
   Eo *snap = data;
63

64
   efl_event_callback_del(ev->object, EFL_CANVAS_SCENE_EVENT_RENDER_POST, _render_post, data);
65
   efl_file_save(snap, eina_slstr_printf("%s/snap-efl.png", eina_environment_tmp_get()), NULL, NULL);
66
}
67

68
static void
69
_save_image(void *data, const Efl_Event *ev EINA_UNUSED)
70
{
71
   Eo *win = data;
72
   Eo *snap;
73

74
   // Save is available only during render_post
75
   snap = efl_key_wref_get(win, "snap");
76
   efl_event_callback_add(win, EFL_CANVAS_SCENE_EVENT_RENDER_POST, _render_post, snap);
77

78
   // Force a render in order to ensure post_render is called. EO API provides
79
   // no way to do manual render, so we add a damage to the snapshot object.
80
   // This is a special case handled by snapshot for the purpose of taking
81
   // screenshots like this. This is useful only if the button click has no
82
   // animation on screen and there is no spinning wheel either.
83
   efl_gfx_buffer_update_add(snap, NULL);
84
}
85

86
static void
87
_radius_set(void *data, const Efl_Event *ev)
88
{
89
   char buf[128];
90
   Eo *win = data;
91
   Eo *snap;
92

93
   snap = efl_key_wref_get(win, "snap");
94
   sprintf(buf, "tonumber(%d)", (int) elm_slider_value_get(ev->object));
95
   efl_gfx_filter_data_set(snap, "radius", buf, EINA_TRUE);
96
}
97

98
static void
99
_close_do(void *data, const Efl_Event *ev EINA_UNUSED)
100
{
101
   Eo *win = data;
102

103
   efl_del(win);
104
}
105

106
static void
107
_toggle_map(void *data, const Efl_Event *ev EINA_UNUSED)
108
{
109
   Eo *win = data;
110
   Eo *snap;
111

112
   snap = efl_key_wref_get(win, "snap");
113
   if (!efl_gfx_mapping_has(snap))
114
     {
115
        efl_gfx_mapping_zoom(snap, 0.8, 0.8, NULL, 0.5, 0.5);
116
        efl_gfx_mapping_rotate(snap, 20.0, NULL, 0.5, 0.5);
117
     }
118
   else efl_gfx_mapping_reset(snap);
119
}
120

121
void
122
test_evas_snapshot(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
123
{
124
   Eo *win, *table, *o, *snap, *box;
125
   const char *path;
126

127
   win = efl_add(EFL_UI_WIN_CLASS, efl_main_loop_get(),
128
                 efl_text_set(efl_added, "Evas Snapshot"),
129
                 efl_ui_win_autodel_set(efl_added, 1));
130

131
   table = efl_add(EFL_UI_TABLE_CLASS, win,
132
                  efl_gfx_arrangement_content_padding_set(efl_added, 5, 5));
133
   efl_content_set(win, table);
134

135
   // Objects below the snapshot
136
   for (int c = 0; c < TABLE_SIZE; c++)
137
     for (int r = 0; r < TABLE_SIZE; r++)
138
       {
139
          int id = rnd[((r * TABLE_SIZE) + c) % EINA_C_ARRAY_LENGTH(rnd)]
140
                % EINA_C_ARRAY_LENGTH(images);
141

142
          path = eina_slstr_printf("%s/images/%s", elm_app_data_dir_get(), images[id]);
143
          o = _image_create(win, path);
144
          efl_pack_table(table, o, r, c, 1, 1);
145
       }
146
   _anim_toggle(win, NULL);
147

148
   // Snapshot
149
   snap = efl_add(EFL_CANVAS_SNAPSHOT_CLASS, win,
150
                  efl_gfx_filter_program_set(efl_added, filter, "filter"),
151
                  efl_gfx_filter_data_set(efl_added, "radius", "tonumber(5)", EINA_TRUE),
152
                  efl_pack_table(table, efl_added, 1, 1, TABLE_SIZE - 2, TABLE_SIZE - 2));
153

154
   // Objects above snapshot
155
   // 1. Opaque rect, not changing
156
   o = evas_object_rectangle_add(win);
157
   evas_object_color_set(o, 32, 32, 96, 255);
158
   evas_object_size_hint_align_set(o, EVAS_HINT_FILL, EVAS_HINT_FILL);
159
   efl_pack_table(table, o, 2, TABLE_SIZE / 2, TABLE_SIZE - 4, TABLE_SIZE / 2 - 2);
160
   evas_object_show(o);
161

162
   // 2. Non-opaque animated object
163
   o = elm_progressbar_add(win);
164
   elm_object_style_set(o, "wheel");
165
   evas_object_size_hint_weight_set(o, 0.0, 0.0);
166
   evas_object_size_hint_align_set(o, 0.5, 0.5);
167
   elm_progressbar_pulse_set(o, EINA_TRUE);
168
   elm_progressbar_pulse(o, EINA_TRUE);
169
   evas_object_show(o);
170
   efl_pack_table(table, o, 0, 0, TABLE_SIZE, TABLE_SIZE);
171

172
   // Controls
173
   efl_add(EFL_UI_SLIDER_CLASS, win,
174
           elm_object_text_set(efl_added, "Blur radius: "),
175
           elm_slider_min_max_set(efl_added, 0, 64),
176
           elm_slider_value_set(efl_added, 5),
177
           elm_slider_unit_format_set(efl_added, "%.0f px"),
178
           efl_gfx_hint_weight_set(efl_added, 1.0, 0.0),
179
           efl_pack_table(table, efl_added, 0, TABLE_SIZE, TABLE_SIZE, 1),
180
           efl_event_callback_add(efl_added, EFL_UI_RANGE_EVENT_CHANGED, _radius_set, win));
181

182
   box = efl_add(EFL_UI_BOX_CLASS, win,
183
                 efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL),
184
                 efl_gfx_hint_fill_set(efl_added, EINA_TRUE, EINA_TRUE),
185
                 efl_pack_table(table, efl_added, 0, TABLE_SIZE + 1, TABLE_SIZE, 1));
186

187
   efl_add(EFL_UI_BUTTON_CLASS, win,
188
           efl_text_set(efl_added, "Toggle animation"),
189
           efl_gfx_hint_weight_set(efl_added, 1.0, 0.0),
190
           efl_pack(box, efl_added),
191
           efl_event_callback_add(efl_added, EFL_INPUT_EVENT_CLICKED, _anim_toggle, win));
192

193
   efl_add(EFL_UI_BUTTON_CLASS, win,
194
           efl_text_set(efl_added, "Save to file"),
195
           efl_gfx_hint_weight_set(efl_added, 1.0, 0.0),
196
           efl_pack(box, efl_added),
197
           efl_event_callback_add(efl_added, EFL_INPUT_EVENT_CLICKED, _save_image, win));
198

199
   efl_add(EFL_UI_BUTTON_CLASS, win,
200
           efl_text_set(efl_added, "Map"),
201
           efl_gfx_hint_weight_set(efl_added, 1.0, 0.0),
202
           efl_pack(box, efl_added),
203
           efl_event_callback_add(efl_added, EFL_INPUT_EVENT_CLICKED, _toggle_map, win));
204

205
   efl_add(EFL_UI_BUTTON_CLASS, win,
206
           efl_text_set(efl_added, "Close"),
207
           efl_gfx_hint_weight_set(efl_added, 1.0, 0.0),
208
           efl_pack(box, efl_added),
209
           efl_event_callback_add(efl_added, EFL_INPUT_EVENT_CLICKED, _close_do, win));
210

211
   efl_key_wref_set(win, "snap", snap);
212
   efl_key_wref_set(win, "table", table);
213
   efl_gfx_entity_size_set(win, EINA_SIZE2D(400,  400));
214
}
215