efl

1
#include "edje_private.h"
2
#include "edje_part_helper.h"
3
#include "efl_canvas_layout_part_text.eo.h"
4
#define MY_CLASS EFL_CANVAS_LAYOUT_PART_TEXT_CLASS
5

6
PROXY_IMPLEMENTATION(text, MY_CLASS, EINA_FALSE)
7
#undef PROXY_IMPLEMENTATION
8

9
EOLIAN static void
10
_efl_canvas_layout_part_text_efl_text_text_set(Eo *obj,
11
      void *_pd EINA_UNUSED, const char *text)
12
{
13
   PROXY_DATA_GET(obj, pd);
14
   _edje_efl_text_text_set(obj, pd->ed, pd->part, text, EINA_FALSE, EINA_FALSE);
15
}
16

17
EOLIAN static const char *
18
_efl_canvas_layout_part_text_efl_text_text_get(const Eo *obj,
19
      void *_pd EINA_UNUSED)
20
{
21
   PROXY_DATA_GET(obj, pd);
22
   return _edje_efl_text_text_get(obj, pd->ed, pd->part, EINA_FALSE, EINA_FALSE);
23
}
24

25
EOLIAN static const char *
26
_efl_canvas_layout_part_text_efl_text_markup_markup_get(const Eo *obj,
27
      void *_pd EINA_UNUSED)
28
{
29
   PROXY_DATA_GET(obj, pd);
30
   return _edje_efl_text_text_get(obj, pd->ed, pd->part, EINA_FALSE, EINA_TRUE);
31
}
32

33
EOLIAN static void
34
_efl_canvas_layout_part_text_efl_text_markup_markup_set(Eo *obj,
35
      void *_pd EINA_UNUSED, const char *text)
36
{
37
   PROXY_DATA_GET(obj, pd);
38
   _edje_efl_text_text_set(obj, pd->ed, pd->part, text, EINA_FALSE, EINA_TRUE);
39
}
40

41
/* More Efl.Text.* API (@since 1.22) */
42

43
EOLIAN static void
44
_efl_canvas_layout_part_text_efl_text_style_text_background_type_set(Eo *obj,
45
      void *_pd EINA_UNUSED,
46
      Efl_Text_Style_Background_Type type)
47
{
48
   Edje_User_Defined *eud;
49

50
   PROXY_DATA_GET(obj, pd);
51
   if (pd->rp->part->type == EDJE_PART_TYPE_TEXT) return;
52

53
   eud = _edje_user_text_style_definition_fetch(pd->ed, pd->part);
54

55
   eud->u.text_style.types |= EDJE_PART_TEXT_PROP_NONE;
56
   efl_text_background_type_set(pd->rp->object, type);
57
}
58

59
EOLIAN static Efl_Text_Style_Background_Type
60
_efl_canvas_layout_part_text_efl_text_style_text_background_type_get(const Eo *obj,
61
      void *_pd EINA_UNUSED)
62
{
63

64
   PROXY_DATA_GET(obj, pd);
65
   if (pd->rp->part->type == EDJE_PART_TYPE_TEXT)
66
      return EFL_TEXT_STYLE_BACKGROUND_TYPE_NONE;
67

68
   return efl_text_background_type_get(pd->rp->object);
69
}
70

71
#define TEXT_COLOR_IMPL(x, X) \
72
EOLIAN static void \
73
_efl_canvas_layout_part_text_efl_text_style_ ##x ##_color_set(Eo *obj, \
74
      void *_pd EINA_UNUSED, \
75
      unsigned char r, unsigned char g, unsigned char b, unsigned char a) \
