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 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()))
