# Instalar o &kdevelop;

Você irá encontrar aqui todos os passos necessários para compilar e instalar o IDE do &kdevelop;:

- O Como obter o &kdevelop; concentra-se principalmente em como obter o código mais recente do CVS.

- Os requisitos do &kdevelop; listam os programas e bibliotecas que irá necessitar de ter instalados para compilar com sucesso o IDE.

- A compilação e instalação do &kdevelop; irá conduzi-lo por todos os passos de compilação e instalação da aplicação.

- O Como obter uma documentação da API do &kdevelop; diz-lhe o que é uma API e como você poderá usar uma dessas ferramentas para navegar pelo código do &kdevelop;.

## Como obter o &kdevelop;

O &kdevelop; está disponível de forma binária para várias distribuições do &Linux; como a SuSE, a RedHat entre outras. Estes binários estão inseridos num pacote, em grande parte em RPMs, para uma instalação mais simples. Para instalar, siga as instruções normais que são dadas para a sua distribuição.

Você também poderá obter o código-fonte do &kdevelop;, compilá-lo e instalá-lo você mesmo. Este código poderá ser obtido na página pessoal do projecto em http://www.kdevelop.org ou através do 'site' FTP do &kde;.

### Obter Versões Diárias do &kdevelop; a partir do &CVS;

Se você quiser estar a acompanhar os desenvolvimentos actuais, estão disponíveis as imagens do repositório anónimo do &CVS;. O nome do módulo é kdevelop em `:pserver:anonymous@anoncvs.kde.org:/home/kde`.

#### 'Checkout' Inicial do &CVS;

Para obter uma versão inicial do &kdevelop;, você precisa de obtê-la a partir do &CVS; anónimo. Para efectuar esta operação, com o nome de checkout, basta seguir estes passos.

Iremos assumir que você irá querer pôr a sua cópia do &kdevelop; na pasta `codigo_kde3` da sua directoria pessoal (a `~`) .

- # Criar a directoria de destino, se necessário:
- `~>` `mkdir codigo_kde3`
- `~>` `cd codigo_kde3`
- `~/codigo_kde3>` `cvs -z3 -d :pserver:anonymous@anoncvs.kde.org:/home/kde co kdevelop`
- `~/codigo_kde3>` `cd kdevelop`

Logo que tenha conseguido obter a sua versão do &kdevelop;, você poderá estar a par das alterações com o procedimento de actualização mostrado na secção a seguir.

Mantenha a carga no servidor baixa. Por favor não faça a transferência completa ('checkout'), sempre que queira ter o seu &kdevelop; actualizado! Utilize para isto uma actualização de CVS.

Agora, você poderá compilar a sua versão do &kdevelop;, tal como é mostrada no capítulo de Compilação e Instalação do &kdevelop;.

#### Manter a Sua Cópia do &CVS; Actual

Depois de você ter obtido (e compilado com sucesso) o &kdevelop; a partir do CVS, tal como foi mostrado em cima, você poderá querer mantê-lo actualizado, de modo a obter todas as modificações. Para isso, siga estes passos (Iremos assumir de novo que você colocou a sua cópia do &kdevelop; na directoria `codigo_kde3`.)

Repare no comando `up` (= update), colocado em vez do `co` (que significa checkout).

- `~>` `cd codigo_kde3`
- `~/codigo_kde3>` `cvs -z3 -d :pserver:anonymous@anoncvs.kde.org:/home/kde up kdevelop`
- `~/codigo_kde3>` `cd kdevelop`

Dê uma vista de olhos nas mensagens que o &CVS; produz, durante a sequência da actualização. Os passos exactos na sequência de compilação dependem disto.

Agora, você poderá compilar uma nova versão do &kdevelop;, tal como é apresentado no capítulo das Considerações especiais de compilação do &CVS;.

## Requisitos do &kdevelop;

