web-dev-qa-db-fra.com

Existe-t-il un indicateur permettant d’accéder rapidement aux fichiers récemment utilisés?

Je cherche un indicateur d’icône de barre des tâches qui - après avoir cliqué sur l’icône - me montre la liste de mes fichiers récemment utilisés. Ce serait un excellent moyen d'accéder rapidement à ces fichiers.

5
orschiro

Avoir vos fichiers récemment utilisés dans le panneau

Avec le script ci-dessous, vous pouvez disposer d’un nombre arbitraire d’articles récemment utilisés dans le panneau, par exemple. 6 éléments:

enter image description here

... ou 20 éléments:

enter image description here

... en fonction de vos paramètres.

Comment ça fonctionne

La configuration existe de deux éléments:

  1. une icône, nommée (exactement) recent.png
  2. un script

Les deux doivent être dans le même dossier. Après cela, lancez simplement le script.

Comment mettre en place

Vous devez éventuellement installer python3-gi:

Sudo apt-get install python3-gi

Ensuite:

  1. Copiez le script ci-dessous dans un fichier vide, enregistrez-le sous le nom recused.py

    #!/usr/bin/env python3
    import signal
    import gi
    gi.require_version('Gtk', '3.0')
    gi.require_version('AppIndicator3', '0.1')
    from gi.repository import Gtk, AppIndicator3, GObject
    import time
    from threading import Thread
    import os
    import subprocess
    
    # --- set the number of recently used files to appear below
    n = 20
    # ---
    
    home = os.environ["HOME"]
    recdata = os.path.join(home, ".local/share/recently-used.xbel")
    currpath = os.path.dirname(os.path.realpath(__file__))
    
    class Indicator():
        def __init__(self):
            self.app = 'show_recent'
            iconpath = os.path.join(currpath, "recent.png")
            self.indicator = AppIndicator3.Indicator.new(
                self.app, iconpath,
                AppIndicator3.IndicatorCategory.OTHER)
            self.indicator.set_status(AppIndicator3.IndicatorStatus.ACTIVE)       
            self.indicator.set_menu(self.create_menu())
            # the thread:
            self.update = Thread(target=self.check_recent)
            # daemonize the thread to make the indicator stopable
            self.update.setDaemon(True)
            self.update.start()
    
        def get_files(self):
            # create the list of recently used files
            used = [l for l in open(recdata) if \
                    all([
                        '<bookmark href="file://' in l,
                        not "/tmp" in l,
                        "." in l,
                         ])]
            relevant = [l.split('="') for l in set(used)]
            relevant = [[it[1][7:-7], it[-2][:-10]] for it in relevant]
            relevant.sort(key=lambda x: x[1])
            return [item[0].replace("%20", " ") for item in relevant[::-1][:n]]
    
        def create_menu(self):
            # creates the (initial) menu
            self.menu = Gtk.Menu()
            # separator
            menu_sep = Gtk.SeparatorMenuItem()
            self.menu.append(menu_sep)
            # item_quit.show() 
            self.menu.show_all()
            return self.menu
    
        def open_file(self, *args):
            # opens the file with the default application
            index = self.menu.get_children().index(self.menu.get_active())
            selection = self.menu_items2[index]
            subprocess.Popen(["xdg-open", selection])
    
        def set_new(self):
            # update the list, appearing in the menu
            for i in self.menu.get_children():
                self.menu.remove(i)
            for file in self.menu_items2:
                sub = Gtk.MenuItem(file)
                self.menu.append(sub)
                sub.connect('activate', self.open_file)
            # separator
            menu_sep = Gtk.SeparatorMenuItem()
            self.menu.append(menu_sep)
            # quit
            item_quit = Gtk.MenuItem('Quit')
            item_quit.connect('activate', self.stop)
            self.menu.append(item_quit)
            self.menu.show_all()
    
        def check_recent(self):
            self.menu_items1 = []
            while True:
                time.sleep(3)
                self.menu_items2 = self.get_files()
                if self.menu_items2 != self.menu_items1:
                    GObject.idle_add(
                        self.set_new, 
                        priority=GObject.PRIORITY_DEFAULT
                        )
                self.menu_items1 = self.menu_items2
    
        def stop(self, source):
            Gtk.main_quit()
    
    Indicator()
    # this is where we call GObject.threads_init()
    GObject.threads_init()
    signal.signal(signal.SIGINT, signal.SIG_DFL)
    Gtk.main()
    
  2. Dans la section head du script, définissez le nombre d'éléments à afficher:

    # --- set the number of recently used files to appear below
    n = 20
    # ---
    
  3. Dans , un seul et même dossier enregistrez l’icône ci-dessous sous le nom (exactement) recent.png

    enter image description here

    (clic droit dessus -> enregistrer sous)

  4. Test - lancez le script avec la commande:

    python3 /path/to/recused.py
    
  5. Si tout fonctionne correctement, ajoutez à Applications de démarrage: Dash> Applications de démarrage> Ajouter. Ajoutez la commande:

    /bin/bash -c "sleep 15 && python3 /path/to/recused.py"
    

