1
/**
2
 * @file lv_rect.c
3
 *
4
 */
5

6
/*********************
7
 *      INCLUDES
8
 *********************/
9
#include "lv_label.h"
10
#if USE_LV_LABEL != 0
11

12
#include "../lv_core/lv_obj.h"
13
#include "../lv_core/lv_group.h"
14
#include "../lv_core/lv_lang.h"
15
#include "../lv_draw/lv_draw.h"
16
#include "../lv_misc/lv_color.h"
17
#include "../lv_misc/lv_math.h"
18

19
/*********************
20
 *      DEFINES
21
 *********************/
22
/*Test configurations*/
23
#ifndef LV_LABEL_SCROLL_SPEED
24
#define LV_LABEL_SCROLL_SPEED       (25) /*Hor, or ver. scroll speed (px/sec) in 'LV_LABEL_LONG_SCROLL/ROLL' mode*/
25
#endif
26

27
#define ANIM_WAIT_CHAR_COUNT 3
28

29
#define LV_LABEL_DOT_END_INV 0xFFFF
30

31
/**********************
32
 *      TYPEDEFS
33
 **********************/
34

35
/**********************
36
 *  STATIC PROTOTYPES
37
 **********************/
38
static lv_res_t lv_label_signal(lv_obj_t * label, lv_signal_t sign, void * param);
39
static bool lv_label_design(lv_obj_t * label, const lv_area_t * mask, lv_design_mode_t mode);
40
static void lv_label_refr_text(lv_obj_t * label);
41
static void lv_label_revert_dots(lv_obj_t * label);
42

43
#if USE_LV_ANIMATION
44
static void lv_label_set_offset_x(lv_obj_t * label, lv_coord_t x);
45
static void lv_label_set_offset_y(lv_obj_t * label, lv_coord_t y);
46
#endif
47
/**********************
48
 *  STATIC VARIABLES
49
 **********************/
50
static lv_signal_func_t ancestor_signal;
51

52
/**********************
53
 *      MACROS
54
 **********************/
55

56
/**********************
57
 *   GLOBAL FUNCTIONS
58
 **********************/
59

60
/**
61
 * Create a label objects
62
 * @param par pointer to an object, it will be the parent of the new label
63
 * @param copy pointer to a button object, if not NULL then the new object will be copied from it
64
 * @return pointer to the created button
65
 */
66
lv_obj_t * lv_label_create(lv_obj_t * par, const lv_obj_t * copy)
67
{
68
    LV_LOG_TRACE("label create started");
69

70
    /*Create a basic object*/
71
    lv_obj_t * new_label = lv_obj_create(par, copy);
72
    lv_mem_assert(new_label);
73
    if(new_label == NULL) return NULL;
74

75
    if(ancestor_signal == NULL) ancestor_signal = lv_obj_get_signal_func(new_label);
76

77
    /*Extend the basic object to a label object*/
78
    lv_obj_allocate_ext_attr(new_label, sizeof(lv_label_ext_t));
79

80
    lv_label_ext_t * ext = lv_obj_get_ext_attr(new_label);
81
    lv_mem_assert(ext);
82
    if(ext == NULL) return NULL;
83

84
    ext->text = NULL;
85
    ext->static_txt = 0;
86
    ext->recolor = 0;
87
    ext->body_draw = 0;
88
    ext->align = LV_LABEL_ALIGN_LEFT;
89
    ext->dot_end = LV_LABEL_DOT_END_INV;
90
    ext->long_mode = LV_LABEL_LONG_EXPAND;
91
    ext->anim_speed = LV_LABEL_SCROLL_SPEED;
92
    ext->offset.x = 0;
93
    ext->offset.y = 0;
94
#if USE_LV_MULTI_LANG
95
    ext->lang_txt_id = LV_LANG_TXT_ID_NONE;
96
#endif
97
    lv_obj_set_design_func(new_label, lv_label_design);
98
    lv_obj_set_signal_func(new_label, lv_label_signal);
99

100
    /*Init the new label*/
101
    if(copy == NULL) {
102
        lv_obj_set_click(new_label, false);
103
        lv_label_set_long_mode(new_label, LV_LABEL_LONG_EXPAND);
104
        lv_label_set_text(new_label, "Text");
105
        lv_label_set_style(new_label, NULL);        /*Inherit parent's style*/
106
    }
107
    /*Copy 'copy' if not NULL*/
108
    else {
109
        lv_label_ext_t * copy_ext = lv_obj_get_ext_attr(copy);
110
        lv_label_set_long_mode(new_label, lv_label_get_long_mode(copy));
111
        lv_label_set_recolor(new_label, lv_label_get_recolor(copy));
112
        lv_label_set_body_draw(new_label, lv_label_get_body_draw(copy));
113
        lv_label_set_align(new_label, lv_label_get_align(copy));
114
        if(copy_ext->static_txt == 0) lv_label_set_text(new_label, lv_label_get_text(copy));
115
        else lv_label_set_static_text(new_label, lv_label_get_text(copy));
116

117
        /*In DOT mode save the text byte-to-byte because a '\0' can be in the middle*/
118
        if(copy_ext->long_mode == LV_LABEL_LONG_DOT) {
119
            ext->text = lv_mem_realloc(ext->text, lv_mem_get_size(copy_ext->text));
120
            lv_mem_assert(ext->text);
121
            if(ext->text == NULL) return NULL;
122
            memcpy(ext->text, copy_ext->text, lv_mem_get_size(copy_ext->text));
123
        }
124

125
        memcpy(ext->dot_tmp, copy_ext->dot_tmp, sizeof(ext->dot_tmp));
126
        ext->dot_end = copy_ext->dot_end;
127

128
        /*Refresh the style with new signal function*/
129
        lv_obj_refresh_style(new_label);
130
    }
131

132

133
    LV_LOG_INFO("label created");
134

135
    return new_label;
136
}
137

