04-VCL-C++BuilderV10

L U I S F E R N A N D O E S P I N O S A C O C I A N

84

44.. AA VVCCLL -- BBiibblliiootteeccaa ddee

CCoommppoonneenntteess VViissuuaaiiss No Windows não são as aplicações quem manipulam os recursos do

sistema tais como a memória, arquivos, janelas, portas de comunicação e

controles gráficos. É o sistema operacional que executa todas essas tarefas. A

aplicação se limita a realizar pedidos do que ela precisa ao sistema operacional.

Esses pedidos são feitos mediante o que se denomina a API8 do Windows, que é

um conjunto de funções que proporciona um sistema de comunicação entre o

programa aplicativo e o sistema operacional. Esse conjunto de funções é enorme,

pouco estruturado e relativamente difícil de manipular.

Por causa dessa dificuldade é que os vários entornos de programação

visual, com objetivo de fornecer simplicidade e estruturação à programação de

programas para Windows, têm desenvolvido diversos Marcos de Trabalho. Um

marco de trabalho é uma fase intermediária que se coloca acima da API para

fornecer maior simplicidade às aplicações. Normalmente esses marcos de

trabalho são orientados a objetos e se implementam como bibliotecas da

linguagem base, por isso também costumam ser chamadas de bibliotecas de

classes.

Os marcos de trabalho são tão importantes que dominar um entorno de

programação visual se traduz em conhecer a linguagem base do entorno e o seu

marco de trabalho (biblioteca de classes).

Os marcos de trabalho podem ser classificados em duas categorias:

� Os marcos de trabalho em C++ (OWL e MFC)

� A VCL

A OWL (Object Windows Library ou Biblioteca de Objetos para Windows) foi

um marco de trabalho desenvolvido pela Borland e incorporado aos compiladores

Borland C++ (versões 3 e subseqüentes) e estabeleceu um importante marco da

programação para Windows pela sua versatilidade e facilidade de uso.

A Microsoft™ desenvolveu o seu próprio marco de trabalho, o MFC

(Microsoft Foundation Class ou Biblioteca Fundamental de Classes de Microsoft) e

a incorporou aos compiladores Microsoft Visual C++. A MFC foi incluída também

8 API: Application Program Interface.

E N G E N H A R I A D E P R O C E S S A M E N T O D I G I T A L I I

85

no compilador Borland C++ 5. A MFC é uma biblioteca de classes menos abstrata

que a OWL e mais próxima da API. Também resulta mais simples que a OWL

para os programadores que conhecem a API. Embora a MFC seja mais usada que

a OWL a arquitetura desta última é tecnicamente melhor que a MFC.

Em 1995 a Borland lançou ao mercado o Delphi que se tornou uma

revolução na programação para Windows e tornou rápido e simples o

desenvolvimento de aplicações visuais. O Delphi oferecia o desenvolvimento

rápido de aplicações (RAD) utilizando componentes (objetos que podem colocar-

se nos quadros e de serem manipulados mediante as suas propriedades, métodos

e eventos). Esta forma de trabalho se tornou mais popular com o Visual Basic. O

Delphi utilizava como base a linguagem Object Pascal (uma ampliação do Pascal

que incorporava a programação orientada a objetos) e permitia a criação de

programas executáveis independentes que não requerem de interpretadores, fato

pelo qual eram mais rapidamente executados que os do Visual Basic.

O fato mais relevante desde o ponto de vista técnico é que a Borland criou

a VCL (Visual Class Library ou Biblioteca de Componentes Visuais) que é um

marco de trabalho para criar aplicações Windows desenhada em torno do

conceito de componente (propriedades, métodos e eventos). A VCL desenvolvida

para o Delphi é a mesma que se utiliza no núcleo do C++ Builder e, de fato, foi

escrita em Object Pascal.

Figura 4-1 – A VCL como interface.

A VCL faz uso extensivo do conceito de herança. O objetivo final da VCL é

criar classes que representem os componentes. Mesmo que algumas classes não

se referenciem a componentes concretos elas realizam tarefas de gestão interna e

utilizam classes base para derivar mediante herança outras classes. A Figura 4-2

mostra uma pequena parte da hierarquia de classes que formam a VCL. Nas

VCL

Aplicação

Windows


86

seções a seguir serão descritas com mais detalhes as classes mais importantes

da VCL.

Figura 4-2 – Hierarquia de classes da VCL.

44..11.. DDeettaallhheess ddaa VVCCLL Conhecer a VCL em profundidade parece impossível além de

desnecessário. É possível construir aplicações Windows de grande qualidade com

o C++ Builder sem precisar conhecer detalhadamente a VCL embora possa ser

considerado conveniente ter um conhecimento superficial da hierarquia de

classes que a formam.

As classes que formam a parte superior da hierarquia da VCL (TObject,

TPersistent e TComponent) são denominadas classes “abstratas” pois servem

para estrutura e agrupar o comportamento comum das classes da VCL. Não

costumam criar objetos diretamente a partir delas. Rigorosamente falando não

são classes abstratas da linguagem C++ por não ter métodos virtuais puros, mas

na prática podem ser consideradas como tais.


87

TObject

TPersistent

TComponent

TTimer, T... TControl

TGraphicControl TWinControl

TPaintBox,T... TButton, T...

Componentes não-visuais

Componentes visuais

Figura 4-3 - Resumo das classes base da VCL

44..11..11.. TTOObbjjeecctt É o ancestral de todas as classes da VCL. Encapsula o comportamento

comum dos objetos do C++ Builder, tais como as informações da classe,

instanciação, etc.

Costuma ser uma boa idéia derivar as próprias classes de TObject porque

mesmo que não seja usual que o programador faça uso dos métodos

proporcionados por esta classe, o uso pelo C++ Builder em tempo de execução o

faz.

Diretamente de TObject herdam aquelas classe que não são componentes

e não precisam ser armazenadas em disco.

44..11..22.. TTCCoommppoonneenntt Esta é uma das classes mais importantes da VCL porque a maioria dos

objetos que se manipulam em uma aplicação são os componentes. Esta classe

proporciona toda a funcionalidade que requer um componente básico. A

