Ejecutar un archivo .desktop en la terminal

142

Por lo que puedo reunir, los .desktoparchivos son accesos directos que permiten personalizar la configuración de la aplicación. Por ejemplo, tengo muchos de ellos en mi /usr/share/applications/carpeta.

Si abro esa carpeta nautilus, puedo ejecutar estas aplicaciones simplemente haciendo doble clic en su archivo asociado, por ejemplo, al hacer doble clic se firefox.desktopejecuta Firefox. Sin embargo, no puedo encontrar una manera de hacer lo mismo a través de la terminal.

Si lo hago gnome-open foo.desktop, simplemente se abre foo.desktopcomo un archivo de texto. Si lo hago ejecutable y luego lo ejecuto en bash, simplemente falla (lo que se espera, claramente no es un script de bash).
EDITAR: Hacer exec /fullpath/foo.desktopme da un Permission deniedmensaje, incluso si cambio de propietario. Si hago ejecutable y hago el mismo comando, la pestaña de terminal que estoy usando simplemente se cierra (supongo que se bloquea). Finalmente, si lo hago sudo exec /fullpath/foo.desktop, recibo un informe de error sudo: exec: command not found.

Esa es mi pregunta, ¿cómo puedo ejecutar un foo.desktoparchivo desde la terminal?

Malabarba
fuente
55
NB: la razón por la que execfalló es porque exec reemplaza el proceso que está ejecutando actualmente con el proceso que especificó, por lo que lo que hizo fue intentar reemplazar su shell con la ejecución del escritorio como un binario compilado. La razón por la que no pudo sudo execes porque es un shell incorporado y no un comando binario.
Daenyth
Interesante, me preguntaba por qué hizo que la pestaña se cerrara.
Malabarba
Ya veo, terminan analizando el archivo .desktop. Gracias de todos modos por el enlace.
enzotib
moderadores: Uy, creo que pude haber marcado esto accidentalmente, lo siento si ese es el caso
Croad Langshan

Respuestas:

54

El comando que se ejecuta está contenido dentro del archivo de escritorio, precedido por Exec=lo que puede extraer y ejecutar:

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

Para romper eso

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

Podría poner esto en un archivo, digamos ~/bin/deskopencon el contenido

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

Luego hazlo ejecutable

chmod +x ~/bin/deskopen

Y luego podrías hacer, por ejemplo

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

Los argumentos ( %u, %Fetc.) se detallan en http://standards.freedesktop.org/desktop-entry-spec/desktop-entry-spec-1.0.html#exec-variables ; ninguno de ellos es relevante para el lanzamiento en la línea de comandos .