76
{ \
77
   Edje_User_Defined *eud; \
78
 \
79
   PROXY_DATA_GET(obj, pd); \
80
   if (pd->rp->part->type == EDJE_PART_TYPE_TEXT) return; \
81
 \
82
   eud = _edje_user_text_style_definition_fetch(pd->ed, pd->part); \
83
 \
84
   eud->u.text_style.types |= EDJE_PART_TEXT_PROP_COLOR_ ##X; \
85
   efl_ ##x ##_color_set(pd->rp->object, r, g, b, a); \
86
} \
87
\
88
EOLIAN static void \
89
_efl_canvas_layout_part_text_efl_text_style_ ##x ##_color_get(const Eo *obj, \
90
      void *_pd EINA_UNUSED, \
91
      unsigned char *r, unsigned char *g, unsigned char *b, unsigned char *a) \
92
{ \
93
   PROXY_DATA_GET(obj, pd); \
94
   *r = *g = *b = *a = 0; \
95
   if (pd->rp->part->type == EDJE_PART_TYPE_TEXT) return; \
96
   efl_ ##x ##_color_get(pd->rp->object, r, g, b, a); \
97
}
98

99
TEXT_COLOR_IMPL(text_background, BACKING)
100
TEXT_COLOR_IMPL(text_glow, GLOW)
101
TEXT_COLOR_IMPL(text_secondary_glow, GLOW2)
102
TEXT_COLOR_IMPL(text, NORMAL)
103
TEXT_COLOR_IMPL(text_outline, OUTLINE)
104
TEXT_COLOR_IMPL(text_shadow, SHADOW)
105
TEXT_COLOR_IMPL(text_strikethrough, STRIKETHROUGH)
106
TEXT_COLOR_IMPL(text_underline, UNDERLINE)
107
TEXT_COLOR_IMPL(text_secondary_underline, UNDERLINE2)
108
TEXT_COLOR_IMPL(text_underline_dashed, UNDERLINE_DASHED)
109

110
EOLIAN static void
111
_efl_canvas_layout_part_text_efl_text_style_text_effect_type_set(Eo *obj,
112
      void *_pd EINA_UNUSED,
113
      Efl_Text_Style_Effect_Type type)
114
{
115
   Edje_User_Defined *eud;
116

117
   PROXY_DATA_GET(obj, pd);
118
   if (pd->rp->part->type == EDJE_PART_TYPE_TEXT) return;
119

120
   eud = _edje_user_text_style_definition_fetch(pd->ed, pd->part);
121

122
   eud->u.text_style.types |= EDJE_PART_TEXT_PROP_EFFECT_TYPE;
123
   efl_text_effect_type_set(pd->rp->object, type);
124
}
125

126
EOLIAN static void
127
_efl_canvas_layout_part_text_efl_text_format_ellipsis_set(Eo *obj,
128
      void *_pd EINA_UNUSED, double value)
129
{
130
   Edje_User_Defined *eud;
131

132
   PROXY_DATA_GET(obj, pd);
133
   if (pd->rp->part->type == EDJE_PART_TYPE_TEXT) return;
134

135
   eud = _edje_user_text_style_definition_fetch(pd->ed, pd->part);
136

137
   eud->u.text_style.types |= EDJE_PART_TEXT_PROP_ELLIPSIS;
138
   efl_text_ellipsis_set(pd->rp->object, value);
139
}
140

141
EOLIAN static double
142
_efl_canvas_layout_part_text_efl_text_format_ellipsis_get(const Eo *obj,
143
      void *_pd EINA_UNUSED)
144
{
145
   PROXY_DATA_GET(obj, pd);
146
   if (pd->rp->part->type == EDJE_PART_TYPE_TEXT) return 0.0;
147

148
   return efl_text_ellipsis_get(pd->rp->object);
149
}
150

151
EOLIAN static void
152
_efl_canvas_layout_part_text_efl_text_font_properties_font_family_set(Eo *obj,
153
      void *_pd EINA_UNUSED, const char *font)