funcionalidade de TComponent permite que os objetos apareçam na paleta de

componentes e que sejam manipulados pelo editor de quadros, além de outras

capacidades comuns aos componentes.


88

Os componentes não-visuais derivam diretamente de TComponent

enquanto que os componentes visuais derivam de TControl, que por sua vez

deriva de TComponent. Por esta razão costuma se denominar de controles os

componentes visuais.

44..11..33.. TTPPeerrssiisstteenntt Esta classe tem a ver com a habilidade de um objeto se armazenar no

disco ou na memória, designar-se a outros objetos assim como outros detalhes

internos do C++ Builder que não vem ao caso conhecer agora.

44..11..44.. TTCCoonnttrrooll A classe TControl proporciona funcionalidades aos componentes visuais

(controles). Estas funcionalidades estão relacionadas com o aspecto visual dos

componentes em tempo de execução. A classe proporciona maior funcionalidade

que as geralmente requeridas pelos componentes visuais. Os componentes

individuais derivam de TGraphicControl ou de TWinControl, que são classes

derivadas de TControl.

44..11..55.. TTGGrraapphhiiccCCoonnttrrooll A classe TGraphicControl generaliza os controles que possuem uma

representação visual mas que não podem receber o foco. O usuário poderá vê-los

mas não poderá interagir com eles. Costumam ser controles para visualizar texto

(não editável em tempo de execução), gráficos ou desenhos. Possuem uma

propriedade Canvas que permite acessar à sua área de desenho.

44..11..66.. TTWWiinnCCoonnttrrooll A classe TWinControl implementa os controles típicos do Windows que

podem receber foco, conter outros controles e além disso, possui um

manipulador de janela.

Os controles de janela possuem as seguintes características:

� Os controles de janela são controles que podem receber foco enquanto a aplicação estiver sendo executada.

� Alguns controles podem mostrar dados assim como o usuário pode usar o teclado para interagir com o controle somente se o controle for de janela.

� Os controles de janela podem conter outros controles.

� Um controle pode conter outro controle como pai. Somente um controle de janela pode ser pai de um ou mais controles filhos.


89

44..22.. CCllaasssseess ddee QQuuaaddrrooss ee AApplliiccaaççõõeess São os basicamente controles, no entanto não são encontrados na paleta

de componentes.

44..22..11.. TTAApppplliiccaattiioonn A classe TApplication encapsula uma aplicação Windows e portanto

engloba as operações fundamentais de um programa Windows. A classe

TApplication simplifica a interface entre o programador e o sistema operacional,

ocupando-se das tarefas tais como a gestão do intercambio de mensagens,

proporcionar ajuda de contexto, estabelecer os hints (textos de sugestão) dos

botões e barras de status, processamento de teclas de atalho, gestão de exceções,

execução de quadro de mensagens, etc.

Todas as aplicações do C++ Builder têm um ponteiro para um objeto

TApplication denominado Application que é criado automaticamente. O

ponteiro Application não aparece na paleta de componentes e não está disponível

o inspetor de objetos para manipular “visualmente” as usas propriedades. De

qualquer forma, algumas propriedades podem ser estabelecidas em tempo de

design selecionando a opção de menu Project + Options nas abas Forms e

Application.

PPRROOPPRRIIEEDDAADDEESS DDAA CCLLAASSSSEE TTAAPPPPLLIICCAATTIIOONN Propriedade Descrição

Active Especifica se a aplicação está ativa e possui foco.

Hint e ShowHint Hint especifica o texto que deve aparecer no quadro de ajuda ou texto de sugestão

associado à aplicação. Este quadro aparece quando ocorre o evento OnHint. Por

default se mostra unicamente o quadro associado ao componente no qual o ponteiro

do mouse estiver apontando, em uma barra de status ou em um balão de informação.

A propriedade ShowHint determina se os quadros de sugestão estarão ativos ou

inativos para toda a aplicação.

MainForm e

ShowMainForm

MainForm especifica que quadro atua como janela principal da aplicação.

ShowMainForm especifica se a aplicação deve mostrar a janela principal ao iniciar a

execução. Para ocultá-la, deve se estabelecer esta propriedade para false antes da

chamada a Application->Run e ter certeza de que a propriedade Visible do

quadro esteja também em false.

Icon e Title Especificam o ícone e o texto que aparecem na barra de tarefas do Windows quando

se minimiza a aplicação. Podem ser estabelecidos em tempo de design usando a

opção de menu Project + Options + Application.

HelpFile e Serve para especificar o arquivo de Ajuda associado à aplicação.


90

CurrentHelpFile.

MMÉÉTTOODDOOSS DDAA CCLLAASSSSEE TTAAPPPPLLIICCAATTIIOONN Método Descrição

BringToFront() Estabelece a última janela ativa como a que se encontra por cima de todas as

demais.

CreateForm() Cria um novo quadro. Geralmente o programador usa este método porque a

criação de quadros é feita automaticamente pelo C++ Builder.

HelpCommand(),

HelpContext() e

HelpJump()

São utilizados para gerenciar a Ajuda associada a uma aplicação. Geram um

evento OnHelp e se não houver um gestor específico para este evento, é

gerenciado através de WinHelp.

MessageBox() Mostra uma mensagem ao usuário no quadro de diálogo que pode incorporar

botões. Devolve um valor dependendo do botão selecionado ao fechar o quadro

de diálogo.

Minimize() e

Restore()

Minimize() minimiza uma aplicação e a armazena na barra de tarefas do

Windows, enquanto que Restore() restabelece o tamanho que tinha a aplicação

antes de ser minimizada.

Run() e Terminate() Run() executa a aplicação, enquanto Terminate() termina a execução de uma

aplicação.

ShowException() Mostra um quadro de diálogo quando se produz uma exceção que não é

gerenciada pela aplicação. Para especificar quais exceções podem ser gerenciadas

pela aplicação deve ser construído um gerenciador para o evento OnException.

HandleException() Proporciona uma maneira de gerenciar exceções por default para a aplicação.

33.. EEVVEENNTTOOSS DDAA CCLLAASSSSEE TTAAPPPPLLIICCAATTIIOONN Evento Descrição

