CPP Builder

CURSO DE CIÊNCIA DA COMPUTAÇÃO
Programação Visual
Prof. Dr. Edison Puig Maldonado
Notas de aula
2002
1
Primeiro Semestre / 2002
Período letivo: Quarto semestre
Disciplina 3697: Programação IV
Professor: Edison Puig Maldonado
Programação Visual com o
PROGRAMAÇÃO VISUAL ORIENTADA A EVENTOS 1

INICIANDO O C++ BUILDER 1
ENTRANDO NO C++ BUILDER 5
CRIANDO E GERENCIANDO PROJETOS 12
CRIANDO FORMS 16
CRIANDO MENUS 24
TRABALHANDO COM O EDITOR DE CÓDIGO 28
TRABALHANDO COM MANIPULADORES DE EVENTOS 29
PROGRAMANDO COM OBJETOS 31
COMPILANDO E AJUSTANDO OPÇÕES DO PROJETO 34
CRIANDO UMA APLICAÇÃO MDI 37
2
Programação Visual Orientada a Eventos
Programação Orientada a Eventos
Esta metodologia de programação consiste em criar aplicações utilizando os componentes já existentes no

ambiente (software) de desenvolvimento rápido de aplicações, e editando o código diretamente nos
eventos gerados pelo componente.
Neste caso, o programador esta utilizando um conjunto de características pré-definidas para cada
componente, sem que sejam criadas novas propriedades, métodos ou até mesmo novos componentes para
aplicação.
Programação Orientada a Objetos
A programação orientada a objetos visa a criação de novos componentes, ou novas propriedades dos
componentes existentes com objetivo de torná-los mais genéricos.
Iniciando o C++ Builder

Introdução
O C++ Builder da Borland é um ambiente visual, orientado a objetos que tem por finalidade desenvolver
aplicações rapidamente para o Windows 95/98/NT. Estas aplicações podem ser de propósitos gerais ou
cliente/servidor. Usando o C++ Builder, você pode criar eficientes aplicações Windows com o mínimo de
codificação manual.
O BCB disponibiliza uma extensa biblioteca de componentes reutilizáveis e um ambiente de ferramentas
RAD (Desenvolvimento de Aplicações Rápida).
Quando você inicia o BCB, você é imediatamente colocado com o ambiente de programação visual. É com
este ambiente que o BCB disponibiliza todas as ferramentas que você necessita para criar, desenvolver,
testar, e debugar suas aplicações.
Iniciando o C++ Builder
A figura abaixo mostra como o BCB irá aparecer quando for rodado pela primeira vez:
1
O C++ Builder ambiente de desenvolvimento (também chamado de IDE), tem várias partes flexíveis que
você poderá coloca-las em qualquer local da tela. A janela principal contem o menu principal, barra de
ferramentas e a paleta de componentes. O Object Inspector, Editor de Código e o formulário são
automaticamente apresentados. Quando você estiver trabalhando, você poderá redimensionar cada parte e
mostrar ferramentas adicionais conforme a sua necessidade.
2
Acessando comandos rapidamente
O menu principal no topo da janela principal, disponibiliza acesso a vários comandos e ferramentas do BCB.
Você pode também ver uma barra de ferramentas no cantos esquerdo, embaixo do menu principal. Ela
contem botões que podem ajuda-lo quando estiver trabalhando. Cada botão executa uma operação ou
comando ( Abrir Arquivo, Salvar Projeto, Rodar, entre outras). A figura abaixo ilustra a barra de ferramentas
e mostra a função de alguns botões.
Clique com o botão direito do mouse na barra de ferramentas e escolha propriedades, você poderá
personaliza-la de acordo com as suas necessidades.
Criando uma aplicação
O BCB imediatamente apresenta as ferramentas necessárias para que você inicie a criação da aplicação.
• Uma janela em branco, conhecida como formulário, na qual você criará a interface do usuário
• Uma extensiva biblioteca, chamada de componentes
• Uma maneira fácil de alterar as propriedades de um objeto, utilizando o Object Inspector
• Acesso direto ao código do programa utilizando o Editor de Código
Você pode usar o BCB para criar aplicações de 32-bits de qualquer tipo. Desde aplicações de propósitos
gerais, até sofisticados programas de acesso a banco de dados.
Criando a interface da aplicação
Todo o trabalho de criação no BCB é visual. Quando você abre ou cria um novo projeto, um formulário em
branco e mostrado na tela. Você poderá usá-lo para iniciar a construção de sua interface e box de dialogo.
Você cria visualmente a interface da aplicação colocando e ajustando, no formulário, componentes visuais
tais como botões e caixa de listagem. Você também pode colocar componentes não-visual que tem por
finalidade capturar informações de banco de dados ou gerenciar outras interações.
Criando a Interface do Usuário, permitirá que você crie um esqueleto (protótipo) da aplicação rapidamente e
visualize como ela irá trabalhar.
Adicionando componentes
Componentes são elementos que você usa para construir suas aplicações BCB. Eles incluem todas as
partes visíveis de sua aplicação tais como, box de dialogo e botões; bem como as partes não visíveis
enquanto a aplicação estiver rodando, como os Timers.
Muitos componentes visuais são disponibilizados no ambiente de desenvolvimento na paleta de
componentes. Você seleciona o componentes da paleta e arrasta-o no formulário que você esta
desenvolvendo. Uma vez que o componentes esteja no formulário você poderá ajustar as sua propriedades
como, posição, tamanho entre outras.
O BCB agrupa os componentes, em diferentes páginas, de acordo com a sua funcionalidade.

Formulários e componentes tem muitos pontos em comum; você pode imaginar que um formulário é um
objeto que pode conter outros componentes.
3
O BCB inclui vários componentes que você pode usar na VCL (Biblioteca de Componentes Visual).
Verifique o Help VCL Reference para mais detalhes dos componentes disponíveis. Você pode personalizar
a biblioteca de componentes adicionando ou removendo componentes, ou ainda escrever seus próprios
componentes.
Alterando o comportamento do componente
Você pode facilmente personalizar a aparência e o comportamento de sua aplicação usando o Object
Inspector. Quando um componente tem o foco no formulário, suas propriedades e eventos são mostrados
no Object Inspector.
Usando a página Propriedades do Object Inspector, você

ajustará os valores iniciais, dos componentes, com o qual
sua aplicação irá iniciar. Você usará a página Eventos para
navegar através dos eventos que o componente pode ter.
Dando um clique em um evento em particular, o BCB irá
gerar o código para este evento ( event handler). Você
apenas deverá completar o código de acordo com a ação
desejada.
Criando menus
Depois de você adicionar um componente menu ao formulário, você poderá usar o Menu Designer para
criar e editar o menu principal e menus pop-up. Você precisa adicionar um componente menu ao seu
formulário para cada menu que você quer incluir em sua aplicação.
Os menus que você cria, são imediatamente visíveis no formulário sem ter que rodar a aplicação para ver o
resultado. Você também poderá alterar o menu em tempo de execução, para que o usuário final possa
adicionar opções ao menu.
Desenvolvendo aplicações
Como você desenvolve visualmente a interface do usuário da sua aplicação, o BCB gera automaticamente o
código C++ da aplicação. Você seleciona e modifica as propriedades dos componentes e formulários, o
resultado destas alterações são refletidas, automaticamente no código fonte, e vice-versa.
Editando o código fonte
O BCB Editor de Código é um completo e poderoso editor ASCII. Com o Editor de Código, você poderá
visualizar e editar todos os códigos fontes que seu projeto contem. A figura abaixo mostra um arquivo
chamado unit1.cpp; o arquivo default criado para cada novo projeto. Este arquivo e um dos vários arquivos
que compõem um Projeto BCB.
4
Escrevendo aplicações de banco de dados
O BCB possui um completo suporte para se criar aplicações avançadas de banco de dados. Ele inclui
ferramentas que permitem você se conectar com Oracle, Sybase, Informix, dBase, Paradox, ou outro
servidor, enquanto disponibiliza um transparente compartilhamento de dados entre aplicações. O Borland
Database Engine (BDE) suporta aplicações cliente servidor.
Ferramentas como o Database Explorer, simplificam o trabalho de escrever aplicações de banco de dados.
O Database Explorer e um browser para inspecionar e modificar especificação de servidor de dados,
incluindo tabelas, campos, armazenar definições de procedimentos, descrição de índices entre outra
funções relacionadas.
Entrando no C++ Builder

Iniciando uma nova aplicação
Antes de iniciar qualquer nova aplicação, você deverá criar o diretório que irá armazenar os códigos fontes
da aplicação. Desta maneira, você não irá "misturar" arquivos da sua aplicação com outros tipos de
arquivos.
1. Cria um diretório chamado MySource a partir da raiz do seu drive de trabalho. Ele irá armazenar todos os
arquivos do projeto que você irá criar com este exemplo.
2. Abra um novo projeto.

Cada aplicação é representado no BCB por um projeto. Quando você inicia o BCB, ele abre um projeto em
branco por default. Se um outro projeto já estiver aberto, escolha File | New Application para criar um novo
projeto.
Quando um novo projeto é aberto, BCB automaticamente cria dois arquivos:
• Unit1.cpp: arquivo fonte associado com o formulário principal do projeto.
• Project1.cpp: arquivo fonte que mantém os caminhos (localizações) dos formulários do seu projeto.
3. Escolha File | Save All para salvar os arquivos do projeto. Quando a janela Save Dialog aparecer,
navegue até o diretório MySource, e salve com os seus nomes default.
5
BCB também cria outros arquivos associados com seu projeto (dê uma olhada no diretório MySource). Para
mais detalhes dos arquivos criados automaticamente, pelo BCB, veja o item Criando e gerenciando
projetos.
Quando você abre um novo projeto, BCB mostra uma representação gráfica do formulário, chamada Form1
por default.
No BCB, você desenvolve a interface do usuário de suas aplicações usando formulários. Formulários
podem conter menus, caixas de diálogo e outros controles, eles também podem ser janelas pai ou filha.
Você coloca objetos no formulário para criar a interface do usuário. Objetos por exemplo, podem ser
controles padrão (como caixa de checagem e lista drop-down), ou eles podem ser completamente
preenchido por componentes (como tabelas de dados e editores).
Ajustando uma propriedade em tempo de desenvolvimento
No desenvolvimento da interface da aplicação, você ajusta as propriedades do objeto usando o Object

Inspector.
• Ajuste a propriedade Color do Form1 para clAqua
Para ajustar a propriedade Color, encontre a propriedade Color, do formulário, no Object Inspector e clique
na lista drop-down da propriedade. Mude a cor de fundo do formulário para clAqua.
Adicionando objetos ao formulário
A paleta de componentes BCB lista todos os componentes disponíveis que você poderá usar para criar sua
aplicação. Os componentes são agrupados em diferentes páginas da paleta de acordo com a sua função.
Usando os componentes, você pode rapidamente criar a interface da sua aplicação.
1. Adicione um componente Panel. Ponha o cursor do mouse sobre a paleta de componentes por um
momento; O BCB mostrará uma mensagem com o respectivo nome do componente. Quando você localizar
o componente Panel de um clique nele (ou duplo-clique), e um no formulário e o componente será inserido.
6
De um clique no componente Panel para que o mesmo tenha o foco. Agora o Object Inspector estará
mostrando as propriedade deste componente.
2. Ajuste a propriedade Align do componente Panel para alBottom.
3. Redimencione o tamanho da janela de sua aplicação (formulário) arrastando o canto direito do formulário.
4. Redimencione o tamanho do Panel até que preencha 1/3 do formulário ( clique no Panel para seleciona-
lo e arraste a sua borda superior).
5. Inclua um componente Table no formulário.

Clique na página Data Access da paleta de componentes para localizar Table.
6. Ajuste a propriedade DatabaseName de Table1 para BCDEMOS.
Acessando um banco de dados
Você agora esta pronto para ajustar a origem dos dados para os seus controles de banco de dados.
1 Na página Data Access, arraste um componente DataSource no formulário. Ajuste a propriedade

DataSet para Table1.
Na paleta de componentes, a página Data Controls contem os componentes que te permitiram visualizar
dados de um banco de dados em sua aplicação. Para mostrar todos os campos de uma tabela de um banco
de dados, use um componente DataGrid.
2. Na página Data Controls, escolha o componente DBGrid e inclua-o no Panel1 ( clique no DBGrid para
seleciona-lo, então clique dentro do Panel1 para colocar o componente lá). Seu formulário deverá estar
como o da figura abaixo:
7
Vamos ajustar as seguintes propriendade do DBGrid:

