estrutura seqüencial - eisnt.org+/manuais/06_estrutura_sequencial.pdf · estrutura seqüencial 55...

EstruturaSeqüencial

Uma estrutura seqüencial é aquela na qual uma linha é executada uma após a outra. É a maneira mais simples de programação e é utili-zada em conjunto com estruturas de seleção (condicional) e repetição, abordadas mais à frente.

Objetivando um padrão único de trabalho inicial no que diz respeito às resoluções de problemas, cada enunciado tem sua explicação deta-lhada nas seguintes partes:

• Uma Análise sobre o Problema: Responsável por uma explana-ção sobre o enunciado e esclarecimento sobre o problema.

• Interface Gráfica com o Usuário (GUI) e o seu Funcionamento:

Responsável pelo detalhamento esperado para a Interface Gráfi-ca com o Usuário e como ela deverá funcionar (interagir).

• Sobre a Implementação: Responsável pelo detalham ento da implementação da solução. Detalhes que merecem uma atenção maior sobre a lógica e recursos utilizados são trabalhados nesse ponto.

6.1 ConceitualizaçãoNo cap ítu lo an terio r, quando foi ap resen tad a a p rim eira

implementação, foi possível verificar que todos os comandos inseridos, tanto de forma automática pela linguagem (quando componentes são inseridos) como manualmente pelo desenvolvedor, estão em uma for-ma seqüencial, uma após a outra.

Praticamente todas as linguagens trabalham com comandos ou ins-truções seqüenciais individualmente ou, ainda, associada a outras es-truturas, tais como condicionais ou de repetição.

Os problemas apresentados neste capítulo trabalham apenas a for-ma seqüencial, sendo que as formas associadas estão nos capítulos seguintes.

52 C++ Builder: Implementação de Algoritmos e Técnicas para Ambientes Visuais

6.2 Problema 1: Troca de Valores entre Variáveis

Enunciado 6.1

Im p le m e n te u m a lg o r i tm o q u e s o l ic ite a o u s u á r io d o is v a lo re s e e fe tu e

a t r o c a d e le s e n t re a s v a r iá v e is d e e n t ra d a .

6.2.1 Analisando o Problema

A troca solicitada refere-se ao processo de inverter entre as variáveis os valores existentes em cada uma delas. Por exemplo, a variável que recebe o primeiro valor deverá ter em si o segundo valor informado e armazenado na segunda variável, e a segunda variável deverá ter o valor informado e armazenado na primeira variável.

6.2.2 A Interface Gráfica com o Usuário (GUI) e o seu Funcionamento

Para que a tela (figura 6.1) seja desenhada de maneira correta, al-gumas propriedades do form foram alteradas.

Figura 6.1 - Interface desejada para a resolução do exercício.

Propriedade para o Objeto Form

BorderStyle: Essa propriedade é responsável pelo Estilo da Bor-da da Janela que o formulário representará. Um formulário pode ter os seguintes estilos de borda: bsDialog, bsSingle, bsNone, bsSizeable, bsToolWindow e bsSizeToolWin. No momento serão detalhadas apenas a bsSizeable, que é o estilo padrão e permite que o usuário altere o tamanho da janela em tem-po de execução, e a bsSingle, que não permite ao usuário essa alteração, ou seja, a janela terá as di-mensões atribuídas em tempo de desenho.

Estrutura Seqüencial 53

As propriedades podem ser atribuídas através de codificação, além do Object Inspector, quando houver necessidade. Altere o valor das pro-priedades para esse form conforme mostra a figura 6 .2 .

BorderStyle b sS in g le

Caption T ro c a d e V a lo re s

Height 104

Name frmTrocaDe Valores

Width 288

Figura 6.2 - Object Inspector com as propriedades manipuladas para o form.

Faz-se necessário incluir no formulário dois Labeis, dois Edits e um BitBtn.

Um Labei é um componente que exibirá ao usuário um texto qual-quer localizado na guia Standard (figura 6.3). A princípio, e como é nesse caso, serve para que o usuário seja orientado ao preenchimento de algum dado.

Figura 6.3 - Seleção do componente Labei na Tool Palette.

Ao incluir esse componente em seu formulário, ele traz seu valor padrão, Labei 1, sendo que o próximo Labei inserido assume o valor Label2.

Propriedades para o Objeto Labei

Left: Essa propriedade representa, em pixels, a posiçãoesquerda em que o Labei será posicionado. A posi-ção é sempre relativa ao contêiner do objeto. Nesse caso, em relação ao form.

Top: Essa propriedade representa, em pixels, a posiçãosuperior em que o Labei será posicionado.

A figura 6.4 traz as propriedades alteradas e seus respectivos valores.

Inclua um objeto Edit que s encontra na guia de componentes Standard (figuras 6.5). Da mesma maneira, quando um Edit é incluso, ele traz um valor padrão relativo à sua propriedade Text, Editl.


Figura 6.4 - Object Inspector com propriedades manipuladas no Labei.

Figura 6.5 - Seleção do componente Edit na Tool Palette.

Para que, ao iniciar, o componente esteja em branco, apenas apa-gue o valor da propriedade Text, conforme figura 6 .6 . Todo conteúdo de entrada no Edit é considerado um texto, ou seja, uma AnsiString. Nesse exemplo, como não haverá cálculos com os valores de entrada, não será necessário utilizar funções de conversão.

Left

Mame Text Top

__Width

Figura 6.6 - Object Inspector com propriedades manipuladas no Edit.

56

edtPrimeiroValor

8

73

Propriedade para o Objeto Edit

Text: Essa propriedade, no objeto Edit, é responsável peloarmazenamento e exibição do dado informado pelo usuário.

A figura 6.7 exibe as propriedades trabalhadas e seus respectivos valores para o segundo Labei e para o Edit, fique sempre atento para incluir os componentes de acordo com a interface desejada apresenta-da inicialmente (figura. 6 .1 ).

