From 332c67c87b4074ca4414f3d84349f5d7f9dffd95 Mon Sep 17 00:00:00 2001 From: JucaBlues Date: Sun, 22 Jun 2008 22:48:08 +0000 Subject: [PATCH] reintroducing code that initially committed in revision 18594 and the have been reverted on revision 18607. * implemented handling of font-style, font-variant, font-weight, and font-stretch attributes on font-face tags This have been previously reverted because I thought they were already handled in node->style, but now I see that this code is needed for font description (used in the font tag to declare font attributes to be stored in the user agent font database). The node->style info is used for font specification (used by document authors with the purpose of declaring the properties of fonts that they would like in their SVG documents). --- src/sp-font-face.cpp | 375 +++++++++++++++++++++++++++++++++++++++++++ src/sp-font-face.h | 46 ++++++ 2 files changed, 421 insertions(+) diff --git a/src/sp-font-face.cpp b/src/sp-font-face.cpp index 31886b718..2a4716595 100644 --- a/src/sp-font-face.cpp +++ b/src/sp-font-face.cpp @@ -54,6 +54,240 @@ private: bool isset; }; +static std::vector sp_read_fontFaceStyleType(gchar const *value){ + std::vector v; + + if (!value){ + v.push_back(SP_FONTFACE_STYLE_ALL); + return v; + } + + if (strncmp(value, "all", 3) == 0){ + value += 3; + while(value[0]==',' || value[0]==' ') + value++; + v.push_back(SP_FONTFACE_STYLE_ALL); + return v; + } + + while(value[0]!='\0'){ + switch(value[0]){ + case 'n': + if (strncmp(value, "normal", 6) == 0){ + v.push_back(SP_FONTFACE_STYLE_NORMAL); + value += 6; + } + break; + case 'i': + if (strncmp(value, "italic", 6) == 0){ + v.push_back(SP_FONTFACE_STYLE_ITALIC); + value += 6; + } + break; + case 'o': + if (strncmp(value, "oblique", 7) == 0){ + v.push_back(SP_FONTFACE_STYLE_OBLIQUE); + value += 7; + } + break; + } + while(value[0]==',' || value[0]==' ') + value++; + } + return v; +} + +static std::vector sp_read_fontFaceVariantType(gchar const *value){ + std::vector v; + + if (!value){ + v.push_back(SP_FONTFACE_VARIANT_NORMAL); + return v; + } + + while(value[0]!='\0'){ + switch(value[0]){ + case 'n': + if (strncmp(value, "normal", 6) == 0){ + v.push_back(SP_FONTFACE_VARIANT_NORMAL); + value += 6; + } + break; + case 's': + if (strncmp(value, "small-caps", 10) == 0){ + v.push_back(SP_FONTFACE_VARIANT_SMALL_CAPS); + value += 10; + } + break; + } + while(value[0]==',' || value[0]==' ') + value++; + } + return v; +} + +static std::vector sp_read_fontFaceWeightType(gchar const *value){ + std::vector v; + + if (!value){ + v.push_back(SP_FONTFACE_WEIGHT_ALL); + return v; + } + + if (strncmp(value, "all", 3) == 0){ + value += 3; + while(value[0]==',' || value[0]==' ') + value++; + v.push_back(SP_FONTFACE_WEIGHT_ALL); + return v; + } + + while(value[0]!='\0'){ + switch(value[0]){ + case 'n': + if (strncmp(value, "normal", 6) == 0){ + v.push_back(SP_FONTFACE_WEIGHT_NORMAL); + value += 6; + } + break; + case 'b': + if (strncmp(value, "bold", 4) == 0){ + v.push_back(SP_FONTFACE_WEIGHT_BOLD); + value += 4; + } + break; + case '1': + if (strncmp(value, "100", 3) == 0){ + v.push_back(SP_FONTFACE_WEIGHT_100); + value += 3; + } + break; + case '2': + if (strncmp(value, "200", 3) == 0){ + v.push_back(SP_FONTFACE_WEIGHT_200); + value += 3; + } + break; + case '3': + if (strncmp(value, "300", 3) == 0){ + v.push_back(SP_FONTFACE_WEIGHT_300); + value += 3; + } + break; + case '4': + if (strncmp(value, "400", 3) == 0){ + v.push_back(SP_FONTFACE_WEIGHT_400); + value += 3; + } + break; + case '5': + if (strncmp(value, "500", 3) == 0){ + v.push_back(SP_FONTFACE_WEIGHT_500); + value += 3; + } + break; + case '6': + if (strncmp(value, "600", 3) == 0){ + v.push_back(SP_FONTFACE_WEIGHT_600); + value += 3; + } + break; + case '7': + if (strncmp(value, "700", 3) == 0){ + v.push_back(SP_FONTFACE_WEIGHT_700); + value += 3; + } + break; + case '8': + if (strncmp(value, "800", 3) == 0){ + v.push_back(SP_FONTFACE_WEIGHT_800); + value += 3; + } + break; + case '9': + if (strncmp(value, "900", 3) == 0){ + v.push_back(SP_FONTFACE_WEIGHT_900); + value += 3; + } + break; + } + while(value[0]==',' || value[0]==' ') + value++; + } + return v; +} + +static std::vector sp_read_fontFaceStretchType(gchar const *value){ + std::vector v; + + if (!value){ + v.push_back(SP_FONTFACE_STRETCH_NORMAL); + return v; + } + + if (strncmp(value, "all", 3) == 0){ + value += 3; + while(value[0]==',' || value[0]==' ') + value++; + v.push_back(SP_FONTFACE_STRETCH_ALL); + return v; + } + + while(value[0]!='\0'){ + switch(value[0]){ + case 'n': + if (strncmp(value, "normal", 6) == 0){ + v.push_back(SP_FONTFACE_STRETCH_NORMAL); + value += 6; + } + break; + case 'u': + if (strncmp(value, "ultra-condensed", 15) == 0){ + v.push_back(SP_FONTFACE_STRETCH_ULTRA_CONDENSED); + value += 15; + } + if (strncmp(value, "ultra-expanded", 14) == 0){ + v.push_back(SP_FONTFACE_STRETCH_ULTRA_EXPANDED); + value += 14; + } + break; + case 'e': + if (strncmp(value, "expanded", 8) == 0){ + v.push_back(SP_FONTFACE_STRETCH_EXPANDED); + value += 8; + } + if (strncmp(value, "extra-condensed", 15) == 0){ + v.push_back(SP_FONTFACE_STRETCH_EXTRA_CONDENSED); + value += 15; + } + if (strncmp(value, "extra-expanded", 14) == 0){ + v.push_back(SP_FONTFACE_STRETCH_EXTRA_EXPANDED); + value += 14; + } + break; + case 'c': + if (strncmp(value, "condensed", 9) == 0){ + v.push_back(SP_FONTFACE_STRETCH_CONDENSED); + value += 9; + } + break; + case 's': + if (strncmp(value, "semi-condensed", 14) == 0){ + v.push_back(SP_FONTFACE_STRETCH_SEMI_CONDENSED); + value += 14; + } + if (strncmp(value, "semi-expanded", 13) == 0){ + v.push_back(SP_FONTFACE_STRETCH_SEMI_EXPANDED); + value += 13; + } + break; + } + while(value[0]==',' || value[0]==' ') + value++; + } + return v; +} + static void sp_fontface_class_init(SPFontFaceClass *fc); static void sp_fontface_init(SPFontFace *font); @@ -108,7 +342,28 @@ static void sp_fontface_class_init(SPFontFaceClass *fc) static void sp_fontface_init(SPFontFace *face) { + std::vector style; + style.push_back(SP_FONTFACE_STYLE_ALL); + face->font_style = style; + + std::vector variant; + variant.push_back(SP_FONTFACE_VARIANT_NORMAL); + face->font_variant = variant; + + std::vector weight; + weight.push_back(SP_FONTFACE_WEIGHT_ALL); + face->font_weight = weight; + + std::vector stretch; + stretch.push_back(SP_FONTFACE_STRETCH_NORMAL); + face->font_stretch = stretch; /* + face->font_family = NULL; + //face->font_style = ; + //face->font_variant = ; + //face->font_weight = ; + //face->font_stretch = ; + face->font_size = NULL; //face->unicode_range = ; face->units_per_em = 1000; //face->panose_1 = ; @@ -145,6 +400,12 @@ static void sp_fontface_build(SPObject *object, SPDocument *document, Inkscape:: ((SPObjectClass *) (parent_class))->build(object, document, repr); } + sp_object_read_attr(object, "font-family"); + sp_object_read_attr(object, "font-style"); + sp_object_read_attr(object, "font-variant"); + sp_object_read_attr(object, "font-weight"); + sp_object_read_attr(object, "font-stretch"); + sp_object_read_attr(object, "font-size"); sp_object_read_attr(object, "unicode-range"); sp_object_read_attr(object, "units-per-em"); sp_object_read_attr(object, "panose-1"); @@ -222,8 +483,104 @@ static void sp_fontface_set(SPObject *object, unsigned int key, const gchar *val { SPFontFace *face = SP_FONTFACE(object); double number; + std::vector style; + std::vector variant; + std::vector weight; + std::vector stretch; switch (key) { + case SP_PROP_FONT_STYLE: + style = sp_read_fontFaceStyleType(value); + if (face->font_style.size() != style.size()){ + face->font_style = style; +g_warning(": SP_ATTR_FONT_STYLE:"); + for (unsigned int i=0;irequestModified(SP_OBJECT_MODIFIED_FLAG); + } else { + for (unsigned int i=0;ifont_style[i]){ + face->font_style = style; +g_warning(": SP_ATTR_FONT_STYLE:"); + for (unsigned int i=0;irequestModified(SP_OBJECT_MODIFIED_FLAG); + break; + } + } + } + break; + case SP_PROP_FONT_VARIANT: + variant = sp_read_fontFaceVariantType(value); + if (face->font_variant.size() != variant.size()){ + face->font_variant = variant; +g_warning(": SP_ATTR_FONT_VARIANT:"); + for (unsigned int i=0;irequestModified(SP_OBJECT_MODIFIED_FLAG); + } else { + for (unsigned int i=0;ifont_variant[i]){ + face->font_variant = variant; +g_warning(": SP_ATTR_FONT_VARIANT:"); + for (unsigned int i=0;irequestModified(SP_OBJECT_MODIFIED_FLAG); + break; + } + } + } + break; + case SP_PROP_FONT_WEIGHT: + weight = sp_read_fontFaceWeightType(value); + if (face->font_weight.size() != weight.size()){ + face->font_weight = weight; +g_warning(": SP_ATTR_FONT_WEIGHT:"); + for (unsigned int i=0;irequestModified(SP_OBJECT_MODIFIED_FLAG); + } else { + for (unsigned int i=0;ifont_weight[i]){ + face->font_weight = weight; +g_warning(": SP_ATTR_FONT_WEIGHT:"); + for (unsigned int i=0;irequestModified(SP_OBJECT_MODIFIED_FLAG); + break; + } + } + } + break; + case SP_PROP_FONT_STRETCH: + stretch = sp_read_fontFaceStretchType(value); + if (face->font_stretch.size() != stretch.size()){ + face->font_stretch = stretch; +g_warning(": SP_ATTR_FONT_STRETCH:"); + for (unsigned int i=0;irequestModified(SP_OBJECT_MODIFIED_FLAG); + } else { + for (unsigned int i=0;ifont_stretch[i]){ + face->font_stretch = stretch; +g_warning(": SP_ATTR_FONT_STRETCH:"); + for (unsigned int i=0;irequestModified(SP_OBJECT_MODIFIED_FLAG); + break; + } + } + } + break; case SP_ATTR_UNITS_PER_EM: number = helperfns_read_number(value); if (number != face->units_per_em){ @@ -423,6 +780,12 @@ static void sp_fontface_update(SPObject *object, SPCtx *ctx, guint flags) { if (flags & (SP_OBJECT_MODIFIED_FLAG)) { + sp_object_read_attr(object, "font-family"); + sp_object_read_attr(object, "font-style"); + sp_object_read_attr(object, "font-variant"); + sp_object_read_attr(object, "font-weight"); + sp_object_read_attr(object, "font-stretch"); + sp_object_read_attr(object, "font-size"); sp_object_read_attr(object, "unicode-range"); sp_object_read_attr(object, "units-per-em"); sp_object_read_attr(object, "panose-1"); @@ -468,6 +831,12 @@ static Inkscape::XML::Node *sp_fontface_write(SPObject *object, Inkscape::XML::D } //TODO: + //sp_repr_set_svg_double(repr, "font-family", face->font_family); + //sp_repr_set_svg_double(repr, "font-style", face->font_style); + //sp_repr_set_svg_double(repr, "font-variant", face->font_variant); + //sp_repr_set_svg_double(repr, "font-weight", face->font_weight); + //sp_repr_set_svg_double(repr, "font-stretch", face->font_stretch); + //sp_repr_set_svg_double(repr, "font-size", face->font_size); //sp_repr_set_svg_double(repr, "unicode-range", face->unicode_range); sp_repr_set_svg_double(repr, "units-per-em", face->units_per_em); //sp_repr_set_svg_double(repr, "panose-1", face->panose_1); @@ -497,6 +866,12 @@ static Inkscape::XML::Node *sp_fontface_write(SPObject *object, Inkscape::XML::D sp_repr_set_svg_double(repr, "overline-thickness", face->overline_thickness); if (repr != SP_OBJECT_REPR(object)) { + COPY_ATTR(repr, object->repr, "font-family"); + COPY_ATTR(repr, object->repr, "font-style"); + COPY_ATTR(repr, object->repr, "font-variant"); + COPY_ATTR(repr, object->repr, "font-weight"); + COPY_ATTR(repr, object->repr, "font-stretch"); + COPY_ATTR(repr, object->repr, "font-size"); COPY_ATTR(repr, object->repr, "unicode-range"); COPY_ATTR(repr, object->repr, "units-per-em"); COPY_ATTR(repr, object->repr, "panose-1"); diff --git a/src/sp-font-face.h b/src/sp-font-face.h index d4ac8790a..156ab63d0 100644 --- a/src/sp-font-face.h +++ b/src/sp-font-face.h @@ -26,11 +26,57 @@ #define SP_IS_FONTFACE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SP_TYPE_FONTFACE)) #define SP_IS_FONTFACE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), SP_TYPE_FONTFACE)) +enum FontFaceStyleType{ + SP_FONTFACE_STYLE_ALL, + SP_FONTFACE_STYLE_NORMAL, + SP_FONTFACE_STYLE_ITALIC, + SP_FONTFACE_STYLE_OBLIQUE +}; + +enum FontFaceVariantType{ + SP_FONTFACE_VARIANT_NORMAL, + SP_FONTFACE_VARIANT_SMALL_CAPS +}; + +enum FontFaceWeightType{ + SP_FONTFACE_WEIGHT_ALL, + SP_FONTFACE_WEIGHT_NORMAL, + SP_FONTFACE_WEIGHT_BOLD, + SP_FONTFACE_WEIGHT_100, + SP_FONTFACE_WEIGHT_200, + SP_FONTFACE_WEIGHT_300, + SP_FONTFACE_WEIGHT_400, + SP_FONTFACE_WEIGHT_500, + SP_FONTFACE_WEIGHT_600, + SP_FONTFACE_WEIGHT_700, + SP_FONTFACE_WEIGHT_800, + SP_FONTFACE_WEIGHT_900 +}; + +enum FontFaceStretchType{ + SP_FONTFACE_STRETCH_ALL, + SP_FONTFACE_STRETCH_NORMAL, + SP_FONTFACE_STRETCH_ULTRA_CONDENSED, + SP_FONTFACE_STRETCH_EXTRA_CONDENSED, + SP_FONTFACE_STRETCH_CONDENSED, + SP_FONTFACE_STRETCH_SEMI_CONDENSED, + SP_FONTFACE_STRETCH_SEMI_EXPANDED, + SP_FONTFACE_STRETCH_EXPANDED, + SP_FONTFACE_STRETCH_EXTRA_EXPANDED, + SP_FONTFACE_STRETCH_ULTRA_EXPANDED +}; + enum FontFaceUnicodeRangeType{ FONTFACE_UNICODERANGE_FIXME_HERE, }; struct SPFontFace : public SPObject { + char* font_family; + std::vector font_style; + std::vector font_variant; + std::vector font_weight; + std::vector font_stretch; + char* font_size; std::vector unicode_range; double units_per_em; std::vector panose_1; -- 2.30.2