• A propriedade Align para alLeft, então arraste o lado direito do DBGrid para preencher 3/4 do
Panel1.
• A propriedade DataSource para DataSource1
Agora você poderá finalizar o ajuste das propriedades do objeto Table1 que você arrastou previamente no
formulário.
• TableName para BIOLIFE.DB
• ReadOnly para true
• Active para true
Quando você ajusta a propriedade Active para true, o grid é preenchido com os dados existentes na tabela
BIOLIFE.DB. (se o grid não preecher, verifique se você seguiu os passos anteriores corretamente).
Uma vez que DBGrid é um controle data aware, ele mostra os dados da tabela enquanto você esta
desenvolvendo sua aplicação. Entretanto, não é possível rolar os dados ou editar em tempo de
desenvolvimento. Para visualizar todos os dados da tabela você deverá rodar a aplicação.
4. Pressione F9 para compilar e rodar o projeto.
Adicionando mais componentes
Quando você roda a aplicação, o BCB abre o programa como uma janela, da mesma maneira que quando
você estava desenvolvendo. Ele é um completo programa Windows, com botões de Minimizar, Maximizar, e
um menu que você pode acessar a partir do canto esquerdo superior da janela. Você verá o grid preenchido
com os dados da tabela e poderá rolar os dados para visualizar todos os valores da tabela BIOLIFE.DB.
Uma vez que você ajustou a propriedade ReadOnly para true (Table1), você não poderá alterar os valores
dos itens da tabela.
Vamos agora completar a nossa aplicação exemplo, feche o programa para voltarmos ao desenvolvimento.
1. Na página Data Controls, selecione o componente DBNavigator e inclua-o no formulário, e ajuste a sua
propriedade DataSource para DataSource1.
Por default, o DBNavigator contem mais controles do que você irá utilizar para esta pequena aplicação;
para o momento , você precisará apenas dos botões First, Prior, Next, e Last. A propriedade
VisibleButtons do DBNavigator mostra os botões que serão apresentados.
8
2. Com o DBNavigator em foco, de um duplo-clique na propriedade VisibleButtons no Object Inspector.

A lista enumerada de VisibleButtons expandirá. Cada expansão corresponderá a um botão do
DBNavigator. Esta proprieade contem valores boleanos que podem ser alternados entre true e false.
Quando for false o botão não será visível.
3. Ajuste para false as seguintes propriedade VisibleButtons:

nbInsert nbDelete nbEdit
nbPost nbCancel nbRefresh
4. Na página Standard, arraste outro componente Panel no topo do formulário. O BCB nomeia por default
Panel2. Para remover este título quando a sua aplicação estiver rodando, limpe o texto que esta na
propriedade Caption. Depois de limpar o valor de Caption de Panel2, tenha certeza de pressiona Enter
para que o novo valor tenha efeito.
5. Alinhe Panel2 para o topo do formulário ajustando a sua propriedade Align para alTop. A seguir arraste a
parte de baixo de Panel2 para preencher a parte superior do formulário.
6. Ajusta a cor dos dois Panels para clBlue.

BCB permite que você ajuste propriedade de varios componentes de um só vez. Primeiro clique em Panel1,
então com Shif pressionado, Clique em Panel2. O Object Inspector mostrará todas as propriedade que são
comuns para ambos os componentes. A partir daqui você poderá ajusta a propriedade cor de ambos para
clBlue.
Nota. Todos os componentes tem uma propriedade Name, cada nome de componente deve ser único. Por
causa disto a propriedade Name não será mostrada no Object Inspector quando houver um grupo de
componentes selecionados.
7. Na página Data Controls, arraster um componente DBImage no topo de Panel2 e dimensione para ficar
como a figura abaixo:
8. Ajuste as seguintes propriedade de DBImage:

• DataSource para DataSource1
9
• DataField para Graphic

Novamente, porque o DBImage é um componente data aware, o componente mostrará a imagem do
primeiro registro da tabela.
9. Clique na seta verde na barra de ferramentas para compilar e rodar sua aplicação.
Com o Linker incremental do C++ Builder, o tempo de compilação e linkagem de seu projeto será
drasticamente reduzido comparado com a primeira vez que você rodou sua aplicação.
Toque final
Agora quando sua aplicação estiver rodando, você poderá facilmente navegar pela tabela usando os botões
do DBNavigator. Entretanto, nos iremos incluir outros recursos para que sua aplicação fique mais funcional.
Feche o programa para retornarmos ao modo de desenvolvimento.
1. Na página Data Controls, arraste um componente DBMemo no Panel2 e posicione para que ocupe o
canto esquerdo do panel. A seguir ajuste as seguintes propriedades.
• DataField para Notes
• ScrollBars para ssVertical
2. Arraste um componente DBText no Panel2, embaixo de DBMemo. Redimensione para que preencha toda
a parte inferior de DBMemo, e então ajuste as seguintes propriedades.
• DataField para Common_Name
3. Personalize a propriedade Font do objeto DBText usando o Editor de Fontes.

Quando você da um clique na propriedade Font de DBText. o BCB mostrará um botão elipse no lado direito
da propriedade. indicando que você pode usar um editor de propriedade para esta propriedade. Clique na
elipse e será mostrado o Editor de Fontes, um dialogo que permitirá que você edite o tamanho dos
caracteres e a fonte.
Modifique as seguintes propriedade de DBText usando o Editor de Fontes, e clique em Ok quando finalizar.
• Font Sylte para Bold
• Color para Silver
• Size para 12
Adicionando um botão sair da aplicação
Sua aplicação esta agora começando a se parecer com alguma coisa que se pode usar. Para torná-la mais
amigável, vamos adicionar um botão Sair para que você encerre o programa facilmente.
1. Na página Additional, arraste um componente BitButton (BitBtn) no Panel1, e ajuste a propriedade

Kind para bkClose.
Este é um valor default para botões, quando você der um clique a aplicação encerrará.
2. Altere a propriedade Caption de BitButtons para Sai&r.

O e comercial (&) antes de r torna-o em uma tecla de atalho, que permitirá que você saia do programa
pressionando Alt+r.
3. Novamente, compile e rode o programa pressionando F9.
Conectando-se a um evento
Você agora tem uma aplicação Windows que acessa uma tabela e mostra imagens, campos memos, e um
campo individual. Existe também um botão Sair que te permite encerrar o programa.
Até agora, você não escreveu uma única linha de código. O nosso próximo passo, será conectar um
identificador de evento a um botão, Nós iremos programar o botão para que quando for dado um clique, seja
10
apresentado o dialogo Windows File Save. Nós iremos salvar informações do registro corrente da tabela
em um arquivo.
1. Na página Dialogs, arraste um componente SaveDialog próximo do DataSource1.
2. Na página Additional, arraste um BitButton acima do botão Sair, e ajuste as seguintes propriedades:
• Caption para &Salvar
• Clyph para o pre-definido FileSave.BMP usando o Editor de Imagem
Quando você da um clique na propriedade Clyph, o BCB mostra um botão elipse no lado direito da
propriedade, isto indica que você pode usar o editor de propriedade para ajustar esta propriedade. Clique na
elipse para acessar o Editor de Imagem. No Editor de Imagem, clique no botão Load, e naveque até o
seguinte diretório:
\Arquivos de Programas\Arquivos Comuns\Borland Shared\Images\Buttons
Neste diretório, localize e carregue o arquivo FileSave.BMP. Quando você escolher Ok, você deverá ver
este BMP aparecer no lado esquerdo do botão Salvar.
A interface do usuário agora esta completa. Se você seguiu os passos deste capítulo, a sua aplicação
deverá se parecer como a figura abaixo:
Agora vamos escrever os código para o botão Salvar.
3. De um duplo-clique no botão Salvar para criar um evento default para este botão.
Quando você da um duplo-clique em um objeto no formulário, o BCB gera um código para este objeto. O
BCB também abre o Editor de Código. Neste caso, o BCB gera o seguinte código para esse evento:
void __fastcall TForm1::BitBtn2Click( TObject *Sender )

{
}
Você também poderá usar o Object Inspector para gerar o código acima. No Object Inspector, selecione a
página Event, você verá todos os eventos possiveis para o objeto selecionado, neste caso, onClick.
11
4. Complete o evento adicionando o código abaixo:
void __fastcall TForm1::BitBtn2Click(TObject *Sender)

{
FILE *outfile;
char buff[100];
wsprintf( buff, "Salvar informação para: %s", DBText1->Field->AsString.c_str());
SaveDialog1->Title = buff;
if( SaveDialog1->Execute())
{
outfile = fopen( SaveDialog1->FileName.c_str(), "wt" );
if( outfile )
{
fprintf( outfile, "Fatos de %s\n\n", DBText1->Field->AsString.c_str() );
for( int i = 0; i < DBGrid1->FieldCount; i++ )
fprintf( outfile,"%s: %s\n", DBGrid1->Fields[i]->FieldName.c_str(),
DBGrid1->Fields[i]->AsString.c_str() );
fprintf( outfile, "\n%s\n", DBMemo1->Text.c_str());

}
fclose( outfile );
}
}
Detalhes de como este código funciona, esta fora do escopo deste capitulo introdutório. Entretanto vamos a
uma breve descrição do que este código faz:
• Quando este código for chamado ( dando um clique no botão Salvar ), um box de dialogo File Save
será mostrado. Quando voce especifica um nome de arquivo, sua aplicação irá escrever os dados
do registro que estiver selecionado.
Antes de rodar o programa, você deverá incluir a seguinte linha no inicio de seu código fonte:
#include <stdio.h>
O tipo de dados FILE esta definido neste arquivo por isto é necessário a sua inclusão.
5. Para rodar a aplicação, pressione F9.
Parabéns! Você acaba de criar uma aplicação completa em C++ Builder.
Criando e gerenciando projetos

O que é um projeto C++ Builder
Um projeto C++ Builder é uma coleção de todos os arquivos que juntos, fazem uma aplicação executável
ou uma .DLL. No BCB, os arquivos do projeto são organizados no arquivo .MAK.
Como a nossa aplicação cresce, você encontrará mais e mais dependências entre diferentes arquivos e
consequentemente a complexidade aumenta. Um programa Windows pode compor-se de script de
recursos, LIB, OBJ, e códigos fonte. Cada tipo de arquivo requer um ajuste especial para ser compilado e
linkeditado na aplicação final.
Como o número de arquivos de sua aplicação cresce, você precisa de uma maneira eficiente de gerenciar
os diferentes componentes do projeto. Nós iremos estudar os arquivos que compõem um projeto, você
poderá ver como um projeto combina um ou mais arquivos fonte para produzir um arquivo final. O arquivo
final, por exemplo, pode ser um .OBJ, .DLL, ou .EXE. Cada arquivo final é dependente de todos os
arquivos usados para sua criação. Arquivos fontes são do tipo .C, .CPP, .H, e .HPP.
Arquivos do projeto
Para gerenciar projetos eficientemente, você necessita entender os diferentes tipos de arquivos que
constituem um projeto C++ Builder. Por default, vários arquivos são gerados cada vez que voce cria um
projeto. Os arquivos podem ser divididos em diferentes grupos como mostra a tabela abaixo:
12
Grupo de Arquivos Tipo do Arquivo

