def __init__(self, text="", skinObj=skin.Skin.default, **kwargs):
self.cfg = skinObj.defaultCheckBoxCfg
uncheckedUpNode = self.__createImageNode(self.cfg["uncheckedUpBmp"])
uncheckedDownNode = self.__createImageNode(
self.cfg["uncheckedDownBmp"])
uncheckedDisabledNode = self.__createImageNode(
self.cfg["uncheckedDisabledBmp"])
checkedUpNode = self.__createImageNode(self.cfg["checkedUpBmp"])
checkedDownNode = self.__createImageNode(self.cfg["checkedDownBmp"])
checkedDisabledNode = self.__createImageNode(
self.cfg["checkedDisabledBmp"])
super(CheckBox,
self).__init__(uncheckedUpNode=uncheckedUpNode,
uncheckedDownNode=uncheckedDownNode,
uncheckedDisabledNode=uncheckedDisabledNode,
checkedUpNode=checkedUpNode,
checkedDownNode=checkedDownNode,
checkedDisabledNode=checkedDisabledNode,
**kwargs)
self.textNode = avg.WordsNode(pos=(20, 0),
text=text,
fontstyle=self.cfg["font"],
parent=self)
def onInit(self):
self.node = avg.WordsNode(pos=(10, 10),
text="Should I stay or should I go?",
parent=self)
div = avg.DivNode(pos=(100, 0), size=(80, 200), parent=self)
self.node.subscribe(avg.Node.CURSOR_MOTION, self.onWords)
div.subscribe(div.CURSOR_MOTION, self.onDiv)
def __create_reload_overlay(self):
if not self.__use_reload_overlay:
return
self.__reload_overlay = avg.DivNode(parent=self._data_div,
size=self._data_div.size,
active=False)
avg.RectNode(parent=self.__reload_overlay,
size=self._data_div.size,
strokewidth=0,
fillopacity=0.75,
fillcolor=global_values.COLOR_DARK_GREY)
text = avg.WordsNode(parent=self.__reload_overlay,
text="Click to\nreload",
fontsize=global_values.FONT_SIZE * 2,
color=global_values.COLOR_FOREGROUND,
alignment="center",
rawtextmode=True,
pos=(self._data_div.size[0] / 2,
self._data_div.size[1] / 2))
text.pos = text.pos[
0], text.pos[1] - 2 * global_values.FONT_SIZE + text.linespacing
self.__reload_tap_recognizer = gesture.TapRecognizer(
node=self.__reload_overlay,
detectedHandler=self.__on_reload_overlay_tapped,
maxDist=5,
maxTime=500)
def change_configuration(self, device_pointer_config):
"""
Changes the device pointer configuration and draws the view anew.
:param device_pointer_config: The new configuration.
:type device_pointer_config: DevicePointerConfigurations
"""
internal_div_nodes = [
self.__internal_div.getChild(i)
for i in range(self.__internal_div.getNumChildren())
]
for node in internal_div_nodes:
node.unlink(True)
self.__device_pointer_config = device_pointer_config
self.__internal_div = avg.DivNode(parent=self)
avg.RectNode(
parent=self.__internal_div,
strokewidth=0,
fillcolor=self.__device_pointer_config.device_canvas_color,
fillopacity=1,
size=self.__device.size)
avg.WordsNode(
parent=self.__internal_div,
text=self.__device_pointer_config.device_canvas_text,
alignment="center",
fontsize=self.__device_pointer_config.text_configuration.font_size,
color=self.__device_pointer_config.text_configuration.color,
pos=(self.__device.size[0] / 2, self.__device.size[1] / 2))
def _draw_data_object_label(self, data_object):
"""
Draws a label for the given data object.
:param data_object: The data object to draw the label for.
:type data_object: DataObject
:return: The new label node.
:rtype: avg.WordsNode
"""
data_line = self._data_object_nodes[data_object.obj_id]
if self.__orientation is Orientation.Horizontal:
pos = sorted(data_line.pos, key=lambda p: p[1])[0]
alignment = "center"
else:
pos = sorted(data_line.pos, key=lambda p: -p[0])[0]
alignment = "left"
label = avg.WordsNode(
parent=self._selection_label_div,
text=str(data_object.obj_id),
alignment=alignment,
fontsize=self._selection_label_text_config.font_size,
color=data_object.color,
rawtextmode=True)
if self.__orientation is Orientation.Horizontal:
label.pos = pos[0], pos[1] - label.size[
1] - self._selection_label_text_config.offset_to_other_element
else:
label.pos = pos[
0] + self._selection_label_text_config.offset_to_other_element, pos[
1] - label.size[1] / 2
return label
def testWrapMode(self):
def setCharMode():
node.wrapmode = 'char'
def setWordMode():
node.wrapmode = 'word'
def setWordCharMode():
node.wrapmode = 'wordchar'
root = self.loadEmptyScene()
node = avg.WordsNode(pos=(1, 1),
fontsize=12,
font="Bitstream Vera Sans",
variant="roman",
width=100,
text="""Wrapped paragraph more than one line long.
Withaverylongpackedlinewithnobreaks""",
parent=root)
self.start(True, (
lambda: self.compareImage("testWrapMode1"),
setCharMode,
lambda: self.compareImage("testWrapMode2"),
setWordMode,
lambda: self.compareImage("testWrapMode3"),
setWordCharMode,
lambda: self.compareImage("testWrapMode4"),
))
def update(self):
self.clear()
for binding in kbmgr.getCurrentBindings():
if binding.keyname:
keystring = binding.keyname
else:
keystring = binding.text
modifiersStr = self.__modifiersToString(binding.modifiers)
if modifiersStr is not None:
key = '%s-%s' % (modifiersStr, keystring)
else:
key = keystring
if binding.type == libavg.avg.KEYDOWN:
key = '%s %s' % (unichr(8595), key)
else:
key = '%s %s' % (unichr(8593), key)
node = avg.WordsNode(
text='<span size="large"><b>%s</b></span>: %s' %
(key, binding.help),
fontsize=g_fontsize,
parent=self)
self.keybindingWordNodes.append(node)
self._placeNodes()
def __init__(self, event, **kwargs):
BaseTouchVisualization.__init__(self, event, **kwargs)
self.positions = [event.pos]
if event.source == avg.Event.TOUCH:
color = 'e5d8d8'
elif event.source == avg.Event.TANGIBLE:
color = 'ffe0e0'
else:
color = 'd8e5e5'
self.opacity = 0.5
self.__transparentCircle = avg.CircleNode(r=self._radius + 20,
fillcolor=color,
fillopacity=0.2,
opacity=0.0,
strokewidth=1,
sensitive=False,
parent=self)
self.__pulsecircle = avg.CircleNode(r=self._radius,
fillcolor=color,
color=color,
fillopacity=0.5,
opacity=0.5,
strokewidth=1,
sensitive=False,
parent=self)
if event.source in [avg.Event.TOUCH, avg.Event.TRACK]:
self.__majorAxis = avg.LineNode(pos1=(0, 0),
pos2=event.majoraxis,
color='FFFFFF',
sensitive=False,
parent=self)
self.__minorAxis = avg.LineNode(pos1=(0, 0),
pos2=event.minoraxis,
color='FFFFFF',
sensitive=False,
parent=self)
if event.source == avg.Event.TOUCH:
self.__handAxis = avg.LineNode(pos1=(0, 0),
pos2=self.__getHandVector(event),
opacity=0.5,
color='A0FFA0',
sensitive=False,
parent=self)
fontPos = avg.Point2D(self.__pulsecircle.r, 0)
self.__textNode = avg.WordsNode(pos=fontPos, fontsize=9, parent=self)
self.motionPath = avg.PolyLineNode(pos=self.positions,
opacity=0.7,
color=color,
parent=kwargs['parent'])
self.motionVector = avg.LineNode(pos1=(0, 0),
pos2=-event.contact.motionvec,
opacity=0.4,
parent=self)
pulseCircleAnim = avg.LinearAnim(self.__pulsecircle, 'r', 200, 50,
self._radius)
pulseCircleAnim.start()
def testGetTextAsDisplayed(self):
orgText = "A<br/>B C <b>D</b> E F G H <i>Ä</i> Ö Ü ? Ì Á<br/>Í Å Ø ∏ ~ ç Ç Å"
orgTextWithout = "A\nB C D E F G H Ä Ö Ü ? Ì Á\nÍ Å Ø ∏ ~ ç Ç Å"
textNode = avg.WordsNode(fontsize=30,
font="Bitstream Vera Sans",
text=orgText,
width=300)
self.assertEqual(orgTextWithout, textNode.getTextAsDisplayed())
def testParaWords(self):
root = self.loadEmptyScene()
avg.LineNode(pos1=(0.5, 0),
pos2=(0.5, 50),
color="FF0000",
parent=root)
avg.LineNode(pos1=(119.5, 0.5),
pos2=(119.5, 50),
color="FF0000",
parent=root)
avg.LineNode(pos1=(74.5, 60),
pos2=(74.5, 110),
color="FF0000",
parent=root)
avg.WordsNode(id="para",
pos=(1, 1),
fontsize=12,
width=70,
font="Bitstream Vera Sans",
text="Left-justified paragraph.",
parent=root)
avg.WordsNode(id="paracenter",
pos=(120, 1),
fontsize=12,
width=70,
font="Bitstream Vera Sans",
text="Centered paragraph",
alignment="center",
parent=root)
avg.WordsNode(id="pararight",
pos=(75, 60),
fontsize=12,
width=70,
font="Bitstream Vera Sans",
alignment="right",
text="Right-justified paragraph.<i>l</i>",
parent=root)
avg.WordsNode(id="paralinespacing",
pos=(80, 60),
fontsize=12,
width=70,
font="Bitstream Vera Sans",
linespacing=-4,
text="Paragraph with custom line spacing.",
parent=root)
self.start(True, [lambda: self.compareImage("testParaWords")])
def testWordsIntensity(self):
root = self.loadEmptyScene()
avg.WordsNode(parent=root, fontsize=24, font="Bitstream Vera Sans",
variant="Roman", intensity=(0.5,0.5,0.5), text="brightness",
width=140)
self.start(True,
(lambda: self.compareImage("testWordsIntensity"),
))
def testWordsOutlines(self):
root = self.loadEmptyScene()
root.elementoutlinecolor = "FFFFFF"
avg.WordsNode(pos=(40, 40),
alignment="center",
text="test",
parent=root)
self.start(True, [lambda: self.compareImage("testWordsOutlines")])
def testFontDir(self):
avg.WordsNode.addFontDir('extrafonts')
root = self.loadEmptyScene()
avg.WordsNode(font="testaddfontdir",
fontsize=50,
text="ABAAA",
parent=root)
self.start(True, (lambda: self.compareImage("testFontDir"), ))
def onInit(self):
self.toggleTouchVisualization()
avg.WordsNode(pos=(10,5), text="Masking", fontsize=13, aagamma=2.0, parent=self)
avg.ImageNode(pos=(10,30), href="rgb24-64x64.png", parent=self)
CaptionNode(pos=(10,30), text="Plain Image", parent=self)
avg.ImageNode(pos=(90,30), href="rgb24-64x64.png", maskhref="mask.png",
parent=self)
CaptionNode(pos=(90,30), text="Masked Image", parent=self)
avg.WordsNode(pos=(10,155), text="Blend Modes", fontsize=13, aagamma=2.0,
parent=self)
for i, blendmode in enumerate(("blend", "add", "min", "max")):
pos=avg.Point2D(10,180)+i*avg.Point2D(80,0)
avg.ImageNode(pos=pos, href="mask.png", parent=self)
avg.ImageNode(pos=pos, href="rgb24-64x64.png", blendmode=blendmode,
parent=self)
CaptionNode(pos=pos, text=blendmode, parent=self)
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 __init__(self, parent=None, **kwargs):
super(DebugWidget, self).__init__(**kwargs)
self.registerInstance(self, parent)
self.publish(DebugWidget.WIDGET_HEIGHT_CHANGED)
if self.CAPTION:
self._caption = avg.WordsNode(text=self.CAPTION, pivot=(0, 0),
opacity=0.5, fontsize=14, parent=self)
self._caption.angle = math.pi / 2
self._caption.pos = (self.width, 0)
def testWordsBR(self):
root = self.loadEmptyScene()
avg.WordsNode(pos=(1, 1),
fontsize=12,
font="Bitstream Vera Sans",
variant="roman",
text="paragraph 1<br/>paragraph 2",
parent=root)
self.start(True, [lambda: self.compareImage("testWordsBR")])
def onInit(self):
self.textNode = avg.WordsNode(pos=(10, 10), text="", parent=self)
for i in range(0, 10):
pos = avg.Point2D(10, 40) + ((i % 3) * 40, (i // 3) * 40)
node = widget.TextButton(pos=pos,
size=(30, 30),
text=str(i),
parent=self)
node.subscribe(widget.Button.CLICKED, lambda i=i: self.onDown(i))
def __init_time_bar(self, duration, interval):
pos = avg.Point2D(58, 0)
size = avg.Point2D(self.width - pos.x - 10, 60)
self.__time_bar = avg.DivNode(pos=pos, size=size, parent=self)
avg.WordsNode(pos=(0, 0),
color=global_values.COLOR_FOREGROUND,
fontsize=global_values.FONT_SIZE,
text="Time range",
parent=self.__time_bar)
self.__time_slider = custom_slider.IntervalScrollBar(
pos=(0, 27),
width=size.x,
range=(0, duration),
thumbExtent=duration,
parent=self.__time_bar)
self.__time_slider.subscribe(
custom_slider.IntervalScrollBar.THUMB_POS_CHANGED,
self.__on_scroll)
self.__start_label = avg.WordsNode(
pos=(0, 48),
color=global_values.COLOR_FOREGROUND,
text="0:00 ({})".format(helper.format_time(interval[0], False)),
fontsize=global_values.FONT_SIZE,
parent=self.__time_bar)
self.__end_label = avg.WordsNode(
pos=(size.x, 48),
color=global_values.COLOR_FOREGROUND,
text="({}) {}".format(helper.format_time(interval[1], False),
helper.format_time(self.__duration, False)),
alignment="right",
fontsize=global_values.FONT_SIZE,
parent=self.__time_bar)
self.__cur_time_line = avg.LineNode(color=global_values.COLOR_WHITE,
sensitive=False,
parent=self.__time_bar)
self.__duration_time_label = avg.WordsNode(
pos=(size.x, 0),
color=global_values.COLOR_FOREGROUND,
alignment="right",
fontsize=global_values.FONT_SIZE,
parent=self.__time_bar)
def __init__(self,
label,
vis_params,
axis_size,
show_grid,
aspect=None,
parent=None,
**kwargs):
super(VisPanel, self).__init__(**kwargs)
self.registerInstance(self, parent)
self.crop = True
self.__axis_size = avg.Point2D(axis_size)
data_div_size = self.size - self.__axis_size
if aspect is not None:
data_div_size.y = data_div_size.x * aspect
self.size = data_div_size + self.__axis_size
# rect for background
avg.RectNode(pos=(self.__axis_size.x, 0),
size=data_div_size,
strokewidth=0,
fillopacity=1,
fillcolor=global_values.VIS_PANEL_BACKGROUND,
parent=self)
self._grid_div = avg.DivNode(pos=(self.__axis_size.x, 0),
size=data_div_size,
parent=self)
# rect for border
avg.RectNode(pos=(self.__axis_size.x, 0),
size=data_div_size,
strokewidth=1,
color=global_values.COLOR_FOREGROUND,
parent=self)
self._data_div = avg.DivNode(pos=(self.__axis_size.x, 0),
size=data_div_size,
crop=True)
avg.WordsNode(pos=(6, 6),
color=global_values.COLOR_FOREGROUND,
text=label,
variant="bold",
sensitive=False,
fontsize=global_values.FONT_SIZE_SMALLER,
parent=self._data_div)
vis_params.subscribe(vis_params.CHANGED, self._update_time)
self._vis_params = vis_params
self.__show_grid = show_grid
self._x_grid = []
self._y_grid = []
self._x_axis = None
self._y_axis = None
def testI18NWords(self):
def changeUnicodeText():
words.text = "Arabic nonsense: ﯿﭗ"
def setNBSP():
words.width = 100
words.text = (u"blindtext1\u00A0blindtext2\u00Ablindtext3 " +
u"blindtext4\u00A0blindtext\u00A0blindtext\u00A0")
root = self.loadEmptyScene()
avg.WordsNode(pos=(1, 1),
fontsize=14,
font="Bitstream Vera Sans",
variant="Roman",
text="一二三四五六七八九",
parent=root)
words = avg.WordsNode(pos=(1, 24),
fontsize=12,
font="Bitstream Vera Sans",
variant="Roman",
text="foo",
parent=root)
root.appendChild(
player.createNode("""
<words x="1" y="48" fontsize="12" font="Bitstream Vera Sans" variant="Roman">
&
</words>
"""))
avg.WordsNode(pos=(12, 48),
fontsize=12,
font="Bitstream Vera Sans",
variant="Roman",
text="&",
rawtextmode=True,
parent=root)
self.start(True, (
lambda: self.compareImage("testI18NWords1"),
changeUnicodeText,
lambda: self.compareImage("testI18NWords2"),
setNBSP,
lambda: self.compareImage("testI18NWords3"),
))
def createUsingDict():
player.getElementByID("words").unlink()
node = avg.WordsNode(id="words",
pos=(1, 1),
fontsize=12,
width=120,
font="Bitstream Vera Sans",
variant="roman",
text=self.text)
root.appendChild(node)
def onInit(self):
self.node.play()
mediaSize = self.node.getMediaSize()
canvasSize = self.size
sizeRatio = min(mediaSize.x / canvasSize.x, mediaSize.y / canvasSize.y)
self.node.size /= sizeRatio
self.node.x = (self.width - self.node.width) / 2
self.node.y = (self.height - self.node.height) / 2
self.node.subscribe(avg.VideoNode.END_OF_FILE, self.onEOF)
if self.node.hasAlpha():
self.__makeAlphaBackground()
self.appendChild(self.node)
self.curFrameWords = avg.WordsNode(parent=self,
pos=(10, 10),
fontsize=10)
self.framesQueuedWords = avg.WordsNode(parent=self,
pos=(10, 22),
fontsize=10)
controlPos = ((self.width - VideoPlayer.CONTROL_WIDTH) / 2,
self.height - 25)
self.videoControl = widget.MediaControl(
pos=controlPos,
size=(VideoPlayer.CONTROL_WIDTH, 20),
duration=self.node.getDuration(),
parent=self)
self.videoControl.play()
self.videoControl.subscribe(widget.MediaControl.PLAY_CLICKED,
self.onPlay)
self.videoControl.subscribe(widget.MediaControl.PAUSE_CLICKED,
self.onPause)
self.videoControl.subscribe(widget.MediaControl.SEEK_PRESSED,
self.onSeekStart)
self.videoControl.subscribe(widget.MediaControl.SEEK_RELEASED,
self.onSeekEnd)
self.videoControl.subscribe(widget.MediaControl.SEEK_MOTION,
self.onSeek)
self.isSeeking = False
self.isPaused = False
def testGetCharIndexFromPos(self):
textNode = avg.WordsNode(fontsize=30,
font = "Bitstream Vera Sans",
text = "A B C D E F G H Ä Ö Ü ? Ì Á Í Å Ø ∏ ~ ç Ç Å",
width = 300)
for k in (1,2,3,23,42):
pos = textNode.getGlyphPos(k)
char = textNode.getCharIndexFromPos(pos)
self.assertEqual(char, k)
def _createGraph(self):
try:
libavg.player.getVideoMemUsed()
except avg.Exception:
return avg.WordsNode(parent=self,
text='GPU memory graph is not supported on this hardware',
color='ff5555')
else:
return graph.AveragingGraph(parent=self, size=self.size,
getValue=libavg.player.getVideoMemUsed)
def testLetterSpacing(self):
def setSpacing():
player.getElementByID("words1").letterspacing=-2
player.getElementByID("words2").letterspacing=-2
root = self.loadEmptyScene()
avg.WordsNode(id="words1", pos=(1,1), fontsize=12, font="Bitstream Vera Sans",
variant="roman",
text="""normal
<span letter_spacing="-2048"> packed</span>
<span letter_spacing="2048"> spaced</span>""",
parent=root)
avg.WordsNode(id="words2", pos=(1,20), fontsize=12, font="Bitstream Vera Sans",
variant="roman", letterspacing=2, text="spaced", parent=root)
self.start(True,
(lambda: self.compareImage("testLetterSpacing1"),
setSpacing,
lambda: self.compareImage("testLetterSpacing2")
))
def __create_wall_rect(self):
x_min = self._x_axis.value_to_pixel(0)
x_max = self._x_axis.value_to_pixel(pat_model.wall_width)
y_max = self._y_axis.value_to_pixel(0)
avg.RectNode(pos=(x_min, y_max-16), size=(x_max - x_min, 16), fillcolor=global_values.COLOR_DARK_GREY,
fillopacity=1, parent=self._data_div)
label_pos = (x_min + (x_max-x_min)/2, y_max-18)
avg.WordsNode(pos=label_pos, text="WALL", fontsize=14, alignment="center",
parent=self._data_div)
def testWordsClicks(self):
root = self.loadEmptyScene()
words = avg.WordsNode(pos=(40,40), alignment="right", text="test", parent=root)
handlerTester = NodeHandlerTester(self, words)
self.start(False,
(lambda: self._sendMouseEvent(avg.Event.CURSOR_DOWN, 45, 45),
lambda: handlerTester.assertState(()),
lambda: self._sendMouseEvent(avg.Event.CURSOR_UP, 35, 45),
lambda: handlerTester.assertState(
(avg.Node.CURSOR_UP, avg.Node.CURSOR_OVER)),
))
def createDynNodes():
self.dictdnode = avg.WordsNode(text='<test dyndict&',
rawtextmode=True, pos=(1,65), font='Bitstream Vera Sans',
variant='roman', fontsize=12)
root.appendChild(self.dictdnode)
self.xmldnode = player.createNode("""
<words text="<test dynattr&" fontsize="12"
font="Bitstream Vera Sans" variant="roman" rawtextmode="true"
x="1" y="85"/>""")
root.appendChild(self.xmldnode)
def testJustify(self):
root = self.loadEmptyScene()
avg.WordsNode(pos=(1, 1),
fontsize=12,
font="Bitstream Vera Sans",
variant="roman",
justify=True,
width=100,
text="Justified paragraph more than one line long.",
parent=root)
self.start(True, [lambda: self.compareImage("testJustify")])
