void litehtml::css_length::fromString( const tstring& str, const tstring& predefs, int defValue )
{
// TODO: Make support for calc
if(str.substr(0, 4) == _t("calc"))
{
m_is_predefined = true;
m_predef = 0;
return;
}
int predef = value_index(str.c_str(), predefs.c_str(), -1);
if(predef >= 0)
{
m_is_predefined = true;
m_predef = predef;
} else
{
m_is_predefined = false;
tstring num;
tstring un;
bool is_unit = false;
for(tstring::const_iterator chr = str.begin(); chr != str.end(); chr++)
{
if(!is_unit)
{
if(t_isdigit(*chr) || *chr == _t('.') || *chr == _t('+') || *chr == _t('-'))
{
num += *chr;
} else
{
is_unit = true;
}
}
if(is_unit)
{
un += *chr;
}
}
if(!num.empty())
{
m_value = (float) t_strtod(num.c_str(), 0);
m_units = (css_units) value_index(un.c_str(), css_units_strings, css_units_none);
} else
{
// not a number so it is predefined
m_is_predefined = true;
m_predef = defValue;
}
}
}
void litehtml::el_table::parse_styles(bool is_reparse)
{
html_tag::parse_styles(is_reparse);
m_border_collapse = (border_collapse) value_index(get_style_property(_t("border-collapse"), true, _t("separate")), border_collapse_strings, border_collapse_separate);
if(m_border_collapse == border_collapse_separate)
{
m_css_border_spacing_x.fromString(get_style_property(_t("-litehtml-border-spacing-x"), true, _t("0px")));
m_css_border_spacing_y.fromString(get_style_property(_t("-litehtml-border-spacing-y"), true, _t("0px")));
int fntsz = get_font_size();
document::ptr doc = get_document();
m_border_spacing_x = doc->cvt_units(m_css_border_spacing_x, fntsz);
m_border_spacing_y = doc->cvt_units(m_css_border_spacing_y, fntsz);
} else
{
m_border_spacing_x = 0;
m_border_spacing_y = 0;
m_padding.bottom = 0;
m_padding.top = 0;
m_padding.left = 0;
m_padding.right = 0;
m_css_padding.bottom.set_value(0, css_units_px);
m_css_padding.top.set_value(0, css_units_px);
m_css_padding.left.set_value(0, css_units_px);
m_css_padding.right.set_value(0, css_units_px);
}
}
void litehtml::el_before_after_base::add_style(const litehtml::style& st)
{
html_tag::add_style(st);
tstring content = get_style_property(_t("content"), false, _t(""));
if(!content.empty())
{
int idx = value_index(content.c_str(), content_property_string);
if(idx < 0)
{
tstring fnc;
tstring::size_type i = 0;
while(i < content.length() && i != tstring::npos)
{
if(content.at(i) == _t('"'))
{
fnc.clear();
i++;
tstring::size_type pos = content.find(_t('"'), i);
tstring txt;
if(pos == tstring::npos)
{
txt = content.substr(i);
i = tstring::npos;
} else
{
txt = content.substr(i, pos - i);
i = pos + 1;
}
add_text(txt);
} else if(content.at(i) == _t('('))
{
i++;
litehtml::trim(fnc);
litehtml::lcase(fnc);
tstring::size_type pos = content.find(_t(')'), i);
tstring params;
if(pos == tstring::npos)
{
params = content.substr(i);
i = tstring::npos;
} else
{
params = content.substr(i, pos - i);
i = pos + 1;
}
add_function(fnc, params);
fnc.clear();
} else
{
fnc += content.at(i);
i++;
}
}
}
}
}
void litehtml::el_before_after_base::add_function( const tstring& fnc, const tstring& params )
{
int idx = value_index(fnc.c_str(), _t("attr;counter;url"));
switch(idx)
{
// attr
case 0:
{
tstring p_name = params;
trim(p_name);
lcase(p_name);
element::ptr el_parent = parent();
if (el_parent)
{
const tchar_t* attr_value = el_parent->get_attr(p_name.c_str());
if (attr_value)
{
add_text(attr_value);
}
}
}
break;
// counter
case 1:
break;
// url
case 2:
{
tstring p_url = params;
trim(p_url);
if(!p_url.empty())
{
if(p_url.at(0) == _t('\'') || p_url.at(0) == _t('\"'))
{
p_url.erase(0, 1);
}
}
if(!p_url.empty())
{
if(p_url.at(p_url.length() - 1) == _t('\'') || p_url.at(p_url.length() - 1) == _t('\"'))
{
p_url.erase(p_url.length() - 1, 1);
}
}
if(!p_url.empty())
{
element::ptr el = std::make_shared<el_image>(get_document());
el->set_attr(_t("src"), p_url.c_str());
el->set_attr(_t("style"), _t("display:inline-block"));
el->set_tagName(_t("img"));
appendChild(el);
el->parse_attributes();
}
}
break;
}
}
void litehtml::el_table::parse_attributes()
{
const tchar_t* str = get_attr(_t("width"));
if(str)
{
m_style.add_property(_t("width"), str, 0, false);
}
str = get_attr(_t("align"));
if(str)
{
int align = value_index(str, _t("left;center;right"));
switch(align)
{
case 1:
m_style.add_property(_t("margin-left"), _t("auto"), 0, false);
m_style.add_property(_t("margin-right"), _t("auto"), 0, false);
break;
case 2:
m_style.add_property(_t("margin-left"), _t("auto"), 0, false);
m_style.add_property(_t("margin-right"), _t("0"), 0, false);
break;
}
}
str = get_attr(_t("cellspacing"));
if(str)
{
tstring val = str;
val += _t(" ");
val += str;
m_style.add_property(_t("border-spacing"), val.c_str(), 0, false);
}
str = get_attr(_t("border"));
if(str)
{
m_style.add_property(_t("border-width"), str, 0, false);
}
str = get_attr(_t("bgcolor"));
if (str)
{
m_style.add_property(_t("background-color"), str, 0, false);
}
html_tag::parse_attributes();
}
void litehtml::el_text::parse_styles(bool is_reparse)
{
m_text_transform = (text_transform) value_index(get_style_property(_t("text-transform"), true, _t("none")), text_transform_strings, text_transform_none);
if(m_text_transform != text_transform_none)
{
m_transformed_text = m_text;
m_use_transformed = true;
m_doc->container()->transform_text(m_transformed_text, m_text_transform);
}
if(is_white_space())
{
m_transformed_text = _t(" ");
m_use_transformed = true;
} else
{
if(m_text == _t("\t"))
{
m_transformed_text = _t(" ");
m_use_transformed = true;
}
if(m_text == _t("\n") || m_text == _t("\r"))
{
m_transformed_text = _t("");
m_use_transformed = true;
}
}
font_metrics fm;
uint_ptr font = m_parent->get_font(&fm);
if(is_break())
{
m_size.height = 0;
m_size.width = 0;
} else
{
m_size.height = fm.height;
m_size.width = m_doc->container()->text_width(m_use_transformed ? m_transformed_text.c_str() : m_text.c_str(), font);
}
m_draw_spaces = fm.draw_spaces;
}
litehtml::media_query::ptr litehtml::media_query::create_from_string(const tstring& str, const std::shared_ptr<document>& doc)
{
media_query::ptr query = std::make_shared<media_query>();
string_vector tokens;
split_string(str, tokens, _t(" \t\r\n"), _t(""), _t("("));
for(string_vector::iterator tok = tokens.begin(); tok != tokens.end(); tok++)
{
if((*tok) == _t("not"))
{
query->m_not = true;
} else if(tok->at(0) == _t('('))
{
tok->erase(0, 1);
if(tok->at(tok->length() - 1) == _t(')'))
{
tok->erase(tok->length() - 1, 1);
}
media_query_expression expr;
string_vector expr_tokens;
split_string((*tok), expr_tokens, _t(":"));
if(!expr_tokens.empty())
{
trim(expr_tokens[0]);
expr.feature = (media_feature) value_index(expr_tokens[0], media_feature_strings, media_feature_none);
if(expr.feature != media_feature_none)
{
if(expr_tokens.size() == 1)
{
expr.check_as_bool = true;
} else
{
trim(expr_tokens[1]);
expr.check_as_bool = false;
if(expr.feature == media_feature_orientation)
{
expr.val = value_index(expr_tokens[1], media_orientation_strings, media_orientation_landscape);
} else
{
tstring::size_type slash_pos = expr_tokens[1].find(_t('/'));
if( slash_pos != tstring::npos )
{
tstring val1 = expr_tokens[1].substr(0, slash_pos);
tstring val2 = expr_tokens[1].substr(slash_pos + 1);
trim(val1);
trim(val2);
expr.val = t_atoi(val1.c_str());
expr.val2 = t_atoi(val2.c_str());
} else
{
css_length length;
length.fromString(expr_tokens[1]);
if(length.units() == css_units_dpcm)
{
expr.val = (int) (length.val() * 2.54);
} else if(length.units() == css_units_dpi)
{
expr.val = (int) (length.val() * 2.54);
} else
{
if(doc)
{
doc->cvt_units(length, doc->container()->get_default_font_size());
}
expr.val = (int) length.val();
}
}
}
}
query->m_expressions.push_back(expr);
}
}
} else
{
query->m_media_type = (media_type) value_index((*tok), media_type_strings, media_type_all);
}
}
return query;
}
litehtml::uint_ptr litehtml::document::add_font(const wchar_t* name, int size,
const wchar_t* weight, const wchar_t* style,
const wchar_t* decoration) {
uint_ptr ret = 0;
if (!name || name && !wcscmp(name, L"inherit")) {
name = m_font_name.c_str();
}
if (!size) {
size = container()->get_default_font_size();
}
// convert integer to wchar_t crossplatform way
wchar_t strSize[20];
swprintf(strSize, sizeof(strSize) / sizeof(*strSize), L"%d", size);
std::wstring key = name;
key += L":";
key += strSize;
key += L":";
key += weight;
key += L":";
key += style;
key += L":";
key += decoration;
if (m_fonts.find(key) == m_fonts.end()) {
font_style fs = (font_style) value_index(style, font_style_strings,
fontStyleNormal);
int fw = value_index(weight, font_weight_strings, -1);
if (fw >= 0) {
switch (fw) {
case litehtml::fontWeightBold:
fw = FW_BOLD;
break;
case litehtml::fontWeightBolder:
fw = FW_SEMIBOLD;
break;
case litehtml::fontWeightLighter:
fw = FW_LIGHT;
break;
default:
fw = FW_NORMAL;
break;
}
} else {
fw = (int) wcstol(weight, NULL, 10);
if (fw < 100) {
fw = FW_NORMAL;
}
}
unsigned int decor = 0;
if (decoration) {
std::vector < std::wstring > tokens;
tokenize(decoration, tokens, L" ");
for (std::vector<std::wstring>::iterator i = tokens.begin();
i != tokens.end(); i++) {
if (!wcscmp(i->c_str(), L"underline")) {
decor |= font_decoration_underline;
} else if (!wcscmp(i->c_str(), L"line-through")) {
decor |= font_decoration_linethrough;
} else if (!wcscmp(i->c_str(), L"overline")) {
decor |= font_decoration_overline;
}
}
}
ret = m_container->create_font(name, size, fw, fs, decor);
m_fonts[key] = ret;
}
return ret;
}