OnActivate e

OnDeactivate

Ocorrem quando se ativa ou desativa a aplicação respectivamente. Uma aplicação é

ativada quando se inicia a mesma (início da execução) ou quando estava ativa outra

aplicação e uma janela da aplicação a que se refere recebe o foco. Uma aplicação é

desativada quando o usuário seleciona outra aplicação.

OnHint e

OnShowHint

OnHint ocorre quando o cursor estiver sobre um controle ou uma opção de menu que

pode mostrar um quadro de sugestão. Costuma se escrever um gerenciador para este

evento quando se deseja mostrar um texto longo de sugestão na barra de status.

OnShowHint ocorre quando a aplicação for mostrar um quadro de sugestão. Pode

ser usado para modificar a aparência do quadro.

OnMinimize e

OnRestore

Ocorrem quando a aplicação é minimizada ou quando re-estabelece o seu tamanho

normal, respectivamente.

OnHelp Ocorre quando a aplicação recebe um pedido de Ajuda. Os métodos HelpContext() e

HelpJump() gerenciam automaticamente este evento.

OnException Se utilize quando se deseja modificar o comportamento default de uma aplicação no

acontecimento de alguma exceção que não é tratada pelo programa.

OnShortCut Ocorre quando se aperta uma tecla. Quando se aperta uma tecla se desencadeiam os

seguintes eventos, nesta ordem: OnKeyDown, OnKeyPress, OnKeyUp. Este

gerenciador é utilizado para realizar ações antes que o quadro ou os controles do

mesmo gerenciem os eventos oportunos ao aperto das teclas.


91

44..22..22.. TTFFoorrmm A classe TForm caracteriza os quadros na VCL. Os quadros se utilizam

como janelas principais, quadros de diálogo, janelas secundárias ou qualquer

outro tipo de janela que se possa imaginar.

PPRROOPPRRIIEEDDAADDEESS DDOOSS QQUUAADDRROOSS

PropPropPropPropriedades eiedades eiedades eiedades em tempo de design e execução Propriedade Descrição

ActiveControl Estabelece qual componente possui o foco quando se abre o quadro.

Enabled Indica se o quadro está ativo (se pode receber o foco)

AutoScroll,

HorzScrollBar e

VertScrollBar

Controlam conjuntamente as barras de deslocamento de um quadro.

BorderIcons Indica quais ícones aparecem na barra do título do quadro (ícones de maximizar,

minimizar, etc.)

BorderStyle Indica o tipo de borda do quadro.

Caption e Name Caption indica a string que aparecerá na barra de título da janela e Name indica o

nome que referencia o quadro na aplicação (no código).

Color Estabelece a cor de fundo da janela.

Cursor Especifica que tipo de cursor será mostrado quando o apontador do mouse estiver

sobre a janela.

Font Permite especificar as propriedades da fonte de letra que se usará na janela. Se aplica

a todos os componentes colocados na janela.

Icon Estabelece o ícone que se verá na barra de título quando se mostrar a janela em

tempo de execução e quando estiver minimizada.

Height e Width Define a altura e largura (em píxeis) da janela.

ClientWidth y

ClientHeight

Define a altura e largura em píxeis da área cliente da janela (área cliente é a que fica

dentro das bordas da janela e por debaixo da barra do título e do menu). Ao modificar

estas propriedades se atualizam as variáveis Width e Height.

Left e Top São as coordenadas X e Y da janela referenciada ao canto superior esquerdo na tela.

Position Determina o tamanho e a posição da janela.

FormStyle Especifica se uma janela é parte ou não de uma aplicação MDI (multiple document

interface – aplicação de janelas múltiplas).

HelpFile e

HelpContext

Especifica o arquivo de ajuda associado à aplicação e gerencia a ajuda de contexto.

Hint e

ShowHint

Hint especifica o texto que deve aparecer na janela de ajuda ou o texto de sugestão

associado. Esta janela aparece quando ocorrer o evento OnHint. Por default aparece o

quadro associado ao componente onde estiver o cursor do mouse.

ShowHint determina se os balões de sugestão estão ativos ou não na janela.

Visible Indica se a janela é visível ou não. Os métodos Show() e ShowModal() fazem que a

janela seja visível e a colocam sobre todas as demais.

WindowState Serve para estabelecer o estado inicial da janela (normal, minimizada ou maximizada)

ou para consultar o seu estado.


92

1.2. Propriedades em tempo de execução Propriedade Descrição

Active Indica se a janela está ativa (se tem foco)

Canvas É uma tela de desenho na janela sobre a qual pode se desenhar. A propriedade

Canvas fornece acesso a esta superfície para desenhar linhas, mapas de bits,

textos, etc., dentro da área cliente. Costuma se usar junto ao gerenciador do

evento OnPaint.

ClientRect Coordenadas dos quatro pontos que delimitam a área cliente da janela.

