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 mouseMoveEvent(self, event):
""" If the mouse moves far enough when the left mouse button is held
down, start a drag and drop operation.
"""
if not event.buttons() & Qt.LeftButton:
return
if (event.pos() - self.dragStartPosition).manhattanLength() \
< QApplication.startDragDistance():
return
if not self.hasImage:
return
drag = QDrag(self)
mimeData = QMimeData()
output = QByteArray()
outputBuffer = QBuffer(output)
outputBuffer.open(QIODevice.WriteOnly)
self.imageLabel.pixmap().toImage().save(outputBuffer, 'PNG')
outputBuffer.close()
mimeData.setData('image/png', output)
drag.setMimeData(mimeData)
drag.setPixmap(self.imageLabel.pixmap().scaled(64, 64, Qt.KeepAspectRatio))
drag.setHotSpot(QPoint(drag.pixmap().width() / 2,
drag.pixmap().height()))
drag.start()
def mouseMoveEvent(self, QMouseEvent):
if self.mMoveing and (QMouseEvent.buttons() and Qt.LeftButton) and (
QMouseEvent.globalPos() - self.mMovePosition
).manhattanLength() > QApplication.startDragDistance():
self.move(QMouseEvent.globalPos() - self.mMovePosition)
self.mMovePosition = QMouseEvent.globalPos() - self.pos()
return super().mouseMoveEvent(QMouseEvent)
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 (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):
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 mouseMoveEvent(self, event):
""" If the mouse moves far enough when the left mouse button is held
down, start a drag and drop operation.
"""
if not event.buttons() & Qt.LeftButton:
return
if (event.pos() - self.dragStartPosition).manhattanLength() \
< QApplication.startDragDistance():
return
if not self.hasImage:
return
drag = QDrag(self)
mimeData = QMimeData()
output = QByteArray()
outputBuffer = QBuffer(output)
outputBuffer.open(QIODevice.WriteOnly)
self.imageLabel.pixmap().toImage().save(outputBuffer, 'PNG')
outputBuffer.close()
mimeData.setData('image/png', output)
drag.setMimeData(mimeData)
drag.setPixmap(self.imageLabel.pixmap().scaled(64, 64, Qt.KeepAspectRatio))
drag.setHotSpot(QPoint(drag.pixmap().width() / 2,
drag.pixmap().height()))
drag.start()
def mouseMoveEvent(self, event):
'''
@param: event QMouseEvent
'''
if not self._locationBar or event.buttons() != Qt.LeftButton:
super().mouseMoveEvent(event)
return
manhattanLength = (event.pos() -
self._drawStartPosition).manhattanLength()
if manhattanLength <= QApplication.startDragDistance():
super().mouseMoveEvent(event)
return
url = self._locationBar.webView().url()
title = self._locationBar.webView().title()
if url.isEmpty() or not title:
super().mouseMoveEvent(event)
return
drag = QDrag(self)
mime = QMimeData()
mime.setUrls([url])
mime.setText(title)
mime.setImageData(self.icon.pixmap(16).toImage())
drag.setMimeData(mime)
drag.setPixmap(
gVar.appTools.createPixmapForSite(self.icon, title,
url.toString()))
drag.exec_()
# Restore Down State
self.setDown(False)
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 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 not (event.buttons() & Qt.LeftButton):
return
delta = event.pos() - self.drag_start_position
if delta.manhattanLength() < QApplication.startDragDistance():
return
self.verticalScrollBar().setValue(self.original_y - delta.y() * 1.5)
self.horizontalScrollBar().setValue(self.original_x - delta.x() * 1.5)
def mouseMoveEvent(self, event):
drag_distance = QLineF(event.screenPos(), event.buttonDownScreenPos(Qt.LeftButton)).length()
if drag_distance < QApplication.startDragDistance():
return
self.isTaken = True
self.select(False)
self.taken.emit()
self.drag(event.widget())
def mouseMoved(self, pos, modifiers):
super().mouseMoved(pos, modifiers)
# Update the hovered item (for mouse cursor)
hoveredRotateHandle = None
hoveredResizeHandle = None
hoveredObjectItem = None
view = self.mapScene().views()[0]
if view:
hoveredItem = self.mapScene().itemAt(pos, view.transform())
hoveredRotateHandle = None
hoveredResizeHandle = None
tp = type(hoveredItem)
if tp == RotateHandle:
hoveredRotateHandle = hoveredItem
elif tp == ResizeHandle:
hoveredResizeHandle = hoveredItem
if (not hoveredRotateHandle and not hoveredResizeHandle):
hoveredObjectItem = self.topMostObjectItemAt(pos)
self.mHoveredObjectItem = hoveredObjectItem
if (self.mAction == Action.NoAction and self.mMousePressed):
screenPos = QCursor.pos()
dragDistance = (self.mScreenStart - screenPos).manhattanLength()
if (dragDistance >= QApplication.startDragDistance()):
hasSelection = not self.mapScene().selectedObjectItems(
).isEmpty()
# Holding Alt forces moving current selection
# Holding Shift forces selection rectangle
if ((self.mClickedObjectItem or
(modifiers & Qt.AltModifier) and hasSelection)
and not (modifiers & Qt.ShiftModifier)):
self.startMoving(modifiers)
elif (self.mClickedRotateHandle):
self.startRotating()
elif (self.mClickedResizeHandle):
self.startResizing()
else:
self.startSelecting()
x = self.mAction
if x == Action.Selecting:
self.mSelectionRectangle.setRectangle(
QRectF(self.mStart, pos).normalized())
elif x == Action.Moving:
self.updateMovingItems(pos, modifiers)
elif x == Action.Rotating:
self.updateRotatingItems(pos, modifiers)
elif x == Action.Resizing:
self.updateResizingItems(pos, modifiers)
elif x == Action.NoAction:
pass
self.refreshCursor()
def mouseMoveEvent(self, ev):
diff = self._startpos - ev.globalPos()
if self._mode == MOVE:
self._startpos = ev.globalPos()
h = self.viewer.horizontalScrollBar()
v = self.viewer.verticalScrollBar()
h.setValue(h.value() + diff.x())
v.setValue(v.value() + diff.y())
elif self._mode == DRAG and diff.manhattanLength() >= QApplication.startDragDistance():
self.viewer.startDrag()
def mouseMoveEvent(self, event):
if not (event.buttons() & Qt.LeftButton):
return
if (event.pos() - self.dragStartPosition
).manhattanLength() < QApplication.startDragDistance():
return
drag = QtGui.QDrag(self)
mimeData = QtCore.QMimeData()
mimeData.setText(self.text())
drag.setMimeData(mimeData)
drag.exec_(Qt.CopyAction)
def mouseMoveEvent(self, evt):
"""
Protected method to handle mouse moves.
@param evt mouse move event (QMouseEvent)
"""
if (self.__mouseClickPoint != QPoint(0, 0)
and (evt.pos() - self.__mouseClickPoint).manhattanLength() >
QApplication.startDragDistance()):
self.__mouseClickPoint = QPoint(0, 0)
self.startDrag.emit()
def mouseMoveEvent(self, evt):
"""
Protected method to handle mouse moves.
@param evt mouse move event (QMouseEvent)
"""
if self.__mouseClickPoint != QPoint(0, 0) and \
(evt.pos() - self.__mouseClickPoint).manhattanLength() > \
QApplication.startDragDistance():
self.__mouseClickPoint = QPoint(0, 0)
self.startDrag.emit()
def mouseMoveEvent(self, event):
if event.buttons() & Qt.LeftButton:
threshold = event.windowPos() - self.__drag_start_position
if threshold.manhattanLength() < QApplication.startDragDistance():
return
point = event.windowPos()
for figure in self.__figures_list:
figure.on_drag(point)
self.update()
def mouseMoveEvent(self, event):
if (event.buttons() & Qt.LeftButton and self._dragstartpos is not None
and (event.pos() - self._dragstartpos).manhattanLength() >=
QApplication.startDragDistance()):
column = self.logicalIndexAt(self._dragstartpos)
data = [column, self.model().headerData(column, Qt.Horizontal)]
self._dragstartpos = None
drag = QDrag(self)
drag.setMimeData(self.encodeMimeData([data]))
action = drag.exec(Qt.MoveAction)
if action != Qt.IgnoreAction:
self.setColumnHidden(column, True)
def mouseMoved(self, pos, modifiers):
super().mouseMoved(pos, modifiers)
# Update the hovered item (for mouse cursor)
hoveredRotateHandle = None
hoveredResizeHandle = None
hoveredObjectItem = None
view = self.mapScene().views()[0]
if view:
hoveredItem = self.mapScene().itemAt(pos,view.transform())
hoveredRotateHandle = None
hoveredResizeHandle = None
tp = type(hoveredItem)
if tp==RotateHandle:
hoveredRotateHandle = hoveredItem
elif tp==ResizeHandle:
hoveredResizeHandle = hoveredItem
if (not hoveredRotateHandle and not hoveredResizeHandle):
hoveredObjectItem = self.topMostObjectItemAt(pos)
self.mHoveredObjectItem = hoveredObjectItem
if (self.mAction == Action.NoAction and self.mMousePressed):
screenPos = QCursor.pos()
dragDistance = (self.mScreenStart - screenPos).manhattanLength()
if (dragDistance >= QApplication.startDragDistance()):
hasSelection = not self.mapScene().selectedObjectItems().isEmpty()
# Holding Alt forces moving current selection
# Holding Shift forces selection rectangle
if ((self.mClickedObjectItem or (modifiers & Qt.AltModifier) and hasSelection) and not (modifiers & Qt.ShiftModifier)):
self.startMoving(modifiers)
elif (self.mClickedRotateHandle):
self.startRotating()
elif (self.mClickedResizeHandle):
self.startResizing()
else:
self.startSelecting()
x = self.mAction
if x==Action.Selecting:
self.mSelectionRectangle.setRectangle(QRectF(self.mStart, pos).normalized())
elif x==Action.Moving:
self.updateMovingItems(pos, modifiers)
elif x==Action.Rotating:
self.updateRotatingItems(pos, modifiers)
elif x==Action.Resizing:
self.updateResizingItems(pos, modifiers)
elif x==Action.NoAction:
pass
self.refreshCursor()
def mouseMoveEvent(self, event):
super().mouseMoveEvent(event)
if (event.buttons() == Qt.LeftButton
and self.left_start is not None and
(event.globalPos() - self.left_start).manhattanLength() >=
QApplication.startDragDistance()):
self.drag_start.emit()
mime = QMimeData()
drag = QDrag(self)
drag.setMimeData(mime)
self.left_start = None
drag.exec_(Qt.MoveAction)
self.drag_stop.emit()
def mouseMoveEvent(self, event):
super(TileView, self).mouseMoveEvent(event)
# If the button is a right click and it has moved a predetermined distance from the start point, then start
# a drag operation
if (event.buttons() & Qt.RightButton) and ((event.pos() - self.dragStartPosition).manhattanLength() >=
QApplication.startDragDistance()):
# Select the current index since that is what we are wanting to drag that one most likely
selectedItem = self.indexAt(event.pos())
if selectedItem is not None:
self.selectionModel().select(selectedItem, QItemSelectionModel.Select)
self.startDrag(Qt.ActionMask)
def mouseMoveEvent(self, event: QMouseEvent):
if not self.ifValidPress:
return
if not event.buttons() & Qt.LeftButton:
return
if (event.pos() - self.dragStartPoint
).manhattanLength() < QApplication.startDragDistance():
return
self.lineLabel.show()
self.doDrag()
self.lineLabel.hide()
self.ifValidPress = False
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 mouseMoveEvent(self, event: QMouseEvent) -> None:
if not (event.buttons().__int__() & Qt.LeftButton):
return
dist = QPoint(event.pos() - self.__dragStartPosition).manhattanLength()
if dist < QApplication.startDragDistance():
return
drag = QDrag(self)
mimeData = QMimeData()
self.setDataToMime(mimeData)
drag.setMimeData(mimeData)
# drag.setHotSpot(event.pos() - )
dropAction = drag.exec()
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 mouseMoveEvent(self, evt):
"""
Protected method to handle mouse move events.
@param evt reference to the event (QMouseEvent)
"""
if self.__model is None:
super(E5ModelMenu, self).mouseMoveEvent(evt)
return
if not (evt.buttons() & Qt.LeftButton):
super(E5ModelMenu, self).mouseMoveEvent(evt)
return
if self.__dragStartPosition.isNull():
super(E5ModelMenu, self).mouseMoveEvent(evt)
return
manhattanLength = (evt.pos() -
self.__dragStartPosition).manhattanLength()
if manhattanLength <= QApplication.startDragDistance():
super(E5ModelMenu, self).mouseMoveEvent(evt)
return
act = self.actionAt(self.__dragStartPosition)
if act is None:
super(E5ModelMenu, self).mouseMoveEvent(evt)
return
idx = self.index(act)
if not idx.isValid():
super(E5ModelMenu, self).mouseMoveEvent(evt)
return
drag = QDrag(self)
drag.setMimeData(self.__model.mimeData([idx]))
actionRect = self.actionGeometry(act)
drag.setPixmap(self.grab(actionRect))
if drag.exec_() == Qt.MoveAction:
row = idx.row()
if self.__dropIndex == idx.parent() and self.__dropRow <= row:
row += 1
self.__model.removeRow(row, self.__root)
if not self.isAncestorOf(drag.target()):
self.close()
else:
self.aboutToShow.emit()
def maybeExecuteDrag(self, event):
if self._maybeDragPosition is None:
return False
if (event.localPos() - self._maybeDragPosition).manhattanLength() \
< QApplication.startDragDistance():
return False
drag = QDrag(self)
glyphs = self.glyphsForIndexes(self.selection())
mimeData = GlyphsMimeData()
mimeData.setGlyphs(glyphs)
drag.setMimeData(mimeData)
drag.exec_()
self._maybeDragPosition = None
return True
def mouseMoveEvent(self, event):
super().mouseMoveEvent(event)
if (
event.buttons() == Qt.LeftButton and
self.left_start is not None and
(event.globalPos() - self.left_start).manhattanLength() >=
QApplication.startDragDistance()
):
self.drag_start.emit()
mime = QMimeData()
drag = QDrag(self)
drag.setMimeData(mime)
self.left_start = None
drag.exec_(Qt.MoveAction)
self.drag_stop.emit()
def mouseMoveEvent(self, event):
if not (event.buttons() & Qt.LeftButton):
return
if ((event.pos() - self.drag_start_position).manhattanLength() <
QApplication.startDragDistance()):
return
drag = QDrag(self)
mimedata = QMimeData()
mimedata.valor = self.valor
mimedata.posicion = self.posicion
mimedata.setImageData(self.pixmap().toImage())
drag.setMimeData(mimedata)
drag.setPixmap(self.fondo_item)
drag.setHotSpot(event.pos())
drag.exec_(Qt.CopyAction | Qt.MoveAction)
def maybeExecuteDrag(self, event):
if self._maybeDragPosition is None:
return False
if (event.localPos() - self._maybeDragPosition
).manhattanLength() < QApplication.startDragDistance():
return False
drag = QDrag(self)
glyphs = self.glyphsForIndexes(self.selection())
mimeData = GlyphsMimeData()
mimeData.setGlyphs(glyphs)
drag.setMimeData(mimeData)
drag.exec_()
self._maybeDragPosition = None
return True
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 mouseMoveEvent(self, evt):
"""
Protected method to handle mouse move events.
@param evt reference to the event (QMouseEvent)
"""
if self.__model is None:
super(E5ModelMenu, self).mouseMoveEvent(evt)
return
if not (evt.buttons() & Qt.LeftButton):
super(E5ModelMenu, self).mouseMoveEvent(evt)
return
manhattanLength = (evt.pos() -
self.__dragStartPosition).manhattanLength()
if manhattanLength <= QApplication.startDragDistance():
super(E5ModelMenu, self).mouseMoveEvent(evt)
return
act = self.actionAt(self.__dragStartPosition)
if act is None:
super(E5ModelMenu, self).mouseMoveEvent(evt)
return
idx = self.index(act)
if not idx.isValid():
super(E5ModelMenu, self).mouseMoveEvent(evt)
return
drag = QDrag(self)
drag.setMimeData(self.__model.mimeData([idx]))
actionRect = self.actionGeometry(act)
if qVersion() >= "5.0.0":
drag.setPixmap(self.grab(actionRect))
else:
drag.setPixmap(QPixmap.grabWidget(self, actionRect))
if drag.exec_() == Qt.MoveAction:
row = idx.row()
if self.__dropIndex == idx.parent() and self.__dropRow <= row:
row += 1
self.__model.removeRow(row, self.__root)
if not self.isAncestorOf(drag.target()):
self.close()
else:
self.aboutToShow.emit()
def mouseMoveEvent(self, event):
if not (event.buttons() & Qt.LeftButton):
return
if (event.pos() - self.drag_start_position
).manhattanLength() < QApplication.startDragDistance():
return
if self.selectedItems():
self.selected = self.selectedItems()
if not self.selected:
return
drag = QDrag(self)
mimedata = QMimeData()
mimedata.setText(UNIT_EDITOR_UNIT +
str(self.itemWidget(self.selected[0]).card_ids))
drag.setMimeData(mimedata)
drag.exec_(Qt.CopyAction | Qt.MoveAction)
def mouseMoveEvent(self, event):
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())
drag.setMimeData(mimedata)
pixmap = QPixmap(self.size())
painter = QPainter(pixmap)
painter.drawPixmap(self.rect(), self.grab())
painter.end()
drag.setPixmap(pixmap)
drag.setHotSpot(event.pos())
drag.exec_(Qt.CopyAction | Qt.MoveAction)
def mouseMoveEvent(self, event):
if event.buttons() & Qt.RightButton:
if (event.pos() - self.dragStartPosition
).manhattanLength() < QApplication.startDragDistance():
return
else:
# Initiate "swap photos" action
# Pass source PhotoFrameItem coordinates in json format
drag = QDrag(event.widget())
mimeData = QMimeData()
mimeData.setText('{ "pos": { "x" : %f, "y" : %f }}' %
(event.scenePos().x(), event.scenePos().y()))
drag.setMimeData(mimeData)
dropAction = drag.exec_(Qt.MoveAction)
logger.debug('dropAction=%s', str(dropAction))
else:
super(PhotoItem, self).mouseMoveEvent(event)
def mouseMoveEvent(self, event):
if QLineF(event.screenPos(),
event.buttonDownScreenPos(Qt.LeftButton)).length() < \
QApplication.startDragDistance():
return
drag = QDrag(event.widget())
mime = QMimeData()
drag.setMimeData(mime)
mime.setImageData(REDDISK)
dragImg = REDDISK.scaled(40, 40, Qt.KeepAspectRatio)
drag.setPixmap(QPixmap.fromImage(dragImg))
drag.setHotSpot(QPoint(dragImg.width() / 2, dragImg.height()/ 2))
drag.exec()
self.setCursor(Qt.OpenHandCursor)
def mouseMoveEvent(self, event: QtGui.QMouseEvent):
if not (event.buttons() & QtCore.Qt.LeftButton):
return
if (event.pos() - self.drag_start_position
).manhattanLength() < QApplication.startDragDistance():
return
drag = QtGui.QDrag(self)
mimedata = QtCore.QMimeData()
mimedata.setData('Checker', bytearray('Checker', 'utf8'))
mimedata.setProperty('offset', QPoint(event.x(), event.y()))
drag.setMimeData(mimedata)
drag.setDragCursor(QPixmap('./assets/emptyCursor.png'),
QtCore.Qt.MoveAction)
drag.setPixmap(self.pixmap())
drag.setHotSpot(event.pos())
self.hide()
drag.exec_(Qt.CopyAction | Qt.MoveAction)
def mouseMoveEvent(self, event):
""" Catch mouseMoveEvent and start dragging when needed. """
if not self.dragging:
diff = (event.pos() - self.start).manhattanLength()
if diff > QApplication.startDragDistance():
self.dock.setStyleSheet(self.dragSty)
drag = QDrag(self)
drag.setMimeData(QMimeData())
pixmap = self.dock.grab()
x, y = (pixmap.width() * 0.8, pixmap.height() * 0.8)
drag.setPixmap(pixmap.scaled(QSize(x, y)))
drag.setHotSpot(QPoint(x/2, y/2))
self.update()
drag.exec_()
self.dock.setStyleSheet(self.noDragSty)
self.dragging = True
event.accept()
def mouseMoved(self, pos, modifiers):
super().mouseMoved(pos, modifiers)
if (self.mMode == EditPolygonTool.NoMode and self.mMousePressed):
screenPos = QCursor.pos()
dragDistance = (self.mScreenStart - screenPos).manhattanLength()
if (dragDistance >= QApplication.startDragDistance()):
if (self.mClickedHandle):
self.startMoving()
else:
self.startSelecting()
x = self.mMode
if x==EditPolygonTool.Selecting:
self.mSelectionRectangle.setRectangle(QRectF(self.mStart, pos).normalized())
elif x==EditPolygonTool.Moving:
self.updateMovingItems(pos, modifiers)
elif x==EditPolygonTool.NoMode:
pass
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, 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 (
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:
root = QFileInfo(__file__).absolutePath()
image = QImage(root + "/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 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 mouseMoved(self, widget, pos):
if (self._dragpos is not None
and (pos - self._dragpos).manhattanLength()
>= QApplication.startDragDistance()):
self.startDrag(widget)
return True
def mouseMoveEvent(self, mouseEvent):
"""
Executed when then mouse is moved on the view.
:type mouseEvent: QGraphicsSceneMouseEvent
"""
scene = self.scene()
mousePos = mouseEvent.pos()
mouseButtons = mouseEvent.buttons()
viewport = self.viewport()
if mouseButtons & Qt.RightButton:
if (mouseEvent.pos() - self.mousePressPos).manhattanLength() >= QApplication.startDragDistance():
########################################################################################################
# #
# SCENE DRAG #
# #
########################################################################################################
if scene.mode is not DiagramMode.SceneDrag:
scene.setMode(DiagramMode.SceneDrag)
viewport.setCursor(Qt.ClosedHandCursor)
mousePos /= self.zoom
mousePressPos = self.mousePressPos / self.zoom
self.centerOn(self.mousePressCenterPos - mousePos + mousePressPos)
else:
super().mouseMoveEvent(mouseEvent)
if mouseButtons & Qt.LeftButton:
self.stopMove()
if scene.mode is DiagramMode.RubberBandDrag:
####################################################################################################
# #
# RUBBERBAND DRAG #
# #
####################################################################################################
area = QRectF(self.mapFromScene(self.rubberBandOrigin), mousePos).normalized()
path = QPainterPath()
path.addRect(area)
scene.setSelectionArea(self.mapToScene(path))
self.rubberBand.setGeometry(area.toRect())
if scene.mode in { DiagramMode.BreakPointMove,
DiagramMode.InsertEdge,
DiagramMode.MoveNode,
DiagramMode.ResizeNode,
DiagramMode.RubberBandDrag }:
####################################################################################################
# #
# VIEW SCROLLING #
# #
####################################################################################################
R = viewport.rect()
if not R.contains(mousePos):
move = QPointF(0, 0)
if mousePos.x() < R.left():
move.setX(mousePos.x() - R.left())
elif mousePos.x() > R.right():
move.setX(mousePos.x() - R.right())
if mousePos.y() < R.top():
move.setY(mousePos.y() - R.top())
elif mousePos.y() > R.bottom():
move.setY(mousePos.y() - R.bottom())
if move:
move.setX(clamp(move.x(), -MainView.MoveBound, +MainView.MoveBound))
move.setY(clamp(move.y(), -MainView.MoveBound, +MainView.MoveBound))
self.startMove(move, MainView.MoveRate)
