Esta seção descreve alguns itens do menu Exibir, permitindo-lhe configurar rapidamente o Kate para funcionar da maneira desejada.

Quando iniciar o Kate pela primeira vez, você verá duas janelas com fundo branco. Acima das duas janelas existe uma barra de ferramentas com os ícones mais utilizados e, acima dela, a barra de menus.

A janela da esquerda é uma barra lateral. Ela é composta pelas janelas Documentos e Navegador do sistema de arquivos. Alterne entre as duas clicando nas abas à esquerda da janela.

Se você iniciou o Kate com um arquivo, na janela da direita aparecerá o arquivo que estiver editando e na janela Documentos da barra lateral, o nome do arquivo. Use a janela Navegador do sistema de arquivos para abrir outros arquivos.

Para ativar ou desativar a janela das barras laterais, use a opção Exibir → Visões da ferramenta ou a combinação de teclas Ctrl+Alt+Shift+F. Essa opção do menu oferece uma prévia do poder e flexibilidade do Kate. Nesta seção, serão vistos quatro itens:

No Ver ferramentas , você tem uma lista de todos osplugins ativos. Clique na caixa de seleção na frente de cada item ou clique com o botão esquerdo do mouse nobotão da ferramenta, na barra lateral, para ativar e desativar a visualização da ferramenta.

Muitos dos comandos ativados pelo teclado (atalhos) do Kate podem ser configurados através do menu Configurações. Por padrão, o Kate respeita os seguintes atalhos de teclado.

Além disso, você pode usar os atalhos fornecidos pela ajuda do componente KatePart e por todos Kate plugins ativados.

Janela, Visão, Documento, Quadro, Editor... O que é toda esta terminologia do Kate e como obter mais informações sobre ela? Este capítulo explicará isto e muito mais.

O Kate é capaz de ter mais de um documento aberto ao mesmo tempo, e também de dividir a área de edição em quadros, de modo similar ao que o Konqueror ou ao que o editor emacs trabalham. Desta maneira você pode visualizar vários documentos ao mesmo tempo, ou mais instâncias do mesmo documentos, útil, por exemplo, se seu documento contém definições, no topo, que você deseja ver com frequência, para referência. Ou, você poderia visualizar um cabeçalho do fonte do programa em um quadro, enquanto edita o arquivo de implementação em outro.

Quando um documento está disponível em mais de um editor, as mudanças feitas em um editor imediatamente serão refletidas nos outros. Isto inclui mudanças de texto, e de seleção de texto. Operações de busca ou movimento do cursor só se refletem no editor atual.

Atualmente não é possível ter mais instâncias do mesmo documento aberto, no sentido de que uma instância será editada, enquanto que a outra não será.

Ao dividir um editor em dois quadros, a divisão é feito em dois quadros de tamanho igual, ambos exibindo o documento atual do editor. O novo quadro será colocado na base (no caso de divisão horizontal) ou para a direito (divisão vertical). O novo quadro obtém o foco, que é visualizado por uma barra de cursor piscante no quadro em foco.

Usar a abertura rápida é muito simples. Depois de abri-la, basta digitar o nome ou partes do nome do arquivo que você deseja abrir e a abertura rápida filtrará a lista com base no que você digitou. Pressionar Enter abre o arquivo selecionado, enquanto Esc fecha a abertura rápida.

Por padrão, apenas o nome do arquivo é considerado na filtragem. Se você quiser corresponder ao caminho, precisa incluir uma barra "/" no texto digitado. Por exemplo: "doc/index" corresponderá a todos os arquivos que contêm "index" dentro da pasta "doc".

Os documentos que já estão abertos são destacados em negrito e listados na parte superior quando a caixa de diálogo é aberta. Além disso, quando a abertura rápida é exibida, o documento aberto anteriormente já está selecionado, então você pode simplesmente pressionar Enter e será levado para esse documento.

A abertura rápida oferece algumas opções de configuração. Para acessar essas opções, clique com o botão direito do mouse na linha de edição de entrada.

O Kate não fornece (ainda) qualquer documentação relacionado a leitura do documento. Dependendo do arquivo que você estiver editando, você pode encontrar a ajuda Integrada ao Emulador de Terminal para visualizar as páginas de manual ou documentação info do UNIX®, ou você pode usar o Konqueror.

A página do Kate fornece alguns Artigos e Howtos com mais informações além do escopo deste manual.

Editar uma ferramenta abre uma caixa de diálogo de configuração que permite uma configuração detalhada da ferramenta.

O botão Padrões só é visível para ferramentas que são disponibilizadas com o Kate. Ao clicar nele, todas as configurações da ferramenta são revertidas para os valores padrão (ou seja, de fábrica).

Alguns campos de edição, como o Executável, os Argumentos, a Entrada e a Pasta de trabalho, suportam variáveis ​​que são expandidas ao invocar a ferramenta. Isso é indicado pelo ícone {} que aparece quando um desses campos de entrada de texto recebe o foco (veja o círculo vermelho):

Ao passar o cursor sobre um desses campos de entrada de texto, também é exibida uma dica de ferramenta com o texto expandido atual. Além disso, clicar na ação {} abrirá uma caixa de diálogo que lista todas as variáveis ​​disponíveis:

Esta funcionalidade oferece muita flexibilidade ao definir uma ferramenta externa, já que todas as variáveis ​​do formato %{...} são expandidas quando a ferramenta é invocada. Há dois tipos de variáveis ​​suportadas:

O primeiro formato, %{nome-variável}, simplesmente substitui a variável pelo seu conteúdo. Por exemplo, a variável %{Document:FileName} é substituída pelo nome do arquivo do documento atual, sem o seu caminho. O segundo formato %{nome-variável:<valor>} obtém o conteúdo <valor>. Por exemplo, isso pode ser usado para expandir uma variável de ambiente com %{ENV:HOME}, ou pode-se obter a data atual no formato desejado, como %{Date:yyyy-MM-dd}.

Diversas ferramentas são fornecidas por padrão. No entanto, se você tiver ferramentas mais úteis, contribua com elas para nosso projeto no GitLab para que possamos adicioná-las a esta lista. Todas as ferramentas padrão são visíveis na lista por padrão. No entanto, todas as ferramentas podem ser alteradas ao seu gosto, incluindo a categoria ou até mesmo excluindo ferramentas. As ferramentas excluídas podem ser adicionadas novamente clicando no botão Adicionar na página de configuração, conforme descrito acima.

