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