Então, pessoal, aqui o ambiente reabriu, aqui está página de Boas Vindas que eu sempre fecho.
Aqui eu vou abrir um projeto pronto.
Então, eu tenho o Open Project.
Não é um projeto que eu estou criando, estou abrindo um projeto que já existe.
Aqui ele já está esperto, já está no diretório que eu trabalho,
onde eu deixo meus projetos, slides 17B, ProjetosOK,
deixei ali.
Vou pegar esse cara aqui
que é o... Vou começar com esse aqui que é o ExemploComDesenho;
Esse é um exemplo bem legalzinho e não tem muita coisa,
mas ele é peculiar, vocês vão entender porque.
Aí tem um form com um botão Mover,
que é um botão que foi criado igual eu fiz no...
no exemplo anterior, vamos rodar antes de ver o código.
Então, olhem só, moçada.
Está aqui o form, vejam que agora o form aparece com desenhos.
Tem uma bola, tem um traço, um quadrado,
quase como se fosse um joguinho, por assim dizer.
Aqui eu tenho o botão Mover
que deveria mover esses caras aqui,
que não está movendo, talvez porque eu andei mexendo no código,
ontem, e fiz alguma malasartes nele.
Vamos ver o que eu fiz no código.
Clica no botão mover, ele tem que rodar o Repaint.
Está aqui o Repaint, tudo jóia.
Ok, gente, está tudo certinho aqui pelo ponto de vista de código.
O que eu acho? Eu acho que, como eu estou rodando no ambiente 32
e 64, e essas operações foram feitas em...
em 32, pode ser que ele tenha compilado para 64, ou algo assim. Então, o que eu vou fazer?
Eu vou vir aqui e fazer um clean, vou limpar todos os meus códigos executados.
Limpou, eu vou recompilar, simples assim.
Então está aqui, Build ExemploComDesenho.
Está recompilando.
Legal.
Vou dar um OK e vamos testar.
Agora está funcionando.
Está mexendo, só recompilar mesmo.
O que acontece? Aqui não tem muita arte
do ponto de vista de eventos, mas tem umas peripécias do ponto de vista da parte gráfica,
que é o seguinte.
Está aqui o meu form que eu chamei de Desenha,
Tela de desenhos, tem o botão mover.
O que acontece? O botão mover muda uma variável chamada valor_aumenta,
ele incrementa em 10,
mais recebe (+=) 10, sabe que valor_aumentar recebe valor_aumentar mais 10,
e chama o this, this é desse objeto, ou seja, do próprio form, Repaint.
Então, hora que eu chamo o Repaint, ele vai repintar o que está dentro do form.
Quando eu repintar,
ele vai chamar essa função FormPaint.
Essa função FormPaint, provavelmente, foi feita
clicando aqui no formulário
e chamando o OnPaint.
Está aqui, foi assim que foi feita.
Daí ele abriu o FormPaint.
Como que eu aciono o evento OnPaint?
Tem várias formas.
Uma maneira de acionar o evento FormPaint é chamando explicitamente o método Repaint.
O Repaint aciona o evento que chama o FormPaint que vocês estão vendo.
Legal.
O que eu faço lá? Eu faço uma série de peripécias.
A primeira peripécia que eu faço,
antes do FormPaint,
é, lá no form, colocar a variável valor_aumentar como 0.
Na verdade não é uma variável, é um atributo,
tanto é que, se você for no .h, ele está lá.
valor_aumentar, aqui meio que obviamente.
Voltando ao ponto, inicializado com 0.
Hora que eu faço aqui o clique do botão,
eu incremento o valor_aumentar inicializado na construtora
e faço o Repaint que ativa o FormPaint.
Aqui eu faço o que?
Minha variável "x" e "y" recebe 10,
e aqui sempre o "y" vai ter o que?
Vai ter 10 mais
o valor que estiver que valor_aumentar que está aumentando de 10 em 10, by the way.
Aqui eu uso Canvas.
O que é o Canvas?
O Canvas é a parte gráfica do formulário
que pode, já tem previsto,
para criar algumas coisas como elipses,
linhas e retângulos.
Aqui eu vou, claro, redesenhando esses cara ali dentro.
Hora que eu faço o Repaint, incluise, ele apaga o que tinha
e rerroda o FormPaint.
Então, é só um exemplo bastante simpático,
eu acho ele simpático, de mostrar
uma outra utilização usando esse ambiente RAD, vocês podem explorar essa aplicação disponível.
Vocês viram que eu abri a aplicação por aqui.
Eu vim abrir aqui pelo ambiente.
Supostamente, nada me impede de pega lá no diretório,
ir lá onde tem os projetos,
aqui o ProjetoOK,
e ir ali e clicar direto
no arquivo de projeto que é esse cara, tem esse CX, Project File.
Como eu instalei 32 e 64 e esse projeto foi feito em 32,
por algum motivo, hora que eu abro a partir daqui
ele está abrindo e tentando compilar para 64.
Então, ele está se perdendo por aqui pelo fato de eu estar com dupla face,
64 e 32.
Esse projeto foi feito em 32,
se eu der um duplo clique aqui, ele abre o ambiente.
Eu vou rodar e tentar compilar para 64.
Se eu abro direto no ambiente como eu fiz,
aí ele entende,
ele consegue entender que foi compilado inicialmente com 32 e recompila com 32 bits.
Então, bom,
se quiserem evitar problema por hora nesse ambiente,
façam o seguinte: abram sempre a partir do próprio ambiente.
Aqui eu vou fechar esse projeto.
Vou abrir um outro projeto ainda.
Aqui o File, estou abrindo a partir do ambiente, insisto,
vou lá nos meus diretórios, eu tenho aqui um
ProjetoOOJanelaExemploOK.
O que é isso aqui, pessoal?
Isso aqui é um recorte do sistema de universidades.
Está aqui o nosso ambiente.
Vamos rodar o bixo.
Está aqui ele rodando.
Se eu clicar em iniciar,
ele trás aqui a Lista de Universidades.
Então, vejam, isso aqui é extrato do sistema universitário,
eu estou tratando com as Universidade, Departamento e seus relacionamentos.
Não estou tratanto, ainda, de Disciplina, Aluno e etc,
estou com só esses dois elementos.
Hora que eu clico em Iniciar,
ele popula meu ListBox desse cara aqui,
ListBox é um parente do EditBox só que list.
Aqui eu posso, também, clicar no ListBox, vamos ver o que acontece.
Opa! Se eu clico aqui na UTFPR,
lá no outro ListBox que é o Lista de Departamentos, aparece
os departamentos pertinentes, vamos ver em Princeton.
Aparece aqui Matemática Princeton, Física Princeton.
Olha lá.
Então, eu tenho o evento aqui o inicializar,
populo a ListBox,
e tenho o evento de ListBoxClick
que faz com que apareça no outro ListBox os departamentos relacionados à Universidade que eu estou clicando.
Aí eu tenho mais um botão que é o adicionar.
O adicionar cria outro form, eu posso ter mais de um form por aplicação.
Aqui eu tenho 2 forms, mas eu posso ter "n" forms.
Aqui eu faço o que?
Vou criar uma universidade aqui, sei lá, USP por exemplo.
Adicionar.
Aqui eu tenho o botão Adicionar que, provavelmente, executa um evento.
Opa! O que aconteceu? Aqui eu posso fazer um Refresh,
podia fazer o Refresh automático, inclusive.
Ele criou a USP, por enquanto para a USP não tem departamentos.
Se eu clicar fora, ele dá um errinho, deu um errinho ali,
mas é um erro de gerenciamento automático dele.
Vou criar mais um cara aqui, UEPG.
Colocar aqui UEPG.
UEPG, adicionar, está ali.
Então, a gente pode investigar um pouco agora como esse sistema foi feito.
Vamos lá.
Eu posso,
deve ter como aumentar esse...
esse espaço aqui de visualização de forms
você olha aqui e está pequeno as coisas.
Provavelmente, se eu vier aqui em Tools e Options,
eu devo ter essas opções aí.
IDE.
Vamos ver, User Interface, Object Inspector.
A paleta, a paleta de objetos, posso colocar large, inclusive.
Form, Form Designer.
Bom.
Certamente, ele tem um lugar para aumentar aqui o tamanho
da coisa, mas como o ambiente mudou, evolui,
teria que buscar, não vou buscar agora, mas vocês sabem que podem buscar isso e localizar.
Aqui pelo já está mudado, incrementado, a nossa Paleta
hora que for olhar os objetos, está grandão mesmo.
Eu tenho, então,
o ListBox que está aqui
e tenho o Inicar e o Adicionar.
Vocês tem que pensar o seguinte: aqui eu estou trabalhando com sistema acadêmico,
no sistema acadêmico eu tinha a classe principal
.h e .cpp, eu tinha a classe
Universidade.h e .cpp, eu tinha Departamento.h e .cpp.
E aí, essas classes sumiram?
Não, não sumiram, elas continuam aqui,
tanto é que está aqui, se você olha ali nos .h,
eu continuo com elas existindo aqui.
Por exemplo, eu continuo tendo Principal.h e .cpp,
eu continuo tendo, inclusive, Professor.h e .cpp, muito embora não esteja utilizando na parte gráfica,
Universidade.h e .cpp, Departamento.h e .cpp.
As coisas estão ali.
Então, se você parar para pensar, na verdade, o que está acontecendo aqui é o que a gente chama de...
em alguma medida, ainda que de maneira pobre,
o Model View Controller.
Eu tenho o View, a visão, que é o form,
eu tenho o controlador, ou seja, a classe Principal que é a principal.
e eu tenho as classes de modelo,
nesse caso, nosso modelo é Universidade e Departamento.
Bem, agora a gente vai entender como que a coisa funciona.
Eu acho que a primeira coisa que a gente tem que olhar
aqui é o main desse cara.
Está aqui o main, o main está usando o TForm1, posso chamar de FormPrinciapl, vocês já viram que eu posso modificar isso.
Aqui não alterou nada.
Agora, vamos dar uma olhada nos formulários principais.
Tenho a unidade, chamei de Unit1, posso mudar o nome, inclusive, aqui eu chamei de
UAdicionaUniver, aqui eu podia ter chamado de UnitPrincipal,
se quiserem, a gente altera ali, mas enfim.
Deixa eu dar uma olhada no .h.
O que acontece no .h?
Esse .h aqui, eu tenho os objetos gráficos
que são criados automaticamente, com os eventuais elementos para ajudar a mexer com eventos, coisa e tal.
Construtora, olhem só,
eu tenho um objeto_principal criado a partir de formulário,
podia ser criado a partir da Principal, também,
talvez até fosse melhor, mas eu não quis mexer naquele código porque o ambiente
não me instiga a mexer no código da Principal,
ele não tem nada dizendo "Adicione código aqui".
Então, eu fui adicionar código onde o ambiente me instiga
que é lá a partir do formulário, olha: "User declarations".
Aqui eu criei o objeto principal.
Bom, aqui é um ponteiro,
inclusive, se você olhar aqui, eu até tenho Principal.h aqui, mas ainda sim um ponteiro.
Aí eu faço o que?
No .cpp, na construtora, eu inicializo esse ponteiro,
inclusive, destruo na destrutora.
Nada me impede de colocar um if, if (objeto_principal) colocar com delete, mas tudo bem.
Então, aqui a gente estar ciente que existe o objeto_principal.
Vamos dar uma olhada como está esse objeto_principal, aliás essa classe Principal,
o que modificou nela.
Ela tem uma parte gráfica, ele continua sendo o C++ padrão que a gente usava.
É o C++ padrão que a gente utilizava.
Está aqui.
Única coisa que foi alterada aqui,
para fins de facilidade, mas pode ser tranquilamente alterado através de iteradores,
através de outras astúcias,
é a lista que, por hora, eu deixei pública.
A gente sabe que elemento público é heresia,
então, depois da para privar e criar funções para
dar acesso ao que precisa utilizar dessas listas
do ponto de vista de form.
Ela está pública porque eu preciso que o form acesse isso,
mas, insisto, isso foi só uma simplificação.
Vocês podem, enquanto exercício, criar funções para permitir que o...
o form acesse isso, talvez através de iteradores,
iteradores programados por vocês, bem entendido,
que permitiriam ao form acessar
esses caras aí
sem eles estarem públicos, com eles privados.
Mas, por enquanto, eles estão públicos, estejam cientes disso.
Legal.
Agora sim, vamos ver graficamente o que está acontecendo lá
no nosso formulário.
Bom, a primeira coisa que tem é o botão iniciar.
Bom, antes vamos dar uma passeada nos objetos.
Que objetos são esses que a gente tem aqui?
O ListBox,
é o lstUniver que é um ListBox,
está vendo?
Eu tenho lstDepart,
lista de departamentos, é um ListBox,
eu tenho aqui o Button, btnIniciar,
eu tenho o btnAdicionar.
E aí, cada um desses cara deve ter um conjunto de eventos tratáveis,
geralmente é o ButtonClick que é o evento mais standard.
Ali, por exemplo, ele tem o listUniverClick.
Esse não tem evento nenhum.
O que acontece hora que eu clico em iniciar?
Hora que eu clico em iniciar,
eu faço com que, no lstUniver, seus itens
sejam limpos, ou seja, limpo o ListBox.
Através do IteradorLUniversidades,
eu faço o iterador apontar para o início da lista,
e enquanto o iterador de universidades,
ah, aqui eu estou trabalhando, inclusive com a lista da STL, bem entendido.
Enquanto o iterador de universidades não estiver no fim,
estou trabalhando com o iterador da STL, então, eu estou fazendo ele apontar para o início,
enquanto o iterador não estiver no fim,
eu vou fazer algo
no tocante dessas iterações que estão ocorrendo dentro da lista de universidades, bem entendido.
Aqui eu criei uma classe string normal do C++.
Aqui eu estou fazendo o que?
Eu estou recuperando o conteúdo do cara apontado pelo iterador.
O que o iterador vai me trazer?
É uma Universidade.
Se o iterador é o iterador de lstUniver,
a hora que eu pego o conteúdo apontado pelo cara,
enquanto ponteiro de alto nível, por assim dizer,
eu ter acesso aqui à Universidade.
Então, aqui, eu estou retornando, na prática,
um ponteiro de Universidade, e aqui eu estou procurando o nome da Universidade que eu estou armazenando nessa string.
ListBox de Universidade não aceita string usual,
eu tenho que criar, por assim dizer, uma string gráfica.
isso é um eufemismo, uma string gráfica.
Essa string gráfica é inicializada com um vetor de caracteres.
De onde vem esse vetor de caracteres?
Da essência do meu aux.
Ou seja, dito de maneira grosseira, você transforma uma string textual em uma string gráfica,
e adiciona essa string gráfica, através do comando Add, nos itens de ListBox de Universidades,
e faço o iterador incrementar, daí eu faço isso para cada Universidade.
O que eu estou fazendo aqui na prática?
Eu estou percorrendo a lista de universidades, recuperando o nome de cada universidade e
populando o ListBox com esses nomes, basicamente é isso.
Legal, então esse aqui está explicado o evento do ButtonClick.