Esecuzione di un file .desktop nel terminale


142

Da quello che posso raccogliere, i .desktopfile sono scorciatoie che consentono di personalizzare le impostazioni dell'applicazione. Ad esempio, ne ho molti nella mia /usr/share/applications/cartella.

Se apro quella cartella nautilus, posso eseguire queste applicazioni semplicemente facendo doppio clic sul file associato, ad esempio facendo doppio clic su firefox.desktopFirefox. Tuttavia, non riesco a trovare un modo per fare la stessa cosa tramite il terminale.

Se lo faccio, gnome-open foo.desktopsi apre semplicemente foo.desktopcome file di testo. Se lo rendo eseguibile e poi lo eseguo in bash semplicemente fallisce (cosa che ci si aspetta, chiaramente non è bash script).
EDIT: Doing exec /fullpath/foo.desktopmi dà un Permission deniedmessaggio, anche se cambio proprietà a me stesso. Se eseguo il comando eseguibile e eseguo lo stesso comando, la scheda del terminale che sto usando si chiude semplicemente (immagino che si blocchi). Infine, se lo faccio sudo exec /fullpath/foo.desktop, ricevo un rapporto di errore sudo: exec: command not found.

Questa è la mia domanda, come posso eseguire un foo.desktopfile dal terminale?


5
NB: Il motivo del execfallimento è perché exec sostituisce il processo attualmente in esecuzione con il processo specificato, quindi quello che hai fatto è stato provare a sostituire la shell con l'esecuzione del desktop come binario compilato. Il motivo per cui non sudo execè stato possibile è perché è un comando incorporato della shell e non un comando binario.
Daenyth,

Interessante, mi chiedevo perché ha causato la chiusura della scheda.
Malabarba,


Vedo, finiscono per analizzare il file .desktop. Grazie comunque per il link.
enzotib,

moderatori: oops, penso che potrei averlo segnalato per sbaglio, scusa se è così
Croad Langshan,

Risposte:


54

Il comando eseguito è contenuto all'interno del file desktop, preceduto da in Exec=modo da poterlo estrarre ed eseguire da:

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

Per scomporlo

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

Potresti metterlo in un file, diciamo ~/bin/deskopencon il contenuto

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

Quindi renderlo eseguibile

chmod +x ~/bin/deskopen

E poi potresti farlo, ad es

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

Gli argomenti ( %u, %Fecc.) Sono dettagliati su http://standards.freedesktop.org/desktop-entry-spec/desktop-entry-spec-1.0.html#exec-variables - nessuno di questi è rilevante per l'avvio dalla riga di comando .


Questo dà il miglior risultato finora, ma a volte produce comportamenti indesiderati. Succede ogni volta che la riga "Exec =" ha un argomento come% u o% i. Bash prova a passare quella stringa come argomento regolare. Ad esempio, facendo si grep '^Exec' firefox.desktop | sed 's/^Exec=//'apre Firefox con una scheda che carica www.% U.com .
Malabarba,

Per il momento ho aggiunto un secondo sedper rimuovere qualsiasi argomento. Ma penso che potrebbe esserci un modo più "naturale" per eseguirlo.
Malabarba,

Ho aggiornato la mia risposta con il sed extra: ho dimenticato che i file desktop potrebbero avere argomenti.
Hamish Downer,

Dovresti aggiungere una "coda -1" alla pipe dopo "grep", poiché "Exec =" può essere visualizzato più volte e, successivamente, deve essere eseguita solo l'ultima apparizione ..
daisy

13
-1: Questo può funzionare per .desktopfile semplici , ma ignora voci simili Path=e TryExec=che possono influire sull'esecuzione. Exec=
Esegue

85

La risposta dovrebbe essere

xdg-open program_name.desktop

Ma a causa di un bug non funziona più.


