Z tego, co mogę zebrać, .desktoppliki są skrótami, które pozwalają dostosować ustawienia aplikacji. Na przykład mam ich wiele w swoim /usr/share/applications/folderze.

Jeśli otworzę ten folder nautilus, mogę uruchomić te aplikacje, klikając dwukrotnie powiązany plik, np. Dwukrotne kliknięcie firefox.desktopuruchamia Firefoksa. Nie mogę jednak znaleźć sposobu na zrobienie tego samego przez terminal.

Jeśli to zrobię gnome-open foo.desktop, po prostu otworzy się foo.desktopjako plik tekstowy. Jeśli sprawię, że będzie wykonywalny, a następnie uruchomię go w wersji bash, po prostu się nie powiedzie (co jest oczekiwane, to oczywiście nie jest skrypt bash).
EDYCJA: Doing exec /fullpath/foo.desktopdaje mi Permission deniedwiadomość, nawet jeśli zmienię własność na siebie. Jeśli utworzę plik wykonywalny i wykonam to samo polecenie, karta terminalu, której używam, po prostu zamyka się (domyślam się, że ulega awarii). Wreszcie, jeśli to zrobię sudo exec /fullpath/foo.desktop, otrzymam raport o błędzie sudo: exec: command not found.

To moje pytanie, jak mogę uruchomić foo.desktopplik z terminala?

Polecenie, które jest uruchamiane, jest zawarte w pliku pulpitu, poprzedzone przez Exec=, abyś mógł go wyodrębnić i uruchomić:

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

Aby to rozbić

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

Możesz umieścić to w pliku, powiedzmy ~/bin/deskopenz zawartością

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

Następnie uczyń go wykonywalnym

chmod +x ~/bin/deskopen

A potem możesz zrobić np

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

Argumenty ( %u, %Fetc) są wyszczególnione w http://standards.freedesktop.org/desktop-entry-spec/desktop-entry-spec-1.0.html#exec-variables - żaden z nich nie są odpowiednie do uruchomienia w linii poleceń .

Odpowiedź powinna być

xdg-open program_name.desktop

Ale z powodu błędu to już nie działa.

Z każdym najnowszym ubuntu, które obsługuje gtk-launchpo prostu go

gtk-launch <file>gdzie jest nazwa pliku .desktop z .desktopczęścią lub bez niej

Tak się gtk-launch foootwierafoo.desktop

( gtk-launchdokumentacja )

.Desktop powinien znajdować się w / usr / share / applications, / usr / local / share / applications lub ~ / .local / share / applications

Można używać z terminala lub alt + F2 (alt + F2 przechowuje polecenia w historii, więc łatwo dostępne)

Na dzień dzisiejszy (12.10) błąd jest nadal obecny. W rzeczywistości zależy to od tego, jak działa gvfs-open(nazywany przez xdg-open).

Mimo to udało mi się szybko obejść (kradzież inspiracji z kodu źródłowego nautilus). Jest nieco skomplikowany, ale działa bezbłędnie na Ubuntu 12.10, dodając znaczącą ikonę (nie więcej ?) w programie uruchamiającym Unity.

Najpierw napisałem skrypt Pythona za pomocą Gio i umieściłem go jako ~/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)

Skrypt musi mieć uprawnienia do wykonywania, więc uruchomiłem to w terminalu:

chmod +x ~/bin/run-desktop

Następnie utworzyłem względny .desktopwpis na ~/.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

Wreszcie związana wpis jako domyślnej obsługi w ~/.local/share/applications/mimeapps.listramach [Default Applications]sekcji jako:

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

Teraz:

• xdg-open coś.desktop działa zgodnie z oczekiwaniami
• #!/usr/bin/xdg-open Działa również hashbang nad plikiem wykonywalnym na pulpicie

Rozwiązanie gvfs-openproblemu będzie bezużyteczne , ale w międzyczasie ...

Właściwy sposób

Naprawdę powinieneś używać, gtk-launchjeśli jest dostępny. Zwykle jest to część pakietu libgtk-3-bin (może to różnić się w zależności od dystrybucji).

gtk-launch jest używany w następujący sposób:

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

Uwaga: gtk-launchwymaga zainstalowania pliku .desktop (tj. Umieszczonego w /usr/share/applicationslub ~/.local/share/applications).

Aby obejść ten problem, możemy użyć chwiejnej funkcji Bash, która tymczasowo instaluje żądany plik .desktop przed jego uruchomieniem. „Prawidłowy” sposób instalacji pliku .desktop polega na tym, desktop-file-installale zignoruję to.

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

    )

}

Możesz użyć go w ten sposób (a także przekazać dodatkowe argumenty lub identyfikatory URI, jeśli chcesz):

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

Manualna alternatywa

Jeśli chcesz ręcznie przeanalizować i wykonać plik .desktop , możesz to zrobić za pomocą następującego awkpolecenia:

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

Jeśli chcesz traktować awkpolecenie jak skrypt typu „wszystko w jednym”; możemy nawet wyświetlić komunikat o błędzie i wyjść z kodem powrotu 1, jeśli nie zostanie znalezione polecenie Exec :

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