Remarques

  • Ce script était basé sur cette réponse précédente , au cas où une alternative vous intéresserait, qu'elle soit ou spécifique à l'application , et utilisait fichier .desktop mis à jour périodiquement.
  • Le script a été testé le 16.04, mais devrait également fonctionner avec les versions antérieures.
  • En raison d'un bogue dans le fichier recently-used.xbel, un fichier est parfois mentionné deux fois; une fois avec et une fois sans extension. J'ai résolu ce problème en filtrant ce dernier. La conséquence est que les fichiers sans extension n'apparaîtront pas dans la liste. Si cela pose un problème, faites-le moi savoir, nous pouvons essayer de trouver une autre solution dans ce cas.
  • Si un fichier n'existe pas (plus), l'indicateur n'ouvre tout simplement pas (évidemment) le fichier. Très probablement, je vais peaufiner le script un peu plus pour filtrer les entrées obsolètes du fichier recently-used.xbel.

Explication

De nombreuses applications, modifiant des fichiers et utilisant une fenêtre Gtk, gardent une trace des fichiers ouverts dans le fichier: ~/.local/share/recently-used.xbel. Les "enregistrements" incluent la date et l'heure, l'application et le fichier qui a été ouvert.

Le script lit le fichier .xbel, trie les éléments par date/heure et inclut les n premiers fichiers (en fonction de vos paramètres) dans le menu de l'indicateur. Le menu est mis à jour (si nécessaire) toutes les 3 secondes tel quel. Ensuite, lorsqu'un élément est sélectionné, le fichier est ouvert avec la commande:

xdg-open <file>

Ainsi, le fichier sélectionné sera ouvert avec l'application default . Il est très possible de s’assurer que le fichier est ouvert avec l’application actuelle qu’il a ouverte pour la dernière fois. Cela prend cependant une analyse un peu plus sophistiquée. J'ajouterai cela en tant qu'option à la version prévue de ppa sur le tableau de bord.

Il en va de même pour une fenêtre d'options permettant de définir quelques options, telles que le nombre de fichiers à afficher, etc.

Remarque

L'indicateur est maintenant fusionné avec quelques autres éléments dans celui-ci .

7
Jacob Vlijm

Bien que vous ne mentionniez pas la saveur Ubuntu que vous utilisez, il existe une application Nice pour Xubuntu. Plus spécifiquement, il fait partie de Xfce , de sorte que vous pourrez peut-être l'utiliser dans Ubuntu si vous utilisez Xfce . L'application s'appelle Lieux .

Pour l'activer, cliquez avec le bouton droit de la souris sur le panneau et sélectionnez dans le menu Panneau -> Ajouter de nouveaux éléments ..., puis choisissez Lieux . Ceci affiche une liste des dossiers et des documents récents que vous venez d'ouvrir. Voir ci-dessous:

enter image description here

Vous pouvez aussi bien le configurer:

enter image description here

Voici le page du projet .


Si vous n'utilisez pas Xfce , vous pouvez l'installer très facilement, comme expliqué dans cette réponse . Il suffit de faire Sudo apt-get install xfce-panel, puis de l'exécuter (voir lien). Notez que le panneau Xfce peut ne pas être compatible avec toutes les autres applications de votre panneau Unity (ou autre). D'après mon expérience, je n'ai eu aucun problème avec cela, donc cela pourrait toujours être une bonne solution.

2
user308164

Mise à jour du 24 février 2017 : l'indicateur dispose désormais d'une option permettant d'épingler des liens Web.

Introduction

L’indicateur de fichiers présenté ci-dessous est un indicateur simple permettant d’accéder aux fichiers et dossiers de l’utilisateur. Il permet de vérifier les fichiers récemment utilisés, les fichiers de signets et les répertoires.

