Manual do Utilizador do KDevelop
Copyright © 2002 Bernd Gehrmann
Copyright © 2002 Caleb Tennis
Copyright © 2004 Bernd Pol
Copyright © 2005 Volker Paul
É dada permissão para copiar, distribuir e/ou modificar este documento ao abrigo da GNU Free Documentation License, Versão 1.1 ou de uma versão mais recente publicada pela Free Software Foundation; sem Secções Invariantes, sem Textos de Capa Frontal, e sem Textos de Capa Traseira. Uma cópia desta licença está incluida na secção intitulada "GNU Free Documentation License".
O KDevelop é um Ambiente de Desenvolvimento Integrado para ser usado numa grande variedade de tarefas de programação.
Índice
Lista de Figuras
Lista de Tabelas
Este manual do utilizador pretende descrever o conteúdo e a utilização do Ambiente de Desenvolvimento Integrado ou IDE KDevelop 3.1.0, do ponto de vista de um utilizador. Não é um manual de programação, nem descreve o processo de desenvolvimento em detalhe. O seu único objectivo é guiá-lo a lidar com o IDE.
Aqui poderá descobrir informações sobre os seguintes tópicos:
Dá-lhe uma introdução rápida ao uso deste IDE, introduzindo os passos básicos para trabalhar num projecto.
Extende a vista guiada no capítulo anterior, dando uma visão geral sobre o que está incluído dentro do KDevelop e põe-o perante a aparência e comportamento deste IDE.
Mostra como poderá adequar o IDE às suas necessidades.
Descreve as bases de como configurar um projecto novo no KDevelop, usando o Application Wizard incorporado.
Tudo o que necessita para escrever os ficheiros de código: usar o editor, procurar texto localmente e a nível do projecto, até à integração de ficheiros e classes novos no projecto.
Demonstra várias ferramentas para olhar para a estrutura do seu projecto e como aceder aos ficheiros com que deseja trabalhar.
Descreve uma das ferramentas mais poderosas do KDevelop, que lhe permite navegar pelas dependências de classes e lhe permite criar e aceder facilmente às classes e métodos que necessita.
Mostra como aceder à rica documentação que o KDevelop oferece e diz-lhe como criar a documentação para o seu projecto, consistindo numa documentação de API poderosa e clara, que lhe dá uma ideia geral de todo o código do seu projecto, assim como a documentação do utilizador baseada em DocBook.
Lida com a criação e gestão do seu projecto; descreve as bases do 'autoconf' e do 'automake', para além de como configurar Makefiles personalizadas e como usar as opções do compilador ou do 'make' para ajustar a sua aplicação de acordo com as suas necessidades.
Olha para as formas de manter várias configurações de compilação, para compilar de forma cruzada para diversas plataformas ou para fazer um sistema embebido, usando a biblioteca Qt/embedded.
Descreve como usar a interface incorporada do depurador gdb, para que possa descobrir os erros sem sair do KDevelop.
Diz-lhe como é que pode manter o seu projecto com o sistema de controlo de versões CVS; uma prioridade, especialmente se vários programadores trabalharem no mesmo projecto.
Alguma informação usada normalmente foi colocada no apêndice. Entre outras, esta consiste de:
Diz-lhe como obter o KDevelop e como o pôr a funcionar.
Uma referência rápida aos comandos e acções mais usados. É também um guia rápido para resolver os problemas comuns ao lidar com o KDevelop.
Uma visão histórica da programação no sistema UNIX®, as ferramentas principais necessárias e porque é que necessita de um IDE.
Indica os ficheiros que o KDevelop usa para gravar a sua informação interna. Isto é particularmente útil, no caso de algo correr mal com a sua configuração.
Indica as ferramentas em 'plugins' que poderá usar para adequar as capacidades do KDevelop às suas necessidades.
Mostra alguns modos de interface do utilizador.
Como obter informações, comunicar erros, etc.
Mostra o histórico desta documentação.
Bibliografia
Agora que você instalou o seu IDE KDevelop, como é que o vai utilizar bem? Dado que esta é uma aplicação complexa, a curva de aprendizagem pode ser um pouco inclinada, principalmente se não estiver já habituado a este tipo de ambientes de desenvolvimento integrados.
Iremos tentar suavizar esta curva de aprendizagem um pouco, vendo os passos de criação de uma aplicação do KDE em C++. Como tal, iremos dar uma vista de olhos (focada) em:
| O que é visto à superfície do IDE do KDevelop. |
| Como criar um novo projecto. |
Quando você inicia o KDevelop pela primeira vez, irá obter uma visualização semelhante à seguinte:
A disposição inicial do KDevelop
Área de Trabalho e Páginas das Janelas de Ferramentas. Neste caso inicial, o KDevelop usa o modo denominado por modo de interface de utilizador IDEAl. Um espaço de trabalho com o tamanho máximo possível fica rodeado pela esquerda, baixo e direita por uma série de botões que actuam de forma semelhante às páginas numa área dividida em páginas. Se carregar numa destas páginas, aparece então uma janela de ferramentas que lhe permitirá trabalhar numa tarefa específica.
Menu e Barras de Ferramentas. No topo, existe o menu normal, seguido de várias filas de barras de ferramentas, estando algumas vazias inicialmente. Elas serão preenchidas, logo que exista um projecto aberto para o trabalho de facto.
Barra de Estado. Finalmente, existe uma barra de estado no fundo da janela que mostra algumas informações curtas sobre as várias tarefas.
Para além da , que oferece algumas respostas a perguntas específicas, a barra de estado e dois tipos de dicas de ferramentas oferecem algumas informações rápidas.
O Que Este Item do Menu Faz? Quando você coloca o cursor do rato sobre um item do menu, existe alguma informação curta que será apresentada na barra de estado. Embora isto, em alguns casos, repita apenas o nome da selecção, noutros poderá oferecer algumas informações adicionais sobre o intuito do comando do menu.
Qual é o Nome Deste Item? Em vários itens, irá aparecer uma dica com um nome curto da função, quando você colocar o cursor por cima dela durante alguns segundos. Isto é útil para uma orientação rápida na barra de ferramentas ou nas páginas de ferramentas no modo IDEAl, quando o IDE tiver sido configurado para mostrar os ícones apenas nestes botões.
O Que é Que Este Item Faz? Está disponível mais alguma informação, através da ajuda de dicas de ferramentas para muitos itens do IDE. Seleccione a opção -> ou carregue em Shift-F1, podendo então com o cursor do ponto de interrogação seleccionar o item que deseja conhecer. Poderá também abrir qualquer menu desta forma e carregar num item específico do menu (tanto os activos como os desactivados, a cinzento) para ver se está disponível mais alguma informação.
Existem dez menus seleccionáveis na barra de menu. A maioria deles fica preenchida por completo, logo que um projecto tenha sido aberto para trabalho, enquanto outros necessitam pelo menos de um documento aberto. Em resumo, eles irão permitir os seguintes tipos de acção.
Isto é apenas uma introdução. Para uma listagem mais detalhada dos menus e dos seus itens, veja a Referência de Comandos.
Acções Normais. Este menu é bastante comum. Permite criar, abrir, gravar, imprimir e fechar ficheiros de documentos, assim como sair da aplicação KDevelop, como é normal acontecer.
Reverter as Alterações. Para além disso, permite reverter as alterações, carregando de novo o conteúdo do ficheiro de uma forma ordeira.
Este menu só é útil se estiver algum documento aberto.
Acções Normais. Oferece as acções normais para desfazer/refazer e para cortar/copiar/colar. Para além disso, permite seleccionar blocos de texto de várias formas.
Procurar e Substituir. Existe uma funcionalidade de procura muito poderosa disponível no menu . Para além das acções normais de procura e substituição que se limitam ao documento actual, você poderá também conduzir uma procura e substituição a nível global. Isto permite trabalhar em todos os ficheiros do projecto de uma vez.
Edição de Texto Avançada. Existem possibilidades para formatar de novo o documento actual e para completar automaticamente alguns textos escritos parcialmente de várias formas.
Tal como no menu , este menu só é útil se estiver algum projecto aberto de momento. Neste caso, ficarão disponíveis as seguintes acções (entre outras):
Histórico de Navegação. Avance e recue pelos documentos etc. que tenha visitado.
Registo de Erros. Navegue pelas linhas de código dos erros que foram encontrados no último processo de compilação/construção.
Gerir a Janela de Ferramentas. Seleccione ou esconda as janelas de ferramentas ou as áreas acopláveis de ferramentas.
Acções Relacionadas com o Editor. Alguns itens do menu controlam a aparência e comportamento do editor que você usa. No caso do componente do Kate (Editor de Texto Avançado Incorporado), ficarão disponíveis os seguintes controlos:
Controlar o comportamento de mudança de linha na janela do documento.
Mostrar ou esconder vários dados nas janelas de documentos: os números de linhas, ícones e, adicionalmente, as marcações de favoritos na barra de posicionamento.
Controlar a visibilidade das secções dobradas (temporariamente escondidas) num texto de código.
Todo o trabalho do KDevelop baseia-se em projectos que coleccionam basicamente os ficheiros de código, os ficheiros de gestão das compilações e outras informações numa pasta de projecto. Neste menu, poderá controlar o projecto a usar, as propriedades que tem e algumas acções de gestão. Em particular:
Abrir um Projecto. Permite criar projectos novos, abrir projectos existentes e importar os projectos de outros ambientes.
Opções do Projecto. Permite definir um conjunto completo de propriedades diferentes do projecto.
Gestão de Classes. Adiciona novas classes ao projecto e atravessa a árvore de heranças de uma classe.
Distribuir o Projecto. Ajuda a distribuir os pacotes de distribuição do projecto.
Este menu tem a ver com tudo o que respeita à compilação e documentação do projecto. Como tal, só é usado quando está um projecto aberto de momento. Neste caso, oferece as seguintes acções:
Compilar, Editar as Ligações, Executar. Permite compilar e gerar o executável do projecto completo ou de partes dele, assim como executar a aplicação a partir do IDE.
Preparar as Operações de Compilação. Isto depende, de facto, do sistema de compilações que usa para este projecto. No caso dos projectos do 'automake', ele permite correr o Makefile.cvs e o configure por si só. Existe também a possibilidade de remover os ficheiros traduzidos do projecto em várias etapas de intensidade.
Instalar a Aplicação. Permite instalar a aplicação, tanto nas pastas locais como nas pastas do sistema que só estão acessíveis para o utilizador 'root'.
Documentação da API. Compila ou remove a documentação da API baseada no 'doxygen' do projecto, tal como está definido nas opções do projecto.
Ainda que este menu seja preenchido quando está activo um projecto, só é útil de facto se o projecto actual tiver sido compilado previamente com a informação de depuração (o que é definido basicamente na opção ->). Estão disponíveis as seguintes acções neste caso:
Acções Normais do Depurador. A primeira secção na opção oferece uma interface gráfica para o depurador simbólico GDB da GNU. Permite iniciar e parar a sua aplicação no depurador e percorrê-lo de várias formas.
Pontos de Paragem. O KDevelop oferece várias formas de definir pontos de paragem no código da sua aplicação. Uma delas é através da opção do menu .
Depuração Avançada. Outras opções do menu permitem uma análise mais sofisticada do programa. Use o Shift-F1 para obter mais informações sobre o seu objectivo.
Este menu é relativamente comum. Poderá seleccionar qualquer janela de documento aberta, assim como fechar aqui uma ou mais janelas. Poderá até seleccionar um conjunto de janelas de documentos para serem fechadas de uma vez.
O KDevelop é altamente personalizado. Poderá seleccionar um editor favorito para os seus documentos, assim como oferecer ferramentas externas e incorporadas para extender as capacidades básicas do IDE. O menu reflecte a maior parte desta configuração.
Edição Avançada. O conjunto superior dos itens do menu será oferecido pelo 'plugin' do editor em uso. Poderá seleccionar o seu editor favorito coma opção ->+Editor. Logo que tenha sido seleccionado um ficheiro de documento editável, a parte superior do menu irá oferecer comandos de edição avançados, específicos para a componente do editor em uso.
Tratamento da Parte Web. No caso de a janela do documento activa conter uma página em HTML (isto é mostrada numa selecção de Documentação), o menu irá mostrar itens de menu adicionais que oferecem várias formas de lidar com as páginas Web.
Outras Ferramentas. Normalmente existirão um conjunto de outros itens, de acordo com as ferramentas disponíveis de momento. Use o Shift-F1 para obter mais informações sobre os seus fins.
Este menu permite-lhe mostrar e esconder o menu, as barras de ferramentas e a barra de estado. Do mesmo modo, também poderá configurar os atalhos, barras de ferramentas, notificações, o editor e o comportamento geral do KDevelop.
Aqui poderá abrir este manual do KDevelop, ler a documentação do Qt, abrir as páginas do manual (no formato tradicional de manuais do UNIX) e as páginas do 'info' (o formato de manual da GNU), comunicar erros e obter algumas informações sobre a versão actual do seu KDevelop e os seus autores.
Isto serve para lhe mostrar quão simples é pôr o KDevelop a criar um programa executável para si.
O Application Wizard poderá criar rapidamente um projecto para si, a partir de uma lista de modelos de projecto predefinidos. Tudo o que tem a fazer é seleccionar o tipo de projecto que deseja, como nomeá-lo e onde colocá-lo.
Seleccione Projecto - Novo Projecto. A janela para Criar um Novo Projecto irá aparecer. Assumir-se-á que deseja criar um projecto normal para o KDE. Como tal, seleccione o tipo: C++ - KDE - Aplicação Simples do KDE. Indique o nome, p.ex. 'olamundo'. A localização por omissão será '/home/utilizador/olamundo'. Se terminou a configuração nesta janela, carregue em Seguinte. Na próxima janela poderá definir algumas opções que trazem já alguns valores predefinidos úteis. Carregue em Seguinte. Finalmente, será apresentado o modelo dos ficheiros .h e dos .cpp. Mais uma vez, poderá deixá-los com os valores predefinidos e carregar em Terminar. Irá ver então a mensagem a avisar que o seu programa foi criado.
Para executar o seu programa, seleccione a opção Construir - Executar o Programa. Irá receber uma mensagem a avisar que o 'automake' & amigos necessitam de correr primeiro. Carregue nesse caso em OK. O seu programa será então compilado e executado, e uma janela do seu novo programa irá aparecer, a dizer "Olá Mundo". Poderá agora editar o seu programa e adicionar mais algumas funcionalidades úteis.
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
O KDevelop integra um conjunto de ferramentas, programas e modelos numa interface de utilizador comum. Basicamente, consiste em
vários modos de interface de utilizador com os quais você poderá seleccionar a aparência e comportamento do espaço de trabalho,
um Application Wizard que o ajuda a configurar um novo projecto,
vários sistemas de gestão de projectos que o ajudam a compilar e a gerir o seu projecto,
algumas ferramentas de edição para trabalhar nos textos do seu programa
vários navegadores de ficheiros que lhe oferecem várias vistas sobre o seu sistema de ficheiros,
vários navegadores de classes para o ajudarem a gerir as classes e as suas relações entre si no seu projecto de programação orientada por objectos,
uma interface para o depurador para procurar e remover os erros do programa dentro do KDevelop, e
várias ferramentas em 'plugins', ou seja, módulos extensíveis que podem ser carregados durante a execução e a pedido. Isto permite-lhe activar apenas as funcionalidades que você realmente necessita.
um conjunto de outras ferramentas auxiliares de diagnóstico, documentação e optimização.
De facto existem três aplicações baseadas no KDevelop:
O IDE do KDevelop — este é o local onde você normalmente irá trabalhar.
O navegador de documentação do Assistente do KDevelop autónomo — isola todas as funcionalidades poderosas de documentação do IDE KDevelop numa ferramenta separada. Isto pode ser útil quando desejar procurar por alguma documentação de programação mas não queira iniciar o IDE por completo.
O Desenhador do KDevelop — aumenta o Qt™ User Interface Designer, adicionando os elementos específicos do KDE e integra-se bem no IDE KDevelop.
O KDevelop oferece aos programadores quatro modos de interface do utilizador (carregue no nome do modo para ver um exemplo):
Esta é uma nova aproximação de interfaces de utilizador que optimiza tanto o espaço de trabalho como a actuação intuitiva sobre as ferramentas.
Todas as janelas de ferramentas estão acopladas numa disposição em páginas à volta da área da janela principal. Elas agrupam-se à esquerda, em baixo e à direita, de acordo com os serviços fornecidos.
As janelas de edição e de navegação estarão empilhadas numa grande janela de páginas a meio da área da janela principal.
Todas as janelas de ferramentas estão inicialmente acopladas à janela principal.
As janelas de edição e de navegação irão existir como janelas de topo dentro de uma área de visualização da janela principal.
Todas as janelas de ferramentas estão inicialmente acopladas à janela principal.
As janelas de edição e de navegação irão estar empilhadas numa janela com várias páginas separadas.
Todas as janelas de edição, navegação e de ferramentas serão janelas de topo directamente no ecrã.
A janela principal só irá conter o menu, as barras de ferramentas e a barra de estado.
Para mudar o modo da interface do utilizador, seleccione a -> no menu. A janela para Configurar o KDevelop irá aparecer, onde então terá de seleccionar Interface do Utilizador no campo do lado esquerdo. Isto levá-lo-á à página de configuração mostrada em baixo.
Seleccione um modo de interface de utilizador
(As versões mais antigas do KDevelop oferecem apenas a secção de selecção do modo de topo).
Na secção do Modo Principal de Interface do Utilizador, seleccione a opção exclusiva do modo de interface de utilizador com que deseja trabalhar.
Dependendo do modo de interface de utilizador que seleccionou, as outras secções de configuração ficarão disponíveis, nas quais poderá ajustar mais detalhes da aparência e comportamento às suas preferências. Veja o capítulo sobre como Seleccionar a Interface do Utilizador para mais detalhes.
Não se esqueça de reiniciar o KDevelop para que as suas selecções façam efeito.
Para maximizar o espaço, existe um modo de janelas de ecrã completo que expande a área da janela principal até aos extremos do ecrã. O espaço adicional poderá ser reclamado de volta se esconder a barra de menu. E, claro, você poderá esconder qualquer barra de ferramentas como é normal nas aplicações do KDE.
Para mudar de ou para o modo de ecrã completo seleccione -> no menu ou carregue em Ctrl-Shift-F. Existe também um ícone Modo de Ecrã Completo na Barra de Navegação.
Para esconder o menu seleccione -> nas opções de menu ou carregue em Ctrl-M. Você poderá também incluir um Mostrar o Menu numa barra de ferramentas adequada, p.ex., na Barra de Navegação para esse fim. Para voltar a mostrar o menu você precisa de carregar em Ctrl-M ou de usar o ícone Mostrar o Menu, se estiver disponível.
(... ainda não escrito ...)
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
Globalmente, um projecto basear-se-á num sistema de gestão de projecto qualquer. O KDevelop oferece quatro sistemas de gestão de projectos que o programador poderá seleccionar ao criar um novo projecto.
Os projectos do Automake usam as ferramentas de desenvolvimento normais da GNU.
Os projectos do QMake usam o gestor de projectos QMake da Trolltech.
Os projectos de ANT usam o gestor de projectos ANT do Apache para a programação em Java™.
Os projectos personalizados necessitam que você faça a gestão das suas próprias Makefiles.
Os projectos criados com o Automake Manager do KDevelop tornam bastante simples a utilização das ferramentas normais da GNU para os programadores. Eles possibilitam
uma melhor forma de gerar Makefiles e
uma forma segura e boa de se adaptar facilmente entre vários sistemas de comandos configure gerados pelo Automake.
Para os programadores que gostam da flexibilidade e comportamento do sistema QMake do Qt™, o KDevelop oferece a possibilidade de lidar com os projectos baseados em QMake (os ficheiros .pro) na sua interface gráfica.
Para mais informações sobre o gestor de projectos QMake veja o “Guia de Utilizador do qmake”, que deverá estar incluído na sua distribuição, ou dê uma vista de olhos na página de Documentação da TROLLTECH onde você poderá encontrar a documentação do QMake para a sua versão da “Plataforma de Desenvolvimento de Aplicações Gráficas em C++ Qt”.
Os programadores em Java™ poderão querer usar o gestor de projectos ANT do projecto Apache para os seus projectos. Para configurar um novo projecto de ANT no KDevelop seleccione ->->->->.
Para mais informações veja a página do Projecto Ant do Apache.
Se você preferir manter as suas próprias Makefiles para o seu projecto, você poderá usar a opção de projectos personalizados do KDevelop. Isto poderá ser adequado para os projectos estruturados de forma anormal ou se deseja ter um controlo absoluto no processo do make.
Todavia, se você não precisa de facto da flexibilidade extra e do controlo do gestor de projectos personalizados, você deverá pensar no Autoproject ou num dos outros gestores de projectos, porque facilitam consideravelmente os processos de compilação e distribuição do programa.
A distribuição das suas aplicações não necessita que o utilizador final tenha nada de diferente instalado, a não ser
um compilador apropriado,
um editor de ligações, e
as bibliotecas de desenvolvimento apropriadas,
o que, pelo menos para as aplicações em C++, é normalmente o caso. Mas você pode também distribuir os pacotes binários da sua aplicação. De qualquer forma, o utilizador final do seu produto não precisa do KDevelop instalado.
Para fornecer o seu código, aconselhamo-o a incluir também o ficheiro do projecto do KDevelop. Isto torna muito simples para os outros programadores — se usarem também o KDevelop — poder trabalhar com o seu código.
Para os projectos onde os vários programadores estão envolvidos, talvez trabalhando em sítios diferentes, poderá ser este o caso de qualquer forma. Por isso, você poderá garantir a consistência das Makefiles para não ter problemas.
Especialmente nas aplicações multilingues, os tradutores não irão lidar de facto com o código-fonte, excepto nos casos que necessitem de correcções para permitir o suporte de traduções.
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
O KDevelop é um IDE muito poderoso e flexível que oferece muitas formas de o ajustar às suas necessidades. Para iniciar a configuração, seleccione ->. Isto fará com que a janela de configuração se abra, consistindo numa janela de selecção à esquerda e na janela de configuração à direita, cujo conteúdo irá variar de acordo com o item de configuração que seleccionou.
Seleccionar um item de configuração
Iremos discutir estas configurações por uma ordem diferente, dividindo nos tópicos principais da Configuração Geral, Configurar a Documentação e Configuração Avançada, o que causa uma leitura mais intuitiva.
Se quiser ver directamente um certo item de configuração, use uma das seguintes referências.
| Geral |
| 'Plugins' |
| Formatador de Código |
| Assistente de Novo Ficheiro |
| Interface do Utilizador |
| Editor |
| Abreviaturas |
| O Menu Ferramentas |
| Ferramentas Externas |
| Documentação |
| Excertos de Código |
| Selector de Ficheiros |
A configuração geral diz respeito às tarefas mais comuns de ajuste do KDevelop e consistem em:
A janela de configuração Geral permite-lhe definir algum comportamento básico do KDevelop que irá mudar pouco no dia-a-dia. Isto respeita a:
definir uma directoria-mãe por omissão, que o KDevelop deverá usar para os projectos novos.
decidir se quer que o KDevelop carregue automaticamente o projecto onde estava a trabalhar da última vez.
a Janela de Mensagens de Resultado que o KDevelop usa para apresentar isto é o progresso da compilação e
a Janela de Resultado da Aplicação que irá mostrar as mensagens de erro e de estado respeitantes a uma aplicação em execução.
se as linhas compridas serão repartidas e
se as mensagens de entrada e saída das directorias geradas pelo Make serão apresentadas.
O nível de detalhe das mensagens correspondentes ao processo de compilação mostrado na janela de Mensagens.
A janela de configuração geral
Assinale esta opção se deseja continuar a trabalhar no último projecto em que trabalhou. Isto fará com que o KDevelop carregue automaticamente este projecto no arranque. Será normalmente mostrado no estado em que você deixou o trabalho, para que possa continuar da mesma forma.
Por omissão, o KDevelop usa uma directoria de base comum para todos os projectos novos. Indique a localização absoluta desta directoria comum no campo de texto respectivo ou seleccione-a na sua estrutura de directorias. O KDevelop irá colocar os projectos novos aqui como sub-pastas desta.
Você poderá, obviamente, mudar a localização de um projecto novo na altura em que o configurar no Application Wizard.
Para seleccionar um tipo de letra adequado para a Janela de Mensagens, carregue no botão do Tipo de Letra da Janela que mostra o tipo de letra actual (na imagem acima, diz “Luxi Sans”). Irá então aparecer a janela normal do KDE para Seleccionar o Tipo de Letra, na qual você poderá seleccionar o tipo de letra a ser usado.
No primeiro arranque, o KDevelop inicializa esta configuração do tipo de letra com base no tipo de letra normal que o seu utilizador do KDE tem configurada. Esta configuração é fixa, por isso, se você alterar as ->-> no Centro de Controlo, isto irá afectar esta selecção de tipo de letra do KDevelop. Você terá de seleccionar de novo explicitamente o tipo de letra da Janela de Mensagens.
Por omissão, o KDevelop irá repartir as linhas compridas na janela de Mensagens, de modo que a informação valiosa não será ignorada com facilidade. Nalguns casos, isto irá gerar listas de mensagens grandes e confusas. Desligue a opção se não quiser que as linhas sejam repartidas.
Existe uma forma alternativa de alterar a mudança de linha. Basta carregar com o botão do rato na Janela de Mensagens e assinalar ou desligar o item do menu que irá aparecer.
A ferramenta Make normalmente irá mostrar linhas do tipo “Entering directory” (A entrar na directoria), ou “Leaving directory” (A sair da directoria), quando ele muda de directoria de trabalho. dado que isto enche a lista de mensagens na janela de Mensagens, o KDevelop suprime estas mensagens por omissão. Assinale a opção se quiser saber que directorias o Make processou.
As alterações desta opção farão efeito apenas no processamento das mensagens novas. As mensagens antigas de navegação nas directorias ficarão à mesma visíveis quando você desligar esta funcionalidade.
O KDevelop faz um pré-processamento que a janela das Mensagens recebe durante os processos de compilação, de modo a filtrar a informação supérflua. Você poderá controlar o nível de detalhe que o KDevelop irá mostrar com as opções exclusivas deste campo.
Mostra apenas os avisos, erros e os ficheiros que estão a ser compilados.
Suprime todas as opções do compilador e forma o resultado para ser mais legível.
Mostra todas as mensagens sem modificações.
Existe uma forma alternativa de mudar o detalhe do resultado do compilador. Basta carregar com o botão do rato na janela de Mensagens e seleccione o nível de detalhe adequado no menu de contexto.
A janela do Resultado da Aplicação é usada par amostrar as mensagens de erro e de estado das aplicações que são executadas dentro do KDevelop. Estas são informações que a aplicação manda normalmente para a consola quando é executada autonomamente. Por isso, não precisa de sair do IDE ao testar a aplicação em que está a trabalhar.
Para seleccionar um tipo de letra adequado para a Janela do Resultado da Aplicação, carregue no botão do Tipo de Letra da Janela, que mostra o tipo de letra seleccionado de momento (ele diz “Luxi Sans” na imagem acima). A janela normal do KDE para Seleccionar o Tipo de Letra irá aparecer, no qual poderá seleccionar o tipo de letra a usar.
No primeiro arranque, o KDevelop inicializa esta configuração do tipo de letra com base no tipo de letra normal que o seu utilizador do KDE tem configurada. Esta configuração é fixa, por isso, se você alterar as ->-> no Centro de Controlo, isto irá afectar esta selecção de tipo de letra do KDevelop. Você terá de seleccionar de novo explicitamente o tipo de letra da Janela de Resultados da Aplicação.
Como já foi dito nos Modos Disponíveis de Interface do Utilizador, existem quatro formas diferentes no KDevelop para configurar o espaço de trabalho, sendo eles:
Para mudar o modo da interface do utilizador, seleccione a -> no menu. A janela para Configurar o KDevelop irá aparecer, onde então terá de seleccionar Interface do Utilizador no campo do lado esquerdo. Isto levá-lo-á à página de configuração mostrada à direita.
Seleccione um modo de interface de utilizador
Seleccione a opção exclusiva para o modo de interface do utilizador que deseja utilizar e carregue em .
Não se esqueça de reiniciar o KDevelop para que estas selecções façam efeito.
Você você tiver seleccionado o modo IDEAl ou o modo de páginas, irão ficar disponíveis mais duas secções: a Usar Tabulações e Usar o Fechar ao Passar. Estas permitem-lhe configurar em que circunstâncias é que os separadores das páginas serão mostrados no topo das janelas dos documentos e se você poderá fechar o documento ao carregar no ícone da página.
Apenas no modo de janelas IDEAl, existirá ainda mais uma secção de configuração, a Disposição das Páginas, a qual permite de facto seleccionar entre vários tamanhos dos separadores de páginas que rodeiam a área de trabalho principal neste modo.
No modo IDEAl e no modo de páginas existirão páginas com nomes no topo dos diferentes documentos por omissão, de modo que possa seleccionar facilmente vários documentos diferentes ao carregar com o botão do rato. Se preferir ter mais espaço para as janelas dos documentos na área de trabalho principal do KDevelop, você poderá mudar para outro comportamento na secção de configuração Usa Tabulações.
Este é o modo por omissão — mostra uma página cujo separador tem um ícone e o nome do documento na área de trabalho principal do KDevelop.
Não mostra o documento numa página, quando só existe de facto um documento aberto. Se existir mais do que um, todavia, o KDevelop irá mostrar a barra de páginas normalmente como aparece na selecção Sempre. Você poderá seleccionar este modo se trabalhar num único documento na maior parte do tempo, dado que oferece um pouco mais de espaço vertical.
Nunca mostra nenhuma página de selecção de documentos. Você poderá preferir este modo se você usa raramente o rato para mudar de documentos. Fornece mais espaço vertical para todas as janelas de documentos. Para seleccionar outra janela de documento ou fechar alguma, use o menu do KDevelop.
Quando você tiver configurado o KDevelop para mostrar a barra de páginas dos documentos, seja sempre ou apenas quando é mostrado mais do que um documento na área de trabalho, você poderá adicionar mais funcionalidades aos separadores das páginas para além da sua capacidade de selecção de documentos. Use a secção de configuração Usar o Fecho ao Passar para tal.
Este é o comportamento normal. Não é adicionada mais nenhuma funcionalidade extra às páginas. Elas poderão ser usadas apenas para seleccionar as janelas dos documentos com o botão do rato.
Quando você tiver seleccionado esta opção exclusiva, o KDevelop irá permitir fechar uma janela de um documento com um 'click' do botão do rato. Use o rato para apontar para o pequeno ícone do lado esquerdo do separador de páginas. Ele irá mudar para um símbolo de fecho. Agora, carregue com o botão do rato neste símbolo alterado para que o KDevelop feche a janela do documento correspondente.
Depois de seleccionar esta opção, o KDevelop permitirá fechar uma janela de um documento como é mostrado no caso do Sim descrito em cima. O ícone não irá mudar instantaneamente, contudo, havendo neste caso um pequeno atraso antes de o ícone aparecer.
A secção de configuração Disposição das Páginas estará disponível apenas no modo IDEAl. Use estes botões para configurar a aparência das páginas que rodeiam a área de trabalho principal neste modo.
Cada página irá mostrar apenas um ícone. Se a ferramenta associada estiver visível, a página irá abrir e aparecerá um texto descritivo no seu separador. Você poderá usar este modo se trabalhar num monitor com uma resolução limitada.
Os ícones não são muito descritivos, de qualquer forma. Se você quiser saber que ferramenta está associada a uma dada página, coloque o cursor do rato sobre ela e espere um segundo. Irá então aparecer uma dica com o nome da ferramenta.
Este é o modo de apresentação das ferramentas por omissão. Cada página mostra o nome da sua ferramenta associada.
Se as ferramentas normais parecem demasiado planas para si e você está a trabalhar num monitor de alta resolução, você poderá seleccionar esta opção. Fará com que o nome da ferramenta associada seja mostrado em cada página, para além de um ícone à esquerda dele, tornando as páginas mais fáceis de compreender. Veja a imagem das Páginas de Ferramentas Fechadas em baixo para um exemplo.
Se você seleccionou o modo IDEAl, com as páginas a mostrarem os textos (com ou sem os ícones a acompanhar), você não precisa de se preocupar em estar escondido por detrás de uma janela de ferramentas. Se uma das janelas das ferramentas ocupar mais espaço do que está disponível para mostrar todas as páginas (verticais), elas fechar-se-ão como é mostrado nesta figura:
A janela de ferramentas activa deverá ser mostrada fixa (sem sobreposição), partilhando a área de trabalho com outras janelas, para permitir esse fecho de páginas. Carregue no pequeno quadrado no contorno da janela para conseguir isto, tal como é mostrado no exemplo.
O KDevelop permite-lhe seleccionar a sua ferramenta de edição de texto favorita. Marque o item Editor da árvore de selecção da lado esquerdo da janela Configurar o KDevelop. Será mostrada a seguinte janela à direita.
Seleccionar um editor
Para seleccionar um novo editor, carregue na seta da lista. Dependendo das interfaces dos componentes de edição com que a sua versão do KDE foi compilada, irá aparecer uma lista dos editores que poderá seleccionar (veja a nota Importante em baixo para tal). Carregue no editor da sua preferência e carregue em OK. De momento, existem três possibilidades:
Esta é a componente de edição normal do KDE, a Kate.
Esta oferece a aparência e comportamento do seu editor de base do Linux® que é o vi.
Você precisa de ter uma aplicação Vim adequada instalada. Dê uma vista de olhos no KVim para mais informações.
Para além disso, você precisa de configurar o componente KParts do Vim no Centro de Controlo do KDE (->) antes de o poder usar.
Este é o editor que o Qt™ oferece no seu componente Designer.
Estas interfaces de edição estão completamente integradas no conceito de IDE do KDevelop. Em particular, a possibilidade de saltar para linha de código-fonte responsável por um dado erro, se carregar no texto da sua mensagem na janela de Mensagens é oferecida por elas.
A mudança de editor não irá afectar os ficheiros já abertos. Existem duas possibilidades de prosseguir. Ou fecha todas as janelas de texto abertas e reabre-as uma a uma ou então simplesmente fecha o projecto inteiro e abre-o outra vez. As janelas serão então automaticamente abertas com a nova interface de edição de texto.
O KDevelop formata automaticamente o texto de código de um estilo predefinido. Este estilo é altamente configurável.
A funcionalidade de nova formatação de código está disponível apenas para o C, o C++ e o Java™, de momento. Em especial, você não a poderá usar para as linguagens de 'scripting' como o PHP. Isto é porque o KDevelop usa a aplicação astyle para implementar esta funcionalidade.
Para configurar um estilo de formatação específico, seleccione -> no menu. A janela para Personalizar o KDevelop irá aparecer, onde terá de seleccionar o Formatador de Código na árvore da esquerda. Isto irá mostrar uma série de três páginas de configuração à direita, nomeadamente uma Configuração Geral da Formatação, uma Configuração do Estilo de Indentação e Outra Configuração de Formatação.
Todas as mudanças de estilo aplicam-se apenas ao ficheiro acabado de introduzir. Se você quiser mudar o estilo de formatação de um texto de código já existente, você terá de usar explicitamente o comando ->.
A consequência exacta destas definições de formatação do estilo dependem do editor que usa. De momento, a maioria das configurações são adequadas para a componente de edição do Kate (o “Editor de Texto Avançado Incorporado”). Outros editores (isto é o editor do Qt) poderão basear-se apenas na sua configuração própria. Você terá de experimentar neste caso para saber os efeitos exactos da configuração de estilo oferecida aqui.
Poderão existir incompatibilidades entre a configuração do estilo aqui oferecida e o editor que usa, até mesmo nos casos extremos, em que poderá corromper os seus ficheiros. Certifique-se que tem uma cópia de segurança dos seus ficheiros de código antes de tentar usar a sua configuração com um editor incompatível com o KDE.
A página Geral da janela do Formatador de Código permite-lhe seleccionar um de cinco estilos predefinidos de formatação de código.
Configuração geral do estilo de formatação de código
Será mostrado um exemplo de código formatado no campo à direita. Se nenhum dos estilos predefinidos é do seu agrado, você poderá carregar na opção de topo Definido pelo utilizador e definir as suas preferências de formatação de código nas outras duas páginas que ficarão disponíveis.
De momento, só os estilos de formatação predefinidos é que serão demonstrados com um texto de exemplo. Se você decidir definir o seu próprio estilo, não será apresentado nenhum texto de exemplo. Você terá de experimentar no próprio texto do código actual para ajustar a configuração ao seu gosto.
Uma indentação adequada é a forma principal de melhorar a legibilidade do texto do código. Se você seleccionou a página Indentação na janela do Formatador do Código, ser-lhe-á apresentada uma série de opções de formatação, agrupadas em três opções, como as que aparecem a seguir.
Configuração do estilo da indentação do código
As escolhas de formato predefinidas fazem com que o código lembre o estilo de formatação da ANSI:
namespace espacoXpto
{
int Xpto()
{
if (eOla)
{
ola();
return 1;
}
else
return 0;
}
}
As opções exclusivas agrupadas no grupo Preenchimento, definem como é que a indentação do código será feita.
Isto fará com que o editor insira um carácter de tabulação por cada nível de indentação. O tamanho da tabulação está predefinido na configuração do editor (é normalmente de 8 ou 4 caracteres). Use o -> para o definir de novo.
O procedimento de definição da largura da tabulação actual depende do editor que seleccionou no passo de configuração em Seleccionar um Editor. Você terá de ver na ajuda correspondente do editor para descobrir como fazê-lo.
Se você seleccionar esta opção, o editor irá introduzir um conjunto de espaços por cada nível de indentação. Mude o número do valor por omissão 2 para o tamanho que preferir.
Isto define quais as entidades de (C/C++) que serão formatadas com uma indentação extra para além do nível de indentação actual.
Por omissão, só os namespaces (espaços de nomes) e os labels (identificadores) terão uma indentação extra. Você poderá querer experimentar com várias opções para se ajustar a essas indentações extra de acordo com o seu agrado.
As opções aqui agrupadas aplicam-se aos casos em que o sistema de formatação de código reparte automaticamente as linhas de código grandes. Ele tem dois casos especiais em conta, nomeadamente os casos em que as indentações são demasiado grandes e é necessário haver espaço restante para o código e para as condições, que deverão ter níveis de indentação extra para que sejam suficientemente perceptíveis.
Isto aplica-se aos casos de mudanças de linha estáticas apenas quando é usado um tamanho de linha máximo fixo no código. Se você configurar o seu editor para repartir dinamicamente as linhas apenas na visualização (o que é possível, na componente de edição do Kate), os efeitos destas configurações não serão visíveis.
Esta configuração limita a indentação máxima possível para as linhas de continuação para que sobre espaço suficiente para manter o texto legível. Nenhuma linha de continuação será indentada para além do número de colunas que seleccionar neste campo.
O tamanho por omissão está definido como 40 colunas de caracteres (metade de uma página de 80 colunas normal). Você poderá querer aumentar este valor para ter em conta o papel mais largo (isto é se você usa a impressão no modo paisagem para o seu código) ou então diminui-lo se quiser ter em conta a configuração das margens nas suas impressões.
As condições ou o código que se segue isto é a um operador de atribuição deverão ter normalmente uma indentação extra nas linhas de continuação para manter o texto legível. A quantidade desta indentação extra é aqui definida.
O valor por omissão é igual a “Duas vezes o actual”, o que significa que as condições continuadas irão ter um nível de indentação extra em relação ao tamanho de indentação normal que seleccionou no grupo Preenchimento. Você poderá alterar esta indentação extra para outro tamanho fixo (incluindo zero), usando as setas ou indicando o valor directamente.
Outra configuração do estilo de formatação do código
As opções no grupo (talvez mal chamado) Parêntesis controlam a posição das chavetas que delimitam os blocos no código em C/C++. Existem três possibilidades para você seleccionar.
Esta insere uma quebra de linha antes de cada chaveta de abertura. Ambas as chavetas delimitadoras de um bloco serão colocadas ao mesmo nível de indentação que a instrução de topo do bloco.
namespace espacoXpto
{
int Xpto()
{
if (eOla)
{
ola();
return 1;
}
else
return 0;
}
}
Isto irá manter a chaveta de abertura de um bloco alinhada com a instrução de topo do bloco. As chavetas de fecho estarão ao mesmo nível de indentação que a instrução de topo do bloco. O else de uma instrução if será mantido em linha com a chaveta de fecho do bloco anterior.
namespace espacoXpto {
int Xpto() {
if (eOla) {
ola();
return 1;
} else
return 0;
}
}
Este é um compromisso entre os estilos listados acima. As chavetas de delimitação dos blocos serão colocadas em linhas extra. As chavetas que abrem um bloco numa instrução condicional ou de ciclo serão mantidas na mesma linha.
namespace espacoXpto
{
int Xpto()
{
if (eOla) {
ola();
return 1;
} else
return 0;
}
}
Por omissão, o KDevelop minimiza a utilização dos espaços no código.
if (eOla(argXpto)==valorOla)
Você poderá aumentar a legibilidade se forçar o sistema de formatação de código a inserir os espaços extra em posições especiais.
De facto, o que esta opção pretende fazer é adicionar espaços à volta do texto entre parêntesis. Isto aumenta a legibilidade dos argumentos das funções e das condições.
if ( eOla( argXpto )==valorOla )
Isto irá colocar espaços à volta dos operadores de atribuição e de comparação para aumentar a legibilidade.
if (eOla(argXpto) == valorOla)
Existem alguns casos em que você não quer que o sistema de formatação de código divida uma linha em duas. Para o código de C/C++, isto poderá ser controlado aqui.
Isto mantém as instruções de uma linha em conjunto, mesmo nas situações em que elas excedem um tamanho máximo de linha.
Isto mantém os blocos de uma única linha em conjunto, mesmo nas situações em que elas excedem um tamanho máximo de linha.
Ao editar no KDevelop você poderá gravar excertos de código usados frequentemente como Excertos de Código. Para configurar as capacidades da componente de excertos de código, seleccione a -> no menu. A janela para Configurar o KDevelop irá aparecer, onde então terá de seleccionar Excertos de Código no campo do lado esquerdo. Isto levá-lo-á à página de configuração mostrada em baixo.
Configurar a Ferramenta de Excertos de Código
Assinale a opção “Mostrar o texto do excerto na dica” se você quiser ver o texto armazenado numa janela de dica de ferramentas, sempre que você deixar o cursor do rato sobre o título desse excerto de código.
A ferramenta de Excertos de Código permite a definição de texto variável em locais bem definidos, sempre que desejar inserir um excerto num ficheiro. Para conseguir isto, os Excertos de Código têm o seu próprio mecanismo de variáveis. Você poderá configurar o seu comportamento no grupo Variáveis.
A ferramenta de Excertos de Código distingue as variáveis no texto, rodeando os nomes das variáveis com símbolos delimitadores especiais. Para usar o seu próprio delimitador, altere o valor predefinido $ no campo Delimitador.
Uma janela para cada variável do excerto – irá mostrar uma janela separada para cada variável que a ferramenta encontre ao inserir o excerto de código seleccionado.
Uma janela para todas as variáveis do excerto – irá mostrar uma janela comum, onde o utilizador terá de de preencher os valores de todas as variáveis antes de o excerto ser inserido
O KDevelop oferece um Selector de Ficheiros que, quando é carregado no arranque, permite navegar até chegar a qualquer ficheiro ou directoria do sistema.
O selector de ficheiros (modo IDEAl)
O comportamento do Selector de Ficheiros é altamente configurável. Seleccione a -> no menu. A janela para Configurar o KDevelop irá aparecer, onde então terá de seleccionar Selector de Ficheiros no campo do lado esquerdo. Isto levá-lo-á à página de configuração mostrada em baixo.
Configurar o selector de ficheiros
Existe uma barra de ferramentas no topo do Selector de Ficheiros, que poderá ser configurada como de costume no grupo Barra de Ferramentas.
Procedimento 4.1. Adicionar uma Acção à Barra de Ferramentas
Seleccione um item na lista das Acções seleccionadas à direita, para que a acção nova seja então introduzida.
Seleccione a acção a ser introduzida na lista de Acções disponíveis à esquerda.
Carregue na seta direita (em cima) entre as duas listas.
A acção será removida da lista de Acções disponíveis e será introduzida nas Acções seleccionadas por baixo do item seleccionado.
Procedimento 4.2. Remover uma Acção da Barra de Ferramentas
Seleccione o item a ser removido da lista de Acções seleccionadas à direita.
Carregue na seta para a esquerda (em baixo) entre as listas.
O item seleccionado será removido da lista de Acções seleccionadas e colocada de novo na lista de Acções disponíveis.
Procedimento 4.3. Reordenar as Acções na Barra de Ferramentas
Seleccione a acção a ser mudada de posição na lista de Acções seleccionadas à direita.
Carregue nas setas para cima e para baixo, à direita desta lista.
O item seleccionado será movido para cima ou para baixo na lista de Acções seleccionadas.
A actualização do conteúdo da janela do Selector de Ficheiros leva tempo e ocupa alguns recursos, especialmente ao mudar para outra directoria. Como tal, o Selector de Ficheiros está configurado por omissão de forma a que o seu conteúdo só se altera a pedido, isto é quando você selecciona outra directoria ou quando desejar explicitamente actualizar o seu conteúdo.
Carregue no botão Actualizar da barra de ferramentas para actualizar o conteúdo do Selector de Ficheiros. Esta barra de ferramentas não está disponível por omissão, todavia. Você precisa de a inserir primeiro.
Você poderá configurar o Selector de Ficheiros para reflectir imediatamente certas alterações no seu trabalho. As opções do grupo Auto-Sincronização da janela de configuração são responsáveis por isto.
Se você seleccionar esta opção, o conteúdo do Selector de Ficheiros será actualizado sempre que for para outro documento aberto, isto é quando você carrega na página da janela de edição respectiva no modo IDEAl. Se necessário, o Selector de Ficheiros irá mudar para a directoria a que este ficheiro pertence e actualizará a área visível para mostrar o conteúdo actual da mesma.
Se você seleccionar esta opção, o conteúdo da janela do Selector de Ficheiros será actualizado sempre que um documento é aberto, isto é pela opção do menu ->. Se necessário, o Selector de Ficheiros irá mudar para a directoria a que este ficheiro pertence e irá refrescar a visualização para mostrar o conteúdo actual.
Se seleccionar esta opção, o conteúdo do Selector de Ficheiros será actualizado sempre que ficar visível de novo. Se necessário, o Selector de Ficheiros irá mudar para a directoria a que este ficheiro pertence e irá refrescar a visualização para mostrar o conteúdo actual.
Você poderá combinar estas opções para ajustar o comportamento da actualização do Selector de Ficheiros ao seu gosto.
Existem duas listas na parte superior e na inferior da janela de conteúdo do Selector de Ficheiros que controlam a directoria a ser mostrada (a lista no topo) e os filtros a serem aplicados à janela de ficheiros (a lista de baixo). Um histórico das opções mais recentes é mantido no campo de selecção de cada lista. Você poderá configurar o número de itens do histórico da seguinte forma.
Indique aqui o número máximo de selecções de directorias que a lista de cima deverá recordar.
Indique aqui o número máximo de definições de filtros que a lista em baixo deverá recordar.
Por omissão, o Selector de Ficheiros está configurado de forma a que mostre o conteúdo da sessão mais recente no próximo arranque do KDevelop. Você poderá alterar este comportamento no grupo de configuração Sessão.
Se o KDevelop foi reiniciado automaticamente pelo gestor de sessões do KDE, as alterações a estas opções não farão efeito. Neste caso, a configuração da localização e dos filtros da sessão mais recente do KDE será sempre reposta.
Desligue esta opção se não quiser que a localização apresentada seja guardada entre sessões.
Se você seleccionou uma das opções de auto-actualização, a localização apresentada poderá mudar automaticamente, independentemente do que foi recordado da sessão recente.
Desligue esta opção se não quiser que os filtros apresentados sejam guardados entre sessões.
O KDevelop contém uma funcionalidade de documentação muito poderosa que fornece o acesso a vários tipos de documentação extensa. Por exemplo, no modo IDEAl, você irá encontrar uma página de Documentação do lado direito da área de trabalho.
A árvore de documentação do KDevelop (modo IDEAl)
O KDevelop precisa de ter carregado o 'plugin' de Documentação para ver a árvore de documentação. Veja as Ferramentas em 'Plugins' para mais informações.
Você poderá configurar o conteúdo desta árvore de documentação se seleccionar a -> no menu. A janela para Configurar o KDevelop irá aparecer, onde então terá de seleccionar Documentação no campo do lado esquerdo.
A página de configuração que é mostrada apresenta um conjunto de páginas de configuração, nomeadamente:
| Colectâneas de Documentação |
| Pesquisa por Texto Completo |
| Outro |
A configuração da documentação foi dividida numa série de colectâneas de documentação, em que cada uma fornece o acesso aos ficheiros de documentação de um determinado formato e tipo de conteúdo únicos. Esta configuração controla quais os itens de documentação que serão listados na página de Conteúdo da funcionalidade de Documentação do KDevelop, e como é que o utilizador pode aceder aos detalhes da documentação, através de procuras indexadas e pelo texto completo.
A página de Documentação oferece uma série de páginas de configuração que são ordenadas verticalmente como uma pilha de cartões de índice. Cada uma das páginas, de cada vez, irá abrir ao carregar no título do seu cartão de índice:
Configurar as colectâneas de documentação
Todas as páginas de configuração da página de Documentação usam uma disposição comum. Você irá encontrar os itens de documentação disponíveis de momento, listados na página aberta à esquerda, bem como uma série de botões à direita.
Existem três botões disponíveis para manter o conteúdo das páginas de configuração da documentação:
Abre uma janela de Propriedades do Catálogo de Documentação, tal como é mostrado em baixo, na qual poderá seleccionar a localização da fonte de documentação a adicionar, bem como lhe poderá atribuir um nome.
Abre uma janela de Propriedades do Catálogo de Documentação, tal como é mostrado em baixo, na qual poderá alterar a localização da fonte de documentação a adicionar, bem como lhe poderá mudar o nome.
Remove o item de documentação seleccionado da lista.
O item só será removido da lista. Todas as fontes de documentação permanecerão inalteradas. Você terá de as remover explicitamente por outros meios.
Adicionar ou alterar um item de documentação
O botão à direita do campo de Localização abre uma janela de directorias, cujos itens serão filtrados de acordo com o tipo de ficheiro da página de configuração seleccionada.
O campo de Título poderá não estar acessível, dependendo do tipo de documentação a ser mantido.
Cada página de configuração de documentação mostra os itens de documentação listados numa tabela com quatro colunas:
Se esta opção estiver assinalada, este item de documentação irá aparecer na página de Conteúdo da funcionalidade de Documentation do KDevelop.
Se desligar a opção TOC, esta irá por sua vez desactivar as opções Índice e Procurar (ver em baixo). Como tal, você não poderá ter itens da colectânea de documentação indexados mas que não estejam visíveis no conteúdo.
Se esta opção estiver assinalada, será criado um índice interno a partir deste item de documentação. Isto oferece um acesso rápido à documentação, através do uso das páginas de Índice e (opcionalmente) Procurar da funcionalidade de Documentation do KDevelop.
O índice interno será criado da primeira vez que o utilizador seleccionar a página de Índice. Isto irá atrasar consideravelmente o primeiro acesso, porque o índice será lido do disco e depois é então colocado numa 'cache'.
Todas as pesquisas subsequentes irão usar então esta 'cache' e, por isso, irão funcionar muito mais depressa.
Se esta opção estiver assinalada, o conteúdo deste item de documentação será incluído nas localizações de procura por texto completo da página Procurar da funcionalidade de Documentation do KDevelop.
O KDevelop usa a colectânea de aplicações do 'htdig' para efectuar as pesquisas por texto completo. Esta pesquisa é feita sobre um índice interno que a plataforma do 'htdig' tem de criar antes de poder ser usada.
Todas as alterações feitas na opção Procurar irão apenas afectar as pesquisas depois de reconstruir o índice da página Procurar da funcionalidade de Documentation do KDevelop.
Este é o nome do item de Documentação que será mostrado na página de Conteúdo da funcionalidade de Documentação do KDevelop.
As versões anteriores do KDevelop permitiam seleccionar os itens de documentação por projecto. Isto já não é mais possível.
Nesta página de configuração é configurada toda a documentação do Qt™.
Configurar a colectânea de documentação do Qt™
Normalmente, o KDevelop irá preencher isto no seu primeiro arranque. Ele irá procurar pelos ficheiros de documentação normais *.xml e *.dcf da directoria de instalação do Qt™. A tabela à esquerda irá listar os ficheiros que o KDevelop encontrou pelo seu título normal.
Se você tem uma instalação fora do normal, então poderá não existir nenhuma informação indicada, ou então os endereços irão apontar para locais inválidos (isto é para outra instalação do Qt™ disponível no seu sistema). Você poderá ajustar os itens, usando os botões à direita da lista.
O KDevelop irá usar os títulos já fornecidos pela documentação do Qt™ instalada. Por isso, o campo Título da janela de Propriedades do Catálogo de Documentação está inacessível.
Por omissão, nem toda a documentação do Qt™ estará visível na página de Conteúdo da funcionalidade de Documentation do KDevelop. Use a opção TOC na tabela de configuração para seleccionar a documentação a ser apresentada.
Se você quiser incluir mais alguma documentação específica do Qt™ nos índices de pesquisa ou na pesquisa por texto completo, use as opções de Índice e Procurar da tabela de configuração.
Nesta página de configuração, você poderá recolher a documentação referente à norma de ficheiros de ajuda CHM da Microsoft®.
Configurar os ficheiros de documentação CHM normais da Microsoft®
Por omissão, esta página de configuração estará vazia (como é mostrado acima). Você poderá adicionar novos itens com os botões à direita do campo da lista. O KDevelop irá filtrar os ficheiros *.chm na janela de directoria associada aos botões e .
Para mais informações sobre o formatos dos ficheiros *.chm da Microsoft®, veja isto é a Documentação do PHP - Formato CHM Extendido em http://de2.php.net/docs-echm.php.
Nesta página de configuração, toda a documentação da API gerada pelo Doxygen será configurada.
Configurar a documentação da API gerada pelo Doxygen
Em resumo, estas APIs documentam a interface para as funções de certas bibliotecas. Para produzir a documentação da API desta página é usada a ferramenta Doxygen.
A documentação da API gerada pelo Doxygen consiste numa série de ficheiros HTML, a começar pelo index.html. Adicionalmente, poderão existir ficheiros tag que contêm informações para se associar a documentações de API já existentes. Como tal, o KDevelop irá procurar pelo index.html e pelos ficheiros *.tag ao procurar pela documentação de API gerada pelo Doxygen.
Existem algumas restrições estruturais assumidas ao procurar pela documentação da API gerada pelo Doxygen. A directoria na qual se encontra o ficheiro index.html deverá conter algumas sub-pastas com colectâneas de documentação separadas. Assume-se que cada uma destas sub-pastas contém um ficheiro .tag e uma subdirectoria html/.
Você poderá dar uma vista de olhos em $ para ter um exemplo de uma disposição de documentação de API em Doxygen. KDEDIR/share/doc/HTML/en/kdelibs-apidocs
O formato de documentação da API mais antigo do KDE, o KDoc, já não é mais suportado directamente. Se quiser usar à mesma essa documentação, você podê-la-á adicionar à mesma na página da Colectânea Personalizada de Documentação.
O KDevelop terá preenchido numa ligação a API actual das Bibliotecas do KDE, desde que tivesse achado alguma na altura da instalação. Existem várias formas de o KDevelop a descobrir:
Ou você indicou no comando configure a opção --with-kdelibsdoxy-dir, quando compilou o KDevelop (veja o capítulo Como Obter a Documentação da API do KDevelop).
Ou então o comando configure descobriu automaticamente uma API das Bibliotecas do KDE gerada pelo Doxygen num dos locais normais que ele conhece à partida.
Ou, como último recurso, a pasta $ foi encontrada no primeiro arranque do KDevelop. KDEDIR/share/doc/HTML/en/kdelibs-apidocs/
Se o KDevelop não encontrou nenhuma documentação da API das Bibliotecas do KDE gerada pelo Doxygen, então a lista da Documentação Gerada pelo Doxygen aparecerá vazia.
Você poderá adicionar os seus próprios itens de documentação da API (isto é dos seus projectos actuais), usando os botões à direita. Se os quiser incluir na pesquisa indexada ou por texto completo marque as opções Índice ou Procurar da tabela de configuração.
O KDevelop usa a informação do título do ficheiro index.html. Daí, o campo Título na janela de Propriedades do Catálogo de Documentação estar inacessível.
O sistema do KDE fornece mais documentação da API do que apenas a API das Bibliotecas do KDE. Você irá precisar de mais informações de interfaces se quiser, isto é, incluir a componente do Kate nos seus programas. Para esta API da componente do Kate, você deverá compilar e instalar a API das Bibliotecas de Base do KDE a partir do código (com os comandos make apidox e make install no código do kdebase), adicionando então um item à lista Documentação Gerada pelo Doxygen como se segue:
Adicionar uma API de Base do KDE à Lista
(Claro que deverá substituir a directoria /home/dev/o-meu-kde/ no campo Localização com a localização da sua instalação do KDE).
Você precisa também de colocar a API do seu projecto actual nesta Colectânea de Documentação do Doxygen. As versões mais antigas do KDevelop colocavam-na na árvore de documentação ao nível do projecto. Isto já não é mais suportado.
O bloco principal da árvore de documentação do KDevelop fornece o acesso imediato à documentação estruturada, seja esta local ou remota. Você poderá configurar isto na página da Colectânea de Documentação do KDevelopTOC.
Fornecer o acesso à documentação estruturada do KDevelopTOC
O KDevelop vem com um conjunto de ficheiros KDevelopTOC predefinidos que são introduzidos automaticamente na tabela, na altura da instalação. Para manter o ambiente de trabalho fácil de gerir, só a documentação usada com maior frequência é que será marcada inicialmente para ser visualizada. Se você quiser ver outra documentação, marque a opção TOC na tabela de configuração.
Os ficheiros KDevelopTOC não podem ser indexados para fazer uma pesquisa por texto completo, porque normalmente apontam para uma localização remota. Por outro lado, qualquer um desses ficheiros .toc poderá ter um índice definido manualmente, usando a marca <index>. Daí, a opção Índice ficará activa apenas quando o KDevelop encontrar uma marca <index> no ficheiro .toc. (Para mais detalhes, veja a descrição em baixo na secção de Ficheiros de Índice do KDevelop.)
A opção Procurar na tabela de configuração ficará sempre desactivada.
Você poderá adicionar novos itens com os botões à direita da lista. O KDevelop irá filtrar os ficheiros *.toc na janela de directoria associada aos botões e .
Só nas versões mais antigas do KDevelop é que o botão irá alterar os ficheiros *.toc em disco, como tal a operação de remoção é segura agora.
Existe uma funcionalidade especial associada a isto. Para ilustrá-la, siga estes passos: Na árvore de documentação, escolha um item ligeiramente abaixo da documentação do Qt™/KDE (isto é, o “Livro de Programação no KDE2 (kde.org)”). Carregue no sinal de mais (+) ao lado dele. Irá abrir uma árvore, na qual você poderá navegar pelos capítulos subsequentes que se encontram vários níveis abaixo, tudo de forma desligada. Porém, se você seleccionar finalmente um dos capítulos, o KDevelop irá em muitos dos casos tentar aceder a um ficheiro de documentação remoto.
A razão por detrás disto e não só navegar localmente pela documentação remota sem desperdiçar recursos de acesso à rede, mas também para oferecer ao programador um acesso simples e estruturado à documentação que precisa. Com as ferramentas aqui oferecidas, uma pessoa poderá aceder a quase qualquer documentação local ou remota de forma estruturada, mesmo que o documento original seja um só ou a sua estrutura original seja diferente. Tudo o que é preciso é o acesso aos ficheiro e/ou partes dos outros ficheiros que são legíveis no Konqueror.
Esse acesso estruturado é possível com a utilização de “ficheiros de índice” especiais, os quais são identificados pela extensão .toc. Qualquer um desses ficheiros de índice do KDevelop contêm uma descrição estruturada em XML™ do documento a ser acedido.
Quando o KDevelop foi instalado, normalmente foi colocada uma série de ficheiros .toc predefinidos na directoria $KDEDIR/share/apps/kdevdoctreeview/tocs. Estes são ficheiros de texto estruturado relativamente simples. Você poderá olhar para eles com um editor de texto ou com outra funcionalidade de apresentação de texto.
Estrutura Básica dos Ficheiros de Índice do KDevelop
<!DOCTYPE kdeveloptoc>
|
<kdeveloptoc>
|
| (título) |
| (endereço de base) |
| (estrutura do conteúdo) |
| (estrutura do índice) |
</kdeveloptoc>
|
Esta estrutura em XML™ será processada pelo 'plugin' de Documentação do KDevelop para configurar o conteúdo da árvore de documentação e para guiar o utilizador na navegação pela documentação. Ele contém toda a informação necessária para mostrar os títulos e aceder ao conteúdo do ficheiro de documentação.
<title> (algum texto de título) </title> |
Este é o título que o KDevelop irá mostrar nos níveis básicos da árvore de documentação.
Este título apresentado não pode de momento ser alterado pelo utilizador. Se você quiser mostrar outro texto, você terá de alterar manualmente o item <title> no ficheiro .toc.
<base href=" (URL do documento de base) "/> |
Este URL aponta para a localização em que todos os ficheiros desta documentação se localizam. Será inserida no início de cada URL de secção na seguinte lista da estrutura do conteúdo. Por isso, se você isto é obter alguma documentação de um servidor remoto, tudo o que precisa para mostrar os ficheiros nesta nova localização é mudar o URL da <base>.
<tocsect1 name=" (título da secção) " url=" (URL da secção) "> |
| ... |
<tocsectn name=" (título da secção) " url=" (URL da secção) "/> |
| ... |
</tocsect1>
|
Toda a informação restante de navegação e de acesso é guardada numa série de pares <tocsecti> ... </tocsecti> aninhados. Cada i corresponde a um nível consecutivo de aninhamento abaixo do nível n, correspondente à secção de documentação finalmente apresentada.
Todos os itens <tocsecti> devem ter um atributo name="xxx" associado a eles (o "xxx" representa o título actual). Isto será mostrado como o título do nível na árvore de documentação. Ele irá corresponder a uma secção da documentação actual.
Poderá existir um atributo url="" associado ao nível de aninhamento i. Quando o utilizador carregar no título de uma secção da documentação, o KDevelop irá tentar aceder ao ficheiro na localização indicada pelo endereço de base combinado com o URL da secção.
O item <tocsectn/> precisa de ter um atributo url="", de qualquer forma. Este <tocsectn/> final não vem aos pares, mas será sim fechado por um / antes do carácter >.
Qualquer endereço resultante da combinação do endereço de base e do URL da secção precisam de apontar para um ficheiro de texto visível. Normalmente, este será um ficheiro estruturado em HTML. É possível fazer referência a 'âncoras' num desses ficheiros, usando a notação normal do '#', com o formato: /url-de-base/url-da-seccao#ancora.
<index>
|
<entry name=" (título do índice) " url=" (URL da secção do índice) "/> |
</index>
|
O índice é uma lista simples de itens de índice - pares de títulos e URLs. O índice não é obrigatório.
A documentação do DevHelp é outra forma de aceder à documentação estruturada. Ele usa os ficheiros de índice estruturados identificados por uma extensão .devhelp semelhante aos ficheiros TOC do KDevelop para aceder à documentação do ambiente de trabalho do GNOME 2.
Você poderá controlar quais os ficheiros do DevHelp que deverão estar acessíveis na página de configuração da Colectânea de Documentação do DevHelp.
Fornecer a documentação do DevHelp
Os ficheiros do DevHelp originalmente estavam acessíveis no 'site' Web do LiDN, mas estes parece que não são mantido já há algum tempo. A documentação do DevHelp mais recente está disponível na página Web para Obter os Livros do DevHelp.
Quando o KDevelop é instalado, ele irá tentar procurar todos os ficheiros .devhelp nos locais-padrão do sistema, isto é nas sub-pastas de /opt/gnome/share/. Inicialmente, estes ficheiros não serão marcados para serem visualizados. Se quiser ver outra documentação, marque a opção TOC da tabela de configuração.
Você poderá adicionar novos itens com os botões à direita da lista. O KDevelop irá filtrar os ficheiros *.toc na janela de directoria associada aos botões e .
Isto é para o seu próprio fim. Você poderá adicionar quase qualquer tipo de documentação, desde que possa ser mostrada pelos 'plugins' do Konqueror.
Fornecer a documentação personalizada
Normalmente, esta colecção estará vazia no primeiro arranque do KDevelop. Foi preenchido deliberadamente um item para mostrar a estrutura do item.
O tratamento é relativamente simples aqui. Use os botões à direita da lista para adicionar, editar ou remover os itens dos documentos. O KDevelop não irá filtrar nada da janela de directorias que esteja associado aos botões e .
Você terá de seleccionar explicitamente os itens para os mostrar na funcionalidade de documentação do KDevelop. Marque a opção TOC do item na tabela de configuração.
A documentação personalizada não pode ser indexada ou pesquisada. Como tal, as opções Índice e Procurar não farão efeito, como é mostrado acima.
(... ainda não escrito ...)
Configurar os índices de pesquisa de texto
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
(... ainda não escrito ...)
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
No KDevelop, o trabalho de desenvolvimento de 'software' está organizado em projectos. Cada um desses projectos reúne tudo o que pertença a uma tarefa de programação completa: ficheiros de código, ficheiros de dados adicionais e todas as necessidades de gestão, como o sistema de compilação, assim como o acesso a todos os componentes e a todas as ferramentas adicionais que sejam necessárias para pôr a aplicação a funcionar.
A organização de todo o trabalho de desenvolvimento nos projectos permite-lhe mudar facilmente de tarefas para tarefas, a nível global. Isto é bastante útil se você, isto é, trabalha em várias aplicações ao mesmo tempo, como poderá ser normalmente o caso. Diga ao KDevelop para abrir o projecto com que deseja trabalhar e poderá continuar no ambiente tal e qual o deixou.
Sempre que deseje iniciar um novo projecto de programação, terão de ser efectuados vários procedimentos formais de configuração. Terá de ser criada uma estrutura de directorias inicial, os ficheiros de inclusão e de código terão de ser fornecidos, o sistema de compilações tem de ser inicializado, etc.
O KDevelop fornece uma forma simples de iniciar um novo projecto de programação — o Application Wizard. Você irá encontrar o Application Wizard no item de menu ->.
Só é necessária uma série curta de passos para iniciar um novo projecto de programação, usando o Application Wizard:
Seleccionar a linguagem de programação que você deseja usar e o tipo da aplicação que deseja compilar, a partir de um conjunto de modelos predefinidos.
Fornecer algumas informações gerais como o nome da aplicação, a directoria em que a aplicação deverá ser criada, etc.
Decidir se deseja usar um sistema de controlo de versões, como isto é o CVS, e fornecer os dados necessários.
Definir alguns modelos para os ficheiros de inclusão e de código iniciais (se for necessário).
Finalmente, dizer ao Application Wizard para configurar todos os artefactos iniciais, a estrutura de directorias, os modelos de ficheiros de ficheiros de código/inclusão iniciais e as ferramentas de gestão, isto é um esqueleto inicial de compilação, etc.
'Voilà' — é tudo. O Application Wizard irá fornecer-lhe então um conjunto inicial e funcional de ficheiros de programação, nos quais você poderá começar prontamente a trabalhar.
Vamos então olhar agora para tudo isto com mais detalhe ...
Para criar um novo projecto no KDevelop, seleccione do menu . A janela para Criar um Novo Projecto irá aparecer e mostrar-lhe-á uma página Geral inicial:
Janela inicial de configuração de um novo projecto
Como pode ver, esta janela está dividida numa parte superior e numa inferior. Na parte superior, você poderá decidir sobre a linguagem de programação e o tipo de aplicação, enquanto que a parte inferior contém algumas informações gerais.
O lado esquerdo da parte superior desta janela é onde você faz o trabalho de selecção. Quando aparecer, você irá encontrar então uma lista de pastas, em que cada uma contém uma linguagem de programação, como por exemplo:
Para ser mais exacto, estas pastas não contêm ferramentas de programação de facto. Elas sim conduzem a modelos predefinidos que você poderá usar como ponto de partida para programar nessa linguagem. Para ter uma ideia do que é fornecido, basta abrir as pastas uma a seguir à outra. Irá aparecer um conjunto de subpastas em algumas e apenas um ou mais itens simples noutras. As subpastas que você verá organizam os modelos disponíveis de acordo com algumas tarefas, enquanto que os itens simples indicam os modelos que você poderá seleccionar.
Não poderemos entrar em detalhes aqui sobre que tarefas fazem o quê, mas é fácil descobrir. Sempre que você seleccionar um modelo, é mostrada alguma informação nos campos à direita. No campo inferior, você irá encontrar uma breve descrição sobre o que é que o modelo é suposto fazer. No campo acima dele é mostrada uma imagem, se estiver disponível, sobre o resultado da aplicação que este modelo produz se você a compilar e correr sem modificações. Normalmente, esta é uma fotografia da janela principal que a aplicação irá mostrar.
Seleccione o modelo que melhor se adequa aos objectivos da sua aplicação como ponto de partida. Depois introduza as informações das propriedades gerais no campo inferior, tal como é mostrado no capítulo seguinte.
Seleccionar um Sistema de Gestão de Projectos. Cada modelo está associado a um Sistema de Gestão de Projectos específico. De momento, não existe uma forma livre de seleccionar um desses Sistemas de Gestão de Projectos. Você terá de procurar um modelo que se adeque às suas necessidades ou de alterar o seu projecto, depois de criado, de acordo com isso.
A parte inferior da janela Criar um Novo Projecto, na página Geral, é uma área chamada Propriedades. Você tem de indicar aqui algumas informações gerais sobre o seu projecto, de modo a que o Application Wizard saiba como criar a estrutura inicial.
Nome da Aplicação. A sua aplicação precisa de um nome, como é óbvio. Indique-o no campo Propriedades, chamado Nome da Aplicação. Iremos usar “MinhaAplicacao” por exemplo.
Quando o fizer, você irá reparar que o Application Wizard se recusará a aceitar caracteres especiais de qualquer espécie. Os únicos caracteres aceites são:
caracteres maiúsculos e minúsculos
números
o carácter de sublinhado (_)
Uma razão importante para esta restrição é que o Application Wizard irá usar este nome da aplicação como base dos nomes de algumas classes que irá construir quando configurar o projecto inicialmente. Daí, o nome da aplicação terá de se adequar às regras da linguagem de programação que usar.
A Directoria do Projecto. A outra causa para esta restrição poderá ser vista por si na linha inferior da área Propriedades. Chama-se Localização final e mostra a directoria onde o Application Wizard irá criar a aplicação.
À medida que você vai escrevendo o nome da aplicação, você irá reparar que o Application Wizard repete os seus dados introduzidos no fim da linha Localização final, usando apenas os caracteres minúsculos.
Como tal, você terá de seleccionar o nome da sua nova aplicação com cuidado. Se você terminar com o nome de uma directoria já utilizada, o Application Wizard não lhe permitirá passar para o próximo passo, mantendo o botão desactivado (a cinzento). De qualquer forma, ele avisá-lo-á nesse caso, adicionando o texto “(dir/ficheiro já existe)” no campo Localização final.
A Localização Inicial. Existem duas formas de seleccionar outra pasta para a sua nova aplicação. Uma passa por seleccionar outro nome. Contudo, isso nem sempre é conveniente (você poderá, isto é, configurar outra versão de uma aplicação já existente). Como alternativa, você poderá seleccionar outra localização para a pasta da aplicação.
Isto é feito com o segundo campo das Propriedades, chamado Localização. O que você indicar aqui é a localização inicial da directoria de desenvolvimento da nova aplicação. O Application Wizard irá adicionar o nome da aplicação a esta directoria quando inicializar o novo projecto. O resultado é apresentado no campo Localização final, que lhe dá um melhor controlo sobre o que se passa.
O Application Wizard irá copiar um valor inicial para o campo Localização no início. Este é extraído a partir do que você tiver escolhido no campo Directoria de projectos por omissão dos passos gerais de configuração. No nosso caso, o KDevelop está configurado para usar a /home/ze/projectos.
Altere o conteúdo do campo Localização para que a directoria de desenvolvimento das aplicações mostrada na linha Localização final seja única.
Tenha em atenção se a linha do campo Localização já existe ou não. O Application Wizard irá avisá-lo se indicar localizações inexistentes adicionando “(inválido)” ao campo Localização final.
Dados Pessoais. Os campos a seguir não são tão críticos. Basta indicar o seu nome (i.e., o nome da pessoal responsável pela aplicação) no campo Autor e um endereço de e-mail válido no campo E-mail, de modo que os utilizadores lhe possam comunicar algo sobre a aplicação.
O Application Wizard preenche este campos com alguns valores predefinidos, extraídos a partir da configuração do E-mail no Centro de Controlo KDE. Se estes valores nos campos da janela Criar um Novo Projecto, para o Autor e para o E-mail não forem válidos, você poderá ter de ver a sua configuração de e-mail no Centro de Controlo KDE.
O Application Wizard integrará esta informação nos modelos iniciais de programas, se tal se aplicar. Nos programas em C++ para o KDE, por exemplo, você poderá encontrá-la perto do início do ficheiro de código main.cpp.
De todos os campos, o E-mail é opcional, o que reflecte o facto de que nem todos os programadores terão acesso à Internet. Você poderá manter este campo em branco se o desejar e continuar o seu trabalho.
Informação da Versão e da Licença. Finalmente indique um número de versão inicial para a sua aplicação nova no campo Versão e seleccione a licença segundo a qual deseja publicar a sua aplicação na página Licença.
Se você seleccionar um tipo de aplicação para o qual o Application Wizard forneça textos de modelos de código comuns (isto é, C/C++), você poderá ver o texto de notificação da licença na terceira página desta janela Criar um Novo Projecto (veja o capítulo sobre como Fornecer modelos de código/inclusão em baixo).
Se você indicou “Personalizada” na página Licença, você terá de indicar um texto próprio para a licença.
Tanto a informação da licença como da versão serão integradas nos modelos iniciais num formato adequado que o tipo de aplicação que você seleccionou ofereça.
Logo que tenha introduzido toda esta informação, carregue no botão para avançar, tal como é mostrado nos capítulos seguintes.
Num segundo passo, o Application Wizard levá-lo-á para a página do Sistema de Controlo de Versões, onde poderá decidir qual o sistema de controlo de versões que desejará usar.
Esta discussão concentra-se nas necessidades apenas para a criação do projecto. Para mais informações sobre o CVS veja o capítulo sobre como Usar o CVS em baixo.
Nenhum Sistema de Controlo de Versões Necessário. Inicialmente, está a opção “Nenhum” seleccionada na página do Sistema de controlo de versões, onde a página ficará em branco. Se não quiser usar nenhum sistema de controlo de versões, basta carregar no botão e seguir em frente.
Usar o CVS. Caso contrário, você terá de seleccionar de novo o sistema de controlo de versões que deseja usar na página Sistema de controlo de versões. De momento, só o “CVS” é que está disponível. Se o seleccionar, então o Application Wizard irá mostrar de novo a página, mostrando ela agora um conjunto de campos que precisa de preencher.
Configurar o novo projecto no CVS
Um sistema de controlo de versões como o CVS (que significa “Concurrent Versions System” ou “Sistema Concorrente de Versões”) guarda as cópias dos ficheiros seleccionados do projecto numa espécie de base de dados. Se você usar o CVS você poderá, entre outras coisas, enviar (fazer “commit”) destes ficheiros ou carregá-los para a sua directoria do projecto (fazer um “checkout” ou um “update”). O que há de especial nisto é que os ficheiros na base de dados das versões são gravados de uma forma estruturada que permite em qualquer altura voltar atrás a um estado anterior de desenvolvimento, se for necessário. Para além disso, o CVS permite a vários programadores colaborarem facilmente num grande projecto (como o KDevelop) sem estragar o trabalho dos outros.
Raiz do CVS. O CVS precisa de gerir a base de dados de versões que mantém para os seus ficheiros do projecto. Para o conseguir, ele mantém alguma informação especial da base de dados numa directoria própria, chamada de raiz do CVS. O primeiro passo para configurar o CVS para o seu projecto novo é então indicar ao KDevelop onde é que se localiza essa raiz.
Raiz local do CVS. Existem duas possibilidades básicas. Ou você usa uma base de dados local do CVS ou poderá usar uma base de dados que é mantida num servidor remoto. Se fizer desenvolvimentos próprios, você poderá usar a base de dados do CVS como uma espécie de base de dados de salvaguarda no seu próprio computador. Normalmente esta é configurada na raiz da sua área pessoal e é-lhe dado o nome cvsroot. Isto poderá assemelhar-se ao seguinte:
/home/ze/cvsrootze poderá ser substituído pelo nome do seu utilizador).
De facto, este é um formato curto. De forma exacta, a raiz local do CVS deverá ser endereçada com o prefixo :local:. O formato curto só é permitido nos casos em que o nome do ficheiro começa por uma barra (/). O nome completo do nosso exemplo seria então igual a :local:/home/ze/cvsroot
Indique o nome da directoria-raiz do CVS que foi configurada para o seu sistema no campo Raiz do CVS. Em princípio, você poderá seleccionar qualquer nome, ou até mesmo usar várias bases de dados do CVS, mas aconselha-se que você se associe à raiz do CVS logo que esteja configurada.
Inicializar uma nova raiz do CVS. Se não existir ainda nenhuma raiz do CVS, o KDevelop poderá dizer ao sistema do CVS para criar uma para si na directoria indicada. Basta assinalar a opção Iniciar raiz por baixo do campo Raiz do CVS.
Como foi dito, o KDevelop só manda o sistema do CVS inicializar uma nova raiz do CVS. Não faz nada, por si só, a esta directoria. Felizmente, o CVS é esperto o suficiente para verificar se a directoria de raiz do CVS já existe ou não. Como tal, não fará mal nenhum se você tiver assinalado inadvertidamente a opção Iniciar raiz numa directoria de raiz do CVS já existente.
Raiz do CVS remota. Existem ocasiões em que a base de dados do CVS deverá ser mantida num servidor remoto, especialmente quando vários programadores trabalharem no mesmo projecto. Aí, você terá de indicar o URL da raiz do CVS deste servidor no campo Raiz do CVS. Por exemplo, se você quiser aceder ao servidor de CVS do KDE:
:pserver:utilizador@cvs.kde.org:/home/kdeutilizador corresponde ao nome do utilizador definido para a sua conta de CVS do KDE)
Tipos de Servidores de CVS Remotos. Basicamente existem dois tipos de servidores de CVS remotos largamente usados, o pserver que usa um protocolo não-cifrado e protegido por senha, ou o ext que uma transferência de dados cifrada por RSH ou SSH. Eles são distinguidos de acordo com o prefixo do URL que usam:
:pserver:
para o tipo de servidor não-cifrado e “protegido por senha”, ou
:ext:
para um tipo de servidor cifrado por RSH ou SSH. Por exemplo, o
:ext:utilizador@cvs.cervisia.sourceforge.net:/cvsroot/cervisia
acede à raiz do CVS da conhecida aplicação Cervisia, que é usada para gerir o CVS e que está no servidor do SourceForge.
Se você quiser usar um servidor cifrado por RSH ou por SSH para o acesso ao CVS, você terá de dizer ao KDevelop, qual o protocolo de cifra a usar. Basta indicar rsh ou ssh no campo CVS_RSH da página Criar um Novo Projecto Sistema de Controlo de Versões.
Existe uma contrapartida se você usar um servidor cifrado para o CVS no KDevelop. Veja o capítulo Usar o CVS para mais detalhes.
O Repositório de CVS. Até agora você só indicou ao KDevelop onde é que a raiz do CVS se encontra para gerir a base de dados das versões e como aceder-lhe. Agora, você irá precisar de dizer ao KDevelop sob que nome você irá querer que o CVS grave os seus ficheiros do projecto nessa base de dados. O local onde os seus ficheiros do projecto serão guardados no CVS é chamado de repositório.
Em princípio, você poderá usar qualquer nome para o repositório de CVS dos ficheiros do seu projecto, desde que corresponda às especificações de nomes de ficheiros. Mesmo assim, a maioria dos programadores usam apenas o nome da aplicação em si. O CVS irá criar uma directoria com esse nome na raiz do CVS, para que seja encontrada com maior facilidade se você mantiver o nome da aplicação nela.
Basta indica o nome do repositório que deseja usar no campo Repositório do CVS da página Criar um Novo Projecto Sistema de Controlo de Versões. No nosso exemplo, esta é: NovaAplicacao
Tenha cuidado em não usar um repositório que já exista! O sistema CVS não o avisa sobre os ficheiros duplicados mas irá limpar tudo o que não conduza a um conflito formal. Em resumo, você poderá deixar tudo confuso!
Os Campos Restantes. Não existe já muito mais para fazer. O Application Wizard já configurou os campos restante por si. Em detalhe:
O campo do Vendedor é usado apenas por razões de compatibilidade. Você poderá usar o valor por omissão “distribuidor” que o Application Wizard usa.
O campo da Mensagem permite-lhe comentar o conteúdo inicial do CVS. Use o texto que desejar ou poderá manter o texto “novo projecto” que o Application Wizard colocou.
O campo Marca de lançamento contém o nome que é marcado para o estado inicial do seu projecto. Essa marca define um certo ponto no repositório do CVS a que você poderá aceder posteriormente para este estado do seu desenvolvimento. (Veja mais no capítulo Usar o CVS.)
O Application Wizard colocou uma marca “inicio”, a qual é uma proposta aceitável. Basta usá-la.
Quando qualquer uma destas informações está errada, o KDevelop normalmente não irá saber de nada até à altura da criação do projecto. É o sistema do CVS que irá descobrir esses erros ao tentar criar o repositório. Aqui você deverá dar uma vista de olhos na janela Mensagens do KDevelop logo que o projecto for criado no passo final da configuração. Se ocorreu algum erro com o CVS, você irá ver na maioria dos casos uma mensagem semelhante a esta:
* cd '/home/ze/teste' e&& cvs -d '/home/ze/raiz_cvs' \
import -m 'novo projecto' '' 'distribuidor' 'inicial' &&\
sh /opt/kde3/share/apps/kdevcvs/buildcvs.sh . '' \
'/home/ze/raiz_cvs'
* cvs [import aborted]: /home/ze/raiz_cvs/CVSROOT: No such file or
directory
* *** Exited with status: 1 ***
Se isto acontecer, você terá de configurar manualmente o CVS (o KDevelop deverá ter conseguido inicializar com sucesso os ficheiros do seu projecto nesta altura) ou então remover a directoria do projecto e começar tudo de novo com a opção do menu .
Depois de você ter introduzido toda a configuração relacionada com o CVS, carregue no botão para prosseguir.
Se você quiser corrigir um erro na página anterior do Criar um Novo Projecto, basta carregar no botão . O Application Wizard irá recordar os seus resultados na página actual, por isso você poderá prosseguir com facilidade quando regressar.
O próximo passo leva-o a uma série de páginas onde poderá configurar informações comuns que deseje incluir nos seus ficheiros de código e de inclusão, se a tarefa à mão o permitir.
Tanto os modelos para ficheiros de código e de inclusão são fornecidos para as aplicações de C e C++, cada um na sua própria página. Para as outras linguagens, só deverão existir modelos de ficheiros de código. E ainda, noutros casos, você poderá encontrar esta página de modelos em branco.
Se a página for usada, o Application Wizard irá preencher um dado comentário comum sobre o que uma aplicação em C++ poderá parecer (o texto está em inglês, dado ser uma transcrição da licença GPL):
/***************************************************************************
* Copyright (C) 2003 by O Seu Nome *
* voce@proprio.com *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
Outros modelos irão fornecer várias informações semelhantes num formato que esteja de acordo com as definições da linguagem de programação que deseja usar.
Como você poderá já ter notado, o gestor de aplicações já preencheu alguma informação que você indicou na primeira página Geral da janela Criar um Novo Projecto, nomeadamente o conteúdo dos campos Autor e E-mail. Também a informação adequada da licença foi introduzida de acordo com a sua selecção na página Licença.
Os modelos que você configurar na janela Criar um Novo Projecto serão depois processados, sempre que você disser ao KDevelop para configurar um novo ficheiro de código e/ou de inclusão. A informação que indicar aqui será incluída no topo, como um cabeçalho de documentação, antes de a parte do código começar.
Você não está restrito ao texto normal, de qualquer forma. O KDevelop reconhece diversas variáveis que lhe permitirão incluir a informação actualizada no ficheiro. O Application Wizard usou de facto algumas variáveis para inserir o Autor, o E-mail e a Licença no campo de texto do modelo inicial.
Se, por exemplo, você quiser que a documentação da API gerada pelo Doxygen mostre alguma informação sobre o conteúdo do ficheiro na sua lista de ficheiros, você poderá incluir as seguintes linhas no modelo do ficheiro de código:
/**
* \file $MODULE$.cpp
* \brief (ponha uma descrição breve aqui).
**/
Sempre que você criar um novo ficheiro de código, o KDevelop irá substituir a variável $MODULE$ pelo nome do ficheiro criado como novo. Por exemplo, se você criou uma nova classe de C++ chamada TesteSimples, você irá ver as seguintes linhas no ficheiro testesimples.cpp:
/**
* \file testesimples.cpp
* \brief (ponha uma descrição breve aqui).
**/
Você terá à mesma de fornecer a breve descrição a seguir à palavra-chave “\brief”, mas parte do trabalho é automaticamente feita para si.
Como outro exemplo, você poderia incluir uma referência explícita para o texto da licença que deseja usar no modelo. Use a variável $LICENSEFILE$ para esse fim e adicione, por exemplo, esta linha:
// Veja o $LICENSEFILE$ para o texto completo da licença.
O Application Wizard irá substituir o $LICENSEFILE$ pela localização do ficheiro com o texto completo da licença, nomeadamente:
// Veja o COPYING para o texto completo da licença.
para a licença GPL ou
// Veja o LICENSE.BSD para o texto completo da licença.
se optou por colocar a sua aplicação segundo os termos da licença BSD.
Existem obviamente mais variáveis que o KDevelop conhece. Veja a secção sobre como Editar os modelos no capítulo Ferramentas de edição para saber o que é possível.
Os modelos que definir aqui ficarão em efeito só após o Application Wizard ter criado o projecto novo. Você irá encontrar esta informação no topo dos ficheiros que você criou durante o processo de desenvolvimento. Ao criar os ficheiros iniciais, o Application Wizard irá usar alguns modelos-padrão predefinidos. Você terá de adaptar manualmente estes ficheiros iniciais de acordo com as suas necessidades.
Está quase tudo feito, por agora. Na última página de modelos, o botão terá mudado para aparecer então .
Pense duas vezes antes de carregar nele! Você terá à mesma a opção de rever tudo se carregar repetidamente no botão . Dado que o Application Wizard recorda todas as informações que você introduziu até agora, é aconselhável que você ocupe algum tempo a rever tudo de novo. No caso de você usar o CVS local, não se esqueça de verificar com atenção o nome do repositório de CVS (não deverá existir nenhuma subdirectoria com esse nome na directoria da raiz do CVS — se existir, tente outro nome de repositório).
Se em alguma altura não desejar que o novo projecto, seja criado, interrompa a janela do Criar um Novo Projecto com o botão . Caso contrário, carregue em e veja na janela Mensagens como é que o Application Wizard inicia o projecto.
Se você quiser usar um sistema de controlo de versões (CVS), irão existir dois passos, de facto. O Application Wizard irá primeiro criar as directorias e ficheiros do projecto e então depois invocará o programa CVS que irá reiniciar a janela de Mensagens com o seu próprio conteúdo. Se ocorrer algum erro durante uma dessas execuções, o processo irá terminar, mostrando-lhe uma mensagem de erro correspondente na janela.
Em muitos casos em que o seu projecto foi configurado desta forma, o KDevelop irá automaticamente carregar os ficheiros de código de um ou mais módulos importantes para que você possa começar logo a trabalhar. (Os módulos de código que serão mostrados—se existir algum que seja—contudo, depende do modelo seleccionado inicialmente no Application Wizard.)
Não se esqueça de verificar inicialmente o que é que o Application Wizard forneceu. Por exemplo, você poderá querer alterar as informações iniciais dos cabeçalhos, de acordo com os seus próprios modelos. Normalmente, você irá encontrar estes numa subdirectoria templates da directoria do seu projecto. À partida, somente algumas cópias simples serão suficientes.
Aí, é aconselhável que você compile o projecto inicial antes de tentar alterar qualquer código que seja. Na maioria dos casos, esta compilação inicial será possível à partida. Como tal, você poderá começar logo a preparar o projecto para ser alterado de acordo com a sua vontade. Se não foi possível, basta remover a directoria do projecto (e da sua raiz local do CVS se usar alguma) e recomeçar do princípio.
Antes de você compilar o seu novo projecto da primeira vez, dê uma vista de olhos no ->. Devem existir três selecções mostradas: , e , com a seleccionada; use se possível esta, ou então use a em alternativa.
Devido a algumas limitações na configuração actual do autoconf/automake, você não deverá de forma alguma compilar com a configuração . Esta irá corromper algumas configurações de directorias internas, fazendo com que o configure se queixe quando o tentar usar nas configurações ou , a seguir.
(Isto aplica-se apenas às capacidades com várias opções. Se o tipo de aplicação que você seleccionou só contém uma configuração , você deverá obviamente usar esta.)
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
Funcionalidades (introdução preliminar)
O SnippetPart adiciona uma janela de ferramentas que fica acoplada por omissão à direita
A adição, edição e remoção de excertos de código está disponível através de um menu
Se fizer duplo-click sobre um excerto, introduzi-lo-á na área activa, na posição actual do cursor
As dicas mostram o conteúdo de um excerto
Os excertos são guardados na área pessoal dos utilizadores, como tal, cada utilizador poderá fazer os seus próprios excertos
Os excertos de código poderão conter variáveis do estilo $NOME_VARIAVEL$. Ao usar o excerto, o utilizador deverá preencher o valor de substituição das variáveis
A seguir, serão listadas as combinações de teclas por omissão do editor predefinido. Poderá configurá-las como desejar (como?)
Esquerda | Move-se um carácter para a esquerda |
Direita | Move-se um carácter para a direita |
Ctrl- Esquerda | Move-se uma palavra para a esquerda |
Ctrl- Direita | Move-se uma palavra para a direita |
Cima | Move-se uma linha para cima |
Baixo | Move-se uma linha para baixo |
Page Up | Move-se uma página para cima |
Page Down | Move-se uma página para baixo |
Ctrl- Page Down | Move-se para o início do ficheiro |
Ctrl- Page Down | Move-se para o fim do ficheiro |
Home | Move-se para o início da linha |
End | Move-se para o fim da linha |
Para todas as teclas acima, pode-se usar adicionalmente a tecla Shift, para marcar a partir da posição actual do cursor até à posição onde se for parar.
Backspace | Apaga um carácter à esquerda |
Delete | Apaga o carácter por baixo do cursor |
Ctrl- C | Copia o texto seleccionado para a área de transferência |
Ctrl- V | Cola o texto seleccionado da área de transferência |
Ctrl- X | Apaga o texto seleccionado e coloca-o na área de transferência |
Ctrl- Z | Desfazer |
Shift-Ctrl- Z | Refazer |
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
A forma convencional de procurar com a opção -> necessita que você indique o termo a procurar por completo, antes de iniciar a pesquisa. A maior parte do tempo, é muito mais fácil procurar incrementalmente. Se carregar no campo de texto chamado ISearch da barra de ferramentas, a pesquisa é efectuada à medida que vai escrevendo. Irá concluir que o termo desejado poderá ser encontrado logo ao fim de escrever 3 ou 4 letras.
Ambos os mecanismos de procura descritos acima estão restringidos a procurar dento de um ficheiro de código. Existe uma outra ferramenta adicional que lhe permite procurar num (talvez grande) conjunto de ficheiros, através da opção do menu do menu . É, basicamente, uma interface para o programa grep(1).
Na janela, poderá indicar os ficheiros onde deseja procurar. Existe um conjunto de padrões especiais disponíveis que poderá usar numa lista. Desta forma, poderá restringir facilmente o mecanismo de procura aos ficheiros de inclusão, por exemplo. Para além disso, existe uma pasta que poderá indicar onde começar a procura. Se assinalar a opção , a pesquisa irá percorrer todas as pastas que estejam abaixo desta na hierarquia.
O termo a procurar é, de um modo geral, uma expressão regular que segue a sintaxe do POSIX. Por exemplo, poderá usar o termo "\<K.*" se desejar procurar todas as palavras que comecem pela letra K. Os seguintes caracteres são interpretados de uma forma especial:
.
| Corresponde a qualquer carácter |
^
| Corresponde ao início de uma linha |
$
| Corresponde ao fim de uma linha |
\<
| Corresponde ao início de uma palavra |
\>
| Corresponde ao fim de uma palavra |
?
| O item antecedente corresponde menos que uma vez |
*
| O item antecedente corresponde zero ou mais vezes |
+
| O item antecedente corresponde uma ou mais vezes |
{n}
| O item antecedente corresponde exactamente 'n' vezes |
{n,}
| O item antecedente corresponde 'n' ou mais vezes |
{,n}
| O item antecedente corresponde menos de 'n' vezes |
{n,m}
| O item antecedente corresponde pelo menos n mas menos que m vezes |
As referências anteriores às expressões entre parêntesis estão também disponíveis, através da notação \n.
Para os programadores em C++, como bónus especial, existem alguns modelos de procura disponíveis para procurar padrões típicos. Estes permitem-lhe procurar, por exemplo, todas as chamadas a funções pertencentes a um dado objecto.
Logo que tenha iniciado a procura, após carregar no botão , esta será efectuada por um processo externo e assíncrono. Todos os itens encontrados irão aparecer na janela chamada Grep. Poderá então saltar para os itens encontrados, carregando neles. Lembre-se que o 'grep' procura os ficheiros da forma que eles estão guardados no sistema de ficheiros. Se tiver versões modificadas dos mesmos no seu editor, poderá ter algumas falhas de correspondência no número da linha ou mesmo obter alguns itens encontrados inválidos. Poderá evitar isto se gravar todos os ficheiros previamente.
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
(... ainda não escrito ...)
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
Do lado esquerdo da janela principal, o KDevelop poderá mostrar vários tipos de listas e árvores para a selecção de ficheiros:
Isto mostra uma árvore com a hierarquia de ficheiros por baixo da pasta do projecto. Se carregar num ficheiro, este é carregado no editor. Para os ficheiros que não contenham texto, o KDevelop inicia uma aplicação que possa lidar com o tipo MIME respectivo.
A árvore de ficheiros é actualizada regularmente, sempre que algo muda no sistema de ficheiros. Por exemplo, se criar ficheiros ou pastas novos (mesmo fora do KDevelop), isto é imediatamente reflectido na lista de ficheiros. No Linux®, esta funcionalidade tira partido da biblioteca FAM. No caso dos outros sistemas operativos ou do NFS, as pastas apresentadas são pesquisadas regularmente em pequenos intervalos de tempo.
A árvore de ficheiros esconde os ficheiros que não são normalmente interessantes, como os ficheiros-objecto. Nas , em , poderá configurar (como uma lista separada por vírgulas de caracteres especiais), quais os padrões que são usados para eliminar os ficheiros irrelevantes.
Para além disso, pode optar por restringir a árvore de ficheiros para mostrar apenas os ficheiros que pertençam ao projecto carregado no momento. Isto poderá ser activado ou desactivado se carregar com o botão direito do rato no item de topo da árvore.
Esta mostra os ficheiros que pertençam ao projecto, agrupados pela sua extensão do nome do ficheiro. Como na árvore de ficheiros, poderá editar um ficheiro se carregar nele com o botão do rato.
Os grupos mostrados nesta área poderão ser configurados na janela das . Para personalizar a área de acordo com as suas necessidades, é útil compreender como é que os ficheiros são distribuídos nos grupos. Para cada ficheiro, o KDevelop percorre todos os grupos de cima para baixo. Em cada grupo, verifica se o nome do ficheiro corresponde a cada um dos padrões. Se houver uma correspondência, o ficheiro é mostrado neste grupo e a iteração é interrompida. Isto torna claro que os padrões mais gerais devem ser colocados abaixo dos mais específicos. Por exemplo, um asterisco para o grupo Outros deverá ser o último padrão.
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
Ao lidar com um projecto numa linguagem orientada por objectos, a sua ênfase ao trabalhar no projecto não é nos ficheiros de código e nos seus nomes, mas sim nas classes e nas relações entre elas. Para o ajudar a navegar no espaço de classes e símbolos definidos, o KDevelop inclui vários navegadores de classes que visualizam a estrutura de classes de várias formas.
Esta área é mostrada do lado esquerdo da janela principal e contém uma lista linear com todas as classes, variáveis e funções do seu projecto. Está representada como uma árvore. Se você abrir o nó de uma classe ao carregar nele, irá aparecer uma lista com todos os métodos e atributos da classe respectiva.
A área de classes funciona de dois modos diferentes. Por omissão, todos os símbolos estão agrupados em “Classes”, “Estruturas”, “Funções”, “Variáveis” e “Espaços de Nomes”. No menu de contexto da área, poderá escolher a opção . Neste modo, a hierarquia do espaço de nomes é mostrada e os símbolos são agrupados pelo espaço de nomes respectivo em que são definidos. Isto poderá ser mais útil nos projectos que tirem bastante partido dos espaços de nomes (encadeados). É menos útil nos projectos sem espaços de nomes.
Poderá também alterar a forma com que os nomes das classes são apresentados. Normalmente, os nomes das classes aparecem sem o espaço de nomes em que foram definidas. Isto significa que você não consegue distinguir imediatamente as classes que tenham o mesmo nome em espaços de nomes diferentes. Se esperar um pouco com o cursor do rato sobre o item, irá aparecer o nome completo como uma dica. Poderá optar por mostrar sempre o nome completo da classe se escolher a opção no menu de contexto.
Se carregar numa classe ou método da área de classes, irá mostrar a sua definição. Poderá sempre saltar para a declaração de um método se escolher a opção no menu de contexto. No menu de contexto das classes, existem também os itens e . Isto irá abrir janelas onde poderá gerar novas declarações de métodos e variáveis nas classes respectivas, em conjunto com uma implementação vazia.
A janela de classes é activada se carregar com o botão direito numa classe da área de classes e escolher a opção .
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
A documentação, infelizmente, pertence às questões mais subestimadas da programação. Contudo, uma vez configurada devidamente e mantida a nível interno e externo, a documentação oferece uma ajuda muito valiosa.
A documentação tem várias facetas. Existe a
documentação interna do projecto, que consiste principalmente em
comentários nos ficheiros de código/inclusão
documentação interna da API do seu projecto, gerada a partir dos ficheiros do programa com ferramentas especiais, isto é Doxygen
documentação externa do projecto, que inclui, entre outras
a documentação externa da API de isto é bibliotecas do sistema comuns (KDE, Qt™, etc.)
qualquer outra documentação (manuais da linguagem de programação, informação de sistema geral, artigos e tutoriais, entre outros)
Toda esta documentação deverá ser fácil de manter e prontamente disponível sempre que necessitar dela. O KDevelop tem todas as capacidades para tal.
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
Este capítulo lida apenas com os projectos compilados, como os projectos de C++, Java ou Fortran. Os projectos para as linguagens de 'scripting' como o Python ou o PHP funcionam de forma bastante diferente.
Aqui irá encontrar informações acerca de:
Resumo do Automake Manager, que contém uma introdução ao Automake Manager,
A Operação com o Gestor Automake, que descreve as bases sobre como trabalhar com o Automake Manager,
No capítulo dos Sistemas de compilação devemos uma vista geral sobre os sistemas de gestão de compilações usados normalmente nos sistemas UNIX®. Nas secções seguintes iremos olhar para isto com mais detalhe.
Existe alguma confusão sobre o nome a dar estas coisas. A GNU chama-lhes “sistemas de compilação” quando descreve o Automake, o Autoconf e o Libtool. O QMake chama-se a si próprio “uma ferramenta para criar Makefiles para os vários compiladores e plataformas”. No KDE, é usado com frequência o termo “sistemas de gestão de projectos”. Iremos usar este termo num sentido mais abrangente para descrever os ambientes predefinidos do KDevelop que são usados para organizar e construir os seus projectos. No contexto desta secção, contudo, iremos ver mais sobre os “sistemas de compilação automatizados”.
Se você tiver um programa simples “Olá Mundo”, feito em C, você poderá compilá-lo e gerar o executável com o comando gcc -o ola ola.c e executá-lo com o comando ./ola, por isso você nem irá necessitar de uma Makefile.
Se você tiver uma aplicação em C com vários módulos e ficheiros de inclusão e só o vai executar na sua própria máquina (isto é., é uma aplicação caseira), você irá só necessitar de uma única Makefile, o que é relativamente simples de criar à mão (use o info Make para saber mais sobre o assunto).
As complicações começam quando:
O seu código, documentação, imagens, sons, traduções, ficheiros de dados, etc., estão localizados em mais do que uma directoria,
Você tem uma hierarquia de directorias e sub-pastas,
Você está a usar bibliotecas que não fazem parte do conjunto tradicional do UNIX®, com a biblioteca de Objectos do Qt™ ou as bibliotecas do KDE,
Você está a usar um pré-processador para gerar algum do seu código-fonte, como o pré-compilador MOC do Qt,
Você pretende distribuir a sua aplicação pelo mundo inteiro, para as pessoas que podem não ter o mesmo sistema UNIX®/Linux®, o mesmo 'software' e 'hardware' que você,
Você precisa de uma funcionalidade de Instalação e Desinstalação automática,
Você pretende tornar a sua aplicação parte do conjunto do Ambiente do KDE.
Se você tiver alguma ou todas as situações acima, você irá provavelmente necessitar de um sistema de compilações. No exemplo acima usámos o gcc para compilar e gerar o executável do programa “Olá Mundo”, mas nem todos os compiladores de C são chamados “gcc”. Por isso, se você distribuir a sua aplicação para alguém que esteja a usar outro compilador de C, a sua Makefile terá de alguma forma de usar o nome do compilador dessa pessoa, caso contrário a sua aplicação não irá conseguir compilar — e isto é apenas um exemplo simples do que poderá correr mal.
Um sistema de compilações irá limar estas diferenças para si.
Irá verificar se as bibliotecas que precisa estão presentes em cada máquina recebida,
irá percorrer automaticamente todas as directorias da sua aplicação à procura dos ficheiros a pré-processar, compilar ou instalar e
irá instalar os componentes da sua aplicação nas directoria de destino correctas, certificando-se que
as directorias são criadas na máquina de destino tal como é pedido.
Em resumo, um sistema de compilação oferece métodos seguros para a sua aplicação ser compilada e instalada correctamente em qualquer máquina de destino. Como foi mostrado acima na introdução aos Sistemas de Gestão de Projectos, o KDevelop oferece três sistemas de compilação automatizados e a opção para criar a sua própria Makefile (carregue nos nomes dos projectos para obter mais informações):
Os projectos do Automake que usam as ferramentas de programação normais da GNU.
Os projectos do QMake que usam o gestor de projectos QMake da Trolltech.
Os projectos do ANT que usam o gestor de projectos ANT do Apache para a programação em Java™.
Os projectos personalizados que deixam a seu cargo a manutenção das suas próprias Makefiles.
Tem de ser escolhida uma destas quatro alternativas quando você criar um projecto e a escolha é difícil de alterar mais tarde, por isso, você deverá pensar bem antes de começar.
Existem vários tutoriais disponíveis sobre o Sistema de Compilações da GNU (o Autoconf, o Automake e a Libtool), dos quais o Automake Manager tira partido.
Está disponível um breve tutorial do 'autoconf', feito pelo Christopher W. Curtis na página pessoal do KDevelop. Ele concentra-se em alguns passos básicos para modificar uma Makefile.
Poderá ser encontrado um tutorial mais detalhado em http://www.amath.washington.edu/~lf/tutorials/autoconf/toolsmanual_toc.html. Este faz parte de um conjunto maior de tutoriais sobre “Desenvolver 'software' com a GNU”.
Existe ainda o famoso “Livro da Cabra”, intitulado “Autoconf, Automake, and Libtool”. Este é uma introdução fácil de ler mas concisa de todos os aspectos principais das Autotools da GNU.
O Application Wizard terá configurado alguns ficheiros Makefile.am iniciais quando você criou um Novo Projecto de um tipo que use o Sistema de Compilações da GNU, como o ->->. Durante o desenvolvimento, o Automake Manager cria vários outros ficheiros Makefile.am para os projectos que usam o Sistema de Compilação da GNU e vai fazendo a manutenção dos mesmos, tal como o Application Wizard e o Automake Manager os criaram.
Existirá um ficheiro Makefile.am por cada directoria do seu projecto que contém os ficheiros a ser compilados ou instalados. Irá conter as suas especificações para compilar, gerar e instalar os ficheiros e uma referência a todas as sub-pastas que também tenham um ficheiro Makefile.am e, possivelmente, alguns ficheiros para compilar, gerar e instalar.
As directoria do seu projecto e os ficheiros de código poderão estar estruturados com qualquer profundidade, ou você poderá preferir uma estrutura plana do projecto com todas as sub-pastas no nível de topo.
O objectivo do Sistema de Compilação da GNU é produzir estruturas de ficheiros de código que possam ser compilados, gerados e instalados em qualquer sistema UNIX® ou Linux® usando os comandos simples:
./configure make make install # Normalmente como "root".
e possam ser desinstalado com o comando make uninstall (normalmente como 'root').
Como é que isto funciona? Bem, o configure é um programa que
lida com os detalhes do sistema em que está a correr, como por exemplo o compilador e as bibliotecas que deve usar e onde é que estas se localizam, e então
cria ficheiros Makefile de forma recursiva, preenchendo as substituições nos respectivos ficheiros Makefile.in.
Os Makefile.in são ficheiros de “input” — modelos que fornecem informações básicas para as Makefiles a serem produzidas a partir deles, preenchendo alguma informação dependente do sistema. Eles são gerados pelo utilitário Automake a partir dos ficheiros Makefile.am.
O processo de passar de Makefile.am (.am significa ficheiros de modelo do “Automake”) para ficheiros Makefile é gerido automaticamente pelo Project Manager do KDevelop, usando o utilitário Autoconf, algumas macros de M4 e outras coisas que não merece a pena falar aqui.
Por isso, quando o make se executa, ele escolhe os pedaços correctos do ambiente actual, como os compiladores e as bibliotecas. De forma semelhante, o make install coloca os componentes da sua aplicação, como os executáveis, a documentação e os ficheiros de dados nos locais correctos para esse ambiente.
Se você distribuir a sua aplicação como um “TAR” (um único pacote comprimido que o KDevelop poderá criar para si), ele irá incluir os ficheiros Makefile.in e o programa configure, de modo a que o destinatário possa compilar, construir e instalar a sua aplicação sem terem o Automake, o Autoconf ou o KDevelop na máquina deles. Os ficheiros Makefile.am são também incluídos, para o caso de o destinatário precisar de fazer algumas modificações ao código-fonte.
As regras são ligeiramente diferentes se você distribuir o código através de um repositório da Web como o CVS do KDE.
Gera ficheiros Makefile.am nas sub-pastas que conhece como “sub-projectos”.
Actualiza os ficheiros Makefile.am à medida que a estrutura do projecto se altera.
Actualiza os ficheiros Makefile.am à medida que os ficheiros são adicionados ou removidos do projecto.
Aceita as definições de como os vários ficheiros deverão ser compilados ou instalados e modifica o Makefile.am de acordo com isso.
Aceita os parâmetros usados na compilação e na instalação (isto é, nomes de bibliotecas) e garante que eles são usados nos passos de compilação e geração de binários.
Um ficheiro Makefile.am tem linhas que contêm nomes de variáveis seguidos de um sinal de igualdade (=) e uma lista de ficheiros ou valores de parâmetros. As “variáveis” têm nomes com duas partes, como por exemplo bin_PROGRAMS, aplicacao_SOURCES ou kdelnk_DATA. A segunda parte é chamada de primária e representa algo a partir do qual compilar ou instalar. A primeira parte é chamada de prefixo e representa:
Uma directoria na qual fazer a instalação (p.ex., a bin),
Um qualificador para o primário (p.ex. novaaplicacao para SOURCES, indicando que os ficheiros de código indicados a seguir ao novaaplicacao_SOURCES vão gerar o novaaplicacao),
Um prefixo especial noinst (abreviatura de “no installation” ou “sem instalação”), é normalmente usado para listar os ficheiros de inclusão (.h),
Ou o prefixo especial EXTRA, para os elementos dependentes da configuração.
Para mais informações sobre o Automake e os ficheiros Makefile.am, vá a info Automake.
Basicamente, o Automake Manager cria e actualiza os nomes das variáveis e as listas de ficheiros ou parâmetros. Veja o exemplo seguinte de um Makefile.am para uma aplicação típica, chamada aplicacao.
## Makefile.am da 'aplicacao' # este é o programa que é instalado. O nome dele é usado para todas as # outras variáveis do Makefile.am bin_PROGRAMS = aplicacao # define os locais dos ficheiros de inclusão do X, qt e KDE INCLUDES = $(all_includes) # as localizações onde procurar as bibliotecas novaaplicacao_LDFLAGS = $(KDE_RPATH) $(all_libraries) # as bibliotecas com as quais compilar novaaplicacao_LDADD = $(LIB_KFILE) $(LIB_KDEPRINT) # quais os ficheiros que devem ser compilados para a 'novaaplicacao' novaaplicacao_SOURCES = main.cpp novaaplicacao.cpp novaaplicacaoview.cpp # estes são os ficheiros de inclusão do seu projecto noinst_HEADERS = novaaplicacao.h novaaplicacaoview.h # deixe que o 'automoc' faça a gestão de todos os ficheiros de meta-código (moc) METASOURCES = AUTO KDE_ICON = novaaplicacao # aqui é para onde irá o ficheiro 'kdelnk' kdelnkdir = $(kde_appsdir)/Utilities kdelnk_DATA = novaaplicacao.desktop # aqui é para onde irá o ficheiro de recursos da XML-GUI rcdir = $(kde_datadir)/novaaplicacao rc_DATA = novaaplicacaoui.rc AM_CXXFLAGS = -DA_MINHA_OPCAO_DO_PREPROCESSADOR_DE_C++
Como poderá ver, muitos dos itens do lado direito são símbolos no formato $(xxxx). Estas são variáveis de ambiente que são definidas no ambiente actual do KDE e que são substituídas pelos valores reais quando o ./configure gerar os ficheiros Makefile finais na máquina de destino.
Também, logo depois de você ter iniciado o KDevelop, é uma boa ideia correr o comando ./configure --help, que lhe irá mostrar o conjunto de coisas que você poderá alterar na altura da compilação ou da instalação, como por exemplo, para um ambiente de testes. Em particular, o comando:
./configure --prefix=/onde/voce/desejarirá redireccionar a instalação por completo para uma estrutura de directorias à sua escolha, alterando a variável interna
$(prefix) para o valor /onde/voce/desejar. Neste capítulo você irá encontrar uma descrição básica dos elementos do Automake Manager e como usá-los. Isto cobre:
A Janela do Automake Manager que descreve a estrutura básica da janela principal do Automake Manager.
A Janela Introdutória que descreve os elementos da sub-janela superior.
A Janela de Detalhes que descreve os elementos da sub-janela inferior.
O Navegar no Automake Manager lista algumas operações básicas que você poderá efectuar no Automake Manager.
Os Menus de Contexto no Automake Manager descreve as janelas que irão aparecer quando você seleccionar uma acção no Automake Manager.
 |