138
/*=====================
139
 * Setter functions
140
 *====================*/
141

142
/**
143
 * Set a new text for a label. Memory will be allocated to store the text by the label.
144
 * @param label pointer to a label object
145
 * @param text '\0' terminated character string. NULL to refresh with the current text.
146
 */
147
void lv_label_set_text(lv_obj_t * label, const char * text)
148
{
149
    lv_obj_invalidate(label);
150

151
    lv_label_ext_t * ext = lv_obj_get_ext_attr(label);
152

153
    /*If text is NULL then refresh */
154
    if(text == NULL) {
155
        lv_label_refr_text(label);
156
        return;
157
    }
158

159
    if(ext->text == text && ext->static_txt == 0) {
160
        /*If set its own text then reallocate it (maybe its size changed)*/
161
        ext->text = lv_mem_realloc(ext->text, strlen(ext->text) + 1);
162
        lv_mem_assert(ext->text);
163
        if(ext->text == NULL) return;
164
    } else {
165
        /*Allocate space for the new text*/
166
        uint32_t len = strlen(text) + 1;
167
        if(ext->text != NULL && ext->static_txt == 0) {
168
            lv_mem_free(ext->text);
169
            ext->text = NULL;
170
        }
171

172
        ext->text = lv_mem_alloc(len);
173
        lv_mem_assert(ext->text);
174
        if(ext->text == NULL) return;
175

176
        strcpy(ext->text, text);
177
        ext->static_txt = 0;    /*Now the text is dynamically allocated*/
178
    }
179

180
    lv_label_refr_text(label);
181
}
182

183
/**
184
 * Set a new text for a label from a character array. The array don't has to be '\0' terminated.
185
 * Memory will be allocated to store the array by the label.
186
 * @param label pointer to a label object
187
 * @param array array of characters or NULL to refresh the label
188
 * @param size the size of 'array' in bytes
189
 */
190
void lv_label_set_array_text(lv_obj_t * label, const char * array, uint16_t size)
191
{
192
    lv_obj_invalidate(label);
193

194
    lv_label_ext_t * ext = lv_obj_get_ext_attr(label);
195

196
    /*If trying to set its own text or the array is NULL then refresh */
197
    if(array == ext->text || array == NULL) {
198
        lv_label_refr_text(label);
199
        return;
200
    }
201

202
    /*Allocate space for the new text*/
203
    if(ext->text != NULL && ext->static_txt == 0) {
204
        lv_mem_free(ext->text);
205
        ext->text = NULL;
206
    }
207
    ext->text = lv_mem_alloc(size + 1);
208
    lv_mem_assert(ext->text);
209
    if(ext->text == NULL) return;
210

211
    memcpy(ext->text, array, size);
212
    ext->text[size] = '\0';
213
    ext->static_txt = 0;    /*Now the text is dynamically allocated*/
214

215
    lv_label_refr_text(label);
216
}
217

218
/**
219
 * Set a static text. It will not be saved by the label so the 'text' variable
220
 * has to be 'alive' while the label exist.
221
 * @param label pointer to a label object
222
 * @param text pointer to a text. NULL to refresh with the current text.
223
 */
224
void lv_label_set_static_text(lv_obj_t * label, const char * text)
225
{
226
    lv_label_ext_t * ext = lv_obj_get_ext_attr(label);
227
    if(ext->static_txt == 0 && ext->text != NULL) {
228
        lv_mem_free(ext->text);
229
        ext->text = NULL;
230
    }
231

232
    if(text != NULL) {
233
        ext->static_txt = 1;
234
        ext->text = (char *) text;
235
    }
236

237
    lv_label_refr_text(label);
238
}
239

240
#if USE_LV_MULTI_LANG
241
/**
242
 *Set a text ID which refers a the same text but in a different languages
243
 * @param label pointer to a label object
244
 * @param txt_id ID of the text
245
 */
246
void lv_label_set_text_id(lv_obj_t * label, uint32_t txt_id)
247
{
248
    lv_label_ext_t * ext = lv_obj_get_ext_attr(label);
249
    ext->lang_txt_id = txt_id;
250

251
    /*Apply the new language*/
252
    label->signal_func(label, LV_SIGNAL_LANG_CHG, NULL);
253
}
254
#endif
255

256
/**
257
 * Set the behavior of the label with longer text then the object size
258
 * @param label pointer to a label object
259
 * @param long_mode the new mode from 'lv_label_long_mode' enum.
260
 *                  In LV_LONG_BREAK/LONG/ROLL the size of the label should be set AFTER this function
261
 */
