Esempio n. 1
0
 def activate(self, leaf):
     gfile = Gio.File.new_for_uri(leaf.object["location"])
     path = gfile.get_path()
     if path:
         result = FileLeaf(path)
         if result.is_valid():
             return result
Esempio n. 2
0
 def activate(self, leaf):
     gfile = Gio.File.new_for_uri(leaf.object["location"])
     try:
         path = gfile.get_path()
     except Exception as exc:
         # On utf-8 decode error
         # FIXME: Unrepresentable path
         raise OperationError(exc)
     if path:
         result = FileLeaf(path)
         if result.is_valid():
             return result
Esempio n. 3
0
 def activate(self, leaf):
     gfile = Gio.File.new_for_uri(leaf.object["location"])
     try:
         path = gfile.get_path()
     except Exception as exc:
         # On utf-8 decode error
         # FIXME: Unrepresentable path
         raise OperationError(exc)
     if path:
         result = FileLeaf(path)
         if result.is_valid():
             return result
     raise NotAvailableError(str(leaf))
Esempio n. 4
0
 def get_text_items(self, text):
     # Find directories or files
     if self._is_local_file_url(text):
         leaf = FileLeaf.from_uri(text)
         if leaf and leaf.is_valid():
             yield leaf
     else:
         prefix = os.path.expanduser("~/")
         ufilepath = text if os.path.isabs(text) else os.path.join(
             prefix, text)
         filepath = os.path.normpath(ufilepath)
         if os.access(filepath, os.R_OK):
             yield FileLeaf(filepath)
Esempio n. 5
0
    def _get_items(max_days, for_app_names=None):
        """
        for_app_names: set of candidate app names, or None.
        """
        def first_word(s):
            return s.split(None, 1)[0]

        for file_path, _modified, item in RecentsSource._get(max_days):
            if for_app_names:
                apps = item.get_applications()
                in_low_apps = any(A.lower() in for_app_names for A in apps)
                in_execs = any(
                    first_word(item.get_application_info(A)[0]) in
                    for_app_names for A in apps)
                if not in_low_apps and not in_execs:
                    continue

            if for_app_names:
                accept_item = True
                for app_id, sort_table in SEPARATE_APPS.items():
                    if app_id in for_app_names:
                        _, ext = path.splitext(file_path)
                        ext = ext.lower()
                        if ext in sort_table and sort_table[
                                ext] not in for_app_names:
                            accept_item = False
                            break
                if not accept_item:
                    continue
            yield FileLeaf(file_path)
Esempio n. 6
0
 def get_text_items(self, text):
     # Find directories or files
     prefix = os.path.expanduser("~/")
     ufilepath = text if os.path.isabs(text) else os.path.join(prefix, text)
     filepath = os.path.normpath(ufilepath)
     if os.access(filepath, os.R_OK):
         yield FileLeaf(filepath)
Esempio n. 7
0
 def get_text_items(self, text):
     # Find directories or files
     prefix = os.path.expanduser(u"~/")
     ufilepath = text if os.path.isabs(text) else os.path.join(prefix, text)
     # use filesystem encoding here
     filepath = gobject.filename_from_utf8(os.path.normpath(ufilepath))
     if os.access(filepath, os.R_OK):
         yield FileLeaf(filepath)
Esempio n. 8
0
 def _finish_callback(self, gfile, result, data):
     self.output_debug("Finished copying", gfile)
     dfile, ctx = data
     try:
         gfile.copy_finish(result)
     except gio.Error:
         ctx.register_late_error()
     else:
         ctx.register_late_result(FileLeaf(dfile.get_path()))