Caption 2o Valor:Left 1152Top 112

Left 20 0Name edtSegundoValor

Text

Top 8Width 73

Figura 6.7 - Object Inspector com propriedades manipuladas no Label e no Edit.


Para finalizar, inclua o componente que representa o botão, o qual proverá a resolução. O botão que será utilizado nesse exemplo é o BitBtn (guia Additioml - figuras 6 .8 ).

O componente BitBtn representa uma variação de botão dentre os oferecidos. Nesse caso, além de um Caption, ele permite a inclusão de uma imagem em BitMap. Todas as explicações sobre o uso e comporta-mento para o componente Button também são válidas para o BitBtn.

Procure lembrar que existem propriedades que têm a mesma funci-onalidade para componentes diferentes.

Propriedades para o Objeto BitBtn

Glyph: Através dessa propriedade, é feita a atribuição deum arquivo que tenha uma imagem em BitMap. Mais a seguir, será exibido como proceder para essa atribuição.

Layout: Essa propriedade determina a posição em que aimagem será exibida no componente, pode ser à esquerda, à direita, ao topo e abaixo do Caption. R esp ectiv am en te : blG lyphLeft, blG lyphRight, blGlyphTop e blGlyphBottom.

Para atribuir o arquivo de imagem para o componente, clique no botão que aparece ao lado direito da propriedade. Será exibida, então, uma janela típica do Windows para a localização de arquivos. Procure o arquivo (Load) desejado e pronto (figura 6.9).

Procure no seguinte caminho: Arquivos de Programas/arquivos Co- muns/Borland Shared/Images/Buttons. Estão disponíveis alguns arquivos (Load).

A interface com o usuário está concluída. Você poderá verificar na unit que existem vários códigos, mas desses códigos, nenhum foi escri-to por você, e sim pelo IDE, que a cada componente inserido tem seu código incluído também, porém de forma automática.

Se você executar agora sua aplicação, ela funcionará perfeitamente, no sentido de aceitar que o usuário digite os dois valores, nada mais que isso, mesmo pressionando o botão Trocar Valores.

Figura 6.8 - Seleção do componente BitButton na Tool Palette.


Figura 6.9 - Janela para busca e seleção de imagem desejada para aparecer no

botão.

6.2.3 O Funcionamento

Note que parte da interação com o usuário está concluída, que é permitir que ele informe os valores desejados. Isso será realizado quan-do o botão Trocar Valores for pressionado (ou clicado).

Resolução 6.1 - Evento O ndickdo Button

E sse e v e n to é c a p tu r a d o n o m o m e n to e m q u e o B u t to n ( o u o u t r o

c o m p o n e n te ) é p re s s io n a d o p e lo b o tã o e s q u e rd o d o m o u s e o u q u a n d o

e s tá c o m o f o c o e a t e c la E n t e r é p r e s s io n a d a . A m a io r ia d o s

c o m p o n e n te s v is u a is q u e in te ra g e m c o m o u s u á r io a t ra v é s d o m o u s e

te m e s s e m e s m o c o m p o r ta m e n to . E ssa s d e f in iç õ e s s ã o v á l id a s p a ra

to d o s o s c o m p o n e n te s q u e t r a z e m e s te e v e n to .

void __ fastca ll T frm TrocaDeValores: :B itB tn lC lic k (T O b je c t *Sender)

{AnsiString Aux ilia r = edtPrim eiroValor->Text;

edtP rim e iroVa lo r-> Text = edtSegundoValor-> Text;

edtSegundoValor->Text = Auxiliar;

MessageDlg("Troca de va lores concluída", m tIn form ation,TM sgD lgButtons() << mbOK, 0);

>___________________

Veja a resolução 6.1. Na seqüência, tem-se uma explicação detalha-da de cada uma das linhas.


6.2.4 Sobre a Implementação

O primeiro ponto a ser tratado neste código é a declaração da variá-vel Auxiliar, que tem seu tipo como AnsiString. Isso se deve ao fato de a propriedade Text do componente Edit, que receberá o valor informado pelo usuário, ter seu tipo também como AnsiString. Veja, na resolução 6.1, que em C++ Builder a declaração e inicialização de uma variável podem ser feitas no momento de uso, dentro do próprio código onde a variável Auxiliar é declarada como AnsiString e incializada recebendo o valor existente no primeiro Edit que, por sua vez, recebe o valor existente no segundo Edit, que então recebe o valor da variável Auxiliar.

O C++ Builder utiliza um padrão para que se trabalhe com a propri-edade de um componente, seja para receber um valor, como está sendo feito no código mostrado anteriormente (atribuição), ou para obter o valor atribuído a uma propriedade (retorno). Dessa maneira, a sintaxe é que a instrução sempre deve referenciar o Componente e a propriedade desejada (separada por um hífen (-) e um sinal de maior (->)).

Variáve l = C om ponen te -> P rop riedade ;Com ponen te -> Prop riedade =

C o m po nen te .P rop riedadeC om ponen te -> P rop r iedade = va lo r_ re ceb ido ;

A u x ilia r = ed tP rim e iroVa lo r-> Text;ed tP rim e iroVa lo r.Text = ed tSegundoValo r- _______>Text;edtSegundoValor.Text: = A u x ilia r______________________________________

atribuição separador

I IAuxi l i ar = ed t Pr i me i r oVa lo r ■> T e x t ;

t t tvariável componente propriedade

Após a execução das instruções, uma mensagem de término é exibi-da ao usuário, como pode ser visto na figura 6 .10 .

A instrução utilizada MessageDlgO tem a mesma funcionalidade que a ShowMessageO, porém com recursos a mais.

Figura 6.10 - Janela com exibição da mensagem de sucesso na operação.


MessagePIgQ___________________________________

Sintaxe

int M essageD lg(const AnsiS tring Msg, TMsgDIgType DlgType, TMsgDIgButtons

Buttons, int HelpCtx);

Objetivo

Exibir ao usuário uma mensagem. É informado o tipo da mensagem e, através desse tipo informado, uma figura (ícone) que expressa esse tipo de mensagem é exibida. É possível também exibir um conjunto de botões predefinidos, além de informações quanto ao Help para essa janela.

Exemplo

MessageDlg("Erro ao ler arquivo", mtError, MsgDlgButtons() << mbYes << mbNo, 0);

MessageDlg("Prossegue?", mtConfirmation, MsgDlgButtons() << mbYes << mbNo, 0);

Detalhamento dos Argumentos e Valor de Retorno

Msg: Esse argumento representa a mensagem a ser exi-bida ao usuário. Esse valor pode estar em uma va-riáv el, um a constan te A nsiString ou em uma concatenação dessas partes.

DlgType: Esse argumento representa o tipo da janela e, deacordo com o tipo informado, um ícone que o ca-racteriza também é exibido. Esses tipos podem ser: mtWarning ( j^), mtError (© ) , mtlnformation ( y ) e mtConfirmation (^)).