Hamish Downer
fuente
Esto da el mejor resultado hasta ahora, pero a veces produce un comportamiento indeseable. Ocurre siempre que la línea "Exec =" tenga un argumento como% uo% i. Bash intenta pasar esa cadena como un argumento regular. Por ejemplo, al hacer grep '^Exec' firefox.desktop | sed 's/^Exec=//'abre Firefox con una pestaña que carga www.% U.com .
Malabarba
Por el momento, he agregado un segundo sedpara eliminar cualquier argumento. Pero creo que podría haber una forma más "natural" de ejecutarlo.
Malabarba
He actualizado mi respuesta con el sed adicional: olvidé que los archivos de escritorio podrían tener argumentos.
Hamish Downer
Usted debe agregar una "cola -1" a la tubería después de "grep", ya que "Exec =" puede ser aparecer múltiples veces, y después de eso, sólo la última aparición se debe ejecutar ..
margarita
13
-1: Esto puede funcionar para .desktoparchivos simples , pero ignora entradas como Path=y TryExec=que pueden afectar la ejecución. También se ejecuta incorrectamente Exec=si el archivo contiene acciones de escritorio ("
listas rápidas
85

La respuesta debería ser

xdg-open program_name.desktop

Pero debido a un error, esto ya no funciona.

Richard Holloway
fuente
77
WoW esto sigue siendo un error, mucho progreso en xdg. exo-openaparece como solución alternativa y también abre gedit. :(
Drew
1
@RichardHolloway: gnome-openno no llamar xdg-open, es al revés! Entonces, el problema radica en gvfs-open(el sucesor o gnome-open)
MestreLion
13
"ya no funciona"? ¡Nunca lo hizo! xdg-openfunciona por asociación mimetype, y los .desktoparchivos están asociados con editores de texto, ya que son una subclase de texto
MestreLion
13
esto es tan estúpido (que no hay una manera sensata de ejecutar un archivo de escritorio desde el terminal)
Sam Watkins
2
Funciona para mí en Arch Linux, pero tal vez sea un error específico de Ubuntu.
Victor
76

Con cualquier ubuntu reciente que admita gtk-launchsimplemente simplemente vaya

gtk-launch <file>donde está el nombre del archivo .desktop con o sin la .desktopparte

Así se gtk-launch fooabrefoo.desktop

( gtk-launchdocumentación )

El .desktop debe estar en / usr / share / aplicaciones, / usr / local / share / aplicaciones o ~ / .local / share / aplicaciones

Utilizable desde la terminal o alt + F2 (alt + F2 almacena el comando en el historial de manera tan accesible)

Doug
fuente
Este es el camino, también funciona en Debian.
gtk-launch firefox.desktop ~ / .local / share / aplicaciones / lanza firefox viendo el directorio ~ / .local / share / aplicaciones / para mí. Parece que si estabas en lo correcto, firefox no debería haber pasado el directorio del archivo .desktop como argumento. De hecho, no se supone que el directorio pasado a gtk-launch se use para localizar el directorio que contiene el archivo .desktop (y de hecho no lo es)
Croad Langshan
¡Hurra! ¡Una respuesta que funciona!
Alicia
Esto sí funciona para mí en Arch Linux también. Ninguna de las otras respuestas fue satisfactoria, pero esta es buena. :-) Funciona aunque estoy ejecutando KDE.
MountainX
2
Ninguna versión de esto funciona para mí en Ubuntu 18.10. Cada vez que se queja, la aplicación no existe, si estoy en la carpeta con el archivo de escritorio o no, si incluyo la extensión .desktop o no, y si nombro el directorio por separado o no.
Joseph Garvin
38

A partir de hoy (12.10) el error aún está presente. De hecho, depende de cómo funciona gvfs-open(llamado por xdg-open).

Aún así, logré una solución rápida (robando inspiración del código fuente nautilus). Es un poco complicado, pero funciona perfectamente en Ubuntu 12.10, agregando un ícono significativo (no más ?) en el iniciador de Unity.

Primero, escribí un script de Python usando Gio y lo guardé como ~/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)

El script necesita tener el permiso ejecutable, así que ejecuté esto en una terminal:

chmod +x ~/bin/run-desktop

Luego creé la .desktopentrada relativa en ~/.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

Finalmente, asocié la entrada como el controlador predeterminado en ~/.local/share/applications/mimeapps.listla [Default Applications]sección como:

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

Ahora:

  • xdg-open something.desktop funciona como se esperaba
  • #!/usr/bin/xdg-open el hashbang en la parte superior de una entrada de escritorio ejecutable también funciona

Será un trabajo inútil gvfs-openresolver el error, pero mientras tanto ...

