Soweit ich weiß, handelt es sich bei .desktopDateien um Verknüpfungen, mit denen die Einstellungen der Anwendung angepasst werden können. Zum Beispiel habe ich viele davon in meinem /usr/share/applications/Ordner.

Wenn ich diesen Ordner öffne, nautiluskann ich diese Anwendungen ausführen, indem ich einfach auf die zugehörige Datei doppelklicke, z firefox.desktop. Ich kann jedoch keine Möglichkeit finden, dasselbe über das Terminal zu tun.

Wenn ich es tue gnome-open foo.desktop, öffnet es sich einfach foo.desktopals Textdatei. Wenn ich es ausführbar mache und es dann in Bash ausführe, schlägt es einfach fehl (was erwartet wird, es ist eindeutig kein Bash-Skript).
EDIT: Wenn ich das tue, exec /fullpath/foo.desktopbekomme ich eine Permission deniedNachricht, auch wenn ich den Besitzer selbst wechsle. Wenn ich ausführbar mache und den gleichen Befehl ausführe, wird der von mir verwendete Terminal-Tab einfach geschlossen (ich vermute, er stürzt ab). Wenn ich das tue sudo exec /fullpath/foo.desktop, erhalte ich schließlich eine Fehlermeldung sudo: exec: command not found.

Das ist meine Frage, wie kann ich eine foo.desktopDatei vom Terminal ausführen ?

Der ausgeführte Befehl ist in der Desktop-Datei enthalten. Davor können Sie den folgenden Befehl Exec=extrahieren und ausführen:

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

Um das aufzubrechen

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

Sie könnten dies in eine Datei einfügen, zum Beispiel ~/bin/deskopenmit dem Inhalt

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

Dann mach es ausführbar

chmod +x ~/bin/deskopen

Und dann könntest du z

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

Die Argumente ( %u, %Fusw.) sind im Detail http://standards.freedesktop.org/desktop-entry-spec/desktop-entry-spec-1.0.html#exec-variables - keiner von ihnen relevant ist für in der Befehlszeile gestartet .

Die Antwort sollte sein

xdg-open program_name.desktop

Aber aufgrund eines Fehlers funktioniert dies nicht mehr.

Mit jedem aktuellen Ubuntu, das unterstützt, gtk-launcheinfach los

gtk-launch <file>Wo ist der Name der .desktop-Datei mit oder ohne .desktopTeil ?

So gtk-launch fooöffnet sichfoo.desktop

( gtk-launchDokumentation )

Die .desktop sollte sich in / usr / share / applications, / usr / local / share / applications oder ~ / .local / share / applications befinden

Kann vom Terminal aus oder mit Alt + F2 verwendet werden (Alt + F2 speichert den Befehl in der Historie und ist so leicht zugänglich)

Ab heute (12.10) ist der Bug noch vorhanden. Es kommt in der Tat darauf an, wie gvfs-open(aufgerufen von xdg-open) funktioniert.

Trotzdem schaffte ich eine schnelle Umgehung (Inspiration aus dem Nautilus-Quellcode stehlen). Es ist ein bisschen kompliziert, funktioniert aber unter Ubuntu 12.10 einwandfrei und fügt ?dem Unity-Launcher ein aussagekräftiges Symbol (nicht mehr ) hinzu.

Zuerst habe ich ein Python-Skript mit Gio geschrieben und es gespeichert als ~/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)

Das Skript muss über die ausführbare Berechtigung verfügen, daher habe ich dies in einem Terminal ausgeführt:

chmod +x ~/bin/run-desktop

Dann habe ich den relativen .desktopEintrag erstellt am ~/.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

Schließlich habe ich den Eintrag als Standard-Handler in ~/.local/share/applications/mimeapps.listdem [Default Applications]Abschnitt wie folgt zugeordnet :

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

Jetzt:

• xdg-open something.desktop funktioniert wie erwartet
• #!/usr/bin/xdg-open Hashbang über einem ausführbaren Desktop-Eintrag funktioniert auch

Es wird nutzlose Arbeit sein, wenn gvfs-opender Fehler behoben wird, aber in der Zwischenzeit ...

Der richtige Weg

