def __init__(self,
margin=None,
style=None,
parentRule=None,
parentStyleSheet=None,
readonly=False):
"""
:param atkeyword:
The margin area, e.g. '@top-left' for this rule
:param style:
CSSStyleDeclaration for this MarginRule
"""
super(MarginRule, self).__init__(parentRule=parentRule,
parentStyleSheet=parentStyleSheet)
self._atkeyword = self._keyword = None
if margin:
self.margin = margin
if style:
self.style = style
else:
self.style = CSSStyleDeclaration(parentRule=self)
self._readonly = readonly
def __init__(self, selectorText=None, style=None, readonly=False):
"""
if readonly allows setting of properties in constructor only
selectorText
type string
style
CSSStyleDeclaration for this CSSStyleRule
"""
super(CSSPageRule, self).__init__()
self.atkeyword = u'@page'
if selectorText:
self.selectorText = selectorText
self.seq.append(self.selectorText)
else:
self._selectorText = u''
if style:
self.style = style
self.seq.append(self.style)
else:
self._style = CSSStyleDeclaration(parentRule=self)
self._readonly = readonly
def _setCssText(self, cssText):
"""
:exceptions:
- :exc:`~xml.dom.SyntaxErr`:
Raised if the specified CSS string value has a syntax error and
is unparsable.
- :exc:`~xml.dom.InvalidModificationErr`:
Raised if the specified CSS string value represents a different
type of rule than the current one.
- :exc:`~xml.dom.HierarchyRequestErr`:
Raised if the rule cannot be inserted at this point in the
style sheet.
- :exc:`~xml.dom.NoModificationAllowedErr`:
Raised if the rule is readonly.
"""
super(MarginRule, self)._setCssText(cssText)
# TEMP: all style tokens are saved in store to fill styledeclaration
# TODO: resolve when all generators
styletokens = Prod(
name='styletokens',
match=lambda t, v: v != u'}',
#toSeq=False,
toStore='styletokens',
storeToken=True)
prods = Sequence(
Prod(name='@ margin',
match=lambda t, v: t == 'ATKEYWORD' and self._normalize(v) in
MarginRule.margins,
toStore='margin'
# TODO?
#, exception=xml.dom.InvalidModificationErr
),
PreDef.char('OPEN', u'{'),
Sequence(Choice(PreDef.unknownrule(toStore='@'), styletokens),
minmax=lambda: (0, None)),
PreDef.char('CLOSE', u'}', stopAndKeep=True))
# parse
ok, seq, store, unused = ProdParser().parse(cssText, u'MarginRule',
prods)
if ok:
# TODO: use seq for serializing instead of fixed stuff?
self._setSeq(seq)
if 'margin' in store:
# may raise:
self.margin = store['margin'].value
else:
self._log.error(u'No margin @keyword for this %s rule' %
self.margin,
error=xml.dom.InvalidModificationErr)
# new empty style
self.style = CSSStyleDeclaration(parentRule=self)
if 'styletokens' in store:
# may raise:
self.style.cssText = store['styletokens']
def __init__(self,
selectorText=None,
style=None,
parentRule=None,
parentStyleSheet=None,
readonly=False):
"""
:Parameters:
selectorText
string parsed into selectorList
style
string parsed into CSSStyleDeclaration for this CSSStyleRule
readonly
if True allows setting of properties in constructor only
"""
super(CSSStyleRule, self).__init__(parentRule=parentRule,
parentStyleSheet=parentStyleSheet)
self.selectorList = SelectorList()
if selectorText:
self.selectorText = selectorText
if style:
self.style = style
else:
self.style = CSSStyleDeclaration()
self._readonly = readonly
def __init__(self, selectorText=None, style=None, parentRule=None,
parentStyleSheet=None, readonly=False):
"""
If readonly allows setting of properties in constructor only.
:param selectorText:
type string
:param style:
CSSStyleDeclaration for this CSSStyleRule
"""
super(CSSPageRule, self).__init__(parentRule=parentRule,
parentStyleSheet=parentStyleSheet)
self._atkeyword = u'@page'
tempseq = self._tempSeq()
if selectorText:
self.selectorText = selectorText
tempseq.append(self.selectorText, 'selectorText')
else:
self._selectorText = self._tempSeq()
self._style = CSSStyleDeclaration(parentRule=self)
if style:
self.style = style
tempseq.append(self.style, 'style')
self._setSeq(tempseq)
self._readonly = readonly
def __init__(self, style=None, parentRule=None,
parentStyleSheet=None, readonly=False):
"""
If readonly allows setting of properties in constructor only.
:param style:
CSSStyleDeclaration used to hold any font descriptions
for this CSSFontFaceRule
"""
super(CSSFontFaceRule, self).__init__(parentRule=parentRule,
parentStyleSheet=parentStyleSheet)
self._atkeyword = u'@font-face'
if style:
self.style = style
else:
self.style = CSSStyleDeclaration()
self._readonly = readonly
def _setStyle(self, style):
"""
:param style:
a CSSStyleDeclaration or string
"""
self._checkReadonly()
if isinstance(style, basestring):
self._style = CSSStyleDeclaration(cssText=style, parentRule=self)
else:
style._parentRule = self
self._style = style
def _setStyle(self, style):
"""
style
StyleDeclaration or string
"""
self._checkReadonly()
if isinstance(style, basestring):
self._style = CSSStyleDeclaration(parentRule=self, cssText=style)
else:
self._style = style
style.parentRule = self
def _setStyle(self, style):
"""
:param style: A string or CSSStyleDeclaration which replaces the
current style object.
"""
self._checkReadonly()
if isinstance(style, basestring):
self._style = CSSStyleDeclaration(cssText=style, parentRule=self)
else:
style._parentRule = self
self._style = style
def __init__(self, style=None, readonly=False):
"""
if readonly allows setting of properties in constructor only
style
CSSStyleDeclaration for this CSSStyleRule
"""
super(CSSFontFaceRule, self).__init__()
self.atkeyword = u'@font-face'
if style:
self.style = style
self.seq.append(self.style)
else:
self._style = CSSStyleDeclaration(parentRule=self)
self._readonly = readonly
def _setCssText(self, cssText):
"""
:exceptions:
- :exc:`~xml.dom.SyntaxErr`:
Raised if the specified CSS string value has a syntax error and
is unparsable.
- :exc:`~xml.dom.InvalidModificationErr`:
Raised if the specified CSS string value represents a different
type of rule than the current one.
- :exc:`~xml.dom.HierarchyRequestErr`:
Raised if the rule cannot be inserted at this point in the
style sheet.
- :exc:`~xml.dom.NoModificationAllowedErr`:
Raised if the rule is readonly.
"""
super(CSSFontFaceRule, self)._setCssText(cssText)
tokenizer = self._tokenize2(cssText)
attoken = self._nexttoken(tokenizer, None)
if self._type(attoken) != self._prods.FONT_FACE_SYM:
self._log.error(u'CSSFontFaceRule: No CSSFontFaceRule found: %s' %
self._valuestr(cssText),
error=xml.dom.InvalidModificationErr)
else:
newStyle = CSSStyleDeclaration(parentRule=self)
ok = True
beforetokens, brace = self._tokensupto2(tokenizer,
blockstartonly=True,
separateEnd=True)
if self._tokenvalue(brace) != u'{':
ok = False
self._log.error(u'CSSFontFaceRule: No start { of style '
u'declaration found: %r'
% self._valuestr(cssText), brace)
# parse stuff before { which should be comments and S only
new = {'wellformed': True}
newseq = self._tempSeq()
beforewellformed, expected = self._parse(expected=':',
seq=newseq, tokenizer=self._tokenize2(beforetokens),
productions={})
ok = ok and beforewellformed and new['wellformed']
styletokens, braceorEOFtoken = self._tokensupto2(tokenizer,
blockendonly=True,
separateEnd=True)
val, type_ = self._tokenvalue(braceorEOFtoken),\
self._type(braceorEOFtoken)
if val != u'}' and type_ != 'EOF':
ok = False
self._log.error(u'CSSFontFaceRule: No "}" after style '
u'declaration found: %r'
% self._valuestr(cssText))
nonetoken = self._nexttoken(tokenizer)
if nonetoken:
ok = False
self._log.error(u'CSSFontFaceRule: Trailing content found.',
token=nonetoken)
if 'EOF' == type_:
# add again as style needs it
styletokens.append(braceorEOFtoken)
# SET, may raise:
newStyle.cssText = styletokens
if ok:
# contains probably comments only (upto ``{``)
self._setSeq(newseq)
self.style = newStyle
class CSSFontFaceRule(cssrule.CSSRule):
"""
The CSSFontFaceRule interface represents a @font-face rule in a CSS
style sheet. The @font-face rule is used to hold a set of font
descriptions.
Format::
font_face
: FONT_FACE_SYM S*
'{' S* declaration [ ';' S* declaration ]* '}' S*
;
cssutils uses a :class:`~cssutils.css.CSSStyleDeclaration` to
represent the font descriptions. For validation a specific profile
is used though were some properties have other valid values than
when used in e.g. a :class:`~cssutils.css.CSSStyleRule`.
"""
def __init__(self, style=None, parentRule=None,
parentStyleSheet=None, readonly=False):
"""
If readonly allows setting of properties in constructor only.
:param style:
CSSStyleDeclaration used to hold any font descriptions
for this CSSFontFaceRule
"""
super(CSSFontFaceRule, self).__init__(parentRule=parentRule,
parentStyleSheet=parentStyleSheet)
self._atkeyword = u'@font-face'
if style:
self.style = style
else:
self.style = CSSStyleDeclaration()
self._readonly = readonly
def __repr__(self):
return u"cssutils.css.%s(style=%r)" % (
self.__class__.__name__,
self.style.cssText)
def __str__(self):
return u"<cssutils.css.%s object style=%r valid=%r at 0x%x>" % (
self.__class__.__name__,
self.style.cssText,
self.valid,
id(self))
def _getCssText(self):
"""Return serialized property cssText."""
return cssutils.ser.do_CSSFontFaceRule(self)
def _setCssText(self, cssText):
"""
:exceptions:
- :exc:`~xml.dom.SyntaxErr`:
Raised if the specified CSS string value has a syntax error and
is unparsable.
- :exc:`~xml.dom.InvalidModificationErr`:
Raised if the specified CSS string value represents a different
type of rule than the current one.
- :exc:`~xml.dom.HierarchyRequestErr`:
Raised if the rule cannot be inserted at this point in the
style sheet.
- :exc:`~xml.dom.NoModificationAllowedErr`:
Raised if the rule is readonly.
"""
super(CSSFontFaceRule, self)._setCssText(cssText)
tokenizer = self._tokenize2(cssText)
attoken = self._nexttoken(tokenizer, None)
if self._type(attoken) != self._prods.FONT_FACE_SYM:
self._log.error(u'CSSFontFaceRule: No CSSFontFaceRule found: %s' %
self._valuestr(cssText),
error=xml.dom.InvalidModificationErr)
else:
newStyle = CSSStyleDeclaration(parentRule=self)
ok = True
beforetokens, brace = self._tokensupto2(tokenizer,
blockstartonly=True,
separateEnd=True)
if self._tokenvalue(brace) != u'{':
ok = False
self._log.error(u'CSSFontFaceRule: No start { of style '
u'declaration found: %r'
% self._valuestr(cssText), brace)
# parse stuff before { which should be comments and S only
new = {'wellformed': True}
newseq = self._tempSeq()
beforewellformed, expected = self._parse(expected=':',
seq=newseq, tokenizer=self._tokenize2(beforetokens),
productions={})
ok = ok and beforewellformed and new['wellformed']
styletokens, braceorEOFtoken = self._tokensupto2(tokenizer,
blockendonly=True,
separateEnd=True)
val, type_ = self._tokenvalue(braceorEOFtoken),\
self._type(braceorEOFtoken)
if val != u'}' and type_ != 'EOF':
ok = False
self._log.error(u'CSSFontFaceRule: No "}" after style '
u'declaration found: %r'
% self._valuestr(cssText))
nonetoken = self._nexttoken(tokenizer)
if nonetoken:
ok = False
self._log.error(u'CSSFontFaceRule: Trailing content found.',
token=nonetoken)
if 'EOF' == type_:
# add again as style needs it
styletokens.append(braceorEOFtoken)
# SET, may raise:
newStyle.cssText = styletokens
if ok:
# contains probably comments only (upto ``{``)
self._setSeq(newseq)
self.style = newStyle
cssText = property(_getCssText, _setCssText,
doc=u"(DOM) The parsable textual representation of this "
u"rule.")
def _setStyle(self, style):
"""
:param style:
a CSSStyleDeclaration or string
"""
self._checkReadonly()
if isinstance(style, basestring):
self._style = CSSStyleDeclaration(cssText=style, parentRule=self)
else:
style._parentRule = self
self._style = style
style = property(lambda self: self._style, _setStyle,
doc=u"(DOM) The declaration-block of this rule set, "
u"a :class:`~cssutils.css.CSSStyleDeclaration`.")
type = property(lambda self: self.FONT_FACE_RULE,
doc=u"The type of this rule, as defined by a CSSRule "
u"type constant.")
def _getValid(self):
needed = ['font-family', 'src']
for p in self.style.getProperties(all=True):
if not p.valid:
return False
try:
needed.remove(p.name)
except ValueError:
pass
return not bool(needed)
valid = property(_getValid,
doc=u"CSSFontFace is valid if properties `font-family` "
u"and `src` are set and all properties are valid.")
# constant but needed:
wellformed = property(lambda self: True)
def _setCssText(self, cssText):
"""
:exceptions:
- :exc:`~xml.dom.SyntaxErr`:
Raised if the specified CSS string value has a syntax error and
is unparsable.
- :exc:`~xml.dom.InvalidModificationErr`:
Raised if the specified CSS string value represents a different
type of rule than the current one.
- :exc:`~xml.dom.HierarchyRequestErr`:
Raised if the rule cannot be inserted at this point in the
style sheet.
- :exc:`~xml.dom.NoModificationAllowedErr`:
Raised if the rule is readonly.
"""
super(CSSPageRule, self)._setCssText(cssText)
tokenizer = self._tokenize2(cssText)
if self._type(self._nexttoken(tokenizer)) != self._prods.PAGE_SYM:
self._log.error(u'CSSPageRule: No CSSPageRule found: %s' %
self._valuestr(cssText),
error=xml.dom.InvalidModificationErr)
else:
newStyle = CSSStyleDeclaration(parentRule=self)
ok = True
selectortokens, startbrace = self._tokensupto2(tokenizer,
blockstartonly=True,
separateEnd=True)
styletokens, braceorEOFtoken = self._tokensupto2(tokenizer,
blockendonly=True,
separateEnd=True)
nonetoken = self._nexttoken(tokenizer)
if self._tokenvalue(startbrace) != u'{':
ok = False
self._log.error(
u'CSSPageRule: No start { of style declaration found: %r' %
self._valuestr(cssText), startbrace)
elif nonetoken:
ok = False
self._log.error(
u'CSSPageRule: Trailing content found.', token=nonetoken)
selok, newselectorseq = self.__parseSelectorText(selectortokens)
ok = ok and selok
val, type_ = self._tokenvalue(braceorEOFtoken),\
self._type(braceorEOFtoken)
if val != u'}' and type_ != 'EOF':
ok = False
self._log.error(
u'CSSPageRule: No "}" after style declaration found: %r' %
self._valuestr(cssText))
else:
if 'EOF' == type_:
# add again as style needs it
styletokens.append(braceorEOFtoken)
# SET, may raise:
newStyle.cssText = styletokens
if ok:
self._selectorText = newselectorseq
self.style = newStyle
def _setCssText(self, cssText):
"""
:param cssText:
a parseable string or a tuple of (cssText, dict-of-namespaces)
:exceptions:
- :exc:`~xml.dom.NamespaceErr`:
Raised if the specified selector uses an unknown namespace
prefix.
- :exc:`~xml.dom.SyntaxErr`:
Raised if the specified CSS string value has a syntax error and
is unparsable.
- :exc:`~xml.dom.InvalidModificationErr`:
Raised if the specified CSS string value represents a different
type of rule than the current one.
- :exc:`~xml.dom.HierarchyRequestErr`:
Raised if the rule cannot be inserted at this point in the
style sheet.
- :exc:`~xml.dom.NoModificationAllowedErr`:
Raised if the rule is readonly.
"""
super(CSSStyleRule, self)._setCssText(cssText)
# might be (cssText, namespaces)
cssText, namespaces = self._splitNamespacesOff(cssText)
try:
# use parent style sheet ones if available
namespaces = self.parentStyleSheet.namespaces
except AttributeError:
pass
tokenizer = self._tokenize2(cssText)
selectortokens = self._tokensupto2(tokenizer, blockstartonly=True)
styletokens = self._tokensupto2(tokenizer, blockendonly=True)
trail = self._nexttoken(tokenizer)
if trail:
self._log.error(u'CSSStyleRule: Trailing content: %s' %
self._valuestr(cssText),
token=trail)
elif not selectortokens:
self._log.error(u'CSSStyleRule: No selector found: %r' %
self._valuestr(cssText))
elif self._tokenvalue(selectortokens[0]).startswith(u'@'):
self._log.error(u'CSSStyleRule: No style rule: %r' %
self._valuestr(cssText),
error=xml.dom.InvalidModificationErr)
else:
newSelectorList = SelectorList(parentRule=self)
newStyle = CSSStyleDeclaration(parentRule=self)
ok = True
bracetoken = selectortokens.pop()
if self._tokenvalue(bracetoken) != u'{':
ok = False
self._log.error(
u'CSSStyleRule: No start { of style declaration found: %r'
% self._valuestr(cssText), bracetoken)
elif not selectortokens:
ok = False
self._log.error(
u'CSSStyleRule: No selector found: %r.' %
self._valuestr(cssText), bracetoken)
# SET
newSelectorList.selectorText = (selectortokens, namespaces)
if not styletokens:
ok = False
self._log.error(
u'CSSStyleRule: No style declaration or "}" found: %r' %
self._valuestr(cssText))
else:
braceorEOFtoken = styletokens.pop()
val, typ = self._tokenvalue(braceorEOFtoken),\
self._type(braceorEOFtoken)
if val != u'}' and typ != 'EOF':
ok = False
self._log.error(u'CSSStyleRule: No "}" after style '
u'declaration found: %r' %
self._valuestr(cssText))
else:
if 'EOF' == typ:
# add again as style needs it
styletokens.append(braceorEOFtoken)
# SET, may raise:
newStyle.cssText = styletokens
if ok:
self.selectorList = newSelectorList
self.style = newStyle
def _setCssText(self, cssText):
"""
DOMException on setting
- SYNTAX_ERR: (self, StyleDeclaration)
Raised if the specified CSS string value has a syntax error and
is unparsable.
- INVALID_MODIFICATION_ERR: (self)
Raised if the specified CSS string value represents a different
type of rule than the current one.
- HIERARCHY_REQUEST_ERR: (CSSStylesheet)
Raised if the rule cannot be inserted at this point in the
style sheet.
- NO_MODIFICATION_ALLOWED_ERR: (CSSRule)
Raised if the rule is readonly.
"""
super(CSSPageRule, self)._setCssText(cssText)
tokenizer = self._tokenize2(cssText)
attoken = self._nexttoken(tokenizer, None)
if not attoken or u"@page" != self._tokenvalue(attoken, normalize=True):
self._log.error(
u"CSSPageRule: No CSSPageRule found: %s" % self._valuestr(cssText), error=xml.dom.InvalidModificationErr
)
else:
valid = True
selectortokens = self._tokensupto2(tokenizer, blockstartonly=True)
styletokens = self._tokensupto2(tokenizer, blockendonly=True)
try:
bracetoken = selectortokens.pop()
except IndexError:
bracetoken = None
if self._tokenvalue(bracetoken) != u"{":
valid = False
self._log.error(
u"CSSPageRule: No start { of style declaration found: %r" % self._valuestr(cssText), bracetoken
)
newselector, newselectorseq = self.__parseSelectorText(selectortokens)
newstyle = CSSStyleDeclaration()
if not styletokens:
valid = False
self._log.error(u'CSSPageRule: No style declaration or "}" found: %r' % self._valuestr(cssText))
braceorEOFtoken = styletokens.pop()
val, typ = self._tokenvalue(braceorEOFtoken), self._type(braceorEOFtoken)
if val != u"}" and typ != "EOF":
valid = False
self._log.error(u'CSSPageRule: No "}" after style declaration found: %r' % self._valuestr(cssText))
else:
if "EOF" == typ:
# add again as style needs it
styletokens.append(braceorEOFtoken)
newstyle.cssText = styletokens
if valid:
self.valid = True
self._selectorText = newselector # already parsed
self.style = newstyle
self.seq = newselectorseq # contains upto style only
def _setCssText(self, cssText):
"""
:exceptions:
- :exc:`~xml.dom.SyntaxErr`:
Raised if the specified CSS string value has a syntax error and
is unparsable.
- :exc:`~xml.dom.InvalidModificationErr`:
Raised if the specified CSS string value represents a different
type of rule than the current one.
- :exc:`~xml.dom.HierarchyRequestErr`:
Raised if the rule cannot be inserted at this point in the
style sheet.
- :exc:`~xml.dom.NoModificationAllowedErr`:
Raised if the rule is readonly.
"""
super(CSSPageRule, self)._setCssText(cssText)
tokenizer = self._tokenize2(cssText)
if self._type(self._nexttoken(tokenizer)) != self._prods.PAGE_SYM:
self._log.error(u'CSSPageRule: No CSSPageRule found: %s' %
self._valuestr(cssText),
error=xml.dom.InvalidModificationErr)
else:
newStyle = CSSStyleDeclaration(parentRule=self)
ok = True
selectortokens, startbrace = self._tokensupto2(tokenizer,
blockstartonly=True,
separateEnd=True)
styletokens, braceorEOFtoken = self._tokensupto2(tokenizer,
blockendonly=True,
separateEnd=True)
nonetoken = self._nexttoken(tokenizer)
if self._tokenvalue(startbrace) != u'{':
ok = False
self._log.error(u'CSSPageRule: No start { of style declaration '
u'found: %r' %
self._valuestr(cssText), startbrace)
elif nonetoken:
ok = False
self._log.error(u'CSSPageRule: Trailing content found.',
token=nonetoken)
selok, newselseq, specificity = self.__parseSelectorText(selectortokens)
ok = ok and selok
val, type_ = self._tokenvalue(braceorEOFtoken),\
self._type(braceorEOFtoken)
if val != u'}' and type_ != 'EOF':
ok = False
self._log.error(
u'CSSPageRule: No "}" after style declaration found: %r' %
self._valuestr(cssText))
else:
if 'EOF' == type_:
# add again as style needs it
styletokens.append(braceorEOFtoken)
# filter pagemargin rules out first
cssRules, styletokens = self.__parseMarginAndStyle(styletokens)
# SET, may raise:
newStyle.cssText = styletokens
if ok:
self._selectorText = newselseq
self._specificity = specificity
self.style = newStyle
self.cssRules = cssutils.css.CSSRuleList()
for r in cssRules:
self.cssRules.append(r)
def _setCssText(self, cssText):
"""
DOMException on setting
- SYNTAX_ERR: (self, StyleDeclaration)
Raised if the specified CSS string value has a syntax error and
is unparsable.
- INVALID_MODIFICATION_ERR: (self)
Raised if the specified CSS string value represents a different
type of rule than the current one.
- HIERARCHY_REQUEST_ERR: (CSSStylesheet)
Raised if the rule cannot be inserted at this point in the
style sheet.
- NO_MODIFICATION_ALLOWED_ERR: (CSSRule)
Raised if the rule is readonly.
"""
super(CSSFontFaceRule, self)._setCssText(cssText)
tokenizer = self._tokenize2(cssText)
attoken = self._nexttoken(tokenizer, None)
if not attoken or u'@font-face' != self._tokenvalue(attoken,
normalize=True):
self._log.error(u'CSSFontFaceRule: No CSSFontFaceRule found: %s' %
self._valuestr(cssText),
error=xml.dom.InvalidModificationErr)
else:
valid = True
beforetokens = self._tokensupto2(tokenizer, blockstartonly=True)
try:
bracetoken = beforetokens.pop()
except IndexError:
bracetoken = None
if self._tokenvalue(bracetoken) != u'{':
valid = False
self._log.error(
u'CSSFontFaceRule: No start { of style declaration found: %r'
% self._valuestr(cssText), bracetoken)
# parse stuff before { which should be comments and S only
new = {'valid': True}
newseq = []
beforevalid, expected = self._parse(
expected=':',
seq=newseq,
tokenizer=self._tokenize2(beforetokens),
productions={})
valid = valid and beforevalid and new['valid']
styletokens = self._tokensupto2(tokenizer, blockendonly=True)
newstyle = CSSStyleDeclaration()
if not styletokens:
valid = False
self._log.error(
u'CSSFontFaceRule: No style declaration or "}" found: %r' %
self._valuestr(cssText))
braceorEOFtoken = styletokens.pop()
val, typ = self._tokenvalue(braceorEOFtoken), self._type(
braceorEOFtoken)
if val != u'}' and typ != 'EOF':
valid = False
self._log.error(
u'CSSFontFaceRule: No "}" after style declaration found: %r'
% self._valuestr(cssText))
else:
if 'EOF' == typ:
# add again as style needs it
styletokens.append(braceorEOFtoken)
newstyle.cssText = styletokens
if valid:
self.valid = True
self.style = newstyle
self.seq = newseq # contains upto { only
def _setCssText(self, cssText):
"""
DOMException on setting
- SYNTAX_ERR: (self, StyleDeclaration, etc)
Raised if the specified CSS string value has a syntax error and
is unparsable.
- INVALID_MODIFICATION_ERR: (self)
Raised if the specified CSS string value represents a different
type of rule than the current one.
- HIERARCHY_REQUEST_ERR: (CSSStylesheet)
Raised if the rule cannot be inserted at this point in the
style sheet.
- NO_MODIFICATION_ALLOWED_ERR: (CSSRule)
Raised if the rule is readonly.
"""
super(CSSStyleRule, self)._setCssText(cssText)
tokenizer = self._tokenize2(cssText)
selectortokens = self._tokensupto2(tokenizer, blockstartonly=True)
styletokens = self._tokensupto2(tokenizer, blockendonly=True)
if not selectortokens or self._tokenvalue(
selectortokens[0]).startswith(u'@'):
self._log.error(u'CSSStyleRule: No content or no style rule.',
error=xml.dom.InvalidModificationErr)
else:
valid = True
bracetoken = selectortokens.pop()
if self._tokenvalue(bracetoken) != u'{':
valid = False
self._log.error(
u'CSSStyleRule: No start { of style declaration found: %r'
% self._valuestr(cssText), bracetoken)
elif not selectortokens:
valid = False
self._log.error(
u'CSSStyleRule: No selector found: %r.' %
self._valuestr(cssText), bracetoken)
newselectorlist = SelectorList(selectorText=selectortokens)
newstyle = CSSStyleDeclaration()
if not styletokens:
valid = False
self._log.error(
u'CSSStyleRule: No style declaration or "}" found: %r' %
self._valuestr(cssText))
else:
braceorEOFtoken = styletokens.pop()
val, typ = self._tokenvalue(braceorEOFtoken), self._type(
braceorEOFtoken)
if val != u'}' and typ != 'EOF':
valid = False
self._log.error(
u'CSSStyleRule: No "}" after style declaration found: %r'
% self._valuestr(cssText))
else:
if 'EOF' == typ:
# add again as style needs it
styletokens.append(braceorEOFtoken)
newstyle.cssText = styletokens
if valid:
self.valid = True
self.selectorList = newselectorlist
self.style = newstyle
def _setCssText(self, cssText):
"""
DOMException on setting
- SYNTAX_ERR: (self, StyleDeclaration)
Raised if the specified CSS string value has a syntax error and
is unparsable.
- INVALID_MODIFICATION_ERR: (self)
Raised if the specified CSS string value represents a different
type of rule than the current one.
- HIERARCHY_REQUEST_ERR: (CSSStylesheet)
Raised if the rule cannot be inserted at this point in the
style sheet.
- NO_MODIFICATION_ALLOWED_ERR: (CSSRule)
Raised if the rule is readonly.
"""
super(CSSFontFaceRule, self)._setCssText(cssText)
tokenizer = self._tokenize2(cssText)
attoken = self._nexttoken(tokenizer, None)
if not attoken or u'@font-face' != self._tokenvalue(
attoken, normalize=True):
self._log.error(u'CSSFontFaceRule: No CSSFontFaceRule found: %s' %
self._valuestr(cssText),
error=xml.dom.InvalidModificationErr)
else:
valid = True
beforetokens = self._tokensupto2(tokenizer, blockstartonly=True)
try:
bracetoken = beforetokens.pop()
except IndexError:
bracetoken = None
if self._tokenvalue(bracetoken) != u'{':
valid = False
self._log.error(
u'CSSFontFaceRule: No start { of style declaration found: %r' %
self._valuestr(cssText), bracetoken)
# parse stuff before { which should be comments and S only
new = {'valid': True}
newseq = []
beforevalid, expected = self._parse(expected=':',
seq=newseq, tokenizer=self._tokenize2(beforetokens),
productions={})
valid = valid and beforevalid and new['valid']
styletokens = self._tokensupto2(tokenizer, blockendonly=True)
newstyle = CSSStyleDeclaration()
if not styletokens:
valid = False
self._log.error(
u'CSSFontFaceRule: No style declaration or "}" found: %r' %
self._valuestr(cssText))
braceorEOFtoken = styletokens.pop()
val, typ = self._tokenvalue(braceorEOFtoken), self._type(braceorEOFtoken)
if val != u'}' and typ != 'EOF':
valid = False
self._log.error(
u'CSSFontFaceRule: No "}" after style declaration found: %r' %
self._valuestr(cssText))
else:
if 'EOF' == typ:
# add again as style needs it
styletokens.append(braceorEOFtoken)
newstyle.cssText = styletokens
if valid:
self.valid = True
self.style = newstyle
self.seq = newseq # contains upto { only
def _setCssText(self, cssText):
"""
DOMException on setting
- SYNTAX_ERR: (self, StyleDeclaration, etc)
Raised if the specified CSS string value has a syntax error and
is unparsable.
- INVALID_MODIFICATION_ERR: (self)
Raised if the specified CSS string value represents a different
type of rule than the current one.
- HIERARCHY_REQUEST_ERR: (CSSStylesheet)
Raised if the rule cannot be inserted at this point in the
style sheet.
- NO_MODIFICATION_ALLOWED_ERR: (CSSRule)
Raised if the rule is readonly.
"""
super(CSSStyleRule, self)._setCssText(cssText)
tokenizer = self._tokenize2(cssText)
selectortokens = self._tokensupto2(tokenizer, blockstartonly=True)
styletokens = self._tokensupto2(tokenizer, blockendonly=True)
if not selectortokens or self._tokenvalue(
selectortokens[0]).startswith(u'@'):
self._log.error(u'CSSStyleRule: No content or no style rule.',
error=xml.dom.InvalidModificationErr)
else:
valid = True
bracetoken = selectortokens.pop()
if self._tokenvalue(bracetoken) != u'{':
valid = False
self._log.error(
u'CSSStyleRule: No start { of style declaration found: %r' %
self._valuestr(cssText), bracetoken)
elif not selectortokens:
valid = False
self._log.error(u'CSSStyleRule: No selector found: %r.' %
self._valuestr(cssText), bracetoken)
newselectorlist = SelectorList(selectorText=selectortokens)
newstyle = CSSStyleDeclaration()
if not styletokens:
valid = False
self._log.error(
u'CSSStyleRule: No style declaration or "}" found: %r' %
self._valuestr(cssText))
else:
braceorEOFtoken = styletokens.pop()
val, typ = self._tokenvalue(braceorEOFtoken), self._type(braceorEOFtoken)
if val != u'}' and typ != 'EOF':
valid = False
self._log.error(
u'CSSStyleRule: No "}" after style declaration found: %r' %
self._valuestr(cssText))
else:
if 'EOF' == typ:
# add again as style needs it
styletokens.append(braceorEOFtoken)
newstyle.cssText = styletokens
if valid:
self.valid = True
self.selectorList = newselectorlist
self.style = newstyle
def _setCssText(self, cssText):
"""
:param cssText:
a parseable string or a tuple of (cssText, dict-of-namespaces)
:exceptions:
- :exc:`~xml.dom.NamespaceErr`:
Raised if the specified selector uses an unknown namespace
prefix.
- :exc:`~xml.dom.SyntaxErr`:
Raised if the specified CSS string value has a syntax error and
is unparsable.
- :exc:`~xml.dom.InvalidModificationErr`:
Raised if the specified CSS string value represents a different
type of rule than the current one.
- :exc:`~xml.dom.HierarchyRequestErr`:
Raised if the rule cannot be inserted at this point in the
style sheet.
- :exc:`~xml.dom.NoModificationAllowedErr`:
Raised if the rule is readonly.
"""
super(CSSStyleRule, self)._setCssText(cssText)
# might be (cssText, namespaces)
cssText, namespaces = self._splitNamespacesOff(cssText)
try:
# use parent style sheet ones if available
namespaces = self.parentStyleSheet.namespaces
except AttributeError:
pass
tokenizer = self._tokenize2(cssText)
selectortokens = self._tokensupto2(tokenizer, blockstartonly=True)
styletokens = self._tokensupto2(tokenizer, blockendonly=True)
trail = self._nexttoken(tokenizer)
if trail:
self._log.error(u'CSSStyleRule: Trailing content: %s' %
self._valuestr(cssText), token=trail)
elif not selectortokens:
self._log.error(u'CSSStyleRule: No selector found: %r' %
self._valuestr(cssText))
elif self._tokenvalue(selectortokens[0]).startswith(u'@'):
self._log.error(u'CSSStyleRule: No style rule: %r' %
self._valuestr(cssText),
error=xml.dom.InvalidModificationErr)
else:
newSelectorList = SelectorList(parentRule=self)
newStyle = CSSStyleDeclaration(parentRule=self)
ok = True
bracetoken = selectortokens.pop()
if self._tokenvalue(bracetoken) != u'{':
ok = False
self._log.error(
u'CSSStyleRule: No start { of style declaration found: %r' %
self._valuestr(cssText), bracetoken)
elif not selectortokens:
ok = False
self._log.error(u'CSSStyleRule: No selector found: %r.' %
self._valuestr(cssText), bracetoken)
# SET
newSelectorList.selectorText = (selectortokens,
namespaces)
if not styletokens:
ok = False
self._log.error(
u'CSSStyleRule: No style declaration or "}" found: %r' %
self._valuestr(cssText))
else:
braceorEOFtoken = styletokens.pop()
val, typ = self._tokenvalue(braceorEOFtoken),\
self._type(braceorEOFtoken)
if val != u'}' and typ != 'EOF':
ok = False
self._log.error(u'CSSStyleRule: No "}" after style '
u'declaration found: %r'
% self._valuestr(cssText))
else:
if 'EOF' == typ:
# add again as style needs it
styletokens.append(braceorEOFtoken)
# SET, may raise:
newStyle.cssText = styletokens
if ok:
self.selectorList = newSelectorList
self.style = newStyle
def _setCssText(self, cssText):
"""
:exceptions:
- :exc:`~xml.dom.SyntaxErr`:
Raised if the specified CSS string value has a syntax error and
is unparsable.
- :exc:`~xml.dom.InvalidModificationErr`:
Raised if the specified CSS string value represents a different
type of rule than the current one.
- :exc:`~xml.dom.HierarchyRequestErr`:
Raised if the rule cannot be inserted at this point in the
style sheet.
- :exc:`~xml.dom.NoModificationAllowedErr`:
Raised if the rule is readonly.
"""
super(CSSPageRule, self)._setCssText(cssText)
tokenizer = self._tokenize2(cssText)
if self._type(self._nexttoken(tokenizer)) != self._prods.PAGE_SYM:
self._log.error(u'CSSPageRule: No CSSPageRule found: %s' %
self._valuestr(cssText),
error=xml.dom.InvalidModificationErr)
else:
wellformed = True
selectortokens, startbrace = self._tokensupto2(tokenizer,
blockstartonly=True,
separateEnd=True)
styletokens, braceorEOFtoken = self._tokensupto2(tokenizer,
blockendonly=True,
separateEnd=True)
nonetoken = self._nexttoken(tokenizer)
if self._tokenvalue(startbrace) != u'{':
wellformed = False
self._log.error(
u'CSSPageRule: No start { of style declaration found: %r' %
self._valuestr(cssText), startbrace)
elif nonetoken:
wellformed = False
self._log.error(
u'CSSPageRule: Trailing content found.', token=nonetoken)
wellformed, newselectorseq = self.__parseSelectorText(selectortokens)
teststyle = CSSStyleDeclaration(parentRule=self)
val, typ = self._tokenvalue(braceorEOFtoken), self._type(braceorEOFtoken)
if val != u'}' and typ != 'EOF':
wellformed = False
self._log.error(
u'CSSPageRule: No "}" after style declaration found: %r' %
self._valuestr(cssText))
else:
if 'EOF' == typ:
# add again as style needs it
styletokens.append(braceorEOFtoken)
teststyle.cssText = styletokens
if wellformed:
# known as correct from before
cssutils.log.enabled = False
self._selectorText = newselectorseq # TODO: TEST and REFS
self.style.cssText = styletokens
cssutils.log.enabled = True