]>

# Manual do Utilizador do KDevelop

Ralf Nolden
A Equipa do KDevelop

    <Ralf.Nolden@post.rwth-aachen.de>

Versão 2.0 , Abril 11,1999

O Guia de Referência para o Ambiente De Desenvolvimento Integrado KDevelop para Sistemas Unix, Versão 2.0. Este manual em si é parte do Ambiente de Desenvolvimento Integrado KDevelop e é assim também licenciado sob a Licença Genérica Pública GNU; veja Copyright para mais informações.

KDE

## Introdução

Como tudo na Terra parece ter as suas modas, o mundo da informática hoje em dia parece tender mais para a utilização de aplicações gratuitas mesmo para fins comerciais. O projecto de aplicações gratuitas mais popular é o Linux. É já ponto acente que o Linux, (bem como outros projectos tais como o servidor de páginas Apache, a linguagem Perl e o conjunto de ferramentas GNU), comprova que as aplicações gratuitas podem ser de tão boa qualidade como as aplicações comerciais. Mas apesar da qualidade, o utilizador final ainda tem de sofrer com os comandos crípticos de qualquer Sistema UNIX. Para o Linux prosperar, necessita de aplicações, tanto gratuitas como comerciais, e facilidade de utilização.

O project KDE
tenta diminuir este fosso providenciando um ambiente gráfico fácil de utilizar e as bibliotecas necessárias para aumentar a variedade de aplicações baseadas num ambiente gráfico (GUI) disponíveis. Mas como principalment as aplicações gratuitas são feitas nos tempos livres dos autores, a pergunta para muitos programadores é o quanto gostam eles do seu ambiente de desenvolvimento actual. O KDevelop deseja realizar um novo grande passo: tornar a vida do programador mais fácil e mais eficiente: produtos criados com o KDevelop podem atingir um nível superior de confiança e funcionalidade no mesmo período de desenvolvimento.

Para atingir este objectivo, o Ambiente Integrado de Desenvolvimento KDevelop oferece muitas funcionalidades que os programadores necessitam bem como encapsula a funcionalidade de projectos de terceiros tais como o `make` e o compilador GNU C++ e torna-os uma parte integrante, invisível, do processo de desenvolvimento. O KDevelop gere:

- Todas as ferramentas de desenvolvimento necessárias para programação C++ tais como compilador, linkador ('linker'), automake e autoconf,

- KAppWizard, que gera aplicações base completas e prontas a utilizar,

- Gerador de Classes, para criar novas classes e integra-las no projecto actual,

- Gestão de ficheiros para fonte, headers, documentação etc. para serem incluídas no projecto,

- A criação de Manuais do Utilizador escritos em SGML e a geração automática de output em HTML com a aparência e funcionamento KDE,

- Documentação da API baseada em HTML automática para as classes do seu projecto com referências cruzadas para as bibliotecas utilizadas,

- Suporte para a internacionaliação da sua aplicação, permitindo aos tradutores facilmente adicionar a sua linguagem alvo ao projecto,

- Criação WYSIWYG (O que vê é o que obtem) de interfaces de utilização com um editor de caixas de diálogo incorporado,

- Depuração da sua aplicação através da integração do KDbg,

- Edição de imagens pixmap específicas do projecto com o KIconedit,

- A inclusão de qualquer outro programa de que necessite para o desenvolvimento adicionando-o ao menu "Ferramentas" de acordo com as suas necessidades individuais.

O KDevelop torna uma alegria trabalhar com todos os programas num local e poupa tempo automatizando processos standard de desenvolvimento bem como dando-lhe acesso directo e transparente a toda a informação de que necessita. Os mecanismos integrados de navegação estão desenhados para suportar requerimentos de documentação que os programadores tenham em conjunto com o seu projecto.

O visualizador de classes e o detector de erros levam-no a qualquer ponto do código do programa com um clique do rato sem ser necessário procurar ficheiros; Árvores de ficheiros dão acesso directo aos ficheiros do projecto e o sistema integrado de ajuda oferece um acesso soberbo à documentação electrónica de qualquer ponto dentro do ambiente gráfico.

### Alterações

Desde a última actualização, o trabalho debruçou-se principalmente em três áreas diferentes: o visualizador de classes, o editor de diálogos e a aparência e funcionamento em geral, incluindo novas funções de edição e a criação de aplicações KDE
. Por forma a conseguir tudo isto, estamos orgulhosos de dar as boas vindas aos dois mais recentes membros da equipa, Jonas Nordin, que desenvolveu um completo visualizador e analisador gramatical de classes, e Pascal Krahmer, que se juntou à equipa para implementar um editor de diálogos integrado. Outro trabalho tem sido feito em várias partes do ambiente, tais como um novo diálogo `grep` permitindo a procura de expressões através de todos os ficheiros do projecto ou mesmo de todo o sistema; utilitários de configuração melhorados; documentação revista e aumentada bem como um novo gerador de projectos.

### Sobre este Manual

Este manual do utilizador dá uma visão geral do ambiente do KDevelop e descreve brevemente o processo de desenvolvimento básico. Para mais informação sobre assuntos específicos de programação, sugerimos a leitura do Manual de Programação KDevelop incluído com o KDevelop, que cobre tems como compreender a estrutura das aplicações geradas e como criar aplicações KDE
completas utilizando projectos de exemplo.

A estrutura deste manual está assim separada nas seguintes partes:

- Capítulo Instalação, cobre os requerimentos do sistema, instalação e configuração do ambiente KDevelop.

- Capítulo Programas, diz-lhe como os programas são criados com ferramentas de desenvolvimento standard GNU e como são construídos.

- Capítulo Desenvolvimento com o KDevelop, leva-o numa pequena volta descrevendo as principais funcionalidades do ambiente.

- Capítulo Descrição Geral, explica os menus e diálogos bem como os atalhos de teclado.

- Capítulo O Sistema de Ajuda, mostra como utilizar o navegador de documentação incorporado e funções adicionais de ajuda.

- Capítulo Trabalhar com o Editor, explica as fucnionalidades de gestão de ficheiros e edição.

- Capítulo Projectos, descreve a criação e manutenção de projectos de aplicações.

- Capítulo Definições de Build, contém uma referência sobre como definir parâmetros de compilação e linkagem bem como opções de projecto.

- Capítulo O Navegador de Classes, diz-lhe como utilizar o potente Navegador de Classes do KDevelop.

- Capítulo O Editor de Diálogos, fala do construtor de inteface gráfico integrado e de como gera código C++.

- Capítulo Configuração Genérica mostra como pode definir preferências globais para a utilização do KDevelop.

- Capítulo Perguntas e Respostas, cobre perguntas que se relacionam com a utilização do KDevelop sob diferentes versões de sistemas Unix e resolução de problemas em geral.

Para iniciados na programação e novos utilizadores deste produto recomendamos que leia bem este manual antes de começar realmente a trabalhar com o ambiente pois cobre a sua utilização com profundidade. O entendimento de como as coisas podem ser feitas da forma mais rápida poupar-lhe-á imenso tempo procurando funcionalidades já que lhe permitirá a utilização de ferramentas de desenvolvimento de primeira classe ainda mais fácil.

## Instalação

### Como obter o KDevelop

