def dropMimeData(self, data, action, row, column, parent):
"""
Public method to accept the mime data of a drop action.
@param data reference to the mime data (QMimeData)
@param action drop action requested (Qt.DropAction)
@param row row number (integer)
@param column column number (integer)
@param parent index of the parent node (QModelIndex)
@return flag indicating successful acceptance of the data (boolean)
"""
if action == Qt.IgnoreAction:
return True
if column > 0:
return False
parentNode = self.node(parent)
if not data.hasFormat(self.MIMETYPE):
if not data.hasUrls():
return False
from .BookmarkNode import BookmarkNode
node = BookmarkNode(BookmarkNode.Bookmark, parentNode)
node.url = bytes(data.urls()[0].toEncoded()).decode()
if data.hasText():
node.title = data.text()
else:
node.title = node.url
self.__bookmarksManager.addBookmark(parentNode, node, row)
return True
ba = data.data(self.MIMETYPE)
stream = QDataStream(ba, QIODevice.ReadOnly)
if stream.atEnd():
return False
undoStack = self.__bookmarksManager.undoRedoStack()
undoStack.beginMacro("Move Bookmarks")
from .XbelReader import XbelReader
while not stream.atEnd():
encodedData = QByteArray()
stream >> encodedData
buffer = QBuffer(encodedData)
buffer.open(QIODevice.ReadOnly)
reader = XbelReader()
rootNode = reader.read(buffer)
for bookmarkNode in rootNode.children():
rootNode.remove(bookmarkNode)
row = max(0, row)
self.__bookmarksManager.addBookmark(
parentNode, bookmarkNode, row)
self.__endMacro = True
return True
def dropMimeData(self, data, action, row, column, parent):
"""
Public method to accept the mime data of a drop action.
@param data reference to the mime data (QMimeData)
@param action drop action requested (Qt.DropAction)
@param row row number (integer)
@param column column number (integer)
@param parent index of the parent node (QModelIndex)
@return flag indicating successful acceptance of the data (boolean)
"""
if action == Qt.IgnoreAction:
return True
if column > 0:
return False
parentNode = self.node(parent)
if not data.hasFormat(self.MIMETYPE):
if not data.hasUrls():
return False
from .BookmarkNode import BookmarkNode
node = BookmarkNode(BookmarkNode.Bookmark, parentNode)
node.url = bytes(data.urls()[0].toEncoded()).decode()
if data.hasText():
node.title = data.text()
else:
node.title = node.url
self.__bookmarksManager.addBookmark(parentNode, node, row)
return True
ba = data.data(self.MIMETYPE)
stream = QDataStream(ba, QIODevice.ReadOnly)
if stream.atEnd():
return False
undoStack = self.__bookmarksManager.undoRedoStack()
undoStack.beginMacro("Move Bookmarks")
from .XbelReader import XbelReader
while not stream.atEnd():
encodedData = QByteArray()
stream >> encodedData
buffer = QBuffer(encodedData)
buffer.open(QIODevice.ReadOnly)
reader = XbelReader()
rootNode = reader.read(buffer)
for bookmarkNode in rootNode.children():
rootNode.remove(bookmarkNode)
row = max(0, row)
self.__bookmarksManager.addBookmark(parentNode, bookmarkNode,
row)
self.__endMacro = True
return True
def dropMimeData(self, data, action, row, column, parent):
if not data.hasFormat('image/x-puzzle-piece'):
return False
if action == Qt.IgnoreAction:
return True
if column > 0:
return False
if not parent.isValid():
if row < 0:
endRow = len(self.pixmaps)
else:
endRow = min(row, len(self.pixmaps))
else:
endRow = parent.row()
encodedData = data.data('image/x-puzzle-piece')
stream = QDataStream(encodedData, QIODevice.ReadOnly)
while not stream.atEnd():
pixmap = QPixmap()
location = QPoint()
stream >> pixmap >> location
self.beginInsertRows(QModelIndex(), endRow, endRow)
self.pixmaps.insert(endRow, pixmap)
self.locations.insert(endRow, location)
self.endInsertRows()
endRow += 1
return True
def load(self):
exception = None
fh = None
try:
if not self.filename:
raise IOError("no filename specified for loading")
fh = QFile(self.filename)
if not fh.open(QIODevice.ReadOnly):
raise IOError(fh.errorString())
stream = QDataStream(fh)
magic = stream.readInt32()
if magic != MAGIC_NUMBER:
raise IOError("unrecognized file type")
fileVersion = stream.readInt16()
if fileVersion != FILE_VERSION:
raise IOError("unrecognized file type version")
self.ships = {}
while not stream.atEnd():
name = stream.readQString()
owner = stream.readQString()
country = stream.readQString()
description = stream.readQString()
teu = stream.readInt32()
ship = Ship(name, owner, country, teu, description)
self.ships[id(ship)] = ship
self.owners.add(owner)
self.countries.add(country)
self.dirty = False
except IOError as e:
exception = e
finally:
if fh is not None:
fh.close()
if exception is not None:
raise exception
def dropMimeData(self, data, action, row, column, parent):
if not data.hasFormat("image/x-puzzle-piece"):
return False
if action == Qt.IgnoreAction:
return True
if column > 0:
return False
if not parent.isValid():
if row < 0:
endRow = len(self.pixmaps)
else:
endRow = min(row, len(self.pixmaps))
else:
endRow = parent.row()
encodedData = data.data("image/x-puzzle-piece")
stream = QDataStream(encodedData, QIODevice.ReadOnly)
while not stream.atEnd():
pixmap = QPixmap()
location = QPoint()
stream >> pixmap >> location
self.beginInsertRows(QModelIndex(), endRow, endRow)
self.pixmaps.insert(endRow, pixmap)
self.locations.insert(endRow, location)
self.endInsertRows()
endRow += 1
return True
def dropMimeData(
self,
data: QMimeData,
action: Qt.DropAction,
row: int = -1,
col: int = -1,
parent: QModelIndex = QModelIndex(),
):
if action == Qt.IgnoreAction or not data or not data.hasFormat(
DEFAULT_MIME_FORMAT):
return True
if row < 0 or row > len(self._selected):
position = len(self._selected)
else:
position = self._plugins[row].pluginOrder
encoded = data.data(DEFAULT_MIME_FORMAT)
stream = QDataStream(encoded, QIODevice.ReadOnly)
indexes = []
while not stream.atEnd():
srcRow = stream.readInt32()
stream.readInt32() # src column
mapItems = stream.readInt32() # role data map
for i in range(mapItems):
stream.readInt32() # map role ID
stream.readQVariant() # map role value
indexes.append(self.index(srcRow, 0))
self.setPluginsOrder(indexes, position)
return False
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 load_datastream(self, fname):
error = None
fh = None
try:
fh = QFile(fname)
if not fh.open(QIODevice.ReadOnly):
raise IOError(str(fh.errorString()))
stream = QDataStream(fh)
while not stream.atEnd():
self.label = stream.readQString()
self.diameter = stream.readInt32()
self.top_elev = stream.readDouble()
self.design_load = stream.readDouble()
except EnvironmentError as e:
error = "Failed to load:{0}".format(e)
finally:
if fh is not None:
fh.close()
if error is not None:
print(error)
self.__dirty = False
print("load data from{0}".format(QFileInfo(fname).fileName()))
# 缺少计算参数的类
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 _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 receiveData(self):
logger.info("waits for data")
ins = QDataStream(self.conn)
ins.setVersion(QDataStream.Qt_5_0)
if ins.atEnd():
return
argv = ins.readQVariant()
logger.info("reads '%s'", str(argv))
# Must be setted up on 'show' action. Move from beginning to appropriate.
action.search_dst_window()
self.dataReceived.emit(argv)
def receiveData(self):
logger.info("waits for data")
ins = QDataStream(self.conn)
ins.setVersion(QDataStream.Qt_5_0)
if ins.atEnd():
return
argv = ins.readQVariant()
logger.info("reads '%s'", str(argv))
# Must be setted up on 'show' action. Move from beginning to appropriate.
action.search_dst_window()
self.dataReceived.emit(argv)
def decodeMimeData(self, mimedata):
data = []
stream = QDataStream(mimedata.data(MyHeader.MimeType))
while not stream.atEnd():
row = stream.readInt32()
column = stream.readInt32()
item = {}
for count in range(stream.readInt32()):
key = stream.readInt32()
item[key] = stream.readQVariant()
data.append([item[Qt.UserRole], item[Qt.DisplayRole]])
return data
def dropMimeData(self, data, action, row, column, parent):
if (action == Qt.IgnoreAction):
return True
if (column > 0):
return False
beginRow = 0
if (row != -1):
beginRow = row
elif parent.isValid():
beginRow = parent.row()
else:
beginRow = self.mFrames.size()
newFrames = QVector()
if (data.hasFormat(FRAMES_MIMETYPE)):
encodedData = data.data(FRAMES_MIMETYPE)
stream = QDataStream(encodedData, QIODevice.ReadOnly)
while (not stream.atEnd()):
frame = Frame()
frame.tileId = stream.readInt()
frame.duration = stream.readInt()
newFrames.append(frame)
elif (data.hasFormat(TILES_MIMETYPE)):
encodedData = data.data(TILES_MIMETYPE)
stream = QDataStream(encodedData, QIODevice.ReadOnly)
while (not stream.atEnd()):
frame = Frame()
frame.tileId = stream.readInt()
frame.duration = FrameListModel.DEFAULT_DURATION
newFrames.append(frame)
if (newFrames.isEmpty()):
return False
self.beginInsertRows(QModelIndex(), beginRow,
beginRow + newFrames.size() - 1)
self.mFrames.insert(beginRow, newFrames.size(), Frame())
for i in range(newFrames.size()):
self.mFrames[i + beginRow] = newFrames[i]
self.endInsertRows()
return True
def dropEvent(self, event):
formats = event.mimeData().formats()
if "application/x-qabstractitemmodeldatalist" in formats:
encoded = event.mimeData().data(
"application/x-qabstractitemmodeldatalist")
stream = QDataStream(encoded, QIODevice.ReadOnly)
while not stream.atEnd():
row = stream.readInt()
col = stream.readInt()
data = stream.readQVariantMap()
self.setText(data[""])
elif "text/uri-list" in formats:
urls = event.mimeData().urls()
if urls:
self.setText(urls[0].toLocalFile())
def readFile(self, filename, blockbytes):
# print("send file",filename)
info = QtCore.QFileInfo(filename)
fname = info.fileName()
localfile = QtCore.QFile(filename)
localfile.open(QtCore.QFile.ReadOnly)
totalFBytes = localfile.size()
filecont = QByteArray()
# filecont = self.localfile.read(min(totalFBytes,self.blockBytes))
fstream = QDataStream(localfile)
fnum = math.ceil(float(totalFBytes) / self.blockBytes)
# print("total",totalFBytes)
# print("blockbytes",self.blockBytes)
# print("fnum",fnum)
i = 0
start_time = int(time.time())
tmp_time = start_time
tmp_speed = ""
tmp_total_time = ""
while not fstream.atEnd():
readsize = min(totalFBytes, self.blockBytes)
totalFBytes -= readsize
filecont = fstream.readRawData(readsize)
# print("send",i,readsize)
self.signThread.emit(fname, i, readsize, filecont)
i += 1
self.signFileBar.emit(fnum, i)
self.flag = True
while self.flag:
if len(tmp_speed) > 0:
self.signFileSpeed.emit(time_total_time + "s",
self.getRandomTime(tmp_speed))
time.sleep(0.5)
now_time = int(time.time())
about_time, speed = self.getAboutTime(now_time - tmp_time + 0.1,
readsize, totalFBytes)
self.signFileSpeed.emit(about_time + "s", speed)
tmp_time = now_time
tmp_speed = speed
time_total_time = about_time
localfile.close()
self.signFileBar.emit(fnum, fnum)
now_time = int(time.time())
ab_time = self.getTimeFromat(now_time - start_time) + "s"
self.signFileSpeed.emit(ab_time, "")
self.signConfirm.emit(fname)
def decode_data(self, bytearray):
data = {}
ds = QDataStream(bytearray)
while not ds.atEnd():
row = ds.readInt32()
column = ds.readInt32()
map_items = ds.readInt32()
for i in range(map_items):
key = ds.readInt32()
value = QVariant()
ds >> value
data[Qt.ItemDataRole(key)] = value
return data
def decode_data(bytearray):
data = []
ds = QDataStream(bytearray)
while not ds.atEnd():
item = {0: ''}
row = ds.readInt32()
column = ds.readInt32()
map_items = ds.readInt32()
for i in range(map_items):
key = ds.readInt32()
value = QVariant()
ds >> value
item[key] = value.value()
data.append(item)
return data
def dropMimeData(self, data: 'QMimeData', action: Qt.DropAction, row: int,
column: int, parent: QModelIndex) -> bool:
if action == Qt.IgnoreAction:
return True
if column > 0:
return False
if row != -1:
endRow = row
elif parent.isValid():
endRow = parent.row()
else:
endRow = self.rowCount(QModelIndex())
encodedData = data.data('application/x-tableview-dragRow')
stream = QDataStream(encodedData, QIODevice.ReadOnly)
beginRows = []
beginDatas = []
# newEndRow = endRow
while not stream.atEnd():
beginRow = stream.readInt32()
beginRows.append(beginRow)
beginDatas.append(self.datas[beginRow])
if beginRow < endRow - 1:
endRow = endRow - 1
beginRows = sorted(beginRows, reverse=True)
for beginRow in beginRows:
self.removeRows(beginRow, 1, 0)
# if endRow == self.rowCount(QModelIndex()) - 1:
# endRow = endRow + 1
for beginData in beginDatas:
self.beginInsertRows(QModelIndex(), endRow, endRow)
self.datas.insert(endRow, beginData)
self.endInsertRows()
endRow = endRow + 1
return True
def decodeMimeData(self, the_bytearray: QByteArray):
"""see:
https://wiki.python.org/moin/PyQt/Handling%20Qt's%20internal%20item%20MIME%20type
http://doc.qt.io/qt-5.5/datastreamformat.html
"""
data = {}
ds = QDataStream(the_bytearray)
while not ds.atEnd():
item = []
row = ds.readInt32()
column = ds.readInt32()
number_of_items = ds.readInt32()
# print("rc:", row, column, number_of_items)
for i in range(number_of_items):
key = ds.readInt32()
value = QVariant()
ds >> value
item.append((value.value(), Qt.ItemDataRole(key)))
data[(row, column)] = item
return data
def readFortune(self):
ins = QDataStream(self.socket)
ins.setVersion(QDataStream.Qt_4_0)
if self.blockSize == 0:
if self.socket.bytesAvailable() < 2:
return
self.blockSize = ins.readUInt16()
if ins.atEnd():
return
nextFortune = ins.readQString()
if nextFortune == self.currentFortune:
QTimer.singleShot(0, self.requestNewFortune)
return
self.currentFortune = nextFortune
self.statusLabel.setText(self.currentFortune)
self.getFortuneButton.setEnabled(True)
def readFortune(self):
ins = QDataStream(self.socket)
ins.setVersion(QDataStream.Qt_4_0)
if self.blockSize == 0:
if self.socket.bytesAvailable() < 2:
return
self.blockSize = ins.readUInt16()
if ins.atEnd():
return
nextFortune = ins.readQString()
if nextFortune == self.currentFortune:
QTimer.singleShot(0, self.requestNewFortune)
return
self.currentFortune = nextFortune
self.statusLabel.setText(self.currentFortune)
self.getFortuneButton.setEnabled(True)
def decodeMimeData(self, the_bytearray: QByteArray):
"""see:
https://wiki.python.org/moin/PyQt/Handling%20Qt's%20internal%20item%20MIME%20type
http://doc.qt.io/qt-5.5/datastreamformat.html
"""
data = {}
ds = QDataStream(the_bytearray)
while not ds.atEnd():
item = []
row = ds.readInt32()
column = ds.readInt32()
number_of_items = ds.readInt32()
# print("rc:", row, column, number_of_items)
for i in range(number_of_items):
key = ds.readInt32()
value = QVariant()
ds >> value
item.append((value.value(), Qt.ItemDataRole(key)))
data[(row, column)] = item
return data
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 decode_mime_data(bytearray_):
data = []
item = {}
ds = QDataStream(bytearray_)
while not ds.atEnd():
row = ds.readInt32()
column = ds.readInt32()
map_items = ds.readInt32()
for i in range(map_items):
key = ds.readInt32()
value = QVariant()
ds >> value
item[Qt.ItemDataRole(key)] = value
data.append(item)
return data
def loadQDataStream(self):
error = None
fh = None
try:
fh = QFile(self.__fname)
if not fh.open(QIODevice.ReadOnly):
raise IOError(unicode(fh.errorString()))
stream = QDataStream(fh)
magic = stream.readInt32()
if magic != MovieContainer.MAGIC_NUMBER:
raise IOError("unrecognized file type")
version = stream.readInt32()
if version < MovieContainer.FILE_VERSION:
raise IOError("old and unreadable file format")
elif version > MovieContainer.FILE_VERSION:
raise IOError("new and unreadable file format")
stream.setVersion(QDataStream.Qt_4_2)
self.clear(False)
while not stream.atEnd():
title = QString()
acquired = QDate()
notes = QString()
stream >> title
year = stream.readInt16()
minutes = stream.readInt16()
stream >> acquired >> notes
self.add(Movie(title, year, minutes, acquired, notes))
except (IOError, OSError) as e:
error = "Failed to load: {0}".format(e)
finally:
if fh is not None:
fh.close()
if error is not None:
return False, error
self.__dirty = False
return True, "Loaded {0} movie records from {1}".format(
len(self.__movies),
QFileInfo(self.__fname).fileName())
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()))
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 SendStream:
def __init__(self, data : bytes = b''):
self.byteArray = QByteArray(data)
self.buffer = QBuffer(self.byteArray)
self.buffer.open(QBuffer.ReadOnly if data else QBuffer.WriteOnly)
self.stream = QDataStream(self.buffer)
def atEnd(self):
return self.stream.atEnd()
def data(self):
return self.byteArray.data()
def clear(self):
self.buffer.reset()
self.byteArray.resize(0)
def send(self, tcpSocket : QTcpSocket):
writeInt(tcpSocket, len(self.byteArray))
tcpSocket.write(self.byteArray)
def writeBytes(self, data: bytes):
self.buffer.write(b'\xFE')
self.stream.writeBytes(data)
def readBytes(self):
controlByte = self.buffer.read(1)
if controlByte != b'\xFE':
raise Exception('Failed to read bytes from stream')
return self.stream.readBytes()
def writeString(self, s: str):
self.buffer.write(b'\xFD')
self.stream.writeBytes(s.encode())
def readString(self):
controlByte = self.buffer.read(1)
if controlByte != b'\xFD':
raise Exception('Failed to read string from stream.')
return self.stream.readBytes().decode()
def writeInt(self, i: int):
self.buffer.write(b'\xFC')
self.stream.writeInt(i)
def readInt(self):
controlByte = self.buffer.read(1)
if controlByte != b'\xFC':
raise Exception('Failed to read int from stream.')
return self.stream.readInt()
def writeBool(self, b: bool):
self.buffer.write(b'\xFB' if b else b'\xFA')
def readBool(self):
b = self.buffer.read(1)
if b == b'\xFB':
return True
elif b == b'\xFA':
return False
else:
raise Exception('Failed to read bool from stream')
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