Esempio n. 9
0
class RecentsSource(AppLeafContentMixin, Source, PicklingHelperMixin):
    appleaf_content_id = "abiword"

    def __init__(self, name=None):
        if not name:
            name = _("Abiword Recent Items")
        super(RecentsSource, self).__init__(name)
        self.unpickle_finish()

    def pickle_prepare(self):
        # monitor is not pickleable
        self.monitor = None

    def unpickle_finish(self):
        """Set up change monitor"""
        abifile = self._get_abiword_file()
        if not abifile: return
        gfile = gio.File(abifile)
        self.monitor = gfile.monitor_file(gio.FILE_MONITOR_NONE, None)
        if self.monitor:
            self.monitor.connect("changed", self._changed)

    def _changed(self, monitor, file1, file2, evt_type):
        """Change callback; something changed"""
        if evt_type in (gio.FILE_MONITOR_EVENT_CREATED,
                        gio.FILE_MONITOR_EVENT_DELETED,
                        gio.FILE_MONITOR_EVENT_CHANGED):
            self.mark_for_update()

    def _get_abiword_file(self):
        abifile = os.path.expanduser("~/.AbiSuite/AbiWord.Profile")
        if not os.path.exists(abifile):
            return None
        return abifile

    def get_items(self):
        abifile = self._get_abiword_file()
        if not abifile:
            self.output_debug("Abiword profile not found at", abifile)
            return

        try:
            uris = list(get_abiword_files(abifile))
        except EnvironmentError, exc:
            self.output_error(exc)
            return

        for uri in uris:
            gfile = gio.File(uri)
            if not gfile.query_exists():
                continue

            if gfile.get_path():
                leaf = FileLeaf(gfile.get_path())
            else:
                leaf = UrlLeaf(gfile.get_uri(), gfile.get_basename())
            yield leaf
Esempio n. 10
0
 def reply(results):
     ret = []
     new_file = Gio.File.new_for_uri
     for result in results:
         try:
             ret.append(FileLeaf(new_file(result[0]).get_path()))
         except Exception:  # This very vague exception is from getpath
             continue
     ctx.register_late_result(
         TrackerQuerySource(query, search_results=ret))
Esempio n. 11
0
def _create_history_leaf(path):
	''' Create leaf from file url '''
	if not path:
		return None
	gfile = gio.File(path)
	if not gfile.query_exists():
		None
	if gfile.get_path():
		return FileLeaf(gfile.get_path())
	return UrlLeaf(path, gfile.get_basename())
Esempio n. 12
0
 def get_items(self):
     with closing(sqlite3.connect(self.metadata_file, timeout=1)) as conn:
         curs = conn.cursor()
         curs.execute(
             "select format, name from data "
             "where book=? "
             "order by format", (self.book_id, ))
         for format_, name in curs:
             yield FileLeaf(
                 os.path.join(self.path, name + "." + format_.lower()))
Esempio n. 13
0
 def activate(self, leaf, iobj):
     outfile, outpath = \
             utils.get_destfile_in_directory(iobj.object, _("Empty File"))
     try:
         l_text = kupferstring.tolocale(leaf.object)
         outfile.write(l_text)
         if not l_text.endswith(b"\n"):
             outfile.write(b"\n")
     finally:
         outfile.close()
     return FileLeaf(outpath)
Esempio n. 14
0
 def activate(self, leaf, obj, ctx):
     size = self._make_size(obj.object)
     fpath = leaf.object
     dirname = os_path.dirname(fpath)
     head, ext = os_path.splitext(os_path.basename(fpath))
     filename = "%s_%s%s" % (head, size, ext)
     dpath = utils.get_destpath_in_directory(dirname, filename)
     argv = ["convert", "-scale", ('%s' % size), fpath, dpath]
     runtimehelper.register_async_file_result(ctx, dpath)
     spawn_operation_err(argv)
     return FileLeaf(dpath)
Esempio n. 15
0
	def activate(self, leaf):
		orig_path = leaf.get_orig_path()
		if not orig_path:
			return
		orig_gfile = gio.File(orig_path)
		cur_gfile = leaf.get_gfile()
		if orig_gfile.query_exists():
			raise IOError("Target file exists at %s" % orig_gfile.get_path())
		pretty.print_debug(__name__, "Move %s to %s" % (cur_gfile, orig_gfile))
		ret = cur_gfile.move(orig_gfile)
		pretty.print_debug(__name__, "Move ret=%s" % (ret, ))
		return FileLeaf(orig_gfile.get_path())