154
{
155
   Edje_User_Defined *eud;
156

157
   PROXY_DATA_GET(obj, pd);
158
   if (pd->rp->part->type == EDJE_PART_TYPE_TEXT) return;
159

160

161
   eud = _edje_user_text_style_definition_fetch(pd->ed, pd->part);
162

163
   eud->u.text_style.types |= EDJE_PART_TEXT_PROP_FONT;
164
   efl_text_font_family_set(pd->rp->object, font);
165
}
166

167
EOLIAN static const char *
168
_efl_canvas_layout_part_text_efl_text_font_properties_font_family_get(const Eo *obj,
169
      void *_pd EINA_UNUSED)
170
{
171
   PROXY_DATA_GET(obj, pd);
172
   if (pd->rp->part->type == EDJE_PART_TYPE_TEXT) return NULL;
173

174
   return efl_text_font_family_get(pd->rp->object);
175
}
176

177
EOLIAN static void
178
_efl_canvas_layout_part_text_efl_text_font_properties_font_size_set(Eo *obj,
179
      void *_pd EINA_UNUSED, Efl_Font_Size size)
180
{
181
   Edje_User_Defined *eud;
182

183
   PROXY_DATA_GET(obj, pd);
184
   if (pd->rp->part->type == EDJE_PART_TYPE_TEXT) return;
185

186

187
   eud = _edje_user_text_style_definition_fetch(pd->ed, pd->part);
188

189
   eud->u.text_style.types |= EDJE_PART_TEXT_PROP_FONT;
190
   efl_text_font_size_set(pd->rp->object, size);
191
}
192

193
EOLIAN static Efl_Font_Size
194
_efl_canvas_layout_part_text_efl_text_font_properties_font_size_get(const Eo *obj,
195
      void *_pd EINA_UNUSED)
196
{
197
   PROXY_DATA_GET(obj, pd);
198
   if (pd->rp->part->type == EDJE_PART_TYPE_TEXT) return 0;
199

200
   return efl_text_font_size_get(pd->rp->object);
201
}
202

203
EOLIAN static void
204
_efl_canvas_layout_part_text_efl_text_style_text_shadow_direction_set(Eo *obj,
205
      void *_pd EINA_UNUSED,
206
      Efl_Text_Style_Shadow_Direction type)
207
{
208
   Edje_User_Defined *eud;
209

210
   PROXY_DATA_GET(obj, pd);
211
   if (pd->rp->part->type == EDJE_PART_TYPE_TEXT) return;
212

213
   eud = _edje_user_text_style_definition_fetch(pd->ed, pd->part);
214

215
   eud->u.text_style.types |= EDJE_PART_TEXT_PROP_SHADOW_DIRECTION;
216
   efl_text_shadow_direction_set(pd->rp->object, type);
217
}
218

219
EOLIAN static void
220
_efl_canvas_layout_part_text_efl_text_style_text_strikethrough_type_set(Eo *obj,
221
      void *_pd EINA_UNUSED,
222
      Efl_Text_Style_Strikethrough_Type type)
223
{
224
   Edje_User_Defined *eud;
225

226
   PROXY_DATA_GET(obj, pd);
227
   if (pd->rp->part->type == EDJE_PART_TYPE_TEXT) return;
228

229
   eud = _edje_user_text_style_definition_fetch(pd->ed, pd->part);
230

231
   eud->u.text_style.types |= EDJE_PART_TEXT_PROP_STRIKETHROUGH_TYPE;
232
   efl_text_strikethrough_type_set(pd->rp->object, type);
233
}
234

235
EOLIAN static void
236
_efl_canvas_layout_part_text_efl_text_style_text_underline_type_set(Eo *obj,
237
      void *_pd EINA_UNUSED,
238
      Efl_Text_Style_Underline_Type type)
239
{
240
   Edje_User_Defined *eud;
241

242
   PROXY_DATA_GET(obj, pd);
243
   if (pd->rp->part->type == EDJE_PART_TYPE_TEXT) return;
244

245

246
   eud = _edje_user_text_style_definition_fetch(pd->ed, pd->part);
247

248
   eud->u.text_style.types = EDJE_PART_TEXT_PROP_UNDERLINE_TYPE;
249
   efl_text_underline_type_set(pd->rp->object, type);
250
}
251

