Python GObject.timeout_add方法代码示例

# 需要导入模块: from gi.repository import GObject [as 别名]
# 或者: from gi.repository.GObject import timeout_add [as 别名]
def run(self, ttl=None):
        if self.DISABLE_SSDP_LISTENER:
            return

        self.allow_reuse_address = True
        SocketServer.UDPServer.__init__(
            self, (self.host or '', self.SSDP_PORT), SSDPHandler)
        self.socket.setsockopt(
            socket.IPPROTO_IP,
            socket.IP_ADD_MEMBERSHIP,
            self._multicast_struct(self.SSDP_ADDRESS))
        self.socket.setsockopt(
            socket.IPPROTO_IP,
            socket.IP_MULTICAST_TTL,
            self.SSDP_TTL)

        if ttl:
            GObject.timeout_add(ttl * 1000, self.shutdown)

        setproctitle.setproctitle('ssdp_listener')
        self.serve_forever(self)
        logger.info('SSDPListener.run()') 

# 需要导入模块: from gi.repository import GObject [as 别名]
# 或者: from gi.repository.GObject import timeout_add [as 别名]
def on_tn_entry_changed(self, widget):
        """ Callback: checks tag name validity and start value changes
        monitoring to decide when to update a tag's name."""
        self.tn_entry_last_recorded_value = self.get_tn_text()
        # check validity
        if self.tn_entry_last_recorded_value == "":
            self.tn_entry.set_icon_from_icon_name(
                Gtk.EntryIconPosition.SECONDARY, Gtk.STOCK_DIALOG_ERROR)
        else:
            self.tn_entry.set_icon_from_icon_name(
                Gtk.EntryIconPosition.SECONDARY, None)
        # filter out change requests to reduce commit overhead
        if self.tn_entry_watch_id is None:
            # There is no watchers for the text entry. Register one.
            # Also, wait 1 second before commiting the change in order to
            # reduce rename requests
            tn_entry_changes = self.watch_tn_entry_changes
            self.tn_entry_watch_id = GObject.timeout_add(1000, tn_entry_changes) 

# 需要导入模块: from gi.repository import GObject [as 别名]
# 或者: from gi.repository.GObject import timeout_add [as 别名]
def nudge_progress_bar (self):

        """Can be called by anything.

        Called by self.run() during the download operation.

        Also called by code in other files, just after that code adds a new
        media data object to our download list.

        Updates the main window's progress bar.
        """

        if DEBUG_FUNC_FLAG:
            utils.debug_time('dld 616 nudge_progress_bar')

        if self.current_item_obj:

            GObject.timeout_add(
                0,
                self.app_obj.main_win_obj.update_progress_bar,
                self.current_item_obj.media_data_obj.name,
                self.job_count,
                    len(self.download_list_obj.download_item_list),
            ) 

# 需要导入模块: from gi.repository import GObject [as 别名]
# 或者: from gi.repository.GObject import timeout_add [as 别名]
def on_query_changed(self, editor):
        if editor is None:
            self.lbl_query.set_text('')
            return
        query = editor.get_active_query()
        if query is None or query.failed:
            self.lbl_query.set_text('')
        elif query.finished:
            self.lbl_query.set_text(query.get_result_summary())
        elif query.pending:
            self.lbl_query.set_text('Pending...')
            GObject.timeout_add(10, self.on_query_changed, self._editor)
        else:
            duration = time.time() - query.start_time
            self.lbl_query.set_text('Running for {} seconds'.format(
                locale.format('%.3f', duration, grouping=True)))
            GObject.timeout_add(10, self.on_query_changed, self._editor) 

# 需要导入模块: from gi.repository import GObject [as 别名]
# 或者: from gi.repository.GObject import timeout_add [as 别名]
def load_book_data(self, filename):
        """
        Loads book to Viwer and moves to correct chapter and scroll position
        :param filename:
        """
        self.spinner.start()
        self.viewer.hide()
        self.right_box.add(self.spinner)
        self.filename = filename
        if not filename.upper().endswith(tuple(constants.NATIVE)):
            convert_thread = threading.Thread(target=self.__bg_import_book, args=(filename,))
            self.job_running = True
            convert_thread.start()
            GObject.timeout_add(100, self.__check_on_work)
        else:
            self.__continiue_book_loading(filename) 

