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)
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)
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()
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 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 ("", "", "")
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 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())
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 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 ("", "", "")
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 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 GopherReply(QNetworkReply): 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 getResource(self): path = self.url().path() if path.isEmpty() or path == u"/": self.output = "\r\n" else: self.output = str(path) + "\r\n" self.writeGopherData() def readGopherData(self): self.input += str(self.gopher.readAll()) def writeGopherData(self, written=0): self.output = self.output[written:] if self.output: self.gopher.write(self.output) def html(self, text): return (text).replace(u"&", u"&").replace(u"<", u"<").replace( u">", u">") def setContent(self): if self.url().hasQueryItem(u"type"): self.setContentData() else: self.setContentList() def setContentData(self): self.open(self.ReadOnly | self.Unbuffered) if self.url().queryItemValue(u"type") == u"text": self.setHeader(QNetworkRequest.ContentTypeHeader, QVariant("text/plain")) self.content = self.input self.setHeader(QNetworkRequest.ContentLengthHeader, QVariant(len(self.content))) self.readyRead.emit() self.finished.emit() def setContentList(self): url = QUrl(self.url()) if not url.path().endsWith(u"/"): url.setPath(url.path() + u"/") base_url = self.url().toString() base_path = (url.path()) self.open(self.ReadOnly | self.Unbuffered) content = (u"<html>\n" u"<head>\n" u" <title>" + self.html(base_url) + u"</title>\n" u' <style type="text/css">\n' u" th { background-color: #aaaaaa;\n" u" color: black }\n" u" table { border: solid 1px #aaaaaa }\n" u" tr.odd { background-color: #dddddd;\n" u" color: black\n }\n" u" tr.even { background-color: white;\n" u" color: black\n }\n" u" </style>\n" u"</head>\n\n" u"<body>\n" u"<h1>Listing for " + base_path + u"</h1>\n\n") lines = self.input.splitlines() for line in lines: pieces = line.split("\t") if pieces == ["."]: break try: type, path, host, port = pieces[:4] except ValueError: # This isn't a listing. Let's try returning data instead. self.setContentData() return if type[0] == "i": content += u"<p>" + self.html(type[1:]) + u"</p>" elif type[0] == "h" and path.startswith(u"URL:"): content += u"<p><a href=\"" + path[4:] + u"\">" + self.html( type[1:]) + u"</a></p>" elif type[0] == "0": content += u"<p><a href=\"gopher://" + host + u":" + port + path + u"?type=text\">" + self.html( type[1:]) + u"</a></p>" elif type[0] == "1": content += u"<p><a href=\"gopher://" + host + u":" + port + path + u"\">" + self.html( type[1:]) + u"</a></p>" elif type[0] == "4": content += u"<p><a href=\"gopher://" + host + u":" + port + path + u"?type=binhex\">" + self.html( type[1:]) + u"</a></p>" elif type[0] == "5": content += u"<p><a href=\"gopher://" + host + u":" + port + path + u"?type=dos\">" + self.html( type[1:]) + u"</a></p>" elif type[0] == "6": content += u"<p><a href=\"gopher://" + host + u":" + port + path + u"?type=uuencoded\">" + self.html( type[1:]) + u"</a></p>" elif type[0] == "9": content += u"<p><a href=\"gopher://" + host + u":" + port + path + u"?type=binary\">" + self.html( type[1:]) + u"</a></p>" elif type[0] == "g": content += u"<img src=\"gopher://" + host + u":" + port + path + u"?type=binary\">" + self.html( type[1:]) + u"</img>" elif type[0] == "I": content += u"<img src=\"gopher://" + host + u":" + port + path + u"?type=binary\">" + self.html( type[1:]) + u"</img>" content += (u"</body>\n" u"</html>\n") self.content = content.encode("utf-8") self.setHeader(QNetworkRequest.ContentTypeHeader, QVariant("text/html; charset=UTF-8")) self.setHeader(QNetworkRequest.ContentLengthHeader, QVariant(len(self.content))) self.readyRead.emit() self.finished.emit() # QIODevice methods def abort(self): pass def bytesAvailable(self): return len(self.content) - self.offset def isSequential(self): return True def readData(self, maxSize): if self.offset < len(self.content): end = min(self.offset + maxSize, len(self.content)) data = self.content[self.offset:end] self.offset = end return data