Para poder compilar e usar o &kdevelop; com sucesso, você precisa dos seguintes programas e bibliotecas. Eles estão disponíveis na maioria das plataformas como pacotes das próprias distribuições e, como tal, poderão ser instalados facilmente.

## Necessário:

- gcc/g++ ≥ 2.95.3 (ou compatível)

  Disponível em gcc.gnu.org

- make da &GNU; (ou compatível)

  Disponível em www.gnu.org/software/make

- &perl; 5.004 (ou superior)

  Disponível em www.perl.com

- autoconf ≥ 2.52

  Disponível em www.gnu.org/software/autoconf

- automake ≥ 1.6

  Disponível em www.gnu.org/software/automake

- flex 2.5.4 (ou superior)

  Disponível em www.gnu.org/software/flex

- &Qt; ≥ 3.0.3 (ou superior)

  Disponível em www.trolltech.com/products/qt

- KDE ≥ 3.0.2

  Disponível em www.kde.org

## Opcional:

- A ferramenta de navegação no código ctags, a partir do 'site' http://ctags.sourceforge.net, que lhe permite aceder rapidamente às declarações e definições, através de uns simples 'clicks' nos nomes dos itens, dentro do editor.

- O dot, um compilador de linguagens gráficas, do http:/www.graphviz.org. Esta ferramenta é necessária, em conjunto com o &doxygen;, se você quiser ter as relações entre as classes desenhadas graficamente (o que é altamente recomendado).

- A ferramenta de documentação &doxygen;, do http://www.doxygen.org, se você quiser gerar documentação de APIs concisa e poderosa para os seus projectos.

- O valgrind de http://developer.kde.org/~sewardj/, que lhe ajuda a encontrar problemas de gestão de memória nas suas aplicações.

- O CVS do http://www.cvshome.org se você quiser usar o sistema de controlo de versões &CVS;.

- Qualquer outro compilador e/ou ferramenta, para o caso de você querer programar noutra linguagem/plataforma que não o C++/&kde; ou queira usar alguma funcionalidade especial.

1. Você poderá dar uma volta à necessidade do &autoconf; ≥ 2.52 e do &automake; ≥ 1.6. Basta remover a directoria `admin` da directoria de instalação do seu &kdevelop; e escrever

   - `(a-sua-directoria-do-kdevelop)>` `ln -s $KDEDIR/share/apps/kdelibs/admin admin`

   na consola. Isto faz com que o &kdevelop; use a configuração normal da directoria `admin` do &kde; em alternativa.

2. Tenha cuidado em não misturar as versões do &Qt;. Associe sempre o &kdevelop; à mesma versão do &Qt; com que as suas bibliotecas do &kde; foram compiladas. Caso contrário, você poderá obter comportamentos muito estranhos.

## Compilação e Instalação do &kdevelop;

Logo que todos os requisitos tenham sido cumpridos, você está pronto para compilar e instalar o &kdevelop;. Este capítulo irá discutir os passos necessários para o fazer.

- Os Passos Preliminares dizem-lhe como configurar um ambiente adequado.

- O Compilar o &kdevelop; lida com a obtenção do código do &kdevelop; a partir do &cvs;, como o preparar para o processo de instalação e finalmente mostra os passos necessários para compilar e instalar o &kdevelop;.

- O Algumas Notas Sobre as Opções do 'Configure' diz-lhe como executar o &kdevelop; se tiver sido instalado numa localização que não a directoria do &kde;.

### Passos Preliminares

Antes de entrar na sequência da consola, você precisa de se certificar que todas as bibliotecas e ferramentas estão disponíveis no sistema de compilação. Para conseguir isto, algumas variáveis de ambiente precisam de estar convenientemente definidas. Os passos reais a efectuar dependem da linha de comandos da consola que você utiliza.

Para evitar ter de escrever todos os comandos que definem as variáveis de ambiente necessárias de cada vez que deseja compilar, você deverá colocá-las no seu ficheiro `.bashrc` ou `.cshrc`. Desta forma, as variáveis de ambiente serão configuradas convenientemente sempre que você iniciar a linha de comandos.