262
void lv_label_set_long_mode(lv_obj_t * label, lv_label_long_mode_t long_mode)
263
{
264
    lv_label_ext_t * ext = lv_obj_get_ext_attr(label);
265

266
#if USE_LV_ANIMATION
267
    /*Delete the old animation (if exists)*/
268
    lv_anim_del(label, (lv_anim_fp_t) lv_obj_set_x);
269
    lv_anim_del(label, (lv_anim_fp_t) lv_obj_set_y);
270
    lv_anim_del(label, (lv_anim_fp_t) lv_label_set_offset_x);
271
    lv_anim_del(label, (lv_anim_fp_t) lv_label_set_offset_y);
272
#endif
273
    ext->offset.x = 0;
274
    ext->offset.y = 0;
275

276
    if(long_mode == LV_LABEL_LONG_ROLL || long_mode == LV_LABEL_LONG_CROP) ext->expand = 1;
277
    else ext->expand = 0;
278

279
    /*Restore the character under the dots*/
280
    if(ext->long_mode == LV_LABEL_LONG_DOT && ext->dot_end != LV_LABEL_DOT_END_INV) {
281
        lv_label_revert_dots(label);
282
    }
283

284
    ext->long_mode = long_mode;
285
    lv_label_refr_text(label);
286
}
287

288
/**
289
 * Set the align of the label (left or center)
290
 * @param label pointer to a label object
291
 * @param align 'LV_LABEL_ALIGN_LEFT' or 'LV_LABEL_ALIGN_LEFT'
292
 */
293
void lv_label_set_align(lv_obj_t * label, lv_label_align_t align)
294
{
295
    lv_label_ext_t * ext = lv_obj_get_ext_attr(label);
296
    if(ext->align == align) return;
297

298
    ext->align = align;
299

300
    lv_obj_invalidate(label);       /*Enough to invalidate because alignment is only drawing related (lv_refr_label_text() not required)*/
301
}
302

303
/**
304
 * Enable the recoloring by in-line commands
305
 * @param label pointer to a label object
306
 * @param en true: enable recoloring, false: disable
307
 */
308
void lv_label_set_recolor(lv_obj_t * label, bool en)
309
{
310
    lv_label_ext_t * ext = lv_obj_get_ext_attr(label);
311
    if(ext->recolor == en) return;
312

313
    ext->recolor = en == false ? 0 : 1;
314

315
    lv_label_refr_text(label);  /*Refresh the text because the potential colo codes in text needs to be hided or revealed*/
316
}
317

318
/**
319
 * Set the label to draw (or not draw) background specified in its style's body
320
 * @param label pointer to a label object
321
 * @param en true: draw body; false: don't draw body
322
 */
323
void lv_label_set_body_draw(lv_obj_t * label, bool en)
324
{
325
    lv_label_ext_t * ext = lv_obj_get_ext_attr(label);
326
    if(ext->body_draw == en) return;
327

328
    ext->body_draw = en == false ? 0 : 1;
329

330
    lv_obj_refresh_ext_size(label);
331

332
    lv_obj_invalidate(label);
333
}
334

335
/**
336
 * Set the label's animation speed in LV_LABEL_LONG_ROLL and SCROLL modes
337
 * @param label pointer to a label object
338
 * @param anim_speed speed of animation in px/sec unit
339
 */
340
void lv_label_set_anim_speed(lv_obj_t * label, uint16_t anim_speed)
341
{
342
    lv_label_ext_t * ext = lv_obj_get_ext_attr(label);
343
    if(ext->anim_speed == anim_speed) return;
344

345
    ext->anim_speed = anim_speed;
346

347
    if(ext->long_mode == LV_LABEL_LONG_ROLL || ext->long_mode == LV_LABEL_LONG_SCROLL) {
348
        lv_label_refr_text(label);
349
    }
350
}
351

352
/*=====================
353
 * Getter functions
354
 *====================*/
355

356
/**
357
 * Get the text of a label
358
 * @param label pointer to a label object
359
 * @return the text of the label
360
 */
361
char * lv_label_get_text(const lv_obj_t * label)
362
{
363
    lv_label_ext_t * ext = lv_obj_get_ext_attr(label);
364

365
    return ext->text;
366
}
367

368
#if USE_LV_MULTI_LANG
369
/**
370
 * Get the text ID of the label. (Used by the multi-language feature)
371
 * @param label pointer to a label object
372
 * @return ID of the text
373
 */
374
uint16_t lv_label_get_text_id(lv_obj_t * label)
375
{
376
    lv_label_ext_t * ext = lv_obj_get_ext_attr(label);
377
    return ext->lang_txt_id;
378
}
379
#endif
380

381
/**
382
 * Get the long mode of a label
383
 * @param label pointer to a label object
384
 * @return the long mode
385
 */
386
lv_label_long_mode_t lv_label_get_long_mode(const lv_obj_t * label)
387
{
388
    lv_label_ext_t * ext = lv_obj_get_ext_attr(label);
389
    return ext->long_mode;
390
}
391

392
/**
393
 * Get the align attribute
394
 * @param label pointer to a label object
395
 * @return LV_LABEL_ALIGN_LEFT or LV_LABEL_ALIGN_CENTER
396
 */
397
lv_label_align_t lv_label_get_align(const lv_obj_t * label)
398
{
399
    lv_label_ext_t * ext = lv_obj_get_ext_attr(label);
400
    return ext->align;
401
}
402

403
/**
404
 * Get the recoloring attribute
405
 * @param label pointer to a label object
406
 * @return true: recoloring is enabled, false: disable
407
 */
408
bool lv_label_get_recolor(const lv_obj_t * label)
409
{
410
    lv_label_ext_t * ext = lv_obj_get_ext_attr(label);
411
    return ext->recolor == 0 ? false : true;
412
}
413