Sie sollten wirklich verwenden, gtk-launchwenn es verfügbar ist. Es ist normalerweise Teil des Pakets libgtk-3-bin (dies kann je nach Distribution variieren).

gtk-launch wird wie folgt verwendet:

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

Bitte beachten Sie, dass gtk-launchdie .desktop- Datei installiert sein muss (dh sich in /usr/share/applicationsoder befindet ~/.local/share/applications).

Um dies zu umgehen, können wir eine kleine hackige Bash-Funktion verwenden, die die gewünschte .desktop- Datei vor dem Start vorübergehend installiert . Die "richtige" Art, eine .desktop- Datei zu installieren, ist über, desktop-file-installaber ich werde das ignorieren.

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

    )

}

Sie können es wie folgt verwenden (und auch zusätzliche Argumente oder URIs weitergeben, wenn Sie möchten):

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

Die manuelle Alternative

Wenn Sie eine .desktop- Datei manuell analysieren und ausführen möchten , können Sie dies mit dem folgenden awkBefehl tun :

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

Wenn Sie den awkBefehl wie ein All-in-One-Skript behandeln möchten ; Wir können sogar eine Fehlermeldung anzeigen und mit dem Rückkehrcode 1 beenden, falls ein Exec- Befehl nicht gefunden wird:

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}}'

Die oben genannten Befehle werden:

1. Suchen Sie die Zeile, die mit Exec = beginnt
2. Entfernen Sie Exec =
3. Entfernen Sie alle Exec Variablen (zB %f, %u, %U). Es ist möglich, diese durch Positionsargumente zu ersetzen, wie es die Spezifikation vorsieht, dies würde dem Problem jedoch eine erhebliche Komplexität hinzufügen. Siehe neueste Desktop-Eintragsspezifikation .
4. Führen Sie den Befehl aus
5. Beenden Sie das Programm sofort mit dem entsprechenden Beendigungscode (um nicht mehrere Exec- Zeilen auszuführen ).

Beachten Sie, dass dieses AWK-Skript einige Randfälle behandelt, die von einigen der anderen Antworten möglicherweise nicht richtig behandelt werden. Insbesondere entfernt dieser Befehl mehrere Exec- Variablen (wobei darauf geachtet wird, das% -Symbol nicht zu entfernen), führt nur einen einzigen Exec- Zeilenbefehl aus und verhält sich erwartungsgemäß, selbst wenn der Exec- Zeilenbefehl ein oder mehrere Gleichheitszeichen enthält (z script.py --profile=name. B. ).

Nur ein paar andere Vorbehalte ... Laut Spezifikation ist TryExec :

Pfad zu einer ausführbaren Datei auf der Festplatte, anhand derer festgestellt wird, ob das Programm tatsächlich installiert ist. Wenn der Pfad kein absoluter Pfad ist, wird die Datei in der Umgebungsvariablen $ PATH nachgeschlagen. Wenn die Datei nicht vorhanden oder nicht ausführbar ist, wird der Eintrag möglicherweise ignoriert (z. B. nicht in Menüs verwendet).

In diesem Sinne macht es keinen Sinn, seinen Wert auszuführen.

Einige andere Probleme sind Path und Terminal . Path besteht aus dem Arbeitsverzeichnis, in dem das Programm ausgeführt werden soll. Terminal ist ein Boolescher Wert, der angibt, ob das Programm in einem Terminalfenster ausgeführt wird. Diese können alle angesprochen werden, aber es macht keinen Sinn, das Rad neu zu erfinden, da es bereits Implementierungen der Spezifikation gibt. Wenn Sie Path implementieren möchten, denken Sie daran, dass system()ein Unterprozess erzeugt wird, sodass Sie das Arbeitsverzeichnis nicht ändern können, indem Sie etwas tun wie system("cd \047" working_directory "\047"); system(command). Allerdings könnte man vermutlich sowas machen system("cd \047" working_directory "\047 && " command). Hinweis \ 047 sind einfache Anführungszeichen (damit der Befehl bei Pfaden mit Leerzeichen nicht unterbrochen wird).

Die Python-Alternative