Buttons: É através desse argum ento que o conjunto debotões que deve ser oferecidos ao usuário é in -form ado. Lem bre-se que, quando se fala em con-junto, se fala de m atriz, dessa form a justificam - se os colchetes do argum ento. Note que o C++ Builder que utiliza o operador de saída << (esse operador tam bém é conhecido com o operador de b its , qu ando u sad o em ex p ressõ es desse tipo).

Note que essa função, como todas, retorna um valor. Esse valor é a informação de qual botão foi pressionado.


6.3 Problema 2: Obtendo o Resto de uma Divisão

Enunciado 6.2

F aça u m p r o g r a m a q u e le ia d o is n ú m e r o s d e e n t ra d a . E m s e g u id a ,

r e a liz e a d iv is ã o d o p r im e ir o p e lo s e g u n d o e im p r im a o r e s to d e s s a

d iv is ã o .


Nesse problema o que interessa não é o Quociente, que é o resultado da divisão, e sim o seu Resto, ou seja, quanto faltou para que a divisão fosse exata, para isso deve ser considerado que o Quociente obrigatori-amente será um número inteiro.

No C++ Builder, o operador de Resto é o % (percentual).

6.3.2 A Interface Gráfica com o Usuário (GUI) e o seu Formulário

A figura 6.11 representa a interface desejada:

Figura 6.11 - Interface desejada para a resolução do problema.

Propriedades para o Objeto Form

Borderlcons: Toda janela possui ícones que estão diretamenteligados a ela. Eles estão ilustrados na figura 6.15 e detalhados ainda nesta tabela. Esses ícones são: biSystemMenu, biMinimize, biMaximize e biHelp. É possível habilitar e desabilitar todos eles, com ex-ceção do biHelp, que, para se tornar ativ o , a BorderStyle deve estar configurada para bsDialog ou, então, a biMinimize e biMaximize devem estar desabilitadas.


biSystemMenu: Quando essa opção está habilitada, os ícones e op-ções representadas na figura 6.12 são exibidos ao usuário. O 2 £l tem a funcionalidade de fechar a janela atual, ou, em caso de ser a janela principal da aplicação, ela é, então, fechada. A mesma fun-cionalidade pode ser obtida com as teclas Alt + F4 para fechar a aplicação e Ctrl + F4 para fechar a jan ela atual. De onde vem esses atalhos? Do Windows! Dessa forma, quando for atribuir ata-lhos em sua aplicação, cuidado para não sobre-por funcionalidades.

O m enu suspenso, obtido através do clique no ícone pfj, representado pela figura 6 .1 2 , traz ata-lhos para as funcionalidades dos ícones d ispo-

níveis para a janela.

biHelp^biSystemMenu

H*J|

1̂01

biMaximize

Rcilô <Jc uma dl vilão

□ f4*m«rttar

X F o c h « r Alt ♦ f 4

Figura 6.12 - ícones disponíveis no menu de controle de cada janela.

biMinimize: A funcionalidade desse botão é minimizar a janelaatual. Uma vez a janela minimizada, para restaurá- la, basta encontrá-la através do atalho Alt + Tab para verificar as aplicações ativas; Ctrl + Tab, para verificar as janelas ativas na aplicação atual, ou, ainda, clicar na respectiva tela na barra de tarefas.

biMaximize: Esse ícone maximizará sua janela à resolução má-xima permitida pela sua configuração atual de tela ou ao tamanho máximo de sua janela principal na aplicação atual, se essa janela for filha de outra (que é o caso de aplicações MDI). A habilitação desse ícone deve ser bem avaliada, pois se sua aplicação não estiver configurada para que os componentes v isu a is se jam rep o sic io n ad o s em caso de


"m a x im iz a çã o ", o resu ltad o pode não ser satisfatório.

A figura 6.13 mostra, no Object Inspector, as propriedades alteradas para o formulário.

