class QNEMainWindow(QMainWindow):
def __init__(self, parent):
super(QNEMainWindow, self).__init__(parent)
quitAct = QAction("&Quit", self, shortcut="Ctrl+Q",
statusTip="Exit the application", triggered=self.close)
addAct = QAction("&Add", self, statusTip="Add a block", triggered=self.addBlock)
fileMenu = self.menuBar().addMenu("&File")
fileMenu.addAction(addAct)
fileMenu.addSeparator()
fileMenu.addAction(quitAct)
self.setWindowTitle("Node Editor")
self.scene = QGraphicsScene(self)
self.view = QGraphicsView(self)
self.view.setScene(self.scene)
self.view.setRenderHint(QPainter.Antialiasing)
self.setCentralWidget(self.view)
self.nodesEditor = QNodesEditor(self)
self.nodesEditor.install(self.scene)
block = QNEBlock(None)
self.scene.addItem(block)
block.addPort("test", 0, QNEPort.NamePort)
block.addPort("TestBlock", 0, QNEPort.TypePort)
block.addInputPort("in1");
block.addInputPort("in2");
block.addInputPort("in3");
block.addOutputPort("out1");
block.addOutputPort("out2");
block.addOutputPort("out3");
block = block.clone()
block.setPos(150,0)
block = block.clone()
block.setPos(150,150)
def addBlock(self):
import random
import math
block = QNEBlock(None)
self.scene.addItem(block)
names = ["Vin", "Voutsadfasdf", "Imin", "Imax", "mul", "add", "sub", "div", "Conv", "FFT"]
for i in range(0,math.floor(random.uniform(3,8))):
block.addPort(random.choice(names), random.random()>0.5)
block.setPos(self.view.sceneRect().center().toPoint())
def testIt(self):
scene = QGraphicsScene()
i1 = QGraphicsRectItem()
scene.addItem(i1)
i2 = QGraphicsRectItem(i1)
i3 = QGraphicsRectItem()
i4 = QGraphicsRectItem()
group = scene.createItemGroup((i2, i3, i4))
scene.removeItem(i1)
del i1 # this shouldn't delete i2
self.assertEqual(i2.scene(), scene)
scene.destroyItemGroup(group)
self.assertRaises(RuntimeError, group.type)
def testIt(self):
scene = QGraphicsScene()
i1 = QGraphicsRectItem()
scene.addItem(i1)
i2 = QGraphicsRectItem(i1)
i3 = QGraphicsRectItem()
i4 = QGraphicsRectItem()
group = scene.createItemGroup((i2, i3, i4))
scene.removeItem(i1)
del i1 # this shouldn't delete i2
self.assertEqual(i2.scene(), scene)
scene.destroyItemGroup(group)
self.assertRaises(RuntimeError, group.type)
def testCustomProxyWidget(self):
scene = QGraphicsScene()
proxy = CustomProxy(None, Qt.Window)
widget = QLabel('Widget')
proxy.setWidget(widget)
proxy.setCacheMode(QGraphicsItem.DeviceCoordinateCache)
scene.addItem(proxy)
scene.setSceneRect(scene.itemsBoundingRect())
view = QGraphicsView(scene)
view.setRenderHints(QPainter.Antialiasing|QPainter.SmoothPixmapTransform)
view.setViewportUpdateMode(QGraphicsView.BoundingRectViewportUpdate)
view.show()
timer = QTimer.singleShot(100, self.app.quit)
self.app.exec_()
def testQGraphicsProxyWidget(self):
scene = QGraphicsScene()
proxy = QGraphicsProxyWidget(None, Qt.Window)
widget = QLabel('Widget')
proxy.setWidget(widget)
proxy.setCacheMode(QGraphicsItem.DeviceCoordinateCache)
scene.addItem(proxy)
scene.setSceneRect(scene.itemsBoundingRect())
view = QGraphicsView(scene)
view.setRenderHints(QPainter.Antialiasing|QPainter.SmoothPixmapTransform)
view.setViewportUpdateMode(QGraphicsView.BoundingRectViewportUpdate)
view.show()
timer = QTimer.singleShot(100, self.app.quit)
self.app.exec_()
def update_frame(self, img):
'''
update the image
:return:
'''
#if not self.queue.empty():
# frame = self.queue.get()
#img = frame['img']
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
size = self.video_view.size()
img = cv2.resize(img, (size.width() - 10, size.height() - 10))
height, width, bpc = img.shape
bpl = bpc * width
image = QImage(img.data, width, height, bpl, QImage.Format_RGB888)
pitem = QGraphicsPixmapItem(QPixmap.fromImage(image))
scene = QGraphicsScene()
scene.addItem(pitem)
self.video_view.setScene(scene)
class timelineTest(object):
'''
Main Class
'''
def __init__(self):
self.app = QApplication.instance()
if self.app is None:
self.app = QApplication(sys.argv)
loader = QUiLoader()
self.mainWindow = loader.load("timelineTest.ui")
self.scene = QGraphicsScene()
self.mainWindow.graphicsView.setScene(self.scene)
track = timelineTrack()
self.addTrack(track)
self.readEDL(track, 'sample.edl')
self.mainWindow.show()
self.app.exec_()
def readEDL(self, track, edlfile):
edlFile = open(edlfile)
for line in edlFile.readlines():
match = re.match(
r"(\d{3})\s+\w+\s+\w+\s+\w+\s+(\d{2}:\d{2}:\d{2}:\d{2}) (\d{2}:\d{2}:\d{2}:\d{2}) (\d{2}:\d{2}:\d{2}:\d{2}) (\d{2}:\d{2}:\d{2}:\d{2})",
line)
if match is not None:
editStart = tc2frames(match.group(2), 24)
editEnd = tc2frames(match.group(3), 24)
editLength = editStart - editEnd
track.addClip(editStart, editLength)
edlFile.close()
def addTrack(self, track):
'''
Add track to timeline
'''
self.scene.addItem(track)
"""
class ItemRetrieve(UsesQApplication):
'''Tests for QGraphicsScene item retrieval methods'''
qapplication = True
def setUp(self):
#Acquire resources
super(ItemRetrieve, self).setUp()
self.scene = QGraphicsScene()
self.topleft = QGraphicsRectItem(0, 0, 100, 100)
self.topright = QGraphicsRectItem(100, 0, 100, 100)
self.bottomleft = QGraphicsRectItem(0, 100, 100, 100)
self.bottomright = QGraphicsRectItem(100, 100, 100, 100)
self.items = [
self.topleft, self.topright, self.bottomleft, self.bottomright
]
for item in self.items:
self.scene.addItem(item)
def tearDown(self):
#Release resources
del self.scene
super(ItemRetrieve, self).tearDown()
def testItems(self):
#QGraphicsScene.items()
items = self.scene.items()
for i in items:
self.assertTrue(i in self.items)
def testItemAt(self):
#QGraphicsScene.itemAt()
self.assertEqual(self.scene.itemAt(50, 50), self.topleft)
self.assertEqual(self.scene.itemAt(150, 50), self.topright)
self.assertEqual(self.scene.itemAt(50, 150), self.bottomleft)
self.assertEqual(self.scene.itemAt(150, 150), self.bottomright)
class ItemRetrieve(UsesQApplication):
"""Tests for QGraphicsScene item retrieval methods"""
qapplication = True
def setUp(self):
# Acquire resources
super(ItemRetrieve, self).setUp()
self.scene = QGraphicsScene()
self.topleft = QGraphicsRectItem(0, 0, 100, 100)
self.topright = QGraphicsRectItem(100, 0, 100, 100)
self.bottomleft = QGraphicsRectItem(0, 100, 100, 100)
self.bottomright = QGraphicsRectItem(100, 100, 100, 100)
self.items = [self.topleft, self.topright, self.bottomleft, self.bottomright]
for item in self.items:
self.scene.addItem(item)
def tearDown(self):
# Release resources
del self.scene
super(ItemRetrieve, self).tearDown()
def testItems(self):
# QGraphicsScene.items()
items = self.scene.items()
for i in items:
self.assertTrue(i in self.items)
def testItemAt(self):
# QGraphicsScene.itemAt()
self.assertEqual(self.scene.itemAt(50, 50), self.topleft)
self.assertEqual(self.scene.itemAt(150, 50), self.topright)
self.assertEqual(self.scene.itemAt(50, 150), self.bottomleft)
self.assertEqual(self.scene.itemAt(150, 150), self.bottomright)
class QNEMainWindow(QMainWindow):
def __init__(self, parent):
super(QNEMainWindow, self).__init__(parent)
quitAct = QAction("&Quit",
self,
shortcut="Ctrl+Q",
statusTip="Exit the application",
triggered=self.close)
addAct = QAction("&Add",
self,
statusTip="Add a block",
triggered=self.addBlock)
fileMenu = self.menuBar().addMenu("&File")
fileMenu.addAction(addAct)
fileMenu.addSeparator()
fileMenu.addAction(quitAct)
self.setWindowTitle("Node Editor")
self.scene = QGraphicsScene(self)
self.view = QGraphicsView(self)
self.view.setScene(self.scene)
self.view.setRenderHint(QPainter.Antialiasing)
self.setCentralWidget(self.view)
self.nodesEditor = QNodesEditor(self)
self.nodesEditor.install(self.scene)
block = QNEBlock(None)
self.scene.addItem(block)
block.addPort("test", 0, QNEPort.NamePort)
block.addPort("TestBlock", 0, QNEPort.TypePort)
block.addInputPort("in1")
block.addInputPort("in2")
block.addInputPort("in3")
block.addOutputPort("out1")
block.addOutputPort("out2")
block.addOutputPort("out3")
block = block.clone()
block.setPos(150, 0)
block = block.clone()
block.setPos(150, 150)
def addBlock(self):
import random
import math
block = QNEBlock(None)
self.scene.addItem(block)
names = [
"Vin", "Voutsadfasdf", "Imin", "Imax", "mul", "add", "sub", "div",
"Conv", "FFT"
]
for i in range(0, math.floor(random.uniform(3, 8))):
block.addPort(random.choice(names), random.random() > 0.5)
block.setPos(self.view.sceneRect().center().toPoint())
def redraw(self,
base_time,
all_tars,
employee_id,
additional_work_timetracks,
additional_presence_timetracks,
special_activities=None,
view_title=""):
scene = QGraphicsScene()
# This scene line is a hack to make sure I can control the "centerOn"
# execution as I wish. This is very hackish.
margin = 30
scene.addLine(
QLineF(0, 0,
self.width() - margin,
self.height() - margin), QPen(Qt.white))
# Dat is heeeel belangerijk om de goede computation te doen
all_tars = sorted(all_tars, key=lambda tar: tar.time)
# chrono.chrono_click("Redraw step 1")
timetracks_tars = dao.task_action_report_dao.compute_activity_timetracks_from_task_action_reports(
all_tars, employee_id)
# We got (timetrack, reports) tuples
timetracks = [tt[0] for tt in timetracks_tars]
# presence_time, off_time, presence_timetracks = dao.task_action_report_dao.recompute_presence_on_tars(employee_id, all_tars)
# chrono.chrono_click("Redraw step 2")
presence_intervals = dao.task_action_report_dao.compute_man_presence_periods(
employee_id, base_time, all_tars, timetracks=[], commit=True)
# chrono.chrono_click("Redraw step 2B")
presence_timetracks = dao.task_action_report_dao.convert_intervals_to_presence_timetracks(
presence_intervals, employee_id)
# chrono.chrono_click("Redraw step 3")
# FIXME this will trigger a session open... Must use the ID without a query first!
presence_task_id = dao.task_action_report_dao.presence_task_id_regular_time(
)
# chrono.chrono_click("redraw")
# mainlog.debug("About to draw ...")
# mainlog.debug("additional presence is")
# for tt in additional_presence_timetracks:
# mainlog.debug(tt)
# mainlog.debug("all_tars")
# mainlog.debug(all_tars)
# mainlog.debug("Timetracks...")
# mainlog.debug(timetracks_tars)
# mainlog.debug("Presenec Timetracks...")
# mainlog.debug(presence_timetracks)
if presence_timetracks == [] and additional_presence_timetracks:
presence_timetracks += additional_presence_timetracks
timetracks += additional_work_timetracks
# mainlog.debug("Augmented Timetracks...")
# mainlog.debug(timetracks)
# mainlog.debug("Augmented Presence Timetracks...")
# for tt in presence_timetracks:
# mainlog.debug(tt)
y = 0
dy = 60
# Title of the view
if view_title:
description = QGraphicsSimpleTextItem()
description.setText(view_title)
description.setFont(self.title_font)
br = QRect(0, 0,
description.boundingRect().width(),
description.boundingRect().height())
description.setPos(0, 0) # y - br.height()/2)
scene.addItem(description)
y += max(br.height() * 2, dy)
# Presence timeline
pointages = []
for tar in all_tars:
# mainlog.debug(tar)
# mainlog.debug(tar.kind == TaskActionReportType.presence)
if tar.kind == TaskActionReportType.presence:
pointages.append((tar.time, Timeline.NO_DIR, tar,
self._hoover_text_for(tar)))
elif tar.kind in (TaskActionReportType.day_in,
TaskActionReportType.start_task):
pointages.append((tar.time, Timeline.START, tar,
self._hoover_text_for(tar)))
elif tar.kind in (TaskActionReportType.day_out,
TaskActionReportType.stop_task):
pointages.append(
(tar.time, Timeline.END, tar, self._hoover_text_for(tar)))
else:
raise Exception("Unsupported TAR.kind. I get {}".format(
tar.kind))
periods = []
for tt in presence_timetracks:
periods.append(
(tt.start_time, tt.start_time + timedelta(tt.duration / 24.0),
None))
# Show the presence timeline
pointages_for_presence = [
p for p in pointages
if p[2].kind not in (TaskActionReportType.start_task,
TaskActionReportType.stop_task)
]
if pointages_for_presence:
tl = Timeline(base_time, pointages_for_presence, periods, None,
_("Presence"),
QColor(Qt.green).darker(150))
tl.draw(scene, y)
y += dy
# Special activities time line
if special_activities:
periods = []
for sa in special_activities:
desc = None
if sa.activity_type:
desc = sa.activity_type.description
periods.append((sa.start_time, sa.end_time, desc))
tl = Timeline(base_time, None, periods, None, _("Absence"),
QColor(Qt.red).darker(150))
tl.draw(scene, y)
y += dy
# Group task action reports according to their task
task_tar = dict()
for tar in all_tars:
task_id = tar.task_id
if task_id and task_id != presence_task_id:
if not task_id in task_tar:
task_tar[task_id] = []
if tar.kind == TaskActionReportType.start_task:
task_tar[task_id].append((tar.time, Timeline.START, tar,
self._hoover_text_for(tar)))
elif tar.kind == TaskActionReportType.stop_task:
task_tar[task_id].append((tar.time, Timeline.END, tar,
self._hoover_text_for(tar)))
# Group timetracks according to their task
task_to_timetracks = dict()
for timetrack in timetracks:
task_id = timetrack.task_id
if task_id and task_id != presence_task_id:
if not task_id in task_to_timetracks:
task_to_timetracks[task_id] = []
task_to_timetracks[task_id].append(timetrack)
# Figure out all the tasks (because each task gives a timeline)
# It is quite possible that some timetracks are not associated
# to any TAR and vice versa.
all_tasks = set()
for t in timetracks:
if t.task_id:
all_tasks.add(t.task_id)
for t in all_tars:
if t.task_id:
all_tasks.add(t.task_id)
all_tasks = dao.task_dao.find_by_ids_frozen(all_tasks)
# map(lambda t:t.task and all_tasks.add(t.task),timetracks)
# map(lambda t:t.task and all_tasks.add(t.task),all_tars)
# The presence stuff was drawn on a separate timeline => we won't draw
# it here again.
# Remove presence task (because it's already drawn).
# FIXME I use the ID because of session handling
all_tasks = list(
filter(lambda t: t.task_id != presence_task_id, all_tasks))
for task in list(sorted(all_tasks, key=lambda a: a.description)):
# Not all TAR have a timetrack !
periods = []
if task.task_id in task_to_timetracks:
for tt in task_to_timetracks[task.task_id]:
periods.append(
(tt.start_time,
tt.start_time + timedelta(tt.duration / 24.0), None))
tars = []
if task.task_id in task_tar:
tars = task_tar[task.task_id]
timeline_title = task.description
# timeline_title = self._make_time_line_title(task) # This will provide nice and complete bar titles
if task.type == TaskOnOperation:
tl = Timeline(base_time, tars, periods, task, timeline_title,
Qt.blue)
else:
tl = Timeline(base_time, tars, periods, task, timeline_title,
Qt.red)
tl.draw(scene, y)
y += dy
self.setScene(scene)
# See the hack top of this method !
self.centerOn(-(self.width() - margin) / 2,
(self.height() - margin) / 2)
class WorldViewer(QWidget):
def __init__(self, charname='', currentzone='', parent=None):
super(WorldViewer, self).__init__(parent)
self.setWindowTitle("World Viewer")
if not DEBUG:
self.setWindowState(Qt.WindowMaximized)
self.move(0,0)
self.grabKeyboard()
self.keyspressed = set()
self.currentzone = currentzone
self.charname = charname
self.scene = QGraphicsScene()
self.view = QGraphicsView(self.scene)
self.view.scale(5, 5)
self.view.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.view.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
# pb = QPushButton("Push!")
# stylesheet = '''
# QPushButton {
# border: 2px solid #8f8f91;
# border-radius: 6px;
# background-color: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1,
# stop: 0 #f6f7fa, stop: 1 #dadbde);
# min-width: 80px;
# }
#
# QPushButton:pressed {
# background-color: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1,
# stop: 0 #dadbde, stop: 1 #f6f7fa);
# }
#
# QPushButton:flat {
# border: none; /* no border for a flat push button */
# }
# QPushButton:default {
# border-color: navy; /* make the default button prominent */
# }
# '''
# pb.setStyleSheet(stylesheet)
# self.scene.addWidget(pb)
layout = QVBoxLayout()
for w in (self.view, ):
layout.addWidget(w)
self.setLayout(layout)
self.loading = self.scene.addText("Loading...")
self.loading.setHtml("<h1>Loading...</h1>")
self.last_update = datetime.datetime.now()
self.world_objects = {}
self.world_object_widgets = {}
self._update_objects(client.get_all_objects(self.currentzone))
print self.world_objects
# Set character status to online.
client.set_status(self.currentzone, self.charname)
self.loading.hide()
# Set a repeating callback on a timer to get object updates
self.obj_update_timer = QTimer(self)
self.connect(self.obj_update_timer, SIGNAL("timeout()"), self.update_objects)
self.obj_update_timer.start(CLIENT_UPDATE_FREQ)
# Set a repeating callback on a timer to send movement packets.
self.movement_timer = QTimer(self)
self.connect(self.movement_timer, SIGNAL("timeout()"), self.send_movement)
self.movement_timer.start(CLIENT_UPDATE_FREQ)
def sizeHint(self):
desktop = QApplication.instance().desktop()
geom = desktop.availableGeometry()
return QSize(geom.width()/2, geom.height()/2)
def keyPressEvent(self, event):
'''Qt's key handling is wierd. If a key gets "stuck", just press and release it again.'''
# Ignore autorepeat events.
if event.isAutoRepeat():
event.ignore()
return
# Add all other events to our set of pressed keys.
self.keyspressed.add(event.key())
event.accept()
def keyReleaseEvent(self, event):
# Ignore autorepeat events.
if event.isAutoRepeat():
event.ignore()
return
# Remove all other events from our set of pressed keys.
self.keyspressed.discard(event.key())
event.accept()
def send_movement(self):
'''Send movement calls to the zone/movement server.'''
x = 0
y = 0
def _in_set(x, *args):
for a in args:
if int(a) in x:
return True
return False
if _in_set(self.keyspressed, Qt.Key_Left, Qt.Key_A):
x -= 1
if _in_set(self.keyspressed, Qt.Key_Right, Qt.Key_D):
x += 1
if _in_set(self.keyspressed, Qt.Key_Up, Qt.Key_W):
y -= 1
if _in_set(self.keyspressed, Qt.Key_Down, Qt.Key_S):
y += 1
client.send_movement(self.currentzone, self.charname, x, y, 0)
def _update_objects(self, objectslist):
if len(objectslist) != 0:
print "Updated %d objects." % len(objectslist)
for obj in objectslist:
# Filter out any hidden objects
if "hidden" in obj.get('states'):
continue
obj_id = obj['_id']['$oid']
self.world_objects.update({obj_id: obj})
if obj_id not in self.world_object_widgets:
# Create a new widget, add it to the view and to world_object_widgets
objwidget = WorldObject(obj)
self.world_object_widgets.update({obj_id: objwidget})
self.scene.addItem(objwidget)
else:
objwidget = self.world_object_widgets[obj_id]
objwidget.setOffset(obj['loc']['x'], obj['loc']['y'])
# Update our view if the name is the same as our character.
if obj['name'] == self.charname:
self.view.centerOn(objwidget)
self.view.ensureVisible(objwidget)
def update_objects(self):
'''Gets an upated list of objects from the zone and stores them locally.'''
new_objects = client.get_objects_since(self.last_update, self.currentzone)
self._update_objects(new_objects)
self.last_update = datetime.datetime.now()
class SceneManager():
def __init__(self, graphicsView):
self.scene = QGraphicsScene()
self.scene.setSceneRect(0,0,SCENE_WIDTH,SCENE_HEIGHT)
graphicsView.setScene(self.scene)
# handles physics involved in collisiions/detection
self.cm = collisionManager()
# add object to simulation scene (given parameters)
# input: 'values' contains (x,y,x_vel,y_vel,mass,radius)
def addItem(self,param):
values = self.decode(param)
item = Ball(values[0],values[1],values[4],values[5])
item.set_velocity(values[2],values[3])
self.scene.addItem(item)
def addItems(self,items):
for item in items:
values = self.decode(item)
ball_obj = Ball(values[0],values[1],values[4],values[5])
ball_obj.set_velocity(values[2],values[3])
self.scene.addItem(ball_obj)
# translate parameters received by TCP
def decode(self,msg):
delims = ['r','m','yv','xv','y','x']
values = []
# traverses delimeters to extract values
for i in range(len(delims)):
index = msg.index(delims[i]) # search for delimeter
arg = msg[index + len(delims[i]) :] # extract value
values.append(int(float(arg))) # store value
msg = msg[:index] # reduce message left to parse
values.reverse()
return values
# access all items in the simulation scene
def getItems(self):
return self.scene.items()
def deleteItems(self):
return self.scene.clear()
def getItemsForTCP(self):
items = self.scene.items()
tcp_list = []
for item in items:
tcp_list.append(str(item))
return tcp_list
# determine an item's next location
def next_move(self,item):
# check whether any ball-to-ball collisions will occur
collisions = self.cm.if_ball_collision(item,self.getItems())
if (len(collisions) > 0): # colllision identified
# print '\nInside next_move()'
# print ('Item: ' + str(item) + ' List: ' )#+ str(collisions))
# for ball in collisions:
# print str(ball) #DEBUG
# obtain velocities so that balls just collide
delta_x, delta_y = self.cm.vel_to_ball(item,collisions[0])
# delta_x = item.x_vel
# delta_y = item.y_vel
self.cm.ball_to_ball(item,collisions[0])
else:
# determine if a wall will be hit in the next move
hit_wall = self.cm.if_wall_collision(item,SCENE_HEIGHT,SCENE_WIDTH)
if (hit_wall != 'NONE'): # if wall collision will occur
# determine displacement left to collide with wall
delta_x, delta_y = self.cm.vel_to_wall(item,hit_wall,SCENE_HEIGHT,SCENE_WIDTH)
# set object's velocity after impacting the wall
self.cm.ball_to_wall(item,hit_wall)
else:
#keep the ball in the same trajectory
delta_x = item.x_vel
delta_y = item.y_vel
# next x/y destination of the item in LOCAL coordinates
# require the offsets (-item.x_start and -item.y_start)
# given the fact that the item.x_pos and item.y_pos values
# represent locations in global coordinates
next_x = item.x_pos + delta_x - item.x_start
next_y = item.y_pos + delta_y - item.y_start
return next_x,next_y
class QNEMainWindow(QMainWindow):
def __init__(self, parent):
super(QNEMainWindow, self).__init__(parent)
self.logger = logging.getLogger("zne")
self.logger.setLevel(logging.DEBUG)
self.setMinimumSize(560,360)
self.setWindowTitle("ZOCP Node Editor")
self.setWindowIcon(QIcon('assets/icon.png'))
self.scene = QGraphicsScene(self)
self.view = QGraphicsView(self)
self.view.setScene(self.scene)
self.setCentralWidget(self.view)
self.nodesEditor = QNodesEditor(self, self.scene, self.view)
self.nodesEditor.onAddConnection = self.onAddConnection
self.nodesEditor.onRemoveConnection = self.onRemoveConnection
self.nodesEditor.onBlockMoved = self.onBlockMoved
self.scale = 1
self.installActions()
self.initZOCP()
self.nodes = {}
self.pendingSubscribers = {}
QTimer.singleShot(250, lambda: self.scene.invalidate())
def closeEvent(self, *args):
self.zocp.stop()
def installActions(self):
quitAct = QAction("&Quit", self, shortcut="Ctrl+Q",
statusTip="Exit the application", triggered=self.close)
if zconfigmanager_found:
openAct = QAction("&Open...", self, shortcut="Ctrl+O",
statusTip="Restore the network from a saved description", triggered=self.readNetwork)
saveAct = QAction("&Save...", self, shortcut="Ctrl+S",
statusTip="Write a description of the network to disc", triggered=self.writeNetwork)
fileMenu = self.menuBar().addMenu("&File")
if zconfigmanager_found:
fileMenu.addAction(openAct)
fileMenu.addAction(saveAct)
fileMenu.addSeparator()
fileMenu.addAction(quitAct)
# for shortcuts
self.view.addAction(quitAct)
selectAllAct = QAction("Select &All", self, shortcut="Ctrl+A",
triggered=self.nodesEditor.selectAll)
selectNoneAct = QAction("Select &None", self, shortcut="Ctrl+D",
triggered=self.nodesEditor.selectNone)
selectInverseAct = QAction("Select &Inverse", self, shortcut="Ctrl+I",
triggered=self.nodesEditor.selectInverse)
deleteSelectedAct = QAction("&Delete Selected", self, shortcut="Del",
triggered=self.nodesEditor.deleteSelected)
editMenu = self.menuBar().addMenu("&Edit")
editMenu.addAction(selectAllAct)
editMenu.addAction(selectNoneAct)
editMenu.addAction(selectInverseAct)
editMenu.addSeparator()
editMenu.addAction(deleteSelectedAct)
self.view.addAction(selectAllAct)
self.view.addAction(selectNoneAct)
self.view.addAction(selectInverseAct)
self.view.addAction(deleteSelectedAct)
zoomInAct = QAction("Zoom &In", self, shortcut="Ctrl++",
triggered=self.zoomIn)
zoomOutAct = QAction("Zoom &Out", self, shortcut="Ctrl+-",
triggered=self.zoomOut)
zoomResetAct = QAction("&Reset Zoom", self, shortcut="Ctrl+0",
triggered=self.zoomReset)
viewMenu = self.menuBar().addMenu("&View")
viewMenu.addAction(zoomInAct)
viewMenu.addAction(zoomOutAct)
viewMenu.addSeparator()
viewMenu.addAction(zoomResetAct)
self.view.addAction(zoomInAct)
self.view.addAction(zoomOutAct)
self.view.addAction(zoomResetAct)
aboutAct = QAction("&About", self,
triggered=self.about)
helpMenu = self.menuBar().addMenu("&Help")
helpMenu.addAction(aboutAct)
self.view.addAction(aboutAct)
def writeNetwork(self):
fileName, filter = QFileDialog.getSaveFileName(self,
caption="Save as",
filter="ZOCP (*.zocp);;JSON (*.json)",
selectedFilter="ZOCP (*.zocp)")
if fileName:
# setup ZOCP node, and run it for some time to discover
# the current network
configManager = ZConfigManagerNode("ConfigManager@%s" % socket.gethostname())
configManager.discover(0.5)
# write network description to file
configManager.write(fileName)
# shut down ZOCP node
configManager.stop()
configManager = None
def readNetwork(self):
fileName, filter = QFileDialog.getOpenFileName(self,
caption="Open",
filter="All files (*.*);;ZOCP (*.zocp);;JSON (*.json)",
selectedFilter="ZOCP (*.zocp)")
if fileName:
# setup ZOCP node, and run it for some time to discover
# the current network
configManager = ZConfigManagerNode("ConfigManager@%s" % socket.gethostname())
configManager.discover(0.5)
# write network description to file
configManager.read(fileName)
# shut down ZOCP node
configManager.stop()
configManager = None
def zoomIn(self):
if self.scale < 4:
self.scale *= 1.2
self.view.scale(1.2, 1.2)
def zoomOut(self):
if self.scale > 0.1:
self.scale /= 1.2
self.view.scale(1/1.2, 1/1.2)
def zoomReset(self):
self.scale = 1
self.view.setTransform(QTransform())
def about(self):
QMessageBox.about(self, "About ZOCP Node Editor",
"<p>A monitor/editor for ZOCP nodes, implemented in PySide"
"(Python/Qt4).</p><p>ZOCP is the Z25 Orchestration Control "
"Protocol, currently in development at "
"<a href='http://z25.org'>z25.org</a></p>")
#########################################
# Node editor callbacks
#########################################
def onAddConnection(self, connection, fromPort, toPort):
fromBlock = fromPort.block()
toBlock = toPort.block()
emitter = fromPort.portName()
emit_peer = fromBlock.uuid()
receiver = toPort.portName()
recv_peer = toBlock.uuid()
self.zocp.signal_subscribe(recv_peer, receiver, emit_peer, emitter)
self.logger.debug("added subscription from %s on %s to %s on %s" %
(receiver, fromBlock.name(), emitter, toBlock.name()))
def onRemoveConnection(self, connection, fromPort, toPort):
fromBlock = fromPort.block()
toBlock = toPort.block()
emitter = fromPort.portName()
emit_peer = fromBlock.uuid()
receiver = toPort.portName()
recv_peer = toBlock.uuid()
self.zocp.signal_unsubscribe(recv_peer, receiver, emit_peer, emitter)
self.logger.debug("removed subscription from %s on %s to %s on %s" %
(receiver, fromBlock.name(), emitter, toBlock.name()))
def onBlockMoved(self, block):
pos = block.pos()
peer = block.uuid()
self.zocp.peer_set(peer, {"_zne_position": [pos.x(), pos.y()]})
def onChangeValue(self, block, port, value):
self.logger.debug("block %s port %s changed to %s" % (block.name(), port.portName(), value))
peer = block.uuid()
portName = port.portName()
capability = self.zocp.peers_capabilities[peer][portName]
typeHint = capability["typeHint"]
validValue = True
if typeHint == "int":
try:
value = int(float(value))
except:
validValue = False
elif typeHint == "flt":
try:
value = float(value.strip())
except:
validValue = False
elif typeHint == "percent":
try:
value = float(value.strip())
except:
validValue = False
elif typeHint == "bool":
value = (value.strip().lower() in ["true", "yes", "1"])
elif typeHint == "string":
pass
elif typeHint.startswith("vec" ) and typeHint.endswith("f") and len(typeHint) == 5:
try:
value = [float(num) for num in ((value.strip())[1:-1]).split(",")]
except:
validValue = False
if validValue:
if len(value) != int(typeHint[3]):
validValue = False
if validValue:
self.zocp.peer_set(peer, {portName: {"value": value}})
port.setValue(str(value))
else:
port.setValue(str(capability["value"]))
#########################################
# ZOCP implementation
#########################################
def initZOCP(self):
self.zocp = ZOCP("ZOCP Node Editor@%s" % socket.gethostname())
self.notifier = QSocketNotifier(
self.zocp.inbox.getsockopt(zmq.FD),
QSocketNotifier.Read)
self.notifier.setEnabled(True)
self.notifier.activated.connect(self.onZOCPEvent)
self.zocp.on_peer_enter = self.onPeerEnter
self.zocp.on_peer_exit = self.onPeerExit
self.zocp.on_peer_modified = self.onPeerModified
self.zocp.on_peer_signaled = self.onPeerSignaled
self.zocp.start()
zl = logging.getLogger("zocp")
zl.setLevel(logging.INFO)
def onZOCPEvent(self):
self.zocp.run_once(0)
def onPeerEnter(self, peer, name, *args, **kwargs):
# Subscribe to any and all value changes
self.zocp.signal_subscribe(self.zocp.uuid(), None, peer, None)
# Add named block; ports are not known at this point
block = QNEBlock(None)
self.scene.addItem(block)
block.setNodeEditor(self)
block.setName(name)
block.setUuid(peer)
block.addPort(name, False, False, QNEPort.NamePort)
block.setVisible(False)
node = {}
node["block"] = block
node["ports"] = dict()
self.nodes[peer.hex] = node
def onPeerExit(self, peer, name, *args, **kwargs):
# Unsubscribe from value changes
self.zocp.signal_unsubscribe(self.zocp.uuid(), None, peer, None)
# Remove block
if peer.hex in self.nodes:
self.nodes[peer.hex]["block"].delete()
self.nodes.pop(peer.hex)
def onPeerModified(self, peer, name, data, *args, **kwargs):
for portname in data:
portdata = data[portname]
if portname not in self.nodes[peer.hex]["ports"]:
if "access" in portdata:
hasInput = "s" in portdata["access"]
hasOutput = "e" in portdata["access"]
port = self.nodes[peer.hex]["block"].addPort(portname, hasInput, hasOutput)
port.setValue(str(portdata["value"]))
port.setAccess(str(portdata["access"]))
self.nodes[peer.hex]["ports"][portname] = port
else:
# Metadata, not a capability
if portname == "_zne_position":
block = self.nodes[peer.hex]["block"]
block.setPos(portdata[0], portdata[1])
else:
port = self.nodes[peer.hex]["ports"][portname]
if "value" in portdata:
port.setValue(str(portdata["value"]))
if "access" in portdata:
port.setAccess(str(portdata["access"]))
if "subscribers" in portdata:
self.updateSubscribers(port, portdata["subscribers"])
if len(self.nodes[peer.hex]["ports"]) > 0:
self.nodes[peer.hex]["block"].setVisible(True)
self.updatePendingSubscribers(peer)
def onPeerSignaled(self, peer, name, data, *args, **kwargs):
[portname, value] = data
if portname in self.nodes[peer.hex]["ports"]:
self.nodes[peer.hex]["ports"][portname].setValue(str(value))
def updateSubscribers(self, port, subscribers):
port1 = port.outputPort
# check if any current connections should be removed
connections = port.connections()
for connection in connections:
if(connection.port1() == port1):
port2 = connection.port2()
else:
port2 = connection.port1()
if not port2.isOutput():
subscriber = [port2.block().uuid().hex, port2.portName()]
if subscriber not in subscribers:
connection.delete()
self.logger.debug("peer removed subscription from %s on %s to %s on %s" %
(port1.portName(), port1.block().name(), port2.portName(), port2.block().name()))
# add new connections for new subscriptions
for subscriber in subscribers:
[uuid, portname] = subscriber
if uuid in self.nodes:
node = self.nodes[uuid]
if portname in node["ports"]:
port2 = node["ports"][portname]
if not port2.isConnected(port1):
# create new connection
connection = QNEConnection(None)
connection.setPort1(port1)
connection.setPort2(port2)
connection.updatePosFromPorts()
connection.updatePath()
self.scene.addItem(connection)
self.logger.debug("peer added subscription from %s on %s to %s on %s" %
(port1.portName(), port1.block().name(), port2.portName(), port2.block().name()))
continue
# if the connection could not be made yet, add it to a list of
# pending subscriber-connections
if uuid not in self.pendingSubscribers:
self.pendingSubscribers[uuid] = []
self.pendingSubscribers[uuid].append([port1, portname])
def updatePendingSubscribers(self, peer):
if peer.hex in self.pendingSubscribers:
for subscriber in self.pendingSubscribers[peer.hex]:
[port1, portname] = subscriber
if peer.hex in self.nodes and portname in self.nodes[peer.hex]["ports"]:
port2 = self.nodes[peer.hex]["ports"][portname]
connection = QNEConnection(None)
connection.setPort1(port1)
connection.setPort2(port2)
connection.updatePosFromPorts()
connection.updatePath()
self.scene.addItem(connection)
else:
# TODO: handle case where port is still not available
pass
self.pendingSubscribers.pop(peer.hex)
class WorldViewer(QWidget):
def __init__(self, charname='', currentzone='', parent=None):
super(WorldViewer, self).__init__(parent)
self.setWindowTitle("World Viewer")
if not DEBUG:
self.setWindowState(Qt.WindowMaximized)
self.move(0, 0)
self.grabKeyboard()
self.keyspressed = set()
self.currentzone = currentzone
self.charname = charname
self.scene = QGraphicsScene()
self.view = QGraphicsView(self.scene)
self.view.scale(5, 5)
self.view.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.view.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
# pb = QPushButton("Push!")
# stylesheet = '''
# QPushButton {
# border: 2px solid #8f8f91;
# border-radius: 6px;
# background-color: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1,
# stop: 0 #f6f7fa, stop: 1 #dadbde);
# min-width: 80px;
# }
#
# QPushButton:pressed {
# background-color: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1,
# stop: 0 #dadbde, stop: 1 #f6f7fa);
# }
#
# QPushButton:flat {
# border: none; /* no border for a flat push button */
# }
# QPushButton:default {
# border-color: navy; /* make the default button prominent */
# }
# '''
# pb.setStyleSheet(stylesheet)
# self.scene.addWidget(pb)
layout = QVBoxLayout()
for w in (self.view, ):
layout.addWidget(w)
self.setLayout(layout)
self.loading = self.scene.addText("Loading...")
self.loading.setHtml("<h1>Loading...</h1>")
self.last_update = datetime.datetime.now()
self.world_objects = {}
self.world_object_widgets = {}
self._update_objects(client.get_all_objects(self.currentzone))
print self.world_objects
# Set character status to online.
client.set_status(self.currentzone, self.charname)
self.loading.hide()
# Set a repeating callback on a timer to get object updates
self.obj_update_timer = QTimer(self)
self.connect(self.obj_update_timer, SIGNAL("timeout()"),
self.update_objects)
self.obj_update_timer.start(CLIENT_UPDATE_FREQ)
# Set a repeating callback on a timer to send movement packets.
self.movement_timer = QTimer(self)
self.connect(self.movement_timer, SIGNAL("timeout()"),
self.send_movement)
self.movement_timer.start(CLIENT_UPDATE_FREQ)
def sizeHint(self):
desktop = QApplication.instance().desktop()
geom = desktop.availableGeometry()
return QSize(geom.width() / 2, geom.height() / 2)
def keyPressEvent(self, event):
'''Qt's key handling is wierd. If a key gets "stuck", just press and release it again.'''
# Ignore autorepeat events.
if event.isAutoRepeat():
event.ignore()
return
# Add all other events to our set of pressed keys.
self.keyspressed.add(event.key())
event.accept()
def keyReleaseEvent(self, event):
# Ignore autorepeat events.
if event.isAutoRepeat():
event.ignore()
return
# Remove all other events from our set of pressed keys.
self.keyspressed.discard(event.key())
event.accept()
def send_movement(self):
'''Send movement calls to the zone/movement server.'''
x = 0
y = 0
def _in_set(x, *args):
for a in args:
if int(a) in x:
return True
return False
if _in_set(self.keyspressed, Qt.Key_Left, Qt.Key_A):
x -= 1
if _in_set(self.keyspressed, Qt.Key_Right, Qt.Key_D):
x += 1
if _in_set(self.keyspressed, Qt.Key_Up, Qt.Key_W):
y -= 1
if _in_set(self.keyspressed, Qt.Key_Down, Qt.Key_S):
y += 1
client.send_movement(self.currentzone, self.charname, x, y, 0)
def _update_objects(self, objectslist):
if len(objectslist) != 0:
print "Updated %d objects." % len(objectslist)
for obj in objectslist:
# Filter out any hidden objects
if "hidden" in obj.get('states'):
continue
obj_id = obj['_id']['$oid']
self.world_objects.update({obj_id: obj})
if obj_id not in self.world_object_widgets:
# Create a new widget, add it to the view and to world_object_widgets
objwidget = WorldObject(obj)
self.world_object_widgets.update({obj_id: objwidget})
self.scene.addItem(objwidget)
else:
objwidget = self.world_object_widgets[obj_id]
objwidget.setOffset(obj['loc']['x'], obj['loc']['y'])
# Update our view if the name is the same as our character.
if obj['name'] == self.charname:
self.view.centerOn(objwidget)
self.view.ensureVisible(objwidget)
def update_objects(self):
'''Gets an upated list of objects from the zone and stores them locally.'''
new_objects = client.get_objects_since(self.last_update,
self.currentzone)
self._update_objects(new_objects)
self.last_update = datetime.datetime.now()
if __name__ == '__main__':
app = QApplication(sys.argv)
app.setApplicationName("tete")
scene = QGraphicsScene()
media = Phonon.MediaObject()
video = Phonon.VideoWidget()
Phonon.createPath(media, video)
proxy = CustomProxy()
proxy.setWidget(video)
rect = proxy.boundingRect()
#proxy.setPos(0, 0)
#proxy.show()
scene.addItem(proxy)
media.setCurrentSource("/home/amit/Videos/Kung Fu Panda 3 (2015) 1080p R6 [DayT.se].mp4")
media.play()
titem = scene.addText("Bla-bla-bla")
titem.setPos(130, 130)
#titem.setPos(rect.width()/2, rect.height()/2)
view = QGraphicsView(scene)
vp = QGLWidget()
view.setViewport(vp)
#view.setRenderHints(QPainter.Antialiasing | QPainter.SmoothPixmapTransform)
view.setViewportUpdateMode(QGraphicsView.BoundingRectViewportUpdate)
view.setWindowTitle("Eternal fire")
class QNEMainWindow(QMainWindow):
def __init__(self, parent):
super(QNEMainWindow, self).__init__(parent)
self.logger = logging.getLogger("zne")
self.logger.setLevel(logging.DEBUG)
self.setMinimumSize(560, 360)
self.setWindowTitle("ZOCP Node Editor")
self.setWindowIcon(QIcon('assets/icon.png'))
self.scene = QGraphicsScene(self)
self.view = QGraphicsView(self)
self.view.setScene(self.scene)
self.setCentralWidget(self.view)
self.nodesEditor = QNodesEditor(self, self.scene, self.view)
self.nodesEditor.onAddConnection = self.onAddConnection
self.nodesEditor.onRemoveConnection = self.onRemoveConnection
self.nodesEditor.onBlockMoved = self.onBlockMoved
self.scale = 1
self.installActions()
self.initZOCP()
self.nodes = {}
self.pendingSubscribers = {}
QTimer.singleShot(250, lambda: self.scene.invalidate())
def closeEvent(self, *args):
self.zocp.stop()
def installActions(self):
quitAct = QAction("&Quit",
self,
shortcut="Ctrl+Q",
statusTip="Exit the application",
triggered=self.close)
fileMenu = self.menuBar().addMenu("&File")
fileMenu.addAction(quitAct)
# for shortcuts
self.view.addAction(quitAct)
selectAllAct = QAction("Select &All",
self,
shortcut="Ctrl+A",
triggered=self.nodesEditor.selectAll)
selectNoneAct = QAction("Select &None",
self,
shortcut="Ctrl+D",
triggered=self.nodesEditor.selectNone)
selectInverseAct = QAction("Select &Inverse",
self,
shortcut="Ctrl+I",
triggered=self.nodesEditor.selectInverse)
deleteSelectedAct = QAction("&Delete Selected",
self,
shortcut="Del",
triggered=self.nodesEditor.deleteSelected)
editMenu = self.menuBar().addMenu("&Edit")
editMenu.addAction(selectAllAct)
editMenu.addAction(selectNoneAct)
editMenu.addAction(selectInverseAct)
editMenu.addSeparator()
editMenu.addAction(deleteSelectedAct)
self.view.addAction(selectAllAct)
self.view.addAction(selectNoneAct)
self.view.addAction(selectInverseAct)
self.view.addAction(deleteSelectedAct)
zoomInAct = QAction("Zoom &In",
self,
shortcut="Ctrl++",
triggered=self.zoomIn)
zoomOutAct = QAction("Zoom &Out",
self,
shortcut="Ctrl+-",
triggered=self.zoomOut)
zoomResetAct = QAction("&Reset Zoom",
self,
shortcut="Ctrl+0",
triggered=self.zoomReset)
viewMenu = self.menuBar().addMenu("&View")
viewMenu.addAction(zoomInAct)
viewMenu.addAction(zoomOutAct)
viewMenu.addSeparator()
viewMenu.addAction(zoomResetAct)
self.view.addAction(zoomInAct)
self.view.addAction(zoomOutAct)
self.view.addAction(zoomResetAct)
aboutAct = QAction("&About", self, triggered=self.about)
helpMenu = self.menuBar().addMenu("&Help")
helpMenu.addAction(aboutAct)
self.view.addAction(aboutAct)
def zoomIn(self):
if self.scale < 4:
self.scale *= 1.2
self.view.scale(1.2, 1.2)
def zoomOut(self):
if self.scale > 0.1:
self.scale /= 1.2
self.view.scale(1 / 1.2, 1 / 1.2)
def zoomReset(self):
self.scale = 1
self.view.setTransform(QTransform())
def about(self):
QMessageBox.about(
self, "About ZOCP Node Editor",
"<p>A monitor/editor for ZOCP nodes, implemented in PySide"
"(Python/Qt4).</p><p>ZOCP is the Z25 Orchestration Control "
"Protocol, currently in development at "
"<a href='http://z25.org'>z25.org</a></p>")
#########################################
# Node editor callbacks
#########################################
def onAddConnection(self, connection, fromPort, toPort):
fromBlock = fromPort.block()
toBlock = toPort.block()
emitter = toPort.portName()
emit_peer = toBlock.uuid()
receiver = fromPort.portName()
recv_peer = fromBlock.uuid()
self.zocp.signal_subscribe(recv_peer, receiver, emit_peer, emitter)
self.logger.debug(
"added subscription from %s on %s to %s on %s" %
(receiver, fromBlock.name(), emitter, toBlock.name()))
def onRemoveConnection(self, connection, fromPort, toPort):
fromBlock = fromPort.block()
toBlock = toPort.block()
emitter = toPort.portName()
emit_peer = toBlock.uuid()
receiver = fromPort.portName()
recv_peer = fromBlock.uuid()
self.zocp.signal_unsubscribe(recv_peer, receiver, emit_peer, emitter)
self.logger.debug(
"removed subscription from %s on %s to %s on %s" %
(receiver, fromBlock.name(), emitter, toBlock.name()))
def onBlockMoved(self, block):
pos = block.pos()
peer = block.uuid()
self.zocp.peer_set(peer, {"_zne_position": [pos.x(), pos.y()]})
def onChangeValue(self, block, port, value):
self.logger.debug("block %s port %s changed to %s" %
(block.name(), port.portName(), value))
peer = block.uuid()
portName = port.portName()
capability = self.zocp.peers_capabilities[peer][portName]
typeHint = capability["typeHint"]
validValue = True
if typeHint == "int":
try:
value = int(float(value))
except:
validValue = False
elif typeHint == "flt":
try:
value = float(value.strip())
except:
validValue = False
elif typeHint == "percent":
try:
value = float(value.strip())
except:
validValue = False
elif typeHint == "bool":
value = (value.strip() in ["true", "yes", "1"])
elif typeHint == "string":
pass
elif typeHint == "vec2f" or typeHint == "vec3f" or typeHint == "vec4f":
try:
value = [
float(num) for num in ((value.strip())[1:-1]).split(",")
]
except:
validValue = False
if validValue:
if len(value) != int(typeHint[3]):
validValue = False
if validValue:
self.zocp.peer_set(peer, {portName: {"value": value}})
port.setValue(str(value))
else:
port.setValue(str(capability["value"]))
#########################################
# ZOCP implementation
#########################################
def initZOCP(self):
self.zocp = ZOCP()
self.zocp.set_name("ZOCP Node Editor@%s" % socket.gethostname())
self.notifier = QSocketNotifier(self.zocp.inbox.getsockopt(zmq.FD),
QSocketNotifier.Read)
self.notifier.setEnabled(True)
self.notifier.activated.connect(self.onZOCPEvent)
self.zocp.on_peer_enter = self.onPeerEnter
self.zocp.on_peer_exit = self.onPeerExit
self.zocp.on_peer_modified = self.onPeerModified
self.zocp.on_peer_signaled = self.onPeerSignaled
self.zocp.start()
zl = logging.getLogger("zocp")
zl.setLevel(logging.INFO)
def onZOCPEvent(self):
self.zocp.run_once(0)
def onPeerEnter(self, peer, name, *args, **kwargs):
# Subscribe to any and all value changes
self.zocp.signal_subscribe(self.zocp.get_uuid(), None, peer, None)
# Add named block; ports are not known at this point
block = QNEBlock(None)
self.scene.addItem(block)
block.setNodeEditor(self)
block.setName(name)
block.setUuid(peer)
block.addPort(name, False, False, QNEPort.NamePort)
block.setVisible(False)
node = {}
node["block"] = block
node["ports"] = dict()
self.nodes[peer.hex] = node
def onPeerExit(self, peer, name, *args, **kwargs):
# Unsubscribe from value changes
self.zocp.signal_unsubscribe(self.zocp.get_uuid(), None, peer, None)
# Remove block
if peer.hex in self.nodes:
self.nodes[peer.hex]["block"].delete()
self.nodes.pop(peer.hex)
def onPeerModified(self, peer, name, data, *args, **kwargs):
for portname in data:
portdata = data[portname]
if portname not in self.nodes[peer.hex]["ports"]:
if "access" in portdata:
hasInput = "s" in portdata["access"]
hasOutput = "e" in portdata["access"]
port = self.nodes[peer.hex]["block"].addPort(
portname, hasInput, hasOutput)
port.setValue(str(portdata["value"]))
self.nodes[peer.hex]["ports"][portname] = port
else:
# Metadata, not a capability
if portname == "_zne_position":
block = self.nodes[peer.hex]["block"]
block.setPos(portdata[0], portdata[1])
else:
port = self.nodes[peer.hex]["ports"][portname]
if "value" in portdata:
port.setValue(str(portdata["value"]))
if "subscribers" in portdata:
self.updateSubscribers(port, portdata["subscribers"])
if len(self.nodes[peer.hex]["ports"]) > 0:
self.nodes[peer.hex]["block"].setVisible(True)
self.updatePendingSubscribers(peer)
def onPeerSignaled(self, peer, name, data, *args, **kwargs):
[portname, value] = data
if portname in self.nodes[peer.hex]["ports"]:
self.nodes[peer.hex]["ports"][portname].setValue(str(value))
def updateSubscribers(self, port, subscribers):
port1 = port.outputPort
# check if any current connections should be removed
connections = port.connections()
for connection in connections:
if (connection.port1() == port1):
port2 = connection.port2()
else:
port2 = connection.port1()
if not port2.isOutput():
subscriber = [port2.block().uuid().hex, port2.portName()]
if subscriber not in subscribers:
connection.delete()
self.logger.debug(
"peer removed subscription from %s on %s to %s on %s" %
(port1.portName(), port1.block().name(),
port2.portName(), port2.block().name()))
# add new connections for new subscriptions
for subscriber in subscribers:
[uuid, portname] = subscriber
if uuid in self.nodes:
node = self.nodes[uuid]
if portname in node["ports"]:
port2 = node["ports"][portname]
if not port2.isConnected(port1):
# create new connection
connection = QNEConnection(None)
connection.setPort1(port1)
connection.setPort2(port2)
connection.updatePosFromPorts()
connection.updatePath()
self.scene.addItem(connection)
self.logger.debug(
"peer added subscription from %s on %s to %s on %s"
% (port1.portName(), port1.block().name(),
port2.portName(), port2.block().name()))
continue
# if the connection could not be made yet, add it to a list of
# pending subscriber-connections
if uuid not in self.pendingSubscribers:
self.pendingSubscribers[uuid] = []
self.pendingSubscribers[uuid].append([port1, portname])
def updatePendingSubscribers(self, peer):
if peer.hex in self.pendingSubscribers:
for subscriber in self.pendingSubscribers[peer.hex]:
[port1, portname] = subscriber
if peer.hex in self.nodes and portname in self.nodes[
peer.hex]["ports"]:
port2 = self.nodes[peer.hex]["ports"][portname]
connection = QNEConnection(None)
connection.setPort1(port1)
connection.setPort2(port2)
connection.updatePosFromPorts()
connection.updatePath()
self.scene.addItem(connection)
else:
# TODO: handle case where port is still not available
pass
self.pendingSubscribers.pop(peer.hex)
def setupUi(self):
scene = QGraphicsScene(self)
self.view = QGraphicsView(scene, self)
self.view.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.view.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.view.setVisible(True)
self.view.setInteractive(True)
self.createPixmapIcon()
self.mapWidget = MapWidget(self.mapManager)
scene.addItem(self.mapWidget)
self.mapWidget.setCenter(QGeoCoordinate(-8.1, -34.95))
self.mapWidget.setZoomLevel(5)
#...
self.slider = QSlider(Qt.Vertical, self)
self.slider.setTickInterval(1)
self.slider.setTickPosition(QSlider.TicksBothSides)
self.slider.setMaximum(self.mapManager.maximumZoomLevel())
self.slider.setMinimum(self.mapManager.minimumZoomLevel())
self.slider.valueChanged[int].connect(self.sliderValueChanged)
self.mapWidget.zoomLevelChanged[float].connect(self.mapZoomLevelChanged)
mapControlLayout = QVBoxLayout()
self.mapWidget.mapTypeChanged.connect(self.mapTypeChanged)
for mapType in self.mapWidget.supportedMapTypes():
radio = QRadioButton(self)
if mapType == QGraphicsGeoMap.StreetMap:
radio.setText('Street')
elif mapType == QGraphicsGeoMap.SatelliteMapDay:
radio.setText('Sattelite')
elif mapType == QGraphicsGeoMap.SatelliteMapNight:
radio.setText('Sattelite - Night')
elif mapType == QGraphicsGeoMap.TerrainMap:
radio.setText('Terrain')
if mapType == self.mapWidget.mapType():
radio.setChecked(True)
radio.toggled[bool].connect(self.mapTypeToggled)
self.mapControlButtons.append(radio)
self.mapControlTypes.append(mapType)
mapControlLayout.addWidget(radio)
self.latitudeEdit = QLineEdit()
self.longitudeEdit = QLineEdit()
formLayout = QFormLayout()
formLayout.addRow('Latitude', self.latitudeEdit)
formLayout.addRow('Longitude', self.longitudeEdit)
self.captureCoordsButton = QToolButton()
self.captureCoordsButton.setText('Capture coordinates')
self.captureCoordsButton.setCheckable(True)
self.captureCoordsButton.toggled[bool].connect(
self.mapWidget.setMouseClickCoordQuery)
self.mapWidget.coordQueryResult.connect(self.updateCoords)
self.setCoordsButton = QPushButton()
self.setCoordsButton.setText('Set coordinates')
self.setCoordsButton.clicked.connect(self.setCoordsClicked)
buttonLayout = QHBoxLayout()
buttonLayout.addWidget(self.captureCoordsButton)
buttonLayout.addWidget(self.setCoordsButton)
coordControlLayout = QVBoxLayout()
coordControlLayout.addLayout(formLayout)
coordControlLayout.addLayout(buttonLayout)
widget = QWidget(self)
layout = QGridLayout()
layout.setRowStretch(0, 1)
layout.setRowStretch(1, 0)
topLayout = QGridLayout()
bottomLayout = QGridLayout()
topLayout.setColumnStretch(0, 0)
topLayout.setColumnStretch(1, 1)
bottomLayout.setColumnStretch(0, 0)
bottomLayout.setColumnStretch(1, 1)
topLayout.addWidget(self.slider, 0, 0)
topLayout.addWidget(self.view, 0, 1)
bottomLayout.addLayout(mapControlLayout, 0, 0)
bottomLayout.addLayout(coordControlLayout, 0, 1)
layout.addLayout(topLayout, 0, 0)
layout.addLayout(bottomLayout, 1, 0)
self.layout = layout
widget.setLayout(layout)
self.setCentralWidget(widget)
self.view.setContextMenuPolicy(Qt.CustomContextMenu)
self.view.customContextMenuRequested.connect(self.customContextMenuRequest)
class multiViewPanel:
def __init__(self, view, controller):
self.view = view
self.controller = controller
self.scene = QGraphicsScene()
self.view.setScene(self.scene)
self.variables = {}
self.variableOrder = []
self.currentX = None
self.currentY = None
def addVariable(self, var):
if not var in self.variables.iterkeys():
p = parametricPulseGraph(self,var,var,self.controller.getVectors(var,var))
self.scene.addItem(p)
varGraphs = {var:p} # stick in a placeholder for the diagonal
for v,graphs in self.variables.iteritems():
x = parametricPulseGraph(self,var,v,self.controller.getVectors(var,v))
y = parametricPulseGraph(self,v,var,self.controller.getVectors(v,var))
self.scene.addItem(x)
self.scene.addItem(y)
varGraphs[v] = x
graphs[var] = y
self.variables[var] = varGraphs
self.variableOrder.append(var)
self.updateView()
def removeVariable(self, var):
self.variableOrder.remove(var)
for v in self.variables[var].itervalues():
self.scene.removeItem(v)
del self.variables[var]
for v in self.variableOrder:
self.scene.removeItem(self.variables[v][var])
del self.variables[v][var]
if self.currentX == var or self.currentY == var:
self.noTarget()
else:
self.updateView()
def noTarget(self):
self.currentX = None
self.currentY = None
self.updateView()
def setTarget(self, x, y):
if self.currentX == x and self.currentY == y:
self.noTarget()
else:
self.currentX = x
self.currentY = y
self.updateView()
def updateView(self):
padding = (parametricPulseGraph.FULL_SIZE-parametricPulseGraph.SMALL_SIZE)/2
xPos = 0
for i,x in enumerate(self.variableOrder):
if x == self.currentX:
xPos += padding
yPos = 0
for j,y in enumerate(self.variableOrder):
self.variables[x][y].isLeft = i == 0
self.variables[x][y].isTop = j == 0
self.variables[x][y].isRight = i == len(self.variableOrder)-1
self.variables[x][y].isBottom = j == len(self.variableOrder)-1
if x == self.currentX and y == self.currentY:
self.variables[x][y].setPos(xPos-padding,yPos)
self.variables[x][y].width = parametricPulseGraph.FULL_SIZE
self.variables[x][y].height = parametricPulseGraph.FULL_SIZE
yPos += parametricPulseGraph.FULL_SIZE
else:
if y == self.currentY:
yPos += padding
self.variables[x][y].setPos(xPos,yPos)
self.variables[x][y].width = parametricPulseGraph.SMALL_SIZE
self.variables[x][y].height = parametricPulseGraph.SMALL_SIZE
yPos += parametricPulseGraph.SMALL_SIZE
if y == self.currentY:
yPos += padding
xPos += parametricPulseGraph.SMALL_SIZE
if x == self.currentX:
xPos += padding
self.scene.update()
