Exemplo n.º 1
0
class Monitor(SignalManager):

	def __init__(self, editor):
		SignalManager.__init__(self)
		self.__init_attributes(editor)
		self.connect(editor, "close", self.__close_cb)
		self.connect(editor, "quit", self.__quit_cb)
		self.connect(editor, "saved-file", self.__saved_file_cb)
		self.connect(editor, "save-file", self.__busy_cb)
		self.connect(editor, "save-error", self.__nobusy_cb, True)
		self.connect(editor, "saved-file", self.__nobusy_cb, True)
		self.connect(editor, "loaded-file", self.__monitor_cb, True)
		editor.register_object(self)

	def __init_attributes(self, editor):
		self.__editor = editor
		self.__uri = ""
		from SCRIBES.GObjectTimerManager import Manager
		self.__timer_manager = Manager()
		from gio import File, FILE_MONITOR_NONE, Cancellable
		self.__cancellable = Cancellable()
		self.__file_monitor = File("").monitor_file(FILE_MONITOR_NONE, self.__cancellable)
		self.__can_reload = True
		return

	def __monitor(self, uri):
		self.__uri = uri
		from gio import File, FILE_MONITOR_NONE
		self.__unmonitor()
		self.__file_monitor = File(uri).monitor_file(FILE_MONITOR_NONE, self.__cancellable)
		self.__file_monitor.connect("changed", self.__changed_cb)
		self.__file_monitor.set_rate_limit(RATE_LIMIT)
		return False

	def __unmonitor(self):
		self.__file_monitor.cancel()
		self.__cancellable.cancel()
		self.__cancellable.reset()
		return False

	def __remove_monitor(self):
		self.__timer_manager.remove_all()
		self.__unmonitor()
		return False

	def __set_can_reload(self, can_reload):
		self.__can_reload = can_reload
		return False

	def __reload(self):
		if self.__file_exists() is False: return False
		if self.__file_is_remote(): return False
		from URILoader.Manager import Manager
		Manager(self.__editor, self.__uri, self.__editor.encoding)
		from gobject import timeout_add, PRIORITY_LOW
		timeout_add(1000, self.__reload_feedback_message, priority=PRIORITY_LOW)
		return False

	def __reload_feedback_message(self):
		from gettext import gettext as _
		message = _("File modification detected. Reloaded file")
		self.__editor.update_message(message, "info", 10)
		return False

	def __file_exists(self):
		from gio import File
		return File(self.__uri).query_exists()

	def __file_is_remote(self):
		if not self.__uri: return False
		from Utils import uri_is_remote
		return uri_is_remote(self.__uri)

	def __change_handler(self, event):
		if self.__can_reload is False or event not in (1, 2, 3, 4): return False
		from gobject import idle_add, PRIORITY_LOW
		idle_add(self.__reload, priority=PRIORITY_LOW)
		return False

	def __destroy(self):
		self.__timer_manager.destroy()
		self.disconnect()
		self.__editor.unregister_object(self)
		del self
		return False

	def __quit_cb(self, *args):
		self.__destroy()
		return False

	def __monitor_cb(self, editor, uri, *args):
		self.__timer_manager.remove_all()
		from gobject import idle_add, PRIORITY_LOW
		idle_add(self.__monitor, uri, priority=PRIORITY_LOW)
		return False

	def __changed_cb(self, monitor, child, other_child, event):
		self.__timer_manager.remove_all()
		from gobject import timeout_add
		self.__timer1 = timeout_add(WAIT_INTERVAL, self.__change_handler, event)
		self.__timer_manager.add(self.__timer1)
		return False

	def __busy_cb(self, *args):
		self.__can_reload = False
		self.__timer_manager.remove_all()
		return False

	def __nobusy_cb(self, *args):
		self.__timer_manager.remove_all()
		from gobject import timeout_add, PRIORITY_LOW
		self.__timer2 = timeout_add(IGNORE_MONITORING_INTERVAL, self.__set_can_reload, True, priority=PRIORITY_LOW)
		self.__timer_manager.add(self.__timer2)
		return False

	def __saved_file_cb(self, editor, uri, *args):
		if self.__uri == uri: return False
		self.__timer_manager.remove_all()
		self.__monitor(uri)
		return False

	def __close_cb(self, *args):
		self.__remove_monitor()
		return False