ModalResult Valor devolvido quando se fecha uma janela modal (aberta com o método

ShowModal().

FormState Fornece informação sobre o estado em que se encontra a janela (se está sendo

criada, se é visível, se é modal, etc.)

MMÉÉTTOODDOOSS DDOOSS QQUUAADDRROOSS Propriedade Descrição

BringToFront() e

SendToBack()

Coloca a janela em primeiro plano ou em último, respectivamente.

Hide() Oculta a janela (estabelece a propriedade Visible para false.

Print() Imprime o conteúdo da janela.

Show() e

ShowModal()

Para mostrar janelas. ShowModal() executa (abre) a janela modalmente: deve ser

fechada para que o usuário possa seguir trabalhando com a aplicação

Close() e

CloseQuery()

Close() fecha a janela depois de chamar CloseQuery() para assegurar que a janela

deve ser efetivamente fechada. Esta última chama o manipulador do evento

OnCloseQuery.

SetFocus() Ativa a janela e a coloca em primeiro plano, colocando a propriedade Active em

true. Além disto, o componente especificado com a propriedade ActiveControl

receberá o foco.

CanFocus() Retorna true se a janela pode receber o foco (se as propriedades Visible e Enabled

estiverem com valor true)

SetBounds() Estabelece simultaneamente os valores das propriedades Top, Left, Width e

Height.

ClientToScreen() e

ScreenToClient()

Converte as coordenadas da área cliente em coordenadas de tela e vice-versa.

Invalidate(),

Refresh(),

Repaint() e

Update()

Redesenha a janela

Release() Destrói a janela e libera a memória associada.

EEVVEENNTTOOSS DDOOSS QQUUAADDRROOSS Uma ação pode desencadear vários eventos e a ordem em que esses

ocorrem pode ser importante.


93

Sobre os eventos associados à criação e destruição de janelas

Quando se cria uma janela se geram os eventos na ordem que segue:

1. O construtor da janela.

2. OnCreate.

3. OnShow.

4. OnActivate.

5. OnPaint.

Da mesma forma, quando se destrói a janela se geram os seguintes

eventos:

1. OnCloseQuery.

2. OnClose.

3. OnDestroy.

4. O destrutor da janela (se existir).

Sobre os eventos associados a ação do mouse

Os eventos do mouse apresentam certas particularidades que se devem

conhecer. Para atender o clique do mouse sobre uma janela ou controle, deve se

atender o evento OnClick.

Se tiver que usar os eventos OnMouseDown e OnMouseUp deve se levar

em conta que OnClick engloba também esses dois eventos. Desta forma, o fato

de pressionar um botão do mouse gera os seguintes eventos:

1. OnMouseDown.

2. OnClick.

3. OnMouseUp.

Da mesma forma, quando o usuário clicar duas vezes sobre uma janela ou

controle se geram os seguintes eventos:

1. OnMouseDown.

2. OnClick.

3. OnDblClick.


94

4. OnMouseUp.

Sobre os eventos associados à ação do teclado

Quando se pressiona uma tecla se desencadeiam os seguintes eventos,

nesta ordem:

1. OnKeyDown,

2. OnKeyPress

3. OnKeyUp

Propriedade Descrição

OnActivate e

OnDeactivate

Ocorrem quando se ativa ou desativa uma janela, respectivamente. Uma janela se

ativa quando recebe o foco e se desativa quando o foco passa para outra janela da

mesma aplicação.

OnCreate e

OnDestroy

OnCreate ocorre quando se cria inicialmente a janela (somente ocorre um evento

deste tipo por janela) e OnDestroy quando se destrói a mesma.

OnClose e

OnCloseQuery

O evento OnClose ocorre quando se fecha a janela. Faz uma chamada a

OnCloseQuery para ter certeza que se deseja fechar a janela.

OnMouseDown,

OnMouseMove,

OnMouseUp,

OnClick e

OnDblClick

Para responder aos eventos de movimento do mouse ou quando se clica encima da

janela.

OnKeyDown,

OnKeyUp e

OnKeyPress

Para responder aos eventos que sucedem ao apertar alguma tecla sobre a janela.

OnHelp Ocorre quando se recebe o pedido de Ajuda na janela.

OnHide e

OnShow

Ocorrem quando a janela se oculta ou reaparece respectivamente (quando a

propriedade Visible for estabelecida para false ou true respectivamente).

OnShow ocorre justamente antes de que a janela se faça visível.

OnPaint Ocorre quando a janela precisar ser redesenhada (refresh). Isto ocorre

freqüentemente e mesmo que os componentes se redesenhem eles mesmos

geralmente, às vezes é preciso redesenhar “manualmente” a janela.

Ocorre antes que qualquer controle seja redesenhado.

OnResize Ocorre quando se modifica o tamanho da janela, justo depois de redimensionar a

mesma.

OnShortCut Ocorre quando se pressiona uma tecla, antes que ocorra OnKeyDown.

44..33.. CCllaasssseess ddee CCoommppoonneenntteess Este grupo abarca um amplo espectro de classes. Basicamente incorpora

todos os componentes que aparecem na paleta de componentes do IDE do

C++Builder.


95

44..33..11.. PPrrooppiieeddaaddeess ddee llooss CCoommppoonneenntteess Mesmo que cada componente tenha as suas próprias propriedades,

métodos e eventos, existem algumas propriedades que são comuns.

PPRROOPPRRIIEEDDAADDEESS CCOOMMUUNNSS MMAAIISS IIMMPPOORRTTAANNTTEESS Propriedade Descrição

Align Estabelece distintas posições e ajustes do componente relativos ao componente

que o contém.

Caption e

Name

Caption indica o texto que acompanha a alguns componentes.

Name indica o nome do identificador que se designa ao componente no programa

e com ele se referenciará o componente na aplicação (no código).

O C++ Builder usará o valor da propriedade Name para criar um ponteiro que

referenciará o componente.

Color Se refere à cor de fundo do componente.

Cursor Estabelece que ícone irá aparecer quando o usuário mover o cursor do mouse

sobre um componente.

Font Permite especificar as propriedades da fonte de letra que se usará no componente.

Enabled Para ativar e desativar componentes: quando um componente se desativa não

pode receber o foco, não responde ao mouse, nem o teclado e nem a eventos do

temporizador.

Hint e

ShowHint

Hint especifica o texto que deve aparecer no quadro de ajuda ou texto de sugestão

associado a um componente. Possui duas partes separadas pela barra |. A

primeira (sugestão breve) se visualiza quando o usuário coloca o apontador do

mouse sobre o componente. A segunda se apresenta na barra de status. Esta

informação aparece quando ocorre o evento OnHint.

ShowHint determina se a ajuda de sugestão breve deve ou não ser mostrada.

ParentColor,

ParentFont y

ParentShowHint

Quando estiverem em true, herdam o valor para a propriedade à qual fazem

referência do componente ancestral. Em outros casos, utilizam o valor que foi

estabelecido para esta propriedade.

Visible Indica se o componente é visível ou não.

OOUUTTRRAASS PPRROOPPRRIIEEDDAADDEESS DDEE UUSSOO CCOORRRREENNTTEE As seguintes propriedades, embora sejam freqüentemente utilizadas não

estão disponíveis para todos os componentes.


BorderStyle Para diferenciar o componente da janela ou integrá-lo no seu fundo.

Height y Width Altura e largura e largura (em píxeis) do componente.

HelpContext Para associar um número de índice de um arquivo de ajuda a um componente.

Left y Top Coordenadas X e Y do componente (canto superior esquerdo).

TabOrder y

TabStop

Para estabelecer a ordem de tabulação e determinar se o componente faz ou não

parte da seqüência de tabulação, respectivamente.


96

44..33..22.. MMééttooddooss ddooss ccoommppoonneenntteess Não são usualmente utilizadas porque as ações que realizam se efetuam

modificando diretamente as propriedades do componente.


ClientToScreen() e

ScreenToClient()

Converte as coordenadas da área cliente em coordenadas de tela e vice-versa.

Hide() e

Show()

Hide() oculta o componente. Pode voltar a ser visível posteriormente com Show().

Ambos métodos modificam a propriedade Visible.

Invalidate(),

Refresh(),

Repaint() e

Update()

Redesenha um componente.

SetBounds() Estabelece simultaneamente os valores das propriedades Top, Left, Width e

Height.

SetFocus() Situa o foco sobre um componente y o converte em componente ativo.

CanFocus() Devolve true se o componente pode receber o foco (se as propriedades Visible e

Enabled estão true).

44..33..33.. EEvveennttooss ddooss ccoommppoonneenntteess Uma ação pode desencadear vários eventos e a ordem em que esses

ocorrem pode ser importante.

Sobre os eventos associados à ação do teclado Propriedade Descrição

OnMouseDown,

OnMouseMove,

OnMouseUp,

OnClick e

OnDblClick

Para responder aos eventos que sucedem ao mover o mouse ou quando se

pressiona o botão do mesmo sobre o componente.

OnEnter e

OnExit

OnEnter ocorre quando se ativa um componente (recebe o foco) sempre que o

foco se transfira desde outro componente da mesma janela.

OnExit ocorre quando o componente perde o foco, sempre que o foco se transfira a

outro componente da mesma janela.

OnKeyDown,

OnKeyUp e

OnKeyPress

Para responder aos eventos que sucedem ao pressionar alguma tecla quando o

foco está em um componente.

OnPaint Este evento ocorre quando um objeto tem de ser redesenhado. Se o objeto for um

PaintBox, este gerenciador se encarregará de desenhar sobre o Canvas e se não

existir este gerenciador, o PaintBox não será visualizado em tempo de execução.

Sobre los eventos associados à ação do mouse


97

Os eventos do mouse apresentam certas particularidades que se devem

conhecer. Para atender o clique do mouse sobre uma janela ou controle, deve se

atender o evento OnClick.

Se tiver que usar os eventos OnMouseDown e OnMouseUp deve se levar

em conta que OnClick engloba também esses dois eventos. Desta forma, o fato

de pressionar um botão do mouse gera os seguintes eventos:

4. OnMouseDown.

5. OnClick.

6. OnMouseUp.

Da mesma forma, quando o usuário clicar duas vezes sobre uma janela ou

controle se geram os seguintes eventos:

5. OnMouseDown.

6. OnClick.

7. OnDblClick.

8. OnMouseUp.

Sobre os eventos associados à ação do teclado

Quando se pressiona uma tecla se desencadeiam os seguintes eventos,

nesta ordem:

1. OnKeyDown,

2. OnKeyPress

3. OnKeyUp

44..44.. RReessttrriiççõõeess ddee uussoo ddaa VVCCLL nnoo CC++++

BBuuiillddeerr A VCL foi desenvolvida originalmente em e para o Delphi, pelo que foi

construída em Object Pascal. Embora isto não suponha normalmente

considerações especiais, existem alguns aspectos que devem ser levados em

conta:

� Os objetos da VCL devem ser criados sempre dinamicamente (usando o operador new). Isto é assim porque eles devem estar localizados no heap e não na pilha.


98

� A VCL não designa valores default às funções.

� Não se pode usar herança múltipla com as classes VCL.

44..55.. EExxeerrccíícciioo -- QQuuaaddrroo NNeeggrroo 1. Criar e configurar um novo projeto usando a opção de menu File

+ New Application.

2. Alterar os nomes default para UQuadroN.cpp e QuadroNegro.bpr

usando a opção de menu File + Save Project As… Observar que o

arquivo de cabeçalho Unit1.h foi alterado automaticamente para

UQuadroN.h.

3. Alterar o nome e título do quadro principal. Com o Inspetor de

Objetos alterar a propriedade Caption de “Form1” para “Quadro

Negro” e a propriedade Name de “Form1” para “MainForm”.

4. Dar um nome para a aplicação e definer o ícone. Para isto usar a

opção de menu Project + Options na aba Application.

5. Configurar a janela principal para ter o seguinte aspecto:


99

Fixar manualmente o tamanho da janela para 300 x 400 (Height = 300 y

Width = 400). A janela possui três componentes:

Na parte superior alinhado por cima, um PaintBox (barra de objetos: aba

System). Fixar as propriedades deste objeto Name = PaintBox, Align = alTop y

Height = 225.

Por baixo do objeto PaintBox, um componente Bevel (barra de objetos:

aba Additional). Fixar as seguintes propriedades: Name = Linha, Align = alTop,

Style = bsLowered y Height = 8.

Por baixo do objeto Bevel, centrado horizontalmente, um componente

BitBtn (barra de objetos: aba Additional). Fixar as seguintes propriedades:

Name = ExitBtn, Kind = bkClose y Caption = &Sair.

6. Escrever o código. Primeiro escrever o código associado ao evento

OnPaint do componente PaintBox. Selecionar no inspetor de objetos o

componente e depois de selecionar a aba Events fazer duplo clique no

gerenciador de eventos OnPaint. O gerenciador deste evento ficará como

segue:

//----------------------------------------------------------- void __fastcall TMainForm::PaintBoxPaint(TObject *Sender) { // Desenha um circulo PaintBox->Canvas->Pen->Color = clBlack; PaintBox->Canvas->Brush->Color = clYellow; PaintBox->Canvas->Ellipse (100, 100, 150, 150); // Desenha um quadrado PaintBox->Canvas->Pen->Color = clRed;


100

PaintBox->Canvas->Brush->Color = clRed; PaintBox->Canvas->Rectangle (200, 100, 250, 150); } //-----------------------------------------------------------

7. Para finalizar, escrever o código associado ao evento OnClick do

componente BitBtn. Selecionar no inspetor de objetos o componente e

depois de selecionar a aba Events fazer duplo clique no gerenciador de

eventos OnClick. O gerenciador deste evento ficará como segue:

//----------------------------------------------------------- void __fastcall TMainForm::ExitBtnClick(TObject *Sender) { Application->Terminate(); } //-----------------------------------------------------------

8. Gerar o executável usando F9. O resultado será o seguinte:

44..66.. EExxeerrccíícciioo -- CCoonnssttrruuççããoo ddee uummaa

AApplliiccaaççããoo uussaannddoo oo ccoommppoonneennttee

TTEEddiitt 1. O primeiro passo é criar um novo projeto usando a opçao de menu File +

New Application. Salvar o projeto numa nova pasta usando a opção de menu File + Save Project As... Para a Unit1.cpp alterar para FuncsEdicao.cpp e para Project1.bpr usar Edicao.bpr. Observar que Unit1.h será alterada automaticamente para FuncsEdicao.h.

2. Alterar o nome e o título do quadro principal: usando o Inspetor de Objetos alterar a propriedade Caption do quadro para “Controles de Edição” e a propriedade Name por MainForm.


101

3. Dar um nome para a aplicação e fixar um ícone (Project + Options + Application). Dar como tíulo: “Controles de Edição” e alterar o ícone.

4. A seguir construir o executável a ser testado: selecionar Project + Build Edit e depois Run + Run.

5. Configurar o quadro principal para ter o seguinte aspecto:

6. Este quadro contém tres objetos TLabel (aba Standard), três objetos TEdit (aba Standard) e dois objetos TBitBtn (aba Additional). Usando o Inspetor de Objetos alterar esses objetos (TLabel: Caption; TEdit: Text; BitBtn: Caption e Kind) para que o quadro apareça da seguinte forma:

7. Usando o Inspetor de Objetos alterar a propriedade Name dos objetos da seguinte forma: BotaoOK, BotaoSair, EditNome, EditSobr1, EditSobr2.

8. Criar um novo quadro para o projeto usando a opção e menu File + New Form. Alterar as propriedades Name = CxMensagem e Caption = Quadro de Mensagem.

9. Salvar o quadro (File + Save All) ulterando Unit1.cpp por CxMens.cpp. Alterar o aspecto do novo quadro para ficar da seguinte maneira:

10. Colocar um objeto TLabel no novo quadro.


102

11. Agora, usando o Inspetor de Eventos (aba Events do Inspetor de Objetos) faça duplo clique no OnClick do componente BotaoOK. No gerenciador do evento OnClick escreva o seguinte código:

//--------------------------------------------------------------------------- void __fastcall TMainForm::BotaoOKClick(TObject *Sender) { if (EditNome->Text == "" || EditSobr1->Text == "" || EditSobr2->Text == "" ) { Application->MessageBox ("Deve especificar todos os campos", "Erro na entrada de dados", MB_OK); } else { CxMensagem->Label1->Caption = "Bem-vindo, " + EditNome->Text + " " + EditSobr1->Text + " " + EditSobr2->Text; CxMensagem->Show(); EditNome->Text = ""; EditSobr1->Text = ""; EditSobr2->Text = ""; EditNome->SetFocus(); } } //---------------------------------------------------------------------------

12. Gerar o executável (opção de menu Project + Build Edit e depois Run + Run). Observar que acontece um erro de compilação:

[C++ Error] FuncsEdicao.cpp(27): E2451 Undefined symbol 'CxMensagem'

Este erro é bastante simples e acontece frequentemente. Isso acontece porque o módulo FuncsEdicao.cpp (que inclui FuncsEdicao.h) não contém declarações sobre o último quadro CxMens.cpp (que inclui o CxMens.h). Em outras palavras, FuncsEdicao não conhece CxMens. Para que haja este enlace pode se usar a opção de menu File + Include Unit Hdr... e escolher o arquivo CxMens.h. Observar que foi incluida a linha #include "CxMens.h" em FuncsEdicao.cpp.


103

13. Votar a executar o programa. Para:

Pressionando o botão OK deverá aparecer:

EEXXEERRCCÍÍCCIIOOSS AADDIICCIIOONNAAIISS 1. É pouco profisisonal que a única possibilidade de fechar uma janela seja

pressionando o botão do canto superior direito da mesma. Adicionar no quadro CxMens um botão para fechá-lo.

2. Alterar o código associado ao método BotaoOKClick para que a janela de mensagem seja executada de forma modal.


104

44..77.. EExxeerrccíícciioo -- UUmm EEddiittoorr ddee TTeexxttooss Neste exemplo se explica como criar rapidamente uma aplicação Windows

usando o C++ Builder. A aplicação a ser apresentada consiste de um editor de

textos com boa funcionalidade embora possa (e deva) ser melhorado. Esta não é

uma aplicação fechada, muito pelo contrário, e deve ser usada para adicionar

novas funcionalidades, o que lhe permitirá ampliar os seus conhecimentos sobre

a programação de aplicações visuais com C++ Builder. Este exercício é estrurado

da seguinte forma:

CCRRIIAARR EE CCOONNFFIIGGUURRAARR OO PPRROOJJEETTOO Aqui se mostra com criar um projeto (conjunto de arquivos de programa e

quadros associados a uma aplicação) e como configurá-lo. Basicamente, a

associar nomes representatives dos arquivos e descartando àqueles que o C++

Builder associa por default.

3. Para iniciar, criar uma nova pasta chamada ExemploEditor. Criar um novo projeto (menu File + New Application), salvar em uma nova pasta (File + Save Project As…). Para Unit1.cpp usar FuncsEditor.cpp e para Project1.bpr usar MeuEditor.bpr.

4. No quadro principal alterar a propriedade Caption no Inspetor de Objetos para “Meu Editor de Texto” e a propriedade Name por MainForm.

5. Dar um nome para a aplicação e selecionar um ícone (Project + Options + Application).

6. Construir e executar a aplicação (Project + Build Meu Editor e depois Run + Run).

CCOONNFFIIGGUURRAARR OO QQUUAADDRROO PPRRIINNCCIIPPAALL Aqui se mostra em detalhes como configurar o quadro, desde adicionar

uma barra rápida até outras janelas de diálogo. Nesta seção se apresentam os

componentes comuns de uma aplicação Windows.

7. Adicionar um componente TMemo: selecionar na paleta Standard de componentes o componente Memo. Colocá-lo sobre o quadro (sem se preocupar com o seu tamanho e nem do seu alinhamento). Alterar a propriedade Name por Memo; selecionar a propriedade Lines e limpar o seu conteúdo no editor de strings. Salvar com File + Save All.

8. Adicionar uma barra de acesso rápido (componente Bevel): Selecionar o componente Bevel (aba Additional) alterando as propriedades Name = Bevel, Height = 2 e Align = alTop.

9. Criar um painel para agrupar os botões da barra de acesso rápido: Selecionar um componente Panel (aba Standard) e colocá-lo em qualquer lugar do quadro. Definir as seguintes propriedades: Name = Speed Bar, Height = 32, BevelOuter = bvNone, Caption = deixar em branco, Align = alTop.


105

10. Colocar os botões de acesso rápido na barra: serão colocados três botões; Abrir, Salvar e Sair. Para o botão Abrir, selecionar um componente SpeedButton (aba Additional) e colocar sobre o painel. Alterar as propriedades: Name = FileOpenBtn, Left = 4; Glyph = inserir uma imagem em bitmap que represente Abrir Arquivo.

11. Repetir o passo acima para adicionar mais dos botões: Salvar Arquivo (Name = FileSaveBtn, Glyph = um bitmap adequado, Left = 32) e Sair (Name = ExitBtn, Left = 60 e Glyph = um bitmap adequado).

12. Adicionar uma barra de status selecionando o componente StatusBar (aba Win32). Fixar a propriedade Name = StatusBar.

13. Ajustar o componente Memo fixando a propriedade Align = alClient. Adicionar uma barra de scroll vertical ajustando a propriedade ScrollBars = ssVertical.


106

14. Adicionar os componentes não visuais OpenDialog e SaveDialog em qualquer local do quadro (aba Dialogs). Alterar as propriedades Name = OpenDialog e SaveDialog respectivamente. Esses componentes não aparecem visualmente em tempo de execução.

15. Salve todos os arquivos (File + Save All) e execute a aplicação (Run + Run).

AADDIICCIIOONNAARR MMEENNUUSS AAOO QQUUAADDRROO PPRRIINNCCIIPPAALL Nesta seção mostraremos algumas técnicas de inserção de menus e

submenús e ainda como incorporar menus de contexto.

16. Adicionar um menu ao quadro usando o componente não visual MainMenu (aba Standard) e colocá-lo em qualquer lugar do mesmo. Fixar a propriedade Name = MainMenu.


107

17. Para desenhar o menu clique duas vezes no objeto MainMenu e abrirá a ferramenta de desenho de menus.

18. Para criar os cabeçalhos na ferramenta de desenho de menus simplesmente escreva Arquivo, Editar e Ajuda na propriedade Caption de cada item cuja edição se ativa com o clique do mouse (cada item de menu é um objeto TMenuItem). Alterar as propriedades dos objetos de menu para Arquivo: Name = FileMenu, Caption = &Arquivo; Editar: Name = EditMenu, Caption = &Editar; Ajuda: Name = HelpMenu, Caption = A&juda.


108

19. Menu Arquivo: adicionar as opções Novo, Abrir, Salvar, Salvar como, (separador), Imprimir, Configurar Impressora, (separador) e Sair.

� Novo: Name = FileNew e Caption = &Novo

� Abrir: Name = FileOpen e Caption = &Abrir,

� Salvar: Name = FileSave e Caption = &Salvar,

� Salvar como: Name = FileSaveAs e Caption = Sa&lvar como ...,

� Incluir um separador: Caption = - ,

� Imprimir: Name = FilePrint, Caption = &Imprimir e Enabled = false,

� Configurar Impressora: Name = FilePrintSetUp, Caption = &Configurar Impressora e Enabled = false,


� Sair: Name = FileExit e Caption = Sai&r .

20. Menu Editar: adicionar as opções Desfazer, (separador), Recortar, Copiar, Colar, Selecionar tudo, (separador), Localizar, Substituir, (separador) e Ajustar.

� Desfazer: Name = EditUndo, Caption = &Desfazer, ShortCut = Ctrl+Z

� Incluir un separador: Caption = -

� Recortar: Name = EditCut, Caption = Recor&tar e ShortCut = Ctrl+X,

� Copiar: Name=EditCopy, Caption = &Copiar e ShortCut = Ctrl+C,

� Colar: Name = EditPaste, Caption = C&olar e ShortCut = Ctrl+V,

� Selecionar tudo: Name = EditSelectAll, Caption = &Selecionar tudo e ShortCut = Ctrl+A,



109

� Localizar: Name = EditFind, Caption = &Localizar e Enabled = false,

� Substituir: Name = EditReplace, Caption = Su&bstituir e Enabled=false


� Ajustar: Name = EditWordWrap, Caption = &Ajustare e Checked=true.

21. Menu Ajuda: adicionar uma opção Sobre... estabelecendo as propriedades Name = HelpAbout e Caption = Sobre Meu Editor.

22. Finalmente, fechar a ferramenta de desenho de menus. O aspecto do quadro deverá ser o seguinte:

23. O Menu de Contexto: para criar um menu de contexto selecionar o componente não-visual PopUpMenu (aba Standard) e colocar em alguma parte do quadro. Fixar a propriedade Name = PopUpMenu. Este menu é desenhado da mesma forma que o menu principal. Adicionar as opções:


110

Recortar, Copiar, Colar, (separador) e Sobre.... Ajustar as propriedades para:

� Recortar: Name = PopUpCut, Caption = Recortar e ShortCut=Ctrl+X,

� Copiar: Name = PopUpCopy, Caption = &Copiar e ShortCut = Ctrl+C,

� Colar: Name = PopUpPaste, Caption = Colar e ShortCut = Ctrl+V,


� Sobre ... : Name = PopUpAbout e Caption = Sobre... .

O menu de contexto pode ser associado a qualquer componente que tenha associada a propriedade PopupMenu. Neste caso será associada ao componente Memo para que ao clicar no botão direito do mouse abra o menu que acabou de ser criado. Para isto no Inspetor de Objetos para o objeto Memo alterar a propriedade PopupMenu para selecionar PopupMenu (única disponível neste caso).

EESSCCRREEVVEERR OO CCÓÓDDIIGGOO DDOO PPRROOGGRRAAMMAA Despois de desenhado o quadro temos que escrever o código C++ dos

manipuladores de eventos associados aos componentes. Cada opção de menu e

cada botão da barra de acesso rápido deve ter associada uma ação. A ação se

associa a cada componente mediante o gerenciador de eventos no Inspetor de

Objetos.

Todos os manipuladores de eventos se escrevem com uma metodologia

similar. A seguir, detalharemos como se faz a opção Arquivo + Sair e os demais

se completarão seguindo as linhas aqui descritas.

No quadro principal, no modo de edição, selecionar a opção do menu

Arquivo + Sair com um clique do mouse. Ao fazer isto será gerado o seguinte

código onde serão colocados os comandos respectivos a esta ação.

//--------------------------------------------------------------------------- void __fastcall TMainForm::FileExitClick(TObject *Sender) {


111

} //---------------------------------------------------------------------------