7
WoW questo è ancora un bug, molti progressi in xdg. exo-openè elencato come soluzione alternativa e apre anche gedit. :(
Ha

1
@RichardHolloway: gnome-opennon non chiamare xdg-open, è il contrario! Quindi il problema sta nel gvfs-open(successore o gnome-open)
MestreLion,

13
"non lavora più"? Non l'ha mai fatto! xdg-openfunziona per associazione mimetype e i .desktopfile sono associati agli editor di testo, poiché sono una sottoclasse di testo
MestreLion,

13
questo è così stupido (che non esiste un modo ragionevole per eseguire un file Desktop dal terminale)
Sam Watkins,

2
Funziona per me su Arch Linux, ma forse è un bug specifico di Ubuntu.
Victor,

76

Con qualsiasi Ubuntu recente che supporti gtk-launchsemplicemente vai

gtk-launch <file>dove è il nome del file .desktop con o senza la .desktopparte

Quindi si gtk-launch fooaprefoo.desktop

( gtk-launchdocumentazione )

Il .desktop dovrebbe essere in / usr / share / applicazioni, / usr / local / share / applicazioni o ~ / .local / share / applicazioni

Utilizzabile dal terminale o alt + F2 (alt + F2 memorizza il comando nella storia in modo facilmente accessibile)


Questo è il modo in cui funziona anche in Debian.

gtk-launch firefox.desktop ~ / .local / share / applicazioni / avvia firefox visualizzando la directory ~ / .local / share / applicazioni / per me. Se avessi ragione, Firefox non avrebbe dovuto passare la directory del file .desktop come argomento. In effetti la directory passata a gtk-launch non dovrebbe essere usata per localizzare la directory contenente il file .desktop (e in realtà non lo è)
Croad Langshan,

Sìì! Una risposta che funziona!
Alicia,

Questo funziona anche per me in Arch Linux. Nessuna delle altre risposte è stata soddisfacente, ma questa è buona. :-) Funziona anche se sto eseguendo KDE.
MountainX,

2
Nessuna versione di questo funziona per me su Ubuntu 18.10. Ogni volta che si lamenta che l'applicazione non esiste, sia che io sia nella cartella con il file desktop o meno, sia che includa l'estensione .desktop o meno, sia che io chiami separatamente la directory o meno.
Joseph Garvin,

38

Ad oggi (12.10) il bug è ancora presente. Dipende infatti da come gvfs-open(chiamato da xdg-open) funziona.

Tuttavia, ho gestito una rapida soluzione (rubando l'ispirazione dal codice sorgente di nautilus). È un po 'contorto, ma funziona perfettamente su Ubuntu 12.10, aggiungendo un'icona significativa (non più ?) sul programma di avvio di Unity.

Innanzitutto, ho scritto una sceneggiatura in pitone usando Gio e l'ho salvata come ~/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)

Lo script deve avere l'autorizzazione eseguibile, quindi l'ho eseguito in un terminale:

chmod +x ~/bin/run-desktop

Quindi ho creato la .desktopvoce relativa su ~/.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

Infine ho associato la voce come il gestore predefinito nel ~/.local/share/applications/mimeapps.listsotto la [Default Applications]sezione come:

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

Adesso:

  • xdg-open qualcosa.desktop funziona come previsto
  • #!/usr/bin/xdg-open funziona anche l'hashbang sopra una voce del desktop eseguibile

Sarà un lavoro inutile quando gvfs-openrisolverà il bug, ma nel frattempo ...


1
Funziona meglio della risposta di Hamish Downer poiché tratterà correttamente più Exec=righe e %parametri nel comando.
Flimm,

4
Grazie per il codice - Sono su Lucid, e l'ho semplicemente salvato come /usr/bin/xdg-openpy, e gli ho dato un chmod +x- e usato al launcher.launch([],context)posto di ...None,context)(a causa di " TypeError: argomento 1: Deve essere una sequenza, non NoneType "). Ora xdg-openpy app.desktopfunziona dalla riga di comando (e tutto normalmente quando si fa doppio clic app.desktop) e può ricordarmi se provo a chiamare il terminale xdg-opene premo tab. Saluti!
sdaau,

3
+1. Questa è l'unica risposta che non richiede l'analisi manuale del .desktopfile, quindi è l'approccio più sano (e sicuro). Utilizza anche moderno gi.repositoryinvece di deprecato pygtk, così fantastico! :)
MestreLion

2
In realtà, questa è una domanda relativa alla risposta di Carlo Pellegrini. Sono un novizio, per favore correggimi se c'è un modo migliore per posizionarlo. Lo script funziona davvero bene, ma l'icona che ottengo su Unity Launcher non è l'icona definita nel file .desktop ma l'icona predefinita del comando 'Exec'. Qualche idea a riguardo?
Ingo Leonhardt,

1
@Noitidart scrivere l'ultima risposta ha portato mo fare qualche google e ho trovato che . Non l'ho verificato, ma forse aiuta
Ingo Leonhardt

31

Il modo giusto

Dovresti davvero usare gtk-launchse è disponibile. Di solito fa parte del pacchetto libgtk-3-bin (questo può variare in base alla distribuzione).

gtk-launch è usato come segue:

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

Si noti che gtk-launchrichiede l' installazione del file .desktop (ovvero situato in /usr/share/applicationso ~/.local/share/applications).

Quindi, per ovviare a questo, possiamo usare una piccola funzione hacker di Bash che installa temporaneamente il file .desktop desiderato prima di avviarlo . Il modo "corretto" per installare un file .desktop è tramite desktop-file-installma lo 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

    )

}

