system-settings-util/src/system_settings_util.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <unistd.h>
   4 #include <errno.h>
   5 #include <time.h>
   6
   7 #include <string.h>
   8 #include <sys/types.h>
   9 #include <sys/stat.h>
  10 #include <fcntl.h>
  11
  12 #include <regex.h>
  13
  14 #include <dlog.h>
  15 #include <vconf.h>
  16
  17 #include <glib.h>
  18 #include <libxml/xmlmemory.h>
  19 #include <libxml/parser.h>
  20
  21 #include <fontconfig/fontconfig.h>
  22
  23 #include <Elementary.h>
  24 #include <Evas.h>
  25 #include <Ecore_Evas.h>
  26
  27 #include <pkgmgr-info.h>
  28
  29 #include <system_settings.h>
  30 #include <system_settings_private.h>
  31
  32 #include <tzplatform_config.h>
  33 #include <system_settings_util.h>
  34
  35 #ifdef TIZEN_WEARABLE
  36 #define SMALL_FONT_DPI                                          (-90)
  37 #endif
  38 #ifdef TIZEN_MOBILE
  39 #define SMALL_FONT_DPI                                          (-80)
  40 #endif
  41 #define MIDDLE_FONT_DPI                                         (-100)
  42 #ifdef TIZEN_WEARABLE
  43 #define LARGE_FONT_DPI                                          (-110)
  44 #endif
  45 #ifdef TIZEN_MOBILE
  46 #define LARGE_FONT_DPI                                          (-150)
  47 #endif
  48 #define HUGE_FONT_DPI                                           (-190)
  49 #define GIANT_FONT_DPI                                          (-250)
  50
  51 #define SETTING_FONT_PRELOAD_FONT_PATH _TZ_SYS_RO_SHARE"/fonts"
  52 #define SETTING_FONT_DOWNLOADED_FONT_PATH _TZ_SYS_RO_SHARE"/fonts"
  53
  54 #define SETTING_FONT_CONF_FILE _TZ_SYS_ETC"/fonts/conf.avail/99-tizen.conf"
  55 #define SETTING_DEFAULT_FONT_CONF_FILE _TZ_SYS_ETC"/fonts/conf.avail/99-tizen.conf"
  56
  57
  58 bool font_config_set(char *font_name);
  59 int __is_available_font(char *font_name);
  60 char *_get_default_font();
  61 char *_get_cur_font();
  62
  63 int __font_size_get();
  64 void __font_size_set();
  65
  66 bool __is_supported_image_type_load(char *path)
  67 {
  68         SETTING_TRACE_BEGIN;
  69         /*evas_init(); */
  70         ecore_evas_init();
  71         Ecore_Evas      *ee;
  72         Evas            *evas;
  73
  74         ee = ecore_evas_new(NULL, 0, 0, 100, 100, NULL);
  75         evas = ecore_evas_get(ee);
  76
  77         Evas_Object *img = evas_object_image_add(evas);
  78         evas_object_image_file_set(img, path, NULL);
  79         Evas_Load_Error ret = evas_object_image_load_error_get(img);
  80
  81         bool result = false;
  82         if (ret == EVAS_LOAD_ERROR_NONE) {
  83                 SETTING_TRACE("%s - OK", path);
  84                 result = true;
  85         } else {
  86                 SETTING_TRACE("%s - NO", path);
  87                 result = false;
  88         }
  89         ecore_evas_free(ee);
  90         evas_shutdown();
  91         return result;
  92 }
  93
  94 bool __is_supported_image_type(char *path)
  95 {
  96         SETTING_TRACE_BEGIN;
  97         bool ret = false;
  98
  99         evas_init();
 100         if (evas_object_image_extension_can_load_get(path))
 101                 ret = true;
 102         else
 103                 ret = false;
 104
 105         evas_shutdown();
 106
 107         return ret;
 108 }
 109
 110 char *_get_cur_font()
 111 {
 112         SETTING_TRACE_BEGIN;
 113         xmlDocPtr doc = NULL;
 114         xmlNodePtr cur = NULL;
 115         xmlNodePtr cur2 = NULL;
 116         xmlNodePtr cur3 = NULL;
 117         xmlChar *key = NULL;
 118
 119         char *font_name = NULL;
 120
 121         doc = xmlParseFile(SETTING_FONT_CONF_FILE);
 122
 123         cur = xmlDocGetRootElement(doc);
 124
 125         if (cur == NULL) {
 126                 xmlFreeDoc(doc);
 127                 doc = NULL;
 128                 return NULL;
 129         }
 130
 131         if (xmlStrcmp(cur->name, (const xmlChar *)"fontconfig")) {
 132                 xmlFreeDoc(doc);
 133                 doc = NULL;
 134                 return NULL;
 135         }
 136
 137         cur = cur->xmlChildrenNode;
 138
 139         while (cur != NULL) {
 140                 if ((!xmlStrcmp(cur->name, (const xmlChar *)"match"))) {
 141                         cur2 = cur->xmlChildrenNode;
 142                         while (cur2 != NULL) {
 143                                 if ((!xmlStrcmp(cur2->name, (const xmlChar *)"edit"))) {
 144                                         cur3 = cur2->xmlChildrenNode;
 145                                         while (cur3 != NULL) {
 146                                                 if ((!xmlStrcmp(cur3->name, (const xmlChar *)"string"))) {
 147                                                         key = xmlNodeListGetString(doc, cur3->xmlChildrenNode, 1);
 148
 149                                                         font_name = g_strdup((char *)key);
 150                                                         xmlFree(key);
 151                                                         key = NULL;
 152                                                         xmlFreeDoc(doc);
 153                                                         doc = NULL;
 154                                                         return font_name;
 155                                                 }
 156                                                 cur3 = cur3->next;
 157                                         }
 158                                 }
 159                                 cur2 = cur2->next;
 160                         }
 161                 }
 162                 cur = cur->next;
 163         }
 164
 165         xmlFreeDoc(doc);
 166         doc = NULL;
 167         return NULL;
 168 }
 169
 170 void font_config_set_notification()
 171 {
 172         SETTING_TRACE_BEGIN;
 173 #if 0
 174         /* notification */
 175         Ecore_X_Window ecore_win = ecore_x_window_root_first_get();
 176         Ecore_X_Atom atom = ecore_x_atom_get("FONT_TYPE_change");
 177         ecore_x_window_prop_string_set(ecore_win, atom, "tizen");
 178 #endif
 179 }
 180
 181 int __is_available_font(char *font_name)
 182 {
 183         SETTING_TRACE_BEGIN;
 184         FcObjectSet *os = NULL;
 185         FcFontSet *fs = NULL;
 186         FcPattern *pat = NULL;
 187         FcConfig *font_config = NULL;
 188
 189         int ret = 0;
 190
 191         if (font_name == NULL)
 192                 return -1;
 193
 194         font_config = FcInitLoadConfigAndFonts();
 195
 196         /*setting_retvm_if(font_config == NULL, NULL, "Failed: FcInitLoadConfigAndFonts"); */
 197
 198         char *locale = setlocale(0, NULL);
 199
 200         pat = FcPatternCreate();
 201
 202         os = FcObjectSetBuild(FC_FAMILY, FC_FILE, FC_FAMILYLANG, (char *) 0);
 203
 204         if (os) {
 205                 fs = FcFontList(font_config, pat, os);
 206                 FcObjectSetDestroy(os);
 207                 os = NULL;
 208         }
 209
 210         if (pat) {
 211                 FcPatternDestroy(pat);
 212                 pat = NULL;
 213         }
 214
 215         if (fs) {
 216                 int j;
 217                 SETTING_TRACE("fs->nfont = %d", fs->nfont);
 218
 219                 for (j = 0; j < fs->nfont; j++) {
 220                         FcChar8 *family = NULL;
 221                         FcChar8 *file = NULL;
 222
 223                         if (FcPatternGetString(fs->fonts[j], FC_FILE, 0, &file) == FcResultMatch) {
 224                                 int preload_path_len = strlen(SETTING_FONT_PRELOAD_FONT_PATH);
 225                                 int download_path_len = strlen(SETTING_FONT_DOWNLOADED_FONT_PATH);
 226
 227                                 if (file && (!strncmp((const char *)file, SETTING_FONT_PRELOAD_FONT_PATH, preload_path_len)
 228                                                          || !strncmp((const char *)file, SETTING_FONT_DOWNLOADED_FONT_PATH, download_path_len))) {
 229                                         char *family_result = NULL;
 230                                         FcChar8 *lang = NULL;
 231                                         int id = 0;
 232                                         if (FcPatternGetString(fs->fonts[j], FC_FAMILY, id, &family) != FcResultMatch) {
 233                                                 break;
 234                                         }
 235                                         if (FcPatternGetString(fs->fonts[j], FC_FAMILYLANG, id, &lang) != FcResultMatch) {
 236                                                 break;
 237                                         }
 238                                         family_result = (char *)family;
 239
 240                                         /* Find proper family name for current locale. */
 241                                         while (locale && family && lang) {
 242                                                 if (!strncmp(locale, (char *)lang, strlen((char *)lang))) {
 243                                                         family_result = (char *)family;
 244                                                         break;
 245                                                 }
 246
 247                                                 /* I will set english as default family language. */
 248                                                 /* If there is no proper family language for current locale, */
 249                                                 /* we have to show the english family name. */
 250                                                 if (!strcmp((char *)lang, (char *)"en")) {
 251                                                         family_result = (char *)family;
 252                                                 }
 253                                                 id++;
 254                                                 if (FcPatternGetString(fs->fonts[j], FC_FAMILY, id, &family) != FcResultMatch) {
 255                                                         break;
 256                                                 }
 257                                                 if (FcPatternGetString(fs->fonts[j], FC_FAMILYLANG, id, &lang) != FcResultMatch) {
 258                                                         break;
 259                                                 }
 260                                         }
 261
 262                                         if (family_result) {
 263                                                 SETTING_TRACE("-------- FONT - family_result = %s", (char *)family_result);
 264                                                 if (strcmp(family_result, font_name) == 0) {
 265                                                         ret = 1;
 266                                                         break;
 267                                                 }
 268                                         }
 269                                 }
 270                         }
 271                 }
 272                 FcFontSetDestroy(fs);
 273                 fs = NULL;
 274         }
 275         FcConfigDestroy(font_config);
 276         font_config = NULL;
 277         return ret;
 278 }
 279
 280
 281 char *_get_default_font()
 282 {
 283         SETTING_TRACE_BEGIN;
 284         xmlDocPtr doc = NULL;
 285         xmlNodePtr cur = NULL;
 286         xmlNodePtr cur2 = NULL;
 287         xmlNodePtr cur3 = NULL;
 288         xmlChar *key = NULL;
 289         struct _xmlAttr *properties = NULL;
 290         char *default_font_name = NULL;
 291
 292         doc = xmlParseFile(SETTING_DEFAULT_FONT_CONF_FILE);
 293
 294         cur = xmlDocGetRootElement(doc);
 295
 296         if (cur == NULL) {
 297                 xmlFreeDoc(doc);
 298                 doc = NULL;
 299                 return NULL;
 300         }
 301
 302         if (xmlStrcmp(cur->name, (const xmlChar *)"fontconfig")) {
 303                 xmlFreeDoc(doc);
 304                 doc = NULL;
 305                 return NULL;
 306         }
 307
 308         cur = cur->xmlChildrenNode;
 309
 310         while (cur != NULL) {
 311                 if ((!xmlStrcmp(cur->name, (const xmlChar *)"match"))) {
 312                         cur2 = cur->xmlChildrenNode;
 313                         while (cur2 != NULL) {
 314                                 if ((!xmlStrcmp(cur2->name, (const xmlChar *)"edit"))) {
 315                                         properties = cur2->properties;
 316                                         /*find the "name" property*/
 317                                         while (NULL != properties) {
 318                                                 if (!xmlStrcmp(properties->name, (const xmlChar *)"name")) {
 319                                                         break;
 320                                                 }
 321                                                 properties = properties->next;
 322                                         }
 323
 324                                         /*If the value of "name" property is "family", then get the child node string,
 325                                         it shall be the default font type*/
 326                                         if (NULL != properties && !xmlStrcmp(properties->children->content, (const xmlChar *)"family")) {
 327                                                 cur3 = cur2->xmlChildrenNode;
 328                                                 while (cur3 != NULL) {
 329                                                         if ((!xmlStrcmp(cur3->name, (const xmlChar *)"string"))) {
 330                                                                 key = xmlNodeListGetString(doc, cur3->xmlChildrenNode, 1);
 331                                                                 default_font_name = g_strdup((char *)key);
 332                                                                 xmlFree(key);
 333                                                                 key = NULL;
 334                                                                 xmlFreeDoc(doc);
 335                                                                 doc = NULL;
 336                                                                 return default_font_name;
 337                                                         }
 338                                                         cur3 = cur3->next;
 339                                                 }
 340                                         }
 341                                 }
 342                                 cur2 = cur2->next;
 343                         }
 344                 }
 345                 cur = cur->next;
 346         }
 347
 348         xmlFreeDoc(doc);
 349         doc = NULL;
 350         return NULL;
 351 }
 352
 353 bool font_config_set(char *font_name)
 354 {
 355         SETTING_TRACE_BEGIN;
 356         Eina_List *text_classes = NULL;
 357         Elm_Text_Class *etc = NULL;
 358         const Eina_List *l = NULL;
 359         Eina_List *fo_list = NULL;
 360         Elm_Font_Overlay *efo = NULL;
 361
 362         int font_size = __font_size_get();
 363         int size = 0;
 364
 365         text_classes = elm_config_text_classes_list_get();
 366
 367         fo_list = (Eina_List *)elm_config_font_overlay_list_get();
 368
 369         Eina_List *ll = NULL;
 370         Eina_List *l_next = NULL;
 371
 372         Eina_Bool slp_medium_exist = EINA_FALSE;
 373         Eina_Bool slp_roman_exist = EINA_FALSE;
 374         Eina_Bool slp_bold_exist = EINA_FALSE;
 375         Eina_Bool slp_regular_exist = EINA_FALSE;
 376
 377         /* Tizen */
 378         Eina_Bool tizen_exist = EINA_FALSE;
 379
 380         EINA_LIST_FOREACH_SAFE(fo_list, ll, l_next, efo) {
 381                 if (!strcmp(efo->text_class, "tizen_medium")) {
 382                         elm_config_font_overlay_set(efo->text_class, (const char *)font_name, efo->size);
 383                         slp_medium_exist = EINA_TRUE;
 384                 } else if (!strcmp(efo->text_class, "tizen_roman")) {
 385                         elm_config_font_overlay_set(efo->text_class, (const char *)font_name, efo->size);
 386                         slp_roman_exist = EINA_TRUE;
 387                 } else if (!strcmp(efo->text_class, "tizen_bold")) {
 388                         elm_config_font_overlay_set(efo->text_class, (const char *)font_name, efo->size);
 389                         slp_bold_exist = EINA_TRUE;
 390                 } else if (!strcmp(efo->text_class, "tizen_regular")) {
 391                         elm_config_font_overlay_set(efo->text_class, (const char *)font_name, efo->size);
 392                         slp_regular_exist = EINA_TRUE;
 393                 }
 394
 395                 /* Tizen */
 396                 if (!strcmp(efo->text_class, "tizen")) {
 397                         elm_config_font_overlay_set(efo->text_class, (const char *)font_name, efo->size);
 398                         tizen_exist = EINA_TRUE;
 399                 }
 400
 401         }
 402
 403         /* if slp_XX do not exist, need to set them, font size is -100(100%) */
 404         if (slp_medium_exist == EINA_FALSE) {
 405                 elm_config_font_overlay_set("tizen_medium", (const char *)font_name,  MIDDLE_FONT_DPI);
 406         }
 407         if (slp_roman_exist == EINA_FALSE) {
 408                 elm_config_font_overlay_set("tizen_roman", (const char *)font_name,      MIDDLE_FONT_DPI);
 409         }
 410         if (slp_bold_exist == EINA_FALSE) {
 411                 elm_config_font_overlay_set("tizen_bold", (const char *)font_name,      MIDDLE_FONT_DPI);
 412         }
 413         if (slp_regular_exist == EINA_FALSE) {
 414                 elm_config_font_overlay_set("tizen_regular", (const char *)font_name,  MIDDLE_FONT_DPI);
 415         }
 416
 417         /* Tizen */
 418         if (tizen_exist == EINA_FALSE) {
 419                 elm_config_font_overlay_set("tizen", (const char *)font_name,  MIDDLE_FONT_DPI);
 420         }
 421
 422         elm_config_font_overlay_set("tizen", (const char *)font_name,  MIDDLE_FONT_DPI);
 423
 424         /* Tizen */
 425         elm_config_font_overlay_set("tizen", (const char *)font_name,  MIDDLE_FONT_DPI);
 426
 427         EINA_LIST_FOREACH(text_classes, l, etc) {
 428                 ll = NULL;
 429
 430                 size = font_size;
 431                 EINA_LIST_FOREACH(fo_list, ll, efo) {
 432                         if (!strcmp(etc->name, efo->text_class)) {
 433                                 size = efo->size;
 434                         }
 435                 }
 436                 elm_config_font_overlay_set(etc->name, (const char *)font_name, size);
 437         }
 438         elm_config_text_classes_list_free(text_classes);
 439         text_classes = NULL;
 440
 441         /* add new function */
 442 #ifdef USE_EFL_ASSIST
 443         ea_theme_system_font_set(font_name, font_size);
 444         ea_theme_system_fonts_apply();
 445 #endif
 446
 447         elm_config_font_overlay_apply();
 448         elm_config_all_flush();
 449         elm_config_save();
 450         return 1;
 451 }
 452
 453 void __font_size_set()
 454 {
 455         SETTING_TRACE_BEGIN;
 456         Eina_List *text_classes = NULL;
 457         Elm_Text_Class *etc = NULL;
 458         const Eina_List *l = NULL;
 459         int font_size = __font_size_get();
 460         char *font_name = _get_cur_font();
 461
 462         if (font_size == -1) {
 463                 return;
 464         }
 465
 466         text_classes = elm_config_text_classes_list_get();
 467
 468         EINA_LIST_FOREACH(text_classes, l, etc) {
 469                 elm_config_font_overlay_set(etc->name, font_name, font_size);
 470         }
 471
 472         elm_config_text_classes_list_free(text_classes);
 473
 474 #ifdef USE_EFL_ASSIST
 475         ea_theme_system_font_set(font_name, font_size);
 476         ea_theme_system_fonts_apply();
 477 #endif
 478
 479         elm_config_font_overlay_apply();
 480         elm_config_all_flush();
 481         elm_config_save();
 482
 483         text_classes = NULL;
 484         g_free(font_name);
 485 }
 486
 487 int __font_size_get()
 488 {
 489         SETTING_TRACE_BEGIN;
 490         int font_size = -1;
 491
 492         int vconf_value = -1;
 493         if (system_setting_vconf_get_value_int(VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_SIZE, &vconf_value)) {
 494                 return -1;
 495         }
 496
 497         switch (vconf_value) {
 498         case SYSTEM_SETTINGS_FONT_SIZE_SMALL:
 499                 font_size = SMALL_FONT_DPI;
 500                 break;
 501         case SYSTEM_SETTINGS_FONT_SIZE_NORMAL:
 502                 font_size = MIDDLE_FONT_DPI;
 503                 break;
 504         case SYSTEM_SETTINGS_FONT_SIZE_LARGE:
 505                 font_size = LARGE_FONT_DPI;
 506                 break;
 507         case SYSTEM_SETTINGS_FONT_SIZE_HUGE:
 508                 font_size = HUGE_FONT_DPI;
 509                 break;
 510         case SYSTEM_SETTINGS_FONT_SIZE_GIANT:
 511                 font_size = GIANT_FONT_DPI;
 512                 break;
 513         default:
 514                 font_size = MIDDLE_FONT_DPI;
 515                 break;
 516         }
 517         return font_size;
 518 }