Pelo que pude reunir, .desktoparquivos são atalhos que permitem personalizar as configurações do aplicativo. Por exemplo, tenho muitos na minha /usr/share/applications/pasta.

Se eu abrir essa pasta nautilus, posso executar esses aplicativos clicando duas vezes no arquivo associado, por exemplo, clicar duas vezes firefox.desktopno Firefox. No entanto, não consigo encontrar uma maneira de fazer a mesma coisa via terminal.

Se eu fizer gnome-open foo.desktopisso simplesmente abre foo.desktopcomo um arquivo de texto. Se eu o tornar executável e executá-lo no bash, ele simplesmente falhará (o que é esperado, claramente não é o script do bash).
EDIT: Doing exec /fullpath/foo.desktopme dá uma Permission deniedmensagem, mesmo que eu mude de propriedade. Se eu tornar o executável e executar o mesmo comando, a guia do terminal que estou usando simplesmente se fecha (acho que trava). Por fim, se o fizer sudo exec /fullpath/foo.desktop, recebo um relatório de erros sudo: exec: command not found.

Essa é a minha pergunta, como posso executar um foo.desktoparquivo no terminal?

O comando que está sendo executado está contido no arquivo da área de trabalho, precedido por Exec=para que você possa extrair e executá-lo por:

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

Para quebrar isso

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

Você pode colocar isso em um arquivo, digamos ~/bin/deskopencom o conteúdo

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

Em seguida, torne-o executável

chmod +x ~/bin/deskopen

E então você poderia fazer, por exemplo

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

Os argumentos ( %u, %Fetc) estão detalhados em http://standards.freedesktop.org/desktop-entry-spec/desktop-entry-spec-1.0.html#exec-variables - nenhum deles é relevante para iniciar na linha de comando .

A resposta deve ser

xdg-open program_name.desktop

Mas devido a um bug, isso não funciona mais.

Com qualquer ubuntu recente que suporte gtk-launchsimplesmente vá

gtk-launch <file>onde é o nome do arquivo .desktop com ou sem a .desktopparte

Então gtk-launch fooabrefoo.desktop

( gtk-launchdocumentação )

O .desktop deve estar em / usr / share / applications, / usr / local / share / applications ou ~ / .local / share / applications

Utilizável a partir do terminal ou alt + F2 (alt + F2 armazena o comando no histórico tão facilmente acessível)

A partir de hoje (12.10) o bug ainda está presente. De fato, depende de como gvfs-open(chamado por xdg-open) funciona.

Ainda assim, consegui uma solução rápida (roubando inspiração do código-fonte do nautilus). É um pouco complicado, mas funciona perfeitamente no Ubuntu 12.10, adicionando um ícone significativo (não mais ?) no iniciador do Unity.

Primeiro, escrevi um script python usando Gio e coloquei o salvo 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)

O script precisa ter a permissão executável, então eu executei isso em um terminal:

chmod +x ~/bin/run-desktop

Então eu criei a .desktopentrada relativa em ~/.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 eu associada a entrada como o manipulador padrão em ~/.local/share/applications/mimeapps.listsob a [Default Applications]seção como:

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

Agora:

• xdg-open something.desktop funciona como esperado
• #!/usr/bin/xdg-open hashbang em cima de uma entrada executável da área de trabalho também funciona

Será um trabalho inútil quando gvfs-openresolverá o erro, mas enquanto isso ...

O Caminho Certo

Você realmente deveria estar usando gtk-launchse estiver disponível. Geralmente faz parte do pacote libgtk-3-bin (isso pode variar de acordo com a distribuição).

gtk-launch é usado da seguinte maneira:

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

Observe que gtk-launchrequer que o arquivo .desktop seja instalado (ou seja, localizado em /usr/share/applicationsou ~/.local/share/applications).

Portanto, para contornar isso, podemos usar uma pequena função Bash que instala temporariamente o arquivo .desktop desejado antes de iniciá-lo. A maneira "correta" de instalar um arquivo .desktop é via desktop-file-installmas eu vou ignorá-lo.

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

    )

}

Você pode usá-lo assim (e também transmitir argumentos adicionais ou URIs, se desejar):

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

A alternativa manual

Se você deseja analisar e executar manualmente um arquivo .desktop , pode fazê-lo com o seguinte awkcomando:

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

Se você deseja tratar o awkcomando como um script all-in-one; podemos até mostrar uma mensagem de erro e sair com um código de retorno 1 no caso de um comando Exec não ser encontrado:

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