Preencher a função do gerenciador do evento da seguinte forma:

//--------------------------------------------------------------------------- void __fastcall TMainForm:: FileExitClick(TObject *Sender) { Application->Terminate(); } //---------------------------------------------------------------------------

Para que o botão rápido ExitBtn realize a mesma tarefa, pode lhe ser

atribuída a mesma função no seu evento OnClick. Para isto, selecionar o

componente ExitBtn no Inspetor de Objetos, na aba Events e no evento OnClick.

Agora a função FileExitClick() pode ser ativada desde a opção de menu Arquivo +

Sair ou desde o botão rápido ExitBtn.

Para cada opção do menu se procede da mesma forma. Assim o resultado

final deverá ser:

� Opção de menu: Arquivo + Novo

� Opção de menu: Arquivo + Novo

� Opção de menu: Arquivo + Abrir e botão rápido FileOpenBtn

� Opção de menu: Arquivo + Salvar e botão rápido FileSaveBtn

� Opção de menu: Arquivo + Salvar como

� Opção de menu: Editar + Desfazer

� Opção de menu: Editar + Cortar e Cortar do menu de contexto.

� Opção de menu: Editar + Copiar e Copiar do menu de contexto

� Opção de menu: Editar + Colar e Colar do menu de contexto

� Opção de menu: Editar + Selecionar tudo

