firka/flutter
3
0
Fork 1
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge "Remove CSS string doLayout entrypoint and supporting code" into lmp-dev

Browse Source
This commit is contained in:
Behdad Esfahbod
2014-07-29 20:47:02 +00:00
committed by Android (Google) Code Review
parent f3879f9b1f bff381b1be
commit 2d51f518d2
5 changed files with 0 additions and 369 deletions
Download Patch File Download Diff File Expand all files Collapse all files

108
engine/src/flutter/include/minikin/CssParse.h
View File

@@ -1,108 +0,0 @@
/*
* Copyright (C) 2013 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef MINIKIN_CSS_PARSE_H
#define MINIKIN_CSS_PARSE_H
#include <map>
#include <string>
namespace android {
enum CssTag {
unknown,
fontScaleX,
fontSize,
fontSkewX,
fontStyle,
fontWeight,
cssLang,
letterSpacing,
minikinBidi,
minikinHinting,
minikinVariant,
paintFlags,
};
const std::string cssTagNames[] = {
"unknown",
"font-scale-x",
"font-size",
"font-skew-x",
"font-style",
"font-weight",
"lang",
"letter-spacing",
"-minikin-bidi",
"-minikin-hinting",
"-minikin-variant",
"-paint-flags",
};
class CssValue {
public:
enum Type {
UNKNOWN,
DOUBLE,
STRING
};
enum Units {
SCALAR,
PERCENT,
PX,
EM
};
CssValue() : mType(UNKNOWN) { }
explicit CssValue(double v) :
mType(DOUBLE), doubleValue(v), mUnits(SCALAR) { }
Type getType() const { return mType; }
double getDoubleValue() const { return doubleValue; }
int32_t getIntValue() const { return doubleValue; }
uint32_t getUintValue() const { return doubleValue; }
std::string getStringValue() const { return stringValue; }
std::string toString(CssTag tag) const;
void setDoubleValue(double v) {
mType = DOUBLE;
doubleValue = v;
}
void setStringValue(const std::string& v) {
mType = STRING;
stringValue = v;
}
private:
Type mType;
double doubleValue;
std::string stringValue;
Units mUnits;
};
class CssProperties {
public:
bool parse(const std::string& str);
bool hasTag(CssTag tag) const;
CssValue value(CssTag tag) const;
// primarily for debugging
std::string toString() const;
private:
// We'll use STL map for now but can replace it with something
// more efficient if needed
std::map<CssTag, CssValue> mMap;
};
} // namespace android
#endif // MINIKIN_CSS_PARSE_H

5
engine/src/flutter/include/minikin/Layout.h
View File

@@ -21,7 +21,6 @@
#include <vector>
#include <minikin/CssParse.h>
#include <minikin/FontCollection.h>
#include <minikin/MinikinFontFreeType.h>
@@ -68,10 +67,6 @@ public:
void dump() const;
void setFontCollection(const FontCollection* collection);
// Deprecated. Will be removed.
void doLayout(const uint16_t* buf, size_t start, size_t count, size_t bufSize,
const std::string& css);
void doLayout(const uint16_t* buf, size_t start, size_t count, size_t bufSize,
int bidiFlags, const FontStyle &style, const MinikinPaint &paint);

1
engine/src/flutter/libs/minikin/Android.mk
View File

@@ -20,7 +20,6 @@ include external/stlport/libstlport.mk
LOCAL_SRC_FILES := \
AnalyzeStyle.cpp \
CmapCoverage.cpp \
CssParse.cpp \
FontCollection.cpp \
FontFamily.cpp \
GraphemeBreak.cpp \

210
engine/src/flutter/libs/minikin/CssParse.cpp
View File

@@ -1,210 +0,0 @@
/*
* Copyright (C) 2013 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <string>
#include <cstdlib>
#include <cstring>
#include <cstdio> // for sprintf - for debugging
#include <minikin/CssParse.h>
#include <minikin/FontFamily.h>
using std::map;
using std::pair;
using std::string;
namespace android {
static bool strEqC(const string str, size_t off, size_t len, const char* str2) {
if (len != strlen(str2)) return false;
return !memcmp(str.data() + off, str2, len);
}
static CssTag parseTag(const string str, size_t off, size_t len) {
if (len == 0) return unknown;
char c = str[off];
if (c == 'f') {
if (strEqC(str, off, len, "font-scale-x")) return fontScaleX;
if (strEqC(str, off, len, "font-size")) return fontSize;
if (strEqC(str, off, len, "font-skew-x")) return fontSkewX;
if (strEqC(str, off, len, "font-weight")) return fontWeight;
if (strEqC(str, off, len, "font-style")) return fontStyle;
} else if (c == 'l') {
if (strEqC(str, off, len, "lang")) return cssLang;
if (strEqC(str, off, len, "letter-spacing")) return letterSpacing;
} else if (c == '-') {
if (strEqC(str, off, len, "-minikin-bidi")) return minikinBidi;
if (strEqC(str, off, len, "-minikin-hinting")) return minikinHinting;
if (strEqC(str, off, len, "-minikin-variant")) return minikinVariant;
if (strEqC(str, off, len, "-paint-flags")) return paintFlags;
}
return unknown;
}
static bool parseStringValue(const string& str, size_t* off, size_t len, CssTag tag, CssValue* v) {
const char* data = str.data();
size_t beg = *off;
if (beg == len) return false;
char first = data[beg];
bool quoted = false;
if (first == '\'' || first == '\"') {
quoted = true;
beg++;
}
size_t end;
for (end = beg; end < len; end++) {
char c = data[end];
if (quoted && c == first) {
v->setStringValue(std::string(str, beg, end - beg));
*off = end + 1;
return true;
} else if (!quoted && (c == ';' || c == ' ')) {
break;
} // TODO: deal with backslash escape, but only important for real strings
}
v->setStringValue(std::string(str, beg, end - beg));
*off = end;
return true;
}
static bool parseValue(const string& str, size_t* off, size_t len, CssTag tag, CssValue* v) {
if (tag == cssLang) {
return parseStringValue(str, off, len, tag, v);
}
const char* data = str.data();
char* endptr;
double fv = strtod(data + *off, &endptr);
if (endptr == data + *off) {
// No numeric value, try tag-specific idents
size_t end;
for (end = *off; end < len; end++) {
char c = data[end];
if (c != '-' && !(c >= 'a' && c <= 'z') &&
!(c >= '0' && c <= '9')) break;
}
size_t taglen = end - *off;
endptr += taglen;
if (tag == fontStyle) {
if (strEqC(str, *off, taglen, "normal")) {
fv = 0;
} else if (strEqC(str, *off, taglen, "italic")) {
fv = 1;
// TODO: oblique, but who really cares?
} else {
return false;
}
} else if (tag == fontWeight) {
if (strEqC(str, *off, taglen, "normal")) {
fv = 400;
} else if (strEqC(str, *off, taglen, "bold")) {
fv = 700;
} else {
return false;
}
} else if (tag == minikinVariant) {
if (strEqC(str, *off, taglen, "compact")) {
fv = VARIANT_COMPACT;
} else if (strEqC(str, *off, taglen, "elegant")) {
fv = VARIANT_ELEGANT;
}
} else {
return false;
}
}
v->setDoubleValue(fv);
*off = endptr - data;
return true;
}
string CssValue::toString(CssTag tag) const {
if (mType == DOUBLE) {
if (tag == fontStyle) {
return doubleValue ? "italic" : "normal";
} else if (tag == minikinVariant) {
if (doubleValue == VARIANT_COMPACT) return "compact";
if (doubleValue == VARIANT_ELEGANT) return "elegant";
}
char buf[64];
sprintf(buf, "%g", doubleValue);
return string(buf);
} else if (mType == STRING) {
return stringValue; // should probably quote
}
return "";
}
bool CssProperties::parse(const string& str) {
size_t len = str.size();
size_t i = 0;
while (true) {
size_t j = i;
while (j < len && str[j] == ' ') j++;
if (j == len) break;
size_t k = str.find_first_of(':', j);
if (k == string::npos) {
return false; // error: junk after end
}
CssTag tag = parseTag(str, j, k - j);
#ifdef VERBOSE
printf("parseTag result %d, ijk %lu %lu %lu\n", tag, i, j, k);
#endif
if (tag == unknown) return false; // error: unknown tag
k++; // skip over colon
while (k < len && str[k] == ' ') k++;
if (k == len) return false; // error: missing value
CssValue v;
if (!parseValue(str, &k, len, tag, &v)) break;
#ifdef VERBOSE
printf("parseValue ok\n");
#endif
mMap.insert(pair<CssTag, CssValue>(tag, v));
while (k < len && str[k] == ' ') k++;
if (k < len) {
if (str[k] != ';') return false;
k++;
}
i = k;
}
return true;
}
bool CssProperties::hasTag(CssTag tag) const {
return (mMap.find(tag) != mMap.end());
}
CssValue CssProperties::value(CssTag tag) const {
map<CssTag, CssValue>::const_iterator it = mMap.find(tag);
if (it == mMap.end()) {
CssValue unknown;
return unknown;
} else {
return it->second;
}
}
string CssProperties::toString() const {
string result;
for (map<CssTag, CssValue>::const_iterator it = mMap.begin();
it != mMap.end(); it++) {
result += cssTagNames[it->first];
result += ": ";
result += it->second.toString(it->first);
result += ";\n";
}
return result;
}
} // namespace android

45
engine/src/flutter/libs/minikin/Layout.cpp
View File

@@ -354,27 +354,6 @@ int Layout::findFace(FakedFont face, LayoutContext* ctx) {
return ix;
}
static FontStyle styleFromCss(const CssProperties &props) {
int weight = 4;
if (props.hasTag(fontWeight)) {
weight = props.value(fontWeight).getIntValue() / 100;
}
bool italic = false;
if (props.hasTag(fontStyle)) {
italic = props.value(fontStyle).getIntValue() != 0;
}
FontLanguage lang;
if (props.hasTag(cssLang)) {
string langStr = props.value(cssLang).getStringValue();
lang = FontLanguage(langStr.c_str(), langStr.size());
}
int variant = 0;
if (props.hasTag(minikinVariant)) {
variant = props.value(minikinVariant).getIntValue();
}
return FontStyle(lang, variant, weight, italic);
}
static hb_script_t codePointToScript(hb_codepoint_t codepoint) {
static hb_unicode_funcs_t* u = 0;
if (!u) {
@@ -495,30 +474,6 @@ static void clearHbFonts(LayoutContext* ctx) {
ctx->hbFonts.clear();
}
void Layout::doLayout(const uint16_t* buf, size_t start, size_t count, size_t bufSize,
const string& css) {
CssProperties props;
props.parse(css);
FontStyle style = styleFromCss(props);
MinikinPaint paint;
paint.size = props.value(fontSize).getDoubleValue();
paint.scaleX = props.hasTag(fontScaleX)
? props.value(fontScaleX).getDoubleValue() : 1;
paint.skewX = props.hasTag(fontSkewX)
? props.value(fontSkewX).getDoubleValue() : 0;
paint.letterSpacing = props.hasTag(letterSpacing)
? props.value(letterSpacing).getDoubleValue() : 0;
paint.paintFlags = props.hasTag(paintFlags)
? props.value(paintFlags).getUintValue() : 0;
int bidiFlags = props.hasTag(minikinBidi) ? props.value(minikinBidi).getIntValue() : 0;
doLayout(buf, start, count, bufSize, bidiFlags, style, paint);
}
void Layout::doLayout(const uint16_t* buf, size_t start, size_t count, size_t bufSize,
int bidiFlags, const FontStyle &style, const MinikinPaint &paint) {
AutoMutex _l(gMinikinLock);