Este plugin é destinado a desenvolvedores e provavelmente de pouca utilidade para os usuários. Isto mostra um backtrace entregue pelo gdb em uma lista de exibição na janela de visualização do Kate Clicar em um item abre o arquivo selecionado e salta para o número da linha correta. Ele funciona para rastreamentos gerados em sua própria máquina, mas também funciona para backtraces de outras pessoas, isto é com /home/dummy/qt-copy/…/qwidget.cpp encontrados em outras máquinas. Para que funcione, você deve indexar os diretórios onde o código-fonte está localizado.

Às vezes, existem vários arquivos com o mesmo nome, por exemplo

Para escolher a opção certa, o plugin seleciona as duas últimas partes da URL, neste caso, isso seria

Geralmente, o plugin correto é encontrado.

A indexação da ramificação master e outra ramificação, é claro, gerará um conflito.

Na página de configuração, adicionar os diretórios contendo o código-fonte.

Configurar caminhos na exibição da ferramenta do navegador Backtrace

Clicar em OK iniciará a indexação. Quando a indexação for finalizada, abra a ferramenta de visualização do navegador backtrace.

Agora você pode carregar um backtrace da área de transferência (por exemplo, quando clicar em Copie para a área de transferência no DrKonqi) ou de um arquivo.

O plugin de compilação permite executar ações como build, clean e compile em um projeto. Você também pode executar automaticamente os aplicativos gerados. O plugin basicamente oferece uma maneira de configurar conjuntos de comandos para serem executados e pode analisar a saída em busca de links para arquivos e linhas e colunas específicas nesses arquivos. Portanto, mesmo que o plugin tenha sido originalmente criado para compilar C/C++ e testado principalmente com essa linguagem, ele também pode ser útil para outros fins e linguagens.

O plugin de compilação adiciona uma área de ferramentas Compilar na parte inferior e um menu Compilar no menu principal. A área de ferramentas pode ser usada para selecionar e configurar alvos de compilação, enquanto o menu e seus atalhos podem ser usados ​​para selecionar e executar os comandos de shell configurados.

A visualização da ferramenta Compilar possui duas abas:

Aba das configurações do alvo

A aba de configurações de alvo pode ser usada para configurar vários alvos e definir conjuntos de alvos.

Um conjunto de alvos é um grupo de comandos que podem ser executados em uma pasta de trabalho específica. Os conjuntos de alvos podem ser adicionados em Projetos ou Sessão. Os conjuntos de alvos personalizados adicionados em Projetos são armazenados em um arquivo .kateproject.build na pasta raiz do projeto e são restaurados quando o projeto é reaberto. Os conjuntos de alvos adicionados em Sessão são armazenados na configuração atual da sessão Kate.

A primeira linha, em um conjunto de alvos, contém um nome para o conjunto na primeira coluna, e na segunda coluna temos a pasta onde os comandos devem ser executados. Em cada linha seguinte, temos um nome para o comando na primeira coluna, um comando de compilação na segunda coluna e um comando de execução na terceira coluna. Para editar um deles, clique duas vezes na entrada ou use o atalho de edição (geralmente F2).

Pasta de trabalho

A segunda coluna da primeira linha em um conjunto de alvos é usada para configurar a pasta de trabalho usada para compilar e executar comandos. Se o plugin de projeto estiver habilitado, a string da pasta de trabalho também pode conter marcadores para o caminho da pasta base do projeto: %B e para o nome: %b

Comando de compilação

A segunda coluna nas "linhas não iniciais" contém o comando do shell a ser executado na pasta de trabalho. Observe a palavra "shell". Quase qualquer comando do shell servirá. O comando de compilação pode conter marcadores. %f para o arquivo atual, %d para a pasta do arquivo atual e %n para o nome base do arquivo atual (nome do arquivo sem sufixo).

Comando de execução

A terceira coluna nas "linhas não iniciais" pode conter um comando shell para execução em um terminal real no diretório de trabalho definido. O terminal é aberto como uma aba. O plugin tentará reutilizar a aba do terminal se o mesmo comando for executado e o aplicativo anterior tiver sido encerrado.

Na parte superior da aba Configurações do alvo, temos uma barra de ferramentas com um filtro de alvo e os seguintes botões:

Compilar o alvo selecionado

Compilar e executar o alvo selecionado

Adicionar um novo alvo de compilação

Criar um novo conjunto de alvos

Copiar um comando ou conjunto de alvos

Excluir o comando atual ou conjunto de alvos

O plugin Compilação do Kate foi criado por Kåre Särs.

Agradecimento especial a Salma Sultana, participante do Google Code-In 2011, por escrever grande parte desta seção.

Este plugin permite fechar um grupo de documentos com base em suas extensão e caminhos.

Supondo que você tenha esses documentos abertos no Kate:

Em seguida, você tem as seguintes opções para fechar documentos, conforme exibido na captura de tela:

Use a caixa de seleção no último item da lista para ativar ou desativar uma caixa de diálogo de confirmação. A opção selecionada será aplicada para fechar ações.