enter image description here

Mise à jour : Indicateur prend également en charge le lancement de fichiers .desktop épinglés. Par exemple, si vous avez épinglé firefox.desktop, il lancera firefox. Ainsi, l'indicateur peut être utilisé comme lanceur rapide pour les programmes. La fonctionnalité est en cours de création dans PPA au moment de la rédaction (le 19 novembre, 19h53 GMT devrait prendre environ 24 heures), mais elle est déjà sur github et ici, dans le code source mis à jour.

enter image description here

Obtention de l'indicateur

L'indicateur est disponible sur mon PPA personnel ainsi que sur GitHub . Utilisez les étapes suivantes pour l'obtenir:

Sudo add-apt-repository ppa:1047481448-2/sergkolo
Sudo apt-get update
Sudo apt-get install files-indicator

Code source

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

#
# Author: Serg Kolo , contact: [email protected]
# Date: November 19 , 2016
# Purpose: appindicator for accessing files and folders
# Tested on: Ubuntu 16.04 LTS
#
#
# Licensed under The MIT License (MIT).
# See included LICENSE file or the notice below.
#
# Copyright © 2016 Sergiy Kolodyazhnyy
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included
# in all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
import gi
gi.require_version('AppIndicator3', '0.1')
gi.require_version('Notify', '0.7')
from gi.repository import GLib as glib
from gi.repository import AppIndicator3 as appindicator
from gi.repository import Gtk as gtk
from gi.repository import Gio
from gi.repository import Notify
from collections import OrderedDict
# from collections import OrderedDict
import urllib.parse
import subprocess
import copy
import shutil
import dbus
import math
import json
import os