414
/**
415
 * Get the body draw attribute
416
 * @param label pointer to a label object
417
 * @return true: draw body; false: don't draw body
418
 */
419
bool lv_label_get_body_draw(const lv_obj_t * label)
420
{
421
    lv_label_ext_t * ext = lv_obj_get_ext_attr(label);
422
    return ext->body_draw == 0 ? false : true;
423
}
424

425
/**
426
 * Get the label's animation speed in LV_LABEL_LONG_ROLL and SCROLL modes
427
 * @param label pointer to a label object
428
 * @return speed of animation in px/sec unit
429
 */
430
uint16_t lv_label_get_anim_speed(const lv_obj_t * label)
431
{
432
    lv_label_ext_t * ext = lv_obj_get_ext_attr(label);
433
    return ext->anim_speed;
434
}
435

436
/**
437
 * Get the relative x and y coordinates of a letter
438
 * @param label pointer to a label object
439
 * @param index index of the letter [0 ... text length]. Expressed in character index, not byte index (different in UTF-8)
440
 * @param pos store the result here (E.g. index = 0 gives 0;0 coordinates)
441
 */
442
void lv_label_get_letter_pos(const lv_obj_t * label, uint16_t index, lv_point_t * pos)
443
{
444
    const char * txt = lv_label_get_text(label);
445
    lv_label_ext_t * ext = lv_obj_get_ext_attr(label);
446
    uint32_t line_start = 0;
447
    uint32_t new_line_start = 0;
448
    lv_coord_t max_w = lv_obj_get_width(label);
449
    lv_style_t * style = lv_obj_get_style(label);
450
    const lv_font_t * font = style->text.font;
451
    uint8_t letter_height = lv_font_get_height(font);
452
    lv_coord_t y = 0;
453
    lv_txt_flag_t flag = LV_TXT_FLAG_NONE;
454

455
    if(ext->recolor != 0) flag |= LV_TXT_FLAG_RECOLOR;
456
    if(ext->expand != 0) flag |= LV_TXT_FLAG_EXPAND;
457
    if(ext->align == LV_LABEL_ALIGN_CENTER) flag |= LV_TXT_FLAG_CENTER;
458

459
    /*If the width will be expanded  the set the max length to very big */
460
    if(ext->long_mode == LV_LABEL_LONG_EXPAND || ext->long_mode == LV_LABEL_LONG_SCROLL) {
461
        max_w = LV_COORD_MAX;
462
    }
463

464
    index = lv_txt_encoded_get_byte_id(txt, index);
465

466
    /*Search the line of the index letter */;
467
    while(txt[new_line_start] != '\0') {
468
        new_line_start += lv_txt_get_next_line(&txt[line_start], font, style->text.letter_space, max_w, flag);
469
        if(index < new_line_start || txt[new_line_start] == '\0') break; /*The line of 'index' letter begins at 'line_start'*/
470

471
        y += letter_height + style->text.line_space;
472
        line_start = new_line_start;
473
    }
474

475
    /*If the last character is line break then go to the next line*/
476
    if(index > 0) {
477
        if((txt[index - 1] == '\n' || txt[index - 1] == '\r') && txt[index] == '\0') {
478
            y += letter_height + style->text.line_space;
479
            line_start = index;
480
        }
481
    }
482

483
    /*Calculate the x coordinate*/
484
    lv_coord_t x = lv_txt_get_width(&txt[line_start], index - line_start,
485
                            font, style->text.letter_space, flag);
486

487
    if(index != line_start) x += style->text.letter_space;
488

489
    if(ext->align == LV_LABEL_ALIGN_CENTER) {
490
        lv_coord_t line_w;
491
        line_w = lv_txt_get_width(&txt[line_start], new_line_start - line_start,
492
                                  font, style->text.letter_space, flag);
493
        x += lv_obj_get_width(label) / 2 - line_w / 2;
494

495
    } else if(ext->align == LV_LABEL_ALIGN_RIGHT) {
496
        lv_coord_t line_w;
497
        line_w = lv_txt_get_width(&txt[line_start], new_line_start - line_start,
498
                                  font, style->text.letter_space, flag);
499

500
        x += lv_obj_get_width(label) - line_w;
501
    }
502
    pos->x = x;
503
    pos->y = y;
504
}
505

506
/**
507
 * Get the index of letter on a relative point of a label
508
 * @param label pointer to label object
509
 * @param pos pointer to point with coordinates on a the label
510
 * @return the index of the letter on the 'pos_p' point (E.g. on 0;0 is the 0. letter)
511
 * Expressed in character index and not byte index (different in UTF-8)
512
 */