Este plugin adiciona uma pré-visualização/seletor de cor embutido no texto (por exemplo, #FFFFFF, branco).

Para carregar este plugin, abra a janela de configuração do Kate em Configurações → Configurar Kate.... Em seguida, selecione Seletor de cor e feche a janela.

Na página de configurações do seletor de cor na configuração do Kate, você pode configurar as seguintes opções de comportamento do plugin.

O plugin de colchetes coloridos colore pares de colchetes correspondentes com cores diferentes para melhorar a legibilidade. No entanto, nem todos os colchetes são coloridos. Um colchete cujo parêntese de abertura ou fechamento correspondente não estiver visível será ignorado. Da mesma forma, um par de colchetes que for o único par de colchetes em uma linha não será colorido.

O plugin não oferece nenhuma opção de configuração.

CTags gera um arquivo de índice (ou tag) de objetos de idioma encontrado nos arquivos de origem que permite que esses itens sejam localizados rápida e facilmente usando esse plugin do Kate.

Uma tag significa um objeto de idioma para o qual uma entrada de índice está disponível (ou, alternativamente, a entrada de índice criada para esse objeto).

A geração de tags é suportada para estas Linguagens de programação.

O plugin CTags usa dois arquivos de banco de dados diferentes para o índice.

Na página de configurações do CTags na configuração do Kate, você pode adicionar ou remover diretórios contendo o código-fonte e regenerar os CTags comuns do banco de dados.

Index comum

Configuração do banco de dados do CTags

Na parte inferior da página de configurações, você pode adaptar os Comandos do CTags.

Para mais informações sobre todas as opções disponíveis, leia o manual do CTags. Esta página de manual está disponível no KHelpCenter e você também pode inserir a URL man:/ctags diretamente no Konqueror

Clicar em Atualizar iniciará a indexação. Quando a indexação terminar, a caixa de diálogo será fechada.

Você coloca o cursor do mouse sobre o objeto de linguagem de programação de seu interesse, como uma função, símbolo etc. , em seguida, selecione uma das ações do CTags para pular para a linha e o arquivo em que o objeto é definido ou declarado.

Por padrão, as ações no menu CTags não possuem atalhos atribuídos. Use o Editor de atalhos de teclado para configurar seus próprios atalhos.

Como alternativa, use o campo de pesquisa na guia Pesquisa doCTags.

A inserção de caracteres no campo de pesquisa iniciará a pesquisa e exibiránomes correspondentes de objetos da linguagem, como funções, classes, símbolos etc.junto com o tipo e o nome do arquivo.

Selecione um item na lista para saltar para a linha correspondente no arquivo fonte.

O plugin permite uma prévia em tempo real do documento de texto atualmente editado e no formato final na barra lateral. Então, ao editar por por exemplo um texto em Markdown ou uma imagem SVG, o resultado é visível instantaneamente ao lado do texto de origem.

Para a exibição, o plugin usa o plugin do KParts, atualmente selecionado como o preferido para o tipo MIME do documento. Se lá não existir um plugin do KParts para esse tipo, nenhuma visualização é possível.

Para alterar o plugin preferido, abra o menu Associações de arquivos nas Configurações do sistema e edite a Ordem de preferência dos serviços na aba Incorporação.

Os botões na parte superior da janela de visualização prévia fornecem estas ações:

De cima para baixo, o navegador do sistema de arquivos consiste nos seguintes elementos:

Este plugin pode ser configurado na página do Navegador do sistema de arquivos da configuração do Kate.

A lista de documentos exibe todos os documentos atualmente abertos no Kate. Os arquivos modificados terão um pequeno ícone disquete à esquerda para indicar esse estado.

Na parte superior da lista de documentos existe uma barra de ferramentas com os seguintes botões:

Criar novo documento

Abre um documento existente

Documento anterior

Próximo documento

Salva o documento atual

Salva o documento atual com outro nome

Por padrão, a lista de documentos é exibida no Modo árvore, que exibe a estrutura de pastas em torno de todos osdocumentos abertos. Também está disponível Modo lista, que mostra em uma lista simples todos os documentos abertos. Você pode alternar os modos clicando com o botão direito do mouse na lista e selecionar no menu Modo de exibição.

Se dois ou mais arquivos com o mesmo nome (localizados em pastas diferentes) são abertos no Modo lista, o nome do segundo aparecerá com o número “(2)”. A dica de ferramenta para o arquivo será exibir seu nome completo, incluindo o caminho, permitindo que você escolha uma.

Para exibir um documento no quadro atualmente ativo, clique no nome do documento na lista.

O menu de contexto possui algumas ações comuns do menu Arquivo.

Além disso, existem ações do gerenciador de arquivos para renomear ou excluir o arquivo.Com Copiar localização, você pode copiar o caminho completo do documento para a área de transferência.

Você pode classificar a lista de algumas maneiras diferentes clicando com o botão direito do mouse na lista eselecionando no menu Classificar por. As opções são:

A lista de documentos, por padrão, visualiza seu histórico sombreando asentradas para os documentos mais recentes com uma cor de fundo. Se odocumento foi editado, uma cor extra é misturada. O documento mais recentetem a cor mais forte, para que você possa encontrar facilmente os documentos em que estátrabalhando. Esse recurso pode ser desativado na configuração Documentos configuração da caixa de diálogo.

A localização padrão da lista de documentos no Kate está àesquerda da área de edição.

O plugin GDB do Kate fornece uma interface simples para qualquer depurador que suporte o Protocolo de Adaptador de Depurador. Em particular, isso inclui o GNU Project Debugger, também conhecido como GDB, conforme descrito aqui.

Você poderá ativar o plugin do GDB na seção plugins da configuração do Kate.

Depois de efetuar estas preparações, abra o arquivo de código no Kate, selecione o "perfil de depuração", insira a localização do executável na aba Configurações da área de Depuração e selecione a opção do menu Depuração → Iniciar depuração para começar.

O "perfil de depuração" seleciona o servidor DAP a ser usado (por exemplo, GDB) e a forma de iniciar esse servidor. Um caso típico é o servidor iniciar um processo conforme especificado acima, mas ele também pode se conectar a um processo em execução (nesse caso, um PID deverá ser especificado em vez de um executável). Também podem existir outros modos específicos para a linguagem e o servidor DAP. Veja mais adiante para obter informações adicionais sobre o contexto e a configuração.

Todas estas opções estão disponíveis nos menus do Kate, estando também muitas disponíveis na barra de Depuração.

A Área de Depuração consiste em várias páginas:

A área da Pilha de chamadas contém uma lista dos registros de chamadas que são devolvidos pelo GDB.

A área da Pilha de chamadas do plugin do GDB.

A área de Locais contém uma lista com todas as variáveis do programa carregadas no momento, bem como os seus valores correspondentes.

A área de Variáveis locais do plugin do GDB.

Agradecimentos especiais ao participante Martin Gergov do Google Code-In 2011 pela escrita de grande parte desta seção.

A página de configuração do plugin define os "perfis de depuração" que podem ser selecionados. A configuração padrão (JSON) é exibida lá e pode ser "sobreposta" por uma configuração semelhante fornecida pelo usuário. Um exemplo de trecho é o seguinte:

{
    "dap": {
        "debugpy": {
            "url": "https://github.com/microsoft/debugpy",
            "run": {
                "command": ["python", "-m", "debugpy", "--listen", "${#run.port}", "--wait-for-client"],
                "port": 0,
                "supportsSourceRequest": false
            },
            "configurations": {
                "launch": {
                    "commandArgs": ["${file}", "${args|list}"],
                    "request": {
                        "command": "attach",
                        "stopOnEntry": true,
                        "redirectOutput": true
                    }
                },
                "attach": {
                    "commandArgs": ["--pid", "${pid}"],
                    "request": {
                        "command": "attach",
                        "stopOnEntry": true,
                        "redirectOutput": true
                    }
                },
        },
        "gdb": {
            "url": "gdb",
            "run": {
                "command": [
                    "gdb",
                    "-i",
                    "dap"
                ],
                "redirectStderr": true,
                "redirectStdout": true,
                "supportsSourceRequest": true
            },
            "configurations": {
                "launch (debug)": {
                    "request": {
                        "command": "launch",
                        "mode": "debug",
                        "program": "${file}",
                        "args": "${args|list}",
                        "cwd": "${workdir}"
                    }
                }
            }
        }
    }
}

Cada uma das entradas em configurations é combinada com os dados de run e forma um "perfil". Isso especifica o servidor DAP a ser iniciado, juntamente com seus argumentos, sendo estes específicos para o perfil (commandArgs). As outras partes especificam a solicitação do protocolo DAP (launch ou attach), juntamente com extensões específicas do DAP.

É claro que o servidor especificado deve estar instalado (e normalmente também estar no PATH para execução adequada).

Várias etapas de sobreposição/fusão são aplicadas; a configuração do usuário (carregada de um arquivo) sobrepõe a configuração padrão (interna), e a entrada "dap" na configuração do projeto .kateproject, por sua vez, sobrepõe as demais.

{
    // isto pode também ser uma array de objetos
    "exec": {
        "hostname": "foobar"
        // o comando pode também ser uma array de string
        "prefix": "podman exec -i foobarcontainer",
        "mapRemoteRoot": true,
        "pathMappings": [
            // ambas as formas a seguir são possíveis
            // uma alternativa mais automágica também existe, veja a seção de referência
            [ "/dir/on/host", "/mounted/in/container" ]
            { "localRoot": "/local/dir", "remoteRoot": "/remote/dir" }
        ]
    },
    "dap": {
        "debugpy": {
            "run": {
                // nesta seção, aplica a todas as configurações
                // isto irá corresponder/juntar com o objeto acima
                "exec": { "hostname": "foobar" },
                // se o servidor está conectado,
                // opcionalmente especificar explicitamente a porta (que é adequada parapublicação/encaminhamento)
                "port": 5678,
                // o servidor pode então também ter que aceitar mais do que o localhost
                "host": "0.0.0.0"
            }
        }
    }
}

A ideia básica do plugin de projeto é ter uma lista estruturada de arquivos pertencentes ao projeto com as seguintes propriedades:

Após o plugin de projeto ser carregado na página de configuração do Kate, abra um arquivo em um projeto e uma barra lateral aparecerá listando todos os projetos, bem como os arquivos do projeto, da seguinte forma:

Como você pode ver, o projeto atualmente ativo é “Kate”, e seu conteúdo está listado na visualização em árvore. Clicar nos arquivos na visualização em árvore abre o arquivo no editor. Além disso, um menu de contexto é fornecido com o qual você pode abrir arquivos com outros aplicativos, como um arquivo .ui com o Qt Designer.

Você pode filtrar os itens digitando parte do nome que deseja buscar na barra de busca localizada a baixo da lista.

A ideia é que você nunca precise abrir um projeto manualmente, isso nem sequer é suportado. Portanto, o que acontece quando você abre um arquivo é que o plugin de projeto verifica rapidamente a pasta e suas subpastas em busca de um arquivo .kateproject. Se encontrado, o projeto é carregado automaticamente.

Além disso, se você abrir outro documento no Kate, que pertence a outro projeto, o plugin de projeto alterna automaticamente para o projeto atual. Assim, intuitivamente, o projeto correto está sempre ativo. Claro, você também pode alternar o projeto ativo usando a caixa de combinação.

O Kate possui um plugin de busca e substituição que aparece na barra lateral inferior. Se um projeto estiver carregado, abra a barra lateral de busca e substituição e mude para o modo para buscar e substituir no projeto atual:

Com o conhecimento de todos os arquivos pertencentes a um projeto, o plugin de projeto fornece recursos simples de autocompletar baseados em CTags. Se um projeto for aberto inicialmente, o CTags analisa todos os arquivos do projeto em uma thread em segundo plano e salva as informações do CTags em /tmp. Este arquivo é então usado para preencher o popup de autocompletar no Kate.

Em contraste, sem esse recurso de autocompletar, o Kate só consegue exibir itens de autocompletar com base nas palavras do arquivo atual. Portanto, o recurso de autocompletar fornecido pelo plugin de projeto é muito mais poderoso.

Se o CTags estiver faltando, um pop-up discreto avisará sobre esse problema. Também é importante notar que o arquivo CTags em /tmp é limpo quando o Kate é encerrado, portanto, o plugin não polui nenhuma pasta com arquivos indesejados.

Outra funcionalidade é o suporte ao Plugin de compilar, para que ele seja configurado automaticamente corretamente.

Usando Projetos → Ir para (Alt+1) você pode abrir a visualização Projeto atual na parte inferior da janela do editor com quatro abas:

O menu Projetos permite alternar entre os projetos atualmente abertos. Ele é exibido pelo plugin de projeto.

Se apropriado, um comando LSP correspondente também é mencionado na explicação abaixo, cuja documentação pode então fornecer informações adicionais e interpretação, embora possa variar dependendo da linguagem específica. A expressão 'símbolo atual' refere-se ao símbolo correspondente à posição atual do cursor, conforme determinado pela linguagem e pela implementação do servidor.

O cliente LSP pode ajudá-lo a navegar até qualquer símbolo em seu projeto ou arquivo atual. Para navegar até qualquer símbolo no arquivo, use a ferramenta "Contorno de símbolo do cliente LSP" na borda direita do Kate. Esta ferramenta lista todos os símbolos encontrados pelo servidor no documento atual.

O comando de troca de cabeçalho de origem do Clangd é suportado. Para trocar o cabeçalho de origem em um projeto C ou C++, use a opção "Trocar cabeçalho de origem" no menu de contexto ou o atalho F12.

Você pode ir rapidamente para um símbolo colocando o mouse sobre ele e pressionando Ctrl + botão esquerdo do mouse.

A página de configuração do plugin permite, em sua maioria, a configuração persistente de alguns dos itens de menu acima. No entanto, há uma entrada adicional para especificar o arquivo de configuração do servidor. Este é um arquivo JSON que pode ser usado para especificar o servidor LSP a ser iniciado (e, em seguida, para se comunicar com ele via stdin/stdout). Para maior conveniência, algumas configurações padrão estão incluídas, as quais podem ser inspecionadas na página de configuração do plugin. Para auxiliar na explicação abaixo, um trecho dessa configuração é fornecido aqui:

{
    "servers": {
        "bibtex": {
            "use": "latex",
            "highlightingModeRegex": "^BibTeX$"
        },
        "c": {
            "command": ["clangd", "-log=error", "--background-index"],
            "commandDebug": ["clangd", "-log=verbose", "--background-index"],
            "url": "https://clang.llvm.org/extra/clangd/",
            "highlightingModeRegex": "^(C|ANSI C89|Objective-C)$"
        },
        "cpp": {
            "use": "c",
            "highlightingModeRegex": "^(C\\+\\+|ISO C\\+\\+|Objective-C\\+\\+)$"
        },
        "d": {
            "command": ["dls", "--stdio"],
            "url": "https://github.com/d-language-server/dls",
            "highlightingModeRegex": "^D$"
        },
        "fortran": {
            "command": ["fortls"],
            "rootIndicationFileNames": [".fortls"],
            "url": "https://github.com/hansec/fortran-language-server",
            "highlightingModeRegex": "^Fortran.*$"
        },
        "javascript": {
            "command": ["typescript-language-server", "--stdio"],
            "rootIndicationFileNames": ["package.json", "package-lock.json"],
            "url": "https://github.com/theia-ide/typescript-language-server",
            "highlightingModeRegex": "^JavaScript.*$",
            "documentLanguageId": false
        },
        "latex": {
            "command": ["texlab"],
            "url": "https://texlab.netlify.com/",
            "highlightingModeRegex": "^LaTeX$"
        },
        "go": {
            "command": ["go-langserver"],
            "commandDebug": ["go-langserver", "-trace"],
            "url": "https://github.com/sourcegraph/go-langserver",
            "highlightingModeRegex": "^Go$"
        },
        "python": {
            "command": ["python3", "-m", "pyls", "--check-parent-process"],
            "url": "https://github.com/palantir/python-language-server",
            "highlightingModeRegex": "^Python$"
        },
        "rust": {
            "command": ["rls"],
            "path": ["%{ENV:HOME}/.cargo/bin", "%{ENV:USERPROFILE}/.cargo/bin"],
            "rootIndicationFileNames": ["Cargo.lock", "Cargo.toml"],
            "url": "https://github.com/rust-lang/rls",
            "highlightingModeRegex": "^Rust$"
        },
        "ocaml": {
            "command": ["ocamlmerlin-lsp"],
            "url": "https://github.com/ocaml/merlin",
            "highlightingModeRegex": "^Objective Caml.*$"
        }
    }
}

Observe que cada "command" pode ser uma matriz ou uma string (nesse caso, ele é dividido em uma matriz). Além disso, uma entrada "global" de nível superior (ao lado de "server") também é considerada (veja mais abaixo). O binário especificado é procurado da maneira usual, por exemplo, usando PATH. Se ele estiver instalado em um local personalizado, este último pode precisar ser estendido. Ou, alternativamente, um link simbólico ou um script wrapper pode ser usado em um local que esteja dentro do PATH usual. Como ilustrado acima, também é possível especificar um "caminho" que será procurado após os locais padrão.

Todas as entradas em "command", "root" e "path" estão sujeitas à expansão de variáveis.

A expressão regular "highlightingModeRegex" é usada para mapear o modo de realce usado pelo Kate ao ID da linguagem do servidor. Se nenhuma expressão regular for fornecida, o próprio ID da linguagem será usado. Se uma entrada "documentLanguageId" for definida como falsa, nenhum ID de linguagem será fornecido ao servidor ao abrir o documento. Isso pode apresentar melhores resultados para alguns servidores que são mais precisos na determinação do tipo de documento do que fazê-lo com base em um modo do Kate.

A partir do exemplo acima, a ideia principal provavelmente está clara. Além disso, cada objeto de entrada do servidor também pode ter uma entrada "initializationOptions", que é passada para o servidor como parte do método 'initialize'. Se presente, uma entrada "settings" é passada para o servidor por meio da notificação 'workspace/didChangeConfiguration'. "completionTriggerCharacters" ou "signatureTriggerCharacters" podem ser especificados como um objeto JSON com os membros de string "exclude" e/ou "include". Estes serão usados ​​para excluir ou adicionar caracteres ao conjunto de gatilhos correspondente, conforme fornecido pelo servidor.

São aplicadas várias etapas de sobreposição/fusão;

Uma instância de servidor é usada para cada combinação (raiz, tipo de servidor). Se "root" for especificado como um caminho absoluto, ele será usado como está; caso contrário, será relativo ao “projectBase” (conforme determinado pelo plugin de projeto), se aplicável, ou, caso contrário, relativo ao diretório do documento. Se não for especificado e "rootIndicationFileNames" for uma matriz de nomes de arquivos, um diretório pai do documento atual que contenha tal arquivo será selecionado. Alternativamente, se "root" não for especificado e "rootIndicationFilePatterns" for uma matriz de padrões de arquivo, um diretório pai do documento atual que corresponda ao padrão de arquivo será selecionado. Como último recurso, o diretório inicial é selecionado como "root". Para qualquer documento, o "root" resultante determina se uma instância separada é necessária ou não. Nesse caso, o "root" é passado como rootUri/rootPath.

Em geral, recomenda-se deixar o diretório raiz sem especificação, pois não é tão importante para um servidor (embora isso possa variar). Menos instâncias de servidor são obviamente mais eficientes e também têm uma visão mais ampla do que a visão de muitas instâncias separadas.

Como mencionado acima, várias entradas estão sujeitas à expansão de variáveis. Uma aplicação adequada disso, combinada com abordagens de "script wrapper", permite a personalização para uma grande variedade de circunstâncias. Por exemplo, considere um cenário de desenvolvimento em Python que consiste em múltiplos projetos (por exemplo, repositórios Git), cada um com sua própria configuração de ambiente virtual. Usando a configuração padrão, o servidor de linguagem Python não reconhecerá o ambiente virtual. No entanto, isso pode ser corrigido com a seguinte abordagem. Primeiro, o seguinte fragmento pode ser inserido nas "Configurações do servidor do usuário" do plugin LSPClient:

{
        "servers":
        {
                "python":
                {
                        "command": ["pylsp_in_env", "%{Project:NativePath}"],
                        "root": "."
                }
        }
}

A entrada raiz acima é relativa ao diretório do projeto e garante que um servidor de linguagem separado seja iniciado para cada projeto, o que é necessário neste caso, pois cada um tem um ambiente virtual distinto.

pylsp_in_env é um pequeno "script auxiliar" que deve ser colocado em PATH com o seguinte conteúdo (a ser ajustado):

#!/bin/bash
cd $1
# executa o servidor (python-lsp-server) dentro de um virtualenv
# (i.e. com configuração de variáveis virtualenv)
# então ative o virtualenv
source XYZ
# disponibilidade do servidor ou os argumentos podem variar
exec meuservidor

Este é apenas um exemplo de um padrão mais geral que pode ser tratado de forma um pouco mais confortável, conforme descrito na seção Ambiente de execução abaixo.

{
    "servers": {
        "python": {
            "settings": {
                "pyls": {
                    "plugins": {
                        "pylint": {
                            "enable": true
                        }
                    }
                }
            }
        }
    }
}

{
    "servers": {
        "c": {
            "suppressions": {
                "rulename": ["filename", "foo"],
                "clang_pointer": ["", "clang-tidy", "clear_pointer"],
            }
        }
    }
}

{
    // isto pode ser uma array de objetos
    "exec": {
        "hostname": "foobar"
        // o comando também pode ser uma array de string
        "prefix": "podman exec -i foobarcontainer",
        "mapRemoteRoot": true,
        "pathMappings": [
            // todas as formas a seguir são possíveis
            // um alternativa mais automágica existe também, veja a seguir/abaixo
            [ "/dir/on/host", "/mounted/in/container" ]
            { "localRoot": "/local/dir", "remoteRoot": "/remote/dir" }
        ]
    },
    "lspclient": {
        "servers": {
            "python": {
                // isto irá corresponder/juntar com o objeto acima
                "exec": { "hostname": "foobar" },
                // confina este servidor a sua raiz de projeto,
                // então ele não é usado para outros projetos que podem ser abertos
                // (outros servidores podem já empregar raízes específicas, mas o python generalmente não pode)
                "root": "."
            },
            "c": {
                // as above
                "exec": { "hostname": "foobar" },
                "root": "."
            }
        }
    }
}

$ rootdir=/proc/`podman inspect --format '{{.State.Pid}}' containername`/root
# alguns links simbólicos podem causar problemas, veja também a alternativa abaixo
$ sudo mount --bind $rootdir /somewhere/containername

# consulte as respectivas páginas de manual; sftp-server é suficiente para o protocolo de operações de arquivo real (não criptografado)
$ socat 'exec:podman exec -i containername /usr/lib/openssh/sftp-server'
   'exec:sshfs -o transform_symlinks -o passive \:/ /somewhere/containername'
# ...
$ fusermount -u /somewhere/containername

O plugin Pesquisar e substituir do Kate permite-lhe pesquisar por um texto ou expressões regulares em vários arquivos de uma só vez. Você pode pesquisar em todos os arquivos abertos, todos os arquivos de uma pasta e, opcionalmente, em suas subpastas, ou no arquivo ativo. Você pode até mesmo filtrar por nome de arquivo, para por exemplo pesquisar somente em arquivos que terminam com uma extensão de arquivo específica.

O plugin de Scripts & Snippets do Kate permite adicionar e gerenciar seus próprios trechos de automação. Isso pode variar de trechos estáticos reutilizáveis ​​de texto simples, passando por modelos sofisticados com campos personalizados, automatizados e programáveis, até scripts JavaScript totalmente personalizados para modificar o conteúdo do seu documento.

Na maior parte dos casos, esses tipos de conteúdo são gerenciados exatamente da mesma maneira. Portanto, para facilitar a leitura, a discussão a seguir não diferencia entre trechos estáticos, trechos com script, snippets e scripts. Em vez disso, o termo “trecho” é usado para se referir a todos eles.

O plugin também suporta a atribuição de atalhos de teclado e a inserção de trechos de código por meio do preenchimento automático. Além disso, você pode baixar coleções de trechos de código (os chamados repositórios) da internet.

Painel de Trechos do Kate.

No painel, você deverá ver uma lista de repositórios de trechos, em conjunto com as opções para criar os seus próprios, obtê-los da Internet ou carregá-los a partir de um arquivo local. Cada repositório tem uma opção de marcação que poderá ser usada para ativá-lo ou desativá-lo. Existem também botões para editar e excluir os repositórios existentes.

Criação e edição de repositórios

Para criar um novo repositório de trechos, clique em Adicionar repositório. Você deverá ver uma caixa de diálogo que lhe pede o nome, licença e autor. Depois de escolher as opções desejadas, clique em Ok.

Interface do editor de repositório.

O editor de repositório de trechos contém as seguintes opções:

Nome

Aparece na lista de trechos na área de ferramentas e também é pesquisada quando for usada a funcionalidade de autocompletar o código.

Espaço de nomes

Prefixo usado ao utilizar o completamento de código.

Licença

Seleciona a licença para o seu repositório de trechos de código.

Autores

Insira o nome do autor ou autores do arquivo de trecho.

Tipos de arquivo

Selecione o(s) tipo(s) de arquivo(s) onde quer que o repositório de trechos se aplique. Por padrão, ele está configurado como “*”, o que se aplica a todos os arquivos. Você pode alterá-lo para algo como C++, por exemplo, ou selecionar a partir de uma lista, clicando nos itens. Poderá também indicar mais de um tipo de arquivo, pressionando Shift enquanto adiciona os tipos.

Criação e edição de trechos

Interface do Editor de Trechos.

Nome

O nome conforme mostrado na lista de trechos e na lista de completamento (obrigatório).

Tipo

Os trechos podem ser definidos como modelos de texto ou scripts. Ambos os tipos permitem o uso de funções JavaScript (veja detalhes abaixo) e, portanto, podem ser usados ​​com efeito semelhante. No entanto, como regra geral, os modelos de texto serão mais adequados se você quiser principalmente inserir texto, enquanto os scripts costumam ser uma solução mais fácil se você quiser modificar texto).

Nota

O Kate precisa ser compilada com o KTextEditor versão 6.15.0 ou superior para que este recurso esteja disponível. Para versões anteriores, somente trechos de modelo de texto podem ser usados.

Atalho

Ao pressionar este atalho, o trecho de código será inserido (ou executado) no documento atual.

Trecho (digite Modelo de texto)

O texto que seu trecho de código irá inserir no documento.

Um trecho de código pode conter campos editáveis. É possível alternar entre eles pressionando a tecla Tab. As seguintes expressões podem ser usadas no texto do modelo para criar campos:

${nome_campo} cria um campo simples e editável. Todas as ocorrências subsequentes do mesmo nome_campo criam campos que espelham o conteúdo do primeiro durante a edição.

Dica

Os nomes dos campos podem conter qualquer caractere, exceto a chave de fechamento (}).