Arquivos de projeto .mak, .cpp, e .res
Arquivos Forms .cpp, .h, e .dfm
Arquivos Unit .cpp e .h
Arquivo Desktop .dsk
Arquivo Projeto
Quando você cria um novo projeto, O BCB automaticamente cria os seguintes arquivos:
• Project1.CPP
• Project1.MAK
• Project1.RES
Estes arquivos são iniciados por Project1, porque seus nomes são derivados do nome que você dá ao seu
projeto. Quando você renomeia o arquivo o projeto, os três arquivos são atualizados, dando a eles os
mesmos nomes.
Project1.CPP
É o ponto central de cada projeto. Este arquivo contem o ponto de entrada de sua aplicação ( função
WinMain() ). É aonde a sua aplicação inicia a execução. É também aonde é dada as "coordenadas" para
outros formularios e unidades de sua aplicação. É o local aonde você deverá declarar as sua variáveis e
constantes globais.
Project1.MAK
É o makefile, um arquivo texto que contem as opções e regras para construir o projeto. O BCB usa este
arquivo para determinar como os diferentes tipos de arquivos são combinados para gerar o arquivo final.
Para visualizar este arquivo, escolha View | Project Makefile.
Project1.RES
É o arquivo de recursos da aplicação. O BCB usa um formato padrão de recursos do Windows para incluir
itens como o ícone de sua aplicação. Você pode editar o arquivo de recursos para adicionar outros itens
como, bitmaps, cursores, tabela de strings ou icones.
Por default, cada aplicação BCB que você cria, terá um arquivo de recursos com o mesmo nome do arquivo
de projeto, mas com a extensão .RES.
Arquivo Form
O BCB representa cada formulário na sua aplicação, por três diferentes tipos de arquivos, dando por default
os seguintes nomes:
• Unit1.DFM
• Unit1.CPP
• Unit1.H
Quando você salva um novo formulários, o BCB pede para que você entre com um nome para o arquivo
.CPP. Este nome é usado para renomear os três arquivos.
Unit1.DFM
Formulários são a parte visível da aplicação. Normalmente, você cria formulários visualmente e usando o
IDE. Quando você cria um formulário, o BCB armazena a imagem deste formulario em um arquivo binário,
dando a extensão .DFM.
Unit1.CPP e Unit1.H
O BCB gera o arquivo fonte (.CPP) e seu header (.H) para cada formulário criado. Juntos, os três .DFM,
.CPP e .H fazem um formulário BCB.
Arquivo Unit
Existe uma pequena distinção entre arquivo formulários (.CPP) e arquivos Unit. Arquivos Unit não são
associados com formulários; eles simplismente são o .CPP e .H. Estes arquivos são flexíveis, eles podem
ser usados para armazenar funções globais que podem ser compartilhadas através do projeto.
13
Arquivo Desktop
O BCB também gera um arquivo que armazena informações sobre a situação atual do seu projeto, tais
como, quais janelas estão abertas e em que posição, os arquivos que estão sendo editados, entre outras
informações sobre o status do seu projeto. Isto permite que você recupere, o seu trabalho do ponto que
parou.
O arquivo Desktop tem o mesmo nome que o arquivo de projeto, mas com a extensão .DSK.
Sobre formulários e arquivos unit
O BCB suporta compilação separada de módulos de códigos chamados units. Usando units você estrutura
e reutiliza códigos através de seu projeto. A mais comun unit em BCB é a ligada a formulário, o qual contem
os identificadores de eventos e outros códigos para o formulário que você cria.
Units são os blocos de construções de sua aplicação BCB - elas contem os códigos fonte C++, de todos os
formulários de sua aplicação e também todas as funções que são chamadas através dos eventos do
programa. Para cada unit que você cria(.cpp), BCB gera uma unit header (.h). Também é gerado um arquivo
binário (.DFM) que contem a representação do formulário.
Arquivos unit podem ser criados como parte do projeto, mas isto não é obrigatório. Você pode criar e salvar
unit e units de formulários como arquivos isolados, para que qualquer porjeto possa usa-los. Arquivos
untis isolados, podem conter qualquer código fonte C ou C++, como funções globais e funções que você
quer compartilhar através dos formulários. Por exemplo, você pode escrever suas próprias funções, .DLLs,
e componentes, e por seus códigos fontes separados em um arquivos unit que não precisa ser associado a
um formulário.
Quando você compila uma unit, o compilador gera arquivos binários com o mesmo nome do arquivo unit
fonte, mas com a extenção .OBJ.
Arquivos units para formulários
Quando você cria um novo formulário, o BCB cria o seguinte código default para o formulário:
//------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
#include "Unit1.h"
//------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
//------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
}
//------------------------------------------------------
O comando TForm1 *Form1; cria o objeto Form1 da classe TForm1. Form1 contem todo o comportamento
e características do objeto TForm. Para este arquivo unit, você adiciona identificadores de eventos e
códigos para cada evento do componente que você necessita para este formulários em particular.
Arquivos units isolados
Voce pode querer reutilzar rotinas que você escreve. Neste caso é melhor criar um arquivo unit separado
para conter esta funções. Para isto você criará uma unit sem associa-la a um formulário, você poderá,
facilmente, criar sua funções e disponibiliza-las para outras units de seu projeto, e para outros projetos que
podem usar estas funnções.
Para cria um arquivo units sem associa-lo a um formulário:
• Escolha File | New Unit.
Não é necessário ter um projeto aberto, a menos que você queira que a nova unit seja parte do projeto.
Nota: Quando você quiser que uma unit faça referência ao código contido em uma segunda unit,
você deverá incluir na primeira o arquivo header (,h) da segunda. Para fazer isto, abra a primeira unit
no Editor de Código e use File | Include Unit Hdr e inclua o header da segunda unit. Usando este
14
método para incluir um arquivo header, fara com que todo os arquivos do projeto sejam
corretamente atualizados. ( em outras palavras, nunca inclua manualmente o header - digitando - ).
Salvando e dando nomes arquivos BCB
Quando você cria um novo projeto no BCB, é automaticamente criado vários arquivos e dado a eles nomes
default: Projeto1.MAK, Unit1.CPP e assim por diante. Quando você inicia um novo projeto, você deverá dar
nome aos arquivos para que os mesmos sejam mais significativos para você.
Você deverá armazenar cada projeto em um diretório especifico. Projetos podem compartilhar formulários,
arquivos e recursos localizados em qualquer diretório.
Salvando um novo projeto
Quando você salva um novo projeto, você deve dar um nome único para os arquivos do projeto.
Para salvar todos os arquivos, use um dos seguintes métodos:
• Escolha File | Save All
• Escolha o botão Save All na barra de ferramentas
Quando você salva um novo projeto, o BCB mostra a caixa de dialogo Salvar Como.
Salvando um arquivo de projeto específico
Você não esta limitado a salvar um projeto do mesmo modo. O BCB permite que você salve arquivos do
projeto, incluindo cópias de um arquivo, em diferentes diretórios ou com diferentes nomes.
Você também pode salvar seus projetos como "modelos" e adiciona-lo ao Object Repositóry (veremos em
outro capitulo) para que você possa reutiliza-lo.
Para salvar um arquivo especifico, você deverára abrir o Editor de Código:
• Carregue o arquivo no Editor.
• Pressione Ctr+S ou escolha File | Save, e clique em Ok.
Se você estiver salvando pela primeira vez, você deverá fornecer um nome para o arquivo.
Removendo arquivos do projeto
Você pode remover formulários e unit do projeto a partir de qualquer ponto de desenvolvimento do projeto,
mas você deverá usar somente o IDE para fazer esta operação. O processo de remoção, deleta qualquer
referência ao arquivo.
Para remover uma unit de um projeto, abra o projeto e escolha qualquer destes métodos:
• Na janela do Project Manager, selecione a unit ou units que você quer remover então escolha o
botão Remove na barra de ferramentas.
• Escolha o botão Remove File From Projeto na barra de ferramentas.
Atenção: Não use o Windows Explorer para deletar arquivos BCB do disco, até que você tenha executado
a remoção pelo IDE. Se você fizer isto, quando você abrir o projeto o BCB apresentará mensagens de erros,
pois ele ainda possui referências a estes arquivos.
Copiando um projeto
BCB permite que você salve uma versão do projeto aberto em um diferente diretório. O comando File |
Save Project As executa este processo, entretanto, como o projeto aberto pode compartilhar arquivos
fontes, o Save Project As salva somente uma cópia, no novo diretorio, dos seguintes arquivos:
• Project1.CPP ( arquivo principal do projeto)
• Project1.MAK ( contem definições de quais arquivos e como eles devem ser
compilados/linkeditados)
• Project1.RES ( arquivo de recursos como - icones, strings...)
Atenção: Nenhum arquivo unit é salvo na nova localização. Quando você abre um cópia do projeto, o
Gerenciador de Projeto mostra todos as units, isto não quer dizer que as units residem no mesmo
diretório do projeto aberto.
Não utilize o Windows Explorer ou outro gerenciador de arquivos para copiar arquivos de um projeto. O BCB
mantem relações entre os arquivos.
15
Visualizando arquivos do projeto
O Gerenciador de Projeto, do BCB, da a você um alto nível de visualização de formulários, units, recursos,
objetos, e arquivos de bibliotecas, que estão incluidos no seu projeto. Você pode usar o Gerenciador de
Projeto para abrir, adicionar, salvar e remover arquivos do projeto. É uma ferramenta indispensável se você
for compartilhar arquivos diferentes entre projetos.
Para abrir a janela do Gerenciador de Projeto, escolha View | Project Manager ( você deve ter um projeto
aberto ).
Usando o Gerenciador de Projeto
A janela do Gerenciador de Projetos mostrará informações

sobre o status e conteúdo o projeto aberto. Ele também da um
acesso rápido as funções de gerenciamento - clicando com
o botão direito do mouse no nome do projeto - , e permite
uma navegação rápida entre todos os arquivos.
É altamente recomendado que você use o Gerenciador de

Projeto para um melhor desempenho, porque ele mantem as
relações entre os arquivos e atualiza todo o projeto quando
um dos arquivos for alterado.
Adicionando formulários e units
Você pode adicionar um formulário ou um arquivo unit, o processo e igual. Use um dos seguintes métodos:
• Escolha File | New Form ou File | New Unit
• Escolha o botão Adicionar Arquivo na barra de ferramentas
Se for adicionado um arquivo .CPP que seja vinculado a um formulário, um arquivo binário .DFM também
ser adicionado automaticamente.
Usando units com fontes em Borland C++, C, ou Pascal
Se você tem units com códigos de procedimentos ou funções escritas em Borland C++, C, Pascal ou Delphi,
você poderá usar estas units no projeto BCB. Você adiciona este arquivos da mesma maneira que você
faria com um form ou unit do BCB.
Criando forms
Criando um aplicação BCB
Forms (formulários) são a base de todas as aplicações de C++ Builder. Você projeta a interface de usuário
para suas aplicações usando forms. Forms podem conter menus, botões, caixas de edição, caixas de
diálogo, ou qualquer outro objeto que você precise para fazer sua aplicação trabalhar da maneira que você
16
quer. Quando você terminar de projetar seu form, você pode acrescenta-lo ao Object Repository
(Repositório de Objeto) assim você poderá reutilizar este forms em outros projetos.
Em resumo, para criar uma aplicação de C++ Builder, você faz o seguinte:
• Começa com um form.
• Coloca componentes no form.
• Ajusta as propriedades dos componentes.
• Cria um manipulador de evento (dando um duplo-clique no componente).
• Escreve o código do evento para que o componente faça algo.
• Salva o projeto.
Uma aplicação de C++ Builder normalmente contém vários forms: um form será o principal que será a
interface do usuário ( tela prinipal do programa) e os outros forms como caixas de diálogo, janelas
secundárias, e coisas assim.
Você desenvolve sua aplicação personalizando o form principal, adicionando e personalizando outros forms.
Você personaliza forms adicionando componentes, ajustando as suas propriedades, criando menus para
que o usuário tenha controle sobre a aplicação durante a execução do programa.
O que são formulários e componentes
Formulários ( Forms) são objetos especializados no qual você coloca componentes VCL. Forms geralmente
se parecem como janelas e caixas de diálogo em uma aplicação que esta rodando. Você interage com o
forms lendo e fixando suas propriedades, chamando os métodos e respondendo aos seus eventos.
17
Associado a cada form (.DFM) está um arquivo .CPP e .H.
Componentes em C++ Builder são blocos de construção de uma aplicação. Cada componente representa
um elemento da aplicação, como um objeto de interface de usuário, um banco de dados, ou uma função de
sistema. Escolhendo e conectando estes elementos, você constrói a interface de sua aplicação.
Componentes também podem ter um manipulador (handle) de evento que permite receber e responder a
tipos específicos de entrada.
Por exemplo, um botão tem um manipulador de evento OnButtonClick que instrui o botão como responder
a um clique do mouse.
Criando um formulário e colocando componentes no formulário
C++ Builder disponibiliza vários maneiras para se criar um novo form, usar e personalizar um form existente.
Você pode criar um novo form de muitas formas:
• Iniciando o C++ Builder. É gerado um form em branco, sua unidade associada, e um arquivo de
projeto, Se você escolheu um form diferente ou um projeto padrão do Repositório de Objeto , um
form padrão se abre em vez de um form em branco.
• Criar uma nova aplicação escolhendo File | New Application. É gerado um novo form e o arquivo de
unidade (.CPP), sempre que se gera uma nova aplicação.
• Adicionando um novo form em um projeto existente, escolhendo File | New Form. Depois que o
form for criado, você pode acrescentar componentes ao form.
As maneiras mais fáceis de se colocar um componente em um form são:
• Clicar duas vezes em um componente na paleta de Componentes.
• Clicar no componente e depois no form.
Entendendo os componentes
Componentes são o blocos de código. Cada componente encapsula algum único elemento de aplicação
dentro um elemento reutilizável. Entender o que é um componente é o passo mais importante para
compreender o C++ Builder.
Esta seção examina duas visões dos componentes do C++ Builder: uma visão hierárquica e uma visão
funcional.
A visão hierárquica descreve os componentes de acordo com o que eles são. A visão funcional descreve
componentes de acordo com o que eles fazem.
Hierarquia do componente
18
Um maneira de entender os componentes é olhar para a relação de herança dos diferentes componentes.
Notando as propriedades, métodos, e eventos comuns que grupos de vários componentes herdam, você
pode entender algumas das semelhanças e diferenças deles.
Em geral, componentes são divididos em dois tipos de categorias: componentes de non-visual (não-visual)
e de controles.
Componentes Non-visual: são componentes que representam elementos do programa que o usuário não
pode interagir diretamente, como timer e conexões de banco de dados. Componentes Non-visual
aparecem em tempo de desenvolvimento como pequenos ícones em um form ou módulo de dados.
Algum componentes non-visual na verdade representam elementos visual quando a aplicação roda, como
uma barra de menu principal ou uma caixa de diálogo comum. Eles armazenam uma descrição dos itens
que a aplicação criará no momento apropriado ao rodar.
Controles: são elementos visíveis que os usuários podem interagir com a aplicação quando estiver rodando.
Em geral, em tempo de desenvolvimento e execução eles se parecem, o que facilita o projeto do formulário.
Sempre que possível, C++ Builder mostra em tempo desenvolvimento o que acontecerá em tempo de
execução: uma exibição de caixa de lista (seus itens são mostrados), um grid de dados que é conectado a
uma tabela aberta (exibe os dados atuais da tabela).
Há duas subcategorias de controles: windowed e controles de gráficos.
• Os controles windowed são controles que podem adquirir foco de entrada. A maioria dos controles
padrão do Windows são controles windowed. O termo "windowed " vem do fato que tais controles
têm um manipulador (handle) de janela (o qual você pode acessar através da propriedade Handle).
• Os controles Gráficos (as vezes chamados "non-windowed controls ") são controles que não podem
receber o foco de entrada, não possuem manipulador (handle) de janela. Controles gráficos utilizam
menos recursos de sistemas, assim eles são úteis para formulários complexos que precisam exibir
um grande número de controles.
A distinção entre controles windowed e gráfico é importante quando você projeta a interface do usuário. Por
exemplo, se você criar um toolbar que contém um número grande de botões, você poderia usar um
componente (button) botão padrão, mas cada um consumiria um handle de janela. Você poderia escolher
um componente non-windowed speedbutton que reduziria o consumo de recursos de sistemas.
Ajustando as propriedades do componente e o Object Inspector
Você pode ajustar as propriedades dos componentes em tempo de desenvolvimento ou muda-las durante a
execução do programa. Para mais informações sobre as propriedades de cada componente, consulte o help
do C++ Builder e procure pela palavra chave components ou veja o tópico Visual Component Library
components e selecione o componente cujas propriedades deseja ver. Você também pode pressionar F1
com um componente selecionado no formulário.
Os componentes da paleta ActiveX só é provida com exemplos, porque eles não fazem, formalmente, parte
do C++ Builder VCL, e não são documentados no C++ Builder.
Com o Inspetor de Objeto você poderá:
• Ajustar as propriedades dos componentes que você coloca no formulário, em tempo de
desenvolvimento.
• Criar e te ajudar navegar entre os manipuladores de eventos ( event handlers).
Você pode redimensionar as colunas do Object Inspector arrastando o separador de coluna para uma nova
posição.
19
O Inspector de Objeto possui duas páginas:

• Página de propriedades
• Página de eventos
A página de propriedades lhe permite ajustar as propriedades dos componentes de seu formulário e do
próprio formulário.
A página de propriedades mostra somente as propriedades do componente que está selecionado.
Nota: Você pode fixar as propriedades em durante a execução do programa, escrevendo o código fonte
dentro do manipulador de evento.
A página de eventos lhe permite conectar o formulário e os componentes aos eventos do programa.
Quando você da um duplo-clique em um evento da página de Eventos, o C++ Builder cria o manipulador de
evento e muda o foco para o Editor de Código. No Editor de Código, você escreve o código dentro do
manipulador de evento. Este código especifica como um componente ou um form responderá a um evento
em particular.
A página de Eventos mostra somente os eventos do componente que está selecionado.
Como o OB mostra as propriedades
O Inspetor de Objeto, muda dinamicamente as propriedades do componente selecionado. Quando você

seleciona mais de um componente, somente as propriedades compartilhadas são mostradas. Exemplo: se
você selecionar um Label e um GroupBox, você verá a propriedade Color junto com outras
Quando você usar o Inspetor de Objeto para selecionar uma propriedade, a propriedade permanecerá
selecionada enquanto você não adicionar ou selecionar outro componente.
Construindo uma caixa de diálogo
O C++ Builder disponibiliza algumas Caixa de Diálogo predefinidas. Eles estão na página Dialogs na Paleta
de Componentes. Você pode especificar opções diferentes para estas caixas de diálogo, como se um botão
de Help deve aparecer, e fazer qualquer mudança que você queira.
Esta seção discute os pontos mais comuns quando se esta projetando um diálogo personalizado:
• Fazendo um diálogo modal ou não-modal.
• Ajustando as propriedades de form.
• Especificando um título para a sua caixa de diálogo.
• Criando botões de comando.
20
• Ajustando, testando e removendo a ordem da tecla Tab.

• Testando a tecla Tab.
• Habilitando e desabilitando um componentes.
Fazendo um diálogo modal ou não-modal
Em tempo de desenvolvimento, caixas de dialogo são simplesmente formulários customizado. Em execução

eles podem ser modais ou não-modais.
Quando um form é modal, o usuário deve explicitamente fecha-lo para prosseguir com outro formulário. A
maioria caixas de diálogo são modais.
Quando um form for não-modal (modeless), você pode ir para outros forms sem ter fechar o form anterior.
Você poderia criar uma form não-modal para exibir informação de estado, como o número de registros
procurado durante uma pesquisa, ou informações que o usuário poderia querer enquanto trabalha.
Nota: Se você quiser que uma caixa de diálogo não-modal permaneça em cima das outras janelas abertas
durante a execução do programa, fixe a propriedade do form FormStyle para fsStayOnTop.
Forms têm dois métodos que dizem se ele será modal ou não-modal durante a execução:
• Para exibir um form como modal utilize o método Show. Ex: Form1->Show( );
• Para exibir um form como não-modal utilize o método ShowModal. Ex: Form1-
>ShowModal( );
Ajustando as propriedades de form
Por padrão formulários do C++ Builder têm botões Maximizar e Minimizar, uma borda de
redimensionamento, e um menu de controle que provê comandos de adicionais para manipular um form.
C++ Builder provê uma propriedade de BorderStyleName na barra de título do form. Se você mudar a
propriedade Name antes de mudar a propriedade Caption, a barra de título mudará para o novo nome.
Uma vez que você mude a propriedade de Caption , a barra de título do form sempre refletirá o valor atual
de Caption.
Criando botões de comando padrão
Você pode, rapidamente, criar um botão padrão adicionando ao form um componente BitBtn e ajustando a
propriedade Kind de cada botão. Como exemplo, se você colocar um BitBtn e ajustar a propriedade Kind
para bkAbort , será mostrado um botão com um X vermelho com o texto Abort ( este texto pode ser
alterado através da propriedade caption), e o form retornará mrAbort, na propriedade ModalResult.
if( Form1->ShomwModal( ) == mrAbort ) {

// codigo
}
O C++ Builder disponibiliza a propriedade Cancel para um componente botão.Quando o seu form possuir
um um botão com esta propriedade ajustada para true, ao ser pressionado a tecla Esc, em tempo de
execucão, o código contido no evento OnClick será executado. Se o botão possuir a propriedade Default
ajustada para true, ao ser pressionda a tecla Enter, o código contido no evento OnClick será executado.
Ajustando, testando e removendo a ordem da tecla Tab.
A tecla Tab ao ser pressionada, move o foco para o próximo componente do form. A ordem inicial, é a
sequência que foi colocado os componentes no formulário. Esta ordem pode ser alterada quando
necessário. Para mudar a ordem do foco dos componentes use a caixa de diálogo Edit Tab Order:
• Selecione o form ou o conjunto de componentes do form que você deseja alterar.
• Escolha Edit | Tab Order, ou clique com o botão direito do mouse e escolha Tab Order.
A caixa de dialogo Edit Tab Order será mostrada com a lista dos componentes e a sequência dos mesmos.
Voce poderá alterar de acordo com as suas necessidades. Pressione o botão Ok quando tiver finalizado.
Caso seja necessário que um componente não faça parte da sequência Tab, você deve seleciona-lo e no
Object Inspector ajuste a propriedade TabStop para false.
21
Compile e rode o programa para testar a tecla Tab
Habilitando e desabilitando um componentes.
Para desabilitar um componente você deve ajustar a propriedade enabled para false e para habilita-lo
ajuste para true. Como exemplo, para desabilitar em tempo de execucão um componente:
NomeDoComponente->Enabled = false;
Gerenciando formulários em tempo de desenvolvimento e execução
Ajustando as propriedades durante a execução
Basicamente, qualquer propriedade pode ser ajustada durante o desenvolvimento (Object Inspector), bem
como na execução do programa (através do código). Algumas propriedades só podem ser alteradas durante
a execução, são chamada runtime-only.
Para ajustar as propriedade durante a execução, no código você especifica o componente, a propriedade e
o novo valor. As propriedades alteradas durante a execução, substitui todos os valoes incluidos durante o
desenvolvimento.
Especificando o form principal
O primeiro form que você cria e salva no seu projeto, torna-se o form principal da aplicação por default. É
por este form que a aplicação irá iniciar. Durante o desenvolvimento, você adiciona outros forms e talvez
você queira alterar o form principal, ou seja, você quer que a aplicação seja iniciada por um form em
particular.
Para alterar o form principal faça o seguinte:
• Escolha Options | Project ou clique com o botão direito no Project Manager, para mostrar caixa de
diálogo Project Options.
• Selecione a página Forms.
• Na caixa de listagem Main Form, selecione o form que você deseja que seja o principal e pressione
o botão Ok.
22
Alterando a forma de criação do form
Todos os forms que você inclui no projeto, são criados automaticamente quando a aplicação inicia. Em
alguns casos você pode decidir que não quer criar todos os forms quando a aplicação é iniciada. Por
exemplo, se diferentes forms se conectam a bancos de dados, você pode preferir criar estes forms somente
quando necessário.
• Escolha Options | Project para mostrar caixa de diálogo Project Options.
• Selecione a página Forms.
• Selecione o formulário que você deseja que não seja criado e pressione o botão >
Todos os forms que são criados automaticamente, estão listados na coluna da esquerda.
Controlando a ordem de criação dos forms
Para alterar a ordem de criação dos forms, selecione-o na lista e arraste para a posição desejada. Todos os
forms que são criados automaticamente estão listados na esquerda.
Instanciando um form em durante a execução
Antes que você utilize um form ele primeiramente deve estar criado, caso contrário um erro ocorrerá. Se
você definiu um form para que não seja criado automaticamente, você deverá faze-lo manualmente no
código.
Para instanciar/utilizar um form durante a execução:

• Adicione o nome do arquivo header (.h) na unidade que você deseja utilizar o form.
• Declare um ponteiro do tipo do form.
• Atribua o valor de retorno de "new" TFormNome( Owner ).
A variável de memória especifica a instancia do tipo do form. Por exemplo:
#include "aboutbox.h"
....
TAboutBox *Box = new TAboutBox( this );
Box->ShowModal( );
delete Box;
Usando formuláios predefinidos
Quando você inicia o C++ Builder pela primeira vez, é aberto um projeto com um simples formulário em
branco. Você adiciona componentes neste formulário. Também pode escolher em adicionar um formulário já
definido e usa-lo ou modifica-lo.
Você pode facilmente usar estes formulários que estão no Object Repository e pode salvar também
qualquer formulário no Object Repository.
Quando você escolhe File | New, o C++ Builder mostra a caixa de dialogo New Items.
23
A caixa de diálogo mostra o que esta no Object Repository. O Object Repository contem forms, projetos,
módulos de dados e outros. Você poderá usar diretamente, copiar ou derivar novos itens a partir deles.
Adicionando um formulário em sua aplicação
Você pode usar qualquer forms em sua aplicação.

Para adicionar um form em seu projeto:
• Com um projeto aberto escolha File | New.
• Escolha a página Forms.
• Selecione o form que você quer utilizar.
• Escolha a forma que você quer utilizar o form.
• Copy – cria uma cópia exata do form em seu projeto. Qualquer alteração no form original,
não afeta a cópia do seu projeto.
• Inherit – deriva um novo form em seu projeto. Qualquer alteração feito no form original,
poderá afetar o seu projeto. Esta opção está relaciona com herança de objetos.
• Use – apenas usa o form em seu projeto. Todas as alterações efetuados no form original,
serão refletidas na sua aplicação.
• Escolha Ok.
Criando menus
Partes básicas de um menu
Os menus provêem um modo fácil, para os usuários de suas aplicações, de executarem comandos. O C++
Builder Menus Designer, adiciona facilmente, um menu predefinido ou um personalizado em um form. Você
acrescenta um componente menu ao form, abre o Menu Designer, e adiciona itens de menu diretamente
na janela do Menu Designer. Você pode adicionar, deletar ou rearranjar, os itens, durante tempo de
desenvolvimento.
Você não precisa compilar e rodar o programa para ver o resultado, conforme você cria o menu, o resultado
pode ser visto automaticamente no form. Seu código também pode mudar o menu em tempo de execução.
Você deve estar familiarizado com as partes básicas de um menu, pois ele é pradão para os programas
Windows. Veja figura abaixo para detalhes.
C++Builder Menu terminologia
24
Criando um menu de simples
A barra de menu é exibida no topo da janela e esta composto de itens de menu que listam comandos que o
usuário pode executar. Uma chave de acelerador é uma letra sublinhada em um item de menu. Um exemplo
é Alt S+F para o comando Find.
Você pode acrescentar um componente MainMenu ou um PopupMenu em seu form. Ambos ficam situados
na página Standard da paleta de Componente.
Um componente MainMenu cria um menu que é anexado a barra de título de um form. Um componente
PopupMenu cria um menu que é mostrado quando o usuário da um clique com o botão direito do mouse.
Estes menus não possuem barra de título.
Para criar um menu:
• Acrescente um componente menu a um form.
• Renomeie o menu para dar um nome mais significativo.
• De um duplo-clique no componente para exibir o Menu Designer.
• Clique com o botão direito e escolha Insert. Um espaço em branco é inserido.
• Digite na propriedade Caption o nome do item que será mostrado no menu e tecle Enter.
• Repita os passos 4 e 5 para cada item do menu.
Alterando menus
Uma vez que você colocou um menu em um form, você precisará personaliza-lo. Você deve dar um nome e
criar os itens, comandos e submenus que você quer sua aplicação tenha. Você pode arrastar, soltar, copiar
e colar itens.
Adicionando, inserindo e apagando itens do menu