Wyżej wymienione polecenia będą:

1. Znajdź linię zaczynającą się od Exec =
2. Usuń Exec =
3. Usunąć wszelkie zmienne Exec (np %f, %u, %U). Możliwe jest zastąpienie ich argumentami pozycyjnymi zgodnie z zamierzeniami specyfikacji, ale spowodowałoby to znaczną złożoność problemu. Zobacz najnowszą specyfikację wpisu na pulpicie .
4. Wykonaj polecenie
5. Natychmiast wyjdź z odpowiednim kodem wyjścia (aby nie wykonywać wielu wierszy Exec )

Uwaga: ten skrypt AWK rozwiązuje kilka przypadków skrajnych, które mogą, ale nie muszą być poprawnie rozwiązane przez niektóre inne odpowiedzi. W szczególności to polecenie usuwa wiele zmiennych Exec (uważając, aby w przeciwnym razie nie usunąć symbolu%), wykona tylko jedno polecenie wiersza Exec i zachowa się zgodnie z oczekiwaniami, nawet jeśli polecenie wiersza Exec zawiera jeden lub więcej znaków równości (np script.py --profile=name.).

Tylko kilka innych zastrzeżeń ... Zgodnie ze specyfikacją TryExec to:

Ścieżka do pliku wykonywalnego na dysku używanego do ustalenia, czy program jest faktycznie zainstalowany. Jeśli ścieżka nie jest ścieżką bezwzględną, plik jest sprawdzany w zmiennej środowiskowej $ PATH. Jeśli plik nie istnieje lub nie jest wykonywalny, wpis może zostać zignorowany (na przykład nie może być używany w menu).

Mając to na uwadze, nie ma sensu wykonywać jego wartości.

Inne obawy dotyczą ścieżki i terminala . Ścieżka składa się z katalogu roboczego do uruchomienia programu. Terminal to wartość logiczna, która wskazuje, czy program jest uruchamiany w oknie terminala. Można to wszystko rozwiązać, ale nie ma sensu wymyślać koła, ponieważ istnieją już implementacje specyfikacji. Jeśli chcesz wdrożyć ścieżkę , pamiętaj, że system()spawnuje podproces, więc nie możesz zmienić katalogu roboczego, wykonując coś takiego system("cd \047" working_directory "\047"); system(command). Można jednak przypuszczalnie zrobić coś takiego system("cd \047" working_directory "\047 && " command). Uwaga \ 047 to pojedyncze cudzysłowy (więc polecenie nie pęka na ścieżkach ze spacjami).

Python Alternative

Jestem kradzież stronę z Carlo tutaj , który zasugerował stworzenie skryptu Pythona aby skorzystać z gi modułu. Oto minimalny sposób wykonania tego samego kodu z powłoki bez konieczności tworzenia pliku i martwienia się o operacje we / wy.

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

}

Następnie uruchom funkcję uruchamiania w następujący sposób:

launch ./path/to/shortcut.desktop

Uwaga: użycie identyfikatorów URI jest opcjonalne. Ponadto nie jest przeprowadzane sprawdzanie błędów, więc upewnij się, że program uruchamiający istnieje i jest czytelny (przed użyciem), jeśli chcesz, aby skrypt był trwały.

Podczas gdy OP nie pytał o KDE, dla każdego, kto korzysta z KDE, można użyć następującego polecenia:

kioclient exec <path-to-desktop-file>

W Fedorze jest to uwzględnione w kde-runtimerpm.

Możesz użyć dex .

dex foo.desktop

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

wydaje się działać w wersji 13.10, jeśli zainstalowano exo-utils (podobnie jak w przypadku Xubuntu).

Dodatek do odpowiedzi Hamisha.

Biorąc pod uwagę skrypt deskopen, możesz użyć odwołania do niego jako linii shebang w pliku .desktop , ponieważ znak komentarza jest nadal #. To znaczy, umieść to jako pierwszy wiersz pliku .desktop :

#!/usr/bin/env deskopen

Następnie oznacz plik .desktop jako wykonywalny (np. Za pomocą a chmod +x whatever.desktop), a następnie możesz

path/to/whatever.desktop

i voilà - Aplikacja zostanie otwarta! (W komplecie z podanym plikiem ikon, choć nie mam pojęcia jak.)

Teraz, jeśli chcesz, aby deskopen przechodził przez dowolne parametry wiersza poleceń, możesz zamiast tego użyć tej lekko zmodyfikowanej wersji:

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

Nawiasem mówiąc, próbowałem użyć "#{@:2}"zamiast shifting, ale wciąż dawało mi to „złe zastąpienie” ...

Obecnie nie ma aplikacji, która robi to, co opisujesz w archiwach Ubuntu. Trwają prace nad stworzeniem ogólnego rozwiązania zapewniającego integrację środowisk pulpitu (takich jak Openbox), które nie są zgodne ze specyfikacjami XDG.

Arch Linux pracuje nad implementacją xdg-autostart opartą na bibliotekach python-xdg. Z tego, co mogę znaleźć, wydaje się, że nie jest to jeszcze całkowicie kompletne, ale ma kilka raportów o sukcesie.