Carlo Pellegrini
fuente
1
Esto funciona mejor que la respuesta de Hamish Downer, ya que se ocupará de múltiples Exec=líneas y %parámetros en el comando correctamente.
Flimm
44
Gracias por el código, estoy en Lucid, y simplemente guardé esto como /usr/bin/xdg-openpy, y le di un chmod +x- y lo usé en launcher.launch([],context)lugar de ...None,context)(debido a " TypeError: argumento 1: Debe ser secuencia, no NoneType "). Ahora xdg-openpy app.desktopfunciona desde la línea de comandos (y todo de manera normal cuando se hace doble clic app.desktop), y me puede recordar si intento llamar a la terminal xdg-openy presionar tab. ¡Salud!
sdaau
3
+1. Esta es la única respuesta que no requiere analizar manualmente el .desktoparchivo, por lo que es el enfoque más sensato (y seguro). También usa moderno en gi.repositorylugar de obsoleto pygtk, ¡genial! :)
MestreLion
2
De hecho, esta es una pregunta sobre la respuesta de Carlo Pellegrini. Soy un novato, corrígeme si hubiera una mejor manera de colocarlo. El script funciona muy bien, pero el ícono que obtengo en el iniciador de Unity no es el ícono definido en el archivo .desktop sino el ícono predeterminado del comando 'Ejecutado'. ¿Alguna idea sobre eso?
Ingo Leonhardt
1
@Noitidart escribe la última respuesta que llevó a hacer algunos google y encontré eso . No lo he comprobado, pero tal vez ayude
Ingo Leonhardt
31

La direccion correcta

Realmente deberías estar usando gtk-launchsi está disponible. Por lo general, forma parte del paquete libgtk-3-bin (esto puede variar según la distribución).

gtk-launch se usa de la siguiente manera:

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

Tenga en cuenta que gtk-launchrequiere la instalación del archivo .desktop (es decir, ubicado en /usr/share/applicationso ~/.local/share/applications).

Por lo tanto, para evitar esto, podemos usar una pequeña función de Bash que instala temporalmente el archivo .desktop deseado antes de iniciarlo. La forma "correcta" de instalar un archivo .desktop es a través de, desktop-file-installpero voy a ignorar eso.

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

    )

}

Puede usarlo así (y también pasar argumentos adicionales o URI si lo desea):

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

La alternativa manual

Si desea analizar y ejecutar manualmente un archivo .desktop , puede hacerlo con el siguiente awkcomando:

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

Si desea tratar el awkcomando como un script todo en uno; incluso podemos mostrar un mensaje de error y salir con un código de retorno de 1 en caso de que no se encuentre 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}}'

Los comandos mencionados anteriormente:

  1. Encuentra la línea que comienza con Exec =
  2. Eliminar Exec =
  3. Elimine cualquier variable Exec (p %f. Ej . %u, %U). Es posible reemplazarlos con argumentos posicionales según lo previsto en la especificación, pero hacerlo agregaría una complejidad significativa al problema. Consulte la última especificación de entrada de escritorio .
  4. Ejecutar el comando
  5. Salga inmediatamente con el código de salida apropiado (para no ejecutar varias líneas Exec )

Tenga en cuenta que este script de AWK aborda algunos casos extremos que pueden o no ser abordados adecuadamente por algunas de las otras respuestas. Específicamente, este comando elimina múltiples variables Exec (teniendo cuidado de no eliminar el símbolo%), solo ejecutará un solo comando de línea Exec y se comportará como se esperaba incluso si el comando de línea Exec contiene uno o más signos de igual (por ejemplo script.py --profile=name).

Solo algunas otras advertencias ... De acuerdo con la especificación, TryExec es:

Ruta a un archivo ejecutable en el disco utilizado para determinar si el programa está realmente instalado. Si la ruta no es absoluta, el archivo se busca en la variable de entorno $ PATH. Si el archivo no está presente o si no es ejecutable, la entrada puede ignorarse (por ejemplo, no se puede usar en los menús).

Con eso en mente, no tiene sentido ejecutar su valor.

Algunas otras preocupaciones son Path y Terminal . La ruta consiste en el directorio de trabajo para ejecutar el programa. Terminal es un booleano que indica si el programa se ejecuta en una ventana de terminal. Todos estos pueden abordarse, pero no tiene sentido reinventar la rueda ya que ya hay implementaciones de la especificación. Si desea implementar Path , tenga en cuenta que system()genera un subproceso, por lo que no puede cambiar el directorio de trabajo haciendo algo como system("cd \047" working_directory "\047"); system(command). Sin embargo, presumiblemente podrías hacer algo así system("cd \047" working_directory "\047 && " command). Nota \ 047 son comillas simples (por lo que el comando no se rompe en las rutas con espacios).