Os passos a seguir descrevem como executar as tarefas básicas ao construir um menu.
25
Adicionando itens
• Acrescente um componente menu em seu form.
• Clique duas vezes no componente para ativar o Menu Designer.
• Selecione a posição onde você quer criar o item.
• Digite a texto do item, na propriedade Caption e tecle Enter.
Inserindo itens
Para inserir um item, coloque o cursor no item e pressione Insert. São inseridos itens a esquerda ou acima
do item selecionado.
Apagando itens
Para deletar, selecione o item e pressione a tecla Del.
Barras de separação de itens
Digite o hífen ( - ) na propriedade Caption do item.
Adicionando e Desabilitando itens dinamicamente
Adicionando itens dinamicamente

Você pode acrescentar itens a um menu existente durante a execução do programa. Você insere um item
usando o método Add ou Insert (Veja o Help do C++ Builder para mais detalhe ). Você também pode
mostrar ou esconder itens mudando a propriedade Visible de determinados itens.
Juntando menus
Você prepara os menus para junção, especificando valores de duas propriedades:
• Menu, a propriedade do form.
• Grouplndex, a propriedade de itens de menu ( TMenuItem) no menu.
O valor defaut para GroupIndex é 0. Várias regras se aplicam quando se especifica um valor para
GroupIndex.
• O número mais baixos aparece primeiro (mais distante a esquerda) no menu.
• Substitui itens no menu principal, se o GroupIndex contiver o mesmo número.
• Para inserir itens, o valor de GroupIndex não deve estar sendo utilizado pelo menu ativo. Isto quer
dizer que, você deve prever "janelas" no menu que irá receber o outro. Por exemplo, numere os
itens do menu principal para 0 e 5, e insira os itens do menu "filho" (GroupIndex ) 1, 2, 3, e 4.
Desabilitando itens
Você pode impedir os usuários de acessar certo itens baseado nas condições atuais do programa, sem
remover os itens do menu. Por exemplo, se nenhum texto esta selecionado atualmente em um documento,
os itens Cortar, Copiar e Apagar podem estar desabilitado ou escondido.
26
Fixe a propriedade Enabled para false. Esta propriedade é diferente de Visible. Enquanto Visible esconde
o item, Enabled deixa-o visível (escurecido) e desabilitado.
27
Trabalhando com o Editor de Código

O Editor de Código permite que você visualize e escreva o código fonte de sua aplicação. Ele oferece vários
recursos e pode ser personalizado a seu gosto.
Algumas caracteristicas do Editor:
• Sintaxe com destaque
• Opção para desfazer múltiplas operações
• Quatro tipo predefinidos de configuração: Default, IDE Classic, Brief e Epsilon
• Help sensitivo para os elementos da linguagem
Este capítulo da uma introdução ao Editor de Código, para mais detalhes consulte o Help.
Você verá aqui:
• Visualizando arquivos no Editor de Código
• Menu de contexto do Editor
• Pesquisando
• Visualizando os efeitos dos componentes no Editor
Visualizando arquivos no Editor de Código
O Editor de Código do C++ Builder, é um poderoso editor de arquivos ASCII. Com ele, você pode editar
qualquer arquivo de sua aplicação C++ Builder e arquivos ASCII, também pode ter vários arquivos abertos
ao mesmo tempo. Cada arquivo é representado por uma "tab" no topo da janela do editor. Você pode
facilmente mudar para outro arquivo clicando na "tab" apropriada.
Quando você abre um novo projeto, o C++ Builder automaticamente gera uma página inicial no editor,
referente ao arquivo .CPP do formulário que foi criado. Quando você abre um novo form, unit ou outro
arquivo fonte em seu projeto, uma nova página é adicionada ao editor.
Existem várias maneiras de se visualizar o um arquivo no Editor de Código como abaixo:
• Escolha File | Open para abrir um arquivo existente.
• Para um arquivo já aberto, clique na tab correspondente
• Usar o botão correspondente na barra de ferramentas.
• Escolha View | Project Manager e de um duplo clique na unit desejada.
Fechando o Editor de Código dando um clique no Menu de Controle (X), todos os arquivos serão fechados.
Para fechar um arquivo em específico, Escolha a opção Close do menu File.
Menu de Contexto do Editor
Clicando com o botão direito do mouse no Editor, é apresentado um menu de contexto, que contem os
comandos mais utilizados.
Pesquisando
28
Você pode usar a opção Search ( no menu principal ) para localizar um texto em específico no Editor de
Código. O texto não precisa estar aberto. Caso você queira, a pesquisa pode ser efetuada em todos os
arquivos do projeto, aberto ou não.
Os comandos mais comuns de pesquisa são os seguintes:
• Find - procurar por um texto.
• Replace - pesquisar e substituir um texto
• Search Again - repetir a pesquisa
Visualizando os efeitos dos componentes no Editor
Quando você adiciona um componente a um form, é gerada uma variável de instância deste componente e
adicionada na declaração do formulário ( no arquivo header do form ). Similarmente quando você delete o
componente a variável também é removida da declaração. Você pode visualizar este efeito movendo o form
para um canto da tela e o Editor de Código em outro, para que os dois fiquem visiveis por inteiro.
Para visualizar como o C++ Builder gera o código:
• Clique com o botão direito no Editor de Código para ativar o menu de contexto, e escolha Open
Source/Header File, role a tela até que a seção de declaração de tipos fique visível.
• Adicione um componente e veja o que acontece no Editor de Código.
• Remova o componente e veja o que acontece no Editor de Código.
Nota: O C++ Builder não remove manipuladores de eventos ( ou métodos ) associados com o componente
que você deletou, porque este evento pode ser chamado por outros componentes no form. Caso você
remova um evento, você deve remover também a declaração do mesmo no arquivo header do form, caso
contrário uma mensagem de erro será gerada na compilação.
Trabalhando com manipuladores de eventos

No C++ Builder, quase todo o código que você escreve é executado diretamente ou indiretamente em
resposta a um evento. Este código é chamado de event handler. Event handlers são procedimentos
especializados. O event handler é executado quando um evento em particular é ocorre.
Você geralmente utiliza o Object Inspector para gerar event handlers. Esta seção mostra como usar o
Object Inspector e o Editor de Código para gerar o código do event handler.
• Gerando um handler padrão
• Escrevendo um event handler
• Localizando um event handler existente
• Associando um evento com um event handler existente
Gerando um event handler padrão
São os eventos mais comuns que você necessita em tempo de execução. Por exemplo, um evento padrão é
o evento OnClick, que ocorre quando se da um clique com o mouse em cima de um componente.
Escrevendo um event handler
Uma vez que você adicionou um componente em um form, você pode facilmente escrever o event handler
para ele:
1. Selecione o componente no form
2. Clique na tab Events do Object Inspector
3. Escolha o evento desejado na lista apresentada e de um duplo-clique no evento.
4. Editor de Código mostra o código gerado para o evento.
5. Digite o código para o event handler.
29
Como exemplo, siga a demonstração abaixo:

Crie um nova aplicação e adicione um componente TButton e um TMemo. Adicione a linha abaixo no
arquivo fonte (.cpp)
#include <vcl/printer.hpp>
De um duplo clique no componente TButton para criar o event handler e digite o

código a seguir:
//---------------------------------------------------------------------
void __fastcall Tform1::Button1onClick( Tobject *Sender){
int FontHeight, LinesOnPage;
Tcanvas *pcanvas;
Printer()->BeginDoc( );
Pcanvas = Printer()->Canvas;
FontHeight = pcanvas->Font->Height;
LinesOnPage = Printer()->PageHeight / -FontHeight;
for( int i = 0, j = 0; i < Memo1->Lines->Count; i++, j++ ){
if( ( i > 1 ) && ( i % LinesOnPage == 0)){
j = 0;
Printer( )->NewPage( );
}
pcanvas->TextOut( 10, (( j * -FontHeight) + 10 ), Memo1->Lines->Strings[i]);
}
Printer()->EndDoc( );
}
Para aprender mais sobre como programar event handlers, pesquise por event handler no Help do C++
Builder.
Localizando um event handler existente
Se você quizer visualizar o código de um event handler que previamente escreveu:

1. No form, selecione o componente desejado.
2. No Object Inspector, mostre a página de eventos - Events page.
3. Na coluna de eventos, de um duplo-clique no evento cujo código você deseja ver/editar.
Associando um evento com um event handler existente
Você pode associar um código (evento ), escrito para um determinado componente, a outro componente.
Você pode com isto, criar eventos genéricos e associa-los a diversos componentes. Como exemplo, você
pode tem um item de menu e um botão na barra de ferramantes associado a um mesmo evento.
1. No form, selecione o componente.
2. No Object Inspector, na página de eventos selecione o evento desejado.
3. Click na seta para baixo, e será aberto uma lista de eventos que podem ser atribuido ao evento
desejado.
4. Selecione o nome do event handler.
Nota: O C++ Builder não duplica o código do event handler quando você associa o mesmo eventos a vários
componentes. O mesmo código será chamado quando o evento ocorrer.
Deletando event handlers
Quando você deleta um componente, o C++ Builder remove a referência deste componente do arquivo
header ( .h). Entretanto, deletando um componente, não deleta o código do evento, pois este evento pode
estar sendo utilizado por outro componente.
30
Programando com objetos

Programação Orientada ao Objeto (Objetc-oriented programming - OOP) é uma extensão natural da
programação estruturada. OOP requer que você use boas técnicas de programação e o resultado será um
código limpo, fácil de expandir e simples de se efetuar manutenção.
Uma vez que você cria um objeto para uma aplicação, você e outros programadores podem utilizar este
objeto em outras aplicações. Reutilizando objetos, você diminuir o tempo de desenvolvimento e aumenta a
sua produtividade.
Estes são os tópicos básicos que serão discutidos neste capítulo:
• O que é uma classe
• O que é um objeto
• Examinando um objeto e classe do C++ Builder
• Herdando dados e códigos de uma classe
• Escopo do objeto
O que é uma classe
Em C++, para se criar um objeto, deve-se primeiro, definir a sua forma geral usando-se a palavra reservada
class. Uma class é similar a uma estrutura. Vamos começar com um exemplo. Esta class define um tipo
chamado fila, que é usado para criar um objeto-fila.
#include <iostream.h>
// Isto cria a classe fila
class fila {
private:
int q[ 100 ];
int slo, rloc;
public:
void init( void );
void qput( int );
void qget( void );
};
Uma class pode conter tanto partes privadas como partes públicas. Por exemplo, as variáveis q, sloc e
rloc são privadas. Isso significa que não podem ser acessadas por qualquer função que não seja membro
da class. Essa é uma maneira de se conseguir a encapsulação - acesso a certos itens de dados pode ser
firmemente controlado mantendo-os privados. Ainda que não seja mostrado nesse exemplo, também é
possível definir funções privadas que só podem ser chamadas por outros membros da class.
Para tornar partes de uma class públicas, (isto é, acessíveis a outras partes do seu programa), você deve
declará-las após a palavra reservada public. Todas as variáveis ou funções definidas depois de public
estão disponíveis a todas as outras funções no programa. Essencialmente, o resto do seu programa acessa
um objeto por meio das funçoes e dados public, filosoficamente deve-se tentar limitar ou eliminar ou seu
uso. O ideal é tornar todos os dados privados e controlar o acesso a eles com funções public.
As funções init( ), qput( ) e qget( ) são chamadas de funções membro, uma vez que fazem parte da class
fila. Lembre-se de que um objeto forma um laço entre o código e dados. Somente aquelas funções
declaradas na class têm acesso às partes privadas da class.
Uma vez definida uma class, pode-se criar um objeto daquele tipo usando-se o nome da class.
Essencialmente, o nome da class torna-se um novo especificador de tipo de dado. Por exemplo, a linha
abaixo cria um objeto chamado intfila do tipo fila:
fila intfila;
O que é um objeto
A característica mais importante de uma linguagem orientada ao objeto é o objeto. De maneira simples,
um objeto é uma entidade lógica que contém dados e códigos para manipular esses dados. Dentro de um
objeto, alguns códigos e/ou dados podem ser privados ao objeto e inacessíveis diretamente para qualquer
elemento fora dele. Dessa maneira, um objeto evita significativamente que outras partes não relacionadas
do programa modifiquem ou usem incorretamente as partes privadas do objeto. Essa ligação dos códigos e
dos dados é frequentemente referenciada como encapsulação.
31
Para todas as intenções e propósitos, um objeto é uma variável de um tipo definido pelo usuário. Pode
parecer estranho à primeira vista encarar um objeto, que une tanto código como dados, como sendo uma
variável. Contudo, em programação orientada ao objeto, esse é precisamente o caso. Quando se define um
objeto, cria-se implicitamente um novo tipo de dado.
Examinando um objeto e classe do C++ Builder
Quando você cria um novo projeto, o C++ Builder mostra um form para que você adicione componentes. No
Editor de Código, o C++ Builder declara uma nova classe para o form e produz o código dos arquivos .cpp e
.h que fazem parte do projeto.
Arquivo unit1.h
//---------------------------------------------------------------------------
#ifndef Unit1H
#define Unit1H
//---------------------------------------------------------------------------
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>
//---------------------------------------------------------------------------
class TForm1 : public TForm
{
__published: // IDE-managed Components
private: // User declarations
public: // User declarations
__fastcall TForm1(TComponent* Owner);
};
//---------------------------------------------------------------------------
extern PACKAGE TForm1 *Form1;
//---------------------------------------------------------------------------
#endif
Arquivo unit1.cpp
//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
#include "Unit1.h"
//---------------------------------------------------------------------------
TForm1 *Form1;
//---------------------------------------------------------------------------
: TForm(Owner)
{
}
//---------------------------------------------------------------------------
A nova classe é TForm1 e é derivada de TForm, que também é uma classe.