Istnieje także implementacja C ++ xdg-autostart na gitorious (http://gitorious.org/xdg-autostart/), która prawdopodobnie skorzystałaby z szerszego zastosowania.

Jeśli którekolwiek z tych rozwiązań będzie dla Ciebie odpowiednie, rozważ przesłanie niezbędnych prac w celu włączenia ich do Debiana lub Ubuntu.

Aby użyć dowolnego narzędzia z openstart, nazwałbyś go w /etc/xdg/openbox/autostart.sh (jeśli poprawnie czytam dokumentację openbox). Jeśli to nie zadziała, prawdopodobnie możesz to wywołać w dowolnym skrypcie inicjującym sesję openbox.

Nie mam natychmiastowego rozwiązania spełniającego wymóg „używania standardowego polecenia” , ale jeśli chcesz minimalnie parsować .desktoppliki lub chcesz utworzyć alias Bash, to powinny działać:

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

innym podejściem, które może być interesujące, byłoby utworzenie binfmt-miscmetody na poziomie jądra niż dopasowywania w .desktopplikach (sprawdź grep -r . /proc/sys/fs/binfmt_misc/te wzorce, które obecnie włączasz).

Pod koniec dnia coś gdzieś będzie musiało przeanalizować .desktoppliki, to tylko pytanie, jak to jest „standardowe / domyślne”.

Wziąłem skrypt z powyższej odpowiedzi Carlo i podjąłem próbę ulepszenia go na własny komputer.

Ta wersja skryptu pozwoli Ci uruchomić dowolną aplikację tak, jakbyś wprowadził ją na HUD, o ile prawdopodobnie będzie to pierwszy wynik. Pozwala także przekazywać argumenty plików dla plików .desktop, które nie obsługują identyfikatorów 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)

Próbując przetestować te pliki, znalazłem najprostszy sposób, aby sprawdzić, czy DM lub menedżer sesji zrobi to, czego się spodziewałem, aby otworzyć otaczający katalog w przeglądarce folderów interfejsu użytkownika, a następnie kliknąć dwukrotnie, aby je otworzyć.

Jeśli znajdujesz się w wierszu poleceń: gvfs-open .lub gnome-open .otworzy go w skonfigurowanej przeglądarce folderów.

Sed nie będzie odzwierciedlał zachowania DM, w tym kłopotliwych rzeczy, takich jak ucieczki i cytowanie tam, gdzie naprawdę nie chciałbyś alternatywnego zachowania. To nie jest wiersz poleceń, ale sprawdził poprawność rzeczy. Uznałem również, że ustawienie jest Terminal=trueprzydatne do debugowania.

Ta SO odpowiedź była dla mnie jasna: nie próbuj uruchomić pliku pulpitu, wykonaj plik wskazany w pliku pulpitu.

Na przykład uruchom /home/jsmith/Desktop/x11vnc.sh

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

(Opracowano na podstawie różnych innych odpowiedzi tutaj)

W zależności od systemu i różnych błędów, które mogą, ale nie muszą istnieć w systemie, wypróbuj następujące rozwiązania, aż jeden z nich zadziała:

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

Należy pamiętać, że w systemach Ubuntu programy uruchamiające pulpity z „menu Start” są dostępne w /usr/share/applications/.

Na przykład, aby pokazać, które z powyższych poleceń działają lub nie działają w moim systemie Ubuntu 14.04, oto wyniki następujących wywołań dla mnie:

1. xdg-open /usr/share/applications/eclipse_for_cpp.desktop # Nie działa z powodu błędu (próbuje zmusić mnie do zapisania tego pliku .desktop)
2. exo-open /usr/share/applications/eclipse_for_cpp.desktop # Pracuje
3. gtk-launch /usr/share/applications/eclipse_for_cpp.desktop # Nie działa z „GTk-launch: brak takiej aplikacji”
4. kioclient exec /usr/share/applications/eclipse_for_cpp.desktop # Pracuje
5. dex /usr/share/applications/eclipse_for_cpp.desktop# Nie działa i sudo apt install dexnie można zlokalizować pakietu dex

Upewnij się, że skrypt, na który wskazuje plik pulpitu, jest wykonywalny.

Jeśli nadal nie działa. Zmień plik pulpitu na uruchamialny przez zmianę Terminal=truei umieść go w skrypcie bash. Uruchom skrypt, aby złapać wyjście błędu. Wróć po poprawieniu błędów.

Odpowiedź Hamisha jest świetna, ale chciałbym zasugerować prostszą alternatywę, z mniejszym zaangażowaniem:

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

W tym przypadku awkszuka linii zaczynającej się od Exec, a następnie po prostu wypisujemy pola po tej linii, używając pętli i =wypisujemy pole 2, tj. Cokolwiek następuje po tym polu. Nawiasy klamrowe na końcach poleceń, $(...)są podstawieniem parametrów, dlatego powłoka wykona wszystkie zwrócone polecenia awk; w tym przypadku zwraca rzeczywiste polecenie, które następuje po Exec=.

W niektórych rzadkich przypadkach może występować więcej niż jeden =znak, co wciąż jest możliwe. W tym celu sugeruję

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