def loadCookies(self, cookies): """ Public method to restore the saved cookies. @param cookies byte array containing the saved cookies (QByteArray) @return list of cookies """ if cookies.isEmpty(): return [] cookiesList = [] data = QByteArray(cookies) stream = QDataStream(data, QIODevice.ReadOnly) stream.setVersion(QDataStream.Qt_4_6) version = stream.readUInt16() if version != self.JAR_VERSION: return [] stream.readUInt32() # number of cookies rawCookie = QByteArray() while not stream.atEnd(): stream >> rawCookie newCookies = QNetworkCookie.parseCookies(rawCookie) for newCookie in newCookies: cookiesList.append(newCookie) return cookiesList
def read_data(self): for client_id, client_socket in enumerate(self.clients): if client_socket.bytesAvailable() > 0: stream = QDataStream(client_socket) stream.setVersion(QDataStream.Qt_5_9) stream.readUInt32() client_data = stream.readQString() self.return_data_to_clients(client_id, client_data)
def read_data(self): stream = QDataStream(self.socket) stream.setVersion(QDataStream.Qt_5_9) while True: if self.socket.bytesAvailable() <= 0: break stream.readUInt32() text_from_server = stream.readQString() if self.text_widget: print('display_text') print(text_from_server) self.text_widget.append(text_from_server)
def restoreState(self, state): """ Public method to restore the state of the sidebar. @param state byte array containing the saved state (QByteArray) @return flag indicating success (boolean) """ if state.isEmpty(): return False if self.__orientation in [E5SideBar.North, E5SideBar.South]: minSize = self.layout.minimumSize().height() maxSize = self.maximumHeight() else: minSize = self.layout.minimumSize().width() maxSize = self.maximumWidth() data = QByteArray(state) stream = QDataStream(data, QIODevice.ReadOnly) stream.setVersion(QDataStream.Qt_4_6) version = stream.readUInt16() # version minimized = stream.readBool() if minimized and not self.__minimized: self.shrink() stream >> self.__bigSize if version == 1: self.__minSize = max(stream.readUInt16(), minSize) self.__maxSize = max(stream.readUInt16(), maxSize) count = stream.readUInt16() self.splitterSizes = [] for _ in range(count): self.splitterSizes.append(stream.readUInt16()) elif version == 2: self.__minSize = max(stream.readUInt32(), minSize) self.__maxSize = max(stream.readUInt32(), maxSize) count = stream.readUInt32() self.splitterSizes = [] for _ in range(count): self.splitterSizes.append(stream.readUInt32()) self.__autoHide = stream.readBool() self.__autoHideButton.setChecked(not self.__autoHide) if not minimized: self.expand() return True
def receiveMessage(self): print("received smtg") for s in self.connections: if s.bytesAvailable() > 0 : stream = QDataStream(s) stream.setVersion(QDataStream.Qt_4_9) if s.nextBlockSize == 0: if s.bytesAvailable() < SIZEOF_UINT32: return size = stream.readUInt32() print("size", size) s.nextBlockSize = size if s.bytesAvailable() < s.nextBlockSize: return header = stream.readUInt32() print("header", header) if header == 0: # QString textFromClient = stream.readQString() print(f"received '{textFromClient}' from {s}") answer = textFromClient + " Back at you!" if "CLOSE" in textFromClient: self.parent.quit() if header == 1: # QImage img_bytes = stream.readBytes() img = QImage() img.loadFromData(img_bytes) img.save("serverQt.jpg") print(f"received an image from {s}") answer = "image saved in the server on serverQt.jpg" s.nextBlockSize = 0 # BACK AT CLIENT self.sendMessage(answer, s) s.nextBlockSize = 0
def readData(self): in_data = QDataStream(self.client) in_data.setVersion(QDataStream.Qt_4_0) if self.data_size == 0: tmp = self.client.bytesAvailable() if tmp < SIZEOF_UINT32: return self.data_size = in_data.readUInt32() print(self.data_size) if self.client.bytesAvailable() < self.data_size: return self.message = self.client.read(self.data_size) self.list.append(self.message) print(self.index) self.index = self.index + 1 if self.index == 10: try: with open("message.pkl", "wb") as fp: pickle.dump(self.list, fp, pickle.HIGHEST_PROTOCOL) self.client.close() except: print("what")
def openWorkspace(self): """ Function for opening a saved workspace. Goes through and reloads in reverse of how it is saved. """ sel = QFileDialog.getOpenFileName( parent=self, caption="Open Workspace", directory=QDir.homePath(), filter="Linnaeo Workspace (*.lno);;Any (*)") if sel != ('', ''): filename = sel[0] self.mainLogger.debug("Opening file: " + str(filename)) file = QFile(filename) file.open(QIODevice.ReadOnly) fstream = QDataStream(file) self.mainLogger.info("Starting restore") self.mainStatus.showMessage("Rebuilding workspace, please wait...") sequences = fstream.readQVariantHash() titles = fstream.readQVariantList() windex = fstream.readUInt32() windows = {} self.mdiArea.closeAllSubWindows() newBModel = widgets.ItemModel(windows, seqTree=True) newPModel = widgets.ItemModel(windows) self.restore_tree(newBModel.invisibleRootItem(), fstream) self.restore_tree(newPModel.invisibleRootItem(), fstream) self.mainStatus.showMessage("Rebuild complete!") self.mdiArea.closeAllSubWindows() self.start = time.perf_counter() self.disconnectSlots() self.guiSet(trees=[newBModel, newPModel], data=[sequences, titles, windex]) self.connectSlots() del sel, filename, file, fstream, sequences, titles, windex, windows, newBModel, newPModel #self.destroy() else: del sel
def _decode_data(self, data): encoded_data = data.data(self.mime_format) stream = QDataStream(encoded_data) dragged_states = [] dragged_state = [] r_previous = None while not stream.atEnd(): r = stream.readInt32() c = stream.readInt32() if r != (r_previous if r_previous else r): dragged_states.append(dragged_state) dragged_state.clear() r_previous = r num_items_in_map = stream.readUInt32() for i in range(num_items_in_map): key = stream.readInt32() value = QVariant() stream >> value dragged_state.append(value.value()) dragged_states.append(dragged_state) return dragged_states
def __load(self): """ Private method to load the saved history entries from disk. """ historyFile = QFile(self.getFileName()) if not historyFile.exists(): return if not historyFile.open(QIODevice.ReadOnly): E5MessageBox.warning( None, self.tr("Loading History"), self.tr("""<p>Unable to open history file <b>{0}</b>.<br/>""" """Reason: {1}</p>""").format( historyFile.fileName, historyFile.errorString() ), ) return history = [] # double check, that the history file is sorted as it is read needToSort = False lastInsertedItem = HistoryEntry() data = QByteArray(historyFile.readAll()) stream = QDataStream(data, QIODevice.ReadOnly) stream.setVersion(QDataStream.Qt_4_6) while not stream.atEnd(): ver = stream.readUInt32() if ver != HISTORY_VERSION: continue itm = HistoryEntry() itm.url = Utilities.readStringFromStream(stream) stream >> itm.dateTime itm.title = Utilities.readStringFromStream(stream) if not itm.dateTime.isValid(): continue if itm == lastInsertedItem: if not lastInsertedItem.title and len(history) > 0: history[0].title = itm.title continue if not needToSort and history and lastInsertedItem < itm: needToSort = True history.insert(0, itm) lastInsertedItem = itm historyFile.close() if needToSort: history.sort() self.setHistory(history, True) # if the history had to be sorted, rewrite the history sorted if needToSort: self.__lastSavedUrl = "" self.__saveTimer.changeOccurred()
def __load(self): """ Private method to load the saved history entries from disk. """ historyFile = QFile(self.getFileName()) if not historyFile.exists(): return if not historyFile.open(QIODevice.ReadOnly): E5MessageBox.warning( None, self.tr("Loading History"), self.tr( """<p>Unable to open history file <b>{0}</b>.<br/>""" """Reason: {1}</p>""") .format(historyFile.fileName, historyFile.errorString())) return history = [] # double check, that the history file is sorted as it is read needToSort = False lastInsertedItem = HistoryEntry() data = QByteArray(historyFile.readAll()) stream = QDataStream(data, QIODevice.ReadOnly) stream.setVersion(QDataStream.Qt_4_6) while not stream.atEnd(): ver = stream.readUInt32() if ver != HISTORY_VERSION: continue itm = HistoryEntry() itm.url = Utilities.readStringFromStream(stream) stream >> itm.dateTime itm.title = Utilities.readStringFromStream(stream) if not itm.dateTime.isValid(): continue if itm == lastInsertedItem: if not lastInsertedItem.title and len(history) > 0: history[0].title = itm.title continue if not needToSort and history and lastInsertedItem < itm: needToSort = True history.insert(0, itm) lastInsertedItem = itm historyFile.close() if needToSort: history.sort() self.setHistory(history, True) # if the history had to be sorted, rewrite the history sorted if needToSort: self.__lastSavedUrl = "" self.__saveTimer.changeOccurred()
def readFromServer(self): stream = QDataStream(self) stream.setVersion(QDataStream.Qt_4_9) while True: if self.nextBlockSize == 0: if self.bytesAvailable() < self.SIZEOF_UINT32: break self.nextBlockSize = stream.readUInt32() if self.bytesAvailable() < self.nextBlockSize: break header = stream.readUInt32() print("header", header) if header == 0: # QString textFromServer = stream.readQString() # print("messageReceived:", textFromServer) print(f"received '{textFromServer}' from Server") self.messageReceived.emit("[RECEIVED] " + textFromServer) self.nextBlockSize = 0
def _onReadyRead(self): while self._socket.bytesAvailable() >= 4: ds = QDataStream(self._socket) ds.setByteOrder(QDataStream.LittleEndian) # Header packet if self.header is None: size, = unpack('=l', self._socket.peek(4)) if self._socket.bytesAvailable() < size + 4: return # Omit size ds.readUInt32() self.header = ds.readRawData(size).decode() # Chunks packet else: if self.nchunks == -1: self.nchunks = ds.readUInt32() self.chunks = [] while len(self.chunks) < self.nchunks: chunk = self._readLuaVal(ds) if chunk is None: return self.chunks.append(chunk) # Packet pair reading done. self._logger.info("GC >> : %s : %s", self.header, self.chunks) self.messageReceived.emit(self.header, self.chunks) self.header = None self.nchunks = -1 self.chunks = None
def MyToolBars(self): ''' Create user toolbars ''' self.file.open(QIODevice.ReadOnly) datastream = QDataStream(self.file) num_childs = datastream.readUInt32() for _ in range(0, num_childs): item = QTreeWidgetItem() item.read(datastream) self.bar = None DelToolBarIface(item.text(0), self.iface) self.bar = self.iface.mainWindow().addToolBar(item.text(0)) self.restore_item(datastream, item) self.file.close() return
def listMyToolBars(self): self.MyToolsBars.clear() self.file.open(QIODevice.ReadOnly) datastream = QDataStream(self.file) num_childs = datastream.readUInt32() for i in range(0, num_childs): self.MyToolsBars.setEnabled(True) self.My_expand.setEnabled(True) self.My_Collapse.setEnabled(True) item = QTreeWidgetItem() item.read(datastream) self.MyToolsBars.insertTopLevelItem(i, item) self.restore_item(datastream, item) self.file.close()
def _decode_data(self, data): encoded_data = data.data(self.mime_format) stream = QDataStream(encoded_data) dragged_data = [] while not stream.atEnd(): row = stream.readInt32() column = stream.readInt32() num_items_in_map = stream.readUInt32() item = {'row': row, 'column': column, 'map items': {}} for i in range(num_items_in_map): key = stream.readInt32() value = QVariant() stream >> value item['map items'][Qt.ItemDataRole(key)] = value.value() dragged_data.append(item) return dragged_data
def read(self, fileName): # Read data. file = QFile(fileName) if (not file.open(QIODevice.ReadOnly)): self.mError = self.tr("Cannot open Replica Island map file!") return 0 _in = QDataStream(file) _in.setByteOrder(QDataStream.LittleEndian) _in.setFloatingPointPrecision(QDataStream.SinglePrecision) # Parse file header. mapSignature = _in.readUInt8() layerCount = _in.readUInt8() backgroundIndex = _in.readUInt8() if (_in.status() == QDataStream.ReadPastEnd or mapSignature != 96): self.mError = self.tr("Can't parse file header!") return 0 # Create our map, setting width and height to 0 until we load a layer. map = Map(Map.Orientation.Orthogonal, 0, 0, 32, 32) map.setProperty("background_index", QString.number(backgroundIndex)) # Load our Tilesets. typeTilesets = QVector() tileIndexTilesets = QVector() self.loadTilesetsFromResources(map, typeTilesets, tileIndexTilesets) # Load each of our layers. for i in range(layerCount): # Parse layer header. _type = _in.readUInt8() tileIndex = _in.readUInt8() scrollSpeed = _in.readFloat() levelSignature = _in.readUInt8() width = _in.readUInt32() height = _in.readUInt32() if (_in.status() == QDataStream.ReadPastEnd or levelSignature != 42): self.mError = self.tr("Can't parse layer header!") return 0 # Make sure our width and height are consistent. if (map.width() == 0): map.setWidth(width) if (map.height() == 0): map.setHeight(height) if (map.width() != width or map.height() != height): self.mError = self.tr("Inconsistent layer sizes!") return 0 # Create a layer object. layer = TileLayer(self.layerTypeToName(_type), 0, 0, width, height) layer.setProperty("type", QString.number(_type)) layer.setProperty("tile_index", QString.number(tileIndex)) layer.setProperty("scroll_speed", QString.number(scrollSpeed, 'f')) map.addLayer(layer) # Look up the tileset for this layer. tileset = tilesetForLayer(_type, tileIndex, typeTilesets, tileIndexTilesets) # Read our tile data all at once. #tileData = QByteArray(width*height, b'\x00') bytesNeeded = width*height tileData = _in.readRawData(bytesNeeded) bytesRead = len(tileData) if (bytesRead != bytesNeeded): self.mError = self.tr("File ended in middle of layer!") return 0 i = 0 # Add the tiles to our layer. for y in range(0, height): for x in range(0, width): tile_id = tileData[i]&0xff i += 1 if (tile_id != 255): tile = tileset.tileAt(tile_id) layer.setCell(x, y, Cell(tile)) # Make sure we read the entire *.bin file. if (_in.status() != QDataStream.Ok or not _in.atEnd()): self.mError = self.tr("Unexpected data at end of file!") return 0 return map
def remove_bookmark(self, spath): if not self.written: return if not os.path.exists(self.config_path): self.written = False return url = pathlib.Path(spath).as_uri() settings_qt4 = QSettings(self.config_path, QSettings.IniFormat) if not settings_qt4.isWritable(): self.written = False return data = settings_qt4.value('Qt/filedialog') stream = QDataStream(data, QIODevice.ReadOnly) magic = stream.readUInt32() version = stream.readUInt32() if not (magic == QFileDialogMagic and version == 3): self.written = False return split_states = stream.readBytes() bookmark_found = False bookmarks_len = stream.readUInt32() bookmarks = [] for bm in range(bookmarks_len): qUrl = QUrl() stream >> qUrl if qUrl.isLocalFile() and qUrl.toLocalFile() == spath: bookmark_found = True else: bookmarks.append(qUrl) if not bookmark_found: self.written = False return history_len = stream.readUInt32() history = [] for h in range(history_len): his = stream.readQString() history.append(his) current_dir = stream.readQString() header_data = stream.readBytes() view_mode = stream.readUInt32() #now rewrite bytes new_data = QByteArray() new_stream = QDataStream(new_data, QIODevice.WriteOnly) new_stream.writeUInt32(magic) new_stream.writeUInt32(3) new_stream.writeBytes(split_states) new_stream.writeUInt32(bookmarks_len-1) for bm in bookmarks: new_stream << bm qUrl = QUrl(url) new_stream << qUrl new_stream.writeQStringList(history) new_stream.writeQString(current_dir) new_stream.writeBytes(header_data) new_stream.writeUInt32(view_mode) settings_qt4.setValue('Qt/filedialog', new_data) settings_qt4.sync() self.written = False
def read(self, fileName): # Read data. file = QFile(fileName) if (not file.open(QIODevice.ReadOnly)): self.mError = self.tr("Cannot open Replica Island map file!") return 0 _in = QDataStream(file) _in.setByteOrder(QDataStream.LittleEndian) _in.setFloatingPointPrecision(QDataStream.SinglePrecision) # Parse file header. mapSignature = _in.readUInt8() layerCount = _in.readUInt8() backgroundIndex = _in.readUInt8() if (_in.status() == QDataStream.ReadPastEnd or mapSignature != 96): self.mError = self.tr("Can't parse file header!") return 0 # Create our map, setting width and height to 0 until we load a layer. map = Map(Map.Orientation.Orthogonal, 0, 0, 32, 32) map.setProperty("background_index", QString.number(backgroundIndex)) # Load our Tilesets. typeTilesets = QVector() tileIndexTilesets = QVector() self.loadTilesetsFromResources(map, typeTilesets, tileIndexTilesets) # Load each of our layers. for i in range(layerCount): # Parse layer header. _type = _in.readUInt8() tileIndex = _in.readUInt8() scrollSpeed = _in.readFloat() levelSignature = _in.readUInt8() width = _in.readUInt32() height = _in.readUInt32() if (_in.status() == QDataStream.ReadPastEnd or levelSignature != 42): self.mError = self.tr("Can't parse layer header!") return 0 # Make sure our width and height are consistent. if (map.width() == 0): map.setWidth(width) if (map.height() == 0): map.setHeight(height) if (map.width() != width or map.height() != height): self.mError = self.tr("Inconsistent layer sizes!") return 0 # Create a layer object. layer = TileLayer(self.layerTypeToName(_type), 0, 0, width, height) layer.setProperty("type", QString.number(_type)) layer.setProperty("tile_index", QString.number(tileIndex)) layer.setProperty("scroll_speed", QString.number(scrollSpeed, 'f')) map.addLayer(layer) # Look up the tileset for this layer. tileset = tilesetForLayer(_type, tileIndex, typeTilesets, tileIndexTilesets) # Read our tile data all at once. #tileData = QByteArray(width*height, b'\x00') bytesNeeded = width * height tileData = _in.readRawData(bytesNeeded) bytesRead = len(tileData) if (bytesRead != bytesNeeded): self.mError = self.tr("File ended in middle of layer!") return 0 i = 0 # Add the tiles to our layer. for y in range(0, height): for x in range(0, width): tile_id = tileData[i] & 0xff i += 1 if (tile_id != 255): tile = tileset.tileAt(tile_id) layer.setCell(x, y, Cell(tile)) # Make sure we read the entire *.bin file. if (_in.status() != QDataStream.Ok or not _in.atEnd()): self.mError = self.tr("Unexpected data at end of file!") return 0 return map
class Client(QDialog): def __init__(self, parent: QWidget = None): super().__init__(parent) self._in = QDataStream() self.blockSize = 0 self.currentFortune = "" self.hostLineEdit = QLineEdit("fortune") self.getFortuneButton = QPushButton(self.tr("Get Fortune")) self.statusLabel = QLabel( self. tr("This examples requires that you run the Local Fortune Server example as well." )) self.socket = QLocalSocket(self) self.setWindowFlags(self.windowFlags() & ~Qt.WindowContextHelpButtonHint) hostLabel = QLabel(self.tr("&Server name:")) hostLabel.setBuddy(self.hostLineEdit) self.statusLabel.setWordWrap(True) self.getFortuneButton.setDefault(True) quitButton = QPushButton(self.tr("Quit")) buttonBox = QDialogButtonBox() buttonBox.addButton(self.getFortuneButton, QDialogButtonBox.ActionRole) buttonBox.addButton(quitButton, QDialogButtonBox.RejectRole) self._in.setDevice(self.socket) self._in.setVersion(QDataStream.Qt_5_10) self.hostLineEdit.textChanged.connect(self.enableGetFortuneButton) self.getFortuneButton.clicked.connect(self.requestNewFortune) quitButton.clicked.connect(self.close) self.socket.readyRead.connect(self.readFortune) self.socket.errorOccurred.connect(self.displayError) mainLayout = QGridLayout(self) mainLayout.addWidget(hostLabel, 0, 0) mainLayout.addWidget(self.hostLineEdit, 0, 1) mainLayout.addWidget(self.statusLabel, 2, 0, 1, 2) mainLayout.addWidget(buttonBox, 3, 0, 1, 2) self.setWindowTitle(QGuiApplication.applicationDisplayName()) self.hostLineEdit.setFocus() @pyqtSlot() def requestNewFortune(self): self.getFortuneButton.setEnabled(False) self.blockSize = 0 self.socket.abort() self.socket.connectToServer(self.hostLineEdit.text()) @pyqtSlot() def readFortune(self): if self.blockSize == 0: # Relies on the fact that QDataStream serializes a quint32 into # sizeof(quint32) bytes if self.socket.bytesAvailable() < 4: # (int)sizeof(quint32)) return self.blockSize = self._in.readUInt32() if self.socket.bytesAvailable() < self.blockSize or self._in.atEnd(): return nextFortune = "" nextFortune = self._in.readQString() if nextFortune == self.currentFortune: QTimer.singleShot(0, self.requestNewFortune) return currentFortune = nextFortune self.statusLabel.setText(currentFortune) self.getFortuneButton.setEnabled(True) @pyqtSlot(QLocalSocket.LocalSocketError) def displayError(self, socketError): if socketError == QLocalSocket.ServerNotFoundError: QMessageBox.information( self, self.tr("Local Fortune Client"), self.tr("The host was not found. Please make sure " "that the server is running and that the " "server name is correct."), ) elif socketError == QLocalSocket.ConnectionRefusedError: QMessageBox.information( self, self.tr("Local Fortune Client"), self.tr("The connection was refused by the peer. " "Make sure the fortune server is running, " "and check that the server name is correct."), ) elif socketError == QLocalSocket.PeerClosedError: return else: QMessageBox.information( self, self.tr("Local Fortune Client"), self.tr("The following error occurred: %s." % (self.socket.errorString())), ) self.getFortuneButton.setEnabled(True) @pyqtSlot() def enableGetFortuneButton(self): self.getFortuneButton.setEnabled(bool(self.hostLineEdit.ext()))