Pessoal, bom dia.
Hoje é dia 15 de setembro de 2020, 9h53 da manhã.
Estou aqui para falar para vocês hoje de programação visual orientada a objetos gráficos,
formulários, botões, caixas de texto, etc,
nos chamados ambientes RAD, Rapid Application Development,
aqui no caso, exemplificado em C++ Builder.
Aqui a gente está no grupo de slides número 17.
Um detalhe é que é grupo de slides número 17B,
e por que o B?
Porque o A, que eu ensinava antes,
que era no ambiente Microsoft C++,
andou modificando o ambiente.
Hoje o desenvolvimento de RAD em C++
já não está mais tão intuitivo como costumava ser,
salvo, bem entendido, algum mal entendido meu.
Mas, no melhor do meu saber, do que eu tenho pesquisado nos últimos anos,
de fato foi desabilitada a opção de RAD para C++,
lá no Microsoft, ainda que seja possível utilizar fazendo um conjunto de peripécias,
que até eu coloquei no meu site, junto dos slides 17A
quais são essas peripécias, pelo menos para o ambiente
Microsoft Visual C++ 2017, se eu não me equivoco,
nas minhas aulas eu tenho utilizado o 2019.
Mas voltando ao ponto, não estou no grupo de slides 17A,
estou sim no 17B, e não vou usar o Microsoft,
vou usar, nesse caso, o C++ Builder.
Insisto, tenho utilizado o Microsoft Visual C++ nas demais aulas,
mas nessa, em específico, vou usar o C++ Builder.
O C++ Builder era feito pelo Borland,
ele foi criado inicialmente pela Borland,
inspirado no Delphi
que foi criado pelo...
como ele se chama? Vamos ver aqui.
Criou esses ambientes RAD, criador do Delphi.
Está aqui o Anders Hejlsberg,
ele criou esses ambientes RAD na Borland.
Olha só, ele não é a pessoa que
desenvolveu o conceito de RAD,
o conceito de RAD já existia lá pelos cientistas da computação,
se você consultar a literatura, tem lá uma série de pesquisadores que trabalharam com ambiente RAD.
Agora, o Anders Hejlsberg, o que ele fez
foi transformar esse conjunto de conceitos acadêmicos
em um conceito muito bem elaborado
que foi o Delphi,
que, na minha opinião,
se não a primeira, uma das primeiras ferramentas RAD que fez sucesso.
Aí a partir do Delphi,
o pessoal da Borland criou o C++ Builder
que segue o mesmo conceito do Delphi.
O Delphi não trabalha com C++, trabalha sim com objeto Pascal.
Por quê? Porque o Hejlsberg já trabalhava com Pascal antes,
já tinha desenvolvido outros ambientes com Pascal,
e aí ele vem e aplica o conceito de RAD para objeto Pascal.
Bom, o pessoal foi e criou o C++ Builder que também, para mim, é um sucesso,
trabalha muito bem, é muito intuitivo,
a tal ponto que o pessoal da Microsoft contratou o Hejlsberg,
que sai da Borland e vai trabalhar na Microsoft,
e lá ele desenvolve uma série de ambientes RAD,
envolvendo C++, e envolvendo também, hoje em dia,
J#, C#,
e no contexto das plataformas chamadas .NET.
Isso aqui é só um pouco de background histórico, vamos dizer assim.
Vamos voltar para a nossa aula.
Aqui está os slides, mas essa aula em particular,
eu não vou começar pelos slides, vou começar por uma aplicação prática.
Abrindo aqui o meu Builder.
Eu instalei ontem esse C++ Builder.
Como já disse para vocês em outros momentos, meu PC teve uma pane então eu tive que reinstalar tudo,
inclusive, instalei esse camarada aqui ontem.
Instalei ele para 32 e para 16 bits,
mas isso me trás algumas peculiaridades,
inclusive aqui ele está dando uma série de errinhos.
Ok gente, já estabilizei o ambiente aqui.
Como cliquei duas vezes, ele abriu duas vezes e deu conflito.
Então, eu fiz uma pausa no vídeo,
fui lá, abri o gerenciador de tarefas, matei uma das aplicações,
fechei a outra e no fim reiniciei mais um vez para que fique ok.
Aqui eu vou criar então, estou no ambiente do C++ Builder,
eu tinha um página de um procedimento que já fechei.
Aqui eu vou fazer new project.
Vamos ver, vou fazer esse Windows VCL Application C++ Builder,
pode ser esse aqui.
Então, ele está processando,
ele já cria uma aplicação para mim aqui,
ele tem essa maneira de criar
sem muita burocracia,
a tal ponto que você nem salva o projeto,
ele deixa salvar depois, ele deixa fazer e salvar depois.
Eu, por hábito, já venho aqui e já salvo.
Então vou salvar esse projeto.
Save All.
Salva o projeto e os módulos.
Deixa eu colocar em algum lugar descente aqui.
Vamos...
no nosso projeto ensino, quem sabe.
Sim, estudo dirigido,
está aqui o projeto de exemplo.
ProjetoBuilder1.
Vai chamar assim.
Aqui eu posso mudar os nomes, posso e devo,
mas eu vou usar o que está vindo por padrão para ganhar tempo,
só vou salvar no diretório certinho, conforme vocês viram.
Aqui estou salvando o projeto, também vou salvar ali.
Aqui ele chamou...
essa unidade aqui cpp,
Unit2.cpp, podia chamar de, sei lá eu, FormularioPrincipal.cpp,
qualquer coisa assim.
Se você olhar aqui,
isso aqui é, por incrível que pareça,
no ambiente RAD, Rapid Application Development,
Desenvolvimento de Aplicação Rápida,
ele já trás nesse conceito de rápido,
em alguma medida, o ambiente meio que pré-rodando.
Isso aqui já é a janela que você vai ter rodando na sua aplicação,
tanto é que, seu eu vier aqui e der um compilar,
compilar e executar,
vamos ver o que acontece.
Está compilando.
Se essa janela está criada aqui, já tem algum código
que disponibilizou essa janela, muito que bem entendido.
Então, o que ele está compilando é o código dessa janela pré-mostrada para nós,
e que você não viu o código ainda.
Eu não mostrei, mas vou mostrar.
Em todo caso, já está aqui a janela, eu já tenho a aplicação rodando.
Daí o conceito de RAD, Rapid Application Development,
claro que do ponto de vista de ambiente gráfico, bem entendido.
Ok, voltando aqui.
Cadê o código?
Está aqui Unit2.cpp,
se eu clicar no .dfm,
é o formulário,
que é o que vocês estão vendo na parte gráfica.
Agora eu posso ter aqui o .h.
Se você olha aqui o .h, ele é relativo
àquele formulário que vocês estão vendo ali.
Muito bem.
Aqui está o código relativo ao form que está aqui, insisto,
aqui está o form e aqui está o código que permite criar esse formulário aí,
essa janela que vocês já viram rodando agora.
Aqui eu vou dar zoom no código,
eu tentei ctrl+shift+scroll do mouse e não foi, daí eu dei uma olhadinha alí
e percebi que é ctrl + mais.
Então ctrl + mais.
Olhem só.
Aqui está o formulário,
ou seja, está a janela
que vocês estão vendo rodar.
Vejam que vocês não programaram toda a parte gráfica dessa janela.
Por quê? Porque esse TForm2,
que é criado automaticamente para você,
aqui ele usa o nome da classe TForm porque você salvou as coisas com nome padrão,
se você tivesse salvado com outro nome,
a gente teria já, por exemplo, FormularioPrincipal.h,
e o nome da classe que está aqui,
melhorando meu discurso, o nome da classe que está aqui, eu posso modificar no meu ambiente.
O fato que eu tenho essa classe TForm2 que foi criado para mim automaticamente,
que reflete o código relativo à parte gráfica,
parte gráfica essa que vocês não implementaram, por quê?
Está vindo automaticamente aqui do form, do TForm.
Veja que o TForm2 é derivado publicamente,
herança portanto, de TForm.
Isso pe bem legal, não precisa programar isso aqui,
ele vem pronto para você.
Aqui eu tenho o .cpp que, por enquanto, não tem nada, salvo a construtora.
Está vendo, tem a construtora ali, bem legal, inclusive.
O que mais a gente tem de código?
Por enquanto a gente só tem o código que eu olhei aqui para vocês,
Unit2.h e Unit2.cpp.
Por que ele chamou de Unit2?
Boa questão, questão de ambiente, geralmente ele ia chamar de Unit1,
antigamente ele chamava assim nos ambientes anteriores,
mas tudo bem.
E aqui eu tenho, então de código ainda, o Project1.cpp.
Supostamente, aqui tem minha main ou equivalente.
Antes de eu mostrar, bom, já mostrando,
dizendo em paralelo com relação a esse código da main aqui,
eu queria dizer que, com relação a esse ambiente, ele tem uma série de peculiaridades.
Por exemplo, o main vai se chamar _tWinMain,
cada ambiente pode configurar sua função main,
inclusive nomeando ela com nomes mais peculiares às suas características.
Outra características interessante desse ambiente RAD,
é que ele é altamente intuitivo, vocês vão perceber.
Outra característica legal ainda desse ambiente RAD do C++ Builder,
que hoje não faz mais parte da Borland,
é que eles tem licença acadêmica.
Então você tem uma licença que você pode usar para fins acadêmicos, para aprendizado basicamente.
Aqui, por exemplo, como sempre,
eu estou rodando com o software todo legalizado.
Eu criei uma licença, contei que sou filiado da UTFPR, fiz tudo certinho,
aí eles criaram uma conta para mim,
permitiram baixar o Builder,
como contei para vocês, baixei em 32x, baixei em 64x,
isso trouxe umas peculiaridades inclusive, depois eu vou explicar.
E aí hora que eu baixei o ambiente,
eles mandaram um email para mim já dizendo: "Olha, tua chave de utilização para instalar é esta aqui."
Então, eu utilizei uma chave de instalação tudo certinho, sem problema.
Então, vocês enquanto estudantes,
até onde eu saiba, ao melhor meu saber, podem baixar o ambiente para usar enquanto estudante.
Sem falar que eles tem, também, um trial de 30 dias.
Isso considerado, está aqui o _tWinMain.
O _tWinMain é só para a gente saber onde o código nasce,
a gente não precisa nem entender isso aqui.
Aqui ele usa uma função try catch, eu já expliquei para vocês try catch em aulas passadas,
ele tenta executar alguma coisa, se não der, ele jogo na exceção,
aqui, inclusive, ele encadeia exceções.
Mas isso aqui não interessa para nós nesse instante, o que interessa é isso aqui.
Ele tem um objeto Application que ele cria por definição,
o Application inicializa elementos no sistema,
daí ele diz que vai ter um form principal,
que na verdade é um atributo, bizarramente, público,
que é inicializado com true.
E aqui ele vem e cria um form.
Então, a aplicação é baseada em ter um form principal.
Eu estou dizendo que eu vou ter um form principal, e eu estou dizendo que vou criar esse form
através da função CreateForm do objeto Application que pré-existe para mim.
O que o form vai ser?
No caso aqui, eu estou usando o próprio Form2,
mas vejam que eu não digitei esse código, esse código veio pronto.
Depois que a aplicação sabe que ela tem que focar como form principal o Form2,
ela manda rodar a aplicação.
Isso é só uma explicação básica para vocês saberem onde o código está rodando inicialmente,
mas, insisto, é um código que veio pronto, eu não mexi nele, ele veio nesse aspecto RAD.
Voltamos agora para nossos formulários.
Aqui eu posso brincar com formulário, posso fazer programação "gráfica".
Imagine que eu quero no meu formulário criar um botão.
Se fosse em um ambiente tradicional, em um ambiente de janelas,
como a antiga biblioteca da Borland,
ou como a antiga biblioteca da Microsoft chama MFC, Microsoft Foundation Class,
para criar uma janela igual essa,
eu teria que vir aqui e eu mesmo programar esse código que está aqui,
inclusive, de maneira um pouco mais peculiar do que está aqui.
Para quem quer saber como fazia códigos de janelas antes do RAD,
pode olhar meu conjunto de slides 17C.
17C eu mostro um ambiente com janelas
em MFC, Microsoft Foundation Class, sem RAD, mas aqui é com RAD.
Se fosse sem RAD e eu quisesse criar um botão no meu form,
eu teria que vir aqui e escrever em algum lugar,
sei lá eu, Button, ia ter que escrever aqui Button,
aí ia ter que escrever, sei lá eu, talvez um ponteiro,
botao1, e eu ia ter que programar isso aqui na unha,
ia ter que fazer tudo isso e eu mesmo escrevendo o código aqui.
No ambiente RAD, a coisa se dá outramente.
Se você voltar para o seu formulário e olhar aqui,
eu tenho um conjunto de paletar aqui.
Eu tenho uma série de componentes disponibilizados
como, por exemplo,
o button, o TEdit que é um text box, o label,
enfim, eu tenho uma série de componentes gráficos, eu vou mostrar alguns para vocês.
Retomando, eu fiz uma pequena pausa no vídeo e aumentei o tamanho dos
componentes para ficar mais fácil para vocês enxergarem.
Como é que aumentei, inclusive, fui lá no Tools,
lá tinha um Options, ali no Options você acha onde fazer isso.
Mas o que acontece aqui é o seguinte, eu quero criar um button
ali dentro do meu form.
Está aqui.
Criei o button, inclusive, posso redimensioná-lo
do jeito que eu quiser.
Se eu for olhar o código agora,
vocês viram que eu fiz por arrasto né,
eu peguei a classe gráfica Button,
e por arrasto, clica na classe gráfica,
arrastando ela para dentro do form,
eu instancio um objeto Button1 da classe Button.
Se eu olhar, é isso que eu tenho ali, eu tenho o Button1
da classe Button, e aqui eu tenho um ponteiro, na verdade.
Se eu olhar o código aqui,
vocês estão vendo que eu não estou fazendo inicialização nenhuma dessa ponteiro,
significa que ele tem alguma maneira de inicializar esse ponteiro
maneira essa que não está demonstrado no código para gente,
mas ele inicializa, isso que é interessante, você não precisa se preocupar com isso.
Inclusive, tanto é
que se eu rodar agora, vou dar um salvar por hábito,
se eu rodar agora, esse botão já vai estar funcional.
Funcional, mas não eficaz,
ou seja, eficiente, mas não eficaz, ele funciona, mas não faz nada.
Aqui já é a aplicação,
tem o botão ali e ele não faz nada.
Justamente, vamos fazer ele fazer alguma coisa.
Se eu olhar aqui,
eu tenho o Object Inspector, ou seja, o inspetor de objetos,
então, aqui eu estou inspecionando o objeto que eu clicar porque no
Button1, ele vai mostar aqui o Button1.
Se eu clicar no Form2, ele vai criar o Form2.
Aqui, eu posso mudar o Caption do Form2, colocar como
Janela Principal.
Isso altera o nome da classe?
Não, não altera, continua sendo o TForm2, por quê?
Porque ali é apenas a propriedade gráfica desse cara,
nome do formulário está em outro lugar.
Aqui, provavelmente, se eu mudar para FormPrincipal,
aí ele vai mudar o nome da classe lá.
Vamos ver se mudou.
Mudou, mudou o nome da classe agora.
Obviamente, que daí ele vai fazer lá as artes
na conexão do main, mudou o para TFormPrincipal também.
Vou dar um ctrl + menos aqui um pouco.
Entenderam?
Legal, o fato aqui, o ponto é que, através do Object Inspector,, eu posso inspecionar meus objetos,
eu posso inspecionar o botão também.
Professor, esse Button1 não está legal graficamente.
Então eu colocar aqui um nome que faça sentido,
sei lá, OK, por exemplo.
Agora eu quero que esse botão faça alguma ação.
O que vocês tem que entender é o seguinte:
isso aqui, além de orientado a objetos gráficos com suas propriedades,
ele também é orientado a eventos, está vendo ali o botão eventos?
Tem uma série de eventos que posso programar aqui.
em relação a esse botão, aliás, com relação a qualquer um dos objetos desse ambiente RAD.
Então, deixa eu programar um evento aqui.
Mas antes de programar um evento, eu vou adicionar mais um objeto gráfico aqui, o TEdit.
O TEdit é uma caixinha de texto.
Inclusive, ele já começa com um valor dentro que é esse Edit1.
Se eu for em propriedades, eu provavelmente consigo tirar esse valor inicial Edit1.
Bom, daí eu tenho que pesquisar aqui propriedades, Name, Edit1.
De certo Name é o nome do objeto, ou é o que aparece ali?
É fácil de saber.
É, de fato é o que aparece ali, se eu tiro, ele some, ou não some?
Some.
Está vendo, então, Name não é o nome interno do objeto, é o que está aparecendo
dentro da caixa de texto por default.
Tanto é que, se eu olha aqui, ele continua...
ele deveria aparecer aqui o meu EditBox.
Vamos ver porque não apareceu.
Vamos fazer um teste.
Ele não está aparecendo ainda meu EditBox, mas deveria aparecer.
A gente vai descobrir porque do ponto de vista de código.
O fato é que eu tenho aqui agora um EditBox e um Button.
Quem sabe se eu salvar e compilar ele melhore minha situação, vamos ver.
Muito bem.
Então aqui, eu vou fazer o seguinte: eu vou apagar o objeto,
provavelmente não poderia ter mexido naquele name.
Apaguei.
Vou recompilar.
Agora foi.
Bom, a gente aprendeu aqui peculiaridades do ambiente.
Vamos arrastar de volta o edit.
Está ali arrastado.
Agora, se eu olhar aqui no .h, ele tem o Edit1.
Bom, lição aprendida.
Tem que tomar cuidado com o que eu estou mexendo no objeto.
Se o ambiente é novo que você está mexendo
e ele tem alterações em relação à ambientes passados, você tem que ver o que aconteceu.
Então Name aqui está significando o nome do objeto, eu não mexo no nome do objeto,
mesmo porque é bastante intuitivo aqui, devia nem ter errado,
Text que é o que aparece por definição.
O que acontece é o seguinte:
o Name é o nome interno do objeto,
só o Text, por definição, vai utilizar o que?
Vai utlizar o Name, o que tinha no Name vai utilizar aqui.
Está aqui o Name, não vou mexer no Name, a não ser que eu queira colocar um nome mais bonito,
tipo, CaixaDeTextoPrincipal, isso eu posso alterar,
nome do objeto internamente, não tem problema,
mas eu não posso deixar ele sem nome.
Agora, o que eu posso deixar sem é o Text, obviamente.
E agora aqui vai continuar funcionando.