A primeira vista TForm1 parece não conter nenhum tipo de dado ou método, isto porque você não adicionou
qualquer componente ao form, e você não criou nenhum event handler. Mas, TForm1 contém dados e
métodos que você não vê, ele herda este dados e métodos da classe antecessor (TForm), isto será
discutido posteriormente.
Esta declaração cria uma variável (ponteiro) chamada Form1 do novo tipo de classe TForm1.
TForm1 *Form1;
Form1 é chamada de instância do tipo TForm1. Você pode declarar mais de uma instância de uma classe.
Você pode querer isto para gerenciar várias janelas filhas em uma aplicação MDI, por exemplo. Cada
instância carrega seus próprios tipos de dados e todas as instâncias de um tipo de classe utilizam o mesmo
código.
Vamos adicionar um botão no form e escrever um código para o evento OnClick - este evento irá mudar a
cor do form.
32
//---------------------------------------------------------------------------
void __fastcall TForm1::Button1Click(TObject *Sender)
{
Form1->Color = clGreen;
}
//---------------------------------------------------------------------------
Se você criou esta aplicação, de uma olhada no código .cpp o no .h, eles deve estar da seguinte forma:
Arquivo unit1.h
//---------------------------------------------------------------------------
#ifndef Unit1H
#define Unit1H
//---------------------------------------------------------------------------
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>
//---------------------------------------------------------------------------
class TForm1 : public TForm
{
TButton *Button1;
void __fastcall Button1Click( TObject *Sender );
__fastcall TForm1(TComponent* Owner);
};
//---------------------------------------------------------------------------
extern PACKAGE TForm1 *Form1;
//---------------------------------------------------------------------------
#endif
Arquivo unit1.cpp
//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
#include "Unit1.h"
//---------------------------------------------------------------------------
TForm1 *Form1;
//---------------------------------------------------------------------------
: TForm(Owner)
{
}
//---------------------------------------------------------------------------
{
Form1->Color = clGreen;
}
//---------------------------------------------------------------------------
A nova classe TForm1 agora contém um membro de dados Button1 - que é o botão que você adicionou.
TButton é uma classe, então Button1 também é um objeto. Classes podem conter outros objetos. Cada vez
que você adiciona um novo componente no form, um novo membro de dado referente ao componente é
adicionado na declaração da classe.
Todos os eventos que você escreve são métodos do objeto form. Cada vez que você cria um novo evento,
um método é adicionado na declaração da classe.
Herdando dados e códigos de uma classe
Herança é o processo em que um objeto pode adquirir as propriedades de outro objeto. Isso é importante, já
que suporta o conceito de classificação. Considerando-o, por classificações hierárquicas, mais
conhecimento torna-se gerenciável. Por exemplo, uma deliciosa maça vermelha é parte da classificação
33
maça, que, por sua vez, faz parte da classificação frutas, que está na grande classe comida. Sem o uso de
classificações, cada objeto precisaria definir explicitamente todas as suas caracteristicas. Portanto, usando-
se classificações, um objeto precisa definir somente aquelas qualidades que o tornam único dentro de sua
classe. Ele pode herdar as qualidades que compartilha com a classe mais geral. É o mecanismo de herança
que torna possível a um objeto ser uma instância específica de uma classe mais geral.
Escopo do objeto
O escopo do objeto determina a visibilidade e acessibilidade do membro de dados, propriedades e métodos

do objeto.
Quando você escreve um código, e este código se refere a um membro de dados, método ou propriedade
do proprio objeto, não é necessário fazer referencia a este objeto. Como exemplo, veja os código abaixo:

{
Color = clGreen;
Edit1->Color = clLime;
}
é o mesmo que:
{
TForm1->Color = clGreen;
TForm1->Edit1->Color = clLime;
}
Isto porque Edit1 (componente) e Color (propriedade) estão dentro do escopo de TForm1.
Compilando e ajustando opções do projeto

Este capítulo mostra como ajustar opções do projeto usando a caixa de diálogo Project Options, e
descreve como compilar e rodar a sua aplicação.
Ajustando opções do projeto
Você pode personalizar a maneira que o C++ Builder irá aparecer e trabalhar para um projeto em
particular, incluindo o próprio IDE. A aparência e comportamento do IDE quando você inicia o C++
Builder ou começa um novo projeto, são governados pôr ajustes de vários grupos de opções:
• Ajustes de Ambiente: afeta todos os projetos do C++ Builder.
Para mudar estas opções escolha Options | Environment.
• Ajuste de Projeto: afeta somente o projeto atual.
Para mudar estas opções escolha Options | Project.
• Ajuste de Repositório: determina o padrão para um novo form, novo módulo de dados e o
novo projeto.
Para mudar estas opções escolhar Options | Repository.
Mudando o padrão para novos projetos
A caixa de diálogo Project Options contêm check box com opções padrão. Estes controles permitem
que você modifique algumas das propriedades do C++ Builder. Quando você altera estes controles e
salva as alterações, o C++ Builder salva estas alterações no arquivo DEFAULT.MAK, localizado no
diretório BIN. O C++ Builder usa as informações deste arquivo para todos os novos projetos que você
cria.
34
Opções de formulário
Estas opções estão na página Forms e permitem que você:
• Defina o formulário principal da aplicação.
• Controle a ordem de criação dos formulários durante a inicialização da aplicação.
• Especifique quais formulários serão criados automaticamente.
Opções da Aplicação
A página Aplication é onde você especifica um título, o arquivo Help, e o ícone para o projeto. Você
também poderá ajustar esta propriedade durante a execução do programa, usando as propriedade Title,
HelpFile e Icon do objeto Application.
Title é o texto que irá aparecer quando você minimiza a aplicação quando ela estiver
rodando. Se não for especificado um título, quando a aplicação for minimizada, será
mostrada no nome do arquivo .EXE.
HelpFile se você criar um arquivo .HLP para o seu projeto, você o "conecta" na sua aplicação
especificando o nome do arquivo .HLP. ( veja o Help do C++ Builder para detalhes de como
utilizar arquivos .HLP).
Icon especifica um ícone para a sua aplicação.
Opções C++
As opções desta página permitem que você especifique as opções do compilador que afetarão o código
fonte C/C++ de seu projeto.
• Clique em Full Debug se você quer usar o integrated debugger para procurar por erros em
seu projeto.
• Clique em Release for distribuir sua aplicação.
Opções Pascal
Nesta página você especifica as opções do compilador que afetarão o código fonte Pascal do seu projeto (
você se lembra que o C++ Builder pode usar alguns forms ou códigos escritos em Delphi). Veja o Help
para mais informações.
Opções Linker
As opções desta página permitem que você especifique as opções de montagem de sua aplicação. Estes
ajustes, por exemplo, permitem que você escolha entre usar o incremental ou standard (TLINK32)
Linker. Usando o incremental Linker, sua aplicações são construidas mais rapaidademente, mas o
TLINK32 disponibiliza mais opções de construção. Para informação de um ajuste em especifico, veja o
Help do C++ Builder.
O arquivo fonte Project
35
O arquivo fonte Project é o principal arquivo de um programa. O C++ Builder usa este arquivo para
compilar e "Linkar" todas as units e arquivos de sua aplicação. Este arquivo é atualizado durante o
desenvolvimento do projeto.
Para abrir este arquivo escolha um deste métodos:
• No Project Manager, clique duas vezes no arquivo de projeto (no exemplo abaixo é o arquivo
logoapp.cpp).
O conteúdo do arquivo aparecerá no Editor de Código.

O C++ Builder gera o seguinte código fonte por padrão quando um novo projeto é criado:
//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
USERES("Project1.res");
USEFORM("Unit1.cpp", Form1);
//---------------------------------------------------------------------------
WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int)
{
try
{
Application->Initialize();
Application->CreateForm(__classid(TForm1), &Form1);
Application->Run();
}
catch (Exception &exception)
{
Application->ShowException(&exception);
}
return 0;
}
//---------------------------------------------------------------------------
• O arquivo header vcl.h contêm definições que são necessárias para a Biblioteca de
Componentes Visuais (VCL).
• A declaração #pragma hrdstop, instrui o compilador a parar de adicionar os arquivos header
precompilados. Por definição o arquivo vcl.h esta incluido no arquivo header precompilado.
• As declarações USEFORM e USERES são duas macros usadas para adicionar itens como arquivos,
forms e recursos ao seu projeto. Estas macros estão definidas em em sysdefs.h (localizado no
diretorio include\vcl). Este arquivo também define USEDATAMODULE, USEUNIT, USEOBJ, USELIB
em outros. O C++ Builder cria estas macros automaticamente quando você inclui um
determinada tipo de arquivo em seu projeto.
• A chamada de WinMain é o ponto de entrada de seu programa. É por aqui que seu programa
começa a ser executado.
• Application->Inatilalize( ); Inicializa o objeto Application VCL para este processo.
• A declaração Application->CreateForm cria os formulários especificados nos parâmetros da
função. Esta declaração cria o objeto form especificado no segundo parâmetro, usando a
especificação de classe de form do primeiro parâmetro. O C++ builder adiciona uma declaração
36
Application->CreateForm para cada form que você adicionar no projeto. É nesta ordem que os
forms são criados na memória quando o programa é executado.
• A declaração Application->Run( ); Faz com que o programa (processo) entre no loop de
mensagens. A partir deste ponto mensagens do Windows são enviadas e recebidas.
Compilando, construindo e rodando projetos
Todos os projetos C++ Builder tem um simples arquivo destino, pode ser um .EXE ou um .DLL. Você
pode visualizar ou testar sua aplicação em vários estágios do desenvolvimento.
Compilando um simples arquivo
Para compilar uma unit em seu projeto,

1. Selecione a unit no Editor de Código ou na janela Project Manager.
2. Escolha o Project | Compile Unit no menu principal.
Um diálogo de progresso irá aparecer indicando o andamento da compilação.
Se um erro for encontrado, de um duplo-clique na janela de mensagens e o Editor de Código irá abrir
com o arquivo fonte, mostrando a linha aonde o erro ocorreu.
Construindo um projeto
Existem duas maneira de construir uma aplicação:

1. Para compilar somente os arquivos alterados desde a última compilação, e linkeditar todos os
arquivos escolha Project | Make a partir do menu principal.
2. Para compilar todos os arquivos e linkeditar escolha Project | Make a partir do menu principal.
Se uma unit a ser compilada conter um inclusão de um arquivo header (.h), o arquivo correspondente
(.cpp) ao header também será compilado.
Rodando um projeto
Para rodar um projeto escolha no menu principal Run | Run ou escolha o botão Run na barra de
ferramentas. Esta ação tem o mesmo efeito que você tivesse escolhido Project | Make, exceto que a
aplicação irá rodar.
Criando uma aplicação MDI

