Exécuter un fichier .desktop dans le terminal


142

D'après ce que je peux .desktopcomprendre , les fichiers sont des raccourcis permettant de personnaliser les paramètres de l'application. Par exemple, j'en ai beaucoup dans mon /usr/share/applications/dossier.

Si j'ouvre ce dossier nautilus, je peux exécuter ces applications en double-cliquant sur le fichier qui lui est associé, par exemple en double-cliquant firefox.desktopsur Firefox. Cependant, je ne trouve pas le moyen de faire la même chose via un terminal.

Si je le fais gnome-open foo.desktopouvre simplement foo.desktopcomme un fichier texte. Si je le rend exécutable puis que je l'exécute en bash, il échoue simplement (ce qui est prévu, ce n'est clairement pas le script bash).
EDIT: Faire exec /fullpath/foo.desktopme donne un Permission deniedmessage, même si je change de propriétaire pour moi-même. Si je m’exécute et que je fais la même commande, l’onglet du terminal que j’utilise est tout simplement fermé (je suppose qu’il se bloque). Enfin, si je le fais sudo exec /fullpath/foo.desktop, je reçois un rapport d'erreur sudo: exec: command not found.

Voilà ma question, comment puis-je exécuter un foo.desktopfichier à partir du terminal?


5
NB: La raison de votre execéchec est parce qu'exec remplace votre processus en cours d'exécution par le processus que vous spécifiez. Vous avez donc essayé de remplacer votre shell par l'exécution du poste de travail sous forme de fichier binaire compilé. La raison pour laquelle vous ne pouviez pas le faire sudo execest qu'il s'agit d'un shell intégré et non d'une commande binaire.
Daenyth

Intéressant, je me demandais pourquoi cela a causé la fermeture de l'onglet.
Malabarba


Je vois, ils finissent par analyser le fichier .desktop. Merci quand même pour le lien.
enzotib

modérateurs: oups, je pense que j'ai peut-être signalé cela par accident, désolé si tel est le cas
Croad Langshan le

Réponses:


54

La commande qui est exécutée est contenue dans le fichier du bureau, précédée de Exec=afin que vous puissiez l'extraire et l'exécuter comme suit:

`grep '^Exec' filename.desktop | tail -1 | sed 's/^Exec=//' | sed 's/%.//' | sed 's/^"//g' | sed 's/" *$//g'` &

Pour décomposer cela

grep  '^Exec' filename.desktop    - finds the line which starts with Exec
| tail -1                         - only use the last line, in case there are multiple
| sed 's/^Exec=//'                - removes the Exec from the start of the line
| sed 's/%.//'                    - removes any arguments - %u, %f etc
| sed 's/^"//g' | sed 's/" *$//g' - removes " around command (if present)
`...`                             - means run the result of the command run here
&                                 - at the end means run it in the background

Vous pouvez mettre cela dans un fichier, par exemple ~/bin/deskopenavec le contenu

#!/bin/sh
`grep '^Exec' $1 | tail -1 | sed 's/^Exec=//' | sed 's/%.//' | sed 's/^"//g' | sed 's/" *$//g'` &

Puis le rendre exécutable

chmod +x ~/bin/deskopen

Et alors vous pourriez faire, par exemple

deskopen /usr/share/applications/ubuntu-about.desktop

Les arguments ( %u, %Fetc.) sont détaillés sur http://standards.freedesktop.org/desktop-entry-spec/desktop-entry-spec-1.0.html#exec-variables - aucun d’entre eux n’est pertinent pour un lancement en ligne de commande. .


Cela donne le meilleur résultat jusqu'à présent, mais cela produit parfois un comportement indésirable. Cela se produit chaque fois que la ligne "Exec =" a un argument tel que% u ou% i. Bash essaie de transmettre cette chaîne en tant qu'argument normal. Par exemple, faire grep '^Exec' firefox.desktop | sed 's/^Exec=//'ouvre Firefox avec un onglet qui charge www.% U.com .
Malabarba