Esempio n. 16
0
 def activate(self, leaf, obj):
     sfile = leaf.get_gfile()
     dest = os_path.join(os_path.dirname(leaf.object), obj.object)
     dfile = Gio.File.new_for_path(dest)
     try:
         ret = sfile.move(dfile, Gio.FileCopyFlags.ALL_METADATA, None, None,
                          None)
         self.output_debug("Move %s to %s (ret: %s)" % (sfile, dfile, ret))
     except GLib.Error as exc:
         raise OperationError(str(exc))
     else:
         return FileLeaf(dfile.get_path())
Esempio n. 17
0
File: text.py Progetto: engla/kupfer
 def get_text_items(self, text):
     # Find directories or files
     if text.startswith("file:///"):
         leaf = FileLeaf.from_uri(text)
         if leaf and leaf.is_valid():
             yield leaf
     else:
         prefix = os.path.expanduser("~/")
         ufilepath = text if os.path.isabs(text) else os.path.join(prefix, text)
         filepath = os.path.normpath(ufilepath)
         if os.access(filepath, os.R_OK):
             yield FileLeaf(filepath)
Esempio n. 18
0
    def activate(self, leaf):
        # Try to find the __file__ attribute for the plugin
        # It will fail for files inside zip packages, but that is
        # uncommon for now.
        # Additionally, it will fail for fake plugins
        plugin_id = leaf.object["name"]
        filename = plugins.get_plugin_attribute(plugin_id, "__file__")
        if not filename:
            return leaf
        root, ext = os.path.splitext(filename)
        if ext.lower() == ".pyc" and os.path.exists(root + ".py"):
            return FileLeaf(root + ".py")

        if not os.path.exists(filename):
            # handle modules in zip or eggs
            import pkgutil
            pfull = "kupfer.plugin." + plugin_id
            loader = pkgutil.get_loader(pfull)
            if loader:
                return TextLeaf(loader.get_source(pfull))
        return FileLeaf(filename)
Esempio n. 19
0
 def activate(self, leaf, obj):
     sfile = leaf.get_gfile()
     bname = sfile.get_basename()
     dfile = obj.get_gfile().get_child(bname)
     try:
         ret = sfile.move(dfile, Gio.FileCopyFlags.ALL_METADATA, None, None,
                          None)
         self.output_debug("Move %s to %s (ret: %s)" % (sfile, dfile, ret))
     except GLib.Error as exc:
         raise OperationError(str(exc))
     else:
         return FileLeaf(dfile.get_path())
Esempio n. 20
0
 def activate(self, leaf, ctx):
     fpath = leaf.object
     dirname = os_path.dirname(fpath)
     head, ext = os_path.splitext(os_path.basename(fpath))
     filename = "%s_%s%s" % (head, self.rotation, ext)
     dpath = utils.get_destpath_in_directory(dirname, filename)
     argv = [
         "jpegtran", "-copy", "all", "-rotate", self.rotation, "-outfile",
         dpath, fpath
     ]
     runtimehelper.register_async_file_result(ctx, dpath)
     spawn_operation_err(argv)
     return FileLeaf(dpath)
Esempio n. 21
0
 def activate(self, leaf):
     orig_path = leaf.get_orig_path()
     if not orig_path:
         return
     orig_gfile = Gio.File.new_for_path(orig_path)
     cur_gfile = leaf.get_gfile()
     if orig_gfile.query_exists():
         raise OperationError("Target file exists at %s" %
                              orig_gfile.get_path())
     pretty.print_debug(__name__, "Move %s to %s" % (cur_gfile, orig_gfile))
     ret = cur_gfile.move(orig_gfile, Gio.FileCopyFlags.ALL_METADATA, None,
                          None, None)
     pretty.print_debug(__name__, "Move ret=%s" % (ret, ))
     return FileLeaf(orig_gfile.get_path())
