O que acontece hora que eu faço aqui, clico nesse cara aqui?
Bom, aqui ele vai fazer uma peripécia.
A única coisa que ele faz é limpar o ListBox dos departamentos.
Eu cliquei no ListBox de Universidade, ele vai limpar o ListBox de Departamento,
vai no ListBox de Universidade e vai recuperar o item
indexado, o número do item indexado,
e através do operador de itens,
eu consigo localizar o item que eu cliquei, eu recupero o item que eu cliquei,
que na prática é uma string gráfica, por assim dizer, eufemismo novamente.
Bom, aí eu faço o que?
Eu vou, agora que eu sei o nome da Universidade que me interessa,
eu vou, primeiro, navegar na lista de universidades.
Aqui na lista de universidades eu vou fazer o que?
Eu vou explicar, não vou explicar linha a linha, mas vou explicar no geral.
Eu tendo o nome da Universidade lá do meu ListBox,
eu percorro a lista de universidades
e vou localizar o objeto de Universidade que me interessa.
Se eu cliquei lá no meu ListBox,
sei lá eu, em Princeton,
ele recupera esse texto "Princeton"
e ele percorre a lista de universidades para localizar
se tem algum objeto
cujo o nome interno, o atributo nome, seja Princeton.
Aí ele vai localizar esse objeto Princeton e vai
me retornar um ponteiro, pUniv, que está aqui.
Aí eu faço o que aqui?
A partir desse momento, eu posso
navegar na lista geral de departamentos
e descobrir, através de uma série de astúcias,
quais os departamentos que estão relacionados com essa Universidade em questão.
Na verdade, sendo mais preciso,
o que acontece é que cada Universidade
já tem uma lista, um vector,
dos seus departamentos.
Então, eu navego na lista de Departamento da própria Universidade,
e uso essa lista de Departamento da própria Universidade,
utilizo os nomes dos departamentos para popular o respectivo ListBox de Departamento.
Simples assim.
O código está aí, basta um pouco de...
de estudo em cima dele que você entende rapidamente, à luz do que eu já expliquei.
E é isso que acontece nesse evento de clique no ListBox de Universidade.
Resumido,
ele pega o texto que eu cliquei, sei lá eu, Cambridge,
então eu tenho o texto Cambridge, vou na lista de universidades, acho se tem algum objeto
na lista de universidades cujo o atributo nome seja Cambridge.
Ah, achei um Cambridge lá.
Então, ele pega o objeto relativo à Universidade Cambridge,
ele navega no vetor, na listinha, de Departamento dessa Universidade,
e popula aqui o Lista de Departamento na direita.
E, por fim, tem aqui um ambiente ainda que é o Adicionar.
Se clicar aqui, ele vai chamar o que?
Opa, ele está chamando um outro form, o form frmAdicionaUniver.
Tem uma função limpaCampos,
tem uma função de receber o objeto_principal,
simples, esse form vai ter que conhecer o form principal para interagir com ele,
e tem um Show aqui.
Ata, mas onde está esse form principal?
Não sei, vamos ver aqui.
Opa, está aqui, form adiciona universidade.
Está ali.
E com é que o form principal conhece esse cara?
Também não sei, a gente vai verificar no código aqui.
Ele deve ter suas astúcias para tal.
Bom, basicamente,
vocês estão vendo que aqui no Form1
não tem nenhuma definição explícita desse form adiciona universidades,
mas tem aqui um extern.
Isso significa que o Form1 é externo
e o form de universidades também.
Ele tem aqui o extern.
E, se você olhar no código principal,
os dois formulário são criados.
Quando são criados com essa denominação externa, significa que um pode enxergar o outro e outro pode enxergar o um.
Então, eles tem essa relação via ambiente.
Legal.
Isso considerado,
se eu vou voltar para o ponto que é o botão
de adicionar,
ele está fazendo, chamando, como form, lá de AdicionaUniver.
Está aqui.
O que esse cara faz? Vamos olha o código dele no .h.
Ele tem o ponteiroPrincipal,
OK, que é recebido na chamada dele, a gente já viu isso,
na chamada dele, ele recebe
esse principal através do setPrincipal,
e também chama o limpaCampos.
Pelo nome que está em português, esse é um cara que foi programado,
de fato aqui o limpaCampos, que é o que está no .cpp.
O limpaCampos faz o que?
Vai limpar o EditBox, edUniver,
que, obviamente, é esse cara aqui, não tem muita opção.
Legal.
Então, hora que eu chamo,
hora que eu chamo ele aqui no adicionar,
ele limpa lá o ListBox,
faz o formulário conhecer o principal porque ele vai precisar disso para algum fim,
e faz o formulário se mostrar,
Show, faz o formulário aparecer.
Daí eu posso digitar aqui o que eu quero.
Por exemplo, USP, UEPG, UFPR, ITA, UNEB e por aí vai.
E aqui eu clico, então, para fazer minha ação.
Criei uma string gráfica, por assim dizer,
na verdade é uma AnsiString, bem entendido,
que permite se comunicar com objetos gráficos, isso que eu quero dizer.
Aqui eu recupero o texto que tem no EditBox,
esse Text me dá um cara compatível com o NomeUniv aqui.
Aí a partir desse cara,
eu quero adicionar no principal, olha que interessante,
lá no principal eu tenho uma função chamada CadUniversidade,
que, provavelmente, foi modificada um pouco para esse contexto dado,
O cadastra universidades recebe como parâmetro o nome do objeto Universidade que vai ser cadastrado.
Ser cadastrado significa que vai ser criado dinamicamente, vai ser jogado na lista de Universidade,
etc e tal, então, eu passo aqui o que está vindo graficamente,
e recupero a essência através da c_str, retorna a string
textual,
e permite eu ir na no objeto_principal e cadastrar,
daí eu fecho o próprio formulário.
Se eu der uma espiada no principal,
lá ele vai ter essa função de cadastra universidade que está aqui,
e se eu olhar o .cpp, aqui,
ele faz o que?
Vai criar Universidade em tempo de execução, vai passar o nome para ela,
e vai jogar essa Universidade no ListBox,
perdão, não é no ListBox, vai jogar na lista de universidades.
Daí, claro, hora que eu vou no formulário principal
e clico aqui,
ele vai limpar o ListBox,
repercorrer a lista de universidade e repopular o ListBox,
agora sim, com os nomes de Universidade.
Agora, como eu tenho uma Universidade nova cadastrada, ele vai também
popular o nome dessa Universidade no ListBox.
E essa aqui é a ideia.
Aqui eu fiz só alguns elementos iniciais,
do tipo Universidade e Departamento, para vocês entenderem a dinâmica.
Mas nada impede,
para quem está interessado em mexer mais nesse tipo de ambiente,
dá para usar a mesma lógica e resolver os outros elementos,
por exemplo, colocar mais um ListBox de Disciplina,
e hora que você clica no Departamento, ele aparece as disciplinas lá.
Daí claro, vocês podem, obviamente, fazer isso e melhorar a solução.
tirar os pecados ali de
atributos que estão público e deveriam estar privados,
melhorando o encapsulamento.
Vocês podem melhorar a coesão e desacoplamento melhorando a composição de listas,
conforme já discutido em aulas anteriores.
Aqui as listas, se vocês olharem, elas estão feitas direto com templates,
aliás perdão, aqui,
vocês sabem que a gente, na verdade, pode criar uma classe ListaUniversidade,
cuja a essência vai ser algo com list,
parametrizada com objeto de Universidade e por aí vai,
à luz do que já foi discutido nas aulas passadas.
Aqui o ponto era mostrar o RAD,
mostrar que você consegue fazer, hoje em dia, graficamente
soluções usando esse formulários, trabalhando com arrasto de componentes gráficos,
trabalhando orientado a eventos,
sem se preocupar com muitos detalhes da criação dos objetos gráficos.
Antigamente, na idade média por assim dizer,
não era assim que funcionava.
Você tinha que fazer graficamente, compor tudo no braço.
Você tinha que criar os formulários no braço,
você tinha que criar os objetos agregados do formulário, como botões,
ListBox, EditBox e etc, tudo no braço também.
Você tinha que programar os eventos no braço,
não era assim que você vem e clica e já sai programando,
você tinha que fazer tudo na unha.
Se vocês quiserem ver como era isso no passado, olhe o grupo de slides 17C,
lá ele mostra como era antes do ambiente RAD.
O fato é que no ambiente RAD,
as coisas são muito mais intuitivas, conforme vocês estão vendo.
Deixa eu fechar esse ambiente aqui.
Voltar aqui, rapidamente, para finalizar nossa aula,
nos nossos slides.
Se você olhar aqui, o que acontece nesses slides?
Tem aqui nosso slides de capa de abertura, para manter a elegância da coisa.
Aqui eu estou falando de programação visual, explicando tudo isso que eu já falei para vocês,
aí durante a exposição prática.
Falando um pouco mais do C++ Builder, contando que ele é um ambiente RAD, contando que ele tem vários componentes.
Aqui eu estou dizendo que eu posso criar um Form Application,
estou mostrando meu formulário,
contando que eu posso ver o código desse cara,
que eu posso adicionar botão,
está ali ele mostrando de maneira estruturada tudo isso que eu expliquei para vocês,
a execução.
Aqui eu trago o projeto da...
do sistema de universidades, desse recorte de Universidade e Departamento,
mostro a execução, mostro detalhes.
Basicamente, eu documentei ali o que a gente já mostrou.
Mostro, também, um exemplo com figuras geométricas,
explico as coisas e mais uns detalhes aí nos links.
E é basicamente isso, pessoal.
Se vocês olharem esse conjunto de slides 17, eu mostrei o 17B para vocês,
mostrando o C++ Builder.
Mas vocês tem ainda o 17A
que mostra o equivalente do C++ Builder no Microsoft Visual C++.
Lá tem uma série de peculiaridades que são explicadas nos slides 17A,
e adicionado o fato que, hoje em dia,
pelo menu do Microsoft Visual C++, você não consegue criar uma aplicação RAD para C++,
ao melhor meu saber, você tem que usar algumas estratégias.
Eles resolveram não disponibilizar RAD para C++,
resolveram disponibilizar RAD para C#,
por algum motivo.
Até as versões de 2015 do Visual C++,
ele tinha, na opção de menus, criar lá a aplicação forms para C++, tranquilamente.
Eles tiraram essa opção, eu não sei porque.
Até estranho isso porque era bastante útil para quem trabalha com C++.
Mas enfim.
Daí tem outras maneiras de criar, mas a maneira burocrática, inclusive,
eu explico lá no meu site, deixei um link no meu site explicando como faz essa maneira burocrática.
Uma vez que você venceu essa barreira burocrática, o ambiente volta a ser RAD normal.
Então aqui, eu estou falando do grupo de slides 17A.
17B eu apresentei para vocês aqui.
O 17C mostra MFC, Microsoft Foundation Class,
que é o ambiente com janelas gráficas
e com eventos, mas não é RAD,
é pré RAD, onde você fazia as coisa muito mais na unha.
E por fim, mais recentemente a gente adicionou um novo exemplo,
que é o 17C, aliás perdão, 17D,
D de dado,
que é outro ambiente, daí sim RAD, chamado QT.
O ambiente QT é um ambiente compatível,
não é compatível, é inspirado no C++ Builder,
acredito eu, inspirado no C++ Builder,
só que ele é um código, até onde me consta, aberto.
O QT de ambiente RAD é inspirado no C++ Builder,
e nos outros ambientes RAD também,
mas ele tem algumas peculiaridades.
Aparentemente, ele preserva um pouco mais essa questão do encapsulamento no tocante dos atributos dos objetos gráficos,
e ele também funciona para Windows e para Linux.
Enquanto, no melhor do meu saber, os ambientes da Microsoft
e do C++ Builder roda só para Windows.
no melhor do meu saber, mas as coisas evoluem também.
Bom então, enfim, longa história curta, lá no 17D você tem outro ambiente RAD,
que é o QT,
que funciona tanto para ambiente Windows quanto para ambiente Linux.
Por que eu adicionei esses exemplos com QT?
Porque eu sei que tem uma moçada que gosta de trabalhar com Linux.
Aí para vocês saberem que o QT pode trabalhar e funciona legalzinho.
para quem quiser se divertir em um outro sistema operacional, que é o Linux.
Pessoal, espero que tenham aproveitado a aula.
Bons estudos, até nosso próximo encontro.