Pour le moment, j'ai ajouté une seconde sedpour supprimer tous les arguments. Mais je pense qu’il pourrait y avoir une façon plus "naturelle" de le gérer.
Malabarba

J'ai mis à jour ma réponse avec extra sed - j'ai oublié que les fichiers du bureau pouvaient avoir des arguments.
Hamish Downer

Vous devez ajouter un "tail -1" au tube après "grep", car "Exec =" peut apparaître plusieurs fois, après quoi seule la dernière apparition doit être exécutée.
daisy

13
-1: Cela peut fonctionner pour des .desktopfichiers simples , mais il ignore les entrées telles que Path=et TryExec=qui peuvent affecter l'exécution. Il s’exécute également de manière erronée Exec=si le fichier contient des actions du bureau ("quicklists")
MestreLion

85

La réponse devrait être

xdg-open program_name.desktop

Mais à cause d' un bug, cela ne fonctionne plus.


7
WoW c'est toujours un bug, beaucoup de progrès dans xdg. exo-openest répertorié comme solution de contournement et ouvre gedit aussi. :(
Dessiné

1
@RichardHolloway: gnome-openne pas appeler xdg-open, il est l'inverse! Donc, le problème réside dans gvfs-open(le successeur ou gnome-open)
MestreLion

13
"ne fonctionne plus"? Cela n'a jamais fait! xdg-openfonctionne par association de types MIME, et les .desktopfichiers sont associés aux éditeurs de texte, car ils sont une sous-classe de texte
MestreLion

13
c'est tellement stupide (qu'il n'y a pas de moyen raisonnable d'exécuter un fichier Desktop à partir du terminal)
Sam Watkins

2
Cela fonctionne pour moi sur Arch Linux, mais c'est peut-être un bogue spécifique à Ubuntu.
Victor

76

Avec tout ubuntu récent qui prend en charge gtk-launchtout simplement aller

gtk-launch <file>où est le nom du fichier .desktop avec ou sans la .desktoppartie

Donc gtk-launch fooouvrefoo.desktop

( gtk-launchdocumentation )

Le fichier .desktop doit se trouver dans / usr / share / applications, / usr / local / share / applications ou ~ / .local / share / applications