Editor de Arquivos
Neste capítulo, serão apresentados os passos necessários para se criar uma aplicação MDI ( Multiple
Document Interface) usando o C++ Builder. Esta aplicação chamada de Editor de Arquivos, permite que o
usuário abra várias janelas filhas, dentro da janela principal da aplicação, e execute os comandos padrão de
um editor de texto.
Visão geral do exemplo
O processo de criação da aplicação Editor de Arquivos envolve os seguintes passos:

1. Construir todas as especificações MDI da aplicação.
2. Definir na aplicação MDI uma janela (pai) que conterá todas as janelas filhas. Você também poderá criar
menus para ambas as janelas (pai e filha), e definir a maneira que eles irão interagir. Dar a aplicação
meios de manipular as janelas filhas ( abrir, fechar, reorganizar, ver a lista de janelas filhas, etc...).
3. Prover a janela filha com um texto a ser editado.
Uma vez que você ajustou o comportamento MDI, você precisa adicionar um texto a janela filha. Você
dará a janela filha as funções básicas de um editor de texto, incluindo alinhamento de texto, barras
de rolagem, alteração de fonte, operações com a área de transferência, etc...
3. Disponibilizar as opções de salvar e carregar arquivos.
4. Capacidade de imprimir o texto.
37
Sobre aplicações MDI
Multiple Document Interface (MDI) é uma interface padrão para aplicações que abrem e mostram
simultaneamente um ou mais arquivos ou documentos dentro de uma janela windows. Por exemplo, você
pode usar MDI para habilitar uma aplicação de processamento de texto abrir e mostrar vários documentos
simultaneamente e permitir que o usuário faça rapidamente, trocas entre estes arquivos.
Aplicações MDI disponibilizam uma conveniente maneira de visualizar e trocas informações entre vários
documentos que estão compartilhados em uma mesma área de trabalho. Esta área comum é chamada de
frame window. Em uma aplicação C++ Builder, frame window é sempre a formulário principal da aplicação.
Como a frame window, outras janelas, chamadas child windows, contem os "documentos da aplicação",
Estes documentos podem ser de qualquer tipo. Aplicações MDI, somente gerenciam janelas que pertencem
a aplicação.
Criando a janela MDI pai
Antes de iniciar, você deve criar o diretório aonde serão salvos todos os arquivos do projeto.
Todo form C++ Builder tem uma propriedade FormStyle que determina se o form é frame ou child.
Somente poderá haver um frame form por aplicação e este será a janela principal da aplicação.
Selecione no menu principal do C++ Builder as opções File | New Application para criar um projeto em
branco.
Em seguida crie um MDI frame form (janela principal da aplicação)
1. Selecione o form
2. Ajuste a propriedade FormStyle para fsMDIForm
Ajuste as demais propriedades conforme abaixo:
Propriedade Valor
Name FrameForm
Caption Editor de Arquivos
Criando a janela MDI filha
Para criar um form MDI filho

1. Adicione um novo form ao projeto (File | New Form)
2. Ajuste a propriedade FormStyle para fsMDIChild
Ajuste as demais propriedades conforme abaixo:
Propriedade Valor
Name EditForm
Caption Sem Nome
Salve todos os arquivos usando os nomes abaixo:
Nome Default Salvar como
unit1.cpp MdiFrame.cpp
unit2.cpp MdiEdit.cpp
project1 EditorTexto
Se você rodar a aplicação agora, a janela filha aparecerá dentro da area da janela pai (frame window). Por
padrão, os forms do C++ Builder são criados quando a aplicação inicia.
Criando Menu
Para criar um menu em aplicações MDI, você utiliza o componente menu e o Menu Designer, da mesma
maneira que faria em um simples form. Entretanto, para aplicações MDI, você pode adicionar funcionalidade
para que o menu da janela pai interaja com o menu da janela filha, isto é, é feito uma junção dos dois
menus.
Por padrão, a barra de menu da janela filha, substitui a barra de menu da janela pai quando a janela filha
possui o foco de entrada. Uma solução elegante e fazer uma junção de itens do menu da janela filha com os
38
itens da janela pai. Isto é chamado de menu merging, e permite que itens de menu do form principal
possam estar disponíveis quando a janela filha tiver o foco.
Em nossa aplicação exemplo, quando não existir nenhuma janela filha aberta, somente os items Arquivo e
Janelas irão aparecer no form principal, porque eles possuem funções especificas para este form.
Quando o usuário abrir uma janela filha, adicionaremos dois novos itens no menu principal, os itens Editar
e Caracter, porque eles possuem funções específicas para elas.
Controlando a junção de menus
Você controla a ordem dos itens dos menus, ajustando o valor da propriedade GroupIndex para cada item
do menu em cada menu. De fato, você pode usar o GroupIndex para substituir itens do menu principal, por
itens do menu da janela filha.
Na aplicação Editor de Arquivos, você usará o valor 0 para GroupIndex para o item de menu Arquivo, para
ambos os form ( pai e filho ). Isto causa a substituição completa do item do menu principal (Arquivo) pelo
item do menu da janela filha quando o usuário abrir uma janela filha.
Criando o menu para a janela principal
Para criar o menu siga os passos abaixo:

1. Adicione um componente MainMenu ao form principal (FrameForm)
2. Use o Menu Designer para adicionar os itens Arquivo e Janela como é mostrado abaixo:
&Arquivo &Janela
&Novo &Lado a lado
&Abrir... &Cascata
- (hífen) &Reorganizar icones
Sai&r
Criando o menu para a janela filha
Para criar o menu siga os passos abaixo:

1. Adicione um componente MainMenu ao form filho(EditForm)
2. Use o Menu Designer para adicionar os itens Arquivo, Editar e Caracter como é mostrado abaixo:
&Arquivo &Editar (teclas de atalho) &Caracter
&Novo Cor&tar Ctrl+X &Esquerdo
&Abrir... &Copiar Ctrl+C &Direito
&Fechar C&olar Ctr+V &Centro
&Salvar De&letar Ctrl+D - (hífen)
Salvar
- (hífen) &Word wrap
&como...
- (hífen) Selecionar &tudo Ctrl+A - (hífen)
&Imprimir... &Fonte...
Configura
impressora...
Sai&r
Preparando os menus para junção
Uma das caracteristicas das aplicações MDI, e que elas podem mudar seus menus dependendo da janela
filha que tem o foco. Se não existe nenhum documento aberto, o menu apresentado será o da janela
principal. Se existir um documento aberto, o menu apresentado pode ser o da janelha filha.
Siga os passos abaixo para preparar os menus para que possam ser feita a junção:
Form Título do item Valor de GroupIndex
FrameForm Arquivo 0
FrameForm Janela 9
39
EditForm Arquivo 0
EditForm Editar 1
EditForm. Caracter 1
1. Selecione todos os itens que você quer que façam parte de um grupo.
2. Ajuste a propriedade GroupIndex para um inteiro, tendo em mente a seguinte regra:
• Um GroupIndex deve ser maior ou igual ao que esta a esquerda.
• Um grupo de menu da janela filha irá substituir um grupo da janela principal caso
possuem o mesmo valor de GroupIndex.
• Após a junção, o menu conterá os grupo de itens de menu na ordem ascendente de

seus GroupIndex, o menor GroupIndex estará na esquerda.
3. Repita os processo para cada grupo do menu.
Compartilhando comandos de menu
Para compartilhar um manipulador de evento em menus que sofreram junção:
1. Adicione o seguinte manipulador de evento ao evento OnClick do item de menu Arquivo | Sair de
FrameForm:
void __fastcall TFrameForm::Sair1Click(TObject *Sender)

{
Close( ); // Fecha a janela
}
Chamando o método Close no form principal da aplicação, fará com que o programa seja encerrado.
2. Anexe um manipulador de evento ao OnClick ao item de menu Arquivo | Sair de EditForm.
void __fastcall TEditForm::Sair1Click(TObject *Sender)

{
FrameForm->SairClick( Sender ); // Chama Sair de FrameForm
}
Ocorrendo este evento, será chamado o método SairClick de FrameForm.

Note que se você tentar compilar ou rodar a aplicação agora, o compilador irá parar neste evento e
será mostrada uma mensagem de erro informando que FrameForm não esta definido. Para que
você tenha acesso aos métodos de FrameForm, você deverá adicionar o arquivo header
MdiFrame.h com descrito abaixo:
Escolha File | Include Unid Hdr... para mostrar a caixa de diálogo Include Unit.
1. Escolha MdiFrame e clique Ok.
2. C++ Builder adiciona a seguinte linha no arquivo MdiEdit.cpp:
#include "MdiFrame.h"
Criando janela em tempo de execução
Uma vez que você cria a janela principal e qualquer janela filha para uma aplicação MDI, o menu da janela
filha irá aparecer. Se você rodar nossa aplicação verá que o menu da janela filha é mostrado. Isto ocorre
porque a janela filha esta sendo criada automaticamente.
Para que isto não ocorra, todas as janelas filhas devem ser "retiradas" da lista de janela que serão criadas
automaticamente.
Para dar o controle ao usuário sobre quais janelas devem ser criadas em tempo de execução, você precisa
fazer:
40
1. Remover os form filhos da lista de auto-criação.

2. Abrir a form em tempo de execução.
Removendo a janela da auto-criação
Em muitos casos, você quer que sua aplicação MDI crie as janelas filhas automaticamente, Mas por
convenção, aplicações MDI adicionam janelas filhas somente quando são necessárias.
Para remover as janelas filhas (EditForm) da lista de criação automática:
1. Escolha Options | Project para acessar a lista Forms Auto-Create.
2. Na lista Auto-Create, selececione o form que você não quer que seja criado
automaticamente( EditForm)
3. Clique no botão > para mover o form para a lista de Available form.
4. Escolha Ok para sair.
Se você rodar agora, verá que somente o form principal irá aparecer com seu respecitivo menu.
Abrindo janela durante a execução
Você irá agora abrir a janela filha a partir do comando de menu Arquivo | Novo. Como o form foi excluido
da lista de criação automatica, você deverá cria-lo através do código, no evento OnClick de Arquivo |
Novo.
Para cria a nova janela filha durante a execução:
1. Localize em seu código fonte aonde você quer que seja criada a janela. Isto normalmente é em um
evento de menu.
2. Execute o comando new seguido da especificação da classe da janela que você quer criar e passe o
parametro this
Inclua os códigos abaixo nos respectivos arquivos.
void __fastcall TFrameForm::Novo1Click(TObject *Sender)

{
new TEditForm( this );
}
void __fastcall TEditForm::Novo1Click(TObject *Sender)
{
FrameForm->Novo1Click( Sender );
}
Você deve incluir no evento OnClose de EditForm o código abaixo. Isto faz com que os recursos alocados
na criação da janela sejam liberados quando a janela for fechada..
void __fastcall TEditForm::FormClose(TObject *Sender, TCloseAction &Action)

{
Action = caFree;
}
Agora selecione o form FrameForm e ajuste a propriedade WindowMenu para Janela1, isto fará com que
as janelas abertas sejam listadas como itens de menu.
Manipulando janelas filhas
Uma vez que a aplicação já pode responder ao comando Arquivo | Novo para criar uma nova janela, você
pode começar a escrever o código para trabalhar com a janela aberta. Especificamente você pode atachar
manipuladores de eventos aos itens de menu para que elas sejam fechadas ou reorganizadas.
Fechando a janela
Para fechar a janela, chame o método Close.
Inclua os códigos abaixo no item de menu Fechar de EditForm.
void __fastcall TEditForm::Close1Click(TObject *Sender)

{
Close( );
}
41
Reorganizando as janelas
Todas aplicação MDI geralmente tem um item de menu Janela que permite que as janelas abertas possam
ser reorganizadas.
Para executar esta operação inclua os códigos abaixo nos eventos de menu correspondente:
void __fastcall TFrameForm::Ladoalado1Click(TObject *Sender)

{
Tile( );
}
void __fastcall TFrameForm::Cascata1Click(TObject *Sender)

{
Cascade( );
}
void __fastcall TFrameForm::Reorganizarcones1Click(TObject *Sender)

{
ArrangeIcons( );
}
Colocando documentos nas janelas filhas
Não existem restrições para o conteúdo de uma janela filha de uma aplicação MDI. Você pode colocar
basicamente tudo o que quizer. O tipo mais comum de janela filha MDI, entretanto, é uma que é
completamente preenchida utilizando um componente que representará um único documento, como um
arquivo texto, uma imagem gráfica, etc...
Na nossa aplicação, usaremos o componente TRichEdit para manipular o texto.
1. Selecione a janela filha (EditForm).
2. Coloque um componente TRichEdit no form.
3. Ajuste as propriedade de TRidchEdit conforme a tabela abaixo:
Propriedade Valor
Align alClient
BorderStyle bsNone
<apagar o
Lines
conteúdo>
Name Editor
ScrollBars ssVertical
Manipulando texto
Com o componente TRichEdit já colocado na janela filha, o próximo passo é desenvolver operações
básicas de manipulação de texto. Para permitir que o usuário execute estas operações, iremos escrever
códigos paras os eventos de menu.
Ajustando o alinhamento do texto
Escreva o seguinte código no evento OnClick do item de menu Caracter | Esquerdo:
void __fastcall TEditForm::Esquerdo1Click(TObject *Sender)

