src/libnrtype/nr-type-pos-def.cpp

   1 #include "nr-type-pos-def.h"
   2 #include <glib.h>
   3 #include <string.h>
   4
   5 /**
   6  * Given a font name or style name, returns a constant describing its
   7  * apparent style (normal/italic/oblique).
   8 */
   9 int
  10 parse_name_for_style (char const *cc)
  11 {
  12         g_assert ( cc != NULL );
  13         gchar *c = g_ascii_strdown (cc, -1);
  14
  15         gint style;
  16         // first dab at i18n... french and german
  17         if (strstr (c, "italic") || strstr (c, "italique") || strstr (c, "kursiv")) {
  18                 style = NR_POS_STYLE_ITALIC;
  19         } else if (strstr (c, "oblique")) {
  20                 style = NR_POS_STYLE_OBLIQUE;
  21         } else {
  22                 style = NR_POS_STYLE_NORMAL;
  23         }
  24
  25         g_free (c);
  26         return style;
  27 }
  28
  29
  30 /**
  31  * Given a font name or style name, returns a constant describing its
  32  * apparent weight.
  33 */
  34 int
  35 parse_name_for_weight (char const *cc)
  36 {
  37         g_assert ( cc != NULL );
  38         gchar *c = g_ascii_strdown (cc, -1);
  39
  40         gint weight;
  41         if (strstr (c, "thin")) {
  42                 weight = NR_POS_WEIGHT_THIN;
  43         } else if (strstr (c, "extra light")) {
  44                 weight = NR_POS_WEIGHT_EXTRA_LIGHT;
  45         } else if (strstr (c, "ultra light")) {
  46                 weight = NR_POS_WEIGHT_ULTRA_LIGHT;
  47         } else if (strstr (c, "light")) {
  48                 weight = NR_POS_WEIGHT_LIGHT;
  49         } else if (strstr (c, "book")) {
  50                 weight = NR_POS_WEIGHT_BOOK;
  51         } else if (strstr (c, "medium")) {
  52                 weight = NR_POS_WEIGHT_MEDIUM;
  53         } else if (strstr (c, "semi bold")) {
  54                 weight = NR_POS_WEIGHT_SEMIBOLD;
  55         } else if (strstr (c, "semibold")) {
  56                 weight = NR_POS_WEIGHT_SEMIBOLD;
  57         } else if (strstr (c, "demi bold")) {
  58                 weight = NR_POS_WEIGHT_DEMIBOLD;
  59         } else if (strstr (c, "demibold") || strstr (c, "demi")) {
  60                 weight = NR_POS_WEIGHT_DEMIBOLD;
  61         } else if (strstr (c, "ultra bold")) {
  62                 weight = NR_POS_WEIGHT_ULTRA_BOLD;
  63         } else if (strstr (c, "extra bold") || strstr (c, "xbold") || strstr (c, "xtrabold")) {
  64                 weight = NR_POS_WEIGHT_EXTRA_BOLD;
  65         } else if (strstr (c, "black") || strstr (c, "heavy")) {
  66                 weight = NR_POS_WEIGHT_BLACK;
  67         } else if (strstr (c, "bold")) {
  68                 /* Must come after the checks for `blah bold'. */
  69                 weight = NR_POS_WEIGHT_BOLD;
  70         } else {
  71                 weight = NR_POS_WEIGHT_NORMAL;
  72         }
  73
  74         g_free (c);
  75         return weight;
  76 }
  77
  78 /**
  79  * Given a font name or style name, returns a constant describing its
  80  * apparent stretch.
  81 */
  82 int
  83 parse_name_for_stretch (char const *cc)
  84 {
  85         g_assert ( cc != NULL );
  86         gchar *c = g_ascii_strdown (cc, -1);
  87
  88         gint stretch;
  89         if (strstr (c, "ultra narrow") || strstr (c, "ultra condensed") || strstr (c, "extra condensed")) {
  90                 stretch = NR_POS_STRETCH_EXTRA_CONDENSED;
  91         } else if (strstr (c, "ultra wide") || strstr (c, "ultra expanded") || strstr (c, "ultra extended")  || strstr (c, "extra expanded")) {
  92                 stretch = NR_POS_STRETCH_EXTRA_EXPANDED;
  93         } else if (strstr (c, "semi condensed") || strstr (c, "semicondensed")) {
  94                 stretch = NR_POS_STRETCH_SEMI_CONDENSED;
  95         } else if (strstr (c, "semi extended") || strstr (c, "semiextended")) {
  96                 stretch = NR_POS_STRETCH_SEMI_EXPANDED;
  97         } else if (strstr (c, "narrow") || strstr (c, "condensed")) {
  98                 stretch = NR_POS_STRETCH_CONDENSED;
  99         } else if (strstr (c, "wide") || strstr (c, "expanded") || strstr (c, "extended")) {
 100                 stretch = NR_POS_STRETCH_EXPANDED;
 101         } else {
 102                 stretch = NR_POS_STRETCH_NORMAL;
 103         }
 104
 105         g_free (c);
 106         return stretch;
 107 }
 108
 109 /**
 110  * Given a font name or style name, returns a constant describing its
 111  * apparent variant (normal/smallcaps).
 112 */
 113 int
 114 parse_name_for_variant (char const *cc)
 115 {
 116         g_assert ( cc != NULL );
 117         gchar *c = g_ascii_strdown (cc, -1);
 118
 119         gint variant;
 120         if (strstr (c, "small caps") || strstr (c, "smallcaps") || strstr (c, "caps")) {
 121                 variant = NR_POS_VARIANT_SMALLCAPS;
 122         } else {
 123                 variant = NR_POS_VARIANT_NORMAL;
 124         }
 125
 126         g_free (c);
 127         return variant;
 128 }
 129
 130 /**
 131  * Given a style constant, returns the CSS value for font-style.
 132 */
 133 const char *
 134 style_to_css (int style)
 135 {
 136         switch (style) {
 137         case NR_POS_STYLE_NORMAL:
 138                 return "normal";
 139                 break;
 140   case NR_POS_STYLE_ITALIC:
 141                 return "italic";
 142                 break;
 143   case NR_POS_STYLE_OBLIQUE:
 144                 return "oblique";
 145                 break;
 146         default:
 147                 break;
 148         }
 149         return NULL;
 150 }
 151
 152
 153 /**
 154  * Given a weight constant, returns the CSS value for font-weight.
 155 */
 156 const char *
 157 weight_to_css (int weight)
 158 {
 159         switch (weight) {
 160         case NR_POS_WEIGHT_THIN:
 161                 return "100";
 162                 break;
 163   case NR_POS_WEIGHT_EXTRA_LIGHT:
 164                 return "200";
 165                 break;
 166   case NR_POS_WEIGHT_LIGHT:
 167                 return "300";
 168                 break;
 169   case NR_POS_WEIGHT_BOOK:
 170                 return "normal";
 171                 break;
 172   case NR_POS_WEIGHT_MEDIUM:
 173                 return "500";
 174                 break;
 175   case NR_POS_WEIGHT_SEMIBOLD:
 176                 return "600";
 177                 break;
 178   case NR_POS_WEIGHT_BOLD:
 179                 return "bold";
 180                 break;
 181   case NR_POS_WEIGHT_EXTRA_BOLD:
 182                 return "800";
 183                 break;
 184         case NR_POS_WEIGHT_BLACK:
 185                 return "900";
 186                 break;
 187         default:
 188                 break;
 189         }
 190         return NULL;
 191 }
 192
 193 /**
 194  * Given a stretch constant, returns the CSS value for font-stretch.
 195 */
 196 const char *
 197 stretch_to_css (int stretch)
 198 {
 199         switch (stretch) {
 200         case NR_POS_STRETCH_EXTRA_CONDENSED:
 201                 return "extra-condensed";
 202                 break;
 203         case NR_POS_STRETCH_CONDENSED:
 204                 return "condensed";
 205                 break;
 206         case NR_POS_STRETCH_SEMI_CONDENSED:
 207                 return "semi-condensed";
 208                 break;
 209         case NR_POS_STRETCH_NORMAL:
 210                 return "normal";
 211                 break;
 212         case NR_POS_STRETCH_SEMI_EXPANDED:
 213                 return "semi-expanded";
 214                 break;
 215         case NR_POS_STRETCH_EXPANDED:
 216                 return "expanded";
 217                 break;
 218         case NR_POS_STRETCH_EXTRA_EXPANDED:
 219                 return "extra-expanded";
 220                 break;
 221         default:
 222                 break;
 223         }
 224         return NULL;
 225 }
 226
 227 /**
 228  * Given a variant constant, returns the CSS value for font-variant.
 229 */
 230 const char *
 231 variant_to_css (int stretch)
 232 {
 233         switch (stretch) {
 234         case NR_POS_VARIANT_SMALLCAPS:
 235                 return "small-caps";
 236                 break;
 237         case NR_POS_VARIANT_NORMAL:
 238                 return "normal";
 239                 break;
 240         default:
 241                 break;
 242         }
 243         return NULL;
 244 }
 245
 246
 247 /**
 248  * Constructor for NRTypePostDef.  Sets the italic, oblique, weight,
 249  * stretch, and variant.
 250  */
 251 NRTypePosDef::NRTypePosDef(char const *description) {
 252         // we cannot use strcasestr, it's linux only... so we must lowercase the string first
 253         g_assert ( description != NULL );
 254         gchar *c = g_ascii_strdown (description, -1);
 255
 256         /* copied from nr-type-directory.cpp:nr_type_calculate_position. */
 257
 258         italic = (strstr (c, "italic") != NULL);
 259         oblique = (strstr (c, "oblique") != NULL);
 260
 261         weight = parse_name_for_weight (c);
 262
 263         stretch = parse_name_for_stretch (c);
 264
 265         variant = parse_name_for_variant (c);
 266
 267         g_free (c);
 268 }