def testBaseStyle(self):
attrs = {
"font": "Bitstream Vera Sans",
"variant": "Bold",
"color": "FF0000",
"aagamma": 0.5,
"fontsize": 20,
"indent": 1,
"linespacing": 2,
"alignment": "right",
"wrapmode": "char",
"justify": True,
"letterspacing": 3,
"hint": False
}
defaultStyle = avg.FontStyle()
fontStyle1 = avg.FontStyle(basestyle=defaultStyle, **attrs)
for attrName in attrs.iterkeys():
self.assert_(
getattr(fontStyle1, attrName) != getattr(
defaultStyle, attrName))
self.assert_(getattr(fontStyle1, attrName) == attrs[attrName])
fontStyle2 = avg.FontStyle(basestyle=fontStyle1)
for attrName in attrs.iterkeys():
self.assert_(
getattr(fontStyle2, attrName) == getattr(fontStyle1, attrName))
def testFontStyle(self):
def setStyle(node, style):
node.fontstyle = style
self.assert_(node.fontsize == 15)
fontStyle = avg.FontStyle(font="Bitstream Vera Sans",
variant="Roman",
fontsize=12)
self.assert_(fontStyle.font == "Bitstream Vera Sans")
root = self.loadEmptyScene()
words = avg.WordsNode(pos=(1, 1),
fontstyle=fontStyle,
text="Bitstream Vera Sans",
parent=root)
avg.WordsNode(pos=(1, 16),
fontstyle=fontStyle,
variant="bold",
text="Bold",
parent=root)
otherFontStyle = fontStyle
otherFontStyle.fontsize = 15
self.start(True, (
lambda: self.compareImage("testFontStyle1"),
lambda: setStyle(words, otherFontStyle),
lambda: self.compareImage("testFontStyle2"),
))
def testUnicodeAttributes(self):
try:
fontStyle = avg.FontStyle(font=u"Bitstream Vera Sans", variant=u"Roman",
alignment=u"left", wrapmode=u"word")
self.assert_(fontStyle.font == "Bitstream Vera Sans")
avg.WordsNode(fontstyle=fontStyle, text="Bitstream Vera Sans")
except avg.Exception as e:
msg = "Failed to create FontStyle object by using unicode strings as parameters"
self.fail(msg)
try:
avg.WordsNode(font=u"Bitstream Vera Sans", variant=u"Roman",
text=u"Bold", alignment=u"left", wrapmode=u"word")
except avg.Exception:
msg = "Failed to create WordsNode object by using unicode strings as parameters"
self.fail(msg)
def setStyle(self, font='sans', fontsize=12, alignment='left', variant='Regular',
color='000000', multiline=True, cursorWidth=None, border=(0,0),
blurOpacity=DEFAULT_BLUR_OPACITY, flashingCursor=False, cursorColor='000000',
lineSpacing=0, letterSpacing=0):
"""
Set TextArea's graphical appearance
@param font: font face
@param fontsize: font size in pixels
@param alignment: one among 'left', 'right', 'center'
@param variant: font variant (eg: 'bold')
@param color: RGB hex for text color
@param multiline: boolean, whether TextArea has to wrap (undefinitely)
or stop at full width
@param cursorWidth: int, width of the cursor in pixels
@param border: amount of offsetting pixels that words node will have from image
extents
@param blurOpacity: opacity that textarea gets when goes to blur state
@param flashingCursor: whether the cursor should flash or not
@param cursorColor: RGB hex for cursor color
@param lineSpacing: linespacing property of words node
@param letterSpacing: letterspacing property of words node
"""
self.__textNode.fontstyle = avg.FontStyle(font=font, fontsize=fontsize,
alignment=alignment, variant=variant, linespacing=lineSpacing,
letterspacing=letterSpacing)
self.__textNode.color = color
self.__isMultiline = multiline
self.__border = border
self.__maxLength = -1
self.__blurOpacity = blurOpacity
if multiline:
self.__textNode.width = int(self.width) - self.__border[0] * 2
self.__textNode.wrapmode = 'wordchar'
else:
self.__textNode.width = 0
self.__textNode.x = self.__border[0]
self.__textNode.y = self.__border[1]
tempNode = avg.WordsNode(text=u'W', font=font, fontsize=int(fontsize),
variant=variant)
self.__textNode.realFontSize = tempNode.getGlyphSize(0)
del tempNode
self.__textNode.alignmentOffset = Point2D(0,0)
if alignment != "left":
offset = Point2D(self.size.x / 2,0)
if alignment == "right":
offset = Point2D(self.size.x,0)
self.__textNode.pos += offset
self.__textNode.alignmentOffset = offset
self.__cursorContainer.pos = offset
self.__cursorNode.color = cursorColor
if cursorWidth is not None:
self.__cursorNode.strokewidth = cursorWidth
else:
w = float(fontsize) * CURSOR_WIDTH_PCT / 100.0
if w < 1:
w = 1
self.__cursorNode.strokewidth = w
x = self.__cursorNode.strokewidth / 2.0
self.__cursorNode.pos1 = Point2D(x, self.__cursorNode.pos1.y)
self.__cursorNode.pos2 = Point2D(x, self.__cursorNode.pos2.y)
self.__flashingCursor = flashingCursor
if not flashingCursor:
self.__cursorContainer.opacity = 1
if self.__loupe:
zoomfactor = (1.0 + self.__loupeZoomFactor)
self.__loupeTextNode.fontstyle = self.__textNode.fontstyle
self.__loupeTextNode.fontsize = int(fontsize) * zoomfactor
self.__loupeTextNode.color = color
if multiline:
self.__loupeTextNode.width = self.__textNode.width * zoomfactor
self.__loupeTextNode.wrapmode = 'wordchar'
else:
self.__loupeTextNode.width = 0
self.__loupeTextNode.x = self.__border[0] * 2
self.__loupeTextNode.y = self.__border[1] * 2
self.__loupeTextNode.realFontSize = self.__textNode.realFontSize * zoomfactor
if alignment != "left":
self.__loupeTextNode.pos = self.__textNode.pos * zoomfactor
self.__loupeTextNode.alignmentOffset = self.__textNode.alignmentOffset * \
zoomfactor
self.__loupeCursorContainer.pos = self.__cursorContainer.pos * zoomfactor
self.__loupeCursorNode.color = cursorColor
if cursorWidth is not None:
self.__loupeCursorNode.strokewidth = cursorWidth * zoomfactor
else:
w = float(self.__loupeTextNode.fontsize) * CURSOR_WIDTH_PCT / 100.0
if w < 1:
w = 1
self.__loupeCursorNode.strokewidth = w * zoomfactor
x = self.__loupeCursorNode.strokewidth / 2.0
self.__loupeCursorNode.pos1 = Point2D(x, self.__loupeCursorNode.pos1.y)
self.__loupeCursorNode.pos2 = Point2D(x, self.__loupeCursorNode.pos2.y)
if not flashingCursor:
self.__loupeCursorContainer.opacity = 1
self.__updateCursors()
def __init__(self, skinXmlFName, mediaDir=""):
global defaultMediaDir
self.__mediaDir = defaultMediaDir if mediaDir == "" else mediaDir
schemaFName = defaultMediaDir + "skin.xsd"
schemaString = open(schemaFName, "r").read()
skinPath = os.path.join(self.__mediaDir, skinXmlFName)
xmlString = open(skinPath, "r").read()
avg.validateXml(xmlString, schemaString, skinXmlFName, schemaFName)
xmlRoot = ET.fromstring(xmlString)
self.fonts = {}
for fontNode in xmlRoot.findall("fontdef"):
fontid, attrs = self.__splitAttrs(fontNode)
if "baseid" in attrs:
self.fonts[fontid] = copy.copy(self.fonts[attrs["baseid"]])
font = self.fonts[fontid]
del attrs["baseid"]
for (key, value) in attrs.iteritems():
setattr(font, key, value)
else:
kwargs = self.__extractArgs(
attrs, ("fontsize", "letterspacing", "linespacing"))
self.fonts[fontid] = avg.FontStyle(**kwargs)
self.textButtonCfg, self.defaultTextButtonCfg = self.__parseElement(
xmlRoot,
"textbutton",
bmpArgNames={
"upSrc": "upBmp",
"downSrc": "downBmp",
"disabledSrc": "disabledBmp"
},
fontArgNames=("font", "downFont", "disabledFont"))
self.checkBoxCfg, self.defaultCheckBoxCfg = self.__parseElement(
xmlRoot,
"checkbox",
bmpArgNames={
"uncheckedUpSrc": "uncheckedUpBmp",
"uncheckedDownSrc": "uncheckedDownBmp",
"uncheckedDisabledSrc": "uncheckedDisabledBmp",
"checkedUpSrc": "checkedUpBmp",
"checkedDownSrc": "checkedDownBmp",
"checkedDisabledSrc": "checkedDisabledBmp"
},
fontArgNames=("font", "downFont", "disabledFont"))
self.sliderCfg, self.defaultSliderCfg = self.__initSliders(
xmlRoot, "slider")
self.scrollBarCfg, self.defaultScrollBarCfg = self.__initSliders(
xmlRoot, "scrollbar")
self.progressBarCfg, self.defaultProgressBarCfg = self.__initSliders(
xmlRoot, "progressbar")
self.scrollAreaCfg, self.defaultScrollAreaCfg = self.__parseElement(
xmlRoot,
"scrollarea",
pyArgNames=("friction", "borderEndsExtent", "margins",
"sensitiveScrollBars"),
bmpArgNames={"borderSrc": "borderBmp"})
self.mediaControlCfg, self.defaultMediaControlCfg = self.__parseElement(
xmlRoot,
"mediacontrol",
bmpArgNames={
"playUpSrc": "playUpBmp",
"playDownSrc": "playDownBmp",
"playDisabledSrc": "playDisabledBmp",
"pauseUpSrc": "pauseUpBmp",
"pauseDownSrc": "pauseDownBmp",
"pauseDisabledSrc": "pauseDisabledBmp"
},
pyArgNames=("timePos", "timeLeftPos", "barPos", "barRight"),
fontArgNames=("font"))
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from libavg import avg, player
BASE_STYLE = avg.FontStyle(font='Arial',
variant='Regular',
fontsize=14,
linespacing=2)
HEADER_STYLE = avg.FontStyle(basestyle=BASE_STYLE,
variant='Bold',
color='FF0000')
SAMPLE_TEXT = """
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Proin vitae gravida urna. Nam ut nisi ac nulla venenatis tincidunt a in urna. Cras vel enim purus, sit amet adipiscing dolor. Aliquam tincidunt interdum velit sed hendrerit. Proin ut enim dolor, sit amet egestas mi. Aenean felis quam, sollicitudin sed tempus in, pharetra eget turpis.
"""
canvas = player.createMainCanvas(size=(640, 480))
rootNode = canvas.getRootNode()
avg.WordsNode(pos=(50, 50),
text='Lorem Ipsum',
fontstyle=HEADER_STYLE,
parent=rootNode)
avg.WordsNode(pos=(50, 70),
text='Lorem Ipsum',
fontstyle=HEADER_STYLE,
variant='Italic',
parent=rootNode)
avg.WordsNode(pos=(50, 90),
text=SAMPLE_TEXT,