Ich stehle eine Seite von Carlo hier , der einen Python - Skript anregte Verwendung des machen gi - Modul. Hier ist eine minimale Möglichkeit, denselben Code über die Shell auszuführen, ohne eine Datei erstellen und sich um die E / A kümmern zu müssen.

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

}

Führen Sie dann die Launcher-Funktion wie folgt aus:

launch ./path/to/shortcut.desktop

Beachten Sie, dass die Verwendung von URIs optional ist. Außerdem wird keine Fehlerprüfung durchgeführt. Sie sollten daher sicherstellen, dass der Launcher vorhanden und lesbar ist (bevor Sie ihn verwenden), wenn Ihr Skript dauerhaft sein soll.

Während OP nicht nach KDE fragte, kann für jeden, der KDE ausführt, der folgende Befehl verwendet werden:

kioclient exec <path-to-desktop-file>

Auf Fedora ist dies in der kde-runtimeDrehzahl enthalten.

Du könntest Dex benutzen .

dex foo.desktop

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

Scheint in Version 13.10 zu funktionieren, wenn Exo-Utils installiert sind (wie es bei Xubuntu der Fall ist).

Nachtrag zu Hamishs Antwort.

Wenn Sie das deskopen-Skript verwenden, können Sie einen Verweis darauf als shebang-Zeile in einer .desktop- Datei verwenden, da das Kommentarzeichen noch vorhanden ist #. Das heißt, setzen Sie dies als erste Zeile der .desktop- Datei:

#!/usr/bin/env deskopen

Dann kennzeichnen Sie die .desktop- Datei als ausführbar (z. B. mit einem chmod +x whatever.desktop) und dann können Sie

path/to/whatever.desktop

und voilà - Die App wird geöffnet! (Vervollständigen Sie die angegebene Symboldatei, obwohl ich keine Ahnung habe, wie.)

Wenn Sie nun auch möchten, dass deskopen Befehlszeilenparameter durchläuft, können Sie stattdessen diese leicht geänderte Version verwenden:

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

Nebenbei habe ich versucht, "#{@:2}"anstelle von shifting zu verwenden, aber es gab mir "schlechte Substitution" ...

Derzeit gibt es keine Anwendung, die das tut, was Sie in den Ubuntu-Archiven beschrieben haben. Derzeit werden einige Anstrengungen unternommen, um eine allgemeine Lösung für die Integration von Desktop-Umgebungen (z. B. Openbox) zu entwickeln, die diesen XDG-Spezifikationen nicht entsprechen.

Arch Linux arbeitet an einer Implementierung von xdg-autostart basierend auf den Python-xdg-Bibliotheken. Soweit ich weiß, scheint dies noch nicht vollständig zu sein, doch es gibt einige Erfolgsberichte.

