efl

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
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
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 *
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
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
79
edje_object_message_signal_recursive_process(Edje_Object *obj)
80
{
81
   efl_layout_signal_process(obj, EINA_TRUE);
82
}
83

84
EAPI void
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 *
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 *
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
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
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
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
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 *
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 *
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
189
edje_object_mirrored_set(Edje_Object *obj, Eina_Bool rtl)
190
{
191
   efl_ui_mirrored_set(obj, rtl);
192
}
193

194
EAPI Eina_Bool edje_object_mirrored_get(const Edje_Object *obj)
195
{
196
   return efl_ui_mirrored_get(obj);
197
}
198

199
EAPI void edje_object_language_set(Edje_Object *obj, const char *language)
200
{
201
   efl_ui_language_set(obj, language);
202
}
203

204
EAPI const char *edje_object_language_get(const Edje_Object *obj)
205
{
206
   return efl_ui_language_get(obj);
207
}
208

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

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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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 *
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
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
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
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
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 *
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 *
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
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
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 *
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 *
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
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
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 *
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 *
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
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 *
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 *
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
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
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
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
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 *
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 *
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
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 *
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
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
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
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
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
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
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
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
1098
edje_object_freeze(Edje_Object *obj)
1099
{
1100
   return efl_layout_calc_freeze(obj);
1101
}
1102

1103
EAPI int
1104
edje_object_thaw(Edje_Object *obj)
1105
{
1106
   return efl_layout_calc_thaw(obj);
1107
}
1108

1109
EAPI void
1110
edje_object_calc_force(Edje_Object *obj)
1111
{
1112
   efl_layout_calc_force(obj);
1113
}
1114

1115
EAPI void
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
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
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
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
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
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
1163
edje_object_part_exists(const Eo *obj, const char *part)
1164
{
1165
   return efl_layout_group_part_exist_get(obj, part);
1166
}
1167