Agora eu tenho dois objetos, o OK e o Text.
Agora eu quero clicar no OK
e fazer com que apareça algo aqui no Text.
Vou clicar aqui no OK, e veja o que acontece.
Hora que eu clico no OK, ele cria automaticamente para mim,
no Unit2.cpp, ou seja, no .cpp do form,
uma função chamada Button1Click, essa função não existia, existia só o TForm,
agora tem o Button1Click também.
Aqui eu posso programar coisas.
Mas, professor, por que você criou isso mesmo?
Eu vim aqui e dei um duplo clique nessa ambiente que está rodando aqui,
esse é o ambiente de programação, ele deixa o ambiente pré-rodando, por assim dizer,
e nesse ambiente que está aqui, ou seja, nessa interfaca gráfica, eu cliquei no OK
e ele criou automaticamente o Button1Click.
Aqui eu posso fazer uma série de manobras.
Eu já não tenho o objeto via ponteiro, mas tenho o objeto Edit1? Tenho.
Então, eu posso ir lá naquele evento,
vejam, eu dei duplo clique no objeto Button OK,
Button1 que tem o texto OK,
Aí ele cria o que? Ele diz: "Opa!"
Então, em termos de programação, eu vou criar um ButtonClick,
significa que, quando eu clicar naquele botão em tempo de execução,
ele vai executar o código que estiver aqui.
Então, vejam que legal.
Eu venho aqui e crio o Edit1
e aqui vai trazer as diversas propriedades que o objeto tem, a gente já tinha percebido que objetos gráficos tem Text.
Então, está ali o Text,
inclusive, ele deixa as propriedades públicas, ele não tem o setText,
ele não tem o getText, ele acessa o Text direto,
ele acessa as propriedades dos atributos gráficos diretamente,
o que, para a ortodoxia
da orientação a objetos, pode ser vista
como uma imperfeição, mas é assim que ele faz.
Eu posso colocar aqui um
"Bonjour les enfants", bom dia às crianças,
aos infantes,
infantes de infantil, bom dia à moçada.
Vamos lá.
E aqui eu vou executar a coisa.
E está ali.
Agora ele cria ali o "Bonjour les enfants", como vocês estão vendo.
Se eu vier aqui, apagar e clicar de volta,
ele continua fazendo.
E claro, eu posso começar a fazer algumas coisas mais bem elaboradas,
por exemplo, eu posso vir aqui no .h
e colocar as minhas declarações, eu não preciso fazer tudo graficamente,
eu posso misturar código,
inclusive, tem lá User declarations, privados.
Vou criar aqui um booleano, ele aceita booleano,
flag de bandeira.
Bom, se eu criei um atributo,
ele é um atributo que está sendo gerenciado em background,
está sendo gerenciado por mim, eu que criei,
eu tenho que inicializar esse atributo na construtora.
Então, eu venho aqui e coloco, sei lá eu,
flag como true.
Legal, então, o flag está true.
Agora eu vou voltar para o meu form e vou clicar de volta no meu evento.
Insisto, o que eu estou programando aqui é um evento,
então, na verdade, eu estou fazendo uma programação orientada a objetos e a eventos.
E aqui, inevitavelmente, quando o Hejlsberg elaborou esse ambiente,
seguindo as diretivas de RAD, ele não tinha outra opção senão trabalhar com eventos.
Clicando no botão OK ou em qualquer componente gráfico,
ele cria o principal eventos, mas não é o único evento que existe,
você tem uma série de outros eventos que são programáveis aqui.
Se eu clicar aqui, eu posso enxergar uma série de eventos, eu estou usando só o ButtonClick, mas eu tenho outros.
Depois eu mostro para vocês.
Por enquanto, eu vou me concentrar no principal que é o que acontece
se você clicar no componente gráfico, nesse caso o botão.
Posso fazer o seguinte, dizer aqui
if (flag == true) ou if (flag),
eu posso fazer esse código que está aqui,
e transformo o flag em false, by the way.
else
aí eu vou copiar esse código aqui e modificá-lo.
Vamos escrever outra coisa aqui, um outro idioma, quem sabe.
"Buenos dias niños!", já não lembro se é assim que escreve,
se alguém fala espanhol, me perdoe os erros, mas acho que está certo.
Bom, se não estiver certo, aí está errado.
Vamos lá, colocar aqui como true.
E aqui eu vou criar um comportamento toda vez que eu apertar o botão,
esse vai depender de um elemento externo que é o flag inicializado com true,
e que vai alternando com o false conforme o rodar da coisa.
Vamos ver o efeito que isso dá.
Então, está aqui.
Se eu for clicando aqui, ele está alterando a coisa ali.
Inclusive, posso vir aqui se eu quiser
e digitar coisa no meio, atrapalhar a brincadeira.
Se eu voltar a clicar aqui, ele volta a limpar, vai fazer o que está programado no meu evento.
Então, aqui eu estou programando orientado a eventos,
no caso aqui do clique do botão.
Aqui, por exemplo, é outro evento, esse aqui já é um evento programado,
posso minimizar e posso maximizar, aumenta a janela.
Esse evento eu não programei, ele já é programado na classe form,
da qual o FormPrincipal derivou de Form,
como vocês estão vendo ali.
Eu posso, também, fazer outras peripécias, aliás, posso fazer uma série de peripécias.
Se vocês olharem aqui, eu tenho uma série de componentes que eu posso utilizar,
está vendo?
Uma série de componentes, eu mostrei dois, tem uma série de eventos sobre cada componente,
eu tenho uma série de propriedades sobre cada botão,
sobre cada componente, inclusive o botão.
Por exemplo, eu quero mudar o nome interno do botão, não quero que seja Button1, quero que seja Botao,
quero que seja botão em português,
posso alterar o nome, deve ter um name em algum lugar.
Ali, está vendo?
Se eu quero que internamente se chame Botao, eu venho aqui e altero.
Botao1, está vendo?
O que vai acontecer?
Ele vai alterar lá para Botao1.
Isso, supostamente, se não tiver nenhuma falha do ambiente,
ele funciona igual, só que agora eu estou usando nomes que são mais assertivos para mim.
Continua funcionando.
Bom, nesse aspecto de possibilidades que eu tenho,
eu posso também programar outros eventos além do evento mais original.
Por exemplo, o que acontece se eu clicar nesse componente gráfico TEdit?
Vamos clicar nele.
Opa, ele abriu um evento Edit1Change.
O que acontece se eu fizer um EditChange?
Se eu fizer um EditChange, eu posso, por exemplo, clicar ali no...
no Edit, mexer nele, eu posso limpar aqui, por exemplo,
para evitar que o usuário fique colocando sujeira,
ou colocar um aviso aqui.
"Não digite no edit."
ou "Não digite nessta caixa de texto."
Sei lá, se esse é o comportamento que eu quero, não que...
que isso seja o padrão, o edit é feito para ser editado, justamente.
Mas enfim, eu dei essa denotação para ele.
Muito legal.
E está aqui.
Então, está aqui, eu estou vendo meu OK, o que acontece se eu alterar aqui?
Esse cara, por default, ele não tem o clique, ele tem a operação,
Olhe, "Não digite nesta caixa de texto".
Legal.
Então, isso acontece.
Aí, ele travou para mim a mudança de textos, por algum motivo.
Ah que legal, eu sei o que está acontecendo, é muito interessante porque um...
um evento altera o outro.
Então, está aqui, não mexi com o edit, vou dar um OK aqui.
O que acontece? Eu dei um OK aqui,
hora que eu dei o OK, o que eu fiz no edit?
Eu não fiz uma alteração do próprio edit?
Fiz uma alteração no próprio edit.
Se eu fizer uma alteração no edit, ele dispara o outro evento,
que é esse que a gente programou aqui,
que é esse que a gente programou aqui, o EditChange.
Então, quando eu faço isso aqui, ele dispara o EditChange
e coloca "Não digite nesta caixa de texto"
e trava minha execução.
É interessantíssimo.
Agora, se eu tirar isso aqui,
ele vai voltar para o comportamento normal.
Ah sim, está com erro porque eu não fechei a aplicação.
E agora volta ao normal.
Legal, interessante.
Muito bem.
Se eu continuar aqui e pegar o botão OK, eu posso programar outros eventos, conforme eu dizia,
eu tenho uma série de eventos que são programáveis.
Por exemplo, mouse leave.
Eu posso fazer o seguinte, se eu sair da região do OK,
ou seja, o mouse leave, partir da região do OK,
eu posso executar alguma coisa, então eu vou clicar aqui.
Por enquanto, não tem nada programado no mouse leave,
eu ativo o Botao1, mas eu posso programar, por exemplo,
para deixar o Edit1, ele deve ter um a função, aliás, uma propriedade chamada Enable,
deixa eu ver se ele tem.
Tem.
Enable que eu vou colocar como false.
Vamos ver o que acontece.
Então, vamos executar aqui.
E está aqui.
Eu estou executando o meu OK aqui,
agora eu vou sair da região da caixa, vou sair do OK, o que acontece quando eu sair, mouse leave?
Esse cara fica indisponível.
Eu posso continuar alterando o conteúdo dele
através dos eventos do OK, do botão Ok, do evento do Botao1Click.
Agora, eu não tenho mais acesso ali.
Interessante, não tem mais acesso,
porque eu deixei ele desabilitado.
Claro, eu posso, através de outros eventos ou de outra situação, aplicar de volta.
Por exemplo, eu posso vir aqui, sei lá eu, criar um
check, CheckBox.
O CheckBox,
ele tem um nome aqui,
eu posso mudar ele em propriedades.
Não é name, deve ser Text ou algo que valha,
ou Caption, ou algo assim.
Caption está aqui.
Vou mudar isso aqui para Habilitar Caixa de Texto.
Aí,o que eu faço aqui?
Ele vai ter aqui, ele trabalha com clique,
CheckBox1Click.
Certamente ele criou mais um componente gráfico para mim aqui.
Está aqui.
Engraçado que ele criou aqui, também, um objeto que a gente não está vendo que é o Botao1MouseLeave,
para gerenciar evento de Leave, mas isso a gente não gerencia.
Então, o que eu posso fazer aqui?
Eu posso, simplesmente, vir aqui, quando eu clicar ali,
independentemente da situação, transformar esse cara como true.
Legal, aqui, por enquanto, está dando para digitar.
Agora eu venho aqui na OK, fazendo a brincadeira ali.
Se eu fizer um Leave, ele não pode mais editar.
E se eu clicar aqui?
Ah, voltou a ser editável.
Agora eu sai.
Mas vejam que não é pelo fato de ele estar checado ou não, é pelo fato de eu ter clicado nele.
Se eu clicar nele, checando ou não checando,
o evento aqui não é de MouseCheck,
é de MouseClick,
aliás, de ComponentClick.
Então, claro, eu posso melhorar o que eu estou fazendo com esses eventos aqui.
Vamos brincar um pouco com isso porque é divertido, um ambiente intuitivo, inclusive,
você aprende rápido ele, mesmo que tenha tido alterações de versão para versão.
Eu tenho um componente, então,
CheckBox.
Eu tenho essa função de clique no Check,
eu posso testar aqui.
Ele deve ter, provavelmente, porque esses ambientes são muito intuitivos,
o Checked.
Tem ali, Checked.
if (Checked == true)
então, o que eu faço?
Libero ali, senão eu deixo travado.
Bem bacana.
Eu venho aqui, vou compilar.
Agora está ficando um negócio mais de acordo com o próprio componente.
Apesar que eu devo ter um evento que seja de Checked, mas eu resolvi fazer um if.
Então, está aqui.
Ah, porque eu já sai do botão de OK.
Se eu clicar lá?
Opa, liberou.
Travou, liberou,
e assim vai para você ir brincando.
Será que eu tenho um evento de Checked para um botão?
Eu não sei, faz tempo que eu não mexo com esse ambiente da Borland,
eu gosto muito de mexer, deveria mexer mais.
Mas seu eu vier aqui,
se eu vier aqui, eu posso ver se ele tem um evento Checked.
Talvez tenha, talvez não.
Não tem, é mais rústico no conjunto de eventos,
mas ele trabalhar bem com as propriedades que eu fiz ali.
Não estou vendo um Checked.
Então, tem que trabalhar do jeito que eu fiz mesmo, que está muito legal.
Com o click a gente está trabalhando, com o enter, com o exit.
Posso fazer, por exemplo, programar algo hora que eu entro no objeto,
hora que eu saio do objeto.
E claro, posso ir melhorando o meu código
a medida que eu for me divertindo, eu posso, por exemplo,
na função de inicialização
que está aqui,
colocar sempre o Checked como true.
Está vendo aqui? Posso colocar como true,
ele já entra como true, ou eu posso colocar como false.
Entra como false, também, já entra aqui
o Edit, também, desabilitado,
para evitar que o cara mexa no Edit sem ele explicitar isso.
Bom, ali eu coloquei duas vezes o Edit1,
mas o fato é que ele está desabilitado ali.
E aqui ele já vem desabilitado por definição o Check, então,
aqui no meu código não ia ser útil, mas
se eu fizer questão, eu posso vir aqui
e colocar.
Só para garantir o óbvio.
Aqui, não consigo clicar, ali já estava false por definição, mas eu garanti no meu código,
ali a brincadeira,
agora eu quero mexer, quero poder escrever,
sei lá eu, "Buongiorno", não sei escrever italino,
deve ser assim, "Buongiorno!",
bom, algo assim, não sei italiano, não falo nem escrevo.
Bem.
Aqui eu volto a fazer minha ação francês/espanhol,
sem poder digitar.
Se eu clicar aqui de volta,
eu volto a digitar, e assim vai.
Pessoal, o fato aqui, o ponto
é que vocês tem uma série de componentes que vocês podem utilizar,
uma série de componentes que vocês podem utilizar, desde TextBox,
Scroll, Panel,
isso que eu estava mostrando só uma classe, só os standards, vocês tem uma série de elementos aqui,
Data Access que permite vocês trabalharem com banco de dados, inclusive,
esses ambientes RAD vocês vão utilizar muito,
acredito eu, na disciplina de banco de dados porque ele dá um acesso muito legal aos sistemas
que gerenciam dados e por aí vai.
Componentes de internet, componentes gráficos,
uma infinidade de componentes que você pode ir explorando e, insisto, o ambiente é intuitivo.
Agora vou fechar esse projeto que eu estava trabalhando.
Dei um salvar geral aqui.
E agora eu vou abrir um ambiente,
aliás, uma aplicação que a gente já fez no passado.