Para inserir literalmente ${texto} em um trecho de código, escape o sinal`$ com uma barra invertida: \${texto}. O texto não será então transformado em um campo. Para inserir barras invertidas literais antes de um campo, escape cada barra invertida individual: \\${campo}, \\\\${campo}, e assim por diante.

${func(outro_campo1, outro_campo2, ...)} cria um campo que avalia uma função JavaScript a cada edição e é substituído pelo valor de retorno dessa função. Consulte a aba da Biblioteca de Scripts para mais informações.

${nome_campo=padrão} define um valor padrão para o campo. padrão é uma expressão JavaScript. Use aspas (${campo_nome="texto"}) para especificar uma string fixa como valor padrão.

Dica

Ao usar valores padrão (${campo_nome=padrão}), lembre-se de que o valor padrão é avaliado imediatamente quando o trecho é inserido no documento e não é atualizado posteriormente quando os campos são alterados.

Você pode referenciar outros campos em valores padrão se eles forem definidos antes do valor padrão que está sendo avaliado. No entanto, isso lhe dará acesso apenas ao valor padrão desses campos.

Caso nenhum valor padrão personalizado seja definido, o valor padrão será o nome do campo.

${cursor} marca a posição final do cursor após todo o resto ter sido preenchido. Inserir texto nesta posição finalizará a edição. Além disso, após pressionar Esc para finalizar a edição, o cursor saltará para esta posição.

Trecho (digite Script)

O código JavaScript a ser avaliado para este trecho

Se este código contiver uma instrução return, a string retornada será inserida na posição atual do cursor. Você também pode usar a API de scripting do Kate para modificar o documento diretamente.

Além disso, seu código pode usar funções definidas na aba da Biblioteca de scripts, que são compartilhadas entre todos os trechos em um repositório.

Biblioteca de scripts

Funções auxiliares em JavaScript para usar em seus trechos de código. Essas funções são compartilhadas entre todos os trechos de código em um repositório.

Você pode usar a API de script do Kate para obter o texto selecionado, o texto completo, o nome do arquivo e muito mais, usando os métodos apropriados dos objetos document e view. Consulte a documentação da API de script para obter mais informações.

Quando uma função é chamada em um campo de um trecho de Modelo de texto, seu valor de retorno é inserido no texto.

Nota

Usando funções em trechos de código de Modelo de texto:

• As funções podem acessar o conteúdo atualizado de todos os campos por meio do objeto fields: use fields.meu_campo ou fields["meu_campo"]. Ao usar uma função como valor padrão para um campo, somente os campos definidos no texto antes estarão disponíveis.

• Os campos podem ser passados ​​como argumentos para funções. O nome do campo pode ser usado diretamente se for um identificador JavaScript válido e nenhuma variável com esse nome existir. Caso contrário, use o objeto fields: ${func(field)}, ${func(fields.document)}, ${func(fields["meu_campo"])}

• Os campos de função (por exemplo, ${func()}) são reavaliados sempre que o conteúdo de qualquer campo é alterado. No entanto, isso não se aplica a chamadas de função com valores padrão: elas são avaliadas apenas uma vez quando o trecho de código é inserido no documento.

• Para scripts mais complexos, pode ser importante entender que primeiro, o trecho bruto é inserido no documento, e depois as funções são avaliadas. Por exemplo, se uma função recupera o texto na linha onde o trecho está sendo inserido, esse texto também conterá ${functionCall()}. Quando isso causar complicações, considere usar um trecho do tipo Script em vez disso.

• Para simplesmente envolver o texto selecionado em tags, use: <strong>${view.selectedText()}</strong>

• Lembre-se de que apenas o valor de retorno de uma função é inserido em um campo.

Descrição

Uma descrição opcional do que este trecho faz. Ela será exibida em dicas de ferramentas. A descrição pode conter formatação HTML básica.

Exemplo de uso

O exemplo a seguir invoca um script que envolve o texto selecionado ou - se não houver seleção - um texto padrão, em tags (Tipo de trecho: Script):

let range = view.hasSelection() ? view.selection() : new Range(view.cursorPosition(), view.cursorPosition());
let innertext = range.isEmpty() ? "Bold" : document.text(range);
document.removeText(range);
document.insertText(range.start, "<strong>" + innertext + "</strong>");

Selecionando a partir de uma lista de trechos.

Você pode chamar os trechos de diversas maneiras:

Se o trecho conter variáveis (além do ${cursor}), o cursor ficará automaticamente posicionado sobre a primeira ocorrência de uma variável, esperando que você digite algo. Quando terminar, você pode pressionar a tecla Tab para ir até a próxima variável, e assim por diante.

Trechos do Kate foi escrito por Joseph Wenninger.

Agradecimentos especiais ao participante Martin Gergov do Google Code-In 2011 pela escrita de grande parte desta seção.

Grava e reproduz macros de teclado (ou seja, sequências de ação de teclado).

É possível salvar macros de teclado atribuindo-lhes um nome.

As macros nomeadas são persistentes entre as sessões de Kate, sendo salvas no arquivo keyboardmacros.json na pasta de dados do usuário do Kate (geralmente ~/.local/share/kate/).

Atualmente, as macros de teclado não funcionam corretamente se alguns tipos de widgets de GUI forem usados: QMenu, QuickOpenLineEdit ou TabSwitcherTreeView, por exemplo.Não sei o motivo, mas meu primeiro palpite é que esses widgets funcionam de maneira não padronizada em relação aos eventos de teclado.

O SQL (Structured Query Language) é uma linguagem especializada para atualizar, excluir e solicitar informações de bancos de dados.

O plugin do SQL do Kate permite-lhe:

Selecione a opção Adicionar conexão do menu SQL ou na barra de ferramentas e depois selecione o controlador de banco de dados do Qt™ que você deseja usar (incluindo QSQLITE, QMYSQL3, QMYSQL, QODBC3, QODBC, QPSQL7 e QPSQL). Se você não conseguir ver o controlador desejado, será necessário instalar. Depois, clique em Próximo.

Se o banco de dados que você selecionar usar um arquivo, basta indicar a localização do banco de dados e clicar no botão Próximo. Se ele precisar conectar-se a um servidor, você precisa indicar o nome do servidor, o seu usuário e senha, e quaisquer outras informações necessárias ao controlador. Depois, clique em Próximo.

Finalmente, forneça um nome a sua conexão e clique em Concluir.

Você pode navegar pelo seu banco de dados com a ferramenta de Esquema de banco de dados no lado esquerdo. A informação apresentada varia de acordo com o controlador de banco de dados que você estiver usando.

Para atualizar esta lista, clique com o botão direito em qualquer lado da área da ferramenta e selecione a opção Atualizar. Para gerar uma pesquisa sobre qualquer item da lista, clique com o botão direito sobre um item, selecione Gerar e depois o tipo de instrução (SELECT, UPDATE, INSERT ou DELETE) no submenu que aparece.

O plugin do SQL foi criado por Marco Mentasti.

Agradecimentos especiais ao participante Ömer Faruk ORUÇ do Google Code-In 2011 pela escrita de grande parte desta seção.

Permite aos desenvolvedores visualizar símbolos (funções, macros e estruturas) a partir do código-fonte.

Ao clicar nas informações analisadas, você pode navegar facilmente pelo código.

Atualmente, os seguintes idiomas são suportados:

C/C++, Java™, Perl, PHP, Python, Ruby, XSLT, Tcl/Tk, Fortran

Lista de funcionalidades:

Você pode configurar o plugin da área da ferramenta Terminal na página da caixa de diálogo de configuração.

Estão disponíveis as seguintes opções:

Você pode usar este plugin para processar o texto selecionado usando comandos do terminal. A seleção será usada como entrada para o comando e a saída substituirá a seleção ou será copiada para a área de transferência, dependendo das preferências do usuário.

Kate Plugin “Validação XML” direitos autorais 2002 Daniel Naber (daniel.naber AT t-online.de).

Copyright da Documentação 2001,2002 Daniel Naber

Inicie o Kate e abra a janela de configuração em Configurações → Configurar o Kate.... Depois, selecione o Completamento de XML que irá aparecer na página Aplicativo → Plugins e feche a janela. Depois disso, selecione a opção do menu XML → Atribuir uma Meta-DTD.... Se o seu documento não tiver nenhum “DOCTYPE” ou se ele for desconhecido, você terá que selecionar uma meta-DTD no sistema de arquivos. Caso contrário, será carregada automaticamente a meta-DTD que corresponder ao DOCTYPE do documento atual.

Você pode agora usar o plugin enquanto digita seu texto:

Você pode testar todas as funções e limitações carregando katexmltools/testcases.xml em qtpaths --paths GenericDataLocation no Kate e seguindo as instruções.

Plugin para o Kate de “Completação de XML” copyright 2001,2002 Daniel Naber (daniel.naber AT t-online.de).

Versão para o KDE SC 4 com direitos autorais de 2010 de Tomáš Trnka

Copyright da Documentação 2001,2002 Daniel Naber

A primeira coisa que você precisa fazer é abrir uma aba do explorador de compiladores. Pressione Ctrl+Alt+I para abrir a barra de comandos e procure por "Abrir arquivo atual no explorador de compiladores" e pressione Enter. Você pode adicionar essa ação à barra de ferramentas ou atribuir um atalho a ela para facilitar o acesso.

Em seguida, você precisa configurar uma instância local do explorador de compiladores ou usar a instância pública https://godbolt.org/. Consulte https://github.com/compiler-explorer/compiler-explorer. Depois de ter uma instância, clique na caixa de combinação Opções na aba do explorador de compiladores que você abriu anteriormente e selecione Alterar URL... e, em seguida, insira a URL do servidor do explorador de compiladores.

Em seguida, você precisa de um arquivo compile_commands.json se precisar visualizar a geração de código para um arquivo em seu projeto. Caso contrário, você pode pular esta parte. Isso pode ser facilmente obtido se você estiver usando um sistema de compilação moderno como CMake ou Meson. Para o CMake, basta passar -DCMAKE_EXPORT_COMPILE_COMMANDS=ON ao invocar o cmake. O arquivo compile_commands.json deve ser colocado na raiz do seu projeto. Feche e abra novamente a aba do explorador de compiladores no Kate. Após reabrir a aba, ela deverá mostrar os comandos de compilação necessários para compilar o arquivo.