□ [B o rd e r lc o n s [b iS y s te m M e n u ,b iM in im a .

biS ystem M enu t ru e

biMinim ize t ru e

biM axim ize fa lse

biHelp t ru e

B orderS tv Ie b sS ina le

C a ption R e s to d e u m a d iv isão

H e igh t 104

Name frm R estoD eD iv isao

W id th 1288

Figura 6.13 - Object Inspector com as propriedades manipuladas noform.

Inclua um Labei e um Edit. Altere as propriedades Caption e Text para que seu formulário apareça como é apresentado na figura 6.14.

Figura 6.14 - Representação do processo de construção da interface desejada:

inserindo os primeiros componentes.

Atribua o valor 10 para as propriedades Left e Top do Labei. Clique com o botão esquerdo no Labei e, depois, com a tecla Ctrl pressionada, clique no Edit para selecionar os dois objetos.

Observe que à medida que os objetos estão sendo inseridos, nesta versão, a ferramenta mostra uma linha, o que permite ao desenvolvedor posicionar os objetos de forma mais correta.

Outra forma para o alinhamento automático desses objetos: clique com o botão direito do mouse sobre um dos botões selecionados, mar-que a opção Position no menu e, em seguida, Align.

Note, na janela exibida (figura 6.15), que existem dois grupos de alinhamento, o Horizontal e o Vertical, e, dentro desses grupos, as op-ções de alinhamento. No exemplo, é necessário é alinhar verticalmente o Labei e o Edit, ou seja, deseja-se que o Labei esteja centralizado ao Edit,


que tem altura maior (figura 6.16). Para isso, marque a opção Centers no grupo Vertical e pressione OK. O alinhamento é feito sempre em relação ao primeiro objeto selecionado.

Figura 6.15 - Opções de alinhamento disponíveis no IDE.


inserindo os primeiros componentes de alinhamento dos objetos.

Atribua o valor de 64 à propriedade Left e 73 à Width. Selecione novamente os dois componentes e os duplique, pressionando Ctrl + C e, em seguida, Ctrl + V. Cuidado ao colar (Ctrl + V), pois o objeto é colado no componente (contêiner) atualmente selecionado. Para evitar transtornos, antes de colar, selecione o formulário.

Arraste os componentes copiados para o lado direito do formulário, selecione o Labei do Dividendo e, depois, os dois novos componentes. Em seguida, efetue a operação de alinhamento Vertical ao Centro. Mude o Caption do novo Labei para Divisor.

Selecione, agora, o Labei e o Edit referente ao Divisor, copie-os e cole- os no formulário.

Mude o Caption do novo Labei para Resto e arraste-o juntamente com o respectivo Edit. Selecione primeiro o Labei superior (Divisor) e, de-pois, o inferior (Resto). Abra a janela do Align (botão direito), selecione


Right Sides no grupo Horizontal e faça o mesmo para o Edit. Sua tela deverá estar semelhante a da figura 6.17.


layout final dos componentes de entrada de dados.

Propriedades para o Objeto Edit

Enabled: Propriedade responsável em perm itir ou não ainteração com o usuário, ou seja, dizer se o compo-nente está ou não habilitado. Recebe o valor trne ou false. Em caso d e false, ou seja, desabilitado, o componente não recebe o foco, impossibilitando, assim, que o usuário atribua valores ao componen-te, porém isso é perfeitamente válido e possível atra-vés de codificação. Atribua false a essa proprieda-de para o Edit responsável por receber o Resto da divisão.

TabStop: Propriedade que informa se o foco (o cursor, não omouse) irá parar no componente em questão. Lem-bre-se que, em aplicações Windows, a movimenta-ção entre os campos é feita através da tecla Tab. Os valores possíveis são True ou False.

TabOrder: Propriedade que determina a ordem pela qual oscomponentes visuais serão navegados. A ordem é determinada por valores inteiros, sendo 0 (zero) o valor para o prim eiro componente da ordem. E preciso estar ciente de que, para cada contêiner de componentes, existe uma ordem. Se você possuir um formulário e nele três GroupBoxes e, em cada GroupBox, um conjunto de Edits, a ordem para cada GroupBox deverá ser definida.

Inclua agora em seu form um BitBtn e o configure para que fique sem elhante à figura 6.11. O valor da propriedade Layout deve ser blGlyphRight.


6.3.3 O Funcionamento e a Implementação

A implementação está relacionada ao pressionamento do botão exis-tente no formulário e o momento para a captura da interação do usu-ário está ligado ao fato de ele clicar no botão (resolução 6 .2 ).

Uma vez que a divisão é feita sobre valores inteiros e o Edit (propri-edade Text) armazena apenas dados AnsiString, a transformação des-ses valores se faz necessária, porém nenhuma variável auxiliar para recebê-los foi criada.

Resolução 6 .2 - Evento Ondickào Button

void __ fastca ll T frm T rocaD eVa lo res::B itB tn lC lic k (T O b je c t *Sender)

{edtResto->Text = edtD iv idendo-> Text % edtD iv isor->Text;

>__________________________________________________________________

Observe na resolução 6.2 que, em C++ Builder, não existe a chama-da para as funções porque a linguagem oferece o recurso de sobrecar-ga e identificação dos tipos de argumentos (nesse caso, operandos) dentro de uma expressão. Com isso, pode-se evitar o excessivo uso de funções conversoras, deixando o código mais limpo.

Tudo isso não quer dizer que estaria errado usar o seguinte código:edtResto->Text = IntToStr(S trToInt(edtD iv idendo-> Text) % StrToInt(ed tD iv isor-

>Text) );

Na realidad e, alguns preferem u tilizar essa ú ltim a form a de codificação para garantir uma compreensão e fácil identificação dos tipos de dados recebidos e retornados por uma função. Uma atenção se faz necessária a esse tipo de comportamento, pois nem sempre a sobrecarga existe, sendo que a necessidade de garantir a corretude de-penderá de seu código.

6.4 Problema 3: Gasto em um Restaurante

Enunciado 6.3

F a ç a u m p r o g r a m a q u e le ia u m v a lo r d e c o n ta d e r e s t a u r a n t e ,

r e p r e s e n ta n d o o g a s to r e a liz a d o p e lo c l ie n te , e im p r im a n o v íd e o o

v a lo r t o t a l a s e r p a g o , c o n s id e r a n d o q u e o r e s ta u r a n te c o b ra 1 0 %

p a ra o g a rç o m ._________________________



O enunciado pede que, ao ser informado um valor (que representa uma despesa em um restaurante), seja exibido o total que um cliente deve pagar com um acréscimo de 10% sobre o valor informado.

É n ecessário , para qu alquer tipo de problem a que se queira automatizar, que a solução obtida seja validada, ou seja, é imprescin-dível que se saiba chegar ao resultado correto para que este possa ser confrontado com o obtido através de seu programa. Dessa forma, vali- da-se a execução e corretude de seu aplicativo.


A interface sugerida é apresentada na figura 6.18.


Propriedades para o Objeto Form

Position:

poDesigned:

poDefault:

Quando se desenha um formulário de uma aplica-ção, no momento em que ela é executada, é neces-sário informar em qual posição da tela o formulário será apresentado. Quando não se determina uma posição, é assumida a posição em que o formulário foi desenhado. Essa propriedade possui os seguin-tes valores: poDesigned, poDefault, poDefaultPosOnly, poDefaultSizeOnly, poScreenCenter, poDesktopCenter, poMainFormCenter e poOwnerFormCenter. Veja a se-guir o resultado obtido com a atribuição de cada um dos valores possíveis para essa propriedade.

O formulário aparecerá posicionado com as mes-mas dimensões e no mesmo local em que foi dese-nhado no IDE.

O formulário será posicionado de acordo com o pa-drão do sistem a o p eracio n al, nesse caso , o

Windows (inclusive suas dimensões), ou seja, a cada exibição do formulário ele estará mais à direita e mais abaixo.

poDefaultPosOnly: Semelhante à opção anterior, porém, com esse valor, as dimensões definidas em tempo de desenho de seu formulário serão preservadas e o sistema operacional define apenas a posição de exibição.

poDefaultSizeOnly: Com esse valor, o sistema operacional elege as dimensões de seu formulário e mantém a posição definida em tempo de desenho.

poScreenCenter: As dimensões definidas em tempo de desenho são respeitadas e seu formulário é exibido ao centro de sua tela. Para nosso exemplo, atribua esse valor a essa propriedade.

poDesktopCenter: Semelhante ao valor anterior, a diferença está quando se utiliza mais de um monitor.

poMainFormCenter: Quando uma aplicação possui mais de um formulário, um deles deve ser definido como prin-cipal e, através desse valor, os formulários-filho podem ser centralizados ao formulário principal. Isso será trabalhado em futuros exercícios.

poOwnerFormCenter: Semelhante ao valor anterior, porém a cen-tralização se dará em relação ao formulário pro-prietário (ozvner) do formulário em questão.

A propriedade Color dos componentes visuais se refere à cor da área em que o componente é desenhado (o fundo), altere essa propriedade do Edit que receberá o total para amarelo. Para o Labei que apresenta o resultado, altere a Color da propriedade Font para azul. Pode-se dizer que cor é uma propriedade que compõe a fonte, assim como seu tama-nho, estilo e tipo. Veja na figura 6.19 os valores atribuídos para esse Labei. Quando se dá um duplo clique na propriedade Font ou um duplo clique em Color, é exibida uma janela padrão do Windows para essas alterações.

Em relação às propriedades e seus valores, é importante notar que, em C++ Builder, alguns valores, tais como os lógicos (true, false), têm sua primeira letra necessariamente em minúsculo. Se você atribuir o valor através do Object Inspector, não terá problemas, pois ele corrige autom aticam ente, mas, se esse valor for atribuído através de uma codificação, isso deve ser feito de maneira correta na codificação, pois o C++ Builder é sensível a letras maiúsculas e minúsculas.



Ë I Font (TFont)

Charset DEFAULT_CHARSET

Color ■ clBlue

Height -11

Name MS Sans Serif

Orientation 0

Pitch fpDefault

Size 8

Style TfsBoldl

fsBold true

fsltalic ’false

fsUnderline false

fsStrikeOut false

Figura 6.19 - Object Inspector com propriedades manipuladas no Label.

Propriedade para o Objeto Edit

BevelKind: Utilizado para modificar a aparência de um Bevel.

O Bevel se refere à borda de um objeto. O BevelKind influencia exatamente como será a aparência des-sa borda.

Procure testar outras propriedades relacionadas com o Bevel, que são: BevelEdges (bordas visíveis), Bevellnner (parte interna) e BevelOuter (parte externa) e verificar o resultado apresentado.

Em relação ao Edit, não apenas as características das fontes são alte-radas, mas também a cor do componente e uma das propriedades refe-rentes a seu estilo de exibição (veja na figura 6 .20 ).

BevelKind bkFlat

Color 1 IclYellow

El Font (TFont)

Charset DEFAULT_CHARSET

Color OclRed

Height -11

Name MS Sans Serif

Orientation 0Pitch fpDefault

Size 8

B Style ufsBold false

fsltalic 1 false

fsUnderline false

fsStrikeOut 1 false

Figura 6.20 - Object Inspector com propriedades manipuladas no Edit.



Veja o detalhe para a função FormatFloatO a seguir. A função StrToFloatO segue o mesmo princípio da StrTolntO, porém o valor ago-ra é transformado de String para Float.

Resolução 6.3.1 - Evento O ndickào Button

void __ fastca ll T frm R es tau ran te ::B itB tn lC lic k (T O b je c t * *Sender)

{edtTotal->Text = Form atFloat("### ,##0.00", StrToFloat(edtDespesa-

> Text)*1.10);

_}___________________________________________________________

FormatFloatO

Sintaxe

AnsiString Form atF loat(const Ans iS tring& form at, const long double& value);

Objetivo

Formatar um valor Float (long double) em uma AnsiString. Não se trata apenas de uma transformação de tipo de valores, mas sim de formatação, da forma como o dado será apresentado (como casas decimais).

Exemplo

sValor = Form atFloat("000.00", 12.3);

sVa lor = Form atFloat("###,##0.00", nValor);


Format: Observe na sintaxe e no exemplo que existem doisargumentos que devem ser utilizados. O primeiro argumento representa a máscara de formatação a ser aplicada ao segundo, que é representado pelo nome de uma variável.

Máscara de formatação ou máscara de edição é a forma como o dado será exibido (ou informado). São utilizados entre aspas:

• # (cerquilha): Suprime dígitos não significativos (zeros à esquerda).

• 0 (zero): Não suprim e os zeros, m esm o que eles não sejam significativos.

• , (vírgula): Separador de milhares. Na hora da formatação, o C ++ Builder substitui a vírgula pelo caractere de separação.

• . (ponto): Separador de casas decimais. Na hora da formatação, o C++ Builder substitui o ponto pelo caractere de separação.


Value: Esse argumento representa o valor em ponto flutu-ante que receberá a máscara de formatação atri-buída ao primeiro argumento.

Sobre os Exemplos

No primeiro exemplo, o retorno será atribuído à variável sValor, que obrigatoriamente (nesse caso) deve ter sido declarada com String. O valor resultante será 012,30.

O segundo exemplo tem uma variável que deve ser do tipo Float ou seus semelhantes como argumento, ao invés de um valor constante. Essa é uma situaçãomais comum. Supondo que a variável nValor pos-sua 4567.89, o resultado será 4.567,89.

A aplicação implementada possui três componentes que permitem interação com o usuário, dois deles são Edit e um é o BitBtn (figura 6.18). Um dos Edit é responsável por receber o valor informado pelo usuário, dessa forma se faz necessário permitir a interação; o BitBtn é responsável por capturar o momento em que o usuário deseja obter o valor total a pagar; e o segundo Edit somente deve ser responsável por informar ao usuário o valor total. Note que, apesar de ser um componente que per-mita interação, não é interessante que esse último Edit permita isso.

Uma solução para esse problema poderia se atribuir false à proprie-dade Enabled e outra, quando o usuário estiver com o foco (o cursor) no componente. O Edit traz um evento chamado OnEnter, que ocorre no momento em que o componente recebe o foco. Assim, basta capturar esse momento e nele implementar um código que impossibilite que o usuário interaja com o componente.

Resolução 6.3.2 - Evento OnEnter Ao Edit

E sse e v e n to é c a p tu r a d o n o m o m e n to e m q u e o c o m p o n e n te v is u a l

q u e p e r m ite in te ra ç ã o c o m o u s u á r io re c e b e o fo c o . E ssas d e f in iç õ e s

s ã o v á l id a s p a ra to d o s o s c o m p o n e n te s q u e t r a z e m e s te e v e n to .

void __ fastca ll T frm Restau ran te::ed tTo ta lEn te r(TO b ject *Sender)

{M essageD lg("Não é perm itido a en trada de dados",

m tIn fo rm a tion ,TM sgD lgB u tton s()< < MbOK, 0);

ed tD espesa-> SetFocus();

>__________________________________________________________________

A resolução 6.3.2 traz a utilização de um método, o setFocus. Obser-ve que esse método pertence ao objeto edtDespesa, que é um Edit. A grande maioria dos componentes visuais que permite foco possui esse método e ele é responsável por enviar o foco da aplicação ou, em ou-tras palavras, o cursor para o objeto em referência. Em nosso exemplo,


quando o usuário tentar interagir com o Edit, uma mensagem de aviso é exibida (figura 6.21) e o foco se posiciona no Edit responsável pelo recebimento do valor de despesa.

Figura 6.21 - Mensagem exibida ao usuário quando tenta entrar em um Edit que não

permite edição.

6.5 Problema 4: Cálculo de Idade

Enunciado 6.4

Faça u m a lg o r i tm o p a ra c a lc u la r a s u a id a d e . U t il iz e a p e n a s o a n o d e

n a s c im e n to e o a n o d e s e u ú l t im o a n iv e r s á r io . A s s u m a ta m b é m q u e ,

o b r ig a to r ia m e n te , o p r im e ir o v a lo r in fo rm a d o s e rá m a io r q u e o s e g u n d o .


O que se deseja pode ser implementado com uma simples operação de subtração, pois a verificação será efetuada.


O layout (figura 6.22) traz três Edits e um BitBtn, sendo que o usuá-rio interagirá apenas com os dois primeiros Edits que solicitam os valo-res e com o BitBtn que é responsável pela resolução (OnClick).


Observe na interface desejada que as letras N, de Nascimento, e A, de Aniversário, estão sublinhadas. Essa linha sublinhada avisa ao usuário que


ela é uma tecla de atalho e que, ao pressionar juntamente a tecla Alt, a operação ligada a essa opção será executada. Para que isso ocorra, insira o símbolo & antes da letra que será combinada com o Alt na propriedade Caption, procurando verificar se a letra já não foi definida para outro com-ponente, o que evitará a sobreposição. Como nesse exercício não existe operação ligada ao Labei e como objetos Labeis não recebem foco, é assumi-do que um componente que permita a interação com o usuário, ligado a este Labei, receba o foco. O próprio componente Labei traz consigo uma propriedade FocusControl, que é responsável por "apontar" o componen-te que receberá o foco quando sua tecla de atalho for pressionada.

Propriedade para o Objeto Labei

FocusControl: Deve ser definido nessa propriedade o componenteque receberá o foco quando uma tecla de atalho liga-da ao componente em questão for pressionada. Uma tecla de atalho pode ser especificada com a inclusão do & precedendo a letra desejada para o atalho.

A figura 6.23 representa as propriedades alteradas para o Labei do ano de nascimento do usuário.

» C a ption Ano de &Nascimento:

0 FocusControl edtNascimento

Figura 6.23 - Object Inspector com propriedades manipuladas no Labei.


Veja na resolução 6.4.1 que os valores são armazenados na proprieda-de Text do respectivo Edit e essa propriedade mantém um valor AnsiString, sendo necessário transformá-lo em Integer/int para realizar a subtração e obter o resultado, depois transformá-lo para AnsiString, pois esse valor será armazenado também na propriedade Text de um Edit.

Resolução 6.4.1 - Evento OnCHckào Button

void __fastca ll T frm Form u lario : :B itB tn lC lic k (T O b je c t *Sender)

{// Observe novamente a não necessidade de conversão de valores para a operação

edtIdade->Text = (ed tAn iversario-> Text -ed tNasc im ento-> Text);

/* Em caso de querer u sar a conversão explícita, pode ser usado o código abaixo

edtIdade-> Text = IntToStr( S trToInt(edtAniversario-> Text) -

StrToInt(edtN ascim ento-> Text) ) ; */

_>__________________________________________________________________


Para o Edit referente ao resultado da subtração (ou seja, a quantida-de de anos de vida do usuário), foi retirado o recurso do exercício ante-rior (evento OnEnter) e atribuído false à propriedade Enabled do respec-tivo Edit.

6.5.4 Uma outra Forma de Resolução

Há situações em que se deseja saber a idade completa: ano, meses e dias de vida (figura 6.24). Você verá no código de implementação que se assume 365 dias para cada ano e 30 dias para cada mês, e não serão considerados anos bissextos.

' C á lc u lo de u m a id a d e c o m p le ta Q Ixj

D ata A tual: 0 8 / 0 8 / 2 0 0 5 Idade Completa

A nos : in f o r m e a id a d eD ata de Nascim ento : !__ /__ / J

Calcular

M e s e s : [n fo r m e a id a d e

D'a s ; Inform e a d ata de nascim ento e pressione no b o tão p ara e fe tu a r o cálculo

Figura 6.24 - Uma variação de interface desejada para a resolução do problema.

Propriedade para o Objeto Form

ActiveControl: Essa propriedade é responsável por determinar qual componente TWinControb terá o foco no momento em que o form for criado e exibido. Ela também é responsável por informar qual componente tem o foco atualmente, pois este depende de qual componente esteja interagindo no momento com o usuário.

Observe no formulário anterior que a informação da data atual não é fornecida pelo usuário, pois está em um Labei. O evento responsável por esse momento é o OnCreate do form. Veja na resolução 6.4.2 o cabeçalho da função para o C++ Builder. Dois pontos devem ser obser-vados: o uso das funções DateToStrO e Date.

Resolução 6.4.2 - Evento OnCreate do Form

E sse e v e n to é c a p tu ra d o n o m o m e n to e m q u e o c o m p o n e n te (n e s s e

c a s o , o fo r m ) é c r ia d o ( in s ta n c ia d o ) . N e le é p o s s ív e l e fe tu a r v e r i f ic a ç õ e s

q u e a t r ib u a m v a lo re s in ic ia is a c o m p o n e n te s d o f o r m u lá r io ( c o m o é

e s s e c a s o ) , v e r i f iq u e e h a b i l i te c o m p o n e n te s (o u d e s a b i l i te ) . É p re c is o

t e r c u id a d o p a ra n ã o h a v e r c o n fu s ã o c o m o s e v e n to s O n S h o w e

O n A c t iv a te . E ssa s d e f in iç õ e s s ã o v á l id a s p a ra to d o s o s c o m p o n e n te s

q u e t r a z e m e s s e e v e n to .

1 TWinControl é a classe base e que provê funcionalidades aos componentes de controle em/para uma janela.


void fa s tca ll T frm IdadeC om p le ta ::Fo rm C rea te (TO b je c t *Sender)

{lb lDataAtual->Caption = Date(); / / O bserve a inexistência de conversão de

tipo

/ / lb lD ataA tua l-> Caption = DateToStr(Date());

>________________________________________________________________

DateToStr()

Sintaxe

Ans iS tr in g DateToStr(TDateT im e Date);

Objetivo

Converter o valor do argumento TDateTime2 em uma AnsiString.

Exemplo

sData = DateToStr(Date());

Detalhamento dos Argumentos e Valor de Retomo

Date: Este argumento representa uma data, a qual deve-rá ser convertida para AnsiString.

Sobre os Exemplos

No exemplo, o retorno será atribuído à variável sData, que obrigato-riamente (nesse caso) deve ter sido declarada como AnsiString.

Date()

Sintaxe

TDateT im e DateQ ;

Objetivo

Retornar a data atualmente definida pelo sistema operacional.

Exemplo

dData = Date();

Sobre os Exemplos

No exemplo, o retorno será atribuído à variável dData, que obrigato-riamente (nesse caso) deve ter sido declarada como TDateTime.

2 O tipo TDateTime guarda data e hora em uma estrutura interna igual ao tipo Double, onde a parte inteira é o número de dias desde 31/12/1899 e a parte decimal guarda a hora, minuto, segundo e milissegundo. As datas podem ser somadas ou subtraídas normalmente. Existem várias rotinas de manipulação de datas e horas, usadas com o tipo TDateTime.


Verificando o componente que é responsável por receber a data de nascimento informada pelo usuário, pode-se notar que nele existemsublinhados e barras (__/ _ / __). A esses valores é dado o nome de"m áscara" e alguns valores informados pelo/para o usuário devem possuir uma máscara3. O componente Edit, que vem sendo utilizado até o momento, não permite o uso de máscara para entrada de da-dos, porém é oferecid o um com ponente esp ecífico para isso , o MaskEdit.

O componente MaskEdit pode ser encontrado na guia Additional da paleta de componentes (figuras 6.25) e é semelhante ao Edit, diferenci-ando-se, basicamente, na propriedade EditMask.

Figura 6.25 - Seleção do componente MaskEdit na Tool Palette.

Verifique na propriedade um botão com três pontos (3 ), na fi-gura 6.26. É através do pressionam ento desse botão que é apresen-tada a tela responsável pela definição da m áscara de entrada para o com ponente. A figura 6.27 traz algum as m áscaras preexistentes, mas é perm itido que você crie suas próprias m áscaras. O campo Input Mask é o local onde você inform a a m áscara que utilizará, verifique o Help para conhecer as possibilidades. A cerquilha (#) aceita apenas núm eros. O cam po Character fo r Blanks inform a o caractere que será apresentado quando a posição tiver um valor em branco. O campo Save Eiteral Characters inform a se os caracteres utilizados na m áscara (nesse exem plo, a barra f) serão gravados junto com o dado inform ado e, por fim , o campo Test Input perm i-te que você sim ule uma entrada de dados que terá a m áscara como regra.

» EditMask •#/##/####; 1L ±

Figura 6.26 - Object Inspector com a propriedade de escolha/seleção de máscara do

MaskEdit.

3 Uma máscara é uma formatação apropriada para determinados dados a serem exi-bidos ou informados pelo usuário. Alguns exemplos conhecidos são: uma data, que tem as barras entre o dia, mês e ano e que também pode, em determinadas situações, exibir ou solicitar o ano em quatro algarismos; e o outro exemplo pode ser um valor financeiro, que tem separadores de centena e decimal.

Estrutura Seqiiencial 75

Figura 6.27 - Janela de configuração da propriedade EditMask.

Altere a propriedade Default do BitBtn - que diz à aplicação que, em caso de pressionam ento da tecla Enter, o evento OnClick desse componente será executado - e atribua uma tecla de atalho ao BitBtn (na letra C).

Um novo componente apresentado nesse exercício é o GroupBox, que é um contêiner para outros componentes, da mesma forma que um formulário. A idéia principal para o uso desse componente é poder agrupar dados comuns e que possam estar em apenas um formulário, como, por exemplo, um formulário que tenha os dados de uma pessoa. Nesse formulário pode ser necessário agrupar, para uma organização visual melhor, o endereço residencial, comercial e telefones para con-tatos, cada um em um GroupBox. A propriedade que traz o título para o GroupBox é a Caption.

Veja na execução do seu aplicativo que, no m om ento em que o m ouse passa sobre o GroupBox, é exibido um texto ao usuário, que tem por finalidade esclarecer ou inform ar algo sobre o com ponen-te. A grande m aioria dos com ponentes perm ite isso através das propriedades Hint e ShowHint. A prim eira recebe o texto que deve-rá ser exibido ao usuário e a segunda habilita a exibição ou não desse texto . V eja na figu ra 6.28 e altere essas prop riedades no Object Inspector. O GroupBox está na guia Standard da VCL, como m ostra a figura 6.29.

iH in t Informe a data de nascimento

1 S h o w H in t true

Figura 6.28 - Object Inspector com propriedades manipuladas no GroupBox.


Figura 6.29 - Seleção do componente GroupBox na Tool Palette.

Resolução 6.4.3 - Evento OnCHckáo Button

void __fastca ll T frm ldadeCom p le ta : :B itB tn lC lic k (T O b je c t *Sender)

{int dias = StrToDate(lb lDataAtual->Caption) - StrToDate(edtl\lascimento->Text);

in t anos = dias / 365;

dias = dias % 365;

int m eses = dias / 30;

dias = dias % 30;

// Código sem conversão exp líc ita

lb lAnos->Caption = anos;

lb lM eses->Caption = meses;

lb lD ias->Caption = dias;

/* Código com conversão exp líc ita

IblAn os-> Caption = IntToStr(anos);

lb lM eses-> Caption = IntToStr(m eses);

lb lD ias->Caption = FloatToStr(d ias); */

}__________________________________________________________________

Veja na resolução 6.4.3 que o tipo de dado int suporta o valor retornado. O corpo da function começa com a subtração das datas. Note que é feito o uso da função StrToDateO, pois as datas estão em propri-edades que têm o tipo AnsiString, a Caption para o Labei e a Text para o MaskEdit (igual ao Edit).

StrToDateO

Sintaxe

TDateT im e S trToDate(const Ans iS tr ing S);

Objetivo

Converter o valor do argumento AnsiString em um TDateTime.

Exemplo

dData = StrToDate(sData);



Const S: Esse argumento representa uma data, a qual deve-rá ser convertida para TDateTime.

Sobre os Exemplos

No exemplo, o retorno será atribuído à variável dData, que obri-gatoriamente (nesse caso) deve ter sido declarada como TDateTime.

O valor retornado pela subtração representa a quantidade de dias existentes entre as duas datas. Para saber a quantidade de anos, me-ses e dias que realmente representam essa diferença, utilizam-se divi-sões, onde o interessante é guardar o Quociente e o Resto (%) dessas divisões.

Observe no exemplo da figura 6.30. Supondo que a diferença entre as datas seja 1010, e assumindo que o ano tem 365 dias e um mês 30 dias, efetuamos a divisão com os operadores Quociente e Resto (%), en-contrando ao final 2 anos, 9 meses e 10 dias.

Figura 6.30 - Divisão de valores considerando operadores mod e div.

6.6 ConclusãoNeste capítulo, com certeza você já pôde utilizar mais a ferramen-

ta de program ação e deve estar muito animado a continuar. Faça isso, mas, antes, procure refazer os exercícios resolvidos e implementar os indicados na seção Exercícios, procurando sempre utilizar as pro-priedades e as funções apresentadas. Não deixe de fazer testes com combinações diferentes em algumas propriedades para visualizar o que ocorrerá.

A inclusão de novos componentes, propriedades e funções nos pró-ximos capítulos o estimulará cada vez mais!

estrutura seqüencial - eisnt.org+/manuais/06_estrutura_sequencial.pdf · estrutura seqüencial 55...

Documents