|
A janela de Introdução contém uma árvore de todas as directorias no seu projecto que contêm ficheiros de programas, documentação ou dados. Cada uma destas directorias contém um ficheiro Makefile.am e é reconhecida pelo Automake Manager como um subprojecto. Existem três sub-projectos típicos num projecto baseado no KDE, tal como é mostrado na ilustração acima:
src – ficheiros com código-fonte para a sua aplicação,
doc – o se manual do utilizador,
po – extracções das cadeias de caracteres dos seus ficheiros de código que necessitem de ser traduzidas para outras línguas (p.ex., os títulos das janelas, os nomes dos menus, os textos dos botões, das janelas e as mensagens de vários tipos).
Repare que o subprojecto doc tem sempre um subprojecto en, o qual você poderá ver se carregar no símbolo + ao lado da palavra doc. Isto acontece porque a língua de base para toda a documentação do KDE é o Inglês (en). Se a sua aplicação fizer parte do KDE, as equipas de tradução do KDE poderão traduzir a sua documentação a partir do Inglês para outras línguas e as traduções irão para outros sub-projectos como o pt (Português) ou para fr (Francês). Os textos do subprojecto po também poderão ser traduzidos e gravados noutros ficheiros do po, permitindo desta forma que a sua aplicação seja utilizada por pessoas que não percebam Inglês.
Os sub-projectos doc e po servem para diferentes fins. O doc contém a documentação, como os manuais do utilizador, enquanto que o po contém o texto traduzido da interface do utilizador que está integrado no código-fonte desta aplicação.
A janela de Introdução serve — entre outras coisas — como uma ferramenta de navegação. Se você seleccionar um subprojecto na janela da Introdução, os detalhes correspondentes serão mostrados na área de Detalhes.
A janela de Detalhes contém uma árvore com todos os ficheiros no subprojecto seleccionado de momento na Introdução, assim como as regras de compilação, geração e instalação para este subprojecto. Como tal, as duas áreas em conjunto poder-lhe-ão dar o acesso a todos os componentes da sua aplicação e a todas as informações sobre como compilar, gerar e instalar os itens.
A lista em árvore nos Detalhes tem dois níveis. O nível de topo consiste nos alvos do Automake Manager e o próximo nível contém as listas dos ficheiros que irão compor cada alvo.
Este conceito de um alvo para o Automake Manager difere de certa forma do que é um alvo nas Makefiles. Em resumo:
A definição de como deverá ser compilado, gerado ou instalado um conjunto de ficheiros é conhecido como um alvo no Automake Manager, mas apenas como uma variável no Automake em si.
Um alvo no make é normalmente algo de muito diferente, sendo o parâmetro de um comando make (p.ex. make install, make clean).
Contudo, algumas variáveis do Makefile.am representam, de facto, um sub-alvo subjacente no make.
Tanto na janela de Introdução como na de Detalhes, você poderá carregar com o botão esquerdo nos símbolos + ou -, juntos a um subprojecto ou nome de alvo para expandir ou contrair a árvore. Se fizer isso com um subprojecto na Introdução, ele irá mostrar ou esconder os sub-projectos no próximo nível abaixo (se existir). Se o fizer com um alvo na janela de Detalhes, ele mostra ou esconde a lista de ficheiros que vão para esse alvo.
Se você carregar com o botão do rato no nome de um ficheiro na janela de Detalhes, o ficheiro correspondente irá abrir na janela de edição do KDevelop.
Se você carregar com o botão do rato no nome de um subprojecto na área de introdução ou num alvo da janela de detalhes, esse nome fica realçado e alguns botões da barra de ferramentas ficam activos na parte superior dessa janela.
Recomenda-se que você use o botão direito do rato e os menus de contexto, em vez dos botões das barras de ferramentas, porque é muito mais fácil de ver e perceber o que é que eles fazem.
As operações nos sub-projectos e nos alvos têm efeitos de larga escala na estrutura, compilação, geração e instalação da sua aplicação.
Se você carregar com o botão do rato no nome de um subprojecto, alvo ou ficheiro, irá aparecer um menu, onde nele poderá seleccionar as acções a efectuar sobre o item em questão, como adicionar um alvo ao subprojecto, adicionar um ficheiro a um alvo ou remover logicamente o ficheiro seleccionado do seu alvo.
As seguintes acções explicam de forma resumida quais as operações que os menus disponibilizam e que irão aparecer, quando o botão direito do rato é carregado na janela do Automake Manager. Elas pretendem ser meramente introdutórias. Você irá obter descrições mais detalhadas para a maioria das operações num capítulo posterior.
Quando você carregar com o botão do rato no nome de um ficheiro na janela de Detalhes, irá aparecer o seguinte menu que lhe permite seleccionar uma de várias operações nesse ficheiro. Na ilustração por baixo, o ícone hi-16app-novaaplicacao.png foi seleccionado a partir do alvo Dados de ícone no 'novaaplicacao' do subprojecto novaaplicacao/src.
 |