252
EOLIAN static void
253
_efl_canvas_layout_part_text_efl_text_style_text_underline_height_set(Eo *obj,
254
      void *_pd EINA_UNUSED,
255
      double value)
256
{
257
   Edje_User_Defined *eud;
258

259
   PROXY_DATA_GET(obj, pd);
260
   if (pd->rp->part->type == EDJE_PART_TYPE_TEXT) return;
261

262
   eud = _edje_user_text_style_definition_fetch(pd->ed, pd->part);
263

264
   eud->u.text_style.types |= EDJE_PART_TEXT_PROP_UNDERLINE_HEIGHT;
265
   efl_text_underline_height_set(pd->rp->object, value);
266
}
267

268
EOLIAN static void
269
_efl_canvas_layout_part_text_efl_text_style_text_underline_dashed_width_set(Eo *obj,
270
      void *_pd EINA_UNUSED,
271
      int value)
272
{
273
   Edje_User_Defined *eud;
274

275
   PROXY_DATA_GET(obj, pd);
276
   if (pd->rp->part->type == EDJE_PART_TYPE_TEXT) return;
277

278
   eud = _edje_user_text_style_definition_fetch(pd->ed, pd->part);
279

280
   eud->u.text_style.types |= EDJE_PART_TEXT_PROP_UNDERLINE_DASHED_WIDTH;
281
   efl_text_underline_dashed_width_set(pd->rp->object, value);
282
}
283

284
EOLIAN static void
285
_efl_canvas_layout_part_text_efl_text_style_text_underline_dashed_gap_set(Eo *obj,
286
      void *_pd EINA_UNUSED,
287
      int value)
288
{
289
   Edje_User_Defined *eud;
290

291
   PROXY_DATA_GET(obj, pd);
292
   if (pd->rp->part->type == EDJE_PART_TYPE_TEXT) return;
293

294
   eud = _edje_user_text_style_definition_fetch(pd->ed, pd->part);
295

296
   eud->u.text_style.types |= EDJE_PART_TEXT_PROP_UNDERLINE_DASHED_GAP;
297
   efl_text_underline_dashed_gap_set(pd->rp->object, value);
298
}
299

300
EOLIAN static void
301
_efl_canvas_layout_part_text_efl_text_format_wrap_set(Eo *obj,
302
      void *_pd EINA_UNUSED, Efl_Text_Format_Wrap wrap)
303
{
304
   Edje_User_Defined *eud;
305

306
   PROXY_DATA_GET(obj, pd);
307
   if (pd->rp->part->type == EDJE_PART_TYPE_TEXT) return;
308

309
   eud = _edje_user_text_style_definition_fetch(pd->ed, pd->part);
310

311
   eud->u.text_style.types |= EDJE_PART_TEXT_PROP_WRAP;
312
   efl_text_wrap_set(pd->rp->object, wrap);
313
}
314

315
EOLIAN static Efl_Text_Format_Wrap
316
_efl_canvas_layout_part_text_efl_text_format_wrap_get(const Eo *obj,
317
      void *_pd EINA_UNUSED)
318
{
319
   PROXY_DATA_GET(obj, pd);
320

321
   if (pd->rp->part->type == EDJE_PART_TYPE_TEXT)
322
      return EFL_TEXT_FORMAT_WRAP_NONE;
323

324
   return efl_text_wrap_get(pd->rp->object);
325
}
326

327
static Edje_Part_Text_Prop *
328
_prop_new(Eina_List **props, Edje_Part_Text_Prop_Type type)
329
{
330
   Edje_Part_Text_Prop *prop;
331

332
   prop = malloc(sizeof(*prop));
333
   prop->type = type;
334

335
   *props = eina_list_append(*props, prop);
336

337
   return prop;
338
}
339

