libutil/sstu.c

   1 /*
   2  * Copyright (c) 2011-2020 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 #include "sst_utils_wrapper.h"
  17
  18 #include <string.h>
  19 #include <vconf.h>
  20 #include <fontconfig/fontconfig.h>
  21 #include <Ecore_Evas.h>
  22 #include <efl_extension.h>
  23 #include "system_settings.h"
  24 #include "sst.h"
  25 #include "sst_core.h"
  26
  27 #ifdef TIZEN_WEARABLE
  28 #define SMALL_FONT_DPI                                          (-90)
  29 #else
  30 #define SMALL_FONT_DPI                                          (-80)
  31 #endif
  32
  33 #define MIDDLE_FONT_DPI                                         (-100)
  34
  35 #ifdef TIZEN_WEARABLE
  36 #define LARGE_FONT_DPI                                          (-110)
  37 #else
  38 #define LARGE_FONT_DPI                                          (-150)
  39 #endif
  40
  41 #define HUGE_FONT_DPI                                           (-190)
  42 #define GIANT_FONT_DPI                                          (-250)
  43
  44 #define SETTING_FONT_PRELOAD_FONT_PATH _TZ_SYS_RO_SHARE"/fonts"
  45 #define SETTING_FONT_DOWNLOADED_FONT_PATH _TZ_SYS_SHARE"/fonts"
  46
  47 #define SETTING_FONT_TIZEN_FONT_ALIAS "Tizen"
  48 #define SETTING_FONT_TIZEN_DEFAULT_FONT_ALIAS "TizenDefaultFont"
  49
  50 static char* _get_main_font_family(char *alias)
  51 {
  52         FcFontSet *set;
  53         FcPattern *pat;
  54         FcConfig *font_config = NULL;
  55         FcChar8 *family = NULL;
  56         char *ret = NULL;
  57         FcResult res = 0;
  58
  59         font_config = FcInitLoadConfigAndFonts();
  60         if (NULL == font_config) {
  61                 ERR("FcInitLoadConfigAndFonts() Fail");
  62                 return NULL;
  63         }
  64
  65         pat = FcPatternBuild(0, FC_FAMILY, FcTypeString, alias, NULL);
  66         if (NULL == pat) {
  67                 ERR("FcPatternBuild() Fail");
  68                 FcConfigDestroy(font_config);
  69                 return NULL;
  70         }
  71
  72         FcConfigSubstitute(font_config, pat, FcMatchPattern);
  73         FcDefaultSubstitute(pat);
  74
  75         /* do matching */
  76         set = FcFontSort(font_config, pat, FcTrue, NULL, &res);
  77         if (set) {
  78                 if (0 < set->nfont) {
  79                         FcPatternGetString(set->fonts[0], FC_FAMILY, 0, &family);
  80                         if (family)
  81                                 ret = strdup((char*)family);
  82                 }
  83                 FcFontSetDestroy(set);
  84         }
  85
  86         FcPatternDestroy(pat);
  87         FcConfigDestroy(font_config);
  88
  89         return ret;
  90 }
  91
  92 API bool sstu_is_valid_image(char *path)
  93 {
  94         void *ee;
  95         void *evas;
  96
  97         if (ecore_evas_init()) {
  98                 ERR("ecore_evas_init() Fail");
  99                 return false;
 100         }
 101
 102         ee = ecore_evas_new(NULL, 0, 0, 100, 100, NULL);
 103         evas = ecore_evas_get(ee);
 104
 105         void *img = evas_object_image_add(evas);
 106         evas_object_image_file_set(img, path, NULL);
 107         int ret = evas_object_image_load_error_get(img);
 108
 109         bool result = false;
 110         if (ret == 0) {
 111                 result = true;
 112         } else {
 113                 ERR("Invalid(%s)", path);
 114                 result = false;
 115         }
 116         ecore_evas_free(ee);
 117         ecore_evas_shutdown();
 118         return result;
 119 }
 120
 121 API void sstu_font_config_set_notification()
 122 {
 123 }
 124
 125 API int sstu_is_available_font(char *font_name)
 126 {
 127         FcObjectSet *os;
 128         FcFontSet *fs;
 129         FcPattern *pat;
 130         FcConfig *font_config;
 131         int ret = 0;
 132
 133         RETV_IF(NULL == font_name, -1);
 134
 135         font_config = FcInitLoadConfigAndFonts();
 136         if (NULL == font_config)
 137                 ERR("FcInitLoadConfigAndFonts() Fail");
 138
 139         char *locale = setlocale(0, NULL);
 140         os = FcObjectSetBuild(FC_FAMILY, FC_FILE, FC_FAMILYLANG, NULL);
 141         if (NULL == os) {
 142                 ERR("FcObjectSetBuild() Fail");
 143                 FcConfigDestroy(font_config);
 144                 return 0;
 145         }
 146
 147         pat = FcPatternCreate();
 148         if (NULL == pat) {
 149                 ERR("FcPatternCreate() Fail");
 150                 FcObjectSetDestroy(os);
 151                 FcConfigDestroy(font_config);
 152                 return 0;
 153         }
 154
 155         fs = FcFontList(font_config, pat, os);
 156         FcPatternDestroy(pat);
 157         FcObjectSetDestroy(os);
 158         if (NULL == fs) {
 159                 ERR("FcFontList() Fail");
 160                 FcConfigDestroy(font_config);
 161                 return 0;
 162         }
 163
 164         INFO("fs->nfont = %d", fs->nfont);
 165
 166         int i;
 167         for (i = 0; i < fs->nfont; i++) {
 168                 FcChar8 *file = NULL;
 169                 FcChar8 *family = NULL;
 170
 171                 FcResult result;
 172                 result = FcPatternGetString(fs->fonts[i], FC_FILE, 0, &file);
 173                 if (FcResultMatch != result || NULL == file) {
 174                         ERR("FcPatternGetString() Fail(%d)", result);
 175                         FcFontSetDestroy(fs);
 176                         FcConfigDestroy(font_config);
 177                         return 0;
 178                 }
 179                 const char *preloaded = SETTING_FONT_PRELOAD_FONT_PATH;
 180                 const char *downloaded = SETTING_FONT_DOWNLOADED_FONT_PATH;
 181                 int preload_len = sizeof(SETTING_FONT_PRELOAD_FONT_PATH) - 1;
 182                 int download_len = sizeof(SETTING_FONT_DOWNLOADED_FONT_PATH) - 1;
 183
 184                 if (SST_EQUAL == strncmp((char*)file, preloaded, preload_len)
 185                         || SST_EQUAL == strncmp((char*)file, downloaded, download_len)) {
 186                         char *family_result = NULL;
 187                         FcChar8 *lang = NULL;
 188                         int id = 0;
 189                         if (FcPatternGetString(fs->fonts[i], FC_FAMILY, id, &family) != FcResultMatch)
 190                                 break;
 191                         if (FcPatternGetString(fs->fonts[i], FC_FAMILYLANG, id, &lang) != FcResultMatch)
 192                                 break;
 193                         family_result = (char*)family;
 194
 195                         /* Find proper family name for current locale. */
 196                         while (locale && family && lang) {
 197                                 if (SST_EQUAL == strncmp(locale, (char*)lang, strlen((char*)lang))) {
 198                                         family_result = (char*)family;
 199                                         break;
 200                                 }
 201
 202                                 /* I will set english as default family language. */
 203                                 /* If there is no proper family language for current locale, */
 204                                 /* we have to show the english family name. */
 205                                 if (SST_EQUAL == strcmp((char*)lang, "en"))
 206                                         family_result = (char*)family;
 207
 208                                 id++;
 209                                 if (FcPatternGetString(fs->fonts[i], FC_FAMILY, id, &family) != FcResultMatch)
 210                                         break;
 211                                 if (FcPatternGetString(fs->fonts[i], FC_FAMILYLANG, id, &lang) != FcResultMatch)
 212                                         break;
 213                         }
 214
 215                         if (family_result) {
 216                                 DBG("family = %s", family_result);
 217                                 if (strcmp(family_result, font_name) == 0) {
 218                                         ret = 1;
 219                                         break;
 220                                 }
 221                         }
 222                 }
 223         }
 224         FcFontSetDestroy(fs);
 225         FcConfigDestroy(font_config);
 226         return ret;
 227 }
 228
 229 API char* sstu_get_default_font()
 230 {
 231         return _get_main_font_family(SETTING_FONT_TIZEN_DEFAULT_FONT_ALIAS);
 232 }
 233
 234 static int _get_font_size()
 235 {
 236         int font_size = -1;
 237
 238         int vconf_value = -1;
 239         if (vconf_get_int(VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_SIZE, &vconf_value)) {
 240                 ERR("vconf_get_int() Fail");
 241                 return -1;
 242         }
 243
 244         switch (vconf_value) {
 245         case SYSTEM_SETTINGS_FONT_SIZE_SMALL:
 246                 font_size = SMALL_FONT_DPI;
 247                 break;
 248         case SYSTEM_SETTINGS_FONT_SIZE_NORMAL:
 249                 font_size = MIDDLE_FONT_DPI;
 250                 break;
 251         case SYSTEM_SETTINGS_FONT_SIZE_LARGE:
 252                 font_size = LARGE_FONT_DPI;
 253                 break;
 254         case SYSTEM_SETTINGS_FONT_SIZE_HUGE:
 255                 font_size = HUGE_FONT_DPI;
 256                 break;
 257         case SYSTEM_SETTINGS_FONT_SIZE_GIANT:
 258                 font_size = GIANT_FONT_DPI;
 259                 break;
 260         default:
 261                 font_size = MIDDLE_FONT_DPI;
 262                 break;
 263         }
 264         return font_size;
 265 }
 266
 267 API bool sstu_set_font_config(char *font_name)
 268 {
 269         int font_size = _get_font_size();
 270         return eext_config_font_set(font_name, font_size);
 271 }
 272
 273 API void sstu_set_font_size()
 274 {
 275         int font_size = _get_font_size();
 276         char *font_name = NULL;
 277         font_name = vconf_get_str(VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_NAME);
 278         eext_config_font_set(font_name, font_size);
 279         free(font_name);
 280 }