513
uint16_t lv_label_get_letter_on(const lv_obj_t * label, lv_point_t * pos)
514
{
515
    const char * txt = lv_label_get_text(label);
516
    lv_label_ext_t * ext = lv_obj_get_ext_attr(label);
517
    uint32_t line_start = 0;
518
    uint32_t new_line_start = 0;
519
    lv_coord_t max_w = lv_obj_get_width(label);
520
    lv_style_t * style = lv_obj_get_style(label);
521
    const lv_font_t * font = style->text.font;
522
    uint8_t letter_height = lv_font_get_height(font);
523
    lv_coord_t y = 0;
524
    lv_txt_flag_t flag = LV_TXT_FLAG_NONE;
525

526
    if(ext->recolor != 0) flag |= LV_TXT_FLAG_RECOLOR;
527
    if(ext->expand != 0) flag |= LV_TXT_FLAG_EXPAND;
528
    if(ext->align == LV_LABEL_ALIGN_CENTER) flag |= LV_TXT_FLAG_CENTER;
529

530
    /*If the width will be expanded set the max length to very big */
531
    if(ext->long_mode == LV_LABEL_LONG_EXPAND || ext->long_mode == LV_LABEL_LONG_SCROLL) {
532
        max_w = LV_COORD_MAX;
533
    }
534

535
    /*Search the line of the index letter */;
536
    while(txt[line_start] != '\0') {
537
        new_line_start += lv_txt_get_next_line(&txt[line_start], font, style->text.letter_space, max_w, flag);
538

539
        if(pos->y <= y + letter_height) break; /*The line is found (stored in 'line_start')*/
540
        y += letter_height + style->text.line_space;
541

542
        line_start = new_line_start;
543
    }
544

545
    /*Calculate the x coordinate*/
546
    lv_coord_t x = 0;
547
    if(ext->align == LV_LABEL_ALIGN_CENTER) {
548
        lv_coord_t line_w;
549
        line_w = lv_txt_get_width(&txt[line_start], new_line_start - line_start,
550
                                  font, style->text.letter_space, flag);
551
        x += lv_obj_get_width(label) / 2 - line_w / 2;
552
    }
553

554
    lv_txt_cmd_state_t cmd_state = LV_TXT_CMD_STATE_WAIT;
555
    uint32_t i = line_start;
556
    uint32_t i_current = i;
557
    uint32_t letter;
558
    while(i < new_line_start - 1) {
559
        letter = lv_txt_encoded_next(txt, &i);    /*Be careful 'i' already points to the next character*/
560
        /*Handle the recolor command*/
561
        if((flag & LV_TXT_FLAG_RECOLOR) != 0) {
562
            if(lv_txt_is_cmd(&cmd_state, txt[i]) != false) {
563
                continue; /*Skip the letter is it is part of a command*/
564
            }
565
        }
566

567
        x += lv_font_get_width(font, letter);
568
        if(pos->x < x) {
569
            i = i_current;
570
            break;
571
        }
572
        x += style->text.letter_space;
573
        i_current = i;
574
    }
575

576
    return lv_encoded_get_char_id(txt, i);
577
}
578

579

580
/*=====================
581
 * Other functions
582
 *====================*/
583

584
/**
585
 * Insert a text to the label. The label text can not be static.
586
 * @param label pointer to a label object
587
 * @param pos character index to insert. Expressed in character index and not byte index (Different in UTF-8)
588
 *            0: before first char.
589
 *            LV_LABEL_POS_LAST: after last char.
590
 * @param txt pointer to the text to insert
591
 */
592
void lv_label_ins_text(lv_obj_t * label, uint32_t pos,  const char * txt)
593
{
594
    lv_label_ext_t * ext = lv_obj_get_ext_attr(label);
595

596
    /*Can not append to static text*/
597
    if(ext->static_txt != 0) return;
598

599
    lv_obj_invalidate(label);
600

601
    /*Allocate space for the new text*/
602
    uint32_t old_len = strlen(ext->text);
603
    uint32_t ins_len = strlen(txt);
604
    uint32_t new_len = ins_len + old_len;
605
    ext->text = lv_mem_realloc(ext->text, new_len + 1);
606
    lv_mem_assert(ext->text);
607
    if(ext->text == NULL) return;
608

609
    if(pos == LV_LABEL_POS_LAST) {
610
#if LV_TXT_UTF8 == 0
611
        pos = old_len;
612
#else
613
        pos = lv_txt_get_encoded_length(ext->text);
614
#endif
615
    }
616

617
    lv_txt_ins(ext->text, pos, txt);
618

619
    lv_label_refr_text(label);
620
}
621

622
/**
623
 * Delete characters from a label. The label text can not be static.
624
 * @param label pointer to a label object
625
 * @param pos character index to insert. Expressed in character index and not byte index (Different in UTF-8)
626
 *            0: before first char.
627
 * @param cnt number of characters to cut
628
 */
629
void lv_label_cut_text(lv_obj_t * label, uint32_t pos,  uint32_t cnt)
630
{
631
    lv_label_ext_t * ext = lv_obj_get_ext_attr(label);
632

633
    /*Can not append to static text*/
634
    if(ext->static_txt != 0) return;
635

636
    lv_obj_invalidate(label);
637

638
    char * label_txt = lv_label_get_text(label);
639
    /*Delete the characters*/
640
    lv_txt_cut(label_txt, pos, cnt);
641

642
    /*Refresh the label*/
643
    lv_label_refr_text(label);
644
}
645

646
/**********************
647
 *   STATIC FUNCTIONS
648
 **********************/
649

650
/**
651
 * Handle the drawing related tasks of the labels
652
 * @param label pointer to a label object
653
 * @param mask the object will be drawn only in this area
654
 * @param mode LV_DESIGN_COVER_CHK: only check if the object fully covers the 'mask_p' area
655
 *                                  (return 'true' if yes)
656
 *             LV_DESIGN_DRAW: draw the object (always return 'true')
657
 *             LV_DESIGN_DRAW_POST: drawing after every children are drawn
658
 * @param return true/false, depends on 'mode'
659
 */
