def mousePressEvent(self, event):
child = self.childAt(event.pos())
if not child:
return
pixmap = QPixmap(child.pixmap())
mimeData = QMimeData()
mimeData.setText(child.type)
drag = QDrag(self)
drag.setPixmap(child.pixmap())
drag.setMimeData(mimeData)
drag.setHotSpot(event.pos() - child.pos())
tempPixmap = QPixmap(pixmap)
painter = QPainter()
painter.begin(tempPixmap)
painter.fillRect(pixmap.rect(), QColor(127, 127, 127, 127))
painter.end()
child.setPixmap(tempPixmap)
if drag.exec_(Qt.CopyAction | Qt.MoveAction,
Qt.CopyAction) == Qt.MoveAction:
child.close()
else:
child.show()
child.setPixmap(pixmap)
def mouseMoveEvent(self, event: QMouseEvent) -> None:
if event.buttons() == Qt.LeftButton:
mimeData = QMimeData()
mimeData.setText(str(self.idx))
drag = QDrag(self)
drag.setMimeData(mimeData)
drag.exec_(Qt.MoveAction)
def mouseMoveEvent(self, e):
mimeData = QMimeData()
mimeData.setText(self.text())
drag = QDrag(self)
drag.setMimeData(mimeData)
drag.setHotSpot(e.pos() - self.rect().topLeft())
dropAction = drag.exec_(Qt.MoveAction)
def mouseMoveEvent(self, event):
"""
Protected method to handle mouse move events.
@param event reference to the mouse move event (QMouseEvent)
"""
if event.buttons() == Qt.MouseButtons(Qt.LeftButton) and \
(event.pos() - self.__dragStartPos).manhattanLength() > \
QApplication.startDragDistance():
drag = QDrag(self)
mimeData = QMimeData()
index = self.tabAt(event.pos())
mimeData.setText(self.tabText(index))
mimeData.setData("action", b"tab-reordering")
mimeData.setData("tabbar-id", str(id(self)).encode("utf-8"))
mimeData.setData(
"source-index",
QByteArray.number(self.tabAt(self.__dragStartPos)))
mimeData.setData(
"tabwidget-id",
str(id(self.parentWidget())).encode("utf-8"))
drag.setMimeData(mimeData)
if event.modifiers() == Qt.KeyboardModifiers(Qt.ShiftModifier):
drag.exec_(Qt.DropActions(Qt.CopyAction))
elif event.modifiers() == Qt.KeyboardModifiers(Qt.NoModifier):
drag.exec_(Qt.DropActions(Qt.MoveAction))
super(TabBar, self).mouseMoveEvent(event)
def mouseMoveEvent(self, e: QtGui.QMouseEvent) -> None:
if e.buttons() != Qt.LeftButton:
return None
#根据currentIndex获取数据行的名称
mimeData = QMimeData()
mimeData.setText('{}:{}:{}'.format(self.type, self.address,
self.text()))
#绘制拖动时的图像
pixmap = QPixmap(self.size())
paint = QPainter()
paint.begin(pixmap)
# paint.fillRect(pixmap.rect(),QColor(Qt.white))
# paint.drawRect(pixmap.rect())
paint.drawPixmap(self.rect(), self.grab())
paint.drawText(pixmap.rect(), Qt.AlignCenter, self.text())
paint.end()
#设定拖动项的数据和图标
drag = QDrag(self)
drag.setMimeData(mimeData)
drag.setPixmap(pixmap)
drag.exec_(Qt.MoveAction)
super().mouseMoveEvent(e)
def mouseMoveEvent(self, event):
drag = QDrag(self)
mimedata = QMimeData()
current_item_test = self.currentItem().text()
mimedata.setText(current_item_test)
drag.setMimeData(mimedata)
drag.exec_()
def mousePressEvent(self, event):
if event.buttons() != Qt.LeftButton:
return
icon = QLabel()
mimeData = QMimeData()
mime_text = str(self.row) + str(self.column) + str(
self.__class__.__name__)
mimeData.setText(mime_text)
pixmap = QPixmap('images/ExecOp.png').scaled(120, 60)
drag = QDrag(self)
drag.setMimeData(mimeData)
drag.setPixmap(self.pixmap)
drag.setHotSpot(event.pos() - self.rect().topLeft())
if drag.exec_(Qt.CopyAction | Qt.MoveAction,
Qt.CopyAction) == Qt.MoveAction:
icon.close()
else:
icon.show()
icon.setPixmap(self.pixmap)
def mimeData(self, indexes):
# TODO : refactor with utilities.mimeWrapJson
data = json.dumps({'source': 'playlist', 'row': indexes[0].row()})
mimeData = QMimeData()
mimeData.setText(data)
return mimeData
def __prepareDropData(self, event):
"""prepares data for the drag and drop process"""
drag = QDrag(self)
dropData = QMimeData()
data = {
'from_row':
self.fromRow,
'from_column':
self.fromColumn,
'row_span':
self.rowSpan,
'column_span':
self.columnSpan,
'row_offset':
event.pos().y() //
(self.verticalSpan + self.tileLayout.verticalSpacing()),
'column_offset':
event.pos().x() //
(self.horizontalSpan + self.tileLayout.horizontalSpacing()),
}
dataToText = json.dumps(data)
dropData.setText(dataToText)
dragIcon = self.widget.grab()
drag.setPixmap(dragIcon)
drag.setMimeData(dropData)
drag.setHotSpot(event.pos() - self.rect().topLeft())
return drag
def mousePressEvent(self, event):
logging.debug('ElementMaster::mousePressEvent() called')
# uncomment this for debugging purpose
#self.listChild()
if event.buttons() != Qt.LeftButton:
return
icon = QLabel()
mimeData = QMimeData()
mime_text = str(self.row) + str(self.column) + str(self.__class__.__name__)
mimeData.setText(mime_text)
drag = QDrag(self)
drag.setMimeData(mimeData)
drag.setPixmap(self.pixmap)
drag.setHotSpot(event.pos() - self.rect().topLeft())
if drag.exec_(Qt.CopyAction | Qt.MoveAction, Qt.CopyAction) == Qt.MoveAction:
icon.close()
else:
icon.show()
icon.setPixmap(self.pixmap)
def startDrag(self, event):
""" Override startDrag method to display custom icon """
# Get image of selected item
selected = self.selectedIndexes()
# Start drag operation
drag = QDrag(self)
drag.setMimeData(self.model.mimeData(selected))
icon = self.model.data(selected[0], Qt.DecorationRole)
drag.setPixmap(
icon.pixmap(QSize(self.drag_item_size, self.drag_item_size)))
drag.setHotSpot(
QPoint(self.drag_item_size / 2, self.drag_item_size / 2))
# Create emoji file before drag starts
data = json.loads(drag.mimeData().text())
file = self.add_file(data[0])
# Update mimedata for emoji
data = QMimeData()
data.setText(json.dumps([file.id]))
data.setHtml("clip")
drag.setMimeData(data)
# Start drag
drag.exec_()
def insertFromMimeData(self, data: QMimeData) -> None:
""" On a paste attempt, reset the cursor if necessary and paste only the plaintext content. """
if data.hasText():
self._set_cursor_valid()
plaintext = QMimeData()
plaintext.setText(data.text())
super().insertFromMimeData(plaintext)
def mousePressEvent(self, event):
# handle an internal move
# start a drag event
if event.button() == Qt.LeftButton and self.dragDropRect().contains(
event.pos()):
# create the pixmap
pixmap = QPixmap.grabWidget(self, self.rect())
# create the mimedata
mimeData = QMimeData()
mimeData.setText('ItemTitle::%s' % (self.title()))
# create the drag
drag = QDrag(self)
drag.setMimeData(mimeData)
drag.setPixmap(pixmap)
drag.setHotSpot(event.pos())
if not drag.exec_():
self._accordianWidget.emitItemDragFailed(self)
event.accept()
# determine if the expand/collapse should occur
elif event.button() == Qt.LeftButton and self.expandCollapseRect(
).contains(event.pos()):
self._clicked = True
event.accept()
else:
event.ignore()
def mouseMoveEvent(self, event):
if not (event.buttons() & Qt.Qt.LeftButton):
return
if (event.pos() - self.drag_start_position
).manhattanLength() < QApplication.startDragDistance():
return
drag = QDrag(self)
mimedata = QMimeData()
row = self.indexAt(self.drag_start_position).row()
collumn = self.indexAt(self.drag_start_position).column()
mimedata.setText(self.item(row, collumn).text())
drag.setMimeData(mimedata)
item = QLabel(self.item(row, collumn).text())
item.adjustSize()
# item.setFixedSize(100,50)
pixmap = QtWidgets.QWidget.grab(item)
# pixmap = QPixmap(self.size())
painter = QPainter(pixmap)
painter.drawPixmap(item.rect(), item.grab())
painter.end()
drag.setPixmap(pixmap)
# drag.setHotSpot(event.pos())
drag.setPixmap(pixmap)
# shift the Pixmap so that it coincides with the cursor position
# drag.setHotSpot(event.pos())
drag.exec_(QtCore.Qt.CopyAction | QtCore.Qt.MoveAction)
def mouseMoveEvent(self, event):
if self.dialog.removable:
return
if not (event.buttons() & Qt.LeftButton):
return
if (event.pos() - self.drag_start_position).manhattanLength() < QApplication.startDragDistance():
return
drag = QDrag(self)
mimedata = QMimeData()
mimedata.setText(self.text())
if self.pixmap() is None:
return
mimedata.setImageData(self.pixmap().toImage())
drag.setMimeData(mimedata)
pixmap = QPixmap(self.size())
self.image = pixmap
painter = QPainter(pixmap)
painter.drawPixmap(self.rect(), self.grab())
painter.end()
drag.setPixmap(pixmap)
drag.setHotSpot(event.pos())
print("Moving")
drag.exec_(Qt.MoveAction)
def get_mime(self):
mime_data = QMimeData()
pretty_xml = etree.tostring(self._to_xml(), pretty_print=True).decode()
mime_data.setText(pretty_xml)
mime_data.setData('application/x-qt-windows-mime;value="XML"',
QByteArray(pretty_xml.encode()))
return mime_data
def copyAct(self):
self.scene.selection = []
p = self.scene.selectionArea()
self.scene.selection = self.scene.items(p)
if self.scene.selection == []:
self.scene.selection = self.scene.selectedItems()
dgmBlocks = []
dgmConnections = []
for item in self.scene.selection:
if isinstance(item, Block):
dgmBlocks.append(item)
for item in self.scene.selection:
if isinstance(item, Connection):
if item.port1.parent in dgmBlocks and item.port2.parent in dgmBlocks:
dgmConnections.append(item)
root = etree.Element('root')
for item in dgmBlocks:
item.save(root)
for item in dgmConnections:
item.save(root)
msg = etree.tostring(root, pretty_print=True)
clipboard = QApplication.clipboard()
mimeData = QMimeData()
mimeData.setText(msg.decode())
clipboard.setMimeData(mimeData)
def mouseMoveEvent(self, e: QtGui.QMouseEvent) -> None:
if e.buttons() != Qt.LeftButton:
return None
#根据currentIndex获取数据行的名称
mimeData = QMimeData()
currentRow = self.currentIndex().row()
index = self.model().index(currentRow, 0)
itemName = self.model().data(index)
mimeData.setText('{}:{}:{}'.format(self.type, self.address, itemName))
#绘制拖动时的图像
width = self.columnWidth(0)
height = self.rowHeight(currentRow)
pixmap = QPixmap(width, height)
paint = QPainter()
paint.begin(pixmap)
paint.fillRect(pixmap.rect(), QColor(Qt.white))
paint.drawRect(0, 0, width - 1, height - 1)
paint.drawText(pixmap.rect(), Qt.AlignCenter, itemName)
paint.end()
#设定拖动项的数据和图标
drag = QDrag(self)
drag.setMimeData(mimeData)
drag.setPixmap(pixmap)
drag.exec_(Qt.MoveAction)
super().mouseMoveEvent(e)
def mouseMoveEvent(self, event):
if (event.pos() - self.dragStartPosition
).manhattanLength() < QApplication.startDragDistance():
return
mimeData = QMimeData()
if not self.layer.selected:
name = self.layer.name
else:
name = ''
for layer in self.layer.viewer.layers:
if layer.selected:
name = layer.name + '; ' + name
name = name[:-2]
mimeData.setText(name)
drag = QDrag(self)
drag.setMimeData(mimeData)
drag.setHotSpot(event.pos() - self.rect().topLeft())
dropAction = drag.exec_(Qt.MoveAction | Qt.CopyAction)
if dropAction == Qt.CopyAction:
if not self.layer.selected:
index = self.layer.viewer.layers.index(self.layer)
self.layer.viewer.layers.pop(index)
else:
self.layer.viewer.layers.remove_selected()
def mouseMoveEvent(self, event):
"""
Protected method to handle mouse move events.
@param event reference to the mouse move event (QMouseEvent)
"""
if event.buttons() == Qt.MouseButtons(Qt.LeftButton) and \
(event.pos() - self.__dragStartPos).manhattanLength() > \
QApplication.startDragDistance():
drag = QDrag(self)
mimeData = QMimeData()
index = self.tabAt(event.pos())
mimeData.setText(self.tabText(index))
mimeData.setData("action", b"tab-reordering")
mimeData.setData("tabbar-id", str(id(self)).encode("utf-8"))
mimeData.setData(
"source-index",
QByteArray.number(self.tabAt(self.__dragStartPos)))
mimeData.setData("tabwidget-id",
str(id(self.parentWidget())).encode("utf-8"))
drag.setMimeData(mimeData)
if event.modifiers() == Qt.KeyboardModifiers(Qt.ShiftModifier):
drag.exec_(Qt.DropActions(Qt.CopyAction))
elif event.modifiers() == Qt.KeyboardModifiers(Qt.NoModifier):
drag.exec_(Qt.DropActions(Qt.MoveAction))
super(TabBar, self).mouseMoveEvent(event)
def mouseMoveEvent(self, event):
if QLineF(QPointF(event.screenPos()), QPointF(event.buttonDownScreenPos(Qt.LeftButton))).length() < QApplication.startDragDistance():
return
drag = QDrag(event.widget())
mime = QMimeData()
drag.setMimeData(mime)
ColorItem.n += 1
if ColorItem.n > 2 and qrand() % 3 == 0:
image = QImage(':/images/head.png')
mime.setImageData(image)
drag.setPixmap(QPixmap.fromImage(image).scaled(30,40))
drag.setHotSpot(QPoint(15, 30))
else:
mime.setColorData(self.color)
mime.setText("#%02x%02x%02x" % (self.color.red(), self.color.green(), self.color.blue()))
pixmap = QPixmap(34, 34)
pixmap.fill(Qt.white)
painter = QPainter(pixmap)
painter.translate(15, 15)
painter.setRenderHint(QPainter.Antialiasing)
self.paint(painter, None, None)
painter.end()
pixmap.setMask(pixmap.createHeuristicMask())
drag.setPixmap(pixmap)
drag.setHotSpot(QPoint(15, 20))
drag.exec_()
self.setCursor(Qt.OpenHandCursor)
def mousePressEvent(self, event):
logging.debug('DropBox::mousePressEvent() called: {}'.format(
event.pos()))
try:
mimeData = QMimeData()
mimeData.setText(self.type)
# load config into memory tmp_config of storabar
self.parent.tmp_config = self.config
self.parent.tmp_element = self
# push config to active workingarea
self.parent.loadConfig()
except Exception as e:
logging.error(
'DropBox::mousePressEvent() Exception caught: {}'.format(
str(e)))
return
drag = QDrag(self)
drag.setHotSpot(event.pos())
drag.setPixmap(self.label.pixmap())
drag.setMimeData(mimeData)
if drag.exec_(Qt.CopyAction | Qt.MoveAction,
Qt.CopyAction) == Qt.MoveAction:
self.close()
else:
self.show()
self.label.setPixmap(self.label.pixmap())
logging.debug('DropBox::mousePressEvent() dropped')
def _handle_copy_text(self):
mime = QMimeData()
try:
mime.setText(binascii.a2b_hex(self._selected_data))
except TypeError:
raise Exception("TOP values are not supported yet")
QApplication.clipboard().setMimeData(mime)
def mouseMoveEvent(self, event):
if not (event.buttons() & Qt.LeftButton):
return None
manhattanLength = event.pos()
manhattanLength -= self.drag_start_position
manhattanLength = manhattanLength.manhattanLength()
if manhattanLength < QApplication.startDragDistance():
return None
drag = QDrag(self)
mimedata = QMimeData()
message = json.dumps({
"codigo": self.code,
"estado": self.state,
"semestre actual": self.semester
})
mimedata.setText(message)
drag.setMimeData(mimedata)
pixmap = QPixmap(QSize(subject_width, self.height))
painter = QPainter(pixmap)
painter.drawPixmap(0, 0, subject_width, self.height, self.grab())
painter.end()
pixmap = pixmap.scaled(QSize(subject_width, self.height))
drag.setPixmap(pixmap)
drag.setHotSpot(event.pos())
drag.exec_(Qt.CopyAction | Qt.MoveAction)
def mousePressEvent(self, event):
child = self.childAt(event.pos())
if child is None:
return
hotSpot = event.pos() - child.pos()
itemData = QByteArray()
dataStream = QDataStream(itemData, QIODevice.WriteOnly)
dataStream.writeQString(child.labelText())
dataStream << hotSpot
mimeData = QMimeData()
mimeData.setData(fridgeMagnetsMimeType(), itemData)
mimeData.setText(child.labelText())
drag = QDrag(self)
drag.setMimeData(mimeData)
drag.setPixmap(child.pixmap())
drag.setHotSpot(hotSpot)
child.hide()
if drag.exec(Qt.MoveAction | Qt.CopyAction,
Qt.CopyAction) == Qt.MoveAction:
child.close()
else:
child.show()
def updateMimeData(
self,
hasColor,
color,
hasHtml,
html,
hasImage,
image,
hasText,
text,
hasUrls,
urls,
hasFiles,
files,
):
# 客户端剪切板同步到服务端
self.append('收到客户端发送的剪贴板')
clipboard = QApplication.clipboard()
clipboard.blockSignals(True)
data = QMimeData()
if hasColor:
data.setColorData(color)
if hasHtml:
data.setHtml(html)
if hasImage:
data.setImageData(image)
if hasText:
data.setText(text)
# if hasUrls:
# data.setUrls(urls)
if hasFiles:
data.setData('')
clipboard.setMimeData(data)
clipboard.blockSignals(False)
def mimeData(self, indexes):
name = indexes[0].data()
print('called mimeData on ' + name)
mimedata = QMimeData()
mimedata.setText(name)
return mimedata
def copy(self):
"""Copy to the clipboard"""
data = QMimeData()
text = '\n'.join([cursor.selectedText() \
for cursor in self.cursors()])
data.setText(text)
data.setData(self.MIME_TYPE, text.encode('utf8'))
QApplication.clipboard().setMimeData(data)
def copy(self):
"""Copy to the clipboard"""
data = QMimeData()
text = '\n'.join([cursor.selectedText() \
for cursor in self.cursors()])
data.setText(text)
data.setData(self.MIME_TYPE, text.encode('utf8'))
QApplication.clipboard().setMimeData(data)
def mouseMoveEvent(self, e):
mime_data = QMimeData()
data = "{}_{}_{}".format(self.bobine.code, self.bobine.pose,
self.bobine.index)
mime_data.setText(data)
drag = QDrag(self)
drag.setMimeData(mime_data)
drag.exec_(Qt.MoveAction)
def startDrag(self, dropActions):
item = self.currentItem()
mimeData = QMimeData()
mimeData.setText(item.text())
drag = QDrag(self)
drag.setMimeData(mimeData)
drag.setHotSpot(QPoint(12, 12))
drag.exec(Qt.MoveAction)
def mouseMoveEvent(self, event):
mime_data = QMimeData()
mime_data.setText(self.text)
drag = QDrag(self)
drag.setMimeData(mime_data)
drag.setHotSpot(event.pos() - self.rect().topLeft())
drag.exec_()
def mimeData(self, items, _=None):
if items:
item = items[0]
node_type = item.data(1, Qt.UserRole)
if node_type:
data = QMimeData()
data.setText(json.dumps(node_type))
return data
return
def mouseMoveEvent(self, e):
modifiers = QApplication.keyboardModifiers()
if modifiers == Qt.ControlModifier:
mimeData = QMimeData()
drag = QDrag(e.widget())
mimeData.setText("node")
drag.setMimeData(mimeData)
drag.exec_(Qt.MoveAction)
self.ungrabMouse()
if self.edgeInConstruction != None:
self.edgeInConstruction.obsUpdate(e.scenePos())
def mimeData(self, indexes):
data = ''
for index in indexes:
parent_item = self.getItem(index.parent())
if parent_item == self.rootItem:
data += "{0},{1},{2}/".format(index.row(), index.column(), -1)
else:
data += "{0},{1},{2}/".format(index.row(), index.column(), self.rootItem.index_of(parent_item))
mime_data = QMimeData()
mime_data.setText(data)
return mime_data
def insertFromMimeData(self, source):
"""Remove newlines from pasted text if necessary."""
if self.single_line:
# Remove newlines.
text = source.text()
mime = QMimeData()
# TODO: does windows+mac work?
mime.setText(text.replace("\n", " "))
else:
mime = source
super().insertFromMimeData(mime)
def mimeData(self, idxs):
mdata = QMimeData()
nodes = []
for idx in idxs:
item = self.itemFromIndex(idx)
if item:
node = item.data()
if node:
nodes.append(node.nodeid.to_string())
mdata.setText(", ".join(nodes))
return mdata
def mimeData(self, indexes):
# Create MimeData for drag operation
data = QMimeData()
# Get list of all selected file ids
property_names = []
for item in indexes:
selected_row = self.itemFromIndex(item).row()
property_names.append(self.item(selected_row, 0).data())
data.setText(json.dumps(property_names))
# Return Mimedata
return data
def mousePressEvent(self, event):
if event.button() == Qt.LeftButton:
self.drag_started.emit(self.mapToParent(event.pos()))
drag = QDrag(self)
mimeData = QMimeData()
mimeData.setText("Move Signal")
pixmap = QPixmap(self.rect().size())
self.render(pixmap, QPoint(), QRegion(self.rect()))
drag.setPixmap(pixmap)
drag.setMimeData(mimeData)
drag.exec_()
def mimeData(self, indexes):
"""
This is a single-selection model, so there should only be
one row getting dragged.
And what we're dragging around is simply a text version of
the inode for the dragged file.
:param indexes:
:return:
"""
mimedata = QMimeData()
mimedata.setText(str(indexes[0].internalId()))
return mimedata
def mouseMoveEvent(self, event):
if not event.buttons() and Qt.LeftButton:
return
distance = (event.pos() - self.start_mouse_drag).manhattanLength()
if distance < QApplication.startDragDistance():
return
item = self.selectedItems()[0]
text = "<row>" + str(item.row()) + "<row>" + "<col>" + str(item.column()) + "<col>" + "<text>" + str(item.text()) + "<text>"
print(text)
drag = QDrag(self)
mim_data = QMimeData()
mim_data.setText(text)
drag.setMimeData(mim_data)
dropAction = drag.exec_(Qt.MoveAction)
def mimeData(self, indexes):
# Create MimeData for drag operation
data = QMimeData()
# Get list of all selected file ids
files = []
for item in indexes:
selected_row = self.itemFromIndex(item).row()
files.append(self.item(selected_row, 4).text())
data.setText(json.dumps(files))
data.setHtml("effect")
# Return Mimedata
return data
def mouseMoveEvent(self, event):
if event.buttons() & Qt.LeftButton:
index = self._findEventIndex(event)
if self._maybeDragPosition is not None:
if ((event.pos() - self._maybeDragPosition).manhattanLength()
< QApplication.startDragDistance()):
return
# TODO: needs ordering or not?
glyphList = " ".join(
glyph.name for glyph in self.getSelectedGlyphs())
drag = QDrag(self)
mimeData = QMimeData()
mimeData.setText(glyphList)
drag.setMimeData(mimeData)
drag.exec_()
self._maybeDragPosition = None
event.accept()
return
if index == self._lastSelectedCell:
return
modifiers = event.modifiers()
event.accept()
if index is None:
if not (modifiers & Qt.ControlModifier or
modifiers & Qt.ShiftModifier):
self.selection = set()
self._lastSelectedCell = index
return
if modifiers & Qt.ControlModifier:
if index in self._selection and index in self._oldSelection:
selection = self.selection
selection.remove(index)
self.selection = selection
elif (index not in self._selection and
index not in self._oldSelection):
selection = self.selection
selection.add(index)
self.selection = selection
elif modifiers & Qt.ShiftModifier:
newSelection = self._linearSelection(index)
if newSelection is not None:
self.selection = newSelection
else:
self.selection = {index}
self.lastSelectedCell = index
else:
super(GlyphCollectionWidget, self).mouseMoveEvent(event)
def mimeData(self, indexes):
"""
:param list[QModelIndex] indexes:
:return: A string that is 2 ints separated by whitespace, e.g.: '4 8' This string corresponds to the first and last row in the block of rows being dragged.
"""
rows = sorted(set(i.row() for i in indexes))
# save these as ints to speed up canDropMimeData
self._drag_start = rows[0]
self._drag_end = rows[-1]
mimedata = QMimeData()
mimedata.setText("{0._drag_start} {0._drag_end}".format(self))
return mimedata
def mouseMoveEvent(self, event):
"""
Protected method to handle mouse move events.
@param event reference to the mouse move event (QMouseEvent)
"""
if event.buttons() == Qt.MouseButtons(Qt.LeftButton) and \
(event.pos() - self.__dragStartPos).manhattanLength() > \
QApplication.startDragDistance():
drag = QDrag(self)
mimeData = QMimeData()
index = self.tabAt(event.pos())
mimeData.setText(self.tabText(index))
mimeData.setData("action", "tab-reordering")
mimeData.setData("tabbar-id", str(id(self)))
drag.setMimeData(mimeData)
drag.exec_()
E5WheelTabBar.mouseMoveEvent(self, event)
def mouseMoveEvent(self, event):
if (event.buttons() == Qt.LeftButton and
(event.modifiers() == Qt.ControlModifier or
event.modifiers() == Qt.ShiftModifier)):
mime_data = QMimeData()
mime_data.setText(PageWidget.DRAG_MAGIC)
drag = QDrag(self)
drag.setMimeData(mime_data)
drag.setPixmap(self.grab(self.rect()))
if event.modifiers() == Qt.ControlModifier:
drag.exec_(Qt.MoveAction)
else:
drag.exec_(Qt.CopyAction)
event.accept()
else:
event.ignore()
def mousePressEvent(self, event):
itemData = QByteArray()
dataStream = QDataStream(itemData, QIODevice.WriteOnly)
dataStream << QByteArray(self.labelText) << QPoint(event.pos() - self.rect().topLeft())
mimeData = QMimeData()
mimeData.setData("application/x-fridgemagnet", itemData)
mimeData.setText(self.labelText)
drag = QDrag(self)
drag.setMimeData(mimeData)
drag.setHotSpot(event.pos() - self.rect().topLeft())
drag.setPixmap(self.pixmap())
self.hide()
if drag.exec_(Qt.MoveAction | Qt.CopyAction, Qt.CopyAction) == Qt.MoveAction:
self.close()
else:
self.show()
def mousePressEvent(self, event):
hotSpot = event.pos()
mimeData = QMimeData()
mimeData.setText(self.text())
mimeData.setData('application/x-hotspot',
'%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()
def copyColoredHtml(self):
cursor = self.textCursor()
if not cursor.hasSelection():
return
s = QSettings()
s.beginGroup("source_export")
number_lines = s.value("number_lines", False, bool)
inline_style = s.value("inline_copy", True, bool)
as_plain_text = s.value("copy_html_as_plain_text", False, bool)
wrap_tag = s.value("wrap_tag", "pre", str)
wrap_attrib = s.value("wrap_attrib", "id", str)
wrap_attrib_name = s.value("wrap_attrib_name", "document", str)
document_body_only = s.value("copy_document_body_only", False, bool)
import highlight2html
html = highlight2html.html_inline(cursor, inline=inline_style, number_lines=number_lines,
full_html=not document_body_only, wrap_tag=wrap_tag, wrap_attrib=wrap_attrib,
wrap_attrib_name=wrap_attrib_name)
data = QMimeData()
data.setText(html) if as_plain_text else data.setHtml(html)
QApplication.clipboard().setMimeData(data)
def mouseMoveEvent(self, evt):
"""
Protected method to handle mouse move events.
@param evt reference to the mouse event (QMouseEvent)
"""
if evt.button() == Qt.LeftButton and \
(evt.pos() - self.__dragStartPos).manhattanLength() > \
QApplication.startDragDistance() and \
self.__browser is not None:
drag = QDrag(self)
mimeData = QMimeData()
title = self.__browser.title()
if title == "":
title = str(self.__browser.url().toEncoded(), encoding="utf-8")
mimeData.setText(title)
mimeData.setUrls([self.__browser.url()])
p = self.pixmap()
if p:
drag.setPixmap(p)
drag.setMimeData(mimeData)
drag.exec_()
def mouseMoveEvent(self, event):
if event.buttons() == Qt.RightButton:
# write the relative cursor position to mime data
mimeData = QMimeData()
# simple string with 'x,y'
mimeData.setText('%d,%d' % (event.x(), event.y()))
# let's make it fancy. we'll show a "ghost" of the button as we drag
# grab the button to a pixmap
pixmap = self.grab()
# below makes the pixmap half transparent
painter = QPainter(pixmap)
painter.setCompositionMode(painter.CompositionMode_DestinationIn)
painter.fillRect(pixmap.rect(), QColor(0, 0, 0, 127))
painter.end()
# make a QDrag
drag = QDrag(self)
# put our MimeData
drag.setMimeData(mimeData)
# set its Pixmap
drag.setPixmap(pixmap)
# shift the Pixmap so that it coincides with the cursor position
drag.setHotSpot(event.pos())
# start the drag operation
# exec_ will return the accepted action from dropEvent
if drag.exec_(Qt.CopyAction | Qt.MoveAction) == Qt.MoveAction:
print('moved')
else:
print('copied:'+str(event.globalPos()))
#self.move(event.pos())
elif event.buttons() == Qt.LeftButton:
delta = QPoint(event.globalPos() - self.oldPos)
self.move(self.frameGeometry().x() + delta.x(), self.frameGeometry().y() + delta.y())
self.oldPos = event.globalPos()
def mimeData(self, indices):
row = -1
for index in indices:
# Only generate mime data on command rows
if (index.row() < 0 or index.row() >= self.mCommands.size()):
return None
# Currently only one row at a time is supported for drags
# Note: we can get multiple indexes in the same row (different columns)
if (row != -1 and index.row() != row):
return None
row = index.row()
command = self.mCommands[row]
mimeData = QMimeData()
# Text data is used if command is dragged to a text editor or terminal
mimeData.setText(command.finalCommand())
# Ptr is used if command is dragged onto another command
# We could store the index instead, the only difference would be that if
# the item is moved or deleted shomehow during the drag, the ptr approach
# will result in a no-op instead of moving the wrong thing.
addr = command
mimeData.setData(commandMimeType, QByteArray(addr, 4))
return mimeData
def mouseMoveEvent(self, mouseEvent):
"""
Executed when the mouse if moved while a button is being pressed.
:type mouseEvent: QMouseEvent
"""
if mouseEvent.buttons() & Qt.LeftButton:
# Exclude edges from drag&drop since we need to source and edge to insert it in the diagram.
if Item.ConceptNode <= self.item <= Item.PropertyAssertionNode:
distance = (mouseEvent.pos() - self.startPos).manhattanLength()
if distance >= QApplication.startDragDistance():
mimeData = QMimeData()
mimeData.setText(str(self.item.value))
drag = QDrag(self)
drag.setMimeData(mimeData)
drag.setPixmap(self.pixmap)
drag.setHotSpot(self.startPos - self.rect().topLeft())
drag.exec_(Qt.CopyAction)
super().mouseMoveEvent(mouseEvent)
def test_pasteText(self):
mimeData = QMimeData()
mimeData.setText('pasted text')
self.editor.insertFromMimeData(mimeData)
self.assertTrue('pasted text' in self.editor.toPlainText())
def mimeWrapJson(data):
data_ = json.dumps(data)
mimeData = QMimeData()
mimeData.setText(data_)
return mimeData
def _handle_copy_text(self):
mime = QMimeData()
mime.setText(self._selected_data)
QApplication.clipboard().setMimeData(mime)
def _handle_copy_hex(self):
mime = QMimeData()
mime.setText(binascii.b2a_hex(self._selected_data))
QApplication.clipboard().setMimeData(mime)
def _handle_copy_hexdump(self):
mime = QMimeData()
t = hexdump.hexdump(self._selected_data, result="return")
mime.setText(t)
QApplication.clipboard().setMimeData(mime)
def _handle_copy_base64(self):
mime = QMimeData()
mime.setText(base64.b64encode(self._selected_data))
QApplication.clipboard().setMimeData(mime)
def createMimeDataFromSelection(self):
"""Reimplemented to only copy plain text."""
m = QMimeData()
m.setText(self.textCursor().selection().toPlainText())
return m