Os comandos acima mencionados:

1. Encontre a linha começando com Exec =
2. Remover Exec =
3. Remova todas as variáveis Exec (por exemplo %f, %u, %U). É possível substituí-los por argumentos posicionais, conforme a especificação pretende, mas isso adicionaria complexidade significativa ao problema. Consulte a última especificação de entrada da área de trabalho .
4. Execute o comando
5. Sair imediatamente com o código de saída apropriado (para não executar várias linhas Exec )

Observe que esse script AWK aborda alguns casos extremos que podem ou não ser tratados adequadamente por algumas das outras respostas. Especificamente, esse comando remove várias variáveis Exec (tomando cuidado para não remover o símbolo%), executará apenas um único comando de linha Exec e se comportará conforme o esperado, mesmo que o comando Exec line contenha um ou mais sinais de igual (por exemplo script.py --profile=name).

Apenas algumas outras advertências ... De acordo com a especificação, o TryExec é:

Caminho para um arquivo executável no disco usado para determinar se o programa está realmente instalado. Se o caminho não for absoluto, o arquivo será procurado na variável de ambiente $ PATH. Se o arquivo não estiver presente ou não for executável, a entrada poderá ser ignorada (não ser usada em menus, por exemplo).

Com isso em mente, não faz sentido executar seu valor.

Algumas outras preocupações são Caminho e Terminal . O caminho consiste no diretório de trabalho para executar o programa. Terminal é um booleano que indica se o programa é executado em uma janela de terminal. Tudo isso pode ser resolvido, mas não há sentido em reinventar a roda, pois já existem implementações da especificação. Se você deseja implementar o Path , lembre-se de que system()gera um subprocesso, para que você não possa alterar o diretório de trabalho fazendo algo parecido system("cd \047" working_directory "\047"); system(command). No entanto, você provavelmente poderia fazer algo assim system("cd \047" working_directory "\047 && " command). Nota \ 047 são aspas simples (portanto, o comando não quebra nos caminhos com espaços).

A Alternativa Python

Estou roubando uma página de Carlo aqui , que sugeriu a criação de um script Python para usar o módulo gi . Aqui está uma maneira mínima de executar o mesmo código do shell sem precisar criar um arquivo e se preocupar com 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

}

Em seguida, execute a função do iniciador da seguinte maneira:

launch ./path/to/shortcut.desktop

Observe que o uso de URIs é opcional. Além disso, nenhuma verificação de erro é realizada, portanto, você deve garantir que o iniciador exista e seja legível (antes de usá-lo) se desejar que seu script seja durável.

Enquanto o OP não estava perguntando sobre o KDE, para quem está executando o KDE, o seguinte comando pode ser usado:

kioclient exec <path-to-desktop-file>

No Fedora, isso está incluído no kde-runtimerpm.

Você poderia usar dex .

dex foo.desktop

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

parece funcionar na versão 13.10, se o exo-utils estiver instalado (como é o caso do Xubuntu).

Adendo à resposta de Hamish.

Dado o script deskopen, você pode usar uma referência a ele como a linha shebang em um arquivo .desktop , pois o caractere de comentário ainda é #. Ou seja, coloque isso como a primeira linha do arquivo .desktop :

#!/usr/bin/env deskopen

Em seguida, sinalize o arquivo .desktop como executável (por exemplo, com a chmod +x whatever.desktop) e, em seguida, você pode

path/to/whatever.desktop

e voilà - O aplicativo será aberto! (Complete com o arquivo de ícone que eu especifiquei, embora não tenha ideia de como.)

Agora, se você também deseja que o deskopen passe por qualquer parâmetro da linha de comando, use esta versão ligeiramente modificada:

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

Como um aparte, tentei usar em "#{@:2}"vez de shifting, mas ele continuava me dando 'má substituição' ...

Atualmente, não há um aplicativo que faça o que você descreve nos arquivos do Ubuntu. Há alguns esforços em andamento para criar uma solução geral para fornecer integração para ambientes de desktop (como o openbox) que não sejam compatíveis com essas especificações XDG.

O Arch Linux está trabalhando na implementação do xdg-autostart com base nas bibliotecas python-xdg. Pelo que pude encontrar, isso ainda não parece totalmente completo, mas tem alguns relatos de sucesso.