660
static bool lv_label_design(lv_obj_t * label, const lv_area_t * mask, lv_design_mode_t mode)
661
{
662
    /* A label never covers an area */
663
    if(mode == LV_DESIGN_COVER_CHK) return false;
664
    else if(mode == LV_DESIGN_DRAW_MAIN) {
665
        lv_area_t coords;
666
        lv_style_t * style = lv_obj_get_style(label);
667
        lv_opa_t opa_scale = lv_obj_get_opa_scale(label);
668
        lv_obj_get_coords(label, &coords);
669

670
#if USE_LV_GROUP
671
        lv_group_t * g = lv_obj_get_group(label);
672
        if(lv_group_get_focused(g) == label) {
673
            lv_draw_rect(&coords, mask, style, opa_scale);
674
        }
675
#endif
676

677
        lv_label_ext_t * ext = lv_obj_get_ext_attr(label);
678

679
        if(ext->body_draw) {
680
            lv_area_t bg;
681
            lv_obj_get_coords(label, &bg);
682
            bg.x1 -= style->body.padding.hor;
683
            bg.x2 += style->body.padding.hor;
684
            bg.y1 -= style->body.padding.ver;
685
            bg.y2 += style->body.padding.ver;
686

687
            lv_draw_rect(&bg, mask, style, lv_obj_get_opa_scale(label));
688
        }
689

690
        /*TEST: draw a background for the label*/
691
        //lv_draw_rect(&label->coords, mask, &lv_style_plain_color, LV_OPA_COVER);
692

693
        lv_txt_flag_t flag = LV_TXT_FLAG_NONE;
694
        if(ext->recolor != 0) flag |= LV_TXT_FLAG_RECOLOR;
695
        if(ext->expand != 0) flag |= LV_TXT_FLAG_EXPAND;
696
        if(ext->align == LV_LABEL_ALIGN_CENTER) flag |= LV_TXT_FLAG_CENTER;
697
        if(ext->align == LV_LABEL_ALIGN_RIGHT) flag |= LV_TXT_FLAG_RIGHT;
698

699
        /* In ROLL mode the CENTER and RIGHT are pointless so remove them.
700
         * (In addition they will result mis-alignment is this case)*/
701
        if((ext->long_mode == LV_LABEL_LONG_ROLL) &&
702
                (ext->align == LV_LABEL_ALIGN_CENTER || ext->align == LV_LABEL_ALIGN_RIGHT)) {
703
            lv_point_t size;
704
            lv_txt_get_size(&size, ext->text, style->text.font, style->text.letter_space, style->text.line_space, LV_COORD_MAX, flag);
705
            if(size.x > lv_obj_get_width(label)) {
706
                flag &= ~LV_TXT_FLAG_RIGHT;
707
                flag &= ~LV_TXT_FLAG_CENTER;
708
            }
709
        }
710

711
        lv_draw_label(&coords, mask, style, opa_scale, ext->text, flag, &ext->offset);
712
    }
713
    return true;
714
}
715

716

717

718
/**
719
 * Signal function of the label
720
 * @param label pointer to a label object
721
 * @param sign a signal type from lv_signal_t enum
722
 * @param param pointer to a signal specific variable
723
 * @return LV_RES_OK: the object is not deleted in the function; LV_RES_INV: the object is deleted
724
 */
725
static lv_res_t lv_label_signal(lv_obj_t * label, lv_signal_t sign, void * param)
726
{
727
    lv_res_t res;
728

729
    /* Include the ancient signal function */
730
    res = ancestor_signal(label, sign, param);
731
    if(res != LV_RES_OK) return res;
732

733
    lv_label_ext_t * ext = lv_obj_get_ext_attr(label);
734
    if(sign ==  LV_SIGNAL_CLEANUP) {
735
        if(ext->static_txt == 0) {
736
            lv_mem_free(ext->text);
737
            ext->text = NULL;
738
        }
739
    } else if(sign == LV_SIGNAL_STYLE_CHG) {
740
        /*Revert dots for proper refresh*/
741
        lv_label_revert_dots(label);
742

743
        lv_label_refr_text(label);
744
    } else if(sign == LV_SIGNAL_CORD_CHG) {
745
        if(lv_area_get_width(&label->coords) != lv_area_get_width(param) ||
746
                lv_area_get_height(&label->coords) != lv_area_get_height(param)) {
747
            lv_label_revert_dots(label);
748
            lv_label_refr_text(label);
749
        }
750
    } else if(sign == LV_SIGNAL_REFR_EXT_SIZE) {
751
        if(ext->body_draw) {
752
            lv_style_t * style = lv_label_get_style(label);
753
            label->ext_size = LV_MATH_MAX(label->ext_size, style->body.padding.hor);
754
            label->ext_size = LV_MATH_MAX(label->ext_size, style->body.padding.ver);
755
        }
756
    } else if(sign == LV_SIGNAL_LANG_CHG) {
757
#if USE_LV_MULTI_LANG
758
        if(ext->lang_txt_id != LV_LANG_TXT_ID_NONE) {
759
            const char * lang_txt = lv_lang_get_text(ext->lang_txt_id);
760
            if(lang_txt) {
761
                lv_label_set_text(label, lang_txt);
762
            } else {
763
                LV_LOG_WARN("lv_lang_get_text return NULL for a label's text");
764
            }
765
        }
766
#endif
767
    } else if(sign == LV_SIGNAL_GET_TYPE) {
768
        lv_obj_type_t * buf = param;
769
        uint8_t i;
770
        for(i = 0; i < LV_MAX_ANCESTOR_NUM - 1; i++) {  /*Find the last set data*/
771
            if(buf->type[i] == NULL) break;
772
        }
773
        buf->type[i] = "lv_label";
774
    }
775

776
    return res;
777
}
778