340
void
341
_canvas_layout_user_text_collect(Edje *ed, Edje_User_Defined *eud)
342
{
343
   Edje_Real_Part *rp;
344
   Eina_List **props = &eud->u.text_style.props;
345

346
   rp = _edje_real_part_recursive_get(&ed, eud->part);
347
   if (!rp) return;
348

349
   if (eud->u.text_style.types == EDJE_PART_TEXT_PROP_NONE) return;
350

351
   if (eud->u.text_style.types & EDJE_PART_TEXT_PROP_BACKING_TYPE)
352
     {
353
        Edje_Part_Text_Prop *prop;
354

355
        prop = _prop_new(props, EDJE_PART_TEXT_PROP_BACKING_TYPE);
356
        prop->val.backing = efl_text_background_type_get(rp->object);
357
     }
358
#define STYLE_COLOR_COLLECT(x, X) \
359
   if (eud->u.text_style.types & EDJE_PART_TEXT_PROP_COLOR_ ##X) \
360
     { \
361
        Edje_Part_Text_Prop *prop; \
362
        prop = _prop_new(props, EDJE_PART_TEXT_PROP_COLOR_ ##X); \
363
        efl_ ##x ##_color_get(rp->object, \
364
              &prop->val.color.r, &prop->val.color.g, \
365
              &prop->val.color.b, &prop->val.color.a); \
366
     } \
367

368
      STYLE_COLOR_COLLECT(text_background, BACKING)
369
      STYLE_COLOR_COLLECT(text_glow, GLOW)
370
      STYLE_COLOR_COLLECT(text_secondary_glow, GLOW2)
371
      STYLE_COLOR_COLLECT(text, NORMAL)
372
      STYLE_COLOR_COLLECT(text_outline, OUTLINE)
373
      STYLE_COLOR_COLLECT(text_shadow, SHADOW)
374
      STYLE_COLOR_COLLECT(text_strikethrough, STRIKETHROUGH)
375
      STYLE_COLOR_COLLECT(text_underline, UNDERLINE)
376
      STYLE_COLOR_COLLECT(text_secondary_underline, UNDERLINE2)
377
      STYLE_COLOR_COLLECT(text_underline_dashed, UNDERLINE_DASHED)
378
#undef STYLE_COLOR_COLLECT
379

380
      if (eud->u.text_style.types & EDJE_PART_TEXT_PROP_EFFECT_TYPE)
381
        {
382
           Edje_Part_Text_Prop *prop;
383

384
           prop = _prop_new(props, EDJE_PART_TEXT_PROP_EFFECT_TYPE);
385
           prop->val.effect = efl_text_effect_type_get(rp->object);
386
        }
387

388
   if (eud->u.text_style.types & EDJE_PART_TEXT_PROP_ELLIPSIS)
389
     {
390
        Edje_Part_Text_Prop *prop;
391

392
        prop = _prop_new(props, EDJE_PART_TEXT_PROP_ELLIPSIS);
393
        prop->val.nd = efl_text_ellipsis_get(rp->object);
394
     }
395

396
   if (eud->u.text_style.types & EDJE_PART_TEXT_PROP_FONT)
397
     {
398
        Edje_Part_Text_Prop *prop;
399

400
        prop = _prop_new(props, EDJE_PART_TEXT_PROP_FONT);
401
        prop->val.font.font = efl_text_font_family_get(rp->object);
402
        prop->val.font.size = efl_text_font_size_get(rp->object);
403
     }
404

405
   if (eud->u.text_style.types & EDJE_PART_TEXT_PROP_SHADOW_DIRECTION)
406
     {
407
        Edje_Part_Text_Prop *prop;
408

409
        prop = _prop_new(props, EDJE_PART_TEXT_PROP_SHADOW_DIRECTION);
410
        prop->val.shadow = efl_text_shadow_direction_get(rp->object);
411
     }
412

413
   if (eud->u.text_style.types & EDJE_PART_TEXT_PROP_STRIKETHROUGH_TYPE)
414
     {
415
        Edje_Part_Text_Prop *prop;
416

417
        prop = _prop_new(props, EDJE_PART_TEXT_PROP_STRIKETHROUGH_TYPE);
418
        prop->val.strikethrough_type = efl_text_strikethrough_type_get(rp->object);
419
     }
420

421
   if (eud->u.text_style.types & EDJE_PART_TEXT_PROP_UNDERLINE_DASHED_GAP)
422
     {
423
        Edje_Part_Text_Prop *prop;
424

425
        prop = _prop_new(props, EDJE_PART_TEXT_PROP_UNDERLINE_DASHED_GAP);
426
        prop->val.ni = efl_text_underline_dashed_gap_get(rp->object);
427
     }
428

429
   if (eud->u.text_style.types & EDJE_PART_TEXT_PROP_UNDERLINE_DASHED_WIDTH)
430
     {
431
        Edje_Part_Text_Prop *prop;
432

433
        prop = _prop_new(props, EDJE_PART_TEXT_PROP_UNDERLINE_DASHED_WIDTH);
434
        prop->val.ni = efl_text_underline_dashed_width_get(rp->object);
435
     }
436

437
   if (eud->u.text_style.types & EDJE_PART_TEXT_PROP_UNDERLINE_TYPE)
438
     {
439
        Edje_Part_Text_Prop *prop;
440

441
        prop = _prop_new(props, EDJE_PART_TEXT_PROP_UNDERLINE_TYPE);
442
        prop->val.ni = efl_text_underline_type_get(rp->object);
443
     }
444

445
   if (eud->u.text_style.types & EDJE_PART_TEXT_PROP_UNDERLINE_HEIGHT)
446
     {
447
        Edje_Part_Text_Prop *prop;
448

449
        prop = _prop_new(props, EDJE_PART_TEXT_PROP_UNDERLINE_HEIGHT);
450
        prop->val.ni = efl_text_underline_height_get(rp->object);
451
     }
452

453
   if (eud->u.text_style.types & EDJE_PART_TEXT_PROP_WRAP)
454
     {
455
        Edje_Part_Text_Prop *prop;
456

457
        prop = _prop_new(props, EDJE_PART_TEXT_PROP_WRAP);
458
        prop->val.wrap = efl_text_wrap_get(rp->object);
459

460
     }
461
}
462

463
void
464
_canvas_layout_user_text_apply(Edje_User_Defined *eud, Eo *obj,
465
      Edje_Part_Text_Prop *prop)
466
{
467
   switch (prop->type)
468
     {
469

470
      case EDJE_PART_TEXT_PROP_BACKING_TYPE:
471
        efl_text_background_type_set(
472
              efl_part(obj,
473
                 eud->part),
474
              prop->val.backing);
475
        break;
476

477
#define STYLE_COLOR_CASE(x, X) \
478
      case EDJE_PART_TEXT_PROP_COLOR_##X : \
479
        efl_##x ##_color_set(efl_part(obj, \
480
                 eud->part), \
481
                 prop->val.color.r, \
482
                 prop->val.color.g, \
483
                 prop->val.color.b, \
484
                 prop->val.color.a); \
485
        break;
486

487
      STYLE_COLOR_CASE(text_background, BACKING)
488
      STYLE_COLOR_CASE(text_glow, GLOW)
489
      STYLE_COLOR_CASE(text_secondary_glow, GLOW2)
490
      STYLE_COLOR_CASE(text, NORMAL)
491
      STYLE_COLOR_CASE(text_outline, OUTLINE)
492
      STYLE_COLOR_CASE(text_shadow, SHADOW)
493
      STYLE_COLOR_CASE(text_strikethrough, STRIKETHROUGH)
494
      STYLE_COLOR_CASE(text_underline, UNDERLINE)
495
      STYLE_COLOR_CASE(text_secondary_underline, UNDERLINE2)
496
      STYLE_COLOR_CASE(text_underline_dashed, UNDERLINE_DASHED)
497
#undef STYLE_COLOR_CASE
498

499
      case EDJE_PART_TEXT_PROP_EFFECT_TYPE:
500
        efl_text_effect_type_set(
501
              efl_part(obj,
502
                 eud->part),
503
              prop->val.effect);
504
        break;
505

506
      case EDJE_PART_TEXT_PROP_ELLIPSIS:
507
        efl_text_ellipsis_set(efl_part(obj,
508
                 eud->part),
509
              prop->val.nd);
510
        break;
511

512
      case EDJE_PART_TEXT_PROP_FONT:
513
        efl_text_font_family_set(efl_part(obj,
514
                 eud->part),
515
              prop->val.font.font);
516
        efl_text_font_size_set(efl_part(obj,
517
                 eud->part),
518
              prop->val.font.size);
519
        break;
520

521
      case EDJE_PART_TEXT_PROP_SHADOW_DIRECTION:
522
        efl_text_shadow_direction_set(
523
              efl_part(obj,
524
                 eud->part),
525
              prop->val.shadow);
526
        break;
527

528
      case EDJE_PART_TEXT_PROP_STRIKETHROUGH_TYPE:
529
        efl_text_strikethrough_type_set(
530
              efl_part(obj,
531
                 eud->part),
532
              prop->val.strikethrough_type);
533
        break;
534

535
      case EDJE_PART_TEXT_PROP_UNDERLINE_DASHED_WIDTH:
536
        efl_text_underline_dashed_width_set(
537
              efl_part(obj,
538
                 eud->part),
539
              prop->val.ni);
540
        break;
541

542
      case EDJE_PART_TEXT_PROP_UNDERLINE_DASHED_GAP:
543
        efl_text_underline_dashed_gap_set(
544
              efl_part(obj,
545
                 eud->part),
546
              prop->val.ni);
547
        break;
548

549
      case EDJE_PART_TEXT_PROP_UNDERLINE_TYPE:
550
        efl_text_underline_type_set(
551
              efl_part(obj,
552
                 eud->part),
553
              prop->val.underline_type);
554
        break;
555

556
      case EDJE_PART_TEXT_PROP_UNDERLINE_HEIGHT:
557
        efl_text_underline_height_set(
558
              efl_part(obj,
559
                 eud->part),
560
              prop->val.nd);
561
        break;
562

563
      case EDJE_PART_TEXT_PROP_WRAP:
564
        efl_text_wrap_set(efl_part(obj,
565
                 eud->part),
566
              prop->val.wrap);
567
        break;
568

569
      default:
570
        break;
571
     }
572
}
573

574

575
EOLIAN static void
576
_efl_canvas_layout_part_text_text_expand_set(Eo *obj,
577
      void *_pd EINA_UNUSED,
578
      Efl_Canvas_Layout_Part_Text_Expand type)
579
{
580
   Edje_User_Defined *eud;
581

582
   PROXY_DATA_GET(obj, pd);
583
   if (pd->rp->part->type == EDJE_PART_TYPE_TEXT) return;
584

585
   eud = _edje_user_text_expand_definition_fetch(pd->ed, pd->part);
586
   eud->u.text_expand.expand = type;
587
   pd->rp->typedata.text->expand = type;
588

589
}
590

591
EOLIAN static Efl_Canvas_Layout_Part_Text_Expand
592
_efl_canvas_layout_part_text_text_expand_get(const Eo *obj,
593
      void *_pd EINA_UNUSED)
594
{
595
   PROXY_DATA_GET(obj, pd);
596
   return pd->rp->typedata.text->expand;
597
}
598

599
#include "efl_canvas_layout_part_text.eo.c"
600

601