python类timeout_add_seconds()的实例源码

def instance_launch(self, image, instancetype):
        launch.launch(config, image, instancetype)
        GLib.timeout_add_seconds(10, self.handler_poll_onetime)

def instance_kill(self, job_number, target_image):
        res = requests.get('%s/shutdown?username=%s&apikey=%s&number=%s' % (api_url, username, apikey, job_number))
        res = json.loads(res.content.decode('utf-8'))
        GLib.timeout_add_seconds(10, self.handler_poll_onetime)

def run_loop(self):
        xml = self.read_nvidia()
        idx = 0
        for gpu in xml.gpu:
            self.update_gpu(idx, gpu)
            idx = idx + 1
        # end with another loop
        GLib.timeout_add_seconds(1, self.run_loop)

def retry(self):
        logger.debug('retrying weather update after an error, retry timeout: {}'.format(self.retry_timeout))

        self.update_weather(setup_retry=False)  # Don't create a bunch of timeouts, could get ugly
        if self.error:
            self.retry_timeout += 1

            if self.retry_timeout >= 15:
                self.retry_timeout = 15

            GLib.timeout_add_seconds(60 * self.retry_timeout, self.retry)

        return False  # Don't let the timeout continue to run as we do an incremental backoff

def run(self):
        self._setup_actions()
        self._setup_menu()

        self.bus.export_action_group(BUS_OBJECT_PATH, self.action_group)
        self.menu_export = self.bus.export_menu_model(BUS_OBJECT_PATH_PHONE, self.menu)

        GLib.timeout_add_seconds(60 * 30, self.update_weather)  # TODO allow this to be configurable
        self.update_weather()

def __init__(self, interval=None, configfile=None, platform=None, datadir=None):
        self.configfile, self.datadir, self.default_config = find_config(configfile, datadir)

        if platform:
            self.platform = getattr(platforms, platform, None)
            if self.platform is None:
                logging.error("No such platform: `{}'".format(platform))
                sys.exit(1)
        else:
            self.platform = platforms.find()
        self.data = self.played = self.notified = {}

        self.icon = Gtk.StatusIcon()
        self.icon.set_name('Battray')

        self.menu = Gtk.Menu()
        refresh = Gtk.MenuItem.new_with_label('Refresh')
        refresh.connect('activate', self.cb_update)
        self.menu.append(refresh)

        about = Gtk.MenuItem.new_with_label('About')
        about.connect('activate', self.cb_about)
        self.menu.append(about)

        quit = Gtk.MenuItem.new_with_label('Quit')
        quit.connect('activate', self.cb_destroy)
        self.menu.append(quit)

        self.icon.connect('activate', self.cb_update)
        self.icon.connect('popup-menu', self.cb_popup_menu)
        self.icon.set_visible(True)

        self.update_status()
        GLib.timeout_add_seconds(interval or 15, self.update_status)

def on_tasks_file_changed(self, monitor, file, other_file, event_type):
        if event_type == Gio.FileMonitorEvent.CHANGES_DONE_HINT:
            self.check_reload_tasks()
        else:
            GLib.timeout_add_seconds(1, self.check_reload_tasks)

def _add_timeout(self):
        if self._id:
            GLib.source_remove(self._id)
        self._id = GLib.timeout_add_seconds(self.timeout, self._run_func)

def on_btNext_clicked(self, *a):
        rvController = self.builder.get_object("rvController")
        tvDevices = self.builder.get_object("tvDevices")
        stDialog = self.builder.get_object("stDialog")
        btBack = self.builder.get_object("btBack")
        btNext = self.builder.get_object("btNext")
        pages = stDialog.get_children()
        index = pages.index(stDialog.get_visible_child())
        if index == 0:
            model, iter = tvDevices.get_selection().get_selected()
            dev = evdev.InputDevice(model[iter][0])
            if (dev.info.vendor, dev.info.product) == (0x054c, 0x09cc):
                # Special case for PS4 controller
                cbDS4 = self.builder.get_object("cbDS4")
                imgDS4 = self.builder.get_object("imgDS4")
                imgDS4.set_from_file(os.path.join(
                        self.app.imagepath, "ds4-small.svg"))
                cbDS4.set_active(Config()['drivers']['ds4drv'])
                stDialog.set_visible_child(pages[3])
                btBack.set_sensitive(True)
                btNext.set_label("_Restart Emulation")
                return
            stDialog.set_visible_child(pages[1])
            self.load_buttons()
            self.refresh_controller_image()
            rvController.set_reveal_child(True)
            self.load_buttons()
            self.refresh_controller_image()
            btBack.set_sensitive(True)
        elif index == 1:
            # Disable Next button and determine which driver should be used
            btNext.set_sensitive(False)
            model, iter = tvDevices.get_selection().get_selected()
            dev = evdev.InputDevice(model[iter][0])
            self.prepare_registration(dev)
        elif index == 2:
            self.save_registration()
        elif index == 3:
            # Next pressed on DS4 info page
            # where it means 'Restart Emulation and close'
            self.app.dm.stop()
            GLib.timeout_add_seconds(1, self.app.dm.start)
            self.kill_tester()
            self.window.destroy()

def update_cpu_speeds(self):
        label = 'failed'
        try:
            jobslist = jobs.get_jobs(config)
            label = ''
            for item in self.instance_items:
                self.menu.remove(item)
            self.instance_items.clear()
            for job in jobslist:
                if label != '':
                     label += ' '
                if job['status'] in ['SUBMITTED']:
                    label += '(' + job['type'] + ')'
                    GLib.timeout_add_seconds(10, self.handler_poll_onetime)  # fast poll whilst wait for it to start
                else:
                    label += job['type']

                item = Gtk.MenuItem()
                item.set_label('ssh to %s' % job['image'])
                item.connect("activate", self.handler_instance_ssh)
                item.target_image = job['image']
                item.job_number = job['number']
                item.show()
                self.menu.insert(item, 0)
                self.instance_items.append(item)

                item = Gtk.MenuItem()
                item.set_label('kill %s' % job['image'])
                item.connect("activate", self.handler_instance_kill)
                item.target_image = job['image']
                item.job_number = job['number']
                item.show()
                self.menu.insert(item, 0)
                self.instance_items.append(item)

        except Exception as e:
            label = 'exception occurred'
            try:
                print(traceback.format_exc())
            except:
                print('exception in exception :-P')
        self.ind.set_label(label, "")