779
/**
780
 * Refresh the label with its text stored in its extended data
781
 * @param label pointer to a label object
782
 */
783
static void lv_label_refr_text(lv_obj_t * label)
784
{
785
    lv_label_ext_t * ext = lv_obj_get_ext_attr(label);
786

787
    if(ext->text == NULL) return;
788

789
    lv_coord_t max_w = lv_obj_get_width(label);
790
    lv_style_t * style = lv_obj_get_style(label);
791
    const lv_font_t * font = style->text.font;
792

793
    /*If the width will be expanded set the max length to very big */
794
    if(ext->long_mode == LV_LABEL_LONG_EXPAND ||
795
            ext->long_mode == LV_LABEL_LONG_SCROLL) {
796
        max_w = LV_COORD_MAX;
797
    }
798

799
    /*Calc. the height and longest line*/
800
    lv_point_t size;
801
    lv_txt_flag_t flag = LV_TXT_FLAG_NONE;
802
    if(ext->recolor != 0) flag |= LV_TXT_FLAG_RECOLOR;
803
    if(ext->expand != 0) flag |= LV_TXT_FLAG_EXPAND;
804
    lv_txt_get_size(&size, ext->text, font, style->text.letter_space, style->text.line_space, max_w, flag);
805

806
    /*Set the full size in expand mode*/
807
    if(ext->long_mode == LV_LABEL_LONG_EXPAND || ext->long_mode == LV_LABEL_LONG_SCROLL) {
808
        lv_obj_set_size(label, size.x, size.y);
809

810
        /*Start scrolling if the label is greater then its parent*/
811
        if(ext->long_mode == LV_LABEL_LONG_SCROLL) {
812
#if USE_LV_ANIMATION
813
            lv_obj_t * parent = lv_obj_get_parent(label);
814

815
            /*Delete the potential previous scroller animations*/
816
            lv_anim_del(label, (lv_anim_fp_t) lv_obj_set_x);
817
            lv_anim_del(label, (lv_anim_fp_t) lv_obj_set_y);
818

819
            lv_anim_t anim;
820
            anim.var = label;
821
            anim.repeat = 1;
822
            anim.playback = 1;
823
            anim.start = 0;
824
            anim.act_time = 0;
825
            anim.end_cb = NULL;
826
            anim.path = lv_anim_path_linear;
827

828
            anim.playback_pause = (((lv_font_get_width(style->text.font, ' ') +
829
                                     style->text.letter_space) * 1000) / ext->anim_speed) * ANIM_WAIT_CHAR_COUNT;
830
            anim.repeat_pause = anim.playback_pause;
831

832
            if(lv_obj_get_width(label) > lv_obj_get_width(parent)) {
833
                anim.end = lv_obj_get_width(parent) - lv_obj_get_width(label);
834
                anim.fp = (lv_anim_fp_t) lv_obj_set_x;
835
                anim.time = lv_anim_speed_to_time(ext->anim_speed, anim.start, anim.end);
836
                lv_anim_create(&anim);
837
            } else if(lv_obj_get_height(label) > lv_obj_get_height(parent)) {
838
                anim.end =  lv_obj_get_height(parent) - lv_obj_get_height(label) - lv_font_get_height(font);
839
                anim.fp = (lv_anim_fp_t)lv_obj_set_y;
840
                anim.time = lv_anim_speed_to_time(ext->anim_speed, anim.start, anim.end);
841
                lv_anim_create(&anim);
842
            }
843
#endif
844
        }
845
    }
846
    /*In roll mode keep the size but start offset animations*/
847
    else if(ext->long_mode == LV_LABEL_LONG_ROLL) {
848
#if USE_LV_ANIMATION
849
        lv_anim_t anim;
850
        anim.var = label;
851
        anim.repeat = 1;
852
        anim.playback = 1;
853
        anim.start = 0;
854
        anim.act_time = 0;
855
        anim.end_cb = NULL;
856
        anim.path = lv_anim_path_linear;
857
        anim.playback_pause = (((lv_font_get_width(style->text.font, ' ') + style->text.letter_space) * 1000) / ext->anim_speed) * ANIM_WAIT_CHAR_COUNT;
858
        anim.repeat_pause =  anim.playback_pause;
859

860
        bool hor_anim = false;
861
        if(size.x > lv_obj_get_width(label)) {
862
            anim.end = lv_obj_get_width(label) - size.x;
863
            anim.fp = (lv_anim_fp_t) lv_label_set_offset_x;
864
            anim.time = lv_anim_speed_to_time(ext->anim_speed, anim.start, anim.end);
865
            lv_anim_create(&anim);
866
            hor_anim = true;
867
        } else {
868
            /*Delete the offset animation if not required*/
869
            lv_anim_del(label, (lv_anim_fp_t) lv_label_set_offset_x);
870
            ext->offset.x = 0;
871
        }
872

873
        if(size.y > lv_obj_get_height(label) && hor_anim == false) {
874
            anim.end =  lv_obj_get_height(label) - size.y - (lv_font_get_height(font));
875
            anim.fp = (lv_anim_fp_t)lv_label_set_offset_y;
876
            anim.time = lv_anim_speed_to_time(ext->anim_speed, anim.start, anim.end);
877
            lv_anim_create(&anim);
878
        } else {
879
            /*Delete the offset animation if not required*/
880
            lv_anim_del(label, (lv_anim_fp_t) lv_label_set_offset_y);
881
            ext->offset.y = 0;
882
        }
883
#endif
884
    } else if(ext->long_mode == LV_LABEL_LONG_DOT) {
885
        if(size.y <= lv_obj_get_height(label)) {                /*No dots are required, the text is short enough*/
886
            ext->dot_end = LV_LABEL_DOT_END_INV;
887
        } else if(lv_txt_get_encoded_length(ext->text) <= LV_LABEL_DOT_NUM) {     /*Don't turn to dots all the characters*/
888
            ext->dot_end = LV_LABEL_DOT_END_INV;
889
        } else {
890
            lv_point_t p;
891
            p.x = lv_obj_get_width(label) - (lv_font_get_width(style->text.font, '.') + style->text.letter_space) * LV_LABEL_DOT_NUM; /*Shrink with dots*/
892
            p.y = lv_obj_get_height(label);
893
            p.y -= p.y  % (lv_font_get_height(style->text.font) + style->text.line_space);   /*Round down to the last line*/
894
            p.y -= style->text.line_space;                                                      /*Trim the last line space*/
895
            uint32_t letter_id = lv_label_get_letter_on(label, &p);
896

897

898
#if LV_TXT_UTF8 == 0
899
            /*Save letters under the dots and replace them with dots*/
900
            uint8_t i;
901
            for(i = 0; i < LV_LABEL_DOT_NUM; i++)  {
902
                ext->dot_tmp[i] = ext->text[letter_id + i];
903
                ext->text[letter_id + i] = '.';
904
            }
905

906
            ext->dot_tmp[LV_LABEL_DOT_NUM] = ext->text[letter_id + LV_LABEL_DOT_NUM];
907
            ext->text[letter_id + LV_LABEL_DOT_NUM] = '\0';
908

909
            ext->dot_end = letter_id + LV_LABEL_DOT_NUM;
910
#else
911
            /*Save letters under the dots and replace them with dots*/
912
            uint32_t i;
913
            uint32_t byte_id = lv_txt_encoded_get_byte_id(ext->text, letter_id);
914
            uint32_t byte_id_ori = byte_id;
915
            uint8_t len = 0;
916
            for(i = 0; i <= LV_LABEL_DOT_NUM; i++)  {
917
                len += lv_txt_encoded_size(&ext->text[byte_id]);
918
                lv_txt_encoded_next(ext->text, &byte_id);
919
            }
920

921
            memcpy(ext->dot_tmp, &ext->text[byte_id_ori], len);
922
            ext->dot_tmp[len] = '\0';       /*Close with a zero*/
923

924
            for(i = 0; i < LV_LABEL_DOT_NUM; i++) {
925
                ext->text[byte_id_ori + i] = '.';
926
            }
927
            ext->text[byte_id_ori + LV_LABEL_DOT_NUM] = '\0';
928

929
            ext->dot_end = letter_id + LV_LABEL_DOT_NUM;
930
#endif
931

932
        }
933
    }
934
    /*In break mode only the height can change*/
935
    else if(ext->long_mode == LV_LABEL_LONG_BREAK) {
936
        lv_obj_set_height(label, size.y);
937
    }
938
    /*Do not set the size in Clip mode*/
939
    else if(ext->long_mode == LV_LABEL_LONG_CROP) {
940
        /*Do nothing*/
941
    }
942

943

944
    lv_obj_invalidate(label);
945
}
946

