Executando um arquivo .desktop no terminal

141

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?

Malabarba
fonte
5
NB: A razão pela qual você execfalhou é porque o exec substitui o processo em execução pelo processo especificado, portanto, o que você fez foi tentar substituir o shell pela execução da área de trabalho como um binário compilado. A razão pela qual você não conseguiu sudo execé porque é um shell embutido e não um comando binário.
Daenyth 4/10/10
Interessante, eu queria saber por que isso causou o fechamento da guia.
Malabarba 4/10/10
Entendo, eles acabam analisando o arquivo .desktop. Obrigado mesmo assim pelo link.
Enzotib
moderadores: oops, acho que pode ter assinalaram este acidentalmente, desculpe se esse for o caso
Croad Langshan

Respostas:

54

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 .

Hamish Downer
fonte
Isso dá o melhor resultado até agora, mas às vezes produz um comportamento indesejável. Isso acontece sempre que a linha "Exec =" possui um argumento como% u ou% i. Bash tenta passar essa string como um argumento regular. Por exemplo, grep '^Exec' firefox.desktop | sed 's/^Exec=//'abrir o Firefox com uma guia que carrega www.% U.com .
Malabarba 4/10/10
No momento, adicionei um segundo sedpara remover qualquer argumento. Mas acho que pode haver uma maneira mais "natural" de executá-lo.
Malabarba 4/10/10
Atualizei minha resposta com o sed extra - esqueci que os arquivos da área de trabalho podem ter argumentos.
quer
Você deve adicionar uma "cauda -1" ao canal após "grep", pois "Exec =" pode aparecer várias vezes e, depois disso, somente a última aparência deve ser executada.
daisy
13
-1: isso pode funcionar para .desktoparquivos simples , mas ignora entradas como Path=e TryExec=que podem afetar a execução. Ele também executa o errado Exec=se o arquivo contém ações da área de trabalho ( "quicklists")
MestreLion
85

A resposta deve ser

xdg-open program_name.desktop

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

Richard Holloway
fonte
7
Uau, isso ainda é um bug, muito progresso no xdg. exo-openestá listado como solução alternativa e também abre o gedit. :(
de Drew
1
@RichardHolloway: gnome-opense não chamar xdg-open, é o contrário! Assim, a questão reside na gvfs-open(o sucessor ou gnome-open)
MestreLion
13
"não funciona mais"? Isso nunca aconteceu! xdg-openfunciona por associação mimetype e .desktoparquivos estão associados com editores de texto, uma vez que são uma subclasse de texto
MestreLion
13
Isto é tão estúpido (que não existe uma maneira sensata para executar um arquivo de área de trabalho a partir do terminal)
Sam Watkins
2
Funciona para mim no Arch Linux, mas talvez seja um bug específico do Ubuntu.
1155 Victor Victor
75

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)

doug
fonte
É assim que funciona também no debian.
gtk-launch firefox.desktop ~ / .local / share / applications / lança o firefox visualizando o diretório ~ / .local / share / applications / para mim. Parece que você estava correto, o Firefox não deveria ter passado o diretório do arquivo .desktop como argumento. Na verdade o diretório passado para gtk-lançamento não é suposto ser usado para localizar o dir que contém o arquivo .desktop (e não é, de fato)
Croad Langshan
Yay! Uma resposta que funciona!
Alicia
Isso funciona para mim no Arch Linux também. Nenhuma das outras respostas foi satisfatória, mas essa é boa. :-) Funciona mesmo que eu esteja executando o KDE.
MountainX
2
Nenhuma versão disso funciona para mim no Ubuntu 18.10. Sempre que reclama que o aplicativo não existe, esteja na pasta com o arquivo da área de trabalho ou não, inclua a extensão .desktop ou não, e nomeie o diretório separadamente ou não.
Joseph Garvin
38

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 ...

Carlo Pellegrini
fonte
1
Isso funciona melhor do que a resposta de Hamish Downer, pois lidará com várias Exec=linhas e %parâmetros no comando corretamente.
Flimm
4
Obrigado pelo código - eu estou no Lucid, e simplesmente salvei isso como /usr/bin/xdg-openpy, e dei um chmod +x- e usei em launcher.launch([],context)vez de ...None,context)(por causa de " TypeError: argumento 1: deve ser sequência, não NoneType "). Agora xdg-openpy app.desktopfunciona a partir da linha de comando (e tudo normal ao clicar duas vezes app.desktop), e isso pode me lembrar se eu tentar ligar para o terminal xdg-opene pressionar tab. Felicidades!
Sdaau
3
+1. Essa é a única resposta que não requer a análise manual do .desktoparquivo, por isso é a abordagem mais sensata (e segura). Também usa moderno em gi.repositoryvez do obsoleto pygtk, ótimo! :)
MestreLion
2
De fato, essa é uma pergunta sobre a resposta de Carlo Pellegrini. Sou iniciante, corrija-me se houver uma maneira melhor de colocá-lo. O script funciona muito bem, mas o ícone que recebo no iniciador do Unity não é o ícone definido no arquivo .desktop, mas o ícone padrão do comando 'Exec'ed'. Alguma idéia sobre isso?
Ingo Leonhardt
1
@Noitidart escrever a última resposta levou mo a fazer algum google e eu achei isso . Não o check-out, mas talvez ele ajuda
Ingo Leonhardt
31

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.

