def decodeMimeData(self, bytearray):
"""
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(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 sendImage(self):
self.request = QByteArray()
stream = QDataStream(self.request, QIODevice.WriteOnly)
stream.setVersion(QDataStream.Qt_4_9)
stream.writeUInt32(0)
stream.writeUInt32(1) # HEADER: this is an QImage
ba = QByteArray()
buffer = QBuffer(ba)
self.img = QImage()
self.img.load(f"{self.text}")
self.img.save(buffer, "PNG") # writes image into ba in PNG format
stream.writeBytes(ba)
stream.device().seek(0)
stream.writeUInt32(self.request.size() - self.SIZEOF_UINT32)
self.write(self.request)
self.nextBlockSize = 0
self.request = None
print(f"sending '{self.text}' to Server")
self.messageSent.emit("[SENT] " + self.text)
def _list_item_mime_to_text(mime_data, c=False):
if mime_data.hasText():
return
data = mime_data.data('application/x-qabstractitemmodeldatalist')
if not data:
return
ds = QDataStream(data)
ds.readInt32() # read row (don't need)
ds.readInt32() # read col (don't need)
value = None
for i in range(ds.readInt32()):
if Qt.ItemDataRole(ds.readInt32()) == Qt.DisplayRole:
value = ds.readQVariant()
break
if value is None:
return
if c:
value = 'c("{}")'.format(value)
else:
value = '"{}"'.format(value)
mime_data.setText(value)
def readFortune(self):
instr = QDataStream(self.tcpSocket)
instr.setVersion(QDataStream.Qt_4_0)
if self.blockSize == 0:
if self.tcpSocket.bytesAvailable() < 2:
return
self.blockSize = instr.readUInt16()
if self.tcpSocket.bytesAvailable() < self.blockSize:
return
nextFortune = instr.readQString()
if nextFortune == self.currentFortune:
QTimer.singleShot(0, self.requestNewFortune)
return
self.currentFortune = nextFortune
self.statusLabel.setText(self.currentFortune)
self.getFortuneButton.setEnabled(True)
def restoreState(self, state):
"""
Restore the toolbox from a :class:`QByteArray` `state`.
.. note:: The toolbox should already be populated for the state
changes to take effect.
"""
# In version 1 of saved state the state was saved in
# a simple dict repr string.
if isinstance(state, QByteArray):
stream = QDataStream(state, QIODevice.ReadOnly)
version = stream.readInt()
if version == 2:
expanded = stream.readQStringList()
for action in map(self.tabAction, range(self.count())):
if (action.text() in expanded) != action.isChecked():
action.trigger()
return True
return False
def mimeData(self, indexes):
item_data = QByteArray()
data_stream = QDataStream(item_data, QIODevice.WriteOnly)
data_stream.writeInt(len(indexes))
tmp = None
for idx in indexes:
s_idx = self.mapToSource(idx)
tmp = self.sourceModel().data(s_idx, role=Qt.UserRole)
data_stream.writeInt(tmp.file_id) # file ID
# may need, in case of copy/move for real folder using mimeData
data_stream.writeInt(tmp.dir_id)
# > 0 - virtual folder, 0 - real, -1 - adv.
data_stream.writeInt(tmp.source)
mime_data = QMimeData()
if tmp.source > 0: # files are from virtual folder
mime_data.setData(MimeTypes[VIRTUAL_FILE], item_data)
else:
mime_data.setData(MimeTypes[REAL_FILE], item_data)
return mime_data
def startDrag(self, supportedActions):
item = self.currentItem()
itemData = QByteArray()
dataStream = QDataStream(itemData, QIODevice.WriteOnly)
pixmap = QPixmap(item.data(Qt.UserRole))
location = item.data(Qt.UserRole + 1)
dataStream << pixmap << location
mimeData = QMimeData()
mimeData.setData('image/x-puzzle-piece', itemData)
drag = QDrag(self)
drag.setMimeData(mimeData)
drag.setHotSpot(QPoint(pixmap.width() / 2, pixmap.height() / 2))
drag.setPixmap(pixmap)
if drag.exec_(Qt.MoveAction) == Qt.MoveAction:
if self.currentItem() is not None:
self.takeItem(self.row(item))
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 __iniWrite(self): ##开始写文件操作
self.fileDevice = QFile(self.__testFileName) #创建文件对象
if not self.fileDevice.open(QIODevice.WriteOnly):
del self.fileDevice #删除对象
return False
self.fileStream = QDataStream(self.fileDevice)
self.fileStream.setVersion(QDataStream.Qt_5_12) #设置流版本号，写入和读取的版本号要兼容
if self.ui.radio_BigEndian.isChecked():
self.fileStream.setByteOrder(QDataStream.BigEndian)
else:
self.fileStream.setByteOrder(QDataStream.LittleEndian)
if self.ui.radio_Single.isChecked(): #必须要设置，float和double都按照这个精度
self.fileStream.setFloatingPointPrecision(
QDataStream.SinglePrecision)
else:
self.fileStream.setFloatingPointPrecision(
QDataStream.DoublePrecision)
return True
def readResponse(self):
stream = QDataStream(self.socket)
stream.setVersion(QDataStream.Qt_5_7)
while True:
if self.nextBlockSize == 0:
if self.socket.bytesAvailable() < SIZEOF_UINT16:
break
self.nextBlockSize = stream.readUInt16()
if self.socket.bytesAvailable() < self.nextBlockSize:
break
action = ""
room = ""
date = QDate()
action = stream.readQString()
room = stream.readQString()
if action == "BOOKINGSFORROOM":
dates = []
for x in range(stream.readInt32()):
stream >> date
dates.append(str(date.toString(Qt.ISODate)))
dates = ", ".join(dates)
if action not in ("BOOKINGSFORROOM", "ERROR"):
stream >> date
if action == "ERROR":
msg = "Error: {0}".format(room)
elif action == "BOOK":
msg = "Booked room {0} for {1}".format(
room, date.toString(Qt.ISODate))
elif action == "UNBOOK":
msg = "Unbooked room {0} for {1}".format(
room, date.toString(Qt.ISODate))
elif action == "BOOKINGSONDATE":
msg = "Rooms booked on {0}: {1}".format(
date.toString(Qt.ISODate), room)
elif action == "BOOKINGSFORROOM":
msg = "Room {0} is booked on: {1}".format(room, dates)
self.responseLabel.setText(msg)
self.updateUi()
self.nextBlockSize = 0
def load_from_memory(self): # consumer slot
buf = QBuffer()
ins = QDataStream(buf)
image = QImage()
if True: # first variant (much simpler / shorter, more robust)
try:
from prodcon_ipc.consumer_ipc import ScopedConsumer
with ScopedConsumer(self.consumer_ipc) as sc:
buf.setData(sc.data())
buf.open(QBuffer.ReadOnly)
ins >> image
except Exception as err:
self.ui.label.setText(str(err))
else: # second variant, using begin()...end() manually
try:
data = self.consumer_ipc.begin()
except RuntimeError as err:
self.ui.label.setText(str(err))
return
# Read from the shared memory:
try:
buf.setData(data)
buf.open(QBuffer.ReadOnly)
ins >> image
except Exception as err:
logzero.logger.error(str(err))
try:
self.consumer_ipc.end()
except RuntimeError as err:
self.ui.label.setText(str(err))
return
if not image.isNull():
self.ui.label.setPixmap(QPixmap.fromImage(image))
else:
logzero.logger.error("Image data was corrupted.")
def mousePressEvent(self, event):
child = self.childAt(event.pos())
if not child:
return
if child == self.BackgroundPic:
return
if child == self.ControlPoints[0]:
self.number_of_draggable = 0
else:
self.number_of_draggable = 1
child.move(event.pos())
pixmap = QPixmap(child.pixmap())
itemData = QByteArray()
dataStream = QDataStream(itemData, QIODevice.WriteOnly)
dataStream << pixmap << QPoint(event.pos() - child.pos())
mimeData = QMimeData()
mimeData.setData('application/x-dnditemdata', itemData)
drag = QDrag(self)
drag.setMimeData(mimeData)
drag.setPixmap(pixmap)
drag.setHotSpot(event.pos() - child.pos())
tempPixmap = QPixmap(pixmap)
painter = QPainter()
painter.begin(tempPixmap)
painter.fillRect(pixmap.rect(), QColor(127, 127, 127, 127))
painter.end()
child.setPixmap(tempPixmap)
if drag.exec_(Qt.CopyAction | Qt.MoveAction,
Qt.CopyAction) == Qt.MoveAction:
child.close()
else:
child.show()
child.setPixmap(pixmap)
def switch_language(core_config, lang_key=None):
global _current_translator
global _current_locale_language
QCoreApplication.translate = qt_translate
if not lang_key:
lang_key = core_config.gui_language
if not lang_key:
lang_key = get_locale_language()
logger.info("No language in settings, trying local language",
lang_key=lang_key)
if lang_key not in LANGUAGES.values():
logger.info("Language unavailable, defaulting to English",
lang_key=lang_key)
lang_key = "en"
_current_locale_language = lang_key
rc_file = QFile(f":/translations/translations/parsec_{lang_key}.mo")
if not rc_file.open(QIODevice.ReadOnly):
logger.warning("Unable to read the translations for language",
lang_key=lang_key)
return None
try:
data_stream = QDataStream(rc_file)
out_stream = io.BytesIO()
content = data_stream.readRawData(rc_file.size())
out_stream.write(content)
out_stream.seek(0)
_current_translator = gettext.GNUTranslations(out_stream)
_current_translator.install()
except OSError:
logger.warning("Unable to load the translations for language",
lang_key=lang_key)
return None
finally:
rc_file.close()
return lang_key
def dropEvent(self, event):
if event.mimeData().hasFormat('application/x-fridgemagnet'):
mime = event.mimeData()
itemData = mime.data('application/x-fridgemagnet')
dataStream = QDataStream(itemData, QIODevice.ReadOnly)
text = QByteArray()
offset = QPoint()
dataStream >> text >> offset
try:
# Python v3.
text = str(text, encoding='latin1')
except TypeError:
# Python v2.
text = str(text)
newLabel = DragLabel(text, self)
newLabel.move(event.pos() - offset)
newLabel.show()
if event.source() in self.children():
event.setDropAction(Qt.MoveAction)
event.accept()
else:
event.acceptProposedAction()
elif event.mimeData().hasText():
pieces = event.mimeData().text().split()
position = event.pos()
for piece in pieces:
newLabel = DragLabel(piece, self)
newLabel.move(position)
newLabel.show()
position += QPoint(newLabel.width(), 0)
event.acceptProposedAction()
else:
event.ignore()
def pushButton_save_clicked(self):
""" Slot : Activate the save operation
"""
# If there where no changes - return
if not self.mainItem.dirty:
QMessageBox.critical(None, "Character Identifier - Save",
"Nothing to save")
return
# Get the previous filename and path
path = QFileInfo(
self.filename).path() if self.filename else os.path.join(
dataDir, "Chapter 3 - Distance Metrics")
fname = QFileDialog.getSaveFileName(
self, "Character Identifier - Save", path,
"Character Identifier Files (*.chr)")
# If the user pressed the cancel button in the dialog - return
if not fname:
return
if not fname[0].lower().endswith(".chr"):
fname[0] += ".chr"
self.filename = fname[0]
try:
# Open the file create the stream and activate the save method of the
# main item
fh = QFile(self.filename)
if not fh.open(QIODevice.WriteOnly):
raise IOError(fh.errorString())
stream = QDataStream(fh)
self.mainItem.save(stream, self.filename)
except IOError as e:
QMessageBox.warning(
self, "Character Identifier -- Save Error",
"Failed to save {}: {}".format(self.filename, e))
finally:
if fh is not None:
fh.close()
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 showMessage(self):
stream = QDataStream(
self.tcpSocket) # 发送数据是以QByteArray数据类型发送过来的，所以接收数据也应该以此接收
stream.setVersion(QDataStream.Qt_5_10) # 发送和接收数据以相同的编码形式传输
self.message = stream.readQString(
) # 写入使用writeString, 对应读取使用readQString
self.ui.showText.append(
'%s %s' %
(self.message,
time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time()))))
message_list = self.message.split(',')
self.radio = message_list[3][3:]
self.x1 = message_list[4][3:]
self.y1 = message_list[5][3:]
self.x2 = message_list[6][3:]
self.y2 = message_list[7][3:]
self.R = message_list[-3][3:]
self.G = message_list[-2][3:]
self.B = message_list[-1][3:]
print(message_list)
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(str(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 = ""
owner = ""
country = ""
description = ""
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(str(owner))
self.countries.add(str(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 decode_data(self, 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 mousePressEvent(self, event):
square = self.targetSquare(event.pos())
found = self.findPiece(square)
if found == -1:
return
location = self.pieceLocations[found]
pixmap = self.piecePixmaps[found]
del self.pieceLocations[found]
del self.piecePixmaps[found]
del self.pieceRects[found]
if location == QPoint(square.x() / 80, square.y() / 80):
self.inPlace -= 1
self.update(square)
itemData = QByteArray()
dataStream = QDataStream(itemData, QIODevice.WriteOnly)
dataStream << pixmap << location
mimeData = QMimeData()
mimeData.setData('image/x-puzzle-piece', itemData)
drag = QDrag(self)
drag.setMimeData(mimeData)
drag.setHotSpot(event.pos() - square.topLeft())
drag.setPixmap(pixmap)
if drag.exec_(Qt.MoveAction) != Qt.MoveAction:
self.pieceLocations.insert(found, location)
self.piecePixmaps.insert(found, pixmap)
self.pieceRects.insert(found, square)
self.update(self.targetSquare(event.pos()))
if location == QPoint(square.x() / 80, square.y() / 80):
self.inPlace += 1
def mousePressEvent(self, event):
itemData = QByteArray()
dataStream = QDataStream(itemData, QIODevice.WriteOnly)
dataStream << QByteArray(
self.labelText) << QPoint(event.pos() - self.rect().topLeft())
mimeData = QMimeData()
mimeData.setData('application/x-fridgemagnet', itemData)
mimeData.setText(self.labelText)
drag = QDrag(self)
drag.setMimeData(mimeData)
drag.setHotSpot(event.pos() - self.rect().topLeft())
drag.setPixmap(self.pixmap())
self.hide()
if drag.exec_(Qt.MoveAction | Qt.CopyAction,
Qt.CopyAction) == Qt.MoveAction:
self.close()
else:
self.show()
def open(self):
self.offerSave()
path = (QFileInfo(self.filename).path()
if self.filename else ".")
fname,filetype = QFileDialog.getOpenFileName(self,
"Page Designer - Open", path,
"Page Designer Files (*.pgd)")
if not fname:
return
self.filename = fname
fh = None
try:
fh = QFile(self.filename)
if not fh.open(QIODevice.ReadOnly):
raise IOError(str(fh.errorString()))
items = self.scene.items()
while items:
item = items.pop()
self.scene.removeItem(item)
del item
self.addBorders()
stream = QDataStream(fh)
stream.setVersion(QDataStream.Qt_5_7)
magic = stream.readInt32()
if magic != MagicNumber:
raise IOError("not a valid .pgd file")
fileVersion = stream.readInt16()
if fileVersion != FileVersion:
raise IOError("unrecognised .pgd file version")
while not fh.atEnd():
self.readItemFromStream(stream)
except IOError as e:
QMessageBox.warning(self, "Page Designer -- Open Error",
"Failed to open {0}: {1}".format(self.filename, e))
finally:
if fh is not None:
fh.close()
global Dirty
Dirty = False
def dropEvent(self, event):
if event.mimeData().hasFormat('application/x-dnditemdata'):
itemData = event.mimeData().data('application/x-dnditemdata')
dataStream = QDataStream(itemData, QIODevice.ReadOnly)
pixmap = QPixmap()
offset = QPoint()
dataStream >> pixmap >> offset
newIcon = QLabel(self)
newIcon.setPixmap(pixmap)
newIcon.move(event.pos() - offset)
newIcon.show()
newIcon.setAttribute(Qt.WA_DeleteOnClose)
if event.source() == self:
event.setDropAction(Qt.MoveAction)
event.accept()
else:
event.acceptProposedAction()
else:
event.ignore()
def write(self, map, fileName):
collisionLayer = None
for layer in map.layers():
if layer.name().lower() == "collision":
tileLayer = layer.asTileLayer()
if tileLayer:
if (collisionLayer) :
self.mError = self.tr("Multiple collision layers found!")
return False
collisionLayer = tileLayer
if (not collisionLayer) :
self.mError = self.tr("No collision layer found!")
return False
file = QSaveFile(fileName)
if (not file.open(QIODevice.WriteOnly)) :
self.mError = self.tr("Could not open file for writing.")
return False
width = collisionLayer.width()
height = collisionLayer.height()
stream = QDataStream(file)
stream.setByteOrder(QDataStream.LittleEndian)
stream.writeInt16(width&0xffff)
stream.writeInt16(height&0xffff)
for y in range(0, height):
for x in range(0, width):
tile = collisionLayer.cellAt(x, y).tile
stream.writeInt8(int(tile and tile.id()> 0)&0xff)
if not file.commit():
self.mError = file.errorString()
return False
return True
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()
while socket.bytesAvailable() < blockSize:
if not socket.waitForReadyRead(Timeout):
self.error.emit(socket.error(), socket.errorString())
return
self.mutex.lock()
fortune = instr.readQString()
self.newFortune.emit(fortune)
self.cond.wait(self.mutex)
serverName = self.hostName
serverPort = self.port
self.mutex.unlock()
def _on_drop(self, event):
"""
Adds to graph contents read from MIME data from drop event.
Note that new vertices are added centered at current mouse position.
:type event: QDropEvent
"""
data = event.mimeData().data(constants.QGRAPH_DD_MIME_TYPE)
if not data.isNull():
data_stream = QDataStream(data, QIODevice.ReadOnly)
parsed = json.loads(data_stream.readString().decode('utf8'))
# Refer to `mime.py` for docs about format
version = parsed['version']
if version == 1:
x = event.pos().x()
y = event.pos().y()
vertices = parsed.get('vertices', [])
for v in vertices:
self.api.insert_vertex(
x=x + v['dx'] - v['width'] // 2,
y=y + v['dy'] - v['height'] // 2,
width=v['width'],
height=v['height'],
label=v['label'],
style=v.get('style', None),
tags=v.get('tags', {}),
)
else:
raise ValueError(
"Unsupported version of QmxGraph MIME data: {}".format(
version))
event.acceptProposedAction()
else:
event.ignore()
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())
def __iniRead(self): ##开始写文件操作
if not QFile.exists(self.__testFileName):
QMessageBox.critical(self,"错误","文件不存在")
return False
self.fileDevice=QFile(self.__testFileName) #创建文件对象
if not self.fileDevice.open(QIODevice.ReadOnly):
del self.fileDevice #删除对象
return False
self.fileStream=QDataStream(self.fileDevice)
self.fileStream.setVersion(QDataStream.Qt_5_12) #设置版本号，写入和读取的版本号要兼容
if self.ui.radio_BigEndian.isChecked():
self.fileStream.setByteOrder(QDataStream.BigEndian)
else:
self.fileStream.setByteOrder(QDataStream.LittleEndian)
if self.ui.radio_Single.isChecked(): #必须要设置，float和double都按照这个精度
self.fileStream.setFloatingPointPrecision(QDataStream.SinglePrecision)
else:
self.fileStream.setFloatingPointPrecision(QDataStream.DoublePrecision)
return True
def create_qt_mime_data(data):
"""
Creates a Qt's MIME data object for data in valid QmxGraph's drag&drop
format.
:param dict data: Contents of MIME data.
:rtype: QMimeData
:return: MIME data in QmxGraph format.
"""
from PyQt5.QtCore import QByteArray, QDataStream, QIODevice, QMimeData
item_data = QByteArray()
data_stream = QDataStream(item_data, QIODevice.WriteOnly)
qgraph_mime = {
'version': qmxgraph.constants.QGRAPH_DD_MIME_VERSION,
}
qgraph_mime.update(data)
data_stream.writeString(json.dumps(qgraph_mime).encode('utf8'))
mime_data = QMimeData()
mime_data.setData(qmxgraph.constants.QGRAPH_DD_MIME_TYPE, item_data)
return mime_data
def send_msg(self):
block = QByteArray()
# QDataStream class provides serialization of binary data to a QIODevice
out = QDataStream(block, QIODevice.ReadWrite)
# We are using PyQt5 so set the QDataStream version accordingly.
out.setVersion(QDataStream.Qt_5_0)
out.writeUInt16(0)
text_box_msg = self.textbox.text()
to = ""
msg = ""
if "@" not in text_box_msg:
print(
"TO whom should I send a message? use e.g. @all Hello all or @Max Hello max"
)
return
else:
to, msg = text_box_msg.split(' ',
1)[0], text_box_msg.split(' ', 1)[1]
to = to.replace("@", "")
# get a byte array of the message encoded appropriately.
message = bytes(msg, encoding='ascii')
# now use the QDataStream and write the byte array to it.
out.writeString(message)
out.device().seek(0)
out.writeUInt16(block.size() - 2)
aaa = True
if to == "all":
for conn in self.clientConnections:
conn["conn"].write(block)
else:
for conn in self.clientConnections:
if conn["name"] == to:
conn["conn"].write(block)
aaa = False
if aaa:
print("Sry I server could not send message to", to)