Utilisable depuis le terminal ou alt + F2 (alt + F2 enregistre la commande dans l'historique si facilement accessible)


C'est comme ça que ça marche aussi dans debian.

gtk-launch firefox.desktop ~ / .local / share / applications / lance Firefox en consultant le répertoire ~ / .local / share / applications / pour moi. Il semble que si vous aviez raison, le répertoire du fichier .desktop n'aurait pas dû être transmis à firefox comme argument. En fait, le répertoire passé à gtk-launch n'est pas censé être utilisé pour localiser le répertoire contenant le fichier .desktop (et ne l'est pas, en fait)
Croad Langshan le

Yay! Une réponse qui fonctionne!
Alicia

Cela fonctionne pour moi dans Arch Linux également. Aucune des autres réponses n'était satisfaisante, mais celle-ci est bonne. :-) Cela fonctionne même si je suis sous KDE.
MountainX

2
Aucune version de cela ne fonctionne pour moi sur Ubuntu 18.10. Chaque fois qu'il se plaint, l'application n'existe pas, que je sois ou non dans le dossier du bureau, que j'inclue ou non l'extension .desktop et que je nomme le répertoire séparément.
Joseph Garvin

38

A partir d'aujourd'hui (12h10), le bogue est toujours présent. Cela dépend en fait de la façon dont gvfs-open(appelé par xdg-open) fonctionne.

Malgré tout, j'ai réussi à contourner rapidement ce problème (en m'inspirant du code source de Nautilus). C'est un peu compliqué, mais fonctionne parfaitement sur Ubuntu 12.10, en ajoutant une icône significative (sans plus ?) sur le lanceur Unity.

Tout d'abord, j'ai écrit un script python à l'aide de Gio et l'ai placé sous le nom ~/bin/run-desktop:

#!/usr/bin/python

from gi.repository import Gio
import sys 

def main(myname, desktop, *uris):
    launcher = Gio.DesktopAppInfo.new_from_filename(desktop)
    launcher.launch_uris(uris, None)

if __name__ == "__main__":
    main(*sys.argv)

Le script doit avoir l'autorisation de l'exécutable, j'ai donc lancé ceci dans un terminal:

chmod +x ~/bin/run-desktop

Ensuite, j'ai créé l' .desktopentrée relative sur ~/.local/share/applications/run-desktop.desktop:

[Desktop Entry]
Version=1.0
Name=run-desktop
Exec=run-desktop %U
MimeType=application/x-desktop
Terminal=false
Type=Application

Enfin, j’ai associé l’entrée en tant que gestionnaire par défaut ~/.local/share/applications/mimeapps.listsous la [Default Applications]section:

[Default Applications]
....
application/x-desktop=run-desktop.desktop

Maintenant:

  • xdg-open quelque chose.desktop fonctionne comme prévu
  • #!/usr/bin/xdg-open hashbang au-dessus d'une entrée de bureau exécutable fonctionne aussi

Ce sera un travail inutile quand gvfs-openle bug sera résolu, mais en attendant ...


1
Cela fonctionne mieux que la réponse de Hamish Downer, car il traitera correctement plusieurs Exec=lignes et %paramètres dans la commande.
Flimm

4
Merci pour le code - je suis sur Lucid, et je l'ai simplement sauvegardé sous /usr/bin/xdg-openpy, et lui ai donné un chmod +x- et utilisé à la launcher.launch([],context)place de ...None,context)(à cause de " TypeError: argument 1: Doit être une séquence, pas NoneType "). Maintenant xdg-openpy app.desktopfonctionne en ligne de commande (et tout comme d'habitude lorsque vous double-cliquez app.desktop), et il peut me rappeler si j'essaie d'appeler dans le terminal xdg-openet d'appuyer sur la touche de tabulation. À votre santé!
Sdaau

3
+1 C'est la seule réponse qui n'exige pas l'analyse manuelle du .desktopfichier, c'est donc l'approche la plus saine (et sûre). Utilise également moderne gi.repositoryau lieu de obsolète pygtk, donc super! :)
MestreLion

2
En fait, cette question concerne la réponse de Carlo Pellegrini. Je suis nouveau, corrigez-moi s'il y avait une meilleure façon de le placer. Le script fonctionne vraiment bien, mais l'icône que je reçois sur le lanceur Unity n'est pas l'icône définie dans le fichier .desktop, mais l'icône par défaut de la commande 'Exec'ed. Des idées à ce sujet?
Ingo Leonhardt

1
@Noitidart écrire la dernière réponse conduit mo à faire un peu de google et j'ai trouvé que . Je n'ai pas vérifié, mais peut-être que ça aide
Ingo Leonhardt

31

Le droit chemin

Vous devriez vraiment utiliser gtk-launchs'il est disponible. Cela fait généralement partie du paquet libgtk-3-bin (cela peut varier en fonction de la distribution).

gtk-launch est utilisé comme suit:

gtk-launch APPLICATION [URI...]
gtk-launch app-name.desktop
gtk-launch app-name