# 需要导入模块: from gi.repository import GObject [as 别名]
# 或者: from gi.repository.GObject import timeout_add [as 别名]
def on_size_allocate(self, allocation):
		# remove timer if any
		if self._render_timeout:
			GObject.source_remove(self._render_timeout)
			self._render_timeout = None

		size = (allocation.width, allocation.height)
		if size == self._render_size or not self._pixbuf:
			pass # no update of rendering needed
		else:
			def render_on_timeout(size):
				self._render_size = size
				try:
					self._render()
				except:
					logger.exception('Exception while rendering image')

				return False

			self._render_timeout = GObject.timeout_add(100, render_on_timeout, size) 

# 需要导入模块: from gi.repository import GObject [as 别名]
# 或者: from gi.repository.GObject import timeout_add [as 别名]
def __init__(self):
            super().__init__()
            self._browser = None
            self._win32_handle = None
            self._initial_html = ""

            sys.excepthook = cef.ExceptHook  # To shutdown CEF processes on error.
            cef.Initialize(settings={"context_menu": {"enabled": False}})

            GObject.threads_init()
            GObject.timeout_add(10, self.on_timer)

            self.connect("configure-event", self.on_configure)
            self.connect("size-allocate", self.on_size_allocate)
            self.connect("focus-in-event", self.on_focus_in)
            self.connect("realize", self.on_realize) 

# 需要导入模块: from gi.repository import GObject [as 别名]
# 或者: from gi.repository.GObject import timeout_add [as 别名]
def __init__(self, path, encoder, recorder, queue, *args, **kwargs):
        threading.Thread.__init__(self, *args, **kwargs)
        self.path = path
        self.encoder = encoder
        self.recorder = recorder
        self.recorder_process = None
        self.encoder_process = None
        self.queue = queue

        self.reinitialize_count = 0
        self.stop_event = threading.Event()

        GObject.timeout_add(
            10000, self._on_regenerate_reinitialize_count) 

# 需要导入模块: from gi.repository import GObject [as 别名]
# 或者: from gi.repository.GObject import timeout_add [as 别名]
def unregister(self, stream):
        logger.info('Unregistered stream "{}" ({}) ...'.format(
            stream.path, stream.id))
        del self.streams[stream.path][stream.id]

        if stream.path in self.timeouts:
            GObject.source_remove(self.timeouts[stream.path])
        self.timeouts[stream.path] = GObject.timeout_add(
            2000, self._on_disconnect, stream) 

# 需要导入模块: from gi.repository import GObject [as 别名]
# 或者: from gi.repository.GObject import timeout_add [as 别名]
def _block_device_handling(self, object_path):
        self.blocked_devices.append(object_path)
        GObject.timeout_add(1000, self._unblock_device_handling, object_path) 

# 需要导入模块: from gi.repository import GObject [as 别名]
# 或者: from gi.repository.GObject import timeout_add [as 别名]
def _delayed_handle_sink_update(self, sink_path):
        if self.signal_timers.get(sink_path, None):
            GObject.source_remove(self.signal_timers[sink_path])
        self.signal_timers[sink_path] = GObject.timeout_add(
            1000, self._handle_sink_update, sink_path) 

# 需要导入模块: from gi.repository import GObject [as 别名]
# 或者: from gi.repository.GObject import timeout_add [as 别名]
def on_name_owner_changed(self, name, new_owner, old_owner):
        if not self.is_checking:
            if self.check_id:
                GObject.source_remove(self.check_id)
            self.check_id = GObject.timeout_add(
                3000, self._check_processes) 

# 需要导入模块: from gi.repository import GObject [as 别名]
# 或者: from gi.repository.GObject import timeout_add [as 别名]
def __init__(self, pulse=True, rate=0.01):

        Gtk.ProgressBar.__init__(self)
        self.activity_mode = pulse
        self.still_working = True
        self.progress_rate = rate

        if self.activity_mode:
            self.pulse()
        else:
            self.set_fraction(0.0)

        GObject.timeout_add(50, self.on_timeout, None) 

# 需要导入模块: from gi.repository import GObject [as 别名]
# 或者: from gi.repository.GObject import timeout_add [as 别名]
def _timer_start(self):
        # Need to stop it, otherwise we potentially leak a timer id that will
        # never be stopped.
        self._timer_stop()
        self._timer = GObject.timeout_add(self._interval, self._on_timer) 

# 需要导入模块: from gi.repository import GObject [as 别名]
# 或者: from gi.repository.GObject import timeout_add [as 别名]
def _on_timer(self):
        TimerBase._on_timer(self)

        # Gtk timeout_add() requires that the callback returns True if it
        # is to be called again.
        if len(self.callbacks) > 0 and not self._single:
            return True
        else:
            self._timer = None
            return False