src/lib/elm_label.c

   1 #include <Elementary.h>
   2 #include "elm_priv.h"
   3
   4 /**
   5  * @defgroup Label Label
   6  * @ingroup Elementary
   7  *
   8  * Display text, with simple html-like markup. The theme of course
   9  * can invent new markup tags and style them any way it likes
  10  */
  11
  12 typedef struct _Widget_Data Widget_Data;
  13
  14 struct _Widget_Data
  15 {
  16    Evas_Object *lbl;
  17    Evas_Object *bg;
  18    const char *label;
  19    Evas_Coord lastw;
  20    Ecore_Job *deferred_recalc_job;
  21    Evas_Coord wrap_w;
  22    Evas_Coord wrap_h;
  23    Eina_Bool linewrap : 1;
  24    Eina_Bool wrapmode : 1;
  25    Eina_Bool slidingmode : 1;
  26    Eina_Bool slidingellipsis : 1;
  27    Eina_Bool changed : 1;
  28    Eina_Bool bgcolor : 1;
  29    Eina_Bool ellipsis : 1;
  30 };
  31
  32 static const char *widtype = NULL;
  33 static void _del_hook(Evas_Object *obj);
  34 static void _theme_hook(Evas_Object *obj);
  35 static void _sizing_eval(Evas_Object *obj);
  36 static int _get_value_in_key_string(const char *oldstring, char *key, char **value);
  37 static int _strbuf_key_value_replace(Eina_Strbuf *srcbuf, char *key, const char *value, int deleteflag);
  38 static int _stringshare_key_value_replace(const char **srcstring, char *key, const char *value, int deleteflag);
  39 static int _is_width_over(Evas_Object *obj, int linemode);
  40 static void _ellipsis_label_to_width(Evas_Object *obj, int linemode);
  41
  42 static void
  43 _elm_win_recalc_job(void *data)
  44 {
  45    Widget_Data *wd = elm_widget_data_get(data);
  46    Evas_Coord minw = -1, minh = -1, maxh = -1;
  47    Evas_Coord resw, resh, minminw, minminh;
  48    if (!wd) return;
  49    wd->deferred_recalc_job = NULL;
  50    evas_object_geometry_get(wd->lbl, NULL, NULL, &resw, &resh);
  51    resh = 0;
  52    minminw = 0;
  53    edje_object_size_min_restricted_calc(wd->lbl, &minw, &minh, 0, 0);
  54    minminw = minw;
  55    minminh = minh;
  56    if (wd->wrap_w >= resw)
  57      {
  58         resw = wd->wrap_w;
  59         edje_object_size_min_restricted_calc(wd->lbl, &minw, &minh, resw, 0);
  60         evas_object_size_hint_min_set(data, minw, minh);
  61      }
  62    else
  63      {
  64         if (wd->wrap_w > minminw) minminw = wd->wrap_w;
  65         edje_object_size_min_restricted_calc(wd->lbl, &minw, &minh, resw, 0);
  66         evas_object_size_hint_min_set(data, minminw, minh);
  67      }
  68
  69    if (wd->ellipsis && wd->linewrap && wd->wrap_h > 0 && _is_width_over(data, 1) == 1)
  70      _ellipsis_label_to_width(data, 1);
  71
  72    maxh = minh;
  73    evas_object_size_hint_max_set(data, -1, maxh);
  74 }
  75
  76 static void
  77 _del_hook(Evas_Object *obj)
  78 {
  79    Widget_Data *wd = elm_widget_data_get(obj);
  80    if (!wd) return;
  81    if (wd->deferred_recalc_job) ecore_job_del(wd->deferred_recalc_job);
  82    if (wd->label) eina_stringshare_del(wd->label);
  83    if (wd->bg) evas_object_del(wd->bg);
  84    free(wd);
  85 }
  86
  87 static void
  88 _theme_change(Evas_Object *obj)
  89 {
  90    Widget_Data *wd = elm_widget_data_get(obj);
  91    if (!wd) return;
  92
  93    if (wd->linewrap)
  94      {
  95        if (wd->ellipsis)
  96          _elm_theme_object_set(obj, wd->lbl, "label", "base_wrap_ellipsis", elm_widget_style_get(obj));
  97        else
  98          _elm_theme_object_set(obj, wd->lbl, "label", "base_wrap", elm_widget_style_get(obj));
  99      }
 100    else
 101      _elm_theme_object_set(obj, wd->lbl, "label", "base", elm_widget_style_get(obj));
 102
 103 }
 104
 105 static void
 106 _theme_hook(Evas_Object *obj)
 107 {
 108    Widget_Data *wd = elm_widget_data_get(obj);
 109    if (!wd) return;
 110    _theme_change(obj);
 111    edje_object_part_text_set(wd->lbl, "elm.text", wd->label);
 112    edje_object_scale_set(wd->lbl, elm_widget_scale_get(obj) *
 113                          _elm_config->scale);
 114    _sizing_eval(obj);
 115 }
 116
 117 static void
 118 _sizing_eval(Evas_Object *obj)
 119 {
 120    Widget_Data *wd = elm_widget_data_get(obj);
 121    Evas_Coord minw = -1, minh = -1, maxw = -1, maxh = -1;
 122    Evas_Coord resw, resh;
 123    if (!wd) return;
 124    if (wd->linewrap)
 125      {
 126         evas_object_geometry_get(wd->lbl, NULL, NULL, &resw, &resh);
 127         if ((resw == wd->lastw) && (!wd->changed)) return;
 128         wd->changed = EINA_FALSE;
 129         wd->lastw = resw;
 130         _elm_win_recalc_job(obj);
 131 // FIXME: works ok. but NOT for genlist. what should genlist do?
 132 //        if (wd->deferred_recalc_job) ecore_job_del(wd->deferred_recalc_job);
 133 //        wd->deferred_recalc_job = ecore_job_add(_elm_win_recalc_job, obj);
 134      }
 135    else
 136      {
 137         evas_object_geometry_get(wd->lbl, NULL, NULL, &resw, &resh);
 138         edje_object_size_min_calc(wd->lbl, &minw, &minh);
 139                 if (wd->wrap_w > 0 && minw > wd->wrap_w)
 140                         minw = wd->wrap_w;
 141         evas_object_size_hint_min_set(obj, minw, minh);
 142         maxh = minh;
 143         evas_object_size_hint_max_set(obj, maxw, maxh);
 144
 145         if (wd->ellipsis && _is_width_over(obj, 0) == 1)
 146           _ellipsis_label_to_width(obj, 0);
 147      }
 148 }
 149
 150 static void
 151 _resize(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
 152 {
 153    Widget_Data *wd = elm_widget_data_get(data);
 154    if (!wd) return;
 155    if (wd->linewrap) _sizing_eval(data);
 156 }
 157
 158 static int
 159 _get_value_in_key_string(const char *oldstring, char *key, char **value)
 160 {
 161    char *curlocater, *starttag, *endtag;
 162    int firstindex = 0, foundflag = -1;
 163
 164    curlocater = strstr(oldstring, key);
 165    if (curlocater)
 166      {
 167         starttag = curlocater;
 168         endtag = curlocater + strlen(key);
 169         if (endtag == NULL || *endtag != '=')
 170           {
 171             foundflag = 0;
 172             return -1;
 173           }
 174
 175         firstindex = abs(oldstring - curlocater);
 176         firstindex += strlen(key)+1; // strlen("key") + strlen("=")
 177         *value = (char*)oldstring + firstindex;
 178
 179         while (oldstring != starttag)
 180           {
 181             if (*starttag == '>')
 182               {
 183                 foundflag = 0;
 184                 break;
 185               }
 186             if (*starttag == '<')
 187               break;
 188             else
 189               starttag--;
 190             if (starttag == NULL) break;
 191           }
 192
 193         while (NULL != endtag)
 194           {
 195             if (*endtag == '<')
 196               {
 197                 foundflag = 0;
 198                 break;
 199               }
 200             if (*endtag == '>')
 201               break;
 202             else
 203               endtag++;
 204             if (endtag == NULL) break;
 205           }
 206
 207         if (foundflag != 0 && *starttag == '<' && *endtag == '>')
 208           foundflag = 1;
 209         else
 210           foundflag = 0;
 211      }
 212    else
 213      {
 214        foundflag = 0;
 215      }
 216
 217    if (foundflag == 1) return 0;
 218
 219    return -1;
 220 }
 221
 222 static int
 223 _strbuf_key_value_replace(Eina_Strbuf *srcbuf, char *key, const char *value, int deleteflag)
 224 {
 225    const char *srcstring = NULL;
 226    Eina_Strbuf *repbuf = NULL, *diffbuf = NULL;
 227    char *curlocater, *replocater;
 228    char *starttag, *endtag;
 229    int tagtxtlen = 0, insertflag = 0;
 230
 231    srcstring = eina_strbuf_string_get(srcbuf);
 232    curlocater = strstr(srcstring, key);
 233
 234    if (curlocater == NULL)
 235      {
 236        insertflag = 1;
 237      }
 238    else
 239      {
 240        do
 241          {
 242            starttag = strchr(srcstring, '<');
 243            endtag = strchr(srcstring, '>');
 244            tagtxtlen = endtag - starttag;
 245            if (tagtxtlen <= 0) tagtxtlen = 0;
 246            if (starttag < curlocater && curlocater < endtag) break;
 247            if (endtag != NULL && endtag+1 != NULL)
 248              srcstring = endtag+1;
 249            else
 250              break;
 251          } while (strlen(srcstring) > 1);
 252
 253        if (starttag && endtag && tagtxtlen > strlen(key))
 254          {
 255            repbuf = eina_strbuf_new();
 256            diffbuf = eina_strbuf_new();
 257            eina_strbuf_append_n(repbuf, starttag, tagtxtlen);
 258            srcstring = eina_strbuf_string_get(repbuf);
 259            curlocater = strstr(srcstring, key);
 260
 261            if (curlocater != NULL)
 262              {
 263                replocater = curlocater + strlen(key) + 1;
 264
 265                while (*replocater == ' ' || *replocater == '=')
 266                            {
 267                  replocater++;
 268                            }
 269
 270                 while (*replocater != NULL && *replocater != ' ' && *replocater != '>')
 271                   replocater++;
 272
 273                if (replocater-curlocater > strlen(key)+1)
 274                  {
 275                    replocater--;
 276                    eina_strbuf_append_n(diffbuf, curlocater, replocater-curlocater+1);
 277                  }
 278                else
 279                  insertflag = 1;
 280              }
 281            else
 282              {
 283                insertflag = 1;
 284              }
 285            eina_strbuf_reset(repbuf);
 286          }
 287        else
 288          {
 289            insertflag = 1;
 290          }
 291      }
 292
 293    if (repbuf == NULL) repbuf = eina_strbuf_new();
 294    if (diffbuf == NULL) diffbuf = eina_strbuf_new();
 295
 296    if (insertflag)
 297      {
 298        eina_strbuf_append_printf(repbuf, "<%s=%s>", key, value);
 299        eina_strbuf_prepend(srcbuf, eina_strbuf_string_get(repbuf));
 300      }
 301    else
 302      {
 303         if (deleteflag)
 304           {
 305             eina_strbuf_prepend(diffbuf, "<");
 306             eina_strbuf_append(diffbuf, ">");
 307             eina_strbuf_replace_first(srcbuf, eina_strbuf_string_get(diffbuf), "");
 308           }
 309         else
 310           {
 311             eina_strbuf_append_printf(repbuf, "%s=%s", key, value);
 312             eina_strbuf_replace_first(srcbuf, eina_strbuf_string_get(diffbuf), eina_strbuf_string_get(repbuf));
 313           }
 314      }
 315
 316    if (repbuf) eina_strbuf_free(repbuf);
 317    if (diffbuf) eina_strbuf_free(diffbuf);
 318
 319    return 0;
 320 }
 321
 322 static int
 323 _stringshare_key_value_replace(const char **srcstring, char *key, const char *value, int deleteflag)
 324 {
 325    Eina_Strbuf *sharebuf = NULL;
 326
 327    sharebuf = eina_strbuf_new();
 328    eina_strbuf_append(sharebuf, *srcstring);
 329    _strbuf_key_value_replace(sharebuf, key, value, deleteflag);
 330    eina_stringshare_del(*srcstring);
 331    *srcstring = eina_stringshare_add(eina_strbuf_string_get(sharebuf));
 332    eina_strbuf_free(sharebuf);
 333
 334    return 0;
 335 }
 336
 337 static int
 338 _is_width_over(Evas_Object *obj, int linemode)
 339 {
 340    Evas_Coord x, y, w, h;
 341    Evas_Coord vx, vy, vw, vh;
 342    Widget_Data *wd = elm_widget_data_get(obj);
 343    const char *ellipsis_string = "...";
 344    size_t ellen = strlen(ellipsis_string)+1;
 345
 346    if (!wd) return 0;
 347
 348    edje_object_part_geometry_get(wd->lbl,"elm.text",&x,&y,&w,&h);
 349
 350    evas_object_geometry_get (obj, &vx,&vy,&vw,&vh);
 351
 352    if (linemode == 0) // single line
 353      {
 354        if ((x >= 0) && (y >= 0))
 355            {
 356                    if ((wd->wrap_w > 0) && (wd->wrap_w < w))
 357                    {
 358                            Evas_Coord minw, minh;
 359                            edje_object_size_min_calc(wd->lbl, &minw, &minh);
 360
 361                            if (minw < wd->wrap_w)
 362                            { // min insufficient
 363                                    return 0;
 364                            }
 365                            else
 366                                    return 1;
 367                    }
 368                    else
 369                            return 0;
 370            }
 371
 372        if (ellen < wd->wrap_w && w > wd->wrap_w) return 1;
 373      }
 374    else // multiline
 375      {
 376        if (vy > h && h > wd->wrap_h) return 1;
 377      }
 378
 379    return 0;
 380 }
 381
 382 static void
 383 _ellipsis_label_to_width(Evas_Object *obj, int linemode)
 384 {
 385    Widget_Data *wd = elm_widget_data_get(obj);
 386    int cur_fontsize = 0, len, showcount;
 387    Eina_Strbuf *fontbuf = NULL, *txtbuf = NULL;
 388    char **kvalue = NULL;
 389    const char *minfont, *deffont, *maxfont;
 390    const char *ellipsis_string = "...";
 391    int minfontsize, maxfontsize, minshowcount;
 392
 393    minshowcount = strlen(ellipsis_string) + 1;
 394    minfont = edje_object_data_get(wd->lbl, "min_font_size");
 395    if (minfont) minfontsize = atoi(minfont);
 396    else minfontsize = 1;
 397    maxfont = edje_object_data_get(wd->lbl, "max_font_size");
 398    if (maxfont) maxfontsize = atoi(maxfont);
 399    else maxfontsize = 1;
 400    deffont = edje_object_data_get(wd->lbl, "default_font_size");
 401    if (deffont) cur_fontsize = atoi(deffont);
 402    else cur_fontsize = 1;
 403    if (minfontsize > maxfontsize || cur_fontsize == 1) return; // theme is not ready for ellipsis
 404    if (eina_stringshare_strlen(wd->label) <= 0) return;
 405
 406    if (_get_value_in_key_string(wd->label, "font_size", &kvalue) == 0)
 407      {
 408        if (*kvalue != NULL) cur_fontsize = atoi((char*)kvalue);
 409      }
 410
 411    txtbuf = eina_strbuf_new();
 412    eina_strbuf_append(txtbuf, wd->label);
 413
 414    while (_is_width_over(obj, linemode))
 415      {
 416        if (cur_fontsize > minfontsize)
 417          {
 418            cur_fontsize--;
 419            if (fontbuf != NULL)
 420              {
 421                eina_strbuf_free(fontbuf);
 422                fontbuf = NULL;
 423              }
 424            fontbuf = eina_strbuf_new();
 425            eina_strbuf_append_printf(fontbuf, "%d", cur_fontsize);
 426            _strbuf_key_value_replace(txtbuf, "font_size", eina_strbuf_string_get(fontbuf), 0);
 427            edje_object_part_text_set(wd->lbl, "elm.text", eina_strbuf_string_get(txtbuf));
 428            eina_strbuf_free(fontbuf);
 429            fontbuf = NULL;
 430          }
 431        else
 432          {
 433            if (txtbuf != NULL)
 434              {
 435                eina_strbuf_free(txtbuf);
 436                txtbuf = NULL;
 437              }
 438            txtbuf = eina_strbuf_new();
 439            eina_strbuf_append_printf(txtbuf, "%s", edje_object_part_text_get(wd->lbl, "elm.text"));
 440            len = eina_strbuf_length_get(txtbuf);
 441            showcount = len - 1;
 442            while (showcount > minshowcount)
 443              {
 444                unsigned char *ltxt = eina_strbuf_string_get(txtbuf);
 445                len = eina_strbuf_length_get(txtbuf);
 446                // FIXME : more reliable truncate routine is needed
 447                //         it works on only EUC-KR
 448                int delta = 0;
 449                            if (ltxt[len-minshowcount-delta] >= 0x80)
 450                  {
 451                    delta = 2;
 452                    showcount--;
 453                  }
 454                eina_strbuf_remove(txtbuf, len-minshowcount-delta, len);
 455                eina_strbuf_append(txtbuf, ellipsis_string);
 456                edje_object_part_text_set(wd->lbl, "elm.text", eina_strbuf_string_get(txtbuf));
 457
 458                if (_is_width_over(obj, linemode))
 459                  showcount--;
 460                else
 461                  break;
 462              }
 463          }
 464      }
 465
 466    if (txtbuf) eina_strbuf_free(txtbuf);
 467    wd->changed = 1;
 468    _sizing_eval(obj);
 469 }
 470
 471 /*
 472  * setting internal state of mulitline entry
 473  * singleline doesn't need it
 474  */
 475
 476 void _label_state_change(Evas_Object *obj)
 477 {
 478    Widget_Data *wd = elm_widget_data_get(obj);
 479    if (!wd) return;
 480
 481    if (wd->linewrap)
 482    {
 483            if (wd->wrapmode)
 484                    edje_object_signal_emit(wd->lbl, "elm,state,wordwrap", "elm");
 485            else
 486                    edje_object_signal_emit(wd->lbl, "elm,state,default", "elm");
 487    }
 488 }
 489
 490 void _label_sliding_change(Evas_Object *obj)
 491 {
 492    Widget_Data *wd = elm_widget_data_get(obj);
 493    if (!wd) return;
 494
 495    if (wd->linewrap)
 496    {
 497            wd->slidingmode = EINA_FALSE;
 498            fprintf(stderr, "ERR: elm_label dosen't support multiline sliding effect!!!\n");
 499            fprintf(stderr, "ERR: elm_label dosen't support multiline sliding effect!!!\n");
 500            fprintf(stderr, "ERR: elm_label dosen't support multiline sliding effect!!!\n");
 501    }
 502
 503    if (wd->slidingmode)
 504    {
 505            if (wd->ellipsis)
 506            {
 507                    wd->slidingellipsis = EINA_TRUE;
 508                    elm_label_ellipsis_set(obj, EINA_FALSE);
 509            }
 510            edje_object_signal_emit(wd->lbl, "elm,state,slide,start", "elm");
 511    }
 512    else
 513    {
 514            edje_object_signal_emit(wd->lbl, "elm,state,slide,stop", "elm");
 515            if (wd->slidingellipsis)
 516            {
 517                    wd->slidingellipsis = EINA_FALSE;
 518                    elm_label_ellipsis_set(obj, EINA_TRUE);
 519            }
 520    }
 521 }
 522
 523 /**
 524  * Add a new label to the parent
 525  *
 526  * @param parent The parent object
 527  * @return The new object or NULL if it cannot be created
 528  *
 529  * @ingroup Label
 530  */
 531 EAPI Evas_Object *
 532 elm_label_add(Evas_Object *parent)
 533 {
 534    Evas_Object *obj;
 535    Evas *e;
 536    Widget_Data *wd;
 537
 538    wd = ELM_NEW(Widget_Data);
 539    e = evas_object_evas_get(parent);
 540    wd->bg = evas_object_rectangle_add(e);
 541    evas_object_color_set(wd->bg, 0, 0, 0, 0);
 542    obj = elm_widget_add(e);
 543    ELM_SET_WIDTYPE(widtype, "label");
 544    elm_widget_type_set(obj, "label");
 545    elm_widget_sub_object_add(parent, obj);
 546    elm_widget_data_set(obj, wd);
 547    elm_widget_del_hook_set(obj, _del_hook);
 548    elm_widget_theme_hook_set(obj, _theme_hook);
 549    elm_widget_can_focus_set(obj, 0);
 550
 551    wd->linewrap = EINA_FALSE;
 552    wd->bgcolor = EINA_FALSE;
 553    wd->ellipsis = EINA_FALSE;
 554    wd->wrapmode = EINA_FALSE;
 555    wd->slidingmode = EINA_FALSE;
 556    wd->slidingellipsis = EINA_FALSE;
 557    wd->wrap_w = 0;
 558    wd->wrap_h = 0;
 559
 560    wd->lbl = edje_object_add(e);
 561    _elm_theme_object_set(obj, wd->lbl, "label", "base", "default");
 562    wd->label = eina_stringshare_add("<br>");
 563    edje_object_part_text_set(wd->lbl, "elm.text", "<br>");
 564    elm_widget_resize_object_set(obj, wd->lbl);
 565
 566    evas_object_event_callback_add(wd->lbl, EVAS_CALLBACK_RESIZE, _resize, obj);
 567
 568    wd->changed = 1;
 569    _sizing_eval(obj);
 570    return obj;
 571 }
 572
 573 /**
 574  * Set the label on the label object
 575  *
 576  * @param obj The label object
 577  * @param label The label will be used on the label object
 578  *
 579  * @ingroup Label
 580  */
 581 EAPI void
 582 elm_label_label_set(Evas_Object *obj, const char *label)
 583 {
 584    ELM_CHECK_WIDTYPE(obj, widtype);
 585    Widget_Data *wd = elm_widget_data_get(obj);
 586    if (!wd) return;
 587    if (!label) label = "";
 588    eina_stringshare_replace(&wd->label, label);
 589    edje_object_part_text_set(wd->lbl, "elm.text", label);
 590    wd->changed = 1;
 591    _sizing_eval(obj);
 592 }
 593
 594 /**
 595  * Get the label used on the label object
 596  *
 597  * @param obj The label object
 598  * @return The string inside the label
 599  * @ingroup Label
 600  */
 601 EAPI const char *
 602 elm_label_label_get(const Evas_Object *obj)
 603 {
 604    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
 605    Widget_Data *wd = elm_widget_data_get(obj);
 606    if (!wd) return NULL;
 607    return wd->label;
 608 }
 609
 610 /**
 611  * Set the wrapping behavior of the label
 612  *
 613  * @param obj The label object
 614  * @param wrap To wrap text or not
 615  * @ingroup Label
 616  */
 617 EAPI void
 618 elm_label_line_wrap_set(Evas_Object *obj, Eina_Bool wrap)
 619 {
 620    ELM_CHECK_WIDTYPE(obj, widtype);
 621    Widget_Data *wd = elm_widget_data_get(obj);
 622    if (!wd) return;
 623    const char *t;
 624    if (wd->linewrap == wrap) return;
 625    wd->linewrap = wrap;
 626    t = eina_stringshare_add(elm_label_label_get(obj));
 627    _theme_change(obj);
 628    elm_label_label_set(obj, t);
 629    eina_stringshare_del(t);
 630    wd->changed = 1;
 631    _sizing_eval(obj);
 632 }
 633
 634 /**
 635  * Get the wrapping behavior of the label
 636  *
 637  * @param obj The label object
 638  * @return To wrap text or not
 639  * @ingroup Label
 640  */
 641 EAPI Eina_Bool
 642 elm_label_line_wrap_get(const Evas_Object *obj)
 643 {
 644    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
 645    Widget_Data *wd = elm_widget_data_get(obj);
 646    if (!wd) return EINA_FALSE;
 647    return wd->linewrap;
 648 }
 649
 650 /**
 651  * Set wrap width of the label
 652  *
 653  * @param obj The label object
 654  * @param w The wrap width in pixels at a minimum where words need to wrap
 655  * @ingroup Label
 656  */
 657 EAPI void
 658 elm_label_wrap_width_set(Evas_Object *obj, Evas_Coord w)
 659 {
 660    ELM_CHECK_WIDTYPE(obj, widtype);
 661    Widget_Data *wd = elm_widget_data_get(obj);
 662    if (!wd) return;
 663    if (w < 0) w = 0;
 664    if (wd->wrap_w == w) return;
 665    if (wd->ellipsis) edje_object_part_text_set(wd->lbl, "elm.text", wd->label);
 666    wd->wrap_w = w;
 667    _sizing_eval(obj);
 668 }
 669
 670 /**
 671  * get wrap width of the label
 672  *
 673  * @param obj The label object
 674  * @return The wrap width in pixels at a minimum where words need to wrap
 675  * @ingroup Label
 676  */
 677 EAPI Evas_Coord
 678 elm_label_wrap_width_get(const Evas_Object *obj)
 679 {
 680    ELM_CHECK_WIDTYPE(obj, widtype) 0;
 681    Widget_Data *wd = elm_widget_data_get(obj);
 682    if (!wd) return 0;
 683    return wd->wrap_w;
 684 }
 685
 686 /**
 687  * Set wrap height of the label
 688  *
 689  * @param obj The label object
 690  * @param w The wrap width in pixels at a minimum where words need to wrap
 691  * @ingroup Label
 692  */
 693 EAPI void
 694 elm_label_wrap_height_set(Evas_Object *obj, Evas_Coord h)
 695 {
 696    ELM_CHECK_WIDTYPE(obj, widtype);
 697    Widget_Data *wd = elm_widget_data_get(obj);
 698    if (!wd) return;
 699    if (h < 0) h = 0;
 700    if (wd->wrap_h == h) return;
 701    if (wd->ellipsis) edje_object_part_text_set(wd->lbl, "elm.text", wd->label);
 702    wd->wrap_h = h;
 703    _sizing_eval(obj);
 704 }
 705
 706 /**
 707  * get wrap width of the label
 708  *
 709  * @param obj The label object
 710  * @return The wrap height in pixels at a minimum where words need to wrap
 711  * @ingroup Label
 712  */
 713 EAPI Evas_Coord
 714 elm_label_wrap_height_get(const Evas_Object *obj)
 715 {
 716    ELM_CHECK_WIDTYPE(obj, widtype) 0;
 717    Widget_Data *wd = elm_widget_data_get(obj);
 718    if (!wd) return 0;
 719    return wd->wrap_h;
 720 }
 721
 722 /**
 723  * Set the font size on the label object
 724  *
 725  * @param obj The label object
 726  * @param size font size
 727  *
 728  * @ingroup Label
 729  */
 730 EAPI void
 731 elm_label_fontsize_set(Evas_Object *obj, int fontsize)
 732 {
 733    ELM_CHECK_WIDTYPE(obj, widtype);
 734    Widget_Data *wd = elm_widget_data_get(obj);
 735    Eina_Strbuf *fontbuf = NULL;
 736    int len, removeflag = 0;
 737
 738    if (!wd) return;
 739    len = strlen(wd->label);
 740    if (len <= 0) return;
 741    fontbuf = eina_strbuf_new();
 742    eina_strbuf_append_printf(fontbuf, "%d", fontsize);
 743
 744    if (fontsize == 0) removeflag = 1; // remove fontsize tag
 745
 746    if (_stringshare_key_value_replace(&wd->label, "font_size", eina_strbuf_string_get(fontbuf), removeflag) == 0)
 747      {
 748        edje_object_part_text_set(wd->lbl, "elm.text", wd->label);
 749        wd->changed = 1;
 750        _sizing_eval(obj);
 751      }
 752    eina_strbuf_free(fontbuf);
 753 }
 754
 755 /**
 756  * Set the text align on the label object
 757  *
 758  * @param obj The label object
 759  * @param align align mode ("left", "center", "right")
 760  *
 761  * @ingroup Label
 762  */
 763 EAPI void
 764 elm_label_text_align_set(Evas_Object *obj, const char *alignmode)
 765 {
 766    ELM_CHECK_WIDTYPE(obj, widtype);
 767    Widget_Data *wd = elm_widget_data_get(obj);
 768    int len;
 769
 770    if (!wd) return;
 771    len = strlen(wd->label);
 772    if (len <= 0) return;
 773
 774    if (_stringshare_key_value_replace(&wd->label, "align", alignmode, 0) == 0)
 775      edje_object_part_text_set(wd->lbl, "elm.text", wd->label);
 776
 777    wd->changed = 1;
 778    _sizing_eval(obj);
 779 }
 780
 781 /**
 782  * Set the text color on the label object
 783  *
 784  * @param obj The label object
 785  * @param r Red property background color of The label object
 786  * @param g Green property background color of The label object
 787  * @param b Blue property background color of The label object
 788  * @param a Alpha property background alpha of The label object
 789  *
 790  * @ingroup Label
 791  */
 792 EAPI void
 793 elm_label_text_color_set(Evas_Object *obj, unsigned int r, unsigned int g, unsigned int b, unsigned int a)
 794 {
 795    ELM_CHECK_WIDTYPE(obj, widtype);
 796    Widget_Data *wd = elm_widget_data_get(obj);
 797    Eina_Strbuf *colorbuf = NULL;
 798    int len;
 799
 800    if (!wd) return;
 801    len = strlen(wd->label);
 802    if (len <= 0) return;
 803    colorbuf = eina_strbuf_new();
 804    eina_strbuf_append_printf(colorbuf, "#%02X%02X%02X%02X", r, g, b, a);
 805
 806    if (_stringshare_key_value_replace(&wd->label, "color", eina_strbuf_string_get(colorbuf), 0) == 0)
 807      {
 808        edje_object_part_text_set(wd->lbl, "elm.text", wd->label);
 809        wd->changed = 1;
 810        _sizing_eval(obj);
 811      }
 812    eina_strbuf_free(colorbuf);
 813 }
 814
 815
 816 /**
 817  * Set background color of the label
 818  *
 819  * @param obj The label object
 820  * @param r Red property background color of The label object
 821  * @param g Green property background color of The label object
 822  * @param b Blue property background color of The label object
 823  * @param a Alpha property background alpha of The label object
 824  * @ingroup Label
 825  */
 826 EAPI void
 827 elm_label_background_color_set(Evas_Object *obj, unsigned int r, unsigned int g, unsigned int b, unsigned int a)
 828 {
 829    ELM_CHECK_WIDTYPE(obj, widtype);
 830    Widget_Data *wd = elm_widget_data_get(obj);
 831    evas_object_color_set(wd->bg, r, g, b, a);
 832
 833    if (wd->bgcolor == EINA_FALSE)
 834      {
 835         wd->bgcolor = 1;
 836         edje_object_part_swallow(wd->lbl, "label.swallow.background", wd->bg);
 837      }
 838 }
 839
 840 /**
 841  * Set the ellipsis behavior of the label
 842  *
 843  * @param obj The label object
 844  * @param ellipsis To ellipsis text or not
 845  * @ingroup Label
 846  */
 847 EAPI void
 848 elm_label_ellipsis_set(Evas_Object *obj, Eina_Bool ellipsis)
 849 {
 850    ELM_CHECK_WIDTYPE(obj, widtype);
 851    Widget_Data *wd = elm_widget_data_get(obj);
 852    if (wd->ellipsis == ellipsis) return;
 853    wd->ellipsis = ellipsis;
 854    if (wd->linewrap) _theme_change(obj);
 855    edje_object_part_text_set(wd->lbl, "elm.text", wd->label);
 856    wd->changed = 1;
 857    _sizing_eval(obj);
 858 }
 859
 860 /**
 861  * Set the wrapmode of the label
 862  *
 863  * @param obj The label object
 864  * @param wrapmode 0 is charwrap, 1 is wordwrap
 865  * @ingroup Label
 866  */
 867 EAPI void
 868 elm_label_wrap_mode_set(Evas_Object *obj, Eina_Bool wrapmode)
 869 {
 870    ELM_CHECK_WIDTYPE(obj, widtype);
 871    Widget_Data *wd = elm_widget_data_get(obj);
 872    if (wd->wrapmode == wrapmode) return;
 873    wd->wrapmode = wrapmode;
 874    _label_state_change(obj);
 875    wd->changed = 1;
 876    _sizing_eval(obj);
 877 }
 878
 879 /**
 880  * Set the text slide of the label
 881  *
 882  * @param obj The label object
 883  * @param slide To start slide or stop
 884  * @ingroup Label
 885  */
 886 EAPI void
 887 elm_label_slide_set(Evas_Object *obj, Eina_Bool slide)
 888 {
 889    ELM_CHECK_WIDTYPE(obj, widtype);
 890    Widget_Data *wd = elm_widget_data_get(obj);
 891    if (!wd) return;
 892
 893    if (wd->slidingmode == slide) return;
 894    wd->slidingmode = slide;
 895    _label_sliding_change(obj);
 896    wd->changed = 1;
 897    _sizing_eval(obj);
 898 }
 899
 900 /**
 901  * get the text slide mode of the label
 902  *
 903  * @param obj The label object
 904  * @return slide set flag value
 905  * @ingroup Label
 906  */
 907 EAPI Eina_Bool
 908 elm_label_slide_get(Evas_Object *obj)
 909 {
 910    ELM_CHECK_WIDTYPE(obj, widtype);
 911    Widget_Data *wd = elm_widget_data_get(obj);
 912    if (!wd) return EINA_FALSE;
 913
 914    return wd->slidingmode;
 915 }