def incomingConnection(self, socket):
if not self.enabled:
return
s = QTcpSocket(self)
self.connect(s, SIGNAL('readyRead()'), self.readClient)
self.connect(s, SIGNAL('disconnected()'), self.discardClient)
s.setSocketDescriptor(socket)
def __init__(self, parent = None):
QTcpSocket.__init__(self, parent)
# The 'readyRead' signal is from QTcpSocket, call 'readyReadId'
# whenever is emitted.
self.readyRead.connect(self.onReadyRead)
self.disconnected.connect(self.onDisconnected)
def newActive(self, peer, resolve=True):
if resolve and peer in self.config['friends']:
self.buf.info('%s is in friends list, querying...' % peer)
def cb(res):
if res == 'n':
self.buf.error('%s is offline' % peer)
elif res[0].isdigit():
self.buf.info('%s has IP address %s' % (peer, res))
self.newActive(res, False)
else:
self.buf.error('status of %s is unknown' % peer)
self.talkToCentral('q%s' % peer, u'query', r'', cb, False)
return
socket = QTcpSocket()
socket.connectToHost(peer, PEER_PORT)
def onConnected():
self.buf.info('Connected to %s' % peer)
self.addPage(socket)
def onError():
self.buf.error('Error communicating with %s: %s' % (
peer, socket.errorString()))
socket.connected.connect(onConnected)
socket.error.connect(onError)
self.buf.info('Reaching out to %s...' % peer)
def talkToCentral(self, msg, name, pattern, cb=None, successMsg=True):
Name = name.title()
socket = QTcpSocket()
socket.connectToHost(CENTRAL_ADDR, CENTRAL_PORT)
def onConnected():
socket.write(msg)
def onReadyRead():
response = str(socket.readAll())
if re.match(pattern, response):
if successMsg:
self.buf.info(u'%s successful.' % Name)
if cb:
cb(response)
else:
self.buf.error(u'%s failed, server said %s.' %
(Name, repr(response)))
socket.close()
socket.readyRead.connect(onReadyRead)
def onError():
self.buf.error(u'Error %s: %s' %
(name, urepr(socket.errorString())))
socket.connected.connect(onConnected)
socket.error.connect(onError)
def app_started(self):
print "[VDBG] APP Started"
self.newApp = True
# Console Port
self.socket = QTcpSocket()
self.nextBlockSize = 0
self.bytesAvail = 0
self.connect(self.socket, SIGNAL("connected()"), self.sendRequest)
self.connect(self.socket, SIGNAL("readyRead()"), self.readResponse)
self.connect(self.socket, SIGNAL("disconnected()"),
self.serverHasStopped)
if self.socket.isOpen():
self.socket.close()
if self.ui.comboBox.currentIndex() != 0:
print("[VDBG] Connecting to console port ")
cnt = 0
while cnt < 5:
try:
self.socket.connectToHost(CON.address,
self.console_port,
mode=QIODevice.ReadWrite)
if self.socket.waitForConnected(100):
self.newApp = True
break
except:
cnt = cnt + 1
class e2midi(QtGui.QMainWindow, Ui_e2midi):
def __init__(self, host, nb):
QtGui.QWidget.__init__(self, None)
self.setupUi(self)
mixer.init()
self.sock = QTcpSocket()
self.sock.connectToHost(host, 2012)
self.sock.readyRead.connect(self.listen)
self.nb = nb
self.bar = []
self.central.setSpacing(500/nb)
for i in range(nb):
b = QtGui.QProgressBar()
b.setOrientation(Qt.Qt.Vertical)
b.setFormat("%d" % i)
b.setValue(0)
self.central.addWidget(b)
self.bar.append(b)
def handle_data(self, position):
print position
bar = self.bar[min(self.nb - 1, int(position * self.nb))]
bar.setValue(100)
QtCore.QTimer.singleShot(200, lambda: bar.setValue(0));
def listen(self):
data = self.sock.readAll()
[self.handle_data(float(i)) for i in data.split('\n') if i != '']
def __init__(self, host, port, sendername='qtcp'):
self.address = (host, port)
self.sendername = sendername
self.leftover = b''
self.socket = QTcpSocket()
self.socket.readyRead.connect(self.on_ready_read)
self.socket.error.connect(self.on_error)
self.socket.connected.connect(self.on_connect)
def __init__(self):
QTcpSocket.__init__(self)
self.wait_len = ''
self.temp = ''
self.setSocketOption(QTcpSocket.KeepAliveOption, QVariant(1))
self.readyRead.connect(self.on_ready_read)
self.connected.connect(self.on_connected)
self.disconnected.connect(self.on_disconnect)
self.error.connect(self.on_error)
class QTcpTransport(Transport):
'''A Transport connecting to a TCP server.
Connect using .start().
Received data is processed on the Qt mainloop thread.
'''
shorthand='qtcp'
@classmethod
def fromstring(cls, expression):
'''qtcp:<host>:<port>'''
_, host, port = expression.split(':')
return cls(host=host, port=int(port), sendername=expression)
def __init__(self, host, port, sendername='qtcp'):
self.address = (host, port)
self.sendername = sendername
self.leftover = b''
self.socket = QTcpSocket()
self.socket.readyRead.connect(self.on_ready_read)
self.socket.error.connect(self.on_error)
self.socket.connected.connect(self.on_connect)
def start(self):
if self.socket.state() != QAbstractSocket.UnconnectedState:
L().debug('start(): Socket is not in UnconnectedState, doing nothing')
return
L().debug('connecting to: %s'%(self.address,))
self.socket.connectToHost(self.address[0], self.address[1])
def stop(self):
self.socket.flush()
self.socket.disconnectFromHost()
def send(self, data, receivers=None):
if receivers is not None and self.sendername not in receivers:
return
L().debug('message to tcp server: %s'%data)
self.socket.write(data.decode('utf8'))
def on_ready_read(self):
data = self.socket.readAll().data()
pdata = data
if len(pdata) > 100:
pdata = pdata[:100] + b'...'
#if pdata.startswith('{'):
L().debug('message from tcp server: %s'%pdata)
self.leftover = self.received(
sender=self.sendername,
data=self.leftover + data
)
def on_connect(self):
L().info('QTcpSocket: Established connection to %s'%(self.address,))
def on_error(self, error):
L().info('QTcpSocket raised error: %s'%error)
def __init__(self, host):
super().__init__()
self._sock = QTcpSocket()
self._pending = None
self._host = host
self._log = logging.getLogger('tcp')
self._sock.connected.connect(self.greet)
self._sock.connected.connect(self.connected.emit)
self._sock.disconnected.connect(self.disconnected.emit)
self._sock.readyRead.connect(self.recv)
def __init__(self):
"""
Arguments:
- `self`:
"""
QMainWindow.__init__(self)
self.setupUi(self)
self.socket = QTcpSocket()
self.connect()
def begin(self, instrument):
self.log = logging.getLogger('GDAIS.' + instrument.short_name +
'.TCPConnection')
self.instrument = instrument
self.io_conn = QTcpSocket()
self.io_conn.connected.connect(self.connected)
self.io_conn.error.connect(self.connection_error)
self.io_conn.connectToHost(instrument.connection.tcp_host,
instrument.connection.tcp_port)
def __init__(self, configdir, recentconndb):
QtGui.QDialog.__init__(self)
# Variables
self.configdir = configdir
self.recentconndb = recentconndb
self.socket = QTcpSocket()
self.status = self.STATUS[0]
log.info("Starting Client")
# Properties
self.setModal(True)
# Setup Widget
self.layout = QtGui.QVBoxLayout()
self.mainWidget = ControllerClientWidget()
self.layout.addWidget(self.mainWidget)
self.setLayout(self.layout)
#Connections
self.connect(self.socket,
QtCore.SIGNAL('error(QAbstractSocket::SocketError)'),
self.displayError)
self.connect(self.socket, QtCore.SIGNAL('connected()'), self.connected)
self.connect(self.mainWidget.connectButton, QtCore.SIGNAL('pressed()'),
self.connectToServer)
self.connect(self.mainWidget.hostEdit,
QtCore.SIGNAL('textChanged(QString)'),
self.enableConnectButton)
self.connect(self.mainWidget.portEdit,
QtCore.SIGNAL('textChanged(QString)'),
self.enableConnectButton)
self.connect(self.mainWidget.passEdit,
QtCore.SIGNAL('textChanged(QString)'),
self.enableConnectButton)
self.connect(self.mainWidget.recentConnList,
QtCore.SIGNAL('doubleClicked(const QModelIndex &)'),
self.recentListHandler)
self.loadRecentConnDB()
self.enableConnectButton()
self.hide()
# Translations
self.app = QtGui.QApplication.instance()
self.current_language = "en_US"
self.uiTranslator = QtCore.QTranslator()
self.uiTranslator.load(":/languages/tr_en_US.qm")
self.retranslate()
self.updateStatus()
def run(self):
tcpSocket = QTcpSocket()
if not tcpSocket.setSocketDescriptor(self.socketDescriptor):
self.error.emit(tcpSocket.error())
return
self._stream = QDataStream(tcpSocket)
print('text stream created')
while not self.shoudDisconnect:
print(tcpSocket.bytesAvailable())
while tcpSocket.bytesAvailable():
pass
def incomingConnection(self, socket):
if not self.enabled:
return
s = QTcpSocket(self)
s.setSocketDescriptor(socket)
sIp = unicode(s.peerAddress().toString())
sPort = s.peerPort()
if sIp.startswith(self.ipFilter):
SimuVis4.Globals.logger.info(unicode(QCoreApplication.translate('RemoteControl',
'RemoteControl: accepting connection from %s, port %s')), sIp, sPort)
self.connect(s, SIGNAL('readyRead()'), self.readClient)
self.connect(s, SIGNAL('disconnected()'), self.discardClient)
else:
SimuVis4.Globals.logger.error(unicode(QCoreApplication.translate('RemoteControl',
'RemoteControl: refusing connection from %s, port %s')), sIp, sPort)
self.discardClient()
def __init__(self, sock):
self.sock = QTcpSocket()
self.sock.setSocketDescriptor(sock)
self.data = []
self.device = None
self.head = False
self.p = False
self.stream = False
self.i = 0
self.stopping = False
self.pp = False
self.pstream = False
self.vi = make_vorbis_info() # struct that stores all the static vorbis bitstream
self.vc = make_vorbis_comment() # struct that stores all the user comments
self.vd = make_vorbis_dsp_state() # central working state for the packet->PCM decoder
self.vb = make_vorbis_block() # local working space for packet->PCM decode
self.header = make_ogg_packet()
self.header_comm = make_ogg_packet()
self.header_code = make_ogg_packet()
self.audio_pkt = make_ogg_packet()
self.to = make_ogg_stream_state()
self.page = make_ogg_page()
self.terminationFlag = True # this flag is used to signal recorder that it is no longer needed (when the connection is lost)
def open(self,options):
self.options = options
self.tcpSocket = QTcpSocket()
# try to connect to the server
self.tcpSocket.connectToHost(QHostAddress("0.0.0.0"), 5006)
self.tcpSocket.waitForConnected(2000)
if self.tcpSocket.state() != 3:
self._launchWindow()
#thread.start_new_thread(self._launchWindow,(xres,yres))
QObject.connect(self.tcpSocket, SIGNAL("connected()"), self.tcpSocketConnected)
#print "connecting now"
while self.tcpSocket.state() != 3:
self.tcpSocket.connectToHost(QHostAddress("0.0.0.0"), 5006)
self.tcpSocket.waitForConnected(5000)
def __init__(self, name, server, serverPort, x, y, width, height ):
"""__init__() -> None
initializes the client class"""
QtCore.QObject.__init__(self)
self.timer = QtCore.QTimer(self)
self.timer.setSingleShot(True)
self.timer.setInterval(1000)
self.timer.start()
self.socket = QTcpSocket()
self.current_pipeline = None
self.current_config_function = None
self.server = server # os.environ.get( 'DV3D_HW_SERVER_NAME', server )
self.serverPort = int(serverPort)
self.buffer = ""
self.pipelineQueue = []
current_pipeline = None
self.deviceName = name
self.currentTab = None
self.mainWindow = None
print " Init VisClient, server=%s, serverPort=%s, name=%s " % ( str(self.server), str(self.serverPort), str(name) )
self.spreadsheetWindow = spreadsheetController.findSpreadsheetWindow( False )
self.spreadsheetWindow.setWindowFlags( self.spreadsheetWindow.windowFlags() | QtCore.Qt.WindowStaysOnTopHint | QtCore.Qt.Window )
# self.spreadsheetWindow.setWindowFlags( self.spreadsheetWindow.windowFlags() | QtCore.Qt.Window )
self.spreadsheetWindow.activateWindow()
self.spreadsheetWindow.showMaximized()
self.dimensions = ( x, y, width, height )
self.connectSignals()
def app_started(self):
print "[VDBG] APP Started"
self.newApp = True
# Console Port
self.socket = QTcpSocket()
self.nextBlockSize = 0
self.bytesAvail = 0
self.connect(self.socket, SIGNAL("connected()"), self.sendRequest)
self.connect(self.socket, SIGNAL("readyRead()"), self.readResponse)
self.connect(self.socket, SIGNAL("disconnected()"), self.serverHasStopped)
if self.socket.isOpen():
self.socket.close()
if self.ui.comboBox.currentIndex() != 0:
print("[VDBG] Connecting to console port ")
cnt = 0
while cnt < 5:
try :
self.socket.connectToHost(CON.address, self.console_port, mode=QIODevice.ReadWrite)
if self.socket.waitForConnected(100):
self.newApp = True
break
except :
cnt = cnt + 1
def __init__(self, url):
QNetworkReply.__init__(self)
self.gopher = QTcpSocket()
self.gopher.bytesWritten.connect(self.writeGopherData)
self.gopher.readyRead.connect(self.readGopherData)
self.gopher.connected.connect(self.getResource)
self.gopher.disconnected.connect(self.setContent)
self.input = ""
self.output = ""
self.content = ""
self.offset = 0
self.setUrl(url)
self.gopher.connectToHost(url.host(), 70)
def __init__(self, id = None, client = False, parent = None):
"""Creates a connection.
id -- Optional socket descriptor.
client -- Whether this connection is opened from the client side or server side.
parent -- Parent object."""
QTcpSocket.__init__(self, parent)
if id:
if not self.setSocketDescriptor(id):
self.done()
return
self.id = id
self.player = None
self.client = client
self.buffer = QBuffer()
self.buffer.open(QBuffer.ReadWrite)
self.readyRead.connect(self._readIncomingData)
def __init__(self):
super(Averager, self).__init__()
self.setupUi(self)
# state variable
self.idle = True
# number of samples to show on the plot
self.size = 8193 # max size
# buffer and offset for the incoming samples
self.buffer = bytearray(4 * self.size)
self.offset = 0
self.data = np.frombuffer(self.buffer, np.int32)
# create figure
figure = Figure()
figure.set_facecolor('none')
self.axes = figure.add_subplot(111)
self.canvas = FigureCanvas(figure)
self.plotLayout.addWidget(self.canvas)
# create navigation toolbar
self.toolbar = NavigationToolbar(self.canvas, self.plotWidget, False)
# remove subplots action
actions = self.toolbar.actions()
self.toolbar.removeAction(actions[7])
self.plotLayout.addWidget(self.toolbar)
# create TCP socket
self.socket = QTcpSocket(self)
self.socket.connected.connect(self.connected)
self.socket.readyRead.connect(self.read_data)
self.socket.error.connect(self.display_error)
self.cbShowComp.clear()
self.cbShowComp.addItems(["Real", "Imaginary", "Absolute", "Phase"])
self.cbShowComp.setCurrentIndex(2);
#connections
self.btnStart.clicked.connect(self.start)
self.txtNOA.valueChanged.connect(self.update_values)
self.txtNOS.valueChanged.connect(self.update_values)
self.chkFFT.stateChanged.connect(self.update_values)
self.chkScale.stateChanged.connect(self.update_values)
self.chkLogScale.stateChanged.connect(self.update_values)
self.cbShowComp.currentIndexChanged.connect(self.update_values)
self.isScaled = True
self.isLogScale = False
self.isFFT = False
self.haveData = False
self.showComp = 0 # Real, Imag, Abs, Phase from combo box
def __init__(self, host):
super().__init__()
self._sock = QTcpSocket()
self._host = host
self._log = logging.getLogger('tcp')
self._sock.connected.connect(self.greet)
self._sock.connected.connect(self.connected.emit)
self._sock.disconnected.connect(self.disconnected.emit)
self._sock.readyRead.connect(self.recv)
def __init__(self):
"""
Arguments:
- `self`:
"""
QMainWindow.__init__(self)
self.setupUi(self)
self.socket = QTcpSocket()
self.connect()
def run(self):
try:
self.stopRequested = False
self.socket = QTcpSocket()
socket = self.socket
while not self.stopRequested:
if socket.state() == QTcpSocket.UnconnectedState:
socket.connectToHost(self.host, self.port)
if not socket.waitForConnected(3000):
self.errorDetected.emit('Unable to connect: %s' %
socket.errorString())
self.sendMessage('status')
data = ''
k = 0
readMore = True
self.lineVoltage = np.nan
self.batteryVoltage = np.nan
self.status = ''
self.loadPercent = np.nan
self.batteryCharge = np.nan
self.celsius = np.nan
while readMore and not self.stopRequested:
if not socket.waitForReadyRead(2000):
self.errorDetected.emit('Timeout waiting for data')
break
data += socket.readAll()
l = len(data)
while k + 2 <= l:
lenPayload = unpack('>H', data[k:k + 2])[0]
if lenPayload == 0: # No more data expected
self.dataAvailable.emit(self.lineVoltage,
self.batteryVoltage,
self.loadPercent,
self.batteryCharge,
self.celsius, self.status)
print "Completed receive"
readMore = False
break
start = k + 2
end = k + 2 + lenPayload
if end > l: # Payload incomplete
break
pl = str(data[start:end])
self.processPayload(pl)
k = end
for i in range(50):
self.msleep(100)
if self.stopRequested:
break
except Exception, e:
print "Exception:", e
def __init__(self, parent=None):
QWidget.__init__(self)
self.socket = _s = QTcpSocket()
_s.setSocketOption(QTcpSocket.LowDelayOption,
1) #Disable the Nagle Algorithm
_s.connected.connect(self._connected)
_s.connectToHost(QHostAddress(argv[1]), int(argv[2]))
if not _s.waitForConnected(5000):
print "Failed!"
_s.close()
class TcpClient(QObject):
packet = pyqtSignal(str)
connected = pyqtSignal()
disconnected = pyqtSignal()
def __init__(self, host):
super().__init__()
self._sock = QTcpSocket()
self._host = host
self._log = logging.getLogger('tcp')
self._sock.connected.connect(self.greet)
self._sock.connected.connect(self.connected.emit)
self._sock.disconnected.connect(self.disconnected.emit)
self._sock.readyRead.connect(self.recv)
def set_host(self, host):
self._sock.disconnectFromHost()
self._host = host
def try_connect(self, port):
msg = 'connecting to ({}:{})'
msg = msg.format(self._host.toString(), port)
self._log.debug(msg)
self._sock.connectToHost(self._host, port)
ok = self._sock.waitForConnected()
if ok:
self._log.debug('connection successful')
else:
self._log.error('failed to connect')
def greet(self):
self.send(query_tag('port', 'udp'), '')
def recv(self):
while self._sock.canReadLine():
data = bytes(self._sock.readLine()) # handle QByteArray
message = data.decode()
self.packet.emit(message)
def send(self, tag, payload):
message = tag + ':' + payload + '\n'
data = message.encode()
self._sock.write(data)
def __init__(self, name, server, serverPort, x, y, width, height):
"""__init__() -> None
initializes the client class"""
QtCore.QObject.__init__(self)
self.timer = QtCore.QTimer(self)
self.timer.setSingleShot(True)
self.timer.setInterval(1000)
self.timer.start()
self.socket = QTcpSocket()
self.current_pipeline = None
self.current_config_function = None
self.server = server # os.environ.get( 'DV3D_HW_SERVER_NAME', server )
self.serverPort = int(serverPort)
self.buffer = ""
self.pipelineQueue = []
current_pipeline = None
self.deviceName = name
self.currentTab = None
self.mainWindow = None
print " Init VisClient, server=%s, serverPort=%s, name=%s " % (str(
self.server), str(self.serverPort), str(name))
self.spreadsheetWindow = spreadsheetController.findSpreadsheetWindow(
False)
self.spreadsheetWindow.setWindowFlags(
self.spreadsheetWindow.windowFlags()
| QtCore.Qt.WindowStaysOnTopHint | QtCore.Qt.Window)
# self.spreadsheetWindow.setWindowFlags( self.spreadsheetWindow.windowFlags() | QtCore.Qt.Window )
self.spreadsheetWindow.activateWindow()
self.spreadsheetWindow.showMaximized()
self.dimensions = (x, y, width, height)
self.connectSignals()
def __init__(self, params={}, parent=None):
'''
Constructor
'''
super(TcpDevice, self).__init__(params, parent)
self.iodevice = QTcpSocket()
self.reconnect = int(params.get('Reconnect', 1000))
self.host = params.get('Host', None)
self.port = int(params.get('Port', 2000))
self.gpsdInit = bool(params.get('GpsdInit', False))
self.iodevice.readyRead.connect(self.readyRead)
self.iodevice.error.connect(self.socketError)
self.iodevice.connected.connect(self.socketConnected)
self.iodevice.disconnected.connect(self.socketDisconnected)
def __init__(self, host, nb):
QtGui.QWidget.__init__(self, None)
self.setupUi(self)
mixer.init()
self.sock = QTcpSocket()
self.sock.connectToHost(host, 2012)
self.sock.readyRead.connect(self.listen)
self.nb = nb
self.bar = []
self.central.setSpacing(500/nb)
for i in range(nb):
b = QtGui.QProgressBar()
b.setOrientation(Qt.Qt.Vertical)
b.setFormat("%d" % i)
b.setValue(0)
self.central.addWidget(b)
self.bar.append(b)
def __init__(self, configdir, recentconndb):
QtGui.QDialog.__init__(self)
# Variables
self.configdir = configdir
self.recentconndb = recentconndb
self.socket = QTcpSocket()
self.status = self.STATUS[0]
log.info("Starting Client")
# Properties
self.setModal(True)
# Setup Widget
self.layout = QtGui.QVBoxLayout()
self.mainWidget = ControllerClientWidget()
self.layout.addWidget(self.mainWidget)
self.setLayout(self.layout)
# Connections
self.connect(self.socket, QtCore.SIGNAL("error(QAbstractSocket::SocketError)"), self.displayError)
self.connect(self.socket, QtCore.SIGNAL("connected()"), self.connected)
self.connect(self.mainWidget.connectButton, QtCore.SIGNAL("pressed()"), self.connectToServer)
self.connect(self.mainWidget.hostEdit, QtCore.SIGNAL("textChanged(QString)"), self.enableConnectButton)
self.connect(self.mainWidget.portEdit, QtCore.SIGNAL("textChanged(QString)"), self.enableConnectButton)
self.connect(self.mainWidget.passEdit, QtCore.SIGNAL("textChanged(QString)"), self.enableConnectButton)
self.connect(
self.mainWidget.recentConnList, QtCore.SIGNAL("doubleClicked(const QModelIndex &)"), self.recentListHandler
)
self.loadRecentConnDB()
self.enableConnectButton()
self.hide()
# Translations
self.app = QtGui.QApplication.instance()
self.current_language = "en_US"
self.uiTranslator = QtCore.QTranslator()
self.uiTranslator.load(":/languages/tr_en_US.qm")
self.retranslate()
self.updateStatus()
class TCPConnection(Connection):
def __init__(self):
Connection.__init__(self)
# read all data in buffer before exiting self.read_data
self.break_on_packet_found = False
def begin(self, instrument):
self.log = logging.getLogger('GDAIS.' + instrument.short_name +
'.TCPConnection')
self.instrument = instrument
self.io_conn = QTcpSocket()
self.io_conn.connected.connect(self.connected)
self.io_conn.error.connect(self.connection_error)
self.io_conn.connectToHost(instrument.connection.tcp_host,
instrument.connection.tcp_port)
def connected(self):
self.io_conn.readyRead.connect(self.read_data)
Connection.begin(self, self.instrument)
def connection_error(self, socket_error):
if socket_error == QTcpSocket.RemoteHostClosedError:
self.log.info(self.io_conn.errorString())
else:
self.log.error(self.io_conn.errorString())
self.error_occurred.emit()
def quit(self):
if self.io_conn and self.io_conn.state() == QTcpSocket.ConnectedState:
loop = QEventLoop()
self.io_conn.disconnected.connect(loop.quit)
self.io_conn.disconnectFromHost()
self.log.debug("Entered disconnect state...")
if self.io_conn.state() == QTcpSocket.ConnectedState:
loop.exec_()
self.log.info("Done")
Connection.quit(self)
class SocketTcpClient(AbstractSocket):
"""Socket que envia e recebe dados via TcpSocket"""
def __init__(self, portaResponder, parent=None):
super().__init__(None, portaResponder, parent)
self._socketClient = QTcpSocket(self)
self._socketClient.readyRead.connect(self._lerDados)
def _lerDados(self):
if self._socketClient.bytesAvailable():
host = self.ipServidor()
data = self._socketClient.readData()
self.dadosRecebidos.emit(host, data)
def enviarDados(self, byteArray):
self._socketClient.write(byteArray)
def setPara(self, para):
if self.getPara() != para:
super().setPara(para)
self._conectarServidor(para)
def _conectarServidor(self, ip):
if self._socketClient.state() in (QAbstractSocket.ConnectedState, QAbstractSocket.ConnectingState):
self._desconectarServidor()
self._socketClient.connectToHost(QHostAddress(ip), self.getPortaResponder())
def _desconectarServidor(self):
if self._socketClient.state() == QAbstractSocket.UnconnectedState:
return True
self._socketClient.disconnectFromHost()
return self._socketClient.waitForConnected(50)
def ipServidor(self):
return self._socketClient.peerAddress()
def meuIP(self):
return self._socketClient.localAddress()
def __init__(self):
super(Averager, self).__init__()
self.setupUi(self)
# Set data acquisition variables
self.idle = True # state variable
self.size = 8193 # number of samples to show on the plot # max size
self.buffer = bytearray(
4 * self.size) # buffer and offset for the incoming samples
self.offset = 0
self.data = np.frombuffer(self.buffer, np.int32)
self.isScaled = True
self.isLogScale = False
self.isFFT = False
self.haveData = False
self.showComp = 0 # Real, Imag, Abs, Phase from combo box
# Create figure
figure = Figure()
figure.set_facecolor('none')
self.axes = figure.add_subplot(111)
self.canvas = FigureCanvas(figure)
self.plotLayout.addWidget(self.canvas)
# Create navigation toolbar
self.toolbar = NavigationToolbar(self.canvas, self.plotWidget, False)
# Remove subplots action
actions = self.toolbar.actions()
self.toolbar.removeAction(actions[7])
self.plotLayout.addWidget(self.toolbar)
# Create TCP socket
self.socket = QTcpSocket(self)
self.socket.connected.connect(self.connected)
self.socket.readyRead.connect(self.read_data)
self.socket.error.connect(self.display_error)
# Populate Combo boxes
self.cbShowComp.clear()
self.cbShowComp.addItems(["Real", "Imaginary", "Absolute", "Phase"])
self.cbShowComp.setCurrentIndex(0)
self.cbNOS.clear() # Number of Samples
for i in range(11): # maximal value set by the FPGA program
self.cbNOS.addItems([str(1 << i)])
self.cbNOS.setCurrentIndex(10)
self.cbNOA.clear() # Number of Averages
for i in range(22): # maximal value could be larger
self.cbNOA.addItems([str(1 << i)])
self.cbNOA.setCurrentIndex(0)
self.cbTrigger.clear() # Trigger rate
for i in range(26): # maximal value set by the FPGA program
self.cbTrigger.addItems(["f0/" + str(int(1 << (26 + 1 - i)))])
self.cbTrigger.setCurrentIndex(16)
# +1 comes from the fact that counter's lowest bit has f0/2 frequency
# Connect UI elements and functions
self.btnStart.clicked.connect(self.start)
self.chkFFT.stateChanged.connect(self.update_values)
self.chkScale.stateChanged.connect(self.update_values)
self.chkLogScale.stateChanged.connect(self.update_values)
self.cbShowComp.currentIndexChanged.connect(self.update_values)
def process_request(self):
socket = self.sender()
request_data = socket.readAll()
if not self.authorize_request(request_data):
socket.write('HTTP/1.1 407 Proxy Authentication Required\r\n')
if self.debug:
self.log.write('407 Proxy Authentication Required\n\n')
socket.write('Proxy-Authenticate: Basic realm="test"\r\n')
socket.write('\r\n')
socket.disconnectFromHost()
return
else:
# remove Proxy-Authorization header
start = request_data.indexOf('Proxy-Authorization:')
end = request_data.lastIndexOf('\r\n')
request_data.remove(start, end)
request_data.append('\r\n')
pos = request_data.indexOf('\r\n')
request_line = request_data.left(pos)
request_data.remove(0, pos + 2)
entries = request_line.split(' ')
method = entries[0]
address = entries[1]
version = entries[2]
port = '80'
if address.count(':') > 1:
protocol, host, port = address.split(':')
else:
protocol, host = address.split(':')
print 'address', address
#url = QUrl( protocol + host )
url = QUrl.fromEncoded(address)
#url.setHost( host )
#url.setPort( int(port) )
if not url.isValid():
if self.debug:
self.log.write('Invalid URL: %s\n\n', url)
socket.disconnectFromHost()
return
host = url.host()
port = 80 if (url.port() < 0) else url.port()
req = url.encodedPath()
if url.hasQuery():
req.append('?').append(url.encodedQuery())
request_line = method + ' ' + req + ' ' + version + '\r\n'
request_data.prepend(request_line)
if self.debug:
self.log.write(method + ' ' + address + ' ' + version + '\n\n')
key = host + ':' + QString.number(port)
proxy_socket = socket.findChild(QTcpSocket, key)
if proxy_socket:
proxy_socket.setObjectName(key)
proxy_socket.setProperty('url', url)
proxy_socket.setProperty('request_data', request_data)
proxy_socket.write(request_data)
else:
proxy_socket = QTcpSocket(socket)
proxy_socket.setObjectName(key)
proxy_socket.setProperty('url', url)
proxy_socket.setProperty('request_data', request_data)
proxy_socket.connected.connect(self.send_request)
proxy_socket.readyRead.connect(self.transfer_data)
proxy_socket.disconnected.connect(self.close_connection)
proxy_socket.error.connect(self.close_connection)
proxy_socket.connectToHost(host, port)
class Averager(QMainWindow, Ui_Averager):
def __init__(self):
super(Averager, self).__init__()
self.setupUi(self)
# state variable
self.idle = True
# number of samples to show on the plot
self.size = 8193 # max size
# buffer and offset for the incoming samples
self.buffer = bytearray(4 * self.size)
self.offset = 0
self.data = np.frombuffer(self.buffer, np.int32)
# create figure
figure = Figure()
figure.set_facecolor('none')
self.axes = figure.add_subplot(111)
self.canvas = FigureCanvas(figure)
self.plotLayout.addWidget(self.canvas)
# create navigation toolbar
self.toolbar = NavigationToolbar(self.canvas, self.plotWidget, False)
# remove subplots action
actions = self.toolbar.actions()
self.toolbar.removeAction(actions[7])
self.plotLayout.addWidget(self.toolbar)
# create TCP socket
self.socket = QTcpSocket(self)
self.socket.connected.connect(self.connected)
self.socket.readyRead.connect(self.read_data)
self.socket.error.connect(self.display_error)
self.cbShowComp.clear()
self.cbShowComp.addItems(["Real", "Imaginary", "Absolute", "Phase"])
self.cbShowComp.setCurrentIndex(2);
#connections
self.btnStart.clicked.connect(self.start)
self.txtNOA.valueChanged.connect(self.update_values)
self.txtNOS.valueChanged.connect(self.update_values)
self.chkFFT.stateChanged.connect(self.update_values)
self.chkScale.stateChanged.connect(self.update_values)
self.chkLogScale.stateChanged.connect(self.update_values)
self.cbShowComp.currentIndexChanged.connect(self.update_values)
self.isScaled = True
self.isLogScale = False
self.isFFT = False
self.haveData = False
self.showComp = 0 # Real, Imag, Abs, Phase from combo box
def update_values(self):
self.labNOA.setText(str((1<<int(self.txtNOA.text()))))
self.labNOS.setText(str((1<<int(self.txtNOS.text()))))
self.isScaled = self.chkScale.isChecked()
self.isLogScale = self.chkLogScale.isChecked()
self.isFFT = self.chkFFT.isChecked()
self.showComp = self.cbShowComp.currentIndex()
self.plot()
def start(self):
if self.idle:
print "connecting ..."
self.btnStart.setEnabled(False)
self.socket.connectToHost(self.txtIPA.text(), 1001)
else:
self.idle = True
self.socket.close()
self.offset = 0
self.btnStart.setText('Start')
self.btnStart.setEnabled(True)
print "Disconnected"
def setConfig(self):
# Number of Samples
self.size = (1<<int(self.txtNOS.text()))
self.naverages = (1<<int(self.txtNOA.text()))
#print "number of samples = " + str(self.size)
if self.idle: return
self.socket.write(struct.pack('<I', 1<<28 | int(self.txtTD.text())))
self.socket.write(struct.pack('<I', 2<<28 | int(self.txtNOS.text())))
self.socket.write(struct.pack('<I', 3<<28 | int(self.txtNOA.text())))
#print "Configuration sent"
def connected(self):
print "Connected"
self.idle = False
self.btnStart.setText('Stop')
self.btnStart.setEnabled(True)
self.setConfig()
self.fire()
def read_data(self):
size = self.socket.bytesAvailable()
print "got " + str(size)
if self.offset + size < 4*self.size:
self.buffer[self.offset:self.offset + size] = self.socket.read(size)
self.offset += size
else:
#print "have all data"
self.buffer[self.offset:4*self.size] = self.socket.read(4*self.size - self.offset)
self.offset = 0
self.haveData = True
self.plot()
self.idle = True
self.socket.close()
self.offset = 0
self.btnStart.setText('Start')
self.btnStart.setEnabled(True)
print "Disconnected"
def plot(self):
if self.haveData == False: return
# reset toolbar
self.toolbar.home()
self.toolbar._views.clear()
self.toolbar._positions.clear()
# reset plot
self.axes.clear()
self.axes.grid()
# set data
self.time_step = 1./125 # us
y_data = np.array(self.data[0:self.size], dtype=float)
N = self.size; # number of complex samples
# scale
y_data = y_data/self.naverages
x_data = np.arange(1,N+1)
xlab = "Index"
ylab = "14-bit ADC output"
if self.isScaled == True:
self.gnd = 0*-146.6
self.vcc = 1133.7;
y_data = 4.96*(y_data - self.gnd)/(self.vcc-self.gnd)
x_data = self.time_step*x_data
xlab = 'Time (us)'
ylab = 'Voltage'
if self.isFFT == True:
y_data[-1] = (y_data[0]+y_data[-2])/2
y_data = np.fft.fft(y_data)/N
x_data = np.fft.fftfreq(y_data.size, self.time_step)
x_data = np.fft.fftshift(x_data)
y_data = np.fft.fftshift(y_data)
xlab = 'Frequency (MHz)'
ylab = 'Amplitude'
if self.showComp == 0:
y_data = y_data.real
ylab = "Real " + ylab
elif self.showComp == 1:
y_data = y_data.imag
ylab = "Imag " + ylab
elif self.showComp == 2:
y_data = np.abs(y_data)
ylab = "Abs " + ylab
else:
y_data = np.angle(y_data)
ylab = "Phase " + ylab
if self.isLogScale == True:
y_data = 20*np.log10(y_data)
ylab = ylab + ' (dBV)'
else:
ylab = ylab + ' (V)'
#print str(y_data[N/2-1]) + " " + str(y_data[N/2]) + " " + str(y_data[N/2+1])
self.curve = self.axes.plot(x_data, y_data)
#x1, x2, y1, y2 = self.axes.axis()
# set y axis limits
#self.axes.axis((1, self.size, -1500,500))
self.axes.set_xlim([min(x_data), max(x_data)])
self.axes.set_xlabel(xlab)
self.axes.set_ylabel(ylab)
self.canvas.draw()
def display_error(self, socketError):
if socketError == QAbstractSocket.RemoteHostClosedError:
pass
else:
QMessageBox.information(self, 'Averager', 'Error: %s.' % self.socket.errorString())
self.btnStart.setText('Start')
self.btnStart.setEnabled(True)
def fire(self):
if self.idle: return
self.socket.write(struct.pack('<I', 0<<28))
class QiVisClient(QtCore.QObject):
def __init__(self, name, server, serverPort, x, y, width, height ):
"""__init__() -> None
initializes the client class"""
QtCore.QObject.__init__(self)
self.timer = QtCore.QTimer(self)
self.timer.setSingleShot(True)
self.timer.setInterval(1000)
self.timer.start()
self.socket = QTcpSocket()
self.current_pipeline = None
self.current_config_function = None
self.server = server # os.environ.get( 'DV3D_HW_SERVER_NAME', server )
self.serverPort = int(serverPort)
self.buffer = ""
self.pipelineQueue = []
current_pipeline = None
self.deviceName = name
self.currentTab = None
self.mainWindow = None
print " Init VisClient, server=%s, serverPort=%s, name=%s " % ( str(self.server), str(self.serverPort), str(name) )
self.spreadsheetWindow = spreadsheetController.findSpreadsheetWindow( False )
self.spreadsheetWindow.setWindowFlags( self.spreadsheetWindow.windowFlags() | QtCore.Qt.WindowStaysOnTopHint | QtCore.Qt.Window )
# self.spreadsheetWindow.setWindowFlags( self.spreadsheetWindow.windowFlags() | QtCore.Qt.Window )
self.spreadsheetWindow.activateWindow()
self.spreadsheetWindow.showMaximized()
self.dimensions = ( x, y, width, height )
self.connectSignals()
def createTab( self, displayWidth, displayHeight, fullScreenEnabled ):
self.spreadsheetWindow.addTabController('DV3D')
tabController = self.spreadsheetWindow.get_current_tab_controller()
tabController.clearTabs()
self.currentTab = DisplayWallSheetTab( tabController, self.dimensions[0], self.dimensions[1], self.dimensions[2], self.dimensions[3], displayWidth, displayHeight, fullScreenEnabled )
tabController.addTabWidget(self.currentTab, self.deviceName)
tabController.setCurrentWidget(self.currentTab)
self.size = self.currentTab.getDimension()
print " Startup VisClient, size=%s, dims=%s, fullScreen=%s " % ( str(self.size), str(self.dimensions), str(fullScreenEnabled) )
def updateCurrentTab(self):
if self.currentTab == None:
tabController = self.spreadsheetWindow.get_current_tab_controller()
# self.currentTab = tabController.tabWidgets[1]
self.currentTab = tabController.widget ( 1 )
if self.currentTab:
self.dims = self.currentTab.getDimension()
print " UpdateCurrentTab: ntabs=%d, dims=%s " % ( len( tabController.tabWidgets ), str( self.dims ) )
return True
return False
def connectSignals(self):
"""connectSignals() -> None
Connects all relevant signals to this class"""
self.connect(self.socket, QtCore.SIGNAL("connected()"), self.connected)
self.connect(self.socket, QtCore.SIGNAL("disconnected()"), self.disconnected)
self.connect(self.socket, QtCore.SIGNAL("readyRead()"), self.readDataFromSocket)
self.connect(self.timer, QtCore.SIGNAL("timeout()"), self.retryConnection)
self.connect(self, QtCore.SIGNAL("executeNextPipeline()"), self.executeNextPipeline)
def retryConnection(self):
"""retryConnection() -> None
this method is called once everytime self.timer ticks. It
tries to connect to the server again"""
print "retryConnection"
sys.stdout.flush()
if self.socket.state()!=QTcpSocket.ConnectedState:
if self.socket.state()==QTcpSocket.UnconnectedState:
port = int( self.serverPort )
print " HWClient connecting to server at %s:%d" % ( self.server, port )
self.socket.connectToHost(self.server, port )
self.timer.start()
elif core.system.systemType in ['Windows', 'Microsoft']:
self.socket.setSocketOption(QAbstractSocket.LowDelayOption, 1)
def connected(self):
"""connected() -> None
this method is called when self.socket emits the connected() signal. It means that a succesful connection
has been established to the server"""
sender = "displayClient"
receiver = "server"
tokens = MessageTokenSep.join( [ "dimensions", self.deviceName, str(self.dimensions[0]), str(self.dimensions[1]), str(self.dimensions[2]), str(self.dimensions[3]) ] )
reply = sender + "-" + receiver + "-" + str(len(tokens)) + ":" + tokens
print " ****** Connected to server! CellCoords = ( %d, %d ), reply: %s " % ( self.dimensions[0], self.dimensions[1], reply )
self.socket.write(reply)
def disconnected(self):
"""disconnected() -> None
this method is called when self.socket emits disconnected(). It means that the socket is no longer connected to the server"""
print "Disconnected from server"
self.timer.start()
def readDataFromSocket(self):
"""readDataFromSocket() -> None
This method is called everytime the socket sends the readyRead() signal"""
incoming = str(self.socket.readAll().data())
while incoming != "":
self.buffer += incoming
while self.buffer != "":
tokens = self.buffer.split(":")
header = tokens[0]
rest = ""
for piece in tokens[1:]:
rest += piece+":"
rest = rest[:-1]
info = header.split("-")
if len(info)<3:
break
(sender, receiver, size) = (info[0], info[1], info[2])
if int(size) > len(rest):
break
tokens = rest[:int(size)]
self.buffer = rest[int(size):]
# print " ********* CLIENT--> gotMessage: %s %s %s ********* " % ( str( receiver ), str( sender ), str( tokens ) )
sys.stdout.flush()
if (receiver == "displayClient"):
reply = self.processMessage((sender, tokens), self.socket)
if reply != ("","",""):
reply = reply[0] + "-" + reply[1] + "-" + str(len(reply[2])) + ":" + reply[2]
self.socket.write(reply)
incoming = str(self.socket.readAll().data())
def processCommand(self, terms):
print " -- processCommand: %s " % str( terms )
if terms[0] == "reltimestep":
relTimeValue = float( terms[1] )
relTimeIndex = float( terms[2] )
useTimeIndex = bool(terms[3])
displayText = terms[4]
if self.current_pipeline:
for module in self.current_pipeline.module_list:
persistentCellModule = ModuleStore.getModule( module.id )
if persistentCellModule: persistentCellModule.updateAnimation( [ relTimeValue, relTimeIndex, useTimeIndex ], displayText )
elif terms[0] == "pipelineHelper":
if self.current_config_function:
if self.current_config_function.type == 'leveling':
range = list( self.current_config_function.range )
cmd_args = terms[1].split('-')
iRangeArg = int( cmd_args[1] )
range[ iRangeArg ] = float( terms[2] )
# print " --- PipelineHelper: set range = ", str( range )
self.current_config_function.broadcastLevelingData( range )
else:
pass
# print " --- PipelineHelper, config type: ", self.current_config_function.type
else:
if self.current_pipeline:
for module in self.current_pipeline.module_list:
persistentCellModule = ModuleStore.getModule( module.id )
if persistentCellModule: persistentCellModule.updateConfigurationObserver( terms[0], terms[1:] )
# if terms[0] == 'colormap':
# cmapData = terms[1]
# displayText = terms[2]
# for module in self.current_pipeline.module_list:
# persistentCellModule = ModuleStore.getModule( module.id )
# persistentCellModule.setColormap( cmapData )
# persistentCellModule.updateTextDisplay( displayText )
def processEvent(self, terms):
"""processEvent(message: String) -> None
decodifies the event received by the server and posts it to QT's event handler. In order
to do this, we must send three events: the first one disables this client's method that
would send events to the server. The second is the actual event we want processed and the third
reenables event sending to the server. This must be done to avoid a deadlock"""
def decodeMouseEvent( event, screenDims ):
"""decodeMouseEvent(event: String) -> QtGui.QMouseEvent
this method receives a string and returns the corresponding mouse event"""
pos = ( int( float( event[2] ) * screenDims[0] ), int( float( event[3] ) * screenDims[1] ) )
if event[1] == "left":
button = QtCore.Qt.LeftButton
elif event[1] == "right":
button = QtCore.Qt.RightButton
if event[0] == "singleClick":
t = QtCore.QEvent.MouseButtonPress
elif event[0] == "mouseMove":
t = QtCore.QEvent.MouseMove
button = QtCore.Qt.NoButton
elif event[0] == "mouseRelease":
t = QtCore.QEvent.MouseButtonRelease
button = QtCore.Qt.MouseButton(button)
m = QtCore.Qt.NoModifier
if event[4] == "shift":
m = QtCore.Qt.ShiftModifier
elif event[4] == "ctrl":
m = QtCore.Qt.ControlModifier
elif event[4] == "alt":
m = QtCore.Qt.AltModifier
# print " Client process %s %s event: pos = %s, screenDims=%s " % ( button, event[0], str( pos ), str( screenDims ) )
return QtGui.QMouseEvent(t, QtCore.QPoint(pos[0], pos[1]), button, button, m)
def decodeKeyEvent(event):
"""decodeKeyEvent(event: String) -> QtGui.QKeyEvent
this method receives a string and returns the corresponding Key event"""
type = None
if event[0] == "keyPress":
type = QtCore.QEvent.KeyPress
elif event[0] == "keyRelease":
type = QtCore.QEvent.KeyRelease
key = int( event[1] )
m = QtCore.Qt.NoModifier
if event[2] == "shift":
m = QtCore.Qt.ShiftModifier
elif event[2] == "ctrl":
m = QtCore.Qt.ControlModifier
elif event[2] == "alt":
m = QtCore.Qt.AltModifier
# print " Client process key event: %s " % str( event )
return QtGui.QKeyEvent( type, key, QtCore.Qt.KeyboardModifiers(m) )
app = QtCore.QCoreApplication.instance()
newTab = self.updateCurrentTab()
widget = self.currentTab.getCellWidget( 0, 0 ) if self.currentTab else None
# print " ------------- QiVisClient.processEvent: %s ---------------------" % ( str(terms) )
sys.stdout.flush()
if terms[2] == "interactionState":
if self.current_pipeline:
state = terms[3] if ( len(terms) > 3 ) else None
altMode = terms[4] if ( len(terms) > 4 ) else None
print " ~~~~~ Setting Client Interaction State: ", str(state), str(altMode)
sys.stdout.flush()
for module in self.current_pipeline.module_list:
persistentModule = ModuleStore.getModule( module.id )
if persistentModule:
cf = persistentModule.updateInteractionState( state, altMode )
if cf: self.current_config_function = cf
else: print "Can't find client persistentModule: ", module.id
else:
newEvent = None
if terms[2] == "singleClick":
cellModules = self.getCellModules()
cpos = [ float(terms[i]) for i in range(7,10) ]
cfol = [ float(terms[i]) for i in range(10,13) ]
cup = [ float(terms[i]) for i in range(13,16) ]
# print " >>> QiVisClient.cellModules: %s, modules: %s" % ( str( [ cellMod.id for cellMod in cellModules ] ), str( ModuleStore.getModuleIDs() ) )
for cellMod in cellModules:
persistentCellModule = ModuleStore.getModule( cellMod.id )
if persistentCellModule: persistentCellModule.syncCamera( cpos, cfol, cup )
if terms[2] in ["singleClick", "mouseMove", "mouseRelease"]:
if self.currentTab:
screenRect = self.currentTab.getCellRect( 0, 0 )
screenDims = ( screenRect.width(), screenRect.height() )
newEvent = decodeMouseEvent( terms[2:], screenDims )
elif terms[2] in ["keyPress", "keyRelease" ]:
newEvent = decodeKeyEvent(terms[2:])
if widget and newEvent:
cellWidget = widget.widget()
app.postEvent( cellWidget, newEvent)
cellWidget.setFocus()
cellWidget.update()
def executeNextPipeline(self):
if len(self.pipelineQueue) == 0:
return
pipeline = self.pipelineQueue[-1]
self.pipelineQueue.pop()
self.executePipeline(pipeline)
self.emit(QtCore.SIGNAL("executeNextPipeline()"))
def getCellModules(self):
cellModules = []
if self.current_pipeline:
for module in self.current_pipeline.module_list:
if ( module.name == "MapCell3D" ): cellModules.append( module )
return cellModules
def getCurrentPipeline(self):
return self.current_pipeline
def setCellLocation(self):
cellModule = None
if self.current_pipeline:
print " Executing Client Workflow, modules: "
for module in self.current_pipeline.module_list:
print str( module )
# if : cellModule = module
def executePipeline(self,pipeline):
from core.db.io import unserialize
from core.vistrail.pipeline import Pipeline
from core.interpreter.default import get_default_interpreter as getDefaultInterpreter
from core.utils import DummyView
import api
tabController = self.spreadsheetWindow.get_current_tab_controller()
pip = unserialize(str(pipeline), Pipeline)
# print " **** Client-%s ---Received Pipeline--- modules:" % str( self.dimensions )
# for module in pip.module_list:
# print " ", str(module.id)
self.current_pipeline = pip
interpreter = getDefaultInterpreter()
kwargs = { "locator": None,
"current_version": None,
"view": DummyView(),
"aliases": {} }
interpreter.execute( pip, **kwargs )
print "Finished Executing Pipeline"
def processMessage(self, message, socket):
(sender, tokens) = message
# print " ********* CLIENT--> processMessage: %s ********* " % str( tokens )
tokens = tokens.split( MessageTokenSep )
if ( len(tokens) < 4 ) or ( tokens[3] <> 'mouseMove' ): print " ********* CLIENT--> splitMessage: %s ********* " % str( tokens )
if len(tokens) == 0: return
if tokens[0] == "exit":
print "Received shutdown message"
sys.stdout.flush()
socket.close()
gui.application.get_vistrails_application().quit()
gui.application.stop_application()
sys.exit(0)
if tokens[0] == "pipeline":
# print " $$$$$$$$$$$ Client-- pipeline message: %s " % str(tokens)
### we must execute a pipeline
# return ("", "", "")
if len(tokens[2:]) != 0:
for t in tokens[2:]:
tokens[1] += t + "@"
tokens[1] = tokens[1][:-1]
self.executePipeline(tokens[1])
elif tokens[0] == "interaction":
self.processEvent(tokens[1:])
elif tokens[0] == "command":
self.processCommand(tokens[3:])
elif tokens[0] == "refresh":
self.updateCurrentTab()
if self.currentTab:
widget = self.currentTab.getCell(int(tokens[1]), int(tokens[2]))
# if widget:
# widget.swapBuffers()
return ("", "", "")
def __init__(self, portaResponder, parent=None):
super().__init__(None, portaResponder, parent)
self._socketClient = QTcpSocket(self)
self._socketClient.readyRead.connect(self._lerDados)
def connectToHost(self, host, port):
print 'connectToHost'
self.temp = ''
self.wait_len = ''
QTcpSocket.abort(self)
QTcpSocket.connectToHost(self, host, port)
def initUI(self):
self.socket = QTcpSocket()
self.connect(self.socket, SIGNAL("connected()"), self.sendRequest)
self.connect(self.socket, SIGNAL("readyRead()"), self.readResponse)
self.connect(self.socket, SIGNAL("disconnected()"),
self.serverHasStopped)
self.connect(self.socket,
SIGNAL("error(QAbstractSocket::SocketError)"),
self.serverHasError)
self.mywin = self.window()
self.value = 0
self.value2 = -2
self.lcdtimer = QtGui.QLCDNumber(self)
self.lcdtimer.setGeometry(QtCore.QRect(700, 120, 250, 120))
self.lcdtimer.setStyleSheet(
_fromUtf8("background-color: rgb(201, 183, 255);"
"color: #F1ECDD;"))
self.lcdtimer.display(self.value2)
self.timer = QtCore.QTimer()
self.timer2 = QtCore.QTimer()
self.timer3 = QtCore.QTimer()
self.lcdwpm = QtGui.QLCDNumber(self)
self.lcdwpm.setGeometry(QtCore.QRect(700, 260, 250, 120))
self.lcdwpm.setStyleSheet(
_fromUtf8("background-color: rgb(201, 183, 255);"
"color: #F1ECDD;"))
self.progbar = QtGui.QProgressBar(self)
self.progbar.setGeometry(70, 670, 1000, 100)
self.progbar.setValue(0)
self.lcdaccuracy = QtGui.QLCDNumber(self)
self.lcdaccuracy.setGeometry(QtCore.QRect(700, 400, 250, 120))
self.lcdaccuracy.setStyleSheet(
_fromUtf8("background-color: rgb(201, 183, 255);"
"color: #F1ECDD;"))
QtCore.QObject.connect(self.timer, QtCore.SIGNAL("timeout()"),
self.count)
QtCore.QObject.connect(self.timer2, QtCore.SIGNAL("timeout()"),
self.count2)
QtCore.QObject.connect(self.timer3, QtCore.SIGNAL("timeout()"),
self.count3)
self.lcdtimer.display(self.value)
self.lbl = QtGui.QTextBrowser(self)
self.exitlbl = QtGui.QLabel(self)
self.exitlbl.setGeometry(QtCore.QRect(70, 365, 700, 100))
self.exitlbl.setVisible(False)
self.restart = QtGui.QPushButton(self)
self.restart.setGeometry(QtCore.QRect(100, 550, 724, 100))
self.restart.setText("Restart")
self.restart.setVisible(False)
self.restart.setStyleSheet(
_fromUtf8("font: 24pt \"mry_KacstQurn\";\n"
"background-color: rgb(255, 255, 255);"))
self.restart.clicked.connect(self.restartf)
self.lbl.setGeometry(QtCore.QRect(70, 50, 724, 300))
self.lbl.setObjectName(_fromUtf8("lbl"))
self.lbl.setStyleSheet(
_fromUtf8("background-color: rgb(201, 183, 255); color: #4C3327;"))
self.qle = QtGui.QLineEdit(self)
self.qle.setGeometry(QtCore.QRect(70, 500, 724, 100))
self.qle.setStyleSheet(
_fromUtf8("font: 24pt \"mry_KacstQurn\";\n"
"color: #25343B;"
"background-color: rgb(201, 183, 255);"))
self.qle.textChanged[str].connect(self.onChanged)
self.qle.setReadOnly(True)
self.wpmlbl = QtGui.QLabel(self)
self.wpmlbl.setGeometry(QtCore.QRect(1155, 260, 100, 120))
self.wpmlbl.setText("<font size=\"20\"> WPM</font>")
self.wpmlbl.setStyleSheet(
_fromUtf8("background-color: rgb(201, 183, 255);"
"color: #F1ECDD;"))
self.accuracylbl = QtGui.QLabel(self)
self.accuracylbl.setGeometry(QtCore.QRect(1155, 400, 120, 120))
self.accuracylbl.setText("<font size=\"28\">Rank</font>")
self.accuracylbl.setStyleSheet(
_fromUtf8("background-color: rgb(201, 183, 255);"
"color: #F1ECDD;"))
self.setGeometry(10, 10, 1365, 758)
self.setStyleSheet(
_fromUtf8("background-color: #4C3327;"
"background-image: url(img3.jpg);"
"color: #4C3327;"))
self.setWindowTitle('SwiftTyper')
self.show()
self.timer.start(100)
self.shrt_sh = QtGui.QShortcut(QtGui.QKeySequence.ZoomIn, self)
self.connect(self.shrt_sh, QtCore.SIGNAL("activated()"), self.shrt)
self.shrt2_sh = QtGui.QShortcut(QtGui.QKeySequence.ZoomOut, self)
self.connect(self.shrt2_sh, QtCore.SIGNAL("activated()"), self.shrt2)
class TrickplayDeviceManager(QWidget):
def __init__(self, main=None, parent=None):
QWidget.__init__(self, parent)
self.main = main
self.inspector = main._inspector
self.editorManager = main._editorManager
self.debugWindow = main._debug
self.backtraceWindow = main.backtrace
self.ui = Ui_DeviceManager()
self.ui.setupUi(self)
self.addLocalComboItem()
self.discovery = TrickplayDiscovery(self)
QObject.connect(self.ui.comboBox, SIGNAL('currentIndexChanged(int)'),
self.service_selected)
QObject.connect(self.ui.run, SIGNAL("clicked()"), self.run)
self._path = ''
self.trickplay = QProcess()
QObject.connect(self.trickplay, SIGNAL('started()'), self.app_started)
#QObject.connect(self.trickplay, SIGNAL('finished(int, QProcess.ExitStatus)'), self.app_finished)
QObject.connect(self.trickplay, SIGNAL('finished(int)'),
self.app_finished)
QObject.connect(self.trickplay, SIGNAL('readyRead()'),
self.app_ready_read)
self.icon = QIcon()
self.icon.addPixmap(
QPixmap(self.main.apath + "/Assets/icon-target.png"), QIcon.Normal,
QIcon.Off)
self.icon_null = QIcon()
self.prev_index = 0
self.ui.comboBox.setSizeAdjustPolicy(QComboBox.AdjustToContents)
self.ui.comboBox.setIconSize(QSize(20, 32))
self.debug_mode = False
self.debug_run = False
self.debug_port = None
self.console_port = None
self.http_port = None
self.my_name = ""
self.manager = QNetworkAccessManager()
#self.reply = None
#self.bs_command = False
self.current_debug_file = None
self.inbreak = True
def service_selected(self, index):
if index < 0:
return
self.ui.comboBox.setItemIcon(self.prev_index, self.icon_null)
self.ui.comboBox.setItemIcon(index, self.icon)
self.prev_index = index
address = self.ui.comboBox.itemData(index, ADDRESS).toPyObject()
port = self.ui.comboBox.itemData(index, PORT).toPyObject()
self.debug_port = self.ui.comboBox.itemData(index,
DEBUG_PORT).toPyObject()
self.http_port = self.ui.comboBox.itemData(index,
HTTP_PORT).toPyObject()
self.console_port = self.ui.comboBox.itemData(
index, CONSOLE_PORT).toPyObject()
if not address or not port:
return
CON.port = port
CON.address = address
def event(self, event):
QCoreApplication.setOrganizationName('Trickplay')
while 1:
if event.type() == ADDEVENT:
d = event.dict
if d[0] != self.my_name:
print "[VDBG] Service ' %s ' added" % d[0]
# Add item to ComboBox
self.ui.comboBox.addItem(d[0])
index = self.ui.comboBox.findText(d[0])
self.ui.comboBox.setItemData(index, d[1], ADDRESS)
self.ui.comboBox.setItemData(index, d[2], PORT)
self.ui.comboBox.setItemData(index, d[1], NAME)
# Automatically select a service if only one exists
if 1 == self.ui.comboBox.count():
self.service_selected(1) # index -> 1
data = getTrickplayControlData("%s:" % str(d[1]) +
"%s" % str(d[2]))
if data is not None:
if data.has_key("debugger"):
self.ui.comboBox.setItemData(
index, data["debugger"], DEBUG_PORT)
print("[VDBG] debug Port : %s" % data["debugger"],
d[0])
else:
print(
"[VDBG] Didn't get %s's debug_port information "
% d[0])
if data.has_key("http"):
#self.http_port = data["http"]
#print("[VDBG] http Port : %s"%self.http_port)
self.ui.comboBox.setItemData(
index, data["http"], HTTP_PORT)
else:
print(
"[VDBG] Didn't get %s's http_port information "
% d[0])
if data.has_key("console"):
self.console_port = data["console"]
#print("[VDBG] console Port : %s"%self.console_port)
self.ui.comboBox.setItemData(
index, data["console"], CONSOLE_PORT)
CON.port = self.http_port
else:
print(
"[VDBG] Didn't get %s's console_port information "
% d[0])
else:
print("[VDBG] Didn't get %s's Control information " %
d[0])
elif event.type() == REMEVENT:
d = event.dict
print "[VDBG] Service ' %s ' removed" % d[0]
# Remove item from ComboBox
index = self.ui.comboBox.findText(d[0])
if index == self.ui.comboBox.currentIndex():
self.ui.comboBox.removeItem(index)
self.ui.comboBox.setCurrentIndex(0)
self.service_selected(0)
else:
self.ui.comboBox.removeItem(index)
#self.inspector.clearTree()
return True
def stop(self):
self.discovery.stop()
def addLocalComboItem(self):
"""
Add combo box from running app locally. This always exists.
"""
name = 'Emulator' #'Trickplay Device '
port = '6789'
address = 'localhost'
icon = QIcon()
icon.addPixmap(QPixmap(self.main.apath + "/Assets/icon-target.png"),
QIcon.Normal, QIcon.Off)
self.ui.comboBox.addItem(name)
index = self.ui.comboBox.findText(name)
self.ui.comboBox.setItemIcon(index, icon)
self.ui.comboBox.setItemData(index, address, ADDRESS)
self.ui.comboBox.setItemData(index, port, PORT)
self.ui.comboBox.setItemData(index, address, NAME)
CON.port = port
CON.address = address
def push(self):
print('[VDBG] Pushing app to %s' % CON.get())
tp = TrickplayPushApp(self, str(self.path()))
ret = tp.push(address=CON.get())
if ret is not False:
self.app_started()
return ret
def setPath(self, p):
self._path = p
def path(self):
return self._path
def app_started(self):
print "[VDBG] APP Started"
self.newApp = True
# Console Port
self.socket = QTcpSocket()
self.nextBlockSize = 0
self.bytesAvail = 0
self.connect(self.socket, SIGNAL("connected()"), self.sendRequest)
self.connect(self.socket, SIGNAL("readyRead()"), self.readResponse)
self.connect(self.socket, SIGNAL("disconnected()"),
self.serverHasStopped)
if self.socket.isOpen():
self.socket.close()
if self.ui.comboBox.currentIndex() != 0:
print("[VDBG] Connecting to console port ")
cnt = 0
while cnt < 5:
try:
self.socket.connectToHost(CON.address,
self.console_port,
mode=QIODevice.ReadWrite)
if self.socket.waitForConnected(100):
self.newApp = True
break
except:
cnt = cnt + 1
def sendRequest(self):
print "Connected"
def readDebugResponse(self):
while self.debug_socket.waitForReadyRead(1100):
print self.debug_socket.read(self.debug_socket.bytesAvailable())
def readResponse(self):
while self.socket.waitForReadyRead(1100):
EGN_MSG(
self.socket.read(self.socket.bytesAvailable())[:-1].replace(
'\033[34;1m', '').replace('\033[31;1m', '').replace(
'\033[0m', '').replace('\033[37m',
'').replace('\033[32m', ''))
def debugServerHasStopped(self):
self.debug_socket.close()
def serverHasStopped(self):
print("Console port disconnected")
self.socket.close()
def serverHasError(self, error):
print(QString("[VDBG] Error: %1").arg(self.socket.errorString()))
self.socket.close()
def app_ready_read(self):
# Read all available output from the process
while True:
# Read one line
if not self.trickplay.canReadLine():
break
# Read one line
s = self.trickplay.readLine()
# If the line is null, it means there is nothing more
# to read during this iteration
if s.isNull():
break
# Convert it to a string and strip the trailing white space
s = str(s).rstrip()
# Look for the CONTROL line
if s.startswith("<<CONTROL>>:"):
try:
# Parse the contents of the control line and get the
# debugger port.
control = json.loads(s[12:])
# Store it. This could fail if the engine has no debugger
# port.
if control.has_key("debugger"):
self.debug_port = control["debugger"]
if control.has_key("http"):
self.http_port = control["http"]
if control.has_key("console"):
self.console_port = control["console"]
self.ui.comboBox.setItemData(0, self.http_port, PORT)
CON.port = self.http_port
# Send our first debugger command, which will return
# when the app breaks
if self.debug_mode == True:
self.inbreak = False
self.send_debugger_command(DBG_CMD_INFO)
if len(self.editorManager.bp_info[1]) > 0:
self.send_debugger_command(DBG_CMD_BB)
else:
self.inspector.ui.refresh.setEnabled(True)
self.inspector.ui.search.setEnabled(True)
except:
print("[VDBG] Failed to obtain debugger port")
# Close the process
self.trickplay.close()
else:
# Output the log line
EGN_MSG(">> %s" % s.replace('\033[34;1m', '').replace(
'\033[31;1m', '').replace('\033[0m', '').replace(
'\033[37m', '').replace('\033[32m', ''))
def send_debugger_command(self, command):
if self.debug_port is None:
print "No debugger port"
return
url = QUrl()
url.setScheme("http")
url.setHost(CON.address)
url.setPort(self.debug_port)
url.setPath("/debugger")
print("[VDBG] ' %s ' Command Sent" % command)
data = {}
request = QNetworkRequest(url)
if command == "bb":
data['clear'] = True
data['add'] = []
bpCnt = len(self.editorManager.bp_info[1])
for r in range(0, bpCnt):
bp_info = self.editorManager.bp_info[2][r]
n = re.search(":", bp_info).end()
fName = bp_info[:n - 1]
lNum = int(bp_info[n:]) - 1
if self.editorManager.bp_info[1][r] == "on":
bState = True
else:
bState = False
#data['add'].append({'file':fName, 'line':lNum, 'on':bState})
bp_item = {}
bp_item['file'] = fName
bp_item['line'] = lNum + 1
bp_item['on'] = bState
data['add'].append(bp_item)
params = json.dumps(data)
reply = self.manager.post(request, command + ' ' + params)
reply.command = command
else:
reply = self.manager.post(request, command)
reply.command = command
def debugger_reply_finished(reply):
def foo():
if reply.error() == QNetworkReply.NoError:
print("[VDBG] ' %s ' Response" % reply.command)
if reply.command == "bn":
return
if reply.command == "r":
self.main.deviceManager.socket.write('/close\n\n')
self.main.rSent = False
if self.main.onExit == True:
if self.editorManager.tab != None:
while self.editorManager.tab.count() != 0:
self.editorManager.close()
self.stop()
self.main.close()
data = self.getFileLineInfo_Resp(str(reply.readAll()),
command)
if data is not None:
if reply.command == DBG_CMD_INFO:
self.inbreak = True
self.inspector.ui.refresh.setEnabled(False)
self.inspector.ui.search.setEnabled(False)
# Open File, Show Current Lines
if self.file_name.startswith("/"):
self.file_name = self.file_name[1:]
self.file_name = self.file_name + '/'
if self.file_name.endswith("/"):
self.file_name = self.file_name[:len(
self.file_name) - 1]
current_file = os.path.join(
str(self.main.path), str(self.file_name))
if self.current_debug_file != current_file:
self.editorManager.newEditor(
current_file, None, self.line_no,
self.current_debug_file, True)
else:
self.editorManager.newEditor(
current_file, None, self.line_no, None,
True)
self.current_debug_file = current_file
# Local Variable Table
local_info = self.getLocalInfo_Resp(data)
if local_info is not None:
self.debugWindow.populateLocalTable(local_info)
# Global Variable Table
global_info = self.getGlobalInfo_Resp(data)
if global_info is not None:
self.debugWindow.populateGlobalTable(
global_info, self.editorManager)
# Stack Trace Table
stack_info = self.getStackInfo_Resp(data)
if stack_info is not None:
self.backtraceWindow.populateTraceTable(
stack_info, self.editorManager)
#reply = None
#reply.command = None
# TODO: Here we should enable the debug UI
self.main.debug_stepinto.setEnabled(True)
self.main.debug_stepover.setEnabled(True)
self.main.debug_stepout.setEnabled(False)
self.main.debug_pause_bt.setEnabled(False)
self.main.debug_continue_bt.setEnabled(True)
self.main.ui.actionContinue.setEnabled(True)
self.main.ui.actionPause.setEnabled(False)
self.main.ui.actionStep_into.setEnabled(True)
self.main.ui.actionStep_over.setEnabled(True)
self.main.ui.actionStep_out.setEnabled(False)
self.main.debug_run = False
elif reply.command[:
1] == DBG_CMD_BREAKPOINT or reply.command == DBG_CMD_BB or reply.command[:
1] == DBG_CMD_DELETE:
# Break Point
break_info = self.getBreakPointInfo_Resp(data)
if break_info is not None:
self.debugWindow.populateBreakTable(
break_info, self.editorManager)
if reply.command == DBG_CMD_BB:
return
editor = self.editorManager.app.focusWidget()
if editor is not None:
nline = editor.margin_nline
else:
index = self.editorManager.tab.currentIndex()
editor = self.editorManager.tab.editors[index]
nline = editor.margin_nline
if reply.command[:
1] == DBG_CMD_DELETE and nline is not None:
if editor.current_line != nline:
editor.markerDelete(nline, -1)
else:
editor.markerDelete(nline, -1)
editor.markerAdd(nline,
editor.ARROW_MARKER_NUM)
editor.line_click[nline] = 0
return
elif nline is None:
return
# Break Point Setting t
if not editor.line_click.has_key(
nline) or editor.line_click[nline] == 0:
if editor.current_line != nline:
editor.markerAdd(
nline, editor.ACTIVE_BREAK_MARKER_NUM)
else:
editor.markerDelete(
nline, editor.ARROW_MARKER_NUM)
editor.markerAdd(
nline,
editor.ARROW_ACTIVE_BREAK_MARKER_NUM)
editor.line_click[nline] = 1
# Break Point Deactivate
elif editor.line_click[nline] == 1:
if editor.current_line != nline:
editor.markerDelete(
nline, editor.ACTIVE_BREAK_MARKER_NUM)
editor.markerAdd(
nline,
editor.DEACTIVE_BREAK_MARKER_NUM)
else:
editor.markerDelete(
nline,
editor.ARROW_ACTIVE_BREAK_MARKER_NUM)
editor.markerAdd(
nline,
editor.ARROW_DEACTIVE_BREAK_MARKER_NUM)
editor.line_click[nline] = 2
# Break Point Active
elif editor.line_click[nline] == 2:
if editor.current_line != nline:
editor.markerDelete(
nline,
editor.DEACTIVE_BREAK_MARKER_NUM)
editor.markerAdd(
nline, editor.ACTIVE_BREAK_MARKER_NUM)
else:
editor.markerDelete(
nline,
editor.ARROW_DEACTIVE_BREAK_MARKER_NUM)
editor.markerAdd(
nline,
editor.ARROW_ACTIVE_BREAK_MARKER_NUM)
editor.line_click[nline] = 1
#reply = None
#self.command = None
if reply.command in DBG_ADVANCE_COMMANDS:
if reply.command == DBG_CMD_CONTINUE:
# delete current line marker
for m in self.editorManager.editors:
if self.current_debug_file == m:
# check what kind of arrow marker was on the current line and delete just arrow mark not break points
self.editorManager.tab.editors[
self.editorManager.editors[m]
[1]].markerDelete(
self.editorManager.tab.editors[
self.editorManager.editors[m]
[1]].current_line,
Editor.ARROW_MARKER_NUM)
self.editorManager.tab.editors[
self.editorManager.editors[m]
[1]].current_line = -1
# clean backtrace and debug windows
self.backtraceWindow.clearTraceTable(0)
self.debugWindow.clearLocalTable(0)
self.debugWindow.clearGlobalTable(0)
# Leave the debug UI disabled, and wait for the info command to return
self.send_debugger_command(DBG_CMD_INFO)
return foo
f = debugger_reply_finished(reply)
QObject.connect(reply, SIGNAL('finished()'), f)
reply.command = command[:]
if command in DBG_ADVANCE_COMMANDS:
# TODO: Here we should disable the debug UI
self.main.debug_stepinto.setEnabled(False)
self.main.debug_stepover.setEnabled(False)
self.main.debug_stepout.setEnabled(False)
self.main.debug_pause_bt.setEnabled(True)
self.main.debug_continue_bt.setEnabled(False)
self.main.ui.actionContinue.setEnabled(False)
self.main.ui.actionPause.setEnabled(True)
self.main.ui.actionStep_into.setEnabled(False)
self.main.ui.actionStep_over.setEnabled(False)
self.main.ui.actionStep_out.setEnabled(False)
self.main.debug_run = True
return True
def app_finished(self, errorCode):
if errorCode == 0:
print(
"[VDBG] Error Code : [" + str(errorCode) +
", FailedToStart] the process failed to start. Either the invoked program is missing, or you may have insufficient permissions to invoke the program"
)
elif errorCode == 1:
print(
"[VDBG] Error Code : [" + str(errorCode) +
", Crashed] The process crashed some time after starting successfully."
)
elif errorCode == 2:
print(
"[VDBG] Error Code : [" + str(errorCode) +
", Timedout] The process crashed some time after starting successfully."
)
elif errorCode == 3:
print(
"[VDBG] Error Code : [" + str(errorCode) +
", ReadError] An error occurred when attempting to read from the process. For example, the process may not be running."
)
elif errorCode == 4:
print(
"[VDBG] Error Code : [" + str(errorCode) +
", WriteError] An error occurred when attempting to write to the process. For example, the process may not be running, or it may have closed its input channel."
)
elif errorCode == 5:
print("[VDBG] Error Code : [" + str(errorCode) +
", UnknownError] An unknown error occurred.")
if self.trickplay.state() == QProcess.NotRunning:
print "[VDBG] Trickplay APP is finished"
if self.trickplay.exitStatus() == QProcess.NormalExit:
print("[VDBG] ExitStatus : The process exited normally.")
elif self.trickplay.exitStatus() == QProcess.CrashExit:
print("[VDBG] ExitStatus : The process crashed.")
if self.main.closedByIDE == False:
msg = QMessageBox()
msg.setText("The process crashed.")
msg.setInformativeText('ErrorCode : [ ' + str(errorCode) +
' ]')
msg.setWindowTitle("Warning")
msg.setGeometry(500, 500, 0, 0)
msg.exec_()
self.inspector.clearTree()
self.inspector.ui.refresh.setEnabled(False)
self.inspector.ui.search.setEnabled(False)
self.main.stop()
def run(self, dMode=False):
# Run on local trickplay
if 0 == self.ui.comboBox.currentIndex():
print("[VDBG] Starting trickplay locally")
if self.trickplay.state() == QProcess.Running:
self.trickplay.close()
env = self.trickplay.processEnvironment().systemEnvironment()
if self.main.config is None:
print("[VDBG] .trickplay config file is ignored.")
for item in env.toStringList():
if item[:3] == "TP_":
n = re.search("=", item).end()
env.remove(item[:n - 1])
env.insert("TP_config_file", "")
else:
print("[VDBG] .trickplay config file is read.")
env.insert("TP_LOG", "bare")
if dMode == True:
self.debug_mode = True
self.main.debug_mode = True
env.insert("TP_start_debugger", "true")
else:
self.debug_mode = False
self.main.debug_mode = False
# To merge stdout and stderr
self.trickplay.setProcessChannelMode(QProcess.MergedChannels)
self.trickplay.setProcessEnvironment(env)
ret = self.trickplay.start('trickplay', [self.path()])
# Push to remote device
else:
if dMode == True:
if self.debug_port is None:
print("[VDBG] Debug port is missing")
return False
# POST http://<host>:<debugger port>/debugger "r"
#url = QUrl()
#url.setScheme( "http" )
#url.setHost( CON.address )
#url.setPort( self.debug_port )
#url.setPath( "/debugger" )
#print ("[VDBG] ' %s ' Command Sent"%'r')
#request = QNetworkRequest( url )
#self.manager.post( request , 'r' )
self.debug_mode = True
self.main.debug_mode = True
ret = self.push()
if ret == False:
return ret
elif dMode == True:
self.inbreak = False
self.send_debugger_command(DBG_CMD_INFO)
if len(self.editorManager.bp_info[1]) > 0:
self.send_debugger_command(DBG_CMD_BB)
else:
self.inspector.ui.refresh.setEnabled(True)
self.inspector.ui.search.setEnabled(True)
def getFileLineInfo_Resp(self, data, command):
pdata = json.loads(data)
if command == "i":
if "error" in pdata:
print "[VDBG] " + pdata["error"]
return None
else:
file_name = pdata["file"]
tp_id = pdata["id"]
line_num = pdata["line"]
self.line_no = str(line_num)
self.file_name = str(file_name)
return pdata
else:
return pdata
def getGlobalInfo_Resp(self, data):
if "globals" in data:
name_var_list = []
type_var_list = []
value_var_list = []
defined_var_list = []
global_vars_str = ""
global_vars = {}
for c in data["globals"]:
if c["name"] != "(*temporary)":
c_v = None
if global_vars_str != "":
global_vars_str = global_vars_str + "\n\t"
global_vars_str = global_vars_str + str(
c["name"]) + "(" + str(c["type"]) + ")"
name_var_list.append(str(c["name"]))
type_var_list.append(str(c["type"]))
defined_var_list.append(str(c["defined"]))
try:
c_v = c["value"]
except KeyError:
pass
if c_v:
global_vars_str = global_vars_str + " = " + str(
c["value"])
value_var_list.append(str(c["value"]))
else:
value_var_list.append("")
global_vars[1] = name_var_list
global_vars[2] = type_var_list
global_vars[3] = value_var_list
global_vars[4] = defined_var_list
return global_vars
else:
return None
def getLocalInfo_Resp(self, data):
if "locals" in data:
name_var_list = []
type_var_list = []
value_var_list = []
local_vars_str = ""
local_vars = {}
for c in data["locals"]:
if c["name"] != "(*temporary)":
c_v = None
if local_vars_str != "":
local_vars_str = local_vars_str + "\n\t"
local_vars_str = local_vars_str + str(
c["name"]) + "(" + str(c["type"]) + ")"
name_var_list.append(str(c["name"]))
type_var_list.append(str(c["type"]))
try:
c_v = c["value"]
except KeyError:
pass
if c_v:
local_vars_str = local_vars_str + " = " + str(
c["value"])
value_var_list.append(str(c["value"]))
else:
value_var_list.append("")
local_vars[1] = name_var_list
local_vars[2] = type_var_list
local_vars[3] = value_var_list
return local_vars
else:
return None
def getStackInfo_Resp(self, data):
if "stack" in data:
stack_info_str = ""
stack_list = []
info_list = []
stack_info = {}
index = 0
for s in data["stack"]:
if "file" in s and "line" in s:
stack_info_str = stack_info_str + "[" + str(
index) + "] " + s["file"] + ":" + str(
s["line"]) + "\n\t"
stack_list.append("[" + str(index) + "] " + s["file"] +
":" + str(s["line"]))
#info_list.append(str(self.path())+'/'+s["file"]+":"+str(s["line"]))
eChar = ""
if s["file"][:1] != "/":
eChar = "/"
info_list.append(
str(self.path()) + eChar + s["file"] + ":" +
str(s["line"]))
index = index + 1
stack_info[1] = stack_list
stack_info[2] = info_list
#print "\t"+stack_info_str
return stack_info
else:
return None
def getBreakPointInfo_Resp(self, data):
if "breakpoints" in data:
state_var_list = []
file_var_list = []
breakpoints_info = {}
breakpoints_info_str = ""
index = 0
if len(data["breakpoints"]) == 0:
print "[VDBG] No breakpoints set"
return breakpoints_info
else:
for b in data["breakpoints"]:
if "file" in b and "line" in b:
breakpoints_info_str = breakpoints_info_str + "[" + str(
index) + "] " + b["file"] + ":" + str(b["line"])
file_var_list.append(b["file"] + ":" + str(b["line"]))
if "on" in b:
if b["on"] == True:
breakpoints_info_str = breakpoints_info_str + "" + "\n "
state_var_list.append("on")
else:
breakpoints_info_str = breakpoints_info_str + " (disabled)" + "\n "
state_var_list.append("off")
index = index + 1
breakpoints_info[1] = state_var_list
breakpoints_info[2] = file_var_list
print "[VDBG] " + breakpoints_info_str
return breakpoints_info
else:
return None
def printResp(self, data, command):
if "source" in data:
source_info = ""
for l in data["source"]:
if "line" in l and "text" in l:
if l["line"] == line_num:
source_info = source_info + str(
l["line"]) + " >>" + str(l["text"]) + "\n\t"
else:
source_info = source_info + str(
l["line"]) + " " + str(l["text"]) + "\n\t"
print "\t" + source_info
elif "lines" in data:
fetched_lines = ""
for l in data["lines"]:
fetched_lines = fetched_lines + l + "\n\t"
print "\t" + fetched_lines
elif "app" in data:
app_info = ""
for key in data["app"].keys():
if key != "contents":
app_info = app_info + str(key) + " : " + str(
data["app"][key]) + "\n\t"
else:
app_info = app_info + key + " : "
for c in data["app"]["contents"]:
app_info = app_info + str(c) + ","
app_info = app_info + "\n\t"
print "\t" + app_info
if command in ['n', 's', 'bn', 'cn']:
#print "\t"+"Break at "+file_name+":"+str(line_num)
pass
return True
class TcpClient(QObject):
packet = pyqtSignal(str)
connected = pyqtSignal()
disconnected = pyqtSignal()
def __init__(self, host):
super().__init__()
self._sock = QTcpSocket()
self._pending = None
self._host = host
self._log = logging.getLogger("tcp")
self._sock.connected.connect(self.greet)
self._sock.connected.connect(self.connected.emit)
self._sock.disconnected.connect(self.disconnected.emit)
self._sock.readyRead.connect(self.recv)
def set_host(self, host):
self._sock.disconnectFromHost()
self._host = host
def _cancel_pending(self):
self._pending.stop()
self._pending = None
self._sock.connected.disconnect(self._connection_success)
@pyqtSlot()
def _connection_success(self):
self._cancel_pending()
self._log.debug("connection successful")
@pyqtSlot()
def _connection_failure(self):
self._cancel_pending()
self._log.debug("connection failed")
def try_connect(self, port):
if self._pending:
self._cancel_pending()
self._sock.disconnectFromHost()
if self._sock.state() != QAbstractSocket.UnconnectedState:
self._sock.waitForDisconnected()
msg = "connecting to ({}:{})"
msg = msg.format(self._host.toString(), port)
self._log.debug(msg)
self._pending = QTimer()
self._pending.timeout.connect(self._connection_failure)
self._pending.setSingleShot(True)
self._sock.connected.connect(self._connection_success)
self._pending.start(10000)
self._sock.connectToHost(self._host, port)
def greet(self):
self.send(query_tag("port", "udp"), "")
def recv(self):
while self._sock.canReadLine():
data = bytes(self._sock.readLine()) # handle QByteArray
message = data.decode()
self.packet.emit(message)
def send(self, tag, payload):
message = tag + ":" + payload + "\n"
data = message.encode()
self._sock.write(data)
class WaveRecorder(object):
def __init__(self, sock):
self.sock = QTcpSocket()
self.sock.setSocketDescriptor(sock)
self.data = []
self.device = None
self.head = False
self.p = False
self.stream = False
self.i = 0
self.stopping = False
self.pp = False
self.pstream = False
self.vi = make_vorbis_info() # struct that stores all the static vorbis bitstream
self.vc = make_vorbis_comment() # struct that stores all the user comments
self.vd = make_vorbis_dsp_state() # central working state for the packet->PCM decoder
self.vb = make_vorbis_block() # local working space for packet->PCM decode
self.header = make_ogg_packet()
self.header_comm = make_ogg_packet()
self.header_code = make_ogg_packet()
self.audio_pkt = make_ogg_packet()
self.to = make_ogg_stream_state()
self.page = make_ogg_page()
self.terminationFlag = True # this flag is used to signal recorder that it is no longer needed (when the connection is lost)
def __del__(self):
if self.stream:
self.stream.stop_stream()
self.stream.close()
if self.pstream:
# stop stream (4)
self.pstream.stop_stream()
self.pstream.close()
# close PyAudio (5)
if self.p:
self.p.terminate()
if self.pp:
self.pp.terminate()
# make the last page in Ogg stream, purging buffer
def flushFrames(self):
vorbis_analysis_wrote(self.vd,0)
while (vorbis_analysis_blockout(self.vd, self.vb) == 1):
vorbis_analysis(self.vb,self.audio_pkt)
ogg_stream_packetin(self.to,self.audio_pkt)
self.savePage()
def addWaveFrames(self, frames):
vorbis_encode_wave_frames(self.vd, self.vb, frames, frames.__len__() / (CHANNELS * 2), CHANNELS)
while (vorbis_analysis_blockout(self.vd, self.vb) == 1):
vorbis_analysis(self.vb,self.audio_pkt)
ogg_stream_packetin(self.to,self.audio_pkt)
self.savePage()
return 1
# make initial page of Ogg stream
def oggStart(self):
r1 = vorbis_info_init(self.vi)
r2 = vorbis_encode_init_vbr(self.vi, CHANNELS, RATE, QUALITY)
r3 = vorbis_encode_setup_init(self.vi)
r4 = vorbis_comment_init(self.vc)
r5 = vorbis_analysis_init(self.vd,self.vi)
r6 = vorbis_block_init(self.vd,self.vb)
r7 = vorbis_analysis_headerout(self.vd, self.vc, self.header, self.header_comm, self.header_code)
rnd = int(random.random()*10000)
ogg_stream_init(self.to,rnd)
r1 = ogg_stream_packetin(self.to, self.header)
r2 = ogg_stream_packetin(self.to, self.header_comm)
r3 = ogg_stream_packetin(self.to, self.header_code)
self.savePage()
# purge Vorbis structures (not used yet)
def clear(self):
vorbis_analysis_wrote(self.vd,0)
while (vorbis_analysis_blockout(self.vd, self.vb) == 1):
vorbis_analysis(self.vb,self.audio_pkt)
ogg_stream_packetin(self.to,self.audio_pkt)
ogg_stream_pageout(self.to, self.page)
# make a (middle) page of Ogg stream - this one contains multimedia data
def savePage(self):
n = ogg_stream_pageout(self.to, self.page)
if n:
header = page_header(self.page)
body = page_body(self.page)
self.sock.write(header) #write Ogg page header to TCP socket
self.sock.write(body) #write Ogg page body to TCP socket
self.sock.flush() # stop waiting for data - immediately send TCP packet with everything, that was put into buffer with "write" method
self.sock.waitForBytesWritten()
def open(self, dev):
if not self.p:
self.p = pyaudio.PyAudio()
if self.stream:
return self.stream
if not self.findDevice(dev):
return False
self.stream = self.p.open(format=FORMAT,
channels=CHANNELS,
rate=RATE,
input=True,
frames_per_buffer=CHUNK,
input_device_index=self.device)
return self.stream
def record(self, dev=0):
stream = self.open(dev)
if stream:
self.oggStart() # initialize Ogg stream by writing the first page
self.readStreamToData(stream)
return True
return False
def findDevice(self, dev):
count = self.p.get_device_count()
devices = [None,] + range(count)
if dev<0 or dev>=len(devices):
return False
self.device = devices[dev]
return True
def readStreamToData(self, stream):
while self.terminationFlag == False:
self.data = stream.read(CHUNK)
self.addWaveFrames(self.data) # recorded audio frames are passed to Vorbis encoder
self.clear()
class ConnectWindow(QMainWindow, Ui_ConnectWindow):
def __init__(self):
"""
Arguments:
- `self`:
"""
QMainWindow.__init__(self)
self.setupUi(self)
self.socket = QTcpSocket()
self.connect()
# Signals
conn_success = pyqtSignal('QTcpSocket')
exit_signal = pyqtSignal()
# Slots
@pyqtSlot()
def connect_server(self):
"""
"""
self.statusBar.clearMessage()
host = self.serverLine.text().trimmed()
port = self.portLine.text().trimmed()
if host and port:
self.socket.connectToHost(host, int(port))
else:
self.statusBar.showMessage(
'Enter valid a server address and port!')
@pyqtSlot()
def on_success(self):
"""
"""
if self.socket.waitForReadyRead(10000):
msg = self.socket.readData(1024)
msg = loads(msg)
if msg['head'] == CONN_SUCC:
self.statusBar.showMessage('Connection established')
self.conn_success.emit(self.socket)
self.hide()
else:
self.statusBar.showMessage('Server is full!')
self.socket.disconnectFromHost()
else:
self.on_error()
@pyqtSlot()
def on_error(self):
self.statusBar.showMessage('Connection cannot be established!')
def closeEvent(self, event):
"""
"""
dialog = ExitDialog()
if dialog.exec_():
event.accept()
else:
event.ignore()
# Connections
def connect(self):
"""
"""
self.connectButton.clicked.connect(self.connect_server)
self.exitButton.clicked.connect(self.close)
self.socket.error.connect(self.on_error)
self.socket.connected.connect(self.on_success)
class QiVisClient(QtCore.QObject):
def __init__(self, name, server, serverPort, x, y, width, height):
"""__init__() -> None
initializes the client class"""
QtCore.QObject.__init__(self)
self.timer = QtCore.QTimer(self)
self.timer.setSingleShot(True)
self.timer.setInterval(1000)
self.timer.start()
self.socket = QTcpSocket()
self.current_pipeline = None
self.current_config_function = None
self.server = server # os.environ.get( 'DV3D_HW_SERVER_NAME', server )
self.serverPort = int(serverPort)
self.buffer = ""
self.pipelineQueue = []
current_pipeline = None
self.deviceName = name
self.currentTab = None
self.mainWindow = None
print " Init VisClient, server=%s, serverPort=%s, name=%s " % (str(
self.server), str(self.serverPort), str(name))
self.spreadsheetWindow = spreadsheetController.findSpreadsheetWindow(
False)
self.spreadsheetWindow.setWindowFlags(
self.spreadsheetWindow.windowFlags()
| QtCore.Qt.WindowStaysOnTopHint | QtCore.Qt.Window)
# self.spreadsheetWindow.setWindowFlags( self.spreadsheetWindow.windowFlags() | QtCore.Qt.Window )
self.spreadsheetWindow.activateWindow()
self.spreadsheetWindow.showMaximized()
self.dimensions = (x, y, width, height)
self.connectSignals()
def createTab(self, displayWidth, displayHeight, fullScreenEnabled):
self.spreadsheetWindow.addTabController('DV3D')
tabController = self.spreadsheetWindow.get_current_tab_controller()
tabController.clearTabs()
self.currentTab = DisplayWallSheetTab(tabController,
self.dimensions[0],
self.dimensions[1],
self.dimensions[2],
self.dimensions[3], displayWidth,
displayHeight, fullScreenEnabled)
tabController.addTabWidget(self.currentTab, self.deviceName)
tabController.setCurrentWidget(self.currentTab)
self.size = self.currentTab.getDimension()
print " Startup VisClient, size=%s, dims=%s, fullScreen=%s " % (str(
self.size), str(self.dimensions), str(fullScreenEnabled))
def updateCurrentTab(self):
if self.currentTab == None:
tabController = self.spreadsheetWindow.get_current_tab_controller()
# self.currentTab = tabController.tabWidgets[1]
self.currentTab = tabController.widget(1)
if self.currentTab:
self.dims = self.currentTab.getDimension()
print " UpdateCurrentTab: ntabs=%d, dims=%s " % (len(
tabController.tabWidgets), str(self.dims))
return True
return False
def connectSignals(self):
"""connectSignals() -> None
Connects all relevant signals to this class"""
self.connect(self.socket, QtCore.SIGNAL("connected()"), self.connected)
self.connect(self.socket, QtCore.SIGNAL("disconnected()"),
self.disconnected)
self.connect(self.socket, QtCore.SIGNAL("readyRead()"),
self.readDataFromSocket)
self.connect(self.timer, QtCore.SIGNAL("timeout()"),
self.retryConnection)
self.connect(self, QtCore.SIGNAL("executeNextPipeline()"),
self.executeNextPipeline)
def retryConnection(self):
"""retryConnection() -> None
this method is called once everytime self.timer ticks. It
tries to connect to the server again"""
print "retryConnection"
sys.stdout.flush()
if self.socket.state() != QTcpSocket.ConnectedState:
if self.socket.state() == QTcpSocket.UnconnectedState:
port = int(self.serverPort)
print " HWClient connecting to server at %s:%d" % (self.server,
port)
self.socket.connectToHost(self.server, port)
self.timer.start()
elif core.system.systemType in ['Windows', 'Microsoft']:
self.socket.setSocketOption(QAbstractSocket.LowDelayOption, 1)
def connected(self):
"""connected() -> None
this method is called when self.socket emits the connected() signal. It means that a succesful connection
has been established to the server"""
sender = "displayClient"
receiver = "server"
tokens = MessageTokenSep.join([
"dimensions", self.deviceName,
str(self.dimensions[0]),
str(self.dimensions[1]),
str(self.dimensions[2]),
str(self.dimensions[3])
])
reply = sender + "-" + receiver + "-" + str(len(tokens)) + ":" + tokens
print " ****** Connected to server! CellCoords = ( %d, %d ), reply: %s " % (
self.dimensions[0], self.dimensions[1], reply)
self.socket.write(reply)
def disconnected(self):
"""disconnected() -> None
this method is called when self.socket emits disconnected(). It means that the socket is no longer connected to the server"""
print "Disconnected from server"
self.timer.start()
def readDataFromSocket(self):
"""readDataFromSocket() -> None
This method is called everytime the socket sends the readyRead() signal"""
incoming = str(self.socket.readAll().data())
while incoming != "":
self.buffer += incoming
while self.buffer != "":
tokens = self.buffer.split(":")
header = tokens[0]
rest = ""
for piece in tokens[1:]:
rest += piece + ":"
rest = rest[:-1]
info = header.split("-")
if len(info) < 3:
break
(sender, receiver, size) = (info[0], info[1], info[2])
if int(size) > len(rest):
break
tokens = rest[:int(size)]
self.buffer = rest[int(size):]
# print " ********* CLIENT--> gotMessage: %s %s %s ********* " % ( str( receiver ), str( sender ), str( tokens ) )
sys.stdout.flush()
if (receiver == "displayClient"):
reply = self.processMessage((sender, tokens), self.socket)
if reply != ("", "", ""):
reply = reply[0] + "-" + reply[1] + "-" + str(
len(reply[2])) + ":" + reply[2]
self.socket.write(reply)
incoming = str(self.socket.readAll().data())
def processCommand(self, terms):
print " -- processCommand: %s " % str(terms)
if terms[0] == "reltimestep":
relTimeValue = float(terms[1])
relTimeIndex = float(terms[2])
useTimeIndex = bool(terms[3])
displayText = terms[4]
if self.current_pipeline:
for module in self.current_pipeline.module_list:
persistentCellModule = ModuleStore.getModule(module.id)
if persistentCellModule:
persistentCellModule.updateAnimation(
[relTimeValue, relTimeIndex, useTimeIndex],
displayText)
elif terms[0] == "pipelineHelper":
if self.current_config_function:
if self.current_config_function.type == 'leveling':
range = list(self.current_config_function.range)
cmd_args = terms[1].split('-')
iRangeArg = int(cmd_args[1])
range[iRangeArg] = float(terms[2])
# print " --- PipelineHelper: set range = ", str( range )
self.current_config_function.broadcastLevelingData(range)
else:
pass
# print " --- PipelineHelper, config type: ", self.current_config_function.type
else:
if self.current_pipeline:
for module in self.current_pipeline.module_list:
persistentCellModule = ModuleStore.getModule(module.id)
if persistentCellModule:
persistentCellModule.updateConfigurationObserver(
terms[0], terms[1:])
# if terms[0] == 'colormap':
# cmapData = terms[1]
# displayText = terms[2]
# for module in self.current_pipeline.module_list:
# persistentCellModule = ModuleStore.getModule( module.id )
# persistentCellModule.setColormap( cmapData )
# persistentCellModule.updateTextDisplay( displayText )
def processEvent(self, terms):
"""processEvent(message: String) -> None
decodifies the event received by the server and posts it to QT's event handler. In order
to do this, we must send three events: the first one disables this client's method that
would send events to the server. The second is the actual event we want processed and the third
reenables event sending to the server. This must be done to avoid a deadlock"""
def decodeMouseEvent(event, screenDims):
"""decodeMouseEvent(event: String) -> QtGui.QMouseEvent
this method receives a string and returns the corresponding mouse event"""
pos = (int(float(event[2]) * screenDims[0]),
int(float(event[3]) * screenDims[1]))
if event[1] == "left":
button = QtCore.Qt.LeftButton
elif event[1] == "right":
button = QtCore.Qt.RightButton
if event[0] == "singleClick":
t = QtCore.QEvent.MouseButtonPress
elif event[0] == "mouseMove":
t = QtCore.QEvent.MouseMove
button = QtCore.Qt.NoButton
elif event[0] == "mouseRelease":
t = QtCore.QEvent.MouseButtonRelease
button = QtCore.Qt.MouseButton(button)
m = QtCore.Qt.NoModifier
if event[4] == "shift":
m = QtCore.Qt.ShiftModifier
elif event[4] == "ctrl":
m = QtCore.Qt.ControlModifier
elif event[4] == "alt":
m = QtCore.Qt.AltModifier
# print " Client process %s %s event: pos = %s, screenDims=%s " % ( button, event[0], str( pos ), str( screenDims ) )
return QtGui.QMouseEvent(t, QtCore.QPoint(pos[0], pos[1]), button,
button, m)
def decodeKeyEvent(event):
"""decodeKeyEvent(event: String) -> QtGui.QKeyEvent
this method receives a string and returns the corresponding Key event"""
type = None
if event[0] == "keyPress":
type = QtCore.QEvent.KeyPress
elif event[0] == "keyRelease":
type = QtCore.QEvent.KeyRelease
key = int(event[1])
m = QtCore.Qt.NoModifier
if event[2] == "shift":
m = QtCore.Qt.ShiftModifier
elif event[2] == "ctrl":
m = QtCore.Qt.ControlModifier
elif event[2] == "alt":
m = QtCore.Qt.AltModifier
# print " Client process key event: %s " % str( event )
return QtGui.QKeyEvent(type, key, QtCore.Qt.KeyboardModifiers(m))
app = QtCore.QCoreApplication.instance()
newTab = self.updateCurrentTab()
widget = self.currentTab.getCellWidget(0,
0) if self.currentTab else None
# print " ------------- QiVisClient.processEvent: %s ---------------------" % ( str(terms) )
sys.stdout.flush()
if terms[2] == "interactionState":
if self.current_pipeline:
state = terms[3] if (len(terms) > 3) else None
altMode = terms[4] if (len(terms) > 4) else None
print " ~~~~~ Setting Client Interaction State: ", str(
state), str(altMode)
sys.stdout.flush()
for module in self.current_pipeline.module_list:
persistentModule = ModuleStore.getModule(module.id)
if persistentModule:
cf = persistentModule.updateInteractionState(
state, altMode)
if cf: self.current_config_function = cf
else:
print "Can't find client persistentModule: ", module.id
else:
newEvent = None
if terms[2] == "singleClick":
cellModules = self.getCellModules()
cpos = [float(terms[i]) for i in range(7, 10)]
cfol = [float(terms[i]) for i in range(10, 13)]
cup = [float(terms[i]) for i in range(13, 16)]
# print " >>> QiVisClient.cellModules: %s, modules: %s" % ( str( [ cellMod.id for cellMod in cellModules ] ), str( ModuleStore.getModuleIDs() ) )
for cellMod in cellModules:
persistentCellModule = ModuleStore.getModule(cellMod.id)
if persistentCellModule:
persistentCellModule.syncCamera(cpos, cfol, cup)
if terms[2] in ["singleClick", "mouseMove", "mouseRelease"]:
if self.currentTab:
screenRect = self.currentTab.getCellRect(0, 0)
screenDims = (screenRect.width(), screenRect.height())
newEvent = decodeMouseEvent(terms[2:], screenDims)
elif terms[2] in ["keyPress", "keyRelease"]:
newEvent = decodeKeyEvent(terms[2:])
if widget and newEvent:
cellWidget = widget.widget()
app.postEvent(cellWidget, newEvent)
cellWidget.setFocus()
cellWidget.update()
def executeNextPipeline(self):
if len(self.pipelineQueue) == 0:
return
pipeline = self.pipelineQueue[-1]
self.pipelineQueue.pop()
self.executePipeline(pipeline)
self.emit(QtCore.SIGNAL("executeNextPipeline()"))
def getCellModules(self):
cellModules = []
if self.current_pipeline:
for module in self.current_pipeline.module_list:
if (module.name == "MapCell3D"): cellModules.append(module)
return cellModules
def getCurrentPipeline(self):
return self.current_pipeline
def setCellLocation(self):
cellModule = None
if self.current_pipeline:
print " Executing Client Workflow, modules: "
for module in self.current_pipeline.module_list:
print str(module)
# if : cellModule = module
def executePipeline(self, pipeline):
from core.db.io import unserialize
from core.vistrail.pipeline import Pipeline
from core.interpreter.default import get_default_interpreter as getDefaultInterpreter
from core.utils import DummyView
import api
tabController = self.spreadsheetWindow.get_current_tab_controller()
pip = unserialize(str(pipeline), Pipeline)
# print " **** Client-%s ---Received Pipeline--- modules:" % str( self.dimensions )
# for module in pip.module_list:
# print " ", str(module.id)
self.current_pipeline = pip
interpreter = getDefaultInterpreter()
kwargs = {
"locator": None,
"current_version": None,
"view": DummyView(),
"aliases": {}
}
interpreter.execute(pip, **kwargs)
print "Finished Executing Pipeline"
def processMessage(self, message, socket):
(sender, tokens) = message
# print " ********* CLIENT--> processMessage: %s ********* " % str( tokens )
tokens = tokens.split(MessageTokenSep)
if (len(tokens) < 4) or (tokens[3] <> 'mouseMove'):
print " ********* CLIENT--> splitMessage: %s ********* " % str(
tokens)
if len(tokens) == 0: return
if tokens[0] == "exit":
print "Received shutdown message"
sys.stdout.flush()
socket.close()
gui.application.get_vistrails_application().quit()
gui.application.stop_application()
sys.exit(0)
if tokens[0] == "pipeline":
# print " $$$$$$$$$$$ Client-- pipeline message: %s " % str(tokens)
### we must execute a pipeline
# return ("", "", "")
if len(tokens[2:]) != 0:
for t in tokens[2:]:
tokens[1] += t + "@"
tokens[1] = tokens[1][:-1]
self.executePipeline(tokens[1])
elif tokens[0] == "interaction":
self.processEvent(tokens[1:])
elif tokens[0] == "command":
self.processCommand(tokens[3:])
elif tokens[0] == "refresh":
self.updateCurrentTab()
if self.currentTab:
widget = self.currentTab.getCell(int(tokens[1]),
int(tokens[2]))
# if widget:
# widget.swapBuffers()
return ("", "", "")
def process_request(self):
socket = self.sender()
request_data = socket.readAll()
if not self.authorize_request(request_data):
socket.write('HTTP/1.1 407 Proxy Authentication Required\r\n')
if self.debug:
self.log.write('407 Proxy Authentication Required\n\n')
socket.write('Proxy-Authenticate: Basic realm="test"\r\n')
socket.write('\r\n')
socket.disconnectFromHost()
return
else:
# remove Proxy-Authorization header
start = request_data.indexOf('Proxy-Authorization:')
end = request_data.lastIndexOf('\r\n')
request_data.remove(start, end)
request_data.append('\r\n')
pos = request_data.indexOf('\r\n')
request_line = request_data.left(pos)
request_data.remove(0, pos + 2)
entries = request_line.split(' ')
method = entries[0]
address = entries[1]
version = entries[2]
port = '80'
if address.count(':') > 1:
protocol, host, port = address.split(':')
else:
protocol, host = address.split(':')
print 'address', address
#url = QUrl( protocol + host )
url = QUrl.fromEncoded(address)
#url.setHost( host )
#url.setPort( int(port) )
if not url.isValid():
if self.debug:
self.log.write('Invalid URL: %s\n\n', url)
socket.disconnectFromHost()
return
host = url.host()
port = 80 if (url.port() < 0) else url.port()
req = url.encodedPath()
if url.hasQuery():
req.append('?').append(url.encodedQuery())
request_line = method + ' ' + req + ' ' + version + '\r\n'
request_data.prepend(request_line)
if self.debug:
self.log.write(method + ' ' + address + ' ' + version + '\n\n')
key = host + ':' + QString.number(port)
proxy_socket = socket.findChild(QTcpSocket, key)
if proxy_socket:
proxy_socket.setObjectName(key)
proxy_socket.setProperty('url', url)
proxy_socket.setProperty('request_data', request_data)
proxy_socket.write(request_data)
else:
proxy_socket = QTcpSocket(socket)
proxy_socket.setObjectName(key)
proxy_socket.setProperty('url', url)
proxy_socket.setProperty('request_data', request_data)
proxy_socket.connected.connect(self.send_request)
proxy_socket.readyRead.connect(self.transfer_data)
proxy_socket.disconnected.connect(self.close_connection)
proxy_socket.error.connect(self.close_connection)
proxy_socket.connectToHost(host, port)
class TcpDevice(DataDevice):
'''
classdocs
'''
def __init__(self, params={}, parent=None):
'''
Constructor
'''
super(TcpDevice, self).__init__(params, parent)
self.iodevice = QTcpSocket()
self.reconnect = int(params.get('Reconnect', 1000))
self.host = params.get('Host', None)
self.port = int(params.get('Port', 2000))
self.gpsdInit = bool(params.get('GpsdInit', False))
self.iodevice.readyRead.connect(self.readyRead)
self.iodevice.error.connect(self.socketError)
self.iodevice.connected.connect(self.socketConnected)
self.iodevice.disconnected.connect(self.socketDisconnected)
@pyqtSlot(QAbstractSocket.SocketError)
def socketError(self, error):
if self.iodevice.state() != QAbstractSocket.BoundState:
if self.reconnect > 0:
QTimer.singleShot(self.reconnect, self.onReconnectTimer)
def connectDevice(self):
self.iodevice.connectToHost(self.host, self.port)
def disconnectDevice(self):
if self.iodevice.state() is QAbstractSocket.ConnectedState:
self.iodevice.disconnectFromHost()
def readData(self):
size = self.iodevice.bytesAvailable()
data = self.iodevice.read(size)
return data
def readLine(self):
if self.iodevice.canReadLine():
return str(self.iodevice.readLine())
return ''
@pyqtSlot()
def socketConnected(self):
self.deviceConnected.emit(True)
if self.gpsdInit:
self.iodevice.writeData('?WATCH={"class":"WATCH","nmea":true}')
@pyqtSlot()
def socketDisconnected(self):
self.deviceDisconnected.emit(True)
def isConnected(url):
socket = QTcpSocket()
socket.connectToHost(url, 80)
return socket.waitForConnected(1000)
class TcpClient(QObject):
packet = pyqtSignal(str)
connected = pyqtSignal()
disconnected = pyqtSignal()
def __init__(self, host):
super().__init__()
self._sock = QTcpSocket()
self._pending = None
self._host = host
self._log = logging.getLogger('tcp')
self._sock.connected.connect(self.greet)
self._sock.connected.connect(self.connected.emit)
self._sock.disconnected.connect(self.disconnected.emit)
self._sock.readyRead.connect(self.recv)
def set_host(self, host):
self._sock.disconnectFromHost()
self._host = host
def _cancel_pending(self):
self._pending.stop()
self._pending = None
self._sock.connected.disconnect(self._connection_success)
@pyqtSlot()
def _connection_success(self):
self._cancel_pending()
self._log.debug('connection successful')
@pyqtSlot()
def _connection_failure(self):
self._cancel_pending()
self._log.debug('connection failed')
def try_connect(self, port):
if self._pending:
self._cancel_pending()
self._sock.disconnectFromHost()
if self._sock.state() != QAbstractSocket.UnconnectedState:
self._sock.waitForDisconnected()
msg = 'connecting to ({}:{})'
msg = msg.format(self._host.toString(), port)
self._log.debug(msg)
self._pending = QTimer()
self._pending.timeout.connect(self._connection_failure)
self._pending.setSingleShot(True)
self._sock.connected.connect(self._connection_success)
self._pending.start(10000)
self._sock.connectToHost(self._host, port)
def greet(self):
self.send(query_tag('port', 'udp'), '')
def recv(self):
while self._sock.canReadLine():
data = bytes(self._sock.readLine()) # handle QByteArray
message = data.decode()
self.packet.emit(message)
def send(self, tag, payload):
message = tag + ':' + payload + '\n'
data = message.encode()
self._sock.write(data)
class ClientDialog(QtGui.QDialog):
STATUS = ["Not Connected",
"Host Lookup",
"Establishing connection",
"Connected",
"The socket is bound to an address and port",
"For internal use only",
"Socket is about to close"]
def __init__(self, configdir, recentconndb):
QtGui.QDialog.__init__(self)
# Variables
self.configdir = configdir
self.recentconndb = recentconndb
self.socket = QTcpSocket()
self.status = self.STATUS[0]
logging.info("Starting Client")
# Properties
self.setModal(True)
# Setup Widget
self.layout = QtGui.QVBoxLayout()
self.mainWidget = ControllerClientWidget()
self.layout.addWidget(self.mainWidget)
self.setLayout(self.layout)
#Connections
self.connect(self.socket, QtCore.SIGNAL('error(QAbstractSocket::SocketError)'), self.displayError)
self.connect(self.socket, QtCore.SIGNAL('connected()'), self.connected)
self.connect(self.mainWidget.connectButton, QtCore.SIGNAL('pressed()'), self.connectToServer)
self.connect(self.mainWidget.hostEdit, QtCore.SIGNAL('textChanged(QString)'), self.enableConnectButton)
self.connect(self.mainWidget.portEdit, QtCore.SIGNAL('textChanged(QString)'), self.enableConnectButton)
self.connect(self.mainWidget.passEdit, QtCore.SIGNAL('textChanged(QString)'), self.enableConnectButton)
self.connect(self.mainWidget.recentConnList, QtCore.SIGNAL('doubleClicked(const QModelIndex &)'), self.recentListHandler)
self.loadRecentConnDB()
self.enableConnectButton()
self.hide()
# Translations
self.current_language = "en_US"
self.uiTranslator = QtCore.QTranslator()
self.uiTranslator.load(":/languages/tr_en_US.qm")
self.retranslate()
self.updateStatus()
###
### Translation Related
###
def retranslate(self, language=None):
if language is not None:
self.current_language = language
self.uiTranslator.load(":/languages/tr_%s.qm" % self.current_language)
self.setWindowTitle(self.uiTranslator.translate("ControllerClientApp", "Controller Client"))
#
# Reusable Strings
#
self.clientStatusString = self.uiTranslator.translate("ControllerClientApp", "Status")
self.connectString = self.uiTranslator.translate("ControllerClientApp", "Connect")
self.disconnectString = self.uiTranslator.translate("ControllerClientApp", "Disconnect")
# --- End Reusable Strings
#
# Connection Settings
#
self.mainWidget.toolBox.setItemText(0, self.uiTranslator.translate("ControllerClientApp", "Connection Settings"))
self.mainWidget.hostLabel.setText(self.uiTranslator.translate("ControllerClientApp", "Host name (or IP Address)"))
self.mainWidget.portLabel.setText(self.uiTranslator.translate("ControllerClientApp", "Port"))
self.mainWidget.passLabel.setText(self.uiTranslator.translate("ControllerClientApp", "Passphrase"))
if self.status == self.STATUS[3]:
self.mainWidget.connectButton.setText(self.uiTranslator.translate("ControllerClientApp", self.disconnectString))
else:
self.mainWidget.connectButton.setText(self.uiTranslator.translate("ControllerClientApp", self.connectString))
self.updateStatus()
# --- End Connection Settings
#
# Recent Connections
#
self.mainWidget.toolBox.setItemText(1, self.uiTranslator.translate("ControllerClientApp", "Recent Connections"))
# --- End Recent Connections
##
## UI Related
##
def enableConnectButton(self):
if self.mainWidget.passEdit.text() == '' or self.mainWidget.hostEdit.text() == '' or self.mainWidget.portEdit.text() == '':
self.mainWidget.connectButton.setEnabled(False)
else:
self.mainWidget.connectButton.setEnabled(True)
def connected(self):
caddr = self.socket.peerName()
cport = self.socket.peerPort()
logging.info("Connected to %s:%s" % (caddr, cport))
self.sendPassphrase()
self.mainWidget.connectButton.setText(self.disconnectString)
self.disconnect(self.mainWidget.connectButton, QtCore.SIGNAL('pressed()'), self.connectToServer)
self.disconnect(self.mainWidget.passEdit, QtCore.SIGNAL('textChanged(QString)'), self.enableConnectButton)
self.connect(self.mainWidget.connectButton, QtCore.SIGNAL('pressed()'), self.disconnectFromHost)
self.connect(self.socket, QtCore.SIGNAL("disconnected()"), self.disconnectedFromHost)
'''
This function is for updating the sockets status and the statusLabel. It's called when a stateChanged signal is triggered.
'''
def updateStatus(self):
state = self.socket.state()
self.status = self.STATUS[state]
self.mainWidget.statusLabel.setText(self.clientStatusString + ": " + self.status)
'''
When there is a socket error this function is called to show the error in a QMessageBox
'''
def displayError(self, socketError):
messageBox = QtGui.QMessageBox.critical(self, QtCore.QString('Error!'),
QtCore.QString(self.socket.errorString()))
logging.error("Socket error %s" % self.socket.errorString())
##
## Connection Related
##
'''
Function that is called when connect button is pressed.
'''
def connectToServer(self):
caddr = self.mainWidget.hostEdit.text()
cport = int(self.mainWidget.portEdit.text())
cpass = self.mainWidget.passEdit.text()
self.connect(self.socket, QtCore.SIGNAL('stateChanged(QAbstractSocket::SocketState)'), self.updateStatus)
logging.info("Connecting to %s:%s" % (caddr, cport))
self.socket.connectToHost(caddr, cport)
if not self.socket.waitForConnected(1000):
logging.error("Socket error %s", self.socket.errorString())
else:
# Add to recent connections if connection is successful
self.addToRecentConnections(caddr, cport, cpass)
def disconnectFromHost(self):
self.socket.disconnectFromHost()
'''
Function for disconnecting the client from the host.
'''
def disconnectedFromHost(self):
logging.info("Disconnected from host")
self.disconnect(self.mainWidget.connectButton, QtCore.SIGNAL('pressed()'), self.disconnectFromHost)
self.connect(self.mainWidget.connectButton, QtCore.SIGNAL('pressed()'), self.connectToServer)
self.connect(self.mainWidget.passEdit, QtCore.SIGNAL('textChanged(QString)'), self.enableConnectButton)
self.mainWidget.connectButton.setText(self.connectString)
'''
Function for sending message to the connected server
'''
def sendMessage(self, message):
logging.info("Sending message: %s", message)
block = QtCore.QByteArray()
block.append(message)
self.socket.write(block)
'''
This function is for sending the passphrase to the server. It uses the sendMessage function
'''
def sendPassphrase(self):
self.sendMessage(self.mainWidget.passEdit.text())
'''
This function is for reading message from the server
'''
def readMessage(self):
message = self.socket.read(self.socket.bytesAvailable())
logging("Server said:%s", message)
return message
##
## Recent Connections Related
##
def loadRecentConnDB(self):
model = self.recentconndb.get_recentconn_model()
self.mainWidget.recentConnList.setModel(model)
self.mainWidget.recentConnList.setColumnHidden(2, True) # Hide the passphrase column
'''
This function is for adding a new connection to the recent connections. It checks whether it exists in the database or not.
'''
def addToRecentConnections(self, caddr, cport, cpass):
self.recentconndb.insert_recentconn(caddr, cport, cpass)
self.loadRecentConnDB()
'''
Handler for the recent connections list. When you click on a recent connection the details of the connection are loaded
'''
def recentListHandler(self, connection):
chost = connection.sibling(connection.row(), 0).data().toString()
cport = int(connection.sibling(connection.row(), 1).data().toString())
cpass = connection.sibling(connection.row(), 2).data().toString()
self.mainWidget.hostEdit.setText(chost)
self.mainWidget.portEdit.setValue(cport)
self.mainWidget.passEdit.setText(cpass)
self.mainWidget.toolBox.setCurrentWidget(self.mainWidget.connWidget)
class App(QtGui.QWidget):
value = 0
start = 0
def getvals(self, text):
global text1
global text2
query = QtSql.QSqlQuery()
query.exec_("SELECT name,credenzID,college FROM reg_table")
while query.next():
name = query.value(0).toString()
creid = query.value(1).toString()
coll = query.value(2).toString()
if creid == text:
text1 = name
text2 = creid
return 1
return 0
def addToDatabase(self):
global speed
global tempfloat
global text1
global text2
global tempatt
global accuracy
accuracy = int(tempfloat)
query2 = QtSql.QSqlQuery()
query2.exec_("SELECT name,credenzID,wpm,accuracy,attempts FROM newdb")
tempatt = 0
tempwpm = 0
tempaccuracy = 0
while query2.next():
if query2.value(1) == text2:
tempwpm = int(query2.value(2).toString())
tempaccuracy = int(query2.value(3).toString())
tempatt = int(query2.value(4).toString())
if tempwpm > speed:
speed = tempwpm
accuracy = tempaccuracy
break
tempatt += 1
query = QtSql.QSqlQuery()
query.exec_("SELECT name,credenzID,wpm,accuracy,attempts FROM newdb")
self.issueRequest(
QString(
str(1009) + "..." + text1 + "." + text2 + "." + str(speed) +
"." + str(accuracy) + "." + str(tempatt)))
def calldialog(self):
text, ok = QtGui.QInputDialog.getText(self, 'Welcome',
'Enter your credenz ID')
if ok:
if (self.getvals(text)):
global PORT
query4 = QtSql.QSqlQuery()
query4.prepare("SELECT attempts FROM newdb WHERE credenzID=?")
query4.addBindValue(text)
query4.exec_()
query4.next()
tempstr = query4.value(0).toString()
if tempstr:
if int(tempstr) > 999:
msg = QtGui.QMessageBox()
msg.setText(
"You Have completed maximum number of tries")
msg.exec_()
sys.exit()
global flag
if flag == 0:
self.initUI()
flag = 1
self.restart.setVisible(False)
self.qle.setVisible(True)
self.start = 0
portstr, ok = QtGui.QInputDialog.getText(
self, 'Welcome', 'Enter port for connection')
PORT = int(portstr)
else:
msg = QtGui.QMessageBox()
msg.setText("You are not registered")
msg.exec_()
self.calldialog()
else:
exit(0)
def __init__(self):
super(App, self).__init__()
global db
db = QtSql.QSqlDatabase.addDatabase("QSQLITE")
db.setDatabaseName("SwiftTyper")
ok = db.open()
if ok:
self.calldialog()
def resizeEvent(self, event):
# 1366 * 768
myh = self.mywin.height()
myw = self.mywin.width()
self.lbl.setGeometry(
QtCore.QRect((myw * 70 / 1366), (myh * 50 / 768),
(myw * 800 / 1366), (myh * 450 / 768)))
self.qle.setGeometry(
QtCore.QRect((myw * 70 / 1366), (myh * 550 / 768),
(myw * 800 / 1366), (myh * 100 / 768)))
self.exitlbl.setGeometry(
QtCore.QRect((myw * 900 / 1366), (myh * 550 / 768),
(myw * 345 / 1366), (myh * 100 / 768)))
self.lcdtimer.setGeometry(
QtCore.QRect((myw * 900 / 1366), (myh * 100 / 768),
(myw * 250 / 1366), (myh * 120 / 768)))
self.lcdwpm.setGeometry(
QtCore.QRect((myw * 1000 / 1366), (myh * 240 / 768),
(myw * 250 / 1366), (myh * 120 / 768)))
self.lcdaccuracy.setGeometry(
QtCore.QRect((myw * 1000 / 1366), (myh * 380 / 768),
(myw * 250 / 1366), (myh * 120 / 768)))
self.wpmlbl.setGeometry(
QtCore.QRect((myw * 900 / 1366), (myh * 240 / 768),
(myw * 100 / 1366), (myh * 120 / 768)))
self.accuracylbl.setGeometry(
QtCore.QRect((myw * 900 / 1366), (myh * 380 / 768),
(myw * 100 / 1366), (myh * 120 / 768)))
self.restart.setGeometry(
QtCore.QRect((myw * 70 / 1366), (myh * 550 / 768),
(myw * 800 / 1366), (myh * 100 / 768)))
self.progbar.setGeometry(
QtCore.QRect((myw * 70 / 1366), (myh * 670 / 768),
(myw * 1200 / 1366), (myh * 50 / 768)))
def restartf(self):
global userInputWord
global positionOfCurrentWord
global endOfCurrentWord
global currentWordFromPara
global paragraph
global paralen
global words
global numberOfReds
global numberOfChars
global totalChars
global paralen
global flag2
self.value = 0
self.value2 = -2
self.timer3.stop()
userInputWord = ""
positionOfCurrentWord = 0
endOfCurrentWord = 0
currentWordFromPara = ""
self.calldialog()
paralen = len(paragraph.split(" "))
self.start = 0
flag2 = 1
self.timer.start(100)
words = 0
numberOfReds = 0
numberOfChars = 1
totalChars = len(paragraph)
global paratextsize
self.lbl.setStyleSheet(
_fromUtf8("background-color: rgb(201, 183, 255); color: #4C3327;"))
self.lbl.setText("<font size=\"" + str(paratextsize) + "\">" +
paragraph + "</font>")
def count3(self):
self.issueRequest(
QString(
str(1009) + "..." + text1 + "." + text2 + "." + str(speed) +
"." + str(accuracy) + "." + str(tempatt)))
def count(self):
global tempfloat
global speed
global flag2
global words
global paralen
global text1
global text2
global accuracy
global tempatt
if flag2 == 0:
self.value = self.value + 1
if self.value % 10 == 0:
self.lcdtimer.display(
(((self.value / 600) * 1000) + (self.value % 600)) / 10)
self.lcdwpm.display(600 * words / self.value)
speed = 600 * words / self.value
tempfloat = 100 * (numberOfChars - numberOfReds) / numberOfChars
self.progbar.setValue((100 * words) / paralen)
if self.value % 10 == 0:
self.issueRequest(QString(str(600 * words / self.value)))
elif flag2 == 2: # flag2==2: means para typed
if self.value % 10 == 0:
self.issueRequest(
QString(
str(1009) + "..." + text1 + "." + text2 + "." +
str(speed) + "." + str(accuracy) + "." + str(tempatt)))
else: # flag2==1: send fetch_para signal to server
if self.value % 10 == 0:
self.issueRequest(QString(str(1000)))
self.start = 0
def count2(self):
self.value2 += 1
self.lcdtimer.display(self.value2)
if self.value2 == 0:
self.qle.setReadOnly(False)
self.qle.setFocus()
if self.value2 == 1:
self.timer2.stop()
self.timer.start(100)
def initUI(self):
self.socket = QTcpSocket()
self.connect(self.socket, SIGNAL("connected()"), self.sendRequest)
self.connect(self.socket, SIGNAL("readyRead()"), self.readResponse)
self.connect(self.socket, SIGNAL("disconnected()"),
self.serverHasStopped)
self.connect(self.socket,
SIGNAL("error(QAbstractSocket::SocketError)"),
self.serverHasError)
self.mywin = self.window()
self.value = 0
self.value2 = -2
self.lcdtimer = QtGui.QLCDNumber(self)
self.lcdtimer.setGeometry(QtCore.QRect(700, 120, 250, 120))
self.lcdtimer.setStyleSheet(
_fromUtf8("background-color: rgb(201, 183, 255);"
"color: #F1ECDD;"))
self.lcdtimer.display(self.value2)
self.timer = QtCore.QTimer()
self.timer2 = QtCore.QTimer()
self.timer3 = QtCore.QTimer()
self.lcdwpm = QtGui.QLCDNumber(self)
self.lcdwpm.setGeometry(QtCore.QRect(700, 260, 250, 120))
self.lcdwpm.setStyleSheet(
_fromUtf8("background-color: rgb(201, 183, 255);"
"color: #F1ECDD;"))
self.progbar = QtGui.QProgressBar(self)
self.progbar.setGeometry(70, 670, 1000, 100)
self.progbar.setValue(0)
self.lcdaccuracy = QtGui.QLCDNumber(self)
self.lcdaccuracy.setGeometry(QtCore.QRect(700, 400, 250, 120))
self.lcdaccuracy.setStyleSheet(
_fromUtf8("background-color: rgb(201, 183, 255);"
"color: #F1ECDD;"))
QtCore.QObject.connect(self.timer, QtCore.SIGNAL("timeout()"),
self.count)
QtCore.QObject.connect(self.timer2, QtCore.SIGNAL("timeout()"),
self.count2)
QtCore.QObject.connect(self.timer3, QtCore.SIGNAL("timeout()"),
self.count3)
self.lcdtimer.display(self.value)
self.lbl = QtGui.QTextBrowser(self)
self.exitlbl = QtGui.QLabel(self)
self.exitlbl.setGeometry(QtCore.QRect(70, 365, 700, 100))
self.exitlbl.setVisible(False)
self.restart = QtGui.QPushButton(self)
self.restart.setGeometry(QtCore.QRect(100, 550, 724, 100))
self.restart.setText("Restart")
self.restart.setVisible(False)
self.restart.setStyleSheet(
_fromUtf8("font: 24pt \"mry_KacstQurn\";\n"
"background-color: rgb(255, 255, 255);"))
self.restart.clicked.connect(self.restartf)
self.lbl.setGeometry(QtCore.QRect(70, 50, 724, 300))
self.lbl.setObjectName(_fromUtf8("lbl"))
self.lbl.setStyleSheet(
_fromUtf8("background-color: rgb(201, 183, 255); color: #4C3327;"))
self.qle = QtGui.QLineEdit(self)
self.qle.setGeometry(QtCore.QRect(70, 500, 724, 100))
self.qle.setStyleSheet(
_fromUtf8("font: 24pt \"mry_KacstQurn\";\n"
"color: #25343B;"
"background-color: rgb(201, 183, 255);"))
self.qle.textChanged[str].connect(self.onChanged)
self.qle.setReadOnly(True)
self.wpmlbl = QtGui.QLabel(self)
self.wpmlbl.setGeometry(QtCore.QRect(1155, 260, 100, 120))
self.wpmlbl.setText("<font size=\"20\"> WPM</font>")
self.wpmlbl.setStyleSheet(
_fromUtf8("background-color: rgb(201, 183, 255);"
"color: #F1ECDD;"))
self.accuracylbl = QtGui.QLabel(self)
self.accuracylbl.setGeometry(QtCore.QRect(1155, 400, 120, 120))
self.accuracylbl.setText("<font size=\"28\">Rank</font>")
self.accuracylbl.setStyleSheet(
_fromUtf8("background-color: rgb(201, 183, 255);"
"color: #F1ECDD;"))
self.setGeometry(10, 10, 1365, 758)
self.setStyleSheet(
_fromUtf8("background-color: #4C3327;"
"background-image: url(img3.jpg);"
"color: #4C3327;"))
self.setWindowTitle('SwiftTyper')
self.show()
self.timer.start(100)
self.shrt_sh = QtGui.QShortcut(QtGui.QKeySequence.ZoomIn, self)
self.connect(self.shrt_sh, QtCore.SIGNAL("activated()"), self.shrt)
self.shrt2_sh = QtGui.QShortcut(QtGui.QKeySequence.ZoomOut, self)
self.connect(self.shrt2_sh, QtCore.SIGNAL("activated()"), self.shrt2)
def shrt(self):
global paratextsize
if paratextsize < 7:
paratextsize += 1
self.lbl.setText("<font size='" + str(paratextsize) + "'>" +
paragraph + "</font>")
def shrt2(self):
global paratextsize
if paratextsize > 3:
paratextsize -= 1
self.lbl.setText("<font size='" + str(paratextsize) + "'>" +
paragraph + "</font>")
def onChanged(self, text):
global positionOfCurrentWord
global words
global numberOfReds
global numberOfChars
global endOfCurrentWord
userInputWord = text
if self.start == 0:
self.start = 1
if stringmatch(userInputWord,
currentWordFromPara[:len(userInputWord)]):
# green
self.setStyleSheet(
_fromUtf8("background-color: #4C3327;"
"background-image: url(img3.jpg);"
"color: #4C3327;"))
numberOfChars += 1
else:
# red
global paratextsize
if positionOfCurrentWord < len(paragraph):
fill = "<html><font color ='green' size='" + str(
paratextsize) + "'>" + str(
paragraph[:positionOfCurrentWord -
len(currentWordFromPara)]
) + "<font color ='red' size='" + str(
paratextsize) + "'>" + str(
currentWordFromPara
) + "<font color=#4C3327 size='" + str(
paratextsize) + "'><font>" + str(
paragraph[positionOfCurrentWord:]) + "</html>"
else:
fill = "<html><font color ='green' size='" + str(
paratextsize) + "'>" + str(
paragraph[:positionOfCurrentWord - 1 -
len(currentWordFromPara)]
) + "<font color ='red' size='" + str(
paratextsize) + "'>" + str(
currentWordFromPara
) + "<font color=#F1ECDD size='" + str(
paratextsize) + "'><font>" + str(
paragraph[positionOfCurrentWord:]) + "</html>"
self.lbl.setText(fill)
numberOfReds += 1
self.setStyleSheet(
_fromUtf8("background-color: rgb(200, 10, 10);"
"background-image: url(img3.jpg);"
"color: #4C3327;"))
numberOfChars += 1
if len(userInputWord) == len(currentWordFromPara):
if stringmatch(userInputWord, currentWordFromPara):
self.lbl.setText(
QtGui.QApplication.translate(
"Dialog",
"<html><head/><body><p><font color=\"green\" size=\"" +
str(paratextsize) + "\">" +
str(paragraph[:positionOfCurrentWord]) +
"</font><font size=\"" + str(paratextsize) + "\">" +
str(paragraph[positionOfCurrentWord:]) +
"</font></p></body></html>", None,
QtGui.QApplication.UnicodeUTF8))
a = updatecurrentWordFromPara()
words += 1
self.qle.clear()
if a == "-1":
global speed
global tempfloat
global flag2
accuracy = tempfloat
self.timer.stop()
self.timer3.start(1000)
self.progbar.setValue((100 * words) / paralen)
self.exitlbl.setVisible(True)
self.exitlbl.setText(
"<font size=\"15\" color=\"#F1ECDD\"> " +
str(speed) + " Words per minute</font>")
self.addToDatabase()
self.start = 0
flag2 = 2
self.timer.start(100)
self.qle.setVisible(False)
self.restart.setVisible(True)
self.restart.setEnabled(True)
def issueRequest(self, inpdata):
self.request = QByteArray()
stream = QDataStream(self.request, QIODevice.WriteOnly)
stream.setVersion(QDataStream.Qt_4_2)
stream.writeUInt16(0)
stream << inpdata
stream.device().seek(0)
stream.writeUInt16(self.request.size() - SIZEOF_UINT16)
if self.socket.isOpen():
self.socket.close()
self.socket.connectToHost("127.0.0.1", PORT)
def sendRequest(self):
self.nextBlockSize = 0
self.socket.write(self.request)
self.request = None
def readResponse(self):
global paralen
global words
stream = QDataStream(self.socket)
stream.setVersion(QDataStream.Qt_4_2)
while True:
if self.nextBlockSize == 0:
if self.socket.bytesAvailable() < SIZEOF_UINT16:
break
self.nextBlockSize = stream.readUInt16()
if self.socket.bytesAvailable() < self.nextBlockSize:
break
inpdata = QString()
stream >> inpdata
s = str(inpdata)
s = s.split(" ", 1)
global flag2
if flag2 == 1:
if int(s[0]) == 1000 and (s[1]) == "0":
self.lbl.setText(
"<font size='8'>Waiting for other players . . . </font>"
)
else:
flag2 = 0 # flag2==0: para is fetched and game is not finished
parastr = s[1].split(" ", 1)
n = int(str(parastr[0]))
allparas = paralist()
global paragraph
global paralen
paragraph = parastr[1]
paralen = len(paragraph.split())
self.lbl.setText("<font size=\"" + str(paratextsize) +
"\">" + paragraph + "</font>")
self.lcdwpm.display(0)
self.lcdaccuracy.display(0)
self.lcdtimer.display(0)
self.progbar.setValue(0)
self.exitlbl.setVisible(False)
updatecurrentWordFromPara()
global totalChars
totalChars = len(paragraph)
self.timer.stop()
self.qle.setReadOnly(True)
self.timer2.start(1000)
if flag2 == 2:
if int(s[0]) == 1009:
self.lbl.setText(s[1])
self.lbl.setStyleSheet(
_fromUtf8("font: 24pt \"mry_KacstQurn\";"
"color:#4C3327;"))
elif flag2 == 0 and int(s[0]) != 1000 and int(
s[0]) != 1010 and int(s[0]) != 1009:
self.lcdaccuracy.display(int(str(inpdata)))
self.nextBlockSize = 0
def serverHasStopped(self):
None
def serverHasError(self, error):
self.socket.close()
class ConnectWindow(QMainWindow, Ui_ConnectWindow):
def __init__(self):
"""
Arguments:
- `self`:
"""
QMainWindow.__init__(self)
self.setupUi(self)
self.socket = QTcpSocket()
self.connect()
# Signals
conn_success = pyqtSignal('QTcpSocket')
exit_signal = pyqtSignal()
# Slots
@pyqtSlot()
def connect_server(self):
"""
"""
self.statusBar.clearMessage()
host = self.serverLine.text().trimmed()
port = self.portLine.text().trimmed()
if host and port:
self.socket.connectToHost(host, int(port))
else:
self.statusBar.showMessage('Enter valid a server address and port!')
@pyqtSlot()
def on_success(self):
"""
"""
if self.socket.waitForReadyRead(10000):
msg = self.socket.readData(1024)
msg = loads(msg)
if msg['head'] == CONN_SUCC:
self.statusBar.showMessage('Connection established')
self.conn_success.emit(self.socket)
self.hide()
else:
self.statusBar.showMessage('Server is full!')
self.socket.disconnectFromHost()
else:
self.on_error()
@pyqtSlot()
def on_error(self):
self.statusBar.showMessage('Connection cannot be established!')
def closeEvent(self, event):
"""
"""
dialog = ExitDialog()
if dialog.exec_():
event.accept()
else:
event.ignore()
# Connections
def connect(self):
"""
"""
self.connectButton.clicked.connect(self.connect_server)
self.exitButton.clicked.connect(self.close)
self.socket.error.connect(self.on_error)
self.socket.connected.connect(self.on_success)
class ClientDialog(QtGui.QDialog):
STATUS = [
"Not Connected", "Host Lookup", "Establishing connection", "Connected",
"The socket is bound to an address and port", "For internal use only",
"Socket is about to close"
]
def __init__(self, configdir, recentconndb):
QtGui.QDialog.__init__(self)
# Variables
self.configdir = configdir
self.recentconndb = recentconndb
self.socket = QTcpSocket()
self.status = self.STATUS[0]
log.info("Starting Client")
# Properties
self.setModal(True)
# Setup Widget
self.layout = QtGui.QVBoxLayout()
self.mainWidget = ControllerClientWidget()
self.layout.addWidget(self.mainWidget)
self.setLayout(self.layout)
#Connections
self.connect(self.socket,
QtCore.SIGNAL('error(QAbstractSocket::SocketError)'),
self.displayError)
self.connect(self.socket, QtCore.SIGNAL('connected()'), self.connected)
self.connect(self.mainWidget.connectButton, QtCore.SIGNAL('pressed()'),
self.connectToServer)
self.connect(self.mainWidget.hostEdit,
QtCore.SIGNAL('textChanged(QString)'),
self.enableConnectButton)
self.connect(self.mainWidget.portEdit,
QtCore.SIGNAL('textChanged(QString)'),
self.enableConnectButton)
self.connect(self.mainWidget.passEdit,
QtCore.SIGNAL('textChanged(QString)'),
self.enableConnectButton)
self.connect(self.mainWidget.recentConnList,
QtCore.SIGNAL('doubleClicked(const QModelIndex &)'),
self.recentListHandler)
self.loadRecentConnDB()
self.enableConnectButton()
self.hide()
# Translations
self.app = QtGui.QApplication.instance()
self.current_language = "en_US"
self.uiTranslator = QtCore.QTranslator()
self.uiTranslator.load(":/languages/tr_en_US.qm")
self.retranslate()
self.updateStatus()
###
### Translation Related
###
def retranslate(self, language=None):
if language is not None:
self.current_language = language
self.uiTranslator.load(":/languages/tr_%s.qm" % self.current_language)
self.setWindowTitle(
self.app.translate("ControllerClientApp", "Controller Client"))
#
# Reusable Strings
#
self.clientStatusString = self.app.translate("ControllerClientApp",
"Status")
self.connectString = self.app.translate("ControllerClientApp",
"Connect")
self.disconnectString = self.app.translate("ControllerClientApp",
"Disconnect")
# --- End Reusable Strings
#
# Connection Settings
#
self.mainWidget.toolBox.setItemText(
0, self.app.translate("ControllerClientApp",
"Connection Settings"))
self.mainWidget.hostLabel.setText(
self.app.translate("ControllerClientApp",
"Host name (or IP Address)"))
self.mainWidget.portLabel.setText(
self.app.translate("ControllerClientApp", "Port"))
self.mainWidget.passLabel.setText(
self.app.translate("ControllerClientApp", "Passphrase"))
if self.status == self.STATUS[3]:
self.mainWidget.connectButton.setText(
self.app.translate("ControllerClientApp",
self.disconnectString))
else:
self.mainWidget.connectButton.setText(
self.app.translate("ControllerClientApp", self.connectString))
self.updateStatus()
# --- End Connection Settings
#
# Recent Connections
#
self.mainWidget.toolBox.setItemText(
1, self.app.translate("ControllerClientApp", "Recent Connections"))
# --- End Recent Connections
##
## UI Related
##
def enableConnectButton(self):
if self.mainWidget.passEdit.text(
) == '' or self.mainWidget.hostEdit.text(
) == '' or self.mainWidget.portEdit.text() == '':
self.mainWidget.connectButton.setEnabled(False)
else:
self.mainWidget.connectButton.setEnabled(True)
def connected(self):
caddr = self.socket.peerName()
cport = self.socket.peerPort()
log.info("Connected to %s:%s" % (caddr, cport))
self.sendPassphrase()
self.mainWidget.connectButton.setText(self.disconnectString)
self.disconnect(self.mainWidget.connectButton,
QtCore.SIGNAL('pressed()'), self.connectToServer)
self.disconnect(self.mainWidget.passEdit,
QtCore.SIGNAL('textChanged(QString)'),
self.enableConnectButton)
self.connect(self.mainWidget.connectButton, QtCore.SIGNAL('pressed()'),
self.disconnectFromHost)
self.connect(self.socket, QtCore.SIGNAL("disconnected()"),
self.disconnectedFromHost)
'''
This function is for updating the sockets status and the statusLabel. It's called when a stateChanged signal is triggered.
'''
def updateStatus(self):
state = self.socket.state()
self.status = self.STATUS[state]
self.mainWidget.statusLabel.setText(self.clientStatusString + ": " +
self.status)
'''
When there is a socket error this function is called to show the error in a QMessageBox
'''
def displayError(self, socketError):
messageBox = QtGui.QMessageBox.critical(
self, QtCore.QString('Error!'),
QtCore.QString(self.socket.errorString()))
log.error("Socket error %s" % self.socket.errorString())
##
## Connection Related
##
'''
Function that is called when connect button is pressed.
'''
def connectToServer(self):
caddr = self.mainWidget.hostEdit.text()
cport = int(self.mainWidget.portEdit.text())
cpass = self.mainWidget.passEdit.text()
self.connect(
self.socket,
QtCore.SIGNAL('stateChanged(QAbstractSocket::SocketState)'),
self.updateStatus)
log.info("Connecting to %s:%s" % (caddr, cport))
self.socket.connectToHost(caddr, cport)
if not self.socket.waitForConnected(1000):
log.error("Socket error %s", self.socket.errorString())
else:
# Add to recent connections if connection is successful
self.addToRecentConnections(caddr, cport, cpass)
def disconnectFromHost(self):
self.socket.disconnectFromHost()
'''
Function for disconnecting the client from the host.
'''
def disconnectedFromHost(self):
log.info("Disconnected from host")
self.disconnect(self.mainWidget.connectButton,
QtCore.SIGNAL('pressed()'), self.disconnectFromHost)
self.connect(self.mainWidget.connectButton, QtCore.SIGNAL('pressed()'),
self.connectToServer)
self.connect(self.mainWidget.passEdit,
QtCore.SIGNAL('textChanged(QString)'),
self.enableConnectButton)
self.mainWidget.connectButton.setText(self.connectString)
'''
Function for sending message to the connected server
'''
def sendMessage(self, message):
log.info("Sending message: %s", message)
block = QtCore.QByteArray()
block.append(message)
self.socket.write(block)
'''
This function is for sending the passphrase to the server. It uses the sendMessage function
'''
def sendPassphrase(self):
self.sendMessage(self.mainWidget.passEdit.text())
'''
This function is for reading message from the server
'''
def readMessage(self):
message = self.socket.read(self.socket.bytesAvailable())
log.info("Server said: %s", message)
return message
##
## Recent Connections Related
##
def loadRecentConnDB(self):
model = self.recentconndb.get_recentconn_model()
self.mainWidget.recentConnList.setModel(model)
self.mainWidget.recentConnList.setColumnHidden(
2, True) # Hide the passphrase column
'''
This function is for adding a new connection to the recent connections. It checks whether it exists in the database or not.
'''
def addToRecentConnections(self, caddr, cport, cpass):
self.recentconndb.insert_recentconn(caddr, cport, cpass)
self.loadRecentConnDB()
'''
Handler for the recent connections list. When you click on a recent connection the details of the connection are loaded
'''
def recentListHandler(self, connection):
chost = connection.sibling(connection.row(), 0).data().toString()
cport = int(connection.sibling(connection.row(), 1).data().toString())
cpass = connection.sibling(connection.row(), 2).data().toString()
self.mainWidget.hostEdit.setText(chost)
self.mainWidget.portEdit.setValue(cport)
self.mainWidget.passEdit.setText(cpass)
self.mainWidget.toolBox.setCurrentWidget(self.mainWidget.connWidget)
class TrickplayDeviceManager(QWidget):
def __init__(self, main=None, parent = None):
QWidget.__init__(self, parent)
self.main = main
self.inspector = main._inspector
self.editorManager = main._editorManager
self.debugWindow = main._debug
self.backtraceWindow = main.backtrace
self.ui = Ui_DeviceManager()
self.ui.setupUi(self)
self.addLocalComboItem()
self.discovery = TrickplayDiscovery(self)
QObject.connect(self.ui.comboBox, SIGNAL('currentIndexChanged(int)'), self.service_selected)
QObject.connect(self.ui.run, SIGNAL("clicked()"), self.run)
self._path = ''
self.trickplay = QProcess()
QObject.connect(self.trickplay, SIGNAL('started()'), self.app_started)
#QObject.connect(self.trickplay, SIGNAL('finished(int, QProcess.ExitStatus)'), self.app_finished)
QObject.connect(self.trickplay, SIGNAL('finished(int)'), self.app_finished)
QObject.connect(self.trickplay, SIGNAL('readyRead()'), self.app_ready_read)
self.icon = QIcon()
self.icon.addPixmap(QPixmap(self.main.apath+"/Assets/icon-target.png"), QIcon.Normal, QIcon.Off)
self.icon_null = QIcon()
self.prev_index = 0
self.ui.comboBox.setSizeAdjustPolicy(QComboBox.AdjustToContents)
self.ui.comboBox.setIconSize(QSize(20,32))
self.debug_mode = False
self.debug_run = False
self.debug_port = None
self.console_port = None
self.http_port = None
self.my_name = ""
self.manager = QNetworkAccessManager()
#self.reply = None
#self.bs_command = False
self.current_debug_file = None
self.inbreak = True
def service_selected(self, index):
if index < 0:
return
self.ui.comboBox.setItemIcon(self.prev_index, self.icon_null)
self.ui.comboBox.setItemIcon(index, self.icon)
self.prev_index = index
address = self.ui.comboBox.itemData(index, ADDRESS).toPyObject()
port = self.ui.comboBox.itemData(index, PORT).toPyObject()
self.debug_port = self.ui.comboBox.itemData(index, DEBUG_PORT).toPyObject()
self.http_port = self.ui.comboBox.itemData(index, HTTP_PORT).toPyObject()
self.console_port = self.ui.comboBox.itemData(index, CONSOLE_PORT).toPyObject()
if not address or not port:
return
CON.port = port
CON.address = address
def event(self, event):
QCoreApplication.setOrganizationName('Trickplay');
while 1:
if event.type() == ADDEVENT:
d = event.dict
if d[0] != self.my_name:
print "[VDBG] Service ' %s ' added"%d[0]
# Add item to ComboBox
self.ui.comboBox.addItem(d[0])
index = self.ui.comboBox.findText(d[0])
self.ui.comboBox.setItemData(index, d[1], ADDRESS)
self.ui.comboBox.setItemData(index, d[2], PORT)
self.ui.comboBox.setItemData(index, d[1], NAME)
# Automatically select a service if only one exists
if 1 == self.ui.comboBox.count():
self.service_selected(1) # index -> 1
data = getTrickplayControlData("%s:"%str(d[1])+"%s"%str(d[2]))
if data is not None:
if data.has_key("debugger"):
self.ui.comboBox.setItemData(index, data["debugger"], DEBUG_PORT)
print("[VDBG] debug Port : %s"%data["debugger"], d[0])
else :
print("[VDBG] Didn't get %s's debug_port information "%d[0])
if data.has_key("http"):
#self.http_port = data["http"]
#print("[VDBG] http Port : %s"%self.http_port)
self.ui.comboBox.setItemData(index, data["http"], HTTP_PORT)
else :
print("[VDBG] Didn't get %s's http_port information "%d[0])
if data.has_key("console"):
self.console_port = data["console"]
#print("[VDBG] console Port : %s"%self.console_port)
self.ui.comboBox.setItemData(index, data["console"], CONSOLE_PORT)
CON.port = self.http_port
else :
print("[VDBG] Didn't get %s's console_port information "%d[0])
else:
print("[VDBG] Didn't get %s's Control information "%d[0])
elif event.type() == REMEVENT:
d = event.dict
print "[VDBG] Service ' %s ' removed"%d[0]
# Remove item from ComboBox
index = self.ui.comboBox.findText(d[0])
if index == self.ui.comboBox.currentIndex():
self.ui.comboBox.removeItem(index)
self.ui.comboBox.setCurrentIndex(0)
self.service_selected(0)
else :
self.ui.comboBox.removeItem(index)
#self.inspector.clearTree()
return True
def stop(self):
self.discovery.stop()
def addLocalComboItem(self):
"""
Add combo box from running app locally. This always exists.
"""
name = 'Emulator' #'Trickplay Device '
port = '6789'
address = 'localhost'
icon = QIcon()
icon.addPixmap(QPixmap(self.main.apath+"/Assets/icon-target.png"), QIcon.Normal, QIcon.Off)
self.ui.comboBox.addItem(name)
index = self.ui.comboBox.findText(name)
self.ui.comboBox.setItemIcon(index, icon)
self.ui.comboBox.setItemData(index, address, ADDRESS)
self.ui.comboBox.setItemData(index, port, PORT)
self.ui.comboBox.setItemData(index, address, NAME)
CON.port = port
CON.address = address
def push(self):
print('[VDBG] Pushing app to %s'%CON.get())
tp = TrickplayPushApp(self, str(self.path()))
ret = tp.push(address = CON.get())
if ret is not False:
self.app_started()
return ret
def setPath(self, p):
self._path = p
def path(self):
return self._path
def app_started(self):
print "[VDBG] APP Started"
self.newApp = True
# Console Port
self.socket = QTcpSocket()
self.nextBlockSize = 0
self.bytesAvail = 0
self.connect(self.socket, SIGNAL("connected()"), self.sendRequest)
self.connect(self.socket, SIGNAL("readyRead()"), self.readResponse)
self.connect(self.socket, SIGNAL("disconnected()"), self.serverHasStopped)
if self.socket.isOpen():
self.socket.close()
if self.ui.comboBox.currentIndex() != 0:
print("[VDBG] Connecting to console port ")
cnt = 0
while cnt < 5:
try :
self.socket.connectToHost(CON.address, self.console_port, mode=QIODevice.ReadWrite)
if self.socket.waitForConnected(100):
self.newApp = True
break
except :
cnt = cnt + 1
def sendRequest(self):
print "Connected"
def readDebugResponse(self):
while self.debug_socket.waitForReadyRead(1100) :
print self.debug_socket.read(self.debug_socket.bytesAvailable())
def readResponse(self):
while self.socket.waitForReadyRead(1100) :
EGN_MSG(self.socket.read(self.socket.bytesAvailable())[:-1].replace('\033[34;1m','').replace('\033[31;1m','').replace('\033[0m','').replace('\033[37m','').replace('\033[32m',''))
def debugServerHasStopped(self):
self.debug_socket.close()
def serverHasStopped(self):
print("Console port disconnected")
self.socket.close()
def serverHasError(self, error):
print(QString("[VDBG] Error: %1").arg(self.socket.errorString()))
self.socket.close()
def app_ready_read(self):
# Read all available output from the process
while True:
# Read one line
if not self.trickplay.canReadLine():
break
# Read one line
s = self.trickplay.readLine()
# If the line is null, it means there is nothing more
# to read during this iteration
if s.isNull():
break
# Convert it to a string and strip the trailing white space
s = str( s ).rstrip()
# Look for the CONTROL line
if s.startswith( "<<CONTROL>>:" ):
try:
# Parse the contents of the control line and get the
# debugger port.
control = json.loads( s[12:] )
# Store it. This could fail if the engine has no debugger
# port.
if control.has_key("debugger"):
self.debug_port = control[ "debugger" ]
if control.has_key("http"):
self.http_port = control[ "http" ]
if control.has_key("console"):
self.console_port = control[ "console" ]
self.ui.comboBox.setItemData(0, self.http_port, PORT)
CON.port = self.http_port
# Send our first debugger command, which will return
# when the app breaks
if self.debug_mode == True:
self.inbreak = False
self.send_debugger_command(DBG_CMD_INFO)
if len(self.editorManager.bp_info[1]) > 0 :
self.send_debugger_command(DBG_CMD_BB)
else :
self.inspector.ui.refresh.setEnabled(True)
self.inspector.ui.search.setEnabled(True)
except:
print( "[VDBG] Failed to obtain debugger port" )
# Close the process
self.trickplay.close()
else:
# Output the log line
EGN_MSG(">> %s"%s.replace('\033[34;1m','').replace('\033[31;1m','').replace('\033[0m','').replace('\033[37m','').replace('\033[32m',''))
def send_debugger_command(self, command):
if self.debug_port is None:
print "No debugger port"
return
url = QUrl()
url.setScheme( "http" )
url.setHost( CON.address )
url.setPort( self.debug_port )
url.setPath( "/debugger" )
print ("[VDBG] ' %s ' Command Sent"%command)
data = {}
request = QNetworkRequest( url )
if command == "bb":
data['clear'] = True
data['add'] = []
bpCnt = len(self.editorManager.bp_info[1])
for r in range(0, bpCnt):
bp_info = self.editorManager.bp_info[2][r]
n = re.search(":", bp_info).end()
fName = bp_info[:n-1]
lNum = int(bp_info[n:]) -1
if self.editorManager.bp_info[1][r] == "on":
bState = True
else:
bState = False
#data['add'].append({'file':fName, 'line':lNum, 'on':bState})
bp_item = {}
bp_item['file'] = fName
bp_item['line'] = lNum + 1
bp_item['on'] = bState
data['add'].append(bp_item)
params = json.dumps(data)
reply = self.manager.post( request ,command+' '+params)
reply.command = command
else:
reply = self.manager.post( request , command )
reply.command = command
def debugger_reply_finished(reply):
def foo ():
if reply.error()== QNetworkReply.NoError:
print("[VDBG] ' %s ' Response"%reply.command)
if reply.command == "bn":
return
if reply.command == "r":
self.main.deviceManager.socket.write('/close\n\n')
self.main.rSent = False
if self.main.onExit == True:
if self.editorManager.tab != None:
while self.editorManager.tab.count() != 0:
self.editorManager.close()
self.stop()
self.main.close()
data = self.getFileLineInfo_Resp(str(reply.readAll()), command)
if data is not None:
if reply.command == DBG_CMD_INFO:
self.inbreak = True
self.inspector.ui.refresh.setEnabled(False)
self.inspector.ui.search.setEnabled(False)
# Open File, Show Current Lines
if self.file_name.startswith("/"):
self.file_name= self.file_name[1:]
self.file_name= self.file_name+'/'
if self.file_name.endswith("/"):
self.file_name= self.file_name[:len(self.file_name) - 1]
current_file = os.path.join(str(self.main.path), str(self.file_name))
if self.current_debug_file != current_file:
self.editorManager.newEditor(current_file, None, self.line_no, self.current_debug_file, True)
else :
self.editorManager.newEditor(current_file, None, self.line_no, None, True)
self.current_debug_file = current_file
# Local Variable Table
local_info = self.getLocalInfo_Resp(data)
if local_info is not None:
self.debugWindow.populateLocalTable(local_info)
# Global Variable Table
global_info = self.getGlobalInfo_Resp(data)
if global_info is not None:
self.debugWindow.populateGlobalTable(global_info, self.editorManager)
# Stack Trace Table
stack_info = self.getStackInfo_Resp(data)
if stack_info is not None:
self.backtraceWindow.populateTraceTable(stack_info, self.editorManager)
#reply = None
#reply.command = None
# TODO: Here we should enable the debug UI
self.main.debug_stepinto.setEnabled(True)
self.main.debug_stepover.setEnabled(True)
self.main.debug_stepout.setEnabled(False)
self.main.debug_pause_bt.setEnabled(False)
self.main.debug_continue_bt.setEnabled(True)
self.main.ui.actionContinue.setEnabled(True)
self.main.ui.actionPause.setEnabled(False)
self.main.ui.actionStep_into.setEnabled(True)
self.main.ui.actionStep_over.setEnabled(True)
self.main.ui.actionStep_out.setEnabled(False)
self.main.debug_run = False
elif reply.command[:1] == DBG_CMD_BREAKPOINT or reply.command == DBG_CMD_BB or reply.command[:1] == DBG_CMD_DELETE:
# Break Point
break_info = self.getBreakPointInfo_Resp(data)
if break_info is not None:
self.debugWindow.populateBreakTable(break_info, self.editorManager)
if reply.command == DBG_CMD_BB :
return
editor = self.editorManager.app.focusWidget()
if editor is not None :
nline = editor.margin_nline
else:
index = self.editorManager.tab.currentIndex()
editor = self.editorManager.tab.editors[index]
nline = editor.margin_nline
if reply.command[:1] == DBG_CMD_DELETE and nline is not None:
if editor.current_line != nline :
editor.markerDelete(nline, -1)
else :
editor.markerDelete(nline, -1)
editor.markerAdd(nline, editor.ARROW_MARKER_NUM)
editor.line_click[nline] = 0
return
elif nline is None:
return
# Break Point Setting t
if not editor.line_click.has_key(nline) or editor.line_click[nline] == 0 :
if editor.current_line != nline :
editor.markerAdd(nline, editor.ACTIVE_BREAK_MARKER_NUM)
else:
editor.markerDelete(nline, editor.ARROW_MARKER_NUM)
editor.markerAdd(nline, editor.ARROW_ACTIVE_BREAK_MARKER_NUM)
editor.line_click[nline] = 1
# Break Point Deactivate
elif editor.line_click[nline] == 1:
if editor.current_line != nline :
editor.markerDelete(nline, editor.ACTIVE_BREAK_MARKER_NUM)
editor.markerAdd(nline, editor.DEACTIVE_BREAK_MARKER_NUM)
else :
editor.markerDelete(nline, editor.ARROW_ACTIVE_BREAK_MARKER_NUM)
editor.markerAdd(nline, editor.ARROW_DEACTIVE_BREAK_MARKER_NUM)
editor.line_click[nline] = 2
# Break Point Active
elif editor.line_click[nline] == 2:
if editor.current_line != nline :
editor.markerDelete(nline, editor.DEACTIVE_BREAK_MARKER_NUM)
editor.markerAdd(nline, editor.ACTIVE_BREAK_MARKER_NUM)
else :
editor.markerDelete(nline, editor.ARROW_DEACTIVE_BREAK_MARKER_NUM)
editor.markerAdd(nline, editor.ARROW_ACTIVE_BREAK_MARKER_NUM)
editor.line_click[nline] = 1
#reply = None
#self.command = None
if reply.command in DBG_ADVANCE_COMMANDS:
if reply.command == DBG_CMD_CONTINUE :
# delete current line marker
for m in self.editorManager.editors:
if self.current_debug_file == m:
# check what kind of arrow marker was on the current line and delete just arrow mark not break points
self.editorManager.tab.editors[self.editorManager.editors[m][1]].markerDelete(
self.editorManager.tab.editors[self.editorManager.editors[m][1]].current_line, Editor.ARROW_MARKER_NUM)
self.editorManager.tab.editors[self.editorManager.editors[m][1]].current_line = -1
# clean backtrace and debug windows
self.backtraceWindow.clearTraceTable(0)
self.debugWindow.clearLocalTable(0)
self.debugWindow.clearGlobalTable(0)
# Leave the debug UI disabled, and wait for the info command to return
self.send_debugger_command( DBG_CMD_INFO )
return foo
f=debugger_reply_finished(reply)
QObject.connect( reply , SIGNAL( 'finished()' ) , f)
reply.command = command[:]
if command in DBG_ADVANCE_COMMANDS:
# TODO: Here we should disable the debug UI
self.main.debug_stepinto.setEnabled(False)
self.main.debug_stepover.setEnabled(False)
self.main.debug_stepout.setEnabled(False)
self.main.debug_pause_bt.setEnabled(True)
self.main.debug_continue_bt.setEnabled(False)
self.main.ui.actionContinue.setEnabled(False)
self.main.ui.actionPause.setEnabled(True)
self.main.ui.actionStep_into.setEnabled(False)
self.main.ui.actionStep_over.setEnabled(False)
self.main.ui.actionStep_out.setEnabled(False)
self.main.debug_run = True
return True
def app_finished(self, errorCode):
if errorCode == 0 :
print ("[VDBG] Error Code : ["+str(errorCode)+", FailedToStart] the process failed to start. Either the invoked program is missing, or you may have insufficient permissions to invoke the program" )
elif errorCode == 1 :
print ("[VDBG] Error Code : ["+str(errorCode)+", Crashed] The process crashed some time after starting successfully.")
elif errorCode == 2 :
print ("[VDBG] Error Code : ["+str(errorCode)+", Timedout] The process crashed some time after starting successfully.")
elif errorCode == 3 :
print ("[VDBG] Error Code : ["+str(errorCode)+", ReadError] An error occurred when attempting to read from the process. For example, the process may not be running.")
elif errorCode == 4 :
print ("[VDBG] Error Code : ["+str(errorCode)+", WriteError] An error occurred when attempting to write to the process. For example, the process may not be running, or it may have closed its input channel.")
elif errorCode == 5 :
print ("[VDBG] Error Code : ["+str(errorCode)+", UnknownError] An unknown error occurred.")
if self.trickplay.state() == QProcess.NotRunning :
print "[VDBG] Trickplay APP is finished"
if self.trickplay.exitStatus() == QProcess.NormalExit :
print ("[VDBG] ExitStatus : The process exited normally.")
elif self.trickplay.exitStatus() == QProcess.CrashExit :
print ("[VDBG] ExitStatus : The process crashed.")
if self.main.closedByIDE == False :
msg = QMessageBox()
msg.setText("The process crashed.")
msg.setInformativeText('ErrorCode : [ '+str(errorCode)+' ]')
msg.setWindowTitle("Warning")
msg.setGeometry(500,500,0,0)
msg.exec_()
self.inspector.clearTree()
self.inspector.ui.refresh.setEnabled(False)
self.inspector.ui.search.setEnabled(False)
self.main.stop()
def run(self, dMode=False):
# Run on local trickplay
if 0 == self.ui.comboBox.currentIndex():
print("[VDBG] Starting trickplay locally")
if self.trickplay.state() == QProcess.Running:
self.trickplay.close()
env = self.trickplay.processEnvironment().systemEnvironment()
if self.main.config is None :
print("[VDBG] .trickplay config file is ignored.")
for item in env.toStringList():
if item[:3] == "TP_":
n = re.search("=", item).end()
env.remove(item[:n-1])
env.insert("TP_config_file","")
else:
print("[VDBG] .trickplay config file is read.")
env.insert("TP_LOG", "bare")
if dMode == True :
self.debug_mode = True
self.main.debug_mode = True
env.insert("TP_start_debugger","true")
else :
self.debug_mode = False
self.main.debug_mode = False
# To merge stdout and stderr
self.trickplay.setProcessChannelMode( QProcess.MergedChannels )
self.trickplay.setProcessEnvironment(env)
ret = self.trickplay.start('trickplay', [self.path()])
# Push to remote device
else:
if dMode == True:
if self.debug_port is None:
print("[VDBG] Debug port is missing")
return False
# POST http://<host>:<debugger port>/debugger "r"
#url = QUrl()
#url.setScheme( "http" )
#url.setHost( CON.address )
#url.setPort( self.debug_port )
#url.setPath( "/debugger" )
#print ("[VDBG] ' %s ' Command Sent"%'r')
#request = QNetworkRequest( url )
#self.manager.post( request , 'r' )
self.debug_mode = True
self.main.debug_mode = True
ret = self.push()
if ret == False:
return ret
elif dMode == True:
self.inbreak = False
self.send_debugger_command(DBG_CMD_INFO)
if len(self.editorManager.bp_info[1]) > 0 :
self.send_debugger_command(DBG_CMD_BB)
else :
self.inspector.ui.refresh.setEnabled(True)
self.inspector.ui.search.setEnabled(True)
def getFileLineInfo_Resp(self, data, command):
pdata = json.loads(data)
if command == "i":
if "error" in pdata:
print "[VDBG] "+pdata["error"]
return None
else:
file_name = pdata["file"]
tp_id = pdata["id"]
line_num = pdata["line"]
self.line_no = str(line_num)
self.file_name = str(file_name)
return pdata
else:
return pdata
def getGlobalInfo_Resp(self, data):
if "globals" in data:
name_var_list = []
type_var_list = []
value_var_list = []
defined_var_list = []
global_vars_str = ""
global_vars = {}
for c in data["globals"]:
if c["name"] != "(*temporary)":
c_v = None
if global_vars_str != "":
global_vars_str = global_vars_str+"\n\t"
global_vars_str = global_vars_str+str(c["name"])+"("+str(c["type"])+")"
name_var_list.append(str(c["name"]))
type_var_list.append(str(c["type"]))
defined_var_list.append(str(c["defined"]))
try:
c_v = c["value"]
except KeyError:
pass
if c_v:
global_vars_str = global_vars_str+" = "+str(c["value"])
value_var_list.append(str(c["value"]))
else:
value_var_list.append("")
global_vars[1] = name_var_list
global_vars[2] = type_var_list
global_vars[3] = value_var_list
global_vars[4] = defined_var_list
return global_vars
else:
return None
def getLocalInfo_Resp(self, data):
if "locals" in data:
name_var_list = []
type_var_list = []
value_var_list = []
local_vars_str = ""
local_vars = {}
for c in data["locals"]:
if c["name"] != "(*temporary)":
c_v = None
if local_vars_str != "":
local_vars_str = local_vars_str+"\n\t"
local_vars_str = local_vars_str+str(c["name"])+"("+str(c["type"])+")"
name_var_list.append(str(c["name"]))
type_var_list.append(str(c["type"]))
try:
c_v = c["value"]
except KeyError:
pass
if c_v:
local_vars_str = local_vars_str+" = "+str(c["value"])
value_var_list.append(str(c["value"]))
else:
value_var_list.append("")
local_vars[1] = name_var_list
local_vars[2] = type_var_list
local_vars[3] = value_var_list
return local_vars
else:
return None
def getStackInfo_Resp(self, data):
if "stack" in data:
stack_info_str = ""
stack_list = []
info_list = []
stack_info = {}
index = 0
for s in data["stack"]:
if "file" in s and "line" in s:
stack_info_str = stack_info_str+"["+str(index)+"] "+s["file"]+":"+str(s["line"])+"\n\t"
stack_list.append("["+str(index)+"] "+s["file"]+":"+str(s["line"]))
#info_list.append(str(self.path())+'/'+s["file"]+":"+str(s["line"]))
eChar = ""
if s["file"][:1] != "/" :
eChar = "/"
info_list.append(str(self.path())+eChar+s["file"]+":"+str(s["line"]))
index = index + 1
stack_info[1] = stack_list
stack_info[2] = info_list
#print "\t"+stack_info_str
return stack_info
else:
return None
def getBreakPointInfo_Resp(self, data):
if "breakpoints" in data:
state_var_list = []
file_var_list = []
breakpoints_info = {}
breakpoints_info_str = ""
index = 0
if len(data["breakpoints"]) == 0:
print "[VDBG] No breakpoints set"
return breakpoints_info
else:
for b in data["breakpoints"]:
if "file" in b and "line" in b:
breakpoints_info_str = breakpoints_info_str+"["+str(index)+"] "+b["file"]+":"+str(b["line"])
file_var_list.append(b["file"]+":"+str(b["line"]))
if "on" in b:
if b["on"] == True:
breakpoints_info_str = breakpoints_info_str+""+"\n "
state_var_list.append("on")
else:
breakpoints_info_str = breakpoints_info_str+" (disabled)"+"\n "
state_var_list.append("off")
index = index + 1
breakpoints_info[1] = state_var_list
breakpoints_info[2] = file_var_list
print "[VDBG] "+breakpoints_info_str
return breakpoints_info
else:
return None
def printResp(self, data, command):
if "source" in data:
source_info = ""
for l in data["source"]:
if "line" in l and "text" in l:
if l["line"] == line_num:
source_info = source_info+str(l["line"])+" >>"+str(l["text"])+"\n\t"
else:
source_info = source_info+str(l["line"])+" "+str(l["text"])+"\n\t"
print "\t"+source_info
elif "lines" in data:
fetched_lines = ""
for l in data["lines"]:
fetched_lines = fetched_lines+l+"\n\t"
print "\t"+fetched_lines
elif "app" in data:
app_info = ""
for key in data["app"].keys():
if key != "contents":
app_info = app_info+str(key)+" : "+str(data["app"][key])+"\n\t"
else:
app_info = app_info+key+" : "
for c in data["app"]["contents"]:
app_info = app_info + str(c) + ","
app_info = app_info+"\n\t"
print "\t"+app_info
if command in ['n','s','bn', 'cn']:
#print "\t"+"Break at "+file_name+":"+str(line_num)
pass
return True
class display_driver(PtDriver.PtDriver):
def __init__(self,name=None):
PtDriver.PtDriver.__init__(self,name=name)
def open(self,options):
self.options = options
self.tcpSocket = QTcpSocket()
# try to connect to the server
self.tcpSocket.connectToHost(QHostAddress("0.0.0.0"), 5006)
self.tcpSocket.waitForConnected(2000)
if self.tcpSocket.state() != 3:
self._launchWindow()
#thread.start_new_thread(self._launchWindow,(xres,yres))
QObject.connect(self.tcpSocket, SIGNAL("connected()"), self.tcpSocketConnected)
#print "connecting now"
while self.tcpSocket.state() != 3:
self.tcpSocket.connectToHost(QHostAddress("0.0.0.0"), 5006)
self.tcpSocket.waitForConnected(5000)
def tcpSocketConnected(self):
#txt = "Successfully connected to Server!!!"
self.xres = self.options.xres.value
self.yres = self.options.yres.value
# send resolution
txt = struct.pack("6sII","imgnfo",self.xres,self.yres)
self.tcpSocket.write(QByteArray(txt))
self.tcpSocket.waitForBytesWritten()
def prepareBucket(self,bucket):
bu = struct.pack("6sIIII","bucket",
bucket.pos.x,
bucket.pos.y,
bucket.width,
bucket.height)
for i,p in enumerate(bucket.pixels):
if i < bucket.width or \
i > ((bucket.height * bucket.width) - bucket.width) or \
(i % bucket.width) == 0 or\
(((i+1) % bucket.width) + bucket.width) == bucket.width:
bu += struct.pack("3I",255,255,0)
else:
bu += struct.pack("3I",0,0,0)
self.tcpSocket.write(QByteArray(bu))
self.tcpSocket.waitForBytesWritten()
def writeBucket(self,bucket):
bu = struct.pack("6sIIII","bucket",
bucket.pos.x,
bucket.pos.y,
bucket.width,
bucket.height)
#print "wrote ",len(bucket.pixels)
#print "x ",bucket.width," y ",bucket.height, " len ",len(bucket.pixels)
#j = 0
for i in bucket.pixels:
#bu += struct.pack("3I",i.r,i.g,i.b)
bu += struct.pack("3I",int(i.r),int(i.g),int(i.b))
#j +=1
#print "size sent ",j
self.tcpSocket.write(QByteArray(bu))
self.tcpSocket.waitForBytesWritten()
def close(self):
self.tcpSocket.close()
def _launchWindow(self):
file = os.path.dirname(__file__)
cmd = "python %s"%os.path.join(file,"framebuffer.py")
subprocess.Popen(cmd.split())