Esempio n. 22
0
def get_file_results_sparql(searchobj, query, max_items):
    clean_query = sparql_escape(query)
    sql = u"""SELECT tracker:coalesce (nie:url (?s), ?s)
	          WHERE {  ?s fts:match "%s*" .  ?s tracker:available true . }
			  ORDER BY tracker:weight(?s)
			  OFFSET 0 LIMIT %d""" % (clean_query, int(max_items))

    pretty.print_debug(__name__, "Searching for %s (%s)", repr(clean_query),
                       repr(query))
    pretty.print_debug(__name__, sql)
    results = searchobj.SparqlQuery(sql)

    gio_File = gio.File
    for result in results:
        yield FileLeaf(gio_File(result[0]).get_path())
Esempio n. 23
0
 def _get_places(self, fileloc):
     for line in open(fileloc):
         if not line.strip():
             continue
         items = line.split(None, 1)
         uri = items[0]
         gfile = Gio.File.new_for_uri(uri)
         if len(items) > 1:
             title = items[1].strip()
         else:
             disp = gfile.get_parse_name()
             title = path.basename(disp)
         locpath = gfile.get_path()
         if locpath:
             yield FileLeaf(locpath, title)
         else:
             yield UrlLeaf(gfile.get_uri(), title)
Esempio n. 24
0
    def get_items(self):
        viminfofile = os.path.expanduser(self.vim_viminfo_file)
        if not os.path.exists(viminfofile):
            self.output_debug("Viminfo not found at", viminfofile)
            return

        try:
            filepaths = list(get_vim_files(viminfofile))
        except EnvironmentError:
            self.output_exc()
            return

        for filepath in filepaths:
            # The most confusing glib function
            # takes a unicode string and returns a
            # filesystem-encoded bytestring.
            yield FileLeaf(glib.filename_from_utf8(filepath))
Esempio n. 25
0
 def activate(self, leaf, iobj):
     if iobj.object is not None:
         # Copy the template to destination directory
         basename = os.path.basename(iobj.object)
         tmpl_gfile = Gio.File.new_for_path(iobj.object)
         destpath = utils.get_destpath_in_directory(leaf.object, basename)
         destfile = Gio.File.new_for_path(destpath)
         tmpl_gfile.copy(destfile, Gio.FileCopyFlags.ALL_METADATA, None, None, None)
     elif isinstance(iobj, NewFolder):
         filename = str(iobj)
         destpath = utils.get_destpath_in_directory(leaf.object, filename)
         os.makedirs(destpath)
     else:
         # create new empty file
         filename = str(iobj)
         f, destpath = utils.get_destfile_in_directory(leaf.object, filename)
         f.close()
     return FileLeaf(destpath)
Esempio n. 26
0
	def activate(self, leaf, iobj):
		if iobj.object is not None:
			# Copy the template to destination directory
			basename = os.path.basename(iobj.object)
			tmpl_gfile = gio.File(iobj.object)
			destpath = utils.get_destpath_in_directory(leaf.object, basename)
			destfile = gio.File(destpath)
			tmpl_gfile.copy(destfile, flags=gio.FILE_COPY_ALL_METADATA)
		elif isinstance(iobj, NewFolder):
			filename = unicode(iobj)
			destpath = utils.get_destpath_in_directory(leaf.object, filename)
			os.makedirs(destpath)
		else:
			# create new empty file
			filename = unicode(iobj)
			f, destpath = utils.get_destfile_in_directory(leaf.object, filename)
			f.close()
		return FileLeaf(destpath)
Esempio n. 27
0
def get_file_results_sparql(searchobj,
                            query,
                            max_items=50,
                            order_by="rank",
                            **kwargs):
    clean_query = sparql_escape(query)
    sql = ("""SELECT tracker:coalesce (nie:url (?s), ?s)
              WHERE {  ?s fts:match "%s" .  ?s tracker:available true . }
              %s
              OFFSET 0 LIMIT %d""" %
           (clean_query, ORDER_BY[order_by], int(max_items)))

    pretty.print_debug(__name__, sql)
    results = searchobj.SparqlQuery(sql, **kwargs)
    if results is None:
        return

    new_file = Gio.File.new_for_uri
    for result in results:
        try:
            yield FileLeaf(new_file(result[0]).get_path())
        except Exception:  # This very vague exception is from getpath
            continue