Há também uma implementação em C ++ do xdg-autostart no gitorious (http://gitorious.org/xdg-autostart/) que provavelmente se beneficiaria de um uso mais amplo.

Se alguma solução funcionar para você, por favor, considere enviar o trabalho necessário para inclusão no Debian ou no Ubuntu.

Para usar qualquer ferramenta com o openstart, chame-o em /etc/xdg/openbox/autostart.sh (se estiver lendo a documentação do openbox corretamente). Se isso não funcionar, você provavelmente poderá chamá-lo em qualquer um dos scripts de inicialização da sessão do openbox.

Não tenho uma solução imediata que atenda ao requisito de "usar um comando padrão" , mas se você deseja analisar minimamente os .desktoparquivos ou criar um alias do Bash, o seguinte deve funcionar:

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

Outra abordagem que pode ser interessante seria criar um binfmt-miscmétodo no nível do kernel que corresponda aos .desktoparquivos (veja grep -r . /proc/sys/fs/binfmt_misc/os padrões que você ativou atualmente).

No final do dia, algo em algum lugar terá que analisar os .desktoparquivos, é apenas uma questão de quão "padrão / padrão" é esse.

Peguei o script da resposta de Carlo acima e tentei aprimorá-lo para meu próprio uso na área de trabalho.

Esta versão do script permitirá executar qualquer aplicativo como se você o tivesse inserido no HUD, desde que seja o primeiro resultado. Também permite passar argumentos de arquivo para arquivos .desktop que não oferecem suporte a URIs.

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

Ao tentar testar esses arquivos, achei a maneira mais simples de verificar se o DM ou o gerenciador de sessões faria o que eu esperava abrir o diretório circundante em um navegador de pastas da interface do usuário e clique duas vezes para abri-los.

Se você estiver em uma linha de comando: gvfs-open .ou gnome-open .a abrirá no navegador de pastas configurado.

A coisa sed não espelha o comportamento do Mestre, incluindo coisas complicadas, como escapadas e citações, nas quais você realmente não gostaria de comportamento alternativo. Não é uma linha de comando, mas validou as coisas. Também achei a configuração Terminal=trueútil para depuração.

Essa resposta do SO é o que deixou claro para mim: não tente executar o arquivo da área de trabalho, execute o arquivo apontado no arquivo da área de trabalho.

Por exemplo, execute /home/jsmith/Desktop/x11vnc.sh

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

(Compilado a partir de várias outras respostas aqui)

Dependendo do seu sistema e dos vários erros que podem ou não existir no seu sistema, tente o seguinte até que um deles 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

Observe que nos sistemas Ubuntu, os ativadores de área de trabalho do "menu Iniciar" estão disponíveis no /usr/share/applications/.

Como exemplo, para mostrar quais dos comandos acima funcionam ou não no meu sistema Ubuntu 14.04, eis os resultados das seguintes chamadas para mim:

1. xdg-open /usr/share/applications/eclipse_for_cpp.desktop # Falha devido a erro (tenta me salvar este arquivo .desktop)
2. exo-open /usr/share/applications/eclipse_for_cpp.desktop # Trabalho
3. gtk-launch /usr/share/applications/eclipse_for_cpp.desktop # Falha com "gtk-launch: no application"
4. kioclient exec /usr/share/applications/eclipse_for_cpp.desktop # Trabalho
5. dex /usr/share/applications/eclipse_for_cpp.desktop# Falha, e sudo apt install dexnão é possível localizar o pacote dex

Verifique se o script para o qual o arquivo da área de trabalho aponta também é executável.

Se ainda não funcionar. Torne o arquivo da área de trabalho executável no terminal alterando-o Terminal=truee coloque-o dentro de um script bash. Execute o script para capturar a saída do erro. Mude de volta quando os erros forem corrigidos.

A resposta de Hamish é ótima, mas eu gostaria de sugerir uma alternativa mais simples, com menos tubulações envolvidas:

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

Nesse caso, awkprocura por uma linha que comece com Exece, em seguida, simplesmente imprimimos campos após essa linha, usando o loop for e =imprimimos o campo 2, ou seja, o que vier depois desse campo. Os colchetes nas extremidades dos comandos, $(...)são substituições de parâmetros, portanto o shell executará o que o comando awk retornar; nesse caso, ele retorna o comando real que vem depois Exec=.

Em alguns casos raros, pode haver mais de um =sinal, o que ainda é uma possibilidade. Por isso, sugiro

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