def run(self):
# Try to connect to an incoming tcp socket using its socket descriptor
tcpSocket = QTcpSocket()
if not tcpSocket.setSocketDescriptor(self.socketDescriptor):
FreeCAD.Console.PrintError("Socket not accepted.\n")
return
FreeCAD.Console.PrintLog("Socket accepted.\n")
# Wait for an incoming message
if not tcpSocket.waitForReadyRead(msecs=WAIT_TIME_MS):
FreeCAD.Console.PrintError("No request send.\n")
return
# Make an input data stream
instr = QDataStream(tcpSocket)
instr.setVersion(QDataStream.Qt_4_0)
# Try to read the message size
if self.blockSize == 0:
if tcpSocket.bytesAvailable() < 2:
FreeCAD.Console.PrintError("Received message "
+ "has too few bytes.\n")
return
self.blockSize = instr.readUInt16()
# Check message is sent complete
if tcpSocket.bytesAvailable() < self.blockSize:
FreeCAD.Console.PrintError("Received message has less bytes "
+ "then it's supposed to.\n")
return
# Read message and inform about it
cmd = instr.readRawData(self.blockSize).decode("UTF-8")
FreeCAD.Console.PrintLog("CommandServer received> "
+ cmd + "\n")
# Try to execute the message string and prepare a response
try:
exec(cmd)
except Exception as e:
FreeCAD.Console.PrintError("Executing external command failed:"
+ str(e) + "\n")
message = "Command failed - " + str(e)
else:
FreeCAD.Console.PrintLog("Executing external command succeeded!\n")
message = COMMAND_EXECUTED_CONFIRMATION_MESSAGE
# Prepare the data block to send back and inform about it
FreeCAD.Console.PrintLog("CommandServer sending> " + message + " \n")
block = QByteArray(
len(message.encode("UTF-8")).to_bytes(2, byteorder='big')
+ message.encode("UTF-8"))
outstr = QDataStream(block, QIODevice.WriteOnly)
outstr.setVersion(QDataStream.Qt_4_0)
# Send the block, disconnect from the socket and terminate the QThread
tcpSocket.write(block)
tcpSocket.disconnectFromHost()
tcpSocket.waitForDisconnected()
def setUp(self):
super(QPixmapQDatastream, self).setUp()
self.source_pixmap = QPixmap(100, 100)
self.source_pixmap.fill(Qt.red)
self.output_pixmap = QPixmap()
self.buffer = QByteArray()
self.read_stream = QDataStream(self.buffer, QIODevice.ReadOnly)
self.write_stream = QDataStream(self.buffer, QIODevice.WriteOnly)
def run(self):
# Try to connect to an incomming tcp socket using its socket descriptor
tcpSocket = QTcpSocket()
if not tcpSocket.setSocketDescriptor(self.socketDescriptor):
FreeCAD.Console.PrintError("Socket not accepted.\n")
return
# Wait for an incomming message
if not tcpSocket.waitForReadyRead(msecs=WAIT_TIME_MS):
FreeCAD.Console.PrintError("No request send.\n")
return
# Make an input data stream
instr = QDataStream(tcpSocket)
instr.setVersion(QDataStream.Qt_4_0)
# Try to read the message size
if self.blockSize == 0:
if tcpSocket.bytesAvailable() < 2:
return
self.blockSize = instr.readUInt16()
# Check message is sent complete
if tcpSocket.bytesAvailable() < self.blockSize:
return
# Read message and inform about it
instr = instr.readString()
FreeCAD.Console.PrintLog("CommandServer received> " + str(instr) +
"\n")
# Try to execute the message string and prepare a response
try:
exec(str(instr))
except Exception as e:
FreeCAD.Console.PrintError("Executing external command failed:" +
str(e) + "\n")
message = "Command failed - " + str(e)
else:
FreeCAD.Console.PrintLog("Executing external command succeded!\n")
message = COMMAND_EXECUTED_CONFIRMATION_MESSAGE
# Prepare the data block to send back and inform about it
FreeCAD.Console.PrintLog("CommandServer sending> " + message + " \n")
block = QByteArray()
outstr = QDataStream(block, QIODevice.WriteOnly)
outstr.setVersion(QDataStream.Qt_4_0)
outstr.writeUInt16(0)
outstr.writeQString(message)
outstr.device().seek(0)
outstr.writeUInt16(block.size() - 2)
# Send the block, disconnect from the socket and terminate the QThread
tcpSocket.write(block)
tcpSocket.disconnectFromHost()
tcpSocket.waitForDisconnected()
def testRawData(self):
data = QDataStream()
self.assertEqual(data.readRawData(4), None)
ba = QByteArray()
data = QDataStream(ba, QIODevice.WriteOnly)
data.writeRawData('AB\x00C')
self.assertEqual(ba.data(), py3k.b('AB\x00C'))
data = QDataStream(ba)
self.assertEqual(data.readRawData(4), py3k.b('AB\x00C'))
def run(self):
self.mutex.lock()
serverName = self.hostName
serverPort = self.port
self.mutex.unlock()
while not self.quit:
Timeout = 5 * 1000
socket = QTcpSocket()
socket.connectToHost(serverName, serverPort)
if not socket.waitForConnected(Timeout):
self.error.emit(socket.error(), socket.errorString())
return
while socket.bytesAvailable() < 2:
if not socket.waitForReadyRead(Timeout):
self.error.emit(socket.error(), socket.errorString())
return
instr = QDataStream(socket)
instr.setVersion(QDataStream.Qt_4_0)
blockSize = instr.readUInt16()
block = QByteArray()
outstr = QDataStream(block, QIODevice.WriteOnly)
outstr.setVersion(QDataStream.Qt_4_0)
while socket.bytesAvailable() < blockSize:
if not socket.waitForReadyRead(Timeout):
self.error.emit(socket.error(), socket.errorString())
return
self.mutex.lock()
outstr.writeUInt16(0)
outstr.writeQString("Message to Server")
outstr.device().seek(0)
outstr.writeUInt16(block.size() - 2)
socket.write(block)
# socket.write(block)
fortune = instr.readQString()
self.newFortune.emit(fortune)
self.cond.wait(self.mutex)
serverName = self.hostName
serverPort = self.port
self.mutex.unlock()
def __init__(self, parent=None):
super(NetworkConnectionClass, self).__init__(parent=parent)
#self.CommandSocket = QTcpSocket()
self.CommandSocket = QUdpSocket()
self.CommandSocket.bind(QHostAddress("192.168.100.2"), 2323)
self.CommandSocket.connected.connect(self.EventConnectedHandle)
self.CommandSocket.readyRead.connect(self.RecieveData)
#self.CommandSocket.connectToHost("192.168.100.5",2323,QIODevice.ReadWrite)
#self.CommandSocket.connectToHost("127.0.0.1",2323,QIODevice.ReadWrite)
#self.CommandSocket.connectToHost("192.168.20.196",2323,QIODevice.ReadWrite)
#print("NETWORK - ",self.CommandSocket.localAddress(),self.CommandSocket.peerAddress())
self.Display = WindowNetworkConnection()
self.NetworkDataArray = QByteArray()
self.NetworkDataArray.resize(2000)
self.SignalDataRec.connect(self.Display.PrintData)
self.BufferWrite = QBuffer(self.NetworkDataArray)
self.BufferWrite.open(QBuffer.WriteOnly)
self.BufferRead = QBuffer(self.NetworkDataArray)
self.BufferRead.open(QBuffer.ReadOnly)
self.ReadDataStream = QDataStream(self.BufferRead)
self.ReadDataStream.setByteOrder(QDataStream.LittleEndian)
self.WriteDataStream = QDataStream(self.BufferWrite)
self.WriteDataStream.setByteOrder(QDataStream.LittleEndian)
self.SocketDataStream = QDataStream(self.CommandSocket)
self.SocketDataStream.setByteOrder(QDataStream.LittleEndian)
self.Timer = QTime()
self.Timer.start()
self.BufferRead.seek(0)
self.BufferWrite.seek(0)
self.LimitBufferSize = 2000
self.MinTransferUnit = 7
self.MaxTransferUnit = 18
self.bytesAvailable = 0
self.Display.ui.pushButton.clicked.connect(self.SendData)
#===================================================== WRITE BUFFER
self.SendBuffer = QByteArray()
def saveStackToFile(self, filename):
qf = QFile(filename)
if not qf.open(QIODevice.WriteOnly):
raise IOError('cannot open file %s' % filename)
dataStream = QDataStream(qf)
self.writeStackToStream(dataStream)
qf.close()
def start(self):
self._sender = self._socket.peerAddress()
stream = QDataStream(self._socket)
if (self._file_size == 0):
if (self._socket.bytesAvailable() < getsizeof(int)):
return
self._file_size = stream.readUInt32()
if (self._socket.bytesAvailable() < self._file_size):
return
self._file_name = stream.readString()
line = QByteArray()
line = self._socket.readAll()
directory = Path(Setup().get_download_dir())
if not (directory.exists() and directory.is_dir()):
directory.mkdir()
self._receiving_file = QFile(Setup().get_download_dir() +
str(self._file_name))
print(Setup().get_download_dir() + str(self._file_name))
if not (self._receiving_file.open(QIODevice.WriteOnly)):
print("can't open file")
return
self._receiving_file.write(line)
self._receiving_file.close()
self._socket.disconnectFromHost()
print("finished")
return self._receiving_file
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 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 send_file(self):
self._transaction.set_status(TransactionStatus.SENDING)
file_to_byte_array = QByteArray()
data = QByteArray()
stream = QDataStream(data, QIODevice.WriteOnly)
QFile.open(self._file, QIODevice.ReadOnly)
stream.writeUInt32(0)
stream.writeString(self._file_name)
print("size of name ", getsizeof(self._file_name))
file_to_byte_array = self._file.readAll()
data.append(file_to_byte_array)
self._file.close()
stream.device().seek(0)
stream.writeUInt32(data.size() - getsizeof(self._file_name))
print("total ", data.size() - getsizeof(self._file_name))
x = 0
while (x < data.size()):
y = self._socket.write(data)
print("poslato ", y)
x += y
print("x ", x)
self._transaction.set_status(TransactionStatus.FINISHED)
def loadStackFromFile(self, filename):
qf = QFile(filename)
if not qf.open(QIODevice.ReadOnly):
raise IOError('cannot open file %s' % filename)
dataStream = QDataStream(qf)
script = self.readStackFromStream(dataStream)
#qf.close()
return script, qf, dataStream
def sendClientCommand(host, port, cmd, wait_time=WAIT_TIME_MS):
# Try to connect to a host server
tcpSocket = QTcpSocket()
tcpSocket.connectToHost(host, port, QIODevice.ReadWrite)
if not tcpSocket.waitForConnected(msecs=wait_time):
return CLIENT_ERROR_NO_CONNECTION
# Prepare a command message to be sent
block = QByteArray()
outstr = QDataStream(block, QIODevice.WriteOnly)
outstr.setVersion(QDataStream.Qt_4_0)
outstr.writeUInt16(0)
outstr.writeQString(cmd)
outstr.device().seek(0)
outstr.writeUInt16(block.size() - 2)
tcpSocket.write(block)
# Try to send the message
if not tcpSocket.waitForBytesWritten(msecs=wait_time):
return CLIENT_ERROR_BLOCK_NOT_WRITTEN
# Wait for a response from the host server
if not tcpSocket.waitForReadyRead(msecs=10000):
return CLIENT_ERROR_NO_RESPONSE
# Try to read the response
instr = QDataStream(tcpSocket)
instr.setVersion(QDataStream.Qt_4_0)
blockSize = 0
if blockSize == 0:
if tcpSocket.bytesAvailable() < 2:
return CLIENT_ERROR_RESPONSE_NOT_COMPLETE
blockSize = instr.readUInt16()
if tcpSocket.bytesAvailable() < blockSize:
return CLIENT_ERROR_RESPONSE_NOT_COMPLETE
# Wait until the host server terminates the connection
tcpSocket.waitForDisconnected()
# Return value representing a command execution status
if instr.readString() == COMMAND_EXECUTED_CONFIRMATION_MESSAGE:
return CLIENT_COMMAND_EXECUTED
else:
return CLIENT_COMMAND_FAILED
def _check_bitarray(self, data_set):
'''Check the >> operator for the given data set'''
for data, expectedStatus, expectedString in data_set:
stream = QDataStream(data, QIODevice.ReadOnly)
string = QBitArray()
stream >> string
self.assertEqual(stream.status(), expectedStatus)
self.assertEqual(string.size(), expectedString.size())
self.assertEqual(string, expectedString)
def SendData(self):
Req = ConnectCheckRequest()
self.SendBuffer.clear()
self.SendBuffer.resize(Req.MESSAGE_SIZE)
WriteDataStream = QDataStream(self.SendBuffer, QIODevice.ReadWrite)
WriteDataStream.setByteOrder(QDataStream.LittleEndian)
Req >> WriteDataStream
self.CommandSocket.write(self.SendBuffer)
self.CommandSocket.waitForBytesWritten(20)
self.SignalDataRec.emit("CHECK CONNECT - " + str(Req.Connect), 1)
def MoveDCMotors(self, MotorsSpeed: DC_Motor_Control_Data):
self.STEP_MOTOR_COMMAND = QByteArray()
stream = QDataStream(self.STEP_MOTOR_COMMAND,
QtCore.QIODevice.ReadWrite)
stream.writeInt8(self.MotorsState.HEADER_B1)
stream.writeInt8(self.MotorsState.HEADER_B2)
stream.writeInt8(self.MotorsState.UNIT_SIZE)
stream.writeInt16(self.MotorsState.Speed1)
stream.writeInt16(self.MotorsState.Speed2)
stream.writeInt16(self.MotorsState.Speed3)
stream.writeInt16(self.MotorsState.Speed4)
def restoreGeometry(self, geometry):
"""
Restores the geometry of this subwindow
:param geometry: the saved state as a QByteArray instance
:return:
"""
if geometry.size() < 4:
return False
stream = QDataStream(geometry)
if stream.readUInt32() != 0x1D9D0CB:
return False
if stream.readUInt16() != 1:
return False
stream.readUInt16() # minorVersion is ignored.
x = stream.readInt64()
y = stream.readInt64()
width = stream.readInt64()
height = stream.readInt64()
restoredFrameGeometry = QRect(x, y, width, height)
x = stream.readInt64()
y = stream.readInt64()
width = stream.readInt64()
height = stream.readInt64()
restoredNormalGeometry = QRect(x, y, width, height)
maximized = stream.readUInt32()
fullScreen = stream.readUInt32()
frameHeight = 20
if not restoredFrameGeometry.isValid():
restoredFrameGeometry = QRect(QPoint(0, 0), self.sizeHint())
if not restoredNormalGeometry.isValid():
restoredNormalGeometry = QRect(QPoint(0, frameHeight),
self.sizeHint())
restoredFrameGeometry.moveTop(max(restoredFrameGeometry.top(), 0))
restoredNormalGeometry.moveTop(
max(restoredNormalGeometry.top(), 0 + frameHeight))
if maximized or fullScreen:
self.setGeometry(restoredNormalGeometry)
ws = self.windowState()
if maximized:
ws |= Qt.WindowMaximized
if fullScreen:
ws |= Qt.WindowFullScreen
self.setWindowState(ws)
else:
offset = QPoint()
self.setWindowState(self.windowState()
& ~(Qt.WindowMaximized | Qt.WindowFullScreen))
self.move(restoredFrameGeometry.topLeft() + offset)
self.resize(restoredNormalGeometry.size())
return True
def send_data_old_main_board(self):
datagram = QByteArray()
stream = QDataStream(datagram, QIODevice.WriteOnly)
# print(self.angularspeed.joint1)
low_byte1, high_byte1 = two_byte_int_to_byte(self.angularspeed.joint1)
low_byte2, high_byte2 = two_byte_int_to_byte(self.angularspeed.joint2)
low_byte3, high_byte3 = two_byte_int_to_byte(self.angularspeed.joint3)
low_byte4, high_byte4 = two_byte_int_to_byte(
self.angularspeed.prismatic)
low_byte5, high_byte5 = two_byte_int_to_byte(self.angularspeed.joint4)
low_byte6, high_byte6 = two_byte_int_to_byte(self.angularspeed.joint5)
low_byte7, high_byte7 = two_byte_int_to_byte(
self.angularspeed.sensor_box)
stream.writeInt8(self.direction.joint1)
stream.writeInt8(self.direction.joint2)
stream.writeInt8(self.direction.joint3)
stream.writeInt8(self.direction.prismatic)
stream.writeInt8(self.direction.joint4)
stream.writeInt8(self.direction.joint5)
stream.writeInt8(self.direction.sensor_box)
stream.writeUInt8(low_byte1)
stream.writeUInt8(high_byte1)
stream.writeUInt8(low_byte2)
stream.writeUInt8(high_byte2)
stream.writeUInt8(low_byte3)
stream.writeUInt8(high_byte3)
stream.writeUInt8(low_byte4)
stream.writeUInt8(high_byte4)
stream.writeUInt8(low_byte5)
stream.writeUInt8(high_byte5)
stream.writeUInt8(low_byte6)
stream.writeUInt8(high_byte6)
stream.writeUInt8(low_byte7)
stream.writeUInt8(high_byte7)
stream.writeUInt8(self.reset_motor.reset_main_board_motor)
stream.writeUInt8(self.home_position.home_position)
stream.writeUInt8(self.emergency_stop.emergency_stop)
self.socket_old_main_board.writeDatagram(
datagram, self.main_board_ip, self.mainboard_port)
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 dropMimeData(
self,
mime_data: "QMimeData",
action: "Qt.DropAction",
row: int,
column: int,
parent: "QModelIndex",
):
"""
Decodes and inserts the MIME data (layers) from a drop operation onto the table.
"""
if action == Qt.IgnoreAction:
return True
if not mime_data.hasFormat(Dial.KerasLayerListMIME.value):
return False
# Get the row number where the layers will be inserted
if row != -1:
begin_row = row
else:
begin_row = self.rowCount()
LOGGER.debug("Drop action type: %s", action)
LOGGER.debug("Adding a new row at index %s...", begin_row)
# Get the serilalized data from the MIME data and prepare for decoding
encoded_data: QByteArray = mime_data.data(
Dial.KerasLayerListMIME.value)
stream = QDataStream(encoded_data, QIODevice.ReadOnly)
# Unserialize binary data
layers = []
while not stream.atEnd():
layer = stream.readQVariant()
layers.append(layer)
LOGGER.debug("Values to insert: %s", len(layers))
LOGGER.debug(layers)
# When adding new layers we must ensure that the names are all uniques
if action == Qt.CopyAction:
self.__set_unique_layer_names(layers)
# Insert the decoded layers on the model
self.insertRows(begin_row, len(layers),
self.createIndex(begin_row, 0, layers))
return True
def send_sensor_board_manipulator_data(self):
datagram = QByteArray()
stream = QDataStream(datagram, QIODevice.WriteOnly)
low_byte4, high_byte4 = two_byte_int_to_byte(self.angularspeed.joint4)
stream.writeUInt8(self.direction.joint4)
stream.writeUInt8(self.direction.joint5)
stream.writeUInt8(self.direction.gripper)
stream.writeUInt8(self.direction.sensor_box)
stream.writeUInt8(low_byte4)
stream.writeUInt8(high_byte4)
stream.writeUInt8(self.reset_motor.reset_sensor_board_motor)
stream.writeUInt8(self.set_led.set_led)
self.socket_sensor_board.writeDatagram(
datagram, self.sensor_board_ip, 3032)
def dropEvent(self, event):
if event.mimeData().hasFormat("application/x-lista-item"):
data = event.mimeData().data("application/x-lista-item")
stream = QDataStream(data, QIODevice.ReadOnly)
text = stream.readQString()
id = stream.readInt16()
# icon = QIcon()
# stream >> icon
item = QListWidgetItem(text, self)
item.setData(1, id)
# item.setIcon(icon)
event.setDropAction(Qt.MoveAction)
event.accept()
else:
event.ignore()
def MoveStepMotor(self, MotorCommand: Step_Motor_Control_Data):
stream = QDataStream(self.STEP_MOTOR_COMMAND,
QtCore.QIODevice.ReadWrite)
stream.writeInt8(MotorCommand.HEADER_B1)
stream.writeInt8(MotorCommand.HEADER_B2)
stream.writeInt8(MotorCommand.UNIT_SIZE)
stream.writeInt16(MotorCommand.SpeedMotor1)
stream.writeInt16(MotorCommand.SpeedMotor2)
stream.writeInt16(MotorCommand.SpeedMotor3)
stream.writeInt16(MotorCommand.AngleMotor1)
stream.writeInt16(MotorCommand.AngleMotor2)
stream.writeInt16(MotorCommand.AngleMotor3)
def run(self):
tcpSocket = QTcpSocket()
if not tcpSocket.setSocketDescriptor(self.socketDescriptor):
self.error.emit(tcpSocket.error())
return
block = QByteArray()
outstr = QDataStream(block, QIODevice.WriteOnly)
outstr.setVersion(QDataStream.Qt_4_0)
outstr.writeUInt16(0)
outstr.writeQString(self.text)
outstr.device().seek(0)
outstr.writeUInt16(block.size() - 2)
tcpSocket.write(block)
tcpSocket.disconnectFromHost()
tcpSocket.waitForDisconnected()
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 accept_and_add(item, event):
hot_spot_point = QPoint()
item_data = event.mimeData().data(config_controller.component_mime)
data_stream = QDataStream(item_data, QIODevice.ReadOnly)
data_stream >> hot_spot_point
view_to_scene_transform, succes = self.page_view_transform.inverted(
)
if not succes:
logger.error("Page_view_transform could not be inverted")
hot_spot_point = view_to_scene_transform.map(hot_spot_point)
item.set_position(event.scenePos() - hot_spot_point)
self.add_component_controller(item)
logger.info("dropEvent")
event.setDropAction(Qt.MoveAction)
event.accept()
def dropEvent(self, event):
if event.mimeData().hasFormat("application/x-lista-item"):
data = event.mimeData().data("application/x-lista-item")
stream = QDataStream(data, QIODevice.ReadOnly)
self._player_name = stream.readQString()
self._player_id = stream.readInt16() # sor eseten p1, oszlopnál p2
for i in range(self.sorok_szama):
self.parent.eredmenyek[self._csoport_number][
self._csoport_sor][i]._set_p1_id(self._player_id)
self.parent.eredmenyek[self._csoport_number][i][
self._csoport_sor]._set_p2_id(self._player_id)
# print("id: ", self._player_id, "csoport: ", self._get_csoport_number(), "sor: ", self._get_csoport_sor())
# icon = QIcon()
# stream >> icon
event.setDropAction(Qt.MoveAction)
event.accept()
self.update()
else:
event.ignore()
def dropMimeData(self, data, action, row, column, parentIndex):
""" Handles the data supplied by a drag and drop operation that ended with the given action. """
if action == Qt.IgnoreAction:
return True
if not data.hasFormat("application/vnd.text.list"):
return False
encodedData = data.data("application/vnd.text.list")
stream = QDataStream(encodedData, QIODevice.ReadOnly)
parent = self.nodeFromIndex(parentIndex)
destRow = row if row != -1 else parent.childCount()
numPlacedBeforeDestination = 0
# MAYA-66630: We want all of this to be one undo transaction
while not stream.atEnd():
typeId = stream.readInt32()
uuid = stream.readInt64()
oldRow = stream.readInt32()
child = None
if typeId == TYPE_ID_LIGHT_ITEM:
child = self.lights[uuid]
elif typeId == TYPE_ID_GROUP_ITEM:
child = self.groups[uuid]
else:
print("Error: Unstream of unknown node type " + str(typeId))
continue
oldParent = child.parent()
oldParent.removeChild(child)
# We are inserting into range [row, row+numRows]. But we also remove. If we remove an item from our parent before this range,
# we must reduce indices that we insert at after that
if oldParent == parent and oldRow < row:
numPlacedBeforeDestination += 1
parent.insertChild(child, destRow - numPlacedBeforeDestination)
destRow += 1
return True
def saveState(self):
"""
Save the state of the configuration gui service (namely the recently
open config files). This is saved in QSettings because it is used
across config files.
:return:
"""
logger.debug("saving config state ...")
settings = QSettings()
b = QByteArray()
ds = QDataStream(b, QIODevice.WriteOnly)
l = [
rc.data() for rc in self.recentConfigs
if rc.isVisible() and rc.data() is not None and rc.data() != ""
]
ds.writeQStringList(l)
settings.setValue("ConfigurationRecentFiles", b)
logger.debug("saving config state done (%s)", l)
def mimeData(self, indexes: List["QModelIndex"]) -> "QMimeData":
"""
Returns a serialized object representing a List of Keras Layer. Used for
drag/drop operations, for example.
"""
mime_data = QMimeData()
# Serializer
encoded_data = QByteArray()
stream = QDataStream(encoded_data, QIODevice.WriteOnly)
# Write all the layers corresponding to the indexes
for index in indexes:
if index.isValid():
layer = index.internalPointer().layer
stream.writeQVariant(layer)
# Store the serialized data on the MIME data
mime_data.setData(Dial.KerasLayerListMIME.value, encoded_data)
return mime_data