La alternativa a Python

Aquí estoy robando una página de Carlo , quien sugirió crear un script de Python para usar el módulo gi . Aquí hay una forma mínima de ejecutar el mismo código desde el shell sin tener que crear un archivo y preocuparse por las 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

}

Luego ejecute la función del iniciador de la siguiente manera:

launch ./path/to/shortcut.desktop

Tenga en cuenta que el uso de URI es opcional. Además, no se realiza ninguna comprobación de errores, por lo que querrá asegurarse de que el iniciador exista y sea legible (antes de usarlo) si desea que su script sea duradero.

Seis
fuente
Pero el awkcomando es bueno. Por lo tanto, un +1
AB
¿Qué es un URI en este contexto? Tengo un archivo de escritorio en una carpeta arbitraria. ¿Cómo diablos ejecuto gtk-launch sin tener que envolverlo en otro script? Esto es enloquecedor.
Joseph Garvin
Esta awksolución no funcionará correctamente si el comando tiene espacios en blanco o barras diagonales de escape doble. Se rompe con esto: Exec=env WINEPREFIX="/path/to/.wine" wine c:\\\\windows\\\\command\\\\start.exe /Unix /path/to/.wine/dosdevices/c:/users/Public/Рабочий\\ стол/appname.lnky la dexsolución funciona bien.
MarSoft
27

Si bien OP no estaba preguntando sobre KDE, para cualquiera que esté ejecutando KDE se puede usar el siguiente comando:

kioclient exec <path-to-desktop-file>

En Fedora, esto está incluido en las kde-runtimerpm.

Raman
fuente
55
Votado porque funciona. No es necesario ejecutar KDE en absoluto, siempre y cuando tenga este programa instalado.
basic6
¿Hay alguna manera de tener esto? He compilado el reproductor de clementina, que tiene un error que solo se inicia al ejecutar el archivo .desktop (con plasma-shell). Y no puedo entender cómo hacer que el registro de salida se registre.
Kwaadpepper
@Kwaadpepper, puede usar su archivo .desktop para iniciar un script de shell, que internamente ejecuta su comando y redirige la salida a un archivo.
Raman
No encuentro kioclient en ningún paquete de KDE para Arch Linux en este momento. Sin embargo, gtk-launch funciona bajo KDE para mí.
MountainX
15

Podrías usar dex .

dex foo.desktop
Couac
fuente
2
En mi humilde opinión, esta es exactamente la respuesta correcta: una herramienta, una sola llamada con solo el archivo como parámetro. Eso es lo que estaba buscando, también, para probar .desktoparchivos escritos a mano . Y también puede crear .desktoparchivos, ¡sí! :-)
Axel Beckert
¡Perfecto! Si agrega un archivo .desktop que usa dex gist.github.com/stuaxo/4169fc1342c496b7c8f7999188f2f242 a / usr / share / aplicaciones / podrá iniciar archivos de escritorio en el administrador de archivos sin que también se abran en gedit por defecto.
Stuart Axon
13
exo-open [[path-to-a-desktop-file]...]

parece funcionar en la versión 13.10, si está instalado exo-utils (como es el caso de Xubuntu).

jarno
fuente
Sí, solo lo probé en Ubuntu Studio 14.04. Por cierto. xdg-open y gvfs-open también funcionan allí.
jarno
También funciona en 15
Jonathan
Usando Debian con xfce. ¡Funciona genial!
king_julien
Funciona para mí en Ubuntu 14.04
Tyler Collier
8

Adición a la respuesta de Hamish.

Dado el script deskopen, puede usar una referencia a él como la línea shebang en un archivo .desktop , ya que el carácter de comentario todavía está #. Es decir, ponga esto como la primera línea del archivo .desktop :