Veuillez noter que gtk-launchle fichier .desktop doit être installé (c'est-à-dire situé dans /usr/share/applicationsou ~/.local/share/applications).

Donc, pour contourner ce problème, nous pouvons utiliser une petite fonction haletante de Bash qui installe temporairement le fichier .desktop souhaité avant de le lancer. La méthode "correcte" pour installer un fichier .desktop est via, desktop-file-installmais je vais l'ignorer.

launch(){

    # Usage: launch PATH [URI...]

    # NOTE: The bulk of this function is executed in a subshell, i.e. `(..)`
    #       This isn't strictly necessary, but it keeps everything
    #       out of the global namespace and lessens the likelihood
    #       of side effects.

    (

    # where you want to install the launcher to
    appdir=$HOME/.local/share/applications

    # the template used to install the launcher
    template=launcher-XXXXXX.desktop

    # ensure $1 has a .desktop extension, exists, is a normal file, is readable, has nonzero size
    # optionally use desktop-file-validate for stricter checking
    # desktop-file-validate "$1" 2>/dev/null || {
    [[ $1 = *.desktop && -f $1 && -r $1 && -s $1 ]] || {
        echo "ERROR: you have not supplied valid .desktop file" >&2
        return 1
    }

    # ensure the temporary launcher is deleted upon exit
    trap 'rm "$launcherfile" &>/dev/null' EXIT

    # create a temp file to overwrite later
    launcherfile=$(mktemp -p "$appdir" "$template")

    launchername=${launcherfile##*/}

    # overwrite temp file with the launcher file
    if cp "$1" "$launcherfile" &>/dev/null; then
        gtk-launch "$launchername" "${@:2}"
    else
        echo "ERROR: failed to copy launcher to applications directory" >&2
        return 1
    fi

    )

}

Vous pouvez l'utiliser comme ça (et également transmettre des arguments supplémentaires ou des URI si vous le souhaitez):

launch PATH [URI...]
launch ./path/to/shortcut.desktop

L'alternative manuelle

Si vous souhaitez analyser et exécuter manuellement un fichier .desktop , vous pouvez le faire avec la awkcommande suivante :

awk '/^Exec=/ {sub("^Exec=", ""); gsub(" ?%[cDdFfikmNnUuv]", ""); exit system($0)}' app-name.desktop

Si vous souhaitez traiter la awkcommande comme un script tout-en-un; nous pouvons même afficher un message d'erreur et quitter avec un code de retour de 1 dans le cas où une commande Exec est introuvable:

awk 'BEGIN {command=""} /^Exec=/ {sub("^Exec=", ""); gsub(" ?%[cDdFfikmNnUuv]", ""); command=$0; exit} END {if (command!="") {exit system(command)} else {if (FILENAME == "-") {printf "ERROR: Failed to identify Exec line\n" > "/dev/stderr"} else {printf "ERROR: Failed to identify Exec line in \047%s\047\n", FILENAME > "/dev/stderr"} close("/dev/stderr"); exit 1}}'

Les commandes susmentionnées vont:

  1. Trouver la ligne commençant par Exec =
  2. Supprimer Exec =
  3. Retirez toutes les variables Exec (par exemple %f, %u, %U). Il est possible de remplacer ceux-ci par des arguments de position comme le prévoit la spécification, mais cela compliquerait considérablement le problème. Voir la dernière spécification du poste de travail .
  4. Exécuter la commande
  5. Quitter immédiatement avec le code de sortie approprié (afin de ne pas exécuter plusieurs lignes Exec )

Notez que ce script AWK aborde quelques cas marginaux qui peuvent ou ne peuvent pas être traités correctement par certaines des autres réponses. Plus précisément, cette commande supprime plusieurs variables Exec (en prenant soin de ne pas supprimer le symbole%), n'exécutera qu'une seule commande de ligne Exec et se comportera comme prévu même si la commande de ligne Exec contient un ou plusieurs signes égal (par exemple script.py --profile=name).

Juste quelques autres avertissements ... Selon la spécification, TryExec est:

Chemin d'accès à un fichier exécutable sur le disque utilisé pour déterminer si le programme est réellement installé. Si le chemin n'est pas un chemin absolu, le fichier est recherché dans la variable d'environnement $ PATH. Si le fichier n'est pas présent ou s'il n'est pas exécutable, l'entrée peut être ignorée (ne pas être utilisée dans les menus, par exemple).

Dans cet esprit, il n’a aucun sens d’exécuter sa valeur.

Path et Terminal sont quelques autres problèmes . Path est constitué du répertoire de travail dans lequel exécuter le programme. Terminal est un booléen indiquant si le programme est exécuté dans une fenêtre de terminal. Tous ces problèmes peuvent être résolus, mais il est inutile de réinventer la roue car il existe déjà des implémentations de la spécification. Si vous souhaitez implémenter Path , gardez à l'esprit que system()génère un sous-processus, vous ne pouvez donc pas modifier le répertoire de travail en procédant de la manière suivante system("cd \047" working_directory "\047"); system(command). Cependant, vous pourriez probablement faire quelque chose comme system("cd \047" working_directory "\047 && " command). Note \ 047 sont des guillemets simples (pour que la commande ne soit pas interrompue sur les chemins contenant des espaces).

L'alternative Python

Je vole une page de Carlo ici , qui a suggéré de créer un script Python pour utiliser le module gi . Voici un moyen minimal d'exécuter le même code à partir du shell sans avoir à créer un fichier et à vous soucier des E / S.

launch(){

# Usage: launch PATH [URI...]

python - "$@" <<EOF
import sys
from gi.repository import Gio
Gio.DesktopAppInfo.new_from_filename(sys.argv[1]).launch_uris(sys.argv[2:])
EOF

}

Puis exécutez la fonction lanceur comme suit:

launch ./path/to/shortcut.desktop

Notez que l'utilisation des URI est facultative. En outre, aucune vérification d'erreur n'est effectuée. Vous devez donc vous assurer que le programme de lancement existe et qu'il est lisible (avant de l'utiliser) si vous souhaitez que votre script soit durable.


Mais la awkcommande est sympa. Par conséquent, un +1
AB

Qu'est-ce qu'un URI dans ce contexte? J'ai un fichier de bureau dans un dossier arbitraire. Comment diable puis-je simplement lancer gtk-launch sans avoir à l'envelopper dans un autre script? C'est exaspérant.
Joseph Garvin

Cette awksolution ne fonctionnera pas correctement si la commande comporte des espaces blancs ou des barres obliques inverses à double échappement. Cela tombe en panne: Exec=env WINEPREFIX="/path/to/.wine" wine c:\\\\windows\\\\command\\\\start.exe /Unix /path/to/.wine/dosdevices/c:/users/Public/Рабочий\\ стол/appname.lnket la dexsolution fonctionne bien.
MarSoft

27

Alors que OP ne demandait pas à propos de KDE, pour toute personne utilisant KDE, la commande suivante peut être utilisée:

kioclient exec <path-to-desktop-file>

Sur Fedora, cela est inclus dans le kde-runtimerégime.


5
Upvote parce que ça marche. Nul besoin d’exécuter KDE tant que ce programme est installé.
basic6

Y at-il un moyen d'avoir stdout de cela? J'ai compilé le lecteur de clémentine, qui a un bug qui se produit uniquement par le biais d'un fichier .desktop (avec plasma-shell). Et je n'arrive pas à comprendre comment avoir un journal de sortie.
Kwaadpepper

@Kwaadpepper, vous pouvez utiliser votre fichier .desktop pour lancer un script shell, qui exécute en interne votre commande et redirige la sortie vers un fichier.
Raman

Je ne trouve kioclient dans aucun paquet de KDE pour Arch Linux pour le moment. Cependant, gtk-launch fonctionne sous KDE pour moi.
MountainX

15

Vous pouvez utiliser dex .

dex foo.desktop

2
IMHO c'est exactement la bonne réponse: Un seul outil, un seul appel avec uniquement le fichier comme paramètre. C'est ce que je recherchais aussi pour tester des .desktopfichiers manuscrits . Et il peut créer des .desktopfichiers aussi, yay! :-)
Axel Beckert le

Parfait! Si vous ajoutez un fichier .desktop qui utilise dex gist.github.com/stuaxo/4169fc1342c496b7c8f7999188f2f242 à / usr / share / applications /, vous pourrez également lancer les fichiers du bureau dans le gestionnaire de fichiers sans qu'ils ne s'ouvrent par défaut dans gedit.
Stuart Axon

13
exo-open [[path-to-a-desktop-file]...]

semble fonctionner dans la version 13.10, si exo-utils est installé (comme c'est le cas avec Xubuntu).


Oui, je viens de le tester dans Ubuntu Studio 14.04. BTW. xdg-open et gvfs-open y travaillent également.
mardi

Fonctionne aussi en 15
Jonathan

Utiliser Debian avec xfce. Fonctionne très bien!
king_julien

Travaille pour moi dans Ubuntu 14.04
Tyler Collier

8

Addendum à la réponse de Hamish.

Etant donné le script deskopen, vous pouvez utiliser une référence à celle-ci en tant que ligne shebang dans un fichier .desktop , car le caractère de commentaire est toujours #. C'est-à-dire, mettez ceci comme première ligne du fichier .desktop :

#!/usr/bin/env deskopen

Ensuite, marquez le fichier .desktop en tant que fichier exécutable (par exemple avec a chmod +x whatever.desktop), puis vous pourrez

path/to/whatever.desktop

et voilà - L'application va s'ouvrir! (Complétez le fichier d'icône que j'ai spécifié, bien que je ne sache pas comment.)

Maintenant, si vous souhaitez également que deskopen transmette des paramètres de ligne de commande, vous pouvez utiliser cette version légèrement modifiée:

#!/bin/sh
desktop_file=$1
shift
`grep '^Exec' "${desktop_file}" | sed 's/^Exec=//' | sed 's/%.//'` "$@" &

En passant, j'ai essayé d'utiliser "#{@:2}"au lieu d' shifting, mais cela continuait à me donner une "mauvaise substitution" ...


Je sais que c'est plutôt un commentaire sur la réponse de Hamish, mais je suis un nouvel utilisateur et je ne suis pas autorisé à commenter. Tant pis!
mardi

Si vous avez la réputation, l’action la plus appropriée serait de modifier cette réponse, en fait.
Flimm

Attaquez-vous, n'importe qui peut suggérer des modifications, même les utilisateurs qui ne se sont pas connectés! Ce n'est pas grave.
Flimm

1
C'est une réponse en soi, c'est bien.
Bruno Pereira

vous pouvez utiliser "${@:1}"au lieu de shift, mais cela nécessite bashau lieu de shdans votre #!shebang. IMHO votre approche d'équipe originale est plus simple et meilleure
MestreLion,

6

Il n'y a actuellement aucune application qui fasse ce que vous décrivez dans les archives Ubuntu. Quelques efforts sont en cours pour créer une solution générale offrant une intégration pour les environnements de bureau (tels que openbox) qui ne sont pas conformes à ces spécifications XDG.

Arch Linux travaille sur une implémentation de xdg-autostart basée sur les bibliothèques python-xdg. D'après ce que je peux trouver, cela ne semble pas encore tout à fait complet, mais il existe des rapports de succès.

Il existe également une implémentation C ++ de xdg-autostart sur gitorious (http://gitorious.org/fr/xdg-autostart/) qui bénéficierait probablement d'une utilisation plus large.

Si l'une de ces solutions vous convient, envisagez de soumettre le travail nécessaire à l'inclusion dans Debian ou Ubuntu.

Pour utiliser l'un des deux outils avec openstart, vous devez l'appeler dans /etc/xdg/openbox/autostart.sh (si je lis correctement la documentation openbox). Si cela ne fonctionne pas, vous pouvez probablement l'appeler dans n'importe lequel des scripts d'initialisation de session openbox.


Pas ce que je voudrais entendre, en tout cas merci pour l'info
enzotib

6

Je n'ai pas de solution immédiate répondant à la condition "d'utiliser une commande standard" , mais si vous souhaitez analyser les .desktopfichiers de manière minimale ou si vous souhaitez créer un alias Bash, les éléments suivants devraient fonctionner:

  • awk -F= '/Exec=/{system($2); exit}' foo.desktop

Une autre approche qui pourrait être intéressante serait de créer une binfmt-miscméthode au niveau du noyau qui ne correspond pas aux .desktopfichiers (voir grep -r . /proc/sys/fs/binfmt_misc/pour les modèles que vous avez activés).

À la fin de la journée, quelque chose quelque part devra analyser les .desktopfichiers, c'est juste une question de comment "standard / default" c'est.


Merci, intéressant. En tant que "standard", je veux dire quelque chose fourni par le DE et conforme à freedesktop.org.
enzotib

Upvote pour awkplutôt que d'une chaîne de greps et seds.
Jmtd

Vote positif, bien que cela ne fonctionne pas (ou mieux, fonctionne trop) si vous avez plusieurs Exec=lignes: /
Boris Churzin

2

J'ai repris le script de la réponse de Carlo ci-dessus et j'ai tenté de l'améliorer pour mon propre usage sur le bureau.

Cette version du script vous permettra d'exécuter n'importe quelle application comme si vous l'aviez entrée sur le HUD, à condition que ce soit probablement le premier résultat. Il vous permet également de passer des arguments de fichier pour les fichiers .desktop qui ne prennent pas en charge les URI.

#!/usr/bin/env python

from gi.repository import Gio
from argparse import ArgumentParser
import sys, os

def find_app(search_string):
    for group in Gio.DesktopAppInfo.search(search_string):
        for entry in group:
            try:
                return Gio.DesktopAppInfo.new(entry)
            except: pass
    return None

def main(args):
    launcher = None
    if os.path.isfile(args.appName):
        try:
        # If it's a file, do that first.
            launcher = Gio.DesktopAppInfo.new_from_filename(args.appName)
        except TypeError:
            print "'" + args.appName + "' is not a .desktop file"
            sys.exit(-1)
    # If it's a .desktop file in the DB, try using that
    if launcher is None and args.appName.endswith('.desktop'):
        try:
            launcher = Gio.DesktopAppInfo.new(args.appName)
        except TypeError: pass

    if launcher is None:
        # Search for the app by the text given
        launcher = find_app(args.appName)

    if launcher is None:
        print "No app named " + args.appName + " could be found"
        sys.exit(-1)
    if (launcher.supports_uris()):
        launcher.launch_uris(args.uris, None)
    elif (launcher.supports_files()):
        launcher.launch(list({ Gio.File.parse_name(x) for x in args.uris }), None)
    else :
        launcher.launch()

if __name__ == "__main__":
    argParser = ArgumentParser(description="Launch a .desktop file or application")
    argParser.add_argument("appName", 
        help="the name of any application, a desktop file's basename, or a concrete path to a desktop file", 
        action='store'
    )
    argParser.add_argument("uris", 
        nargs='*', 
        help="Files or URIs to pass to the application"
    )
    args = argParser.parse_args()
    main(args)

1

En essayant de tester ces fichiers, j’ai trouvé le moyen le plus simple de vérifier que le gestionnaire de session ou le gestionnaire de sessions ferait ce que j’attendais: ouvrir le répertoire environnant dans un navigateur de dossiers d’UI, puis double-cliquer pour les ouvrir.

Si vous êtes en ligne de commande: gvfs-open .ou gnome-open .l'ouvrirez dans le navigateur de dossiers configuré.

Le système sed ne reflétera pas le comportement du sous-ministre, y compris des choses délicates telles que des évasions et citant les endroits où vous ne voudriez pas d'un comportement alternatif. Ce n'est pas une ligne de commande, mais cela a validé les choses. J'ai également trouvé le réglage Terminal=trueutile pour le débogage.


Le terminal disparaît immédiatement, je n'ai pas le temps de voir le message lorsque Terminal = true: s
gouessej

1

Cette réponse SO est ce qui m’a permis de comprendre: n’essayez pas d’exécuter le fichier de bureau, mais exécutez le fichier indiqué dans le fichier de bureau.

Par exemple, exécutez /home/jsmith/Desktop/x11vnc.sh

Exec=/home/jsmith/Desktop/x11vnc.sh

1

(Compilé à partir des différentes autres réponses ici)

En fonction de votre système et des divers bogues qui peuvent ou non exister sur votre système, essayez les étapes suivantes jusqu'à ce que l'un d'entre eux fonctionne:

  1. xdg-open program_name.desktop
  2. exo-open program_name.desktop
  3. gtk-launch program_name.desktop
  4. kioclient exec program_name.desktop
  5. dex program_name.desktop

Notez que sur les systèmes Ubuntu, vos lanceurs de bureau "Menu Démarrer" sont disponibles dans /usr/share/applications/.

A titre d'exemple, pour montrer quelles commandes ci-dessus fonctionnent ou non sur mon système Ubuntu 14.04, voici les résultats des appels suivants pour moi:

  1. xdg-open /usr/share/applications/eclipse_for_cpp.desktop # Échoue à cause d'un bogue (essaie de me faire sauvegarder ce fichier .desktop)
  2. exo-open /usr/share/applications/eclipse_for_cpp.desktop # Travaux
  3. gtk-launch /usr/share/applications/eclipse_for_cpp.desktop # Échoue avec "gtk-launch: aucune application de ce type"
  4. kioclient exec /usr/share/applications/eclipse_for_cpp.desktop # Travaux
  5. dex /usr/share/applications/eclipse_for_cpp.desktop# Échec, et sudo apt install deximpossible de localiser le paquet dex

0

Assurez-vous que le script sur lequel pointe votre fichier de bureau est également exécutable.

Si ça ne marche toujours pas. Rendre le fichier de bureau exécutable dans le terminal en le changeant Terminal=trueet le placer dans un script bash. Exécutez le script pour intercepter la sortie d'erreur. Revenir en arrière lorsque les erreurs sont corrigées.


0

La réponse de Hamish est excellente, mais j'aimerais suggérer une alternative plus simple, avec moins de tuyauterie:

$(awk -F= '/^Exec/||/^TryExec/ {print $2;exit}' /usr/share/applications/firefox.desktop)

Dans ce cas, awkrecherche une ligne commençant par Exec, puis nous imprimons simplement les champs après cette ligne, en utilisant for et =nous imprimons le champ 2, c’est-à-dire tout ce qui vient après ce champ. Les accolades aux extrémités des commandes, $(...)sont des substitutions de paramètres, ainsi le shell exécutera toutes les commandes awk retournées; dans ce cas, il retourne la commande réelle qui vient après Exec=.

Dans de rares cas, il peut y avoir plus d’un =signe, ce qui reste une possibilité. Pour cela, je suggère

$(awk -F= '/^Exec/||/^TryExec/ {for(i=2;i<=NF;i++) print $i;exit}' /usr/share/applications/firefox.desktop)

Nice awket Serg =)
AB

Et parfois, il y a un TryExec, peut-être devriez-vous vérifier votre 2e commande =)
AB

@AB Hehe, awkest mon arme de choix pour le traitement de texte. De plus, sa syntaxe est proche de C. Oh, et déjà ajouté une TryExecpartie ^ _ ^
Sergiy Kolodyazhnyy

Vous avez mon +1 =)
AB

Mais ce qui est sur %f, %u, %Uou quelque chose comme ça derrière la commande?
AB
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.