Puoi usarlo in questo modo (e anche passare argomenti aggiuntivi o URI se vuoi):

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

L'alternativa manuale

Se si desidera analizzare manualmente ed eseguire un file .desktop , è possibile farlo con il seguente awkcomando:

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

Se vuoi trattare il awkcomando come uno script all-in-one; possiamo anche mostrare un messaggio di errore ed uscire con un codice di ritorno 1 nel caso in cui non venga trovato un comando 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}}'

I comandi di cui sopra dovranno:

  1. Trova la riga che inizia con Exec =
  2. Rimuovi Exec =
  3. Rimuovere tutte le variabili Exec (ad esempio %f, %u, %U). È possibile sostituirli con argomenti posizionali come previsto dalla specifica, ma in tal modo si aggiungerebbe una notevole complessità al problema. Vedi le ultime specifiche sulle voci del desktop .
  4. Esegui il comando
  5. Esci immediatamente con il codice di uscita appropriato (in modo da non eseguire più righe Exec )

Nota, questo script AWK risolve alcuni casi limite che possono o non possono essere correttamente affrontati da alcune delle altre risposte. In particolare, questo comando rimuove più variabili Exec (facendo attenzione a non rimuovere altrimenti il ​​simbolo%), eseguirà solo un singolo comando di linea Exec e si comporterà come previsto anche se il comando di linea Exec contiene uno o più segni di uguale (ad es script.py --profile=name.).

Solo alcune altre avvertenze ... Secondo le specifiche, TryExec è:

Percorso di un file eseguibile su disco utilizzato per determinare se il programma è effettivamente installato. Se il percorso non è un percorso assoluto, il file viene cercato nella variabile di ambiente $ PATH. Se il file non è presente o non è eseguibile, la voce potrebbe essere ignorata (non utilizzata nei menu, ad esempio).

Con questo in mente, non ha senso eseguire il suo valore.

Alcune altre preoccupazioni sono Path e Terminal . Il percorso è costituito dalla directory di lavoro in cui eseguire il programma. Terminal è un valore booleano che indica se il programma viene eseguito in una finestra del terminale. Questi possono essere tutti affrontati, ma non ha senso reinventare la ruota in quanto esistono già implementazioni delle specifiche. Se vuoi implementare Path , tieni presente che system()genera un sottoprocesso, quindi non puoi cambiare la directory di lavoro facendo qualcosa di simile system("cd \047" working_directory "\047"); system(command). Tuttavia presumibilmente potresti fare qualcosa del genere system("cd \047" working_directory "\047 && " command). Nota \ 047 sono virgolette singole (quindi il comando non si interrompe su percorsi con spazi).

L'alternativa Python

Sto rubando una pagina da Carlo qui , che ha suggerito di creare uno script Python per utilizzare il modulo gi . Ecco un modo minimo per eseguire lo stesso codice dalla shell senza dover creare un file e preoccuparsi dell'I / O.

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

}

Quindi eseguire la funzione di avvio come segue:

launch ./path/to/shortcut.desktop

Si noti che l'uso di URI è facoltativo. Inoltre, non viene eseguito alcun controllo degli errori, quindi è necessario assicurarsi che il programma di avvio esista e sia leggibile (prima di utilizzarlo) se si desidera che lo script sia durevole.


Ma il awkcomando è carino. Quindi un +1
AB

Che cos'è un URI in questo contesto? Ho un file desktop in una cartella arbitraria. Come diamine posso eseguire gtk-launch su di esso senza doverlo avvolgere in qualche altro script? Questo è esasperante.
Joseph Garvin,

Questa awksoluzione non funzionerà correttamente se il comando ha spazi bianchi o barre rovesciate con doppio escape. Si rompe su questo: Exec=env WINEPREFIX="/path/to/.wine" wine c:\\\\windows\\\\command\\\\start.exe /Unix /path/to/.wine/dosdevices/c:/users/Public/Рабочий\\ стол/appname.lnke la dexsoluzione funziona bene.
MarSoft

27

Mentre OP non chiedeva di KDE, per chiunque stia eseguendo KDE può essere usato il seguente comando:

kioclient exec <path-to-desktop-file>

Su Fedora, questo è incluso nel numero di kde-runtimegiri.


5
Eseguito l'upgrade perché funziona. Non è necessario eseguire KDE, a condizione che questo programma sia installato.
basic6,