#### Configurar o Ambiente para a Linha de Comandos Bash

Se você usar a linha de comandos 'bash', adicione as seguintes linhas:

- `export KDEDIR=`(local da sua instalação do KDE)
- `export QTDIR=`(local da sua biblioteca Qt)
- `export LD_LIBRARY_PATH=$QTDIR/lib:$KDEDIR/lib:$LD_LIBRARY_PATH`
- `export LIBRARY_PATH=$QTDIR/lib:$KDEDIR/lib:$LIBRARY_PATH`
- `export PATH=$QTDIR/bin:$KDEDIR/bin:$PATH`

#### Configurar o Ambiente para a Linha de Comandos Tcsh

Se você usar a linha de comandos 'tcsh', adicione as seguintes linhas:

- `setenv KDEDIR` (local da sua instalação do KDE)
- `setenv QTDIR` (local da sua biblioteca Qt)
- `setenv LD_LIBRARY_PATH=$QTDIR/lib:$KDEDIR/lib:$LD_LIBRARY_PATH`
- `setenv LIBRARY_PATH $QTDIR/lib:$KDEDIR/lib:$LIBRARY_PATH`
- `setenv PATH $QTDIR/bin:$KDEDIR/bin:$PATH`

### Compilar o &kdevelop;

Na discussão a seguir, assumimos que você colocou o código do seu &kdevelop; na directoria `~/codigo_kde3/kdevelop`.

#### Considerações Especiais de Compilação do &CVS;

No caso de você usar uma imagem do &kdevelop; do &CVS;, os passos de compilação iniciais dependem se você fez um 'checkout' completo ou se apenas actualizou o código.

#### Após um 'Checkout' de CVS

Você deverá inicializar o sistema de compilação depois de um 'checkout' completo. O mesmo se aplica de cada vez que você inicia a extracção do zero. Escreva:

- `~/codigo_kde3/kdevelop>` `make -f admin/Makefile.common cvs-clean`

e depois todos os passos a seguir.

Você poderá necessitar de acesso ao repositório do &CVS; para a limpeza, se alguns ficheiros corrompidos ou em falta precisarem de ser reconstruídos.

O comando `cvs-clean` irá remover todos os ficheiros que não pertençam ao &CVS; na directoria! Certifique-se que salvaguarda todas as informações valiosas, antes de executar este comando de limpeza.

#### Após uma Actualização do CVS

O próximo passo depende do resultado da sequência de actualização do &CVS;. Se você obteve algo do género do que se segue (repare na marca U ou P à esquerda, o que indica que o ficheiro foi alterado):

    U /uma_directoria_qualquer/Makefile.am

ou se você fez uma extracção completa, você precisa de fazer:

- `~/codigo_kde3/kdevelop>` `make -f Makefile.cvs`

antes de prosseguir com todos os passos a seguir.

#### Sequência Básica de Comandos do `make`

Logo que o sistema básico do 'make' tenha sido configurado desta forma, você precisa de decidir o tipo de sistema do &kdevelop; que você deseja usar. Isto é feito com o seguinte passo do 'configure' que compila a `Makefile` real que o comando `make` irá usar.

Você poderá ignorar a opção `--prefix` das seguintes linhas de comando do `configure` se você quiser que o &kdevelop; seja instalado na directoria predefinida do &kde;. Veja o capítulo com Algumas notas sobre as opções do `configure` para saber mais sobre o assunto.

#### Uma Versão Compilada com Depuração

Se você quiser manter um registo do que a sua aplicação &kdevelop; faz durante a sua execução, poderá criar uma versão compilada com informações de depuração. Basta correr o comando `configure` para o fazer:

- `~/codigo_kde3/kdevelop>` `./configure --enable-debug=full --prefix=(onde-está-o-seu-kde3)`

#### Uma Versão Compilada para Produção