{
// Limpa marcas existentes
Esquerdo1->Checked = false;
Direito1->Checked = false;
Centro1->Checked = false;
// Este código é compartilhado pelos itens de menu

// Esquerdo, Direito e Centro
((TMenuItem *)(Sender))->Checked = true; // Marca o item que chamou
if( Esquerdo1->Checked )
Editor->Paragraph->Alignment = taLeftJustify;
42
else if( Direito1->Checked )

Editor->Paragraph->Alignment = taRightJustify;
else if( Centro1->Checked )
Editor->Paragraph->Alignment = taCenter;
}
Você deve selecionar o evento OnClick dos itens de menu Caracter | Direito e Caracter | Centro, e incluir
o evento Esquerdo1Click . No Object Inspector, na página Event selecione o evento OnClick e clique na
seta para baixo, do lado direito, para selecionar o evento.
Selecionando, cortando, copiando e deletando texto
Inclua os código abaixo nos respectivos eventos:
void __fastcall TEditForm::Selecionartudo1Click(TObject *Sender)

{
Editor->SelectAll( );
}
void __fastcall TEditForm::Cortar1Click(TObject *Sender)

{
Editor->CutToClipboard( );
}
void __fastcall TEditForm::Copiar1Click(TObject *Sender)

{
Editor->CopyToClipboard( );
}
void __fastcall TEditForm::Colar1Click(TObject *Sender)

{
Editor->PasteFromClipboard( );
}
void __fastcall TEditForm::Deletar1Click(TObject *Sender)

{
Editor->ClearSelection( );
}
Desabilitando itens de menu
Dependendo da situação atual do programa, quando ele esta rodando, alguns itens de menu não devem
estar disponíveis para o usuário. Como exemplo, selecionar a opção Caracter | Copiar se não existe texto
selecionado.
Para desabilitar este item e outros, selecione o evento OnClick do item Editar (do menu principal da janela
filha) e inclua o seguinte código:
void __fastcall TEditForm::Editar1Click(TObject *Sender)

{
bool TemSelecao;
// Habilita ou desabilida o item Colar se existir
// informações na área de transferência
Colar1->Enabled = Clipboard( )->HasFormat( CF_TEXT );
// true se tiver texto selecionado
TemSelecao = Editor->SelLength > 0;
Cortar1->Enabled = TemSelecao;
Copiar1->Enabled = TemSelecao;
Deletar1->Enabled = TemSelecao;
}
Voce deve incluir o arquivo header abaixo para que a função Clipboard( ) possa
ser utilizada:
#include <vcl\clipbrd.hpp>
Caixas de diálogo comum
43
Aplicações Windows usam um conjunto de caixas de diálogos para abrir arquivos, especificar nomes,
escolher fontes e cores, informações de impressão e outras mais. Estas caixas de diálogos são conhecidas
no Windows como caixas de diálogos comum. Estes componentes estão localizados na paleta de
Componentes na página Dialogs.
Para adicionar um controle em seu projeto:
1. Coloque uma caixa de diálogo (componente) Font no form EditForm. Não será necessário em nossa
aplicação, ajustar as propriedade deste componente.
2. Durante a execução, nós iremos mostrar esta caixa de diálogo chamando o método Execute.
Executando caixa de diálogo
Um coisa importante a se lembrar sobre caixas de diálogo comun é que elas não disponibilização operações
como abrir um arquivo ou alterar uma cor. Isto deve ser feito em sua aplicação. Estas caixas apenas fazem
uma interface para operações comuns como a escolha de um nome de arquivo ou seleção uma cor. Sua
aplicação usa estas informações para uma ação apropriada.
Para usar caixa de diálogo durante a execução:
1. Ajuste os valores iniciais das propriedade ( nome do arquivo, cor, fonte, e outras) ou as opções iniciais.
2. Chame o método Execute do componente. Execute abre a caixa de dialogo e então retorna um
boleano ( true ou false) quando o usuário fecha a caixa de diálogo. Se for escolhido Ok será retornado
true; se for escolhido Cancela será retornado false.
Alterando a fonte do editor
Durante o desenvolvimento você utiliza a propriedade Font do componente TRichEdit para ajustar a fonte
incial do texto. Você também pode escolher a fonte que quer usar durante a execução do programa. Para a
nossa aplicação inclua o código abaixo no evento OnClick do item de menu Caracter | Fonte:
void __fastcall TEditForm::Fonte1Click(TObject *Sender)

{
FontDialog1->Font->Assign( Editor->SelAttributes );
if( FontDialog1->Execute( ) )
Editor->Font = FontDialog1->Font;
}
Rode o programa para testar. Note que todo o texto do editor será alterado. Não
é este comportamento que queremos. Vamos fazer uma pequena alteração no código
acima para que somente o texto selecionado seja alterado.
void __fastcall TEditForm::Fonte1Click(TObject *Sender)

{
FontDialog1->Font->Assign( Editor->SelAttributes );
if( FontDialog1->Execute( ) )
Editor->SelAttributes->Assign( FontDialog1->Font );
}
Agora somente o texto selecionado será alterado ou o que for incluido a partir
do cursor.
Selecionando arquivos para abrir
Sua aplicação já pode criar um nova janela aonde o usuário pode digitar o texto. Agora nós iremos abrir um
arquivo existente para podermos edita-lo.
Nós iremos colocar no form FrameForm uma caixa de diálogo OpenDialog para que possamos selecionar
o arquivo que será aberto. Esta caixa de diálogo permite que se inclua um filtro para podemos selecionar
um tipo específico de arquivo ( *.txt, *.rtf, etc...).
Para criar um filtro de nomes de arquivos:
1. Inclua no form FrameForm um componente TOpenDialog.
2. Selecione a propriedade Filters da caixa de dialogo.
3. Digite os valores abaixo:
44
Nome do filtro Filtro

Arquivos Rich Text *.rtf
Arquivos Texto *.txt
Todos os arquivos *.*
Inclua no evento OnClick do item de menu Arquivo | Abrir de FrameForm o código abaixo:
void __fastcall TFrameForm::Abrir1Click(TObject *Sender)

{
if( OpenDialog1->Execute( ) ) // Abre a caixa de diálogo
{
// Cria uma nova janela e chama o método Abrir( )
( new TEditForm( this ) )->Abrir( OpenDialog1->FileName );
}
}
Inclua no evento OnClick do item de menu Arquivo | Abrir de EditForm o código abaixo:
void __fastcall TEditForm::Abrir1Click(TObject *Sender)

{
FrameForm->Abrir1Click( Sender );
}
Nós agora iremos criar o método Abrir que irá carregar o arquivo no editor.
Este método pertence a classe EditForm e sua definição (protótipo) deverá estar na seção public da
definição da classe . Isto deve ser feito, pois ele será chamado fora da classe de definição.
Arquivo header MdiEdit.h
//---------------------------------------------------------------------------
#ifndef MdiEditH
#define MdiEditH
........
class TEditForm : public TForm
{
TMainMenu *MainMenu1;
........
__fastcall TEditForm(TComponent* Owner);
void __fastcall Abrir( AnsiString );
};
//---------------------------------------------------------------------------
extern PACKAGE TEditForm *EditForm;
//---------------------------------------------------------------------------
#endif
Implementação do método Abrir:
void __fastcall TEditForm::Abrir( AnsiString NomeDoArquivo )

{
Editor->Lines->LoadFromFile( NomeDoArquivo ); // Carrega o arquivo especificado
Editor->SelStart = 0; // Move o cursor para o inicio do arquivo
Caption = ExtractFileName( NomeDoArquivo ); // Mostra o nome do arquivo
Editor->Modified = false; // O arquivo não foi modificado
}
Salvando arquivos
Agora que sua aplicação pode criar e carregar arquivos, é necessário que as alterações efetuadas nos
arquivos possam ser salvas.
Inclua nos eventos de menu OnClick de Salvar e Salvar como... os códigos abaixo:
void __fastcall TEditForm::Salvar1Click(TObject *Sender)

{
if( Caption == "Sem nome" ) // Se não tem nome
45
Salvarcomo1Click( Sender ); // Escolha um nome

else {
Editor->Lines->SaveToFile( Caption ); // Salva o arquivo
Editor->Modified = false;
}
}
//---------------------------------------------------------------------------
void __fastcall TEditForm::Salvarcomo1Click(TObject *Sender)

{
SaveDialog1->FileName = Caption;
if( SaveDialog1->Execute( ) ) {
Caption = ExtractFileName( SaveDialog1->FileName );
Salvar1Click( Sender ); // chama o método Salvar
}
}
//---------------------------------------------------------------------------
Para evitar dores de cabeça com perda de arquivos, é sempre bom ter uma cópia de segurança. Se você
alterar o método Salvar, como esta descrito abaixo, sempre será efetuado um backup do arquivo existente
antes que seja salvo o novo arquivo.
void __fastcall TEditForm::Salvar1Click(TObject *Sender)

{
AnsiString BackupFileName;
AnsiString BackupExt = ".BAK";
if( Caption == "Sem nome" ) // Se não tem nome
Salvarcomo1Click( Sender ); // Escolha um nome
else {
BackupFileName = ChangeFileExt( Caption, BackupExt ); // Se já existir
DeleteFile( BackupFileName.c_str( ) ); // .BAK será deletado
RenameFile( Caption, BackupFileName ); // renomeia o atual p/ .BAK
Editor->Lines->SaveToFile( Caption );
Editor->Modified = false;
}
}
46

CPP Builder

Загружено:

Сведения о документе

Исходное описание:

Оригинальное название

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

CPP Builder

Загружено:

Авторское право:

Доступные форматы

CURSO DE CIÊNCIA DA COMPUTAÇÃO

Prof. Dr. Edison Puig Maldonado

Programação Visual com o

PROGRAMAÇÃO VISUAL ORIENTADA A EVENTOS 1

Programação Visual Orientada a Eventos

Programação Orientada a Eventos

Esta metodologia de programação consiste em criar aplicações utilizando os componentes já existentes no

Programação Orientada a Objetos

Iniciando o C++ Builder

Iniciando o C++ Builder

Acessando comandos rapidamente

Criando uma aplicação

Criando a interface da aplicação

O BCB agrupa os componentes, em diferentes páginas, de acordo com a sua funcionalidade.

Alterando o comportamento do componente

Usando a página Propriedades do Object Inspector, você

Editando o código fonte

Escrevendo aplicações de banco de dados

Entrando no C++ Builder

2. Abra um novo projeto.

Ajustando uma propriedade em tempo de desenvolvimento

No desenvolvimento da interface da aplicação, você ajusta as propriedades do objeto usando o Object

Adicionando objetos ao formulário

2. Ajuste a propriedade Align do componente Panel para alBottom.

5. Inclua um componente Table no formulário.

6. Ajuste a propriedade DatabaseName de Table1 para BCDEMOS.

Acessando um banco de dados

1 Na página Data Access, arraste um componente DataSource no formulário. Ajuste a propriedade

Vamos ajustar as seguintes propriendade do DBGrid:

4. Pressione F9 para compilar e rodar o projeto.

Adicionando mais componentes

2. Com o DBNavigator em foco, de um duplo-clique na propriedade VisibleButtons no Object Inspector.

3. Ajuste para false as seguintes propriedade VisibleButtons:

6. Ajusta a cor dos dois Panels para clBlue.

8. Ajuste as seguintes propriedade de DBImage:

• DataField para Graphic

3. Personalize a propriedade Font do objeto DBText usando o Editor de Fontes.

Adicionando um botão sair da aplicação

1. Na página Additional, arraste um componente BitButton (BitBtn) no Panel1, e ajuste a propriedade

2. Altere a propriedade Caption de BitButtons para Sai&r.

3. Novamente, compile e rode o programa pressionando F9.

1. Na página Dialogs, arraste um componente SaveDialog próximo do DataSource1.

Agora vamos escrever os código para o botão Salvar.

void __fastcall TForm1::BitBtn2Click( TObject *Sender )

4. Complete o evento adicionando o código abaixo:

void __fastcall TForm1::BitBtn2Click(TObject *Sender)

fprintf( outfile, "\n%s\n", DBMemo1->Text.c_str());

5. Para rodar a aplicação, pressione F9.

Parabéns! Você acaba de criar uma aplicação completa em C++ Builder.

Criando e gerenciando projetos

Grupo de Arquivos Tipo do Arquivo

Sobre formulários e arquivos unit

Arquivos units para formulários

Arquivos units isolados

Salvando e dando nomes arquivos BCB

Salvando um novo projeto

Salvando um arquivo de projeto específico

Removendo arquivos do projeto

Visualizando arquivos do projeto

Usando o Gerenciador de Projeto

A janela do Gerenciador de Projetos mostrará informações

É altamente recomendado que você use o Gerenciador de