Exemplo n.º 2
0
class Monitor(SignalManager):
    def __init__(self, editor):
        SignalManager.__init__(self)
        self.__init_attributes(editor)
        self.connect(editor, "close", self.__close_cb)
        self.connect(editor, "quit", self.__quit_cb)
        self.connect(editor, "saved-file", self.__saved_file_cb)
        self.connect(editor, "save-file", self.__busy_cb)
        self.connect(editor, "save-error", self.__nobusy_cb, True)
        self.connect(editor, "saved-file", self.__nobusy_cb, True)
        self.connect(editor, "loaded-file", self.__monitor_cb, True)
        editor.register_object(self)

    def __init_attributes(self, editor):
        self.__editor = editor
        self.__uri = ""
        from SCRIBES.GObjectTimerManager import Manager
        self.__timer_manager = Manager()
        from gio import File, FILE_MONITOR_NONE, Cancellable
        self.__cancellable = Cancellable()
        self.__file_monitor = File("").monitor_file(FILE_MONITOR_NONE,
                                                    self.__cancellable)
        self.__can_reload = True
        return

    def __monitor(self, uri):
        self.__uri = uri
        from gio import File, FILE_MONITOR_NONE
        self.__unmonitor()
        self.__file_monitor = File(uri).monitor_file(FILE_MONITOR_NONE,
                                                     self.__cancellable)
        self.__file_monitor.connect("changed", self.__changed_cb)
        self.__file_monitor.set_rate_limit(RATE_LIMIT)
        return False

    def __unmonitor(self):
        self.__file_monitor.cancel()
        self.__cancellable.cancel()
        self.__cancellable.reset()
        return False

    def __remove_monitor(self):
        self.__timer_manager.remove_all()
        self.__unmonitor()
        return False

    def __set_can_reload(self, can_reload):
        self.__can_reload = can_reload
        return False

    def __reload(self):
        if self.__file_exists() is False: return False
        if self.__file_is_remote(): return False
        from URILoader.Manager import Manager
        Manager(self.__editor, self.__uri, self.__editor.encoding)
        from gobject import timeout_add, PRIORITY_LOW
        timeout_add(1000,
                    self.__reload_feedback_message,
                    priority=PRIORITY_LOW)
        return False

    def __reload_feedback_message(self):
        from gettext import gettext as _
        message = _("File modification detected. Reloaded file")
        self.__editor.update_message(message, "info", 10)
        return False

    def __file_exists(self):
        from gio import File
        return File(self.__uri).query_exists()

    def __file_is_remote(self):
        if not self.__uri: return False
        from Utils import uri_is_remote
        return uri_is_remote(self.__uri)

    def __change_handler(self, event):
        if self.__can_reload is False or event not in (1, 2, 3, 4):
            return False
        from gobject import idle_add, PRIORITY_LOW
        idle_add(self.__reload, priority=PRIORITY_LOW)
        return False

    def __destroy(self):
        self.__timer_manager.destroy()
        self.disconnect()
        self.__editor.unregister_object(self)
        del self
        return False

    def __quit_cb(self, *args):
        self.__destroy()
        return False

    def __monitor_cb(self, editor, uri, *args):
        self.__timer_manager.remove_all()
        from gobject import idle_add, PRIORITY_LOW
        idle_add(self.__monitor, uri, priority=PRIORITY_LOW)
        return False

    def __changed_cb(self, monitor, child, other_child, event):
        self.__timer_manager.remove_all()
        from gobject import timeout_add
        self.__timer1 = timeout_add(WAIT_INTERVAL, self.__change_handler,
                                    event)
        self.__timer_manager.add(self.__timer1)
        return False

    def __busy_cb(self, *args):
        self.__can_reload = False
        self.__timer_manager.remove_all()
        return False

    def __nobusy_cb(self, *args):
        self.__timer_manager.remove_all()
        from gobject import timeout_add, PRIORITY_LOW
        self.__timer2 = timeout_add(IGNORE_MONITORING_INTERVAL,
                                    self.__set_can_reload,
                                    True,
                                    priority=PRIORITY_LOW)
        self.__timer_manager.add(self.__timer2)
        return False

    def __saved_file_cb(self, editor, uri, *args):
        if self.__uri == uri: return False
        self.__timer_manager.remove_all()
        self.__monitor(uri)
        return False

    def __close_cb(self, *args):
        self.__remove_monitor()
        return False
