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

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

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

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

### 4.3.2.2. 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&_;de&_;Sua&_;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.

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

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

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

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