def print_svg(self, svg_source):
#logger.info(svg_source)
svg_renderer = QtSvg.QSvgRenderer()
svg_renderer.load(QtCore.QByteArray(svg_source))
logger.info('svg renderer')
printer = QtGui.QPrinter()
printer.setPageMargins(50, 250, 50, 250, QtGui.QPrinter.DevicePixel)
print_dialog = QtGui.QPrintDialog(printer, self.app.view)
print_dialog.setOption(QtGui.QAbstractPrintDialog.PrintToFile, True)
print_dialog.setOption(QtGui.QAbstractPrintDialog.PrintPageRange, True)
if print_dialog.exec_() == QtGui.QDialog.Accepted:
painter = QtGui.QPainter()
painter.begin(printer)
svg_renderer.render(painter)
painter.end()
def dirtyGameCheck(self):
#self.logger.debug("dirtyGameCheck start")
if time.time() - self.lastDirty > 5.2 and self.skippedDirty < 2:
self.logger.debug("skipping")
#the server is probably laggin, we a beat
self.lastDirty = time.time()
self.skippedDirty = self.skippedDirty + 1
else:
self.lastDirty = time.time()
self.skippedDirty = 0
reply = QtCore.QByteArray()
for uid in self.dirtyGameList:
game = self.parent.games.getGameByUuid(uid)
if game != None:
container = self.parent.games.getGameContainer(game)
if container.isListable(
) == True or container.isPrivateBeta() == False:
reply.append(self.prepareBigJSON(self.jsonGame(game)))
else:
# the current uid doesn't have an associated game. It shouldn't happen, and the game is probably invalid.
# We send "empty" info to the players to be sure that the game is removed on his side.
jsonToSend = {}
jsonToSend["command"] = "game_info"
jsonToSend["uid"] = uid
jsonToSend["title"] = "unknown"
jsonToSend["state"] = "closed"
jsonToSend["featured_mod"] = "unknown"
jsonToSend["featured_mod_versions"] = {}
jsonToSend["sim_mods"] = []
jsonToSend["mapname"] = "unknown"
jsonToSend["host"] = "unknown"
jsonToSend["num_players"] = 0
jsonToSend["game_type"] = "unknown"
jsonToSend["game_time"] = 0
jsonToSend["max_players"] = 0
jsonToSend["teams"] = {}
jsonToSend["options"] = []
reply.append(self.prepareBigJSON(jsonToSend))
if uid in self.dirtyGameList:
self.dirtyGameList.remove(uid)
for lobby in self.recorders:
lobby.sendArray(reply)
def issueRequest(self, action, room, date):
print "Client issuing request"
self.request = QtCore.QByteArray()
stream = QtCore.QDataStream(self.request, QtCore.QIODevice.WriteOnly)
stream.setVersion(QtCore.QDataStream.Qt_4_2)
stream.writeUInt16(0)
stream.writeQString(action)
stream.writeQString(room)
stream << date
stream.device().seek(0)
stream.writeUInt16(self.request.size() - SIZEOF_UINT16)
self.updateUi()
if self.socket.isOpen():
self.socket.close()
self.responseLabel.setText("Connecting to server...")
self.socket.connectToHost("localhost", PORT)
def close_ticket(self, ticket):
request = self._new_request("tickets/%s" % ticket.id)
_ticket = Ticket(ticket.ticket_type_id, ticket.driver_id,
ticket.truck_id, ticket.incoming_weight,
ticket.comment, ticket.document_type_id,
ticket.address)
_ticket.outgoing_weight = ticket.outgoing_weight
_ticket.provider_weight = ticket.provider_weight
_ticket.provider_document_number = ticket.provider_document_number
_ticket.manual_incoming = ticket.manual_incoming
_ticket.manual_outgoing = ticket.manual_outgoing
_ticket.client_id = ticket.client_id
_ticket.transactions_attributes = ticket.transactions_attributes
data = QtCore.QByteArray(_ticket.toJSON())
self.closeTicketReply = self.manager.put(request, data)
self.closeTicketReply.finished.connect(self.close_ticket_finished)
def hoverMoveEvent(self, event):
pos = event.scenePos()
x, y = pos.x(), pos.y()
XML = None
if self.action_ind == 2: # then placeDimensionBaseLine action
XML = angularDimensionSVG(self.line1, self.line2, x, y,
**self.dim_svg_KWs)
elif self.action_ind == 3: # then placeDimensionText
XML = angularDimensionSVG(self.line1, self.line2, self.point3[0],
self.point3[1], x, y, **self.dim_svg_KWs)
if XML <> None:
self.dimSVGRenderer.load(QtCore.QByteArray(XML))
self.dimPreview.update()
self.dimPreview.show()
else:
self.dimPreview.hide()
def service(self):
print(self.thread().currentThreadId())
while not self.stop:
command = self.TcpSocket.read(4096)
if command["type"] == "loadUrl":
self.webview.load(cmd["url"])
data = QtCore.QByteArray()
data = "load finished"
self.TcpSocket.write(data)
self.TcpSocket.flush()
data.deleteLater()
elif cmd["type"] == "close":
self.forceStop()
else:
print("unknow command")
def _composeMessage(self):
"""
Create a message and pass it to the network socket.
"""
datagram = QtCore.QByteArray()
out = QtCore.QDataStream(datagram, QtCore.QIODevice.WriteOnly)
out.setVersion(QtCore.QDataStream.Qt_4_0)
out.writeUInt16(0)
out.writeString(self.toTransmit)
out.device().seek(0)
out.writeUInt16(datagram.size() - 2)
written = self.tcpSocket.write(datagram)
if written != datagram.size():
print "BidirectionalCommunication error - message not sent"
self.tcpSocket.flush()
def startDrag(self):
icon = self.icon
if icon.isNull():
return
data = QtCore.QByteArray()
stream = QtCore.QDataStream(data, QtCore.QIODevice.WriteOnly)
stream.writeQString(self.text)
stream << icon
mimeData = QtCore.QMimeData()
mimeData.setData("application/x-icon-and-text", data)
drag = QtGui.QDrag(self)
drag.setMimeData(mimeData)
pixmap = icon.pixmap(24, 24)
drag.setHotSpot(QtCore.QPoint(12, 12))
drag.setPixmap(pixmap)
drag.start(QtCore.Qt.CopyAction)
def onChanged(self, vobj, prop):
if hasattr(vobj, "OverrideLineColorChildren") and vobj.OverrideLineColorChildren:
if hasattr(vobj, "Object") and hasattr(vobj.Object, "Group"):
for o in vobj.Object.Group:
if o.ViewObject:
for p in ["LineColor", "ShapeColor", "LineWidth", "DrawStyle", "Transparency"]:
if p == "ShapeColor":
if hasattr(vobj, "OverrideShapeColorChildren") and vobj.OverrideShapeColorChildren:
setattr(o.ViewObject, p, getattr(vobj, p))
else:
if hasattr(vobj, p) and hasattr(o.ViewObject, p):
setattr(o.ViewObject, p, getattr(vobj, p))
# give line color to texts
if hasattr(vobj, "LineColor") and hasattr(o.ViewObject, "TextColor"):
o.ViewObject.TextColor = vobj.LineColor
if (prop == "Visibility") and hasattr(vobj, "Visibility"):
if hasattr(vobj, "Object") and hasattr(vobj.Object, "Group"):
for o in vobj.Object.Group:
if o.ViewObject and hasattr(o.ViewObject, "Visibility"):
o.ViewObject.Visibility = vobj.Visibility
if (prop in ["LineColor", "ShapeColor"]) and hasattr(vobj, "LineColor") and hasattr(vobj, "ShapeColor"):
from PySide import QtCore, QtGui
lc = vobj.LineColor
sc = vobj.ShapeColor
lc = QtGui.QColor(int(lc[0] * 255), int(lc[1] * 255), int(lc[2] * 255))
sc = QtGui.QColor(int(sc[0] * 255), int(sc[1] * 255), int(sc[2] * 255))
p1 = QtCore.QPointF(2, 17)
p2 = QtCore.QPointF(13, 8)
p3 = QtCore.QPointF(30, 15)
p4 = QtCore.QPointF(20, 25)
im = QtGui.QImage(32, 32, QtGui.QImage.Format_ARGB32)
im.fill(QtCore.Qt.transparent)
pt = QtGui.QPainter(im)
pt.setBrush(QtGui.QBrush(sc, QtCore.Qt.SolidPattern))
pt.drawPolygon([p1, p2, p3, p4])
pt.setPen(QtGui.QPen(lc, 2, QtCore.Qt.SolidLine, QtCore.Qt.FlatCap))
pt.drawPolygon([p1, p2, p3, p4])
pt.end()
ba = QtCore.QByteArray()
b = QtCore.QBuffer(ba)
b.open(QtCore.QIODevice.WriteOnly)
im.save(b, "XPM")
self.icondata = ba.data().decode("latin1")
vobj.signalChangeIcon()
def __init__(self, data, parent=None):
QtGui.QWidget.__init__(self, parent)
self.resize(QtCore.QSize(620, 500))
self._image_label = QtGui.QLabel(self)
self._image_label.raise_()
self._image_label.setAutoFillBackground(True)
self._image_label.setScaledContents(False)
self.pixmap = QtGui.QPixmap()
self.pixmap.loadFromData(QtCore.QByteArray(data), "PNG")
if self.pixmap.width() <= 600:
self._image_label.setPixmap(self.pixmap)
self.resize(QtCore.QSize(600, self.pixmap.height()))
else:
pixmap = self.pixmap.scaled(600, 600, QtCore.Qt.KeepAspectRatio)
self._image_label.setPixmap(pixmap)
self.resize(QtCore.QSize(600, pixmap.height()))
def on_selected_material(self):
filename = self._mat_name_label.text()
matname = ""
if self._mat_list.selectedItems():
matname = self._mat_list.selectedItems()[0].text()
encoded_png = None
if filename:
vrmat = vray.VRMat(str(filename))
encoded_png = vrmat.getEncodedThumbnail(matname)
if not encoded_png:
encoded_png = blank_preview_b64
image_array = QtCore.QByteArray().fromBase64(encoded_png)
image = QtGui.QPixmap()
image.loadFromData(image_array, "PNG")
self._mat_thumb_label.setPixmap(image)
def __init__(self, parent=None, socket=None):
QtCore.QObject.__init__(self, parent)
if socket is not None:
self.__socket = socket
else:
self.__socket = QtNetwork.QTcpSocket(self)
self.__socket.connected.connect(self.connected)
self.__socket.disconnected.connect(self.disconnected)
self.__socket.readyRead.connect(self.__onReadyRead)
self.__blockSize = 0L
self.__buffer = QtCore.QByteArray()
self.__din = QtCore.QDataStream(self.__buffer,
QtCore.QIODevice.ReadOnly)
self.__queue = []
def run(self):
tcpSocket = QtNetwork.QTcpSocket()
if not tcpSocket.setSocketDescriptor(self.socketDescriptor):
self.error.emit(tcpSocket.error())
return
block = QtCore.QByteArray()
outstr = QtCore.QDataStream(block, QtCore.QIODevice.WriteOnly)
outstr.setVersion(QtCore.QDataStream.Qt_4_0)
outstr.writeUInt16(0)
outstr.writeString(self.text)
outstr.device().seek(0)
outstr.writeUInt16(block.count() - 2)
tcpSocket.write(block)
tcpSocket.disconnectFromHost()
tcpSocket.waitForDisconnected()
def startDrag(self, dropActions):
item = self.currentItem()
icon = item.icon()
data = QtCore.QByteArray()
stream = QtCore.QDataStream(data, QtCore.QIODevice.WriteOnly)
stream.writeQString(item.text())
stream << icon
mimeData = QtCore.QMimeData()
mimeData.setData("application/x-icon-and-text", data)
drag = QtGui.QDrag(self)
drag.setMimeData(mimeData)
pixmap = icon.pixmap(24, 24)
drag.setHotSpot(QtCore.QPoint(12, 12))
drag.setPixmap(pixmap)
#changed .start() to .exec_()
if drag.exec_(QtCore.Qt.MoveAction) == QtCore.Qt.MoveAction:
self.takeItem(self.row(item))
def __init__(self, parent=None):
super(CucumberGifWidget, self).__init__(parent)
self.setAcceptDrops(True)
self.setFrameStyle(QtGui.QFrame.WinPanel | QtGui.QFrame.Sunken)
self.setAlignment(QtCore.Qt.AlignCenter)
self.setSizePolicy(QtGui.QSizePolicy.MinimumExpanding, QtGui.QSizePolicy.MinimumExpanding)
trashGif= open(os.path.join(ImagesFolder,'cucumber.gif'), 'rb').read()
self.gifByteArray=QtCore.QByteArray(trashGif)
self.gifBuffer=QtCore.QBuffer(self.gifByteArray)
self.movie = QtGui.QMovie()
self.movie.setFormat('GIF')
self.movie.setDevice(self.gifBuffer)
self.movie.setCacheMode(QtGui.QMovie.CacheAll)
self.movie.setSpeed(100)
self.setMovie(self.movie)
self.movie.jumpToFrame(0)
def show_gif_right_base(self, path, layout):
print("ui parent view show_gif_right_base line 394")
self.movie_screen = QLabel()
self.movie_screen.setSizePolicy(QtGui.QSizePolicy.Expanding,
QtGui.QSizePolicy.Expanding)
self.movie_screen.setAlignment(QtCore.Qt.AlignCenter)
layout.addWidget(self.movie_screen)
ag_file = path
self.movie = QtGui.QMovie(ag_file, QtCore.QByteArray(), None)
self.movie.setCacheMode(QtGui.QMovie.CacheAll)
self.movie.setSpeed(75)
self.movie_screen.setMovie(self.movie)
#"C:/Users/rg012f/eclipse-workspace/poojan_try/giphy.gif"
self.movie.setPaused(True)
self.movie.start()
def hoverMoveEvent(self, event):
if self.action_ind == 0:
return
pos = event.scenePos()
x, y = pos.x(), pos.y()
XML = None
if self.action_ind == 1: # then placeDimensionBaseLine action
XML = centerLinesSVG( self.center, [x, y],
**self.dim_svg_KWs )
elif self.action_ind == 2: # then placeDimensionText
XML = centerLinesSVG( self.center, self.topLeft, [ x, y ], **self.dim_svg_KWs )
if XML <> None:
self.dimSVGRenderer.load( QtCore.QByteArray( XML ) )
self.dimPreview.update()
self.dimPreview.show()
else:
self.dimPreview.hide()
def set_avatar(self):
choose = QtGui.QApplication.translate("ProfileSettingsForm",
"Choose avatar", None,
QtGui.QApplication.UnicodeUTF8)
name = QtGui.QFileDialog.getOpenFileName(self, choose, None,
'Images (*.png)')
if name[0]:
bitmap = QtGui.QPixmap(name[0])
bitmap.scaled(QtCore.QSize(128, 128),
aspectMode=QtCore.Qt.KeepAspectRatio,
mode=QtCore.Qt.SmoothTransformation)
byte_array = QtCore.QByteArray()
buffer = QtCore.QBuffer(byte_array)
buffer.open(QtCore.QIODevice.WriteOnly)
bitmap.save(buffer, 'PNG')
Profile.get_instance().set_avatar(str(byte_array.data()))
def __init__(self,*args):
super(DimensioningRect, self).__init__(*args)
svgRenderer = QtSvg.QSvgRenderer()
self.action_ind = 0
self.dimPreview = QtSvg.QGraphicsSvgItem()
self.dimSVGRenderer = QtSvg.QSvgRenderer()
self.dimSVGRenderer.load( QtCore.QByteArray( '''<svg width="%i" height="%i"></svg>''' % (args[2],args[3])))
self.dimPreview.setSharedRenderer( self.dimSVGRenderer )
self.dimPreview.setZValue(100)
graphicsScene.addItem( self.dimPreview )
self.dim_svg_KWs = dict(
svgTag='svg', svgParms='width="%i" height="%i"' % (args[2],args[3]),
centerLine_width=2.0, centerLine_len_dot=5, centerLine_len_dash=15, centerLine_len_gap=5
)
assert not hasattr(self, 'topLeft')
assert not hasattr(self, 'bottomRight')
assert not hasattr(self, 'center')
def getIcon(self):
self.p = FreeCAD.ParamGet("User parameter:BaseApp/Preferences/Macro")
self.macropath = self.p.GetString("MacroPath", "")
if os.path.isfile(self.macropath + "/vise/vise.svg"):
i = QtGui.QIcon(self.macropath + "/vise/vise.svg")
else:
vise_icon_url = "https://raw.githubusercontent.com/danielfalck/FCparametric/master/vise/vise.svg"
vise_icon = utils.download(vise_icon_url, force=True)
i = QtGui.QIcon(vise_icon)
p = i.pixmap(128, 128)
a = QtCore.QByteArray()
b = QtCore.QBuffer(a)
b.open(QtCore.QIODevice.WriteOnly)
p.save(b, "XPM")
b.close()
return str(a)
def send(self, value):
"""
We send a message back to the client.
We do it by serialization, compressing and writing of a QByteArray to the TCPSocket.
"""
# serialize value to yaml
serialized = yaml.dump(value, allow_unicode=True)
# encode to utf-8 bytes and compress
compressed = zlib.compress(serialized.encode())
# wrap in QByteArray
bytearray = QtCore.QByteArray(compressed)
# write using a data stream
writer = QtCore.QDataStream(self.socket)
writer.setVersion(QtCore.QDataStream.Qt_4_8)
writer << bytearray
def grabWindowPixmap(self):
""" grabWindowImage() -> QPixmap
Widget special grabbing function
"""
uchar = self.saveToPNG(None)
ba = QtCore.QByteArray()
buf = QtCore.QBuffer(ba)
buf.open(QtCore.QIODevice.WriteOnly)
for i in xrange(uchar.GetNumberOfTuples()):
c = uchar.GetValue(i)
buf.putChar(chr(c))
buf.close()
pixmap = QtGui.QPixmap()
pixmap.loadFromData(ba, 'PNG')
return pixmap
def save_png_bytes_io(self):
""" Save contents as PNG format file(BytesIO object)
Note: DPI is platform dependent due to QPaintDevice DPI handling.
Mac -> 72dpi, Ubuntu -> 96dpi
"""
bytearr = QtCore.QByteArray()
buf = QtCore.QBuffer(bytearr)
buf.open(QtCore.QIODevice.WriteOnly)
self.contents.save(buf, "PNG")
bio = io.BytesIO(bytearr.data())
# DPI correction
img = Image.open(bio)
img = img.resize((self.screen_size[0], self.screen_size[1]),
Image.ANTIALIAS)
img.info["dpi"] = (96, 96)
converted = io.BytesIO()
img.save(converted, format='png')
return converted
def on_change(self, s, lst):
self.labArt.setFixedHeight(300)
self.labArt.setFixedWidth(300)
database = DBConnect('GPlayer.db')
try:
data = database.get_image(unicode(s.encode('iso8859-1')))
pm = QtGui.QPixmap()
pm.loadFromData(QtCore.QByteArray(data))
self.labArt.setPixmap(pm)
except:
self.labArt.setPixmap('logo.png')
lst = [unicode(x.encode('iso8859-1')) for x in lst]
self.add_list(lst) # add list to gui tracks table
self.set_current(
lst.index(instance.player.source.info.title or u'Unknown'))
self.slider.setMaximum(instance.player.source.duration - 1)
self.slider.setValue(instance.player.time)
def copyToClipboard(self):
data = []
indexes = self.selectionModel().selectedIndexes()
if not indexes:
return
for index in indexes:
if index.column() != 0:
continue
data.append(self.model().rowData(index.row()))
mimeData = QtCore.QMimeData()
mimeData.setData(StockerView.mimeType,
QtCore.QByteArray(json.dumps(data)))
clipboard = QtGui.QApplication.clipboard()
clipboard.setMimeData(mimeData)
def mouseReleaseEvent(self, event):
if self.rubberband.isVisible():
self.rubberband.hide()
rect = self.rubberband.geometry()
if rect.width() and rect.height():
p = QtGui.QPixmap.grabWindow(
QtGui.QApplication.desktop().winId(),
rect.x() + 4,
rect.y() + 4,
rect.width() - 8,
rect.height() - 8)
byte_array = QtCore.QByteArray()
buffer = QtCore.QBuffer(byte_array)
buffer.open(QtCore.QIODevice.WriteOnly)
p.save(buffer, 'PNG')
Profile.get_instance().send_screenshot(bytes(
byte_array.data()))
self.close()
def create_widgets(self):
#Widgets
self.movie_screen = QtGui.QLabel()
self.movie_screen.setSizePolicy(QtGui.QSizePolicy.Expanding,
QtGui.QSizePolicy.Expanding)
self.movie_screen.setAlignment(QtCore.Qt.AlignCenter)
self.movie = QtGui.QMovie("anim.gif", QtCore.QByteArray(), self)
self.movie.setCacheMode(QtGui.QMovie.CacheAll)
self.movie.setSpeed(100)
self.movie_screen.setMovie(self.movie)
self.movie.start()
self.label = QtGui.QLabel("SWIFT GRB alert")
self.label.setAlignment(QtCore.Qt.AlignCenter)
self.last_button = QtGui.QPushButton("Show Last GRB")
self.info_button = QtGui.QPushButton("Info")
self.reset_button = QtGui.QPushButton("Reset")
self.config_button = QtGui.QPushButton("Configure")
self.quit_button = QtGui.QPushButton("Quit program")
self.setWindowTitle("GRB Alert")
#connect signals
QtCore.QObject.connect(self.last_button, QtCore.SIGNAL("clicked()"),
self.on_last_clicked)
QtCore.QObject.connect(self.info_button, QtCore.SIGNAL("clicked()"),
self.on_info_clicked)
QtCore.QObject.connect(self.reset_button, QtCore.SIGNAL("clicked()"),
self.on_reset_clicked)
QtCore.QObject.connect(self.config_button, QtCore.SIGNAL("clicked()"),
self.on_config_clicked)
QtCore.QObject.connect(self.quit_button, QtCore.SIGNAL("clicked()"),
QtGui.qApp, QtCore.SLOT('quit()'))
#vert layout
v_box = QtGui.QVBoxLayout()
v_box.addWidget(self.movie_screen)
v_box.addWidget(self.label)
v_box.addWidget(self.last_button)
v_box.addWidget(self.info_button)
v_box.addWidget(self.reset_button)
v_box.addWidget(self.config_button)
v_box.addWidget(self.quit_button)
#Create central widget, add layout and set
central_widget = QtGui.QWidget()
central_widget.setLayout(v_box)
self.setCentralWidget(central_widget)
def onChanged(self, vobj, prop):
"""Execute when a view property is changed."""
if prop in ("LineColor", "ShapeColor", "LineWidth",
"DrawStyle", "Transparency", "Visibility"):
self.change_view_properties(vobj, prop)
if (prop in ("LineColor", "ShapeColor")
and hasattr(vobj, "LineColor")
and hasattr(vobj, "ShapeColor")):
# This doesn't do anything to the objects inside the layer,
# it just uses the defined Line and Shape colors
# to paint the layer icon accordingly in the tree view
l_color = vobj.LineColor
s_color = vobj.ShapeColor
l_color = QtGui.QColor(int(l_color[0] * 255),
int(l_color[1] * 255),
int(l_color[2] * 255))
s_color = QtGui.QColor(int(s_color[0] * 255),
int(s_color[1] * 255),
int(s_color[2] * 255))
p1 = QtCore.QPointF(2, 17)
p2 = QtCore.QPointF(13, 8)
p3 = QtCore.QPointF(30, 15)
p4 = QtCore.QPointF(20, 25)
image = QtGui.QImage(32, 32, QtGui.QImage.Format_ARGB32)
image.fill(QtCore.Qt.transparent)
pt = QtGui.QPainter(image)
pt.setBrush(QtGui.QBrush(s_color, QtCore.Qt.SolidPattern))
pt.drawPolygon([p1, p2, p3, p4])
pt.setPen(QtGui.QPen(l_color, 2,
QtCore.Qt.SolidLine, QtCore.Qt.FlatCap))
pt.drawPolygon([p1, p2, p3, p4])
pt.end()
byte_array = QtCore.QByteArray()
buffer = QtCore.QBuffer(byte_array)
buffer.open(QtCore.QIODevice.WriteOnly)
image.save(buffer, "XPM")
self.icondata = byte_array.data().decode("latin1")
vobj.signalChangeIcon()
def dropEvent(self, event):
if event.mimeData().hasFormat("image/x-workflow-step"):
pieceData = event.mimeData().data("image/x-workflow-step")
stream = QtCore.QDataStream(pieceData, QtCore.QIODevice.ReadOnly)
hotspot = QtCore.QPoint()
nameLen = stream.readUInt32()
# name = stream.readRawData(nameLen).decode('utf-8')
if sys.version_info < (3, 0):
name = stream.readRawData(nameLen).decode('utf-8')
else:
buf = QtCore.QByteArray()
stream >> buf
name = '{0}'.format(buf)
stream >> hotspot
scene = self.scene()
position = self.mapToScene(event.pos() - hotspot)
step = workflowStepFactory(name, self._location)
step.setMainWindow(self._main_window)
metastep = MetaStep(step)
node = Node(metastep)
node.showStepName(self._showStepNames)
metastep._step.registerConfiguredObserver(scene.stepConfigured)
metastep._step.registerDoneExecution(scene.doneExecution)
metastep._step.registerOnExecuteEntry(scene.setCurrentWidget)
metastep._step.registerIdentifierOccursCount(
scene.identifierOccursCount)
self._undoStack.beginMacro('Add node')
self._undoStack.push(CommandAdd(scene, node))
# Set the position after it has been added to the scene
self._undoStack.push(
CommandMove(node, position,
scene.ensureItemInScene(node, position)))
scene.clearSelection()
node.setSelected(True)
self._undoStack.endMacro()
self.setFocus()
event.accept()
else:
event.ignore()
def startDrag(self, dropActions):
item = self.currentItem()
icon = item.icon()
data = QtCore.QByteArray()
stream = QtCore.QDataStream(data, QtCore.QIODevice.WriteOnly)
stream.writeQString(item.text())
stream << icon
mimeData = QtCore.QMimeData()
mimeData.setData("application/x-icon-and-text", data)
drag = QtGui.QDrag(self)
drag.setMimeData(mimeData)
pixmap = icon.pixmap(24, 24)
drag.setHotSpot(QtCore.QPoint(12, 12))
drag.setPixmap(pixmap)
#will need to modify following to take into account move versus copy
dragResult = drag.exec_(QtCore.Qt.MoveAction | QtCore.Qt.CopyAction)
#print "dragResult: ", dragResult
if dragResult == QtCore.Qt.MoveAction:
self.takeItem(self.row(item))