Esempio n. 28
0
def get_file_results_sparql(searchobj,
                            query,
                            max_items=50,
                            order_by="rank",
                            location=None,
                            **kwargs):
    clean_query = sparql_escape(query)

    if location:
        location_filter = \
        'FILTER(tracker:uri-is-descendant ("%s", nie:url (?s)))' % sparql_escape(location)
    else:
        location_filter = ""

    sql = ("""SELECT tracker:coalesce (nie:url (?s), ?s)
              WHERE {
                ?s fts:match "%(query)s" .  ?s tracker:available true .
                %(location_filter)s
              }
              %(order_by)s
              OFFSET 0 LIMIT %(limit)d""" %
           dict(query=clean_query,
                location_filter=location_filter,
                order_by=ORDER_BY[order_by],
                limit=int(max_items)))

    pretty.print_debug(__name__, sql)
    results = searchobj.SparqlQuery(sql, **kwargs)
    if results is None:
        return

    new_file = Gio.File.new_for_uri
    for result in results:
        try:
            yield FileLeaf(new_file(result[0]).get_path())
        except Exception:  # This very vague exception is from getpath
            continue
Esempio n. 29
0
    def _get_items(cls, max_days, for_application_named=None):
        manager = recent_manager_get_default()
        items = manager.get_items()
        item_leaves = []
        for item in items:
            if for_application_named:
                low_apps = [A.lower() for A in item.get_applications()]
                if for_application_named.lower() not in low_apps:
                    continue
            day_age = item.get_age()
            if max_days >= 0 and day_age > max_days:
                continue
            if not item.exists():
                continue

            uri = item.get_uri()
            name = item.get_short_name()
            if item.is_local():
                leaf = FileLeaf(gio.File(uri).get_path())
            else:
                leaf = UrlLeaf(uri, name)
            item_leaves.append((leaf, item.get_modified()))
        for lf, date in sorted(item_leaves, key=lambda t: t[1], reverse=True):
            yield lf
Esempio n. 30
0
	def get_gicon(self):
		file_gicon = FileLeaf.get_gicon(self)
		return icons.ComposedIcon("text-x-generic-template", file_gicon)
Esempio n. 31
0
	def get_actions(self):
		yield CreateDocumentIn()
		for a in FileLeaf.get_actions(self):
			yield a
Esempio n. 32
0
	def __init__(self, path):
		basename = glib.filename_display_basename(path)
		nameroot, ext = os.path.splitext(basename)
		FileLeaf.__init__(self, path, _("%s template") % nameroot)
Esempio n. 33
0
 def __init__(self, paths):
     files = [FileLeaf(path) for path in paths]
     MultipleLeaf.__init__(self, files, _("Clipboard Files"))
Esempio n. 34
0
 def __init__(self, filepath):
     """@filepath is a filesystem byte string `str`"""
     FileLeaf.__init__(self, filepath, _('Clipboard File'))
Esempio n. 35
0
	def changed(self, monitor, gfile1, gfile2, event):
		if event == gio.FILE_MONITOR_EVENT_CHANGES_DONE_HINT:
			self.ctx.register_late_result(FileLeaf(gfile1.get_path()))
			self.monitor.disconnect(self.callback_id)
			self.monitor = None
Esempio n. 36
0
 def __init__(self, filepath):
     """@filepath is a filesystem byte string `str`"""
     FileLeaf.__init__(self, filepath, _('Clipboard File'))
Esempio n. 37
0
	def __init__(self, filepath):
		"""@filepath is a filesystem byte string `str`"""
		basename = gobject.filename_display_basename(filepath)
		FileLeaf.__init__(self, filepath, _('Selected File "%s"') % basename)