� Opção de menu: Editar + Ajustar

AADDIICCIIOONNAARR UUMM NNOOVVOO QQUUAADDRROO ((SSOOBBRREE ......)) A seguir mostramos como se podem adicionar novos quadros à sua

aplicação.


112

24. Adicionar um novo quadro (Sobre…) selecionando a opção de menu File + New Form. Sobre este quadro desenhar uma janela modal com o título Sobre o Meu Editor de Textos para ficar com o seguinte aspecto mostrado a seguir.

25. Fixar as proprieades Caption = Sobre o Meu Editor de Texto, Name = AboutBox e Border Style = bsDialog.

26. Adicionar três componentes Label (aba Standard) com textos “Meu Editor e Texto”, “Versão 1.0” e “©EPD II”.

27. Adicionar um ícone selecionando um componente Image (aba Additional). Para esse componente fixar Autosize = true.

28. Adicionar um botão de OK. Usar o componente BitBtn (aba Additional). Fixar Kind = bkOK.

29. Adicionar um marco que englobe os objetos Label usando a opção Bevel (aba Additional).


113

30. Salvar a unidade com File + Save e dar o nome de UAbout.cpp. 31. Adicionar esta unidade ao projeto. Selecionar FuncsEditor.cpp no Editor de Código e então a opção de menu File + Include Unit Hdr. Selecionar UAbout.