|
Quando você carregar com o botão direito num alvo da janela de Detalhes, irá aparecer o seguinte menu que lhe permitirá seleccionar uma de várias operações sobre ele. Na imagem em baixo, o alvo novaaplicacao (Programa em bin) do subprojecto novaaplicacao/src estava seleccionado.
 |
|
Quando você carregar com o botão do rato num subprojecto da janela de Introdução, irá aparecer o seguinte menu que lhe permite fazer as alterações mais abrangentes à estrutura do seu projecto e à forma como é compilado, gerado e instalado. Você poderá usá-lo para expandir ou modificar a estrutura básica do projecto que o Application Wizard criou.
 |
|
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
(... ainda não escrito ...)
Makefile.in em Makefile
prefix = @prefix@ INSTALL = @INSTALL@ build_triplet = @build@ CXX = @CXX@
prefix = /home/ze/kde3 INSTALL = /usr/bin/ginstall -c -p build_triplet = i686-pc-linux-gnu CXX = g++
config.h.in em config.h
/* Defina se você tiver a 'libz' */ #undef HAVE_LIBZ /* O tamanho de um `int', tal como indicado pelo 'sizeof'. */ #undef SIZEOF_INT
/* Defina se tiver a 'libz' */ #define HAVE_LIBZ 1 /* O tamanho de um `int', tal como indicado pelo 'sizeof'. */ #define SIZEOF_INT 4
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
Quando tiver compiladores cruzados disponíveis, poderá compilar os seus programas para processadores e sistemas operativos diferentes do sistema operativo onde o KDevelop e o compilador estão a correr. A colecção de compiladores da GNU, o gcc, pode ser configurado e compilado como compilador cruzado se o compilar você mesmo. Consulte as páginas do 'info' do GCC para saber mais informações. Algumas das distribuições do Linux® também oferecem pacotes binários.
Um pacote baseado no automake pode ser compilado de forma cruzada se indicar a opção --host no programa 'configure' e definir as variáveis de ambiente CC e CXX para os executáveis dos compiladores cruzados. Muitas vezes poderá querer mudar entre uma versão compilada de forma cruzada e outra compilada para o seu sistema de desenvolvimento. Para tal, é vantajoso usar a capacidade de o KDevelop criar várias configurações de compilação, como é explicado em “Configurações de Compilação Múltiplas”. Logo que tenha criado uma nova configuração de compilação criada na janela ->, adicione a opção
--host=plataforma
às opções do 'configure'. O nome da plataforma é um tuplo no formato
cpu-fabricante-so
ou
cpu-fabricante-kernel-so
Para as várias combinações, poderá usar uma versão reduzida, como por exemplo i386-linux ou arm-elf.
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
O Qt/embedded é uma versão da biblioteca Qt™ que não usa o sistema de janelas do X, mas acede directamente ao 'framebuffer' nos sistemas Linux®. É por isso interessante para os sistemas embebidos com grandes restrições na utilização de memória do sistema completo. A sua API é completamente compatível com a versão para X11.
O desenvolvimento de uma aplicação para o Qt/embedded com o KDevelop não é muito diferente de desenvolver um programa para a versão em X11 do Qt™. De facto, pode usar a mesma base de código para ambas as versões. Se usar a gestão de projectos 'autoproject', poderá passar para a versão embebida, usando o argumento --enable-embedded no programa 'configure'. Poderá definir isto na janela de -> em Opções do Configure. Com a opção --with-qt-dir=DIR, poderá definir a pasta em que o Qt/embedded está instalado.
Após configurar e compilar a sua aplicação com estas opções, ela irá associar-se à biblioteca libqpe.so. Esta versão da sua aplicação não irá executar normalmente quando usar o X11. Para poder testá-la, execute-a sob o controlo do programa qvfb (Qt™ Virtual Frame Buffer). Isto é feito ao iniciar o qvfb e depois, ao iniciar a sua aplicação, com
aplicacao -qws -display QVFb:0Naturalmente, quando tiver uma versão funcional da sua aplicação, irá querer usá-la no processador-alvo. Para tal, será provavelmente conveniente criar várias configurações de compilação, como foi explicado acima, para que possa mudar rapidamente entre a versão em execução no seu sistema de desenvolvimento e a versão a correr no sistema-alvo.
As aplicações para o Qt/embedded irão executar normalmente como aplicações autónomas no dispositivo para o qual estão desenhadas. A Trolltech também suporta o Qtopia, que é uma colecção de aplicações para PIM, navegação Web e outras áreas diversas, funcionando em conjunto de forma consistente. É o ambiente-padrão, por exemplo, do Sharp Zaurus. Poderá criar aplicações que se integrem neste ambiente, usando o SDK do Qtopia. Isto implica fazer com que a classe da sua aplicação seja uma sub-classe de QPEApplication e compilar com a biblioteca libqpe.so. Se desenvolver a sua aplicação com a gestão de projectos 'autoproject', terá de adicionar --enable-qtopia às opções do 'configure'.
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
Para o C e C++, o KDevelop contém um depurador interno que está integrado directamente com o editor. Do ponto de vista técnico, está implementado como uma interface para o depurador multi-plataforma da GNU gdb através de um 'pipe'. O depurador poderá ser iniciado de várias formas:
Com a opção ->, o programa principal do seu projecto é carregado no depurador.
Se usar a opção ->->, poderá carregar um ficheiro de 'core' para a memória, o qual é gerado pelo 'kernel' do sistema operativo, quando o programa tiver estoirado (A geração de ficheiros 'core' poderá estar desligada no seu sistema; veja o ulimit(1)). Isto é útil para uma análise 'post-mortem' de um programa.
Com a opção ->->, poderá invocar o depurador sobre um programa já em execução. Irá ver uma lista de processos onde poderá seleccionar o processo que o depurador deverá capturar.
Lembre-se que a depuração só é possível se o seu projecto tiver sido compilado com as informações de depuração activas. Poderá ser activada na janela de . Quando esta opção estiver activa, o compilador gera dados adicionais que permitem ao depurador associar nomes de ficheiros e números de linha aos endereços do executável.
A interface do depurador oferece várias vistas “dentro” do processo:
Se tentar depurar um projecto sem informação de depuração, irá obter a mensagem Sem código... na barra de estado. Se tentar definir um ponto de paragem, é mostrado como Pendente (adicionar) na janela do ponto de paragem (ver abaixo).
Esta janela lista os valores de todas as variáveis locais no ponto de execução actual do programa. Ela cobre as variáveis na pilha de chamadas completa, isto é a função onde o processo foi interrompido, a função que chamou esta função, e assim por diante até à função main().
Outra ramificação nas variáveis contém as variáveis de vigia. Poderá configurar por si próprio as variáveis que são aqui mostradas. Tanto poderão ser vigiadas as variáveis locais como as globais. Poderá adicionar as variáveis se carregar no botão ou carregar em Return, enquanto o item Vigia estiver seleccionado. Eles poderão ser removidos de novo, através do menu de contexto.
(... ainda não escrito ...)
Esta janela permite-lhe ver e manipular os pontos de paragem. Lembre-se que o KDevelop usa o GDB, como tal, para compreender por completo as funcionalidades de depuração do KDevelop, deverá ler um pouco sobre o GDB.
Se quiser olhar para o código-fonte, os pontos de paragem estão definidos no kdevelop/languages/cpp/debugger/breakpoint.h.
Do lado esquerdo, a janela tem botões para:
Adicionar um ponto de paragem vazio
Editar o ponto de paragem seleccionado
Remover o ponto de paragem seleccionado
Remover todos os pontos de paragem
A parte principal da janela é uma tabela com 7 colunas. Cada linha da tabela é um ponto de paragem. As colunas são:
Opção de selecção
Tipo: um dos seguinte: Inválido, Ficheiro:Linha, Ponto de Vigia, Endereço, Função
Estado. Os valores são:
Activo
Inactivo: Cada ponto de paragem poderá estar “activo” ou “inactivo”; no último caso, não fará efeito no seu programa até que o active de novo.
Pendente (adicionar): um ponto de paragem fica marcado desta forma se não estiver disponível nenhuma informação de depuração. Na página do 'info' do GDB:
Se a localização de um dado ponto de paragem não puder ser encontrada, poder-se-á dever ao facto que a localização esteja numa biblioteca dinâmica ainda por carregar. Nesse caso, poderá querer que o GDB crie um ponto de paragem especial (conhecido por “ponto de paragem pendente”) que tentará resolver-se a si próprio no futuro, quando for carregada a biblioteca dinâmica adequada.
Pendente (limpar)
Pendente (modificar)
Localização no formato nome-ficheiro:número-linha
Condição
Ignorar a Contagem: Se este for um número QUANTIDADE maior que zero, as próximas QUANTIDADE vezes que o ponto de paragem for atingido, a execução do seu programa não irá parar; para além de decrementar o número de vezes a ignorar, o gdb não irá fazer nada.
Contagem: indica quantas vezes foi atingido um ponto de paragem.
(... ainda não escrito ...)
No C++, os nomes das funções no executável são “codificados”, isto é os nomes das funções incluem a informação sobre os tipos de argumentos recebidos. Isto é necessário para suportar a sobreposição ('overloading') de funções. O algoritmo de codificação não é normalizado e difere mesmo entre várias versões do compilador de C++ da GNU.
Na janela de descodificação, são mostrados os nomes normalmente descodificados, como tal as assinaturas das funções irão aparecer como existem no código-fonte, por isso são fáceis de ler. Em alternativa, poderá querer ver os nomes codificados.
A infra-estrutura do depurador gdb não permite definir pontos de paragem em código que ainda não está carregado de momento. Numa aplicação altamente modular, onde muitas vezes o código só é carregado a pedido, como um 'plugin' (com a função da 'libc' dlopen(3)), isto poderá ser inconveniente. Como tal, o KDevelop contém o seu próprio suporte para os pontos de paragem em bibliotecas dinâmicas. Se definir esta opção, ela permitir-lhe-á definir pontos de paragem nas bibliotecas que ainda não estão carregada. Aí, sempre que o gdb notificar que uma biblioteca vai ser carregada, o KDevelop tentará definir os pontos de paragem pendentes.
(... ainda não escrito ...)
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
O CVS é o sistema de controlo de versões que muitos dos projectos 'open-source' - incluindo o KDE — usam. Ele grava todo o código num sítio local, chamado de repositório. A partir do repositório, os programadores poderão obter uma versão actualizada do projecto (ou partes dele) em qualquer altura. Em contraste com outros sistemas de controlo de versões, não é necessário bloquear os ficheiros em que uma pessoa deseja trabalhar. Como tal, o desenvolvimento poderá ser altamente paralelizado.
Sempre que um programador terminar uma tarefa, ele envia o seu código (acompanhado de uma mensagem de registo). O CVS tem a seu cargo a junção das alterações feitas pelos vários programadores. Poderá acontecer, obviamente, que os programadores trabalhem no mesmo pedaço de código, o que irá resultar num conjunto de alterações em conflito (na prática, isto ocorre raramente, e normalmente é sintoma de falta de comunicação). Nesse caso, o CVS rejeita um envio; só após todos os conflitos terem sido resolvidos é que um ficheiro poderá ser enviado.
Até agora, isto foi uma descrição das funcionalidades básicas do CVS com que uma pessoa tem de lidar normalmente. Mas o CVS oferece bastante mais: poder-se-ão manter várias ramificações de um projecto (isto é o KDE 1.1.2 e o KDE 2 eram ramificações da árvore de desenvolvimento do KDE), reunir as modificações de uma ramificação noutra, pedir as diferenças entre versões, o histórico de versões de ficheiros etc.
O CVS está implementado como um sistema cliente-servidor. Como utilizador, toda a comunicação com o repositório é feita através do programa da linha de comandos CVS. Está disponível uma interface de nível mais elevado através das interfaces existentes, como o Cervisia (http://cervisia.sf.net) ou o TkCVS (http://tkcvs.sf.net). No KDevelop, só uma pequena parte da funcionalidade do CVS é relevante para o seu trabalho diário e que poderá ser usada directamente.
Assume-se um conhecimento básico da utilização do CVS. Em particular, deverá saber como obter um dado projecto do seu repositório. Recomenda-se o livro “Open Source Development With CVS” de Karl Fogel, o qual está disponível de forma livre (excepto os capítulos não-técnicos). Veja em http://cvsbook.red-bean.com/cvsbook.html.
Na árvore de ficheiros, estão disponíveis os seguintes itens do menu de contexto:
Prepara o ficheiro marcado para ser adicionado ao repositório. O ficheiro é transferido para o mesmo quando o enviar (ou a pasta que o contém) da próxima vez.
Prepara um ficheiro para ser removido do repositório. Isto remove também o ficheiro do sistema de ficheiros local, como tal use esta funcionalidade com cuidado!
Execute o cvs update para reunir as modificações dos outros utilizadores na sua pasta de trabalho. Quando usar este item do menu sobre uma pasta, a actualização irá acontecer normalmente de forma recursiva, excepto se tiver desactivado essa possibilidade no ficheiro de configuração .cvsrc.
Executa o cvs commit para enviar as modificações locais para o repositório. Lembre-se que deverá fazer uma actualização local antes de fazer isto. Caso contrário, quando outro utilizador tiver enviado as suas modificações antes, o CVS poder-lhe-á mostrar uma mensagem de erro.
Todos estes comandos são invocados como sub-processos pelo KDevelop sem quaisquer outras opções da linha de comandos ou variáveis de ambiente. Isto poderá ser um problema quando a ligação ao servidor de CVS for através de uma ligação de ssh e você tiver de indicar a sua senha, sempre que envia ou recebe as actualizações. Isto é, por exemplo, necessário quando o seu projecto está alojado no sourceforge.net. As soluções alternativas para este problema estão descritas na FAQ do CVS/SSH, que poderá encontrar na documentação do SourceForge.
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
O conteúdo inicial deste manual foi escrito pelo Bernd Gehrmann (bernd AT kdevelop.org) e pelo Caleb Tennis (caleb AT aei-tech.com).
Os capítulos Resumo do Automake Manager e Operação do Gestor Automake foram escritos pelo Ian Wadham, (ianw AT netspace.net.au)).
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
Índice
Você irá encontrar aqui todos os passos necessários para compilar e instalar o IDE do KDevelop:
O Como obter o KDevelop concentra-se principalmente em como obter o código mais recente do CVS.
Os requisitos do KDevelop listam os programas e bibliotecas que irá necessitar de ter instalados para compilar com sucesso o IDE.
A compilação e instalação do KDevelop irá conduzi-lo por todos os passos de compilação e instalação da aplicação.
O Como obter uma documentação da API do KDevelop diz-lhe o que é uma API e como você poderá usar uma dessas ferramentas para navegar pelo código do KDevelop.
O KDevelop está disponível de forma binária para várias distribuições do Linux® como a SuSE, a RedHat entre outras. Estes binários estão inseridos num pacote, em grande parte em RPMs, para uma instalação mais simples. Para instalar, siga as instruções normais que são dadas para a sua distribuição.
Você também poderá obter o código-fonte do KDevelop, compilá-lo e instalá-lo você mesmo. Este código poderá ser obtido na página pessoal do projecto em http://www.kdevelop.org ou através do 'site' FTP do KDE.
Se você quiser estar a acompanhar os desenvolvimentos actuais, estão disponíveis as imagens do repositório anónimo do CVS. O nome do módulo é kdevelop em :pserver:anonymous@anoncvs.kde.org:/home/kde.
Para obter uma versão inicial do KDevelop, você precisa de obtê-la a partir do CVS anónimo. Para efectuar esta operação, com o nome de checkout, basta seguir estes passos.
Iremos assumir que você irá querer pôr a sua cópia do KDevelop na pasta codigo_kde3 da sua directoria pessoal (a ~) .
| # Criar a directoria de destino, se necessário: |
~> mkdir codigo_kde3 |
~> cd codigo_kde3 |
~/codigo_kde3> cvs -z3 -d :pserver:anonymous@anoncvs.kde.org:/home/kde co kdevelop |
~/codigo_kde3> cd kdevelop |
Logo que tenha conseguido obter a sua versão do KDevelop, você poderá estar a par das alterações com o procedimento de actualização mostrado na secção a seguir.
Mantenha a carga no servidor baixa. Por favor não faça a transferência completa ('checkout'), sempre que queira ter o seu KDevelop actualizado! Utilize para isto uma actualização de CVS.
Agora, você poderá compilar a sua versão do KDevelop, tal como é mostrada no capítulo de Compilação e Instalação do KDevelop.
Depois de você ter obtido (e compilado com sucesso) o KDevelop a partir do CVS, tal como foi mostrado em cima, você poderá querer mantê-lo actualizado, de modo a obter todas as modificações. Para isso, siga estes passos (Iremos assumir de novo que você colocou a sua cópia do KDevelop na directoria codigo_kde3.)
Repare no comando up (= update), colocado em vez do co (que significa checkout).
~> cd codigo_kde3 |
~/codigo_kde3> cvs -z3 -d :pserver:anonymous@anoncvs.kde.org:/home/kde up kdevelop |
~/codigo_kde3> cd kdevelop |
Dê uma vista de olhos nas mensagens que o CVS produz, durante a sequência da actualização. Os passos exactos na sequência de compilação dependem disto.
Agora, você poderá compilar uma nova versão do KDevelop, tal como é apresentado no capítulo das Considerações especiais de compilação do CVS.
Para poder compilar e usar o KDevelop com sucesso, você precisa dos seguintes programas e bibliotecas. Eles estão disponíveis na maioria das plataformas como pacotes das próprias distribuições e, como tal, poderão ser instalados facilmente.
Necessário:
gcc/g++ ≥ 2.95.3 (ou compatível)
Disponível em gcc.gnu.org
Disponível em www.gnu.org/software/make
Disponível em www.perl.com
Disponível em www.gnu.org/software/autoconf
Disponível em www.gnu.org/software/automake
Disponível em www.gnu.org/software/flex
Disponível em www.trolltech.com/products/qt
Disponível em www.kde.org
Opcional:
A ferramenta de navegação no código ctags, a partir do 'site' http://ctags.sourceforge.net, que lhe permite aceder rapidamente às declarações e definições, através de uns simples 'clicks' nos nomes dos itens, dentro do editor.
O dot, um compilador de linguagens gráficas, do http:/www.graphviz.org. Esta ferramenta é necessária, em conjunto com o Doxygen, se você quiser ter as relações entre as classes desenhadas graficamente (o que é altamente recomendado).
A ferramenta de documentação Doxygen, do http://www.doxygen.org, se você quiser gerar documentação de APIs concisa e poderosa para os seus projectos.
O valgrind de http://developer.kde.org/~sewardj/, que lhe ajuda a encontrar problemas de gestão de memória nas suas aplicações.
O CVS do http://www.cvshome.org se você quiser usar o sistema de controlo de versões CVS.
Qualquer outro compilador e/ou ferramenta, para o caso de você querer programar noutra linguagem/plataforma que não o C++/KDE ou queira usar alguma funcionalidade especial.
Você poderá dar uma volta à necessidade do autoconf ≥ 2.52 e do automake ≥ 1.6. Basta remover a directoria admin da directoria de instalação do seu KDevelop e escrever
(a-sua-directoria-do-kdevelop)> ln -s $KDEDIR/share/apps/kdelibs/admin admin |
na consola. Isto faz com que o KDevelop use a configuração normal da directoria admin do KDE em alternativa.
Tenha cuidado em não misturar as versões do Qt™. Associe sempre o KDevelop à mesma versão do Qt™ com que as suas bibliotecas do KDE foram compiladas. Caso contrário, você poderá obter comportamentos muito estranhos.
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
Logo que todos os requisitos tenham sido cumpridos, você está pronto para compilar e instalar o KDevelop. Este apêndice irá discutir os passos necessários para o fazer.
Os Passos Preliminares dizem-lhe como configurar um ambiente adequado.
O Compilar o KDevelop lida com a obtenção do código do KDevelop a partir do CVS, como o preparar para o processo de instalação e finalmente mostra os passos necessários para compilar e instalar o KDevelop.
O Algumas Notas Sobre as Opções do 'Configure' diz-lhe como executar o KDevelop se tiver sido instalado numa localização que não a directoria do KDE.
Antes de entrar na sequência da consola, você precisa de se certificar que todas as bibliotecas e ferramentas estão disponíveis no sistema de compilação. Para conseguir isto, algumas variáveis de ambiente precisam de estar convenientemente definidas. Os passos reais a efectuar dependem da linha de comandos da consola que você utiliza.
Para evitar ter de escrever todos os comandos que definem as variáveis de ambiente necessárias de cada vez que deseja compilar, você deverá colocá-las no seu ficheiro .bashrc ou .cshrc. Desta forma, as variáveis de ambiente serão configuradas convenientemente sempre que você iniciar a linha de comandos.
Se você usar a linha de comandos 'bash', adicione as seguintes linhas:
export KDEDIR=(local da sua instalação do KDE) |
export QTDIR=(local da sua biblioteca Qt) |
export LD_LIBRARY_PATH=$QTDIR/lib:$KDEDIR/lib:$LD_LIBRARY_PATH |
export LIBRARY_PATH=$QTDIR/lib:$KDEDIR/lib:$LIBRARY_PATH |
export PATH=$QTDIR/bin:$KDEDIR/bin:$PATH |
Se você usar a linha de comandos 'tcsh', adicione as seguintes linhas:
setenv KDEDIR (local da sua instalação do KDE) |
setenv QTDIR (local da sua biblioteca Qt) |
setenv LD_LIBRARY_PATH=$QTDIR/lib:$KDEDIR/lib:$LD_LIBRARY_PATH |
setenv LIBRARY_PATH $QTDIR/lib:$KDEDIR/lib:$LIBRARY_PATH |
setenv PATH $QTDIR/bin:$KDEDIR/bin:$PATH |
Na discussão a seguir, assumimos que você colocou o código do seu KDevelop na directoria ~/codigo_kde3/kdevelop.
No caso de você usar uma imagem do KDevelop do CVS, os passos de compilação iniciais dependem se você fez um 'checkout' completo ou se apenas actualizou o código.
Você deverá inicializar o sistema de compilação depois de um 'checkout' completo. O mesmo se aplica de cada vez que você inicia a extracção do zero. Escreva:
~/codigo_kde3/kdevelop> make -f admin/Makefile.common cvs-clean |
e depois todos os passos a seguir.
Você poderá necessitar de acesso ao repositório do CVS para a limpeza, se alguns ficheiros corrompidos ou em falta precisarem de ser reconstruídos.
O comando cvs-clean irá remover todos os ficheiros que não pertençam ao CVS na directoria! Certifique-se que salvaguarda todas as informações valiosas, antes de executar este comando de limpeza.
O próximo passo depende do resultado da sequência de actualização do CVS. Se você obteve algo do género do que se segue (repare na marca U ou P à esquerda, o que indica que o ficheiro foi alterado):
U /uma_directoria_qualquer/Makefile.am
ou se você fez uma extracção completa, você precisa de fazer:
~/codigo_kde3/kdevelop> make -f Makefile.cvs |
antes de prosseguir com todos os passos a seguir.
Logo que o sistema básico do 'make' tenha sido configurado desta forma, você precisa de decidir o tipo de sistema do KDevelop que você deseja usar. Isto é feito com o seguinte passo do 'configure' que compila a Makefile real que o comando make irá usar.
Você poderá ignorar a opção --prefix das seguintes linhas de comando do configure se você quiser que o KDevelop seja instalado na directoria predefinida do KDE. Veja o capítulo com Algumas notas sobre as opções do configure para saber mais sobre o assunto.
Se você quiser manter um registo do que a sua aplicação KDevelop faz durante a sua execução, poderá criar uma versão compilada com informações de depuração. Basta correr o comando configure para o fazer:
~/codigo_kde3/kdevelop> ./configure --enable-debug=full --prefix=(onde-está-o-seu-kde3) |
Se você só quiser usar o KDevelop tal-como-está (mais pequeno e mais rápido) basta a versão para produção. O configure fica deste modo da seguinte forma.
~/codigo_kde3/kdevelop> ./configure --prefix=(onde-está-o-seu-kde3) |
Se você quiser criar a sua própria documentação da API para o KDevelop, você precisa de incluir ainda mais outra opção do comando configure:
~/codigo_kde3/kdevelop> ./configure --(opções-acima) \ |
--with-kdelibsdoxy-dir=$KDEDIR/share/doc/HTML/en/kdelibs-apidocs |
O configure irá verificar o sistema e criar uma Makefile de acordo com o que encontrou. O comando make irá usar esta Makefile por omissão. Deste modo, o
~/codigo_kde3/kdevelop> make |
será suficiente. Se necessário, obtenha agora permissões de 'root' se fizer
~/codigo_kde3/kdevelop> su |
e indique a senha do 'root'. Instale então agora a aplicação:
~/codigo_kde3/kdevelop> make install |
E foi tudo. Se você instalou o KDevelop na directoria por omissão do KDE, você poderá agora correr o IDE. Caso contrário, serão necessários alguns passos adicionais como é demonstrado na secção Directoria de instalação personalizada em baixo.
De facto, já terão sido instaladas normalmente três aplicações baseadas no KDevelop:
O IDE do KDevelop — este é o local onde você normalmente irá trabalhar.
O navegador de documentação do Assistente do KDevelop autónomo — isola todas as funcionalidades poderosas de documentação do IDE KDevelop numa ferramenta separada. Isto pode ser útil quando desejar procurar por alguma documentação de programação mas não queira iniciar o IDE por completo.
O Desenhador do KDevelop — aumenta o Qt™ User Interface Designer, adicionando os elementos específicos do KDE e integra-se bem no IDE KDevelop.
Por omissão, o configure prepara o IDE para ser instalado na directoria predefinida do KDE. Isto é necessário porque o KDevelop assume o acesso directo a algumas ferramentas e componentes que se encontram aí. Se você quiser usar a sua própria directoria de instalação, você terá de dizer isso ao configure com a opção --prefix:
~/codigo_kde3/kdevelop> ./configure --prefix=(onde-está-o-seu-kde3) |
Existe uma contrapartida se o fizer. Você precisa de arranjar uma forma de o KDevelop aceder às ferramentas e componentes necessários na directoria do KDE. (Você poderá à mesma usar o IDE sem o fazer, mas terá as capacidades bastante restritas).
Invoque uma linha de comandos e execute os seguintes comandos antes de iniciar o KDevelop na linha de comandos.
Tenha cuidado em usar o plural: É o “KDEDIRS”, não apenas o “KDEDIR”)
(a-sua-directoria-do-kdevelop)> export KDEDIRS=/usr/local/kde:/opt/kde3 |
~> kbuildsycoca |
| (Agora inicie o KDevelop:) |
~> kdevelop |
A variável de ambiente KDEDIRS precisa de apontar para a lista de directorias activas do KDE do seu sistema. É usado |
/usr/local/kde:/opt/kde3 |
| apenas como exemplo. |
A directoria /usr/local/kde poderá, por exemplo, conter uma versão incompleta do KDE que você tenha compilado para fins de depuração e a /opt/kde3 poderá, por sua vez, conter a versão normal do KDE para a sua distribuição usada no dia-a-dia. |
Numa linha de comandos 'tcsh' você precisa de definir as variáveis de ambiente usando:
~> setenv KDEDIRS /usr/local/kde:/opt/kde3 |
O comando kbuildsycoca (“build system control cache” ou “construir a 'cache' de controlo do sistema”) procura as bibliotecas e coloca em 'cache' a sua localização e versão, para que o KDevelop possa então encontrá-las. A contrapartida é que leva bastante tempo — e tem de ser corrida sempre que você você invoque a linha de comandos para iniciar o KDevelop a partir de uma directoria não-predefinida. Você poderá querer colocar os comandos acima num 'script' para reduzir o esforço de escrita.
(Você poderá também colocar as mesmas linhas no seu .bashrc ou .cshrc, mas isso não é aconselhável, dado que o kbuildsycoca irá então ser executado sempre que você chamar a linha de comandos).
O comando kbuildsycoca não se executa a partir da raiz. Você terá de o invocar com um utilizador que não o 'root'. (Mas não é uma boa ideia, de qualquer forma, programar com o utilizador 'root'!)
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
API é a abreviatura de “Application Program Interface” ou “Interface de Programação de Aplicações”. De facto, uma interface de programação desse tipo é um conjunto de descrições (isto é, convenções de chamadas) pelas quais uma aplicação acede ao sistema operativo ou a outros serviços. No nosso contexto, todavia, foi adoptada uma definição mais abrangente. A API de uma aplicação do KDE ou do Qt™ é um resumo das interfaces das classes e dos métodos, uma sinopse a ser usada como um dicionário para navegar pelo código.
Existe uma versão da API mais actual disponível na página Web do KDevelop. Ele será actualizado automaticamente a cada 24 horas, para que você se possa manter a par.
Bem, esta versão poderá ser usada apenas para leitura na Internet. Mas, de qualquer forma, você poderá criar também a sua própria documentação da API a partir do código do KDevelop. Para o fazer, você precisa de dizer ao sistema do 'automake' onde encontrar a API das KDELIBS no seu sistema. Isto é feito com a opção --with-kdelibsdoxy-dir no comando configure:, quando se preparar para compilar o código do KDevelop:
~/codigo_kde/kdevelop> ./configure --(opções-normais) \ |
--with-kdelibsdoxy-dir=$KDEDIR/share/doc/HTML/en/kdelibs-apidocs
|
(o make irá substituir o $KDEDIR pela sua directoria real do KDE). Depois disso, execute um comando make normal. Depois de o IDE do KDevelop ter sido criado, você terá a opção para criar a API também. Para isso, você terá de executar
~/codigo_kde3/kdevelop> make apidocs |
Isto irá criar um ficheiro Doxyfile na sua directoria de base do KDevelop que irá, por sua vez, ser processado pela aplicação DOxygen para criar um conjunto grande de ficheiros .html com a API. Quando o processo relativamente longo de criação da API chegar finalmente ao fim, você terá de instalar a API tal como se fosse instalar o IDE KDevelop em si. Obtenha as permissões de super-utilizador, se necessário,
~/codigo_kde3/kdevelop> su |
e indique a senha do 'root'. Instale então os ficheiros da API:
~/codigo_kde3/kdevelop> make install-apidox |
Quando isto tiver sido feito, o make informá-lo-á sobre a directoria onde você poderá finalmente ver o conteúdo da documentação da API. Lembre-se deste endereço, dado que o poderá usar tanto no Konqueror como dentro do KDevelop, no caso de você ter configurado o código do KDevelop como um projecto sobre o qual trabalhar.
Você irá ver provavelmente um grande conjunto de mensagens de aviso e/ou erro durante a criação da API executada pelo Doxygen. É melhor ignorá-las, dado que são apenas do interesse dos programadores do KDevelop. Se a geração da API chegar alguma vez ao fim com sucesso, os ficheiros da API em .html serão válidos.
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
A informação deste capítulo pretende ser uma referência rápida para uma introdução ou se você (momentaneamente) se esqueceu de algum conceito básico. Existem também dicas rápidas para saber como resolver alguns problemas comuns ao trabalhar com o KDevelop.
Se quiser mais informações sobre determinado tópico, basta seguir a ligação no título que inicia esse aviso.
Está disponível alguma informação sobre os seguintes tópicos:
| Aparência e Comportamento |
| Projectos |
| Compilação |
| Automake Manager |
| Problemas na Compilação/Make |
| Outros Tópicos |
Aparência e Comportamento
Por omissão, o KDevelop começa com páginas de ferramentas grandes baseadas em texto, em torno da área de trabalho. Poderá alterar esta aparência para isto é poupar espaço na janela de configuração do KDevelop (->->).
Se você usar uma versão mais antiga do KDevelop 3, esta janela de configuração poderá não estar disponível. Para mudar a visualização das páginas de ferramentas, coloque um item MDIStyle da marca [UI] do seu ficheiro de configuração $KDEHOME/share/config/kdeveloprc, como se segue:
MDIStyle=0: apenas os ícones |
MDIStyle=1: apenas o texto (por omissão) |
MDIStyle=3: ícones e texto |
Se reparar em letras coloridas por todo o lado (isto é nas páginas, barras de ferramentas, etc.) e a janela do KDevelop parecer estar a usar um estilo de visualização errado, isto poderá ajudar:
No seu ficheiro de configuração $, descubra a linha que contém “KDEHOME/share/config/kdeveloprcStyle=Checked” e remova-a. Depois, reinicie o KDevelop.
(Este comportamento acontece às vezes, depois de ter carregado num ficheiro UI de um dos navegadores de ficheiros e o KDevelop conseguiu de facto abrir o KUIViewer para mostrar a GUI que foi produzido a partir deste ficheiro.)
Seleccione a opção -> dos menus ou carregue em Ctrl-Shift-F.
Para esconder o menu, seleccione a opção -> dos menus ou carregue em Ctrl-M. Para voltar a mostrar o menu, só está disponível o Ctrl-M.
Projectos
O -> irá iniciar o Application Wizard.
Não existe qualquer forma directa de criar um projecto personalizado (isto é um projecto que usa as suas próprias Makefiles). Use a opção -> em alternativa. Lembre-se de definir o Tipo de Projecto apropriado, indicado por um “(Makefiles personalizadas)”, na janela.
Sempre que iniciar um projecto novo, não se esqueça de configurar o -> de acordo com a sua necessidade.
Compilação
Se, durante as compilações, notar que falta alguma informação valiosa na Janela de Resultado das Mensagens, poderá ser devido ao facto de o nível de detalhe das mensagens estar demasiado baixo. Carregue com o botão do rato na janela e seleccione outro nível de detalhe do menu de contexto.
Seleccione o sub-projecto na metade superior do Automake Manager, depois carregue com o botão do rato na metade inferior nos títulos dos grupos a que deseja adicionar os ficheiros e seleccione a opção .
Seleccione o sub-projecto na metade superior do Automake Manager, depois carregue com o botão do rato na metade inferior nos títulos dos grupos a que deseja adicionar os ficheiros e seleccione a opção .
Seleccione o sub-projecto na metade superior do Automake Manager, depois carregue com o botão do rato na metade inferior nos títulos dos grupos de que deseja remover os ficheiros e seleccione a opção .
Problemas na Compilação/Make
Existe um problema com o sistema do automake/autoconf. Se a opção -> oferecer para selecção as opções de três pastas de compilação: , e , tente-se manter sempre ou no 'default' ou nos alvos 'debug'/'optimized'.
Logo que tenha configurado o seu projecto com o 'default', nunca mais irá compilar com o 'debug' ou o 'optimized'.
Logo que tenha configurado o seu projecto com o 'debug' ou o 'optimized', nunca mais irá compilar com o 'default'.
Existem várias mensagens de erro relacionadas com as versões demasiado antigas do autoconf etc. que impedem que o configure funcione convenientemente. Execute o autoreconf na árvore de pastas onde estão os ficheiros configure.in em questão. Este comando irá tentar actualizar a informação dos ficheiros do Sistema de Compilação da GNU. Veja o man autoreconf para mais informações.
Outros Tópicos
Normalmente não terá de se preocupar, mas isto é muito útil de saber, no caso de algo correr mal com a sua configuração.
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
Índice
Desde o início, o UNIX® tem mantido dois paradigmas de programação bastante diferentes. Um é o mundo das linguagens de programação das aplicações e do sistema, onde algum código-fonte é traduzido para código-máquina por um programa de tradução, normalmente um compilador ou um interpretador. A linguagem de programação C é um exemplo. O UNIX® foi o primeiro 'kernel' de sistema operativos a ser criado numa dessas linguagens de alto nível, em vez de ser feito em Assembly altamente orientado à máquina, como era feito antes dessa altura. (De facto, a linguagem C foi mesmo inventada para escrever o 'kernel' do UNIX® e os programas associados num computador PDP-11 da DEC.)
O outro paradigma é o mundo das linguagens de 'scripting'. Este mundo evoluiu com a invenção da linha de comandos do UNIX®, que era a interface do utilizador com o sistema operativo — e ao mesmo tempo uma linguagem de programação de muito alto nível. Um 'script' da linha de comandos é criado a partir de um conjunto de pequenos programas utilitários, como p.ex. o grep, o sed ou o find. Cada um desses utilitários é desenhado para uma tarefa estritamente definida. O truque é cada utilitário pode ser ligado a outro através de um mecanismo simples de transporte, chamado de pipe, o qual direcciona o resultado do utilitário anterior para o canal de introdução de dados do utilitário a seguir. Isto cria uma ferramenta de programação muito poderosa e altamente flexível.
À medida que o tempo foi evoluindo, também ambos os mundos foram evoluindo. Embora o C ainda seja usado principalmente como uma linguagem de programação de sistemas, o C++, como uma variante do C, enriqueceu com extensões orientadas a objectos e com genericidade e encontrou o seu lugar para o desenvolvimento de aplicações complexas nos anos 90. Existem outras linguagens de programação diversas, e mesmo algumas linguagens mais antigas ainda têm lugar — o FORTRAN77 e o Ada p.ex. ainda têm a sua força nas aplicações numéricas.
Na área do 'scripting', houve um ligeiro desvio da linha de comandos, que sofre de problemas de portabilidade, para as linguagens que unificam todas as funcionalidades comuns necessárias para as suas bibliotecas-padrão, embora sejam à mesma capazes de interagir com o exterior através de 'pipes' se necessário.
Todas essas linguagens de 'scripting' têm em comum o facto de serem altamente portáveis entre as variantes de UNIX®, Microsoft® Windows®, Mac® OS ou até mesmo o VMS. Do mesmo modo, todas elas têm implementações distribuídas de forma gratuita.
O Perl tornou-se popular como uma linguagem de processamento de texto e de administração de sistemas. No início da World Wide Web, os 'scripts' CGI escritos em Perl eram uma forma usada em grande medida para criar páginas Web dinâmicas a partir de bases de dados. Hoje em dia, este método foi substituído em grande parte pelo 'plugin' mod_perl do servidor Web Apache. Entre as potencialidades do Perl encontra-se o seu suporte incorporado para correspondência de expressões regulares avançado e o seu arquivo rico de módulos distribuídos gratuitamente.
Para mais informações veja o 'site' Web do Comprehensive Perl Archive Network (CPAN).
O Python brilha pela elegância do seu sistema de classes e pela facilidade e flexibilidade com que as bibliotecas externas conseguem ser incorporadas, de forma a aparecerem como classes e funções normais do Python. Em contraste com o Perl, o Python tem uma API embebida clara e concisa, o que o torna a linguagem de escolha para tornar os programas em C ou C++ utilizáveis em 'scripts'.
O PHP foi inventado como uma linguagem directamente incorporada nas páginas HTML e, por consequência, tem as suas utilizações principais a distribuir conteúdo dinâmico na Web.
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
As aplicações de UNIX® de alto-nível normalmente perdem a velocidade e flexibilidade dos mecanismos de 'scripting' da linha de comandos tradicional. Isto é especialmente verdadeiro no mundo das interfaces gráficas do utilizador (GUI) como isto é o KDE.
Têm existido algumas tentativas de oferecer mecanismos semelhantes que irão funcionar num nível aplicacional mais elevado, como o CORBA e, no ambiente do KDE, o DCOP.
O CORBA (Common Object Request Broker Architecture) é uma tentativa para permitir as aplicações informáticas trabalharem em conjunto numa rede. Foi originada pelo comité normativo, privado e independente do distribuidor da OMG (Object Management Group).
Os programas baseados em CORBA usam o protocolo-padrão IIOP para comunicarem. As implementações baseadas no IIOP estão disponíveis num vasto conjunto de sistemas operativos, linguagens de programação e redes, sendo assim multi-plataforma.
A desvantagem principal do CORBA é a sua velocidade relativamente baixo. Embora isto possa ser suportável em redes, é um grande entrave para as comunicações entre aplicações num ambiente sem rede, como por exemplo o KDE a correr num único computador.
Outra evolução do 'scripting' semelhante ao UNIX® é o protocolo DCOP, o qual foi destinado à comunicação entre as aplicações do KDE para ultrapassar as limitações do CORBA.
O DCOP significa Desktop COmmunikation Protocol e está implementado como um mecanismo simples de IPC/RPC para operar sobre 'sockets'. De facto, isto fornece funcionalidades semelhantes às do mecanismo tradicional de 'pipes' do UNIX®.
O 'scripting' de linha de comandos tradicional é baseado em programas utilitários relativamente pequenos que foram desenhados para funcionarem de uma forma textual muito restrita. O DCOP permite aos programas gráficos elaborados comunicarem uns com os outros de uma forma muito semelhante. Isto permite isto é a um programa do KDE enviar mensagens a outro programa do KDE ou receber dados do mesmo para os seus objectivos próprios.
Existem desvantagens, contudo. Para usar o DCOP um programa precisa de ser desenhado para conter uma interface DCOP especial. Para além disso, o processo de comunicação do DCOP corre de forma um pouco lenta. De qualquer forma, ele confere muito do poder e da flexibilidade do 'scripting' em UNIX® para os programas de alto nível que se baseiam numa interface gráfica para o utilizador.
Para mais informações, veja o artigo DCOP: Desktop COmmunications Protocol ou a referência da API da biblioteca do Desktop Communication Protocol DCOP para a biblioteca de DCOP do KDE.
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
Excepto nos casos muito simples, o seu projecto irá consistir de um grande conjunto de blocos de construção de código-fonte, estando cada um deles colocado num ficheiro separado para uma manutenção mais simples. Para pôr isto a correr, você terá de traduzir efectivamente todas estas coisas em algumas unidades de linguagem da máquina, num formato adequado que permita ao sistema operativo carregar e executar o programa.
Para conseguir isto, as ferramentas básicas que necessárias são
um editor de texto para escrever os ficheiros de código-fonte,
um programa de tradução, normalmente um compilador para transformar o código-fonte em ficheiros-objecto,
um criador de bibliotecas que junta os ficheiros-objecto em bibliotecas, para os poder reutilizar facilmente sem ter de os recompilar.
um editor de ligações que junta os vários ficheiros-objecto e bibliotecas todos num único executável,
um sistema de compilação que forneça alguns meios de gerir todas estas coisas e — não esquecer
um depurador para (assim se espera) poder encontrar todos os erros no programa e possivelmente algumas outras ferramentas de diagnóstico para ter tudo a correr sem problemas.
Quando você tem um projecto grande que consiste possivelmente em centenas de ficheiros de código-fonte, o processo de compilação pode-se tornar bastante trabalhoso. Você não irá querer recompilar todos os ficheiros de cada vez que você tenha alterado apenas alguns deles. Em vez disso, você só deseja compilar aqueles ficheiros que são afectados pelas modificações. De um mode geral, não é óbvio saber quais é que são.
Quando você isto é mudar o protótipo de uma função num ficheiro de inclusão, você terá de compilar todos os ficheiros que incluam este. Se o seu projecto contiver assim tantos ficheiros, você poder-se-á esquecer de um ou dois deles, se tiver de fazer esse trabalho manualmente. Como tal, é necessária alguma forma de automatização.
Uma ferramenta que toma conta das recompilações é o make. Ele mantém um registo de todo o trabalho, usando um conjunto de regras que descrevem o que fazer no caso de algum pedaço de informação (normalmente um ficheiro de código ou um ficheiro-objecto) ser alterado. Todas as regras que pertencem a um dado projecto são guardadas num ficheiro chamado Makefile que é processado pelo make de cada vez que você deseja actualizar o seu trabalho.
Cada regra consiste em vários blocos de construção, nomeadamente
um alvo, ou seja, o ficheiro a ser criado
um conjunto de dependências, basicamente os nomes daqueles ficheiros de que o alvo depende (isto é, o nome de um ficheiro de código, onde então o alvo será o nome do ficheiro-objecto a ser criado) e
os comandos que serão executados para “criar” o alvo (isto é, para o compilar ou para ligar outros ficheiros-objecto em conjunto para formar um programa executável).
Basicamente, o comando make irá ler as regras uma a seguir à outra, verificar cada ficheiro na lista de dependências de um determinado alvo e criar esse alvo de novo, se algum destes ficheiros foi alterado, usando os comandos indicados na regra.
Existem várias possibilidades adicionais para controlar um processo do 'make' e, deste modo, uma Makefile poderá deste modo ficar bastante complexa. Não poderemos entrar em detalhes aqui. Contudo, recomendamos que você se vá acostumando à sintaxe do make. Mesmo que você não o use directamente, a compreensão dos fundamentos do sistema de compilação poderá ser útil. Veja o “Manual do Make da GNU” para mais informações.
Para mais detalhes específicos do KDevelop, veja o capítulo sobre a Gestão de Projectos e Compilações deste manual.
Existem vários tutoriais disponíveis; veja as referências no capítulo sobre gestão dos projectos e das compilações.
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
Os programadores de aplicações estão incumbidos normalmente em ter não só de criar as bibliotecas e a lógica dos programas, mas também em fornecer interfaces de utilizador que sejam tanto intuitivas como funcionais. A maioria dos programadores recebem pouca ou nenhuma formação na programação de GUIs e, como tal, as interfaces do utilizador resultantes poderão ficar mal desenhadas.
Ao longo dos anos, alguns princípios de desenho foram evoluindo. É altamente recomendado que adira a eles. Desta forma, as suas interfaces de utilizador irão reter uma aparência e comportamento comuns, factores que os utilizadores da sua aplicação irão agradecer.
Para a programação de GUIs no KDE, existe um guia de estilo disponível. Ele está nas Linhas-Guia de Interfaces do Utilizador do KDE na página dos programadores do KDE.
Poderá ser encontrada uma breve introdução aos princípios de desenho de interfaces aqui.
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
Existem várias ferramentas separadas disponíveis para quase todos os passos do processo de programação — planeamento, edição, gestão de ficheiros e processos de compilação, depuração, documentação, entre muitas outras coisas. Mas, logo que os projectos cresçam, o processo de programação tornar-se-ão bastante complicados.
Muito do trabalho repetitivo tem de ser feito ao desenhar, compilar e depurar um programa. Muito do trabalho pode-se poupar através do uso de modelos e 'scripts'. O restante é feito mantendo, de forma simples, as ferramentas disponíveis facilmente e com capacidades de comunicarem umas com as outras através de uma GUI comum.
Por exemplo—não seria conveniente que um depurador fosse capaz de abrir o ficheiro de código em questão num editor e colocasse o cursor directamente sobre a posição do erro que foi encontrado?
Para conseguir um esquema desses mais facilmente, os Ambientes de Desenvolvimento Integrados (IDEs) foram criados. Um IDE desse género integra todos os modelos, ferramentas e programas necessários no processo de desenvolvimento num único ambiente.
Para a plataforma do KDE, o KDevelop é desses IDEs. Ele contém um conjunto vasto de ferramentas que facilitam o desenvolvimento e manutenção dos programas, mesmo para as diferentes linguagens de programação e pelas várias plataformas.
Gere todas as ferramentas de desenvolvimento necessárias para a programação em C++, como o compilador, o editor de ligações, o depurador e o sistema de compilações.
Contém um Application Wizard que gera aplicações completas e prontas a funcionar.
Permite ao utilizador seleccionar um editor integrado, baseado no editor do programador KWrite ou no QEditor da Trolltech ou noutro qualquer.
Um gerador de classes, para poder criar classes novas e integrá-las no projecto actual.
Gestão de ficheiros para o código, os ficheiros de inclusão, documentação, etc., a incluir no projecto.
A assistência na criação de manuais do utilizador da aplicação, feitos com as ferramentas do KDE.
Documentação da API automática e baseada em HTML para as classes de um projecto com referências cruzadas para as bibliotecas utilizadas.
Suporte para internacionalização, o que permite aos tradutores adicionarem a sua língua-alvo a um projecto com facilidade, incluindo o suporte para o KBabel.
O suporte para a gestão de um projecto através de um de vários sistemas de controlo de versões (isto é, o CVS), fornecendo uma interface simples de utilizar para as funções mais necessárias.
Uma interface para um depurador integrado.
Um emulador da consola de texto.
Realce de sintaxe nos ficheiros de código.
Completação automática de código para as variáveis das classes, os métodos das mesmas, os argumentos das funções, entre outras coisas.
Modelos para criar vários projectos (módulos do KControl, 'applets' do Kicker (painel), KIOSlaves, 'plugins' do Konqueror e estilos do ecrã).
Quatro janelas de navegação em árvore para mudar facilmente entre ficheiros de código, ficheiros de inclusão, classes e documentação, eliminando a necessidade de um gestor de ficheiros externo.
Suporte para compilações cruzadas, com a possibilidade de indicar vários compiladores diferentes, opções de compilação, arquitecturas-alvo, etc.
Suporte para projectos do Qt/Embedded (como o Zaurus e o iPAQ).
Inclusão de vários programas que necessite para programar, adicionando-os ao menu , de acordo com as suas necessidades individuais.
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
Índice
O KDevelop usa uma série de ficheiros de configuração que estão distribuídos entre várias pastas. Existem dois grupos principais de ficheiros de configuração para distinguir:
| Configuração por Omissão do KDevelop — os ficheiros configurados quando o KDevelop foi instalado. |
| Configuração Orientada pelo Utilizador — os ficheiros que contêm as modificações do utilizador aos valores predefinidos, assim como as configurações feitas pelo próprio KDevelop e pelos seus 'plugins'. |
Na instalação, o KDevelop grava alguns ficheiros de informação por omissão para fins de configuração nas subpastas da pasta de instalação $ (normalmente algo do género de KDEDIR/opt/kde, /usr/local/kde, ou outra pasta de instalação definida pelo utilizador; veja em Instalar o KDevelop).
Só existe um ficheiro de configuração por omissão específico do KDevelop na pasta $: KDEDIR/share/config/
kdeveloprcEste ficheiro contém as opções básicas que o KDevelop necessita para começar. Será copiado para a pasta do utilizador em $, quando o KDevelop não encontrar aí um ficheiro KDEHOME/share/configkdeveloprc no arranque.
A maioria das funcionalidades do KDevelop são oferecidas através de KParts. Estas são basicamente aplicações desenhadas especialmente para correr na plataforma do KDevelop (veja a introdução no apêndice sobre as Ferramentas e 'Plugins'). Cada aplicação KPart tem o seu próprio conjunto de ficheiros de configuração, cujos valores por omissão serão gravados em várias subpastas da pasta de instalação $. KDEDIR/share/apps/
Existem bastantes subpastas de configuração por omissão em $, cujos nomes começam todos por uma sequência KDEDIR/share/apps/kdev. A maioria delas são para o uso interno do KDevelop. Elas poderão estar agrupadas deliberadamente para fins de legibilidade como:
| Aplicações Autónomas |
| Componentes Específicas de uma Tarefa |
| Componentes de Geração de Projectos |
| Componentes Específicas da Linguagem |
Aplicações Autónomas
kdevelop/ — contém os ficheiros para configurar o IDE KDevelop:
licenses/ — contém os vários textos de licenças.
pics/ — contém os ficheiros de imagens usados nos ecrãs iniciais do Assistente do KDevelop e do Desenhador do KDevelop.
profiles/ — contém as opções de perfis dos 'plugins'. (De momento só existe um perfil tiny (minúsculo) que define um conjunto mínimo de 'plugins' activos do KDevelop.)
eventsrc — mantém vários textos de localização de “Processo com sucesso”.
kdevelopui.rc — oferece os menus e barras de ferramentas básicos que o KDevelop usa.
kdevhtml_partui.rc — oferece um item no menu , um item no menu e as setas Recuar e Avançar na Barra do Navegador, para o caso de navegar num ficheiro HTML no 'plugin' de Documentação.
kdevassistant/ — oferece os menus e barras de ferramentas do navegador de documentação do Assistente do KDevelop.
kdevdesigner/ e kdevdesignerpart/ — oferecem os menus e barras de ferramentas para o desenhador de interfaces autónomo do KDevelop.
Componentes Específicas de uma Tarefa
kdevabbrev/ — contém os ficheiros usados pelo 'plugin' de Expansão de Abreviaturas:
sources/ — contém os ficheiros de definições de palavras-chave usadas pelo comando Expandir o Texto.
templates/ — contém os ficheiros de definição de modelos usados pelo comando Expandir a Abreviatura.
kdevabbrev.rc — oferece os itens e do menu .
kdevappwizard/ — contém os ficheiros usados pela componente do Application Wizard:
importfiles/ — contém os ficheiros de projecto .kdevelop que controlam a inicialização de um novo projecto.
imports/ — contém os modelos para configurar os ficheiros .desktop específicos de um projecto.
template-common/ — contém vários ficheiros que são incluídos normalmente nas pastas de código do projecto.
templates/ — contém os ficheiros de configuração que descrevem a informação a ser incluída numa dada pasta de código do projecto.
*.png — as imagens de antevisão do projecto usadas pelo Application Wizard.
*.tar.gz — os pacotes que contêm os ficheiros de código a serem incluídos numa pasta de um projecto novo gerada.
kdevastyle/ — oferece o item para no menu .
kdevautoproject/ — oferece os itens para o menu e para a Barra de Construção (KDevelop).
kdevclassview/ — contém os ficheiros usados pelo 'plugin' do projecto para a Janela de Classes:
pics/ — contém os ícones usados na árvore de Classes.
kdevclassview.tc — oferece o item do no menu , assim como a lista de navegação de classes na Barra de Navegação.
kdevcloser/ — oferece os itens de fecho do menu .
kdevctags/ — oferece o item do do menu para o 'plugin' do projecto para a Interface do CTags.
kdevcvsservice/ — oferece o ícone usado pela página de CvsService e um pequeno programa usado para adicionar um novo item ao repositório do CVS, sendo ambos usados no 'plugin' do projecto para a Integração com o CVS.
kdevdebugger/ — oferece os itens de menu para o 'plugin' do projecto Interface do Depurador.
kdevdiff/ — oferece o item do no menu .
kdevdistpart/ — oferece o item de no menu do 'plugin' do projecto Suporte de Empacotamento Final.
kdevdocumentation/ — contém os ficheiros usados pelo 'plugin' de Documentação:
en/ e pics/ — contém os ficheiros usados pela ferramenta de procura htdig.
tocs/ — contém os ficheiros de descrição do conteúdo da documentação por omissão do KDevelop (veja a descrição em Estrutura Básica dos Ficheiros TOC do KDevelop).
kdevpart_documentation.rc — oferece os itens relacionados com a procura no menu .
kdevdoxygen/ — oferece os itens de menu para o 'plugin' do projecto Suporte do Doxygen.
kdevfilecreate/ — contém os ficheiros usados pelo Assistente de Novo Ficheiro:
file-templates/ — oferece o conteúdo de texto inicial a ser colocado num ficheiro de código novo de determinado tipo.
kdevpart_filecreate.rc — oferece o item do menu .
template-info.xml — contém as descrições dos tipos de ficheiros disponíveis a serem mostrados na janela de Novo Ficheiro.
kdevfilter/ — oferece os itens e no menu , usado pelo 'plugin' de Filtragem e Inserção na Linha de Comandos.
kdevfullscreen/ — oferece o item do no menu , assim como o ícone respectivo na barra de ferramentas.
kdevgrepview/ — oferece o item no menu , usado pelo 'plugin' da Interface do Grep.
kdevhistory/ — oferece os itens e no menu .
kdevjavadebugger/ — oferece o menu de para poder depurar uma aplicação de Java™.
kdevoutputviews/ — oferece os itens e no menu .
kdevpartexplorer/ — oferece o item do menu , usado pelo 'plugin' da Ferramenta do Explorador de Componentes.
kdevquickopen/ — oferece o item no menu e o e no menu , que são usadas pelo 'plugin' do projecto Abertura Rápida.
kdevregexptest/ — oferece o item do menu , usado pelo 'plugin' de Teste de Expressões Regulares.
kdevreplace/ — oferece o item do menu , usado pelo 'plugin' de Substituição.
kdevtipofday/ — oferece o item da do menu , assim como um ficheiro HTML que contém as dicas disponíveis.
kdevtools/ — controla os vários itens de menu criados pelo e pelo Menu de Ferramentas Externas, oferecidas pelo 'plugin' de Adição ao Menu de Ferramentas.
kdevvalgrind/ — oferece os itens de e do menu , usados pelo 'plugin' de Interface do Valgrind.
Componentes de Geração de Projectos
kdevadaproject/ — oferece os itens para o menu e os ícones respectivos da barra de ferramentas para criar uma aplicação em Ada.
kdevantproject/ — oferece os itens para o menu quando é usado o gerador de projectos Ant.
kdevautoproject/ — oferece os itens para o menu , assim como os ícones respectivos da barra de ferramentas ao trabalhar com o gerador de projectos automake com base nas ferramentas da GNU. Para além disso, oferece os itens e para o menu .
kdevcustomproject/ — oferece os itens para o menu e os ícones da barra de ferramentas respectivos, quando o projecto se baseia em Makefile's personalizadas.
kdevgenericproject/ — contém as definições do menu para um gerador de projectos genérico e experimental. De momento (na versão 3.1.0) não é usado.
kdevhaskellproject/ — oferece os itens para o menu , bem como os ícones da barra de ferramentas respectivos, para criar uma aplicação em Haskell.
kdevpascalproject/ — oferece os itens para o menu , bem como os ícones da barra de ferramentas respectivos, para criar uma aplicação em Pascal.
kdevtrollproject/ — oferece os itens para o menu , bem como os ícones da barra de ferramentas respectivos, para criar uma aplicação que usa o gestor de projectos QMake da Qt™.
Componentes Específicas da Linguagem
kdeadasupport/ — oferece os itens para o menu , bem como os ícones da barra de ferramentas respectivos, para criar uma aplicação em Ada.
kdebashsupport/ — oferece os itens para o menu , bem como os ícones da barra de ferramentas respectivos, para criar um 'script' em Bash.
kdecppsupport/ — oferece os ficheiros usados pelo Application Wizard para criar aplicações em C++:
newclass/ — contém os ficheiros-modelo de inclusão e de código, a partir dos quais o Application Wizard cria os ficheiros de código correspondentes.
subclassing/ — contém os ficheiros-modelo que o Application Wizard usa para configurar as declarações/definições de classes iniciais nos ficheiros de código.
templates — contém os ficheiros-modelo, a partir dos quais o Application Wizard configura os ficheiros de modelo de inclusão e de código predefinidos que são usados pelo New File Wizard.
configuration — modelo inútil para adicionar macros.
kdevcppsupport.rc — oferece o suporte para os itens e do menu , o item do menu e o item do menu , assim como um ícone Nova Classe para a Barra de Navegação.
kdefortransupport/ — oferece os itens para o menu , bem como os ícones da barra de ferramentas respectivos, para criar uma aplicação em Fortran.
kdehaskellsupport/ — oferece os itens para o menu , bem como os ícones da barra de ferramentas respectivos, para criar uma aplicação em Haskell.
kdevjavasupport/ — contém a definição da interface necessária para desenvolver as aplicações em Java™.
kdevpascalsupport/ — contém a definição da interface necessária para desenvolver aplicações em Pascal.
kdevperlsupport/ — oferece os itens do menu e necessários para desenvolver programas em Perl.
kdevphpsupport/ — contém os ficheiros de definição da interface e de PHP, necessários para desenvolver programas em PHP.
kdevpythonsupport/ — oferece os itens do menu e , bem como os ícones da barras de ferramentas, necessários para desenvolver programas em Python.
kdevrubysupport/ — oferece os itens do menu e os ícones das barras de ferramentas respectivos que são necessários para desenvolver programas em Ruby.
kdevscriptproject/ — oferece as definições da interface necessárias ara criar projectos personalizados. De momento (na versão 3.1.0) não é usado.
kdevsqlsupport/ — oferece as definições de interface necessárias para desenvolver projectos em SQL. De momento (na versão 3.1.0), não é usado.
Toda a informação sobre as opções definidas pelo utilizador é mantida em duas subpastas da $, nomeadamente: KDEHOME
Configuração Específica da Aplicação na pasta $ e |
Ficheiro de Configuração do Recurso na pasta $. |
Todas as alterações do utilizador à Configuração por Omissão do KDevelop, assim como as opções específicas do utilizador que não são mantidas em nenhum dos Ficheiros de Configuração de Recursos encontram-se nas subpastas kdev... da pasta $. KDEHOME/share/apps/
A maioria destes ficheiros de configuração são usados, todavia, por vários 'plugins' do KDevelop para oferecer alguns itens do menu e/ou barra de ferramentas. Como tal, são apenas de interesse no caso de algo correr realmente mal com a interface do utilizador.
No caso do conteúdo destas pastas reflectir o da Configuração por Omissão, o KDevelop terá copiado as mesmas de $ para a pasta KDEDIR/apps/$ no seu arranque inicial. Todas as alterações subsequentes serão feitas apenas nestas cópias. As opções da Configuração por Omissão irão permanecer inalteradas, em qualquer dos casos. KDEHOME/apps/
kdevabbrev/ — contém os ficheiros usados pelo 'plugin' de Expansão de Abreviaturas:
sources/ — de momento vazio; o KDevelop usa os ficheiros de definição de palavras-chave por omissão para os comandos para Expandir o Texto.
templates/ — contém os ficheiros de definição de modelos usados pelo comando Expandir a Abreviatura.
kdevabbrev.rc — oferece os itens e do menu .
kdevappwizard/ — só oferece os itens e do menu de . O Application Wizard irá então usar as opções de configuração por omissão para as suas tarefas actuais.
kdevastyle/ — oferece o item para no menu .
kdevautoproject/ — oferece os itens para o menu e da Barra de Construção (KDevelop).
kdevclassview — oferece o item do no menu , assim como a lista de navegação de classes na Barra de Navegação do 'plugin' do projecto da Lista de Classes.
kdevcloser/ — oferece o item para no menu .
kdevcppsupport/ — contém a configuração actual, usada pelo Application Wizard, para criar aplicações em C++. O Application Wizard usa, contudo, o seu maior bloco de informação de configuração directamente a partir da pasta de configuração por omissão. Veja aí para ter mais detalhes.
newclass/ — contém os ficheiros-modelo de inclusão e de código, a partir dos quais o Application Wizard cria os ficheiros de código correspondentes.
pcs/ — contém os ficheiros de base de dados que o KDevelop usa para criar o Persistent Code Store (.pcs) actual de um projecto em C++ do KDE.
kdevcppsupport.rc — oferece o suporte para os itens e do menu , o item do menu e o item do menu , assim como um ícone Nova Classe para a Barra de Navegação.
kdevctags/ — oferece o item do do menu para o 'plugin' do projecto para a Interface do CTags.
kdevdebugger/ — oferece os itens de menu para o 'plugin' do projecto Interface do Depurador.
kdevdiff/ — oferece o item do no menu .
kdevdocumentation/ — contém os ficheiros usados pelo 'plugin' de Documentação para além dos ficheiros predefinidos de configuração. Veja nesse local para mais detalhes.
As pastas em kdevdocumentation/ normalmente guardam apenas informações de organização. Os ficheiros de documentação configurados de momento são mantidos nos ficheiros “doc...pluginrc” da pasta $.KDEHOME/share/config/
bookmarks/ — mantém os itens da página de Favoritos do 'plugin' de Documentação do KDevelop.
index/ — mantém os vários ficheiros de 'cache' que o KDevelop usa para acelerar as pesquisas de documentação na página de Índice do 'plugin' de Documentação.
search/ — contém os ficheiros usados pela ferramenta de procura htdig que serve várias chamadas de procura da página Procurar do 'plugin' de Documentação.
kdevpart_documentation.rc — oferece os itens relacionados com a procura no menu .
kdevdoxygen/ — oferece os itens de menu para o 'plugin' do projecto Suporte do Doxygen.
kdevelop/ — contém algumas opções actuais que o IDE KDevelop usa para a sua configuração básica:
profiles/ — oferece a configuração do perfil do 'plugin' actual. (No início existe apenas um perfil FullIDE que define um conjunto completo de 'plugins' activos inicialmente KDevelop.)
kdevelopui.rc — oferece os menus e barras de ferramentas básicos que o KDevelop usa.
kdevfilecreate/ — contém os ficheiros usados pelo Assistente de Novo Ficheiro:
file-templates/ — oferece o conteúdo de texto inicial a ser colocado num ficheiro de código novo de determinado tipo. Podem ser encontrados mais modelos de ficheiros na pasta de ficheiros de configuração por omissão.
kdevpart_filecreate.rc — oferece o item do menu .
template-info.xml — contém as descrições dos tipos de ficheiros disponíveis a serem mostrados na janela de Novo Ficheiro.
kdevfilter/ — oferece os itens e no menu , usado pelo 'plugin' de Filtragem e Inserção na Linha de Comandos.
kdevfullscreen/ — oferece o item do no menu , assim como o ícone respectivo na barra de ferramentas.
kdevgrepview/ — oferece o item no menu , usado pelo 'plugin' da Interface do Grep.
kdevoutputviews/ — oferece os itens e no menu .
kdevpartexplorer/ — oferece o item do menu , usado pelo 'plugin' da Ferramenta do Explorador de Componentes.
kdevquickopen/ — oferece o item no menu e o e no menu , que são usadas pelo 'plugin' do projecto Abertura Rápida.
kdevregexptest/ — oferece o item do menu , usado pelo 'plugin' de Teste de Expressões Regulares.
kdevreplace/ — oferece o item do menu , usado pelo 'plugin' de Substituição.
kdevtipofday/ — oferece o item da do menu . O ficheiro em HTML que contém as dicas disponíveis é oferecido apenas como um ficheiro de configuração por omissão.
kdevtools/ — controla os vários itens de menu criados pelo e pelo Menu de Ferramentas Externas, oferecidas pelo 'plugin' de Adição ao Menu de Ferramentas.
kdevvalgrind/ — oferece os itens de e do menu , usados pelo 'plugin' de Interface do Valgrind.
Existem dois grupos de ficheiros de configuração do KDevelop na pasta $, distinguidos pelas suas sequências de caracteres envolventes: KDEHOME/share/config/
O “doc...pluginrc” denota os ficheiros usados pelo 'plugin' de documentação. |
O “kdev...rc” denota os ficheiros de configuração usados pelo KDevelop propriamente dito e pelos seus 'plugins' disponíveis. |
Ficheiros de Configuração Usados pelo KDevelop
kdevabbrevrc — contém o estado actual da configuração de Abreviaturas oferecida pelo 'plugin' de Expansão de Abreviaturas.
Isto apenas regista se as abreviaturas serão usadas ou não. As definições actuais das abreviaturas novas irão parar ao ficheiro $.KDEHOME/share/apps/kdevabbrev/templates/templates
kdevassistantrc — mantém algum estado de configuração específico do navegador de documentação do Assistente do KDevelop.
As opções de configuração mais comuns são partilhadas no ficheiro de configuração do IDE KDevelop em kdeveloprc.
kdevassistantuimode4rc — mantém o estado da configuração actual do MDI (posições da acoplagem, etc.) do navegador de documentação do Assistente do KDevelop.
kdevclassviewrc — mantém a configuração do Modo de Visualização da página de navegação de Classes, que é oferecida pelo 'plugin' de projecto da Janela de Classes.
Esta é uma opção global, ainda que a Janela de Classes possa ou não estar desactivada. Qualquer alteração nesta opção será actualizada globalmente, sempre que o projecto actual for fechado e, deste modo, afectar todos os projectos carregados subsequentemente.
kdevcppsupportrc — contém algumas opções usadas para configurar os ficheiros de código CPP. Em particular, irá encontrar as opções definidas na janela de configuração do Gerador de Classes de C++ aqui registadas.
kdevdocumentationrc — mantém a configuração actual do 'plugin' de Documentação.
kdeveloprc — contém as opções globais que o IDE KDevelop IDE e o Assistente do KDevelop usam.
kdevelopuimode4rc — mantém a configuração da MDI actual (posições de acoplagem, etc.) do IDE KDevelop.
kdevfileselectorrc — mantém a configuração actual do 'plugin' do Selector de Ficheiros.
kdevfileviewrc — mantém as configurações de cores dos ficheiros actuais que a Integração com o CVS (Cervisia) usa na apresentação.
kdevfilterrc — mantém a configuração que o 'plugin' Filtragem e Inserção da Linha de Comandos usa.
kdevgrepviewrc — mantém as opções actuais do 'plugin' da Interface do Grep.
kdevsnippetrc — mantém a configuração actual do 'plugin' dos Excertos de Código.
kdevtoolsrc — mantém a configuração actual que o 'plugin' de Adição ao Menu Ferramentas usa.
Ficheiros de Configuração Usados pelo 'Plugin' de Documentação
docchmpluginrc — mantém a informação sobre os ficheiros de ajuda CHM da Microsoft®, tal como está definido na página de configuração da Colecção de Documentação CHM.
doccustompluginrc — mantém a informação sobre os ficheiros de documentação personalizados que estão definidos na página de configuração da Colecção de Documentação Personalizada.
docdevhelppluginrc — mantém a informação acerca dos ficheiros de documentação do GNOME 2, tal como está definido na página de configuração da Colecção de Documentação do Devhelp.
docdoxygenpluginrc — mantém a informação acerca da documentação da API gerada pelo Doxygen, tal como está definida na página de configuração da Colecção de Documentação do Doxygen.
dockdevtocpluginrc — mantém a informação acerca dos ficheiros de documentação estruturada KDevelopTOC, tal como está definido na página de configuração da Colecção de Documentação do KDevelopTOC.
docqtpluginrc — mantém a informação acerca dos ficheiros de documentação do QT, tal como está definido na página de configuração da Colecção de Documentação do Qt.
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
A maior parte da configuração dependente do projecto é mantida nos ficheiros de configuração do projecto <nome-projecto>.kdevelop e <nome-projecto>.kdevses do KDevelop, em vez de serem mantidos em ficheiros separados como as outras opções de configuração mais globais. Em resumo estes ficheiros são:
<nome-projecto>.kdevelop — informação de configuração global do projecto. |
<nome-projecto>.kdevses — informação de configuração necessária para repor os comportamentos específicos da sessão actual. |
Ambos são ficheiros em XML™. Eles podem ser vistos e (cuidadosamente) alterados com qualquer editor de texto.
Existe um terceiro ficheiro de configuração do projecto, o Repositório de Código Persistente <nome-projecto>.kdevelop.pcs. Este é um ficheiro binário que mantém uma 'cache' de processamento para acelerar em grande medida a sequência de carregamento do projecto. Para além disso, este repositório mantém a informação da funcionalidade de Completação do Código do KDevelop.
Poderão estar definidos ficheiros de Repositórios de Código Persistente na página de Completação de Código da página de configuração do projecto Específico do C++. A informação sobre estes ficheiros .pcs adicionais é mantida a nível global na pasta $. KDEHOME/share/apps/kdevcppsupport/pcs/
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
O KDevelop contém uma grande quantidade de pequenas ferramentas que o ajudam a desempenhar certas tarefas. A maioria delas está implementada sob a forma de 'plugins'. Isto significa que, se não necessitar de um 'plugin', podê-lo-á desactivar.
Isto também significa que, se está à procura de uma determinada funcionalidade que deveria lá estar e não está, então é porque provavelmente está implementada num 'plugin' e este está desactivado. Por exemplo, no menu de ficheiros, existe um menu de Abertura Rápida, se estiver activo na janela de Projecto - Opções do Projecto.
Tecnicamente, os 'plugins' são baseados na classe KDevPlugin que está definida em 'lib/interfaces/kdevplugin.h'. O seguinte é retirado de um comentário de lá (devidamente traduzida).
O KDevPlugin é a classe de base para todos os 'plugins' do KDevelop. Um 'plugin' é um componente que é carregado na plataforma do KDevelop no início ou a pedido. Um 'plugin' tem um âmbito que poderá ser:
Os 'plugins' nucleares são 'plugins' globais que oferecem alguma funcionalidade "nuclear" e, como tal, não são seleccionados pelo utilizador, nas páginas de configuração dos 'plugins'.
Os 'plugins' globais são 'plugins' que só necessitam da plataforma para serem carregados e não operam na interface KDevProject e/ou não usam a informação ao nível do projecto. Por exemplo, o 'plugin' 'uimode' permite a um programador escolher a interface do utilizador que deseja usar.
Os 'plugins' do projecto necessitam de ter um projecto carregado e são normalmente carregados/terminados em conjunto com o projecto. Se um 'plugin' funcionar com informação relacionada com o projecto, então é um 'plugin' de projecto. O Gestor do Automake, por exemplo, só necessita de estar activo quando estiver carregado um projecto baseado no Automake.
Como foi dito acima, os 'plugins' do núcleo não poderão ser desactivados. Os 'plugins' globais podem ser activados/desactivados em -> em . Os 'plugins' do projecto podem ser activados/desactivados na opção -> em . Os 'plugins' activos poderão ter vários efeitos no KDevelop. Dependendo da sua função, poderão adicionar menus extra, opções extra, botões extra na barra de ferramentas, etc.
Os 'plugins' que estão desactivados não enchem os seus menus e não são carregados na memória.
A lista de 'plugins' que se segue é gerada por um pequeno programa ('listplugins.sh'), criado por Volker Paul. Todos os 'plugins' têm um ficheiro .desktop cujo nome e comentários estão escritos. Se, no que se segue, este comentários não forem muito úteis, foi porque os autores dos 'plugins' os fizeram assim.
Os 'plugins' estão organizados por âmbito (Nuclear, Global, Projecto).
Âmbito: Nuclear
Âmbito: Global
Expansão de Abreviaturas. Oferece o suporte para as abreviaturas personalizadas - as palavras pequenas que se expandem em estruturas de código comuns necessárias.
Documentação. O 'plugin' de Documentação oferece a navegação e pesquisa na documentação local e 'online', com o suporte para vários sistemas de documentação.
Lista de Ficheiros. Oferece uma lista com todos os ficheiros abertos. (É útil quando a barra de páginas não é suficientemente larga.)
Selector de Ficheiros. Um utilitário de navegação de ficheiros transparente na rede e poderoso.
Filtragem e Inserção da Linha de Comandos. Oferece uma forma de manipular o texto do editor com base em ferramentas da linha de comandos. Aparece no menu Ferramentas.
Interface do Grep. Integra o "find|grep" no KDevelop - permite uma procura rápida em vários ficheiros, com padrões e expressões regulares.
Konsole Embebido. Este 'plugin' dá ao KDevelop um Konsole incorporado, para poder aceder fácil e rapidamente à linha de comandos.
Adição do Menu "Abrir com". Este 'plugin' oferece alternativas adicionais para "abrir" nos vários menus de contexto do KDevelop.
Ferramenta de Exploração de Componentes. Uma ferramenta gráfica para efectuar pesquisas do tipo do KTrader acerca dos serviços registados
Teste de Expressões Regulares. Uma ferramenta para desenhar e testar expressões regulares, usando as sintaxes de expressões regulares normais.
Componente de Substituição. Este 'plugin' é uma ferramenta interactiva de "Procurar e Substituir" ao nível do projecto. Faça a pesquisa com a correspondência por texto ou expressões regulares, e seleccione as substituições a fazer, numa antevisão, antes de a acção terminar. Logo que esteja carregada, aparece no menu Editar.
Programação. O 'plugin' de Programação oferece capacidades de programação em KScript à aplicação KDevelop
Excertos de Código. Este 'plugin' permite-lhe gravar excertos de código e adicioná-los ao seu código
Estrutura do Texto. Oferece uma vista estrutural e de navegação para os ficheiros em HTML e TEX
Adição ao Menu de Ferramentas. Este 'plugin' oferece uma forma simples para adicionar aplicações externas ao menu e às barras de Ferramentas.
Interface para o Valgrind. O Valgrind é uma ferramenta que o ajuda a detectar problemas de gestão de memória nos programas. Veja em http://developer.kde.org/~sewardj/
Âmbito: Projecto
Formatador do Código-Fonte. Um 'plugin' para formatar o código-fonte, de acordo com um conjunto bem definido de regras. Quando for carregado, está presente no menu Ferramentas.
Favoritos. Um 'plugin' que oferece a navegação e a apresentação de favoritos de código activos, mantendo-os persistentes entre sessões.
Área de Classes. Este 'plugin' mostra uma vista gráfica sobre todas as classes do projecto, completas com os métodos e atributos, oferecendo ainda uma forma de navegar directamente pelo código.
Copiar Para. Um 'plugin' de envio de ficheiros simples. Faz uma cópia de ficheiros através de qualquer protocolo suportado pelo KIO.
Interface para o CTags. O CTags é uma ferramenta para navegar no código, com o suporte para várias línguas. Quando for carregado, oferece um menu para procurar as declarações/definições dos tipos, assim como uma janela de pesquisa. Para mais informações, vá a http://ctags.sourceforge.net/
Suporte de Empacotamento Final. Ajuda na criação de pacotes e na publicação do projecto final. Só é suportado o formato de pacotes RPM, por agora.
Suporte para Doxygen. O 'plugin' do 'doxygen' oferece uma forma de indicar e controlar a geração da documentação para um projecto, com base no conteúdo do código-fonte. Deverá ter o 'doxygen' instalado para poder usar isto. Para mais informações, vá a http://www.doxygen.org
Abertura Rápida. Oferece uma forma eficiente de procurar/abrir ficheiros, classes e métodos num projecto grande. Aparece nos menus Ficheiro e Ferramentas, quando estiver carregado.
Verificação de Segurança. Verificação da segurança do código
Até agora, foi a lista de 'plugins' gerada.
Tabela E.1. 'Plugins' de Gestão de Projectos do KDevelop
| antproject | Gestor de Projectos do ANT (aplicações de Java™) |
| autoproject | Gestor de Projectos do Automake |
| customproject | Gestor de Projectos Personalizados |
| trollproject | Gestor de Projectos baseado no QMake |
Os 'plugin' acima indicados estão de momento (Maio de 2005) vazios. Talvez o suporte para a gestão de projectos seja implementado como 'plugins' no futuro.
Tabela E.2. 'Plugins' de Suporte de Linguagens no KDevelop
| cppsupport | Suporte para C/C++ |
| fortransupport | Suporte para Fortran |
| javasupport | Suporte para Java™ |
| perlsupport | Suporte para Perl |
| phpsupport | Suporte para PHP |
| pythonsupport | Suporte para Python |
No que se segue, alguns dos 'plugins' serão discutidos em detalhe.
O 'plugin' abbrev. Este 'plugin' expande as abreviaturas em excertos de código usados com frequência. É activado ao carregar em Ctrl-Espaço. Por exemplo, quando indicar "ife" num ficheiro de C++ no editor e carregar em Ctrl-Espaço, irá obter um modelo de código if-else, poupando assim algum texto escrito manualmente. O conjunto de abreviaturas depende da linguagem de programação do ficheiro editado. Por exemplo, para o PHP, irá estar obviamente interessado noutros modelos de código que não os do Java™.
O conjunto de modelos de código é configurável. Se o 'plugin' estiver activo, poderá ver os que estão disponíveis na opção ->, em .
O 'plugin' filter. Este oferece duas funcionalidades. Se seleccionar a opção ->, poderá indicar um comando da consola. O resultado deste comando é introduzido na janela de edição, quando carregar no botão .
Está disponível uma funcionalidade relacionada em ->. Para a usar, deverá seleccionar uma área de texto no editor. Se agora indicar um comando e carregar no botão , o comando é iniciado e a selecção é usada como dados de entrada para ele. O resultado à saída do comando é então introduzido no editor, substituindo a selecção.
Por exemplo, se você escrever documentação, terá de fazer referência aos itens do menu. Para o fazer correctamente, p.ex., para o comando Copiar do menu Editar, terá de escrever:
<menuchoice><guimenu>Editar</guimenu><guimenuitem>Copiar</guimenuitem></menuchoice>Isto é difícil, como tal gostaria de escrever apenas "Editar - Copiar" e deixar que o computador faça a formatação. Aqui está como o poderá fazer. Poderá criar um pequeno programa chamado 'mef', que poderá pôr p.ex., na pasta 'bin' da sua pasta pessoal:
sed s/"^\(.*\) - \(.*\)\$"/"<menuchoice><guimenu>\1<\/guimenu><guimenuitem>\2<\/guimenuitem><\/menuchoice>"/Não se esqueça de o tornar executável, e é tudo. Agora, no código .docbook da sua documentação, poderá escrever "Editar - Copiar". Se seleccionar o texto que acabou de escrever, escolha a opção -> e invoque o '~/bin/mef'. Imediatamente o "Editar - Copiar" será substituído por
<menuchoice><guimenu>Editar</guimenu><guimenuitem>Copiar</guimenuitem></menuchoice>
O 'plugin' do Doxygen. Este 'plugin' ajuda a usar a ferramenta de documentação de APIs Doxygen (http://www.doxygen.org). Poderá seleccionar a opção -> para gerar a documentação da API para o seu projecto actual, com base na configuração indicada pelo ficheiro Doxyfile da pasta do seu projecto.
Para além disso, poderá configurar o Doxygen no menu ->. Esta janela é bastante semelhante à ferramenta doxywizard.
O 'Plugin' do ctags. Ainda que o navegador de classes lhe dê uma análise extensiva dos símbolos e classes do seu projecto, poderá também querer usar a ferramenta 'ctags'. Em particular, este suporta bastantes mais linguagens que o navegador de classes.
Pode activar este 'plugin' em ->. Quando a iniciar da primeira vez, o utilizador será questionado para criar uma base de dados de procura. Quando aceitar essa opção, o programa ctags irá iniciar e irá criar um ficheiro chamado tags na pasta do seu projecto. Este é um ficheiro de texto que contém todos os símbolos dos seus ficheiros de código.
Poderá procurar na base de dados de símbolos de duas formas: quando a opção Corresponder à expressão regular estiver assinalada, o texto que introduzir será interpretado como uma expressão regular (variante POSIX) e aplicada aos símbolos existentes. Por exemplo, o texto .*Widget irá procurar por todos os símbolos que terminem em Widget. Se a opção não estiver assinalada, a pesquisa será feita à letra.
Ao procurar, irá obter uma lista dos símbolos correspondentes, acompanhada dos números de linha em que estes são definidos. Poderá saltar para o ponto respectivo, se carregar num item da lista.
Para algumas linguagens, o ctags distingue os diferentes tipos de símbolos. Por exemplo, o Python tem classes e funções. Poderá optar por procurar apenas por classes, assinalando ou desligando os tipos respectivos na janela.
A base de dados de símbolos normalmente não é actualizada com as modificações do seu código. Por consequência, ao fim de algum tempo, os números de linha já não estarão mais correctos, e irão faltar as classes e funções novas. Como tal, deverá actualizar o ficheiro tags com intervalos regulares, carregando no botão .
O 'plugin' astyle. O 'astyle' é um 'plugin' para formatar o código-fonte, de acordo com um conjunto definido de regras.
O 'plugin' regexptest. A programação com expressões regulares poderá ser bastante complicada. Muitas das vezes, à primeira tentativa, uma expressão irá corresponder com demasiado texto. Em particular, ao lidar com uma linguagem compilada, os tempos em que se anda às voltas a depurar uma expressão regular poderão ser desgastantes. O 'plugin' 'regexptest' permite-lhe explorar directamente as alterações numa expressão regular. É activada ao escolher a opção ->.
No grupo da variante, poderá escolher a variante do motor de expressões regulares usada. As versões suportadas de momento são as da norma do POSIX, que é usado pelo programa grep, e a sintaxe extendida do POSIX, que é usada pelo programa egrep.
Quando introduzir uma expressão, irá obter uma reacção imediata sobre os erros de sintaxe da mesma. Ao indicar um texto qualquer no Texto de teste, poderá ver se a expressão corresponde a este texto. Em particular, se a sua expressão incluir grupos, como o ([a-z]), o conteúdos dos sub-grupos será apresentado numa lista.
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
Carregue aqui para voltar à introdução aos modos.
Modo IDEAl do KDevelop
Carregue aqui para voltar à introdução aos modos.
Modo IDEAl do KDevelop, com páginas fechadas
Esta imagem de exemplo demonstra uma das virtudes principais do modo IDEAl. Está o máximo de espaço de trabalho disponível. De qualquer forma, qualquer uma das ferramentas está prontamente disponível, se carregar na página correspondente.
Provavelmente terá de ter algum tempo para se habituar aos ícones na barra de páginas. Se se perdeu, basta colocar o cursor do rato sobre uma página e esperar alguns segundos. Irá aparecer uma breve descrição com uma dica. Nesta imagem, é mostrada a dica do “Gestor do Automake” como exemplo. Ela descreve a página inferior da barra de páginas da direita.
Carregue aqui para voltar à introdução aos modos.
Carregue aqui para voltar à introdução aos modos.
Modo de janelas-filhas do KDevelop
Carregue aqui para voltar à introdução aos modos.
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
Carregue aqui para voltar à introdução aos modos.
Modo por páginas separadas do KDevelop
Carregue aqui para voltar à introdução aos modos.
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
Carregue aqui para voltar à introdução aos modos.
Modo por janelas de topo do KDevelop
Carregue aqui para voltar à introdução aos modos.
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
As combinações de teclas de atalho mostradas neste capítulo são as que vêm por omissão. Poderão à mesma ser alteradas.
Lembre-se que alguns dos itens do menu só aparecem quando se aplicarem. Especialmente, alguns itens estão associados à funcionalidade de determinados 'plugins' que só ficará disponível, quando os 'plugins' respectivos estiverem activos.
Cria um novo ficheiro. É pedida ao utilizador a pasta onde colocar o ficheiro (por omissão: a pasta de código do projecto actual) e o nome do ficheiro. O tipo do ficheiro poderá ser seleccionado a partir de uma lista. Do mesmo modo, o utilizador poderá escolher se o ficheiro é para ser adicionado ao projecto. Nesse caso, o Gestor do Automake irá perguntar o alvo ao qual adicionar o novo ficheiro.
Abre um ficheiro existente numa janela simples.
Abre um submenu que mostra os ficheiros abertos recentemente. Se seleccionar um destes, fará com que o KDevelop abra esse ficheiro.
Apresenta uma lista de ficheiros na pasta de código do projecto actual. O utilizador poderá seleccioná-lo na lista ou indicar o seu nome. Será esse ficheiro então aberto.
Grava o ficheiro actual.
Usa a janela Gravar Como... para lhe permitir gravar uma cópia com um novo nome.
Grava todos os ficheiros abertos.
Volta a carregar o ficheiro actual para mostrar as alterações feitas pelos outros programas. (Lembre-se que estas alterações são normalmente detectadas automaticamente e o utilizador é avisado para dizer se deseja carregar os ficheiros novos).
Reverte todas as modificações feitas nos ficheiros abertos. Avisa o utilizador para gravar as alterações, para que essa reposição possa ser cancelada para cada ficheiro modificado.
Imprimir.
Exportar
Fecha o ficheiro actual.
Fecha todos os ficheiros abertos.
Fecha todos os ficheiros excepto o actual. É muito útil se tiver aberto vários ficheiros e só se deseja concentrar no actual. Sem isto, teria de fechá-los a todos e voltar a abrir o actual.
Repare que existe uma opção semelhante no menu Janela.
Fecha o KDevelop.
Desfazer
Refazer
Cortar
Copiar
Colar
Seleccionar Tudo
Deseleccionar
Modo de Selecção em Bloco
Modo de Sobreposição
Procurar
Procurar o Seguinte
Procurar o Anterior
Substituir
Ir para a Linha
Procurar nos Ficheiros
Procurar-Seleccionar-Substituir
Formatar o Código
Expandir o Texto
Expandir a Abreviatura
Completar o Texto
Criar o Membro
Recuar
Avançar
Mudar para...
Elevar o Editor
Erro Seguinte
Erro Anterior
Modo de Ecrã Completo
Mudar Para a Declaração/Implementação
Janelas de Ferramentas
Acoplagem de Ferramentas
Mudar para a Linha de Comandos
Esquema
Mudança de Linha Dinâmica
Indicadores de Mudança de Linha Dinâmica
Mostrar/Esconder o Marcador Estático de Mudança de Linha
Mostrar/Esconder o Contorno dos Ícones
Mostrar/Esconder os Números de Linha
Mostrar/Esconder as Marcações da Barra de Posicionamento
Mostrar/Esconder as Marcas de Expansão/Recolhimento do Código
Dobragem do Código
Escolher a Codificação
Novo Projecto...
Abrir um Projecto...
Abrir um Projecto Recente
Linguagem Activa
Importar um Projecto Existente...
Nova Classe...
Diagrama de Herança de Classes
Adicionar uma Tradução...
Configuração da Compilação
Distribuição & Publicação
Opções do Projecto...
Fechar o Projecto
Construir o Projecto
Construir o Alvo Activo
Compilar o Ficheiro
Correr o 'Configure'
Executar o 'automake' & outros
Instalar
Instalar (como utilizador 'root')
Limpar o projecto
Distclean
Mensagens do Make & Reunir
Executar o Programa
Criar a Documentação da API
Limpar a Documentação da API
Parar
Iniciar
Parar
Interromper
Executar Até Ao Cursor
Avançar Sobre
Avançar Sobre a Instrução
Avançar Para
Avançar Para a Instrução
Sair
Comutar o Ponto de Paragem
Visualizadores
Examinar o Ficheiro 'Core'...
Anexar ao Processo
Verificação de Fugas de Memória do Valgrind
Análise com o KCachegrind
Fechar as Janelas Seleccionadas...
Fechar
Fechar Tudo
Fechar Todos os Outros
Modo Apenas de Leitura
Modo do Tipo de Ficheiro
Modo de Realce
Fim da Linha
Ortografia
Indentar
Desindentar
Limpar a Indentação
Alinhar
Comentário
Descomentar
Maiúsculas
Minúsculas
Capitalização
Juntar as Linhas
Repartir o Documento
Visualizador das Diferenças...
Executar o Comando...
Filtra os dados seleccionados, através de um comando externo, usando o 'plugin' do Filtro.
Depurar a Expressão Regular...
Explorador de Componentes
Abertura Rápida de Classes...
Abertura Rápida de Métodos...
Antever o Resultado do Doxygen
Documentar a Função Actual
Mostra ou esconde a barra do menu.
Abre um sub-menu onde você poderá optar por mostrar ou esconder as várias barras de ferramentas disponíveis.
Mostra a barra de estado.
Configurar os Atalhos...
Configurar a Barra de Ferramentas...
Configurar as Notificações...
Configurar o Editor...
Configurar o KDevelop...
Vê este documento.
Mostra um ponto de interrogação (?) ao lado do cursor do rato, pelo que se carregar num item da janela, como o botão Parar, irá mostrar uma explicação breve.
Dica do Dia
Procurar no Índice da Documentação...
Procurar na Documentação...
Página do 'Man'...
Página do 'Info'...
Comunica um erro.
Mostra alguma informação breve sobre o número de versão do KDevelop, os autores e o contrato de licença.
Mostra alguma informação acerca da versão do KDE que você está a executar.
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
A documentação está licenciada ao abrigo da GNU Free Documentation License.
Este programa está licenciado ao abrigo da GNU General Public License.
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
03-01-2003 — Início deste Changelog
02-05-2005 Muitas alterações de Volker Paul, incluindo:
divisão em ficheiros por cada capítulo/apêndice
adicionada a referência dos comandos ordenada pelo menu (as descrições ainda não estão completas)
Tutorial do AppWizard no 'getting-started.docbook'
Reorganização dos capítulos, inspirada no manual do Konqueror
Moveu-se a instalação, a programação em Unix e o "num Minuto" para o apêndice
Reformulação do apêndice de 'plugins, incluindo o gerado da lista de 'plugins' listplugins.sh
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
Índice
(... ainda não escrito ...)
GNU Autoconf, Automake, and Libtool. 1st edition. October 2000. New Riders Publishing. ISBN 1578701902.
Advanced Programming in the UNIX® Environment. 1st edition. June 1992. Addison-Wesley Pub Co. ISBN 0201563177.
Thinking in C++, Volume 1: Introduction to Standard C++. 2nd Edition. April 15, 2000. Prentice Hall. ISBN 0139798099.
Open Source Development with CVS. 2nd Edition. October 12, 2001. The Coriolis Group. ISBN 158880173X.
Programming PHP. 1st edition. March 2002. O'Reilly & Associates. ISBN 1565926102.
Programming Python. 2nd Edition. March 2001. O'Reilly & Associates. ISBN 0596000855.
Gui Programming With Python : Using the Qt Toolkit. Bk&Cd-r edition. January 2002. Opendocs Llc. ISBN 0970033044.
Programming Perl. The Camel book. 3rd Edition. July 2000. O'Reilly & Associates. ISBN 0596000278.
Learning Perl. The Lama book. 3rd Edition. July 15, 2001. O'Reilly & Associates. ISBN 0596001320.
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team