def testRotatePivot(self):
def setPivot(pos):
node.pivot = pos
def addPivot(offset):
node.pivot += offset
root = self.loadEmptyScene()
node = avg.DivNode(pos=(80, 0),
size=(160, 120),
pivot=(0, 0),
angle=1.57,
crop=True,
parent=root)
div = avg.DivNode(pos=(40, -20),
size=(160, 120),
pivot=(0, 0),
angle=0.79,
crop=True,
parent=node)
avg.ImageNode(pos=(-10, -10),
size=(128, 128),
href="rgb24-65x65.png",
parent=div)
avg.ImageNode(pos=(0, 10),
size=(32, 32),
href="rgb24-65x65.png",
parent=node)
self.start(False, (
lambda: self.compareImage("testRotatePivot1"),
lambda: setPivot((10, 10)),
lambda: self.compareImage("testRotatePivot2"),
lambda: addPivot((-8, 0)),
lambda: self.compareImage("testRotatePivot3"),
))
def onInit(self):
self.mediadir = getMediaDir(__file__)
self.__gameMusic = avg.SoundNode(href='Fire_Birds.mp3', loop=True,
volume=0.75, parent=self)
self.__scrollingBg = ScrollingBackground(self)
self.__shadowDiv = avg.DivNode(parent=self)
self.__gameDiv = avg.DivNode(size=self.size, parent=self)
self.__guiDiv = avg.DivNode(parent=self)
bg = avg.ImageNode(href='gui_frame.png', parent=self.__guiDiv)
self.__guiDiv.pos = (0, self.height - bg.height)
self.__lifeCounter = LifeCounter(pos=(8, 12), parent=self.__guiDiv)
gunCtrl = GunControl(pos=(300, 54), parent=self.__guiDiv)
self.__scoreCounter = ScoreCounter(pos=(1142, 54), parent=self.__guiDiv)
self.__enemies = []
for i in xrange(2):
self.__createEnemy()
self.__player = PlayerAircraft(self.__shadowDiv, gunCtrl, parent=self.__gameDiv)
enemyMask = avg.Bitmap(self.mediadir + '/enemy.gif')
self.__playerCollisionDetector = collisiondetector.CollisionDetector(
enemyMask, avg.Bitmap(self.mediadir + '/spitfire.gif'))
self.__bulletCollisionDetector = collisiondetector.CollisionDetector(
enemyMask, avg.Bitmap(self.mediadir + '/bullet.gif'))
self.__keyStates = dict.fromkeys(PlayerAircraft.ACTION_KEYS, False)
self.__frameHandlerId = None
self.__spawnTimeoutId = None
self.__gameMusic.play()
self.__start()
player.subscribe(player.KEY_DOWN, self.__onKeyDown)
player.subscribe(player.KEY_UP, self.__onKeyUp)
def __initDefaultRotateScene(self):
root = self.loadEmptyScene()
div = avg.DivNode(pos=(80, 10),
size=(80, 60),
pivot=(0, 0),
angle=0.274,
crop=True,
parent=root)
avg.ImageNode(pos=(10, 10),
size=(32, 32),
href="rgb24-65x65.png",
parent=div)
outerDiv = avg.DivNode(id="outer",
pos=(80, 70),
size=(80, 60),
pivot=(0, 0),
angle=0.274,
crop=True,
parent=root)
innerDiv = avg.DivNode(id="inner",
size=(80, 60),
pivot=(0, 0),
angle=-0.274,
crop=True,
parent=outerDiv)
avg.ImageNode(pos=(10, 10),
size=(32, 32),
href="rgb24-65x65.png",
parent=innerDiv)
return root
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 testRotate2(self):
root = self.loadEmptyScene()
div1 = avg.DivNode(pos=(80,0), size=(160,120), pivot=(0,0), angle=1.57,
parent=root)
avg.ImageNode(size=(16,16), href="rgb24-65x65.png", parent=div1)
div2 = avg.DivNode(pos=(40,0), size=(110,80), pivot=(0,0), angle=1.57,
crop=True, parent=div1)
avg.ImageNode(pos=(0,0), size=(16,16), href="rgb24-65x65.png", parent=div2)
avg.ImageNode(pos=(30,-6), size=(16,16), href="rgb24-65x65.png", parent=div2)
self.start(False, [lambda: self.compareImage("testRotate2")])
def testInputDeviceEventReceiverNode(self):
root = self.loadEmptyScene()
divNode = avg.DivNode(id="div", size=(50, 50), parent=root)
rectNode = avg.RectNode(id="rect", size=(50, 50), parent=root)
self.customInputDevice = CustomInputDevice(divNode)
player.addInputDevice(self.customInputDevice)
handlerTester = NodeHandlerTester(self, divNode)
self.start(False, (
lambda: self.customInputDevice.feedEvent(
avg.MouseEvent(avg.Event.CURSOR_DOWN, True, False, False,
(10, 10), 1)),
lambda: handlerTester.assertState(
(avg.Node.CURSOR_DOWN, avg.Node.CURSOR_OVER)),
lambda: self.customInputDevice.feedEvent(
avg.MouseEvent(avg.Event.CURSOR_MOTION, True, False, False,
(12, 12), 1)),
lambda: handlerTester.assertState((avg.Node.CURSOR_MOTION, )),
lambda: self.customInputDevice.feedEvent(
avg.MouseEvent(avg.Event.CURSOR_MOTION, True, False, False,
(100, 100), 1)),
lambda: handlerTester.assertState((avg.Node.CURSOR_OUT, )),
lambda: self.customInputDevice.feedEvent(
avg.MouseEvent(avg.Event.CURSOR_MOTION, True, False, False,
(12, 12), 1)),
lambda: handlerTester.assertState(
(avg.Node.CURSOR_OVER, avg.Node.CURSOR_MOTION)),
lambda: self.customInputDevice.feedEvent(
avg.MouseEvent(avg.Event.CURSOR_UP, False, False, False,
(12, 12), 1)),
lambda: handlerTester.assertState((avg.Node.CURSOR_UP, )),
))
def testDivEvents(self):
root = self.loadEmptyScene()
div = avg.DivNode(pos=(0,0), parent=root)
divHandlerTester = NodeHandlerTester(self, div)
img = avg.ImageNode(pos=(0,0), href="rgb24-65x65.png", parent=div)
imgHandlerTester = NodeHandlerTester(self, img)
self.start(False,
(# down, move, up.
# events are inside img and therefore should bubble to div.
lambda: self._sendMouseEvent(avg.Event.CURSOR_DOWN, 10, 10),
lambda: divHandlerTester.assertState(
(avg.Node.CURSOR_DOWN, avg.Node.CURSOR_OVER)),
lambda: imgHandlerTester.assertState(
(avg.Node.CURSOR_DOWN, avg.Node.CURSOR_OVER)),
lambda: self._sendMouseEvent(avg.Event.CURSOR_MOTION, 12, 12),
lambda: divHandlerTester.assertState((avg.Node.CURSOR_MOTION,)),
lambda: imgHandlerTester.assertState((avg.Node.CURSOR_MOTION,)),
lambda: self._sendMouseEvent(avg.Event.CURSOR_UP, 12, 12),
lambda: divHandlerTester.assertState((avg.Node.CURSOR_UP,)),
lambda: imgHandlerTester.assertState((avg.Node.CURSOR_UP,))
))
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 onInit(self):
player.showCursor(True)
self.videoListNode = avg.DivNode(parent=self)
self.videoNodes = []
fileNames = os.listdir(self.__folder)
i = 0
for fileName in fileNames:
try:
videoNode = avg.VideoNode(pos=(i * (self.__thumbWidth + 20),
0),
href=self.__folder + '/' + fileName,
loop=True,
mipmap=True,
enablesound=False,
parent=self.videoListNode)
videoNode.play()
self.videoNodes.append(videoNode)
size = videoNode.getMediaSize()
height = (self.__thumbWidth * size.y) / size.x
videoNode.size = (self.__thumbWidth, height)
videoNode.subscribe(videoNode.CURSOR_DOWN,
lambda event, videoNode=videoNode: self.
chooseVideo(event, videoNode))
i += 1
except RuntimeError:
pass
self.subscribe(self.CURSOR_MOTION, self.onMouseMove)
self.bigVideoNode = None
def __initDefaultScene(self):
root = self.loadEmptyScene()
avg.ImageNode(id="mainimg",
size=(100, 75),
href="rgb24-65x65.png",
parent=root)
div = avg.DivNode(id="nestedavg",
pos=(0, 32),
opacity=1,
size=(128, 32),
crop=True,
parent=root)
avg.ImageNode(id="obscured",
pos=(0, 20),
size=(96, 40),
href="rgb24-65x65.png",
parent=div)
avg.ImageNode(id="nestedimg1",
size=(96, 48),
href="rgb24-65x65.png",
parent=div)
avg.ImageNode(id="nestedimg2",
pos=(65, 0),
href="rgb24alpha-64x64.png",
parent=div)
def testPolygonEvents(self):
def moveNode():
div.pos = (40,40)
canvas = self.makeEmptyCanvas()
div = avg.DivNode(parent=canvas)
polygon = avg.PolygonNode(strokewidth=10, color="FF00FF",
pos=((10,10), (50,10), (90,50), (90, 90)), parent=div)
handlerTester = NodeHandlerTester(self, polygon)
self.start(False,
(lambda: self.fakeClick(20, 50),
lambda: handlerTester.assertState(()),
lambda: self.fakeClick(70, 50),
lambda: handlerTester.assertState(
(avg.Node.CURSOR_DOWN, avg.Node.CURSOR_OVER, avg.Node.CURSOR_UP)),
lambda: self.fakeClick(30, 7),
lambda: handlerTester.assertState(
(avg.Node.CURSOR_DOWN, avg.Node.CURSOR_UP)),
moveNode,
lambda: self.fakeClick(20, 20),
lambda: handlerTester.assertState([avg.Node.CURSOR_OUT]),
lambda: self.fakeClick(50, 50),
lambda: handlerTester.assertState(
(avg.Node.CURSOR_DOWN, avg.Node.CURSOR_OVER, avg.Node.CURSOR_UP)),
))
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 _initRow(self):
self.columnBackground = avg.RectNode(parent=self,
fillcolor="222222",
fillopacity=0.6,
opacity=0)
self.columnContainer = avg.DivNode(parent=self)
if TableRow.ROW_ID % 2 != 0:
self.columnBackground.fillopacity = 0
self.cols = [0] * NUM_COLS
self.liveColumn = avg.WordsNode(parent=self.columnContainer,
fontsize=g_fontsize,
text="N/A - SPECIAL",
size=(COL_WIDTH, ROW_HEIGHT),
variant="bold")
for i in xrange(0, NUM_COLS):
self.cols[i] = (avg.WordsNode(parent=self.columnContainer,
fontsize=g_fontsize,
text="0",
size=(COL_WIDTH / 2.0, ROW_HEIGHT),
pos=((i + 1) * COL_WIDTH, 0)),
avg.WordsNode(parent=self.columnContainer,
fontsize=g_fontsize,
text="(0)",
size=(COL_WIDTH / 2.0, ROW_HEIGHT),
pos=((i + 1) * COL_WIDTH +
COL_WIDTH / 2, 0),
color="000000"))
self.rowData = deque([(0, 0)] * (NUM_COLS + 1), maxlen=NUM_COLS + 1)
self.label = avg.WordsNode(parent=self,
fontsize=g_fontsize,
variant="bold")
self.setLabel("NONE")
def testUnlinkInHandler(self):
def onImgDown(event):
self.__imgDownCalled = True
self.div.unlink(True)
def onDivDown(event):
self.__divDownCalled = True
def checkState():
self.assert_(self.__imgDownCalled and not (self.__divDownCalled))
self.__imgDownCalled = False
self.__divDownCalled = False
root = self.loadEmptyScene()
self.div = avg.DivNode(pos=(0, 0), parent=root)
self.div.connectEventHandler(avg.Event.CURSOR_DOWN, avg.Event.MOUSE,
self, onDivDown)
img = avg.ImageNode(pos=(0, 0),
href="rgb24-65x65.png",
parent=self.div)
img.connectEventHandler(avg.Event.CURSOR_DOWN, avg.Event.MOUSE, self,
onImgDown)
self.start(
False,
(lambda: self._sendMouseEvent(avg.Event.CURSOR_DOWN, 10, 10),
checkState))
def testScrollPane(self):
def scrollLarge():
scrollPane.contentpos = (34, 34)
self.assertEqual(scrollPane.contentpos, (32, 32))
def initSmallContent():
scrollPane.size = (64, 64)
contentArea.size = (32, 32)
image.size = (32, 32)
scrollPane.contentpos = (0, 0)
self.assertEqual(scrollPane.getMaxContentPos(), (0, 0))
def scrollSmall():
scrollPane.contentpos = (32, 32)
root = self.loadEmptyScene()
contentArea = avg.DivNode(size=(64, 64))
image = avg.ImageNode(href="rgb24-64x64.png", parent=contentArea)
scrollPane = widget.ScrollPane(contentNode=contentArea,
size=(32, 32),
parent=root)
self.start(False, (
lambda: self.compareImage("testScrollPane1"),
scrollLarge,
lambda: self.compareImage("testScrollPane2"),
initSmallContent,
lambda: self.compareImage("testScrollPane3"),
scrollSmall,
lambda: self.compareImage("testScrollPane3"),
))
def showMenu(self):
self._createMenuBackground()
self.menuScreen = avg.DivNode(parent=self._parentNode, size=self._parentNode.size)
self.startButton = self.makeButtonInMiddle('start', self.menuScreen, -1, lambda:self.machine.changeState('Playing'))
self.tutorialButton = self.makeButtonInMiddle('help', self.menuScreen, 0, lambda:self.machine.changeState('Tutorial'))
self.aboutButton = self.makeButtonInMiddle('about', self.menuScreen, 1, lambda:self.machine.changeState('About'))
self.exitButton = self.makeButtonInMiddle('exit', self.menuScreen, 2, lambda:exit(0))
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 onInit(self):
if not os.path.isdir(self._imagesDir):
avg.logger.error('Directory [%s] not found' % self._imagesDir)
exit(1)
avg.logger.info('Scanning directory [%s] ...' % self._imagesDir)
imgExts = tuple(IMAGE_EXTENSIONS +
[ext.upper() for ext in IMAGE_EXTENSIONS])
self.__imgFiles = [
os.path.join(self._imagesDir, imgFile) for imgFile in filter(
lambda f: f.endswith(imgExts), os.listdir(self._imagesDir))
]
if not self.__imgFiles:
avg.logger.error('No image files found, '
'scanned file extensions:\n%s' %
(', '.join(imgExts)))
exit(1)
l = len(self.__imgFiles)
avg.logger.info('%d image file%s found' % (l, 's' if l > 1 else ''))
shuffle(self.__imgFiles)
self.__slidesDiv = avg.DivNode(size=self.size, parent=self)
# ping-pong two slides for cross-fade transition
self.__newSlide = Slide(parent=self.__slidesDiv)
self.__oldSlide = Slide(href=self.__imgFiles[0],
parent=self.__slidesDiv)
# HIDE_DONE notifications will trigger asynchronous pre-loading of the next image
self.__newSlide.subscribe(Slide.HIDE_DONE, self.__asyncPreload)
self.__oldSlide.subscribe(Slide.HIDE_DONE, self.__asyncPreload)
self.__currentIdx = 0
self.__changeSlide()
player.setInterval(CHANGE_INTERVAL, self.__changeSlide)
def __init__(self, parent=None, **kwargs):
super(GunControl, self).__init__(**kwargs)
self.registerInstance(self, parent)
bg = avg.ImageNode(href='gui_heatbar_bg.png', parent=self)
self.__heatbar = avg.DivNode(size=(1, bg.height), crop=True, parent=self)
avg.ImageNode(href='gui_heatbar_fg.png', parent=self.__heatbar)
self.__maxTemp = bg.width - GunControl.__TEMPERATURE_INC
self.__shootTimeout = 0.0
def testInvalidImageFilename(self):
def activateNode():
div.active = 1
root = self.loadEmptyScene()
div = avg.DivNode(active=False, parent=root)
avg.ImageNode(href="filedoesntexist.png", parent=div)
self.start(False, [activateNode])
def createPolygonInInivisbleDiv():
canvas = self.makeEmptyCanvas()
div = avg.DivNode(parent=canvas, opacity=0)
avg.PolygonNode(parent=div,
strokewidth=2, color="FF00FF",
fillopacity=1, fillcolor="00FF00",
pos=((10, 10), (50, 10), (90, 50), (90, 90)))
return div
def testCanvasCrop(self):
root = self.loadEmptyScene()
canvas = player.createCanvas(id="testcanvas", size=(160,120),
mediadir="media")
div = avg.DivNode(pos=(40,30), size=(80,60), crop=True,
parent=canvas.getRootNode())
avg.ImageNode(id="test1", pos=(-32, -32), href="rgb24-65x65.png", parent=div)
avg.ImageNode(parent=root, href="canvas:testcanvas")
self.start(False, (lambda: self.compareImage("testCanvasCrop"),))
def _setupBaseDivs(self, resolution):
player.loadString('''
<?xml version="1.0"?>
<!DOCTYPE avg SYSTEM "../../libavg/doc/avg.dtd">
<avg width="%s" height="%s">
</avg>''' % (resolution.x, resolution.y))
rootNode = player.getRootNode()
self._appNode = avg.DivNode(opacity=0, sensitive=False,
size=rootNode.size, parent=rootNode)
def setupPlayground(self):
# libavg setup
self.display = avg.DivNode(parent=self._parentNode, size=self._parentNode.size)
self.renderer = Renderer()
background = avg.ImageNode(parent=self.display)
background.setBitmap(self.backgroundpic)
self.display.player = None
(displayWidth, displayHeight) = self.display.size
widthThird = (int)(displayWidth / 3)
fieldSize = (widthThird, displayHeight)
self.field1 = avg.DivNode(parent=self.display, size=fieldSize)
self.field2 = avg.DivNode(parent=self.display, size=fieldSize, pos=(displayWidth - widthThird, 0))
avg.LineNode(parent=self.display, pos1=(0, 1), pos2=(displayWidth, 1))
avg.LineNode(parent=self.display, pos1=(0, displayHeight), pos2=(displayWidth, displayHeight))
self.lines.createImageNode('layer1', dict(parent=self.display, pos=(widthThird, 0)), (2, displayHeight))
self.lines.createImageNode('layer1', dict(parent=self.display, pos=(displayWidth - widthThird, 0)), (2, displayHeight))
# pybox2d setup
self.world = b2World(gravity=(0, 0), doSleep=True)
self.hitset = set()
self.listener = ContactListener(self.hitset)
self.world.contactListener = self.listener
self.running = True
pointsToWin = 999 if self.tutorialMode else config.pointsToWin
self.leftPlayer, self.rightPlayer = Player(self, self.field1, pointsToWin), Player(self, self.field2, pointsToWin)
self.leftPlayer.other, self.rightPlayer.other = self.rightPlayer, self.leftPlayer
# horizontal lines
BorderLine(self.world, a2w((0, 1)), a2w((displayWidth, 1)), 1, False, 'redball')
BorderLine(self.world, a2w((0, displayHeight)), a2w((displayWidth, displayHeight)), 1, False, 'redball')
# vertical ghost lines
maxWallHeight = brickSize * brickLines * PPM
BorderLine(self.world, a2w((maxWallHeight, 0)), a2w((maxWallHeight, displayHeight)), 1, False, 'redball', 'ball')
BorderLine(self.world, a2w((displayWidth - maxWallHeight - 1, 0)), a2w((displayWidth - maxWallHeight - 1, displayHeight)), 1, False, 'redball', 'ball')
self.middleX, self.middleY = self.display.size / 2
self.middle = a2w((self.middleX, self.middleY))
BatManager(self.field1, self.world, self.renderer)
BatManager(self.field2, self.world, self.renderer)
self.bonus = None
self.balls = []
self.redballs = []
self.towers = []
self.ghosts = []
self.mainLoop = g_player.setOnFrameHandler(self.step)
def createDiv(useXml):
if useXml:
node = player.createNode("""
<div>
<image href='rgb24-64x64.png'/>
</div>
""")
else:
node = avg.DivNode()
avg.ImageNode(href="rgb24-64x64.png", parent=node)
return node
def __init__(self,
map_model,
size,
parent,
map_provider,
country_list=None,
**kwargs):
"""
:param map_model: The model this view is based on.
:type map_model: MapModel
:param parent: The parent this view should be shown in.
:type parent: DivNode
:param geo_cord_border: Border for the data points of the map. (left, top, right, bottom)
:type geo_cord_border: tuple
"""
super(MapView, self).__init__(**kwargs)
self.registerInstance(self, parent)
EventDispatcher.__init__(self)
self.subscribe(avg.Node.KILLED, self.__on_self_killed)
self.__map_model = map_model
self.__map_model.start_listening(
points_changed=self.__on_points_changed)
self.__map_provider = map_provider
if isinstance(self.__map_provider, ImageMapProvider):
self.__map_provider.start_listening(
image_moved=self.__on_background_resized)
self.__geo_coord_mapper = GeoCoordMapper()
self.__size = size
self.__background_div = avg.DivNode(parent=self, size=size)
self.__point_div = avg.DivNode(parent=self)
self.__point_detail_div = avg.DivNode(parent=self)
self.__point_views = []
self.__country_list = [] if not country_list else country_list
self.update(country_list=country_list)
self.size = size
self.crop = True
def testOpacity(self):
root = self.loadEmptyScene()
avg.ImageNode(pos=(0,0), href="rgb24-65x65.png", opacity=0.5, parent=root)
avg.RectNode(pos=(0,64), size=(64,64), opacity=0.5, fillopacity=0.5,
fillcolor="FF0000", strokewidth=2, parent=root)
div = avg.DivNode(pos=(80,0), opacity=0.5, parent=root)
avg.ImageNode(pos=(0,0), href="rgb24-65x65.png", parent=div)
avg.RectNode(pos=(0,64), size=(64,64), opacity=1, fillopacity=1,
fillcolor="FF0000", strokewidth=2, parent=div)
self.start(False,
(lambda: self.compareImage("testOpacity"),
))
def addMesh():
div = avg.DivNode()
mesh = avg.MeshNode(
texhref="rgb24-64x64.png",
vertexcoords=((0,0), (64,0), (0,64), (64, 64),(32, 32)),
texcoords=((0,0),(1,0),(0,1),(1,1),(0.5,0.5)),
triangles=((0,1,4),(1,3,4),(3,2,4),(2,0,4)))
div.appendChild(mesh)
div.x = 50
div.y = 30
canvas.appendChild(div)
return mesh
def __init__(self, parent=None, **kwargs):
"""
:param parent: The parent that the pointer controller uses to show the pointer.
:type parent: DivNode
"""
super(PointerControl, self).__init__(**kwargs)
self.registerInstance(self, parent)
self._pointer_div = avg.DivNode(parent=self)
# dict: key -> device id values -> pointer
self._pointer = {}
def __init__(self, **kwargs):
"""
:param kwargs: Other parameters for the base.
"""
super(CursorAidLine, self).__init__(**kwargs)
size = self._aid_line_area[2] - self._aid_line_area[
0], self._aid_line_area[3] - self._aid_line_area[1]
self._recognition_div = avg.DivNode(parent=self._internal_div,
pos=(self._aid_line_area[0],
self._aid_line_area[1]),
size=size)
self._recognition_div.subscribe(avg.Node.CURSOR_OVER,
self._on_mouse_enter)
self._recognition_div.subscribe(avg.Node.CURSOR_OUT,
self._on_mouse_leave)
self._recognition_div.subscribe(avg.Node.CURSOR_MOTION,
self._on_mouse_move)
self._recognition_div.subscribe(avg.Node.CURSOR_UP, self._on_mouse_up)
self._vertical_aid_line = None
self._horizontal_aid_line = None
self._aid_line_movement_block = False
self.bind(
self.STEP_FORWARD_HORIZONTAL,
lambda steps=1, axis_index=0: self._on_step(direction=1,
steps=steps,
axis_index=axis_index,
horizontal=True,
vertical=False))
self.bind(
self.STEP_BACKWARD_HORIZONTAL,
lambda steps=1, axis_index=0: self._on_step(direction=-1,
steps=steps,
axis_index=axis_index,
horizontal=True,
vertical=False))
self.bind(
self.STEP_FORWARD_VERTICAL,
lambda steps=1, axis_index=0: self._on_step(direction=1,
steps=steps,
axis_index=axis_index,
horizontal=False,
vertical=True))
self.bind(
self.STEP_BACKWARD_VERTICAL,
lambda steps=1, axis_index=0: self._on_step(direction=-1,
steps=steps,
axis_index=axis_index,
horizontal=False,
vertical=True))