class FilesIndicator(object):

    def __init__(self):
        self.app = appindicator.Indicator.new(
            'files-indicator', "document-open-recent",
            appindicator.IndicatorCategory.HARDWARE
        )
        self.user_home = os.path.expanduser('~')
        filename = '.pinned_files.json'
        self.pinned_list = os.path.join(self.user_home,filename)

        self.config = os.path.join(self.user_home,'.files_indicator.json')
        self.max_items = 15
        self.name_length = 20
        self.read_config()

        self.app.set_status(appindicator.IndicatorStatus.ACTIVE)

        self.cached_files = self.get_recent_files()
        self.make_menu()
        self.update()

    def read_config(self,*args):
        config = {}
        try:
            with open(self.config) as f:
                 config = json.load(f)

        except FileNotFoundError:
            print('>>> ',self.config,' not found.Creating one')
            f = open(self.config,'w')
            config = {'max_items':self.max_items,
                      'name_length':self.name_length
            }
            json.dump(config,f,indent=4)
            f.close()
        except json.JSONDecodeError:
            print(">>> Can't read ",self.pinned_list,',may be corrupt')
            return None
        else:
            self.max_items = config['max_items']
            self.name_length = config['name_length']

    def add_menu_item(self, menu_obj, item_type, image, label, action, args):
        """ dynamic function that can add menu items depending on
            the item type and other arguments"""
        menu_item, icon = None, None
        if item_type is gtk.ImageMenuItem and label:
            menu_item = gtk.ImageMenuItem.new_with_label(label)
            menu_item.set_always_show_image(True)
            if '/' in image:
                icon = gtk.Image.new_from_file(image)
            else:
                icon = gtk.Image.new_from_icon_name(image, 48)
            menu_item.set_image(icon)
        Elif item_type is gtk.ImageMenuItem and not label:
            menu_item = gtk.ImageMenuItem()
            menu_item.set_always_show_image(True)
            if '/' in image:
                icon = gtk.Image.new_from_file(image)
            else:
                icon = gtk.Image.new_from_icon_name(image, 16)
            menu_item.set_image(icon)
        Elif item_type is gtk.MenuItem:
            menu_item = gtk.MenuItem(label)
        Elif item_type is gtk.SeparatorMenuItem:
            menu_item = gtk.SeparatorMenuItem()
        if action:
            menu_item.connect('activate', action, *args)

        menu_obj.append(menu_item)
        menu_item.show()

    def get_user_dirs(self,*args):
        user_dirs = []
        for index,val in glib.UserDirectory.__enum_values__.items():
            if index == 8: continue
            dir = glib.get_user_special_dir(index)
            if dir: user_dirs.append(dir)
        return user_dirs

    def get_file_icon(self,*args):
        if args[-1].endswith('.desktop'):
            desk_file = Gio.DesktopAppInfo.new_from_filename(args[-1])
            icon = desk_file.get_icon()
            if type(icon) == Gio.ThemedIcon:
                themed_name = icon.get_names()[0]
                theme = gtk.IconTheme.get_default()
                name = theme.lookup_icon(themed_name, 48, 0).get_filename()
            if type(icon) == Gio.FileIcon:
                name = icon.get_file().get_uri()

            icon_url= urllib.parse.unquote(name).replace('file://','') 
            return icon_url

        file = Gio.File.new_for_path(args[-1])
        file_info = file.query_info("standard::*",0)
        icon_string = file_info.get_icon().to_string()
        if 'folder-' in icon_string:
            return icon_string.split()[-2]
        return icon_string.split()[-1]

    def get_recent_files(self,*args):
        manager = gtk.RecentManager.get_default()
        try:
            files = OrderedDict()
            for index,item in enumerate(manager.get_items(),1):
                    uri = item.get_uri()
                    uri_decoded = urllib.parse.unquote(uri)
                    filepath = uri_decoded.replace('file://','')
                    if not os.path.exists(filepath): continue
                    basename = os.path.basename(uri_decoded)
                    files[basename] = filepath
                    if index == self.max_items:
                        break
        except Exception as e:
            print(e)
            return None
        finally:  return files

    def callback(self,*args):
        self.update()

    def update(self,*args):
        current_files = self.get_recent_files()
        if current_files != self.cached_files:
             self.make_menu()
             self.cached_files = current_files
        glib.timeout_add_seconds(3,self.callback)

    def add_submenu(self,top_menu,label):
        menuitem = gtk.MenuItem(label)
        submenu = gtk.Menu()
        menuitem.set_submenu(submenu)
        top_menu.append(menuitem)
        menuitem.show()
        return submenu

    def make_menu(self):
        if hasattr(self, 'app_menu'):
            for item in self.app_menu.get_children():
                    self.app_menu.remove(item)
        else:
            self.app_menu = gtk.Menu()
        recent = self.add_submenu(self.app_menu,'Recent Files')
        recent_dict = self.get_recent_files()

        content = [recent,gtk.ImageMenuItem,'gtk-add',
                   'Add to Recent Files',self.add_recent,[None]
        ]      
        self.add_menu_item(*content) 

        content = [recent,gtk.ImageMenuItem,'user-trash',
                   'Clear recent files list',self.clear_recent,[None]
        ]      
        self.add_menu_item(*content)

        content = [recent,gtk.SeparatorMenuItem,
                   None,None,
                   None,[None]
        ]
        self.add_menu_item(*content)
        self.add_menu_item(*content) 
        if not recent_dict:
            content = [recent,gtk.MenuItem,None,
                       'No items',None,None
            ]
            self.add_menu_item(*content)
            last = None
            for i in recent.get_children():
                last = i
            last.set_sensitive(False)
        else:
            for name,data in recent_dict.items():
                icon = self.get_file_icon(data)
                content = [recent, gtk.ImageMenuItem,
                           icon, name[:self.name_length],
                           self.open_item, [data]
                ]
                self.add_menu_item(*content)

        # Pinned files
        bookmarks = self.add_submenu(self.app_menu,'Pinned Files')
        content = [bookmarks,gtk.ImageMenuItem,
                   'bookmark_add','Pin a file',
                   self.pin_file,[bookmarks,None]
        ]
        self.add_menu_item(*content)

        content = [bookmarks,gtk.ImageMenuItem,
                   'remove','Remove item',
                   self.remove_pinned,['files']
        ]
        self.add_menu_item(*content)

        content = [bookmarks,gtk.ImageMenuItem,
                   'user-trash','Remove All',
                   self.remove_all_pinned,[None]
        ]
        self.add_menu_item(*content)
        content = [bookmarks,gtk.SeparatorMenuItem,
                   None,None,
                   None,[None]
        ]
        self.add_menu_item(*content)
        self.add_menu_item(*content) 

        pinned_files = self.get_pinned()

        if (pinned_files and 
            'files' in pinned_files.keys() and
            pinned_files['files']):
            for filepath in pinned_files['files']:
                icon = self.get_file_icon(filepath) 
                content = [bookmarks,gtk.ImageMenuItem,
                           icon,os.path.basename(filepath),
                           self.open_item,[filepath]
                ]
                self.add_menu_item(*content)
        else:
            content = [bookmarks,gtk.MenuItem,None,
                       'No items',None,None
            ]
            self.add_menu_item(*content)
            last = None
            for i in bookmarks.get_children():
                last = i
            last.set_sensitive(False)

        places = self.add_submenu(self.app_menu,'Places')
        content = [places,gtk.ImageMenuItem,'add',
                   'Pin Directory',self.pin_dir,[None]
        ]

        self.add_menu_item(*content)

        content = [places,gtk.ImageMenuItem,
                   'remove','Remove Pinned',
                   self.remove_pinned,['dirs']
        ]
        self.add_menu_item(*content)

        content = [places,gtk.SeparatorMenuItem,
                   None,None,
                   None,[None]
        ]
        self.add_menu_item(*content)

        content = [places,gtk.MenuItem,None,
                   'Standard Dirs',None,None
        ]
        self.add_menu_item(*content)
        last = None
        for i in places.get_children():
            last = i
        last.set_sensitive(False)
        for dir in self.get_user_dirs():
            icon = self.get_file_icon(dir)
            content = [places,gtk.ImageMenuItem,icon,
                       os.path.basename(dir),self.open_item,[dir]

            ]
            self.add_menu_item(*content)

        content = [places,gtk.SeparatorMenuItem,
                   None,None,
                   None,[None]
        ]
        self.add_menu_item(*content)

        content = [places,gtk.MenuItem,None,
                   'Pinned Dirs',None,None
        ]
        self.add_menu_item(*content)
        last = None
        for i in places.get_children():
            last = i
        last.set_sensitive(False)

        if (pinned_files and 
           'dirs' in pinned_files.keys() and
           pinned_files['dirs']):
            for dir in pinned_files['dirs']:
                icon = self.get_file_icon(dir)
                print(icon)
                content = [places,gtk.ImageMenuItem,icon,
                           os.path.basename(dir),self.open_item,[dir]

                ]
                self.add_menu_item(*content)
        else:
            content = [places,gtk.MenuItem,None,
                       'No items',None,None
            ]
            self.add_menu_item(*content)
            last = None
            for i in places.get_children():
                last = i
            last.set_sensitive(False)

        content = [self.app_menu,gtk.SeparatorMenuItem,
                   None,None,
                   None,[None]
        ]
        self.add_menu_item(*content)
        content = [self.app_menu,gtk.ImageMenuItem,'exit',
                   'quit',self.quit,[None]
        ]
        self.add_menu_item(*content)
        self.app.set_menu(self.app_menu)

    def check_directory(self,*args):
        current_set = set(os.listdir(args[-1]))
        return current_set - self.cached_set


    def get_pinned(self,*args):
        try:
            with open(self.pinned_list) as f:
                 return json.load(f,object_pairs_hook=OrderedDict)

        except FileNotFoundError:
            print('>>> ',self.pinned_list,' not found')
            return None
        except json.JSONDecodeError:
            print(">>> Can't read ",self.pinned_list,',may be corrupt')
            return None

    def pin_dir(self,*args):
        # TODO
        current_list = self.get_pinned()
        if not current_list:
                current_list = OrderedDict()
                current_list['dirs'] = []
                f = open(self.pinned_list,'w')
                f.write("")
                f.close()

        if not args[-1]:
                cmd = "zenity --file-selection --directory --separator || --multiple"
                dirs = self.run_cmd(cmd.split())
        else:
                dirs = args[-1]

        dir_list = []
        if not dirs: return None
        dir_list = dirs.decode().strip().split("||")
        if not 'dirs' in current_list.keys():
             current_list['dirs'] = []
        for f in dir_list:
                #icon = self.get_file_icon(f)
                current_list['dirs'].append(f)

        with open(self.pinned_list,'w') as f:
                json.dump(current_list,f,indent=4)
        self.make_menu()

    def pin_file(self,*args):
        current_list = self.get_pinned()
        if not current_list:
                current_list = OrderedDict()
                current_list['files'] = []
                f = open(self.pinned_list,'w')
                f.write("")
                f.close()
        if not args[-1]:
                cmd = "zenity --file-selection --separator || --multiple "
                files = self.run_cmd(cmd.split())
        else:
                files = args[-1]

        file_list = []
        if not files: return None
        file_list = files.decode().strip().split("||")
        if not 'files' in current_list.keys():
            current_list['files'] = []
        for f in file_list:
                #icon = self.get_file_icon(f)
                current_list['files'].append(f)

        with open(self.pinned_list,'w') as f:
                json.dump(current_list,f,indent=4)
        self.make_menu()

    def remove_all_pinned(self,*args):
        try:
            #os.unlink(self.pinned_list)

            with open(self.pinned_list) as f:
                pinned = json.load(f)
            pinned.pop('files')       
            with open(self.pinned_list,'w') as f:
                    json.dump(pinned,f,indent=4)
        except:
            pass
        finally:
            self.make_menu()

    def remove_pinned(self,*args):
        key = args[-1]
        pinned = self.get_pinned() 
        if not pinned: return
        cmd_str = "zenity --forms --add-combo Remove --combo-values"
        vals = "|".join(pinned[key])
        cmd = cmd_str.split() + [vals]
        item = self.run_cmd(cmd)
        if item: 
            path = item.decode().strip()
            index = pinned[key].index(path)
            pinned[key].pop(index)
            with open(self.pinned_list,'w') as f:
                json.dump(pinned,f,indent=4)
            self.make_menu()

    def add_recent(self,*args):
        cmd = "zenity --file-selection --separator || --multiple "
        files = self.run_cmd(cmd.split())
        file_list = []
        if not files: return
        file_list = files.decode().strip().split("||")
        items = ['file://' + f for f in file_list]
        for f in items: gtk.RecentManager().get_default().add_item(f)

    def clear_recent(self,*args):
        try:
            gtk.RecentManager.get_default().purge_items()
            self.make_menu()
        except:
            pass

    def open_item(self,*args):
        #self.run_cmd(['xdg-open',args[-1]]) 
        if args[-1].endswith('.desktop'):
            desk_file = Gio.DesktopAppInfo.new_from_filename(args[-1])
            return desk_file.launch_uris()
        return subprocess.Popen(['xdg-open',args[-1]])

    def quit(self,*args):
        gtk.main_quit()

    def run_cmd(self, cmdlist):
        """ utility: reusable function for running external commands """
        #new_env = dict(os.environ)
        #new_env['LC_ALL'] = 'C'
        try:
            stdout = subprocess.check_output(cmdlist) #env=new_env)
        except subprocess.CalledProcessError:
            pass
        else:
            if stdout:
                return stdout

    def run(self):
        """ Launches the indicator """
        try:
            gtk.main()
        except KeyboardInterrupt:
            pass

    def quit(self, *args):
        """ closes indicator """
        gtk.main_quit()