O KDevelop pode ser encontrado quer na página de Aplicações KDE
(http://www.kde.org/current.html) ou na página principal do KDevelop (http://www.kdevelop.org). O KDevelop também está disponível em distribuições de Linux, tais como a SuSE 6.1.

Estamos a disponibilizar snapshots semanais do repositório CVS do KDevelop na nossa página de internet para aqueles que se querem manter actualizados com o KDevelop. Normalmente, as snapshots não são supostamente para utilização de produção mas sim para teste de novas funcionalidades e para dar uma prespectiva do progresso de desenvolvimento da equipa do KDevelop. Também disponibilizamos várias aplicações de terceiros que o KDevelop necessita directamente tal como o KDoc e o KDbg.

Se estiver a sentir problemas com a compilação ou utilização do KDevelop, por favor leia a secção Perguntas e Respostas deste manual ou o ficheiro "FAQ - Perguntas Colocadas Frequentemente" incluida com o pacote KDevelop. Se o seu problema não se encontrar mencionado, por favor subscreva a lista de discussão do KDevelop em kdevelop@fara3.cs.uni-potsdam.de enviando um e-mail com o "Assunto" vazio e com o corpo da mensagem a dizer apenas "subscribe". Pedidos e reporte de problemas devem apenas debruçar-se sobre a utilização do ambiente KDevelop e não dirigir-se a questões que tenha sobre problemas de implementação enquanto programa uma aplicação. De qualque forma, todos os e-mails enviados para a lista de discussão devem ser escritos em inglês, para que todos os participantes possam tomar parte na discussão e serem capazes de prestar melhor ajuda. A lista de discussão também se dirige aqueles que estejam dispostos a contribuir e que tenham encontrado soluções para quaisquer problemas encontrados, para que nós possamos corrigir erros e incluir esse conhecimento para prestar aos novatos uma ajuda ainda melhor e mais qualificada. Uma boa forma de reportar problemas é enviando o output que obtém iniciando o KDevelop da consola ou copiando e colando o conteúdo da Janela de Mensagens interna do KDevelop.

### Requerimentos

Por forma a compilar e utilizar com sucesso o KDevelop, necessita dos seguintes programas e bibliotecas que estão disponíveis para a maior parte das plataformas como pacotes de distribuição e podem, assim, ser facilmente instalados.

Requeridos:

- g++ 2.7.2/g++ 2.8.1/egcs 1.1 (ou compatível), disponível em http://www.gnu.org

- GNU make (ou compatível), disponível em http://www.gnu.org

- perl 5.004, disponível em http://www.perl.com

- autoconf 2.12, disponível em http://www.gnu.org

- automake 1.2, disponível em http://www.gnu.org

- Qt 1.42, disponível em http://www.troll.no

- KDE
  1.1.x, disponível em http://www.kde.org

Opcional:

- a2ps ou enscript para suporte de impressão

- ghostview ou kghostview para visualização prévia de impressão

- glimpse 4.0 para o índice de busca, disponível em http://glimpse.cs.arizona.edu

- sgmltools 1.0, disponível em http://www.sgmltools.org

- KDE-SDK
  (KDE Software Development Kit) com KDoc, KSgml2Html, KTranslator (disponível em http://developer.kde.org)

- KDbg, KIconEdit (disponível em http://www.kde.org)

O KDevelop foi testado com SuSE Linux 5.2 num AMD K6 200, 64MB RAM e FreeBSD 3.0-Release bem como um SuSE Linux 6.0 num Intel 200 MMX, 128MB RAM.

Tanto quanto os autores sabem, SuSE Linux e FreeBSD contêm todos os pacotes necessários, incluindo a2ps e enscript como pacotes ou rpm's, pelo que não deve ter qualquer problema a instalar as aplicações de terceiros requeridas.

Documentação:

Para criar a documentação da biblioteca KDE
, necessita do pacote das kdelibs em código fonte disponível no seu sistema como providenciado pelo projecto KDE ou incluido com os pacotes de código-fonte da sua distribuição e do KDoc (incluido no KDE-SDK
).

Estamos também a oferecer uma Referência C/C++ na nossa página principal em http://www.kdevelop.com que é integrada no navegador de documentação após a sua instalação. Descarregue o pacote e copie o ficheiro como `root` para o seu directório KDE
e descomprima-o `tar zxvf c&&lowbar;;c++&&lowbar;;reference.tar.gz`, após o que a referência estará disponível na árvore de documentação; caso contrário seleccionar o livro de referência no navegador mostrará uma página de erro com o endereço URL da página do KDevelop oferecendo o ficheiro e descrevendo o processo de instalação.

### Compilação e Instalação

Por forma a compilar e instalar o KDevelop no seu sistema, escreva o seguinte no directório base da sua distribuição do KDevelop:

    	&&percnt;; ./configure
    	&&percnt;; make

    	(como root)

    	&&percnt;; make install

Visto que o KDevelop utiliza o `autoconf` não deverá ter problema a compila-lo.

Por forma a compilar a snapshot do CVS do KDevelop, escreva o seguinte:

    	&&percnt;; make -f Makefile.cvs
    	&&percnt;; ./configure
    	&&percnt;; make

    	mude para `root` e escreva:

    	&&percnt;; make install

Se o comando make do seu sistema for `gmake`, escreva `gmake` em vez de `make`.

### Iniciar o KDevelop

Se utiliza o KDE
como gestor de janelas, o KDevelop pode ser iniciado escolhendo "K"&->;"Aplicações"&->;"KDevelop"&->;"KDevelop 0.4". Como o KDevelop suporta KDE
-Mime-types, também o pode iniciar seleccionando um ficheiro de projecto KDevelop ("*.kdevprj", apresentado com o icon de projecto do KDevelop) no Gestor de Ficheiros do KDE
o que iniciará o KDevelop e carregará o projecto. Utilizando outros gestores de janelas, abra uma consola e escreva:

    &&percnt;; kdevelop

Para iniciar o Kdevelop com um projecto existente, mude para o directório do projecto e escreva:

    &&percnt;; kdevelop  &<;seuProjecto&>;.kdevprj

Dentro de cada conta de utilizador o KDevelop irá invocar o processo de instalação automatica no primeiro arranque, permitindo uma configuração rápida das opções mais necessárias. Se a sua instalação estiver estragada, pode reconfigurar o KDevelop a qualquer momento quer escrevendo

    &&percnt;; kdevelop  --setup

ou, quando a utilizar o KDE, escolhendo "K"&->;"Aplicações"&->;"KDevelop"&->;"Setup".

### The Installation Program

O KDevelop inclui um módulo de instalação automatica que é invocado sempre que o Kdevelop é iniciado e o ficheiro de configuração kdeveloprc não existe. Sugerimos que siga os passos de instalação escolhendo "Prosseguir" para automaticamente verificar o seu sistema e configurar o ambiente do KDevelop.

Os botões de diálogo da instalação executam as seguintes acções:

Ajuda: Abrirá o programa KDEHelp.

Prosseguir: Isto inicia o processo de instalação e executa as seguintes acções:

1. Verificar a existência do make/gmake, autoconf, autoheader, automake e perl para a criação e compilação de novas aplicações geradas pelo KDevelop. Se o gmake estiver instalado, o comando make será definido automaticamente para utilizar o gmake. Outras opções de linha de comando para o seu programa make podem ser definidas no diálogo de configuração acessível pelo menu de opções, mais tarde. Uma introdução ao desenvolvimento em Unix é explicado na secção Programas.

2. Verificar a existência do KDoc e Glimpse. Estas permitirão criar automaticamente uma nova documentação de bibliotecas KDE e um indice de busca num passo seguinte da configuração, se encontradas.

3. Verificar a existência do a2ps e enscript para assegurar que é possível imprimir. Um destes dois programas tem de estar instalado para permitir imprimir correctamente. Se nenhum deles estiver instalado, pode faze-lo a qualquer momento mais tarde sem ter de correr a configuração de novo.

4. Verificar a existência do KDbg, KIconedit e KTranslator. Encorajamo-lo a instalar esses programas pois são bons ajudantes para criar aplicações KDE
   completas. Note que o KDbg é utilizado directamente para depurar o seu projecto actual dentro do KDevelop; o KIconedit é utilizado para apresentar e editar pixmaps seleccionados nas árvores de vista de ficheiros. Os programas KDbg, KIconedit e KTranslator serão então configurados para estarem disponíveis no menu "Ferramentas" da barra de menu do KDevelop se encontrados. Outras ferramentas podem ser adicionadas ao menu Ferramentas seleccionado "Ferramentas..." no menu de Opções mais tarde.

5. Resumo de programas detectados: a instalação lista os programas que encontrou e os que não encontrou. Dicas adicionais são dadas, see um um programa necessário for recomendado.

6. Detecção do caminho para a sua documentação electrónica Qt: verifica vários caminhos standard no seu sistema procurando a documentação e define o caminho automaticamente. Se a sua documentação Qt não tiver sido encontrada quer porque não está instalado ou o seu sistema a tem numa localização diferente, uma mensagem aparecerá pedindo-lhe para definir o caminho manualmente ou continuar. Escolhendo o botão para definir o caminho leva-lo-á de volta à janela principal de instalação e mostrará um campo de edição com um botão à direita para escolher o caminho. Normalmente isto é no directório qt/html. Após faze-lo, a instalação pode continuar com a selecção de "Prosseguir" novamente.

7. Se o KDoc foi detectado, ser-lhe-á pedido para criar/actualizar a documentação da sua biblioteca KDE
   . Para isso, precisa de ter as bibliotecas KDE em código fonte. Para utilizadore Linux que tiverem instalado o KDE
   de uma distribuição, sugerimos que copiem e extraiam o código fonte do pacote kdelibs para o seu sistema; utilizadores do Free BSD que tenham instalado as kdelibs como pacote deverão procurar o correspondente pacote de distribuição na colecção de portes. Se nenhum destes casos for o seu, deverá ir buscar o código fonte a http://www.kde.org e descomprimir as fontes no seu sistema. Se deseja utilizar o pacote de documentação disponibilizado por http://developer.kde.org, cancele a criação e continue criando o índice de busca. Depois do programa de instalação terminar e o KDevelop ter iniciado, defina o caminho para o pacote de documentação descomprimido no diálogo de Configuração do KDevelop e corra a configuração do índice de novo, que pode ser encontrado na mesma página do diálogo de configuração.

   O diálogo "Actualizar a documentação das bibliotecas KDE
   " é definido para utilizar um caminho por defeito para a localização da documentação em $(HOME)/.kde/share/apps/kdevelop/KDE-Documentation. A única coisa que tem a fazer é escolher o caminho para o código fonte das bibliotecas que descompactou no seu sistema com o botão de selecção no topo do diálogo e escolher OK. Como exemplo, se tiver o pacote kdelibs.tar.gz de http://www.kde.org e o tiver puxado para o seu directório principal, terá de abrir uma consola ou terminal e escrever "tar zxvf kdelibs.tar.gz". Isto irá descomprimir o código fonte para o directório $HOME/kdelibs, que então conterá o código fonte para cada biblioteca num subdirectório, por ex. para a kdecore, seria em /home/rnolden/kdelibs/kdecore. Agora, o caminho que tem de inserir no diálogo de documentação das bibliotecas KDEdeverá ser o caminho para todas as bibliotecas, no exemplo /home/rnolden/kdelibs.

   Se o caminho tiver sido definido correctamente, ser-lhe-á perguntado se a documentação deve ser criada utilizando a biblioteca khtml ou a khtmlw. Ambas disponibilizam um widget HTML que é utilizado para criar janelas que podem mostrar ficheiros HTML e é utilizado pelo KDEHelp e KFM. Como as classes são as mesmas em ambas as bibliotecas, decidimos apenas incluir uma biblioteca para documentação para evitar confusão devido ao facto de os ficheiros header que contêm as classes diferirem nos seus nomes. Após premir o botão OK, uma mensagem na janela de instalação mostra que ela está em progresso e que deve aguardar pela próxima mensagem.

   NOTA: Num sistema multi-utilizador ou sistemas com quotas de espaço em disco para contas de utilizadores, a instalação de uma documentação completa em HTML para cada utilizador seria um desperdício de espaço em disco. Neste caso, peça ao seu administrador de sistema para correr o KDevelop com a conta root para permitir acesso de escrita à raiz do sistema. Depois instalar a documentação dentro do directório KDE
   , debaixo de $KDEDIR/share/apps/kdevelop/KDE-Documentation. O caminho correcto pode depois ser definido mais tarde no diálogo de configuração do KDevelop, disponível no menu "Opções".

8. Se a verificação do sistema encontrou o programa Glimpse, é-lhe oferecida a possibilidade de criar uma base de dados de busca. A base de dados de busca pode ser criada com as opções de incluir a documentação KDE e a documentação Qt (defeito). Adicionalmente a documentação do KDevelop é incluida e será indexada. Se possuir outra documentação que deseje indexada pode seleccionar os directórios e adiciona-los também ao processo de indexação.

9. Durante a criação do index de busca, a janela de instalação apresentará uma mensagem indicando que está em progresso.

10. Se todos os passos de instalação tiverem sido realizados correctamente, uma mensagem final dirá que o KDevelop será iniciado após se premir OK. Lembre-se que pode definir opções adicionais tais como gravação automática no diálogo de Configuração do KDevelop que é acessível a partir do menu de opções.

Cancelar: Mostrará uma mensagem de aviso de que o processo de instalação será cancelado. Esta mensagem de aviso permite-lhe regressar à instalação ("Regressar") ou iniciar o KDevelop com os valores por defeito ("Continuar"). Lembre-se que neste caso terá de definir todas as opções sozinho com os diálogos de configuração disponibilizados no menu de opções.

## Programas

Agora que o KDevelop foi instalado com sucesso e as opções mais utilizadas estão configuradas, você está provavelmente a perguntar-se se o programa cumprirá as expectativas. Este capítulo dá-lhe as linhas mestras sobre como os programas são criados utilizando as ferramentas GNU em geral e especificamente que papel o KDevelop tem neste jogo.

### The Compiler

O compilador é na realidade o programa no seu sistema que tem de estar instalado como um mínimo para criar programas executáveis; é ele que compila o código fonte em ficheiros objecto e cria o programa.

Normalmente, você iniciaria assim: Abra um editor da sua preferência - não utilize um processador de texto. Escreva algo similar a isto para criar o código fonte do seu primeiro programa:

    #include <iostream.h>

    int main(){

    cout << "Olá Mundo!" << endl;

    }

Bem, na realidade tudo o que o programa fará é imprimir a frase "Olá Mundo!" no seu output standard. Mas isto é apenas o código fonte para o programa ser construido, não o programa em si. Por isso, necessitamos de um compilador, neste caso um compilador C++ como o g++. Depois podemos gravar este ficheiro com o código fonte, como, por exemplo, meuprograma.cpp e invocar o compilador com o nome de ficheiro (na consola):

    g++ -o meuprograma meuprograma.cpp

Depois podemos iniciar o nosso programa- basta escrever `meuprograma` na consola, e o programa imprime a frase; depois termina.

### Make e Makefiles

Tenho tudo o que necessito: um editor, um compilador e posso executar o meu próprio programa C++. Mas não é assim tão fácil. Que acontece se tiver mais de um ficheiro de código? E, tem de compilar todos os ficheiros de código vezes e vezes sem conta se apenas tiver alterado um ficheiro? Compilar tornar-se-á mais e mais complicado e moroso, porque tem de escrever todos os comandos e opções você próprio. Por isso, poderia escrever o que se chama uma "Makefile". Também lhe pode chamar qualquer outro nome excepto no nome do programa a construir. Depois, deverá ter a ferramenta `make` ou `gmake` instalada, ou qualquer outra ferramenta que seja capaz de manter registo da compilação de um projecto. Insira todos os comandos de compilação numa certa sintaxe nessa Makefile e grave-a; depois apenas terá de escrever `make` ou `gmake` na consola no directório onde a Makefile se encontra, e o make tomará conta da situação, levando o compilador a criar a sua aplicação. O utilitário make tem muitas outras vantagens e pode ser utilizado para bastantes fins. Para obter uma visão geral e total, abra uma consola e escreva:

`man make`

ou procure "GNU Make" no KDEHelp, "Sistema GNU Info conteúdos". Pelo menos, tem uma ideia, porque um programador necessita do utilitário make para tornar mais fácil compilar a sua aplicação. Agora, escrever Makefiles não é apenas trabalho manual até agora, também tem de pesquisar por si toda a sintaxe e opções. Mas aqui estão as boas notícias sobre o KDevelop e qualquer utilitário Make: Apenas tem de definir o comando Make no diálogo de Configuração do KDevelop e está tudo pronto. Todos os projectos gerados com o KDevelop irão utilizar aquele comando Make para construir a aplicação alvo, e nada de escrever mais. Apenas prima o botão na barra de ferramentas do KDevelop, a começar com o primeiro após a segunda linha separadora, ou escolha a função desejada para o Make no menu "Construir".

A barra de ferramentas e o menu construir então oferecem as funções mais comuns de que necessita para deixar o make fazer o trabalho sujo:

- Compilar Ficheiro: apenas está activo se você estiver a trabalhar num ficheiro de código. Invoca o make com o comando correcto para compilar apenas o ficheiro de código actual.

- Make: apenas chama o make e cria o seu alvo.

- Reconstruir tudo: reconstroi todo o projecto

- Limpar/Reconstruir tudo: limpa primeiro o directório do projecto e depois corre novamente o make.

- Parar Construção: cancela o processo actual- isto é principalmente utilizado se vir o make a trabalhar e a emperrar no seu código fonte. Então- ahh- Eu esqueci-me desta linha...e você tem de corrigir o seu código. Basta premir Parar, corrigir o erro que descobriu por si só e correr o Make de novo.

Mas esta não é a única forma como o KDevelop funciona em conjunto com o make- para aplicações KDE
, existem algumas coisas que são especiais, tal como criar ficheiros de mensagens para internacionalização. Estas funções estão também incluidas, pelo que não tem de se preocupar mais com estas coisas.

Até agora, você sabe sobre código fonte, o compilador e porque o make é necessário. Na próxima secção, iremos discutir como é que projectos criados com o KDevelop automaticamanre podem ser compilados em quase todas as outras plataformas Unix utilizando o script (ficheiro de código) `configure`.

### Configure

O título desta secção deixa-lhe provavelmente a questão: Configurar ? O que tem de ser configurado? Ou quem? Bem, assuma que escreveu um programa incluindo um Makefile. Depois deseja distribui-lo, mas o binário compilado apenas corre no seu sistema ou em sistemas que são compatíveis com o seu. Para suportar outras plataformas como diferentes sistemas Unix ou máquinas como Alpha's ou RISC's, tem de recompilar o programa. A forma mais simples seria copiar o pacote com o código fonte para a máquina alvo e executar `make` de novo. Mas e se a máquina alvo utiliza outro comando de compilador ou tem de outra forma um problema em construir o seu binário? Já para não mencionar assuntos mais difíceis tais como caminhos de instalação para o seu programa e documentação- por ex. o KDE pode estar instalado em ``opt/kde/ numa máquina, enquanto esta instalado em ``usr/local/kde/ noutra. Neste caso, você teria de re-escrever o Makefile cada vez para assegurar uma correcta compilação e instalação do seu produto.

Felizmente, as ferramentas GNU têm ainda mais a oferecer que aquele poderoso `make`- os muito utilizados pacotes automake e autoconf. Soa bem ouvir algo com "auto"- parece que algo sobre o desenvolvimento de aplicações pode ser feito fácil e rapidamente, o que completamente correcto.

O objectivo do Automake é basicamente criar um chamado `Makefile.in` a partir de um ficheiro `Makefile.am` que tem de escrever para o seu projecto. Este Makefile.am consiste em macros que podem ser interpretadas e reduzem a complexidade que o make apresenta, pelo que um Makefile.am é escrito mais segura e rapidamente que o Makefile final.

Tendo dito isto, quem é que afinal está a criar o meu Makefile ? Agora, aqui entra o autoconf. O Autoconf necessita de vários ficheiros de macro para o projecto. Esses ficheiros são o Makefile.in gerado pelo automake e um ficheiro chamado `configure.in`, também contendo macros. Assim o Makefile.am e .in contêm macros que são responsáveis pela forma como a sua aplicação é construida em termos de que código fonte é compilado, que ficheiros pertencem ao pacote e que nome o binário final ou biblioteca terá após a construção. O Configure.in por outro lado contém macros sobre o que o script de consola configure irá verificar no sistema em que o configure é executado. Poderão ser por ex. o comando de compilador, bibliotecas necessárias com as quais o binário final será ligado (linked), ficheiros include que o projecto necessita e a sua localização.

Por exemplo você deseja escrever uma aplicação KDE
. Após escrever o seu código, deseja distribuir o seu programa à comunidade, e cada utilizador tem de compilar o binário por si. Então você escreveria um ficheiro configure.in que conteria as macros para uma aplicação compatível com o KDE
. Essa macro irá expandir-se para verificar o sistema sobre se a biblioteca Qt está instalada, verificar onde estão os ficheiros header do Qt, as bibliotecas KDE e headers etc.

Resumo: Para criar uma aplicação compatível GNU que seja portável para diferentes sistemas operativos Unix e máquinas que não a sua, terá de fazer o seguinte:

1. escreva o código do seu projecto

2. escreva um Makefile.am para cada subdirectório, incluindo o directório principal do seu projecto

3. escreva um ficheiro configure.in gravado no directório principal do seu projecto contendo as macros com os requerimentos de sistema

4. execute o automake

5. execute o autoconf

Então o trabalho principal está feito. O Automake cria os Makefile.in, o autoconf processa o configure.in e Makefile.in's e gera um script de consola executável chamado `configure`. Tudo o que então tem a fazer é executá-lo com ./`configure` e o script fará as verificações da sua escolha. Finalmente os Makefiles serão gerados e permitirão uma execução final do make (ou gmake) que irá processar todos os Makefiles e tudo estará feito.

Isto parece ser um monte de coisas para escrever uma pequena aplicação e muito a aprender especialmente como escrever macros correctamente. Mas mesmo o facto de que possibilitará a compilação em quase todos os sistemas Unix valerá a pena mais cedo ou mais tarde. Finalmente, você apenas tem de fazer este trabalho uma vez para o seu projecto e no caso de os ficheiros do seu projecto aumentarem apenas terá de acrescentar os seus nomes às macros.

Agora, quão longe o KDevelop suporta este tipo de desenvolvimento aplicacional e quão complicado se torna para o programador? As boas noticias são, que você nem precisa de saber nada sobre macros e scripts. Todos os detalhes são escondidos atrás de um interface gráfico fácil de utilizar e que faz o trabalho por si. Uma aplicação é assim criada com as ferramentas GNU de uma forma muito amiga do utilizador:

Basta gerar a sua aplicação com o KAppWizard, pela escolha das necessidades da sua aplicação- seja ela uma aplicação pura de terminal em C++ ou um programa com uma espécie de interface gráfico utilizando as bibliotecas Qt
ou Qt/KDE
. Todo o trabalho é feito automaticamente e o seu projecto já conterá os Makefiles que são criados pela execução automática das ferramentas GNU e do script de configuração.

É tudo- está preparado para expandir o código do seu projecto, seja adicionando classes, diálogos, traduções ou documentação, o que é também completamente automatizado. Concentre-se apenas no verdadeiro trabalho do programador, que é criar funcionalidades para a aplicação final que deseja criar. Na maior parte dos casos, provavelmente não chegará a entrar em contacto com Makefiles de todo enquanto a utilizar o KDevelop.

### Depuração

A secção seguinte cobre um termo que é muito utilizado pelos programadores: Depuração (Debugging). Significa que, apesar do compilador produzir a aplicação final, a sua aplicação pode não correr ou bloquear durante a execução devido a um chamado "bug" (erro de código) no código. Um erro de programa descrito pelo nome deste insecto tem origem na história dos computadores; um dos primeiros erros que causou o "crash" de uma máquina não foi obviamente uma avaria- havia insectos dentro do computador que eram responsaveis pelo problema. Assim, um erro não detectado à primeira vista é chamado um "bug", pelo que "debugging" (depuração) significa retirar os "bugs" de onde eles não deveriam estar. Mas não precisa de os caçar a sério; assumindo que os computadores actuais são desenhados para os manter fora através de uma qualquer protecção exterior. Eles têm de ser encontrados dentro do código, quase sempre terminando a execução de um programa com a mensagem "Segmentation fault". GNU oferece outra ferramenta chamada `gdb`, o depurador GNU. Este programa de consola permite observar valores internos da aplicação e a execução passo a passo pela definição de "breakpoints" (pontos de paragem) no código. O Gdb pára a execução sempre que o programa atingir um ponto de paragem enquanto a correr. Mas tal como a maioria das ferramentas, o depurador é gerido por outro programa disponibilizando um interface, permitindo facilmente observar valores e a definição de pontos de paragem no código.

Para este porpósito, a aplicação do seu projecto é criada por defeito com uma opção de compilador para depuração, guardando assim informação adicional no executável para permitir a localização de valores e linhas no código. Sendo um interface de terceiros para o gdb, o KDevelop utiliza o KDbg, o KDebugger. Para depurar o seu programa, apenas tem de seleccionar "Depurar" no menu Construir ou premir o correspondente botão da barra de ferramentas apresentado por uma roda com uma lupa sobre ela, sinalizando que você deseja observar a execução.

O KDevelop abre então a janela de ferramentas e inicia a sua aplicação com o KDbg. O interface do KDbg surge dentro da janela de ferramentas e permite a sua utilização tal como se o tivesse iniciado de fora.

Em geral, os passos acima estão claramente a indicar a necessidade de algumas medidas que um programador tem de tomar quando inicia a codificação da sua aplicação, e cobre aspectos que são comuns a todos os projectos. Também, explicamos que parte do trabalho o KDevelop faz pelo programador e como suporta a ideia de oferecer uma maneira simples de programar em Unix. Para obter mais informações sobre o papel e propósito das ferramentas GNU, deverá ler a documentação disponibilizada com elas, facilmente acessível através do comando `man` ou pela secção "Sistema GNU Info conteúdos" no KDEHelp.

## Desenvolvimento com o KDevelop

Neste capítulo obterá uma visão genérica sobre como pode utilizar o KDevelop e o Editor de Diálogos interno para criar as suas aplicações. Assim, todas as ferramentas são descritas pela sua utilização durante o processo de desenvolvimento. Se é um iniciado no desenvolvimento C++/Interface Grafico Utilizador (IGU) e programação, deverá ler "O Manual de Programação KDevelop", que descreve alguma informação básica para desenho de programas e mostra uma utilização mais detalhada do KDevelop através de projectos exemplo que pode seguir passo a passo para se habituar com a forma como as aplicações são criadas utilizando o KDevelop. Deverá também ter lido o capítulo Programas para possuir um entendimento genérico porque aplicações Unix devem fazer uso das ferramentas de desenvlvimento disponibilizadas; isto fará as coisas mais fáceis quando atingir referências sobre o que são Makefiles etc.

### O que são Projectos de Aplicações KDevelop?

Projectos criados com o KDevelop tornam mais fácil para os programadores a utilização das ferramentas standard de desenvolvimento GNU. Os Makefiles gerados automaticamente, que têm de ser escritos de qualquer forma devido à complexidade do projecto, oferecem não apenas uma melhor forma de gerar Makefile mas também um meio bom e seguro de oferecer uma rápida adaptação em direcção a diferentes sistemas através de scripts de `configure` gerados pelo autoconf.

A distribuição das suas aplicações não requer que o utilizador final tenha nada de mais instalado além do compilador C++ e das bibliotecas de desenvolvimento, o que é o caso quase sempre; mas pode também distribuir pacotes de binários das suas aplicações. De qualquer forma, o utilizador final do seu produto não necessita de ter o KDevelop instalado. Para distribuir o seu código fonte, aconselhamo-lo a incluir também o ficheiro de projecto do KDevelop, já que isto torna mais fácil a outros programadores trabalharem com o seu código fonte se também utilizarem o KDevelop. Para projectos em que vários programadores, talvez trabalhando em diferentes locais, estão envolvidos, este deve ser também o caso para assegurar consistência nos Makefiles para que não depare com problemas. Especialmente em aplicações multi-idiomas, os tradutores não irão realmente trabalhar com o código fonte, excepto nos casos em que requeiram correcções para permitir suporte para traduções. De qualquer forma, eles ficarão agradecidos pois o KDevelop simplifica-lhes o trabalho a um mínimo adicionando o seu idioma e reduzindo o trabalho para que se concentrem na tradução.

Com a utilização do KDevelop para os seus projectos, poderia iniciar a criação de uma nova aplicação com o KAppWizard. Aí, poderia também definir o tipo de projecto de acordo com os objectivos do seu programa. Depois, iniciaria o desenvolvimento do interface do utilizador adicionando widgets que já se encontram construidos nas bibliotecas e apenas têm de ser chamados pela sua aplicação, ou por auto-construções que podem ser feitas com o editor de diálogos. Depois vem a extensão do interface do utilizador pela alteração e extensão daquelas partes que já foram feitas pelo KDevelop tal como a barra de estados, barra de menu e barra de ferramentas. Como os resources são coleccionados num ficheiro resource, isto pode ser expandido apenas adicionando novos valores aos já existentes; os resources existentes podem também ser utilizados como linhas de orientação para adicionar os seus específicos. Após implementar a funcionalidade a métodos que são ou gerados vazios pelo editor de diálogo ou já contêm código para acções standard do utilizador, deverá aumentar o Manual do Utilizador simplesmente editando o ficheiro de índice em sgml que é fornecido no sentido de descrever as capacidades da sua aplicação. O último passo seria gerar os ficheiros de tradução e distribuir o seu projecto aos tradutores para fazerem o restante no sentido de potenciar a internacionalização.

Mas mesmo para programadores de aplicações não-gráficas o ambiente gráfico de desenvolvimento oferece uma forma fácil de criar novos projectos; o editor e o Navegador de Classes em conjunto com a poderosa gestão de projectos do KDevelop irá reduzir o tempo de desenvolvimento a um mínimo que é requerido para a implementação das funcionalidades.

### Breve Descrição das Ferramentas do KDevelop

Com KDevelop você escolheu um pacote, que, em conjunto com a utilização de outras ferramentas, lhe disponibilizará um ambiente perfeito e flexível para desenvolvimento orientado por objectos de aplicações em Sistemas Unix. Geralmente, o KDevelop consiste do ambiente de programação e do editor de diálogos; para além disso todos os programas necessários que possam ser úteis para a programação de aplicações estão imbutidos de uma forma ou de outra.

#### Ambiente de Desenvolvimento e Editor de Diálogos

##### O Ambiente de Desenvolvimento

O Ambiente de Desenvolvimento é o interface do utilizador que o KDevelop disponibiliza para a criação e manutenção de projectos, utilizando implicitamente muitas outras ferramentas simplificando a sua utilização. O Editor e Navegador de Ajuda incorporados bem como o Navegador de Classes reduzem a quantidade de trabalho que o processo de desenvolvimento normalmente coloca sobre o programador. A facilidade de utilização tornam a programação de aplicações para Unix um prazer por si só e irá provavelmente resultar em ciclos de lançamento de novas versões mais curtos e mais melhorias nas características. A partir daqui, está a gerir o seu projecto através de todos os seus detalhes, mantém uma visão geral das suas classes e não tem de utilizar consolas adicionais para o seu trabalho, bem como a integração de todos os interfaces de utilizador resulta em que você apenas tem de trabalhar com uma janela dentro do X e em vez de ter de controlar várias espalhadas pelo seu ambiente de trabalho.

##### O Editor de Diálogos

O editor de diálogos incorporado no KDevelop oferece uma forma simples de desenhar interfaces de utilizador com as bibliotecas Qt
e KDE
. A sua forma simples de fazer quase tudo com o rato permite uma construção rápida de diálogos e ecrãs principais para aplicações e a sua transformação directa em código C++, que é directamente adicionado ao projecto. Como o editor de diálogos está incorporado no resto do interface do utilizador KDevelop, tem disponíveis os mesmos comandos que teria estando a trabalhar em modo Programação. Isto permite por ex. construir um diálogo, geração de código de output e o seu teste directo dentro do programa pela disponibilidade dos comandos make e pode ainda controlar o output do compilador sem ter de voltar para a vista de programação. Para uma descrição detalhada, veja \|\|.

#### KAppWizard e as Ferramentas de Classes

O KAppWizard e as Ferramentas de Classes oferecidas para geração de projectos e extenção automática de código têm como intuito tornar a criação de aplicações fácil e segura e oferece uma boa forma de iniciados na programação Qt
/KDE
iniciarem-se e realmente trabalharem nos detalhes de desenho do Interface Gráfico do Utilizador da aplicação, já que os resultados conseguem ser atingidos muito rapidamente.

##### KAppWizard

O KAppWizard tem como objectivo criar projectos de aplicações completamente funcionais que estão prontos a correr utilizando ferramentas standard GNU e, para programas gráficos, ganhar proveito das bibliotecas KDE
e Qt
. Especificando apenas a informação que é requerida como um mínimo, os utilizadores podem começar a trabalhar num novo projecto em segundos. Chamar o KAppWizard deveria ser o primeiro passo a ser realizado para criar novas aplicações com o KDevelop.

O KAppWizard oferece-lhe um chamado esqueleto (ou moldura) de aplicação com todos os ficheiros de código C++ necessários para uma aplicação executável. Depois de você especificar um nome de projecto e defenir as preferências necessárias, o seu novo projecto será gerado e terá uma aplicação completa que já conterá imensas funcionalidades (para projectos KDE e Qt), sem mesmo ter de escrever uma linha de código C++ sozinho. Caso especifique o conjunto total de opções que o gerador de programas disponibiliza, a sua aplicação já conterá:

- um interface SDI (para trabalhar com um documento por janela de aplicação), baseado no modelo de controlo de vista de documento

- Menus e diálogos para abrir e gravar ficheiros bem como diálogos de impressão

- uma barra de ferramentas e de estados já dispondo de total funcionalidade

- um sistema de ajuda, contendo um manual do utilizador baseado em sgml e uma ajuda de barra de estados

- uma documentação API (interface de programação da aplicação) completa baseada em HTML para o estado actual do projecto

- uma rotina de instalação através do make

O KAppWizard está disponível no menu Projecto, opção "Novo...".

##### Ferramentas de Classe

O termo "Ferramentas de Classe" descreve uma variedade de funções que estão disponíveis para o programador num projecto não só através de uma linguagem orientada por objectos mas utilizando o código fonte de uma forma orientada por objectos. Trabalhando com classes em vez de ter de olhar para ficheiros oferece uma forma muito flexível de extender o seu projecto e permite ao programador concentrar-se nos objectos que o projecto contém. As ferramentas que o KDevelop oferece são um Gerador de Classes e um Navegador de Classes, em que cada um disponibiliza bastantes funcionalidades automatizadas.

###### Criar uma nova classe com o Gerador de Classes

Após gerar um projecto com o KAppWizard o seu trabalho como programador seria adicionar um conjunto de classes que coincidiriam com o desenho da aplicação. O processo típico sem utilizar o KDevelop seria criar um novo header e ficheiro de código fonte, adiciona-los manualmente ao correspondente Makefile.am e começar a escrever as declarações e implementações de classe. Para simplificar todo o processo, o Gerador de Classes permite-lhe fazer isto apenas especificando a nova classe pelo seu nome, classe de onde herda, atributos herdados e mais informação tal como documentação da classe segundo os seus objectivos para o projecto. Adicionalmente, pode também mudar os nomes dos ficheiros que são pré-definidos pelo gerador e se a classe teria por defeito Qt-sinal/espaço (signal/slot).

O resto do trabalho é feito automaticamente- não tem de se preocupar com os Makefile.am, ficheiros e a classe em sí. Uma nova invocação do "make" é o suficiente para incluir a nova classe no processo de compilação. Como o Navegador de Classes se actualiza após a adição de uma classe, a declaração e implementação está disponível desde logo e pode começar a trabalhar na extensão da classe. O Gerador de Classes é invocado pelo menu Projecto, opção "Nova Classe".

###### O Navegador de Classes

O Navegador de Classes apresenta todos os tipos de objectos e funções do seu projecto numa árvore à esquerda das janelas de edição. Um analisador de classes percorre todos os ficheiros procurando métodos e classes e torna-os acessíveis através de símbolos gráficos. Sobre eles, menus de contexto oferecem uma funcionalidade especializada para trabalhar com o código fonte focando-se nas classes e funções.

Seleccionar uma classe resultará na abertura do ficheiro que contém a declaração; em métodos e funções isto irá mostrar-lhe a implementação. Para uma descrição completa, veja O Navegador de Classes

### O Processo de Desenvolvimento

O desenvolvimento de uma nova aplicação com o KDevelop pode ser geralmente dividida em dois passos principais: primeiro, tem de gerar um esqueleto de programa com o KAppWizard, depois o "resto" do desenvolvimento tem de ser feito utilizando as características do KDevelop, que apenas necessitam das suas capacidades como programador. Para descrever o processo de desenvolvimento, nós assumimos que deseja criar uma aplicação Qt/KDE
, que implica utilizar a maior parte das características do KDevelop para trabalhar com estes tipos de projectos, para que tenha um "Como-Fazer" geral.

#### Criar um Esqueleto de Programa

Para começar a criar a sua aplicação, normalmente invoca o KAppWizard, introduz o nome do projecto e gera o programa. Através disto, o assistente cria automaticamente um ficheiro de projecto para a aplicação e insere as áreas do KDevelop nos Makefile.am's que serão utilizados mais tarde quando expandir a aplicação. O ficheiro de projecto é o ficheiro que tem de executar para abrir o projecto em sessões posteriores.

Você chama o KAppWizard pelo menu "Projecto", opção "Novo...". Quando o assistente surge, tem de especificar o tipo de projecto na primeira página. Seleccionando "Seguinte >>" leva-o à página seguinte onde tem de inserir o nome, versão e directório do projecto e a sua informação pessoal. A página 3 oferece opções mais detalhadas, as páginas 4 e 5 permitem a edição dos cabeçalhos para os ficheiros header e de implementação que são inseridos automaticamente de acordo com a sua selecção. Se já possui cabeçalhos de ficheiro que deseja utilizar, pode seleccionar esses ficheiros também. A última página contém uma janela de output e uma janela de mensagem de erro. Quando seleccionar "Criar", a sua aplicação será gerada e as acções que forem executadas podem ser observadas na janela de output. Se surgir PRONTO (READY) na janela de output, o KAppWizard termina e pode seleccionar "Sair" para regressar ao ambiente de programação. Para construir o binário, escolha "Make" do menu Construir ou escolha o botão correspondente na barra de ferramentas. Pode também testas as funções já existente escolhendo "Executar" a partir do menu Construir.

#### Desenvolver uma Aplicação

Esta secção descreve a fase de desenvolvimento de aplicações com o KDevelop e o Editor de Diálogos - e todo o trabalho pode ser feito dentro do Ambiente Gráfico.

Os passos de desenvolvimento são geralmente editar os ficheiros de código fonte, a compilação do código do projecto seguido do processo de ligação unindo todos os ficheiros objecto ao binário final. Então os erros tem de ser encontrados quer sejam dos que impedem a compilação ou linkagem ou são erros de semântica que podem ser encontrados através de uma sessão de depuração. Finalmente, a documentação tem de ser acrescentada e traduções têm de ser adicionadas. Mas como todos esses passos se podem misturar, não é assim tão fácil descrever uma forma genérica de como desenvolver a sua própria aplicação. Geralmente, o procedimento habitual seria primeiro criar todas as partes visíveis do projecto tal como o ecrã principal e os diálogos para configurar quaisquer opções, depois gerar o código fonte e implementar todas as conecções necessárias que ainda tenham de ser feitas tal como modificar as barras de menu e de ferramentas, adicionar ajuda na barra de estados para entradas de menu e preencher as novas funções membro com objectos que são apresentados nos seus diálogos. Depois compilaria a sua aplicação e testaria as suas capacidades, corrigiria erros e testaria de novo. A secção seguinte descreve como isto poderia ser realizado; para a sua aplicação particular poderá seleccionar outra forma- o KDevelop deixa-lhe flexibilidade suficiente para decidir o que fazer e quando o fazer.

##### Interfaces do Utilizador

O Interface do Utilizador de uma aplicação é na realidade o que o utilizador vê e através do que interage com o programa. Assim um programa geralmente tem uma barra de menu, barras de ferramentas e de estados bem como uma janela principal que seria por ex. uma janela de inserção de texto para um editor. As aplicações geradas pelo KAppWizard já possuem uma complexa funcionalidade no interface gráfico- a estrutura base toma conta de elementos standard tais como barras e botões. Quando a desenvolver a sua aplicação, tem de expandir a estrutura dada para oferecer ao programa a capacidade de interacção com o utilizador que deseja prestar. Uma parte do trabalho é o desenho dos diálogos por ex. para alterar valores tais como a grossura do pincel numa aplicação de desenho. Isto pode ser facilmente realizado com o Editor de Diálogos dentro do KDevelop. Agora, como criar esses diálogos com tão bom aspecto? Como a biblioteca Qt é um conjunto de ferramentas de Interface Gráfico, disponibiliza um conjunto base dos chamados "widgets" tal como etiquetas apresentando texto, linhas de edição para entrada de texto e botões para navegação e selecção de comandos. Para além destas partes de "baixo-nível" do interface de utilização, diálogos standard são fornecidos e estão prontos a usar tais como o diálogo de impressão. As bibliotecas KDE
são por sua vez baseadas na biblioteca Qt e contêm substitutos para alguns diálogos bem como widgets adicionais que podem ser utilizados na sua aplicação. Assim, quando iniciar o desenho do comportamento da sua aplicação em relação ao utilizador, deverá fazer por estar á-vontade com os widgets disponibilizados com a Qt
e KDE
. A documentação electrónica da Qt disponibilizam capturas de ecrã da maior parte deles, pelo que deverá vê-los lá primeiro. Depois aconselhamo-lo a verificar com mais atenção a biblioteca KDE-UI, que disponibiliza outros widgets. Bibliotecas como a biblioteca KHTML contêm widgets extremamente especializados de que imensos programas utilizam. Isto simplifica o desenho de aplicações tais como os diálogos pré-definidos oferecidos com o Qt. Para os seus próprios diálogos, aqueles widgets de baixo-nível são o que necessita. Um diálogo consiste meramente na colecção de diferentes widgets combinados em conunto para construir o interface e é tecnicamente programado em código C++ numa classe que é derivada da QWidget ou uma classe de diálogo mais especializada que herda a QWidget. O programa que utiliza um widget necessita assim de um objecto da classe do widget- isto é praticamente tudo o que tem de compreender sobre como os diálogos ou vistas são utilizados.

O Editor de Diálogos do KDevelop dispõe agora de uma forma simples de construir diálogos e interfaces de utilizador visualmente em vez de ter de combinar diálogos com puro código C++- esta é a forma difícil de criar interfaces. Alterne para o Editor de Diálogos escolhendo a entrada correspondente no menu "Ferramentas" (ou pelo botão da barra de ferramentas). Verá que o aspecto do KDevelop mudou mas por ex. a barra de menu e de ferramentas são bastante similares. Isto torna muito fácil saltar de trás para a frente entre os dois modos de trabalho e você sentir-se-á confortável em ambos passado pouco tempo. Aí poderá construir as suas vistas e diálogos como desejar e definir todas as preferências disponíveis para os items que a vista conterá. Quando terminar, seleccione "Gerar Código" a partir do menu Construir; o Editor de Diálogos e a gestão do projecto tomarão conta do resto. Pode testar se tudo funcionou correctamente seleccionando Make ou Executar, o que irá construir a sua aplicação incluindo o novo código. Mas não espere que os diálogos já estejam a funcionar- isto é uma questão de implementação que é a forma habitual como um programador trabalha. Não se preocupe- isto também não é muito difícil. Para mais informação sobre criar diálogos, veja O Editor de Diálogos, exemplos e linhas de orientação podem também ser encontradas em O Manual de Programação KDevelop.

##### Ligar Novos Elementos

Após ter criado o seu interface de utilizador e gerado o código, está pronto a fazer a sua aplicação utiliza-los por objectos. Como descrito acima, um programa baseado num interface gráfico normal contém barras e a janela principal; adicionalmente a janela principal funciona com as barras, que são parte da classe principal da aplicação, e do objecto documento a que está conectado. Em termos de desenho orientado por objectos, descreveria a arquitectura dada como o modelo "Controlador de Vista de Documento". Este modelo descreve as funções básicas para objectos numa aplicação no que respeita ao seu papel dentro do programa. O Controlador representa aquele que coordena a aplicação principal e permite a interacção do utilizador através da barra de menu e barras de ferramentas e status adicionais. A classe Documento toma a tarefa de representar um documento com que o utilizador trabalha. Assim, uma classe documento deveria realizar todas as acções tal como ler ficheiros e grava-los novamente. A vista é agora o centro da janela da aplicação, mostrando ao utilizador uma parte do documento visualmente e disponibilizando todas as funções para manipular os dados. Como as barras de menu e ferramentas já estão presentes, o seu trabalho seria criar a vista principal e diálogos adicionais através dos quais o utilizador pudesse modificar quaisquer definições ou ter acesso a funções adicionais.

Para construir a sua vista principal, o código fonte gerado para a sua aplicação já contém uma classe sob a forma de &<;YourApplication&>;View (Vista&&lowbar;;de&&lowbar;;Sua&&lowbar;;Aplicação) que herda da classe QWidget (esta é a classe mínima que gere interfaces visuais em Qt e assim também em KDE
). Em geral, existem três maneiras diferentes de extender a dada classe:

- remover a estrutura de vista de documento e utilizar um dos "grandes" widgets pré-definidos que já contêm imensas funcionalidades- basta remover a View-class (classe-Vista) e substituir o objecto-vista por outro.

- alterar a herança da classe-Vista. Alterar a herança para por ex. QMultiLineEdit e a sua aplicação seria um editor.

- Se a sua vista principal consistirá de várias partes separadas, criar os widgets e as suas classes de que necessita com o editor de diálogos e criar objectos destas classes no construtor de vista de classes que em combinação irá construir a vista principal.

Para diálogos, as coisas são ligeiramente diferentes. A forma normal seria chamar um diálogo através de uma entrada na barra de menu e adicionalmente por um icon da barra de ferramentas. Após ter construido o seu diálogo e gerado o código, a classe está disponível para criar um objecto que irá ser o diálogo. Então primeiro terá de procurar um lugar funcional na barra de menu para adicionar a entrada que irá chamar o diálogo quando seleccionada pelo utilizador. Se os menus já existentes não coincidirem com as suas necessidades, crie um menu tal como os outros e insira a sua entrada e o espaço que quer chamar quando o item de menu for seleccionado. Depois implemente o espaço criando uma instância da classe de diálogo e chame o diálogo com as funções membras dadas pela classe base. Tem também de especificar um ID para a entrada de menu. As aplicações base têm todas IDs já atribuídos coleccionados num ficheiro resource.h, pelo que apenas tem de adicionar o ID e dar-lhe um novo número. E está feito- adicionalmente poderia construir um icon de barra de ferramentas novo e adicionar uma mensagem de ajuda para a barra de estados. A sua aplicação agora oferece uma nova funcionalidade que é visível ao utilizador. Agora tem de adicionar a implementação dos métodos com que o seu diálogo irá operar para manipular quaisquer valores. Finalmente, chamar a sua ferramenta make ou "Executar" e os ficheiros modificados serão recompilados; o resultado das suas alterações pode ser testado imediatamente.

##### O Processod de Desenvolvimento Completo

Acima, discutimos a maneira normal de como começar a trabalhar numa aplicação nova utilizando o KDevelop e como expandir o interface do utilizador. Agora, estes são os passos standard em que o ambiente gráfico o irá ajudar, mas o KDevelop faz mais do que disponibilizar ferramentas para criar aplicações e as suas componentes visuais. De seguida iremos ver uma breve descrição das principais funcionalidades que são oferecidas para melhorar o desenvolvimento de aplicações.

###### Gestão de Código Fonte

O ambiente gráfico do KDevelop disponibiliza imensos métodos para o programador atingir os seus objectivos no menor espaço de tempo. Como descrito acima, o KAppWizard e o Editor de Diálogos diminuem o tempo que normalmente necessitaria para obter o mesmo resultado manualmente. Mas isto não cobriu o trabalho que um programador normalmente tem de realizar: trabalhar na implementação da sua aplicação para proporcionar uma execução correcta pelo utilizador final. Agora, porque é o KDevelop o ambiente gráfico que desejaria utilizar como ambiente de desenvolvimento, incluindo a sua utilização para criar aplicações não-gráficas?

Implicitamente, o ambiente gráfico controla o seu projecto em geral; isso significa que, não tem de se preocupar em gravar as alterações, a geração de Makefile e por aí fora- isto é disponibilizar completa gestão de projecto, e o KDevelop mostra todo o seu poder aqui no desenvolvimento de qualquer tipo de aplicação C++. É fácil entender que, após tirar a gestão ao programador, ele está mais concentrado em trabalhar no código fonte. Por um lado, o código encontra-se normalmente espalhado por vários ficheiros ao longo do projecto, pelo que pode separar algumas partes. Mas isri ainda significa trabalhar da maneira difícil- sendo o programador, você ainda teria de lutar com a criação desses ficheiros e escrever conteudo standard tal como cabeçalhos de ficheiros contendo a data e o nome do autor bem como por ex. termos de licença para o código. Adicionalmente, isto requer que tenha que se lembrar onde as suas funções, declarações de classes e implementações estão no projecto. Assim, o KDevelop contém a Ferramenta de Classes- uma variedade de acções, que permitem um trbalho mais rápido e mover a atenção do programador de ficheiros para objectos- classes, estruturas e métodos. O gerador de classes permite-lhe criar facilmente uma nova classe incluindo a herança, atributos e documentação. Para trabalho orientado por objectos, o Navegador de Classes leva-o para a localização dos seus objectos; já não importa onde o código está na realidade. O Navegador procura todos os ficheiros de código automaticamente e reconstroi-se após adições para se actualizar com o seu trabalho e permitir-lhe acesso ao novo código directamente. Através de menus de contexto, o navegador oferece ainda mais funcionalidades, tais como leva-lo para a implementação ou para a declaração de funções membras. Depois, a adição de membros é feita graficamente por diálogos- não há a procura do ficheiro e do local em que teria de adicionar as suas entradas. Finalmente, pode obter uma vista ainda mais especializada das classes do seu projecto através do diálogo de Ferramenta de Classes, apresentando-lhe árvores que mostram a utilização, conteudo e herança das classes e seus objectos. Para informação mais detalhada, veja O Navegador de Classes.

###### Construir e Executar as Suas Aplicações

O ambiente do KDevelop está especialmente desenhado para lhe retirar os passos que tem de fazer periodicamente tal como construir e executar o seu programa bem como localizar erros no código fonte.

Você inicia o processo de construção com:

- carregando com o rato no símbolo "Construir" ou "Construir Tudo" na barra de ferramentas

- ou seleccionando "Construir"/"Construir Tudo" a partir do menu Construir.

Para executar a sua aplicação, escolha

- o símbolo "Executar" ou "Depurar" (inicia o KDbg com o seu programa) a partir da barra de ferramentas

- através das respectivas entradas de menu no menu Construir.

- ou através de "Executar com Argumentos" para iniciar a aplicação com argumentos adicionais

Para mais informações sobre o processo de construção, veja Projectos.

###### Procurar Erros de Programação

Naturalmente erros ocorrem ou durante o processo de construção (que são detectados pelo compilador e são chamados erros de sintaxe porque resultavam de uma sintaxe errada no código) ou durante a execução da aplicação, os quais têm de ser encontrados e removidos pelo programador. Para localizar erros, o programador necessita da informação de onde precisamente se dá o problema. Tal como mencionado, o compilador é capaz de detectar erros de sintaxe sozinho, resultando em que o executável não pode ser construido (isto pode também acontecer quando o linker detecta "unresolved symbols"-veja Opções de Linkagem). Como ele dá uma descrição do erro o mais detalhada possível, o erro pode ser encontrado e removido. Durante o processo de construção, verá a janela de output surgir mostrando-lhe o que a sua ferramenta make e o compilador têm a dizer. Em caso de erros ou avisos, basta premir o botão do rato sobre a linha de erro e o editor irá abrir o ficheiro afectado e colocar o cursor na linha do erro. Isto também pode ser feito através das entradas no menu "Ver", "Próximo Erro" e "Erro Anterior" ou através dos correspondentes atalhos de teclado. Irá descobrir que isto é extremamente funcional e poupa imenso tempo a chegar ao erro, apesar de que para o remover os seus conhecimentos como programador são vitais.

Erros de Execução (Runtime Errors), que ocorrem durante a execução e irão resultar numa "segmentation fault", são por vezes difícies de detectar. Assim, pode requesitar ao compilador que adicione informação dentro do binário para observar a execução através do código fonte. Um depurador é então outro programa que lhe permite fazer isto iniciando a aplicação e permitindo-lhe definir pontos de paragem (breakpoints) no código onde a execução pára, para que possa controlar implementações críticas e assim detectar pelo menos a linha que causa o erro. Descobrir a verdadeira causa é outra tarefa; depende do programador localiza-la. O gdb é um depurador que é disponibilizado com o compilador GNU e programas como o ddd ou KDbg são interfaces gráficos que permitem uma utilização mais fácil. O KDevelop utiliza assim o KDbg e permite-lhe invocar o processo de depuração através dos comandos "Depurar" no menu Construir ou através do símbolo "Depurar" na barra de ferramentas. Para mais informações sobre depuração de aplicações, veja Projectos e O Manual de Programação do KDevelop.

### Informação Adicional

Os tópicos abordados dentro deste capítulo são descritos em mais detalhe dentro da documentação disponibilizada com o ambiente de desenvolvimento KDevelop IDE e outra documentação:

- O Manual de Programação do KDevelop, cobre uma introdução completa no desenho de aplicações de interface gráfico e programação com as bibliotecas Qt e KDE
  ,

- este manual, secções Descrição Geral a Projectos, descrevendo todas as funções disponíveis dentro do KDevelop,

- este manual, secção O Editorde Diálogos, respeitante à utilização do editor de diálogos para criar os seus widgets,

- A Documentação Electrónica de Referência para a biblioteca Qt, que cobre exemplos da utilização do conjunto de ferramentas de interface gráfico Qt bem como uma classe de referência e imagens dos widgets prontos a utilizar mais importantes incluidos,

- A Referência de Classes da Biblioteca KDE, gerada automaticamente pelo KDevelop a partir do código fonte das bibliotecas KDE, contendo descrições de todas as classes e widgets incluindo exemplos para a sua utilização,

- na Internet, veja:

  - http://www.troll.no para informações sobre a Qt e widgets adicionais de terceiros,

  - http://www.kde.org para informações sobre o projecto KDE e linhas mestras de desenvolvimento,

  - http://developer.kde.org para referências adicionais para o desenvolvimento de aplicações KDE.

  - na página do KDevelop http://www.kdevelop.org

## Descrição Geral

Olhando para o KDevelop, o interface do utilizador pode ser descrito através da sua separação lógica: a janela principal, a vista de árvore e a janela de output, rodeadas pelas barras de menu, ferramentas e estados. Esta secção descreve o objectivo de cada parte do interface, começando pelas janelas, seguido das barras e das funções que disponibilizam.

### Janela Principal

A janela principal consiste de quatro pastas em que as duas da esquerda são para realizar edições. Primeiro vem a janela Header/Resource para headers e quaisquer outros ficheiros de texto tais como a documentação em sgml, depois a janela C/C++ para o código fonte. A estas segue-se a janela de Documentação apresentando o conteudo em formato HTML. Por fim é a janle de Ferramentas para programas externos tais como o KIconedit e o KDbg que estão integrados no ambiente gráfico. Qualquer Ferramenta que esteja registada pode ser acedida através do menu de Ferramentas; pelo que o registo de programas de terceiros pode ser facilmente conseguido através de um diálogo de configuração (veja Configuração Genérica). Para uma descrição das funcionalidades das janelas do Editor, veja o capítulo Trabalhar com o Editor, e para o Navegador de Ajuda, deverá ler a secção O Sistema de Ajuda.

### O Navegador de Classes e Janelas de Ficheiros

#### O Visualizador de Classes

O Visualizador de Classes (VC) mostra as classes do seu projecto bem como as funções e variáveis globais. Abrindo a árvore irá mostrar todas as funções membras e membros com símbolos para atributos (privado, protegido e público, sinais e espaços), para que possa ver as propriedades dos membros visualmente sem ter de alternar para os ficheiros header. Seleccionar o nome de uma classe irá abrir o ficheiro header correspondente contendo a classe e colocar o cursor no início da declaração da classe. Seleccionar funções membras irá abrir o ficheiro de implementação e colocar o cursor no cabeçalho da função. Para elementos, o KDevelop irá procurar o ficheiro header e colocar o cursor na linha onde o elemento é declarado. O visualizador de classes também disponibiliza um menu de contexto (acessível pelo botão direito do rato) que oferece opções mais específicas, veja O Navegador de Classes para informação mais detalhada.

#### O Visualizador de Ficheiros Lógicos

O Visualizador de Ficheiros Lógicos (VFL) permite ordenar ficheiros por filtros em grupos. Grupos individuais podem ser adicionados pela opção de propriedades do menu de projecto ou através do clique do botão direito do rato no item da árvore. Isto permite uma busca mais especializada para ficheiros que deseja aceder rapidamente, primeiramente apenas mostrando os ficheiros incluidos no projecto. De acordo com o seu tipo Mime, os ficheiros serão abertos quando seleccionados. Você gostará do VFL por coisas como seleccionar ficheiros gráficos- irá iniciar o KIconEdit (se instalado no sistema) na janela de Ferramentas e abrir a imagem escolhida.

#### O Visualizador de Ficheiros Reais

O Visualizador de Ficheiros Reais (VFR) mostra a árvore de directório do projecto com todos os seus ficheiros, para que possa editar ficheiros que não pertencem ao projecto ou que estão escondidas no VFL tal como o configure.in e Makefiles. Os menus de contexto também disponibilizam funções tais como adicionar ou remover ficheiros do projecto actual.

#### A Árvore de Documentação

A Árvore de Documentação (ADOC) apresenta toda a documentação baseada em HTMLque está configurada como livros. Seleccionando um livro irá abrir a primeira página na janela de Navegação. Também, um menu de contexto permite configuração personalizada para pacotes de documentação adicionais baseados em HTML.

### Janela de Output

A janela de Output está separada também numa janela de mensagens, uma janela stdin/stdout e uma janela stderr para as seguintes necessidades:

- janela de mensagens: mostra todo o output do compilador. Carregando numa mensagem de erro irá alterar o widget de edição para colocar o cursor na linha onde o compilador encontrou o erro.

- janela stdout: apresenta para aplicações baseadas em consola que enviam mensagens para o output standard do computador. Note que aplicações de Consola são agora iniciadas numa janela de consola externa.

- janela stderr: apresenta todas as mensagens de erro que o seu programa produzir. Isto é útil para realizar testes. A janela de Output está programada para surgir cada vez que um processo externo for chamado, tal como o make ou uma aplicação de consola (ou terminal).

### Comandos da Barra de Menu

#### Gestão de Ficheiros e Impressão

Esta secção cobre as funções que o KDevelop disponibiliza em relação a ficheiros; acedido através do menu de Ficheiros na barra de menu ou pelos respectivos itens na barra de ferramentas:

- Novo Ctrl+N Abre o diálogo "Novo Ficheiro", permitindo criar um novo ficheiro. O ficheiro pode ser criado utilizando diferentes modelos e o nome do ficheiro tem de ser dado bem como o caminho onde o ficheiro será criado.

- Abrir Ctrl+O apresenta o diálogo "Abrir Ficheiro..." e permite-lhe escolher um ficheiro para ser aberto.

- Fechar Ctrl+W Fecha o ficheiro de topo na janela de edição

- Gravar Ctrl+S Grava o ficheiro aberto no topo da janela de edição. Se o ficheiro não tiver ainda sido gravado , o diálogo "Gravar Ficheiro Como..." será aberto para lhe permitir escolher um caminho e nome de ficheiro para o ficheiro a ser gravado.

- Gravar Como... Abre o diálogo "Gravar Ficheiro Como..." para lhe permitir gravar o ficheiro actual com um novo nome de ficheiro

- Gravar Todos Grava todos os ficheiros modificados

- Imprimir... Ctrl+P Abre o diálogo "Imprimir Ficheiro" onde pode definir várias opções de impressão quer utilizando o a2ps, o enscript ou o lpr

- Sair Ctrl+Q Sai do KDevelop. Se ficheiros tiverem sido modificados, ser-lhe-á perguntado se os deseja gravar.

#### Editar Ficheiros

Aqui, o menu "Editar" e os icons correspondentes na barra de ferramentas são cobertos o que permite editar ficheiros. As funções de edição estão também disponíveis através de um menu de contexto no editor.

- Desfazer Ctrl+Z Desfaz a última operação de edição

- Refazer Ctrl+Z permite-lhe fazer de novo o último passo desfeito

- Cortar Ctrl+X corta a selecção e copia-a para a área de transferência do sistema.

- Copiar Ctrl+C copia a selecção para a área de transferência do sistema. Isto também inclui selecções feitas no navegador de documentação.

- Colar Ctrl+V insere o conteúdo da área de transferência na posição actual do cursor.

- Indentar Ctrl+I Indentar move a selecção para a direita

- Des-Indentar Ctrl+U Des-Indentar move a selecção para a esquerda

- Inserir Ficheiro...Ctrl+Insert Permite-lhe inserir um ficheiro e insere o seu conteudo na posição actual do cursor

- Procurar... Ctrl+F Abre um diálogo de busca que procura uma expressão no ficheiro actual. Para uma busca através de vários ficheiros, "Procurar nos Ficheiros..." deverá ser utilizado.

- Repetir Busca F3 Repete a última busca por uma expressão. Isto também inclui buscas que foram feitas sobre a documentação, em que mais de uma ocorrência foi encontrada na mesma página. A ocorrência seguinte será apresentada escolhendo "Repetir Busca" ou F3 e assinalar como marcado.

- Substituir... Ctrl+R Abre o diálogo de "Busca e Substituição" que permite a busca por uma expressão e substituir o texto encontrado por uma nova expressão.

- Procurar nos Ficheiros... Ctrl+Alt+F Apresenta o diálogo "Procurar nos Ficheiros...", que gere o `grep` em directorias inteiras com restrições (wildcards). Os resultados da busca são apresentados com uma lista de ficheiros, linhas e expressões. Escolhendo uma entrada é aberto o ficheiro e o cursor é colocado na linha do resultado da busca

- Seleccionar Tudo Ctrl+A Selecciona todo o texto do ficheiro correntemente aberto na janela de edição de topo

- Des-seleccionar Tudo Des-selecciona todo o texto do ficheiro actual. Isto é utilizado para selecções múltiplas para que não tenha de des-seleccionar cada um separadamente

- Inverter Selecção Inverte a selecção, o que significa que a selecção fica des-seleccionada e o texto que não está seleccionado fica seleccionado.

#### Configuração de Vista

O Menu Ver cobre as funções de abertura e fecho de janelas e comandos para activar/desactivar as barras de ferramentas e estados bem como para ir para erros no código.

- Ir Para a Linha... Ctrl+G Abre um diálogo "Ir Para Linha..." que lhe permite inserir um número de linha para mostrar no ficheiro corrente. O último número de linha é recordado e marcado, para que possa saltar para essa linha de novo ou apenas inserir um novo número de linha que deseje ver.

- Erro Seguinte F4 Salta para o erro seguinte que o KDevelop detectar a partir do output. A mensagem de output do Make ou outra ferramenta deve dar-lhe uma ajuda descritiva do que é o problema, para que possa corrigir o erro.

- Erro Anterior Shift+F4 Salta para o erro anterior que tenha sido reportado.

- Editor de Diálogos Ctrl+D Alterna para o Editor de Diálogos

- Vista de Árvore Shift+T (Des)Activa a janela de Árvore no lado esquerdo da vista principal contendo o Navegador de Classes, VFL, VFR e ADOC.

- Vista de Output Shift+O (Des)Activa a janela de Output no fundo da vista principal.

- Barra de Ferramentas (Des)Activa a barra de ferramentas.

- Barra de Navegação (Des)Activa a barra de navegação, contendo os botões de Seguinte, Anterior e Procurar do Navegador

- Barra de Estados Ctrl+B (Des)Activa a barra de estados.

- Refrescar percorre novamente todos os ficheiros para reconstruir o Navegador de Classes. O progresso do processo de percorrer os ficheiros é mostrado na barra de estados.

#### Criar e Manter Projectos

Esta secção descreve funções que estão disponíveis no menu "Projecto" e é suposto cobrirem a criação e manutenção dos projectos

- Novo... Inicia o KAppWizard e permite-lhe criar um novo projecto escolhendo o tipo de aplicação, nome, versão e outras opções.

- Abrir Mostra o diálogo de Abertura de Projecto, onde pode escolher um ficheiro de projecto KDevelop para ser aberto. Após a selecção, o projecto é aberto.

- Abrir projecto recente... contem um submenu com pelo menos 5 projectos que foram abertos. Pode abrir um projecto mais facilmente utilizando o menu de projectos recentes.

- Fechar Fecha o projecto actual. Isto é basicamente feito automaticamente quando sai do KDevelop, invoca o KAppWizard ou abre outro projecto.

- Nova Classe... Inicia o gerador de classes para crear uma nova classe que será adicionada ao projecto actual. O gerador de classes permite-lhe especificar um nome de classe, herança e nome de ficheiro para a nova classe.

- Adicionar Ficheiro(s) Existente(s) Abre um diálogo de selecção onde pode escolher os ficheiros que deseja adicionar ao projecto actual e o caminho para onde serão copiados. Se escolher um destino que não estava actualmente incluido no projecto, por ex. criando um novo subdirectório, o KDevelop copiará os ficheiros a adicionar ao novoa subdirectório e criará um novo Makefile.am. Após o processo de cópia, o seu projecto será reconstruido pelo automake e autoconf para incluir o novo subdirectório criado no processo do make.

- Adicionar novo ficheiro de tradução Abre um diálogo de selecção de idioma que lhe permite escolher o idioma do ficheiro de tradução que irá ser adicionado ao projecto. Isto é principalmente utilizado por tradutores que podem facilmente adicionar o seu idioma ao projecto e trabalhar na tradução sem ter de se preocupar com os Makefile.am's

- Propriedades de Ficheiros Shift+F7 Abre o diálogo de Propriedades de Ficheiros mostrando uma cópia do VFL e as opções do ficheiro de projecto. Aqui, as propriedades para os seus ficheiros têm de ser definidas tal como o caminho de instalação e tipo de ficheiro.

- Fazer mensagens e juntar Isto tem como objectivo criar o ficheiro de mensagens para o seu projecto. O ficheiro de mensagens é o que contém todas as frases que estão definidas no código para internacionalização e é utilizado pelos tradutores para criar o ficheiro .po para o seu idioma alvo.

- Fazer Doc-API Chama o KDoc sobre os seus ficheiros header e gera um output em HTML com a documentação das classes do seu projecto.

- Fazer Manual do Utilizador executa o ksgml2html sobre o ficheiro sgml do seu manual, criando um manual do utilizador em HTML. Se o ksgml2html não está instalado, o sgml2html será utilizado para fazer isto.

- Fazer Distribuição:

  - tar.gz cria um ficheiro de distribuição do seu projecto actual no directório do projecto e que está pronto para enviar aos utilizadores finais contendo o código fonte do projecto. O utilizador final tem de `tar zxvf seuprojecto.tar.gz` para descompactar o código para um directório e utilizar os comandos standard `./configure, make` e `make install`.

- Opções F7 Abre o diálogo de Opções do Projecto que lhe permite modificar várias definições para o seu projecto. Isto pode ser um novo número de versão ou as opções de compilador para definir -02 para uma distribuição com optimização.

#### Construir Projectos

Esta secção descreve o menu Construir que cobre todas as acções a serem feitas com o make ou acções como reconstruir a documentação ou ajuda electrónica do projecto.

- Compilar ficheiro... Ctrl+F8 Activo, se a janela de topo de edição é a Janela C++. Isto apenas compila o ficheiro actual de implementação e permite-lhe poupar tempo no caso de suspeitar de erros.

- Make F8 Invoca o comando make para o seu projecto e constroi o alvo.

- Reconstruir Tudo Reconstroi todos os ficheiros objecto e o alvo do seu projecto.

- Limpar Reconstruir Tudo Limpa o directório do projecto de todos os ficheiros criados pelo make e reconstroi o alvo.

- Parar Construção F10 Pára o processo em curso.

- Executar F9 Executa o seu alvo após construir o programa com o make.

- Executar com Argumentos Alt+F9 Executa o seu alvo com argumentos. Primeiro, um diálogo surge para lhe permitir especificar os argumentos de execução (que são gravados no projecto para a próxima sessão), depois a sua aplicação utiliza a linha de comando inserida. Lembre-se que a sua aplicação é iniciada directamente do directório do projecto

- Depurar... Abre o KDbg na Janela de Ferramentas para depurar a sua aplicação. Neste caso, o KDbg abre automaticamente o ficheiro contendo a função main() e executa a sua aplicação.

- Distclean Remove todos os ficheiros que são gerados pelo projecto tal como ficheiros objecto etc. Distclean tem de ser feito antes de distribuir o seu projecto, para que o ficheiro de distribuição não contenha nenhum ficheiro específico de plataforma tal como aquelas geradas pelo seu compilador.

- Autoconf e automake Chama o Make sobre o ficheiro Makefile.dist, localizado no seu directório principal do projecto. O Makefile.dist contém todos os comandos para o automake, autoconf etc. para construir o seu projecto. Se adicionou ficheiros manualmente ou modificou macros, deve correr o Autoconf depois, seguido do Configure para recriar todos os Makefiles.

- Configurar Executa o script configure gerado pelo autoconf. Se este comando não puder ser executado, corra o Autoconf e depois o Configure de novo.

#### Chamar Ferramentas

O menu de Ferramentas cont´me por defeito as entradas para o Editor de Diálogos interno (que pode também ser iniciado pelo botão da barra de ferramentas) e os seguintes programas se instalados: KDbg, KIconEdit e KTranslator. Estes são procurados pelo programa de instalação do KDevelop e inseridos na ordem indicada no menu. Invocar uma ferramenta irá abrir a janela de "Ferramentas" e iniciar o programa seleccionado dentro desta janela. O menu de Ferramentas pode ser editado pela entrada Ferramentas no menu de Opções; veja Configurar o Menu "Ferramentas").

#### Alterar as Definições do KDevelop

O menu de Opções contém todas as entradas para invocar diálogos de configuração com os quais pode alterar as definições de defeito do KDevelop. Definições principais tais como as do editor ou impressão têm as suas entradas específicas; definições gerais do comportamento do KDevelop podem ser feitas com o diálogo de Configuração do KDevelop.

- Editor... Permite a configuração do comportamento do editor tal como a quebra de palavras, selecções etc.

- Cores do Editor... Aqui, pode definir a configuração de cores do editor tal como por ex. o fundo.

- Defeitos do Editor... Isto define a apresentação por defeito tal como fontes e tamanho de letra do editor

- Realce de Sintaxe Este diálogo permite-lhe definir as fontes e cores para o realce de várias linguagens de programação, incluindo HTML, e o realce dos tipos-mime também será activada.

- Navegador de Documentação Neste diálogo de pastas, pode definir as fontes, tamanhos e cores para o navegador de ajuda interno

- Configuração de Impressora... Contém as entradas para o diálogo de configuração da impressora de acordo com o programa de impressão utilizado, a2ps ou enscript.

  - a2ps Configura a impressora para utilização com o a2ps. Veja Imprimir para mais informações.

  - enscript Configura a impressora para utilização com o enscript. Veja Imprimir para mais informações.

- Ferramentas... Abre o diálogo de Configuração de Ferramentas. Aqui, pode configurar o menu "Ferramentas" adicionando ou removendo programas que serão iniciados na janela de Ferramentas.

- Configuração do KDevelop Abre o diálogo de Configuração do KDevelop. A primeira pasta configura definições gerais, seguida das definições principais e de Documentação. As definições de Documentação também incluem a geração dum novo conjunto de documentação HTML de bibliotecas e a reconstrução do index de busca para o navegador de Ajuda.

#### O Menu Janela

O menu Janela contém uma lista com todos os ficheiros actualmente abertos. Isto permite ir rapidamente para outro ficheiro em que esteja correntemente a trabalhar.

#### Gerir Marcas de Leitura

O menu de Marcas de Leitura é destinado para adicionar e remover marcas de leitura que deseje colocar no ficheiro correntemente em edição. Como o KDevelop utiliza duas janelas de edição, cada uma configura as suas marcas de leitura separadamente.

- Definir Marca de Leitura Abre um menu de contexto com até nove marcas de leitura configuráveis. Isto permite definir uma marca de leitura para uma dada entrada no menu de marcas de leitura por razões lógicas.

- Adicionar Marca de Leitura Ctrl+Alt+A Adiciona a linha da posição actual do cursor ao menu de marcas de leitura como uma marca de leitura. tenha em atenção que isto pode sobrepor uma marca de leitura definida com a opção Definir Marca de Leitura. Se o navegador estiver aberto, uma marca de leitura será adicionada ao menu de marcas de leitura da Janela de Navegação.

- Limpar Marcas de Leitura Ctrl+Alt+C Limpa as entradas de marcas de leitura para a janela de edição no topo ou o navegador, por ex. se a Janela de Header é visível e chamar Limpar Marcas de Leitura, as entradas para a Janela de Header serão apagadas.

- Janela de Header Contém a lista de marcas de leitura para a Janela de Header. Seleccionando uma marca de leitura colocará o cursor na linha da maraca de leitura seleccionada. Tome nota que a marca de leitura só é atribuida ao ficheiro em que é definida, pelo que se mudar de ficheiro, as marcas de leitura não são apagadas mas escolher uma marca de leitura não irá para o ficheiro onde ela foi definida.

- Janela C/C++ Contém a lista de marcas de leitura para a Janela C/C++. As opções são as mesmas que para a Janela de Header.

- Janela de Navegação Contém as marcas de leitura do navegador. Seleccionando uma marca de leitura irá abrir o navegador na página seleccionada.

#### Ajuda Electrónica

O menu de Ajuda contém entradas para navegação no navegador de Ajuda bem como as entradas para documentação electrónica e de bibliotecas para os mais utilizados recentemente. Aceder a documentação electrónica adicional pode ser conseguido com a ADOC na vista de árvore automaticamente aberta (se a Auto-Alternância estiver activa) quando se muda para a janela do Navegador de Documentação.

- Recuar Alt+ Seta para Esquerda Abre a página aberta antes da actual.

- Recuar Alt+ Seta para Direita Abre a página seguinte na história do navegador, disponível após se ter feito um "Recuar".

- Procurar Texto Marcado F2 Procura no índice de busca o texto correntemente marcado nas janelas de edição ou na janela de navegação. Após a busca, uma página com os resultados é apresentada que lhe permite seleccionar a página de ajuda para onde ir. Após escolher a página, o navegador irá realçar a ocorrência encontrada para a expressão com que a busca foi invocada. Com a tecla F3 o próximo resultado de busca na mesma página será apresentado se mais de uma ocorrência foi reportada para a busca numa página.

- Procurar Ajuda Sobre... Abre o diálogo Procurar Ajuda Sobre... que lhe permite procurar por uma expressão específica sobre a qual deseja ajuda.

- Manual do Utilizador F1 Abre o Manual do Utilizador do KDevelop na página de ínice para que tenha acesso a este manual.

- Manual de Programação Abre o Manual de Programação do KDevelop na página de índice para aceder ao manual de programação.

- Dica do Dia Abre o diálogo da Dica do Dia para o informar sobre as características do KDevelop.

- Página do KDevelop Abre a página de internet do KDevelop na janela de navegação se existir acesso à internet.

- Reporte de Erros... Abre o diálogo de Reporte de Erros do KDevelop, onde pode enviar um relatório de erro directamente para a Equipa do KDevelop por e-mail. Veja Reporte de Erros de Código (Bugs)

- Referência C/C++ Apresenta a página de índice da referência da linguagem. Se a referência não estiver instalada, uma página de erro explica-lhe como obter a referência e como a instalar correctamente.

- Biblioteca Qt Vai para a página de índice da documentação da biblioteca Qt disponibilizada com a sua cópia da biblioteca Qt.

- Biblioteca KDE-Core Abre o ficheiro de índice de classes da documentação da biblioteca KDE-Core.

- Biblioteca KDE-GUI O que acima foi dito mas para a biblioteca GUI

- Biblioteca KDE-KFile O que acima foi dito mas para a biblioteca KFile

- Biblioteca KDE-HTML O que acima foi dito mas para a biblioteca HTML

- Doc da API do Projecto Vai para o índice da documentação das classes do projecto.

- Manual do Utilizador do Projecto Abre o ficheiro de índice do manual do utilizador para o projecto actual. Isto pode ser utilizado para rever o resultado em HTML gerado pelo ksgml2html

- Sobre o KDevelop... Mostra a caixa Sobre o KDevelop contendo o número da versão utilizada e os nomes dos autores e endereços de e-mail bem como a referência ao licenciamento do KDevelop.

### Itens da Barra de Ferramentas

O KDevelop disponibiliza acesso rápido a vários conjuntos de comandos através das barras de ferramentas. Estas são as barras standard e de navegação; no modo de edição de diálogos apenas a barra de ferramentas standard é visível. Ambas podem ser (des)activadas através das respectivas entradas de menu no menu "Ver"; também podem ser arrastadas para fora da janela principal e colocadas de cada lado da área de trabalho.

#### A Barra de Ferramentas Standard

A barra de ferramentas standard disponibiliza acesso rápido às funções mais recentemente utilizadas para processamento de ficheiros e sua edição bem como construir a sua aplicação. Os botões executam os seguintes comandos da esquerda para a direita:

- Abrir Projecto - mostra o diálogo de abertura de projecto

- Abrir Ficheiro - mostra o diálogo de abertura de ficheiro e contém uma forma de escolher rapidamente os ficheiros header e código fonte do projecto.

- Gravar Ficheiro - grava o ficheiro correntemente aberto para o disco

- Imprimir Ficheiro - abre o diálogo de impressão

- (separador)

- Desfazer - reverte a última acção

- Refazer - executa a acção revertida de novo

- Cortar - corta a selecção corrente

- Copiar - copia a selecção corrente para a área de transferência do sistema

- Colar - cola o conteudo actual da área de transferência na posição corrente do cursor

- (separador)

- Compilar Ficheiro - compila o ficheiro correntemente visível na janela de ficheiro de código. No modo de edição de diálogos é substituido pelo botão de Gerar Ficheiros.

- Make - invoca make sobre o projecto

- Reconstruir Tudo - reconstroi o projecto

- Depurar - abre o KDbg com o binário da aplicação para depurar na janela de Ferramentas

- Executar - executa o binário da aplicação alvo

- Parar - cancela o processo actual

- (separador)

- Editor de Diálogos - vai para o modo de edição de diálogos. Aí, o botão é substituido pelo botão do Editor de Código Fonte

- Vista de Árvore - (des)activa a vista de árvore e funciona como um botão de alternância para apresentar o estado actual

- Vista de Output - (des)activa a vista de output e funciona como um botão de alternância para apresentar o estado actual

- (separador)

- Botão de Ajuda O que é isto..? - modifica o cursor para um ponto de interrogação e permite-lhe obter informação sobre os componentes do ambiênte de desenvolvimento do KDevelop

#### A Barra de Ferramentas de Navegação

A barra de ferramentas de navegação é outra barra de ferramentas que disponibiliza vários comandos úteis para navegar nos ficheiros e documentação. A barra de ferramentas contém:

- a caixa de lista de Classes - permite-lhe seleccionar uma classe do projecto actual para ir para

- a caixa de lista de Métodos - permite-lhe seleccionar um método do da classe actual e navega até à implementação do método

- o botão do assistente de Classes - um único clique do rato leva-o para a declaração do método actualmente seleccionado. Contém uma forma rápida de aceder a ferramentas de classes para adicionar Classes, Métodos e Atributos bem como comandos de navegação.

- Recuar - navega para trás na história de navegação da documentação; contém uma forma rápida de seleccionar uma dada página da história.

- Avançar - navega para a frente na história de navegação da documentação; contém uma forma rápida de seleccionar uma página da história.

- Parar - pára a leitura de um ficheiro de documento pedido no navegador

- Reler - relê a página actualmente apresentada

- Casa - abre a página de índice do Manual do Utilizador do KDevelop no navegador

- Procurar Texto Marcado - procura o índice de documentação pelo texto seleccionado; funciona com as janelas de navegação e de edição

- Procurar Ajuda Sobre... - abre o diálodo Procurar Ajuda Sobre.. para lhe permitir inserir uma expressão a procurar na documentação

### Atalhos de Teclado

Esta secção gere os valores pré-definidos bem como os valores standard para comandos de teclado configuráveis utilizados no ambiente de desenvolvimento KDevelop. É recomendado que veja a secção Alterar Atalhos de Teclado para uma explicação detalhada de como modificar valores designados a comandos.

#### Atalhos para Processamento de Texto

##### Movimentos do Cursor

    uma letra para a esquerda                        Seta Esquerda
    uma letra para a direita                         Seta Direita
    uma palavra para a esquerda                      CTRL+Seta Esquerda
    uma palavra para a direita                       CTRL+Seta Direita
    uma linha para cima                              Seta para Cima
    uma linha para baixo                             Seta para Baixo
    para o princípio da linha                        POS 1
    para o fim da linha                              END
    uma página para cima                             PageUp
    uma página para baixo                            PageDown
    para o princípio do ficheiro actual              CTRL+PageUp
    para o final do ficheiro actual                  CTRL+PageDown

##### Selecção de Texto

    uma letra para a esquerda                        SHIFT+Seta Esquerda
    uma letra para a direita                         SHIFT+Seta Direita
    uma palavra para a esquerda                      CTRL+SHIFT+Seta Esquerda
    uma palavra para a direita                       CTRL+SHIFT+Seta Direita
    uma linha para cima                              CTRL+Seta para Cima
    uma linha para baixo                             CTRL+Seta para Baixo
    para o princípio da linha                        CTRL+POS 1
    para o fim da linha                              CTRL+END
    uma página para cima                             SHIFT+PageUp
    uma página para baixo                            SHIFT+PageDown
    para o princípio do ficheiro actual              CTRL+SHIFT+PageUp
    para o final do ficheiro actual                  CTRL+SHIFT+PageDown

##### Inserir e Copiar Texto, Tabuladores

    (des)activar modo de inserção                    INS
    copiar selecção para a área de transferência     CTRL+C, CTRL+INS
    inserir texto da área de transferência           CTRL+V, SHIFT+INS
    apagar linha actual                              CTRL+K
    inserir linha após linha actual                  END, depois Enter
    inserir linha antes da linha actual              POS 1, depois Enter
    desfazer passo de edição                         CTRL+Z
    refazer passo desfeito                           CTRL+Y
    tabulador                                        TAB

##### Apagar Texto

    apagar letra à esquerda da posição do cursor     Backspace
    apagar letra à direita da posição do cursor      Delete
    apagar texto seleccionado                        Seleccionar texto, depois Backspace ou Delete

##### Procurar Texto Dentro do Editor

    abrir diálogo Ir Para Linha...                   STRG+G
    abre diálogo Procurar Texto                      STRG+F
    repete a última busca                            F3
    abre o diálogo Procurar e Substituir             STRG+R

    abre o diálogo Procurar em Ficheiros (grep)      STRG+ALT+F
    procurar texto marcado com o Grep                SHIFT+F2

    localizar erro seguinte                          F4
    localizar erro anterior                          SHIFT+F4

##### Procurar Texto com o Navegador de Documentação

    procurar texto seleccionado no editor na documentação          F2
    procurar texto seleccionado no navegador na documentação       F2
    apresentar ocorrência seguinte na mesma página                 F3

    procurar texto seleccionado no navegador dentro do projecto    SHIFT+F2

##### Atalhos do Navegador

    página anterior                                                                                                                                            Alt+ Seta para a Esquerda
    página seguinte                                                                                                                                                                Alt+ Seta para a Direita

##### Gerir Marcas de Leitura

    adicionar marcas de leitura                      STRG+ALT+A
    limpar lista de marcas de leitura                STRG+ALT+C

#### Atalhos par Símbolos da Barra de Ferramentas

    Símbolo "Abrir Ficheiro"                          STRG+O
    Símbolo "Gravar Ficheiro"                         STRG+S
    Símbolo "Imprimir Ficheiro"                       STRG+P
    Símbolo "Desfazer"                                STRG+Z
    Símbolo "Refazer"                                 STRG+Y
    Símbolo "Cortar"                                  STRG+X
    Símbolo "Copiar"                                  STRG+C
    Símbolo "Colar"                                   STRG+V
    Símbolo "Compilar Ficheiro"                       STRG+F8
    Símbolo "Make"                                    F8
    Símbolo "Executar"                                F9
    Símbolo "Executar com Argumentos"                 ALT+F9
    Símbolo "Editor de Diálogos"                      STRG+D
    Símbolo "Recuar"                                  ALT+Seta para a Esquerda, se navegador aberto
    Símbolo "Avançar"                                 ALT+Seta para a Direita, se navegador aberto
    Símbolo "Procurar Texto Marcado"                  F2

#### Gestão de Janelas

Para ir para uma dada janela, prima ALT mais a letra sublinhada no título da janela, por ex. Ferramentas seria Alt+F

#### Atalhos par o Processo de Compilação

    Compilar ficheiro de código actual               STRG+F8
    Construir projecto alvo actual                   F8
    Executar alvo após processo de construção        STRG+F9
    Executar alvo com Argumentos                     ALT+F9
    Parar o processo actual                          F10

## O Sistema de Ajuda

Muita da força do KDevelop está acumulada no Sistema de Ajuda. Deve ser também entendido como um exemplo de como extender a sua própria aplicação KDE com um conjunto completo de funcionalidades de ajuda, e está, em parte, já realizado nos modelos de aplicações iniciais, pelo que esqueletos de aplicações KDE/Qt geradas pelo KAppWizard já contêm a funcionalidade básica para a ajuda de barra de estados e documentação, que apenas tem de ser aumentada pelo programador. Esta secção irá assim introduzi-lo à utilização da ajuda geral disponibilizada dentro do ambiente de desenvolvimento bem como mostrar a utilização do Navegador de Ajuda, o qual, através de uma utilização inteligente, irá tornar muito fácil encontrar a informação de que necessita para o desenvolvimento.

### O Botão "O que é isto?" e a Ajuda Rápida

Olhando para a barra de ferramentas de cima do KDevelop, você vê o botão "O que é isto?" na ponta direita. Seleccionando o botão, o cursor irá mudar para um ponteiro com um ponto de interrogação à direita, tal como o icon do botão na barra de ferramentas. Agora, pode seleccionar qualquer parte visível do interface de utilizador do KDevelop e clicar sobre ela. Isto irá resultar na apresentação de uma janela de ajuda dando-lhe uma breve descrição da função que esta parte lhe dá ou o que poderá fazer por si. Inclui-se a janela principal, as vistas de árvore e as barras de ferramentas, para os quais é disponibilizada ajuda para cada botão. Após outro clique do rato ou entrada de teclado, a janela de ajuda O que é isto? desaparece e o seu cursor é modificado de volta à última forma activa. Lembre-se, que, se colocar o ponteiro do rato sobre um botão, ele fica em relevo e após um curto período de tempo, obtém uma janela com uma Dica Rápida, descrevendo as funcionalidades que o botão representa na barra de menu; a dica irá desaparecer se afastar o ponteiro do rato.

Para diálogos de interacção com o utilizador, a Ajuda Rápida disponibiliza-lhe janelas de ajuda com uma breve descrição do item seleccionado para o qual deseja ajuda. Estes são acedidos através de um clique do botão direito do rato sobre o item, em que um menu de contexto surge e permite a selecção da "Ajuda Rápida". Seleccionado esta surge uma janela de ajuda. Isto é sempre útil para diálogos em que não consegue ver qual o objectivo da acção durante o período em que não estiver familiarizado com o KDevelop. Lembre-se que a maior parte dos diálogos oferece um botão de Ajuda que lhe mostra a ajuda de contecto para as opções do diálogo dentro do manual electrónico no navegador de ajuda.

### A Ajuda de Barra de Estados

A barra de estados do KDevelop disponibiliza-lhe várias funções que o informam sobre o estado da actividade actual bem como uma "mensagem de estado" oferecendo uma breve descrição para os comandos.

#### Entradas da Barra de Estados

A Barra de Estados contém:

1. um campo de mensagem genérica, na extrema esquerda. Isto é utilizado para mensagens de ajuda e apresenta a actividade a decorrer.

2. a barra de progresso, indicando o progresso para acções que requeiram um período de tempo mais comprido para terminar, tal como gravar ficheiros e o progresso de percorrer todos os ficheiros do Navegador de Classes. A barra de progresso apenas aparece durante o decurso desses processos.

3. um indicador de Inserir/Sobrepor. Mostra o modo do editor para acções de inserção através de INS para modo inserir e OVR para modo sobrepor. O modo pode ser modificado através da tecla INS (Insert) no teclado.

4. um contador de linha, apresentando a linha actual em que o cursor se encontra.

5. um contador de coluna, apresentando a coluna actual em que o cursor se encontra na linha.

#### Mensagens de Ajuda

A barra de estados informa-o sobre acções de entradas de menu se seleccionar um menu dentro da barra de menu e seleccionar uma acção sem a executar. Além disso, se premir um icon da barra de ferramentas, mas sem largar o botão do rato, a mensagem de ajuda do botão é apresentada da mesma forma que para as entradas de menu. Pode impedir a execução do icon seleccionado movendo o ponteiro do rato para longe do icon, ainda premindo o botão do rato. Se o cursor estiver afastado, largue o botão do rato.

Para acções que estão presentemente em execução, o KDevelop apresenta a acção. Isto inclui processos a decorrer por trás tal como gravar ficheiros bem como diálogos. Se o processo tiver saido tal como uma invocação do make, a barra de estados modifica-se para o estado "Pronta".

Também, quando a utilizar o navegador de documentação, a barra de estados disponibiliza ligações urls durante o período de tempo que o cursor estiver colocado sobre um endereço URL na janela de navegação. Assim, pode rapidamente descobrirse um ficheiro é local ou ficheiro remoto apenas acessível através de uma conecção na rede.

O título do Editor de Projecto KDevelop apresenta o nome do ficheiro presentemente aberto na janela de topo. Isto seria um ficheiro HTML para o navegador de documentação ou um ficheiro de texto para as janelas de edição. Além disso, o nome do Projecto é apresentada, pelo que você tem controlo constante sobre onde se encontra e no que está presentemente a trabalhar.

### Configurar o Navegador de HTML

O navegador incluido com o KDevelop é completamente baseado em HTML, pelo que você pode especificar as opções normais tais como fundo e afins. Pode definir todas as preferências através da entrada "Navegador de Documentação" do menu "Opções". O diálogo de configuração mostra-lhe dois tabuladores; o primeiro para definir as preferências de fontes, o segundo para selecção de cores.

#### Preferências de Fontes

A primeira opção para a apresentação da fonte é o tamanho. Os disponíveis são pequeno, médio e grande. A melhor apresentação para utilização normal é definir pequeno por defeito. Para a selecção de fonte tem de especificar uma fonte standard para texto normal tal como surge em documentos HTML; a fonte fixa é para apresentar por ex. código dentro de um ficheiro de HTML.

#### Preferências de Cores

O diálogo de preferências de cores permite a configuração das cores de fundo, texto normal, ligações URL e côr das ligações seguidas. OS botões coloridos à direita estão a mostrar as definições actuais; seleccionando um botão irá resultar na abertura de um diálogo de "Selecção de Côr". Aí, você pode especificar a côr quer escolhendo uma Côr de Sistema, uma côr costumizada, seleccionando a côr a partir da janela multi-colorida ou através da entrada directa de valores. O meio contém uma antevisão da côr seleccionada.

Além disso, você pode especificar se o navegador deverá sublinhar ligações para mais facilmente você as detectar visualmente e se deseja utilizar as suas próprias cores sempre independentemente as pré-definidas da página que estiver a visualizar. "Aplicar" irá executar todas as alterações, enquanto que "OK" irá aplicar as alterações e fechar o diálogo. "Cancelar" deixa todas as definições intocadas e sai da configuração.

### Utilizar o Navegador de Documentação

O navegador de documentação permite acesso rápido e fácil a todos os manuais e documentações que são disponibilizadas com o KDevelop ou geradas automaticamente, incluindo documentação electrónica para as bibliotecas KDE
e a documentação do seu projecto. Mais, a Árvore de Documentação na vista de árvore permite-lhe costumizar uma pasta especial "Outras" que contém toda a documentação adicionada individualmente.

#### Requisitos

Para fazer uso de todas as funcionalidades do Navegador de Ajuda, deverá ter o KDoc e o glimpse instalados. O KDoc irá gerar todo o tipo de documentação electrónica de classes para as bibliotecas KDE
durante o processo de instalação, mas pode também ser invocado por opção na Configuração do KDevelop. Para a geração de uma Documentação da API (Application Programming Interface - Interface de Programação da Aplicação) para as classes do seu projecto, o KDoc é também utilizado e chamado pelo menu Construir, entrada "Fazer Doc-API". Isto irá processar todos os ficheiros header actuais do projecto mais uma referência cruzada com as bibliotecas da Qt e KDE
se estas estiverem disponíveis no Navegador de Ajuda. Para a geração de manuais do projecto, deverá ter o ksgml2html (disponibilizado com o KDE-SDK
) e, como um mínimo, as ferramentas SGML instaladas no seu sistema. Para aumentar e modificar a documentação electrónica do seu projecto, tem de editar o ficheiro de documentação do seu projecto seleccionando-o no VFR. Após gravar as suas modificações, chame "Fazer Manual do Utilizador" a partir do menu Construir. No caso das ferramentas sgml detectarem erros de formatação, estes serão apresentadas na janela de output permitindo-lhe descobrir directamente a linha com o erro. O programa "glimpse" é utilizado para criar automaticamente um índice de busca pessoal para a sua documentação. O índice é geralmente construido durante o processo de instalação, mas pode também ser construido com o diálogo da Configuração do KDevelop. Para uma descrição das funções de busca disponibilizadas veja Utilizar o Índice de Busca.

#### Documentação Disponibilizada

O ambiente de desenvolvimento KDevelop vem com dois conjuntos de documentação electrónica, que podem ser acedidos quer através do menu Ajuda ou através da árvore de documentação na Vista de Árvore na pasta do KDevelop. O primeiro livro apresentado é o manual electrónico contendo toda a informação de que poderá necessitar no sentido de instalar, configurar, funcionalidades disponíveis e introdução ao desenvolvimento de aplicações. O segundo livro é o Manual de Programação do KDevelop na sua primeira edição. O manual de programação cobre a maior parte das questões relativas à criação e expansão de projectos que funcionem com o KDevelop. Através de explicações passo-a-passo o utilizador obtém uma introdução às ricas potencialidades que aplicações criadas com as bibliotecas da Qt e/ou KDE
têm a oferecer bem como dar linhas mestras para assegurar compatibilidade com o KDE
, o que cobre as mesmas instruções dadas na página de internet do http://developer.kde.org. No entanto, o manual de programação não pode ser substituido por nenhuma documentação adicional disponível em formato impresso ou electrónico sobre a linguagem de programação C++ bem como sobre a utilização da biblioteca Qt sob certos termos.

A Referência C/C++ utiizada com o KDevelop é actualmente a única disponível na página de internet do KDevelop em http://www.kdevelop.org. Pode ser instalada facilmente puxando o ficheiro e copiando o código fonte para o directório principal do KDE ($KDEDIR). Aí, tem de descomprimir o ficheiro como root com `tar zxvf c&&lowbar;;c++&&lowbar;;reference.tar.gz`, a referência será então copiada para o directório de documentação do KDevelop. Para desinstalar a documentação de referência apenas tem de apagar o directório "reference" em ($KDEDIR)/share/doc/HTML/default/kdevelop/reference.

A pasta de documentação das bibliotecas Qt/KDE permite acesso directo à documentação electrónica da sua cópia da biblioteca Qt. O caminho para a documentação da biblioteca é normalmente detectado pelo programa de instalação do KDevelop, mas pode ser definido manualmente no diálogo de Configuração do KDevelop. Também, toda a documentação disponível para as bibliotecas KDE são listadas por ordem de nome de biblioteca, pelo qie se você utilizar classes de uma dada biblioteca é fácil determinar o tipo de biblioteca a ser adicionada às definições de linkagem do projecto. Lembre-se de que toda a documentação da biblioteca KDE apenas é acessível quando gerada pelo KDoc- pelo que este programa, incluido no KDE-SDK
, tem de estar instalado antes da documentação poder ser gerada. Como o programa de instalação do KDevelop faz isto automaticamente, deve ser instalado antes do KDevelop ser iniciado pela primeira vez. Se este não for o caso e a documentação não conseguir ser construida, é-lhe possível cria-la posteriormente a qualquer momento através do diálogo Configuração do KDevelop.

A árvore de documentação das bibliotecas é seguida de uma pasta "Outros" que se destina a conter toda a documentação costumizada pessoalmente como descrito abaixo. Finalmente, a Árvore de Doc permite um acesso rápido à API de um Projecto e ao Manual do Projecto para o projecto actual.

#### Adicionar Documentação ao Navegador de Ajuda

Para costumizar o Navegador de Ajuda, abra a Vista de Árvore e seleccione a pasta "ADOC". Verá uma árvore aberta chamada Documentação, contendo quatro pastas. A pasta "Outras" está, por defeito, vazia. Com um clique do botão direito do rato sobre esta pasta, um menu de contexto abre e possui uma entrada "Adicionar Entrada". Seleccione este para abrir o diálogo de Adicionar Entrada onde terá de inserir dois valores: o de cima para o nome que será apresentado para a documentação dentro da árvore de Doc, e, por baixo dessa, uma linha de entrada de ficheiro. Aqui, tem de inserir o caminho e nome de ficheiro para a página inicial que será aberta pela selecção da entrada mais tarde. Você pode indicar o caminho e nome de ficheiro directamente ou selecciona-lo premindo um botão à direita para abrir um diálogo de escolha de ficheiro. Isto permite uma visão rápida do seu sistem até ao caminho para a sua página inicial. Lembre-se que apenas documentação HTML pode ser seleccionada, pelo que apenas é possível escolher ficheiros HTML. Seleccionando OK irá adicionar a entrada à árvore de Doc e encontra-se desde logo disponível.

#### Utilizar o Índice de Busca

O KDevelop inclui um conjunto de funções para ajudar a busca de informação dentro da documentação HTML. Para utilizar estas funcionalidades, o seu sistema tem de ter o programa "glimpse", um gerador de bases de dados gratuito, instalado, que irá criar o índice de busca e executar as procuras dentro da documentação. Para definir o índice, veja Configuração do KDevelop. O índice é também gerado automaticamente durante o programa de instalação.

As funções de busca estão disponíveis através de várias formas que pode escolher:

1. no editor, seleccione o texto sobre o qual deseja ter ajuda ou coloque o cursor na palavra que deseja procurar. Depois prima o botão direito do rato e seleccione procurar: "expressão" Isto também pode ser feito seleccionado "Procurar Texto Marcado" a partir do menu de ajuda, da tecla de atalho F2 ou seleccionando o icon de Busca a partir da barra de ferramentas.

2. no Navegador de Documentação seleccione o texto que deseja procurar e prima o botão direito do rato, seleccione procurar :"expressão" ou seleccione "Procurar Texto Marcado" ou o icon de busca como acima.

3. se deseja procurar uma palavra chave específica, seleccione "Procurar Ajuda sobre..." no menu de ajuda ou seleccione o icon "Procurar Ajuda sobre..." a partir da barra de ferramentas, abrindo um diálogo de busca onde poderá inserir a expressão sobre a qual deseja obter informações.

Acesso directo a documentação específica é dado seleccionando o icon correspondente na vista de árvore "ADOC" ou através das entradas do menu de ajuda.

O Navegador de Ajuda também disponibiliza suporte para grep para procurar por uma selecção dentro do projecto actual, por ex. você abriu a página de documentação para a classe `KTMainWindow` (biblioteca KDEUI) e deseja saber onde no seu código `KTMainWindow` surge. Marque `KTMainWindow` e seleccione "Grep: KTMainWindow" ou então prima Shift+F2. O diálog "Procurar nos Ficheiros" abre com os resultados sobre a sua busca grep directamente. Depois pode escolher uma linha de resultado e ir para o código fonte respectivo.

## Trabalhar com o Editor

Uma parte importante do ambiente integrado de desenvolvimento é o editor. Você usa-o para:

- criar, abrir e gravar ficheiros de código e do projecto

- editar código e ficheiros do projecto

- escrever a sua documentação sgml

- imprimir os ficheiros do seu projecto

Geralmente, o editor em si não faz muita diferença em comparação com outros editores; especialmente pois é uma versão incorporada do popular KWrite, também conhecido como "Editor Extendido". Se está familiarizado com ele, não terá quaisquer problemas a utiliza-lo para gerir os seus projectos. Em adição aos editores normais, o KDevelop contém um novo sistema de impressão, que tem muitas mais características para utilização com código fonte- e você pode escolher qual o programa de impressão que deseja utilizar.

Esta secção dá-lhe mais informação sobre como gerir os ficheiros do seu projecto e familiariza-lo com as funcionalidades do editor. Muitos dos utilizadores mais antigos de Unix prefeririam utilizar o Emacs ou XEmacs- estão à vontade com eles. Mas não é necessário simplesmente para programar, e especialmente para iniciados, é difícil habituarem-se a editores potentes que irão, no fim de contas, apenas permitir introduzir o seu código.

### Gerir Ficheiros do Projecto

As secções seguintes descrevem como criar, gravar, abrir e fechar os ficheiros do seu projecto que necessita editar- lembre-se que isto não inclui os ficheiros de tradução ou imagens. Esses são reconhecidos automaticamente e o programa de edição correspondente tal como o KTranslator abre esses ficheiros para sí.

Para lhe permitir um acesso fácil aos seus ficheiros, o KDevelop contém duas vistas de árvore fáceis de utilizar, similares a um gestor de ficheiros, que reconhece se seleccionou um ficheiro, e abre-o na janela de edição correspondente. A vista principal contém duas janelas que são utilizadas independentemente, mas conectadas através do Editor de Projecto, pelo que pode fazer todas as acções de menu da mesma forma. A intenção por trás disto é que lhe permite manusear duas janelas ao mesmo tempo, apesar de que apenas uma se encontra visível. A janela C/C++ toma assim outra tarefa, que lhe permite facilmente compilar o seu código ficheiro a ficheiro, para que possa verificar as implementações sem ter de executar um processo de construção completo do seu projecto.

Isto pode ser conseguido tendo a janela C/C++ no topo. Seleccione "Compilar Ficheiro" a partir do menu Construir ou pressione o botão correspondente na barra de ferramentas. O seu ficheiro é gravado e compilado, e pode controlar quaisquer erros do compilador pela janela de output.

Dentro do ambiente de desenvolvimento pode ter abertas quantos ficheiros de texto desejar. Todos os ficheiros abertos são listados no menu Janela, para que possa alternar entre eles seleccionando o correspondente nome de ficheiro a partir do menu. Ainda mais, o ficheiro actualmente aberto é apresentado com o seu nome na moldura de janela do KDevelop.

#### Criar e Gravar Ficheiros

Para criar um ficheiro novo, escolhe "Novo" a partir do menu Ficheiro ou seleccione "Adicionar Ficheiro(s) ao projecto"&->;"Novo Ficheiro". Isto abre o diálogo "Novo Ficheiro", onde pode especificar o nome e tipo de ficheiro. Adicionalmente, tem de definir o directório de destino bem como se o ficheiro é adicionado ao projecto ou não. Finalmente, pode também utilizar o seu modelo de cabeçalho para o projecto no caso de querer adicionar um novo ficheiro de código sem gerar uma nova classe através do Gerador de Classes.

Após o ficheiro ter sido criado, pode editar o novo ficheiro normalmente; se tem de alternar entre ficheiros diferentes, pode sempre voltar atrás ao ficheiro quer através da árvore de ficheiros ou do menu Janela.

Para gravar quaisquer alterações, o KDevelop oferece uma variedade de opções. A forma standard seria gravar o ficheiro seleccionando "Gravar" ou "Gravar Como " a partir do menu Ficheiro ou através do botão Gravar na barra de ferramentas. Para gravar todos os ficheiros alterados de uma vez, poderia também seleccionar "Gravar Todos" a partir do menu Ficheiro.

Agora, quando a trabalhar num projecto, é muito irritante se algo crítico acontece após ter feito imensas alterações aos seus ficheiros; algumas vezes irá morder-se a si próprio por se ter esquecido de gravar as alterações. O KDevelop toma conta disto oferecendo "Auto-gravação", que está activada por defeito e definida para gravar todos os ficheiros em intrevalos de 5 minutos. Para seleccionar outro período de gravação ou desactivar isto, veja Configuração do KDevelop, onde as opções de configuração são descritas.

Adicionalmente, o KDevelop toma conta de todas as alterações se abrir outro projecto ou sair do KDevelop. Ser-lhe-á perguntado se deseja gravar os ficheiros modificados, onde poderá também ter a opção de espeificar quais gravar e quais manter como estavam anteriormente. Além disso, quando se invoca qualquer processo de construção, os seus ficheiros são gravados automaticamente, pelo que nunca se perguntará porque a sua aplicação não corre da forma que esperava após ter modificado o seu código fonte. A única excepção é o comando "Compilar Ficheiro", que apenas grava o ficheiro de código actualmente aberto e visível na janela de código do editor.

#### Abrir e Fechar Ficheiros

Para abrir um ficheiro de código, também tem imensas opções. Uma poderia ser, como é standard para os editores, seleccionar "Abrir" a partir do menu Ficheiro. Ser-lhe-á apresentado um diálogo "Abrir Ficheiro", que lhe permite escolher o ficheiro que deseja editar. Outra forma, provavelmente mais frequentemente utilizada é seleccionar o ficheiro a partir do VLF, o Visualizador Lógico de Ficheiros, ou do VRF, o Visualizador Real de Ficheiros (veja \|\|). A vantagem das árvores de ficheiro é que proporcionam um acesso visual rápido aos seus ficheiros, especialmente o VLF, que apenas apresenta os ficheiros do seu projecto pelo seu tipo, agregados dentro de pastas. Pode também configurar o VLF no sentido de ordenar os seus ficheiros de outra forma através de um clique do botão direito do rato sobre a árvore. Seleccione "Novo Grupo" a partir do menu de contexto, e pode configurar um novo grupo, ou seleccionar "Editar Grupo" para instalar um novo filtro de ficheiro especificando as extenções de ficheiros do grupo, separadas por vírgulas.

Os grupos de ficheiros standard para um projecto gerado pelo KAppWizard são os Headers, Código, GNU e Outros. Adicionalmente, após adicionar um ficheiro de tradução, o KDevelop adiciona uma pasta "Traduções", contendo os seus ficheiros *.po.

Para fechar ficheiros, seleccione o ficheiro a fechar a partir do menu Janelamenu, que lê o ficheiro aberto para o editor de topo. Depois seleccione "Fechar" a partir do menu Ficheiro. Se o seu ficheiro tiver sido modificado, ser-lhe-á perguntado se o deseja gravar. Quando fechar um projecto, todos os ficheiros correntemente abertos serão verificados por alterações e ser-lh-é também perguntado se os deseja gravar.

### Navegar dentro dos Ficheiros

De seguida ser-lhe-ão dadas linhas gerais de orientação sobre como localizar certas posições dentro dos seus ficheiros para um acesso mais rápido.

Como encontrar uma certa linha num ficheiro

1. Seleccione "Linha" no menu "Ver" ou prima STRG+L. O diálogo preenchido "Ir para Linha" surge.

2. Insira o número da linha para onde deseja ir.

3. Prima OK.

Como definir uma marca de leitura

1. Coloque o cursor na linha que deseja aceder através da marca de leitura

2. Seleccione "Definir Marca de Leitura" através do menu "Marcas de Leitura".

3. Um menu de contexto surge que lhe permite seleccionar o número da marca de leitura que deseja definir para a nova marca.

4. Seleccione o número da marca de leitura.

Outra forma de definir marcas de leitura seria seleccionar "Adicionar Marca de Leitura" a partir do menu "Marcas de Leitura". Isto define uma marca para a linha actual e acrescenta a marca à lista de marcas de leitura. O navegador de documentação também oferece a definição de marcas de leitura para a página actual através de um menu de contexto na entrada "Adicionar Marca de Leitura".

Como apagar marcas de leitura

As marcas de leitura são definidas para cada janela de edição separadamente- lembre-se que as suas marcas não estão conectadas com um dado ficheiro em que tenha definido uma marca de leitura. Para apagar todas as marcas de leitura, seleccione "Apagar Marcas de Leitura" a partir do menu "Marcas de Leitura". Isto apaga as marcas para a janela actualmente no topo, quer seja a janela de Header, a janela C++ ou a janela de navegação.

Como ir para uma linha marcada

1. Seleccione o menu "Marcas de Leitura" e abra o menu de contexto contendo as marcas de leitura para a janela cujas marcas deseja ver; poderá ser a entrada de janela C++ ou de janela Header.

2. Seleccione a linha marcada.

Seleccionar uma marca de leitura para uma janela de navegação irá abrir o navegador e ler a página.

### Trabalhar com Atalhos de teclado

Para utilizar o editor, deverá tornar-se acostumado com alguns atalhos de teclado que lhe tornam a vida mais fácil para posicionar o cursor e editar o ficheiro. A referência completa de atalhos de teclado está também listada na secção Descrição Geral.

    uma letra para a esquerda                        Seta para a Esquerda
    uma letra para a direita                         Seta para a Direita
    uma palavra para a esquerda                      CTRL+Seta para a Esquerda
    uma palavra para a direita                       CTRL+Seta para a Direita
    uma linha para cima                              Seta para Cima
    uma linha para baixo                             Seta para Baixo
    para o princípio da linha                        POS 1
    para o fim da linha                              END
    uma página para cima                             PageUp
    uma página para baixo                            PageDown
    para o princípio do ficheiro actual              CTRL+PageUp
    para o fim do ficheiro actual                    CTRL+PageDown
    uma letra para a esquerda                        SHIFT+Seta para a Esquerda
    uma letra para a direita                         SHIFT+Seta para a Direita
    uma palavra para a esquerda                      CTRL+SHIFT+Seta para a Esquerda
    uma palavra para a direita                       CTRL+SHIFT+Seta para a Direita
    uma linha para cima                              CTRL+Seta para Cima
    uma linha para baixo                             CTRL+Seta para Baixo
    para o princípio da linha                        CTRL+POS 1
    para o fim da linha                              CTRL+END
    uma página para cima                             SHIFT+PageUp
    uma página para baixo                            SHIFT+PageDown
    para o princípio do ficheiro actual              CTRL+SHIFT+PageUp
    para o fim do ficheiro actual                    CTRL+SHIFT+PageDown
    (des)activar modo de inserção                    INS
    copiar selecção para a área de transferência     CTRL+C, CTRL+INS
    inserir texto da área de transferência           CTRL+V, SHIFT+INS
    apagar a linha actual                            CTRL+K
    inserir linha após a linha actual                END, depois Enter
    inserir linha antes da linha actual              POS 1, depois Enter
    desfazer passo de edição                         CTRL+Z
    re-fazer passo de edição                         CTRL+Y
    tabulador                                        TAB
    apagar letra à esquerda da posição do cursor     Backspace
    apagar letra à direita da posição do cursor      Delete
    apagar texto seleccionado                        Seleccionar texto, depois Backspace

### Editar Definições de Janelas

O editor dentro do KDevelop pode ser configurado no sentido de necessidades especiais de edição com efeito global para todas as janelas de edição. Assim pode definir modos de cores, cores de realce (também configurável em relação à linguagem de programação do ficheiro) e definições de texto automaticas tais como dimensão da tabulação e modos de selecção. De seguida iremos ver como definir estas opções através dos diálogos de configuração disponibilizados no menu de "Opções"menu.

#### Definições Gerais

As definições gerais do editor podem ser configuradas com a entrada "Editor" no menu de "Opções". Seleccione os valores desejados e prima OK após terminar com a sua configuração.

##### Opções de Edição

Indentação Automática:

  especifica que o editor deverá colocar o cursor por baixo do primeiro literal quando se inicia uma nova linha.

Indentação de Backspace:

  esta opção define que o cursor deverá ser movido para baixo do primeiro literal da linha de cima quando a tecla backspace é premida.

Translineamento:

  as palavras são levadas para a linha seguinte após a coluna definida em "Translinear Palavras em:"

Substituir Tabs:

  tabuladores no texto actual são substituidos por tabuladores do valor "Comprimento de Tab:"

Remover Espaços Finais:

  remove os espaços no final das linhas

Translinear Cursor:

  coloca o cursor no final da última linha quando o backspace leva ao início de uma linha

Parentesis Automáticos:

  cria um parentesis de fecho em frente do cursor sempre que (qualquer tipo de) parentesis é aberto (parentesis curvos e rectos, chavetas, etc.).

##### Seleccionar Opções

Selecções Persistentes:

  selecções feitas ficam marcadas após colocar o cursor noutro local

Selecções Multiplas:

  permite selecções multiplas independentes dentro de um texto

Selecções Verticais:

  quando a seleccionar multiplas linhas, a selecção é também feita na horizontal e não cobre toda a linha

Apagar na Inserção:

  apaga uma selecção quando se escreve na selecção.

Alternar Antiga:

  permite apenas uma selecção. Uma selecção feita é des-seleccionada quando outra selecção é feita.

Translinear Palavras em:

  define o número máximo de colunas que uma linha pode ter. A palavra que contém a letra que alcança este valor será automaticamente quebrada para a linha seguinte.

#### Cores

Para alterar a aparência geral do editor, pode definir um conjunto de cores que o editor utiliza através da entrada "Cores do Editor" a partir do menu "Opções". Pode configurar as cores para:

- fundo: o fundo do editor

- fundo do texto: o fundo do texto apresentado

- seleccionado: a cor do texto seleccionado para apresentar a selecção

- encontrado: a cor do texto encontrado por uma busca através do menu "Ver"-"Procurar", "Repetir Procura" e "Substituir".

- seleccionado + encontrado: a cor do texto seleccionado para ser procurado e encontrado

#### Realce de Sintaxe

O modo de realce de sintaxe do editor do KDevelop pode ser configurado através de dois diálogos; primeiro pode definir as cores por defeito para o realce de sintaxe através da entrada "Defeitos do Editor" no menu "Opções". Aí, pode definir cores e fontes bem como o tamanho das fontes por ex. palavras-chave. Seleccione o item por defeito e defina todas as opções necessárias.

O segundo diálogo de configuração é acedido através da entrada "Realce de Sintaxe" no menu "Opções". Isto permite-lhe definir os filtros de ficheiros para a linguagem de programação, por ex. *.cpp, *.h para C++. Depois seleccione o item que deseja configurar. Se desejar utilizar os valores por defeito que definiu no diálogo "Defeitos do Editor", seleccione as caixas de escolha "defeito" nas selecções Estilo-Item e Fonte-Item. Isto lê as definições por defeito para o item seleccionado. Após premir OK, os seus novos valores serão activados e utilizados pelo editor.

### Procurar e Substituir

#### Procura num Único Ficheiro

Como encontrar um ou mais caracteres na janela de edição actual

1. Seleccione "Procurar" a partir do menu "Editar". Isto abre um diálogo de procura.

2. Especifique a expressão a procurar no campo de edição. O menu de caixa permite a escolha de uma expressão de busca anterior.

3. Seleccione opções adicionais tais como "Apenas Palavras Inteiras"

4. Prima OK.

Para repetir a busca por uma expressão inserida no diálogo de procura, prima F3.

#### Procurar em Vários Ficheiros

Como a função de procura está a realizar buscas sobre apenas um ficheiro que está actualmente visível, encontra-se limitado a isto. Mas muitas vezes você deseja procurar a mesma expressão em todo o seu projecto. Assim, o KDevelop contém um diálogo `grep`, que lhe permite procurar sobre todos os ficheiros que especificar quer através da definição do directório onde iniciar a busca e/ou por tipos mime. Especificando o directório exacto e o tipo mime irá assim reduzir o tempo que o KDevelop necessita para ler os ficheiros e apresentar os resultados. Para iniciar uma busca sobre vários ficheiros, seleccione "Procurar nos ficheiros..." a partir do menu "Editar". O diálogo deprocura abre e permite-lhe inserir:

- A expressão a procurar (o padrão)

- O modelo utilizado para a busca

- O tipo mime dos ficheiros onde procurar

- O directório onde começar

- Se a busca é recursiva sobre todos os subdirectórios incluidos

Por defeito, o diálogo grep está definido para iniciar no directório do seu projecto e trabalhar recursivamente sobre os ficheiros de implementação e header.

Pode até ampliar o seu padrão de busca utilizando as seguintes opções:

1. . Equivale a qualquer caractere

2. &ˆ; Equivale ao princípio de uma linha

3. $ Equivale ao fim de uma linha

4. \< Equivale ao princípio de uma palavra

5. \> Equivale ao fim de uma palavra

Para uma busca repetida, pode também utilizar os operadores disponíbilizados:

1. ? O item precedente é encontrado menos de uma vez

2. * O item precedente é encontrado zero ou mais vezes

3. + O item precedente é encontrado uma ou mais vezes

4. &&lcub;; n &&rcub;; O item precedente é encontrado exactamente n vezes

5. &&lcub;; n,&&rcub;; O item precedente é encontrado n ou mais vezes

6. &&lcub;;,n &&rcub;; O item precedente é encontrado menos de n vezes

7. &&lcub;;n,m&&rcub;; O item precedente é encontrado pelo menos n vezes mas menos de m vezes

Referências anteriores a subexpressões dentro de aspas estão também disponíveis através da notação \n.

Após especificar a sua busca, prima "Procurar". Os resultados são então apresentados na janela de resultado. Para ir para um ficheiro e número de linha, seleccione a linha do resultado e prima Enter ou clique duplo sobre o resultado. O editor irá automaticamente abrir o ficheiro correspondente e colocar o cursor na linha do resultado. Isto permite uma especificação completa para qualquer acção de procura e devolve resultados exactos.

O KDevelop oferece também algumas funcionalidades mais específicas para a utilização do grep dentro do editor e do navegador. Seleccione a expressão que deseja procurar em qualquer uma das janelas e prima SHIFT+F2 ou seleccione "grep:&<;sua&&lowbar;;expressão&>;" a partir do menu de contexto acessível pelo botão direito do rato. Isto irá pedir ao grep para procurar pela selecção nos ficheiros no directório do seu projecto e mostrará os resultados imediatamente. Ir para o resultado funciona como descrito acima. A partir da janela de navegação, basta colocar o cursor sobre uma palavra e iniciar a procura; a palavra por baixo do cursor será o padrão de procura.

#### Procurar dentro da Documentação

Enquanto a trabalhar num projecto, muitas vezes você necessita de ter informação sobre parâmetros de funções membras que deseja utilizar- quase sempre você lembra-se do nome da função que responde às suas necessidades, mas os parâmetros são algo muito difícil de memorizar. Assim, e para outros propósitos que possam ocorrer, o KDevelop contém uma funcionalidade de procura que combina a busca de expressões que surgem dentro dos seus ficheiros com o navegador de documentação. Para fazer uso desta funcionalidade de busca, você deverá ter definido o navegador de documentação correctamente e criado a base de dados de pesquisa. Para invocar uma procura através da documentação, faça o seguinte:

1. coloque o cursor na palavra que deseja procurar ou seleccione uma expressão

2. seleccione "Procurar Texto Marcado" a partir do menu "Ajuda" ou prima o botão direito do rato para abrir o menu de contexto; depois seleccione "Procurar : "expressão".

3. após a página de resultados da busca ser apresentada no navegador de documentação, seleccione a página que pensa conter a informação de que necessita.

4. a página de documentação seleccionada é apresentada e o resultado da sua procura é marcado. Para observar o resultado seguinte dentro da mesma página de documentação, prima F3.

Isto permite-lhe procurar facilmente a informação de que necessita. Para utilizar os resultados, o navegador de documentação permite marcar uma selecção e copia-la para a área de transferência. Depois volte para o ficheiro que estava a editar e seleccione "Colar" a partir do menu "Editar".

Para uma descrição completa de como utilizar a Documentação, veja Utilizar o Índice de Busca.

#### Substituir Texto

Para substituir uma expressão, seleccione "Procurar e Substituir" a partir do menu "Editar". O diálogo de "Procurar e Substituir" permite-lhe especificar a expressão a ser substituida bem como a expressão de substituição. Depois prima OK. A primeira expressão que for encontrada será marcada, pelo que pode ver onde a expressão está e em que contexto. Depois pode especificar através de um diálogo se a expressão será substituida ou não. Quando a busca estiver terminada por atingir o final do ficheiro actual, ser-lhe-á perguntado se deseja re-iniciar a procura de novo a partir do início do ficheiro. Se tiver terminado, seleccione "Cancelar".

### Imprimir

Como o KDevelop está desenhado para dar aos programadores o melhor acesso aos ficheiros e informação para reduzir o ciclo de desenvolvimento, também contém um novo utilitário de impressão que faz uso de dois programas de impressão comuns disponíveis para sistemas Unix, a2ps (ASCII-para-Postscript) e enscript. Para além destes, pode também imprimir directamente utilizando o lpr (o dispositivo de impressão linear). Como a utilização do a2ps ou enscript oferecem o maior número de opções de impressão, deverá instalar qualquer um deles no seu sistema; ambos os programas são normalmente enviados com as distribuições, pelo que não deverá ter qualquer problema em os obter. Mas antes de imprimir, deverá percorrer os diálogos de configuração disponíveis para preparar o resultado final de acordo com as suas necessidades. As secções seguintes descrevem como configurar o KDevelop para imprimir ficheiros.

#### Configurar a Impressora

Ambos os programas de impressão podem ser configurados seleccionando "Imprimir" a partir do menu "Ficheiro"; no diálogo de impressão, seleccione o programa através do menu de caixa no canto superior esquerdo. Depois prima o botão "Opções" à direita. Isto irá abrir a configuração para o programa seleccionado que será utilizado. Outra forma de configurar os programas é seleccionando "Configuração de Impressora..." a partir do menu "Opções"; depois seleccione "a2ps" ou "enscript".

##### As Opções de Configuração do a2ps

###### Imprimir

- cabeçalho: adiciona uma moldura de cabeçalho à página

- nome do ficheiro: se activo, a moldura de cabeçalho conterá o nome do ficheiro como sendo o seu texto

- utilizador: adiciona a identificação do utilizador (User ID) ao canto superior direito da página

- margens: adiciona molduras de margem à página de texto

- Data & Hora: adiciona a data e hora de impressão

- alinhar ficheiros: imprime os ficheiros na mesma página, disponível para modo de impressão de duas páginas

- definir tamanho do TAB: define o tamanho do TAB para impressão de TABs

- texto de cabeçalho: disponível, se nome de ficheiro está inactivo e permite inserir outro texto na moldura de cabeçalho

- tamanho da fonte: define o tamanho da fonte para o texto. O tamanho por defeito é 9

###### Impressão de Texto

- cortar linhas: corta o conteudo das linhas se elas forem demasiado grandes para serem impressas. Se inactivo, as linhas serão quebradas.

- interpretar TAB, BS e FF: interpreta os caracteres TAB, Backspace e FastForward.

- substituir caracteres não imprimíveis por espaços: se o ficheiro contém caracteres não-imprimíveis, eles serão substituidos por caracteres de espaços.

- imprimir caracteres não-ASCII como ISO-Latin 1: imprime caracteres não incluídos no formato ASCII em formato ISO-Latin 1

- fonte negrito: imprime todo o texto em modo de fonte negrito.

###### Numeração

- numeração de linhas: numera todas as linhas de cima para baixo, se activo

- numeração de páginas: permite seleccionar o modo de numeração de páginas por:

  - ficheiro sozinho: numera as páginas de cada ficheiro a começar no 1

  - ficheiros juntos: junta todas as páginas após a primeira para numeração de páginas

- linhas por página: define o número máximo de linhas por página a ser impressa.

##### As Opções de Configuração enscript

###### Cabeçalho

- Cabeçalho Fantasioso: adiciona um cabeçalho fantasioso

- Texto de Cabeçalho: permite adicionar um texto de cabeçalho

  - texto: define o conteúdo do texto

  - posicionamento: define o posicionamento do texto à esquerda, centro ou direita

- Utilizador: adiciona a identificação do utilizador (UserID) ao cabeçalho

  - utilizador: permite adicionar identificação de utilizador (UserID)

  - posicionamento: define o posicionamento para o UserID

- Nome de Ficheiro: adiciona o nome de ficheiro ao cabeçalho

  - Tamanho do Nome de Ficheiro: adiciona o nome do ficheiro como completo ou curto, significando caminho completo ou apenas nome do ficheiro

  - Posicionamento: define o posicionamento do nome do ficheiro

- Nome do Servidor: adiciona o nome do computador (hostname) ao cabeçalho

  - nome do servidor: permite adicionar nome do computador

  - tamanho do nome do servidor: define o tamanho do nome do servidor

  - posicionamento: define o posicionamento para o nome do servidor

###### Data & Hora

- Data Actual: inclui a data actual

  - data actual: permite adicionar a data actual

  - posicionamento: define o posicionamento para a entrada de data

  - formato: define o formato da data

- Data de Modificação: inclui a data da última modificação

  - data de modificação: permite adicionar a data da última modificação

  - posicionamento: define o posicionamento para a entrada de data de modificação

  - formato: define o formato da data

- Hora Actual: inclui a hora actual

  - hora actual: permite adicionar a hora actual

  - AMPM:/ utiliza o formato AM/PM ou 24h

  - Posicionamento: define o posicionamento para a entrada de hora

  - Formato: define o formato de hora

- Hora de Modificação: inclui a hora da última modificação

  - hora de modificação: permite adicionar a hora de modificação

  - AMPM:/ utiliza o formato AM/PM ou 24h

  - Posicionamento: define o posicionamento para a entrada de hora

  - Formato: define o formato de hora

###### Aspecto Final

- Numeração & Margens:

  - numeração de linhas: adiciona numeração de linhas ao documento a ser impresso

  - margens: adiciona uma margem às páginas a serem impressas

  - numeração de páginas: numera as paginas para impressão

  - alinhar ficheiros: junta os ficheiros para numeração de página

  - linhas por página: o valor máximo de linhas por página

- Formato e TAB:

  - define tamanho de TAB: define o tamanho do TAB para interpretar TABs

  - fonte para cabeçalhos: define a fonte utilizada para texto de cabeçalho

  - fonte para corpo: define a fonte para o corpo do texte (conteudo do ficheiro)

- Impressão de Texto:

  - cortar linhas: corta as linhas se forem demasiado grandes. Se inactivo, as linhas são quebradas

  - substituir caracteres não imprimíveis por espaços: substitui caracteres não imprimíveis por caracteres de espaço

- Outras Opções:

  - índice: adiciona uma página de índice que contém informação sobre os ficheiros impressos, número de páginas etc.

  - Barras de Realce:

    - barras de realce: realça as linhas para impressão

    - ciclo de mudança: define o número de linhas para mudar o estilo de realce

  - Translinear Linha:

    - marcar linhas translineadas: linhas que são quebradas são marcadas para impressão

    - valor para linhas translineadas: o valor pré-definido para para a nova linha em que a linha foi quebrada.

###### Marca de Água

- Texto: define o texto para a marca de água

- Posicionamento: define o posicionamento para o texto de marca de água

- Fonte: define a fonte utilizada para a marca de água

- Ângulo: define o ângulo para o texto da marca de água

- Escala de Cinzento: define a escala de cinzento para o texto de marca de água

- Estilo: define o texto de marca de água a ser impresso como sendo apenas bordejado ou cheio

#### O Diálogo de Impressão

##### Opções de Impressão Directa

- Programa: define o programa de impressão a ser utilizado: a2ps, enscript ou lpr

- Impressora: define a impressora a ser utilizada

- Localização do Output: para imprimir para ficheiro, selecciona a localização do output

- Orientação: define a orientação para imprimir, ou paisagem ou retrato

- Copias: define o número de copias a serem feitas por página

- Tamanho do Papel: define o tamanho do papel a ser utilizado

- Formato do Output: para utilizar o enscript como programa de impressão, pode escolher entre impressão em postscript ou html

- Definições de Impressão de Defeito: utiliza as definições por defeito para impressão

- Formato de Impressão:

  - Impressão de Páginas: define uma ou duas páginas numa folha de papel

  - Páginas: selecciona todas, ímpares ou pares para utilização com o enscript

  - Impressão de Qualidade:

    - impressão de qualidade: activa modo de impressão de qualidade para o enscript

    - côr: imprime a cores

    - Modo de Impressão de Qualidade: define o modo de impressão dependendo do formato do seu ficheiro

##### Selecção de Ficheiros

O diálogo de selecção de ficheiros é acedido através do botão "Ficheiros" no diálog de impressão. A selecção de ficheiros permite especificar que ficheiros imprimir através de certos critérios:

- Selecção de Ficheiros:

  - actual: o ficheiro actualmente aberto e visível na janela de edição

  - todos no projecto: todos os ficheiros incluidos no projecto actualmente aberto

  - ficheiros escolhidos: permite-lhe escolher que ficheiros imprimir através de selecção de ficheiros

  - todos os ficheiros cpp: imprime todos os ficheiros de código do projecto

  - todos os headers: imprime todos os ficheiros header do projecto

  - ficheiros modificados: permite especificar ficheiros que foram modificados entre datas:

- Ficheiros Modificados:

  - Entre: especifica todos os ficheiros modificados depois:

    - Data: a data em que os ficheiros foram modificados

    - Hora: a hora a que os ficheiros foram alterados

  - E: especifica todos os ficheiros modificados antes:

    - Data: a data em que os ficheiros foram modificados

    - Hora: a hora a que os ficheiros foram modificados

- Ficheiros Escolhidos: disponível se foi seleccionado ficheiros escolhidos (ver acima)

  - adicionar: prima para adicionar um ficheiro seleccionado para imprimir à lista à esquerda

  - apagar: apaga um ficheiro seleccionado da lista de impressão

  - limpar: limpa a lista de impressão

##### Ver Antes

Ver Antes está disponível para que você possa controlar qual será o aspecto do resultado final. Assim, o KDevelop utiliza o programa ghostview ou kghostview. Quando o botão de ver antes for premido em qualquer um dos diálogos de impressão, ser-lhe-á apresentado um modelo de output que lhe mostra o efeito das opções actualmente definidas.

## Projectos

### Tipos de Projectos

#### Programas

O KDevelop cria um ficheiro de projecto com a extenção .kdevprj. Este ficheiro contém toda a informação do seu projecto, pelo que deverá ter cuidado em não o apagar. É guardado no directório base do projecto e tem de ser aberto para ler o projecto. O ficheiro de projecto armazena toda a informação dos seus ficheiros tal como propriedades dos ficheiros, caminhos de instalação, estado de distribuição e opções de compilador (CXXFLAGS). Definir propriedades dos ficheiros permite-lhe manter registo de para onde os ficheiros deverão ir.

Com o KAppWizard, você pode criar um novo projecto de aplicação de acordo com a sua escolha de tipo de aplicação. Por ora, o KAppWizard gera três tipos de esqueletos de aplicação, sendo:

- Aplicação KDE
  Interface de Documento Único (SDI) incluindo uma barra de menu, uma barra de ferramentas e de estados. Contém controlo básico de gestão de recursos para permitir extender o esqueleto da aplicação até obter uma nova aplicação KDE
  . O esqueleto de aplicação também contém mensagens de ajuda na barra de estados já conhecidas de produtos comerciais e até do próprio KDevelop. Do ponto de vista do programador, é baseada em três classes específicas de aplicação que se apoiam no conceito MVC (Model-View-Controller = Controlo de Modelo de Vista). Tecnicamente, as classes base podem não ser vistas dessa forma, mas a sua construção é pelo menos bastante lógica para criar aplicações com interface gráfico.

- esqueleto de janela de aplicação baseada em KDE
  . Este tipo de aplicação oferece a maior flexibilidade para aqueles que querem desenvolver o seu programa de raiz, mas pode também ser utilizado como uma base para desenvolver aplicações tipo assistente ou módulos.

- um esqueleto de programa baseado apenas na Qt. Para aqueles programadores que desejam utilizar apenas as bibliotecas Qt como interface gráfico, nós tentamos oferecer um esqueleto inteligente para suportar o desenvolvimento da sua aplicação. Como a programação Qt é completamente suportada, não deverá ter quaiquer problemas em criar uma aplicação completamente funcional utilizando apenas a Qt.

- um esqueleto de programa C++. Este tipo de aplicação é destinado aqueles que desejam escrever um programa C++ baseado em consola. Basta removee a linha "Hello World" no main() e construir as suas classes da mesma forma com o KDevelop como faria para uma aplicação KDE
  .

Para importar aplicações existentes, sugerimos que utiliza a opção Novo Projecto. Seleccione "Projecto" a partir da barra de menu e seleccione "Novo". O diálogo de Novo Projecto oferece a criação de directório de projecto e subdirectórios bem como o ficheiro do projecto com o nome do projecto e tipo. Aconcelhamos copiar todos os ficheiros de criação necessários tais como configure.in, Makefile.am's etc. para dentro do directório do projecto a partir do seu projecto existente e escolher "Projecto"&->;"Adicionar Ficheiro(s)"&->;"Adicionar ficheiro(s) existente(s)" para copiar o código para o seu novo directório de projecto. Note que os seus Makefile.am's serão alterados pelo KDevelop e provavelmente terá de modificar ou apagar algumas entradas para conseguir uma compilação limpa. Não deverá editar a área de escrita do KDevelop, em vez disso deverá ler as entradas feitas pelo KDevelop e apagar os títulos correspondentes criados por si próprio. Também note que apenas é suportado trabalhar num projecto de momento, pelo que os seus ficheiros de código deverão estar no subdirectório do projecto que terá o mesmo nome que o directório principal do projecto. No Visualizador Lógico de Ficheiros os grupos têm de ser definidos por sí se escolher utilizar essa forma de importação. Outra forma seria criar um esqueleto de aplicação e apagar os ficheiros de código e header criados. Depois adiciona os ficheiros existentes como descrito acima.

#### Bibliotecas

Este tipo de projecto não é suportado de momento. Esta é outra funcionalidade planeada para ser integrada em versões posteriores do KDevelop.

#### Alvos Múltiplos

Para alguns projectos, as facilidades do KDevelop no seu estado actual não serão suficientes. Esses projectos são os que incluem alvos múltiplos tais como pacotes contendo várias aplicações. Como comandos tais como "Executar" ou o Navegador de Classes requerem que apenas um alvo seja construido pelo programados, esses tipos de projectos são apenas suportados na forma em que tem de escrever as suas próprias entradas nos Makefiles e construir os seus directórios para bibliotecas ou binários adicionais a serem construidos. No entanto, um processo de construção sempre invoca o seu programa make independentemente do que são na realidade os alvos; pelo que estas funções ainda podem ser utilizadas.

Outra forma de poder trabalhar com este tipo e continuar a ter acesso aos binários em si é criar projectos vazios e mover mais tarde os seus subdirectórios em conjunto com os ficheiros de projecto para o directório contendo todo o código. Depois poderá ler cada um dos alvos independentemente através do seu ficheiro de projecto; isto também permite executar e depurar o alvo.

### Projectos Novos

O Assistente de Aplicações do KDevelop permite a criação de quatro tipos diferentes de projectos, construindo um esqueleto para cada. Todos os projectos estão de acordo com FSF e utilizam as ferramentas de desenvolvimento standard GNU como descrito na secção dos requerimentos deste manual. Para aplicações KDE
, o assistente oferece dois esqueletos diferentes, a Aplicação KDE
, disponibilizando uma aplicação completa com classes base para escrever documento, ver e aplicação. Isto inclui a criação de barras de menu, ferramentas e estadps, a janela principal herda a classe KTMainWindow. A Mini-Aplicação KDE
apenas disponibiliza uma vista que está vazia. Este tipo de projecto pode ser utilizado para criar uma pequena ferramenta de ambiente de trabalho ou outra aplicação simples sem muitas modificações no código existente disponibilizado com o esqueleto. Uma aplicação Qt disponibiliza a criação de um programa apenas Qt
se não desejar quaisquer dependências de bibliotecas KDE para o utilizador final. (NOTA: O script de configuração irá verificar a existência das bibliotecas KDE
. Isto será corrigido na próxima versão do KDevelop). A Aplicação Qt também é criada com três classes base tal como a Aplicação Standard KDE e disponibiliza uma barra de menu, de ferramentas e de estados.

A Aplicação C++ oferece um esqueleto para criar aplicações de linha de comando. Está pronta a correr e por defeito apresenta "Hello World" como única acção. Isto pode ser útil a quem está a aprender C++ e que queiram programar aplicações sem utilizar um ambiente gráfico primeiro ou para aqueles a trabalhar em programas de linha de comando escritos em C++ ou C.

O assistente pergunta-lhe o nome do projecto, versão e localização conde deseja que o directório do projecto seja construido. Além disso, o seu Nome e Endereço Email são pedidos para inserir no cabeçalho dos modelos de header e cpp bem como nas entradas no ficheiro *.lsm.

### Abrir e Fechar Projectos

O KDevelop está por defeito configurado para abrir o último projecto carregado quando arranca. Isto permite um arranque rápido, mas pode desejar alterar isso para iniciar o ambiente de desenvolvimento sem qualquer projecto. Para evitar o comportamento de defeito, desactive a opção "Ler último projecto" no diálogo Configuração do KDevelop.

Para abrir outro projecto, seleccione "Abrir" a partir do menu "Projecto" ou prima o botão "Abrir Projecto" na barra de ferramentas. No caso de ter outro projecto presentemente aberto, ele será fechado. Se esse seu projecto contiver ficheiros que não estão gravados, é-lhe perguntado se deseja gravar todos os ficheiros modificados. Assim, pode seleccionar quais os ficheiros que grava e quais os que fecha sem gravar, ou gravar todos de uma vez.

Depois obtém um diálogo "Abrir Projecto", onde pode ir para o directório contendo o ficheiro do projecto a ser aberto. Os ficheiros de projecto do KDevelop têm a extenção mime *.kdevprj que é também apresentada pelo icon do projecto. Seleccione o ficheiro do projecto e prima "Abrir". Quando a ler o projecto, o Navegador de Classes percorre todos os ficheiros e constroi a árvore de classes inicial, para que possa começar a trabalhar no projecto utilizando directamente o Navegador de Classes.

Outra forma confortável de abrir um projecto é seleccionar o ficheiro do projecto no KFM, o Gestor de Ficheiros do KDE
. Isto irá iniciar o KDevelop lendo o ficheiro de projecto seleccionado. Pode também abrir um projecto através da linha de comandos, escrevendo `kdevelop nomeprojecto.kdevprj`.

Quando fechar o KDevelop, os ficheiros do seu projecto serão gravados automaticamente e o ambiente de desenvolvimento detecta se você modificou quaisquer ficheiros do projecto. Ser-lhe-á então perguntado se deseja gravar as modificações antes de sair. As opções disponíveis são as mesmas que para fechar um projecto antes de abrir outro.

### Editar um Projecto

Após ter criado um projecto novo com o KAppWizard, a tarefa habitual é ampliar o projecto editando o código já criado e adicionar classes, pixmaps, imagens e o que mais o seu projecto necessitar. Agora, editar um projecto significa que você pode modificar o projecto de defeito após a sua geração através de menus e diálogos de acordo com as suas necessidades. A secção seguinte descreve assim como pode adicionar ficheiros existentes e classes bem como criar novos ficheiros. Isto é necessário para construir o seu projecto, mas não o ajudará no processo de instalação para o utilizador final. Desta forma, a secção Definir Opções de Ficheiros do Projecto descreve como definir Propriedades dos Ficheiros especialmente para adicionar ficheiros que deseja que o make instale, tais como documentação ou pixmaps. Outra parte na manutenção de um projecto é adicionar traduções para a aplicações que suportem internacionalização, o que é descrito em Adicionar Traduções.

Extender a Documentação do Projecto cobre questões sobre como criar um bom conjunto de documentação para ajuda electrónica permitindo ao utilizador final ajudar-se a si próprio em caso de problemas bem como saber utilizar o seu produto.

Finalmente, Hacking do Projecto descreve como poderá eventualmente trabalhar à volta da gestão do projecto no KDevelop em casos especiais.

#### Adicionar e Remover Ficheiros e Classes

Adicionar um novo ficheiro é muito utilizado quando pensa em separar o seu ficheiro de implementação de classes em vários. Depois você necessita de criar um novo ficheiro que contenha parte da implementação da classe que deseja mover. Pode fazer isto escolhendo "Novo" a partir do menu "Ficheiro", abrindo o diálogo "Novo Ficheiro". Isto permite-lhe especificar o tipo de ficheiro, nome e localização. Depois de inserir o nome do ficheiro, o KDevelop automaticamente acrescenta a extenção por si, mas pode modificar a extenção segundo as suas preferências. Mais ainda, pode incluir o modelo de cabeçalho para ficheiros de código, pelo que não tem de copiar isto para o seu novo ficheiro manualmente. Também, você pode decidir, de o ficheiro é ou não incluido no projecto. Lembre-se que isto não cobre o destino de instalação; isto tem de ser configurado mais tarde definindo as preferências de ficheiro.

Depois de o novo ficheiro ter sido criado, o ficheiro de projecto será actualizado bem como os correspondentes Makefile.am's. Para adicionar uma classe completa ao seu projecto, pode construir uma nova classe no Gerador de Classes que é invocado pela entrada "Nova Classe" no menu Projecto.

No caso de ter um projecto existente e querer adicionar certas classes que deseja re-utilizar no seu projecto, seleccione "Adicionar Ficheiros(s) ao Projecto..." a partir do menu Projecto. Seleccione "Adicionar ficheiros existentes", que irá abrir um diálogo para lhe permitir especificar que ficheiros serão adicionados ao projecto e o directório de destino. Lembre-se que os ficheiros serão copiados para o directório especificado e adicionados ao projecto. Deverá chamar o "Make" após adicionar código; depois os ficheiros por si adicionados serão incluidos no processo de construção. No caso de querer adicionar por ex. pixmaps que têm de ser instalados pelo utilizador final, deverá actualizar as Propriedades do Ficheiro para o ficheiro adicionado e especificar o caminho de instalação (veja Definir Opções de Ficheiros do Projecto

Para adicionar um ficheiro ao projecto que já se encontra no directório do projecto, vá ao VFR, onde todos os ficheiros incluídos no projecto são apresentados pelo seu estado no projecto através de um ! a vermelho sobre o icon do ficheiro. Seleccione o ficheiro que deseja adicionar ao projecto (que tem um icon de ficheiro normal) e prima o botão direito do rato para obter o menu de contexto. Depois seleccione "Adicionar".

Ficheiros podem também ser removidos do seu projecto. Isto pode ser necessário em casos em que não deseja utilizar ficheiros pré-gerados que são já dados pelo KAppWizard. Para remover um ficheiro, tem adicionalmente a opção entre remover o ficheiro do projecto ou apaga-lo completamente. Para remover um ficheiro do projecto, seleccione o ficheiro no VFL ou no VFR, pressione o botão direito do rato e seleccione "remover". Para apagar um ficheiro, seleccione "apagar fisicamente".

#### Definir Opções de Ficheiro de Projecto

O diálogo de propriedades do ficheiro pode ser acedido através do menu projecto ou dentro do VFL através de um clique do botão direito do rato. Mostra os ficheiros do projecto em grupos como estão ordenados no VFL e são apresentadas as propriedades dos ficheiros tais como tamanho do ficheiro, tipo de ficheiro e se o ficheiro está incluido no projecto bem como o caminho de instalação se o ficheiro for ser instalado pelo comando make install do utilizador final. É importante para ficheiros de documentação bem como pixmaps especificar a licalização para onde os ficheiros devem ir quando o projecto é construido e instalado pelos utilizadores finais, pelo que tem de definir estas localizações. Para macros de localizações standard KDE
deverá procurar no seu Makefile.am onde as macros de localização são especificadas.

#### Adicionar Traduções

Como o KDE
permite configurar o seu ambiente de trabalho e o comportamento das suas aplicações, tem também a opção de escolher o idioma que a sua aplicação utiliza, no que toca à utilização de documentação electrónica bem como do aspecto da aplicação. Para ficheiros de documentação, isto parece uma tarefa trivial. Deverá adicionar um subdirectório com o nome do idioma desejado, por ex. `de` para alemão, ao directório `docs` do seu projecto e copiar a documentação em inglês para esse directório. Depois deverá gerar a documentação e definir todas as opções de ficheiros de projecto para os directórios de instalação. Depois poderá começar a traduzir o ficheiro sgml para o seu idioma desejado e re-gerar a documentação; ficará tudo pronto. Para a aplicação, isto é um pouco mais difícil para o programador. Agora, nós queremos explicar como permitir suporte para internacionalização na sua aplicação e como adicionar idiomas que deseje suportar.

Primeiro, tem de delimitar todo o texto visível da sua aplicação que surge em barras ou diálogos com a macro `i18n()`. Esta macro é a substituição para a função `klocale->tranlate()` da classe KLocale e muito mais fácil de utilizar. Como esta macro é declarada no ficheiro include `kapp.h`, tem de adicionar `&&num;;include &<;kapp.h&>;` ao ficheiro de código ou ficheiro de declaração de classe da classe que faz uso desta macro. Também deverá ser mencionado, que apesar de `i18n()` ser uma macro e por isso você poderia pensar em utilizar a função original, mas isto não irá funcionar porque os textos que são definidos para tradução têm de ser lidos a partir do código e serem guardados no ficheiro de tradução da aplicação (&<;SuaApl&>;.pot no subdirectório /po ). Esta tarefa é feita pelo programa xgettext, e para o fazer, você deverá escrever `make messages` no directório do seu projecto contendo o código. Como o xgettext depende da macro `i18n()`, a função original não conseguirá realizar a tarefa.

Para as traduções em si, tem primeiro de criar o ficheiro de mensagens contendo todos os textos a serem utilizados no seu código com a macro `i18n()`. isto pode ser feito escolhendo "Make Messages e juntar" a partir do menu Construir. Depois tem de adicionar os idiomas que a sua aplicação deseja suportar. Para tal, seleccione "Adicionar Ficheiro de Tradução" a partir do menu Projecto. Isto abre o diálogo de selecção de idioma. Seleccione o idioma e prima OK. Isto irá construir o ficheiro ASCII contendo entradas para o ficheiro do texto e a linha onde o texto original é colocado. Depois irá ver uma linha `msgid` contendo o texto a ser traduzido, seguido de `msgstr`. A linha msgstr é normalmente vazia excepto para as traduções já disponibilizadas pelas bibliotecas KDE
. Essas têm de ser preenchidas com as traduções correspondentes para o seu idioma.

Poderia pensar em escrever as traduções manualmente, o que pode ser feito. Mas o KDE-SDK
disponibiliza a utilização do programa KTranslator, que abre os ficheiros existentes de outras aplicações instaladas no sistema, para que possa re-utilizar textos já traduzidos para suportar o seu idioma.

Para aceder ao KTranslator, a forma mais fácil é seleccionar um ficheiro &<;idioma&>;.po no directório /po quer através do VFL ou no VFR. Isto abre o KTranslator permite-lhe fazer a tradução facilmente. Lembre-se que tem de definir você mesmo as propriedades do KTranslator para incluir o nome do autor e o idioma bem como o ficheiro de destino. O KTranslator por defeito apenas abre o seu ficheiro de tradução.

Para todos os ficheiros de tradução, `make` utiliza o programa `msgfmt` para formatar os seus ficheiros de mensagens para utilizar com o binário, mas você não tem de tomar conta disto, bem como especificar o directório de destino para instalar os ficheiros de tradução; isto é tudo feito automaticamente pelo KDevelop.

Para mais informações sobre suporte à internacionalização, veja http://www.kde.org; imensas pessoas estão a fazer traduções para si para suportar o idioma deles. Irá encontrar uma lista de endereços e-mail dos tradutores a que poderá escrever e que o ajudarão com isto. Leia também O Editor de Diálogos e O Manual de Programação do KDevelop onde questões sobre a internacionalização são de novo abordadas.

#### Aumentar a Documentação do Projecto

Todos os projectos criados com o KDevelop contêm uma documentação pré-configurada, que já contém capítulos standard para instalação, nome de projecto e versão bem como o nome do autor e endereço email. Como o KDevelop utiliza modelos SGML, é muito simples ampliar a documentação para um sistema de ajuda completamente descritivo. A única coisa que tem de fazer é editar o ficheiro sgml, colocado em docs/en como index.sgml. A documentação de referência incluida com o seu pacote de ferramentas sgml pode ser adicionada ao navegador de ajuda e permitir-lhe acesso directo a algumas tags especiais bem como uma breve descrição de como expandir a sua documentação. O SGML tem imensas vantagens, pelo que o KDE
faz grande uso deste tipo de documentação adicionalmente à ferramenta ksgml2html. Isto cria a documentação tipica estilo-KDE
e fa-la ter um melhor aspecto. De qualquer forma, as ferramentas sgml por si são o suficiente para produzir um resultado em html que é logo incluido na sua aplicação. Para criar os documentos utilizando o ksgml2html, instale a ferramenta e corra "Make Manual do Utilizador" a partir do menu Construir. O Navegador de Documentação permite um controlo directo do resultado seleccionando "Manual do Utilizador do Projecto" a partir do menu Ajuda ou do icon correspondente na árvore DOC. Pode depois navegar a sua documentação electrónica no KDevelop e ter uma melhor visão do resultado final em relação a erros resultantes de tags que não foram escritas.

Agora, enquanto a ampliar a documentação, não pode evitar que ficheiros adicionais sejam produzidos e tenham de ser incluidos no projecto já que cada `sect`-tag cria um novo ficheiro HTML. O resultado final gerado pelo KAppWizard já se encontra incluido no projecto, pelo que não se tem de preocupar com o seu caminho de instalação. O que tem de observar é qualquer ficheiro index-xx.html, onde xx é superior a 6 (já que as primeiras seis páginas já estão incluidas no projecto). Após gerar a documentação, mude para o VFR e vá para o seu directório de documentação. Prima o botão direito do rato sobre os ficheiros a adicionar e seleccione "Adicionar". Além disso, o ksgml2html adiciona o logotipo KDE
ao directório da documentação. Este ficheiro, `logotp3.gif`, tem também de ser adicionado ao projecto. Depois tem de seleccionar "Propriedades de Ficheiros" quer a partir do menu Projecto ou pelo menu de contexto nos visualizadores de ficheiros. A forma mais fácil de definir o caminho de instalação é seleccionar um ficheiro de documentação já definido para instalação tal como o `index.html`. Verá que o `Instalar` está activo e o Directório de Instalação+Nome de Ficheiro já contêm o destino. Marque o Directório de Instalação prima CTRL+C para copiar o caminho de instalação para a área de transferência. Depois seleccione o ficheiro que deseja especificar para instalação. Active `Instalar`, o que irá activar o campo Directório de Instalação, já contendo o nome do ficheiro. Coloque o cursor em frente do nome do ficheiro e prima CTRL+V para inserir o conteudo da área de transferência (que eram o caminho de instalação copiado anteriormente). Esta é a forma mais rápida de especificar o caminho de instalação. Para mais opções sobre especificação de destinos de instalação, veja O Manual de Programação do KDevelop.

#### Hacking ao Projecto

Quando a trabalhar com um projecto, nunca deverá editar o ficheiro do projecto manualmente. Isto impedirá o KDevelop de ler o seu projecto correctamente em algumas circunstâncias, bem como alterações não irão resultar na actualização dos ficheiros Makefiles. Para modificar quaisquer definições para o seu projecto, tem de utilizar as entradas de menu existentes tal como por ex. para adicionar ficheiros ou definir propriedades de ficheiros. Para grandes conehcedores que não estão à vontade com certas opções por ex. o linkador ou configurações adicionais de projecto necessárias, deverá mexer por si nas macros dos Makefile.am e adicionar todas as modificações nos Makefile.am's após a secção separada com a entrada "KDevelop write area". Como as ferramentas GNU estão a utilizar os comandos no final de todos os ficheiros macros, pode passar por cima das definições do KDevelop desta forma. Lembre-se que isto o impedirá de utilizar o KDevelop para quaisquer modificações relacionadas com a configuração do projecto.

### Parâmetros de Compilador e Linker para Projectos

Cada novo projecto contém todas as opções necessárias para o compilador e linker bem como as definições gerais. Por defeito, o seu projecto está preparado para utilizar depuração pela parâmetro -g, e os avisos estão definidos para standard, -Wall. Isto assegura que você pode depurar a sua aplicação e detectar construções que podem causar erros no programa. Para algumas aplicações, poderá precisar de opções adicionais de compilador ou linker, especialmente se estiver a utilizar bibliotecas que não estão actualmente incluidas pelo linker. Depois necessita de actualizar o projecto através da configuração das definições correctas com o diálogo de Opções do Projecto. Veja Definições de Construção para mais informação sobre onde definir Opções de Compilador, Avisos e Opções de Linkagem.

### Projectos Externos

Projectos existentes podem ser convertidos para projectos do KDevelop seleccionando "Novo" a partir do menu projecto. O diálogo seguinte cria um ficheiro de projecto vazio com o nome do seu projecto, versão e informação tipo bem como o seu nome e endereço email. Depois copie todos os seus ficheiros de compilação e construção para o novo directório de projecto e escolha "Adicionar Ficheiros" a partir do menu projecto. Os ficheiros seleccionados serão copiados para o seu directório de projecto e os makefile.am's são actualizados. Por favor modifique todas as entradas existentes nos Makefile.am antes da conversão no sentido das entradas agora criadas pelo KDevelop na área KDevelop. Teste, se o seu programa ainda pode ser compilado e instalado depois da conversão para se assegurar da consistência do projecto.

## Definições de Construção

O diálogo de Opções do Projecto, acedido a partir do menu projecto, permite-lhe especificar todos os parâmetros necessários para o seu projecto. Eles serão utilizados pelos Makefile.am's e o script configure.in (por ex. alteração de número de versão ou avisos do compilador) e assim definem também as preferências de compilação. Após alterar as opções do projecto, deverá invocar "make clean" ou "reconstruir tudo" para compilar o seu projecto com as novas opções. Por favor lembre-se que depurar apenas está disponível se as opções do projecto estão definidas para gerar informação de depuração, a quantidade pode ser definida com o nível de depuração (0-3). Se adicionar funções que pertençam a uma biblioteca que não esteja incluida nas parâmetros do linker, o seu programa não será correctamente linkado se essas opções não forem actualizadas, por isso tenha atenção às linkagens de bibliotecas.

Para uma construção de distribuição das suas aplicações ou para distribuir um pacote com o código fonte, deverá observar as seguintes definições standard:

- desactivar a depuração

- activar optimização e definir o nível de optimização para -02

- definir os avisos do compilador para -Wall

- por cada nova distribuição, aumentar o número da versão e actualizar o ficheiro projecto.lsm segundo a versão e os requerimentos.

### Opções Gerais

A primeira página do diálogo de Opções do Projecto define as opções gerais para o seu projecto. Estas são o nome e número do projecto, o ficheiro sgml de manual que será utilizado para gerar um conjunto de ficheiros HTML que serão incluidos no projecto e informação específica sobre o autor. O campo para breve descrição é para informação adicional que deseje incluir tal como o objectivo do programa e outras similares.

### Opções de Compilador

A página de opções do compilador define os parâmetros do compilador em relação ao seu alvo, depuração e outras.

#### Alvo

A caixa de alvo contém três opções que podem ser definidas:

Máquina Alvo: Tem a possibilidade de definir a máquina alvo escolhendo entre a sua máquina (defeito) e i386v, que é a opção se tiver definido o seu compilador como sendo compilador-cruzado para uma máquina Intel 386-compatível correndo System V. Esta opção define o parâmetro -b para o compilador. Normalmente deixaria isto como sendo o defeito.

apenas verificação de sintaxe: Se activo, o parâmetro -fsyntax-only é definido. Isto significa que o compilador irá verificar o seu código apenas por correcção no que toca à sintaxe, mas não verifica mais nada para além disso.

Optimizar: Pode activar optimização para o seu processo de construção através desta opção, o que significa que é definido o parâmetro -O. Se inactivo, o parâmetro é definido para -O0, pelo que nenhuma optimização será utilizada. Se activar optimização seleccionando esta opção, pode também especificar o nível de optimização entre 1 e 3.

Para uma versão de distribuição da sua aplicação, active a optimização e defina o nível para 2.

#### Depuração

À direita da caixa de Alvo, pode ver a secção de Depuração. Isto significa que você pode definir o seu compilador para incluir informação para depuradores dentro do binário final, para que o programador possa seguir a execução da aplicação com o depurador em contexto directo com o código fonte.

Activar a defpuração assim define o parâmetro -g; o nível de depuração especifica a quantidade de informação a ser incluida no binário. Disponíveis estão os níveis 1 até 3 para escolher. Lembre-se que a execução do binário será mais lenta se definir quaisquer opções de depuração e que o tamanho do binário será tanto maior quanto o nível de depuração.

Gerar informação extra para o gprof: define o parâmetro -pg, resultando em que o compilador irá incluir informação para o programa gprof que apresenta gráficos de chamadas das funções do seu programa.

Guardar ficheiros temporários intermédios: define o parâmetro -save-temps. Isto irá resultar no armazenamento dos normais ficheiros temporários produzidos pelo preprocessador e o assemblador. A compilação de um ficheiro de código irá assim produzir três ficheiros finais: um ficheiro *.o que é o resultado final do compilador, um ficheiro *.i produzido pelo preprocessador e um ficheiro *.s que é o resultado final do assemblador.

Para a distribuição do seu projecto, desactive a depuração.

#### Opções Adicionais

O campo de entrada de texto em baixo destina-se a que introduza manualmente quaisquer parâmetros para o compilador definindo as variáveis de ambiente CXXFLAGS nos makefiles, para que o make defina os parâmetros antes do processo de construção e os desligue depois. Para uma descrição completa de todos os parâmetros de compilador disponíveis deverá ler a documentação do seu compilador; para o gcc e egcs isto pode ser feito através de man gcc; man g++ irá mostrar-lhe informação sobre o script c++ que é utilizado para coordenar o compilador.

### Avisos de Compilador

De seguida iremos ver uma descrição sobre as opções de avisos do compilador que podem ser definidas na página 3 do diálogo de opções do projecto. As explicações foram tiradas da página do manual para o GCC, egcs versão 1.1.1. Os avisos em si são mensagens de diagnóstico que indicam construções que podem causar erros.

-Wall

  Opções `-W' standard combinadas.

-W

  Compilar com -W. Esta opção define opções não incluidas no -Wall que são muito específicas. Por favor leia a informação GCC para mais informações.

-Wtraditional

  Avisa sobre algumas construções que se comportam de forma diferente no C tradicional e ANSI.

-Wundef

  Avisa de um identificador não definido é avaliado numa directiva `&&num;;if'.

-Wshadow

  Avisa sempre que uma variável local encobre outra variável local.

-Wid-clash-LEN

  Avisa sempre que dois identificadores distintos coincidem nos primeiros len caracteres. Isto pode ajudá-lo a preparar um programa que irá compilar com alguns compiladores obsoletos e com lesões cerebrais.

-Wlarger-then-LEN

  Avisa sempre que um objecto maior que LEN bytes é definido.

-Wpointer-arith

  Avisa sobre tudo o que dependa do «size of» de um tipo de função ou de void. O GNU C atribui a estes tipos um tamanho de 1, por conveniencia nos cálculos com ponteiros void * e ponteiros para funções.

-Wbad-function-cast

  Avisa sempre que uma chamada a uma função é feita para um tipo não coincidente. Por exemplo, avisa se `int malloc()` é feito sobre `qualquer&&lowbar;;coisa *.`

-Wcast-equal

  Avisa sempre que um ponteiro for feito de forma a remover um qualificador de tipo do tipo do alvo. Por exemplo, avisa se um const char * é feito sobre um char * normal.

-Wcast-align

  Avisa sempre que um ponteiro é feito de tal modo que o alinhamento requerido do alvo é aumentado. Por exemplo, avisa se um char * é feito sobre um int * em máquinas em que inteiros apenas podem ser acedidos em fronteiras de dois ou quatro byte.

-Wwrite-strings

  Dá às constantes string o tipo const char&&lsqb;;tamanho] de forma a que copiar o endereço de uma para um ponteiro char * não-const dará um aviso. Estes avisos ajuda-lo-ão a encontrar na hora da compilação código que pode tentar escrever numa constante string, Mas apenas se você tiver sido muito cuidadoso na utilização de const em declarações e protótipos. Caso contrário, será apenas uma nuisance; é por esta razão que não fizemos o `-Wall' pedir estes avisos.

-Wconversion

  Avisa se um protótipo causar uma conversão de tipo que é diferente da que aconteceria ao mesmo argumento na ausência de um protótipo. Isto inclui conversões de virgula fixa para flutuante e vice versa, e conversões que alteram o tamanho ou signedness (poder ser negativo ou ser sempre valor absoluto) de um argumento de vírgula fixa excepto quando é o mesmo que a promoção por defeito.

-Wsign-compare

  Avisa quando uma comparação entre valores signed e unsigned pode produzir um resultado incorrecto quando o valor signed é convertido para unsigned.

-Waggregate-return

  Avisa se qualquer função retornar estruturas ou uniões definidas ou chamadas. (Em linguagens em que pode retornar uma matriz (array), isto também levanta um aviso.)

-Wmissing-prototypes

  Avisa se uma função global é definida sem a prévia declaração de protótipo. Este aviso é levantado mesmo se a definição em si disponibiliza um protótipo. O objectivo é detectar funções globais que não são declaradas em ficheiros header.

-Wmissing-declarations

  Avisa se uma função global é definida sem a declaração prévia. Faz isto mesmo se a definição em si disponibiliza um protótipo. Utilize esta opção para detectar funções globais que não são declaradas em ficheiros header.

-Wredundant-decls

  Avisa se algo for declarado mais de uma vez no mesmo âmbito, mesmo em casos em que a declaração múltipla é válida e não altera nada.

-Wnested-externs

  Avisa se uma declaração externa é encontrada dentro de uma função.

-Winline

  Avisa se uma função não pode ser inlined, e ou foi declarada como inline, ou então a opção -fin*line-functions foi dada.

-Wold-style-cast

  Avisa se uma chamada (cast) de tipo antigo (C-style) é utilizada dentro do programa

-Woverloaded-virtual

  (apenas C++.) Numa classe derivada, as definições de funções virtuais têm de coincidir com o tipo de signature de uma função virtual declarada na classe base. Utilize esta opção para pedir avisos quando uma classe derivada declara uma função que possa ser uma tentativa errada para definir uma função virtual: isto é, avisa quando uma função com o mesmo nome que uma função virtual na classe base, mas com um tipo de signature que não coincide com o de nenhuma função virtual da classe base.

-Wsynth

  Avisa quando o comportamento de síntese do g++ não coincide com o do cfront.

torna todos os avisos em erros

  (-Werror) Trata os avisos como erros; aborta a compilação após quaisquer avisos.

Para uma distribuição do seu projecto, é recomendado que active -Wall.

### Opções de Linkagem

As Opções de Linkagem para o seu actual projecto podem ser definidas na última página do diálogo de opções do projecto. Tem de activar as bibliotecas que a sua aplicação utiliza para as ligar ao seu binário com o linkador, por ex. a sua aplicação utiliza a classe KFileDialog. Como a classe KFileDialog é parte da biblioteca KFile, tem de activar kfile. Para classes ou funções que não são listadas nas caixas de escolha, utilize o campo "bibliotecas adicionais".

#### Parâmetros do Linkador

remove toda a tabela de símbolos e informação de realocação do executável:

  isto significa que toda a informação redundante será removida dos ficheiros de objecto e do binário, resultando em que a depuração não será possível. Durante o tempo em que a sua aplicação estiver em fase de desenvolvimento e não em distribuição final, deve deixar esta opção desactivada.

impedir a utilização de bibliotecas partilhadas:

  Esta opção desactiva a utilização de bibliotecas partilhadas em sistemas que suportem isto. Em sistemas que não utilizem bibliotecas partilhadas, esta opção não terá qualquer efeito.

parâmetros adicionais:

  Aqui, você poderá introduzir parâmetros adicionais para o linkador, definindo a variável de ambiente LDFLAGS através do make. As opções disponíveis podem ser tiradas da página de manual para ld ou a página de manual do seu compilador.

#### Bibliotecas

A secção de bibliotecas contém caixas de selecção para as bibliotecas mais utilizadas em conjunto com o desenvolvimento de aplicações Qt
/KDE
. Tem de activar as bibliotecas que a sua aplicação utiliza, caso contrário o linkador irá queixar-se sobre tabelas de símbolos não resolvidas.

X11

  A biblioteca X11. Recomendada para todos os programas X-Window.

Xext

  A biblioteca de extenções X11. Também a maioria dos programas X-Window depende da Xext.

qt

  A biblioteca Qt. Recomendada para aplicações Qt
  e KDE
  .

kdecore

  A biblioteca KDE Core; contém as classes para o esqueleto de aplicações KDE.

kdeui

  A biblioteca de interface de utilizador KDE; contém widgets específicos KDE.

khtmlw

  A biblioteca de Widget KHTML.

kfm

  A biblioteca KFM contendo classes para funções KFM.

kfile

  A biblioteca KFile. Contém diálogos de ficheiros etc.

kspell

  A biblioteca KSpell. Contém um interface para programas utilizarem o ISpell para verificação ortográfica.

kab

  A biblioteca KAdressBook. Necessária para acesso ao livro de endereços bem como para disponibilizar o widget de livro de endereços

additional libraries: Here you can enter additional libraries that your application needs, e.g. the KOM library. Set the libraries with the -l option; for the example -lkom.

#### Make

Como o make GNU suporta algumas opções úteis, o diálogo de Opções do Projecto contém uma página chamada "Opções Make", onde essas podem ser (des)activadas. As definições disponíveis são:

Imprimir informação de depuração

  imprime toda a informação sobre ficheiros do projecto e o que o make determina para os reconstruir.

Continuar após erros

  tenta continuar com a compilação após um erro ocorrer (por ex. um ficheiro não conseguiu ser compilado devido a um erro)

Imprimir a base de dados

  imprime a base de dados make para o processo actual que contém as modificações desde a última execução de construção.

Variáveis de ambiente

  dão as variáveis de ambiente actuais uma prioridade mais elevada que as variáveis a utilizar nos ficheiros Makefiles.

Não utiliza regras inclusas

  não utiliza as regras inclusas para o make.

Tocar ficheiros

  não corre o compilador sobre ficheiros modificados; em vez disso apenas os toca. Isto define-os como já processados pelo make.

Ignorar todos os erros

  Ignora todos os erros que possam ocorrer

Operação silenciosa

  não imprime qualquer informação sobre o processo de construção

Imprime o directório de trabalho

  imprime o directório actual durante o processo do make.

Número do trabalho

  define o número de processos paralelos para o make. Para um sistema de CPU único nós recomendamos definir este parâmetro para um ou dois.

Definir modificado

  define o ficheiro seleccionado como modificado. Escolha o ficheiro clicando sobre o botão de pasta à direita. Definir um ficheiro como modificado significa que esse ficheiro será processado pelo make e compilado se for um ficheiro de código fonte.

Opções adicionais

  define opções adicionais para o make; estas podem ser encontradas na sua página de manual local para o "Make GNU".

## O Navegador de Classes

### O Visualizador de Classes

O Visualizador de Classes do KDevelop é uma das ferramentas mais importantes e úteis que o ambiente de desenvolvimento disponibiliza ao programador para gerir o código do seu projecto. Quando um projecto é aberto, um analisador de sintaxe de classes lê todo o código do projecto procurando funções, classes etc., apresentando depois os resultados na árvore de vista VC. Este capítulo mostra-lhe como utilizar o Visualizador de Classes e a funcionalidade disponibilizada e como isso pode melhorar o seu trabalho.

As Classes e os seus métodos também são acessíveis através das caixas de selecção da barra de ferramentas do navegador. Aí, a caixa esquerda selecciona a classe; a direita permite-lhe escolher os métodos da classe seleccionada. Quando selecciona um método, o navegador de classes mostra automaticamente o ficheiro de implementação e coloca o cursor no método. Finalmente, o botão de assistente de classes à direita da caixa de selecção irá mostrar-lhe, quando premido, a declaração do método. O menu de escolha, disponibilizado pela seta para baixo no botão, permite funcionalidades adicionais também disponíveis no navegador de classes, tais como:

- Ver Declaração: navega para a declaração do método

- Ver Definição: navega para a definição do método

- Nova Classe: abre o diálogo de Nova Classe para construir uma classe nova

- Adicionar Método: adiciona um método à classe seleccionada

- Adicionar Atributo: adiciona um atributo à classe seleccionada

#### Objectos Disponíveis

Por objectos disponíveis, descrevemos um termo que significa que o código C++ pode ser visto como uma colecção de objectos- classes, seus membros, funções globais e afins. A árvore de classes apresenta estes objectos logicamente e ordena-os por caracter, pelo que são fáceis de localizar na árvore bem como pelo seu icon correspondente. Assim a árvore de classes contém uma pasta "Classes" e uma "Globais". Por isso a pasta "Classes" geralmente contém as classes do projecto; se o seu projecto contém subdirectórios para gerir os ficheiros de código, estes também são apresentados pelo seu nme de directório original e contêm todas as classes que estão guardades nos ficheiros localizados no subdirectório.

Mais ainda, quando expandindo uma classe, a árvore de classes apresenta o conteudo da classe separando os métodos e atributos. Como estes podem ter atributos dos tipos público, privado e protegido, estes são também apresentados por icons modificados. Pode ver que uma classe apresentada no Navegador de Classes contém todos os objectos que estão presentes na declaração da classe.

Agora, classes são algo muito comum quando a programar em C++ e irão conter a maior parte do código. Mas as aplicações também contêm objectos que têm a apresentação de "Globais" para o programa. Estes seriam estruturas, funções etc. Especialmente a função `main()` aparece em todas as aplicações e necessita de a modificar de uma ou outra forma por vezes. Para aceder a estes objectos, o Visualizador de Classes disponibiliza a pasta "Globais", contendo subpastas para os seguintes tipos de objectos:

- Estruturas

- Funções

- Variáveis

Como os icons que apresentam estes itens são semelhantes aos utilizados no visualizador de classes, o seu significado é fácil de adivinhar e recordar pelo programador.

Finalmente, pode ser afirmado que o visualizador de classes apresenta o seu projecto graficamente através dos seus objectos relativamente à sua aparência para o código. Na secção seguinte irá aprender como utilizar o visualizador de classes e as suas ferramentas em conjunto com o seu código.

#### Navegar as Declarações e Implementações dos Objectos

A maior capacidade do Visualizador de Classes é disponibilizar uma boa forma de aceder rápidamente ao seu código independentemente da sua localização dentro dos ficheiros. Assim, selecções através de um clique do rato irão resultar nas seguintes acções:

- Num nome de classe: Vai para a declaração da classe

- Num método da classe: Vai para a implementação do método

- Num atributo da classe: Vai para a declaração do atributo na declaração da classe

- Numa estrutura: Vai para a declaração da estrutura

- Numa função global: Vai para a implementação da função

Agora, Isto permite-lhe o acesso mais necessário ao código dos objectos. Aparentemente, pode ser necessário modificar o cabeçalho de um método, resultando na necessidade de alterar a sua declaração na classe bem como a implementação. O visualizador de classes suporta isto disponibilizando menus de contexto acessíveis pelo botão direito do rato sobre os itens. Num método ou função, isto significa que pode seleccionar para onde quer ir:

- Ir para a definição: Vai para a implementação- este é o defeito para um clique do botão esquerdo como descrito acima

- Ir para a declaração: Vai para a declaração do método ou função.

Através deste comportamento, o Navegador de Classes oferece-lhe acesso a todo o lado que necessita ir para programar a sua aplicação em C++.

As seguintes secções dão-lhe uma descrição de outras ferramentas que o Navegador de Classes disponibiliza- irá acha-las muito úteis quando trabalhar com grandes projectos pois elas potenciam o trabalho orientado por objectos em programas C++.

### As Ferramentas de Classes

As ferramentas de classes são diálogos que tornam ainda mais fácil ao programador obter mais informação sobre as classes do seu projecto. Como o visualizador de classes apresenta todos os objectos segundo a sua ocorrência no código, por vezes você pode querer mais informação sobre classes sem ter de olhar para o código. Assim, os diálogos das ferramentas de classes estão idealizadas para apresentar atributos específicos de classes.

O diálogo das ferramentas de classes é invocado pelo menu de contexto sobre uma classe no visualizador de classes. Seleccione "Ferramentas de Classes", e o diálogo surgirá. Para obter informação sobre uma classe, escolha a classe na lista de selecção no topo. Depois os botões na barra de ferramentas disponibilizam funções que lhe dão árvores específicas para a sua classe. Estas são:

Pais:

  Os pais da classe seleccionada, o que significa a classe donde herdou. Isto é útil para heranças múltiplas bem como para ver porque uma classe se comporta de uma ou de outra forma, por ex. para diálogos a sua classe Pai poderia ser QWidget ou QDialog.

Filhos:

  Apresenta as classes filhas que herdam da classe actual.

Clientes:

  Classes que fazem uso da classe seleccionada através de um atributo na sua declaração de classe.

Fornecedores:

  Os fornecedores que dão atributos para a classe seleccionada.

Atributos:

  Os atributos da classe pelo seu nome.

Métodos:

  Os Métodos da classe seleccionada.

Métodos Virtuais:

  Os métodos virtuais que uma classe disponibiliza.

Ainda mais, a selecção de um atributo publico, protegido, privado ou todos mostra Atributos, Métodos e Métodos Virtuais pelo seu valor de atributo.

### Gerir Classes

O Navegador de Classes também permite adicionar métodos e atributos directamente através de diálogos. Isto significa que você não tem de escrever a declaração de classe e o cabeçalho de implementação. Depois de adicionar o método, apenas tem de definir os parâmetros formais para o cabeçalho de implementação e, se o método requer um atributo, para a declaração.

Como adicionar um método a uma classe

1. seleccione a classe a que deseja adicionar o método

2. prima o botão direito do rato; surge o menu de contexto

3. seleccione "Adicionar função membro".

4. o diálogo "Adicionar função membro" surge.

5. inserir o tipo, declaração e documentação para o método

6. especificar o acesso e modificadores do método

7. premir OK para sair do diálogo

Para adicionar uma variável, esta é a mesma forma, apenas tendo de seleccionar "Adicionar variável membro" no menu de contexto.

A diferença entre as acções destes diálogos são que adicionar uma variável apenas irá adicionar uma variável à declaração da classe, e a adição de um método irá adicionar a declaração do método e o cabeçalho de implementação do mesmo ao código. Como o visualizador de classes se actualiza automaticamente por si só, você tem acesso ao novo método implementado, para que só tenha de escrever o código para o verdadeiro objectivo do método.

## O Editor de Diálogos

O Editor de Diálogos integrado do KDevelop permite uma construção fácil de widgets e diálogos através de meios gráficos para a sua aplicação utilizar. Vê a aparência do seu diálogo directamente tal como será apresentado ao utilizador. Utilizar o editor de diálogos é normalmente o primeiro passo que tomará após criar um projecto novo com o KAppWizard para dar origem á vista principal, os diálogos de interacção com utilizador e, após terminar o trabalho gráfico, a geração de código. Desta forma, o seu projecto conterá todas as partes que normalmente são consideradas "difíceis" e levariam imenso tempo a implementar. Depois, o "resto" do seu trabalho é implementar as funcionalidades no código gerado. Este capítulo debate-se com a utilização do editor de diálogos para criar widgets do projecto bem como o que fazer no caso de verificar que os seus widgets necessitam de correcções ou adições mais à frente no processo de desenvolvimento.

Pode ir para o Editor de Diálogos quer seleccionando "Editor de Diálogos" do menu de "Ferramentas" quer através do correspondente icon da barra de ferramentas. Para regressar ao Editor de Projecto, seleccione "KDevelop" a partir do menu "Ferramentas" do editor de diálogos ou através do icon na barra de ferramentas.

Que mais o interface do editor de diálogos lhe oferece? Principalmente, que a sua aparência é quase a mesma que o editor de projecto em termos da separação da janela principal bem como do menu e das barras de ferramentas. Isto permite-lhe acostumar-se muito mais rapidamente com o editor de diálogos e, como ele interage inteiramente com o gestor de projecto, permanecer no editor de diálogos se deseja controlar o seu processo de construção. Acções que requeiram que volte para o KDevelop farão isso automaticamente para si, tal como aceder ao navegador de documentação. Apenas seleccione os comandos de menu, e o KDevelop reagirá aos seus desejos.

Os capítulos seguintes dar-lhe-ão uma visão geral do interface do editor de diálogos, como criar inicialmente um diálogo novo e como definir as propriedades dos widgets filhos que o seu diálogo poderá conter.

### A Vista do Editor de Diálogos

#### A Vista Principal

A vista do editor de diálogos está logicamente separada em:

- O separador Widgets, que contém as pastas "Widgets", "Diálogos" e "Itens". Estes são descritos em Adicionar Widgets.

- O Editor de Widgets, representando a vista de edição para a criação do seu diálogo. Veja O Editor de Widgets

- A janela de Propriedades, contendo uma lista das propriedades e dos seus valores, dependendo do widget actualmente seleccionado no editor de widgets. Veja Definir Propriedades para informação sobre como especializar a aparência e comportamento dos widget's.

#### Diferenças para o KDevelop das Barras de Menus, Ferramentas e Estados

Em modo de Editor de Diálogos, o KDevelop modifica ligeiramente as barras de menu, ferramentas e estados para disponibilizar a funcionalidade que necessita para criar widgets. Estes são:

##### Barra de Menus

Menu "Ficheiro": substitui "Novo" por "Novo Diálogo". "Abrir" permite abrir um ficheiro de definição de diálogo.

Menu "Ver": substitui "Vista de Árvore" por "Vista de Widgets", (des/)activa os separadores de Vista de Widgets; adiciona "Vista de Propriedades" para (des/)activar a Vista de Propriedades e "Tamanho de Grelha" para lhe permitir especificar o tamanho da grelha em pixels para valores horizontais e verticais.

Menu "Construir": substitui "Compilar Ficheiro" por "Gerar Código". Isto permite-lhe realmente gerar o código para o seu diálogo.

##### Barra de Ferramentas

A barra de ferramentas contém um novo ícon para "Novo Diálogo" bem como um substituto para "Compilar Ficheiro" por "Gerar Código".

##### Barra de Estados

A barra de estados disponibiliza-lhe informação sobre o widget actualmente seleccionado, especialmente apresentando os valores de tamanho X e Y em coordenadas do sistema. Para ajuda de Barra de Estados, e-lhe disponibilizada a mesma funcionalidade que no modo de Edição de Projecto.

Enquanto a modificar o tamanho de um widget, a barra de estados mostrará os valores actuais para o comprimento e altura do widget seleccionado.

### Criar um Novo Diálogo

Após criar o seu esqueleto de projecto, é-lhe disponibilizada uma aplicação pronta a correr, de acordo com as suas preferências. Como o KDevelop disponibiliza os tipos de projecto de aplicação KDE e Qt, o editor de diálogos reconhece isto e oferece a construção dos widgets através dos widgets que são disponibilizados pelas bibliotecas utilizadas. Para poupar tempo, você já deverá ter um desenho em mente do que fará as acções desejadas. Para informações sobre desenho de widget's, veja O Manual de Programação do KDevelop.

Para criar um novo diálogo, seleccione "Novo" do menu "Ficheiro" ou seleccione "Novo" do menu de contexto na pasta dos diálogos. O menu "Novo Diálogo" surge onde tem de fornecer ao KDevelop informação específica do diálogo em relação à classe base e nomes de ficheiros de código e seu destino.

#### Classe de Diálogo

A classe de diálogo que pode seleccionar, é a classe que é herdada pelo seu novo widget, que é tecnicamente representado por uma classe também. Assim, tem as seguintes opções:

1. QWidget: a classe base para todos os widgets com interacção do utilizador disponibilizados pela Qt. Utilizado para vistas principais e widgets de nível superior.

2. QFrame: herda QWidget e é utilizado por numerosos widgets como classe base. Este é útil para widgets que já querem ter uma funcionalidade QFrame além dos métodos QWidget.

3. Custom: herda uma classe costumizada que tem de ser definida nas "Propriedades Costumizáveis". Pode ser uma classe já desenhada disponibilizada pelo seu projecto ou pelas bibliotecas.

4. QDialog: a classe base para diálogos que desejaria herdar para interacção do utilizador tal como definir propriedades ou modificar valores.

5. QTabDialog: herda QDialog e disponibiliza um diálogo com botões pré-definidos e um conjunto de pastas, que você irá disponibilizar através dos widgets que você criar.

Propriedades Costumizáveis

Para a herança de uma classe costumizável como seleccionado no campo de diálogo de classe, tem de especificar o nome da classe, que vai para "Classe Costumizável". O editor de diálogos utiliza isto para a geração do código; assim, você também tem de inserir o "Header Costumizável", onde o ficheiro header da classe costumizável tem de ser definido.

#### Ficheiros

Na secção "Ficheiros", você tem de inserir a informação específica dos widget's. Esta é o nome da classe (que deverá ser por ex. KColorSelectDlg para um diálogo que permite a selecção de dores de uma caneta), o header, ficheiros C++ e o Data. Quando inserir o Nome da Classe, os nomes de ficheiros são dados pelo editor de diálogos, mas você pode também modificar os nomes de ficheiros.

Agora, e sobre os ficheiros? Quando estiver preparado com a construção de widgets visualmente, terá de gerar os ficheiros que contêm a implementação do seu widget. Como isto será uma classe, o diálogo irá existir através do ficheiro header contendo a declaração de classe, um ficheiro C++ contendo a implementação dos métodos para os métodos e espaços do widget. O ficheiro Data é o ficheiro que conterá a função que é chamada pelo construtor do widget,no método initDialog(). O ficheiro em sí não deverá ser modificado pois contém o código gerado pelo editor de diálogos para criar o widget em ecrã. Se alguma vez tiver de modificar valores, deverá fazer isto através do construtor ou ter a certeza de que não irá alterar o diálogo durante o processo de desenvolvimento, pois o ficheiro Data será substituido de cada vez que o código for gerado para o seu widget. Os ficheiros header e C++ contêm secções, onde o editor de diálogos escreve; estes estão marcados por comentários. Após a geração dos ficheiros, pode modificar quaisquer valores e definições fora das secções; de outra forma as alterações perder-se-ão na próxima geração de código.

#### Localização

Para gerar o código do widget, o editor de diálogos necessita de saber a localização onde este irá. Os valores de defeito para o directório de destino é o subdirectório que contém o código fonte do projecto actual.

Após premir "OK", os seus valores por defeito serão gerados e um construtor de Widget vazio é aberto. Então encontra-se preparado para ir criar o seu próprio widget. Lembre-se que o editor de diálogos actualmente apenas suporta widgets estáticos sem gestão de geometria. Se estiver para utilizar gestão de geometria para os seus widgets, deverá acostumar-se com as classes que a Qt disponibiliza para isto, criando uma nova classe com o gerador de classes e escrevendo o resto do seu widget à mão. Para mais informações, veja O Manual de Programação do KDevelop.

### Adicionar Widgets

Após especificar a classe e nome de ficheiros dos diálogos ou widgets, está preparado para começar a criar o widget e preenchê-lo com conteudo. Adicionar widgets de nível-baixo ao seu diálogo é uma tarefa muito simples. Basta seleccionar o widget que deseja a partir da pasta de "Wigets" à esquerda através de um clique sobre o correspondente icon de widget. O widget será então colocado no canto superior esquerdo do widget principal actualmente aberto. Um widget adicionado então obtém o temanho de defeito de 100x30 pixels na vista de edição. Para mover um widget, carregue sobre ele para activar a moldura de desenho, que é apresentada em cinzento escuro com pontos quentes nos cantos e no centro dos lados superior, inferior, esquerdo e direito do widget. Um cursor em cruz indica que o widget pode ser movido. Para o mover, pressione o botão esquerdo do rato e mantenha-o premido. Depois mova o widget com o rato até ao local onde deseja que ele passe a estar.

Para redimensionar um widget, mova o cursor do rato sobre um dos pontos quentes do item já activo. O cursor do rato muda então para uma seta dupla, indicando as direcções, em que o redimensionamento pode ser feito. Prima o botão esquerdo do rato e mantenha-o premido. O item widget irá ter o seu tamanho modificado quando o rato for movido para a direcção indicada pelo cursor.

Ainda mais, o editor de widget contém imensos menus de contexto para o ajudarem a coordenar o seu trabalho. Estes estão disponíveis sobre todos os itens na pasta widgets e dão-lhe uma pequena janela de ajuda que mostra o nome da classe do widget seleccionado com uma breve descrição. Sobre um widget seleccionado, o menu de contexto mostra o nome da classe do item seleccionado e disponibiliza:

- Subir

- Baixar

- Subir ao Topo

- Baixar ao Fundo

- Cortar

- Apagar

- Copiar

- Colar

- Ajuda

Após definir o tamanho e posição, pode editar as preferências para o item seleccionado na janela de Preferências.

#### A Pasta de Widgets

A pasta de widgets representa os widgets disponíveis que pode colocar no diálogo. Se deseja informação sobre um certo widget, pressione o botão direito do rato sobre o icon do widget e seleccione "Ajuda-Rápida" do menu de contexto. Lembre-se que o editor de diálogos determina automaticamente, se o seu projecto é do tipo apenas Qt ou KDE. Isto impede-o de utilizar widgets KDE em aplicações Qt.

Após ter seleccionado um item widget, ele é colocado com os valores e tamanhos de defeito sobre a janela de edição e marcado como seleccionado com a moldura e cantos escuros. Para redimensionar um widget, mova o seu rato sobre um dos pontos escuros e o seu cursor será modificado para apresentar que direcções de redimensionamento são possíveis. Depois prime-se o botão do rato e movimenta-se enquanto se mantém o botão premido. Quando terminar de redimensionar o widget, liberte o rato. Enquanto a redimensionar, a barra de estados apresenta a posição corrente em termos de valores X e Y e o tamanho actual em valore W(Comprimento) e H(Altura).

#### A Pasta de Diálogos

A pasta de diálogos é destinada a permitir-lhe abrir os diálogos do seu projecto através de um clique do rato. Como a estrutura de diálogos é gravada num ficheiro *.kdevdlg dentro do directório que contém os ficheiros gerados, apenas esses ficheiros de definição de diálogos são mostrados. Lembre-se também que você não apaga estes ficheiros de definição.

Ao seleccionar um diálogo, será mostrado no estado em que foi gravado no último passo de edição na vista de Edição de Widget.

#### A Pasta de Itens

A pasta de itens permite-lhe ter uma visão geral sobre os itens do widget actual dispostos hierarquicamente. Isto significa que, como o seu fundo representa o pai de todos os widgets dentro do diálogo, é mostrado no topo da árvore. Os filhos do diálogo principal são listados no nível de árvore seguinte.

Ao seleccionar um item, ele fica marcado na vista de edição, bem como as suas propriedades são apresentadas na janela de propriedades. Utilizar a vista de itens é às vezes importante se o comportamento do seu widget depende da relação pai-filho. Para mais informações veja O Manual de Programação do KDevelop.

### O Editor de Widget

O Editor de Widget é a vista principal que é colocada no meio e onde você constroi o seu widget. Após adicionar itens, eles podem ser seleccionados e redimensionados, bem como movidos para o local que necessitar. Sobre todos os itens, menus de contexto disponibilizam um acesso rápido às funções tais como cortar, copiar e inserir.

### Definir Propriedades

A janela de propriedades à direita é o local onde define o comportamento por defeito do widget e dos seus itens. Apresenta os valores pré-definidos para cada item seleccionado no momentop; modificar valores resultará em alterações directas na vista do Editor de Widget, por ex. renomear labels (etiquetas) ou botões.

Para separar alguns valores de propriedades pelos seus efeitos, a janela de propriedades contém quatro pastas; seleccionando uma pasta mostrará todos os valores paea o grupo de propriedades. Todos os valores possíveis estão descritos abaixo. Lembre-se que as propriedades dependem do widget, por ex. uma etiqueta (label) e botão (button) terão uma propriedade para o seu nome em ecrã, enquanto que lineedits (caixa de edição multi-linha) terá propriedades para métodos tais como setText().

Para uma lista completa dos valores disponíveis por item, deverá ver a referência de classes do widget que explica os métodos utilizados e todos os valores possíveis. Note que a maior parte dos valores estão implementados no QWidget e são utilizados para todos os widgets que herdam QWidget. Lembre-se também que o código final não contém quaisquer chamadas a métodos que sejam inalteráveis pelo utilizador e assim utiliza os valores por defeito dados no cosntrutor de widget's.

Para uma lista completa das propriedades suportadas que podem ser definidas na janela de propriedades para cada ietm widget, veja O Manual de Programação do KDevelop.

### Gerar Ficheiros

Após criar o widget, tem de gerar o código fonte para o tornar disponível no seu projecto. Isto pode ser feito ou com o "Gerar Código" do menu "Construir" ou pelo correspondente icon na barra de ferramentas do editor de diálogos. Os seus Makefiles serão actualizados automaticamente para incluir o novo widget no processo de compilação; Assim, após chamar "Gerar Código", pode construir o seu projecto de novo dentro do editor de diálogos. A janela de output surge debaixo da janela de Edição de Widget tal como no modo de Edição de Projecto.

Agora que o seu projecto contém um novo widget, o seu trabalho como programador é implementar funcionalidades para os espaços utilizados e eventualmente adicionar outros métodos de que possa necessitar.

Para mais informações sobre a implementação de funções de widgets, veja O Manual de Programação do KDevelop.

## Configuração Geral

Este capítulo descreve como pode definir as suas preferências pessoais sobre a forma como o KDevelop trabalha. Todas as configurações descritas em baixo podem ser encontradas na entrada correspondente do menu de Opções.

### Configurar o Menu "Ferramentas"

Como o KDevelop suporta a utilização de programas de terceiros dentro do seu interface, é-lhe possível configurar quaisquer programas que lhe suprimam necessidades no sentido do desenvolvimento de aplicações. Isto pode ser feito adicionando programas aos já definidos no menu "Ferramentas". Para modificar o menu ferramentas, seleccione "Ferramentas" a partir do menu "Opções". Este diálogo permite especificar o nome para o menu, o programa e comandos de linha adicionais que deseje passar no momento da execução. Para remover um programa do menu, seleccione o nome de entrada e escolhe "Apagar". Para adicionar um programa, especifique a entrada de menu, em que & é utilizado como um acelarador de menu; pode comparar as entradas já configuradas com a lista de entradas. Seleccione o binário e passe as opções de linha de comandos. Depois prima "Adicionar" e a entrada é adicionada à lista. Após sair do diálogo de configuração, o menu de ferramentas actualiza-se automaticamente, pelo que a nova configuração está já disponível sem a necessidade de reiniciar o KDevelop.

### Opções de Vista de Ficheiros

O Visualizador Lógico de Ficheiros pode ser configurado completamente por menus de contexto. Como o seu objectivo é separar ficheiros logicamente para manter uma visão geral melhor de projectos complexos, uma das configurações mais utilizada é criar grupos de ficheiros. Estes podem ser definidos abrindo o menu de contexto com um clique do botão direito do rato sobre o icon do projecto apresentado na raíz da árvore. O menu disponibiliza:

- Novo Ficheiro: Abre o diálogo de Novo Ficheiro. Equivale ao comando da barra de menu "Ficheiro"-"Novo"

- Nova Classe: Abre o Gerador de Classes para criar uma nova classe. Equivale ao comando da barra de menu "Projecto"-"Nova Classe"

- Novo Grupo: Abre um diálogo para criar um novo grupo. Aí, defina o nome do grupo e o filtro de ficheiro para os ficheiros do projecto que serão apresentados neste grupo.

- Mostrar Caminho Relativo: apresenta os ficheiros com os seus caminhos a partir do directório do projecto se definido; caso contrário apenas o nome do ficheiro é mostrado.

Sobre uma pastas de grupo, o respectivo menu de contexto disponibiliza:

- Novo Grupo: Abre o diálogo de Novo Grupo tal como no menu de contexto descrito acima.

- Remover grupo: remove o grupo do VFL.

- Propriedades: Abre as propriedades do grupo. Aí, pode editar os filtros de ficheiros através de uma lista com caractéres de selecção múltipla (wildcards) separados por vírgulas.

### Configuração do KDevelop

Comando Make: O diálogo de Opções Gerais permite-lhe configurar definições gerais do KDevelop. Primeiro, deve definir o comando make disponível no seu sistema. Se o programa seleccionado não existir, o KDevelop avisa-lo-á da próxima vez que invocar o comando make.

Gravação Automática:

Se a Gravação Automática estiver seleccionada, o KDevelop irá gravar todos os ficheiros modificados periodicamente. O intrevalo de tempo da gravação automática pode ser definido para 3, 5, 15 ou 30 minutos.

Auto-Alternância:

Se a Auto-Alternância estiver activa, a janela do KDevelop irá alternar entre estados consoante o contexto de utilização, por ex. se for para a documentação no menu de Ajuda, o navegador de Documentação irá ser aberto, junto com a árvore de documentação e a janela de output será desligada.

Iniciar:

Para iniciar o KDevelop, tem a opção de activar/desactivar o logotipo de arranque a ser apresentado enquanto o KDevelop lê. Além disso, se não gosta que o último projecto seja aberto aquando do carregamento do programa, pode desligar o comportamento por defeito.

### Alterar Atalhos de Teclado

O diálogo de Configuração de Teclas permite-lhe configurar os atalhos de teclas do KDevelop. Note que as teclas globais podem ser configuradas no Controlo Central do KDE, tais como abrir ficheiro e imprimir. Uma função de teclado pode ser configurada escolhendo a entrada de menu. Depois a configuração pode ser modificada activando valores tais como as teclas Alt / Ctrl etc.

### Documentação

#### Directórios

Para configurar o navegador de documentação para funcionar correctamente, o KDevelop necessita de alguma informação sobre onde a documentação HTML está localizada no sistema. Assim, o diálogo de propriedades do Caminho da Documentação necessita do caminho para a documentação electrónica da Qt em HTML bem como o caminho para a documentação da biblioteca KDE.

Normalmente, a documentação Qt é colocada no mesmo directório que a Qt é instalada; por ex. se a Qt reside em /usr/local/qt, o caminho que tem de introduzir é /usr/local/qt/html. Para a documentação KDE, tem de definir o directório para a raiz da documentação, assumindo que toda a documentação das bibliotecas do KDE residem no mesmo directório. Ambos os caminhos podem ser seleccionados premindo os botões respectivos, que mostram uma selecção de caminho. Se o seu sistema não contém a documentação para as bibliotecas KDE, você deverá primeiro ir para o diálogo de configuração seguinte, Actualizar Documentação KDE. Isto irá criar a documentação para um caminho da sua escolha, também definindo o caminho da documentação da biblioteca KDE automaticamente.

#### Opções

##### Actualizar Documentação KDE

Para aqueles utilizadores que não dispõem de documentação recente das bibliotecas de KDE, especialmente a documentação para os ficheiros instalados no sistema, o diálogo de Actualização de Documentação KDE cria uma documentação nova ou actualiza a existente. Esta função requer que o seu sistem tenha o kdoc e o qt2kdoc instalados, incluídos no pacote kdesdk. Primeiro, tem de definir o caminho para o código fonte recente das kdelibs, que não é o caminho include para o KDE ! Basta introsuzir o caminho para o código, como: /home/rnolden/kdelibs-1.1/.

Depois, pode seleccionar três modos de instalação diferentes, como sendo:

- Apagar Documentação antiga e instalar para o Caminho de Documentação recente: isto assume que você já tem a documentação instalada e está colocada no caminho que foi inserido no diálogo de Caminho da Documentação. Isto irá apagar toda a documentação e instalar a documentação recentemente gerada no caminho recente.

- Apagar Documentação antiga e instalar para o novo Caminho de Documentação: isto irá resultar em apagar a documentação antiga tal como acima, mas dá-lhe a escolha de definir um novo local para a documentação.

- Deixar a Documentação intocada e instalar para o novo caminho de Documentação: Isto é recomendado para uma nova geração da documentação das kdelibs para utilizadores que antes não tinham nenhuma e para aqueles que querem guardar a última documentação para uma versão mais antiga das kdelibs.

O "novo caminho da Documentação das Bibliotecas KDE" tem de ser difinido para opções 2 e 3 do modo de instalação. Isto é também recomendado para utilizadores que geram nova documentação do zero.

Após premir o botão OK, o KDevelop irá criar um subdirectório "kdoc-reference" no caminho da documentação contendo os ficheiros de referência do Kdoc. Primeiro, a documentação das classes da biblioteca qt serão indexadas para ligar a documentação da Qt com a documentação a ser gerada para as kdelibs. Assim é importanteque tenha definido o caminho da documentação Qt primeiro para assegurar que pode ser encontrada pelo qt2kdoc. Finalmente, as bibliotecas KDE serão indexadas e a documentação será construida com referências cruzadas para dar à navegação a melhor funcionalidade.

##### Criar Base de Dados de Busca

O diálogo Criar Base de Dados de Busca, acedido através do botão criar, permite ao programador criar uma base de dados para procurar uma palavra chave interactivamente. Para criar e utilizar a função de procura na documentação, tem de ter o programa glimpse 4.1 instalado. Pre-definidas estão as opções para indexar a documentação das bibliotecas KDE bem como a documentação Qt, assumindo que o caminho para os ficheiros de documentação estavam definidos no diálogo "Caminho da Documentação" do menu de opções. Adicionamente, o índice pode incluir directórios que o utilizador pode definir por si através do campo "directórios adicionais para o index". Após definir um caminho para um directório adicional, o botão "Adicionar" tem de ser premido para definir o caminho. Um caminho definido pode ser removido do index seleccionando o caminho no campo de caminho e premindo "Remover". Ainda mais, ao utilizador são oferecidos três modos diferentes para o tamanho do index: minúsculo, pequeno e médio. Quanto maior o tamanho do index, mais os ficheiros de index irão crescer. Por outro lado, uma busca numa base de dados maior será mais rápida e melhor sucedida, pelo que sugerimos a escolha de um tamanho "médio". Para a utilização da função de busca, veja a secção Utilizar o Navegador de Documentação.

## Perguntas e Respostas

Esta secção debruça-se sobre questões colocadas pelos utilizadores e que foram respondidas pela Equipa do KDevelop ou pelos seus apoiantes na lista de correio electrónico do KDevelop durante experiências com as versões actuais do KDevelop bem como reportes de erros em geral.

### Reporte de Erros

Outro melhoramento do KDevelop é o sistema integrado de reporte de erros através de correio electrónico. Se encontrar um erro de código (bug), tem a opção de enviar à equipa de desenvolvimento do KDevelop um reporte quer seja através do seu cliente de e-mail quer através do diálogo de reporte de erros. Todos os reportes de erros são compilados na página de internet do KDevelop e podem ser revistos em www.kdevelop.org/bugarchive/maillist.html. Pode também receber todos os reportes de erros através da inscrição na lista de correio electrónico de reporte de erros enviando um e-mail vazio para kdevelop-bug-report-request@fara3.cs.uni-potsdam.de com "subscribe seu&&lowbar;;endereço&&lowbar;;email" como conteudo do corpo da mensagem.

Para enviar reporte de erros, por favor utilize este endereço de e-mail através do seu programa de e-mail. Se desejar utilizar o KDevelop para reporte de erros directo, escolha "Reporte de Erros" do menu "Ajuda". É-lhe apresentado um diálogo de reporte que lhe permite inserir toda a informação necessária sobre o erro que você descobriu. Após premir "OK", o conteudo do diálogo é enviado para a lista de e-mail automaticamente.

### Onde Obter Informação

P: Tenho uma pergunta que não está colocada no ficheiro de Perguntas Mais Frequentes, nem nos manuais do KDevelop. Onde me devo dirigir?

R: Em qualquer caso envie todos os pedidos que respeitem ao KDevelop subscrevendo a lista de e-mail do KDevelop em kdevelop@fara3.cs.uni-potsdam.de. Envie um e-mail com o cabeça-lho vazio e "subscribe" como conteudo da mensagem; pode então participar nas discussões. Todas as questões devem ser lá colocadas e serão também respondidas. Se se ficar por aí, obterá a maior parte da ajuda dos programadores e todos os utilizadores que tenham o mesmo problema, bem como ajudará a manter a lista de Perguntas Mais Frequentes actualizada.

A página de Internet do KDevelop em http://www.kdevelop.org também contém um arquivo da lista de e-mail que lhe permite ler os e-mails já enviados pelos inscritos, pelo que deverá procurar lá primeiro pois muitos dos problemas podem já ter sido discutidos pelos programadores ou outros utilizadores.

### Problemas de Sistema e Bibliotecas

P: Erro "Wrong JPEG library version: library is 61, caller expects 62"

R: Existem duas formas.

1. Quando as kdelibs são instaladas elas instalam ficheiros header para as bibliotecas jpeg, que são da versão 61, no entanto, a maior parte das distribuições (Redhat) utiliza as bibliotecas da versão 62. Para corrigir basta remover jpeglib.h de /opt/kde/include (ou /usr/local/kde/include). O ficheiro da include para a versão 62 deverá ser então utilizado. No entanto olhando para a mensagem de erro acima poderá existir outra forma de contornar, de qualquer forma assegure-se de que apenas tem uma versão do ficheiro header, a biblioteca e que são consistentes.

   É útil utilizar o comando locate para verificar que possui a versão correcta das bibliotecas e ficheiro header por ex. updatedb locate libjpeg locate jpeglib

2. Tem de recompilar o kdesupport se a biblioteca jpeg (./configure --with-libjpeg --with-libgif).

P:

    make[2]: Entering directory `/usr/local/src/kdevelop-0.3/po'
    cd .. && automake --gnu --include-deps po/Makefile
    aclocal.m4: 2709: `AM_PROG_INSTALL' is obsolete; use `AC_PROG_INSTALL'
    make[2]: *** [Makefile.in] Error 1

R: Forma de contornar para utilizadores do automake-1.4/automake-2.13: Basta correr o "aclocal" manualmente, depois já compilará.

P: O que preciso de fazer, se o configure disse que eu necessitava da giflib23.

R: Tente uma snap mais recente do kdesupport, ou talvez tenha outra giflib instalada?

P: Como posso converter um projecto do KDevelop 0.2 para o 0.3?

R: Por favor altere o AC&&lowbar;;OUTPUT no configure.in para uma versão de uma linha

por exemplo: versão antiga:

    AC_OUTPUT(Makefile \
    kdevelop/kwrite/Makefile \
    kdevelop/templates/Makefile
    )

nova versão:

    AC_OUTPUT(Makefile kdevelop/kwrite/Makefile kdevelop/templates/Makefile)

P: Obtenho os seguintes erros de linkagem quando a utilizar o SuSE Linux com o KDE 1.1, que tenho de fazer para conseguir linkar o KDevelop?

    /usr/lib/libqt.so:
    warning: multiple common of `QArrayT&<;char&>; type_info node'
    ckdevelop.o: warning: previous common is here
    ckdevelop.o: In function `CKDevelop::slotFileSaveAll(void)':
    ckdevelop.o(.text+0x784): undefined reference to `kdebug(unsigned short,
    unsigned short, char const *,...)'
    ckdevelop.o(.text+0x839): undefined reference to `kdebug(unsigned short,
    unsigned short, char const *,...)'
    ckdevelop.o(.text+0x89d): undefined reference to `kdebug(unsigned short,
    unsigned short, char const *,...)'
    ckdevelop.o: In function `CKDevelop::slotFileSaveAs(void)':
    ckdevelop.o(.text+0xd28): undefined reference to `kdebug(unsigned short,
    unsigned short, char const *,...)'
    ckdevelop.o: In function `CKDevelop::slotFileClose(void)':
    ckdevelop.o(.text+0x1216): undefined reference to `kdebug(unsigned short,
    unsigned short, char const *,...)'
    ckdevelop.o(.text+0x1263): more undefined references to `kdebug(unsigned
    short, unsigned short, char const     *,...)' follow  collect2: ld returned 1
    exit status  make[2]: ***
    [kdevelop] Error 1  make[2]: Leaving directory
    '/home/LinuXDaten/Programme_Updates_Packete/KDE_Updates/Kdevelop_actual_snapshot/kdevelop-0.3/kdevelop'
    make[1]: *** [all-recursive] Error 1  make[1]: Leaving directory
    `/home/LinuXDaten/Programme_Updates_Packete/KDE_Updates/Kdevelop_actual_snapshot/kdevelop-0.3'
    make: *** [all-recursive-am] Error 2

R: Se possuir os rpm's da SuSE do KDE-1.1, tem de recompilar as kdelibs sem a correcção inserida pela SuSE e reinstala-las ou obter um rpm actualizado das kdelibs de ftp://ftp.suse.com

### Questões de Utilização

P: Vejo que o KDevelop não permite a utilização da tecla delete (ou apagar com o backspace quando o texto está marcado).

R: vá a "Opções"->"Editor" e certifique-se que "Apagar na Introdução" está activado, então o backspace e o delete funcionarão.

P: Se adiciono ficheiros ao meu projecto, eles serão automaticamente incluidos e compilados?

R: Sim, eles são logo incluidos nos Makefile.am's se fizer um "Reconstruir Tudo" (./configure actualiza os Makefiles), os seus ficheiros novos adicionados serão também incluidos.

P: Se eu apagar um ficheiro, recebo umas mensagens estranhas do linkador. O que está errado com o meu projecto?

R: Se o ficheiro removido é um ficheiro header, que é automaticamente processado pelo automoc (executando o Qt-Meta-Object-Compiler automaticamente em todos os headers), o seu header removido ainda está presente como um ficheiro *.moc.cpp gerado e compilado. Remova o correspondente ficheiro *.moc.cpp e reconstrua o projecto.

## Autores

Programadores Principais:

Sandy Meier <smeier@rz.uni-potsdam.de> (manutenção, coordenação do desenvolvimento e disponibilização da página de internet) Desenvolvimento Principal de: estrutura geral, aspecto e funcionalidade do ambiente, gestão de projectos.

Stefan Heidrich <sheidric@rz.uni-potsdam.de> Desenvolvimento Principal de: KAppWizard, funcionalidades de impressão

Ralf Nolden <Ralf.Nolden@post.rwth-aachen.de> Desenvolvimento Principal de: KDevelop<->interface do Editor de Diálogo, funcionalidades de configuração, ajuda electrónica e manuais

Jonas Nordin <jonas.nordin@cenacle.se> Desenvolvimento Principal de: Visualizador de Classes e analisador de sintaxe (parser)

Pascal Krahmer <pascal@beast.de> Desenvolvimento Principal de: Editor de Diálogos

Bernd Gehrmann <bernd@physik.hu-berlin.de> Desenvolvimento Principal de: Diálogo do Comando Grep, Integração CVS

Stefan Bartel <bartel@rz.uni-potsdam.de> Desenvolvimento Principal de: Visualizador de Ficheiros Reais

Coordenação da Tradução:

Martin Piskernig <martin.piskernig@stuwo.at>

Tradutores da Aplicação e Documentação:

Steen Rabol <rabol@get2net.dk> -Dinamarquês

Martin Piskernig <martin.piskernig@stuwo.at> -Alemão

Salvador Gimeno <salgiza@eui.upv.es> -Espanhol

Sami Kuhmonen <sami@iqs.fi> -Finlandês

Herve Lefebvre <hlefebvre@easynet.fr> -Francês

Pahan Szabolcs <szabczy@bigfoot.com> -Hungaro

Duarte Loreto <dnloreto@esoterica.pt> -Portugues

Ilmar Habibulin <ilmar@ints.ru> -Russo

Jacek Wojdel <wojdel@kbs.twi.tudelft.nl> -Polaco

Jan Prokop <jprokop@ibl.sk> -Eslovaco

Patrik Adolfsson <patrik.adolfsson@iname.com> -Sueco

Logotipo Inicial:

Jacek Wojdel <wojdel@kbs.twi.tudelft.nl>

Adições, alterações e correcções de erros:

Jost Schenk <Jost@Schenk.de>

David Barth <dbarth@videotron.ca>

Matthias Hipp <Matthias.Hipp@gmx.de>

Martin Piskernig <martin.piskernig@stuwo.at>

Matthias Hoelzer-Kluepfel <mh@caldera.de>

Steen Rabol <rabol@get2net.dk>

Matt Koss <koss@napri.sk>

Jochen Wilhelmy <digisnap@cs.tu-berlin.de>

Bernd Gehrmann <bernd@physik.hu-berlin.de>

Walter Tasin <tasin@e-technik.fh-muenchen.de>

Torsten Uhlmann <TUhlmann@debis.com>

O KDevelop contém código fonte das seguintes aplicações:

KWrite 0.98 &©; por Jochen Wilhelmy <digisnap@cs.tu-berlin.de>

KDE Help &©; por Martin R. Jones <mjones@kde.org>

GrapeFruit &©; 1999 por Bernd Gehrmann <bernd@physik.hu-berlin.de>

KSwallow &©; por Matthias Hoelzer <hoelzer@physik.uni-wuerzburg.de>

kcmlocale &©; 1998 por Matthias Hoelzer <hoelzer@physik.uni-wuerzburg.de>

## Agradecimentos

Gostariamos de exprimir agradecimentos especiais aos membros das nossas famílias e amigos que nos deram apoio de diversas formas o que nos permitiu construir e melhorar o KDevelop.

Também, nós agradecemos ao Jochen Wilhelmy por oferecer o seu programa kwrite e a sua ajuda para o integrar no KDevelop.

Agradecimentos também à equipa do KDE e ao Stephan Kulow, que nos deu a possibilidade de trabalhar no KDevelop através de CVS

Nós esperamos que o nosso trabalho gratuíto neste produto leve a uma melhor aceitação do Free Software (Aplicações Gratítas) e ao seu desenvolvimento. Sem a ajuda e idealismo de muitos, o Ambiente Gráfico de Desenvolvimento KDevelop nunca teria sido realizado num período te tempo tão reduzido e nós estamos orgulhosos de que tantos utilizadores tenham já relatado boas experiências e tenham levado o KDevelop ao seu destino: ajudar programadores de aplicações livres a construir um mundo melhor em que os utilizadores têm liberdade de escolha.

## Copyright

    KDevelop Copyright 1998,1999 A Equipa do KDevelop.

    Este programa é software livre; pode redistribui-lo e/ou modifica-lo
    dentro dos termos da Licença Geral Pública GNU (GNU General Public License) tal como publicado
    pela Free Software Foundation (Fundação das Aplicações Livres); quer seja a versão 2 da licença,
    ou (pode optar) qualquer versão posterior.

    Este programa é distribuido com a esperança de que seja útil,
    mas SEM QUALQUER GARANTIA; sem mesmo a garantia implícita de
    COMERCIALIZAÇÃO ou PREPARAÇÃO PARA UM FIM ESPECÍFICO. Veja a
    Licença Geral Pública GNU para mais detalhes.

    Deverá ter recebido uma cópia da Licença Geral Pública GNU
    junto com esta aplicação; se não recebeu, escreva para a
    Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.