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