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