def main(): opts = get_config() #dbus.glib.threads_init() #glib.theads_init() bus_loop = DBusGMainLoop(set_as_default=True) main_loop = glib.MainLoop() bus = dbus.SystemBus() bluez_proxy = bus.get_object('org.bluez', '/') bluez_manager = dbus.Interface(bluez_proxy, 'org.bluez.Manager') if opts.adapter is not None: adapter = bluez_manager.FindAdapter(opts.adapter) else: adapter = bluez_manager.DefaultAdapter() bd_path = '%s/dev_%s' % (adapter, opts.bdaddr.upper().replace(':', '_')) def input_callback(*args): # print 'INPUT: %s' % repr(args) main_loop.quit() return True # What return value signifies what? glib.io_add_watch(sys.stdin, glib.IO_IN, input_callback) try: bluez_net_monitor = BluezNetMonitor(bus, bd_path, main_loop, opts.reconnect) except dbus.exceptions.DBusException as e: return 1 print 'Press enter to close connection' main_loop.run()
def _configure_io_handler(self, handler): """Register an io-handler with the glib main loop.""" if self.check_events(): return if handler in self._unprepared_handlers: old_fileno = self._unprepared_handlers[handler] prepared = self._prepare_io_handler(handler) else: old_fileno = None prepared = True fileno = handler.fileno() if old_fileno is not None and fileno != old_fileno: tag = self._io_sources.pop(handler, None) if tag is not None: glib.source_remove(tag) if not prepared: self._unprepared_handlers[handler] = fileno if fileno is None: logger.debug( " {0!r}.fileno() is None, not polling".format(handler)) return events = 0 if handler.is_readable(): logger.debug(" {0!r} readable".format(handler)) events |= glib.IO_IN | glib.IO_ERR if handler.is_writable(): logger.debug(" {0!r} writable".format(handler)) events |= glib.IO_OUT | glib.IO_HUP | glib.IO_ERR if events: logger.debug(" registering {0!r} handler fileno {1} for" " events {2}".format(handler, fileno, events)) glib.io_add_watch(fileno, events, self._io_callback, handler)
def __init__(self): self.__init_curses() self.__bus = ibus.Bus() self.__ic_path = self.__bus.create_input_context("DemoTerm") self.__ic = ibus.InputContext(self.__bus, self.__ic_path, True) self.__ic.set_capabilities(7) self.__ic.connect("commit-text", self.__commit_text_cb) self.__ic.connect("update-preedit-text", self.__update_preedit_text_cb) self.__ic.connect("show-preedit-text", self.__show_preedit_text_cb) self.__ic.connect("hide-preedit-text", self.__hide_preedit_text_cb) self.__ic.connect("update-auxiliary-text", self.__update_aux_text_cb) self.__ic.connect("show-auxiliary-text", self.__show_aux_text_cb) self.__ic.connect("hide-auxiliary-text", self.__hide_aux_text_cb) self.__ic.connect("update-lookup-table", self.__update_lookup_table_cb) self.__ic.connect("show-lookup-table", self.__show_lookup_table_cb) self.__ic.connect("hide-lookup-table", self.__hide_lookup_table_cb) glib.io_add_watch(0, glib.IO_IN, self.__stdin_cb) # glib.timeout_add(500, self.__timeout_cb) # self.__master_fd, self.__slave_fd = os.openpty() # self.__run_shell() self.__is_invalidate = False self.__preedit = None self.__preedit_visible = False self.__aux_string = None self.__aux_string_visible = False self.__lookup_table = None self.__lookup_table_visible = False
def main(): opts = get_config() #dbus.glib.threads_init() #glib.theads_init() bus_loop = DBusGMainLoop(set_as_default=True) main_loop = glib.MainLoop() bus = dbus.SystemBus() # FIXME: BROKEN IN BLUEZ 5!!!! adapter = fucking_bluez_devs_hate_backwards_compatibility_what_bloody_arseholes( bus, opts.adapter) bd_path = '%s/dev_%s' % (adapter, opts.bdaddr.upper().replace(':', '_')) def input_callback(*args): # print 'INPUT: %s' % repr(args) main_loop.quit() return True # What return value signifies what? glib.io_add_watch(sys.stdin, glib.IO_IN, input_callback) try: bluez_net_monitor = BluezNetMonitor(bus, bd_path, main_loop, opts.reconnect) except dbus.exceptions.DBusException as e: return 1 print 'Press enter to close connection' main_loop.run() # Bluez 5 now seem to require manual disconnection... probably for the best, # but an incompatible change none the less: bluez_net_monitor.disconnect()
def __init__(self): self.__init_curses() self.__bus = ibus.Bus() self.__ic = self.__bus.create_input_context("DemoTerm") self.__bus.set_capabilities(self.__ic, 7) self.__bus.connect("commit-string", self.__commit_string_cb) self.__bus.connect("update-preedit", self.__update_preedit_cb) self.__bus.connect("show-preedit", self.__show_preedit_cb) self.__bus.connect("hide-preedit", self.__hide_preedit_cb) self.__bus.connect("update-aux-string", self.__update_aux_string_cb) self.__bus.connect("show-aux-string", self.__show_aux_string_cb) self.__bus.connect("hide-aux-string", self.__hide_aux_string_cb) self.__bus.connect("update-lookup-table", self.__update_lookup_table_cb) self.__bus.connect("show-lookup-table", self.__show_lookup_table_cb) self.__bus.connect("hide-lookup-table", self.__hide_lookup_table_cb) glib.io_add_watch(0, glib.IO_IN, self.__stdin_cb) # glib.timeout_add(500, self.__timeout_cb) # self.__master_fd, self.__slave_fd = os.openpty() # self.__run_shell() self.__is_invalidate = False self.__preedit = "" self.__preedit_visible = False self.__aux_string = "" self.__aux_string_visible = False self.__lookup_table = None self.__lookup_table_visible = False
def __init__(self, device_name, printer_class=None, baudrate=9600, printer=None, delay=5): """ @param device_name: @param printer_class: @param delay: """ if not printer and not printer_class: raise TypeError gobject.GObject.__init__(self) self._reply = '' self._device_name = device_name self._delay = delay self._baudrate = baudrate if printer_class: port = self._create_port() printer = printer_class(port) else: port = printer.get_port() self._port = port self.printer = printer self._add_timeout() if port is not None: glib.io_add_watch(port, glib.IO_OUT, self._fd_watch_out) glib.io_add_watch(port, glib.IO_IN, self._fd_watch_in)
def _connect_socket(address, callback): def ready(sock, cond): if not cond & (glib.IO_OUT | glib.IO_ERR): return True # Get error code err = sock.getsockopt(socket.SOL_SOCKET, socket.SO_ERROR) if err: # os.strerror() can't convert WinSock error codes, but the # socket module has an undocumented mapping table errortab = getattr(socket, 'errorTab', {}) callback(error=errortab.get(err, os.strerror(err))) sock.close() else: sock.setblocking(1) callback(sock=sock) return False try: sock = socket.socket() sock.setblocking(0) sock.connect(address) except socket.error, e: # EWOULDBLOCK on Windows (actually WSAEWOULDBLOCK) if e.errno in (errno.EINPROGRESS, errno.EWOULDBLOCK): # IO_ERR on Windows glib.io_add_watch(sock, glib.IO_OUT | glib.IO_ERR, ready) else: callback(error=str(e)) sock.close()
def start_scanner(self, widget): self._count = 0 buf = self.text.get_buffer().set_text('') video_dev = self.device_list['video'][self.video_combo.get_active()] tty_dev = self.device_list['tty'][self.tty_combo.get_active()] path = self.xml.get_widget('target_path').get_current_folder() steps = [1, 2, 4, 8][int(self.xml.get_widget('scan-degree-combo').get_active())] #steps = [steps] widget.set_sensitive(False) self.xml.get_widget('main_stop').set_sensitive(True) frame = self.xml.get_widget('scanner-settings-frame') frame.set_sensitive(False) #script = 'pylatscan_cli' #script = os.path.realpath('%s/../run_scanner.py' % os.path.dirname(__file__)); script = os.path.realpath('%s/scanner_cli.py' % os.path.dirname(__file__)) cmd = [ 'python', '-u', script, '-s%d' % steps, '-x', '640', '-y', '480', '-t', tty_dev, '-d', video_dev, path ] print str.join(' ', cmd) self.proc = sp.Popen(cmd, stdout=sp.PIPE) glib.io_add_watch(self.proc.stdout, glib.IO_IN, self.update_status) glib.io_add_watch(self.proc.stdout, glib.IO_HUP, self.stop_scanner)
def __init__(self, line_callback): self.buffer = '' self.line_callback = line_callback flags = fcntl.fcntl(sys.stdin.fileno(), fcntl.F_GETFL) flags |= os.O_NONBLOCK fcntl.fcntl(sys.stdin.fileno(), fcntl.F_SETFL, flags) glib.io_add_watch(sys.stdin, glib.IO_IN, self.io_callback)
def set_up_extraction_process(status): """ run process_ballot_on_input in separate Python, asking it to extract one ballot per request and print back the number of the processed ballot. """ global extraction_stdin global extraction_stdout global extraction_stderr global extraction_object global extraction_pid try: extraction_object = subprocess.Popen( ["/usr/bin/python", "process_ballot_on_input.py"], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, close_fds = True) extraction_pid = extraction_object.pid (extraction_stdin, extraction_stdout, extraction_stderr) = (extraction_object.stdin, extraction_object.stdout, extraction_object.stderr) glib.io_add_watch(extraction_object.stdout, glib.IO_IN, data_available_from_extraction_process, status) glib.io_add_watch(extraction_object.stdout, glib.IO_HUP, extraction_process_done, status) return extraction_pid except Exception,e: print e return -1
def main(): opts = get_config() # dbus.glib.threads_init() # glib.theads_init() bus_loop = DBusGMainLoop(set_as_default=True) main_loop = glib.MainLoop() bus = dbus.SystemBus() # FIXME: BROKEN IN BLUEZ 5!!!! adapter = fucking_bluez_devs_hate_backwards_compatibility_what_bloody_arseholes(bus, opts.adapter) bd_path = "%s/dev_%s" % (adapter, opts.bdaddr.upper().replace(":", "_")) def input_callback(*args): # print 'INPUT: %s' % repr(args) main_loop.quit() return True # What return value signifies what? glib.io_add_watch(sys.stdin, glib.IO_IN, input_callback) try: bluez_net_monitor = BluezNetMonitor(bus, bd_path, main_loop, opts.reconnect) except dbus.exceptions.DBusException as e: return 1 print "Press enter to close connection" main_loop.run() # Bluez 5 now seem to require manual disconnection... probably for the best, # but an incompatible change none the less: bluez_net_monitor.disconnect()
def start_scanner( self, widget ): self._count = 0 buf = self.text.get_buffer().set_text('') video_dev = self.device_list['video'][self.video_combo.get_active()] tty_dev = self.device_list['tty'][self.tty_combo.get_active()] path = self.xml.get_widget( 'target_path' ).get_current_folder() steps = [1,2,4,8][int(self.xml.get_widget( 'scan-degree-combo' ).get_active())] #steps = [steps] widget.set_sensitive( False ) self.xml.get_widget( 'main_stop' ).set_sensitive(True) frame = self.xml.get_widget('scanner-settings-frame') frame.set_sensitive( False ) #script = 'pylatscan_cli' #script = os.path.realpath('%s/../run_scanner.py' % os.path.dirname(__file__)); script = os.path.realpath( '%s/scanner_cli.py' % os.path.dirname(__file__)); cmd = ['python', '-u', script, '-s%d'%steps, '-x', '640', '-y', '480', '-t', tty_dev, '-d', video_dev, path] print str.join( ' ', cmd ) self.proc = sp.Popen(cmd,stdout=sp.PIPE) glib.io_add_watch(self.proc.stdout, glib.IO_IN, self.update_status) glib.io_add_watch(self.proc.stdout, glib.IO_HUP, self.stop_scanner)
def _configure_io_handler(self, handler): """Register an io-handler with the glib main loop.""" if self.check_events(): return if handler in self._unprepared_handlers: old_fileno = self._unprepared_handlers[handler] prepared = self._prepare_io_handler(handler) else: old_fileno = None prepared = True fileno = handler.fileno() if old_fileno is not None and fileno != old_fileno: tag = self._io_sources.pop(handler, None) if tag is not None: glib.source_remove(tag) if not prepared: self._unprepared_handlers[handler] = fileno if fileno is None: logger.debug(" {0!r}.fileno() is None, not polling" .format(handler)) return events = 0 if handler.is_readable(): logger.debug(" {0!r} readable".format(handler)) events |= glib.IO_IN | glib.IO_ERR if handler.is_writable(): logger.debug(" {0!r} writable".format(handler)) events |= glib.IO_OUT | glib.IO_HUP | glib.IO_ERR if events: logger.debug(" registering {0!r} handler fileno {1} for" " events {2}".format(handler, fileno, events)) glib.io_add_watch(fileno, events, self._io_callback, handler)
def main(): opts = get_config() #dbus.glib.threads_init() #glib.theads_init() bus_loop = DBusGMainLoop(set_as_default = True) main_loop = glib.MainLoop() bus = dbus.SystemBus() bluez_proxy = bus.get_object('org.bluez', '/') bluez_manager = dbus.Interface(bluez_proxy, 'org.bluez.Manager') if opts.adapter is not None: adapter = bluez_manager.FindAdapter(opts.adapter) else: adapter = bluez_manager.DefaultAdapter() bd_path = '%s/dev_%s' % (adapter, opts.bdaddr.upper().replace(':', '_')) def input_callback(*args): # print 'INPUT: %s' % repr(args) main_loop.quit() return True # What return value signifies what? glib.io_add_watch(sys.stdin, glib.IO_IN, input_callback) try: bluez_net_monitor = BluezNetMonitor(bus, bd_path, main_loop, opts.reconnect) except dbus.exceptions.DBusException as e: return 1 print 'Press enter to close connection' main_loop.run()
def main(): listen_sock = setup_socket() glib.io_add_watch(listen_sock.fileno(), glib.IO_IN, gui_callback, listen_sock); try: gtk.main() except: listen_sock.close()
def __init__ (self, port, obj, address = '', backlog = 5, tls = None, disconnect_cb = None): '''Listen on a port and accept connections. Set tls to a key+certificate file to use tls.''' self._disconnect_cb = disconnect_cb self.group = None self.obj = obj self.port = '' self.ipv6 = False self.socket = None self.tls = tls self.connections = set () if isinstance (port, str) and '/' in port: # Unix socket. # TLS is ignored for these sockets. self.tls = False self.socket = socket.socket (socket.AF_UNIX) self.socket.bind (port) self.port = port self.socket.listen (backlog) elif have_avahi and isinstance (port, str) and '|' in port: self._tls_init () self.socket = socket.socket () self.socket.setsockopt (socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) if address == '': self.socket6 = socket.socket (socket.AF_INET6) self.socket6.setsockopt (socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) info = port.split ('|') self.port = port if len (info) > 2: self.socket.bind ((address, lookup (info[2]))) self.socket.listen (backlog) if address == '': p = self.socket.getsockname ()[1] self.socket6.bind (('::1', p)) self.socket6.listen (backlog) self.ipv6 = True bus = dbus.SystemBus () server = dbus.Interface (bus.get_object (avahi.DBUS_NAME, avahi.DBUS_PATH_SERVER), avahi.DBUS_INTERFACE_SERVER) self.group = dbus.Interface (bus.get_object (avahi.DBUS_NAME, server.EntryGroupNew ()), avahi.DBUS_INTERFACE_ENTRY_GROUP) self.group.AddService (avahi.IF_UNSPEC, avahi.PROTO_UNSPEC, dbus.UInt32 (0), info[1], '_%s._tcp' % info[0], '', '', dbus.UInt16 (self.socket.getsockname ()[1]), '') self.group.Commit () else: self._tls_init () port = lookup (port) self.socket = socket.socket () self.socket.setsockopt (socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) self.socket.bind ((address, port)) self.socket.listen (backlog) if address == '': self.socket6 = socket.socket (socket.AF_INET6) self.socket6.setsockopt (socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) self.socket6.bind (('::1', port)) self.socket6.listen (backlog) self.ipv6 = True self.port = port fd = self.socket.fileno () glib.io_add_watch (fd, glib.IO_IN | glib.IO_PRI, self._cb) if self.ipv6: fd = self.socket6.fileno () glib.io_add_watch (fd, glib.IO_IN | glib.IO_PRI, self._cb)
def __init__(self, ipmi_obj): self.buffer = "" self.seq = 0 self.ipmi_obj = ipmi_obj flags = fcntl.fcntl(sys.stdin.fileno(), fcntl.F_GETFL) flags |= os.O_NONBLOCK fcntl.fcntl(sys.stdin.fileno(), fcntl.F_SETFL, flags) glib.io_add_watch(sys.stdin, glib.IO_IN, self.io_callback)
def input_add(self, source, condition, callback): if hasattr(source, 'fileno'): # handle python objects def wrapper(source, condition, real_s=source, real_cb=callback): return real_cb(real_s, condition) return glib.io_add_watch(source.fileno(), condition, wrapper) else: return glib.io_add_watch(source, condition, callback)
def __init__(self, ipmi_obj): self.buffer = '' self.seq = 0 self.ipmi_obj = ipmi_obj flags = fcntl.fcntl(sys.stdin.fileno(), fcntl.F_GETFL) flags |= os.O_NONBLOCK fcntl.fcntl(sys.stdin.fileno(), fcntl.F_SETFL, flags) glib.io_add_watch(sys.stdin, glib.IO_IN, self.io_callback)
def run(self): ''' RUNS THE PROCESS ''' proc = subprocess.Popen(self.command, stdout=subprocess.PIPE) # SPAWNING glib.io_add_watch( proc.stdout, # FILE DESCRIPTOR glib.IO_IN, # CONDITION self.write_to_buffer) # CALLBACK
def main(): widget = MyDotWidget() glib.io_add_watch(sys.stdin, # FILE DESCRIPTOR glib.IO_IN, # CONDITION widget.on_input_response) # CALLBACK gtk.main()
def consume_pty(editor, proc, master, on_finish): console = get_console_widget(editor) buf = console.view.get_buffer() buf.delete(*buf.get_bounds()) unblock_fd(master) glib.io_add_watch(master, glib.IO_IN|glib.IO_ERR|glib.IO_HUP, consume_io, editor, console, proc, on_finish) pty_master[0] = master
def open(m): m.open_file() m.expect_message = None m.expect_next = "" m.expect_reason = "" m.line_buf = "" # | glib.IO_OUT | glib.IO_PRI | glib.IO_ERR | glib.IO_HUP glib.io_add_watch(m.at, glib.IO_IN, m.data_ready, m) m.l = "\r"
def RegisterForUdevMonitor(self): # have udevadm output to a pty so it will line buffer (master, slave) = pty.openpty() monitor = self.Popen(['udevadm', 'monitor'], stdout=os.fdopen(slave), bufsize=1) glib.io_add_watch(os.fdopen(master), glib.IO_IN | glib.IO_HUP, self.ExceptionWrapper(self.UdevOutputReceived))
def main(): widget = MyDotWidget() glib.io_add_watch( sys.stdin, # FILE DESCRIPTOR glib.IO_IN, # CONDITION widget.on_input_response) # CALLBACK gtk.main()
def run(self): # set up the control socket self.server_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.server_sock.bind(("", 8989)) self.server_sock.listen(1) glib.io_add_watch(self.server_sock, glib.IO_IN, self.__accept_listener) gobject.threads_init() loop = glib.MainLoop() loop.run()
def main(args): global manager global bus global mainloop global interactive global n_iterations # D-Bus initialization DBusGMainLoop(set_as_default=True) mainloop = gobject.MainLoop() bus = dbus.SystemBus() if not bus: print("ERROR: failed to get system bus") exit(1) # Create the manager for handling resource sets. manager_obj = None # TODO: get service and manager path from command line? try: manager_obj = bus.get_object('org.Murphy', '/org/murphy/resource') except: pass if not manager_obj: print("ERROR: failed get Murphy resource manager object") exit(1) manager = dbus.Interface(manager_obj, dbus_interface='org.murphy.manager') if (len(args) > 0 and args[0] == "fuzz"): interactive = False n_iterations = 1000 if (len(args) == 2): n_iterations = int(args[1]) if (len(args) == 3): limit = int(args[2]) glib.idle_add(fuzz_test) else: # interactive mode interactive = True manager.connect_to_signal("propertyChanged", mgr_handler, path_keyword='path') # make STDIN non-blocking fcntl.fcntl(sys.stdin.fileno(), fcntl.F_SETFL, os.O_NONBLOCK) # listen for user input glib.io_add_watch(sys.stdin, glib.IO_IN, stdin_cb) add_prompt() mainloop.run()
def open_server(self): try: self.sock.bind(self.sock_path) self.sock.listen(5) except: error_except(msg='-server') return False fd=self.sock.makefile() glib.io_add_watch(fd,glib.IO_IN|glib.IO_ERR|glib.IO_HUP,self.callback) return True
def __init__(self, displaier, sendMess, sendShutdown): self.buffer = '' self.line_callback = self.commandSwitch self.sendMess = sendMess self.displaier = displaier self.sendShutdown = sendShutdown flags = fcntl.fcntl(sys.stdin.fileno(), fcntl.F_GETFL) flags |= os.O_NONBLOCK fcntl.fcntl(sys.stdin.fileno(), fcntl.F_SETFL, flags) glib.io_add_watch(sys.stdin, glib.IO_IN, self.io_callback)
def consume_output(editor, proc, on_finish): console = get_console_widget(editor) buf = console.view.get_buffer() buf.delete(*buf.get_bounds()) unblock_fd(proc.stdout) unblock_fd(proc.stderr) glib.io_add_watch(proc.stdout, glib.IO_IN|glib.IO_ERR|glib.IO_HUP, consume_io, editor, console, proc, on_finish) glib.io_add_watch(proc.stderr, glib.IO_IN|glib.IO_ERR|glib.IO_HUP, consume_io, editor, console, proc, on_finish)
def run(self): self._findPlayer() glib.io_add_watch(sys.stdin, glib.IO_IN, self._processStdin) glib.io_add_watch(sys.stdin, glib.IO_HUP, self._processClose) try: self._loop.run() except KeyboardInterrupt: pass
def connect_callback(self, response): if "CONNECT" in response: dprint("Starting pppd") self.pppd = subprocess.Popen(["/usr/sbin/pppd", "%s" % self.port, "defaultroute", "updetach", "usepeerdns"], bufsize=1, stdout=subprocess.PIPE) glib.io_add_watch(self.pppd.stdout, glib.IO_IN | glib.IO_ERR | glib.IO_HUP, self.on_pppd_stdout) glib.timeout_add(1000, self.check_pppd) self.cleanup() else: self.cleanup() raise PPPException("Bad modem response %s, expected CONNECT" % response[0])
def run(self): global read_pipe global main_window glib.io_add_watch(read_pipe, glib.IO_IN, self.handle_queue) main_window = gui.MyWindow() main_window.init(gdb) main_window.connect("delete-event", gtk.main_quit) main_window.show_all() gtk.main()
def start (self): """ Start the subprocess and begin collecting results from it. """ with open ("/dev/null", "r") as null: child = subprocess.Popen ([sys.argv[0], "--subprocess", self.__player_name, self.__daemon_prefix, self.__prefix, self.__user, self.__password] + self.__test_names, shell = False, close_fds = True, preexec_fn = os.setsid, stdin = null, stdout = subprocess.PIPE, env = self.__env) glib.io_add_watch (child.stdout, glib.IO_IN | glib.IO_HUP, self.__child_io_cb)
def listener(self, source, condition, sock): conn, addr = sock.accept() conn.setblocking(False) oid = id(conn) self.__connections[oid] = conn self.__oids[oid] = None glib.io_add_watch(conn, glib.IO_IN | glib.IO_HUP, self._data_callback, oid) return True
def create_peer_socket(self): import socket sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, True) sock.bind(("", self.port)) glib.io_add_watch(sock, glib.IO_IN, self.peer_socket_event) self.peersock = sock # self.peeraddrs = set() self.send_peer_announce()
def __init__ (self, test_widget_size=(640,480), trigger_set=None): self.fail = True label = gtk.Label("摄像头测试,成功按回车键,失败按Tab键\n") label.modify_font(pango.FontDescription('courier new condensed 20')) label.modify_fg(gtk.STATE_NORMAL, gdk.color_parse('light green')) test_widget = gtk.VBox() test_widget.modify_bg(gtk.STATE_NORMAL, gdk.color_parse('black')) test_widget.add(label) self.test_widget = test_widget self.img = None dev = v4l2.Device(DEVICE_NAME) if not dev.cap.capabilities & v4l2.V4L2_CAP_VIDEO_CAPTURE: raise ValueError("%s doesn't support video capture interface" % (DEVICE_NAME, )) if not dev.cap.capabilities & v4l2.V4L2_CAP_STREAMING: raise ValueError("%s doesn't support streaming I/O" % (DEVICE_NAME, )) glib.io_add_watch(dev.fd, glib.IO_IN, lambda *x:dev.capture_mmap_shot(self.render) or True, priority=glib.PRIORITY_LOW) frame_size = self.get_best_frame_size(dev, v4l2.V4L2_PIX_FMT_YUYV, PREFERRED_WIDTH, PREFERRED_HEIGHT) adj_fmt = dev.capture_set_format(frame_size[0], frame_size[1], v4l2.V4L2_PIX_FMT_YUYV, v4l2.V4L2_FIELD_INTERLACED) width, height = adj_fmt.fmt.pix.width, adj_fmt.fmt.pix.height self.pixbuf = gdk.Pixbuf(gdk.COLORSPACE_RGB, False, 8, width, height) self.pixels = self.pixbuf.get_pixels_array() self.img = gtk.image_new_from_pixbuf(self.pixbuf); self.test_widget.add(self.img) self.img.show() dev.capture_mmap_prepare(PREFERRED_BUFFER_COUNT, 2) dev.capture_mmap_start() self.run_test_widget( test_widget=test_widget, test_widget_size=test_widget_size) dev.capture_mmap_stop() dev.capture_mmap_finish()
def create_peer_socket(self): import socket sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, True) sock.bind(("", self.port)) glib.io_add_watch( sock, glib.IO_IN, self.peer_socket_event) self.peersock = sock #self.peeraddrs = set() self.send_peer_announce()
def run(self): glib.idle_add(self.__start_cb) glib.io_add_watch(0, glib.IO_IN, self.__stdin_cb) glib.io_add_watch(0, glib.IO_ERR | glib.IO_HUP, self.__io_error_cb) while True: try: super(IBusModeMainLoop, self).run() except: import traceback print_command('error', traceback.format_exc()) else: break for ic in imcontexts: if ic: ic.destroy()
def start(self): self.p= subprocess.Popen(self.cmdline_array, bufsize = 0, close_fds = True, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.STDOUT) #(self.stdin,self.stdout,self.stderr) = ( # self.p.stdin,self.p.stdout,self.p.stderr) self.pid = self.p.pid self.stdout_watch_id = glib.io_add_watch( self.p.stdout,glib.IO_IN,self.receive_stdout,self.data) #if self.hup_cb is not None: self.hup_watch_id = glib.io_add_watch( self.p.stdout,glib.IO_HUP,self.receive_hup, None)
def ChannelConnected(self, channel, interface, device): #print "Device %s channel %s up" % (device, channel) channel = bus.get_object("org.bluez", channel) channel = dbus.Interface(channel, "org.bluez.HealthChannel1") fd = channel.Acquire() #print "Got raw rd %s" % fd # take fd ownership fd = fd.take() #print "FD number is %d" % fd # encapsulate numericfd in Python socket object sk = socket.fromfd(fd, socket.AF_UNIX, socket.SOCK_STREAM) # fromfd() does dup() so we need to close the original os.close(fd) #print "FD acquired" glib.io_add_watch(sk, watch_bitmap, data_received)
def start_processing( self ): script = os.path.realpath( '%s/parser_cli.py' % os.path.dirname(__file__)); do_left = self.xml.get_widget('radiobutton_scan_left').get_active() do_right = self.xml.get_widget('radiobutton_scan_right').get_active() do_both = self.xml.get_widget('radiobutton_scan_both').get_active() #print "left, right, both?", do_left, do_right, do_both filename = self.xml.get_widget( "entry_output_file").get_text() basepath = self.xml.get_widget( 'fileselect_target_path' ).get_current_folder() path = "%s%s%s.wrl" % ( basepath, os.sep, self.safe_filename(filename,basepath) ) left, top, width, height = [str(int(i)) for i in self.roi] cmd = [ 'python', '-u', script, '-x', left, '-y', top, '-w', width, '-g', height, '-f', path, self.xml.get_widget( 'fileselect_source_path' ).get_current_folder() ] if do_both: #print "do both" cmd.extend(['-l','-r']) elif do_left: #print "do left" cmd.append('-r') elif do_right: #print "do right" cmd.append('-l') # #print str.join( ' ', cmd ) self.current_safe_path = path self.set_status_bar( str.join( ' ', cmd ) ) self.proc = sp.Popen(cmd,stdout=sp.PIPE) self.events.append(glib.io_add_watch(self.proc.stdout, glib.IO_IN, self.status_processing)) self.events.append(glib.io_add_watch(self.proc.stdout, glib.IO_HUP, self.stop_processing))
def start(self): self.p= subprocess.Popen(self.cmdline_array, bufsize = 0, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE) (self.stdin,self.stdout,self.stderr) = ( self.p.stdin,self.p.stdout,self.p.stderr) self.pid = self.p.pid self.stdout_watch_id = glib.io_add_watch( self.p.stdout,glib.IO_IN,self.receive_stdout,self.data) self.stderr_watch_id = glib.io_add_watch( self.p.stderr,glib.IO_IN,self.receive_stderr,self.data) #if self.hup_cb is not None: self.hup_watch_id = glib.io_add_watch( self.p.stdout,glib.IO_HUP,self.receive_hup, None)
def initialize(self): # Prepare environment for local controllers LocalController.setup_environment() http_server = HttpServer(self._options, self) host = self._options['http_host'] port = self._options['http_port'] self._http = Thread(target=http_server.run, kwargs={"host": host, "port": port, "threaded": True}) # The http server should exit when the main thread terminates self._http.daemon = True self._http.start() self._listen = socket.socket() self._listen.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) self._listen.bind((self._options['host'], self._options['port'])) self._listen.listen(16) self._listen.setblocking(0) self._listen_source = glib.io_add_watch(self._listen, glib.IO_IN, self._accept) # Start garbage collection self._gc_timer = glib.timeout_add_seconds(self._options['gc_interval'], self._gc) self.running = True
def __init__(self): #Creates a new instance of gtp with which to interface with GnuGo args = shlex.split("/usr/games/gnugo --mode gtp") self.proc = subprocess.Popen(args, stdin=subprocess.PIPE, stdout=subprocess.PIPE) (self.infile, self.outfile) = (self.proc.stdin, self.proc.stdout) self.watch = glib.io_add_watch(self.outfile,glib.IO_IN, self.__gnugo_write_callback) self.waiting = False
def _update(self): if self._sock is None: return if (self._send_closing and not self._send_closed and not self._send_buf): try: self._sock.shutdown(socket.SHUT_WR) except socket.error: pass self._send_closed = True if self._send_close_timeout_source is not None: glib.source_remove(self._send_close_timeout_source) self._send_close_timeout_source = None if self._send_closed and self._recv_closed: if self._source is not None: glib.source_remove(self._source) self._source = None self._sock.close() self._sock = None self.emit('close') return cond = 0 if self._recv_callback is not None and not self._recv_closed: cond |= glib.IO_IN if self._send_buf and not self._send_closed: cond |= glib.IO_OUT if self._source is not None: glib.source_remove(self._source) self._source = glib.io_add_watch(self._sock, cond, self._io_ready)
def start(self): # Start server try: uri = self.notebookcombobox.get_notebook() if uri: notebook, x = build_notebook(NotebookInfo(uri)) if not notebook: return else: return port = int(self.portentry.get_value()) public = self.public_checkbox.get_active() self.httpd = make_server(notebook, port, public, **self.interface_opts) if sys.platform == 'win32': # glib io watch conflicts with socket use on windows.. # idle handler uses a bit to much CPU for my taste, # timeout every 0.5 sec is better self.httpd.timeout = 0.1 # 100 ms self._source_id = glib.timeout_add(500, self.do_serve_on_poll) else: self.httpd.timeout = 3 # if no response after 3 sec, drop it self._source_id = glib.io_add_watch( self.httpd.fileno(), glib.IO_IN | glib.IO_OUT | glib.IO_ERR | glib.IO_HUP | glib.IO_PRI, # any event.. self.do_serve_on_io) logger.info("Serving HTTP on %s port %i...", self.httpd.server_name, self.httpd.server_port) except Exception, error: ErrorDialog(self, error).run() return
def enabled(self, value): if value and self.event_source is None: # pylint: disable=attribute-defined-outside-init self.event_source = glib.io_add_watch(self.monitor, glib.IO_IN, self._process_udev_event) elif not value and self.event_source is not None: glib.source_remove(self.event_source)
def set_close_callback(self, callback): if self.__close_id: glib.source_remove(self.__close_id) self.__close_callback = callback self.__close_id = glib.io_add_watch(self.__socket, glib.IO_HUP|glib.IO_ERR, self.__on_close_callback)