947
static void lv_label_revert_dots(lv_obj_t * label)
948
{
949
    lv_label_ext_t * ext = lv_obj_get_ext_attr(label);
950
    if(ext->long_mode != LV_LABEL_LONG_DOT) return;
951
    if(ext->dot_end == LV_LABEL_DOT_END_INV) return;
952
#if LV_TXT_UTF8 == 0
953
    uint32_t i;
954
    for(i = 0; i <= LV_LABEL_DOT_NUM; i++) {
955
        ext->text[ext->dot_end - i] = ext->dot_tmp[LV_LABEL_DOT_NUM - i];
956
    }
957
#else
958
    uint32_t letter_i = ext->dot_end - LV_LABEL_DOT_NUM;
959
    uint32_t byte_i = lv_txt_encoded_get_byte_id(ext->text, letter_i);
960

961
    /*Restore the characters*/
962
    uint8_t i = 0;
963
    while(ext->dot_tmp[i] != '\0') {
964
        ext->text[byte_i + i] = ext->dot_tmp[i];
965
        i++;
966
    }
967
#endif
968

969
    ext->dot_end = LV_LABEL_DOT_END_INV;
970
}
971

972
#if USE_LV_ANIMATION
973
static void lv_label_set_offset_x(lv_obj_t * label, lv_coord_t x)
974
{
975
    lv_label_ext_t * ext = lv_obj_get_ext_attr(label);
976
    ext->offset.x = x;
977
    lv_obj_invalidate(label);
978
}
979

980
static void lv_label_set_offset_y(lv_obj_t * label, lv_coord_t y)
981
{
982
    lv_label_ext_t * ext = lv_obj_get_ext_attr(label);
983
    ext->offset.y = y;
984
    lv_obj_invalidate(label);
985
}
986
#endif
987
#endif
988

989