Se você só quiser usar o &kdevelop; tal-como-está (mais pequeno e mais rápido) basta a versão para produção. O `configure` fica deste modo da seguinte forma.

- `~/codigo_kde3/kdevelop>` `./configure --prefix=(onde-está-o-seu-kde3)`

Se você quiser criar a sua própria documentação da API para o &kdevelop;, você precisa de incluir ainda mais outra opção do comando `configure`:

- `~/codigo_kde3/kdevelop>` `./configure --`(opções-acima) `\`
- `--with-kdelibsdoxy-dir=$KDEDIR/share/doc/HTML/en/kdelibs-apidocs`

#### Compilar e Instalar o &kdevelop;

O `configure` irá verificar o sistema e criar uma `Makefile` de acordo com o que encontrou. O comando `make` irá usar esta `Makefile` por omissão. Deste modo, o

- `~/codigo_kde3/kdevelop>` `make`

será suficiente. Se necessário, obtenha agora permissões de 'root' se fizer

- `~/codigo_kde3/kdevelop>` `su`

e indique a senha do 'root'. Instale então agora a aplicação:

- `~/codigo_kde3/kdevelop>` `make install`

E foi tudo. Se você instalou o &kdevelop; na directoria por omissão do &kde;, você poderá agora correr o IDE. Caso contrário, serão necessários alguns passos adicionais como é demonstrado na secção Directoria de instalação personalizada em baixo.

De facto, já terão sido instaladas normalmente três aplicações baseadas no &kdevelop;:

- O IDE do &kdevelop; — este é o local onde voce normalmente irá trabalhar.

- O navegador de documentação do Assistente do &kdevelop; autónomo — isola todas as funcionalidades poderosas de documentação do IDE &kdevelop; numa ferramenta separada. Isto pode ser útil quando desejar procurar por alguma documentação de programação mas não queira iniciar o IDE por completo.

- O Desenhador do &kdevelop; — aumenta o &Qt; User Interface Designer, adicionando os elementos específicos do &kde; e integra-se bem no IDE &kdevelop;.

### Algumas Notas sobre as Opções do `configure`

#### Directoria de Instalação Personalizada

Por omissão, o `configure` prepara o IDE para ser instalado na directoria predefinida do &kde;. Isto é necessário porque o &kdevelop; assume o acesso directo a algumas ferramentas e componentes que se encontram aí. Se você quiser usar a sua própria directoria de instalação, você terá de dizer isso ao `configure` com a opção `--prefix`:

- `~/codigo_kde3/kdevelop>` `./configure --prefix=(onde-está-o-seu-kde3)`

Existe uma contrapartida se o fizer. Você precisa de arranjar uma forma de o &kdevelop; aceder às ferramentas e componentes necessários na directoria do &kde;. (Você poderá à mesma usar o IDE sem o fazer, mas terá as capacidades bastante restritas).

Invoque uma linha de comandos e execute os seguintes comandos antes de iniciar o &kdevelop; na linha de comandos.

Tenha cuidado em usar o plural: É o `KDEDIRS`, não apenas o `KDEDIR`)

- `(a-sua-directoria-do-kdevelop)>` `export KDEDIRS=/usr/local/kde:/opt/kde3`
- `~>` `kbuildsycoca`
- (Agora inicie o &kdevelop;:)
- `~>` `kdevelop`

- A variável de ambiente `KDEDIRS` precisa de apontar para a lista de directorias activas do &kde; do seu sistema. É usado
- `/usr/local/kde`:`/opt/kde3`
- apenas como exemplo.
- A directoria `/usr/local/kde` poderá, por exemplo, conter uma versão incompleta do &kde; que você tenha compilado para fins de depuração e a `/opt/kde3` poderá, por sua vez, conter a versão normal do &kde; para a sua distribuição usada no dia-a-dia.

Numa linha de comandos 'tcsh' você precisa de definir as variáveis de ambiente usando:

- `~>` `setenv KDEDIRS /usr/local/kde:/opt/kde3`

O comando `kbuildsycoca` (build system control cache ou construir a 'cache' de controlo do sistema) procura as bibliotecas e coloca em 'cache' a sua localização e versão, para que o &kdevelop; possa então encontrá-las. A contrapartida é que leva bastante tempo — e tem de ser corrida sempre que você você invoque a linha de comandos para iniciar o &kdevelop; a partir de uma directoria não-predefinida. Você poderá querer colocar os comandos acima num 'script' para reduzir o esforço de escrita.

(Você poderá também colocar as mesmas linhas no seu `.bashrc` ou `.cshrc`, mas isso não é aconselhável, dado que o `kbuildsycoca` irá então ser executado sempre que você chamar a linha de comandos).

O comando `kbuildsycoca` não se executa a partir da raiz. Você terá de o invocar com um utilizador que não o 'root'. (Mas não é uma boa ideia, de qualquer forma, programar com o utilizador 'root'!)

## Como Obter a Documentação da API do &kdevelop;

API é a abreviatura de Application Program Interface ou Interface de Programação de Aplicações. De facto, uma interface de programação desse tipo é um conjunto de descrições (&ie;, convenções de chamadas) pelas quais uma aplicação acede ao sistema operativo ou a outros serviços. No nosso contexto, todavia, foi adoptada uma definição mais abrangente. A API de uma aplicação do &kde; ou do &Qt; é um resumo das interfaces das classes e dos métodos, uma sinopse a ser usada como um dicionário para navegar pelo código.

Existe uma versão da API mais actual disponível na página Web do KDevelop. Ele será actualizado automaticamente a cada 24 horas, para que você se possa manter a par.

Bem, esta versão poderá ser usada apenas para leitura na Internet. Mas, de qualquer forma, você poderá criar também a sua própria documentação da API a partir do código do &kdevelop;. Para o fazer, você precisa de dizer ao sistema do 'automake' onde encontrar a API das KDELIBS no seu sistema. Isto é feito com a opção `--with-kdelibsdoxy-dir` no comando `configure`:, quando se preparar para compilar o código do &kdevelop;:

- `~/codigo_kde/kdevelop>` `./configure --`(opções-normais)`\`
- `--with-kdelibsdoxy-dir=$KDEDIR/share/doc/HTML/en/kdelibs-apidocs`

(o `make` irá substituir o `$KDEDIR` pela sua directoria real do &kde;). Depois disso, execute um comando `make` normal. Depois de o IDE do &kdevelop; ter sido criado, você terá a opção para criar a API também. Para isso, você terá de executar

- `~/codigo_kde3/kdevelop>` `make apidocs`

Isto irá criar um ficheiro `Doxyfile` na sua directoria de base do &kdevelop; que irá, por sua vez, ser processado pela aplicação DOxygen para criar um conjunto grande de ficheiros `.html` com a API. Quando o processo relativamente longo de criação da API chegar finalmente ao fim, você terá de instalar a API tal como se fosse instalar o IDE &kdevelop; em si. Obtenha as permissões de super-utilizador, se necessário,

- `~/codigo_kde3/kdevelop>` `su`

e indique a senha do 'root'. Instale então os ficheiros da API:

- `~/codigo_kde3/kdevelop>` `make install-apidox`

Quando isto tiver sido feito, o `make` informá-lo-á sobre a directoria onde você poderá finalmente ver o conteúdo da documentação da API. Lembre-se deste endereço, dado que o poderá usar tanto no &konqueror; como dentro do &kdevelop;, no caso de você ter configurado o código do &kdevelop; como um projecto sobre o qual trabalhar.

Você irá ver provavelmente um grande conjunto de mensagens de aviso e/ou erro durante a criação da API executada pelo Doxygen. É melhor ignorá-las, dado que são apenas do interesse dos programadores do &kdevelop;. Se a geração da API chegar alguma vez ao fim com sucesso, os ficheiros da API em `.html` serão válidos.