void WebKitCSSKeyframesRule::insertRule(const String& rule)
{
CSSParser p(useStrictParsing());
RefPtr<CSSRule> newRule = p.parseKeyframeRule(parentStyleSheet(), rule);
if (newRule.get() && newRule.get()->isKeyframeRule())
append(static_cast<WebKitCSSKeyframeRule*>(newRule.get()));
}
void WebKitCSSMatrix::setMatrixValue(const String& string, ExceptionCode& ec)
{
CSSParser p(useStrictParsing());
RefPtr<CSSMutableStyleDeclaration> styleDeclaration = CSSMutableStyleDeclaration::create();
if (p.parseValue(styleDeclaration.get(), CSSPropertyWebkitTransform, string, true)) {
// Convert to TransformOperations. This can fail if a property
// requires style (i.e., param uses 'ems' or 'exs')
PassRefPtr<CSSValue> val = styleDeclaration->getPropertyCSSValue(CSSPropertyWebkitTransform);
TransformOperations operations;
if (!CSSStyleSelector::createTransformOperations(val.get(), 0, operations)) {
ec = SYNTAX_ERR;
return;
}
// Convert transform operations to a TransformationMatrix. This can fail
// if a param has a percentage ('%')
TransformationMatrix t;
for (unsigned i = 0; i < operations.operations().size(); ++i) {
if (operations.operations()[i].get()->apply(t, IntSize(0, 0))) {
ec = SYNTAX_ERR;
return;
}
}
// set the matrix
m_matrix = t;
} else if (!string.isEmpty()) // There is something there but parsing failed
ec = SYNTAX_ERR;
}
void CSSMutableStyleDeclaration::parseDeclaration(const String& styleDeclaration)
{
m_values.clear();
CSSParser parser(useStrictParsing());
parser.parseDeclaration(this, styleDeclaration);
setChanged();
}
void CSSMutableStyleDeclaration::setLengthProperty(int propertyId, const String& value, bool important, bool /*multiLength*/)
{
bool parseMode = useStrictParsing();
setStrictParsing(false);
setProperty(propertyId, value, important);
setStrictParsing(parseMode);
}
void WebKitCSSKeyframesRule::insertRule(const String& rule)
{
CSSParser p(useStrictParsing());
RefPtr<WebKitCSSKeyframeRule> newRule = p.parseKeyframeRule(parentStyleSheet(), rule);
if (newRule)
append(newRule.get());
}
void CSSVariablesDeclaration::setVariable(const String& variableName, const String& variableValue, ExceptionCode& excCode)
{
// Try to parse the variable value into a Value*. If it fails we throw an exception.
CSSParser parser(useStrictParsing());
if (!parser.parseVariable(this, variableName, variableValue)) // If the parse succeeds, it will call addParsedVariable (our internal method for doing the add) with the parsed Value*.
excCode = SYNTAX_ERR;
else
setChanged();
}
void CSSMutableStyleDeclaration::setCssText(const String& text, ExceptionCode& ec)
{
ec = 0;
m_values.clear();
CSSParser parser(useStrictParsing());
parser.parseDeclaration(this, text);
// FIXME: Detect syntax errors and set ec.
setChanged();
}
void CSSMutableStyleDeclaration::parseDeclaration(const String& styleDeclaration)
{
ASSERT(!m_iteratorCount);
m_properties.clear();
CSSParser parser(useStrictParsing());
parser.parseDeclaration(this, styleDeclaration);
setNeedsStyleRecalc();
}
void CSSMutableStyleDeclaration::setCssText(const String& text, ExceptionCode& ec)
{
ASSERT(!m_iteratorCount);
ec = 0;
m_properties.clear();
CSSParser parser(useStrictParsing());
parser.parseDeclaration(this, text);
// FIXME: Detect syntax errors and set ec.
setNeedsStyleRecalc();
}
unsigned CSSStyleSheet::insertRule(const String& rule, unsigned index, ExceptionCode& ec)
{
ec = 0;
if (index > length()) {
ec = INDEX_SIZE_ERR;
return 0;
}
CSSParser p(useStrictParsing());
RefPtr<CSSRule> r = p.parseRule(this, rule);
if (!r) {
ec = SYNTAX_ERR;
return 0;
}
// Throw a HIERARCHY_REQUEST_ERR exception if the rule cannot be inserted at the specified index. The best
// example of this is an @import rule inserted after regular rules.
if (index > 0) {
if (r->isImportRule()) {
// Check all the rules that come before this one to make sure they are only @charset and @import rules.
for (unsigned i = 0; i < index; ++i) {
if (!item(i)->isCharsetRule() && !item(i)->isImportRule()) {
ec = HIERARCHY_REQUEST_ERR;
return 0;
}
}
} else if (r->isCharsetRule()) {
// The @charset rule has to come first and there can be only one.
ec = HIERARCHY_REQUEST_ERR;
return 0;
}
}
CSSRule* c = r.get();
m_children.insert(index, r.release());
c->insertedIntoParent();
styleSheetChanged();
return index;
}
bool CSSMutableStyleDeclaration::setProperty(int propertyID, const String& value, bool important, bool notifyChanged)
{
ASSERT(!m_iteratorCount);
// Setting the value to an empty string just removes the property in both IE and Gecko.
// Setting it to null seems to produce less consistent results, but we treat it just the same.
if (value.isEmpty()) {
removeProperty(propertyID, notifyChanged, false);
return true;
}
// When replacing an existing property value, this moves the property to the end of the list.
// Firefox preserves the position, and MSIE moves the property to the beginning.
bool success = CSSParser::parseValue(this, propertyID, value, important, useStrictParsing());
if (!success) {
// CSS DOM requires raising SYNTAX_ERR here, but this is too dangerous for compatibility,
// see <http://bugs.webkit.org/show_bug.cgi?id=7296>.
} else if (notifyChanged)
setNeedsStyleRecalc();
return success;
}
unsigned CSSMediaRule::insertRule(const String& rule, unsigned index, ExceptionCode& ec)
{
if (index > m_lstCSSRules->length()) {
// INDEX_SIZE_ERR: Raised if the specified index is not a valid insertion point.
ec = INDEX_SIZE_ERR;
return 0;
}
CSSParser p(useStrictParsing());
RefPtr<CSSRule> newRule = p.parseRule(parentStyleSheet(), rule);
if (!newRule) {
// SYNTAX_ERR: Raised if the specified rule has a syntax error and is unparsable.
ec = SYNTAX_ERR;
return 0;
}
if (newRule->isImportRule()) {
// FIXME: an HIERARCHY_REQUEST_ERR should also be thrown for a @charset or a nested
// @media rule. They are currently not getting parsed, resulting in a SYNTAX_ERR
// to get raised above.
// HIERARCHY_REQUEST_ERR: Raised if the rule cannot be inserted at the specified
// index, e.g., if an @import rule is inserted after a standard rule set or other
// at-rule.
ec = HIERARCHY_REQUEST_ERR;
return 0;
}
newRule->setParent(this);
unsigned returnedIndex = m_lstCSSRules->insertRule(newRule.get(), index);
// stylesheet() can only return 0 for computed style declarations.
stylesheet()->styleSheetChanged();
return returnedIndex;
}
unsigned CSSStyleSheet::insertRule(const String& rule, unsigned index, ExceptionCode& ec)
{
ec = 0;
if (index > length()) {
ec = INDEX_SIZE_ERR;
return 0;
}
CSSParser p(useStrictParsing());
RefPtr<CSSRule> r = p.parseRule(this, rule);
if (!r) {
ec = SYNTAX_ERR;
return 0;
}
// ###
// HIERARCHY_REQUEST_ERR: Raised if the rule cannot be inserted at the specified index e.g. if an
//@import rule is inserted after a standard rule set or other at-rule.
insert(index, r.release());
styleSheetChanged();
return index;
}