C'è un modo per avere stdout di questo? Ho compilato il lettore di clementine, che ha un bug che si verifica solo avviando tramite il file .desktop (con plasma-shell). E non riesco a capire come avere comunque il log di output.
Kwaadpepper,

@Kwaadpepper potresti usare il tuo file .desktop per lanciare uno script di shell, che esegue internamente il tuo comando e reindirizza l'output su un file.
Raman,

Al momento non trovo kioclient in nessun pacchetto di KDE per Arch Linux. Tuttavia, gtk-launch funziona sotto KDE per me.
MountainX,

15

Puoi usare dex .

dex foo.desktop

2
IMHO questa è esattamente la risposta giusta: uno strumento, una singola chiamata con solo il file come parametro. È quello che cercavo anche per testare .desktopfile scritti a mano . E può anche creare .desktopfile, yay! :-)
Axel Beckert,

Perfetto! Se aggiungi un file .desktop che utilizza dex gist.github.com/stuaxo/4169fc1342c496b7c8f7999188f2f242 a / usr / share / applicazioni / sarai in grado di avviare i file desktop nel gestore dei file senza che si aprano anche in gedit per impostazione predefinita.
Stuart Axon,

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

sembra funzionare nella versione 13.10, se è installato exo-utils (come nel caso di Xubuntu).


Sì, l'ho appena testato in Ubuntu Studio 14.04. BTW. Anche xdg-open e gvfs-open funzionano lì.
jarno,

Funziona anche nel 15
Jonathan

Usare Debian con xfce. Funziona alla grande!
king_julien,

Funziona per me in Ubuntu 14.04
Tyler Collier,

8

Addendum alla risposta di Hamish.

Dato lo script deskopen, puoi usare un riferimento ad esso come linea shebang in un file .desktop , poiché il carattere del commento è ancora #. Vale a dire, metti questo come prima riga del file .desktop :

#!/usr/bin/env deskopen

Quindi contrassegnare il file .desktop come eseguibile (ad es. Con a chmod +x whatever.desktop), quindi è possibile

path/to/whatever.desktop

e voilà - L'app si aprirà! (Completo del file icona che ho specificato, anche se non ho idea di come.)

Ora, se vuoi che anche deskopen passi attraverso qualsiasi parametro della riga di comando, puoi invece usare questa versione leggermente modificata:

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

A parte questo, ho provato a usare "#{@:2}"invece di shifting, ma continuava a darmi 'brutta sostituzione' ...


So che questo è un commento più appropriato alla risposta di Hamish, ma sono un nuovo utente e non posso commentare. Oh bene!
pabst

Se hai la reputazione, l'azione più appropriata sarebbe quella di modificare quella risposta, in realtà.
Flimm,

Colpiscilo, chiunque può suggerire modifiche, anche gli utenti che non hanno effettuato l'accesso! In ogni caso non è un problema.
Flimm,

1
Questa è una risposta di per sé, va bene.
Bruno Pereira,

puoi usare "${@:1}"invece di shift, ma questo richiede bashinvece che shnel tuo #!shebang. IMHO il tuo approccio al turno originale è più semplice e migliore
MestreLion,

6

Al momento non esiste un'applicazione che fa ciò che descrivi negli archivi Ubuntu. Ci sono un paio di sforzi in corso per creare una soluzione generale per fornire l'integrazione per ambienti desktop (come openbox) che non sono conformi a queste specifiche XDG.

Arch Linux sta lavorando su un'implementazione di xdg-autostart basata sulle librerie python-xdg. Da quello che posso trovare, questo non sembra ancora del tutto completo, ma ha alcuni rapporti di successo.

Esiste anche un'implementazione C ++ di xdg-autostart su gitorious (http://gitorious.org/xdg-autostart/) che probabilmente trarrebbe beneficio da un uso più ampio.

Se una delle soluzioni funziona per te, ti preghiamo di considerare di inviare il lavoro necessario per l'inclusione in Debian o Ubuntu.

Per usare entrambi gli strumenti con openstart, dovresti chiamarlo in /etc/xdg/openbox/autostart.sh (se sto leggendo correttamente la documentazione di openbox). Se questo non funziona, puoi probabilmente chiamarlo in uno qualsiasi degli script di inizializzazione della sessione di openbox.


Non è quello che vorrei sentire, comunque grazie per l'informazione
enzotib,

6

Non ho una soluzione immediata che soddisfi i requisiti per "l'utilizzo di un comando standard" , ma se si desidera analizzare minimamente i .desktopfile o si desidera creare un alias Bash, dovrebbe funzionare quanto segue:

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

