class NetworkConnectionClass(QtCore.QObject):
SignalDataRec = Signal(str, int)
SignalFrameDataAvailable = Signal()
def __init__(self, parent=None):
super(NetworkConnectionClass, self).__init__(parent=parent)
#self.CommandSocket = QTcpSocket()
self.CommandSocket = QUdpSocket()
self.CommandSocket.bind(QHostAddress("192.168.100.2"), 2323)
self.CommandSocket.connected.connect(self.EventConnectedHandle)
self.CommandSocket.readyRead.connect(self.RecieveData)
#self.CommandSocket.connectToHost("192.168.100.5",2323,QIODevice.ReadWrite)
#self.CommandSocket.connectToHost("127.0.0.1",2323,QIODevice.ReadWrite)
#self.CommandSocket.connectToHost("192.168.20.196",2323,QIODevice.ReadWrite)
#print("NETWORK - ",self.CommandSocket.localAddress(),self.CommandSocket.peerAddress())
self.Display = WindowNetworkConnection()
self.NetworkDataArray = QByteArray()
self.NetworkDataArray.resize(2000)
self.SignalDataRec.connect(self.Display.PrintData)
self.BufferWrite = QBuffer(self.NetworkDataArray)
self.BufferWrite.open(QBuffer.WriteOnly)
self.BufferRead = QBuffer(self.NetworkDataArray)
self.BufferRead.open(QBuffer.ReadOnly)
self.ReadDataStream = QDataStream(self.BufferRead)
self.ReadDataStream.setByteOrder(QDataStream.LittleEndian)
self.WriteDataStream = QDataStream(self.BufferWrite)
self.WriteDataStream.setByteOrder(QDataStream.LittleEndian)
self.SocketDataStream = QDataStream(self.CommandSocket)
self.SocketDataStream.setByteOrder(QDataStream.LittleEndian)
self.Timer = QTime()
self.Timer.start()
self.BufferRead.seek(0)
self.BufferWrite.seek(0)
self.LimitBufferSize = 2000
self.MinTransferUnit = 7
self.MaxTransferUnit = 18
self.bytesAvailable = 0
self.Display.ui.pushButton.clicked.connect(self.SendData)
#===================================================== WRITE BUFFER
self.SendBuffer = QByteArray()
#=====================================================
# TestMessage = QByteArray(bytearray.fromhex('A1 A2 A3')); TestMessage2 = QByteArray(bytearray.fromhex('A4 A5 A6'))
# self.BufferWriteQueue.write(TestMessage); self.BufferWriteQueue.write(TestMessage2)
# print("BUFFER - ",self.NetworkDataArray)
# self.Message = MessageData()
# self.Message << self.NetworkDataStream << self.NetworkDataStream
def __rshift__(self, Reciever: DataTransferHeader):
Reciever << self.ReadDataStream
self.bytesAvailable -= Reciever.UNIT_SIZE
print("BYTES AVAILABLE - ", self.bytesAvailable)
#print(" REABUFFER POS - ",self.BufferRead.pos(),'BYTES AVAILABLE - ',self.bytesAvailable,"UNIT SIZE -",Reciever.UNIT_SIZE)
#print(" READ UNIT -",Reciever.UNIT_SIZE)
#print(" READ BUFFER POS -",self.BufferRead.pos())
#print(" READ BUFFER -",self.BufferRead.data().toHex())
if not self.BufferRead.pos(
) < self.LimitBufferSize - self.MaxTransferUnit:
self.BufferRead.seek(0)
print("READ BUFFER SEEK TO 0 - ", self.BufferRead.pos())
return self
def EventConnectedHandle(self):
self.SignalDataRec.emit("CONNECTED TO HOST", 0)
#self.SignalDataRec.emit("192.168.100.5 PORT 2323",0)
self.SignalDataRec.emit("192.168.20.197 PORT 2323", 0)
#self.SignalDataRec.emit("BYTES IN REC BUFFER - " + str(self.bytesAvailable))
def RecieveData(self):
#self.CommandSocket.receiveDatagram(20)
HEADER = QByteArray()
HEADER.resize(2)
if self.bytesAvailable < self.LimitBufferSize - self.MaxTransferUnit: #check that memory for packet available
if self.BufferWrite.pos(
) < self.LimitBufferSize - self.MaxTransferUnit:
(newData, sender,
senderPort) = self.CommandSocket.readDatagram(20)
#newData = self.CommandSocket.read(self.LimitBufferSize - self.bytesAvailable)
#print(" NEW DATA - ",newData.toHex(),"to POS - ",self.BufferWrite.pos())
self.BufferWrite.write(newData)
self.bytesAvailable += newData.size()
print(self.Timer.restart())
#print("REC ",data)
#print(" BUFFER - ",self.BufferWrite.data().toHex())
else:
H1 = 0
H2 = 0
while self.CommandSocket.bytesAvailable() > 0:
H1 = H2
H2 = self.SocketDataStream.readInt16()
if H1 == 0xF1 and (H2 == 0xD1 or H2 == 0xD2 or H2 == 0xD3
or H2 == 0xC1):
self.BufferWrite.seek(0)
newData = self.CommandSocket.read(
self.LimitBufferSize - self.bytesAvailable)
self.WriteDataStream.writeInt16(H1)
self.WriteDataStream.writeInt16(H2)
print(
"=============================================================="
)
print("SEEK TO 0")
print("NEW DATA - ", newData, "to POS - ",
self.BufferWrite.pos() - 4)
self.BufferWrite.write(newData)
self.bytesAvailable += (4 + newData.size())
#print("BUFFER - ",self.NetworkDataArray.toHex())
break
else:
self.WriteDataStream.writeInt16(H2)
self.bytesAvailable += 1
#self.SignalDataRec.emit("BYTES IN REC BUFFER - " + str(self.bytesAvailable))
if (self.bytesAvailable >= self.MinTransferUnit):
self.SignalFrameDataAvailable.emit()
def SendData(self):
Req = ConnectCheckRequest()
self.SendBuffer.clear()
self.SendBuffer.resize(Req.MESSAGE_SIZE)
WriteDataStream = QDataStream(self.SendBuffer, QIODevice.ReadWrite)
WriteDataStream.setByteOrder(QDataStream.LittleEndian)
Req >> WriteDataStream
self.CommandSocket.write(self.SendBuffer)
self.CommandSocket.waitForBytesWritten(20)
self.SignalDataRec.emit("CHECK CONNECT - " + str(Req.Connect), 1)
#self.CommandSocket.write(bytearray(b'TestMessage\r\n'))
#print("WRITE BUFFER - ",self.SendBuffer.toHex())
#print("===============================================")
def HandleErrorSocket(self):
print("ErrorSocket")
class QCanvas(QLabel):
def __init__(self, parent: QWidget, window: MainWindow):
super().__init__(parent)
self.pWindow = window
self.strokeX = []
self.strokeY = []
self.strokeT = []
self.timing = QTime()
self.timing.start()
self.paused = 0
self.painter = QPainter()
self.setStyleSheet("background-color: white;")
""" EVENT: MOUSE CLICK/PRESS """
def mousePressEvent(self, event: QMouseEvent) -> None:
self.timing.restart()
self.strokeX.append(list())
self.strokeY.append(list())
self.strokeT.append(list())
self.strokeX[-1].append(event.x())
self.strokeY[-1].append(event.y())
self.strokeT[-1].append(self.paused)
return super().mousePressEvent(event)
""" EVENT: MOUSE MOVE WHILE PRESSED """
def mouseMoveEvent(self, event: QMouseEvent) -> None:
if event.x() > 0 and event.y() > 0 and event.x() <= self.width() and event.y() <= self.height():
# IF DRAWING IS NOT JUST A MERE POINT...
if len(self.strokeT[-1]) == 1:
self.timing.restart()
self.paused += 1
self.strokeX[-1].append(event.x())
self.strokeY[-1].append(event.y())
self.strokeT[-1].append(self.timing.elapsed() + self.paused)
else: return
return super().mouseMoveEvent(event)
""" EVENT: MOUSE RELEASE """
def mouseReleaseEvent(self, event: QMouseEvent) -> None:
# TO ABLE TO RECOGNIZE POINTS AS PART OF THE DRAWING...
if len(self.strokeT[-1]) == 1:
self.paused += 1
# OTHERWISE, CHECKPOINTS THE MILLISECONDS AS FOLLOWS.
else:
self.paused += (self.timing.elapsed() + 1)
return super().mouseReleaseEvent(event)
""" EVENT: UPDATE PAINT
=> Beware, every time paintEvent updates removes previous drawings.
Therefore, store the data of previous drawing to prevent being erased.
"""
def paintEvent(self, event: QPaintEvent) -> None:
pen = QPen()
pen.setWidth(4)
pen.setColor(Qt.color1)
self.painter.begin(self)
self.painter.setPen(pen)
if len(self.strokeX) != 0:
for stroke in range(len(self.strokeX)):
if len(self.strokeX[stroke]) == 1:
self.painter.drawPoint(self.strokeX[stroke][0], self.strokeY[stroke][0])
else:
for index in range(len(self.strokeX[stroke]) - 1):
self.painter.drawLine(self.strokeX[stroke][index], self.strokeY[stroke][index], self.strokeX[stroke][index+1], self.strokeY[stroke][index+1])
self.painter.end()
self.update()
return super().paintEvent(event)
""" EVENT: UPON SHOWN """
def showEvent(self, event: QShowEvent) -> None:
self.blankCanvas()
return super().showEvent(event)
""" METHOD: CREATE CANVAS """
def blankCanvas(self) -> None:
margin = self.parentWidget().layout().margin()
width = self.topLevelWidget().width()
height = self.topLevelWidget().height()
for index in range(self.parentWidget().layout().count()):
if index != self.parentWidget().layout().indexOf(self):
height -= (self.parentWidget().layout().itemAt(index).widget().height() + margin * 2)
canvas = QBitmap(width - margin * 2, height)
canvas.clear()
self.setPixmap(canvas)
self.update()
""" METHOD: RESET CANVAS """
def resetCanvas(self) -> None:
self.strokeX = []
self.strokeY = []
self.strokeT = []
self.paused = 0
self.blankCanvas()
""" METHOD: UNDO CANVAS """
def undoCanvas(self) -> None:
try:
self.paused = self.strokeT[-1][0]
self.strokeX.pop()
self.strokeY.pop()
self.strokeT.pop()
except IndexError:
print("The canvas is completely empty!")
self.blankCanvas()