#!/usr/bin/env deskopen

Luego marque el archivo .desktop como ejecutable (por ejemplo, con a chmod +x whatever.desktop), y luego puede

path/to/whatever.desktop

y voilà - ¡La aplicación se abrirá! (Complete con el archivo de icono que especifiqué, aunque no tengo idea de cómo hacerlo).

Ahora, si también desea que deskopen pase por los parámetros de la línea de comandos, puede usar esta versión ligeramente modificada:

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

Como comentario aparte, intenté usar en "#{@:2}"lugar de shifting, pero seguía dándome una 'mala sustitución' ...

pabst
fuente
Sé que esto es más apropiadamente un comentario a la respuesta de Hamish, pero soy un nuevo usuario y no puedo comentar. ¡Oh bien!
Pasado
Si tiene la reputación, la acción más apropiada sería editar esa respuesta, en realidad.
Flimm
¡Sorprende eso, cualquiera puede sugerir ediciones, incluso los usuarios que no han iniciado sesión! No es gran cosa de ninguna manera.
Flimm
1
Esta es una respuesta en sí misma, está bien.
Bruno Pereira
puede usar en "${@:1}"lugar de shift, pero eso requiere en bashlugar de shen su #!shebang. En mi humilde opinión, su enfoque de cambio original es más simple y mejor
MestreLion
6

Actualmente no hay una aplicación que haga lo que usted describe en los archivos de Ubuntu. Hay un par de esfuerzos en progreso para crear una solución general para proporcionar integración para entornos de escritorio (como openbox) que no cumplen con estas especificaciones XDG.

Arch Linux está trabajando en una implementación de xdg-autostart basada en las bibliotecas python-xdg. Por lo que puedo encontrar, esto aún no parece completamente completo, pero tiene algunos informes de éxito.

También hay una implementación en C ++ de xdg-autostart en gitorious (http://gitorious.org/xdg-autostart/) que probablemente se beneficiaría de un uso más amplio.

Si alguna de las soluciones funciona para usted, considere enviar el trabajo necesario para su inclusión en Debian o Ubuntu.

Para usar cualquiera de las herramientas con openstart, debe llamarlo en /etc/xdg/openbox/autostart.sh (si estoy leyendo la documentación de openbox correctamente). Si esto no funciona, probablemente pueda llamarlo en cualquiera de los scripts de inicialización de sesión de openbox.

Emmet Hikory
fuente
No es lo que escuchar, de todos modos gracias por la info
enzotib
6

No tengo una solución inmediata que cumpla con el requisito de "usar un comando estándar" , pero si desea analizar mínimamente los .desktoparchivos o desea crear un alias Bash, entonces lo siguiente debería funcionar:

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

Otro enfoque que podría ser interesante sería crear un binfmt-miscmétodo a nivel de kernel que coincida con los .desktoparchivos (consulte grep -r . /proc/sys/fs/binfmt_misc/los patrones que ha habilitado actualmente).

Al final del día, algo en algún lugar tendrá que analizar los .desktoparchivos, es solo una cuestión de qué tan "estándar / predeterminado" es.

Sladen
fuente
Gracias interesante. Como "estándar" me refiero a algo provisto por el DE y conforme a freedesktop.org.
enzotib
Vota a favor en awklugar de una cadena de grepsy seds.
jmtd
Voto a favor, aunque no funciona (o mejor dicho, funciona demasiado) si tiene Exec=líneas
finales
2

Tomé el guión de la respuesta de Carlo anterior e intenté mejorarlo para mi propio uso en el escritorio.

Esta versión del script le permitirá ejecutar cualquier aplicación como si la hubiera ingresado en el HUD, siempre que sea el primer resultado. También le permite pasar argumentos de archivo para archivos .desktop que no admiten 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)
Fordi
fuente
1