32. Agora, quando seja selecionado no programa Ajuda + Sobre Meu Editor no menu principal ou Sobre… no menu de contexto deve ser abrir a nova janela criada. Para isto selecionar a opção do programa Ajuda + Sobre Meu Editor e completar o manipulador HelpAboutClick() da seguinte forma:

//--------------------------------------------------------------------------- void __fastcall TMainForm::HelpAboutClick(TObject *Sender) { AboutBox->ShowModal(); } //---------------------------------------------------------------------------

12. Designar a mesma função ao gerenciador do evento OnClick do PopUpAbout.

33. Finalmente, construa o executável e teste o projeto. 34. A estutura do projeto deve estar como a figura a seguir.


114

AADDIICCIIOONNAANNDDOO UUMMAA BBAARRRRAA DDEE SSTTAATTUUSS EE BBAALLÕÕEESS DDEE HHIINNTTSS

A seguir mostraremos como adicionar hints aos botões rápidos e como

mostrar informações na barra de status.

35. Para associar um componente a um balão de hint deve se fixar a propriedade Hint do mesmo ao texto que se deseja mostrar quando o ponteiro do mouse estiver encima do mesmo. Para mostrar um texto mais amplo na barra de status, este deve ser especificado também na mesma propriedade separado pela barra |. Por exemplo, selecionar o botão FileOpenBtn e fixar a proprieade Hint = Abrir arquivo | Abrir um arquivo existente e ShowHint = true. Salvar e executar o projeto.

36. Observar que colocando o cursor sobre o botão aparece um balão do hint mas nada na barra de status. Alterar as propriedades Hint dos botões FileSaveBtn e ExitBtn para Salvar Arquivo | Salvar em arquivo o texto mostrado e Sair | Terminar a execução do programa, respectivamente, e colocando as duas propriedades ShowHint = true.

37. Para que apareça o texto comprido na barra de status, bastca com estabelecer a propriedade AutoHint do mesmo para true.

38. Finalmente, construir e executar o projeto.


115

Documents

04-VCL-C++BuilderV10