def startDrag(self, event):
item = self.itemAt(event.scenePos(), self.page_view_transform)
if item is None:
event.ignore()
return
self.item_being_dragged = item.parent
self.remove_component_controller(item.parent)
hotspot = event.scenePos() - item.scenePos()
hot_spot_point = hotspot.toPoint()
hot_spot_point = self.page_view_transform.map(hot_spot_point)
item_data = QByteArray()
data_stream = QDataStream(item_data, QIODevice.WriteOnly)
data_stream << hot_spot_point # pixmap << location
mime_data = QMimeData()
mime_data.setData(config_controller.component_mime, item_data)
drag = QDrag(self)
drag.setMimeData(mime_data)
horizontal_scaling = self.page_view_transform.m11()
logger.info(f"sceneBoundingRect {item.sceneBoundingRect().width()}")
logger.info(
f"sceneBoundingRect {item.sceneBoundingRect().width()*horizontal_scaling}"
)
drag.setPixmap(
item.parent.pixmap.scaledToWidth(item.sceneBoundingRect().width() *
horizontal_scaling))
drag.setHotSpot(hot_spot_point)
result = drag.start(QtCore.Qt.MoveAction)
if result: # == QtCore.Qt.MoveAction:
pass
def to_clipboard(self):
html = '<table><tbody>\n'
headers = [
self.table.horizontalHeaderItem(i).text()
for i in range(self.table.columnCount() - 1)
]
html += '<tr>'
for c in range(len(headers)):
html += '<th>%s</th>' % headers[c]
html += '</tr>\n'
for r in range(self.table.rowCount() - 1):
html += '<tr>'
for c in range(self.table.columnCount() - 1):
try:
v = self.table.item(r, c).text()
html += '<td>%s</td>' % v
except AttributeError:
v = ''
html += '<td>%s</td>' % v
html += '</tr>'
html += '</tbody></table>'
mime = QMimeData()
mime.setHtml(html)
clipboard = QApplication.clipboard()
clipboard.setMimeData(mime)
def _menuAction_copy_evaluated_buffer(self, buffer_id):
mime = QMimeData()
buff = self.current_state.symbolic_buffers[buffer_id][0]
res = self.current_state.solver.evaluate(buff).as_bytes()
res = '"' + repr(res)[2:-1] + '"'
mime.setText(res)
QApplication.clipboard().setMimeData(mime)
def mouseMoveEvent(self, event):
"""Start dragging action if needed."""
if not event.buttons() & Qt.LeftButton:
return
if not self.drag_start_pos:
return
if not self.drag_indexes:
return
if (event.pos() - self.drag_start_pos
).manhattanLength() < QApplication.startDragDistance():
return
drag = QDrag(self)
mimeData = QMimeData()
urls = list()
for index in self.drag_indexes:
file_path = index.data(Qt.UserRole)
urls.append(QUrl.fromLocalFile(file_path))
mimeData.setUrls(urls)
drag.setMimeData(mimeData)
icon = self.drag_indexes[0].data(Qt.DecorationRole)
if icon:
pixmap = icon.pixmap(32, 32)
drag.setPixmap(pixmap)
drag.setHotSpot(pixmap.rect().center())
drag.exec_()
def startDrag(self, event: QEvent) -> None:
item = self.currentItem()
if item is None:
event.ignore()
return
self.item_being_dragged = self.takeItem(self.row(item)).parent
hot_spot_point = event.pos()
item_data = QByteArray()
data_stream = QDataStream(item_data, QIODevice.WriteOnly)
data_stream << hot_spot_point # pixmap << location
mime_data = QMimeData()
mime_data.setData(config_controller.component_mime, item_data)
drag = QDrag(self)
pixmap = item.parent.pixmap.scaledToWidth(64)
drag.setHotSpot(QPoint(pixmap.width() / 2, pixmap.height() / 2))
drag.setPixmap(pixmap)
drag.setMimeData(mime_data)
result = drag.start(QtCore.Qt.MoveAction)
if result: # == QtCore.Qt.MoveAction:
pass
def mousePressEvent(self, event):
"""Register drag start position"""
super().mousePressEvent(event)
if event.button() == Qt.LeftButton:
self.drag_start_pos = event.pos()
self.pixmap = self.icon().pixmap(self.iconSize())
self.mime_data = QMimeData()
self.mime_data.setText(self._make_mime_data_text())
def _copy_string(self, expr):
mime = QMimeData()
expr_bytes = split_bv_in_list(expr, 8)
res = ""
for el in reversed(expr_bytes):
res += chr(el.value) if el.value >= 32 and el.value <= 126 else "."
mime.setText(res)
QApplication.clipboard().setMimeData(mime)
def startDrag(self, supportedActions):
dragged = self.selectedItems()[0]
mimeData = QMimeData()
mimeData.setText(dragged.text(0))
drag = QDrag(self)
drag.setMimeData(mimeData)
drag.exec_(supportedActions=supportedActions, defaultAction=Qt.MoveAction)
def mimeData(self, indexes):
mime_data = QMimeData()
element_index = indexes[0].row(
) * ELEMENT_COLUMN_NUMBER + indexes[0].column()
# send name of process core to QGraphicsScene
data_array = QByteArray(bytes(self._model[element_index].name,
'UTF-8'))
mime_data.setData(MimeType.PROCESS_CORE.value, data_array)
return mime_data
def mousePressEvent(self, event):
if event.button() == Qt.LeftButton:
drag = QDrag(self)
mime_data = QMimeData()
data_text = self.get_drag_data()
data = QByteArray(bytes(data_text, 'utf-8'))
mime_data.setData('text/plain', data)
drag.setMimeData(mime_data)
drop_action = drag.exec_()
return
def _copy_binary(self, expr):
mime = QMimeData()
expr_bytes = split_bv_in_list(expr, 8)
res = "\""
for el in reversed(expr_bytes):
res += "\\x{:02x}".format(el.value)
res += "\""
mime.setText(res)
QApplication.clipboard().setMimeData(mime)
def _copy_little_endian(self, expr):
mime = QMimeData()
expr_bytes = split_bv_in_list(expr, 8)
res = 0
i = 0
for el in reversed(expr_bytes):
res += el.value << i * 8
i += 1
mime.setText(hex(res))
QApplication.clipboard().setMimeData(mime)
def _handle_mouse_press_event_for_dispos(self, ev: QMouseEvent):
if ev.button() != QtCore.Qt.LeftButton:
return
if self.spawns:
self.spawn_selected.emit(self)
mime_data = QMimeData()
mime_data.setData("application/fe14-spawn", b"")
drag = QDrag(self)
drag.setMimeData(mime_data)
drag.setHotSpot(ev.pos())
drag.exec_(QtCore.Qt.MoveAction)
class DragListView(QListView):
"""Custom QListView class with dragging support.
Attributes:
parent (QWidget): The parent of this view
"""
def __init__(self, parent):
"""Initialize the view."""
super().__init__(parent=parent)
self.drag_start_pos = None
self.pixmap = None
self.mime_data = None
def mousePressEvent(self, event):
"""Register drag start position"""
super().mousePressEvent(event)
if event.button() == Qt.LeftButton:
index = self.indexAt(event.pos())
if not index.isValid() or not index.model().is_index_draggable(
index):
self.drag_start_pos = None
self.pixmap = None
self.mime_data = None
return
self.drag_start_pos = event.pos()
self.pixmap = index.data(Qt.DecorationRole).pixmap(self.iconSize())
mime_data_text = self.model().get_mime_data_text(index)
self.mime_data = QMimeData()
self.mime_data.setText(mime_data_text)
def mouseMoveEvent(self, event):
"""Start dragging action if needed"""
if not event.buttons() & Qt.LeftButton:
return
if not self.drag_start_pos:
return
if (event.pos() - self.drag_start_pos
).manhattanLength() < QApplication.startDragDistance():
return
drag = QDrag(self)
drag.setPixmap(self.pixmap)
drag.setMimeData(self.mime_data)
drag.setHotSpot(self.pixmap.rect().center())
drag.exec_()
self.drag_start_pos = None
self.pixmap = None
self.mime_data = None
def mouseReleaseEvent(self, event):
"""Forget drag start position"""
super().mouseReleaseEvent(event)
self.drag_start_pos = None
self.pixmap = None
self.mime_data = None
def mimeData(self, indices):
logger.debug("mimeData")
if len(indices) == 1 and indices[0].isValid():
index = indices[0]
item = index.internalPointer().content
if isinstance(item, self.SubConfigContent) and isinstance(
item.subConfig, CompositeFilter):
res = QMimeData()
res.setData(self.mimeTypes()[0],
item.subConfig.getName().encode("utf8"))
return res
return None
def startDrag(self, dropActions):
item = self.currentItem()
# icon = item.icon()
data = QByteArray()
stream = QDataStream(data, QIODevice.WriteOnly)
stream.writeQString(item.text())
stream.writeInt16(item.data(1))
# stream << icon
mimeData = QMimeData()
mimeData.setData("application/x-lista-item", data)
drag = QDrag(self)
drag.setMimeData(mimeData)
if drag.exec_(Qt.MoveAction) == Qt.MoveAction:
self.takeItem(self.row(item))
def hCopy(self):
"""
# slot for action copy_to_clipboard
"""
sel = self.listWdg.selectedItems()
####################
# test code
l = []
for item in sel:
# get url from path
l.append(QUrl.fromLocalFile(item.data(Qt.UserRole)[0]))
# init clipboard data
q = QMimeData()
# set some Windows magic values for copying files from system clipboard : Don't modify
# 1 : copy; 2 : move
q.setData("Preferred DropEffect", QByteArray(1, "2"))
q.setUrls(l)
# end of test code
#####################
# copy image to clipboard
item = sel[0]
filename = item.data(Qt.UserRole)[0]
if filename.endswith(IMAGE_FILE_EXTENSIONS):
q.setImageData(QImage(sel[0].data(Qt.UserRole)[0]))
QApplication.clipboard().clear()
QApplication.clipboard().setMimeData(q)
def mousePressEvent(self, event):
"""Register drag start position"""
super().mousePressEvent(event)
if event.button() == Qt.LeftButton:
index = self.indexAt(event.pos())
if not index.isValid():
self.drag_start_pos = None
self.pixmap = None
self.mime_data = None
return
self.drag_start_pos = event.pos()
self.pixmap = index.data(Qt.DecorationRole).pixmap(self.iconSize())
mime_data_text = self.model().get_mime_data_text(index)
self.mime_data = QMimeData()
self.mime_data.setText(mime_data_text)
def mousePressEvent(self, event):
"""Register drag start position"""
super().mousePressEvent(event)
if event.button() == Qt.LeftButton:
index = self.indexAt(event.pos())
if not index.isValid() or index == index.model().new_index:
self.drag_start_pos = None
self.pixmap = None
self.mime_data = None
return
self.drag_start_pos = event.pos()
self.pixmap = index.data(Qt.DecorationRole).pixmap(self.iconSize())
entity_class_id = index.data(Qt.UserRole + 1)
self.mime_data = QMimeData()
self.mime_data.setText(str(entity_class_id))
def mouseMoveEvent(self, event: QGraphicsSceneMouseEvent):
if (QLineF(event.screenPos(), event.buttonDownScreenPos(
Qt.LeftButton)).length() < QApplication.startDragDistance()):
return
self.parentItem().edgeDragStart()
package = QMimeData()
package.setData(self.DragMimeType, bytes())
drag = QDrag(event.widget())
drag.setMimeData(package)
drag.exec_()
self.parentItem().edgeDragStop()
def mouseMoveEvent(self, event):
"""Start dragging action if needed"""
if not event.buttons() & Qt.LeftButton:
return
if not self.drag_start_pos:
return
if (event.pos() - self.drag_start_pos
).manhattanLength() < QApplication.startDragDistance():
return
drag = QDrag(self)
mimeData = QMimeData()
mimeData.setText(self.text)
drag.setMimeData(mimeData)
drag.setPixmap(self.pixmap())
drag.setHotSpot(self.pixmap().rect().center())
dropAction = drag.exec_()
def mousePressEvent(self, event):
# call to super needed for selections
super().mousePressEvent(event)
if event.button() == Qt.LeftButton:
drag = QDrag(self)
mimeData = QMimeData()
item = self.itemAt(event.pos())
if item is None:
return
mimeData.setText(item.data(Qt.UserRole)[0]) # should be path to file
drag.setMimeData(mimeData)
# set dragging pixmap
drag.setPixmap(item.icon().pixmap(QSize(160, 120)))
# roughly center the cursor relative to pixmap
drag.setHotSpot(QPoint(60, 60))
dropAction = drag.exec_()
def mimeData(self, indexes: List[QModelIndex]) -> QMimeData:
indexes = [item for item in indexes if item.column() == 0]
if not indexes:
return None
data = typing.cast(_InternalData, indexes[0].internalPointer())
out = QMimeData()
out_data = {
"id": data["id"],
"parent": "",
"type": "dir" if "data" not in data else "app",
}
if data["parent"]:
out_data["parent"] = data["parent"].internalPointer()["id"]
out.setData(MIMETYPE, json.dumps(out_data).encode("ascii"))
return out
def mousePressEvent(self, event):
super(SnapWindow, self).mousePressEvent(event)
if event.button() == QtCore.Qt.MouseButton.LeftButton:
self.scale_ratio()
self.QDrag = QDrag(self)
self.QMimeData = QMimeData()
self.imgdata = QByteArray()
imgbuffer = QBuffer(self.imgdata)
imgbuffer.open(QIODevice.WriteOnly)
self.original_snap.save(imgbuffer, "PNG")
self.QMimeData.setImageData(self.imgdata)
self.QMimeData.setData("image/png", self.imgdata)
self.QDrag.setMimeData(self.QMimeData)
self.QDrag.setPixmap(self.dragicon)
dropaction = self.QDrag.exec_(Qt.CopyAction)
def mouseMoveEvent(self, e): # noqa: N802 - Part of QT signature.
if e.buttons() != Qt.LeftButton:
return
mimedata = QMimeData()
drag = QDrag(self)
drag.setMimeData(mimedata)
drag.exec_(Qt.MoveAction)
def startDrag(self):
data = QByteArray()
stream = QDataStream(data, QIODevice.WriteOnly)
stream.writeQString(self._player_name)
stream.writeInt16(self._player_id)
mimedata = QMimeData()
mimedata.setData("application/x-lista-item", data)
drag = QDrag(self)
drag.setMimeData(mimedata)
if drag.exec_(Qt.MoveAction) == Qt.MoveAction:
self._player_name = ""
self._player_id = 0
for i in range(self.sorok_szama):
self.parent.eredmenyek[self._csoport_number][
self._csoport_sor][i]._set_p1_id(0)
self.parent.eredmenyek[self._csoport_number][i][
self._csoport_sor]._set_p2_id(0)
self.update()
def mouseMoveEvent(self, event):
if event.buttons() != Qt.LeftButton:
return
if (event.pos() - self._dragStartPosition
).manhattanLength() < QApplication.startDragDistance():
return
pixmap = QPixmap(23, 23)
pixmap.fill(self._color_srgb)
drag = QDrag(self)
mime_data = QMimeData()
text = encode_index(self.parentWidget().index)
mime_data.setText(text)
drag.setMimeData(mime_data)
drag.setPixmap(pixmap)
drop_action = drag.start(Qt.CopyAction) # | Qt.MoveAction)
def decode_mime_data(self, mime_data: QtCore.QMimeData) -> tuple[list[QtCore.QModelIndex], list[EditorTreeItem]]:
encoded_data = mime_data.data('text/index-json-array')
index_data = json.loads(str(encoded_data, 'utf-8')) # type: ignore
indexes = [self.createIndex(
i['row'], i['column'], i['internalId']) for i in index_data]
tree_items = [self.getItem(i) for i in indexes]
return (indexes, tree_items)
def _copy(self, cut):
"""
Copys the selection to clipboard.
:param cut: boolean whether the copy is actually a cut.
:return:
"""
logger.internal("Copying...")
sc = self.scene()
assert isinstance(sc, GraphScene)
items = sc.selectedItems()
nodes = set()
for i in items:
if isinstance(i, BaseGraphScene.NodeItem):
nodes.add(i.name)
saved = sc.graph.getSubConfig().save()
if "_guiState" in saved:
del saved["_guiState"]
toDelIdx = []
deletedNodes = set()
for i, n in enumerate(saved["nodes"]):
if not n["name"] in nodes:
toDelIdx.append(i)
deletedNodes.add(n["name"])
for i in toDelIdx[::-1]:
saved["nodes"] = saved["nodes"][:i] + saved["nodes"][i + 1:]
cToDel = set()
for c in saved["connections"]:
node1, _, node2, _ = SubConfiguration.connectionStringToTuple(c)
if node1 in deletedNodes or node2 in deletedNodes:
cToDel.add(c)
for c in cToDel:
saved["connections"].remove(c)
md = QMimeData()
md.setData("nexxT/json",
json.dumps(saved, indent=2, ensure_ascii=False).encode())
QGuiApplication.clipboard().setMimeData(md)
if cut:
for n in saved["nodes"]:
sc.graph.deleteNode(n["name"])
logger.info("Copyied %d nodes and %d connections", len(saved["nodes"]),
len(saved["connections"]))
def mimeData(self, indexes):
assert len(indexes) == 1
i = indexes[0].row()
package = QMimeData()
mime.dump(self._items.peekitem(i)[1],
package,
self.DragMimeType,
hooks=hooks.qt)
return package
def mousePressEvent(self, event):
hotSpot = event.pos()
mimeData = QMimeData()
mimeData.setText(self.text())
mimeData.setData('application/x-hotspot',
b'%d %d' % (hotSpot.x(), hotSpot.y()))
pixmap = QPixmap(self.size())
self.render(pixmap)
drag = QDrag(self)
drag.setMimeData(mimeData)
drag.setPixmap(pixmap)
drag.setHotSpot(hotSpot)
dropAction = drag.exec_(Qt.CopyAction | Qt.MoveAction, Qt.CopyAction)
if dropAction == Qt.MoveAction:
self.close()
self.update()
