Current File : //lib/python3/dist-packages/css_parser/css/cssfontfacerule.py
from __future__ import unicode_literals, division, absolute_import, print_function
import xml.dom
import css_parser
from . import cssrule
from .cssstyledeclaration import CSSStyleDeclaration
"""CSSFontFaceRule implements DOM Level 2 CSS CSSFontFaceRule.
From css_parser 0.9.6 additions from CSS Fonts Module Level 3 are
added http://www.w3.org/TR/css3-fonts/.
"""
__all__ = ['CSSFontFaceRule']
__docformat__ = 'restructuredtext'
__version__ = '$Id$'
import sys
if sys.version_info[0] >= 3:
string_type = str
else:
string_type = basestring
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*
;
css_parser uses a :class:`~css_parser.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:`~css_parser.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 = '@font-face'
if style:
self.style = style
else:
self.style = CSSStyleDeclaration()
self._readonly = readonly
def __repr__(self):
return "css_parser.css.%s(style=%r)" % (
self.__class__.__name__,
self.style.cssText)
def __str__(self):
return "<css_parser.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 css_parser.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('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) != '{':
ok = False
self._log.error('CSSFontFaceRule: No start { of style '
'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 != '}' and type_ != 'EOF':
ok = False
self._log.error('CSSFontFaceRule: No "}" after style '
'declaration found: %r'
% self._valuestr(cssText))
nonetoken = self._nexttoken(tokenizer)
if nonetoken:
ok = False
self._log.error('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="(DOM) The parsable textual representation of this "
"rule.")
def _setStyle(self, style):
"""
:param style:
a CSSStyleDeclaration or string
"""
self._checkReadonly()
# under Python 2.X this was basestring but given unicode literals ...
if isinstance(style, string_type):
self._style = CSSStyleDeclaration(cssText=style, parentRule=self)
else:
style._parentRule = self
self._style = style
style = property(lambda self: self._style, _setStyle,
doc="(DOM) The declaration-block of this rule set, "
"a :class:`~css_parser.css.CSSStyleDeclaration`.")
type = property(lambda self: self.FONT_FACE_RULE,
doc="The type of this rule, as defined by a CSSRule "
"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="CSSFontFace is valid if properties `font-family` "
"and `src` are set and all properties are valid.")
# constant but needed:
wellformed = property(lambda self: True)
Mini Shell