1 /* Legacy API implementations based on internal EO calls */
2
3 #include "edje_private.h"
4 #include "edje_part_helper.h"
5
6 #define GET_REAL_PART_ON_FAIL_RETURN(x) Edje_Real_Part *rp;\
7 Edje *ed;\
8 if (!part) return x;\
9 ed = _edje_fetch(obj);\
10 if (!ed) return x;\
11 rp = _edje_real_part_recursive_get(&ed, part);\
12 if (!rp) return x;\
13
14 EAPI Edje_Load_Error
edje_object_load_error_get(const Eo * obj)15 edje_object_load_error_get(const Eo *obj)
16 {
17 Edje *ed;
18
19 ed = _edje_fetch(obj);
20 if (!ed) return EDJE_LOAD_ERROR_GENERIC;
21 return ed->load_error;
22 }
23
24 EAPI Eina_Bool
edje_object_part_geometry_get(const Edje_Object * obj,const char * part,int * x,int * y,int * w,int * h)25 edje_object_part_geometry_get(const Edje_Object *obj, const char *part, int *x, int *y, int *w, int *h)
26 {
27 Edje_Real_Part *rp;
28 Edje *ed;
29 EINA_SAFETY_ON_NULL_RETURN_VAL(part, EINA_FALSE);
30
31 // Similar to geometry_get(efl_part(obj, part), x, y, w, h) but the bool
32 // return value matters here.
33
34 ed = _edje_fetch(obj);
35 if (!ed)
36 {
37 if (x) *x = 0;
38 if (y) *y = 0;
39 if (w) *w = 0;
40 if (h) *h = 0;
41 return EINA_FALSE;
42 }
43
44 /* Need to recalc before providing the object. */
45 _edje_recalc_do(ed);
46
47 rp = _edje_real_part_recursive_get(&ed, part);
48 if (!rp)
49 {
50 if (x) *x = 0;
51 if (y) *y = 0;
52 if (w) *w = 0;
53 if (h) *h = 0;
54 return EINA_FALSE;
55 }
56 if (x) *x = rp->x;
57 if (y) *y = rp->y;
58 if (w) *w = rp->w;
59 if (h) *h = rp->h;
60 return EINA_TRUE;
61 }
62
63 EAPI const char *
edje_object_part_state_get(const Edje_Object * obj,const char * part,double * val_ret)64 edje_object_part_state_get(const Edje_Object *obj, const char * part, double *val_ret)
65 {
66 const char *str = "";
67 efl_canvas_layout_part_state_get(efl_part(obj, part), &str, val_ret);
68 return str;
69 }
70
71 EAPI void
edje_object_message_signal_process(Edje_Object * obj)72 edje_object_message_signal_process(Edje_Object *obj)
73 {
74 efl_layout_signal_process(obj, EINA_FALSE);
75 }
76
77 /* since 1.20 */
78 EAPI void
edje_object_message_signal_recursive_process(Edje_Object * obj)79 edje_object_message_signal_recursive_process(Edje_Object *obj)
80 {
81 efl_layout_signal_process(obj, EINA_TRUE);
82 }
83
84 EAPI void
edje_object_signal_callback_add(Evas_Object * obj,const char * emission,const char * source,Edje_Signal_Cb func,void * data)85 edje_object_signal_callback_add(Evas_Object *obj, const char *emission, const char *source, Edje_Signal_Cb func, void *data)
86 {
87 Edje *ed;
88
89 ed = _edje_fetch(obj);
90 if (!ed || ed->delete_me) return;
91 _edje_object_signal_callback_add(obj, ed, emission, source, func, NULL, NULL, data);
92 }
93
94 EAPI void *
edje_object_signal_callback_del_full(Evas_Object * obj,const char * emission,const char * source,Edje_Signal_Cb func,void * data)95 edje_object_signal_callback_del_full(Evas_Object *obj, const char *emission, const char *source, Edje_Signal_Cb func, void *data)
96 {
97 Edje_Signal_Callback_Group *gp;
98 Edje *ed = _edje_fetch(obj);
99 Eina_Bool ok;
100
101 if (!ed || ed->delete_me) return NULL;
102
103 gp = (Edje_Signal_Callback_Group *) ed->callbacks;
104 if (!gp) return NULL;
105
106 emission = eina_stringshare_add(emission);
107 source = eina_stringshare_add(source);
108
109 // We can cast here as the function won't be used and is just going to be used for comparison
110 ok = _edje_signal_callback_disable(gp, emission, source, func, NULL, NULL, data);
111
112 // Legacy only
113 if (!ok && !data)
114 {
115 for (unsigned i = 0; i < gp->matches->matches_count; ++i)
116 {
117 if (emission == gp->matches->matches[i].signal &&
118 source == gp->matches->matches[i].source &&
119 func == gp->matches->matches[i].legacy &&
120 gp->flags[i].legacy &&
121 !gp->flags[i].delete_me)
122 {
123 gp->flags[i].delete_me = EINA_TRUE;
124 //return gp->custom_data[i];
125 break;
126 }
127 }
128 }
129
130 eina_stringshare_del(emission);
131 eina_stringshare_del(source);
132
133 // Note: This function seems to have returned NULL since ~2013, despite
134 // what the documentation says.
135 return NULL;
136 }
137
138 EAPI void *
edje_object_signal_callback_del(Evas_Object * obj,const char * emission,const char * source,Edje_Signal_Cb func)139 edje_object_signal_callback_del(Evas_Object *obj, const char *emission, const char *source, Edje_Signal_Cb func)
140 {
141 // Legacy del_full seems to have been sloppy with NULL data, as that would
142 // match the first callback found. Keeping this legacy behaviour unchanged.
143 return edje_object_signal_callback_del_full(obj, emission, source, func, NULL);
144 }
145
146 EAPI void
edje_object_signal_emit(Evas_Object * obj,const char * emission,const char * source)147 edje_object_signal_emit(Evas_Object *obj, const char *emission, const char *source)
148 {
149 efl_layout_signal_emit(obj, emission, source);
150 }
151
152 EAPI Eina_Bool
edje_object_part_external_param_set(Eo * obj,const char * part,const Edje_External_Param * param)153 edje_object_part_external_param_set(Eo *obj, const char *part, const Edje_External_Param *param)
154 {
155 Edje *ed = _edje_fetch(obj);
156 return _edje_object_part_external_param_set(ed, part, param);
157 }
158
159 EAPI Eina_Bool
edje_object_part_external_param_get(const Eo * obj,const char * part,Edje_External_Param * param)160 edje_object_part_external_param_get(const Eo *obj, const char *part, Edje_External_Param *param)
161 {
162 Edje *ed = _edje_fetch(obj);
163 return _edje_object_part_external_param_get(ed, part, param);
164 }
165
166 EAPI Edje_External_Param_Type
edje_object_part_external_param_type_get(const Eo * obj,const char * part,const char * param)167 edje_object_part_external_param_type_get(const Eo *obj, const char *part, const char *param)
168 {
169 Edje *ed = _edje_fetch(obj);
170 return _edje_object_part_external_param_type_get(ed, part, param);
171 }
172
173 EAPI Evas_Object *
edje_object_part_external_object_get(const Edje_Object * obj,const char * part)174 edje_object_part_external_object_get(const Edje_Object *obj, const char *part)
175 {
176 return efl_content_get(efl_part(obj, part));
177 }
178
179 /* Legacy only. Shall we deprecate this API? */
180 EAPI Evas_Object *
edje_object_part_external_content_get(const Edje_Object * obj,const char * part,const char * content)181 edje_object_part_external_content_get(const Edje_Object *obj, const char *part, const char *content)
182 {
183 Edje *ed = _edje_fetch(obj);
184 return _edje_object_part_external_content_get(ed, part, content);
185 }
186
187 /* Efl.Ui.I18n APIs */
188 EAPI void
edje_object_mirrored_set(Edje_Object * obj,Eina_Bool rtl)189 edje_object_mirrored_set(Edje_Object *obj, Eina_Bool rtl)
190 {
191 efl_ui_mirrored_set(obj, rtl);
192 }
193
edje_object_mirrored_get(const Edje_Object * obj)194 EAPI Eina_Bool edje_object_mirrored_get(const Edje_Object *obj)
195 {
196 return efl_ui_mirrored_get(obj);
197 }
198
edje_object_language_set(Edje_Object * obj,const char * language)199 EAPI void edje_object_language_set(Edje_Object *obj, const char *language)
200 {
201 efl_ui_language_set(obj, language);
202 }
203
edje_object_language_get(const Edje_Object * obj)204 EAPI const char *edje_object_language_get(const Edje_Object *obj)
205 {
206 return efl_ui_language_get(obj);
207 }
208
edje_object_scale_set(Edje_Object * obj,double scale)209 EAPI Eina_Bool edje_object_scale_set(Edje_Object *obj, double scale)
210 {
211 efl_gfx_entity_scale_set(obj, scale);
212 return EINA_TRUE;
213 }
214
edje_object_scale_get(const Edje_Object * obj)215 EAPI double edje_object_scale_get(const Edje_Object *obj)
216 {
217 return efl_gfx_entity_scale_get(obj);
218 }
219
220 /* Legacy part drag APIs */
221 EAPI Edje_Drag_Dir
edje_object_part_drag_dir_get(const Evas_Object * obj,const char * part)222 edje_object_part_drag_dir_get(const Evas_Object *obj, const char *part)
223 {
224 return (Edje_Drag_Dir)efl_ui_drag_dir_get(efl_part(obj, part));
225 }
226
227 EAPI Eina_Bool
edje_object_part_drag_value_set(Evas_Object * obj,const char * part,double dx,double dy)228 edje_object_part_drag_value_set(Evas_Object *obj, const char *part, double dx, double dy)
229 {
230 return efl_ui_drag_value_set(efl_part(obj, part), dx, dy);
231 }
232
233 EAPI Eina_Bool
edje_object_part_drag_value_get(const Evas_Object * obj,const char * part,double * dx,double * dy)234 edje_object_part_drag_value_get(const Evas_Object *obj, const char *part, double *dx, double *dy)
235 {
236 return efl_ui_drag_value_get(efl_part(obj, part), dx, dy);
237 }
238
239 EAPI Eina_Bool
edje_object_part_drag_size_set(Evas_Object * obj,const char * part,double dw,double dh)240 edje_object_part_drag_size_set(Evas_Object *obj, const char *part, double dw, double dh)
241 {
242 return efl_ui_drag_size_set(efl_part(obj, part), dw, dh);
243 }
244
245 EAPI Eina_Bool
edje_object_part_drag_size_get(const Evas_Object * obj,const char * part,double * dw,double * dh)246 edje_object_part_drag_size_get(const Evas_Object *obj, const char *part, double *dw, double *dh)
247 {
248 return efl_ui_drag_size_get(efl_part(obj, part), dw, dh);
249 }
250
251 EAPI Eina_Bool
edje_object_part_drag_step_set(Evas_Object * obj,const char * part,double dx,double dy)252 edje_object_part_drag_step_set(Evas_Object *obj, const char *part, double dx, double dy)
253 {
254 return efl_ui_drag_step_set(efl_part(obj, part), dx, dy);
255 }
256
257 EAPI Eina_Bool
edje_object_part_drag_step_get(const Evas_Object * obj,const char * part,double * dx,double * dy)258 edje_object_part_drag_step_get(const Evas_Object *obj, const char *part, double *dx, double *dy)
259 {
260 return efl_ui_drag_step_get(efl_part(obj, part), dx, dy);
261 }
262
263 EAPI Eina_Bool
edje_object_part_drag_page_set(Evas_Object * obj,const char * part,double dx,double dy)264 edje_object_part_drag_page_set(Evas_Object *obj, const char *part, double dx, double dy)
265 {
266 return efl_ui_drag_page_set(efl_part(obj, part), dx, dy);
267 }
268
269 EAPI Eina_Bool
edje_object_part_drag_page_get(const Evas_Object * obj,const char * part,double * dx,double * dy)270 edje_object_part_drag_page_get(const Evas_Object *obj, const char *part, double *dx, double *dy)
271 {
272 return efl_ui_drag_page_get(efl_part(obj, part), dx, dy);
273 }
274
275 EAPI Eina_Bool
edje_object_part_drag_step(Evas_Object * obj,const char * part,double dx,double dy)276 edje_object_part_drag_step(Evas_Object *obj, const char *part, double dx, double dy)
277 {
278 return efl_ui_drag_step_move(efl_part(obj, part), dx, dy);
279 }
280
281 EAPI Eina_Bool
edje_object_part_drag_page(Evas_Object * obj,const char * part,double dx,double dy)282 edje_object_part_drag_page(Evas_Object *obj, const char *part, double dx, double dy)
283 {
284 return efl_ui_drag_page_move(efl_part(obj, part), dx, dy);
285 }
286
287 EAPI void
edje_object_part_text_cursor_begin_set(Edje_Object * obj,const char * part EINA_UNUSED,Edje_Cursor cur)288 edje_object_part_text_cursor_begin_set(Edje_Object *obj, const char *part EINA_UNUSED, Edje_Cursor cur)
289 {
290 GET_REAL_PART_ON_FAIL_RETURN()
291 _edje_text_cursor_begin(rp, _edje_text_cursor_get(rp, cur));
292 }
293
294 EAPI void
edje_object_part_text_cursor_end_set(Edje_Object * obj,const char * part EINA_UNUSED,Edje_Cursor cur)295 edje_object_part_text_cursor_end_set(Edje_Object *obj, const char *part EINA_UNUSED, Edje_Cursor cur)
296 {
297 GET_REAL_PART_ON_FAIL_RETURN()
298 _edje_text_cursor_end(rp, _edje_text_cursor_get(rp, cur));
299 }
300
301 EAPI void
edje_object_part_text_cursor_pos_set(Edje_Object * obj,const char * part EINA_UNUSED,Edje_Cursor cur,int pos)302 edje_object_part_text_cursor_pos_set(Edje_Object *obj, const char * part EINA_UNUSED, Edje_Cursor cur, int pos)
303 {
304 GET_REAL_PART_ON_FAIL_RETURN()
305 _edje_text_cursor_pos_set(rp, _edje_text_cursor_get(rp, cur), pos);
306 }
307
308 EAPI int
edje_object_part_text_cursor_pos_get(const Edje_Object * obj,const char * part EINA_UNUSED,Edje_Cursor cur)309 edje_object_part_text_cursor_pos_get(const Edje_Object *obj, const char * part EINA_UNUSED, Edje_Cursor cur)
310 {
311 GET_REAL_PART_ON_FAIL_RETURN(0)
312 return _edje_text_cursor_pos_get(rp, _edje_text_cursor_get(rp, cur));
313 }
314
315 EAPI Eina_Bool
edje_object_part_text_cursor_coord_set(Edje_Object * obj,const char * part EINA_UNUSED,Edje_Cursor cur,int x,int y)316 edje_object_part_text_cursor_coord_set(Edje_Object *obj, const char *part EINA_UNUSED, Edje_Cursor cur, int x, int y)
317 {
318 GET_REAL_PART_ON_FAIL_RETURN(EINA_FALSE)
319 return _edje_text_cursor_coord_set(rp, _edje_text_cursor_get(rp, cur), x, y);
320 }
321
322 EAPI void
edje_object_part_text_cursor_line_begin_set(Edje_Object * obj,const char * part EINA_UNUSED,Edje_Cursor cur)323 edje_object_part_text_cursor_line_begin_set(Edje_Object *obj, const char *part EINA_UNUSED, Edje_Cursor cur)
324 {
325 GET_REAL_PART_ON_FAIL_RETURN()
326 _edje_text_cursor_line_begin(rp, _edje_text_cursor_get(rp, cur));
327 }
328
329 EAPI void
edje_object_part_text_cursor_line_end_set(Edje_Object * obj,const char * part EINA_UNUSED,Edje_Cursor cur)330 edje_object_part_text_cursor_line_end_set(Edje_Object *obj, const char *part EINA_UNUSED, Edje_Cursor cur)
331 {
332 GET_REAL_PART_ON_FAIL_RETURN()
333 _edje_text_cursor_line_end(rp, _edje_text_cursor_get(rp, cur));
334 }
335
336 EAPI Eina_Bool
edje_object_part_text_cursor_prev(Edje_Object * obj,const char * part EINA_UNUSED,Edje_Cursor cur)337 edje_object_part_text_cursor_prev(Edje_Object *obj, const char *part EINA_UNUSED, Edje_Cursor cur)
338 {
339 GET_REAL_PART_ON_FAIL_RETURN(EINA_FALSE)
340 return _edje_text_cursor_prev(rp, _edje_text_cursor_get(rp, cur));
341 }
342
343 EAPI Eina_Bool
edje_object_part_text_cursor_next(Edje_Object * obj,const char * part EINA_UNUSED,Edje_Cursor cur)344 edje_object_part_text_cursor_next(Edje_Object *obj, const char *part EINA_UNUSED, Edje_Cursor cur)
345 {
346 GET_REAL_PART_ON_FAIL_RETURN(EINA_FALSE)
347 return _edje_text_cursor_next(rp, _edje_text_cursor_get(rp, cur));
348 }
349
350 EAPI Eina_Bool
edje_object_part_text_cursor_down(Edje_Object * obj,const char * part EINA_UNUSED,Edje_Cursor cur)351 edje_object_part_text_cursor_down(Edje_Object *obj, const char *part EINA_UNUSED, Edje_Cursor cur)
352 {
353 GET_REAL_PART_ON_FAIL_RETURN(EINA_FALSE)
354 return _edje_text_cursor_down(rp, _edje_text_cursor_get(rp, cur));
355 }
356
357 EAPI Eina_Bool
edje_object_part_text_cursor_up(Edje_Object * obj,const char * part EINA_UNUSED,Edje_Cursor cur)358 edje_object_part_text_cursor_up(Edje_Object *obj, const char *part EINA_UNUSED, Edje_Cursor cur)
359 {
360 GET_REAL_PART_ON_FAIL_RETURN(EINA_FALSE)
361 return _edje_text_cursor_up(rp, _edje_text_cursor_get(rp, cur));
362 }
363
364 EAPI void
edje_object_part_text_cursor_copy(Edje_Object * obj,const char * part EINA_UNUSED,Edje_Cursor cur,Edje_Cursor dst)365 edje_object_part_text_cursor_copy(Edje_Object *obj, const char *part EINA_UNUSED, Edje_Cursor cur, Edje_Cursor dst)
366 {
367 GET_REAL_PART_ON_FAIL_RETURN()
368 _edje_text_cursor_copy(rp, _edje_text_cursor_get(rp, cur), _edje_text_cursor_get(rp, dst));
369 }
370
371 EAPI char *
edje_object_part_text_cursor_content_get(const Edje_Object * obj,const char * part EINA_UNUSED,Edje_Cursor cur)372 edje_object_part_text_cursor_content_get(const Edje_Object *obj, const char *part EINA_UNUSED, Edje_Cursor cur)
373 {
374 GET_REAL_PART_ON_FAIL_RETURN(NULL)
375 if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
376 {
377 return _edje_entry_cursor_content_get(rp, cur);
378 }
379
380 return NULL;
381 }
382
383 EAPI void
edje_object_part_text_cursor_geometry_get(const Edje_Object * obj,const char * part EINA_UNUSED,int * x,int * y,int * w,int * h)384 edje_object_part_text_cursor_geometry_get(const Edje_Object *obj, const char * part EINA_UNUSED, int *x, int *y, int *w, int *h)
385 {
386 GET_REAL_PART_ON_FAIL_RETURN()
387 if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
388 {
389 _edje_entry_cursor_geometry_get(rp, x, y, w, h, NULL);
390 if (x) *x -= ed->x;
391 if (y) *y -= ed->y;
392 }
393 }
394
395 EAPI Eina_Bool
edje_object_part_text_hide_visible_password(Eo * obj,const char * part)396 edje_object_part_text_hide_visible_password(Eo *obj, const char *part)
397 {
398 GET_REAL_PART_ON_FAIL_RETURN(EINA_FALSE)
399 Eina_Bool int_ret = EINA_FALSE;
400 if (rp->part->type != EDJE_PART_TYPE_TEXTBLOCK) return EINA_FALSE;
401 if ((rp->type != EDJE_RP_TYPE_TEXT) ||
402 (!rp->typedata.text))
403 {
404 return EINA_FALSE;
405 }
406
407 if (rp->part->entry_mode == EDJE_ENTRY_EDIT_MODE_PASSWORD)
408 int_ret = _edje_entry_hide_visible_password(ed, rp);
409
410 return int_ret;
411 }
412
413 EAPI Eina_Bool
edje_object_part_text_cursor_is_format_get(const Eo * obj,const char * part,Edje_Cursor cur)414 edje_object_part_text_cursor_is_format_get(const Eo *obj, const char *part, Edje_Cursor cur)
415 {
416 GET_REAL_PART_ON_FAIL_RETURN(EINA_FALSE)
417 if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
418 {
419 return _edje_entry_cursor_is_format_get(rp, cur);
420 }
421 return EINA_FALSE;
422 }
423
424 EAPI Eina_Bool
edje_object_part_text_cursor_is_visible_format_get(const Eo * obj,const char * part,Edje_Cursor cur)425 edje_object_part_text_cursor_is_visible_format_get(const Eo *obj, const char *part, Edje_Cursor cur)
426 {
427 GET_REAL_PART_ON_FAIL_RETURN(EINA_FALSE)
428 if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
429 {
430 return _edje_entry_cursor_is_visible_format_get(rp, cur);
431 }
432
433 return EINA_FALSE;
434 }
435
436 EAPI const Eina_List *
edje_object_part_text_anchor_list_get(const Eo * obj,const char * part)437 edje_object_part_text_anchor_list_get(const Eo *obj, const char *part)
438 {
439 GET_REAL_PART_ON_FAIL_RETURN(NULL)
440 if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
441 return _edje_entry_anchors_list(rp);
442
443 return NULL;
444 }
445
446 EAPI const Eina_List *
edje_object_part_text_anchor_geometry_get(const Eo * obj,const char * part,const char * anchor)447 edje_object_part_text_anchor_geometry_get(const Eo *obj, const char *part, const char *anchor)
448 {
449 GET_REAL_PART_ON_FAIL_RETURN(NULL)
450 if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
451 return _edje_entry_anchor_geometry_get(rp, anchor);
452
453 return NULL;
454 }
455
456 EAPI void
edje_object_part_text_style_user_push(Eo * obj,const char * part,const char * style)457 edje_object_part_text_style_user_push(Eo *obj, const char *part, const char *style)
458 {
459 Evas_Textblock_Style *ts;
460 GET_REAL_PART_ON_FAIL_RETURN()
461
462 if (rp->part->type != EDJE_PART_TYPE_TEXTBLOCK) return;
463
464 ts = evas_textblock_style_new();
465 evas_textblock_style_set(ts, style);
466 evas_object_textblock_style_user_push(rp->object, ts);
467 evas_textblock_style_free(ts);
468 ed->recalc_hints = EINA_TRUE;
469 #ifdef EDJE_CALC_CACHE
470 rp->invalidate = EINA_TRUE;
471 #endif
472 _edje_recalc(ed);
473 }
474
475 EAPI void
edje_object_part_text_style_user_pop(Eo * obj,const char * part)476 edje_object_part_text_style_user_pop(Eo *obj, const char *part)
477 {
478 GET_REAL_PART_ON_FAIL_RETURN()
479 if (rp->part->type != EDJE_PART_TYPE_TEXTBLOCK) return;
480
481 evas_object_textblock_style_user_pop(rp->object);
482 ed->recalc_hints = EINA_TRUE;
483 #ifdef EDJE_CALC_CACHE
484 rp->invalidate = EINA_TRUE;
485 #endif
486 _edje_recalc(ed);
487 }
488
489 EAPI const char *
edje_object_part_text_style_user_peek(const Eo * obj,const char * part)490 edje_object_part_text_style_user_peek(const Eo *obj, const char *part)
491 {
492 Edje_Real_Part *rp;
493 const Evas_Textblock_Style *ts;
494 Edje *ed;
495 EINA_SAFETY_ON_NULL_RETURN_VAL(part, NULL);
496
497 ed = _edje_fetch(obj);
498
499 if (!ed) return NULL;
500 rp = _edje_real_part_recursive_get(&ed, part);
501 if (!rp) return NULL;
502 if (rp->part->type != EDJE_PART_TYPE_TEXTBLOCK) return NULL;
503
504 ts = evas_object_textblock_style_user_peek(rp->object);
505 if (ts)
506 return evas_textblock_style_get(ts);
507
508 return NULL;
509 }
510
511 EAPI const Eina_List *
edje_object_part_text_item_list_get(const Eo * obj,const char * part)512 edje_object_part_text_item_list_get(const Eo *obj, const char *part)
513 {
514 GET_REAL_PART_ON_FAIL_RETURN(NULL)
515 if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
516 return _edje_entry_items_list(rp);
517
518 return NULL;
519 }
520
521 EAPI Eina_Bool
edje_object_part_text_item_geometry_get(const Eo * obj,const char * part,const char * item,Evas_Coord * cx,Evas_Coord * cy,Evas_Coord * cw,Evas_Coord * ch)522 edje_object_part_text_item_geometry_get(const Eo *obj, const char *part, const char *item, Evas_Coord *cx, Evas_Coord *cy, Evas_Coord *cw, Evas_Coord *ch)
523 {
524 GET_REAL_PART_ON_FAIL_RETURN(EINA_FALSE)
525 if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
526 {
527 return _edje_entry_item_geometry_get(rp, item, cx, cy, cw, ch);
528 }
529
530 return EINA_FALSE;
531 }
532
533 EAPI void
edje_object_text_insert_filter_callback_add(Eo * obj,const char * part,Edje_Text_Filter_Cb func,void * data)534 edje_object_text_insert_filter_callback_add(Eo *obj, const char *part, Edje_Text_Filter_Cb func, void *data)
535 {
536 Edje_Text_Insert_Filter_Callback *cb;
537 Edje *ed;
538 EINA_SAFETY_ON_NULL_RETURN(part);
539
540 ed = _edje_fetch(obj);
541
542 if (!ed) return;
543 cb = calloc(1, sizeof(Edje_Text_Insert_Filter_Callback));
544 cb->part = eina_stringshare_add(part);
545 cb->func = func;
546 cb->data = (void *)data;
547 ed->text_insert_filter_callbacks =
548 eina_list_append(ed->text_insert_filter_callbacks, cb);
549 }
550
551 EAPI void *
edje_object_text_insert_filter_callback_del(Eo * obj,const char * part,Edje_Text_Filter_Cb func)552 edje_object_text_insert_filter_callback_del(Eo *obj, const char *part, Edje_Text_Filter_Cb func)
553 {
554 Edje_Text_Insert_Filter_Callback *cb;
555 Eina_List *l;
556 Edje *ed;
557 EINA_SAFETY_ON_NULL_RETURN_VAL(part, NULL);
558
559 ed = _edje_fetch(obj);
560
561 if (!ed) return NULL;
562 EINA_LIST_FOREACH(ed->text_insert_filter_callbacks, l, cb)
563 {
564 if ((!strcmp(cb->part, part)) && (cb->func == func))
565 {
566 void *data = cb->data;
567 ed->text_insert_filter_callbacks =
568 eina_list_remove_list(ed->text_insert_filter_callbacks, l);
569 eina_stringshare_del(cb->part);
570 free(cb);
571 return data;
572 }
573 }
574
575 return NULL;
576 }
577
578 EAPI void *
edje_object_text_insert_filter_callback_del_full(Eo * obj,const char * part,Edje_Text_Filter_Cb func,void * data)579 edje_object_text_insert_filter_callback_del_full(Eo *obj, const char *part, Edje_Text_Filter_Cb func, void *data)
580 {
581 Edje_Text_Insert_Filter_Callback *cb;
582 Eina_List *l;
583 Edje *ed;
584 EINA_SAFETY_ON_NULL_RETURN_VAL(part, NULL);
585
586 ed = _edje_fetch(obj);
587
588 if (!ed) return NULL;
589 EINA_LIST_FOREACH(ed->text_insert_filter_callbacks, l, cb)
590 {
591 if ((!strcmp(cb->part, part)) && (cb->func == func) &&
592 (cb->data == data))
593 {
594 void *tmp = cb->data;
595 ed->text_insert_filter_callbacks =
596 eina_list_remove_list(ed->text_insert_filter_callbacks, l);
597 eina_stringshare_del(cb->part);
598 free(cb);
599 return tmp;
600 }
601 }
602
603 return NULL;
604 }
605
606 EAPI void
edje_object_text_markup_filter_callback_add(Eo * obj,const char * part,Edje_Markup_Filter_Cb func,void * data)607 edje_object_text_markup_filter_callback_add(Eo *obj, const char *part, Edje_Markup_Filter_Cb func, void *data)
608 {
609 Edje_Markup_Filter_Callback *cb;
610 Edje *ed;
611 EINA_SAFETY_ON_NULL_RETURN(part);
612
613 ed = _edje_fetch(obj);
614
615 if (!ed) return;
616 cb = calloc(1, sizeof(Edje_Markup_Filter_Callback));
617 cb->part = eina_stringshare_add(part);
618 cb->func = func;
619 cb->data = (void *)data;
620 ed->markup_filter_callbacks =
621 eina_list_append(ed->markup_filter_callbacks, cb);
622 }
623
624 EAPI void *
edje_object_text_markup_filter_callback_del(Eo * obj,const char * part,Edje_Markup_Filter_Cb func)625 edje_object_text_markup_filter_callback_del(Eo *obj, const char *part, Edje_Markup_Filter_Cb func)
626 {
627 Edje_Markup_Filter_Callback *cb;
628 Eina_List *l;
629 Edje *ed;
630 EINA_SAFETY_ON_NULL_RETURN_VAL(part, NULL);
631
632 ed = _edje_fetch(obj);
633
634 if (!ed) return NULL;
635 EINA_LIST_FOREACH(ed->markup_filter_callbacks, l, cb)
636 {
637 if ((!strcmp(cb->part, part)) && (cb->func == func))
638 {
639 void *data = cb->data;
640 ed->markup_filter_callbacks =
641 eina_list_remove_list(ed->markup_filter_callbacks, l);
642 eina_stringshare_del(cb->part);
643 free(cb);
644 return data;
645 }
646 }
647
648 return NULL;
649 }
650
651 EAPI void *
edje_object_text_markup_filter_callback_del_full(Eo * obj,const char * part,Edje_Markup_Filter_Cb func,void * data)652 edje_object_text_markup_filter_callback_del_full(Eo *obj, const char *part, Edje_Markup_Filter_Cb func, void *data)
653 {
654 Edje_Markup_Filter_Callback *cb;
655 Eina_List *l;
656 Edje *ed;
657 EINA_SAFETY_ON_NULL_RETURN_VAL(part, NULL);
658
659 ed = _edje_fetch(obj);
660
661 if (!ed) return NULL;
662 EINA_LIST_FOREACH(ed->markup_filter_callbacks, l, cb)
663 {
664 if ((!strcmp(cb->part, part)) && (cb->func == func) &&
665 (cb->data == data))
666 {
667 void *tmp = cb->data;
668 ed->markup_filter_callbacks =
669 eina_list_remove_list(ed->markup_filter_callbacks, l);
670 eina_stringshare_del(cb->part);
671 free(cb);
672 return tmp;
673 }
674 }
675
676 return NULL;
677 }
678
679 EAPI void
edje_object_part_text_user_insert(const Eo * obj,const char * part,const char * text)680 edje_object_part_text_user_insert(const Eo *obj, const char *part, const char *text)
681 {
682 Edje_Real_Part *rp;
683 Edje *ed;
684 EINA_SAFETY_ON_NULL_RETURN(part);
685
686 ed = _edje_fetch(obj);
687
688 if (!ed) return;
689 rp = _edje_real_part_recursive_get(&ed, part);
690 if (!rp) return;
691 if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
692 _edje_entry_user_insert(rp, text);
693 }
694
695 Eina_Bool
_edje_object_part_text_raw_append(Edje * ed,Evas_Object * obj,Edje_Real_Part * rp,const char * part,const char * text)696 _edje_object_part_text_raw_append(Edje *ed, Evas_Object *obj, Edje_Real_Part *rp, const char *part, const char *text)
697 {
698 if ((rp->type != EDJE_RP_TYPE_TEXT) ||
699 (!rp->typedata.text)) return EINA_TRUE;
700 if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
701 _edje_entry_text_markup_append(rp, text);
702 else if (text)
703 {
704 if (rp->typedata.text->text)
705 {
706 char *new = NULL;
707 int len_added = strlen(text);
708 int len_old = strlen(rp->typedata.text->text);
709 new = malloc(len_old + len_added + 1);
710 memcpy(new, rp->typedata.text->text, len_old);
711 memcpy(new + len_old, text, len_added);
712 new[len_old + len_added] = '\0';
713 eina_stringshare_replace(&rp->typedata.text->text, new);
714 free(new);
715 }
716 else
717 {
718 eina_stringshare_replace(&rp->typedata.text->text, text);
719 }
720 }
721 ed->dirty = EINA_TRUE;
722 ed->recalc_call = 1;
723 #ifdef EDJE_CALC_CACHE
724 rp->invalidate = EINA_TRUE;
725 #endif
726 _edje_recalc(ed);
727 if (ed->text_change.func)
728 ed->text_change.func(ed->text_change.data, obj, part);
729 return EINA_TRUE;
730 }
731
732 EAPI void
edje_object_part_text_append(Eo * obj,const char * part,const char * text)733 edje_object_part_text_append(Eo *obj, const char *part, const char *text)
734 {
735 Edje_Real_Part *rp;
736 Edje *ed;
737 EINA_SAFETY_ON_NULL_RETURN(part);
738
739 ed = _edje_fetch(obj);
740
741 if (!ed) return;
742 rp = _edje_real_part_recursive_get(&ed, part);
743 if (!rp) return;
744 if ((rp->part->type != EDJE_PART_TYPE_TEXTBLOCK)) return;
745 _edje_object_part_text_raw_append(ed, obj, rp, part, text);
746 ed->dirty = EINA_TRUE;
747 ed->recalc_call = EINA_TRUE;
748 ed->recalc_hints = EINA_TRUE;
749 #ifdef EDJE_CALC_CACHE
750 rp->invalidate = EINA_TRUE;
751 #endif
752 _edje_recalc(ed);
753 if (ed->text_change.func)
754 ed->text_change.func(ed->text_change.data, obj, part);
755 }
756
757 EAPI Eina_Bool
edje_object_part_text_escaped_set(Eo * obj,const char * part,const char * text)758 edje_object_part_text_escaped_set(Eo *obj, const char *part, const char *text)
759 {
760 Edje_Real_Part *rp;
761 Eina_Bool int_ret;
762 Edje *ed;
763 EINA_SAFETY_ON_NULL_RETURN_VAL(part, EINA_FALSE);
764
765 ed = _edje_fetch(obj);
766
767 if (!ed) return EINA_FALSE;
768 rp = _edje_real_part_recursive_get(&ed, part);
769 if (!rp) return EINA_FALSE;
770 if ((rp->type != EDJE_RP_TYPE_TEXT) ||
771 (!rp->typedata.text)) return EINA_FALSE;
772 if (rp->part->type != EDJE_PART_TYPE_TEXTBLOCK &&
773 rp->part->type != EDJE_PART_TYPE_TEXT)
774 return EINA_FALSE;
775 if ((rp->part->type == EDJE_PART_TYPE_TEXT) && (text))
776 {
777 Eina_Strbuf *sbuf;
778 char *esc_start = NULL, *esc_end = NULL;
779 char *s, *p;
780
781 sbuf = eina_strbuf_new();
782 p = (char *)text;
783 s = p;
784 for (;; )
785 {
786 if ((*p == 0) || (esc_end) || (esc_start))
787 {
788 if (esc_end)
789 {
790 const char *escape;
791
792 escape = evas_textblock_escape_string_range_get
793 (esc_start, esc_end + 1);
794 if (escape) eina_strbuf_append(sbuf, escape);
795 esc_start = esc_end = NULL;
796 }
797 else if (*p == 0)
798 {
799 if (!s) s = esc_start; /* This would happen when there is & that isn't escaped */
800 eina_strbuf_append_length(sbuf, s, p - s);
801 s = NULL;
802 }
803 if (*p == 0)
804 break;
805 }
806
807 if (*p == '&')
808 {
809 if (!s) s = esc_start; /* This would happen when there is & that isn't escaped */
810 esc_start = p;
811 esc_end = NULL;
812 eina_strbuf_append_length(sbuf, s, p - s);
813 s = NULL;
814 }
815 else if (*p == ';')
816 {
817 if (esc_start)
818 {
819 esc_end = p;
820 s = p + 1;
821 }
822 }
823 p++;
824 }
825 int_ret = _edje_object_part_text_raw_set(ed, obj, rp, part, eina_strbuf_string_get(sbuf));
826 _edje_user_define_string(ed, part, rp->typedata.text->text, EDJE_TEXT_TYPE_ESCAPED);
827 eina_strbuf_free(sbuf);
828 return int_ret;
829 }
830 int_ret = _edje_object_part_text_raw_set(ed, obj, rp, part, text);
831 _edje_user_define_string(ed, part, rp->typedata.text->text, EDJE_TEXT_TYPE_ESCAPED);
832
833 return int_ret;
834 }
835
836 char *
_edje_text_escape(const char * text)837 _edje_text_escape(const char *text)
838 {
839 Eina_Strbuf *txt;
840 char *ret;
841 const char *text_end;
842 size_t text_len;
843
844 if (!text) return NULL;
845
846 txt = eina_strbuf_new();
847 text_len = strlen(text);
848
849 text_end = text + text_len;
850 while (text < text_end)
851 {
852 int advance;
853 const char *escaped = evas_textblock_string_escape_get(text, &advance);
854 if (!escaped)
855 {
856 eina_strbuf_append_char(txt, text[0]);
857 advance = 1;
858 }
859 else
860 eina_strbuf_append(txt, escaped);
861
862 text += advance;
863 }
864
865 ret = eina_strbuf_string_steal(txt);
866 eina_strbuf_free(txt);
867 return ret;
868 }
869
870 char *
_edje_text_unescape(const char * text)871 _edje_text_unescape(const char *text)
872 {
873 Eina_Strbuf *txt;
874 char *ret;
875 const char *text_end, *last, *escape_start;
876 size_t text_len;
877
878 if (!text) return NULL;
879
880 txt = eina_strbuf_new();
881 text_len = strlen(text);
882
883 text_end = text + text_len;
884 last = text;
885 escape_start = NULL;
886 for (; text < text_end; text++)
887 {
888 if (*text == '&')
889 {
890 size_t len;
891 const char *str;
892
893 if (last)
894 {
895 len = text - last;
896 str = last;
897 }
898 else
899 {
900 len = text - escape_start;
901 str = escape_start;
902 }
903
904 if (len > 0)
905 eina_strbuf_append_n(txt, str, len);
906
907 escape_start = text;
908 last = NULL;
909 }
910 else if ((*text == ';') && (escape_start))
911 {
912 size_t len;
913 const char *str = evas_textblock_escape_string_range_get(escape_start, text);
914
915 if (str)
916 len = strlen(str);
917 else
918 {
919 str = escape_start;
920 len = text + 1 - escape_start;
921 }
922
923 eina_strbuf_append_n(txt, str, len);
924
925 escape_start = NULL;
926 last = text + 1;
927 }
928 }
929
930 if (!last && escape_start)
931 last = escape_start;
932
933 if (last && (text > last))
934 {
935 size_t len = text - last;
936 eina_strbuf_append_n(txt, last, len);
937 }
938
939 ret = eina_strbuf_string_steal(txt);
940 eina_strbuf_free(txt);
941 return ret;
942 }
943
944 EAPI Eina_Bool
edje_object_part_text_unescaped_set(Eo * obj,const char * part,const char * text_to_escape)945 edje_object_part_text_unescaped_set(Eo *obj, const char *part, const char *text_to_escape)
946 {
947 Edje_Real_Part *rp;
948 Eina_Bool int_ret = EINA_FALSE;
949 Edje *ed;
950 EINA_SAFETY_ON_NULL_RETURN_VAL(part, EINA_FALSE);
951
952 ed = _edje_fetch(obj);
953
954 if (!ed) return EINA_FALSE;
955 rp = _edje_real_part_recursive_get(&ed, part);
956 if (!rp) return EINA_FALSE;
957 if ((rp->type != EDJE_RP_TYPE_TEXT) ||
958 (!rp->typedata.text)) return EINA_FALSE;
959 if (rp->part->type == EDJE_PART_TYPE_TEXT)
960 int_ret = _edje_object_part_text_raw_set(ed, obj, rp, part, text_to_escape);
961 else if (rp->part->type == EDJE_PART_TYPE_TEXTBLOCK)
962 {
963 char *text = _edje_text_escape(text_to_escape);
964
965 int_ret = _edje_object_part_text_raw_set(ed, obj, rp, part, text);
966 free(text);
967 }
968 _edje_user_define_string(ed, part, rp->typedata.text->text, EDJE_TEXT_TYPE_UNESCAPED);
969
970 return int_ret;
971 }
972
973 EAPI char *
edje_object_part_text_unescaped_get(const Eo * obj,const char * part)974 edje_object_part_text_unescaped_get(const Eo *obj, const char *part)
975 {
976 Edje_Real_Part *rp;
977 Edje *ed;
978 EINA_SAFETY_ON_NULL_RETURN_VAL(part, NULL);
979
980 ed = _edje_fetch(obj);
981
982 if (!ed) return NULL;
983
984 /* Need to recalc before providing the object. */
985 _edje_recalc_do(ed);
986
987 rp = _edje_real_part_recursive_get(&ed, part);
988 if (!rp) return NULL;
989 if ((rp->type != EDJE_RP_TYPE_TEXT) ||
990 (!rp->typedata.text)) return NULL;
991 if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
992 {
993 const char *t = _edje_entry_text_get(rp);
994 return _edje_text_unescape(t);
995 }
996 else
997 {
998 if (rp->part->type == EDJE_PART_TYPE_TEXT)
999 {
1000 return strdup(rp->typedata.text->text);
1001 }
1002 if (rp->part->type == EDJE_PART_TYPE_TEXTBLOCK)
1003 {
1004 const char *t = evas_object_textblock_text_markup_get(rp->object);
1005 return _edje_text_unescape(t);
1006 }
1007 }
1008
1009 return NULL;
1010 }
1011
1012 void
_edje_object_part_text_insert(Edje * ed,Edje_Real_Part * rp,const char * text)1013 _edje_object_part_text_insert(Edje *ed, Edje_Real_Part *rp, const char *text)
1014 {
1015 if (!rp) return;
1016 if ((rp->part->type != EDJE_PART_TYPE_TEXTBLOCK)) return;
1017 if (rp->part->entry_mode <= EDJE_ENTRY_EDIT_MODE_NONE) return;
1018 _edje_entry_text_markup_insert(rp, text);
1019 ed->dirty = EINA_TRUE;
1020 ed->recalc_call = EINA_TRUE;
1021 ed->recalc_hints = EINA_TRUE;
1022 #ifdef EDJE_CALC_CACHE
1023 rp->invalidate = EINA_TRUE;
1024 #endif
1025 _edje_recalc(ed);
1026 }
1027
1028 EAPI void
edje_object_part_text_insert(Eo * obj,const char * part,const char * text)1029 edje_object_part_text_insert(Eo *obj, const char *part, const char *text)
1030 {
1031 Edje_Real_Part *rp;
1032 Edje *ed;
1033 EINA_SAFETY_ON_NULL_RETURN(part);
1034
1035 ed = _edje_fetch(obj);
1036
1037 if (!ed) return;
1038 rp = _edje_real_part_recursive_get(&ed, part);
1039 _edje_object_part_text_insert(ed, rp, text);
1040 if (ed->text_change.func)
1041 ed->text_change.func(ed->text_change.data, obj, part);
1042 }
1043
1044 /* Calc interface APIs */
1045
1046 EAPI void
edje_object_update_hints_set(Edje_Object * obj,Eina_Bool update)1047 edje_object_update_hints_set(Edje_Object *obj, Eina_Bool update)
1048 {
1049 efl_layout_calc_auto_update_hints_set(obj, update);
1050 }
1051
1052 EAPI Eina_Bool
edje_object_update_hints_get(const Edje_Object * obj)1053 edje_object_update_hints_get(const Edje_Object *obj)
1054 {
1055 return efl_layout_calc_auto_update_hints_get(obj);
1056 }
1057
1058 EAPI void
edje_object_size_min_calc(Edje_Object * obj,int * minw,int * minh)1059 edje_object_size_min_calc(Edje_Object *obj, int *minw, int *minh)
1060 {
1061 edje_object_size_min_restricted_calc(obj, minw, minh, 0, 0);
1062 }
1063
1064 EAPI void
edje_object_size_min_restricted_calc(Edje_Object * obj,int * minw,int * minh,int restrictedw,int restrictedh)1065 edje_object_size_min_restricted_calc(Edje_Object *obj, int *minw, int *minh, int restrictedw, int restrictedh)
1066 {
1067 Eina_Size2D sz = { restrictedw, restrictedh };
1068 Edje *ed;
1069
1070 ed = _edje_fetch(obj);
1071 if (!ed)
1072 {
1073 if (minw) *minw = sz.w;
1074 if (minh) *minh = sz.h;
1075 return;
1076 }
1077 sz = efl_layout_calc_size_min(obj, EINA_SIZE2D(restrictedw, restrictedh));
1078 if (minw) *minw = sz.w;
1079 if (minh) *minh = sz.h;
1080 }
1081
1082 EAPI Eina_Bool
edje_object_parts_extends_calc(Edje_Object * obj,int * x,int * y,int * w,int * h)1083 edje_object_parts_extends_calc(Edje_Object *obj, int *x, int *y, int *w, int *h)
1084 {
1085 Eina_Rect r = EINA_RECT_ZERO();
1086 Edje *ed;
1087
1088 ed = _edje_fetch(obj);
1089 if (ed) r = efl_layout_calc_parts_extends(obj);
1090 if (x) *x = r.x;
1091 if (y) *y = r.y;
1092 if (w) *w = r.w;
1093 if (h) *h = r.h;
1094 return (ed != NULL);
1095 }
1096
1097 EAPI int
edje_object_freeze(Edje_Object * obj)1098 edje_object_freeze(Edje_Object *obj)
1099 {
1100 return efl_layout_calc_freeze(obj);
1101 }
1102
1103 EAPI int
edje_object_thaw(Edje_Object * obj)1104 edje_object_thaw(Edje_Object *obj)
1105 {
1106 return efl_layout_calc_thaw(obj);
1107 }
1108
1109 EAPI void
edje_object_calc_force(Edje_Object * obj)1110 edje_object_calc_force(Edje_Object *obj)
1111 {
1112 efl_layout_calc_force(obj);
1113 }
1114
1115 EAPI void
edje_object_play_set(Evas_Object * obj,Eina_Bool play)1116 edje_object_play_set(Evas_Object *obj, Eina_Bool play)
1117 {
1118 efl_player_paused_set(obj, !play);
1119 }
1120
1121 EAPI Eina_Bool
edje_object_play_get(const Evas_Object * obj)1122 edje_object_play_get(const Evas_Object *obj)
1123 {
1124 if (!efl_isa(obj, EFL_CANVAS_LAYOUT_CLASS)) return EINA_FALSE;
1125 return !efl_player_paused_get(obj);
1126 }
1127
1128 EAPI void
edje_object_transition_duration_factor_set(Evas_Object * obj,double scale)1129 edje_object_transition_duration_factor_set(Evas_Object *obj, double scale)
1130 {
1131 if (scale <= 0.0) return;
1132 efl_player_playback_speed_set(obj, 1.0/scale);
1133 }
1134
1135 EAPI double
edje_object_transition_duration_factor_get(const Evas_Object * obj)1136 edje_object_transition_duration_factor_get(const Evas_Object *obj)
1137 {
1138 double speed = efl_player_playback_speed_get(obj);
1139
1140 if (speed <= 0.0) speed = 1.0;
1141 return 1.0/speed;
1142 }
1143
1144 EAPI void
edje_object_size_min_get(const Edje_Object * obj,int * minw,int * minh)1145 edje_object_size_min_get(const Edje_Object *obj, int *minw, int *minh)
1146 {
1147 Eina_Size2D sz;
1148 sz = efl_layout_group_size_min_get(obj);
1149 if (minw) *minw = sz.w;
1150 if (minh) *minh = sz.h;
1151 }
1152
1153 EAPI void
edje_object_size_max_get(const Edje_Object * obj,int * maxw,int * maxh)1154 edje_object_size_max_get(const Edje_Object *obj, int *maxw, int *maxh)
1155 {
1156 Eina_Size2D sz;
1157 sz = efl_layout_group_size_max_get(obj);
1158 if (maxw) *maxw = sz.w;
1159 if (maxh) *maxh = sz.h;
1160 }
1161
1162 EAPI Eina_Bool
edje_object_part_exists(const Eo * obj,const char * part)1163 edje_object_part_exists(const Eo *obj, const char *part)
1164 {
1165 return efl_layout_group_part_exist_get(obj, part);
1166 }
1167