Al intentar probar estos archivos, encontré la forma más simple de verificar que el DM o el administrador de la sesión hicieran lo que esperaba era abrir el directorio circundante en un navegador de carpetas de la interfaz de usuario y luego hacer doble clic para abrirlos.

Si está en una línea de comando: gvfs-open .o la gnome-open .abrirá en el explorador de carpetas configurado.

Lo sed no reflejará el comportamiento del DM, incluidas cosas complicadas como escapes y citas donde realmente no querría un comportamiento alternativo. No es la línea de comando, pero sí validado las cosas. También encontré la configuración Terminal=trueútil para la depuración.

Danny Staple
fuente
La terminal desaparece de inmediato, no tengo tiempo para ver el mensaje cuando uso Terminal = true: s
gouessej
1

Esta respuesta SO es lo que me dejó claro: no intente ejecutar el archivo de escritorio, ejecute el archivo señalado en el archivo de escritorio.

Por ejemplo, ejecute /home/jsmith/Desktop/x11vnc.sh

Exec=/home/jsmith/Desktop/x11vnc.sh
usuario119824
fuente
1

(Compilado de las otras respuestas aquí)

Dependiendo de su sistema y los diversos errores que pueden existir o no en su sistema, intente lo siguiente hasta que uno de ellos funcione:

  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

Tenga en cuenta que en los sistemas Ubuntu, sus lanzadores de escritorio "menú de inicio" están disponibles en /usr/share/applications/.

Como ejemplo, para mostrar cuál de los comandos anteriores funciona o no en mi sistema Ubuntu 14.04, estos son los resultados de las siguientes llamadas:

  1. xdg-open /usr/share/applications/eclipse_for_cpp.desktop # Falla debido a un error (intenta que guarde este archivo .desktop)
  2. exo-open /usr/share/applications/eclipse_for_cpp.desktop # Trabajos
  3. gtk-launch /usr/share/applications/eclipse_for_cpp.desktop # Falla con "gtk-launch: no existe tal aplicación"
  4. kioclient exec /usr/share/applications/eclipse_for_cpp.desktop # Trabajos
  5. dex /usr/share/applications/eclipse_for_cpp.desktop# Falla, y sudo apt install dexno puede localizar el paquete dex
Gabriel Staples
fuente
0

Asegúrese de que el script al que apunta su archivo de escritorio también sea ejecutable.

Si aún no funciona. Haga que el archivo de escritorio pueda ejecutarse en la terminal cambiando Terminal=truey colóquelo dentro de un script bash. Ejecute el script para atrapar la salida del error. Cambiar de nuevo cuando se corrijan los errores.

hakunami
fuente
0

La respuesta de Hamish es excelente, pero me gustaría sugerir una alternativa más simple, con menos tuberías involucradas:

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

En este caso, awkbusca una línea que comience por Exec, y luego simplemente imprimimos los campos después de esa línea, usando for loop e =imprimimos el campo 2, es decir, lo que venga después de ese campo. Los corchetes en los extremos de los comandos $(...)son sustitución de parámetros, por lo tanto, shell ejecutará lo que devuelva el comando awk; en este caso, devuelve el comando real que viene después Exec=.

En algunos casos raros, puede haber más de un =signo, que todavía es una posibilidad. Por eso, sugiero

$(awk -F= '/^Exec/||/^TryExec/ {for(i=2;i<=NF;i++) print $i;exit}' /usr/share/applications/firefox.desktop)
Sergiy Kolodyazhnyy
fuente
Nice, awkand Serg =)
AB
Y a veces, hay un TryExec, tal vez deberías verificar tu segundo comando =)
AB
@AB Jeje, awkes mi arma preferida cuando se trata de procesamiento de texto. Además, su sintaxis está cerca C. Ah, y ya agregó TryExecparte ^ _ ^
Sergiy Kolodyazhnyy
Tienes mi +1 =)
AB
Pero lo que va %f, %u, %Uo algo así detrás del comando?
AB