Es gibt auch eine C ++ - Implementierung von xdg-autostart auf gitorious (http://gitorious.org/xdg-autostart/), die wahrscheinlich von einer umfassenderen Verwendung profitieren würde.

Wenn eine der beiden Lösungen für Sie funktioniert, überlegen Sie bitte, ob Sie die erforderlichen Arbeiten für die Aufnahme in Debian oder Ubuntu einreichen möchten.

Um eines der beiden Tools mit openstart zu verwenden, rufen Sie es in /etc/xdg/openbox/autostart.sh auf (wenn ich die openbox-Dokumentation richtig lese). Wenn dies nicht funktioniert, können Sie es wahrscheinlich in einem der Openbox-Sitzungsinitialisierungsskripten aufrufen.

Ich habe keine sofortige Lösung, die die Anforderung für die Verwendung eines Standardbefehls erfüllt. Wenn Sie die .desktopDateien jedoch nur minimal analysieren oder einen Bash-Alias ​​erstellen möchten, sollte Folgendes funktionieren:

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

Ein weiterer Ansatz, der interessant sein könnte, ist die Erstellung einer Kernel-Level- binfmt-miscMethode als Matching für .desktopDateien (siehe grep -r . /proc/sys/fs/binfmt_misc/Muster, die Sie derzeit aktiviert haben).

Letztendlich muss irgendwo etwas die .desktopDateien analysieren , es ist nur eine Frage, wie "standard / default" das ist.

Ich habe das Skript aus der obigen Antwort von Carlo entnommen und versucht, es für meinen eigenen Desktop zu verbessern.

Mit dieser Version des Skripts können Sie jede App so ausführen, als ob Sie sie im HUD eingegeben hätten, sofern dies wahrscheinlich das erste Ergebnis ist. Sie können auch Dateiargumente für Desktopdateien übergeben, die keine URIs unterstützen.

#!/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)

Beim Versuch, diese Dateien zu testen, habe ich die einfachste Möglichkeit gefunden, um zu überprüfen, ob der DM oder der Sitzungsmanager das Umgebungsverzeichnis in einem Browser für Benutzeroberflächenordner öffnen und dann darauf doppelklicken, um sie zu öffnen.

Wenn Sie sich in einer Befehlszeile befinden: gvfs-open .oder gnome-open .diese im konfigurierten Ordner-Browser öffnen.

Das Sed-Ding wird das Verhalten des DM nicht widerspiegeln, einschließlich fummeliger Dinge wie Fluchten und Zitieren, wo man wirklich kein alternatives Verhalten haben möchte. Es ist keine Befehlszeile, aber es hat die Dinge validiert. Ich fand die Einstellung auch Terminal=truenützlich für das Debuggen.

Diese SO Antwort hat für mich deutlich gemacht: Versuchen Sie nicht, die Desktop-Datei auszuführen, sondern führen Sie die Datei aus, auf die in der Desktop-Datei verwiesen wird.

Führen Sie beispielsweise /home/jsmith/Desktop/x11vnc.sh aus

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

(Zusammengestellt aus den verschiedenen anderen Antworten hier)

Versuchen Sie je nach Ihrem System und den verschiedenen Fehlern, die auf Ihrem System vorhanden sein können oder nicht, Folgendes, bis einer von ihnen funktioniert:

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

Beachten Sie, dass auf Ubuntu-Systemen Ihre "Startmenü" -Desktopstarter in verfügbar sind /usr/share/applications/.

Als Beispiel, um zu zeigen, welche der obigen Befehle auf meinem Ubuntu 14.04-System funktionieren oder nicht, sind hier die Ergebnisse der folgenden Aufrufe für mich:

1. xdg-open /usr/share/applications/eclipse_for_cpp.desktop # Fehler aufgrund eines Fehlers (versucht, mich diese .desktop-Datei speichern zu lassen)
2. exo-open /usr/share/applications/eclipse_for_cpp.desktop # Funktioniert
3. gtk-launch /usr/share/applications/eclipse_for_cpp.desktop # Schlägt fehl mit "gtk-launch: keine solche Anwendung"
4. kioclient exec /usr/share/applications/eclipse_for_cpp.desktop # Funktioniert
5. dex /usr/share/applications/eclipse_for_cpp.desktop# Schlägt fehl, & sudo apt install dexkann das Paket dex nicht finden

Stellen Sie sicher, dass das Skript, auf das Ihre Desktop-Datei zeigt, auch ausführbar ist.

Wenn immer noch nicht funktioniert. Machen Sie Desktop-Dateien durch Ändern im Terminal lauffähig Terminal=trueund fügen Sie sie in ein Bash-Skript ein. Führen Sie das Skript aus, um die Fehlerausgabe abzufangen. Wechseln Sie zurück, wenn Fehler behoben sind.

Die Antwort von Hamish ist großartig, aber ich würde gerne eine einfachere Alternative vorschlagen, bei der weniger Rohrleitungen erforderlich sind:

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

In diesem Fall wird awknach der Zeile gesucht, die mit beginnt Exec, und dann werden einfach Felder nach dieser Zeile gedruckt, wobei for loop verwendet wird, und =Feld 2 wird gedruckt, dh was auch immer nach diesem Feld kommt. Die geschweiften Klammern an den Enden der Befehle $(...)sind Parameterersetzungen, daher führt die Shell den jeweils zurückgegebenen awk-Befehl aus. In diesem Fall gibt es den tatsächlichen Befehl zurück, der danach kommt Exec=.

In einigen seltenen Fällen kann es mehr als ein =Zeichen geben, was immer noch möglich ist. Dafür schlage ich vor

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