Exemplo n.º 3
0
class Monitor(SignalManager):

	def __init__(self, manager, editor):
		SignalManager.__init__(self, editor)
		self.__init_attributes(manager, editor)
		self.connect(manager, "destroy", self.__destroy_cb)
		self.connect(manager, "generate-uris", self.__generate_uris_cb)
		self.connect(manager, "generate-data-for-treeview", self.__uris_cb)
		self.connect(manager, "finished-enumerating-children", self.__enumerated_children_cb)

	def __init_attributes(self, manager, editor):
		self.__manager = manager
		self.__editor = editor
		self.__folder_uri = ""
		self.__folder_monitor = None
		self.__uris = []
		self.__unique_id = ""
		return

	def __monitor(self, folder_uri):
		if self.__folder_uri == folder_uri: return False
		self.__disconnect()
		self.__connect(folder_uri)
		return False

	def __connect(self, folder_uri):
		self.__folder_uri = folder_uri
		from gio import File, FILE_MONITOR_WATCH_MOUNTS
		self.__folder_monitor = File(folder_uri).monitor_directory(FILE_MONITOR_WATCH_MOUNTS)
		self.__sigid1 = self.__folder_monitor.connect("changed", self.__changed_cb)
		return False

	def __disconnect(self):
		if not self.__folder_uri: return False
		self.__folder_monitor.disconnect(self.__sigid1)
		self.__folder_monitor.cancel()
		self.__folder_monitor = None
		return False

	def __check(self):
		from uuid import uuid1
		self.__unique_id = str(uuid1())
		from gobject import idle_add
		idle_add(self.__manager.emit, "enumerate-children", (self.__folder_uri, self.__unique_id))
		return False

	def __compare(self, user_data):
		fileinfos, folder_uri, unique_id = user_data
		if unique_id != self.__unique_id: return False
		if folder_uri != self.__folder_uri: return False
		from gio import File
		uris = sorted((File(folder_uri).resolve_relative_path(fileinfo.get_name()).get_uri()
			for fileinfo in fileinfos))
		if uris == self.__uris: return False
		from gobject import idle_add
		idle_add(self.__manager.emit, "generate-uris", folder_uri)
		return False

	def __remove_timer(self, _timer=1):
		try:
			timers = {
				1: self.__timer1,
			}
			from gobject import source_remove
			source_remove(timers[_timer])
		except AttributeError:
			pass
		return False

	def __changed_cb(self, folder_monitor, gfile, other_gfile, event_type):
		from gio import FILE_MONITOR_EVENT_CREATED, FILE_MONITOR_EVENT_DELETED
		if event_type not in (FILE_MONITOR_EVENT_CREATED, FILE_MONITOR_EVENT_DELETED): return False
		self.__remove_timer(1)
		from gobject import timeout_add, PRIORITY_LOW
		self.__timer1 = timeout_add(2000, self.__check, priority=PRIORITY_LOW)
		return False

	def __generate_uris_cb(self, manager, folder_uri):
		from gobject import idle_add
		idle_add(self.__monitor, folder_uri)
		return False

	def __enumerated_children_cb(self, manager, user_data):
		from gobject import idle_add, PRIORITY_LOW
		idle_add(self.__compare, user_data, priority=PRIORITY_LOW)
		return False

	def __uris_cb(self, manager, user_data):
		folder_uri, fileinfos, treeview_reference = user_data
		from gio import File
		self.__uris = sorted((File(folder_uri).resolve_relative_path(fileinfo.get_name()).get_uri()
			for fileinfo in fileinfos))
		return False

	def __destroy_cb(self, *args):
		self.__disconnect()
		self.disconnect()
		del self
		return False