un altro approccio che potrebbe essere interessante sarebbe quello di creare un binfmt-miscmetodo a livello di kernel rispetto alle corrispondenze sui .desktopfile (vedi grep -r . /proc/sys/fs/binfmt_misc/per quei pattern che hai attualmente abilitato).

Alla fine, qualcosa da qualche parte dovrà analizzare i .desktopfile, è solo una questione di "standard / default".


Grazie, interessante. Come "standard" intendo qualcosa fornito dal DE e conforme a freedesktop.org.
enzotib,

Upvote per awkpiuttosto che una catena di greps e seds.
jmtd,

Votazione, anche se non funziona (o meglio, funziona troppo) se hai molte Exec=righe: /
Boris Churzin il

2

Ho preso la sceneggiatura dalla risposta di Carlo sopra e ho tentato di migliorarla per il mio uso desktop.

Questa versione dello script ti consentirà di eseguire qualsiasi app come se fosse stata inserita nell'HUD, purché sia ​​probabilmente il primo risultato. Inoltre, consente di passare argomenti di file per file .desktop che non supportano gli 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

Quando ho provato a provare questi file ho trovato il modo più semplice per verificare che il DM o il gestore sessioni facessero quello che mi aspettavo fosse aprire la directory circostante in un browser di cartelle UI e quindi fare doppio clic per aprirli.

Se sei in una riga di comando: gvfs-open .o gnome-open .lo aprirai nel browser delle cartelle configurato.

La cosa sed non rispecchierà il comportamento del DM, comprese cose complicate come fughe e citazioni in cui non vorresti davvero un comportamento alternativo. Non è la riga di comando, ma ha convalidato le cose. Ho anche trovato l'impostazione Terminal=trueutile per il debug.


Il terminale scompare immediatamente, non ho il tempo di vedere il messaggio quando uso Terminal = true: s
gouessej

1

Questa risposta SO è ciò che mi ha chiarito: non tentare di eseguire il file desktop, eseguire il file indicato nel file desktop.

Ad esempio, eseguire /home/jsmith/Desktop/x11vnc.sh

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

1

(Compilato dalle varie altre risposte qui)

A seconda del sistema in uso e dei vari bug che possono o meno esistere nel sistema, provare quanto segue fino a quando uno di essi funziona:

  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

Si noti che sui sistemi Ubuntu sono disponibili i desktop launcher "menu di avvio" in /usr/share/applications/.

Ad esempio, per mostrare quale dei comandi sopra funziona o non funziona sul mio sistema Ubuntu 14.04, ecco i risultati delle seguenti chiamate per me:

  1. xdg-open /usr/share/applications/eclipse_for_cpp.desktop # Errore a causa di un bug (cerca di farmi salvare questo file .desktop)
  2. exo-open /usr/share/applications/eclipse_for_cpp.desktop # Lavori
  3. gtk-launch /usr/share/applications/eclipse_for_cpp.desktop # Non riesce con "gtk-launch: nessuna di queste applicazioni"
  4. kioclient exec /usr/share/applications/eclipse_for_cpp.desktop # Lavori
  5. dex /usr/share/applications/eclipse_for_cpp.desktop# Non riesce e sudo apt install dexnon è possibile individuare il pacchetto dex

0

Assicurati che anche lo script a cui punta il tuo file desktop sia eseguibile.

Se ancora non funziona. Rendi il file desktop eseguibile nel terminale modificandolo Terminal=truee inseriscilo in uno script bash. Esegui lo script per rilevare l'output dell'errore. Torna indietro quando gli errori vengono corretti.


0

La risposta di Hamish è ottima, ma vorrei suggerire un'alternativa più semplice, con meno tubazioni coinvolte:

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

In questo caso, awkcerca la riga che inizia con Exec, quindi stampiamo semplicemente i campi dopo quella riga, usando for loop e =stampiamo il campo 2, cioè qualunque cosa venga dopo quel campo. Le parentesi graffe alle estremità dei comandi, $(...)sono sostituzione dei parametri, quindi la shell eseguirà qualunque comando awk restituisca; in questo caso, restituisce il comando effettivo che viene dopo Exec=.

In alcuni rari casi potrebbe esserci più di un =segno, che è ancora una possibilità. Per quello, suggerisco

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

Nice, awkand Serg =)
AB

E a volte c'è un TryExec, forse dovresti controllare il tuo secondo comando =)
AB

@AB Hehe, awkè la mia arma preferita per quanto riguarda l'elaborazione del testo. Inoltre, la sua sintassi è vicina C. Oh, e TryExec
ho

Hai il mio +1 =)
AB

Ma che cosa è su %f, %u, %Uo qualcosa di simile alle spalle il comando?
AB
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.