Seis
fonte
Mas o awkcomando é bom. Portanto, +1
AB
O que é um URI neste contexto? Eu tenho um arquivo da área de trabalho em uma pasta arbitrária. Como diabos eu apenas corro o gtk-launch nele sem precisar envolvê-lo em algum outro script? Isso é enlouquecedor.
Joseph Garvin
Esta awksolução não funcionará corretamente se o comando tiver espaços em branco de escape duplo ou barras invertidas. Ele quebra com isso: Exec=env WINEPREFIX="/path/to/.wine" wine c:\\\\windows\\\\command\\\\start.exe /Unix /path/to/.wine/dosdevices/c:/users/Public/Рабочий\\ стол/appname.lnke a dexsolução funciona bem.
MarSoft 8/03
27

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.

Raman
fonte
5
Votado porque funciona. Não é necessário executar o KDE, desde que você tenha este programa instalado.
basic6
Existe uma maneira de descobrir isso? Eu compilei o Clementine Player, que possui um bug que ocorre apenas através do arquivo .desktop (com plasma-shell). E eu não consigo descobrir, como ter o log de saída log anywere.
Kwaadpepper
@Kwaadpepper, você pode usar o arquivo .desktop para iniciar um script de shell, que executa internamente o seu comando e redireciona a saída para um arquivo.
Raman
Não encontro o kioclient em nenhum pacote do KDE para Arch Linux no momento. No entanto, o gtk-launch funciona no KDE para mim.
MountainX
15

Você poderia usar dex .

dex foo.desktop
couac
fonte
2
IMHO esta é exatamente a resposta certa: Uma ferramenta, uma única chamada com apenas o arquivo como parâmetro. Também era o que eu procurava para testar .desktoparquivos escritos à mão . E também pode criar .desktoparquivos, sim ! :-)
Axel Beckert
Perfeito! Se você adicionar um arquivo .desktop que use dex gist.github.com/stuaxo/4169fc1342c496b7c8f7999188f2f242 em / usr / share / applications /, poderá iniciar arquivos da área de trabalho no gerenciador de arquivos sem que eles também sejam abertos no gedit por padrão.
perfil completo de Stuart Axon
13
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).

jarno
fonte
Sim, apenas testei no Ubuntu Studio 14.04. Entre. O xdg-open e o gvfs-open também funcionam lá.
28414 jarno
Funciona em 15 também
Jonathan
Usando o Debian com o xfce. Funciona bem!
king_julien
Funciona para mim no Ubuntu 14.04
Tyler Collier
8

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

pabst
fonte
Sei que este é um comentário mais adequado à resposta de Hamish, mas sou um novo usuário e não tenho permissão para comentar. Ah bem!
Pabst
Se você tem reputação, a ação mais apropriada seria editar essa resposta, na verdade.
Flimm
Nota: qualquer pessoa pode sugerir edições, mesmo usuários que não fizeram login! Não é nada demais.
Flimm
1
Esta é uma resposta por si só, tudo bem.
Bruno Pereira
você pode usar em "${@:1}"vez de shift, mas isso requer em bashvez de shno seu #!shebang. IMHO sua abordagem mudança original está mais simples e melhor
MestreLion
6

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.

Emmet Hikory
fonte
Não o que gostaria de ouvir, de qualquer forma obrigado pela informação
enzotib
6

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.

sladen
fonte
Obrigado, interessante. Como "padrão", quero dizer algo fornecido pelo DE e em conformidade com o freedesktop.org.
enzotib
Voto por favor em awkvez de uma cadeia de greps e seds.
jmtd
Voto a favor, apesar de não funcionar (ou melhor, colocar demais) se você tiver várias Exec=linhas: /
Boris Churzin
2

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)
Fordi
fonte
1

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.

Danny Staple
fonte
O terminal desaparece imediatamente, não tenho tempo para ver a mensagem ao usar o Terminal = true: s
gouessej
1

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
user119824
fonte
1

(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
Gabriel Staples
fonte
0

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.

hakunami
fonte
0

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)
Sergiy Kolodyazhnyy
fonte
Bom, awke Serg =)
AB
E, às vezes, há uma TryExec, talvez você deve verificar o seu 2º comando =)
AB
@AB Hehe, awké a minha arma de escolha quando se trata de processamento de texto. Além disso, sua sintaxe está próxima C. Ah, e já adicionou TryExecparte ^ _ ^
Sergiy Kolodyazhnyy
Você tem o meu +1 =)
AB
Mas o que é cerca de %f, %u, %Uou algo assim para trás o comando?
AB