def __init__(self, host):
super().__init__()
self._sock = QUdpSocket()
self._host = host
self._log = logging.getLogger('udp')
self._sock.readyRead.connect(self.recv)
bind(self._sock)
class WaitingBroadCast(QObject):
def __init__(self,parent=None):
super(WaitingBroadCast,self).__init__(parent)
self.port = 5555
self.udpSocket = QUdpSocket(self)
self.connect(self.udpSocket,SIGNAL("readyRead()"),self.dataReceived)
result = self.udpSocket.bind(self.port)
if not result:
LogRecord.instance().logger.info(u'udpserver create error!')
return
def dataReceived(self):
try:
dataValue = self.getDataContent()
if dataValue:
LogRecord.instance().logger.info(u'接收到广播信息：%s' % dataValue)
self.emit(SIGNAL("operaterCmd"), dataValue)
except:
LogRecord.instance().logger.info(u'广播信息有误：%s' % dataValue)
def getDataContent(self):
while self.udpSocket.hasPendingDatagrams():
msglist = self.udpSocket.readDatagram(self.port)
msg = msglist[0]
return msg
return None
class UdpTx(QWidget):
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.setWindowTitle("UDP Transmit")
self.setWindowIcon(QIcon('g-square.png'))
self.us=QUdpSocket(self)
self.host=QHostAddress(QHostAddress.LocalHost)
self.port=5000
self.us.bytesWritten.connect(self.udpSent)
send=QPushButton("&Send")
send.clicked.connect(self.udpSend)
self.datagram=QLineEdit()
self.datagram.returnPressed.connect(self.udpSend)
l=QVBoxLayout()
l.addWidget(self.datagram)
l.addWidget(send)
self.setLayout(l)
def udpSend(self):
print self.us.writeDatagram(self.datagram.text(), self.host, self.port)
def udpSent(self):
print "Datagram sent"
class UdpRx(QWidget):
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.setWindowTitle("UDP Receive")
self.setGeometry(300,300,300,300)
self.setWindowIcon(QIcon('g-square.png'))
self.us=QUdpSocket(self)
self.us.bind(5000)
self.us.readyRead.connect(self.udpRead)
self.trace=QTextEdit()
self.trace.setReadOnly(True)
self.trace.append("UDP Trace:")
l=QVBoxLayout()
l.addWidget(self.trace)
self.setLayout(l)
def udpRead(self):
while self.us.hasPendingDatagrams():
datagram, host, port=self.us.readDatagram(self.us.pendingDatagramSize())
self.trace.append("%s:%s -> %s" % (host.toString(), port, datagram))
if datagram.strip()=="::kill::":
self.close()
class UdpTx(QWidget):
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.setWindowTitle("UDP Transmit")
self.setWindowIcon(QIcon("g-square.png"))
self.us = QUdpSocket(self)
self.host = QHostAddress(QHostAddress.LocalHost)
self.port = 5000
self.us.bytesWritten.connect(self.udpSent)
send = QPushButton("&Send")
send.clicked.connect(self.udpSend)
self.datagram = QLineEdit()
self.datagram.returnPressed.connect(self.udpSend)
l = QVBoxLayout()
l.addWidget(self.datagram)
l.addWidget(send)
self.setLayout(l)
def udpSend(self):
print self.us.writeDatagram(self.datagram.text(), self.host, self.port)
def udpSent(self):
print "Datagram sent"
def __init__(self,parent=None):
super(SocketThread,self).__init__(parent)
self.clientuuid = str(uuid.uuid4())
self.list = []
self.timetemp = ""
self.msginfo = QByteArray()
self.port = 5555
self.broadFlag = False
self.currentStudent = False
self.porttwo = 5556
self.datagramcount = 40
self.datanum = 0
self.datareceivenum = 0
self.localframenum = 0
self.avilableframenum = 0
self.necnum = 0
self.framedata = {}
self.framelist = {}
self.framedatalist = []
self.currentframe = ""
self.dataframelist = {}
#self.mouseTimer = QTimer()
#self.connect(self.mouseTimer, SIGNAL("timeout()"),self.broadTheMousePos)
self.teacherIp = ""
#self.slotTimer = QTimer()
#self.slotTimer.start(3000)
#self.connect(self.slotTimer, SIGNAL("timeout()"),self.writeDataToSocket)
self.waitingTimer = QTimer()
self.waitingTimer.start(10000)
self.connect(self.waitingTimer, SIGNAL("timeout()"),self.slotStopBroadcastTimeout)
self.waitingTeacher = WaitingTeacher()
self.connect(self.waitingTeacher, SIGNAL("receive_data"),self.operateTeacherMsg)
self.udpSocket = QUdpSocket(self)
#self.udpSocket.setReadBufferSize(1024*1024*2)
self.udpSocket.setReadBufferSize(1024*1024)
self.connect(self.udpSocket,SIGNAL("readyRead()"),self.dataReceive)
self.results = self.udpSocket.bind(self.port)
self.mcast_addr = QHostAddress("224.0.0.17")
self.mcast_addr_two = QHostAddress("224.0.0.18")
self.udpSocketTwo = QUdpSocket(self)
self.udpSocketTwo.setReadBufferSize(1024)
self.connect(self.udpSocketTwo,SIGNAL("readyRead()"),self.dataReceiveTwo)
self.result = self.udpSocketTwo.bind(self.porttwo)
if self.result:
self.joinGroup = self.udpSocketTwo.joinMulticastGroup(self.mcast_addr)
self.joinGroupTwo = self.udpSocketTwo.joinMulticastGroup(self.mcast_addr_two)
print("joinmulticastGroup %d" % self.joinGroup)
self.mcast_addr_own = QHostAddress("224.0.0.19")
def __init__(self):
super(PsyQtChaoscClientBase, self).__init__()
self.osc_sock = QUdpSocket(self)
logger.info("osc bind localhost %d", self.args.client_port)
self.osc_sock.bind(QHostAddress(self.args.client_host),
self.args.client_port)
self.osc_sock.readyRead.connect(self.got_message)
self.osc_sock.error.connect(self.handle_osc_error)
self.subscribe()
def __init__(self, game_port, login, peer_id, recv):
QObject.__init__(self)
self._logger.info("Allocating local relay for {}, {}".format(
login, peer_id))
self._socket = QUdpSocket()
self._socket.stateChanged.connect(self._state_changed)
self._socket.readyRead.connect(self._ready_read)
self.game_port = game_port
self.login, self.peer_id = login, peer_id
self.recv = recv
class Relay(QObject):
bound = pyqtSignal(int)
def __init__(self, game_port, login, peer_id, recv):
QObject.__init__(self)
self._logger.info("Allocating local relay for {}, {}".format(
login, peer_id))
self._socket = QUdpSocket()
self._socket.stateChanged.connect(self._state_changed)
self._socket.readyRead.connect(self._ready_read)
self.game_port = game_port
self.login, self.peer_id = login, peer_id
self.recv = recv
def listen(self):
self._socket.bind()
def send(self, message):
self._logger.debug("game at 127.0.0.1:{}<<{} len: {}".format(
self.game_port, self.peer_id, len(message)))
self._socket.writeDatagram(message, QHostAddress.LocalHost,
self.game_port)
def _state_changed(self, state):
if state == QUdpSocket.BoundState:
self.bound.emit(self._socket.localPort())
def _ready_read(self):
while self._socket.hasPendingDatagrams():
data, host, port = self._socket.readDatagram(
self._socket.pendingDatagramSize())
self._logger.debug("{}>>{}/{}".format(self._socket.localPort(),
self.login, self.peer_id))
self.recv(data)
class Relay(QObject):
bound = pyqtSignal(int)
def __init__(self, game_port, login, peer_id, recv):
QObject.__init__(self)
self._logger.info("Allocating local relay for {}, {}".format(login, peer_id))
self._socket = QUdpSocket()
self._socket.stateChanged.connect(self._state_changed)
self._socket.readyRead.connect(self._ready_read)
self.game_port = game_port
self.login, self.peer_id = login, peer_id
self.recv = recv
def listen(self):
self._socket.bind()
def send(self, message):
self._logger.debug("game at 127.0.0.1:{}<<{} len: {}".format(self.game_port, self.peer_id, len(message)))
self._socket.writeDatagram(message, QHostAddress.LocalHost, self.game_port)
def _state_changed(self, state):
if state == QUdpSocket.BoundState:
self.bound.emit(self._socket.localPort())
def _ready_read(self):
while self._socket.hasPendingDatagrams():
data, host, port = self._socket.readDatagram(self._socket.pendingDatagramSize())
self._logger.debug("{}>>{}/{}".format(self._socket.localPort(), self.login, self.peer_id))
self.recv(data)
def __init__(self, params={}, parent=None):
'''
Constructor
'''
super(UdpDevice, self).__init__(params, parent)
self.iodevice = QUdpSocket()
self.reconnect = int(params.get('Reconnect', 1000))
self.host = params.get('Host', None)
self.port = int(params.get('Port', 2000))
self.iodevice.readyRead.connect(self.readyRead)
self.buffer = list()
def __init__(self,parent=None):
super(SocketThread,self).__init__(parent)
self.clientuuid = str(uuid.uuid4())
self.port = 5555
self.broadFlag = False
self.currentStudent = False
self.porttwo = 5556
self.framedata = {}
self.currentframe = ""
self.dataframelist = {}
self.joinGroupTwo = False
self.udpSocket = QUdpSocket(self)
self.udpSocket.setReadBufferSize(1024*1024)
#self.connect(self.udpSocket,SIGNAL("readyRead()"),self.dataReceive)
self.connect(self.udpSocket,SIGNAL("readyRead()"),self.dataReceiveTest)
self.results = self.udpSocket.bind(self.port)
self.mcast_addr = QHostAddress("224.0.0.17")
self.mcast_addr_two = QHostAddress("224.0.0.18")
self.udpSocketTwo = QUdpSocket(self)
self.udpSocketTwo.setReadBufferSize(1024)
self.connect(self.udpSocketTwo,SIGNAL("readyRead()"),self.dataReceiveTwo)
self.result = self.udpSocketTwo.bind(self.porttwo)
if self.result:
self.joinGroupTwo = self.udpSocketTwo.joinMulticastGroup(self.mcast_addr_two)
print("joinmulticastGroup %d" % self.joinGroupTwo)
if not os.path.exists(os.path.dirname(LOG_PATH)):
os.makedirs(os.path.dirname(LOG_PATH))
handler = logging.handlers.RotatingFileHandler(LOG_PATH, maxBytes = 1024*1024, backupCount = 5) # ?????????handler
fmt = '%(asctime)s - %(filename)s:%(lineno)s - %(name)s - %(message)s'
formatter = logging.Formatter(fmt) # ?????????formatte
handler.setFormatter(formatter) # ???handler??????format
self.logger = logging.getLogger(LOG_PATH) # ????????tst???logger
self.logger.addHandler(handler) # ???logger??????handle
self.logger.setLevel(logging.DEBUG)
self.timer = QTimer()
self.connect(self.timer, SIGNAL("timeout()"), self.bindUdpPort)
self.timer.start(1000)
self.mutex = QMutex()
gc.set_debug(gc.DEBUG_STATS|gc.DEBUG_LEAK)
def __init__(self,parent=None):
super(SocketThread,self).__init__(parent)
self.clientuuid = str(uuid.uuid4())
self.list = []
self.timetemp = ""
self.msginfo = QByteArray()
self.port = 5555
self.broadFlag = True
self.startReceive = False
self.porttwo = 5556
self.datagramcount = 40
self.datanum = 0
self.datareceivenum = 0
self.localframenum = 0
self.avilableframenum = 0
self.necnum = 0
self.framedata = {}
self.framelist = {}
self.framedatalist = []
self.currentframe = ""
self.dataframelist = {}
self.teacherIp = ""
#self.slotTimer = QTimer()
#self.slotTimer.start(3000)
#self.connect(self.slotTimer, SIGNAL("timeout()"),self.writeDataToSocket)
self.udpSocket = QUdpSocket(self)
#self.udpSocket.setReadBufferSize(1024*1024*2)
self.udpSocket.setReadBufferSize(1024*1024)
self.connect(self.udpSocket,SIGNAL("readyRead()"),self.dataReceived)
result = self.udpSocket.bind(self.port)
if not result:
pass
self.mcast_addr_two = QHostAddress("224.0.0.18")
self.udpSocketTwo = QUdpSocket(self)
self.udpSocketTwo.setReadBufferSize(1024)
self.connect(self.udpSocketTwo,SIGNAL("readyRead()"),self.dataReceiveTwo)
result = self.udpSocketTwo.bind(self.porttwo)
self.udpSocketTwo.joinMulticastGroup(self.mcast_addr_two)
if not result:
pass
self.mcast_addr_own = QHostAddress("224.0.0.19")
class MyWidgetchat(QWidget):
def __init__(self,parent=None):
super(MyWidgetchat,self).__init__(parent)
self.ui = Ui_FormChat()
self.ui.setupUi(self)
self.sock = QUdpSocket()
self.ui.textEdit_chat.setStyleSheet("font: 11pt ;")
self.connect(self.ui.pb_sendChat,PyQt4.QtCore.SIGNAL("clicked()"),self.sendChat)
self.connect(self.ui.pb_ding,PyQt4.QtCore.SIGNAL("clicked()"),self.dingT)
self.connect(self.ui.pb_cleareChat,PyQt4.QtCore.SIGNAL("clicked()"),self.clearChatT)
self.connect(self.ui.pb_connect,PyQt4.QtCore.SIGNAL("clicked()"),self.binds)
self.connect(self.sock,PyQt4.QtCore.SIGNAL("readyRead()"),self.readPaygam)
def binds(self):
#1024 < port < 65535
myip=QHostAddress(self.ui.le_my_ip.text())
myport=int(self.ui.le_my_port.text())
if self.sock.bind(myip,myport):
QMessageBox.information(self,"","connected :)")
else:
QMessageBox.information(self,"","not connected :(")
def sendChat(self):
payam=self.ui.le_matnChat.text()
namekarbar=self.ui.lineEdit_3.text()
messageForsend="%s : %s"%(namekarbar,payam)
messageForsend1=messageForsend.encode('utf-8')
self.ui.textEdit_chat.append(messageForsend)
self.ui.le_matnChat.clear()
#---------
yport=int(self.ui.le_yorport.text())
yip = QHostAddress(self.ui.le_yorip.text())
self.sock.writeDatagram(messageForsend1,yip,yport)
def dingT(self):
namekarbar=self.ui.lineEdit_3.text()
payamepishin=self.ui.textEdit_chat.toPlainText()
messagekol="%s \n %s : ding"%(payamepishin,namekarbar)
self.ui.textEdit_chat.setText(messagekol)
def clearChatT(self):
self.ui.textEdit_chat.clear()
def readPaygam(self):
#if(sock.hasPendingDatagrams()
ds = self.sock.pendingDatagramSize()
msg = self.sock.readDatagram(ds)
#msg[0] payam - 1 ip - 2 port
#print("message is : ",msg[0]," host : ",str(msg[1].toString())," port : ",str(msg[2]))
payamamade=str(msg[0].decode('utf-8'))
messagekolamade="%s"%(payamamade)
self.ui.textEdit_chat.append(messagekolamade)
def __init__(self, port, data_cb):
QUdpSocket.__init__(self)
self._session = QTurnSession(self)
self._state = TURNState.UNBOUND
self.bindings = {}
self.port = port
self._data_cb = data_cb
self.turn_host, self.turn_port = config.Settings.get('turn/host', type=unicode, default='dev.faforever.com'), \
config.Settings.get('turn/port', type=int, default=3478)
self._logger.info("Turn socket initialized: {}".format(self.turn_host))
self.turn_address = None
QHostInfo.lookupHost(self.turn_host, self._looked_up)
self.bind(port)
self.readyRead.connect(self._readyRead)
self.error.connect(self._error)
def __init__(self, port, data_cb):
QUdpSocket.__init__(self)
self._session = None
self._state = TURNState.UNBOUND
self.bindings = {}
self.port = port
self._data_cb = data_cb
self.turn_host, self.turn_port = config.Settings.get('turn/host', type=unicode, default='dev.faforever.com'), \
config.Settings.get('turn/port', type=int, default=3478)
self._logger.info("Turn socket initialized: {}".format(self.turn_host))
self.turn_address = None
QHostInfo.lookupHost(self.turn_host, self._looked_up)
self.bind(port)
self.readyRead.connect(self._readyRead)
self.error.connect(self._error)
def __init__(self, portaReceber, portaResponder, parent=None):
super().__init__(portaReceber, portaResponder, parent)
self._socketClient = QUdpSocket()
self._socketClient.bind(self.getPortaReceber())
self._socketClient.readyRead.connect(self._lerDados)
def __init__(self, host):
super().__init__()
self._sock = QUdpSocket()
self._host = host
self._log = logging.getLogger("udp")
self._sock.readyRead.connect(self.recv)
bind(self._sock)
class UdpClient(QThread): def __init__(self, parent): QThread.__init__(self, parent) self.prnt = parent self.udp = QUdpSocket() addr = QHostAddress(QHostAddress.Any) print 'bind to:', addr.toString() self.udp.bind(addr, 34001) self.udp.error.connect(self.errorAnalyser) self.udp.readyRead.connect(self.readUdp) print "Binding..." self.STOP = False self.locker = QMutex() def run(self): self.prnt.initAvahiService() while True : if self.udp is not None and self.udp.state() == QAbstractSocket.ConnectedState : self.udp.waitForReadyRead() else : self.msleep(100) if self.STOP and self.udp is not None: self.udp.close(); break print 'UDPClient closed...' self.prnt.changeConnectState.emit() def stop(self): self.locker.lock() self.STOP = True self.locker.unlock() def readUdp(self): while ( self.udp.hasPendingDatagrams() ): data = QByteArray() addr = QHostAddress() port = 0 try : datagramSize = self.udp.pendingDatagramSize() if datagramSize > 0 : (data, addr, port) = self.udp.readDatagram(datagramSize) #print "Datagram: [%s] from %s:%i" % (QString().fromUtf8(data), addr.toString(), port) self.prnt.contactMessage.emit(QString().fromUtf8(data), addr.toString()) except socket.error, err : print '[in readUdp() UdpClient] SocketError1 : ', err except socket.timeout, err : print '[in readUdp() UdpClient] SocketError2 : ', err except :
def __init__(self, args, parent=None):
self.args = args
QMainWindow.__init__(self, parent)
self.mcount = 0
self.osc_sock = QUdpSocket(self)
logger.info("osc bind localhost %d", self.args.client_port)
self.osc_sock.bind(QHostAddress(self.args.client_host), self.args.client_port)
self.osc_sock.readyRead.connect(self.got_message)
self.osc_sock.error.connect(self.handle_osc_error)
self.subscribe()
self.plot_widget = PlotWidget()
self.setCentralWidget(self.plot_widget)
self.resize(args.client_width, args.client_height)
colors = ["r", "g", "b"]
self.active_actors = list()
self.actors = dict()
self.max_value = 255
actor_names = ["merle", "uwe", "bjoern"]
self.max_actors = len(actor_names)
self.actor_height = self.max_value / self.max_actors
self.fps = 12.5
self.num_data = 100
self.plot_widget.showGrid(False, False)
self.plot_widget.setYRange(0, 255)
self.plot_widget.setXRange(0, self.num_data)
self.plot_widget.resize(args.client_width, args.client_height)
bottom_axis = self.plot_widget.getAxis("bottom")
left_axis = self.plot_widget.getAxis("left")
bottom_axis.setTicks([])
left_axis.setTicks([])
bottom_axis.hide()
left_axis.hide()
for ix, (actor_name, color) in enumerate(zip(actor_names, colors)):
self.add_actor(actor_name, self.num_data, color, ix, self.max_actors, self.actor_height)
self.set_positions()
self.ekg_regex = re.compile("^/(.*?)/ekg$")
self.heartbeat_regex = re.compile("^/(.*?)/heartbeat$")
self.timer = QtCore.QTimer()
self.timer.timeout.connect(self.render_image)
self.timer.start(50)
class SocketUdp(AbstractSocket):
"""Socket que envia e recebe dados via QUdpSocket"""
def __init__(self, portaReceber, portaResponder, parent=None):
super().__init__(portaReceber, portaResponder, parent)
self._socketClient = QUdpSocket()
self._socketClient.bind(self.getPortaReceber())
self._socketClient.readyRead.connect(self._lerDados)
def _lerDados(self):
"""Lê os dados que foram enviados para a portaReceber e emite o sinal dadosRecebidos"""
while self._socketClient.hasPendingDatagrams():
data, host, _port = self._socketClient.readDatagram(self._socketClient.pendingDatagramSize())
self._readDatagram(host.toString(), data)
def _readDatagram(self, ip, data):
self.dadosRecebidos.emit(ip, data)
def enviarDados(self, byteArray):
"""Envia os dados via socketUdp para ip e porta pré-determinados
@param byteArray: Dados que serão enviados"""
if not self.getPara():
self._lancarExcecaoParaNaoDefinido()
self._writeDatagram(byteArray)
def _writeDatagram(self, data):
self._socketClient.writeDatagram(data, QHostAddress(self.getPara()), self.getPortaResponder())
class UdpDevice(DataDevice):
'''
Implementation of a UDP server socket
'''
readyRead = pyqtSignal()
def __init__(self, params={}, parent=None):
'''
Constructor
'''
super(UdpDevice, self).__init__(params, parent)
self.iodevice = QUdpSocket()
self.reconnect = int(params.get('Reconnect', 1000))
self.host = params.get('Host', None)
self.port = int(params.get('Port', 2000))
self.iodevice.readyRead.connect(self.readyRead)
self.buffer = list()
def connectDevice(self):
result = False
if self.host is None:
result = self.iodevice.bind(self.port)
else:
ha = QHostAddress(self.host)
result = self.iodevice.bind(ha, self.port)
if result is False:
if self.reconnect > 0:
QTimer.singleShot(self.reconnect, self.onReconnectTimer)
else:
self.deviceConnected.emit(True)
def disconnectDevice(self):
if self.iodevice.state() is QAbstractSocket.BoundState:
self.iodevice.disconnectFromHost()
self.deviceDisconnected.emit(True)
def readData(self):
(data, ha, port) = self.iodevice.readDatagram(
self.iodevice.pendingDatagramSize())
self.remoteHost = ha.toString()
self.remotePort = port
return data
def readLine(self):
if self.iodevice.hasPendingDatagrams():
self.buffer.extend(self.readData())
try:
i = self.buffer.index('\n')
data = self.buffer[0:i]
del self.buffer[0:i + 1]
return ''.join(data)
except ValueError:
return ''
def __init__(self, game_port, login, peer_id, recv):
QObject.__init__(self)
self._logger.info("Allocating local relay for {}, {}".format(login, peer_id))
self._socket = QUdpSocket()
self._socket.stateChanged.connect(self._state_changed)
self._socket.readyRead.connect(self._ready_read)
self.game_port = game_port
self.login, self.peer_id = login, peer_id
self.recv = recv
class UdpDevice(DataDevice):
'''
Implementation of a UDP server socket
'''
readyRead = pyqtSignal()
def __init__(self, params={}, parent=None):
'''
Constructor
'''
super(UdpDevice, self).__init__(params, parent)
self.iodevice = QUdpSocket()
self.reconnect = int(params.get('Reconnect', 1000))
self.host = params.get('Host', None)
self.port = int(params.get('Port', 2000))
self.iodevice.readyRead.connect(self.readyRead)
self.buffer = list()
def connectDevice(self):
result = False
if self.host is None:
result = self.iodevice.bind(self.port)
else:
ha = QHostAddress(self.host)
result = self.iodevice.bind(ha, self.port)
if result is False:
if self.reconnect > 0:
QTimer.singleShot(self.reconnect, self.onReconnectTimer)
else:
self.deviceConnected.emit(True)
def disconnectDevice(self):
if self.iodevice.state() is QAbstractSocket.BoundState:
self.iodevice.disconnectFromHost()
self.deviceDisconnected.emit(True)
def readData(self):
(data, ha, port) = self.iodevice.readDatagram(self.iodevice.pendingDatagramSize())
self.remoteHost = ha.toString()
self.remotePort = port
return data
def readLine(self):
if self.iodevice.hasPendingDatagrams():
self.buffer.extend(self.readData())
try:
i = self.buffer.index('\n')
data = self.buffer[0:i]
del self.buffer[0:i + 1]
return ''.join(data)
except ValueError:
return ''
def __init__(self,parent=None):
super(MyWidgetchat,self).__init__(parent)
self.ui = Ui_FormChat()
self.ui.setupUi(self)
self.sock = QUdpSocket()
self.ui.textEdit_chat.setStyleSheet("font: 11pt ;")
self.connect(self.ui.pb_sendChat,PyQt4.QtCore.SIGNAL("clicked()"),self.sendChat)
self.connect(self.ui.pb_ding,PyQt4.QtCore.SIGNAL("clicked()"),self.dingT)
self.connect(self.ui.pb_cleareChat,PyQt4.QtCore.SIGNAL("clicked()"),self.clearChatT)
self.connect(self.ui.pb_connect,PyQt4.QtCore.SIGNAL("clicked()"),self.binds)
self.connect(self.sock,PyQt4.QtCore.SIGNAL("readyRead()"),self.readPaygam)
def __init__(self,parent=None):
super(WaitingBroadCast,self).__init__(parent)
self.port = 5555
self.udpSocket = QUdpSocket(self)
self.connect(self.udpSocket,SIGNAL("readyRead()"),self.dataReceived)
result = self.udpSocket.bind(self.port)
if not result:
LogRecord.instance().logger.info(u'udpserver create error!')
return
def __init__(self, params={}, parent=None):
'''
Constructor
'''
super(UdpDevice, self).__init__(params, parent)
self.iodevice = QUdpSocket()
self.reconnect = int(params.get('Reconnect', 1000))
self.host = params.get('Host', None)
self.port = int(params.get('Port', 2000))
self.iodevice.readyRead.connect(self.readyRead)
self.buffer = list()
def __init__(self,parent=None):
super(WaitingBroadCast,self).__init__(parent)
self.port = common.BROAD_CAST_PORT
self.udpSocket = QUdpSocket(self)
self.connect(self.udpSocket,SIGNAL("readyRead()"),self.dataReceived)
self.result = self.udpSocket.bind(self.port)
if not self.result:
#LogRecord.instance().logger.info(u'udpserver create error!')
print("udpserver create error!")
return
class UdpServer(QObject):
datagram = pyqtSignal(str)
def __init__(self, host):
super().__init__()
self._sock = QUdpSocket()
self._host = host
self._log = logging.getLogger('udp')
self._sock.readyRead.connect(self.recv)
bind(self._sock)
def set_host(self, host):
self._host = host
@pyqtSlot(str)
def try_connect(self, port):
port = int(port)
msg = 'connecting to ({}:{})'
msg = msg.format(self._host.toString(), port)
self._log.debug(msg)
self._sock.connectToHost(self._host, port)
self._sock.write('_:start\n')
def recv(self):
while self._sock.hasPendingDatagrams():
data = self._sock.readDatagram(BUFFER_SIZE)
data = data[0]
message = data.decode()
for line in message.split('\n'):
if line == '':
continue
self.datagram.emit(line)
def __init__(self, parent): QThread.__init__(self, parent) self.prnt = parent self.udp = QUdpSocket() addr = QHostAddress(QHostAddress.Any) print 'bind to:', addr.toString() self.udp.bind(addr, 34001) self.udp.error.connect(self.errorAnalyser) self.udp.readyRead.connect(self.readUdp) print "Binding..." self.STOP = False self.locker = QMutex()
class QtPacketProcessing(QThread):
def __init__(self):
QThread.__init__(self)
self.socket = QUdpSocket()
self.socket.bind(QHostAddress(address[0]), address[1])
self.terminate = False
def run(self):
last_packet = -1
m = ctypes.create_string_buffer(ctypes.sizeof(Timetag_packet)*64)
while not self.terminate:
if not self.socket.hasPendingDatagrams():
continue
#b_received = s.recv_into(m)
m, addr, port = self.socket.readDatagram(1024*8)
#print(m)
header = decodeNetPacket(m)
packet_n = header['packet_n']
#print(packet_n)
data_size = header['data_size']
#if b_received > (30 + data_size*8):
# print('Longer message')
## put encoded data in the queue
#packet_queue.put( (header['packet_n'],
#(header['data_size'], m[30:], header['mode']), ),
#)
#packet_n, (data_size, data, mode) = packet_queue.get()
#packet_queue.task_done()
## Verify we are not losing net-packages
if last_packet == -1:
last_packet = packet_n - 1
if packet_n != (last_packet+1)%2**16:
print(packet_n-last_packet, " packet miss")
last_packet = packet_n
#ttm_c.printPacket(data_size, m[30:(data_size+4)*8], header['mode'])
pc.processPacket(data_size, m[30:(data_size+4)*8], header['mode'])
def __init__(self, parent=None):
QObject.__init__(self, parent)
self.__socket = QUdpSocket(self)
self.__socket.readyRead.connect(self.__onReadyRead)
self.__on_read = None
self.__port = None
ips = [] # gel all the local IP-addresses
addresses = QNetworkInterface.allAddresses()
for address in addresses:
match = re.match("(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})", str(address.toString()))
if match:
ip = match.group(0)
if "127.0.0.1" == ip or "0.0.0.0" == ip:
continue
ips.append(ip)
self.__ips = ips
class WaitingBroadCast(QObject):
def __init__(self,parent=None):
super(WaitingBroadCast,self).__init__(parent)
self.port = common.BROAD_CAST_PORT
self.udpSocket = QUdpSocket(self)
self.connect(self.udpSocket,SIGNAL("readyRead()"),self.dataReceived)
self.result = self.udpSocket.bind(self.port)
if not self.result:
#LogRecord.instance().logger.info(u'udpserver create error!')
print("udpserver create error!")
return
def dataReceived(self):
while self.udpSocket.hasPendingDatagrams():
msglist = self.udpSocket.readDatagram(self.port)
msg = msglist[0]
self.emit(SIGNAL("operaterCmd"), msg)
def bindUdpPort(self):
if not self.result:
self.result = self.udpSocket.bind(self.port)
def start_server(self):
self.progressBar.setVisible(True)
self.progressLbl.setVisible(True)
self.progressBar.setValue(2)
if self.check_parameters() != 1:
self.progressLbl.setText("Connecting...")
self.progressBar.setValue(5)
self.set_box_disabled()
if (self.startServer.text() == "Connect"):
self.server = QUdpSocket()
error = self.server.bind(QHostAddress(self.hostIp.text()), self.hostPort.value())
if (error == True):
self.update_my_status_online()
self.timer.start(3000)
self.timer_clientCheck.start(4000)
self.progressBarTimer.start(100)
self.timer2.setSingleShot(True)
self.timer2.start(300)
QtCore.QObject.connect(self.server, QtCore.SIGNAL('readyRead()'), self.read_message)
self.startServer.setText("Disconnect")
elif (error == False):
self.info_box("Connection refused", "The Host Address or Host Port are currently unavailable.")
self.progressBar.setValue(10)
self.progressLbl.setText("Connecting failed!")
self.set_box_enabled()
elif (self.startServer.text() == "Disconnect"):
self.update_my_status_offline()
self.server.close()
self.set_box_enabled()
self.startServer.setText("Connect")
self.label_3.setText("")
self.progressBarTimer.stop()
self.timer2.stop()
self.timer.stop()
self.progressBar.setVisible(False)
self.progressLbl.setVisible(False)
self.timer_clientCheck.stop()
class PsyQtChaoscClientBase(PsyQtClientBase):
def __init__(self):
super(PsyQtChaoscClientBase, self).__init__()
self.osc_sock = QUdpSocket(self)
logger.info("osc bind localhost %d", self.args.client_port)
self.osc_sock.bind(QHostAddress(self.args.client_host),
self.args.client_port)
self.osc_sock.readyRead.connect(self.got_message)
self.osc_sock.error.connect(self.handle_osc_error)
self.subscribe()
def sigint_handler(self, ex_cls, ex, tb):
"""Handler for the SIGINT signal."""
logger.info("sigint_handler")
if ex_cls == KeyboardInterrupt:
logger.info("found KeyboardInterrupt")
self.unsubscribe()
QtGui.QApplication.exit()
else:
logger.critical(''.join(traceback.format_tb(tb)))
logger.critical('{0}: {1}'.format(ex_cls, ex))
def sigterm_handler(self, *args):
logger.info("sigterm_handler")
self.unsubscribe()
QtGui.QApplication.exit()
def subscribe(self):
logger.info("subscribe")
msg = OSCMessage("/subscribe")
logger.info(self.args.client_host)
msg.appendTypedArg(self.args.client_host, "s")
msg.appendTypedArg(self.args.client_port, "i")
msg.appendTypedArg(self.args.authenticate, "s")
if self.args.subscriber_label is not None:
msg.appendTypedArg(self.args.subscriber_label, "s")
self.osc_sock.writeDatagram(QByteArray(msg.encode_osc()),
QHostAddress(self.args.chaosc_host),
self.args.chaosc_port)
def unsubscribe(self):
logger.info("unsubscribe")
msg = OSCMessage("/unsubscribe")
msg.appendTypedArg(self.args.client_host, "s")
msg.appendTypedArg(self.args.client_port, "i")
msg.appendTypedArg(self.args.authenticate, "s")
self.osc_sock.writeDatagram(QByteArray(msg.encode_osc()),
QHostAddress(self.args.chaosc_host),
self.args.chaosc_port)
def handle_osc_error(self, error):
logger.info("osc socket error %d", error)
def closeEvent(self, event):
logger.info("closeEvent", event)
self.unsubscribe()
event.accept()
def bind(self, host=None, port=0, family=None,
mode=QUdpSocket.DontShareAddress):
"""Raises Exception if UDP socket cannot be bound at specified
host and port."""
if not host:
if family==ip.PF_INET6: host = QHostAddress.AnyIPv6
else: host = QHostAddress.Any
if not QHostAddress(host) in (QHostAddress.Any,
QHostAddress.AnyIPv6):
host, port = ip.resolve(host, port,
family if family is not None else 0,
_socket.SOCK_DGRAM)[:2]
if not QUdpSocket.bind(self, QHostAddress(host), port, mode):
raise Exception(self.errorString())
self.__open = True
return self
class UdpSocket(QObject):
def __init__(self, parent=None):
QObject.__init__(self, parent)
self.__socket = QUdpSocket(self)
self.__socket.readyRead.connect(self.__onReadyRead)
self.__on_read = None
self.__port = None
ips = [] # gel all the local IP-addresses
addresses = QNetworkInterface.allAddresses()
for address in addresses:
match = re.match("(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})", str(address.toString()))
if match:
ip = match.group(0)
if "127.0.0.1" == ip or "0.0.0.0" == ip:
continue
ips.append(ip)
self.__ips = ips
def __onReadyRead(self):
while self.__socket.hasPendingDatagrams():
size = self.__socket.pendingDatagramSize()
data, host, port = self.__socket.readDatagram(size)
host = str(host.toString())
if host in self.__ips: # if the datagram comes from the local IP, we simply ignore it
return
source = (host, port)
if self.__on_read:
self.__on_read(source, data)
def __read(self, callback):
self.__on_read = callback
def bind(self, port):
self.__port = port
self.__socket.bind(self.__port, QUdpSocket.ShareAddress)
def write(self, data):
if None == self.__port:
return -1
return self.__socket.writeDatagram(data, QHostAddress.Broadcast, self.__port)
onRead = property(fset=__read)
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.setWindowTitle("UDP Receive")
self.setGeometry(300,300,300,300)
self.setWindowIcon(QIcon('g-square.png'))
self.us=QUdpSocket(self)
self.us.bind(5000)
self.us.readyRead.connect(self.udpRead)
self.trace=QTextEdit()
self.trace.setReadOnly(True)
self.trace.append("UDP Trace:")
l=QVBoxLayout()
l.addWidget(self.trace)
self.setLayout(l)
class EkgPlotWidget(QMainWindow):
def __init__(self, args, parent=None):
self.args = args
QMainWindow.__init__(self, parent)
self.mcount = 0
self.osc_sock = QUdpSocket(self)
logger.info("osc bind localhost %d", self.args.client_port)
self.osc_sock.bind(QHostAddress(self.args.client_host), self.args.client_port)
self.osc_sock.readyRead.connect(self.got_message)
self.osc_sock.error.connect(self.handle_osc_error)
self.subscribe()
self.plot_widget = PlotWidget()
self.setCentralWidget(self.plot_widget)
self.resize(args.client_width, args.client_height)
colors = ["r", "g", "b"]
self.active_actors = list()
self.actors = dict()
self.max_value = 255
actor_names = ["merle", "uwe", "bjoern"]
self.max_actors = len(actor_names)
self.actor_height = self.max_value / self.max_actors
self.fps = 12.5
self.num_data = 100
self.plot_widget.showGrid(False, False)
self.plot_widget.setYRange(0, 255)
self.plot_widget.setXRange(0, self.num_data)
self.plot_widget.resize(args.client_width, args.client_height)
bottom_axis = self.plot_widget.getAxis("bottom")
left_axis = self.plot_widget.getAxis("left")
bottom_axis.setTicks([])
left_axis.setTicks([])
bottom_axis.hide()
left_axis.hide()
for ix, (actor_name, color) in enumerate(zip(actor_names, colors)):
self.add_actor(actor_name, self.num_data, color, ix, self.max_actors, self.actor_height)
self.set_positions()
self.ekg_regex = re.compile("^/(.*?)/ekg$")
self.heartbeat_regex = re.compile("^/(.*?)/heartbeat$")
self.timer = QtCore.QTimer()
self.timer.timeout.connect(self.render_image)
self.timer.start(50)
def subscribe(self):
logger.info("subscribe")
msg = OSCMessage("/subscribe")
msg.appendTypedArg(self.args.client_host, "s")
msg.appendTypedArg(self.args.client_port, "i")
msg.appendTypedArg(self.args.authenticate, "s")
if self.args.subscriber_label is not None:
msg.appendTypedArg(self.args.subscriber_label, "s")
self.osc_sock.writeDatagram(QByteArray(msg.encode_osc()), QHostAddress(self.args.chaosc_host),
self.args.chaosc_port)
def unsubscribe(self):
logger.info("unsubscribe")
msg = OSCMessage("/unsubscribe")
msg.appendTypedArg(self.args.client_host, "s")
msg.appendTypedArg(self.args.client_port, "i")
msg.appendTypedArg(self.args.authenticate, "s")
self.osc_sock.writeDatagram(QByteArray(msg.encode_osc()), QHostAddress(self.args.chaosc_host),
self.args.chaosc_port)
def handle_osc_error(self, error):
logger.info("osc socket error %d", error)
def closeEvent(self, event):
logger.info("closeEvent %r", event)
self.unsubscribe()
event.accept()
def pubdir(self):
return os.path.dirname(os.path.abspath(__file__))
def add_actor(self, actor_name, num_data, color, ix, max_actors, actor_height):
actor_obj = Actor(actor_name, num_data, color, ix, max_actors, actor_height)
self.actors[actor_name] = actor_obj
self.plot_widget.addItem(actor_obj.plotItem)
self.plot_widget.addItem(actor_obj.plotPoint)
self.active_actors.append(actor_obj)
def set_positions(self):
for ix, actor_obj in enumerate(self.active_actors):
actor_obj.plotItem.setPos(0, ix * 2)
actor_obj.plotPoint.setPos(0, ix * 2)
def active_actor_count(self):
return self.max_actors
def update(self, osc_address, args):
res = self.ekg_regex.match(osc_address)
if res:
self.mcount += 1
actor_name = res.group(1)
actor_obj = self.actors[actor_name]
actor_obj.add_value(args[0])
logger.info("actor: %r, %r", actor_name, args)
def render_image(self):
for actor_obj in self.active_actors:
actor_obj.add_value(actor_obj.osci.next())
actor_obj.render()
@QtCore.pyqtSlot()
def render_image(self):
for actor_obj in self.active_actors:
actor_obj.render()
print self.mcount
def got_message(self):
while self.osc_sock.hasPendingDatagrams():
data, address, port = self.osc_sock.readDatagram(self.osc_sock.pendingDatagramSize())
try:
osc_address, typetags, args = decode_osc(data, 0, len(data))
self.update(osc_address, args)
except ValueError, error:
logger.exception(error)
class SocketThread(QThread):
def __init__(self,parent=None):
super(SocketThread,self).__init__(parent)
self.clientuuid = str(uuid.uuid4())
self.list = []
self.timetemp = ""
self.msginfo = QByteArray()
self.port = 5555
self.broadFlag = True
self.startReceive = False
self.porttwo = 5556
self.datagramcount = 40
self.datanum = 0
self.datareceivenum = 0
self.localframenum = 0
self.avilableframenum = 0
self.necnum = 0
self.framedata = {}
self.framelist = {}
self.framedatalist = []
self.currentframe = ""
self.dataframelist = {}
self.teacherIp = ""
#self.slotTimer = QTimer()
#self.slotTimer.start(3000)
#self.connect(self.slotTimer, SIGNAL("timeout()"),self.writeDataToSocket)
self.udpSocket = QUdpSocket(self)
#self.udpSocket.setReadBufferSize(1024*1024*2)
self.udpSocket.setReadBufferSize(1024*1024)
self.connect(self.udpSocket,SIGNAL("readyRead()"),self.dataReceived)
result = self.udpSocket.bind(self.port)
if not result:
pass
self.mcast_addr_two = QHostAddress("224.0.0.18")
self.udpSocketTwo = QUdpSocket(self)
self.udpSocketTwo.setReadBufferSize(1024)
self.connect(self.udpSocketTwo,SIGNAL("readyRead()"),self.dataReceiveTwo)
result = self.udpSocketTwo.bind(self.porttwo)
self.udpSocketTwo.joinMulticastGroup(self.mcast_addr_two)
if not result:
pass
self.mcast_addr_own = QHostAddress("224.0.0.19")
#self.start()
def dataReceive(self):
#totalmsg = ""
self.datareceivenum+=1
while self.udpSocket.hasPendingDatagrams():
datagram = QByteArray()
datagram.resize(self.udpSocket.pendingDatagramSize())
msglist = self.udpSocket.readDatagram(datagram.size())
msg = msglist[0]
timetemp = msg[0:17]
datanumth = msg[17:19]
datatotalnum = msg[19:21]
datacontent = msg[21:]
self.addToLocal(timetemp,datanumth,datatotalnum,datacontent)
#self.timetemp = msg[0:9]
#totalmsg = totalmsg+msg
#self.emit(SIGNAL("imgsignal"),totalmsg)
self.datanum+=1
#self.list.append(msg)
def dataReceived(self):
if self.startReceive == False:
return
try:
msg = self.getDataContent()
timetemp = msg[0:17]
datanumth = msg[17:19]
datatotalnum = msg[19:21]
datacontent = msg[21:]
self.addToLocal(timetemp,datanumth,datatotalnum,datacontent)
self.datanum+=1
except:
def getDataContent(self):
while self.udpSocket.hasPendingDatagrams():
msglist = self.udpSocket.readDatagram(65*1024)
msg = msglist[0]
return msg
return None
def addToLocal(self,timetemp,datanumth,datatotalnum,datacontent):
if self.framedata.has_key(timetemp):
self.framedata[timetemp][datanumth] = datacontent
if len(self.framedata[timetemp]) == int(datatotalnum):
self.localframenum+=1
self.dataframelist[timetemp] = self.framedata[timetemp]
self.framedata.pop(timetemp)
else:
self.framedata[timetemp] = {}
self.framedata[timetemp][datanumth] = datacontent
def parseLocalData(self):
framedatas = self.dataframelist
for key in framedatas.keys():
if len(framedatas[key]) == self.datagramcount:
self.localframenum+=1
dataframe = framedatas[key]
imgdata = ""
for i in range(0,self.datagramcount):
keys = "%02d"%i
imgdata = imgdata + dataframe[keys]
#imgdata = dataframe["00"] + dataframe["01"] + dataframe["02"] + dataframe["03"]
self.framelist[key] = imgdata
self.framedata.pop(key)
return
def sortAddLocalList(self):
if len(self.dataframelist) >= 5:
keylist = []
for key in self.dataframelist:
keylist.append(int(key))
keylist.sort()
imgdata = ""
for i in range(0,len(self.dataframelist[("%017d"%(keylist[0]))])):
keys = "%02d"%i
imgdata = imgdata + self.dataframelist[("%017d"%(keylist[0]))][keys]
self.currentframe = imgdata
self.dataframelist.pop(("%017d"%(keylist[0])))
else:
self.currentframe = None
def dataReceiveTwo(self):
while self.udpSocketTwo.hasPendingDatagrams():
datagram = QByteArray()
datagram.resize(self.udpSocketTwo.pendingDatagramSize())
msglist = self.udpSocketTwo.readDatagram(datagram.size())
msg = str(msglist[0])
self.parseMsg(msg)
def slotStartAllBroadcast(self,msgs):
# flag = False
# iplist = msgs.split("#")
# localip = globalfunc.get_ip_address()
# for item in iplist:
# if item == localip:
# flag = True
# break
# if flag:
#self.udpSocket.joinMulticastGroup(self.mcast_addr)#加入组
self.startReceive = True
self.emit(SIGNAL("startbroadcast"))
self.datanum = 0
self.datareceivenum = 0
self.localframenum = 0
self.avilableframenum = 0
self.necnum = 0
self.broadFlag = True
self.start()
def slotStartSomeBroadcast(self,fmsgs,smsgs):
if fmsgs == "somehost" and QString(smsgs).contains(self.clientuuid):
#self.udpSocket.joinMulticastGroup(self.mcast_addr_own)
self.startReceive = True
self.emit(SIGNAL("startbroadcast"))
self.datanum = 0
self.datareceivenum = 0
self.localframenum = 0
self.avilableframenum = 0
self.necnum = 0
self.broadFlag = True
self.start()
def slotStopBroadcast(self):
pass
def slotSetMousePos(self,msg):
if len(msg.split("#")) == 3:
mousex = int(msg.split("#")[1])
mousey = int(msg.split("#")[2])
self.emit(SIGNAL("mousepos"),mousex,mousey)
def parseMsg(self,msg):
if len(msg.split("#")) >= 2:
if msg.split("#")[0] == "teacherip":
self.teacherIp = msg.split("#")[1]
self.emit(SIGNAL("receiveteacherip"),self.teacherIp)
elif msg.split("#")[0] == "mousepos":
self.slotSetMousePos(msg)
elif msg.split("#")[0] == "startbroadcast":
self.slotStartAllBroadcast(msg)
elif msg.split("#")[0] == "stopbroadcast":
#self.udpSocket.leaveMulticastGroup(self.mcast_addr_own)
self.startReceive = True
self.emit(SIGNAL("stopbroadcast"))
self.broadFlag = False
# lent = len(self.framedata)
# file = open("frame.txt","w")
# file.write(QString.number(self.datanum))
# file.write("++")
# file.write(QString.number(self.datareceivenum))
# file.write("++")
# file.write(QString.number(self.localframenum))
# file.write("++")
# file.write(QString.number(self.necnum))
# file.write("++")
# file.write(QString.number(self.avilableframenum))
# file.write("++")
# file.write(QString.number(lent))
# file.close()
self.framedata.clear()
self.dataframelist.clear()
self.currentframe = None
def writeDataToSocket(self):
hour = "%02d"%(QTime.currentTime().hour())
minute = "%02d"%(QTime.currentTime().minute())
second = "%02d"%(QTime.currentTime().second())
if self.teacherIp != "":
ip = self.teacherIp
name = "client-" + self.clientuuid
data = name + "#" + hour + minute + second
self.udpSocket.writeDatagram(data, QHostAddress(ip), self.porttwo)
def run(self):
#return
while self.broadFlag:
self.sortAddLocalList()
if self.currentframe == None:
time.sleep(0.01)
continue
msg = self.currentframe
#if self.msginfo != msg:
self.necnum+=1
self.avilableframenum+=1
self.emit(SIGNAL("imgsignal"),msg)
self.msginfo = msg
time.sleep(0.01)
def pickImage(self,list):
if len(self.list) >=10:
self.list.remove(self.list[0])
imglist = []
if len(list) <= 2:
return []
#timetemp = list[0][0:9]
for item in list:
if item[0:9] == self.timetemp:
imglist.append(item)
if len(imglist) == 4:
self.list.remove(imglist[0])
self.list.remove(imglist[1])
self.list.remove(imglist[2])
self.list.remove(imglist[3])
return imglist
else:
return []
def __init__(self):
QThread.__init__(self)
self.socket = QUdpSocket()
self.socket.bind(QHostAddress(address[0]), address[1])
self.terminate = False
def __init__(self):
QWidget.__init__(self)
Ui_MainScreen.__init__(self)
self.setupUi(self)
self.settings = Settings()
self.restoreSettingsFromConfig()
# quit app from settings window
self.settings.sigExitOAS.connect(self.exitOAS)
self.settings.sigRebootHost.connect(self.reboot_host)
self.settings.sigShutdownHost.connect(self.shutdown_host)
self.settings.sigConfigFinished.connect(self.configFinished)
settings = QSettings(QSettings.UserScope, "astrastudio", "OnAirScreen")
settings.beginGroup("General")
if settings.value('fullscreen', True).toBool():
self.showFullScreen()
app.setOverrideCursor(QCursor(10))
settings.endGroup()
self.labelWarning.hide()
# add hotkey bindings
QShortcut(QKeySequence("Ctrl+F"), self, self.toggleFullScreen)
QShortcut(QKeySequence("F"), self, self.toggleFullScreen)
QShortcut(QKeySequence(16777429), self,
self.toggleFullScreen) # 'Display' Key on OAS USB Keyboard
QShortcut(QKeySequence(16777379), self,
self.shutdown_host) # 'Calculator' Key on OAS USB Keyboard
QShortcut(QKeySequence("Ctrl+Q"), self,
QCoreApplication.instance().quit)
QShortcut(QKeySequence("Q"), self, QCoreApplication.instance().quit)
QShortcut(QKeySequence("Ctrl+C"), self,
QCoreApplication.instance().quit)
QShortcut(QKeySequence("ESC"), self, QCoreApplication.instance().quit)
QShortcut(QKeySequence("Ctrl+S"), self, self.showsettings)
QShortcut(QKeySequence("Ctrl+,"), self, self.showsettings)
QShortcut(QKeySequence(" "), self, self.radioTimerStartStop)
QShortcut(QKeySequence(","), self, self.radioTimerStartStop)
QShortcut(QKeySequence("."), self, self.radioTimerStartStop)
QShortcut(QKeySequence("0"), self, self.radioTimerReset)
QShortcut(QKeySequence("R"), self, self.radioTimerReset)
QShortcut(QKeySequence("1"), self, self.toggleLED1)
QShortcut(QKeySequence("2"), self, self.toggleLED2)
QShortcut(QKeySequence("3"), self, self.toggleLED3)
QShortcut(QKeySequence("4"), self, self.toggleLED4)
QShortcut(QKeySequence("M"), self, self.toggleAIR1)
QShortcut(QKeySequence("/"), self, self.toggleAIR1)
QShortcut(QKeySequence("P"), self, self.toggleAIR2)
QShortcut(QKeySequence("*"), self, self.toggleAIR2)
QShortcut(QKeySequence("S"), self, self.toggleAIR4)
QShortcut(QKeySequence("Enter"), self, self.getTimerDialog)
QShortcut(QKeySequence("Return"), self, self.getTimerDialog)
# Setup and start timers
self.ctimer = QTimer()
QObject.connect(self.ctimer, SIGNAL("timeout()"), self.constantUpdate)
self.ctimer.start(100)
# LED timers
self.timerLED1 = QTimer()
QObject.connect(self.timerLED1, SIGNAL("timeout()"), self.toggleLED1)
self.timerLED2 = QTimer()
QObject.connect(self.timerLED2, SIGNAL("timeout()"), self.toggleLED2)
self.timerLED3 = QTimer()
QObject.connect(self.timerLED3, SIGNAL("timeout()"), self.toggleLED3)
self.timerLED4 = QTimer()
QObject.connect(self.timerLED4, SIGNAL("timeout()"), self.toggleLED4)
# Setup OnAir Timers
self.timerAIR1 = QTimer()
QObject.connect(self.timerAIR1, SIGNAL("timeout()"),
self.updateAIR1Seconds)
self.Air1Seconds = 0
self.statusAIR1 = False
self.timerAIR2 = QTimer()
QObject.connect(self.timerAIR2, SIGNAL("timeout()"),
self.updateAIR2Seconds)
self.Air2Seconds = 0
self.statusAIR2 = False
self.timerAIR3 = QTimer()
QObject.connect(self.timerAIR3, SIGNAL("timeout()"),
self.updateAIR3Seconds)
self.Air3Seconds = 0
self.statusAIR3 = False
self.radioTimerMode = 0 #count up mode
self.timerAIR4 = QTimer()
QObject.connect(self.timerAIR4, SIGNAL("timeout()"),
self.updateAIR4Seconds)
self.Air4Seconds = 0
self.statusAIR4 = False
self.streamTimerMode = 0 #count up mode
# Setup check NTP Timer
self.ntpHadWarning = True
self.timerNTP = QTimer()
QObject.connect(self.timerNTP, SIGNAL("timeout()"),
self.checkNTPOffset)
# initial check
self.timerNTP.start(5000)
# Setup UDP Socket
self.udpsock = QUdpSocket()
settings = QSettings(QSettings.UserScope, "astrastudio", "OnAirScreen")
settings.beginGroup("Network")
(port, foo) = settings.value('udpport', 3310).toInt()
settings.endGroup()
self.udpsock.bind(port, QUdpSocket.ShareAddress)
self.udpsock.readyRead.connect(self.cmdHandler)
# diplay all host adresses
self.displayAllHostaddresses()
# set NTP warning
settings = QSettings(QSettings.UserScope, "astrastudio", "OnAirScreen")
settings.beginGroup("NTP")
if settings.value('ntpcheck', True).toBool():
self.showWarning("Clock NTP status unknown")
settings.endGroup()
class MainScreen(QWidget, Ui_MainScreen):
def __init__(self):
QWidget.__init__(self)
Ui_MainScreen.__init__(self)
self.setupUi(self)
self.settings = Settings()
self.restoreSettingsFromConfig()
# quit app from settings window
self.settings.sigExitOAS.connect(self.exitOAS)
self.settings.sigRebootHost.connect(self.reboot_host)
self.settings.sigShutdownHost.connect(self.shutdown_host)
self.settings.sigConfigFinished.connect(self.configFinished)
settings = QSettings(QSettings.UserScope, "astrastudio", "OnAirScreen")
settings.beginGroup("General")
if settings.value('fullscreen', True).toBool():
self.showFullScreen()
app.setOverrideCursor(QCursor(10))
settings.endGroup()
self.labelWarning.hide()
# add hotkey bindings
QShortcut(QKeySequence("Ctrl+F"), self, self.toggleFullScreen)
QShortcut(QKeySequence("F"), self, self.toggleFullScreen)
QShortcut(QKeySequence(16777429), self,
self.toggleFullScreen) # 'Display' Key on OAS USB Keyboard
QShortcut(QKeySequence(16777379), self,
self.shutdown_host) # 'Calculator' Key on OAS USB Keyboard
QShortcut(QKeySequence("Ctrl+Q"), self,
QCoreApplication.instance().quit)
QShortcut(QKeySequence("Q"), self, QCoreApplication.instance().quit)
QShortcut(QKeySequence("Ctrl+C"), self,
QCoreApplication.instance().quit)
QShortcut(QKeySequence("ESC"), self, QCoreApplication.instance().quit)
QShortcut(QKeySequence("Ctrl+S"), self, self.showsettings)
QShortcut(QKeySequence("Ctrl+,"), self, self.showsettings)
QShortcut(QKeySequence(" "), self, self.radioTimerStartStop)
QShortcut(QKeySequence(","), self, self.radioTimerStartStop)
QShortcut(QKeySequence("."), self, self.radioTimerStartStop)
QShortcut(QKeySequence("0"), self, self.radioTimerReset)
QShortcut(QKeySequence("R"), self, self.radioTimerReset)
QShortcut(QKeySequence("1"), self, self.toggleLED1)
QShortcut(QKeySequence("2"), self, self.toggleLED2)
QShortcut(QKeySequence("3"), self, self.toggleLED3)
QShortcut(QKeySequence("4"), self, self.toggleLED4)
QShortcut(QKeySequence("M"), self, self.toggleAIR1)
QShortcut(QKeySequence("/"), self, self.toggleAIR1)
QShortcut(QKeySequence("P"), self, self.toggleAIR2)
QShortcut(QKeySequence("*"), self, self.toggleAIR2)
QShortcut(QKeySequence("S"), self, self.toggleAIR4)
QShortcut(QKeySequence("Enter"), self, self.getTimerDialog)
QShortcut(QKeySequence("Return"), self, self.getTimerDialog)
# Setup and start timers
self.ctimer = QTimer()
QObject.connect(self.ctimer, SIGNAL("timeout()"), self.constantUpdate)
self.ctimer.start(100)
# LED timers
self.timerLED1 = QTimer()
QObject.connect(self.timerLED1, SIGNAL("timeout()"), self.toggleLED1)
self.timerLED2 = QTimer()
QObject.connect(self.timerLED2, SIGNAL("timeout()"), self.toggleLED2)
self.timerLED3 = QTimer()
QObject.connect(self.timerLED3, SIGNAL("timeout()"), self.toggleLED3)
self.timerLED4 = QTimer()
QObject.connect(self.timerLED4, SIGNAL("timeout()"), self.toggleLED4)
# Setup OnAir Timers
self.timerAIR1 = QTimer()
QObject.connect(self.timerAIR1, SIGNAL("timeout()"),
self.updateAIR1Seconds)
self.Air1Seconds = 0
self.statusAIR1 = False
self.timerAIR2 = QTimer()
QObject.connect(self.timerAIR2, SIGNAL("timeout()"),
self.updateAIR2Seconds)
self.Air2Seconds = 0
self.statusAIR2 = False
self.timerAIR3 = QTimer()
QObject.connect(self.timerAIR3, SIGNAL("timeout()"),
self.updateAIR3Seconds)
self.Air3Seconds = 0
self.statusAIR3 = False
self.radioTimerMode = 0 #count up mode
self.timerAIR4 = QTimer()
QObject.connect(self.timerAIR4, SIGNAL("timeout()"),
self.updateAIR4Seconds)
self.Air4Seconds = 0
self.statusAIR4 = False
self.streamTimerMode = 0 #count up mode
# Setup check NTP Timer
self.ntpHadWarning = True
self.timerNTP = QTimer()
QObject.connect(self.timerNTP, SIGNAL("timeout()"),
self.checkNTPOffset)
# initial check
self.timerNTP.start(5000)
# Setup UDP Socket
self.udpsock = QUdpSocket()
settings = QSettings(QSettings.UserScope, "astrastudio", "OnAirScreen")
settings.beginGroup("Network")
(port, foo) = settings.value('udpport', 3310).toInt()
settings.endGroup()
self.udpsock.bind(port, QUdpSocket.ShareAddress)
self.udpsock.readyRead.connect(self.cmdHandler)
# diplay all host adresses
self.displayAllHostaddresses()
# set NTP warning
settings = QSettings(QSettings.UserScope, "astrastudio", "OnAirScreen")
settings.beginGroup("NTP")
if settings.value('ntpcheck', True).toBool():
self.showWarning("Clock NTP status unknown")
settings.endGroup()
def radioTimerStartStop(self):
self.startStopAIR3()
def radioTimerReset(self):
self.resetAIR3()
self.radioTimerMode = 0 #count up mode
def radioTimerSet(self, seconds):
self.Air3Seconds = seconds
if seconds > 0:
self.radioTimerMode = 1 #count down mode
else:
self.radioTimerMode = 0 #count up mode
self.AirLabel_3.setText("Timer\n%d:%02d" %
(self.Air3Seconds / 60, self.Air3Seconds % 60))
def getTimerDialog(self):
# generate and display timer input window
self.getTimeWindow = QDialog()
self.getTimeWindow.resize(200, 100)
self.getTimeWindow.setWindowTitle("Please enter timer")
self.getTimeWindow.timeEdit = QLineEdit("Enter timer here")
self.getTimeWindow.timeEdit.selectAll()
self.getTimeWindow.infoLabel = QLabel(
"Examples:\nenter 2,10 for 2:10 minutes\nenter 30 for 30 seconds")
layout = QVBoxLayout()
layout.addWidget(self.getTimeWindow.infoLabel)
layout.addWidget(self.getTimeWindow.timeEdit)
self.getTimeWindow.setLayout(layout)
self.getTimeWindow.timeEdit.setFocus()
self.getTimeWindow.timeEdit.returnPressed.connect(self.parseTimerInput)
self.getTimeWindow.show()
def parseTimerInput(self):
minutes = 0
seconds = 0
# hide input window
self.sender().parent().hide()
# get timestring
text = str(self.sender().text())
if re.match('^[0-9]*,[0-9]*$', text):
(minutes, seconds) = text.split(",")
minutes = int(minutes)
seconds = int(seconds)
elif re.match('^[0-9]*\.[0-9]*$', text):
(minutes, seconds) = text.split(".")
minutes = int(minutes)
seconds = int(seconds)
elif re.match('^[0-9]*$', text):
seconds = int(text)
seconds = (minutes * 60) + seconds
self.radioTimerSet(seconds)
def streamTimerStartStop(self):
self.startStopAIR4()
def streamTimerReset(self):
self.resetAIR4()
self.streamTimerMode = 0 #count up mode
def showsettings(self):
global app
# un-hide mousecursor
app.setOverrideCursor(QCursor(0))
self.settings.showsettings()
def displayAllHostaddresses(self):
v4addrs = list()
v6addrs = list()
for address in QNetworkInterface().allAddresses():
if address.protocol() == 0:
v4addrs.append(address.toString())
#if address.protocol() == 1:
# v6addrs.append(address.toString())
self.setCurrentSongText(", ".join(["%s" % (addr) for addr in v4addrs]))
self.setNewsText(", ".join(["%s" % (addr) for addr in v6addrs]))
def cmdHandler(self):
while self.udpsock.hasPendingDatagrams():
data, host, port = self.udpsock.readDatagram(
self.udpsock.pendingDatagramSize())
#print "DATA: ", data
lines = data.splitlines()
for line in lines:
(command, value) = line.split(':', 1)
#print "command: '" + command + "'"
#print "value: '" + value + "'"
if command == "NOW":
self.setCurrentSongText(value)
if command == "NEXT":
self.setNewsText(value)
if command == "LED1":
if value == "OFF":
self.ledLogic(1, False)
else:
self.ledLogic(1, True)
if command == "LED2":
if value == "OFF":
self.ledLogic(2, False)
else:
self.ledLogic(2, True)
if command == "LED3":
if value == "OFF":
self.ledLogic(3, False)
else:
self.ledLogic(3, True)
if command == "LED4":
if value == "OFF":
self.ledLogic(4, False)
else:
self.ledLogic(4, True)
if command == "WARN":
if value:
self.showWarning(value)
else:
self.hideWarning()
if command == "AIR1":
if value == "OFF":
self.setAIR1(False)
else:
self.setAIR1(True)
if command == "AIR2":
if value == "OFF":
self.setAIR2(False)
else:
self.setAIR2(True)
if command == "AIR3":
if value == "OFF":
self.stopAIR3()
if value == "ON":
self.startAIR3()
if value == "RESET":
self.radioTimerReset()
if value == "TOGGLE":
self.radioTimerStartStop()
if command == "AIR3TIME":
self.radioTimerSet(int(value))
if command == "AIR4":
if value == "OFF":
self.setAIR4(False)
if value == "ON":
self.setAIR4(True)
if value == "RESET":
self.streamTimerReset()
if command == "CMD":
if value == "REBOOT":
self.reboot_host()
if value == "SHUTDOWN":
self.shutdown_host()
if value == "QUIT":
QApplication.quit()
if command == "CONF":
#split group, config and values and apply them
(group, paramvalue) = value.split(':', 1)
(param, content) = paramvalue.split('=', 1)
#print "CONF:", param, content
if group == "General":
if param == "stationname":
self.settings.StationName.setText(content)
if param == "slogan":
self.settings.Slogan.setText(content)
if param == "stationcolor":
self.settings.setStationNameColor(
self.settings.getColorFromName(content))
if param == "slogancolor":
self.settings.setSloganColor(
self.settings.getColorFromName(content))
if group == "LED1":
if param == "used":
self.settings.LED1.setChecked(
QVariant(content).toBool())
if param == "text":
self.settings.LED1Text.setText(content)
if param == "activebgcolor":
self.settings.setLED1BGColor(
self.settings.getColorFromName(content))
if param == "activetextcolor":
self.settings.setLED1FGColor(
self.settings.getColorFromName(content))
if param == "autoflash":
self.settings.LED1Autoflash.setChecked(
QVariant(content).toBool())
if param == "timedflash":
self.settings.LED1Timedflash.setChecked(
QVariant(content).toBool())
if group == "LED2":
if param == "used":
self.settings.LED2.setChecked(
QVariant(content).toBool())
if param == "text":
self.settings.LED2Text.setText(content)
if param == "activebgcolor":
self.settings.setLED2BGColor(
self.settings.getColorFromName(content))
if param == "activetextcolor":
self.settings.setLED2FGColor(
self.settings.getColorFromName(content))
if param == "autoflash":
self.settings.LED2Autoflash.setChecked(
QVariant(content).toBool())
if param == "timedflash":
self.settings.LED2Timedflash.setChecked(
QVariant(content).toBool())
if group == "LED3":
if param == "used":
self.settings.LED3.setChecked(
QVariant(content).toBool())
if param == "text":
self.settings.LED3Text.setText(content)
if param == "activebgcolor":
self.settings.setLED3BGColor(
self.settings.getColorFromName(content))
if param == "activetextcolor":
self.settings.setLED3FGColor(
self.settings.getColorFromName(content))
if param == "autoflash":
self.settings.LED3Autoflash.setChecked(
QVariant(content).toBool())
if param == "timedflash":
self.settings.LED3Timedflash.setChecked(
QVariant(content).toBool())
if group == "LED4":
if param == "used":
self.settings.LED4.setChecked(
QVariant(content).toBool())
if param == "text":
self.settings.LED4Text.setText(content)
if param == "activebgcolor":
self.settings.setLED4BGColor(
self.settings.getColorFromName(content))
if param == "activetextcolor":
self.settings.setLED4FGColor(
self.settings.getColorFromName(content))
if param == "autoflash":
self.settings.LED4Autoflash.setChecked(
QVariant(content).toBool())
if param == "timedflash":
self.settings.LED4Timedflash.setChecked(
QVariant(content).toBool())
if group == "Clock":
if param == "digital":
if content == "True":
self.settings.clockDigital.setChecked(
QVariant(content).toBool())
self.settings.clockAnalog.setChecked(
not QVariant(content).toBool())
if content == "False":
self.settings.clockAnalog.setChecked(
QVariant(content).toBool())
self.settings.clockDigital.setChecked(
not QVariant(content).toBool())
if param == "digitalhourcolor":
self.settings.setDigitalHourColor(
self.settings.getColorFromName(content))
if param == "digitalsecondcolor":
self.settings.setDigitalSecondColor(
self.settings.getColorFromName(content))
if param == "digitaldigitcolor":
self.settings.setDigitalDigitColor(
self.settings.getColorFromName(content))
if param == "logopath":
self.settings.setLogoPath(content)
if group == "Network":
if param == "udpport":
self.settings.udpport.setText(content)
if param == "tcpport":
self.settings.tcpport.setText(content)
if group == "CONF":
if param == "APPLY":
if content == "TRUE":
# apply and save settings
self.settings.applySettings()
def toggleLED1(self):
if self.statusLED1:
self.setLED1(False)
else:
self.setLED1(True)
def toggleLED2(self):
if self.statusLED2:
self.setLED2(False)
else:
self.setLED2(True)
def toggleLED3(self):
if self.statusLED3:
self.setLED3(False)
else:
self.setLED3(True)
def toggleLED4(self):
if self.statusLED4:
self.setLED4(False)
else:
self.setLED4(True)
def toggleAIR1(self):
if self.statusAIR1:
self.setAIR1(False)
else:
self.setAIR1(True)
def toggleAIR2(self):
if self.statusAIR2:
self.setAIR2(False)
else:
self.setAIR2(True)
def toggleAIR4(self):
if self.statusAIR4:
self.setAIR4(False)
else:
self.setAIR4(True)
def unsetLED1(self):
self.ledLogic(1, False)
def unsetLED2(self):
self.ledLogic(2, False)
def unsetLED3(self):
self.ledLogic(3, False)
def unsetLED4(self):
self.ledLogic(4, False)
def ledLogic(self, led, state):
if state == True:
if led == 1:
if self.settings.LED1Autoflash.isChecked():
self.timerLED1.start(500)
if self.settings.LED1Timedflash.isChecked():
self.timerLED1.start(500)
QTimer.singleShot(20000, self.unsetLED1)
self.setLED1(state)
if led == 2:
if self.settings.LED2Autoflash.isChecked():
self.timerLED2.start(500)
if self.settings.LED2Timedflash.isChecked():
self.timerLED2.start(500)
QTimer.singleShot(20000, self.unsetLED2)
self.setLED2(state)
if led == 3:
if self.settings.LED3Autoflash.isChecked():
self.timerLED3.start(500)
if self.settings.LED3Timedflash.isChecked():
self.timerLED3.start(500)
QTimer.singleShot(20000, self.unsetLED3)
self.setLED3(state)
if led == 4:
if self.settings.LED4Autoflash.isChecked():
self.timerLED4.start(500)
if self.settings.LED4Timedflash.isChecked():
self.timerLED4.start(500)
QTimer.singleShot(20000, self.unsetLED4)
self.setLED4(state)
if state == False:
if led == 1:
self.setLED1(state)
self.timerLED1.stop()
if led == 2:
self.setLED2(state)
self.timerLED2.stop()
if led == 3:
self.setLED3(state)
self.timerLED3.stop()
if led == 4:
self.setLED4(state)
self.timerLED4.stop()
def setStationColor(self, newcolor):
palette = self.labelStation.palette()
palette.setColor(QPalette.WindowText, newcolor)
self.labelStation.setPalette(palette)
def setSloganColor(self, newcolor):
palette = self.labelSlogan.palette()
palette.setColor(QPalette.WindowText, newcolor)
self.labelSlogan.setPalette(palette)
def restoreSettingsFromConfig(self):
settings = QSettings(QSettings.UserScope, "astrastudio", "OnAirScreen")
settings.beginGroup("General")
self.labelStation.setText(
settings.value('stationname', 'Radio Eriwan').toString())
self.labelSlogan.setText(
settings.value('slogan',
'Your question is our motivation').toString())
self.setStationColor(
self.settings.getColorFromName(
settings.value('stationcolor', '#FFAA00').toString()))
self.setSloganColor(
self.settings.getColorFromName(
settings.value('slogancolor', '#FFAA00').toString()))
settings.endGroup()
settings.beginGroup("LED1")
self.setLED1Text(settings.value('text', 'ON AIR').toString())
settings.endGroup()
settings.beginGroup("LED2")
self.setLED2Text(settings.value('text', 'PHONE').toString())
settings.endGroup()
settings.beginGroup("LED3")
self.setLED3Text(settings.value('text', 'DOORBELL').toString())
settings.endGroup()
settings.beginGroup("LED4")
self.setLED4Text(settings.value('text', 'ARI').toString())
settings.endGroup()
settings.beginGroup("Clock")
self.clockWidget.setClockMode(settings.value('digital', True).toBool())
self.clockWidget.setDigiHourColor(
self.settings.getColorFromName(
settings.value('digitalhourcolor', '#3232FF').toString()))
self.clockWidget.setDigiSecondColor(
self.settings.getColorFromName(
settings.value('digitalsecondcolor', '#FF9900').toString()))
self.clockWidget.setDigiDigitColor(
self.settings.getColorFromName(
settings.value('digitaldigitcolor', '#3232FF').toString()))
self.clockWidget.setLogo(
settings.value(
'logopath',
':/astrastudio_logo/astrastudio_transparent.png').toString())
settings.endGroup()
def constantUpdate(self):
# slot for constant timer timeout
self.updateDate()
self.updateBacktimingText()
self.updateBacktimingSeconds()
def updateDate(self):
now = datetime.now()
self.setLeftText(QDate.currentDate().toString("dddd, dd. MMMM yyyy"))
def updateBacktimingText(self):
now = datetime.now()
hour = now.hour
minute = now.minute
second = now.second
remain_min = 60 - minute
if hour > 12:
hour -= 12
if minute > 0 and minute < 25:
string = "%d Minute%s nach %d" % (minute,
'n' if minute > 1 else '', hour)
if minute >= 25 and minute < 30:
string = "%d Minute%s vor halb %d" % (
remain_min - 30, 'n' if remain_min - 30 > 1 else '', hour + 1)
if minute >= 30 and minute <= 39:
string = "%d Minute%s nach halb %d" % (
30 - remain_min, 'n' if 30 - remain_min > 1 else '', hour + 1)
if minute >= 40 and minute <= 59:
string = "%d Minute%s vor %d" % (remain_min, 'n' if remain_min > 1
else '', hour + 1)
if minute == 30:
string = "halb %d" % (hour + 1)
if minute == 0:
string = "%d" % hour
self.setRightText(string)
def updateBacktimingSeconds(self):
now = datetime.now()
second = now.second
remain_seconds = 60 - second
self.setBacktimingSecs(remain_seconds)
def toggleFullScreen(self):
global app
settings = QSettings(QSettings.UserScope, "astrastudio", "OnAirScreen")
settings.beginGroup("General")
if not settings.value('fullscreen', 'True').toBool():
self.showFullScreen()
app.setOverrideCursor(QCursor(10))
settings.setValue('fullscreen', True)
else:
self.showNormal()
app.setOverrideCursor(QCursor(0))
settings.setValue('fullscreen', False)
settings.endGroup()
def setAIR1(self, action):
settings = QSettings(QSettings.UserScope, "astrastudio", "OnAirScreen")
if action:
self.Air1Seconds = 0
self.AirLabel_1.setStyleSheet(
"color: #000000; background-color: #FF0000")
self.AirIcon_1.setStyleSheet(
"color: #000000; background-color: #FF0000")
self.AirLabel_1.setText(
"Mic\n%d:%02d" %
(self.Air1Seconds / 60, self.Air1Seconds % 60))
self.statusAIR1 = True
# AIR1 timer
self.timerAIR1.start(1000)
else:
settings.beginGroup("LEDS")
self.AirIcon_1.setStyleSheet(
"color:" +
settings.value('inactivetextcolor', '#555555').toString() +
";background-color:" +
settings.value('inactivebgcolor', '#222222').toString())
self.AirLabel_1.setStyleSheet(
"color:" +
settings.value('inactivetextcolor', '#555555').toString() +
";background-color:" +
settings.value('inactivebgcolor', '#222222').toString())
settings.endGroup()
self.statusAIR1 = False
self.timerAIR1.stop()
def updateAIR1Seconds(self):
self.Air1Seconds += 1
self.AirLabel_1.setText("Mic\n%d:%02d" %
(self.Air1Seconds / 60, self.Air1Seconds % 60))
def setAIR2(self, action):
settings = QSettings(QSettings.UserScope, "astrastudio", "OnAirScreen")
if action:
self.Air2Seconds = 0
self.AirLabel_2.setStyleSheet(
"color: #000000; background-color: #FF0000")
self.AirIcon_2.setStyleSheet(
"color: #000000; background-color: #FF0000")
self.AirLabel_2.setText(
"Phone\n%d:%02d" %
(self.Air2Seconds / 60, self.Air2Seconds % 60))
self.statusAIR2 = True
# AIR2 timer
self.timerAIR2.start(1000)
else:
settings.beginGroup("LEDS")
self.AirIcon_2.setStyleSheet(
"color:" +
settings.value('inactivetextcolor', '#555555').toString() +
";background-color:" +
settings.value('inactivebgcolor', '#222222').toString())
self.AirLabel_2.setStyleSheet(
"color:" +
settings.value('inactivetextcolor', '#555555').toString() +
";background-color:" +
settings.value('inactivebgcolor', '#222222').toString())
settings.endGroup()
self.statusAIR2 = False
self.timerAIR2.stop()
def updateAIR2Seconds(self):
self.Air2Seconds += 1
self.AirLabel_2.setText("Phone\n%d:%02d" %
(self.Air2Seconds / 60, self.Air2Seconds % 60))
def resetAIR3(self):
self.timerAIR3.stop()
self.Air3Seconds = 0
self.AirLabel_3.setText("Timer\n%d:%02d" %
(self.Air3Seconds / 60, self.Air3Seconds % 60))
if self.statusAIR3 == True:
self.timerAIR3.start(1000)
def setAIR3(self, action):
settings = QSettings(QSettings.UserScope, "astrastudio", "OnAirScreen")
if action:
self.AirLabel_3.setStyleSheet(
"color: #000000; background-color: #FF0000")
self.AirIcon_3.setStyleSheet(
"color: #000000; background-color: #FF0000")
self.AirLabel_3.setText(
"Timer\n%d:%02d" %
(self.Air3Seconds / 60, self.Air3Seconds % 60))
self.statusAIR3 = True
# substract initial second on countdown with display update
if self.radioTimerMode == 1 and self.Air3Seconds > 1:
self.updateAIR3Seconds()
# AIR3 timer
self.timerAIR3.start(1000)
else:
settings.beginGroup("LEDS")
self.AirIcon_3.setStyleSheet(
"color:" +
settings.value('inactivetextcolor', '#555555').toString() +
";background-color:" +
settings.value('inactivebgcolor', '#222222').toString())
self.AirLabel_3.setStyleSheet(
"color:" +
settings.value('inactivetextcolor', '#555555').toString() +
";background-color:" +
settings.value('inactivebgcolor', '#222222').toString())
settings.endGroup()
self.statusAIR3 = False
self.timerAIR3.stop()
def startStopAIR3(self):
if self.statusAIR3 == False:
self.startAIR3()
else:
self.stopAIR3()
def startAIR3(self):
self.setAIR3(True)
def stopAIR3(self):
self.setAIR3(False)
def updateAIR3Seconds(self):
if self.radioTimerMode == 0: #count up mode
self.Air3Seconds += 1
else:
self.Air3Seconds -= 1
if self.Air3Seconds < 1:
self.stopAIR3()
self.radioTimerMode = 0
self.AirLabel_3.setText("Timer\n%d:%02d" %
(self.Air3Seconds / 60, self.Air3Seconds % 60))
def resetAIR4(self):
self.timerAIR4.stop()
self.Air4Seconds = 0
self.AirLabel_4.setText("Stream\n%d:%02d" %
(self.Air4Seconds / 60, self.Air4Seconds % 60))
if self.statusAIR4 == True:
self.timerAIR4.start(1000)
def setAIR4(self, action):
settings = QSettings(QSettings.UserScope, "astrastudio", "OnAirScreen")
if action:
self.AirLabel_4.setStyleSheet(
"color: #000000; background-color: #FF0000")
self.AirIcon_4.setStyleSheet(
"color: #000000; background-color: #FF0000")
self.AirLabel_4.setText(
"Stream\n%d:%02d" %
(self.Air4Seconds / 60, self.Air4Seconds % 60))
self.statusAIR4 = True
# substract initial second on countdown with display update
if self.streamTimerMode == 1 and self.Air4Seconds > 1:
self.updateAIR4Seconds()
# AIR4 timer
self.timerAIR4.start(1000)
else:
settings.beginGroup("LEDS")
self.AirIcon_4.setStyleSheet(
"color:" +
settings.value('inactivetextcolor', '#555555').toString() +
";background-color:" +
settings.value('inactivebgcolor', '#222222').toString())
self.AirLabel_4.setStyleSheet(
"color:" +
settings.value('inactivetextcolor', '#555555').toString() +
";background-color:" +
settings.value('inactivebgcolor', '#222222').toString())
settings.endGroup()
self.statusAIR4 = False
self.timerAIR4.stop()
def startStopAIR4(self):
if self.statusAIR4 == False:
self.startAIR4()
else:
self.stopAIR4()
def startAIR4(self):
self.setAIR4(True)
def stopAIR4(self):
self.setAIR4(False)
def updateAIR4Seconds(self):
if self.streamTimerMode == 0: #count up mode
self.Air4Seconds += 1
else:
self.Air4Seconds -= 1
if self.Air4Seconds < 1:
self.stopAIR4()
self.radioTimerMode = 0
self.AirLabel_4.setText("Stream\n%d:%02d" %
(self.Air4Seconds / 60, self.Air4Seconds % 60))
def checkNTPOffset(self):
settings = QSettings(QSettings.UserScope, "astrastudio", "OnAirScreen")
settings.beginGroup("NTP")
ntpcheck = settings.value('ntpcheck', True).toBool()
ntpserver = str(
settings.value('ntpcheckserver', 'pool.ntp.org').toString())
settings.endGroup()
if not ntpcheck:
return
self.timerNTP.stop()
max_deviation = 0.3
c = ntplib.NTPClient()
try:
response = c.request(ntpserver)
if response.offset > max_deviation or response.offset < -max_deviation:
print "offset too big: %f while checking %s" % (
response.offset, ntpserver)
self.showWarning("Clock not NTP synchronized: offset too big")
self.ntpHadWarning = True
else:
if self.ntpHadWarning == True:
self.ntpHadWarning = False
self.hideWarning()
except socket.timeout:
print "timeout checking NTP %s" % ntpserver
self.showWarning("Clock not NTP synchronized")
self.ntpHadWarning = True
except socket.gaierror:
print "error checking NTP %s" % ntpserver
self.showWarning("Clock not NTP synchronized")
self.ntpHadWarning = True
except:
print "general error checking NTP %s" % ntpserver
self.showWarning("Clock not NTP synchronized")
self.ntpHadWarning = True
self.timerNTP.start(60000)
def setLED1(self, action):
settings = QSettings(QSettings.UserScope, "astrastudio", "OnAirScreen")
if action:
settings.beginGroup("LED1")
self.buttonLED1.setStyleSheet(
"color:" +
settings.value('activetextcolor', '#FFFFFF').toString() +
";background-color:" +
settings.value('activebgcolor', '#FF0000').toString())
settings.endGroup()
self.statusLED1 = True
else:
settings.beginGroup("LEDS")
self.buttonLED1.setStyleSheet(
"color:" +
settings.value('inactivetextcolor', '#555555').toString() +
";background-color:" +
settings.value('inactivebgcolor', '#222222').toString())
settings.endGroup()
self.statusLED1 = False
def setLED2(self, action):
settings = QSettings(QSettings.UserScope, "astrastudio", "OnAirScreen")
if action:
settings.beginGroup("LED2")
self.buttonLED2.setStyleSheet(
"color:" +
settings.value('activetextcolor', '#FFFFFF').toString() +
";background-color:" +
settings.value('activebgcolor', '#FF0000').toString())
settings.endGroup()
self.statusLED2 = True
else:
settings.beginGroup("LEDS")
self.buttonLED2.setStyleSheet(
"color:" +
settings.value('inactivetextcolor', '#555555').toString() +
";background-color:" +
settings.value('inactivebgcolor', '#222222').toString())
settings.endGroup()
self.statusLED2 = False
def setLED3(self, action):
settings = QSettings(QSettings.UserScope, "astrastudio", "OnAirScreen")
if action:
settings.beginGroup("LED3")
self.buttonLED3.setStyleSheet(
"color:" +
settings.value('activetextcolor', '#FFFFFF').toString() +
";background-color:" +
settings.value('activebgcolor', '#FF0000').toString())
settings.endGroup()
self.statusLED3 = True
else:
settings.beginGroup("LEDS")
self.buttonLED3.setStyleSheet(
"color:" +
settings.value('inactivetextcolor', '#555555').toString() +
";background-color:" +
settings.value('inactivebgcolor', '#222222').toString())
settings.endGroup()
self.statusLED3 = False
def setLED4(self, action):
settings = QSettings(QSettings.UserScope, "astrastudio", "OnAirScreen")
if action:
settings.beginGroup("LED4")
self.buttonLED4.setStyleSheet(
"color:" +
settings.value('activetextcolor', '#FFFFFF').toString() +
";background-color:" +
settings.value('activebgcolor', '#FF0000').toString())
settings.endGroup()
self.statusLED4 = True
else:
settings.beginGroup("LEDS")
self.buttonLED4.setStyleSheet(
"color:" +
settings.value('inactivetextcolor', '#555555').toString() +
";background-color:" +
settings.value('inactivebgcolor', '#222222').toString())
settings.endGroup()
self.statusLED4 = False
def setStation(self, text):
self.labelStation.setText(text)
def setSlogan(self, text):
self.labelSlogan.setText(text)
def setLeftText(self, text):
self.labelTextLeft.setText(text)
def setRightText(self, text):
self.labelTextRight.setText(text)
def setLED1Text(self, text):
self.buttonLED1.setText(text)
def setLED2Text(self, text):
self.buttonLED2.setText(text)
def setLED3Text(self, text):
self.buttonLED3.setText(text)
def setLED4Text(self, text):
self.buttonLED4.setText(text)
def setCurrentSongText(self, text):
self.labelCurrentSong.setText(text)
def setNewsText(self, text):
self.labelNews.setText(text)
def setBacktimingSecs(self, value):
pass
#self.labelSeconds.setText( str(value) )
def showWarning(self, text):
self.labelCurrentSong.hide()
self.labelNews.hide()
self.labelWarning.setText(text)
font = self.labelWarning.font()
font.setPointSize(45)
self.labelWarning.setFont(font)
self.labelWarning.show()
def hideWarning(self):
self.labelWarning.hide()
self.labelCurrentSong.show()
self.labelNews.show()
self.labelWarning.setText("")
self.labelWarning.hide()
def exitOAS(self):
global app
app.exit()
def configFinished(self):
self.restoreSettingsFromConfig()
global app
# hide mousecursor if in fullscreen mode
settings = QSettings(QSettings.UserScope, "astrastudio", "OnAirScreen")
settings.beginGroup("General")
if settings.value('fullscreen', 'True').toBool():
app.setOverrideCursor(QCursor(10))
settings.endGroup()
def reboot_host(self):
self.showWarning("SYSTEM REBOOT IN PROGRESS")
if os.name == "posix":
cmd = "sudo reboot"
os.system(cmd)
if os.name == "nt":
cmd = "shutdown -f -r -t 0"
pass
def shutdown_host(self):
self.showWarning("SYSTEM SHUTDOWN IN PROGRESS")
if os.name == "posix":
cmd = "sudo halt"
os.system(cmd)
if os.name == "nt":
cmd = "shutdown -f -t 0"
pass
class MainWindow(QtGui.QMainWindow):
"""This app receives per actor osc messages and provides an mjpeg stream
with colored text representation arranged in columns"""
def __init__(self, args, parent=None):
self.args = args
QtGui.QMainWindow.__init__(self, parent)
self.osc_sock = QUdpSocket(self)
logger.info("osc bind localhost %d", self.args.client_port)
self.osc_sock.bind(QHostAddress(self.args.client_host),
self.args.client_port)
self.osc_sock.readyRead.connect(self.got_message)
self.osc_sock.error.connect(self.handle_osc_error)
self.subscribe()
self.graphics_view = QtGui.QGraphicsView(self)
self.resize(640, 480)
font = QtGui.QFont()
font.setFamily(_fromUtf8("Monospace"))
font.setPointSize(12)
font.setItalic(True)
self.setFont(font)
palette = QtGui.QPalette()
brush = QtGui.QBrush(QtGui.QColor(255, 255, 255))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.WindowText,
brush)
brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Button, brush)
brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Light, brush)
brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Midlight, brush)
brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Dark, brush)
brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Mid, brush)
brush = QtGui.QBrush(QtGui.QColor(255, 255, 255))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Text, brush)
brush = QtGui.QBrush(QtGui.QColor(255, 255, 255))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.BrightText,
brush)
brush = QtGui.QBrush(QtGui.QColor(255, 255, 255))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.ButtonText,
brush)
brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Base, brush)
brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Window, brush)
brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Shadow, brush)
brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.AlternateBase,
brush)
brush = QtGui.QBrush(QtGui.QColor(255, 255, 220))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.ToolTipBase,
brush)
brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.ToolTipText,
brush)
brush = QtGui.QBrush(QtGui.QColor(255, 255, 255))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.WindowText,
brush)
brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Button, brush)
brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Light, brush)
brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Midlight,
brush)
brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Dark, brush)
brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Mid, brush)
brush = QtGui.QBrush(QtGui.QColor(255, 255, 255))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Text, brush)
brush = QtGui.QBrush(QtGui.QColor(255, 255, 255))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.BrightText,
brush)
brush = QtGui.QBrush(QtGui.QColor(255, 255, 255))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.ButtonText,
brush)
brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Base, brush)
brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Window, brush)
brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Shadow, brush)
brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.AlternateBase,
brush)
brush = QtGui.QBrush(QtGui.QColor(255, 255, 220))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.ToolTipBase,
brush)
brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.ToolTipText,
brush)
brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.WindowText,
brush)
brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Button, brush)
brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Light, brush)
brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Midlight,
brush)
brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Dark, brush)
brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Mid, brush)
brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Text, brush)
brush = QtGui.QBrush(QtGui.QColor(255, 255, 255))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.BrightText,
brush)
brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.ButtonText,
brush)
brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Base, brush)
brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Window, brush)
brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Shadow, brush)
brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.AlternateBase,
brush)
brush = QtGui.QBrush(QtGui.QColor(255, 255, 220))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.ToolTipBase,
brush)
brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.ToolTipText,
brush)
self.graphics_view.setPalette(palette)
self.graphics_view.setAutoFillBackground(False)
self.graphics_view.setObjectName(_fromUtf8("graphics_view"))
self.setCentralWidget(self.graphics_view)
self.graphics_view.setHorizontalScrollBarPolicy(
QtCore.Qt.ScrollBarAlwaysOff)
self.graphics_view.setVerticalScrollBarPolicy(
QtCore.Qt.ScrollBarAlwaysOff)
self.graphics_view.setRenderHint(QtGui.QPainter.Antialiasing, True)
self.graphics_view.setFrameStyle(QtGui.QFrame.NoFrame)
self.graphics_scene = QtGui.QGraphicsScene(self)
self.graphics_scene.setSceneRect(0, 0, 640, 480)
self.graphics_view.setScene(self.graphics_scene)
self.default_font = QtGui.QFont("Monospace", 12)
self.default_font.setStyleHint(QtGui.QFont.Monospace)
self.default_font.setBold(True)
self.graphics_scene.setFont(self.default_font)
self.font_metrics = QtGui.QFontMetrics(self.default_font)
self.line_height = self.font_metrics.height()
self.setWindowTitle(_translate("MainWindow", "DumpGrabberMain", None))
columns = 3
self.column_width = 640 / columns
self.text_storage = ExclusiveTextStorage(columns, self.default_font,
self.column_width,
self.line_height,
self.graphics_scene)
self.text_storage.init_columns()
self.regex = re.compile("^/(uwe|merle|bjoern)/(.*?)$")
self.osc_sock.readyRead.connect(self.got_message)
self.timer = QtCore.QTimer()
self.timer.timeout.connect(self.render_image)
self.timer.start(100)
def sigint_handler(self, ex_cls, ex, tb):
"""Handler for the SIGINT signal."""
logger.info("sigint_handler")
if ex_cls == KeyboardInterrupt:
logger.info("found KeyboardInterrupt")
self.unsubscribe()
QtGui.QApplication.exit()
else:
logger.critical(''.join(traceback.format_tb(tb)))
logger.critical('{0}: {1}'.format(ex_cls, ex))
def sigterm_handler(self, *args):
logger.info("sigterm_handler")
self.unsubscribe()
QtGui.QApplication.exit()
def subscribe(self):
logger.info("subscribe")
msg = OSCMessage("/subscribe")
logger.info(self.args.client_host)
msg.appendTypedArg(self.args.client_host, "s")
msg.appendTypedArg(self.args.client_port, "i")
msg.appendTypedArg(self.args.authenticate, "s")
if self.args.subscriber_label is not None:
msg.appendTypedArg(self.args.subscriber_label, "s")
self.osc_sock.writeDatagram(QByteArray(msg.encode_osc()),
QHostAddress(self.args.chaosc_host),
self.args.chaosc_port)
def unsubscribe(self):
logger.info("unsubscribe")
msg = OSCMessage("/unsubscribe")
msg.appendTypedArg(self.args.client_host, "s")
msg.appendTypedArg(self.args.client_port, "i")
msg.appendTypedArg(self.args.authenticate, "s")
self.osc_sock.writeDatagram(QByteArray(msg.encode_osc()),
QHostAddress(self.args.chaosc_host),
self.args.chaosc_port)
def handle_osc_error(self, error):
logger.info("osc socket error %d", error)
def closeEvent(self, event):
logger.info("closeEvent %r", event)
self.unsubscribe()
event.accept()
def pubdir(self):
return os.path.dirname(os.path.abspath(__file__))
def add_text(self, column, text):
self.text_storage.add_text(column, text)
def render_image(self):
# print "render_iamge"
self.text_storage.finish()
# image = QPixmap(768, 576)
# image.fill(QtCore.Qt.black)
# painter = QPainter(image)
#painter.setRenderHints(QPainter.RenderHint(
# QPainter.Antialiasing | QPainter.TextAntialiasing), True)
#painter.setFont(self.default_font)
#self.graphics_view.render(
# painter, target=QtCore.QRectF(0, 0, 768, 576),
# source=QtCore.QRect(0, 0, 768, 576))
#painter.end()
#buf = QBuffer()
#buf.open(QIODevice.WriteOnly)
#image.save(buf, "JPG", 100)
#image_data = buf.data()
#return image_data
def got_message(self):
def convert(value):
if isinstance(value, float):
return "%.1f" % value
else:
return str(value)
while self.osc_sock.hasPendingDatagrams():
data, address, port = self.osc_sock.readDatagram(
self.osc_sock.pendingDatagramSize())
try:
osc_address, typetags, args = decode_osc(data, 0, len(data))
except ValueError:
return
try:
actor, text = self.regex.match(osc_address).groups()
except AttributeError:
pass
else:
if actor == "merle":
self.add_text(
0, "%s = %s" %
(text, ", ".join([convert(i) for i in args])))
elif actor == "uwe":
self.add_text(
1, "%s = %s" %
(text, ", ".join([convert(i) for i in args])))
elif actor == "bjoern":
self.add_text(
2, "%s = %s" %
(text, ", ".join([convert(i) for i in args])))
return True
def __init__(self, args, parent=None):
self.args = args
QtGui.QMainWindow.__init__(self, parent)
self.osc_sock = QUdpSocket(self)
logger.info("osc bind localhost %d", self.args.client_port)
self.osc_sock.bind(QHostAddress(self.args.client_host),
self.args.client_port)
self.osc_sock.readyRead.connect(self.got_message)
self.osc_sock.error.connect(self.handle_osc_error)
self.subscribe()
self.graphics_view = QtGui.QGraphicsView(self)
self.resize(640, 480)
font = QtGui.QFont()
font.setFamily(_fromUtf8("Monospace"))
font.setPointSize(12)
font.setItalic(True)
self.setFont(font)
palette = QtGui.QPalette()
brush = QtGui.QBrush(QtGui.QColor(255, 255, 255))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.WindowText,
brush)
brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Button, brush)
brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Light, brush)
brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Midlight, brush)
brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Dark, brush)
brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Mid, brush)
brush = QtGui.QBrush(QtGui.QColor(255, 255, 255))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Text, brush)
brush = QtGui.QBrush(QtGui.QColor(255, 255, 255))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.BrightText,
brush)
brush = QtGui.QBrush(QtGui.QColor(255, 255, 255))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.ButtonText,
brush)
brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Base, brush)
brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Window, brush)
brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Shadow, brush)
brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.AlternateBase,
brush)
brush = QtGui.QBrush(QtGui.QColor(255, 255, 220))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.ToolTipBase,
brush)
brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.ToolTipText,
brush)
brush = QtGui.QBrush(QtGui.QColor(255, 255, 255))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.WindowText,
brush)
brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Button, brush)
brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Light, brush)
brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Midlight,
brush)
brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Dark, brush)
brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Mid, brush)
brush = QtGui.QBrush(QtGui.QColor(255, 255, 255))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Text, brush)
brush = QtGui.QBrush(QtGui.QColor(255, 255, 255))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.BrightText,
brush)
brush = QtGui.QBrush(QtGui.QColor(255, 255, 255))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.ButtonText,
brush)
brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Base, brush)
brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Window, brush)
brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Shadow, brush)
brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.AlternateBase,
brush)
brush = QtGui.QBrush(QtGui.QColor(255, 255, 220))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.ToolTipBase,
brush)
brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.ToolTipText,
brush)
brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.WindowText,
brush)
brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Button, brush)
brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Light, brush)
brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Midlight,
brush)
brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Dark, brush)
brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Mid, brush)
brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Text, brush)
brush = QtGui.QBrush(QtGui.QColor(255, 255, 255))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.BrightText,
brush)
brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.ButtonText,
brush)
brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Base, brush)
brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Window, brush)
brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Shadow, brush)
brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.AlternateBase,
brush)
brush = QtGui.QBrush(QtGui.QColor(255, 255, 220))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.ToolTipBase,
brush)
brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.ToolTipText,
brush)
self.graphics_view.setPalette(palette)
self.graphics_view.setAutoFillBackground(False)
self.graphics_view.setObjectName(_fromUtf8("graphics_view"))
self.setCentralWidget(self.graphics_view)
self.graphics_view.setHorizontalScrollBarPolicy(
QtCore.Qt.ScrollBarAlwaysOff)
self.graphics_view.setVerticalScrollBarPolicy(
QtCore.Qt.ScrollBarAlwaysOff)
self.graphics_view.setRenderHint(QtGui.QPainter.Antialiasing, True)
self.graphics_view.setFrameStyle(QtGui.QFrame.NoFrame)
self.graphics_scene = QtGui.QGraphicsScene(self)
self.graphics_scene.setSceneRect(0, 0, 640, 480)
self.graphics_view.setScene(self.graphics_scene)
self.default_font = QtGui.QFont("Monospace", 12)
self.default_font.setStyleHint(QtGui.QFont.Monospace)
self.default_font.setBold(True)
self.graphics_scene.setFont(self.default_font)
self.font_metrics = QtGui.QFontMetrics(self.default_font)
self.line_height = self.font_metrics.height()
self.setWindowTitle(_translate("MainWindow", "DumpGrabberMain", None))
columns = 3
self.column_width = 640 / columns
self.text_storage = ExclusiveTextStorage(columns, self.default_font,
self.column_width,
self.line_height,
self.graphics_scene)
self.text_storage.init_columns()
self.regex = re.compile("^/(uwe|merle|bjoern)/(.*?)$")
self.osc_sock.readyRead.connect(self.got_message)
self.timer = QtCore.QTimer()
self.timer.timeout.connect(self.render_image)
self.timer.start(100)
class QUdpTransport(Transport):
'''A Transport sending and receiving UDP datagrams.
Connectionless - sender/receiver are IP addresses. Sending and receiving is
done on the same port. Sending with receiver=None makes a broadcast.
Use messages > 500 Byte at your own peril.
Received data is processed on the Qt mainloop thread.
'''
def __init__(self, port):
self.port = port
self.leftover = b''
self.socket = QUdpSocket()
self.socket.readyRead.connect(self.on_ready_read)
self.socket.error.connect(self.on_error)
def start(self):
if self.socket.state() != QAbstractSocket.UnconnectedState:
L().debug(
'QUdpSocket.start(): Socket is not in UnconnectedState, doing nothing'
)
return
L().debug('QUdpTransport: binding to port %d' % (self.port, ))
self.socket.bind(self.port, QUdpSocket.ShareAddress)
def stop(self):
self.socket.flush()
self.socket.close()
def send(self, data, receivers=None):
L().debug('message to udp %s: %s' % (receivers, data))
data = data.decode('utf8')
if receivers:
for receiver in receivers:
self.socket.writeDatagram(data, QHostAddress(receiver),
self.port)
else:
self.socket.writeDatagram(data, QHostAddress.Broadcast, self.port)
def on_ready_read(self):
while self.socket.hasPendingDatagrams():
data, host, port = self.socket.readDatagram(
self.socket.pendingDatagramSize())
assert isinstance(data, bytes)
sender = host.toString()
pdata = data
if len(pdata) > 100:
pdata = pdata[:100] + b'...'
L().debug('UDP message from %s: %s' % (sender, pdata))
self.leftover = self.received(sender=sender,
data=self.leftover + data)
def on_error(self, error):
L().info('QTcpSocket raised error: %s' % error)
class UdpServer(QObject):
datagram = pyqtSignal(str)
def __init__(self, host):
super().__init__()
self._sock = QUdpSocket()
self._host = host
self._log = logging.getLogger('udp')
self._sock.readyRead.connect(self.recv)
bind(self._sock)
def set_host(self, host):
self._host = host
@pyqtSlot(str)
def try_connect(self, port):
self._sock.disconnectFromHost()
if self._sock.state() != QAbstractSocket.UnconnectedState:
self._sock.waitForDisconnected()
port = int(port)
msg = 'connecting to ({}:{})'
msg = msg.format(self._host.toString(), port)
self._log.debug(msg)
self._sock.connectToHost(self._host, port)
self._sock.write('_:start\n')
def recv(self):
while self._sock.hasPendingDatagrams():
data = self._sock.readDatagram(BUFFER_SIZE)
data = data[0]
message = data.decode()
for line in message.split('\n'):
if line == '':
continue
self.datagram.emit(line)
def __init__(self, port):
self.port = port
self.leftover = b''
self.socket = QUdpSocket()
self.socket.readyRead.connect(self.on_ready_read)
self.socket.error.connect(self.on_error)
class UdpServer(QObject):
datagram = pyqtSignal(str)
def __init__(self, host):
super().__init__()
self._sock = QUdpSocket()
self._host = host
self._log = logging.getLogger("udp")
self._sock.readyRead.connect(self.recv)
bind(self._sock)
def set_host(self, host):
self._host = host
@pyqtSlot(str)
def try_connect(self, port):
self._sock.disconnectFromHost()
if self._sock.state() != QAbstractSocket.UnconnectedState:
self._sock.waitForDisconnected()
port = int(port)
msg = "connecting to ({}:{})"
msg = msg.format(self._host.toString(), port)
self._log.debug(msg)
self._sock.connectToHost(self._host, port)
self._sock.write("_:start\n")
def recv(self):
while self._sock.hasPendingDatagrams():
data = self._sock.readDatagram(BUFFER_SIZE)
data = data[0]
message = data.decode()
for line in message.split("\n"):
if line == "":
continue
self.datagram.emit(line)
class SocketThread(QThread):
def __init__(self,parent=None):
super(SocketThread,self).__init__(parent)
self.clientuuid = str(uuid.uuid4())
self.port = 5555
self.broadFlag = False
self.currentStudent = False
self.porttwo = 5556
self.framedata = {}
self.currentframe = ""
self.dataframelist = {}
self.udpSocket = QUdpSocket(self)
self.udpSocket.setReadBufferSize(1024*1024)
self.connect(self.udpSocket,SIGNAL("readyRead()"),self.dataReceive)
self.results = self.udpSocket.bind(self.port)
self.mcast_addr = QHostAddress("224.0.0.17")
self.mcast_addr_two = QHostAddress("224.0.0.18")
self.udpSocketTwo = QUdpSocket(self)
self.udpSocketTwo.setReadBufferSize(1024)
self.connect(self.udpSocketTwo,SIGNAL("readyRead()"),self.dataReceiveTwo)
self.result = self.udpSocketTwo.bind(self.porttwo)
if self.result:
self.joinGroupTwo = self.udpSocketTwo.joinMulticastGroup(self.mcast_addr_two)
print("joinmulticastGroup %d" % self.joinGroupTwo)
if not os.path.exists(os.path.dirname(LOG_PATH)):
os.makedirs(os.path.dirname(LOG_PATH))
handler = logging.handlers.RotatingFileHandler(LOG_PATH, maxBytes = 1024*1024, backupCount = 5) # ?????????handler
fmt = '%(asctime)s - %(filename)s:%(lineno)s - %(name)s - %(message)s'
formatter = logging.Formatter(fmt) # ?????????formatte
handler.setFormatter(formatter) # ???handler??????format
self.logger = logging.getLogger(LOG_PATH) # ????????tst???logger
self.logger.addHandler(handler) # ???logger??????handle
self.logger.setLevel(logging.DEBUG)
self.timer = QTimer()
self.connect(self.timer, SIGNAL("timeout()"), self.bindUdpPort)
self.timer.start(1000)
self.mutex = QMutex()
gc.set_debug(gc.DEBUG_STATS|gc.DEBUG_LEAK)
def bindUdpPort(self):
if not self.joinGroupTwo:
self.joinGroupTwo = self.udpSocketTwo.joinMulticastGroup(self.mcast_addr_two)
self.logger.info("joinGroupTwo:%d" % self.joinGroupTwo)
else:
self.timer.stop()
def dataReceive(self):
while self.udpSocket.hasPendingDatagrams():
try:
if self.broadFlag == False:
continue
datagram = QByteArray()
datagram.resize(self.udpSocket.pendingDatagramSize())
msglist = self.udpSocket.readDatagram(datagram.size())
msg = msglist[0]
if len(msg) <= 21:
print "msg data smaller"
continue
timetemp = msg[0:17]
datanumth = msg[17:19]
datatotalnum = msg[19:21]
datacontent = msg[21:]
self.addToLocal(timetemp,datanumth,datatotalnum,datacontent)
del msg
del datacontent
except Exception, e:
del datacontent
self.logger.error(e.message)
class MainWind(QtGui.QMainWindow, gui.Ui_MainWindow):
def app_q(self):
app.quit()
def print_version(self):
self.info_box("App Version", "p2pme-1.0(beta) ®")
def __init__(self):
super(self.__class__, self).__init__()
self.setupUi(self)
QObject.connect(self.startServer, QtCore.SIGNAL ('clicked()'), self.start_server)
QtCore.QObject.connect(self.sendButton, QtCore.SIGNAL('clicked()'), self.send_message)
QtCore.QObject.connect(self.clearButton, QtCore.SIGNAL('clicked()'), self.clear_logs)
self.messageBox.textChanged.connect(self.check_for_return)
self.clientIp.returnPressed.connect(self.startServer.click)
self.nickName.returnPressed.connect(self.startServer.click)
#timers
self.progressBarTimer = QtCore.QTimer(self)
self.timer_clientCheck = QtCore.QTimer(self)
self.timer2 = QtCore.QTimer(self)
self.timer = QtCore.QTimer(self)
#timer-signals
QtCore.QObject.connect(self.timer, QtCore.SIGNAL("timeout()"), self.update_my_status_online)
QtCore.QObject.connect(self.progressBarTimer, QtCore.SIGNAL("timeout()"), self.progressBarInc)
QtCore.QObject.connect(self.timer2, QtCore.SIGNAL("timeout()"), self.check_client_status)
QtCore.QObject.connect(self.timer_clientCheck, QtCore.SIGNAL("timeout()"), self.setLbl_text)
self.progressBar.valueChanged.connect(self.checkProgressVal)
self.actionVersion.triggered.connect(self.print_version)
self.actionExit.triggered.connect(self.app_q)
#progressBar-settings
self.progressBar.setMaximum(10)
self.progressBar.setMinimum(0)
#parameters for testing
#self.nickName.setText("nick")
#self.clientIp.setText("192.168.0.13")
#parameters for testing
def setLbl_text(self):
palette = QtGui.QPalette()
palette.setColor(QtGui.QPalette.Foreground, QtCore.Qt.darkRed)
self.label_3.setPalette(palette)
self.label_3.setText("Client is offline")
def info_box(self,ttl, info):
msgBox = QtGui.QMessageBox()
msgBox.setWindowTitle(ttl)
msgBox.setText(info)
msgBox.exec_()
def info_box_advanced(self,ttl, info):
msgBox = QtGui.QMessageBox()
stayButton = msgBox.addButton(self.tr("Stay connected"), QtGui.QMessageBox.ActionRole)
disconnectButton = msgBox.addButton(self.tr("Disconect"), QtGui.QMessageBox.ActionRole)
msgBox.setDefaultButton(stayButton)
msgBox.setWindowTitle(ttl)
msgBox.setText(info)
msgBox.exec_()
if msgBox.clickedButton() == disconnectButton:
self.update_my_status_offline()
self.server.close()
self.set_box_enabled()
self.startServer.setText("Connect")
self.label_3.setText("")
self.progressBarTimer.stop()
self.timer2.stop()
self.timer.stop()
self.progressBar.setValue(0)
self.progressLbl.setText("")
self.progressBar.setVisible(False)
self.progressLbl.setVisible(False)
self.timer_clientCheck.stop()
def clear_logs(self):
self.listWidget.clear()
self.messageBox.setText("")
def update_list(self, data):
self.listWidget.addItem(data)
self.listWidget.scrollToBottom()
def myItemOnList(self, data):
item = QtGui.QListWidgetItem(data)
item.setTextAlignment(QtCore.Qt.AlignRight)
self.listWidget.addItem(item)
self.listWidget.scrollToBottom()
def read_message(self):
palette = QtGui.QPalette()
#recieving-message
(data, senderAddress, senderPort) = self.server.readDatagram(1024)
senderAddress = senderAddress.toString()
data = data.decode("utf-8")
if senderAddress == self.clientIp.text():
if data == '$#*--imonline--*#$':
palette.setColor(QtGui.QPalette.Foreground, QtCore.Qt.darkGreen)
self.timer_clientCheck.start(4000)
self.label_3.setText("Client is online")
self.label_3.setPalette(palette)
elif data == '$#*--imoffline--*#$':
palette.setColor(QtGui.QPalette.Foreground, QtCore.Qt.darkRed)
self.label_3.setText("Client is offline")
self.label_3.setPalette(palette)
self.timer_clientCheck.stop()
else:
self.update_list(data)
def send_datagram(self, message):
send = QUdpSocket()
send.writeDatagram(message, QHostAddress(self.clientIp.text()), self.clientPort.value())
def update_my_status_online(self):
testmsg = '$#*--imonline--*#$'
self.send_datagram(testmsg)
def update_my_status_offline(self):
testmsg = '$#*--imoffline--*#$'
self.send_datagram(testmsg)
def set_box_disabled(self):
self.nickName.setDisabled(True)
#self.hostIp.setDisabled(True)
self.hostPort.setDisabled(True)
self.clientIp.setDisabled(True)
self.clientPort.setDisabled(True)
def set_box_enabled(self):
self.nickName.setDisabled(False)
#self.hostIp.setDisabled(False)
self.hostPort.setDisabled(False)
self.clientIp.setDisabled(False)
self.clientPort.setDisabled(False)
def check_client_status(self):
palette = QtGui.QPalette()
palette.setColor(QtGui.QPalette.Foreground, QtCore.Qt.darkRed)
self.label_3.setPalette(palette)
if self.label_3.text() == "":
self.label_3.setText("Client is offline")
def check_parameters(self):
if self.nickName.text() == '':
self.progressBar.setValue(10)
self.progressLbl.setText("Connecting failed!")
self.info_box("Connection Refused", "Nick not set.")
return 1
elif self.clientIp.text() == '...':
self.progressBar.setValue(10)
self.progressLbl.setText("Connecting failed!")
self.info_box("Connection Refused", "Client ip not set.")
return 1
elif self.hostIp.text() == '...':
self.progressBar.setValue(10)
self.progressLbl.setText("Connecting failed!")
self.info_box("Connection Refused", "Host ip not set.")
return 1
elif self.clientIp.text() != '...':
IP = self.clientIp.text()
IP = IP.split('.')
for i in range(0, 4):
if IP[i] == '':
self.info_box("Connection Refused", "Client ip incompletely.")
self.progressBar.setValue(10)
self.progressLbl.setText("Connecting failed!")
return 1
break
elif self.hostIp.text() != '...':
IP = self.hostIp.text()
IP = IP.split('.')
for i in range(0, 4):
if IP[i] == '':
self.info_box("Connection Refused", "Host ip incompletely.")
self.progressBar.setValue(10)
self.progressLbl.setText("Connecting failed!")
return 1
break
def start_server(self):
self.progressBar.setVisible(True)
self.progressLbl.setVisible(True)
self.progressBar.setValue(2)
if self.check_parameters() != 1:
self.progressLbl.setText("Connecting...")
self.progressBar.setValue(5)
self.set_box_disabled()
if (self.startServer.text() == "Connect"):
self.server = QUdpSocket()
error = self.server.bind(QHostAddress(self.hostIp.text()), self.hostPort.value())
if (error == True):
self.update_my_status_online()
self.timer.start(3000)
self.timer_clientCheck.start(4000)
self.progressBarTimer.start(100)
self.timer2.setSingleShot(True)
self.timer2.start(300)
QtCore.QObject.connect(self.server, QtCore.SIGNAL('readyRead()'), self.read_message)
self.startServer.setText("Disconnect")
elif (error == False):
self.info_box("Connection refused", "The Host Address or Host Port are currently unavailable.")
self.progressBar.setValue(10)
self.progressLbl.setText("Connecting failed!")
self.set_box_enabled()
elif (self.startServer.text() == "Disconnect"):
self.update_my_status_offline()
self.server.close()
self.set_box_enabled()
self.startServer.setText("Connect")
self.label_3.setText("")
self.progressBarTimer.stop()
self.timer2.stop()
self.timer.stop()
self.progressBar.setVisible(False)
self.progressLbl.setVisible(False)
self.timer_clientCheck.stop()
def check_for_return(self):
a = self.messageBox.toPlainText()
a = str(a)
x = len(a)
if a != "":
ascii = ord(a[x-1])
if ascii == 10:
self.sendButton.click()
##if x > 30:
## self.message = a + 10
def send_message(self):
self.progressBar.setVisible(True)
self.progressLbl.setText("Sending Message...")
#preparing-for-sending
message = self.messageBox.toPlainText()
x = len(message)
nick = self.nickName.text()
msg = nick + ": \n" + message
self.progressBar.setValue(2)
if self.startServer.text() == 'Connect':
self.progressBar.setValue(10)
self.progressLbl.setText("Sending Refused")
self.info_box("Sending Refused", "Server not started.")
elif message != '':
self.progressBar.setValue(6)
if self.label_3.text() == "" or self.label_3.text() == "Client is offline":
self.info_box_advanced("Sending Unsuccessful","The message cannot be sent. \nWrong Client Ip or client not online.")
self.progressBar.setValue(10)
self.progressLbl.setText("Sending Failed!")
else:
self.messageBox.clear()
self.myItemOnList(msg)
self.send_datagram(msg)
self.progressBar.setValue(10)
self.progressLbl.setText("Message Sent!")
elif message == '':
self.progressBar.setValue(10)
self.progressLbl.setText("Empty Message!")
#progressBar-work
def progressBarInc(self):
i = self.progressBar.value()
i += 1
self.progressBar.setValue(i)
def checkProgressVal(self):
if self.progressBar.value() == 10:
self.update_my_status_online()
self.progressBarTimer.stop()
self.progressLbl.setText("Connected!")
if aqt.mw.state != "deckBrowser":
msgCmd = MessageCommand(filename)
else:
showTooltip("Error, you must open a deck first!")
#### Main ####
if CLEAR_LOG_AT_STARTUP:
clearLog()
writeLog("-----------------------------------------------------------")
writeLog("Main: START")
try:
udpSocket = QUdpSocket()
udpSocket.bind(PORT)
udpSocket.readyRead.connect(processPendingDatagrams)
except:
writeLog("Main: Could not setup connection!")
#
# TCP Server
#
# Note, this code was taken from the Anki plugin "AnkiConnect", which was built for Yomichan
TICK_INTERVAL = 25
URL_TIMEOUT = 10
NET_ADDRESS = '127.0.0.1'
NET_BACKLOG = 5
def send_datagram(self, message):
send = QUdpSocket()
send.writeDatagram(message, QHostAddress(self.clientIp.text()), self.clientPort.value())