def main():
    """ defines program entry point """
    indicator = FilesIndicator()
    indicator.run()

if __== '__main__':
  try:
    main()
  except  KeyboardInterrupt:
    gtk.main_quit()

Les configurations

L'indicateur est configuré via deux fichiers JSON stockés dans le répertoire de base de l'utilisateur.

~/.files_indicator.json contrôle l'interface utilisateur, la longueur des entrées de menu et le nombre maximum dans le menu Fichiers récents.

{
    "name_length": 30,
    "max_items": 10
}

Le ~/.pinned_files.json contrôle les listes de fichiers et de dossiers épinglés. Chaque élément est une liste/tableau.

{
    "dirs": [
        "/home/xieerqi/\u56fe\u7247/Wallpapers"
    ],
    "files": [
        "/home/xieerqi/work_in_progress/videonauth_code.py",
        "/home/xieerqi/work_in_progress/spin_button.py"
    ]
}
1

Pas une icône de barre d'état, mais un script de liste rapide pour le launcher d'unité (fonctionne avec Umlauts), et vous pouvez également épingler des fichiers: buntu-Recentquicklists

URQ screenshot

[instructions d'installation détaillées ici]

Instructions rapides:

  • télécharger .Zip
  • extrait
  • faire install.sh et ubuntu-recentquicklists.py exécutable
  • lancer le script install.sh

Fonctionnalités:

  • ajoute automatiquement les fichiers récents
  • ajouter manuellement des fichiers non récents/épingler des fichiers récents
  • spécifier le nombre d'éléments par liste que vous souhaitez et
  • quel âge les objets peuvent être
  • résoudre les liens symboliques
  • affiche le chemin complet (ou juste le nom du fichier, comme sur la capture d'écran)
1
hirsch